t3d.h

Go to the documentation of this file.

 
#ifndef TINY3D_T3D_H
#define TINY3D_T3D_H
 
#include <t3d/t3dmath.h>
#include <libdragon.h>
 
#ifdef __cplusplus
extern "C"
{
#endif
 
#define T3D_VERTEX_CACHE_SIZE 70
 
extern uint32_t T3D_RSP_ID;
 
// RSP commands, must match with the commands defined in `rsp/rsp_tiny3d.rspl`
enum T3DCmd {
  T3D_CMD_TRI_DRAW     = 0x0,
  T3D_CMD_SCREEN_SIZE  = 0x1,
  T3D_CMD_MATRIX_STACK = 0x2,
  T3D_CMD_SET_WORD     = 0x3,
  T3D_CMD_VERT_LOAD    = 0x4,
  T3D_CMD_LIGHT_SET    = 0x5,
  T3D_CMD_DRAWFLAGS    = 0x6,
  T3D_CMD_PROJ_SET     = 0x7,
  T3D_CMD_FOG_RANGE    = 0x8,
  T3D_CMD_FOG_STATE    = 0x9,
  T3D_CMD_TRI_SYNC     = 0xA,
  T3D_CMD_TRI_STRIP    = 0xB,
  T3D_CMD_TRI_SEQ      = 0xC,
  //                   = 0xD,
  //                   = 0xE,
  //                   = 0xF,
};
 
// Internal vertex format, interleaves two vertices
typedef struct {
  /* 0x00 */ int16_t posA[3]; // s16 (used in the ucode as the int. part of a s16.16)
  /* 0x06 */ uint16_t normA;  // 5,6,5 packed normal
  /* 0x08 */ int16_t posB[3]; // s16 (used in the ucode as the int. part of a s16.16)
  /* 0x0E */ uint16_t normB;  // 5,6,5 packed normal
  /* 0x10 */ uint32_t rgbaA; // RGBA8 color
  /* 0x14 */ uint32_t rgbaB; // RGBA8 color
  /* 0x18 */ int16_t stA[2]; // UV fixed point 10.5 (pixel coords)
  /* 0x1C */ int16_t stB[2]; // UV fixed point 10.5 (pixel coords)
} __attribute__((aligned(8))) T3DVertPacked;
 
static_assert(sizeof(T3DVertPacked) == 0x20, "T3DVertPacked has wrong size");
 
enum T3DDrawFlags {
  T3D_FLAG_DEPTH      = 1 << 0,
  T3D_FLAG_TEXTURED   = 1 << 1,
  T3D_FLAG_SHADED     = 1 << 2,
  T3D_FLAG_CULL_FRONT = 1 << 3,
  T3D_FLAG_CULL_BACK  = 1 << 4,
  T3D_FLAG_NO_LIGHT   = 1 << 16,
};
 
// Segment addresses, some are used internally but can be set by the user too
enum T3DSegment {
  T3D_SEGMENT_1 = 1,
  T3D_SEGMENT_2 = 2,
  T3D_SEGMENT_3 = 3,
  T3D_SEGMENT_4 = 4,
  T3D_SEGMENT_5 = 5,
  T3D_SEGMENT_6 = 6,
  T3D_SEGMENT_SKELETON = 7,
};
 
// Vertex effect functions
enum T3DVertexFX {
  T3D_VERTEX_FX_NONE           = 0,
  T3D_VERTEX_FX_SPHERICAL_UV   = 1,
  T3D_VERTEX_FX_CELSHADE_COLOR = 2,
  T3D_VERTEX_FX_CELSHADE_ALPHA = 3,
  T3D_VERTEX_FX_OUTLINE        = 4,
  T3D_VERTEX_FX_UV_OFFSET      = 5,
};
 
typedef struct {
  T3DMat4FP _matCameraFP [[deprecated("Use t3d_viewport_set_view_matrix()")]];
  T3DMat4FP _matProjFP [[deprecated("Use t3d_viewport_set_projection_matrix()")]];
 
  T3DMat4 matCamera; // view matrix, can be set via `t3d_viewport_look_at`
  T3DMat4 matProj;   // projection matrix, can be set via `t3d_viewport_set_projection`
 
  T3DMat4 matCamProj; // combined view-projection matrix, calculated automatically on demand
  T3DFrustum viewFrustum; // frustum, calculated from the combined matrix
  bool _isCamProjDirty; // flag to indicate if the combined matrix needs to be recalculated
 
  int32_t offset[2];  // screen offset in pixel, [0,0] by default
  int32_t size[2];    // screen size in pixel, same as the allocated framebuffer size by default
  int guardBandScale; // guard band for clipping, 2 by default
  int useRejection;   // use rejection instead of clipping, false by default
 
  float _normScaleW; // factor to normalize W in the ucode, set automatically
 
  uint16_t _bufferCount; // amount of matrices / framebuffers
  uint16_t _bufferIdx;   // current buffer index
  T3DMat4FP *_matFP; // stores both camera and projection matrices
} T3DViewport;
 
typedef struct {
   // Internal matrix stack size, must be at least 2.
   // If set two zero, 8 will be used by default.
  int matrixStackSize;
} T3DInitParams;
 
typedef struct {
  uint32_t trisPreCull;
  uint32_t trisPostCull;
} T3DMetrics;
 
void t3d_init(T3DInitParams params);
 
void t3d_destroy(void);
 
void t3d_frame_start(void);
 
 
void t3d_screen_clear_color(color_t color);
 
void t3d_screen_clear_depth();
 
void t3d_metrics_fetch(T3DMetrics* data);
 
inline static T3DViewport t3d_viewport_create() {
  return (T3DViewport){
    ._isCamProjDirty = true,
    .offset = {0, 0},
    .size = {(int32_t)display_get_width(), (int32_t)display_get_height()},
    .guardBandScale = 2,
    .useRejection = false,
    ._bufferCount = 0,
    ._matFP = NULL,
  };
}
 
inline static T3DViewport t3d_viewport_create_buffered(uint16_t count) {
  T3DViewport vp = t3d_viewport_create();
  vp._bufferCount = count;
  vp._bufferIdx = 0;
  vp._matFP = (T3DMat4FP*)malloc_uncached(sizeof(T3DMat4FP) * 2 * count);
  return vp;
}
 
inline static void t3d_viewport_destroy(T3DViewport *viewport) {
  if(viewport->_matFP) {
    free_uncached(viewport->_matFP);
    viewport->_matFP = NULL;
    viewport->_bufferCount = 0;
    viewport->_bufferIdx = 0;
  }
}
 
void t3d_viewport_attach(T3DViewport *viewport);
 
T3DViewport *t3d_viewport_get();
 
inline static void t3d_viewport_set_area(T3DViewport *viewport, int32_t x, int32_t y, int32_t width, int32_t height) {
  viewport->offset[0] = x;
  viewport->offset[1] = y;
  viewport->size[0] = width;
  viewport->size[1] = height;
}
 
void t3d_viewport_set_perspective(T3DViewport *viewport, float fov, float aspectRatio, float near, float far);
 
void t3d_viewport_set_projection(T3DViewport *viewport, float fov, float near, float far);
 
void t3d_viewport_set_ortho(T3DViewport *viewport, float left, float right, float bottom, float top, float near, float far);
 
inline static void t3d_viewport_set_w_normalize(T3DViewport *viewport, float near, float far) {
  viewport->_normScaleW = 2.0f / (far + near);
}
 
void t3d_viewport_look_at(T3DViewport *viewport, const T3DVec3 *eye, const T3DVec3 *target, const T3DVec3 *up);
 
void t3d_viewport_set_view_matrix(T3DViewport *viewport, const T3DMat4 *mat);
 
void t3d_viewport_set_projection_matrix(T3DViewport *viewport, const T3DMat4 *mat);
 
void t3d_viewport_calc_viewspace_pos(T3DViewport *viewport, T3DVec3 *out, const T3DVec3 *pos);
 
void t3d_tri_draw(uint32_t v0, uint32_t v1, uint32_t v2);
 
void t3d_tri_draw_unindexed(uint32_t baseIndex, uint32_t triCount);
 
void t3d_quad_draw_unindexed(uint32_t baseIndex, uint32_t quadCount);
 
 
void t3d_tri_draw_strip(int16_t* indexBuff, int count);
 
void t3d_tri_draw_strip_and_sync(int16_t* indexBuff, int count);
 
inline static void t3d_tri_sync() {
  rspq_write(T3D_RSP_ID, T3D_CMD_TRI_SYNC, 0);
}
 
void t3d_matrix_set(const T3DMat4FP *mat, bool doMultiply);
 
void t3d_matrix_push(const T3DMat4FP *mat);
 
void t3d_matrix_pop(int count);
 
void t3d_matrix_push_pos(int count);
 
void t3d_matrix_set_proj(const T3DMat4FP *mat);
 
void t3d_vert_load(const T3DVertPacked *vertices, uint32_t offset, uint32_t count);
 
void t3d_light_set_ambient(const uint8_t *color);
 
void t3d_light_set_directional(int index, const uint8_t *color, const T3DVec3 *dir);
 
void t3d_light_set_point(int index, const uint8_t *color, const T3DVec3 *pos, float size, bool ignoreNormals);
 
void t3d_light_set_count(int count);
 
void t3d_light_set_exposure(float exposure);
 
void t3d_fog_set_range(float near, float far);
 
static inline void t3d_fog_set_enabled(bool isEnabled) {
  // 0xB/0xC are the offsets of attributes (color/UV) in a vertex on the RSP side
  // this allows the code to do a branch-less save.
  // 0xB points to alpha of the current vertex, 0xC to the UV which get overwritten later
  rspq_write(T3D_RSP_ID, T3D_CMD_FOG_STATE, isEnabled ? 0x0B : 0x0C);
}
 
uint16_t t3d_vert_pack_normal(const T3DVec3 *normal);
 
void t3d_state_set_drawflags(enum T3DDrawFlags drawFlags);
 
void t3d_state_set_depth_offset(int16_t offset);
 
void t3d_state_set_alpha_to_tile(bool enable);
 
void t3d_state_set_vertex_fx(enum T3DVertexFX func, int16_t arg0, int16_t arg1);
 
void t3d_state_set_vertex_fx_scale(uint16_t scale);
 
void t3d_segment_set(uint8_t segmentId, void* address);
 
static inline void* t3d_segment_placeholder(uint8_t segmentId) {
  return (void*)(uint32_t)(segmentId << (8*3 + 2));
}
 
static inline void* t3d_segment_address(uint8_t segmentId, void* ptr) {
  return (void*)(PhysicalAddr(ptr) | (segmentId << (8*3 + 2)));
}
 
// Index-buffer helpers:
 
void t3d_indexbuffer_convert(int16_t indices[], int count);
 
// Vertex-buffer helpers:
 
static inline int16_t* t3d_vertbuffer_get_pos(T3DVertPacked vert[], int idx) {
  return (idx & 1) ? vert[idx/2].posB : vert[idx/2].posA;
}
 
static inline int16_t* t3d_vertbuffer_get_uv(T3DVertPacked vert[], int idx) {
  return (idx & 1) ? vert[idx/2].stB : vert[idx/2].stA;
}
 
static inline uint32_t* t3d_vertbuffer_get_color(T3DVertPacked vert[], int idx) {
  return (idx & 1) ? &vert[idx/2].rgbaB : &vert[idx/2].rgbaA;
}
 
static inline uint8_t* t3d_vertbuffer_get_rgba(T3DVertPacked vert[], int idx) {
  return (idx & 1) ? (uint8_t*)&vert[idx/2].rgbaB : (uint8_t*)&vert[idx/2].rgbaA;
}
 
static inline uint16_t* t3d_vertbuffer_get_norm(T3DVertPacked vert[], int idx) {
  return (idx & 1) ? &vert[idx/2].normB : &vert[idx/2].normA;
}
 
#ifdef __cplusplus
}
#endif
 
