Voxel GBuffer and lighting stems

Game/assets/shaders/gbuffer_voxel.frag

@@ -0,0 +1,103 @@
+#version 450
+#extension GL_GOOGLE_include_directive : require
+
+// GBuffer pass, voxel format: engine gbuffer.frag plus RT3 (voxel model)
+
+#include "sleak/frame.glsl"
+#include "craft/shading_models.glsl"
+
+layout(location = 0) in vec3 fragWorldPos;
+layout(location = 1) in vec3 fragWorldNorm;
+layout(location = 2) in vec3 fragWorldTan;
+layout(location = 3) in vec3 fragWorldBit;
+layout(location = 4) in vec4 fragColor;
+layout(location = 5) in vec2 fragUV;
+
+// -- Set 0: PBR material textures (bindings 0-5) --------------------
+layout(set = 0, binding = 0) uniform sampler2D texDiffuse;
+layout(set = 0, binding = 1) uniform sampler2D texNormal;
+layout(set = 0, binding = 2) uniform sampler2D texMetallic;
+layout(set = 0, binding = 3) uniform sampler2D texRoughness;
+layout(set = 0, binding = 4) uniform sampler2D texAO;
+layout(set = 0, binding = 5) uniform sampler2D texEmissive;
+
+// -- Set 0: per-material scalar parameters (binding 6) --------------
+layout(set = 0, binding = 6) uniform MaterialParams {
+    vec4  albedoFactor;      // xyz = base color tint, w = opacity
+    float metallicFactor;
+    float roughnessFactor;
+    float aoFactor;
+    float normalIntensity;
+    vec4  emissiveFactor;    // xyz = emissive color tint, w = intensity
+    float tilingX;
+    float tilingY;
+    float offsetX;
+    float offsetY;
+    uint  hasNormalMap;
+    uint  hasMetallicMap;
+    uint  hasRoughnessMap;
+    uint  hasAOMap;
+    uint  hasEmissiveMap;
+    float _pad0;
+    float _pad1;
+    float _pad2;
+};
+
+layout(location = 0) out vec4 outAlbedoAO;
+layout(location = 1) out vec4 outNormalRough;
+layout(location = 2) out vec4 outMetalEmit;
+layout(location = 3) out vec4 outMotionModel;
+
+// Atlas texels below this alpha are cut out
+const float CRAFT_ALPHA_CUTOFF = 0.5;
+// Roughness floor that keeps the BRDF finite
+const float CRAFT_MIN_ROUGHNESS = 0.04;
+
+void main() {
+    vec2 uv = fragUV * vec2(tilingX, tilingY) + vec2(offsetX, offsetY);
+
+    // --- Base Colour / Albedo ---
+    vec4 albedoSample = texture(texDiffuse, uv) * albedoFactor;
+    if (albedoSample.a < CRAFT_ALPHA_CUTOFF) discard;
+
+    // --- Normal (TBN basis) ---
+    vec3 N = normalize(fragWorldNorm);
+    if (hasNormalMap != 0u) {
+        vec3 tN = texture(texNormal, uv).xyz * 2.0 - 1.0;
+        tN.xy  *= normalIntensity;
+        tN.z = sqrt(max(1.0 - dot(tN.xy, tN.xy), 0.0));
+        vec3 T = normalize(fragWorldTan - dot(fragWorldTan, N) * N);
+        vec3 B = normalize(fragWorldBit - dot(fragWorldBit, N) * N -
+                           dot(fragWorldBit, T) * T);
+        N = normalize(mat3(T, B, N) * tN);
+    }
+
+    // --- Metallic ---
+    float metallic = hasMetallicMap != 0u
+        ? texture(texMetallic, uv).r * metallicFactor
+        : metallicFactor;
+    metallic = clamp(metallic, 0.0, 1.0);
+
+    // --- Roughness ---
+    float roughness = hasRoughnessMap != 0u
+        ? texture(texRoughness, uv).r * roughnessFactor
+        : roughnessFactor;
+    roughness = clamp(roughness, CRAFT_MIN_ROUGHNESS, 1.0);
+
+    // --- Ambient Occlusion (vertex AO in the red channel) ---
+    float ao = hasAOMap != 0u
+        ? texture(texAO, uv).r * aoFactor
+        : fragColor.r * aoFactor;
+    ao = clamp(ao, 0.0, 1.0);
+
+    // --- Emissive (HDR in RT2.gba) ---
+    vec3 emissive = hasEmissiveMap != 0u
+        ? texture(texEmissive, uv).rgb * emissiveFactor.rgb * emissiveFactor.w
+        : emissiveFactor.rgb * emissiveFactor.w;
+
+    outAlbedoAO    = SleakFrameGuard(vec4(albedoSample.rgb, ao));
+    outNormalRough = vec4(N * 0.5 + 0.5, roughness);
+    outMetalEmit   = vec4(metallic, emissive);
+    outMotionModel = SleakEncodeMotionModel(vec2(0.0), 0.0,
+                                            CRAFT_SHADING_MODEL_VOXEL);
+}

