Added Game dev Topics and Learning Paths. Which Covers advance Fandamentals.

Author: VR-Rathod

pages/Introduction.md

@@ -3,7 +3,6 @@
 -
 -
 - ## Programming Languages
-  collapsed:: true
 	-
 	- [[Python]] :- A beginner-friendly language known for its readability and extensive libraries.
 	-
@@ -84,7 +83,6 @@
 	- [[Zig]]: A systems programming language that aims to replace C with a focus on simplicity, performance, and safety.
 -
 - ## Databases
-  collapsed:: true
 	- [[MySQL]] : One of the most widely used open-source relational database management systems (RDBMS), especially in web applications.
 	-
 	- [[PostgreSQL]] : An advanced, open-source relational database that emphasizes extensibility, SQL compliance, and performance.
@@ -101,7 +99,6 @@
 	- [[GraphQL]] - **GraphQL** is a query language for APIs and a runtime for executing those queries with your existing data. It was developed by **Facebook** and offers a more flexible and efficient alternative to REST APIs.
 -
 - ## CMS (Content Management Systems)
-  collapsed:: true
 	- [[WordPress]] :- A widely used, open-source CMS known for its ease of use, vast theme/plugin ecosystem, and flexibility for building various websites from blogs to e-commerce stores.
 	-
 	- [[Joomla]] :- A flexible and powerful CMS that allows for the creation of complex websites with various extensions and templates.
@@ -126,7 +123,6 @@
 	- [[Shopify]] - it is a **hosted e-commerce platform** that includes **some CMS-like features**.
 -
 - ## Operating Systems & Kernels
-  collapsed:: true
 	- ## Linux
 		- [[Kali Linux]] :- A Debian-based distribution designed for penetration testing and cybersecurity professionals, featuring numerous security tools.
 		-
@@ -147,16 +143,13 @@
 	- ## Windows
 -
 - ## Frameworks, Libraries Common Elements
-  collapsed:: true
 	- You Can find particular lib & Frameworks  in that programing page
 	- [[Api]] - You can find specific APIs and related documentation on the respective programming language or framework page.
 -
 - ## Data Structures , Algorithms & OOP
-  collapsed:: true
 	- [[DSA , Algo & System Design]]: The study of organizing and manipulating data efficiently, focusing on fundamental structures like arrays, linked lists, stacks, queues, trees, and graphs, as well as algorithms for searching, sorting, and optimization.
 -
 - ## DevOps & CI/CD
-  collapsed:: true
 	- ## DevOps Concepts
 		- [[Collaboration & Communication]]: Emphasizes enhanced communication between development and operations teams to improve the software development lifecycle (SDLC).
 		-
@@ -259,6 +252,13 @@
 - ## Cybersecurity
 	- [[Cybersecurity]] - This page contains DevOps Concepts
 -
+- ## Game Development & Graphics
+	- For game engines, 3D tools, design software, and all related applications, see [[Software]].
+	-
+	- ### Graphics Programming & Rendering
+		- [[PathTracer Learning]] :- Deep-dive learning series for building a GPU path tracer from scratch — covers math foundations, CPU ray tracing, Vulkan ray tracing, and Godot rendering internals.
+	-
+-
 - ## Software Information
   id:: 6722a764-cba3-430a-805a-3a2746eb9e3f
 	- [[Software]] - This page showcases all types of software, categorized by their functionality and purpose.

pages/PathTracer Learning - BLAS and TLAS.md

