Data Structures
struct	SpriteComponent

struct	PlayerCurrentAnimInfo

struct	SpriteAnimComponent

struct	SpriteRasterCacheEntry

struct	SpriteAnimData
	Sprite data header. More...

struct	SpriteInstance

struct	PlayerRastersHeader

struct	PlayerSpriteSet

struct	PlayerSpriteCacheEntry

struct	Quad

Macros
#define	SPR_PLAYER_COLOR_VARIATIONS 6

#define	SPR_PEACH_BTL_PAL_STRIDE 4

#define	SPR_UNPACK_SPR(animID) (((animID) >> 16) & 0xFF)

#define	SPR_UNPACK_PAL(animID) (((animID) >> 8) & 0xFF)

#define	SPR_UNPACK_ANIM(animID) ((animID) & 0xFF)

Enumerations
enum	SpriteIDFields { SPRITE_ID_ANIM_MASK = 0x000000FF , SPRITE_ID_PAL_MASK = 0x0000FF00 , SPRITE_ID_SPR_MASK = 0x00FF0000 , SPRITE_ID_BACK_FACING = 0x01000000 , SPRITE_ID_TAIL_ALLOCATE = 0x80000000 }

enum	DrawSpriteOptions { DRAW_SPRITE_USE_PLAYER_RASTERS = 0x08000000 , DRAW_SPRITE_UPSIDE_DOWN = 0x10000000 , DRAW_SPRITE_OVERRIDE_PALETTES = 0x20000000 , DRAW_SPRITE_OVERRIDE_YAW = 0x40000000 , DRAW_SPRITE_OVERRIDE_ALPHA = 0x80000000 }

enum	{ PLAYER_SPRITE_MAIN = 0 , PLAYER_SPRITE_AUX1 = 1 , PLAYER_SPRITE_AUX2 = 2 }

enum	{ SPRITE_MODE_PLAYER = 0 , SPRITE_MODE_NPC = 1 }

Functions
void	imgfx_init (void)

void	spr_init_sprites (s32 playerSpriteSet)

void	spr_render_init (void)

void	spr_update_player_raster_cache (void)

s32	spr_update_player_sprite (s32 arg0, s32 arg1, f32 timescale)

s32	spr_draw_player_sprite (s32 spriteInstanceID, s32 yaw, s32 arg2, PAL_PTR *paletteList, Matrix4f mtx)

s32	func_802DDEC4 (s32 arg0)

void	set_player_imgfx_comp (s32, s32, ImgFXType, s32, s32, s32, s32, s32)

void	set_player_imgfx_all (s32, ImgFXType, s32, s32, s32, s32, s32)

IMG_PTR	spr_get_player_raster (s32 rasterIndex, s32 playerSpriteID)

void	spr_get_player_raster_info (SpriteRasterInfo *out, s32 playerSpriteID, s32 rasterIndex)

PAL_PTR *	spr_get_player_palettes (s32 spriteIndex)

s32	spr_load_npc_sprite (s32 animID, u32 *extraAnimList)

s32	spr_update_sprite (s32 spriteInstanceID, s32 animID, f32 timeScale)

s32	spr_draw_npc_sprite (s32 spriteInstanceID, s32 yaw, s32 alphaIn, PAL_PTR *paletteList, Matrix4f mtx)

s32	spr_get_notify_value (s32 spriteInstanceID)

s32	spr_free_sprite (s32 spriteInstanceID)

s32	get_npc_comp_imgfx_idx (s32, s32)

void	set_npc_imgfx_comp (s32, s32, ImgFXType, s32, s32, s32, s32, s32)

void	set_npc_imgfx_all (s32 arg0, ImgFXType arg1, s32 arg2, s32 arg3, s32 arg4, s32 arg5, s32 arg6)

s32	spr_get_comp_position (s32 spriteIdx, s32 compListIdx, s32 outX, s32 outY, s32 *outZ)

s32	spr_get_npc_raster_info (SpriteRasterInfo *out, s32 npcSpriteID, s32 rasterIndex)

PAL_PTR *	spr_get_npc_palettes (s32 npcSpriteID)

s32	spr_get_npc_color_variations (s32 npcSpriteID)

void	create_shading_palette (Matrix4f mtx, s32 uls, s32 ult, s32 lrs, s32 lrt, s32 alpha, s32)

void	func_801491E4 (Matrix4f mtx, s32, s32, s32, s32, s32 alpha)

SpriteAnimData *	spr_load_sprite (s32 idx, s32 arg1, s32 arg2)

Data Structure Documentation

◆ SpriteComponent

struct SpriteComponent

Data Fields
s32	initialized
s32	properties	AABBCCCC : AA = unused?, BB = parent, CCCC = notify value.
s16 *	readPos
f32	waitTime
s32	loopCounter
s32	curRaster
s32	curPalette
Vec3f	posOffset
Vec3f	compPos
Vec3i	rot
Vec3f	scale
s32	imgfxIdx

◆ PlayerCurrentAnimInfo

struct PlayerCurrentAnimInfo

Data Fields
SpriteComponent **	componentList
s32	animID
s32	notifyValue

◆ SpriteAnimComponent

struct SpriteAnimComponent

Data Fields
u16 *	cmdList
s16	cmdListSize
Vec3s	compOffset

◆ SpriteRasterCacheEntry

struct SpriteRasterCacheEntry

Data Fields
IMG_PTR	image
u8	width
u8	height
s8	palette
s8	quadCacheIndex

◆ SpriteAnimData

struct SpriteAnimData

Data Fields
SpriteRasterCacheEntry **	rastersOffset
PAL_PTR *	palettesOffset
s32	maxComponents
s32	colorVariations
SpriteAnimComponent **	animListStart[VLA]

◆ SpriteInstance

struct SpriteInstance

Data Fields
s32	spriteIndex
SpriteComponent **	componentList
SpriteAnimData *	spriteData
s32	curAnimID
s32	notifyValue

◆ PlayerRastersHeader

struct PlayerRastersHeader

Data Fields
s32	indexRanges
s32	loadDescriptors
s32	imageData

◆ PlayerSpriteSet

struct PlayerSpriteSet

Data Fields
s32	cacheSize	Number of cache entries.
s32	rasterSize	Maximum raster size.
s32	initiallyLoaded	Flags saying which rasters to load into the cache in spr_init_sprites(), with each bit corresponding to the Nth raster (with LSB = raster 0).

◆ PlayerSpriteCacheEntry

struct PlayerSpriteCacheEntry

Data Fields
s32	lazyDeleteTime
s32	rasterIndex
s32	spriteIndex
IMG_PTR	raster

◆ Quad

struct Quad

Data Fields
Vtx	v[4]

Macro Definition Documentation

◆ SPR_PLAYER_COLOR_VARIATIONS

#define SPR_PLAYER_COLOR_VARIATIONS 6

Definition at line 6 of file sprite.h.

Referenced by render_with_player_debuff_palettes(), render_with_poison_palettes(), render_with_static_palettes(), render_with_watt_attack_palettes(), and render_with_watt_idle_palettes().

