thoehne/PhanesEngine
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: thoehne:0f0c8088172f69d0036170bebe3e421d995c90da
Branches Tags
thoehne:main
..
compare: thoehne:main
Branches Tags
thoehne:main

10 Commits
0f0c808817 ... main

Author SHA1 Message Date
Thorben Höhne
1688665852 Removing .vscode project config 2025-05-04 21:31:44 +02:00
Thorben Höhne
b881bde64b feat: Changes to Matrix2 FunctionTests 2025-05-04 21:30:14 +02:00
Thorben Höhne
e6d0cd2235 Insignificant changes 2025-05-04 21:29:31 +02:00
Thorben Höhne
91ea4a1aed chore: Fixing wrong docs. 2025-05-04 21:28:51 +02:00
Thorben Höhne
8bd331396d chore: Make construction from 2d Array explicit. 2025-05-04 21:27:53 +02:00
Thorben Höhne
af41821541 chore: Replacing typedef with using. 2025-05-04 21:26:24 +02:00
Thorben Höhne
1213bd3a2d feat: Introducing TQuaternion. 2025-05-04 21:24:56 +02:00
Thorben Höhne
3d656bedb0 feat: Fixing typo 2025-05-04 19:58:52 +02:00
Thorben Höhne
81ef16cc99 feat: Fix misleading doc. 2025-05-04 16:30:02 +02:00
Thorben Höhne
77d39b6254 feat: First good README.md 2025-05-04 02:02:34 +02:00
12 changed files with 1885 additions and 1608 deletions
Expand all files Collapse all files

4
.clang-tidy
View File

@@ -21,7 +21,9 @@ clang-analyzer-*,
-modernize-avoid-c-arrays, -modernize-avoid-c-arrays,
-cppcoreguidelines-pro-bounds-array-to-pointer-decay, -cppcoreguidelines-pro-bounds-array-to-pointer-decay,
-readability-named-parameter, -readability-named-parameter,
-cert-env33-c -cert-env33-c,
-readability-identifier-length,
-cppcoreguidelines-pro-type-union-access
' '

32
.vscode/launch.json vendored
View File

@@ -1,32 +0,0 @@
{
// Use IntelliSense to learn about possible attributes.
// Hover to view descriptions of existing attributes.
// For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
"version": "0.2.0",
"configurations": [
{
"name": "Debug MathTestFPU (gdb)",
"type": "cppdbg",
"request": "launch",
"program": "${workspaceFolder}/bin/1.0.0/Debug/MathTestFPU/MathTestFPU",
"args": [],
"stopAtEntry": false,
"cwd": "${fileDirname}",
"environment": [],
"externalConsole": false,
"MIMode": "gdb",
"setupCommands": [
{
"description": "Enable pretty-printing for gdb",
"text": "-enable-pretty-printing",
"ignoreFailures": true
},
{
"description": "Set Disassembly Flavor to Intel",
"text": "-gdb-set disassembly-flavor intel",
"ignoreFailures": true
}
]
}
]
}

152
.vscode/settings.json vendored
View File

@@ -1,152 +0,0 @@
{
"C_Cpp.formatting": "clangFormat",
"C_Cpp.loggingLevel": "Error",
"C_Cpp.default.cppStandard": "c++20",
"C_Cpp.default.includePath": [
"${workspaceFolder}/Engine/Source/Runtime/",
"${workspaceFolder}/Engine/Source/ThirdParty/"
],
"C_Cpp.default.browse.path": [
"${workspaceFolder}/Engine/Source/Runtime",
"${workspaceFolder}/Engine/Source/ThirdParty"
],
"C_Cpp.default.browse.databaseFilename": "${workspaceFolder}/.vscode/browse.vc.db",
"files.associations": {
"cstdint": "cpp",
"chrono": "cpp",
"string": "cpp",
"cctype": "cpp",
"clocale": "cpp",
"cmath": "cpp",
"cstdarg": "cpp",
"cstddef": "cpp",
"cstdio": "cpp",
"cstdlib": "cpp",
"cstring": "cpp",
"ctime": "cpp",
"cwchar": "cpp",
"cwctype": "cpp",
"any": "cpp",
"array": "cpp",
"atomic": "cpp",
"bit": "cpp",
"*.tcc": "cpp",
"bitset": "cpp",
"charconv": "cpp",
"cinttypes": "cpp",
"codecvt": "cpp",
"compare": "cpp",
"complex": "cpp",
"concepts": "cpp",
"condition_variable": "cpp",
"deque": "cpp",
"forward_list": "cpp",
"list": "cpp",
"map": "cpp",
"set": "cpp",
"unordered_map": "cpp",
"unordered_set": "cpp",
"vector": "cpp",
"exception": "cpp",
"expected": "cpp",
"algorithm": "cpp",
"functional": "cpp",
"iterator": "cpp",
"memory": "cpp",
"memory_resource": "cpp",
"numeric": "cpp",
"optional": "cpp",
"random": "cpp",
"ratio": "cpp",
"regex": "cpp",
"source_location": "cpp",
"string_view": "cpp",
"system_error": "cpp",
"tuple": "cpp",
"type_traits": "cpp",
"utility": "cpp",
"hash_map": "cpp",
"hash_set": "cpp",
"format": "cpp",
"fstream": "cpp",
"future": "cpp",
"initializer_list": "cpp",
"iomanip": "cpp",
"iosfwd": "cpp",
"iostream": "cpp",
"istream": "cpp",
"limits": "cpp",
"mutex": "cpp",
"new": "cpp",
"numbers": "cpp",
"ostream": "cpp",
"semaphore": "cpp",
"shared_mutex": "cpp",
"span": "cpp",
"sstream": "cpp",
"stdexcept": "cpp",
"stdfloat": "cpp",
"stop_token": "cpp",
"streambuf": "cpp",
"text_encoding": "cpp",
"thread": "cpp",
"cfenv": "cpp",
"typeindex": "cpp",
"typeinfo": "cpp",
"valarray": "cpp",
"variant": "cpp"
},
"C_Cpp.default.defines": [
"P_LINUX_BUILD",
"__SSE__",
],
"C_Cpp.default.configurationProvider": "ms-vscode.cmake-tools",
"editor.tokenColorCustomizations": {
"[*Light*]": {
"textMateRules": [
{
"scope": "ref.matchtext",
"settings": {
"foreground": "#000"
}
}
]
},
"[*Dark*]": {
"textMateRules": [
{
"scope": "ref.matchtext",
"settings": {
"foreground": "#fff"
}
}
]
},
"textMateRules": [
{
"scope": "googletest.failed",
"settings": {
"foreground": "#f00"
}
},
{
"scope": "googletest.passed",
"settings": {
"foreground": "#0f0"
}
},
{
"scope": "googletest.run",
"settings": {
"foreground": "#0f0"
}
}
]
},
"gtest-adapter.debugConfig": [
"Debug MathTestFPU (gdb)"
],
"gtest-adapter.supportLocation": true,
"premake.version": "Premake 5.0-beta5",
}

