356 lines
11 KiB
C
356 lines
11 KiB
C
#include "global.h"
|
|
#include "malloc.h"
|
|
#include "data.h"
|
|
#include "decompress.h"
|
|
#include "pokemon.h"
|
|
#include "pokemon_sprite_visualizer.h"
|
|
#include "text.h"
|
|
#include "menu.h"
|
|
|
|
void LZDecompressWram(const u32 *src, void *dest)
|
|
{
|
|
LZ77UnCompWram(src, dest);
|
|
}
|
|
|
|
void LZDecompressVram(const u32 *src, void *dest)
|
|
{
|
|
LZ77UnCompVram(src, dest);
|
|
}
|
|
|
|
// Checks if `ptr` is likely LZ77 data
|
|
// Checks word-alignment, min/max size, and header byte
|
|
// Returns uncompressed size if true, 0 otherwise
|
|
u32 IsLZ77Data(const void *ptr, u32 minSize, u32 maxSize)
|
|
{
|
|
const u8 *data = ptr;
|
|
u32 size;
|
|
// Compressed data must be word aligned
|
|
if (((u32)ptr) & 3)
|
|
return 0;
|
|
// Check LZ77 header byte
|
|
// See https://problemkaputt.de/gbatek.htm#biosdecompressionfunctions
|
|
if (data[0] != 0x10)
|
|
return 0;
|
|
|
|
// Read 24-bit uncompressed size
|
|
size = data[1] | (data[2] << 8) | (data[3] << 16);
|
|
if (size >= minSize && size <= maxSize)
|
|
return size;
|
|
return 0;
|
|
}
|
|
|
|
static inline u32 DoLoadCompressedSpriteSheet(const struct CompressedSpriteSheet *src, void *buffer)
|
|
{
|
|
struct SpriteSheet dest;
|
|
|
|
dest.data = buffer;
|
|
dest.size = src->size;
|
|
dest.tag = src->tag;
|
|
return LoadSpriteSheet(&dest);
|
|
}
|
|
|
|
u32 LoadCompressedSpriteSheet(const struct CompressedSpriteSheet *src)
|
|
{
|
|
void *buffer = malloc_and_decompress(src->data, NULL);
|
|
u32 ret = DoLoadCompressedSpriteSheet(src, buffer);
|
|
Free(buffer);
|
|
|
|
return ret;
|
|
}
|
|
|
|
u32 LoadCompressedSpriteSheetOverrideBuffer(const struct CompressedSpriteSheet *src, void *buffer)
|
|
{
|
|
LZDecompressWram(src->data, buffer);
|
|
return DoLoadCompressedSpriteSheet(src, buffer);
|
|
}
|
|
|
|
// This can be used for either compressed or uncompressed sprite sheets
|
|
u32 LoadCompressedSpriteSheetByTemplate(const struct SpriteTemplate *template, s32 offset)
|
|
{
|
|
struct SpriteTemplate myTemplate;
|
|
struct SpriteFrameImage myImage;
|
|
u32 size;
|
|
|
|
// Check for LZ77 header and read uncompressed size, or fallback if not compressed (zero size)
|
|
if ((size = IsLZ77Data(template->images->data, TILE_SIZE_4BPP, MAX_DECOMPRESSION_BUFFER_SIZE)) == 0)
|
|
return LoadSpriteSheetByTemplate(template, 0, offset);
|
|
|
|
void *buffer = malloc_and_decompress(template->images->data, NULL);
|
|
myImage.data = buffer;
|
|
myImage.size = size + offset;
|
|
myTemplate.images = &myImage;
|
|
myTemplate.tileTag = template->tileTag;
|
|
|
|
u32 ret = LoadSpriteSheetByTemplate(&myTemplate, 0, offset);
|
|
Free(buffer);
|
|
return ret;
|
|
}
|
|
|
|
u32 LoadCompressedSpritePalette(const struct CompressedSpritePalette *src)
|
|
{
|
|
return LoadCompressedSpritePaletteWithTag(src->data, src->tag);
|
|
}
|
|
|
|
u32 LoadCompressedSpritePaletteWithTag(const u32 *pal, u16 tag)
|
|
{
|
|
u32 index;
|
|
struct SpritePalette dest;
|
|
void *buffer = malloc_and_decompress(pal, NULL);
|
|
|
|
dest.data = buffer;
|
|
dest.tag = tag;
|
|
index = LoadSpritePalette(&dest);
|
|
Free(buffer);
|
|
return index;
|
|
}
|
|
|
|
void LoadCompressedSpritePaletteOverrideBuffer(const struct CompressedSpritePalette *src, void *buffer)
|
|
{
|
|
struct SpritePalette dest;
|
|
|
|
LZ77UnCompWram(src->data, buffer);
|
|
dest.data = buffer;
|
|
dest.tag = src->tag;
|
|
LoadSpritePalette(&dest);
|
|
}
|
|
|
|
void DecompressPicFromTable(const struct CompressedSpriteSheet *src, void *buffer)
|
|
{
|
|
LZ77UnCompWram(src->data, buffer);
|
|
}
|
|
|
|
void HandleLoadSpecialPokePic(bool32 isFrontPic, void *dest, s32 species, u32 personality)
|
|
{
|
|
LoadSpecialPokePic(dest, species, personality, isFrontPic);
|
|
}
|
|
|
|
void LoadSpecialPokePic(void *dest, s32 species, u32 personality, bool8 isFrontPic)
|
|
{
|
|
species = SanitizeSpeciesId(species);
|
|
if (species == SPECIES_UNOWN)
|
|
species = GetUnownSpeciesId(personality);
|
|
|
|
if (isFrontPic)
|
|
{
|
|
#if P_GENDER_DIFFERENCES
|
|
if (gSpeciesInfo[species].frontPicFemale != NULL && IsPersonalityFemale(species, personality))
|
|
LZ77UnCompWram(gSpeciesInfo[species].frontPicFemale, dest);
|
|
else
|
|
#endif
|
|
if (gSpeciesInfo[species].frontPic != NULL)
|
|
LZ77UnCompWram(gSpeciesInfo[species].frontPic, dest);
|
|
else
|
|
LZ77UnCompWram(gSpeciesInfo[SPECIES_NONE].frontPic, dest);
|
|
}
|
|
else
|
|
{
|
|
#if P_GENDER_DIFFERENCES
|
|
if (gSpeciesInfo[species].backPicFemale != NULL && IsPersonalityFemale(species, personality))
|
|
LZ77UnCompWram(gSpeciesInfo[species].backPicFemale, dest);
|
|
else
|
|
#endif
|
|
if (gSpeciesInfo[species].backPic != NULL)
|
|
LZ77UnCompWram(gSpeciesInfo[species].backPic, dest);
|
|
else
|
|
LZ77UnCompWram(gSpeciesInfo[SPECIES_NONE].backPic, dest);
|
|
}
|
|
|
|
if (species == SPECIES_SPINDA && isFrontPic)
|
|
{
|
|
DrawSpindaSpots(personality, dest, FALSE);
|
|
DrawSpindaSpots(personality, dest, TRUE);
|
|
}
|
|
}
|
|
|
|
void Unused_LZDecompressWramIndirect(const void **src, void *dest)
|
|
{
|
|
LZ77UnCompWram(*src, dest);
|
|
}
|
|
|
|
static void UNUSED StitchObjectsOn8x8Canvas(s32 object_size, s32 object_count, u8 *src_tiles, u8 *dest_tiles)
|
|
{
|
|
/*
|
|
This function appears to emulate behaviour found in the GB(C) versions regarding how the Pokemon images
|
|
are stitched together to be displayed on the battle screen.
|
|
Given "compacted" tiles, an object count and a bounding box/object size, place the tiles in such a way
|
|
that the result will have each object centered in a 8x8 tile canvas.
|
|
*/
|
|
s32 i, j, k, l;
|
|
u8 *src = src_tiles, *dest = dest_tiles;
|
|
u8 bottom_off;
|
|
|
|
if (object_size & 1)
|
|
{
|
|
// Object size is odd
|
|
bottom_off = (object_size >> 1) + 4;
|
|
for (l = 0; l < object_count; l++)
|
|
{
|
|
// Clear all unused rows of tiles plus the half-tile required due to centering
|
|
for (j = 0; j < 8-object_size; j++)
|
|
{
|
|
for (k = 0; k < 8; k++)
|
|
{
|
|
for (i = 0; i < 16; i++)
|
|
{
|
|
if (j % 2 == 0)
|
|
{
|
|
// Clear top half of top tile and bottom half of bottom tile when on even j
|
|
((dest+i) + (k << 5))[((j >> 1) << 8)] = 0;
|
|
((bottom_off << 8) + (dest+i) + (k << 5) + 16)[((j >> 1) << 8)] = 0;
|
|
}
|
|
else
|
|
{
|
|
// Clear bottom half of top tile and top half of tile following bottom tile when on odd j
|
|
((dest+i) + (k << 5) + 16)[((j >> 1) << 8)] = 0;
|
|
((bottom_off << 8) + (dest+i) + (k << 5) + 256)[((j >> 1) << 8)] = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Clear the columns to the left and right that wont be used completely
|
|
// Unlike the previous loops, this will clear the later used space as well
|
|
for (j = 0; j < 2; j++)
|
|
{
|
|
for (i = 0; i < 8; i++)
|
|
{
|
|
for (k = 0; k < 32; k++)
|
|
{
|
|
// Left side
|
|
((dest+k) + (i << 8))[(j << 5)] = 0;
|
|
// Right side
|
|
((dest+k) + (i << 8))[(j << 5)+192] = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Skip the top row and first tile on the second row for objects of size 5
|
|
if (object_size == 5) dest += 0x120;
|
|
|
|
// Copy tile data
|
|
for (j = 0; j < object_size; j++)
|
|
{
|
|
for (k = 0; k < object_size; k++)
|
|
{
|
|
for (i = 0; i < 4; i++)
|
|
{
|
|
// Offset the tile by +4px in both x and y directions
|
|
(dest + (i << 2))[18] = (src + (i << 2))[0];
|
|
(dest + (i << 2))[19] = (src + (i << 2))[1];
|
|
(dest + (i << 2))[48] = (src + (i << 2))[2];
|
|
(dest + (i << 2))[49] = (src + (i << 2))[3];
|
|
|
|
(dest + (i << 2))[258] = (src + (i << 2))[16];
|
|
(dest + (i << 2))[259] = (src + (i << 2))[17];
|
|
(dest + (i << 2))[288] = (src + (i << 2))[18];
|
|
(dest + (i << 2))[289] = (src + (i << 2))[19];
|
|
}
|
|
src += 32;
|
|
dest += 32;
|
|
}
|
|
|
|
// At the end of a row, skip enough tiles to get to the beginning of the next row
|
|
if (object_size == 7) dest += 0x20;
|
|
else if (object_size == 5) dest += 0x60;
|
|
}
|
|
|
|
// Skip remaining unused space to go to the beginning of the next object
|
|
if (object_size == 7) dest += 0x100;
|
|
else if (object_size == 5) dest += 0x1e0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Object size is even
|
|
for (i = 0; i < object_count; i++)
|
|
{
|
|
// For objects of size 6, the first and last row and column will be cleared
|
|
// While the remaining space will be filled with actual data
|
|
if (object_size == 6)
|
|
{
|
|
for (k = 0; k < 256; k++)
|
|
{
|
|
*dest = 0;
|
|
dest++;
|
|
}
|
|
}
|
|
|
|
for (j = 0; j < object_size; j++)
|
|
{
|
|
if (object_size == 6)
|
|
{
|
|
for (k = 0; k < 32; k++)
|
|
{
|
|
*dest = 0;
|
|
dest++;
|
|
}
|
|
}
|
|
|
|
// Copy tile data
|
|
for (k = 0; k < 32 * object_size; k++)
|
|
{
|
|
*dest = *src;
|
|
src++;
|
|
dest++;
|
|
}
|
|
|
|
if (object_size == 6)
|
|
{
|
|
for (k = 0; k < 32; k++)
|
|
{
|
|
*dest = 0;
|
|
dest++;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (object_size == 6)
|
|
{
|
|
for (k = 0; k < 256; k++)
|
|
{
|
|
*dest = 0;
|
|
dest++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
u32 GetDecompressedDataSize(const u32 *ptr)
|
|
{
|
|
const u8 *ptr8 = (const u8 *)ptr;
|
|
return (ptr8[3] << 16) | (ptr8[2] << 8) | (ptr8[1]);
|
|
}
|
|
|
|
bool8 LoadCompressedSpriteSheetUsingHeap(const struct CompressedSpriteSheet *src)
|
|
{
|
|
struct SpriteSheet dest;
|
|
void *buffer;
|
|
|
|
buffer = AllocZeroed(src->data[0] >> 8);
|
|
LZ77UnCompWram(src->data, buffer);
|
|
|
|
dest.data = buffer;
|
|
dest.size = src->size;
|
|
dest.tag = src->tag;
|
|
|
|
LoadSpriteSheet(&dest);
|
|
Free(buffer);
|
|
return FALSE;
|
|
}
|
|
|
|
bool8 LoadCompressedSpritePaletteUsingHeap(const struct CompressedSpritePalette *src)
|
|
{
|
|
struct SpritePalette dest;
|
|
void *buffer;
|
|
|
|
buffer = AllocZeroed(src->data[0] >> 8);
|
|
LZ77UnCompWram(src->data, buffer);
|
|
dest.data = buffer;
|
|
dest.tag = src->tag;
|
|
|
|
LoadSpritePalette(&dest);
|
|
Free(buffer);
|
|
return FALSE;
|
|
}
|