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)

char *	int_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 476 of file 43F0.c.

                                                           {
    OSIoMesg osIoMesg;
    OSMesg osMesg;
    OSMesgQueue osMesgQueue;
 
    osWritebackDCache(dramAddr, size);
    osCreateMesgQueue(&osMesgQueue, &osMesg, 1);
 
    osIoMesg.hdr.pri = 0;
    osIoMesg.hdr.retQueue = &osMesgQueue;
    osIoMesg.dramAddr = dramAddr;
    osIoMesg.devAddr = devAddr;
    osIoMesg.size = size;
 
    osEPiStartDma(nuPiCartHandle, &osIoMesg, 1);
    osRecvMesg(&osMesgQueue, &osMesg, 1);
}

Referenced by dma_write().

◆ length2D()

f32 length2D	(	f32	x,
		f32	y )

Definition at line 58 of file 43F0.c.

                           {
    return sqrtf(SQ(x) + SQ(y));
}

Referenced by ArcsinDeg().

◆ _heap_create()

HeapNode * _heap_create	(	HeapNode *	addr,
		u32	size )

Definition at line 62 of file 43F0.c.

                                                 {
    if (size < 32) {
        return (HeapNode*)-1;
    } else {
        HeapNode* heapNode = (HeapNode*)ALIGN16((u32)addr);
 
        size -= ((u8*)heapNode - (u8*)addr);
        heapNode->next = nullptr;
        heapNode->length = size - sizeof(HeapNode);
        heapNode->allocated = 0;
        heapNode->capacity = size;
        return heapNode;
    }
}

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.

                                             {
    HeapNode* nextHeapNode;
    HeapNode* pPrevHeapNode = nullptr;
    u32 newBlockSize;
    u32 curBlockLength;
    HeapNode* curHeapNode;
    u32 smallestBlockFound;
    u16 HeapEntryID;
    u16 HeapEntryID2;
 
    // must allocate 16 bytes or more at minimum or fail
    size = ALIGN16(size);
    if (!size) {
        debug_printf("warning: attempt to malloc less than 16 bytes\n");
        return nullptr;
    }
 
    smallestBlockFound = 0;
    nextHeapNode = nullptr;
 
    // find the smallest block we can fit into in the free list
    for (curHeapNode = head; ; curHeapNode = curHeapNode->next) {
        if (!curHeapNode->allocated) {
            curBlockLength = curHeapNode->length;
            if ((curBlockLength >= size) && (curBlockLength < smallestBlockFound || !smallestBlockFound)) {
                pPrevHeapNode = curHeapNode;
                smallestBlockFound = curBlockLength;
                nextHeapNode = curHeapNode->next;
            }
        }
        if (!curHeapNode->next) {
            break;
        }
    }
 
    // find out the required block size with header
    newBlockSize = size + sizeof(HeapNode);
 
    // if we found a block see if we need to split it up
    if (smallestBlockFound) {
        if (smallestBlockFound >= newBlockSize) {
            // update previous to the proper size for the block being returned
            pPrevHeapNode->next = (HeapNode*)((u8*)pPrevHeapNode + newBlockSize);
            pPrevHeapNode->length = size;
 
            // update the entry id on allocation
            HeapEntryID = heap_nextMallocID;
            pPrevHeapNode->allocated = true;
            heap_nextMallocID = HeapEntryID + 1;
            pPrevHeapNode->entryID = HeapEntryID;
 
            // setup the new heap block entry
            curHeapNode = pPrevHeapNode->next;
            curHeapNode->next = nextHeapNode;
            curHeapNode->length = smallestBlockFound - newBlockSize;
            curHeapNode->allocated = false;
        } else {
            // take this entry out of the free linked list and mark as allocated
            pPrevHeapNode->next = nextHeapNode;
            pPrevHeapNode->length = smallestBlockFound;
 
            // update the entry id on allocation
            // note, usage of a single ID from above will result in wrong code
            HeapEntryID2 = heap_nextMallocID;
            pPrevHeapNode->allocated = true;
            heap_nextMallocID = HeapEntryID2 + 1;
            pPrevHeapNode->entryID = HeapEntryID2;
        }
        return (u8*)pPrevHeapNode + sizeof(HeapNode);
    }
    debug_printf("warning: out of memory\n");
    return nullptr;
}

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.

                                                  {
    HeapNode* curNode;
    u32 newNodeSize;
    u32 foundNodeLength;
    HeapNode* foundNode;
    HeapNode* nextNode;
 
    size = ALIGN16(size);
    foundNode = nullptr;
 
    // make sure we have a size to allocate
    if (!size) {
        debug_printf("warning: attempt to malloc less than 16 bytes\n");
        return nullptr;
    }
 
    foundNodeLength = 0;
    nextNode = nullptr;
 
    // find the smallest block we can fit into
    for (curNode = head; ; curNode = curNode->next) {
        if (!curNode->allocated) {
            if (curNode->length >= size) {
                foundNode = curNode;
                foundNodeLength = curNode->length;
                nextNode = curNode->next;
            }
        }
 
        if (!curNode->next) {
            break;
        }
    }
 
    newNodeSize = size + sizeof(HeapNode);
    if (foundNodeLength != 0) {
        curNode = foundNode;
 
        // we found a block to use, see if we can split it and return a portion
        // or if we just need to return the whole block
        if (foundNodeLength >= newNodeSize) {
            // add a free block before this one
            // this is where this function differs from heap_malloc, it returns
            // the end of the block instead of the beginning when splitting it up
            curNode->next = (HeapNode*)((u8*)curNode + foundNodeLength - size);
            curNode->length = foundNodeLength - newNodeSize;
            curNode->allocated = false;
 
            curNode = curNode->next;
            curNode->next = nextNode;
            curNode->length = size;
            curNode->allocated = true;
 
        } else {
            // just return this actual block
            curNode->next = nextNode;
            curNode->length = foundNodeLength;
            curNode->allocated = true;
        }
 
        return (u8*)curNode + sizeof(HeapNode);
    }
 
    // did not find a block
    debug_printf("warning: out of memory\n");
    return nullptr;
}

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.

                                                         {
    u32 curNodeLength;
    HeapNode* nextNode;
    HeapNode* nodeToFreeHeader;
    HeapNode* tempNode;
    HeapNode* outNode;
 
    // if no address to free then return
    if (addrToFree == nullptr) {
        return true;
    }
 
    // if we are not allocated then ignore this request
    nodeToFreeHeader = (HeapNode*)((u8*)addrToFree - sizeof(HeapNode));
    if (!nodeToFreeHeader->allocated) {
        return true;
    }
 
    nextNode = nodeToFreeHeader->next;
    curNodeLength = nodeToFreeHeader->length;
    outNode = nextNode;
 
    // see if the next node after us is allocated, if not then adjust our size
    // to include it and point nextNode to be the node after as it must be allocated
    if (nextNode && !nextNode->allocated) {
        curNodeLength += nextNode->length + sizeof(HeapNode);
        nextNode = nextNode->next;
    }
 
    // walk the full heap node list looking for the block before our current entry
    tempNode = heapNodeList;
    while (true) {
        // get the pointer to the next block, if it matches the block being freed then
        // exit the search
        heapNodeList = tempNode->next;
        if (heapNodeList == nodeToFreeHeader) {
 
            // we found the node prior to us, if it is not allocated then adjust our total
            // size to include it and change the header node pointer to point that block
            if (!tempNode->allocated) {
                curNodeLength += sizeof(HeapNode) + tempNode->length;
                nodeToFreeHeader = tempNode;
            }
            break;
        }
 
        // if the node being freed is before the current node being looked at then we
        // moved past our current node, bail out. Also bail if we hit the end of the list
        if (nodeToFreeHeader < tempNode || !heapNodeList) {
            break;
        }
 
        // move to the next node
        tempNode = tempNode->next;
    }
 
    // update the node being free'd with a proper size and pointer to the next node that is
    // allocated
    outNode = nodeToFreeHeader;
    outNode->next = nextNode;
    outNode->length = curNodeLength;
    outNode->allocated = false;
    return false;
}

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.

                                                                     {
    u32 newSizeAligned;
    HeapNode* nextNode;
    HeapNode* curHeapAlloc;
    HeapNode* newFreeBlock;
    u32 newNodeLength;
    HeapNode* nodeToUpdate;
 
    curHeapAlloc = (HeapNode*)((u8*)addr - sizeof(HeapNode));
    newSizeAligned = ALIGN16(newSize);
 
    // check if the realloc is on an allocated node otherwise fail
    if (!curHeapAlloc->allocated) {
        return nullptr;
    }
 
    nextNode = curHeapAlloc->next;
    newNodeLength = curHeapAlloc->length;
 
    // if we have a node after us and it isn't allocated then
    // adjust the length and next node pointers to include the node after us
    nodeToUpdate = nextNode;
    if (nextNode && !nextNode->allocated) {
        nextNode = nextNode->next;
        newNodeLength += sizeof(HeapNode) + nodeToUpdate->length;
    }
 
    // check if the current block or current + next block (if free) are too small
    nodeToUpdate = curHeapAlloc;
    if (newNodeLength < newSizeAligned) {
        // too small, allocatr a new node, copy data to it then free the current one
        curHeapAlloc = _heap_malloc(heapNodeList, newSizeAligned);
        if (curHeapAlloc == nullptr) {
            return nullptr;
        }
 
        // minor interest note, copy the size of the newly allocated size
        // instead of just how much data used to be stored, this results in copying
        // excessive data
        memcpy(curHeapAlloc, addr, newSizeAligned);
        _heap_free(heapNodeList, addr);
        return curHeapAlloc;
    }
 
    // see if there is room to add a new free block after us
    if (newSizeAligned + sizeof(HeapNode) < newNodeLength) {
        // room for a free block, create it
        newFreeBlock = (HeapNode*)((u8*)addr + newSizeAligned);
 
        // update current node
        nodeToUpdate->next = newFreeBlock;
        nodeToUpdate->length = newSizeAligned;
 
        // create new node after the current one
        nodeToUpdate = newFreeBlock;
        nodeToUpdate->next = nextNode;
        nodeToUpdate->length = (newNodeLength - newSizeAligned) - sizeof(HeapNode);
        nodeToUpdate->allocated = false;
    } else {
        // no room, update our next and length
        nodeToUpdate->next = nextNode;
        nodeToUpdate->length = newNodeLength;
    }
 
    // return the location we were at
    return addr;
}

