Minor updates to readme

Author: TheMostDiligent

Graphics/GraphicsEngineD3D11/readme.md

@@ -11,10 +11,10 @@ The following code snippet shows how to initialize diligent engine in D3D11 mode
 #include "RenderDeviceFactoryD3D11.h"
 using namespace Diligent;
 
-// ... 
+// ...
 
 EngineD3D11Attribs DeviceAttribs;
-DeviceAttribs.DebugFlags = 
+DeviceAttribs.DebugFlags =
     (Uint32)EngineD3D11DebugFlags::VerifyCommittedShaderResources |
     (Uint32)EngineD3D11DebugFlags::VerifyCommittedResourceRelevance;
 
@@ -38,8 +38,8 @@ Alternatively, the engine can be initialized by attaching to existing D3D11 devi
 
 # 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 
+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 D3D11 objects
@@ -57,13 +57,13 @@ Below are some of the methods that provide access to internal D3D11 objects:
 
 ## Creating Diligent Engine Objects from D3D11 Resources
 
-* `void IRenderDeviceD3D11::CreateBufferFromD3DResource(ID3D11Buffer *pd3d11Buffer, const BufferDesc& BuffDesc, IBuffer **ppBuffer)` - 
+* `void IRenderDeviceD3D11::CreateBufferFromD3DResource(ID3D11Buffer *pd3d11Buffer, const BufferDesc& BuffDesc, IBuffer **ppBuffer)` -
    creates a diligent engine buffer object from the native d3d11 buffer
-* `void IRenderDeviceD3D11::CreateTextureFromD3DResource(ID3D11Texture1D *pd3d11Texture, ITexture **ppTexture)` - 
+* `void IRenderDeviceD3D11::CreateTextureFromD3DResource(ID3D11Texture1D *pd3d11Texture, ITexture **ppTexture)` -
    create a diligent engine texture object from the native D3D11 1D texture
-* `void IRenderDeviceD3D11::CreateTextureFromD3DResource(ID3D11Texture2D *pd3d11Texture, ITexture **ppTexture)` - 
+* `void IRenderDeviceD3D11::CreateTextureFromD3DResource(ID3D11Texture2D *pd3d11Texture, ITexture **ppTexture)` -
    create a diligent engine texture object from the native D3D11 2D texture
-* `void IRenderDeviceD3D11::CreateTextureFromD3DResource(ID3D11Texture3D *pd3d11Texture, ITexture **ppTexture)` - 
+* `void IRenderDeviceD3D11::CreateTextureFromD3DResource(ID3D11Texture3D *pd3d11Texture, ITexture **ppTexture)` -
    create a diligent engine texture object from the native D3D11 3D texture
 
 ## Initializing the Engine by Attaching to Existing D3D11 Device and Immediate Context

Graphics/GraphicsEngineD3D12/readme.md

@@ -11,11 +11,11 @@ The following code snippet shows how to initialize diligent engine in D3D12 mode
 #include "RenderDeviceFactoryD3D12.h"
 using namespace Diligent;
 
-// ... 
+// ...
 #if ENGINE_DLL
-	GetEngineFactoryD3D12Type GetEngineFactoryD3D12 = nullptr;
-	// Load the dll and import GetEngineFactoryD3D12() function
-	LoadGraphicsEngineD3D12(GetEngineFactoryD3D12);
+  GetEngineFactoryD3D12Type GetEngineFactoryD3D12 = nullptr;
+  // Load the dll and import GetEngineFactoryD3D12() function
+  LoadGraphicsEngineD3D12(GetEngineFactoryD3D12);
 #endif
 auto *pFactoryD3D11 = GetEngineFactoryD3D12();
 EngineD3D12Attribs EngD3D12Attribs;
@@ -36,8 +36,8 @@ Alternatively, the engine can be initialized by attaching to existing D3D12 devi
 
 # Interoperability with Direct3D12
 
-Diligent Engine exposes methods to access internal D3D12 objects, is able to create diligent engine buffers 
-and textures from existing Direct3D12 resources, and can be initialized by attaching to existing D3D12 
+Diligent Engine exposes methods to access internal D3D12 objects, is able to create diligent engine buffers
+and textures from existing Direct3D12 resources, and can be initialized by attaching to existing D3D12
 device and provide synchronization tools.
 
 ## Accessing Native D3D12 Resources
@@ -69,12 +69,12 @@ Below are some of the methods that provide access to internal D3D12 objects:
 
 ## Creating Diligent Engine Objects from D3D12 Resources
 
-* `void IRenderDeviceD3D12::CreateTextureFromD3DResource(ID3D12Resource *pd3d12Texture, ITexture **ppTexture)` - 
+* `void IRenderDeviceD3D12::CreateTextureFromD3DResource(ID3D12Resource *pd3d12Texture, ITexture **ppTexture)` -
    creates a diligent engine texture object from native D3D12 resource.