◆ SPR_PEACH_BTL_PAL_STRIDE

#define SPR_PEACH_BTL_PAL_STRIDE 4

Definition at line 7 of file sprite.h.

Referenced by render_with_player_debuff_palettes().

◆ SPR_UNPACK_SPR

#define SPR_UNPACK_SPR ( animID ) (((animID) >> 16) & 0xFF)

Definition at line 9 of file sprite.h.

Referenced by spr_draw_player_sprite(), and spr_update_player_sprite().

◆ SPR_UNPACK_PAL

#define SPR_UNPACK_PAL ( animID ) (((animID) >> 8) & 0xFF)

Definition at line 10 of file sprite.h.

Referenced by spr_update_sprite().

◆ SPR_UNPACK_ANIM

#define SPR_UNPACK_ANIM ( animID ) ((animID) & 0xFF)

Definition at line 11 of file sprite.h.

Referenced by spr_draw_npc_sprite(), spr_draw_player_sprite(), spr_update_player_sprite(), and spr_update_sprite().

Enumeration Type Documentation

◆ SpriteIDFields

enum SpriteIDFields

Enumerator
SPRITE_ID_ANIM_MASK
SPRITE_ID_PAL_MASK
SPRITE_ID_SPR_MASK
SPRITE_ID_BACK_FACING
SPRITE_ID_TAIL_ALLOCATE

Definition at line 13 of file sprite.h.

                    {
    SPRITE_ID_ANIM_MASK         = 0x000000FF,
    SPRITE_ID_PAL_MASK          = 0x0000FF00,
    SPRITE_ID_SPR_MASK          = 0x00FF0000,
    SPRITE_ID_BACK_FACING       = 0x01000000,
    SPRITE_ID_TAIL_ALLOCATE     = 0x80000000,
};

◆ DrawSpriteOptions

enum DrawSpriteOptions

Enumerator
DRAW_SPRITE_USE_PLAYER_RASTERS
DRAW_SPRITE_UPSIDE_DOWN
DRAW_SPRITE_OVERRIDE_PALETTES
DRAW_SPRITE_OVERRIDE_YAW
DRAW_SPRITE_OVERRIDE_ALPHA

Definition at line 21 of file sprite.h.

                       {
    DRAW_SPRITE_USE_PLAYER_RASTERS  = 0x08000000,
    DRAW_SPRITE_UPSIDE_DOWN         = 0x10000000,
    DRAW_SPRITE_OVERRIDE_PALETTES   = 0x20000000,
    DRAW_SPRITE_OVERRIDE_YAW        = 0x40000000,
    DRAW_SPRITE_OVERRIDE_ALPHA      = 0x80000000,
};

◆ anonymous enum

anonymous enum

Enumerator
PLAYER_SPRITE_MAIN
PLAYER_SPRITE_AUX1
PLAYER_SPRITE_AUX2

Definition at line 29 of file sprite.h.

     {
    PLAYER_SPRITE_MAIN      = 0,
    PLAYER_SPRITE_AUX1      = 1,
    PLAYER_SPRITE_AUX2      = 2,
};

◆ anonymous enum

anonymous enum

Enumerator
SPRITE_MODE_PLAYER
SPRITE_MODE_NPC

Definition at line 36 of file sprite.h.

     {
    SPRITE_MODE_PLAYER  = 0,
    SPRITE_MODE_NPC     = 1,
};

Function Documentation

◆ imgfx_init()

void imgfx_init ( void )

Definition at line 242 of file imgfx.c.

                      {
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(ImgFXVtxBuffers); i++) {
        ImgFXVtxBuffers[i] = _heap_malloc(&heap_spriteHead, ImgFXVtxBufferCapacity * sizeof(Vtx));
    }
 
    ImgFXInstances = (ImgFXInstanceList*)_heap_malloc(&heap_spriteHead, sizeof(ImgFXInstanceList));
 
    for (i = 0; i < ARRAY_COUNT(*ImgFXInstances); i++) {
        imgfx_init_instance(&(*ImgFXInstances)[i]);
        imgfx_clear_instance_data(&(*ImgFXInstances)[i]);
    }
 
    for (i = 0; i < ARRAY_COUNT(ImgFXDataCache); i++) {
        ImgFXDataCache[i].data = NULL;
        ImgFXDataCache[i].staleCooldownTimer = 0;
        ImgFXDataCache[i].usingContextualHeap = FALSE;
    }
 
    imgfx_vtxCount = 0;
    imgfx_vtxBuf = ImgFXVtxBuffers[gCurrentDisplayContextIndex];
}

Referenced by spr_init_sprites().

◆ spr_init_sprites()

void spr_init_sprites ( s32 playerSpriteSet )

Definition at line 765 of file sprite.c.

                                           {
    s32 loadedFlags;
    s32 i;
 
    SpriteUseGeneralHeap = FALSE;
    _heap_create(&heap_spriteHead, SPRITE_HEAP_SIZE);
    imgfx_init();
 
    for (i = 0; i < ARRAY_COUNT(PlayerSprites); i++) {
        SpriteAnimData** playerSprites = PlayerSprites;
        playerSprites[i] = 0;
    }
 
    MaxPlayerSpriteComponents = 0;
 
    if (gGameStatusPtr->peachFlags & PEACH_FLAG_IS_PEACH) {
        playerSpriteSet = PLAYER_SPRITES_PEACH_WORLD;
    }
 
    loadedFlags = (&PlayerSpriteSets[playerSpriteSet])->initiallyLoaded;
    spr_init_player_raster_cache((&PlayerSpriteSets[playerSpriteSet])->cacheSize,
                  (&PlayerSpriteSets[playerSpriteSet])->rasterSize);
 
    for (i = 1; i <= SPR_Peach3; i++) {
        if ((loadedFlags >> i) & 1) {
            spr_load_player_sprite(i);
        }
    }
 
    for (i = 0; i < ARRAY_COUNT(CurPlayerAnimInfo); i++) {
        CurPlayerAnimInfo[i].componentList = NULL;
        CurPlayerAnimInfo[i].animID = -1;
    }
 
    for (i = 0; i < ARRAY_COUNT(NpcSpriteData); i++) {
        NpcSpriteData[i] = NULL;
        NpcSpriteInstanceCount[i] = 0;
    }
 
    for (i = 0; i < ARRAY_COUNT(SpriteInstances); i++) {
        SpriteInstances[i].spriteIndex = 0;
        SpriteInstances[i].componentList = NULL;
        SpriteInstances[i].spriteData = NULL;
        SpriteInstances[i].curAnimID = -1;
        SpriteInstances[i].notifyValue = 0;
    }
 
    spr_init_quad_cache();
}

Referenced by load_demo_battle(), load_engine_data(), load_map_by_IDs(), state_init_logos(), state_init_title_screen(), state_step_battle(), state_step_demo(), state_step_end_battle(), state_step_intro(), state_step_pause(), state_step_startup(), state_step_title_screen(), and state_step_unpause().

