Paper Mario DX
Paper Mario (N64) modding
 
Loading...
Searching...
No Matches
43F0.c File Reference

Go to the source code of this file.

Macros

#define ROM_CHUNK_SIZE   0x2000
 

Functions

void dma_write_block (Addr dramAddr, u32 devAddr, s32 size)
 
f32 length2D (f32 x, f32 y)
 
HeapNode_heap_create (HeapNode *addr, u32 size)
 
void_heap_malloc (HeapNode *head, u32 size)
 
void_heap_malloc_tail (HeapNode *head, u32 size)
 
u32 _heap_free (HeapNode *heapNodeList, void *addrToFree)
 
void_heap_realloc (HeapNode *heapNodeList, void *addr, u32 newSize)
 
f32 cosine (s16 arg0)
 
s32 sign (s32 val)
 
charint_to_string (s32 integer, char *dest, s32 base)
 
void mem_clear (void *data, s32 numBytes)
 
void transform_point (Matrix4f mtx, f32 inX, f32 inY, f32 inZ, f32 inS, f32 *outX, f32 *outY, f32 *outZ, f32 *outW)
 
void copy_matrix (Matrix4f src, Matrix4f dest)
 
u32 dma_copy (Addr romStart, Addr romEnd, void *vramDest)
 
s32 dma_write (Addr romStart, Addr romEnd, void *vramDest)
 
u32 advance_rng (void)
 
f32 rand_float (void)
 
s32 rand_int_internal (u32 max)
 
s32 rand_int (s32 max)
 
f32 signF (f32 val)
 
s32 round (f32 x)
 
f32 clamp_angle (f32 theta)
 
f32 get_clamped_angle_diff (f32 a, f32 b)
 
f32 atan2 (f32 startX, f32 startZ, f32 endX, f32 endZ)
 
f32 get_player_normal_yaw (void)
 
f32 get_player_normal_pitch (void)
 
f32 dist2D (f32 ax, f32 ay, f32 bx, f32 by)
 
f32 dist3D (f32 ax, f32 ay, f32 az, f32 bx, f32 by, f32 bz)
 
void add_vec2D_polar (f32 *x, f32 *y, f32 r, f32 theta)
 
u16 _wrap_trig_lookup_value (f32 theta)
 
void sin_cos_rad (f32 theta, f32 *outSinTheta, f32 *outCosTheta)
 
f32 sin_rad (f32 theta)
 
f32 cos_rad (f32 theta)
 
void sin_cos_deg (f32 theta, f32 *outSinTheta, f32 *outCosTheta)
 
f32 sin_deg (f32 theta)
 
f32 cos_deg (f32 theta)
 
f32 update_lerp (s32 easing, f32 start, f32 end, s32 elapsed, s32 duration)
 
void appendGfx_startup_prim_rect (u8 r, u8 g, u8 b, u8 a, u16 left, u16 top, u16 right, u16 bottom)
 
void startup_draw_prim_rect_COPY (s16 left, s16 top, s16 right, s16 bottom, u16 r, u16 g, u16 b, u16 a)
 
void startup_draw_prim_rect (s16 left, s16 top, s16 right, s16 bottom, u16 r, u16 g, u16 b, u16 a)
 

Variables

u16 heap_nextMallocID = 0
 
f32 sCosineTable []
 
u8 sIntegerDigits []
 
u32 gRandSeed = 1
 
f32 sAtanFactors []
 
Gfx D_80074580 []
 

Macro Definition Documentation

◆ ROM_CHUNK_SIZE

#define ROM_CHUNK_SIZE   0x2000

Definition at line 56 of file 43F0.c.

Referenced by dma_copy(), and dma_write().

Function Documentation

◆ dma_write_block()

void dma_write_block ( Addr dramAddr,
u32 devAddr,
s32 size )

Definition at line 474 of file 43F0.c.

474 {
478
481
482 osIoMesg.hdr.pri = 0;
483 osIoMesg.hdr.retQueue = &osMesgQueue;
484 osIoMesg.dramAddr = dramAddr;
485 osIoMesg.devAddr = devAddr;
486 osIoMesg.size = size;
487
490}
BSS s32 PopupMenu_SelectedIndex

Referenced by dma_write().

◆ length2D()

f32 length2D ( f32 x,
f32 y )

Definition at line 58 of file 43F0.c.

58 {
59 return sqrtf(SQ(x) + SQ(y));
60}
#define sqrtf
#define SQ(x)
Definition macros.h:170

Referenced by ArcsinDeg().

◆ _heap_create()

HeapNode * _heap_create ( HeapNode * addr,
u32 size )

Definition at line 62 of file 43F0.c.

62 {
63 if (size < 32) {
64 return (HeapNode*)-1;
65 } else {
67
68 size -= ((u8*)heapNode - (u8*)addr);
70 heapNode->length = size - sizeof(HeapNode);
71 heapNode->allocated = 0;
72 heapNode->capacity = size;
73 return heapNode;
74 }
75}
struct HeapNode * next
#define ALIGN16(val)
Definition macros.h:20

Referenced by battle_heap_create(), battle_heap_create_obfuscated(), collision_heap_create(), general_heap_create(), and spr_init_sprites().

◆ _heap_malloc()

