Added Matrix3x3::Inverse(), added check for RT feature when using BIND_RAY_TRACING, clamping maxAnisotropy to supported values

azhirnov · TheMostDiligent · commit 3583f5912a6c · 2021-05-17T19:11:39.000-08:00
diff --git a/Common/interface/BasicMath.hpp b/Common/interface/BasicMath.hpp
@@ -228,6 +228,8 @@ template <class T> struct Vector2
 
     Vector2() :
         x{0}, y{0} {}
+    explicit Vector2(T s) :
+        x{s}, y{s} {}
     Vector2(T _x, T _y) :
         x{_x}, y{_y} {}
 
@@ -433,6 +435,8 @@ template <class T> struct Vector3
 
     Vector3() :
         x{0}, y{0}, z{0} {}
+    explicit Vector3(T s) :
+        x{s}, y{s}, z{s} {}
     Vector3(T _x, T _y, T _z) :
         x{_x}, y{_y}, z{_z} {}
 
@@ -652,6 +656,8 @@ template <class T> struct Vector4
 
     Vector4() :
         x{0}, y{0}, z{0}, w{0} {}
+    explicit Vector4(T s) :
+        x{s}, y{s}, z{s}, w{s} {}
     Vector4(T _x, T _y, T _z, T _w) :
         x{_x}, y{_y}, z{_z}, w{_w} {}
     Vector4(const Vector3<T>& v3, T _w) :
@@ -1059,6 +1065,55 @@ template <class T> struct Matrix3x3
         det += _13 * (_21 * _32 - _31 * _22);
         return det;
     }
+
+    Matrix3x3 Inverse() const
+    {
+        Matrix3x3 Inv;
+
+        Inv._11 = Matrix2x2<T>(_22, _23,
+                               _32, _33)
+                      .Determinant();
+
+        Inv._12 = -Matrix2x2<T>(_21, _23,
+                                _31, _33)
+                       .Determinant();
+
+        Inv._13 = Matrix2x2<T>(_21, _22,
+                               _31, _32)
+                      .Determinant();
+
+
+        Inv._21 = -Matrix2x2<T>(_12, _13,
+                                _32, _33)
+                       .Determinant();
+
+        Inv._22 = Matrix2x2<T>(_11, _13,
+                               _31, _33)
+                      .Determinant();
+
+        Inv._23 = -Matrix2x2<T>(_11, _12,
+                                _31, _32)
+                       .Determinant();
+
+
+        Inv._31 = Matrix2x2<T>(_12, _13,
+                               _22, _23)
+                      .Determinant();
+
+        Inv._32 = -Matrix2x2<T>(_11, _13,
+                                _21, _23)
+                       .Determinant();
+
+        Inv._33 = Matrix2x2<T>(_11, _12,
+                               _21, _22)
+                      .Determinant();
+
+        auto det = _11 * Inv._11 + _12 * Inv._12 + _13 * Inv._13;
+        Inv      = Inv.Transpose();
+        Inv *= static_cast<T>(1) / det;
+
+        return Inv;
+    }
 };
 
 template <class T> struct Matrix4x4
