#ifndef UNITY_CG_INCLUDED

#define UNITY_CG_INCLUDED

#define UNITY_PI 3.14159265359f

#define UNITY_TWO_PI 6.28318530718f

#define UNITY_FOUR_PI 12.56637061436f

#define UNITY_INV_PI 0.31830988618f

#define UNITY_INV_TWO_PI 0.15915494309f

#define UNITY_INV_FOUR_PI 0.07957747155f

#define UNITY_HALF_PI 1.57079632679f

#define UNITY_INV_HALF_PI 0.636619772367f

#define UNITY_SHOULD_SAMPLE_SH (defined(LIGHTPROBE_SH) && !defined(UNITY_PASS_FORWARDADD) && !defined(UNITY_PASS_PREPASSBASE) && !defined(UNITY_PASS_SHADOWCASTER) && !defined(UNITY_PASS_META))

#include "UnityShaderVariables.cginc"

#include "UnityShaderUtilities.cginc"

#include "UnityInstancing.cginc"

#ifdef UNITY_COLORSPACE_GAMMA

#define unity_ColorSpaceGrey fixed4(0.5, 0.5, 0.5, 0.5)

#define unity_ColorSpaceDouble fixed4(2.0, 2.0, 2.0, 2.0)

#define unity_ColorSpaceDielectricSpec half4(0.220916301, 0.220916301, 0.220916301, 1.0 - 0.220916301)

#define unity_ColorSpaceLuminance half4(0.22, 0.707, 0.071, 0.0) // Legacy: alpha is set to 0.0 to specify gamma mode

#else // Linear values

#define unity_ColorSpaceGrey fixed4(0.214041144, 0.214041144, 0.214041144, 0.5)

#define unity_ColorSpaceDouble fixed4(4.59479380, 4.59479380, 4.59479380, 2.0)

#define unity_ColorSpaceDielectricSpec half4(0.04, 0.04, 0.04, 1.0 - 0.04) // standard dielectric reflectivity coef at incident angle (= 4%)

#define unity_ColorSpaceLuminance half4(0.0396819152, 0.458021790, 0.00609653955, 1.0) // Legacy: alpha is set to 1.0 to specify linear mode

#if defined (DIRECTIONAL) || defined (DIRECTIONAL_COOKIE) || defined (POINT) || defined (SPOT) || defined (POINT_NOATT) || defined (POINT_COOKIE)

#define USING_LIGHT_MULTI_COMPILE

#if defined(SHADER_API_D3D11) || defined(SHADER_API_PSSL) || defined(SHADER_API_METAL) || defined(SHADER_API_GLCORE) || defined(SHADER_API_GLES3) || defined(SHADER_API_VULKAN) || defined(SHADER_API_SWITCH) // D3D11, D3D12, XB1, PS4, iOS, macOS, tvOS, glcore, gles3, webgl2.0, Switch

#define SHADOWS_CUBE_IN_DEPTH_TEX

#define SCALED_NORMAL v.normal

#define LIGHTMAP_RGBM_SCALE 5.0

#define EMISSIVE_RGBM_SCALE 97.0

struct appdata_base {

float4 vertex : POSITION;

float3 normal : NORMAL;

float4 texcoord : TEXCOORD0;

UNITY_VERTEX_INPUT_INSTANCE_ID

};

struct appdata_tan {

float4 vertex : POSITION;

float4 tangent : TANGENT;

float3 normal : NORMAL;

float4 texcoord : TEXCOORD0;

UNITY_VERTEX_INPUT_INSTANCE_ID

};

struct appdata_full {

float4 vertex : POSITION;

float4 tangent : TANGENT;

float3 normal : NORMAL;

float4 texcoord : TEXCOORD0;

float4 texcoord1 : TEXCOORD1;

float4 texcoord2 : TEXCOORD2;

float4 texcoord3 : TEXCOORD3;

fixed4 color : COLOR;

UNITY_VERTEX_INPUT_INSTANCE_ID

};

inline bool IsGammaSpace()

{

#ifdef UNITY_COLORSPACE_GAMMA

return true;

return false;

}

inline float GammaToLinearSpaceExact (float value)

{

if (value <= 0.04045F)

return value / 12.92F;

else if (value < 1.0F)

return pow((value + 0.055F)/1.055F, 2.4F);

else

return pow(value, 2.2F);

}

inline half3 GammaToLinearSpace (half3 sRGB)

