Enhance documentation with help of Copilot

Author: egorodet

Apps/01-HelloTriangle/README.md

@@ -4,16 +4,16 @@
 |-------------------------------------------------------------------------|--------------------------------------------------------------------|-------------------------------------------------------------------|-----------------------------------------------------------------|
 | ![Hello Triangle on Windows](Screenshots/HelloTriangleWinDirectX12.jpg) | ![Hello Triangle on Linux](Screenshots/HelloTriangleLinVulkan.jpg) | ![Hello Triangle on MacOS](Screenshots/HelloTriangleMacMetal.jpg) | ![Hello Triangle on iOS](Screenshots/HelloTriangleIOSMetal.jpg) | 
 
-This tutorial demonstrates colored triangle rendering implemented in just 130 lines of code using Methane Kit:
+This tutorial demonstrates how to render a colored triangle in just 130 lines of code using Methane Kit:
 - [HelloTriangleApp.cpp](HelloTriangleApp.cpp)
 - [Shaders/HelloTriangle.hlsl](Shaders/HelloTriangle.hlsl)
 
-Tutorial demonstrates the following Methane Kit features and techniques:
-- Use base graphics application class for deferred frames rendering with triple buffering.
-- Load shaders, creating program and render state.
-- Use render command lists for encoding draw commands.
-- Execute command lists on GPU and presenting frame buffers on screen.
-- Configure cross-platform application build with shaders compilation to embedded resources.
+The tutorial covers the following Methane Kit features and techniques:
+- Using the base graphics application class for deferred frame rendering with triple buffering.
+- Loading shaders, creating programs, and setting render states.
+- Using render command lists to encode draw commands.
+- Executing command lists on the GPU and presenting frame buffers on the screen.
+- Configuring cross-platform application builds with shaders compiled into embedded resources.
 
 ## Application Controls
 
@@ -23,14 +23,14 @@ Common keyboard controls are enabled by the `Platform` and `Graphics` applicatio
 
 ## Application and Frame Class Definitions
 
-Application class `HelloTriangleApp` is derived from the base template class [Graphics::App<HelloTriangleFrame>](/Modules/Graphics/App) 
-which implements base platform and graphics application infrastructure with support of deferred frames rendering.
+The `HelloTriangleApp` application class is derived from the base template class [Graphics::App<HelloTriangleFrame>](/Modules/Graphics/App),
+which implements the base platform and graphics application infrastructure with support for deferred frame rendering.
 
