117 lines
3.1 KiB
C
117 lines
3.1 KiB
C
/**
|
|
* Copyright (c) 2026 Dominic Masters
|
|
*
|
|
* This software is released under the MIT License.
|
|
* https://opensource.org/licenses/MIT
|
|
*/
|
|
|
|
#include "plane.h"
|
|
#include "assert/assert.h"
|
|
|
|
mesh_t PLANE_MESH_SIMPLE;
|
|
meshvertex_t PLANE_MESH_SIMPLE_VERTICES[PLANE_VERTEX_COUNT];
|
|
|
|
errorret_t planeInit() {
|
|
vec3 min = { 0.0f, 0.0f, 0.0f };
|
|
vec3 max = { 1.0f, 0.0f, 1.0f };
|
|
vec2 uvMin = { 0.0f, 0.0f };
|
|
vec2 uvMax = { 1.0f, 1.0f };
|
|
planeBuffer(
|
|
PLANE_MESH_SIMPLE_VERTICES,
|
|
PLANE_AXIS_XZ,
|
|
min,
|
|
max
|
|
#if MESH_ENABLE_COLOR
|
|
, COLOR_WHITE_4B
|
|
#endif
|
|
, uvMin,
|
|
uvMax
|
|
);
|
|
errorChain(meshInit(
|
|
&PLANE_MESH_SIMPLE,
|
|
PLANE_PRIMITIVE_TYPE,
|
|
PLANE_VERTEX_COUNT,
|
|
PLANE_MESH_SIMPLE_VERTICES
|
|
));
|
|
errorOk();
|
|
}
|
|
|
|
/* Helper macro to write one vertex. */
|
|
#if MESH_ENABLE_COLOR
|
|
#define PLANE_VERT(i, px, py, pz, u, v) \
|
|
vertices[i].color = color; \
|
|
vertices[i].pos[0] = (px); \
|
|
vertices[i].pos[1] = (py); \
|
|
vertices[i].pos[2] = (pz); \
|
|
vertices[i].uv[0] = (u); \
|
|
vertices[i].uv[1] = (v);
|
|
#else
|
|
#define PLANE_VERT(i, px, py, pz, u, v) \
|
|
vertices[i].pos[0] = (px); \
|
|
vertices[i].pos[1] = (py); \
|
|
vertices[i].pos[2] = (pz); \
|
|
vertices[i].uv[0] = (u); \
|
|
vertices[i].uv[1] = (v);
|
|
#endif
|
|
|
|
void planeBuffer(
|
|
meshvertex_t *vertices,
|
|
const planeaxis_t axis,
|
|
const vec3 min,
|
|
const vec3 max
|
|
#if MESH_ENABLE_COLOR
|
|
, const color_t color
|
|
#endif
|
|
, 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, "uvMin cannot be NULL");
|
|
assertNotNull(uvMax, "uvMax cannot be NULL");
|
|
|
|
const float_t u0 = uvMin[0], u1 = uvMax[0];
|
|
const float_t v0 = uvMin[1], v1 = uvMax[1];
|
|
|
|
switch(axis) {
|
|
case PLANE_AXIS_XY: {
|
|
/* Flat in XY at z = min[2]; spans X and Y. */
|
|
const float_t z = min[2];
|
|
PLANE_VERT(0, min[0], min[1], z, u0, v0)
|
|
PLANE_VERT(1, max[0], min[1], z, u1, v0)
|
|
PLANE_VERT(2, max[0], max[1], z, u1, v1)
|
|
PLANE_VERT(3, min[0], min[1], z, u0, v0)
|
|
PLANE_VERT(4, max[0], max[1], z, u1, v1)
|
|
PLANE_VERT(5, min[0], max[1], z, u0, v1)
|
|
break;
|
|
}
|
|
|
|
case PLANE_AXIS_XZ: {
|
|
/* Flat in XZ at y = min[1]; spans X and Z. */
|
|
const float_t y = min[1];
|
|
PLANE_VERT(0, min[0], y, min[2], u0, v0)
|
|
PLANE_VERT(1, max[0], y, min[2], u1, v0)
|
|
PLANE_VERT(2, max[0], y, max[2], u1, v1)
|
|
PLANE_VERT(3, min[0], y, min[2], u0, v0)
|
|
PLANE_VERT(4, max[0], y, max[2], u1, v1)
|
|
PLANE_VERT(5, min[0], y, max[2], u0, v1)
|
|
break;
|
|
}
|
|
|
|
case PLANE_AXIS_YZ: {
|
|
/* Flat in YZ at x = min[0]; spans Y and Z. */
|
|
const float_t x = min[0];
|
|
PLANE_VERT(0, x, min[1], min[2], u0, v0)
|
|
PLANE_VERT(1, x, max[1], min[2], u1, v0)
|
|
PLANE_VERT(2, x, max[1], max[2], u1, v1)
|
|
PLANE_VERT(3, x, min[1], min[2], u0, v0)
|
|
PLANE_VERT(4, x, max[1], max[2], u1, v1)
|
|
PLANE_VERT(5, x, min[1], max[2], u0, v1)
|
|
break;
|
|
}
|
|
}
|
|
|
|
#undef PLANE_VERT
|
|
}
|