@@ -0,0 +1,80 @@
+tags:: vulkan, acceleration-structure, bvh, blas, tlas
+title:: PathTracer Learning - BLAS and TLAS
+
+- # BLAS and TLAS — Acceleration Structures
+	- Hardware-accelerated BVH for Vulkan ray tracing.
+	- Parent: [[PathTracer Learning]]
+- ---
+- ## Conceptual Overview
+	- Two-level hierarchy
+		- BLAS (Bottom-Level AS): geometry BVH — triangles or AABBs
+		- TLAS (Top-Level AS): instance BVH — references to BLASes with transforms
+	- Why two levels?
+		- Allows instancing: one BLAS, many TLAS instances (e.g., 1000 trees from 1 mesh)
+		- TLAS can be rebuilt cheaply (just transforms) while BLASes stay static
+		- Hardware traversal handles both levels transparently
+	- Analogy to software BVH
+		- BLAS ≈ per-mesh BVH (built offline or at load time)
+		- TLAS ≈ scene BVH (rebuilt every frame)
+- ---
+- ## BLAS Construction
+	- Input: vertex buffer + index buffer (triangle list)
+	- `VkAccelerationStructureGeometryKHR`
+		- ```
+		  geometry.geometryType = VK_GEOMETRY_TYPE_TRIANGLES_KHR;
+		  geometry.geometry.triangles.vertexFormat = VK_FORMAT_R32G32B32_SFLOAT;
+		  geometry.geometry.triangles.vertexData.deviceAddress = vertexBufferAddress;
+		  geometry.geometry.triangles.vertexStride = sizeof(Vertex);
+		  geometry.geometry.triangles.maxVertex = vertexCount - 1;
+		  geometry.geometry.triangles.indexType = VK_INDEX_TYPE_UINT32;
+		  geometry.geometry.triangles.indexData.deviceAddress = indexBufferAddress;
+		  ```
+	- Build flags
+		- `VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR` — optimize for traversal (static geometry)
+		- `VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR` — optimize for build speed (dynamic geometry)
+		- `VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR` — allow incremental updates (skinned meshes)
+		- `VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR` — compact after build (saves memory)
+	- Memory requirements
+		- Query with `vkGetAccelerationStructureBuildSizesKHR`
+		- Returns: `accelerationStructureSize`, `buildScratchSize`, `updateScratchSize`
+		- Scratch buffer is temporary — can be reused after build completes
+	- Compaction (important for memory)
+		- Build with `ALLOW_COMPACTION` flag
+		- Query compacted size with `VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR`
+		- Copy to smaller buffer with `vkCmdCopyAccelerationStructureKHR`
+		- Typical compaction ratio: 50-70% size reduction
+- ---
+- ## TLAS Construction
+	- Input: array of `VkAccelerationStructureInstanceKHR`
+	- Instance struct fields
+		- `transform` — 3×4 row-major affine transform matrix
+		- `instanceCustomIndex` — 24-bit value accessible as `gl_InstanceCustomIndexEXT` in shaders
+		- `mask` — 8-bit visibility mask (AND with ray mask in `traceRayEXT`)
+		- `instanceShaderBindingTableRecordOffset` — SBT hit group offset for this instance
+		- `flags` — `VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR` etc.
+		- `accelerationStructureReference` — device address of the BLAS
+	- TLAS is rebuilt every frame
+		- Upload new instance buffer with updated transforms
+		- `vkCmdBuildAccelerationStructuresKHR` with `VK_BUILD_ACCELERATION_STRUCTURE_MODE_BUILD_KHR`
+		- Or use `MODE_UPDATE_KHR` for incremental update (faster but lower quality BVH)
+- ---
+- ## Memory Layout and Device Addresses
+	- [[PathTracer Learning - Concept - Device Address Bit]]
+	- All AS input buffers need `VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT`
+	- AS buffer needs `VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR`
+	- Scratch buffer needs `VK_BUFFER_USAGE_STORAGE_BIT | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT`
+- ---
+- ## Traversal in Shaders
+	- `traceRayEXT(tlas, rayFlags, cullMask, sbtOffset, sbtStride, missIndex, origin, tMin, dir, tMax, payloadLocation)`
+	- Ray flags
+		- `gl_RayFlagsOpaqueEXT` — skip any-hit shaders (faster)
+		- `gl_RayFlagsTerminateOnFirstHitEXT` — stop at first hit (shadow rays)
+		- `gl_RayFlagsSkipClosestHitShaderEXT` — don't call closest-hit (occlusion only)
+	- Built-in variables in hit shaders
+		- `gl_HitTEXT` — distance to hit
+		- `gl_PrimitiveID` — triangle index within the BLAS geometry
+		- `gl_InstanceID` — instance index in the TLAS
+		- `gl_InstanceCustomIndexEXT` — custom index from instance struct
+		- `gl_WorldRayOriginEXT`, `gl_WorldRayDirectionEXT` — ray in world space
+		- `gl_ObjectRayOriginEXT`, `gl_ObjectRayDirectionEXT` — ray in object space
+		- `gl_ObjectToWorldEXT`, `gl_WorldToObjectEXT` — transform matrices

pages/PathTracer Learning - Books and Tutorials.md

