ruby_rpg 0.0.5 → 0.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);
+}

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

@@ -0,0 +1,118 @@
+#version 330 core
+
+in vec2 TexCoords;
+out vec4 FragColor;
+
+uniform sampler2D screenTexture;
+uniform sampler2D depthTexture;
+uniform sampler2D normalTexture;
+uniform samplerCube skyboxCubemap;
+
+uniform mat4 inverseVP;
+uniform mat4 viewProj;
+uniform vec3 cameraPos;
+
+uniform int maxSteps;
+uniform float maxRayDistance;
+uniform float thickness;
+uniform float rayOffset;
+uniform float nearPlane;
+uniform float farPlane;
+
+float linearizeDepth(float d) {
+    return nearPlane * farPlane / (farPlane - d * (farPlane - nearPlane));
+}
+
+vec3 worldPosFromDepth(vec2 uv, float depth) {
+    vec4 ndc = vec4(uv * 2.0 - 1.0, depth * 2.0 - 1.0, 1.0);
+    vec4 world = inverseVP * ndc;
+    return world.xyz / world.w;
+}
+
+void main() {
+    float depth = texture(depthTexture, TexCoords).r;
+
+    // No reflection for skybox
+    if (depth >= 1.0) {
+        FragColor = vec4(0.0, 0.0, 0.0, 0.0);
+        return;
+    }
+
+    vec4 normalRough = texture(normalTexture, TexCoords);
+    float roughness = normalRough.a;
+
+    // No reflection for fully rough surfaces
+    if (roughness >= 1.0) {
+        FragColor = vec4(0.0, 0.0, 0.0, 0.0);
+        return;
+    }
+
+    vec3 worldPos = worldPosFromDepth(TexCoords, depth);
+    vec3 normal = normalize(normalRough.rgb * 2.0 - 1.0);
+    vec3 viewDir = normalize(worldPos - cameraPos);
+    vec3 reflectDir = reflect(viewDir, normal);
+
+    // Project ray start/end to screen space once
+    vec3 rayStart = worldPos + reflectDir * rayOffset;
+    vec3 rayEnd = worldPos + reflectDir * maxRayDistance;
+
+    vec4 clipStart = viewProj * vec4(rayStart, 1.0);
+    vec4 clipEnd = viewProj * vec4(rayEnd, 1.0);
+
+    if (clipEnd.w < 0.0) {
+        float t = clipStart.w / (clipStart.w - clipEnd.w);
+        clipEnd = mix(clipStart, clipEnd, t);
+    }
+
+    vec3 screenStart = clipStart.xyz / clipStart.w;
+    vec3 screenEnd = clipEnd.xyz / clipEnd.w;
+
+    screenStart.xy = screenStart.xy * 0.5 + 0.5;
+    screenEnd.xy = screenEnd.xy * 0.5 + 0.5;
+    screenStart.z = screenStart.z * 0.5 + 0.5;
+    screenEnd.z = screenEnd.z * 0.5 + 0.5;
+
+    // Ray march in screen space with perspective-correct depth
+    float linearDepthStart = linearizeDepth(screenStart.z);
+    float linearDepthEnd = linearizeDepth(screenEnd.z);
+
+    bool hitFound = false;
+    vec2 hitUV;
+
+    for (int i = 0; i < maxSteps; i++) {
+        float t = float(i) / float(maxSteps - 1);
+
+        vec2 screenPos = mix(screenStart.xy, screenEnd.xy, t);
+
+        if (screenPos.x < 0.0 || screenPos.x > 1.0 ||
+            screenPos.y < 0.0 || screenPos.y > 1.0) {
+            break;
+        }
+
+        float rayLinearDepth = (linearDepthStart * linearDepthEnd) /
+                                mix(linearDepthEnd, linearDepthStart, t);
+
+        float sceneDepthRaw = texture(depthTexture, screenPos).r;
+        if (sceneDepthRaw >= 1.0) continue;
+
+        float sceneLinearDepth = linearizeDepth(sceneDepthRaw);
+        float depthDiff = rayLinearDepth - sceneLinearDepth;
+
+        if (depthDiff > 0.0 && depthDiff < thickness) {
+            hitFound = true;
+            hitUV = screenPos;
+            break;
+        }
+    }
+
+    float reflectivity = 1.0 - roughness;
+
+    // Output: RGB = reflection color, A = reflectivity
+    if (hitFound) {
+        vec3 reflectionColor = texture(screenTexture, hitUV).rgb;
+        FragColor = vec4(reflectionColor, reflectivity);
+    } else {
+        vec3 skyColor = texture(skyboxCubemap, reflectDir).rgb;
+        FragColor = vec4(skyColor, reflectivity);
+    }
+}

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

