ruby_rpg 0.0.4 → 0.1.0

data/lib/engine/shaders/lighting/spot_light.glsl

@@ -0,0 +1,80 @@
+// Spot light structure and calculation functions
+
+#include "lighting_common.glsl"
+
+struct SpotLight {
+    vec3 position;
+    vec3 direction;
+    float sqrRange;
+    vec3 colour;
+    float innerCutoff;
+    float outerCutoff;
+    mat4 lightSpaceMatrix;
+    bool castsShadows;
+    float shadowNear;
+    float shadowFar;
+};
+#define NR_SPOT_LIGHTS 8
+#define NR_SHADOW_CASTING_SPOT_LIGHTS 4
+uniform SpotLight spotLights[NR_SPOT_LIGHTS];
+uniform sampler2DArray spotShadowMaps;
+
+// Convert non-linear depth buffer value to linear depth
+float LinearizeDepth(float depth, float near, float far)
+{
+    float z = depth * 2.0 - 1.0; // back to NDC
+    return (2.0 * near * far) / (far + near - z * (far - near));
+}
+
+float CalcSpotShadow(SpotLight light, int lightIndex, vec3 fragPos)
+{
+    if (!light.castsShadows || lightIndex >= NR_SHADOW_CASTING_SPOT_LIGHTS) {
+        return 0.0;
+    }
+
+    vec4 fragPosLightSpace = light.lightSpaceMatrix * vec4(fragPos, 1.0);
+
+    // Point is behind the light
+    if (fragPosLightSpace.w <= 0.0) {
+        return 0.0;
+    }
+
+    vec3 projCoords = fragPosLightSpace.xyz / fragPosLightSpace.w;
+    projCoords = projCoords * 0.5 + 0.5;
+
+    // Fragment is outside the shadow map frustum
+    if (projCoords.z > 1.0 || projCoords.z < 0.0 ||
+        projCoords.x < 0.0 || projCoords.x > 1.0 ||
+        projCoords.y < 0.0 || projCoords.y > 1.0) {
+        return 0.0;
+    }
+
+    float closestDepth = texture(spotShadowMaps, vec3(projCoords.xy, float(lightIndex))).r;
+    float currentDepth = projCoords.z;
+
+    // Convert to linear depth for more stable comparison
+    float near = light.shadowNear;
+    float far = light.shadowFar;
+    float linearClosest = LinearizeDepth(closestDepth, near, far);
+    float linearCurrent = LinearizeDepth(currentDepth, near, far);
+
+    float bias = 0.5; // bias in world units
+    return linearCurrent - bias > linearClosest ? 1.0 : 0.0;
+}
+
+vec3 CalcSpotLight(SpotLight light, int lightIndex, vec3 normal, vec3 fragPos, vec3 viewDir, float diffuseStrength, float specularStrength, float specularPower)
+{
+    vec3 lightOffset = light.position - fragPos;
+    float sqrDistance = dot(lightOffset, lightOffset);
+    vec3 lightDir = normalize(lightOffset);
+
+    float theta = dot(lightDir, -light.direction);
+    float epsilon = light.innerCutoff - light.outerCutoff;
+    float intensity = clamp((theta - light.outerCutoff) / epsilon, 0.0, 1.0);
+
+    float shadow = CalcSpotShadow(light, lightIndex, fragPos);
+    float attenuation = light.sqrRange / sqrDistance;
+
+    vec2 phong = CalcPhong(normal, lightDir, viewDir, diffuseStrength, specularStrength, specularPower);
+    return light.colour * (phong.x + phong.y) * attenuation * intensity * (1.0 - shadow);
+}

data/lib/engine/shaders/mesh_frag.glsl

@@ -1,102 +1,53 @@
-#version 330 core
+#version 400 core
+
+layout(location = 0) out vec4 FragColour;
+layout(location = 1) out vec4 normalRoughness;
 
 in vec2 TexCoord;
 in vec3 Normal;
 in vec3 Tangent;
 in vec3 FragPos;
 
