sprite.c File Reference

Go to the source code of this file.

Macros
#define	MAX_SPRITE_ID   0xFF
#define	MARIO_SPRITE_COMMON_BITS
#define	MARIO_SPRITE_WORLD_BITS
#define	MARIO_SPRITE_BATTLE_BITS
#define	PEACH_SPRITE_BITS

Functions
SpriteComponent **	spr_allocate_components (s32)
void	spr_load_npc_extra_anims (SpriteAnimData *, u32 *)
void	spr_init_player_raster_cache (s32 cacheSize, s32 maxRasterSize)
void	spr_init_quad_cache (void)
Quad *	spr_get_cached_quad (s32 quadIndex)
void	spr_make_quad_for_size (Quad *quad, s32 width, s32 height)
Quad *	spr_get_quad_for_size (s32 *quadIndex, s32 width, s32 height)
void	spr_clear_quad_cache (void)
void	spr_appendGfx_component_flat (Quad *vertices, IMG_PTR raster, PAL_PTR palette, s32 width, s32 height, f32 arg5, Matrix4f mtx, s32 alpha)
void	spr_appendGfx_component (SpriteRasterCacheEntry *cache, f32 dx, f32 dy, f32 dz, f32 rotX, f32 rotY, f32 rotZ, f32 scaleX, f32 scaleY, f32 scaleZ, s32 opacity, PAL_PTR palette, Matrix4f mtx)
void	spr_transform_point (s32 rotX, s32 rotY, s32 rotZ, f32 inX, f32 inY, f32 inZ, f32 *outX, f32 *outY, f32 *outZ)
void	spr_draw_component (s32 drawOpts, SpriteComponent *component, SpriteAnimComponent *anim, SpriteRasterCacheEntry **cache, PAL_PTR *palettes, f32 zscale, Matrix4f mtx)
s32	spr_unpack_signed_12bit (u16 val)
s32	spr_unpack_signed_16bit (u16 val)
void	spr_component_update_commands (SpriteComponent *comp, SpriteAnimComponent *anim)
void	spr_component_update_finish (SpriteComponent *comp, SpriteComponent **compList, SpriteRasterCacheEntry **rasterCacheEntry, s32 overridePalette)
s32	spr_component_update (s32 curNotifyValue, SpriteComponent **compList, SpriteAnimComponent **animList, SpriteRasterCacheEntry **rasterCache, s32 overridePalette)
void	spr_init_component_anim_state (SpriteComponent *comp, SpriteAnimComponent *anim)
void	spr_init_anim_state (SpriteComponent **compList, SpriteAnimComponent **animList)
void	spr_set_anim_timescale (f32 timescale)
void	spr_load_player_sprite (s32 spriteIndex)
void	spr_init_sprites (s32 playerSpriteSet)
void	spr_render_init (void)
s32	spr_update_player_sprite (s32 spriteInstanceID, s32 animID, f32 timeScale)
s32	spr_draw_player_sprite (s32 spriteInstanceID, s32 yaw, s32 alphaIn, PAL_PTR *paletteList, Matrix4f mtx)
s32	func_802DDEC4 (s32 spriteIdx)
void	set_player_imgfx_comp (s32 spriteIdx, s32 compIdx, ImgFXType imgfx, s32 imgfxArg1, s32 imgfxArg2, s32 imgfxArg3, s32 imgfxArg4, s32 flags)
void	set_player_imgfx_all (s32 animID, ImgFXType imgfxType, s32 arg2, s32 arg3, s32 arg4, s32 arg5, s32 arg6)
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 spriteIdx, s32 compIdx)
void	set_npc_imgfx_comp (s32 spriteIdx, s32 compIdx, ImgFXType imgfx, s32 imgfxArg1, s32 imgfxArg2, s32 imgfxArg3, s32 imgfxArg4, s32 imgfxArg5)
void	set_npc_imgfx_all (s32 spriteIdx, ImgFXType imgfxType, s32 imgfxArg1, s32 imgfxArg2, s32 imgfxArg3, s32 imgfxArg4, s32 imgfxArg5)
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)

Variables
HeapNode	heap_generalHead
HeapNode	heap_spriteHead
BSS b32	SpriteUseGeneralHeap
BSS s32	MaxLoadedSpriteInstanceID
BSS s32	CurSpriteImgFX
BSS SpriteAnimData *	PlayerSprites [13]
BSS s32	CurPlayerSpriteIndex
BSS s32	MaxPlayerSpriteComponents
BSS PlayerCurrentAnimInfo	CurPlayerAnimInfo [3]
BSS SpriteAnimData *	NpcSpriteData [0xFF]
BSS u8	NpcSpriteInstanceCount [0xFF]
BSS SpriteInstance	SpriteInstances [51]
BSS Quad *	SpriteQuadCache
BSS s32	SpriteQuadCacheInfo [22]
BSS s32	SpriteCurBaseRot [3]
BSS s32	SpriteUpdateNotifyValue
Quad	SpriteQuadTemplate
Vp	SpritePauseVp
Vp	SpritePauseVpAlt
Gfx	OpaqueSpriteGfx []
Gfx	TranslucentSpriteGfx []
Gfx	OpaqueShadedSpriteGfx []
Gfx	TranslucentShadedSpriteGfx []
f32	SpriteAnimUpdateTimescale = 1.0f
PlayerSpriteSet	PlayerSpriteSets []

Macro Definition Documentation

MAX_SPRITE_ID

#define MAX_SPRITE_ID   0xFF

Definition at line 5 of file sprite.c.

MARIO_SPRITE_COMMON_BITS

#define MARIO_SPRITE_COMMON_BITS

Value:

      1 << SPR_Mario1 \
    | 1 << SPR_Mario1_Back \

Definition at line 90 of file sprite.c.

#define MARIO_SPRITE_COMMON_BITS \
      1 << SPR_Mario1 \
    | 1 << SPR_Mario1_Back \
 

MARIO_SPRITE_WORLD_BITS

#define MARIO_SPRITE_WORLD_BITS

Value:

    MARIO_SPRITE_COMMON_BITS \
    | 1 << SPR_MarioW1 \
    | 1 << SPR_MarioW1_Back \
    | 1 << SPR_MarioW2 \
    | 1 << SPR_MarioW3

Definition at line 94 of file sprite.c.

#define MARIO_SPRITE_WORLD_BITS \
    MARIO_SPRITE_COMMON_BITS \
    | 1 << SPR_MarioW1 \
    | 1 << SPR_MarioW1_Back \
    | 1 << SPR_MarioW2 \
    | 1 << SPR_MarioW3

MARIO_SPRITE_BATTLE_BITS

#define MARIO_SPRITE_BATTLE_BITS

Value:

    MARIO_SPRITE_COMMON_BITS \
    | 1 << SPR_MarioB1 \
    | 1 << SPR_MarioB2 \
    | 1 << SPR_MarioB3

Definition at line 101 of file sprite.c.

#define MARIO_SPRITE_BATTLE_BITS \
    MARIO_SPRITE_COMMON_BITS \
    | 1 << SPR_MarioB1 \
    | 1 << SPR_MarioB2 \
    | 1 << SPR_MarioB3

PEACH_SPRITE_BITS

#define PEACH_SPRITE_BITS

Value:

      1 << SPR_Peach1 \
    | 1 << SPR_Peach1_Back \
    | 1 << SPR_Peach2 \
    | 1 << SPR_Peach3 \

Definition at line 107 of file sprite.c.

#define PEACH_SPRITE_BITS \
      1 << SPR_Peach1 \
    | 1 << SPR_Peach1_Back \
    | 1 << SPR_Peach2 \
    | 1 << SPR_Peach3 \
 

Function Documentation

spr_allocate_components()

SpriteComponent ** spr_allocate_components

(

s32

count

)