◆ spr_render_init()

void spr_render_init ( void )

Definition at line 815 of file sprite.c.

                           {
    spr_update_player_raster_cache();
    spr_clear_quad_cache();
}

Referenced by gfx_draw_frame().

◆ spr_update_player_raster_cache()

void spr_update_player_raster_cache ( void )

Definition at line 217 of file 101b90_len_8f0.c.

                                          {
    s32 i;
 
    func_8013A4D0();
 
    for (i = 0; i < PlayerRasterCacheSize; i++) {
        if (PlayerRasterCache[i].lazyDeleteTime != 0) {
            PlayerRasterCache[i].lazyDeleteTime--;
        }
    }
}

Referenced by spr_render_init().

◆ spr_update_player_sprite()

s32 spr_update_player_sprite	(	s32	arg0,
		s32	arg1,
		f32	timescale )

Definition at line 820 of file sprite.c.

                                                                              {
    SpriteAnimData* spriteData;
    SpriteComponent** compList;
    SpriteComponent* component;
    SpriteAnimComponent** animList;
    SpriteRasterCacheEntry** rasterList;
    s32 spriteID = SPR_UNPACK_SPR(animID);
    s32 instanceIdx = spriteInstanceID & 0xFF;
    CurPlayerSpriteIndex = spriteID - 1;
 
    if (CurPlayerAnimInfo[instanceIdx].componentList == NULL) {
        compList = spr_allocate_components(MaxPlayerSpriteComponents);
        CurPlayerAnimInfo[instanceIdx].componentList = compList;
        while (*compList != PTR_LIST_END) {
            component = *compList;
            component->imgfxIdx = imgfx_get_free_instances(1);
            compList++;
        }
    }
 
    spriteData = PlayerSprites[CurPlayerSpriteIndex];
    compList = CurPlayerAnimInfo[instanceIdx].componentList;
 
    if (spriteData == NULL) {
        return 0;
    }
 
    rasterList = spriteData->rastersOffset;
    animList = spriteData->animListStart[SPR_UNPACK_ANIM(animID)];
 
    spr_set_anim_timescale(timeScale);
    if ((spriteInstanceID & DRAW_SPRITE_OVERRIDE_ALPHA) ||
        (animID & ~SPRITE_ID_BACK_FACING) != (CurPlayerAnimInfo[instanceIdx].animID & ~SPRITE_ID_BACK_FACING))
    {
        spr_init_anim_state(compList, animList);
        CurPlayerAnimInfo[instanceIdx].notifyValue = 0;
    }
 
    CurPlayerAnimInfo[instanceIdx].animID = animID;
 
    if (!(spriteInstanceID & DRAW_SPRITE_OVERRIDE_YAW)) {
        CurPlayerAnimInfo[instanceIdx].notifyValue = spr_component_update(CurPlayerAnimInfo[instanceIdx].notifyValue,
                compList, animList, rasterList, 0);
    }
    return CurPlayerAnimInfo[instanceIdx].notifyValue;
}

Referenced by appendGfx_player_actor(), player_update_sprite(), set_actor_anim(), set_actor_anim_by_ref(), update_npcs(), and update_player_actor_shadow().

◆ spr_draw_player_sprite()

s32 spr_draw_player_sprite	(	s32	spriteInstanceID,
		s32	yaw,
		s32	arg2,
		PAL_PTR *	paletteList,
		Matrix4f	mtx )

Definition at line 867 of file sprite.c.

                                                                                                           {
    SpriteAnimData* spriteData;
    SpriteComponent** compList;
    SpriteAnimComponent** animList;
    SpriteRasterCacheEntry** rasterList;
    PAL_PTR* palettes;
    f32 zscale;
    u32 alpha;
    s32 spriteID;
    s32 instanceIdx = spriteInstanceID & 0xFF;
    s32 animID = CurPlayerAnimInfo[instanceIdx].animID;
 
    if (animID == ANIM_LIST_END) {
        return FALSE;
    }
 
    spriteID = SPR_UNPACK_SPR(animID);
    CurPlayerSpriteIndex = spriteID - 1;
 
    spriteData = PlayerSprites[CurPlayerSpriteIndex];
    if (spriteData == NULL) {
        return FALSE;
    }
 
    rasterList = spriteData->rastersOffset;
    palettes = spriteData->palettesOffset;
    animList = spriteData->animListStart[SPR_UNPACK_ANIM(animID)];
 
    if (animID & SPRITE_ID_BACK_FACING) {
        switch (spriteID) {
            case SPR_Mario1:
            case SPR_MarioW1:
            case SPR_Peach1:
                CurPlayerSpriteIndex++; // use the following sprite index if using back sprite
                rasterList = PlayerSprites[CurPlayerSpriteIndex]->rastersOffset;
                break;
        }
    }
 
    if (yaw > 90 && yaw <= 270 || yaw >= -270 && yaw < -90) {
        zscale = -1.5f;
    } else {
        zscale = 1.5f;
    }
 
    if (spriteInstanceID & DRAW_SPRITE_UPSIDE_DOWN) {
        zscale = -zscale;
    }
 
    if (!(spriteInstanceID & DRAW_SPRITE_OVERRIDE_YAW)) {
        yaw -= gCameras[gCurrentCamID].curYaw;
        if (yaw > 360) {
            yaw -= 360;
        }
        if (yaw < -360) {
            yaw += 360;
        }
    }
 
    SpriteCurBaseRot[0] = 0;
    SpriteCurBaseRot[1] = yaw;
    SpriteCurBaseRot[2] = 0;
 
    if (spriteInstanceID & DRAW_SPRITE_OVERRIDE_ALPHA) {
        alpha = alphaIn & 0xFF;
        if (alphaIn == 0) {
            return FALSE;
        }
    } else {
        alpha = 255;
    }
 
    compList = CurPlayerAnimInfo[instanceIdx].componentList;
    if (spriteInstanceID & DRAW_SPRITE_OVERRIDE_PALETTES) {
        palettes = paletteList;
    }
 
    while (*compList != PTR_LIST_END) {
        spr_draw_component(alpha | DRAW_SPRITE_USE_PLAYER_RASTERS, *compList++, *animList, rasterList, palettes, zscale, mtx);
        if (*animList != PTR_LIST_END) {
            animList++;
        }
    }
 
    return TRUE;
}

Referenced by appendGfx_npc(), appendGfx_npc_blur(), appendGfx_player(), appendGfx_player_spin(), func_unkA_draw_player(), func_unkB_draw_player(), npc_render_without_adjusted_palettes(), and render_with_adjusted_palettes().

◆ func_802DDEC4()

s32 func_802DDEC4 ( s32 arg0 )

Definition at line 954 of file sprite.c.

                                 {
    return CurPlayerAnimInfo[spriteIdx].notifyValue;
}

Referenced by appendGfx_npc().

◆ set_player_imgfx_comp()

