render_player.c File Reference

#include <libultraship.h>
#include <macros.h>
#include <mk64.h>
#include <stubs.h>
#include <common_structs.h>
#include <defines.h>
#include "code_800029B0.h"
#include "camera.h"
#include "math_util.h"
#include "math_util_2.h"
#include "main.h"
#include "decode.h"
#include "kart_dma.h"
#include "objects.h"
#include "render_player.h"
#include "code_80057C60.h"
#include "effects.h"
#include "buffers.h"
#include "waypoints.h"
#include "player_controller.h"
#include "render_objects.h"
#include <assets/models/common_data.h>
#include "skybox_and_splitscreen.h"
#include "spawn_players.h"
#include <assets/textures/karts/mario_kart.h>
#include <assets/textures/karts/luigi_kart.h>
#include <assets/textures/karts/peach_kart.h>
#include <assets/textures/karts/yoshi_kart.h>
#include <assets/textures/karts/toad_kart.h>
#include <assets/textures/karts/bowser_kart.h>
#include <assets/textures/karts/wario_kart.h>
#include <assets/textures/karts/donkeykong_kart.h>
#include "port/Game.h"
#include "engine/Matrix.h"
#include "port/interpolation/FrameInterpolation.h"
#include "port/Engine.h"

Include dependency graph for render_player.c:

Macros
#define	PLAYER_WHEEL_MACRO(a, screenId, playerId)

Typedefs
typedef u8 **	kart_texture_t

Functions
void	func_8001F980 (s32 *arg0, s32 *arg1)
void	func_8001F9E4 (Player *player, Camera *camera, s8 screenId)
u16	check_player_camera_collision (Player *player, Camera *camera, f32 arg2, f32 arg3)
u16	func_8001FD78 (Player *player, f32 posX, UNUSED f32 arg2, f32 posZ)
void	init_render_player (Player *player, Camera *camera, s8 playerId, s8 screenId)
	one of his function is to put the frame to load in to a list to load it to be only applied for the next frame
void	load_kart_texture_and_render_kart_particles (s32 screenIdx)
void	try_rendering_player (Player *player, s8 playerId, s8 screenIdx)
void	render_players (Camera *camera, s32 screenIdx)
void	func_80021B0C (void)
void	func_80021C78 (void)
void	func_80021D40 (void)
void	func_80021DA8 (void)
void	mtxf_translate_rotate (Mat4 dest, Vec3f pos, Vec3s orientation)
UNUSED void	func_80021F50 (Mat4 arg0, Vec3f arg1)
UNUSED void	failed_fixed_point_matrix_conversion (Mtx *dest, Mat4 src)
void	convert_to_fixed_point_matrix (Mtx *dest, Mat4 src)
bool	adjust_angle (s16 *angle, s16 targetAngle, s16 step)
void	move_s32_towards (s32 *startingValue, s32 targetValue, f32 somePercent)
void	move_f32_towards (f32 *startingValue, f32 targetValue, f32 somePercent)
void	move_s16_towards (s16 *startingValue, s16 targetValue, f32 somePercent)
void	move_u16_towards (u16 *startingValue, s16 targetValue, f32 somePercent)
void	func_80022744 (void)
void	func_8002276C (void)
void	func_80022A98 (Player *player, s8 arg1)
void	func_80022B50 (Player *player, UNUSED s8 arg1)
void	func_80022BC4 (Player *player, UNUSED s8 arg1)
void	func_80022CA8 (Player *player, s8 playerId, UNUSED s8 screenId, s8 flipOffset)
void	func_80022D60 (UNUSED Player *player, s8 playerId, UNUSED s8 screenId, s8 flipOffset)
void	func_80022DB4 (Player *player, UNUSED s8 arg1)
void	func_80022E84 (Player *player, s8 playerId, UNUSED s8 screenId, s8 flipOffset)
void	change_player_color_effect_rgb (UNUSED Player *player, s8 arg1, s32 arg2, f32 alpha)
void	change_player_color_effect_cmy (UNUSED Player *player, s8 arg1, s32 arg2, f32 arg3)
bool	is_player_under_light_luigi_raceway (Player *player, s8 arg1)
void	render_light_environment_on_player (Player *player, s8 arg1)
void	func_800235AC (Player *player, s8 arg1)
void	func_80023BF0 (Player *player, s8 playerId, s8 screenId, s8 arg3)
void	render_player_shadow (Player *player, s8 playerId, s8 screenId)
void	render_player_shadow_credits (Player *player, s8 playerId, s8 screenId)
void	render_kart (Player *player, s8 playerId, s8 screenId, s8 flipOffset)
void	render_ghost (Player *player, s8 playerId, s8 screenId, s8 flipOffset)
void	func_80025DE8 (Player *player, s8 playerId, s8 screenId, s8 flipOffset)
void	render_player_ice_reflection (Player *player, s8 playerId, s8 screenId, s8 flipOffset)
void	render_player (Player *player, s8 playerId, s8 screenId)
void	func_80026A48 (Player *player, s8 arg1)
void	update_wheel_palette (Player *player, s8 playerId, s8 screenId, s8 arg3)
UNUSED void	func_8002701C (void)
UNUSED void	func_80027024 (UNUSED s32 arg0, UNUSED s32 arg1, UNUSED s32 arg2)

