romdev-mcp 0.1.1

package/src/platforms/genesis/lib/sgdk/src/pal.c

@@ -0,0 +1,484 @@
+#include "config.h"
+#include "types.h"
+
+#include "vdp.h"
+#include "pal.h"
+
+#include "sys.h"
+#include "timer.h"
+#include "memory.h"
+#include "dma.h"
+#include "maths.h"
+
+#if (ENABLE_NEWLIB == 1)
+#include <string.h>	// For memcpy
+#endif
+
+#define PALETTEFADE_FRACBITS    8
+#define PALETTEFADE_ROUND_VAL   ((1 << (PALETTEFADE_FRACBITS - 1)) - 1)
+
+
+// we don't want to share them
+extern vu16 VBlankProcess;
+
+
+const u16 palette_black_all[64] =
+{
+    0x0000,
+    0x0000,
+    0x0000,
+    0x0000,
+    0x0000,
+    0x0000,
+    0x0000,
+    0x0000,
+
+    0x0000,
+    0x0000,
+    0x0000,
+    0x0000,
+    0x0000,
+    0x0000,
+    0x0000,
+    0x0000,
+
+    0x0000,
+    0x0000,
+    0x0000,
+    0x0000,
+    0x0000,
+    0x0000,
+    0x0000,
+    0x0000,
+
+    0x0000,
+    0x0000,
+    0x0000,
+    0x0000,
+    0x0000,
+    0x0000,
+    0x0000,
+    0x0000,
+
+    0x0000,
+    0x0000,
+    0x0000,
+    0x0000,
+    0x0000,
+    0x0000,
+    0x0000,
+    0x0000,
+
+    0x0000,
+    0x0000,
+    0x0000,
+    0x0000,
+    0x0000,
+    0x0000,
+    0x0000,
+    0x0000,
+
+    0x0000,
+    0x0000,
+    0x0000,
+    0x0000,
+    0x0000,
+    0x0000,
+    0x0000,
+    0x0000,
+
+    0x0000,
+    0x0000,
+    0x0000,
+    0x0000,
+    0x0000,
+    0x0000,
+    0x0000,
+    0x0000,
+};
+
+const u16 palette_grey[16] =
+{
+    0x0000,
+    0x0222,
+    0x0444,
+    0x0666,
+    0x0888,
+    0x0AAA,
+    0x0CCC,
+    0x0EEE,
+
+    0x0EEE,
+    0x0EEE,
+    0x0EEE,
+    0x0EEE,
+    0x0EEE,
+    0x0EEE,
+    0x0EEE,
+    0x0EEE
+};
+
+const u16 palette_red[16] =
+{
+    0x0000,
+    0x0002,
+    0x0004,
+    0x0006,
+    0x0008,
+    0x000A,
+    0x000C,
+    0x000E,
+
+    0x000E,
+    0x000E,
+    0x000E,
+    0x000E,
+    0x000E,
+    0x000E,
+    0x000E,
+    0x000E
+};
+
+const u16 palette_green[16] =
+{
+    0x0000,
+    0x0020,
+    0x0040,
+    0x0060,
+    0x0080,
+    0x00A0,
+    0x00C0,
+    0x00E0,
+
+    0x00E0,
+    0x00E0,
+    0x00E0,
+    0x00E0,
+    0x00E0,
+    0x00E0,
+    0x00E0,
+    0x00E0
+};
+
+const u16 palette_blue[16] =
+{
+    0x0000,
+    0x0200,
+    0x0400,
+    0x0600,
+    0x0800,
+    0x0A00,
+    0x0C00,
+    0x0E00,
+
+    0x0E00,
+    0x0E00,
+    0x0E00,
+    0x0E00,
+    0x0E00,
+    0x0E00,
+    0x0E00,
+    0x0E00
+};
+
+
+const u16* const palette_black = palette_black_all;
+const u16* const palette_white = palette_grey;
+
+// used for palette fading (consumes 896 bytes of memory)
+u16 fadeCurrentPal[64];
+
+static s16 fadeR[64];
+static s16 fadeG[64];
+static s16 fadeB[64];
+static s16 fadeSR[64];
+static s16 fadeSG[64];
+static s16 fadeSB[64];
+
+static u16 fadeInd;
+static u16 fadeSize;
+static s16 fadeCounter;
+
+
+u16 PAL_getColor(u16 index)
+{
+    const u16 addr = index * 2;
+
+    *((vu32*) VDP_CTRL_PORT) = VDP_READ_CRAM_ADDR((u32)addr);
+
+    return (*((vu16*) VDP_DATA_PORT)) & VDPPALETTE_COLORMASK;
+}
+
+void PAL_getColors(u16 index, u16* dest, u16 count)
+{
+    VDP_setAutoInc(2);
+
+    const u16 addr = index * 2;
+    *((vu32*) VDP_CTRL_PORT) = VDP_READ_CRAM_ADDR((u32)addr);
+
+    vu32* pl = (u32*) VDP_DATA_PORT;
+    u32* dl = (u32*) dest;
+    u32 mask32 = (VDPPALETTE_COLORMASK << 16) | (VDPPALETTE_COLORMASK << 0);
+
+    u16 il = count >> 4;
+    while(il--)
+    {
+        *dl++ = *pl & mask32;
+        *dl++ = *pl & mask32;
+        *dl++ = *pl & mask32;
+        *dl++ = *pl & mask32;
+        *dl++ = *pl & mask32;
+        *dl++ = *pl & mask32;
+        *dl++ = *pl & mask32;
+        *dl++ = *pl & mask32;
+    }
+
+    vu16* pw = (u16*) pl;
+    u16* dw = (u16*) dl;
+    u16 mask16 = VDPPALETTE_COLORMASK;
+
+    u16 i = count & 0xF;
+    while(i--) *dw++ = *pw & mask16;
+}
+
+void PAL_getPalette(u16 numPal, u16* dest)
+{
+    VDP_setAutoInc(2);
+
+    const u16 addr = numPal * (16 * 2);
+    *((vu32*) VDP_CTRL_PORT) = VDP_READ_CRAM_ADDR((u32)addr);
+
+    vu32* pl = (u32*) VDP_DATA_PORT;
+    u32* d = (u32*) dest;
+    u32 mask32 = (VDPPALETTE_COLORMASK << 16) | (VDPPALETTE_COLORMASK << 0);
+
+    *d++ = *pl & mask32;
+    *d++ = *pl & mask32;
+    *d++ = *pl & mask32;
+    *d++ = *pl & mask32;
+    *d++ = *pl & mask32;
+    *d++ = *pl & mask32;
+    *d++ = *pl & mask32;
+    *d++ = *pl & mask32;
+}
+
+void PAL_setColor(u16 index, u16 value)
+{
+    const u16 addr = index * 2;
+
+    *((vu32*) VDP_CTRL_PORT) = VDP_WRITE_CRAM_ADDR((u32)addr);
+    *((vu16*) VDP_DATA_PORT) = value;
+}
+
+void PAL_setColors(u16 index, const u16* pal, u16 count, TransferMethod tm)
+{
+    DMA_transfer(tm, DMA_CRAM, (void*) pal, index * 2, count, 2);
+}
+
+void PAL_setPaletteColors(u16 index, const Palette* pal, TransferMethod tm)
+{
+    PAL_setColors(index, pal->data, pal->length, tm);
+}
+
+void PAL_setPalette(u16 numPal, const u16* pal, TransferMethod tm)
+{
+    PAL_setColors(numPal * 16, pal, 16, tm);
+}
+
+
+NO_INLINE bool PAL_initFade(u16 fromCol, u16 toCol, const u16* palSrc, const u16* palDst, u16 numFrame)
+{
+    // can't do a fade on 0 frame !
+    if (numFrame == 0) return FALSE;
+
+    fadeInd = fromCol;
+    fadeSize = (toCol - fromCol) + 1;
+    fadeCounter = numFrame;
+
+    const u16* src = palSrc;
+    const u16* dst = palDst;
+    u16 len = fadeSize;
+
+    // set source palette as current fade palette
+    memcpy(fadeCurrentPal, src, len * 2);
+
+    s16 *palR = fadeR;
+    s16 *palG = fadeG;
+    s16 *palB = fadeB;
+    s16 *stepR = fadeSR;
+    s16 *stepG = fadeSG;
+    s16 *stepB = fadeSB;
+
+    while(len--)
+    {
+        const u16 s = *src++;
+        const s16 RS = ((s & VDPPALETTE_REDMASK) >> VDPPALETTE_REDSFT) << PALETTEFADE_FRACBITS;
+        const s16 GS = ((s & VDPPALETTE_GREENMASK) >> VDPPALETTE_GREENSFT) << PALETTEFADE_FRACBITS;
+        const s16 BS = ((s & VDPPALETTE_BLUEMASK) >> VDPPALETTE_BLUESFT) << PALETTEFADE_FRACBITS;
+
+        *palR++ = RS + PALETTEFADE_ROUND_VAL;
+        *palG++ = GS + PALETTEFADE_ROUND_VAL;
+        *palB++ = BS + PALETTEFADE_ROUND_VAL;
+
+        const u16 d = *dst++;
+        const s16 RD = ((d & VDPPALETTE_REDMASK) >> VDPPALETTE_REDSFT) << PALETTEFADE_FRACBITS;
+        const s16 GD = ((d & VDPPALETTE_GREENMASK) >> VDPPALETTE_GREENSFT) << PALETTEFADE_FRACBITS;
+        const s16 BD = ((d & VDPPALETTE_BLUEMASK) >> VDPPALETTE_BLUESFT) << PALETTEFADE_FRACBITS;
+
+        *stepR++ = divs(RD - RS, numFrame);
+        *stepG++ = divs(GD - GS, numFrame);
+        *stepB++ = divs(BD - BS, numFrame);
+    }
+
+    // set current palette on next vblank
+    PAL_setColors(fadeInd, fadeCurrentPal, fadeSize, DMA_QUEUE);
+
+    return TRUE;
+}
+
+NO_INLINE bool PAL_doFadeStep(void)
+{
+    // fading is done? --> exit
+    if (fadeCounter <= 0)
+        return FALSE;
+
+    // prepare fade palette for next frame
+    s16* palR = fadeR;
+    s16* palG = fadeG;
+    s16* palB = fadeB;
+    s16* stepR = fadeSR;
+    s16* stepG = fadeSG;
+    s16* stepB = fadeSB;
+    u16* dst = fadeCurrentPal;
+
+    // compute the next fade palette
+    u16 i = fadeSize;
+    while(i--)
+    {
+        u16 col;
+
+        const u16 R = *palR + *stepR++;
+        const u16 G = *palG + *stepG++;
+        const u16 B = *palB + *stepB++;
+
+        *palR++ = R;
+        *palG++ = G;
+        *palB++ = B;
+
+        col = ((R >> PALETTEFADE_FRACBITS) << VDPPALETTE_REDSFT) & VDPPALETTE_REDMASK;
+        col |= ((G >> PALETTEFADE_FRACBITS) << VDPPALETTE_GREENSFT) & VDPPALETTE_GREENMASK;
+        col |= ((B >> PALETTEFADE_FRACBITS) << VDPPALETTE_BLUESFT) & VDPPALETTE_BLUEMASK;
+
+        *dst++ = col;
+    }
+
+    // schedule palette transfer on next vblank
+    PAL_setColors(fadeInd, fadeCurrentPal, fadeSize, DMA_QUEUE);
+
+    return (--fadeCounter > 0);
+}
+
+bool PAL_isManualFadeDone(void)
+{
+    return (fadeCounter > 0) ? FALSE : TRUE;
+}
+
+void PAL_fade(u16 fromCol, u16 toCol, const u16* palSrc, const u16* palDst, u16 numFrame, bool async)
+{
+    // error during fading initialization --> exit
+    if (!PAL_initFade(fromCol, toCol, palSrc, palDst, numFrame)) return;
+
+    // process asynchrone fading
+    if (async) VBlankProcess |= PROCESS_PALETTE_FADING;
+    else
+    {
+        // process fading immediately
+        do SYS_doVBlankProcess();
+        while (PAL_doFadeStep());
+        // final update
+        SYS_doVBlankProcess();
+    }
+}
+
+
+void PAL_fadeTo(u16 fromCol, u16 toCol, const u16* pal, u16 numFrame, bool async)
+{
+    u16 tmp_pal[64];
+
+    // read current palette (better to disable interrupts to avoid issue with raster effects)
+    SYS_disableInts();
+    PAL_getColors(fromCol, tmp_pal, (toCol - fromCol) + 1);
+    SYS_enableInts();
+
+    // do the fade
+    PAL_fade(fromCol, toCol, tmp_pal, pal, numFrame, async);
+}
+
+void PAL_fadeOut(u16 fromCol, u16 toCol, u16 numFrame, bool async)
+{
+    PAL_fadeTo(fromCol, toCol, palette_black_all, numFrame, async);
+}
+
+void PAL_fadeIn(u16 fromCol, u16 toCol, const u16* pal, u16 numFrame, bool async)
+{
+    PAL_fade(fromCol, toCol, palette_black_all, pal, numFrame, async);
+}
+
+
+void PAL_fadePalette(u16 numpal, const u16* palSrc, const u16* palDst, u16 numFrame, bool async)
+{
+    PAL_fade(numpal << 4, (numpal << 4) + 15, palSrc, palDst, numFrame, async);
+}
+
+void PAL_fadeToPalette(u16 numpal, const u16* pal, u16 numFrame, bool async)
+{
+    PAL_fadeTo(numpal << 4, (numpal << 4) + 15, pal, numFrame, async);
+}
+
+void PAL_fadeOutPalette(u16 numpal, u16 numFrame, bool async)
+{
+    PAL_fadeTo(numpal << 4, (numpal << 4) + 15, palette_black, numFrame, async);
+}
+
+void PAL_fadeInPalette(u16 numpal, const u16* pal, u16 numFrame, bool async)
+{
+    PAL_fade(numpal << 4, (numpal << 4) + 15, palette_black, pal, numFrame, async);
+}
+
+
+void PAL_fadeAll(const u16* palSrc, const u16* palDst, u16 numFrame, bool async)
+{
+    PAL_fade(0, 63, palSrc, palDst, numFrame, async);
+}
+
+void PAL_fadeToAll(const u16* pal, u16 numFrame, bool async)
+{
+    PAL_fadeTo(0, 63, pal, numFrame, async);
+}
+
+void PAL_fadeOutAll(u16 numFrame, bool async)
+{
+    PAL_fadeTo(0, 63, palette_black_all, numFrame, async);
+}
+
+void PAL_fadeInAll(const u16* pal, u16 numFrame, bool async)
+{
+    PAL_fade(0, 63, palette_black_all, pal, numFrame, async);
+}
+
+
+bool PAL_isDoingFade()
+{
+    return (VBlankProcess & PROCESS_PALETTE_FADING)?TRUE:FALSE;
+}
+
+void PAL_waitFadeCompletion()
+{
+    // need to do VBlank process otherwise we can wait a long time for completion ^^
+    while (PAL_isDoingFade()) SYS_doVBlankProcess();
+}
+
+void PAL_interruptFade(void)
+{
+    VBlankProcess &= ~PROCESS_PALETTE_FADING;
+}

