249 lines
7.7 KiB
HLSL
249 lines
7.7 KiB
HLSL
|
|
//-------------------------------------------------------------------------------------
|
|
inline half3 WaterEdge ( half3 i_rgb, half3 i_worldPos, half i_dist2Cam, const half c_mult )
|
|
{
|
|
half fade = clamp ( i_dist2Cam / ( _EdgeWaterDist * c_mult), 0.0, 1.0 );
|
|
|
|
fade = lerp ( 1.0, fade, _EdgeWaterColor.a );
|
|
|
|
return ( lerp ( _EdgeWaterColor.rgb, i_rgb, fade * fade * fade ) );
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------
|
|
inline half TrowbridgeReitzNDF ( in half i_dotNH )
|
|
{
|
|
half roughnessX2 = 1.0 - _Smoothness;
|
|
|
|
roughnessX2 = roughnessX2 * roughnessX2;
|
|
|
|
half dist = i_dotNH * i_dotNH * ( roughnessX2 - 1.0 ) + 1.0;
|
|
return roughnessX2 / ( 3.14159 * dist * dist );
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------
|
|
inline half GGXNDF ( in half i_dotNH, in half i_roughness, in half i_roughnessX2 )
|
|
{
|
|
half dotNHX2 = i_dotNH * i_dotNH;
|
|
|
|
half tanDotNHX2 = ( 1 - dotNHX2 ) / dotNHX2;
|
|
|
|
half st = i_roughness / ( dotNHX2 * ( i_roughnessX2 + tanDotNHX2 ) );
|
|
|
|
return ( 1.0 / 3.14159 ) * ( st * st );
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------
|
|
inline half SpecularStandard ( in half i_dotNH, in half i_dotLH, in half i_roughness, in half i_roughnessX2 )
|
|
{
|
|
half specTerm;
|
|
|
|
half d = i_dotNH * i_dotNH * ( i_roughnessX2 - 1.0h) + 1.00001h;
|
|
|
|
specTerm = i_roughnessX2 / ( ( d * d ) * max ( 0.1h, i_dotLH * i_dotLH ) * ( i_roughness * 4.0h + 2.0h ) );
|
|
|
|
return ( specTerm );
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------
|
|
inline half3 FresnelReflection ( in PWSurface i_surf)
|
|
{
|
|
half f = i_surf.dotNV * i_surf.dotNV * i_surf.dotNV * i_surf.dotNV;// * 0.7;
|
|
|
|
half3 grazing = saturate ( ( 1.0 - i_surf.roughness ) + i_surf.reflectivity );// * i_color;
|
|
|
|
return ( lerp ( i_surf.specularColor, grazing, f ) );
|
|
}
|
|
|
|
inline half3 FesnelShlick(float cosTheta, half3 F0)
|
|
{
|
|
return F0 + (1.0 - F0) * pow(1.0 - cosTheta, 5.0);
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------------------
|
|
inline void SurfacePBR( inout PWSurface i_surf, in half i_foamAmount, in half i_metallic, in half3 i_worldNormal, in half3 i_viewDir, in half4 i_screenPos, in half2 i_distortion )
|
|
{
|
|
i_surf.roughnessX2 = i_surf.roughness * i_surf.roughness;
|
|
i_surf.metallic = i_metallic * ( 1.0 - i_foamAmount );
|
|
|
|
half3 F0 = lerp(DielectricSpec.rgb,i_surf.depthColor,i_surf.metallic);
|
|
|
|
i_surf.specularColor = _PW_MainLightColor.rgb * F0;
|
|
|
|
i_surf.reflectInverse = DielectricSpec.a - i_surf.metallic * DielectricSpec.a;
|
|
|
|
i_surf.reflectivity = 1.0h - i_surf.reflectInverse;
|
|
|
|
i_surf.dotNV = dot ( i_viewDir, i_worldNormal );
|
|
half flatwaterNV = dot ( i_viewDir, float3(0,1,0));
|
|
half smoothedNV = lerp(i_surf.dotNV,flatwaterNV,saturate(flatwaterNV * 5));
|
|
|
|
|
|
half4 ruv = i_screenPos;
|
|
ruv.xy += i_distortion;
|
|
|
|
half3 reflectionSample = tex2Dproj (_ReflectionTex, UNITY_PROJ_COORD(ruv * 5)).rgb;
|
|
reflectionSample = lerp(reflectionSample,_AmbientColor, i_surf.roughnessX2);
|
|
|
|
i_surf.reflection = reflectionSample * FesnelShlick(smoothedNV,F0);
|
|
i_surf.reflection *= 1.0 / ( i_surf.roughnessX2 + 1.0 );
|
|
|
|
|
|
//i_surf.debug = FresnelReflection ( i_surf);
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------
|
|
inline void PBRDirLighting ( inout PWSurface i_surf, in half3 i_worldPosition, in half3 i_worldNormal, in half3 i_viewDir )
|
|
{
|
|
half3 direction = normalize(_PW_MainLightDir.xyz);
|
|
|
|
half dotNL = saturate ( dot ( i_worldNormal, direction ) );
|
|
half3 halfDir = normalize ( direction + i_viewDir );
|
|
half dotNH = max ( dot ( halfDir,i_worldNormal ), HALF_MIN );
|
|
half spec = GGXNDF ( dotNH, i_surf.roughness, i_surf.roughnessX2 );
|
|
|
|
// spec = min ( 3, spec * 0.111 );
|
|
// half spec = SpecularStandard ( dotNH, dotLH, i_surf.roughness, i_surf.roughnessX2 );
|
|
|
|
//half amt = 0.9 + 1;
|
|
//half wrap = ( dotNL + 0.9 ) / ( amt * amt );
|
|
|
|
half wrap = saturate( dotNL);
|
|
i_surf.reflection += ( spec * i_surf.specularColor ) * dotNL;
|
|
i_surf.finalRGBA.rgb *= ( _PW_MainLightColor.rgb * _PW_MainLightIntensity * wrap ) + _AmbientColor.rgb;
|
|
i_surf.finalRGBA.rgb *= i_surf.reflectInverse;
|
|
|
|
}
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------
|
|
inline float EchoWave ( in float3 i_position, in float2 i_direction, in float i_waveLength, in float i_speed, in half i_size, in float i_scale )
|
|
{
|
|
float dir = ( dot ( i_position.xz, i_direction ) );
|
|
|
|
float3 vert = i_position;
|
|
|
|
float speed = i_speed * -_Time.x;
|
|
|
|
float offset = sin ( i_waveLength * dir + speed ) * i_size * i_scale;
|
|
|
|
return ( offset );
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------
|
|
float3 GerstnerWave2 ( float4 wave, float3 p, inout float3 tangent, inout float3 binormal )
|
|
{
|
|
float steepness = wave.z;
|
|
float wavelength = wave.w;
|
|
float k = 2 * UNITY_PI / wavelength;
|
|
float c = sqrt(9.8 / k);
|
|
float2 d = normalize(wave.xy);
|
|
float f = k * (dot(d, p.xz) - c * (_Time.y ));
|
|
float a = steepness / k;
|
|
|
|
//p.x += d.x * (a * cos(f));
|
|
//p.y = a * sin(f);
|
|
//p.z += d.y * (a * cos(f));
|
|
|
|
tangent += float3(
|
|
-d.x * d.x * (steepness * sin(f)),
|
|
d.x * (steepness * cos(f)),
|
|
-d.x * d.y * (steepness * sin(f))
|
|
);
|
|
|
|
binormal += float3(
|
|
-d.x * d.y * (steepness * sin(f)),
|
|
d.y * (steepness * cos(f)),
|
|
-d.y * d.y * (steepness * sin(f))
|
|
);
|
|
|
|
return float3(
|
|
d.x * (a * cos(f)),
|
|
a * sin(f),
|
|
d.y * (a * cos(f))
|
|
);
|
|
}
|
|
|
|
#define GRAVITY 9.81
|
|
|
|
//-------------------------------------------------------------------------------------
|
|
float3 GerstnerWave ( in float i_id, float2 i_dir, in float i_waveLength, in float i_steepness, in float i_scale, in float i_speed, in float3 i_point, inout float3 tangent, inout float3 binormal )
|
|
{
|
|
float waveLength = i_waveLength;
|
|
float steepness = pow ( i_steepness, i_id ) * i_scale;
|
|
|
|
float k = 6.2831853 / waveLength;
|
|
float c = sqrt ( GRAVITY / k );
|
|
float2 dir = normalize ( i_dir );
|
|
float f = k * ( dot ( dir, i_point.xz ) - c * ( _Time.y * i_speed ) );
|
|
float a = steepness / k;
|
|
|
|
// gotta scale tanget and binormal
|
|
tangent += float3 ( -dir.x * dir.x * (steepness * sin(f)),
|
|
dir.x * (steepness * cos(f)),
|
|
-dir.x * dir.y * (steepness * sin(f))
|
|
);
|
|
|
|
binormal += float3 ( -dir.x * dir.y * (steepness * sin(f)),
|
|
dir.y * (steepness * cos(f)),
|
|
-dir.y * dir.y * (steepness * sin(f))
|
|
);
|
|
|
|
float3 newPos = float3( dir.x * (a * cos(f)), a * sin(f), dir.y * (a * cos(f) ) );
|
|
|
|
return ( newPos );
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------
|
|
inline half2 CalcLayerUVRotation ( in float2 iuv, in float i_angle )
|
|
{
|
|
float2x2 rotationMatrix;
|
|
float sinX;
|
|
float cosX;
|
|
|
|
sincos ( i_angle, sinX, cosX );
|
|
rotationMatrix = float2x2 ( cosX, -sinX, sinX, cosX );
|
|
|
|
iuv -= float2 ( 0.5, 0.5 );
|
|
|
|
iuv = mul ( iuv, rotationMatrix );
|
|
|
|
iuv += float2 ( 0.5, 0.5 );
|
|
|
|
return ( iuv );
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------
|
|
half3 BlendUnpacked(half3 n1, half3 n2)
|
|
{
|
|
n1 += half3( 0, 0, 1);
|
|
n2 *= half3(-1, -1, 1);
|
|
return n1*dot(n1, n2)/n1.z - n2;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------
|
|
inline half4 FlowMap ( in sampler2D i_normalTex, in half2 i_uv, in half2 i_flowXY, in half i_speed )
|
|
{
|
|
// half4 flowDir = tex2D ( i_flowMap, i_layer.uv ).rgba;
|
|
|
|
i_flowXY = ( i_flowXY * 2.0 - 1.0 ) * half2 ( i_speed, i_speed );
|
|
|
|
half flowPhase0 = frac ( _Time.y * 0.5f + 0.5f );
|
|
half flowPhase1 = frac ( _Time.y * 0.5f + 1.0f );
|
|
|
|
half flowLerp = abs ( ( 0.5f - flowPhase0 ) / 0.5f );
|
|
|
|
half flowUV0 = i_uv + i_flowXY * flowPhase0;
|
|
half flowUV1 = i_uv + i_flowXY * flowPhase1;
|
|
|
|
half4 tex0 = tex2D ( i_normalTex, flowUV0 );
|
|
half4 tex1 = tex2D ( i_normalTex, flowUV1 );
|
|
|
|
return ( lerp ( tex0, tex1, flowLerp ) );
|
|
}
|
|
|
|
|
|
|