void * _heap_malloc ( HeapNode * head,
u32 size )

Definition at line 77 of file 43F0.c.

77 {
84 u16 HeapEntryID;
85 u16 HeapEntryID2;
86
87 // must allocate 16 bytes or more at minimum or fail
88 size = ALIGN16(size);
89 if (!size) {
90 debug_printf("warning: attempt to malloc less than 16 bytes\n");
91 return NULL;
92 }
93
96
97 // find the smallest block we can fit into in the free list
98 for (curHeapNode = head; ; curHeapNode = curHeapNode->next) {
99 if (!curHeapNode->allocated) {
100 curBlockLength = curHeapNode->length;
105 }
106 }
107 if (!curHeapNode->next) {
108 break;
109 }
110 }
111
112 // find out the required block size with header
113 newBlockSize = size + sizeof(HeapNode);
114
115 // if we found a block see if we need to split it up
116 if (smallestBlockFound) {
118 // update previous to the proper size for the block being returned
120 pPrevHeapNode->length = size;
121
122 // update the entry id on allocation
124 pPrevHeapNode->allocated = TRUE;
126 pPrevHeapNode->entryID = HeapEntryID;
127
128 // setup the new heap block entry
132 curHeapNode->allocated = FALSE;
133 } else {
134 // take this entry out of the free linked list and mark as allocated
137
138 // update the entry id on allocation
139 // note, usage of a single ID from above will result in wrong code
141 pPrevHeapNode->allocated = TRUE;
143 pPrevHeapNode->entryID = HeapEntryID2;
144 }
145 return (u8*)pPrevHeapNode + sizeof(HeapNode);
146 }
147 debug_printf("warning: out of memory\n");
148 return NULL;
149}
u16 heap_nextMallocID
Definition 43F0.c:5
#define debug_printf(fmt, args...)
Definition debug_menu.h:84

Referenced by _heap_realloc(), collision_heap_malloc(), general_heap_malloc(), heap_malloc(), imgfx_init(), spr_allocate_components(), spr_init_player_raster_cache(), spr_init_quad_cache(), and spr_load_sprite().

◆ _heap_malloc_tail()

void * _heap_malloc_tail ( HeapNode * head,
u32 size )

Definition at line 151 of file 43F0.c.

151 {
157
158 size = ALIGN16(size);
159 foundNode = NULL;
160
161 // make sure we have a size to allocate
162 if (!size) {
163 debug_printf("warning: attempt to malloc less than 16 bytes\n");
164 return NULL;
165 }
166
167 foundNodeLength = 0;
168 nextNode = NULL;
169
170 // find the smallest block we can fit into
171 for (curNode = head; ; curNode = curNode->next) {
172 if (!curNode->allocated) {
173 if (curNode->length >= size) {
175 foundNodeLength = curNode->length;
176 nextNode = curNode->next;
177 }
178 }
179
180 if (!curNode->next) {
181 break;
182 }
183 }
184
185 newNodeSize = size + sizeof(HeapNode);
186 if (foundNodeLength != 0) {
188
189 // we found a block to use, see if we can split it and return a portion
190 // or if we just need to return the whole block
192 // add a free block before this one
193 // this is where this function differs from heap_malloc, it returns
194 // the end of the block instead of the beginning when splitting it up
195 curNode->next = (HeapNode*)((u8*)curNode + foundNodeLength - size);
197 curNode->allocated = FALSE;
198
199 curNode = curNode->next;
200 curNode->next = nextNode;
201 curNode->length = size;
202 curNode->allocated = TRUE;
203
204 } else {
205 // just return this actual block
206 curNode->next = nextNode;
207 curNode->length = foundNodeLength;
208 curNode->allocated = TRUE;
209 }
210
211 return (u8*)curNode + sizeof(HeapNode);
212 }
213
214 // did not find a block
215 debug_printf("warning: out of memory\n");
216 return NULL;
217}

Referenced by general_heap_malloc_tail(), and spr_load_sprite().

◆ _heap_free()

u32 _heap_free ( HeapNode * heapNodeList,
void * addrToFree )

Definition at line 219 of file 43F0.c.

219 {
225
226 // if no address to free then return
227 if (addrToFree == NULL) {
228 return TRUE;
229 }
230
231 // if we are not allocated then ignore this request
233 if (!nodeToFreeHeader->allocated) {
234 return TRUE;
235 }
236
240
241 // see if the next node after us is allocated, if not then adjust our size
242 // to include it and point nextNode to be the node after as it must be allocated
243 if (nextNode && !nextNode->allocated) {
244 curNodeLength += nextNode->length + sizeof(HeapNode);
245 nextNode = nextNode->next;
246 }
247
248 // walk the full heap node list looking for the block before our current entry
250 while (TRUE) {
251 // get the pointer to the next block, if it matches the block being freed then
252 // exit the search
253 heapNodeList = tempNode->next;
255
256 // we found the node prior to us, if it is not allocated then adjust our total
257 // size to include it and change the header node pointer to point that block
258 if (!tempNode->allocated) {
259 curNodeLength += sizeof(HeapNode) + tempNode->length;
261 }
262 break;
263 }
264
265 // if the node being freed is before the current node being looked at then we
266 // moved past our current node, bail out. Also bail if we hit the end of the list
268 break;
269 }
270
271 // move to the next node
272 tempNode = tempNode->next;
273 }
274
275 // update the node being free'd with a proper size and pointer to the next node that is
276 // allocated
278 outNode->next = nextNode;
279 outNode->length = curNodeLength;
280 outNode->allocated = FALSE;
281 return FALSE;
282}

