Readme: updated section headers

Author: TheMostDiligent

Graphics/GraphicsEngineD3D11/readme.md

@@ -1,15 +1,15 @@
 
-# GraphicsEngineD3D11
+# Graphics Engine D3D11
 
 Implementation of Direct3D11 backend
 
-# Interoperability with Direct3D11
+## Interoperability with Direct3D11
 
 Diligent Engine exposes methods to access internal D3D11 objects, is able to create diligent engine buffers
 and textures from existing Direct3D11 buffers and textures, and can be initialized by attaching to existing D3D11
 device and immediate context.
 
-## Accessing Native Direct3D11 objects
+### Accessing Native Direct3D11 objects
 
 Below are some of the methods that provide access to internal D3D11 objects:
 
@@ -38,7 +38,7 @@ Below are some of the methods that provide access to internal D3D11 objects:
 | `ITextureViewD3D11* ISwapChainD3D11::GetDepthBufferDSV`                   | returns a pointer to the native `ITextureViewD3D11` object representing depth-stencil view                      |
 | `IDXGISwapChain* ISwapChainD3D11::GetDXGISwapChain`                       | returns a pointer to the native `IDXGISwapChain` object                                                         |
 
-## Creating Diligent Engine Objects from Direct3D11 Resources
+### Creating Diligent Engine Objects from Direct3D11 Resources
 
 |                              Function                 |                              Description                                        |
 |-------------------------------------------------------|---------------------------------------------------------------------------------|
@@ -48,7 +48,7 @@ Below are some of the methods that provide access to internal D3D11 objects:
 | `IRenderDeviceD3D11::CreateTexture3DFromD3DResource`  | creates a Diligent Engine texture object from the native Direct3D11 3D texture  |
 
 
-## Initializing the Engine by Attaching to Existing Direct3D11 Device and Immediate Context
+### Initializing the Engine by Attaching to Existing Direct3D11 Device and Immediate Context
 
 You can use `IEngineFactoryD3D11::AttachToD3D11Device` to attach the engine to existing Direct3D11 device and immediate context.
 For example, the code snippet below shows how Diligent Engine can be attached to Direct3D11 device returned by Unity:

Graphics/GraphicsEngineD3D12/readme.md

@@ -1,15 +1,15 @@
 
-# GraphicsEngineD3D12
+# Graphics Engine D3D12
 
 Implementation of Direct3D12 backend
 
-# Interoperability with Direct3D12
+## Interoperability with Direct3D12
 
 Diligent Engine exposes methods to access internal Direct3D12 objects, is able to create diligent engine buffers
 and textures from existing Direct3D12 resources, and can be initialized by attaching to existing Direct3D12
 device and provide synchronization tools.
 
-## Accessing Native Direct3D12 Resources
+### Accessing Native Direct3D12 Resources
 
 Below are some of the methods that provide access to internal Direct3D12 objects:
 
@@ -40,7 +40,7 @@ Below are some of the methods that provide access to internal Direct3D12 objects
 | `IShaderBindingTableD3D12::GetD3D12BindingTable`                       | returns the shader binding table structure that can be used with `ID3D12GraphicsCommandList4::DispatchRays` call |
 | `ISwapChainD3D12::GetDXGISwapChain`                                    | returns a pointer to the IDXGISwapChain interface of the internal DXGI object |
 
-## Synchronization Tools
+### Synchronization Tools
 
 |                              Function          |                              Description         |
 |------------------------------------------------|--------------------------------------------------|
@@ -49,7 +49,7 @@ Below are some of the methods that provide access to internal Direct3D12 objects
 | `ICommandQueueD3D12::EnqueueSignal`            | signals the Direct3D12 fence                     |
 | `ICommandQueueD3D12::WaitFence`                | waits for the Direct3D12 fence on the GPU        |
 
-## Creating Diligent Engine Objects from D3D12 Resources
+### Creating Diligent Engine Objects from D3D12 Resources
 
 |                              Function              |                              Description                                                                      |
 |----------------------------------------------------|---------------------------------------------------------------------------------------------------------------|
@@ -59,7 +59,7 @@ Below are some of the methods that provide access to internal Direct3D12 objects
 | `IRenderDeviceD3D12::CreateTLASFromD3DResource`    | creates a Diligent Engine top-level acceleration structure from the native Direct3D12 resource |
 
 