void set_player_imgfx_comp	(	s32	spriteIdx,
		s32	compIdx,
		ImgFXType	imgfx,
		s32	imgfxArg1,
		s32	imgfxArg2,
		s32	imgfxArg3,
		s32	imgfxArg4,
		s32	flags )

Definition at line 958 of file sprite.c.

                                                                                                                                               {
    SpriteComponent* component;
    SpriteComponent** componentListIt;
    s32 i;
 
    if (CurPlayerAnimInfo[spriteIdx].componentList != NULL) {
        componentListIt = CurPlayerAnimInfo[spriteIdx].componentList;
        i = 0;
 
        while (*componentListIt != PTR_LIST_END) {
            component = *componentListIt;
            if (compIdx == -1 || i == compIdx) {
                imgfx_update(component->imgfxIdx & 0xFF, imgfx, imgfxArg1, imgfxArg2, imgfxArg3, imgfxArg4, flags);
                if (imgfx != IMGFX_CLEAR) {
                    component->imgfxIdx |= SPR_IMGFX_FLAG_10000000;
                } else {
                    component->imgfxIdx &= ~SPR_IMGFX_FLAG_ALL;
                }
            }
            componentListIt++;
            i++;
        }
    }
}

Referenced by appendGfx_player(), appendGfx_player_spin(), entity_CymbalPlant_idle(), render_player_model(), reset_outta_sight_alpha_on_menu_close(), and set_player_imgfx_all().

◆ set_player_imgfx_all()

void set_player_imgfx_all	(	s32	animID,
		ImgFXType	imgfxType,
		s32	arg2,
		s32	arg3,
		s32	arg4,
		s32	arg5,
		s32	arg6 )

Definition at line 984 of file sprite.c.

                                                                                                             {
    set_player_imgfx_comp(PLAYER_SPRITE_MAIN, -1, imgfxType, arg2, arg3, arg4, arg5, arg6);
}

Referenced by appendGfx_player(), appendGfx_player_spin(), entity_BlueWarpPipe_enter_pipe_init(), entity_BlueWarpPipe_enter_pipe_update(), entity_CymbalPlant_idle(), part_glow_off(), part_glow_on(), and update_riding_physics().

◆ spr_get_player_raster()

IMG_PTR spr_get_player_raster	(	s32	rasterIndex,
		s32	playerSpriteID )

Definition at line 184 of file 101b90_len_8f0.c.

                                                                   {
    PlayerSpriteCacheEntry* cacheEntry;
    u32 playerRasterInfo;
    s32 idx = -1;
    s32 i;
 
    for (i = 0; i < PlayerRasterCacheSize; i++) {
        if (PlayerRasterCache[i].lazyDeleteTime != 0) {
            if (PlayerRasterCache[i].rasterIndex == rasterIndex && PlayerRasterCache[i].spriteIndex == playerSpriteID) {
                PlayerRasterCache[i].lazyDeleteTime = 2;
                return PlayerRasterCache[i].raster;
            }
        } else if (idx == -1) {
            idx = i;
        }
    }
 
    if (idx == -1) {
        return NULL;
    }
 
    cacheEntry = &PlayerRasterCache[idx];
    cacheEntry->rasterIndex = rasterIndex;
    cacheEntry->spriteIndex = playerSpriteID;
    cacheEntry->lazyDeleteTime = 2;
 
    // each player raster load descriptor has image size (in bytes) and relative offset packed into one word
    // upper three nibbles give size / 16, lower 5 give offset
    playerRasterInfo = PlayerRasterLoadDesc[PlayerRasterLoadDescBeginSpriteIndex[playerSpriteID] + rasterIndex];
    nuPiReadRom(SpriteDataHeader[0] + (playerRasterInfo & 0xFFFFF), cacheEntry->raster, (playerRasterInfo >> 0x10) & 0xFFF0);
    return cacheEntry->raster;
}

Referenced by spr_draw_component(), and spr_get_player_raster_info().

◆ spr_get_player_raster_info()

void spr_get_player_raster_info	(	SpriteRasterInfo *	out,
		s32	playerSpriteID,
		s32	rasterIndex )

Definition at line 988 of file sprite.c.

                                                                                            {
    SpriteAnimData* sprite;
    SpriteRasterCacheEntry* cache;
    u16** paletteOffsetCopy;
 
    playerSpriteID--;
    sprite = PlayerSprites[playerSpriteID];
    if (sprite != NULL) {
        paletteOffsetCopy = sprite->palettesOffset;
        cache = sprite->rastersOffset[rasterIndex];
        out->width = cache->width;
        out->height = cache->height;
        out->defaultPal = paletteOffsetCopy[cache->palette];
        out->raster = spr_get_player_raster(rasterIndex, playerSpriteID);
    }
}

Referenced by gfx_build_knocked_down_player().

◆ spr_get_player_palettes()

PAL_PTR * spr_get_player_palettes ( s32 spriteIndex )

Definition at line 1005 of file sprite.c.

                                                  {
    SpriteAnimData* sprites = PlayerSprites[spriteIndex - 1];
 
    if (sprites == NULL) {
        return NULL;
    } else {
        return sprites->palettesOffset;
    }
}

Referenced by func_unkA_draw_player(), render_with_berserk_palettes(), render_with_fear_palettes(), render_with_pal_blending(), render_with_palset_blending(), render_with_paralyze_palettes(), render_with_player_debuff_palettes(), render_with_poison_palettes(), render_with_sleep_palettes(), render_with_static_palettes(), render_with_watt_attack_palettes(), and render_with_watt_idle_palettes().

◆ spr_load_npc_sprite()

s32 spr_load_npc_sprite	(	s32	animID,
		u32 *	extraAnimList )

Parameters

animID - Set MSB for tail allocation (i.e. 0x80XXYYZZ)

Definition at line 1015 of file sprite.c.

                                                        {
    SpriteAnimData* header;
    SpriteComponent** compList;
    s32 listIndex;
    s32 i;
 
    s32 spriteIndex = (animID >> 0x10) & 0x7FFF;
    s32 useTailAlloc = (u32)animID >> 0x1F;
 
    for (i = 0; i < ARRAY_COUNT(SpriteInstances); i++) {
        if (SpriteInstances[i].spriteIndex == 0) {
            break;
        }
    }
    if (MaxLoadedSpriteInstanceID < i) {
        MaxLoadedSpriteInstanceID = i;
    }
    if (i == ARRAY_COUNT(SpriteInstances)) {
        return -1;
    }
    listIndex = i;
    if (NpcSpriteData[spriteIndex] != NULL) {
        NpcSpriteInstanceCount[spriteIndex]++;
        header = NpcSpriteData[spriteIndex];
        SpriteInstances[listIndex].spriteData = header;
    } else {
        NpcSpriteInstanceCount[spriteIndex] = 1;
        header = spr_load_sprite(spriteIndex - 1, FALSE, useTailAlloc);
        SpriteInstances[listIndex].spriteData = header;
        NpcSpriteData[spriteIndex] = header;
        if (extraAnimList != NULL) {
            spr_load_npc_extra_anims(header, extraAnimList);
        }
    }
    compList = spr_allocate_components(header->maxComponents);
    SpriteInstances[listIndex].componentList = compList;
    while (*compList != PTR_LIST_END) {
        SpriteComponent* comp = *compList;
        comp->imgfxIdx = imgfx_get_free_instances(1);
        compList++;
    }
    SpriteInstances[listIndex].spriteIndex = spriteIndex;
    SpriteInstances[listIndex].curAnimID = -1;
    return listIndex;
}

