clang-formatted AssetLoader

2 files changed, 217 insertions, 213 deletions

diff --git a/AssetLoader/interface/DXSDKMeshLoader.h b/AssetLoader/interface/DXSDKMeshLoader.h
index 9881b10..aac9753 100644
--- a/AssetLoader/interface/DXSDKMeshLoader.h
+++ b/AssetLoader/interface/DXSDKMeshLoader.h
@@ -40,15 +40,15 @@ namespace Diligent
 //--------------------------------------------------------------------------------------
 // Hard Defines for the various structures
 //--------------------------------------------------------------------------------------
-#define DXSDKMESH_FILE_VERSION  101
+#define DXSDKMESH_FILE_VERSION 101
 
-#define INVALID_FRAME           ((Uint32)-1)
-#define INVALID_MESH            ((Uint32)-1)
-#define INVALID_MATERIAL        ((Uint32)-1)
-#define INVALID_SUBSET          ((Uint32)-1)
-#define INVALID_ANIMATION_DATA  ((Uint32)-1)
-#define INVALID_SAMPLER_SLOT    ((Uint32)-1)
-#define ERROR_RESOURCE_VALUE    1
+#define INVALID_FRAME          ((Uint32)-1)
+#define INVALID_MESH           ((Uint32)-1)
+#define INVALID_MATERIAL       ((Uint32)-1)
+#define INVALID_SUBSET         ((Uint32)-1)
+#define INVALID_ANIMATION_DATA ((Uint32)-1)
+#define INVALID_SAMPLER_SLOT   ((Uint32)-1)
+#define ERROR_RESOURCE_VALUE   1
 
 // Enumerated Types.
 enum DXSDKMESH_PRIMITIVE_TYPE
@@ -75,7 +75,7 @@ enum DXSDKMESH_INDEX_TYPE
 enum FRAME_TRANSFORM_TYPE
 {
     FTT_RELATIVE = 0,
-    FTT_ABSOLUTE,    //This is not currently used but is here to support absolute transformations in the future
+    FTT_ABSOLUTE, //This is not currently used but is here to support absolute transformations in the future
 };
 
 // Structures.  Unions with pointers are forced to 64bit.