Referenced by _heap_realloc(), collision_heap_free(), general_heap_free(), heap_free(), and spr_free_sprite().

◆ _heap_realloc()

void * _heap_realloc ( HeapNode * heapNodeList,
void * addr,
u32 newSize )

Definition at line 284 of file 43F0.c.

284 {
291
292 curHeapAlloc = (HeapNode*)((u8*)addr - sizeof(HeapNode));
294
295 // check if the realloc is on an allocated node otherwise fail
296 if (!curHeapAlloc->allocated) {
297 return NULL;
298 }
299
300 nextNode = curHeapAlloc->next;
301 newNodeLength = curHeapAlloc->length;
302
303 // if we have a node after us and it isn't allocated then
304 // adjust the length and next node pointers to include the node after us
306 if (nextNode && !nextNode->allocated) {
307 nextNode = nextNode->next;
308 newNodeLength += sizeof(HeapNode) + nodeToUpdate->length;
309 }
310
311 // check if the current block or current + next block (if free) are too small
314 // too small, allocatr a new node, copy data to it then free the current one
316 if (curHeapAlloc == NULL) {
317 return NULL;
318 }
319
320 // minor interest note, copy the size of the newly allocated size
321 // instead of just how much data used to be stored, this results in copying
322 // excessive data
325 return curHeapAlloc;
326 }
327
328 // see if there is room to add a new free block after us
329 if (newSizeAligned + sizeof(HeapNode) < newNodeLength) {
330 // room for a free block, create it
331 newFreeBlock = (HeapNode*)((u8*)addr + newSizeAligned);
332
333 // update current node
336
337 // create new node after the current one
339 nodeToUpdate->next = nextNode;
340 nodeToUpdate->length = (newNodeLength - newSizeAligned) - sizeof(HeapNode);
341 nodeToUpdate->allocated = FALSE;
342 } else {
343 // no room, update our next and length
344 nodeToUpdate->next = nextNode;
345 nodeToUpdate->length = newNodeLength;
346 }
347
348 // return the location we were at
349 return addr;
350}
void * _heap_malloc(HeapNode *head, u32 size)
Definition 43F0.c:77
u32 _heap_free(HeapNode *heapNodeList, void *addrToFree)
Definition 43F0.c:219

Referenced by spr_load_npc_extra_anims().

◆ cosine()

f32 cosine ( s16 arg0)

Definition at line 352 of file 43F0.c.

352 {
353 s16 temp360;
354 s16 idx;
355
356 temp360 = arg0 % 360;
357
358 if (temp360 < 0) {
359 temp360 += 360;
360 }
361
362 idx = temp360 % 180;
363 if (idx > 90) {
364 idx = 180 - idx;
365 }
366
367 if (temp360 >= 180) {
368 return -sCosineTable[idx];
369 } else {
370 return sCosineTable[idx];
371 }
372}
f32 sCosineTable[]
Definition 43F0.c:7

Referenced by appendGfx_message(), imgfx_appendGfx_mesh(), msg_draw_choice_pointer(), msg_draw_speech_arrow(), msg_update_rewind_arrow(), npc_update_decoration_charged(), part_glow_on(), and SentinelAI_Descend().

◆ sign()

s32 sign ( s32 val)

Definition at line 374 of file 43F0.c.

374 {
375 s32 sign = -1;
376
377 if (val >= 0) {
378 sign = val > 0;
379 }
380 return sign;
381}
s32 sign(s32 val)
Definition 43F0.c:374

Referenced by imgfx_mesh_make_wavy(), pause_interp_text_scroll(), pause_interp_vertical_scroll(), pause_partners_update(), pause_tabs_update(), show_immune_bonk(), sign(), and signF().

◆ int_to_string()

char * int_to_string ( s32 integer,
char * dest,
s32 base )

Definition at line 384 of file 43F0.c.

384 {
385 u8 string[40]; // Even for binary this is a little long: 34 would suffice
386 s32 i = ARRAY_COUNT(string) - 2;
387 s32 negative = FALSE;
389
390 // handle negative integers
391 if (longInteger < 0) {
392 negative = TRUE;
393 longInteger *= -1;
394 }
395
396 // null-terminate string
397 string[ARRAY_COUNT(string) - 1] = '\0';
398
399 // extract digits, filling string from the back
400 while (TRUE) {
401 string[i] = sIntegerDigits[longInteger % base];
402 longInteger /= base;
403 if (longInteger == 0 || i == 0) {
404 break;
405 }
406 i--;
407 }
408
409 // Add - to negatives
410 if (negative) {
411 i--;
412 string[i] = '-';
413 }
414
415 // copy only populated part of string
416 strcpy(dest, &string[i]);
417
418 return dest;
419}
u8 sIntegerDigits[]
Definition 43F0.c:20
#define ARRAY_COUNT(arr)
Definition macros.h:40

Referenced by draw_number(), and set_message_int_var().