Definition at line 353 of file 101b90_len_8f0.c.

                                                     {
    s32 listSize;
    SpriteComponent** listStart;
    SpriteComponent* component;
    SpriteComponent** listPos;
    u32 totalSize;
    s32 i;
 
    // data will contain a -1 terminated list, followed by the SpriteComponents
    // corresponding to that list
    listSize = (count + 1) * 4;
    totalSize = (count * sizeof(SpriteComponent)) + listSize;
 
    if (SpriteUseGeneralHeap) {
        listStart = _heap_malloc(&heap_generalHead, totalSize);
        listPos = listStart;
        component = (SpriteComponent*) listPos;
    } else {
        listStart = _heap_malloc(&heap_spriteHead, totalSize);
        listPos = listStart;
        component = (SpriteComponent*) listPos;
    }
 
    component = (SpriteComponent*)((s32)(component) + (listSize / 4) * 4);
 
    // fill list values
    for (i = 0; i < count; i++) {
        *listPos++ = component;
        component++;
    }
    *listPos = PTR_LIST_END;
 
    return listStart;
}

Referenced by spr_load_npc_sprite(), and spr_update_player_sprite().

spr_load_npc_extra_anims()

void spr_load_npc_extra_anims	(	SpriteAnimData *	header,
		u32 *	extraAnimList )

Definition at line 229 of file 101b90_len_8f0.c.

                                                                          {
    u8* src;
    s32 imgID;
    s32 rasterSize;
    s32 remaining;
    u16 animCmd;
    u16* cmdList;
    u32 extraAnimID;
    u8* dataPos;
    void* copyEnd;
    SpriteAnimComponent* comp;
    SpriteAnimComponent** compList;
    void* writePos;
    SpriteRasterCacheEntry** rasterList;
    SpriteRasterCacheEntry* raster;
    u16** oldPalList;
    u16* palette;
    // one extra required for 'done' sentinel
    s32 sawRaster[100 + 1];
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(sawRaster) - 1; i++) {
        sawRaster[i] = FALSE;
    }
 
    while ((extraAnimID = *extraAnimList++) != -1) {
        compList = header->animListStart[extraAnimID & 0xFF];
        while ((comp = *compList++) != PTR_LIST_END) {
            cmdList = comp->cmdList;
            remaining = (s16) comp->cmdListSize / 2;
            while (remaining > 0) {
                animCmd = *cmdList++;
                remaining--;
                switch (animCmd & 0xF000) {
                    case 0x1000:
                        i = animCmd; // required to match
                        imgID = i & 0xFF;
                        if (imgID < ARRAY_COUNT(sawRaster) - 1) {
                            sawRaster[imgID] = TRUE;
                        }
                        break;
                    case 0x3000:
                        cmdList++;
                        remaining--;
                        // fallthrough
                    case 0x4000:
                        cmdList++;
                        remaining--;
                        // fallthrough
                    case 0x7000:
                    case 0x5000:
                        cmdList++;
                        remaining--;
                        // fallthrough
                    case 0x0000:
                    case 0x2000:
                    case 0x6000:
                    case 0x8000:
                        break;
                }
            }
        }
    }
 
    rasterList = header->rastersOffset;
    raster = *rasterList;
    dataPos = raster->image;
 
    for (i = 0; i < ARRAY_COUNT(sawRaster) - 1; i++) {
        if ((raster = *rasterList) == PTR_LIST_END) {
            break;
        }
        if (sawRaster[i]) {
            src = raster->image;
            rasterSize = (raster->width * raster->height) / 2;
            copyEnd = &dataPos[rasterSize];
            rasterSize += 8;
            if (dataPos != src) {
                raster->image = dataPos;
                bcopy(src, dataPos, rasterSize);
            }
            *rasterList = copyEnd;
            dataPos += rasterSize;
        }
        rasterList++;
    }
    // sentinel value to mark end of valid data
    sawRaster[i] = TRUE;
 
    writePos = dataPos;
 
    // copy raster list
    rasterList = header->rastersOffset;
    header->rastersOffset = writePos;
 
    for (i = 0; i < ARRAY_COUNT(sawRaster) - 1; i++) {
        raster = *rasterList++;
        if (sawRaster[i]) {
            *(SpriteRasterCacheEntry**) writePos = raster;
        } else {
            *(SpriteRasterCacheEntry**) writePos = (SpriteRasterCacheEntry*) copyEnd;
        }
        writePos += 4;
        if (raster == PTR_LIST_END) {
            break;
        }
    }
 
    // copy palette list
    oldPalList = header->palettesOffset;
    header->palettesOffset = writePos;
 
    for (i = 0; i < ARRAY_COUNT(sawRaster) - 1; i++) {
        raster = (SpriteRasterCacheEntry*)*oldPalList++; // required to match
        *(u16**)writePos = (u16*)raster;
        writePos += 4;
        if (raster == PTR_LIST_END) {
            break;
        }
    }
 
    _heap_realloc(&heap_spriteHead, header, (s32)writePos - (s32)header);
}

Referenced by spr_load_npc_sprite().

spr_init_player_raster_cache()

void spr_init_player_raster_cache	(	s32	cacheSize,
		s32	maxRasterSize )

Definition at line 156 of file 101b90_len_8f0.c.

                                                                    {
    void* raster;
    s32 i;
 
    nuPiReadRom(SPRITE_ROM_START, &SpriteDataHeader, sizeof(SpriteDataHeader));
    PlayerRasterCacheSize = cacheSize;
    PlayerRasterMaxSize = maxRasterSize;
    SpriteDataHeader[0] += SPRITE_ROM_START;
    SpriteDataHeader[1] += SPRITE_ROM_START;
    SpriteDataHeader[2] += SPRITE_ROM_START;
    raster = _heap_malloc(&heap_spriteHead, maxRasterSize * cacheSize);
 
    for (i = 0; i < ARRAY_COUNT(PlayerRasterCache); i++) {
        PlayerRasterCache[i].raster = raster;
        raster += PlayerRasterMaxSize;
        PlayerRasterCache[i].lazyDeleteTime = 0;
        PlayerRasterCache[i].rasterIndex = 0;
        PlayerRasterCache[i].spriteIndex = 0xFF;
    }
 
    for (i = 0; i < ARRAY_COUNT(PlayerRasterLoadDescBeginSpriteIndex); i++)    {
        PlayerRasterLoadDescBeginSpriteIndex[i] = 0;
    }
    PlayerRasterLoadDescNumLoaded = 0;
    nuPiReadRom(SpriteDataHeader[0], &PlayerRasterHeader, sizeof(PlayerRasterHeader));
    nuPiReadRom(SpriteDataHeader[0] + PlayerRasterHeader.indexRanges, PlayerSpriteRasterSets, sizeof(PlayerSpriteRasterSets));
}

Referenced by spr_init_sprites().

spr_init_quad_cache()

void spr_init_quad_cache

(

void

)

Definition at line 125 of file sprite.c.

                               {
    s32 i;
 
    SpriteQuadCache = _heap_malloc(&heap_spriteHead, ARRAY_COUNT(SpriteQuadCacheInfo) * sizeof(*SpriteQuadCache));
 
    for (i = 0; i < ARRAY_COUNT(SpriteQuadCacheInfo); i++) {
        SpriteQuadCacheInfo[i] = -1;
    }
}

Referenced by spr_init_sprites().

spr_get_cached_quad()

Quad * spr_get_cached_quad

(

s32

quadIndex

)

Definition at line 135 of file sprite.c.

                                         {
    s32* quadInfo = &SpriteQuadCacheInfo[quadIndex];
 
    *quadInfo |= 0x1F; // reset life timer
    return &SpriteQuadCache[quadIndex];
}

Referenced by spr_get_quad_for_size().

spr_make_quad_for_size()

void spr_make_quad_for_size	(	Quad *	quad,
		s32	width,
		s32	height )