@@ -0,0 +1,14 @@
+#version 330 core
+
+in vec2 TexCoords;
+out vec4 color;
+
+uniform sampler2D screenTexture;
+uniform vec4 tintColor; // rgba, alpha controls intensity
+
+void main()
+{
+    vec4 texColor = texture(screenTexture, TexCoords);
+    vec3 tinted = mix(texColor.rgb, texColor.rgb * tintColor.rgb, tintColor.a);
+    color = vec4(tinted, texColor.a);
+}

data/lib/engine/shaders/shadow_frag.glsl

@@ -0,0 +1,6 @@
+#version 330 core
+
+void main()
+{
+    // Depth is written automatically
+}

data/lib/engine/shaders/shadow_vertex.glsl

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

data/lib/engine/shaders/skybox_cubemap_frag.glsl

@@ -0,0 +1,46 @@
+#version 330 core
+
+in vec2 TexCoords;
+out vec4 FragColor;
+
+uniform vec3 groundColour = vec3(0.2, 0.2, 0.2);  // neutral grey
+uniform vec3 horizonColour = vec3(0.7, 0.8, 0.9); // light hazy blue
+uniform vec3 skyColour = vec3(0.3, 0.5, 0.8);     // deeper blue
+uniform float groundY = -0.1;   // ground gradient ends here
+uniform float horizonY = 0;  // horizon line
+uniform float skyY = 0.2;       // sky gradient completes here
+uniform int faceIndex;
+
+vec3 getDirection(vec2 uv, int face) {
+    vec2 st = uv * 2.0 - 1.0;
+    vec3 dir;
+
+    switch(face) {
+        case 0: dir = vec3( 1.0, -st.y, -st.x); break;  // +X
+        case 1: dir = vec3(-1.0, -st.y,  st.x); break;  // -X
+        case 2: dir = vec3( st.x,  1.0,  st.y); break;  // +Y
+        case 3: dir = vec3( st.x, -1.0, -st.y); break;  // -Y
+        case 4: dir = vec3( st.x, -st.y,  1.0); break;  // +Z
+        case 5: dir = vec3(-st.x, -st.y, -1.0); break;  // -Z
+        default: dir = vec3(0.0, 1.0, 0.0); break;
+    }
+
+    return normalize(dir);
+}
+
+void main() {
+    vec3 dir = getDirection(TexCoords, faceIndex);
+
+    vec3 color;
+    if (dir.y >= horizonY) {
+        // Above horizon: blend horizon -> sky
+        float mixFactor = clamp((dir.y - horizonY) / (skyY - horizonY), 0.0, 1.0);
+        color = mix(horizonColour, skyColour, mixFactor);
+    } else {
+        // Below horizon: blend ground -> horizon
+        float mixFactor = clamp((dir.y - groundY) / (horizonY - groundY), 0.0, 1.0);
+        color = mix(groundColour, horizonColour, mixFactor);
+    }
+
+    FragColor = vec4(color, 1.0);
+}

data/lib/engine/shaders/sprite_frag.glsl

@@ -1,17 +1,17 @@
-#version 330 core
-in vec2 TexCoords;
-out vec4 color;
-
-uniform sampler2D image;
-uniform vec3 spriteColor;
-uniform vec4 frameCoords;
-
-void main()
-{
-    vec2 interpolatedCoords = vec2(frameCoords.x + (TexCoords.x * frameCoords.z), frameCoords.y + TexCoords.y * frameCoords.w);;
-    vec4 texColor = texture(image, interpolatedCoords);
-    if(texColor.a < 0.05)
-        discard;
-    else
-        color = vec4(spriteColor, 1.0) * texColor;
-}
+#version 330 core
+in vec2 TexCoords;
+out vec4 color;
+
+uniform sampler2D image;
+uniform vec3 spriteColor;
+uniform vec4 frameCoords;
+
+void main()
+{
+    vec2 interpolatedCoords = vec2(frameCoords.x + (TexCoords.x * frameCoords.z), frameCoords.y + TexCoords.y * frameCoords.w);;
+    vec4 texColor = texture(image, interpolatedCoords);
+    if(texColor.a < 0.05)
+        discard;
+    else
+        color = vec4(spriteColor, 1.0) * texColor;
+}

data/lib/engine/shaders/sprite_vertex.glsl

