tbld/tumbledemerald-legacy
1
0
Fork 0
Code Issues 2 Pull Requests Packages Projects Releases 5 Wiki Activity
30da637fa0
tumbledemerald-legacy/gflib/sprite.c

1761 lines
48 KiB
C
Raw Normal View History

import from github
2022-05-19 19:14:13 +02:00
#include "global.h"
#include "sprite.h"
#include "main.h"
#include "palette.h"
#define MAX_SPRITE_COPY_REQUESTS 64
#define OAM_MATRIX_COUNT 32
#define sAnchorX data[6]
#define sAnchorY data[7]
#define SET_SPRITE_TILE_RANGE(index, start, count) \
{ \
sSpriteTileRanges[index * 2] = start; \
(sSpriteTileRanges + 1)[index * 2] = count; \
}
#define ALLOC_SPRITE_TILE(n) \
{ \
sSpriteTileAllocBitmap[(n) / 8] |= (1 << ((n) % 8)); \
}
#define FREE_SPRITE_TILE(n) \
{ \
sSpriteTileAllocBitmap[(n) / 8] &= ~(1 << ((n) % 8)); \
}
#define SPRITE_TILE_IS_ALLOCATED(n) ((sSpriteTileAllocBitmap[(n) / 8] >> ((n) % 8)) & 1)
struct SpriteCopyRequest
{
const u8 *src;
u8 *dest;
u16 size;
};
struct OamDimensions32
{
s32 width;
s32 height;
};
struct OamDimensions
{
s8 width;
s8 height;
};
static void UpdateOamCoords(void);
static void BuildSpritePriorities(void);
static void SortSprites(void);
static void CopyMatricesToOamBuffer(void);
static void AddSpritesToOamBuffer(void);
static u8 CreateSpriteAt(u8 index, const struct SpriteTemplate *template, s16 x, s16 y, u8 subpriority);
static void ResetOamMatrices(void);
static void ResetSprite(struct Sprite *sprite);
static s16 AllocSpriteTiles(u16 tileCount);
static void RequestSpriteFrameImageCopy(u16 index, u16 tileNum, const struct SpriteFrameImage *images);
static void ResetAllSprites(void);
static void BeginAnim(struct Sprite *sprite);
static void ContinueAnim(struct Sprite *sprite);
static void AnimCmd_frame(struct Sprite *sprite);
static void AnimCmd_end(struct Sprite *sprite);
static void AnimCmd_jump(struct Sprite *sprite);
static void AnimCmd_loop(struct Sprite *sprite);
static void BeginAnimLoop(struct Sprite *sprite);
static void ContinueAnimLoop(struct Sprite *sprite);
static void JumpToTopOfAnimLoop(struct Sprite *sprite);
static void BeginAffineAnim(struct Sprite *sprite);
static void ContinueAffineAnim(struct Sprite *sprite);
static void AffineAnimDelay(u8 matrixNum, struct Sprite *sprite);
static void AffineAnimCmd_loop(u8 matrixNum, struct Sprite *sprite);
static void BeginAffineAnimLoop(u8 matrixNum, struct Sprite *sprite);
static void ContinueAffineAnimLoop(u8 matrixNum, struct Sprite *sprite);
static void JumpToTopOfAffineAnimLoop(u8 matrixNum, struct Sprite *sprite);
static void AffineAnimCmd_jump(u8 matrixNum, struct Sprite *sprite);
static void AffineAnimCmd_end(u8 matrixNum, struct Sprite *sprite);
static void AffineAnimCmd_frame(u8 matrixNum, struct Sprite *sprite);
static void CopyOamMatrix(u8 destMatrixIndex, struct OamMatrix *srcMatrix);
static u8 GetSpriteMatrixNum(struct Sprite *sprite);
static void SetSpriteOamFlipBits(struct Sprite *sprite, u8 hFlip, u8 vFlip);
static void AffineAnimStateRestartAnim(u8 matrixNum);
static void AffineAnimStateStartAnim(u8 matrixNum, u8 animNum);
static void AffineAnimStateReset(u8 matrixNum);
static void ApplyAffineAnimFrameAbsolute(u8 matrixNum, struct AffineAnimFrameCmd *frameCmd);
static void DecrementAnimDelayCounter(struct Sprite *sprite);
static bool8 DecrementAffineAnimDelayCounter(struct Sprite *sprite, u8 matrixNum);
static void ApplyAffineAnimFrameRelativeAndUpdateMatrix(u8 matrixNum, struct AffineAnimFrameCmd *frameCmd);
static s16 ConvertScaleParam(s16 scale);
static void GetAffineAnimFrame(u8 matrixNum, struct Sprite *sprite, struct AffineAnimFrameCmd *frameCmd);
static void ApplyAffineAnimFrame(u8 matrixNum, struct AffineAnimFrameCmd *frameCmd);
static u8 IndexOfSpriteTileTag(u16 tag);
static void AllocSpriteTileRange(u16 tag, u16 start, u16 count);
static void DoLoadSpritePalette(const u16 *src, u16 paletteOffset);
static void UpdateSpriteMatrixAnchorPos(struct Sprite* sprite, s32 a1, s32 a2);
typedef void (*AnimFunc)(struct Sprite *);
typedef void (*AnimCmdFunc)(struct Sprite *);
typedef void (*AffineAnimCmdFunc)(u8 matrixNum, struct Sprite *);
#define DUMMY_OAM_DATA \
{ \
.y = DISPLAY_HEIGHT, \
.affineMode = 0, \
.objMode = 0, \
.mosaic = 0, \
.bpp = 0, \
.shape = SPRITE_SHAPE(8x8), \
.x = DISPLAY_WIDTH + 64, \
.matrixNum = 0, \
.size = SPRITE_SIZE(8x8), \
.tileNum = 0, \
.priority = 3, /* lowest priority */ \
.paletteNum = 0, \
.affineParam = 0 \
}
#define ANIM_END 0xFFFF
#define AFFINE_ANIM_END 0x7FFF
// forward declarations
const union AnimCmd * const gDummySpriteAnimTable[];
const union AffineAnimCmd * const gDummySpriteAffineAnimTable[];
const struct SpriteTemplate gDummySpriteTemplate;
// Unreferenced data. Also unreferenced in R/S.
static const u8 sUnknownData[24] =
{
0x01, 0x04, 0x10, 0x40,
0x02, 0x04, 0x08, 0x20,
0x02, 0x04, 0x08, 0x20,
0x01, 0x04, 0x10, 0x40,
0x02, 0x04, 0x08, 0x20,
0x02, 0x04, 0x08, 0x20,
};
static const u8 sCenterToCornerVecTable[3][4][2] =
{
{ // square
{ -4, -4 },
{ -8, -8 },
{ -16, -16 },
{ -32, -32 },
},
{ // horizontal rectangle
{ -8, -4 },
{ -16, -4 },
{ -16, -8 },
{ -32, -16 },
},
{ // vertical rectangle
{ -4, -8 },
{ -4, -16 },
{ -8, -16 },
{ -16, -32 },
},
};
static const struct Sprite sDummySprite =
{
.oam = DUMMY_OAM_DATA,
.anims = gDummySpriteAnimTable,
.affineAnims = gDummySpriteAffineAnimTable,
.template = &gDummySpriteTemplate,
.callback = SpriteCallbackDummy,
.x = DISPLAY_WIDTH + 64,
.y = DISPLAY_HEIGHT,
.subpriority = 0xFF
};
const struct OamData gDummyOamData = DUMMY_OAM_DATA;
static const union AnimCmd sDummyAnim = { ANIM_END };
const union AnimCmd * const gDummySpriteAnimTable[] = { &sDummyAnim };
static const union AffineAnimCmd sDummyAffineAnim = { AFFINE_ANIM_END };
const union AffineAnimCmd * const gDummySpriteAffineAnimTable[] = { &sDummyAffineAnim };
const struct SpriteTemplate gDummySpriteTemplate =
{
.tileTag = 0,
.paletteTag = TAG_NONE,
.oam = &gDummyOamData,
.anims = gDummySpriteAnimTable,
.images = NULL,
.affineAnims = gDummySpriteAffineAnimTable,
.callback = SpriteCallbackDummy
};
static const AnimFunc sAnimFuncs[] =
{
ContinueAnim,
BeginAnim,
};
static const AnimFunc sAffineAnimFuncs[] =
{
ContinueAffineAnim,
BeginAffineAnim,
};
static const AnimCmdFunc sAnimCmdFuncs[] =
{
AnimCmd_loop,
AnimCmd_jump,
AnimCmd_end,
AnimCmd_frame,
};
static const AffineAnimCmdFunc sAffineAnimCmdFuncs[] =
{
AffineAnimCmd_loop,
AffineAnimCmd_jump,
AffineAnimCmd_end,
AffineAnimCmd_frame,
};
static const struct OamDimensions32 sOamDimensions32[3][4] =
{
[ST_OAM_SQUARE] =
{
[SPRITE_SIZE(8x8)] = { 8, 8 },
[SPRITE_SIZE(16x16)] = { 16, 16 },
[SPRITE_SIZE(32x32)] = { 32, 32 },
[SPRITE_SIZE(64x64)] = { 64, 64 },
},
[ST_OAM_H_RECTANGLE] =
{
[SPRITE_SIZE(16x8)] = { 16, 8 },
[SPRITE_SIZE(32x8)] = { 32, 8 },
[SPRITE_SIZE(32x16)] = { 32, 16 },
[SPRITE_SIZE(64x32)] = { 64, 32 },
},
[ST_OAM_V_RECTANGLE] =
{
[SPRITE_SIZE(8x16)] = { 8, 16 },
[SPRITE_SIZE(8x32)] = { 8, 32 },
[SPRITE_SIZE(16x32)] = { 16, 32 },
[SPRITE_SIZE(32x64)] = { 32, 64 },
},
};
static const struct OamDimensions sOamDimensions[3][4] =
{
[ST_OAM_SQUARE] =
{
[SPRITE_SIZE(8x8)] = { 8, 8 },
[SPRITE_SIZE(16x16)] = { 16, 16 },
[SPRITE_SIZE(32x32)] = { 32, 32 },
[SPRITE_SIZE(64x64)] = { 64, 64 },
},
[ST_OAM_H_RECTANGLE] =
{
[SPRITE_SIZE(16x8)] = { 16, 8 },
[SPRITE_SIZE(32x8)] = { 32, 8 },
[SPRITE_SIZE(32x16)] = { 32, 16 },
[SPRITE_SIZE(64x32)] = { 64, 32 },
},
[ST_OAM_V_RECTANGLE] =
{
[SPRITE_SIZE(8x16)] = { 8, 16 },
[SPRITE_SIZE(8x32)] = { 8, 32 },
[SPRITE_SIZE(16x32)] = { 16, 32 },
[SPRITE_SIZE(32x64)] = { 32, 64 },
},
};
// iwram bss
static u16 sSpriteTileRangeTags[MAX_SPRITES];
static u16 sSpriteTileRanges[MAX_SPRITES * 2];
static struct AffineAnimState sAffineAnimStates[OAM_MATRIX_COUNT];
static u16 sSpritePaletteTags[16];
// iwram common
u32 gOamMatrixAllocBitmap;
u8 gReservedSpritePaletteCount;
EWRAM_DATA struct Sprite gSprites[MAX_SPRITES + 1] = {0};
EWRAM_DATA static u16 sSpritePriorities[MAX_SPRITES] = {0};
EWRAM_DATA static u8 sSpriteOrder[MAX_SPRITES] = {0};
EWRAM_DATA static bool8 sShouldProcessSpriteCopyRequests = 0;
EWRAM_DATA static u8 sSpriteCopyRequestCount = 0;
EWRAM_DATA static struct SpriteCopyRequest sSpriteCopyRequests[MAX_SPRITES] = {0};
EWRAM_DATA u8 gOamLimit = 0;
EWRAM_DATA u16 gReservedSpriteTileCount = 0;
EWRAM_DATA static u8 sSpriteTileAllocBitmap[128] = {0};
EWRAM_DATA s16 gSpriteCoordOffsetX = 0;
EWRAM_DATA s16 gSpriteCoordOffsetY = 0;
EWRAM_DATA struct OamMatrix gOamMatrices[OAM_MATRIX_COUNT] = {0};
EWRAM_DATA bool8 gAffineAnimsDisabled = FALSE;
void ResetSpriteData(void)
{
ResetOamRange(0, 128);
ResetAllSprites();
ClearSpriteCopyRequests();
ResetAffineAnimData();
FreeSpriteTileRanges();
gOamLimit = 64;
gReservedSpriteTileCount = 0;
AllocSpriteTiles(0);
gSpriteCoordOffsetX = 0;
gSpriteCoordOffsetY = 0;
}
void AnimateSprites(void)
{
u8 i;
for (i = 0; i < MAX_SPRITES; i++)
{
struct Sprite *sprite = &gSprites[i];
if (sprite->inUse)
{
sprite->callback(sprite);
if (sprite->inUse)
AnimateSprite(sprite);
}
}
}
void BuildOamBuffer(void)
{
u8 temp;
UpdateOamCoords();
BuildSpritePriorities();
SortSprites();
temp = gMain.oamLoadDisabled;
gMain.oamLoadDisabled = TRUE;
AddSpritesToOamBuffer();
CopyMatricesToOamBuffer();
gMain.oamLoadDisabled = temp;
sShouldProcessSpriteCopyRequests = TRUE;
}
void UpdateOamCoords(void)
{
u8 i;
for (i = 0; i < MAX_SPRITES; i++)
{
struct Sprite *sprite = &gSprites[i];
if (sprite->inUse && !sprite->invisible)
{
if (sprite->coordOffsetEnabled)
{
sprite->oam.x = sprite->x + sprite->x2 + sprite->centerToCornerVecX + gSpriteCoordOffsetX;
sprite->oam.y = sprite->y + sprite->y2 + sprite->centerToCornerVecY + gSpriteCoordOffsetY;
}
else
{
sprite->oam.x = sprite->x + sprite->x2 + sprite->centerToCornerVecX;
sprite->oam.y = sprite->y + sprite->y2 + sprite->centerToCornerVecY;
}
}
}
}
void BuildSpritePriorities(void)
{
u16 i;
for (i = 0; i < MAX_SPRITES; i++)
{
struct Sprite *sprite = &gSprites[i];
u16 priority = sprite->subpriority | (sprite->oam.priority << 8);
sSpritePriorities[i] = priority;
}
}
void SortSprites(void)
{
u8 i;
for (i = 1; i < MAX_SPRITES; i++)
{
u8 j = i;
struct Sprite *sprite1 = &gSprites[sSpriteOrder[i - 1]];
struct Sprite *sprite2 = &gSprites[sSpriteOrder[i]];
u16 sprite1Priority = sSpritePriorities[sSpriteOrder[i - 1]];
u16 sprite2Priority = sSpritePriorities[sSpriteOrder[i]];
s16 sprite1Y = sprite1->oam.y;
s16 sprite2Y = sprite2->oam.y;
if (sprite1Y >= DISPLAY_HEIGHT)
sprite1Y = sprite1Y - 256;
if (sprite2Y >= DISPLAY_HEIGHT)
sprite2Y = sprite2Y - 256;
if (sprite1->oam.affineMode == ST_OAM_AFFINE_DOUBLE
&& sprite1->oam.size == ST_OAM_SIZE_3)
{
u32 shape = sprite1->oam.shape;
if (shape == ST_OAM_SQUARE || shape == ST_OAM_V_RECTANGLE)
{
if (sprite1Y > 128)
sprite1Y = sprite1Y - 256;
}
}
if (sprite2->oam.affineMode == ST_OAM_AFFINE_DOUBLE
&& sprite2->oam.size == ST_OAM_SIZE_3)
{
u32 shape = sprite2->oam.shape;
if (shape == ST_OAM_SQUARE || shape == ST_OAM_V_RECTANGLE)
{
if (sprite2Y > 128)
sprite2Y = sprite2Y - 256;
}
}
while (j > 0
&& ((sprite1Priority > sprite2Priority)
|| (sprite1Priority == sprite2Priority && sprite1Y < sprite2Y)))
{
u8 temp = sSpriteOrder[j];
sSpriteOrder[j] = sSpriteOrder[j - 1];
sSpriteOrder[j - 1] = temp;
// UB: If j equals 1, then j-- makes j equal 0.
// Then, sSpriteOrder[-1] gets accessed below.
// Although this doesn't result in a bug in the ROM,
// the behavior is undefined.
j--;
#ifdef UBFIX
if (j == 0)
break;
#endif
sprite1 = &gSprites[sSpriteOrder[j - 1]];
sprite2 = &gSprites[sSpriteOrder[j]];
sprite1Priority = sSpritePriorities[sSpriteOrder[j - 1]];
sprite2Priority = sSpritePriorities[sSpriteOrder[j]];
sprite1Y = sprite1->oam.y;
sprite2Y = sprite2->oam.y;
if (sprite1Y >= DISPLAY_HEIGHT)
sprite1Y = sprite1Y - 256;
if (sprite2Y >= DISPLAY_HEIGHT)
sprite2Y = sprite2Y - 256;
if (sprite1->oam.affineMode == ST_OAM_AFFINE_DOUBLE
&& sprite1->oam.size == ST_OAM_SIZE_3)
{
u32 shape = sprite1->oam.shape;
if (shape == ST_OAM_SQUARE || shape == ST_OAM_V_RECTANGLE)
{
if (sprite1Y > 128)
sprite1Y = sprite1Y - 256;
}
}
if (sprite2->oam.affineMode == ST_OAM_AFFINE_DOUBLE
&& sprite2->oam.size == ST_OAM_SIZE_3)
{
u32 shape = sprite2->oam.shape;
if (shape == ST_OAM_SQUARE || shape == ST_OAM_V_RECTANGLE)
{
if (sprite2Y > 128)
sprite2Y = sprite2Y - 256;
}
}
}
}
}
void CopyMatricesToOamBuffer(void)
{
u8 i;
for (i = 0; i < OAM_MATRIX_COUNT; i++)
{
u32 base = 4 * i;
gMain.oamBuffer[base + 0].affineParam = gOamMatrices[i].a;
gMain.oamBuffer[base + 1].affineParam = gOamMatrices[i].b;
gMain.oamBuffer[base + 2].affineParam = gOamMatrices[i].c;
gMain.oamBuffer[base + 3].affineParam = gOamMatrices[i].d;
}
}
void AddSpritesToOamBuffer(void)
{
u8 i = 0;
u8 oamIndex = 0;
while (i < MAX_SPRITES)
{
struct Sprite *sprite = &gSprites[sSpriteOrder[i]];
if (sprite->inUse && !sprite->invisible && AddSpriteToOamBuffer(sprite, &oamIndex))
return;
i++;
}
while (oamIndex < gOamLimit)
{
gMain.oamBuffer[oamIndex] = gDummyOamData;
oamIndex++;
}
}
u8 CreateSprite(const struct SpriteTemplate *template, s16 x, s16 y, u8 subpriority)
{
u8 i;
for (i = 0; i < MAX_SPRITES; i++)
if (!gSprites[i].inUse)
return CreateSpriteAt(i, template, x, y, subpriority);
return MAX_SPRITES;
}
u8 CreateSpriteAtEnd(const struct SpriteTemplate *template, s16 x, s16 y, u8 subpriority)
{
s16 i;
for (i = MAX_SPRITES - 1; i > -1; i--)
if (!gSprites[i].inUse)
return CreateSpriteAt(i, template, x, y, subpriority);
return MAX_SPRITES;
}
u8 CreateInvisibleSprite(void (*callback)(struct Sprite *))
{
u8 index = CreateSprite(&gDummySpriteTemplate, 0, 0, 31);
if (index == MAX_SPRITES)
{
return MAX_SPRITES;
}
else
{
gSprites[index].invisible = TRUE;
gSprites[index].callback = callback;
return index;
}
}
u8 CreateSpriteAt(u8 index, const struct SpriteTemplate *template, s16 x, s16 y, u8 subpriority)
{
struct Sprite *sprite = &gSprites[index];
ResetSprite(sprite);
sprite->inUse = TRUE;
sprite->animBeginning = TRUE;
sprite->affineAnimBeginning = TRUE;
sprite->usingSheet = TRUE;
sprite->subpriority = subpriority;
sprite->oam = *template->oam;
sprite->anims = template->anims;
sprite->affineAnims = template->affineAnims;
sprite->template = template;
sprite->callback = template->callback;
sprite->x = x;
sprite->y = y;
CalcCenterToCornerVec(sprite, sprite->oam.shape, sprite->oam.size, sprite->oam.affineMode);
if (template->tileTag == TAG_NONE)
{
s16 tileNum;
sprite->images = template->images;
tileNum = AllocSpriteTiles((u8)(sprite->images->size / TILE_SIZE_4BPP));
if (tileNum == -1)
{
ResetSprite(sprite);
return MAX_SPRITES;
}
sprite->oam.tileNum = tileNum;
sprite->usingSheet = FALSE;
sprite->sheetTileStart = 0;
}
else
{
sprite->sheetTileStart = GetSpriteTileStartByTag(template->tileTag);
SetSpriteSheetFrameTileNum(sprite);
}
if (sprite->oam.affineMode & ST_OAM_AFFINE_ON_MASK)
InitSpriteAffineAnim(sprite);
if (template->paletteTag != TAG_NONE)
sprite->oam.paletteNum = IndexOfSpritePaletteTag(template->paletteTag);
return index;
}
u8 CreateSpriteAndAnimate(const struct SpriteTemplate *template, s16 x, s16 y, u8 subpriority)
{
u8 i;
for (i = 0; i < MAX_SPRITES; i++)
{
struct Sprite *sprite = &gSprites[i];
if (!gSprites[i].inUse)
{
u8 index = CreateSpriteAt(i, template, x, y, subpriority);
if (index == MAX_SPRITES)
return MAX_SPRITES;
gSprites[i].callback(sprite);
if (gSprites[i].inUse)
AnimateSprite(sprite);
return index;
}
}
return MAX_SPRITES;
}
void DestroySprite(struct Sprite *sprite)
{
if (sprite->inUse)
{
if (!sprite->usingSheet)
{
u16 i;
u16 tileEnd = (sprite->images->size / TILE_SIZE_4BPP) + sprite->oam.tileNum;
for (i = sprite->oam.tileNum; i < tileEnd; i++)
FREE_SPRITE_TILE(i);
}
ResetSprite(sprite);
}
}
void ResetOamRange(u8 a, u8 b)
{
u8 i;
for (i = a; i < b; i++)
{
gMain.oamBuffer[i] = *(struct OamData *)&gDummyOamData;
}
}
void LoadOam(void)
{
if (!gMain.oamLoadDisabled)
CpuCopy32(gMain.oamBuffer, (void *)OAM, sizeof(gMain.oamBuffer));
}
void ClearSpriteCopyRequests(void)
{
u8 i;
sShouldProcessSpriteCopyRequests = FALSE;
sSpriteCopyRequestCount = 0;
for (i = 0; i < MAX_SPRITE_COPY_REQUESTS; i++)
{
sSpriteCopyRequests[i].src = 0;
sSpriteCopyRequests[i].dest = 0;
sSpriteCopyRequests[i].size = 0;
}
}
void ResetOamMatrices(void)
{
u8 i;
for (i = 0; i < OAM_MATRIX_COUNT; i++)
{
// set to identity matrix
gOamMatrices[i].a = 0x0100;
gOamMatrices[i].b = 0x0000;
gOamMatrices[i].c = 0x0000;
gOamMatrices[i].d = 0x0100;
}
}
void SetOamMatrix(u8 matrixNum, u16 a, u16 b, u16 c, u16 d)
{
gOamMatrices[matrixNum].a = a;
gOamMatrices[matrixNum].b = b;
gOamMatrices[matrixNum].c = c;
gOamMatrices[matrixNum].d = d;
}
void ResetSprite(struct Sprite *sprite)
{
*sprite = sDummySprite;
}
void CalcCenterToCornerVec(struct Sprite *sprite, u8 shape, u8 size, u8 affineMode)
{
u8 x = sCenterToCornerVecTable[shape][size][0];
u8 y = sCenterToCornerVecTable[shape][size][1];
if (affineMode & ST_OAM_AFFINE_DOUBLE_MASK)
{
x *= 2;
y *= 2;
}
sprite->centerToCornerVecX = x;
sprite->centerToCornerVecY = y;
}
s16 AllocSpriteTiles(u16 tileCount)
{
u16 i;
s16 start;
u16 numTilesFound;
if (tileCount == 0)
{
// Free all unreserved tiles if the tile count is 0.
for (i = gReservedSpriteTileCount; i < TOTAL_OBJ_TILE_COUNT; i++)
FREE_SPRITE_TILE(i);
return 0;
}
i = gReservedSpriteTileCount;
for (;;)
{
while (SPRITE_TILE_IS_ALLOCATED(i))
{
i++;
if (i == TOTAL_OBJ_TILE_COUNT)
return -1;
}
start = i;
numTilesFound = 1;
while (numTilesFound != tileCount)
{
i++;
if (i == TOTAL_OBJ_TILE_COUNT)
return -1;
if (!SPRITE_TILE_IS_ALLOCATED(i))
numTilesFound++;
else
break;
}
if (numTilesFound == tileCount)
break;
}
for (i = start; i < tileCount + start; i++)
ALLOC_SPRITE_TILE(i);
return start;
}
u8 SpriteTileAllocBitmapOp(u16 bit, u8 op)
{
u8 index = bit / 8;
u8 shift = bit % 8;
u8 val = bit % 8;
u8 retVal = 0;
if (op == 0)
{
val = ~(1 << val);
sSpriteTileAllocBitmap[index] &= val;
}
else if (op == 1)
{
val = (1 << val);
sSpriteTileAllocBitmap[index] |= val;
}
else
{
retVal = 1 << shift;
retVal &= sSpriteTileAllocBitmap[index];
}
return retVal;
}
void SpriteCallbackDummy(struct Sprite *sprite)
{
}
void ProcessSpriteCopyRequests(void)
{
if (sShouldProcessSpriteCopyRequests)
{
u8 i = 0;
while (sSpriteCopyRequestCount > 0)
{
CpuCopy16(sSpriteCopyRequests[i].src, sSpriteCopyRequests[i].dest, sSpriteCopyRequests[i].size);
sSpriteCopyRequestCount--;
i++;
}
sShouldProcessSpriteCopyRequests = FALSE;
}
}
void RequestSpriteFrameImageCopy(u16 index, u16 tileNum, const struct SpriteFrameImage *images)
{
if (sSpriteCopyRequestCount < MAX_SPRITE_COPY_REQUESTS)
{
sSpriteCopyRequests[sSpriteCopyRequestCount].src = images[index].data;
sSpriteCopyRequests[sSpriteCopyRequestCount].dest = (u8 *)OBJ_VRAM0 + TILE_SIZE_4BPP * tileNum;
sSpriteCopyRequests[sSpriteCopyRequestCount].size = images[index].size;
sSpriteCopyRequestCount++;
}
}
void RequestSpriteCopy(const u8 *src, u8 *dest, u16 size)
{
if (sSpriteCopyRequestCount < MAX_SPRITE_COPY_REQUESTS)
{
sSpriteCopyRequests[sSpriteCopyRequestCount].src = src;
sSpriteCopyRequests[sSpriteCopyRequestCount].dest = dest;
sSpriteCopyRequests[sSpriteCopyRequestCount].size = size;
sSpriteCopyRequestCount++;
}
}
void CopyFromSprites(u8 *dest)
{
u32 i;
u8 *src = (u8 *)gSprites;
for (i = 0; i < sizeof(struct Sprite) * MAX_SPRITES; i++)
{
*dest = *src;
dest++;
src++;
}
}
void CopyToSprites(u8 *src)
{
u32 i;
u8 *dest = (u8 *)gSprites;
for (i = 0; i < sizeof(struct Sprite) * MAX_SPRITES; i++)
{
*dest = *src;
src++;
dest++;
}
}
void ResetAllSprites(void)
{
u8 i;
for (i = 0; i < MAX_SPRITES; i++)
{
ResetSprite(&gSprites[i]);
sSpriteOrder[i] = i;
}
ResetSprite(&gSprites[i]);
}
void FreeSpriteTiles(struct Sprite *sprite)
{
// UB: template pointer may point to freed temporary storage
#ifdef UBFIX
if (!sprite || !sprite->template)
return;
#endif
if (sprite->template->tileTag != TAG_NONE)
FreeSpriteTilesByTag(sprite->template->tileTag);
}
void FreeSpritePalette(struct Sprite *sprite)
{
// UB: template pointer may point to freed temporary storage
#ifdef UBFIX
if (!sprite || !sprite->template)
return;
#endif
FreeSpritePaletteByTag(sprite->template->paletteTag);
}
void FreeSpriteOamMatrix(struct Sprite *sprite)
{
if (sprite->oam.affineMode & ST_OAM_AFFINE_ON_MASK)
{
FreeOamMatrix(sprite->oam.matrixNum);
sprite->oam.affineMode = ST_OAM_AFFINE_OFF;
}
}
void DestroySpriteAndFreeResources(struct Sprite *sprite)
{
FreeSpriteTiles(sprite);
FreeSpritePalette(sprite);
FreeSpriteOamMatrix(sprite);
DestroySprite(sprite);
}
void AnimateSprite(struct Sprite *sprite)
{
sAnimFuncs[sprite->animBeginning](sprite);
if (!gAffineAnimsDisabled)
sAffineAnimFuncs[sprite->affineAnimBeginning](sprite);
}
void BeginAnim(struct Sprite *sprite)
{
s16 imageValue;
u8 duration;
u8 hFlip;
u8 vFlip;
sprite->animCmdIndex = 0;
sprite->animEnded = FALSE;
sprite->animLoopCounter = 0;
imageValue = sprite->anims[sprite->animNum][sprite->animCmdIndex].frame.imageValue;
if (imageValue != -1)
{
sprite->animBeginning = FALSE;
duration = sprite->anims[sprite->animNum][sprite->animCmdIndex].frame.duration;
hFlip = sprite->anims[sprite->animNum][sprite->animCmdIndex].frame.hFlip;
vFlip = sprite->anims[sprite->animNum][sprite->animCmdIndex].frame.vFlip;
if (duration)
duration--;
sprite->animDelayCounter = duration;
if (!(sprite->oam.affineMode & ST_OAM_AFFINE_ON_MASK))
SetSpriteOamFlipBits(sprite, hFlip, vFlip);
if (sprite->usingSheet)
sprite->oam.tileNum = sprite->sheetTileStart + imageValue;
else
RequestSpriteFrameImageCopy(imageValue, sprite->oam.tileNum, sprite->images);
}
}
void ContinueAnim(struct Sprite *sprite)
{
if (sprite->animDelayCounter)
{
u8 hFlip;
u8 vFlip;
DecrementAnimDelayCounter(sprite);
hFlip = sprite->anims[sprite->animNum][sprite->animCmdIndex].frame.hFlip;
vFlip = sprite->anims[sprite->animNum][sprite->animCmdIndex].frame.vFlip;
if (!(sprite->oam.affineMode & ST_OAM_AFFINE_ON_MASK))
SetSpriteOamFlipBits(sprite, hFlip, vFlip);
}
else if (!sprite->animPaused)
{
s16 type;
s16 funcIndex;
sprite->animCmdIndex++;
type = sprite->anims[sprite->animNum][sprite->animCmdIndex].type;
funcIndex = 3;
if (type < 0)
funcIndex = type + 3;
sAnimCmdFuncs[funcIndex](sprite);
}
}
void AnimCmd_frame(struct Sprite *sprite)
{
s16 imageValue;
u8 duration;
u8 hFlip;
u8 vFlip;
imageValue = sprite->anims[sprite->animNum][sprite->animCmdIndex].frame.imageValue;
duration = sprite->anims[sprite->animNum][sprite->animCmdIndex].frame.duration;
hFlip = sprite->anims[sprite->animNum][sprite->animCmdIndex].frame.hFlip;
vFlip = sprite->anims[sprite->animNum][sprite->animCmdIndex].frame.vFlip;
if (duration)
duration--;
sprite->animDelayCounter = duration;
if (!(sprite->oam.affineMode & ST_OAM_AFFINE_ON_MASK))
SetSpriteOamFlipBits(sprite, hFlip, vFlip);
if (sprite->usingSheet)
sprite->oam.tileNum = sprite->sheetTileStart + imageValue;
else
RequestSpriteFrameImageCopy(imageValue, sprite->oam.tileNum, sprite->images);
}
void AnimCmd_end(struct Sprite *sprite)
{
sprite->animCmdIndex--;
sprite->animEnded = TRUE;
}
void AnimCmd_jump(struct Sprite *sprite)
{
s16 imageValue;
u8 duration;
u8 hFlip;
u8 vFlip;
sprite->animCmdIndex = sprite->anims[sprite->animNum][sprite->animCmdIndex].jump.target;
imageValue = sprite->anims[sprite->animNum][sprite->animCmdIndex].frame.imageValue;
duration = sprite->anims[sprite->animNum][sprite->animCmdIndex].frame.duration;
hFlip = sprite->anims[sprite->animNum][sprite->animCmdIndex].frame.hFlip;
vFlip = sprite->anims[sprite->animNum][sprite->animCmdIndex].frame.vFlip;
if (duration)
duration--;
sprite->animDelayCounter = duration;
if (!(sprite->oam.affineMode & ST_OAM_AFFINE_ON_MASK))
SetSpriteOamFlipBits(sprite, hFlip, vFlip);
if (sprite->usingSheet)
sprite->oam.tileNum = sprite->sheetTileStart + imageValue;
else
RequestSpriteFrameImageCopy(imageValue, sprite->oam.tileNum, sprite->images);
}
void AnimCmd_loop(struct Sprite *sprite)
{
if (sprite->animLoopCounter)
ContinueAnimLoop(sprite);
else
BeginAnimLoop(sprite);
}
void BeginAnimLoop(struct Sprite *sprite)
{
sprite->animLoopCounter = sprite->anims[sprite->animNum][sprite->animCmdIndex].loop.count;
JumpToTopOfAnimLoop(sprite);
ContinueAnim(sprite);
}
void ContinueAnimLoop(struct Sprite *sprite)
{
sprite->animLoopCounter--;
JumpToTopOfAnimLoop(sprite);
ContinueAnim(sprite);
}
void JumpToTopOfAnimLoop(struct Sprite *sprite)
{
if (sprite->animLoopCounter)
{
sprite->animCmdIndex--;
while (sprite->anims[sprite->animNum][sprite->animCmdIndex - 1].type != -3)
{
if (sprite->animCmdIndex == 0)
break;
sprite->animCmdIndex--;
}
sprite->animCmdIndex--;
}
}
void BeginAffineAnim(struct Sprite *sprite)
{
if ((sprite->oam.affineMode & ST_OAM_AFFINE_ON_MASK) && sprite->affineAnims[0][0].type != 32767)
{
struct AffineAnimFrameCmd frameCmd;
u8 matrixNum = GetSpriteMatrixNum(sprite);
AffineAnimStateRestartAnim(matrixNum);
GetAffineAnimFrame(matrixNum, sprite, &frameCmd);
sprite->affineAnimBeginning = FALSE;
sprite->affineAnimEnded = FALSE;
ApplyAffineAnimFrame(matrixNum, &frameCmd);
sAffineAnimStates[matrixNum].delayCounter = frameCmd.duration;
if (sprite->anchored)
UpdateSpriteMatrixAnchorPos(sprite, sprite->sAnchorX, sprite->sAnchorY);
}
}
void ContinueAffineAnim(struct Sprite *sprite)
{
if (sprite->oam.affineMode & ST_OAM_AFFINE_ON_MASK)
{
u8 matrixNum = GetSpriteMatrixNum(sprite);
if (sAffineAnimStates[matrixNum].delayCounter)
AffineAnimDelay(matrixNum, sprite);
else if (sprite->affineAnimPaused)
return;
else
{
s16 type;
s16 funcIndex;
sAffineAnimStates[matrixNum].animCmdIndex++;
type = sprite->affineAnims[sAffineAnimStates[matrixNum].animNum][sAffineAnimStates[matrixNum].animCmdIndex].type;
funcIndex = 3;
if (type >= 32765)
funcIndex = type - 32765;
sAffineAnimCmdFuncs[funcIndex](matrixNum, sprite);
}
if (sprite->anchored)
UpdateSpriteMatrixAnchorPos(sprite, sprite->sAnchorX, sprite->sAnchorY);
}
}
void AffineAnimDelay(u8 matrixNum, struct Sprite *sprite)
{
if (!DecrementAffineAnimDelayCounter(sprite, matrixNum))
{
struct AffineAnimFrameCmd frameCmd;
GetAffineAnimFrame(matrixNum, sprite, &frameCmd);
ApplyAffineAnimFrameRelativeAndUpdateMatrix(matrixNum, &frameCmd);
}
}
void AffineAnimCmd_loop(u8 matrixNum, struct Sprite *sprite)
{
if (sAffineAnimStates[matrixNum].loopCounter)
ContinueAffineAnimLoop(matrixNum, sprite);
else
BeginAffineAnimLoop(matrixNum, sprite);
}
void BeginAffineAnimLoop(u8 matrixNum, struct Sprite *sprite)
{
sAffineAnimStates[matrixNum].loopCounter = sprite->affineAnims[sAffineAnimStates[matrixNum].animNum][sAffineAnimStates[matrixNum].animCmdIndex].loop.count;
JumpToTopOfAffineAnimLoop(matrixNum, sprite);
ContinueAffineAnim(sprite);
}
void ContinueAffineAnimLoop(u8 matrixNum, struct Sprite *sprite)
{
sAffineAnimStates[matrixNum].loopCounter--;
JumpToTopOfAffineAnimLoop(matrixNum, sprite);
ContinueAffineAnim(sprite);
}
void JumpToTopOfAffineAnimLoop(u8 matrixNum, struct Sprite *sprite)
{
if (sAffineAnimStates[matrixNum].loopCounter)
{
sAffineAnimStates[matrixNum].animCmdIndex--;
while (sprite->affineAnims[sAffineAnimStates[matrixNum].animNum][sAffineAnimStates[matrixNum].animCmdIndex - 1].type != 32765)
{
if (sAffineAnimStates[matrixNum].animCmdIndex == 0)
break;
sAffineAnimStates[matrixNum].animCmdIndex--;
}
sAffineAnimStates[matrixNum].animCmdIndex--;
}
}
void AffineAnimCmd_jump(u8 matrixNum, struct Sprite *sprite)
{
struct AffineAnimFrameCmd frameCmd;
sAffineAnimStates[matrixNum].animCmdIndex = sprite->affineAnims[sAffineAnimStates[matrixNum].animNum][sAffineAnimStates[matrixNum].animCmdIndex].jump.target;
GetAffineAnimFrame(matrixNum, sprite, &frameCmd);
ApplyAffineAnimFrame(matrixNum, &frameCmd);
sAffineAnimStates[matrixNum].delayCounter = frameCmd.duration;
}
void AffineAnimCmd_end(u8 matrixNum, struct Sprite *sprite)
{
struct AffineAnimFrameCmd dummyFrameCmd = {0};
sprite->affineAnimEnded = TRUE;
sAffineAnimStates[matrixNum].animCmdIndex--;
ApplyAffineAnimFrameRelativeAndUpdateMatrix(matrixNum, &dummyFrameCmd);
}
void AffineAnimCmd_frame(u8 matrixNum, struct Sprite *sprite)
{
struct AffineAnimFrameCmd frameCmd;
GetAffineAnimFrame(matrixNum, sprite, &frameCmd);
ApplyAffineAnimFrame(matrixNum, &frameCmd);
sAffineAnimStates[matrixNum].delayCounter = frameCmd.duration;
}
void CopyOamMatrix(u8 destMatrixIndex, struct OamMatrix *srcMatrix)
{
gOamMatrices[destMatrixIndex].a = srcMatrix->a;
gOamMatrices[destMatrixIndex].b = srcMatrix->b;
gOamMatrices[destMatrixIndex].c = srcMatrix->c;
gOamMatrices[destMatrixIndex].d = srcMatrix->d;
}
u8 GetSpriteMatrixNum(struct Sprite *sprite)
{
u8 matrixNum = 0;
if (sprite->oam.affineMode & ST_OAM_AFFINE_ON_MASK)
matrixNum = sprite->oam.matrixNum;
return matrixNum;
}
// Used to shift a sprite's position as it scales.
// Only used by the minigame countdown, so that for instance the numbers don't slide up as they squish down before jumping.
void SetSpriteMatrixAnchor(struct Sprite* sprite, s16 x, s16 y)
{
sprite->sAnchorX = x;
sprite->sAnchorY = y;
sprite->anchored = TRUE;
}
static s32 GetAnchorCoord(s32 a0, s32 a1, s32 coord)
{
s32 subResult, var1;
subResult = a1 - a0;
if (subResult < 0)
var1 = -(subResult) >> 9;
else
var1 = -(subResult >> 9);
return coord - ((u32)(coord * a1) / (u32)(a0) + var1);
}
static void UpdateSpriteMatrixAnchorPos(struct Sprite *sprite, s32 x, s32 y)
{
s32 dimension, var1, var2;
u32 matrixNum = sprite->oam.matrixNum;
if (x != NO_ANCHOR)
{
dimension = sOamDimensions32[sprite->oam.shape][sprite->oam.size].width;
var1 = dimension << 8;
var2 = (dimension << 16) / gOamMatrices[matrixNum].a;
sprite->x2 = GetAnchorCoord(var1, var2, x);
}
if (y != NO_ANCHOR)
{
dimension = sOamDimensions32[sprite->oam.shape][sprite->oam.size].height;
var1 = dimension << 8;
var2 = (dimension << 16) / gOamMatrices[matrixNum].d;
sprite->y2 = GetAnchorCoord(var1, var2, y);
}
}
void SetSpriteOamFlipBits(struct Sprite *sprite, u8 hFlip, u8 vFlip)
{
sprite->oam.matrixNum &= 0x7;
sprite->oam.matrixNum |= (((hFlip ^ sprite->hFlip) & 1) << 3);
sprite->oam.matrixNum |= (((vFlip ^ sprite->vFlip) & 1) << 4);
}
void AffineAnimStateRestartAnim(u8 matrixNum)
{
sAffineAnimStates[matrixNum].animCmdIndex = 0;
sAffineAnimStates[matrixNum].delayCounter = 0;
sAffineAnimStates[matrixNum].loopCounter = 0;
}
void AffineAnimStateStartAnim(u8 matrixNum, u8 animNum)
{
sAffineAnimStates[matrixNum].animNum = animNum;
sAffineAnimStates[matrixNum].animCmdIndex = 0;
sAffineAnimStates[matrixNum].delayCounter = 0;
sAffineAnimStates[matrixNum].loopCounter = 0;
sAffineAnimStates[matrixNum].xScale = 0x0100;
sAffineAnimStates[matrixNum].yScale = 0x0100;
sAffineAnimStates[matrixNum].rotation = 0;
}
void AffineAnimStateReset(u8 matrixNum)
{
sAffineAnimStates[matrixNum].animNum = 0;
sAffineAnimStates[matrixNum].animCmdIndex = 0;
sAffineAnimStates[matrixNum].delayCounter = 0;
sAffineAnimStates[matrixNum].loopCounter = 0;
sAffineAnimStates[matrixNum].xScale = 0x0100;
sAffineAnimStates[matrixNum].yScale = 0x0100;
sAffineAnimStates[matrixNum].rotation = 0;
}
void ApplyAffineAnimFrameAbsolute(u8 matrixNum, struct AffineAnimFrameCmd *frameCmd)
{
sAffineAnimStates[matrixNum].xScale = frameCmd->xScale;
sAffineAnimStates[matrixNum].yScale = frameCmd->yScale;
sAffineAnimStates[matrixNum].rotation = frameCmd->rotation << 8;
}
void DecrementAnimDelayCounter(struct Sprite *sprite)
{
if (!sprite->animPaused)
sprite->animDelayCounter--;
}
bool8 DecrementAffineAnimDelayCounter(struct Sprite *sprite, u8 matrixNum)
{
if (!sprite->affineAnimPaused)
--sAffineAnimStates[matrixNum].delayCounter;
return sprite->affineAnimPaused;
}
void ApplyAffineAnimFrameRelativeAndUpdateMatrix(u8 matrixNum, struct AffineAnimFrameCmd *frameCmd)
{
struct ObjAffineSrcData srcData;
struct OamMatrix matrix;
sAffineAnimStates[matrixNum].xScale += frameCmd->xScale;
sAffineAnimStates[matrixNum].yScale += frameCmd->yScale;
sAffineAnimStates[matrixNum].rotation = (sAffineAnimStates[matrixNum].rotation + (frameCmd->rotation << 8)) & ~0xFF;
srcData.xScale = ConvertScaleParam(sAffineAnimStates[matrixNum].xScale);
srcData.yScale = ConvertScaleParam(sAffineAnimStates[matrixNum].yScale);
srcData.rotation = sAffineAnimStates[matrixNum].rotation;
ObjAffineSet(&srcData, &matrix, 1, 2);
CopyOamMatrix(matrixNum, &matrix);
}
s16 ConvertScaleParam(s16 scale)
{
s32 val = 0x10000;
return SAFE_DIV(val, scale);
}
void GetAffineAnimFrame(u8 matrixNum, struct Sprite *sprite, struct AffineAnimFrameCmd *frameCmd)
{
frameCmd->xScale = sprite->affineAnims[sAffineAnimStates[matrixNum].animNum][sAffineAnimStates[matrixNum].animCmdIndex].frame.xScale;
frameCmd->yScale = sprite->affineAnims[sAffineAnimStates[matrixNum].animNum][sAffineAnimStates[matrixNum].animCmdIndex].frame.yScale;
frameCmd->rotation = sprite->affineAnims[sAffineAnimStates[matrixNum].animNum][sAffineAnimStates[matrixNum].animCmdIndex].frame.rotation;
frameCmd->duration = sprite->affineAnims[sAffineAnimStates[matrixNum].animNum][sAffineAnimStates[matrixNum].animCmdIndex].frame.duration;
}
void ApplyAffineAnimFrame(u8 matrixNum, struct AffineAnimFrameCmd *frameCmd)
{
struct AffineAnimFrameCmd dummyFrameCmd = {0};
if (frameCmd->duration)
{
frameCmd->duration--;
ApplyAffineAnimFrameRelativeAndUpdateMatrix(matrixNum, frameCmd);
}
else
{
ApplyAffineAnimFrameAbsolute(matrixNum, frameCmd);
ApplyAffineAnimFrameRelativeAndUpdateMatrix(matrixNum, &dummyFrameCmd);
}
}
void StartSpriteAnim(struct Sprite *sprite, u8 animNum)
{
sprite->animNum = animNum;
sprite->animBeginning = TRUE;
sprite->animEnded = FALSE;
}
void StartSpriteAnimIfDifferent(struct Sprite *sprite, u8 animNum)
{
if (sprite->animNum != animNum)
StartSpriteAnim(sprite, animNum);
}
void SeekSpriteAnim(struct Sprite *sprite, u8 animCmdIndex)
{
u8 temp = sprite->animPaused;
sprite->animCmdIndex = animCmdIndex - 1;
sprite->animDelayCounter = 0;
sprite->animBeginning = FALSE;
sprite->animEnded = FALSE;
sprite->animPaused = FALSE;
ContinueAnim(sprite);
if (sprite->animDelayCounter)
sprite->animDelayCounter++;
sprite->animPaused = temp;
}
void StartSpriteAffineAnim(struct Sprite *sprite, u8 animNum)
{
u8 matrixNum = GetSpriteMatrixNum(sprite);
AffineAnimStateStartAnim(matrixNum, animNum);
sprite->affineAnimBeginning = TRUE;
sprite->affineAnimEnded = FALSE;
}
void StartSpriteAffineAnimIfDifferent(struct Sprite *sprite, u8 animNum)
{
u8 matrixNum = GetSpriteMatrixNum(sprite);
if (sAffineAnimStates[matrixNum].animNum != animNum)
StartSpriteAffineAnim(sprite, animNum);
}
void ChangeSpriteAffineAnim(struct Sprite *sprite, u8 animNum)
{
u8 matrixNum = GetSpriteMatrixNum(sprite);
sAffineAnimStates[matrixNum].animNum = animNum;
sprite->affineAnimBeginning = TRUE;
sprite->affineAnimEnded = FALSE;
}
void ChangeSpriteAffineAnimIfDifferent(struct Sprite *sprite, u8 animNum)
{
u8 matrixNum = GetSpriteMatrixNum(sprite);
if (sAffineAnimStates[matrixNum].animNum != animNum)
ChangeSpriteAffineAnim(sprite, animNum);
}
void SetSpriteSheetFrameTileNum(struct Sprite *sprite)
{
if (sprite->usingSheet)
{
s16 tileOffset = sprite->anims[sprite->animNum][sprite->animCmdIndex].frame.imageValue;
if (tileOffset < 0)
tileOffset = 0;
sprite->oam.tileNum = sprite->sheetTileStart + tileOffset;
}
}
void ResetAffineAnimData(void)
{
u8 i;
gAffineAnimsDisabled = FALSE;
gOamMatrixAllocBitmap = 0;
ResetOamMatrices();
for (i = 0; i < OAM_MATRIX_COUNT; i++)
AffineAnimStateReset(i);
}
u8 AllocOamMatrix(void)
{
u8 i = 0;
u32 bit = 1;
u32 bitmap = gOamMatrixAllocBitmap;
while (i < OAM_MATRIX_COUNT)
{
if (!(bitmap & bit))
{
gOamMatrixAllocBitmap |= bit;
return i;
}
i++;
bit <<= 1;
}
return 0xFF;
}
void FreeOamMatrix(u8 matrixNum)
{
u8 i = 0;
u32 bit = 1;
while (i < matrixNum)
{
i++;
bit <<= 1;
}
gOamMatrixAllocBitmap &= ~bit;
SetOamMatrix(matrixNum, 0x100, 0, 0, 0x100);
}
void InitSpriteAffineAnim(struct Sprite *sprite)
{
u8 matrixNum = AllocOamMatrix();
if (matrixNum != 0xFF)
{
CalcCenterToCornerVec(sprite, sprite->oam.shape, sprite->oam.size, sprite->oam.affineMode);
sprite->oam.matrixNum = matrixNum;
sprite->affineAnimBeginning = TRUE;
AffineAnimStateReset(matrixNum);
}
}
void SetOamMatrixRotationScaling(u8 matrixNum, s16 xScale, s16 yScale, u16 rotation)
{
struct ObjAffineSrcData srcData;
struct OamMatrix matrix;
srcData.xScale = ConvertScaleParam(xScale);
srcData.yScale = ConvertScaleParam(yScale);
srcData.rotation = rotation;
ObjAffineSet(&srcData, &matrix, 1, 2);
CopyOamMatrix(matrixNum, &matrix);
}
u16 LoadSpriteSheet(const struct SpriteSheet *sheet)
{
s16 tileStart = AllocSpriteTiles(sheet->size / TILE_SIZE_4BPP);
if (tileStart < 0)
{
return 0;
}
else
{
AllocSpriteTileRange(sheet->tag, (u16)tileStart, sheet->size / TILE_SIZE_4BPP);
CpuCopy16(sheet->data, (u8 *)OBJ_VRAM0 + TILE_SIZE_4BPP * tileStart, sheet->size);
return (u16)tileStart;
}
}
void LoadSpriteSheets(const struct SpriteSheet *sheets)
{
u8 i;
for (i = 0; sheets[i].data != NULL; i++)
LoadSpriteSheet(&sheets[i]);
}
void FreeSpriteTilesByTag(u16 tag)
{
u8 index = IndexOfSpriteTileTag(tag);
if (index != 0xFF)
{
u16 i;
u16 *rangeStarts;
u16 *rangeCounts;
u16 start;
u16 count;
rangeStarts = sSpriteTileRanges;
start = rangeStarts[index * 2];
rangeCounts = sSpriteTileRanges + 1;
count = rangeCounts[index * 2];
for (i = start; i < start + count; i++)
FREE_SPRITE_TILE(i);
sSpriteTileRangeTags[index] = TAG_NONE;
}
}
void FreeSpriteTileRanges(void)
{
u8 i;
for (i = 0; i < MAX_SPRITES; i++)
{
sSpriteTileRangeTags[i] = TAG_NONE;
SET_SPRITE_TILE_RANGE(i, 0, 0);
}
}
u16 GetSpriteTileStartByTag(u16 tag)
{
u8 index = IndexOfSpriteTileTag(tag);
if (index == 0xFF)
return 0xFFFF;
return sSpriteTileRanges[index * 2];
}
u8 IndexOfSpriteTileTag(u16 tag)
{
u8 i;
for (i = 0; i < MAX_SPRITES; i++)
if (sSpriteTileRangeTags[i] == tag)
return i;
return 0xFF;
}
u16 GetSpriteTileTagByTileStart(u16 start)
{
u8 i;
for (i = 0; i < MAX_SPRITES; i++)
{
if (sSpriteTileRangeTags[i] != TAG_NONE && sSpriteTileRanges[i * 2] == start)
return sSpriteTileRangeTags[i];
}
return TAG_NONE;
}
void AllocSpriteTileRange(u16 tag, u16 start, u16 count)
{
u8 freeIndex = IndexOfSpriteTileTag(TAG_NONE);
sSpriteTileRangeTags[freeIndex] = tag;
SET_SPRITE_TILE_RANGE(freeIndex, start, count);
}
void FreeAllSpritePalettes(void)
{
u8 i;
gReservedSpritePaletteCount = 0;
for (i = 0; i < 16; i++)
sSpritePaletteTags[i] = TAG_NONE;
}
u8 LoadSpritePalette(const struct SpritePalette *palette)
{
u8 index = IndexOfSpritePaletteTag(palette->tag);
if (index != 0xFF)
return index;
index = IndexOfSpritePaletteTag(TAG_NONE);
if (index == 0xFF)
{
return 0xFF;
}
else
{
sSpritePaletteTags[index] = palette->tag;
DoLoadSpritePalette(palette->data, index * 16);
return index;
}
}
void LoadSpritePalettes(const struct SpritePalette *palettes)
{
u8 i;
for (i = 0; palettes[i].data != NULL; i++)
if (LoadSpritePalette(&palettes[i]) == 0xFF)
break;
}
void DoLoadSpritePalette(const u16 *src, u16 paletteOffset)
{
LoadPalette(src, paletteOffset + 0x100, 32);
}
u8 AllocSpritePalette(u16 tag)
{
u8 index = IndexOfSpritePaletteTag(TAG_NONE);
if (index == 0xFF)
{
return 0xFF;
}
else
{
sSpritePaletteTags[index] = tag;
return index;
}
}
u8 IndexOfSpritePaletteTag(u16 tag)
{
u8 i;
for (i = gReservedSpritePaletteCount; i < 16; i++)
if (sSpritePaletteTags[i] == tag)
return i;
return 0xFF;
}
u16 GetSpritePaletteTagByPaletteNum(u8 paletteNum)
{
return sSpritePaletteTags[paletteNum];
}
void FreeSpritePaletteByTag(u16 tag)
{
u8 index = IndexOfSpritePaletteTag(tag);
if (index != 0xFF)
sSpritePaletteTags[index] = TAG_NONE;
}
void SetSubspriteTables(struct Sprite *sprite, const struct SubspriteTable *subspriteTables)
{
sprite->subspriteTables = subspriteTables;
sprite->subspriteTableNum = 0;
sprite->subspriteMode = SUBSPRITES_ON;
}
bool8 AddSpriteToOamBuffer(struct Sprite *sprite, u8 *oamIndex)
{
if (*oamIndex >= gOamLimit)
return 1;
if (!sprite->subspriteTables || sprite->subspriteMode == SUBSPRITES_OFF)
{
gMain.oamBuffer[*oamIndex] = sprite->oam;
(*oamIndex)++;
return 0;
}
else
{
return AddSubspritesToOamBuffer(sprite, &gMain.oamBuffer[*oamIndex], oamIndex);
}
}
bool8 AddSubspritesToOamBuffer(struct Sprite *sprite, struct OamData *destOam, u8 *oamIndex)
{
const struct SubspriteTable *subspriteTable;
struct OamData *oam;
if (*oamIndex >= gOamLimit)
return 1;
subspriteTable = &sprite->subspriteTables[sprite->subspriteTableNum];
oam = &sprite->oam;
if (!subspriteTable || !subspriteTable->subsprites)
{
*destOam = *oam;
(*oamIndex)++;
return 0;
}
else
{
u16 tileNum;
u16 baseX;
u16 baseY;
u8 subspriteCount;
u8 hFlip;
u8 vFlip;
u8 i;
tileNum = oam->tileNum;
subspriteCount = subspriteTable->subspriteCount;
hFlip = ((s32)oam->matrixNum >> 3) & 1;
vFlip = ((s32)oam->matrixNum >> 4) & 1;
baseX = oam->x - sprite->centerToCornerVecX;
baseY = oam->y - sprite->centerToCornerVecY;
for (i = 0; i < subspriteCount; i++, (*oamIndex)++)
{
u16 x;
u16 y;
if (*oamIndex >= gOamLimit)
return 1;
x = subspriteTable->subsprites[i].x;
y = subspriteTable->subsprites[i].y;
if (hFlip)
{
s8 width = sOamDimensions[subspriteTable->subsprites[i].shape][subspriteTable->subsprites[i].size].width;
s16 right = x;
right += width;
x = right;
x = ~x + 1;
}
if (vFlip)
{
s8 height = sOamDimensions[subspriteTable->subsprites[i].shape][subspriteTable->subsprites[i].size].height;
s16 bottom = y;
bottom += height;
y = bottom;
y = ~y + 1;
}
destOam[i] = *oam;
destOam[i].shape = subspriteTable->subsprites[i].shape;
destOam[i].size = subspriteTable->subsprites[i].size;
destOam[i].x = (s16)baseX + (s16)x;
destOam[i].y = baseY + y;
destOam[i].tileNum = tileNum + subspriteTable->subsprites[i].tileOffset;
if (sprite->subspriteMode != SUBSPRITES_IGNORE_PRIORITY)
destOam[i].priority = subspriteTable->subsprites[i].priority;
}
}
return 0;
}
Reference in New Issue Copy Permalink