removed tons of duplicate code!

devshgraphicsprogramming · devshgraphicsprogramming · commit 4a2c18c18fcd · 2024-03-14T17:48:45.000+01:00
diff --git a/examples_tests b/examples_tests
@@ -1 +1 @@
-Subproject commit c5620756c10632ea826997e5e1344a2c82072ad3
+Subproject commit 26e4ad199600330dd6d5dc6ff124544a7381b871
diff --git a/include/nbl/builtin/hlsl/surface_transform.h b/include/nbl/builtin/hlsl/surface_transform.h
@@ -3,6 +3,7 @@
 // For conditions of distribution and use, see copyright notice in nabla.h
 #ifndef _NBL_BUILTIN_HLSL_SURFACE_TRANSFORM_INCLUDED_
 #define _NBL_BUILTIN_HLSL_SURFACE_TRANSFORM_INCLUDED_
+#include <nbl/builtin/hlsl/limits.hlsl>
 
 namespace nbl
 {
@@ -24,6 +25,70 @@ enum class FLAG_BITS : uint16_t
     HORIZONTAL_MIRROR_ROTATE_270_BIT = 0x0080,
     INHERIT_BIT = 0x0100,
     ALL_BITS = 0x01FF
+};
+
+// define everything else in terms of this
+float32_t2x2 transformMatrix(const FLAG_BITS transform)
+{
+    switch (transform)
+    {
+        case FLAG_BITS::IDENTITY_BIT:
+            return float32_t2x2( 1.f, 0.f,
+                                 0.f, 1.f);
+        case FLAG_BITS::ROTATE_90_BIT:
+            return float32_t2x2( 0.f, 1.f,
+                                -1.f, 0.f);
+        case FLAG_BITS::ROTATE_180_BIT:
+            return float32_t2x2(-1.f, 0.f,
+                                 0.f,-1.f);
+        case FLAG_BITS::ROTATE_270_BIT:
+            return float32_t2x2( 0.f,-1.f,
+                                 1.f, 0.f);
+        case FLAG_BITS::HORIZONTAL_MIRROR_BIT:
+            return float32_t2x2(-1.f, 0.f,
+                                 0.f, 1.f);
+        case FLAG_BITS::HORIZONTAL_MIRROR_ROTATE_90_BIT:
+            return float32_t2x2( 0.f, 1.f,
+                                 1.f, 0.f);
+        case FLAG_BITS::HORIZONTAL_MIRROR_ROTATE_180_BIT:
+            return float32_t2x2( 1.f, 0.f,
+                                 0.f,-1.f);
+        case FLAG_BITS::HORIZONTAL_MIRROR_ROTATE_270_BIT:
+            return float32_t2x2( 0.f,-1.f,
+                                -1.f, 0.f);
+        default:
+            break;
+    }
+    const float _nan = numeric_limits<float>::signaling_NaN;
+    return float32_t2x2(_nan,_nan,_nan,_nan);
+}
+
+//! [width,height] might switch to [height, width] in orientations such as 90�CW
+//! Usecase: Find out how big the viewport has to be after or before a tranform is applied
+uint16_t2 transformedExtents(const FLAG_BITS transform, const uint16_t2 screenSize)
+{
+    switch (transform)
+    {
+        case FLAG_BITS::IDENTITY_BIT:
+        case FLAG_BITS::HORIZONTAL_MIRROR_BIT:
+        case FLAG_BITS::HORIZONTAL_MIRROR_ROTATE_180_BIT:
+        case FLAG_BITS::ROTATE_180_BIT:
+            return screenSize;
+        case FLAG_BITS::ROTATE_90_BIT:
+        case FLAG_BITS::ROTATE_270_BIT:
+        case FLAG_BITS::HORIZONTAL_MIRROR_ROTATE_90_BIT:
+        case FLAG_BITS::HORIZONTAL_MIRROR_ROTATE_270_BIT:
+            return screenSize.yx;
+        default:
+            break;
+    }
+    return uint16_t2(0);
+}
+
+float transformedAspectRatio(const FLAG_BITS transform, const uint16_t2 screenSize)
+{
+    const uint16_t2 newExtents = transformedExtents(transform,screenSize);
+    return float(newExtents[1])/float(newExtents[0]);
 }
 
 //! Use this function to apply the INVERSE of swapchain tranformation to the screenspace coordinate `coord` 
