2c4520000b
Replaced Unity TAA with PlayDead TAA Custom keyboard layout test scene Adjusted Aetheric Drive VFX to be more subtle Reworked stardust VFX to reduce flickering artifacts Added Action Bar & weapon groups saving/loading Implemented security levels and faction safe zone visualization Improved station placement (now include defensive turrets)
307 lines
8.7 KiB
GLSL
307 lines
8.7 KiB
GLSL
Shader "VolSample/Volume Render" {
|
|
Properties {
|
|
_MainTex( "", 2D ) = "white" {}
|
|
_StepExponent("Step Exponent", float) = 1
|
|
_Surface("Surface", 2D) = "black" {}
|
|
_Patch("Patch", 2D) = "black" {}
|
|
_Displacement("Displacement", 2D) = "black" {}
|
|
_TintTexture("Tint Texture", 2D ) = "white" {}
|
|
[HDR]_Tint("Tint Color", Color) = (1,1,1,1)
|
|
//_GridTransform("Grid Transform", Vector) = (0,0,0,0)
|
|
_GridFillDensity("Fill Density", float) = 1
|
|
_GridFloorDensity("Floor Density", float) = 1
|
|
_GridPatchDensity("Patch Density", float) = 1
|
|
_GridFloorOffset("Floor Offset", float) = 1
|
|
_GridFloorBlend("Floor Blend", float) = 1
|
|
_GridPatchBlend("Patch Blend", float) = 1
|
|
_Gamma("Gamma", float) = .5
|
|
_TintExponent("Tint Exponent", float) = .5
|
|
_DepthCeiling("Depth Ceiling", float) = 1000
|
|
_DepthBlend("Depth Blend", float) = 100
|
|
_NoiseStrength("Noise Strength", float) = 1
|
|
_NoiseFrequency("Noise Frequency", float) = 1
|
|
_NoiseSpeed("Noise Speed", float) = 1
|
|
_SafetyDistance("Safety Distance", float) = 20
|
|
_Scattering("Scattering", float) = 1
|
|
_ScatteringMinDist("ScatteringMinDist", float) = 1
|
|
_ScatteringDistExponent("ScatteringDistExponent", float) = 1
|
|
_ScatteringDensityExponent("ScatteringDensityExponent", float) = 1
|
|
}
|
|
|
|
CGINCLUDE;
|
|
|
|
uniform sampler2D _MainTex;
|
|
uniform sampler2D _CameraDepthTexture;
|
|
|
|
uniform sampler2D _Surface;
|
|
uniform sampler2D _Patch;
|
|
uniform sampler2D _Displacement;
|
|
uniform sampler2D _TintTexture;
|
|
//uniform sampler3D _NoiseTex;
|
|
|
|
#include "UnityCG.cginc"
|
|
|
|
// the number of volume samples to take
|
|
#define SAMPLE_COUNT 128
|
|
|
|
// Shared shader code for pixel view rays, given screen pos and camera frame vectors.
|
|
// Camera vectors are passed in as this shader is run from a post proc camera, so the unity built-in values are not useful.
|
|
uniform float4x4 _CamProj;
|
|
uniform float4x4 _CamInvProj;
|
|
uniform float3 _CamPos;
|
|
uniform float3 _CamForward;
|
|
uniform float3 _CamRight;
|
|
uniform float _HalfFov;
|
|
uniform int _FrameNumber;
|
|
|
|
uniform float _StepExponent;
|
|
|
|
uniform float3 _GridTransform;
|
|
|
|
uniform half4 _Tint;
|
|
|
|
uniform half _GridFillDensity,
|
|
_GridFloorDensity,
|
|
_GridPatchDensity,
|
|
_GridFloorOffset,
|
|
_GridFloorBlend,
|
|
_GridPatchBlend,
|
|
_Gamma,
|
|
_TintExponent,
|
|
_DepthCeiling,
|
|
_DepthBlend,
|
|
_NoiseFrequency,
|
|
_NoiseStrength,
|
|
_NoiseSpeed,
|
|
_Scattering,
|
|
_ScatteringDensityExponent,
|
|
_ScatteringDistExponent,
|
|
_ScatteringMinDist,
|
|
_SafetyDistance;
|
|
|
|
// Dithering
|
|
sampler2D _DitheringTex;
|
|
float4 _DitheringCoords;
|
|
|
|
inline float nrand(float2 ScreenUVs)
|
|
{
|
|
return frac(sin(ScreenUVs.x * 12.9898 + ScreenUVs.y * 78.233) * 43758.5453);
|
|
}
|
|
|
|
float tri(in float x){return abs(frac(x)-.5);}
|
|
float3 tri3(in float3 p){return float3( tri(p.z+tri(p.y*1.)), tri(p.z+tri(p.x*1.)), tri(p.y+tri(p.x*1.)));}
|
|
|
|
float triNoise3d(in float3 p)
|
|
{
|
|
float z=1.4;
|
|
float rz = 0.;
|
|
float3 bp = p;
|
|
for (float i=0.; i<=2.; i++ )
|
|
{
|
|
float3 dg = tri3(bp * 2.);
|
|
p += dg + _Time.y * _NoiseSpeed;
|
|
|
|
bp *= 1.8;
|
|
z *= 1.5;
|
|
p *= 1.2;
|
|
|
|
rz+= (tri(p.z+tri(p.x+tri(p.y))))/z;
|
|
bp += 0.14;
|
|
}
|
|
return rz;
|
|
}
|
|
|
|
float4 VolumeSampleColor(float3 pos)
|
|
{
|
|
float2 uv = -(pos.xz-_GridTransform.xy)/_GridTransform.z + float2(.5,.5);
|
|
|
|
float surface = tex2Dlod(_Surface, half4(uv, 0, 0)).r;
|
|
float dist = pos.y + surface - _GridFloorOffset;
|
|
float4 lightTint = tex2Dlod(_TintTexture, half4(uv, 0, dist/30));
|
|
float fillDensity = saturate(-pos.y * _GridFillDensity);
|
|
|
|
if(dist < _SafetyDistance)
|
|
{
|
|
float patch = tex2Dlod(_Patch, half4(uv, 0, 0)).r;
|
|
float displacement = tex2Dlod(_Displacement, half4(uv, 0, 0)).r;
|
|
|
|
//float noise = tex3D(_NoiseTex, pos*_NoiseFrequency);
|
|
float noise = pow(triNoise3d(pos*_NoiseFrequency),2)* _NoiseStrength;// + triNoise3d(pos*_NoiseFrequency*2, _NoiseSpeed * 2) * .5;
|
|
pos.y += noise;
|
|
float patchDensity = saturate((-abs(pos.y+displacement)+patch)/_GridPatchBlend)*_GridPatchDensity;
|
|
float floorDist = -pos.y-surface+_GridFloorOffset;
|
|
float floorDensity = floorDist/_GridFloorBlend*_GridFloorDensity;
|
|
float fogDensity = patchDensity + max(0,floorDensity);
|
|
float alpha = min(max(fogDensity, 0) + fillDensity, .99);
|
|
float albedo = pow(1-alpha, _TintExponent) * smoothstep(0,-250,pos.y);
|
|
return float4((albedo*_Tint*lightTint).rgb, alpha);
|
|
}
|
|
|
|
float albedo = pow(1-fillDensity, _TintExponent);
|
|
return float4((albedo*_Tint*lightTint).rgb, fillDensity);
|
|
}
|
|
|
|
void RaymarchStep( in float3 pos, in float stepSize, in float weight, inout float4 sum, in float scatter, inout float scatterSum)
|
|
{
|
|
if( sum.a <= 0.99 )
|
|
{
|
|
float4 col = VolumeSampleColor( pos );
|
|
col.rgb *= weight * (1.0 - sum.a);
|
|
|
|
sum += stepSize * col * col.a;
|
|
scatterSum += pow(col.a, _ScatteringDensityExponent) * scatter;
|
|
}
|
|
}
|
|
|
|
float4 RayMarch( in float3 origin, in float3 direction, in float zbuf, in float2 screenUV, out float scatterSum )
|
|
{
|
|
scatterSum = 0;
|
|
float blue = tex2D(_DitheringTex, screenUV * _DitheringCoords.xy).r;
|
|
float rand = frac(blue + _FrameNumber * 1.61803398875);
|
|
//return float4(rand, rand, rand, 1);
|
|
//half rand = frac(nrand(screenUV) + _FrameNumber * 1.61803398875);
|
|
//half rand = nrand(screenUV + frac(_Time.x)) * 2;
|
|
float4 sum = (float4)0.;
|
|
scatterSum = 0.;
|
|
|
|
// setup sampling
|
|
|
|
float offset = rand/SAMPLE_COUNT;
|
|
float rayDist = 0;
|
|
for( int i = 0; i < SAMPLE_COUNT; i++ )
|
|
{
|
|
float prevRayDist = rayDist;
|
|
rayDist = pow((float)i/SAMPLE_COUNT + offset,_StepExponent) * _DepthCeiling;
|
|
float distToSurf = zbuf - rayDist;
|
|
if( distToSurf <= 0.001 || sum.a > .99) break;
|
|
|
|
float step = rayDist - prevRayDist;
|
|
//float wt = (distToSurf >= step) ? 1. : distToSurf / step;
|
|
|
|
RaymarchStep( origin + rayDist * direction, step, 1-rayDist/_DepthCeiling, sum, _Scattering/pow(max(rayDist,_ScatteringMinDist),_ScatteringDistExponent), scatterSum);
|
|
|
|
rayDist += step;
|
|
}
|
|
|
|
sum.rgb = pow( sum.rgb, 1 / _Gamma );
|
|
return sum;
|
|
}
|
|
|
|
struct v2f
|
|
{
|
|
float4 pos : SV_POSITION;
|
|
float4 screenPos : TEXCOORD1;
|
|
};
|
|
|
|
v2f vert( appdata_base v )
|
|
{
|
|
v2f o;
|
|
o.pos = UnityObjectToClipPos( v.vertex );
|
|
o.screenPos = ComputeScreenPos( o.pos );
|
|
return o;
|
|
}
|
|
|
|
void computeCamera( in float2 q, out float3 rayOrigin, out float3 rd )
|
|
{
|
|
rayOrigin = _WorldSpaceCameraPos;
|
|
|
|
float2 p = 2.0*(q - 0.5);
|
|
float4 d = mul(_CamProj, float4(p, 0, 1));
|
|
d.xyz /= d.w;
|
|
//rd = (d - rayOrigin);
|
|
rd = normalize(d - rayOrigin);
|
|
rayOrigin = d;
|
|
//rayOrigin += _ProjectionParams.y * rd;
|
|
}
|
|
|
|
inline float LinearEyeDepthToOutDepth(float z)
|
|
{
|
|
return (1 - _ZBufferParams.w * z) / (_ZBufferParams.z * z);
|
|
}
|
|
|
|
float3 DepthToWorld(float2 uv, float depth) {
|
|
float z = (1-depth) * 2.0 - 1.0;
|
|
|
|
float4 clipSpacePosition = float4(uv * 2.0 - 1.0, z, 1.0);
|
|
|
|
float4 viewSpacePosition = mul(_CamInvProj,clipSpacePosition);
|
|
viewSpacePosition /= viewSpacePosition.w;
|
|
|
|
float4 worldSpacePosition = mul(unity_ObjectToWorld,viewSpacePosition);
|
|
|
|
return worldSpacePosition.xyz;
|
|
}
|
|
|
|
// MRT shader
|
|
struct FragmentOutput
|
|
{
|
|
half4 dest0 : COLOR0;
|
|
half4 dest1 : COLOR1;
|
|
};
|
|
|
|
FragmentOutput frag( v2f i ) : SV_Target //out float outDepth : SV_Depth
|
|
{
|
|
FragmentOutput o;
|
|
|
|
float2 q = i.screenPos.xy / i.screenPos.w;
|
|
|
|
// camera
|
|
float3 rayOrigin, rayDirection;
|
|
computeCamera( q, rayOrigin, rayDirection );
|
|
|
|
// z buffer / scene depth for this pixel
|
|
float4 screenPos = UNITY_PROJ_COORD( i.screenPos );
|
|
float2 screenUV = screenPos.xy / screenPos.w;
|
|
|
|
float depthSample = tex2Dproj( _CameraDepthTexture, screenPos ).r;
|
|
//float depthValue = LinearEyeDepth(depthSample);
|
|
|
|
float3 worldDepth = DepthToWorld(screenPos, depthSample);
|
|
float depthValue = length(worldDepth-rayOrigin);
|
|
|
|
// march through volume
|
|
float scatter;
|
|
float4 clouds = RayMarch( rayOrigin, rayDirection, depthValue, screenUV, scatter );
|
|
o.dest1 = .5 + scatter*.5;//smoothstep(1,.99,clouds.a)*pow(clouds.a,1)*.5;
|
|
|
|
float3 bgcol = tex2Dlod( _MainTex, float4(q, 0., 0.) );
|
|
// add in camera render colours, if not zfar (so we exclude skybox)
|
|
if(clouds.a < .99 && depthValue < _DepthCeiling)
|
|
{
|
|
// Blend out camera render when outside marching range
|
|
if( depthValue >= _DepthCeiling - _DepthBlend )
|
|
clouds.a = lerp(clouds.a, 1, (depthValue - (_DepthCeiling - _DepthBlend)) / _DepthBlend);
|
|
|
|
//clouds.xyz = lerp(clouds.xyz, bgcol, 1-clouds.a);
|
|
clouds.xyz += (1. - clouds.a) * bgcol;
|
|
// assume zbuffer represents opaque surface
|
|
|
|
}
|
|
clouds.a = 1.;
|
|
|
|
//outDepth = LinearEyeDepthToOutDepth(min(depthValue, rayDist));
|
|
|
|
o.dest0 = clouds;
|
|
return o;
|
|
}
|
|
|
|
|
|
ENDCG
|
|
|
|
Subshader
|
|
{
|
|
Pass
|
|
{
|
|
ZTest Always Cull Off ZWrite Off
|
|
|
|
CGPROGRAM
|
|
#pragma target 3.0
|
|
#pragma vertex vert
|
|
#pragma fragment frag
|
|
ENDCG
|
|
}
|
|
}
|
|
|
|
Fallback off
|
|
|
|
} // shader
|