◆ mem_clear()

void mem_clear ( void * data,
s32 numBytes )

Definition at line 421 of file 43F0.c.

421 {
422 u8* addressableData = data;
423
424 while (numBytes > 0) {
425 *addressableData++ = 0;
426 numBytes--;
427 }
428}

◆ transform_point()

void transform_point ( Matrix4f mtx,
f32 inX,
f32 inY,
f32 inZ,
f32 inS,
f32 * outX,
f32 * outY,
f32 * outZ,
f32 * outW )

Definition at line 430 of file 43F0.c.

430 {
431 *outX = (mtx[0][0] * inX) + (mtx[1][0] * inY) + (mtx[2][0] * inZ) + mtx[3][0];
432 *outY = (mtx[0][1] * inX) + (mtx[1][1] * inY) + (mtx[2][1] * inZ) + mtx[3][1];
433 *outZ = (mtx[0][2] * inX) + (mtx[1][2] * inY) + (mtx[2][2] * inZ) + mtx[3][2];
434 *outW = (mtx[0][3] * inX) + (mtx[1][3] * inY) + (mtx[2][3] * inZ) + mtx[3][3];
435}

◆ copy_matrix()

void copy_matrix ( Matrix4f src,
Matrix4f dest )

Definition at line 437 of file 43F0.c.

437 {
438 bcopy(src, dest, sizeof(Matrix4f));
439}
f32 Matrix4f[4][4]

Referenced by animator_node_update_model_transform(), and update_collider_transform().

◆ dma_copy()

◆ dma_write()

s32 dma_write ( Addr romStart,
Addr romEnd,
void * vramDest )

Definition at line 459 of file 43F0.c.

459 {
460 u32 length = romEnd - romStart;
461 s32 i;
462
463 for (i = 0; i + ROM_CHUNK_SIZE < length; i += ROM_CHUNK_SIZE) {
464 dma_write_block(romStart + i, (u32)vramDest + i, ROM_CHUNK_SIZE);
465 }
466
467 if (i != length) {
468 dma_write_block(romStart + i, (u32)vramDest + i, length - i);
469 }
470
471 return length;
472}
void dma_write_block(Addr dramAddr, u32 devAddr, s32 size)
Definition 43F0.c:474

◆ advance_rng()

u32 advance_rng ( void )

Definition at line 493 of file 43F0.c.

493 {
494 gRandSeed = gRandSeed * 0x5D588B65 + 1;
495
497
498 return gRandSeed;
499}
u32 gRandSeed
Definition 43F0.c:27
GameStatus * gGameStatusPtr
Definition main_loop.c:31

Referenced by rand_float(), and rand_int_internal().

◆ rand_float()

f32 rand_float ( void )

Definition at line 502 of file 43F0.c.

502 {
503 return (advance_rng() & 0x7FFF) / 32768.0;
504}
u32 advance_rng(void)
Definition 43F0.c:493

Referenced by entity_shattering_init_pieces().

◆ rand_int_internal()

s32 rand_int_internal ( u32 max)

Definition at line 507 of file 43F0.c.

507 {
508 u32 partitionSize = 0xFFFFFFFF;
509 u32 maxPlusOne = max + 1;
510 u32 result;
511
512 // split [0,2^32) into ``maxPlusOne`` equally sized partitions
513 // [0, partitionSize), [partitionSize, 2*partitionSize), ... [maxPlusOne*partitionSize, 2^32)
515 if (partitionSize == 0) {
516 partitionSize = 1;
517 }
518
519 // numbers in the leftover [maxPlusOne*partitionSize, 2^32) are rejected as they would return maxPlusOne
520 // this ensures the result is [0,max] whilst also ensuring each partition is the same size and equally probable
521 do {
522 // determine which partition the random number is in by dividing it by partitionSize
523 result = advance_rng() / partitionSize;
524 } while (result >= maxPlusOne);
525
526 return result;
527}

Referenced by rand_int().

◆ rand_int()

s32 rand_int ( s32 max)

Definition at line 530 of file 43F0.c.

530 {
531 s32 ret = 0;
532
533 max = abs(max);
534
535 if (max != 0) {
536 switch (max) {
537 case 1:
538 // due to the off-by-one input of 1000 and the > operator being used,
539 // there is a 501/1001 chance of returning 0 and a 500/1001 chance of returning 1
540 // (assuming statistical randomness of rand_int_internal).
541 ret = rand_int_internal(1000) > 500;
542 break;
543 default:
544 ret = rand_int_internal(max);
545 break;
546 case 100:
547 ret = rand_int_internal(1009) / 10;
548 break;
549 }
550 }
551
552 return ret;
553}
s32 rand_int_internal(u32 max)
Definition 43F0.c:507

◆ signF()

f32 signF ( f32 val)

Definition at line 555 of file 43F0.c.

555 {
556 f32 sign;
557
558 if (!(val > 0.0f)) {
559 sign = -1.0f;
560 if (!(val < 0.0f)) {
561 sign = 0.0f;
562 }
563 } else {
564 sign = 1.0f;
565 }
566
567 return sign;
568}

Referenced by FireBarAI_Callback().

◆ round()

s32 round ( f32 x)

Definition at line 570 of file 43F0.c.

