wipe CIESProfile::sphericalDirToRadians and use polar.hlsl

Author: AnastaZIuk

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

@@ -24,7 +24,7 @@ struct OctahedralTransform
     using vector3_type  = vector<T, 3>;
 
     // F : [0, 1]^2 -> S^2
-    static vector3_type uvToDir(const vector2_type uv)
+    static vector3_type uvToDir(NBL_CONST_REF_ARG(vector2_type) uv)
     {
         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);
@@ -41,9 +41,9 @@ struct OctahedralTransform
     }
 
     // F^-1 : S^2 -> [-1, 1]^2
-    static vector2_type dirToNDC(vector3_type dir)
+    static vector2_type dirToNDC(NBL_CONST_REF_ARG(vector3_type) d)
     {
-        dir = hlsl::normalize(dir);
+        scalar_type dir = hlsl::normalize(d);
         const scalar_type sum = hlsl::dot(vector3_type(scalar_type(1), scalar_type(1), scalar_type(1)), abs(dir));
         vector3_type s = dir / sum;
 
@@ -61,7 +61,7 @@ struct OctahedralTransform
     // where halfMinusHalfPixel = 0.5-0.5/texSize
     // and texSize.x >= 1, texSize.y >= 1
     // NOTE/TODO: not best place to keep it here
-    static vector2_type toCornerSampledUV(vector3_type dir, vector2_type halfMinusHalfPixel)
+    static vector2_type toCornerSampledUV(NBL_CONST_REF_ARG(vector3_type) dir, NBL_CONST_REF_ARG(vector2_type) halfMinusHalfPixel)
     {
         // note: cornerSampled(NDC*0.5+0.5) = NDC*0.5*(1-1/texSize)+0.5
         return dirToNDC(dir) * halfMinusHalfPixel + scalar_type(0.5);

include/nbl/builtin/hlsl/math/polar.hlsl

@@ -14,36 +14,38 @@ namespace hlsl
 namespace math
 {
 
-template<typename T>
+template<typename T = float32_t>
 struct Polar
 {
     using scalar_type = T;
     using vector2_type = vector<T, 2>;
     using vector3_type = vector<T, 3>;
 
-    // should be normalized
-    static Polar<T> createFromCartesian(const vector3_type coords)
+    // input must be normalized
+    static Polar<T> createFromCartesian(NBL_CONST_REF_ARG(vector3_type) dir)
     {
         Polar<T> retval;
-        retval.theta = hlsl::acos(coords.z);
-        retval.phi = hlsl::atan2(coords.y, coords.x);
+        retval.theta = acos(dir.z);
+        retval.phi = atan2(dir.y, dir.x);
         return retval;
     }
 
-    static vector3_type ToCartesian(const scalar_type theta, const scalar_type phi)
+    static vector3_type ToCartesian(NBL_CONST_REF_ARG(scalar_type) theta, NBL_CONST_REF_ARG(scalar_type) phi)
     {
-        return vector<T, 3>(hlsl::cos(phi) * hlsl::cos(theta),
-            hlsl::sin(phi) * hlsl::cos(theta),
-            hlsl::sin(theta));
+        return vector<T, 3>(
+            cos(phi) * cos(theta),
+            sin(phi) * cos(theta),
+            sin(theta)
+        );
     }
 
     vector3_type getCartesian()
     {
         return ToCartesian(theta, phi);
     }
 
-    scalar_type theta;
-    scalar_type phi;
+    scalar_type theta;  //! polar angle in range [0, PI]
+    scalar_type phi;    //! azimuthal angle in range [-PI, PI]
 };
 
 }

src/nbl/asset/utils/CIESProfile.cpp

@@ -3,6 +3,7 @@
 #include <atomic>
 #include "nbl/asset/filters/CBasicImageFilterCommon.h"
 #include "nbl/builtin/hlsl/math/octahedral.hlsl"
+#include "nbl/builtin/hlsl/math/polar.hlsl"
 
 using namespace nbl;
 using namespace asset;
@@ -83,14 +84,6 @@ const CIESProfile::IES_STORAGE_FORMAT CIESProfile::sample(IES_STORAGE_FORMAT the
     return s0 * (1.0 - u) + s1 * u;
 }
 
-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));
-    const float phi = std::atan2(dir.y, dir.x);
-
-    return { theta, phi };
-}
-
 template<class ExecutionPolicy>
 core::smart_refctd_ptr<asset::ICPUImageView> CIESProfile::createIESTexture(ExecutionPolicy&& policy, const float flatten, const bool fullDomainFlatten, uint32_t width, uint32_t height) const
 {
@@ -172,15 +165,15 @@ core::smart_refctd_ptr<asset::ICPUImageView> CIESProfile::createIESTexture(Execu
             // 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. 
 
             using Octahedral = hlsl::math::OctahedralTransform<hlsl::float32_t>;
+            using Polar = hlsl::math::Polar<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);
-            
+            const auto polar = Polar::createFromCartesian(dir);
+            const auto intensity = sample(polar.theta, polar.phi);
+
             //! blend the IES texture with "flatten"
             double blendV = intensity * (1.0 - flatten);
-            if (fullDomainFlatten && domainLo<=theta && theta<=domainHi || intensity >0.0)
+            if (fullDomainFlatten && domainLo<= polar.theta && polar.theta<=domainHi || intensity >0.0)
                 blendV += flattenTarget * flatten;
 
             blendV *= maxValueRecip;

src/nbl/asset/utils/CIESProfile.h

@@ -89,34 +89,6 @@ namespace nbl
             private:
                 CIESProfile(PhotometricType type, size_t hSize, size_t vSize)
                     : type(type), version(V_SIZE), hAngles(hSize), vAngles(vSize), data(hSize* vSize) {}
-
-                // TODO for @Hazard, I would move it into separate file, we may use this abstraction somewhere too
-                //! Returns spherical coordinates with physics convention in radians
-                /*
-                    https://en.wikipedia.org/wiki/Spherical_coordinate_system#/media/File:3D_Spherical.svg
-                    Retval.first is "theta" polar angle in range [0, PI] & Retval.second "phi" is azimuthal angle
-                    in range [-PI, PI] range
-
-                    Cartesian coordinates obtained from the spherical coordinates in Nabla
-                    are assumed to have radius equal to 1 and therefore always are
-
-                    x = cos(phi)*sin(theta)
-                    y = sin(phi)*sin(theta)
-                    z = cos(theta)
-                */
-
-                static inline std::pair<float, float> sphericalDirToRadians(const core::vectorSIMDf& dir);
-                
-                //! Octahedral coordinate mapping is following
-                /*
-                    center is Z-
-                    U+ from center is X+
-                    V+ from center is Y+
-
-                    when viewed as a texture, the net folds, and the apex where the seams join is Z+
-                */
-                
-                static inline core::vectorSIMDf octahdronUVToDir(const float& u, const float& v);
 
                 void setCandelaValue(size_t i, size_t j, IES_STORAGE_FORMAT val) { data[vAngles.size() * i + j] = val; }