ruby_rpg 0.0.5 → 0.1.0

data/lib/engine/shaders/{skybox_vert.glsl → instanced_sprite_vertex.glsl}

@@ -1,14 +1,15 @@
-#version 330 core
-
-layout (location = 0) in vec3 vertex;
-layout (location = 7) in mat4 model;
-
-out vec3 FragPos;
-
-uniform mat4 camera;
-
-void main()
-{
-    FragPos = vec3(model * vec4(vertex, 1.0));
-    gl_Position = camera * model * vec4(vertex, 1.0);
-}
+#version 330 core
+
+layout (location = 0) in vec3 vertex;
+layout (location = 1) in vec2 texCoord;
+layout (location = 7) in mat4 model;
+
+out vec2 TexCoords;
+
+uniform mat4 camera;
+
+void main()
+{
+    TexCoords = texCoord;
+    gl_Position = camera * model * vec4(vertex, 1.0);
+}

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

@@ -0,0 +1,49 @@
+// Directional light structure and calculation functions
+
+#include "lighting_common.glsl"
+
+struct DirectionalLight {
+    vec3 direction;
+    vec3 colour;
+    mat4 lightSpaceMatrix;
+    bool castsShadows;
+};
+#define NR_DIRECTIONAL_LIGHTS 4
+uniform DirectionalLight directionalLights[NR_DIRECTIONAL_LIGHTS];
+uniform sampler2DArray directionalShadowMaps;
+
+float CalcDirectionalShadow(DirectionalLight light, int lightIndex, vec3 fragPos)
+{
+    if (!light.castsShadows) {
+        return 0.0;
+    }
+
+    vec4 fragPosLightSpace = light.lightSpaceMatrix * vec4(fragPos, 1.0);
+    vec3 projCoords = fragPosLightSpace.xyz / fragPosLightSpace.w;
+    projCoords = projCoords * 0.5 + 0.5;
+
+    // Fragment is beyond the shadow map frustum
+    if (projCoords.z > 1.0) {
+        return 0.0;
+    }
+
+    // Check if coords are in valid range
+    if (projCoords.x < 0.0 || projCoords.x > 1.0 ||
+        projCoords.y < 0.0 || projCoords.y > 1.0) {
+        return 0.0;  // Outside frustum XY
+    }
+
+    float closestDepth = texture(directionalShadowMaps, vec3(projCoords.xy, float(lightIndex))).r;
+    float currentDepth = projCoords.z;
+    float bias = 0.005;
+
+    return currentDepth - bias > closestDepth ? 1.0 : 0.0;
+}
+
+vec3 CalcDirectionalLight(DirectionalLight light, int lightIndex, vec3 normal, vec3 fragPos, vec3 viewDir, float diffuseStrength, float specularStrength, float specularPower)
+{
+    float shadow = CalcDirectionalShadow(light, lightIndex, fragPos);
+    vec3 lightDir = -light.direction;
+    vec2 phong = CalcPhong(normal, lightDir, viewDir, diffuseStrength, specularStrength, specularPower);
+    return light.colour * (phong.x + phong.y) * (1.0 - shadow);
+}

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

@@ -0,0 +1,33 @@
+// Lighting - includes all light types and provides combined calculation
+// Include this file in shaders that need lighting support
+
+#include "directional_light.glsl"
+#include "point_light.glsl"
+#include "spot_light.glsl"
+
+uniform samplerCube skybox; // @fallback skybox
+uniform float ambientStrength = 0.3;
+
+vec3 CalcAllLights(vec3 normal, vec3 fragPos, vec3 viewDir, float diffuseStrength, float specularStrength, float specularPower)
+{
+    // Sample skybox using surface normal for ambient lighting
+    vec3 ambientLight = texture(skybox, normal).rgb * ambientStrength;
+    vec3 result = ambientLight;
+
+    for (int i = 0; i < NR_POINT_LIGHTS; i++) {
+        if (pointLights[i].sqrRange == 0.0) break;
+        result += CalcPointLight(pointLights[i], i, normal, fragPos, viewDir, diffuseStrength, specularStrength, specularPower);
+    }
+
+    for (int i = 0; i < NR_DIRECTIONAL_LIGHTS; i++) {
+        if (directionalLights[i].colour == vec3(0.0)) break;
+        result += CalcDirectionalLight(directionalLights[i], i, normal, fragPos, viewDir, diffuseStrength, specularStrength, specularPower);
+    }
+
+    for (int i = 0; i < NR_SPOT_LIGHTS; i++) {
+        if (spotLights[i].sqrRange == 0.0) break;
+        result += CalcSpotLight(spotLights[i], i, normal, fragPos, viewDir, diffuseStrength, specularStrength, specularPower);
+    }
+
+    return result;
+}

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

