addressing more comments.

Author: gpx1000

en/Building_a_Simple_Engine/GUI/04_ui_elements.adoc

@@ -88,13 +88,13 @@ ImGui requires descriptors for its font texture. Ensure your descriptor pool has
 ----
 // Create descriptor pool with enough capacity for ImGui
 vk::DescriptorPoolSize poolSizes[] = {
-    { vk::DescriptorType::eCombinedImageSampler, 1000 },
+    { vk::DescriptorType::eCombinedImageSampler, 50 },
     // Other descriptor types...
 };
 
 vk::DescriptorPoolCreateInfo poolInfo{};
 poolInfo.flags = vk::DescriptorPoolCreateFlagBits::eFreeDescriptorSet;
-poolInfo.maxSets = 1000;
+poolInfo.maxSets = 50;
 poolInfo.poolSizeCount = static_cast<uint32_t>(std::size(poolSizes));
 poolInfo.pPoolSizes = poolSizes;
 

en/Building_a_Simple_Engine/Lighting_Materials/02_lighting_models.adoc

@@ -60,7 +60,7 @@ One of the most widely used traditional lighting models, developed by Bui Tuong
 * *Disadvantages*: Not physically accurate, can look artificial under certain lighting conditions
 * *When to use*: For simple real-time applications where PBR is too expensive
 
-For more information on the Phong lighting model, see the link:https://en.wikipedia.org/wiki/Phong_reflection_model[Wikipedia article] or this link:https://www.cs.utah.edu/~shirley/books/fcg2/rt.pdf[computer graphics textbook].
+For more information on the Phong lighting model, see the link:https://en.wikipedia.org/wiki/Phong_reflection_model[Wikipedia article].
 
 ==== Blinn-Phong Model
 
@@ -149,7 +149,7 @@ Global Illumination (GI) simulates how light bounces between surfaces, creating
 * *Path Tracing*: Traces light paths through the scene
 * *Photon Mapping*: Stores light information in a spatial data structure
 
-For more information, see this link:https://developer.nvidia.com/gpugems/gpugems2/part-ii-shading-lighting-and-shadows/chapter-12-tricks-real-time-radiosity[GPU Gems chapter on radiosity].
+For more information, see this link:https://developer.download.nvidia.com/books/HTML/gpugems2/chapters/gpugems2_chapter12.html[GPU Gems chapter on radiosity].
 
 === Subsurface Scattering
 
@@ -161,7 +161,7 @@ For more information, see this link:https://developer.nvidia.com/gpugems/gpugems
 
 Ambient Occlusion (AO) approximates how much ambient light a surface point would receive, darkening corners and crevices.
 
-For more information, see this link:https://developer.nvidia.com/gpugems/gpugems/part-ii-lighting-and-shadows/chapter-17-ambient-occlusion[GPU Gems chapter on ambient occlusion].
+For more information, see this link:https://developer.download.nvidia.com/books/HTML/gpugems/gpugems_ch17.html[GPU Gems chapter on ambient occlusion].
 
 == Choosing the Right Lighting Model
 

en/Building_a_Simple_Engine/Lighting_Materials/05_vulkan_integration.adoc

@@ -144,288 +144,18 @@ void Renderer::recordCommandBuffer(vk::CommandBuffer commandBuffer, uint32_t ima
 }
 ----
 
-== Creating the PBR Shader
+== PBR Shader Reference
 
-Now that we've updated our renderer to support our PBR implementation, we need to create the PBR shader that implements the concepts we've discussed in this chapter. Rather than presenting this as a monolithic code dump, let's break down the shader creation into logical sections that explain both the technical implementation and the reasoning behind each component.
+This chapter reuses the exact PBR shader defined in the previous section to avoid duplication and drift. Please refer to link:04_lighting_implementation.adoc[Implementing the PBR Shader] for the full pbr.slang source and detailed explanations. Here we focus strictly on Vulkan integration: pipeline layout, descriptor bindings, push constants, and draw submission.
 
