HeavenStudioPlus/Assets/X-PostProcessing/Shaders/XPostProcessing.hlsl

467 lines
12 KiB
HLSL
Raw Normal View History


#include "Sampling.hlsl"
//Always present in every shader
TEXTURE2D_SAMPLER2D(_MainTex, sampler_MainTex); //Present in every shader
TEXTURE2D_SAMPLER2D(_CameraDepthNormalsTexture, sampler_CameraDepthNormalsTexture);
float4 _MainTex_TexelSize;
#define fixed half
#define fixed2 half2
#define fixed3 half3
#define fixed4 half4
#define fixed4x4 half4x4
#define fixed3x3 half3x3
#define fixed2x2 half2x2
#define sampler2D_half sampler2D
#define sampler2D_float sampler2D
#define samplerCUBE_half samplerCUBE
#define samplerCUBE_float samplerCUBE
//------------------------------------------------------------------------------------------------------
// Blend Functions
//------------------------------------------------------------------------------------------------------
half4 BlendOperation_Burn(half4 Base, half4 Blend, half Opacity)
{
half4 Out = 1.0 - (1.0 - Blend) / Base;
Out = lerp(Base, Out, Opacity);
return Out;
}
half4 BlendOperation_Darken(half4 Base, half4 Blend, half Opacity)
{
half4 Out = min(Blend, Base);
Out = lerp(Base, Out, Opacity);
return Out;
}
half4 BlendOperation_Difference(half4 Base, half4 Blend, half Opacity)
{
half4 Out = abs(Blend - Base);
Out = lerp(Base, Out, Opacity);
return Out;
}
half4 BlendOperation_Dodge(half4 Base, half4 Blend, half Opacity)
{
half4 Out = Base / (1.0 - Blend);
Out = lerp(Base, Out, Opacity);
return Out;
}
half4 BlendOperation_Divide(half4 Base, half4 Blend, half Opacity)
{
half4 Out = Base / (Blend + 0.000000000001);
Out = lerp(Base, Out, Opacity);
return Out;
}
half4 BlendOperation_Exclusion(half4 Base, half4 Blend, half Opacity)
{
half4 Out = Blend + Base - (2.0 * Blend * Base);
Out = lerp(Base, Out, Opacity);
return Out;
}
half4 BlendOperation_HardLight(half4 Base, half4 Blend, half Opacity)
{
float4 result1 = 1.0 - 2.0 * (1.0 - Base) * (1.0 - Blend);
float4 result2 = 2.0 * Base * Blend;
float4 zeroOrOne = step(Blend, 0.5);
half4 Out = result2 * zeroOrOne + (1 - zeroOrOne) * result1;
Out = lerp(Base, Out, Opacity);
return Out;
}
half4 BlendOperation_HardMix(half4 Base, half4 Blend, half Opacity)
{
half4 Out = step(1 - Base, Blend);
Out = lerp(Base, Out, Opacity);
return Out;
}
half4 BlendOperation_Lighten(half4 Base, half4 Blend, half Opacity)
{
half4 Out = max(Blend, Base);
Out = lerp(Base, Out, Opacity);
return Out;
}
half4 BlendOperation_LinearBurn(half4 Base, half4 Blend, half Opacity)
{
half4 Out = Base + Blend - 1.0;
Out = lerp(Base, Out, Opacity);
return Out;
}
half4 BlendOperation_LinearDodge(half4 Base, half4 Blend, half Opacity)
{
half4 Out = Base + Blend;
Out = lerp(Base, Out, Opacity);
return Out;
}
half4 BlendOperation_LinearLight(half4 Base, half4 Blend, half Opacity)
{
half4 Out = Blend < 0.5 ? max(Base + (2 * Blend) - 1, 0): min(Base + 2 * (Blend - 0.5), 1);
Out = lerp(Base, Out, Opacity);
return Out;
}
half4 BlendOperation_LinearLightAddSub(half4 Base, half4 Blend, half Opacity)
{
half4 Out = Blend + 2.0 * Base - 1.0;
Out = lerp(Base, Out, Opacity);
return Out;
}
half4 BlendOperation_Multiply(half4 Base, half4 Blend, half Opacity)
{
half4 Out = Base * Blend;
Out = lerp(Base, Out, Opacity);
return Out;
}
half4 BlendOperation_Negation(half4 Base, half4 Blend, half Opacity)
{
half4 Out = 1.0 - abs(1.0 - Blend - Base);
Out = lerp(Base, Out, Opacity);
return Out;
}
half4 BlendOperation_Overlay(half4 Base, half4 Blend, half Opacity)
{
half4 result1 = 1.0 - 2.0 * (1.0 - Base) * (1.0 - Blend);
half4 result2 = 2.0 * Base * Blend;
half4 zeroOrOne = step(Base, 0.5);
half4 Out = result2 * zeroOrOne + (1 - zeroOrOne) * result1;
Out = lerp(Base, Out, Opacity);
return Out;
}
half4 BlendOperation_PinLight(half4 Base, half4 Blend, half Opacity)
{
half4 check = step(0.5, Blend);
half4 result1 = check * max(2.0 * (Base - 0.5), Blend);
half4 Out = result1 + (1.0 - check) * min(2.0 * Base, Blend);
Out = lerp(Base, Out, Opacity);
return Out;
}
half4 BlendOperation_Screen(half4 Base, half4 Blend, half Opacity)
{
half4 Out = 1.0 - (1.0 - Blend) * (1.0 - Base);
Out = lerp(Base, Out, Opacity);
return Out;
}
half4 BlendOperation_SoftLight(half4 Base, half4 Blend, half Opacity)
{
half4 result1 = 2.0 * Base * Blend + Base * Base * (1.0 - 2.0 * Blend);
half4 result2 = sqrt(Base) * (2.0 * Blend - 1.0) + 2.0 * Base * (1.0 - Blend);
half4 zeroOrOne = step(0.5, Blend);
half4 Out = result2 * zeroOrOne + (1 - zeroOrOne) * result1;
Out = lerp(Base, Out, Opacity);
return Out;
}
half4 BlendOperation_Subtract(half4 Base, half4 Blend, half Opacity)
{
half4 Out = Base - Blend;
Out = lerp(Base, Out, Opacity);
return Out;
}
half4 BlendOperation_VividLight(half4 Base, half4 Blend, half Opacity)
{
half4 result1 = 1.0 - (1.0 - Blend) / (2.0 * Base);
half4 result2 = Blend / (2.0 * (1.0 - Base));
half4 zeroOrOne = step(0.5, Base);
half4 Out = result2 * zeroOrOne + (1 - zeroOrOne) * result1;
Out = lerp(Base, Out, Opacity);
return Out;
}
half4 BlendOperation_Overwrite(half4 Base, half4 Blend, half Opacity)
{
half4 Out = lerp(Base, Blend, Opacity);
return Out;
}
//------------------------------------------------------------------------------------------------------
// Generic functions
//------------------------------------------------------------------------------------------------------
float rand(float n)
{
return frac(sin(n) * 13758.5453123 * 0.01);
}
float rand(float2 n)
{
return frac(sin(dot(n, float2(12.9898, 78.233))) * 43758.5453);
}
float2 RotateUV(float2 uv, float rotation)
{
float cosine = cos(rotation);
float sine = sin(rotation);
float2 pivot = float2(0.5, 0.5);
float2 rotator = (mul(uv - pivot, float2x2(cosine, -sine, sine, cosine)) + pivot);
return saturate(rotator);
}
float3 ChromaticAberration(TEXTURE2D_ARGS(tex, samplerTex), float4 texelSize, float2 uv, float amount)
{
float2 direction = normalize((float2(0.5, 0.5) - uv));
float3 distortion = float3(-texelSize.x * amount, 0, texelSize.x * amount);
float red = SAMPLE_TEXTURE2D(tex, samplerTex, uv + direction * distortion.r).r;
float green = SAMPLE_TEXTURE2D(tex, samplerTex, uv + direction * distortion.g).g;
float blue = SAMPLE_TEXTURE2D(tex, samplerTex, uv + direction * distortion.b).b;
return float3(red, green, blue);
}
/*
float3 PositionFromDepth(float depth, float2 uv, float4 inverseViewMatrix) {
float4 clip = float4((uv.xy * 2.0f - 1.0f) * float2(1, -1), 0.0f, 1.0f);
float3 worldDirection = mul(inverseViewMatrix, clip) - _WorldSpaceCameraPos;
float3 worldspace = worldDirection * depth + _WorldSpaceCameraPos;
return float3(frac((worldspace.rgb)) + float3(0, 0, 0.1));
}
*/
// (returns 1.0 when orthographic)
float CheckPerspective(float x)
{
return lerp(x, 1.0, unity_OrthoParams.w);
}
// Reconstruct view-space position from UV and depth.
float3 ReconstructViewPos(float2 uv, float depth)
{
float3 worldPos = float3(0, 0, 0);
worldPos.xy = (uv.xy * 2.0 - 1.0 - float2(unity_CameraProjection._13, unity_CameraProjection._23)) / float2(unity_CameraProjection._11, unity_CameraProjection._22) * CheckPerspective(depth);
worldPos.z = depth;
return worldPos;
}
float2 FisheyeUV(half2 uv, half amount, half zoom)
{
half2 center = uv.xy - half2(0.5, 0.5);
half CdotC = dot(center, center);
half f = 1.0 + CdotC * (amount * sqrt(CdotC));
return f * zoom * center + 0.5;
}
float2 Distort(float2 uv)
{
#if DISTORT
{
uv = (uv - 0.5) * _Distortion_Amount.z + 0.5;
float2 ruv = _Distortion_CenterScale.zw * (uv - 0.5 - _Distortion_CenterScale.xy);
float ru = length(float2(ruv));
UNITY_BRANCH
if (_Distortion_Amount.w > 0.0)
{
float wu = ru * _Distortion_Amount.x;
ru = tan(wu) * (1.0 / (ru * _Distortion_Amount.y));
uv = uv + ruv * (ru - 1.0);
}
else
{
ru = (1.0 / ru) * _Distortion_Amount.x * atan(ru * _Distortion_Amount.y);
uv = uv + ruv * (ru - 1.0);
}
}
#endif
return uv;
}
//----------------------------------------------------------------
// Common vertex functions
//--------------------------------------------------------------
float4 _BlurOffsets;
struct v2fGaussian
{
float4 pos: POSITION;
float2 uv: TEXCOORD0;
float4 uv01: TEXCOORD1;
float4 uv23: TEXCOORD2;
float4 uv45: TEXCOORD3;
};
v2fGaussian VertGaussian(AttributesDefault v)
{
v2fGaussian o;
o.pos = float4(v.vertex.xy, 0, 1);
o.uv.xy = TransformTriangleVertexToUV(o.pos.xy);
#if UNITY_UV_STARTS_AT_TOP
o.uv = o.uv * float2(1.0, -1.0) + float2(0.0, 1.0);
#endif
//UNITY_SINGLE_PASS_STEREO
o.uv = TransformStereoScreenSpaceTex(o.uv, 1.0);
o.uv01 = o.uv.xyxy + _BlurOffsets.xyxy * float4(1, 1, -1, -1);
o.uv23 = o.uv.xyxy + _BlurOffsets.xyxy * float4(1, 1, -1, -1) * 2.0;
o.uv45 = o.uv.xyxy + _BlurOffsets.xyxy * float4(1, 1, -1, -1) * 6.0;
return o;
}
float4 FragBlurBox(VaryingsDefault i): SV_Target
{
return DownsampleBox4Tap(TEXTURE2D_PARAM(_MainTex, sampler_MainTex), i.texcoord, _BlurOffsets.xy).rgba;
}
float4 FragBlurGaussian(v2fGaussian i): SV_Target
{
half4 color = float4(0, 0, 0, 0);
color += 0.40 * SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, i.uv);
color += 0.15 * SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, i.uv01.xy);
color += 0.15 * SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, i.uv01.zw);
color += 0.10 * SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, i.uv23.xy);
color += 0.10 * SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, i.uv23.zw);
color += 0.05 * SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, i.uv45.xy);
color += 0.05 * SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, i.uv45.zw);
return color;
}
half simpleNoise(half x, half y, half seed, half phase)
{
half n = x * y * phase * seed;
return fmod(n, 13) * fmod(n, 123);
}
half3 Lut2D(TEXTURE2D_ARGS(tex, samplerTex), float3 uvw, float2 texelSize, half tileAmount)
{
uvw.z *= tileAmount;
float shift = floor(uvw.z);
uvw.xy = uvw.xy * tileAmount * texelSize.xy + texelSize.xy * 0.5;
uvw.x += shift * texelSize.y;
uvw.xyz = lerp(
SAMPLE_TEXTURE2D(tex, samplerTex, uvw.xy).rgb,
SAMPLE_TEXTURE2D(tex, samplerTex, uvw.xy + float2(texelSize.y, 0.0)).rgb,
uvw.z - shift
);
return uvw;
}
half3 Lut2D_InvertY(TEXTURE2D_ARGS(tex, samplerTex), float3 uvw, float2 texelSize, half tileAmount)
{
// Strip format where `height = sqrt(width)`
uvw.z *= tileAmount;
float shift = floor(uvw.z);
uvw.xy = uvw.xy * tileAmount * texelSize.xy + texelSize.xy * 0.5;
uvw.x += shift * texelSize.y;
//uvw.y = 1 - uvw.y;
uvw.xyz = lerp(
SAMPLE_TEXTURE2D(tex, samplerTex, uvw.xy).rgb,
SAMPLE_TEXTURE2D(tex, samplerTex, uvw.xy + float2(texelSize.y, 0.0)).rgb,
uvw.z - shift
);
return uvw;
}
//-------------------------------------------------------------------------------------------
// Lift, Gamma (pre-inverted), Gain tuned for HDR use - best used with the ACES tonemapper as
// negative values will creep in the result
// Expected workspace: ACEScg (linear)
//-------------------------------------------------------------------------------------------
half3 LiftGammaGain_HDR(half3 c, half3 lift, float3 invgamma, half3 gain)
{
c = c * gain + lift;
// ACEScg will output negative values, as clamping to 0 will lose precious information we'll
// mirror the gamma function instead
return FastSign(c) * pow(abs(c), invgamma);
}
half3 Luminance_V1(half3 color)
{
return(color.r * 0.3 + color.g * 0.59 + color.b * 0.11);
}
half Luminance_V2(half3 color)
{
return dot(color, half3(0.222, 0.707, 0.071));
}
half4 LuminanceThreshold(half4 color, half threshold)
{
half br = Max3(color.r, color.g, color.b);
half contrib = max(0, br - threshold);
contrib /= max(br, 0.001);
return color * contrib;
}
float4 GetDepthNormal_ViewSpace(float2 uv)
{
float4 cdn = SAMPLE_TEXTURE2D(_CameraDepthNormalsTexture, sampler_CameraDepthNormalsTexture, uv);
float4 Normal_ViewSpace = float4(DecodeViewNormalStereo(cdn), 1);
return Normal_ViewSpace;
}
float GetSinusoidWave(float len, float pi, float time)
{
float wave = sin(8.0f * pi * len + time);
wave = 0.5 * wave + 0.2;
wave *= wave * wave;
return wave;
}