wipe CIESProfile::octahdronUVToDir and use HLSL version

Author: AnastaZIuk

include/nbl/builtin/hlsl/math/octahedral.hlsl

@@ -16,49 +16,55 @@ namespace math
 {
 
 // Octahedral Transform, maps 3D direction vectors to 2D square and vice versa
-template<typename T = float64_t>
+template<typename T = float32_t>
 struct OctahedralTransform
 {
     using scalar_type   = T;
     using vector2_type  = vector<T, 2>;
     using vector3_type  = vector<T, 3>;
 
-    // F : [-1, 1]^2 -> S^2
-    static vector3_type eval(const vector2_type ndc)
+    // F : [0, 1]^2 -> S^2
+    static vector3_type uvToDir(const vector2_type uv)
     {
-        vector3_type p = vector3_type(ndc.xy, scalar_type(0));
-        const vector2_type a = abs(p.xy);
+        vector3_type p = vector3_type((uv * scalar_type(2) - scalar_type(1)), scalar_type(0));
+		const scalar_type a_x = abs(p.x); const scalar_type a_y = abs(p.y);
 
-        p.z = scalar_type(1) - a.x - a.y;
+        p.z = scalar_type(1) - a_x - a_y;
 
-        if (p.z < scalar_type(0))
-            p.xy = hlsl::sign(p.xy) * (scalar_type(1) - abs(p.yx));
+        if (p.z < scalar_type(0)) 
+        {
+            p.x = (p.x < scalar_type(0) ? scalar_type(-1) : scalar_type(1)) * (scalar_type(1) - a_y);
+            p.y = (p.y < scalar_type(0) ? scalar_type(-1) : scalar_type(1)) * (scalar_type(1) - a_x);
+        }
 
         return hlsl::normalize(p);
     }
 
     // F^-1 : S^2 -> [-1, 1]^2
-    static vector2_type inverse(vector3_type dir)
+    static vector2_type dirToNDC(vector3_type dir)
     {
         dir = hlsl::normalize(dir);
         const scalar_type sum = hlsl::dot(vector3_type(scalar_type(1), scalar_type(1), scalar_type(1)), abs(dir));
         vector3_type s = dir / sum;
 
         if (s.z < scalar_type(0))
-            s.xy = hlsl::sign(s.xy) * (scalar_type(1) - abs(s.yx));
+        {
+            s.x = (s.x < scalar_type(0) ? scalar_type(-1) : scalar_type(1)) * (scalar_type(1) - abs(s.y));
+            s.y = (s.y < scalar_type(0) ? scalar_type(-1) : scalar_type(1)) * (scalar_type(1) - abs(s.x));
+        }
 
         return s.xy;
     }
 
-    // transforms direction vector into UV (for corner sampling)
+    // transforms direction vector into UV for corner sampling
     // dir in S^2, halfMinusHalfPixel in [0, 0.5)^2,
     // where halfMinusHalfPixel = 0.5-0.5/texSize
     // and texSize.x >= 1, texSize.y >= 1
-    // NOTE/TODO: not best place to keep it here imo
+    // NOTE/TODO: not best place to keep it here
     static vector2_type toCornerSampledUV(vector3_type dir, vector2_type halfMinusHalfPixel)
     {
         // note: cornerSampled(NDC*0.5+0.5) = NDC*0.5*(1-1/texSize)+0.5
-        return inverse(dir) * halfMinusHalfPixel + scalar_type(0.5);
+        return dirToNDC(dir) * halfMinusHalfPixel + scalar_type(0.5);
     }
 };
 

src/nbl/asset/utils/CIESProfile.cpp

@@ -2,6 +2,7 @@
 
 #include <atomic>
 #include "nbl/asset/filters/CBasicImageFilterCommon.h"
+#include "nbl/builtin/hlsl/math/octahedral.hlsl"
 
 using namespace nbl;
 using namespace asset;
@@ -82,20 +83,6 @@ const CIESProfile::IES_STORAGE_FORMAT CIESProfile::sample(IES_STORAGE_FORMAT the
     return s0 * (1.0 - u) + s1 * u;
 }
 
-inline core::vectorSIMDf CIESProfile::octahdronUVToDir(const float& u, const float& v)
-{
-    core::vectorSIMDf pos = core::vectorSIMDf(2 * (u - 0.5), 2 * (v - 0.5), 0.0);
-    float abs_x = core::abs(pos.x), abs_y = core::abs(pos.y);
-    pos.z = 1.0 - abs_x - abs_y;
-    if (pos.z < 0.0) {
-        pos.x = (pos.x<0.f ? (-1.f):1.f) * (1.0 - abs_y);
-        pos.y = (pos.y<0.f ? (-1.f):1.f) * (1.0 - abs_x);
-    }
-
-    return core::normalize(pos);
-}
-
-
 inline std::pair<float, float> CIESProfile::sphericalDirToRadians(const core::vectorSIMDf& dir)
 {
     const float theta = std::acos(std::clamp<float>(dir.z, -1.f, 1.f));
@@ -183,8 +170,12 @@ core::smart_refctd_ptr<asset::ICPUImageView> CIESProfile::createIESTexture(Execu
         {
             // We don't currently support generating IES images that exploit symmetries or reduced domains, all are full octahederal mappings of a sphere.
             // If we did, we'd rely on MIRROR and CLAMP samplers to do some of the work for us while handling the discontinuity due to corner sampling. 
-            const auto dir = octahdronUVToDir(position.x * vertInv, position.y * horiInv);
-            const auto [theta, phi] = sphericalDirToRadians(dir);
+            
+            using Octahedral = hlsl::math::OctahedralTransform<hlsl::float32_t>;
+            const auto uv = Octahedral::vector2_type(position.x * vertInv, position.y * horiInv);
+            const auto dir = Octahedral::uvToDir(uv);
+			const auto tmp = core::vectorSIMDf(dir.x, dir.y, dir.z);
+            const auto [theta, phi] = sphericalDirToRadians(tmp);
             const auto intensity = sample(theta, phi);
 
             //! blend the IES texture with "flatten"