Definition at line 142 of file sprite.c.

                                                               {
    Vtx* vtx = &quad->v[0];
 
    *quad = SpriteQuadTemplate;
 
    vtx->v.ob[0] = -width / 2;
    vtx->v.ob[1] = height;
    vtx->v.tc[0] = 0x2000;
    vtx->v.tc[1] = 0x2000;
 
    vtx++;
    vtx->v.ob[0] = width / 2;
    vtx->v.ob[1] = height;
    vtx->v.tc[0] = (width + 256) * 32;
    vtx->v.tc[1] = 0x2000;
 
    vtx++;
    vtx->v.tc[0] = (width + 256) * 32;
    vtx->v.ob[0] = width / 2;
    vtx->v.tc[1] = (height + 256) * 32;
 
    vtx++;
    vtx->v.ob[0] = -width / 2;
    vtx->v.tc[0] = 0x2000;
    vtx->v.tc[1] = (height + 256) * 32;
}

Referenced by spr_get_quad_for_size().

spr_get_quad_for_size()

Quad * spr_get_quad_for_size	(	s32 *	quadIndex,
		s32	width,
		s32	height )

Definition at line 169 of file sprite.c.

                                                                   {
    Quad* quad;
    s32 qi;
    s32 dimensions;
    s32 i;
 
    if ((width * height) / 2 <= 0x800) {
        dimensions = (width << 0x18) + (height << 0x10);
        qi = *quadIndex;
        if (qi != -1 && (dimensions == (SpriteQuadCacheInfo[qi] & 0xFFFF0000))) {
            return spr_get_cached_quad(qi);
        }
 
        for (i = 0; i < ARRAY_COUNT(SpriteQuadCacheInfo); i++) {
            if (dimensions == (SpriteQuadCacheInfo[i] & 0xFFFF0000)) {
                *quadIndex = i;
                return spr_get_cached_quad(i);
            }
        }
 
        for (i = 0; i < ARRAY_COUNT(SpriteQuadCacheInfo); i++) {
            if (SpriteQuadCacheInfo[i] == -1) {
                break;
            }
        }
 
        if (i != ARRAY_COUNT(SpriteQuadCacheInfo)) {
            *quadIndex = i;
            SpriteQuadCacheInfo[i] = dimensions;
            quad = spr_get_cached_quad(i);
            spr_make_quad_for_size(quad, width, height);
            return quad;
        }
    }
    return NULL;
}

Referenced by spr_appendGfx_component().

spr_clear_quad_cache()

void spr_clear_quad_cache

(

void

)

Definition at line 206 of file sprite.c.

                                {
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(SpriteQuadCacheInfo); i++) {
        if (SpriteQuadCacheInfo[i] != -1) {
            SpriteQuadCacheInfo[i]--;
            if ((SpriteQuadCacheInfo[i] & 0xFFFF) == 0) {
                SpriteQuadCacheInfo[i] = -1;
            }
        }
    }
}

Referenced by spr_render_init().

spr_appendGfx_component_flat()

void spr_appendGfx_component_flat	(	Quad *	vertices,
		IMG_PTR	raster,
		PAL_PTR	palette,
		s32	width,
		s32	height,
		f32	arg5,
		Matrix4f	mtx,
		s32	alpha )

Definition at line 219 of file sprite.c.

  {
    gDPLoadTLUT_pal16(gMainGfxPos++, 0, palette);
    if (gSpriteShadingProfile->flags & SPR_SHADING_FLAG_ENABLED) {
        gDPScrollMultiTile2_4b(gMainGfxPos++, raster, G_IM_FMT_CI, width, height,
                              0, 0, width - 1, height - 1, 0,
                              G_TX_CLAMP, G_TX_CLAMP, 8, 8, G_TX_NOLOD, G_TX_NOLOD,
                              256, 256);
        gDPSetTile(gMainGfxPos++, G_IM_FMT_RGBA, G_IM_SIZ_16b, 4, 0x0100, 2, 0, G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD, G_TX_WRAP, G_TX_NOMASK, G_TX_NOLOD);
        gDPSetTileSize(gMainGfxPos++, 2, 0, 0, 63 << 2, 0);
        if (gSpriteShadingProfile->flags & SPR_SHADING_FLAG_SET_VIEWPORT) {
            Camera* camera = &gCameras[gCurrentCamID];
            if (gGameStatusPtr->context == CONTEXT_PAUSE) {
                gSPViewport(gMainGfxPos++, &SpritePauseVpAlt);
            } else {
                gSPViewport(gMainGfxPos++, &camera->vpAlt);
            }
 
            if (alpha == 255) {
                gDPSetRenderMode(gMainGfxPos++, AA_EN | Z_CMP | Z_UPD | CVG_DST_FULL | ZMODE_OPA | CVG_X_ALPHA |
                                 G_RM_PASS, AA_EN | Z_CMP | Z_UPD | CVG_DST_FULL | ZMODE_OPA | CVG_X_ALPHA |
                                 GBL_c2(G_BL_CLR_IN, G_BL_A_IN, G_BL_CLR_MEM, G_BL_A_MEM));
            } else {
                gDPSetRenderMode(gMainGfxPos++, G_RM_PASS, G_RM_ZB_CLD_SURF2);
            }
 
            gDPSetEnvColor(gMainGfxPos++, 0, 0, 0, alpha);
            gDPSetCombineMode(gMainGfxPos++, PM_CC_0B, PM_CC_0C);
            gSPVertex(gMainGfxPos++, vertices, 4, 0);
            gSP2Triangles(gMainGfxPos++, 0, 2, 1, 0, 0, 3, 2, 0);
            gDPPipeSync(gMainGfxPos++);
        }
        create_shading_palette(mtx, 0, 0, width, height, alpha, alpha == 255 ? 0x111238 : 0x104B50); // TODO make macro for render mode
    } else {
        gDPScrollTextureBlock_4b(gMainGfxPos++, raster, G_IM_FMT_CI, width, height, 0,
                                 G_TX_CLAMP, G_TX_CLAMP, 8, 8, G_TX_NOLOD, G_TX_NOLOD,
                                 256, 256);
        if (gSpriteShadingProfile->flags & SPR_SHADING_FLAG_SET_VIEWPORT) {
            Camera* camera =  &gCameras[gCurrentCamID];
            if (gGameStatusPtr->context == CONTEXT_PAUSE) {
                gSPViewport(gMainGfxPos++, &SpritePauseVpAlt);
            } else {
                gSPViewport(gMainGfxPos++, &camera->vpAlt);
            }
            if (alpha == 255) {
                gDPSetRenderMode(gMainGfxPos++, AA_EN | Z_CMP | Z_UPD | CVG_DST_FULL | ZMODE_OPA | CVG_X_ALPHA | ALPHA_CVG_SEL | GBL_c1(G_BL_CLR_IN, G_BL_A_IN, G_BL_CLR_MEM, G_BL_A_MEM), AA_EN | Z_CMP | Z_UPD | CVG_DST_FULL | ZMODE_OPA | CVG_X_ALPHA | ALPHA_CVG_SEL | GBL_c2(G_BL_CLR_IN, G_BL_A_IN, G_BL_CLR_MEM, G_BL_A_MEM));
            } else {
                gDPSetRenderMode(gMainGfxPos++, G_RM_ZB_CLD_SURF, G_RM_ZB_CLD_SURF2);
            }
 
            gDPSetEnvColor(gMainGfxPos++, 0, 0, 0, alpha);
            gDPSetCombineMode(gMainGfxPos++, PM_CC_0A, PM_CC_0A);
            gSPVertex(gMainGfxPos++, vertices, 4, 0);
            gSP2Triangles(gMainGfxPos++, 0, 2, 1, 0, 0, 3, 2, 0);
            gDPPipeSync(gMainGfxPos++);
 
            if (alpha == 255) {
                gDPSetRenderMode(gMainGfxPos++, AA_EN | Z_CMP | Z_UPD | CVG_DST_FULL | ZMODE_OPA | CVG_X_ALPHA |
                                 GBL_c1(G_BL_CLR_IN, G_BL_A_IN, G_BL_CLR_MEM, G_BL_A_MEM),
                                 AA_EN | Z_CMP | Z_UPD | CVG_DST_FULL | ZMODE_OPA | CVG_X_ALPHA |
                                 GBL_c2(G_BL_CLR_IN, G_BL_A_IN, G_BL_CLR_MEM, G_BL_A_MEM));
            } else {
                gDPSetRenderMode(gMainGfxPos++, G_RM_ZB_CLD_SURF, G_RM_ZB_CLD_SURF2);
            }
 
            gDPSetEnvColor(gMainGfxPos++, 100, 100, 100, 255);
            gDPSetPrimColor(gMainGfxPos++, 0, 0, 0, 0, 0, alpha);
            gDPSetCombineMode(gMainGfxPos++, PM_CC_3D, PM_CC_3D);
            gDPSetColorDither(gMainGfxPos++, G_CD_MAGICSQ);
        }
    }
 
    if (gSpriteShadingProfile->flags & SPR_SHADING_FLAG_SET_VIEWPORT) {
        Camera* camera =  &gCameras[gCurrentCamID];
 
        if (gGameStatusPtr->context == CONTEXT_PAUSE) {
            gSPViewport(gMainGfxPos++, &SpritePauseVp);
            SpritePauseVpAlt.vp.vtrans[0] = SpritePauseVp.vp.vtrans[0] + gGameStatusPtr->altViewportOffset.x;
            SpritePauseVpAlt.vp.vtrans[1] = SpritePauseVp.vp.vtrans[1] + gGameStatusPtr->altViewportOffset.y;
        } else {
            gSPViewport(gMainGfxPos++, &camera->vp);
        }
    }
 
    gSPVertex(gMainGfxPos++, vertices, 4, 0);
    gSP2Triangles(gMainGfxPos++, 0, 2, 1, 0, 0, 3, 2, 0);
    gDPPipeSync(gMainGfxPos++);
}