Variables
s8	gRenderingFramebufferByPlayer [] = { 0x00, 0x02, 0x00, 0x01, 0x00, 0x01, 0x00, 0x02 }
s32	gPlayersToRenderCount = 0
UNUSED void *	D_800DDB5C [3] = { gFramebuffer0, gFramebuffer1, gFramebuffer2 }
s16	gPlayersToRenderPlayerId [8]
s16	gPlayersToRenderScreenId [8]
Player *	gPlayersToRenderPlayer [8]
s16	gMatrixEffectCount
s32	D_80164AF4 [3]
struct_D_802F1F80 *	gPlayerPalette
static const char *	sKartTexture
u16	gPlayerRedEffect [8]
u16	gPlayerGreenEffect [8]
u16	gPlayerBlueEffect [8]
u16	gPlayerCyanEffect [8]
u16	gPlayerMagentaEffect [8]
u16	gPlayerYellowEffect [8]
UNUSED u16	gPlayerWhiteEffect [8]
s32	D_80164B80 [296]
s16	D_80165020 [40]
Vec3f	gPlayerLastVelocity [8]
s16	gLastAnimFrameSelector [4][8]
s16	gLastAnimGroupSelector [4][8]
s16	D_80165150 [4][8]
s16	D_80165190 [4][8]
s16	D_801651D0 [4][8]
s32	junk [] = { 0, 0, 0 }
Vtx *	gPlayerVtx []
f32	gCharacterSize [] = { MARIO_SIZE, LUIGI_SIZE, YOSHI_SIZE, TOAD_SIZE, DK_SIZE, WARIO_SIZE, PEACH_SIZE, BOWSER_SIZE }
u32	gKartMarioWheels0 [] = { 672, 588, 504, 420, 336, 252, 168, 84, 0 }
u32	gKartMarioWheels1 [] = { 1076, 1076, 996, 916, 916, 916, 836, 756, 756 }
u32	gKartLuigiWheels0 [] = { 672, 588, 504, 420, 336, 252, 168, 84, 0 }
u32	gKartLuigiWheels1 [] = { 1076, 1076, 996, 916, 916, 916, 836, 756, 756 }
u32	gKartBowserWheels0 [] = { 672, 588, 504, 420, 336, 252, 168, 84, 0 }
u32	gKartBowserWheels1 [] = { 1076, 1076, 996, 916, 916, 916, 836, 756, 756 }
u32	gKartToadWheels0 [] = { 672, 588, 504, 420, 336, 252, 168, 84, 0 }
u32	gKartToadWheels1 [] = { 1076, 1076, 996, 916, 916, 916, 836, 756, 756 }
u32	gKartYoshiWheels0 [] = { 672, 588, 504, 420, 336, 252, 168, 84, 0 }
u32	gKartYoshiWheels1 [] = { 1076, 1076, 996, 916, 916, 916, 836, 756, 756 }
u32	gKartDKWheels0 [] = { 672, 588, 504, 420, 336, 252, 168, 84, 0 }
u32	gKartDKWheels1 [] = { 1076, 1076, 996, 916, 916, 916, 836, 756, 756 }
u32	gKartPeachWheels0 [] = { 672, 588, 504, 420, 336, 252, 168, 84, 0 }
u32	gKartPeachWheels1 [] = { 1076, 1076, 996, 916, 916, 916, 836, 756, 756 }
u32	gKartWarioWheels0 [] = { 672, 588, 504, 420, 336, 252, 168, 84, 0 }
u32	gKartWarioWheels1 [] = { 1076, 1076, 996, 916, 916, 916, 836, 756, 756 }
u32 *	gPaletteWheel0Offset []
u32 *	gPaletteWheel1Offset []
const char **	wheelPtr []
s32	D_800DDE74 [] = { 96, 128, 192, 256, 288, 384, 512, 544, 576, 0, 0 }
Vtx	gKartShadowVertices []
kart_texture_t **	gKartTextureTable0 []
kart_texture_t **	gKartTextureTable1 []
u8 **	gKartTextureTumbles []
u32	wheel_offset [] = { 1076, 1076, 996, 916, 916, 916, 836, 756, 756 }

