Alles was nun folgt spielt sich innerhalb der Szene ab. Da wir mit dynamischer Speicherzuweisung arbeiten benötigen wir Funktionen aus der <stdlib.h> die wir oben in der scene.c einbinden müssen.

#include <stdlib.h>

Anschließend definieren wir das THM Rot mit unserem neuen Datentyp color. Und wir erstellen eine Variable in der wir eine rote Kugel speichern wollen.

static const color thmRed = {0.61f, 0.07f, 0.18f, 1.0f};

static mesh redSphere;

Und dann benötigen wir noch die nötige Funktion, die die Vertices dieser Kugel berechnet, den Speicherbereich zuweist und die Kugel erzeugt.

static mesh createSphereMesh(color col)
{
    const int segments = 64;
    const int rings = segments / 2;
    
    int vcount = segments * rings * 4;
    vertex* vertices = (vertex *)calloc(vcount, sizeof(vertex));

    vector3 **vectors = (vector3 **)calloc(segments+1, sizeof(vector3 *));
    for (int i = 0; i <= segments; i++)
    {
        vectors[i] = (vector3 *)calloc(rings+1, sizeof(vector3));
    }
    
    for (int y = 0; y <= rings; y++)
    {
        float deg = 180.0f / rings * (y - rings * 0.5f);
        matrix rotationMatrixX = matrixRotateX(deg2rad(deg));
        vector3 startVector = matrixVector3Multiply(rotationMatrixX, (vector3){0,0,1});
        vectors[0][y] = startVector;
        vectors[segments][y] = startVector;
        for (int x = 1; x < segments; x++)
        {
            float deg2 = 360.0f / (float)segments * (float)x;
            matrix rotationMatrixY = matrixRotateY(deg2rad(deg2));
            vectors[x][y] = matrixVector3Multiply(rotationMatrixY, vectors[0][y]);
        }
    }
    int i = 0;
    for (int y = 0; y < rings; y++)
    {
        for (int x = 0; x < segments; x++)
        {
            vertices[i++] = (vertex){ vectors[ x ][y+1], col };
            vertices[i++] = (vertex){ vectors[x+1][y+1], col };
            vertices[i++] = (vertex){ vectors[x+1][ y ], col };
            vertices[i++] = (vertex){ vectors[ x ][ y ], col };
        }
    }
    for (int i = 0; i <= segments; i++)
    {
        free(vectors[i]);
    }
    free(vectors);
    return (mesh){
        vcount: vcount,
        vertices: vertices
    };
}

Mesh laden, rendern und entladen

Innerhalb der Funktion loadScene können wir nun unseren Würfel laden:

redSpehere = createSphereMesh(thmRed);

In der renderScene können wir ihn rendern:

renderMesh(redSphere, matrixTranslate(0,2,0));

Und in der unloadScene müssen wir den Speicher wieder freigeben:

free(redSphere.vertices);