@@ -108,53 +108,53 @@ struct DXSDKMESH_HEADER
 enum DXSDKMESH_VERTEX_SEMANTIC
 {
     DXSDKMESH_VERTEX_SEMANTIC_POSITION = 0,
-    DXSDKMESH_VERTEX_SEMANTIC_BLENDWEIGHT,   // 1
-    DXSDKMESH_VERTEX_SEMANTIC_BLENDINDICES,  // 2
-    DXSDKMESH_VERTEX_SEMANTIC_NORMAL,        // 3
-    DXSDKMESH_VERTEX_SEMANTIC_PSIZE,         // 4
-    DXSDKMESH_VERTEX_SEMANTIC_TEXCOORD,      // 5
-    DXSDKMESH_VERTEX_SEMANTIC_TANGENT,       // 6
-    DXSDKMESH_VERTEX_SEMANTIC_BINORMAL,      // 7
-    DXSDKMESH_VERTEX_SEMANTIC_TESSFACTOR,    // 8
-    DXSDKMESH_VERTEX_SEMANTIC_POSITIONT,     // 9
-    DXSDKMESH_VERTEX_SEMANTIC_COLOR,         // 10
-    DXSDKMESH_VERTEX_SEMANTIC_FOG,           // 11
-    DXSDKMESH_VERTEX_SEMANTIC_DEPTH,         // 12
-    DXSDKMESH_VERTEX_SEMANTIC_SAMPLE         // 13
+    DXSDKMESH_VERTEX_SEMANTIC_BLENDWEIGHT,  // 1
+    DXSDKMESH_VERTEX_SEMANTIC_BLENDINDICES, // 2
+    DXSDKMESH_VERTEX_SEMANTIC_NORMAL,       // 3
+    DXSDKMESH_VERTEX_SEMANTIC_PSIZE,        // 4
+    DXSDKMESH_VERTEX_SEMANTIC_TEXCOORD,     // 5
+    DXSDKMESH_VERTEX_SEMANTIC_TANGENT,      // 6
+    DXSDKMESH_VERTEX_SEMANTIC_BINORMAL,     // 7
+    DXSDKMESH_VERTEX_SEMANTIC_TESSFACTOR,   // 8
+    DXSDKMESH_VERTEX_SEMANTIC_POSITIONT,    // 9
+    DXSDKMESH_VERTEX_SEMANTIC_COLOR,        // 10
+    DXSDKMESH_VERTEX_SEMANTIC_FOG,          // 11
+    DXSDKMESH_VERTEX_SEMANTIC_DEPTH,        // 12
+    DXSDKMESH_VERTEX_SEMANTIC_SAMPLE        // 13
 };
 
 enum DXSDKMESH_VERTEX_DATA_TYPE
 {
-    DXSDKMESH_VERTEX_DATA_TYPE_FLOAT1    =  0,  // 1D float expanded to (value, 0., 0., 1.)
-    DXSDKMESH_VERTEX_DATA_TYPE_FLOAT2    =  1,  // 2D float expanded to (value, value, 0., 1.)
-    DXSDKMESH_VERTEX_DATA_TYPE_FLOAT3    =  2,  // 3D float expanded to (value, value, value, 1.)
-    DXSDKMESH_VERTEX_DATA_TYPE_FLOAT4    =  3,  // 4D float
-    DXSDKMESH_VERTEX_DATA_TYPE_D3DCOLOR  =  4,  // 4D packed unsigned bytes mapped to 0. to 1. range
-                                                // Input is in D3DCOLOR format (ARGB) expanded to (R, G, B, A)
-    DXSDKMESH_VERTEX_DATA_TYPE_UBYTE4    =  5,  // 4D unsigned byte
-    DXSDKMESH_VERTEX_DATA_TYPE_SHORT2    =  6,  // 2D signed short expanded to (value, value, 0., 1.)
-    DXSDKMESH_VERTEX_DATA_TYPE_SHORT4    =  7,  // 4D signed short
-
-    DXSDKMESH_VERTEX_DATA_TYPE_UBYTE4N   =  8,  // Each of 4 bytes is normalized by dividing to 255.0
-    DXSDKMESH_VERTEX_DATA_TYPE_SHORT2N   =  9,  // 2D signed short normalized (v[0]/32767.0,v[1]/32767.0,0,1)
-    DXSDKMESH_VERTEX_DATA_TYPE_SHORT4N   = 10,  // 4D signed short normalized (v[0]/32767.0,v[1]/32767.0,v[2]/32767.0,v[3]/32767.0)
-    DXSDKMESH_VERTEX_DATA_TYPE_USHORT2N  = 11,  // 2D unsigned short normalized (v[0]/65535.0,v[1]/65535.0,0,1)
-    DXSDKMESH_VERTEX_DATA_TYPE_USHORT4N  = 12,  // 4D unsigned short normalized (v[0]/65535.0,v[1]/65535.0,v[2]/65535.0,v[3]/65535.0)
-    DXSDKMESH_VERTEX_DATA_TYPE_UDEC3     = 13,  // 3D unsigned 10 10 10 format expanded to (value, value, value, 1)
-    DXSDKMESH_VERTEX_DATA_TYPE_DEC3N     = 14,  // 3D signed 10 10 10 format normalized and expanded to (v[0]/511.0, v[1]/511.0, v[2]/511.0, 1)
-    DXSDKMESH_VERTEX_DATA_TYPE_FLOAT16_2 = 15,  // Two 16-bit floating point values, expanded to (value, value, 0, 1)
-    DXSDKMESH_VERTEX_DATA_TYPE_FLOAT16_4 = 16,  // Four 16-bit floating point values
-    DXSDKMESH_VERTEX_DATA_TYPE_UNUSED    = 17,  // When the type field in a decl is unused.
+    DXSDKMESH_VERTEX_DATA_TYPE_FLOAT1   = 0, // 1D float expanded to (value, 0., 0., 1.)
+    DXSDKMESH_VERTEX_DATA_TYPE_FLOAT2   = 1, // 2D float expanded to (value, value, 0., 1.)
+    DXSDKMESH_VERTEX_DATA_TYPE_FLOAT3   = 2, // 3D float expanded to (value, value, value, 1.)
+    DXSDKMESH_VERTEX_DATA_TYPE_FLOAT4   = 3, // 4D float
+    DXSDKMESH_VERTEX_DATA_TYPE_D3DCOLOR = 4, // 4D packed unsigned bytes mapped to 0. to 1. range
+                                             // Input is in D3DCOLOR format (ARGB) expanded to (R, G, B, A)
+    DXSDKMESH_VERTEX_DATA_TYPE_UBYTE4 = 5,   // 4D unsigned byte
+    DXSDKMESH_VERTEX_DATA_TYPE_SHORT2 = 6,   // 2D signed short expanded to (value, value, 0., 1.)
+    DXSDKMESH_VERTEX_DATA_TYPE_SHORT4 = 7,   // 4D signed short
+
+    DXSDKMESH_VERTEX_DATA_TYPE_UBYTE4N   = 8,  // Each of 4 bytes is normalized by dividing to 255.0
+    DXSDKMESH_VERTEX_DATA_TYPE_SHORT2N   = 9,  // 2D signed short normalized (v[0]/32767.0,v[1]/32767.0,0,1)
+    DXSDKMESH_VERTEX_DATA_TYPE_SHORT4N   = 10, // 4D signed short normalized (v[0]/32767.0,v[1]/32767.0,v[2]/32767.0,v[3]/32767.0)
+    DXSDKMESH_VERTEX_DATA_TYPE_USHORT2N  = 11, // 2D unsigned short normalized (v[0]/65535.0,v[1]/65535.0,0,1)
+    DXSDKMESH_VERTEX_DATA_TYPE_USHORT4N  = 12, // 4D unsigned short normalized (v[0]/65535.0,v[1]/65535.0,v[2]/65535.0,v[3]/65535.0)
+    DXSDKMESH_VERTEX_DATA_TYPE_UDEC3     = 13, // 3D unsigned 10 10 10 format expanded to (value, value, value, 1)
+    DXSDKMESH_VERTEX_DATA_TYPE_DEC3N     = 14, // 3D signed 10 10 10 format normalized and expanded to (v[0]/511.0, v[1]/511.0, v[2]/511.0, 1)
+    DXSDKMESH_VERTEX_DATA_TYPE_FLOAT16_2 = 15, // Two 16-bit floating point values, expanded to (value, value, 0, 1)
+    DXSDKMESH_VERTEX_DATA_TYPE_FLOAT16_4 = 16, // Four 16-bit floating point values
+    DXSDKMESH_VERTEX_DATA_TYPE_UNUSED    = 17, // When the type field in a decl is unused.
 };
 
 struct DXSDKMESH_VERTEX_ELEMENT
 {
-    Uint16    Stream;     // Stream index
-    Uint16    Offset;     // Offset in the stream in Uint8s
-    Uint8     Type;       // Data type
-    Uint8     Method;     // Processing method
-    Uint8     Usage;      // Semantics
-    Uint8     UsageIndex; // Semantic index
+    Uint16 Stream;     // Stream index
+    Uint16 Offset;     // Offset in the stream in Uint8s
+    Uint8  Type;       // Data type
+    Uint8  Method;     // Processing method
+    Uint8  Usage;      // Semantics
+    Uint8  UsageIndex; // Semantic index
 };
 
 