@@ -0,0 +1,100 @@
+tags:: reference, books, tutorials, resources
+title:: PathTracer Learning - Books and Tutorials
+
+- # Books and Tutorials
+	- Parent: [[PathTracer Learning]]
+- ---
+- ## Essential Books
+	- "Ray Tracing in One Weekend" series — Peter Shirley (free online)
+		- Book 1: Ray Tracing in One Weekend — basic ray tracer
+		- Book 2: Ray Tracing: The Next Week — BVH, textures, motion blur
+		- Book 3: Ray Tracing: The Rest of Your Life — Monte Carlo, importance sampling
+		- URL: https://raytracing.github.io/
+		- Best starting point — builds intuition before GPU
+	- "Physically Based Rendering: From Theory to Implementation" (PBRT)
+		- Pharr, Jakob, Humphreys — the definitive reference
+		- 4th edition free online: https://pbr-book.org/
+		- Covers everything: BVH, BRDFs, Monte Carlo, spectral rendering, volumes
+		- Very dense — use as reference, not cover-to-cover
+		- Chapter 9 (Reflection Models) and Chapter 13 (Monte Carlo) are essential
+	- "Real-Time Rendering" — Akenine-Möller et al.
+		- Chapter 26: Real-Time Ray Tracing
+		- Good overview of hardware RT and denoising
+	- "Fundamentals of Computer Graphics" — Shirley & Marschner
+		- Good intro to the math before diving into PBRT
+- ---
+- ## Vulkan Ray Tracing
+	- Vulkan Ray Tracing Tutorial — NVIDIA (nvpro-samples)
+		- https://github.com/nvpro-samples/vk_raytracing_tutorial_KHR
+		- Step-by-step from basic triangle to full path tracer
+		- Uses C++ + GLSL, very practical
+	- Vulkan Specification — Ray Tracing chapters
+		- https://registry.khronos.org/vulkan/specs/1.3-extensions/html/
+		- Chapters on VK_KHR_ray_tracing_pipeline, VK_KHR_acceleration_structure
+	- "Ray Tracing Gems" (free PDF)
+		- https://www.realtimerendering.com/raytracinggems/
+		- Collection of practical techniques from industry experts
+		- Chapter 3: Introduction to DirectX Raytracing (concepts apply to Vulkan)
+		- Chapter 20: Texture Level of Detail Strategies for Real-Time Ray Tracing
+	- "Ray Tracing Gems II" (free PDF)
+		- https://www.realtimerendering.com/raytracinggems/rtg2/
+		- More advanced topics: ReSTIR, denoising, production techniques
+		- Chapter 23: ReSTIR GI
+- ---
+- ## Key Papers
+	- Kajiya 1986 — "The Rendering Equation"
+		- Foundation of physically-based rendering
+	- Möller & Trumbore 1997 — "Fast, Minimum Storage Ray/Triangle Intersection"
+		- The standard ray-triangle intersection algorithm
+	- Walter et al. 2007 — "Microfacet Models for Refraction through Rough Surfaces"
+		- GGX BRDF derivation
+	- Heitz 2014 — "Understanding the Masking-Shadowing Function in Microfacet-Based BRDFs"
+		- Definitive reference for Smith G term
+	- Heitz 2018 — "Sampling the GGX Distribution of Visible Normals"
+		- VNDF sampling — better importance sampling for GGX
+	- Burley 2012 — "Physically-Based Shading at Disney"
+		- Disney Principled BRDF — the basis for most PBR workflows
+	- Veach & Guibas 1995 — "Optimally Combining Sampling Techniques for Monte Carlo Rendering"
+		- MIS (Multiple Importance Sampling) — essential for path tracing
+	- Bitterli et al. 2020 — "Spatiotemporal reservoir resampling for real-time ray tracing with dynamic direct lighting"
+		- ReSTIR DI paper
+	- Ouyang et al. 2021 — "ReSTIR GI: Path Resampling for Real-Time Path Tracing"
+		- ReSTIR GI paper
+	- Schied et al. 2017 — "Spatiotemporal Variance-Guided Filtering"
+		- SVGF denoiser
+	- Müller et al. 2017 — "Practical Path Guiding for Efficient Light-Transport Simulation"
+		- SD-Tree path guiding
+	- Woop et al. 2013 — "Watertight Ray/Triangle Intersection"
+		- Prevents light leaking through mesh cracks
+- ---
+- ## Video Courses
+	- "Computer Graphics" — TU Wien (YouTube, free)
+		- Excellent lectures on rendering theory
+		- Covers path tracing, BRDFs, Monte Carlo in depth
+		- https://www.youtube.com/playlist?list=PLujxSBD-JXgnGmsn7gEyN28P1DnRZG7qi
+	- "Advances in Real-Time Rendering" — SIGGRAPH courses
+		- Annual course with cutting-edge techniques
+		- https://advances.realtimerendering.com/
+	- "Introduction to Computer Graphics" — Cem Yuksel (YouTube)
+		- Clear explanations of rendering fundamentals
+	- "GAMES101" — Lingqi Yan (YouTube, Chinese with subtitles)
+		- Comprehensive graphics course, excellent path tracing coverage
+- ---
+- ## Online Resources
+	- Shadertoy — https://www.shadertoy.com/
+		- Many path tracer implementations to study
+		- Search "path tracer" for examples
+	- Inigo Quilez's articles — https://iquilezles.org/articles/
+		- Excellent math and rendering articles
+	- Physically Based Rendering blog — https://www.pbr-book.org/blog
+	- JCGT (Journal of Computer Graphics Techniques) — https://jcgt.org/
+		- Free peer-reviewed graphics papers
+- ---
+- ## Godot Specific
+	- Godot source code — `servers/rendering/renderer_rd/`
+		- Best documentation is the code itself
+	- NVPathtracer PR/fork — study the actual implementation
+	- Godot rendering documentation
+		- https://docs.godotengine.org/en/stable/contributing/development/core_and_modules/custom_rendering_server.html
+	- Godot RenderingDevice API docs
+		- https://docs.godotengine.org/en/stable/classes/class_renderingdevice.html