Referenced by create_actor(), create_npc_impl(), load_partner_actor(), npc_reload_all(), pause_init(), pause_partners_init(), pause_spirits_init(), set_npc_sprite(), and update_npcs().

◆ spr_update_sprite()

s32 spr_update_sprite	(	s32	spriteInstanceID,
		s32	animID,
		f32	timeScale )

Definition at line 1061 of file sprite.c.

                                                                       {
    SpriteAnimData* spriteData;
    SpriteComponent** compList;
    SpriteAnimComponent** animList;
    SpriteRasterCacheEntry** rasterList;
 
    s32 palID;
    s32 i = spriteInstanceID & 0xFF;
    s32 animIndex = SPR_UNPACK_ANIM(animID);
 
    ASSERT_MSG(i <= MaxLoadedSpriteInstanceID, "Invalid sprite instance ID %x", spriteInstanceID);
 
    compList = SpriteInstances[i].componentList;
    spriteData = SpriteInstances[i].spriteData;
 
    rasterList = spriteData->rastersOffset;
    animList = spriteData->animListStart[animIndex];
 
    palID = SPR_UNPACK_PAL(animID);
    spr_set_anim_timescale(timeScale);
    if ((spriteInstanceID & DRAW_SPRITE_OVERRIDE_ALPHA) || (SPR_UNPACK_ANIM(SpriteInstances[i].curAnimID) != animIndex)) {
        ASSERT_MSG(animList != -1, "Anim %lx is not loaded", animID);
        spr_init_anim_state(compList, animList);
        SpriteInstances[i].curAnimID = (palID << 8) | animIndex;
        SpriteInstances[i].notifyValue = 0;
    }
    if (!(spriteInstanceID & DRAW_SPRITE_OVERRIDE_YAW)) {
        SpriteInstances[i].notifyValue = spr_component_update(SpriteInstances[i].notifyValue,
            compList, animList, rasterList, palID);
    }
    return SpriteInstances[i].notifyValue;
}

Referenced by appendGfx_npc_actor(), pause_handle_input(), pause_partners_update(), pause_spirits_update(), set_actor_anim(), set_actor_anim_by_ref(), set_npc_sprite(), update_nonplayer_actor_shadow(), and update_npcs().

◆ spr_draw_npc_sprite()

s32 spr_draw_npc_sprite	(	s32	spriteInstanceID,
		s32	yaw,
		s32	alphaIn,
		PAL_PTR *	paletteList,
		Matrix4f	mtx )

Definition at line 1094 of file sprite.c.

                                                                                                        {
    SpriteAnimData* spriteData;
    SpriteAnimComponent** animComps;
    SpriteComponent** components;
    SpriteRasterCacheEntry** rasters;
    PAL_PTR* palettes;
    f32 zscale;
    u32 alpha;
    s32 instanceIdx = spriteInstanceID & 0xFF;
    s32 animID = SpriteInstances[instanceIdx].curAnimID;
 
    if (animID == ANIM_LIST_END) {
        return FALSE;
    }
 
    spriteData = SpriteInstances[instanceIdx].spriteData;
    rasters = spriteData->rastersOffset;
    palettes = spriteData->palettesOffset;
    animComps = spriteData->animListStart[SPR_UNPACK_ANIM(animID)];
 
    SpriteCurBaseRot[0] = 0;
    SpriteCurBaseRot[1] = yaw;
    SpriteCurBaseRot[2] = 0;
 
    if (!(spriteInstanceID & DRAW_SPRITE_OVERRIDE_YAW)) {
        yaw += gCameras[gCurrentCamID].curYaw;
        if (yaw > 360) {
            yaw -= 360;
        }
        if (yaw < -360) {
            yaw += 360;
        }
    }
 
    if (yaw > 90 && yaw <= 270 || yaw >= -270 && yaw < -90) {
        zscale = -1.5f;
    } else {
        zscale = 1.5f;
    }
 
    if (spriteInstanceID & DRAW_SPRITE_OVERRIDE_ALPHA) {
        alpha = alphaIn & 0xFF;
        if (alphaIn == 0) {
            return FALSE;
        }
    } else {
        alpha = 255;
    }
 
    components = SpriteInstances[instanceIdx].componentList;
    if (spriteInstanceID & DRAW_SPRITE_OVERRIDE_PALETTES) {
        palettes = paletteList;
    }
 
    while (*components != PTR_LIST_END) {
        spr_draw_component(alpha, *components++, *animComps, rasters, palettes, zscale, mtx);
        if (*animComps != PTR_LIST_END) {
            animComps++;
        }
    }
 
    return TRUE;
}

Referenced by appendGfx_nonplayer_actor_blur(), appendGfx_npc(), appendGfx_npc_blur(), func_unkA_draw_npc(), func_unkB_draw_npc(), npc_render_with_double_pal_blending(), npc_render_with_single_pal_blending(), npc_render_with_watt_idle_palettes(), npc_render_without_adjusted_palettes(), pause_partners_draw_contents(), pause_spirits_draw_contents(), pause_tutorial_draw_contents(), and render_with_adjusted_palettes().

◆ spr_get_notify_value()

s32 spr_get_notify_value ( s32 spriteInstanceID )

Definition at line 1158 of file sprite.c.

                                               {
    return SpriteInstances[spriteInstanceID].notifyValue;
}

Referenced by appendGfx_npc(), appendGfx_npc_actor(), set_actor_anim(), set_actor_anim_by_ref(), and update_nonplayer_actor_shadow().

◆ spr_free_sprite()

s32 spr_free_sprite ( s32 spriteInstanceID )

Definition at line 1162 of file sprite.c.

                                          {
    SpriteInstance* sprite = &SpriteInstances[spriteInstanceID];
    SpriteAnimData* spriteData;
    SpriteComponent** compList;
    s32 spriteIndex = sprite->spriteIndex;
 
    if (spriteIndex == 0 || spriteIndex >= ARRAY_COUNT(NpcSpriteData)) {
        return spriteInstanceID;
    }
 
    NpcSpriteInstanceCount[spriteIndex]--;
    spriteData = sprite->spriteData;
 
    compList = sprite->componentList;
    while (*compList != PTR_LIST_END) {
        SpriteComponent* comp = *compList;
        imgfx_release_instance(comp->imgfxIdx & 0xFF);
        compList++;
    }
 
    compList = SpriteInstances[spriteInstanceID].componentList;
 
    if (NpcSpriteInstanceCount[spriteIndex] == 0) {
        NpcSpriteData[spriteIndex] = NULL;
        _heap_free(&heap_spriteHead, spriteData);
    }
 
    if (SpriteUseGeneralHeap) {
        _heap_free(&heap_generalHead, compList);
    } else {
        _heap_free(&heap_spriteHead, compList);
    }
 
    SpriteInstances[spriteInstanceID].spriteIndex = 0;
    SpriteInstances[spriteInstanceID].componentList = NULL;
    SpriteInstances[spriteInstanceID].spriteData = NULL;
    SpriteInstances[spriteInstanceID].curAnimID = -1;
    return 0;
}

