fix(rendering): GBuffer pipeline, second-launch asset reload, HashMap rewrite

Resources/Shaders/bindings.glsl

@@ -0,0 +1,11 @@
+// Full bindings — geometry pipeline + global bindless textures + sampler.
+// Use this in shaders that sample from TextureArray (e.g. g_buffer.frag).
+// For passes that only need geometry (e.g. depth pre-pass vertex), use geometry_bindings.glsl.
+#extension GL_EXT_nonuniform_qualifier : require
+
+#include "geometry_bindings.glsl"
+
+#define INVALID_MAP_HANDLE 0xFFFFFFFFu
+
+layout(set = 1, binding = 0) uniform texture2D TextureArray[];
+layout(set = 1, binding = 1) uniform sampler LinearWrapSampler;

Resources/Shaders/composite.frag

@@ -2,13 +2,12 @@
 
 layout(location = 0) in vec2 outUV;
 
-layout(set = 0, binding = 0) uniform texture2D sharedRTAsTex;
+layout(set = 0, binding = 10) uniform texture2D sharedRTAsTex;
 layout(set = 1, binding = 1) uniform sampler LinearWrapSampler;
 
 layout(location = 0) out vec4 outColor;
 
 void main()
 {
-    vec4 color = texture(sampler2D(sharedRTAsTex, LinearWrapSampler), outUV);
-    outColor   = color;
+    outColor = texture(sampler2D(sharedRTAsTex, LinearWrapSampler), outUV);
 }

Resources/Shaders/deferred_lighting.frag

@@ -1,6 +1,7 @@
 #version 460
 #extension GL_GOOGLE_include_directive : require
-#include "fragment_common.glsl"
+#include "bindings.glsl"
+#include "light_types.glsl"
 
 layout(location = 0) in vec2 TexCoord;
 layout(location = 1) in vec4 ViewPos;

Resources/Shaders/deferred_lighting.vert

@@ -1,6 +1,6 @@
 #version 460
 #extension GL_GOOGLE_include_directive : require
-#include "vertex_common.glsl"
+#include "draw.glsl"
 
 layout(location = 0) out vec2 TexCoord;
 layout(location = 1) out vec4 ViewPos;

Resources/Shaders/depth_prepass_scene.vert

@@ -1,6 +1,6 @@
 #version 460
 #extension GL_GOOGLE_include_directive : require