@@ -0,0 +1,13 @@
+// Common lighting calculations shared by all light types
+
+// Calculates Phong diffuse and specular contribution
+// lightDir: normalized direction FROM fragment TO light
+// Returns vec2(diffuse, specular)
+vec2 CalcPhong(vec3 normal, vec3 lightDir, vec3 viewDir,
+               float diffuseStrength, float specularStrength, float specularPower)
+{
+    float diff = max(dot(normal, lightDir), 0.0);
+    vec3 reflectDir = reflect(lightDir, normal);
+    float spec = pow(max(dot(-viewDir, reflectDir), 0.0), specularPower);
+    return vec2(diff * diffuseStrength, spec * specularStrength);
+}

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

@@ -0,0 +1,46 @@
+// Point light structure and calculation functions
+
+#include "lighting_common.glsl"
+
+struct PointLight {
+    vec3 position;
+    float sqrRange;
+    vec3 colour;
+    bool castsShadows;
+    int shadowLayerIndex;
+    float shadowFar;
+};
+#define NR_POINT_LIGHTS 16
+#define NR_SHADOW_CASTING_POINT_LIGHTS 4
+uniform PointLight pointLights[NR_POINT_LIGHTS];
+uniform samplerCubeArray pointShadowMaps;
+
+float CalcPointShadow(PointLight light, int lightIndex, vec3 fragPos)
+{
+    if (!light.castsShadows) {
+        return 0.0;
+    }
+
+    vec3 fragToLight = fragPos - light.position;
+    float currentDepth = length(fragToLight);
+
+    // Sample from cubemap array using vec4(direction, layerIndex)
+    float closestDepth = texture(pointShadowMaps, vec4(fragToLight, float(light.shadowLayerIndex))).r;
+    closestDepth *= light.shadowFar;  // Convert from [0,1] to world units
+
+    float bias = 0.5;
+    return currentDepth - bias > closestDepth ? 1.0 : 0.0;
+}
+
+vec3 CalcPointLight(PointLight 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 attenuation = light.sqrRange / sqrDistance;
+    float shadow = CalcPointShadow(light, lightIndex, fragPos);
+
+    vec2 phong = CalcPhong(normal, lightDir, viewDir, diffuseStrength, specularStrength, specularPower);
+    return light.colour * (phong.x + phong.y) * attenuation * (1.0 - shadow);
+}

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
-
-in vec2 TexCoord;
-in vec3 Normal;
-in vec3 Tangent;
-in vec3 FragPos;
-
-out vec4 color;
-
-uniform sampler2D image;
-uniform sampler2D normalMap;
-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;
-
-    return light.colour * (diffuse + specular);
-}
-
-void main()
-{
-    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 )
-    {
-        vec3 b = cross(t, n);
-        mat3 TBN = mat3(t, b, n);
-        norm = normalize(TBN * normalize(sampledNormal));
-    }
-    vec3 viewDir = normalize(cameraPos - FragPos);
-
-    vec3 result = ambientLight;
-
-    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);
-    }
-
-    vec4 tex = texture(image, TexCoord);
-    color = tex * vec4(result, 1.0);
-}
+#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;
+
+uniform sampler2D image; // @fallback white
+uniform sampler2D normalMap; // @fallback normal
+uniform vec3 cameraPos;
+
+// 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;
+
+#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;
+    vec3 n = normalize(Normal);
+    vec3 t = normalize(Tangent);
+    vec3 norm = n;
+
+    // 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 = CalcAllLights(norm, FragPos, viewDir, diffuseStrength, specularStrength, specularPower);
+
+    FragColour = vec4(colour * result, texSample.a);
+
+    // 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
-
-// <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;
-
-out vec2 TexCoord;
-out vec3 Normal;
-out vec3 Tangent;
-out vec3 FragPos;
-
-uniform mat4 camera;
-
-void main()
-{
-    TexCoord = texCoord;
-    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);
-}
+#version 400 core
+
+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;
+
+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));
+}

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);
+}