@@ -164,11 +164,11 @@ struct DXSDKMESH_VERTEX_BUFFER_HEADER
     Uint64 SizeUint8s;
     Uint64 StrideUint8s;
 
-    static constexpr size_t MaxVertexElements = 32;
+    static constexpr size_t  MaxVertexElements = 32;
     DXSDKMESH_VERTEX_ELEMENT Decl[MaxVertexElements];
     union
     {
-        Uint64   DataOffset;        //(This also forces the union to 64bits)
+        Uint64   DataOffset; //(This also forces the union to 64bits)
         IBuffer* pVB;
     };
 };
@@ -180,7 +180,7 @@ struct DXSDKMESH_INDEX_BUFFER_HEADER
     Uint32 IndexType;
     union
     {
-        Uint64   DataOffset;        //(This also forces the union to 64bits)
+        Uint64   DataOffset; //(This also forces the union to 64bits)
         IBuffer* pIB;
     };
 };
@@ -188,103 +188,103 @@ struct DXSDKMESH_INDEX_BUFFER_HEADER
 struct DXSDKMESH_MESH
 {
     static constexpr size_t MaxMeshName = 100;
-    char   Name[MaxMeshName];
-    Uint8  NumVertexBuffers;
+    char                    Name[MaxMeshName];
+    Uint8                   NumVertexBuffers;
     static constexpr size_t MaxVertexStreams = 16;
-    Uint32 VertexBuffers[MaxVertexStreams];
-    Uint32 IndexBuffer;
-    Uint32 NumSubsets;
-    Uint32 NumFrameInfluences; //aka bones
+    Uint32                  VertexBuffers[MaxVertexStreams];
+    Uint32                  IndexBuffer;
+    Uint32                  NumSubsets;
+    Uint32                  NumFrameInfluences; //aka bones
 
     float3 BoundingBoxCenter;
     float3 BoundingBoxExtents;
 
     union
     {
-        Uint64 SubsetOffset;  //Offset to list of subsets (This also forces the union to 64bits)
-        Uint32* pSubsets;      //Pointer to list of subsets
+        Uint64  SubsetOffset; //Offset to list of subsets (This also forces the union to 64bits)
+        Uint32* pSubsets;     //Pointer to list of subsets
     };
     union
     {
-        Uint64 FrameInfluenceOffset;  //Offset to list of frame influences (This also forces the union to 64bits)
-        Uint32* pFrameInfluences;      //Pointer to list of frame influences
+        Uint64  FrameInfluenceOffset; //Offset to list of frame influences (This also forces the union to 64bits)
+        Uint32* pFrameInfluences;     //Pointer to list of frame influences
     };
 };
 
 struct DXSDKMESH_SUBSET
 {
     static constexpr size_t MaxSubsetName = 100;
-    char Name[MaxSubsetName];
-    Uint32 MaterialID;
-    Uint32 PrimitiveType;
-    Uint64 IndexStart;
-    Uint64 IndexCount;
-    Uint64 VertexStart;
-    Uint64 VertexCount;
+    char                    Name[MaxSubsetName];
+    Uint32                  MaterialID;
+    Uint32                  PrimitiveType;
+    Uint64                  IndexStart;
+    Uint64                  IndexCount;
+    Uint64                  VertexStart;
+    Uint64                  VertexCount;
 };
 
 struct DXSDKMESH_FRAME
 {
     static constexpr size_t MaxFrameName = 100;
-    char Name[MaxFrameName];
-    Uint32 Mesh;
-    Uint32 ParentFrame;
-    Uint32 ChildFrame;
-    Uint32 SiblingFrame;
-    float4x4 Matrix;
-    Uint32 AnimationDataIndex;    //Used to index which set of keyframes transforms this frame
+    char                    Name[MaxFrameName];
+    Uint32                  Mesh;
+    Uint32                  ParentFrame;
+    Uint32                  ChildFrame;
+    Uint32                  SiblingFrame;
+    float4x4                Matrix;
+    Uint32                  AnimationDataIndex; //Used to index which set of keyframes transforms this frame
 };
 
 struct DXSDKMESH_MATERIAL
 {
     static constexpr size_t MaxMaterialName = 100;
-    char    Name[MaxMaterialName];
+    char                    Name[MaxMaterialName];
 
     // Use MaterialInstancePath
     static constexpr size_t MaxMaterialPath = 260;
-    char    MaterialInstancePath[MaxMaterialPath];
+    char                    MaterialInstancePath[MaxMaterialPath];
 
     // Or fall back to d3d8-type materials
     static constexpr size_t MaxTextureName = 260;
-    char    DiffuseTexture[MaxTextureName];
-    char    NormalTexture[MaxTextureName];
-    char    SpecularTexture[MaxTextureName];
+    char                    DiffuseTexture[MaxTextureName];
+    char                    NormalTexture[MaxTextureName];
+    char                    SpecularTexture[MaxTextureName];
 
     float4 Diffuse;
     float4 Ambient;
     float4 Specular;
     float4 Emissive;
-    float Power;
+    float  Power;
 
     union
     {
-        Uint64 Force64_1;      //Force the union to 64bits
+        Uint64    Force64_1; //Force the union to 64bits
         ITexture* pDiffuseTexture = nullptr;
     };
     union
     {
-        Uint64 Force64_2;      //Force the union to 64bits
+        Uint64    Force64_2; //Force the union to 64bits
         ITexture* pNormalTexture = nullptr;
     };
     union
     {
-        Uint64 Force64_3;      //Force the union to 64bits
+        Uint64    Force64_3; //Force the union to 64bits
         ITexture* pSpecularTexture = nullptr;
     };
 
     union
     {
-        Uint64 Force64_4;      //Force the union to 64bits
+        Uint64        Force64_4; //Force the union to 64bits
         ITextureView* pDiffuseRV = nullptr;
     };
     union
     {
-        Uint64 Force64_5;        //Force the union to 64bits
+        Uint64        Force64_5; //Force the union to 64bits
         ITextureView* pNormalRV = nullptr;
     };
     union
     {
-        Uint64 Force64_6;      //Force the union to 64bits
+        Uint64        Force64_6; //Force the union to 64bits
         ITextureView* pSpecularRV = nullptr;
     };
 };
