A number of minor updates

20 files changed, 303 insertions, 287 deletions

diff --git a/Graphics/GraphicsAccessories/src/GraphicsAccessories.cpp b/Graphics/GraphicsAccessories/src/GraphicsAccessories.cpp
index 0617ca59..dd1f2c78 100644
--- a/Graphics/GraphicsAccessories/src/GraphicsAccessories.cpp
+++ b/Graphics/GraphicsAccessories/src/GraphicsAccessories.cpp
@@ -869,7 +869,7 @@ static const Char* GetSingleCPUAccessFlagString(Uint32 CPUAccessFlag)
         // clang-format off
 #define CPU_ACCESS_FLAG_STR_CASE(Flag) case Flag: return #Flag;
         CPU_ACCESS_FLAG_STR_CASE( CPU_ACCESS_READ )
-	    CPU_ACCESS_FLAG_STR_CASE( CPU_ACCESS_WRITE  )
+        CPU_ACCESS_FLAG_STR_CASE( CPU_ACCESS_WRITE  )
 #undef  CPU_ACCESS_FLAG_STR_CASE
         // clang-format on
         default: UNEXPECTED("Unexpected CPU access flag ", CPUAccessFlag); return "";
@@ -1205,7 +1205,6 @@ if ( (State & ExclusiveState) != 0 && (State & ~ExclusiveState) != 0 )\
     VERIFY_EXCLUSIVE_STATE(RESOURCE_STATE_COPY_DEST);
     VERIFY_EXCLUSIVE_STATE(RESOURCE_STATE_RESOLVE_DEST);
     VERIFY_EXCLUSIVE_STATE(RESOURCE_STATE_PRESENT);
-    VERIFY_EXCLUSIVE_STATE(RESOURCE_STATE_BUILD_AS_READ);
     VERIFY_EXCLUSIVE_STATE(RESOURCE_STATE_BUILD_AS_WRITE);
     VERIFY_EXCLUSIVE_STATE(RESOURCE_STATE_RAY_TRACING);
 #undef VERIFY_EXCLUSIVE_STATE
diff --git a/Graphics/GraphicsEngine/include/BottomLevelASBase.hpp b/Graphics/GraphicsEngine/include/BottomLevelASBase.hpp
index 9f37fb3f..41f2fdf3 100644
--- a/Graphics/GraphicsEngine/include/BottomLevelASBase.hpp
+++ b/Graphics/GraphicsEngine/include/BottomLevelASBase.hpp
@@ -133,6 +133,7 @@ public:
             }
             this->m_Desc.pBoxes = pBoxes.release();
         }
+        VERIFY_EXPR(m_StringPool.GetRemainingSize() == 0);
     }
 
     ~BottomLevelASBase()
diff --git a/Graphics/GraphicsEngine/include/DeviceContextBase.hpp b/Graphics/GraphicsEngine/include/DeviceContextBase.hpp
index 0d98bae3..829416d2 100644
--- a/Graphics/GraphicsEngine/include/DeviceContextBase.hpp
+++ b/Graphics/GraphicsEngine/include/DeviceContextBase.hpp
@@ -1811,10 +1811,7 @@ void DeviceContextBase<BaseInterface, ImplementationTraits>::
     DEV_CHECK_ERR(Barrier.NewState != RESOURCE_STATE_UNKNOWN, "New resource state can't be unknown");
     RESOURCE_STATE OldState = RESOURCE_STATE_UNKNOWN;
 
-    RefCntAutoPtr<ITexture> pTexture{Barrier.pResource, IID_Texture};
-    RefCntAutoPtr<IBuffer>  pBuffer{Barrier.pResource, IID_Buffer};
-
-    if (pTexture)
+    if (RefCntAutoPtr<ITexture> pTexture{Barrier.pResource, IID_Texture})
     {
         const auto& TexDesc = pTexture->GetDesc();
 
@@ -1850,7 +1847,7 @@ void DeviceContextBase<BaseInterface, ImplementationTraits>::
                           "Failed to transition texture '", TexDesc.Name, "': only whole resources can be transitioned on this device");
         }
     }
-    else if (pBuffer)
+    else if (RefCntAutoPtr<IBuffer> pBuffer{Barrier.pResource, IID_Buffer})
     {
         const auto& BuffDesc = pBuffer->GetDesc();
         DEV_CHECK_ERR(VerifyResourceStates(Barrier.NewState, false), "Invlaid new state specified for buffer '", BuffDesc.Name, "'");
@@ -1858,6 +1855,14 @@ void DeviceContextBase<BaseInterface, ImplementationTraits>::
         DEV_CHECK_ERR(OldState != RESOURCE_STATE_UNKNOWN, "The state of buffer '", BuffDesc.Name, "' is unknown to the engine and is not explicitly specified in the barrier");
         DEV_CHECK_ERR(VerifyResourceStates(OldState, false), "Invlaid old state specified for buffer '", BuffDesc.Name, "'");
     }
+    else if (RefCntAutoPtr<IBottomLevelAS> pBLAS{Barrier.pResource, IID_BottomLevelAS})
+    {
+        // AZ TODO
+    }
+    else if (RefCntAutoPtr<ITopLevelAS> pTLAS{Barrier.pResource, IID_TopLevelAS})
+    {
+        // AZ TODO
+    }
     else
     {
         UNEXPECTED("unsupported resource type");
@@ -2147,7 +2152,7 @@ bool DeviceContextBase<BaseInterface, ImplementationTraits>::BuildTLAS(const TLA
 
     if (Attribs.pInstanceBuffer == nullptr)
     {
-        LOG_ERROR_MESSAGE("IDeviceContext::BuildTLAS: pInstanceaBuffer must not be null");
+        LOG_ERROR_MESSAGE("IDeviceContext::BuildTLAS: pInstanceBuffer must not be null");
         return false;
     }
 
diff --git a/Graphics/GraphicsEngine/interface/DeviceContext.h b/Graphics/GraphicsEngine/interface/DeviceContext.h
index 04ff3030..35e17e91 100644
--- a/Graphics/GraphicsEngine/interface/DeviceContext.h
+++ b/Graphics/GraphicsEngine/interface/DeviceContext.h
@@ -743,6 +743,7 @@ DILIGENT_TYPED_ENUM(RAYTRACING_INSTANCE_FLAGS, Uint8)
 
     RAYTRACING_INSTANCE_FLAGS_LAST = 0x08
 };
+DEFINE_FLAG_ENUM_OPERATORS(RAYTRACING_INSTANCE_FLAGS)
 
 /// AZ TODO
 DILIGENT_TYPED_ENUM(COPY_AS_MODE, Uint8)
@@ -1145,7 +1146,7 @@ struct StateTransitionDesc
                         RESOURCE_STATE _OldState,
                         RESOURCE_STATE _NewState,
                         bool           _UpdateState)noexcept : 
-        pResource           {static_cast<IDeviceObject*>(_pBuffer)},
+        pResource           {_pBuffer    },
         OldState            {_OldState   },
         NewState            {_NewState   },
         UpdateResourceState {_UpdateState}
@@ -1155,7 +1156,7 @@ struct StateTransitionDesc
                         RESOURCE_STATE  _OldState,
                         RESOURCE_STATE  _NewState,
                         bool            _UpdateState)noexcept : 
-        pResource           {static_cast<IDeviceObject*>(_pBLAS)},
+        pResource           {_pBLAS      },
         OldState            {_OldState   },
         NewState            {_NewState   },
         UpdateResourceState {_UpdateState}
@@ -1165,7 +1166,7 @@ struct StateTransitionDesc
                         RESOURCE_STATE  _OldState,
                         RESOURCE_STATE  _NewState,
                         bool            _UpdateState)noexcept : 
-        pResource           {static_cast<IDeviceObject*>(_pTLAS)},
+        pResource           {_pTLAS      },
         OldState            {_OldState   },
         NewState            {_NewState   },
         UpdateResourceState {_UpdateState}
diff --git a/Graphics/GraphicsEngine/interface/GraphicsTypes.h b/Graphics/GraphicsEngine/interface/GraphicsTypes.h
index 093039bd..00d91725 100644
--- a/Graphics/GraphicsEngine/interface/GraphicsTypes.h
+++ b/Graphics/GraphicsEngine/interface/GraphicsTypes.h
@@ -83,7 +83,8 @@ DILIGENT_TYPED_ENUM(BIND_FLAGS, Uint32)
     BIND_UNORDERED_ACCESS	 = 0x80L,  ///< A buffer or a texture can be bound as an unordered access view
     BIND_INDIRECT_DRAW_ARGS	 = 0x100L, ///< A buffer can be bound as the source buffer for indirect draw commands
     BIND_INPUT_ATTACHMENT    = 0x200L, ///< A texture can be used as render pass input attachment
-    BIND_RAY_TRACING         = 0x400L, ///< A buffer can be used as scratch buffer for acceleration structure building.
+    BIND_RAY_TRACING         = 0x400L, ///< A buffer can be used as a scratch buffer or as the source of primitive data 
+                                       ///  for acceleration structure building
     BIND_FLAGS_LAST          = 0x400L
 };
 DEFINE_FLAG_ENUM_OPERATORS(BIND_FLAGS)
diff --git a/Graphics/GraphicsEngine/interface/PipelineState.h b/Graphics/GraphicsEngine/interface/PipelineState.h
index 3afa83f2..4115a9d1 100644
--- a/Graphics/GraphicsEngine/interface/PipelineState.h
+++ b/Graphics/GraphicsEngine/interface/PipelineState.h
@@ -223,11 +223,11 @@ struct RayTracingGeneralShaderGroup
 
     /// AZ TODO
     IShader*    pShader DEFAULT_INITIALIZER(nullptr);
-    
+
 #if DILIGENT_CPP_INTERFACE
     RayTracingGeneralShaderGroup() noexcept
     {}