Macro Definition Documentation

PLAYER_WHEEL_MACRO

#define PLAYER_WHEEL_MACRO	(		a,
			screenId,
			playerId )

Value:

&gPlayerPalettesList[a][screenId][(PlayerId * 0x100) + 0xC0]

Typedef Documentation

kart_texture_t

typedef u8** kart_texture_t

Function Documentation

adjust_angle()

bool adjust_angle	(	s16 *	angle,
		s16	targetAngle,
		s16	step )

Here is the caller graph for this function:

change_player_color_effect_cmy()

void change_player_color_effect_cmy	(	UNUSED Player *	player,
		s8	arg1,
		s32	arg2,
		f32	arg3 )

Here is the call graph for this function:

Here is the caller graph for this function:

change_player_color_effect_rgb()

void change_player_color_effect_rgb	(	UNUSED Player *	player,
		s8	arg1,
		s32	arg2,
		f32	alpha )

Sets player shading/colour.

Here is the caller graph for this function:

check_player_camera_collision()

u16 check_player_camera_collision	(	Player *	player,
		Camera *	camera,
		f32	arg2,
		f32	arg3 )

Here is the call graph for this function:

Here is the caller graph for this function:

convert_to_fixed_point_matrix()

void convert_to_fixed_point_matrix	(	Mtx *	dest,
		Mat4	src )

Takes a floating-point matrix and converts it to an s15.16 internal matrix. Each Mtx entry is a size of s32 that holds two values. The first 16 entries hold only the integer values and the second 16 entries hold only the decimal (fractional) parts. In simpler words, the integer and decimal gets split up and stored in their own section. Mtx is setup this way due to hardware restrictions of the n64 or as an optimization.

Parameters

Mtx	A new internal fixed-point matrix.
Mat4	An array of f32 Mat4 to Mtx explanation: https://blarg.ca/2020/10/11/fixed-point-math.

Here is the call graph for this function:

Here is the caller graph for this function:

failed_fixed_point_matrix_conversion()

UNUSED void failed_fixed_point_matrix_conversion	(	Mtx *	dest,
		Mat4	src )