@@ -292,7 +292,7 @@ struct DXSDKMESH_MATERIAL
 struct SDKANIMATION_FILE_HEADER
 {
     Uint32 Version;
-    Uint8 IsBigEndian;
+    Uint8  IsBigEndian;
     Uint32 FrameTransformType;
     Uint32 NumFrames;
     Uint32 NumAnimationKeys;
@@ -311,10 +311,10 @@ struct SDKANIMATION_DATA
 struct SDKANIMATION_FRAME_DATA
 {
     static constexpr size_t MaxFrameName = 100;
-    char FrameName[MaxFrameName];
+    char                    FrameName[MaxFrameName];
     union
     {
-        Uint64 DataOffset;
+        Uint64             DataOffset;
         SDKANIMATION_DATA* pAnimationData;
     };
 };
@@ -326,96 +326,98 @@ class DXSDKMesh
 public:
     virtual ~DXSDKMesh();
 
-    bool    Create( const Char* szFileName );
-    bool    Create( Uint8* pData, Uint32 DataUint8s );
-    void    LoadGPUResources(const Char* ResourceDirectory, IRenderDevice* pDevice, IDeviceContext* pDeviceCtx);
-    void    Destroy();
+    bool Create(const Char* szFileName);
+    bool Create(Uint8* pData, Uint32 DataUint8s);
+    void LoadGPUResources(const Char* ResourceDirectory, IRenderDevice* pDevice, IDeviceContext* pDeviceCtx);
+    void Destroy();
 
     //Helpers
-    static PRIMITIVE_TOPOLOGY   GetPrimitiveType( DXSDKMESH_PRIMITIVE_TYPE PrimType );
-    VALUE_TYPE                  GetIBFormat( Uint32 iMesh )  const;
-    DXSDKMESH_INDEX_TYPE        GetIndexType( Uint32 iMesh ) const
+    static PRIMITIVE_TOPOLOGY GetPrimitiveType(DXSDKMESH_PRIMITIVE_TYPE PrimType);
+    VALUE_TYPE                GetIBFormat(Uint32 iMesh) const;
+    DXSDKMESH_INDEX_TYPE      GetIndexType(Uint32 iMesh) const
     {
-        return ( DXSDKMESH_INDEX_TYPE ) m_pIndexBufferArray[m_pMeshArray[ iMesh ].IndexBuffer].IndexType;
+        return (DXSDKMESH_INDEX_TYPE)m_pIndexBufferArray[m_pMeshArray[iMesh].IndexBuffer].IndexType;
     }
 
-    Uint32  GetNumMeshes()   const { return m_pMeshHeader ? m_pMeshHeader->NumMeshes        : 0;}
-    Uint32  GetNumMaterials()const { return m_pMeshHeader ? m_pMeshHeader->NumMaterials     : 0;}
-    Uint32  GetNumVBs()      const { return m_pMeshHeader ? m_pMeshHeader->NumVertexBuffers : 0;}
-    Uint32  GetNumIBs()      const { return m_pMeshHeader ? m_pMeshHeader->NumIndexBuffers  : 0;}
+    // clang-format off
+    Uint32 GetNumMeshes()    const { return m_pMeshHeader ? m_pMeshHeader->NumMeshes : 0; }
+    Uint32 GetNumMaterials() const { return m_pMeshHeader ? m_pMeshHeader->NumMaterials : 0; }
+    Uint32 GetNumVBs()       const { return m_pMeshHeader ? m_pMeshHeader->NumVertexBuffers : 0; }
+    Uint32 GetNumIBs()       const { return m_pMeshHeader ? m_pMeshHeader->NumIndexBuffers : 0; }
+    // clang-format on
 
-    const Uint8*              GetRawVerticesAt( Uint32 iVB ) const {return m_ppVertices[iVB];}
-    const Uint8*              GetRawIndicesAt( Uint32 iIB )  const {return m_ppIndices[iIB]; }
-    const DXSDKMESH_MATERIAL& GetMaterial( Uint32 iMaterial )const {return m_pMaterialArray[ iMaterial ];}
+    const Uint8*              GetRawVerticesAt(Uint32 iVB) const { return m_ppVertices[iVB]; }
+    const Uint8*              GetRawIndicesAt(Uint32 iIB) const { return m_ppIndices[iIB]; }
+    const DXSDKMESH_MATERIAL& GetMaterial(Uint32 iMaterial) const { return m_pMaterialArray[iMaterial]; }
 
-    const DXSDKMESH_MESH&     GetMesh( Uint32 iMesh )  const { return m_pMeshArray[ iMesh ];}
-    Uint32              GetNumSubsets( Uint32 iMesh )  const { return m_pMeshArray[ iMesh ].NumSubsets; }
-    const DXSDKMESH_SUBSET& GetSubset( Uint32 iMesh, Uint32 iSubset ) const
+    const DXSDKMESH_MESH&   GetMesh(Uint32 iMesh) const { return m_pMeshArray[iMesh]; }
+    Uint32                  GetNumSubsets(Uint32 iMesh) const { return m_pMeshArray[iMesh].NumSubsets; }
+    const DXSDKMESH_SUBSET& GetSubset(Uint32 iMesh, Uint32 iSubset) const
     {
-        return m_pSubsetArray[ m_pMeshArray[ iMesh ].pSubsets[iSubset] ];
+        return m_pSubsetArray[m_pMeshArray[iMesh].pSubsets[iSubset]];
     }
 
-    Uint32  GetMeshVertexStride( Uint32 iMesh, Uint32 iVB ) const
+    Uint32 GetMeshVertexStride(Uint32 iMesh, Uint32 iVB) const
     {
-        return ( Uint32 )m_pVertexBufferArray[ m_pMeshArray[ iMesh ].VertexBuffers[iVB] ].StrideUint8s;
+        return (Uint32)m_pVertexBufferArray[m_pMeshArray[iMesh].VertexBuffers[iVB]].StrideUint8s;
     }
 
-    Uint32  GetVertexStride( Uint32 iVB ) const
+    Uint32 GetVertexStride(Uint32 iVB) const
     {
-        return ( Uint32 )m_pVertexBufferArray[ iVB ].StrideUint8s;
+        return (Uint32)m_pVertexBufferArray[iVB].StrideUint8s;
     }
 
-    Uint64  GetNumMeshVertices( Uint32 iMesh, Uint32 iVB ) const
+    Uint64 GetNumMeshVertices(Uint32 iMesh, Uint32 iVB) const
     {
-        return m_pVertexBufferArray[ m_pMeshArray[ iMesh ].VertexBuffers[iVB] ].NumVertices;
+        return m_pVertexBufferArray[m_pMeshArray[iMesh].VertexBuffers[iVB]].NumVertices;
     }
 
-    Uint64  GetNumMeshIndices( Uint32 iMesh ) const
+    Uint64 GetNumMeshIndices(Uint32 iMesh) const
     {
-        return m_pIndexBufferArray[ m_pMeshArray[ iMesh ].IndexBuffer ].NumIndices;
+        return m_pIndexBufferArray[m_pMeshArray[iMesh].IndexBuffer].NumIndices;
     }
 
     IBuffer* GetMeshVertexBuffer(Uint32 iMesh, Uint32 iVB)
     {
-        return m_VertexBuffers[m_pMeshArray[ iMesh ].VertexBuffers[iVB]];
+        return m_VertexBuffers[m_pMeshArray[iMesh].VertexBuffers[iVB]];
     }
 
     IBuffer* GetMeshIndexBuffer(Uint32 iMesh)
     {
-        return m_IndexBuffers[ m_pMeshArray[ iMesh ].IndexBuffer];
+        return m_IndexBuffers[m_pMeshArray[iMesh].IndexBuffer];
     }
 
-    const DXSDKMESH_VERTEX_ELEMENT*   VBElements( Uint32 iVB ) const { return m_pVertexBufferArray[0].Decl; }
+    const DXSDKMESH_VERTEX_ELEMENT* VBElements(Uint32 iVB) const { return m_pVertexBufferArray[0].Decl; }
 
     //Uint32                          GetNumFrames();
     //DXSDKMESH_FRAME*                GetFrame( Uint32 iFrame );
     //DXSDKMESH_FRAME*                FindFrame( char* pszName );
 
 protected:
-    bool                            CreateFromFile( const char* szFileName );
+    bool CreateFromFile(const char* szFileName);
 
-    bool                            CreateFromMemory( Uint8* pData,
-                                                      Uint32 DataUint8s );
+    bool CreateFromMemory(Uint8* pData,
+                          Uint32 DataUint8s);
 
-    void                            ComputeBoundingBoxes();
+    void ComputeBoundingBoxes();
 
     //These are the pointers to the two chunks of data loaded in from the mesh file
-    std::vector<Uint8>      m_StaticMeshData;
+    std::vector<Uint8> m_StaticMeshData;
     //Uint8*  m_pAnimationData    = nullptr;
-    std::vector<Uint8*>     m_ppVertices;
-    std::vector<Uint8*>     m_ppIndices;
+    std::vector<Uint8*> m_ppVertices;
+    std::vector<Uint8*> m_ppIndices;
 
     std::vector<RefCntAutoPtr<IBuffer>> m_VertexBuffers;
     std::vector<RefCntAutoPtr<IBuffer>> m_IndexBuffers;
 
     //General mesh info
-    DXSDKMESH_HEADER*                 m_pMeshHeader        = nullptr;
-    DXSDKMESH_VERTEX_BUFFER_HEADER*   m_pVertexBufferArray = nullptr;
-    DXSDKMESH_INDEX_BUFFER_HEADER*    m_pIndexBufferArray  = nullptr;
-    DXSDKMESH_MESH*                   m_pMeshArray         = nullptr;
-    DXSDKMESH_SUBSET*                 m_pSubsetArray       = nullptr;
-    DXSDKMESH_FRAME*                  m_pFrameArray        = nullptr;
-    DXSDKMESH_MATERIAL*               m_pMaterialArray     = nullptr;
+    DXSDKMESH_HEADER*               m_pMeshHeader        = nullptr;
+    DXSDKMESH_VERTEX_BUFFER_HEADER* m_pVertexBufferArray = nullptr;
+    DXSDKMESH_INDEX_BUFFER_HEADER*  m_pIndexBufferArray  = nullptr;
+    DXSDKMESH_MESH*                 m_pMeshArray         = nullptr;
+    DXSDKMESH_SUBSET*               m_pSubsetArray       = nullptr;
+    DXSDKMESH_FRAME*                m_pFrameArray        = nullptr;
+    DXSDKMESH_MATERIAL*             m_pMaterialArray     = nullptr;
 
     // Adjacency information (not part of the m_pStaticMeshData, so it must be created and destroyed separately )
     //DXSDKMESH_INDEX_BUFFER_HEADER* m_pAdjacencyIndexBufferArray = nullptr;
@@ -426,7 +428,6 @@ protected:
     //float4x4*                   m_pBindPoseFrameMatrices    = nullptr;
     //float4x4*                   m_pTransformedFrameMatrices = nullptr;
     //float4x4*                   m_pWorldPoseFrameMatrices   = nullptr;
-
 };
 