Referenced by spr_appendGfx_component().

spr_appendGfx_component()

void spr_appendGfx_component	(	SpriteRasterCacheEntry *	cache,
		f32	dx,
		f32	dy,
		f32	dz,
		f32	rotX,
		f32	rotY,
		f32	rotZ,
		f32	scaleX,
		f32	scaleY,
		f32	scaleZ,
		s32	opacity,
		PAL_PTR	palette,
		Matrix4f	mtx )

Definition at line 314 of file sprite.c.

{
    Matrix4f mtxTransform;
    Matrix4f mtxTemp;
    ImgFXTexture ifxImg;
    s32 quadIndex;
    Quad* quad;
    s32 width;
    s32 height;
 
    guTranslateF(mtxTemp, dx, dy, dz);
    guMtxCatF(mtxTemp, mtx, mtxTransform);
 
    if (rotY != 0.0f) {
        guRotateF(mtxTemp, rotY, 0.0f, 1.0f, 0.0f);
        guMtxCatF(mtxTemp, mtxTransform, mtxTransform);
    }
    if (rotZ != 0.0f) {
        guRotateF(mtxTemp, rotZ, 0.0f, 0.0f, 1.0f);
        guMtxCatF(mtxTemp, mtxTransform, mtxTransform);
    }
    if (rotX != 0.0f) {
        guRotateF(mtxTemp, rotX, 1.0f, 0.0f, 0.0f);
        guMtxCatF(mtxTemp, mtxTransform, mtxTransform);
    }
 
    if (scaleX != 1.0f || scaleY != 1.0f || scaleZ != 1.0f) {
        guScaleF(mtxTemp, scaleX, scaleY, scaleZ);
        guMtxCatF(mtxTemp, mtxTransform, mtxTransform);
    }
 
    guMtxF2L(mtxTransform, &gDisplayContext->matrixStack[gMatrixListPos]);
    gSPMatrix(gMainGfxPos++, VIRTUAL_TO_PHYSICAL(&gDisplayContext->matrixStack[gMatrixListPos++]),
              G_MTX_PUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
 
    if (gSpriteShadingProfile->flags & SPR_SHADING_FLAG_ENABLED) {
        if ((u8) opacity == 255) {
            gSPDisplayList(gMainGfxPos++, OpaqueShadedSpriteGfx);
        } else {
            gSPDisplayList(gMainGfxPos++, TranslucentShadedSpriteGfx);
        }
    } else {
        if ((u8) opacity == 255) {
            gSPDisplayList(gMainGfxPos++, OpaqueSpriteGfx);
        } else {
            gDPSetPrimColor(gMainGfxPos++, 0, 0, 0, 0, 0, (u8) opacity);
            gSPDisplayList(gMainGfxPos++, TranslucentSpriteGfx);
        }
    }
 
    width = cache->width;
    height = cache->height;
    quadIndex = cache->quadCacheIndex;
    quad = NULL;
    if (!(CurSpriteImgFX & SPR_IMGFX_FLAG_ALL)) {
        quad = spr_get_quad_for_size(&quadIndex, width, height);
        cache->quadCacheIndex = quadIndex;
    }
 
    if (quad != NULL) {
        spr_appendGfx_component_flat(quad, cache->image, palette, width, height, rotY, mtxTransform, (u8) opacity);
    } else {
        ifxImg.raster  = cache->image;
        ifxImg.palette = palette;
        ifxImg.width   = width;
        ifxImg.height  = height;
        ifxImg.xOffset = -(width / 2);
        ifxImg.yOffset = height;
        ifxImg.alpha = opacity;
        if (imgfx_appendGfx_component((u8) CurSpriteImgFX, &ifxImg, IMGFX_FLAG_80000, mtxTransform) == 1) {
            CurSpriteImgFX &= ~SPR_IMGFX_FLAG_ALL;
        }
    }
    gSPPopMatrix(gMainGfxPos++, G_MTX_MODELVIEW);
}

Referenced by spr_draw_component().

spr_transform_point()

void spr_transform_point	(	s32	rotX,
		s32	rotY,
		s32	rotZ,
		f32	inX,
		f32	inY,
		f32	inZ,
		f32 *	outX,
		f32 *	outY,
		f32 *	outZ )

Definition at line 395 of file sprite.c.

                                                                                                                   {
    if (rotX == 0 && rotY == 0 && rotZ == 0) {
        *outX = inX;
        *outY = inY;
        *outZ = inZ;
    } else {
        Matrix4f mtxTransform, mtxTemp;
        f32 xx, yx, zx, xy, yy, zy, xz, yz, zz;
 
        guRotateF(mtxTransform, rotY, 0.0f, 1.0f, 0.0f);
        guRotateF(mtxTemp, rotZ, 0.0f, 0.0f, 1.0f);
        guMtxCatF(mtxTemp, mtxTransform, mtxTransform);
        guRotateF(mtxTemp, rotX, 1.0f, 0.0f, 0.0f);
        guMtxCatF(mtxTemp, mtxTransform, mtxTransform);
 
        xx = (mtxTransform[0][0] * inX);
        yx = (mtxTransform[1][0] * inY);
        zx = (mtxTransform[2][0] * inZ);
        xy = (mtxTransform[0][1] * inX);
        yy = (mtxTransform[1][1] * inY);
        zy = (mtxTransform[2][1] * inZ);
        xz = (mtxTransform[0][2] * inX);
        yz = (mtxTransform[1][2] * inY);
        zz = (mtxTransform[2][2] * inZ);
 
        *outX = xx + yx + zx;
        *outY = xy + yy + zy;
        *outZ = xz + yz + zz;
    }
}

Referenced by spr_draw_component().

spr_draw_component()

void spr_draw_component	(	s32	drawOpts,
		SpriteComponent *	component,
		SpriteAnimComponent *	anim,
		SpriteRasterCacheEntry **	cache,
		PAL_PTR *	palettes,
		f32	zscale,
		Matrix4f	mtx )

Definition at line 426 of file sprite.c.

                                                                                     {
    SpriteRasterCacheEntry* cacheEntry;
    s32 paletteIdx;
    PAL_PTR pal;
    f32 dx, dy, dz;
    f32 rotX, rotY, rotZ;
    f32 inX, inY, inZ;
 
    if (component->initialized && component->curRaster != -1) {
        rotX = SpriteCurBaseRot[0];
        rotY = SpriteCurBaseRot[1];
        rotZ = SpriteCurBaseRot[2];
        inX = component->compPos.x + anim->compOffset.x;
        inY = component->compPos.y + anim->compOffset.y;
        inZ = component->compPos.z + anim->compOffset.z;
 
        spr_transform_point(rotX, rotY, rotZ, inX, inY, inZ * zscale, &dx, &dy, &dz);
        cacheEntry = cache[component->curRaster];
        paletteIdx = component->curPalette;
        if (drawOpts & DRAW_SPRITE_USE_PLAYER_RASTERS) {
            cacheEntry->image = spr_get_player_raster(component->curRaster & 0xFFF, CurPlayerSpriteIndex);
        }
        CurSpriteImgFX = component->imgfxIdx;
        pal = palettes[paletteIdx];
 
        spr_appendGfx_component(
            cacheEntry,
            dx, dy, dz,
            rotX + component->rot.x,
            rotY + component->rot.y,
            rotZ + component->rot.z,
            component->scale.x,
            component->scale.y,
            component->scale.z,
            drawOpts, pal, mtx
        );
        component->imgfxIdx = CurSpriteImgFX;
    }
}

Referenced by spr_draw_npc_sprite(), and spr_draw_player_sprite().

spr_unpack_signed_12bit()

s32 spr_unpack_signed_12bit

(

u16

val

)

Definition at line 467 of file sprite.c.

                                     {
    s32 temp = val & 0xFFF;
 
    if (temp & 0x800) {
        return temp | ~0xFFF;
    } else {
        return temp;
    }
}

Referenced by spr_component_update_commands().

spr_unpack_signed_16bit()

s32 spr_unpack_signed_16bit

(

u16

val

)

Definition at line 477 of file sprite.c.

                                     {
    s32 temp = val & 0xFFFF;
 
    if (temp & 0x8000) {
        return temp | ~0xFFFF;
    } else {
        return temp;
    }
}

Referenced by spr_component_update_commands().

spr_component_update_commands()

void spr_component_update_commands	(	SpriteComponent *	comp,
		SpriteAnimComponent *	anim )

Definition at line 487 of file sprite.c.

                                                                                     {
    f32 posX, posY, posZ;
    f32 rotX, rotY, rotZ;
    f32 scaleX, scaleY, scaleZ;
    s32 changedFlags;
 
    u16* bufPos;
    u16* gotoPos;
    s32 cmdValue;
 
    if (comp->initialized) {
        scaleZ = 1.0f;
        scaleY = 1.0f;
        scaleX = 1.0f;
        changedFlags = 0;
 
        bufPos = comp->readPos;
        gotoPos = (u16*) -1;
 
        comp->waitTime -= SpriteAnimUpdateTimescale;
 
        while (comp->waitTime <= 0.0f) {
            // overflow check
            if (bufPos >= &anim->cmdList[anim->cmdListSize / 2]) {
                bufPos = anim->cmdList;
                break;
            }
 
            switch (*bufPos & 0xF000) {
                // 0VVV
                // Wait
                case 0x0000:
                    comp->waitTime = *bufPos++ & 0xFFF;
                    if (comp->waitTime == 0.0f) {
                        comp->waitTime = 4095.0f;
                    }
                    comp->posOffset.z = 0.0f;
                    comp->posOffset.y = 0.0f;
                    comp->posOffset.x = 0.0f;
                    comp->rot.z = 0;
                    comp->rot.y = 0;
                    comp->rot.x = 0;
                    comp->scale.z = 1.0f;
                    comp->scale.y = 1.0f;
                    comp->scale.x = 1.0f;
                    break;
                // 2VVV
                // Goto -- jump to another position in the list
                case 0x2000:
                    bufPos = &anim->cmdList[spr_unpack_signed_12bit(*bufPos)];
                    if (bufPos == gotoPos) {
                        bufPos = anim->cmdList;
                        comp->waitTime = 1.0f;
                    }
                    gotoPos = bufPos;
                    break;
                // 1VVV
                // SetImage -- FFF is valid value for "no image"
                case 0x1000:
                    cmdValue = *bufPos++ & 0xFFF;
                    if (cmdValue != 0xFFF) {
                        comp->curRaster = cmdValue;
                    } else {
                        comp->curRaster = -1;
                    }
                    comp->curPalette = -1;
                    break;
                // 6VVV
                // SetPalette -- FFF to clear
                case 0x6000:
                    cmdValue = *bufPos++ & 0xFFF;
                    if (cmdValue != 0xFFF) {
                        comp->curPalette = cmdValue;
                    } else {
                        comp->curPalette = -1;
                    }
                    break;
                // 8VUU
                // SetProperty
                // 81-XX parent to component XX
                // 82-YY set notify value to YY
                case 0x8000:
                    cmdValue = *bufPos++;
                    switch (cmdValue & 0xF00) {
                        case 0x100: // set parent
                            comp->properties = (comp->properties & 0xFFFF0000) | cmdValue;
                            break;
                        case 0x200: // set notify value
                            SpriteUpdateNotifyValue = cmdValue & 0xFF;
                            comp->properties = (comp->properties & 0xFF00FFFF) | (SpriteUpdateNotifyValue << 0x10);
                            break;
                    }
                    break;
                // 3VVV XXXX YYYY ZZZZ
                // SetPosition -- what does the flag do?
                case 0x3000:
                    switch (*bufPos++ & 0xF) {
                        case 0:
                        case 1:
                            posX = spr_unpack_signed_16bit(*bufPos++);
                            posY = spr_unpack_signed_16bit(*bufPos++);
                            posZ = spr_unpack_signed_16bit(*bufPos++);
                            changedFlags |= 1;
                            break;
                    }
                    break;
                // 4XXX YYYY ZZZZ
                // SetRotation (euler angles)
                case 0x4000:
                    rotX = spr_unpack_signed_12bit(*bufPos++);
                    rotY = spr_unpack_signed_16bit(*bufPos++);
                    rotZ = spr_unpack_signed_16bit(*bufPos++);
                    changedFlags |= 2;
                    break;
                // 5VVV UUUU
                // SetScale (%)
                case 0x5000:
                    switch (*bufPos++ & 0xF) {
                        case 0:
                            scaleZ = *bufPos++ / 100.0f;
                            scaleY = scaleZ;
                            scaleX = scaleZ;
                            break;
                        case 1:
                            scaleX = *bufPos++ / 100.0f;
                            break;
                        case 2:
                            scaleY = *bufPos++ / 100.0f;
                            break;
                        case 3:
                            scaleZ = *bufPos++ / 100.0f;
                            break;
                    }
                    changedFlags |= 4;
                    break;
                // 7VVV UUUU
                // Loop -- VV iterations jumping back to UUUU
                case 0x7000:
                    if (comp->loopCounter != 0) {
                        comp->loopCounter--;
                        if (comp->loopCounter == 0) {
                            bufPos += 2;
                            break;
                        }
                    } else {
                        comp->loopCounter = bufPos[1];
                    }
                    bufPos = &anim->cmdList[spr_unpack_signed_12bit(*bufPos)];
                    break;
                // invalid command
                default:
                    bufPos = anim->cmdList;
                    comp->waitTime = 1.0f;
                    break;
            }
        } // end loop
 
        comp->readPos = bufPos;
        if (changedFlags & 1) {
            comp->posOffset.x = posX;
            comp->posOffset.y = posY;
            comp->posOffset.z = posZ;
        }
        if (changedFlags & 2) {
            comp->rot.x = rotX;
            comp->rot.y = rotY;
            comp->rot.z = rotZ;
        }
        if (changedFlags & 4) {
            comp->scale.x = scaleX;
            comp->scale.y = scaleY;
            comp->scale.z = scaleZ;
        }
    }
}

Referenced by spr_component_update().

spr_component_update_finish()

void spr_component_update_finish	(	SpriteComponent *	comp,
		SpriteComponent **	compList,
		SpriteRasterCacheEntry **	rasterCacheEntry,
		s32	overridePalette )

Definition at line 663 of file sprite.c.

{
    SpriteComponent* listComp;
    SpriteRasterCacheEntry* cache;
 
    if (comp->initialized) {
        comp->compPos.x = comp->posOffset.x;
        comp->compPos.y = comp->posOffset.y;
        comp->compPos.z = comp->posOffset.z;
 
        if ((comp->properties & 0xF00) == 0x100) {
            listComp = compList[comp->properties & 0xFF];
            comp->compPos.x += listComp->compPos.x;
            comp->compPos.y += listComp->compPos.y;
            comp->compPos.z += listComp->compPos.z;
        }
 
        if (comp->curRaster != -1) {
            cache = rasterCacheEntry[comp->curRaster];
            if (comp->curPalette == -1) {
                comp->curPalette = cache->palette;
                if (overridePalette != 0 && comp->curPalette == 0) {
                    comp->curPalette = overridePalette;
                }
            }
        }
    }
}

Referenced by spr_component_update().

spr_component_update()

s32 spr_component_update	(	s32	curNotifyValue,
		SpriteComponent **	compList,
		SpriteAnimComponent **	animList,
		SpriteRasterCacheEntry **	rasterCache,
		s32	overridePalette )

Definition at line 693 of file sprite.c.

                                                                   {
    SpriteComponent** compListIt;
 
    SpriteUpdateNotifyValue = curNotifyValue;
 
    compListIt = compList;
    while (*compListIt != PTR_LIST_END) {
        spr_component_update_commands(*compListIt++, *animList);
        if (*animList != PTR_LIST_END) {
            animList++;
        }
    }
 
    compListIt = compList;
    while (*compListIt != PTR_LIST_END) {
        spr_component_update_finish(*compListIt++, compList, rasterCache, overridePalette);
    }
 
    return SpriteUpdateNotifyValue;
}

Referenced by spr_update_player_sprite(), and spr_update_sprite().

spr_init_component_anim_state()

void spr_init_component_anim_state	(	SpriteComponent *	comp,
		SpriteAnimComponent *	anim )

Definition at line 715 of file sprite.c.

                                                                                     {
    if (anim == PTR_LIST_END) {
        comp->initialized = FALSE;
        return;
    }
 
    comp->initialized = TRUE;
    comp->properties = 0;
    comp->readPos = anim->cmdList;
    comp->waitTime = 0;
    comp->loopCounter = 0;
    comp->curRaster = -1;
    comp->curPalette = -1;
    comp->posOffset.x = 0.0f;
    comp->posOffset.y = 0.0f;
    comp->posOffset.z = 0.0f;
    comp->compPos.x = 0.0f;
    comp->compPos.y = 0.0f;
    comp->compPos.z = 0.0f;
    comp->rot.x = 0.0f;
    comp->rot.y = 0.0f;
    comp->rot.z = 0.0f;
    comp->scale.x = 1.0f;
    comp->scale.y = 1.0f;
    comp->scale.z = 1.0f;
}

Referenced by spr_init_anim_state().

spr_init_anim_state()

void spr_init_anim_state	(	SpriteComponent **	compList,
		SpriteAnimComponent **	animList )

Definition at line 742 of file sprite.c.

                                                                                     {
    while (*compList != PTR_LIST_END) {
        SpriteComponent* component = *compList++;
        spr_init_component_anim_state(component, *animList);
        if (*animList != PTR_LIST_END) {
            animList++;
        }
    }
}

Referenced by spr_update_player_sprite(), and spr_update_sprite().

spr_set_anim_timescale()

void spr_set_anim_timescale

(

f32

timescale

)

Definition at line 752 of file sprite.c.

                                           {
    SpriteAnimUpdateTimescale = timescale * 2.0f;
}

Referenced by spr_update_player_sprite(), and spr_update_sprite().

spr_load_player_sprite()

void spr_load_player_sprite

(

s32

spriteIndex

)

Definition at line 756 of file sprite.c.

                                             {
    SpriteAnimData* playerSprite = spr_load_sprite(spriteIndex - 1, TRUE, FALSE);
 
    PlayerSprites[spriteIndex - 1] = playerSprite;
    if (MaxPlayerSpriteComponents < playerSprite->maxComponents) {
        MaxPlayerSpriteComponents = playerSprite->maxComponents;
    }
}

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_sprite()

s32 spr_update_player_sprite	(	s32	spriteInstanceID,
		s32	animID,
		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	alphaIn,
		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

spriteIdx

)

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_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	spriteIdx,
		ImgFXType	imgfxType,
		s32	imgfxArg1,
		s32	imgfxArg2,
		s32	imgfxArg3,
		s32	imgfxArg4,
		s32	imgfxArg5 )

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;
    }
}

