Merge branch 'main' into project_tester

.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

.idea/vcs.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings" defaultProject="true" />
+</project>

.vscode/launch.json

@@ -0,0 +1,10 @@
+{
+    // 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": [
+        
+
+    ]
+}

CMakeLists.txt

@@ -8,71 +8,56 @@ set(CMAKE_CXX_STANDARD 20)
 
 # Set the default build type if not specified
 if(NOT CMAKE_BUILD_TYPE)
-    set(CMAKE_BUILD_TYPE Release CACHE STRING "Build type" FORCE)
+        set(CMAKE_BUILD_TYPE Release CACHE STRING "Build type" FORCE)
 endif()
 
 set(SRC_FILES
-        ${CMAKE_CURRENT_LIST_DIR}/src/main.cpp
+        src/main.cpp
-        ${CMAKE_CURRENT_LIST_DIR}/src/gamecube.cpp
+        src/gamecube.cpp
+        src/gamematrix.cpp
 )
 
 set(INCLUDE_DIRS
         ${CMAKE_CURRENT_LIST_DIR}/includes
-        ${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
 )
-include_directories(${CMAKE_CURRENT_LIST_DIR}/raylib)
-add_executable(${EXECUTABLE_NAME} ${SRC_FILES})
-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/libgamematrix.a
         ${CMAKE_CURRENT_LIST_DIR}/windows/libraylib.a
         opengl32
         gdi32
+        m
         winmm
 )
-target_link_libraries(${EXECUTABLE_NAME} PRIVATE
-        ${CMAKE_CURRENT_LIST_DIR}/mac_x86/libgamematrix.a
-        ${CMAKE_CURRENT_LIST_DIR}/mac_x86/libraylib.a
-)
-target_link_libraries(${EXECUTABLE_NAME} PRIVATE
-        ${CMAKE_CURRENT_LIST_DIR}/mac_arm/libgamematrix.a
-        ${CMAKE_CURRENT_LIST_DIR}/mac_arm/libraylib.a
-)
 
 # Checks if OSX and links appropriate frameworks (Only required on MacOS)
 if (APPLE)
-    target_link_libraries(Prog3B "-framework IOKit")
+        target_link_libraries(Prog3B "-framework IOKit")
-    target_link_libraries(Prog3B "-framework Cocoa")
+        target_link_libraries(Prog3B "-framework Cocoa")
-    target_link_libraries(Prog3B "-framework OpenGL")
+        target_link_libraries(Prog3B "-framework OpenGL")
 endif()
 
 add_executable(tests
-        src/tests.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/src/tests.cpp
-        ${CMAKE_CURRENT_LIST_DIR}/src/gamecube.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/src/gamematrix.cpp
 )
 target_include_directories(tests PRIVATE ${INCLUDE_DIRS})
 
 target_link_libraries(tests PRIVATE
-        ${CMAKE_CURRENT_LIST_DIR}/windows/libgamematrix.a
-        ${CMAKE_CURRENT_LIST_DIR}/windows/libraylib.a
         opengl32
         gdi32
         winmm
 )
-target_link_libraries(tests PRIVATE
-        ${CMAKE_CURRENT_LIST_DIR}/mac_x86/libgamematrix.a
-        ${CMAKE_CURRENT_LIST_DIR}/mac_x86/libraylib.a
-)
-target_link_libraries(tests PRIVATE
-        ${CMAKE_CURRENT_LIST_DIR}/mac_arm/libgamematrix.a
-        ${CMAKE_CURRENT_LIST_DIR}/mac_arm/libraylib.a
-)
 
 if (APPLE)
-    target_link_libraries(Prog3B PRIVATE "-framework IOKit")
+        target_link_libraries(Prog3B PRIVATE "-framework IOKit")
-    target_link_libraries(Prog3B PRIVATE "-framework Cocoa")
+        target_link_libraries(Prog3B PRIVATE "-framework Cocoa")
-    target_link_libraries(Prog3B PRIVATE "-framework OpenGL")
+        target_link_libraries(Prog3B PRIVATE "-framework OpenGL")
 endif()
 
-

docs/requirements.txt

@@ -0,0 +1,20 @@
+Projekt: .wuerfelmemory
+Datum: 03.11.2025
+
+
+Team(Rollen):Projektleiter: Alina.B
+            Architekt:     Alex.S
+            Entwickler:    Tomila.B
+            Tester:        Elisa.S
+
+1.Projektziel:
+
+| Funktion      | Eingabe                            | Ausgabe               | Kurzbeschreibung                       |
+|---------------|------------------------------------|-----------------------|----------------------------------------|
+| matmul        | 4x4 Matrix A, 4x4 Matrix B         | 4x4 Matrix            |                                        |
+| translate     | 3D Vektor                          | 4x4 Matrix            |                                        |
+| rot3D         | Winkel in °, Rotationsachse (x/y/z)| 4x4 Matrix            |                                        |
+
+
+Dokumentation:
+

gamematrix.h

@@ -1,19 +0,0 @@
-#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

@@ -0,0 +1,23 @@
+#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/gamecube.cpp

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

src/gamematrix.cpp

@@ -0,0 +1,97 @@
+//
+// 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]};
+    }
+
+}

src/tests.cpp

@@ -31,7 +31,7 @@ Vec3 applyMatrix(const Matrix4& M, const Vec3& v) {
 void testMatmulIdentity() {
     Matrix4 A = identity();
     Matrix4 B = identity();
-    Matrix4 C = gameMatrix::matmul(A, B);
+    Matrix4 C = Matrix3D::gameMatrix::matmul(A, B);
 
     for (int i = 0; i < 4; i++) {
         for (int j = 0; j < 4; j++) {
@@ -48,7 +48,7 @@ void testMatmulIdentity() {
 
 void testTranslate() {
     Vec3 pos{1,2,3};
-    Matrix4 T = gameMatrix::translate(pos);
+    Matrix4 T = Matrix3D::gameMatrix::translate(pos);
 
     if (eq(T[0][3], 1) && eq(T[1][3], 2) && eq(T[2][3], 3))
         std::cout << "[OK] translate\n";
@@ -58,7 +58,7 @@ void testTranslate() {
 
 void testRotZ90() {
     Vec3 v{1,0,0};
-    Matrix4 R = gameMatrix::rot3D(90, 'z');
+    Matrix4 R = Matrix3D::gameMatrix::rot3D(90, 'z');
     Vec3 r = applyMatrix(R, v);
 
     if (eq(r[0], 0) && eq(r[1], 1) && eq(r[2], 0))
@@ -69,7 +69,7 @@ void testRotZ90() {
 
 void testRotX180() {
     Vec3 v{0,1,0};
-    Matrix4 R = gameMatrix::rot3D(180, 'x');
+    Matrix4 R = Matrix3D::gameMatrix::rot3D(180, 'x');
     Vec3 r = applyMatrix(R, v);
 
     if (eq(r[0], 0) && eq(r[1], -1) && eq(r[2], 0))
@@ -80,10 +80,10 @@ void testRotX180() {
 
 void testRotY270() {
     Vec3 v{1,0,0};
-    Matrix4 R = gameMatrix::rot3D(270, 'y');
+    Matrix4 R = Matrix3D::gameMatrix::rot3D(270, 'y');
     Vec3 r = applyMatrix(R, v);
 
-    if (eq(r[0], 0) && eq(r[1], 0) && eq(r[2], -1))
+    if (eq(r[0], 0) && eq(r[1], 0) && eq(r[2], 1))
         std::cout << "[OK] rotY 270°\n";
     else
         std::cout << "[FAIL] rotY 270°\n";