unity_InstanceID;

float3 ase_objectScale = float3
    ( 
        length( unity_ObjectToWorld[ 0 ].xyz ), 
        length( unity_ObjectToWorld[ 1 ].xyz ), 
        length( unity_ObjectToWorld[ 2 ].xyz ) 
    );

float3 ase_vertexBitangent = cross(v.normal,v.tangent.xyz);

struct appdata
{
    float4 vertex : POSITION;
    float4 color : COLOR;
    UNITY_VERTEX_INPUT_INSTANCE_ID

};
    
v2f vert ( appdata v )
{
    v.color;
}

v2f vert ( appdata v , uint ase_vertexId : SV_VertexID)
{
}

struct appdata
{
    float3 normal : NORMAL;
};
    
v.normal;

struct appdata
{
	float4 vertex : POSITION;

};

v.vertex;

struct appdata
{
	float4 tangent : TANGENT;
};

v.tangent;

float ase_vertexTangentSign = v.tangent.w * unity_WorldTransformParams.w;

struct appdata
{
	float4 texcoord : TEXCOORD0;
};

v.texcoord;

float3 break47 = float3(2,0,2);
float2 appendResult50 = (float2(break47.x , break47.z));

fixed4 finalColor;
float3 right = normalize( float3(1,0,0) );
float3 up = normalize( float3(1,1,0) );
float3 front = normalize( cross( right , up ) );
float3 offset = mul
    ( 
        float4x4
        (
            float4( right , 0.0 ), 
            float4( cross( front , right ) , 0.0 ), 
            float4( front , 0.0 ), 
            float4( 0,0,0,0 )
        ), 
        float4( i.ase_texcoord.xyz , 0.0 ) 
    ).xyz;


finalColor = float4( offset , 0.0 );

cross( float3(1,0,0) , float3(0,1,0) ); // float3(0, 0, 1)

float d = distance( float3(0,0,0) , float3(1,1,1) );

float d = dot( float3(0,0,0) , float3(1,1,1) );

