367 lines
13 KiB
HLSL
367 lines
13 KiB
HLSL
#include "UnityCG.cginc"
|
|
#include "Lighting.cginc"
|
|
#include "UnityStandardUtils.cginc"
|
|
#include "GlobalSnowDeferredOptions.cginc"
|
|
|
|
#define RELIEF_SAMPLE_COUNT 8
|
|
#define RELIEF_BINARY_SAMPLE_COUNT 8
|
|
#define RELIEF_MAX_RAY_LENGTH 0.5
|
|
// #define USE_BLEND_NORMALS_FUNCTION
|
|
|
|
uniform sampler2D_float _CameraDepthTexture;
|
|
uniform sampler2D_float _GS_DeferredExclusionBuffer;
|
|
uniform float4x4 _ClipToWorld;
|
|
uniform sampler2D _GS_GBuffer0Copy;
|
|
uniform sampler2D _GS_GBuffer1Copy;
|
|
#if GLOBALSNOW_FLAT_SHADING
|
|
#define _GS_GBuffer2Copy _CameraGBufferTexture2
|
|
#endif
|
|
uniform sampler2D _GS_GBuffer2Copy;
|
|
|
|
uniform sampler2D _GS_SnowTex;
|
|
uniform float4 _MainTex_TexelSize;
|
|
uniform float4 _MainTex_ST;
|
|
uniform sampler2D _GS_SnowNormalsTex;
|
|
uniform sampler2D _GS_NoiseTex;
|
|
uniform sampler2D_float _GS_DepthTexture;
|
|
uniform sampler2D_float _GS_FootprintTex;
|
|
uniform sampler2D _GS_DetailTex;
|
|
uniform sampler2D_float _GS_DecalTex;
|
|
uniform float4 _GS_DecalTex_TexelSize;
|
|
uniform float4 _GS_SnowCamPos;
|
|
uniform float4 _GS_SunDir; // w = terrain mark distance
|
|
uniform float4 _GS_SnowData1; // x = relief, y = occlusion, z = glitter, w = brightness
|
|
uniform float4 _GS_SnowData2; // x = minimum altitude for vegetation and trees, y = altitude scattering, z = coverage extension, w = billboard coverage
|
|
uniform float4 _GS_SnowData3; // x = Sun occlusion, y = sun atten, z = ground coverage, w = grass coverage
|
|
uniform float4 _GS_SnowData4; // x = footprint scale, y = footprint obscurance, z = snow normals strength, w = minimum altitude for terrain including scattering
|
|
uniform float4 _GS_SnowData5; // x = slope threshold, y = slope sharpness, z = slope noise, w = noise scale
|
|
uniform float4 _GS_SnowData6; // x = _Alpha, y = _Smoothness, z = altitude blending, w = snow thickness
|
|
uniform half4 _GS_SnowTint;
|
|
|
|
#define SNOW_TEXTURE_SCALE _GS_SnowData5.w
|
|
#define SNOW_NORMALS_STRENGTH _GS_SnowData4.z
|
|
|
|
#if !defined(USE_ZENITHAL_DEPTH)
|
|
uniform sampler2D _GS_DepthMask;
|
|
uniform float4 _GS_DepthMaskWorldSize;
|
|
#endif
|
|
|
|
uniform float3 _FlickerFreeCamPos;
|
|
|
|
struct v2f {
|
|
float4 pos: SV_POSITION;
|
|
float2 uv : TEXCOORD0;
|
|
float3 cameraToFarPlane : TEXCOORD2;
|
|
};
|
|
|
|
|
|
v2f vert(appdata_img v) {
|
|
v2f o;
|
|
o.pos = float4(v.vertex.xy, 0, 1);
|
|
#if UNITY_UV_STARTS_AT_TOP
|
|
o.pos.y *= -1;
|
|
#endif
|
|
|
|
o.uv = TransformStereoScreenSpaceTex((v.vertex + 1.0) * 0.5, 1.0);
|
|
|
|
// Clip space X and Y coords
|
|
float2 clipXY = o.pos.xy / o.pos.w;
|
|
|
|
// Position of the far plane in clip space
|
|
float4 farPlaneClip = float4(clipXY, 1, 1);
|
|
|
|
// Homogeneous world position on the far plane
|
|
farPlaneClip.y *= _ProjectionParams.x;
|
|
_ClipToWorld = mul(_ClipToWorld, unity_CameraInvProjection);
|
|
float4 farPlaneWorld4 = mul(_ClipToWorld, farPlaneClip);
|
|
|
|
// World position on the far plane
|
|
float3 farPlaneWorld = farPlaneWorld4.xyz / farPlaneWorld4.w;
|
|
|
|
// Vector from the camera to the far plane
|
|
o.cameraToFarPlane = farPlaneWorld - _WorldSpaceCameraPos + _FlickerFreeCamPos;
|
|
return o;
|
|
}
|
|
|
|
inline float3 getWorldPos(v2f i, float depth01) {
|
|
return i.cameraToFarPlane * depth01 + _WorldSpaceCameraPos;
|
|
}
|
|
|
|
// get snow coverage
|
|
#if GLOBALSNOW_FLAT_SHADING
|
|
void frag(v2f i, out half4 outAlbedo: SV_Target0, out half4 outSpecular: SV_Target1, out half4 outAmbient : SV_Target2 ) {
|
|
#else
|
|
void frag(v2f i, out half4 outAlbedo: SV_Target0, out half4 outSpecular: SV_Target1, out half4 outNormal: SV_Target2, out half4 outAmbient : SV_Target3 ) {
|
|
#endif
|
|
|
|
float depth01 = Linear01Depth(UNITY_SAMPLE_DEPTH(tex2D(_CameraDepthTexture, i.uv)));
|
|
float depthExclusion = Linear01Depth(UNITY_SAMPLE_DEPTH(tex2D(_GS_DeferredExclusionBuffer, i.uv))) * 0.9999;
|
|
|
|
#if GLOBALSNOW_FLAT_SHADING
|
|
float2 uv_flat = i.uv;
|
|
#endif
|
|
i.uv = TransformStereoScreenSpaceTex(i.uv, 1.0);
|
|
|
|
outSpecular = 0;
|
|
#if !GLOBALSNOW_FLAT_SHADING
|
|
outNormal = 0;
|
|
#endif
|
|
outAmbient = 0;
|
|
outAlbedo = 0;
|
|
|
|
#if defined(EXCLUDE_NEAR_SNOW)
|
|
depth01 = max(depth01, NEAR_DISTANCE_SNOW);
|
|
#endif
|
|
|
|
if (depthExclusion <= depth01) {
|
|
discard;
|
|
return;
|
|
}
|
|
|
|
float3 worldPos = getWorldPos(i, depth01);
|
|
float3 snowPos = worldPos;
|
|
|
|
#if defined(USE_ZENITHAL_DEPTH)
|
|
float4 st = float4(worldPos.xz - _GS_SnowCamPos.xz, 0, 0);
|
|
st *= _GS_SnowData2.z;
|
|
st += 0.5;
|
|
float2 zmask = tex2Dlod(_GS_DepthTexture, st).rg;
|
|
_GS_SnowData6.x += zmask.g;
|
|
float y = max(_GS_SnowCamPos.y - worldPos.y, 0.001) / _GS_SnowCamPos.w;
|
|
float zd = min(zmask.r + _GS_SnowData3.z, y);
|
|
fixed snowCover = saturate( ((zd / y) - 0.9875) * 110.0);
|
|
#else
|
|
float2 maskUV = (worldPos.xz - _GS_DepthMaskWorldSize.yw) / _GS_DepthMaskWorldSize.xz + 0.5.xx;
|
|
fixed snowCover = tex2D(_GS_DepthMask, maskUV).a;
|
|
if (maskUV.x<=0.01 || maskUV.x>=0.99 || maskUV.y<=0.01 || maskUV.y>=0.99) snowCover = 1.0;
|
|
#endif
|
|
|
|
// diffuse
|
|
#if GLOBALSNOW_FLAT_SHADING
|
|
fixed4 diff = tex2D(_GS_SnowTex, snowPos.xz * 0.02);
|
|
#else
|
|
fixed4 diff = tex2D(_GS_SnowTex, snowPos.xz * 0.02).gggg;
|
|
#endif
|
|
|
|
// get world space normal
|
|
#if GLOBALSNOW_FLAT_SHADING
|
|
float3 wsNormal = tex2D(_GS_GBuffer2Copy, uv_flat).xyz * 2.0 - 1.0;
|
|
#else
|
|
float3 wsNormal = tex2D(_GS_GBuffer2Copy, i.uv).xyz * 2.0 - 1.0;
|
|
#endif
|
|
|
|
// prevent snow on walls and below minimum altitude
|
|
float altG = tex2D(_GS_SnowTex, snowPos.xz * 0.5).g;
|
|
float altNoise = diff.r * altG - 0.9;
|
|
#if !SHADER_API_D3D9 && defined(GLOBALSNOW_ENABLE_SLOPE_CONTROL)
|
|
float ny = wsNormal.y - _GS_SnowData5.x;
|
|
float flatSurface = saturate( (ny + altNoise * _GS_SnowData5.z) * _GS_SnowData5.y);
|
|
#else
|
|
float ny = wsNormal.y - 0.7;
|
|
float flatSurface = saturate(ny * 15.0);
|
|
#endif
|
|
float minAltitude = worldPos.y - _GS_SnowData2.w - altNoise * _GS_SnowData2.y;
|
|
minAltitude = saturate(minAltitude / _GS_SnowData6.z);
|
|
|
|
snowCover = snowCover * minAltitude * flatSurface - _GS_SnowData6.x;
|
|
if (snowCover <= 0) {
|
|
discard;
|
|
return;
|
|
}
|
|
|
|
const float snowHeight = _GS_SnowData1.x; // Range: 0.001 .. 0.3 or will distort
|
|
float3 rayDir = normalize(_WorldSpaceCameraPos - snowPos);
|
|
|
|
// relief
|
|
#if GLOBALSNOW_RELIEF || GLOBALSNOW_OCCLUSION
|
|
float height = 0;
|
|
if (snowCover > 0.1) {
|
|
// 3D surface mapping
|
|
snowPos.y = 0;
|
|
float3 snowPos0 = snowPos + float3(rayDir.x, max(0.3, rayDir.y), rayDir.z) * RELIEF_MAX_RAY_LENGTH;
|
|
float3 rayStep = (snowPos - snowPos0) / (float)RELIEF_SAMPLE_COUNT;
|
|
// locate hit point
|
|
UNITY_UNROLL
|
|
for (int k=0;k<RELIEF_SAMPLE_COUNT;k++) {
|
|
float h1 = tex2Dlod(_GS_NoiseTex, float4(snowPos0.xz * SNOW_TEXTURE_SCALE, 0, 0)).g * snowHeight; // use tex2Dlod to prevent artifacts due to quantization of step
|
|
if (h1>snowPos0.y) {
|
|
snowPos = snowPos0;
|
|
snowPos0 -= rayStep;
|
|
break;
|
|
}
|
|
snowPos0 += rayStep;
|
|
}
|
|
// binary search
|
|
UNITY_UNROLL
|
|
for (int j=0;j<RELIEF_BINARY_SAMPLE_COUNT;j++) {
|
|
float3 occ = (snowPos0 + snowPos) * 0.5;
|
|
height = tex2D(_GS_NoiseTex, occ.xz * SNOW_TEXTURE_SCALE).g; // don't use tex2Dlod to prevent occlusion artifacts - we need an average here
|
|
if (height * snowHeight>occ.y) {
|
|
snowPos = occ;
|
|
} else {
|
|
snowPos0 = occ;
|
|
}
|
|
}
|
|
}
|
|
#if GLOBALSNOW_OCCLUSION
|
|
// fake occlusion (optional)
|
|
float height2 = tex2D(_GS_NoiseTex, (snowPos.xz + (_GS_SunDir.xz) * 0.03) * SNOW_TEXTURE_SCALE).g;
|
|
diff.a = saturate(height-height2);
|
|
#endif
|
|
#endif // RELIEF
|
|
|
|
// surface normal at point
|
|
#if GLOBALSNOW_FLAT_SHADING
|
|
float3 norm = float3(0,1,0);
|
|
#else
|
|
float4 texNorm1 = tex2D(_GS_SnowNormalsTex, snowPos.xz * SNOW_TEXTURE_SCALE);
|
|
float3 norm1 = UnpackNormal(texNorm1);
|
|
// perturb normal (optional)
|
|
float4 texNorm2 = tex2D(_GS_SnowNormalsTex, snowPos.xz * SNOW_TEXTURE_SCALE * 64.0);
|
|
float3 norm2 = UnpackNormal(texNorm2);
|
|
#if defined(USE_BLEND_NORMALS_FUNCTION)
|
|
float3 norm = BlendNormals(norm1, norm2);
|
|
#else
|
|
float3 norm = (norm1 + norm2) * 0.5;
|
|
#endif
|
|
|
|
// rotate snow normal in world space
|
|
float3 axis = normalize(float3(norm.y, 0, -norm.x));
|
|
float angle = acos(norm.z);
|
|
float s, c;
|
|
sincos(angle, s, c);
|
|
float oc = 1.0 - c;
|
|
float3x3 rot = float3x3(oc * axis.x * axis.x + c, oc * axis.x * axis.y - axis.z * s, oc * axis.z * axis.x + axis.y * s,
|
|
oc * axis.x * axis.y + axis.z * s, oc * axis.y * axis.y + c, oc * axis.y * axis.z - axis.x * s,
|
|
oc * axis.z * axis.x - axis.y * s, oc * axis.y * axis.z + axis.x * s, oc * axis.z * axis.z + c);
|
|
|
|
norm = lerp(mul(rot, wsNormal), norm.xzy, _GS_SnowData6.w * wsNormal.y);
|
|
norm = normalize(lerp(wsNormal, norm, snowCover * SNOW_NORMALS_STRENGTH));
|
|
|
|
// glitter (optional)
|
|
float randomFacet = frac(norm.x * 173.13) - 0.99;
|
|
float normalGloss = saturate(dot(-_GS_SunDir.xyz, norm));
|
|
float glitter = saturate(randomFacet * 55.0) * normalGloss * _GS_SnowData1.z;
|
|
#endif
|
|
|
|
#if GLOBALSNOW_TERRAINMARKS
|
|
float drawDistSqr = dot(worldPos - _WorldSpaceCameraPos, worldPos - _WorldSpaceCameraPos);
|
|
if (drawDistSqr< _GS_SunDir.w) {
|
|
const float decalTexScale = 8.0 * _GS_DecalTex_TexelSize.x; // / 2048.0;
|
|
const float texelScale = 0.1;
|
|
const float2 offs = float2(-0.5, 0.5);
|
|
float2 uv00 = (snowPos.xz + offs.xx * texelScale) * decalTexScale;
|
|
float2 uv01 = (snowPos.xz + offs.xy * texelScale) * decalTexScale;
|
|
float2 uv10 = (snowPos.xz - offs.xy * texelScale) * decalTexScale;
|
|
float4 decal = tex2D(_GS_DecalTex, uv00);
|
|
float h00 = decal.y;
|
|
float h01 = tex2D(_GS_DecalTex, uv01).y;
|
|
float h10 = tex2D(_GS_DecalTex, uv10).y;
|
|
float sh = h00+h01+h10;
|
|
sh *= snowCover;
|
|
if (sh>0) {
|
|
#if !GLOBALSNOW_FLAT_SHADING
|
|
float3 dduv00 = normalize(float3(offs.x, h00, offs.x));
|
|
float3 dduv01 = normalize(float3(offs.x, h01, offs.y));
|
|
float3 dduv10 = normalize(float3(offs.y, h10, offs.x));
|
|
float3 dduvA = (dduv01 - dduv00);
|
|
float3 dduvB = (dduv10 - dduv00);
|
|
float3 holeNorm = cross(dduvB, dduvA);
|
|
holeNorm.y *= -0.5;
|
|
norm = lerp(norm, holeNorm, saturate( sh/1.75));
|
|
norm = normalize(norm) + 0.00001.xxx;
|
|
#endif // !FLAT_SHADING
|
|
|
|
diff.rgb -= sh / 38.0; // simulate self shadowing - the value of 38.0 can be decreased / increased to change obscurance
|
|
#if GLOBALSNOW_OCCLUSION
|
|
diff.a = lerp(diff.a, diff.a * 0.5, sh/3.0);
|
|
#endif
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#if GLOBALSNOW_FOOTPRINTS
|
|
snowPos.xz = lerp(snowPos.xz, worldPos.xz, 0.9); // make footprint less flat
|
|
snowPos.xz *= _GS_SnowData4.xx;
|
|
float4 dd = tex2D(_GS_FootprintTex, snowPos.xz / 2048.0);
|
|
dd.y *= snowCover;
|
|
if (dd.y) {
|
|
float2 dduv0 = frac(snowPos.xz) - 0.5.xx;
|
|
float4 dduv = float4(0,0,0,0);
|
|
// rotate decal hit pos
|
|
dduv.x = dot(dduv0, float2(dd.x, -dd.z));
|
|
dduv.y = dot(dduv0, dd.zx);
|
|
dduv.xy += 0.5.xx;
|
|
float4 dt = tex2Dlod(_GS_DetailTex, dduv);
|
|
if (dt.a) { // hole
|
|
#if GLOBALSNOW_OCCLUSION
|
|
diff.a *= 0.35; // soften occlusion inside plain hole
|
|
#endif
|
|
// 3D hole (optional)
|
|
const int holeSamples = 5;
|
|
const float deepness = 0.02; // (option)
|
|
// rotate raydir
|
|
dduv0.x = dot(-rayDir.xz, float2(dd.x, -dd.z)); // dduv0.x * dd.x - dduv0.y * dd.z;
|
|
dduv0.y = dot(-rayDir.xz, dd.zx); // dduv0.x * dd.z + dduv0.y * dd.x;
|
|
float4 holeStep = float4(dduv0 * deepness, 0, 0);
|
|
float3 holeNorm = float3(0.0,1.0,0.0);
|
|
float holeDeep = 0.75; // (option)
|
|
UNITY_UNROLL
|
|
for (int k=0;k<holeSamples;k++) {
|
|
dt = tex2Dlod(_GS_DetailTex, dduv);
|
|
if (dt.a<=0) { // no hole
|
|
float kh = (float)k / holeSamples;
|
|
#if GLOBALSNOW_OCCLUSION
|
|
diff.a += 0.075 * kh * dd.y; // add occlusion around edges of hole
|
|
#endif
|
|
holeDeep *= kh;
|
|
holeNorm = rayDir; // * 0.95;
|
|
break;
|
|
}
|
|
dduv += holeStep;
|
|
}
|
|
diff.rgb *= 1.0 - dd.y * _GS_SnowData4.y;
|
|
norm = normalize(lerp(norm, holeNorm, dd.y * holeDeep));
|
|
}
|
|
}
|
|
#endif
|
|
|
|
// output g-buffer values
|
|
#if !GLOBALSNOW_FLAT_SHADING
|
|
outNormal = half4(norm * 0.5 + 0.5, 1.0);
|
|
#endif
|
|
|
|
// Albedo
|
|
fixed3 snowAlbedo;
|
|
#if GLOBALSNOW_OCCLUSION
|
|
snowAlbedo = (diff.rgb * _GS_SnowTint.rgb + glitter.xxx) * (_GS_SnowData1.w * saturate (1.0 - diff.a * _GS_SnowData1.y));
|
|
#elif GLOBALSNOW_FLAT_SHADING
|
|
snowAlbedo = diff.rgb * _GS_SnowTint.rgb * _GS_SnowData1.w;
|
|
#else
|
|
snowAlbedo = (diff.rgb * _GS_SnowTint.rgb + glitter.xxx) * _GS_SnowData1.w;
|
|
#endif
|
|
|
|
// Specular
|
|
float gloss = saturate(0.65 + _GS_SunDir.y);
|
|
half4 newSpecular = half4(snowAlbedo * gloss, _GS_SnowData6.y) * _GS_SnowData3.x;
|
|
if (snowCover>=1.0) {
|
|
outAlbedo = half4(snowAlbedo, 0.0);
|
|
outSpecular = newSpecular;
|
|
} else {
|
|
outAlbedo = tex2Dlod(_GS_GBuffer0Copy, float4(i.uv, 0, 0));
|
|
outAlbedo = lerp(outAlbedo, half4(snowAlbedo, 0), snowCover);
|
|
outSpecular = tex2Dlod(_GS_GBuffer1Copy, float4(i.uv, 0, 0));
|
|
outSpecular = lerp(outSpecular, newSpecular, snowCover);
|
|
}
|
|
|
|
half3 ambientColor = max(0, ShadeSH9(float4(norm, 1)));
|
|
ambientColor = lerp(ambientColor, ambientColor.ggg, _GS_SnowTint.a) * outAlbedo.rgb;
|
|
#if UNITY_HDR_ON
|
|
outAmbient.rgb = ambientColor;
|
|
#else
|
|
outAmbient.rgb = exp2(-ambientColor);
|
|
#endif
|
|
|
|
}
|
|
|