mirror of
https://github.com/Kelsidavis/WoWee.git
synced 2026-03-22 23:30:14 +00:00
c4d0a21713
- SHADOW_MAP_SIZE 2048→1024: 4x fewer pixels rasterized in depth pass - Replace 9-tap manual PCF loop with single hardware PCF tap in all 4 receiver shaders (terrain.frag, wmo_renderer, m2_renderer, character_renderer). GL_LINEAR + GL_COMPARE_REF_TO_TEXTURE already gives 2×2 bilinear PCF per tap for free, so quality is maintained while doing 9x fewer texture fetches. - Throttle shadow depth pass to every 2 frames; OpenGL depth texture persists between frames so receivers always have a valid shadow map. 1-frame lag at 60 fps is invisible.
138 lines
4.1 KiB
GLSL
138 lines
4.1 KiB
GLSL
#version 330 core
|
||
|
||
in vec3 FragPos;
|
||
in vec3 Normal;
|
||
in vec2 TexCoord;
|
||
in vec2 LayerUV;
|
||
|
||
out vec4 FragColor;
|
||
|
||
// Texture layers (up to 4)
|
||
uniform sampler2D uBaseTexture;
|
||
uniform sampler2D uLayer1Texture;
|
||
uniform sampler2D uLayer2Texture;
|
||
uniform sampler2D uLayer3Texture;
|
||
|
||
// Alpha maps for blending
|
||
uniform sampler2D uLayer1Alpha;
|
||
uniform sampler2D uLayer2Alpha;
|
||
uniform sampler2D uLayer3Alpha;
|
||
|
||
// Layer control
|
||
uniform int uLayerCount;
|
||
uniform bool uHasLayer1;
|
||
uniform bool uHasLayer2;
|
||
uniform bool uHasLayer3;
|
||
|
||
// Lighting
|
||
uniform vec3 uLightDir;
|
||
uniform vec3 uLightColor;
|
||
uniform vec3 uAmbientColor;
|
||
|
||
// Camera
|
||
uniform vec3 uViewPos;
|
||
|
||
// Fog
|
||
uniform vec3 uFogColor;
|
||
uniform float uFogStart;
|
||
uniform float uFogEnd;
|
||
|
||
// Shadow mapping
|
||
uniform sampler2DShadow uShadowMap;
|
||
uniform mat4 uLightSpaceMatrix;
|
||
uniform bool uShadowEnabled;
|
||
uniform float uShadowStrength;
|
||
|
||
float calcShadow() {
|
||
vec4 lsPos = uLightSpaceMatrix * vec4(FragPos, 1.0);
|
||
vec3 proj = lsPos.xyz / lsPos.w * 0.5 + 0.5;
|
||
if (proj.z > 1.0) return 1.0;
|
||
float edgeDist = max(abs(proj.x - 0.5), abs(proj.y - 0.5));
|
||
float coverageFade = 1.0 - smoothstep(0.40, 0.49, edgeDist);
|
||
vec3 norm = normalize(Normal);
|
||
vec3 lightDir = normalize(-uLightDir);
|
||
float bias = max(0.005 * (1.0 - dot(norm, lightDir)), 0.001);
|
||
// Single hardware PCF tap — GL_LINEAR + compare mode gives 2×2 bilinear PCF for free
|
||
float shadow = texture(uShadowMap, vec3(proj.xy, proj.z - bias));
|
||
return mix(1.0, shadow, coverageFade);
|
||
}
|
||
|
||
float sampleAlpha(sampler2D tex, vec2 uv) {
|
||
// Slight blur near alpha-map borders to hide seams between chunks.
|
||
vec2 edge = min(uv, 1.0 - uv);
|
||
float border = min(edge.x, edge.y);
|
||
float doBlur = step(border, 2.0 / 64.0); // within ~2 texels of edge
|
||
if (doBlur < 0.5) {
|
||
return texture(tex, uv).r;
|
||
}
|
||
vec2 texel = vec2(1.0 / 64.0);
|
||
float a = 0.0;
|
||
a += texture(tex, uv + vec2(-texel.x, 0.0)).r;
|
||
a += texture(tex, uv + vec2(texel.x, 0.0)).r;
|
||
a += texture(tex, uv + vec2(0.0, -texel.y)).r;
|
||
a += texture(tex, uv + vec2(0.0, texel.y)).r;
|
||
return a * 0.25;
|
||
}
|
||
|
||
void main() {
|
||
// Sample base texture
|
||
vec4 baseColor = texture(uBaseTexture, TexCoord);
|
||
vec4 finalColor = baseColor;
|
||
|
||
// Apply texture layers with alpha blending
|
||
// TexCoord = tiling UVs for texture sampling (repeats across chunk)
|
||
// LayerUV = 0-1 per-chunk UVs for alpha map sampling
|
||
float a1 = uHasLayer1 ? sampleAlpha(uLayer1Alpha, LayerUV) : 0.0;
|
||
float a2 = uHasLayer2 ? sampleAlpha(uLayer2Alpha, LayerUV) : 0.0;
|
||
float a3 = uHasLayer3 ? sampleAlpha(uLayer3Alpha, LayerUV) : 0.0;
|
||
|
||
// Normalize weights to reduce quilting seams at chunk borders.
|
||
float w0 = 1.0;
|
||
float w1 = a1;
|
||
float w2 = a2;
|
||
float w3 = a3;
|
||
float sum = w0 + w1 + w2 + w3;
|
||
if (sum > 0.0) {
|
||
w0 /= sum; w1 /= sum; w2 /= sum; w3 /= sum;
|
||
}
|
||
|
||
finalColor = baseColor * w0;
|
||
if (uHasLayer1) {
|
||
vec4 layer1Color = texture(uLayer1Texture, TexCoord);
|
||
finalColor += layer1Color * w1;
|
||
}
|
||
if (uHasLayer2) {
|
||
vec4 layer2Color = texture(uLayer2Texture, TexCoord);
|
||
finalColor += layer2Color * w2;
|
||
}
|
||
if (uHasLayer3) {
|
||
vec4 layer3Color = texture(uLayer3Texture, TexCoord);
|
||
finalColor += layer3Color * w3;
|
||
}
|
||
|
||
// Normalize normal
|
||
vec3 norm = normalize(Normal);
|
||
vec3 lightDir = normalize(-uLightDir);
|
||
|
||
// Ambient lighting
|
||
vec3 ambient = uAmbientColor * finalColor.rgb;
|
||
|
||
// Diffuse lighting (two-sided for terrain hills)
|
||
float diff = abs(dot(norm, lightDir));
|
||
diff = max(diff, 0.2); // Minimum light to prevent completely dark faces
|
||
vec3 diffuse = diff * uLightColor * finalColor.rgb;
|
||
|
||
// Shadow
|
||
float shadow = uShadowEnabled ? calcShadow() : 1.0;
|
||
shadow = mix(1.0, shadow, clamp(uShadowStrength, 0.0, 1.0));
|
||
|
||
// Combine lighting (terrain is purely diffuse — no specular on ground)
|
||
vec3 result = ambient + shadow * diffuse;
|
||
|
||
// Apply fog
|
||
float distance = length(uViewPos - FragPos);
|
||
float fogFactor = clamp((uFogEnd - distance) / (uFogEnd - uFogStart), 0.0, 1.0);
|
||
result = mix(uFogColor, result, fogFactor);
|
||
|
||
FragColor = vec4(result, 1.0);
|
||
}
|