570 {
571 if (!(x >= 0.0f)) {
572 return -(s32)(0.5 - x);
573 } else {
574 return (s32)(0.5 + x);
575 }
576}

Referenced by atan2().

◆ clamp_angle()

f32 clamp_angle ( f32 theta)

Definition at line 578 of file 43F0.c.

578 {
579 if (fabsf(theta) > 3600.0f) {
580 s32 thetaInt = theta;
581
582 if (thetaInt >= 0) {
583 thetaInt = -(thetaInt / 360 * 360) + thetaInt;
584 } else {
586 thetaInt = (thetaInt / 360 * 360) - thetaInt;
587 }
588
589 return thetaInt;
590 }
591
592 do {
593 if (theta < 0.0f) {
594 theta += 360.0f;
595 }
596 if (theta >= 360.0f) {
597 theta -= 360.0f;
598 }
599 } while (!(theta >= 0.0f) || !(theta < 360.0f));
600
601 return theta;
602}
f32 fabsf(f32 f)

◆ get_clamped_angle_diff()

◆ atan2()

f32 atan2 ( f32 startX,
f32 startZ,
f32 endX,
f32 endZ )

Definition at line 615 of file 43F0.c.

615 {
616 f32 dx = endX - startX;
617 f32 dz = endZ - startZ;
618 f32 absXDiff = fabsf(dx);
619 f32 absZDiff = fabsf(dz);
620 f32 ret;
621
622 if (absZDiff < absXDiff) {
623 ret = (absZDiff / absXDiff) * 45.0f;
624 ret *= sAtanFactors[round(2.0f * ret)];
625 if (dx >= 0.0f) {
626 if (dz >= 0.0f) {
627 return ret + 90.0f;
628 } else {
629 return 90.0f - ret;
630 }
631 }
632 if (dz >= 0.0f) {
633 return 270.0f - ret;
634 } else {
635 return ret + 270.0f;
636 }
637 } else {
638 if (absZDiff == 0.0f) {
639 return 0.0f;
640 }
641 ret = (absXDiff / absZDiff) * 45.0f;
642 ret *= sAtanFactors[round(2.0f * ret)];
643 if (dz >= 0.0f) {
644 if (dx >= 0.0f) {
645 return 180.0f - ret;
646 } else {
647 return ret + 180.0f;
648 }
649 } else if (!(dx >= 0.0f)) {
650 return 360.0f - ret;
651 }
652 }
653 return ret;
654}
s32 round(f32 x)
Definition 43F0.c:570
f32 sAtanFactors[]
Definition 43F0.c:29

◆ get_player_normal_yaw()

f32 get_player_normal_yaw ( void )

Definition at line 656 of file 43F0.c.

Referenced by player_raycast_down(), and update_player_shadow().

◆ get_player_normal_pitch()

◆ dist2D()

f32 dist2D ( f32 ax,
f32 ay,
f32 bx,
f32 by )

◆ dist3D()

f32 dist3D ( f32 ax,
f32 ay,
f32 az,
f32 bx,
f32 by,
f32 bz )

Definition at line 675 of file 43F0.c.

675 {
676 f32 xDiff = bx - ax;
677 f32 yDiff = by - ay;
678 f32 zDiff = bz - az;
679
680 return sqrtf(SQ(xDiff) + SQ(yDiff) + SQ(zDiff));
681}

Referenced by update_triggers().

◆ add_vec2D_polar()

◆ _wrap_trig_lookup_value()

u16 _wrap_trig_lookup_value ( f32 theta)

Definition at line 693 of file 43F0.c.

693 {
694 f32 ret = theta;
695
696 if (theta >= 0x100000 || theta <= -0x100000) {
697 ret = theta / 0x100000;
698 ret = theta - (f32)(s32)ret * 0x100000;
699 }
700
701 return (s32) ret;
702}

Referenced by cos_deg(), cos_rad(), sin_cos_deg(), sin_cos_rad(), sin_deg(), and sin_rad().

◆ sin_cos_rad()

void sin_cos_rad ( f32 theta,
f32 * outSinTheta,
f32 * outCosTheta )

Definition at line 704 of file 43F0.c.

704 {
706
709}
u16 _wrap_trig_lookup_value(f32 theta)
Definition 43F0.c:693
#define SHT_MINV
Definition macros.h:141
#define RAD_TO_BINANG(x)
Definition macros.h:137

Referenced by action_hammer_end_swing(), action_hammer_test_swing_collision(), action_update_hit_fire(), action_update_hit_lava(), action_update_knockback(), action_update_sliding(), action_update_state_23(), action_update_step_up(), action_update_use_spinning_flower(), action_update_use_tweester(), add_vec2D_polar(), collision_main_lateral(), entity_GiantChest_open(), entity_PinkFlowerLight_setupGfx(), entity_shattering_idle(), npc_surface_spawn_basic_fx(), npc_surface_spawn_cloud_fx(), npc_surface_spawn_flower_fx(), npc_surface_spawn_hedges_fx(), npc_surface_spawn_snow_fx(), npc_surface_spawn_water_fx(), npc_test_move_with_slipping(), npc_test_move_without_slipping(), peach_disguise_check_overlaps(), player_raycast_below(), player_surface_spawn_basic_fx(), player_surface_spawn_cloud_fx(), player_surface_spawn_flower_fx(), player_surface_spawn_hedges_fx(), player_surface_spawn_snow_fx(), player_surface_spawn_water_fx(), player_test_lateral_overlap(), player_test_move_with_slipping(), player_test_move_without_slipping(), test_ray_collider_horizontal(), test_ray_to_wall_center(), update_riding_physics(), and update_riding_physics().

