diff options
Diffstat (limited to 'arm9/src')
| -rw-r--r-- | arm9/src/palette.c | 760 | ||||
| -rw-r--r-- | arm9/src/unk_02002F08.c | 51 |
2 files changed, 786 insertions, 25 deletions
diff --git a/arm9/src/palette.c b/arm9/src/palette.c new file mode 100644 index 00000000..525574e7 --- /dev/null +++ b/arm9/src/palette.c @@ -0,0 +1,760 @@ +#include "global.h" +#include "palette.h" +#include "MI_memory.h" +#include "unk_02002F08.h" +#include "unk_0200CA44.h" + +extern void *FUN_020222E8(); +extern void *FUN_020222F8(); +extern void *FUN_02022308(); +extern void *FUN_02022310(); +extern int abs(int); + +THUMB_FUNC void FUN_02003108(struct PaletteData *paletteData, u32 index, u16 offset, u32 size) +{ + GF_ASSERT(offset * 2 + size <= paletteData->pltt[index].bufSize); + + u16 *ptr; + switch (index) + { + case 0: + ptr = FUN_020222E8(); + break; + case 1: + ptr = FUN_020222F8(); + break; + case 2: + ptr = FUN_02022308(); + break; + case 3: + ptr = FUN_02022310(); + break; + default: + GF_ASSERT(FALSE); + return; + } + + PaletteData_LoadPalette(paletteData, ptr + offset, index, offset, (u16)size); +} + +THUMB_FUNC void CopyPaletteFromNarc( + NarcId narcId, s32 memberId, u32 heap_id, u32 size, u16 offset, void *dest) +{ + NNSG2dPaletteData *pltData; + + void *ptr = GfGfxLoader_GetPlttData(narcId, memberId, &pltData, heap_id); + GF_ASSERT(ptr != NULL); + + if (size == 0) + { + size = pltData->szByte; + } + + MI_CpuCopy16(pltData->pRawData + offset * 2, dest, size); + + FreeToHeap(ptr); +} + +THUMB_FUNC void PaletteData_CopyPalette(struct PaletteData *paletteData, + u32 srcIdx, + u16 srcOffset, + u32 destIdx, + u16 destOffset, + u16 size) +{ + + MI_CpuCopy16(paletteData->pltt[srcIdx].unfadedBuf + srcOffset, + paletteData->pltt[destIdx].unfadedBuf + destOffset, + size); + MI_CpuCopy16(paletteData->pltt[srcIdx].unfadedBuf + srcOffset, + paletteData->pltt[destIdx].fadedBuf + destOffset, + size); +} + +THUMB_FUNC u16 *PaletteData_GetUnfadedBuf(struct PaletteData *paletteData, u32 index) +{ + return paletteData->pltt[index].unfadedBuf; +} + +THUMB_FUNC u16 *PaletteData_GetFadedBuf(struct PaletteData *paletteData, u32 index) +{ + return paletteData->pltt[index].fadedBuf; +} + +THUMB_FUNC u32 FUN_02003210(struct PaletteData *paletteData, + u16 param1, + u16 param2, + s16 delay, + u8 startY, + u8 targetY, + u16 color) +{ + + u16 stc = param2; + u32 r6 = 0; + + for (u8 i = 0; i < 14; i++) + { + if (IsPaletteSelected(param1, i) != 1) + { + continue; + } + + if (IsPaletteSelected(paletteData->activeFadePalettes, i) != 0) + { + continue; + } + + FUN_02003368(i, &paletteData->pltt[i], ¶m2); + + FUN_020033A4(&paletteData->pltt[i].fadeCtrl, param2, delay, startY, targetY, color); + + FUN_02003328(paletteData, i); + + if (i >= 4) + { + FUN_0200359C(paletteData, i, 0x100); + } + else + { + FUN_0200359C(paletteData, i, 0x10); + } + + param2 = stc; + r6 = 1; + } + + if (r6 == 1) + { + paletteData->activeFadePalettes |= param1; + if (paletteData->unk11a_e == 0) + { + paletteData->unk11a_e = 1; + + paletteData->unk118_0 = 1; + paletteData->unk11c = 0; + + // wtf is that? + FUN_0200CA44((void (*)(u32, struct TextPrinter *))FUN_02003464, + (struct TextPrinter *)paletteData, + (u32)(-2)); + } + } + + return r6; +} + +THUMB_FUNC u8 IsPaletteSelected(u16 selectedPalettes, u16 index) +{ + u32 r3 = 1; + if ((selectedPalettes & (1 << index)) == 0) + { + r3 = 0; + } + + return (u8)r3; +} + +THUMB_FUNC void FUN_02003328(struct PaletteData *param0, u16 param1) +{ + if (IsPaletteSelected(param0->unk11a_0, param1) != 1) + { + param0->unk11a_0 |= 1 << param1; + } +} + +THUMB_FUNC void FUN_02003368(s32 param0, struct Palette *param1, u16 *param2) +{ + u8 r0; + if (param0 < 4) + { + r0 = (u8)(param1->bufSize >> 5); + } + else + { + r0 = (u8)(param1->bufSize >> 9); + } + + u16 r4 = 0; + for (u8 i = 0; i < r0; i++) + { + r4 += 1 << i; + } + + *param2 &= r4; +} + +THUMB_FUNC void FUN_020033A4(struct PaletteFadeControl *paletteFade, + u16 selectedPalettes, + s16 delay, + u8 startY, + u8 targetY, + u16 color) +{ + if (delay < 0) + { + paletteFade->deltaY = abs(delay) + 2; + paletteFade->delay = 0; + } + else + { + paletteFade->deltaY = 2; + paletteFade->delay = delay; + } + + paletteFade->selectedPalettes = selectedPalettes; + paletteFade->y = startY; + paletteFade->targetY = targetY; + paletteFade->blendColor = color; + + paletteFade->delayCounter = paletteFade->delay; + + if (startY < targetY) + { + paletteFade->yDec = 0; + return; + } + paletteFade->yDec = 1; +} + +THUMB_FUNC void FUN_02003464(u32 param0, struct PaletteData *param1) +{ + if (param1->unk11c == 1) + { + param1->unk11c = 0; + param1->unk11a_0 = 0; + param1->activeFadePalettes = 0; + param1->unk11a_e = 0; + FUN_0200CAB4((s32)param0); + return; + } + + if (param1->unk118_0 == 1) + { + param1->unk11a_0 = param1->activeFadePalettes; + FUN_02003500(param1); + FUN_02003520(param1); + + if (param1->activeFadePalettes == 0) + { + param1->unk11a_e = 0; + FUN_0200CAB4((s32)param0); + } + } +} + +THUMB_FUNC void FUN_02003500(struct PaletteData *param0) +{ + for (u8 i = 0; i < 4; i++) + { + FUN_02003540(param0, i, 0x10); + } +} + +THUMB_FUNC void FUN_02003520(struct PaletteData *param0) +{ + for (u8 i = 4; i < 14; i++) + { + FUN_02003540(param0, i, 0x100); + } +} + +THUMB_FUNC void FUN_02003540(struct PaletteData *paletteData, u8 index, u32 param2) +{ + if (IsPaletteSelected(paletteData->activeFadePalettes, index) != 0) + { + if (paletteData->pltt[index].fadeCtrl.delayCounter < + paletteData->pltt[index].fadeCtrl.delay) + { + paletteData->pltt[index].fadeCtrl.delayCounter++; + return; + } + + paletteData->pltt[index].fadeCtrl.delayCounter = 0; + FUN_0200359C(paletteData, index, param2); + } +} + +THUMB_FUNC void FUN_0200359C(struct PaletteData *paletteData, u32 index, u32 param2) +{ + + for (u32 i = 0; i < 0x10; i++) + { + if (IsPaletteSelected(paletteData->pltt[index].fadeCtrl.selectedPalettes, (u16)i) != 0) + { + FUN_020035F8(paletteData->pltt[index].unfadedBuf + param2 * i, + paletteData->pltt[index].fadedBuf + param2 * i, + &paletteData->pltt[index].fadeCtrl, + param2); + } + } + + FUN_02003684(paletteData, (u8)index, &paletteData->pltt[index].fadeCtrl); +} + +THUMB_FUNC void FUN_020035F8( + u16 *src, u16 *dest, struct PaletteFadeControl *fadeCtrl, u32 numEntries) +{ + for (u32 i = 0; i < numEntries; i++) + { + u8 lo = (u8)((src[i] & 0x1f) + + ((((fadeCtrl->blendColor & 0x1f) - (src[i] & 0x1f)) * fadeCtrl->y) >> 4)); + + u8 hi = (u8)(((src[i] >> 10) & 0x1f) + + (((((fadeCtrl->blendColor >> 10) & 0x1f) - ((src[i] >> 10) & 0x1f)) * + fadeCtrl->y) >> + 4)); + u8 mid = + (u8)(((src[i] >> 5) & 0x1f) + + (((((fadeCtrl->blendColor >> 5) & 0x1f) - ((src[i] >> 5) & 0x1f)) * fadeCtrl->y) >> + 4)); + + dest[i] = (u16)((hi << 10) | (mid << 5) | lo); + } +} + +THUMB_FUNC void FUN_02003684( + struct PaletteData *paletteData, u8 index, struct PaletteFadeControl *fadeCtrl) +{ + if (fadeCtrl->y == fadeCtrl->targetY) + { + if ((paletteData->activeFadePalettes & (1 << index)) == 0) + { + return; + } + + paletteData->activeFadePalettes ^= (1 << index); + + return; + } + + s16 val; + if (fadeCtrl->yDec == 0) + { + val = (s16)fadeCtrl->y; + val += fadeCtrl->deltaY; + if (val > fadeCtrl->targetY) + { + val = (s16)fadeCtrl->targetY; + } + + fadeCtrl->y = val; + return; + } + + val = (s16)fadeCtrl->y; + val -= fadeCtrl->deltaY; + if (val < fadeCtrl->targetY) + { + val = (s16)fadeCtrl->targetY; + } + + fadeCtrl->y = val; +} + +THUMB_FUNC void FUN_0200372C(struct PaletteData *paletteData) +{ + if (paletteData->unk11a_f == 0 && paletteData->unk118_0 != 1) + { + return; + } + + for (s32 i = 0; i < 14; i++) + { + if (paletteData->unk11a_f != 0 || + (paletteData->pltt[i].fadedBuf != 0 && + IsPaletteSelected(paletteData->unk11a_0, (u16)i) != 0)) + { + DC_FlushRange(paletteData->pltt[i].fadedBuf, paletteData->pltt[i].bufSize); + + switch (i) + { + case 0: + GX_LoadBGPltt(paletteData->pltt[i].fadedBuf, 0, paletteData->pltt[i].bufSize); + break; + case 1: + GXS_LoadBGPltt(paletteData->pltt[i].fadedBuf, 0, paletteData->pltt[i].bufSize); + break; + case 2: + GX_LoadOBJPltt(paletteData->pltt[i].fadedBuf, 0, paletteData->pltt[i].bufSize); + break; + case 3: + GXS_LoadOBJPltt(paletteData->pltt[i].fadedBuf, 0, paletteData->pltt[i].bufSize); + break; + case 4: + GX_BeginLoadBGExtPltt(); + GX_LoadBGExtPltt( + paletteData->pltt[i].fadedBuf, 0, paletteData->pltt[i].bufSize); + GX_EndLoadBGExtPltt(); + break; + case 5: + GX_BeginLoadBGExtPltt(); + GX_LoadBGExtPltt( + paletteData->pltt[i].fadedBuf, 0x2000, paletteData->pltt[i].bufSize); + GX_EndLoadBGExtPltt(); + break; + case 6: + GX_BeginLoadBGExtPltt(); + GX_LoadBGExtPltt( + paletteData->pltt[i].fadedBuf, 0x4000, paletteData->pltt[i].bufSize); + GX_EndLoadBGExtPltt(); + break; + case 7: + GX_BeginLoadBGExtPltt(); + GX_LoadBGExtPltt( + paletteData->pltt[i].fadedBuf, 0x6000, paletteData->pltt[i].bufSize); + GX_EndLoadBGExtPltt(); + break; + case 8: + GXS_BeginLoadBGExtPltt(); + GXS_LoadBGExtPltt( + paletteData->pltt[i].fadedBuf, 0, paletteData->pltt[i].bufSize); + GXS_EndLoadBGExtPltt(); + break; + case 9: + GXS_BeginLoadBGExtPltt(); + GXS_LoadBGExtPltt( + paletteData->pltt[i].fadedBuf, 0x2000, paletteData->pltt[i].bufSize); + GXS_EndLoadBGExtPltt(); + break; + case 10: + GXS_BeginLoadBGExtPltt(); + GXS_LoadBGExtPltt( + paletteData->pltt[i].fadedBuf, 0x4000, paletteData->pltt[i].bufSize); + GXS_EndLoadBGExtPltt(); + break; + case 11: + GXS_BeginLoadBGExtPltt(); + GXS_LoadBGExtPltt( + paletteData->pltt[i].fadedBuf, 0x6000, paletteData->pltt[i].bufSize); + GXS_EndLoadBGExtPltt(); + break; + case 12: + GX_BeginLoadOBJExtPltt(); + GX_LoadOBJExtPltt( + paletteData->pltt[i].fadedBuf, 0, paletteData->pltt[i].bufSize); + GX_EndLoadOBJExtPltt(); + break; + case 13: + GXS_BeginLoadOBJExtPltt(); + GXS_LoadOBJExtPltt( + paletteData->pltt[i].fadedBuf, 0, paletteData->pltt[i].bufSize); + GXS_EndLoadOBJExtPltt(); + break; + } + } + } + + paletteData->unk11a_0 = paletteData->activeFadePalettes; + if (paletteData->unk11a_0 == 0) + { + paletteData->unk118_0 = 0; + } +} + +THUMB_FUNC u16 FUN_020038E4(struct PaletteData *paletteData) +{ + return paletteData->activeFadePalettes; +} + +THUMB_FUNC void FUN_020038F0(struct PaletteData *paletteData, u32 param1) +{ + paletteData->unk11a_f = param1; +} + +THUMB_FUNC void PaletteData_FillPalette(struct PaletteData *paletteData, + u32 index, + u32 selection, + u16 value, + u16 startOffset, + u16 endOffset) +{ + GF_ASSERT(endOffset * 2 <= paletteData->pltt[index].bufSize); + if (selection == 1 || selection == 2) + { + MI_CpuFill16(&paletteData->pltt[index].unfadedBuf[startOffset], + value, + (u32)((endOffset - startOffset) * 2)); + } + + if (selection == 0 || selection == 2) + { + MI_CpuFill16(&paletteData->pltt[index].fadedBuf[startOffset], + value, + (u32)((endOffset - startOffset) * 2)); + } +} + +#ifdef NONMATCHING +THUMB_FUNC void BlendPalette(u16 *src, u16 *dest, u16 numEntries, u8 coeff, u16 blendColor) +{ + s32 r12 = ((u32)(blendColor << 0x1b)) >> 0x1b; + s32 lr = ((u32)(blendColor << 0x16)) >> 0x1b; + s32 st8 = ((u32)(blendColor << 0x11)) >> 0x1b; + s32 lo, mid, hi; + + for (u16 i = 0; i < numEntries; i++) + { + lo = (((u32)(src[i] << 0x1b)) >> 0x1b); + mid = (((u32)(src[i] << 0x16)) >> 0x1b); + hi = (((u32)(src[i] << 0x11)) >> 0x1b); + + dest[i] = (lo + ((r12 - lo) * coeff) >> 4) | (mid + ((lr - mid) * coeff) >> 4) << 5 | + (hi + ((st8 - hi) * coeff) >> 4) << 10; + } +} +#else +asm void BlendPalette(u16 *param0, u16 *param1, u16 param2, u8 param3, u16 param4) +{ + // clang-format off + push {r4-r7, lr} + sub sp, #0xc + str r0, [sp, #0x0] + add r0, sp, #0x10 + ldrh r0, [r0, #0x10] + str r1, [sp, #0x4] + add r7, r2, #0x0 + lsl r1, r0, #0x1b + lsr r1, r1, #0x1b + mov r12, r1 + lsl r1, r0, #0x16 + lsl r0, r0, #0x11 + lsr r1, r1, #0x1b + lsr r0, r0, #0x1b + mov r2, #0x0 + mov lr, r1 + str r0, [sp, #0x8] + cmp r7, #0x0 + bls _020039E2 +_0200399A: + ldr r0, [sp, #0x0] + lsl r6, r2, #0x1 + ldrh r4, [r0, r6] + lsl r0, r4, #0x1b + lsr r1, r0, #0x1b + lsl r0, r4, #0x16 + lsl r4, r4, #0x11 + lsr r5, r4, #0x1b + ldr r4, [sp, #0x8] + lsr r0, r0, #0x1b + sub r4, r4, r5 + mul r4, r3 + asr r4, r4, #0x4 + add r4, r5, r4 + lsl r5, r4, #0xa + mov r4, r12 + sub r4, r4, r1 + mul r4, r3 + asr r4, r4, #0x4 + add r1, r1, r4 + mov r4, lr + sub r4, r4, r0 + mul r4, r3 + asr r4, r4, #0x4 + add r0, r0, r4 + lsl r0, r0, #0x5 + orr r0, r1 + add r1, r5, #0x0 + orr r1, r0 + ldr r0, [sp, #0x4] + strh r1, [r0, r6] + add r0, r2, #0x1 + lsl r0, r0, #0x10 + lsr r2, r0, #0x10 + cmp r2, r7 + blo _0200399A +_020039E2: + add sp, #0xc + pop {r4-r7, pc} + // clang-format on +} +#endif + +THUMB_FUNC void BlendPaletteUnfaded(struct PaletteData *paletteData, + u32 index, + u16 offset, + u16 numEntries, + u8 coeff, + u16 blendColor) +{ + BOOL r0 = FALSE; + if (paletteData->pltt[index].unfadedBuf != 0 && paletteData->pltt[index].fadedBuf != 0) + { + r0 = TRUE; + } + + GF_ASSERT(r0); + + BlendPalette(paletteData->pltt[index].unfadedBuf + offset, + paletteData->pltt[index].fadedBuf + offset, + numEntries, + coeff, + blendColor); +} + +THUMB_FUNC void BlendPalettes(u16 *src, u16 *dest, u16 selectedPalettes, u8 coeff, u16 blendColor) +{ + while (selectedPalettes != 0) + { + if ((selectedPalettes & 1) != 0) + { + BlendPalette(src, dest, 0x10, coeff, blendColor); + } + + selectedPalettes >>= 1; + dest += 0x10; + src += 0x10; + } +} + +THUMB_FUNC void BlendPalettesUnfaded( + struct PaletteData *paletteData, u32 index, u16 selectedPalettes, u8 coeff, u16 blendColor) +{ + u32 r4 = 0; + BOOL r0 = FALSE; + if (paletteData->pltt[index].unfadedBuf != 0 && paletteData->pltt[index].fadedBuf != 0) + { + r0 = TRUE; + } + + GF_ASSERT(r0); + + while (selectedPalettes != 0) + { + if ((selectedPalettes & 1) != 0) + { + BlendPaletteUnfaded(paletteData, index, (u16)r4, 0x10, coeff, blendColor); + } + + selectedPalettes >>= 1; + r4 += 0x10; + } +} + +#ifdef NONMATCHING +THUMB_FUNC void TintPalette_CustomTone(u16 *palette, u32 count, u32 rTone, u32 gTone, u32 bTone) +{ + s32 r, g, b, i; + u32 gray; + + for (i = 0; i < count; i++) + { + r = (*palette >> 0) & 0x1F; + g = (*palette >> 5) & 0x1F; + b = (*palette >> 10) & 0x1F; + + gray = (r * 76 + g * 151 + b * 29) >> 8; + + r = (u16)((rTone * gray)) >> 8; + g = (u16)((gTone * gray)) >> 8; + b = (u16)((bTone * gray)) >> 8; + + if (r > 31) + r = 31; + if (g > 31) + g = 31; + if (b > 31) + b = 31; + + *palette++ = (b << 10) | (g << 5) | (r << 0); + } +} +#else +asm void TintPalette_CustomTone(u16 *palette, u32 count, u32 rTone, u32 gTone, u32 bTone) +{ + // clang-format off + push {r3-r7, lr} + mov lr, r1 + mov r12, r2 + add r7, r3, #0x0 + mov r4, #0x0 + cmp r1, #0x0 + ble _02003B3C + ldr r6, [sp, #0x18] +_02003AD4: + ldrh r3, [r0, #0x0] + mov r1, #0x1f + add r2, r3, #0x0 + asr r5, r3, #0xa + and r2, r1 + and r5, r1 + mov r1, #0x1d + mul r1, r5 + mov r5, #0x4c + mul r5, r2 + asr r3, r3, #0x5 + mov r2, #0x1f + and r3, r2 + mov r2, #0x97 + mul r2, r3 + add r2, r5, r2 + add r1, r1, r2 + asr r3, r1, #0x8 + mov r1, r12 + add r2, r1, #0x0 + mul r2, r3 + lsl r1, r2, #0x10 + lsr r1, r1, #0x10 + asr r2, r1, #0x8 + add r1, r7, #0x0 + mul r1, r3 + mul r3, r6 + lsl r1, r1, #0x10 + lsl r3, r3, #0x10 + lsr r1, r1, #0x10 + lsr r3, r3, #0x10 + asr r1, r1, #0x8 + asr r3, r3, #0x8 + cmp r2, #0x1f + ble _02003B1C + mov r2, #0x1f +_02003B1C: + cmp r1, #0x1f + ble _02003B22 + mov r1, #0x1f +_02003B22: + cmp r3, #0x1f + ble _02003B28 + mov r3, #0x1f +_02003B28: + lsl r3, r3, #0xa + lsl r1, r1, #0x5 + orr r1, r3 + orr r1, r2 + strh r1, [r0, #0x0] + add r4, r4, #0x1 + mov r1, lr + add r0, r0, #0x2 + cmp r4, r1 + blt _02003AD4 +_02003B3C: + pop {r3-r7, pc} + // clang-format on +} +#endif + +THUMB_FUNC void FUN_02003B40(struct PaletteData *paletteData, + NarcId narcId, + s32 memberId, + u32 heap_id, + u32 index, + u32 size, + u16 offset, + u32 rTone, + u32 gTone, + u32 bTone) +{ + NNSG2dPaletteData *pltData; + void *ptr = GfGfxLoader_GetPlttData(narcId, memberId, &pltData, heap_id); + GF_ASSERT(ptr != NULL); + + if (size == 0) + { + size = pltData->szByte; + } + + TintPalette_CustomTone(pltData->pRawData, 0x10, rTone, gTone, bTone); + PaletteData_LoadPalette(paletteData, pltData->pRawData, index, offset, (u16)size); + + FreeToHeap(ptr); +} diff --git a/arm9/src/unk_02002F08.c b/arm9/src/unk_02002F08.c index b81da622..5a1eca36 100644 --- a/arm9/src/unk_02002F08.c +++ b/arm9/src/unk_02002F08.c @@ -60,53 +60,54 @@ THUMB_FUNC s32 FUN_02002F9C(u32 param0, struct String *str) UNK_02106FC8->unk94[param0], String_c_str(str)); } -THUMB_FUNC struct UnkStruct_02002F08 *FUN_02002FD0(u32 heap_id) +THUMB_FUNC struct PaletteData *FUN_02002FD0(u32 heap_id) { - struct UnkStruct_02002F08 *ptr = AllocFromHeap(heap_id, sizeof(struct UnkStruct_02002F08)); - MI_CpuFill8(ptr, 0, sizeof(struct UnkStruct_02002F08)); + struct PaletteData *ptr = AllocFromHeap(heap_id, sizeof(struct PaletteData)); + MI_CpuFill8(ptr, 0, sizeof(struct PaletteData)); return ptr; } -THUMB_FUNC void FUN_02002FEC(struct UnkStruct_02002F08 *ptr) +THUMB_FUNC void FUN_02002FEC(struct PaletteData *ptr) { FreeToHeap(ptr); } -THUMB_FUNC void FUN_02002FF4( - struct UnkStruct_02002F08 *param0, u32 param1, void *param2, void *param3, u32 size) +THUMB_FUNC void PaletteData_SetBuffers( + struct PaletteData *paletteData, u32 index, void *unfadedBuf, void *fadedBuf, u32 size) { - param0->unk000[param1].unk00 = param2; - param0->unk000[param1].unk04 = param3; - param0->unk000[param1].unk08 = size; + paletteData->pltt[index].unfadedBuf = unfadedBuf; + paletteData->pltt[index].fadedBuf = fadedBuf; + paletteData->pltt[index].bufSize = size; } -THUMB_FUNC void FUN_02003008(struct UnkStruct_02002F08 *param0, u32 param1, u32 size, u32 heap_id) +THUMB_FUNC void PaletteData_AllocBuffers( + struct PaletteData *paletteData, u32 index, u32 size, u32 heap_id) { void *ptr = AllocFromHeap(heap_id, size); void *ptr2 = AllocFromHeap(heap_id, size); - FUN_02002FF4(param0, param1, ptr, ptr2, size); + PaletteData_SetBuffers(paletteData, index, ptr, ptr2, size); } -THUMB_FUNC void FUN_02003038(struct UnkStruct_02002F08 *param0, u32 param1) +THUMB_FUNC void PaletteData_FreeBuffers(struct PaletteData *paletteData, u32 index) { - FreeToHeap(param0->unk000[param1].unk00); - FreeToHeap(param0->unk000[param1].unk04); + FreeToHeap(paletteData->pltt[index].unfadedBuf); + FreeToHeap(paletteData->pltt[index].fadedBuf); } -THUMB_FUNC void FUN_02003054( - struct UnkStruct_02002F08 *param0, const void *param1, u32 param2, u32 offset, u16 size) +THUMB_FUNC void PaletteData_LoadPalette( + struct PaletteData *paletteData, const void *src, u32 index, u32 offset, u16 size) { - MIi_CpuCopy16(param1, param0->unk000[param2].unk00 + offset, size); - MIi_CpuCopy16(param1, param0->unk000[param2].unk04 + offset, size); + MIi_CpuCopy16(src, paletteData->pltt[index].unfadedBuf + offset, size); + MIi_CpuCopy16(src, paletteData->pltt[index].fadedBuf + offset, size); } -THUMB_FUNC void FUN_02003084(struct UnkStruct_02002F08 *param0, +THUMB_FUNC void PaletteData_LoadFromNarc(struct PaletteData *paletteData, NarcId narcId, s32 memberId, u32 heap_id, - u32 param4, + u32 index, u32 size, u16 offset, u16 param7) @@ -121,19 +122,19 @@ THUMB_FUNC void FUN_02003084(struct UnkStruct_02002F08 *param0, size = pltData->szByte; } - GF_ASSERT(size + offset * 2 <= param0->unk000[param4].unk08); + GF_ASSERT(size + offset * 2 <= paletteData->pltt[index].bufSize); - FUN_02003054(param0, pltData->pRawData + param7 * 2, param4, offset, (u16)size); + PaletteData_LoadPalette(paletteData, pltData->pRawData + param7 * 2, index, offset, (u16)size); FreeToHeap(ptr); } -THUMB_FUNC void FUN_020030E8(struct UnkStruct_02002F08 *param0, +THUMB_FUNC void PaletteData_LoadNarc(struct PaletteData *paletteData, NarcId narcId, s32 memberId, u32 heap_id, - u32 param4, + u32 index, u32 size, u16 offset) { - FUN_02003084(param0, narcId, memberId, heap_id, param4, size, offset, 0); + PaletteData_LoadFromNarc(paletteData, narcId, memberId, heap_id, index, size, offset, 0); } |