{

// Approximate version from http://chilliant.blogspot.com.au/2012/08/srgb-approximations-for-hlsl.html?m=1

return sRGB * (sRGB * (sRGB * 0.305306011h + 0.682171111h) + 0.012522878h);

// Precise version, useful for debugging.

//return half3(GammaToLinearSpaceExact(sRGB.r), GammaToLinearSpaceExact(sRGB.g), GammaToLinearSpaceExact(sRGB.b));

}

inline float LinearToGammaSpaceExact (float value)

{

if (value <= 0.0F)

return 0.0F;

else if (value <= 0.0031308F)

return 12.92F * value;

else if (value < 1.0F)

return 1.055F * pow(value, 0.4166667F) - 0.055F;

else

return pow(value, 0.45454545F);

}

inline half3 LinearToGammaSpace (half3 linRGB)

{

linRGB = max(linRGB, half3(0.h, 0.h, 0.h));

// An almost-perfect approximation from http://chilliant.blogspot.com.au/2012/08/srgb-approximations-for-hlsl.html?m=1

return max(1.055h * pow(linRGB, 0.416666667h) - 0.055h, 0.h);

// Exact version, useful for debugging.

//return half3(LinearToGammaSpaceExact(linRGB.r), LinearToGammaSpaceExact(linRGB.g), LinearToGammaSpaceExact(linRGB.b));

}

inline float4 UnityWorldToClipPos( in float3 pos )

{

return mul(UNITY_MATRIX_VP, float4(pos, 1.0));

}

inline float4 UnityViewToClipPos( in float3 pos )

{

return mul(UNITY_MATRIX_P, float4(pos, 1.0));

}

inline float3 UnityObjectToViewPos( in float3 pos )

{

return mul(UNITY_MATRIX_V, mul(unity_ObjectToWorld, float4(pos, 1.0))).xyz;

}

inline float3 UnityObjectToViewPos(float4 pos) // overload for float4; avoids "implicit truncation" warning for existing shaders

{

return UnityObjectToViewPos(pos.xyz);

}

inline float3 UnityWorldToViewPos( in float3 pos )

{

return mul(UNITY_MATRIX_V, float4(pos, 1.0)).xyz;

}

inline float3 UnityObjectToWorldDir( in float3 dir )

{

return normalize(mul((float3x3)unity_ObjectToWorld, dir));

}

inline float3 UnityWorldToObjectDir( in float3 dir )

{

return normalize(mul((float3x3)unity_WorldToObject, dir));

}

inline float3 UnityObjectToWorldNormal( in float3 norm )

{

#ifdef UNITY_ASSUME_UNIFORM_SCALING

return UnityObjectToWorldDir(norm);

// mul(IT_M, norm) => mul(norm, I_M) => {dot(norm, I_M.col0), dot(norm, I_M.col1), dot(norm, I_M.col2)}

return normalize(mul(norm, (float3x3)unity_WorldToObject));

}

inline float3 UnityWorldSpaceLightDir( in float3 worldPos )

{

#ifndef USING_LIGHT_MULTI_COMPILE

return _WorldSpaceLightPos0.xyz - worldPos * _WorldSpaceLightPos0.w;

#ifndef USING_DIRECTIONAL_LIGHT

return _WorldSpaceLightPos0.xyz - worldPos;

return _WorldSpaceLightPos0.xyz;

}

inline float3 WorldSpaceLightDir( in float4 localPos )

{

float3 worldPos = mul(unity_ObjectToWorld, localPos).xyz;

return UnityWorldSpaceLightDir(worldPos);

}

inline float3 ObjSpaceLightDir( in float4 v )

{

float3 objSpaceLightPos = mul(unity_WorldToObject, _WorldSpaceLightPos0).xyz;

#ifndef USING_LIGHT_MULTI_COMPILE

return objSpaceLightPos.xyz - v.xyz * _WorldSpaceLightPos0.w;

#ifndef USING_DIRECTIONAL_LIGHT

return objSpaceLightPos.xyz - v.xyz;

return objSpaceLightPos.xyz;

}

inline float3 UnityWorldSpaceViewDir( in float3 worldPos )

{

return _WorldSpaceCameraPos.xyz - worldPos;

}

inline float3 WorldSpaceViewDir( in float4 localPos )

{

float3 worldPos = mul(unity_ObjectToWorld, localPos).xyz;

return UnityWorldSpaceViewDir(worldPos);

}

inline float3 ObjSpaceViewDir( in float4 v )

{

float3 objSpaceCameraPos = mul(unity_WorldToObject, float4(_WorldSpaceCameraPos.xyz, 1)).xyz;

return objSpaceCameraPos - v.xyz;

}