This function writes a fixed-point value to each Mtx entry. This is not how the Mtx struct works. The first half of Mtx only holds s16 whole numbers and the second half holds the s16 decimal (fractional) parts. See convert_to_fixed_point_matrix() for correct calculations. Note that each Mtx entry is the size of s32. This means each Mtx entry holds two s16 values. The first sixteen entries contain only the integer parts and the second sixteen entries hold only the decimal (fractional) parts.

func_8001F980()

void func_8001F980	(	s32 *	arg0,
		s32 *	arg1 )

Here is the caller graph for this function:

func_8001F9E4()

void func_8001F9E4	(	Player *	player,
		Camera *	camera,
		s8	screenId )

Here is the call graph for this function:

Here is the caller graph for this function:

func_8001FD78()

u16 func_8001FD78	(	Player *	player,
		f32	posX,
		UNUSED f32	arg2,
		f32	posZ )

Here is the call graph for this function:

Here is the caller graph for this function:

func_80021B0C()

void func_80021B0C

(

void

)

Here is the call graph for this function:

Here is the caller graph for this function:

func_80021C78()

void func_80021C78

(

void

)

Here is the call graph for this function:

Here is the caller graph for this function:

func_80021D40()

void func_80021D40

(

void

)

Here is the call graph for this function:

Here is the caller graph for this function:

func_80021DA8()

void func_80021DA8

(

void

)

Here is the call graph for this function:

Here is the caller graph for this function:

func_80021F50()

UNUSED void func_80021F50	(	Mat4	arg0,
		Vec3f	arg1 )

func_80022744()

void func_80022744

(

void

)

Here is the call graph for this function:

Here is the caller graph for this function:

func_8002276C()

void func_8002276C

(

void

)

Here is the call graph for this function:

Here is the caller graph for this function:

func_80022A98()

void func_80022A98	(	Player *	player,
		s8	arg1 )

Here is the call graph for this function:

Here is the caller graph for this function:

func_80022B50()

void func_80022B50	(	Player *	player,
		UNUSED s8	arg1 )

Here is the caller graph for this function:

func_80022BC4()

void func_80022BC4	(	Player *	player,
		UNUSED s8	arg1 )

Here is the caller graph for this function:

func_80022CA8()

void func_80022CA8	(	Player *	player,
		s8	playerId,
		UNUSED s8	screenId,
		s8	flipOffset )

Here is the caller graph for this function:

func_80022D60()

void func_80022D60	(	UNUSED Player *	player,
		s8	playerId,
		UNUSED s8	screenId,
		s8	flipOffset )

Seems to stretch/warp a specific players texture for a short period of time. Perhaps does not do anything

Here is the caller graph for this function:

func_80022DB4()

void func_80022DB4	(	Player *	player,
		UNUSED s8	arg1 )

Here is the caller graph for this function:

func_80022E84()

void func_80022E84	(	Player *	player,
		s8	playerId,
		UNUSED s8	screenId,
		s8	flipOffset )

Here is the caller graph for this function:

func_800235AC()

void func_800235AC	(	Player *	player,
		s8	arg1 )

Here is the call graph for this function:

Here is the caller graph for this function:

func_80023BF0()

void func_80023BF0	(	Player *	player,
		s8	playerId,
		s8	screenId,
		s8	arg3 )

Here is the call graph for this function:

Here is the caller graph for this function:

func_80025DE8()

void func_80025DE8	(	Player *	player,
		s8	playerId,
		s8	screenId,
		s8	flipOffset )

Here is the call graph for this function:

Here is the caller graph for this function:

func_80026A48()

void func_80026A48	(	Player *	player,
		s8	arg1 )

Warning

This condition prevents an array overflow.

Here is the caller graph for this function:

func_8002701C()

UNUSED void func_8002701C

(

void

)

func_80027024()

UNUSED void func_80027024	(	UNUSED s32	arg0,
		UNUSED s32	arg1,
		UNUSED s32	arg2 )