Referenced by spr_load_npc_extra_anims().

◆ cosine()

f32 cosine ( s16 arg0 )

Definition at line 352 of file 43F0.c.

                     {
    s16 temp360;
    s16 idx;
 
    temp360 = arg0 % 360;
 
    if (temp360 < 0) {
        temp360 += 360;
    }
 
    idx = temp360 % 180;
    if (idx > 90) {
        idx = 180 - idx;
    }
 
    if (temp360 >= 180) {
        return -sCosineTable[idx];
    } else {
        return sCosineTable[idx];
    }
}

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.

                  {
    s32 sign = -1;
 
    if (val >= 0) {
        sign = val > 0;
    }
    return sign;
}

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.

                                                       {
    u8 string[40]; // Even for binary this is a little long: 34 would suffice
    s32 i = ARRAY_COUNT(string) - 2;
    s32 negative = false;
    s64 longInteger = integer;
 
    // handle negative integers
    if (longInteger < 0) {
        negative = true;
        longInteger *= -1;
    }
 
    // null-terminate string
    string[ARRAY_COUNT(string) - 1] = '\0';
 
    // extract digits, filling string from the back
    while (true) {
        string[i] = sIntegerDigits[longInteger % base];
        longInteger /= base;
        if (longInteger == 0 || i == 0) {
            break;
        }
        i--;
    }
 
    // Add - to negatives
    if (negative) {
        i--;
        string[i] = '-';
    }
 
    // copy only populated part of string
    strcpy(dest, &string[i]);
 
    return dest;
}

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.

                                         {
    u8* addressableData = data;
 
    while (numBytes > 0) {
        *addressableData++ = 0;
        numBytes--;
    }
}