◆ sin_rad()

f32 sin_rad ( f32 theta)

Definition at line 711 of file 43F0.c.

Referenced by action_hammer_play_hit_fx(), action_update_hit_lava(), action_update_parasol(), action_update_spin(), action_update_use_spinning_flower(), action_update_use_tweester(), add_part_decor_steam(), add_xz_vec3f(), add_xz_vec3f_copy1(), add_xz_vec3f_copy2(), appendGfx_background_texture(), apply_constraints_to_lead_amount(), btl_state_update_9(), btl_state_update_end_player_turn(), btl_state_update_end_turn(), btl_state_update_partner_menu(), btl_state_update_peach_menu(), btl_state_update_player_menu(), btl_state_update_twink_menu(), btl_state_update_victory(), ChompChainAddPolarPos(), ChompChainGetPolarX(), create_camera_leadplayer_matrix(), Entity_BoardedFloor_update_fragments(), entity_BombableRock_update_fragments(), entity_Chest_close(), entity_Chest_open(), entity_GiantChest_give_equipment(), entity_GiantChest_open(), entity_HeartBlockContent__anim_heal(), entity_HiddenPanel_flip_over(), entity_inactive_block_hit_anim(), entity_inactive_block_recoil_anim(), entity_Padlock_push_player(), entity_StarBoxLauncher_launch(), entity_TrumpetPlant_create_effect(), entity_TrumpetPlant_spawn_coin(), entity_Tweester_move(), entity_WoodenCrate_update_fragments(), func_802BC3E4_E2ED14(), interp_lookat_pos(), npc_do_other_npc_collision(), npc_do_player_collision(), npc_move_heading(), npc_raycast_down_around(), npc_raycast_down_sides(), npc_raycast_up_corners(), play_movement_dust_effects(), player_raycast_up_corners(), sfx_compute_spatialized_sound_params_ignore_depth(), sync_held_position(), unkVtxFunc001(), update_camera_interp_pos(), update_camera_no_interp(), update_camera_unused_ahead(), update_camera_unused_confined(), update_camera_unused_radial(), update_item_entity_collectable(), update_lerp(), update_lerp_battle(), and virtual_entity_move_polar().

◆ cos_rad()

◆ sin_cos_deg()

void sin_cos_deg ( f32 theta,
f32 * outSinTheta,
f32 * outCosTheta )

Definition at line 718 of file 43F0.c.

718 {
720
723}
#define DEG_TO_BINANG(x)
Definition macros.h:136

◆ sin_deg()

f32 sin_deg ( f32 theta)

Definition at line 725 of file 43F0.c.

◆ cos_deg()

f32 cos_deg ( f32 theta)

Definition at line 729 of file 43F0.c.

◆ update_lerp()

f32 update_lerp ( s32 easing,
f32 start,
f32 end,
s32 elapsed,
s32 duration )

Definition at line 733 of file 43F0.c.

733 {
734 s32 timeLeft;
735 f32 absMag;
736
737 if (duration == 0) {
738 return end;
739 }
740
741 switch (easing) {
742 case EASING_LINEAR:
743 return start + (end - start) * elapsed / duration;
745 return start + SQ(elapsed) * (end - start) / SQ(duration);
746 case EASING_CUBIC_IN:
747 return start + CUBE(elapsed) * (end - start) / CUBE(duration);
749 return start + QUART(elapsed) * (end - start) / QUART(duration);
751 return end - ((end - start) * cos_rad(((f32)elapsed / duration) * PI_D * 4.0) * (duration - elapsed) *
752 (duration - elapsed)) / SQ((f32)duration);
754 return end - ((end - start) * cos_rad((((f32)SQ(elapsed) / duration) * PI_D * 4.0) / 15.0) * (duration - elapsed) *
755 (duration - elapsed)) / SQ((f32)duration);
757 timeLeft = duration - elapsed;
758 return start + (end - start) - ((SQ(timeLeft) * (end - start))) / SQ(duration);
759 case EASING_CUBIC_OUT:
760 timeLeft = duration - elapsed;
761 return start + (end - start) - ((CUBE(timeLeft) * (end - start))) / CUBE(duration);
763 timeLeft = duration - elapsed;
764 return start + (end - start) - ((QUART(timeLeft) * (end - start))) / QUART(duration);
766 absMag = cos_rad((((f32)SQ(elapsed) / duration) * PI_D * 4.0) / 40.0) * (duration - elapsed) *
767 (duration - elapsed) / SQ((f32)duration);
768 if (absMag < 0.0f) {
769 absMag = -absMag;
770 }
771 return end - (end - start) * absMag;
773 return start + (end - start) * (1.0 - cos_rad(((f32)elapsed * PI_D) / (f32)duration)) * 0.5;
774 case EASING_SIN_OUT:
775 return start + (end - start) * sin_rad(((f32)elapsed * (PI_D / 2)) / (f32)duration);
776 case EASING_COS_IN:
777 return start + (end - start) * (1.0 - cos_rad(((f32)elapsed * (PI_D / 2)) / (f32)duration));
778 }
779
780 return 0.0f;
781}
f32 sin_rad(f32 theta)
Definition 43F0.c:711
f32 cos_rad(f32 theta)
Definition 43F0.c:715
@ EASING_SIN_OUT
Definition enums.h:521
@ EASING_COS_IN
Definition enums.h:522
@ EASING_CUBIC_IN
Definition enums.h:512
@ EASING_CUBIC_OUT
Definition enums.h:515
@ EASING_QUARTIC_IN
Definition enums.h:513
@ EASING_COS_BOUNCE
Definition enums.h:519
@ EASING_COS_SLOW_OVERSHOOT
Definition enums.h:517
@ EASING_QUADRATIC_IN
Definition enums.h:511
@ EASING_COS_IN_OUT
Definition enums.h:520
@ EASING_QUARTIC_OUT
Definition enums.h:516
@ EASING_QUADRATIC_OUT
Definition enums.h:514
@ EASING_LINEAR
Definition enums.h:510
@ EASING_COS_FAST_OVERSHOOT
Definition enums.h:518
#define PI_D
Definition macros.h:131
#define QUART(x)
Definition macros.h:172
#define CUBE(x)
Definition macros.h:171