-#include "vertex_common.glsl"
+#include "draw.glsl"
 
 void main()
 {

Resources/Shaders/draw.glsl

@@ -0,0 +1,38 @@
+// Pull-render helpers — assembles per-vertex data from the global geometry buffers.
+// Uses geometry_bindings.glsl only — safe for all vertex stages including depth pre-pass.
+#include "geometry_bindings.glsl"
+
+DrawDataView GetDrawDataView()
+{
+    DrawDataView dataView;
+
+    DrawData     dd     = DrawDataBuffer.Data[gl_BaseInstance];
+    uint         refIdx = dd.IndexOffset + gl_VertexIndex;
+    uint         verIdx = IndexBuffer.Data[refIdx] + dd.VertexOffset;
+    DrawVertex   v      = VertexBuffer.Data[verIdx];
+
+    dataView.Vertex     = vec4(v.x, v.y, v.z, 1.0);
+    dataView.Normal     = vec3(v.nx, v.ny, v.nz);
+    dataView.TexCoord   = vec2(v.u, v.v);
+    dataView.Transform  = TransformBuffer.Data[dd.TransformIndex];
+    dataView.MaterialId = dd.MaterialIndex;
+    return dataView;
+}
+
+DrawData FetchDrawData()
+{
+    return DrawDataBuffer.Data[gl_BaseInstance];
+}
+
+DrawVertex FetchVertexData()
+{
+    DrawData dd     = FetchDrawData();
+    uint     refIdx = dd.IndexOffset + gl_VertexIndex;
+    uint     verIdx = IndexBuffer.Data[refIdx] + dd.VertexOffset;
+    return VertexBuffer.Data[verIdx];
+}
+
+mat4 FetchTransform()
+{
+    return TransformBuffer.Data[FetchDrawData().TransformIndex];
+}

Resources/Shaders/draw_types.glsl

@@ -0,0 +1,30 @@
+// Vertex and draw-call data structures used by the pull-render pipeline.
+// No descriptor bindings — include this wherever the structs are needed.
+
+struct DrawVertex
+{
+    float x, y, z;
+    float nx, ny, nz;
+    float u, v;
+};
+
+struct DrawData
+{
+    uint VertexOffset;
+    uint VertexCount;
+    uint IndexOffset;
+    uint IndexCount;
+    uint AllocationCount;
+    uint InstanceCount;
+    uint TransformIndex;
+    uint MaterialIndex;
+};
+
+struct DrawDataView
+{
+    uint MaterialId;
+    mat4 Transform;
+    vec4 Vertex;
+    vec3 Normal;
+    vec2 TexCoord;
+};

Resources/Shaders/g_buffer.frag

@@ -1,6 +1,6 @@
 #version 460
 #extension GL_GOOGLE_include_directive : require
-#include "fragment_common.glsl"
+#include "material.glsl"
 
 layout(location = 0) in vec2 TexCoord;
 layout(location = 1) in vec3 WorldNormal;

Resources/Shaders/g_buffer.vert

@@ -1,6 +1,6 @@
 #version 460
 #extension GL_GOOGLE_include_directive : require
-#include "vertex_common.glsl"
+#include "draw.glsl"
 
 layout(location = 0) out vec2 TexCoord;
 layout(location = 1) out vec3 WorldNormal;

Resources/Shaders/geometry_bindings.glsl

@@ -0,0 +1,35 @@
+// Geometry pipeline bindings — camera, vertex, index, draw data, transform.
+// No material, no textures, no samplers — safe to include in any pass.
+#include "draw_types.glsl"
+
+layout(set = 0, binding = 0) uniform UBCamera
+{
+    mat4 View;
+    mat4 Projection;
+    vec4 Position;
+}
+Camera;
+
+layout(set = 0, binding = 1) readonly buffer VertexSB
+{
+    DrawVertex Data[];
+}
+VertexBuffer;
+
+layout(set = 0, binding = 2) readonly buffer IndexSB
+{
+    uint Data[];
+}
+IndexBuffer;
+
+layout(set = 0, binding = 3) readonly buffer DrawDataSB
+{
+    DrawData Data[];
+}
+DrawDataBuffer;
+
+layout(set = 0, binding = 4) readonly buffer TransformSB
+{
+    mat4 Data[];
+}
+TransformBuffer;

Resources/Shaders/light_types.glsl

@@ -0,0 +1,37 @@
+// Light data structures — composable by any pass that needs lighting.
+// No descriptor bindings.
+
+struct DirectionalLight
+{
+    vec4 Direction;
+    vec4 Ambient;
+    vec4 Diffuse;
+    vec4 Specular;
+};
+
+struct PointLight
+{
+    vec4  Position;
+    vec4  Ambient;
+    vec4  Diffuse;
+    vec4  Specular;
+
+    float Constant;
+    float Linear;
+    float Quadratic;
+    float _padding;
+};
+
+struct SpotLight
+{
+    vec4  Position;
+    vec4  Direction;
+    vec4  Ambient;
+    vec4  Diffuse;
+    vec4  Specular;
+
+    float CutOff;
+    float Constant;
+    float Linear;
+    float Quadratic;
+};

Resources/Shaders/material.glsl

@@ -0,0 +1,18 @@
+// Material bindings and accessor — fragment-stage only.
+// Declares set=1 (TextureArray, LinearWrapSampler) and MatSB.
+// Does NOT pull in geometry buffers so no duplicate-binding conflicts with vertex stage.
+#extension GL_EXT_shader_explicit_arithmetic_types_int64 : enable
+
+#include "material_types.glsl"
+#include "texture_bindings.glsl"
+
+layout(std140, set = 0, binding = 5) readonly buffer MatSB
+{
+    MaterialData Data[];
+}
+MaterialDataBuffer;
+
+MaterialData FetchMaterial(uint dataIndex)
+{
+    return MaterialDataBuffer.Data[dataIndex];
+}

Resources/Shaders/material_types.glsl

@@ -0,0 +1,21 @@
+// Material data structure.
+// No descriptor bindings — include wherever MaterialData is needed.
+// Note: MaterialData uses uint64_t; include material.glsl (not this file directly)
+// in shader stages that need the full material pipeline — it enables Int64 there.
+
+struct MaterialData
+{
+    vec4     Ambient;
+    vec4     Emissive;
+    vec4     Albedo;
+    vec4     Specular;
+    vec4     Roughness;
+    vec4     Factors; // {x : transparency, y : Metallic, z : AlphaTest, w : _padding}
+
+    uint64_t EmissiveMap;
+    uint64_t AlbedoMap;
+    uint64_t SpecularMap;
+    uint64_t NormalMap;
+    uint64_t OpacityMap;
+    uint64_t _padding;
+};