◆ 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.

                                                                                                                   {
    *outX = (mtx[0][0] * inX) + (mtx[1][0] * inY) + (mtx[2][0] * inZ) + mtx[3][0];
    *outY = (mtx[0][1] * inX) + (mtx[1][1] * inY) + (mtx[2][1] * inZ) + mtx[3][1];
    *outZ = (mtx[0][2] * inX) + (mtx[1][2] * inY) + (mtx[2][2] * inZ) + mtx[3][2];
    *outW = (mtx[0][3] * inX) + (mtx[1][3] * inY) + (mtx[2][3] * inZ) + mtx[3][3];
}

◆ copy_matrix()

void copy_matrix	(	Matrix4f	src,
		Matrix4f	dest )

Definition at line 437 of file 43F0.c.

                                              {
    bcopy(src, dest, sizeof(Matrix4f));
}

Referenced by animator_node_update_model_transform(), and update_collider_transform().

◆ dma_copy()

u32 dma_copy	(	Addr	romStart,
		Addr	romEnd,
		void *	vramDest )

Definition at line 442 of file 43F0.c.

                                                         {
    u32 length = romEnd - romStart;
    s32 i;
 
    ASSERT_MSG(((u32)vramDest & 7) == 0, "dma_copy: dest not 8-byte aligned");
 
    osInvalICache(vramDest, length);
 
    for (i = 0; i + ROM_CHUNK_SIZE < length; i += ROM_CHUNK_SIZE) {
        nuPiReadRom((u32)romStart + i, vramDest + i, ROM_CHUNK_SIZE);
    }
 
    if (i != length) {
        nuPiReadRom((u32)romStart + i, vramDest + i, length - i);
    }
 
    return length;
}

Referenced by create_partner_npc(), dma_load_msg(), get_asset_offset(), imgfx_load_anim(), imgfx_mesh_anim_update(), load_asset_by_name(), load_battle_section(), load_effect(), load_font_data(), load_map_by_IDs(), load_obfuscation_shims(), load_simple_entity_data(), load_split_entity_data(), load_texture_by_name(), load_texture_impl(), load_texture_variants(), msg_copy_to_print_buffer(), phys_peach_update(), phys_update_action_state(), reload_world_entity_data(), state_init_logos(), state_step_end_battle(), state_step_unpause(), and use_consumable().

◆ dma_write()

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

Definition at line 461 of file 43F0.c.

                                                          {
    u32 length = romEnd - romStart;
    s32 i;
 
    for (i = 0; i + ROM_CHUNK_SIZE < length; i += ROM_CHUNK_SIZE) {
        dma_write_block(romStart + i, (u32)vramDest + i, ROM_CHUNK_SIZE);
    }
 
    if (i != length) {
        dma_write_block(romStart + i, (u32)vramDest + i, length - i);
    }
 
    return length;
}

◆ advance_rng()

u32 advance_rng ( void )

Definition at line 495 of file 43F0.c.

                      {
    gRandSeed = gRandSeed * 0x5D588B65 + 1;
 
    gGameStatusPtr->nextRNG = gRandSeed;
 
    return gRandSeed;
}

Referenced by rand_float(), and rand_int_internal().

◆ rand_float()

f32 rand_float ( void )

Definition at line 504 of file 43F0.c.

                     {
    return (advance_rng() & 0x7FFF) / 32768.0;
}

Referenced by entity_shattering_init_pieces().

◆ rand_int_internal()

s32 rand_int_internal ( u32 max )

