CoCalc -- renderer.c

GitHub Repository: MorsGames/sm64plus
Path: blob/master/src/goddard/renderer.c
⁷⁸⁵⁸ views
1
#include <ultra64.h>
2
#include <stdarg.h>
3
#include <stdio.h>
4

5
#if defined(VERSION_JP) || defined(VERSION_US)
6
#include "prevent_bss_reordering.h"
7
#endif
8

9
#include "debug_utils.h"
10
#include "draw_objects.h"
11
#include "dynlist_proc.h"
12
#include "dynlists/dynlists.h"
13
#include "gd_macros.h"
14
#include "gd_main.h"
15
#include "gd_math.h"
16
#include "gd_memory.h"
17
#include "gd_types.h"
18
#include "macros.h"
19
#include "objects.h"
20
#include "renderer.h"
21
#include "sfx.h"
22
#include "shape_helper.h"
23
#include "skin.h"
24
#include "types.h"
25

26
#include "./game/settings.h"
27

28
#include "config.h"
29
#include "gfx_dimensions.h"
30

31
#define MAX_GD_DLS 1000
32
#define OS_MESG_SI_COMPLETE 0x33333333
33

34
#ifndef NO_SEGMENTED_MEMORY
35
#define GD_VIRTUAL_TO_PHYSICAL(addr) ((uintptr_t)(addr) &0x0FFFFFFF)
36
#define GD_LOWER_24(addr) ((uintptr_t)(addr) &0x00FFFFFF)
37
#define GD_LOWER_29(addr) (((uintptr_t)(addr)) & 0x1FFFFFFF)
38
#else
39
#define GD_VIRTUAL_TO_PHYSICAL(addr) (addr)
40
#define GD_LOWER_24(addr) ((uintptr_t)(addr))
41
#define GD_LOWER_29(addr) (((uintptr_t)(addr)))
42
#endif
43

44
#define MTX_INTPART_PACK(w1, w2) (((w1) &0xFFFF0000) | (((w2) >> 16) & 0xFFFF))
45
#define MTX_FRACPART_PACK(w1, w2) ((((w1) << 16) & 0xFFFF0000) | ((w2) &0xFFFF))
46
#define LOOKAT_PACK(c) ((s32) MIN(((c) * (128.0)), 127.0) & 0xff)
47

48
// structs
49
struct GdDisplayList {
50
    /* Vertices */
51
    /*0x00*/ s32 curVtxIdx;
52
    /*0x04*/ s32 totalVtx;
53
    /*0x08*/ Vtx *vtx;
54
    /* Matrices */
55
    /*0x0C*/ s32 curMtxIdx;
56
    /*0x10*/ s32 totalMtx;
57
    /*0x14*/ Mtx *mtx;
58
    /* Lights */
59
    /*0x18*/ s32 curLightIdx;
60
    /*0x1C*/ s32 totalLights;
61
    /*0x20*/ Lights4 *light;
62
    /* Gfx-es */
63
    /*0x24*/ s32 curGfxIdx;
64
    /*0x28*/ s32 totalGfx;
65
    /*0x2C*/ Gfx *gfx;    // active position in DL
66
    /*0x30*/ Gfx **dlptr; // pointer to list/array of display lists for each frame?
67
                          /* Viewports */
68
    /*0x34*/ s32 curVpIdx;
69
    /*0x38*/ s32 totalVp;
70
    /*0x3C*/ Vp *vp;
71
    /* GD DL Info */
72
    /*0x40*/ u32 id;     // user specified
73
    /*0x44*/ u32 number; // count
74
    /*0x48*/ u8 pad48[4];
75
    /*0x4C*/ struct GdDisplayList *parent; // not quite sure?
76
};                                         /* sizeof = 0x50 */
77
// accessor macros for gd dl
78
#define DL_CURRENT_VTX(dl)   ((dl)->vtx[(dl)->curVtxIdx])
79
#define DL_CURRENT_MTX(dl)   ((dl)->mtx[(dl)->curMtxIdx])
80
#define DL_CURRENT_LIGHT(dl) ((dl)->light[(dl)->curLightIdx])
81
#define DL_CURRENT_GFX(dl)   ((dl)->gfx[(dl)->curGfxIdx])
82
#define DL_CURRENT_VP(dl)    ((dl)->vp[(dl)->curVpIdx])
83

84
struct LightDirVec {
85
    s32 x, y, z;
86
};
87

88
enum DynListBankFlag { TABLE_END = -1, STD_LIST_BANK = 3 };
89

90
struct DynListBankInfo {
91
    /* 0x00 */ enum DynListBankFlag flag;
92
    /* 0x04 */ struct DynList *list;
93
};
94

95
// bss
96
#if defined(VERSION_EU) || defined(VERSION_SH)
97
static OSMesgQueue D_801BE830; // controller msg queue
98
static OSMesg D_801BE848[10];
99
u8 EUpad1[0x40];
100
static OSMesgQueue D_801BE8B0;
101
static OSMesgQueue sGdDMAQueue; // @ 801BE8C8
102
// static u32 unref_801be870[16];
103
// static u32 unref_801be8e0[25];
104
// static u32 unref_801be948[13];
105
u8 EUpad2[0x64];
106
static OSMesg sGdMesgBuf[1]; // @ 801BE944
107
u8 EUpad3[0x34];
108
static OSMesg sGdDMACompleteMsg; // msg buf for D_801BE8B0 queue
109
static OSIoMesg sGdDMAReqMesg;
110
static struct ObjView *D_801BE994; // store if View flag 0x40 set
111

112
u8 EUpad4[0x88];
113
#endif
114
static OSContStatus D_801BAE60[4];
115
static OSContPad sGdContPads[4];    // @ 801BAE70
116
static OSContPad sPrevFrameCont[4]; // @ 801BAE88
117
static u8 D_801BAEA0;
118
static struct ObjGadget *sTimerGadgets[GD_NUM_TIMERS]; // @ 801BAEA8
119
static u32 D_801BAF28;                                 // RAM addr offset?
120
static s16 sTriangleBuf[13][8];                          // [[s16; 8]; 13]? vert indices?
121
UNUSED static u32 unref_801bb000[3];
122
#ifndef USE_SYSTEM_MALLOC
123
static u8 *sMemBlockPoolBase; // @ 801BB00C
124
static u32 sAllocMemory;      // @ 801BB010; malloc-ed bytes
125
#endif
126
UNUSED static u32 unref_801bb014;
127
static s32 D_801BB018;
128
static s32 D_801BB01C;
129
static void *sLoadedTextures[0x10];          // texture pointers
130
static s32 sTextureDisplayLists[0x10];            // gd_dl indices
131
static s16 sVtxCvrtTCBuf[2];            // @ 801BB0A0
132
static s32 sCarGdDlNum;                 // @ 801BB0A4
133
static struct ObjGroup *sYoshiSceneGrp; // @ 801BB0A8
134
static s32 unusedDl801BB0AC;                  // unused DL number
135
static struct ObjGroup *sMarioSceneGrp; // @ 801BB0B0
136
static s32 D_801BB0B4;                  // second offset into sTriangleBuf
137
static struct ObjGroup *sCarSceneGrp;   // @ 801BB0B8
138
static s32 sVertexBufCount; // vtx's to load into RPD? Vtx len in GD Dl and in the lower bank (AF30)
139
static struct ObjView *sYoshiSceneView; // @ 801BB0C0
140
static s32 sTriangleBufCount;                  // number of triangles in sTriangleBuf
141
static struct ObjView *sMSceneView;     // @ 801BB0C8; Mario scene view
142
static s32 sVertexBufStartIndex;                  // Vtx start in GD Dl
143
static struct ObjView *sCarSceneView;   // @ 801BB0D0
144
static s32 sUpdateYoshiScene;           // @ 801BB0D4; update dl Vtx from ObjVertex?
145
static s32 sUpdateMarioScene;           // @ 801BB0D8; update dl Vtx from ObjVertex?
146
UNUSED static u32 unref_801bb0dc;
147
static s32 sUpdateCarScene; // @ 801BB0E0; guess, not really used
148
UNUSED static u32 unref_801bb0e4;
149
static struct GdVec3f sTextDrawPos;  // position to draw text? only set in one function, never used
150
UNUSED static u32 unref_801bb0f8[2];
151
static Mtx sIdnMtx;           // @ 801BB100
152
static Mat4f sInitIdnMat4;    // @ 801BB140
153
static s8 sVtxCvrtNormBuf[3]; // @ 801BB180
154
static s16 sAlpha;
155
static s32 sNumLights;
156
static struct GdColour sAmbScaleColour;       // @ 801BB190
157
static struct GdColour sLightScaleColours[2]; // @ 801BB1A0
158
static struct LightDirVec sLightDirections[2];
159
static s32 sLightId;
160
static Hilite sHilites[600];
161
static struct GdVec3f D_801BD758;
162
static struct GdVec3f D_801BD768; // had to migrate earlier
163
static u32 D_801BD774;
164
static struct GdObj *sMenuGadgets[9]; // @ 801BD778; d_obj ptr storage? menu?
165
static struct ObjView *sDebugViews[2];  // Seems to be a list of ObjViews for displaying debug info
166
static struct GdDisplayList *sStaticDl;     // @ 801BD7A8
167
static struct GdDisplayList *sDynamicMainDls[2]; // @ 801BD7B0
168
static struct GdDisplayList *sGdDlStash;    // @ 801BD7B8
169
static struct GdDisplayList *sMHeadMainDls[2]; // @ 801BD7C0; two DLs, double buffered one per frame - seem to be basic dls that branch to actual lists?
170
static struct GdDisplayList *sViewDls[3][2];       // I guess? 801BD7C8 -> 801BD7E0?
171
static struct GdDisplayList *sGdDLArray[MAX_GD_DLS]; // @ 801BD7E0; indexed by dl number (gddl+0x44)
172
static s32 sPickBufLen;                              // @ 801BE780
173
static s32 sPickBufPosition;                         // @ 801BE784
174
static s16 *sPickBuf;                                // @ 801BE788
175
static LookAt D_801BE790[2];
176
static LookAt D_801BE7D0[3];
177
#if defined(VERSION_JP) || defined(VERSION_US)
178
static OSMesgQueue D_801BE830; // controller msg queue
179
static OSMesg D_801BE848[10];
180
UNUSED static u32 unref_801be870[16];
181
static OSMesgQueue D_801BE8B0;
182
static OSMesgQueue sGdDMAQueue; // @ 801BE8C8
183
UNUSED static u32 unref_801be8e0[25];
184
static OSMesg sGdMesgBuf[1]; // @ 801BE944
185
UNUSED static u32 unref_801be948[13];
186
static OSMesg sGdDMACompleteMsg; // msg buf for D_801BE8B0 queue
187
static OSIoMesg sGdDMAReqMesg;
188
static struct ObjView *D_801BE994; // store if View flag 0x40 set
189
#endif
190

191
#ifdef USE_SYSTEM_MALLOC
192
static void *(*sAllocFn)(u32 size);
193
static void (*sFreeFn)(void *ptr);
194
#endif
195

196
// data
197
UNUSED static u32 unref_801a8670 = 0;
198
static s32 D_801A8674 = 0;
199
UNUSED static u32 unref_801a8678 = 0;
200
static s32 D_801A867C = 0;
201
static s32 D_801A8680 = 0;
202
static f32 sTracked1FrameTime = 0.0f; // @ 801A8684
203
static f32 sDynamicsTime = 0.0f;      // @ 801A8688
204
static f32 sDLGenTime = 0.0f;         // @ 801A868C
205
static f32 sRCPTime = 0.0f;           // @ 801A8690
206
static f32 sTimeScaleFactor = 1.0f;   // @ D_801A8694
207
#ifndef USE_SYSTEM_MALLOC
208
static u32 sMemBlockPoolSize = 1;     // @ 801A8698
209
static s32 sMemBlockPoolUsed = 0;     // @ 801A869C
210
#endif
211
static s32 sTextureCount = 0;  // maybe?
212
static struct GdTimer *D_801A86A4 = NULL; // timer for dlgen, dynamics, or rcp
213
static struct GdTimer *D_801A86A8 = NULL; // timer for dlgen, dynamics, or rcp
214
static struct GdTimer *D_801A86AC = NULL; // timer for dlgen, dynamics, or rcp
215
s32 gGdFrameBufNum = 0;                      // @ 801A86B0
216
UNUSED static u32 unref_801a86B4 = 0;
217
static struct ObjShape *sHandShape = NULL; // @ 801A86B8
218
static s32 D_801A86BC = 1;
219
static s32 D_801A86C0 = 0; // gd_dl id for something?
220
UNUSED static u32 unref_801a86C4 = 10;
221
static s32 sMtxParamType = G_MTX_PROJECTION;
222
static struct GdVec3f D_801A86CC = { 1.0f, 1.0f, 1.0f };
223
static struct ObjView *sActiveView = NULL;  // @ 801A86D8 current view? used when drawing dl
224
static struct ObjView *sScreenView = NULL; // @ 801A86DC
225
static struct ObjView *D_801A86E0 = NULL;
226
static struct ObjView *sHandView = NULL; // @ 801A86E4
227
static struct ObjView *sMenuView = NULL; // @ 801A86E8
228
static u32 sItemsInMenu = 0;             // @ 801A86EC
229
static s32 sDebugViewsCount = 0;               // number of elements in the sDebugViews array
230
static s32 sCurrDebugViewIndex = 0;             // @ 801A86F4; timing activate cool down counter?
231
UNUSED static u32 unref_801a86F8 = 0;
232
static struct GdDisplayList *sCurrentGdDl = NULL; // @ 801A86FC
233
static u32 sGdDlCount = 0;                        // @ 801A8700
234
static struct DynListBankInfo sDynLists[] = {     // @ 801A8704
235
    { STD_LIST_BANK, dynlist_test_cube },
236
    { STD_LIST_BANK, dynlist_spot_shape },
237
    { STD_LIST_BANK, dynlist_mario_master },
238
    { TABLE_END, NULL }
239
};
240

241
// textures and display list data
242
UNUSED static Gfx gd_texture1_dummy_aligner1[] = { // @ 801A8728
243
    gsSPEndDisplayList(),
244
};
245

246
ALIGNED8 static Texture gd_texture_hand_open[] = {
247
#include "textures/intro_raw/hand_open.rgba16.inc.c"
248
};
249

250
UNUSED static Gfx gd_texture2_dummy_aligner1[] = {
251
    gsSPEndDisplayList()
252
};
253

254
ALIGNED8 static Texture gd_texture_hand_closed[] = {
255
#include "textures/intro_raw/hand_closed.rgba16.inc.c"
256
};
257

258
ALIGNED8 static Texture gd_texture_red_star_0[] = {
259
#include "textures/intro_raw/red_star_0.rgba16.inc.c"
260
};
261

262
ALIGNED8 static Texture gd_texture_red_star_1[] = {
263
#include "textures/intro_raw/red_star_1.rgba16.inc.c"
264
};
265

266
ALIGNED8 static Texture gd_texture_red_star_2[] = {
267
#include "textures/intro_raw/red_star_2.rgba16.inc.c"
268
};
269

270
ALIGNED8 static Texture gd_texture_red_star_3[] = {
271
#include "textures/intro_raw/red_star_3.rgba16.inc.c"
272
};
273

274
ALIGNED8 static Texture gd_texture_red_star_4[] = {
275
#include "textures/intro_raw/red_star_4.rgba16.inc.c"
276
};
277

278
ALIGNED8 static Texture gd_texture_red_star_5[] = {
279
#include "textures/intro_raw/red_star_5.rgba16.inc.c"
280
};
281

282
ALIGNED8 static Texture gd_texture_red_star_6[] = {
283
#include "textures/intro_raw/red_star_6.rgba16.inc.c"
284
};
285

286
ALIGNED8 static Texture gd_texture_red_star_7[] = {
287
#include "textures/intro_raw/red_star_7.rgba16.inc.c"
288
};
289

290
ALIGNED8 static Texture gd_texture_white_star_0[] = {
291
#include "textures/intro_raw/white_star_0.rgba16.inc.c"
292
};
293

294
ALIGNED8 static Texture gd_texture_white_star_1[] = {
295
#include "textures/intro_raw/white_star_1.rgba16.inc.c"
296
};
297

298
ALIGNED8 static Texture gd_texture_white_star_2[] = {
299
#include "textures/intro_raw/white_star_2.rgba16.inc.c"
300
};
301

302
ALIGNED8 static Texture gd_texture_white_star_3[] = {
303
#include "textures/intro_raw/white_star_3.rgba16.inc.c"
304
};
305

306
ALIGNED8 static Texture gd_texture_white_star_4[] = {
307
#include "textures/intro_raw/white_star_4.rgba16.inc.c"
308
};
309

310
ALIGNED8 static Texture gd_texture_white_star_5[] = {
311
#include "textures/intro_raw/white_star_5.rgba16.inc.c"
312
};
313

314
ALIGNED8 static Texture gd_texture_white_star_6[] = {
315
#include "textures/intro_raw/white_star_6.rgba16.inc.c"
316
};
317

318
ALIGNED8 static Texture gd_texture_white_star_7[] = {
319
#include "textures/intro_raw/white_star_7.rgba16.inc.c"
320
};
321

322
static Vtx_t gd_vertex_star[] = {
323
    {{-64,   0, 0}, 0, {  0, 992}, {0x00, 0x00, 0x7F}},
324
    {{ 64,   0, 0}, 0, {992, 992}, {0x00, 0x00, 0x7F}},
325
    {{ 64, 128, 0}, 0, {992,   0}, {0x00, 0x00, 0x7F}},
326
    {{-64, 128, 0}, 0, {  0,   0}, {0x00, 0x00, 0x7F}},
327
};
328

329
//! no references to these vertices
330
UNUSED static Vtx_t gd_unused_vertex[] = {
331
    {{16384, 0,     0}, 0, {0, 16384}, {0x00, 0x00, 0x00}},
332
    {{    0, 0, 16384}, 0, {0,     0}, {0x00, 0x00, 0x40}},
333
    {{    0, 0,     0}, 0, {0,     0}, {0x00, 0x00, 0x00}},
334
    {{    0, 0,     0}, 0, {0,     0}, {0x00, 0x00, 0x00}},
335
};
336

337
static Gfx gd_dl_star_common[] = {
338
    gsDPSetCombineMode(G_CC_DECALRGBA, G_CC_DECALRGBA),
339
    gsSPClearGeometryMode(G_TEXTURE_GEN | G_TEXTURE_GEN_LINEAR),
340
    gsDPSetRenderMode(G_RM_AA_ZB_TEX_EDGE, G_RM_NOOP2),
341
    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_ON),
342
    gsDPSetTile(G_IM_FMT_RGBA, G_IM_SIZ_16b, 0, 0, G_TX_LOADTILE, 0, G_TX_CLAMP, 5, G_TX_NOLOD, G_TX_CLAMP, 5, G_TX_NOLOD),
343
    gsDPLoadSync(),
344
    gsDPLoadBlock(G_TX_LOADTILE, 0, 0, 32 * 32 - 1, CALC_DXT(32, G_IM_SIZ_16b_BYTES)),
345
    gsDPSetTile(G_IM_FMT_RGBA, G_IM_SIZ_16b, 8, 0, G_TX_RENDERTILE, 0, G_TX_CLAMP, 5, G_TX_NOLOD, G_TX_CLAMP, 5, G_TX_NOLOD),
346
    gsDPSetTileSize(0, 0, 0, (32 - 1) << G_TEXTURE_IMAGE_FRAC, (32 - 1) << G_TEXTURE_IMAGE_FRAC),
347
    gsSPVertex(gd_vertex_star, 4, 0),
348
    gsSP2Triangles( 0,  1,  2, 0x0,  0,  2,  3, 0x0),
349
    gsSPTexture(0xFFFF, 0xFFFF, 0, G_TX_RENDERTILE, G_OFF),
350
    gsDPSetCombineMode(G_CC_SHADE, G_CC_SHADE),
351
    gsDPSetRenderMode(G_RM_AA_ZB_OPA_INTER, G_RM_NOOP2),
352
    gsSPEndDisplayList(),
353
};
354

355
static Gfx gd_dl_red_star_0[] = {
356
    gsDPPipeSync(),
357
    gsDPSetTextureImage(G_IM_FMT_RGBA, G_IM_SIZ_16b, 1, gd_texture_red_star_0),
358
    gsSPBranchList(gd_dl_star_common),
359
};
360

361
static Gfx gd_dl_red_star_1[] = {
362
    gsDPPipeSync(),
363
    gsDPSetTextureImage(G_IM_FMT_RGBA, G_IM_SIZ_16b, 1, gd_texture_red_star_1),
364
    gsSPBranchList(gd_dl_star_common),
365
};
366

367
static Gfx gd_dl_red_star_2[] = {
368
    gsDPPipeSync(),
369
    gsDPSetTextureImage(G_IM_FMT_RGBA, G_IM_SIZ_16b, 1, gd_texture_red_star_2),
370
    gsSPBranchList(gd_dl_star_common),
371
};
372

373
static Gfx gd_dl_red_star_3[] = {
374
    gsDPPipeSync(),
375
    gsDPSetTextureImage(G_IM_FMT_RGBA, G_IM_SIZ_16b, 1, gd_texture_red_star_3),
376
    gsSPBranchList(gd_dl_star_common),
377
};
378

379
static Gfx gd_dl_red_star_4[] = {
380
    gsDPPipeSync(),
381
    gsDPSetTextureImage(G_IM_FMT_RGBA, G_IM_SIZ_16b, 1, gd_texture_red_star_4),
382
    gsSPBranchList(gd_dl_star_common),
383
};
384

385
static Gfx gd_dl_red_star_5[] = {
386
    gsDPPipeSync(),
387
    gsDPSetTextureImage(G_IM_FMT_RGBA, G_IM_SIZ_16b, 1, gd_texture_red_star_5),
388
    gsSPBranchList(gd_dl_star_common),
389
};
390

391
static Gfx gd_dl_red_star_6[] = {
392
    gsDPPipeSync(),
393
    gsDPSetTextureImage(G_IM_FMT_RGBA, G_IM_SIZ_16b, 1, gd_texture_red_star_6),
394
    gsSPBranchList(gd_dl_star_common),
395
};
396

397
static Gfx gd_dl_red_star_7[] = {
398
    gsDPPipeSync(),
399
    gsDPSetTextureImage(G_IM_FMT_RGBA, G_IM_SIZ_16b, 1, gd_texture_red_star_7),
400
    gsSPBranchList(gd_dl_star_common),
401
};
402

403
static Gfx gd_dl_silver_star_0[] = {
404
    gsDPPipeSync(),
405
    gsDPSetTextureImage(G_IM_FMT_RGBA, G_IM_SIZ_16b, 1, gd_texture_white_star_0),
406
    gsSPBranchList(gd_dl_star_common),
407
};
408

409
static Gfx gd_dl_silver_star_1[] = {
410
    gsDPPipeSync(),
411
    gsDPSetTextureImage(G_IM_FMT_RGBA, G_IM_SIZ_16b, 1, gd_texture_white_star_1),
412
    gsSPBranchList(gd_dl_star_common),
413
};
414

415
static Gfx gd_dl_silver_star_2[] = {
416
    gsDPPipeSync(),
417
    gsDPSetTextureImage(G_IM_FMT_RGBA, G_IM_SIZ_16b, 1, gd_texture_white_star_2),
418
    gsSPBranchList(gd_dl_star_common),
419
};
420

421
static Gfx gd_dl_silver_star_3[] = {
422
    gsDPPipeSync(),
423
    gsDPSetTextureImage(G_IM_FMT_RGBA, G_IM_SIZ_16b, 1, gd_texture_white_star_3),
424
    gsSPBranchList(gd_dl_star_common),
425
};
426

427
static Gfx gd_dl_silver_star_4[] = {
428
    gsDPPipeSync(),
429
    gsDPSetTextureImage(G_IM_FMT_RGBA, G_IM_SIZ_16b, 1, gd_texture_white_star_4),
430
    gsSPBranchList(gd_dl_star_common),
431
};
432

433
static Gfx gd_dl_silver_star_5[] = {
434
    gsDPPipeSync(),
435
    gsDPSetTextureImage(G_IM_FMT_RGBA, G_IM_SIZ_16b, 1, gd_texture_white_star_5),
436
    gsSPBranchList(gd_dl_star_common),
437
};
438

