Architekt: Design-Spez. erstellt

docs/design.txt

@@ -0,0 +1,74 @@
+========================================================
+Projekt: gamematrix (C++ Library)
+Rolle: Architekt
+Datei: design.txt
+Datum: 03.11.2025
+Team: prog3b_652
+========================================================
+
+# ----------------------------
+# 1. Projektstruktur / Namespace
+# ----------------------------
+Namespace: Matrix3D
+
+Ziel: Saubere Trennung der Bibliothek, Vermeidung von Namenskonflikten.
+
+Beispiel:
+namespace Matrix3D {
+    // Funktionen, ggf Klasse(n)
+}
+
+# ----------------------------
+# 2. Datenstrukturen / Klassen
+# ----------------------------
+Listen Sie die Klassen oder Structs auf, die verwendet werden:
+
+| Name   | Typ                                      | Beschreibung         |
+|--------|------------------------------------------|----------------------|
+| Vec3   | struct Vec3                              | 3D-Vektor (x, y, z)  |
+| Mat4   | std::array<std::array<double,4>,4>       | 4x4-Matrix (homogen) |
+| Vec4   | struct Vec4                              | 4D-Vektor (x, y, z, w|
+| Vec2   | struct Vec2                              | 2D-Vektor (x, y)     |
+
+# ----------------------------
+# 3. Operatoren / Templates
+# ----------------------------
+Welche Operatoren oder Templates sollen definiert werden?
+
+- Templates für unterschiedliche Datentypen? - Ja
+- Operatoren:
+    - Mat4 * Mat4
+    - Mat4 * Vec3
+
+# ----------------------------
+# 4. Funktionen / Schnittstellen
+# ----------------------------
+Liste der Funktionen mit Eingabe/Ausgabe und kurzer Beschreibung:
+
+| Funktion      | Eingabe                            | Ausgabe               | Kurzbeschreibung                       |
+|---------------|------------------------------------|-----------------------|----------------------------------------|
+| matmul        | Mat4 A, Mat4 B                     | Mat4                  | Matrixmultiplikation 4x4               |
+| translate     | Vec3 pos                           | Mat4                  | Verschiebungstransformation            |
+| rot3D         | double angle_deg, char axis        | Mat4                  | Rotation um Achse x/y/z                |
+| identity (optional)| ---                           | Mat4                  | Identitätsmatrix                       |
+| _____________ | __________________________________ | ____________________  | ______________________________         |
+
+# ----------------------------
+# 5. Designentscheidungen / Hinweise
+# ----------------------------
+- Rückgabe der Matrizen per Wert oder Referenz? per Wert
+- Verwendung von std::array oder std::vector? std::array
+- Homogene Koordinaten für Translation / Rotation (4x4)? - Ja
+- Weitere Designüberlegungen: Nutzung von Templates für float/double
+
+# ----------------------------
+# 6. Deliverables / Milestones
+# ----------------------------
+- design.txt fertig und im Branch architect committed
+- Übergabe an Entwickler für Implementierung
+
+========================================================
+Hinweis:
+- Dieses Dokument dient als Grundlage für die Implementierung.
+- Alle Designentscheidungen sollen klar nachvollziehbar sein.
+========================================================

docs/tests.txt

@@ -1,44 +0,0 @@
-@@ -1,43 +0,0 @@
-========================================================
-Projekt: gamematrix (C++ Library)
-Rolle: Tester
-Datei: tests.txt
-Datum: 4.10.2025
-Team: prog3b_652
-========================================================
-
-# ----------------------------
-# 1. Testplan Übersicht
-# ----------------------------
-Ziel: Überprüfung der Funktionen matmul(), translate(), rot3D().
-
-| Funktion      | Testfall                  | Eingabe                      | Erwartetes Ergebnis               | Bemerkung                  |
-|---------------|---------------------------|------------------------------|-----------------------------------|----------------------------|
-| matmul        | Identity * Identity       | 4x4 Identity Matrizen        | Identity                          | Basisfall                  |
-| matmul        | Beispielmatrizen          | A=[[...]], B=[[...]]         | C=[[...]]                         | Prüfen mit Handrechnung    |
-| translate     | Verschiebung              | Vec3 {1,2,3}                 | Matrix mit Translation 1,2,3      | Prüfen letzte Spalte       |
-| rot3D         | Rotation Z 90°            | angle_deg=90, axis='z'       | (1,0,0) -> (0,1,0)                | Prüfen Anwendung auf Vektor|
-| rot3D         | Rotation X 180°           | angle_deg=180, axis='x'      | (0,1,0) -> (0,-1,0)               | Prüfen Anwendung auf Vektor|
-| rot3D         | Rotation Y 270°           | angle_deg=270, axis='y'      | (1,0,0) -> (0,0,-1)               | Prüfen Anwendung auf Vektor|
-
-
-# ----------------------------
-# 2. Testdaten / Matrizen
-# ----------------------------
-- Matrizen für matmul: Identity, Beispiel A/B Matrizen
-- Vektoren für translate: Vec3 {x, y, z}
-- Vektoren für rot3D: Vec3 {1,0,0}, Vec3 {0,1,0}
-
-# ----------------------------
-# 3. Abnahmekriterien
-# ----------------------------
-- Alle Unit-Tests erfolgreich
-- Keine Exceptions außer gewollt (z. B. ungültige Achse)
-- Testbericht in tests.txt dokumentiert
-
-========================================================
-Hinweis:
-- Diese Datei wird vom Tester gepflegt.
-- Tester dokumentiert Input, Output, erwartetes Ergebnis und Erfolg/Fehler.
-========================================================
-

includes/gamematrix.cpp

@@ -1,150 +0,0 @@
-//
-// Created by kris- on 03.11.2025.
-//
-#include <iostream>
-#include "gamematrix.h"
-
-// Matrixmultiplikation
-
-
-// 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);
-
-
-
-
-//Matrixmultiplikation-Funktion
-std::array<std::array<double,4>,4> gameMatrix::matmul(
-    const std::array<std::array<double,4>,4>& A,
-    const std::array<std::array<double,4>,4>& B)
-
-{       //Matrix-Mathematik (Matrix C = A*B)
-    std::array<std::array<double,4>,4> C{};
-
-    for (int i = 0; i < 4; ++i)
-        for (int j = 0; j < 4; ++j)
-            for (int k = 0; k < 4; ++k)
-                C[i][j] += A[i][k] * B[k][j];
-
-
-    return C;
-
-}
-
-//Rotation 3D
-std::array<std::array<double,4>,4> gameMatrix::rot3D(double angle_deg, char axis) {
-    double rad = angle_deg * M_PI / 180.0;
-
-    //Mathematik-Rotation
-    std::array<std::array<double,4>,4> R{};
-
-    for (int i = 0; i < 4; ++i)
-        R[i][i] = 1.0;
-
-    if (axis == 'x' || axis == 'X') {
-        R[1][1] = cos(rad);
-        R[1][2] = -sin(rad);
-        R[2][1] = sin(rad);
-        R[2][2] = cos(rad);
-    } else if (axis == 'y' || axis == 'Y') {
-        R[0][0] = cos(rad);
-        R[0][2] = sin(rad);
-        R[2][0] = -sin(rad);
-        R[2][2] = cos(rad);
-    } else if (axis == 'z' || axis == 'Z') {
-        R[0][0] = cos(rad);
-        R[0][1] = -sin(rad);
-        R[1][0] = sin(rad);
-        R[1][1] = cos(rad);
-    }
-
-    return R;
-}
-
-//Translation
-std::array<std::array<double,4>,4> gameMatrix::translate(const std::array<double,3>& pos) {
-    std::array<std::array<double,4>,4> T{};
-    for (int i = 0; i < 4; ++i)
-        T[i][i] = 1.0; // Identitätsmatrix
-
-    T[0][3] = pos[0]; // x-Verschiebung
-    T[1][3] = pos[1]; // y-Verschiebung
-    T[2][3] = pos[2]; // z-Verschiebung
-
-    return T;
-}
-
-
-
-
-int main()
-{
-    // Part Matrix
-    std::array<std::array<double,4>,4> A{};
-    std::array<std::array<double,4>,4> B{};
-
-    std::cout << "Gib die Werte für Matrix A (4x4) ein:\n";
-    for (int i = 0; i < 4; ++i)
-        for (int j = 0; j < 4; ++j) {
-            std::cout << "A[" << i << "][" << j << "] = ";
-            std::cin >> A[i][j];
-        }
-
-    std::cout << "\nGib die Werte für Matrix B (4x4) ein:\n";
-    for (int i = 0; i < 4; ++i)
-        for (int j = 0; j < 4; ++j) {
-            std::cout << "B[" << i << "][" << j << "] = ";
-            std::cin >> B[i][j];
-        }
-
-    std::array<std::array<double,4>,4> C = gameMatrix::matmul(A, B);
-
-    std::cout << "\nErgebnis der Matrixmultiplikation (C = A * B):\n";
-    for (int i = 0; i < 4; ++i) {
-        for (int j = 0; j < 4; ++j)
-            std::cout << C[i][j] << "\t";
-        std::cout << "\n";
-    }
-    //Ende Matrix
-
-
-    // Rotation
-    double angle;
-    char axis;
-    std::cout << "\nGib einen Rotationswinkel in Grad ein: ";
-    std::cin >> angle;
-    std::cout << "Gib die Rotationsachse (x/y/z) ein: ";
-    std::cin >> axis;
-
-    std::array<std::array<double,4>,4> R = gameMatrix::rot3D(angle, axis);
-
-    std::cout << "\nRotationsmatrix R:\n";
-    for (int i = 0; i < 4; ++i) {
-        for (int j = 0; j < 4; ++j)
-            std::cout << R[i][j] << "\t";
-        std::cout << "\n";
-    }
-
-    // Translation
-    std::array<double,3> pos;
-    std::cout << "\nGib die Translation (x y z) ein: ";
-    std::cin >> pos[0] >> pos[1] >> pos[2];
-
-    std::array<std::array<double,4>,4> T = gameMatrix::translate(pos);
-
-    std::cout << "\nTranslationsmatrix T:\n";
-    for (int i = 0; i < 4; ++i) {
-        for (int j = 0; j < 4; ++j)
-            std::cout << T[i][j] << "\t";
-        std::cout << "\n";
-    }
-
-    return 0;
-}
-
-
-
-

src/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);
-};

