More ddoc in dagon.render

Author: gecko0307

src/dagon/render/deferred/gbuffer.d

@@ -25,6 +25,19 @@ ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 DEALINGS IN THE SOFTWARE.
 */
 
+/**
+ * G-buffer abstraction for deferred rendering.
+ *
+ * Description:
+ * This module provides a lightweight wrapper around OpenGL framebuffer and
+ * texture attachments used for deferred shading. The GBuffer class owns
+ * render targets for color, depth, normal, material (PBR), emission, velocity,
+ * and radiance output.
+ *
+ * Copyright: Timur Gafarov 2019-2026
+ * License: $(LINK2 https://boost.org/LICENSE_1_0.txt, Boost License 1.0).
+ * Authors: Timur Gafarov
+ */
 module dagon.render.deferred.gbuffer;
 
 import std.stdio;
@@ -37,20 +50,53 @@ import dagon.core.bindings;
 import dagon.core.logger;
 import dagon.render.framebuffer;
 
+/**
+ * Manages the G-buffer attachments.
+ *
+ * The G-Buffer (Geometry buffer) is a set of fragment attribute buffers
+ * used to store screen-space geometry data in a deferred renderer.
+ */
 class GBuffer: Owner
 {
+    /// Current framebuffer width.
     uint width;
+
+    /// Current framebuffer height.
     uint height;
 
+    /// OpenGL framebuffer object handle.
     GLuint framebuffer;
+
+    /// Color render target.
     GLuint colorTexture = 0;
+
+    /// Depth-stencil render target.
     GLuint depthTexture = 0;
+
+    /// Eye-space normal render target.
     GLuint normalTexture = 0;
+
+    /// Roughness-Metallic render target.
     GLuint pbrTexture = 0;
+
+    /// Emission render target.
     GLuint emissionTexture = 0;
+
+    /// Screen-space velocity render target.
     GLuint velocityTexture = 0;
+
+    /// Radiance framebuffer that is also attached to this G-buffer.
     Framebuffer radiance;
 
+    /**
+     * Creates a new GBuffer for the given size and radiance target.
+     *
+     * Params:
+     *   w = Width of the G-buffer.
+     *   h = Height of the G-buffer.
+     *   radiance = Framebuffer used for radiance output.
+     *   owner = Owner object.
+     */
     this(uint w, uint h, Framebuffer radiance, Owner owner)
     {
         super(owner);
@@ -61,6 +107,12 @@ class GBuffer: Owner
         createFramebuffer();
     }
 
+    /**
+     * Initializes and configures the framebuffer and its texture attachments.
+     *
+     * Recreates the G-buffer textures and rebinds them to a new
+     * framebuffer object. It also validates framebuffer completeness.
+     */
     void createFramebuffer()
     {
         releaseFramebuffer();
@@ -155,6 +207,7 @@ class GBuffer: Owner
         glBindFramebuffer(GL_FRAMEBUFFER, 0);
     }
 
+    /// Releases the framebuffer and texture resources owned by this GBuffer.
     void releaseFramebuffer()
     {
         if (glIsFramebuffer(framebuffer))
@@ -179,21 +232,25 @@ class GBuffer: Owner
             glDeleteTextures(1, &velocityTexture);
     }
 
+    /// Destructor that ensures OpenGL resources are cleaned up.
     ~this()
     {
         releaseFramebuffer();
     }
 
+    /// Binds the G-buffer for drawing.
     void bind()
     {
         glBindFramebuffer(GL_DRAW_FRAMEBUFFER, framebuffer);
     }
 
+    /// Unbinds any draw framebuffer and returns to the default framebuffer.
     void unbind()
     {
         glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
     }
 
+    /// Clears all G-buffer attachments.
     void clear()
     {
         glBindFramebuffer(GL_DRAW_FRAMEBUFFER, framebuffer);
@@ -214,6 +271,7 @@ class GBuffer: Owner
         glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
     }
 
+    /// Resizes the G-buffer and recreates the framebuffer attachments.
     void resize(uint w, uint h)
     {
         width = w;

src/dagon/render/deferred/package.d

@@ -25,6 +25,13 @@ ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 DEALINGS IN THE SOFTWARE.
 */
 
+/**
+ * Deferred rendering package.
+ *
+ * This module exposes the deferred renderer, including G-buffer
+ * and all the render passes used. It serves as the entry point for
+ * configuring the renderer and connecting scene data to the pipeline.
+ */
 module dagon.render.deferred;
 
 import dlib.core.memory;
@@ -47,6 +54,13 @@ public import dagon.render.deferred.gbuffer;
 import dagon.render.postproc.filterpass;
 import dagon.render.postproc.shaders.denoise;
 
+/**
+ * Deferred renderer implementation.
+ *
+ * The DeferredRenderer manages the shading pipeline, including
+ * shadow pre-pass, geometry pre-pass, IBL, lighting, occlusion, etc.
+ * It also owns the G-buffer and intermediate render targets.
+ */
 class DeferredRenderer: Renderer
 {
     Texture brdf;
@@ -82,6 +96,7 @@ class DeferredRenderer: Renderer
     float ssaoDenoise = 1.0f;
     bool ssaoDenoiseDepthAware = true;
 
+    /// Enables or disables screen-space ambient occlusion.
     void ssaoEnabled(bool mode) @property
     {
         _ssaoEnabled = mode;
@@ -99,23 +114,34 @@ class DeferredRenderer: Renderer
         }
     }
 
+    /// Returns screen-space ambient occlusion state.
     bool ssaoEnabled() @property
     {
         return _ssaoEnabled;
     }
 
+    /// Adjusts the resolution scale of the SSAO buffers.
     void occlusionBufferDetail(float value) @property
     {
         _occlusionBufferDetail = value;
         occlusionView.resize(cast(uint)(view.width * _occlusionBufferDetail), cast(uint)(view.height * _occlusionBufferDetail));
         occlusionNoisyBuffer.resize(occlusionView.width, occlusionView.height);
         occlusionBuffer.resize(occlusionView.width, occlusionView.height);
     }
+
+    /// Returns the resolution scale of the SSAO buffers.
     float occlusionBufferDetail() @property
     {
         return _occlusionBufferDetail;
     }
 
+    /**
+     * Creates the deferred renderer and initializes all render passes.
+     *
+     * Params:
+     *   application = The Application instance.
+     *   owner = Owner object.
+     */
     this(Application application, Owner owner)
     {
         super(application, owner);
@@ -188,6 +214,7 @@ class DeferredRenderer: Renderer
         passParticles.gbuffer = gbuffer;
     }
 
+    /// Loads the default BRDF lookup texture from a stream.
     void loadDefaultBRDF(InputStream istrm)
     {
         if (brdf)
@@ -209,6 +236,7 @@ class DeferredRenderer: Renderer
         }
     }
 
+    /// Assigns scene reference to all the render passes.
     override void scene(Scene s)
     {
         passShadow.group = s.world.spatial;
@@ -227,6 +255,7 @@ class DeferredRenderer: Renderer
         pipeline.environment = s.environment;
     }
 
+    /// Updates renderer state each frame.
     override void update(Time t)
     {
         passShadow.camera = activeCamera;
@@ -240,6 +269,7 @@ class DeferredRenderer: Renderer
         super.update(t);
     }
 
+    /// Resizes the renderer viewport and all associated buffers.
     override void setViewport(uint x, uint y, uint w, uint h)
     {
         super.setViewport(x, y, w, h);

src/dagon/render/stereorenderer.d

@@ -46,32 +46,70 @@ import dagon.resource.scene;
 class StereoRenderer: Renderer
 {
     alias headView = view;
+    
+    /// Left eye render view.
     RenderView viewLeft;
+    
+    /// Right eye render view.
     RenderView viewRight;
 
+    /// Left eye output framebuffer.
     Framebuffer outputBufferLeft;
+    
+    /// Right eye output framebuffer.
     Framebuffer outputBufferRight;
 
+    /**
+     * Sets the left eye active camera for rendering.
+     *
+     * Params:
+     *   camera = The camera to use.
+     */
     void activeCameraLeft(Camera camera)
     {
         viewLeft.camera = camera;
     }
 
+    /**
+     * Returns the currently active left eye camera.
+     *
+     * Returns:
+     *   The active left eye camera.
+     */
     Camera activeCameraLeft()
     {
         return viewLeft.camera;
     }
 
+    /**
+     * Sets the right eye active camera for rendering.
+     *
+     * Params:
+     *   camera = The camera to use.
+     */
     void activeCameraRight(Camera camera)
     {
         viewRight.camera = camera;
     }
 
+    /**
+     * Returns the currently active right eye camera.
+     *
+     * Returns:
+     *   The active right eye camera.
+     */
     Camera activeCameraRight()
     {
         return viewRight.camera;
     }
-    
+
+    /**
+     * Constructs a stereo renderer with the given application and owner.
+     *
+     * Params:
+     *   application = Application object.
+     *   owner       = Owner object.
+     */
     this(Application application, Owner owner)
     {
         super(application, owner);