28
.vscode/tasks.json vendored
View File

@@ -1,28 +0,0 @@
{
"tasks": [
{
"type": "cppbuild",
"label": "C/C++: g++ build active file",
"command": "/sbin/g++",
"args": [
"-fdiagnostics-color=always",
"-g",
"${file}",
"-o",
"${fileDirname}/${fileBasenameNoExtension}"
],
"options": {
"cwd": "${fileDirname}"
},
"problemMatcher": [
"$gcc"
],
"group": {
"kind": "build",
"isDefault": true
},
"detail": "Task generated by Debugger."
}
],
"version": "2.0.0"
}

307
Engine/Source/Runtime/Core/Math/MathFwd.h
View File

@@ -1,201 +1,238 @@
#pragma once #pragma once
#ifdef P_BUILD_LIB #ifdef P_BUILD_LIB
#include "PhanesEnginePCH.h" # include "PhanesEnginePCH.h"
#else #else
#include <vector> # include <vector>
#endif #endif
#ifndef MATH_FWD_H #ifndef MATH_FWD_H
#define MATH_FWD_H # define MATH_FWD_H
#include "Core/Math/Boilerplate.h" # include "Core/Math/Boilerplate.h"
#include "Core/Math/SIMD/PhanesSIMDTypes.h" # include "Core/Math/SIMD/PhanesSIMDTypes.h"
/** /**
* Includes forward declarations, as well as certain useful typedefs. * Includes forward declarations, as well as certain useful usings.
* *
* @ref OSAL/PlatformTypes.h * @ref OSAL/PlatformTypes.h
*/ */
namespace Phanes::Core::Math
{
namespace Phanes::Core::Math { /**
/**
* Template forward declarations. * Template forward declarations.
*/ */
template<RealType T> struct TColor; template <RealType T>
template<RealType T> struct TLinearColor; struct TColor;
template<RealType T> struct TLine;
template<RealType T> struct TQuaternion;
template<RealType T> struct TTransform;
template<RealType T> struct TPoint2;
template<RealType T> struct TPoint3;
template<RealType T> struct TPoint4;
template<IntType T> struct TIntPoint2;
template<IntType T> struct TIntPoint3;
template<IntType T> struct TIntPoint4;
template<RealType T> struct TMatrix2;
template<RealType T, bool S> struct TMatrix3;
template<RealType T, bool S> struct TMatrix4;
template<RealType T, bool S> struct TVector2;
template<RealType T, bool S> struct TVector3;
template<RealType T, bool S> struct TVector4;
template<IntType T, bool S> struct TIntVector2;
template<IntType T, bool S> struct TIntVector3;
template<IntType T, bool S> struct TIntVector4;
template<RealType T, bool S> struct TPlane;
template<RealType T, bool S> struct TRay;
/** template <RealType T>
struct TLinearColor;
template <RealType T>
struct TLine;
template <RealType T>
struct TTransform;
template <RealType T>
struct TPoint2;
template <RealType T>
struct TPoint3;
template <RealType T>
struct TPoint4;
template <IntType T>
struct TIntPoint2;
template <IntType T>
struct TIntPoint3;
template <IntType T>
struct TIntPoint4;
template <RealType T>
struct TMatrix2;
template <RealType T, bool S>
struct TQuaternion;
template <RealType T, bool S>
struct TMatrix3;
template <RealType T, bool S>
struct TMatrix4;
template <RealType T, bool S>
struct TVector2;
template <RealType T, bool S>
struct TVector3;
template <RealType T, bool S>
struct TVector4;
template <IntType T, bool S>
struct TIntVector2;
template <IntType T, bool S>
struct TIntVector3;
template <IntType T, bool S>
struct TIntVector4;
template <RealType T, bool S>
struct TPlane;
template <RealType T, bool S>
struct TRay;
/**
* Specific instantiation of forward declarations. * Specific instantiation of forward declarations.
*/ */
// TPoint2 // TPoint2
typedef TPoint2<float> Point2; using Point2 = TPoint2<float>;
typedef TPoint2<float> Point2f; using Point2f = TPoint2<float>;
typedef TPoint2<double> Point2d; using Point2d = TPoint2<double>;
// TPoint3 // TPoint3
typedef TPoint3<float> Point3; using Point3 = TPoint3<float>;
typedef TPoint3<float> Point3f; using Point3f = TPoint3<float>;
typedef TPoint3<double> Point3d; using Point3d = TPoint3<double>;
// TPoint4 // TPoint4
typedef TPoint4<float> Point4; using Point4 = TPoint4<float>;
typedef TPoint4<float> Point4f; using Point4f = TPoint4<float>;
typedef TPoint4<double> Point4d; using Point4d = TPoint4<double>;
// TIntPoint2
// TIntPoint2 using IntPoint2 = TIntPoint2<int>;
using IntPoint2i = TIntPoint2<int>;
using IntPoint2l = TIntPoint2<long>;
typedef TIntPoint2<int> IntPoint2; // TIntPoint3
typedef TIntPoint2<int> IntPoint2i;
typedef TIntPoint2<long> IntPoint2l;
// TIntPoint3 using IntPoint3 = TIntPoint3<int>;
using IntPoint3i = TIntPoint3<int>;
using IntPoint3l = TIntPoint3<long>;
typedef TIntPoint3<int> IntPoint3; // TIntPoint4
typedef TIntPoint3<int> IntPoint3i;
typedef TIntPoint3<long> IntPoint3l;
// TIntPoint4 using IntPoint4 = TIntPoint4<int>;
using IntPoint4i = TIntPoint4<int>;
using IntPoint4l = TIntPoint4<long>;
typedef TIntPoint4<int> IntPoint4; // IntVetor2
typedef TIntPoint4<int> IntPoint4i;
typedef TIntPoint4<long> IntPoint4l;
// IntVetor2 using IntVector2 = TIntVector2<int, false>;
using Vector2i = TIntVector2<int, false>;
using LongVector2 = TIntVector2<long, false>;
using Vector2l = TIntVector2<long, false>;
typedef TIntVector2<int, false> IntVector2; // IntVetor3
typedef TIntVector2<int, false> Vector2i;
typedef TIntVector2<long, false> LongVector2;
typedef TIntVector2<long, false> Vector2l;
// IntVetor3 using IntVector3 = TIntVector3<int, false>;
using Vector3i = TIntVector3<int, false>;
using LongVector3 = TIntVector3<long, false>;
using Vector3l = TIntVector3<long, false>;
typedef TIntVector3<int, false> IntVector3; // IntVetor4
typedef TIntVector3<int, false> Vector3i;
typedef TIntVector3<long, false> LongVector3;
typedef TIntVector3<long, false> Vector3l;
using IntVector4 = TIntVector4<int, false>;
using Vector4i = TIntVector4<int, false>;
using LongVector4 = TIntVector4<long, false>;
using Vector4l = TIntVector4<long, false>;
// IntVetor4 // Vector2
typedef TIntVector4<int, false> IntVector4; using Vector2 = TVector2<float, false>;
typedef TIntVector4<int, false> Vector4i; using Vector2f = TVector2<float, false>;
typedef TIntVector4<long, false> LongVector4; using Vector2d = TVector2<double, false>;
typedef TIntVector4<long, false> Vector4l;
// Vector2 using Vector2Regf64 = TVector2<double, SIMD::use_simd<double, 2, true>::value>;
using Vector2Reg = TVector2<double, SIMD::use_simd<double, 2, true>::value>;
using Vector2Regd = TVector2<double, SIMD::use_simd<double, 2, true>::value>;
typedef TVector2<float, false> Vector2; // Vector3
typedef TVector2<float, false> Vector2f;
typedef TVector2<double, false> Vector2d;
typedef TVector2<double, SIMD::use_simd<double, 2, true>::value> Vector2Regf64; using Vector3 = TVector3<float, false>;
typedef TVector2<double, SIMD::use_simd<double, 2, true>::value> Vector2Reg; using Vector3f = TVector3<float, false>;
typedef TVector2<double, SIMD::use_simd<double, 2, true>::value> Vector2Regd; using Vector3d = TVector3<double, false>;
using Vector3Reg = TVector3<float, SIMD::use_simd<float, 3, true>::value>;
using Vector3Regf32 = TVector3<float, SIMD::use_simd<float, 3, true>::value>;
using Vector3Regd = TVector3<double, SIMD::use_simd<double, 3, true>::value>;
using Vector3Regf64 = TVector3<double, SIMD::use_simd<double, 3, true>::value>;
// Vector3 // Vector4
typedef TVector3<float, false> Vector3; using Vector4 = TVector4<float, false>;
typedef TVector3<float, false> Vector3f; using Vector4f = TVector4<float, false>;
typedef TVector3<double, false> Vector3d; using Vector4d = TVector4<double, false>;
typedef TVector3<float, SIMD::use_simd<float, 3, true>::value> Vector3Reg; using Vector4Reg = TVector4<float, SIMD::use_simd<float, 4, true>::value>;
typedef TVector3<float, SIMD::use_simd<float, 3, true>::value> Vector3Regf32; using Vector4Regf32 = TVector4<float, SIMD::use_simd<float, 4, true>::value>;
typedef TVector3<double, SIMD::use_simd<double, 3, true>::value> Vector3Regd; using Vector4Regd = TVector4<double, SIMD::use_simd<double, 4, true>::value>;
typedef TVector3<double, SIMD::use_simd<double, 3, true>::value> Vector3Regf64; using Vector4Regf64 = TVector4<double, SIMD::use_simd<double, 4, true>::value>;
// Matrix2
// Vector4 using Matrix2 = TMatrix2<float>;
using Matrix2f = TMatrix2<float>;
using Matrix2d = TMatrix2<double>;
typedef TVector4<float, false> Vector4; // Matrix3
typedef TVector4<float, false> Vector4f;
typedef TVector4<double, false> Vector4d;
typedef TVector4<float, SIMD::use_simd<float, 4, true>::value> Vector4Reg; using Matrix3 = TMatrix3<float, false>;
typedef TVector4<float, SIMD::use_simd<float, 4, true>::value> Vector4Regf32; using Matrix3f = TMatrix3<float, false>;
typedef TVector4<double, SIMD::use_simd<double, 4, true>::value> Vector4Regd; using Matrix3d = TMatrix3<double, false>;
typedef TVector4<double, SIMD::use_simd<double, 4, true>::value> Vector4Regf64;
// Matrix2
typedef TMatrix2<float> Matrix2;
typedef TMatrix2<float> Matrix2f;
typedef TMatrix2<double> Matrix2d;
// Matrix3 using Matrix3Reg = TMatrix3<float, SIMD::use_simd<float, 3, true>::value>;
using Matrix3Regf = TMatrix3<float, SIMD::use_simd<float, 3, true>::value>;
using Matrix3Regd = TMatrix3<double, SIMD::use_simd<double, 3, true>::value>;
using Matrix3Regf64 = TMatrix3<double, SIMD::use_simd<double, 3, true>::value>;
typedef TMatrix3<float, false> Matrix3; // Matrix4
typedef TMatrix3<float, false> Matrix3f;
typedef TMatrix3<double, false> Matrix3d;
typedef TMatrix3<float, SIMD::use_simd<float, 3, true>::value> Matrix3Reg; using Matrix4 = TMatrix4<float, false>;
typedef TMatrix3<float, SIMD::use_simd<float, 3, true>::value> Matrix3Regf; using Matrix4f = TMatrix4<float, false>;
typedef TMatrix3<double, SIMD::use_simd<double, 3, true>::value> Matrix3Regd; using Matrix4d = TMatrix4<double, false>;
typedef TMatrix3<double, SIMD::use_simd<double, 3, true>::value> Matrix3Regf64;
// Matrix4 using Matrix4Reg = TMatrix3<float, SIMD::use_simd<float, 4, true>::value>;
using Matrix4Regf = TMatrix3<float, SIMD::use_simd<float, 4, true>::value>;
using Matrix4Regd = TMatrix3<double, SIMD::use_simd<double, 4, true>::value>;
using Matrix4Regf64 = TMatrix3<double, SIMD::use_simd<double, 4, true>::value>;
typedef TMatrix4<float, false> Matrix4; // TPlane
typedef TMatrix4<float, false> Matrix4f;
typedef TMatrix4<double, false> Matrix4d;
typedef TMatrix3<float, SIMD::use_simd<float, 4, true>::value> Matrix4Reg; using Plane = TPlane<float, false>;
typedef TMatrix3<float, SIMD::use_simd<float, 4, true>::value> Matrix4Regf; using Planef = TPlane<float, false>;
typedef TMatrix3<double, SIMD::use_simd<double, 4, true>::value> Matrix4Regd; using Planed = TPlane<double, false>;
typedef TMatrix3<double, SIMD::use_simd<double, 4, true>::value> Matrix4Regf64;
using PlaneReg = TPlane<float, SIMD::use_simd<float, 4, true>::value>;
using PlaneRegd = TPlane<float, SIMD::use_simd<double, 4, true>::value>;
} // namespace Phanes::Core::Math
// TPlane
typedef TPlane<float, false> Plane;
typedef TPlane<float, false> Planef;
typedef TPlane<double, false> Planed;
typedef TPlane<float, SIMD::use_simd<float, 4, true>::value> PlaneReg;
typedef TPlane<float, SIMD::use_simd<double, 4, true>::value> PlaneRegd;
} // Phanes::Core::Math::coretypes
namespace Phanes::Core::Math::Internal namespace Phanes::Core::Math::Internal
{ {
// Internal types // Internal types
template <typename T, unsigned int D> struct AVector; template <typename T, unsigned int D>
struct AVector;
template <typename T, unsigned int n, unsigned int> struct AMatrix; template <typename T, unsigned int n, unsigned int>
} struct AMatrix;
} // namespace Phanes::Core::Math::Internal
#endif // !MATH_FWD_H
#endif // !MATH_FWD_H