-    
+
     RayTracingGeneralShaderGroup(const char* _Name,
                                  IShader*    _pShader) noexcept:
         Name   {_Name   },
@@ -248,11 +248,11 @@ struct RayTracingTriangleHitShaderGroup
 
     /// AZ TODO
     IShader*    pAnyHitShader     DEFAULT_INITIALIZER(nullptr); // can be null
-    
+
 #if DILIGENT_CPP_INTERFACE
     RayTracingTriangleHitShaderGroup() noexcept
     {}
-    
+
     RayTracingTriangleHitShaderGroup(const char* _Name,
                                      IShader*    _pClosestHitShader,
                                      IShader*    _pAnyHitShader    = nullptr) noexcept:
@@ -278,11 +278,11 @@ struct RayTracingProceduralHitShaderGroup
 
     /// AZ TODO
     IShader*    pAnyHitShader       DEFAULT_INITIALIZER(nullptr); // can be null
-    
+
 #if DILIGENT_CPP_INTERFACE
     RayTracingProceduralHitShaderGroup() noexcept
     {}
-    
+
     RayTracingProceduralHitShaderGroup(const char* _Name,
                                        IShader*    _pIntersectionShader,
                                        IShader*    _pClosestHitShader  = nullptr,
diff --git a/Graphics/GraphicsEngineD3D11/src/DeviceContextD3D11Impl.cpp b/Graphics/GraphicsEngineD3D11/src/DeviceContextD3D11Impl.cpp
index e42dd2d0..54c9b3c4 100755
--- a/Graphics/GraphicsEngineD3D11/src/DeviceContextD3D11Impl.cpp
+++ b/Graphics/GraphicsEngineD3D11/src/DeviceContextD3D11Impl.cpp
@@ -2167,8 +2167,7 @@ void DeviceContextD3D11Impl::TransitionResourceStates(Uint32 BarrierCount, State
         }
         VERIFY(Barrier.TransitionType == STATE_TRANSITION_TYPE_IMMEDIATE || Barrier.TransitionType == STATE_TRANSITION_TYPE_END, "Unexpected barrier type");
 
-        RefCntAutoPtr<TextureBaseD3D11> pTexture{Barrier.pResource, IID_TextureD3D11};
-        if (pTexture)
+        if (RefCntAutoPtr<TextureBaseD3D11> pTexture{Barrier.pResource, IID_TextureD3D11})
         {
             auto OldState = Barrier.OldState;
             if (OldState == RESOURCE_STATE_UNKNOWN)
@@ -2218,11 +2217,8 @@ void DeviceContextD3D11Impl::TransitionResourceStates(Uint32 BarrierCount, State
             {
                 pTexture->SetState(Barrier.NewState);
             }
-            continue;
         }
-
-        RefCntAutoPtr<BufferD3D11Impl> pBuffer{Barrier.pResource, IID_BufferD3D11};
-        if (pBuffer)
+        else if (RefCntAutoPtr<BufferD3D11Impl> pBuffer{Barrier.pResource, IID_BufferD3D11})
         {
             auto OldState = Barrier.OldState;
             if (OldState == RESOURCE_STATE_UNKNOWN)
@@ -2262,10 +2258,11 @@ void DeviceContextD3D11Impl::TransitionResourceStates(Uint32 BarrierCount, State
             {
                 pBuffer->SetState(Barrier.NewState);
             }
-            continue;
         }
-
-        UNEXPECTED("unsupported resource type");
+        else
+        {
+            UNEXPECTED("The type of resource '", Barrier.pResource->GetDesc().Name, "' is not support in D3D11");
+        }
     }
 }
 
diff --git a/Graphics/GraphicsEngineD3D12/src/CommandContext.cpp b/Graphics/GraphicsEngineD3D12/src/CommandContext.cpp
index 6bc55ac3..4285e11a 100644
--- a/Graphics/GraphicsEngineD3D12/src/CommandContext.cpp
+++ b/Graphics/GraphicsEngineD3D12/src/CommandContext.cpp
@@ -171,9 +171,9 @@ void CommandContext::TransitionResource(const StateTransitionDesc& Barrier)
     RESOURCE_STATE                        OldState       = RESOURCE_STATE_UNKNOWN;
     ID3D12Resource*                       pd3d12Resource = nullptr;
     RefCntAutoPtr<TextureD3D12Impl>       pTextureD3D12Impl{Barrier.pResource, IID_TextureD3D12};
-    RefCntAutoPtr<BufferD3D12Impl>        pBufferD3D12Impl{Barrier.pResource, IID_BufferD3D12};
-    RefCntAutoPtr<BottomLevelASD3D12Impl> pBLASD3D12Impl{Barrier.pResource, IID_BottomLevelASD3D12};
-    RefCntAutoPtr<TopLevelASD3D12Impl>    pTLASD3D12Impl{Barrier.pResource, IID_TopLevelASD3D12};
+    RefCntAutoPtr<BufferD3D12Impl>        pBufferD3D12Impl{pTextureD3D12Impl ? nullptr : Barrier.pResource, IID_BufferD3D12};
+    RefCntAutoPtr<BottomLevelASD3D12Impl> pBLASD3D12Impl{pBufferD3D12Impl ? nullptr : Barrier.pResource, IID_BottomLevelASD3D12};
+    RefCntAutoPtr<TopLevelASD3D12Impl>    pTLASD3D12Impl{pBLASD3D12Impl ? nullptr : Barrier.pResource, IID_TopLevelASD3D12};
 
     if (pTextureD3D12Impl)
     {
@@ -324,9 +324,8 @@ void CommandContext::TransitionResource(const StateTransitionDesc& Barrier)
         }
     }
 
-    if ((OldState == RESOURCE_STATE_UNORDERED_ACCESS && Barrier.NewState == RESOURCE_STATE_UNORDERED_ACCESS) ||
-        (OldState == RESOURCE_STATE_BUILD_AS_WRITE && Barrier.NewState == RESOURCE_STATE_BUILD_AS_WRITE) ||
-        (OldState == RESOURCE_STATE_RAY_TRACING && Barrier.NewState == RESOURCE_STATE_RAY_TRACING))
+    if ((OldState == RESOURCE_STATE_UNORDERED_ACCESS || OldState == RESOURCE_STATE_BUILD_AS_WRITE) &&
+        (Barrier.NewState == RESOURCE_STATE_UNORDERED_ACCESS || Barrier.NewState == RESOURCE_STATE_BUILD_AS_WRITE))
     {
         DEV_CHECK_ERR(Barrier.TransitionType == STATE_TRANSITION_TYPE_IMMEDIATE, "UAV barriers must not be split");
         InsertUAVBarrier(pd3d12Resource);
diff --git a/Graphics/GraphicsEngineD3D12/src/D3D12TypeConversions.cpp b/Graphics/GraphicsEngineD3D12/src/D3D12TypeConversions.cpp
index ddab5096..a6d6963e 100644
--- a/Graphics/GraphicsEngineD3D12/src/D3D12TypeConversions.cpp
+++ b/Graphics/GraphicsEngineD3D12/src/D3D12TypeConversions.cpp
@@ -612,22 +612,21 @@ D3D12_RAYTRACING_GEOMETRY_FLAGS GeometryFlagsToD3D12RTGeometryFlags(RAYTRACING_G
     static_assert(RAYTRACING_GEOMETRY_FLAGS_LAST == RAYTRACING_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION,
                   "Please update the switch below to handle the new ray tracing geometry flag");
 
-    Uint32 Result = 0;
-    for (Uint32 Bit = 1; Bit <= Flags; Bit <<= 1)
+    D3D12_RAYTRACING_GEOMETRY_FLAGS Result = D3D12_RAYTRACING_GEOMETRY_FLAG_NONE;
+    while (Flags != RAYTRACING_GEOMETRY_NONE)
     {
-        if ((Flags & Bit) != Bit)
-            continue;
-
-        switch (static_cast<RAYTRACING_GEOMETRY_FLAGS>(Bit))
+        auto FlagBit = static_cast<RAYTRACING_GEOMETRY_FLAGS>(1 << PlatformMisc::GetLSB(Uint32{Flags}));
+        switch (FlagBit)
         {
             // clang-format off
-            case RAYTRACING_GEOMETRY_OPAQUE:                          Result |= D3D12_RAYTRACING_GEOMETRY_FLAG_OPAQUE; break;
+            case RAYTRACING_GEOMETRY_OPAQUE:                          Result |= D3D12_RAYTRACING_GEOMETRY_FLAG_OPAQUE;                         break;
             case RAYTRACING_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION: Result |= D3D12_RAYTRACING_GEOMETRY_FLAG_NO_DUPLICATE_ANYHIT_INVOCATION; break;
             // clang-format on
             default: UNEXPECTED("unknown geometry flag");
         }
+        Flags &= ~FlagBit;
     }
-    return static_cast<D3D12_RAYTRACING_GEOMETRY_FLAGS>(Result);
+    return Result;
 }
 
 D3D12_RAYTRACING_INSTANCE_FLAGS InstanceFlagsToD3D12RTInstanceFlags(RAYTRACING_INSTANCE_FLAGS Flags)
@@ -635,24 +634,23 @@ D3D12_RAYTRACING_INSTANCE_FLAGS InstanceFlagsToD3D12RTInstanceFlags(RAYTRACING_I
     static_assert(RAYTRACING_INSTANCE_FLAGS_LAST == RAYTRACING_INSTANCE_FORCE_NO_OPAQUE,
                   "Please update the switch below to handle the new ray tracing instance flag");
 
-    Uint32 Result = 0;
-    for (Uint32 Bit = 1; Bit <= Flags; Bit <<= 1)
+    D3D12_RAYTRACING_INSTANCE_FLAGS Result = D3D12_RAYTRACING_INSTANCE_FLAG_NONE;
+    while (Flags != RAYTRACING_INSTANCE_NONE)
     {
-        if ((Flags & Bit) != Bit)
-            continue;
-
-        switch (static_cast<RAYTRACING_INSTANCE_FLAGS>(Bit))
+        auto FlagBit = static_cast<RAYTRACING_INSTANCE_FLAGS>(1 << PlatformMisc::GetLSB(Uint32{Flags}));
+        switch (FlagBit)
         {
             // clang-format off
-            case RAYTRACING_INSTANCE_TRIANGLE_FACING_CULL_DISABLE:    Result |= D3D12_RAYTRACING_INSTANCE_FLAG_TRIANGLE_CULL_DISABLE ; break;
-            case RAYTRACING_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE: Result |= D3D12_RAYTRACING_INSTANCE_FLAG_TRIANGLE_FRONT_COUNTERCLOCKWISE ; break;
-            case RAYTRACING_INSTANCE_FORCE_OPAQUE:                    Result |= D3D12_RAYTRACING_INSTANCE_FLAG_FORCE_OPAQUE ; break;
-            case RAYTRACING_INSTANCE_FORCE_NO_OPAQUE:                 Result |= D3D12_RAYTRACING_INSTANCE_FLAG_FORCE_NON_OPAQUE ; break;
+            case RAYTRACING_INSTANCE_TRIANGLE_FACING_CULL_DISABLE:    Result |= D3D12_RAYTRACING_INSTANCE_FLAG_TRIANGLE_CULL_DISABLE;           break;
+            case RAYTRACING_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE: Result |= D3D12_RAYTRACING_INSTANCE_FLAG_TRIANGLE_FRONT_COUNTERCLOCKWISE; break;
+            case RAYTRACING_INSTANCE_FORCE_OPAQUE:                    Result |= D3D12_RAYTRACING_INSTANCE_FLAG_FORCE_OPAQUE;                    break;
+            case RAYTRACING_INSTANCE_FORCE_NO_OPAQUE:                 Result |= D3D12_RAYTRACING_INSTANCE_FLAG_FORCE_NON_OPAQUE;                break;
             // clang-format on
             default: UNEXPECTED("unknown instance flag");
         }
+        Flags &= ~FlagBit;
     }
-    return static_cast<D3D12_RAYTRACING_INSTANCE_FLAGS>(Result);
+    return Result;
 }
 
 } // namespace Diligent