439
static Gfx gd_dl_silver_star_6[] = {
440
    gsDPPipeSync(),
441
    gsDPSetTextureImage(G_IM_FMT_RGBA, G_IM_SIZ_16b, 1, gd_texture_white_star_6),
442
    gsSPBranchList(gd_dl_star_common),
443
};
444

445
static Gfx gd_dl_silver_star_7[] = {
446
    gsDPPipeSync(),
447
    gsDPSetTextureImage(G_IM_FMT_RGBA, G_IM_SIZ_16b, 1, gd_texture_white_star_7),
448
    gsSPBranchList(gd_dl_star_common),
449
};
450

451
static Gfx *gd_red_star_dl_array[] = {
452
    gd_dl_red_star_0,
453
    gd_dl_red_star_0,
454
    gd_dl_red_star_1,
455
    gd_dl_red_star_1,
456
    gd_dl_red_star_2,
457
    gd_dl_red_star_2,
458
    gd_dl_red_star_3,
459
    gd_dl_red_star_3,
460
    gd_dl_red_star_4,
461
    gd_dl_red_star_4,
462
    gd_dl_red_star_5,
463
    gd_dl_red_star_5,
464
    gd_dl_red_star_6,
465
    gd_dl_red_star_6,
466
    gd_dl_red_star_7,
467
    gd_dl_red_star_7,
468
};
469

470
static Gfx *gd_silver_star_dl_array[] = {
471
    gd_dl_silver_star_0,
472
    gd_dl_silver_star_0,
473
    gd_dl_silver_star_1,
474
    gd_dl_silver_star_1,
475
    gd_dl_silver_star_2,
476
    gd_dl_silver_star_2,
477
    gd_dl_silver_star_3,
478
    gd_dl_silver_star_3,
479
    gd_dl_silver_star_4,
480
    gd_dl_silver_star_4,
481
    gd_dl_silver_star_5,
482
    gd_dl_silver_star_5,
483
    gd_dl_silver_star_6,
484
    gd_dl_silver_star_6,
485
    gd_dl_silver_star_7,
486
    gd_dl_silver_star_7,
487
};
488

489
ALIGNED8 static Texture gd_texture_sparkle_0[] = {
490
#include "textures/intro_raw/sparkle_0.rgba16.inc.c"
491
};
492

493
ALIGNED8 static Texture gd_texture_sparkle_1[] = {
494
#include "textures/intro_raw/sparkle_1.rgba16.inc.c"
495
};
496

497
ALIGNED8 static Texture gd_texture_sparkle_2[] = {
498
#include "textures/intro_raw/sparkle_2.rgba16.inc.c"
499
};
500

501
ALIGNED8 static Texture gd_texture_sparkle_3[] = {
502
#include "textures/intro_raw/sparkle_3.rgba16.inc.c"
503
};
504

505
ALIGNED8 static Texture gd_texture_sparkle_4[] = {
506
#include "textures/intro_raw/sparkle_4.rgba16.inc.c"
507
};
508

509
//! No reference to this texture. Two DL's uses the same previous texture
510
//  instead of using this texture.
511
UNUSED ALIGNED8 static Texture gd_texture_sparkle_5[] = {
512
#include "textures/intro_raw/sparkle_5.rgba16.inc.c"
513
};
514

515
static Vtx_t gd_vertex_sparkle[] = {
516
    {{   -32,      0,      0}, 0, {      0,   1984}, {  0x00, 0x00, 0x7F, 0x00}},
517
    {{    32,      0,      0}, 0, {   1984,   1984}, {  0x00, 0x00, 0x7F, 0x00}},
518
    {{    32,     64,      0}, 0, {   1984,      0}, {  0x00, 0x00, 0x7F, 0x00}},
519
    {{   -32,     64,      0}, 0, {      0,      0}, {  0x00, 0x00, 0x7F, 0x00}},
520
};
521

522
static Gfx gd_dl_sparkle[] = {
523
    gsDPSetCombineMode(G_CC_MODULATERGBA_PRIM, G_CC_MODULATERGBA_PRIM),
524
    gsSPClearGeometryMode(G_TEXTURE_GEN | G_TEXTURE_GEN_LINEAR),
525
    gsDPSetRenderMode(G_RM_AA_ZB_TEX_EDGE, G_RM_NOOP2),
526
    gsSPTexture(0x8000, 0x8000, 0, G_TX_RENDERTILE, G_ON),
527
    gsDPSetTile(G_IM_FMT_RGBA, G_IM_SIZ_16b, 0, 0, G_TX_LOADTILE, 0, G_TX_WRAP | G_TX_NOMIRROR, G_TX_NOMASK, G_TX_NOLOD,
528
                G_TX_WRAP | G_TX_NOMIRROR, G_TX_NOMASK, G_TX_NOLOD),
529
    gsDPLoadSync(),
530
    gsDPLoadBlock(G_TX_LOADTILE, 0, 0, 32 * 32 - 1, CALC_DXT(32, G_IM_SIZ_16b_BYTES)),
531
    gsDPSetTile(G_IM_FMT_RGBA, G_IM_SIZ_16b, 8, 0, G_TX_RENDERTILE, 0, G_TX_WRAP | G_TX_NOMIRROR, G_TX_NOMASK, G_TX_NOLOD,
532
                G_TX_WRAP | G_TX_NOMIRROR, G_TX_NOMASK, G_TX_NOLOD),
533
    gsDPSetTileSize(0, 0, 0, (32 - 1) << G_TEXTURE_IMAGE_FRAC, (32 - 1) << G_TEXTURE_IMAGE_FRAC),
534
    gsSPVertex(gd_vertex_sparkle, 4, 0),
535
    gsSP2Triangles(0,  1,  2, 0x0,  0,  2,  3, 0x0),
536
    gsSPTexture(0x0001, 0x0001, 0, G_TX_RENDERTILE, G_OFF),
537
    gsDPSetCombineMode(G_CC_SHADE, G_CC_SHADE),
538
    gsDPSetRenderMode(G_RM_AA_ZB_OPA_INTER, G_RM_NOOP2),
539
    gsSPEndDisplayList(),
540
};
541

542
static Gfx gd_dl_sparkle_red_color[] = {
543
    gsDPSetPrimColor(0, 0, 255, 0, 0, 255),
544
    gsSPEndDisplayList(),
545
};
546

547
static Gfx gd_dl_sparkle_white_color[] = {
548
    gsDPSetPrimColor(0, 0, 255, 255, 255, 255),
549
    gsSPEndDisplayList(),
550
};
551

552
static Gfx gd_dl_red_sparkle_0[] = {
553
    gsDPPipeSync(),
554
    gsSPDisplayList(gd_dl_sparkle_red_color),
555
    gsDPSetTextureImage(G_IM_FMT_RGBA, G_IM_SIZ_16b, 1, gd_texture_sparkle_0),
556
    gsSPBranchList(gd_dl_sparkle),
557
};
558

559
static Gfx gd_dl_red_sparkle_1[] = {
560
    gsDPPipeSync(),
561
    gsSPDisplayList(gd_dl_sparkle_red_color),
562
    gsDPSetTextureImage(G_IM_FMT_RGBA, G_IM_SIZ_16b, 1, gd_texture_sparkle_1),
563
    gsSPBranchList(gd_dl_sparkle),
564
};
565

566
static Gfx gd_dl_red_sparkle_2[] = {
567
    gsDPPipeSync(),
568
    gsSPDisplayList(gd_dl_sparkle_red_color),
569
    gsDPSetTextureImage(G_IM_FMT_RGBA, G_IM_SIZ_16b, 1, gd_texture_sparkle_2),
570
    gsSPBranchList(gd_dl_sparkle),
571
};
572

573
static Gfx gd_dl_red_sparkle_3[] = {
574
    gsDPPipeSync(),
575
    gsSPDisplayList(gd_dl_sparkle_red_color),
576
    gsDPSetTextureImage(G_IM_FMT_RGBA, G_IM_SIZ_16b, 1, gd_texture_sparkle_3),
577
    gsSPBranchList(gd_dl_sparkle),
578
};
579

580
static Gfx gd_dl_red_sparkle_4[] = {
581
    gsDPPipeSync(),
582
    gsSPDisplayList(gd_dl_sparkle_red_color),
583
    gsDPSetTextureImage(G_IM_FMT_RGBA, G_IM_SIZ_16b, 1, gd_texture_sparkle_4),
584
    gsSPBranchList(gd_dl_sparkle),
585
};
586

587
static Gfx gd_dl_red_sparkle_4_dup[] ={
588
    gsDPPipeSync(),
589
    gsSPDisplayList(gd_dl_sparkle_red_color),
590
    gsDPSetTextureImage(G_IM_FMT_RGBA, G_IM_SIZ_16b, 1, gd_texture_sparkle_4), // 4 again, correct texture would be 5
591
    gsSPBranchList(gd_dl_sparkle),
592
};
593

594
static Gfx gd_dl_silver_sparkle_0[] = {
595
    gsDPPipeSync(),
596
    gsSPDisplayList(gd_dl_sparkle_white_color),
597
    gsDPSetTextureImage(G_IM_FMT_RGBA, G_IM_SIZ_16b, 1, gd_texture_sparkle_0),
598
    gsSPBranchList(gd_dl_sparkle),
599
};
600

601
static Gfx gd_dl_silver_sparkle_1[] = {
602
    gsDPPipeSync(),
603
    gsSPDisplayList(gd_dl_sparkle_white_color),
604
    gsDPSetTextureImage(G_IM_FMT_RGBA, G_IM_SIZ_16b, 1, gd_texture_sparkle_1),
605
    gsSPBranchList(gd_dl_sparkle),
606
};
607

608
static Gfx gd_dl_silver_sparkle_2[] = {
609
    gsDPPipeSync(),
610
    gsSPDisplayList(gd_dl_sparkle_white_color),
611
    gsDPSetTextureImage(G_IM_FMT_RGBA, G_IM_SIZ_16b, 1, gd_texture_sparkle_2),
612
    gsSPBranchList(gd_dl_sparkle),
613
};
614

615
static Gfx gd_dl_silver_sparkle_3[] = {
616
    gsDPPipeSync(),
617
    gsSPDisplayList(gd_dl_sparkle_white_color),
618
    gsDPSetTextureImage(G_IM_FMT_RGBA, G_IM_SIZ_16b, 1, gd_texture_sparkle_3),
619
    gsSPBranchList(gd_dl_sparkle),
620
};
621

622
static Gfx gd_dl_silver_sparkle_4[] = {
623
    gsDPPipeSync(),
624
    gsSPDisplayList(gd_dl_sparkle_white_color),
625
    gsDPSetTextureImage(G_IM_FMT_RGBA, G_IM_SIZ_16b, 1, gd_texture_sparkle_4),
626
    gsSPBranchList(gd_dl_sparkle),
627
};
628

629
static Gfx gd_dl_silver_sparkle_4_dup[] = {
630
    gsDPPipeSync(),
631
    gsSPDisplayList(gd_dl_sparkle_white_color),
632
    gsDPSetTextureImage(G_IM_FMT_RGBA, G_IM_SIZ_16b, 1, gd_texture_sparkle_4), // 4 again, correct texture would be 5
633
    gsSPBranchList(gd_dl_sparkle),
634
};
635

636
static Gfx *gd_red_sparkle_dl_array[] = {
637
    gd_dl_red_sparkle_4,
638
    gd_dl_red_sparkle_4,
639
    gd_dl_red_sparkle_3,
640
    gd_dl_red_sparkle_3,
641
    gd_dl_red_sparkle_2,
642
    gd_dl_red_sparkle_2,
643
    gd_dl_red_sparkle_1,
644
    gd_dl_red_sparkle_1,
645
    gd_dl_red_sparkle_0,
646
    gd_dl_red_sparkle_0,
647
    gd_dl_red_sparkle_4_dup,
648
    gd_dl_red_sparkle_4_dup,
649
};
650

651
static Gfx *gd_silver_sparkle_dl_array[] = {
652
    gd_dl_silver_sparkle_4,
653
    gd_dl_silver_sparkle_4,
654
    gd_dl_silver_sparkle_3,
655
    gd_dl_silver_sparkle_3,
656
    gd_dl_silver_sparkle_2,
657
    gd_dl_silver_sparkle_2,
658
    gd_dl_silver_sparkle_1,
659
    gd_dl_silver_sparkle_1,
660
    gd_dl_silver_sparkle_0,
661
    gd_dl_silver_sparkle_0,
662
    gd_dl_silver_sparkle_4_dup,
663
    gd_dl_silver_sparkle_4_dup,
664
};
665

666
UNUSED static Gfx gd_texture3_dummy_aligner1[] = {
667
    gsSPEndDisplayList(),
668
};
669

670
ALIGNED8 static Texture gd_texture_mario_face_shine[] = {
671
#include "textures/intro_raw/mario_face_shine.ia8.inc.c"
672
};
673

674
static Gfx gd_dl_mario_face_shine[] = {
675
    gsSPSetGeometryMode(G_TEXTURE_GEN),
676
    gsSPTexture(0x07C0, 0x07C0, 0, G_TX_RENDERTILE, G_ON),
677
    gsDPSetTexturePersp(G_TP_PERSP),
678
    gsDPSetTextureFilter(G_TF_BILERP),
679
    gsDPSetCombineMode(G_CC_HILITERGBA, G_CC_HILITERGBA),
680
    gsDPLoadTextureBlock(gd_texture_mario_face_shine, G_IM_FMT_IA, G_IM_SIZ_8b, 32, 32, 0,
681
                        G_TX_WRAP | G_TX_NOMIRROR, G_TX_WRAP | G_TX_NOMIRROR, 5, 5, G_TX_NOLOD, G_TX_NOLOD),
682
    gsDPPipeSync(),
683
    gsSPEndDisplayList(),
684
};
685

686
static Gfx gd_dl_rsp_init[] = {
687
    gsSPClearGeometryMode(0xFFFFFFFF),
688
    gsSPSetGeometryMode(G_SHADING_SMOOTH | G_SHADE),
689
    gsSPEndDisplayList(),
690
};
691

692
static Gfx gd_dl_rdp_init[] = {
693
    gsDPPipeSync(),
694
    gsDPSetCombineMode(G_CC_SHADE, G_CC_SHADE),
695
    gsDPSetCycleType(G_CYC_1CYCLE),
696
    gsDPSetTextureLOD(G_TL_TILE),
697
    gsDPSetTextureLUT(G_TT_NONE),
698
    gsDPSetTextureDetail(G_TD_CLAMP),
699
    gsDPSetTexturePersp(G_TP_PERSP),
700
    gsDPSetTextureFilter(G_TF_BILERP),
701
    gsDPSetTextureConvert(G_TC_FILT),
702
    gsDPSetCombineKey(G_CK_NONE),
703
    gsDPSetAlphaCompare(G_AC_NONE),
704
    gsDPSetRenderMode(G_RM_OPA_SURF, G_RM_OPA_SURF2),
705
    gsDPNoOp(),
706
    gsDPSetColorDither(G_CD_MAGICSQ),
707
    gsDPPipeSync(),
708
    gsSPEndDisplayList(),
709
};
710

711
UNUSED static u32 gd_unused_pad1 = 0;
712

713
float sGdPerspTimer = 1.0;
714

715
UNUSED static u32 gd_unused_pad2 = 0;
716

717
UNUSED static Gfx gd_texture4_dummy_aligner1[] = {
718
    gsDPPipeSync(),
719
    gsSPEndDisplayList(),
720
};
721

722
static Vtx_t gd_unused_mesh_vertex_group1[] = {
723
    {{-8,  8,  0}, 0, {  0,  0}, {  0x00, 0x00, 0x00, 0xFF}},
724
    {{ 8, -2,  0}, 0, {  0,  0}, {  0x00, 0x00, 0x00, 0xFF}},
725
    {{ 2, -8,  0}, 0, {  0,  0}, {  0x00, 0x00, 0x00, 0xFF}},
726
};
727

728
static Vtx_t gd_unused_mesh_vertex_group2[] = {
729
    {{-6,  6,  0}, 0, {  0,  0}, {  0xFF, 0xFF, 0xFF, 0xFF}},
730
    {{ 7, -3,  0}, 0, {  0,  0}, {  0xFF, 0x00, 0x00, 0xFF}},
731
    {{ 3, -7,  0}, 0, {  0,  0}, {  0xFF, 0x00, 0x00, 0xFF}},
732
};
733

734
UNUSED static Gfx gd_dl_unused_mesh[] = {
735
    gsDPPipeSync(),
736
    gsDPSetRenderMode(G_RM_OPA_SURF, G_RM_OPA_SURF2),
737
    gsSPClearGeometryMode(0xFFFFFFFF),
738
    gsSPSetGeometryMode(G_SHADING_SMOOTH | G_SHADE),
739
    gsDPPipeSync(),
740
    gsSPVertex(gd_unused_mesh_vertex_group1, 3, 0),
741
    gsSP1Triangle(0,  1,  2, 0x0),
742
    gsSPVertex(gd_unused_mesh_vertex_group2, 3, 0),
743
    gsSP1Triangle(0,  1,  2, 0x0),
744
    gsSPEndDisplayList(),
745
};
746

747
static Gfx gd_dl_sprite_start_tex_block[] = {
748
    gsDPPipeSync(),
749
    gsDPSetCycleType(G_CYC_1CYCLE),
750
    gsSPTexture(0x8000, 0x8000, 0, G_TX_RENDERTILE, G_ON),
751
    gsDPSetAlphaCompare(G_AC_THRESHOLD),
752
    gsDPSetBlendColor(0, 0, 0, 1),
753
    gsDPSetRenderMode(G_RM_AA_ZB_TEX_EDGE, G_RM_NOOP2),
754
    gsDPSetCombineMode(G_CC_DECALRGBA, G_CC_DECALRGBA),
755
    gsDPSetTextureFilter(G_TF_BILERP),
756
    gsDPSetTexturePersp(G_TP_NONE),
757
    gsSPEndDisplayList(),
758
};
759

760
// linker (ROM addresses)
761
extern u8 _gd_dynlistsSegmentRomStart[];
762
extern u8 _gd_dynlistsSegmentRomEnd[];
763

764
// forward declarations
765
u32 new_gddl_from(Gfx *, s32);
766
void gd_setup_cursor(struct ObjGroup *);
767
void parse_p1_controller(void);
768
void update_cursor(void);
769
void update_view_and_dl(struct ObjView *);
770
static void update_render_mode(void);
771
void gddl_is_loading_shine_dl(s32);
772
void func_801A3370(f32, f32, f32);
773
void gd_put_sprite(u16 *, s32, s32, s32, s32);
774
void reset_cur_dl_indices(void);
775

776
// TODO: make a gddl_num_t?
777

778
u32 get_alloc_mem_amt(void) {
779
#ifdef USE_SYSTEM_MALLOC
780
    return 0;
781
#else
782
    return sAllocMemory;
783
#endif
784
}
785

786
/**
787
 * Returns the current time
788
 */
789
s32 gd_get_ostime(void) {
790
    return osGetTime();
791
}
792

793
f32 get_time_scale(void) {
794
    return sTimeScaleFactor;
795
}
796

797
void dump_disp_list(void) {
798
    gd_printf("%d\n", sCurrentGdDl->id);
799
    gd_printf("Vtx=%d/%d, Mtx=%d/%d, Light=%d/%d, Gfx=%d/%d\n", sCurrentGdDl->curVtxIdx,
800
              sCurrentGdDl->totalVtx, sCurrentGdDl->curMtxIdx, sCurrentGdDl->totalMtx,
801
              sCurrentGdDl->curLightIdx, sCurrentGdDl->totalLights, sCurrentGdDl->curGfxIdx,
802
              sCurrentGdDl->totalGfx);
803
}
804

805
/**
806
 * Increments the current display list's Gfx index list and returns a pointer to the next Gfx element
807
 */
808
static Gfx *next_gfx(void) {
809
    if (sCurrentGdDl->curGfxIdx >= sCurrentGdDl->totalGfx) {
810
        dump_disp_list();
811
        fatal_printf("Gfx list overflow");
812
    }
813

814
    return &sCurrentGdDl->gfx[sCurrentGdDl->curGfxIdx++];
815
}
816

817
/**
818
 * Increments the current display list's Light index list and returns a pointer to the next Light element
819
 */
820
static Lights4 *next_light(void) {
821
    if (sCurrentGdDl->curLightIdx >= sCurrentGdDl->totalLights) {
822
        dump_disp_list();
823
        fatal_printf("Light list overflow");
824
    }
825

826
    return &sCurrentGdDl->light[sCurrentGdDl->curLightIdx++];
827
}
828

829
/**
830
 * Increments the current display list's matrix index list and returns a pointer to the next matrix element
831
 */
832
static Mtx *next_mtx(void) {
833
    if (sCurrentGdDl->curMtxIdx >= sCurrentGdDl->totalMtx) {
834
        dump_disp_list();
835
        fatal_printf("Mtx list overflow");
836
    }
837

838
    return &sCurrentGdDl->mtx[sCurrentGdDl->curMtxIdx++];
839
}
840

841
/**
842
 * Increments the current display list's vertex index list and returns a pointer to the next vertex element
843
 */
844
static Vtx *next_vtx(void) {
845
    if (sCurrentGdDl->curVtxIdx >= sCurrentGdDl->totalVtx) {
846
        dump_disp_list();
847
        fatal_printf("Vtx list overflow");
848
    }
849

850
    return &sCurrentGdDl->vtx[sCurrentGdDl->curVtxIdx++];
851
}
852

853
/**
854
 * Increments the current display list's viewport list and returns a pointer to the next viewport element
855
 */
856
static Vp *next_vp(void) {
857
    if (sCurrentGdDl->curVpIdx >= sCurrentGdDl->totalVp) {
858
        dump_disp_list();
859
        fatal_printf("Vp list overflow");
860
    }
861

862
    return &sCurrentGdDl->vp[sCurrentGdDl->curVpIdx++];
863
}
864

865
/* 249AAC -> 249AEC */
866
f64 gd_sin_d(f64 x) {
867
    return sinf(x);
868
}
869

870
/* 249AEC -> 249B2C */
871
f64 gd_cos_d(f64 x) {
872
    return cosf(x);
873
}
874

875
/* 249B2C -> 249BA4 */
876
f64 gd_sqrt_d(f64 x) {
877
    if (x < 1.0e-7) {
878
        return 0.0;
879
    }
880
    return sqrtf(x);
881
}
882

883
/**
884
 * Unused
885
 */
886
f64 stub_renderer_1(UNUSED f64 x) {
887
    return 0.0;
888
}
889

890
/* 249BCC -> 24A19C */
891
void gd_printf(const char *format, ...) {
892
    s32 i;
893
    UNUSED u32 pad158;
894
    char c;
895
    char f;
896
    UNUSED u32 pad150;
897
    char buf[0x100];
898
    char *csr = buf;
899
    char spec[8];    // specifier string
900
    UNUSED u32 pad40;
901
    union PrintVal val;
902
    va_list args;
903

904
    *csr = '\0';
905
    va_start(args, format);
906
    while ((c = *format++)) {
907
        switch (c) {
908
            case '%':
909
                f = *format++;
910
                i = 0;
911
                // handle f32 precision formatter (N.Mf)
912
                if (f >= '0' && f <= '9') {
913
                    for (i = 0; i < 3; i++) {
914
                        if ((f >= '0' && f <= '9') || f == '.') {
915
                            spec[i] = f;
916
                        } else {
917
                            break;
918
                        }
919

920
                        f = *format++;
921
                    }
922
                }
923

924
                spec[i] = f;
925
                i++;
926
                spec[i] = '\0';
927

928
                switch ((c = spec[0])) {
929
                    case 'd':
930
                        val.i = va_arg(args, s32);
931
                        csr = sprint_val_withspecifiers(csr, val, spec);
932
                        break;
933
                    case 'x':
934
                        val.i = va_arg(args, u32);
935
                        csr = sprint_val_withspecifiers(csr, val, spec);
936
                        break;
937
                    case '%':
938
                        *csr = '%';
939
                        csr++;
940
                        *csr = '\0';
941
                        break;
942
                        break; // needed to match
943
                    case 'f':
944
                        val.f = (f32) va_arg(args, double);
945
                        csr = sprint_val_withspecifiers(csr, val, spec);
946
                        break;
947
                    case 's':
948
                        csr = gd_strcat(csr, va_arg(args, char *));
949
                        break;
950
                    case 'c':
951
                        //! @bug formatter 'c' uses `s32` for va_arg instead of `char`
952
                        *csr = va_arg(args, s32);
953
                        csr++;
954
                        *csr = '\0';
955
                        break;
956
                    default:
957
                        if (spec[3] == 'f') {
958
                            val.f = (f32) va_arg(args, double);
959
                            csr = sprint_val_withspecifiers(csr, val, spec);
960
                        }
961
                        break;
962
                }
963
                break;
964
            case '\\':
965
                *csr = '\\';
966
                csr++;
967
                *csr = '\0';
968
                break;
969
            case '\n':
970
                *csr = '\n';
971
                csr++;
972
                *csr = '\0';
973
                break;
974
            default:
975
                *csr = c;
976
                csr++;
977
                *csr = '\0';
978
                break;
979
        }
980
    }
981
    va_end(args);
982

983
    *csr = '\0';
984
    if (csr - buf >= ARRAY_COUNT(buf) - 1) {
985
        fatal_printf("printf too long");
986
    }
987
}
988

