Merge remote-tracking branch 'origin/main'

# Conflicts:
#	CMakeLists.txt

CMakeLists.txt

@@ -19,7 +19,6 @@ set(SRC_FILES
         ${CMAKE_CURRENT_LIST_DIR}/src/main.cpp
         ${CMAKE_CURRENT_LIST_DIR}/src/gamecube.cpp
         src/gamematrix.cpp
-        docs/tests.cpp
 )
 
 ##Tom: prev: ${CMAKE_CURRENT_LIST_DIR}/linux -> now /include

includes/gamecube.h

@@ -2,6 +2,9 @@
 #include "gamematrix.h"
 #include "raylib.h"
 #include <rlgl.h>
+#include <array>
+
+using Mat4 = std::array<std::array<double, 4>, 4>;
 
 struct Vec3
 {

includes/gamematrix.h

@@ -3,6 +3,7 @@
 #include <array>
 #include <stdexcept>
 #include <cmath>
+#include "gamecube.h"
 
 class gameMatrix
 {

src/gamecube.cpp

@@ -1,70 +1,70 @@
-#include "gamecube.h"
+    #include "gamecube.h"
 
-gamecube::gamecube(const Vec3 &pos, Color col)
+    gamecube::gamecube(const Vec3 &pos, Color col)
-    : position(pos), color(col) {}
+        : position(pos), color(col) {}
 
-void gamecube::Update(float flipSpeed)
+    void gamecube::Update(float flipSpeed)
-{
-    //Tom: Added vars for clarity; replaced old 180.0f, 0.0f
-    const float MaxRotationAngle = 180.0f;
-    const float NoRotationAngle = 0.0f;
-
-    if (flippingForward)
     {
-        rotation += flipSpeed;
+        //Tom: Added vars for clarity; replaced old 180.0f, 0.0f
-        if (rotation >= MaxRotationAngle)
+        const float MaxRotationAngle = 180.0f;
+        const float NoRotationAngle = 0.0f;
+
+        if (flippingForward)
         {
-            rotation = MaxRotationAngle;
+            rotation += flipSpeed;
-            flippingForward = false;
+            if (rotation >= MaxRotationAngle)
-            flipped = true;
+            {
+                rotation = MaxRotationAngle;
+                flippingForward = false;
+                flipped = true;
+            }
+        }
+        else if (flippingBackward)
+        {
+            rotation -= flipSpeed;
+            if (rotation <= NoRotationAngle)
+            {
+                rotation = NoRotationAngle;
+                flippingBackward = false;
+                flipped = false;
+            }
         }
     }
-    else if (flippingBackward)
+
+    void gamecube::FlipForward()   { flippingForward = true; }
+    void gamecube::FlipBackward()  { flippingBackward = true; }
+
+    bool gamecube::IsFlipped() const { return flipped; }
+    bool gamecube::IsMatched() const { return matched; }
+    void gamecube::SetMatched(bool m) { matched = m; }
+
+    void gamecube::Draw() const
     {
-        rotation -= flipSpeed;
+        rlPushMatrix();
-        if (rotation <= NoRotationAngle)
+
-        {
+        // Matrizen für Rotation und Translation erzeugen
-            rotation = NoRotationAngle;
+        auto matrix_a = gameMatrix::translate({ position.x, position.y, position.z});
-            flippingBackward = false;
+        auto matrix_b = gameMatrix::rot3D(rotation, 'y');
-            flipped = false;
+
-        }
+        // Matrizen multiplizieren (Translation * Rotation)
+        auto model = gameMatrix::matmul(matrix_a, matrix_b);
+
+        // transform for raylib matrix
+        float f[16];
+        for (int i = 0; i < 4; i++)
+            for (int j = 0; j < 4; j++)
+                f[j * 4 + i] = model[i][j];
+        rlMultMatrixf(f);
+
+        if (rotation < 90.0f)
+            DrawCube({0,0,0}, 1,1,1, GRAY);
+        else
+            DrawCube({0,0,0}, 1,1,1, color);
+
+        DrawCubeWires({0,0,0}, 1,1,1, BLACK);
+
+        rlPopMatrix();
     }
-}
 
-void gamecube::FlipForward()   { flippingForward = true; }
+    Vec3 gamecube::GetPosition() const     { return position; }
-void gamecube::FlipBackward()  { flippingBackward = true; }
+    float gamecube::GetRotationY() const   { return rotation; }
-
-bool gamecube::IsFlipped() const { return flipped; }
-bool gamecube::IsMatched() const { return matched; }
-void gamecube::SetMatched(bool m) { matched = m; }
-
-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_b = gameMatrix::rot3D(rotation, 'y');
-
-    // Matrizen multiplizieren (Translation * Rotation)
-    auto model = gameMatrix::matmul(matrix_a, matrix_b);
-
-    // transform for raylib matrix
-    float f[16];
-    for (int i = 0; i < 4; i++)
-        for (int j = 0; j < 4; j++)
-            f[j * 4 + i] = model[i][j];
-    rlMultMatrixf(f);
-
-    if (rotation < 90.0f)
-        DrawCube({0,0,0}, 1,1,1, GRAY);
-    else
-        DrawCube({0,0,0}, 1,1,1, color);
-
-    DrawCubeWires({0,0,0}, 1,1,1, BLACK);
-
-    rlPopMatrix();
-}
-
-Vec3 gamecube::GetPosition() const     { return position; }
-float gamecube::GetRotationY() const   { return rotation; }

src/gamematrix.cpp

@@ -1,76 +1,75 @@
 #include "gamematrix.h"
 #include <cmath>
 
-namespace Matrix3D {
+// Entfernt: namespace Matrix3D { ... }   <-- GEÄNDERT
 
-    Mat4 identity() {
+// Implementierungen jetzt als Klassenmethoden von gameMatrix   <-- GEÄNDERT
-        Mat4 m{};
+
-        for(int i = 0; i < 4; i++) {
+// Optional: identity() als Hilfsmethode hinzugefügt
-            for(int j = 0; j < 4; j++) {
+static std::array<std::array<double,4>,4> identity() {   // <-- NEU
-                m[i][j] = (i == j) ? 1.0 : 0.0;
+    std::array<std::array<double,4>,4> m{};
-            }
+    for(int i = 0; i < 4; i++) {
+        for(int j = 0; j < 4; j++) {
+            m[i][j] = (i == j) ? 1.0 : 0.0;
         }
-        return m;
     }
+    return m;
+}
 
-    Mat4 matmul(const Mat4& A, const Mat4& B) {
+// -------------------- matmul --------------------
-        Mat4 R{};
+std::array<std::array<double,4>,4> gameMatrix::matmul(    // <-- GEÄNDERT
-        for(int i = 0; i < 4; i++) {
+    const std::array<std::array<double,4>,4>& A,
-            for(int j = 0; j < 4; j++) {
+    const std::array<std::array<double,4>,4>& B)
-                double sum = 0.0;
+{
-                for(int k = 0; k < 4; k++) {
+    std::array<std::array<double,4>,4> R{};
-                    sum += A[i][k] * B[k][j];
+    for(int i = 0; i < 4; i++) {
-                }
+        for(int j = 0; j < 4; j++) {
-                R[i][j] = sum;
+            double sum = 0.0;
+            for(int k = 0; k < 4; k++) {
+                sum += A[i][k] * B[k][j];
             }
+            R[i][j] = sum;
         }
-        return R;
     }
+    return R;
+}
 
-    Mat4 translate(const Vec3& pos) {
+// -------------------- translate --------------------
-        Mat4 t = identity();
+std::array<std::array<double,4>,4> gameMatrix::translate( // <-- GEÄNDERT
-        t[0][3] = pos.x;
+    const std::array<double,3>& pos)
-        t[1][3] = pos.y;
+{
-        t[2][3] = pos.z;
+    auto t = identity();   // <-- NEU: nutzt die Hilfsmethode
-        return t;
+    t[0][3] = pos[0];
-    }
+    t[1][3] = pos[1];
+    t[2][3] = pos[2];
+    return t;
+}
 
-    Mat4 rot3D(double angle_deg, char axis) {
+// -------------------- rot3D --------------------
-        Mat4 r = identity();
+std::array<std::array<double,4>,4> gameMatrix::rot3D(     // <-- GEÄNDERT
+    double angle_deg, char axis)
+{
+    auto r = identity();   // <-- NEU: nutzt die Hilfsmethode
 
-        double rad = angle_deg * M_PI / 180.0;
+    double rad = angle_deg * M_PI / 180.0;
-        double c = std::cos(rad);
+    double c = std::cos(rad);
-        double s = std::sin(rad);
+    double s = std::sin(rad);
 
-        switch(axis) {
+    switch(axis) {
-            case 'x': case 'X':
+        case 'x': case 'X':
-                r[1][1] = c;  r[1][2] = -s;
+            r[1][1] = c;  r[1][2] = -s;
             r[2][1] = s;  r[2][2] =  c;
             break;
 
-            case 'y': case 'Y':
+        case 'y': case 'Y':
-                r[0][0] =  c; r[0][2] = s;
+            r[0][0] =  c; r[0][2] = s;
             r[2][0] = -s; r[2][2] = c;
             break;
 
-            case 'z': case 'Z':
+        case 'z': case 'Z':
-                r[0][0] = c;  r[0][1] = -s;
+            r[0][0] = c;  r[0][1] = -s;
             r[1][0] = s;  r[1][1] =  c;
             break;
-        }
-        return r;
     }
-
+    return r;
-    Vec3 operator*(const Mat4& M, const Vec3& v) {
-        Vec3 out;
-        out.x = M[0][0]*v.x + M[0][1]*v.y + M[0][2]*v.z + M[0][3];
-        out.y = M[1][0]*v.x + M[1][1]*v.y + M[1][2]*v.z + M[1][3];
-        out.z = M[2][0]*v.x + M[2][1]*v.y + M[2][2]*v.z + M[2][3];
-        return out;
-    }
-
-    Mat4 operator*(const Mat4& A, const Mat4& B) {
-        return matmul(A, B);
-    }
-
 }