Erste Erfahrungen mit AmigaOS-Programmierung

[Sen]

Benötigt war nur eine Vektor-Mathe-Bibilothek, daraus die Funktionen, sind nur 2 Dateien mehr zu kompilieren.
In den globalen Variablen ist ein konstantes DOUBLE-Array mit Würfel-Eckpunkten hinterlegt. (12[Linien]*2[Punkte]*3[Koordinaten])

Im Render-Struct:

Code:

    mfloat_t position[VEC3_SIZE]; // Kameraposition
    mfloat_t target[VEC3_SIZE]; // Kameraziel
    mfloat_t up[VEC3_SIZE];  // Kamera-Up(gibt an an welcher Achse es hoch geht)
    mfloat_t view[MAT4_SIZE];  // Kameramatrix für die Sichtrichtung
    mfloat_t perspective[MAT4_SIZE];  // Kameramatrix für die Perspektive
    mfloat_t rotation[MAT4_SIZE]; // Matrix für Rotation des Würfels
    mfloat_t raxis[VEC3_SIZE]; // Rotationsachse
    mfloat_t scale[MAT4_SIZE]; // Matrix zum verkleinern des Würfels
    mfloat_t scalar[VEC3_SIZE]; // Skalierfaktor
    mfloat_t transform[MAT4_SIZE]; // Transformationsmatrix aus Sicht und Perspektive
    mfloat_t model[MAT4_SIZE]; // Modellmatrix aus Rotation und Skalierung
    mfloat_t total[MAT4_SIZE]; // Hauptmatrix aus Transformation und Modell
    mfloat_t vertexA[VEC4_SIZE]; // Erster Vertex der Linie
    mfloat_t vertexB[VEC4_SIZE]; // Zweiter

Im Render-Init (1x berechnet):

Code:

mat4_look_at(rd->view,vec3(rd->position, 0.0, 0.0, -10.0),vec3(rd->target, 0.0, 0.0, 0.0),vec3(rd->up, 0.0, 1.0, 0.0)); // Berechnung der Sichtmatrix
        mat4_perspective(rd->perspective, to_radians(70.0), 320.0/200.0, 0.1, 20.0); // Perspektive
        mat4_identity(rd->scale); // Skalierung auf 1
        mat4_scaling(rd->scale,rd->scale,vec3(rd->scalar,0.25,0.25,0.25)); // Skalierungsmatrix
        mat4_identity(rd->rotation); // Rotation auf 1
        mat4_rotation_axis(rd->rotation,vec3(rd->raxis,0.5,0.1,0.2),to_radians(0.0)); // Rotationsmatrix
        mat4_multiply(rd->transform, rd->perspective, rd->view); // Transformationsmatrix == Sicht * Perspektive

Im Render-Loop:

Code:

SetRast(renderTarget,BLACK); // Bildschirm schwarz

        mat4_identity(rd->rotation); // Rotation auf 1
        mat4_rotation_axis(rd->rotation,vec3(rd->raxis,0.5,0.1,0.2),to_radians(currentStep * 360.0)); // Rotation entlang der Achse um SEKUNDEN/16*360
        // currentStep sind die vergangenen Sekunden seit dem letzten Rendervorgang (höchstens 1.0)
        mat4_multiply(rd->model, rd->scale, rd->rotation); // Modell = Skalierung * Rotation
        mat4_multiply(rd->total, rd->transform, rd->model); // Haupt = Transformation * Modell

        SetAPen(renderTarget,WHITE); // Weiss zeichnen
        for(int i = 0;i < CUBE_LINES;i++) { // 12 Linien rendern
            for(int d = 0;d < 3;d++) { // Kopieren der Punkte in die Vertexe
                rd->vertexA[d] = cubePoints[i*6+d];
                rd->vertexB[d] = cubePoints[i*6+d+3];
            }
            rd->vertexA[3] = 1.0; // W muss 1 sein
            rd->vertexB[3] = 1.0;

            vec4_multiply_mat4(rd->vertexA,rd->vertexA,rd->total); // Multiplikation Matrix mit Punkten -> neue Koordinaten
            vec4_multiply_mat4(rd->vertexB,rd->vertexB,rd->total);
            

            WORD xA = ((WORD)(((rd->vertexA[0] + 1.0) / 2.0) * 320.0)); // Koordinaten -1.0...1.0 -> Pixelkoordinaten (Y umgedreht)
            WORD yA = ((WORD)(((rd->vertexA[1] + 1.0) / 2.0) * 200.0));
            WORD xB = ((WORD)(((rd->vertexB[0] + 1.0) / 2.0) * 320.0));
            WORD yB = ((WORD)(((rd->vertexB[1] + 1.0) / 2.0) * 200.0));
            if(rd->vertexA[2] < 0.0 || rd->vertexB[2] < 0.0) { // Baufaellig: Prüfen ob Koordinaten (oben Z, unten X und Y) im Bereich liegen (noch nicht benötigt)
                continue;
            }
            if((xA >= 320 || xB >= 320) || (yA >= 200 || yB >= 200) || (xA < 0 || xB < 0) || (yA < 0 || yB < 0)) {
                continue;
            }
            Move(renderTarget,(LONG)xA,(LONG)yA); // Gehe zu Punkt A
            Draw(renderTarget,(LONG)xB,(LONG)yB); // Zeichne bis Punkt B
        }

Naja, OpenGL ist da besser, da es die GraKa nutzt, aber der A500 hat keine, und auch keine FPU, so sind die Fließkommazahlen lahm.
PS: läuft mit diesem Code jetzt 2 FPS schneller (vorher Alles im Loop berechnet)!