989
/* 24A19C -> 24A1D4 */
990
void gd_exit(UNUSED s32 code) {
991
    gd_printf("exit\n");
992
    while (TRUE) {
993
    }
994
}
995

996
/* 24A1D4 -> 24A220; orig name: func_8019BA04 */
997
void gd_free(void *ptr) {
998
#ifdef USE_SYSTEM_MALLOC
999
    sFreeFn(ptr);
1000
#else
1001
    sAllocMemory -= gd_free_mem(ptr);
1002
#endif
1003
}
1004

1005
#ifndef USE_SYSTEM_MALLOC
1006
/* 24A220 -> 24A318 */
1007
void *gd_allocblock(u32 size) {
1008
    void *block; // 1c
1009

1010
    size = ALIGN(size, 8);
1011
    if ((sMemBlockPoolUsed + size) > sMemBlockPoolSize) {
1012
        gd_printf("gd_allocblock(): Failed request: %dk (%d bytes)\n", size / 1024, size);
1013
        gd_printf("gd_allocblock(): Heap usage: %dk (%d bytes) \n", sMemBlockPoolUsed / 1024,
1014
                  sMemBlockPoolUsed);
1015
        print_all_memtrackers();
1016
        mem_stats();
1017
        fatal_printf("exit");
1018
    }
1019

1020
    block = sMemBlockPoolBase + sMemBlockPoolUsed;
1021
    sMemBlockPoolUsed += size;
1022
    return block;
1023
}
1024
#endif
1025

1026
/* 24A318 -> 24A3E8 */
1027
void *gd_malloc(u32 size, UNUSED u8 perm) {
1028
#ifdef USE_SYSTEM_MALLOC
1029
    return sAllocFn(size);
1030
#else
1031
    void *ptr; // 1c
1032
    size = ALIGN(size, 8);
1033
    ptr = gd_request_mem(size, perm);
1034

1035
    if (ptr == NULL) {
1036
        gd_printf("gd_malloc(): Failed request: %dk (%d bytes)\n", size / 1024, size);
1037
        gd_printf("gd_malloc(): Heap usage: %dk (%d bytes) \n", sAllocMemory / 1024, sAllocMemory);
1038
        print_all_memtrackers();
1039
        mem_stats();
1040
        return NULL;
1041
    }
1042

1043
    sAllocMemory += size;
1044

1045
    return ptr;
1046
#endif
1047
}
1048

1049
/* 24A3E8 -> 24A420; orig name: func_8019BC18 */
1050
void *gd_malloc_perm(u32 size) {
1051
    return gd_malloc(size, PERM_G_MEM_BLOCK);
1052
}
1053

1054
/* 24A420 -> 24A458; orig name: func_8019BC50 */
1055
void *gd_malloc_temp(u32 size) {
1056
    return gd_malloc(size, TEMP_G_MEM_BLOCK);
1057
}
1058

1059
/* 24A458 -> 24A4A4 */
1060
void *Unknown8019BC88(u32 size, u32 count) {
1061
    return gd_malloc_perm(size * count);
1062
}
1063

1064
/* 24A4A4 -> 24A4DC */
1065
void *Unknown8019BCD4(u32 size) {
1066
    return gd_malloc_perm(size);
1067
}
1068

1069
/* 24A4DC -> 24A598 */
1070
void draw_indexed_dl(s32 dlNum, s32 gfxIdx) {
1071
    Gfx *dl;
1072

1073
    if (gfxIdx != 0) {
1074
        dl = sGdDLArray[dlNum]->dlptr[gfxIdx - 1];  // multiple display lists (determined by frame)
1075
    } else {
1076
        dl = sGdDLArray[dlNum]->gfx;  // only one display list
1077
    }
1078
    gSPDisplayList(next_gfx(), GD_VIRTUAL_TO_PHYSICAL(dl));
1079
}
1080

1081
/* 24A598 -> 24A610; orig name: func_8019BDC8 */
1082
void branch_cur_dl_to_num(s32 dlNum) {
1083
    Gfx *dl;
1084
    UNUSED u32 pad[2];
1085

1086
    dl = sGdDLArray[dlNum]->gfx;
1087
    gSPDisplayList(next_gfx(), GD_VIRTUAL_TO_PHYSICAL(dl));
1088
}
1089

1090
/**
1091
 * Unused (not called)
1092
 */
1093
Gfx *get_dl_gfx(s32 num) {
1094
    return sGdDLArray[num]->gfx;
1095
}
1096

1097
/**
1098
 * Creates `ObjShape`s for the stars and sparkles
1099
 */
1100
void setup_stars(void) {
1101
    gShapeRedStar = make_shape(0, "redstar");
1102
    gShapeRedStar->dlNums[0] = new_gddl_from(NULL, 0);
1103
    gShapeRedStar->dlNums[1] = gShapeRedStar->dlNums[0];
1104
    sGdDLArray[gShapeRedStar->dlNums[0]]->dlptr = gd_red_star_dl_array;
1105
    sGdDLArray[gShapeRedStar->dlNums[1]]->dlptr = gd_red_star_dl_array;
1106

1107
    gShapeSilverStar = make_shape(0, "silverstar");
1108
    gShapeSilverStar->dlNums[0] = new_gddl_from(NULL, 0);
1109
    gShapeSilverStar->dlNums[1] = gShapeSilverStar->dlNums[0];
1110
    sGdDLArray[gShapeSilverStar->dlNums[0]]->dlptr = gd_silver_star_dl_array;
1111
    sGdDLArray[gShapeSilverStar->dlNums[1]]->dlptr = gd_silver_star_dl_array;
1112

1113
    // make_shape names of the dl array they call are misnamed (swapped)
1114
    // "sspark" calls red sparkles and "rspark" calls silver sparkles
1115
    gShapeRedSpark = make_shape(0, "sspark");
1116
    gShapeRedSpark->dlNums[0] = new_gddl_from(NULL, 0);
1117
    gShapeRedSpark->dlNums[1] = gShapeRedSpark->dlNums[0];
1118
    sGdDLArray[gShapeRedSpark->dlNums[0]]->dlptr = gd_red_sparkle_dl_array;
1119
    sGdDLArray[gShapeRedSpark->dlNums[1]]->dlptr = gd_red_sparkle_dl_array;
1120

1121
    gShapeSilverSpark = make_shape(0, "rspark");
1122
    gShapeSilverSpark->dlNums[0] = new_gddl_from(NULL, 0);
1123
    gShapeSilverSpark->dlNums[1] = gShapeSilverSpark->dlNums[0];
1124
    sGdDLArray[gShapeSilverSpark->dlNums[0]]->dlptr = gd_silver_sparkle_dl_array;
1125
    sGdDLArray[gShapeSilverSpark->dlNums[1]]->dlptr = gd_silver_sparkle_dl_array;
1126
}
1127

1128
/* 24A8D0 -> 24AA40 */
1129
void setup_timers(void) {
1130
    start_timer("updateshaders");
1131
    stop_timer("updateshaders");
1132
    start_timer("childpos");
1133
    stop_timer("childpos");
1134
    start_timer("netupd");
1135
    stop_timer("netupd");
1136
    start_timer("drawshape2d");
1137
    stop_timer("drawshape2d");
1138

1139
    start_timer("drawshape");
1140
    start_timer("drawobj");
1141
    start_timer("drawscene");
1142
    start_timer("camsearch");
1143
    start_timer("move_animators");
1144
    start_timer("move_nets");
1145
    stop_timer("move_animators");
1146
    stop_timer("move_nets");
1147
    stop_timer("drawshape");
1148
    stop_timer("drawobj");
1149
    stop_timer("drawscene");
1150
    stop_timer("camsearch");
1151

1152
    start_timer("move_bones");
1153
    stop_timer("move_bones");
1154
    start_timer("move_skin");
1155
    stop_timer("move_skin");
1156
    start_timer("draw1");
1157
    stop_timer("draw1");
1158
    start_timer("dynamics");
1159
    stop_timer("dynamics");
1160
}
1161

1162
/* 24AA40 -> 24AA58 */
1163
void Unknown8019C270(u8 *buf) {
1164
    gGdStreamBuffer = buf;
1165
}
1166

1167
/* 24AA58 -> 24AAA8 */
1168
void Unknown8019C288(s32 stickX, s32 stickY) {
1169
    struct GdControl *ctrl = &gGdCtrl; // 4
1170

1171
    ctrl->stickXf = (f32) stickX;
1172
    ctrl->stickYf = (f32)(stickY / 2);
1173
}
1174

1175
#ifndef USE_SYSTEM_MALLOC
1176
/* 24AAA8 -> 24AAE0; orig name: func_8019C2D8 */
1177
void gd_add_to_heap(void *addr, u32 size) {
1178
    // TODO: is this `1` for permanence special?
1179
    gd_add_mem_to_heap(size, addr, 1);
1180
}
1181
#endif
1182

1183
#ifdef USE_SYSTEM_MALLOC
1184
void gdm_init(void *(*allocFn)(u32 size), void (*freeFn)(void *addr)) {
1185
    imin("gdm_init");
1186
    sAllocFn = allocFn;
1187
    sFreeFn = freeFn;
1188
    gd_reset_sfx();
1189
    imout();
1190
}
1191
#else
1192
/* 24AAE0 -> 24AB7C */
1193
void gdm_init(void *blockpool, u32 size) {
1194
    UNUSED u32 pad;
1195

1196
    imin("gdm_init");
1197
    // Align downwards?
1198
    size = (size - 8) & ~7;
1199
    // Align to next double word boundry?
1200
    blockpool = (void *) (((uintptr_t) blockpool + 8) & ~7);
1201
    sMemBlockPoolBase = blockpool;
1202
    sMemBlockPoolSize = size;
1203
    sMemBlockPoolUsed = 0;
1204
    sAllocMemory = 0;
1205
    init_mem_block_lists();
1206
    gd_reset_sfx();
1207
    imout();
1208
}
1209
#endif
1210

1211
/**
1212
 * Initializes the Mario head demo
1213
 */
1214
void gdm_setup(void) {
1215
    UNUSED u32 pad;
1216

1217
    imin("gdm_setup");
1218
    sYoshiSceneGrp = NULL;
1219
    sMarioSceneGrp = NULL;
1220
    sUpdateYoshiScene = FALSE;
1221
    sUpdateMarioScene = FALSE;
1222
    sCarGdDlNum = 0;
1223
    osViSetSpecialFeatures(OS_VI_GAMMA_OFF);
1224
    osCreateMesgQueue(&sGdDMAQueue, sGdMesgBuf, ARRAY_COUNT(sGdMesgBuf));
1225
    gd_init();
1226
    load_shapes2();
1227
    reset_cur_dl_indices();
1228
    setup_stars();
1229
    imout();
1230
}
1231

1232
/* 24AC18 -> 24AC2C */
1233
void stub_renderer_2(UNUSED u32 a0) {
1234
}
1235

1236
/* 24AC2C -> 24AC80; not called; orig name: Unknown8019C45C */
1237
void print_gdm_stats(void) {
1238
    stop_memtracker("total");
1239
    gd_printf("\ngdm stats:\n");
1240
    print_all_memtrackers();
1241
    mem_stats();
1242
    start_memtracker("total");
1243
}
1244

1245
/* 24AC80 -> 24AD14; orig name: func_8019C4B0 */
1246
struct ObjView *make_view_withgrp(char *name, struct ObjGroup *grp) {
1247
    struct ObjView *view = make_view(name, (VIEW_DRAW | VIEW_ALLOC_ZBUF | VIEW_MOVEMENT), 1, 0, 0, 320, 240, grp);
1248
    UNUSED struct ObjGroup *viewgrp = make_group(2, grp, view);
1249

1250
    view->lights = gGdLightGroup;
1251
    return view;
1252
}
1253

1254
/* 24AD14 -> 24AEB8 */
1255
void gdm_maketestdl(s32 id) {
1256
    UNUSED u32 pad[3];
1257

1258
    imin("gdm_maketestdl");
1259
    switch (id) {
1260
        case 0:
1261
            sYoshiSceneView = make_view_withgrp("yoshi_scene", sYoshiSceneGrp);
1262
            break;
1263
        case 1:
1264
            reset_nets_and_gadgets(sYoshiSceneGrp);
1265
            break;
1266
        case 2: // normal Mario head
1267
            if (sMarioSceneGrp == NULL) {
1268
                load_mario_head(animate_mario_head_normal);
1269
                sMarioSceneGrp = gMarioFaceGrp; // gMarioFaceGrp set by load_mario_head
1270
                gd_setup_cursor(NULL);
1271
            }
1272
            sMSceneView = make_view_withgrp("mscene", sMarioSceneGrp);
1273
            break;
1274
        case 3: // game over Mario head
1275
            if (sMarioSceneGrp == NULL) {
1276
                load_mario_head(animate_mario_head_gameover);
1277
                sMarioSceneGrp = gMarioFaceGrp;
1278
                gd_setup_cursor(NULL);
1279
            }
1280
            sMSceneView = make_view_withgrp("mscene", sMarioSceneGrp);
1281
            break;
1282
        case 4:
1283
            sCarSceneView = make_view_withgrp("car_scene", sCarSceneGrp);
1284
            break;
1285
        case 5:
1286
            reset_nets_and_gadgets(sCarSceneGrp);
1287
            break;
1288
        default:
1289
            fatal_printf("gdm_maketestdl(): unknown dl");
1290
    }
1291
    imout();
1292
}
1293

1294
/* 24AEB8 -> 24AED0 */
1295
void set_time_scale(f32 factor) {
1296
    sTimeScaleFactor = factor;
1297
}
1298

1299
/* 24AED0 -> 24AF04 */
1300
void Unknown8019C840(void) {
1301
    gd_printf("\n");
1302
    print_all_timers();
1303
}
1304

1305
/**
1306
 * Runs every frame at V-blank. Handles input and updates state.
1307
 */
1308
void gd_vblank(void) {
1309
    gd_sfx_update();
1310
    if (sUpdateYoshiScene) {
1311
        apply_to_obj_types_in_group(OBJ_TYPE_NETS, (applyproc_t) convert_net_verts, sYoshiSceneGrp);
1312
    }
1313
    if (sUpdateMarioScene) {
1314
        apply_to_obj_types_in_group(OBJ_TYPE_NETS, (applyproc_t) convert_net_verts, sMarioSceneGrp);
1315
    }
1316
    sUpdateYoshiScene = FALSE;
1317
    sUpdateMarioScene = FALSE;
1318
    gGdFrameBufNum ^= 1;
1319
    reset_cur_dl_indices();
1320
    parse_p1_controller();
1321
    update_cursor();
1322
}
1323

1324
/**
1325
 * Copies the player1 controller data from p1cont to sGdContPads[0].
1326
 */
1327
void gd_copy_p1_contpad(OSContPad *p1cont) {
1328
    u32 i;                                    // 24
1329
    u8 *src = (u8 *) p1cont;             // 20
1330
    u8 *dest = (u8 *) &sGdContPads[0]; // 1c
1331

1332
    for (i = 0; i < sizeof(OSContPad); i++) {
1333
        dest[i] = src[i];
1334
    }
1335

1336
    if (p1cont->button & Z_TRIG) {
1337
        print_all_timers();
1338
    }
1339
}
1340

1341
/* 24B058 -> 24B088; orig name: gd_sfx_to_play */
1342
s32 gd_sfx_to_play(void) {
1343
    return gd_new_sfx_to_play();
1344
}
1345

1346
/* 24B088 -> 24B418 */
1347
Gfx *gdm_gettestdl(s32 id) {
1348
    struct GdObj *dobj;
1349
    struct GdDisplayList *gddl;
1350
    UNUSED u32 pad28[2];
1351
    struct GdVec3f vec;
1352

1353
    start_timer("dlgen");
1354
    vec.x = vec.y = vec.z = 0.0f;
1355
    gddl = NULL;
1356

1357
    switch (id) {
1358
        case 0:
1359
            if (sYoshiSceneView == NULL) {
1360
                fatal_printf("gdm_gettestdl(): DL number %d undefined", id);
1361
            }
1362
            //! @bug Code treats `sYoshiSceneView` as group; not called in game though
1363
            apply_to_obj_types_in_group(OBJ_TYPE_VIEWS, (applyproc_t) update_view,
1364
                                        (struct ObjGroup *) sYoshiSceneView);
1365
            dobj = d_use_obj("yoshi_scene");
1366
            gddl = sGdDLArray[((struct ObjView *) dobj)->gdDlNum];
1367
            sUpdateYoshiScene = TRUE;
1368
            break;
1369
        case 1:
1370
            if (sYoshiSceneGrp == NULL) {
1371
                fatal_printf("gdm_gettestdl(): DL number %d undefined", id);
1372
            }
1373
            dobj = d_use_obj("yoshi_sh_l1");
1374
            gddl = sGdDLArray[((struct ObjShape *) dobj)->dlNums[gGdFrameBufNum]];
1375
            sUpdateYoshiScene = TRUE;
1376
            break;
1377
        case GD_SCENE_REGULAR_MARIO:
1378
        case GD_SCENE_DIZZY_MARIO:
1379
            setup_timers();
1380
            update_view_and_dl(sMSceneView);
1381
            if (sHandView != NULL) {
1382
                update_view_and_dl(sHandView);
1383
            }
1384
            sCurrentGdDl = sMHeadMainDls[gGdFrameBufNum];
1385
            gSPEndDisplayList(next_gfx());
1386
            gddl = sCurrentGdDl;
1387
            sUpdateMarioScene = TRUE;
1388
            break;
1389
        case 4:
1390
            if (sCarSceneView == NULL) {
1391
                fatal_printf("gdm_gettestdl(): DL number %d undefined", id);
1392
            }
1393
            //! @bug Code treats `sCarSceneView` as group; not called in game though
1394
            apply_to_obj_types_in_group(OBJ_TYPE_VIEWS, (applyproc_t) update_view,
1395
                                        (struct ObjGroup *) sCarSceneView);
1396
            dobj = d_use_obj("car_scene");
1397
            gddl = sGdDLArray[((struct ObjView *) dobj)->gdDlNum];
1398
            sUpdateCarScene = TRUE;
1399
            break;
1400
        case 5:
1401
            sActiveView = sScreenView;
1402
            set_gd_mtx_parameters(G_MTX_MODELVIEW | G_MTX_LOAD | G_MTX_PUSH);
1403
            dobj = d_use_obj("testnet2");
1404
            sCarGdDlNum = gd_startdisplist(8);
1405

1406
            if (sCarGdDlNum == 0) {
1407
                fatal_printf("no memory for car DL\n");
1408
            }
1409
            apply_obj_draw_fn(dobj);
1410
            gd_enddlsplist_parent();
1411
            gddl = sGdDLArray[sCarGdDlNum];
1412
            sUpdateCarScene = TRUE;
1413
            break;
1414
        default:
1415
            fatal_printf("gdm_gettestdl(): %d out of range", id);
1416
    }
1417

1418
    if (gddl == NULL) {
1419
        fatal_printf("no display list");
1420
    }
1421
    stop_timer("dlgen");
1422
    return (void *) osVirtualToPhysical(gddl->gfx);
1423
}
1424

1425
/* 24B418 -> 24B4CC; not called */
1426
void gdm_getpos(s32 id, struct GdVec3f *dst) {
1427
    struct GdObj *dobj; // 1c
1428
    switch (id) {
1429
        case 5:
1430
            set_gd_mtx_parameters(G_MTX_MODELVIEW | G_MTX_LOAD | G_MTX_PUSH);
1431
            dobj = d_use_obj("testnet2");
1432
            dst->x = ((struct ObjNet *) dobj)->worldPos.x;
1433
            dst->y = ((struct ObjNet *) dobj)->worldPos.y;
1434
            dst->z = ((struct ObjNet *) dobj)->worldPos.z;
1435
            break;
1436
        default:
1437
            fatal_printf("gdm_getpos(): %d out of range", id);
1438
    }
1439
    return;
1440
}
1441

1442
/**
1443
 * Clamps the coordinates so that they are within the active view
1444
 */
1445
static void clamp_coords_to_active_view(f32 *x, f32 *y) {
1446
    struct ObjView *view = sActiveView;
1447

1448
    if (*x < 0.0f) {
1449
        *x = 0.0f;
1450
    } else if (*x > view->lowerRight.x) {
1451
        *x = view->lowerRight.x;
1452
    }
1453

1454
    if (*y < 0.0f) {
1455
        *y = 0.0f;
1456
    } else if (*y > view->lowerRight.y) {
1457
        *y = view->lowerRight.y;
1458
    }
1459
}
1460

1461
/* 24B5A8 -> 24B5D4; orig name: func_8019CDD8 */
1462
void fatal_no_dl_mem(void) {
1463
    fatal_printf("Out of DL mem\n");
1464
}
1465

1466
/* 24B5D4 -> 24B6AC */
1467
struct GdDisplayList *alloc_displaylist(u32 id) {
1468
    struct GdDisplayList *gdDl;
1469

1470
    gdDl = gd_malloc_perm(sizeof(struct GdDisplayList));
1471
    if (gdDl == NULL) {
1472
        fatal_no_dl_mem();
1473
    }
1474

1475
    gdDl->number = sGdDlCount++;
1476
    if (sGdDlCount >= MAX_GD_DLS) {
1477
        fatal_printf("alloc_displaylist() too many display lists %d (MAX %d)", sGdDlCount + 1,
1478
                     MAX_GD_DLS);
1479
    }
1480
    sGdDLArray[gdDl->number] = gdDl;
1481
    gdDl->id = id;
1482
    return gdDl;
1483
}
1484

1485
/* 24B6AC -> 24B7A0; orig name: func_8019CEDC */
1486
void cpy_remaining_gddl(struct GdDisplayList *dst, struct GdDisplayList *src) {
1487
    dst->vtx = &DL_CURRENT_VTX(src);
1488
    dst->mtx = &DL_CURRENT_MTX(src);
1489
    dst->light = &DL_CURRENT_LIGHT(src);
1490
    dst->gfx = &DL_CURRENT_GFX(src);
1491
    dst->vp = &DL_CURRENT_VP(src);
1492
    dst->totalVtx = src->totalVtx - src->curVtxIdx;
1493
    dst->totalMtx = src->totalMtx - src->curMtxIdx;
1494
    dst->totalLights = src->totalLights - src->curLightIdx;
1495
    dst->totalGfx = src->totalGfx - src->curGfxIdx;
1496
    dst->totalVp = src->totalVp - src->curVpIdx;
1497
    dst->curVtxIdx = 0;
1498
    dst->curMtxIdx = 0;
1499
    dst->curLightIdx = 0;
1500
    dst->curGfxIdx = 0;
1501
    dst->curVpIdx = 0;
1502
}
1503

1504
/* 24B7A0 -> 24B7F8; orig name: func_8019CFD0 */
1505
struct GdDisplayList *create_child_gdl(s32 id, struct GdDisplayList *srcDl) {
1506
    struct GdDisplayList *newDl;
1507

1508
    newDl = alloc_displaylist(id);
1509
    newDl->parent = srcDl;
1510
    cpy_remaining_gddl(newDl, srcDl);
1511
//! @bug No return statement, despite return value being used.
1512
//!      Goddard lucked out that `v0` return from alloc_displaylist()
1513
//!      is not overwriten, as that pointer is what should be returned
1514
#ifdef AVOID_UB
1515
    return newDl;
1516
#endif
1517
}
1518