float d = length( float3(1,0,0);

float3 n = normalize( float3(1,2.01,0.36) );

float3 r = refract( float3(1,1,0) , normalize( i.normal ) , eta )

uniform float3 _axis;
uniform float _Angle;
uniform float3 _pivot;
float3 RotateAroundAxis( float3 center, float3 original, float3 u, float angle )
{
    original -= center;
    float C = cos( angle );
    float S = sin( angle );
    float t = 1 - C;
    float m00 = t * u.x * u.x + C;
    float m01 = t * u.x * u.y - S * u.z;
    float m02 = t * u.x * u.z + S * u.y;
    float m10 = t * u.x * u.y + S * u.z;
    float m11 = t * u.y * u.y + C;
    float m12 = t * u.y * u.z - S * u.x;
    float m20 = t * u.x * u.z - S * u.y;
    float m21 = t * u.y * u.z + S * u.x;
    float m22 = t * u.z * u.z + C;
    float3x3 finalMatrix = float3x3( m00, m01, m02, m10, m11, m12, m20, m21, m22 );
    return mul( finalMatrix, original ) + center;
}

float3 rotatedValue93 = RotateAroundAxis( _pivot, v.vertex.xyz, normalize( _axis ), _Angle );

(_Vector0).xyzz.xyz;

// from: object, to: world
 float4 n = mul( unity_ObjectToWorld, float4( i.ase_normal, 0 ) )
     
// from: object, to: View   
 mul( UNITY_MATRIX_IT_MV, float4( i.ase_normal, 0 ) ).xyz;   

// from: object, to: Tangent   
float3 ase_worldTangent = UnityObjectToWorldDir(v.ase_tangent);
float3 ase_worldNormal = UnityObjectToWorldNormal(v.ase_normal);
float ase_vertexTangentSign = v.ase_tangent.w * unity_WorldTransformParams.w;
float3 ase_worldBitangent = cross( ase_worldNormal, ase_worldTangent ) * ase_vertexTangentSign;
float3x3 ase_worldToTangent = float3x3(ase_worldTangent,ase_worldBitangent,ase_worldNormal);
float3 objectToTangentDir112 = mul( ase_worldToTangent, mul( unity_ObjectToWorld, float4( v.ase_normal, 0 ) ).xyz);

// from: object, to: Clip  
mul(UNITY_MATRIX_VP, mul(unity_ObjectToWorld, float4(v.ase_normal, 0.0)));

// from: world, to: object
mul( unity_WorldToObject, float4( v.ase_normal, 0 ) ).xyz;

// from: world, to: view
mul( UNITY_MATRIX_V, float4( v.ase_normal, 0 ) ).xyz;

// from: world, to: Tangent
float3 ase_worldTangent = UnityObjectToWorldDir(v.ase_tangent);
float3 ase_worldNormal = UnityObjectToWorldNormal(v.ase_normal);
float ase_vertexTangentSign = v.ase_tangent.w * unity_WorldTransformParams.w;
float3 ase_worldBitangent = cross( ase_worldNormal, ase_worldTangent ) * ase_vertexTangentSign;
float3x3 ase_worldToTangent = float3x3(ase_worldTangent,ase_worldBitangent,ase_worldNormal);
float3 worldToTangentDir112 = mul( ase_worldToTangent, v.ase_normal);

// from: world, to: Clip  
mul(UNITY_MATRIX_VP, float4(v.ase_normal, 0.0));

// from: view, to: world  
mul( UNITY_MATRIX_I_V, float4( v.ase_normal, 0 ) ).xyz;

// from: view, to: object  
mul( UNITY_MATRIX_T_MV, float4( v.ase_normal, 0 ) ).xyz;

// from: view, to: clip  
mul(UNITY_MATRIX_P, float4(v.ase_normal, 0.0));

 _Time.y

// t/20
_Time.x;
// t
_Time.y;
// t*2
_Time.z;
// t*3
_Time.w;

// dt
unity_DeltaTime.x;
// 1/dt
unity_DeltaTime.y;
// smoothDt
unity_DeltaTime.z;
// 1/smoothDt
unity_DeltaTime.w;

// t/8
_CosTime.x
// t/4
_CosTime.y    
// t/2
_CosTime.z
// t
_CosTime.w

// t/8
_SinTime.x
// t/4
_SinTime.y    
// t/2
_SinTime.z
// t
_SinTime.w

abs( i.ase_normal )

floor( 1.1 ) // 1
floor( 1.6 ) // 2

round(1.1); // 1
round(1.5); // 2
round(1.6); // 2

fmod( -4.1 , 4.0 ); // -0.1
fmod( 4.1 , 4.0 ); // 0.1
fmod( 4 , 4.0 ); // 0  
fmod( 4 , 8.0 ); // 0  

frac(a/b)*b

frac( 4.2 ); // 0.2

float lerp(float a, float b, float t)
{
    return (1 - a) * t + b * t;
}

float4 lerpResult223 = lerp( color225 , color226 , dotResult126);

float3 v3 = i.ase_normal;

float3 v3_ddx = ddx( v3 );
float dot_ddx = dot( v3_ddx , v3_ddx );

float3 v3_ddy = ddy( v3 );
float dot_ddy = dot( v3_ddy , v3_ddy );

float dot_val = 0;
if( dot_ddx <= dot_ddy )
    dot_val = dot_ddy;
else
    dot_val = dot_ddx;

float4 v3_out = (sqrt( dot_val )).xxxx;

normalize(cross(ddy(IN.worldPos),ddx(IN.worldPos)));

void surf (Input IN, inout SurfaceOutput o) {
    half4 c = tex2D(_MainTex, IN.uv_MainTex);
    //c += ddx(c)*2 + ddy(c)*2; //这行代码开启和关闭的效果
    o.Albedo = c.rgb;
    o.Alpha = c.a;
}

float3 v3 = ddx( i.ase_normal )

fwidth( i.ase_texcoord.xyz )

exp( 1 ) // 2.71828

exp2( -4 ), 1/exp2(4);  //0.0625
exp2( -3 ), 1/exp2(3);  //0.125
exp2( -2 ), 1/exp2(2);  //0.25
exp2( -1 ), 1/exp2(1);  //0.5
exp2( 0 ); // 1
exp2( 1 ); // 2
exp2( 2 ); // 4
exp2( 3 ); // 8

log( _Float10 )

rsqrt(16); // 0.5 == 1/4 == 1 / sqr(pow(4, 2))

max( 0.1 , 0.5 ); // 0.5

min( 0.1 , 0.5 ); // 0.1

float clamp(float a, float min, float max)
{
    return a < min ? min   :   a > max ? max : a
}

float saturate(float a)
{
	return a < 0 ?  0    :      a >1 ? 1 :  a 
}

float step(a, b)
{
    return b < a ? 0 : 1;
}

float sign(float a)
{
	return a == 0 ? 0 :    a > 0 ? 1 : -1;
}

color * 0.2

color * 2 + -1

float t = ( B - A );
float result = saturate(    t / fwidth( t )   )

trunc( -2.1 ); // -2
trunc( -1.6 ); // -1
trunc( -1.1 ); // -1
trunc( 0.1 ); // 0
trunc( 0.6 ); // 0
trunc( 1.6 ); // 1
trunc( 2.6 ); // 2

float randians(float angle)
{
	reutrn angle * (pi / 180);
}

float degrees(float randians)
{
	reutrn randians * 180 / pi;
}

cos( radian )

acos(  cos(radian) ) == radian

asin( sin(a) ) == a

float4 left = unity_CameraWorldClipPlanes[0];
float4 right = unity_CameraWorldClipPlanes[1];

float4 bottom = unity_CameraWorldClipPlanes[2];
float4 up = unity_CameraWorldClipPlanes[3];

float4 near = unity_CameraWorldClipPlanes[4];
float4 far = unity_CameraWorldClipPlanes[5];

float Dither4x4Bayer( int x, int y )
{
    const float dither[ 16 ] = {
        1,  9,  3, 11,
            13,  5, 15,  7,
            4, 12,  2, 10,
            16,  8, 14,  6 };
        int r = y * 4 + x;
    return dither[r] / 16; // same # of instructions as pre-dividing due to compiler magic
}



v2f vert ( appdata v )
{
    v2f o;
    UNITY_SETUP_INSTANCE_ID(v);
    UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
    UNITY_TRANSFER_INSTANCE_ID(v, o);

    float4 ase_clipPos = UnityObjectToClipPos(v.vertex);
    float4 screenPos = ComputeScreenPos(ase_clipPos);
    o.ase_texcoord = screenPos;

    o.ase_texcoord1.xy = v.ase_texcoord.xy;

    //setting value to unused interpolator channels and avoid initialization warnings
    o.ase_texcoord1.zw = 0;
    float3 vertexValue = float3(0, 0, 0);
    #if ASE_ABSOLUTE_VERTEX_POS
    vertexValue = v.vertex.xyz;
    #endif
    vertexValue = vertexValue;
    #if ASE_ABSOLUTE_VERTEX_POS
    v.vertex.xyz = vertexValue;
    #else
    v.vertex.xyz += vertexValue;
    #endif
    o.vertex = UnityObjectToClipPos(v.vertex);
    return o;
}


fixed4 frag (v2f i ) : SV_Target
{
    UNITY_SETUP_INSTANCE_ID(i);
    UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(i);
    fixed4 finalColor;
    float4 screenPos = i.ase_texcoord;
    float4 ase_screenPosNorm = screenPos / screenPos.w;
    ase_screenPosNorm.z = ( UNITY_NEAR_CLIP_VALUE >= 0 ) ? ase_screenPosNorm.z : ase_screenPosNorm.z * 0.5 + 0.5;
    float2 clipScreen367 = ase_screenPosNorm.xy * _ScreenParams.xy;
    float dither367 = Dither4x4Bayer( fmod(clipScreen367.x, 4), fmod(clipScreen367.y, 4) );
    float2 uv_Texture0 = i.ase_texcoord1.xy * _Texture0_ST.xy + _Texture0_ST.zw;
    dither367 = step( dither367, tex2D( _Texture0, uv_Texture0 ).g );
    float4 temp_cast_0 = (dither367).xxxx;


    finalColor = temp_cast_0;
    return finalColor;
}

float Dither8x8Bayer( int x, int y )
{
    const float dither[ 64 ] = {
        1, 49, 13, 61,  4, 52, 16, 64,
            33, 17, 45, 29, 36, 20, 48, 32,
            9, 57,  5, 53, 12, 60,  8, 56,
            41, 25, 37, 21, 44, 28, 40, 24,
            3, 51, 15, 63,  2, 50, 14, 62,
            35, 19, 47, 31, 34, 18, 46, 30,
            11, 59,  7, 55, 10, 58,  6, 54,
            43, 27, 39, 23, 42, 26, 38, 22};
        int r = y * 8 + x;
    return dither[r] / 64; // same # of instructions as pre-dividing due to compiler magic
}


float dither367 = Dither8x8Bayer( fmod(clipScreen367.x, 8), fmod(clipScreen367.y, 8) );

GrabPass{ }

Pass
{
    fixed4 frag (v2f i ) : SV_Target
    {
        float4 screenColor371 = UNITY_SAMPLE_SCREENSPACE_TEXTURE(_GrabTexture,_Vector0);
    }
}

GrabPass{ }

Pass
{
            #if defined(UNITY_STEREO_INSTANCING_ENABLED) || defined(UNITY_STEREO_MULTIVIEW_ENABLED)
                #define ASE_DECLARE_SCREENSPACE_TEXTURE(tex) UNITY_DECLARE_SCREENSPACE_TEXTURE(tex);
            #else
                #define ASE_DECLARE_SCREENSPACE_TEXTURE(tex) UNITY_DECLARE_SCREENSPACE_TEXTURE(tex)
            #endif
    
            ASE_DECLARE_SCREENSPACE_TEXTURE( _GrabTexture )
            inline float4 ASE_ComputeGrabScreenPos( float4 pos )
            {
                #if UNITY_UV_STARTS_AT_TOP
                float scale = -1.0;
                #else
                float scale = 1.0;
                #endif
                float4 o = pos;
                o.y = pos.w * 0.5f;
                o.y = ( pos.y - o.y ) * _ProjectionParams.x * scale + o.y;
                return o;
            }

    
			v2f vert ( appdata v )
			{
				v2f o;
                float4 ase_clipPos = UnityObjectToClipPos(v.vertex);
				float4 screenPos = ComputeScreenPos(ase_clipPos);
				o.ase_texcoord = screenPos;
            }
    
    
			fixed4 frag (v2f i ) : SV_Target
			{
                float4 screenPos = i.ase_texcoord;
				float4 ase_grabScreenPos = ASE_ComputeGrabScreenPos( screenPos );
				float4 ase_grabScreenPosNorm = ase_grabScreenPos / ase_grabScreenPos.w;
				float4 screenColor371 = UNITY_SAMPLE_SCREENSPACE_TEXTURE(_GrabTexture,ase_grabScreenPosNorm.xy);
            }

}

unity_OrthoParams.x; //Ortho Cam Width: 正交摄像机的宽度
unity_OrthoParams.y; //Ortho Cam Height: 正交摄像机的高度
unity_OrthoParams.w; //Projection Mode: 投影模式， 0：透视投影， 1：正交投影

unity_CameraProjection:float4x4; // 投影矩阵
unity_CameraInvProjection:float4x4 // 投影逆矩阵

_ProjectionParams.x; // Flipped 翻转
_ProjectionParams.y; // Near Plane 近平面
_ProjectionParams.z; // Far Plane 远平面
_ProjectionParams.w; // 1 / Far Plane 返远平面

Pass
{
    
            #ifndef UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX
                //only defining to not throw compilation error over Unity 5.5
                #define UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input)
            #endif
    
			UNITY_DECLARE_DEPTH_TEXTURE( _CameraDepthTexture );
			uniform float4 _CameraDepthTexture_TexelSize;
    
    	
			v2f vert ( appdata v )
			{
                float4 ase_clipPos = UnityObjectToClipPos(v.vertex);
				float4 screenPos = ComputeScreenPos(ase_clipPos);
				o.ase_texcoord = screenPos;
            }
    
    
			fixed4 frag (v2f i ) : SV_Target
			{
                
				UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(i);
                
                fixed4 finalColor;
				float4 screenPos = i.ase_texcoord;
				float4 ase_screenPosNorm = screenPos / screenPos.w;
				ase_screenPosNorm.z = ( UNITY_NEAR_CLIP_VALUE >= 0 ) ? ase_screenPosNorm.z : ase_screenPosNorm.z * 0.5 + 0.5;
				float eyeDepth388 = LinearEyeDepth(SAMPLE_DEPTH_TEXTURE( _CameraDepthTexture, ase_screenPosNorm.xy ));
				
            }
    
}

			fixed4 frag (v2f i ) : SV_Target
			{
				UNITY_SETUP_INSTANCE_ID(i);
				UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(i);
				fixed4 finalColor;
				float4 screenPos = i.ase_texcoord;
				float4 ase_screenPosNorm = screenPos / screenPos.w;
				ase_screenPosNorm.z = ( UNITY_NEAR_CLIP_VALUE >= 0 ) ? ase_screenPosNorm.z : ase_screenPosNorm.z * 0.5 + 0.5;
				float eyeDepth388 = (SAMPLE_DEPTH_TEXTURE( _CameraDepthTexture, ase_screenPosNorm.xy )*( _ProjectionParams.z - _ProjectionParams.y ));
			}

			fixed4 frag (v2f i ) : SV_Target
			{
				UNITY_SETUP_INSTANCE_ID(i);
				UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(i);
				fixed4 finalColor;
				float4 screenPos = i.ase_texcoord;
				float4 ase_screenPosNorm = screenPos / screenPos.w;
				ase_screenPosNorm.z = ( UNITY_NEAR_CLIP_VALUE >= 0 ) ? ase_screenPosNorm.z : ase_screenPosNorm.z * 0.5 + 0.5;
				float clampDepth388 = SAMPLE_DEPTH_TEXTURE( _CameraDepthTexture, ase_screenPosNorm.xy );
            }

_ScreenParams.x; // RT Width, 当前渲染目标/屏幕宽度（以像素为单位）
_ScreenParams.y; // RT Height, 当前渲染目标/屏幕高度（以像素为单位）
_ScreenParams.z; // 1 + 1 / Width, 当前渲染目标/屏幕的反转宽度（以像素为单位）加1
_ScreenParams.w; // 1 + 1 / Height, 当前渲染目标/屏幕的反向高度（以像素为单位）加1

			v2f vert ( appdata v )
			{
				
				float4 ase_clipPos = UnityObjectToClipPos(v.vertex);
				float4 screenPos = ComputeScreenPos(ase_clipPos);
				o.ase_texcoord = screenPos;
			}
			
			
			fixed4 frag (v2f i ) : SV_Target
			{
				float4 screenPos = i.ase_texcoord;
				float4 ase_screenPosNorm = screenPos / screenPos.w;
				ase_screenPosNorm.z = ( UNITY_NEAR_CLIP_VALUE >= 0 ) ? ase_screenPosNorm.z : ase_screenPosNorm.z * 0.5 + 0.5;
				float4 temp_cast_0 = (ase_screenPosNorm.x).xxxx;
				
				
				finalColor = temp_cast_0;
				return finalColor;
			}

			v2f vert ( appdata v )
			{
				v2f o;

				float3 ase_worldPos = mul(unity_ObjectToWorld, v.vertex).xyz;
				o.ase_texcoord.xyz = ase_worldPos;
				
				
				//setting value to unused interpolator channels and avoid initialization warnings
				o.ase_texcoord.w = 0;
            }


			fixed4 frag (v2f i ) : SV_Target
			{
				fixed4 finalColor;
				float3 ase_worldPos = i.ase_texcoord.xyz;
				float3 ase_worldViewDir = UnityWorldSpaceViewDir(ase_worldPos);
				ase_worldViewDir = Unity_SafeNormalize( ase_worldViewDir );
                // ase_worldViewDir = normalize(ase_worldViewDir);
				float4 temp_cast_0 = (ase_worldViewDir.x).xxxx;
				
				
				finalColor = temp_cast_0;
				return finalColor;
			}

			struct appdata
			{
				float4 vertex : POSITION;
				float4 color : COLOR;
				UNITY_VERTEX_INPUT_INSTANCE_ID
				float4 ase_tangent : TANGENT;
				float3 ase_normal : NORMAL;
			};
                
			struct v2f
			{
				float4 vertex : SV_POSITION;
				UNITY_VERTEX_INPUT_INSTANCE_ID
				UNITY_VERTEX_OUTPUT_STEREO
				float4 ase_texcoord : TEXCOORD0;
				float4 ase_texcoord1 : TEXCOORD1;
				float4 ase_texcoord2 : TEXCOORD2;
				float4 ase_texcoord3 : TEXCOORD3;
			};
			
			v2f vert ( appdata v )
			{
				v2f o;

                // 切线，世界坐标系
				float3 ase_worldTangent = UnityObjectToWorldDir(v.ase_tangent);
				o.ase_texcoord.xyz = ase_worldTangent;
                
                // 法线，世界坐标系
				float3 ase_worldNormal = UnityObjectToWorldNormal(v.ase_normal);
				o.ase_texcoord1.xyz = ase_worldNormal;
                
                // 法线和切线垂直面，世界坐标系
				float ase_vertexTangentSign = v.ase_tangent.w * unity_WorldTransformParams.w;
				float3 ase_worldBitangent = cross( ase_worldNormal, ase_worldTangent ) * ase_vertexTangentSign;
				o.ase_texcoord2.xyz = ase_worldBitangent;
                
                // 位置，世界坐标系
				float3 ase_worldPos = mul(unity_ObjectToWorld, v.vertex).xyz;
				o.ase_texcoord3.xyz = ase_worldPos;
            }


			fixed4 frag (v2f i ) : SV_Target
			{
				fixed4 finalColor;
				float3 ase_worldTangent = i.ase_texcoord.xyz;
				float3 ase_worldNormal = i.ase_texcoord1.xyz;
				float3 ase_worldBitangent = i.ase_texcoord2.xyz;
                
				float3 tanToWorld0 = float3( ase_worldTangent.x, ase_worldBitangent.x, ase_worldNormal.x );
				float3 tanToWorld1 = float3( ase_worldTangent.y, ase_worldBitangent.y, ase_worldNormal.y );
				float3 tanToWorld2 = float3( ase_worldTangent.z, ase_worldBitangent.z, ase_worldNormal.z );
                
				float3 ase_worldPos = i.ase_texcoord3.xyz;
				float3 ase_worldViewDir = UnityWorldSpaceViewDir(ase_worldPos);
				ase_worldViewDir = normalize(ase_worldViewDir);
                
				float3 ase_tanViewDir =  tanToWorld0 * ase_worldViewDir.x + tanToWorld1 * ase_worldViewDir.y  + tanToWorld2 * ase_worldViewDir.z;
				ase_tanViewDir = normalize(ase_tanViewDir);
				
				
				finalColor = float4( ase_tanViewDir , 0.0 );
				return finalColor;
			}

_WorldSpaceCameraPos:float3:

_ZBufferParams.x; // 1 - far/near
_ZBufferParams.y; // far / near
_ZBufferParams.z; // ( 1 - far plane / near plane ) / far 
_ZBufferParams.w; //  ( far plane / near plane ) / far

			struct Gradient
			{
				int type;
				int colorsLength;
				int alphasLength;
				float4 colors[8];
				float2 alphas[8];
			};
			
			Gradient NewGradient(int type, int colorsLength, int alphasLength, 
			float4 colors0, float4 colors1, float4 colors2, float4 colors3, float4 colors4, float4 colors5, float4 colors6, float4 colors7,
			float2 alphas0, float2 alphas1, float2 alphas2, float2 alphas3, float2 alphas4, float2 alphas5, float2 alphas6, float2 alphas7)
			{
				Gradient g;
				g.type = type;
				g.colorsLength = colorsLength;
				g.alphasLength = alphasLength;
				g.colors[ 0 ] = colors0;
				g.colors[ 1 ] = colors1;
				g.colors[ 2 ] = colors2;
				g.colors[ 3 ] = colors3;
				g.colors[ 4 ] = colors4;
				g.colors[ 5 ] = colors5;
				g.colors[ 6 ] = colors6;
				g.colors[ 7 ] = colors7;
				g.alphas[ 0 ] = alphas0;
				g.alphas[ 1 ] = alphas1;
				g.alphas[ 2 ] = alphas2;
				g.alphas[ 3 ] = alphas3;
				g.alphas[ 4 ] = alphas4;
				g.alphas[ 5 ] = alphas5;
				g.alphas[ 6 ] = alphas6;
				g.alphas[ 7 ] = alphas7;
				return g;
			}
			
			float4 SampleGradient( Gradient gradient, float time )
			{
				float3 color = gradient.colors[0].rgb;
				UNITY_UNROLL
				for (int c = 1; c < 8; c++)
				{
				float colorPos = saturate((time - gradient.colors[c-1].w) / (gradient.colors[c].w - gradient.colors[c-1].w)) * step(c, (float)gradient.colorsLength-1);
				color = lerp(color, gradient.colors[c].rgb, lerp(colorPos, step(0.01, colorPos), gradient.type));
				}
				#ifndef UNITY_COLORSPACE_GAMMA
				color = half3(GammaToLinearSpaceExact(color.r), GammaToLinearSpaceExact(color.g), GammaToLinearSpaceExact(color.b));
				#endif
				float alpha = gradient.alphas[0].x;
				UNITY_UNROLL
				for (int a = 1; a < 8; a++)
				{
				float alphaPos = saturate((time - gradient.alphas[a-1].y) / (gradient.alphas[a].y - gradient.alphas[a-1].y)) * step(a, (float)gradient.alphasLength-1);
				alpha = lerp(alpha, gradient.alphas[a].x, lerp(alphaPos, step(0.01, alphaPos), gradient.type));
				}
				return float4(color, alpha);
			}
			


			fixed4 frag (v2f i ) : SV_Target
			{
				fixed4 finalColor;
				Gradient gradient414 = NewGradient( 0, 2, 2, float4( 1, 0, 0, 0.2500038 ), float4( 1, 1, 1, 0.9499962 ), 0, 0, 0, 0, 0, 0, float2( 0.6627451, 0.319997 ), float2( 1, 0.9000076 ), 0, 0, 0, 0, 0, 0 );
				float2 uv0421 = i.ase_texcoord.xy * float2( 1,1 ) + float2( 0,0 );
				
				
				finalColor = SampleGradient( gradient414, uv0421.y );
				return finalColor;
			}

UNITY_PI

6.28318548202515

	Properties
	{
		_ColorBase("ColorBase", Color) = (1,1,1,0)
		_Specular("Specular", Range( 0 , 5)) = 1.930303
		_Glosss("Glosss", Range( 0 , 5)) = 0.4863844
		_LightWrapping("LightWrapping", Range( 0 , 5)) = 0
		[Normal]_TextureNormal("TextureNormal", 2D) = "white" {}
		[HideInInspector] _texcoord( "", 2D ) = "white" {}

	}


	SubShader
	{
        
		
		Pass
		{
            
			struct appdata
			{
				float4 vertex : POSITION;
				float4 color : COLOR;
				UNITY_VERTEX_INPUT_INSTANCE_ID
				float4 ase_texcoord : TEXCOORD0;
				float4 ase_tangent : TANGENT;
				float3 ase_normal : NORMAL;
			};
			
			struct v2f
			{
				float4 vertex : SV_POSITION;
				UNITY_VERTEX_INPUT_INSTANCE_ID
				UNITY_VERTEX_OUTPUT_STEREO
				float4 ase_texcoord : TEXCOORD0;
				float4 ase_texcoord1 : TEXCOORD1;
				float4 ase_texcoord2 : TEXCOORD2;
				float4 ase_texcoord3 : TEXCOORD3;
				float4 ase_texcoord4 : TEXCOORD4;
				UNITY_SHADOW_COORDS(5)
			};
                
                
			uniform float _LightWrapping;
			uniform sampler2D _TextureNormal;
			uniform float4 _TextureNormal_ST;
			uniform float4 _ColorBase;
			uniform float _Glosss;
			uniform float _Specular;
            
			v2f vert ( appdata v )
			{
				v2f o;
				UNITY_SETUP_INSTANCE_ID(v);
				UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
				UNITY_TRANSFER_INSTANCE_ID(v, o);

				// 切线，世界坐标系
				float3 ase_worldTangent = UnityObjectToWorldDir(v.ase_tangent);
				o.ase_texcoord1.xyz = ase_worldTangent;

				// 法线，世界坐标系
				float3 ase_worldNormal = UnityObjectToWorldNormal(v.ase_normal);
				o.ase_texcoord2.xyz = ase_worldNormal;

				// 切线和法线垂直面，世界坐标系
				float ase_vertexTangentSign = v.ase_tangent.w * unity_WorldTransformParams.w;
				float3 ase_worldBitangent = cross( ase_worldNormal, ase_worldTangent ) * ase_vertexTangentSign;
				o.ase_texcoord3.xyz = ase_worldBitangent;

				// 位置，世界坐标系
				float3 ase_worldPos = mul(unity_ObjectToWorld, v.vertex).xyz;
				o.ase_texcoord4.xyz = ase_worldPos;
				
				o.ase_texcoord.xy = v.ase_texcoord.xy;
				
				//setting value to unused interpolator channels and avoid initialization warnings
				o.ase_texcoord.zw = 0;
				o.ase_texcoord1.w = 0;
				o.ase_texcoord2.w = 0;
				o.ase_texcoord3.w = 0;
				o.ase_texcoord4.w = 0;
				float3 vertexValue = float3(0, 0, 0);
				#if ASE_ABSOLUTE_VERTEX_POS
				vertexValue = v.vertex.xyz;
				#endif
				vertexValue = vertexValue;
				#if ASE_ABSOLUTE_VERTEX_POS
				v.vertex.xyz = vertexValue;
				#else
				v.vertex.xyz += vertexValue;
				#endif
				o.vertex = UnityObjectToClipPos(v.vertex);
				return o;
			}
			
			fixed4 frag (v2f i ) : SV_Target
			{
				UNITY_SETUP_INSTANCE_ID(i);
				UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(i);
				fixed4 finalColor;

				float3 LightWrapVector47_g1 = (( _LightWrapping * 0.5 )).xxx;

				// 法线贴图UV
				float2 uv_TextureNormal = i.ase_texcoord.xy * _TextureNormal_ST.xy + _TextureNormal_ST.zw;

				// 切线，世界坐标系
				float3 ase_worldTangent = i.ase_texcoord1.xyz;

				// 法线，世界坐标系
				float3 ase_worldNormal = i.ase_texcoord2.xyz;

				// 切线和法线垂直面，世界坐标系
				float3 ase_worldBitangent = i.ase_texcoord3.xyz;

				float3 tanToWorld0 = float3( ase_worldTangent.x, ase_worldBitangent.x, ase_worldNormal.x );
				float3 tanToWorld1 = float3( ase_worldTangent.y, ase_worldBitangent.y, ase_worldNormal.y );
				float3 tanToWorld2 = float3( ase_worldTangent.z, ase_worldBitangent.z, ase_worldNormal.z );

				// 法线贴图
				float3 tanNormal19_g1 = UnpackNormal( tex2D( _TextureNormal, uv_TextureNormal ) );
				// 法线贴图, 世界坐标系
				float3 worldNormal19_g1 = normalize( float3(dot(tanToWorld0,tanNormal19_g1), dot(tanToWorld1,tanNormal19_g1), dot(tanToWorld2,tanNormal19_g1)) );
				float3 CurrentNormal23_g1 = worldNormal19_g1;

				// 位置， 世界坐标系
				float3 ase_worldPos = i.ase_texcoord4.xyz;
				// 顶点灯光方向， 世界坐标系
				float3 worldSpaceLightDir = UnityWorldSpaceLightDir(ase_worldPos);

				// 光照
				float dotResult20_g1 = dot( CurrentNormal23_g1 , worldSpaceLightDir );
				float NDotL21_g1 = dotResult20_g1;

				// 灯光颜色
				#if defined(LIGHTMAP_ON) && ( UNITY_VERSION < 560 || ( defined(LIGHTMAP_SHADOW_MIXING) && !defined(SHADOWS_SHADOWMASK) && defined(SHADOWS_SCREEN) ) )//aselc
				float4 ase_lightColor = 0;
				#else //aselc
				float4 ase_lightColor = _LightColor0;
				#endif //aselc

				// 自身接收的阴影
				UNITY_LIGHT_ATTENUATION(ase_atten, i, ase_worldPos)
				float3 AttenuationColor8_g1 = ( ase_lightColor.rgb * ase_atten );

				float3 DiffuseColor70_g1 = ( ( ( max( ( LightWrapVector47_g1 + ( ( 1.0 - LightWrapVector47_g1 ) * NDotL21_g1 ) ) , float3(0,0,0) ) * AttenuationColor8_g1 ) + (UNITY_LIGHTMODEL_AMBIENT).rgb ) * _ColorBase.rgb );
				float3 normalizeResult77_g1 = normalize( _WorldSpaceLightPos0.xyz );
				float3 ase_worldViewDir = UnityWorldSpaceViewDir(ase_worldPos);
				ase_worldViewDir = normalize(ase_worldViewDir);
				float3 normalizeResult28_g1 = normalize( ( normalizeResult77_g1 + ase_worldViewDir ) );
				float3 HalfDirection29_g1 = normalizeResult28_g1;
				float dotResult32_g1 = dot( HalfDirection29_g1 , CurrentNormal23_g1 );
				float SpecularPower14_g1 = exp2( ( ( _Glosss * 10.0 ) + 1.0 ) );
				float3 specularFinalColor42_g1 = ( AttenuationColor8_g1 * pow( max( dotResult32_g1 , 0.0 ) , SpecularPower14_g1 ) * _Specular );
				
				
				finalColor = float4( ( DiffuseColor70_g1 + specularFinalColor42_g1 ) , 0.0 );
				return finalColor;
			}

        }
    }

	Properties
	{
		_Center("Center", Vector) = (0,0,0,0)
		_Size("Size", Vector) = (1,1,1,0)
		_Falloff("Falloff", Int) = 0

	}

	SubShader
	{
		
		Pass
		{
            
			struct appdata
			{
				float4 vertex : POSITION;
				float4 color : COLOR;
				UNITY_VERTEX_INPUT_INSTANCE_ID
				
			};
			
			struct v2f
			{
				float4 vertex : SV_POSITION;
				UNITY_VERTEX_INPUT_INSTANCE_ID
				UNITY_VERTEX_OUTPUT_STEREO
				float4 ase_texcoord : TEXCOORD0;
			};

			uniform float3 _Center;
			uniform float3 _Size;
			uniform int _Falloff;
            
            
			v2f vert ( appdata v )
			{
				v2f o;

				float3 ase_worldPos = mul(unity_ObjectToWorld, v.vertex).xyz;
				o.ase_texcoord.xyz = ase_worldPos;
				
				
				//setting value to unused interpolator channels and avoid initialization warnings
				o.ase_texcoord.w = 0;
            }
            
            
			fixed4 frag (v2f i ) : SV_Target
			{
				fixed4 finalColor;
				float3 ase_worldPos = i.ase_texcoord.xyz;
				float4 temp_cast_1 = (( distance( max( ( abs( ( ase_worldPos - _Center ) ) - ( _Size * float3( 0.5,0.5,0.5 ) ) ) , float3( 0,0,0 ) ) , float3( 0,0,0 ) ) / (float)_Falloff )).xxxx;
				
				
				finalColor = temp_cast_1;
				return finalColor;
			}
        }
    }

Shader "TestNode"
{
	Properties
	{
		_FireTexture("Fire Texture", 2D) = "white" {}
		_BurnMask("Burn Mask", 2D) = "white" {}
		_FireIntensity("Fire Intensity", Range( 0 , 5)) = 3.529412
		[HideInInspector] _texcoord( "", 2D ) = "white" {}

	}
	
	SubShader
	{
		
		
		Tags { "RenderType"="Opaque" }
	LOD 100

		CGINCLUDE
		#pragma target 3.0
		ENDCG
		Blend Off
		Cull Back
		ColorMask RGBA
		ZWrite On
		ZTest LEqual
		Offset 0 , 0
		
		
		
		Pass
		{
			Name "Unlit"
			Tags { "LightMode"="ForwardBase"  }
			CGPROGRAM

			

			#ifndef UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX
			//only defining to not throw compilation error over Unity 5.5
			#define UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input)
			#endif
			#pragma vertex vert
			#pragma fragment frag
			#pragma multi_compile_instancing
			#include "UnityCG.cginc"
			#include "UnityShaderVariables.cginc"


			struct appdata
			{
				float4 vertex : POSITION;
				float4 color : COLOR;
				UNITY_VERTEX_INPUT_INSTANCE_ID
				float4 ase_texcoord : TEXCOORD0;
			};
			
			struct v2f
			{
				float4 vertex : SV_POSITION;
				UNITY_VERTEX_INPUT_INSTANCE_ID
				UNITY_VERTEX_OUTPUT_STEREO
				float4 ase_texcoord : TEXCOORD0;
			};

			uniform sampler2D _BurnMask;
			uniform float4 _BurnMask_ST;
			uniform sampler2D _FireTexture;
			uniform float _FireIntensity;

			
			v2f vert ( appdata v )
			{
				v2f o;
				UNITY_SETUP_INSTANCE_ID(v);
				UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
				UNITY_TRANSFER_INSTANCE_ID(v, o);

				o.ase_texcoord.xy = v.ase_texcoord.xy;
				
				//setting value to unused interpolator channels and avoid initialization warnings
				o.ase_texcoord.zw = 0;
				float3 vertexValue = float3(0, 0, 0);
				#if ASE_ABSOLUTE_VERTEX_POS
				vertexValue = v.vertex.xyz;
				#endif
				vertexValue = vertexValue;
				#if ASE_ABSOLUTE_VERTEX_POS
				v.vertex.xyz = vertexValue;
				#else
				v.vertex.xyz += vertexValue;
				#endif
				o.vertex = UnityObjectToClipPos(v.vertex);
				return o;
			}
			
			fixed4 frag (v2f i ) : SV_Target
			{
				UNITY_SETUP_INSTANCE_ID(i);
				UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(i);
				fixed4 finalColor;
				float2 uv_BurnMask = i.ase_texcoord.xy * _BurnMask_ST.xy + _BurnMask_ST.zw;
				float2 panner2_g4 = ( _Time.x * float2( -1,0 ) + i.ase_texcoord.xy);
				
				
				finalColor = ( ( tex2D( _BurnMask, uv_BurnMask ) * tex2D( _FireTexture, panner2_g4 ) ) * ( _FireIntensity * ( _SinTime.w + 1.5 ) ) );
				return finalColor;
			}
			ENDCG
		}
	}
	CustomEditor "ASEMaterialInspector"
	
	
}

Shader "TestNode"
{
	Properties
	{
		_MaskColor("MaskColor", Color) = (0.5566038,0.3019313,0.3019313,0)
		_Texture0("Texture 0", 2D) = "white" {}
		_Range("Range", Range( 0 , 1)) = 0.4294117
		_Fuzziness("Fuzziness", Range( 0 , 1)) = 0.5235294

	}
	
	SubShader
	{
		
		
		Tags { "RenderType"="Opaque" }
	LOD 100

		CGINCLUDE
		#pragma target 3.0
		ENDCG
		Blend Off
		Cull Back
		ColorMask RGBA
		ZWrite On
		ZTest LEqual
		Offset 0 , 0
		
		
		
		Pass
		{
			Name "Unlit"
			Tags { "LightMode"="ForwardBase"  }
			CGPROGRAM

			

			#ifndef UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX
			//only defining to not throw compilation error over Unity 5.5
			#define UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input)
			#endif
			#pragma vertex vert
			#pragma fragment frag
			#pragma multi_compile_instancing
			#include "UnityCG.cginc"
			

			struct appdata
			{
				float4 vertex : POSITION;
				float4 color : COLOR;
				UNITY_VERTEX_INPUT_INSTANCE_ID
				float4 ase_texcoord : TEXCOORD0;
			};
			
			struct v2f
			{
				float4 vertex : SV_POSITION;
				UNITY_VERTEX_INPUT_INSTANCE_ID
				UNITY_VERTEX_OUTPUT_STEREO
				float4 ase_texcoord : TEXCOORD0;
			};

			uniform float4 _MaskColor;
			uniform sampler2D _Texture0;
			uniform float4 _Texture0_ST;
			uniform float _Range;
			uniform float _Fuzziness;

			
			v2f vert ( appdata v )
			{
				v2f o;
				UNITY_SETUP_INSTANCE_ID(v);
				UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
				UNITY_TRANSFER_INSTANCE_ID(v, o);

				o.ase_texcoord.xy = v.ase_texcoord.xy;
				
				//setting value to unused interpolator channels and avoid initialization warnings
				o.ase_texcoord.zw = 0;
				float3 vertexValue = float3(0, 0, 0);
				#if ASE_ABSOLUTE_VERTEX_POS
				vertexValue = v.vertex.xyz;
				#endif
				vertexValue = vertexValue;
				#if ASE_ABSOLUTE_VERTEX_POS
				v.vertex.xyz = vertexValue;
				#else
				v.vertex.xyz += vertexValue;
				#endif
				o.vertex = UnityObjectToClipPos(v.vertex);
				return o;
			}
			
			fixed4 frag (v2f i ) : SV_Target
			{
				UNITY_SETUP_INSTANCE_ID(i);
				UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(i);
				fixed4 finalColor;
				float2 uv0_Texture0 = i.ase_texcoord.xy * _Texture0_ST.xy + _Texture0_ST.zw;
				float4 temp_cast_2 = (saturate( ( 1.0 - ( ( distance( _MaskColor.rgb , tex2D( _Texture0, uv0_Texture0 ).rgb ) - _Range ) / max( _Fuzziness , 1E-05 ) ) ) )).xxxx;
				
				
				finalColor = temp_cast_2;
				return finalColor;
			}
			ENDCG
		}
	}
	CustomEditor "ASEMaterialInspector"
	
	
}

( _Input + _Bias ) * _Scale );