Merge branch 'master' into bxdf_fixes_non_ct

Author: keptsecret

examples_tests

@@ -1126,10 +1126,14 @@ struct beta
     {
         assert(x >= T(0.999) && y >= T(0.999));
 
+#ifdef __HLSL_VERSION
         #pragma dxc diagnostic push
 		#pragma dxc diagnostic ignored "-Wliteral-range"
+#endif
 		const T thresholds[4] = { 0, 5e5, 1e6, 1e15 };	// threshold values gotten from testing when the function returns nan/inf/1
+#ifdef __HLSL_VERSION
         #pragma dxc diagnostic pop
+#endif
 		if (x+y > thresholds[mpl::find_lsb_v<sizeof(T)>])
 			return T(0.0);
 

include/nbl/builtin/hlsl/bxdf/common.hlsl

@@ -4,12 +4,10 @@
 #ifndef _NBL_BUILTIN_HLSL_MATH_LINALG_TRANSFORM_INCLUDED_
 #define _NBL_BUILTIN_HLSL_MATH_LINALG_TRANSFORM_INCLUDED_
 
-
 #include <nbl/builtin/hlsl/mpl.hlsl>
 #include <nbl/builtin/hlsl/cpp_compat/intrinsics.hlsl>
 #include <nbl/builtin/hlsl/concepts.hlsl>
 
-
 namespace nbl
 {
 namespace hlsl
@@ -19,35 +17,81 @@ namespace math
 namespace linalg
 {
 
-/// Builds a rotation 4 * 4 matrix created from an axis vector and an angle.
+/// Builds a rotation 3 * 3 matrix created from an axis vector and an angle.
 ///
 /// @param angle Rotation angle expressed in radians.
 /// @param axis Rotation axis, must be normalized.
 ///
 /// @tparam T A floating-point scalar type
 template <typename T>
-matrix<T, 4, 4> rotation_mat(T angle, vector<T, 3> const& axis)
+matrix<T, 3, 3> rotation_mat(T angle, const vector<T, 3> axis)
 {
-  T const a = angle;
-  T const c = cos(a);
-  T const s = sin(a);
+    const T a = angle;
+    const T c = cos(a);
+    const T s = sin(a);
+
+    vector<T, 3> temp = hlsl::promote<vector<T, 3> >((T(1.0) - c) * axis);
+
+    matrix<T, 3, 3> rotation;
+    rotation[0][0] = c + temp[0] * axis[0];
+    rotation[0][1] = temp[1] * axis[0] - s * axis[2];
+    rotation[0][2] = temp[2] * axis[0] + s * axis[1];
 
-  vector<T, 3> temp((T(1) - c) * axis);
+    rotation[1][0] = temp[0] * axis[1] + s * axis[2];
+    rotation[1][1] = c + temp[1] * axis[1];
+    rotation[1][2] = temp[2] * axis[1] - s * axis[0];
 
-  matrix<T, 4, 4> rotation;
-  rotation[0][0] = c + temp[0] * axis[0];
-  rotation[0][1] = temp[1] * axis[0] - s * axis[2];
-  rotation[0][2] = temp[2] * axis[0] + s * axis[1];
+    rotation[2][0] = temp[0] * axis[2] - s * axis[1];
+    rotation[2][1] = temp[1] * axis[2] + s * axis[0];
+    rotation[2][2] = c + temp[2] * axis[2];
 
-  rotation[1][0] = temp[0] * axis[1] + s * axis[2];
-  rotation[1][1] = c + temp[1] * axis[1];
-  rotation[1][2] = temp[2] * axis[1] - s * axis[0];
+    return rotation;
+}
+
+namespace impl
+{
+template<uint16_t MOut, uint16_t MIn, typename T>
+struct zero_expand_helper
+{
+    static vector<T, MOut> __call(const vector<T, MIn> inVec)
+    {
+        return vector<T, MOut>(inVec, vector<T, MOut - MIn>(0));
+    }
+};
+template<uint16_t M, typename T>
+struct zero_expand_helper<M,M,T>
+{
+    static vector<T, M> __call(const vector<T, M> inVec)
+    {
+        return inVec;
+    }
+};
+}
+
+template<uint16_t MOut, uint16_t MIn, typename T NBL_FUNC_REQUIRES(MOut >= MIn)
+vector<T, MOut> zero_expand(vector<T, MIn> inVec)
+{
+    return impl::zero_expand_helper<MOut, MIn, T>::__call(inVec);
+}
+
+template <uint16_t NOut, uint16_t MOut, uint16_t NIn, uint16_t MIn, typename T NBL_FUNC_REQUIRES(NOut >= NIn && MOut >= MIn)
+matrix<T, NOut, MOut> promote_affine(const matrix<T, NIn, MIn> inMatrix)
+{
+    matrix<T, NOut, MOut> retval;
 
-  rotation[2][0] = temp[0] * axis[2] - s * axis[1];
-  rotation[2][1] = temp[1] * axis[2] + s * axis[0];
-  rotation[2][2] = c + temp[2] * axis[2];
+    using out_row_t = hlsl::vector<T, MOut>;
 
-  return rotation;
+    NBL_UNROLL for (uint32_t row_i = 0; row_i < NIn; row_i++)
+    {
+        retval[row_i] = zero_expand<MOut, MIn>(inMatrix[row_i]);
+    }
+    NBL_UNROLL for (uint32_t row_i = NIn; row_i < NOut; row_i++)
+    {
+        retval[row_i] = promote<out_row_t>(0.0);
+        if (row_i >= MIn && row_i < MOut)
+            retval[row_i][row_i] = T(1.0);
+    }
+    return retval;
 }
 
 }

include/nbl/builtin/hlsl/math/linalg/transform.hlsl

@@ -539,10 +539,14 @@ struct l2gamma_helper<T NBL_PARTIAL_REQ_BOT(concepts::FloatingPointScalar<T>) >
 	// implementation derived from Numerical Recipes in C, transformed for log2
 	static T __call(T x)
 	{
+#ifdef __HLSL_VERSION
 		#pragma dxc diagnostic push
 		#pragma dxc diagnostic ignored "-Wliteral-range"
+#endif
 		const T thresholds[4] = { 0, 5e4, 1e36, 1e305 };	// threshold values gotten from testing when the function returns nan/inf
+#ifdef __HLSL_VERSION
 		#pragma dxc diagnostic pop
+#endif
 		if (x > thresholds[mpl::find_lsb_v<sizeof(T)>])
 			return bit_cast<T>(numeric_limits<T>::infinity);
 
@@ -584,10 +588,14 @@ struct beta_helper<T NBL_PARTIAL_REQ_BOT(concepts::FloatingPointScalar<T>) >
 	// implementation from Numerical Recipes in C, 2nd ed.
 	static T __call(T v1, T v2)
 	{
+#ifdef __HLSL_VERSION
 		#pragma dxc diagnostic push
 		#pragma dxc diagnostic ignored "-Wliteral-range"
+#endif
 		const T thresholds[4] = { 0, 2e4, 1e6, 1e15 };	// threshold values gotten from testing when the function returns nan/inf/1
+#ifdef __HLSL_VERSION
 		#pragma dxc diagnostic pop
+#endif
 		if (v1+v2 > thresholds[mpl::find_lsb_v<sizeof(T)>])
 			return T(0.0);
 

include/nbl/builtin/hlsl/tgmath/impl.hlsl

@@ -133,7 +133,7 @@ class NBL_FORCE_EBO IReferenceCounted : public Interface, public AllocationOverr
 		// Old destructor, but needed virtual for abstractness!
 		// _NBL_INTERFACE_CHILD_DEFAULT(IReferenceCounted);
 		//! Destructor, no need to define really, but make it pure virtual to truly prevent instantiation.
-		NBL_API2 virtual ~IReferenceCounted() = 0;
+		virtual ~IReferenceCounted() = 0;
 
 		//! Sets the debug name of the object.
 		/** The Debugname may only be set and changed by the object
@@ -155,6 +155,13 @@ class NBL_FORCE_EBO IReferenceCounted : public Interface, public AllocationOverr
 		static_assert(alignof(std::atomic<uint32_t>) <= _NBL_SIMD_ALIGNMENT/2u, "This compiler has a problem with its atomic int decl!");
 		static_assert(sizeof(std::atomic<uint32_t>) <= _NBL_SIMD_ALIGNMENT/2u, "This compiler has a problem with its atomic int decl!");
 };
+
+// yes pure virt can be inline, just needs a definition outside the class
+inline IReferenceCounted::~IReferenceCounted()
+{
+    _NBL_DEBUG_BREAK_IF(ReferenceCounter!=0);
+}
+
 static_assert(alignof(IReferenceCounted) == _NBL_SIMD_ALIGNMENT, "This compiler has a problem respecting alignment!");
 
 template<typename T>

include/nbl/core/IReferenceCounted.h

@@ -122,7 +122,6 @@ unset(NABLA_HEADERS_PUBLIC2 ${NBL_TMP_FULL_PATHS})
 # <=
 
 set(NBL_CORE_SOURCES
-	core/IReferenceCounted.cpp
 	core/alloc/refctd_memory_resource.cpp
 	core/hash/blake.cpp
 )

src/nbl/CMakeLists.txt

@@ -749,7 +749,7 @@ core::smart_refctd_ptr<ICPUGeometryCollection> CGeometryCreator::createArrow(
 	});
 	const auto coneTransform = hlsl::math::linalg::rotation_mat(hlsl::numbers::pi<hlsl::float32_t> * -0.5f, hlsl::float32_t3(1.f, 0.f, 0.f));
 	geometries->push_back({
-		.transform = hlsl::float32_t3x4(coneTransform),
+		.transform = hlsl::math::linalg::promote_affine<3, 4>(coneTransform),
 		.geometry = cone
 	});
 	return collection;