Referenced by btl_delete_actor(), free_npc(), free_npc_by_index(), pause_cleanup(), pause_partners_cleanup(), pause_spirits_cleanup(), and set_npc_sprite().

◆ get_npc_comp_imgfx_idx()

s32 get_npc_comp_imgfx_idx	(	s32	spriteIdx,
		s32	compIdx )

Definition at line 1202 of file sprite.c.

                                                       {
    SpriteComponent** componentList = SpriteInstances[spriteIdx].componentList;
 
    if (componentList == NULL) {
        return -1;
    } else {
        return componentList[compIdx]->imgfxIdx & 0xFF;
    }
}

◆ set_npc_imgfx_comp()

void set_npc_imgfx_comp	(	s32	spriteIdx,
		s32	compIdx,
		ImgFXType	imgfx,
		s32	imgfxArg1,
		s32	imgfxArg2,
		s32	imgfxArg3,
		s32	imgfxArg4,
		s32	imgfxArg5 )

Definition at line 1212 of file sprite.c.

                                                                                                                                                {
    SpriteInstance* sprite = &SpriteInstances[spriteIdx];
    SpriteComponent** componentList;
    s32 i;
 
    if (sprite->componentList != NULL) {
        componentList = sprite->componentList;
        i = 0;
 
        while (*componentList != PTR_LIST_END) {
            SpriteComponent* comp = *componentList;
 
            if (compIdx == -1 || i == compIdx) {
                imgfx_update((u8)comp->imgfxIdx, imgfx, imgfxArg1, imgfxArg2, imgfxArg3, imgfxArg4, imgfxArg5);
                if (imgfx != IMGFX_CLEAR) {
                    comp->imgfxIdx |= SPR_IMGFX_FLAG_10000000;
                } else {
                    comp->imgfxIdx &= ~SPR_IMGFX_FLAG_ALL;
                }
            }
            componentList++;
            i++;
        }
    }
}

Referenced by set_npc_imgfx_all().

◆ set_npc_imgfx_all()

void set_npc_imgfx_all	(	s32	arg0,
		ImgFXType	arg1,
		s32	arg2,
		s32	arg3,
		s32	arg4,
		s32	arg5,
		s32	arg6 )

Definition at line 1238 of file sprite.c.

                                                                                                                                      {
    set_npc_imgfx_comp(spriteIdx, -1, imgfxType, imgfxArg1, imgfxArg2, imgfxArg3, imgfxArg4, imgfxArg5);
}

Referenced by appendGfx_npc_blur(), btl_delete_actor(), MagikoopaAI_11(), npc_imgfx_update(), npc_update_decoration_charged(), part_glow_off(), part_glow_on(), pause_partners_draw_contents(), pause_spirits_draw_contents(), pause_tutorial_draw_contents(), SentinelAI_Descend(), and SentinelAI_LosePlayerInit().

◆ spr_get_comp_position()

s32 spr_get_comp_position	(	s32	spriteIdx,
		s32	compListIdx,
		s32 *	outX,
		s32 *	outY,
		s32 *	outZ )

Definition at line 1242 of file sprite.c.

                                                                                           {
    SpriteInstance* sprite = &SpriteInstances[spriteIdx];
    SpriteAnimComponent** animComps;
    SpriteAnimComponent* animComp;
    SpriteComponent** compList;
    SpriteComponent* comp;
    u8 animID;
    s32 i;
 
    if (sprite->componentList == NULL) {
        return -1;
    }
 
    animID = sprite->curAnimID;
    if (animID != 255) {
        animComps = sprite->spriteData->animListStart[animID];
        compList = sprite->componentList;
        i = 0;
        while (*compList != PTR_LIST_END) {
            if (i == compListIdx) {
                animComp = *animComps;
                comp = *compList;
                *outX = comp->compPos.x + animComp->compOffset.x;
                *outY = comp->compPos.y + animComp->compOffset.y;
                *outZ = comp->compPos.z + animComp->compOffset.z;
                return 0;
            }
            i++;
            compList++;
            if (*animComps != PTR_LIST_END) {
                animComps++;
            }
        }
    }
    return -1;
}

◆ spr_get_npc_raster_info()

s32 spr_get_npc_raster_info	(	SpriteRasterInfo *	out,
		s32	npcSpriteID,
		s32	rasterIndex )

Definition at line 1279 of file sprite.c.

                                                                                     {
    SpriteAnimData* sprite = NpcSpriteData[npcSpriteID];
    SpriteRasterCacheEntry* cache;
    PAL_PTR* paletteOffsetCopy;
 
    if (sprite != NULL) {
        paletteOffsetCopy = sprite->palettesOffset;
        cache = sprite->rastersOffset[rasterIndex];
        out->raster = cache->image;
        out->width = cache->width;
        out->height = cache->height;
        out->defaultPal = paletteOffsetCopy[cache->palette];
        return TRUE;
    }
    return FALSE;
}

Referenced by appendGfx_message().

◆ spr_get_npc_palettes()

PAL_PTR * spr_get_npc_palettes ( s32 npcSpriteID )

Definition at line 1296 of file sprite.c.

                                               {
    SpriteAnimData* sprite = NpcSpriteData[npcSpriteID];
 
    if (sprite != NULL) {
        return sprite->palettesOffset;
    } else {
        return NULL;
    }
}

◆ spr_get_npc_color_variations()

s32 spr_get_npc_color_variations ( s32 npcSpriteID )

Definition at line 1306 of file sprite.c.

                                                  {
    SpriteAnimData* sprite = NpcSpriteData[npcSpriteID];
 
    if (sprite != NULL) {
        return sprite->colorVariations;
    } else {
        return -1;
    }
}

Referenced by npc_reload_all(), npc_render_with_watt_idle_palettes(), render_with_palset_blending(), render_with_player_debuff_palettes(), render_with_poison_palettes(), render_with_static_palettes(), render_with_watt_attack_palettes(), and render_with_watt_idle_palettes().

◆ create_shading_palette()

void create_shading_palette	(	Matrix4f	mtx,
		s32	uls,
		s32	ult,
		s32	lrs,
		s32	lrt,
		s32	alpha,
		s32	otherModeLBits )