1519
/* 24B7F8 -> 24BA48; orig name: func_8019D028 */
1520
struct GdDisplayList *new_gd_dl(s32 id, s32 gfxs, s32 verts, s32 mtxs, s32 lights, s32 vps) {
1521
    struct GdDisplayList *dl; // 24
1522

1523
    dl = alloc_displaylist(id);
1524
    dl->parent = NULL;
1525
    if (verts == 0) {
1526
        verts = 1;
1527
    }
1528
    dl->curVtxIdx = 0;
1529
    dl->totalVtx = verts;
1530
    if ((dl->vtx = gd_malloc_perm(verts * sizeof(Vtx))) == NULL) {
1531
        fatal_no_dl_mem();
1532
    }
1533

1534
    if (mtxs == 0) {
1535
        mtxs = 1;
1536
    }
1537
    dl->curMtxIdx = 0;
1538
    dl->totalMtx = mtxs;
1539
    if ((dl->mtx = gd_malloc_perm(mtxs * sizeof(Mtx))) == NULL) {
1540
        fatal_no_dl_mem();
1541
    }
1542

1543
    if (lights == 0) {
1544
        lights = 1;
1545
    }
1546
    dl->curLightIdx = 0;
1547
    dl->totalLights = lights;
1548
    if ((dl->light = gd_malloc_perm(lights * sizeof(Lights4))) == NULL) {
1549
        fatal_no_dl_mem();
1550
    }
1551

1552
    if (gfxs == 0) {
1553
        gfxs = 1;
1554
    }
1555
    dl->curGfxIdx = 0;
1556
    dl->totalGfx = gfxs;
1557
    if ((dl->gfx = gd_malloc_perm(gfxs * sizeof(Gfx))) == NULL) {
1558
        fatal_no_dl_mem();
1559
    }
1560

1561
    if (vps == 0) {
1562
        vps = 1;
1563
    }
1564
    dl->curVpIdx = 0;
1565
    dl->totalVp = vps;
1566
    if ((dl->vp = gd_malloc_perm(vps * sizeof(Vp))) == NULL) {
1567
        fatal_no_dl_mem();
1568
    }
1569

1570
    dl->dlptr = NULL;
1571
    return dl;
1572
}
1573

1574
/* 24BA48 -> 24BABC; not called */
1575
void gd_rsp_init(void) {
1576
    gSPDisplayList(next_gfx(), osVirtualToPhysical(&gd_dl_rsp_init));
1577
    gDPPipeSync(next_gfx());
1578
}
1579

1580
/* 24BABC -> 24BB30; not called */
1581
void gd_rdp_init(void) {
1582
    gSPDisplayList(next_gfx(), osVirtualToPhysical(&gd_dl_rdp_init));
1583
    gDPPipeSync(next_gfx());
1584
}
1585

1586
/* 24BB30 -> 24BED8; orig name: func_8019D360 */
1587
void gd_draw_rect(f32 ulx, f32 uly, f32 lrx, f32 lry) {
1588
    clamp_coords_to_active_view(&ulx, &uly);
1589
    clamp_coords_to_active_view(&lrx, &lry);
1590

1591
    if (lrx > ulx && lry > uly) {
1592
        gDPFillRectangle(next_gfx(), (u32)(sActiveView->upperLeft.x + ulx),
1593
                         (u32)(uly + sActiveView->upperLeft.y), (u32)(sActiveView->upperLeft.x + lrx),
1594
                         (u32)(lry + sActiveView->upperLeft.y));
1595
    }
1596

1597
    gDPPipeSync(next_gfx());
1598
    gDPSetCycleType(next_gfx(), G_CYC_1CYCLE);
1599
    gDPSetRenderMode(next_gfx(), G_RM_AA_ZB_OPA_INTER, G_RM_NOOP2);
1600
}
1601

1602
/* 24BED8 -> 24CAC8; orig name: func_8019D708 */
1603
void gd_draw_border_rect(f32 ulx, f32 uly, f32 lrx, f32 lry) {
1604
    clamp_coords_to_active_view(&ulx, &uly);
1605
    clamp_coords_to_active_view(&lrx, &lry);
1606

1607
    if (lrx > ulx && lry > uly) {
1608
        gDPFillRectangle(
1609
            next_gfx(), (u32)(sActiveView->upperLeft.x + ulx), (u32)(uly + sActiveView->upperLeft.y),
1610
            (u32)(sActiveView->upperLeft.x + ulx + 5.0f), (u32)(lry + sActiveView->upperLeft.y));
1611
        gDPFillRectangle(next_gfx(), (u32)(sActiveView->upperLeft.x + lrx - 5.0f),
1612
                         (u32)(uly + sActiveView->upperLeft.y), (u32)(sActiveView->upperLeft.x + lrx),
1613
                         (u32)(lry + sActiveView->upperLeft.y));
1614
        gDPFillRectangle(next_gfx(), (u32)(sActiveView->upperLeft.x + ulx),
1615
                         (u32)(uly + sActiveView->upperLeft.y), (u32)(sActiveView->upperLeft.x + lrx),
1616
                         (u32)(uly + sActiveView->upperLeft.y + 5.0f));
1617
        gDPFillRectangle(next_gfx(), (u32)(sActiveView->upperLeft.x + ulx),
1618
                         (u32)(lry + sActiveView->upperLeft.y - 5.0f),
1619
                         (u32)(sActiveView->upperLeft.x + lrx), (u32)(lry + sActiveView->upperLeft.y));
1620
    }
1621

1622
    gDPPipeSync(next_gfx());
1623
    gDPSetCycleType(next_gfx(), G_CYC_1CYCLE);
1624
    gDPSetRenderMode(next_gfx(), G_RM_AA_ZB_OPA_INTER, G_RM_NOOP2);
1625
}
1626

1627
/* 24CAC8 -> 24CDB4; orig name: func_8019E2F8 */
1628
void gd_dl_set_fill(struct GdColour *colour) {
1629
    u8 r, g, b;
1630

1631
    r = colour->r * 255.0f;
1632
    g = colour->g * 255.0f;
1633
    b = colour->b * 255.0f;
1634

1635
    gDPPipeSync(next_gfx());
1636
    gDPSetCycleType(next_gfx(), G_CYC_FILL);
1637
    gDPSetRenderMode(next_gfx(), G_RM_OPA_SURF, G_RM_OPA_SURF2);
1638
    gDPSetFillColor(next_gfx(), GPACK_RGBA5551(r, g, b, 1) << 16 | GPACK_RGBA5551(r, g, b, 1));
1639
}
1640

1641
/* 24CDB4 -> 24CE10; orig name: func_8019E5E4 */
1642
void gd_dl_set_zbuffer_area(void) {
1643
    gDPSetDepthImage(next_gfx(), GD_LOWER_24(sActiveView->parent->zbuf));
1644
}
1645

1646
/* 24CE10 -> 24CF2C; orig name: func_8019E640 */
1647
void gd_set_color_fb(void) {
1648
    gDPSetColorImage(next_gfx(), G_IM_FMT_RGBA, G_IM_SIZ_16b, sActiveView->parent->lowerRight.x,
1649
                     GD_LOWER_24(sActiveView->parent->colourBufs[gGdFrameBufNum]));
1650
}
1651

1652
/* 24CF2C -> 24CFCC; orig name: func_8019E75C */
1653
void reset_cur_dl_indices(void) {
1654
    sMHeadMainDls[gGdFrameBufNum]->curGfxIdx = 0;
1655
    sCurrentGdDl = sDynamicMainDls[gGdFrameBufNum];
1656
    sCurrentGdDl->curVtxIdx = 0;
1657
    sCurrentGdDl->curMtxIdx = 0;
1658
    sCurrentGdDl->curLightIdx = 0;
1659
    sCurrentGdDl->curGfxIdx = 0;
1660
    sCurrentGdDl->curVpIdx = 0;
1661
}
1662

1663
/* 24CFCC -> 24D044; orig name: func_8019E7FC */
1664
void begin_gddl(s32 num) {
1665
    sCurrentGdDl = sGdDLArray[num];
1666
    sCurrentGdDl->curVtxIdx = 0;
1667
    sCurrentGdDl->curMtxIdx = 0;
1668
    sCurrentGdDl->curLightIdx = 0;
1669
    sCurrentGdDl->curGfxIdx = 0;
1670
    sCurrentGdDl->curVpIdx = 0;
1671
}
1672

1673
/* 24D044 -> 24D064; orig name: func_8019E874 */
1674
void stash_current_gddl(void) {
1675
    sGdDlStash = sCurrentGdDl;
1676
}
1677

1678
/* 24D064 -> 24D084; orig name: func_8019E894 */
1679
void pop_gddl_stash(void) {
1680
    sCurrentGdDl = sGdDlStash;
1681
}
1682

1683
/* 24D084 -> 24D1D4 */
1684
s32 gd_startdisplist(s32 memarea) {
1685
    D_801BB018 = 0;
1686
    D_801BB01C = 1;
1687

1688
    switch (memarea) {
1689
        case 7:  // Create new display list as a child of sStaticDl
1690
            sCurrentGdDl = create_child_gdl(0, sStaticDl);
1691
            break;
1692
        case 8:  // Use the active view's display list
1693
            if (sActiveView->id > 2) {
1694
                fatal_printf("gd_startdisplist(): Too many views to display");
1695
            }
1696

1697
            sCurrentGdDl = sViewDls[sActiveView->id][gGdFrameBufNum];
1698
            cpy_remaining_gddl(sCurrentGdDl, sCurrentGdDl->parent);
1699
            break;
1700
        default:
1701
            fatal_printf("gd_startdisplist(): Unknown memory area");
1702
            break;
1703
    }
1704
    gDPPipeSync(next_gfx());
1705

1706
    return sCurrentGdDl->number;
1707
}
1708

1709
/* 24D1D4 -> 24D23C */
1710
void gd_enddlsplist(void) {
1711
    gDPPipeSync(next_gfx());
1712
    gSPEndDisplayList(next_gfx());
1713
}
1714

1715
/* 24D23C -> 24D39C; orig name: func_8019EA6C */
1716
s32 gd_enddlsplist_parent(void) {
1717
    s32 curDlIdx = 0; // 24
1718

1719
    gDPPipeSync(next_gfx());
1720
    gSPEndDisplayList(next_gfx());
1721
    if (sCurrentGdDl->parent != NULL) {
1722
        sCurrentGdDl->parent->curVtxIdx = (sCurrentGdDl->parent->curVtxIdx + sCurrentGdDl->curVtxIdx);
1723
        sCurrentGdDl->parent->curMtxIdx = (sCurrentGdDl->parent->curMtxIdx + sCurrentGdDl->curMtxIdx);
1724
        sCurrentGdDl->parent->curLightIdx =
1725
            (sCurrentGdDl->parent->curLightIdx + sCurrentGdDl->curLightIdx);
1726
        sCurrentGdDl->parent->curGfxIdx = (sCurrentGdDl->parent->curGfxIdx + sCurrentGdDl->curGfxIdx);
1727
        sCurrentGdDl->parent->curVpIdx = (sCurrentGdDl->parent->curVpIdx + sCurrentGdDl->curVpIdx);
1728
    }
1729
    curDlIdx = sCurrentGdDl->curGfxIdx;
1730
    return curDlIdx;
1731
}
1732

1733
/* 24D39C -> 24D3D8 */
1734
void Unknown8019EBCC(s32 num, uintptr_t gfxptr) {
1735
    sGdDLArray[num]->gfx = (Gfx *) (GD_LOWER_24(gfxptr) + D_801BAF28);
1736
}
1737

1738
/* 24D3D8 -> 24D458; orig name: func_8019EC08 */
1739
u32 new_gddl_from(Gfx *dl, UNUSED s32 arg1) {
1740
    struct GdDisplayList *gddl;
1741

1742
    gddl = new_gd_dl(0, 0, 0, 0, 0, 0);
1743
    gddl->gfx = (Gfx *) (GD_LOWER_24((uintptr_t) dl) + D_801BAF28);
1744
    return gddl->number;
1745
}
1746

1747
/* 24D458 -> 24D4C4 */
1748
u32 Unknown8019EC88(Gfx *dl, UNUSED s32 arg1) {
1749
    struct GdDisplayList *gddl;
1750

1751
    gddl = new_gd_dl(0, 0, 0, 0, 0, 0);
1752
    gddl->gfx = dl;
1753
    return gddl->number;
1754
}
1755

1756
/* 24D4C4 -> 24D63C; orig name: func_8019ECF4 */
1757
void mat4_to_mtx(Mat4f *src, Mtx *dst) {
1758
#ifndef GBI_FLOATS
1759
    s32 i; // 14
1760
    s32 j; // 10
1761
    s32 w1;
1762
    s32 w2;
1763
    s32 *mtxInt = (s32 *) dst->m[0]; // s32 part
1764
    s32 *mtxFrc = (s32 *) dst->m[2]; // frac part
1765

1766
    for (i = 0; i < 4; i++) {
1767
        for (j = 0; j < 2; j++) {
1768
            w1 = (s32)((*src)[i][j * 2] * 65536.0f);
1769
            w2 = (s32)((*src)[i][j * 2 + 1] * 65536.0f);
1770
            *mtxInt = MTX_INTPART_PACK(w1, w2);
1771
            mtxInt++;
1772
            *mtxFrc = MTX_FRACPART_PACK(w1, w2);
1773
            mtxFrc++;
1774
        }
1775
    }
1776
#else
1777
    guMtxF2L(*src, dst);
1778
#endif
1779
}
1780

1781
/**
1782
 * Adds a display list operation that multiplies the current matrix with `mtx`.
1783
 */
1784
void gd_dl_mul_matrix(Mat4f *mtx) {
1785
    mat4_to_mtx(mtx, &DL_CURRENT_MTX(sCurrentGdDl));
1786
    gSPMatrix(next_gfx(), osVirtualToPhysical(&DL_CURRENT_MTX(sCurrentGdDl)), sMtxParamType | G_MTX_MUL | G_MTX_NOPUSH);
1787
    next_mtx();
1788
}
1789

1790
/**
1791
 * Adds a display list operation that replaces the current matrix with `mtx`.
1792
 */
1793
void gd_dl_load_matrix(Mat4f *mtx) {
1794
    mat4_to_mtx(mtx, &DL_CURRENT_MTX(sCurrentGdDl));
1795
    gSPMatrix(next_gfx(), osVirtualToPhysical(&DL_CURRENT_MTX(sCurrentGdDl)),
1796
              sMtxParamType | G_MTX_LOAD | G_MTX_NOPUSH);
1797
    next_mtx();
1798
}
1799

1800
/**
1801
 * Adds a display list operation that replaces the current matrix with the
1802
 * identity matrix.
1803
 */
1804
void gd_dl_load_identity_matrix(void) {
1805
    gSPMatrix(next_gfx(), osVirtualToPhysical(&sIdnMtx), sMtxParamType | G_MTX_LOAD | G_MTX_NOPUSH);
1806
}
1807

1808
/**
1809
 * Adds a display list operation that pushes the current matrix onto the matrix
1810
 * stack.
1811
 */
1812
void gd_dl_push_matrix(void) {
1813
    gSPMatrix(next_gfx(), osVirtualToPhysical(&sIdnMtx), sMtxParamType | G_MTX_MUL | G_MTX_PUSH);
1814
}
1815

1816
/**
1817
 * Adds a display list operation that pops a matrix from the matrix stack.
1818
 */
1819
void gd_dl_pop_matrix(void) {
1820
    gSPPopMatrix(next_gfx(), sMtxParamType);
1821
}
1822

1823
/**
1824
 * Adds a display list operation that translates the current matrix by `x`, `y`, and `z`.
1825
 */
1826
void gd_dl_mul_trans_matrix(f32 x, f32 y, f32 z) {
1827
    guTranslate(&DL_CURRENT_MTX(sCurrentGdDl), x, y, z);
1828
    gSPMatrix(next_gfx(), osVirtualToPhysical(&DL_CURRENT_MTX(sCurrentGdDl)), sMtxParamType | G_MTX_MUL | G_MTX_NOPUSH);
1829
    next_mtx();
1830
}
1831

1832
/**
1833
 * Adds a display list operation that loads a translation matrix.
1834
 */
1835
void gd_dl_load_trans_matrix(f32 x, f32 y, f32 z) {
1836
    guTranslate(&DL_CURRENT_MTX(sCurrentGdDl), x, y, z);
1837
    gSPMatrix(next_gfx(), osVirtualToPhysical(&DL_CURRENT_MTX(sCurrentGdDl)),
1838
              sMtxParamType | G_MTX_LOAD | G_MTX_NOPUSH);
1839
    next_mtx();
1840
}
1841

1842
/**
1843
 * Adds a display list operation that scales the current matrix by `x`, `y`, and `z`.
1844
 */
1845
void gd_dl_scale(f32 x, f32 y, f32 z) {
1846
    Mat4f mtx;
1847
    struct GdVec3f vec;
1848

1849
    vec.x = x;
1850
    vec.y = y;
1851
    vec.z = z;
1852
    gd_set_identity_mat4(&mtx);
1853
    gd_scale_mat4f_by_vec3f(&mtx, &vec);
1854
    gd_dl_mul_matrix(&mtx);
1855
}
1856

1857
/* 24DA94 -> 24DAE8 */
1858
void func_8019F2C4(f32 arg0, s8 arg1) {
1859
    Mat4f mtx; // 18
1860

1861
    gd_set_identity_mat4(&mtx);
1862
    gd_absrot_mat4(&mtx, arg1 - 120, -arg0);
1863
    gd_dl_mul_matrix(&mtx);
1864
}
1865

1866
/* 24DAE8 -> 24E1A8 */
1867
void gd_dl_lookat(struct ObjCamera *cam, f32 arg1, f32 arg2, f32 arg3, f32 arg4, f32 arg5, f32 arg6, f32 arg7) {
1868
    LookAt *lookat;
1869

1870
    arg7 *= RAD_PER_DEG;
1871

1872
    gd_mat4f_lookat(&cam->unkE8, arg1, arg2, arg3, arg4, arg5, arg6, gd_sin_d(arg7), gd_cos_d(arg7),
1873
                  0.0f);
1874

1875
    mat4_to_mtx(&cam->unkE8, &DL_CURRENT_MTX(sCurrentGdDl));
1876
    gSPMatrix(next_gfx(), osVirtualToPhysical(&DL_CURRENT_MTX(sCurrentGdDl)),
1877
            G_MTX_PROJECTION | G_MTX_MUL | G_MTX_NOPUSH);
1878

1879
    /*  col           colc          dir
1880
        0  1  2   3   4  5  6   7   8  9  10  11
1881
    { { 0, 0, 0}, _, {0, 0, 0}, _, {0, 0, 0}, _}
1882
       16 17 18  19  20 21  22 23  24 25  26  27
1883
    { { 0, 0, 0}, _, {0, 0, 0}, _, {0, 0, 0}, _}
1884
    */
1885
    lookat = &D_801BE7D0[gGdFrameBufNum];
1886

1887
    lookat->l[0].l.dir[0] = LOOKAT_PACK(cam->unkE8[0][0]);
1888
    lookat->l[0].l.dir[1] = LOOKAT_PACK(cam->unkE8[1][0]);
1889
    lookat->l[0].l.dir[2] = LOOKAT_PACK(cam->unkE8[2][0]);
1890

1891
    lookat->l[1].l.dir[0] = LOOKAT_PACK(cam->unkE8[0][1]);
1892
    lookat->l[1].l.dir[1] = LOOKAT_PACK(cam->unkE8[1][1]);
1893
    lookat->l[1].l.dir[2] = LOOKAT_PACK(cam->unkE8[2][1]);
1894

1895
    lookat->l[0].l.col[0] = 0;
1896
    lookat->l[0].l.col[1] = 0;
1897
    lookat->l[0].l.col[2] = 0;
1898
    lookat->l[0].l.pad1 = 0;
1899
    lookat->l[0].l.colc[0] = 0;
1900
    lookat->l[0].l.colc[1] = 0;
1901
    lookat->l[0].l.colc[2] = 0;
1902
    lookat->l[0].l.pad2 = 0;
1903
    lookat->l[1].l.col[0] = 0;
1904
    lookat->l[1].l.col[1] = 0x80;
1905
    lookat->l[1].l.col[2] = 0;
1906
    lookat->l[1].l.pad1 = 0;
1907
    lookat->l[1].l.colc[0] = 0;
1908
    lookat->l[1].l.colc[1] = 0x80;
1909
    lookat->l[1].l.colc[2] = 0;
1910
    lookat->l[1].l.pad2 = 0;
1911

1912
    lookat = &D_801BE790[0];
1913
    lookat->l[0].l.dir[0] = 1;
1914
    lookat->l[0].l.dir[1] = 0;
1915
    lookat->l[0].l.dir[2] = 0;
1916

1917
    lookat->l[1].l.dir[0] = 0;
1918
    lookat->l[1].l.dir[1] = 1;
1919
    lookat->l[1].l.dir[2] = 0;
1920

1921
    lookat->l[0].l.col[0] = 0;
1922
    lookat->l[0].l.col[1] = 0;
1923
    lookat->l[0].l.col[2] = 0;
1924
    lookat->l[0].l.pad1 = 0;
1925
    lookat->l[0].l.colc[0] = 0;
1926
    lookat->l[0].l.colc[1] = 0;
1927
    lookat->l[0].l.colc[2] = 0;
1928
    lookat->l[0].l.pad2 = 0;
1929
    lookat->l[1].l.col[0] = 0;
1930
    lookat->l[1].l.col[1] = 0x80;
1931
    lookat->l[1].l.col[2] = 0;
1932
    lookat->l[1].l.pad1 = 0;
1933
    lookat->l[1].l.colc[0] = 0;
1934
    lookat->l[1].l.colc[1] = 0x80;
1935
    lookat->l[1].l.colc[2] = 0;
1936
    lookat->l[1].l.pad2 = 0;
1937

1938
    gSPLookAt(next_gfx(), osVirtualToPhysical(&D_801BE7D0[gGdFrameBufNum]));
1939
    next_mtx();
1940
}
1941

1942
/* 24E1A8 -> 24E230; orig name: func_8019F9D8 */
1943
void check_tri_display(s32 vtxcount) {
1944
    D_801A86C0 = sCurrentGdDl->curVtxIdx;
1945
    D_801BB0B4 = 0;
1946
    if (vtxcount != 3) {
1947
        fatal_printf("cant display no tris\n");
1948
    }
1949
    if (D_801BB018 != 0 || D_801BB01C != 0) {
1950
        ;
1951
    }
1952
}
1953

1954
/**
1955
 * Adds a vertex to the current display list. Returns a pointer to the vertex if
1956
 * it is new, or NULL if the vertex already exists.
1957
 */
1958
Vtx *gd_dl_make_vertex(f32 x, f32 y, f32 z, f32 alpha) {
1959
    Vtx *vtx = NULL;
1960
    s32 i;
1961

1962
    // Add the vertex index to the buffer if it doesn't already exist
1963
    for (i = sVertexBufStartIndex; i < (sVertexBufStartIndex + sVertexBufCount); i++) {
1964
        // the ifs need to be separate to match...
1965
        if (sCurrentGdDl->vtx[i].n.ob[0] == (s16) x) {
1966
            if (sCurrentGdDl->vtx[i].n.ob[1] == (s16) y) {
1967
                if (sCurrentGdDl->vtx[i].n.ob[2] == (s16) z) {
1968
                    sTriangleBuf[sTriangleBufCount][D_801BB0B4++] = (s16) i;
1969
                    return NULL;
1970
                }
1971
            }
1972
        }
1973
    }
1974

1975
    sVertexBufCount++;
1976
    sTriangleBuf[sTriangleBufCount][D_801BB0B4++] = (s16) sCurrentGdDl->curVtxIdx;
1977

1978
    DL_CURRENT_VTX(sCurrentGdDl).n.ob[0] = (s16) x;
1979
    DL_CURRENT_VTX(sCurrentGdDl).n.ob[1] = (s16) y;
1980
    DL_CURRENT_VTX(sCurrentGdDl).n.ob[2] = (s16) z;
1981
    DL_CURRENT_VTX(sCurrentGdDl).n.flag = 0;
1982
    DL_CURRENT_VTX(sCurrentGdDl).n.tc[0] = sVtxCvrtTCBuf[0];
1983
    DL_CURRENT_VTX(sCurrentGdDl).n.tc[1] = sVtxCvrtTCBuf[1];
1984
    DL_CURRENT_VTX(sCurrentGdDl).n.n[0] = sVtxCvrtNormBuf[0];
1985
    DL_CURRENT_VTX(sCurrentGdDl).n.n[1] = sVtxCvrtNormBuf[1];
1986
    DL_CURRENT_VTX(sCurrentGdDl).n.n[2] = sVtxCvrtNormBuf[2];
1987
    DL_CURRENT_VTX(sCurrentGdDl).n.a = (u8)(alpha * 255.0f);
1988

1989
    vtx = &DL_CURRENT_VTX(sCurrentGdDl);
1990
    next_vtx();
1991
    return vtx;
1992
}
1993

