提交Spine插件
This commit is contained in:
YiHan0621
@@ -0,0 +1,70 @@
|
||||
#ifndef SHADER_MATHS_INCLUDED
|
||||
#define SHADER_MATHS_INCLUDED
|
||||
|
||||
#include "UnityCG.cginc"
|
||||
|
||||
////////////////////////////////////////
|
||||
// Maths functions
|
||||
//
|
||||
|
||||
inline half3 safeNormalize(half3 inVec)
|
||||
{
|
||||
half dp3 = max(0.001f, dot(inVec, inVec));
|
||||
return inVec * rsqrt(dp3);
|
||||
}
|
||||
|
||||
inline float dotClamped(float3 a, float3 b)
|
||||
{
|
||||
#if (SHADER_TARGET < 30 || defined(SHADER_API_PS3))
|
||||
return saturate(dot(a, b));
|
||||
#else
|
||||
return max(0.0h, dot(a, b));
|
||||
#endif
|
||||
}
|
||||
|
||||
inline float oneDividedBy(float value)
|
||||
{
|
||||
//Catches NANs
|
||||
float sign_value = sign(value);
|
||||
float sign_value_squared = sign_value*sign_value;
|
||||
return sign_value_squared / ( value + sign_value_squared - 1.0);
|
||||
}
|
||||
|
||||
inline half pow5 (half x)
|
||||
{
|
||||
return x*x*x*x*x;
|
||||
}
|
||||
|
||||
inline float4 quat_from_axis_angle(float3 axis, float angleRadians)
|
||||
{
|
||||
float4 qr;
|
||||
float half_angle = (angleRadians * 0.5);
|
||||
qr.x = axis.x * sin(half_angle);
|
||||
qr.y = axis.y * sin(half_angle);
|
||||
qr.z = axis.z * sin(half_angle);
|
||||
qr.w = cos(half_angle);
|
||||
return qr;
|
||||
}
|
||||
|
||||
inline float3 rotate_vertex_position(float3 position, float3 axis, float angleRadians)
|
||||
{
|
||||
float4 q = quat_from_axis_angle(axis, angleRadians);
|
||||
float3 v = position.xyz;
|
||||
return v + 2.0 * cross(q.xyz, cross(q.xyz, v) + q.w * v);
|
||||
}
|
||||
|
||||
float3 EncodeFloatRGB(float value)
|
||||
{
|
||||
const float max24int = 256*256*256-1;
|
||||
float3 decomp = floor( value * float3( max24int/(256*256), max24int/256, max24int ) ) / 255.0;
|
||||
decomp.z -= decomp.y * 256.0;
|
||||
decomp.y -= decomp.x * 256.0;
|
||||
return decomp;
|
||||
}
|
||||
|
||||
float DecodeFloatRGB(float3 decomp)
|
||||
{
|
||||
return dot( decomp.xyz, float3( 255.0/256, 255.0/(256*256), 255.0/(256*256*256) ) );
|
||||
}
|
||||
|
||||
#endif // SHADER_MATHS_INCLUDED
|
||||
@@ -0,0 +1,9 @@
|
||||
fileFormatVersion: 2
|
||||
guid: e1de23de2025abe4a84ff2edd3f24491
|
||||
timeCreated: 1494092582
|
||||
licenseType: Free
|
||||
ShaderImporter:
|
||||
defaultTextures: []
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -0,0 +1,474 @@
|
||||
// Upgrade NOTE: upgraded instancing buffer 'PerDrawSprite' to new syntax.
|
||||
|
||||
#ifndef SHADER_SHARED_INCLUDED
|
||||
#define SHADER_SHARED_INCLUDED
|
||||
|
||||
#include "UnityCG.cginc"
|
||||
|
||||
#ifdef UNITY_INSTANCING_ENABLED
|
||||
|
||||
UNITY_INSTANCING_BUFFER_START(PerDrawSprite)
|
||||
// SpriteRenderer.Color while Non-Batched/Instanced.
|
||||
fixed4 unity_SpriteRendererColorArray[UNITY_INSTANCED_ARRAY_SIZE];
|
||||
// this could be smaller but that's how bit each entry is regardless of type
|
||||
float4 unity_SpriteFlipArray[UNITY_INSTANCED_ARRAY_SIZE];
|
||||
UNITY_INSTANCING_BUFFER_END(PerDrawSprite)
|
||||
|
||||
#define _RendererColor unity_SpriteRendererColorArray[unity_InstanceID]
|
||||
#define _Flip unity_SpriteFlipArray[unity_InstanceID]
|
||||
|
||||
#endif // instancing
|
||||
|
||||
CBUFFER_START(UnityPerDrawSprite)
|
||||
#ifndef UNITY_INSTANCING_ENABLED
|
||||
fixed4 _RendererColor;
|
||||
float4 _Flip;
|
||||
#endif
|
||||
float _EnableExternalAlpha;
|
||||
CBUFFER_END
|
||||
|
||||
////////////////////////////////////////
|
||||
// Space functions
|
||||
//
|
||||
|
||||
inline float4 calculateWorldPos(float4 vertex)
|
||||
{
|
||||
return mul(unity_ObjectToWorld, vertex);
|
||||
}
|
||||
|
||||
inline float4 calculateLocalPos(float4 vertex)
|
||||
{
|
||||
#ifdef UNITY_INSTANCING_ENABLED
|
||||
vertex.xy *= _Flip.xy;
|
||||
#endif
|
||||
|
||||
float4 pos = UnityObjectToClipPos(vertex);
|
||||
|
||||
#ifdef PIXELSNAP_ON
|
||||
pos = UnityPixelSnap(pos);
|
||||
#endif
|
||||
|
||||
return pos;
|
||||
}
|
||||
|
||||
inline half3 calculateWorldNormal(float3 normal)
|
||||
{
|
||||
return UnityObjectToWorldNormal(normal);
|
||||
}
|
||||
|
||||
////////////////////////////////////////
|
||||
// Normal map functions
|
||||
//
|
||||
|
||||
#if defined(_NORMALMAP)
|
||||
|
||||
uniform sampler2D _BumpMap;
|
||||
uniform half _BumpScale;
|
||||
|
||||
half3 UnpackScaleNormal(half4 packednormal, half bumpScale)
|
||||
{
|
||||
#if defined(UNITY_NO_DXT5nm)
|
||||
return packednormal.xyz * 2 - 1;
|
||||
#else
|
||||
half3 normal;
|
||||
normal.xy = (packednormal.wy * 2 - 1);
|
||||
#if (SHADER_TARGET >= 30)
|
||||
// SM2.0: instruction count limitation
|
||||
// SM2.0: normal scaler is not supported
|
||||
normal.xy *= bumpScale;
|
||||
#endif
|
||||
normal.z = sqrt(1.0 - saturate(dot(normal.xy, normal.xy)));
|
||||
return normal;
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
inline half3 calculateWorldTangent(float4 tangent)
|
||||
{
|
||||
return UnityObjectToWorldDir(tangent);
|
||||
}
|
||||
|
||||
inline half3 calculateWorldBinormal(half3 normalWorld, half3 tangentWorld, float tangentSign)
|
||||
{
|
||||
//When calculating the binormal we have to flip it when the mesh is scaled negatively.
|
||||
//Normally this would just be unity_WorldTransformParams.w but this isn't set correctly by Unity for its SpriteRenderer meshes so get from objectToWorld matrix scale instead.
|
||||
half worldTransformSign = sign(unity_ObjectToWorld[0][0] * unity_ObjectToWorld[1][1] * unity_ObjectToWorld[2][2]);
|
||||
half sign = tangentSign * worldTransformSign;
|
||||
return cross(normalWorld, tangentWorld) * sign;
|
||||
}
|
||||
|
||||
inline half3 calculateNormalFromBumpMap(float2 texUV, half3 tangentWorld, half3 binormalWorld, half3 normalWorld)
|
||||
{
|
||||
half3 localNormal = UnpackScaleNormal(tex2D(_BumpMap, texUV), _BumpScale);
|
||||
half3x3 rotation = half3x3(tangentWorld, binormalWorld, normalWorld);
|
||||
half3 normal = normalize(mul(localNormal, rotation));
|
||||
return normal;
|
||||
}
|
||||
|
||||
#endif // _NORMALMAP
|
||||
|
||||
////////////////////////////////////////
|
||||
// Blending functions
|
||||
//
|
||||
|
||||
inline fixed4 calculateLitPixel(fixed4 texureColor, fixed4 color, fixed3 lighting) : SV_Target
|
||||
{
|
||||
fixed4 finalPixel;
|
||||
|
||||
#if defined(_ALPHABLEND_ON)
|
||||
//Normal Alpha
|
||||
finalPixel.a = texureColor.a * color.a;
|
||||
finalPixel.rgb = texureColor.rgb * color.rgb * (lighting * finalPixel.a);
|
||||
#elif defined(_ALPHAPREMULTIPLY_ON)
|
||||
//Pre multiplied alpha
|
||||
finalPixel = texureColor * color;
|
||||
finalPixel.rgb *= lighting * color.a;
|
||||
#elif defined(_MULTIPLYBLEND)
|
||||
//Multiply
|
||||
finalPixel = texureColor * color;
|
||||
finalPixel.rgb *= lighting;
|
||||
finalPixel = lerp(fixed4(1,1,1,1), finalPixel, finalPixel.a);
|
||||
#elif defined(_MULTIPLYBLEND_X2)
|
||||
//Multiply x2
|
||||
finalPixel.rgb = texureColor.rgb * color.rgb * lighting * 2.0f;
|
||||
finalPixel.a = color.a * texureColor.a;
|
||||
finalPixel = lerp(fixed4(0.5f,0.5f,0.5f,0.5f), finalPixel, finalPixel.a);
|
||||
#elif defined(_ADDITIVEBLEND)
|
||||
//Additive
|
||||
finalPixel = texureColor * 2.0f * color;
|
||||
finalPixel.rgb *= lighting * color.a;
|
||||
#elif defined(_ADDITIVEBLEND_SOFT)
|
||||
//Additive soft
|
||||
finalPixel = texureColor * color;
|
||||
finalPixel.rgb *= lighting * finalPixel.a;
|
||||
#else
|
||||
//Opaque
|
||||
finalPixel.a = 1;
|
||||
finalPixel.rgb = texureColor.rgb * color.rgb * lighting;
|
||||
#endif
|
||||
|
||||
return finalPixel;
|
||||
}
|
||||
|
||||
inline fixed4 calculateLitPixel(fixed4 texureColor, fixed3 lighting) : SV_Target
|
||||
{
|
||||
fixed4 finalPixel;
|
||||
|
||||
#if defined(_ALPHABLEND_ON)
|
||||
//Normal Alpha
|
||||
finalPixel.a = texureColor.a;
|
||||
finalPixel.rgb = texureColor.rgb * (lighting * finalPixel.a);
|
||||
#elif defined(_ALPHAPREMULTIPLY_ON)
|
||||
//Pre multiplied alpha
|
||||
finalPixel = texureColor;
|
||||
finalPixel.rgb *= lighting;
|
||||
#elif defined(_MULTIPLYBLEND)
|
||||
//Multiply
|
||||
finalPixel = texureColor;
|
||||
finalPixel.rgb *= lighting;
|
||||
finalPixel = lerp(fixed4(1,1,1,1), finalPixel, finalPixel.a);
|
||||
#elif defined(_MULTIPLYBLEND_X2)
|
||||
//Multiply x2
|
||||
finalPixel.rgb = texureColor.rgb * lighting * 2.0f;
|
||||
finalPixel.a = texureColor.a;
|
||||
finalPixel = lerp(fixed4(0.5f,0.5f,0.5f,0.5f), finalPixel, finalPixel.a);
|
||||
#elif defined(_ADDITIVEBLEND)
|
||||
//Additive
|
||||
finalPixel = texureColor * 2.0f;
|
||||
finalPixel.rgb *= lighting;
|
||||
#elif defined(_ADDITIVEBLEND_SOFT)
|
||||
//Additive soft
|
||||
finalPixel = texureColor;
|
||||
finalPixel.rgb *= lighting * finalPixel.a;
|
||||
#else
|
||||
//Opaque
|
||||
finalPixel.a = 1;
|
||||
finalPixel.rgb = texureColor.rgb * lighting;
|
||||
#endif
|
||||
|
||||
return finalPixel;
|
||||
}
|
||||
|
||||
inline fixed4 calculateAdditiveLitPixel(fixed4 texureColor, fixed4 color, fixed3 lighting) : SV_Target
|
||||
{
|
||||
fixed4 finalPixel;
|
||||
|
||||
#if defined(_ALPHABLEND_ON) || defined(_MULTIPLYBLEND) || defined(_MULTIPLYBLEND_X2) || defined(_ADDITIVEBLEND) || defined(_ADDITIVEBLEND_SOFT)
|
||||
//Normal Alpha, Additive and Multiply modes
|
||||
finalPixel.rgb = (texureColor.rgb * lighting * color.rgb) * (texureColor.a * color.a);
|
||||
finalPixel.a = 1.0;
|
||||
#elif defined(_ALPHAPREMULTIPLY_ON)
|
||||
//Pre multiplied alpha
|
||||
finalPixel.rgb = texureColor.rgb * lighting * color.rgb * color.a;
|
||||
finalPixel.a = 1.0;
|
||||
#else
|
||||
//Opaque
|
||||
finalPixel.rgb = texureColor.rgb * lighting * color.rgb;
|
||||
finalPixel.a = 1.0;
|
||||
#endif
|
||||
|
||||
return finalPixel;
|
||||
}
|
||||
|
||||
inline fixed4 calculateAdditiveLitPixel(fixed4 texureColor, fixed3 lighting) : SV_Target
|
||||
{
|
||||
fixed4 finalPixel;
|
||||
|
||||
#if defined(_ALPHABLEND_ON) || defined(_MULTIPLYBLEND) || defined(_MULTIPLYBLEND_X2) || defined(_ADDITIVEBLEND) || defined(_ADDITIVEBLEND_SOFT)
|
||||
//Normal Alpha, Additive and Multiply modes
|
||||
finalPixel.rgb = (texureColor.rgb * lighting) * texureColor.a;
|
||||
finalPixel.a = 1.0;
|
||||
#else
|
||||
//Pre multiplied alpha and Opaque
|
||||
finalPixel.rgb = texureColor.rgb * lighting;
|
||||
finalPixel.a = 1.0;
|
||||
#endif
|
||||
|
||||
return finalPixel;
|
||||
}
|
||||
|
||||
inline fixed4 calculatePixel(fixed4 texureColor, fixed4 color) : SV_Target
|
||||
{
|
||||
fixed4 finalPixel;
|
||||
|
||||
#if defined(_ALPHABLEND_ON)
|
||||
//Normal Alpha
|
||||
finalPixel.a = texureColor.a * color.a;
|
||||
finalPixel.rgb = (texureColor.rgb * color.rgb) * finalPixel.a;
|
||||
#elif defined(_ALPHAPREMULTIPLY_ON)
|
||||
//Pre multiplied alpha
|
||||
finalPixel = texureColor * color;
|
||||
finalPixel.rgb *= color.a;
|
||||
#elif defined(_MULTIPLYBLEND)
|
||||
//Multiply
|
||||
finalPixel = color * texureColor;
|
||||
finalPixel = lerp(fixed4(1,1,1,1), finalPixel, finalPixel.a);
|
||||
#elif defined(_MULTIPLYBLEND_X2)
|
||||
//Multiply x2
|
||||
finalPixel.rgb = texureColor.rgb * color.rgb * 2.0f;
|
||||
finalPixel.a = color.a * texureColor.a;
|
||||
finalPixel = lerp(fixed4(0.5f,0.5f,0.5f,0.5f), finalPixel, finalPixel.a);
|
||||
#elif defined(_ADDITIVEBLEND)
|
||||
//Additive
|
||||
finalPixel = texureColor * 2.0f * color;
|
||||
#elif defined(_ADDITIVEBLEND_SOFT)
|
||||
//Additive soft
|
||||
finalPixel = color * texureColor;
|
||||
finalPixel.rgb *= finalPixel.a;
|
||||
#else
|
||||
//Opaque
|
||||
finalPixel.a = 1;
|
||||
finalPixel.rgb = texureColor.rgb * color.rgb;
|
||||
#endif
|
||||
|
||||
return finalPixel;
|
||||
}
|
||||
|
||||
inline fixed4 calculatePixel(fixed4 texureColor) : SV_Target
|
||||
{
|
||||
fixed4 finalPixel;
|
||||
|
||||
#if defined(_ALPHABLEND_ON)
|
||||
//Normal Alpha
|
||||
finalPixel.a = texureColor.a;
|
||||
finalPixel.rgb = texureColor.rgb * finalPixel.a;
|
||||
#elif defined(_ALPHAPREMULTIPLY_ON)
|
||||
//Pre multiplied alpha
|
||||
finalPixel = texureColor;
|
||||
#elif defined(_MULTIPLYBLEND)
|
||||
//Multiply
|
||||
finalPixel = texureColor;
|
||||
finalPixel = lerp(fixed4(1,1,1,1), finalPixel, finalPixel.a);
|
||||
#elif defined(_MULTIPLYBLEND_X2)
|
||||
//Multiply x2
|
||||
finalPixel.rgb = texureColor.rgb * 2.0f;
|
||||
finalPixel.a = texureColor.a;
|
||||
finalPixel = lerp(fixed4(0.5f,0.5f,0.5f,0.5f), finalPixel, finalPixel.a);
|
||||
#elif defined(_ADDITIVEBLEND)
|
||||
//Additive
|
||||
finalPixel = texureColor * 2.0f;
|
||||
#elif defined(_ADDITIVEBLEND_SOFT)
|
||||
//Additive soft
|
||||
finalPixel = texureColor;
|
||||
finalPixel.rgb *= finalPixel.a;
|
||||
#else
|
||||
//Opaque
|
||||
finalPixel.a = 1;
|
||||
finalPixel.rgb = texureColor.rgb;
|
||||
#endif
|
||||
|
||||
return finalPixel;
|
||||
}
|
||||
|
||||
////////////////////////////////////////
|
||||
// Alpha Clipping
|
||||
//
|
||||
|
||||
#if defined(_ALPHA_CLIP)
|
||||
|
||||
uniform fixed _Cutoff;
|
||||
|
||||
#define ALPHA_CLIP(pixel, color) clip((pixel.a * color.a) - _Cutoff);
|
||||
|
||||
#else
|
||||
|
||||
#define ALPHA_CLIP(pixel, color)
|
||||
|
||||
#endif
|
||||
|
||||
////////////////////////////////////////
|
||||
// Color functions
|
||||
//
|
||||
|
||||
uniform fixed4 _Color;
|
||||
|
||||
inline fixed4 calculateVertexColor(fixed4 color)
|
||||
{
|
||||
return color * _Color;
|
||||
}
|
||||
|
||||
#if defined(_COLOR_ADJUST)
|
||||
|
||||
uniform float _Hue;
|
||||
uniform float _Saturation;
|
||||
uniform float _Brightness;
|
||||
uniform fixed4 _OverlayColor;
|
||||
|
||||
float3 rgb2hsv(float3 c)
|
||||
{
|
||||
float4 K = float4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
|
||||
float4 p = lerp(float4(c.bg, K.wz), float4(c.gb, K.xy), step(c.b, c.g));
|
||||
float4 q = lerp(float4(p.xyw, c.r), float4(c.r, p.yzx), step(p.x, c.r));
|
||||
|
||||
float d = q.x - min(q.w, q.y);
|
||||
float e = 1.0e-10;
|
||||
return float3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);
|
||||
}
|
||||
|
||||
float3 hsv2rgb(float3 c)
|
||||
{
|
||||
c = float3(c.x, clamp(c.yz, 0.0, 1.0));
|
||||
float4 K = float4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
|
||||
float3 p = abs(frac(c.xxx + K.xyz) * 6.0 - K.www);
|
||||
return c.z * lerp(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
|
||||
}
|
||||
|
||||
inline fixed4 adjustColor(fixed4 color)
|
||||
{
|
||||
float3 hsv = rgb2hsv(color.rgb);
|
||||
|
||||
hsv.x += _Hue;
|
||||
hsv.y *= _Saturation;
|
||||
hsv.z *= _Brightness;
|
||||
|
||||
color.rgb = hsv2rgb(hsv);
|
||||
|
||||
return color;
|
||||
}
|
||||
|
||||
#define COLORISE(pixel) pixel.rgb = lerp(pixel.rgb, _OverlayColor.rgb, _OverlayColor.a * pixel.a);
|
||||
#define COLORISE_ADDITIVE(pixel) pixel.rgb = ((1.0-_OverlayColor.a) * pixel.rgb);
|
||||
|
||||
#else // !_COLOR_ADJUST
|
||||
|
||||
#define COLORISE(pixel)
|
||||
#define COLORISE_ADDITIVE(pixel)
|
||||
|
||||
#endif // !_COLOR_ADJUST
|
||||
|
||||
////////////////////////////////////////
|
||||
// Fog
|
||||
//
|
||||
|
||||
#if defined(_FOG) && (defined(FOG_LINEAR) || defined(FOG_EXP) || defined(FOG_EXP2))
|
||||
|
||||
inline fixed4 applyFog(fixed4 pixel, float1 fogCoord)
|
||||
{
|
||||
#if defined(_ADDITIVEBLEND) || defined(_ADDITIVEBLEND_SOFT)
|
||||
//In additive mode blend from clear to black based on luminance
|
||||
float luminance = pixel.r * 0.3 + pixel.g * 0.59 + pixel.b * 0.11;
|
||||
fixed4 fogColor = lerp(fixed4(0,0,0,0), fixed4(0,0,0,1), luminance);
|
||||
#elif defined(_MULTIPLYBLEND)
|
||||
//In multiplied mode fade to white based on inverse luminance
|
||||
float luminance = pixel.r * 0.3 + pixel.g * 0.59 + pixel.b * 0.11;
|
||||
fixed4 fogColor = lerp(fixed4(1,1,1,1), fixed4(0,0,0,0), luminance);
|
||||
#elif defined(_MULTIPLYBLEND_X2)
|
||||
//In multipliedx2 mode fade to grey based on inverse luminance
|
||||
float luminance = pixel.r * 0.3 + pixel.g * 0.59 + pixel.b * 0.11;
|
||||
fixed4 fogColor = lerp(fixed4(0.5f,0.5f,0.5f,0.5f), fixed4(0,0,0,0), luminance);
|
||||
#elif defined(_ALPHABLEND_ON) || defined(_ALPHAPREMULTIPLY_ON)
|
||||
//In alpha blended modes blend to fog color based on pixel alpha
|
||||
fixed4 fogColor = lerp(fixed4(0,0,0,0), unity_FogColor, pixel.a);
|
||||
#else
|
||||
//In opaque mode just return fog color;
|
||||
fixed4 fogColor = unity_FogColor;
|
||||
#endif
|
||||
|
||||
UNITY_APPLY_FOG_COLOR(fogCoord, pixel, fogColor);
|
||||
|
||||
return pixel;
|
||||
}
|
||||
|
||||
#define APPLY_FOG(pixel, input) pixel = applyFog(pixel, input.fogCoord);
|
||||
|
||||
#define APPLY_FOG_ADDITIVE(pixel, input) \
|
||||
UNITY_APPLY_FOG_COLOR(input.fogCoord, pixel.rgb, fixed4(0,0,0,0)); // fog towards black in additive pass
|
||||
|
||||
#else
|
||||
|
||||
#define APPLY_FOG(pixel, input)
|
||||
#define APPLY_FOG_ADDITIVE(pixel, input)
|
||||
|
||||
#endif
|
||||
|
||||
////////////////////////////////////////
|
||||
// Texture functions
|
||||
//
|
||||
|
||||
uniform sampler2D _MainTex;
|
||||
|
||||
#if ETC1_EXTERNAL_ALPHA
|
||||
//External alpha texture for ETC1 compression
|
||||
uniform sampler2D _AlphaTex;
|
||||
#endif //ETC1_EXTERNAL_ALPHA
|
||||
|
||||
#if _TEXTURE_BLEND
|
||||
uniform sampler2D _BlendTex;
|
||||
uniform float _BlendAmount;
|
||||
|
||||
inline fixed4 calculateBlendedTexturePixel(float2 texcoord)
|
||||
{
|
||||
return (1.0-_BlendAmount) * tex2D(_MainTex, texcoord) + _BlendAmount * tex2D(_BlendTex, texcoord);
|
||||
}
|
||||
#endif // _TEXTURE_BLEND
|
||||
|
||||
inline fixed4 calculateTexturePixel(float2 texcoord)
|
||||
{
|
||||
fixed4 pixel;
|
||||
|
||||
#if _TEXTURE_BLEND
|
||||
pixel = calculateBlendedTexturePixel(texcoord);
|
||||
#else
|
||||
pixel = tex2D(_MainTex, texcoord);
|
||||
#endif // !_TEXTURE_BLEND
|
||||
|
||||
#if ETC1_EXTERNAL_ALPHA
|
||||
fixed4 alpha = tex2D (_AlphaTex, texcoord);
|
||||
pixel.a = lerp (pixel.a, alpha.r, _EnableExternalAlpha);
|
||||
#endif
|
||||
|
||||
#if defined(_COLOR_ADJUST)
|
||||
pixel = adjustColor(pixel);
|
||||
#endif // _COLOR_ADJUST
|
||||
|
||||
return pixel;
|
||||
}
|
||||
|
||||
uniform fixed4 _MainTex_ST;
|
||||
|
||||
inline float2 calculateTextureCoord(float4 texcoord)
|
||||
{
|
||||
return TRANSFORM_TEX(texcoord, _MainTex);
|
||||
}
|
||||
|
||||
#endif // SHADER_SHARED_INCLUDED
|
||||
@@ -0,0 +1,9 @@
|
||||
fileFormatVersion: 2
|
||||
guid: c18c5cab567666f4d8c5b2bd4e61390b
|
||||
timeCreated: 1494092582
|
||||
licenseType: Free
|
||||
ShaderImporter:
|
||||
defaultTextures: []
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -0,0 +1,200 @@
|
||||
#ifndef SPRITE_LIGHTING_INCLUDED
|
||||
#define SPRITE_LIGHTING_INCLUDED
|
||||
|
||||
//Check for using mesh normals
|
||||
#if !defined(_FIXED_NORMALS_VIEWSPACE) && !defined(_FIXED_NORMALS_VIEWSPACE_BACKFACE) && !defined(_FIXED_NORMALS_MODELSPACE) && !defined(_FIXED_NORMALS_MODELSPACE_BACKFACE)
|
||||
#define MESH_NORMALS
|
||||
#endif
|
||||
|
||||
//Check for fixing backfacing tangents
|
||||
#if defined(_FIXED_NORMALS_VIEWSPACE_BACKFACE) || defined(_FIXED_NORMALS_MODELSPACE_BACKFACE)
|
||||
#define FIXED_NORMALS_BACKFACE_RENDERING
|
||||
#endif
|
||||
|
||||
////////////////////////////////////////
|
||||
// Vertex structs
|
||||
//
|
||||
|
||||
struct VertexInput
|
||||
{
|
||||
float4 vertex : POSITION;
|
||||
float4 texcoord : TEXCOORD0;
|
||||
float4 color : COLOR;
|
||||
#if defined(MESH_NORMALS)
|
||||
float3 normal : NORMAL;
|
||||
#endif // _FIXED_NORMALS
|
||||
#if defined(_NORMALMAP)
|
||||
float4 tangent : TANGENT;
|
||||
#endif // _NORMALMAP
|
||||
UNITY_VERTEX_INPUT_INSTANCE_ID
|
||||
};
|
||||
|
||||
////////////////////////////////////////
|
||||
// Normal functions
|
||||
//
|
||||
|
||||
uniform float4 _FixedNormal = float4(0, 0, 1, 1);
|
||||
|
||||
inline float3 getFixedNormal()
|
||||
{
|
||||
return _FixedNormal.xyz;
|
||||
}
|
||||
|
||||
inline float calculateBackfacingSign(float3 worldPos)
|
||||
{
|
||||
//If we're using fixed normals and mesh is facing away from camera, flip tangentSign
|
||||
//Unity uses a left handed coordinate system so camera always looks down the negative z axis
|
||||
float3 cameraForward = float3(0,0,-1);
|
||||
float3 meshWorldForward = mul((float3x3)unity_ObjectToWorld, cameraForward);
|
||||
float3 toCamera = _WorldSpaceCameraPos - worldPos;
|
||||
return sign(dot(toCamera, meshWorldForward));
|
||||
}
|
||||
|
||||
inline half3 calculateSpriteWorldNormal(VertexInput vertex, float backFaceSign)
|
||||
{
|
||||
#if defined(MESH_NORMALS)
|
||||
|
||||
return calculateWorldNormal(vertex.normal);
|
||||
|
||||
#else // !MESH_NORMALS
|
||||
|
||||
float3 normal = getFixedNormal();
|
||||
|
||||
#if defined(_FIXED_NORMALS_VIEWSPACE) || defined(_FIXED_NORMALS_VIEWSPACE_BACKFACE)
|
||||
//View space fixed normal
|
||||
//Rotate fixed normal by inverse view matrix to convert the fixed normal into world space
|
||||
float3x3 invView = transpose((float3x3)UNITY_MATRIX_V);
|
||||
return normalize(mul(invView, normal));
|
||||
#else
|
||||
//Model space fixed normal.
|
||||
#if defined(FIXED_NORMALS_BACKFACE_RENDERING)
|
||||
//If back face rendering is enabled and the sprite is facing away from the camera (ie we're rendering the backface) then need to flip the normal
|
||||
normal *= backFaceSign;
|
||||
#endif
|
||||
return calculateWorldNormal(normal);
|
||||
#endif
|
||||
|
||||
#endif // !MESH_NORMALS
|
||||
}
|
||||
|
||||
inline half3 calculateSpriteViewNormal(VertexInput vertex, float backFaceSign)
|
||||
{
|
||||
#if defined(MESH_NORMALS)
|
||||
|
||||
return normalize(mul((float3x3)UNITY_MATRIX_IT_MV, vertex.normal));
|
||||
|
||||
#else // !MESH_NORMALS
|
||||
|
||||
float3 normal = getFixedNormal();
|
||||
|
||||
#if defined(_FIXED_NORMALS_VIEWSPACE) || defined(_FIXED_NORMALS_VIEWSPACE_BACKFACE)
|
||||
//View space fixed normal
|
||||
return normal;
|
||||
#else
|
||||
//Model space fixed normal
|
||||
#if defined(FIXED_NORMALS_BACKFACE_RENDERING)
|
||||
//If back face rendering is enabled and the sprite is facing away from the camera (ie we're rendering the backface) then need to flip the normal
|
||||
normal *= backFaceSign;
|
||||
#endif
|
||||
return normalize(mul((float3x3)UNITY_MATRIX_IT_MV, normal));
|
||||
#endif
|
||||
|
||||
#endif // !MESH_NORMALS
|
||||
}
|
||||
|
||||
////////////////////////////////////////
|
||||
// Normal map functions
|
||||
//
|
||||
|
||||
#if defined(_NORMALMAP)
|
||||
|
||||
inline half3 calculateSpriteWorldBinormal(VertexInput vertex, half3 normalWorld, half3 tangentWorld, float backFaceSign)
|
||||
{
|
||||
float tangentSign = vertex.tangent.w;
|
||||
|
||||
#if defined(FIXED_NORMALS_BACKFACE_RENDERING)
|
||||
tangentSign *= backFaceSign;
|
||||
#endif
|
||||
|
||||
return calculateWorldBinormal(normalWorld, tangentWorld, tangentSign);
|
||||
}
|
||||
|
||||
#endif // _NORMALMAP
|
||||
|
||||
#if defined(_DIFFUSE_RAMP)
|
||||
|
||||
|
||||
////////////////////////////////////////
|
||||
// Diffuse ramp functions
|
||||
//
|
||||
|
||||
//Disable for softer, more traditional diffuse ramping
|
||||
#define HARD_DIFFUSE_RAMP
|
||||
|
||||
uniform sampler2D _DiffuseRamp;
|
||||
|
||||
inline fixed3 calculateDiffuseRamp(float ramp)
|
||||
{
|
||||
return tex2D(_DiffuseRamp, float2(ramp, ramp)).rgb;
|
||||
}
|
||||
|
||||
inline fixed3 calculateRampedDiffuse(fixed3 lightColor, float attenuation, float angleDot)
|
||||
{
|
||||
float d = angleDot * 0.5 + 0.5;
|
||||
#if defined(HARD_DIFFUSE_RAMP)
|
||||
half3 ramp = calculateDiffuseRamp(d * attenuation * 2);
|
||||
return lightColor * ramp;
|
||||
#else
|
||||
half3 ramp = calculateDiffuseRamp(d);
|
||||
return lightColor * ramp * (attenuation * 2);
|
||||
#endif
|
||||
}
|
||||
#endif // _DIFFUSE_RAMP
|
||||
|
||||
////////////////////////////////////////
|
||||
// Rim Lighting functions
|
||||
//
|
||||
|
||||
#ifdef _RIM_LIGHTING
|
||||
|
||||
uniform float _RimPower;
|
||||
uniform fixed4 _RimColor;
|
||||
|
||||
inline fixed3 applyRimLighting(fixed3 posWorld, fixed3 normalWorld, fixed4 pixel) : SV_Target
|
||||
{
|
||||
fixed3 viewDir = normalize(_WorldSpaceCameraPos - posWorld);
|
||||
float invDot = 1.0 - saturate(dot(normalWorld, viewDir));
|
||||
float rimPower = pow(invDot, _RimPower);
|
||||
float rim = saturate(rimPower * _RimColor.a);
|
||||
|
||||
#if defined(_DIFFUSE_RAMP)
|
||||
rim = calculateDiffuseRamp(rim).r;
|
||||
#endif
|
||||
|
||||
return lerp(pixel.rgb, _RimColor.xyz * pixel.a, rim);
|
||||
}
|
||||
|
||||
#endif //_RIM_LIGHTING
|
||||
|
||||
////////////////////////////////////////
|
||||
// Emission functions
|
||||
//
|
||||
|
||||
#ifdef _EMISSION
|
||||
|
||||
uniform sampler2D _EmissionMap;
|
||||
uniform fixed4 _EmissionColor;
|
||||
uniform float _EmissionPower;
|
||||
|
||||
|
||||
#define APPLY_EMISSION(diffuse, uv) diffuse += tex2D(_EmissionMap, uv).rgb * _EmissionColor.rgb * _EmissionPower;
|
||||
#define APPLY_EMISSION_SPECULAR(pixel, uv) pixel.rgb += (tex2D(_EmissionMap, uv).rgb * _EmissionColor.rgb * _EmissionPower) * pixel.a;
|
||||
|
||||
#else //!_EMISSION
|
||||
|
||||
#define APPLY_EMISSION(diffuse, uv)
|
||||
#define APPLY_EMISSION_SPECULAR(pixel, uv)
|
||||
|
||||
#endif //!_EMISSION
|
||||
|
||||
#endif // SPRITE_LIGHTING_INCLUDED
|
||||
@@ -0,0 +1,9 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 0cfb891658099ca4bb0c9544c08e60f9
|
||||
timeCreated: 1494092582
|
||||
licenseType: Free
|
||||
ShaderImporter:
|
||||
defaultTextures: []
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -0,0 +1,252 @@
|
||||
#ifndef SPRITE_PIXEL_LIGHTING_INCLUDED
|
||||
#define SPRITE_PIXEL_LIGHTING_INCLUDED
|
||||
|
||||
#include "ShaderShared.cginc"
|
||||
#include "SpriteLighting.cginc"
|
||||
#include "SpriteSpecular.cginc"
|
||||
#include "AutoLight.cginc"
|
||||
|
||||
////////////////////////////////////////
|
||||
// Defines
|
||||
//
|
||||
|
||||
////////////////////////////////////////
|
||||
// Vertex output struct
|
||||
//
|
||||
|
||||
#if defined(_NORMALMAP)
|
||||
#define _VERTEX_LIGHTING_INDEX TEXCOORD5
|
||||
#define _LIGHT_COORD_INDEX_0 6
|
||||
#define _LIGHT_COORD_INDEX_1 7
|
||||
#define _FOG_COORD_INDEX 8
|
||||
#else
|
||||
#define _VERTEX_LIGHTING_INDEX TEXCOORD3
|
||||
#define _LIGHT_COORD_INDEX_0 4
|
||||
#define _LIGHT_COORD_INDEX_1 5
|
||||
#define _FOG_COORD_INDEX 6
|
||||
#endif // _NORMALMAP
|
||||
|
||||
struct VertexOutput
|
||||
{
|
||||
float4 pos : SV_POSITION;
|
||||
fixed4 color : COLOR;
|
||||
float2 texcoord : TEXCOORD0;
|
||||
float4 posWorld : TEXCOORD1;
|
||||
half3 normalWorld : TEXCOORD2;
|
||||
#if defined(_NORMALMAP)
|
||||
half3 tangentWorld : TEXCOORD3;
|
||||
half3 binormalWorld : TEXCOORD4;
|
||||
#endif // _NORMALMAP
|
||||
fixed3 vertexLighting : _VERTEX_LIGHTING_INDEX;
|
||||
LIGHTING_COORDS(_LIGHT_COORD_INDEX_0, _LIGHT_COORD_INDEX_1)
|
||||
#if defined(_FOG)
|
||||
UNITY_FOG_COORDS(_FOG_COORD_INDEX)
|
||||
#endif // _FOG
|
||||
|
||||
UNITY_VERTEX_OUTPUT_STEREO
|
||||
};
|
||||
|
||||
////////////////////////////////////////
|
||||
// Light calculations
|
||||
//
|
||||
|
||||
uniform fixed4 _LightColor0;
|
||||
|
||||
inline fixed3 calculateLightDiffuse(VertexOutput input, float3 normalWorld, inout fixed4 albedo)
|
||||
{
|
||||
//For directional lights _WorldSpaceLightPos0.w is set to zero
|
||||
float3 lightWorldDirection = normalize(_WorldSpaceLightPos0.xyz - input.posWorld.xyz * _WorldSpaceLightPos0.w);
|
||||
|
||||
float attenuation = LIGHT_ATTENUATION(input);
|
||||
float angleDot = max(0, dot(normalWorld, lightWorldDirection));
|
||||
|
||||
#if defined(_DIFFUSE_RAMP)
|
||||
fixed3 lightDiffuse = calculateRampedDiffuse(_LightColor0.rgb, attenuation, angleDot);
|
||||
#else
|
||||
fixed3 lightDiffuse = _LightColor0.rgb * (attenuation * angleDot);
|
||||
#endif // _DIFFUSE_RAMP
|
||||
|
||||
return lightDiffuse;
|
||||
}
|
||||
|
||||
inline float3 calculateNormalWorld(VertexOutput input)
|
||||
{
|
||||
#if defined(_NORMALMAP)
|
||||
return calculateNormalFromBumpMap(input.texcoord, input.tangentWorld, input.binormalWorld, input.normalWorld);
|
||||
#else
|
||||
return input.normalWorld;
|
||||
#endif
|
||||
}
|
||||
|
||||
fixed3 calculateVertexLighting(float3 posWorld, float3 normalWorld)
|
||||
{
|
||||
fixed3 vertexLighting = fixed3(0,0,0);
|
||||
|
||||
#ifdef VERTEXLIGHT_ON
|
||||
//Get approximated illumination from non-important point lights
|
||||
vertexLighting = Shade4PointLights ( unity_4LightPosX0, unity_4LightPosY0, unity_4LightPosZ0,
|
||||
unity_LightColor[0].rgb, unity_LightColor[1].rgb, unity_LightColor[2].rgb, unity_LightColor[3].rgb,
|
||||
unity_4LightAtten0, posWorld, normalWorld) * 0.5;
|
||||
#endif
|
||||
|
||||
return vertexLighting;
|
||||
}
|
||||
|
||||
fixed3 calculateAmbientLight(half3 normalWorld)
|
||||
{
|
||||
#if defined(_SPHERICAL_HARMONICS)
|
||||
fixed3 ambient = ShadeSH9(half4(normalWorld, 1.0));
|
||||
#else
|
||||
fixed3 ambient = unity_AmbientSky.rgb;
|
||||
#endif
|
||||
return ambient;
|
||||
}
|
||||
|
||||
#if defined(SPECULAR)
|
||||
|
||||
fixed4 calculateSpecularLight(SpecularCommonData s, float3 viewDir, float3 normal, float3 lightDir, float3 lightColor, half3 ambient)
|
||||
{
|
||||
SpecularLightData data = calculatePhysicsBasedSpecularLight (s.specColor, s.oneMinusReflectivity, s.smoothness, normal, viewDir, lightDir, lightColor, ambient, unity_IndirectSpecColor.rgb);
|
||||
fixed4 pixel = calculateLitPixel(fixed4(s.diffColor, s.alpha), data.lighting);
|
||||
pixel.rgb += data.specular * s.alpha;
|
||||
return pixel;
|
||||
}
|
||||
|
||||
fixed4 calculateSpecularLightAdditive(SpecularCommonData s, float3 viewDir, float3 normal, float3 lightDir, float3 lightColor)
|
||||
{
|
||||
SpecularLightData data = calculatePhysicsBasedSpecularLight (s.specColor, s.oneMinusReflectivity, s.smoothness, normal, viewDir, lightDir, lightColor, half3(0,0,0), half3(0,0,0));
|
||||
fixed4 pixel = calculateAdditiveLitPixel(fixed4(s.diffColor, s.alpha), data.lighting);
|
||||
pixel.rgb += data.specular * s.alpha;
|
||||
return pixel;
|
||||
}
|
||||
|
||||
#endif //SPECULAR
|
||||
|
||||
////////////////////////////////////////
|
||||
// Vertex program
|
||||
//
|
||||
|
||||
VertexOutput vert(VertexInput v)
|
||||
{
|
||||
VertexOutput output;
|
||||
|
||||
UNITY_SETUP_INSTANCE_ID(input);
|
||||
UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output);
|
||||
|
||||
output.pos = calculateLocalPos(v.vertex);
|
||||
output.color = calculateVertexColor(v.color);
|
||||
output.texcoord = calculateTextureCoord(v.texcoord);
|
||||
output.posWorld = calculateWorldPos(v.vertex);
|
||||
|
||||
float backFaceSign = 1;
|
||||
#if defined(FIXED_NORMALS_BACKFACE_RENDERING)
|
||||
backFaceSign = calculateBackfacingSign(output.posWorld.xyz);
|
||||
#endif
|
||||
|
||||
output.normalWorld = calculateSpriteWorldNormal(v, backFaceSign);
|
||||
output.vertexLighting = calculateVertexLighting(output.posWorld, output.normalWorld);
|
||||
|
||||
#if defined(_NORMALMAP)
|
||||
output.tangentWorld = calculateWorldTangent(v.tangent);
|
||||
output.binormalWorld = calculateSpriteWorldBinormal(v, output.normalWorld, output.tangentWorld, backFaceSign);
|
||||
#endif
|
||||
|
||||
TRANSFER_VERTEX_TO_FRAGMENT(output)
|
||||
|
||||
#if defined(_FOG)
|
||||
UNITY_TRANSFER_FOG(output,output.pos);
|
||||
#endif // _FOG
|
||||
|
||||
return output;
|
||||
}
|
||||
|
||||
////////////////////////////////////////
|
||||
// Fragment programs
|
||||
//
|
||||
|
||||
fixed4 fragBase(VertexOutput input) : SV_Target
|
||||
{
|
||||
fixed4 texureColor = calculateTexturePixel(input.texcoord);
|
||||
ALPHA_CLIP(texureColor, input.color)
|
||||
|
||||
//Get normal direction
|
||||
fixed3 normalWorld = calculateNormalWorld(input);
|
||||
|
||||
//Get Ambient diffuse
|
||||
fixed3 ambient = calculateAmbientLight(normalWorld);
|
||||
|
||||
|
||||
#if defined(SPECULAR)
|
||||
|
||||
//For directional lights _WorldSpaceLightPos0.w is set to zero
|
||||
float3 lightWorldDirection = normalize(_WorldSpaceLightPos0.xyz - input.posWorld.xyz * _WorldSpaceLightPos0.w);
|
||||
float attenuation = LIGHT_ATTENUATION(input);
|
||||
|
||||
//Returns pixel lit by light, texture color should inlcluded alpha
|
||||
half3 viewDir = normalize(_WorldSpaceCameraPos - input.posWorld.xyz);
|
||||
fixed4 pixel = calculateSpecularLight(getSpecularData(input.texcoord.xy, texureColor, input.color), viewDir, normalWorld, lightWorldDirection, _LightColor0.rgb * attenuation, ambient + input.vertexLighting);
|
||||
|
||||
APPLY_EMISSION_SPECULAR(pixel, input.texcoord)
|
||||
|
||||
#else
|
||||
|
||||
//Get primary pixel light diffuse
|
||||
fixed3 diffuse = calculateLightDiffuse(input, normalWorld, texureColor);
|
||||
|
||||
//Combine along with vertex lighting for the base lighting pass
|
||||
fixed3 lighting = ambient + diffuse + input.vertexLighting;
|
||||
|
||||
APPLY_EMISSION(lighting, input.texcoord)
|
||||
|
||||
fixed4 pixel = calculateLitPixel(texureColor, input.color, lighting);
|
||||
|
||||
#endif
|
||||
|
||||
#if defined(_RIM_LIGHTING)
|
||||
pixel.rgb = applyRimLighting(input.posWorld, normalWorld, pixel);
|
||||
#endif
|
||||
|
||||
COLORISE(pixel)
|
||||
APPLY_FOG(pixel, input)
|
||||
|
||||
return pixel;
|
||||
}
|
||||
|
||||
fixed4 fragAdd(VertexOutput input) : SV_Target
|
||||
{
|
||||
fixed4 texureColor = calculateTexturePixel(input.texcoord);
|
||||
|
||||
#if defined(_COLOR_ADJUST)
|
||||
texureColor = adjustColor(texureColor);
|
||||
#endif // _COLOR_ADJUST
|
||||
|
||||
ALPHA_CLIP(texureColor, input.color)
|
||||
|
||||
//Get normal direction
|
||||
fixed3 normalWorld = calculateNormalWorld(input);
|
||||
|
||||
#if defined(SPECULAR)
|
||||
|
||||
//For directional lights _WorldSpaceLightPos0.w is set to zero
|
||||
float3 lightWorldDirection = normalize(_WorldSpaceLightPos0.xyz - input.posWorld.xyz * _WorldSpaceLightPos0.w);
|
||||
float attenuation = LIGHT_ATTENUATION(input);
|
||||
|
||||
half3 viewDir = normalize(_WorldSpaceCameraPos - input.posWorld.xyz);
|
||||
fixed4 pixel = calculateSpecularLightAdditive(getSpecularData(input.texcoord.xy, texureColor, input.color), viewDir, normalWorld, lightWorldDirection, _LightColor0.rgb * attenuation);
|
||||
|
||||
#else
|
||||
|
||||
//Get light diffuse
|
||||
fixed3 lighting = calculateLightDiffuse(input, normalWorld, texureColor);
|
||||
fixed4 pixel = calculateAdditiveLitPixel(texureColor, input.color, lighting);
|
||||
|
||||
#endif
|
||||
|
||||
COLORISE_ADDITIVE(pixel)
|
||||
APPLY_FOG_ADDITIVE(pixel, input)
|
||||
|
||||
return pixel;
|
||||
}
|
||||
|
||||
|
||||
#endif // SPRITE_PIXEL_LIGHTING_INCLUDED
|
||||
@@ -0,0 +1,9 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 7ffc57e05c42ec748838bea0a3aff9f9
|
||||
timeCreated: 1494092582
|
||||
licenseType: Free
|
||||
ShaderImporter:
|
||||
defaultTextures: []
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -0,0 +1,49 @@
|
||||
#ifndef SPRITE_SHADOWS_INCLUDED
|
||||
#define SPRITE_SHADOWS_INCLUDED
|
||||
|
||||
#include "ShaderShared.cginc"
|
||||
|
||||
////////////////////////////////////////
|
||||
// Vertex structs
|
||||
//
|
||||
|
||||
struct vertexInput
|
||||
{
|
||||
float4 vertex : POSITION;
|
||||
float4 texcoord : TEXCOORD0;
|
||||
};
|
||||
|
||||
struct vertexOutput
|
||||
{
|
||||
V2F_SHADOW_CASTER;
|
||||
float2 texcoord : TEXCOORD1;
|
||||
};
|
||||
|
||||
////////////////////////////////////////
|
||||
// Vertex program
|
||||
//
|
||||
|
||||
vertexOutput vert(vertexInput v)
|
||||
{
|
||||
vertexOutput o;
|
||||
TRANSFER_SHADOW_CASTER(o)
|
||||
o.texcoord = calculateTextureCoord(v.texcoord);
|
||||
return o;
|
||||
}
|
||||
|
||||
////////////////////////////////////////
|
||||
// Fragment program
|
||||
//
|
||||
|
||||
|
||||
uniform fixed _ShadowAlphaCutoff;
|
||||
|
||||
fixed4 frag(vertexOutput IN) : SV_Target
|
||||
{
|
||||
fixed4 texureColor = calculateTexturePixel(IN.texcoord);
|
||||
clip(texureColor.a - _ShadowAlphaCutoff);
|
||||
|
||||
SHADOW_CASTER_FRAGMENT(IN)
|
||||
}
|
||||
|
||||
#endif // SPRITE_SHADOWS_INCLUDED
|
||||
@@ -0,0 +1,9 @@
|
||||
fileFormatVersion: 2
|
||||
guid: b7dbdfb1f55ee26459284220ad6d5bc4
|
||||
timeCreated: 1494092582
|
||||
licenseType: Free
|
||||
ShaderImporter:
|
||||
defaultTextures: []
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -0,0 +1,246 @@
|
||||
#ifndef SPRITE_SPECULAR_INCLUDED
|
||||
#define SPRITE_SPECULAR_INCLUDED
|
||||
|
||||
#include "ShaderMaths.cginc"
|
||||
|
||||
////////////////////////////////////////
|
||||
// Specular functions
|
||||
//
|
||||
|
||||
#if defined(_SPECULAR) || defined(_SPECULAR_GLOSSMAP)
|
||||
|
||||
#define SPECULAR
|
||||
|
||||
|
||||
//ALL THESE FUNCTIONS ARE TAKEN AND ADAPTED FROM UNITY'S OWN PHYSICS BASED STANDARD SHADER
|
||||
|
||||
uniform float _Metallic;
|
||||
uniform float _Glossiness;
|
||||
uniform float _GlossMapScale;
|
||||
uniform sampler2D _MetallicGlossMap;
|
||||
|
||||
struct SpecularLightData
|
||||
{
|
||||
half3 lighting;
|
||||
half3 specular;
|
||||
};
|
||||
|
||||
struct SpecularCommonData
|
||||
{
|
||||
half3 diffColor, specColor;
|
||||
// Note: smoothness & oneMinusReflectivity for optimization purposes, mostly for DX9 SM2.0 level.
|
||||
// Most of the math is being done on these (1-x) values, and that saves a few precious ALU slots.
|
||||
half oneMinusReflectivity, smoothness;
|
||||
half alpha;
|
||||
};
|
||||
|
||||
inline half2 getMetallicGloss(float2 uv)
|
||||
{
|
||||
half2 mg;
|
||||
|
||||
#ifdef _SPECULAR_GLOSSMAP
|
||||
mg = tex2D(_MetallicGlossMap, uv).ra;
|
||||
mg.g *= _GlossMapScale;
|
||||
#else
|
||||
mg.r = _Metallic;
|
||||
mg.g = _Glossiness;
|
||||
#endif
|
||||
|
||||
return mg;
|
||||
}
|
||||
|
||||
inline half getOneMinusReflectivityFromMetallic(half metallic)
|
||||
{
|
||||
// We'll need oneMinusReflectivity, so
|
||||
// 1-reflectivity = 1-lerp(dielectricSpec, 1, metallic) = lerp(1-dielectricSpec, 0, metallic)
|
||||
// store (1-dielectricSpec) in unity_ColorSpaceDielectricSpec.a, then
|
||||
// 1-reflectivity = lerp(alpha, 0, metallic) = alpha + metallic*(0 - alpha) =
|
||||
// = alpha - metallic * alpha
|
||||
half oneMinusDielectricSpec = unity_ColorSpaceDielectricSpec.a;
|
||||
return oneMinusDielectricSpec - metallic * oneMinusDielectricSpec;
|
||||
}
|
||||
|
||||
inline SpecularCommonData getSpecularData(float2 uv, half4 texureColor, fixed4 color)
|
||||
{
|
||||
half2 metallicGloss = getMetallicGloss(uv);
|
||||
half metallic = metallicGloss.x;
|
||||
half smoothness = metallicGloss.y; // this is 1 minus the square root of real roughness m.
|
||||
|
||||
fixed4 albedo = calculatePixel(texureColor, color);
|
||||
|
||||
half3 specColor = lerp (unity_ColorSpaceDielectricSpec.rgb, albedo, metallic);
|
||||
half oneMinusReflectivity = getOneMinusReflectivityFromMetallic(metallic);
|
||||
half3 diffColor = albedo * oneMinusReflectivity;
|
||||
|
||||
SpecularCommonData o = (SpecularCommonData)0;
|
||||
o.diffColor = diffColor;
|
||||
o.specColor = specColor;
|
||||
o.oneMinusReflectivity = oneMinusReflectivity;
|
||||
o.smoothness = smoothness;
|
||||
|
||||
#if defined(_ALPHAPREMULTIPLY_ON) && (SHADER_TARGET >= 30)
|
||||
// Reflectivity 'removes' from the rest of components, including Transparency
|
||||
// outAlpha = 1-(1-alpha)*(1-reflectivity) = 1-(oneMinusReflectivity - alpha*oneMinusReflectivity) =
|
||||
// = 1-oneMinusReflectivity + alpha*oneMinusReflectivity
|
||||
//o.alpha = 1-oneMinusReflectivity + albedo.a*oneMinusReflectivity;
|
||||
o.alpha = albedo.a;
|
||||
#else
|
||||
o.alpha = albedo.a;
|
||||
#endif
|
||||
|
||||
return o;
|
||||
}
|
||||
inline half SmoothnessToPerceptualRoughness(half smoothness)
|
||||
{
|
||||
return (1 - smoothness);
|
||||
}
|
||||
|
||||
inline half PerceptualRoughnessToRoughness(half perceptualRoughness)
|
||||
{
|
||||
return perceptualRoughness * perceptualRoughness;
|
||||
}
|
||||
|
||||
// Ref: http://jcgt.org/published/0003/02/03/paper.pdf
|
||||
inline half SmithJointGGXVisibilityTerm (half NdotL, half NdotV, half roughness)
|
||||
{
|
||||
#if 0
|
||||
// Original formulation:
|
||||
// lambda_v = (-1 + sqrt(a2 * (1 - NdotL2) / NdotL2 + 1)) * 0.5f;
|
||||
// lambda_l = (-1 + sqrt(a2 * (1 - NdotV2) / NdotV2 + 1)) * 0.5f;
|
||||
// G = 1 / (1 + lambda_v + lambda_l);
|
||||
|
||||
// Reorder code to be more optimal
|
||||
half a = roughness;
|
||||
half a2 = a * a;
|
||||
|
||||
half lambdaV = NdotL * sqrt((-NdotV * a2 + NdotV) * NdotV + a2);
|
||||
half lambdaL = NdotV * sqrt((-NdotL * a2 + NdotL) * NdotL + a2);
|
||||
|
||||
// Simplify visibility term: (2.0f * NdotL * NdotV) / ((4.0f * NdotL * NdotV) * (lambda_v + lambda_l + 1e-5f));
|
||||
return 0.5f / (lambdaV + lambdaL + 1e-5f); // This function is not intended to be running on Mobile,
|
||||
// therefore epsilon is smaller than can be represented by half
|
||||
#else
|
||||
// Approximation of the above formulation (simplify the sqrt, not mathematically correct but close enough)
|
||||
half a = roughness;
|
||||
half lambdaV = NdotL * (NdotV * (1 - a) + a);
|
||||
half lambdaL = NdotV * (NdotL * (1 - a) + a);
|
||||
|
||||
return 0.5f / (lambdaV + lambdaL + 1e-5f);
|
||||
#endif
|
||||
}
|
||||
|
||||
inline half GGXTerm (half NdotH, half roughness)
|
||||
{
|
||||
half a2 = roughness * roughness;
|
||||
half d = (NdotH * a2 - NdotH) * NdotH + 1.0f; // 2 mad
|
||||
return UNITY_INV_PI * a2 / (d * d + 1e-7f); // This function is not intended to be running on Mobile,
|
||||
// therefore epsilon is smaller than what can be represented by half
|
||||
}
|
||||
|
||||
inline half3 FresnelTerm (half3 F0, half cosA)
|
||||
{
|
||||
half t = pow5 (1 - cosA); // ala Schlick interpoliation
|
||||
return F0 + (1-F0) * t;
|
||||
}
|
||||
|
||||
inline half3 FresnelLerp (half3 F0, half F90, half cosA)
|
||||
{
|
||||
half t = pow5 (1 - cosA); // ala Schlick interpoliation
|
||||
return lerp (F0, F90, t);
|
||||
}
|
||||
|
||||
// Note: Disney diffuse must be multiply by diffuseAlbedo / PI. This is done outside of this function.
|
||||
inline half DisneyDiffuse(half NdotV, half NdotL, half LdotH, half perceptualRoughness)
|
||||
{
|
||||
half fd90 = 0.5 + 2 * LdotH * LdotH * perceptualRoughness;
|
||||
// Two schlick fresnel term
|
||||
half lightScatter = (1 + (fd90 - 1) * pow5(1 - NdotL));
|
||||
half viewScatter = (1 + (fd90 - 1) * pow5(1 - NdotV));
|
||||
|
||||
return lightScatter * viewScatter;
|
||||
}
|
||||
|
||||
// Main Physically Based BRDF
|
||||
// Derived from Disney work and based on Torrance-Sparrow micro-facet model
|
||||
//
|
||||
// BRDF = kD / pi + kS * (D * V * F) / 4
|
||||
// I = BRDF * NdotL
|
||||
//
|
||||
// * NDF (depending on UNITY_BRDF_GGX):
|
||||
// a) Normalized BlinnPhong
|
||||
// b) GGX
|
||||
// * Smith for Visiblity term
|
||||
// * Schlick approximation for Fresnel
|
||||
SpecularLightData calculatePhysicsBasedSpecularLight(half3 specColor, half oneMinusReflectivity, half smoothness, half3 normal, half3 viewDir, half3 lightdir, half3 lightColor, half3 indirectDiffuse, half3 indirectSpecular)
|
||||
{
|
||||
half perceptualRoughness = SmoothnessToPerceptualRoughness (smoothness);
|
||||
half3 halfDir = safeNormalize (lightdir + viewDir);
|
||||
|
||||
// NdotV should not be negative for visible pixels, but it can happen due to perspective projection and normal mapping
|
||||
// In this case normal should be modified to become valid (i.e facing camera) and not cause weird artifacts.
|
||||
// but this operation adds few ALU and users may not want it. Alternative is to simply take the abs of NdotV (less correct but works too).
|
||||
// Following define allow to control this. Set it to 0 if ALU is critical on your platform.
|
||||
// This correction is interesting for GGX with SmithJoint visibility function because artifacts are more visible in this case due to highlight edge of rough surface
|
||||
// Edit: Disable this code by default for now as it is not compatible with two sided lighting used in SpeedTree.
|
||||
#define UNITY_HANDLE_CORRECTLY_NEGATIVE_NDOTV 0
|
||||
|
||||
#if UNITY_HANDLE_CORRECTLY_NEGATIVE_NDOTV
|
||||
// The amount we shift the normal toward the view vector is defined by the dot product.
|
||||
half shiftAmount = dot(normal, viewDir);
|
||||
normal = shiftAmount < 0.0f ? normal + viewDir * (-shiftAmount + 1e-5f) : normal;
|
||||
// A re-normalization should be applied here but as the shift is small we don't do it to save ALU.
|
||||
//normal = normalize(normal);
|
||||
|
||||
half nv = saturate(dot(normal, viewDir)); // TODO: this saturate should no be necessary here
|
||||
#else
|
||||
half nv = abs(dot(normal, viewDir)); // This abs allow to limit artifact
|
||||
#endif
|
||||
|
||||
half nl = saturate(dot(normal, lightdir));
|
||||
half nh = saturate(dot(normal, halfDir));
|
||||
|
||||
half lv = saturate(dot(lightdir, viewDir));
|
||||
half lh = saturate(dot(lightdir, halfDir));
|
||||
|
||||
// Diffuse term
|
||||
half diffuseTerm = DisneyDiffuse(nv, nl, lh, perceptualRoughness) * nl;
|
||||
|
||||
// Specular term
|
||||
// HACK: theoretically we should divide diffuseTerm by Pi and not multiply specularTerm!
|
||||
// BUT 1) that will make shader look significantly darker than Legacy ones
|
||||
// and 2) on engine side "Non-important" lights have to be divided by Pi too in cases when they are injected into ambient SH
|
||||
half roughness = PerceptualRoughnessToRoughness(perceptualRoughness);
|
||||
half V = SmithJointGGXVisibilityTerm (nl, nv, roughness);
|
||||
half D = GGXTerm (nh, roughness);
|
||||
|
||||
half specularTerm = V*D * UNITY_PI; // Torrance-Sparrow model, Fresnel is applied later
|
||||
|
||||
# ifdef UNITY_COLORSPACE_GAMMA
|
||||
specularTerm = sqrt(max(1e-4h, specularTerm));
|
||||
# endif
|
||||
|
||||
// specularTerm * nl can be NaN on Metal in some cases, use max() to make sure it's a sane value
|
||||
specularTerm = max(0, specularTerm * nl);
|
||||
|
||||
// surfaceReduction = Int D(NdotH) * NdotH * Id(NdotL>0) dH = 1/(roughness^2+1)
|
||||
half surfaceReduction;
|
||||
# ifdef UNITY_COLORSPACE_GAMMA
|
||||
surfaceReduction = 1.0 - 0.28f * roughness * perceptualRoughness; // 1-0.28*x^3 as approximation for (1/(x^4+1))^(1/2.2) on the domain [0;1]
|
||||
# else
|
||||
surfaceReduction = 1.0 / (roughness*roughness + 1.0); // fade \in [0.5;1]
|
||||
# endif
|
||||
|
||||
// To provide true Lambert lighting, we need to be able to kill specular completely.
|
||||
specularTerm *= any(specColor) ? 1.0 : 0.0;
|
||||
|
||||
half grazingTerm = saturate(smoothness + (1-oneMinusReflectivity));
|
||||
|
||||
SpecularLightData outData = (SpecularLightData)0;
|
||||
outData.lighting = indirectDiffuse + lightColor * diffuseTerm;
|
||||
outData.specular = (specularTerm * lightColor * FresnelTerm (specColor, lh)) + (surfaceReduction * indirectSpecular * FresnelLerp (specColor, grazingTerm, nv));
|
||||
return outData;
|
||||
}
|
||||
|
||||
#endif // _SPECULAR && _SPECULAR_GLOSSMAP
|
||||
|
||||
#endif // SPRITE_SPECULAR_INCLUDED
|
||||
@@ -0,0 +1,9 @@
|
||||
fileFormatVersion: 2
|
||||
guid: f195336fc94457241a37a0aa85923681
|
||||
timeCreated: 1494092582
|
||||
licenseType: Free
|
||||
ShaderImporter:
|
||||
defaultTextures: []
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -0,0 +1,72 @@
|
||||
#ifndef SPRITE_UNLIT_INCLUDED
|
||||
#define SPRITE_UNLIT_INCLUDED
|
||||
|
||||
#include "ShaderShared.cginc"
|
||||
|
||||
////////////////////////////////////////
|
||||
// Vertex structs
|
||||
//
|
||||
|
||||
struct VertexInput
|
||||
{
|
||||
float4 vertex : POSITION;
|
||||
float4 texcoord : TEXCOORD0;
|
||||
fixed4 color : COLOR;
|
||||
UNITY_VERTEX_INPUT_INSTANCE_ID
|
||||
};
|
||||
|
||||
struct VertexOutput
|
||||
{
|
||||
float4 pos : SV_POSITION;
|
||||
float2 texcoord : TEXCOORD0;
|
||||
fixed4 color : COLOR;
|
||||
#if defined(_FOG)
|
||||
UNITY_FOG_COORDS(1)
|
||||
#endif // _FOG
|
||||
|
||||
UNITY_VERTEX_OUTPUT_STEREO
|
||||
};
|
||||
|
||||
////////////////////////////////////////
|
||||
// Vertex program
|
||||
//
|
||||
|
||||
VertexOutput vert(VertexInput input)
|
||||
{
|
||||
VertexOutput output;
|
||||
|
||||
UNITY_SETUP_INSTANCE_ID(input);
|
||||
UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output);
|
||||
|
||||
output.pos = calculateLocalPos(input.vertex);
|
||||
output.texcoord = calculateTextureCoord(input.texcoord);
|
||||
output.color = calculateVertexColor(input.color);
|
||||
|
||||
#if defined(_FOG)
|
||||
UNITY_TRANSFER_FOG(output,output.pos);
|
||||
#endif // _FOG
|
||||
|
||||
return output;
|
||||
}
|
||||
|
||||
////////////////////////////////////////
|
||||
// Fragment program
|
||||
//
|
||||
|
||||
|
||||
|
||||
|
||||
fixed4 frag(VertexOutput input) : SV_Target
|
||||
{
|
||||
fixed4 texureColor = calculateTexturePixel(input.texcoord.xy);
|
||||
ALPHA_CLIP(texureColor, input.color)
|
||||
|
||||
fixed4 pixel = calculatePixel(texureColor, input.color);
|
||||
|
||||
COLORISE(pixel)
|
||||
APPLY_FOG(pixel, input)
|
||||
|
||||
return pixel;
|
||||
}
|
||||
|
||||
#endif // SPRITE_UNLIT_INCLUDED
|
||||
@@ -0,0 +1,9 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 072e7b07ec7fb1346a9dcd3bcbbb7111
|
||||
timeCreated: 1494092582
|
||||
licenseType: Free
|
||||
ShaderImporter:
|
||||
defaultTextures: []
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -0,0 +1,474 @@
|
||||
#ifndef SPRITE_VERTEX_LIGHTING_INCLUDED
|
||||
#define SPRITE_VERTEX_LIGHTING_INCLUDED
|
||||
|
||||
#include "ShaderShared.cginc"
|
||||
#include "SpriteLighting.cginc"
|
||||
#include "SpriteSpecular.cginc"
|
||||
|
||||
////////////////////////////////////////
|
||||
// Defines
|
||||
//
|
||||
|
||||
//Define to use spot lights (more expensive)
|
||||
#define SPOT_LIGHTS
|
||||
|
||||
//Have to process lighting per pixel if using normal maps or a diffuse ramp or rim lighting or specular
|
||||
#if defined(_NORMALMAP) || defined(_DIFFUSE_RAMP) || defined(_RIM_LIGHTING) || defined(SPECULAR)
|
||||
#define PER_PIXEL_LIGHTING
|
||||
#endif
|
||||
|
||||
//Turn off bump mapping and diffuse ramping on older shader models as they dont support needed number of outputs
|
||||
#if defined(PER_PIXEL_LIGHTING) && (SHADER_TARGET < 30)
|
||||
#undef PER_PIXEL_LIGHTING
|
||||
#undef _NORMALMAP
|
||||
#undef _DIFFUSE_RAMP
|
||||
#undef _RIM_LIGHTING
|
||||
#endif
|
||||
|
||||
//In D3D9 only have a max of 9 TEXCOORD so can't have diffuse ramping or fog or rim lighting if processing lights per pixel
|
||||
#if defined(SHADER_API_D3D9) && defined(PER_PIXEL_LIGHTING)
|
||||
#if defined(_NORMALMAP)
|
||||
#undef _DIFFUSE_RAMP
|
||||
#undef _FOG
|
||||
#undef _RIM_LIGHTING
|
||||
#elif defined(_DIFFUSE_RAMP)
|
||||
#undef _FOG
|
||||
#undef _RIM_LIGHTING
|
||||
#elif defined(_RIM_LIGHTING)
|
||||
#undef _FOG
|
||||
#undef _DIFFUSE_RAMP
|
||||
#else
|
||||
#undef _DIFFUSE_RAMP
|
||||
#undef _RIM_LIGHTING
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if defined(PER_PIXEL_LIGHTING)
|
||||
#if defined(_NORMALMAP) && defined(_DIFFUSE_RAMP)
|
||||
#define ATTENUATIONS TEXCOORD9
|
||||
#if defined(_RIM_LIGHTING)
|
||||
#define _POS_WORLD_INDEX TEXCOORD10
|
||||
#define _FOG_COORD_INDEX 11
|
||||
#else
|
||||
#define _FOG_COORD_INDEX 10
|
||||
#endif
|
||||
#elif defined(_NORMALMAP) != defined(_DIFFUSE_RAMP)
|
||||
#define ATTENUATIONS TEXCOORD8
|
||||
#if defined(_RIM_LIGHTING)
|
||||
#define _POS_WORLD_INDEX TEXCOORD9
|
||||
#define _FOG_COORD_INDEX 10
|
||||
#else
|
||||
#define _FOG_COORD_INDEX 9
|
||||
#endif
|
||||
#else //!_DIFFUSE_RAMP && !_NORMALMAP
|
||||
#if defined(_RIM_LIGHTING)
|
||||
#define _POS_WORLD_INDEX TEXCOORD8
|
||||
#define _FOG_COORD_INDEX 9
|
||||
#else
|
||||
#define _FOG_COORD_INDEX 8
|
||||
#endif
|
||||
#endif
|
||||
#else //!PER_PIXEL_LIGHTING
|
||||
#define _FOG_COORD_INDEX 2
|
||||
#endif
|
||||
|
||||
////////////////////////////////////////
|
||||
// Vertex output struct
|
||||
//
|
||||
|
||||
struct VertexOutput
|
||||
{
|
||||
float4 pos : SV_POSITION;
|
||||
fixed4 color : COLOR;
|
||||
float3 texcoord : TEXCOORD0;
|
||||
|
||||
#if defined(PER_PIXEL_LIGHTING)
|
||||
|
||||
half4 VertexLightInfo0 : TEXCOORD1;
|
||||
half4 VertexLightInfo1 : TEXCOORD2;
|
||||
half4 VertexLightInfo2 : TEXCOORD3;
|
||||
half4 VertexLightInfo3 : TEXCOORD4;
|
||||
half4 VertexLightInfo4 : TEXCOORD5;
|
||||
|
||||
#if defined(_NORMALMAP)
|
||||
half4 normalWorld : TEXCOORD6;
|
||||
half4 tangentWorld : TEXCOORD7;
|
||||
half4 binormalWorld : TEXCOORD8;
|
||||
#else
|
||||
half3 normalWorld : TEXCOORD6;
|
||||
half3 VertexLightInfo5 : TEXCOORD7;
|
||||
#endif
|
||||
#if defined(_DIFFUSE_RAMP)
|
||||
half4 LightAttenuations : ATTENUATIONS;
|
||||
#endif
|
||||
#if defined(_RIM_LIGHTING)
|
||||
float4 posWorld : _POS_WORLD_INDEX;
|
||||
#endif
|
||||
|
||||
#else //!PER_PIXEL_LIGHTING
|
||||
|
||||
half3 FullLighting : TEXCOORD1;
|
||||
|
||||
#endif // !PER_PIXEL_LIGHTING
|
||||
|
||||
#if defined(_FOG)
|
||||
UNITY_FOG_COORDS(_FOG_COORD_INDEX)
|
||||
#endif // _FOG
|
||||
|
||||
UNITY_VERTEX_OUTPUT_STEREO
|
||||
};
|
||||
|
||||
////////////////////////////////////////
|
||||
// Light calculations
|
||||
//
|
||||
|
||||
struct VertexLightInfo
|
||||
{
|
||||
half3 lightDirection;
|
||||
fixed3 lightColor;
|
||||
|
||||
#if defined(_DIFFUSE_RAMP)
|
||||
float attenuation;
|
||||
#endif // _DIFFUSE_RAMP
|
||||
};
|
||||
|
||||
inline VertexLightInfo getVertexLightAttenuatedInfo(int index, float3 viewPos)
|
||||
{
|
||||
VertexLightInfo lightInfo;
|
||||
|
||||
//For directional lights unity_LightPosition.w is set to zero
|
||||
lightInfo.lightDirection = unity_LightPosition[index].xyz - viewPos.xyz * unity_LightPosition[index].w;
|
||||
float lengthSq = dot(lightInfo.lightDirection, lightInfo.lightDirection);
|
||||
|
||||
// don't produce NaNs if some vertex position overlaps with the light
|
||||
lengthSq = max(lengthSq, 0.000001);
|
||||
|
||||
lightInfo.lightDirection *= rsqrt(lengthSq);
|
||||
|
||||
float attenuation = 1.0 / (1.0 + lengthSq * unity_LightAtten[index].z);
|
||||
|
||||
#if defined(SPOT_LIGHTS)
|
||||
//Spot light attenuation - for non-spot lights unity_LightAtten.x is set to -1 and y is set to 1
|
||||
{
|
||||
float rho = max (0, dot(lightInfo.lightDirection, unity_SpotDirection[index].xyz));
|
||||
float spotAtt = (rho - unity_LightAtten[index].x) * unity_LightAtten[index].y;
|
||||
attenuation *= saturate(spotAtt);
|
||||
}
|
||||
#endif // SPOT_LIGHTS
|
||||
|
||||
//If using a diffuse ramp texture then need to pass through the lights attenuation, otherwise premultiply the light color with it
|
||||
#if defined(_DIFFUSE_RAMP)
|
||||
lightInfo.lightColor = unity_LightColor[index].rgb;
|
||||
lightInfo.attenuation = attenuation;
|
||||
#else
|
||||
lightInfo.lightColor = unity_LightColor[index].rgb * attenuation;
|
||||
#endif // _DIFFUSE_RAMP
|
||||
|
||||
return lightInfo;
|
||||
}
|
||||
|
||||
fixed3 calculateAmbientLight(half3 normalWorld)
|
||||
{
|
||||
#if defined(_SPHERICAL_HARMONICS)
|
||||
|
||||
//Magic constants used to tweak ambient to approximate pixel shader spherical harmonics
|
||||
static const fixed3 worldUp = fixed3(0,1,0);
|
||||
static const float skyGroundDotMul = 2.5;
|
||||
static const float minEquatorMix = 0.5;
|
||||
static const float equatorColorBlur = 0.33;
|
||||
|
||||
float upDot = dot(normalWorld, worldUp);
|
||||
|
||||
//Fade between a flat lerp from sky to ground and a 3 way lerp based on how bright the equator light is.
|
||||
//This simulates how directional lights get blurred using spherical harmonics
|
||||
|
||||
//Work out color from ground and sky, ignoring equator
|
||||
float adjustedDot = upDot * skyGroundDotMul;
|
||||
fixed3 skyGroundColor = lerp(unity_AmbientGround, unity_AmbientSky, saturate((adjustedDot + 1.0) * 0.5));
|
||||
|
||||
//Work out equator lights brightness
|
||||
float equatorBright = saturate(dot(unity_AmbientEquator.rgb, unity_AmbientEquator.rgb));
|
||||
|
||||
//Blur equator color with sky and ground colors based on how bright it is.
|
||||
fixed3 equatorBlurredColor = lerp(unity_AmbientEquator, saturate(unity_AmbientEquator + unity_AmbientGround + unity_AmbientSky), equatorBright * equatorColorBlur);
|
||||
|
||||
//Work out 3 way lerp inc equator light
|
||||
fixed3 equatorColor = lerp(equatorBlurredColor, unity_AmbientGround, -upDot) * step(upDot, 0) + lerp(equatorBlurredColor, unity_AmbientSky, upDot) * step(0, upDot);
|
||||
|
||||
//Mix the two colors together based on how bright the equator light is
|
||||
return lerp(skyGroundColor, equatorColor, saturate(equatorBright + minEquatorMix));
|
||||
|
||||
#else // !_SPHERICAL_HARMONICS
|
||||
|
||||
//Flat ambient is just the sky color
|
||||
return unity_AmbientSky.rgb;
|
||||
|
||||
#endif // !_SPHERICAL_HARMONICS
|
||||
}
|
||||
|
||||
////////////////////////////////////////
|
||||
// Light Packing Functions
|
||||
//
|
||||
|
||||
#if defined(_DIFFUSE_RAMP)
|
||||
|
||||
inline fixed3 calculateLightDiffuse(fixed3 lightColor, half3 viewNormal, half3 lightViewDir, float attenuation)
|
||||
{
|
||||
float angleDot = max(0, dot(viewNormal, lightViewDir));
|
||||
fixed3 lightDiffuse = calculateRampedDiffuse(lightColor, attenuation, angleDot);
|
||||
return lightDiffuse;
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
inline fixed3 calculateLightDiffuse(fixed3 attenuatedLightColor, half3 viewNormal, half3 lightViewDir)
|
||||
{
|
||||
float angleDot = max(0, dot(viewNormal, lightViewDir));
|
||||
fixed3 lightDiffuse = attenuatedLightColor * angleDot;
|
||||
|
||||
return lightDiffuse;
|
||||
}
|
||||
|
||||
#endif // _NORMALMAP
|
||||
|
||||
|
||||
#if defined(PER_PIXEL_LIGHTING)
|
||||
|
||||
#define VERTEX_LIGHT_0_DIR VertexLightInfo0.xyz
|
||||
#define VERTEX_LIGHT_0_R VertexLightInfo4.x
|
||||
#define VERTEX_LIGHT_0_G VertexLightInfo4.y
|
||||
#define VERTEX_LIGHT_0_B VertexLightInfo4.z
|
||||
|
||||
#define VERTEX_LIGHT_1_DIR VertexLightInfo1.xyz
|
||||
#define VERTEX_LIGHT_1_R VertexLightInfo0.w
|
||||
#define VERTEX_LIGHT_1_G VertexLightInfo1.w
|
||||
#define VERTEX_LIGHT_1_B VertexLightInfo2.w
|
||||
|
||||
#define VERTEX_LIGHT_2_DIR VertexLightInfo2.xyz
|
||||
#define VERTEX_LIGHT_2_R VertexLightInfo3.w
|
||||
#define VERTEX_LIGHT_2_G VertexLightInfo4.w
|
||||
#define VERTEX_LIGHT_2_B texcoord.z
|
||||
|
||||
#define VERTEX_LIGHT_3_DIR VertexLightInfo3.xyz
|
||||
|
||||
#if defined(_NORMALMAP)
|
||||
#define VERTEX_LIGHT_3_R normalWorld.w
|
||||
#define VERTEX_LIGHT_3_G tangentWorld.w
|
||||
#define VERTEX_LIGHT_3_B binormalWorld.w
|
||||
#else
|
||||
#define VERTEX_LIGHT_3_R VertexLightInfo5.x
|
||||
#define VERTEX_LIGHT_3_G VertexLightInfo5.y
|
||||
#define VERTEX_LIGHT_3_B VertexLightInfo5.z
|
||||
#endif
|
||||
|
||||
#if defined(_DIFFUSE_RAMP)
|
||||
|
||||
#define LIGHT_DIFFUSE_ATTEN_0 LightAttenuations.x
|
||||
#define LIGHT_DIFFUSE_ATTEN_1 LightAttenuations.y
|
||||
#define LIGHT_DIFFUSE_ATTEN_2 LightAttenuations.z
|
||||
#define LIGHT_DIFFUSE_ATTEN_3 LightAttenuations.w
|
||||
|
||||
#define PACK_VERTEX_LIGHT_DIFFUSE(index, output, lightInfo) \
|
||||
{ \
|
||||
output.LIGHT_DIFFUSE_ATTEN_##index = lightInfo.attenuation; \
|
||||
}
|
||||
|
||||
#define ADD_VERTEX_LIGHT_DIFFUSE(index, diffuse, input, lightColor, viewNormal, lightViewDir) \
|
||||
{ \
|
||||
diffuse += calculateLightDiffuse(lightColor, viewNormal, lightViewDir, input.LIGHT_DIFFUSE_ATTEN_##index); \
|
||||
}
|
||||
#else
|
||||
#define PACK_VERTEX_LIGHT_DIFFUSE(index, output, lightInfo)
|
||||
#define ADD_VERTEX_LIGHT_DIFFUSE(index, diffuse, input, lightColor, viewNormal, lightViewDir) \
|
||||
{ \
|
||||
diffuse += calculateLightDiffuse(lightColor, viewNormal, lightViewDir); \
|
||||
}
|
||||
#endif
|
||||
|
||||
#define PACK_VERTEX_LIGHT(index, output, viewPos) \
|
||||
{ \
|
||||
VertexLightInfo lightInfo = getVertexLightAttenuatedInfo(index, viewPos); \
|
||||
output.VERTEX_LIGHT_##index##_DIR = lightInfo.lightDirection; \
|
||||
output.VERTEX_LIGHT_##index##_R = lightInfo.lightColor.r; \
|
||||
output.VERTEX_LIGHT_##index##_G = lightInfo.lightColor.g; \
|
||||
output.VERTEX_LIGHT_##index##_B = lightInfo.lightColor.b; \
|
||||
PACK_VERTEX_LIGHT_DIFFUSE(index, output, lightInfo); \
|
||||
}
|
||||
|
||||
#define ADD_VERTEX_LIGHT(index, input, viewNormal, diffuse) \
|
||||
{ \
|
||||
half3 lightViewDir = input.VERTEX_LIGHT_##index##_DIR; \
|
||||
fixed3 lightColor = fixed3(input.VERTEX_LIGHT_##index##_R, input.VERTEX_LIGHT_##index##_G, input.VERTEX_LIGHT_##index##_B); \
|
||||
ADD_VERTEX_LIGHT_DIFFUSE(index, diffuse, input, lightColor, viewNormal, lightViewDir) \
|
||||
}
|
||||
|
||||
#if defined(SPECULAR)
|
||||
|
||||
#define ADD_VERTEX_LIGHT_SPEC(index, input, viewNormal, specData, combinedLightData, indirectDiffuse, indirectSpecular) \
|
||||
{ \
|
||||
half3 lightViewDir = input.VERTEX_LIGHT_##index##_DIR; \
|
||||
fixed3 lightColor = fixed3(input.VERTEX_LIGHT_##index##_R, input.VERTEX_LIGHT_##index##_G, input.VERTEX_LIGHT_##index##_B); \
|
||||
SpecularLightData lightData = calculatePhysicsBasedSpecularLight(specData.specColor, specData.oneMinusReflectivity, specData.smoothness, viewNormal, fixed3(0,0,1), lightViewDir, lightColor, indirectDiffuse, indirectSpecular); \
|
||||
combinedLightData.lighting += lightData.lighting; \
|
||||
combinedLightData.specular += lightData.specular; \
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
#else //!PER_PIXEL_LIGHTING
|
||||
|
||||
////////////////////////////////////////
|
||||
// Vertex Only Functions
|
||||
//
|
||||
|
||||
inline fixed3 calculateLightDiffuse(int index, float3 viewPos, half3 viewNormal)
|
||||
{
|
||||
VertexLightInfo lightInfo = getVertexLightAttenuatedInfo(index, viewPos);
|
||||
float angleDot = max(0, dot(viewNormal, lightInfo.lightDirection));
|
||||
return lightInfo.lightColor * angleDot;
|
||||
}
|
||||
|
||||
#endif // !PER_PIXEL_LIGHTING
|
||||
|
||||
////////////////////////////////////////
|
||||
// Vertex program
|
||||
//
|
||||
|
||||
VertexOutput vert(VertexInput input)
|
||||
{
|
||||
VertexOutput output;
|
||||
|
||||
UNITY_SETUP_INSTANCE_ID(input);
|
||||
UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output);
|
||||
|
||||
output.pos = calculateLocalPos(input.vertex);
|
||||
output.color = calculateVertexColor(input.color);
|
||||
output.texcoord = float3(calculateTextureCoord(input.texcoord), 0);
|
||||
|
||||
float3 viewPos = UnityObjectToViewPos(input.vertex); //float3 viewPos = mul(UNITY_MATRIX_MV, input.vertex); //
|
||||
#if defined(FIXED_NORMALS_BACKFACE_RENDERING) || defined(_RIM_LIGHTING)
|
||||
float4 powWorld = calculateWorldPos(input.vertex);
|
||||
#endif
|
||||
|
||||
float backFaceSign = 1;
|
||||
#if defined(FIXED_NORMALS_BACKFACE_RENDERING)
|
||||
backFaceSign = calculateBackfacingSign(powWorld.xyz);
|
||||
#endif
|
||||
|
||||
#if defined(PER_PIXEL_LIGHTING)
|
||||
|
||||
#if defined(_RIM_LIGHTING)
|
||||
output.posWorld = powWorld;
|
||||
#endif
|
||||
|
||||
PACK_VERTEX_LIGHT(0, output, viewPos)
|
||||
PACK_VERTEX_LIGHT(1, output, viewPos)
|
||||
PACK_VERTEX_LIGHT(2, output, viewPos)
|
||||
PACK_VERTEX_LIGHT(3, output, viewPos)
|
||||
|
||||
output.normalWorld.xyz = calculateSpriteWorldNormal(input, backFaceSign);
|
||||
|
||||
#if defined(_NORMALMAP)
|
||||
output.tangentWorld.xyz = calculateWorldTangent(input.tangent);
|
||||
output.binormalWorld.xyz = calculateSpriteWorldBinormal(input, output.normalWorld, output.tangentWorld, backFaceSign);
|
||||
#endif
|
||||
|
||||
#else // !PER_PIXEL_LIGHTING
|
||||
|
||||
//Just pack full lighting
|
||||
float3 viewNormal = calculateSpriteViewNormal(input, backFaceSign);
|
||||
//Get Ambient diffuse
|
||||
float3 normalWorld = calculateSpriteWorldNormal(input, backFaceSign);
|
||||
fixed3 ambient = calculateAmbientLight(normalWorld);
|
||||
|
||||
fixed3 diffuse = calculateLightDiffuse(0, viewPos, viewNormal);
|
||||
diffuse += calculateLightDiffuse(1, viewPos, viewNormal);
|
||||
diffuse += calculateLightDiffuse(2, viewPos, viewNormal);
|
||||
diffuse += calculateLightDiffuse(3, viewPos, viewNormal);
|
||||
|
||||
output.FullLighting = ambient + diffuse;
|
||||
|
||||
#endif // !PER_PIXEL_LIGHTING
|
||||
|
||||
#if defined(_FOG)
|
||||
UNITY_TRANSFER_FOG(output, output.pos);
|
||||
#endif // _FOG
|
||||
|
||||
return output;
|
||||
}
|
||||
|
||||
////////////////////////////////////////
|
||||
// Fragment program
|
||||
//
|
||||
|
||||
fixed4 frag(VertexOutput input) : SV_Target
|
||||
{
|
||||
fixed4 texureColor = calculateTexturePixel(input.texcoord.xy);
|
||||
ALPHA_CLIP(texureColor, input.color)
|
||||
|
||||
#if defined(PER_PIXEL_LIGHTING)
|
||||
|
||||
#if defined(_NORMALMAP)
|
||||
half3 normalWorld = calculateNormalFromBumpMap(input.texcoord.xy, input.tangentWorld.xyz, input.binormalWorld.xyz, input.normalWorld.xyz);
|
||||
#else
|
||||
half3 normalWorld = input.normalWorld.xyz;
|
||||
#endif
|
||||
|
||||
//Get Ambient diffuse
|
||||
fixed3 ambient = calculateAmbientLight(normalWorld);
|
||||
|
||||
half3 normalView = normalize(mul((float3x3)UNITY_MATRIX_V, normalWorld));
|
||||
|
||||
#if defined(SPECULAR)
|
||||
|
||||
SpecularCommonData specData = getSpecularData(input.texcoord.xy, texureColor, input.color);
|
||||
|
||||
SpecularLightData combinedLightData = (SpecularLightData)0;
|
||||
ADD_VERTEX_LIGHT_SPEC(0, input, normalView, specData, combinedLightData, ambient, unity_IndirectSpecColor.rgb)
|
||||
ADD_VERTEX_LIGHT_SPEC(1, input, normalView, specData, combinedLightData, fixed3(0,0,0), fixed3(0,0,0))
|
||||
ADD_VERTEX_LIGHT_SPEC(2, input, normalView, specData, combinedLightData, fixed3(0,0,0), fixed3(0,0,0))
|
||||
ADD_VERTEX_LIGHT_SPEC(3, input, normalView, specData, combinedLightData, fixed3(0,0,0), fixed3(0,0,0))
|
||||
|
||||
fixed4 pixel = calculateLitPixel(fixed4(specData.diffColor, specData.alpha), combinedLightData.lighting);
|
||||
pixel.rgb += combinedLightData.specular * specData.alpha;
|
||||
|
||||
APPLY_EMISSION_SPECULAR(pixel, input.texcoord)
|
||||
|
||||
#else
|
||||
|
||||
//Find vertex light diffuse
|
||||
fixed3 diffuse = fixed3(0,0,0);
|
||||
|
||||
//Add each vertex light to diffuse
|
||||
ADD_VERTEX_LIGHT(0, input, normalView, diffuse)
|
||||
ADD_VERTEX_LIGHT(1, input, normalView, diffuse)
|
||||
ADD_VERTEX_LIGHT(2, input, normalView, diffuse)
|
||||
ADD_VERTEX_LIGHT(3, input, normalView, diffuse)
|
||||
|
||||
fixed3 lighting = ambient + diffuse;
|
||||
|
||||
APPLY_EMISSION(lighting, input.texcoord.xy)
|
||||
|
||||
fixed4 pixel = calculateLitPixel(texureColor, input.color, lighting);
|
||||
|
||||
#endif
|
||||
|
||||
#if defined(_RIM_LIGHTING)
|
||||
pixel.rgb = applyRimLighting(input.posWorld, normalWorld, pixel);
|
||||
#endif
|
||||
|
||||
#else // !PER_PIXEL_LIGHTING
|
||||
|
||||
APPLY_EMISSION(input.FullLighting, input.texcoord.xy)
|
||||
|
||||
fixed4 pixel = calculateLitPixel(texureColor, input.color, input.FullLighting);
|
||||
|
||||
#endif // !PER_PIXEL_LIGHTING
|
||||
|
||||
COLORISE(pixel)
|
||||
APPLY_FOG(pixel, input)
|
||||
|
||||
return pixel;
|
||||
}
|
||||
|
||||
#endif // SPRITE_VERTEX_LIGHTING_INCLUDED
|
||||
@@ -0,0 +1,9 @@
|
||||
fileFormatVersion: 2
|
||||
guid: c739dcf9dbcab944898d0b796e11afb9
|
||||
timeCreated: 1494092582
|
||||
licenseType: Free
|
||||
ShaderImporter:
|
||||
defaultTextures: []
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
Reference in New Issue
Block a user