init_render_player()

void init_render_player	(	Player *	player,
		Camera *	camera,
		s8	playerId,
		s8	screenId )

one of his function is to put the frame to load in to a list to load it to be only applied for the next frame

Here is the call graph for this function:

Here is the caller graph for this function:

is_player_under_light_luigi_raceway()

bool is_player_under_light_luigi_raceway	(	Player *	player,
		s8	arg1 )

Activates in the tunnel to shade the player a bit darker Sort of an atmospheric effect.

Here is the call graph for this function:

Here is the caller graph for this function:

load_kart_texture_and_render_kart_particles()

void load_kart_texture_and_render_kart_particles

(

s32

screenIdx

)

This function used to be split for each player screen. It is combined now.

Check buffers.c // [nothing][screen][player] ALIGNED8 struct_D_802DFB80 gEncodedKartTexture[2][2][8];

The buffer is sized for two screens. In 3P/4P mode, the player and screen indexes need to be adjusted like so:

Screen 3 uses buffer[unused][screen 1][slots 5-8] Screen 4 uses buffer[unused][screen 2][slots 5-8]

Due to this remapping, 3P/4P modes only support upto four racers.

Here is the call graph for this function:

Here is the caller graph for this function:

move_f32_towards()

void move_f32_towards	(	f32 *	startingValue,
		f32	targetValue,
		f32	somePercent )

Function: move_f32_towards

Parameters: f32 *startingValue - Pointer to the float that will be modified f32 targetValue - Float value to move startingValue towards f32 somePercent - The percent of the difference between startingValue and targetValue to actually move

Moves a given startingValue the given somePercent towards the targetValue

f32 *thing = 2500; move_f32_towards(thing, 500, 0.75f); thing now has a value of 1000

If after the move startingValue is inside of the range [-0.001, 0.001], force it to exactly 0.0f

This is probably a precision thing. The scaling with somePercent likely can't hit exactly 0 with any reliability, so they force it to 0 if you're in a small range around it. Why they only do this for 0 is anyone's guess though

Here is the caller graph for this function:

move_s16_towards()

void move_s16_towards	(	s16 *	startingValue,
		s16	targetValue,
		f32	somePercent )

Here is the caller graph for this function:

move_s32_towards()

void move_s32_towards	(	s32 *	startingValue,
		s32	targetValue,
		f32	somePercent )

Here is the caller graph for this function:

move_u16_towards()

void move_u16_towards	(	u16 *	startingValue,
		s16	targetValue,
		f32	somePercent )

Here is the caller graph for this function:

mtxf_translate_rotate()

void mtxf_translate_rotate	(	Mat4	dest,
		Vec3f	pos,
		Vec3s	orientation )

Here is the call graph for this function:

Here is the caller graph for this function:

render_ghost()

void render_ghost	(	Player *	player,
		s8	playerId,
		s8	screenId,
		s8	flipOffset )

Here is the call graph for this function:

Here is the caller graph for this function:

render_kart()

void render_kart	(	Player *	player,
		s8	playerId,
		s8	screenId,
		s8	flipOffset )

Here is the call graph for this function:

Here is the caller graph for this function:

render_light_environment_on_player()

void render_light_environment_on_player	(	Player *	player,
		s8	arg1 )

Here is the call graph for this function:

Here is the caller graph for this function:

render_player()

void render_player	(	Player *	player,
		s8	playerId,
		s8	screenId )

Here is the call graph for this function:

Here is the caller graph for this function:

render_player_ice_reflection()

void render_player_ice_reflection	(	Player *	player,
		s8	playerId,
		s8	screenId,
		s8	flipOffset )

Here is the call graph for this function:

Here is the caller graph for this function:

render_player_shadow()

void render_player_shadow	(	Player *	player,
		s8	playerId,
		s8	screenId )

Here is the call graph for this function:

Here is the caller graph for this function:

render_player_shadow_credits()