Referenced by appendGfx_message(), FlyingMagikoopaAI_17(), msg_update_rewind_arrow(), sfx_compute_spatialized_sound_params_full(), and update_riding_physics().

◆ appendGfx_startup_prim_rect()

void appendGfx_startup_prim_rect ( u8 r,
u8 g,
u8 b,
u8 a,
u16 left,
u16 top,
u16 right,
u16 bottom )

◆ startup_draw_prim_rect_COPY()

void startup_draw_prim_rect_COPY ( s16 left,
s16 top,
s16 right,
s16 bottom,
u16 r,
u16 g,
u16 b,
u16 a )

Definition at line 803 of file 43F0.c.

803 {
804 u16 temp;
805
806 if (right < left) {
807 temp = right;
808 right = left;
809 left = temp;
810 }
811
812 if (bottom < top) {
813 temp = bottom;
814 bottom = top;
815 top = temp;
816 }
817
819}
void appendGfx_startup_prim_rect(u8 r, u8 g, u8 b, u8 a, u16 left, u16 top, u16 right, u16 bottom)
Definition 43F0.c:783

Referenced by draw_mash_meter().

◆ startup_draw_prim_rect()

void startup_draw_prim_rect ( s16 left,
s16 top,
s16 right,
s16 bottom,
u16 r,
u16 g,
u16 b,
u16 a )

Definition at line 821 of file 43F0.c.

821 {
822 u16 temp;
823
824 if (right < left) {
825 temp = right;
826 right = left;
827 left = temp;
828 }
829
830 if (bottom < top) {
831 temp = bottom;
832 bottom = top;
833 top = temp;
834 }
835
837}

Referenced by state_drawUI_startup().

Variable Documentation

◆ heap_nextMallocID

u16 heap_nextMallocID = 0

Definition at line 5 of file 43F0.c.

Referenced by _heap_malloc().

◆ sCosineTable

f32 sCosineTable[]
Initial value:
= {
0.0f, 0.017452f, 0.034899f, 0.052336f, 0.069756f, 0.087156f, 0.104528f, 0.121869f, 0.139173f,
0.156434f, 0.173648f, 0.190809f, 0.207912f, 0.224951f, 0.241922f, 0.258819f, 0.275637f, 0.292372f, 0.309017f,
0.325568f, 0.34202f, 0.358368f, 0.374607f, 0.390731f, 0.406737f, 0.422618f, 0.438371f, 0.45399f, 0.469472f,
0.48481f, 0.5f, 0.515038f, 0.529919f, 0.544639f, 0.559193f, 0.573576f, 0.587785f, 0.601815f, 0.615661f, 0.62932f,
0.642788f, 0.656059f, 0.669131f, 0.681998f, 0.694658f, 0.707107f, 0.71934f, 0.731354f, 0.743145f, 0.75471f,
0.766044f, 0.777146f, 0.788011f, 0.798636f, 0.809017f, 0.819152f, 0.829038f, 0.838671f, 0.848048f, 0.857167f,
0.866025f, 0.87462f, 0.882948f, 0.891007f, 0.898794f, 0.906308f, 0.913545f, 0.920505f, 0.927184f, 0.93358f,
0.939693f, 0.945519f, 0.951057f, 0.956305f, 0.961262f, 0.965926f, 0.970296f, 0.97437f, 0.978148f, 0.981627f,
0.984808f, 0.987688f, 0.990268f, 0.992546f, 0.994522f, 0.996195f, 0.997564f, 0.99863f, 0.999391f, 0.999848f, 1.0f
}

Definition at line 7 of file 43F0.c.