#define TANGENT_SPACE_ROTATION \

float3 binormal = cross( normalize(v.normal), normalize(v.tangent.xyz) ) * v.tangent.w; \

float3x3 rotation = float3x3( v.tangent.xyz, binormal, v.normal )

float3 Shade4PointLights (

float4 lightPosX, float4 lightPosY, float4 lightPosZ,

float3 lightColor0, float3 lightColor1, float3 lightColor2, float3 lightColor3,

float4 lightAttenSq,

float3 pos, float3 normal)

{

// to light vectors

float4 toLightX = lightPosX - pos.x;

float4 toLightY = lightPosY - pos.y;

float4 toLightZ = lightPosZ - pos.z;

// squared lengths

float4 lengthSq = 0;

lengthSq += toLightX * toLightX;

lengthSq += toLightY * toLightY;

lengthSq += toLightZ * toLightZ;

// don't produce NaNs if some vertex position overlaps with the light

lengthSq = max(lengthSq, 0.000001);

// NdotL

float4 ndotl = 0;

ndotl += toLightX * normal.x;

ndotl += toLightY * normal.y;

ndotl += toLightZ * normal.z;

// correct NdotL

float4 corr = rsqrt(lengthSq);

ndotl = max (float4(0,0,0,0), ndotl * corr);

// attenuation

float4 atten = 1.0 / (1.0 + lengthSq * lightAttenSq);

float4 diff = ndotl * atten;

// final color

float3 col = 0;

col += lightColor0 * diff.x;

col += lightColor1 * diff.y;

col += lightColor2 * diff.z;

col += lightColor3 * diff.w;

return col;

}

float3 ShadeVertexLightsFull (float4 vertex, float3 normal, int lightCount, bool spotLight)

{

float3 viewpos = UnityObjectToViewPos (vertex.xyz);

float3 viewN = normalize (mul ((float3x3)UNITY_MATRIX_IT_MV, normal));

float3 lightColor = UNITY_LIGHTMODEL_AMBIENT.xyz;

for (int i = 0; i < lightCount; i++) {

float3 toLight = unity_LightPosition[i].xyz - viewpos.xyz * unity_LightPosition[i].w;

float lengthSq = dot(toLight, toLight);

// don't produce NaNs if some vertex position overlaps with the light

lengthSq = max(lengthSq, 0.000001);

toLight *= rsqrt(lengthSq);

float atten = 1.0 / (1.0 + lengthSq * unity_LightAtten[i].z);

if (spotLight)

{

float rho = max (0, dot(toLight, unity_SpotDirection[i].xyz));

float spotAtt = (rho - unity_LightAtten[i].x) * unity_LightAtten[i].y;

atten *= saturate(spotAtt);

}

float diff = max (0, dot (viewN, toLight));

lightColor += unity_LightColor[i].rgb * (diff * atten);

}

return lightColor;

}

float3 ShadeVertexLights (float4 vertex, float3 normal)

{

return ShadeVertexLightsFull (vertex, normal, 4, false);

}

half3 SHEvalLinearL0L1 (half4 normal)

{

half3 x;

// Linear (L1) + constant (L0) polynomial terms

x.r = dot(unity_SHAr,normal);

x.g = dot(unity_SHAg,normal);

x.b = dot(unity_SHAb,normal);

return x;

}

half3 SHEvalLinearL2 (half4 normal)

{

half3 x1, x2;

// 4 of the quadratic (L2) polynomials

half4 vB = normal.xyzz * normal.yzzx;

x1.r = dot(unity_SHBr,vB);

x1.g = dot(unity_SHBg,vB);

x1.b = dot(unity_SHBb,vB);

// Final (5th) quadratic (L2) polynomial

half vC = normal.x*normal.x - normal.y*normal.y;

x2 = unity_SHC.rgb * vC;

return x1 + x2;

}

half3 ShadeSH9 (half4 normal)

{

// Linear + constant polynomial terms

half3 res = SHEvalLinearL0L1 (normal);

// Quadratic polynomials

res += SHEvalLinearL2 (normal);

# ifdef UNITY_COLORSPACE_GAMMA

res = LinearToGammaSpace (res);

return res;

}

half3 ShadeSH3Order(half4 normal)

{

// Quadratic polynomials

half3 res = SHEvalLinearL2 (normal);

# ifdef UNITY_COLORSPACE_GAMMA

res = LinearToGammaSpace (res);

return res;

}

