Add the custom renderCsm fragment shader
This commit is contained in:
RallyBlock committed
1 parent
1aa4517282
commit
3d80ba088b
1 file changed
+730
@@ -0,0 +1,730 @@
|
||||
#version 120
|
||||
#extension GL_EXT_texture_array : require
|
||||
#extension GL_EXT_texture_array : enable
|
||||
|
||||
// =============================================================================
|
||||
// renderCsm_frag.glsl — Blockland high-quality / CSM fragment shader
|
||||
// Originals: _backup_defaults/
|
||||
//
|
||||
// What this file does
|
||||
// Lighting, fog, point lights, and cascaded shadow maps for bricks.
|
||||
// Shadows: 8-tap Vogel near, 4-tap mid, 1-tap far. Particles: 1-tap.
|
||||
// brickTOP: hide the overlay and light a five-face bevel in the shader.
|
||||
// Ground_Plate is not this program (baked plate.png instead).
|
||||
// Interior lamps: wrap + longer falloff so light crawls out of doorways.
|
||||
// Outdoor shade crush (bevelAmb) only runs on stud bevels, not walls.
|
||||
//
|
||||
// How to reload
|
||||
// Options → shader quality (or whatever forces a shader recompile).
|
||||
//
|
||||
// Do not
|
||||
// Use fwidth() on the shadow compare value (draws cascade lines).
|
||||
// Snap shadow UVs to texel centers (moiré on studded plates).
|
||||
// Compress albedo*light together (washes out brickTOP studs).
|
||||
// =============================================================================
|
||||
|
||||
// --- Sun terminator (Blockland stock) ---------------------------------------
|
||||
// Softens the 0.04–0.10 NdotL band so faces don't pop from lit to shadow color.
|
||||
const float NDOTL_TRANSITION_DENOM = 0.06f; // 0.1 - 0.04
|
||||
|
||||
// --- Shadow filter averages ---------------------------------------------------
|
||||
const float INV_VOGEL_SAMPLES = 0.125f; // 1/8 taps
|
||||
const float INV_VOGEL4_SAMPLES = 0.25f; // 1/4 taps
|
||||
|
||||
// --- Diffuse wrap ------------------------------------------------------------
|
||||
// wrapLit = NdotL * SCALE + BIAS. Makes studs/cylinders a bit rounder.
|
||||
// Higher BIAS = more light wraps onto the dark side.
|
||||
const float WRAP_SCALE = 0.88f;
|
||||
const float WRAP_BIAS = 0.12f;
|
||||
|
||||
// --- Shadows / ambient -------------------------------------------------------
|
||||
// How much sky ambient still reaches a fully shadowed brick (0 = pitch black
|
||||
// shade, 1 = no shadow darkening on ambient).
|
||||
const float SHADOW_AMBIENT_FILL = 0.42f;
|
||||
|
||||
// --- Highlight shoulder (stops white tiles going solid white) ---------------
|
||||
// Below KNEE, color is unchanged. Above it, extra brightness rolls off.
|
||||
// Lower KNEE / higher COMPRESS = less blowout, dimmer lamps.
|
||||
const float HIGHLIGHT_KNEE = 0.78f;
|
||||
const float HIGHLIGHT_COMPRESS = 2.2f;
|
||||
|
||||
// --- Specular ----------------------------------------------------------------
|
||||
// SUN: tight NdotH^16 spark from the directional light.
|
||||
const float SUN_SPEC_GAIN = 1.15f;
|
||||
// POINT: lamp glint brightness. This is the main "brighter lamps" knob.
|
||||
const float POINT_SPEC_GAIN = 0.45f;
|
||||
// Physical bulb size vs Blockland's attenuation radius (which is a volume,
|
||||
// not the fixture). Higher = wider, softer lamp highlights.
|
||||
const float POINT_SPEC_BULB = 0.25f;
|
||||
// Extra spec on bevels vs flat (from |tangent.xy|).
|
||||
const float BEVEL_SPEC_BOOST = 0.25f;
|
||||
// Point-light window. 0 = cubic (tight, stock), 1 = quadratic (longer spill).
|
||||
const float POINT_FALLOFF_GAIN = 0.40f;
|
||||
const float POINT_FALLOFF_SOFT = 0.35f;
|
||||
// Sky-bevel dim in shade. Only applied on studs (see applyLighting).
|
||||
const float BEVEL_AMB_MIN = 0.58f;
|
||||
|
||||
// --- brickTOP bevel (procedural, tops only) --------------------------------
|
||||
// Matches the five-region plate map. STUD_FLAT is |p| with p = uv*2-1
|
||||
// (0.5 = inner square UV 0.25–0.75). STUD_SLOPE is bevel tilt.
|
||||
const float STUD_FLAT = 0.50f;
|
||||
const float STUD_SLOPE = 0.55f;
|
||||
|
||||
// --- Cascade blend / PCF radius ---------------------------------------------
|
||||
// Extra UV radius per cascade index. Keep low so splits don't jump softness.
|
||||
#define CASCADE_SOFTNESS_SCALE 0.25f
|
||||
// Start mixing the NEXT cascade this early (0.12 = last 88% of the split).
|
||||
// Lower = wider blend, more dual-map cost.
|
||||
#define CASCADE_BLEND_START 0.12f
|
||||
#define CASCADE_BLEND_RANGE (1.0f - CASCADE_BLEND_START)
|
||||
// Atlas-edge fade: mix next map when UV is this close to 0 or 1.
|
||||
#define CASCADE_UV_MARGIN 0.02f
|
||||
#define CASCADE_UV_FADE 0.20f
|
||||
// Vogel disk size in texels. Higher = softer 2D PCF.
|
||||
#define VOGEL_RADIUS_SCALE 2.75f
|
||||
|
||||
// --- Distance fade toward unshadowed "minimum" look --------------------------
|
||||
// Stud self-shadow aliases into rings at range. Fade CSM off between these
|
||||
// view distances (world units).
|
||||
#define SHADOW_FADE_START 16.0f
|
||||
#define SHADOW_FADE_END 88.0f
|
||||
|
||||
// =============================================================================
|
||||
// Engine varyings / uniforms (set by Blockland, do not rename)
|
||||
// =============================================================================
|
||||
|
||||
varying vec4 vPos; // view-space position (cascade pick uses vPos.y)
|
||||
varying vec3 worldNormal;
|
||||
varying vec3 worldPos;
|
||||
|
||||
uniform vec4 dirLightDir; // sun direction
|
||||
uniform vec4 dirLightColor;
|
||||
uniform vec4 dirLightAmbient;
|
||||
uniform vec4 dirShadowColor; // color in full shadow
|
||||
|
||||
uniform vec3 camPos;
|
||||
uniform mat4 obj2World;
|
||||
uniform mat4 world2Cam;
|
||||
|
||||
uniform int isParticle;
|
||||
uniform int doColorMultiply;
|
||||
uniform int glow; // emissive / light brick
|
||||
|
||||
uniform sampler2DArray stex; // shadow atlas (cascades in Z)
|
||||
uniform sampler2D tex; // brick overlay (studs, prints)
|
||||
|
||||
varying vec2 texCoord;
|
||||
|
||||
// Per-pixel surface state (filled in calculateSurface)
|
||||
vec4 viewDelta; // xyz = view dir (surface → camera), w = view distance
|
||||
float specular; // sun Blinn term (NdotH^16)
|
||||
float specFactor; // 1 + bevel boost (not overlay brightness)
|
||||
float NdotL; // clamped sun lambert on surfNormal
|
||||
float NdotLRaw; // signed, used for wrap
|
||||
float geoNdotL; // geometric face vs sun (shadows / slope bias)
|
||||
float fresnel; // Schlick, F0=0.04
|
||||
float distLod; // 0 near → 1 at SHADOW_FADE_END
|
||||
vec3 surfNormal; // worldNormal, or five-face bevel on brickTOP
|
||||
|
||||
// Cotangent frame from screen-space derivatives (no vertex tangents).
|
||||
// Degenerate UV (stretched brickTOP on a side/sliver) must not perturb —
|
||||
// inversesqrt of a tiny TBN is the salt-and-pepper sparkle on those faces.
|
||||
vec3 perturbNormal(vec3 N, vec3 wp, vec2 uv, vec3 tN)
|
||||
{
|
||||
vec3 dp1 = dFdx(wp);
|
||||
vec3 dp2 = dFdy(wp);
|
||||
vec2 duv1 = dFdx(uv);
|
||||
vec2 duv2 = dFdy(uv);
|
||||
float uvLen = abs(duv1.x) + abs(duv1.y) + abs(duv2.x) + abs(duv2.y);
|
||||
if(uvLen < 1.0e-8f)
|
||||
return N;
|
||||
vec3 dp2perp = cross(dp2, N);
|
||||
vec3 dp1perp = cross(N, dp1);
|
||||
vec3 T = dp2perp * duv1.x + dp1perp * duv2.x;
|
||||
vec3 B = dp2perp * duv1.y + dp1perp * duv2.y;
|
||||
float m = max(dot(T, T), dot(B, B));
|
||||
if(m < 1.0e-10f)
|
||||
return N;
|
||||
float invmax = inversesqrt(m);
|
||||
vec3 P = T * (tN.x * invmax) + B * (tN.y * invmax) + N * tN.z;
|
||||
float p2 = dot(P, P);
|
||||
if(p2 < 1.0e-10f)
|
||||
return N;
|
||||
return P * inversesqrt(p2);
|
||||
}
|
||||
|
||||
// Five-region plate: flat top + N/E/S/W bevels.
|
||||
vec3 plateTangent(vec2 uv)
|
||||
{
|
||||
vec2 p = fract(uv) * 2.0f - 1.0f;
|
||||
vec2 a = abs(p);
|
||||
if(a.x <= STUD_FLAT && a.y <= STUD_FLAT)
|
||||
return vec3(0.0f, 0.0f, 1.0f);
|
||||
if(a.x > a.y)
|
||||
return normalize(vec3(sign(p.x) * STUD_SLOPE, 0.0f, 1.0f));
|
||||
return normalize(vec3(0.0f, sign(p.y) * STUD_SLOPE, 1.0f));
|
||||
}
|
||||
|
||||
float plateSpecFactor(vec3 tN)
|
||||
{
|
||||
float bevel = length(tN.xy);
|
||||
return mix(0.10f, 1.0f, smoothstep(0.02f, STUD_SLOPE * 0.7f, bevel))
|
||||
+ bevel * BEVEL_SPEC_BOOST;
|
||||
}
|
||||
|
||||
bool colorNear(vec3 c, vec3 t, float e)
|
||||
{
|
||||
vec3 d = abs(c - t);
|
||||
return d.r < e && d.g < e && d.b < e;
|
||||
}
|
||||
|
||||
vec3 probeTex(vec2 uv)
|
||||
{
|
||||
return texture2D(tex, uv, -16.0f).rgb;
|
||||
}
|
||||
|
||||
// Stock brickTOP.png. Sides have a black center; prints will not match.
|
||||
bool isStockBrickTop()
|
||||
{
|
||||
vec3 c00 = probeTex(vec2(0.01f, 0.01f));
|
||||
vec3 c99 = probeTex(vec2(0.99f, 0.99f));
|
||||
vec3 c50 = probeTex(vec2(0.5f, 0.01f));
|
||||
vec3 c59 = probeTex(vec2(0.5f, 0.99f));
|
||||
vec3 c55 = probeTex(vec2(0.5f, 0.5f));
|
||||
return c00.r > 0.92f && c00.g > 0.92f && c00.b > 0.92f
|
||||
&& c99.r < 0.08f && c99.g < 0.08f && c99.b < 0.08f
|
||||
&& c50.r > 0.92f && c50.g > 0.92f && c50.b > 0.92f
|
||||
&& c59.r < 0.08f && c59.g < 0.08f && c59.b < 0.08f
|
||||
&& c55.r > 0.92f && c55.g > 0.92f && c55.b > 0.92f;
|
||||
}
|
||||
|
||||
// Five-color nmap still used as brickTOP (not the baked grayscale plate.png).
|
||||
bool isFiveRegionTopMap()
|
||||
{
|
||||
if(worldNormal.z < 0.72f)
|
||||
return false;
|
||||
vec3 s = texture2D(tex, texCoord, -16.0f).rgb;
|
||||
return colorNear(s, vec3(0.451f, 0.451f, 0.906f), 0.09f)
|
||||
|| colorNear(s, vec3(0.275f, 0.451f, 0.875f), 0.09f)
|
||||
|| colorNear(s, vec3(0.620f, 0.451f, 0.875f), 0.09f)
|
||||
|| colorNear(s, vec3(0.451f, 0.620f, 0.875f), 0.09f)
|
||||
|| colorNear(s, vec3(0.451f, 0.275f, 0.875f), 0.09f);
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// Brick color, view, sun spec, fresnel, distance fade.
|
||||
// -----------------------------------------------------------------------------
|
||||
void calculateSurface(vec4 color, inout vec4 albedo)
|
||||
{
|
||||
viewDelta.xyz = worldPos - camPos;
|
||||
viewDelta.w = length(viewDelta.xyz);
|
||||
viewDelta.xyz = -viewDelta.xyz / viewDelta.w; // toward camera
|
||||
|
||||
distLod = smoothstep(SHADOW_FADE_START, SHADOW_FADE_END, viewDelta.w);
|
||||
|
||||
vec4 texAlbedo = texture2D(tex, texCoord);
|
||||
surfNormal = worldNormal;
|
||||
|
||||
geoNdotL = max(dot(worldNormal, dirLightDir.xyz), 0.0f);
|
||||
|
||||
vec3 tN = vec3(0.0f, 0.0f, 1.0f);
|
||||
specFactor = 1.0f;
|
||||
|
||||
// Only real tops. isStockBrickTop() matches the bound texture, so a brick
|
||||
// that puts brickTOP on a side would otherwise get plateTangent + TBN
|
||||
// sparkle on that face.
|
||||
bool topStud = (worldNormal.z > 0.72f)
|
||||
&& (isStockBrickTop() || isFiveRegionTopMap());
|
||||
if(topStud)
|
||||
{
|
||||
// Hide brickTOP overlay — its baked dark rim fights the moving spec.
|
||||
albedo.rgb = color.rgb;
|
||||
tN = plateTangent(texCoord);
|
||||
specFactor = plateSpecFactor(tN);
|
||||
surfNormal = perturbNormal(worldNormal, worldPos, texCoord, tN);
|
||||
}
|
||||
else
|
||||
albedo.rgb = mix(color.rgb, texAlbedo.rgb, texAlbedo.a);
|
||||
|
||||
if(doColorMultiply == 1)
|
||||
albedo *= gl_Color;
|
||||
|
||||
albedo.a = color.a;
|
||||
|
||||
NdotLRaw = dot(surfNormal, dirLightDir.xyz);
|
||||
NdotL = max(NdotLRaw, 0.0f);
|
||||
|
||||
// Schlick fresnel: more on glancing edges.
|
||||
float NdotV = max(dot(surfNormal, viewDelta.xyz), 0.0f);
|
||||
float f = 1.0f - NdotV;
|
||||
float f2 = f * f;
|
||||
fresnel = 0.04f + 0.96f * f2 * f2 * f;
|
||||
|
||||
// Sun spec only if the sun actually hits this (perturbed) face.
|
||||
if(NdotL > 0.04f)
|
||||
{
|
||||
vec3 halfVec = normalize(dirLightDir.xyz + viewDelta.xyz);
|
||||
float NdotH = max(dot(surfNormal, halfVec), 0.0f);
|
||||
float d2 = NdotH * NdotH;
|
||||
float d4 = d2 * d2;
|
||||
float d8 = d4 * d4;
|
||||
specular = d8 * d8 * SUN_SPEC_GAIN * specFactor; // NdotH^16
|
||||
}
|
||||
else
|
||||
specular = 0.0f;
|
||||
}
|
||||
|
||||
// Fog (per-vertex fogCoords from the vertex shader).
|
||||
uniform vec4 fogBaseColor;
|
||||
uniform vec4 fogConsts;
|
||||
uniform sampler2D fogTex;
|
||||
varying vec2 fogCoords;
|
||||
|
||||
void applyFog(inout vec4 albedo)
|
||||
{
|
||||
vec4 fogColor = texture2D(fogTex, fogCoords) * fogBaseColor;
|
||||
// Sine remap of fog alpha (stock Blockland).
|
||||
float fogFactor = 0.5f + 0.5f * sin(fogColor.a * 3.141592654f - 1.570796327f);
|
||||
albedo = mix(albedo, fogColor, fogFactor);
|
||||
}
|
||||
|
||||
// Soft-clip values above HIGHLIGHT_KNEE so stacked lamps don't go solid white.
|
||||
vec3 compressHighlights(vec3 c)
|
||||
{
|
||||
vec3 over = max(c - vec3(HIGHLIGHT_KNEE), vec3(0.0f));
|
||||
return min(c, vec3(HIGHLIGHT_KNEE)) + over / (vec3(1.0f) + over * HIGHLIGHT_COMPRESS);
|
||||
}
|
||||
|
||||
// =============================================================================
|
||||
// Cascaded shadow maps
|
||||
// far_d = view-depth of each split (x,y,z)
|
||||
// texSize = atlas size (x) and 1/size (y)
|
||||
// zScale = per-cascade depth scale for bias
|
||||
// =============================================================================
|
||||
uniform vec4 far_d;
|
||||
uniform vec2 texSize;
|
||||
uniform vec4 zScale;
|
||||
uniform int shadowSplitCount;
|
||||
|
||||
// 0 at start of split, 1 at the far plane of this cascade.
|
||||
float cascadeDepthBlend(float viewY, float split)
|
||||
{
|
||||
float t = clamp((viewY - split * CASCADE_BLEND_START) / (split * CASCADE_BLEND_RANGE), 0.0f, 1.0f);
|
||||
return smoothstep(0.0f, 1.0f, t);
|
||||
}
|
||||
|
||||
// 1 when UV is at the atlas border (cascade frustum edge), 0 in the middle.
|
||||
float cascadeUvBlend(vec2 uv)
|
||||
{
|
||||
float edgeDist = min(min(uv.x, 1.0f - uv.x), min(uv.y, 1.0f - uv.y));
|
||||
return 1.0f - smoothstep(CASCADE_UV_MARGIN, CASCADE_UV_FADE, edgeDist);
|
||||
}
|
||||
|
||||
// Project this pixel into cascade A (and B if blending).
|
||||
// offset = view-space jitter for the ultra 3D grid; (0,0,0) for a normal sample.
|
||||
// .xy = atlas UV, .z = cascade layer, .w = depth compare value.
|
||||
void calculateShadowCoords(vec3 offset, inout vec4 shadow_coordA, inout vec4 shadow_coordB, out float blend, bool allowBlend)
|
||||
{
|
||||
vec4 rPos = vPos + vec4(offset, 0.0f);
|
||||
int index = 3; // farthest cascade unless a nearer split matches
|
||||
|
||||
// Depth bias: more on grazing receivers, less on cascade 0 (contact at feet).
|
||||
float slope = clamp(1.0f - geoNdotL, 0.0f, 1.0f);
|
||||
float fudgeKey = 0.008f + 0.012f * slope * slope;
|
||||
if(rPos.y < far_d.x)
|
||||
fudgeKey *= 0.75f;
|
||||
|
||||
float fudgeFactorA = 4.0f * fudgeKey / zScale.w;
|
||||
float fudgeFactorB = 4.0f * fudgeKey / zScale.w;
|
||||
float depthBlend = 0.0f;
|
||||
|
||||
if(rPos.y < far_d.x)
|
||||
{
|
||||
index = 0;
|
||||
if(allowBlend && shadowSplitCount > 1)
|
||||
depthBlend = cascadeDepthBlend(rPos.y, far_d.x);
|
||||
fudgeFactorA = fudgeKey / zScale.x;
|
||||
fudgeFactorB = 2.0f * fudgeKey / zScale.y;
|
||||
}
|
||||
else if(rPos.y < far_d.y)
|
||||
{
|
||||
index = 1;
|
||||
if(allowBlend && shadowSplitCount > 2)
|
||||
depthBlend = cascadeDepthBlend(rPos.y, far_d.y);
|
||||
fudgeFactorA = 2.0f * fudgeKey / zScale.y;
|
||||
fudgeFactorB = 3.0f * fudgeKey / zScale.z;
|
||||
}
|
||||
else if(rPos.y < far_d.z)
|
||||
{
|
||||
index = 2;
|
||||
if(allowBlend && shadowSplitCount > 3)
|
||||
depthBlend = cascadeDepthBlend(rPos.y, far_d.z);
|
||||
fudgeFactorA = 3.0f * fudgeKey / zScale.z;
|
||||
fudgeFactorB = 4.0f * fudgeKey / zScale.w;
|
||||
}
|
||||
|
||||
shadow_coordA = gl_TextureMatrix[index]*rPos;
|
||||
shadow_coordA.w = shadow_coordA.z - fudgeFactorA;
|
||||
shadow_coordA.z = float(index);
|
||||
|
||||
blend = depthBlend;
|
||||
if(allowBlend && index < 3 && (index + 1) < shadowSplitCount)
|
||||
{
|
||||
shadow_coordB = gl_TextureMatrix[index + 1]*rPos;
|
||||
shadow_coordB.w = shadow_coordB.z - fudgeFactorB;
|
||||
shadow_coordB.z = float(index + 1);
|
||||
blend = max(depthBlend, cascadeUvBlend(shadow_coordA.xy));
|
||||
}
|
||||
}
|
||||
|
||||
// 1 = lit (receiver closer than stored depth), 0 = shadowed.
|
||||
float sampleShadowTap(vec2 uv, float layer, float compare)
|
||||
{
|
||||
return step(0.0f, texture2DArray(stex, vec3(uv, layer)).x - compare - 1.0e-6f);
|
||||
}
|
||||
|
||||
// 8-tap disk PCF (near cascades).
|
||||
float vogelSample(vec4 shadow_coord, float radius)
|
||||
{
|
||||
float compare = shadow_coord.w;
|
||||
float layer = shadow_coord.z;
|
||||
vec2 uv = shadow_coord.xy;
|
||||
|
||||
float hits = 0.0f;
|
||||
hits += sampleShadowTap(uv + vec2( 0.250000f, 0.000000f) * radius, layer, compare);
|
||||
hits += sampleShadowTap(uv + vec2(-0.319292f, 0.292492f) * radius, layer, compare);
|
||||
hits += sampleShadowTap(uv + vec2( 0.048890f, -0.556882f) * radius, layer, compare);
|
||||
hits += sampleShadowTap(uv + vec2( 0.401722f, 0.525731f) * radius, layer, compare);
|
||||
hits += sampleShadowTap(uv + vec2(-0.707107f, 0.000000f) * radius, layer, compare);
|
||||
hits += sampleShadowTap(uv + vec2( 0.157013f, 0.693780f) * radius, layer, compare);
|
||||
hits += sampleShadowTap(uv + vec2( 0.453990f, -0.632281f) * radius, layer, compare);
|
||||
hits += sampleShadowTap(uv + vec2(-0.340561f, -0.748511f) * radius, layer, compare);
|
||||
return hits * INV_VOGEL_SAMPLES;
|
||||
}
|
||||
|
||||
float vogelSample4(vec4 shadow_coord, float radius)
|
||||
{
|
||||
float compare = shadow_coord.w;
|
||||
float layer = shadow_coord.z;
|
||||
vec2 uv = shadow_coord.xy;
|
||||
|
||||
float hits = 0.0f;
|
||||
hits += sampleShadowTap(uv + vec2( 0.250000f, 0.000000f) * radius, layer, compare);
|
||||
hits += sampleShadowTap(uv + vec2(-0.707107f, 0.000000f) * radius, layer, compare);
|
||||
hits += sampleShadowTap(uv + vec2( 0.048890f, -0.556882f) * radius, layer, compare);
|
||||
hits += sampleShadowTap(uv + vec2( 0.401722f, 0.525731f) * radius, layer, compare);
|
||||
return hits * INV_VOGEL4_SAMPLES;
|
||||
}
|
||||
|
||||
float basicShadow(vec4 shadow_coord)
|
||||
{
|
||||
return sampleShadowTap(shadow_coord.xy, shadow_coord.z, shadow_coord.w);
|
||||
}
|
||||
|
||||
// 8-tap near, 4-tap mid, 1-tap far.
|
||||
float filterCascade(vec4 shadow_coord, float radius, int idx)
|
||||
{
|
||||
if(idx <= 1)
|
||||
return vogelSample(shadow_coord, radius);
|
||||
if(idx == 2)
|
||||
return vogelSample4(shadow_coord, radius);
|
||||
return basicShadow(shadow_coord);
|
||||
}
|
||||
|
||||
// =============================================================================
|
||||
// Point lights (engine binds up to 8; unused have radius 0)
|
||||
// =============================================================================
|
||||
uniform vec4 pointLightPos0;
|
||||
uniform vec4 pointLightColor0;
|
||||
uniform float pointLightRadius0;
|
||||
|
||||
uniform vec4 pointLightPos1;
|
||||
uniform vec4 pointLightColor1;
|
||||
uniform float pointLightRadius1;
|
||||
|
||||
uniform vec4 pointLightPos2;
|
||||
uniform vec4 pointLightColor2;
|
||||
uniform float pointLightRadius2;
|
||||
|
||||
uniform vec4 pointLightPos3;
|
||||
uniform vec4 pointLightColor3;
|
||||
uniform float pointLightRadius3;
|
||||
|
||||
uniform vec4 pointLightPos4;
|
||||
uniform vec4 pointLightColor4;
|
||||
uniform float pointLightRadius4;
|
||||
|
||||
uniform vec4 pointLightPos5;
|
||||
uniform vec4 pointLightColor5;
|
||||
uniform float pointLightRadius5;
|
||||
|
||||
uniform vec4 pointLightPos6;
|
||||
uniform vec4 pointLightColor6;
|
||||
uniform float pointLightRadius6;
|
||||
|
||||
uniform vec4 pointLightPos7;
|
||||
uniform vec4 pointLightColor7;
|
||||
uniform float pointLightRadius7;
|
||||
|
||||
// 1 at the bulb, 0 at radius. Mix cubic→quadratic so interiors spill farther
|
||||
// without a big brightness jump at the fixture.
|
||||
float pointLightWindow(float lightDist, float radius)
|
||||
{
|
||||
float ratio = max(0.0f, 1.0f - lightDist / radius);
|
||||
float r2 = ratio * ratio;
|
||||
return r2 * mix(ratio, 1.0f, POINT_FALLOFF_SOFT) * POINT_FALLOFF_GAIN;
|
||||
}
|
||||
|
||||
// Lamp specular: tight Blinn on surfNormal. Low exponent used to
|
||||
// flood whole facets; keep it high so only a small glint reads as plastic.
|
||||
float pointBlinnSpec(vec3 lightDir, float lightDist, float radius, float lightDot)
|
||||
{
|
||||
float bulb = max(radius * POINT_SPEC_BULB, 0.08f);
|
||||
float lift = clamp(bulb / max(lightDist, bulb * 0.2f), 0.0f, 0.22f);
|
||||
vec3 L = normalize(lightDir + surfNormal * lift);
|
||||
vec3 halfVec = normalize(L + viewDelta.xyz);
|
||||
float nh = max(dot(surfNormal, halfVec), 0.0f);
|
||||
float angularSize = clamp(bulb / max(lightDist, bulb * 0.2f), 0.0f, 1.0f);
|
||||
float width = smoothstep(0.12f, 0.9f, angularSize);
|
||||
float specExp = mix(36.0f, 14.0f, width);
|
||||
float energy = mix(0.55f, 0.22f, width);
|
||||
float facing = smoothstep(0.12f, 0.42f, lightDot);
|
||||
return pow(nh, specExp) * energy * POINT_SPEC_GAIN * specFactor
|
||||
* (0.80f + 0.20f * fresnel) * facing;
|
||||
}
|
||||
|
||||
void addPointLight(vec3 pos, vec3 color, float radius, inout vec3 diffuse, inout vec3 spec)
|
||||
{
|
||||
vec3 lightDelta = worldPos.xyz - pos;
|
||||
float distSq = dot(lightDelta, lightDelta);
|
||||
float radiusSq = radius * radius;
|
||||
if(distSq >= radiusSq)
|
||||
return;
|
||||
|
||||
float invDist = inversesqrt(distSq);
|
||||
float lightDist = invDist * distSq;
|
||||
vec3 L = -lightDelta * invDist;
|
||||
float nDotL = max(dot(L, surfNormal), 0.0f);
|
||||
float wrapDot = max(dot(L, surfNormal) * WRAP_SCALE + WRAP_BIAS, 0.0f);
|
||||
float ratio = pointLightWindow(lightDist, radius);
|
||||
diffuse += ratio * wrapDot * color;
|
||||
spec += ratio * pointBlinnSpec(L, lightDist, radius, nDotL) * color;
|
||||
}
|
||||
|
||||
vec4 accumulatePointLights(out vec3 pointSpec)
|
||||
{
|
||||
vec3 diffuse = vec3(0.0f);
|
||||
pointSpec = vec3(0.0f);
|
||||
|
||||
addPointLight(pointLightPos0.xyz, pointLightColor0.xyz, pointLightRadius0, diffuse, pointSpec);
|
||||
addPointLight(pointLightPos1.xyz, pointLightColor1.xyz, pointLightRadius1, diffuse, pointSpec);
|
||||
addPointLight(pointLightPos2.xyz, pointLightColor2.xyz, pointLightRadius2, diffuse, pointSpec);
|
||||
addPointLight(pointLightPos3.xyz, pointLightColor3.xyz, pointLightRadius3, diffuse, pointSpec);
|
||||
addPointLight(pointLightPos4.xyz, pointLightColor4.xyz, pointLightRadius4, diffuse, pointSpec);
|
||||
addPointLight(pointLightPos5.xyz, pointLightColor5.xyz, pointLightRadius5, diffuse, pointSpec);
|
||||
addPointLight(pointLightPos6.xyz, pointLightColor6.xyz, pointLightRadius6, diffuse, pointSpec);
|
||||
addPointLight(pointLightPos7.xyz, pointLightColor7.xyz, pointLightRadius7, diffuse, pointSpec);
|
||||
|
||||
return vec4(diffuse, 0.0f);
|
||||
}
|
||||
|
||||
// Particles: lights 0–1 only, no NdotL, no spec (stock).
|
||||
vec4 accumulateParticlePointLights()
|
||||
{
|
||||
vec4 pointLightTotal = vec4(0.0f, 0.0f, 0.0f, 0.0f);
|
||||
vec3 lightDelta = vec3(0.0f, 0.0f, 0.0f);
|
||||
float distSq = 0.0f;
|
||||
float lightDist = 0.0f;
|
||||
|
||||
lightDelta = worldPos.xyz - pointLightPos0.xyz;
|
||||
distSq = dot(lightDelta, lightDelta);
|
||||
float radiusSq0 = pointLightRadius0 * pointLightRadius0;
|
||||
if(distSq < radiusSq0)
|
||||
{
|
||||
float invDist = inversesqrt(distSq);
|
||||
lightDist = invDist * distSq;
|
||||
pointLightTotal.xyz += pointLightWindow(lightDist, pointLightRadius0) * pointLightColor0.xyz;
|
||||
}
|
||||
|
||||
lightDelta = worldPos.xyz - pointLightPos1.xyz;
|
||||
distSq = dot(lightDelta, lightDelta);
|
||||
float radiusSq1 = pointLightRadius1 * pointLightRadius1;
|
||||
if(distSq < radiusSq1)
|
||||
{
|
||||
float invDist = inversesqrt(distSq);
|
||||
lightDist = invDist * distSq;
|
||||
pointLightTotal.xyz += pointLightWindow(lightDist, pointLightRadius1) * pointLightColor1.xyz;
|
||||
}
|
||||
|
||||
return pointLightTotal;
|
||||
}
|
||||
|
||||
// Combine sun, ambient, shadow color, lamps, spec, rim. Compress light, then
|
||||
// multiply albedo (preserves stud contrast).
|
||||
void applyLighting(inout vec4 combinedColor, vec4 albedo, float occlusionFactor)
|
||||
{
|
||||
// Dielectric: most of the glint takes the brick color so brown stays brown.
|
||||
vec3 specularTint = mix(vec3(1.0f), albedo.rgb, 0.72f);
|
||||
vec3 dirLightSpecular = occlusionFactor * specular * 0.5f * dirLightColor.rgb * specularTint;
|
||||
|
||||
// More ambient on faces pointing up (world Z). Fades to even at distance.
|
||||
float skyFactor = mix(surfNormal.z * 0.5f + 0.5f, 0.5f, distLod);
|
||||
vec4 skyAmbient = dirLightAmbient * (0.72f + skyFactor * 0.55f);
|
||||
|
||||
float wrapLit = max(NdotLRaw * WRAP_SCALE + WRAP_BIAS, 0.0f);
|
||||
float ambOcc = mix(SHADOW_AMBIENT_FILL, 1.0f, occlusionFactor);
|
||||
vec4 dirLightDirect = ((wrapLit * dirLightColor) * occlusionFactor) + (skyAmbient * ambOcc) + (dirShadowColor * (1.0f - occlusionFactor));
|
||||
|
||||
vec3 coolShadow = dirShadowColor.rgb * vec3(0.92f, 0.96f, 1.08f);
|
||||
vec3 shadedFill = coolShadow + skyAmbient.rgb * SHADOW_AMBIENT_FILL;
|
||||
|
||||
// Sky-facing bevel in shade: form lighting on studs only. Walls used to
|
||||
// get this too, which crushed indoor corridors to flat black.
|
||||
float studMask = clamp(length(surfNormal - worldNormal) * 5.0f, 0.0f, 1.0f);
|
||||
vec3 skyDir = vec3(0.14f, 0.28f, 0.95f);
|
||||
skyDir = skyDir * inversesqrt(dot(skyDir, skyDir));
|
||||
float skyN = max(dot(surfNormal, skyDir), 0.0f);
|
||||
float bevelAmb = mix(1.0f, mix(BEVEL_AMB_MIN, 1.0f, skyN), studMask);
|
||||
shadedFill *= bevelAmb;
|
||||
dirLightDirect.rgb *= mix(bevelAmb, 1.0f, occlusionFactor);
|
||||
|
||||
// Terminator on the geometric face, not the stud N — otherwise each
|
||||
// pyramid facet dumps to shade as a solid polygon.
|
||||
if(geoNdotL <= 0.04f)
|
||||
{
|
||||
dirLightDirect = vec4(shadedFill, dirShadowColor.a);
|
||||
dirLightSpecular = vec3(0.0f);
|
||||
}
|
||||
else if(geoNdotL <= 0.1f)
|
||||
{
|
||||
float val = (geoNdotL - 0.04f) / NDOTL_TRANSITION_DENOM;
|
||||
dirLightDirect.rgb = (dirLightDirect.rgb * val) + (shadedFill * (1.0f - val));
|
||||
dirLightSpecular *= val;
|
||||
}
|
||||
|
||||
vec3 pointSpec = vec3(0.0f);
|
||||
dirLightDirect.rgb += accumulatePointLights(pointSpec).rgb;
|
||||
vec3 specTotal = dirLightSpecular + pointSpec * specularTint;
|
||||
|
||||
vec3 halfSky = normalize(skyDir + viewDelta.xyz);
|
||||
float ambSpec = pow(max(dot(surfNormal, halfSky), 0.0f), 22.0f)
|
||||
* specFactor * 0.22f * studMask;
|
||||
specTotal += ambSpec * specularTint * (dirLightAmbient.rgb + vec3(0.12f));
|
||||
|
||||
vec3 rimLight = fresnel * dirLightAmbient.rgb * 0.15f * (1.0f - distLod);
|
||||
|
||||
float specIntensity = length(specTotal);
|
||||
float kD = max(1.0f - specIntensity * 0.2f, 0.8f); // leave some diffuse where spec is strong
|
||||
float fakeAO = mix(0.90f + surfNormal.z * 0.10f, 1.0f, distLod);
|
||||
|
||||
dirLightDirect.a *= min(occlusionFactor + 0.75f, 1.0f);
|
||||
|
||||
vec3 light = compressHighlights(dirLightDirect.rgb * kD * fakeAO);
|
||||
combinedColor.rgb = light * albedo.rgb + rimLight + specTotal;
|
||||
combinedColor.a = albedo.a;
|
||||
}
|
||||
|
||||
// Returns 0 (shadowed) … 1 (lit). cheap = particles (1-tap + cascade blend).
|
||||
float shadowCoef(bool cheap)
|
||||
{
|
||||
float blend = 0.0f;
|
||||
vec4 shadow_coordA = vec4(0.0f, 0.0f, 0.0f, 0.0f);
|
||||
vec4 shadow_coordB = vec4(0.0f, 0.0f, 0.0f, 0.0f);
|
||||
|
||||
calculateShadowCoords(vec3(0.0f), shadow_coordA, shadow_coordB, blend, true);
|
||||
|
||||
float baseRadius = max(texSize.y, 0.5f / 1024.0f) * VOGEL_RADIUS_SCALE;
|
||||
float texel = max(texSize.y, 0.5f / 1024.0f);
|
||||
float slope = max(0.0f, 1.0f - geoNdotL);
|
||||
float slopeBias = texel * 0.15f * slope;
|
||||
shadow_coordA.w -= slopeBias;
|
||||
|
||||
int idx = int(shadow_coordA.z);
|
||||
float radiusNear = baseRadius * (1.0f + float(idx) * CASCADE_SOFTNESS_SCALE);
|
||||
float radiusFar = baseRadius * (1.0f + float(idx + 1) * CASCADE_SOFTNESS_SCALE);
|
||||
float radiusA = mix(radiusNear, radiusFar, blend);
|
||||
|
||||
if(cheap)
|
||||
{
|
||||
float shadowA = basicShadow(shadow_coordA);
|
||||
if(blend > 0.0f)
|
||||
{
|
||||
shadow_coordB.w -= slopeBias;
|
||||
return mix(shadowA, basicShadow(shadow_coordB), blend);
|
||||
}
|
||||
return shadowA;
|
||||
}
|
||||
|
||||
// 8 / 4 / 1 tap by cascade. Blend mixes the next map at splits.
|
||||
float shadowA = filterCascade(shadow_coordA, radiusA, idx);
|
||||
|
||||
if(blend > 0.0f)
|
||||
{
|
||||
shadow_coordB.w -= slopeBias;
|
||||
float shadowB = filterCascade(shadow_coordB, radiusFar, idx + 1);
|
||||
return mix(shadowA, shadowB, blend);
|
||||
}
|
||||
return shadowA;
|
||||
}
|
||||
|
||||
void main()
|
||||
{
|
||||
// Glow / emitter: skip lighting and shadows.
|
||||
if(glow == 1 || (worldNormal.x + worldNormal.y + worldNormal.z) > 2.0f)
|
||||
{
|
||||
vec4 texAlbedo = texture2D(tex, texCoord);
|
||||
vec4 albedo;
|
||||
albedo.rgb = mix(gl_Color.rgb, texAlbedo.rgb, texAlbedo.a);
|
||||
albedo.a = gl_Color.a;
|
||||
if(doColorMultiply == 1)
|
||||
albedo *= gl_Color;
|
||||
gl_FragColor = vec4(albedo.rgb * 1.5f, albedo.a);
|
||||
return;
|
||||
}
|
||||
|
||||
if(isParticle == 1)
|
||||
{
|
||||
NdotL = max(dot(worldNormal, dirLightDir.xyz), 0.0f);
|
||||
geoNdotL = NdotL;
|
||||
float occlusionFactor = 0.0f;
|
||||
if(NdotL > -0.01f)
|
||||
{
|
||||
if(shadowSplitCount <= 0)
|
||||
occlusionFactor = 1.0f;
|
||||
else
|
||||
occlusionFactor = shadowCoef(true);
|
||||
}
|
||||
|
||||
vec4 texAlbedo = texture2D(tex, texCoord);
|
||||
vec4 dirLightDirect = (dirLightColor * occlusionFactor) + (dirLightAmbient * occlusionFactor) + (dirShadowColor * (1.0f - occlusionFactor));
|
||||
vec4 plt = accumulateParticlePointLights();
|
||||
|
||||
vec4 lightTotal = dirLightDirect + plt;
|
||||
lightTotal.rgb = compressHighlights(lightTotal.rgb);
|
||||
vec4 fragColor = texAlbedo * gl_Color * lightTotal;
|
||||
applyFog(fragColor);
|
||||
fragColor.a = texAlbedo.a * gl_Color.a;
|
||||
gl_FragColor = fragColor;
|
||||
return;
|
||||
}
|
||||
|
||||
vec4 albedo = vec4(0.0f, 0.0f, 0.0f, 0.0f);
|
||||
calculateSurface(gl_Color, albedo);
|
||||
|
||||
float occlusionFactor = 0.0f;
|
||||
if(geoNdotL > -0.01f)
|
||||
{
|
||||
if(shadowSplitCount <= 0 || distLod >= 1.0f)
|
||||
occlusionFactor = 1.0f;
|
||||
else
|
||||
occlusionFactor = shadowCoef(false);
|
||||
}
|
||||
|
||||
occlusionFactor = mix(occlusionFactor, 1.0f, distLod);
|
||||
|
||||
vec4 fragColor = vec4(0.0f, 0.0f, 0.0f, 0.0f);
|
||||
applyLighting(fragColor, albedo, occlusionFactor);
|
||||
applyFog(fragColor);
|
||||
|
||||
gl_FragColor = fragColor;
|
||||
}
|
||||
Reference in new issue
Block a user