-out vec4 color;
-
-uniform sampler2D image;
-uniform sampler2D normalMap;
+uniform sampler2D image; // @fallback white
+uniform sampler2D normalMap; // @fallback normal
 uniform vec3 cameraPos;
-uniform float diffuseStrength;
-uniform float specularStrength;
-uniform float specularPower;
-uniform vec3 ambientLight;
-
-struct DirectionalLight {
-    vec3 direction;
-    vec3 colour;
-};
-#define NR_DIRECTIONAL_LIGHTS 4
-uniform DirectionalLight directionalLights[NR_DIRECTIONAL_LIGHTS];
-
-struct PointLight {
-    vec3 position;
-    float sqrRange;
-    vec3 colour;
-};
-#define NR_POINT_LIGHTS 16
-uniform PointLight pointLights[NR_POINT_LIGHTS];
-
-vec3 CalcPointLight(PointLight light, vec3 normal, vec3 fragPos, vec3 viewDir)
-{
-    vec3 lightOffset = light.position - fragPos;
-    float sqrDistance = dot(lightOffset, lightOffset);
-    vec3 lightDir = normalize(lightOffset);
-    float diff = max(dot(normal, lightDir), 0.0);
-
-    vec3 reflectDir = reflect(lightDir, normal);
-    float spec = pow(max(dot(-viewDir, reflectDir), 0.0), specularPower);
-
-    float attenuation = light.sqrRange / sqrDistance;
-
-    float diffuse = diff * diffuseStrength;
-    float specular = spec * specularStrength;
-
-    return light.colour * (diffuse + specular) * attenuation;
-}
 