// C++ wrappers that allow (const-)references to be passed instead of pointers
#ifdef __cplusplus
 
inline void t3d_viewport_attach(T3DViewport &viewport) { t3d_viewport_attach(&viewport); }
inline void t3d_viewport_set_area(T3DViewport &viewport, int32_t x, int32_t y, int32_t width, int32_t height) { t3d_viewport_set_area(&viewport, x, y, width, height); }
inline void t3d_viewport_set_projection(T3DViewport &viewport, float fov, float near, float far) { t3d_viewport_set_projection(&viewport, fov, near, far); }
inline void t3d_viewport_set_ortho(T3DViewport &viewport, float left, float right, float bottom, float top, float near, float far) { t3d_viewport_set_ortho(&viewport, left, right, bottom, top, near, far); }
inline void t3d_viewport_set_w_normalize(T3DViewport &viewport, float near, float far) { t3d_viewport_set_w_normalize(&viewport, near, far); }
inline void t3d_viewport_look_at(T3DViewport &viewport, const T3DVec3 &eye, const T3DVec3 &target, const T3DVec3 &up = T3DVec3{{0,1,0}}) { t3d_viewport_look_at(&viewport, &eye, &target, &up); }
inline void t3d_viewport_calc_viewspace_pos(T3DViewport &viewport, T3DVec3 &out, const T3DVec3 &pos) { t3d_viewport_calc_viewspace_pos(&viewport, &out, &pos); }
 
inline void t3d_light_set_directional(int index, const uint8_t *color, const T3DVec3 &dir) { t3d_light_set_directional(index, color, &dir); }
inline void t3d_light_set_point(int index, const uint8_t *color, const T3DVec3 &pos, float size, bool ignoreNormals = false) { t3d_light_set_point(index, color, &pos, size, ignoreNormals); }
 
inline void t3d_light_set_ambient(const color_t &color) { t3d_light_set_ambient((const uint8_t*)&color); }
inline void t3d_light_set_directional(int index, const color_t &color, const T3DVec3 &dir) { t3d_light_set_directional(index, (const uint8_t*)&color, &dir); }
inline void t3d_light_set_point(int index, const color_t &color, const T3DVec3 &pos, float size, bool ignoreNormals = false) { t3d_light_set_point(index, (const uint8_t*)&color, &pos, size, ignoreNormals); }
 
#endif
 
#endif //TINY3D_T3D_H