Referenced by func_unkA_draw_npc(), npc_reload_all(), npc_render_with_double_pal_blending(), npc_render_with_single_pal_blending(), npc_render_with_watt_idle_palettes(), 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_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().

Variable Documentation

heap_generalHead

HeapNode heap_generalHead

extern

Definition at line 3 of file heaps3.c.

Referenced by spr_free_sprite().

heap_spriteHead

HeapNode heap_spriteHead

extern

Definition at line 4 of file heaps3.c.

Referenced by spr_free_sprite(), spr_init_quad_cache(), and spr_init_sprites().

SpriteUseGeneralHeap

BSS b32 SpriteUseGeneralHeap

Definition at line 10 of file sprite.c.

Referenced by spr_allocate_components(), spr_free_sprite(), and spr_init_sprites().

MaxLoadedSpriteInstanceID

BSS s32 MaxLoadedSpriteInstanceID

Definition at line 11 of file sprite.c.

Referenced by spr_load_npc_sprite(), and spr_update_sprite().

CurSpriteImgFX

BSS s32 CurSpriteImgFX

Definition at line 12 of file sprite.c.

Referenced by spr_appendGfx_component(), and spr_draw_component().

PlayerSprites

BSS SpriteAnimData* PlayerSprites[13]

Definition at line 13 of file sprite.c.