Definition at line 509 of file 43F0.c.

                               {
    u32 partitionSize = 0xFFFFFFFF;
    u32 maxPlusOne = max + 1;
    u32 result;
 
    // split [0,2^32) into ``maxPlusOne`` equally sized partitions
    // [0, partitionSize), [partitionSize, 2*partitionSize), ... [maxPlusOne*partitionSize, 2^32)
    partitionSize /= maxPlusOne;
    if (partitionSize == 0) {
        partitionSize = 1;
    }
 
    // numbers in the leftover [maxPlusOne*partitionSize, 2^32) are rejected as they would return maxPlusOne
    // this ensures the result is [0,max] whilst also ensuring each partition is the same size and equally probable
    do {
        // determine which partition the random number is in by dividing it by partitionSize
        result = advance_rng() / partitionSize;
    } while (result >= maxPlusOne);
 
    return result;
}

Referenced by rand_int().

◆ rand_int()

s32 rand_int ( s32 max )

Definition at line 532 of file 43F0.c.

                      {
    s32 ret = 0;
 
    max = abs(max);
 
    if (max != 0) {
        switch (max) {
            case 1:
                // due to the off-by-one input of 1000 and the > operator being used,
                // there is a 501/1001 chance of returning 0 and a 500/1001 chance of returning 1
                // (assuming statistical randomness of rand_int_internal).
                ret = rand_int_internal(1000) > 500;
                break;
            default:
                ret = rand_int_internal(max);
                break;
            case 100:
                ret = rand_int_internal(1009) / 10;
                break;
        }
    }
 
    return ret;
}

◆ signF()

f32 signF ( f32 val )

Definition at line 557 of file 43F0.c.

                   {
    f32 sign;
 
    if (!(val > 0.0f)) {
        sign = -1.0f;
        if (!(val < 0.0f)) {
            sign = 0.0f;
        }
    } else {
        sign = 1.0f;
    }
 
    return sign;
}

Referenced by FireBarAI_Callback().

◆ round()

s32 round ( f32 x )

Definition at line 572 of file 43F0.c.

                 {
    if (!(x >= 0.0f)) {
        return -(s32)(0.5 - x);
    } else {
        return (s32)(0.5 + x);
    }
}

Referenced by atan2().

◆ clamp_angle()

f32 clamp_angle ( f32 theta )

Definition at line 580 of file 43F0.c.

                           {
    if (fabsf(theta) > 3600.0f) {
        s32 thetaInt = theta;
 
        if (thetaInt >= 0) {
            thetaInt = -(thetaInt / 360 * 360) + thetaInt;
        } else {
            thetaInt = -thetaInt;
            thetaInt = (thetaInt / 360 * 360) - thetaInt;
        }
 
        return thetaInt;
    }
 
    do {
        if (theta < 0.0f) {
            theta += 360.0f;
        }
        if (theta >= 360.0f) {
            theta -= 360.0f;
        }
    } while (!(theta >= 0.0f) || !(theta < 360.0f));
 
    return theta;
}

◆ get_clamped_angle_diff()

f32 get_clamped_angle_diff	(	f32	a,
		f32	b )

Definition at line 606 of file 43F0.c.

                                         {
    if (fabsf(b - a) >= 180.0f) {
        if (b < a) {
            b += 360.0f;
        } else {
            b -= 360.0f;
        }
    }
    return b - a;
}

Referenced by AvoidPlayerAI_ChaseInit(), basic_ai_chase_init(), check_conversation_trigger(), CleftAI_CanSeePlayer(), FlyingAI_LosePlayer(), FlyingNoAttackAI_12(), GuardAI_ChaseInit(), MagikoopaAI_CanShootSpell(), MeleeHitbox_CanSeePlayer(), npc_do_player_collision(), npc_follow_npc(), npc_get_render_yaw(), partner_flying_follow_player(), partner_force_player_flip_done(), partner_walking_follow_player(), PatrolAI_ChaseInit(), player_get_side_angle(), player_update_sprite(), ProjectileHitbox_GetUsableProjectileID(), SentinelAI_ChaseInit(), set_npc_yaw(), test_item_player_collision(), update_camera_unused_radial(), update_encounters_neutral(), and update_unused_lead_amt().

◆ atan2()

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

Definition at line 617 of file 43F0.c.

                                                      {
    f32 dx = endX - startX;
    f32 dz = endZ - startZ;
    f32 absXDiff = fabsf(dx);
    f32 absZDiff = fabsf(dz);
    f32 ret;
 
    if (absZDiff < absXDiff) {
        ret = (absZDiff / absXDiff) * 45.0f;
        ret *= sAtanFactors[round(2.0f * ret)];
        if (dx >= 0.0f) {
            if (dz >= 0.0f) {
                return ret + 90.0f;
            } else {
                return 90.0f - ret;
            }
        }
        if (dz >= 0.0f) {
            return 270.0f - ret;
        } else {
            return ret + 270.0f;
        }
    } else {
        if (absZDiff == 0.0f) {
            return 0.0f;
        }
        ret = (absXDiff / absZDiff) * 45.0f;
        ret *= sAtanFactors[round(2.0f * ret)];
        if (dz >= 0.0f) {
            if (dx >= 0.0f) {
                return 180.0f - ret;
            } else {
                return ret + 180.0f;
            }
        } else if (!(dx >= 0.0f)) {
            return 360.0f - ret;
        }
    }
    return ret;
}