-* `void IRenderDeviceD3D12::CreateBufferFromD3DResource(ID3D12Resource *pd3d12Buffer, const BufferDesc& BuffDesc, IBuffer **ppBuffer)` - 
+* `void IRenderDeviceD3D12::CreateBufferFromD3DResource(ID3D12Resource *pd3d12Buffer, const BufferDesc& BuffDesc, IBuffer **ppBuffer)` -
    creates a diligent engine buffer object from native D3D12 resource.
-   The method takes a pointer to the native d3d12 resiyrce pd3d12Buffer, buffer description BuffDesc and writes a pointer to the IBuffer 
-   interface at the memory location pointed to by ppBuffer. The system can recover buffer size, but the rest of the fields of 
+   The method takes a pointer to the native d3d12 resiyrce pd3d12Buffer, buffer description BuffDesc and writes a pointer to the IBuffer
+   interface at the memory location pointed to by ppBuffer. The system can recover buffer size, but the rest of the fields of
    BuffDesc structure need to be populated by the client as they cannot be recovered from d3d12 resource description.
 
 
@@ -91,10 +91,10 @@ void IEngineFactoryD3D12::AttachToD3D12Device(void *pd3d12NativeDevice,
                                               Uint32 NumDeferredContexts);
 ```
 
-The method takes a pointer to the native D3D12 device `pd3d12NativeDevice`, initialization parameters `EngineAttribs`, 
-and returns diligent engine device interface in `ppDevice`, and diligent engine contexts in `ppContexts`. Pointer to the 
-immediate goes at position 0. If `NumDeferredContexts` > 0, pointers to deferred contexts go afterwards. 
-The function also takes a pointer to the command queue object `pCommandQueue`, which needs to implement 
+The method takes a pointer to the native D3D12 device `pd3d12NativeDevice`, initialization parameters `EngineAttribs`,
+and returns diligent engine device interface in `ppDevice`, and diligent engine contexts in `ppContexts`. Pointer to the
+immediate goes at position 0. If `NumDeferredContexts` > 0, pointers to deferred contexts go afterwards.
+The function also takes a pointer to the command queue object `pCommandQueue`, which needs to implement
 `ICommandQueueD3D12` interface.
 
 For more information about interoperability with D3D12, please visit [Diligent Engine web site](http://diligentgraphics.com/diligent-engine/native-api-interoperability/direct3d12-interoperability/)

Graphics/GraphicsEngineOpenGL/readme.md

@@ -11,7 +11,7 @@ The following code snippet shows how to initialize diligent engine in OpenGL/GLE
 #include "RenderDeviceFactoryOpenGL.h"
 using namespace Diligent;
 
-// ... 
+// ...
 
 #if ENGINE_DLL
     GetEngineFactoryOpenGLType GetEngineFactoryOpenGL;
@@ -30,8 +30,8 @@ Alternatively, the engine can be initialized by attaching to existing OpenGL con
 
 # 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 
+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
@@ -47,16 +47,16 @@ Below are some of the methods that provide access to internal D3D11 objects:
 
 ## Creating Diligent Engine Objects from OpenGL Handles
 
-* `void IRenderDeviceGL::CreateTextureFromGLHandle(Uint32 GLHandle, const TextureDesc &TexDesc, ITexture **ppTexture)`  - 
-	creates a diligent engine texture from OpenGL handle. The method takes OpenGL handle GLHandle, texture description TexDesc, 
-	and writes the pointer to the created texture object at the memory address pointed to by ppTexture. The engine can automatically 
-	set texture width, height, depth, mip levels count, and format, but the remaining field of TexDesc structure must be populated by 
-	the application. Note that 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.
+* `void IRenderDeviceGL::CreateTextureFromGLHandle(Uint32 GLHandle, const TextureDesc &TexDesc, ITexture **ppTexture)` -
+    creates a diligent engine texture from OpenGL handle. The method takes OpenGL handle GLHandle, texture description TexDesc,
+    and writes the pointer to the created texture object at the memory address pointed to by ppTexture. The engine can automatically
+    set texture width, height, depth, mip levels count, and format, but the remaining field of TexDesc structure must be populated by
+    the application. Note that 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.
 * `void IRenderDeviceGL::CreateBufferFromGLHandle(Uint32 GLHandle, const BufferDesc &BuffDesc, IBuffer **ppBuffer)` -
-    creates a diligent engine buffer from OpenGL handle. The method takes OpenGL handle GLHandle, buffer description BuffDesc, 
-    and writes the pointer to the created buffer object at the memory address pointed to by ppBuffer. The engine can automatically 
-    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 
+    creates a diligent engine buffer from OpenGL handle. The method takes OpenGL handle GLHandle, buffer description BuffDesc,
+    and writes the pointer to the created buffer object at the memory address pointed to by ppBuffer. The engine can automatically
+    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