[카테고리:] shader

float node_8816 = (sceneUVs.r+_ReflectionCoordinater);
                float2 node_2055 = (float2(sceneUVs.r,sceneUVs.g)+(float2(node_8816,node_8816)*(float2(_normal_var.r,_normal_var.g)*_NormalJitter)));
                half4 _ReflectionTex_var = tex2D(_ReflectionTex,node_2055);
                fixed3 FlatMirror = ((_ReflectionTex_var.rgb+(pow((1.0 - lerp( _ReflectionTex_var.rgb.g, _ReflectionTex_var.rgb.r, _ChannelSwap )),exp2(_ReflectionBrightSubScale))*_ReflectionBrightSubScale))*_ReflectionsIntensity);
                half Fresnel = dot(pow(1.0-max(0,dot(normalDirection, viewDirection)),exp2((1.0 - _ReflectionFresnel))),lightDirection);
                float3 node_9903 = (FlatMirror*Fresnel);
                half3 FlatMirrorBlended = saturate(max(_MainTex_var.rgb,node_9903));
                half3 node_9232 = FlatMirrorBlended;
                half3 Albedo = _MainTex_var.rgb;
                float node_6753 = (i.uv0.g+(_ReflectionFadeOffset*0.5+0.0)).r;
                half3 FlatMirrorFade = lerp(node_9232,Albedo,node_6753);
                float3 diffuseColor = FlatMirrorFade;

Shader "ASE_DualMatcap"
{
	Properties
	{
		_FrontParaboloid ("_FrontParaboloid", 2D) = "white" { }
		_RearParaboloid ("_RearParaboloid", 2D) = "white" { }
		_Albedo("Albedo", 2D) = "white" {}
		_Float0("Float 0", Range( 0 , 2)) = 1
		[HideInInspector] _texcoord( "", 2D ) = "white" {}
		
	
	}
	
	SubShader
	{
		Tags { "RenderType"="Opaque" "LightMode" = "ForwardBase" }
		LOD 100
		Cull Off


		Pass
		{
			CGPROGRAM
			#pragma target 3.0 
			#pragma vertex vert
			#pragma fragment frag
			#include "UnityCG.cginc"


			struct appdata
			{
				float4 vertex : POSITION;
				float3 normal : NORMAL;	
				float4 texcoord : TEXCOORD0;
				float4 texcoord1 : TEXCOORD1;
				UNITY_VERTEX_INPUT_INSTANCE_ID
			};
			
			struct v2f
			{
				float4 vertex : SV_POSITION;
				float4 texcoord : TEXCOORD0;
				float3 worldNormal : TEXCOORD1;
				UNITY_VERTEX_OUTPUT_STEREO
			};

			
			uniform fixed4 _Color;
			uniform sampler2D _FrontParaboloid;
			uniform sampler2D _RearParaboloid;
			uniform sampler2D _Albedo;
			uniform float4 _Albedo_ST;
			uniform float _Float0;
			
			v2f vert ( appdata v )
			{
				v2f o;
				UNITY_SETUP_INSTANCE_ID(v);
				UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
				o.texcoord.xy = v.texcoord.xy;
				o.texcoord.zw = v.texcoord1.xy;
				
				// ase common template code
				
				v.vertex.xyz +=  float3(0,0,0) ;
				o.vertex = UnityObjectToClipPos(v.vertex);
				o.worldNormal = normalize(mul((float3x3)unity_ObjectToWorld, v.normal));
				return o;
			}

			inline fixed4 texParaboloidXFliped(sampler2D front, sampler2D back, float3 refl)
			{
				if (refl.x > 0)
				{
					float2 frontUv;
					frontUv.x = refl.z / (refl.x + 1);
					frontUv.y = refl.y / (refl.x + 1);
					frontUv = (frontUv * .5f) + 0.5f;
		
					frontUv.x = 1 - frontUv.x;

					return tex2D(front, frontUv);
				}
				else
				{
					float2 backUv;
					backUv.x = refl.z / (1 - refl.x);
					backUv.x *= -1;
					backUv.y = refl.y / (1 - refl.x);
					backUv = (backUv * .5f) + 0.5f;
	
					backUv.x = backUv.x;
		
					return tex2D(back, backUv);
				}
			}
			
			fixed4 frag (v2f i ) : SV_Target
			{
				fixed4 parabolicOut;
				// ase common template code
				float2 uv_Albedo = i.texcoord.xy * _Albedo_ST.xy + _Albedo_ST.zw;
				
				
				parabolicOut = ( float4(1,1,1,0) * ( tex2D( _Albedo, uv_Albedo ) * _Float0 ) );
				//return myColorVar;
				return parabolicOut * texParaboloidXFliped(_FrontParaboloid, _RearParaboloid, i.worldNormal);;
			}
			ENDCG
		}
	}
	CustomEditor "ASEMaterialInspector"
}