541
Engine/Source/Runtime/Core/Math/Matrix2.hpp
View File

@@ -7,352 +7,345 @@
#include "Core/Math/Vector2.hpp" #include "Core/Math/Vector2.hpp"
#ifndef MATRIX2_H #ifndef MATRIX2_H
#define MATRIX2_H # define MATRIX2_H
namespace Phanes::Core::Math { namespace Phanes::Core::Math
{
// 2x2 Matrix defined in column-major order.
// Accessed by M[Row][Col].
template<RealType T> // 2x2 Matrix defined in column-major order.
struct TMatrix2 // Accessed by M[Col][Row].
{
public:
union template <RealType T>
{ struct TMatrix2
struct {
{ public:
/// <summary> union
/// Column one. {
/// </summary> struct
TVector2<T, false> c0; {
/// <summary>
/// Column one.
/// </summary>
TVector2<T, false> c0;
/// <summary> /// <summary>
/// Column two /// Column two
/// </summary> /// </summary>
TVector2<T, false> c1; TVector2<T, false> c1;
}; };
T data[2][2]; T data[2][2];
}; };
public: public:
TMatrix2() = default;
TMatrix2() = default; /**
/**
* Copy constructor. * Copy constructor.
*/ */
TMatrix2(const TMatrix2<T>& m1) TMatrix2(const TMatrix2<T>& m1)
{ {
this->c0 = m1.c0; this->c0 = m1.c0;
this->c1 = m1.c1; this->c1 = m1.c1;
} }
/** /**
* Construct Matrix from 2d array. * Construct Matrix from 2d array.
* *
* @param(fields) 2D Array with column major order. * @param(fields) 2D Array with column major order.
*/ */
TMatrix2(T fields[2][2]) TMatrix2(T fields[2][2])
{ {
this->data[0][0] = fields[0][0]; this->data[1][0] = fields[1][0]; this->data[0][0] = fields[0][0];
this->data[0][1] = fields[0][1]; this->data[1][1] = fields[1][1]; this->data[1][0] = fields[1][0];
} this->data[0][1] = fields[0][1];
this->data[1][1] = fields[1][1];
}
/** /**
* Construct Matrix from parameters. * Construct Matrix from parameters.
* *
* @param(n00) M[0][0] * @param(n00) M[0][0]
* @param(n10) M[1][0] * @param(n01) M[1][0]
* @param(n01) M[0][1] * @param(n10) M[0][1]
* @param(n11) M[1][1] * @param(n11) M[1][1]
* *
* @note nXY = n[Row][Col] * @note nXY = n[Col][Row]
*/ */
TMatrix2(T n00, T n01, T n10, T n11) TMatrix2(T n00, T n01, T n10, T n11)
{ {
this->data[0][0] = n00; this->data[1][0] = n01; this->data[0][0] = n00;
this->data[0][1] = n10; this->data[1][1] = n11; this->data[1][0] = n01;
} this->data[0][1] = n10;
this->data[1][1] = n11;
}
/** /**
* Construct Matrix from two 2d vector columns. * Construct Matrix from two 2d vector columns.
* *
* @param(v1) Column zero * @param(v1) Column zero
* @param(v2) Column one * @param(v2) Column one
*/ */
TMatrix2(const TVector2<T, false>& v1, const TVector2<T, false>& v2) TMatrix2(const TVector2<T, false>& v1, const TVector2<T, false>& v2)
{ {
this->c0 = v1; this->c0 = v1;
this->c1 = v2; this->c1 = v2;
} }
public: public:
T& operator()(int n, int m)
{
return this->data[m][n];
}
T& operator() (int n, int m) T operator()(int n, int m) const
{ {
return this->data[m][n]; return this->data[m][n];
} }
T operator() (int n, int m) const TVector2<T, false>& operator[](int m)
{ {
return this->data[m][n]; switch(m)
} {
case 0:
return this->c0;
case 1:
return this->c1;
}
TVector2<T, false>& operator[] (int m) throw std::invalid_argument("m is outside valid range.");
{ }
switch (m)
{
case 0:
return this->c0;
case 1:
return this->c1;
}
throw std::invalid_argument("m is outside valid range."); TVector2<T, false> operator[](int m) const
} {
switch(m)
{
case 0:
return this->c0;
case 1:
return this->c1;
}
TVector2<T, false> operator[] (int m) const throw std::invalid_argument("m is outside valid range.");
{ }
switch (m) };
{
case 0:
return this->c0;
case 1:
return this->c1;
}
throw std::invalid_argument("m is outside valid range."); // ====================== //
} // TMatrix2 operator //
// ====================== //
}; template <RealType T>
TMatrix2<T>& operator+=(TMatrix2<T>& m1, T s)
{
m1(0, 0) += s;
m1(0, 1) += s;
m1(1, 0) += s;
m1(1, 1) += s;
// ====================== // return m1;
// TMatrix2 operator // }
// ====================== //
template<RealType T>
TMatrix2<T>& operator+= (TMatrix2<T>& m1, T s)
{
m1(0, 0) += s;
m1(0, 1) += s;
m1(1, 0) += s;
m1(1, 1) += s;
return m1; template <RealType T>
} TMatrix2<T>& operator+=(TMatrix2<T>& m1, const TMatrix2<T>& m2)
{
m1(0, 0) += m2(0, 0);
m1(0, 1) += m2(0, 1);
m1(1, 0) += m2(1, 0);
m1(1, 1) += m2(1, 1);
template<RealType T> return m1;
TMatrix2<T>& operator+= (TMatrix2<T>& m1, const TMatrix2<T>& m2) }
{
m1(0, 0) += m2(0, 0);
m1(0, 1) += m2(0, 1);
m1(1, 0) += m2(1, 0);
m1(1, 1) += m2(1, 1);
return m1; template <RealType T>
} TMatrix2<T>& operator-=(TMatrix2<T>& m1, T s)
{
template<RealType T> m1(0, 0) -= s;
TMatrix2<T>& operator-= (TMatrix2<T>& m1, T s) m1(0, 1) -= s;
{ m1(1, 0) -= s;
m1(0, 0) -= s; m1(1, 1) -= s;
m1(0, 1) -= s;
m1(1, 0) -= s;
m1(1, 1) -= s;
return m1; return m1;
} }
template<RealType T>
TMatrix2<T>& operator-= (TMatrix2<T>& m1, const TMatrix2<T>& m2)
{
m1(0, 0) -= m2(0, 0);
m1(0, 1) -= m2(0, 1);
m1(1, 0) -= m2(1, 0);
m1(1, 1) -= m2(1, 1);
return m1; template <RealType T>
} TMatrix2<T>& operator-=(TMatrix2<T>& m1, const TMatrix2<T>& m2)
{
template<RealType T> m1(0, 0) -= m2(0, 0);
TMatrix2<T>& operator*= (TMatrix2<T>& m1, T s) m1(0, 1) -= m2(0, 1);
{ m1(1, 0) -= m2(1, 0);
m1.data[0][0] *= s; m1(1, 1) -= m2(1, 1);
m1.data[0][1] *= s;
m1.data[1][0] *= s;
m1.data[1][1] *= s;
return m1; return m1;
} }
template<RealType T>
TMatrix2<T>& operator*= (TMatrix2<T>& m1, const TMatrix2<T>& m2)
{
TMatrix2<T> c = m1;
m1(0, 0) = c(0, 0) * m2(0, 0) + c(0, 1) * m2(1, 0); template <RealType T>
m1(0, 1) = c(0, 0) * m2(0, 1) + c(0, 1) * m2(1, 1); TMatrix2<T>& operator*=(TMatrix2<T>& m1, T s)
{
m1.data[0][0] *= s;
m1.data[0][1] *= s;
m1.data[1][0] *= s;
m1.data[1][1] *= s;
m1(1, 0) = c(1, 0) * m2(0, 0) + c(1, 1) * m2(1, 0); return m1;
m1(1, 1) = c(1, 0) * m2(0, 1) + c(1, 1) * m2(1, 1); }
return m1; template <RealType T>
} TMatrix2<T>& operator*=(TMatrix2<T>& m1, const TMatrix2<T>& m2)
{
TMatrix2<T> c = m1;
template<RealType T> m1(0, 0) = c(0, 0) * m2(0, 0) + c(0, 1) * m2(1, 0);
TMatrix2<T>& operator/= (TMatrix2<T>& m1, T s) m1(0, 1) = c(0, 0) * m2(0, 1) + c(0, 1) * m2(1, 1);
{
s = (T)1.0 / s;
m1.data[0][0] *= s;
m1.data[0][1] *= s;
m1.data[1][0] *= s;
m1.data[1][1] *= s;
return m1; m1(1, 0) = c(1, 0) * m2(0, 0) + c(1, 1) * m2(1, 0);
} m1(1, 1) = c(1, 0) * m2(0, 1) + c(1, 1) * m2(1, 1);
template<RealType T> return m1;
TMatrix2<T> operator+ (const TMatrix2<T>& m1, T s) }
{
return TMatrix2<T>(m1(0, 0) + s, m1(0, 1) + s,
m1(1, 0) + s, m1(1, 1) + s);
}
template<RealType T>
TMatrix2<T> operator+ (const TMatrix2<T>& m1, const TMatrix2<T>& m2)
{
return TMatrix2<T>(m1(0, 0) + m2(0, 0), m1(0, 1) + m2(0, 1),
m1(1, 0) + m2(1, 0), m1(1, 1) + m2(1, 1));
}
template<RealType T> template <RealType T>
TMatrix2<T> operator- (const TMatrix2<T>& m1, T s) TMatrix2<T>& operator/=(TMatrix2<T>& m1, T s)
{ {
return TMatrix2<T>(m1(0, 0) - s, m1(0, 1) - s, s = (T)1.0 / s;
m1(1, 0) - s, m1(1, 1) - s); m1.data[0][0] *= s;
} m1.data[0][1] *= s;
m1.data[1][0] *= s;
template<RealType T> m1.data[1][1] *= s;
TMatrix2<T> operator- (const TMatrix2<T>& m1, const TMatrix2<T>& m2)
{
return TMatrix2<T>(m1(0, 0) - m2(0, 0), m1(0, 1) - m2(0, 1),
m1(1, 0) - m2(1, 0), m1(1, 1) - m2(1, 1));
}
template<RealType T> return m1;
TMatrix2<T> operator* (const TMatrix2<T>& m1, T s) }
{
return TMatrix2<T>(m1(0, 0) * s, m1(0, 1) * s,
m1(1, 0) * s, m1(1, 1) * s);
}
template<RealType T> template <RealType T>
TMatrix2<T> operator/ (const TMatrix2<T>& m1, T s) TMatrix2<T> operator+(const TMatrix2<T>& m1, T s)
{ {
s = (T)1.0 / s; return TMatrix2<T>(m1(0, 0) + s, m1(0, 1) + s, m1(1, 0) + s, m1(1, 1) + s);
return TMatrix2<T>(m1(0, 0) * s, m1(0, 1) * s, }
m1(1, 0) * s, m1(1, 1) * s);
}
template<RealType T>
TMatrix2<T> operator* (const TMatrix2<T>& m1, const TMatrix2<T>& m2)
{
return TMatrix2<T>(m1(0, 0) * m2(0, 0) + m1(0, 1) * m2(1, 0), m1(0, 0) * m2(0, 1) + m1(0, 1) * m2(1, 1),
m1(1, 0) * m2(0, 0) + m1(1, 1) * m2(1, 0), m1(1, 0) * m2(0, 1) + m1(1, 1) * m2(1, 1));
}
template<RealType T>
TVector2<T, false> operator* (const TMatrix2<T>& m1, const TVector2<T, false>& v)
{
return TVector2<T, false>(m1(0, 0) * v.x + m1(0, 1) * v.y,
m1(1, 0) * v.x + m1(1, 1) * v.y);
}
template<RealType T> template <RealType T>
bool operator== (const TMatrix2<T>& m1, const TMatrix2<T>& m2) TMatrix2<T> operator+(const TMatrix2<T>& m1, const TMatrix2<T>& m2)
{ {
return m1[0] == m2[0] && m1[1] == m2[1]; return TMatrix2<T>(
} m1(0, 0) + m2(0, 0), m1(0, 1) + m2(0, 1), m1(1, 0) + m2(1, 0), m1(1, 1) + m2(1, 1));
}
template<RealType T> template <RealType T>
bool operator!= (const TMatrix2<T>& m1, const TMatrix2<T>& m2) TMatrix2<T> operator-(const TMatrix2<T>& m1, T s)
{ {
return m1[0] != m2[0] || m1[1] != m2[1]; return TMatrix2<T>(m1(0, 0) - s, m1(0, 1) - s, m1(1, 0) - s, m1(1, 1) - s);
} }
template <RealType T>
TMatrix2<T> operator-(const TMatrix2<T>& m1, const TMatrix2<T>& m2)
{
return TMatrix2<T>(
m1(0, 0) - m2(0, 0), m1(0, 1) - m2(0, 1), m1(1, 0) - m2(1, 0), m1(1, 1) - m2(1, 1));
}
// ============================== // template <RealType T>
// Matrix function definition // TMatrix2<T> operator*(const TMatrix2<T>& m1, T s)
// ============================== // {
return TMatrix2<T>(m1(0, 0) * s, m1(0, 1) * s, m1(1, 0) * s, m1(1, 1) * s);
}
template<RealType T> template <RealType T>
T Determinant(const TMatrix2<T>& m1) TMatrix2<T> operator/(const TMatrix2<T>& m1, T s)
{ {
return m1(0, 0) * m1(1, 1) - m1(0, 1) * m1(1, 0); s = (T)1.0 / s;
} return TMatrix2<T>(m1(0, 0) * s, m1(0, 1) * s, m1(1, 0) * s, m1(1, 1) * s);
}
template<RealType T> template <RealType T>
TMatrix2<T>& InverseV(TMatrix2<T>& m1) TMatrix2<T> operator*(const TMatrix2<T>& m1, const TMatrix2<T>& m2)
{ {
float _1_det = 1.0f / Determinant(m1); return TMatrix2<T>(m1(0, 0) * m2(0, 0) + m1(0, 1) * m2(1, 0),
float m00 = m1(0, 0); m1(0, 0) * m2(0, 1) + m1(0, 1) * m2(1, 1),
m1(1, 0) * m2(0, 0) + m1(1, 1) * m2(1, 0),
m1(1, 0) * m2(0, 1) + m1(1, 1) * m2(1, 1));
}
m1(0, 0) = m1(1, 1); template <RealType T>
m1(0, 1) = -m1(0, 1); TVector2<T, false> operator*(const TMatrix2<T>& m1, const TVector2<T, false>& v)
m1(1, 0) = -m1(1, 0); {
m1(1, 1) = m00; return TVector2<T, false>(m1(0, 0) * v.x + m1(0, 1) * v.y, m1(1, 0) * v.x + m1(1, 1) * v.y);
}
m1 *= _1_det; template <RealType T>
return m1; bool operator==(const TMatrix2<T>& m1, const TMatrix2<T>& m2)
} {
return m1[0] == m2[0] && m1[1] == m2[1];
}
template<RealType T> template <RealType T>
TMatrix2<T>& TransposeV(TMatrix2<T>& m1) bool operator!=(const TMatrix2<T>& m1, const TMatrix2<T>& m2)
{ {
Swap(m1(0, 1), m1(1, 0)); return m1[0] != m2[0] || m1[1] != m2[1];
}
return m1; // ============================== //
} // Matrix function definition //
// ============================== //
// =============== // template <RealType T>
// WITH RETURN // T Determinant(const TMatrix2<T>& m1)
// =============== // {
return m1(0, 0) * m1(1, 1) - m1(0, 1) * m1(1, 0);
}
template<RealType T> template <RealType T>
TMatrix2<T> Inverse(TMatrix2<T>& m1) TMatrix2<T>& InverseV(TMatrix2<T>& m1)
{ {
float _1_det = 1.0f / Determinant(m1); float _1_det = 1.0f / Determinant(m1);
float m00 = m1(0, 0);
return TMatrix2<T>( m1(1, 1) * _1_det, -m1(0, 1) * _1_det, m1(0, 0) = m1(1, 1);
-m1(1, 0) * _1_det, m1(0, 0) * _1_det); m1(0, 1) = -m1(0, 1);
} m1(1, 0) = -m1(1, 0);
m1(1, 1) = m00;
template<RealType T> m1 *= _1_det;
TMatrix2<T> Transpose(const TMatrix2<T>& m1) return m1;
{ }
return TMatrix2<T>(m1(0, 0), m1(1, 0),
m1(0, 1), m1(1, 1));
}
template<RealType T> template <RealType T>
bool IsIdentityMatrix(const TMatrix2<T>& m1, T threshold = P_FLT_INAC) TMatrix2<T>& TransposeV(TMatrix2<T>& m1)
{ {
return (abs(m1(0, 0) - (T)1.0) < P_FLT_INAC && abs(m1(0, 1)) < P_FLT_INAC && Swap(m1(0, 1), m1(1, 0));
abs(m1(1, 0)) < P_FLT_INAC && abs(m1(1, 1) - (T)1.0) < P_FLT_INAC);
}
} // Phanes::Core::Math return m1;
}
// =============== //
// WITH RETURN //
// =============== //
template <RealType T>
TMatrix2<T> Inverse(TMatrix2<T>& m1)
{
float _1_det = 1.0f / Determinant(m1);
return TMatrix2<T>(
m1(1, 1) * _1_det, -m1(0, 1) * _1_det, -m1(1, 0) * _1_det, m1(0, 0) * _1_det);
}
template <RealType T>
TMatrix2<T> Transpose(const TMatrix2<T>& m1)
{
return TMatrix2<T>(m1(0, 0), m1(1, 0), m1(0, 1), m1(1, 1));
}
template <RealType T>
bool IsIdentityMatrix(const TMatrix2<T>& m1, T threshold = P_FLT_INAC)
{
return (abs(m1(0, 0) - (T)1.0) < P_FLT_INAC && abs(m1(0, 1)) < P_FLT_INAC &&
abs(m1(1, 0)) < P_FLT_INAC && abs(m1(1, 1) - (T)1.0) < P_FLT_INAC);
}
} // namespace Phanes::Core::Math
#endif // !MATRIX2_H #endif // !MATRIX2_H
#include "Core/Math/SIMD/SIMDIntrinsics.h"
#include "Core/Math/SIMD/SIMDIntrinsics.h"