package/src/platforms/genesis/lib/sgdk/src/pool.c

@@ -0,0 +1,234 @@
+#include "config.h"
+#include "types.h"
+
+#include "pool.h"
+
+#include "memory.h"
+#include "tools.h"
+
+
+Pool* POOL_create(u16 size, u16 objectSize)
+{
+    // word align object size
+    const u16 adjObjectSize = (objectSize + 1) & 0xFFFE;
+    // create the pool
+    Pool* result = MEM_alloc(sizeof(Pool));
+
+    // error on allocation --> return NULL
+    if (result == NULL)
+    {
+#if (LIB_LOG_LEVEL >= LOG_LEVEL_ERROR)
+        kprintf("POOL_create(%d, %d) error: not enough memory (free = %d, largest block = %d)", size, adjObjectSize, MEM_getFree() & 0xFFFF, MEM_getLargestFreeBlock() & 0XFFFF);
+#endif
+        return NULL;
+    }
+
+    // allocate bank (we use objectSize + 2 as we store the object index before the object)
+    result->bank = MEM_alloc(size * (adjObjectSize + 2));
+    // can't allocate ? --> and return NULL
+    if (result->bank == NULL)
+    {
+#if (LIB_LOG_LEVEL >= LOG_LEVEL_ERROR)
+        kprintf("POOL_create(%d, %d) error: not enough memory (free = %d, largest block = %d, required = %d)", size, adjObjectSize, MEM_getFree() & 0xFFFF, MEM_getLargestFreeBlock() & 0XFFFF, size * (adjObjectSize + 2));
+#endif
+
+        // release pool
+        MEM_free(result);
+
+        // and return NULL
+        return NULL;
+    }
+
+    // allocate stack
+    result->allocStack = MEM_alloc(size * sizeof(void*));
+    // can't allocate ?
+    if (result->allocStack == NULL)
+    {
+#if (LIB_LOG_LEVEL >= LOG_LEVEL_ERROR)
+        kprintf("POOL_create(%d, %d) error: not enough memory (free = %d, largest block = %d)", size, adjObjectSize, MEM_getFree() & 0xFFFF, MEM_getLargestFreeBlock() & 0XFFFF);
+#endif
+
+        // release bank & pool
+        MEM_free(result->bank);
+        MEM_free(result);
+
+        // and return NULL
+        return NULL;
+    }
+
+#if (LIB_LOG_LEVEL >= LOG_LEVEL_INFO)
+    kprintf("Object pool succefully created - number of object = %d - object size = %d (free memory = %d)", size, adjObjectSize, MEM_getFree() & 0xFFFF);
+#endif
+
+    // set size
+    result->size = size;
+    result->objectSize = adjObjectSize;
+
+    POOL_reset(result, TRUE);
+
+    return result;
+}
+
+void POOL_reset(Pool* pool, bool clear)
+{
+    u16 i;
+    u16 ind;
+    u16 os;
+    u16* d;
+    void** s;
+
+    // clear bank
+    if (clear)
+        memset(pool->bank, 0, pool->size * (pool->objectSize + 2));
+
+    // reset allocation stack
+    s = pool->allocStack;
+    d = pool->bank;
+    // as we use u16 pointer
+    os = pool->objectSize >> 1;
+    i = pool->size;
+    ind = 0;
+    while(i--)
+    {
+        // store the object index before the object
+        *d++ = ind++;
+        // set current object pointer
+        *s++ = d;
+        // point on next object
+        d += os;
+    }
+
+    // init 'first' position (point at the end of alloc stack)
+    pool->free = s;
+}
+
+void POOL_destroy(Pool* pool)
+{
+    if (pool)
+    {
+        if (pool->allocStack)
+        {
+            // release alloc stack / bank and the pool itself
+            MEM_free(pool->allocStack);
+            pool->allocStack = NULL;
+        }
+        if (pool->bank)
+        {
+            MEM_free(pool->bank);
+            pool->bank = NULL;
+        }
+
+        MEM_free(pool);
+
+#if (LIB_LOG_LEVEL >= LOG_LEVEL_INFO)
+        kprintf("Object pool succefully destroyed - number of object = %d - object size = %d (free memory = %d)", pool->size, pool->objectSize, MEM_getFree() & 0xFFFF);
+#endif
+    }
+#if (LIB_LOG_LEVEL >= LOG_LEVEL_ERROR)
+    else
+    {
+        kprintf("POOL_destroy(): error - trying to destroy a not allocated pool !");
+    }
+#endif
+}
+
+
+void* POOL_allocate(Pool* pool)
+{
+    // pool is empty ?
+    if (pool->free == pool->allocStack)
+    {
+#if (LIB_LOG_LEVEL >= LOG_LEVEL_ERROR)
+        kprintf("POOL_allocate(): failed - no more available object !");
+#endif
+
+        return NULL;
+    }
+
+    // allocate object
+    --pool->free;
+
+#if (LIB_LOG_LEVEL >= LOG_LEVEL_INFO)
+    kprintf("POOL_allocate: object succefully created at position %d - remaining object = %d", POOL_find(pool, *pool->free), POOL_getFree(pool));
+#endif
+
+    // return it
+    return *pool->free;
+}
+
+void POOL_release(Pool* pool, void* object, bool maintainCoherency)
+{
+#if (LIB_LOG_LEVEL >= LOG_LEVEL_ERROR)
+    if (object == NULL)
+        kprintf("POOL_release(): failed - trying to release a NULL object !");
+    // empty pool ?
+    if (pool->free >= &pool->allocStack[pool->size])
+        kprintf("POOL_release(): failed - pool doesn't contain any object !");
+#endif
+
+#if (LIB_LOG_LEVEL >= LOG_LEVEL_INFO)
+    kprintf("POOL_release: object at position %d released - remaining object = %d", POOL_find(pool, object), POOL_getFree(pool) + 1);
+#endif
+
+    // get previous
+    void* prevObject = *pool->free;
+
+    // release object
+    *pool->free = object;
+    pool->free++;
+
+    // different from the one in place ?
+    if (maintainCoherency && (prevObject != object))
+    {
+        // get object index
+        u16* objectIndexP = ((u16*)object) - 1;
+        u16 objectIndex = *objectIndexP;
+
+        // replace with the overwritten one so we can use stack iteration
+        pool->allocStack[objectIndex] = prevObject;
+
+        // get previous object index
+        u16* prevObjectIndexP = ((u16*)prevObject) - 1;
+        u16 prevObjectIndex = *prevObjectIndexP;
+
+        // swap indexes
+        *prevObjectIndexP = objectIndex;
+        *objectIndexP = prevObjectIndex;
+    }
+}
+
+
+u16 POOL_getFree(Pool* pool)
+{
+    return pool->free - pool->allocStack;
+}
+
+u16 POOL_getNumAllocated(Pool* pool)
+{
+    return pool->size - POOL_getFree(pool);
+}
+
+void** POOL_getFirst(Pool* pool)
+{
+    // free point on last allocated object
+    return pool->free;
+}
+
+s16 POOL_find(Pool* pool, void* object)
+{
+    void** s = pool->free;
+    u16 i = POOL_getNumAllocated(pool);
+
+    while(i--)
+    {
+        // we found the object in alloc stack ? --> return its position
+        if (*s == object)
+            return (pool->size - 1) - (s - pool->allocStack);
+        // next
+        s++;
+    }
+
+    // not found
+    return -1;
+}
+