Game/assets/shaders/gbuffer_gl.frag → Game/assets/shaders/gbuffer_voxel_gl.frag

@@ -1,9 +1,7 @@
 #version 450 core
+#extension GL_GOOGLE_include_directive : require
 
-// GBuffer geometry pass — outputs material properties to 3 render targets.
-// RT0: AlbedoRGB + AO           (RGBA8)
-// RT1: WorldNormalXYZ + Rough   (RGBA16F, normal packed to [0,1])
-// RT2: Metallic + EmissiveScale  (RGBA8)
+// GBuffer pass, OpenGL, voxel format: engine gbuffer_gl.frag plus RT3
 
 in vec3 fragWorldPos;
 in vec3 fragWorldNorm;
@@ -16,6 +14,7 @@ in vec4 fragShadowCoord;
 layout(location = 0) out vec4 outAlbedoAO;
 layout(location = 1) out vec4 outNormalRough;
 layout(location = 2) out vec4 outMetalEmit;
+layout(location = 3) out vec4 outMotionModel;
 
 // Material textures (binding must match TEXTURE_SLOT defines)
 layout(binding = 0) uniform sampler2D diffuseTexture;
@@ -52,11 +51,15 @@ layout(std140, binding = 1) uniform MaterialUBO {
     vec2 _pad1;
 };
 
+#include "sleak/frame.glsl"
+#include "craft/shading_models.glsl"
+
 void main() {
     vec2 uv = fragUV * matTiling + matOffset;
 
     // Albedo
-    vec4 albedo = (HasDiffuseMap != 0u) ? texture(diffuseTexture, uv) : matDiffuseColor;
+    vec4 albedo = (HasDiffuseMap != 0u) ? texture(diffuseTexture, uv)
+                                        : matDiffuseColor;
     if (albedo.a < matAlphaCutoff) discard;
 
     // Normal (world space)
@@ -70,13 +73,19 @@ void main() {
     }
 
     // PBR scalars
-    float roughness  = (HasRoughnessMap != 0u) ? texture(roughnessTexture, uv).r : matRoughness;
-    float metallic   = (HasMetallicMap  != 0u) ? texture(metallicTexture,  uv).r : matMetallic;
-    float ao         = (HasAOMap        != 0u) ? texture(aoTexture,        uv).r : (matAO * fragColor.r);
-    float emitScale  = (HasEmissiveMap  != 0u) ? length(texture(emissiveTexture, uv).rgb) :
-                        length(matEmissiveColor) * matEmissiveIntensity;
+    float roughness  = (HasRoughnessMap != 0u) ? texture(roughnessTexture, uv).r
+                                               : matRoughness;
+    float metallic   = (HasMetallicMap  != 0u) ? texture(metallicTexture,  uv).r
+                                               : matMetallic;
+    float ao         = (HasAOMap        != 0u) ? texture(aoTexture,        uv).r
+                                               : (matAO * fragColor.r);
+    float emitScale  = (HasEmissiveMap  != 0u)
+                           ? length(texture(emissiveTexture, uv).rgb)
+                           : length(matEmissiveColor) * matEmissiveIntensity;
 
-    outAlbedoAO    = vec4(albedo.rgb, ao);
+    outAlbedoAO    = SleakFrameGuard(vec4(albedo.rgb, ao));
     outNormalRough = vec4(N * 0.5 + 0.5, roughness);  // pack normal to [0,1]
     outMetalEmit   = vec4(metallic, clamp(emitScale, 0.0, 1.0), 0.0, 1.0);
+    outMotionModel = SleakEncodeMotionModel(vec2(0.0), 0.0,
+                                            CRAFT_SHADING_MODEL_VOXEL);
 }

Game/assets/shaders/include/craft/shading_models.glsl

@@ -0,0 +1,9 @@
+#ifndef CRAFT_SHADING_MODELS_GLSL
+#define CRAFT_SHADING_MODELS_GLSL
+
+#include "sleak/gbuffer.glsl"
+
+// SleakCraft shading model ids in GBuffer RT3.w; 0 belongs to the engine
+#define CRAFT_SHADING_MODEL_VOXEL 1u
+
+#endif