@@ -35,6 +100,7 @@ enum class FLAG_BITS : uint16_t
 //! - Be aware that almost always you'd want to do a single transform in your rendering pipeline.
 uint16_t2 applyInverseToScreenSpaceCoordinate(const FLAG_BITS transform, const uint16_t2 coord, const uint16_t2 screenSize)
 {
+    // TODO: use inverse(transformMatrix(transform)) somehow
     const uint16_t2 lastTexel = screenSize - uint16_t2(1,1);
     switch (transform)
     {
@@ -66,8 +132,9 @@ uint16_t2 applyInverseToScreenSpaceCoordinate(const FLAG_BITS transform, const u
 //! Warning: Be aware that almost always you'd want to do a single transform in your rendering pipeline.
 uint16_t2 applyToScreenSpaceCoordinate(const FLAG_BITS transform, const uint16_t2 coord, const uint16_t2 screenSize)
 {
-    const uint16_t2 lastTexel = screenSize - uint16_t2(1);
-    switch (swapchainTransform)
+    // TODO: use transformMatrix(transform) somehow
+    const uint16_t2 lastTexel = screenSize - uint16_t2(1, 1);
+    switch (transform)
     {
         case FLAG_BITS::IDENTITY_BIT:
             return coord;
@@ -91,56 +158,13 @@ uint16_t2 applyToScreenSpaceCoordinate(const FLAG_BITS transform, const uint16_t
     return uint16_t2(0);
 }
 
-//! [width,height] might switch to [height, width] in orientations such as 90�CW
-//! Usecase: Find out how big the viewport has to be after or before a tranform is applied
-uint16_t2 transformedExtents(const FLAG_BITS transform, const uint16_t2 screenSize)
-{
-    switch (swapchainTransform) 
-    {
-        case FLAG_BITS::IDENTITY_BIT:
-        case FLAG_BITS::HORIZONTAL_MIRROR_BIT:
-        case FLAG_BITS::HORIZONTAL_MIRROR_ROTATE_180_BIT:
-        case FLAG_BITS::ROTATE_180_BIT:
-            return screenSize;
-        case FLAG_BITS::ROTATE_90_BIT:
-        case FLAG_BITS::ROTATE_270_BIT:
-        case FLAG_BITS::HORIZONTAL_MIRROR_ROTATE_90_BIT:
-        case FLAG_BITS::HORIZONTAL_MIRROR_ROTATE_270_BIT:
-            return screenSize.yx;
-        default:
-            break;
-    }
-    return uint16_t2(0);
-}
-
 //! Same as `applyToScreenSpaceCoordinate` but const NDC space
 //! If rendering to the swapchain, you may use this function to transform the NDC coordinates directly
 //! to be fed into gl_Position in vertex shading
 //! Warning: Be aware that almost always you'd want to do a single transform in your rendering pipeline.
 float32_t2 applyToNDC(const FLAG_BITS transform, const float32_t2 ndc)
 {
-    switch (swapchainTransform) 
-    {
-        case FLAG_BITS::IDENTITY_BIT:
-            return ndc;
-        case FLAG_BITS::ROTATE_90_BIT:
-            return float32_t2(-ndc.y,ndc.x);
-        case FLAG_BITS::ROTATE_180_BIT:
-            return -ndc;
-        case FLAG_BITS::ROTATE_270_BIT:
-            return float32_t2(ndc.y,-ndc.x);
-        case FLAG_BITS::HORIZONTAL_MIRROR_BIT:
-            return float32_t2(-ndc.x,ndc.y);
-        case FLAG_BITS::HORIZONTAL_MIRROR_ROTATE_90_BIT:
-            return ndc.yx;
-        case FLAG_BITS::HORIZONTAL_MIRROR_ROTATE_180_BIT:
-            return float32_t2(ndc.x,-ndc.y);
-        case FLAG_BITS::HORIZONTAL_MIRROR_ROTATE_270_BIT:
-            return -ndc.yx;
-        default:
-            break;
-    }
-    return float32_t2(0,0)/0.f;
+    return mul(transformMatrix(transform),ndc);
 }
 
 // TODO: This is untested
@@ -149,37 +173,8 @@ float32_t2 applyToNDC(const FLAG_BITS transform, const float32_t2 ndc)
 template<typename TwoColumns>
 TwoColumns applyToDerivatives(const FLAG_BITS transform, TwoColumns dDx_dDy)
 {
-    switch (swapchainTransform)
-    {
-        case FLAG_BITS::IDENTITY_BIT:
-            return dDx_dDy;
-        case FLAG_BITS::ROTATE_90_BIT:
-            return mul(dDx_dDy,float32_t2x2( 0.f,-1.f
-                                             1.f, 0.f));
-        case FLAG_BITS::ROTATE_180_BIT:
-            return mul(dDx_dDy,float32_t2x2(-1.f, 0.f
-                                             0.f,-1.f));
-        case FLAG_BITS::ROTATE_270_BIT:
-            return mul(dDx_dDy,float32_t2x2( 0.f, 1.f
-                                            -1.f, 0.f));
-        case FLAG_BITS::HORIZONTAL_MIRROR_BIT:
-            return mul(dDx_dDy,float32_t2x2(-1.f, 0.f
-                                             0.f, 1.f));
-        case FLAG_BITS::HORIZONTAL_MIRROR_ROTATE_90_BIT:
-            return mul(dDx_dDy,float32_t2x2( 0.f, 1.f
-                                             1.f, 0.f));
-        case FLAG_BITS::HORIZONTAL_MIRROR_ROTATE_180_BIT:
-            return mul(dDx_dDy,float32_t2x2( 1.f, 0.f
-                                             0.f,-1.f));
-        case FLAG_BITS::HORIZONTAL_MIRROR_ROTATE_270_BIT:
-            return mul(dDx_dDy,float32_t2x2( 0.f,-1.f
-                                            -1.f, 0.f));
-        default:
-            break;
-    }
-    return dDx_dDy*(0.f/0.f);
+    return mul(inverse(transformMatrix(transform)),dDx_dDy);
 }
-// TODO: could define the NDC in terms of inverse Derivative XForm
 
 }
 }
diff --git a/include/nbl/video/ISwapchain.h b/include/nbl/video/ISwapchain.h
@@ -73,15 +73,15 @@ class ISwapchain : public IBackendObject
                 ISurface::ECA_POST_MULTIPLIED_BIT,
                 ISurface::ECA_INHERIT_BIT
             };
-            constexpr static inline ISurface::E_SURFACE_TRANSFORM_FLAGS DefaultPreferredTransforms[] = {
-                ISurface::EST_IDENTITY_BIT
+            constexpr static inline hlsl::SurfaceTransform::FLAG_BITS DefaultPreferredTransforms[] = {
+                hlsl::SurfaceTransform::FLAG_BITS::IDENTITY_BIT
                 // nothing else will work out the box without us explicitly having to handle it
             };
             inline bool deduce(
                 const IPhysicalDevice* physDev, const ISurface* surface,
                 std::span<const ISurface::E_PRESENT_MODE> preferredPresentModes=DefaultPreferredPresentModes,
                 std::span<const ISurface::E_COMPOSITE_ALPHA> preferredCompositeAlphas=DefaultPreferredCompositeAlphas,
-                std::span<const ISurface::E_SURFACE_TRANSFORM_FLAGS> preferredTransforms=DefaultPreferredTransforms
+                std::span<const hlsl::SurfaceTransform::FLAG_BITS> preferredTransforms=DefaultPreferredTransforms
             )
             {
                 ISurface::SCapabilities caps;
@@ -174,7 +174,7 @@ class ISwapchain : public IBackendObject
             uint16_t height = 0u;
             core::bitflag<ISurface::E_COMPOSITE_ALPHA> compositeAlpha = ISurface::ECA_ALL_BITS;
             uint8_t arrayLayers = 1u;
-            core::bitflag<ISurface::E_SURFACE_TRANSFORM_FLAGS> preTransform = ISurface::EST_ALL_BITS;
+            core::bitflag<hlsl::SurfaceTransform::FLAG_BITS> preTransform = hlsl::SurfaceTransform::FLAG_BITS::ALL_BITS;
             // If you set it to something else then your Swapchain will be created with Mutable Format capability
             // NOTE: If you do that, then the bitset needs to contain `viewFormats[surfaceFormat.format] = true` which is deduced later
             std::bitset<asset::E_FORMAT::EF_COUNT> viewFormats = {};
@@ -315,7 +315,7 @@ class ISwapchain : public IBackendObject
 
         // The value passed to `preTransform` when creating the swapchain. "pre" refers to the transform happening
         // as an operation before the presentation engine presents the image.
-        inline ISurface::E_SURFACE_TRANSFORM_FLAGS getPreTransform() const { return m_params.sharedParams.preTransform.value; }
+        inline hlsl::SurfaceTransform::FLAG_BITS getPreTransform() const { return m_params.sharedParams.preTransform.value; }
         
         //
         inline uint64_t getAcquireCount() const {return m_acquireCounter;}
diff --git a/include/nbl/video/surface/ISurface.h b/include/nbl/video/surface/ISurface.h
@@ -7,6 +7,7 @@
 #include "nbl/asset/format/EFormat.h"
 
 #include "nbl/video/IAPIConnection.h"
+#include "nbl/builtin/hlsl/surface_transform.h"
 
 #define VK_NO_PROTOTYPES
 #include "vulkan/vulkan.h"
@@ -44,7 +45,8 @@ class ISurface : public core::IReferenceCounted
             asset::E_FORMAT format = asset::EF_UNKNOWN;
             SColorSpace colorSpace = {};
         };
-        // TODO: move these structs and enums to HLSL header!
+
+        // TODO: move these enums to HLSL header!
         enum E_PRESENT_MODE : uint8_t
         {
             EPM_NONE = 0x0,
@@ -56,105 +58,6 @@ class ISurface : public core::IReferenceCounted
             EPM_UNKNOWN = 0
         };
 
-        enum E_SURFACE_TRANSFORM_FLAGS : uint16_t
-        {
-            EST_NONE = 0x0,
-            EST_IDENTITY_BIT = 0x0001,
-            EST_ROTATE_90_BIT = 0x0002,
-            EST_ROTATE_180_BIT = 0x0004,
-            EST_ROTATE_270_BIT = 0x0008,
-            EST_HORIZONTAL_MIRROR_BIT = 0x0010,
-            EST_HORIZONTAL_MIRROR_ROTATE_90_BIT = 0x0020,
-            EST_HORIZONTAL_MIRROR_ROTATE_180_BIT = 0x0040,
-            EST_HORIZONTAL_MIRROR_ROTATE_270_BIT = 0x0080,
-            EST_INHERIT_BIT = 0x0100,
-            EST_ALL_BITS = 0x01FF
-        };
-
-        // A matrix that can be pre-multiplied to the projection matrix in order to apply the
-        // surface transform.
-        static inline core::matrix4SIMD getSurfaceTransformationMatrix(const E_SURFACE_TRANSFORM_FLAGS transform)
-        {
-            const float sin90 = 1.0, cos90 = 0.0,
-                sin180 = 0.0, cos180 = -1.0,
-                sin270 = -1.0, cos270 = 0.0;
-
-            switch (transform)
-            {
-            case ISurface::E_SURFACE_TRANSFORM_FLAGS::EST_ROTATE_90_BIT:
-                return core::matrix4SIMD(
-                    cos90, -sin90, 0.0, 0.0,
-                    sin90, cos90, 0.0, 0.0,
-                    0.0, 0.0, 1.0, 0.0,
-                    0.0, 0.0, 0.0, 1.0
-                );
-            case ISurface::E_SURFACE_TRANSFORM_FLAGS::EST_ROTATE_180_BIT:
-                return core::matrix4SIMD(
-                    cos180, -sin180, 0.0, 0.0,
-                    sin180, cos180, 0.0, 0.0,
-                    0.0, 0.0, 1.0, 0.0,
-                    0.0, 0.0, 0.0, 1.0
-                );
-            case ISurface::E_SURFACE_TRANSFORM_FLAGS::EST_ROTATE_270_BIT:
-                return core::matrix4SIMD(
-                    cos270, -sin270, 0.0, 0.0,
-                    sin270, cos270, 0.0, 0.0,
-                    0.0, 0.0, 1.0, 0.0,
-                    0.0, 0.0, 0.0, 1.0
-                );
-            case ISurface::E_SURFACE_TRANSFORM_FLAGS::EST_HORIZONTAL_MIRROR_BIT:
-                return core::matrix4SIMD(
-                    -1.0, 0.0, 0.0, 0.0,
-                    0.0, 1.0, 0.0, 0.0,
-                    0.0, 0.0, 1.0, 0.0,
-                    0.0, 0.0, 0.0, 1.0
-                );
-            // The same matricies as the rotation ones above, but with the horizontal mirror matrix
-            // (directly above this) pre-multiplied
-            case ISurface::E_SURFACE_TRANSFORM_FLAGS::EST_HORIZONTAL_MIRROR_ROTATE_90_BIT:
-                return core::matrix4SIMD(
-                    -cos90, sin90, 0.0, 0.0,
-                    sin90, cos90, 0.0, 0.0,
-                    0.0, 0.0, 1.0, 0.0,
-                    0.0, 0.0, 0.0, 1.0
-                );
-            case ISurface::E_SURFACE_TRANSFORM_FLAGS::EST_HORIZONTAL_MIRROR_ROTATE_180_BIT:
-                return core::matrix4SIMD(
-                    -cos180, sin180, 0.0, 0.0,
-                    sin180, cos180, 0.0, 0.0,
-                    0.0, 0.0, 1.0, 0.0,
-                    0.0, 0.0, 0.0, 1.0
-                );
-            case ISurface::E_SURFACE_TRANSFORM_FLAGS::EST_HORIZONTAL_MIRROR_ROTATE_270_BIT:
-                return core::matrix4SIMD(
-                    -cos270, sin270, 0.0, 0.0,
-                    sin270, cos270, 0.0, 0.0,
-                    0.0, 0.0, 1.0, 0.0,
-                    0.0, 0.0, 0.0, 1.0
-                );
-            default:
-                return core::matrix4SIMD();
-            }
-        }
-
-        static inline float getTransformedAspectRatio(const E_SURFACE_TRANSFORM_FLAGS transform, uint32_t w, uint32_t h)
-        {
-            switch (transform)
-            {
-            case ISurface::E_SURFACE_TRANSFORM_FLAGS::EST_ROTATE_90_BIT:
-            case ISurface::E_SURFACE_TRANSFORM_FLAGS::EST_ROTATE_270_BIT:
-            case ISurface::E_SURFACE_TRANSFORM_FLAGS::EST_HORIZONTAL_MIRROR_ROTATE_90_BIT:
-            case ISurface::E_SURFACE_TRANSFORM_FLAGS::EST_HORIZONTAL_MIRROR_ROTATE_270_BIT:
-                return float(h) / w;
-            case ISurface::E_SURFACE_TRANSFORM_FLAGS::EST_ROTATE_180_BIT:
-            case ISurface::E_SURFACE_TRANSFORM_FLAGS::EST_HORIZONTAL_MIRROR_BIT:
-            case ISurface::E_SURFACE_TRANSFORM_FLAGS::EST_HORIZONTAL_MIRROR_ROTATE_180_BIT:
-                return float(w) / h;
-            default:
-                return float(w) / h;
-            }
-        }
-
         enum E_COMPOSITE_ALPHA : uint8_t
         {
             ECA_NONE = 0x0,
@@ -176,8 +79,8 @@ class ISurface : public core::IReferenceCounted
             uint8_t maxImageCount = 0;
             uint8_t maxImageArrayLayers = 0;
             core::bitflag<E_COMPOSITE_ALPHA> supportedCompositeAlpha = ECA_NONE;
-            core::bitflag<E_SURFACE_TRANSFORM_FLAGS> supportedTransforms = EST_NONE;
-            E_SURFACE_TRANSFORM_FLAGS currentTransform = EST_NONE;
+            core::bitflag<hlsl::SurfaceTransform::FLAG_BITS> supportedTransforms = hlsl::SurfaceTransform::FLAG_BITS::NONE;
+            hlsl::SurfaceTransform::FLAG_BITS currentTransform = hlsl::SurfaceTransform::FLAG_BITS::NONE;
         };
 
         inline E_API_TYPE getAPIType() const { return m_api->getAPIType(); }
diff --git a/src/nbl/builtin/CMakeLists.txt b/src/nbl/builtin/CMakeLists.txt
@@ -290,7 +290,7 @@ LIST_BUILTIN_RESOURCE(NBL_RESOURCES_TO_EMBED "hlsl/subgroup/basic.hlsl")
 LIST_BUILTIN_RESOURCE(NBL_RESOURCES_TO_EMBED "hlsl/subgroup/arithmetic_portability.hlsl")
 LIST_BUILTIN_RESOURCE(NBL_RESOURCES_TO_EMBED "hlsl/subgroup/arithmetic_portability_impl.hlsl")
 #shared header between C++ and HLSL
-LIST_BUILTIN_RESOURCE(NBL_RESOURCES_TO_EMBED "hlsl/surface_transform.hlsl")
+LIST_BUILTIN_RESOURCE(NBL_RESOURCES_TO_EMBED "hlsl/surface_transform.h")
 #workgroup
 LIST_BUILTIN_RESOURCE(NBL_RESOURCES_TO_EMBED "hlsl/workgroup/arithmetic.hlsl")
 LIST_BUILTIN_RESOURCE(NBL_RESOURCES_TO_EMBED "hlsl/workgroup/basic.hlsl")
diff --git a/src/nbl/video/CSurfaceVulkan.cpp b/src/nbl/video/CSurfaceVulkan.cpp
@@ -111,8 +111,8 @@ bool ISurfaceVulkan::isSupportedForPhysicalDevice(const IPhysicalDevice* physica
 		capabilities.minImageExtent = vk_surfaceCapabilities.surfaceCapabilities.minImageExtent;
 		capabilities.maxImageExtent = vk_surfaceCapabilities.surfaceCapabilities.maxImageExtent;
 		capabilities.maxImageArrayLayers = vk_surfaceCapabilities.surfaceCapabilities.maxImageArrayLayers;
-		capabilities.supportedTransforms = static_cast<ISurface::E_SURFACE_TRANSFORM_FLAGS>(vk_surfaceCapabilities.surfaceCapabilities.supportedTransforms);
-		capabilities.currentTransform = static_cast<ISurface::E_SURFACE_TRANSFORM_FLAGS>(vk_surfaceCapabilities.surfaceCapabilities.currentTransform);
+		capabilities.supportedTransforms = static_cast<hlsl::SurfaceTransform::FLAG_BITS>(vk_surfaceCapabilities.surfaceCapabilities.supportedTransforms);
+		capabilities.currentTransform = static_cast<hlsl::SurfaceTransform::FLAG_BITS>(vk_surfaceCapabilities.surfaceCapabilities.currentTransform);
 		capabilities.supportedCompositeAlpha = static_cast<ISurface::E_COMPOSITE_ALPHA>(vk_surfaceCapabilities.surfaceCapabilities.supportedCompositeAlpha);
 		capabilities.supportedUsageFlags = getImageUsageFlagsFromVkImageUsageFlags(vk_surfaceCapabilities.surfaceCapabilities.supportedUsageFlags);
 
