CMakeLists.txt

@@ -12,28 +12,19 @@ if(NOT CMAKE_BUILD_TYPE)
 endif()
 
 set(SRC_FILES
-        src/main.cpp
-        src/gamecube.cpp
-        src/gamematrix.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/main.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/gamecube.cpp
 )
 
-#set(INCLUDE_DIRS
-#        ${CMAKE_CURRENT_LIST_DIR}/linux
-#)
+set(INCLUDE_DIRS
+        ${CMAKE_CURRENT_LIST_DIR}/linux
+)
 
 add_executable(${EXECUTABLE_NAME} ${SRC_FILES})
-#target_include_directories(${EXECUTABLE_NAME} PRIVATE ${INCLUDE_DIRS})
-target_include_directories(Prog3B PRIVATE
-        ${CMAKE_CURRENT_LIST_DIR}/includes
-        ${CMAKE_CURRENT_LIST_DIR}/raylib
-)
+target_include_directories(${EXECUTABLE_NAME} PRIVATE ${INCLUDE_DIRS})
 target_link_libraries(${EXECUTABLE_NAME} PRIVATE
-        #${CMAKE_CURRENT_LIST_DIR}/windows/libgamematrix.a
-        ${CMAKE_CURRENT_LIST_DIR}/windows/libraylib.a
-        opengl32
-        gdi32
-        m
-        winmm
+        ${CMAKE_CURRENT_LIST_DIR}/linux/libgamematrix.a
+        ${CMAKE_CURRENT_LIST_DIR}/linux/libraylib.a
 )
 
 # Checks if OSX and links appropriate frameworks (Only required on MacOS)

gamecube.cpp

@@ -39,11 +39,11 @@ void gamecube::Draw() const
     rlPushMatrix();
 
     // Matrizen für Rotation und Translation erzeugen
-    auto matrix_a = Matrix3D::gameMatrix::translate({ position.x, position.y, position.z});
-    auto matrix_b = Matrix3D::gameMatrix::rot3D(rotation, 'y');
+    auto matrix_a = gameMatrix::translate({ position.x, position.y, position.z});
+    auto matrix_b = gameMatrix::rot3D(rotation, 'y');
 
     // Matrizen multiplizieren (Translation * Rotation)
-    auto model = Matrix3D::gameMatrix::matmul(matrix_a, matrix_b);
+    auto model = gameMatrix::matmul(matrix_a, matrix_b);
 
     // transform for raylib matrix
     float f[16];

gamematrix.h

@@ -0,0 +1,19 @@
+#pragma once
+#include <vector>
+#include <array>
+#include <stdexcept>
+#include <cmath>
+
+class gameMatrix
+{
+public:
+    // Matrix Multiplikation
+    static std::array<std::array<double,4>,4> matmul(const std::array<std::array<double,4>,4>& A,
+                                                   const std::array<std::array<double,4>,4>& B);
+
+    // Rotationsmatrix um Achse x/y/z
+    static std::array<std::array<double,4>,4> rot3D(double angle_deg, char axis);
+
+    // Verschiebung
+    static std::array<std::array<double,4>,4> translate(const std::array<double, 3>& pos);
+};

includes/gamematrix.h

@@ -1,23 +0,0 @@
-#pragma once
-#include <vector>
-#include <array>
-#include <stdexcept>
-#include <cmath>
-
-namespace Matrix3D
-{
-    using Vec3 = std::array<double, 3>;
-    using Vec4 = std::array<double, 4>;
-    using Mat4 = std::array<std::array<double, 4>, 4>;
-
-    class gameMatrix
-    {
-    public:
-        static Mat4 identity();
-        static Mat4 matmul(const Mat4& A, const Mat4& B);
-        static Mat4 translate(const Vec3& pos);
-        static Mat4 rot3D(double angle_deg, char axis);
-    };
-    Mat4 operator*(const Mat4& A, const Mat4& B);
-    Vec3 operator*(const Mat4& m, const Vec3& v);
-}

src/gamematrix.cpp

@@ -1,97 +0,0 @@
-//
-// Created by bakee on 03.11.2025.
-//
-#include "gamematrix.h"
-#include <cmath>
-
-namespace Matrix3D
-{
-    Mat4 gameMatrix::identity()
-    {
-        return {{
-            {1.0, 0.0, 0.0, 0.0},
-            {0.0, 1.0, 0.0, 0.0},
-            {0.0, 0.0, 1.0, 0.0},
-            {0.0, 0.0, 0.0, 1.0}
-        }};
-    }
-
-    Mat4 gameMatrix::matmul(const Mat4& A, const Mat4& B)
-    {
-        const int N = 4;
-        Mat4 result = {};
-        for (int i = 0; i < N; ++i)
-        {
-            for (int j = 0; j < N; ++j)
-            {
-                for (int k = 0; k < N; ++k)
-                {
-                    result[i][j] += A[i][k] * B[k][j];
-                }
-            }
-        }
-        return result;
-    }
-
-    Mat4 gameMatrix::translate(const Vec3& pos)
-    {
-        Mat4 result = identity();
-
-        result[0][3] = pos[0]; // x
-        result[1][3] = pos[1]; // y
-        result[2][3] = pos[2]; // z
-
-        return result;
-    }
-
-    Mat4 gameMatrix::rot3D(double angle_deg, char axis)
-    {
-        const double angle_rad = angle_deg * M_PI / 180.0;
-
-        Mat4 result = identity();
-
-        const double c = std::cos(angle_rad);
-        const double s = std::sin(angle_rad);
-
-        switch (axis)
-        {
-            case 'x':
-                result[1][1] = c; result[1][2] = -s;
-                result[2][1] = s; result[2][2] = c;
-                break;
-            case 'y':
-                result[0][0] = c; result[0][2] = s;
-                result[2][0] = -s; result[2][2] = c;
-                break;
-            case 'z':
-                result[0][0] = c; result[0][1] = -s;
-                result[1][0] = s; result[1][1] = c;
-                break;
-            default:
-                break;
-        }
-        return result;
-    }
-
-    Mat4 operator*(const Mat4& A, const Mat4& B)
-    {
-        return gameMatrix::matmul(A, B);
-    }
-
-    Vec3 operator*(const Mat4& m, const Vec3& v)
-    {
-        Vec4 v_hom = {v[0], v[1], v[2], 1.0};
-        Vec4 res_hom = {};
-
-        for (int i = 0; i < 4; ++i)
-        {
-            for (int j = 0; j < 4; ++j)
-            {
-                res_hom[i] += m[i][j] * v_hom[j];
-            }
-        }
-
-        return {res_hom[0], res_hom[1], res_hom[2]};
-    }
-
-}