7 {
8 0.0f, 0.017452f, 0.034899f, 0.052336f, 0.069756f, 0.087156f, 0.104528f, 0.121869f, 0.139173f,
9 0.156434f, 0.173648f, 0.190809f, 0.207912f, 0.224951f, 0.241922f, 0.258819f, 0.275637f, 0.292372f, 0.309017f,
10 0.325568f, 0.34202f, 0.358368f, 0.374607f, 0.390731f, 0.406737f, 0.422618f, 0.438371f, 0.45399f, 0.469472f,
11 0.48481f, 0.5f, 0.515038f, 0.529919f, 0.544639f, 0.559193f, 0.573576f, 0.587785f, 0.601815f, 0.615661f, 0.62932f,
12 0.642788f, 0.656059f, 0.669131f, 0.681998f, 0.694658f, 0.707107f, 0.71934f, 0.731354f, 0.743145f, 0.75471f,
13 0.766044f, 0.777146f, 0.788011f, 0.798636f, 0.809017f, 0.819152f, 0.829038f, 0.838671f, 0.848048f, 0.857167f,
14 0.866025f, 0.87462f, 0.882948f, 0.891007f, 0.898794f, 0.906308f, 0.913545f, 0.920505f, 0.927184f, 0.93358f,
15 0.939693f, 0.945519f, 0.951057f, 0.956305f, 0.961262f, 0.965926f, 0.970296f, 0.97437f, 0.978148f, 0.981627f,
16 0.984808f, 0.987688f, 0.990268f, 0.992546f, 0.994522f, 0.996195f, 0.997564f, 0.99863f, 0.999391f, 0.999848f, 1.0f
17};

Referenced by cosine().

◆ sIntegerDigits

u8 sIntegerDigits[]
Initial value:
= {
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',
'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r',
's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
}

Definition at line 20 of file 43F0.c.

20 {
21 '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
22 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',
23 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r',
24 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
25};

Referenced by int_to_string().

◆ gRandSeed

u32 gRandSeed = 1

Definition at line 27 of file 43F0.c.

Referenced by advance_rng(), and boot_main().

◆ sAtanFactors

f32 sAtanFactors[]
Initial value:
= {
1.0f, 1.273187f, 1.27303f, 1.272768f, 1.272402f, 1.271932f, 1.271358f, 1.270681f, 1.269902f, 1.269021f, 1.268038f,
1.266956f, 1.265774f, 1.264494f, 1.263116f, 1.261643f, 1.260075f, 1.258413f, 1.256659f, 1.254815f, 1.252881f,
1.250859f, 1.248752f, 1.24656f, 1.244285f, 1.241929f, 1.239494f, 1.236981f, 1.234393f, 1.231731f, 1.228997f,
1.226192f, 1.22332f, 1.220382f, 1.217379f, 1.214315f, 1.211189f, 1.208006f, 1.204766f, 1.201471f, 1.198124f,
1.194727f, 1.191281f, 1.187787f, 1.18425f, 1.180669f, 1.177047f, 1.173386f, 1.169687f, 1.165952f, 1.162184f,
1.158384f, 1.154553f, 1.150693f, 1.146806f, 1.142893f, 1.138957f, 1.134998f, 1.131018f, 1.127019f, 1.123002f,
1.118969f, 1.11492f, 1.110858f, 1.106783f, 1.102697f, 1.098601f, 1.094496f, 1.090384f, 1.086266f, 1.082142f,
1.078014f, 1.073883f, 1.06975f, 1.065616f, 1.061482f, 1.057348f, 1.053216f, 1.049087f, 1.04496f, 1.040838f,
1.036721f, 1.03261f, 1.028504f, 1.024406f, 1.020316f, 1.016234f, 1.01216f, 1.008097f, 1.004043f, 1.0f
}

Definition at line 29 of file 43F0.c.

29 {
30 1.0f, 1.273187f, 1.27303f, 1.272768f, 1.272402f, 1.271932f, 1.271358f, 1.270681f, 1.269902f, 1.269021f, 1.268038f,
31 1.266956f, 1.265774f, 1.264494f, 1.263116f, 1.261643f, 1.260075f, 1.258413f, 1.256659f, 1.254815f, 1.252881f,
32 1.250859f, 1.248752f, 1.24656f, 1.244285f, 1.241929f, 1.239494f, 1.236981f, 1.234393f, 1.231731f, 1.228997f,
33 1.226192f, 1.22332f, 1.220382f, 1.217379f, 1.214315f, 1.211189f, 1.208006f, 1.204766f, 1.201471f, 1.198124f,
34 1.194727f, 1.191281f, 1.187787f, 1.18425f, 1.180669f, 1.177047f, 1.173386f, 1.169687f, 1.165952f, 1.162184f,
35 1.158384f, 1.154553f, 1.150693f, 1.146806f, 1.142893f, 1.138957f, 1.134998f, 1.131018f, 1.127019f, 1.123002f,
36 1.118969f, 1.11492f, 1.110858f, 1.106783f, 1.102697f, 1.098601f, 1.094496f, 1.090384f, 1.086266f, 1.082142f,
37 1.078014f, 1.073883f, 1.06975f, 1.065616f, 1.061482f, 1.057348f, 1.053216f, 1.049087f, 1.04496f, 1.040838f,
38 1.036721f, 1.03261f, 1.028504f, 1.024406f, 1.020316f, 1.016234f, 1.01216f, 1.008097f, 1.004043f, 1.0f
39};

Referenced by atan2().

◆ D_80074580