Updated documentation for OpenGL backend interfaces

Author: TheMostDiligent

Graphics/GraphicsEngineOpenGL/interface/EngineFactoryOpenGL.h

@@ -67,18 +67,42 @@ static DILIGENT_CONSTEXPR INTERFACE_ID IID_EngineFactoryOpenGL =
 
 // clang-format off
 
+/// Engine factory for OpenGL rendering backend.
 DILIGENT_BEGIN_INTERFACE(IEngineFactoryOpenGL, IEngineFactory)
 {
+    /// Creates a render device and swap chain for OpenGL-based engine implementation.
+
+    /// \param [in]  EngineCI           - Engine creation info, see EngineGLCreateInfo.
+    /// \param [out] ppDevice           - Address of the memory location where pointer to
+    ///                                   the created device will be written.
+    /// \param [out] ppImmediateContext - Address of the memory location where pointer to
+    ///                                   the immediate device context will be written.
+    /// \param [in]  SCDesc             - Swap chain description.
+    /// \param [out] ppSwapChain        - Address of the memory location where pointer to
+    ///                                   the created swap chain will be written.
     VIRTUAL void METHOD(CreateDeviceAndSwapChainGL)(THIS_
                                                     const EngineGLCreateInfo REF EngineCI,
                                                     IRenderDevice**              ppDevice,
                                                     IDeviceContext**             ppImmediateContext,
                                                     const SwapChainDesc REF      SCDesc,
                                                     ISwapChain**                 ppSwapChain) PURE;
 
+    /// Creates a HLSL2GLSL converter.
+
+    /// \param [out] ppConverter - Address of the memory location where pointer to
+    ///                            the created HLSL2GLSL converter will be written.
     VIRTUAL void METHOD(CreateHLSL2GLSLConverter)(THIS_
                                                   IHLSL2GLSLConverter** ppConverter) PURE;
 
+    /// Attaches to the active GL context in the thread.
+
+    /// \param [in]  EngineCI           - Engine creation info, see EngineGLCreateInfo.
+    /// \param [out] ppDevice           - Address of the memory location where pointer to
+    /// 								  the created device will be written.
+    /// \param [out] ppImmediateContext - Address of the memory location where pointer to
+    /// 								  the immediate device context will be written.
+    /// 
+    /// \note The application is responsible for presenting the main frame buffer.
     VIRTUAL void METHOD(AttachToActiveGLContext)(THIS_
                                                  const EngineGLCreateInfo REF EngineCI,
                                                  IRenderDevice**              ppDevice,

Graphics/GraphicsEngineOpenGL/interface/PipelineStateGL.h

@@ -1,5 +1,5 @@
 /*
- *  Copyright 2019-2023 Diligent Graphics LLC
+ *  Copyright 2019-2025 Diligent Graphics LLC
  *  Copyright 2015-2019 Egor Yusov
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
@@ -55,11 +55,11 @@ DILIGENT_BEGIN_INTERFACE(IPipelineStateGL, IPipelineState)
     /// \param [in] Stage - Shader stage.
     /// \return OpenGL program handle for the specified shader stage.
     ///
-    /// \remarks    If device supports separable programs, the function
-    ///             returns the handle of the program for the specified
-    ///             shader stage. Otherwise, the function returns the handle
-    ///             of the program that contains all shaders, if Stage is
-    ///             one of the active shader stages, or zero otherwise.
+    /// If device supports separable programs, the function
+    /// returns the handle of the program for the specified
+    /// shader stage. Otherwise, the function returns the handle
+    /// of the program that contains all shaders, if Stage is
+    /// one of the active shader stages, or zero otherwise.
     VIRTUAL GLuint METHOD(GetGLProgramHandle)(THIS_
                                               SHADER_TYPE Stage) CONST PURE;
 

Graphics/GraphicsEngineOpenGL/interface/RenderDeviceGL.h

@@ -88,9 +88,9 @@ DILIGENT_BEGIN_INTERFACE(IRenderDeviceGL, IRenderDevice)
     /// \param [in] GLHandle      - OpenGL texture handle.
     /// \param [in] GLBindTarget  - OpenGL bind target. If this parameter is null, the engine will
     ///                             automatically select the target based on texture
-    ///                             type (e.g. RESOURCE_DIM_TEX_2D will map to GL_TEXTURE_2D).
+    ///                             type (e.g. Diligent::RESOURCE_DIM_TEX_2D will map to `GL_TEXTURE_2D`).
     ///                             An application should typically use this parameter when the texture
-    ///                             has non-standard bind target such as, GL_TEXTURE_EXTERNAL_OES.
+    ///                             has non-standard bind target such as, `GL_TEXTURE_EXTERNAL_OES`.
     /// \param [in] TexDesc       - Texture description. The engine can automatically
     ///                             set texture width, height, depth, mip levels count, and format.
     ///                             Remaining fields should be set up by the app.
@@ -99,6 +99,7 @@ DILIGENT_BEGIN_INTERFACE(IRenderDeviceGL, IRenderDevice)
     ///                             texture interface will be stored.
     ///                             The function calls AddRef(), so that the new object will contain
     ///                             one reference.
+    ///
     /// \note  Diligent engine texture object does not take ownership of the GL resource,
     ///        and the application must not destroy it while it is in use by the engine.
     VIRTUAL void METHOD(CreateTextureFromGLHandle)(THIS_
@@ -119,6 +120,7 @@ DILIGENT_BEGIN_INTERFACE(IRenderDeviceGL, IRenderDevice)
     ///                             texture interface will be stored.
     ///                             The function calls AddRef(), so that the new object will contain
     ///                             one reference.
+    ///
     /// \note  Diligent engine buffer object does not take ownership of the GL resource,
     ///        and the application must not destroy it while it is in use by the engine.
     VIRTUAL void METHOD(CreateBufferFromGLHandle)(THIS_
@@ -140,6 +142,7 @@ DILIGENT_BEGIN_INTERFACE(IRenderDeviceGL, IRenderDevice)
     ///                             texture interface will be stored.
     ///                             The function calls AddRef(), so that the new object will contain
     ///                             one reference.
+    ///
     /// \note  Only RESOURCE_DIM_TEX_2D dummy textures are supported.
     VIRTUAL void METHOD(CreateDummyTexture)(THIS_
                                             const TextureDesc REF TexDesc,