"progress"

archive/src/display/mesh/CMakeLists.txt

@@ -0,0 +1,11 @@
+# Copyright (c) 2025 Dominic Masters
+#
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+# Sources
+target_sources(${DUSK_LIBRARY_TARGET_NAME}
+  PUBLIC
+    mesh.c
+    quad.c
+)

archive/src/display/mesh/mesh.c

@@ -0,0 +1,104 @@
+/**
+ * Copyright (c) 2025 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "mesh.h"
+#include "util/memory.h"
+#include "assert/assert.h"
+
+#if DOLPHIN
+  #include "display/texture.h"
+#endif
+
+void meshInit(
+  mesh_t *mesh,
+  const meshprimitivetype_t primitiveType,
+  const int32_t vertexCount,
+  const meshvertex_t *vertices
+) {
+  assertNotNull(mesh, "Mesh cannot be NULL");
+  assertNotNull(vertices, "Vertices cannot be NULL");
+  assertTrue(vertexCount > 0, "Vertex count must be greater than 0");
+
+  memoryZero(mesh, sizeof(mesh_t));
+  
+  mesh->primitiveType = primitiveType;
+  mesh->vertexCount = vertexCount;
+  mesh->vertices = vertices;
+}
+
+void meshDraw(
+  const mesh_t *mesh,
+  const int32_t vertexOffset,
+  const int32_t vertexCount
+) {
+  const int32_t offset = vertexOffset == -1 ? 0 : vertexOffset;
+  const int32_t count = vertexCount == -1 ? mesh->vertexCount : vertexCount;
+
+  assertNotNull(mesh, "Mesh cannot be NULL");
+  assertTrue(offset >= 0, "Vertex offset must be non-negative");
+  assertTrue(count >= 0, "Vertex count must be non-negative");
+  assertTrue(offset + count <= mesh->vertexCount, 
+    "Vertex offset + count must not exceed vertex count"
+  );
+
+  #if DISPLAY_SDL2
+    // PSP style pointer legacy OpenGL
+    const GLsizei stride = sizeof(meshvertex_t);
+
+    glColorPointer(
+      sizeof(color4b_t),
+      GL_UNSIGNED_BYTE,
+      stride,
+      (const GLvoid*)&mesh->vertices[offset].color
+    );
+    glTexCoordPointer(
+      MESH_VERTEX_UV_SIZE,
+      GL_FLOAT,
+      stride,
+      (const GLvoid*)&mesh->vertices[offset].uv[0]
+    );
+    glVertexPointer(
+      MESH_VERTEX_POS_SIZE,
+      GL_FLOAT,
+      stride,
+      (const GLvoid*)&mesh->vertices[offset].pos[0]
+    );
+    
+    glDrawArrays(
+      mesh->primitiveType,
+      0,
+      count
+    );
+
+  #elif DOLPHIN
+    // Prepare Vertex descriptor
+    DCFlushRange(
+      (void*)&mesh->vertices[offset],
+      sizeof(meshvertex_t) * count
+    );
+
+    const u8 stride = (u8)sizeof(meshvertex_t);
+    GX_SetArray(GX_VA_POS, (void*)&mesh->vertices[offset].pos[0], stride);
+    GX_SetArray(GX_VA_CLR0, (void*)&mesh->vertices[offset].color, stride);
+    GX_SetArray(GX_VA_TEX0, (void*)&mesh->vertices[offset].uv[0], stride);
+    
+    textureDolphinUploadTEV();
+    
+    GX_Begin(mesh->primitiveType, GX_VTXFMT0, (uint16_t)count);
+    for(u16 i = 0; i < (u16)count; ++i) {
+      GX_Position1x16(i);
+      GX_Color1x16(i);
+      GX_TexCoord1x16(i);
+    }
+    GX_End();
+  #endif
+}
+
+void meshDispose(mesh_t *mesh) {
+  assertNotNull(mesh, "Mesh cannot be NULL");
+  memoryZero(mesh, sizeof(mesh_t));
+}

archive/src/display/mesh/mesh.h

@@ -0,0 +1,70 @@
+// Copyright (c) 2025 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "display/display.h"
+#include "display/color.h"
+
+typedef enum {
+  #if DISPLAY_SDL2
+    MESH_PRIMITIVE_TRIANGLES = GL_TRIANGLES,
+    MESH_PRIMITIVE_LINES = GL_LINES,
+    MESH_PRIMITIVE_POINTS = GL_POINTS,
+  #elif DOLPHIN
+    MESH_PRIMITIVE_TRIANGLES = GX_TRIANGLES,
+    MESH_PRIMITIVE_LINES = GX_LINES,
+    MESH_PRIMITIVE_POINTS = GX_POINTS,
+  #endif
+} meshprimitivetype_t;
+
+#define MESH_VERTEX_UV_SIZE 2
+#define MESH_VERTEX_POS_SIZE 3
+
+typedef struct {
+  color_t color;
+  float_t uv[MESH_VERTEX_UV_SIZE];
+  float_t pos[MESH_VERTEX_POS_SIZE];
+} meshvertex_t;
+
+typedef struct {
+  const meshvertex_t *vertices;
+  int32_t vertexCount;
+  meshprimitivetype_t primitiveType;
+} mesh_t;
+
+/**
+ * Initializes a mesh.
+ * 
+ * @param mesh The mesh to initialize.
+ * @param primitiveType The OpenGL primitive type (e.g., GL_TRIANGLES).
+ * @param vertexCount The number of vertices in the mesh.
+ * @param vertices The vertex data for the mesh.
+ */
+void meshInit(
+  mesh_t *mesh,
+  const meshprimitivetype_t primitiveType,
+  const int32_t vertexCount,
+  const meshvertex_t *vertices
+);
+
+/**
+ * Draws a mesh.
+ * 
+ * @param mesh The mesh to draw.
+ * @param vertexOffset The offset in the vertex array to start drawing from.
+ * @param vertexCount The number of vertices to draw. If -1, draws all vertices.
+ */
+void meshDraw(
+  const mesh_t *mesh,
+  const int32_t vertexOffset,
+  const int32_t vertexCount
+);
+
+/**
+ * Disposes a mesh.
+ * 
+ * @param mesh The mesh to dispose.
+ */
+void meshDispose(mesh_t *mesh);