◆ get_player_normal_yaw()

f32 get_player_normal_yaw ( void )

Definition at line 658 of file 43F0.c.

                                {
    return atan2(0, 0, gGameStatusPtr->playerGroundTraceNormal.x, gGameStatusPtr->playerGroundTraceNormal.z);
}

Referenced by player_raycast_down(), and update_player_shadow().

◆ get_player_normal_pitch()

f32 get_player_normal_pitch ( void )

Definition at line 662 of file 43F0.c.

                                  {
    f32 traceNormalX = gGameStatusPtr->playerGroundTraceNormal.x;
    f32 traceNormalZ = gGameStatusPtr->playerGroundTraceNormal.z;
    f32 sqrt = sqrtf(SQ(traceNormalX) + SQ(traceNormalZ));
 
    return atan2(0.0f, 0.0f, sqrt, -gGameStatusPtr->playerGroundTraceNormal.y);
}

Referenced by phys_main_collision_below(), player_raycast_down(), and update_riding_physics().

◆ dist2D()

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

Definition at line 670 of file 43F0.c.

                                           {
    f32 xDiff = bx - ax;
    f32 yDiff = by - ay;
 
    return sqrtf(SQ(xDiff) + SQ(yDiff));
}

Referenced by _npc_jump_to(), action_update_use_spinning_flower(), action_update_use_tweester(), ai_check_fwd_collisions(), ai_check_player_dist(), AvoidPlayerAI_ChaseInit(), basic_ai_chase(), basic_ai_chase_init(), basic_ai_check_player_dist(), basic_ai_wander(), BooPatrolAI_Move(), CleftAI_ReturnHome(), CleftAI_RevUp(), ClubbaNappingAI_ReturnHome(), ClubbaNappingAI_Sleep(), entity_HiddenPanel_idle(), entity_Tweester_idle(), FlyingAI_Wander(), FlyingMagikoopaAI_15(), func_802BB0A0_E2D9D0(), func_802BB8D4_E2E204(), func_802BC0F0_E2EA20(), game_input_to_move_vector(), get_movement_from_input(), get_stick_input_radial(), get_xz_dist_to_player(), GuardAI_ReturnHome(), handle_jumping_land_on_switch(), is_point_outside_territory(), MagikoopaAI_10(), MeleeHitbox_CanSeePlayer(), msg_draw_speech_arrow(), npc_find_closest(), npc_find_closest_simple(), npc_follow_npc(), npc_update_npc_tracking(), ParatroopaAI_Windup(), partner_flying_follow_player(), partner_get_out(), partner_move_to_goal(), partner_put_away(), partner_walking_follow_player(), PatrolAI_Move(), PatrolAI_MoveInit(), PiranhaPlantAI_10(), player_input_to_move_vector(), player_jump(), render_entities(), SentinelAI_Chase(), SentinelAI_ReturnHome(), test_first_strike(), test_first_strike(), UnkDistFunc(), update_camera_unused_radial(), and update_player_shadow().

◆ dist3D()

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

Definition at line 677 of file 43F0.c.

                                                           {
    f32 xDiff = bx - ax;
    f32 yDiff = by - ay;
    f32 zDiff = bz - az;
 
    return sqrtf(SQ(xDiff) + SQ(yDiff) + SQ(zDiff));
}

Referenced by update_triggers().

◆ add_vec2D_polar()

void add_vec2D_polar	(	f32 *	x,
		f32 *	y,
		f32	r,
		f32	theta )

Definition at line 685 of file 43F0.c.

                                                       {
    f32 sinTheta;
    f32 cosTheta;
 
    sin_cos_rad(DEG_TO_RAD(theta), &sinTheta, &cosTheta);
    *x += r * sinTheta;
    *y -= r * cosTheta;
}

Referenced by action_update_use_munchlesia(), ai_check_player_dist(), basic_ai_check_player_dist(), btl_main_menu_draw(), btl_main_menu_update(), can_dismount(), check_for_treadmill_overlaps(), ClubbaNappingAI_Sleep(), collision_main_lateral(), draw_all_status_icons(), entity_StarBoxLauncher_check_launch(), FlyingMagikoopaAI_15(), FlyingMagikoopaAI_21(), func_802BB98C_E2E2BC(), func_802BC17C_E2EAAC(), handle_jumping_land_on_switch(), MagikoopaAI_21(), offset_player_from_camera(), partner_do_player_collision(), partner_flying_follow_player(), partner_get_out(), partner_move_to_goal(), partner_walking_follow_player(), PiranhaPlantAI_10(), pre_battle(), sync_player_position(), test_item_player_collision(), update_encounters_neutral(), and update_riding_physics().

◆ _wrap_trig_lookup_value()

u16 _wrap_trig_lookup_value ( f32 theta )

Definition at line 695 of file 43F0.c.

                                       {
    f32 ret = theta;
 
    if (theta >= 0x100000 || theta <= -0x100000) {
        ret = theta / 0x100000;
        ret = theta - (f32)(s32)ret * 0x100000;
    }
 
    return (s32) ret;
}

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 706 of file 43F0.c.

                                                                {
    u16 binang = _wrap_trig_lookup_value(RAD_TO_BINANG(theta));
 
    *outSinTheta = sins(binang) * SHT_MINV;
    *outCosTheta = coss(binang) * SHT_MINV;
}

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 713 of file 43F0.c.

                       {
    return sins(_wrap_trig_lookup_value(RAD_TO_BINANG(theta))) * SHT_MINV;
}

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_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_transfer_turn(), 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()