-vec3 CalcDirectionalLight(DirectionalLight light, vec3 normal, vec3 fragPos, vec3 viewDir)
-{
-    float diff = max(dot(normal, -light.direction), 0.0);
-
-    vec3 reflectDir = reflect(-light.direction, normal);
-    float spec = pow(max(dot(-viewDir, reflectDir), 0.0), specularPower);
-
-    float diffuse = diff * diffuseStrength;
-    float specular = spec * specularStrength;
+// Material properties with sensible defaults
+uniform vec3 baseColour = vec3(1.0, 1.0, 1.0);
+uniform float diffuseStrength = 0.5;
+uniform float specularStrength = 0.7;
+uniform float specularPower = 32.0;
+uniform float roughness = 0.5;
 
-    return light.colour * (diffuse + specular);
-}
+#include "lighting/lighting.glsl"
 
 void main()
 {
+    // Sample texture and apply base colour tint
+    // (nil textures → white 1x1, baseColour defaults to white in Material)
+    vec4 texSample = texture(image, TexCoord);
+    vec3 colour = texSample.rgb * baseColour;
+
+    // Calculate world-space normal (with normal mapping if available)
     vec3 sampledNormal = texture(normalMap, TexCoord).rgb * 2.0 - 1.0;
-    if ( sampledNormal.r + sampledNormal.g + sampledNormal.b <= 0)
-    {
-        sampledNormal = vec3(0.0, 0.0, 1.0);
-    }
     vec3 n = normalize(Normal);
     vec3 t = normalize(Tangent);
     vec3 norm = n;
-    if ( length(t) > 0.0 )
-    {
+
+    // Apply normal map if valid tangent exists
+    if (length(t) > 0.0 && (sampledNormal.r + sampledNormal.g + sampledNormal.b) > 0.0) {
         vec3 b = cross(t, n);
         mat3 TBN = mat3(t, b, n);
         norm = normalize(TBN * normalize(sampledNormal));
     }
+
+    // Calculate lighting
     vec3 viewDir = normalize(cameraPos - FragPos);
 
-    vec3 result = ambientLight;
+    vec3 result = CalcAllLights(norm, FragPos, viewDir, diffuseStrength, specularStrength, specularPower);
 
-    for (int i = 0; i < NR_POINT_LIGHTS; i++) {
-        if (pointLights[i].sqrRange == 0.0)
-        {
-            break;
-        }
-        result += CalcPointLight(pointLights[i], norm, FragPos, viewDir);
-    }
-
-    for (int i = 0; i < NR_DIRECTIONAL_LIGHTS; i++) {
-        if (directionalLights[i].colour == vec3(0.0))
-        {
-            break;
-        }
-        result += CalcDirectionalLight(directionalLights[i], norm, FragPos, viewDir);
-    }
+    FragColour = vec4(colour * result, texSample.a);
 
-    vec4 tex = texture(image, TexCoord);
-    color = tex * vec4(result, 1.0);
+    // Output world-space normal (encoded to 0-1) and roughness in alpha
+    normalRoughness = vec4(norm * 0.5 + 0.5, roughness);
 }

data/lib/engine/shaders/mesh_vertex.glsl

@@ -1,25 +1,25 @@
-#version 330 core
+#version 400 core
 
-// <vec2 position, vec2 texCoords, vec3 normal, vec3 tangent>
 layout (location = 0) in vec3 vertex;
 layout (location = 1) in vec2 texCoord;
 layout (location = 2) in vec3 normal;
 layout (location = 3) in vec3 tangent;
 layout (location = 7) in mat4 model;
 
+uniform mat4 camera;
+
 out vec2 TexCoord;
 out vec3 Normal;
 out vec3 Tangent;
 out vec3 FragPos;
 
-uniform mat4 camera;
-
 void main()
 {
+    gl_Position = camera * model * vec4(vertex, 1.0);
     TexCoord = texCoord;
+    // Transform normal and tangent to world space (proper normal matrix for non-uniform scale)
     mat3 normalMatrix = mat3(transpose(inverse(model)));
     Normal = normalMatrix * normal;
     Tangent = normalMatrix * tangent;
     FragPos = vec3(model * vec4(vertex, 1.0));
-    gl_Position = camera * model * vec4(vertex, 1.0);
 }

data/lib/engine/shaders/point_shadow_frag.glsl

@@ -0,0 +1,12 @@
+#version 330 core
+
+in vec3 FragPos;
+
+uniform vec3 lightPos;
+uniform float farPlane;
+
+void main()
+{
+    float dist = length(FragPos - lightPos);
+    gl_FragDepth = dist / farPlane;
+}

data/lib/engine/shaders/point_shadow_vertex.glsl

@@ -0,0 +1,15 @@
+#version 330 core
+
+layout (location = 0) in vec3 vertex;
+layout (location = 7) in mat4 model;
+
+uniform mat4 lightSpaceMatrix;
+
+out vec3 FragPos;
+
+void main()
+{
+    vec4 worldPos = model * vec4(vertex, 1.0);
+    FragPos = worldPos.xyz;
+    gl_Position = lightSpaceMatrix * worldPos;
+}

data/lib/engine/shaders/post_process/bloom_blur_frag.glsl

@@ -0,0 +1,25 @@
+#version 330 core
+
+in vec2 TexCoords;
+out vec4 color;
+
+uniform sampler2D screenTexture;
+uniform vec2 direction; // (1,0) for horizontal, (0,1) for vertical
+uniform float blurScale; // multiplier for sample spacing
+
+// 9-tap gaussian weights
+const float weights[5] = float[](0.227027, 0.1945946, 0.1216216, 0.054054, 0.016216);
+
+void main()
+{
+    vec2 texelSize = 1.0 / textureSize(screenTexture, 0);
+    vec3 result = texture(screenTexture, TexCoords).rgb * weights[0];
+
+    for (int i = 1; i < 5; i++) {
+        vec2 offset = direction * texelSize * float(i) * blurScale;
+        result += texture(screenTexture, TexCoords + offset).rgb * weights[i];
+        result += texture(screenTexture, TexCoords - offset).rgb * weights[i];
+    }
+
+    color = vec4(result, 1.0);
+}

data/lib/engine/shaders/post_process/bloom_combine_frag.glsl

@@ -0,0 +1,19 @@
+#version 330 core
+
+in vec2 TexCoords;
+out vec4 color;
+
+uniform sampler2D screenTexture;  // original image
+uniform sampler2D bloomTexture;   // blurred bright pixels
+uniform float intensity;
+
+void main()
+{
+    vec3 original = texture(screenTexture, TexCoords).rgb;
+    vec3 bloom = texture(bloomTexture, TexCoords).rgb;
+
+    // Debug: output red to verify shader runs
+    // color = vec4(1.0, 0.0, 0.0, 1.0);
+
+    color = vec4(original + bloom * intensity, 1.0);
+}

data/lib/engine/shaders/post_process/bloom_threshold_frag.glsl

@@ -0,0 +1,19 @@
+#version 330 core
+
+in vec2 TexCoords;
+out vec4 color;
+
+uniform sampler2D screenTexture;
+uniform float threshold;
+
+void main()
+{
+    vec3 texColor = texture(screenTexture, TexCoords).rgb;
+    float brightness = dot(texColor, vec3(0.2126, 0.7152, 0.0722));
+
+    if (brightness > threshold) {
+        color = vec4(texColor, 1.0);
+    } else {
+        color = vec4(0.0, 0.0, 0.0, 1.0);
+    }
+}

data/lib/engine/shaders/post_process/debug_normals_frag.glsl

@@ -0,0 +1,21 @@
+#version 330 core
+
+in vec2 TexCoords;
+out vec4 color;
+
+uniform sampler2D screenTexture;
+uniform sampler2D normalTexture;
+
+void main()
+{
+    vec4 normalRough = texture(normalTexture, TexCoords);
+    vec3 normal = normalRough.rgb;  // already 0-1 encoded
+    float roughness = normalRough.a;
+
+    // Output: RGB = normal colors (visualizes surface orientation)
+    // Blue = up, Green = forward, Red = right
+    color = vec4(normal, 1.0);
+
+    // Uncomment to visualize roughness instead:
+    // color = vec4(vec3(roughness), 1.0);
+}

data/lib/engine/shaders/post_process/depth_debug_frag.glsl

@@ -0,0 +1,17 @@
+#version 330 core
+
+in vec2 TexCoords;
+out vec4 color;
+
+uniform sampler2D screenTexture;
+uniform sampler2D depthTexture;
+
+void main()
+{
+    float depth = texture(depthTexture, TexCoords).r;
+    // Visualize depth (linearize for better visualization)
+    float near = 0.1;
+    float far = 100.0;
+    float linearDepth = (2.0 * near) / (far + near - depth * (far - near));
+    color = vec4(vec3(linearDepth), 1.0);
+}

data/lib/engine/shaders/post_process/dof_blur_frag.glsl

@@ -0,0 +1,52 @@
+#version 330 core
+
+in vec2 TexCoords;
+out vec4 color;
+
+uniform sampler2D screenTexture;
+uniform sampler2D depthTexture;
+uniform vec2 direction;        // (1,0) horizontal, (0,1) vertical
+uniform float focusDistance;
+uniform float focusRange;
+uniform float blurAmount;
+uniform float nearPlane;
+uniform float farPlane;
+
+float linearizeDepth(float d) {
+    return nearPlane * farPlane / (farPlane - d * (farPlane - nearPlane));
+}
+
+float calcCoC(vec2 uv) {
+    float depth = texture(depthTexture, uv).r;
+    float linear = linearizeDepth(depth);
+    float coc = max(0.0, linear - focusDistance) / focusRange;
+    return clamp(coc, 0.0, 1.0) * blurAmount;
+}
+
+void main()
+{
+    float centerCoC = calcCoC(TexCoords);
+
+    // Early out for sharp pixels
+    if (centerCoC < 0.01) {
+        color = texture(screenTexture, TexCoords);
+        return;
+    }
+
+    vec2 texelSize = 1.0 / textureSize(screenTexture, 0);
+    vec3 result = texture(screenTexture, TexCoords).rgb;
+    float totalWeight = 1.0;
+
+    int samples = int(centerCoC * 4.0) + 1;
+
+    for (int i = 1; i <= samples; i++) {
+        vec2 offset = direction * texelSize * float(i) * centerCoC;
+
+        // Sample both directions
+        result += texture(screenTexture, TexCoords + offset).rgb;
+        result += texture(screenTexture, TexCoords - offset).rgb;
+        totalWeight += 2.0;
+    }
+
+    color = vec4(result / totalWeight, 1.0);
+}

data/lib/engine/shaders/post_process/skybox_frag.glsl

@@ -0,0 +1,29 @@
+#version 330 core
+
+in vec2 TexCoords;
+out vec4 FragColor;
+
+uniform sampler2D screenTexture;
+uniform sampler2D depthTexture;
+uniform samplerCube skyboxCubemap;
+uniform mat4 inverseVP;
+uniform vec3 cameraPos;
+
+void main()
+{
+    float depth = texture(depthTexture, TexCoords).r;
+
+    // If depth < 1.0, this is geometry - keep existing color
+    // Use tight threshold since depth buffer clears to exactly 1.0
+    if (depth < 0.99999) {
+        FragColor = texture(screenTexture, TexCoords);
+        return;
+    }
+
+    // Sky pixel: reconstruct view direction and sample cubemap
+    vec4 ndc = vec4(TexCoords * 2.0 - 1.0, 1.0, 1.0);
+    vec4 worldPos = inverseVP * ndc;
+    vec3 viewDir = normalize(worldPos.xyz / worldPos.w - cameraPos);
+
+    FragColor = texture(skyboxCubemap, viewDir);
+}

data/lib/engine/shaders/post_process/ssao/blur_frag.glsl

@@ -0,0 +1,50 @@
+#version 330 core
+
+in vec2 TexCoords;
+out vec4 FragColor;
+
+uniform sampler2D ssaoTexture;
+uniform sampler2D depthTexture;
+uniform int blurSize;
+uniform float depthThreshold;
+
+float linearizeDepth(float d, float near, float far) {
+    return near * far / (far - d * (far - near));
+}
+
+void main() {
+    vec2 texelSize = 1.0 / vec2(textureSize(ssaoTexture, 0));
+    float centerDepth = texture(depthTexture, TexCoords).r;
+
+    // Skip skybox
+    if (centerDepth >= 1.0) {
+        FragColor = vec4(1.0);
+        return;
+    }
+
+    float result = 0.0;
+    float weightSum = 0.0;
+
+    for (int x = -blurSize; x <= blurSize; x++) {
+        for (int y = -blurSize; y <= blurSize; y++) {
+            vec2 offset = vec2(float(x), float(y)) * texelSize;
+            vec2 sampleCoord = TexCoords + offset;
+
+            float sampleDepth = texture(depthTexture, sampleCoord).r;
+
+            // Edge-aware: reduce weight for samples with very different depth
+            float depthDiff = abs(centerDepth - sampleDepth);
+            float depthWeight = 1.0 / (1.0 + depthDiff * depthThreshold);
+
+            // Spatial weight (simple box for now, could use gaussian)
+            float spatialWeight = 1.0;
+
+            float weight = depthWeight * spatialWeight;
+            result += texture(ssaoTexture, sampleCoord).r * weight;
+            weightSum += weight;
+        }
+    }
+
+    float ao = result / weightSum;
+    FragColor = vec4(ao, ao, ao, 1.0);
+}

data/lib/engine/shaders/post_process/ssao/combine_frag.glsl

@@ -0,0 +1,15 @@
+#version 330 core
+
+in vec2 TexCoords;
+out vec4 FragColor;
+
+uniform sampler2D screenTexture;
+uniform sampler2D ssaoTexture;
+
+void main() {
+    vec4 sceneColor = texture(screenTexture, TexCoords);
+    float ao = texture(ssaoTexture, TexCoords).r;
+
+    // Multiply scene color by ambient occlusion
+    FragColor = vec4(sceneColor.rgb * ao, sceneColor.a);
+}

data/lib/engine/shaders/post_process/ssao/frag.glsl

@@ -0,0 +1,99 @@
+#version 330 core
+
+in vec2 TexCoords;
+out vec4 FragColor;
+
+uniform sampler2D depthTexture;
+uniform sampler2D normalTexture;
+uniform sampler2D noiseTexture;
+
+uniform vec3 samples[64];
+uniform int kernelSize;
+uniform float radius;
+uniform float bias;
+uniform float power;
+
+uniform mat4 projection;
+uniform mat4 view;
+uniform mat4 inverseVP;
+uniform float nearPlane;
+uniform float farPlane;
+uniform vec2 noiseScale;
+
+float linearizeDepth(float d) {
+    return nearPlane * farPlane / (farPlane - d * (farPlane - nearPlane));
+}
+
+vec3 viewPosFromDepth(vec2 uv, float depth) {
+    // Reconstruct world position from depth
+    vec4 ndc = vec4(uv * 2.0 - 1.0, depth * 2.0 - 1.0, 1.0);
+    vec4 world = inverseVP * ndc;
+    vec3 worldPos = world.xyz / world.w;
+    // Transform to view space
+    return (view * vec4(worldPos, 1.0)).xyz;
+}
+
+void main() {
+    float depth = texture(depthTexture, TexCoords).r;
+
+    // Skip skybox pixels
+    if (depth >= 1.0) {
+        FragColor = vec4(1.0);
+        return;
+    }
+
+    // Get view-space position
+    vec3 fragPos = viewPosFromDepth(TexCoords, depth);
+
+    // Get world normal and transform to view space
+    vec4 normalRough = texture(normalTexture, TexCoords);
+    vec3 worldNormal = normalize(normalRough.rgb * 2.0 - 1.0);
+    vec3 normal = normalize((view * vec4(worldNormal, 0.0)).xyz);
+
+    // Get random rotation vector from noise texture
+    vec3 randomVec = texture(noiseTexture, TexCoords * noiseScale).xyz;
+
+    // Create TBN matrix (Gram-Schmidt process)
+    vec3 tangent = normalize(randomVec - normal * dot(randomVec, normal));
+    vec3 bitangent = cross(normal, tangent);
+    mat3 TBN = mat3(tangent, bitangent, normal);
+
+    // Sample hemisphere and accumulate occlusion
+    float occlusion = 0.0;
+    for (int i = 0; i < kernelSize; i++) {
+        // Transform sample from tangent space to view space
+        vec3 samplePos = TBN * samples[i];
+        samplePos = fragPos + samplePos * radius;
+
+        // Project sample to screen space
+        vec4 offset = projection * vec4(samplePos, 1.0);
+        offset.xyz /= offset.w;
+        offset.xyz = offset.xyz * 0.5 + 0.5;
+
+        // Sample depth at this screen position
+        float sampleDepth = texture(depthTexture, offset.xy).r;
+
+        // Skip if sample is outside screen
+        if (offset.x < 0.0 || offset.x > 1.0 || offset.y < 0.0 || offset.y > 1.0) {
+            continue;
+        }
+
+        // Skip skybox samples
+        if (sampleDepth >= 1.0) {
+            continue;
+        }
+
+        // Get view-space depth of the geometry at this sample
+        float geometryDepth = -linearizeDepth(sampleDepth);
+
+        // Range check to avoid occlusion from distant objects
+        float rangeCheck = smoothstep(0.0, 1.0, radius / abs(fragPos.z - geometryDepth));
+
+        // Compare depths: if geometry is in front of sample, it's occluded
+        occlusion += (geometryDepth >= samplePos.z + bias ? 1.0 : 0.0) * rangeCheck;
+    }
+
+    occlusion = 1.0 - (occlusion / float(kernelSize));
+    float ao = pow(occlusion, power);
+    FragColor = vec4(ao, ao, ao, 1.0);
+}

data/lib/engine/shaders/post_process/ssr/combine_frag.glsl

@@ -0,0 +1,16 @@
+#version 330 core
+
+in vec2 TexCoords;
+out vec4 FragColor;
+
+uniform sampler2D screenTexture;
+uniform sampler2D ssrTexture;
+
+void main() {
+    vec4 sceneColor = texture(screenTexture, TexCoords);
+    vec4 ssr = texture(ssrTexture, TexCoords);
+
+    // ssr.rgb = reflection color, ssr.a = reflectivity
+    vec3 finalColor = mix(sceneColor.rgb, ssr.rgb, ssr.a);
+    FragColor = vec4(finalColor, sceneColor.a);
+}