-## Initializing the Engine by Attaching to Existing D3D12 Device
+### Initializing the Engine by Attaching to Existing D3D12 Device
 
 To attach diligent engine to existing D3D12 device, use the following factory function:
 

Graphics/GraphicsEngineMetal/readme.md

@@ -1,5 +1,5 @@
 
-# GraphicsEngineMetal
+# Graphics Engine Metal
 
 Implementation of Metal backend is available for commercial clients.
 

Graphics/GraphicsEngineOpenGL/readme.md

@@ -1,15 +1,15 @@
 
-# GraphicsEngineOpenGL
+# Graphics Engine OpenGL
 
 Implementation of OpenGL/GLES backend
 
-# Interoperability with OpenGL/GLES
+## Interoperability with OpenGL/GLES
 
 Diligent Engine exposes methods to access internal OpenGL/GLES objects, is able to create diligent engine buffers
 and textures from existing GL buffer and texture handles, and can be initialized by attaching to existing GL
 context.
 
-## Accessing Native GL objects
+### Accessing Native GL objects
 
 Below are some of the methods that provide access to internal GL object handles:
 
@@ -23,7 +23,7 @@ Below are some of the methods that provide access to internal GL object handles:
 | `ISwapChainGL::GetDefaultFBO`              | returns default framebuffer handle               |
 
 
-## Creating Diligent Engine Objects from OpenGL Handles
+### Creating Diligent Engine Objects from OpenGL Handles
 
 * `void IRenderDeviceGL::CreateTextureFromGLHandle(Uint32 GLHandle, Uint32 GLBindTarget, const TextureDesc& TexDesc, RESOURCE_STATE InitialState, ITexture** ppTexture)` -
     creates a diligent engine texture from OpenGL handle. The method takes OpenGL handle `GLHandle`, texture bind target `GLBindTarget`
@@ -39,7 +39,7 @@ Below are some of the methods that provide access to internal GL object handles:
     set the buffer size, but the rest of the fields need to be set by the client. Note that 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.
 
-## Initializing the Engine by Attaching to Existing GL Context
+### Initializing the Engine by Attaching to Existing GL Context
 
 The code snippet below shows how diligent engine can be attached to existing GL context that is active in the current thread.
 

Graphics/GraphicsEngineVulkan/readme.md

@@ -1,14 +1,14 @@
 
-# GraphicsEngineVulkan
+# Graphics Engine Vulkan
 
 Implementation of Vulkan backend
 
-# Interoperability with Vulkan
+## Interoperability with Vulkan
 
 Diligent Engine exposes methods to access internal Vulkan objects, is able to create diligent engine buffers
 and textures from existing Vulkan handles.
 
-## Accessing Native Vulkan handles
+### Accessing Native Vulkan handles
 
 Below are some of the methods that provide access to internal Vulkan objects:
 
@@ -44,7 +44,7 @@ Below are some of the methods that provide access to internal Vulkan objects:
 | `IFramebuffer::GetVkFramebuffer`            | returns Vulkan framebuffer object handle                                 |
 
 
-## Synchronization Tools
+### Synchronization Tools
 
 |                              Function          |                              Description         |
 |------------------------------------------------|--------------------------------------------------|
@@ -55,7 +55,7 @@ Below are some of the methods that provide access to internal Vulkan objects:
 | `ICommandQueueVk::EnqueueSignalFence`          | signals the given fence                                          |
 | `ICommandQueueVk::EnqueueSignal`               | signals the given timeline semaphore.                            |
 
-## Creating Diligent Engine Objects from Vk Resources
+### Creating Diligent Engine Objects from Vk Resources
 
 |                              Function              |                              Description                                                    |
 |----------------------------------------------------|---------------------------------------------------------------------------------------------|

Graphics/GraphicsEngineWebGPU/readme.md

@@ -1,3 +1,3 @@
-# GraphicsEngineWebGPU
+# Graphics Engine WebGPU
 
 Implementation of WebGPU backend

Graphics/HLSL2GLSLConverterLib/readme.md

@@ -1,16 +1,16 @@
 