#if UNITY_LIGHT_PROBE_PROXY_VOLUME

half3 SHEvalLinearL0L1_SampleProbeVolume (half4 normal, float3 worldPos)

{

const float transformToLocal = unity_ProbeVolumeParams.y;

const float texelSizeX = unity_ProbeVolumeParams.z;

//The SH coefficients textures and probe occlusion are packed into 1 atlas.

//-------------------------

//| ShR | ShG | ShB | Occ |

//-------------------------

float3 position = (transformToLocal == 1.0f) ? mul(unity_ProbeVolumeWorldToObject, float4(worldPos, 1.0)).xyz : worldPos;

float3 texCoord = (position - unity_ProbeVolumeMin.xyz) * unity_ProbeVolumeSizeInv.xyz;

texCoord.x = texCoord.x * 0.25f;

// We need to compute proper X coordinate to sample.

// Clamp the coordinate otherwize we'll have leaking between RGB coefficients

float texCoordX = clamp(texCoord.x, 0.5f * texelSizeX, 0.25f - 0.5f * texelSizeX);

// sampler state comes from SHr (all SH textures share the same sampler)

texCoord.x = texCoordX;

half4 SHAr = UNITY_SAMPLE_TEX3D_SAMPLER(unity_ProbeVolumeSH, unity_ProbeVolumeSH, texCoord);

texCoord.x = texCoordX + 0.25f;

half4 SHAg = UNITY_SAMPLE_TEX3D_SAMPLER(unity_ProbeVolumeSH, unity_ProbeVolumeSH, texCoord);

texCoord.x = texCoordX + 0.5f;

half4 SHAb = UNITY_SAMPLE_TEX3D_SAMPLER(unity_ProbeVolumeSH, unity_ProbeVolumeSH, texCoord);

// Linear + constant polynomial terms

half3 x1;

x1.r = dot(SHAr, normal);

x1.g = dot(SHAg, normal);

x1.b = dot(SHAb, normal);

return x1;

}

half3 ShadeSH12Order (half4 normal)

{

// Linear + constant polynomial terms

half3 res = SHEvalLinearL0L1 (normal);

# ifdef UNITY_COLORSPACE_GAMMA

res = LinearToGammaSpace (res);

return res;

}

#define TRANSFORM_TEX(tex,name) (tex.xy * name##_ST.xy + name##_ST.zw)

#define TRANSFORM_UV(idx) v.texcoord.xy

struct v2f_vertex_lit {

float2 uv : TEXCOORD0;

fixed4 diff : COLOR0;

fixed4 spec : COLOR1;

};

inline fixed4 VertexLight( v2f_vertex_lit i, sampler2D mainTex )

{

fixed4 texcol = tex2D( mainTex, i.uv );

fixed4 c;

c.xyz = ( texcol.xyz * i.diff.xyz + i.spec.xyz * texcol.a );

c.w = texcol.w * i.diff.w;

return c;

}

inline float2 ParallaxOffset( half h, half height, half3 viewDir )

{

h = h * height - height/2.0;

float3 v = normalize(viewDir);

v.z += 0.42;

return h * (v.xy / v.z);

}

inline half Luminance(half3 rgb)

{

return dot(rgb, unity_ColorSpaceLuminance.rgb);

}

half LinearRgbToLuminance(half3 linearRgb)

{

return dot(linearRgb, half3(0.2126729f, 0.7151522f, 0.0721750f));

}

half4 UnityEncodeRGBM (half3 color, float maxRGBM)

{

float kOneOverRGBMMaxRange = 1.0 / maxRGBM;

const float kMinMultiplier = 2.0 * 1e-2;

float3 rgb = color * kOneOverRGBMMaxRange;

float alpha = max(max(rgb.r, rgb.g), max(rgb.b, kMinMultiplier));

alpha = ceil(alpha * 255.0) / 255.0;

// Division-by-zero warning from d3d9, so make compiler happy.

alpha = max(alpha, kMinMultiplier);

return half4(rgb / alpha, alpha);

}

inline half3 DecodeHDR (half4 data, half4 decodeInstructions)

{

// Take into account texture alpha if decodeInstructions.w is true(the alpha value affects the RGB channels)

half alpha = decodeInstructions.w * (data.a - 1.0) + 1.0;

// If Linear mode is not supported we can skip exponent part

#if defined(UNITY_COLORSPACE_GAMMA)

return (decodeInstructions.x * alpha) * data.rgb;

# if defined(UNITY_USE_NATIVE_HDR)

return decodeInstructions.x * data.rgb; // Multiplier for future HDRI relative to absolute conversion.

return (decodeInstructions.x * pow(alpha, decodeInstructions.y)) * data.rgb;

}