Referenced by spr_draw_player_sprite(), spr_get_player_palettes(), spr_get_player_raster_info(), spr_init_sprites(), spr_load_player_sprite(), and spr_update_player_sprite().

CurPlayerSpriteIndex

BSS s32 CurPlayerSpriteIndex

Definition at line 14 of file sprite.c.

Referenced by spr_draw_component(), spr_draw_player_sprite(), and spr_update_player_sprite().

MaxPlayerSpriteComponents

BSS s32 MaxPlayerSpriteComponents

Definition at line 15 of file sprite.c.

Referenced by spr_init_sprites(), spr_load_player_sprite(), and spr_update_player_sprite().

CurPlayerAnimInfo

BSS PlayerCurrentAnimInfo CurPlayerAnimInfo[3]

Definition at line 16 of file sprite.c.

Referenced by func_802DDEC4(), set_player_imgfx_comp(), spr_draw_player_sprite(), spr_init_sprites(), and spr_update_player_sprite().

NpcSpriteData

BSS SpriteAnimData* NpcSpriteData[0xFF]

Definition at line 17 of file sprite.c.

Referenced by spr_free_sprite(), spr_get_npc_color_variations(), spr_get_npc_palettes(), spr_get_npc_raster_info(), spr_init_sprites(), and spr_load_npc_sprite().

NpcSpriteInstanceCount

BSS u8 NpcSpriteInstanceCount[0xFF]

Definition at line 18 of file sprite.c.