-Application frame class `HelloTriangleFrame` is derived from the base class `Graphics::AppFrame` and extends it 
-with render command list `render_cmd_list_ptr` and command list set `execute_cmd_list_set_ptr` submitted 
-for rendering to frame buffer `index`. Application is initialized with default settings using `Graphics::AppSettings` structure,
-which is initialized with helper function `Tutorials::GetGraphicsTutorialAppSettings(...)`. 
-Destroying of application along with its resources is delayed until all rendering is completed on GPU.
+The `HelloTriangleFrame` class is derived from the base class `Graphics::AppFrame` and extends it with a render command list
+`render_cmd_list_ptr` and a command list set `execute_cmd_list_set_ptr` submitted for rendering to the frame buffer `index`.
+The application is initialized with default settings using the `Graphics::AppSettings` structure, which is initialized
+with the helper function `Tutorials::GetGraphicsTutorialAppSettings(...)`. The destruction of the application and its
+resources is delayed until all rendering is completed on the GPU.
 
 ```cpp
 #include <Methane/Kit.h>
@@ -75,31 +75,32 @@ public:
 
 ## Graphics Resources Initialization
 
-Application class `HelloTriangleApp` keeps frame independent resources in private class members.
-In this tutorial it is only render state `m_render_state` which is initialized in `HelloTriangleApp::Init` method.
-Render state is created with `GetRenderContext().CreateRenderState(...)` factory method of the render context, which encapsulate 
-program created inline with `GetRenderContext().CreateProgram(...)`. Program is created with a set of vertex and pixel shaders
-created by `Rhi::Program::ShaderSet` shaders set description which takes `Data::IProvider` and 
-`IShader::EntryPoint` structure consisting of file and function names. Compiled shader data is embedded in executable resources
-and is accessed via shader data provider singleton available with `Data::ShaderProvider::Get()`.
-Program also defines input buffer layout using argument semantic names from HLSL shaders. Methane graphics abstraction 
-uses shader reflection to automatically identify argument types and offset sizes to build underlying DirectX, Metal or Vulkan
-layout description. Render target color formats `GetScreenRenderPattern().GetAttachmentFormats()` are also required for program creation,
-these formats are taken from `Rhi::RenderPattern` object provided by the base class `Graphics::App` and describing general 
-configuration of color/depth/stencil attachments used for final drawing to window on screen.
-`RenderState::Settings` requires `Rhi::RenderPattern` object and also contains settings of rasterizer, depth, stencil, 
-blending states which are skipped with default values for simplicity of this tutorial.
-
-Render command lists are created from the rendering command queue `cmd_queue` acquired from render context 
-`GetRenderContext().GetRenderCommandKit().GetQueue()`. Command lists `frame.render_cmd_list` are created for each frame using 
-`cmd_queue.CreateRenderCommandList(frame.screen_pass)` factory method of the `Rhi::CommandQueue` taking `Rhi::RenderPass` as an argument.
-So the created command list can be used for rendering only to that particular render pass. Command lists are executed as a
-part of command list sets `Rhi::CommandListSet` which include only one command list in this example and are also created for each frame
-`frame.execute_cmd_list_set`.
-
-Finally, at the end of `Init()` function `GraphicsApp::CompleteInitialization()` is called to complete graphics
+The `HelloTriangleApp` class keeps frame-independent resources in private class members. In this tutorial, it is only
+the render state `m_render_state`, which is initialized in the `HelloTriangleApp::Init` method. The render state is
+created with the `GetRenderContext().CreateRenderState(...)` factory method of the render context, which encapsulates
+the program created inline with `GetRenderContext().CreateProgram(...)`. The program is created with a set of vertex and
+pixel shaders described by the `Rhi::Program::ShaderSet` structure, which takes `Data::IProvider` and `IShader::EntryPoint`
+structures consisting of file and function names. Compiled shader data is embedded in executable resources and accessed
+via the shader data provider singleton available with `Data::ShaderProvider::Get()`. The program also defines the input
+buffer layout using argument semantic names from HLSL shaders. Methane graphics abstraction uses shader reflection to
+automatically identify argument types and offset sizes to build the underlying DirectX, Metal, or Vulkan layout description.
+Render target color formats `GetScreenRenderPattern().GetAttachmentFormats()` are also required for program creation.
+These formats are taken from the `Rhi::RenderPattern` object provided by the base class `Graphics::App`, which describes
+the general configuration of color, depth, and stencil attachments used for final drawing to the window on the screen.
+`RenderState::Settings` requires an `Rhi::RenderPattern` object and also contains settings for rasterizer, depth, stencil,
+and blending states, which are skipped with default values for simplicity in this tutorial.
+
+Render command lists are created from the rendering command queue `cmd_queue` acquired from the render context
+`GetRenderContext().GetRenderCommandKit().GetQueue()`. Command lists `frame.render_cmd_list` are created for each frame
+using the `cmd_queue.CreateRenderCommandList(frame.screen_pass)` factory method of the `Rhi::CommandQueue`, taking
+`Rhi::RenderPass` as an argument. The created command list can be used for rendering only to that particular render pass.
+Command lists are executed as part of command list sets `Rhi::CommandListSet`, which include only one command list in
+this example and are also created for each frame `frame.execute_cmd_list_set`.
+
+Finally, at the end of the `Init()` function, `GraphicsApp::CompleteInitialization()` is called to complete graphics
 resources initialization and prepare for rendering.
 
+
 ```cpp
 class HelloTriangleApp final : public GraphicsApp
 {
@@ -151,21 +152,23 @@ public:
 
 ## Frame Rendering Cycle
 
-Rendering is implemented in overridden `HelloTriangleApp::Render` method. Base graphics application
-rendering is executed first with `GraphicsApp::Render()` and rendering is continued only when it succeedes,
-it waits for previous iteration of rendering cycle completion and availability of all frame resources.
-Then current frame resources are requested with `GraphicsApp::GetCurrentFrame()` and used for render commands encoding.
+## Frame Rendering Cycle
+
+Rendering is implemented in the overridden `HelloTriangleApp::Render` method. Base graphics application rendering is executed
+first with `GraphicsApp::Render()`, and rendering continues only when it succeeds. It waits for the previous iteration of the
+rendering cycle to complete and for the availability of all frame resources. Then, current frame resources are requested with
+`GraphicsApp::GetCurrentFrame()` and used for render commands encoding.
 
-To begin encoding, command list has to be reset with render state using `Rhi::RenderCommandList::Reset(...)` method.
-Default view state is set with full frame viewport and scissor rect using `Rhi::RenderCommandList::SetViewState(...)`.
-Drawing of 3 vertices is submitted as `Rhi::RenderPrimitive::Triangle` primitive using `Rhi::RenderCommandList::Draw(...)` call.
-Vertex buffers are not used for simplification, so the vertex shader will receive only `vertex_id` and 
-will need to provide vertex coordinates based on that. Finally, `ICommandList::Commit` method is called 
-to complete render commands encoding.
+To begin encoding, the command list has to be reset with the render state using the `Rhi::RenderCommandList::Reset(...)` method.
+The default view state is set with a full frame viewport and scissor rect using the `Rhi::RenderCommandList::SetViewState(...)`
+method. Drawing of 3 vertices is submitted as the `Rhi::RenderPrimitive::Triangle` primitive using the
+`Rhi::RenderCommandList::Draw(...)` call. Vertex buffers are not used for simplification, so the vertex shader will receive only
+`vertex_id` and will need to provide vertex coordinates based on that. Finally, the `ICommandList::Commit` method is called to
+complete render commands encoding.
 
-Execution of GPU rendering is started with `ICommandQueue::Execute(...)` method called on the same command queue
-which was used to create the command list submitted for execution. Frame buffer with the result image is presented by
-swap-chain with `RenderContext::Present()` method call.
+Execution of GPU rendering is started with the `ICommandQueue::Execute(...)` method called on the same command queue which was
+used to create the command list submitted for execution. The frame buffer with the result image is presented by the swap-chain
+with the `RenderContext::Present()` method call.
 
 ```cpp
 class HelloTriangleApp final : public GraphicsApp
@@ -191,7 +194,8 @@ class HelloTriangleApp final : public GraphicsApp
 };
 ```
 
-Graphics render loop is started from `main(...)` entry function using `GraphicsApp::Run(...)` method which is also parsing command line arguments.
+Graphics render loop is started from `main(...)` entry function using `GraphicsApp::Run(...)` method which is
+also parsing command line arguments.
 
 ```cpp
 int main(int argc, const char* argv[])
@@ -203,7 +207,7 @@ int main(int argc, const char* argv[])
 ## Colored Triangle Shaders
 
 This tutorial uses simple HLSL shader [Shaders/Triangle.hlsl](Shaders/Triangle.hlsl) which is taking vertex positions
-and colors from inline constant arrays based on vertex_id argument passed to vertex shader. 
+and colors from inline constant arrays based on `vertex_id` argument passed to vertex shader. 
 
 ```cpp
 struct PSInput
@@ -240,7 +244,7 @@ float4 TrianglePS(PSInput input) : SV_TARGET
 
 ## CMake Build Configuration
 
-Finally CMake build configuration [CMakeLists.txt](CMakeLists.txt) of the application
+Finally, CMake build configuration [CMakeLists.txt](CMakeLists.txt) of the application
 is powered by the included Methane CMake modules:
 - [MethaneApplications.cmake](/CMake/MethaneApplications.cmake) - defines function `add_methane_application`
 - [MethaneShaders.cmake](/CMake/MethaneShaders.cmake) - defines functions `add_methane_shaders_source` and `add_methane_shaders_library`

Apps/02-HelloCube/HelloCubeApp.cpp

@@ -48,7 +48,7 @@ struct HelloCubeFrame final : AppFrame
 {
 #ifdef UNIFORMS_ENABLED
     Rhi::ProgramBindings          program_bindings;
-    rhi::IProgramArgumentBinding* uniforms_binding_ptr = nullptr;
+    Rhi::IProgramArgumentBinding* uniforms_binding_ptr = nullptr;
 #else
     Rhi::BufferSet         vertex_buffer_set;
 #endif