f32 cos_rad ( f32 theta )

Definition at line 717 of file 43F0.c.

                       {
    return coss(_wrap_trig_lookup_value(RAD_TO_BINANG(theta))) * SHT_MINV;
}

Referenced by action_hammer_play_hit_fx(), action_update_hit_lava(), action_update_parasol(), action_update_spin(), add_part_decor_steam(), add_xz_vec3f(), add_xz_vec3f_copy1(), add_xz_vec3f_copy2(), apply_constraints_to_lead_amount(), ChompChainAddPolarPos(), ChompChainGetPolarX(), create_camera_leadplayer_matrix(), Entity_BoardedFloor_update_fragments(), entity_BombableRock_update_fragments(), entity_GiantChest_give_equipment(), entity_GiantChest_open(), entity_HeartBlockContent__anim_heal(), entity_Padlock_push_player(), entity_StarBoxLauncher_launch(), entity_TrumpetPlant_create_effect(), entity_TrumpetPlant_spawn_coin(), entity_Tweester_move(), entity_WoodenCrate_update_fragments(), 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(), 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_camera_zone_interp(), update_item_entity_collectable(), update_lerp(), update_lerp_battle(), and virtual_entity_move_polar().

◆ sin_cos_deg()

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

Definition at line 720 of file 43F0.c.

                                                                {
    u16 binang = _wrap_trig_lookup_value(DEG_TO_BINANG(theta));
 
    *outSinTheta = sins(binang) * SHT_MINV;
    *outCosTheta = coss(binang) * SHT_MINV;
}

◆ sin_deg()

f32 sin_deg ( f32 theta )

Definition at line 727 of file 43F0.c.

                       {
    return sins(_wrap_trig_lookup_value(DEG_TO_BINANG(theta))) * SHT_MINV;
}

◆ cos_deg()

f32 cos_deg ( f32 theta )

Definition at line 731 of file 43F0.c.

                       {
    return coss(_wrap_trig_lookup_value(DEG_TO_BINANG(theta))) * SHT_MINV;
}

◆ update_lerp()

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

Definition at line 735 of file 43F0.c.

                                                                           {
    s32 timeLeft;
    f32 absMag;
 
    if (duration == 0) {
        return end;
    }
 
    switch (easing) {
        case EASING_LINEAR:
            return start + (end - start) * elapsed / duration;
        case EASING_QUADRATIC_IN:
            return start + SQ(elapsed) * (end - start) / SQ(duration);
        case EASING_CUBIC_IN:
            return start + CUBE(elapsed) * (end - start) / CUBE(duration);
        case EASING_QUARTIC_IN:
            return start + QUART(elapsed) * (end - start) / QUART(duration);
        case EASING_COS_SLOW_OVERSHOOT:
            return end - ((end - start) * cos_rad(((f32)elapsed / duration) * PI_D * 4.0) * (duration - elapsed) *
                    (duration - elapsed)) / SQ((f32)duration);
        case EASING_COS_FAST_OVERSHOOT:
            return end - ((end - start) * cos_rad((((f32)SQ(elapsed) / duration) * PI_D * 4.0) / 15.0) * (duration - elapsed) *
                    (duration - elapsed)) / SQ((f32)duration);
        case EASING_QUADRATIC_OUT:
            timeLeft = duration - elapsed;
            return start + (end - start) - ((SQ(timeLeft) * (end - start))) / SQ(duration);
        case EASING_CUBIC_OUT:
            timeLeft = duration - elapsed;
            return start + (end - start) - ((CUBE(timeLeft) * (end - start))) / CUBE(duration);
        case EASING_QUARTIC_OUT:
            timeLeft = duration - elapsed;
            return start + (end - start) - ((QUART(timeLeft) * (end - start))) / QUART(duration);
        case EASING_COS_BOUNCE:
            absMag = cos_rad((((f32)SQ(elapsed) / duration) * PI_D * 4.0) / 40.0) * (duration - elapsed) *
                    (duration - elapsed) / SQ((f32)duration);
            if (absMag < 0.0f) {
                absMag = -absMag;
            }
            return end - (end - start) * absMag;
        case EASING_COS_IN_OUT:
            return start + (end - start) * (1.0 - cos_rad(((f32)elapsed * PI_D) / (f32)duration)) * 0.5;
        case EASING_SIN_OUT:
            return start + (end - start) * sin_rad(((f32)elapsed * (PI_D / 2)) / (f32)duration);
        case EASING_COS_IN:
            return start + (end - start) * (1.0 - cos_rad(((f32)elapsed * (PI_D / 2)) / (f32)duration));
    }
 
    return 0.0f;
}

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 )