pages/PathTracer Learning - Chat Analysis.md

@@ -0,0 +1,71 @@
+tags:: reference, godot, nvpathtracer, chat-notes
+title:: PathTracer Learning - Chat Analysis
+
+- # Chat Analysis — Godot NVPathtracer Discussion
+	- Notes extracted from the actual Godot Contributors NVPathtracer chat discussion.
+	- Parent: [[PathTracer Learning]]
+- ---
+- ## Key Contributors and Context
+	- This was a technical discussion among Godot engine contributors
+	- Topic: integrating NVIDIA's path tracer (NVPathtracer) into Godot 4
+	- Challenges discussed: engine integration, performance, API design
+- ---
+- ## Technical Insights from the Chat
+	- TLAS rebuild strategy
+		- Contributors debated full rebuild vs incremental update every frame
+		- Full rebuild: simpler, always correct BVH quality
+		- Incremental update: faster but BVH quality degrades over time
+		- Decision: full rebuild for correctness, optimize later
+	- Material system design
+		- How to pass PBR material data (albedo, roughness, metallic, textures) to RT shaders
+		- Solution: per-instance data buffer indexed by `gl_InstanceCustomIndexEXT`
+		- Each instance stores: vertex buffer address, index buffer address, material index
+		- Material buffer stores: albedo, roughness, metallic, texture indices
+	- Denoising approach
+		- Initial: simple temporal accumulation (free, no extra cost)
+		- Target: DLSS 3.5 Ray Reconstruction for final quality
+		- Intermediate: OIDN for platforms without DLSS
+	- Skinned mesh handling
+		- Skinned meshes need BLAS rebuild every frame
+		- Use `ALLOW_UPDATE` flag for incremental BLAS update
+		- Separate "dynamic" and "static" BLAS pools
+	- Async compute for BLAS builds
+		- [[PathTracer Learning - Concept - Async Compute]]
+		- BLAS builds can run on compute queue while previous frame renders
+		- Reduces per-frame RT budget impact of BLAS builds
+- ---
+- ## Architecture Decisions
+	- Engine fork vs GDExtension
+		- NVPathtracer is an engine fork — modifies core rendering code
+		- GDExtension cannot access `RenderingDevice` internals
+		- Future goal: expose RT hooks via GDExtension API
+	- Integration point
+		- Override `_render_scene()` in `RendererSceneRenderRD`
+		- Skip rasterization entirely for path-traced frames
+		- Keep shadow maps for hybrid rendering (raster + RT)
+	- Buffer management
+		- Reuse Godot's existing depth/normal/motion buffers
+		- Add new accumulation buffer and albedo buffer for denoiser
+		- Use `RenderSceneBuffersRD` to manage lifetime
+- ---
+- ## Open Questions from the Chat
+	- How to handle transparent objects (glass, water)?
+		- RT handles refraction naturally — just trace through
+		- Need to disable alpha blending for RT objects
+	- LOD (Level of Detail) with RT?
+		- RT doesn't use rasterization LOD system
+		- Need separate LOD selection for BLAS geometry
+	- Emissive materials as light sources?
+		- NEE needs to know which instances are emissive
+		- Build a light list from emissive instances for NEE sampling
+- ---
+- ## Lessons Learned
+	- Start simple: temporal accumulation before DLSS
+	- Get correctness first: full TLAS rebuild before optimization
+	- Test with Cornell box: known ground truth for validation
+	- Profile early: GPU timing for each pass (BLAS, TLAS, RT, denoise)
+- ---
+- ## Related
+	- [[PathTracer Learning - Phase 4 - Godot Internals]]
+	- [[PathTracer Learning - BLAS and TLAS]]
+	- [[PathTracer Learning - Vulkan RT Pipeline]]

