Skip to content

Using custom dot implementation and fixing matmul #284

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 3 commits into from
Apr 10, 2025
Merged

Using custom dot implementation and fixing matmul #284

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
44de1ca
Fix project setup
Zuzu-Typ Apr 10, 2025
3a98f72
Using custom dot that supports integer vectors
Zuzu-Typ Apr 10, 2025
43fd699
Fixed matmul implementation for vectors
Zuzu-Typ Apr 10, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
146 changes: 143 additions & 3 deletions PyGLM_lib/PyGLM/functions/detail/func_geometric.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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"
Expand Down
2 changes: 2 additions & 0 deletions PyGLM_lib/PyGLM/imports.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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>
Expand Down
69 changes: 69 additions & 0 deletions PyGLM_lib/PyGLM/internal_functions/glm_customizations.h
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -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));
}
}
}
4 changes: 2 additions & 2 deletions PyGLM_lib/PyGLM/type_methods/mat.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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>
Expand All @@ -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)) {
Expand Down
11 changes: 10 additions & 1 deletion PyGLM_lib/PyGLM/type_methods/vec.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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);
}
Expand Down
7 changes: 4 additions & 3 deletions vs-project/PyGLM build/PyGLM build.vcxproj
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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'">
Expand All @@ -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'">
Expand Down Expand Up @@ -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'">
Expand Down Expand Up @@ -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" />
Expand Down
3 changes: 3 additions & 0 deletions vs-project/PyGLM build/PyGLM build.vcxproj.filters
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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>
2 changes: 1 addition & 1 deletion vs-project/PyGLM test.pyproj
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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>
Expand Down
2 changes: 1 addition & 1 deletion vs-project/PyGLM.sln
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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
Expand Down
4 changes: 2 additions & 2 deletions wiki/function-reference/detail/func_geometric.md
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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>
Expand Down
4 changes: 2 additions & 2 deletions wiki/function-reference/detail/func_geometric.sb
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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\
Expand Down