inline half3 DecodeLightmapRGBM (half4 data, half4 decodeInstructions)

{

// If Linear mode is not supported we can skip exponent part

#if defined(UNITY_COLORSPACE_GAMMA)

# if defined(UNITY_FORCE_LINEAR_READ_FOR_RGBM)

return (decodeInstructions.x * data.a) * sqrt(data.rgb);

return (decodeInstructions.x * data.a) * data.rgb;

return (decodeInstructions.x * pow(data.a, decodeInstructions.y)) * data.rgb;

}

inline half3 DecodeLightmapDoubleLDR( fixed4 color, half4 decodeInstructions)

{

// decodeInstructions.x contains 2.0 when gamma color space is used or pow(2.0, 2.2) = 4.59 when linear color space is used on mobile platforms

return decodeInstructions.x * color.rgb;

}

inline half3 DecodeLightmap( fixed4 color, half4 decodeInstructions)

{

#if defined(UNITY_LIGHTMAP_DLDR_ENCODING)

return DecodeLightmapDoubleLDR(color, decodeInstructions);

#elif defined(UNITY_LIGHTMAP_RGBM_ENCODING)

return DecodeLightmapRGBM(color, decodeInstructions);

#else //defined(UNITY_LIGHTMAP_FULL_HDR)

return color.rgb;

}

half4 unity_Lightmap_HDR;

inline half3 DecodeLightmap( fixed4 color )

{

return DecodeLightmap( color, unity_Lightmap_HDR );

}

half4 unity_DynamicLightmap_HDR;

inline half3 DecodeRealtimeLightmap( fixed4 color )

{

//@TODO: Temporary until Geomerics gives us an API to convert lightmaps to RGBM in gamma space on the enlighten thread before we upload the textures.

#if defined(UNITY_FORCE_LINEAR_READ_FOR_RGBM)

return pow ((unity_DynamicLightmap_HDR.x * color.a) * sqrt(color.rgb), unity_DynamicLightmap_HDR.y);

return pow ((unity_DynamicLightmap_HDR.x * color.a) * color.rgb, unity_DynamicLightmap_HDR.y);

}

inline half3 DecodeDirectionalLightmap (half3 color, fixed4 dirTex, half3 normalWorld)

{

// In directional (non-specular) mode Enlighten bakes dominant light direction

// in a way, that using it for half Lambert and then dividing by a "rebalancing coefficient"

// gives a result close to plain diffuse response lightmaps, but normalmapped.

// Note that dir is not unit length on purpose. Its length is "directionality", like

// for the directional specular lightmaps.

half halfLambert = dot(normalWorld, dirTex.xyz - 0.5) + 0.5;

return color * halfLambert / max(1e-4h, dirTex.w);

}

inline float4 EncodeFloatRGBA( float v )

{

float4 kEncodeMul = float4(1.0, 255.0, 65025.0, 16581375.0);

float kEncodeBit = 1.0/255.0;

float4 enc = kEncodeMul * v;

enc = frac (enc);

enc -= enc.yzww * kEncodeBit;

return enc;

}

inline float DecodeFloatRGBA( float4 enc )

{

float4 kDecodeDot = float4(1.0, 1/255.0, 1/65025.0, 1/16581375.0);

return dot( enc, kDecodeDot );

}

inline float2 EncodeFloatRG( float v )

{

float2 kEncodeMul = float2(1.0, 255.0);

float kEncodeBit = 1.0/255.0;

float2 enc = kEncodeMul * v;

enc = frac (enc);

enc.x -= enc.y * kEncodeBit;

return enc;

}

inline float DecodeFloatRG( float2 enc )

{

float2 kDecodeDot = float2(1.0, 1/255.0);

return dot( enc, kDecodeDot );

}

inline float2 EncodeViewNormalStereo( float3 n )

{

float kScale = 1.7777;

float2 enc;

enc = n.xy / (n.z+1);

enc /= kScale;

enc = enc*0.5+0.5;

return enc;

}

inline float3 DecodeViewNormalStereo( float4 enc4 )

{

float kScale = 1.7777;

float3 nn = enc4.xyz*float3(2*kScale,2*kScale,0) + float3(-kScale,-kScale,1);

float g = 2.0 / dot(nn.xyz,nn.xyz);

float3 n;

n.xy = g*nn.xy;

n.z = g-1;

return n;

}