Referenced by spr_free_sprite(), spr_init_sprites(), and spr_load_npc_sprite().

SpriteInstances

BSS SpriteInstance SpriteInstances[51]

Definition at line 19 of file sprite.c.

Referenced by get_npc_comp_imgfx_idx(), set_npc_imgfx_comp(), spr_draw_npc_sprite(), spr_free_sprite(), spr_get_comp_position(), spr_get_notify_value(), spr_init_sprites(), spr_load_npc_sprite(), and spr_update_sprite().

SpriteQuadCache

BSS Quad* SpriteQuadCache

Definition at line 20 of file sprite.c.

Referenced by spr_get_cached_quad(), and spr_init_quad_cache().

SpriteQuadCacheInfo

BSS s32 SpriteQuadCacheInfo[22]

Definition at line 21 of file sprite.c.

Referenced by spr_clear_quad_cache(), spr_get_cached_quad(), spr_get_quad_for_size(), and spr_init_quad_cache().

SpriteCurBaseRot

BSS s32 SpriteCurBaseRot[3]

Definition at line 22 of file sprite.c.

Referenced by spr_draw_component(), spr_draw_npc_sprite(), and spr_draw_player_sprite().

SpriteUpdateNotifyValue

BSS s32 SpriteUpdateNotifyValue

Definition at line 23 of file sprite.c.

Referenced by spr_component_update(), and spr_component_update_commands().

SpriteQuadTemplate

Quad SpriteQuadTemplate

Initial value:

= {
    {
    {{{ -16, 56, 0 }, FALSE, {    0,    0 }, { 240, 240, 240, 255 }}},
    {{{  16, 56, 0 }, FALSE, { 1024,    0 }, { 120, 120, 120, 255 }}},
    {{{  16,  0, 0 }, FALSE, { 1024, 1792 }, {   0,   0,   0, 255 }}},
    {{{ -16,  0, 0 }, FALSE, {    0, 1792 }, { 120, 120, 120, 255 }}},
    }
}

Definition at line 29 of file sprite.c.

                          {
    {
    {{{ -16, 56, 0 }, FALSE, {    0,    0 }, { 240, 240, 240, 255 }}},
    {{{  16, 56, 0 }, FALSE, { 1024,    0 }, { 120, 120, 120, 255 }}},
    {{{  16,  0, 0 }, FALSE, { 1024, 1792 }, {   0,   0,   0, 255 }}},
    {{{ -16,  0, 0 }, FALSE, {    0, 1792 }, { 120, 120, 120, 255 }}},
    }
};

Referenced by spr_make_quad_for_size().

SpritePauseVp

Vp SpritePauseVp

Initial value:

= {{
        { 640, 480, 511, 0 },
        { 640, 480, 511, 0 },
    }
}

Definition at line 38 of file sprite.c.

                   {{
        { 640, 480, 511, 0 },
        { 640, 480, 511, 0 },
    }
};

Referenced by spr_appendGfx_component_flat().

SpritePauseVpAlt

Vp SpritePauseVpAlt

Initial value:

= {{
        { 640, 480, 511, 0 },
        { 640, 480, 512, 0 },
    }
}

Definition at line 44 of file sprite.c.

                      {{
        { 640, 480, 511, 0 },
        { 640, 480, 512, 0 },
    }
};

Referenced by spr_appendGfx_component_flat().

OpaqueSpriteGfx

Gfx OpaqueSpriteGfx[]

Initial value:

= {
    gsSPClearGeometryMode(G_CULL_BOTH | G_LIGHTING),
    gsDPSetCombineMode(G_CC_DECALRGBA, G_CC_DECALRGBA),
    gsSPTexture(-1, -1, 0, G_TX_RENDERTILE, G_ON),
    gsSPSetGeometryMode(G_ZBUFFER | G_SHADE | G_SHADING_SMOOTH),
    gsDPSetRenderMode(AA_EN | Z_CMP | Z_UPD | CVG_DST_FULL | ZMODE_OPA | CVG_X_ALPHA | GBL_c1(G_BL_CLR_IN, G_BL_A_IN, G_BL_CLR_MEM, G_BL_A_MEM), AA_EN | Z_CMP | Z_UPD | CVG_DST_FULL | ZMODE_OPA | CVG_X_ALPHA | GBL_c2(G_BL_CLR_IN, G_BL_A_IN, G_BL_CLR_MEM, G_BL_A_MEM)),
    gsSPSetOtherMode(G_SETOTHERMODE_H, G_MDSFT_ALPHADITHER, 18, G_AD_DISABLE | G_CD_DISABLE | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_RGBA16 | G_TL_TILE | G_TD_CLAMP | G_TP_PERSP | G_CYC_1CYCLE | G_PM_NPRIMITIVE),
    gsSPEndDisplayList(),
}

Definition at line 50 of file sprite.c.

                        {
    gsSPClearGeometryMode(G_CULL_BOTH | G_LIGHTING),
    gsDPSetCombineMode(G_CC_DECALRGBA, G_CC_DECALRGBA),
    gsSPTexture(-1, -1, 0, G_TX_RENDERTILE, G_ON),
    gsSPSetGeometryMode(G_ZBUFFER | G_SHADE | G_SHADING_SMOOTH),
    gsDPSetRenderMode(AA_EN | Z_CMP | Z_UPD | CVG_DST_FULL | ZMODE_OPA | CVG_X_ALPHA | GBL_c1(G_BL_CLR_IN, G_BL_A_IN, G_BL_CLR_MEM, G_BL_A_MEM), AA_EN | Z_CMP | Z_UPD | CVG_DST_FULL | ZMODE_OPA | CVG_X_ALPHA | GBL_c2(G_BL_CLR_IN, G_BL_A_IN, G_BL_CLR_MEM, G_BL_A_MEM)),
    gsSPSetOtherMode(G_SETOTHERMODE_H, G_MDSFT_ALPHADITHER, 18, G_AD_DISABLE | G_CD_DISABLE | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_RGBA16 | G_TL_TILE | G_TD_CLAMP | G_TP_PERSP | G_CYC_1CYCLE | G_PM_NPRIMITIVE),
    gsSPEndDisplayList(),
};

Referenced by spr_appendGfx_component().

TranslucentSpriteGfx

Gfx TranslucentSpriteGfx[]

Initial value:

= {
    gsSPClearGeometryMode(G_CULL_BOTH | G_LIGHTING),
    gsDPSetCombineMode(PM_CC_02, PM_CC_02),
    gsSPTexture(-1, -1, 0, G_TX_RENDERTILE, G_ON),
    gsSPSetGeometryMode(G_ZBUFFER | G_SHADE | G_SHADING_SMOOTH),
    gsDPSetRenderMode(G_RM_ZB_CLD_SURF, G_RM_ZB_CLD_SURF2),
    gsSPSetOtherMode(G_SETOTHERMODE_H, G_MDSFT_ALPHADITHER, 18, G_AD_DISABLE | G_CD_DISABLE | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_RGBA16 | G_TL_TILE | G_TD_CLAMP | G_TP_PERSP | G_CYC_1CYCLE | G_PM_NPRIMITIVE),
    gsSPEndDisplayList(),
}

Definition at line 60 of file sprite.c.

                             {
    gsSPClearGeometryMode(G_CULL_BOTH | G_LIGHTING),
    gsDPSetCombineMode(PM_CC_02, PM_CC_02),
    gsSPTexture(-1, -1, 0, G_TX_RENDERTILE, G_ON),
    gsSPSetGeometryMode(G_ZBUFFER | G_SHADE | G_SHADING_SMOOTH),
    gsDPSetRenderMode(G_RM_ZB_CLD_SURF, G_RM_ZB_CLD_SURF2),
    gsSPSetOtherMode(G_SETOTHERMODE_H, G_MDSFT_ALPHADITHER, 18, G_AD_DISABLE | G_CD_DISABLE | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_RGBA16 | G_TL_TILE | G_TD_CLAMP | G_TP_PERSP | G_CYC_1CYCLE | G_PM_NPRIMITIVE),
    gsSPEndDisplayList(),
};