1994
/* 24E6C0 -> 24E724 */
1995
void func_8019FEF0(void) {
1996
    sTriangleBufCount++;
1997
    if (sVertexBufCount >= 12) {
1998
        gd_dl_flush_vertices();
1999
        func_801A0038();
2000
    }
2001
    D_801BB018 = 0;
2002
}
2003

2004
/**
2005
 * Adds a triange to the current display list.
2006
 */
2007
void gd_dl_make_triangle(f32 x1, f32 y1, f32 z1, f32 x2, f32 y2, f32 z2, f32 x3, f32 y3, f32 z3) {
2008
    Vtx *vtx;
2009

2010
    vtx = &DL_CURRENT_VTX(sCurrentGdDl);
2011
    gd_dl_make_vertex(x1, y1, z1, 1.0f);
2012
    gd_dl_make_vertex(x2, y2, z2, 1.0f);
2013
    gd_dl_make_vertex(x3, y3, z3, 1.0f);
2014

2015
    gSPVertex(next_gfx(), osVirtualToPhysical(vtx), 3, 0);
2016
    gSP1Triangle(next_gfx(), 0, 1, 2, 0);
2017
}
2018

2019
/* 24E808 -> 24E840 */
2020
void func_801A0038(void) {
2021
    sVertexBufCount = 0;
2022
    sTriangleBufCount = 0;
2023
    sVertexBufStartIndex = sCurrentGdDl->curVtxIdx;
2024
}
2025

2026
/* 24E840 -> 24E9BC */
2027
void gd_dl_flush_vertices(void) {
2028
    UNUSED u32 pad;
2029
    s32 i;
2030
    UNUSED s32 startvtx = sVertexBufStartIndex;
2031

2032
    if (sVertexBufCount != 0) {
2033
        // load vertex data
2034
        gSPVertex(next_gfx(), osVirtualToPhysical(&sCurrentGdDl->vtx[sVertexBufStartIndex]), sVertexBufCount, 0);
2035
        // load triangle data
2036
        for (i = 0; i < sTriangleBufCount; i++) {
2037
            gSP1Triangle(next_gfx(),
2038
                sTriangleBuf[i][0] - sVertexBufStartIndex,
2039
                sTriangleBuf[i][1] - sVertexBufStartIndex,
2040
                sTriangleBuf[i][2] - sVertexBufStartIndex,
2041
                0);
2042
        }
2043
    }
2044
    func_801A0038();
2045
}
2046

2047
/**
2048
 * Unused - called by func_801A520C
2049
 */
2050
static void func_801A01EC(void) {
2051
    if (D_801BE8B0.validCount >= D_801BE8B0.msgCount) {
2052
        osRecvMesg(&D_801BE8B0, &sGdDMACompleteMsg, OS_MESG_BLOCK);
2053
    }
2054
    osRecvMesg(&D_801BE8B0, &sGdDMACompleteMsg, OS_MESG_BLOCK);
2055
}
2056

2057
/**
2058
 * Unused - called by func_801A520C
2059
 */
2060
static void func_801A025C(void) {
2061
    gGdFrameBufNum ^= 1;
2062
    osViSwapBuffer(sScreenView->parent->colourBufs[gGdFrameBufNum]);
2063
}
2064

2065
/* 24EA88 -> 24EAF4 */
2066
void set_render_alpha(f32 alpha) {
2067
    sAlpha = alpha * 255.0f;
2068
    update_render_mode();
2069
}
2070

2071
/* 24EAF4 -> 24EB0C */
2072
// light id?
2073
void set_light_id(s32 index) {
2074
    sLightId = index;
2075
}
2076

2077
/* 24EB0C -> 24EB24; orig name: func_801A033C */
2078
void set_light_num(s32 n) {
2079
    sNumLights = n;
2080
}
2081

2082
/* 24EB24 -> 24EC18 */
2083
s32 create_mtl_gddl(UNUSED s32 mtlType) {
2084
    s32 dlnum;            // 24
2085
    struct GdColour blue; // 18
2086

2087
    blue.r = 0.0f;
2088
    blue.g = 0.0f;
2089
    blue.b = 1.0f;
2090
    dlnum = gd_startdisplist(7);
2091
    gd_dl_material_lighting(dlnum, &blue, GD_MTL_TEX_OFF);
2092
    gd_enddlsplist_parent();
2093
    sCurrentGdDl->totalVtx = sCurrentGdDl->curVtxIdx;
2094
    sCurrentGdDl->totalMtx = sCurrentGdDl->curMtxIdx;
2095
    sCurrentGdDl->totalLights = sCurrentGdDl->curLightIdx;
2096
    sCurrentGdDl->totalGfx = sCurrentGdDl->curGfxIdx;
2097
    sCurrentGdDl->totalVp = sCurrentGdDl->curVpIdx;
2098
    return dlnum;
2099
}
2100

2101
/* 24EC18 -> 24EC48; orig name: func_801A0448 */
2102
void branch_to_gddl(s32 dlNum) {
2103
    branch_cur_dl_to_num(dlNum);
2104
}
2105

2106
/* 24EC48 -> 24F03C */
2107
// phong shading function?
2108
void gd_dl_hilite(s32 idx, // material GdDl number; offsets into hilite array
2109
                   struct ObjCamera *cam, UNUSED struct GdVec3f *arg2, UNUSED struct GdVec3f *arg3,
2110
                   struct GdVec3f *arg4,   // vector to light source?
2111
                   struct GdColour *colour // light color
2112
) {
2113
    UNUSED u32 pad2[24];
2114
    Hilite *hilite; // 4c
2115
    struct GdVec3f sp40;
2116
    f32 sp3C; // magnitude of sp40
2117
    f32 sp38;
2118
    f32 sp34;
2119
    UNUSED u32 pad[6];
2120

2121
    sp38 = 32.0f; // x scale factor?
2122
    sp34 = 32.0f; // y scale factor?
2123
    if (idx >= 0xc8) {
2124
        fatal_printf("too many hilites");
2125
    }
2126
    hilite = &sHilites[idx];
2127

2128
    gDPSetPrimColor(next_gfx(), 0, 0, (s32)(colour->r * 255.0f), (s32)(colour->g * 255.0f),
2129
                    (s32)(colour->b * 255.0f), 255);
2130
    sp40.z = cam->unkE8[0][2] + arg4->x;
2131
    sp40.y = cam->unkE8[1][2] + arg4->y;
2132
    sp40.x = cam->unkE8[2][2] + arg4->z;
2133
    sp3C = sqrtf(SQ(sp40.z) + SQ(sp40.y) + SQ(sp40.x));
2134
    if (sp3C > 0.1) {
2135
        sp3C = 1.0 / sp3C; //? 1.0f
2136
        sp40.z *= sp3C;
2137
        sp40.y *= sp3C;
2138
        sp40.x *= sp3C;
2139

2140
        hilite->h.x1 =
2141
            (((sp40.z * cam->unkE8[0][0]) + (sp40.y * cam->unkE8[1][0]) + (sp40.x * cam->unkE8[2][0]))
2142
             * sp38 * 2.0f)
2143
            + (sp38 * 4.0f);
2144
        hilite->h.y1 =
2145
            (((sp40.z * cam->unkE8[0][1]) + (sp40.y * cam->unkE8[1][1]) + (sp40.x * cam->unkE8[2][1]))
2146
             * sp34 * 2.0f)
2147
            + (sp34 * 4.0f);
2148
    } else {
2149
        hilite->h.x1 = sp38 * 2.0f;
2150
        hilite->h.y1 = sp34 * 2.0f;
2151
    }
2152
}
2153

2154
/**
2155
 * Adds some display list commands that perform lighting for a material
2156
 */
2157
s32 gd_dl_material_lighting(s32 id, struct GdColour *colour, s32 material) {
2158
    UNUSED u32 pad60[2];
2159
    s32 i;
2160
    s32 numLights = sNumLights;
2161
    s32 scaledColours[3];
2162
    s32 lightDir[3];
2163

2164
    if (id > 0) {
2165
        begin_gddl(id);
2166
    }
2167
    switch (material) {
2168
        case GD_MTL_TEX_OFF:
2169
            gddl_is_loading_stub_dl(FALSE);
2170
            gddl_is_loading_stub_dl(FALSE);
2171
            gddl_is_loading_stub_dl(FALSE);
2172
            gddl_is_loading_stub_dl(FALSE);
2173
            gddl_is_loading_shine_dl(FALSE);
2174
            gddl_is_loading_shine_dl(FALSE);
2175
            gddl_is_loading_shine_dl(FALSE);
2176
            gddl_is_loading_shine_dl(FALSE);
2177
            numLights = NUMLIGHTS_2;
2178
            break;
2179
        case GD_MTL_STUB_DL:
2180
            gddl_is_loading_stub_dl(TRUE);
2181
            break;
2182
        case GD_MTL_SHINE_DL:
2183
            gddl_is_loading_shine_dl(TRUE);
2184
            if (id >= 200) {
2185
                fatal_printf("too many hilites");
2186
            }
2187
            gDPSetHilite1Tile(next_gfx(), G_TX_RENDERTILE, &sHilites[id], 32, 32);
2188
            break;
2189
        case GD_MTL_BREAK:
2190
            break;
2191
        default:
2192
            gddl_is_loading_stub_dl(FALSE);
2193
            gddl_is_loading_shine_dl(FALSE);
2194

2195
            DL_CURRENT_LIGHT(sCurrentGdDl).a.l.col[0] = colour->r * 255.0f;
2196
            DL_CURRENT_LIGHT(sCurrentGdDl).a.l.col[1] = colour->g * 255.0f;
2197
            DL_CURRENT_LIGHT(sCurrentGdDl).a.l.col[2] = colour->b * 255.0f;
2198

2199
            DL_CURRENT_LIGHT(sCurrentGdDl).a.l.colc[0] = DL_CURRENT_LIGHT(sCurrentGdDl).a.l.col[0];
2200
            DL_CURRENT_LIGHT(sCurrentGdDl).a.l.colc[1] = DL_CURRENT_LIGHT(sCurrentGdDl).a.l.col[1];
2201
            DL_CURRENT_LIGHT(sCurrentGdDl).a.l.colc[2] = DL_CURRENT_LIGHT(sCurrentGdDl).a.l.col[2];
2202
            // 801A0D04
2203
            DL_CURRENT_LIGHT(sCurrentGdDl).l[0].l.col[0] = 0;
2204
            DL_CURRENT_LIGHT(sCurrentGdDl).l[0].l.col[1] = 0;
2205
            DL_CURRENT_LIGHT(sCurrentGdDl).l[0].l.col[2] = 0;
2206

2207
            DL_CURRENT_LIGHT(sCurrentGdDl).l[0].l.colc[0] = 0;
2208
            DL_CURRENT_LIGHT(sCurrentGdDl).l[0].l.colc[1] = 0;
2209
            DL_CURRENT_LIGHT(sCurrentGdDl).l[0].l.colc[2] = 0;
2210

2211
            gSPNumLights(next_gfx(), NUMLIGHTS_1);
2212
            gSPLight(next_gfx(), osVirtualToPhysical(&DL_CURRENT_LIGHT(sCurrentGdDl).l), LIGHT_1);
2213
            gSPLight(next_gfx(), osVirtualToPhysical(&DL_CURRENT_LIGHT(sCurrentGdDl).a), LIGHT_2);
2214
            next_light();
2215
            if (id > 0) {
2216
                gd_enddlsplist();
2217
            }
2218
            return 0;
2219
            break;
2220
    }
2221
    // L801A0EF4
2222
    scaledColours[0] = (s32)(colour->r * sAmbScaleColour.r * 255.0f);
2223
    scaledColours[1] = (s32)(colour->g * sAmbScaleColour.g * 255.0f);
2224
    scaledColours[2] = (s32)(colour->b * sAmbScaleColour.b * 255.0f);
2225
    // 801A0FE4
2226
    DL_CURRENT_LIGHT(sCurrentGdDl).a.l.col[0] = scaledColours[0];
2227
    DL_CURRENT_LIGHT(sCurrentGdDl).a.l.col[1] = scaledColours[1];
2228
    DL_CURRENT_LIGHT(sCurrentGdDl).a.l.col[2] = scaledColours[2];
2229
    // 801A1068
2230
    DL_CURRENT_LIGHT(sCurrentGdDl).a.l.colc[0] = scaledColours[0];
2231
    DL_CURRENT_LIGHT(sCurrentGdDl).a.l.colc[1] = scaledColours[1];
2232
    DL_CURRENT_LIGHT(sCurrentGdDl).a.l.colc[2] = scaledColours[2];
2233
    // 801A10EC
2234
    gSPNumLights(next_gfx(), numLights);
2235
    for (i = 0; i < numLights; i++) { // L801A1134
2236
        scaledColours[0] = colour->r * sLightScaleColours[i].r * 255.0f;
2237
        scaledColours[1] = colour->g * sLightScaleColours[i].g * 255.0f;
2238
        scaledColours[2] = colour->b * sLightScaleColours[i].b * 255.0f;
2239
        // 801A1260
2240
        DL_CURRENT_LIGHT(sCurrentGdDl).l[i].l.col[0] = scaledColours[0];
2241
        DL_CURRENT_LIGHT(sCurrentGdDl).l[i].l.col[1] = scaledColours[1];
2242
        DL_CURRENT_LIGHT(sCurrentGdDl).l[i].l.col[2] = scaledColours[2];
2243
        DL_CURRENT_LIGHT(sCurrentGdDl).l[i].l.colc[0] = scaledColours[0];
2244
        DL_CURRENT_LIGHT(sCurrentGdDl).l[i].l.colc[1] = scaledColours[1];
2245
        DL_CURRENT_LIGHT(sCurrentGdDl).l[i].l.colc[2] = scaledColours[2];
2246

2247
        // 801A13B0
2248
        lightDir[0] = (s8)sLightDirections[i].x;
2249
        lightDir[1] = (s8)sLightDirections[i].y;
2250
        lightDir[2] = (s8)sLightDirections[i].z;
2251
        // 801A141C
2252
        DL_CURRENT_LIGHT(sCurrentGdDl).l[i].l.dir[0] = lightDir[0];
2253
        DL_CURRENT_LIGHT(sCurrentGdDl).l[i].l.dir[1] = lightDir[1];
2254
        DL_CURRENT_LIGHT(sCurrentGdDl).l[i].l.dir[2] = lightDir[2];
2255
        // 801A14C4
2256
        gSPLight(next_gfx(), osVirtualToPhysical(&DL_CURRENT_LIGHT(sCurrentGdDl).l[i]), i + 1);
2257
    }
2258
    // L801A1550
2259
    gSPLight(next_gfx(), osVirtualToPhysical(&DL_CURRENT_LIGHT(sCurrentGdDl)), i + 1);
2260
    next_light();
2261
    gd_enddlsplist();
2262
    return 0;
2263
}
2264

2265
/* 24FDB8 -> 24FE94; orig name: func_801A15E8; only from faces? */
2266
void set_Vtx_norm_buf_1(struct GdVec3f *norm) {
2267
    sVtxCvrtNormBuf[0] = (s8)(norm->x * 127.0f);
2268
    sVtxCvrtNormBuf[1] = (s8)(norm->y * 127.0f);
2269
    sVtxCvrtNormBuf[2] = (s8)(norm->z * 127.0f);
2270
}
2271

2272
/* 24FE94 -> 24FF80; orig name: func_801A16C4; only from verts? */
2273
void set_Vtx_norm_buf_2(struct GdVec3f *norm) {
2274
    sVtxCvrtNormBuf[0] = (s8)(norm->x * 127.0f);
2275
    sVtxCvrtNormBuf[1] = (s8)(norm->y * 127.0f);
2276
    sVtxCvrtNormBuf[2] = (s8)(norm->z * 127.0f);
2277

2278
    //? are these stub functions?
2279
    return; // @ 801A17A0
2280
    return; // @ 801A17A8
2281
}
2282

2283
/* 24FF80 -> 24FFDC; orig name: func_801A17B0 */
2284
void set_gd_mtx_parameters(s32 params) {
2285
    switch (params) {
2286
        case G_MTX_PROJECTION | G_MTX_MUL | G_MTX_PUSH:
2287
            sMtxParamType = G_MTX_PROJECTION;
2288
            break;
2289
        case G_MTX_MODELVIEW | G_MTX_LOAD | G_MTX_PUSH:
2290
            sMtxParamType = G_MTX_MODELVIEW;
2291
            break;
2292
    }
2293
}
2294

2295
/**
2296
 * Adds a viewport to the current display list based on the current active view
2297
 */
2298
static void gd_dl_viewport(void) {
2299
    Vp *vp;
2300

2301
    vp = &DL_CURRENT_VP(sCurrentGdDl);
2302

2303
    vp->vp.vscale[0] = (s16)(sActiveView->lowerRight.x * 2.0f);  // x scale
2304
    vp->vp.vscale[1] = (s16)(sActiveView->lowerRight.y * 2.0f);  // y scale
2305
    vp->vp.vscale[2] = 0x1FF;  // z scale
2306
    vp->vp.vscale[3] = 0x000;
2307

2308
    vp->vp.vtrans[0] = (s16)((sActiveView->upperLeft.x * 4.0f) + (sActiveView->lowerRight.x * 2.0f));  // x offset
2309
    vp->vp.vtrans[1] = (s16)((sActiveView->upperLeft.y * 4.0f) + (sActiveView->lowerRight.y * 2.0f));  // y offset
2310
    vp->vp.vtrans[2] = 0x1FF;  // z offset
2311
    vp->vp.vtrans[3] = 0x000;
2312

2313
    gSPViewport(next_gfx(), osVirtualToPhysical(vp));
2314
    next_vp();
2315
}
2316

2317
/* 2501D0 -> 250300 */
2318
static void update_render_mode(void) {
2319
    if ((sActiveView->flags & VIEW_ALLOC_ZBUF) != 0) {
2320
        if (sAlpha != 0xff) {
2321
            gDPSetRenderMode(next_gfx(), G_RM_AA_ZB_XLU_SURF, G_RM_AA_ZB_XLU_SURF2);
2322
        } else {
2323
            gDPSetRenderMode(next_gfx(), G_RM_AA_ZB_OPA_INTER, G_RM_NOOP2);
2324
        }
2325
    } else {
2326
        if (sAlpha != 0xff) {
2327
            gDPSetRenderMode(next_gfx(), G_RM_AA_XLU_SURF, G_RM_AA_XLU_SURF2);
2328
        } else {
2329
            gDPSetRenderMode(next_gfx(), G_RM_AA_ZB_OPA_INTER, G_RM_NOOP2);
2330
        }
2331
    }
2332
}
2333

2334
/* 250300 -> 250640 */
2335
void Unknown801A1B30(void) {
2336
    gDPPipeSync(next_gfx());
2337
    gd_set_color_fb();
2338
    gd_dl_set_fill(&sActiveView->colour);
2339
    gDPFillRectangle(next_gfx(), (u32)(sActiveView->upperLeft.x), (u32)(sActiveView->upperLeft.y),
2340
                     (u32)(sActiveView->upperLeft.x + sActiveView->lowerRight.x - 1.0f),
2341
                     (u32)(sActiveView->upperLeft.y + sActiveView->lowerRight.y - 1.0f));
2342
    gDPPipeSync(next_gfx());
2343
}
2344

2345
/* 250640 -> 250AE0 */
2346
void Unknown801A1E70(void) {
2347
    gDPPipeSync(next_gfx());
2348
    gDPSetCycleType(next_gfx(), G_CYC_FILL);
2349
    gDPSetRenderMode(next_gfx(), G_RM_OPA_SURF, G_RM_OPA_SURF2);
2350
    gd_dl_set_zbuffer_area();
2351
    gDPSetColorImage(next_gfx(), G_IM_FMT_RGBA, G_IM_SIZ_16b, sActiveView->parent->lowerRight.x,
2352
                     GD_LOWER_24(sActiveView->parent->zbuf));
2353
    gDPSetFillColor(next_gfx(), GPACK_ZDZ(G_MAXFBZ, 0) << 16 | GPACK_ZDZ(G_MAXFBZ, 0));
2354
    gDPFillRectangle(next_gfx(), (u32)(sActiveView->upperLeft.x), (u32)(sActiveView->upperLeft.y),
2355
                     (u32)(sActiveView->upperLeft.x + sActiveView->lowerRight.x - 1.0f),
2356
                     (u32)(sActiveView->upperLeft.y + sActiveView->lowerRight.y - 1.0f));
2357
    gDPPipeSync(next_gfx());
2358
    gd_set_color_fb();
2359
}
2360

2361
/* 250AE0 -> 250B30; orig name: func_801A2310 */
2362
void gd_set_one_cycle(void) {
2363
    gDPSetCycleType(next_gfx(), G_CYC_1CYCLE);
2364
    update_render_mode();
2365
}
2366

2367
/* 250B30 -> 250B44 */
2368
void stub_renderer_3(void) {
2369
    UNUSED u32 pad[4];
2370
}
2371

2372
/* 250B44 -> 250B58 */
2373
void gddl_is_loading_stub_dl(UNUSED s32 dlLoad) {
2374
}
2375

2376
/* 250B58 -> 250C18 */
2377
void gddl_is_loading_shine_dl(s32 dlLoad) {
2378
    if (dlLoad) {
2379
        gSPDisplayList(next_gfx(), osVirtualToPhysical(&gd_dl_mario_face_shine));
2380
    } else {
2381
        gSPTexture(next_gfx(), 0x8000, 0x8000, 0, G_TX_RENDERTILE, G_OFF);
2382
        gDPSetCombineMode(next_gfx(), G_CC_SHADE, G_CC_SHADE);
2383
    }
2384
}
2385

2386
/* 250C18 -> 251014; orig name: func_801A2448 */
2387
void start_view_dl(struct ObjView *view) {
2388
    f32 ulx;
2389
    f32 uly;
2390
    f32 lrx;
2391
    f32 lry;
2392

2393
    if (view->upperLeft.x < view->parent->upperLeft.x) {
2394
        ulx = view->parent->upperLeft.x;
2395
    } else {
2396
        ulx = view->upperLeft.x;
2397
    }
2398

2399
    if (view->upperLeft.x + view->lowerRight.x
2400
        > view->parent->upperLeft.x + view->parent->lowerRight.x) {
2401
        lrx = view->parent->upperLeft.x + view->parent->lowerRight.x;
2402
    } else {
2403
        lrx = view->upperLeft.x + view->lowerRight.x;
2404
    }
2405

2406
    if (view->upperLeft.y < view->parent->upperLeft.y) {
2407
        uly = view->parent->upperLeft.y;
2408
    } else {
2409
        uly = view->upperLeft.y;
2410
    }
2411

2412
    if (view->upperLeft.y + view->lowerRight.y
2413
        > view->parent->upperLeft.y + view->parent->lowerRight.y) {
2414
        lry = view->parent->upperLeft.y + view->parent->lowerRight.y;
2415
    } else {
2416
        lry = view->upperLeft.y + view->lowerRight.y;
2417
    }
2418

2419
    if (ulx >= lrx) {
2420
        ulx = lrx - 1.0f;
2421
    }
2422
    if (uly >= lry) {
2423
        uly = lry - 1.0f;
2424
    }
2425

2426
#ifdef TARGET_N64
2427
    gDPSetScissor(next_gfx(), G_SC_NON_INTERLACE, ulx, uly, lrx, lry);
2428
#endif
2429
    gSPClearGeometryMode(next_gfx(), 0xFFFFFFFF);
2430
    gSPSetGeometryMode(next_gfx(), G_LIGHTING | G_CULL_BACK | G_SHADING_SMOOTH | G_SHADE);
2431
    if (view->flags & VIEW_ALLOC_ZBUF) {
2432
        gSPSetGeometryMode(next_gfx(), G_ZBUFFER);
2433
    }
2434
    gd_dl_viewport();
2435
    update_render_mode();
2436
    gDPPipeSync(next_gfx());
2437
}
2438