-# HLSL2GLSLConverterLib
+# HLSL2GLSL Converter Lib
 
 Implementation of HLSL to GLSL source converter
 
 DirectX and OpenGL use different shading languages, which share a lot in common, but sometimes differ substantially. 
 For cross-platform applications, maintaining two versions of each shader is time-consuming and error-prone. Diligent 
 Engine uses HLSL2GLSL Converter that allows shader authored in HLSL to be converted into GLSL source.
 
-# Details
+## Details
 
 
-## Requirements
+### Requirements
 The converter supports HLSL5.0, all shader types (vertex, geometry, pixel, domain, hull, and compute) as well as most 
 of the language constructs. There are however few special requirements that must be met in order for the HLSL source 
 to be successfully converted to GLSL:
@@ -89,7 +89,7 @@ DSOutput main( HS_CONSTANT_DATA_OUTPUT input,
 * Geometry, Domain and Hull shaders must be defined in separate files
 * GLSL allows samplers to be declared as global variables or function arguments only. It does not allow local variables of sampler type.
 
-## Textures and samplers
+### Textures and samplers
 
 The following rules are used to convert HLSL texture declaration into GLSL sampler:
 
@@ -133,7 +133,7 @@ GLSL image format specification inside the special comment block:
 RWTexture2D<float /* format=r32f */ > Tex2D;
 ```
 
-## Important notes/known issues
+### Important notes/known issues
 
 * GLSL compiler does not handle `float3` (`vec3`) structure members correctly. It is strongly suggested avoid 
 using this type in structure definitions
@@ -195,7 +195,7 @@ all(p < q); // Error
   - `TextureCube.SampleCmpLevelZero()`
   - `TextureCubeArray.SampleCmpLevelZero()`
 
-## Limitations
+### Limitations
 Converter does not perform macros expansion, so usage of preprocessor directives is limited to 
 text block that do not need to be converted. The following are some examples that are not supported.
 
@@ -260,40 +260,11 @@ VSOut VSTes(...)
 }
 ```
 
-# Features
+## Features
 
 Please visit [this page](http://diligentgraphics.com/diligent-engine/shader-converter/supported-features/) 
 for the full list of supported language features.
 
-# References
+## References
 
 [HLSL to GLSL Source Converter](http://diligentgraphics.com/diligent-engine/shader-converter/)
-
-# Release Notes
-
-## 2.1
-
-### New features
-
-* Support for structured buffers
-* HLSL->GLSL conversion is now a two-stage process:
-  - Creating conversion stream
-  - Creating GLSL source from the stream
-* Geometry shader support
-* Tessellation control and tessellation evaluation shader support
-* Support for non-void shader functions
-* Allowing structs as input parameters for shader functions
-
-## 2.0
-
-Reworked the API to follow D3D12 style
-
-## 1.0
-
-Initial release
-
-
-
-**Copyright 2015-2018 Egor Yusov**
-
-[diligentgraphics.com](http://diligentgraphics.com)

ReleaseHistory.md

@@ -1,3 +1,5 @@
+# Release Notes
+
 ## Current progress
 
 * Added `SHADER_COMPILE_FLAG_HLSL_TO_SPIRV_VIA_GLSL` flag (API256008)

doc/CodingGuidelines.md

@@ -1,6 +1,8 @@
-# Includes
+# Coding Guidelines
 
-## Header files
+## Includes
+
+### Header files
 
 Includes in the source file should go in the following order:
 1. System includes and standard headers
@@ -39,7 +41,7 @@ Example:
 #include "D3D12DynamicHeap.hpp"
 ```
 
-## Source files
+### Source files
 
 Includes in the source file should go in the following order:
 
@@ -90,10 +92,10 @@ Example:
 When there is more than one header in each group, it is recommended to separate the groups with blank lines.
 
 
-# Exceptions
+## Exceptions
 
 
-# Naming conventions
+## Naming conventions
 
 
-# Debug macros
+## Debug macros

doc/CoordinateSystem.md

@@ -1,4 +1,3 @@
-
 # Coordinate System Conventions
 
 While there exist multiple ways to express transformations of a 3D scene (row-vectors vs column-vectors, right-handed systems vs left-handed systems, etc.),