Shader "Water Ripple Shader"
{
	Properties
	{
		_Cutoff( "Mask Clip Value", Float ) = 0.5
		_RippleFoam("RippleFoam", 2D) = "white" {}
		_MainFoamSpeed("Main Foam Speed", Float) = 0.1
		_SecondFoamSpeed("Second Foam Speed", Float) = 0.1
		_MainFoamScale("Main Foam Scale", Float) = 2
		[HideInInspector] __dirty( "", Int ) = 1
	}

	SubShader
	{
		Tags{ "RenderType" = "TransparentCutout"  "Queue" = "AlphaTest+0" "IgnoreProjector" = "True" "ForceNoShadowCasting" = "True" "IsEmissive" = "true"  }
		Cull Back
		CGPROGRAM
		#include "UnityShaderVariables.cginc"
		#pragma target 3.5
		#pragma multi_compile_instancing
		#pragma only_renderers d3d11 glcore gles gles3 metal 
		#pragma surface surf Unlit keepalpha noshadow novertexlights nolightmap  nodynlightmap nodirlightmap nometa noforwardadd vertex:vertexDataFunc 
		struct Input
		{
			float2 vertexToFrag32;
			float2 vertexToFrag33;
			float4 vertexColor : COLOR;
		};

		uniform float _MainFoamSpeed;
		uniform float _MainFoamScale;
		uniform sampler2D _RippleFoam;
		uniform float _SecondFoamSpeed;
		uniform float _Cutoff = 0.5;

		void vertexDataFunc( inout appdata_full v, out Input o )
		{
			UNITY_INITIALIZE_OUTPUT( Input, o );
			float temp_output_30_0 = ( _MainFoamSpeed * 0.15 );
			float2 appendResult31 = (float2(temp_output_30_0 , temp_output_30_0));
			float2 panner8 = ( ( appendResult31 * _Time.y ).x * float2( 0,1 ) + v.texcoord.xy);
			float2 temp_output_22_0 = ( panner8 * _MainFoamScale );
			o.vertexToFrag32 = temp_output_22_0;
			float temp_output_15_0 = ( _SecondFoamSpeed * 0.15 );
			float2 appendResult18 = (float2(temp_output_15_0 , temp_output_15_0));
			o.vertexToFrag33 = ( temp_output_22_0 + ( appendResult18 * _Time.y ) );
		}

		inline fixed4 LightingUnlit( SurfaceOutput s, half3 lightDir, half atten )
		{
			return fixed4 ( 0, 0, 0, s.Alpha );
		}

		void surf( Input i , inout SurfaceOutput o )
		{
			o.Emission = float4(1,1,1,0).rgb;
			o.Alpha = 1;
			float lerpResult40 = lerp( 0.5 , ( tex2D( _RippleFoam, i.vertexToFrag32 ).g + tex2D( _RippleFoam, i.vertexToFrag33 ).r ) , i.vertexColor.r);
			clip( lerpResult40 - _Cutoff );
		}

		ENDCG
	}
	CustomEditor "ASEMaterialInspector"
}