2439
/* 251014 -> 251A1C; orig name: func_801A2844 */
2440
void parse_p1_controller(void) {
2441
    u32 i;
2442
    struct GdControl *gdctrl = &gGdCtrl;
2443
    OSContPad *currInputs;
2444
    OSContPad *prevInputs;
2445

2446
    // Copy current inputs to previous
2447
    u8 *src = (u8 *) gdctrl;
2448
    u8 *dest = (u8 *) gdctrl->prevFrame;
2449
    for (i = 0; i < sizeof(struct GdControl); i++) {
2450
        *dest++ = *src++;
2451
    }
2452

2453
    gdctrl->unk50 = gdctrl->unk4C = gdctrl->dup = gdctrl->ddown = 0;
2454

2455
    currInputs = &sGdContPads[0];
2456
    prevInputs = &sPrevFrameCont[0];
2457
    // stick values
2458
    gdctrl->stickXf = (f32) currInputs->stick_x + (configMouseCam ? currInputs->stick2_x : 0);
2459
    gdctrl->stickYf = (f32) currInputs->stick_y - (configMouseCam ? currInputs->stick2_y : 0);
2460
    gdctrl->stickDeltaX = gdctrl->stickX;
2461
    gdctrl->stickDeltaY = gdctrl->stickY;
2462
    gdctrl->stickX = (s32) currInputs->stick_x + (configMouseCam ? currInputs->stick2_x : 0);
2463
    gdctrl->stickY = (s32) currInputs->stick_y - (configMouseCam ? currInputs->stick2_y : 0);
2464
    gdctrl->stickDeltaX -= gdctrl->stickX;
2465
    gdctrl->stickDeltaY -= gdctrl->stickY;
2466
    // button values (as bools)
2467
    gdctrl->trgL   = (currInputs->button & L_TRIG) != 0;
2468
    gdctrl->trgR   = (currInputs->button & R_TRIG) != 0;
2469
    gdctrl->btnA   = (currInputs->button & A_BUTTON) != 0;
2470
    gdctrl->btnB   = (currInputs->button & B_BUTTON) != 0;
2471
    gdctrl->cleft  = (currInputs->button & L_CBUTTONS) != 0;
2472
    gdctrl->cright = (currInputs->button & R_CBUTTONS) != 0;
2473
    gdctrl->cup    = (currInputs->button & U_CBUTTONS) != 0;
2474
    gdctrl->cdown  = (currInputs->button & D_CBUTTONS) != 0;
2475
    // but not these buttons??
2476
    gdctrl->dleft  = currInputs->button & L_JPAD;
2477
    gdctrl->dright = currInputs->button & R_JPAD;
2478
    gdctrl->dup    = currInputs->button & U_JPAD;
2479
    gdctrl->ddown  = currInputs->button & D_JPAD;
2480

2481
    if (gdctrl->btnA && !gdctrl->dragging) {
2482
        gdctrl->startedDragging = TRUE;
2483
    } else {
2484
        gdctrl->startedDragging = FALSE;
2485
    }
2486
    // toggle if A is pressed? or is this just some seed for an rng?
2487
    gdctrl->dragging = gdctrl->btnA;
2488
    gdctrl->unkD8b20 = gdctrl->unkD8b40 = FALSE;
2489
    gdctrl->AbtnPressWait = FALSE;
2490

2491
    if (gdctrl->startedDragging) {
2492
        gdctrl->dragStartX = gdctrl->csrX;
2493
        gdctrl->dragStartY = gdctrl->csrY;
2494

2495
        if (gdctrl->currFrame - gdctrl->dragStartFrame < 10) {
2496
            gdctrl->AbtnPressWait = TRUE;
2497
        }
2498
    }
2499

2500
    if (gdctrl->dragging) {
2501
        gdctrl->dragStartFrame = gdctrl->currFrame;
2502
    }
2503
    gdctrl->currFrame++;
2504

2505
    if (currInputs->button & START_BUTTON && !(prevInputs->button & START_BUTTON)) {
2506
        gdctrl->newStartPress ^= 1;
2507
    }
2508

2509
    if (currInputs->button & Z_TRIG && !(prevInputs->button & Z_TRIG)) {
2510
        sCurrDebugViewIndex++;
2511
    }
2512

2513
    if (sCurrDebugViewIndex > sDebugViewsCount) {
2514
        sCurrDebugViewIndex = 0;
2515
    } else if (sCurrDebugViewIndex < 0) {
2516
        sCurrDebugViewIndex = sDebugViewsCount;
2517
    }
2518

2519
    if (sCurrDebugViewIndex) {
2520
        deactivate_timing();
2521
    } else {
2522
        activate_timing();
2523
    }
2524

2525
    for (i = 0; ((s32) i) < sDebugViewsCount; i++) {
2526
        sDebugViews[i]->flags &= ~VIEW_UPDATE;
2527
    }
2528

2529
    if (sCurrDebugViewIndex) {
2530
        sDebugViews[sCurrDebugViewIndex - 1]->flags |= VIEW_UPDATE;
2531
    }
2532

2533
    // deadzone checks
2534
    if (ABS(gdctrl->stickX) >= 6) {
2535
        gdctrl->csrX += gdctrl->stickX * 0.1;
2536
    }
2537
    if (ABS(gdctrl->stickY) >= 6) {
2538
        gdctrl->csrY -= gdctrl->stickY * 0.1; //? 0.1f
2539
    }
2540
    // Clamp cursor position within screen view bounds
2541
    if (config4by3Hud || configAspectRatio == 1) {
2542

2543
        if (gdctrl->csrX < sScreenView->parent->upperLeft.x + 16.0f) {
2544
            gdctrl->csrX = sScreenView->parent->upperLeft.x + 16.0f;
2545
        }
2546
        if (gdctrl->csrX > sScreenView->parent->upperLeft.x + sScreenView->parent->lowerRight.x - 48.0f) {
2547
            gdctrl->csrX = sScreenView->parent->upperLeft.x + sScreenView->parent->lowerRight.x - 48.0f;
2548
        }
2549
        if (gdctrl->csrY < sScreenView->parent->upperLeft.y + 16.0f) {
2550
            gdctrl->csrY = sScreenView->parent->upperLeft.y + 16.0f;
2551
        }
2552
        if (gdctrl->csrY > sScreenView->parent->upperLeft.y + sScreenView->parent->lowerRight.y - 32.0f) {
2553
            gdctrl->csrY = sScreenView->parent->upperLeft.y + sScreenView->parent->lowerRight.y - 32.0f;
2554
        }
2555
    }
2556
    else {
2557

2558
        if (gdctrl->csrX < GFX_DIMENSIONS_RECT_FROM_LEFT_EDGE(sScreenView->parent->upperLeft.x)) {
2559
            gdctrl->csrX = GFX_DIMENSIONS_RECT_FROM_LEFT_EDGE(sScreenView->parent->upperLeft.x);
2560
        }
2561
        if (gdctrl->csrX > GFX_DIMENSIONS_RECT_FROM_RIGHT_EDGE(sScreenView->parent->upperLeft.x + sScreenView->parent->upperLeft.x) - 32.0f) {
2562
            gdctrl->csrX = GFX_DIMENSIONS_RECT_FROM_RIGHT_EDGE(sScreenView->parent->upperLeft.x + sScreenView->parent->upperLeft.x) - 32.0f;
2563
        }
2564
        if (gdctrl->csrY < sScreenView->parent->upperLeft.y) {
2565
            gdctrl->csrY = sScreenView->parent->upperLeft.y;
2566
        }
2567
        if (gdctrl->csrY > sScreenView->parent->upperLeft.y + sScreenView->parent->lowerRight.y - 32.0f) {
2568
            gdctrl->csrY = sScreenView->parent->upperLeft.y + sScreenView->parent->lowerRight.y - 32.0f;
2569
        }
2570
    }
2571

2572
    for (i = 0; i < sizeof(OSContPad); i++) {
2573
        ((u8 *) prevInputs)[i] = ((u8 *) currInputs)[i];
2574
    }
2575
}
2576

2577
void stub_renderer_4(f32 arg0) {
2578
    return;
2579

2580
    // dead code
2581
    if (D_801BD768.x * D_801A86CC.x + arg0 * 2.0f > 160.0)
2582
    {
2583
        func_801A3370(D_801BD758.x - D_801BD768.x, -20.0f, 0.0f);
2584
        D_801BD768.x = D_801BD758.x;
2585
    }
2586
}
2587

2588
/**
2589
 * Unused
2590
 */
2591
void Unknown801A32F4(s32 arg0) {
2592
    D_801BD774 = GD_LOWER_24(arg0) + D_801BAF28;
2593
}
2594

2595
/* 251AF4 -> 251B40 */
2596
void func_801A3324(f32 x, f32 y, f32 z) {
2597
    D_801BD768.x = x;
2598
    D_801BD768.y = y;
2599
    D_801BD768.z = z;
2600
    D_801BD758.x = x;
2601
    D_801BD758.y = y;
2602
    D_801BD758.z = z;
2603
}
2604

2605
/* 251B40 -> 251BC8 */
2606
void func_801A3370(f32 x, f32 y, f32 z) {
2607
    gd_dl_mul_trans_matrix(x, y, z);
2608
    D_801BD768.x += x;
2609
    D_801BD768.y += y;
2610
    D_801BD768.z += z;
2611
}
2612

2613
/**
2614
 * Unused
2615
 */
2616
void Unknown801A33F8(f32 x, f32 y, f32 z) {
2617
    gd_dl_mul_trans_matrix(x - D_801BD768.x, y - D_801BD768.y, z - D_801BD768.z);
2618

2619
    D_801BD768.x = x;
2620
    D_801BD768.y = y;
2621
    D_801BD768.z = z;
2622
}
2623

2624
/**
2625
 * Unused
2626
 */
2627
void Unknown801A347C(f32 x, f32 y, f32 z) {
2628
    D_801A86CC.x = x;
2629
    D_801A86CC.y = y;
2630
    D_801A86CC.z = z;
2631
    gd_dl_scale(x, y, z);
2632
}
2633

2634
/* 251CB0 -> 251D44; orig name: func_801A34E0 */
2635
void border_active_view(void) {
2636
    if (sActiveView->flags & VIEW_BORDERED) {
2637
        gd_dl_set_fill(gd_get_colour(1));
2638
        gd_draw_border_rect(0.0f, 0.0f, (sActiveView->lowerRight.x - 1.0f),
2639
                            (sActiveView->lowerRight.y - 1.0f));
2640
    }
2641
}
2642

2643
/* 251D44 -> 251DAC */
2644
void gd_shading(s32 model) {
2645
    switch (model) {
2646
        case 9:
2647
            break;
2648
        case 10:
2649
            break;
2650
        default:
2651
            fatal_printf("gd_shading(): Unknown shading model");
2652
    }
2653
}
2654

2655
/* 251DAC -> 251E18 */
2656
s32 gd_getproperty(s32 prop, UNUSED void *arg1) {
2657
    s32 got = FALSE;
2658

2659
    switch (prop) {
2660
        case 3:
2661
            got = TRUE;
2662
            break;
2663
        default:
2664
            fatal_printf("gd_getproperty(): Unkown property");
2665
    }
2666

2667
    return got;
2668
}
2669

2670
/* 251E18 -> 2522B0 */
2671
void gd_setproperty(enum GdProperty prop, f32 f1, f32 f2, f32 f3) {
2672
    UNUSED f32 sp3C = 1.0f;
2673
    s32 parm;
2674

2675
    switch (prop) {
2676
        case GD_PROP_LIGHTING:
2677
            parm = (s32) f1;
2678
            switch (parm) {
2679
                case 1:
2680
                    gSPSetGeometryMode(next_gfx(), G_LIGHTING);
2681
                    break;
2682
                case 0:
2683
                    gSPClearGeometryMode(next_gfx(), G_LIGHTING);
2684
                    break;
2685
            }
2686
            break;
2687
        case GD_PROP_AMB_COLOUR:
2688
            sAmbScaleColour.r = f1;
2689
            sAmbScaleColour.g = f2;
2690
            sAmbScaleColour.b = f3;
2691
            break;
2692
        case GD_PROP_LIGHT_DIR:
2693
            sLightDirections[sLightId].x = (s32)(f1 * 120.f);
2694
            sLightDirections[sLightId].y = (s32)(f2 * 120.f);
2695
            sLightDirections[sLightId].z = (s32)(f3 * 120.f);
2696
            break;
2697
        case GD_PROP_DIFUSE_COLOUR:
2698
            sLightScaleColours[sLightId].r = f1;
2699
            sLightScaleColours[sLightId].g = f2;
2700
            sLightScaleColours[sLightId].b = f3;
2701
            break;
2702
        case GD_PROP_CULLING:
2703
            parm = (s32) f1;
2704
            switch (parm) {
2705
                case 1:
2706
                    gSPSetGeometryMode(next_gfx(), G_CULL_BACK);
2707
                    break;
2708
                case 0:
2709
                    gSPClearGeometryMode(next_gfx(), G_CULL_BACK);
2710
                    break;
2711
            }
2712
            break;
2713
        case GD_PROP_OVERLAY:
2714
            parm = (s32) f1;
2715
            switch (parm) {
2716
                case 1:
2717
                    break;
2718
                case 0:
2719
                    break;
2720
                default:
2721
                    fatal_printf("Bad GD_OVERLAY parm");
2722
            }
2723
            break;
2724
        case GD_PROP_ZBUF_FN:
2725
            parm = (s32) f1;
2726
            switch (parm) {
2727
                case 23:
2728
                    break;
2729
                case 24:
2730
                    break;
2731
                case 25:
2732
                    break;
2733
                default:
2734
                    fatal_printf("Bad zbuf function");
2735
            }
2736
            //? no break?
2737
        case GD_PROP_STUB17:
2738
            break;
2739
        case GD_PROP_STUB18:
2740
            break;
2741
        case GD_PROP_STUB19:
2742
            break;
2743
        case GD_PROP_STUB20:
2744
            break;
2745
        case GD_PROP_STUB21:
2746
            break;
2747
        default:
2748
            fatal_printf("gd_setproperty(): Unkown property");
2749
    }
2750
}
2751

2752
/* 2522B0 -> 2522C0 */
2753
void stub_renderer_5(void) {
2754
}
2755

2756
/* 2522C0 -> 25245C */
2757
void gd_create_ortho_matrix(f32 l, f32 r, f32 b, f32 t, f32 n, f32 f) {
2758
    uintptr_t orthoMtx;
2759
    uintptr_t rotMtx;
2760

2761
    // Should produce G_RDPHALF_1 in Fast3D
2762
    gSPPerspNormalize(next_gfx(), 0xFFFF);
2763

2764
    guOrtho(&DL_CURRENT_MTX(sCurrentGdDl), l, r, b, t, n, f, 1.0f);
2765
    orthoMtx = GD_LOWER_29(&DL_CURRENT_MTX(sCurrentGdDl));
2766
    gSPMatrix(next_gfx(), orthoMtx, G_MTX_PROJECTION | G_MTX_LOAD | G_MTX_NOPUSH);
2767

2768
    next_mtx();
2769
    guRotate(&DL_CURRENT_MTX(sCurrentGdDl), 0.0f, 0.0f, 0.0f, 1.0f);
2770
    rotMtx = GD_LOWER_29(&DL_CURRENT_MTX(sCurrentGdDl));
2771
    gSPMatrix(next_gfx(), rotMtx, G_MTX_MODELVIEW | G_MTX_LOAD | G_MTX_NOPUSH);
2772

2773
    func_801A3324(0.0f, 0.0f, 0.0f);
2774
    next_mtx();
2775
}
2776

2777
/* 25245C -> 25262C */
2778
void gd_create_perspective_matrix(f32 fovy, f32 aspect, f32 near, f32 far) {
2779
    u16 perspNorm;
2780
    UNUSED u32 unused1;
2781
    uintptr_t perspecMtx;
2782
    uintptr_t rotMtx;
2783
    UNUSED u32 unused2;
2784
    UNUSED f32 unusedf = 0.0625f;
2785

2786
    sGdPerspTimer += 0.1;
2787
    guPerspective(&DL_CURRENT_MTX(sCurrentGdDl), &perspNorm, fovy, aspect, near, far, 1.0f);
2788

2789
    gSPPerspNormalize(next_gfx(), perspNorm);
2790

2791
    perspecMtx = GD_LOWER_29(&DL_CURRENT_MTX(sCurrentGdDl));
2792
    gSPMatrix(next_gfx(), perspecMtx, G_MTX_PROJECTION | G_MTX_LOAD | G_MTX_NOPUSH);
2793
    next_mtx();
2794

2795
    guRotate(&DL_CURRENT_MTX(sCurrentGdDl), 0.0f, 0.0f, 0.0f, 1.0f);
2796
    rotMtx = GD_LOWER_29(&DL_CURRENT_MTX(sCurrentGdDl));
2797
    gSPMatrix(next_gfx(), rotMtx, G_MTX_MODELVIEW | G_MTX_LOAD | G_MTX_NOPUSH);
2798
    func_801A3324(0.0f, 0.0f, 0.0f);
2799
    next_mtx();
2800
}
2801

2802
/* 25262C -> 252AF8 */
2803
s32 setup_view_buffers(const char *name, struct ObjView *view, UNUSED s32 ulx, UNUSED s32 uly,
2804
                       UNUSED s32 lrx, UNUSED s32 lry) {
2805
    char memtrackerName[0x100];
2806

2807
    if (view->flags & (VIEW_Z_BUF | VIEW_COLOUR_BUF) && !(view->flags & VIEW_UNK_1000)) {
2808
        if (view->flags & VIEW_COLOUR_BUF) {
2809
            sprintf(memtrackerName, "%s CBuf", name);
2810
            start_memtracker(memtrackerName);
2811
            view->colourBufs[0] =
2812
                gd_malloc((u32)(2.0f * view->lowerRight.x * view->lowerRight.y + 64.0f), 0x20);
2813

2814
            if (view->flags & VIEW_2_COL_BUF) {
2815
                view->colourBufs[1] =
2816
                    gd_malloc((u32)(2.0f * view->lowerRight.x * view->lowerRight.y + 64.0f), 0x20);
2817
            } else {
2818
                view->colourBufs[1] = view->colourBufs[0];
2819
            }
2820

2821
            view->colourBufs[0] = (void *) ALIGN((uintptr_t) view->colourBufs[0], 64);
2822
            view->colourBufs[1] = (void *) ALIGN((uintptr_t) view->colourBufs[1], 64);
2823
            stop_memtracker(memtrackerName);
2824

2825
            if (view->colourBufs[0] == NULL || view->colourBufs[1] == NULL) {
2826
                fatal_printf("Not enough DRAM for colour buffers\n");
2827
            }
2828
            view->parent = view;
2829
        } else {
2830
            view->parent = sScreenView;
2831
        }
2832

2833
        if (view->flags & VIEW_Z_BUF) {
2834
            sprintf(memtrackerName, "%s ZBuf", name);
2835
            start_memtracker(memtrackerName);
2836
            if (view->flags & VIEW_ALLOC_ZBUF) {
2837
                view->zbuf =
2838
                    gd_malloc((u32)(2.0f * view->lowerRight.x * view->lowerRight.y + 64.0f), 0x40);
2839
                if (view->zbuf == NULL) {
2840
                    fatal_printf("Not enough DRAM for Z buffer\n");
2841
                }
2842
                view->zbuf = (void *) ALIGN((uintptr_t) view->zbuf, 64);
2843
            }
2844
            stop_memtracker(memtrackerName);
2845
        } else {
2846
            view->zbuf = sScreenView->zbuf;
2847
        }
2848
    } else {
2849
        view->parent = sScreenView;
2850
    }
2851

2852
    view->gdDlNum = 0;
2853
    view->unk74 = 0;
2854

2855
    if (view->flags & VIEW_DEFAULT_PARENT) {
2856
        view->parent = D_801A86E0;
2857
    }
2858

2859
//! @bug No actual return, but the return value is used.
2860
//!      There is no obvious value to return. Since the function
2861
//!      doesn't use four of its parameters, this function may have
2862
//!      had a fair amount of its code commented out. In game, the
2863
//!      returned value is always 0, so the fix returns that value
2864
#ifdef AVOID_UB
2865
    return 0;
2866
#endif
2867
}
2868

2869
/* 252AF8 -> 252BAC; orig name: _InitControllers */
2870
void gd_init_controllers(void) {
2871
    OSContPad *p1cont = &sPrevFrameCont[0]; // 1c
2872
    u32 i;                                  // 18
2873

2874
    osCreateMesgQueue(&D_801BE830, D_801BE848, ARRAY_COUNT(D_801BE848));
2875
    osSetEventMesg(OS_EVENT_SI, &D_801BE830, (OSMesg) OS_MESG_SI_COMPLETE);
2876
    osContInit(&D_801BE830, &D_801BAEA0, D_801BAE60);
2877
    osContStartReadData(&D_801BE830);
2878

2879
    for (i = 0; i < sizeof(OSContPad); i++) {
2880
        ((u8 *) p1cont)[i] = 0;
2881
    }
2882
}
2883

2884
/* 252BAC -> 252BC0 */
2885
void stub_renderer_6(UNUSED struct GdObj *obj) {
2886
}
2887

2888
/**
2889
 * Unused - This is likely a stub version of the `defpup` function from the IRIX
2890
 * Graphics Library. It was used to define a popup menu. See the IRIX "Graphics
2891
 * Library Reference Manual, C Edition" for details.
2892
 *
2893
 * @param menufmt  a format string defining the menu items to be added to the
2894
 *                 popup menu.
2895
 * @return  an identifier of the menu just defined
2896
 */
2897
long defpup(UNUSED const char *menufmt, ...) {
2898
    //! @bug no return; function was stubbed
2899
#ifdef AVOID_UB
2900
   return 0;
2901
#endif
2902
}
2903

2904
/**
2905
 * Unused - called when the user picks an item from the "Control Type" menu.
2906
 * Presumably, this would allow switching inputs between controller, keyboard,
2907
 * and mouse.
2908
 *
2909
 * @param itemId  ID of the menu item that was clicked
2910
 *                (1 = "U-64 Analogue Joystick", 2 = "Keyboard", 3 = "Mouse")
2911
 */
2912
void menu_cb_control_type(UNUSED u32 itemId) {
2913
}
2914

2915
/**
2916
 * Unused - called when the user clicks the "Re-Calibrate Controller" item from
2917
 * the "Dynamics" menu.
2918
 */
2919
void menu_cb_recalibrate_controller(UNUSED u32 itemId) {
2920
}
2921

2922
/* 252C08 -> 252C70 */
2923
void func_801A4438(f32 x, f32 y, f32 z) {
2924
    sTextDrawPos.x = x - (sActiveView->lowerRight.x / 2.0f);
2925
    sTextDrawPos.y = (sActiveView->lowerRight.y / 2.0f) - y;
2926
    sTextDrawPos.z = z;
2927
}
2928

2929
/* 252C70 -> 252DB4 */
2930
s32 gd_gentexture(void *texture, s32 fmt, s32 size, UNUSED u32 arg3, UNUSED u32 arg4) {
2931
    UNUSED s32 sp2C;
2932
    UNUSED s32 sp28 = 1;
2933
    s32 dl; // 24
2934

2935
    switch (fmt) {
2936
        case 29:
2937
            fmt = 0;
2938
            break;
2939
        case 31:
2940
            fmt = 3;
2941
            break;
2942
        default:
2943
            fatal_printf("gd_gentexture(): bad format");
2944
    }
2945

2946
    switch (size) {
2947
        case 33:
2948
            size = 2;
2949
            sp2C = 16;
2950
            break;
2951
        default:
2952
            fatal_printf("gd_gentexture(): bad size");
2953
    }
2954

2955
    sLoadedTextures[++sTextureCount] = texture;
2956
    dl = gd_startdisplist(7);
2957

2958
    if (dl == 0) {
2959
        fatal_printf("Cant generate DL for texture");
2960
    }
2961
    gd_enddlsplist_parent();
2962
    sTextureDisplayLists[sTextureCount] = dl;
2963

2964
    return dl;
2965
}
2966