@@ -1,16 +1,16 @@
-#version 330 core
-
-// <vec3 position, vec2 texCoords>
-layout (location = 0) in vec3 vertex;
-layout (location = 1) in vec2 texCoord;
-
-out vec2 TexCoords;
-
-uniform mat4 camera;
-uniform mat4 model;
-
-void main()
-{
-    TexCoords = texCoord;
-    gl_Position = camera * model * vec4(vertex, 1.0);
+#version 330 core
+
+// <vec3 position, vec2 texCoords>
+layout (location = 0) in vec3 vertex;
+layout (location = 1) in vec2 texCoord;
+
+out vec2 TexCoords;
+
+uniform mat4 camera;
+uniform mat4 model;
+
+void main()
+{
+    TexCoords = texCoord;
+    gl_Position = camera * model * vec4(vertex, 1.0);
 }

data/lib/engine/shaders/text_frag.glsl

@@ -1,15 +1,15 @@
-#version 330 core
-
-out vec4 color;
-
-in vec2 TexCoords;
-
-uniform sampler2D fontTexture;
-
-void main()
-{
-    vec4 textureColor = texture(fontTexture, TexCoords);
-    if(textureColor.a < 0.1)
-        discard;
-    color = vec4(1.0, 1.0, 1.0, textureColor.a);
-}
+#version 330 core
+
+out vec4 color;
+
+in vec2 TexCoords;
+
+uniform sampler2D fontTexture;
+
+void main()
+{
+    vec4 textureColor = texture(fontTexture, TexCoords);
+    if(textureColor.a < 0.1)
+        discard;
+    color = vec4(1.0, 1.0, 1.0, textureColor.a);
+}

data/lib/engine/shaders/text_vertex.glsl

@@ -1,31 +1,31 @@
-#version 330 core
-
-// <vec3 position, vec2 texCoords>
-layout (location = 0) in vec3 vertex;
-layout (location = 1) in vec2 texCoords;
-layout (location = 2) in int textIndex;
-layout (location = 3) in vec2 offset;
-
-uniform mat4 camera;
-uniform mat4 model;
-
-out vec2 TexCoords;
-
-vec2 getTexCoords()
-{
-    int x = textIndex / 16;
-    int y = textIndex % 16;
-    return (vec2(x, y) + texCoords) / 16.0;
-}
-
-vec3 quadPosition()
-{
-    return vertex + vec3(offset.x, offset.y, 0);
-}
-
-
-void main()
-{
-    gl_Position = camera * model * vec4(quadPosition(), 1.0);
-    TexCoords = getTexCoords();
-}
+#version 330 core
+
+// <vec3 position, vec2 texCoords>
+layout (location = 0) in vec3 vertex;
+layout (location = 1) in vec2 texCoords;
+layout (location = 2) in int textIndex;
+layout (location = 3) in vec2 offset;
+
+uniform mat4 camera;
+uniform mat4 model;
+
+out vec2 TexCoords;
+
+vec2 getTexCoords()
+{
+    int x = textIndex / 16;
+    int y = textIndex % 16;
+    return (vec2(x, y) + texCoords) / 16.0;
+}
+
+vec3 quadPosition()
+{
+    return vertex + vec3(offset.x, offset.y, 0);
+}
+
+
+void main()
+{
+    gl_Position = camera * model * vec4(quadPosition(), 1.0);
+    TexCoords = getTexCoords();
+}

data/lib/engine/shaders/ui_sprite_frag.glsl

@@ -1,15 +1,15 @@
-#version 330 core
-in vec2 TexCoords;
-out vec4 color;
-
-uniform sampler2D image;
-uniform vec4 spriteColor;
-
-void main()
-{
-    vec4 texColor = texture(image, TexCoords);
-    if(texColor.a < 0.05)
-        discard;
-    else
-        color = spriteColor * texColor;
-}
+#version 330 core
+in vec2 TexCoords;
+out vec4 color;
+
+uniform sampler2D image;
+uniform vec4 spriteColor;
+
+void main()
+{
+    vec4 texColor = texture(image, TexCoords);
+    if(texColor.a < 0.05)
+        discard;
+    else
+        color = spriteColor * texColor;
+}

data/lib/engine/shaders/ui_sprite_vertex.glsl

@@ -1,16 +1,16 @@
-#version 330 core
-
-// <vec3 position, vec2 texCoords>
-layout (location = 0) in vec3 vertex;
-layout (location = 1) in vec2 texCoord;
-
-out vec2 TexCoords;
-
-uniform mat4 camera;
-uniform mat4 model;
-
-void main()
-{
-    TexCoords = texCoord;
-    gl_Position = camera * model * vec4(vertex, 1.0);
+#version 330 core
+
+// <vec3 position, vec2 texCoords>
+layout (location = 0) in vec3 vertex;
+layout (location = 1) in vec2 texCoord;
+
+out vec2 TexCoords;
+
+uniform mat4 camera;
+uniform mat4 model;
+
+void main()
+{
+    TexCoords = texCoord;
+    gl_Position = camera * model * vec4(vertex, 1.0);
 }