488 lines
17 KiB
C
488 lines
17 KiB
C
|
#ifndef SLB_SHADOW_H
|
||
|
|
#define SLB_SHADOW_H
|
||
|
|
|
||
|
|
#include "slb_common.h"
|
||
|
|
#include "slb_shadow_settings.h"
|
||
|
|
|
||
|
|
#ifdef SLB_GLSL /// As always dummy
|
||
|
|
float SLB_Shadow_Load(float2 uv) {
|
||
|
|
return texelFetch(s_smap, int2(frac(uv)*float(SMAP_size)), 0).x;
|
||
|
|
}
|
||
|
|
|
||
|
|
float SLB_Shadow_LoadOffset(float2 uv, int2 offset) {
|
||
|
|
return texelFetch(s_smap, int2(frac(uv)*float(SMAP_size)) + offset, 0).x;
|
||
|
|
}
|
||
|
|
|
||
|
|
float SLB_Shadow_SampleCmp(float2 uv, float z) {
|
||
|
|
return textureLod(s_smap, uv, 0.0).x;
|
||
|
|
}
|
||
|
|
|
||
|
|
float4 SLB_Shadow_Gather(float2 uv) {
|
||
|
|
return textureGather(s_smap, uv);
|
||
|
|
}
|
||
|
|
|
||
|
|
float4 SLB_Shadow_GatherOffset(float2 uv, int2 offset) {
|
||
|
|
return textureGatherOffset(s_smap, uv, offset);
|
||
|
|
}
|
||
|
|
|
||
|
|
float4 SLB_Shadow_GatherCmp(float2 uv, float z) {
|
||
|
|
return textureGather(s_smap, uv);
|
||
|
|
}
|
||
|
|
#else
|
||
|
|
float SLB_Shadow_Load(float2 uv) {
|
||
|
|
return s_smap.Load(int3(uv*float(SMAP_size) - 0.25, 0));
|
||
|
|
}
|
||
|
|
|
||
|
|
float SLB_Shadow_LoadOffset(float2 uv, int2 offset) {
|
||
|
|
return s_smap.Load(int3(uv*float(SMAP_size) - 0.25, 0), offset);
|
||
|
|
}
|
||
|
|
|
||
|
|
float SLB_Shadow_SampleCmp(float2 uv, float z) {
|
||
|
|
return s_smap.SampleCmpLevelZero(smp_smap, uv, z).x;
|
||
|
|
}
|
||
|
|
|
||
|
|
float4 SLB_Shadow_Gather(float2 uv) {
|
||
|
|
return s_smap.Gather(smp_nofilter, uv);
|
||
|
|
}
|
||
|
|
|
||
|
|
float4 SLB_Shadow_GatherOffset(float2 uv, int2 offset) {
|
||
|
|
return s_smap.Gather(smp_nofilter, uv, offset);
|
||
|
|
}
|
||
|
|
|
||
|
|
float4 SLB_Shadow_GatherCmp(float2 uv, float z) {
|
||
|
|
return s_smap.GatherCmp(smp_smap, uv, z);
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
float SLB_Shadow_Linear(float4 tc) {
|
||
|
|
return SLB_Shadow_SampleCmp(tc.xy, tc.z);
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Taken from https://www.shadertoy.com/view/XsfGDn
|
||
|
|
float SLB_Shadow_Nice(float4 tc) {
|
||
|
|
float2 uv = tc.xy;
|
||
|
|
float2 textureResolution = float2(float(SMAP_size), float(SMAP_size));
|
||
|
|
|
||
|
|
uv = uv*textureResolution + 0.5;
|
||
|
|
|
||
|
|
float2 iuv = floor(uv);
|
||
|
|
float2 fuv = frac(uv);
|
||
|
|
|
||
|
|
uv = iuv + fuv*fuv*(3.0-2.0*fuv);
|
||
|
|
uv = (uv - 0.5)/textureResolution;
|
||
|
|
|
||
|
|
return SLB_Shadow_SampleCmp(uv, tc.z);
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Taken from http://www.java-gaming.org/index.php?topic=35123.0
|
||
|
|
float SLB_Shadow_Bicubic(float4 tc) {
|
||
|
|
float2 texCoords = tc.xy;
|
||
|
|
|
||
|
|
float2 texSize = float2(float(SMAP_size), float(SMAP_size));
|
||
|
|
float2 invTexSize = 1.0 / texSize;
|
||
|
|
|
||
|
|
texCoords = texCoords * texSize - 0.5;
|
||
|
|
|
||
|
|
float2 fxy = frac(texCoords);
|
||
|
|
texCoords -= fxy;
|
||
|
|
|
||
|
|
float4 xcubic = SLB_Cubic_For_Bicubic(fxy.x);
|
||
|
|
float4 ycubic = SLB_Cubic_For_Bicubic(fxy.y);
|
||
|
|
|
||
|
|
float4 c = texCoords.xxyy + float2(-0.5, +1.5).xyxy;
|
||
|
|
|
||
|
|
float4 s = float4(xcubic.xz + xcubic.yw, ycubic.xz + ycubic.yw);
|
||
|
|
float4 offset = c + float4(xcubic.yw, ycubic.yw) / s;
|
||
|
|
|
||
|
|
offset *= invTexSize.xxyy;
|
||
|
|
|
||
|
|
float sample0 = SLB_Shadow_SampleCmp(offset.xz, tc.z);
|
||
|
|
float sample1 = SLB_Shadow_SampleCmp(offset.yz, tc.z);
|
||
|
|
float sample2 = SLB_Shadow_SampleCmp(offset.xw, tc.z);
|
||
|
|
float sample3 = SLB_Shadow_SampleCmp(offset.yw, tc.z);
|
||
|
|
|
||
|
|
float sx = s.x / (s.x + s.y);
|
||
|
|
float sy = s.z / (s.z + s.w);
|
||
|
|
|
||
|
|
return lerp(lerp(sample3, sample2, sx), lerp(sample1, sample0, sx), sy);
|
||
|
|
}
|
||
|
|
|
||
|
|
#if 0
|
||
|
|
#include "slb_shadow_normal.h"
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#include "slb_shadow_optimized_pcf.h"
|
||
|
|
|
||
|
|
float SLB_Shadow_CHS(float4 tc, float noise) {
|
||
|
|
float light_width = slb_shadow_settings_pcss_light_width;
|
||
|
|
|
||
|
|
float average_blocker_depth = 0.0;
|
||
|
|
|
||
|
|
{
|
||
|
|
float average_blocker_div = 1e-6;
|
||
|
|
|
||
|
|
float blocker_count = 0.0;
|
||
|
|
int blocker_count_max = 0;
|
||
|
|
|
||
|
|
for(int i = -3; i <= 3; i += 2) {
|
||
|
|
for(int j = -3; j <= 3; j += 2) {
|
||
|
|
float4 gather = SLB_Shadow_GatherOffset(tc.xy, int2(i, j));
|
||
|
|
float4 weight = max(float4(0.0,0.0,0.0,0.0), tc.z - gather);
|
||
|
|
weight /= weight + 0.025;
|
||
|
|
#ifdef SLB_GLSL
|
||
|
|
weight = 1.0 - gather;
|
||
|
|
#endif
|
||
|
|
average_blocker_depth += dot(gather, weight);
|
||
|
|
average_blocker_div += dot(weight, float4(1.0, 1.0, 1.0, 1.0));
|
||
|
|
blocker_count += float(weight.x > 1e-6) + float(weight.y > 1e-6)
|
||
|
|
+ float(weight.z > 1e-6) + float(weight.w > 1e-6);
|
||
|
|
blocker_count_max += 4;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
SLB_BRANCH
|
||
|
|
if(blocker_count < 0.5 || blocker_count > float(blocker_count_max) - 0.5) {
|
||
|
|
#if 1 /// Toggles debug
|
||
|
|
return 1.0 - blocker_count/float(blocker_count_max);
|
||
|
|
#else
|
||
|
|
return 0.0; } else { return 100.0;
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
average_blocker_depth /= average_blocker_div;
|
||
|
|
}
|
||
|
|
|
||
|
|
float penumbra_size = light_width * (tc.z - average_blocker_depth)/average_blocker_depth;
|
||
|
|
|
||
|
|
float lightness = SLB_Shadow_OptimizedPCF(tc);
|
||
|
|
|
||
|
|
float scurve = clamp(3.0/float(SMAP_size)/penumbra_size, 1.0, 100.0);
|
||
|
|
lightness = saturate((lightness*scurve + 0.5) - 0.5*scurve);
|
||
|
|
|
||
|
|
return lightness;
|
||
|
|
}
|
||
|
|
|
||
|
|
float SLB_Shadow_VogelFilter(float4 tc, float noise, float filter_size, float filter_size_real, const int filter_samples, bool linear_sample, float radial_bias) {
|
||
|
|
const float compare_window = 0.0001;
|
||
|
|
|
||
|
|
float lightness = 0.0;
|
||
|
|
float div = 1e-6; /// Migitate division by zero
|
||
|
|
|
||
|
|
if(linear_sample) {
|
||
|
|
float2x2 rot_mat = SLB_Rotate2Matrix(noise*SLB_TAU);
|
||
|
|
|
||
|
|
SLB_UNROLL(filter_samples)
|
||
|
|
for(int i = 0; i < filter_samples; i++) {
|
||
|
|
float2 offset = SLB_VogelDisk_Sample(i, filter_samples);
|
||
|
|
float offset_length = length(offset);
|
||
|
|
offset = mul(offset, rot_mat);
|
||
|
|
offset *= filter_size;
|
||
|
|
|
||
|
|
float biased_z = tc.z - radial_bias*offset_length*filter_size_real;
|
||
|
|
|
||
|
|
float2 uv = tc.xy + offset;
|
||
|
|
float notblocker;
|
||
|
|
|
||
|
|
{
|
||
|
|
float4 depths = SLB_Shadow_Gather(uv);
|
||
|
|
float4 notblockers = saturate((depths - biased_z + compare_window)/compare_window);
|
||
|
|
#ifdef SLB_GLSL
|
||
|
|
notblockers = depths;
|
||
|
|
#endif
|
||
|
|
|
||
|
|
float s1 = notblockers.x;
|
||
|
|
float s2 = notblockers.y;
|
||
|
|
float s3 = notblockers.z;
|
||
|
|
float s4 = notblockers.w;
|
||
|
|
|
||
|
|
float2 fract = frac(uv*float(SMAP_size)+0.5);
|
||
|
|
notblocker = lerp(lerp(s4, s3, fract.x), lerp(s1, s2, fract.x), fract.y);
|
||
|
|
|
||
|
|
lightness += notblocker;
|
||
|
|
div += 1.0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
float2x2 rot_mat = SLB_Rotate2Matrix(noise*SLB_TAU);
|
||
|
|
|
||
|
|
SLB_UNROLL(filter_samples)
|
||
|
|
for(int i = 0; i < filter_samples; i++) {
|
||
|
|
float2 offset = SLB_VogelDisk_Sample(i, filter_samples);
|
||
|
|
float offset_length = length(offset);
|
||
|
|
offset = mul(offset, rot_mat);
|
||
|
|
offset *= filter_size;
|
||
|
|
|
||
|
|
float biased_z = tc.z - radial_bias*offset_length*filter_size_real;
|
||
|
|
|
||
|
|
float2 uv = tc.xy + offset;
|
||
|
|
|
||
|
|
float depth = SLB_Shadow_Load(uv);
|
||
|
|
float notblocker = saturate((depth - biased_z)/compare_window);
|
||
|
|
float weight = float(depth > 1e-6);
|
||
|
|
|
||
|
|
#ifdef SLB_GLSL
|
||
|
|
notblocker = depth;
|
||
|
|
weight = 1.0;
|
||
|
|
#endif
|
||
|
|
|
||
|
|
lightness += notblocker * weight;
|
||
|
|
div += weight;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
lightness /= div;
|
||
|
|
return lightness;
|
||
|
|
}
|
||
|
|
|
||
|
|
float SLB_Shadow_PCF(float4 tc, float noise) {
|
||
|
|
SLB_STATIC_CONST int filter_samples = max(1, int(slb_shadow_settings_pcss_filter_samples*slb_shadow_pcss_filter_samples_multiplier));
|
||
|
|
float pcss_size_min = slb_shadow_settings_pcss_size_min / float(SMAP_size) * slb_shadow_pcss_size_min_multiplier;
|
||
|
|
float filter_size = pcss_size_min;
|
||
|
|
|
||
|
|
#if defined(SLB_SHADOW_SPOT)
|
||
|
|
SLB_STATIC_CONST float radial_bias = 2.0;
|
||
|
|
#elif defined(SLB_SHADOW_OMNI)
|
||
|
|
SLB_STATIC_CONST float radial_bias = 1.0;
|
||
|
|
#else
|
||
|
|
SLB_STATIC_CONST float radial_bias = 0.3;
|
||
|
|
#endif
|
||
|
|
|
||
|
|
float lightness = SLB_Shadow_VogelFilter(tc, noise, filter_size, filter_size/2.0, filter_samples, true, radial_bias);
|
||
|
|
|
||
|
|
lightness = SLB_QuarticRational1D(lightness);
|
||
|
|
|
||
|
|
return lightness;
|
||
|
|
}
|
||
|
|
|
||
|
|
float SLB_Shadow_VogelCHS(float4 tc, float noise) {
|
||
|
|
SLB_STATIC_CONST int filter_samples = max(1, int(slb_shadow_settings_pcss_filter_samples*slb_shadow_pcss_filter_samples_multiplier));
|
||
|
|
SLB_STATIC_CONST float light_width = slb_shadow_settings_pcss_light_width;
|
||
|
|
float pcss_size_min = slb_shadow_settings_pcss_size_min / float(SMAP_size) * slb_shadow_pcss_size_min_multiplier;
|
||
|
|
float filter_size = pcss_size_min;
|
||
|
|
|
||
|
|
SLB_STATIC_CONST int biases = 4;
|
||
|
|
const float compare_window = 0.0001;
|
||
|
|
|
||
|
|
const float filter_bias[biases] = {0.0, 0.1, 0.2, 0.3};
|
||
|
|
|
||
|
|
float average_blocker_depth = 0.0;
|
||
|
|
float average_blocker_div = 1e-6; /// Migitate division by zero
|
||
|
|
|
||
|
|
float lightnesses[biases] = {0.0, 0.0, 0.0, 0.0};
|
||
|
|
float lightnesses_div[biases] = {1e-6, 1e-6, 1e-6, 1e-6}; /// Migitate division by zero
|
||
|
|
|
||
|
|
float2x2 rot_mat = SLB_Rotate2Matrix(noise*SLB_TAU);
|
||
|
|
|
||
|
|
SLB_UNROLL(filter_samples)
|
||
|
|
for(int i = 0; i < filter_samples; i++) {
|
||
|
|
float2 offset = SLB_VogelDisk_Sample(i, filter_samples);
|
||
|
|
float offset_length = length(offset);
|
||
|
|
offset = mul(offset, rot_mat);
|
||
|
|
offset *= filter_size;
|
||
|
|
|
||
|
|
float2 uv = tc.xy + offset;
|
||
|
|
float4 depths = SLB_Shadow_Gather(uv);
|
||
|
|
|
||
|
|
SLB_UNROLL(biases)
|
||
|
|
for(int j = 0; j < biases; j++) {
|
||
|
|
float biased_z = tc.z - filter_bias[j]*offset_length*filter_size;
|
||
|
|
{
|
||
|
|
float4 notblockers = saturate((depths - biased_z + compare_window)/compare_window);
|
||
|
|
#ifdef SLB_GLSL
|
||
|
|
notblockers = depths;
|
||
|
|
#endif
|
||
|
|
|
||
|
|
float s1 = notblockers.x;
|
||
|
|
float s2 = notblockers.y;
|
||
|
|
float s3 = notblockers.z;
|
||
|
|
float s4 = notblockers.w;
|
||
|
|
|
||
|
|
float2 fract = frac(uv*float(SMAP_size)+0.5);
|
||
|
|
float notblocker = lerp(lerp(s4, s3, fract.x), lerp(s1, s2, fract.x), fract.y);
|
||
|
|
|
||
|
|
lightnesses[j] += notblocker;
|
||
|
|
lightnesses_div[j] += 1.0;
|
||
|
|
}
|
||
|
|
{
|
||
|
|
float4 blockers = float4(float(biased_z - 0.0001*float(j-1) > depths.x),
|
||
|
|
float(biased_z - 0.0001*float(j-1) > depths.y),
|
||
|
|
float(biased_z - 0.0001*float(j-1) > depths.z),
|
||
|
|
float(biased_z - 0.0001*float(j-1) > depths.w));
|
||
|
|
|
||
|
|
average_blocker_depth += dot(depths, blockers);
|
||
|
|
average_blocker_div += dot(float4(1.0,1.0,1.0,1.0), blockers);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
SLB_UNROLL(biases)
|
||
|
|
for(int i = 0; i < biases; i++) {
|
||
|
|
lightnesses[i] /= lightnesses_div[i];
|
||
|
|
}
|
||
|
|
|
||
|
|
average_blocker_depth /= average_blocker_div;
|
||
|
|
|
||
|
|
float penumbra_size = light_width * (tc.z - average_blocker_depth)/average_blocker_depth;
|
||
|
|
|
||
|
|
/// Choose bias
|
||
|
|
float lightness = lightnesses[0];
|
||
|
|
SLB_UNROLL(biases-1)
|
||
|
|
for(int i = 1; i < biases; i++) {
|
||
|
|
if(penumbra_size > float(i)/float(biases-1)*filter_size) {
|
||
|
|
lightness = lightnesses[i];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
float scurve = clamp(filter_size/penumbra_size, 1.0, 2.0*float(filter_samples)/(filter_size*float(SMAP_size)));
|
||
|
|
lightness = saturate((lightness*scurve + 0.5) - 0.5*scurve);
|
||
|
|
|
||
|
|
return lightness;
|
||
|
|
}
|
||
|
|
|
||
|
|
float SLB_Shadow_PCSS(float4 tc, float noise) {
|
||
|
|
/// Settings
|
||
|
|
SLB_STATIC_CONST int blocker_samples = max(1, int(slb_shadow_settings_pcss_blocker_samples * slb_shadow_pcss_blocker_samples_multiplier));
|
||
|
|
SLB_STATIC_CONST int filter_samples = max(1, int(slb_shadow_settings_pcss_filter_samples * slb_shadow_pcss_filter_samples_multiplier));
|
||
|
|
SLB_STATIC_CONST int filter_small_samples = max(1, int(slb_shadow_settings_pcss_filter_small_samples * slb_shadow_pcss_filter_small_samples_multiplier));
|
||
|
|
float pcss_size = slb_shadow_settings_pcss_size / float(2048) * slb_shadow_pcss_size_multiplier;
|
||
|
|
float pcss_size_min = slb_shadow_settings_pcss_size_min / float(SMAP_size) * slb_shadow_pcss_size_min_multiplier;
|
||
|
|
float light_width = slb_shadow_settings_pcss_light_width;
|
||
|
|
|
||
|
|
float filter_size_real;
|
||
|
|
float filter_size;
|
||
|
|
|
||
|
|
#if defined(SLB_SHADOW_SPOT)
|
||
|
|
SLB_STATIC_CONST float radial_bias = 2.0;
|
||
|
|
#elif defined(SLB_SHADOW_OMNI)
|
||
|
|
SLB_STATIC_CONST float radial_bias = 1.0;
|
||
|
|
#else
|
||
|
|
SLB_STATIC_CONST float radial_bias = 0.3;
|
||
|
|
#endif
|
||
|
|
|
||
|
|
{
|
||
|
|
/// Blocker search
|
||
|
|
float blocker_size = pcss_size;
|
||
|
|
|
||
|
|
float average_blocker_depth = tc.z * 1e-6;
|
||
|
|
float average_blocker_div = 1e-6; /// Migitate division by zero
|
||
|
|
|
||
|
|
float2x2 rot_mat = SLB_Rotate2Matrix(noise*SLB_TAU);
|
||
|
|
|
||
|
|
SLB_UNROLL(blocker_samples)
|
||
|
|
for(int i = 0; i < blocker_samples; i++) {
|
||
|
|
float2 offset = SLB_VogelDisk_Sample(i, blocker_samples);
|
||
|
|
offset *= sqrt(length(offset));
|
||
|
|
float offset_length = length(offset);
|
||
|
|
offset = mul(offset, rot_mat);
|
||
|
|
offset *= blocker_size;
|
||
|
|
|
||
|
|
float depth = SLB_Shadow_Load(tc.xy + offset);
|
||
|
|
|
||
|
|
float biased_z = tc.z - radial_bias*offset_length*blocker_size;
|
||
|
|
|
||
|
|
float blocker = float(biased_z > depth && depth > 1e-6);
|
||
|
|
|
||
|
|
blocker *= 1.0/(offset_length + 1e-9);
|
||
|
|
|
||
|
|
average_blocker_depth += depth * blocker;
|
||
|
|
average_blocker_div += blocker;
|
||
|
|
}
|
||
|
|
|
||
|
|
average_blocker_depth /= average_blocker_div;
|
||
|
|
|
||
|
|
/// Calculate penumbra size
|
||
|
|
filter_size = light_width * (tc.z - average_blocker_depth)/average_blocker_depth;
|
||
|
|
|
||
|
|
#if defined(SLB_SHADOW_SPOT) || defined(SLB_SHADOW_OMNI)
|
||
|
|
filter_size *= 2 - average_blocker_depth;
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#ifdef SLB_GLSL
|
||
|
|
filter_size += 1;
|
||
|
|
#endif
|
||
|
|
|
||
|
|
filter_size = min(pcss_size, filter_size);
|
||
|
|
|
||
|
|
#ifdef SLB_GLSL
|
||
|
|
// filter_size *= frac(timers.y/10.0);
|
||
|
|
// filter_size *= cos(timers.y/5.0)*0.5 + 0.5;
|
||
|
|
// filter_size *= abs(frac(timers.y/2.0/8.0)*2.0 - 1.0)*1.0 + 0.0;
|
||
|
|
// filter_size *= noise;
|
||
|
|
// filter_size *= 0.0;
|
||
|
|
// if(sin(tc.x*100.0) > 0.5) {
|
||
|
|
// filter_size = 2.9/float(SMAP_size);
|
||
|
|
// } else {
|
||
|
|
// filter_size = 3.000/float(SMAP_size);
|
||
|
|
// }
|
||
|
|
#endif
|
||
|
|
|
||
|
|
filter_size_real = max(pcss_size_min/1000.0, filter_size);
|
||
|
|
filter_size = max(pcss_size_min, filter_size);
|
||
|
|
}
|
||
|
|
|
||
|
|
float lightness;
|
||
|
|
|
||
|
|
SLB_BRANCH
|
||
|
|
if(filter_size_real < pcss_size_min) {
|
||
|
|
if (slb_shadow_pcss_early_quit) {
|
||
|
|
float lightness = SLB_Shadow_VogelFilter(tc, noise, filter_size*1.25, filter_size_real*1.25, 8, false, radial_bias);
|
||
|
|
float scurve = clamp(filter_size/filter_size_real, 1.0, 2/(pcss_size_min*float(SMAP_size)));
|
||
|
|
lightness = saturate((lightness*scurve + 0.5) - 0.5*scurve);
|
||
|
|
|
||
|
|
SLB_BRANCH
|
||
|
|
if(abs(lightness - 0.5) > 0.45)
|
||
|
|
#if 1
|
||
|
|
{ return lightness; }
|
||
|
|
#else
|
||
|
|
{ return 0.0; } else { return 10.0; }
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
lightness = SLB_Shadow_VogelFilter(tc, noise, filter_size, filter_size_real, filter_small_samples, true, radial_bias);
|
||
|
|
} else {
|
||
|
|
lightness = SLB_Shadow_VogelFilter(tc, noise, filter_size, filter_size_real, filter_samples, false, radial_bias);
|
||
|
|
}
|
||
|
|
|
||
|
|
float scurve = clamp(filter_size/filter_size_real, 1.0, 2.0*float(filter_small_samples)/(pcss_size_min*float(SMAP_size)));
|
||
|
|
lightness = saturate((lightness*scurve + 0.5) - 0.5*scurve);
|
||
|
|
|
||
|
|
return lightness;
|
||
|
|
}
|
||
|
|
|
||
|
|
float SLB_Shadow(float4 tc, float2 pos2d) {
|
||
|
|
float noise;
|
||
|
|
if(slb_shadow_animated_noise) {
|
||
|
|
uint noise_offset = SLB_PCG(asuint(timers.y));
|
||
|
|
uint2 noise_uv = uint2(pos2d+0.5) + uint2(noise_offset, noise_offset);
|
||
|
|
noise = SLB_PhiNoise2_float(noise_uv);
|
||
|
|
} else {
|
||
|
|
noise = SLB_Morton_OwenHash4_Bluenoise_float(uint2(pos2d+0.5));
|
||
|
|
}
|
||
|
|
|
||
|
|
tc.xyz /= tc.w;
|
||
|
|
|
||
|
|
float lightness = 1.0;
|
||
|
|
|
||
|
|
if(slb_shadow_settings_method == slb_shadow_method_linear) {
|
||
|
|
lightness = SLB_Shadow_Linear(tc);
|
||
|
|
} else if (slb_shadow_settings_method == slb_shadow_method_nice) {
|
||
|
|
lightness = SLB_Shadow_Nice(tc);
|
||
|
|
} else if (slb_shadow_settings_method == slb_shadow_method_bicubic) {
|
||
|
|
lightness = SLB_Shadow_Bicubic(tc);
|
||
|
|
} else if (slb_shadow_settings_method == slb_shadow_method_optimized_pcf) {
|
||
|
|
lightness = SLB_CubicRational1D(SLB_Shadow_OptimizedPCF(tc));
|
||
|
|
} else if (slb_shadow_settings_method == slb_shadow_method_chs) {
|
||
|
|
lightness = SLB_Shadow_CHS(tc, noise);
|
||
|
|
} else if (slb_shadow_settings_method == slb_shadow_method_pcf) {
|
||
|
|
lightness = SLB_Shadow_PCF(tc, noise);
|
||
|
|
} else if (slb_shadow_settings_method == slb_shadow_method_vogel_chs) {
|
||
|
|
lightness = SLB_Shadow_VogelCHS(tc, noise);
|
||
|
|
} else if (slb_shadow_settings_method == slb_shadow_method_pcss) {
|
||
|
|
lightness = SLB_Shadow_PCSS(tc, noise);
|
||
|
|
}
|
||
|
|
|
||
|
|
return lightness;
|
||
|
|
}
|
||
|
|
|
||
|
|
#endif /// SLB_SHADOW_H
|