void render_player_shadow_credits	(	Player *	player,
		s8	playerId,
		s8	screenId )

Here is the call graph for this function:

Here is the caller graph for this function:

render_players()

void render_players	(	Camera *	camera,
		s32	screenIdx )

Here is the call graph for this function:

Here is the caller graph for this function:

try_rendering_player()

void try_rendering_player	(	Player *	player,
		s8	playerId,
		s8	screenIdx )

Here is the call graph for this function:

Here is the caller graph for this function:

update_wheel_palette()

void update_wheel_palette	(	Player *	player,
		s8	playerId,
		s8	screenId,
		s8	arg3 )

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

D_800DDB5C

UNUSED void* D_800DDB5C[3] = { gFramebuffer0, gFramebuffer1, gFramebuffer2 }

D_800DDE74

s32 D_800DDE74[] = { 96, 128, 192, 256, 288, 384, 512, 544, 576, 0, 0 }

D_80164AF4

s32 D_80164AF4[3]

D_80164B80

s32 D_80164B80[296]

D_80165020

s16 D_80165020[40]

D_80165150

s16 D_80165150[4][8]

D_80165190

s16 D_80165190[4][8]

D_801651D0

s16 D_801651D0[4][8]

gCharacterSize

f32 gCharacterSize[] = { MARIO_SIZE, LUIGI_SIZE, YOSHI_SIZE, TOAD_SIZE, DK_SIZE, WARIO_SIZE, PEACH_SIZE, BOWSER_SIZE }

gKartBowserWheels0

u32 gKartBowserWheels0[] = { 672, 588, 504, 420, 336, 252, 168, 84, 0 }

gKartBowserWheels1

u32 gKartBowserWheels1[] = { 1076, 1076, 996, 916, 916, 916, 836, 756, 756 }

gKartDKWheels0

u32 gKartDKWheels0[] = { 672, 588, 504, 420, 336, 252, 168, 84, 0 }

gKartDKWheels1

u32 gKartDKWheels1[] = { 1076, 1076, 996, 916, 916, 916, 836, 756, 756 }

gKartLuigiWheels0

u32 gKartLuigiWheels0[] = { 672, 588, 504, 420, 336, 252, 168, 84, 0 }

gKartLuigiWheels1

u32 gKartLuigiWheels1[] = { 1076, 1076, 996, 916, 916, 916, 836, 756, 756 }

gKartMarioWheels0

u32 gKartMarioWheels0[] = { 672, 588, 504, 420, 336, 252, 168, 84, 0 }

gKartMarioWheels1

u32 gKartMarioWheels1[] = { 1076, 1076, 996, 916, 916, 916, 836, 756, 756 }

gKartPeachWheels0

u32 gKartPeachWheels0[] = { 672, 588, 504, 420, 336, 252, 168, 84, 0 }

gKartPeachWheels1

u32 gKartPeachWheels1[] = { 1076, 1076, 996, 916, 916, 916, 836, 756, 756 }

gKartShadowVertices

Vtx gKartShadowVertices[]

Initial value:

= {
    { { { 9, 0, 9 }, 0, { 4032, 0 }, { 0xFF, 0xFF, 0xFF, 0xFF } } },
    { { { 9, 0, -9 }, 0, { 4032, 4032 }, { 0xFF, 0xFF, 0xFF, 0xFF } } },
    { { { -9, 0, -9 }, 0, { 0, 4032 }, { 0xFF, 0xFF, 0xFF, 0xFF } } },
    { { { -9, 0, 9 }, 0, { 0, 0 }, { 0xFF, 0xFF, 0xFF, 0xFF } } },
}

gKartTextureTable0

kart_texture_t** gKartTextureTable0[]

extern

gKartTextureTable1

kart_texture_t** gKartTextureTable1[]

extern

gKartTextureTumbles

u8** gKartTextureTumbles[]

extern