2967
/**
2968
 * Unused (not called)
2969
 */
2970
void *load_texture_from_file(const char *file, s32 fmt, s32 size, u32 arg3, u32 arg4) {
2971
    struct GdFile *txFile; // 3c
2972
    void *texture;         // 38
2973
    u32 txSize;            // 34
2974
    u32 i;                 // 30
2975
    u16 *txHalf;           // 2C
2976
    u8 buf[3];             // 28
2977
    u8 alpha;              // 27
2978
    s32 dl;                // 20
2979

2980
    txFile = gd_fopen(file, "r");
2981
    if (txFile == NULL) {
2982
        fatal_print("Cant load texture");
2983
    }
2984
    txSize = gd_get_file_size(txFile);
2985
    texture = gd_malloc_perm(txSize / 3 * 2);
2986
    if (texture == NULL) {
2987
        fatal_printf("Cant allocate memory for texture");
2988
    }
2989
    txHalf = (u16 *) texture;
2990
    for (i = 0; i < txSize / 3; i++) {
2991
        gd_fread((s8 *) buf, 3, 1, txFile);
2992
        alpha = 0xFF;
2993
        *txHalf = ((buf[2] >> 3) << 11) | ((buf[1] >> 3) << 6) | ((buf[0] >> 3) << 1) | (alpha >> 7);
2994
        txHalf++;
2995
    }
2996
    gd_printf("Loaded texture '%s' (%d bytes)\n", file, txSize);
2997
    gd_fclose(txFile);
2998
    dl = gd_gentexture(texture, fmt, size, arg3, arg4);
2999
    gd_printf("Generated '%s' (%d) display list ok.\n", file, dl);
3000

3001
    return texture;
3002
}
3003

3004
/* 252F88 -> 252FAC */
3005
void Unknown801A47B8(struct ObjView *v) {
3006
    if (v->flags & VIEW_SAVE_TO_GLOBAL) {
3007
        D_801BE994 = v;
3008
    }
3009
}
3010

3011
void stub_renderer_7(void) {
3012
}
3013

3014
/* 252FC4 -> 252FD8 */
3015
void stub_renderer_8(UNUSED u32 arg0) {
3016
}
3017

3018
/**
3019
 * Unused - called by func_801A520C and Unknown801A5344
3020
 */
3021
void func_801A4808(void) {
3022
    while (D_801A8674 != 0) {
3023
        ;
3024
    }
3025

3026
    return;
3027
}
3028

3029
/* 253018 -> 253084 */
3030
void func_801A4848(s32 linkDl) {
3031
    struct GdDisplayList *curDl;
3032

3033
    curDl = sCurrentGdDl;
3034
    sCurrentGdDl = sMHeadMainDls[gGdFrameBufNum];
3035
    branch_cur_dl_to_num(linkDl);
3036
    sCurrentGdDl = curDl;
3037
}
3038

3039
/**
3040
 * Unused - called by func_801A520C and Unknown801A5344
3041
 */
3042
void stub_renderer_9(void) {
3043
}
3044

3045
/* 253094 -> 2530A8 */
3046
void stub_renderer_10(UNUSED u32 arg0) {
3047
}
3048

3049
/* 2530A8 -> 2530C0 */
3050
void stub_draw_label_text(UNUSED char *s) {
3051
    UNUSED u32 pad2;
3052
    UNUSED char *save = s;
3053
    UNUSED u8 pad[0x18];
3054
}
3055

3056
/* 2530C0 -> 2530D8; orig name: func_801A48F0 */
3057
void set_active_view(struct ObjView *v) {
3058
    sActiveView = v;
3059
}
3060

3061
void stub_renderer_11(void) {
3062
}
3063

3064
/**
3065
 * Unused - called by func_801A520C
3066
 */
3067
void func_801A4918(void) {
3068
    f32 x;     // c
3069
    f32 y;     // 8
3070
    u32 ydiff; // 4
3071

3072
    if (sHandView == NULL || sMenuView == NULL) {
3073
        return;
3074
    }
3075

3076
    x = sHandView->upperLeft.x;
3077
    y = sHandView->upperLeft.y;
3078

3079
    if (!(x > sMenuView->upperLeft.x && x < sMenuView->upperLeft.x + sMenuView->lowerRight.x
3080
          && y > sMenuView->upperLeft.y && y < sMenuView->upperLeft.y + sMenuView->lowerRight.y)) {
3081
        return;
3082
    }
3083
    ydiff = (y - sMenuView->upperLeft.y) / 25.0f;
3084

3085
    if (ydiff < sItemsInMenu) {
3086
        sMenuGadgets[ydiff]->drawFlags |= OBJ_HIGHLIGHTED;
3087
    }
3088
}
3089

3090
/* 2532D4 -> 2533DC */
3091
void Unknown801A4B04(void) {
3092
    if (D_801A86AC != NULL) {
3093
        D_801A86AC->prevScaledTotal = 20.0f;
3094
    }
3095
    if (D_801A86A4 != NULL) {
3096
        D_801A86A4->prevScaledTotal = (f32)((sDLGenTime * 50.0f) + 20.0f);
3097
    }
3098
    if (D_801A86A8 != NULL) {
3099
        D_801A86A8->prevScaledTotal = (f32)((sDLGenTime * 50.0f) + 20.0f);
3100
    }
3101
    sDLGenTime = get_scaled_timer_total("dlgen");
3102
    sRCPTime = get_scaled_timer_total("rcp");
3103
    sDynamicsTime = get_scaled_timer_total("dynamics");
3104
}
3105

3106
/* 2533DC -> 253728; orig name: func_801A4C0C */
3107
void update_cursor(void) {
3108
    if (sHandView == NULL)
3109
        return;
3110

3111
    if (gGdCtrl.currFrame - gGdCtrl.dragStartFrame < 300) {
3112
        sHandView->flags |= VIEW_UPDATE;
3113
        // by playing the sfx every frame, it will only play once as it
3114
        // never leaves the "sfx played last frame" buffer
3115
        gd_play_sfx(GD_SFX_HAND_APPEAR);
3116
    } else {
3117
        sHandView->flags &= ~VIEW_UPDATE;
3118
        gd_play_sfx(GD_SFX_HAND_DISAPPEAR);
3119
    }
3120

3121
    sHandView->upperLeft.x = (f32) gGdCtrl.csrX;
3122
    sHandView->upperLeft.y = (f32) gGdCtrl.csrY;
3123

3124
    // Make hand display list
3125
    begin_gddl(sHandShape->dlNums[gGdFrameBufNum]);
3126
    if (gGdCtrl.dragging) {
3127
        gd_put_sprite((u16 *) gd_texture_hand_closed, sHandView->upperLeft.x, sHandView->upperLeft.y, 0x20, 0x20);
3128
    } else {
3129
        gd_put_sprite((u16 *) gd_texture_hand_open, sHandView->upperLeft.x, sHandView->upperLeft.y, 0x20, 0x20);
3130
    }
3131
    gd_enddlsplist_parent();
3132

3133
    if (sHandView->upperLeft.x < sHandView->parent->upperLeft.x) {
3134
        sHandView->upperLeft.x = sHandView->parent->upperLeft.x;
3135
    }
3136
    if (sHandView->upperLeft.x > (sHandView->parent->upperLeft.x + sHandView->parent->lowerRight.x)) {
3137
        sHandView->upperLeft.x = sHandView->parent->upperLeft.x + sHandView->parent->lowerRight.x;
3138
    }
3139

3140
    if (sHandView->upperLeft.y < sHandView->parent->upperLeft.y) {
3141
        sHandView->upperLeft.y = sHandView->parent->upperLeft.y;
3142
    }
3143
    if (sHandView->upperLeft.y > (sHandView->parent->upperLeft.y + sHandView->parent->lowerRight.y)) {
3144
        sHandView->upperLeft.y = sHandView->parent->upperLeft.y + sHandView->parent->lowerRight.y;
3145
    }
3146
}
3147

3148
/* 253728 -> 2538E0 */
3149
void Unknown801A4F58(void) {
3150
    register s16 *cbufOff; // a0
3151
    register s16 *cbufOn;  // a1
3152
    register u16 *zbuf;    // a2
3153
    register s16 colour;   // a3
3154
    register s16 r;        // t0
3155
    register s16 g;        // t1
3156
    register s16 b;        // t2
3157
    register s32 i;        // t3
3158

3159
    cbufOff = sScreenView->colourBufs[gGdFrameBufNum ^ 1];
3160
    cbufOn = sScreenView->colourBufs[gGdFrameBufNum];
3161
    zbuf = sScreenView->zbuf;
3162

3163
    for (i = 0; i < (320 * 240); i++) { // L801A4FCC
3164
        colour = cbufOff[i];
3165
        if (colour) {
3166
            r = (s16)(colour >> 11 & 0x1F);
3167
            g = (s16)(colour >> 6 & 0x1F);
3168
            b = (s16)(colour >> 1 & 0x1F);
3169
            if ((r -= 1) < 0) {
3170
                r = 0;
3171
            }
3172
            if ((g -= 1) < 0) {
3173
                g = 0;
3174
            }
3175
            if ((b -= 1) < 0) {
3176
                b = 0;
3177
            }
3178

3179
            colour = (s16)(r << 11 | g << 6 | b << 1);
3180
            cbufOff[i] = colour;
3181
            cbufOn[i] = colour;
3182
        } else { // L801A50D8
3183
            zbuf[i] = 0xFFFC;
3184
        }
3185
    }
3186
}
3187

3188
/* 2538E0 -> 253938 */
3189
void Proc801A5110(struct ObjView *view) {
3190
    if (view->flags & VIEW_UPDATE) {
3191
        apply_to_obj_types_in_group(OBJ_TYPE_NETS, (applyproc_t) convert_net_verts, view->components);
3192
    }
3193
}
3194

3195
/* 253938 -> 2539DC; orig name: func_801A5168 */
3196
void update_view_and_dl(struct ObjView *view) {
3197
    UNUSED u32 pad;
3198
    s32 prevFlags; // 18
3199

3200
    prevFlags = view->flags;
3201
    update_view(view);
3202
    if (prevFlags & VIEW_UPDATE) {
3203
        sCurrentGdDl = sMHeadMainDls[gGdFrameBufNum];
3204
        if (view->gdDlNum != 0) {
3205
            func_801A4848(view->gdDlNum);
3206
        }
3207
    }
3208
}
3209

3210
/**
3211
 * Unused - called by __main__
3212
 */
3213
void func_801A520C(void) {
3214
    UNUSED u32 pad[2];
3215

3216
    start_timer("1frame");
3217
    start_timer("cpu");
3218
    stub_renderer_9();
3219
    reset_cur_dl_indices();
3220
    parse_p1_controller();
3221
    setup_timers();
3222
    start_timer("dlgen");
3223
    apply_to_obj_types_in_group(OBJ_TYPE_VIEWS, (applyproc_t) update_view_and_dl, gGdViewsGroup);
3224
    stop_timer("dlgen");
3225
    restart_timer("netupd");
3226
    if (!gGdCtrl.newStartPress) {
3227
        apply_to_obj_types_in_group(OBJ_TYPE_VIEWS, (applyproc_t) Proc801A5110, gGdViewsGroup);
3228
    }
3229
    split_timer("netupd");
3230
    split_timer("cpu");
3231
    func_801A4808();
3232
    restart_timer("cpu");
3233
    func_801A025C();
3234
    update_cursor();
3235
    func_801A4918();
3236
    stop_timer("1frame");
3237
    sTracked1FrameTime = get_scaled_timer_total("1frame");
3238
    split_timer("cpu");
3239
    func_801A01EC();
3240
}
3241

3242
/**
3243
 * Unused
3244
 */
3245
void Unknown801A5344(void) {
3246
    if ((sActiveView = sScreenView) == NULL) {
3247
        return;
3248
    }
3249

3250
    reset_cur_dl_indices();
3251
    sScreenView->gdDlNum = gd_startdisplist(8);
3252
    start_view_dl(sScreenView);
3253
    gd_set_one_cycle();
3254
    gd_enddlsplist_parent();
3255
    func_801A4848(sScreenView->gdDlNum);
3256
    stub_renderer_9();
3257
    func_801A4808();
3258
    sScreenView->gdDlNum = 0;
3259
}
3260

3261
/* 253BC8 -> 2540E0 */
3262
void gd_init(void) {
3263
    s32 i; // 34
3264
    UNUSED u32 pad30;
3265
    s8 *data; // 2c
3266

3267
    imin("gd_init");
3268
#ifndef USE_SYSTEM_MALLOC
3269
    i = (u32)(sMemBlockPoolSize - DOUBLE_SIZE_ON_64_BIT(0x3E800));
3270
    data = gd_allocblock(i);
3271
    gd_add_mem_to_heap(i, data, 0x10);
3272
#endif
3273
    sAlpha = (u16) 0xff;
3274
    D_801A867C = 0;
3275
    D_801A8680 = 0;
3276
    sTextureCount = 0;
3277
    gGdFrameBufNum = 0;
3278
    D_801A86BC = 1;
3279
    sItemsInMenu = 0;
3280
    sDebugViewsCount = 0;
3281
    sCurrDebugViewIndex = 0;
3282
    sGdDlCount = 0;
3283
    D_801A8674 = 0;
3284
    sLightId = 0;
3285
    sAmbScaleColour.r = 0.0f;
3286
    sAmbScaleColour.g = 0.0f;
3287
    sAmbScaleColour.b = 0.0f;
3288

3289
    for (i = 0; i < ARRAY_COUNT(sLightScaleColours); i++) {
3290
        sLightScaleColours[i].r = 1.0f;
3291
        sLightScaleColours[i].g = 0.0f;
3292
        sLightScaleColours[i].b = 0.0f;
3293
        sLightDirections[i].x = 0;
3294
        sLightDirections[i].y = 120;
3295
        sLightDirections[i].z = 0;
3296
    }
3297

3298
    sNumLights = NUMLIGHTS_2;
3299
    gd_set_identity_mat4(&sInitIdnMat4);
3300
    mat4_to_mtx(&sInitIdnMat4, &sIdnMtx);
3301
    remove_all_memtrackers();
3302
    null_obj_lists();
3303
    start_memtracker("total");
3304
    remove_all_timers();
3305

3306
    start_memtracker("Static DL");
3307
    sStaticDl = new_gd_dl(0, 1900, 4000, 1, 300, 8);
3308
    stop_memtracker("Static DL");
3309

3310
    start_memtracker("Dynamic DLs");
3311
    sDynamicMainDls[0] = new_gd_dl(1, 600, 10, 200, 10, 3);
3312
    sDynamicMainDls[1] = new_gd_dl(1, 600, 10, 200, 10, 3);
3313
    stop_memtracker("Dynamic DLs");
3314

3315
    sMHeadMainDls[0] = new_gd_dl(1, 100, 0, 0, 0, 0);
3316
    sMHeadMainDls[1] = new_gd_dl(1, 100, 0, 0, 0, 0);
3317

3318
    for (i = 0; i < ARRAY_COUNT(sViewDls); i++) {
3319
        sViewDls[i][0] = create_child_gdl(1, sDynamicMainDls[0]);
3320
        sViewDls[i][1] = create_child_gdl(1, sDynamicMainDls[1]);
3321
    }
3322

3323
    sScreenView =
3324
        make_view("screenview2", (VIEW_2_COL_BUF | VIEW_UNK_1000 | VIEW_COLOUR_BUF | VIEW_Z_BUF), 0, 0,
3325
                  0, 320, 240, NULL);
3326
    sScreenView->colour.r = 0.0f;
3327
    sScreenView->colour.g = 0.0f;
3328
    sScreenView->colour.b = 0.0f;
3329
    sScreenView->parent = sScreenView;
3330
    sScreenView->flags &= ~VIEW_UPDATE;
3331
    sActiveView = sScreenView;
3332

3333
    // Zero out controller inputs
3334
    data = (s8 *) &gGdCtrl;
3335
    for (i = 0; (u32) i < sizeof(struct GdControl); i++) {
3336
        *data++ = 0;
3337
    }
3338

3339
    // 801A5868
3340
    gGdCtrl.unk88 = 1.0f;
3341
    gGdCtrl.unkA0 = -45.0f;
3342
    gGdCtrl.unkAC = 45.0f;
3343
    gGdCtrl.unk00 = 2;
3344
    gGdCtrl.newStartPress = FALSE;
3345
    gGdCtrl.prevFrame = &gGdCtrlPrev;
3346
    gGdCtrl.csrX = 160;
3347
    gGdCtrl.csrY = 120;
3348
    gGdCtrl.dragStartFrame = -1000;
3349
    unusedDl801BB0AC = create_mtl_gddl(4);
3350
    imout();
3351
}
3352

3353
/**
3354
 * Unused - reverses the characters in `str`.
3355
 */
3356
void reverse_string(char *str, s32 len) {
3357
    char buf[100];
3358
    s32 i;
3359

3360
    for (i = 0; i < len; i++) {
3361
        buf[i] = str[len - i - 1];
3362
    }
3363

3364
    for (i = 0; i < len; i++) {
3365
        str[i] = buf[i];
3366
    }
3367
}
3368

3369
/* 254168 -> 25417C */
3370
void stub_renderer_12(UNUSED s8 *arg0) {
3371
}
3372

3373
/* 25417C -> 254190 */
3374
void stub_renderer_13(UNUSED void *arg0) {
3375
}
3376

3377
/* 254190 -> 2541A4 */
3378
void stub_renderer_14(UNUSED s8 *arg0) {
3379
}
3380

3381
/**
3382
 * Initializes the pick buffer. This functions like the `pick` or `gselect`
3383
 * functions from IRIS GL.
3384
 * @param buf  pointer to an array of 16-bit values
3385
 * @param len  maximum number of values to store
3386
 */
3387
void init_pick_buf(s16 *buf, s32 len) {
3388
    buf[0] = 0;
3389
    buf[1] = 0;
3390
    sPickBufLen = len;
3391
    sPickBuf = buf;
3392
    sPickBufPosition = 0;
3393
}
3394

3395
/**
3396
 * Stores a 16-bit value into the pick buffer. This functions like the
3397
 * `pushname` function from IRIS GL.
3398
 */
3399
void store_in_pickbuf(s16 data) {
3400
    sPickBuf[sPickBufPosition++] = data;
3401
}
3402

3403
/* 25421C -> 254250; orig name: func_801A5A4C
3404
** Divides by 3, since in the final game, only thing stored
3405
** in the pick buf is a tupple of three halves: (datasize, objtype, objnumber)
3406
** (datasize is always 2) */
3407
s32 get_cur_pickbuf_offset(UNUSED s16 *arg0) {
3408
    return sPickBufPosition / 3;
3409
}
3410

3411
/* 254250 -> 254264 */
3412
void stub_renderer_15(UNUSED u32 arg0) {
3413
}
3414

3415
/* 254264 -> 254278 */
3416
void stub_renderer_16(UNUSED u32 arg0) {
3417
}
3418

3419
/* 254278 -> 254288 */
3420
void stub_renderer_17(void) {
3421
}
3422

3423
/* 254288 -> 2542B0 */
3424
void *Unknown801A5AB8(s32 texnum) {
3425
    return sLoadedTextures[texnum];
3426
}
3427

3428
/* 2542B0 -> 254328 */
3429
void Unknown801A5AE0(s32 arg0) {
3430
    D_801BB018 = arg0;
3431
    if (D_801BB01C != D_801BB018) {
3432
        branch_cur_dl_to_num(sTextureDisplayLists[arg0]);
3433
        D_801BB01C = D_801BB018;
3434
    }
3435
}
3436

3437
/* 254328 -> 2543B8; orig name: func_801A5B58 */
3438
void set_vtx_tc_buf(f32 tcS, f32 tcT) {
3439
    sVtxCvrtTCBuf[0] = (s16)(tcS * 512.0f);
3440
    sVtxCvrtTCBuf[1] = (s16)(tcT * 512.0f);
3441
}
3442

3443
/* 2543B8 -> 2543F4 */
3444
void add_debug_view(struct ObjView *view) {
3445
    sDebugViews[sDebugViewsCount++] = view;
3446
}
3447

3448
/* 2543F4 -> 254450; orig name: Unknown801A5C24 */
3449
union ObjVarVal *cvrt_val_to_kb(union ObjVarVal *dst, union ObjVarVal src) {
3450
    union ObjVarVal temp;
3451

3452
    temp.f = src.f / 1024.0; //? 1024.0f
3453
    return (*dst = temp, dst);
3454
}
3455

3456
/* 254450 -> 254560 */
3457
void Unknown801A5C80(struct ObjGroup *parentGroup) {
3458
    struct ObjLabel *label;      // 3c
3459
    struct ObjGroup *debugGroup; // 38
3460

3461
    d_start_group("debugg");
3462
    label = (struct ObjLabel *) d_makeobj(D_LABEL, 0);
3463
    d_set_rel_pos(10.0f, 230.0f, 0.0f);
3464
    d_set_parm_ptr(PARM_PTR_CHAR, gd_strdup("FT %2.2f"));
3465
    d_add_valptr(NULL, 0, OBJ_VALUE_FLOAT, (uintptr_t) &sTracked1FrameTime);
3466
    label->unk30 = 3;
3467
    d_end_group("debugg");
3468

3469
    debugGroup = (struct ObjGroup *) d_use_obj("debugg");
3470
    make_view("debugview", (VIEW_2_COL_BUF | VIEW_ALLOC_ZBUF | VIEW_1_CYCLE | VIEW_DRAW), 2, 0, 0, 320,
3471
              240, debugGroup);
3472

3473
    if (parentGroup != NULL) {
3474
        addto_group(parentGroup, &debugGroup->header);
3475
    }
3476
}
3477

3478
/* 254560 -> 2547C8 */
3479
void Unknown801A5D90(struct ObjGroup *arg0) {
3480
    struct ObjLabel *mtLabel;  // 254
3481
    struct ObjGroup *labelgrp; // 250
3482
    struct ObjView *memview;   // 24c
3483
    s32 trackerNum;                 // memtracker id and/or i
3484
    s32 sp244;                 // label y position?
3485
    s32 sp240;                 // done checking all memtrakcers
3486
    s32 sp23C;                 // memtracker label made?
3487
    char mtStatsFmt[0x100];    // 13c
3488
    char groupId[0x100];       // 3c
3489
    struct MemTracker *mt;     // 38
3490

3491
    sp240 = FALSE;
3492
    trackerNum = -1;
3493

3494
    while (!sp240) {
3495
        sprintf(groupId, "memg%d\n", trackerNum);
3496
        d_start_group(AsDynName(groupId));
3497
        sp244 = 20;
3498
        sp23C = FALSE;
3499

3500
        for (;;) {
3501
            trackerNum += 1;
3502
            mt = get_memtracker_by_index(trackerNum);
3503

3504
            if (mt->name != NULL) {
3505
                sprintf(mtStatsFmt, "%s  %%6.2fk", mt->name);
3506
                mtLabel = (struct ObjLabel *) d_makeobj(D_LABEL, AsDynName(0));
3507
                d_set_rel_pos(10.0f, sp244, 0.0f);
3508
                d_set_parm_ptr(PARM_PTR_CHAR, gd_strdup(mtStatsFmt));
3509
                d_add_valptr(NULL, 0, OBJ_VALUE_FLOAT, (uintptr_t) &mt->total);
3510
                mtLabel->unk30 = 3;
3511
                d_add_valproc(cvrt_val_to_kb);
3512
                sp23C = TRUE;
3513
                sp244 += 14;
3514
                if (sp244 > 200) {
3515
                    break;
3516
                }
3517
            }
3518

3519
            if (trackerNum >= GD_NUM_MEM_TRACKERS) {
3520
                sp240 = TRUE;
3521
                break;
3522
            }
3523
        }
3524

3525
        d_end_group(AsDynName(groupId));
3526
        labelgrp = (struct ObjGroup *) d_use_obj(AsDynName(groupId));
3527

3528
        if (sp23C) {
3529
            memview = make_view("memview",
3530
                                (VIEW_2_COL_BUF | VIEW_ALLOC_ZBUF | VIEW_UNK_2000 | VIEW_UNK_4000
3531
                                 | VIEW_1_CYCLE | VIEW_DRAW),
3532
                                2, 0, 10, 320, 200, labelgrp);
3533
            memview->colour.r = 0.0f;
3534
            memview->colour.g = 0.0f;
3535
            memview->colour.b = 0.0f;
3536
            addto_group(arg0, &labelgrp->header);
3537
            memview->flags &= ~VIEW_UPDATE;
3538
            add_debug_view(memview);
3539
        }
3540
    }
3541
}
3542

