Using custom dot implementation and fixing matmul (#284)

Zuzu-Typ · web-flow · commit 239c053aadd4 · 2025-04-10T16:38:46.000+02:00
* Fix project setup

* Using custom dot that supports integer vectors

* Fixed matmul implementation for vectors
diff --git a/PyGLM_lib/PyGLM/functions/detail/func_geometric.h b/PyGLM_lib/PyGLM/functions/detail/func_geometric.h
@@ -28,14 +28,154 @@ PyDoc_STRVAR(distance_docstr,
 PyGLM_MAKE_GLM_FUNC_NN_VV__tfF(distance)
 
 PyDoc_STRVAR(dot_docstr,
-	"dot(x: float, y: float) -> float\n"
+	"dot(x: number, y: number) -> float\n"
 	"	Returns the dot product of `x` and `y`, i.e., `result = x * y`.\n"
-	"dot(x: vecN, y: vecN) -> float\n"
+	"dot(x: vecN, y: vecN) -> number\n"
 	"	Returns the dot product of `x` and `y`, i.e., `result = x[0] * y[0] + x[1] * y[1] + ...`\n"
 	"dot(x: quat, y: quat) -> float\n"
 	"	Returns dot product of `x` and `y`, i.e., `x[0] * y[0] + x[1] * y[1] + ...`"
 );
-PyGLM_MAKE_GLM_FUNC_NN_VV_QQ__tfF(dot)
+
+static PyObject*
+dot_(PyObject*, PyObject* args) {
+	PyObject *arg1, *arg2;
+	PyGLM_Arg_Unpack_2O(args, "dot", arg1, arg2);
+	if (PyGLM_Number_Check(arg1) && PyGLM_Number_Check(arg2)) {
+		return pack(glm::custom::dot(PyGLM_Number_FromPyObject<double>(arg1), PyGLM_Number_FromPyObject<double>(arg2)));
+	}
+	PyGLM_PTI_Init0(arg1, PyGLM_T_VEC | PyGLM_T_QUA | PyGLM_SHAPE_ALL | PyGLM_DT_FD | PyGLM_DT_I);
+	PyGLM_PTI_Init1(arg2, PyGLM_T_VEC | PyGLM_T_QUA | PyGLM_SHAPE_ALL | PyGLM_DT_FD | PyGLM_DT_I);
+	if (PyGLM_PTI_IsVec(0)) {
+		if (PyGLM_Vec_PTI_Check0(1, float, arg1) && PyGLM_Vec_PTI_Check1(1, float, arg2)) {
+			return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(1, float, arg1), PyGLM_Vec_PTI_Get1(1, float, arg2)));
+		}
+		if (PyGLM_Vec_PTI_Check0(1, double, arg1) && PyGLM_Vec_PTI_Check1(1, double, arg2)) {
+			return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(1, double, arg1), PyGLM_Vec_PTI_Get1(1, double, arg2)));
+		}
+		if (PyGLM_Vec_PTI_Check0(1, int32, arg1) && PyGLM_Vec_PTI_Check1(1, int32, arg2)) {
+			return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(1, int32, arg1), PyGLM_Vec_PTI_Get1(1, int32, arg2)));
+		}
+		if (PyGLM_Vec_PTI_Check0(1, uint32, arg1) && PyGLM_Vec_PTI_Check1(1, uint32, arg2)) {
+			return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(1, uint32, arg1), PyGLM_Vec_PTI_Get1(1, uint32, arg2)));
+		}
+		if (PyGLM_Vec_PTI_Check0(1, int64, arg1) && PyGLM_Vec_PTI_Check1(1, int64, arg2)) {
+			return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(1, int64, arg1), PyGLM_Vec_PTI_Get1(1, int64, arg2)));
+		}
+		if (PyGLM_Vec_PTI_Check0(1, uint64, arg1) && PyGLM_Vec_PTI_Check1(1, uint64, arg2)) {
+			return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(1, uint64, arg1), PyGLM_Vec_PTI_Get1(1, uint64, arg2)));
+		}
+		if (PyGLM_Vec_PTI_Check0(1, int16, arg1) && PyGLM_Vec_PTI_Check1(1, int16, arg2)) {
+			return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(1, int16, arg1), PyGLM_Vec_PTI_Get1(1, int16, arg2)));
+		}
+		if (PyGLM_Vec_PTI_Check0(1, uint16, arg1) && PyGLM_Vec_PTI_Check1(1, uint16, arg2)) {
+			return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(1, uint16, arg1), PyGLM_Vec_PTI_Get1(1, uint16, arg2)));
+		}
+		if (PyGLM_Vec_PTI_Check0(1, int8, arg1) && PyGLM_Vec_PTI_Check1(1, int8, arg2)) {
+			return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(1, int8, arg1), PyGLM_Vec_PTI_Get1(1, int8, arg2)));
+		}
+		if (PyGLM_Vec_PTI_Check0(1, uint8, arg1) && PyGLM_Vec_PTI_Check1(1, uint8, arg2)) {
+			return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(1, uint8, arg1), PyGLM_Vec_PTI_Get1(1, uint8, arg2)));
+		}
+		if (PyGLM_Vec_PTI_Check0(2, float, arg1) && PyGLM_Vec_PTI_Check1(2, float, arg2)) {
+			return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(2, float, arg1), PyGLM_Vec_PTI_Get1(2, float, arg2)));
+		}
+		if (PyGLM_Vec_PTI_Check0(2, double, arg1) && PyGLM_Vec_PTI_Check1(2, double, arg2)) {
+			return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(2, double, arg1), PyGLM_Vec_PTI_Get1(2, double, arg2)));
+		}
+		if (PyGLM_Vec_PTI_Check0(2, int32, arg1) && PyGLM_Vec_PTI_Check1(2, int32, arg2)) {
+			return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(2, int32, arg1), PyGLM_Vec_PTI_Get1(2, int32, arg2)));
+		}
+		if (PyGLM_Vec_PTI_Check0(2, uint32, arg1) && PyGLM_Vec_PTI_Check1(2, uint32, arg2)) {
+			return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(2, uint32, arg1), PyGLM_Vec_PTI_Get1(2, uint32, arg2)));
+		}
+		if (PyGLM_Vec_PTI_Check0(2, int64, arg1) && PyGLM_Vec_PTI_Check1(2, int64, arg2)) {
+			return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(2, int64, arg1), PyGLM_Vec_PTI_Get1(2, int64, arg2)));
+		}
+		if (PyGLM_Vec_PTI_Check0(2, uint64, arg1) && PyGLM_Vec_PTI_Check1(2, uint64, arg2)) {
+			return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(2, uint64, arg1), PyGLM_Vec_PTI_Get1(2, uint64, arg2)));
+		}
+		if (PyGLM_Vec_PTI_Check0(2, int16, arg1) && PyGLM_Vec_PTI_Check1(2, int16, arg2)) {
+			return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(2, int16, arg1), PyGLM_Vec_PTI_Get1(2, int16, arg2)));
+		}
+		if (PyGLM_Vec_PTI_Check0(2, uint16, arg1) && PyGLM_Vec_PTI_Check1(2, uint16, arg2)) {
+			return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(2, uint16, arg1), PyGLM_Vec_PTI_Get1(2, uint16, arg2)));
+		}
+		if (PyGLM_Vec_PTI_Check0(2, int8, arg1) && PyGLM_Vec_PTI_Check1(2, int8, arg2)) {
+			return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(2, int8, arg1), PyGLM_Vec_PTI_Get1(2, int8, arg2)));
+		}
+		if (PyGLM_Vec_PTI_Check0(2, uint8, arg1) && PyGLM_Vec_PTI_Check1(2, uint8, arg2)) {
+			return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(2, uint8, arg1), PyGLM_Vec_PTI_Get1(2, uint8, arg2)));
+		}
+		if (PyGLM_Vec_PTI_Check0(3, float, arg1) && PyGLM_Vec_PTI_Check1(3, float, arg2)) {
+			return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(3, float, arg1), PyGLM_Vec_PTI_Get1(3, float, arg2)));
+		}
+		if (PyGLM_Vec_PTI_Check0(3, double, arg1) && PyGLM_Vec_PTI_Check1(3, double, arg2)) {
+			return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(3, double, arg1), PyGLM_Vec_PTI_Get1(3, double, arg2)));
+		}
+		if (PyGLM_Vec_PTI_Check0(3, int32, arg1) && PyGLM_Vec_PTI_Check1(3, int32, arg2)) {
+			return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(3, int32, arg1), PyGLM_Vec_PTI_Get1(3, int32, arg2)));
+		}
+		if (PyGLM_Vec_PTI_Check0(3, uint32, arg1) && PyGLM_Vec_PTI_Check1(3, uint32, arg2)) {
+			return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(3, uint32, arg1), PyGLM_Vec_PTI_Get1(3, uint32, arg2)));
+		}
+		if (PyGLM_Vec_PTI_Check0(3, int64, arg1) && PyGLM_Vec_PTI_Check1(3, int64, arg2)) {
+			return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(3, int64, arg1), PyGLM_Vec_PTI_Get1(3, int64, arg2)));
+		}
+		if (PyGLM_Vec_PTI_Check0(3, uint64, arg1) && PyGLM_Vec_PTI_Check1(3, uint64, arg2)) {
+			return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(3, uint64, arg1), PyGLM_Vec_PTI_Get1(3, uint64, arg2)));
+		}
+		if (PyGLM_Vec_PTI_Check0(3, int16, arg1) && PyGLM_Vec_PTI_Check1(3, int16, arg2)) {
+			return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(3, int16, arg1), PyGLM_Vec_PTI_Get1(3, int16, arg2)));
+		}
+		if (PyGLM_Vec_PTI_Check0(3, uint16, arg1) && PyGLM_Vec_PTI_Check1(3, uint16, arg2)) {
+			return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(3, uint16, arg1), PyGLM_Vec_PTI_Get1(3, uint16, arg2)));
+		}
+		if (PyGLM_Vec_PTI_Check0(3, int8, arg1) && PyGLM_Vec_PTI_Check1(3, int8, arg2)) {
+			return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(3, int8, arg1), PyGLM_Vec_PTI_Get1(3, int8, arg2)));
+		}
+		if (PyGLM_Vec_PTI_Check0(3, uint8, arg1) && PyGLM_Vec_PTI_Check1(3, uint8, arg2)) {
+			return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(3, uint8, arg1), PyGLM_Vec_PTI_Get1(3, uint8, arg2)));
+		}
+		if (PyGLM_Vec_PTI_Check0(4, float, arg1) && PyGLM_Vec_PTI_Check1(4, float, arg2)) {
+			return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(4, float, arg1), PyGLM_Vec_PTI_Get1(4, float, arg2)));
+		}
+		if (PyGLM_Vec_PTI_Check0(4, double, arg1) && PyGLM_Vec_PTI_Check1(4, double, arg2)) {
+			return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(4, double, arg1), PyGLM_Vec_PTI_Get1(4, double, arg2)));
+		}
+		if (PyGLM_Vec_PTI_Check0(4, int32, arg1) && PyGLM_Vec_PTI_Check1(4, int32, arg2)) {
+			return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(4, int32, arg1), PyGLM_Vec_PTI_Get1(4, int32, arg2)));
+		}
+		if (PyGLM_Vec_PTI_Check0(4, uint32, arg1) && PyGLM_Vec_PTI_Check1(4, uint32, arg2)) {
+			return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(4, uint32, arg1), PyGLM_Vec_PTI_Get1(4, uint32, arg2)));
+		}
+		if (PyGLM_Vec_PTI_Check0(4, int64, arg1) && PyGLM_Vec_PTI_Check1(4, int64, arg2)) {
+			return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(4, int64, arg1), PyGLM_Vec_PTI_Get1(4, int64, arg2)));
+		}
+		if (PyGLM_Vec_PTI_Check0(4, uint64, arg1) && PyGLM_Vec_PTI_Check1(4, uint64, arg2)) {
+			return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(4, uint64, arg1), PyGLM_Vec_PTI_Get1(4, uint64, arg2)));
+		}
+		if (PyGLM_Vec_PTI_Check0(4, int16, arg1) && PyGLM_Vec_PTI_Check1(4, int16, arg2)) {
+			return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(4, int16, arg1), PyGLM_Vec_PTI_Get1(4, int16, arg2)));
+		}
+		if (PyGLM_Vec_PTI_Check0(4, uint16, arg1) && PyGLM_Vec_PTI_Check1(4, uint16, arg2)) {
+			return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(4, uint16, arg1), PyGLM_Vec_PTI_Get1(4, uint16, arg2)));
+		}
+		if (PyGLM_Vec_PTI_Check0(4, int8, arg1) && PyGLM_Vec_PTI_Check1(4, int8, arg2)) {
+			return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(4, int8, arg1), PyGLM_Vec_PTI_Get1(4, int8, arg2)));
+		}
+		if (PyGLM_Vec_PTI_Check0(4, uint8, arg1) && PyGLM_Vec_PTI_Check1(4, uint8, arg2)) {
+			return pack(glm::custom::dot(PyGLM_Vec_PTI_Get0(4, uint8, arg1), PyGLM_Vec_PTI_Get1(4, uint8, arg2)));
+		}
+	}
+	if (PyGLM_Qua_PTI_Check0(float, arg1) && PyGLM_Qua_PTI_Check1(float, arg2)) {
+		return pack(glm::custom::dot(PyGLM_Qua_PTI_Get0(float, arg1), PyGLM_Qua_PTI_Get1(float, arg2)));
+	}
+	if (PyGLM_Qua_PTI_Check0(double, arg1) && PyGLM_Qua_PTI_Check1(double, arg2)) {
+		return pack(glm::custom::dot(PyGLM_Qua_PTI_Get0(double, arg1), PyGLM_Qua_PTI_Get1(double, arg2)));
+	}
+	PyGLM_TYPEERROR_2O("invalid argument type(s) for dot(): ", arg1, arg2);
+	return NULL;
+}
 
 PyDoc_STRVAR(cross_docstr,
 	"cross(x: vec3, y: vec3) -> vec3\n"
diff --git a/PyGLM_lib/PyGLM/imports.h b/PyGLM_lib/PyGLM/imports.h
@@ -20,6 +20,8 @@
 
 #include <glm/glm.hpp>
 
+#include "internal_functions/glm_customizations.h"
+
 #include <glm/gtc/quaternion.hpp>
 #include <glm/gtc/matrix_integer.hpp>
 #include <glm/gtx/hash.hpp>
diff --git a/PyGLM_lib/PyGLM/internal_functions/glm_customizations.h b/PyGLM_lib/PyGLM/internal_functions/glm_customizations.h
@@ -0,0 +1,69 @@
+#pragma once
+
+#include "../compiler_setup.h"
+
+namespace glm {
+	namespace custom {
+		template<typename T>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR T dot(T x, T y)
+		{
+			return x * y;
+		}
+
+		template<length_t L, typename T, qualifier Q>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR T dot(vec<L, T, Q> const& x, vec<L, T, Q> const& y)
+		{
+			return detail::compute_dot<vec<L, T, Q>, T, detail::is_aligned<Q>::value>::call(x, y);
+		}
+
+		template<typename T, qualifier Q>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR T dot(qua<T, Q> const& x, qua<T, Q> const& y)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_CONFIG_UNRESTRICTED_FLOAT, "'dot' accepts only floating-point inputs");
+			return detail::compute_dot<qua<T, Q>, T, detail::is_aligned<Q>::value>::call(x, y);
+		}
+
+		template<int C, int R, typename T, qualifier Q>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename mat<C, R, T, Q>::col_type mat_mul
+		(
+			mat<C, R, T, Q> const& m,
+			typename mat<C, R, T, Q>::row_type const& v
+		)
+		{
+			return m * v;
+		}
+
+		template<int C, int R, typename T, qualifier Q>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename mat<C, R, T, Q>::row_type mat_mul
+		(
+			typename mat<C, R, T, Q>::col_type const& v,
+			mat<C, R, T, Q> const& m
+		)
+		{
+			return v * m;
+		}
+
+		template<typename T, qualifier Q>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename mat<3, 3, T, Q>::row_type mat_mul(typename mat<3, 3, T, Q>::col_type const& v, mat<3, 3, T, Q> const& m)
+		{
+			return typename mat<3, 3, T, Q>::row_type(
+				glm::custom::dot(m[0], v),
+				glm::custom::dot(m[1], v),
+				glm::custom::dot(m[2], v));
+		}
+
+		template<typename T, qualifier Q>
+		GLM_FUNC_QUALIFIER GLM_CONSTEXPR typename mat<4, 4, T, Q>::row_type mat_mul
+		(
+			typename mat<4, 4, T, Q>::col_type const& v,
+			mat<4, 4, T, Q> const& m
+		)
+		{
+			return typename mat<4, 4, T, Q>::row_type(
+				glm::custom::dot(m[0], v),
+				glm::custom::dot(m[1], v),
+				glm::custom::dot(m[2], v),
+				glm::custom::dot(m[3], v));
+		}
+	}
+}
diff --git a/PyGLM_lib/PyGLM/type_methods/mat.h b/PyGLM_lib/PyGLM/type_methods/mat.h
@@ -1375,7 +1375,7 @@ mat_mul(PyObject *obj1, PyObject *obj2)
 	if (PyGLM_Vec_PTI_Check0(R, T, obj1)) { // obj1 is a col_type
 		glm::vec<R, T> o = PyGLM_Vec_PTI_Get0(R, T, obj1);
 
-		return pack_vec(o * ((mat<C, R, T>*)obj2)->super_type);
+		return pack_vec(glm::custom::mat_mul(o, ((mat<C, R, T>*)obj2)->super_type));
 	}
 
 	if (!PyGLM_Mat_PTI_Check0(C, R, T, obj1)) { // obj1 can't be interpreted as mat<C, R, T>
@@ -1394,7 +1394,7 @@ mat_mul(PyObject *obj1, PyObject *obj2)
 	if (PyGLM_Vec_PTI_Check0(C, T, obj2)) { // obj2 is a row_type
 		glm::vec<C, T> o2 = PyGLM_Vec_PTI_Get0(C, T, obj2);
 
-		return pack_vec(o * o2);
+		return pack_vec(glm::custom::mat_mul(o, o2));
 	}
 
 	if (PyGLM_Mat_PTI_Check0(2, C, T, obj2)) {
diff --git a/PyGLM_lib/PyGLM/type_methods/vec.h b/PyGLM_lib/PyGLM/type_methods/vec.h
@@ -1166,10 +1166,19 @@ vec_pow(PyObject * obj1, PyObject * obj2, PyObject * obj3) {
 	return pack_vec<L, T>(glm::mod(glm::pow(o, o2), o3));
 }
 
+static PyObject* dot_(PyObject*, PyObject* args);
+
 static PyObject*
 vec_matmul(PyObject* obj1, PyObject* obj2)
 {
-	PyObject* out = PyNumber_Multiply(obj1, obj2);
+	PyObject* args = PyTuple_New(2);
+	PyTuple_SET_ITEM(args, 0, PyGLM_INCREF(obj1));
+	PyTuple_SET_ITEM(args, 1, PyGLM_INCREF(obj2));
+
+	PyObject* out = dot_(NULL, args);
+
+	Py_DECREF(args);
+
 	if (out == NULL) {
 		PyGLM_TYPEERROR_2O("unsupported operand type(s) for @: ", obj1, obj2);
 	}
diff --git a/vs-project/PyGLM build/PyGLM build.vcxproj b/vs-project/PyGLM build/PyGLM build.vcxproj
@@ -70,7 +70,7 @@
   </ImportGroup>
   <PropertyGroup Label="UserMacros" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
-    <TargetName>glm</TargetName>
+    <TargetName>glm_d</TargetName>
     <TargetExt>.pyd</TargetExt>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
@@ -80,7 +80,7 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <OutDir>$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>
     <IntDir>$(Platform)\$(Configuration)\</IntDir>
-    <TargetName>glm</TargetName>
+    <TargetName>glm_d</TargetName>
     <TargetExt>.pyd</TargetExt>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
@@ -117,7 +117,7 @@
     </ClCompile>
     <Link>
       <AdditionalLibraryDirectories>C:\Python39\libs;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-      <AdditionalDependencies>%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalDependencies>python39_d.lib;%(AdditionalDependencies)</AdditionalDependencies>
     </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
@@ -206,6 +206,7 @@
     <ClInclude Include="..\..\PyGLM_lib\PyGLM\internal_functions\all.h" />
     <ClInclude Include="..\..\PyGLM_lib\PyGLM\internal_functions\ctypes_pointers.h" />
     <ClInclude Include="..\..\PyGLM_lib\PyGLM\internal_functions\error_functions.h" />
+    <ClInclude Include="..\..\PyGLM_lib\PyGLM\internal_functions\glm_customizations.h" />
     <ClInclude Include="..\..\PyGLM_lib\PyGLM\internal_functions\helper_macros.h" />
     <ClInclude Include="..\..\PyGLM_lib\PyGLM\internal_functions\number_functions.h" />
     <ClInclude Include="..\..\PyGLM_lib\PyGLM\internal_functions\packers.h" />
diff --git a/vs-project/PyGLM build/PyGLM build.vcxproj.filters b/vs-project/PyGLM build/PyGLM build.vcxproj.filters
@@ -734,5 +734,8 @@
     <ClInclude Include="..\..\PyGLM_lib\version.h">
       <Filter>Headerdateien</Filter>
     </ClInclude>
+    <ClInclude Include="..\..\PyGLM_lib\PyGLM\internal_functions\glm_customizations.h">
+      <Filter>Headerdateien\PyGLM\internal_functions</Filter>
+    </ClInclude>
   </ItemGroup>
 </Project>
diff --git a/vs-project/PyGLM test.pyproj b/vs-project/PyGLM test.pyproj
@@ -31,7 +31,7 @@
     <Compile Include="PyGLM_run.py" />
   </ItemGroup>
   <ItemGroup>
-    <ProjectReference Include="..\PyGLM build\PyGLM build.vcxproj">
+    <ProjectReference Include="PyGLM build\PyGLM build.vcxproj">
       <Name>PyGLM build</Name>
       <Project>{9908a257-6824-4543-b7e4-acfd9f40ad85}</Project>
       <Private>True</Private>
diff --git a/vs-project/PyGLM.sln b/vs-project/PyGLM.sln
@@ -5,7 +5,7 @@ VisualStudioVersion = 17.10.34916.146
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{888888A0-9F3D-457C-B088-3A5042F75D52}") = "PyGLM test", "PyGLM test.pyproj", "{4DB02B00-448E-49AC-BBDE-4E06AA14F15D}"
 EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "PyGLM build", "..\PyGLM build\PyGLM build.vcxproj", "{9908A257-6824-4543-B7E4-ACFD9F40AD85}"
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "PyGLM build", "PyGLM build\PyGLM build.vcxproj", "{9908A257-6824-4543-B7E4-ACFD9F40AD85}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
diff --git a/wiki/function-reference/detail/func_geometric.md b/wiki/function-reference/detail/func_geometric.md
@@ -30,10 +30,10 @@ These operate on vectors as vectors, not component\-wise\.
 &emsp;&emsp;Returns the distance between ``` p0 ``` and ``` p1 ```, i\.e\., ``` length(p0 - p1) ```\.  
   
 ### dot\(\) function  
-#### <code>glm.<code>**dot**(**x**: *float*, **y**: *float*) -\> *float*</code></code>  
+#### <code>glm.<code>**dot**(**x**: *number*, **y**: *number*) -\> *float*</code></code>  
 &emsp;&emsp;Returns the dot product of ``` x ``` and ``` y ```, i\.e\., ``` result = x * y ```\.  
   
-#### <code>glm.<code>**dot**(**x**: *vecN*, **y**: *vecN*) -\> *float*</code></code>  
+#### <code>glm.<code>**dot**(**x**: *vecN*, **y**: *vecN*) -\> *number*</code></code>  
 &emsp;&emsp;Returns the dot product of ``` x ``` and ``` y ```, i\.e\., ``` result = x[0] * y[0] + x[1] * y[1] + ... ```  
   
 #### <code>glm.<code>**dot**(**x**: *quat*, **y**: *quat*) -\> *float*</code></code>  
diff --git a/wiki/function-reference/detail/func_geometric.sb b/wiki/function-reference/detail/func_geometric.sb
@@ -28,10 +28,10 @@ These operate on vectors as vectors, not component-wise.
 \raw\&emsp;&emsp;\raw\Returns the distance between \code\p0\code\ and \code\p1\code\, i.e., \code\length(p0 - p1)\code\.
 
 \h3\dot() function\h3\
-\raw\#### <code>glm.<code>**dot**(**x**: *float*, **y**: *float*) -\\> *float*</code></code>\raw\
+\raw\#### <code>glm.<code>**dot**(**x**: *number*, **y**: *number*) -\\> *float*</code></code>\raw\
 \raw\&emsp;&emsp;\raw\Returns the dot product of \code\x\code\ and \code\y\code\, i.e., \code\result = x * y\code\.
 
-\raw\#### <code>glm.<code>**dot**(**x**: *vecN*, **y**: *vecN*) -\\> *float*</code></code>\raw\
+\raw\#### <code>glm.<code>**dot**(**x**: *vecN*, **y**: *vecN*) -\\> *number*</code></code>\raw\
 \raw\&emsp;&emsp;\raw\Returns the dot product of \code\x\code\ and \code\y\code\, i.e., \code\result = x[0] * y[0] + x[1] * y[1] + ...\code\
 
 \raw\#### <code>glm.<code>**dot**(**x**: *quat*, **y**: *quat*) -\\> *float*</code></code>\raw\

Original file line number	Diff line number	Diff line change
`@@ -1375,7 +1375,7 @@ mat_mul(PyObject obj1, PyObject obj2)`
`1375`	`1375`	`if (PyGLM_Vec_PTI_Check0(R, T, obj1)) { // obj1 is a col_type`
`1376`	`1376`	`glm::vec<R, T> o = PyGLM_Vec_PTI_Get0(R, T, obj1);`
`1377`	`1377`
`1378`		`- return pack_vec(o * ((mat<C, R, T>*)obj2)->super_type);`
	`1378`	`+ return pack_vec(glm::custom::mat_mul(o, ((mat<C, R, T>*)obj2)->super_type));`
`1379`	`1379`	`}`
`1380`	`1380`
`1381`	`1381`	`if (!PyGLM_Mat_PTI_Check0(C, R, T, obj1)) { // obj1 can't be interpreted as mat<C, R, T>`
`@@ -1394,7 +1394,7 @@ mat_mul(PyObject obj1, PyObject obj2)`
`1394`	`1394`	`if (PyGLM_Vec_PTI_Check0(C, T, obj2)) { // obj2 is a row_type`
`1395`	`1395`	`glm::vec<C, T> o2 = PyGLM_Vec_PTI_Get0(C, T, obj2);`
`1396`	`1396`
`1397`		`- return pack_vec(o * o2);`
	`1397`	`+ return pack_vec(glm::custom::mat_mul(o, o2));`
`1398`	`1398`	`}`
`1399`	`1399`
`1400`	`1400`	`if (PyGLM_Mat_PTI_Check0(2, C, T, obj2)) {`