Definition at line 785 of file 43F0.c.

                                                                                                   {
    gDPPipeSync(gMainGfxPos++);
    gSPDisplayList(gMainGfxPos++, D_80074580);
 
    if (a == 255) {
        gDPSetRenderMode(gMainGfxPos++, G_RM_OPA_SURF, G_RM_OPA_SURF2);
        gDPSetCombineMode(gMainGfxPos++, PM_CC_PRIM_FULL_ALPHA, PM_CC_PRIM_FULL_ALPHA);
    } else {
        gDPSetRenderMode(gMainGfxPos++, G_RM_XLU_SURF, G_RM_XLU_SURF2);
        gDPSetCombineMode(gMainGfxPos++, G_CC_PRIMITIVE, G_CC_PRIMITIVE);
    }
 
    gDPSetPrimColor(gMainGfxPos++, 0, 0, r, g, b, a);
    gDPFillRectangle(gMainGfxPos++, left, top, right, bottom);
 
    gDPPipeSync(gMainGfxPos++);
    gDPSetRenderMode(gMainGfxPos++, G_RM_TEX_EDGE, G_RM_TEX_EDGE2);
    gDPSetCombineMode(gMainGfxPos++, G_CC_DECALRGBA, G_CC_DECALRGBA);
}

Referenced by startup_draw_prim_rect(), and startup_draw_prim_rect_COPY().

◆ 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 805 of file 43F0.c.

                                                                                                       {
    u16 temp;
 
    if (right < left) {
        temp = right;
        right = left;
        left = temp;
    }
 
    if (bottom < top) {
        temp = bottom;
        bottom = top;
        top = temp;
    }
 
    appendGfx_startup_prim_rect(r, g, b, a, left, top, right, bottom);
}

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 823 of file 43F0.c.

                                                                                                  {
    u16 temp;
 
    if (right < left) {
        temp = right;
        right = left;
        left = temp;
    }
 
    if (bottom < top) {
        temp = bottom;
        bottom = top;
        top = temp;
    }
 
    appendGfx_startup_prim_rect(r, g, b, a, left, top, right, bottom);
}

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:

= {
0f, 0.017452f, 0.034899f, 0.052336f, 0.069756f, 0.087156f, 0.104528f, 0.121869f, 0.139173f,
156434f, 0.173648f, 0.190809f, 0.207912f, 0.224951f, 0.241922f, 0.258819f, 0.275637f, 0.292372f, 0.309017f,
325568f, 0.34202f, 0.358368f, 0.374607f, 0.390731f, 0.406737f, 0.422618f, 0.438371f, 0.45399f, 0.469472f,
48481f, 0.5f, 0.515038f, 0.529919f, 0.544639f, 0.559193f, 0.573576f, 0.587785f, 0.601815f, 0.615661f, 0.62932f,
642788f, 0.656059f, 0.669131f, 0.681998f, 0.694658f, 0.707107f, 0.71934f, 0.731354f, 0.743145f, 0.75471f,
766044f, 0.777146f, 0.788011f, 0.798636f, 0.809017f, 0.819152f, 0.829038f, 0.838671f, 0.848048f, 0.857167f,
866025f, 0.87462f, 0.882948f, 0.891007f, 0.898794f, 0.906308f, 0.913545f, 0.920505f, 0.927184f, 0.93358f,
939693f, 0.945519f, 0.951057f, 0.956305f, 0.961262f, 0.965926f, 0.970296f, 0.97437f, 0.978148f, 0.981627f,
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.

                     {
0f, 0.017452f, 0.034899f, 0.052336f, 0.069756f, 0.087156f, 0.104528f, 0.121869f, 0.139173f,
156434f, 0.173648f, 0.190809f, 0.207912f, 0.224951f, 0.241922f, 0.258819f, 0.275637f, 0.292372f, 0.309017f,
325568f, 0.34202f, 0.358368f, 0.374607f, 0.390731f, 0.406737f, 0.422618f, 0.438371f, 0.45399f, 0.469472f,
48481f, 0.5f, 0.515038f, 0.529919f, 0.544639f, 0.559193f, 0.573576f, 0.587785f, 0.601815f, 0.615661f, 0.62932f,
642788f, 0.656059f, 0.669131f, 0.681998f, 0.694658f, 0.707107f, 0.71934f, 0.731354f, 0.743145f, 0.75471f,
766044f, 0.777146f, 0.788011f, 0.798636f, 0.809017f, 0.819152f, 0.829038f, 0.838671f, 0.848048f, 0.857167f,
866025f, 0.87462f, 0.882948f, 0.891007f, 0.898794f, 0.906308f, 0.913545f, 0.920505f, 0.927184f, 0.93358f,
939693f, 0.945519f, 0.951057f, 0.956305f, 0.961262f, 0.965926f, 0.970296f, 0.97437f, 0.978148f, 0.981627f,
984808f, 0.987688f, 0.990268f, 0.992546f, 0.994522f, 0.996195f, 0.997564f, 0.99863f, 0.999391f, 0.999848f, 1.0f
};

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.

                      {
    '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',
};

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:

= {
0f, 1.273187f, 1.27303f, 1.272768f, 1.272402f, 1.271932f, 1.271358f, 1.270681f, 1.269902f, 1.269021f, 1.268038f,
266956f, 1.265774f, 1.264494f, 1.263116f, 1.261643f, 1.260075f, 1.258413f, 1.256659f, 1.254815f, 1.252881f,
250859f, 1.248752f, 1.24656f, 1.244285f, 1.241929f, 1.239494f, 1.236981f, 1.234393f, 1.231731f, 1.228997f,
226192f, 1.22332f, 1.220382f, 1.217379f, 1.214315f, 1.211189f, 1.208006f, 1.204766f, 1.201471f, 1.198124f,
194727f, 1.191281f, 1.187787f, 1.18425f, 1.180669f, 1.177047f, 1.173386f, 1.169687f, 1.165952f, 1.162184f,
158384f, 1.154553f, 1.150693f, 1.146806f, 1.142893f, 1.138957f, 1.134998f, 1.131018f, 1.127019f, 1.123002f,
118969f, 1.11492f, 1.110858f, 1.106783f, 1.102697f, 1.098601f, 1.094496f, 1.090384f, 1.086266f, 1.082142f,
078014f, 1.073883f, 1.06975f, 1.065616f, 1.061482f, 1.057348f, 1.053216f, 1.049087f, 1.04496f, 1.040838f,
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.

                     {
0f, 1.273187f, 1.27303f, 1.272768f, 1.272402f, 1.271932f, 1.271358f, 1.270681f, 1.269902f, 1.269021f, 1.268038f,
266956f, 1.265774f, 1.264494f, 1.263116f, 1.261643f, 1.260075f, 1.258413f, 1.256659f, 1.254815f, 1.252881f,
250859f, 1.248752f, 1.24656f, 1.244285f, 1.241929f, 1.239494f, 1.236981f, 1.234393f, 1.231731f, 1.228997f,
226192f, 1.22332f, 1.220382f, 1.217379f, 1.214315f, 1.211189f, 1.208006f, 1.204766f, 1.201471f, 1.198124f,
194727f, 1.191281f, 1.187787f, 1.18425f, 1.180669f, 1.177047f, 1.173386f, 1.169687f, 1.165952f, 1.162184f,
158384f, 1.154553f, 1.150693f, 1.146806f, 1.142893f, 1.138957f, 1.134998f, 1.131018f, 1.127019f, 1.123002f,
118969f, 1.11492f, 1.110858f, 1.106783f, 1.102697f, 1.098601f, 1.094496f, 1.090384f, 1.086266f, 1.082142f,
078014f, 1.073883f, 1.06975f, 1.065616f, 1.061482f, 1.057348f, 1.053216f, 1.049087f, 1.04496f, 1.040838f,
036721f, 1.03261f, 1.028504f, 1.024406f, 1.020316f, 1.016234f, 1.01216f, 1.008097f, 1.004043f, 1.0f
};

Referenced by atan2().

◆ D_80074580

Gfx D_80074580[]

Initial value:

= {
    gsDPPipeSync(),
    gsSPTexture(-1, -1, 0, G_TX_RENDERTILE, G_OFF),
    gsDPSetCycleType(G_CYC_1CYCLE),
    gsDPSetTexturePersp(G_TP_NONE),
    gsDPSetTextureDetail(G_TD_CLAMP),
    gsDPSetTextureLOD(G_TL_TILE),
    gsDPSetTextureFilter(G_TF_POINT),
    gsDPSetTextureLUT(G_TT_NONE),
    gsDPSetTextureConvert(G_TC_FILT),
    gsSPEndDisplayList(),
}

Definition at line 41 of file 43F0.c.

                   {
    gsDPPipeSync(),
    gsSPTexture(-1, -1, 0, G_TX_RENDERTILE, G_OFF),
    gsDPSetCycleType(G_CYC_1CYCLE),
    gsDPSetTexturePersp(G_TP_NONE),
    gsDPSetTextureDetail(G_TD_CLAMP),
    gsDPSetTextureLOD(G_TL_TILE),
    gsDPSetTextureFilter(G_TF_POINT),
    gsDPSetTextureLUT(G_TT_NONE),
    gsDPSetTextureConvert(G_TC_FILT),
    gsSPEndDisplayList(),
};

Referenced by appendGfx_startup_prim_rect().

Macros

Functions

Variables

Macro Definition Documentation

◆ ROM_CHUNK_SIZE

Function Documentation

◆ dma_write_block()

◆ length2D()

◆ _heap_create()

◆ _heap_malloc()

◆ _heap_malloc_tail()

◆ _heap_free()

◆ _heap_realloc()

◆ cosine()

◆ sign()

◆ int_to_string()

◆ mem_clear()

◆ transform_point()

◆ copy_matrix()

◆ dma_copy()

◆ dma_write()

◆ advance_rng()

◆ rand_float()

◆ rand_int_internal()

◆ rand_int()

◆ signF()

◆ round()

◆ clamp_angle()

◆ get_clamped_angle_diff()

◆ atan2()

◆ get_player_normal_yaw()

◆ get_player_normal_pitch()

◆ dist2D()

◆ dist3D()

◆ add_vec2D_polar()

◆ _wrap_trig_lookup_value()

◆ sin_cos_rad()

◆ sin_rad()

◆ cos_rad()

◆ sin_cos_deg()

◆ sin_deg()

◆ cos_deg()

◆ update_lerp()

◆ appendGfx_startup_prim_rect()

◆ startup_draw_prim_rect_COPY()

◆ startup_draw_prim_rect()

Variable Documentation

◆ heap_nextMallocID

◆ sCosineTable

◆ sIntegerDigits

◆ gRandSeed

◆ sAtanFactors

◆ D_80074580