src/tests.cpp

@@ -1,41 +0,0 @@
-#include <iostream>
-#include <array>
-#include <cassert>
-#include <cmath>
-#include "gamematrix.h"
-
-// Matrix-Vektor Multiplikation (4x4 Matrix auf 4D Vektor anwenden)
-std::array<double, 4> matVecMul(const std::array<std::array<double, 4>, 4>& mat, const std::array<double, 4>& vec) {
-    std::array<double, 4> result = {0, 0, 0, 0};
-    for (size_t i = 0; i < 4; ++i) {
-        for (size_t j = 0; j < 4; ++j) {
-            result[i] += mat[i][j] * vec[j];
-        }
-    }
-    return result;
-}
-
-void test_rotateZ() {
-    std::array<double, 4> v = {1, 0, 0, 1};  // Der Vektor (1, 0, 0) wird zu (1, 0, 0, 1)
-
-    // Rotationsmatrix um 90° um die Z-Achse
-    auto R = gameMatrix::rot3D(90, 'Z');
-
-    // Vektor mit der Matrix multiplizieren
-    std::array<double, 4> result = matVecMul(R, v);
-
-    // Erwartetes Ergebnis
-    std::array<double, 4> expected_result = {0, 1, 0, 1};
-
-    // Vergleich der Ergebnisse
-    for (size_t i = 0; i < 4; ++i) {
-        assert(std::abs(result[i] - expected_result[i]) < 1e-6);
-    }
-
-    std::cout << "Test erfolgreich! Rotation um Z-Achse funktioniert." << std::endl;
-}
-
-int main() {
-    test_rotateZ();
-    return 0;
-}