diff --git a/Graphics/GraphicsEngineD3D12/src/DeviceContextD3D12Impl.cpp b/Graphics/GraphicsEngineD3D12/src/DeviceContextD3D12Impl.cpp
index 95025c4c..3cd896ac 100644
--- a/Graphics/GraphicsEngineD3D12/src/DeviceContextD3D12Impl.cpp
+++ b/Graphics/GraphicsEngineD3D12/src/DeviceContextD3D12Impl.cpp
@@ -2279,9 +2279,9 @@ void DeviceContextD3D12Impl::BuildBLAS(const BLASBuildAttribs& Attribs)
     if (!TDeviceContextBase::BuildBLAS(Attribs, 0))
         return;
 
-    auto* pBLASD12    = ValidatedCast<BottomLevelASD3D12Impl>(Attribs.pBLAS);
-    auto* pScratchD12 = ValidatedCast<BufferD3D12Impl>(Attribs.pScratchBuffer);
-    auto& BLASDesc    = pBLASD12->GetDesc();
+    auto* const pBLASD12    = ValidatedCast<BottomLevelASD3D12Impl>(Attribs.pBLAS);
+    auto* const pScratchD12 = ValidatedCast<BufferD3D12Impl>(Attribs.pScratchBuffer);
+    const auto& BLASDesc    = pBLASD12->GetDesc();
 
     auto&       CmdCtx = GetCmdContext();
     const char* OpName = "Build BottomLevelAS (DeviceContextD3D12Impl::BuildBLAS)";
@@ -2298,54 +2298,54 @@ void DeviceContextD3D12Impl::BuildBLAS(const BLASBuildAttribs& Attribs)
 
         for (Uint32 i = 0; i < Attribs.TriangleDataCount; ++i)
         {
-            auto&  src = Attribs.pTriangleData[i];
-            Uint32 j   = pBLASD12->GetGeometryIndex(src.GeometryName);
-            auto&  dst = Geometries.data()[j];
-            auto&  tri = dst.Triangles;
+            const auto& SrcTris   = Attribs.pTriangleData[i];
+            Uint32      GeoIdx    = pBLASD12->GetGeometryIndex(SrcTris.GeometryName);
+            auto&       d3d12Geo  = Geometries[GeoIdx];
+            auto&       d3d12Tris = d3d12Geo.Triangles;
 
-            if (j >= Geometries.size())
+            if (GeoIdx >= Geometries.size())
             {
                 UNEXPECTED("Failed to find geometry by name");
                 continue;
             }
 
-            dst.Type  = D3D12_RAYTRACING_GEOMETRY_TYPE_TRIANGLES;
-            dst.Flags = GeometryFlagsToD3D12RTGeometryFlags(src.Flags);
+            d3d12Geo.Type  = D3D12_RAYTRACING_GEOMETRY_TYPE_TRIANGLES;
+            d3d12Geo.Flags = GeometryFlagsToD3D12RTGeometryFlags(SrcTris.Flags);
 
-            auto* pVB                      = ValidatedCast<BufferD3D12Impl>(src.pVertexBuffer);
-            tri.VertexFormat               = TypeToDXGI_Format(src.VertexValueType, src.VertexComponentCount, src.VertexValueType < VT_FLOAT16);
-            tri.VertexCount                = src.VertexCount;
-            tri.VertexBuffer.StartAddress  = pVB->GetGPUAddress() + src.VertexOffset;
-            tri.VertexBuffer.StrideInBytes = src.VertexStride;
+            auto* const pVB                      = ValidatedCast<BufferD3D12Impl>(SrcTris.pVertexBuffer);
+            d3d12Tris.VertexFormat               = TypeToDXGI_Format(SrcTris.VertexValueType, SrcTris.VertexComponentCount, SrcTris.VertexValueType < VT_FLOAT16);
+            d3d12Tris.VertexCount                = SrcTris.VertexCount;
+            d3d12Tris.VertexBuffer.StartAddress  = pVB->GetGPUAddress() + SrcTris.VertexOffset;
+            d3d12Tris.VertexBuffer.StrideInBytes = SrcTris.VertexStride;
 
-            if (src.pIndexBuffer)
+            if (SrcTris.pIndexBuffer)
             {
-                auto* pIB       = ValidatedCast<BufferD3D12Impl>(src.pIndexBuffer);
-                tri.IndexBuffer = pIB->GetGPUAddress() + src.IndexOffset;
-                tri.IndexCount  = src.IndexCount;
-                tri.IndexFormat = ValueTypeToIndexType(src.IndexType);
+                auto* const pIB       = ValidatedCast<BufferD3D12Impl>(SrcTris.pIndexBuffer);
+                d3d12Tris.IndexBuffer = pIB->GetGPUAddress() + SrcTris.IndexOffset;
+                d3d12Tris.IndexCount  = SrcTris.IndexCount;
+                d3d12Tris.IndexFormat = ValueTypeToIndexType(SrcTris.IndexType);
 
                 TransitionOrVerifyBufferState(CmdCtx, *pIB, Attribs.GeometryTransitionMode, RESOURCE_STATE_BUILD_AS_READ, OpName);
             }
             else
             {
-                tri.IndexFormat = DXGI_FORMAT_UNKNOWN;
-                tri.IndexBuffer = 0;
+                d3d12Tris.IndexFormat = DXGI_FORMAT_UNKNOWN;
+                d3d12Tris.IndexBuffer = 0;
             }
 
-            if (src.pTransformBuffer)
+            if (SrcTris.pTransformBuffer)
             {
-                VERIFY_EXPR(BLASDesc.pTriangles[j].AllowsTransforms);
+                VERIFY_EXPR(BLASDesc.pTriangles[GeoIdx].AllowsTransforms);
 
-                auto* pTB        = ValidatedCast<BufferD3D12Impl>(src.pTransformBuffer);
-                tri.Transform3x4 = pTB->GetGPUAddress() + src.TransformBufferOffset;
+                auto* const pTB        = ValidatedCast<BufferD3D12Impl>(SrcTris.pTransformBuffer);
+                d3d12Tris.Transform3x4 = pTB->GetGPUAddress() + SrcTris.TransformBufferOffset;
 
                 TransitionOrVerifyBufferState(CmdCtx, *pTB, Attribs.GeometryTransitionMode, RESOURCE_STATE_BUILD_AS_READ, OpName);
             }
             else
             {
-                VERIFY_EXPR(!BLASDesc.pTriangles[j].AllowsTransforms);
-                tri.Transform3x4 = 0;
+                VERIFY_EXPR(!BLASDesc.pTriangles[GeoIdx].AllowsTransforms);
+                d3d12Tris.Transform3x4 = 0;
             }
         }
     }