inline float4 EncodeDepthNormal( float depth, float3 normal )

{

float4 enc;

enc.xy = EncodeViewNormalStereo (normal);

enc.zw = EncodeFloatRG (depth);

return enc;

}

inline void DecodeDepthNormal( float4 enc, out float depth, out float3 normal )

{

depth = DecodeFloatRG (enc.zw);

normal = DecodeViewNormalStereo (enc);

}

inline fixed3 UnpackNormalDXT5nm (fixed4 packednormal)

{

fixed3 normal;

normal.xy = packednormal.wy * 2 - 1;

normal.z = sqrt(1 - saturate(dot(normal.xy, normal.xy)));

return normal;

}

fixed3 UnpackNormalmapRGorAG(fixed4 packednormal)

{

// This do the trick

packednormal.x *= packednormal.w;

fixed3 normal;

normal.xy = packednormal.xy * 2 - 1;

normal.z = sqrt(1 - saturate(dot(normal.xy, normal.xy)));

return normal;

}

inline fixed3 UnpackNormal(fixed4 packednormal)

{

#if defined(UNITY_NO_DXT5nm)

return packednormal.xyz * 2 - 1;

return UnpackNormalmapRGorAG(packednormal);

}

fixed3 UnpackNormalWithScale(fixed4 packednormal, float scale)

{

#ifndef UNITY_NO_DXT5nm

// Unpack normal as DXT5nm (1, y, 1, x) or BC5 (x, y, 0, 1)

// Note neutral texture like "bump" is (0, 0, 1, 1) to work with both plain RGB normal and DXT5nm/BC5

packednormal.x *= packednormal.w;

fixed3 normal;

normal.xy = (packednormal.xy * 2 - 1) * scale;

normal.z = sqrt(1 - saturate(dot(normal.xy, normal.xy)));

return normal;

}

inline float Linear01Depth( float z )

{

return 1.0 / (_ZBufferParams.x * z + _ZBufferParams.y);

}

inline float LinearEyeDepth( float z )

{

return 1.0 / (_ZBufferParams.z * z + _ZBufferParams.w);

}

inline float2 UnityStereoScreenSpaceUVAdjustInternal(float2 uv, float4 scaleAndOffset)

{

return uv.xy * scaleAndOffset.xy + scaleAndOffset.zw;

}

inline float4 UnityStereoScreenSpaceUVAdjustInternal(float4 uv, float4 scaleAndOffset)

{

return float4(UnityStereoScreenSpaceUVAdjustInternal(uv.xy, scaleAndOffset), UnityStereoScreenSpaceUVAdjustInternal(uv.zw, scaleAndOffset));

}

#define UnityStereoScreenSpaceUVAdjust(x, y) UnityStereoScreenSpaceUVAdjustInternal(x, y)

#if defined(UNITY_SINGLE_PASS_STEREO)

float2 TransformStereoScreenSpaceTex(float2 uv, float w)

{

float4 scaleOffset = unity_StereoScaleOffset[unity_StereoEyeIndex];

return uv.xy * scaleOffset.xy + scaleOffset.zw * w;

}

inline float2 UnityStereoTransformScreenSpaceTex(float2 uv)

{

return TransformStereoScreenSpaceTex(saturate(uv), 1.0);

}

inline float4 UnityStereoTransformScreenSpaceTex(float4 uv)

{

return float4(UnityStereoTransformScreenSpaceTex(uv.xy), UnityStereoTransformScreenSpaceTex(uv.zw));

}

inline float2 UnityStereoClamp(float2 uv, float4 scaleAndOffset)

{

return float2(clamp(uv.x, scaleAndOffset.z, scaleAndOffset.z + scaleAndOffset.x), uv.y);

}

#define TransformStereoScreenSpaceTex(uv, w) uv

#define UnityStereoTransformScreenSpaceTex(uv) uv

#define UnityStereoClamp(uv, scaleAndOffset) uv

#define DECODE_EYEDEPTH(i) LinearEyeDepth(i)

#define COMPUTE_EYEDEPTH(o) o = -UnityObjectToViewPos( v.vertex ).z

#define COMPUTE_DEPTH_01 -(UnityObjectToViewPos( v.vertex ).z * _ProjectionParams.w)

#define COMPUTE_VIEW_NORMAL normalize(mul((float3x3)UNITY_MATRIX_IT_MV, v.normal))

struct appdata_img

{

float4 vertex : POSITION;

half2 texcoord : TEXCOORD0;

UNITY_VERTEX_INPUT_INSTANCE_ID

};