diff --git a/Graphics/GraphicsEngine/include/BufferBase.hpp b/Graphics/GraphicsEngine/include/BufferBase.hpp
@@ -43,7 +43,7 @@ namespace Diligent
 {
 
 /// Validates buffer description and throws an exception in case of an error.
-void ValidateBufferDesc(const BufferDesc& Desc, const AdapterMemoryInfo& memoryInfo) noexcept(false);
+void ValidateBufferDesc(const BufferDesc& Desc, const IRenderDevice* pDevice) noexcept(false);
 
 /// Validates initial buffer data parameters and throws an exception in case of an error.
 void ValidateBufferInitData(const BufferDesc& Desc, const BufferData* pBuffData) noexcept(false);
@@ -94,7 +94,7 @@ class BufferBase : public DeviceObjectBase<typename EngineImplTraits::BufferInte
         m_pDefaultUAV{nullptr, STDDeleter<BufferViewImplType, TBuffViewObjAllocator>(BuffViewObjAllocator)},
         m_pDefaultSRV{nullptr, STDDeleter<BufferViewImplType, TBuffViewObjAllocator>(BuffViewObjAllocator)}
     {
-        ValidateBufferDesc(this->m_Desc, pDevice->GetAdapterInfo().Memory);
+        ValidateBufferDesc(this->m_Desc, pDevice);
 
         Uint64 DeviceQueuesMask = pDevice->GetCommandQueueMask();
         DEV_CHECK_ERR((this->m_Desc.ImmediateContextMask & DeviceQueuesMask) != 0,
diff --git a/Graphics/GraphicsEngine/interface/DeviceContext.h b/Graphics/GraphicsEngine/interface/DeviceContext.h
@@ -1176,11 +1176,14 @@ struct InstanceMatrix
     }
 
     /// Sets the rotation part.
-    InstanceMatrix& SetRotation(const float* pMatrix3x3) noexcept
+    InstanceMatrix& SetRotation(const float* pMatrix, Uint32 RowSize = 3) noexcept
     {
-        data[0][0] = pMatrix3x3[0];  data[1][0] = pMatrix3x3[1];  data[2][0] = pMatrix3x3[2];
-        data[0][1] = pMatrix3x3[3];  data[1][1] = pMatrix3x3[4];  data[2][1] = pMatrix3x3[5];
-        data[0][2] = pMatrix3x3[6];  data[1][2] = pMatrix3x3[7];  data[2][2] = pMatrix3x3[8];
+        for (Uint32 r = 0; r < 3; ++r)
+        {
+            for (Uint32 c = 0; c < 3; ++c)
+                data[r][c] = pMatrix[c * RowSize + r];
+        }
+
         return *this;
     }
 #endif
@@ -1202,7 +1205,12 @@ struct TLASBuildInstanceData
     /// Instance to world transformation.
     InstanceMatrix            Transform;
 
-    /// User-defined value that can be accessed in the shader via InstanceID() in HLSL and gl_InstanceCustomIndex in GLSL.
+    /// User-defined value that can be accessed in the shader:
+    ///   HLSL: `InstanceID()` in closest-hit and intersection shaders.
+    ///   HLSL: `RayQuery::CommittedInstanceID()` within inline ray tracing.
+    ///   GLSL: `gl_InstanceCustomIndex` in closest-hit and intersection shaders.
+    ///   GLSL: `rayQueryGetIntersectionInstanceCustomIndex` within inline ray tracing.
+    ///   MSL:  `intersection_result< instancing >::instance_id`.
     /// Only the lower 24 bits are used.
     Uint32                    CustomId        DEFAULT_INITIALIZER(0);
 
diff --git a/Graphics/GraphicsEngine/src/BufferBase.cpp b/Graphics/GraphicsEngine/src/BufferBase.cpp
@@ -43,8 +43,11 @@ namespace Diligent
     } while (false)
 
 
-void ValidateBufferDesc(const BufferDesc& Desc, const AdapterMemoryInfo& memoryInfo) noexcept(false)
+void ValidateBufferDesc(const BufferDesc& Desc, const IRenderDevice* pDevice) noexcept(false)
 {
+    const auto& MemoryInfo = pDevice->GetAdapterInfo().Memory;
+    const auto& Features   = pDevice->GetDeviceInfo().Features;
+
     static_assert(BIND_FLAGS_LAST == 0x400L, "Please update this function to handle the new bind flags");
 
     constexpr Uint32 AllowedBindFlags =
@@ -72,6 +75,9 @@ void ValidateBufferDesc(const BufferDesc& Desc, const AdapterMemoryInfo& memoryI
         }
     }
 
+    if ((Desc.BindFlags & BIND_RAY_TRACING) != 0)
+        VERIFY_BUFFER(Features.RayTracing, "BIND_RAY_TRACING flag can't be used when RayTracing feature is not enabled.");
+
     switch (Desc.Usage)
     {
         case USAGE_IMMUTABLE:
@@ -91,20 +97,20 @@ void ValidateBufferDesc(const BufferDesc& Desc, const AdapterMemoryInfo& memoryI
             break;
 
         case USAGE_UNIFIED:
-            VERIFY_BUFFER(memoryInfo.UnifiedMemory != 0,
+            VERIFY_BUFFER(MemoryInfo.UnifiedMemory != 0,
                           "Unified memory is not present on this device. Check the amount of available unified memory "
                           "in the device caps before creating unified buffers.");
             VERIFY_BUFFER(Desc.CPUAccessFlags != CPU_ACCESS_NONE,
                           "at least one of CPU_ACCESS_WRITE or CPU_ACCESS_READ flags must be specified for a unified buffer.");
             if (Desc.CPUAccessFlags & CPU_ACCESS_WRITE)
             {
-                VERIFY_BUFFER(memoryInfo.UnifiedMemoryCPUAccess & CPU_ACCESS_WRITE,
+                VERIFY_BUFFER(MemoryInfo.UnifiedMemoryCPUAccess & CPU_ACCESS_WRITE,
                               "Unified memory on this device does not support write access. Check the available access flags "
                               "in the device caps before creating unified buffers.");
             }
             if (Desc.CPUAccessFlags & CPU_ACCESS_READ)
             {
-                VERIFY_BUFFER(memoryInfo.UnifiedMemoryCPUAccess & CPU_ACCESS_READ,
+                VERIFY_BUFFER(MemoryInfo.UnifiedMemoryCPUAccess & CPU_ACCESS_READ,
                               "Unified memory on this device does not support read access. Check the available access flags "
                               "in the device caps before creating unified buffers.");
             }
diff --git a/Graphics/GraphicsEngineVulkan/src/SamplerVkImpl.cpp b/Graphics/GraphicsEngineVulkan/src/SamplerVkImpl.cpp
@@ -30,6 +30,7 @@
 #include "RenderDeviceVkImpl.hpp"
 #include "VulkanTypeConversions.hpp"
 #include "GraphicsAccessories.hpp"
+#include "BasicMath.hpp"
 
 namespace Diligent
 {
@@ -45,34 +46,30 @@ SamplerVkImpl::SamplerVkImpl(IReferenceCounters* pRefCounters, RenderDeviceVkImp
 // clang-format on
 {
     const auto& LogicalDevice = pRenderDeviceVk->GetLogicalDevice();
+    const auto& Limits        = pRenderDeviceVk->GetPhysicalDevice().GetProperties().limits;
 
     VkSamplerCreateInfo SamplerCI{};
-    SamplerCI.sType            = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
-    SamplerCI.pNext            = nullptr;
-    SamplerCI.flags            = 0; // reserved for future use
-    SamplerCI.magFilter        = FilterTypeToVkFilter(m_Desc.MagFilter);
-    SamplerCI.minFilter        = FilterTypeToVkFilter(m_Desc.MinFilter);
-    SamplerCI.mipmapMode       = FilterTypeToVkMipmapMode(m_Desc.MipFilter);
-    SamplerCI.addressModeU     = AddressModeToVkAddressMode(m_Desc.AddressU);
-    SamplerCI.addressModeV     = AddressModeToVkAddressMode(m_Desc.AddressV);
-    SamplerCI.addressModeW     = AddressModeToVkAddressMode(m_Desc.AddressW);
-    SamplerCI.mipLodBias       = m_Desc.MipLODBias;
+    SamplerCI.sType        = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
+    SamplerCI.pNext        = nullptr;
+    SamplerCI.flags        = 0; // reserved for future use
+    SamplerCI.magFilter    = FilterTypeToVkFilter(m_Desc.MagFilter);
+    SamplerCI.minFilter    = FilterTypeToVkFilter(m_Desc.MinFilter);
+    SamplerCI.mipmapMode   = FilterTypeToVkMipmapMode(m_Desc.MipFilter);
+    SamplerCI.addressModeU = AddressModeToVkAddressMode(m_Desc.AddressU);
+    SamplerCI.addressModeV = AddressModeToVkAddressMode(m_Desc.AddressV);
+    SamplerCI.addressModeW = AddressModeToVkAddressMode(m_Desc.AddressW);
+    SamplerCI.mipLodBias   = m_Desc.MipLODBias;
+
     SamplerCI.anisotropyEnable = IsAnisotropicFilter(m_Desc.MinFilter);
-#ifdef DILIGENT_DEVELOPMENT
-    if ((SamplerCI.anisotropyEnable != VK_FALSE) != IsAnisotropicFilter(m_Desc.MagFilter))
-    {
-        LOG_ERROR("Min and mag filters must both be either anisotropic filters or non-anisotropic ones");
-    }
-#endif
+    DEV_CHECK_ERR(!SamplerCI.anisotropyEnable || (m_Desc.MaxAnisotropy >= 1 && static_cast<float>(m_Desc.MaxAnisotropy) <= Limits.maxSamplerAnisotropy),
+                  "MaxAnisotropy (", m_Desc.MaxAnisotropy, ") must be in range 1 .. ", Limits.maxSamplerAnisotropy, ".");
+    SamplerCI.maxAnisotropy = SamplerCI.anisotropyEnable ? clamp(static_cast<float>(m_Desc.MaxAnisotropy), 1.f, Limits.maxSamplerAnisotropy) : 0.f;
+    DEV_CHECK_ERR((SamplerCI.anisotropyEnable != VK_FALSE) == IsAnisotropicFilter(m_Desc.MagFilter),
+                  "Min and mag filters must both be either anisotropic filters or non-anisotropic ones");
 
-    SamplerCI.maxAnisotropy = static_cast<float>(m_Desc.MaxAnisotropy);
     SamplerCI.compareEnable = IsComparisonFilter(m_Desc.MinFilter);
-#ifdef DILIGENT_DEVELOPMENT
-    if ((SamplerCI.compareEnable != VK_FALSE) != IsComparisonFilter(m_Desc.MagFilter))
-    {
-        LOG_ERROR("Min and mag filters must both be either comparison filters or non-comparison ones");
-    }
-#endif
+    DEV_CHECK_ERR((SamplerCI.compareEnable != VK_FALSE) == IsComparisonFilter(m_Desc.MagFilter),
+                  "Min and mag filters must both be either comparison filters or non-comparison ones");
 
     SamplerCI.compareOp               = ComparisonFuncToVkCompareOp(m_Desc.ComparisonFunc);
     SamplerCI.minLod                  = m_Desc.MinLOD;
diff --git a/Graphics/ShaderTools/src/DXCompiler.cpp b/Graphics/ShaderTools/src/DXCompiler.cpp
@@ -751,6 +751,7 @@ void DXCompilerImpl::Compile(const ShaderCreateInfo& ShaderCI,
                 L"-fspv-reflect",
                 //L"-WX", // Warnings as errors
                 L"-O3", // Optimization level 3
+                L"-Zpc" // Matrices in column-major order
             });
 
         if (m_APIVersion >= VK_API_VERSION_1_2 && ShaderModel >= ShaderVersion{6, 3})
diff --git a/Tests/DiligentCoreTest/src/Common/MathLibTest.cpp b/Tests/DiligentCoreTest/src/Common/MathLibTest.cpp
@@ -964,6 +964,44 @@ TEST(Common_BasicMath, MatrixInverse)
             }
         }
     }
+
+    // Determinant
+    {
+        // clang-format off
+        float3x3 m1
+        {
+            1,  2,   3,
+            5,  6,   7,
+            9, 10,  11
+        };
+        // clang-format on
+        auto det = m1.Determinant();
+        EXPECT_EQ(det, 0);
+    }
+
+    {
+        // clang-format off
+        const float3x3 m
+        {
+            7,   8,  3,
+            5,   1,  4,
+            5,  11,  7
+        };
+        // clang-format on
+
+        auto inv      = m.Inverse();
+        auto identity = m * inv;
+
+        for (int j = 0; j < 3; ++j)
+        {
+            for (int i = 0; i < 3; ++i)
+            {
+                float ref = i == j ? 1.f : 0.f;
+                auto  val = identity[i][j];
+                EXPECT_NEAR(val, ref, 1e-6f);
+            }
+        }
+    }
 }
 
 

Original file line number	Diff line number	Diff line change
`@@ -43,7 +43,7 @@ namespace Diligent`
`43`	`43`	`{`
`44`	`44`
`45`	`45`	`/// Validates buffer description and throws an exception in case of an error.`
`46`		`-void ValidateBufferDesc(const BufferDesc& Desc, const AdapterMemoryInfo& memoryInfo) noexcept(false);`
	`46`	`+void ValidateBufferDesc(const BufferDesc& Desc, const IRenderDevice* pDevice) noexcept(false);`
`47`	`47`
`48`	`48`	`/// Validates initial buffer data parameters and throws an exception in case of an error.`
`49`	`49`	`void ValidateBufferInitData(const BufferDesc& Desc, const BufferData* pBuffData) noexcept(false);`
`@@ -94,7 +94,7 @@ class BufferBase : public DeviceObjectBase<typename EngineImplTraits::BufferInte`
`94`	`94`	`m_pDefaultUAV{nullptr, STDDeleter<BufferViewImplType, TBuffViewObjAllocator>(BuffViewObjAllocator)},`
`95`	`95`	`m_pDefaultSRV{nullptr, STDDeleter<BufferViewImplType, TBuffViewObjAllocator>(BuffViewObjAllocator)}`
`96`	`96`	`{`
`97`		`- ValidateBufferDesc(this->m_Desc, pDevice->GetAdapterInfo().Memory);`
	`97`	`+ ValidateBufferDesc(this->m_Desc, pDevice);`
`98`	`98`
`99`	`99`	`Uint64 DeviceQueuesMask = pDevice->GetCommandQueueMask();`
`100`	`100`	`DEV_CHECK_ERR((this->m_Desc.ImmediateContextMask & DeviceQueuesMask) != 0,`
Original file line number	Diff line number	Diff line change
`@@ -43,8 +43,11 @@ namespace Diligent`
`43`	`43`	`} while (false)`
`44`	`44`
`45`	`45`
`46`		`-void ValidateBufferDesc(const BufferDesc& Desc, const AdapterMemoryInfo& memoryInfo) noexcept(false)`
	`46`	`+void ValidateBufferDesc(const BufferDesc& Desc, const IRenderDevice* pDevice) noexcept(false)`
`47`	`47`	`{`
	`48`	`+ const auto& MemoryInfo = pDevice->GetAdapterInfo().Memory;`
	`49`	`+ const auto& Features = pDevice->GetDeviceInfo().Features;`
	`50`	`+`
`48`	`51`	`static_assert(BIND_FLAGS_LAST == 0x400L, "Please update this function to handle the new bind flags");`
`49`	`52`
`50`	`53`	`constexpr Uint32 AllowedBindFlags =`
`@@ -72,6 +75,9 @@ void ValidateBufferDesc(const BufferDesc& Desc, const AdapterMemoryInfo& memoryI`
`72`	`75`	`}`
`73`	`76`	`}`
`74`	`77`
	`78`	`+ if ((Desc.BindFlags & BIND_RAY_TRACING) != 0)`
	`79`	`+ VERIFY_BUFFER(Features.RayTracing, "BIND_RAY_TRACING flag can't be used when RayTracing feature is not enabled.");`
	`80`	`+`
`75`	`81`	`switch (Desc.Usage)`
`76`	`82`	`{`
`77`	`83`	`case USAGE_IMMUTABLE:`
`@@ -91,20 +97,20 @@ void ValidateBufferDesc(const BufferDesc& Desc, const AdapterMemoryInfo& memoryI`
`91`	`97`	`break;`
`92`	`98`
`93`	`99`	`case USAGE_UNIFIED:`
`94`		`- VERIFY_BUFFER(memoryInfo.UnifiedMemory != 0,`
	`100`	`+ VERIFY_BUFFER(MemoryInfo.UnifiedMemory != 0,`
`95`	`101`	`"Unified memory is not present on this device. Check the amount of available unified memory "`
`96`	`102`	`"in the device caps before creating unified buffers.");`
`97`	`103`	`VERIFY_BUFFER(Desc.CPUAccessFlags != CPU_ACCESS_NONE,`
`98`	`104`	`"at least one of CPU_ACCESS_WRITE or CPU_ACCESS_READ flags must be specified for a unified buffer.");`
`99`	`105`	`if (Desc.CPUAccessFlags & CPU_ACCESS_WRITE)`
`100`	`106`	`{`
`101`		`- VERIFY_BUFFER(memoryInfo.UnifiedMemoryCPUAccess & CPU_ACCESS_WRITE,`
	`107`	`+ VERIFY_BUFFER(MemoryInfo.UnifiedMemoryCPUAccess & CPU_ACCESS_WRITE,`
`102`	`108`	`"Unified memory on this device does not support write access. Check the available access flags "`
`103`	`109`	`"in the device caps before creating unified buffers.");`
`104`	`110`	`}`
`105`	`111`	`if (Desc.CPUAccessFlags & CPU_ACCESS_READ)`
`106`	`112`	`{`
`107`		`- VERIFY_BUFFER(memoryInfo.UnifiedMemoryCPUAccess & CPU_ACCESS_READ,`
	`113`	`+ VERIFY_BUFFER(MemoryInfo.UnifiedMemoryCPUAccess & CPU_ACCESS_READ,`
`108`	`114`	`"Unified memory on this device does not support read access. Check the available access flags "`
`109`	`115`	`"in the device caps before creating unified buffers.");`
`110`	`116`	`}`