archive/src/display/mesh/quad.c

@@ -0,0 +1,149 @@
+/**
+ * Copyright (c) 2025 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "quad.h"
+#include "assert/assert.h"
+#include "debug/debug.h"
+
+mesh_t QUAD_MESH_SIMPLE;
+meshvertex_t QUAD_MESH_SIMPLE_VERTICES[QUAD_VERTEX_COUNT] = {
+  { .color = COLOR_WHITE_4B, .uv = { 0.0f, 0.0f }, .pos = { 0.0f, 0.0f, 0.0f } },
+  { .color = COLOR_WHITE_4B, .uv = { 1.0f, 0.0f }, .pos = { 1.0f, 0.0f, 0.0f } },
+  { .color = COLOR_WHITE_4B, .uv = { 1.0f, 1.0f }, .pos = { 1.0f, 1.0f, 0.0f } },
+
+  { .color = COLOR_WHITE_4B, .uv = { 0.0f, 0.0f }, .pos = { 0.0f, 0.0f, 0.0f } },
+  { .color = COLOR_WHITE_4B, .uv = { 1.0f, 1.0f }, .pos = { 1.0f, 1.0f, 0.0f } },
+  { .color = COLOR_WHITE_4B, .uv = { 0.0f, 1.0f }, .pos = { 0.0f, 1.0f, 0.0f } }
+};
+
+void quadInit() {
+  meshInit(
+    &QUAD_MESH_SIMPLE,
+    QUAD_PRIMITIVE_TYPE,
+    QUAD_VERTEX_COUNT,
+    QUAD_MESH_SIMPLE_VERTICES
+  );
+}
+
+void quadBuffer(
+  meshvertex_t *vertices,
+  const float_t minX,
+  const float_t minY,
+  const float_t maxX,
+  const float_t maxY,
+  const color_t color,
+  const float_t u0,
+  const float_t v0,
+  const float_t u1,
+  const float_t v1
+) {
+  const float_t z = 0.0f; // Z coordinate for 2D rendering
+  assertNotNull(vertices, "Vertices cannot be NULL");
+
+  // First triangle
+  vertices[0].color = color;
+  vertices[0].uv[0] = u0;
+  vertices[0].uv[1] = v1;
+  vertices[0].pos[0] = minX;
+  vertices[0].pos[1] = maxY;
+  vertices[0].pos[2] = z;
+
+  vertices[1].color = color;
+  vertices[1].uv[0] = u1;
+  vertices[1].uv[1] = v0;
+  vertices[1].pos[0] = maxX;
+  vertices[1].pos[1] = minY;
+  vertices[1].pos[2] = z;
+
+  vertices[2].color = color;
+  vertices[2].uv[0] = u0;
+  vertices[2].uv[1] = v0;
+  vertices[2].pos[0] = minX;
+  vertices[2].pos[1] = minY;
+  vertices[2].pos[2] = z;
+
+  // Second triangle
+  vertices[3].color = color;
+  vertices[3].uv[0] = u0;
+  vertices[3].uv[1] = v1;
+  vertices[3].pos[0] = minX;
+  vertices[3].pos[1] = maxY;
+  vertices[3].pos[2] = z;
+
+  vertices[4].color = color;
+  vertices[4].uv[0] = u1;
+  vertices[4].uv[1] = v1;
+  vertices[4].pos[0] = maxX;
+  vertices[4].pos[1] = maxY;
+  vertices[4].pos[2] = z;
+
+  vertices[5].color = color;
+  vertices[5].uv[0] = u1;
+  vertices[5].uv[1] = v0;
+  vertices[5].pos[0] = maxX;
+  vertices[5].pos[1] = minY;
+  vertices[5].pos[2] = z;
+}
+
+void quadBuffer3D(
+  meshvertex_t *vertices,
+  const vec3 min,
+  const vec3 max,
+  const color_t color,
+  const vec2 uvMin,
+  const vec2 uvMax
+) {
+  assertNotNull(vertices, "Vertices cannot be NULL");
+  assertNotNull(min, "Min vector cannot be NULL");
+  assertNotNull(max, "Max vector cannot be NULL");
+  assertNotNull(uvMin, "UV Min vector cannot be NULL");
+  assertNotNull(uvMax, "UV Max vector cannot be NULL");
+
+  // First triangle
+  vertices[0].color = color;
+  vertices[0].uv[0] = uvMin[0];
+  vertices[0].uv[1] = uvMin[1];
+  vertices[0].pos[0] = min[0];
+  vertices[0].pos[1] = min[1];
+  vertices[0].pos[2] = min[2];
+
+  vertices[1].color = color;
+  vertices[1].uv[0] = uvMax[0];
+  vertices[1].uv[1] = uvMin[1];
+  vertices[1].pos[0] = max[0];
+  vertices[1].pos[1] = min[1];
+  vertices[1].pos[2] = min[2];
+
+  vertices[2].color = color;
+  vertices[2].uv[0] = uvMax[0];
+  vertices[2].uv[1] = uvMax[1];
+  vertices[2].pos[0] = max[0];
+  vertices[2].pos[1] = max[1];
+  vertices[2].pos[2] = min[2];
+
+  // Second triangle
+  vertices[3].color = color;
+  vertices[3].uv[0] = uvMin[0];
+  vertices[3].uv[1] = uvMin[1];
+  vertices[3].pos[0] = min[0];
+  vertices[3].pos[1] = min[1];
+  vertices[3].pos[2] = min[2];
+
+  vertices[4].color = color;
+  vertices[4].uv[0] = uvMax[0];
+  vertices[4].uv[1] = uvMax[1];
+  vertices[4].pos[0] = max[0];
+  vertices[4].pos[1] = max[1];
+  vertices[4].pos[2] = min[2];
+
+  vertices[5].color = color;
+  vertices[5].uv[0] = uvMin[0];
+  vertices[5].uv[1] = uvMax[1];
+  vertices[5].pos[0] = min[0];
+  vertices[5].pos[1] = max[1];
+  vertices[5].pos[2] = min[2];
+}

archive/src/display/mesh/quad.h

@@ -0,0 +1,67 @@
+/**
+ * Copyright (c) 2025 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "mesh.h"
+#include "display/color.h"
+
+#define QUAD_VERTEX_COUNT 6
+#define QUAD_PRIMITIVE_TYPE MESH_PRIMITIVE_TRIANGLES
+
+extern mesh_t QUAD_MESH_SIMPLE;
+extern meshvertex_t QUAD_MESH_SIMPLE_VERTICES[QUAD_VERTEX_COUNT];
+
+/**
+ * Initializes the quad mesh.
+ */
+void quadInit();
+
+/**
+ * Buffers a quad into the provided vertex array.
+ * 
+ * @param vertices The vertex array to buffer into.
+ * @param minX The minimum X coordinate of the quad.
+ * @param minY The minimum Y coordinate of the quad.
+ * @param maxX The maximum X coordinate of the quad.
+ * @param maxY The maximum Y coordinate of the quad.
+ * @param color The color of the quad.
+ * @param u0 The U texture coordinate for the first vertex.
+ * @param v0 The V texture coordinate for the first vertex.
+ * @param u1 The U texture coordinate for the second vertex.
+ * @param v1 The V texture coordinate for the second vertex.
+ */
+void quadBuffer(
+  meshvertex_t *vertices,
+  const float_t minX,
+  const float_t minY,
+  const float_t maxX,
+  const float_t maxY,
+  const color_t color,
+  const float_t u0,
+  const float_t v0,
+  const float_t u1,
+  const float_t v1
+);
+
+/**
+ * Buffers a 3D quad into the provided vertex array.
+ * 
+ * @param vertices The vertex array to buffer into.
+ * @param min The minimum XYZ coordinates of the quad.
+ * @param max The maximum XYZ coordinates of the quad.
+ * @param color The color of the quad.
+ * @param uvMin The minimum UV coordinates of the quad.
+ * @param uvMax The maximum UV coordinates of the quad.
+ */
+void quadBuffer3D(
+  meshvertex_t *vertices,
+  const vec3 min,
+  const vec3 max,
+  const color_t color,
+  const vec2 uvMin,
+  const vec2 uvMax
+);