@@ -2355,24 +2355,24 @@ void DeviceContextD3D12Impl::BuildBLAS(const BLASBuildAttribs& Attribs)
 
         for (Uint32 i = 0; i < Attribs.BoxDataCount; ++i)
         {
-            auto&  src = Attribs.pBoxData[i];
-            Uint32 j   = pBLASD12->GetGeometryIndex(src.GeometryName);
-            auto&  dst = Geometries.data()[j];
-            auto&  box = dst.AABBs;
+            const auto& SrcBoxes  = Attribs.pBoxData[i];
+            Uint32      GeoIdx    = pBLASD12->GetGeometryIndex(SrcBoxes.GeometryName);
+            auto&       d3d12Geo  = Geometries[GeoIdx];
+            auto&       d3d12AABs = d3d12Geo.AABBs;
 
-            if (j >= Geometries.size())
+            if (GeoIdx >= Geometries.size())
             {
                 UNEXPECTED("Failed to find geometry by name");
                 continue;
             }
 
-            dst.Type  = D3D12_RAYTRACING_GEOMETRY_TYPE_PROCEDURAL_PRIMITIVE_AABBS;
-            dst.Flags = GeometryFlagsToD3D12RTGeometryFlags(src.Flags);
+            d3d12Geo.Type  = D3D12_RAYTRACING_GEOMETRY_TYPE_PROCEDURAL_PRIMITIVE_AABBS;
+            d3d12Geo.Flags = GeometryFlagsToD3D12RTGeometryFlags(SrcBoxes.Flags);
 
-            auto* pBB               = ValidatedCast<BufferD3D12Impl>(src.pBoxBuffer);
-            box.AABBCount           = src.BoxCount;
-            box.AABBs.StartAddress  = pBB->GetGPUAddress() + src.BoxOffset;
-            box.AABBs.StrideInBytes = src.BoxStride;
+            auto* pBB                     = ValidatedCast<BufferD3D12Impl>(SrcBoxes.pBoxBuffer);
+            d3d12AABs.AABBCount           = SrcBoxes.BoxCount;
+            d3d12AABs.AABBs.StartAddress  = pBB->GetGPUAddress() + SrcBoxes.BoxOffset;
+            d3d12AABs.AABBs.StrideInBytes = SrcBoxes.BoxStride;
 
             TransitionOrVerifyBufferState(CmdCtx, *pBB, Attribs.GeometryTransitionMode, RESOURCE_STATE_BUILD_AS_READ, OpName);
         }
@@ -2418,18 +2418,18 @@ void DeviceContextD3D12Impl::BuildTLAS(const TLASBuildAttribs& Attribs)
 
         for (Uint32 i = 0; i < Attribs.InstanceCount; ++i)
         {
-            auto& src      = Attribs.pInstances[i];
-            auto& dst      = static_cast<D3D12_RAYTRACING_INSTANCE_DESC*>(pMappedInstances)[i];
-            auto* pBLASD12 = ValidatedCast<BottomLevelASD3D12Impl>(src.pBLAS);
+            const auto& Inst      = Attribs.pInstances[i];
+            auto&       d3d12Inst = static_cast<D3D12_RAYTRACING_INSTANCE_DESC*>(pMappedInstances)[i];
+            auto* const pBLASD12  = ValidatedCast<BottomLevelASD3D12Impl>(Inst.pBLAS);
 
-            static_assert(sizeof(dst.Transform) == sizeof(src.Transform), "size mismatch");
-            std::memcpy(&dst.Transform, src.Transform, sizeof(dst.Transform));
+            static_assert(sizeof(d3d12Inst.Transform) == sizeof(Inst.Transform), "size mismatch");
+            std::memcpy(&d3d12Inst.Transform, Inst.Transform, sizeof(d3d12Inst.Transform));
 
-            dst.InstanceID                          = src.CustomId;
-            dst.InstanceContributionToHitGroupIndex = pTLASD12->GetInstanceDesc(src.InstanceName).ContributionToHitGroupIndex; // AZ TODO: optimize
-            dst.InstanceMask                        = src.Mask;
-            dst.Flags                               = InstanceFlagsToD3D12RTInstanceFlags(src.Flags);
-            dst.AccelerationStructure               = pBLASD12->GetGPUAddress();
+            d3d12Inst.InstanceID                          = Inst.CustomId;
+            d3d12Inst.InstanceContributionToHitGroupIndex = pTLASD12->GetInstanceDesc(Inst.InstanceName).ContributionToHitGroupIndex; // AZ TODO: optimize
+            d3d12Inst.InstanceMask                        = Inst.Mask;
+            d3d12Inst.Flags                               = InstanceFlagsToD3D12RTInstanceFlags(Inst.Flags);
+            d3d12Inst.AccelerationStructure               = pBLASD12->GetGPUAddress();
 
             TransitionOrVerifyBLASState(CmdCtx, *pBLASD12, Attribs.BLASTransitionMode, RESOURCE_STATE_BUILD_AS_READ, OpName);
         }
@@ -2437,19 +2437,19 @@ void DeviceContextD3D12Impl::BuildTLAS(const TLASBuildAttribs& Attribs)
     }
     TransitionOrVerifyBufferState(CmdCtx, *pInstancesD12, Attribs.InstanceBufferTransitionMode, RESOURCE_STATE_BUILD_AS_READ, OpName);
 
-    D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC    Desc   = {};
-    D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS& Inputs = Desc.Inputs;
+    D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC    d3d12BuildASDesc   = {};
+    D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS& d3d12BuildASInputs = d3d12BuildASDesc.Inputs;
 
-    Inputs.Type          = D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL;
-    Inputs.DescsLayout   = D3D12_ELEMENTS_LAYOUT_ARRAY;
-    Inputs.NumDescs      = Attribs.InstanceCount;
-    Inputs.InstanceDescs = pInstancesD12->GetGPUAddress();
+    d3d12BuildASInputs.Type          = D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL;
+    d3d12BuildASInputs.DescsLayout   = D3D12_ELEMENTS_LAYOUT_ARRAY;
+    d3d12BuildASInputs.NumDescs      = Attribs.InstanceCount;
+    d3d12BuildASInputs.InstanceDescs = pInstancesD12->GetGPUAddress();
 
-    Desc.DestAccelerationStructureData    = pTLASD12->GetGPUAddress();
-    Desc.ScratchAccelerationStructureData = pScratchD12->GetGPUAddress();
-    Desc.SourceAccelerationStructureData  = 0;
+    d3d12BuildASDesc.DestAccelerationStructureData    = pTLASD12->GetGPUAddress();
+    d3d12BuildASDesc.ScratchAccelerationStructureData = pScratchD12->GetGPUAddress();
+    d3d12BuildASDesc.SourceAccelerationStructureData  = 0;
 
-    CmdCtx.AsGraphicsContext4().BuildRaytracingAccelerationStructure(Desc, 0, nullptr);
+    CmdCtx.AsGraphicsContext4().BuildRaytracingAccelerationStructure(d3d12BuildASDesc, 0, nullptr);
     ++m_State.NumCommands;
 }
 
@@ -2474,19 +2474,23 @@ void DeviceContextD3D12Impl::TraceRays(const TraceRaysAttribs& Attribs)
     if (!TDeviceContextBase::TraceRays(Attribs, 0))
         return;
 
-    D3D12_DISPATCH_RAYS_DESC Desc = {};
+    D3D12_DISPATCH_RAYS_DESC d3d12DispatchDesc = {};
 
-    Desc.Width  = Attribs.DimensionX;
-    Desc.Height = Attribs.DimensionY;
-    Desc.Depth  = Attribs.DimensionZ;
+    d3d12DispatchDesc.Width  = Attribs.DimensionX;
+    d3d12DispatchDesc.Height = Attribs.DimensionY;
+    d3d12DispatchDesc.Depth  = Attribs.DimensionZ;
 
     auto* pSBTD12 = ValidatedCast<ShaderBindingTableD3D12Impl>(Attribs.pSBT);
-    pSBTD12->GetD3D12AddressRangeAndStride(this, Attribs.TransitionMode, Desc.RayGenerationShaderRecord, Desc.MissShaderTable, Desc.HitGroupTable, Desc.CallableShaderTable);
+    pSBTD12->GetD3D12AddressRangeAndStride(this, Attribs.TransitionMode,
+                                           d3d12DispatchDesc.RayGenerationShaderRecord,
+                                           d3d12DispatchDesc.MissShaderTable,
+                                           d3d12DispatchDesc.HitGroupTable,
+                                           d3d12DispatchDesc.CallableShaderTable);
 
     auto& CmdCtx = GetCmdContext().AsGraphicsContext4();
     PrepareForDispatchRays(CmdCtx);
 
-    CmdCtx.DispatchRays(Desc);
+    CmdCtx.DispatchRays(d3d12DispatchDesc);
     ++m_State.NumCommands;
 }
 