gKartToadWheels0

u32 gKartToadWheels0[] = { 672, 588, 504, 420, 336, 252, 168, 84, 0 }

gKartToadWheels1

u32 gKartToadWheels1[] = { 1076, 1076, 996, 916, 916, 916, 836, 756, 756 }

gKartWarioWheels0

u32 gKartWarioWheels0[] = { 672, 588, 504, 420, 336, 252, 168, 84, 0 }

gKartWarioWheels1

u32 gKartWarioWheels1[] = { 1076, 1076, 996, 916, 916, 916, 836, 756, 756 }

gKartYoshiWheels0

u32 gKartYoshiWheels0[] = { 672, 588, 504, 420, 336, 252, 168, 84, 0 }

gKartYoshiWheels1

u32 gKartYoshiWheels1[] = { 1076, 1076, 996, 916, 916, 916, 836, 756, 756 }

gLastAnimFrameSelector

s16 gLastAnimFrameSelector[4][8]

gLastAnimGroupSelector

s16 gLastAnimGroupSelector[4][8]

gMatrixEffectCount

s16 gMatrixEffectCount

gPaletteWheel0Offset

u32* gPaletteWheel0Offset[]

Initial value:

= { gKartMarioWheels0, gKartLuigiWheels0, gKartYoshiWheels0, gKartToadWheels0,
                      gKartDKWheels0,    gKartWarioWheels0, gKartPeachWheels0, gKartBowserWheels0 }

gPaletteWheel1Offset

u32* gPaletteWheel1Offset[]

Initial value:

= { gKartMarioWheels1, gKartLuigiWheels1, gKartYoshiWheels1, gKartToadWheels1,
                      gKartDKWheels1,    gKartWarioWheels1, gKartPeachWheels1, gKartBowserWheels1 }

gPlayerBlueEffect

u16 gPlayerBlueEffect[8]

gPlayerCyanEffect

u16 gPlayerCyanEffect[8]

gPlayerGreenEffect

u16 gPlayerGreenEffect[8]

gPlayerLastVelocity

Vec3f gPlayerLastVelocity[8]

gPlayerMagentaEffect

u16 gPlayerMagentaEffect[8]

gPlayerPalette

struct_D_802F1F80* gPlayerPalette

gPlayerRedEffect

u16 gPlayerRedEffect[8]

gPlayersToRenderCount

s32 gPlayersToRenderCount = 0

gPlayersToRenderPlayer

Player* gPlayersToRenderPlayer[8]

gPlayersToRenderPlayerId

s16 gPlayersToRenderPlayerId[8]

gPlayersToRenderScreenId

s16 gPlayersToRenderScreenId[8]

gPlayerVtx

Vtx* gPlayerVtx[]

Initial value:

= { gPlayerOneVtx,  gPlayerTwoVtx, gPlayerThreeVtx, gPlayerFourVtx,
                      gPlayerFiveVtx, gPlayerSixVtx, gPlayerSevenVtx, gPlayerEightVtx }

gPlayerWhiteEffect

UNUSED u16 gPlayerWhiteEffect[8]

gPlayerYellowEffect

u16 gPlayerYellowEffect[8]

gRenderingFramebufferByPlayer

s8 gRenderingFramebufferByPlayer[] = { 0x00, 0x02, 0x00, 0x01, 0x00, 0x01, 0x00, 0x02 }

junk

s32 junk[] = { 0, 0, 0 }

sKartTexture

const char* sKartTexture

static

wheel_offset

u32 wheel_offset[] = { 1076, 1076, 996, 916, 916, 916, 836, 756, 756 }

wheelPtr

const char** wheelPtr[]

Initial value:

= {
    mario_kart_wheels,      luigi_kart_wheels, yoshi_kart_wheels, toad_kart_wheels,
    donkeykong_kart_wheels, wario_kart_wheels, peach_kart_wheels, bowser_kart_wheels,
}