struct v2f_img

{

float4 pos : SV_POSITION;

half2 uv : TEXCOORD0;

UNITY_VERTEX_INPUT_INSTANCE_ID

UNITY_VERTEX_OUTPUT_STEREO

};

float2 MultiplyUV (float4x4 mat, float2 inUV) {

float4 temp = float4 (inUV.x, inUV.y, 0, 0);

temp = mul (mat, temp);

return temp.xy;

}

v2f_img vert_img( appdata_img v )

{

v2f_img o;

UNITY_INITIALIZE_OUTPUT(v2f_img, o);

UNITY_SETUP_INSTANCE_ID(v);

UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);

o.pos = UnityObjectToClipPos (v.vertex);

o.uv = v.texcoord;

return o;

}

#define V2F_SCREEN_TYPE float4

inline float4 ComputeNonStereoScreenPos(float4 pos) {

float4 o = pos * 0.5f;

o.xy = float2(o.x, o.y*_ProjectionParams.x) + o.w;

o.zw = pos.zw;

return o;

}

inline float4 ComputeScreenPos(float4 pos) {

float4 o = ComputeNonStereoScreenPos(pos);

#if defined(UNITY_SINGLE_PASS_STEREO)

o.xy = TransformStereoScreenSpaceTex(o.xy, pos.w);

return o;

}

inline float4 ComputeGrabScreenPos (float4 pos) {

#if UNITY_UV_STARTS_AT_TOP

float scale = -1.0;

float scale = 1.0;

float4 o = pos * 0.5f;

o.xy = float2(o.x, o.y*scale) + o.w;

#ifdef UNITY_SINGLE_PASS_STEREO

o.xy = TransformStereoScreenSpaceTex(o.xy, pos.w);

o.zw = pos.zw;

return o;

}

inline float4 UnityPixelSnap (float4 pos)

{

float2 hpc = _ScreenParams.xy * 0.5f;

#if SHADER_API_PSSL

float2 temp = ((pos.xy / pos.w) * hpc) + float2(0.5f,0.5f);

float2 pixelPos = float2(__v_floor_f32(temp.x), __v_floor_f32(temp.y));

float2 pixelPos = round ((pos.xy / pos.w) * hpc);

pos.xy = pixelPos / hpc * pos.w;

return pos;

}

inline float2 TransformViewToProjection (float2 v) {

return mul((float2x2)UNITY_MATRIX_P, v);

}

inline float3 TransformViewToProjection (float3 v) {

return mul((float3x3)UNITY_MATRIX_P, v);

}

float4 UnityEncodeCubeShadowDepth (float z)

{

#ifdef UNITY_USE_RGBA_FOR_POINT_SHADOWS

return EncodeFloatRGBA (min(z, 0.999));

return z;

}

float UnityDecodeCubeShadowDepth (float4 vals)

{

#ifdef UNITY_USE_RGBA_FOR_POINT_SHADOWS

return DecodeFloatRGBA (vals);

return vals.r;

}

float4 UnityClipSpaceShadowCasterPos(float4 vertex, float3 normal)

{

float4 wPos = mul(unity_ObjectToWorld, vertex);

if (unity_LightShadowBias.z != 0.0)

{

float3 wNormal = UnityObjectToWorldNormal(normal);

float3 wLight = normalize(UnityWorldSpaceLightDir(wPos.xyz));

// apply normal offset bias (inset position along the normal)

// bias needs to be scaled by sine between normal and light direction

// (http://the-witness.net/news/2013/09/shadow-mapping-summary-part-1/)

//

// unity_LightShadowBias.z contains user-specified normal offset amount

// scaled by world space texel size.

float shadowCos = dot(wNormal, wLight);

float shadowSine = sqrt(1-shadowCos*shadowCos);

float normalBias = unity_LightShadowBias.z * shadowSine;

wPos.xyz -= wNormal * normalBias;

}

return mul(UNITY_MATRIX_VP, wPos);

}

float4 UnityClipSpaceShadowCasterPos(float3 vertex, float3 normal)

{

return UnityClipSpaceShadowCasterPos(float4(vertex, 1), normal);

}

float4 UnityApplyLinearShadowBias(float4 clipPos)