Referenced by spr_appendGfx_component().

OpaqueShadedSpriteGfx

Gfx OpaqueShadedSpriteGfx[]

Initial value:

= {
    gsSPClearGeometryMode(G_CULL_BOTH | G_LIGHTING),
    gsSPTexture(-1, -1, 0, G_TX_RENDERTILE, G_ON),
    gsSPSetGeometryMode(G_ZBUFFER | G_SHADE | G_SHADING_SMOOTH),
    gsDPSetRenderMode(AA_EN | Z_CMP | Z_UPD | CVG_DST_FULL | ZMODE_OPA | CVG_X_ALPHA | G_RM_PASS, AA_EN | Z_CMP | Z_UPD | CVG_DST_FULL | ZMODE_OPA | CVG_X_ALPHA | GBL_c2(G_BL_CLR_IN, G_BL_A_IN, G_BL_CLR_MEM, G_BL_A_MEM)),
    gsSPSetOtherMode(G_SETOTHERMODE_H, G_MDSFT_ALPHADITHER, 18, G_AD_DISABLE | G_CD_DISABLE | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_RGBA16 | G_TL_TILE | G_TD_CLAMP | G_TP_PERSP | G_CYC_2CYCLE | G_PM_NPRIMITIVE),
    gsSPEndDisplayList(),
}

Definition at line 70 of file sprite.c.

                              {
    gsSPClearGeometryMode(G_CULL_BOTH | G_LIGHTING),
    gsSPTexture(-1, -1, 0, G_TX_RENDERTILE, G_ON),
    gsSPSetGeometryMode(G_ZBUFFER | G_SHADE | G_SHADING_SMOOTH),
    gsDPSetRenderMode(AA_EN | Z_CMP | Z_UPD | CVG_DST_FULL | ZMODE_OPA | CVG_X_ALPHA | G_RM_PASS, AA_EN | Z_CMP | Z_UPD | CVG_DST_FULL | ZMODE_OPA | CVG_X_ALPHA | GBL_c2(G_BL_CLR_IN, G_BL_A_IN, G_BL_CLR_MEM, G_BL_A_MEM)),
    gsSPSetOtherMode(G_SETOTHERMODE_H, G_MDSFT_ALPHADITHER, 18, G_AD_DISABLE | G_CD_DISABLE | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_RGBA16 | G_TL_TILE | G_TD_CLAMP | G_TP_PERSP | G_CYC_2CYCLE | G_PM_NPRIMITIVE),
    gsSPEndDisplayList(),
};

Referenced by spr_appendGfx_component().

TranslucentShadedSpriteGfx

Gfx TranslucentShadedSpriteGfx[]

Initial value:

= {
    gsSPClearGeometryMode(G_CULL_BOTH | G_LIGHTING),
    gsSPTexture(-1, -1, 0, G_TX_RENDERTILE, G_ON),
    gsSPSetGeometryMode(G_ZBUFFER | G_SHADE | G_SHADING_SMOOTH),
    gsDPSetRenderMode(G_RM_PASS, G_RM_ZB_CLD_SURF2),
    gsSPSetOtherMode(G_SETOTHERMODE_H, G_MDSFT_ALPHADITHER, 18, G_AD_DISABLE | G_CD_DISABLE | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_RGBA16 | G_TL_TILE | G_TD_CLAMP | G_TP_PERSP | G_CYC_2CYCLE | G_PM_NPRIMITIVE),
    gsSPEndDisplayList(),
}

Definition at line 79 of file sprite.c.

                                   {
    gsSPClearGeometryMode(G_CULL_BOTH | G_LIGHTING),
    gsSPTexture(-1, -1, 0, G_TX_RENDERTILE, G_ON),
    gsSPSetGeometryMode(G_ZBUFFER | G_SHADE | G_SHADING_SMOOTH),
    gsDPSetRenderMode(G_RM_PASS, G_RM_ZB_CLD_SURF2),
    gsSPSetOtherMode(G_SETOTHERMODE_H, G_MDSFT_ALPHADITHER, 18, G_AD_DISABLE | G_CD_DISABLE | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_RGBA16 | G_TL_TILE | G_TD_CLAMP | G_TP_PERSP | G_CYC_2CYCLE | G_PM_NPRIMITIVE),
    gsSPEndDisplayList(),
};

Referenced by spr_appendGfx_component().

SpriteAnimUpdateTimescale

f32 SpriteAnimUpdateTimescale = 1.0f

Definition at line 88 of file sprite.c.

Referenced by spr_component_update_commands(), and spr_set_anim_timescale().

PlayerSpriteSets

PlayerSpriteSet PlayerSpriteSets[]

Initial value:

= {
    [PLAYER_SPRITES_MARIO_WORLD]            {  6, 0x700,   1 << SPR_Mario1   | 1 << SPR_Mario1_Back    | 1 << SPR_MarioW1   | 1 << SPR_MarioW1_Back   | 1 << SPR_MarioW2   | 1 << SPR_MarioW3  },
    [PLAYER_SPRITES_MARIO_REFLECT_FLOOR]    { 18, 0x700,   1 << SPR_Mario1   | 1 << SPR_Mario1_Back    | 1 << SPR_MarioW1   | 1 << SPR_MarioW1_Back   | 1 << SPR_MarioW2   | 1 << SPR_MarioW3  },
    [PLAYER_SPRITES_COMBINED_EPILOGUE]      { 10, 0x900,   1 << SPR_Mario1   | 1 << SPR_Mario1_Back    | 1 << SPR_MarioW1   | 1 << SPR_MarioW1_Back   | 1 << SPR_MarioW2   | 1 << SPR_MarioW3  |  1 << SPR_Peach1   | 1 << SPR_Peach1_Back   | 1 << SPR_Peach2   | 1 << SPR_Peach3  },
    [PLAYER_SPRITES_MARIO_PARADE]           {  3, 0x700,  1 << SPR_Mario1   | 1 << SPR_Mario1_Back  },
    [PLAYER_SPRITES_PEACH_WORLD]            {  6, 0x900,  1 << SPR_Peach1   | 1 << SPR_Peach1_Back   | 1 << SPR_Peach2   | 1 << SPR_Peach3  },
    [PLAYER_SPRITES_MARIO_BATTLE]           {  6, 0x700,   1 << SPR_Mario1   | 1 << SPR_Mario1_Back    | 1 << SPR_MarioB1   | 1 << SPR_MarioB2   | 1 << SPR_MarioB3  },
    [PLAYER_SPRITES_PEACH_BATTLE]           {  6, 0x900,  1 << SPR_Peach1   | 1 << SPR_Peach1_Back   | 1 << SPR_Peach2   | 1 << SPR_Peach3 },
}

Definition at line 115 of file sprite.c.

                                     {
    [PLAYER_SPRITES_MARIO_WORLD]            {  6, 0x700, MARIO_SPRITE_WORLD_BITS },
    [PLAYER_SPRITES_MARIO_REFLECT_FLOOR]    { 18, 0x700, MARIO_SPRITE_WORLD_BITS },
    [PLAYER_SPRITES_COMBINED_EPILOGUE]      { 10, 0x900, MARIO_SPRITE_WORLD_BITS | PEACH_SPRITE_BITS },
    [PLAYER_SPRITES_MARIO_PARADE]           {  3, 0x700, MARIO_SPRITE_COMMON_BITS },
    [PLAYER_SPRITES_PEACH_WORLD]            {  6, 0x900, PEACH_SPRITE_BITS },
    [PLAYER_SPRITES_MARIO_BATTLE]           {  6, 0x700, MARIO_SPRITE_BATTLE_BITS },
    [PLAYER_SPRITES_PEACH_BATTLE]           {  6, 0x900, PEACH_SPRITE_BITS},
};