pages/PathTracer Learning - Concept - AABB.md

@@ -0,0 +1,58 @@
+tags:: concept, bvh, acceleration-structure, geometry
+title:: PathTracer Learning - Concept - AABB
+
+- # Concept: AABB (Axis-Aligned Bounding Box)
+	- Parent: [[PathTracer Learning - Phase 2 - CPU Ray Tracing]]
+- ---
+- ## Definition
+	- A box whose faces are aligned with the coordinate axes
+	- Defined by two points: `min = (x_min, y_min, z_min)` and `max = (x_max, y_max, z_max)`
+	- Every point `P` inside satisfies: `min.x ≤ P.x ≤ max.x` (and same for y, z)
+	- "Axis-aligned" means no rotation — simplifies intersection math enormously
+- ---
+- ## Ray-AABB Intersection (Slab Method)
+	- Treat the AABB as the intersection of 3 pairs of parallel planes (slabs)
+	- For each axis, compute entry and exit `t` values
+		- `t_x_min = (min.x - ray.origin.x) / ray.direction.x`
+		- `t_x_max = (max.x - ray.origin.x) / ray.direction.x`
+		- If `ray.direction.x < 0`, swap min and max
+	- Combine all 3 axes
+		- `t_enter = max(t_x_min, t_y_min, t_z_min)` — ray enters the box
+		- `t_exit  = min(t_x_max, t_y_max, t_z_max)` — ray exits the box
+	- Hit condition: `t_enter <= t_exit && t_exit > t_min`
+	- Implementation
+		- ```glsl
+		  bool intersectAABB(Ray ray, vec3 boxMin, vec3 boxMax, out float tNear) {
+		      vec3 invDir = 1.0 / ray.direction;
+		      vec3 t0 = (boxMin - ray.origin) * invDir;
+		      vec3 t1 = (boxMax - ray.origin) * invDir;
+		      vec3 tMin = min(t0, t1);
+		      vec3 tMax = max(t0, t1);
+		      float tEnter = max(max(tMin.x, tMin.y), tMin.z);
+		      float tExit  = min(min(tMax.x, tMax.y), tMax.z);
+		      tNear = tEnter;
+		      return tEnter <= tExit && tExit > 0.0;
+		  }
+		  ```
+	- Note: `invDir = 1.0 / ray.direction` precomputed for efficiency
+	- Handle `direction = 0` case: `invDir = ±infinity`, which works correctly with IEEE 754
+- ---
+- ## AABB Construction
+	- From a set of points: `min = componentwise_min(all_points)`, `max = componentwise_max(all_points)`
+	- From a triangle: `min = min(v0, v1, v2)`, `max = max(v0, v1, v2)`
+	- Merging two AABBs: `merged.min = min(a.min, b.min)`, `merged.max = max(a.max, b.max)`
+- ---
+- ## Surface Area
+	- `SA = 2 * (dx*dy + dy*dz + dz*dx)` where `dx = max.x - min.x` etc.
+	- Used in SAH (Surface Area Heuristic) for BVH construction
+	- Intuition: larger surface area → more likely to be hit by a random ray
+- ---
+- ## Why AABB and Not OBB?
+	- OBB (Oriented Bounding Box) fits tighter but intersection is much more expensive
+	- AABB intersection: ~6 divisions, ~6 comparisons
+	- OBB intersection: requires transforming ray to box space (matrix multiply)
+	- BVH with AABBs is fast enough in practice — hardware RT uses AABBs
+- ---
+- ## Related
+	- [[PathTracer Learning - Concept - BVH Construction]]
+	- [[PathTracer Learning - Concept - BVH Traversal]]