-}
\ No newline at end of file
+} // namespace Diligent
diff --git a/AssetLoader/interface/GLTFLoader.h b/AssetLoader/interface/GLTFLoader.h
index f99cdea..7bd263c 100644
--- a/AssetLoader/interface/GLTFLoader.h
+++ b/AssetLoader/interface/GLTFLoader.h
@@ -33,9 +33,11 @@
 
 namespace tinygltf
 {
+
 class Node;
 class Model;
-}
+
+} // namespace tinygltf
 
 namespace Diligent
 {
@@ -44,7 +46,7 @@ namespace GLTF
 {
 
 struct Material
-{		
+{
     enum ALPHA_MODE
     {
         ALPHAMODE_OPAQUE,
@@ -53,17 +55,17 @@ struct Material
     };
     ALPHA_MODE AlphaMode = ALPHAMODE_OPAQUE;
 
-    float AlphaCutoff       = 1.0f;
-    float MetallicFactor    = 1.0f;
-    float RoughnessFactor   = 1.0f;
-    float4 BaseColorFactor  = float4(1.0f, 1.0f, 1.0f, 1.0f);
-    float4 EmissiveFactor   = float4(1.0f, 1.0f, 1.0f, 1.0f);
+    float  AlphaCutoff     = 1.0f;
+    float  MetallicFactor  = 1.0f;
+    float  RoughnessFactor = 1.0f;
+    float4 BaseColorFactor = float4(1.0f, 1.0f, 1.0f, 1.0f);
+    float4 EmissiveFactor  = float4(1.0f, 1.0f, 1.0f, 1.0f);
 
-    RefCntAutoPtr<ITexture>   pBaseColorTexture;
-    RefCntAutoPtr<ITexture>   pMetallicRoughnessTexture;
-    RefCntAutoPtr<ITexture>   pNormalTexture;
-    RefCntAutoPtr<ITexture>   pOcclusionTexture;
-    RefCntAutoPtr<ITexture>   pEmissiveTexture;
+    RefCntAutoPtr<ITexture> pBaseColorTexture;
+    RefCntAutoPtr<ITexture> pMetallicRoughnessTexture;
+    RefCntAutoPtr<ITexture> pNormalTexture;
+    RefCntAutoPtr<ITexture> pOcclusionTexture;
+    RefCntAutoPtr<ITexture> pEmissiveTexture;
 
     struct TextureCoordinateSets
     {
@@ -80,8 +82,8 @@ struct Material
     {
         RefCntAutoPtr<ITexture> pSpecularGlossinessTexture;
         RefCntAutoPtr<ITexture> pDiffuseTexture;
-        float4 DiffuseFactor  = float4(1.0f, 1.0f, 1.0f, 1.0f);
-        float3 SpecularFactor = float3(1.0f, 1.0f, 1.0f);
+        float4                  DiffuseFactor  = float4(1.0f, 1.0f, 1.0f, 1.0f);
+        float3                  SpecularFactor = float3(1.0f, 1.0f, 1.0f);
     };
     Extension extension;
 
@@ -93,14 +95,14 @@ struct Material
     PbrWorkflow workflow = PbrWorkflow::MetallicRoughness;
 };
 
-    
+
 struct Primitive
 {
-    Uint32 FirstIndex   = 0;
-    Uint32 IndexCount   = 0;
-    Uint32 VertexCount  = 0;
+    Uint32    FirstIndex  = 0;
+    Uint32    IndexCount  = 0;
+    Uint32    VertexCount = 0;
     Material& material;
-    bool hasIndices;
+    bool      hasIndices;
 
     BoundBox BB;
     bool     IsValidBB = false;
@@ -109,18 +111,18 @@ struct Primitive
               Uint32    _IndexCount,
               Uint32    _VertexCount,
               Material& _material) :
-        FirstIndex  (_FirstIndex),
-        IndexCount  (_IndexCount),
-        VertexCount (_VertexCount),
-        material    (_material),
-        hasIndices  (_IndexCount > 0)
+        FirstIndex{_FirstIndex},
+        IndexCount{_IndexCount},
+        VertexCount{_VertexCount},
+        material{_material},
+        hasIndices{_IndexCount > 0}
     {
     }
 
     void SetBoundingBox(const float3& min, const float3& max)
     {
-        BB.Min = min;
-        BB.Max = max;
+        BB.Min    = min;
+        BB.Max    = max;
         IsValidBB = true;
     }
 };
@@ -141,7 +143,7 @@ struct Mesh
 
         float4x4 matrix;
         float4x4 jointMatrix[MaxNumJoints] = {};
-        int      jointcount = 0;
+        int      jointcount                = 0;
     };
 
     TransformData Transforms;
@@ -155,7 +157,7 @@ struct Node;
 struct Skin
 {
     std::string           Name;
-    Node*                 pSkeletonRoot       = nullptr;
+    Node*                 pSkeletonRoot = nullptr;
     std::vector<float4x4> InverseBindMatrices;
     std::vector<Node*>    Joints;
 };
@@ -163,24 +165,26 @@ struct Skin
 
 struct Node
 {
-    std::string                         Name;
-    Node*                               Parent      = nullptr;
-    Uint32                              Index;
-    std::vector<std::unique_ptr<Node>>  Children;
-    float4x4                            Matrix;
-    std::unique_ptr<Mesh>               _Mesh;
-    Skin*                               _Skin       = nullptr;
-    Int32                               SkinIndex   = -1;
-    float3                              Translation;
-    float3                              Scale       = float3(1.0f, 1.0f, 1.0f);
-    Quaternion                          Rotation;
-    BoundBox                            BVH;
-    BoundBox                            AABB;
-    bool                                IsValidBVH  = false;
-
-    float4x4 LocalMatrix()const;
-    float4x4 GetMatrix()const;
-    void Update();
+    std::string Name;
+    Node*       Parent = nullptr;
+    Uint32      Index;
+
+    std::vector<std::unique_ptr<Node>> Children;
+
+    float4x4              Matrix;
+    std::unique_ptr<Mesh> _Mesh;
+    Skin*                 _Skin     = nullptr;
+    Int32                 SkinIndex = -1;
+    float3                Translation;
+    float3                Scale = float3(1.0f, 1.0f, 1.0f);
+    Quaternion            Rotation;
+    BoundBox              BVH;
+    BoundBox              AABB;
+    bool                  IsValidBVH = false;
+
+    float4x4 LocalMatrix() const;
+    float4x4 GetMatrix() const;
+    void     Update();
 };
 
 
@@ -193,8 +197,8 @@ struct AnimationChannel
         SCALE
     };
     PATH_TYPE PathType;
-    Node*     node          = nullptr;
-    Uint32    SamplerIndex  = static_cast<Uint32>(-1);
+    Node*     node         = nullptr;
+    Uint32    SamplerIndex = static_cast<Uint32>(-1);
 };
 
 