Definition at line 66 of file sprite_shading.c.

                                                                                                             {
    Camera* camera = &gCameras[gCurrentCameraID];
    SpriteShadingLightSource* lightSource;
    f32 shadowDirX, shadowDirY, shadowDirZ;
    f32 posX, posY, posZ;
    f32 facingDir;
    f32 Mxz, Myz, Mzz;
    f32 shadowColorR, shadowColorG, shadowColorB;
    f32 commonColorR, commonColorG, commonColorB;
    f32 backColorR, backColorG, backColorB;
    f32 frontColorR, frontColorG, frontColorB;
    f32 shadowIntensity;
    f32 lightIntensity;
    f32 intensityScale;
    f32 temp_f10;
    f32 temp_f16;
    f32 distSq;
    f32 dx, dy, dz;
    f32 dist;
    f32 invDist;
    f32 qx, qy, qz;
    f32 wx, wy, wz;
    f32 ex, ey, ez;
    f32 Pxz, Pzz;
    s32 i;
 
    shadowDirX = 0.0f;
    shadowDirY = 0.0f;
    shadowDirZ = 0.0f;
 
    posX = mtx[3][0];
    posY = mtx[3][1];
    posZ = mtx[3][2];
 
    Mxz = mtx[0][2];
    Myz = mtx[1][2];
    Mzz = mtx[2][2];
 
    commonColorR = 0.0f;
    commonColorG = 0.0f;
    commonColorB = 0.0f;
 
    backColorR = 0.0f;
    backColorG = 0.0f;
    backColorB = 0.0f;
 
    frontColorR = 0.0f;
    frontColorG = 0.0f;
    frontColorB = 0.0f;
 
    shadowColorR = gSpriteShadingProfile->ambientColor.r;
    shadowColorG = gSpriteShadingProfile->ambientColor.g;
    shadowColorB = gSpriteShadingProfile->ambientColor.b;
 
    Pxz = camera->mtxPerspective[0][2];
    Pzz = camera->mtxPerspective[2][2];
 
    if ((-Mxz * Pxz + Mzz * Pzz) < 0.0f) {
        facingDir = 1.0f;
    } else {
        facingDir = -1.0f;
    }
 
    for (i = 0; i < ARRAY_COUNT(gSpriteShadingProfile->sources); i++) {
        lightSource = &gSpriteShadingProfile->sources[i];
        if (lightSource->flags & LIGHT_SOURCE_ENABLED) {
            dx = posX - lightSource->pos.x;
            dy = posY - lightSource->pos.y;
            dz = posZ - lightSource->pos.z;
 
            distSq = SQ(dx) + SQ(dy) + SQ(dz);
 
            if (distSq != 0.0f) {
                dist = sqrtf(distSq);
                invDist = 1.0f / dist;
            } else {
                dist = 0.0f;
                invDist = 0.0f;
            }
 
            // normalize dx/dy/dz
            // they now form a normal vector pointing from light source to sprite
            dx *= invDist;
            dy *= invDist;
            dz *= invDist;
 
            // apply falloff from light source
            if (lightSource->flags & LIGHT_SOURCE_LINEAR_FALLOFF) {
                if ((dist == 0.0f) && (lightSource->falloff == 0.0f)) {
                    intensityScale = 1.0f;
                } else {
                    intensityScale = 1.0f / (dist * lightSource->falloff);
                    dx *= intensityScale;
                    dy *= intensityScale;
                    dz *= intensityScale;
                }
            } else if (lightSource->flags & LIGHT_SOURCE_QUADRATIC_FALLOFF) {
                if ((distSq == 0.0f) && (lightSource->falloff == 0.0f)) {
                    intensityScale = 1.0f;
                } else {
                    intensityScale = 1.0f / (distSq * lightSource->falloff);
                    dx *= intensityScale;
                    dy *= intensityScale;
                    dz *= intensityScale;
                }
            } else {
                intensityScale = 1.0f;
            }
 
            if (intensityScale > 1.0f) {
                intensityScale = 1.0f;
            }
 
            shadowDirX += dx;
            shadowDirY += dy;
            shadowDirZ += dz;
 
            if (facingDir < 0.0f) {
                ex = Mxz;
                ey = Myz;
                ez = -Mzz;
            } else {
                ex = -Mxz;
                ey = Myz;
                ez = Mzz;
            }
            temp_f10 = ex * dx + ey * dy + ez * dz;
 
            if (facingDir < 0.0f) {
                wx = Mzz;
                wy = Myz;
                wz = Mxz;
            } else {
                wx = -Mzz;
                wy = Myz;
                wz = -Mxz;
            }
            temp_f16 = wx * dx + wy * dy + wz * dz;
 
            shadowIntensity = intensityScale * fabsf(temp_f10);
            lightIntensity  = intensityScale * fabsf(temp_f16);
            if (temp_f10 > 0.0f) {
                commonColorR += lightSource->rgb.r * shadowIntensity;
                commonColorG += lightSource->rgb.g * shadowIntensity;
                commonColorB += lightSource->rgb.b * shadowIntensity;
                if (temp_f16 > 0.0f) {
                    backColorR += lightSource->rgb.r * lightIntensity;
                    backColorG += lightSource->rgb.g * lightIntensity;
                    backColorB += lightSource->rgb.b * lightIntensity;
                } else {
                    frontColorR += lightSource->rgb.r * lightIntensity;
                    frontColorG += lightSource->rgb.g * lightIntensity;
                    frontColorB += lightSource->rgb.b * lightIntensity;
                }
            } else {
                shadowColorR += lightSource->rgb.r * shadowIntensity;
                shadowColorG += lightSource->rgb.g * shadowIntensity;
                shadowColorB += lightSource->rgb.b * shadowIntensity;
                if (temp_f16 > 0.0f) {
                    backColorR += lightSource->rgb.r * lightIntensity;
                    backColorG += lightSource->rgb.g * lightIntensity;
                    backColorB += lightSource->rgb.b * lightIntensity;
                } else {
                    frontColorR += lightSource->rgb.r * lightIntensity;
                    frontColorG += lightSource->rgb.g * lightIntensity;
                    frontColorB += lightSource->rgb.b * lightIntensity;
                }
            }
        }
    }
 
    if (facingDir < 0.0f) {
        qx = Mzz;
        qy = Myz;
        qz = Mxz;
    } else {
        qx = -Mzz;
        qy = Myz;
        qz = -Mxz;
    }
 
    if (qx * shadowDirX + qy * shadowDirY + qz * shadowDirZ > 0.0f) {
        appendGfx_shading_palette(
            mtx,
            uls, ult, lrs, lrt,
            alpha,
            shadowDirX, shadowDirY, shadowDirZ,
            shadowColorR, shadowColorG, shadowColorB,
            gSpriteShadingProfile->ambientColor.r + commonColorR + backColorR,
            gSpriteShadingProfile->ambientColor.g + commonColorG + backColorG,
            gSpriteShadingProfile->ambientColor.b + commonColorB + backColorB,
            gSpriteShadingProfile->ambientPower,
            otherModeLBits
        );
    } else {
        appendGfx_shading_palette(
            mtx,
            uls, ult, lrs, lrt,
            alpha,
            shadowDirX, shadowDirY, shadowDirZ,
            shadowColorR, shadowColorG, shadowColorB,
            gSpriteShadingProfile->ambientColor.r + commonColorR + frontColorR,
            gSpriteShadingProfile->ambientColor.g + commonColorG + frontColorG,
            gSpriteShadingProfile->ambientColor.b + commonColorB + frontColorB,
            gSpriteShadingProfile->ambientPower,
            otherModeLBits
        );
    }
}