3543
/* 2547C8 -> 254AC0 */
3544
void Unknown801A5FF8(struct ObjGroup *arg0) {
3545
    struct ObjView *menuview;      // 3c
3546
    UNUSED struct ObjLabel *label; // 38
3547
    struct ObjGroup *menugrp;      // 34
3548
    UNUSED u32 pad2C[2];
3549

3550
    d_start_group("menug");
3551
    sMenuGadgets[0] = d_makeobj(D_GADGET, "menu0");
3552
    d_set_obj_draw_flag(OBJ_IS_GRABBALE);
3553
    d_set_world_pos(5.0f, 0.0f, 0.0f);
3554
    d_set_scale(100.0f, 20.0f, 0.0f);
3555
    d_set_type(6);
3556
    d_set_colour_num(2);
3557
    label = (struct ObjLabel *) d_makeobj(D_LABEL, AsDynName(0));
3558
    d_set_rel_pos(5.0f, 18.0f, 0.0f);
3559
    d_set_parm_ptr(PARM_PTR_CHAR, "ITEM 1");
3560
    d_add_valptr("menu0", 0x40000, 0, (uintptr_t) NULL);
3561

3562
    sMenuGadgets[1] = d_makeobj(D_GADGET, "menu1");
3563
    d_set_obj_draw_flag(OBJ_IS_GRABBALE);
3564
    d_set_world_pos(5.0f, 25.0f, 0.0f);
3565
    d_set_scale(100.0f, 20.0f, 0.0f);
3566
    d_set_type(6);
3567
    d_set_colour_num(4);
3568
    label = (struct ObjLabel *) d_makeobj(D_LABEL, AsDynName(0));
3569
    d_set_rel_pos(5.0f, 18.0f, 0.0f);
3570
    d_set_parm_ptr(PARM_PTR_CHAR, "ITEM 2");
3571
    d_add_valptr("menu1", 0x40000, 0, (uintptr_t) NULL);
3572

3573
    sMenuGadgets[2] = d_makeobj(D_GADGET, "menu2");
3574
    d_set_obj_draw_flag(OBJ_IS_GRABBALE);
3575
    d_set_world_pos(5.0f, 50.0f, 0.0f);
3576
    d_set_scale(100.0f, 20.0f, 0.0f);
3577
    d_set_type(6);
3578
    d_set_colour_num(3);
3579
    label = (struct ObjLabel *) d_makeobj(D_LABEL, AsDynName(0));
3580
    d_set_rel_pos(5.0f, 18.0f, 0.0f);
3581
    d_set_parm_ptr(PARM_PTR_CHAR, "ITEM 3");
3582
    d_add_valptr("menu2", 0x40000, 0, (uintptr_t) NULL);
3583
    sItemsInMenu = 3;
3584
    d_end_group("menug");
3585

3586
    menugrp = (struct ObjGroup *) d_use_obj("menug");
3587
    menuview = make_view(
3588
        "menuview", (VIEW_2_COL_BUF | VIEW_ALLOC_ZBUF | VIEW_BORDERED | VIEW_UNK_2000 | VIEW_UNK_4000),
3589
        2, 100, 20, 110, 150, menugrp);
3590
    menuview->colour.r = 0.0f;
3591
    menuview->colour.g = 0.0f;
3592
    menuview->colour.b = 0.0f;
3593
    addto_group(arg0, &menugrp->header);
3594
    sMenuView = menuview;
3595
}
3596

3597
/* 254AC0 -> 254DFC; orig name: PutSprite */
3598
void gd_put_sprite(u16 *sprite, s32 x, s32 y, s32 wx, s32 wy) {
3599
    s32 c; // 5c
3600
    s32 r; // 58
3601

3602
    gSPDisplayList(next_gfx(), osVirtualToPhysical(gd_dl_sprite_start_tex_block));
3603
    for (r = 0; r < wy; r += 32) {
3604
        for (c = 0; c < wx; c += 32) {
3605
             gDPLoadTextureBlock(next_gfx(), (r * 32) + sprite + c, G_IM_FMT_RGBA, G_IM_SIZ_16b, 32, 32, 0,
3606
                G_TX_WRAP | G_TX_NOMIRROR, G_TX_WRAP | G_TX_NOMIRROR, G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOLOD)
3607
             gSPTextureRectangle(next_gfx(), x << 2, (y + r) << 2, (x + 32) << 2, (y + r + 32) << 2,
3608
                G_TX_RENDERTILE, 0, 0, 1 << 10, 1 << 10);
3609
        }
3610
    }
3611

3612
    gDPPipeSync(next_gfx());
3613
    gDPSetCycleType(next_gfx(), G_CYC_1CYCLE);
3614
    gDPSetRenderMode(next_gfx(), G_RM_AA_ZB_OPA_INTER, G_RM_NOOP2);
3615
    gSPTexture(next_gfx(), 0x8000, 0x8000, 0, G_TX_RENDERTILE, G_OFF);
3616
}
3617

3618
/* 254DFC -> 254F94; orig name: proc_dyn_list */
3619
void gd_setup_cursor(struct ObjGroup *parentgrp) {
3620
    struct ObjView *mouseview; // 34
3621
    struct ObjGroup *mousegrp; // 30
3622
    UNUSED struct ObjNet *net; // 2c
3623

3624
    sHandShape = make_shape(0, "mouse");
3625
    sHandShape->dlNums[0] = gd_startdisplist(7);
3626
    gd_put_sprite((u16 *) gd_texture_hand_open, 100, 100, 32, 32);
3627
    gd_enddlsplist_parent();
3628
    sHandShape->dlNums[1] = gd_startdisplist(7);
3629
    gd_put_sprite((u16 *) gd_texture_hand_open, 100, 100, 32, 32);
3630
    gd_enddlsplist_parent();
3631

3632
    d_start_group("mouseg");
3633
    net = (struct ObjNet *) d_makeobj(D_NET, AsDynName(0));
3634
    d_set_init_pos(0.0f, 0.0f, 0.0f);
3635
    d_set_type(3);
3636
    d_set_shapeptrptr(&sHandShape);
3637
    d_end_group("mouseg");
3638

3639
    mousegrp = (struct ObjGroup *) d_use_obj("mouseg");
3640
    mouseview = make_view("mouseview",
3641
                          (VIEW_2_COL_BUF | VIEW_ALLOC_ZBUF | VIEW_1_CYCLE | VIEW_MOVEMENT | VIEW_DRAW),
3642
                          2, 0, 0, 32, 32, mousegrp);
3643
    mouseview->flags &= ~VIEW_UPDATE;
3644
    sHandView = mouseview;
3645
    if (parentgrp != NULL) {
3646
        addto_group(parentgrp, &mousegrp->header);
3647
    }
3648
}
3649

3650
/**
3651
 * 254F94 -> 254FE4; orig name: Proc801A67C4
3652
 * This prints all timers if the view was not updated for a frame
3653
 **/
3654
void view_proc_print_timers(struct ObjView *self) {
3655
    if (self->flags & VIEW_WAS_UPDATED) {
3656
        return;
3657
    }
3658

3659
    print_all_timers();
3660
}
3661

3662
/* 254FE4 -> 255600; not called; orig name: Unknown801A6814 */
3663
void make_timer_gadgets(void) {
3664
    struct ObjLabel *timerLabel;
3665
    struct ObjGroup *timerg;
3666
    UNUSED u32 pad6C;
3667
    struct ObjView *timersview;
3668
    struct ObjGadget *bar1;
3669
    struct ObjGadget *bar2;
3670
    struct ObjGadget *bar3;
3671
    struct ObjGadget *bar4;
3672
    struct ObjGadget *bar5;
3673
    struct ObjGadget *bar6;
3674
    struct GdTimer *timer;
3675
    s32 i;
3676
    char timerNameBuf[0x20];
3677

3678
    d_start_group("timerg");
3679
    d_makeobj(D_GADGET, "bar1");
3680
    d_set_obj_draw_flag(OBJ_IS_GRABBALE);
3681
    d_set_world_pos(20.0f, 5.0f, 0.0f);
3682
    d_set_scale(50.0f, 5.0f, 0.0f);
3683
    d_set_type(4);
3684
    d_set_parm_f(PARM_F_RANGE_MIN, 0);
3685
    d_set_parm_f(PARM_F_RANGE_MAX, sTimeScaleFactor);
3686
    d_add_valptr(NULL, 0, OBJ_VALUE_FLOAT, (uintptr_t) &sTimeScaleFactor);
3687
    bar1 = (struct ObjGadget *) d_use_obj("bar1");
3688
    bar1->colourNum = COLOUR_WHITE;
3689

3690
    d_makeobj(D_GADGET, "bar2");
3691
    d_set_obj_draw_flag(OBJ_IS_GRABBALE);
3692
    d_set_world_pos(70.0f, 5.0f, 0.0f);
3693
    d_set_scale(50.0f, 5.0f, 0.0f);
3694
    d_set_type(4);
3695
    d_set_parm_f(PARM_F_RANGE_MIN, 0);
3696
    d_set_parm_f(PARM_F_RANGE_MAX, sTimeScaleFactor);
3697
    d_add_valptr(NULL, 0, OBJ_VALUE_FLOAT, (uintptr_t) &sTimeScaleFactor);
3698
    bar2 = (struct ObjGadget *) d_use_obj("bar2");
3699
    bar2->colourNum = COLOUR_PINK;
3700

3701
    d_makeobj(D_GADGET, "bar3");
3702
    d_set_obj_draw_flag(OBJ_IS_GRABBALE);
3703
    d_set_world_pos(120.0f, 5.0f, 0.0f);
3704
    d_set_scale(50.0f, 5.0f, 0.0f);
3705
    d_set_type(4);
3706
    d_set_parm_f(PARM_F_RANGE_MIN, 0);
3707
    d_set_parm_f(PARM_F_RANGE_MAX, sTimeScaleFactor);
3708
    d_add_valptr(NULL, 0, OBJ_VALUE_FLOAT, (uintptr_t) &sTimeScaleFactor);
3709
    bar3 = (struct ObjGadget *) d_use_obj("bar3");
3710
    bar3->colourNum = COLOUR_WHITE;
3711

3712
    d_makeobj(D_GADGET, "bar4");
3713
    d_set_obj_draw_flag(OBJ_IS_GRABBALE);
3714
    d_set_world_pos(170.0f, 5.0f, 0.0f);
3715
    d_set_scale(50.0f, 5.0f, 0.0f);
3716
    d_set_type(4);
3717
    d_set_parm_f(PARM_F_RANGE_MIN, 0);
3718
    d_set_parm_f(PARM_F_RANGE_MAX, sTimeScaleFactor);
3719
    d_add_valptr(NULL, 0, OBJ_VALUE_FLOAT, (uintptr_t) &sTimeScaleFactor);
3720
    bar4 = (struct ObjGadget *) d_use_obj("bar4");
3721
    bar4->colourNum = COLOUR_PINK;
3722

3723
    d_makeobj(D_GADGET, "bar5");
3724
    d_set_obj_draw_flag(OBJ_IS_GRABBALE);
3725
    d_set_world_pos(220.0f, 5.0f, 0.0f);
3726
    d_set_scale(50.0f, 5.0f, 0.0f);
3727
    d_set_type(4);
3728
    d_set_parm_f(PARM_F_RANGE_MIN, 0);
3729
    d_set_parm_f(PARM_F_RANGE_MAX, sTimeScaleFactor);
3730
    d_add_valptr(NULL, 0, OBJ_VALUE_FLOAT, (uintptr_t) &sTimeScaleFactor);
3731
    bar5 = (struct ObjGadget *) d_use_obj("bar5");
3732
    bar5->colourNum = COLOUR_WHITE;
3733

3734
    d_makeobj(D_GADGET, "bar6");
3735
    d_set_obj_draw_flag(OBJ_IS_GRABBALE);
3736
    d_set_world_pos(270.0f, 5.0f, 0.0f);
3737
    d_set_scale(50.0f, 5.0f, 0.0f);
3738
    d_set_type(4);
3739
    d_set_parm_f(PARM_F_RANGE_MIN, 0);
3740
    d_set_parm_f(PARM_F_RANGE_MAX, sTimeScaleFactor);
3741
    d_add_valptr(NULL, 0, OBJ_VALUE_FLOAT, (uintptr_t) &sTimeScaleFactor);
3742
    bar6 = (struct ObjGadget *) d_use_obj("bar6");
3743
    bar6->colourNum = COLOUR_PINK;
3744

3745
    for (i = 0; i < GD_NUM_TIMERS; i++) {
3746
        sprintf(timerNameBuf, "tim%d\n", i);
3747

3748
        timer = get_timernum(i);
3749

3750
        d_makeobj(D_GADGET, timerNameBuf);
3751
        d_set_obj_draw_flag(OBJ_IS_GRABBALE);
3752
        d_set_world_pos(20.0f, (f32)((i * 15) + 15), 0.0f);
3753
        d_set_scale(50.0f, 14.0f, 0);
3754
        d_set_type(4);
3755
        d_set_parm_f(PARM_F_RANGE_MIN, 0.0f);
3756
        d_set_parm_f(PARM_F_RANGE_MAX, 1.0f);
3757
        d_add_valptr(NULL, 0, OBJ_VALUE_FLOAT, (uintptr_t) &timer->prevScaledTotal);
3758
        sTimerGadgets[i] = (struct ObjGadget *) d_use_obj(timerNameBuf);
3759
        sTimerGadgets[i]->colourNum = timer->gadgetColourNum;
3760

3761
        timerLabel = (struct ObjLabel *) d_makeobj(D_LABEL, AsDynName(0));
3762
        d_set_rel_pos(5.0f, 14.0f, 0);
3763
        d_set_parm_ptr(PARM_PTR_CHAR, (void *) timer->name);
3764
        d_add_valptr(timerNameBuf, 0x40000, 0, (uintptr_t) NULL);
3765
        timerLabel->unk30 = 3;
3766
    }
3767

3768
    d_end_group("timerg");
3769
    timerg = (struct ObjGroup *) d_use_obj("timerg");
3770
    timersview = make_view(
3771
        "timersview", (VIEW_2_COL_BUF | VIEW_ALLOC_ZBUF | VIEW_1_CYCLE | VIEW_MOVEMENT | VIEW_DRAW), 2,
3772
        0, 10, 320, 270, timerg);
3773
    timersview->colour.r = 0.0f;
3774
    timersview->colour.g = 0.0f;
3775
    timersview->colour.b = 0.0f;
3776
    timersview->flags &= ~VIEW_UPDATE;
3777
    timersview->proc = view_proc_print_timers;
3778
    add_debug_view(timersview);
3779

3780
    return;
3781
}
3782

3783
/* 255600 -> 255614 */
3784
void stub_renderer_18(UNUSED u32 a0) {
3785
}
3786

3787
/* 255614 -> 255628 */
3788
void stub_renderer_19(UNUSED u32 a0) {
3789
}
3790

3791
#ifndef NO_SEGMENTED_MEMORY
3792
/**
3793
 * Copies `size` bytes of data from ROM address `romAddr` to RAM address `vAddr`.
3794
 */
3795
static void gd_block_dma(u32 romAddr, void *vAddr, s32 size) {
3796
    s32 blockSize;
3797

3798
    do {
3799
        if ((blockSize = size) > 0x1000) {
3800
            blockSize = 0x1000;
3801
        }
3802

3803
        osPiStartDma(&sGdDMAReqMesg, OS_MESG_PRI_NORMAL, OS_READ, romAddr, vAddr, blockSize, &sGdDMAQueue);
3804
        osRecvMesg(&sGdDMAQueue, &sGdDMACompleteMsg, OS_MESG_BLOCK);
3805
        romAddr += blockSize;
3806
        vAddr = (void *) ((uintptr_t) vAddr + blockSize);
3807
        size -= 0x1000;
3808
    } while (size > 0);
3809
}
3810

3811
/**
3812
 * Loads the specified DynList from ROM and processes it.
3813
 */
3814
struct GdObj *load_dynlist(struct DynList *dynlist) {
3815
    u32 segSize;
3816
    u8 *allocSegSpace;
3817
    void *allocPtr;
3818
    uintptr_t dynlistSegStart;
3819
    uintptr_t dynlistSegEnd;
3820
    s32 i;
3821
    s32 tlbEntries;
3822
    struct GdObj *loadedList;
3823

3824
    i = -1;
3825

3826
    // Make sure the dynlist exists
3827
    while (sDynLists[++i].list != NULL) {
3828
        if (sDynLists[i].list == dynlist) {
3829
            break;
3830
        }
3831
    }
3832
    if (sDynLists[i].list == NULL) {
3833
        fatal_printf("load_dynlist() ptr not found in any banks");
3834
    }
3835

3836
    switch (sDynLists[i].flag) {
3837
        case STD_LIST_BANK:
3838
            dynlistSegStart = (uintptr_t) _gd_dynlistsSegmentRomStart;
3839
            dynlistSegEnd = (uintptr_t) _gd_dynlistsSegmentRomEnd;
3840
            break;
3841
        default:
3842
            fatal_printf("load_dynlist() unkown bank");
3843
    }
3844

3845
#define PAGE_SIZE 65536  // size of a 64K TLB page
3846

3847
    segSize = dynlistSegEnd - dynlistSegStart;
3848
    allocSegSpace = gd_malloc_temp(segSize + PAGE_SIZE);
3849

3850
    if ((allocPtr = (void *) allocSegSpace) == NULL) {
3851
        fatal_printf("Not enough DRAM for DATA segment \n");
3852
    }
3853

3854
    allocSegSpace = (u8 *) (((uintptr_t) allocSegSpace + PAGE_SIZE) & 0xFFFF0000);
3855

3856
    // Copy the dynlist data from ROM
3857
    gd_block_dma(dynlistSegStart, (void *) allocSegSpace, segSize);
3858

3859
    osUnmapTLBAll();
3860

3861
    tlbEntries = (segSize / PAGE_SIZE) / 2 + 1;
3862
    if (tlbEntries >= 31) {
3863
        fatal_printf("load_dynlist() too many TLBs");
3864
    }
3865

3866
    // Map virtual address 0x04000000 to `allocSegSpace`
3867
    for (i = 0; i < tlbEntries; i++) {
3868
        osMapTLB(i, OS_PM_64K,
3869
            (void *) (uintptr_t) (0x04000000 + (i * 2 * PAGE_SIZE)),  // virtual address to map
3870
            GD_LOWER_24(((uintptr_t) allocSegSpace) + (i * 2 * PAGE_SIZE) + 0),  // even page address
3871
            GD_LOWER_24(((uintptr_t) allocSegSpace) + (i * 2 * PAGE_SIZE) + PAGE_SIZE),  // odd page address
3872
            -1);
3873
    }
3874

3875
#undef PAGE_SIZE
3876

3877
    // process the dynlist
3878
    loadedList = proc_dynlist(dynlist);
3879

3880
    gd_free(allocPtr);
3881
    osUnmapTLBAll();
3882

3883
    return loadedList;
3884
}
3885
#else
3886
struct GdObj *load_dynlist(struct DynList *dynlist) {
3887
    return proc_dynlist(dynlist);
3888
}
3889
#endif
3890

3891
/**
3892
 * Unused (not called)
3893
 */
3894
void stub_renderer_20(UNUSED u32 a0) {
3895
}
3896

3897
/**
3898
 * Unused (not called)
3899
 */
3900
void func_801A71CC(struct ObjNet *net) {
3901
    s32 i; // spB4
3902
    s32 j; // spB0
3903
    f32 spAC;
3904
    f32 spA8;
3905
    struct GdBoundingBox bbox;
3906
    UNUSED u32 pad8C;
3907
    struct ObjZone *sp88;
3908
    register struct ListNode *link;  // s0 (84)
3909
    s32 sp80;                     // linked planes contained in zone?
3910
    s32 sp7C;                     // linked planes in net count?
3911
    register struct ListNode *link1; // s1 (78)
3912
    register struct ListNode *link2; // s2 (74)
3913
    register struct ListNode *link3; // s3 (70)
3914
    struct GdVec3f sp64;
3915
    UNUSED u32 pad60;
3916
    struct ObjPlane *plane; // 5c
3917
    UNUSED u32 pad58;
3918
    struct ObjZone *linkedZone; // 54
3919
    UNUSED u32 pad50;
3920
    struct ObjPlane *planeL2; // 4c
3921
    UNUSED u32 pad48;
3922
    struct ObjPlane *planeL3; // 44
3923

3924
    if (net->unk21C == NULL) {
3925
        net->unk21C = make_group(0);
3926
    }
3927

3928
    gd_print_bounding_box("making zones for net=", &net->boundingBox);
3929

3930
    sp64.x = (ABS(net->boundingBox.minX) + ABS(net->boundingBox.maxX)) / 16.0f;
3931
    sp64.z = (ABS(net->boundingBox.minZ) + ABS(net->boundingBox.maxZ)) / 16.0f;
3932

3933
    spA8 = net->boundingBox.minZ + sp64.z / 2.0f;
3934

3935
    for (i = 0; i < 16; i++) {
3936
        spAC = net->boundingBox.minX + sp64.x / 2.0f;
3937

3938
        for (j = 0; j < 16; j++) {
3939
            bbox.minX = spAC - (sp64.x / 2.0f);
3940
            bbox.minY = 0.0f;
3941
            bbox.minZ = spA8 - (sp64.z / 2.0f);
3942

3943
            bbox.maxX = spAC + (sp64.x / 2.0f);
3944
            bbox.maxY = 0.0f;
3945
            bbox.maxZ = spA8 + (sp64.z / 2.0f);
3946

3947
            sp88 = make_zone(NULL, &bbox, NULL);
3948
            addto_group(net->unk21C, &sp88->header);
3949
            sp88->unk2C = make_group(0);
3950

3951
            spAC += sp64.x;
3952
        }
3953
        spA8 += sp64.z;
3954
    }
3955

3956
    for (link = net->unk1CC->firstMember; link != NULL; link = link->next) {
3957
        plane = (struct ObjPlane *) link->obj;
3958
        plane->unk18 = FALSE;
3959
    }
3960

3961
    i = 0; // acts as Zone N here... kinda
3962
    for (link1 = net->unk21C->firstMember; link1 != NULL; link1 = link1->next) {
3963
        linkedZone = (struct ObjZone *) link1->obj;
3964
        sp88 = linkedZone;
3965
        sp7C = 0;
3966
        sp80 = 0;
3967

3968
        for (link2 = net->unk1CC->firstMember; link2 != NULL; link2 = link2->next) {
3969
            planeL2 = (struct ObjPlane *) link2->obj;
3970
            sp7C += 1;
3971
            if (gd_plane_point_within(&planeL2->boundingBox, &sp88->boundingBox)) {
3972
                planeL2->unk18 = TRUE;
3973
                addto_group(sp88->unk2C, &planeL2->header);
3974
                sp80 += 1;
3975
            }
3976
        }
3977

3978
        if (sp80 == 0) {
3979
            stub_objects_1(net->unk21C, &linkedZone->header); // stubbed fatal function?
3980
        } else {
3981
            gd_printf("%d/%d planes in zone %d\n", sp80, sp7C, i++);
3982
        }
3983
    }
3984

3985
    for (link3 = net->unk1CC->firstMember; link3 != NULL; link3 = link3->next) {
3986
        planeL3 = (struct ObjPlane *) link3->obj;
3987

3988
        if (!planeL3->unk18) {
3989
            gd_print_bounding_box("plane=", &planeL3->boundingBox);
3990
            fatal_printf("plane not in any zones\n");
3991
        }
3992
    }
3993
}
3994

3995
/* 255EB0 -> 255EC0 */
3996
void stub_renderer_21(void) {
3997
}
3998

3999
Product

Resources

Company