@@ -206,16 +210,16 @@ struct AnimationSampler
         STEP,
         CUBICSPLINE
     };
-    INTERPOLATION_TYPE      Interpolation;
-    std::vector<float>      Inputs;
-    std::vector<float4>     OutputsVec4;
+    INTERPOLATION_TYPE  Interpolation;
+    std::vector<float>  Inputs;
+    std::vector<float4> OutputsVec4;
 };
 
 struct Animation
 {
-    std::string                         Name;
-    std::vector<AnimationSampler>       Samplers;
-    std::vector<AnimationChannel>       Channels;
+    std::string                   Name;
+    std::vector<AnimationSampler> Samplers;
+    std::vector<AnimationChannel> Channels;
 
     float Start = std::numeric_limits<float>::max();
     float End   = std::numeric_limits<float>::min();
@@ -247,46 +251,45 @@ struct Model
 
     std::vector<RefCntAutoPtr<ITexture>> Textures;
     std::vector<RefCntAutoPtr<ISampler>> TextureSamplers;
-    std::vector<Material>       Materials;
-    std::vector<Animation>      Animations;
-    std::vector<std::string>    Extensions;
+    std::vector<Material>                Materials;
+    std::vector<Animation>               Animations;
+    std::vector<std::string>             Extensions;
 
     struct Dimensions
     {
-        float3 min = float3(+FLT_MAX, +FLT_MAX, +FLT_MAX);
-        float3 max = float3(-FLT_MAX, -FLT_MAX, -FLT_MAX);
+        float3 min = float3{+FLT_MAX, +FLT_MAX, +FLT_MAX};
+        float3 max = float3{-FLT_MAX, -FLT_MAX, -FLT_MAX};
     } dimensions;
 
-    Model(IRenderDevice* pDevice, IDeviceContext* pContext, const std::string &filename);
+    Model(IRenderDevice* pDevice, IDeviceContext* pContext, const std::string& filename);
 
     void UpdateAnimation(Uint32 index, float time);
 
 private:
-    void LoadFromFile(IRenderDevice* pDevice, IDeviceContext* pContext, const std::string &filename);
-    void LoadNode(IRenderDevice*            pDevice,
-                  Node*                     parent,
-                  const tinygltf::Node&     gltf_node,
-                  uint32_t                  nodeIndex,
-                  const tinygltf::Model&    gltf_model,
-                  std::vector<uint32_t>&    indexBuffer,
-                  std::vector<Vertex>&      vertexBuffer);
+    void LoadFromFile(IRenderDevice* pDevice, IDeviceContext* pContext, const std::string& filename);
+    void LoadNode(IRenderDevice*         pDevice,
+                  Node*                  parent,
+                  const tinygltf::Node&  gltf_node,
+                  uint32_t               nodeIndex,
+                  const tinygltf::Model& gltf_model,
+                  std::vector<uint32_t>& indexBuffer,
+                  std::vector<Vertex>&   vertexBuffer);
 
     void LoadSkins(const tinygltf::Model& gltf_model);
 
-    void LoadTextures(IRenderDevice*          pDevice,
-                      IDeviceContext*         pCtx,
-                      const tinygltf::Model&  gltf_model);
+    void LoadTextures(IRenderDevice*         pDevice,
+                      IDeviceContext*        pCtx,
+                      const tinygltf::Model& gltf_model);
 
-    void LoadTextureSamplers(IRenderDevice* pDevice, const tinygltf::Model& gltf_model);
-    void LoadMaterials(const tinygltf::Model& gltf_model);
-    void LoadAnimations(const tinygltf::Model& gltf_model);
-    void CalculateBoundingBox(Node* node, const Node* parent);
-    void GetSceneDimensions();
+    void  LoadTextureSamplers(IRenderDevice* pDevice, const tinygltf::Model& gltf_model);
+    void  LoadMaterials(const tinygltf::Model& gltf_model);
+    void  LoadAnimations(const tinygltf::Model& gltf_model);
+    void  CalculateBoundingBox(Node* node, const Node* parent);
+    void  GetSceneDimensions();
     Node* FindNode(Node* parent, Uint32 index);
     Node* NodeFromIndex(uint32_t index);
 };
 
-
 } // namespace GLTF
 
 } // namespace Diligent