Referenced by imgfx_appendGfx_mesh_anim(), imgfx_appendGfx_mesh_basic(), imgfx_appendGfx_mesh_grid(), and spr_appendGfx_component_flat().

◆ func_801491E4()

void func_801491E4	(	Matrix4f	mtx,
		s32	arg1,
		s32	arg2,
		s32	arg3,
		s32	arg4,
		s32	alpha )

Definition at line 415 of file sprite_shading.c.

                                                                                    {
    gDPSetPrimColor(gMainGfxPos++, 0, 0, 0, 0, 0, alpha);
 
    if (alpha == 255) {
        gDPSetCombineMode(gMainGfxPos++, PM_CC_WINDOW_5, G_CC_PASS2);
    } else {
        gDPSetCombineMode(gMainGfxPos++, PM_CC_02, G_CC_PASS2);
    }
}

Referenced by appendGfx_item_entity(), and render_item_entities().

◆ spr_load_sprite()

SpriteAnimData * spr_load_sprite	(	s32	idx,
		s32	arg1,
		s32	arg2 )

Definition at line 69 of file 101b90_len_8f0.c.

                                                                               {
    SpriteAnimData* animData;
    s32 base;
    s32 i;
    s32 compressedSize;
    s32* ptr1;
    IMG_PTR image;
    s32 count;
    s32** data;
    s32** palettes;
 
    if (isPlayerSprite) {
        base = SpriteDataHeader[1];
    } else {
        base = SpriteDataHeader[2];
    }
 
    // read current and next sprite offsets, so we can find the difference
    nuPiReadRom(base + idx * 4, &spr_asset_entry, sizeof(spr_asset_entry));
 
    compressedSize = ALIGN8(spr_asset_entry[1] - spr_asset_entry[0]);
    data = general_heap_malloc(compressedSize);
    nuPiReadRom(base + spr_asset_entry[0], data, compressedSize);
 
    ptr1 = (s32*)data;
    // skip 4 bytes: 'YAY0' signature
    ptr1++;
 
    if (useTailAlloc) {
        animData = _heap_malloc_tail(&heap_spriteHead, *ptr1);
    } else {
        animData = _heap_malloc(&heap_spriteHead, *ptr1);
    }
    ASSERT_MSG(animData, "out of sprite memory");
    decode_yay0(data, animData);
    general_heap_free(data);
 
    // swizzle raster array
    data = (s32**)animData->rastersOffset;
    data = SPR_SWIZZLE(ALIGN4(animData), data);
    animData->rastersOffset = (SpriteRasterCacheEntry**)data;
 
    while (TRUE) {
        ptr1 = *data;
        if (ptr1 == PTR_LIST_END) {
            break;
        }
        // swizzle each raster cache entry
        ptr1 = SPR_SWIZZLE(ALIGN4(animData), ptr1);
        *data++ = ptr1;
        image = ((SpriteRasterCacheEntry*)ptr1)->image;
 
        if (!isPlayerSprite) {
            // swizzle image pointer in the cache entry
            image = SPR_SWIZZLE(ALIGN4(animData), image);
            *ptr1 = (s32)image;
        }
    }
 
    if (isPlayerSprite) {
        PlayerRasterLoadDescBeginSpriteIndex[idx] = PlayerRasterLoadDescNumLoaded;
        count = PlayerSpriteRasterSets[idx + 1] - PlayerSpriteRasterSets[idx];
        // load a range of raster loading desciptors to a buffer and copy contents into PlayerRasterLoadDesc
        nuPiReadRom(SpriteDataHeader[0] + PlayerRasterHeader.loadDescriptors + sizeof(u32) * PlayerSpriteRasterSets[idx],
            PlayerRasterLoadDescBuffer, sizeof(PlayerRasterLoadDescBuffer));
        for (i = 0; i < count; i++) {
            PlayerRasterLoadDesc[PlayerRasterLoadDescNumLoaded++] = PlayerRasterLoadDescBuffer[i];
        }
    }
 
    // swizzle palettes array
    palettes = SPR_SWIZZLE(ALIGN4(animData), animData->palettesOffset);
    animData->palettesOffset = (PAL_PTR*)palettes;
    while (TRUE) {
        ptr1 = *palettes;
        if (ptr1 == PTR_LIST_END) {
            break;
        }
        // swizzle each palette pointer
        ptr1 = SPR_SWIZZLE(ALIGN4(animData), ptr1);
        *palettes++ = ptr1;
    }
 
    spr_swizzle_anim_offsets(0, 0, animData);
    return animData;
}

Referenced by spr_load_npc_sprite(), and spr_load_player_sprite().

Data Structures

Macros

Enumerations

Functions

Data Structure Documentation

◆ SpriteComponent

◆ PlayerCurrentAnimInfo

◆ SpriteAnimComponent

◆ SpriteRasterCacheEntry

◆ SpriteAnimData

◆ SpriteInstance

◆ PlayerRastersHeader

◆ PlayerSpriteSet

◆ PlayerSpriteCacheEntry

◆ Quad

Macro Definition Documentation

◆ SPR_PLAYER_COLOR_VARIATIONS

◆ SPR_PEACH_BTL_PAL_STRIDE

◆ SPR_UNPACK_SPR

◆ SPR_UNPACK_PAL

◆ SPR_UNPACK_ANIM

Enumeration Type Documentation

◆ SpriteIDFields

◆ DrawSpriteOptions

◆ anonymous enum

◆ anonymous enum

Function Documentation

◆ imgfx_init()

◆ spr_init_sprites()

◆ spr_render_init()

◆ spr_update_player_raster_cache()

◆ spr_update_player_sprite()

◆ spr_draw_player_sprite()

◆ func_802DDEC4()

◆ set_player_imgfx_comp()

◆ set_player_imgfx_all()

◆ spr_get_player_raster()

◆ spr_get_player_raster_info()

◆ spr_get_player_palettes()

◆ spr_load_npc_sprite()

◆ spr_update_sprite()

◆ spr_draw_npc_sprite()

◆ spr_get_notify_value()

◆ spr_free_sprite()

◆ get_npc_comp_imgfx_idx()

◆ set_npc_imgfx_comp()

◆ set_npc_imgfx_all()

◆ spr_get_comp_position()

◆ spr_get_npc_raster_info()

◆ spr_get_npc_palettes()

◆ spr_get_npc_color_variations()

◆ create_shading_palette()

◆ func_801491E4()

◆ spr_load_sprite()