œ]'"œ€5.5.1f1ţ˙˙˙˙˙Č0ĹňĂôL.`?^Ů0D7€˙˙˙˙€Ś€˛€ЀŚ€Ś€Ś€#Ś€+H€3˙˙˙˙€1€1€˙˙˙˙@ހ€ Q€j€ ™€< Ś€H H€Z˙˙˙˙ €1€1€˙˙˙˙@ހ€Q€j€ЀgŚ€Ś€Ś€#Ś€+v~ € €– €Ÿ €¨ €ą €ş €Ă €Ě €Ő €Ţ  €ç! €ń" €ű# €$ €% €&Ő€#˙˙˙˙'€1€1€˙˙˙˙(€ހ€)H€j€˙˙˙˙*€1€1€˙˙˙˙+@ހ€,Q€j€-™€*.ހ8/AssetMetaDataguiddata[0]data[1]data[2]data[3]pathNametimeCreatedoriginalChangesetoriginalNameoriginalParentHash128originalDigestbytes[0]bytes[1]bytes[2]bytes[3]bytes[4]bytes[5]bytes[6]bytes[7]bytes[8]bytes[9]bytes[10]bytes[11]bytes[12]bytes[13]bytes[14]bytes[15]labelsassetStoreReflicenseTypeď˙˙2ƒ…>”KËĽŁMźHîÁƒ#{7€˙˙˙˙€Ś€˛€Ő€ ހ%.€.†€Ä€ ހ%.€.H€Ť€˙˙˙˙€1€1€˙˙˙˙ @ހ€ Q€j€ Ő€7˙˙˙˙ Ŕ1€1€˙˙˙˙ €ހ€€j€˙˙˙˙€H€›€˙˙˙˙€1€1€˙˙˙˙@ހ€Q€j€°€ € ހ%.€.H€I˙˙˙˙€1€1€˙˙˙˙@ހ€Q€j€H€T˙˙˙˙€1€1€˙˙˙˙@ހ€Q€j€H€f˙˙˙˙€1€1€˙˙˙˙ @ހ€!Q€j€"ShaderImporterPPtrm_FileIDm_PathIDm_DefaultTexturesm_UserDatam_AssetBundleNamem_AssetBundleVariant0˙˙şěŻu`Aă•\á|^FďYŹü 7€˙˙˙˙€Ś€˛€Ő€ ހ.€&†€Ä€ ހ.€&H€Ť€˙˙˙˙€1€1€˙˙˙˙ @ހ€ Q€j€ /@˙˙˙˙ €Mb˙˙˙˙ €Ő€m˙˙˙˙€1€1€˙˙˙˙€ހ€uj€˙˙˙˙€H€Ť€˙˙˙˙€1€1€˙˙˙˙@ހ€Q€j€H€ˆ˙˙˙˙€1€1€˙˙˙˙@ހ€Q€j€Ő€–˙˙˙˙€1€1€˙˙˙˙€ހ€H€j€˙˙˙˙€ 1€1€˙˙˙˙@ ހ€ Q€j€ ހ€!Ś€Ł"Ą€Ť#Ą€š$Ą€Ç%Ą€Ő&ăý˙˙˙˙'€H€ ˙˙˙˙(€1€1€˙˙˙˙)@ ހ€* Q€j€+ހ,Ő€!˙˙˙˙-€1€1€˙˙˙˙.€ހ€/.j€˙˙˙˙0€Ő€B˙˙˙˙1€1€1€˙˙˙˙2€ހ€3Kj€˙˙˙˙4€ń€Z˙˙˙˙5€ 1€1€˙˙˙˙6€ ހ€7 €j€˙˙˙˙8€ H€›€˙˙˙˙9€ 1€1€˙˙˙˙:@ ހ€; Q€j€< ހ €=ހ€>h~˙˙˙˙?€ H€Ť€˙˙˙˙@€ 1€1€˙˙˙˙A@ ހ€B Q€j€C †Ł˙˙˙˙D€ ŹÇ˙˙˙˙E€ Ą€ĐF Š€Ô˙˙˙˙G€ H€Ô˙˙˙˙H€ 1€1€˙˙˙˙I@ހ€JQ€j€K ŹŮ˙˙˙˙L€ Ą€ĐM Š€Ô˙˙˙˙N€ H€Ô˙˙˙˙O€ 1€1€˙˙˙˙P@ހ€QQ€j€R Źă˙˙˙˙S€ Ą€ĐT Š€Ô˙˙˙˙U€ H€Ô˙˙˙˙V€ 1€1€˙˙˙˙W@ހ€XQ€j€Y Źń˙˙˙˙Z€ Ą€Đ[ Š€Ô˙˙˙˙\€ H€Ô˙˙˙˙]€ 1€1€˙˙˙˙^@ހ€_Q€j€` Ź˙˙˙˙a€ Ą€Đb Š€Ô˙˙˙˙c€ H€Ô˙˙˙˙d€ 1€1€˙˙˙˙e@ހ€fQ€j€g Ź˙˙˙˙h€ Ą€Đi Š€Ô˙˙˙˙j€ H€Ô˙˙˙˙k€ 1€1€˙˙˙˙l@ހ€mQ€j€n Ź˙˙˙˙o€ Ą€Đp Š€Ô˙˙˙˙q€ H€Ô˙˙˙˙r€ 1€1€˙˙˙˙s@ހ€tQ€j€u †˙˙˙˙v€ ŹÇ˙˙˙˙w€ Ą€Đx Š€Ô˙˙˙˙y€ H€Ô˙˙˙˙z€ 1€1€˙˙˙˙{@ހ€|Q€j€} ŹŮ˙˙˙˙~€ Ą€Đ Š€Ô˙˙˙˙€€ H€Ô˙˙˙˙€ 1€1€˙˙˙˙‚@ހ€ƒQ€j€„ Źă˙˙˙˙…€ Ą€Đ† Š€Ô˙˙˙˙‡€ H€Ô˙˙˙˙ˆ€ 1€1€˙˙˙˙‰@ހ€ŠQ€j€‹ Źń˙˙˙˙Œ€ Ą€Đ Š€Ô˙˙˙˙Ž€ H€Ô˙˙˙˙€ 1€1€˙˙˙˙@ހ€‘Q€j€’ Ź˙˙˙˙“€ Ą€Đ” Š€Ô˙˙˙˙•€ H€Ô˙˙˙˙–€ 1€1€˙˙˙˙—@ހ€˜Q€j€™ Ź˙˙˙˙š€ Ą€Đ› Š€Ô˙˙˙˙œ€ H€Ô˙˙˙˙€ 1€1€˙˙˙˙ž@ހ€ŸQ€j€  Ź˙˙˙˙Ą€ Ą€Đ˘ Š€Ô˙˙˙˙Ł€ H€Ô˙˙˙˙¤€ 1€1€˙˙˙˙Ľ@ހ€ŚQ€j€§ †&˙˙˙˙¨€ ŹÇ˙˙˙˙Š€ Ą€ĐŞ Š€Ô˙˙˙˙Ť€ H€Ô˙˙˙˙Ź€ 1€1€˙˙˙˙­@ހ€ŽQ€j€Ż ŹŮ˙˙˙˙°€ Ą€Đą Š€Ô˙˙˙˙˛€ H€Ô˙˙˙˙ł€ 1€1€˙˙˙˙´@ހ€ľQ€j€ś Źă˙˙˙˙ˇ€ Ą€Đ¸ Š€Ô˙˙˙˙š€ H€Ô˙˙˙˙ş€ 1€1€˙˙˙˙ť@ހ€źQ€j€˝ Źń˙˙˙˙ž€ Ą€Đż Š€Ô˙˙˙˙Ŕ€ H€Ô˙˙˙˙Á€ 1€1€˙˙˙˙Â@ހ€ĂQ€j€Ä Ź˙˙˙˙ŀ Ą€ĐĆ Š€Ô˙˙˙˙ǀ H€Ô˙˙˙˙Ȁ 1€1€˙˙˙˙É@ހ€ĘQ€j€Ë Ź˙˙˙˙̀ Ą€ĐÍ Š€Ô˙˙˙˙΀ H€Ô˙˙˙˙π 1€1€˙˙˙˙Đ@ހ€ŃQ€j€Ň Ź˙˙˙˙Ӏ Ą€ĐÔ Š€Ô˙˙˙˙Հ H€Ô˙˙˙˙ր 1€1€˙˙˙˙×@ހ€ŘQ€j€Ů †/˙˙˙˙ڀ ŹÇ˙˙˙˙ۀ Ą€ĐÜ Š€Ô˙˙˙˙݀ H€Ô˙˙˙˙ހ 1€1€˙˙˙˙ß@ހ€ŕQ€j€á ŹŮ˙˙˙˙†Ą€Đă Š€Ô˙˙˙˙ä€ H€Ô˙˙˙˙ĺ€ 1€1€˙˙˙˙ć@ހ€çQ€j€č Źă˙˙˙˙é€ Ą€Đę Š€Ô˙˙˙˙ë€ H€Ô˙˙˙˙ě€ 1€1€˙˙˙˙í@ހ€îQ€j€ď Źń˙˙˙˙đ€ Ą€Đń Š€Ô˙˙˙˙ň€ H€Ô˙˙˙˙ó€ 1€1€˙˙˙˙ô@ހ€őQ€j€ö Ź˙˙˙˙÷€ Ą€Đř Š€Ô˙˙˙˙ů€ H€Ô˙˙˙˙ú€ 1€1€˙˙˙˙ű@ހ€üQ€j€ý Ź˙˙˙˙ţ€ Ą€Đ˙ Š€Ô˙˙˙˙€ H€Ô˙˙˙˙€ 1€1€˙˙˙˙@ހ€Q€j€ Ź˙˙˙˙€ Ą€Đ Š€Ô˙˙˙˙€ H€Ô˙˙˙˙€ 1€1€˙˙˙˙ @ހ€ Q€j€  †8˙˙˙˙ € ŹÇ˙˙˙˙ € Ą€Đ Š€Ô˙˙˙˙€ H€Ô˙˙˙˙€ 1€1€˙˙˙˙@ހ€Q€j€ ŹŮ˙˙˙˙€ Ą€Đ Š€Ô˙˙˙˙€ H€Ô˙˙˙˙€ 1€1€˙˙˙˙@ހ€Q€j€ Źă˙˙˙˙€ Ą€Đ Š€Ô˙˙˙˙€ H€Ô˙˙˙˙€ 1€1€˙˙˙˙@ހ€ Q€j€! Źń˙˙˙˙"€ Ą€Đ# Š€Ô˙˙˙˙$€ H€Ô˙˙˙˙%€ 1€1€˙˙˙˙&@ހ€'Q€j€( Ź˙˙˙˙)€ Ą€Đ* Š€Ô˙˙˙˙+€ H€Ô˙˙˙˙,€ 1€1€˙˙˙˙-@ހ€.Q€j€/ Ź˙˙˙˙0€ Ą€Đ1 Š€Ô˙˙˙˙2€ H€Ô˙˙˙˙3€ 1€1€˙˙˙˙4@ހ€5Q€j€6 Ź˙˙˙˙7€ Ą€Đ8 Š€Ô˙˙˙˙9€ H€Ô˙˙˙˙:€ 1€1€˙˙˙˙;@ހ€<Q€j€= †A˙˙˙˙>€ ŹÇ˙˙˙˙?€ Ą€Đ@ Š€Ô˙˙˙˙A€ H€Ô˙˙˙˙B€ 1€1€˙˙˙˙C@ހ€DQ€j€E ŹŮ˙˙˙˙F€ Ą€ĐG Š€Ô˙˙˙˙H€ H€Ô˙˙˙˙I€ 1€1€˙˙˙˙J@ހ€KQ€j€L Źă˙˙˙˙M€ Ą€ĐN Š€Ô˙˙˙˙O€ H€Ô˙˙˙˙P€ 1€1€˙˙˙˙Q@ހ€RQ€j€S Źń˙˙˙˙T€ Ą€ĐU Š€Ô˙˙˙˙V€ H€Ô˙˙˙˙W€ 1€1€˙˙˙˙X@ހ€YQ€j€Z Ź˙˙˙˙[€ Ą€Đ\ Š€Ô˙˙˙˙]€ H€Ô˙˙˙˙^€ 1€1€˙˙˙˙_@ހ€`Q€j€a Ź˙˙˙˙b€ Ą€Đc Š€Ô˙˙˙˙d€ H€Ô˙˙˙˙e€ 1€1€˙˙˙˙f@ހ€gQ€j€h Ź˙˙˙˙i€ Ą€Đj Š€Ô˙˙˙˙k€ H€Ô˙˙˙˙l€ 1€1€˙˙˙˙m@ހ€nQ€j€o †J˙˙˙˙p€ ŹÇ˙˙˙˙q€ Ą€Đr Š€Ô˙˙˙˙s€ H€Ô˙˙˙˙t€ 1€1€˙˙˙˙u@ހ€vQ€j€w ŹŮ˙˙˙˙x€ Ą€Đy Š€Ô˙˙˙˙z€ H€Ô˙˙˙˙{€ 1€1€˙˙˙˙|@ހ€}Q€j€~ Źă˙˙˙˙€ Ą€Đ€ Š€Ô˙˙˙˙€ H€Ô˙˙˙˙‚€ 1€1€˙˙˙˙ƒ@ހ€„Q€j€… Źń˙˙˙˙†€ Ą€Đ‡ Š€Ô˙˙˙˙ˆ€ H€Ô˙˙˙˙‰€ 1€1€˙˙˙˙Š@ހ€‹Q€j€Œ Ź˙˙˙˙€ Ą€ĐŽ Š€Ô˙˙˙˙€ H€Ô˙˙˙˙€ 1€1€˙˙˙˙‘@ހ€’Q€j€“ Ź˙˙˙˙”€ Ą€Đ• Š€Ô˙˙˙˙–€ H€Ô˙˙˙˙—€ 1€1€˙˙˙˙˜@ހ€™Q€j€š Ź˙˙˙˙›€ Ą€Đœ Š€Ô˙˙˙˙€ H€Ô˙˙˙˙ž€ 1€1€˙˙˙˙Ÿ@ހ€ Q€j€Ą †S˙˙˙˙˘€ ŹÇ˙˙˙˙Ł€ Ą€Đ¤ Š€Ô˙˙˙˙Ľ€ H€Ô˙˙˙˙Ś€ 1€1€˙˙˙˙§@ހ€¨Q€j€Š ŹŮ˙˙˙˙Ş€ Ą€ĐŤ Š€Ô˙˙˙˙Ź€ H€Ô˙˙˙˙­€ 1€1€˙˙˙˙Ž@ހ€ŻQ€j€° Źă˙˙˙˙ą€ Ą€Đ˛ Š€Ô˙˙˙˙ł€ H€Ô˙˙˙˙´€ 1€1€˙˙˙˙ľ@ހ€śQ€j€ˇ Źń˙˙˙˙¸€ Ą€Đš Š€Ô˙˙˙˙ş€ H€Ô˙˙˙˙ť€ 1€1€˙˙˙˙ź@ހ€˝Q€j€ž Ź˙˙˙˙ż€ Ą€ĐŔ Š€Ô˙˙˙˙Á€ H€Ô˙˙˙˙€ 1€1€˙˙˙˙Ă@ހ€ÄQ€j€Ĺ Ź˙˙˙˙Ć€ Ą€ĐÇ Š€Ô˙˙˙˙Č€ H€Ô˙˙˙˙É€ 1€1€˙˙˙˙Ę@ހ€ËQ€j€Ě Ź˙˙˙˙Í€ Ą€ĐÎ Š€Ô˙˙˙˙Ď€ H€Ô˙˙˙˙Đ€ 1€1€˙˙˙˙Ń@ހ€ŇQ€j€Ó L€\Ô@ Źl˙˙˙˙Ő€ Ą€ĐÖ Š€Ô˙˙˙˙×€ H€Ô˙˙˙˙Ř€ 1€1€˙˙˙˙Ů@ ހ€Ú Q€j€Ű Źr˙˙˙˙Ü€ Ą€ĐÝ Š€Ô˙˙˙˙Ţ€ H€Ô˙˙˙˙߀ 1€1€˙˙˙˙ŕ@ ހ€á Q€j€â Źy˙˙˙˙〠Ą€Đä Š€Ô˙˙˙˙ĺ€ H€Ô˙˙˙˙ć€ 1€1€˙˙˙˙ç@ ހ€č Q€j€é Ź˙˙˙˙ę€ Ą€Đë Š€Ô˙˙˙˙ě€ H€Ô˙˙˙˙í€ 1€1€˙˙˙˙î@ ހ€ď Q€j€đ ŹŽ˙˙˙˙ń€ Ą€Đň Š€Ô˙˙˙˙ó€ H€Ô˙˙˙˙ô€ 1€1€˙˙˙˙ő@ ހ€ö Q€j€÷ Źš˙˙˙˙ř€ Ą€Đů Š€Ô˙˙˙˙ú€ H€Ô˙˙˙˙ű€ 1€1€˙˙˙˙ü@ ހ€ý Q€j€ţ Śş˙˙˙˙˙€ ŹÄ˙˙˙˙€ Ą€Đ Š€Ô˙˙˙˙€ H€Ô˙˙˙˙€ 1€1€˙˙˙˙@ހ€Q€j€ ŹÉ˙˙˙˙€ Ą€Đ Š€Ô˙˙˙˙ € H€Ô˙˙˙˙ € 1€1€˙˙˙˙ @ހ€ Q€j€  ŹÎ˙˙˙˙€ Ą€Đ Š€Ô˙˙˙˙€ H€Ô˙˙˙˙€ 1€1€˙˙˙˙@ހ€Q€j€ ŹÔ˙˙˙˙€ Ą€Đ Š€Ô˙˙˙˙€ H€Ô˙˙˙˙€ 1€1€˙˙˙˙@ހ€Q€j€ ŚŮ˙˙˙˙€ ŹÄ˙˙˙˙€ Ą€Đ Š€Ô˙˙˙˙€ H€Ô˙˙˙˙ € 1€1€˙˙˙˙!@ހ€"Q€j€# ŹÉ˙˙˙˙$€ Ą€Đ% Š€Ô˙˙˙˙&€ H€Ô˙˙˙˙'€ 1€1€˙˙˙˙(@ހ€)Q€j€* ŹÎ˙˙˙˙+€ Ą€Đ, Š€Ô˙˙˙˙-€ H€Ô˙˙˙˙.€ 1€1€˙˙˙˙/@ހ€0Q€j€1 ŹÔ˙˙˙˙2€ Ą€Đ3 Š€Ô˙˙˙˙4€ H€Ô˙˙˙˙5€ 1€1€˙˙˙˙6@ހ€7Q€j€8 Śč˙˙˙˙9€ ŹÄ˙˙˙˙:€ Ą€Đ; Š€Ô˙˙˙˙<€ H€Ô˙˙˙˙=€ 1€1€˙˙˙˙>@ހ€?Q€j€@ ŹÉ˙˙˙˙A€ Ą€ĐB Š€Ô˙˙˙˙C€ H€Ô˙˙˙˙D€ 1€1€˙˙˙˙E@ހ€FQ€j€G ŹÎ˙˙˙˙H€ Ą€ĐI Š€Ô˙˙˙˙J€ H€Ô˙˙˙˙K€ 1€1€˙˙˙˙L@ހ€MQ€j€N ŹÔ˙˙˙˙O€ Ą€ĐP Š€Ô˙˙˙˙Q€ H€Ô˙˙˙˙R€ 1€1€˙˙˙˙S@ހ€TQ€j€U Źö˙˙˙˙V€ Ą€ĐW Š€Ô˙˙˙˙X€ H€Ô˙˙˙˙Y€ 1€1€˙˙˙˙Z@ ހ€[ Q€j€\ Ź˙˙˙˙]€ Ą€Đ^ Š€Ô˙˙˙˙_€ H€Ô˙˙˙˙`€ 1€1€˙˙˙˙a@ ހ€b Q€j€c Ź˙˙˙˙d€ Ą€Đe Š€Ô˙˙˙˙f€ H€Ô˙˙˙˙g€ 1€1€˙˙˙˙h@ ހ€i Q€j€j Ź"˙˙˙˙k€ Ą€Đl Š€Ô˙˙˙˙m€ H€Ô˙˙˙˙n€ 1€1€˙˙˙˙o@ ހ€p Q€j€q Ź+˙˙˙˙r€ Ą€Đs Š€Ô˙˙˙˙t€ H€Ô˙˙˙˙u€ 1€1€˙˙˙˙v@ ހ€w Q€j€x Ź2˙˙˙˙y€ Ą€Đz Š€Ô˙˙˙˙{€ H€Ô˙˙˙˙|€ 1€1€˙˙˙˙}@ ހ€~ Q€j€ =Y˙˙˙˙€€ Źb˙˙˙˙€ Ą€Đ‚ Š€Ô˙˙˙˙ƒ€ H€Ô˙˙˙˙„€ 1€1€˙˙˙˙…@ހ€†Q€j€‡ Źd˙˙˙˙ˆ€ Ą€Đ‰ Š€Ô˙˙˙˙Š€ H€Ô˙˙˙˙‹€ 1€1€˙˙˙˙Œ@ހ€Q€j€Ž Źf˙˙˙˙€ Ą€Đ Š€Ô˙˙˙˙‘€ H€Ô˙˙˙˙’€ 1€1€˙˙˙˙“@ހ€”Q€j€• Źh˙˙˙˙–€ Ą€Đ— Š€Ô˙˙˙˙˜€ H€Ô˙˙˙˙™€ 1€1€˙˙˙˙š@ހ€›Q€j€œ Š€Ô˙˙˙˙€ H€Ô˙˙˙˙ž€ 1€1€˙˙˙˙Ÿ@ ހ€  Q€j€Ą ހj˘ ހrŁ ˙˙˙˙¤€ ń€—˙˙˙˙Ľ€ 1€1€˙˙˙˙Ś€ ހ€§ €j€˙˙˙˙¨€ H€›€˙˙˙˙Š€1€1€˙˙˙˙Ş@ހ€ŤQ€j€Ź H€ €˙˙˙˙­€1€1€˙˙˙˙Ž@ހ€ŻQ€j€° ހœą L€˘˛@Ś€ŤłšË˙˙˙˙´€ Ő€Ö˙˙˙˙ľ€ 1€1€˙˙˙˙ś€ ހ€ˇ äj€˙˙˙˙¸€ Ś€ůš ˙˙˙˙ş€ Ő€˙˙˙˙ť@1€1€˙˙˙˙źހ€˝#j€ž5€5ż5€<Ŕ Ś€CÁ Ő€O˙˙˙˙ 1€1€˙˙˙˙Ăހ€Ä‹€j€Ĺ 5€`Ć 5€uÇ@ Ő€†˙˙˙˙Č€ 1€1€˙˙˙˙É€ހ€Ę•j€Ë€ހĽĚހƒ€ÍހąÎ5€€Ď5€˝Đ@ Ő€Ă˙˙˙˙Ń€ 1€1€˙˙˙˙Ň€ހ€ÓŇj€Ô€ހĽŐހƒ€Öހą×5€€Ř5€âŮ@ Ő€í˙˙˙˙Ú€ 1€1€˙˙˙˙Ű€ހ€Üýj€ Ý€ހĽŢހƒ€ßހŕ5€˝á@ Ő€˙˙˙˙â 1€1€˙˙˙˙ăހ€ä,j€ĺހĽćހƒ€ç Ő€:˙˙˙˙č€ 1€1€˙˙˙˙é€ހ€ęLj€˙˙˙˙ë€ހĽěŐ€Ă˙˙˙˙í€1€1€˙˙˙˙î€ހ€ďŇj€đ€ހĽńހƒ€ňހąó5€€ô5€âő@Ő€†˙˙˙˙ö€1€1€˙˙˙˙÷€ހ€ř•j€ů€ހĽúހƒ€űހąü5€€ý5€˝ţ@ހ[˙ Ő€b˙˙˙˙ 1€1€˙˙˙˙ހ€,j€ހĽހƒ€ Ő€{˙˙˙˙ 1€1€˙˙˙˙ހ€‡j€ ހĽ ހƒ€ ހ” š¤˙˙˙˙ € Ő€Ö˙˙˙˙€ 1€1€˙˙˙˙€ ހ€ äj€˙˙˙˙€ Ś€ů ˙˙˙˙€ Ő€˙˙˙˙@1€1€˙˙˙˙ހ€#j€5€55€< Ś€C Ő€O˙˙˙˙ 1€1€˙˙˙˙ހ€‹€j€ 5€` 5€u @ Ő€†˙˙˙˙!€ 1€1€˙˙˙˙"€ހ€#•j€$€ހĽ%ހƒ€&ހą'5€€(5€˝)@ Ő€Ă˙˙˙˙*€ 1€1€˙˙˙˙+€ހ€,Ňj€-€ހĽ.ހƒ€/ހą05€€15€â2@ Ő€í˙˙˙˙3€ 1€1€˙˙˙˙4€ހ€5ýj€ 6€ހĽ7ހƒ€8ހ95€˝:@ Ő€˙˙˙˙; 1€1€˙˙˙˙<ހ€=,j€>ހĽ?ހƒ€@ Ő€:˙˙˙˙A€ 1€1€˙˙˙˙B€ހ€CLj€˙˙˙˙D€ހĽEŐ€Ă˙˙˙˙F€1€1€˙˙˙˙G€ހ€HŇj€I€ހĽJހƒ€KހąL5€€M5€âN@Ő€†˙˙˙˙O€1€1€˙˙˙˙P€ހ€Q•j€R€ހĽSހƒ€TހąU5€€V5€˝W@ހ[X Ő€b˙˙˙˙Y 1€1€˙˙˙˙Zހ€[,j€\ހĽ]ހƒ€^ Ő€{˙˙˙˙_ 1€1€˙˙˙˙`ހ€a‡j€ bހĽcހƒ€dހ”ešą˙˙˙˙f€ Ő€Ö˙˙˙˙g€ 1€1€˙˙˙˙h€ ހ€i äj€˙˙˙˙j€ Ś€ůk ˙˙˙˙l€ Ő€˙˙˙˙m@1€1€˙˙˙˙nހ€o#j€p5€5q5€<r Ś€Cs Ő€O˙˙˙˙t 1€1€˙˙˙˙uހ€v‹€j€w 5€`x 5€uy@ Ő€†˙˙˙˙z€ 1€1€˙˙˙˙{€ހ€|•j€}€ހĽ~ހƒ€ހą€5€€5€˝‚@ Ő€Ă˙˙˙˙ƒ€ 1€1€˙˙˙˙„€ހ€…Ňj€†€ހĽ‡ހƒ€ˆހą‰5€€Š5€â‹@ Ő€í˙˙˙˙Œ€ 1€1€˙˙˙˙€ހ€Žýj€ €ހĽހƒ€‘ހ’5€˝“@ Ő€˙˙˙˙” 1€1€˙˙˙˙•ހ€–,j€—ހĽ˜ހƒ€™ Ő€:˙˙˙˙š€ 1€1€˙˙˙˙›€ހ€œLj€˙˙˙˙€ހĽžŐ€Ă˙˙˙˙Ÿ€1€1€˙˙˙˙ €ހ€ĄŇj€˘€ހĽŁހƒ€¤ހąĽ5€€Ś5€â§@Ő€†˙˙˙˙¨€1€1€˙˙˙˙Š€ހ€Ş•j€Ť€ހĽŹހƒ€­ހąŽ5€€Ż5€˝°@ހ[ą Ő€b˙˙˙˙˛ 1€1€˙˙˙˙łހ€´,j€ľހĽśހƒ€ˇ Ő€{˙˙˙˙¸ 1€1€˙˙˙˙šހ€ş‡j€ ťހĽźހƒ€˝ހ”žšž˙˙˙˙ż€ Ő€Ö˙˙˙˙Ŕ€ 1€1€˙˙˙˙Á€ ހ€Â äj€˙˙˙˙Ă€ Ś€ůÄ ˙˙˙˙Ĺ€ Ő€˙˙˙˙Ć@1€1€˙˙˙˙Çހ€Č#j€É5€5Ę5€<Ë Ś€CĚ Ő€O˙˙˙˙Í 1€1€˙˙˙˙Îހ€Ď‹€j€Đ 5€`Ń 5€uŇ@ Ő€†˙˙˙˙Ó€ 1€1€˙˙˙˙Ô€ހ€Ő•j€Ö€ހĽ×ހƒ€ŘހąŮ5€€Ú5€˝Ű@ Ő€Ă˙˙˙˙Ü€ 1€1€˙˙˙˙Ý€ހ€ŢŇj€ß€ހĽŕހƒ€áހąâ5€€ă5€âä@ Ő€í˙˙˙˙ĺ€ 1€1€˙˙˙˙ć€ހ€çýj€ č€ހĽéހƒ€ęހë5€˝ě@ Ő€˙˙˙˙í 1€1€˙˙˙˙îހ€ď,j€đހĽńހƒ€ň Ő€:˙˙˙˙ó€ 1€1€˙˙˙˙ô€ހ€őLj€˙˙˙˙ö€ހĽ÷Ő€Ă˙˙˙˙ř€1€1€˙˙˙˙ů€ހ€úŇj€ű€ހĽüހƒ€ýހąţ5€€˙5€â@Ő€†˙˙˙˙€1€1€˙˙˙˙€ހ€•j€€ހĽހƒ€ހą5€€5€˝ @ހ[  Ő€b˙˙˙˙  1€1€˙˙˙˙ ހ€ ,j€ހĽހƒ€ Ő€{˙˙˙˙ 1€1€˙˙˙˙ހ€‡j€ ހĽހƒ€ހ”šÇ˙˙˙˙€ Ő€Ö˙˙˙˙€ 1€1€˙˙˙˙€ ހ€ äj€˙˙˙˙€ Ś€ů ˙˙˙˙€ Ő€˙˙˙˙@1€1€˙˙˙˙ ހ€!#j€"5€5#5€<$ Ś€C% Ő€O˙˙˙˙& 1€1€˙˙˙˙'ހ€(‹€j€) 5€`* 5€u+@ Ő€†˙˙˙˙,€ 1€1€˙˙˙˙-€ހ€.•j€/€ހĽ0ހƒ€1ހą25€€35€˝4@ Ő€Ă˙˙˙˙5€ 1€1€˙˙˙˙6€ހ€7Ňj€8€ހĽ9ހƒ€:ހą;5€€<5€â=@ Ő€í˙˙˙˙>€ 1€1€˙˙˙˙?€ހ€@ýj€ A€ހĽBހƒ€CހD5€˝E@ Ő€˙˙˙˙F 1€1€˙˙˙˙Gހ€H,j€IހĽJހƒ€K Ő€:˙˙˙˙L€ 1€1€˙˙˙˙M€ހ€NLj€˙˙˙˙O€ހĽPŐ€Ă˙˙˙˙Q€1€1€˙˙˙˙R€ހ€SŇj€T€ހĽUހƒ€VހąW5€€X5€âY@Ő€†˙˙˙˙Z€1€1€˙˙˙˙[€ހ€\•j€]€ހĽ^ހƒ€_ހą`5€€a5€˝b@ހ[c Ő€b˙˙˙˙d 1€1€˙˙˙˙eހ€f,j€gހĽhހƒ€i Ő€{˙˙˙˙j 1€1€˙˙˙˙kހ€l‡j€ mހĽnހƒ€oހ”pL€Ňq@H€é˙˙˙˙r€ 1€1€˙˙˙˙s@ ހ€t Q€j€uH€Ť€˙˙˙˙v€ 1€1€˙˙˙˙w@ ހ€x Q€j€yH€ó˙˙˙˙z€ 1€1€˙˙˙˙{@ ހ€| Q€j€}˙˙˙˙~€ ń€—˙˙˙˙€ 1€1€˙˙˙˙€€ ހ€ €j€˙˙˙˙‚€ H€›€˙˙˙˙ƒ€ 1€1€˙˙˙˙„@ހ€…Q€j€† H€ €˙˙˙˙‡€ 1€1€˙˙˙˙ˆ@ހ€‰Q€j€Š˙˙˙˙‹€ń€—˙˙˙˙Œ€1€1€˙˙˙˙€ހ€Ž€j€˙˙˙˙€ H€›€˙˙˙˙€ 1€1€˙˙˙˙‘@ ހ€’ Q€j€“ H€ €˙˙˙˙”€ 1€1€˙˙˙˙•@ ހ€– Q€j€—ހœ˜H€Ť€˙˙˙˙™€1€1€˙˙˙˙š@ހ€›Q€j€œH€˙˙˙˙€1€1€˙˙˙˙ž@ހ€ŸQ€j€ H€˙˙˙˙Ą€1€1€˙˙˙˙˘@ހ€ŁQ€j€¤Ő€#˙˙˙˙Ľ€1€1€˙˙˙˙Ś€ހ€§2j€˙˙˙˙¨€H€M˙˙˙˙Š€1€1€˙˙˙˙Ş@ހ€ŤQ€j€ŹH€R˙˙˙˙­€1€1€˙˙˙˙Ž@ހ€ŻQ€j€°L€Uą@Ő€r˙˙˙˙˛1€1€˙˙˙˙łހ€´Ś€j€ľŐ€|˙˙˙˙ś1€1€˙˙˙˙ˇހ€¸Ś€j€šŐ€„˙˙˙˙ş1€1€˙˙˙˙ťހ€źŚ€j€˝Ő€–˙˙˙˙ž1€1€˙˙˙˙żހ€ŔŚ€j€ÁŐ€Ş˙˙˙˙€1€1€˙˙˙˙Ă@ހ€Ä €j€ĹŐ€#˙˙˙˙Ć1€1€˙˙˙˙Çހ€Čšj€ ÉހĘ.€&ËL€ĆĚ@ń€Ö˙˙˙˙Í€1€1€˙˙˙˙΀ހ€Ď€j€˙˙˙˙Đ€H€›€˙˙˙˙Ń€1€1€˙˙˙˙Ň@ހ€ÓQ€j€Ô°€ € ŐހÖ.€&×čţ˙˙˙˙Ř€ń€ ˙˙˙˙Ů€1€1€˙˙˙˙Ú€ހ€Ű€j€˙˙˙˙Ü€ހ›€Ý €˙˙˙˙Ţ€H€%˙˙˙˙߀1€1€˙˙˙˙ŕ@ހ€áQ€j€âH€,˙˙˙˙ă€1€1€˙˙˙˙ä@ހ€ĺQ€j€ćŚ€8猀Gčހb錀nęz‚ë €‘ě €ší €Łî €Źď €ľđ €žń €Çň €Đó €Ůô €âő €ëö €ő÷ €˙ř € ů €ú €űL€'ü@ހ3ýŐ€>˙˙˙˙ţ€1€1€˙˙˙˙˙€ހ€Ő€j€˙˙˙˙€ 1€1€˙˙˙˙€ ހ€ H€j€˙˙˙˙€ 1€1€˙˙˙˙@ ހ€ Q€j€Ő€N˙˙˙˙€1€1€˙˙˙˙ €ހ€ Ő€j€˙˙˙˙ € 1€1€˙˙˙˙ € ހ€  H€j€˙˙˙˙€ 1€1€˙˙˙˙@ ހ€ Q€j€Ő€^˙˙˙˙€1€1€˙˙˙˙€ހ€Ő€j€˙˙˙˙€ 1€1€˙˙˙˙€ ހ€ H€j€˙˙˙˙€ 1€1€˙˙˙˙@ ހ€ Q€j€Ő€n˙˙˙˙€1€1€˙˙˙˙€ހ€Ő€j€˙˙˙˙€ 1€1€˙˙˙˙ € ހ€! H€j€˙˙˙˙"€ 1€1€˙˙˙˙#@ ހ€$ Q€j€%Ő€~˙˙˙˙&€1€1€˙˙˙˙'€ހ€(Ő€j€˙˙˙˙)€ 1€1€˙˙˙˙*€ ހ€+ H€j€˙˙˙˙,€ 1€1€˙˙˙˙-@ ހ€. Q€j€/Ő€Ž˙˙˙˙0€1€1€˙˙˙˙1€ހ€2Ő€j€˙˙˙˙3€ 1€1€˙˙˙˙4€ ހ€5 H€j€˙˙˙˙6€ 1€1€˙˙˙˙7@ ހ€8 Q€j€9Ő€ž˙˙˙˙:€1€1€˙˙˙˙;€ހ€<Ő€j€˙˙˙˙=€ 1€1€˙˙˙˙>€ ހ€? H€j€˙˙˙˙@€ 1€1€˙˙˙˙A@ ހ€B Q€j€CŐ€ą˙˙˙˙D€1€1€˙˙˙˙E€ހ€FŐ€j€˙˙˙˙G€ 1€1€˙˙˙˙H€ ހ€I H€j€˙˙˙˙J€ 1€1€˙˙˙˙K@ ހ€L Q€j€MŐ€Ä˙˙˙˙N€1€1€˙˙˙˙O€ހ€PŐ€j€˙˙˙˙Q€ 1€1€˙˙˙˙R€ ހ€S H€j€˙˙˙˙T€ 1€1€˙˙˙˙U@ ހ€V Q€j€WŐ€×˙˙˙˙X€1€1€˙˙˙˙Y€ހ€ZŐ€j€˙˙˙˙[€ 1€1€˙˙˙˙\€ ހ€] H€j€˙˙˙˙^€ 1€1€˙˙˙˙_@ ހ€` Q€j€aŐ€ę˙˙˙˙b€1€1€˙˙˙˙c€ހ€dŐ€j€˙˙˙˙e€ 1€1€˙˙˙˙f€ ހ€g H€j€˙˙˙˙h€ 1€1€˙˙˙˙i@ ހ€j Q€j€kŐ€ý˙˙˙˙l€1€1€˙˙˙˙m€ހ€nŐ€j€˙˙˙˙o€ 1€1€˙˙˙˙p€ ހ€q H€j€˙˙˙˙r€ 1€1€˙˙˙˙s@ ހ€t Q€j€uހ vŐ€ ˙˙˙˙w€1€1€˙˙˙˙x€ހ€yH€j€˙˙˙˙z€ 1€1€˙˙˙˙{@ ހ€| Q€j€}Ő€+ ˙˙˙˙~€1€1€˙˙˙˙€ހ€€H€j€˙˙˙˙€ 1€1€˙˙˙˙‚@ ހ€ƒ Q€j€„Ő€= ˙˙˙˙…€1€1€˙˙˙˙†€ހ€‡H€j€˙˙˙˙ˆ€ 1€1€˙˙˙˙‰@ ހ€Š Q€j€‹Ő€O ˙˙˙˙Œ€1€1€˙˙˙˙€ހ€ŽH€j€˙˙˙˙€ 1€1€˙˙˙˙@ ހ€‘ Q€j€’Ő€a ˙˙˙˙“€1€1€˙˙˙˙”€ހ€•H€j€˙˙˙˙–€ 1€1€˙˙˙˙—@ ހ€˜ Q€j€™Ő€s ˙˙˙˙š€1€1€˙˙˙˙›€ހ€œH€j€˙˙˙˙€ 1€1€˙˙˙˙ž@ ހ€Ÿ Q€j€ H€… ˙˙˙˙Ą€1€1€˙˙˙˙˘@ހ€ŁQ€j€¤H€Ÿ ˙˙˙˙Ľ€1€1€˙˙˙˙Ś@ހ€§Q€j€¨Ś€ą ŠL€Î ŞL€â ŤShaderPPtrm_FileIDm_PathIDSerializedShaderm_ParsedFormSerializedPropertiesm_PropInfom_PropsSerializedPropertym_Descriptionm_Attributesm_Flagsm_DefValue[0]m_DefValue[1]m_DefValue[2]m_DefValue[3]SerializedTexturePropertym_DefTexturem_DefaultNamem_TexDimm_SubShadersSerializedSubShaderm_PassesSerializedPassm_NameIndicesSerializedShaderStatem_StateSerializedShaderRTBlendStatertBlend0SerializedShaderFloatValuesrcBlendvalnamedestBlendsrcBlendAlphadestBlendAlphablendOpblendOpAlphacolMaskrtBlend1rtBlend2rtBlend3rtBlend4rtBlend5rtBlend6rtBlend7rtSeparateBlendzTestzWritecullingoffsetFactoroffsetUnitsalphaToMaskSerializedStencilOpstencilOppassfailzFailcompstencilOpFrontstencilOpBackstencilReadMaskstencilWriteMaskstencilReffogStartfogEndfogDensitySerializedShaderVectorValuefogColorxyzwfogModegpuProgramIDSerializedTagMapm_Tagstagsm_LODlightingm_ProgramMaskSerializedProgramprogVertexm_SubProgramsSerializedSubProgramm_BlobIndexParserBindChannelsm_ChannelsShaderBindChannelsourcetargetm_SourceMapm_KeywordIndicesm_ShaderHardwareTierm_GpuProgramTypem_VectorParamsVectorParameterm_NameIndexm_ArraySizem_Dimm_MatrixParamsMatrixParameterm_RowCountm_TextureParamsTextureParameterm_SamplerIndexm_BufferParamsBufferBindingm_ConstantBuffersConstantBufferm_Sizem_ConstantBufferBindingsm_UAVParamsUAVParameterm_OriginalIndexprogFragmentprogGeometryprogHullprogDomainm_HasInstancingVariantm_UseNamem_TextureNamem_CustomEditorNamem_FallbackNamem_DependenciesSerializedShaderDependencyfromtom_DisableNoSubshadersMessageplatformsoffsetscompressedLengthsdecompressedLengthscompressedBlobPPtrm_ShaderIsBakedm_DefaultTexturesShaderCompilationInfom_CompileInfom_SnippetsShaderSnippetm_Codem_AssetPathm_PlatformMaskm_HardwareTierVariantsMaskm_StartLinem_TypesMaskHash128m_IncludesHashbytes[0]bytes[1]bytes[2]bytes[3]bytes[4]bytes[5]bytes[6]bytes[7]bytes[8]bytes[9]bytes[10]bytes[11]bytes[12]bytes[13]bytes[14]bytes[15]m_FromOtherm_Languagem_VariantsUser0m_VariantsUser1m_VariantsUser2m_VariantsUser3m_VariantsUser4m_VariantsUser5m_VariantsBuiltin0m_VariantsBuiltin1m_VariantsBuiltin2m_VariantsBuiltin3m_VariantsBuiltin4m_VariantsBuiltin5m_Targetm_TargetVariants0m_TargetVariants1m_TargetVariants2m_TargetVariants3m_TargetVariants4m_TargetVariants5m_NonStrippedUserKeywordsm_BuiltinKeywordsm_MeshComponentsFromSnippetsm_HasSurfaceShadersm_HasFixedFunctionShadersŹ°0>Iŕ‰öAüß!Aö˘8ë—őöZzTAssets/Standard Assets/Effects/ImageEffects/Shaders/_Antialiasing/FXAAPreset2.shader_MainTex Base (RGB)white€? €? pA €? €? pA €? €? pA €? €? pA €? €? pA €? €? pA €? €? pA €? €? pA A A A A C C unity_FogStart unity_FogEndunity_FogDensity unity_FogColor˙˙˙˙/ŔHidden/FXAA Preset 2Hidden/FXAA II/Ŕ°€#line 8 "" #ifdef DUMMY_PREPROCESSOR_TO_WORK_AROUND_HLSL_COMPILER_LINE_HANDLING #endif #include "HLSLSupport.cginc" #include "UnityShaderVariables.cginc" #line 8 "" #ifdef DUMMY_PREPROCESSOR_TO_WORK_AROUND_HLSL_COMPILER_LINE_HANDLING #endif /* UNITY: Original start of shader */ #pragma vertex vert #pragma fragment frag #include "UnityCG.cginc" #pragma target 3.0 // doesn't make sense to have this on consoles, it'll fallback to FXAA2 #pragma exclude_renderers xbox360 ps3 gles #define FXAA_HLSL_3 1 #define FXAA_PRESET 2 // Copyright (c) 2010 NVIDIA Corporation. All rights reserved. // // TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED // *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS // OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY // AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS // BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES // WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS, // BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS) // ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS // BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. /*============================================================================ FXAA ============================================================================*/ /*============================================================================ API PORTING ============================================================================*/ #ifndef FXAA_GLSL_120 #define FXAA_GLSL_120 0 #endif #ifndef FXAA_GLSL_130 #define FXAA_GLSL_130 0 #endif #ifndef FXAA_HLSL_3 #define FXAA_HLSL_3 0 #endif #ifndef FXAA_HLSL_4 #define FXAA_HLSL_4 0 #endif /*--------------------------------------------------------------------------*/ #if FXAA_GLSL_120 // Requires, // #version 120 // #extension GL_EXT_gpu_shader4 : enable #define int2 ivec2 #define float2 vec2 #define float3 vec3 #define float4 vec4 #define FxaaBool3 bvec3 #define FxaaInt2 ivec2 #define FxaaFloat2 vec2 #define FxaaFloat3 vec3 #define FxaaFloat4 vec4 #define FxaaBool2Float(a) mix(0.0, 1.0, (a)) #define FxaaPow3(x, y) pow(x, y) #define FxaaSel3(f, t, b) mix((f), (t), (b)) #define FxaaTex sampler2D #endif /*--------------------------------------------------------------------------*/ #if FXAA_GLSL_130 // Requires "#version 130" or better #define int2 ivec2 #define float2 vec2 #define float3 vec3 #define float4 vec4 #define FxaaBool3 bvec3 #define FxaaInt2 ivec2 #define FxaaFloat2 vec2 #define FxaaFloat3 vec3 #define FxaaFloat4 vec4 #define FxaaBool2Float(a) mix(0.0, 1.0, (a)) #define FxaaPow3(x, y) pow(x, y) #define FxaaSel3(f, t, b) mix((f), (t), (b)) #define FxaaTex sampler2D #endif /*--------------------------------------------------------------------------*/ #if FXAA_HLSL_3 #define int2 float2 #define FxaaInt2 float2 #define FxaaFloat2 float2 #define FxaaFloat3 float3 #define FxaaFloat4 float4 #define FxaaBool2Float(a) (a) #define FxaaPow3(x, y) pow(x, y) #define FxaaSel3(f, t, b) ((f)*(!b) + (t)*(b)) #define FxaaTex sampler2D #endif /*--------------------------------------------------------------------------*/ #if FXAA_HLSL_4 #define FxaaInt2 int2 #define FxaaFloat2 float2 #define FxaaFloat3 float3 #define FxaaFloat4 float4 #define FxaaBool2Float(a) (a) #define FxaaPow3(x, y) pow(x, y) #define FxaaSel3(f, t, b) ((f)*(!b) + (t)*(b)) struct FxaaTex { SamplerState smpl; Texture2D tex; }; #endif /*--------------------------------------------------------------------------*/ #define FxaaToFloat3(a) FxaaFloat3((a), (a), (a)) /*--------------------------------------------------------------------------*/ half4 _MainTex_ST; float4 FxaaTexLod0(FxaaTex tex, float2 pos) { #if FXAA_GLSL_120 return texture2DLod(tex, pos.xy, 0.0); #endif #if FXAA_GLSL_130 return textureLod(tex, pos.xy, 0.0); #endif #if FXAA_HLSL_3 return tex2Dlod(tex, float4(UnityStereoScreenSpaceUVAdjust(pos.xy, _MainTex_ST), 0.0, 0.0)); #endif #if FXAA_HLSL_4 return tex.tex.SampleLevel(tex.smpl, UnityStereoScreenSpaceUVAdjust(pos.xy, _MainTex_ST), 0.0); #endif } /*--------------------------------------------------------------------------*/ float4 FxaaTexGrad(FxaaTex tex, float2 pos, float2 grad) { #if FXAA_GLSL_120 return texture2DGrad(tex, pos.xy, grad, grad); #endif #if FXAA_GLSL_130 return textureGrad(tex, pos.xy, grad, grad); #endif #if FXAA_HLSL_3 return tex2Dgrad(tex, UnityStereoScreenSpaceUVAdjust(pos.xy, _MainTex_ST), grad, grad); #endif #if FXAA_HLSL_4 return tex.tex.SampleGrad(tex.smpl, UnityStereoScreenSpaceUVAdjust(pos.xy, _MainTex_ST), grad, grad); #endif } /*--------------------------------------------------------------------------*/ float4 FxaaTexOff(FxaaTex tex, float2 pos, int2 off, float2 rcpFrame) { #if FXAA_GLSL_120 return texture2DLodOffset(tex, pos.xy, 0.0, off.xy); #endif #if FXAA_GLSL_130 return textureLodOffset(tex, pos.xy, 0.0, off.xy); #endif #if FXAA_HLSL_3 return tex2Dlod(tex, float4(UnityStereoScreenSpaceUVAdjust(pos.xy + (off * rcpFrame), _MainTex_ST), 0, 0)); #endif #if FXAA_HLSL_4 return tex.tex.SampleLevel(tex.smpl, UnityStereoScreenSpaceUVAdjust(pos.xy, _MainTex_ST), 0.0, off.xy); #endif } /*============================================================================ SRGB KNOBS ------------------------------------------------------------------------------ FXAA_SRGB_ROP - Set to 1 when applying FXAA to an sRGB back buffer (DX10/11). This will do the sRGB to linear transform, as ROP will expect linear color from this shader, and this shader works in non-linear color. ============================================================================*/ #define FXAA_SRGB_ROP 0 /*============================================================================ DEBUG KNOBS ------------------------------------------------------------------------------ All debug knobs draw FXAA-untouched pixels in FXAA computed luma (monochrome). FXAA_DEBUG_PASSTHROUGH - Red for pixels which are filtered by FXAA with a yellow tint on sub-pixel aliasing filtered by FXAA. FXAA_DEBUG_HORZVERT - Blue for horizontal edges, gold for vertical edges. FXAA_DEBUG_PAIR - Blue/green for the 2 pixel pair choice. FXAA_DEBUG_NEGPOS - Red/blue for which side of center of span. FXAA_DEBUG_OFFSET - Red/blue for -/+ x, gold/skyblue for -/+ y. ============================================================================*/ #ifndef FXAA_DEBUG_PASSTHROUGH #define FXAA_DEBUG_PASSTHROUGH 0 #endif #ifndef FXAA_DEBUG_HORZVERT #define FXAA_DEBUG_HORZVERT 0 #endif #ifndef FXAA_DEBUG_PAIR #define FXAA_DEBUG_PAIR 0 #endif #ifndef FXAA_DEBUG_NEGPOS #define FXAA_DEBUG_NEGPOS 0 #endif #ifndef FXAA_DEBUG_OFFSET #define FXAA_DEBUG_OFFSET 0 #endif /*--------------------------------------------------------------------------*/ #if FXAA_DEBUG_PASSTHROUGH || FXAA_DEBUG_HORZVERT || FXAA_DEBUG_PAIR #define FXAA_DEBUG 1 #endif #if FXAA_DEBUG_NEGPOS || FXAA_DEBUG_OFFSET #define FXAA_DEBUG 1 #endif #ifndef FXAA_DEBUG #define FXAA_DEBUG 0 #endif /*============================================================================ COMPILE-IN KNOBS ------------------------------------------------------------------------------ FXAA_PRESET - Choose compile-in knob preset 0-5. ------------------------------------------------------------------------------ FXAA_EDGE_THRESHOLD - The minimum amount of local contrast required to apply algorithm. 1.0/3.0 - too little 1.0/4.0 - good start 1.0/8.0 - applies to more edges 1.0/16.0 - overkill ------------------------------------------------------------------------------ FXAA_EDGE_THRESHOLD_MIN - Trims the algorithm from processing darks. Perf optimization. 1.0/32.0 - visible limit (smaller isn't visible) 1.0/16.0 - good compromise 1.0/12.0 - upper limit (seeing artifacts) ------------------------------------------------------------------------------ FXAA_SEARCH_STEPS - Maximum number of search steps for end of span. ------------------------------------------------------------------------------ FXAA_SEARCH_ACCELERATION - How much to accelerate search, 1 - no acceleration 2 - skip by 2 pixels 3 - skip by 3 pixels 4 - skip by 4 pixels ------------------------------------------------------------------------------ FXAA_SEARCH_THRESHOLD - Controls when to stop searching. 1.0/4.0 - seems to be the best quality wise ------------------------------------------------------------------------------ FXAA_SUBPIX_FASTER - Turn on lower quality but faster subpix path. Not recomended, but used in preset 0. ------------------------------------------------------------------------------ FXAA_SUBPIX - Toggle subpix filtering. 0 - turn off 1 - turn on 2 - turn on full (ignores FXAA_SUBPIX_TRIM and CAP) ------------------------------------------------------------------------------ FXAA_SUBPIX_TRIM - Controls sub-pixel aliasing removal. 1.0/2.0 - low removal 1.0/3.0 - medium removal 1.0/4.0 - default removal 1.0/8.0 - high removal 0.0 - complete removal ------------------------------------------------------------------------------ FXAA_SUBPIX_CAP - Insures fine detail is not completely removed. This is important for the transition of sub-pixel detail, like fences and wires. 3.0/4.0 - default (medium amount of filtering) 7.0/8.0 - high amount of filtering 1.0 - no capping of sub-pixel aliasing removal ============================================================================*/ #ifndef FXAA_PRESET #define FXAA_PRESET 3 #endif /*--------------------------------------------------------------------------*/ #if (FXAA_PRESET == 0) #define FXAA_EDGE_THRESHOLD (1.0/4.0) #define FXAA_EDGE_THRESHOLD_MIN (1.0/12.0) #define FXAA_SEARCH_STEPS 2 #define FXAA_SEARCH_ACCELERATION 4 #define FXAA_SEARCH_THRESHOLD (1.0/4.0) #define FXAA_SUBPIX 1 #define FXAA_SUBPIX_FASTER 1 #define FXAA_SUBPIX_CAP (2.0/3.0) #define FXAA_SUBPIX_TRIM (1.0/4.0) #endif /*--------------------------------------------------------------------------*/ #if (FXAA_PRESET == 1) #define FXAA_EDGE_THRESHOLD (1.0/8.0) #define FXAA_EDGE_THRESHOLD_MIN (1.0/16.0) #define FXAA_SEARCH_STEPS 4 #define FXAA_SEARCH_ACCELERATION 3 #define FXAA_SEARCH_THRESHOLD (1.0/4.0) #define FXAA_SUBPIX 1 #define FXAA_SUBPIX_FASTER 0 #define FXAA_SUBPIX_CAP (3.0/4.0) #define FXAA_SUBPIX_TRIM (1.0/4.0) #endif /*--------------------------------------------------------------------------*/ #if (FXAA_PRESET == 2) #define FXAA_EDGE_THRESHOLD (1.0/8.0) #define FXAA_EDGE_THRESHOLD_MIN (1.0/24.0) #define FXAA_SEARCH_STEPS 8 #define FXAA_SEARCH_ACCELERATION 2 #define FXAA_SEARCH_THRESHOLD (1.0/4.0) #define FXAA_SUBPIX 1 #define FXAA_SUBPIX_FASTER 0 #define FXAA_SUBPIX_CAP (3.0/4.0) #define FXAA_SUBPIX_TRIM (1.0/4.0) #endif /*--------------------------------------------------------------------------*/ #if (FXAA_PRESET == 3) #define FXAA_EDGE_THRESHOLD (1.0/8.0) #define FXAA_EDGE_THRESHOLD_MIN (1.0/24.0) #define FXAA_SEARCH_STEPS 16 #define FXAA_SEARCH_ACCELERATION 1 #define FXAA_SEARCH_THRESHOLD (1.0/4.0) #define FXAA_SUBPIX 1 #define FXAA_SUBPIX_FASTER 0 #define FXAA_SUBPIX_CAP (3.0/4.0) #define FXAA_SUBPIX_TRIM (1.0/4.0) #endif /*--------------------------------------------------------------------------*/ #if (FXAA_PRESET == 4) #define FXAA_EDGE_THRESHOLD (1.0/8.0) #define FXAA_EDGE_THRESHOLD_MIN (1.0/24.0) #define FXAA_SEARCH_STEPS 24 #define FXAA_SEARCH_ACCELERATION 1 #define FXAA_SEARCH_THRESHOLD (1.0/4.0) #define FXAA_SUBPIX 1 #define FXAA_SUBPIX_FASTER 0 #define FXAA_SUBPIX_CAP (3.0/4.0) #define FXAA_SUBPIX_TRIM (1.0/4.0) #endif /*--------------------------------------------------------------------------*/ #if (FXAA_PRESET == 5) #define FXAA_EDGE_THRESHOLD (1.0/8.0) #define FXAA_EDGE_THRESHOLD_MIN (1.0/24.0) #define FXAA_SEARCH_STEPS 32 #define FXAA_SEARCH_ACCELERATION 1 #define FXAA_SEARCH_THRESHOLD (1.0/4.0) #define FXAA_SUBPIX 1 #define FXAA_SUBPIX_FASTER 0 #define FXAA_SUBPIX_CAP (3.0/4.0) #define FXAA_SUBPIX_TRIM (1.0/4.0) #endif /*--------------------------------------------------------------------------*/ #define FXAA_SUBPIX_TRIM_SCALE (1.0/(1.0 - FXAA_SUBPIX_TRIM)) /*============================================================================ HELPERS ============================================================================*/ // Return the luma, the estimation of luminance from rgb inputs. // This approximates luma using one FMA instruction, // skipping normalization and tossing out blue. // FxaaLuma() will range 0.0 to 2.963210702. float FxaaLuma(float3 rgb) { return rgb.y * (0.587/0.299) + rgb.x; } /*--------------------------------------------------------------------------*/ float3 FxaaLerp3(float3 a, float3 b, float amountOfA) { return (FxaaToFloat3(-amountOfA) * b) + ((a * FxaaToFloat3(amountOfA)) + b); } /*--------------------------------------------------------------------------*/ // Support any extra filtering before returning color. float3 FxaaFilterReturn(float3 rgb) { #if FXAA_SRGB_ROP // Do sRGB encoded value to linear conversion. return FxaaSel3( rgb * FxaaToFloat3(1.0/12.92), FxaaPow3( rgb * FxaaToFloat3(1.0/1.055) + FxaaToFloat3(0.055/1.055), FxaaToFloat3(2.4)), rgb > FxaaToFloat3(0.04045)); #else return rgb; #endif } /*============================================================================ VERTEX SHADER ============================================================================*/ float2 FxaaVertexShader( // Both x and y range {-1.0 to 1.0 across screen}. float2 inPos) { float2 pos; pos.xy = (inPos.xy * FxaaFloat2(0.5, 0.5)) + FxaaFloat2(0.5, 0.5); return pos; } /*============================================================================ PIXEL SHADER ============================================================================*/ float3 FxaaPixelShader( // Output of FxaaVertexShader interpolated across screen. // xy -> actual texture position {0.0 to 1.0} float2 pos, // Input texture. FxaaTex tex, // RCPFRAME SHOULD PIXEL SHADER CONSTANTS!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! // {1.0/frameWidth, 1.0/frameHeight} float2 rcpFrame) { /*---------------------------------------------------------------------------- EARLY EXIT IF LOCAL CONTRAST BELOW EDGE DETECT LIMIT ------------------------------------------------------------------------------ Majority of pixels of a typical image do not require filtering, often pixels are grouped into blocks which could benefit from early exit right at the beginning of the algorithm. Given the following neighborhood, N W M E S If the difference in local maximum and minimum luma (contrast "range") is lower than a threshold proportional to the maximum local luma ("rangeMax"), then the shader early exits (no visible aliasing). This threshold is clamped at a minimum value ("FXAA_EDGE_THRESHOLD_MIN") to avoid processing in really dark areas. ----------------------------------------------------------------------------*/ float3 rgbN = FxaaTexOff(tex, pos.xy, FxaaInt2( 0,-1), rcpFrame).xyz; float3 rgbW = FxaaTexOff(tex, pos.xy, FxaaInt2(-1, 0), rcpFrame).xyz; float3 rgbM = FxaaTexOff(tex, pos.xy, FxaaInt2( 0, 0), rcpFrame).xyz; float3 rgbE = FxaaTexOff(tex, pos.xy, FxaaInt2( 1, 0), rcpFrame).xyz; float3 rgbS = FxaaTexOff(tex, pos.xy, FxaaInt2( 0, 1), rcpFrame).xyz; float lumaN = FxaaLuma(rgbN); float lumaW = FxaaLuma(rgbW); float lumaM = FxaaLuma(rgbM); float lumaE = FxaaLuma(rgbE); float lumaS = FxaaLuma(rgbS); float rangeMin = min(lumaM, min(min(lumaN, lumaW), min(lumaS, lumaE))); float rangeMax = max(lumaM, max(max(lumaN, lumaW), max(lumaS, lumaE))); float range = rangeMax - rangeMin; #if FXAA_DEBUG float lumaO = lumaM / (1.0 + (0.587/0.299)); #endif if(range < max(FXAA_EDGE_THRESHOLD_MIN, rangeMax * FXAA_EDGE_THRESHOLD)) { #if FXAA_DEBUG return FxaaFilterReturn(FxaaToFloat3(lumaO)); #endif return FxaaFilterReturn(rgbM); } #if FXAA_SUBPIX > 0 #if FXAA_SUBPIX_FASTER float3 rgbL = (rgbN + rgbW + rgbE + rgbS + rgbM) * FxaaToFloat3(1.0/5.0); #else float3 rgbL = rgbN + rgbW + rgbM + rgbE + rgbS; #endif #endif /*---------------------------------------------------------------------------- COMPUTE LOWPASS ------------------------------------------------------------------------------ FXAA computes a local neighborhood lowpass value as follows, (N + W + E + S)/4 Then uses the ratio of the contrast range of the lowpass and the range found in the early exit check, as a sub-pixel aliasing detection filter. When FXAA detects sub-pixel aliasing (such as single pixel dots), it later blends in "blendL" amount of a lowpass value (computed in the next section) to the final result. ----------------------------------------------------------------------------*/ #if FXAA_SUBPIX != 0 float lumaL = (lumaN + lumaW + lumaE + lumaS) * 0.25; float rangeL = abs(lumaL - lumaM); #endif #if FXAA_SUBPIX == 1 float blendL = max(0.0, (rangeL / range) - FXAA_SUBPIX_TRIM) * FXAA_SUBPIX_TRIM_SCALE; blendL = min(FXAA_SUBPIX_CAP, blendL); #endif #if FXAA_SUBPIX == 2 float blendL = rangeL / range; #endif #if FXAA_DEBUG_PASSTHROUGH #if FXAA_SUBPIX == 0 float blendL = 0.0; #endif return FxaaFilterReturn( FxaaFloat3(1.0, blendL/FXAA_SUBPIX_CAP, 0.0)); #endif /*---------------------------------------------------------------------------- CHOOSE VERTICAL OR HORIZONTAL SEARCH ------------------------------------------------------------------------------ FXAA uses the following local neighborhood, NW N NE W M E SW S SE To compute an edge amount for both vertical and horizontal directions. Note edge detect filters like Sobel fail on single pixel lines through M. FXAA takes the weighted average magnitude of the high-pass values for rows and columns as an indication of local edge amount. A lowpass value for anti-sub-pixel-aliasing is computed as (N+W+E+S+M+NW+NE+SW+SE)/9. This full box pattern has higher quality than other options. Note following this block, both vertical and horizontal cases flow in parallel (reusing the horizontal variables). ----------------------------------------------------------------------------*/ float3 rgbNW = FxaaTexOff(tex, pos.xy, FxaaInt2(-1,-1), rcpFrame).xyz; float3 rgbNE = FxaaTexOff(tex, pos.xy, FxaaInt2( 1,-1), rcpFrame).xyz; float3 rgbSW = FxaaTexOff(tex, pos.xy, FxaaInt2(-1, 1), rcpFrame).xyz; float3 rgbSE = FxaaTexOff(tex, pos.xy, FxaaInt2( 1, 1), rcpFrame).xyz; #if (FXAA_SUBPIX_FASTER == 0) && (FXAA_SUBPIX > 0) rgbL += (rgbNW + rgbNE + rgbSW + rgbSE); rgbL *= FxaaToFloat3(1.0/9.0); #endif float lumaNW = FxaaLuma(rgbNW); float lumaNE = FxaaLuma(rgbNE); float lumaSW = FxaaLuma(rgbSW); float lumaSE = FxaaLuma(rgbSE); float edgeVert = abs((0.25 * lumaNW) + (-0.5 * lumaN) + (0.25 * lumaNE)) + abs((0.50 * lumaW ) + (-1.0 * lumaM) + (0.50 * lumaE )) + abs((0.25 * lumaSW) + (-0.5 * lumaS) + (0.25 * lumaSE)); float edgeHorz = abs((0.25 * lumaNW) + (-0.5 * lumaW) + (0.25 * lumaSW)) + abs((0.50 * lumaN ) + (-1.0 * lumaM) + (0.50 * lumaS )) + abs((0.25 * lumaNE) + (-0.5 * lumaE) + (0.25 * lumaSE)); bool horzSpan = edgeHorz >= edgeVert; #if FXAA_DEBUG_HORZVERT if(horzSpan) return FxaaFilterReturn(FxaaFloat3(1.0, 0.75, 0.0)); else return FxaaFilterReturn(FxaaFloat3(0.0, 0.50, 1.0)); #endif float lengthSign = horzSpan ? -rcpFrame.y : -rcpFrame.x; if(!horzSpan) lumaN = lumaW; if(!horzSpan) lumaS = lumaE; float gradientN = abs(lumaN - lumaM); float gradientS = abs(lumaS - lumaM); lumaN = (lumaN + lumaM) * 0.5; lumaS = (lumaS + lumaM) * 0.5; /*---------------------------------------------------------------------------- CHOOSE SIDE OF PIXEL WHERE GRADIENT IS HIGHEST ------------------------------------------------------------------------------ This chooses a pixel pair. For "horzSpan == true" this will be a vertical pair, [N] N [M] or [M] S [S] Note following this block, both {N,M} and {S,M} cases flow in parallel (reusing the {N,M} variables). This pair of image rows or columns is searched below in the positive and negative direction until edge status changes (or the maximum number of search steps is reached). ----------------------------------------------------------------------------*/ bool pairN = gradientN >= gradientS; #if FXAA_DEBUG_PAIR if(pairN) return FxaaFilterReturn(FxaaFloat3(0.0, 0.0, 1.0)); else return FxaaFilterReturn(FxaaFloat3(0.0, 1.0, 0.0)); #endif if(!pairN) lumaN = lumaS; if(!pairN) gradientN = gradientS; if(!pairN) lengthSign *= -1.0; float2 posN; posN.x = pos.x + (horzSpan ? 0.0 : lengthSign * 0.5); posN.y = pos.y + (horzSpan ? lengthSign * 0.5 : 0.0); /*---------------------------------------------------------------------------- CHOOSE SEARCH LIMITING VALUES ------------------------------------------------------------------------------ Search limit (+/- gradientN) is a function of local gradient. ----------------------------------------------------------------------------*/ gradientN *= FXAA_SEARCH_THRESHOLD; /*---------------------------------------------------------------------------- SEARCH IN BOTH DIRECTIONS UNTIL FIND LUMA PAIR AVERAGE IS OUT OF RANGE ------------------------------------------------------------------------------ This loop searches either in vertical or horizontal directions, and in both the negative and positive direction in parallel. This loop fusion is faster than searching separately. The search is accelerated using FXAA_SEARCH_ACCELERATION length box filter via anisotropic filtering with specified texture gradients. ----------------------------------------------------------------------------*/ float2 posP = posN; float2 offNP = horzSpan ? FxaaFloat2(rcpFrame.x, 0.0) : FxaaFloat2(0.0f, rcpFrame.y); float lumaEndN = lumaN; float lumaEndP = lumaN; bool doneN = false; bool doneP = false; #if FXAA_SEARCH_ACCELERATION == 1 posN += offNP * FxaaFloat2(-1.0, -1.0); posP += offNP * FxaaFloat2( 1.0, 1.0); #endif #if FXAA_SEARCH_ACCELERATION == 2 posN += offNP * FxaaFloat2(-1.5, -1.5); posP += offNP * FxaaFloat2( 1.5, 1.5); offNP *= FxaaFloat2(2.0, 2.0); #endif #if FXAA_SEARCH_ACCELERATION == 3 posN += offNP * FxaaFloat2(-2.0, -2.0); posP += offNP * FxaaFloat2( 2.0, 2.0); offNP *= FxaaFloat2(3.0, 3.0); #endif #if FXAA_SEARCH_ACCELERATION == 4 posN += offNP * FxaaFloat2(-2.5, -2.5); posP += offNP * FxaaFloat2( 2.5, 2.5); offNP *= FxaaFloat2(4.0, 4.0); #endif for(int i = 0; i < FXAA_SEARCH_STEPS; i++) { #if FXAA_SEARCH_ACCELERATION == 1 if(!doneN) lumaEndN = FxaaLuma(FxaaTexLod0(tex, posN.xy).xyz); if(!doneP) lumaEndP = FxaaLuma(FxaaTexLod0(tex, posP.xy).xyz); #else if(!doneN) lumaEndN = FxaaLuma(FxaaTexGrad(tex, posN.xy, offNP).xyz); if(!doneP) lumaEndP = FxaaLuma(FxaaTexGrad(tex, posP.xy, offNP).xyz); #endif doneN = doneN || (abs(lumaEndN - lumaN) >= gradientN); doneP = doneP || (abs(lumaEndP - lumaN) >= gradientN); if(doneN && doneP) break; if(!doneN) posN -= offNP; if(!doneP) posP += offNP; } /*---------------------------------------------------------------------------- HANDLE IF CENTER IS ON POSITIVE OR NEGATIVE SIDE ------------------------------------------------------------------------------ FXAA uses the pixel's position in the span in combination with the values (lumaEnd*) at the ends of the span, to determine filtering. This step computes which side of the span the pixel is on. On negative side if dstN < dstP, posN pos posP |-----------|------|------------------| | | | | |<--dstN--->|<---------dstP---------->| | span center ----------------------------------------------------------------------------*/ float dstN = horzSpan ? pos.x - posN.x : pos.y - posN.y; float dstP = horzSpan ? posP.x - pos.x : posP.y - pos.y; bool directionN = dstN < dstP; #if FXAA_DEBUG_NEGPOS if(directionN) return FxaaFilterReturn(FxaaFloat3(1.0, 0.0, 0.0)); else return FxaaFilterReturn(FxaaFloat3(0.0, 0.0, 1.0)); #endif lumaEndN = directionN ? lumaEndN : lumaEndP; /*---------------------------------------------------------------------------- CHECK IF PIXEL IS IN SECTION OF SPAN WHICH GETS NO FILTERING ------------------------------------------------------------------------------ If both the pair luma at the end of the span (lumaEndN) and middle pixel luma (lumaM) are on the same side of the middle pair average luma (lumaN), then don't filter. Cases, (1.) "L", lumaM | V XXXXXXXX <- other line averaged XXXXXXX[X]XXXXXXXXXXX <- source pixel line | . | -------------------------- [ ]xxxxxx[x]xx[X]XXXXXX <- pair average -------------------------- ^ ^ ^ ^ | | | | . |<---->|<---------- no filter region . | | | . center | | . | lumaEndN . | . . lumaN . . . |<--- span -->| (2.) "^" and "-", <- other line averaged XXXXX[X]XXX <- source pixel line | | | -------------------------- [ ]xxxx[x]xx[ ] <- pair average -------------------------- | | | |<--->|<--->|<---------- filter both sides (3.) "v" and inverse of "-", XXXXXX XXXXXXXXX <- other line averaged XXXXXXXXXXX[X]XXXXXXXXXXXX <- source pixel line | | | -------------------------- XXXX[X]xxxx[x]xx[X]XXXXXXX <- pair average -------------------------- | | | |<--->|<--->|<---------- don't filter both! Note the "v" case for FXAA requires no filtering. This is because the inverse of the "-" case is the "v". Filtering "v" case turns open spans like this, XXXXXXXXX Into this (which is not desired), x+. .+x XXXXXXXXX ----------------------------------------------------------------------------*/ if(((lumaM - lumaN) < 0.0) == ((lumaEndN - lumaN) < 0.0)) lengthSign = 0.0; /*---------------------------------------------------------------------------- COMPUTE SUB-PIXEL OFFSET AND FILTER SPAN ------------------------------------------------------------------------------ FXAA filters using a bilinear texture fetch offset from the middle pixel M towards the center of the pair (NM below). Maximum filtering will be half way between pair. Reminder, at this point in the code, the {N,M} pair is also reused for all cases: {S,M}, {W,M}, and {E,M}. +-------+ | | 0.5 offset | N | | | | V +-------+....--- | | | M...|....--- | | ^ +-------+ | . . 0.0 offset . S . . . ......... Position on span is used to compute sub-pixel filter offset using simple ramp, posN posP |\ |<------- 0.5 pixel offset into pair pixel | \ | | \ | ---.......|...\..........|<------- 0.25 pixel offset into pair pixel ^ | ^\ | | | | \ | V | | \ | ---.......|===|==========|<------- 0.0 pixel offset (ie M pixel) ^ . | ^ . | . pos | . | . . | . | . . center . | . . . | |<->|<---------.-------- dstN | . . . | . |<-------->|<------- dstP | . . | |<------------>|<------- spanLength | subPixelOffset ----------------------------------------------------------------------------*/ float spanLength = (dstP + dstN); dstN = directionN ? dstN : dstP; float subPixelOffset = (0.5 + (dstN * (-1.0/spanLength))) * lengthSign; #if FXAA_DEBUG_OFFSET float ox = horzSpan ? 0.0 : subPixelOffset*2.0/rcpFrame.x; float oy = horzSpan ? subPixelOffset*2.0/rcpFrame.y : 0.0; if(ox < 0.0) return FxaaFilterReturn( FxaaLerp3(FxaaToFloat3(lumaO), FxaaFloat3(1.0, 0.0, 0.0), -ox)); if(ox > 0.0) return FxaaFilterReturn( FxaaLerp3(FxaaToFloat3(lumaO), FxaaFloat3(0.0, 0.0, 1.0), ox)); if(oy < 0.0) return FxaaFilterReturn( FxaaLerp3(FxaaToFloat3(lumaO), FxaaFloat3(1.0, 0.6, 0.2), -oy)); if(oy > 0.0) return FxaaFilterReturn( FxaaLerp3(FxaaToFloat3(lumaO), FxaaFloat3(0.2, 0.6, 1.0), oy)); return FxaaFilterReturn(FxaaFloat3(lumaO, lumaO, lumaO)); #endif float3 rgbF = FxaaTexLod0(tex, FxaaFloat2( pos.x + (horzSpan ? 0.0 : subPixelOffset), pos.y + (horzSpan ? subPixelOffset : 0.0))).xyz; #if FXAA_SUBPIX == 0 return FxaaFilterReturn(rgbF); #else return FxaaFilterReturn(FxaaLerp3(rgbL, rgbF, blendL)); #endif } struct v2f { float4 pos : SV_POSITION; float2 uv : TEXCOORD0; }; v2f vert (appdata_img v) { v2f o; o.pos = mul (UNITY_MATRIX_MVP, v.vertex); o.uv = v.texcoord.xy; return o; } sampler2D _MainTex; float4 _MainTex_TexelSize; float4 frag (v2f i) : SV_Target { return float4(FxaaPixelShader(i.uv.xy, _MainTex, _MainTex_TexelSize.xy).xyz, 0.0f); } AAssets/Standard Assets/Effects/ImageEffects/Shaders/_AntialiasingÓ˙˙˙ =(´žçˇ‘Šd{´ěy SHADOWS_SOFTDIRLIGHTMAP_COMBINEDDIRLIGHTMAP_SEPARATEDYNAMICLIGHTMAP_ON INSTANCING_ON