{

// For point lights that support depth cube map, the bias is applied in the fragment shader sampling the shadow map.

// This is because the legacy behaviour for point light shadow map cannot be implemented by offseting the vertex position

// in the vertex shader generating the shadow map.

#if !(defined(SHADOWS_CUBE) && defined(SHADOWS_CUBE_IN_DEPTH_TEX))

#if defined(UNITY_REVERSED_Z)

// We use max/min instead of clamp to ensure proper handling of the rare case

// where both numerator and denominator are zero and the fraction becomes NaN.

clipPos.z += max(-1, min(unity_LightShadowBias.x / clipPos.w, 0));

clipPos.z += saturate(unity_LightShadowBias.x/clipPos.w);

#if defined(UNITY_REVERSED_Z)

float clamped = min(clipPos.z, clipPos.w*UNITY_NEAR_CLIP_VALUE);

float clamped = max(clipPos.z, clipPos.w*UNITY_NEAR_CLIP_VALUE);

clipPos.z = lerp(clipPos.z, clamped, unity_LightShadowBias.y);

return clipPos;

}

#if defined(SHADOWS_CUBE) && !defined(SHADOWS_CUBE_IN_DEPTH_TEX)

// Rendering into point light (cubemap) shadows

#define V2F_SHADOW_CASTER_NOPOS float3 vec : TEXCOORD0;

#define TRANSFER_SHADOW_CASTER_NOPOS_LEGACY(o,opos) o.vec = mul(unity_ObjectToWorld, v.vertex).xyz - _LightPositionRange.xyz; opos = UnityObjectToClipPos(v.vertex);

#define TRANSFER_SHADOW_CASTER_NOPOS(o,opos) o.vec = mul(unity_ObjectToWorld, v.vertex).xyz - _LightPositionRange.xyz; opos = UnityObjectToClipPos(v.vertex);

#define SHADOW_CASTER_FRAGMENT(i) return UnityEncodeCubeShadowDepth ((length(i.vec) + unity_LightShadowBias.x) * _LightPositionRange.w);

// Rendering into directional or spot light shadows

#define V2F_SHADOW_CASTER_NOPOS

// Let embedding code know that V2F_SHADOW_CASTER_NOPOS is empty; so that it can workaround

// empty structs that could possibly be produced.

#define V2F_SHADOW_CASTER_NOPOS_IS_EMPTY

#define TRANSFER_SHADOW_CASTER_NOPOS_LEGACY(o,opos) \

opos = UnityObjectToClipPos(v.vertex.xyz); \

opos = UnityApplyLinearShadowBias(opos);

#define TRANSFER_SHADOW_CASTER_NOPOS(o,opos) \

opos = UnityClipSpaceShadowCasterPos(v.vertex, v.normal); \

opos = UnityApplyLinearShadowBias(opos);

#define SHADOW_CASTER_FRAGMENT(i) return 0;

#define V2F_SHADOW_CASTER V2F_SHADOW_CASTER_NOPOS UNITY_POSITION(pos)

#define TRANSFER_SHADOW_CASTER_NORMALOFFSET(o) TRANSFER_SHADOW_CASTER_NOPOS(o,o.pos)

#define TRANSFER_SHADOW_CASTER(o) TRANSFER_SHADOW_CASTER_NOPOS_LEGACY(o,o.pos)

#define UNITY_OPAQUE_ALPHA(outputAlpha) outputAlpha = 1.0

#if defined(UNITY_PASS_PREPASSBASE) || defined(UNITY_PASS_DEFERRED) || defined(UNITY_PASS_SHADOWCASTER)

#undef FOG_LINEAR

#undef FOG_EXP

#undef FOG_EXP2

#if defined(UNITY_REVERSED_Z)

#if UNITY_REVERSED_Z == 1

//D3d with reversed Z => z clip range is [near, 0] -> remapping to [0, far]

//max is required to protect ourselves from near plane not being correct/meaningfull in case of oblique matrices.

#define UNITY_Z_0_FAR_FROM_CLIPSPACE(coord) max(((1.0-(coord)/_ProjectionParams.y)*_ProjectionParams.z),0)

//GL with reversed z => z clip range is [near, -far] -> should remap in theory but dont do it in practice to save some perf (range is close enough)

#define UNITY_Z_0_FAR_FROM_CLIPSPACE(coord) max(-(coord), 0)

#elif UNITY_UV_STARTS_AT_TOP

//D3d without reversed z => z clip range is [0, far] -> nothing to do

#define UNITY_Z_0_FAR_FROM_CLIPSPACE(coord) (coord)

//Opengl => z clip range is [-near, far] -> should remap in theory but dont do it in practice to save some perf (range is close enough)

#define UNITY_Z_0_FAR_FROM_CLIPSPACE(coord) (coord)