-=== Section 1: Shader Structure and Data Interface
-
-The first section establishes the communication interface between our CPU application and GPU shader, defining how data flows through the rendering pipeline.
-
-[source,cpp]
-----
-// Combined vertex and fragment shader for PBR rendering
-
-// Input from vertex buffer - Data sent per vertex from CPU
-struct VSInput {
-    float3 Position : POSITION;     // 3D position in model space
-    float3 Normal : NORMAL;         // Surface normal for lighting calculations
-    float2 UV : TEXCOORD0;          // Texture coordinates for material sampling
-    float4 Tangent : TANGENT;       // Tangent vector for normal mapping (w component = handedness)
-};
-
-// Output from vertex shader / Input to fragment shader - Interpolated data
-struct VSOutput {
-    float4 Position : SV_POSITION; // Required clip space position for rasterization
-    float3 WorldPos : POSITION;    // World space position for lighting calculations
-    float3 Normal : NORMAL;        // World space normal (interpolated)
-    float2 UV : TEXCOORD0;         // Texture coordinates (interpolated)
-    float4 Tangent : TANGENT;      // World space tangent (interpolated)
-};
-
-// Uniform buffer - Global data shared across all vertices/fragments
-struct UniformBufferObject {
-    float4x4 model;                     // Model-to-world transformation matrix
-    float4x4 view;                      // World-to-camera transformation matrix
-    float4x4 proj;                      // Camera-to-clip space projection matrix
-    float4 lightPositions[4];           // Light positions in world space
-    float4 lightColors[4];              // Light intensities and colors
-    float4 camPos;                      // Camera position for view-dependent effects
-    float exposure;                     // HDR exposure control
-    float gamma;                        // Gamma correction value (typically 2.2)
-    float prefilteredCubeMipLevels;     // IBL prefiltered environment map mip levels
-    float scaleIBLAmbient;              // IBL ambient contribution scale
-};
-
-// Push constants - Fast, small data updated frequently per material/object
-struct PushConstants {
-    float4 baseColorFactor;             // Base color tint/multiplier
-    float metallicFactor;               // Metallic property multiplier
-    float roughnessFactor;              // Surface roughness multiplier
-    int baseColorTextureSet;            // Texture binding index for base color (-1 = none)
-    int physicalDescriptorTextureSet;   // Texture binding for metallic/roughness
-    int normalTextureSet;               // Texture binding for normal maps
-    int occlusionTextureSet;            // Texture binding for ambient occlusion
-    int emissiveTextureSet;             // Texture binding for emissive maps
-    float alphaMask;                    // Alpha masking enable flag
-    float alphaMaskCutoff;              // Alpha cutoff threshold
-};
-
-// Mathematical constants
-static const float PI = 3.14159265359;
-
-// Resource bindings - Connect CPU resources to GPU shader registers
-[[vk::binding(0, 0)]] ConstantBuffer<UniformBufferObject> ubo;
-[[vk::binding(1, 0)]] Texture2D baseColorMap;
-[[vk::binding(1, 0)]] SamplerState baseColorSampler;
-[[vk::binding(2, 0)]] Texture2D metallicRoughnessMap;
-[[vk::binding(2, 0)]] SamplerState metallicRoughnessSampler;
-[[vk::binding(3, 0)]] Texture2D normalMap;
-[[vk::binding(3, 0)]] SamplerState normalSampler;
-[[vk::binding(4, 0)]] Texture2D occlusionMap;
-[[vk::binding(4, 0)]] SamplerState occlusionSampler;
-[[vk::binding(5, 0)]] Texture2D emissiveMap;
-[[vk::binding(5, 0)]] SamplerState emissiveSampler;
-
-[[vk::push_constant]] PushConstants material;
-----
-
-This interface design reflects modern GPU architecture principles where different types of data flow through different pathways based on their update frequency and size. Uniform buffers efficiently handle large, infrequently changing data like transformation matrices, while push constants provide ultra-fast updates for small, frequently changing material properties.
-
-=== Section 2: PBR Mathematical Foundation
-
-The second section implements the core mathematical functions that form the foundation of physically-based rendering, translating complex light-surface interactions into computationally efficient approximations.
-
-[source,cpp]
-----
-// Normal Distribution Function (D) - GGX/Trowbridge-Reitz Distribution
-// Describes the statistical distribution of microfacet orientations
-float DistributionGGX(float NdotH, float roughness) {
-    float a = roughness * roughness;        // Remapping for more perceptual linearity
-    float a2 = a * a;
-    float NdotH2 = NdotH * NdotH;
-
-    float nom = a2;                         // Numerator: concentration factor
-    float denom = (NdotH2 * (a2 - 1.0) + 1.0);
-    denom = PI * denom * denom;             // Normalization factor
-
-    return nom / denom;                     // Normalized distribution
-}
-
-// Geometry Function (G) - Smith's method with Schlick-GGX approximation
-// Models self-shadowing and masking between microfacets
-float GeometrySmith(float NdotV, float NdotL, float roughness) {
-    float r = roughness + 1.0;
-    float k = (r * r) / 8.0;               // Direct lighting remapping
-
-    // Geometry obstruction from view direction (masking)
-    float ggx1 = NdotV / (NdotV * (1.0 - k) + k);
-    // Geometry obstruction from light direction (shadowing)
-    float ggx2 = NdotL / (NdotL * (1.0 - k) + k);
-
-    return ggx1 * ggx2;                     // Combined masking-shadowing
-}
-
-// Fresnel Reflectance (F) - Schlick's approximation
-// Models how reflectance changes with viewing angle
-float3 FresnelSchlick(float cosTheta, float3 F0) {
-    return F0 + (1.0 - F0) * pow(1.0 - cosTheta, 5.0);
-}
-----
-
-These mathematical functions represent decades of computer graphics research distilled into efficient real-time approximations. The GGX distribution provides more realistic highlight falloff compared to older models, while the Smith geometry function ensures energy conservation at grazing angles. The Fresnel approximation captures the essential angle-dependent reflection behavior that makes materials look convincing under different viewing conditions.
-
-=== Section 3: Vertex and Fragment Shader Implementation
-
-The final section contains the actual shader entry points that execute for each vertex and pixel, implementing the complete PBR pipeline from geometry transformation through final color output.
-
-[source,cpp]
-----
-// Vertex shader entry point - Executes once per vertex
-[[shader("vertex")]]
-VSOutput VSMain(VSInput input)
-{
-    VSOutput output;
-
-    // Transform vertex position through the rendering pipeline
-    // Model -> World -> Camera -> Clip space transformation chain
-    float4 worldPos = mul(ubo.model, float4(input.Position, 1.0));
-    output.Position = mul(ubo.proj, mul(ubo.view, worldPos));
-
-    // Pass world position for fragment lighting calculations
-    // Fragment shader needs world space position to calculate light vectors
-    output.WorldPos = worldPos.xyz;
-
-    // Transform normal from model space to world space
-    // Use only rotation/scale part of model matrix (upper-left 3x3)
-    // Normalize to ensure unit length after transformation
-    output.Normal = normalize(mul((float3x3)ubo.model, input.Normal));
-
-    // Pass through texture coordinates unchanged
-    // UV coordinates are typically in [0,1] range and don't need transformation
-    output.UV = input.UV;
-
-    // Pass tangent vector for normal mapping
-    // Will be used in fragment shader to construct tangent-space basis
-    output.Tangent = input.Tangent;
-
-    return output;
-}
-
-// Fragment shader entry point - Executes once per pixel
-[[shader("fragment")]]
-float4 PSMain(VSOutput input) : SV_TARGET
-{
-    // === MATERIAL PROPERTY SAMPLING ===
-    // Sample base color texture and apply material color factor
-    float4 baseColor = baseColorMap.Sample(baseColorSampler, input.UV) * material.baseColorFactor;
-
-    // Sample metallic-roughness texture (metallic=B channel, roughness=G channel)
-    // glTF standard: metallic stored in blue, roughness in green
-    float2 metallicRoughness = metallicRoughnessMap.Sample(metallicRoughnessSampler, input.UV).bg;
-    float metallic = metallicRoughness.x * material.metallicFactor;
-    float roughness = metallicRoughness.y * material.roughnessFactor;
-
-    // Sample ambient occlusion (typically stored in red channel)
-    float ao = occlusionMap.Sample(occlusionSampler, input.UV).r;
-
-    // Sample emissive texture for self-illuminating materials
-    float3 emissive = emissiveMap.Sample(emissiveSampler, input.UV).rgb;
-
-    // === NORMAL CALCULATION ===
-    // Start with interpolated surface normal
-    float3 N = normalize(input.Normal);
-
-    // Apply normal mapping if texture is available
-    if (material.normalTextureSet >= 0) {
-        // Sample normal map and convert from [0,1] to [-1,1] range
-        float3 tangentNormal = normalMap.Sample(normalSampler, input.UV).xyz * 2.0 - 1.0;
-
-        // Construct tangent-space to world-space transformation matrix (TBN)
-        float3 T = normalize(input.Tangent.xyz);              // Tangent
-        float3 B = normalize(cross(N, T)) * input.Tangent.w;  // Bitangent (w = handedness)
-        float3x3 TBN = float3x3(T, B, N);                     // Tangent-Bitangent-Normal matrix
-
-        // Transform normal from tangent space to world space
-        N = normalize(mul(tangentNormal, TBN));
-    }
-
-    // === LIGHTING SETUP ===
-    // Calculate view direction (camera to fragment)
-    float3 V = normalize(ubo.camPos.xyz - input.WorldPos);
-
-    // Calculate reflection vector for environment mapping
-    float3 R = reflect(-V, N);
-
-    // === PBR MATERIAL SETUP ===
-    // Calculate F0 (reflectance at normal incidence)
-    // Non-metals: low reflectance (~0.04), Metals: colored reflectance from base color
-    float3 F0 = float3(0.04, 0.04, 0.04);  // Dielectric default
-    F0 = lerp(F0, baseColor.rgb, metallic); // Lerp to metallic behavior
-
-    // Initialize outgoing radiance accumulator
-    float3 Lo = float3(0.0, 0.0, 0.0);
-
-    // === DIRECT LIGHTING LOOP ===
-    // Calculate contribution from each light source
-    for (int i = 0; i < 4; i++) {
-        float3 lightPos = ubo.lightPositions[i].xyz;
-        float3 lightColor = ubo.lightColors[i].rgb;
-
-        // Calculate light direction and attenuation
-        float3 L = normalize(lightPos - input.WorldPos);      // Light direction
-        float distance = length(lightPos - input.WorldPos);   // Distance for falloff
-        float attenuation = 1.0 / (distance * distance);     // Inverse square falloff
-        float3 radiance = lightColor * attenuation;           // Attenuated light color
-
-        // Calculate half vector (between view and light directions)
-        float3 H = normalize(V + L);
-
-        // === BRDF EVALUATION ===
-        // Calculate all necessary dot products for BRDF terms
-        float NdotL = max(dot(N, L), 0.0);  // Lambertian falloff
-        float NdotV = max(dot(N, V), 0.0);  // View angle
-        float NdotH = max(dot(N, H), 0.0);  // Half vector for specular
-        float HdotV = max(dot(H, V), 0.0);  // For Fresnel calculation
-
-        // Evaluate Cook-Torrance BRDF components
-        float D = DistributionGGX(NdotH, roughness);    // Normal distribution
-        float G = GeometrySmith(NdotV, NdotL, roughness); // Geometry function
-        float3 F = FresnelSchlick(HdotV, F0);           // Fresnel reflectance
-
-        // Calculate specular BRDF
-        float3 numerator = D * G * F;
-        float denominator = 4.0 * NdotV * NdotL + 0.0001; // Prevent division by zero
-        float3 specular = numerator / denominator;
-
-        // === ENERGY CONSERVATION ===
-        // Fresnel term represents specular reflection ratio
-        float3 kS = F;                          // Specular contribution
-        float3 kD = float3(1.0, 1.0, 1.0) - kS; // Diffuse contribution (energy conservation)
-        kD *= 1.0 - metallic;                   // Metals have no diffuse reflection
-
-        // === RADIANCE ACCUMULATION ===
-        // Combine diffuse (Lambertian) and specular (Cook-Torrance) terms
-        // Multiply by incident radiance and cosine foreshortening
-        Lo += (kD * baseColor.rgb / PI + specular) * radiance * NdotL;
-    }
-
-    // === AMBIENT AND EMISSIVE ===
-    // Add simple ambient lighting (should be replaced with IBL in production)
-    float3 ambient = float3(0.03, 0.03, 0.03) * baseColor.rgb * ao;
-
-    // Combine all lighting contributions
-    float3 color = ambient + Lo + emissive;
-
-    // === HDR TONE MAPPING AND GAMMA CORRECTION ===
-    // Apply Reinhard tone mapping to compress HDR values to [0,1] range
-    color = color / (color + float3(1.0, 1.0, 1.0));
-
-    // Apply gamma correction for sRGB display (inverse gamma)
-    color = pow(color, float3(1.0 / ubo.gamma, 1.0 / ubo.gamma, 1.0 / ubo.gamma));
-
-    // Output final color with original alpha
-    return float4(color, baseColor.a);
-}
-----
 
 == Compiling the Shader
 
 After creating the shader file, we need to compile it using slangc. This is typically done as part of the build process, but we can also do it manually:
 
 [source,bash]
 ----
-slangc shaders/pbr.slang -target spirv -profile spirv_1_4 -emit-spirv-directly -o shaders/pbr.spv
+slangc shaders/pbr.slang -target spirv -profile spirv_1_4 -o shaders/pbr.spv
 ----
 
 == Testing the Implementation with glTF Models