diff --git a/Graphics/GraphicsEngineD3D12/src/ShaderBindingTableD3D12Impl.cpp b/Graphics/GraphicsEngineD3D12/src/ShaderBindingTableD3D12Impl.cpp
index 3727913f..d352caf0 100644
--- a/Graphics/GraphicsEngineD3D12/src/ShaderBindingTableD3D12Impl.cpp
+++ b/Graphics/GraphicsEngineD3D12/src/ShaderBindingTableD3D12Impl.cpp
@@ -110,7 +110,7 @@ void ShaderBindingTableD3D12Impl::GetD3D12AddressRangeAndStride(IDeviceContextD3
                                                                 D3D12_GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE& CallableShaderBindingTable)
 {
     const auto AlignToLarger = [](size_t offset) -> Uint32 {
-        return Align(static_cast<Uint32>(offset), static_cast<Uint32>(D3D12_RAYTRACING_SHADER_TABLE_BYTE_ALIGNMENT));
+        return Align(static_cast<Uint32>(offset), Uint32{D3D12_RAYTRACING_SHADER_TABLE_BYTE_ALIGNMENT});
     };
 
     const Uint32 RayGenOffset          = 0;
diff --git a/Graphics/GraphicsEngineD3D12/src/ShaderResourceLayoutD3D12.cpp b/Graphics/GraphicsEngineD3D12/src/ShaderResourceLayoutD3D12.cpp
index 6dbdb97f..bfc8693a 100644
--- a/Graphics/GraphicsEngineD3D12/src/ShaderResourceLayoutD3D12.cpp
+++ b/Graphics/GraphicsEngineD3D12/src/ShaderResourceLayoutD3D12.cpp
@@ -456,7 +456,7 @@ void ShaderResourceLayoutD3D12::D3D12Resource::CacheCB(IDeviceObject*
 
     // We cannot use ValidatedCast<> here as the resource retrieved from the
     // resource mapping can be of wrong type
-    RefCntAutoPtr<BufferD3D12Impl> pBuffD3D12(pBuffer, IID_BufferD3D12);
+    RefCntAutoPtr<BufferD3D12Impl> pBuffD3D12{pBuffer, IID_BufferD3D12};
 #ifdef DILIGENT_DEVELOPMENT
     VerifyConstantBufferBinding(Attribs, GetVariableType(), ArrayInd, pBuffer, pBuffD3D12.RawPtr(), DstRes.pObject.RawPtr(), ParentResLayout.GetShaderName());
 #endif
@@ -576,7 +576,7 @@ void ShaderResourceLayoutD3D12::D3D12Resource::CacheSampler(IDeviceObject*
     VERIFY(Attribs.IsValidBindPoint(), "Invalid bind point");
     VERIFY_EXPR(ArrayIndex < Attribs.BindCount);
 
-    RefCntAutoPtr<ISamplerD3D12> pSamplerD3D12(pSampler, IID_SamplerD3D12);
+    RefCntAutoPtr<ISamplerD3D12> pSamplerD3D12{pSampler, IID_SamplerD3D12};
     if (pSamplerD3D12)
     {
         if (GetVariableType() != SHADER_RESOURCE_VARIABLE_TYPE_DYNAMIC && DstSam.pObject != nullptr)
@@ -626,7 +626,7 @@ void ShaderResourceLayoutD3D12::D3D12Resource::CacheAccelStruct(IDeviceObject*
     VERIFY(Attribs.IsValidBindPoint(), "Invalid bind point");
     VERIFY_EXPR(ArrayIndex < Attribs.BindCount);
 
-    RefCntAutoPtr<ITopLevelASD3D12> pTLASD3D12(pTLAS, IID_TopLevelASD3D12);
+    RefCntAutoPtr<ITopLevelASD3D12> pTLASD3D12{pTLAS, IID_TopLevelASD3D12};
     if (pTLASD3D12)
     {
         if (GetVariableType() != SHADER_RESOURCE_VARIABLE_TYPE_DYNAMIC && DstRes.pObject != nullptr)
diff --git a/Graphics/GraphicsEngineD3D12/src/TopLevelASD3D12Impl.cpp b/Graphics/GraphicsEngineD3D12/src/TopLevelASD3D12Impl.cpp
index 5f411640..3bbf3308 100644
--- a/Graphics/GraphicsEngineD3D12/src/TopLevelASD3D12Impl.cpp
+++ b/Graphics/GraphicsEngineD3D12/src/TopLevelASD3D12Impl.cpp
@@ -44,20 +44,20 @@ TopLevelASD3D12Impl::TopLevelASD3D12Impl(IReferenceCounters*          pRefCounte
                                          bool                         bIsDeviceInternal) :
     TTopLevelASBase{pRefCounters, pDeviceD3D12, Desc, bIsDeviceInternal}
 {
-    D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO TopLevelPrebuildInfo = {};
-    D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS  TopLevelInputs       = {};
+    D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO d3d12TopLevelPrebuildInfo = {};
+    D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS  d3d12TopLevelInputs       = {};
 
-    TopLevelInputs.Type        = D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL;
-    TopLevelInputs.Flags       = D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_NONE;
-    TopLevelInputs.DescsLayout = D3D12_ELEMENTS_LAYOUT_ARRAY;
-    TopLevelInputs.NumDescs    = Desc.MaxInstanceCount;
+    d3d12TopLevelInputs.Type        = D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL;
+    d3d12TopLevelInputs.Flags       = D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_NONE;
+    d3d12TopLevelInputs.DescsLayout = D3D12_ELEMENTS_LAYOUT_ARRAY;
+    d3d12TopLevelInputs.NumDescs    = Desc.MaxInstanceCount;
 
     VERIFY_EXPR(Desc.MaxInstanceCount <= D3D12_RAYTRACING_MAX_INSTANCES_PER_TOP_LEVEL_ACCELERATION_STRUCTURE);
 
     auto* pd3d12Device = pDeviceD3D12->GetD3D12Device5();
 
-    pd3d12Device->GetRaytracingAccelerationStructurePrebuildInfo(&TopLevelInputs, &TopLevelPrebuildInfo);
-    if (TopLevelPrebuildInfo.ResultDataMaxSizeInBytes == 0)
+    pd3d12Device->GetRaytracingAccelerationStructurePrebuildInfo(&d3d12TopLevelInputs, &d3d12TopLevelPrebuildInfo);
+    if (d3d12TopLevelPrebuildInfo.ResultDataMaxSizeInBytes == 0)
         LOG_ERROR_AND_THROW("Failed to get ray tracing acceleration structure prebuild info");
 
     D3D12_HEAP_PROPERTIES HeapProps;
@@ -67,21 +67,21 @@ TopLevelASD3D12Impl::TopLevelASD3D12Impl(IReferenceCounters*          pRefCounte
     HeapProps.CreationNodeMask     = 1;
     HeapProps.VisibleNodeMask      = 1;
 
-    D3D12_RESOURCE_DESC ASDesc = {};
-    ASDesc.Dimension           = D3D12_RESOURCE_DIMENSION_BUFFER;
-    ASDesc.Alignment           = 0;
-    ASDesc.Width               = TopLevelPrebuildInfo.ResultDataMaxSizeInBytes;
-    ASDesc.Height              = 1;
-    ASDesc.DepthOrArraySize    = 1;
-    ASDesc.MipLevels           = 1;
-    ASDesc.Format              = DXGI_FORMAT_UNKNOWN;
-    ASDesc.SampleDesc.Count    = 1;
-    ASDesc.SampleDesc.Quality  = 0;
-    ASDesc.Layout              = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
-    ASDesc.Flags               = D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS;
+    D3D12_RESOURCE_DESC d3d12ASDesc = {};
+    d3d12ASDesc.Dimension           = D3D12_RESOURCE_DIMENSION_BUFFER;
+    d3d12ASDesc.Alignment           = 0;
+    d3d12ASDesc.Width               = d3d12TopLevelPrebuildInfo.ResultDataMaxSizeInBytes;
+    d3d12ASDesc.Height              = 1;
+    d3d12ASDesc.DepthOrArraySize    = 1;
+    d3d12ASDesc.MipLevels           = 1;
+    d3d12ASDesc.Format              = DXGI_FORMAT_UNKNOWN;
+    d3d12ASDesc.SampleDesc.Count    = 1;
+    d3d12ASDesc.SampleDesc.Quality  = 0;
+    d3d12ASDesc.Layout              = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
+    d3d12ASDesc.Flags               = D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS;
 
     auto hr = pd3d12Device->CreateCommittedResource(&HeapProps, D3D12_HEAP_FLAG_NONE,
-                                                    &ASDesc, D3D12_RESOURCE_STATE_RAYTRACING_ACCELERATION_STRUCTURE, nullptr,
+                                                    &d3d12ASDesc, D3D12_RESOURCE_STATE_RAYTRACING_ACCELERATION_STRUCTURE, nullptr,
                                                     __uuidof(m_pd3d12Resource),
                                                     reinterpret_cast<void**>(static_cast<ID3D12Resource**>(&m_pd3d12Resource)));
     if (FAILED(hr))
@@ -90,17 +90,17 @@ TopLevelASD3D12Impl::TopLevelASD3D12Impl(IReferenceCounters*          pRefCounte
     if (*m_Desc.Name != 0)
         m_pd3d12Resource->SetName(WidenString(m_Desc.Name).c_str());
 
-    m_ScratchSize.Build  = static_cast<Uint32>(TopLevelPrebuildInfo.ScratchDataSizeInBytes);
-    m_ScratchSize.Update = static_cast<Uint32>(TopLevelPrebuildInfo.UpdateScratchDataSizeInBytes);
+    m_ScratchSize.Build  = static_cast<Uint32>(d3d12TopLevelPrebuildInfo.ScratchDataSizeInBytes);
+    m_ScratchSize.Update = static_cast<Uint32>(d3d12TopLevelPrebuildInfo.UpdateScratchDataSizeInBytes);
 
     m_DescriptorHandle = pDeviceD3D12->AllocateDescriptor(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV);
 
-    D3D12_SHADER_RESOURCE_VIEW_DESC SRVDesc;
-    SRVDesc.ViewDimension                            = D3D12_SRV_DIMENSION_RAYTRACING_ACCELERATION_STRUCTURE;
-    SRVDesc.Shader4ComponentMapping                  = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
-    SRVDesc.Format                                   = DXGI_FORMAT_UNKNOWN;
-    SRVDesc.RaytracingAccelerationStructure.Location = GetGPUAddress();
-    pd3d12Device->CreateShaderResourceView(nullptr, &SRVDesc, m_DescriptorHandle.GetCpuHandle());
+    D3D12_SHADER_RESOURCE_VIEW_DESC d3d12SRVDesc;
+    d3d12SRVDesc.ViewDimension                            = D3D12_SRV_DIMENSION_RAYTRACING_ACCELERATION_STRUCTURE;
+    d3d12SRVDesc.Shader4ComponentMapping                  = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
+    d3d12SRVDesc.Format                                   = DXGI_FORMAT_UNKNOWN;
+    d3d12SRVDesc.RaytracingAccelerationStructure.Location = GetGPUAddress();
+    pd3d12Device->CreateShaderResourceView(nullptr, &d3d12SRVDesc, m_DescriptorHandle.GetCpuHandle());
 }
 
 TopLevelASD3D12Impl::~TopLevelASD3D12Impl()
diff --git a/Graphics/GraphicsEngineVulkan/include/DescriptorPoolManager.hpp b/Graphics/GraphicsEngineVulkan/include/DescriptorPoolManager.hpp
index 41a8cac3..b60f3d89 100644
--- a/Graphics/GraphicsEngineVulkan/include/DescriptorPoolManager.hpp
+++ b/Graphics/GraphicsEngineVulkan/include/DescriptorPoolManager.hpp
@@ -165,9 +165,9 @@ protected:
     RenderDeviceVkImpl& m_DeviceVkImpl;
     const std::string   m_PoolName;
 
-    std::vector<VkDescriptorPoolSize> m_PoolSizes;
-    const uint32_t                    m_MaxSets;
-    const bool                        m_AllowFreeing;
+    const std::vector<VkDescriptorPoolSize> m_PoolSizes;
+    const uint32_t                          m_MaxSets;
+    const bool                              m_AllowFreeing;
 
     std::mutex                                         m_Mutex;
     std::deque<VulkanUtilities::DescriptorPoolWrapper> m_Pools;
diff --git a/Graphics/GraphicsEngineVulkan/src/CommandPoolManager.cpp b/Graphics/GraphicsEngineVulkan/src/CommandPoolManager.cpp
index 6d0e1ab2..cf24d9ea 100644
--- a/Graphics/GraphicsEngineVulkan/src/CommandPoolManager.cpp
+++ b/Graphics/GraphicsEngineVulkan/src/CommandPoolManager.cpp
@@ -53,7 +53,7 @@ VulkanUtilities::CommandPoolWrapper CommandPoolManager::AllocateCommandPool(cons
 {
     std::lock_guard<std::mutex> LockGuard{m_Mutex};
 
-    auto& LogicalDevice = m_DeviceVkImpl.GetLogicalDevice();
+    const auto& LogicalDevice = m_DeviceVkImpl.GetLogicalDevice();
 
     VulkanUtilities::CommandPoolWrapper CmdPool;
     if (!m_CmdPools.empty())
diff --git a/Graphics/GraphicsEngineVulkan/src/DescriptorPoolManager.cpp b/Graphics/GraphicsEngineVulkan/src/DescriptorPoolManager.cpp
index 6557ac6d..45045cea 100644
--- a/Graphics/GraphicsEngineVulkan/src/DescriptorPoolManager.cpp
+++ b/Graphics/GraphicsEngineVulkan/src/DescriptorPoolManager.cpp
@@ -59,28 +59,16 @@ VulkanUtilities::DescriptorPoolWrapper DescriptorPoolManager::CreateDescriptorPo
     return m_DeviceVkImpl.GetLogicalDevice().CreateDescriptorPool(PoolCI, DebugName);
 }
 
-DescriptorPoolManager::DescriptorPoolManager(RenderDeviceVkImpl&               DeviceVkImpl,
-                                             std::string                       PoolName,
-                                             std::vector<VkDescriptorPoolSize> PoolSizes,
-                                             uint32_t                          MaxSets,
-                                             bool                              AllowFreeing) noexcept :
-    // clang-format off
-    m_DeviceVkImpl{DeviceVkImpl        },
-    m_PoolName    {std::move(PoolName) },
-    m_PoolSizes   (std::move(PoolSizes)),
-    m_MaxSets     {MaxSets             },
-    m_AllowFreeing{AllowFreeing        }
-// clang-format on
+static std::vector<VkDescriptorPoolSize> PrunePoolSizes(RenderDeviceVkImpl& DeviceVkImpl, std::vector<VkDescriptorPoolSize>&& PoolSizes)
 {
-    const auto& Feats = m_DeviceVkImpl.GetLogicalDevice().GetEnabledExtFeatures();
-
-    for (auto iter = m_PoolSizes.begin(); iter != m_PoolSizes.end();)
+    const auto& Feats = DeviceVkImpl.GetLogicalDevice().GetEnabledExtFeatures();
+    for (auto iter = PoolSizes.begin(); iter != PoolSizes.end();)
     {
         switch (iter->type)
         {
             case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR:
                 if (Feats.RayTracing.rayTracing == VK_FALSE)
-                    iter = m_PoolSizes.erase(iter);
+                    iter = PoolSizes.erase(iter);
                 else
                     ++iter;
                 break;
@@ -88,7 +76,22 @@ DescriptorPoolManager::DescriptorPoolManager(RenderDeviceVkImpl&               D
                 ++iter;
         }
     }
+    return PoolSizes;
+}
 
+DescriptorPoolManager::DescriptorPoolManager(RenderDeviceVkImpl&               DeviceVkImpl,
+                                             std::string                       PoolName,
+                                             std::vector<VkDescriptorPoolSize> PoolSizes,
+                                             uint32_t                          MaxSets,
+                                             bool                              AllowFreeing) noexcept :
+    // clang-format off
+    m_DeviceVkImpl{DeviceVkImpl        },
+    m_PoolName    {std::move(PoolName) },
+    m_PoolSizes   (PrunePoolSizes(DeviceVkImpl, std::move(PoolSizes))),
+    m_MaxSets     {MaxSets             },
+    m_AllowFreeing{AllowFreeing        }
+// clang-format on
+{
 #ifdef DILIGENT_DEVELOPMENT
     m_AllocatedPoolCounter = 0;
 #endif
diff --git a/Graphics/GraphicsEngineVulkan/src/DeviceContextVkImpl.cpp b/Graphics/GraphicsEngineVulkan/src/DeviceContextVkImpl.cpp
index 554352ad..69a3a1ba 100644
--- a/Graphics/GraphicsEngineVulkan/src/DeviceContextVkImpl.cpp
+++ b/Graphics/GraphicsEngineVulkan/src/DeviceContextVkImpl.cpp
@@ -2704,8 +2704,7 @@ void DeviceContextVkImpl::TransitionResourceStates(Uint32 BarrierCount, StateTra
         }
         VERIFY(Barrier.TransitionType == STATE_TRANSITION_TYPE_IMMEDIATE || Barrier.TransitionType == STATE_TRANSITION_TYPE_END, "Unexpected barrier type");
 
-        RefCntAutoPtr<TextureVkImpl> pTexture{Barrier.pResource, IID_TextureVk};
-        if (pTexture)
+        if (RefCntAutoPtr<TextureVkImpl> pTexture{Barrier.pResource, IID_TextureVk})
         {
             VkImageSubresourceRange SubResRange;
             SubResRange.aspectMask     = 0;
@@ -2714,17 +2713,23 @@ void DeviceContextVkImpl::TransitionResourceStates(Uint32 BarrierCount, StateTra
             SubResRange.baseArrayLayer = Barrier.FirstArraySlice;
             SubResRange.layerCount     = (Barrier.ArraySliceCount == REMAINING_ARRAY_SLICES) ? VK_REMAINING_ARRAY_LAYERS : Barrier.ArraySliceCount;
             TransitionTextureState(*pTexture, Barrier.OldState, Barrier.NewState, Barrier.UpdateResourceState, &SubResRange);
-            continue;
         }
-
-        RefCntAutoPtr<BufferVkImpl> pBuffer{Barrier.pResource, IID_BufferVk};
-        if (pBuffer)
+        else if (RefCntAutoPtr<BufferVkImpl> pBuffer{Barrier.pResource, IID_BufferVk})
         {
             TransitionBufferState(*pBuffer, Barrier.OldState, Barrier.NewState, Barrier.UpdateResourceState);
-            continue;
         }
-
-        UNEXPECTED("unsupported resource type");
+        else if (RefCntAutoPtr<BottomLevelASVkImpl> pBLAS{Barrier.pResource, IID_BottomLevelAS})
+        {
+            TransitionBLASState(*pBLAS, Barrier.OldState, Barrier.NewState, Barrier.UpdateResourceState);
+        }
+        else if (RefCntAutoPtr<TopLevelASVkImpl> pTLAS{Barrier.pResource, IID_TopLevelAS})
+        {
+            TransitionTLASState(*pTLAS, Barrier.OldState, Barrier.NewState, Barrier.UpdateResourceState);
+        }
+        else
+        {
+            UNEXPECTED("unsupported resource type");
+        }
     }
 }
 
@@ -2816,61 +2821,61 @@ void DeviceContextVkImpl::BuildBLAS(const BLASBuildAttribs& Attribs)
 
         for (Uint32 i = 0; i < Attribs.TriangleDataCount; ++i)
         {
-            auto&  src = Attribs.pTriangleData[i];
-            Uint32 j   = pBLASVk->GetGeometryIndex(src.GeometryName);
-            auto&  dst = Geometries.data()[j];
-            auto&  tri = dst.geometry.triangles;
-            auto&  off = Offsets.data()[j];
+            const auto& SrcTris = Attribs.pTriangleData[i];
+            Uint32      GeoIdx  = pBLASVk->GetGeometryIndex(SrcTris.GeometryName);
+            auto&       vkGeo   = Geometries[GeoIdx];
+            auto&       vkTris  = vkGeo.geometry.triangles;
+            auto&       off     = Offsets[GeoIdx];
 
-            if (j >= Geometries.size())
+            if (GeoIdx >= Geometries.size())
             {
                 UNEXPECTED("Failed to find geometry by name");
                 continue;
             }
 
-            dst.sType        = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR;
-            dst.pNext        = nullptr;
-            dst.flags        = GeometryFlagsToVkGeometryFlags(src.Flags);
-            dst.geometryType = VK_GEOMETRY_TYPE_TRIANGLES_KHR;
-            tri.sType        = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR;
-            tri.pNext        = nullptr;
+            vkGeo.sType        = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR;
+            vkGeo.pNext        = nullptr;
+            vkGeo.flags        = GeometryFlagsToVkGeometryFlags(SrcTris.Flags);
+            vkGeo.geometryType = VK_GEOMETRY_TYPE_TRIANGLES_KHR;
+            vkTris.sType       = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR;
+            vkTris.pNext       = nullptr;
 
-            auto* pVB                    = ValidatedCast<BufferVkImpl>(src.pVertexBuffer);
-            tri.vertexFormat             = TypeToVkFormat(src.VertexValueType, src.VertexComponentCount, src.VertexValueType < VT_FLOAT16);
-            tri.vertexStride             = src.VertexStride;
-            tri.vertexData.deviceAddress = pVB->GetVkDeviceAddress() + src.VertexOffset;
+            auto* const pVB                 = ValidatedCast<BufferVkImpl>(SrcTris.pVertexBuffer);
+            vkTris.vertexFormat             = TypeToVkFormat(SrcTris.VertexValueType, SrcTris.VertexComponentCount, SrcTris.VertexValueType < VT_FLOAT16);
+            vkTris.vertexStride             = SrcTris.VertexStride;
+            vkTris.vertexData.deviceAddress = pVB->GetVkDeviceAddress() + SrcTris.VertexOffset;
 
-            TransitionOrVerifyBufferState(*pVB, Attribs.GeometryTransitionMode, RESOURCE_STATE_BUILD_AS_READ, VkAccessFlagBits(0), OpName);
+            TransitionOrVerifyBufferState(*pVB, Attribs.GeometryTransitionMode, RESOURCE_STATE_BUILD_AS_READ, static_cast<VkAccessFlagBits>(0), OpName);
 
-            if (src.pIndexBuffer)
+            if (SrcTris.pIndexBuffer)
             {
-                auto* pIB                   = ValidatedCast<BufferVkImpl>(src.pIndexBuffer);
-                tri.indexType               = TypeToVkIndexType(src.IndexType);
-                tri.indexData.deviceAddress = pIB->GetVkDeviceAddress() + src.IndexOffset;
-                off.primitiveCount          = src.IndexCount / 3;
+                auto* const pIB                = ValidatedCast<BufferVkImpl>(SrcTris.pIndexBuffer);
+                vkTris.indexType               = TypeToVkIndexType(SrcTris.IndexType);
+                vkTris.indexData.deviceAddress = pIB->GetVkDeviceAddress() + SrcTris.IndexOffset;
+                off.primitiveCount             = SrcTris.IndexCount / 3;
 
-                TransitionOrVerifyBufferState(*pIB, Attribs.GeometryTransitionMode, RESOURCE_STATE_BUILD_AS_READ, VkAccessFlagBits(0), OpName);
+                TransitionOrVerifyBufferState(*pIB, Attribs.GeometryTransitionMode, RESOURCE_STATE_BUILD_AS_READ, static_cast<VkAccessFlagBits>(0), OpName);
             }
             else
             {
-                tri.indexType               = VK_INDEX_TYPE_NONE_KHR;
-                tri.indexData.deviceAddress = 0;
-                off.primitiveCount          = src.VertexCount / 3;
+                vkTris.indexType               = VK_INDEX_TYPE_NONE_KHR;
+                vkTris.indexData.deviceAddress = 0;
+                off.primitiveCount             = SrcTris.VertexCount / 3;
             }
 
-            if (src.pTransformBuffer)
+            if (SrcTris.pTransformBuffer)
             {
-                VERIFY_EXPR(BLASDesc.pTriangles[j].AllowsTransforms);
+                VERIFY_EXPR(BLASDesc.pTriangles[GeoIdx].AllowsTransforms);
 
-                auto* pTB                       = ValidatedCast<BufferVkImpl>(src.pTransformBuffer);
-                tri.transformData.deviceAddress = pTB->GetVkDeviceAddress() + src.TransformBufferOffset;
+                auto* const pTB                    = ValidatedCast<BufferVkImpl>(SrcTris.pTransformBuffer);
+                vkTris.transformData.deviceAddress = pTB->GetVkDeviceAddress() + SrcTris.TransformBufferOffset;
 
                 TransitionOrVerifyBufferState(*pTB, Attribs.GeometryTransitionMode, RESOURCE_STATE_BUILD_AS_READ, VkAccessFlagBits(0), OpName);
             }
             else
             {
-                VERIFY_EXPR(!BLASDesc.pTriangles[j].AllowsTransforms);
-                tri.transformData.deviceAddress = 0;
+                VERIFY_EXPR(!BLASDesc.pTriangles[GeoIdx].AllowsTransforms);
+                vkTris.transformData.deviceAddress = 0;
             }
 
             off.firstVertex     = 0;
@@ -2885,35 +2890,35 @@ void DeviceContextVkImpl::BuildBLAS(const BLASBuildAttribs& Attribs)
 
         for (Uint32 i = 0; i < Attribs.BoxDataCount; ++i)
         {
-            auto&  src = Attribs.pBoxData[i];
-            Uint32 j   = pBLASVk->GetGeometryIndex(src.GeometryName);
-            auto&  dst = Geometries.data()[j];
-            auto&  box = dst.geometry.aabbs;
-            auto&  off = Offsets.data()[j];
+            const auto& SrcBoxes = Attribs.pBoxData[i];
+            Uint32      GeoIdx   = pBLASVk->GetGeometryIndex(SrcBoxes.GeometryName);
+            auto&       vkGeo    = Geometries[GeoIdx];
+            auto&       vkAABBs  = vkGeo.geometry.aabbs;
+            auto&       off      = Offsets[GeoIdx];
 
-            if (j >= Geometries.size())
+            if (GeoIdx >= Geometries.size())
             {
                 UNEXPECTED("Failed to find geometry by name");
                 continue;
             }
 
-            dst.sType        = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR;
-            dst.pNext        = nullptr;
-            dst.flags        = GeometryFlagsToVkGeometryFlags(src.Flags);
-            dst.geometryType = VK_GEOMETRY_TYPE_AABBS_KHR;
+            vkGeo.sType        = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR;
+            vkGeo.pNext        = nullptr;
+            vkGeo.flags        = GeometryFlagsToVkGeometryFlags(SrcBoxes.Flags);
+            vkGeo.geometryType = VK_GEOMETRY_TYPE_AABBS_KHR;
 
-            auto* pBB              = ValidatedCast<BufferVkImpl>(src.pBoxBuffer);
-            box.sType              = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR;
-            box.pNext              = nullptr;
-            box.stride             = src.BoxStride;
-            box.data.deviceAddress = pBB->GetVkDeviceAddress() + src.BoxOffset;
+            auto* const pBB            = ValidatedCast<BufferVkImpl>(SrcBoxes.pBoxBuffer);
+            vkAABBs.sType              = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR;
+            vkAABBs.pNext              = nullptr;
+            vkAABBs.stride             = SrcBoxes.BoxStride;
+            vkAABBs.data.deviceAddress = pBB->GetVkDeviceAddress() + SrcBoxes.BoxOffset;
 
             TransitionOrVerifyBufferState(*pBB, Attribs.GeometryTransitionMode, RESOURCE_STATE_BUILD_AS_READ, VkAccessFlagBits(0), OpName);
 
             off.firstVertex     = 0;
             off.transformOffset = 0;
             off.primitiveOffset = 0;
-            off.primitiveCount  = src.BoxCount;
+            off.primitiveCount  = SrcBoxes.BoxCount;
         }
     }
 
@@ -2971,18 +2976,18 @@ void DeviceContextVkImpl::BuildTLAS(const TLASBuildAttribs& Attribs)
 
         for (Uint32 i = 0; i < Attribs.InstanceCount; ++i)
         {
-            auto& src     = Attribs.pInstances[i];
-            auto& dst     = static_cast<VkAccelerationStructureInstanceKHR*>(pMappedInstances)[i];
-            auto* pBLASVk = ValidatedCast<BottomLevelASVkImpl>(src.pBLAS);
+            const auto& Inst     = Attribs.pInstances[i];
+            auto&       vkASInst = static_cast<VkAccelerationStructureInstanceKHR*>(pMappedInstances)[i];
+            auto* const pBLASVk  = ValidatedCast<BottomLevelASVkImpl>(Inst.pBLAS);
 
-            static_assert(sizeof(dst.transform) == sizeof(src.Transform), "size mismatch");
-            std::memcpy(&dst.transform, src.Transform, sizeof(dst.transform));
+            static_assert(sizeof(vkASInst.transform) == sizeof(Inst.Transform), "size mismatch");
+            std::memcpy(&vkASInst.transform, Inst.Transform, sizeof(vkASInst.transform));
 
-            dst.instanceCustomIndex                    = src.CustomId;
-            dst.instanceShaderBindingTableRecordOffset = pTLASVk->GetInstanceDesc(src.InstanceName).ContributionToHitGroupIndex; // AZ TODO: optimize
-            dst.mask                                   = src.Mask;
-            dst.flags                                  = InstanceFlagsToVkGeometryInstanceFlags(src.Flags);
-            dst.accelerationStructureReference         = pBLASVk->GetVkDeviceAddress();
+            vkASInst.instanceCustomIndex                    = Inst.CustomId;
+            vkASInst.instanceShaderBindingTableRecordOffset = pTLASVk->GetInstanceDesc(Inst.InstanceName).ContributionToHitGroupIndex; // AZ TODO: optimize
+            vkASInst.mask                                   = Inst.Mask;
+            vkASInst.flags                                  = InstanceFlagsToVkGeometryInstanceFlags(Inst.Flags);
+            vkASInst.accelerationStructureReference         = pBLASVk->GetVkDeviceAddress();
 
             TransitionOrVerifyBLASState(*pBLASVk, Attribs.BLASTransitionMode, RESOURCE_STATE_BUILD_AS_READ, OpName);
         }
@@ -2991,37 +2996,37 @@ void DeviceContextVkImpl::BuildTLAS(const TLASBuildAttribs& Attribs)
     }
     TransitionOrVerifyBufferState(*pInstancesVk, Attribs.InstanceBufferTransitionMode, RESOURCE_STATE_BUILD_AS_READ, VkAccessFlagBits(0), OpName);
 
-    VkAccelerationStructureBuildGeometryInfoKHR      Info          = {};
-    VkAccelerationStructureBuildOffsetInfoKHR        Offset        = {};
-    VkAccelerationStructureBuildOffsetInfoKHR const* OffsetsPtr    = &Offset;
-    VkAccelerationStructureGeometryKHR               Geometry      = {};
-    VkAccelerationStructureGeometryKHR const*        GeometriesPtr = &Geometry;
-
-    Offset.primitiveCount = Attribs.InstanceCount;
-
-    Geometry.sType        = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR;
-    Geometry.pNext        = nullptr;
-    Geometry.geometryType = VK_GEOMETRY_TYPE_INSTANCES_KHR;
-    Geometry.flags        = 0;
-
-    auto& inst              = Geometry.geometry.instances;
-    inst.sType              = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR;
-    inst.pNext              = nullptr;
-    inst.arrayOfPointers    = VK_FALSE;
-    inst.data.deviceAddress = pInstancesVk->GetVkDeviceAddress() + Attribs.InstanceBufferOffset;
-
-    Info.sType                     = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR;
-    Info.type                      = VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR;                    // type must be compatible with create info
-    Info.flags                     = BuildASFlagsToVkBuildAccelerationStructureFlags(TLASDesc.Flags); // flags must be compatible with create info
-    Info.update                    = VK_FALSE;
-    Info.srcAccelerationStructure  = VK_NULL_HANDLE;
-    Info.dstAccelerationStructure  = pTLASVk->GetVkTLAS();
-    Info.geometryArrayOfPointers   = VK_FALSE;
-    Info.geometryCount             = 1;
-    Info.ppGeometries              = &GeometriesPtr;
-    Info.scratchData.deviceAddress = pScratchVk->GetVkDeviceAddress() + Attribs.ScratchBufferOffset;
-
-    m_CommandBuffer.BuildAccelerationStructure(1, &Info, &OffsetsPtr);
+    VkAccelerationStructureBuildGeometryInfoKHR      vkASBuildInfo      = {};
+    VkAccelerationStructureBuildOffsetInfoKHR        vkASBuildOffset    = {};
+    VkAccelerationStructureBuildOffsetInfoKHR const* vkASBuildOffsetPtr = &vkASBuildOffset;
+    VkAccelerationStructureGeometryKHR               vkASGeometry       = {};
+    VkAccelerationStructureGeometryKHR const*        vkASGeometriesPtr  = &vkASGeometry;
+
+    vkASBuildOffset.primitiveCount = Attribs.InstanceCount;
+
+    vkASGeometry.sType        = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR;
+    vkASGeometry.pNext        = nullptr;
+    vkASGeometry.geometryType = VK_GEOMETRY_TYPE_INSTANCES_KHR;
+    vkASGeometry.flags        = 0;
+
+    auto& vkASInst              = vkASGeometry.geometry.instances;
+    vkASInst.sType              = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR;
+    vkASInst.pNext              = nullptr;
+    vkASInst.arrayOfPointers    = VK_FALSE;
+    vkASInst.data.deviceAddress = pInstancesVk->GetVkDeviceAddress() + Attribs.InstanceBufferOffset;
+
+    vkASBuildInfo.sType                     = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR;
+    vkASBuildInfo.type                      = VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR;                    // type must be compatible with create info
+    vkASBuildInfo.flags                     = BuildASFlagsToVkBuildAccelerationStructureFlags(TLASDesc.Flags); // flags must be compatible with create info
+    vkASBuildInfo.update                    = VK_FALSE;
+    vkASBuildInfo.srcAccelerationStructure  = VK_NULL_HANDLE;
+    vkASBuildInfo.dstAccelerationStructure  = pTLASVk->GetVkTLAS();
+    vkASBuildInfo.geometryArrayOfPointers   = VK_FALSE;
+    vkASBuildInfo.geometryCount             = 1;
+    vkASBuildInfo.ppGeometries              = &vkASGeometriesPtr;
+    vkASBuildInfo.scratchData.deviceAddress = pScratchVk->GetVkDeviceAddress() + Attribs.ScratchBufferOffset;
+
+    m_CommandBuffer.BuildAccelerationStructure(1, &vkASBuildInfo, &vkASBuildOffsetPtr);
     ++m_State.NumCommands;
 }
 
diff --git a/Graphics/GraphicsEngineVulkan/src/PipelineStateVkImpl.cpp b/Graphics/GraphicsEngineVulkan/src/PipelineStateVkImpl.cpp
index 548a9cf3..36ca3a42 100644
--- a/Graphics/GraphicsEngineVulkan/src/PipelineStateVkImpl.cpp
+++ b/Graphics/GraphicsEngineVulkan/src/PipelineStateVkImpl.cpp
@@ -392,8 +392,8 @@ void BuildRTPipelineDescription(const RayTracingPipelineStateCreateInfo&
 
     Uint32 GroupIndex = 0;
 
-    std::array<Uint32, 6>                      ShaderIndices = {};
-    std::unordered_map<const IShader*, Uint32> UniqueShaders;
+    std::array<Uint32, MAX_SHADERS_IN_PIPELINE> ShaderIndices = {};
+    std::unordered_map<const IShader*, Uint32>  UniqueShaders;
 
     const auto ShaderToIndex = [&ShaderIndices, &UniqueShaders](const IShader* pShader) -> Uint32 {
         if (pShader != nullptr)
diff --git a/Graphics/GraphicsEngineVulkan/src/SwapChainVkImpl.cpp b/Graphics/GraphicsEngineVulkan/src/SwapChainVkImpl.cpp
index 27be99fc..d32f9788 100644
--- a/Graphics/GraphicsEngineVulkan/src/SwapChainVkImpl.cpp
+++ b/Graphics/GraphicsEngineVulkan/src/SwapChainVkImpl.cpp
@@ -425,20 +425,22 @@ void SwapChainVkImpl::CreateVulkanSwapChain()
     DEV_CHECK_ERR(m_SwapChainDesc.Usage != 0, "No swap chain usage flags defined");
     static_assert(SWAP_CHAIN_USAGE_LAST == SWAP_CHAIN_USAGE_UNORDERED_ACCESS, "Please update this function to handle the new swapchain usage");
 
-    for (Uint32 UsageBit = 1; UsageBit <= m_SwapChainDesc.Usage; UsageBit <<= 1)
     {
-        if ((m_SwapChainDesc.Usage & UsageBit) == 0)
-            continue;
-
-        switch (static_cast<SWAP_CHAIN_USAGE_FLAGS>(UsageBit))
+        auto SCUsage = m_SwapChainDesc.Usage;
+        while (SCUsage != SWAP_CHAIN_USAGE_NONE)
         {
-            // clang-format off
-            case SWAP_CHAIN_USAGE_RENDER_TARGET:    swapchain_ci.imageUsage |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT; break;
-            case SWAP_CHAIN_USAGE_SHADER_INPUT:     swapchain_ci.imageUsage |= VK_IMAGE_USAGE_SAMPLED_BIT;                                            break;
-            case SWAP_CHAIN_USAGE_COPY_SOURCE:      swapchain_ci.imageUsage |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;                                       break;
-            case SWAP_CHAIN_USAGE_UNORDERED_ACCESS: swapchain_ci.imageUsage |= VK_IMAGE_USAGE_STORAGE_BIT;                                            break;
-            default:                                UNEXPECTED("unknown swapchain usage flag");
+            auto UsageBit = static_cast<SWAP_CHAIN_USAGE_FLAGS>(1 << PlatformMisc::GetLSB(Uint32{SCUsage}));
+            switch (UsageBit)
+            {
+                // clang-format off
+                case SWAP_CHAIN_USAGE_RENDER_TARGET:    swapchain_ci.imageUsage |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT; break;
+                case SWAP_CHAIN_USAGE_SHADER_INPUT:     swapchain_ci.imageUsage |= VK_IMAGE_USAGE_SAMPLED_BIT;                                            break;
+                case SWAP_CHAIN_USAGE_COPY_SOURCE:      swapchain_ci.imageUsage |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;                                       break;
+                case SWAP_CHAIN_USAGE_UNORDERED_ACCESS: swapchain_ci.imageUsage |= VK_IMAGE_USAGE_STORAGE_BIT;                                            break;
                 // clang-format on
+                default: UNEXPECTED("unknown swapchain usage flag");
+            }
+            SCUsage &= ~UsageBit;
         }
     }
 
diff --git a/Graphics/GraphicsEngineVulkan/src/VulkanTypeConversions.cpp b/Graphics/GraphicsEngineVulkan/src/VulkanTypeConversions.cpp
index 40882b09..143042b8 100644
--- a/Graphics/GraphicsEngineVulkan/src/VulkanTypeConversions.cpp
+++ b/Graphics/GraphicsEngineVulkan/src/VulkanTypeConversions.cpp
@@ -1187,17 +1187,18 @@ static VkPipelineStageFlags ResourceStateFlagToVkPipelineStage(RESOURCE_STATE St
     }
 }
 
-VkPipelineStageFlags ResourceStateFlagsToVkPipelineStageFlags(RESOURCE_STATE StateFlags, VkPipelineStageFlags ShaderStages)
+VkPipelineStageFlags ResourceStateFlagsToVkPipelineStageFlags(RESOURCE_STATE StateFlags, VkPipelineStageFlags vkShaderStages)
 {
     VERIFY(Uint32{StateFlags} < (RESOURCE_STATE_MAX_BIT << 1), "Resource state flags are out of range");
 
-    VkPipelineStageFlags Stages = 0;
-    for (Uint32 Bit = 1; Bit <= StateFlags; Bit <<= 1)
+    VkPipelineStageFlags vkPipelineStages = 0;
+    while (StateFlags != RESOURCE_STATE_UNKNOWN)
     {
-        if (StateFlags & Bit)
-            Stages |= ResourceStateFlagToVkPipelineStage(static_cast<RESOURCE_STATE>(Bit), ShaderStages);
+        auto StateBit = static_cast<RESOURCE_STATE>(1 << PlatformMisc::GetLSB(Uint32{StateFlags}));
+        vkPipelineStages |= ResourceStateFlagToVkPipelineStage(StateBit, vkShaderStages);
+        StateFlags &= ~StateBit;
     }
-    return Stages;
+    return vkPipelineStages;
 }