4
Engine/Source/Runtime/Core/Math/Matrix4.hpp
View File

@@ -83,7 +83,7 @@ namespace Phanes::Core::Math {
/// Construct matrix from field of values. /// Construct matrix from field of values.
/// </summary> /// </summary>
/// <param name="field"></param> /// <param name="field"></param>
TMatrix4(T field[4][4]) explicit TMatrix4(T field[4][4])
{ {
this->c0 = TVector4(field[0]); this->c0 = TVector4(field[0]);
this->c1 = TVector4(field[1]); this->c1 = TVector4(field[1]);
@@ -331,4 +331,4 @@ namespace Phanes::Core::Math {
#endif // !MATRIX4_H #endif // !MATRIX4_H
#include "Core/Math/Matrix4.inl" #include "Core/Math/Matrix4.inl"

85
Engine/Source/Runtime/Core/Math/Quaternion.hpp Normal file
View File

@@ -0,0 +1,85 @@
#pragma once
#include "Core/Math/Boilerplate.h"
#include "Core/Math/MathFwd.h"
#include "Core/Math/SIMD/PhanesSIMDTypes.h"
#include "Core/Math/SIMD/Storage.h"
#include "Core/Math/Vector3.hpp"
#include "Core/Math/Vector4.hpp"
#ifndef QUATERNION_H
# define QUATERNION_H
namespace Phanes::Core::Math
{
// Quaternion
template <RealType T, bool S>
struct TQuaternion
{
using Real = T;
public:
union
{
struct
{
float x;
float y;
float z;
float w;
};
union
{
typename SIMD::Storage<4, Real, SIMD::use_simd<Real, 4, S>::value>::type comp;
typename SIMD::Storage<4, Real, SIMD::use_simd<Real, 4, S>::value>::type data;
};
};
public:
/// Default constructor
TQuaternion() = default;
/**
* Construct quaternion from vector4.
* v.w is the scalar part of the quaternion (q.w).
*/
explicit TQuaternion(const TVector4<T, S>& v);
/**
* Construct quaternion from vector (x,y,z) and scalar part (w).
*
* @param x X
* @param y Y
* @param z Z
* @param w W
*/
TQuaternion(Real x, Real y, Real z, Real w);
/**
* Construct vector from vector part and scalar part.
*/
TQuaternion(const TVector3<Real, S>& v, Real w);
/**
* Construct quaternion from array of length >= four.
*
* @note If used with SIMD the array will is assumed to be aligned.
*/
explicit TQuaternion(const Real* comp);
/**
* Construct from euler angles (yaw, pitch, roll)
*/
explicit TQuaternion(const TVector3<Real, S>& euler_angels);
/**
* Construct from Transformation
*/
explicit TQuaternion(const TTransform<Real>& t);
explicit TQuaternion(const TMatrix4<Real, S>& t);
};
} // namespace Phanes::Core::Math
#endif // QUATERNION_H

21
Engine/Source/Runtime/Core/Tests/Math/MathTestFPU/main.cpp
View File

@@ -1,21 +0,0 @@
#include <iostream>
#include "Core/Math/Include.h"
namespace PMath = Phanes::Core::Math;
int main()
{
PMath::Matrix4 m0 = PMath::Matrix4(1.0f, 5.0f, 3.0f, 4.0f,
2.0f, 6.0f, 4.0f, 1.0f,
2.0f, -3.0f, 5.0f, 3.0f,
8.0f, -4.0f, 6.0f, -2.0f);
PMath::Matrix4 m2;
std::cout << std::to_string(PMath::InverseV<float, false>(m0)) << std::endl;
std::cout << PMath::ToString(m0) << std::endl;
return 0;
}

2256
Engine/Source/Runtime/Core/Tests/Math/MathTestFPU/test.cpp
View File

File diff suppressed because it is too large Load Diff

45
README.md
View File

@@ -1,2 +1,45 @@
# PhanesEngine # PhanesEngine
3D / 2D Game Engine.
Yet another Game Engine written in C++.
## Build
For building the engine premake5 is required. Execute `premake5 gmake` to generate the Makefile.
### PhanesCore
The Core Runtime library is build with:
make PhanesCore
## Status
Phanes is and will be developed, though progress will be slow.
### Currenty under development
- PhanesCore
- <span style="color:green; font-weight:800">Math</span>
## Testing
Testing PhanesEngine happens via the gtest framework. To run the tests for PhanesEngine one needs to
build the test applications (currently only MathTestFPU) as well as gtet.
make MathTestFPU
They depend on the gtest library so it should not be required to build it manually. If for some reason this doesn't
work gtest can be build via:
make gtest
## Sample Project
The repository contains a sample game project using PhanesEngine. It can be build by executing:
make DevPlayground
## Copyright
PhanesEngine was developed by Thorben Höhne and is licensed under the Apache License Version 2.0. See
[LICENSE](LICENSE) for more information.

18
premake5.lua
View File

@@ -63,17 +63,19 @@ function boilerplate()
buildoptions({ "-Wno-unused-parameter", "-fms-extensions" }) buildoptions({ "-Wno-unused-parameter", "-fms-extensions" })
end end
buildoptions({"-fno-fast-math"})
filter("configurations:Debug") filter("configurations:Debug")
defines({ "DEBUG", "TRACE", "P_DEBUG" }) defines({ "DEBUG", "TRACE", "P_DEBUG" })
symbols("On") symbols("On")
buildmessage("Building %{prj.name} in debug mode") buildmessage("Building %{prj.name} in debug mode")
filter("configurations:Release") filter("configurations:Release")
defines({ "NDEBUG", "P_RELEASE" }) defines({ "NDEBUG", "P_RELEASE" })
linktimeoptimization("On") linktimeoptimization("On")
optimize("On") optimize("On")
intrinsics("On") intrinsics("On")
buildmessage("Building %{prj.name} in release mode") buildmessage("Building %{prj.name} in release mode")
filter({}) filter({})
end end