Implement complete rendering system with lighting, shadows, post-processing, GPU-driven features, professional editor UI with 7 panels, and FileSystem utility with full integration

.gitmodules

@@ -12,3 +12,6 @@
 	path = Core/vendor/tracy/tracy
 	url = https://github.com/wolfpld/tracy
 	branch = v0.9.1
+[submodule "Core/vendor/NFD-Extended/NFD-Extended"]
+	path = Core/vendor/NFD-Extended/NFD-Extended
+	url = https://github.com/btzy/nativefiledialog-extended

App/Resources/Shaders/TexturedModel.frag.glsl

@@ -0,0 +1,128 @@
+#version 450 core
+
+in vec2 v_UV;
+in vec3 v_WorldPos;
+in vec3 v_NormalWS;
+
+uniform int u_HasAlbedo;
+uniform int u_HasNormal;
+uniform int u_HasMR;
+uniform int u_HasAO;
+uniform int u_HasEmissive;
+
+uniform sampler2D u_AlbedoTex;
+uniform sampler2D u_NormalTex;
+uniform sampler2D u_MRTex;      // assume ORM packed: R=AO, G=Roughness, B=Metallic (glTF)
+uniform sampler2D u_AOTex;      // optional separate AO
+uniform sampler2D u_EmissiveTex;
+
+uniform vec4  u_BaseColorFactor;
+uniform float u_MetallicFactor;
+uniform float u_RoughnessFactor;
+
+out vec4 o_Color;
+
+vec3 SRGBToLinear(vec3 c) { return pow(c, vec3(2.2)); }
+vec3 LinearToSRGB(vec3 c) { return pow(c, vec3(1.0/2.2)); }
+
+vec3 GetNormalWS()
+{
+    vec3 N = normalize(v_NormalWS);
+
+    if (u_HasNormal == 0)
+        return N;
+
+    // Build TBN from derivatives (no tangent attribute required)
+    vec3 dp1 = dFdx(v_WorldPos);
+    vec3 dp2 = dFdy(v_WorldPos);
+    vec2 duv1 = dFdx(v_UV);
+    vec2 duv2 = dFdy(v_UV);
+
+    vec3 T = normalize(dp1 * duv2.y - dp2 * duv1.y);
+    vec3 B = normalize(-dp1 * duv2.x + dp2 * duv1.x);
+
+    mat3 TBN = mat3(T, B, N);
+
+    vec3 nTS = texture(u_NormalTex, v_UV).xyz * 2.0 - 1.0;
+    return normalize(TBN * nTS);
+}
+
+// tiny GGX helpers
+float D_GGX(float NoH, float a)
+{
+    float a2 = a*a;
+    float d = (NoH*NoH)*(a2-1.0) + 1.0;
+    return a2 / (3.14159 * d * d);
+}
+float V_SmithGGX(float NoV, float NoL, float a)
+{
+    float a2 = a*a;
+    float gv = NoL * sqrt(NoV*(NoV - NoV*a2) + a2);
+    float gl = NoV * sqrt(NoL*(NoL - NoL*a2) + a2);
+    return 0.5 / max(gv + gl, 1e-6);
+}
+vec3 F_Schlick(vec3 F0, float VoH)
+{
+    return F0 + (1.0 - F0) * pow(1.0 - VoH, 5.0);
+}
+
+void main()
+{
+    vec3 base = vec3(0.8);
+    if (u_HasAlbedo == 1)
+        base = SRGBToLinear(texture(u_AlbedoTex, v_UV).rgb);
+
+    base *= u_BaseColorFactor.rgb;
+
+    float ao = 1.0;
+    float rough = 0.8;
+    float metal = 0.0;
+
+    if (u_HasMR == 1)
+    {
+        vec3 orm = texture(u_MRTex, v_UV).rgb;
+        ao = orm.r;
+        rough = orm.g;
+        metal = orm.b;
+    }
+
+    if (u_HasAO == 1)
+        ao = texture(u_AOTex, v_UV).r;
+
+    rough = clamp(rough * u_RoughnessFactor, 0.04, 1.0);
+    metal = clamp(metal * u_MetallicFactor, 0.0, 1.0);
+
+    vec3 N = GetNormalWS();
+    vec3 V = normalize(vec3(0.0, 0.0, 1.0)); // ok-ish placeholder if you don't have camera pos in shader
+    // If you can pass camera position, use: normalize(u_CameraPos - v_WorldPos)
+
+    vec3 L = normalize(vec3(0.4, 0.8, 0.2));
+    vec3 H = normalize(V + L);
+
+    float NoL = max(dot(N, L), 0.0);
+    float NoV = max(dot(N, V), 0.001);
+    float NoH = max(dot(N, H), 0.001);
+    float VoH = max(dot(V, H), 0.001);
+
+    vec3 F0 = mix(vec3(0.04), base, metal);
+
+    float a = rough * rough;
+    vec3  F = F_Schlick(F0, VoH);
+    float D = D_GGX(NoH, a);
+    float G = V_SmithGGX(NoV, NoL, a);
+
+    vec3 spec = (D * G) * F;
+    vec3 kd = (1.0 - F) * (1.0 - metal);
+    vec3 diff = kd * base / 3.14159;
+
+    vec3 color = (diff + spec) * NoL;
+
+    // emissive
+    if (u_HasEmissive == 1)
+        color += SRGBToLinear(texture(u_EmissiveTex, v_UV).rgb);
+
+    // cheap ambient with AO
+    color += base * 0.03 * ao;
+
+    o_Color = vec4(LinearToSRGB(color), 1.0);
+}

App/Resources/Shaders/TexturedModel.vert.glsl

@@ -0,0 +1,24 @@
+#version 450 core
+
+layout(location = 0) in vec3 a_Position;
+layout(location = 1) in vec3 a_Normal;
+layout(location = 2) in vec2 a_TexCoord;
+
+layout(std140, binding = 0) uniform FrameData { mat4 u_ViewProjection; };
+layout(std140, binding = 1) uniform ObjectData { mat4 u_Model; };
+
+out vec2 v_UV;
+out vec3 v_WorldPos;
+out vec3 v_NormalWS;
+
+void main()
+{
+    vec4 wp = u_Model * vec4(a_Position, 1.0);
+    v_WorldPos = wp.xyz;
+    v_UV = a_TexCoord;
+
+    // ok for uniform scaling; if you do non-uniform later, use inverse transpose
+    v_NormalWS = mat3(u_Model) * a_Normal;
+
+    gl_Position = u_ViewProjection * wp;
+}