Remove core::matrixSIMD #950

Przemog1 · 2025-11-21T11:59:29Z

No description provided.

devshgraphicsprogramming · 2025-12-03T17:17:09Z

include/ICameraSceneNode.h

+#include <vectorSIMD.h>
+#include <nbl/builtin/hlsl/cpp_compat/matrix.hlsl>
+
 #include "ISceneNode.h"
 #include "matrixutil.h"


no need to touch this file, its dead code

devshgraphicsprogramming · 2025-12-03T17:18:40Z

include/nabla.h

 #include "line3d.h"
-#include "matrix4SIMD.h"
 #include "position2d.h"
 #include "quaternion.h"


merge #960 into your branch and nuke the quaternion.h as well

devshgraphicsprogramming · 2025-12-03T17:19:24Z

include/nbl/asset/IAccelerationStructure.h

-			core::matrix3x4SIMD	transform = core::matrix3x4SIMD();
+			hlsl::float32_t3x4	transform = hlsl::float32_t3x4();
 			Instance<blas_ref_t> base = {};
 		};
 		template<typename blas_ref_t>
 		struct MatrixMotionInstance final
 		{
-			core::matrix3x4SIMD transform[2] = {core::matrix3x4SIMD(),core::matrix3x4SIMD()};
+			hlsl::float32_t3x4 transform[2] = {hlsl::float32_t3x4(),hlsl::float32_t3x4()};


did you test the acceleration structure examples ? 67 and 71 ?

devshgraphicsprogramming · 2025-12-03T17:23:09Z

include/nbl/builtin/hlsl/camera/view_matrix.hlsl

+#ifndef _NBL_BUILTIN_HLSL_CAMERA_VIEW_MATRIX_INCLUDED_
+#define _NBL_BUILTIN_HLSL_CAMERA_VIEW_MATRIX_INCLUDED_
+
+#include <nbl/builtin/hlsl/cpp_compat.hlsl>
+
+namespace nbl
+{
+namespace hlsl
+{
+
+// /Arek: glm:: for normalize till dot product is fixed (ambiguity with glm namespace + linker issues)
+template<typename T>
+inline matrix<T, 3, 4> buildCameraLookAtMatrixLH(
+	const vector<T, 3>& position,
+	const vector<T, 3>& target,
+	const vector<T, 3>& upVector)
+{
+	const vector<T, 3> zaxis = hlsl::normalize(target - position);
+	const vector<T, 3> xaxis = hlsl::normalize(hlsl::cross(upVector, zaxis));
+	const vector<T, 3> yaxis = hlsl::cross(zaxis, xaxis);
+
+	matrix<T, 3, 4> r;
+	r[0] = vector<T, 4>(xaxis, -hlsl::dot(xaxis, position));
+	r[1] = vector<T, 4>(yaxis, -hlsl::dot(yaxis, position));
+	r[2] = vector<T, 4>(zaxis, -hlsl::dot(zaxis, position));
+
+	return r;
+}
+
+template<typename T>
+inline matrix<T, 3, 4> buildCameraLookAtMatrixRH(
+	const vector<T, 3>& position,
+	const vector<T, 3>& target,
+	const vector<T, 3>& upVector)
+{
+	const vector<T, 3> zaxis = hlsl::normalize(position - target);
+	const vector<T, 3> xaxis = hlsl::normalize(hlsl::cross(upVector, zaxis));
+	const vector<T, 3> yaxis = hlsl::cross(zaxis, xaxis);
+
+	matrix<T, 3, 4> r;
+	r[0] = vector<T, 4>(xaxis, -hlsl::dot(xaxis, position));
+	r[1] = vector<T, 4>(yaxis, -hlsl::dot(yaxis, position));
+	r[2] = vector<T, 4>(zaxis, -hlsl::dot(zaxis, position));
+
+	return r;
+}
+
+}
+}
+
+#endif


add these to https://github.com/Devsh-Graphics-Programming/Nabla/blob/563be557e2dbebcdf00e6b2244f6a339d0bb5b07/include/nbl/builtin/hlsl/math/linalg/transform.hlsl

and drop buildCamera just call tehem lhLookAt and rhLookAt

devshgraphicsprogramming · 2025-12-03T17:23:43Z

include/nbl/builtin/hlsl/cpp_compat/unroll.hlsl

+#ifndef _NBL_BUILTIN_HLSL_CPP_COMPAT_UNROLL_INCLUDED_
+#define _NBL_BUILTIN_HLSL_CPP_COMPAT_UNROLL_INCLUDED_
+
+#ifdef __HLSL_VERSION
+#define NBL_UNROLL [unroll]
+#define NBL_UNROLL_LIMITED(LIMIT) [unroll(LIMIT)]
+#else
+#define NBL_UNROLL // can't be bothered / TODO
+#define NBL_UNROLL_LIMITED(LIMIT)
+#endif
+
+#endif


its already in

Nabla/include/nbl/builtin/hlsl/macros.h

Line 38 in 1e637c4

#define NBL_UNROLL [[unroll]]

can add the LIMITED there

devshgraphicsprogramming · 2025-12-03T17:24:30Z

include/nbl/builtin/hlsl/math/quaternion/quaternion.hlsl

+// Copyright (C) 2019 - DevSH Graphics Programming Sp. z O.O.
+// This file is part of the "Nabla Engine" and was originally part of the "Irrlicht Engine"
+// For conditions of distribution and use, see copyright notice in nabla.h
+// See the original file in irrlicht source for authors
+
+#ifndef _NBL_BUILTIN_HLSL_MATH_QUATERNION_INCLUDED_
+#define _NBL_BUILTIN_HLSL_MATH_QUATERNION_INCLUDED_
+
+#include <nbl/builtin/hlsl/cpp_compat.hlsl>
+
+namespace nbl
+{
+namespace hlsl
+{
+
+//! Quaternion class for representing rotations.
+/** It provides cheap combinations and avoids gimbal locks.
+Also useful for interpolations. */
+
+template<typename float_t>
+struct quaternion
+{
+	// i*data[0] + j*data[1] + k*data[2] + data[3]
+	using vec_t = vector<float_t, 4>;
+	vector<float_t, 4> data;
+
+	//! creates identity quaternion
+	static inline quaternion create()
+	{
+		quaternion q;
+		q.data = vector<float_t, 4>(0.0f, 0.0f, 0.0f, 1.0f);
+
+		return q;
+	}
+
+	static inline quaternion create(float_t x, float_t y, float_t z, float_t w)
+	{
+		quaternion q;
+		q.data = vector<float_t, 4>(x, y, z, w);
+
+		return q;
+	}
+
+	static inline quaternion create(NBL_CONST_REF_ARG(quaternion) other)
+	{
+		return other;
+	}
+
+	static inline quaternion create(float_t pitch, float_t yaw, float_t roll)
+	{
+		const float rollDiv2 = roll * 0.5f;
+		const float sr = sinf(rollDiv2);
+		const float cr = cosf(rollDiv2);
+
+		const float pitchDiv2 = pitch * 0.5f;
+		const float sp = sinf(pitchDiv2);
+		const float cp = cosf(pitchDiv2);
+
+		const float yawDiv2 = yaw * 0.5f;
+		const float sy = sinf(yawDiv2);
+		const float cy = cosf(yawDiv2);
+
+		quaternion<float_t> output;
+		output.data[0] = cr * sp * cy + sr * cp * sy; // x
+		output.data[1] = cr * cp * sy - sr * sp * cy; // y
+		output.data[2] = sr * cp * cy - cr * sp * sy; // z
+		output.data[3] = cr * cp * cy + sr * sp * sy; // w
+
+		return output;
+	}
+
+	// TODO:
+	//explicit quaternion(NBL_CONST_REF_ARG(float32_t3x4) m) {}
+
+	inline quaternion operator*(float_t scalar)
+	{
+		quaternion output;
+		output.data = data * scalar;
+		return output;
+	}
+
+	inline quaternion operator*(NBL_CONST_REF_ARG(quaternion) other)
+	{
+		return quaternion::create(
+			data.w * other.data.w - data.x * other.x - data.y * other.data.y - data.z * other.data.z,
+			data.w * other.data.x + data.x * other.w + data.y * other.data.z - data.z * other.data.y,
+			data.w * other.data.y - data.x * other.z + data.y * other.data.w + data.z * other.data.x,
+			data.w * other.data.z + data.x * other.y - data.y * other.data.x + data.z * other.data.w
+		);
+	}
+};
+
+} // end namespace core
+} // nbl
+
+#endif


let #960 overwrite your changes

devshgraphicsprogramming · 2025-12-03T17:24:45Z

include/nbl/builtin/hlsl/math/quaternion/quaternion_impl.hlsl

+// Copyright (C) 2019 - DevSH Graphics Programming Sp. z O.O.
+// This file is part of the "Nabla Engine" and was originally part of the "Irrlicht Engine"
+// For conditions of distribution and use, see copyright notice in nabla.h
+// See the original file in irrlicht source for authors
+
+#ifndef _NBL_BUILTIN_HLSL_MATH_QUATERNION_IMPL_INCLUDED_
+#define _NBL_BUILTIN_HLSL_MATH_QUATERNION_IMPL_INCLUDED_
+
+#include <nbl/builtin/hlsl/cpp_compat.hlsl>
+
+namespace nbl
+{
+namespace hlsl
+{
+
+namespace quaternion_impl
+{
+
+}
+
+} // end namespace core
+} // nbl
+
+#endif


there's no need for this file then

devshgraphicsprogramming · 2025-12-03T17:26:49Z

include/nbl/core/math/plane3dSIMD.h

-            matrix3x4SIMD inv;
-            _mat.getInverse(inv);
+			hlsl::float32_t4x4 inv = hlsl::getMatrix3x4As4x4<hlsl::float32_t>(_mat);
+			hlsl::inverse(inv);


inverse is not in-place, you need to do const hlsl::float32_t4x4 inv = inverse(linalg::promote(_mat))

devshgraphicsprogramming · 2025-12-03T17:27:31Z

include/nbl/core/math/plane3dSIMD.h

            vectorSIMDf normal(_in.getNormal());
            // transform by inverse transpose
-            return plane3dSIMDf(inv.rows[0]*normal.xxxx()+inv.rows[1]*normal.yyyy()+inv.rows[2]*normal.zzzz()+(normal.wwww()&BUILD_MASKF(0,0,0,1)));
+			hlsl::float32_t4 planeEq = inv[0] * hlsl::float32_t4(normal.x) + inv[1] * hlsl::float32_t4(normal.y) + inv[2] * hlsl::float32_t4(normal.z) + (hlsl::float32_t4(0, 0, 0, normal.w));


use swizzles instead of counting on promotions from constructors

devshgraphicsprogramming · 2025-12-03T18:05:15Z

include/nbl/ext/EnvmapImportanceSampling/EnvmapImportanceSampling.h

 		#define vec4 core::vectorSIMDf
-		#define mat4 core::matrix4SIMD
-		#define mat4x3 core::matrix3x4SIMD
+		#define mat4 hlsl::float32_t4x4
+		#define mat4x3 hlsl::float32_t3x4


don't touch this to reduce conflicts with #946

devshgraphicsprogramming · 2025-12-03T18:06:22Z

include/nbl/ext/MitsubaLoader/PropertyElement.h

 template<> struct SPropertyElementData::get_typename<SPropertyElementData::Type::BLACKBODY>
 { using type = void; };
 template<> struct SPropertyElementData::get_typename<SPropertyElementData::Type::MATRIX>
-{ using type = core::matrix4SIMD; };
+{ using type = hlsl::float32_t4x4; };
 template<> struct SPropertyElementData::get_typename<SPropertyElementData::Type::TRANSLATE>
-{ using type = core::matrix4SIMD; };
+{ using type = hlsl::float32_t4x4; };
 template<> struct SPropertyElementData::get_typename<SPropertyElementData::Type::ROTATE>
-{ using type = core::matrix4SIMD; };
+{ using type = hlsl::float32_t4x4; };
 template<> struct SPropertyElementData::get_typename<SPropertyElementData::Type::SCALE>
-{ using type = core::matrix4SIMD; };
+{ using type = hlsl::float32_t4x4; };
 template<> struct SPropertyElementData::get_typename<SPropertyElementData::Type::LOOKAT>
-{ using type = core::matrix4SIMD; };
+{ using type = hlsl::float32_t4x4; };
 template<> struct SPropertyElementData::get_typename<SPropertyElementData::Type::INVALID>
 { using type = void; };


undo all changes to nbl/ext/MitsubaLoader because it will badly conflict with my #937

devshgraphicsprogramming · 2025-12-03T18:16:06Z