romdev-mcp 0.1.1

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

@@ -0,0 +1,1011 @@
+#include "config.h"
+#include "types.h"
+
+#include "vdp.h"
+#include "vdp_tile.h"
+
+#include "memory.h"
+#include "dma.h"
+#include "tools.h"
+#include "mapper.h"
+
+#include "tab_cnv.h"
+#include "tools.h"
+
+#include "res/libres.h"
+
+
+// forward
+static void setTileMapDataRow(VDPPlane plane, const u16 *data, u16 row, u16 x, u16 w, TransferMethod tm);
+static void setTileMapDataRowEx(VDPPlane plane, const u16 *data, u16 basetile, u16 row, u16 x, u16 w, TransferMethod tm);
+static void setTileMapDataColumn(VDPPlane plane, const u16 *data, u16 column, u16 y, u16 h, u16 wm, TransferMethod tm);
+static void setTileMapDataColumnEx(VDPPlane plane, const u16 *data, u16 basetile, u16 column, u16 y, u16 h, u16 wm, TransferMethod tm);
+
+static void prepareTileMapDataColumn(u16* dest, u16 height, const u16 *data, u16 wm);
+static void prepareTileMapDataRowEx(u16* dest, u16 width, const u16* data, u16 basetile);
+static void prepareTileMapDataColumnEx(u16* dest, u16 height, const u16 *mapData, u16 basetile, u16 wm);
+
+
+void VDP_loadTileData(const u32 *data, u16 index, u16 num, TransferMethod tm)
+{
+    DMA_transfer(tm, DMA_VRAM, (void*) data, index * 32, num * 16, 2);
+}
+
+void VDP_loadFontData(const u32 *font, u16 length, TransferMethod tm)
+{
+    VDP_loadTileData(font, TILE_FONT_INDEX, length, tm);
+}
+
+bool VDP_loadTileSet(const TileSet *tileset, u16 index, TransferMethod tm)
+{
+    return VDP_loadTileSetEx(tileset, index, 0, tileset->numTile, tm);
+}
+
+bool VDP_loadTileSetEx(const TileSet *tileset, u16 index, u16 fromTile, u16 count, TransferMethod tm)
+{
+    // compressed tileset ?
+    if (tileset->compression != COMPRESSION_NONE)
+    {
+        // unpack first
+        TileSet *t = unpackTileSet(tileset, NULL);
+
+        if (t == NULL) return FALSE;
+
+        // tiles
+        VDP_loadTileData(t->tiles + (fromTile * 8), index, count, tm);
+        // be careful, we are releasing buffer here so DMA_QUEUE transfer isn't safe here, use DMA_QUEUE_COPY instead for safe operation
+        MEM_free(t);
+    }
+    else
+        // tiles
+        VDP_loadTileData(FAR_SAFE(tileset->tiles + (fromTile * 8), count * 32), index, count, tm);
+
+    return TRUE;
+}
+
+
+bool VDP_loadFont(const TileSet *font, TransferMethod tm)
+{
+    return VDP_loadTileSet(font, TILE_FONT_INDEX, tm);
+}
+
+bool VDP_loadDefaultFont(TransferMethod tm)
+{
+    return VDP_loadFont(&font_default, tm);
+}
+
+void VDP_loadBMPTileDataEx(const u32 *data, u16 index, u16 x, u16 y, u16 w, u16 h, u16 bmp_w)
+{
+    VDP_loadBMPTileData(&data[x + mulu(y, bmp_w)], index, w, h, bmp_w);
+}
+
+void VDP_fillTileData(u8 value, u16 index, u16 num, bool wait)
+{
+    // do DMA fill
+    DMA_doVRamFill(index * 32, num * 32, value, 1);
+    // wait for DMA completion
+    if (wait)
+        VDP_waitDMACompletion();
+}
+
+
+u16 VDP_getPlaneAddress(VDPPlane plane, u16 x, u16 y)
+{
+    switch(plane)
+    {
+        default:
+        case BG_A:
+            return VDP_BG_A + (((x & (planeWidth - 1)) + ((y & (planeHeight - 1)) << planeWidthSft)) * 2);
+
+        case BG_B:
+            return VDP_BG_B + (((x & (planeWidth - 1)) + ((y & (planeHeight - 1)) << planeWidthSft)) * 2);
+
+        case WINDOW:
+            return VDP_WINDOW + (((x & (windowWidth - 1)) + ((y & (32 - 1)) << windowWidthSft)) * 2);
+    }
+}
+
+
+void VDP_clearTileMap(u16 planeAddr, u16 ind, u16 num, bool wait)
+{
+    // do DMA fill
+    DMA_doVRamFill(planeAddr + (ind * 2), num * 2, 0, 1);
+    // wait for DMA completion
+    if (wait)
+        VDP_waitDMACompletion();
+}
+
+void VDP_fillTileMap(u16 planeAddr, u16 tile, u16 ind, u16 num)
+{
+    vu32 *plctrl;
+    vu16 *pwdata;
+    vu32 *pldata;
+    u32 addr;
+    u16 i;
+
+    VDP_setAutoInc(2);
+
+    /* point to vdp port */
+    plctrl = (u32 *) VDP_CTRL_PORT;
+    pldata = (u32 *) VDP_DATA_PORT;
+
+    addr = planeAddr + (ind * 2);
+
+    *plctrl = VDP_WRITE_VRAM_ADDR(addr);
+
+    const u32 tile32 = ((u32) tile << 16) | tile;
+
+    i = num >> 3;
+    while (i--)
+    {
+        *pldata = tile32;
+        *pldata = tile32;
+        *pldata = tile32;
+        *pldata = tile32;
+    }
+
+    pwdata = (u16 *) VDP_DATA_PORT;
+
+    i = num & 7;
+    while (i--) *pwdata = tile;
+}
+
+
+void VDP_setTileMapData(u16 planeAddr, const u16 *data, u16 ind, u16 num, u16 vramStep, TransferMethod tm)
+{
+    DMA_transfer(tm, DMA_VRAM, (void*) data,  planeAddr + (ind * 2), num, vramStep);
+}
+
+void VDP_setTileMapDataEx(u16 planeAddr, const u16 *data, u16 basetile, u16 ind, u16 num, u16 vramStep)
+{
+    vu32 *plctrl;
+    vu16 *pwdata;
+    const u16 *src;
+    u16 addr;
+    u16 baseinc;
+    u16 baseor;
+    u16 i;
+
+    VDP_setAutoInc(vramStep);
+
+    addr = planeAddr + (ind * 2);
+
+    /* point to vdp port */
+    plctrl = (u32 *) VDP_CTRL_PORT;
+    pwdata = (u16 *) VDP_DATA_PORT;
+
+    *plctrl = VDP_WRITE_VRAM_ADDR((u32) addr);
+
+    // we can increment both index and palette
+    baseinc = basetile & (TILE_INDEX_MASK | TILE_ATTR_PALETTE_MASK);
+    // we can only do logical OR on priority and HV flip
+    baseor = basetile & (TILE_ATTR_PRIORITY_MASK | TILE_ATTR_VFLIP_MASK | TILE_ATTR_HFLIP_MASK);
+
+    src = (u16*) data;
+    i = num >> 2;
+    while (i--)
+    {
+        *pwdata = baseor | (*src++ + baseinc);
+        *pwdata = baseor | (*src++ + baseinc);
+        *pwdata = baseor | (*src++ + baseinc);
+        *pwdata = baseor | (*src++ + baseinc);
+    }
+
+    i = num & 3;
+    while (i--) *pwdata = baseor | (*src++ + baseinc);
+}
+
+
+void VDP_setTileMapXY(VDPPlane plane, u16 tile, u16 x, u16 y)
+{
+    vu32 *plctrl;
+    vu16 *pwdata;
+    u16 addr;
+
+    /* point to vdp port */
+    plctrl = (u32 *) VDP_CTRL_PORT;
+    pwdata = (u16 *) VDP_DATA_PORT;
+
+    // get address
+    addr = VDP_getPlaneAddress(plane, x, y);
+
+    *plctrl = VDP_WRITE_VRAM_ADDR((u32) addr);
+    *pwdata = tile;
+}
+
+void VDP_clearTileMapRect(VDPPlane plane, u16 x, u16 y, u16 w, u16 h)
+{
+    VDP_fillTileMapRect(plane, 0, x, y, w, h);
+}
+
+void VDP_fillTileMapRect(VDPPlane plane, u16 tile, u16 x, u16 y, u16 w, u16 h)
+{
+    vu32 *plctrl;
+    vu32 *pldata;
+    vu16 *pwdata;
+    u16 addr;
+    u16 width;
+    u16 i, j;
+
+    VDP_setAutoInc(2);
+
+    /* point to vdp port */
+    plctrl = (u32 *) VDP_CTRL_PORT;
+    pldata = (u32 *) VDP_DATA_PORT;
+    pwdata = (u16 *) VDP_DATA_PORT;
+
+    addr = VDP_getPlaneAddress(plane, x, y);
+    width = (plane == WINDOW)?windowWidth:planeWidth;
+
+    const u32 tile32 = ((u32) tile << 16) | tile;
+
+    i = h;
+    while (i--)
+    {
+        *plctrl = VDP_WRITE_VRAM_ADDR((u32) addr);
+
+        j = w >> 3;
+        while (j--)
+        {
+            *pldata = tile32;
+            *pldata = tile32;
+            *pldata = tile32;
+            *pldata = tile32;
+        }
+
+        j = w & 7;
+        while (j--) *pwdata = tile;
+
+        addr += width * 2;
+    }
+}
+
+void VDP_fillTileMapRectInc(VDPPlane plane, u16 basetile, u16 x, u16 y, u16 w, u16 h)
+{
+    vu32 *plctrl;
+    vu16 *pwdata;
+    u16 addr;
+    u16 width;
+    u16 tile;
+    u16 i, j;
+
+    VDP_setAutoInc(2);
+
+    /* point to vdp port */
+    plctrl = (u32 *) VDP_CTRL_PORT;
+    pwdata = (u16 *) VDP_DATA_PORT;
+
+    addr = VDP_getPlaneAddress(plane, x, y);
+    width = (plane == WINDOW)?windowWidth:planeWidth;
+    tile = basetile;
+
+    i = h;
+    while (i--)
+    {
+        *plctrl = VDP_WRITE_VRAM_ADDR((u32) addr);
+
+        j = w;
+        while (j--) *pwdata = tile++;
+
+        addr += width * 2;
+    }
+}
+
+
+void VDP_setTileMapDataRect(VDPPlane plane, const u16 *data, u16 x, u16 y, u16 w, u16 h, u16 wm, TransferMethod tm)
+{
+    const u16* src = data;
+    const u16 pw = (plane == WINDOW)?windowWidth:planeWidth;
+
+    // if plan width < 128 (we cannot do 256 bytes auto increment) and
+    // if half less number of column than number of row --> we use column transfer
+    if ((pw < 128) && (w < (h / 2)))
+    {
+        const u16 ph = (plane == WINDOW)?32:planeHeight;
+        const u16 yAdj = y & (ph - 1);
+        u16 h1, h2;
+        u32 off;
+
+        // larger than plane height ? --> need to split
+        if ((yAdj + h) > ph)
+        {
+            // first part
+            h1 = ph - yAdj;
+            // second part
+            h2 = h - h1;
+            // offset
+            off = mulu(wm, h1);
+        }
+        else
+        {
+            // no split
+            h1 = h;
+            h2 = 0;
+            off = 0;
+        }
+
+        u16 col = x;
+        u16 i = w;
+
+        // set region by column
+        while (i--)
+        {
+            // first part
+            setTileMapDataColumn(plane, src, col, yAdj, h1, wm, tm);
+            // second part
+            if (h2 != 0) setTileMapDataColumn(plane, src + off, col, 0, h2, wm, tm);
+            col++;
+            src++;
+        }
+    }
+    else
+    {
+        const u16 xAdj = x & (pw - 1);
+        u16 w1, w2;
+
+        // larger than plane width ? --> need to split
+        if ((xAdj + w) > pw)
+        {
+            // first part
+            w1 = pw - xAdj;
+            // second part
+            w2 = w - w1;
+        }
+        else
+        {
+            w1 = w;
+            w2 = 0;
+        }
+
+        u16 row = y;
+        u16 i = h;
+
+        // otherwise we set region by row (faster)
+        while (i--)
+        {
+            // first part
+            setTileMapDataRow(plane, src, row, xAdj, w1, tm);
+            // second part
+            if (w2 != 0) setTileMapDataRow(plane, src + w1, row, 0, w2, tm);
+            row++;
+            src += wm;
+        }
+    }
+}
+
+void VDP_setTileMapDataRectEx(VDPPlane plane, const u16 *data, u16 basetile, u16 x, u16 y, u16 w, u16 h, u16 wm, TransferMethod tm)
+{
+    const u16* src = data;
+    const u16 pw = (plane == WINDOW)?windowWidth:planeWidth;
+
+    // if plan width < 128 (we cannot do 256 bytes auto increment) and
+    // if half less number of column than number of row --> we use column transfer
+    if ((pw < 128) && (w < (h / 2)))
+    {
+        const u16 ph = (plane == WINDOW)?32:planeHeight;
+        const u16 yAdj = y & (ph - 1);
+        u16 h1, h2;
+        u32 off;
+
+        // larger than plane height ? --> need to split
+        if ((yAdj + h) > ph)
+        {
+            // first part
+            h1 = ph - yAdj;
+            // second part
+            h2 = h - h1;
+            // offset
+            off = mulu(wm, h1);
+        }
+        else
+        {
+            // no split
+            h1 = h;
+            h2 = 0;
+            off = 0;
+        }
+
+        u16 col = x;
+        u16 i = w;
+
+        // set region by column
+        while (i--)
+        {
+            // first part
+            setTileMapDataColumnEx(plane, src, basetile, col, yAdj, h1, wm, tm);
+            // second part
+            if (h2 != 0) setTileMapDataColumnEx(plane, src + off, basetile, col, 0, h2, wm, tm);
+            col++;
+            src++;
+        }
+    }
+    else
+    {
+        const u16 xAdj = x & (pw - 1);
+        u16 w1, w2;
+
+        // larger than plane width ? --> need to split
+        if ((xAdj + w) > pw)
+        {
+            // first part
+            w1 = pw - xAdj;
+            // second part
+            w2 = w - w1;
+        }
+        else
+        {
+            w1 = w;
+            w2 = 0;
+        }
+
+        u16 row = y;
+        u16 i = h;
+
+        // otherwise we set region by row (faster)
+        while (i--)
+        {
+            // first part
+            setTileMapDataRowEx(plane, src, basetile, row, xAdj, w1, tm);
+            // second part
+            if (w2 != 0) setTileMapDataRowEx(plane, src + w1, basetile, row, 0, w2, tm);
+            row++;
+            src += wm;
+        }
+    }
+}
+
+
+static void setTileMapDataRow(VDPPlane plane, const u16 *data, u16 row, u16 x, u16 w, TransferMethod tm)
+{
+    DMA_transfer(tm, DMA_VRAM, (void*) data, VDP_getPlaneAddress(plane, x, row), w, 2);
+}
+
+static void setTileMapDataRowEx(VDPPlane plane, const u16 *data, u16 basetile, u16 row, u16 x, u16 w, TransferMethod tm)
+{
+    const u16 addr = VDP_getPlaneAddress(plane, x, row);
+
+    if (tm >= DMA_QUEUE)
+    {
+        // get temp buffer and schedule DMA
+        u16* buf = DMA_allocateAndQueueDma(DMA_VRAM, addr, w, 2);
+
+#if (LIB_LOG_LEVEL >= LOG_LEVEL_ERROR)
+        if (!buf)
+        {
+            KLog("VDP_setTileMapDataRowEx failed: DMA temporary buffer is full");
+            return;
+        }
+#endif
+        // then prepare data in buffer that will be transferred by DMA
+        prepareTileMapDataRowEx(buf, w, data, basetile);
+    }
+    // DMA is interesting only for long transfer
+    else if ((tm == DMA) && (w > 16))
+    {
+        // allocate on DMA buffer
+        u16* buf = DMA_allocateTemp(w);
+
+        // prepare tilemap data into temp buffer
+        prepareTileMapDataRowEx(buf, w, data, basetile);
+        // transfer the buffer data to VRAM (can use fast version here as source is in RAM)
+        DMA_doDmaFast(DMA_VRAM, buf, addr, w, 2);
+
+        // release allocated buffer
+        DMA_releaseTemp(w);
+    }
+    else
+    {
+        // CPU copy
+        VDP_setTileMapDataEx(addr, data, basetile, 0, w, 2);
+    }
+}
+
+void VDP_setTileMapDataRow(VDPPlane plane, const u16 *data, u16 row, u16 x, u16 w, TransferMethod tm)
+{
+    const u16 pw = (plane == WINDOW)?windowWidth:planeWidth;
+    const u16 xAdj = x & (pw - 1);
+
+    // larger than plane width ? --> need to split
+    if ((xAdj + w) > pw)
+    {
+        u16 w1 = pw - xAdj;
+
+        // first part
+        setTileMapDataRow(plane, data, row, xAdj, w1, tm);
+        // second part
+        setTileMapDataRow(plane, data + w1, row, 0, w - w1, tm);
+    }
+    // no split needed
+    else setTileMapDataRow(plane, data, row, xAdj, w, tm);
+}
+
+void VDP_setTileMapDataRowEx(VDPPlane plane, const u16 *data, u16 basetile, u16 row, u16 x, u16 w, TransferMethod tm)
+{
+    const u16 pw = (plane == WINDOW)?windowWidth:planeWidth;
+    const u16 xAdj = x & (pw - 1);
+
+    // larger than plane width ? --> need to split
+    if ((xAdj + w) > pw)
+    {
+        u16 w1 = pw - xAdj;
+
+        // first part
+        setTileMapDataRowEx(plane, data, basetile, row, xAdj, w1, tm);
+        // second part
+        setTileMapDataRowEx(plane, data + w1, basetile, row, 0, w - w1, tm);
+    }
+    // no split needed
+    else setTileMapDataRowEx(plane, data, basetile, row, xAdj, w, tm);
+}
+
+
+static void setTileMapDataColumn(VDPPlane plane, const u16 *data, u16 column, u16 y, u16 h, u16 wm, TransferMethod tm)
+{
+    const u16 addr = VDP_getPlaneAddress(plane, column, y);
+    const u16 pw = (plane == WINDOW)?windowWidth:planeWidth;
+
+#if (LIB_LOG_LEVEL >= LOG_LEVEL_ERROR)
+    if (pw == 128)
+        KLog("setTileMapDataColumn(..) error: cannot be used when tilemap width is set to 128 !");
+#endif
+
+    if (tm >= DMA_QUEUE)
+    {
+        // get temp buffer and schedule DMA
+        u16* buf = DMA_allocateAndQueueDma(DMA_VRAM, addr, h, pw * 2);
+
+#if (LIB_LOG_LEVEL >= LOG_LEVEL_ERROR)
+        if (!buf)
+        {
+            KLog("VDP_setTileMapDataColumn failed: DMA temporary buffer is full");
+            return;
+        }
+#endif
+        // then prepare data in buffer that will be transferred by DMA
+        prepareTileMapDataColumn(buf, h, data, wm);
+    }
+    // DMA is interesting only for long transfer
+    else if ((tm == DMA) && (h > 16))
+    {
+        // allocate on DMA buffer
+        u16* buf = DMA_allocateTemp(h);
+
+        // prepare tilemap data into temp buffer
+        prepareTileMapDataColumn(buf, h, data, wm);
+        // transfer the temp data to VRAM (can use fast version here as source is in RAM)
+        DMA_doDmaFast(DMA_VRAM, buf, addr, h, pw * 2);
+
+        // release allocated buffer
+        DMA_releaseTemp(h);
+    }
+    // CPU copy
+    else
+    {
+        vu32 *plctrl;
+        vu16 *pwdata;
+        const u16 *src;
+        u16 i;
+
+        VDP_setAutoInc(pw * 2);
+
+        /* point to vdp port */
+        plctrl = (u32 *) VDP_CTRL_PORT;
+        pwdata = (u16 *) VDP_DATA_PORT;
+
+        *plctrl = VDP_WRITE_VRAM_ADDR((u32) addr);
+
+        src = (u16*) data;
+        i = h >> 2;
+        while (i--)
+        {
+            *pwdata = *src;
+            src += wm;
+            *pwdata = *src;
+            src += wm;
+            *pwdata = *src;
+            src += wm;
+            *pwdata = *src;
+            src += wm;
+        }
+
+        i = h & 3;
+        while (i--)
+        {
+            *pwdata = *src;
+            src += wm;
+        }
+    }
+}
+
+static void setTileMapDataColumnEx(VDPPlane plane, const u16 *data, u16 basetile, u16 column, u16 y, u16 h, u16 wm, TransferMethod tm)
+{
+    const u16 addr = VDP_getPlaneAddress(plane, column, y);
+    const u16 pw = (plane == WINDOW)?windowWidth:planeWidth;
+
+#if (LIB_LOG_LEVEL >= LOG_LEVEL_ERROR)
+    if (pw == 128)
+        KLog("setTileMapDataColumnEx(..) error: cannot be used when tilemap width is set to 128 !");
+#endif
+
+    if (tm >= DMA_QUEUE)
+    {
+        // get temp buffer and schedule DMA
+        u16* buf = DMA_allocateAndQueueDma(DMA_VRAM, addr, h, pw * 2);
+
+#if (LIB_LOG_LEVEL >= LOG_LEVEL_ERROR)
+        if (!buf)
+        {
+            KLog("setTileMapDataColumnEx(..) failed: DMA temporary buffer is full");
+            return;
+        }
+#endif
+        // then prepare data in buffer that will be transferred by DMA
+        prepareTileMapDataColumnEx(buf, h, data, basetile, wm);
+    }
+    // DMA is interesting only for long transfer
+    else if ((tm == DMA) && (h > 16))
+    {
+        // allocate on DMA buffer
+        u16* buf = DMA_allocateTemp(h);
+
+        // prepare tilemap data into temp buffer
+        prepareTileMapDataColumnEx(buf, h, data, basetile, wm);
+        // transfer the buffer data to VRAM (can use fast version here as source is in RAM)
+        DMA_doDmaFast(DMA_VRAM, buf, addr, h, pw * 2);
+
+        // release allocated buffer
+        DMA_releaseTemp(h);
+    }
+    // CPU copy
+    else
+    {
+        vu32 *plctrl;
+        vu16 *pwdata;
+        const u16 *src;
+        u16 baseinc;
+        u16 baseor;
+        u16 i;
+
+        VDP_setAutoInc(pw * 2);
+
+        /* point to vdp port */
+        plctrl = (u32 *) VDP_CTRL_PORT;
+        pwdata = (u16 *) VDP_DATA_PORT;
+
+        *plctrl = VDP_WRITE_VRAM_ADDR((u32) addr);
+
+        // we can increment both index and palette
+        baseinc = basetile & (TILE_INDEX_MASK | TILE_ATTR_PALETTE_MASK);
+        // we can only do logical OR on priority and HV flip
+        baseor = basetile & (TILE_ATTR_PRIORITY_MASK | TILE_ATTR_VFLIP_MASK | TILE_ATTR_HFLIP_MASK);
+
+        src = (u16*) data;
+        i = h >> 2;
+        while (i--)
+        {
+            *pwdata = baseor | (*src + baseinc);
+            src += wm;
+            *pwdata = baseor | (*src + baseinc);
+            src += wm;
+            *pwdata = baseor | (*src + baseinc);
+            src += wm;
+            *pwdata = baseor | (*src + baseinc);
+            src += wm;
+        }
+
+        i = h & 3;
+        while (i--)
+        {
+            *pwdata = baseor | (*src + baseinc);
+            src += wm;
+        }
+    }
+}
+
+void VDP_setTileMapDataColumnFast(VDPPlane plane, u16* data, u16 column, u16 y, u16 h, TransferMethod tm)
+{
+    const u16 addr = VDP_getPlaneAddress(plane, column, y);
+    const u16 pw = (plane == WINDOW)?windowWidth:planeWidth;
+    const u16 ph = (plane == WINDOW)?32:planeHeight;
+    const u16 yAdj = y & (ph - 1);
+
+#if (LIB_LOG_LEVEL >= LOG_LEVEL_ERROR)
+    if (pw == 128)
+        KLog("VDP_setTileMapDataColumnFast(..) error: cannot be used when tilemap width is set to 128 !");
+#endif
+
+    // larger than plane height ? --> need to split
+    if ((yAdj + h) > ph)
+    {
+        u16 h1 = ph - yAdj;
+
+        // first part
+        DMA_transfer(tm, DMA_VRAM, data, addr, h1, pw * 2);
+        // second part
+        DMA_transfer(tm, DMA_VRAM, data + h1, VDP_getPlaneAddress(plane, column, 0), h - h1, pw * 2);
+    }
+    // no split needed
+    else DMA_transfer(tm, DMA_VRAM, data, addr, h, pw * 2);
+}
+
+void VDP_setTileMapDataColumn(VDPPlane plane, const u16 *data, u16 column, u16 y, u16 h, u16 wm, TransferMethod tm)
+{
+    const u16 ph = (plane == WINDOW)?32:planeHeight;
+    const u16 yAdj = y & (ph - 1);
+
+    // larger than plane height ? --> need to split
+    if ((yAdj + h) > ph)
+    {
+        u16 h1 = ph - yAdj;
+
+        // first part
+        setTileMapDataColumn(plane, data, column, yAdj, h1, wm, tm);
+        // second part
+        setTileMapDataColumn(plane, data + mulu(wm, h1), column, 0, h - h1, wm, tm);
+    }
+    // no split needed
+    else setTileMapDataColumn(plane, data, column, yAdj, h, wm, tm);
+}
+
+void VDP_setTileMapDataColumnEx(VDPPlane plane, const u16 *data, u16 basetile, u16 column, u16 y, u16 h, u16 wm, TransferMethod tm)
+{
+    const u16 ph = (plane == WINDOW)?32:planeHeight;
+    const u16 yAdj = y & (ph - 1);
+
+    // larger than plane height ? --> need to split
+    if ((yAdj + h) > ph)
+    {
+        u16 h1 = ph - yAdj;
+
+        // first part
+        setTileMapDataColumnEx(plane, data, basetile, column, yAdj, h1, wm, tm);
+        // second part
+        setTileMapDataColumnEx(plane, data + mulu(wm, h1), basetile, column, 0, h - h1, wm, tm);
+    }
+    // no split needed
+    else setTileMapDataColumnEx(plane, data, basetile, column, yAdj, h, wm, tm);
+}
+
+
+bool VDP_setTileMap(VDPPlane plane, const TileMap *tilemap, u16 x, u16 y, u16 w, u16 h, TransferMethod tm)
+{
+    const u32 offset = mulu(y, tilemap->w) + x;
+
+    // compressed tilemap ?
+    if (tilemap->compression != COMPRESSION_NONE)
+    {
+        // unpack first
+        TileMap *m = unpackTileMap(tilemap, NULL);
+
+        if (m == NULL) return FALSE;
+
+        // tilemap
+        VDP_setTileMapDataRect(plane, m->tilemap + offset, x, y, w, h, m->w, tm);
+        // be careful, we are releasing buffer here so DMA_QUEUE transfer isn't safe here, use DMA_QUEUE_COPY instead for safe operation
+        MEM_free(m);
+    }
+    else
+        // tilemap
+        VDP_setTileMapDataRect(plane, (u16*) FAR_SAFE(tilemap->tilemap + offset, mulu(tilemap->w, h) * 2), x, y, w, h, tilemap->w, tm);
+
+    return TRUE;
+}
+
+bool VDP_setTileMapEx(VDPPlane plane, const TileMap *tilemap, u16 basetile, u16 xp, u16 yp, u16 x, u16 y, u16 w, u16 h, TransferMethod tm)
+{
+    const u32 offset = mulu(y, tilemap->w) + x;
+
+    // compressed tilemap ?
+    if (tilemap->compression != COMPRESSION_NONE)
+    {
+        // unpack first
+        TileMap *m = unpackTileMap(tilemap, NULL);
+
+        if (m == NULL) return FALSE;
+
+        // tilemap
+        VDP_setTileMapDataRectEx(plane, m->tilemap + offset, basetile, xp, yp, w, h, m->w, tm);
+        // be careful, we are releasing buffer here so DMA_QUEUE transfer isn't safe here, use DMA_QUEUE_COPY instead for safe operation
+        MEM_free(m);
+    }
+    else
+        // tilemap
+        VDP_setTileMapDataRectEx(plane, (u16*) FAR_SAFE(tilemap->tilemap + offset, mulu(tilemap->w, h) * 2), basetile, xp, yp, w, h, tilemap->w, tm);
+
+    return TRUE;
+}
+
+bool VDP_setTileMapRow(VDPPlane plane, const TileMap *tilemap, u16 row, u16 x, u16 w, TransferMethod tm)
+{
+    const u32 offset = mulu(row, tilemap->w) + x;
+
+    // compressed tilemap ?
+    if (tilemap->compression != COMPRESSION_NONE)
+    {
+        // unpack first
+        TileMap *m = unpackTileMap(tilemap, NULL);
+
+        if (m == NULL) return FALSE;
+
+        // tilemap
+        VDP_setTileMapDataRow(plane, m->tilemap + offset, row, x, w, tm);
+        // be careful, we are releasing buffer here so DMA_QUEUE transfer isn't safe here, use DMA_QUEUE_COPY instead for safe operation
+        MEM_free(m);
+    }
+    else
+        // tilemap
+        VDP_setTileMapDataRow(plane, (u16*) FAR_SAFE(tilemap->tilemap + offset, w * 2), row, x, w, tm);
+
+    return TRUE;
+}
+
+bool VDP_setTileMapRowEx(VDPPlane plane, const TileMap *tilemap, u16 basetile, u16 row, u16 x, u16 y, u16 w, TransferMethod tm)
+{
+    const u32 offset = mulu(y, tilemap->w) + x;
+
+    // compressed tilemap ?
+    if (tilemap->compression != COMPRESSION_NONE)
+    {
+        // unpack first
+        TileMap *m = unpackTileMap(tilemap, NULL);
+
+        if (m == NULL) return FALSE;
+
+        // tilemap
+        VDP_setTileMapDataRowEx(plane, m->tilemap + offset, basetile, row, x, w, tm);
+        // be careful, we are releasing buffer here so DMA_QUEUE transfer isn't safe here, use DMA_QUEUE_COPY instead for safe operation
+        MEM_free(m);
+    }
+    else
+        // tilemap
+        VDP_setTileMapDataRowEx(plane, (u16*) FAR_SAFE(tilemap->tilemap + offset, w * 2), basetile, row, x, w, tm);
+
+    return TRUE;
+}
+
+
+bool VDP_setTileMapColumn(VDPPlane plane, const TileMap *tilemap, u16 column, u16 y, u16 h, TransferMethod tm)
+{
+    const u32 offset = mulu(y, tilemap->w) + column;
+
+    // compressed tilemap ?
+    if (tilemap->compression != COMPRESSION_NONE)
+    {
+        // unpack first
+        TileMap *m = unpackTileMap(tilemap, NULL);
+
+        if (m == NULL) return FALSE;
+
+        // tilemap
+        VDP_setTileMapDataColumn(plane, m->tilemap + offset, column, y, h, m->w, tm);
+        // be careful, we are releasing buffer here so DMA_QUEUE transfer isn't safe here, use DMA_QUEUE_COPY instead for safe operation
+        MEM_free(m);
+    }
+    else
+        // tilemap
+        VDP_setTileMapDataColumn(plane, (u16*) FAR_SAFE(tilemap->tilemap + offset, mulu(tilemap->w, h) * 2), column, y, h, tilemap->w, tm);
+
+    return TRUE;
+}
+
+bool VDP_setTileMapColumnEx(VDPPlane plane, const TileMap *tilemap, u16 basetile, u16 column, u16 x, u16 y, u16 h, TransferMethod tm)
+{
+    const u32 offset = mulu(y, tilemap->w) + x;
+
+    // compressed tilemap ?
+    if (tilemap->compression != COMPRESSION_NONE)
+    {
+        // unpack first
+        TileMap *m = unpackTileMap(tilemap, NULL);
+
+        if (m == NULL) return FALSE;
+
+        // tilemap
+        VDP_setTileMapDataColumnEx(plane, m->tilemap + offset, basetile, column, y, h, m->w, tm);
+        // be careful, we are releasing buffer here so DMA_QUEUE transfer isn't safe here, use DMA_QUEUE_COPY instead for safe operation
+        MEM_free(m);
+    }
+    else
+        // tilemap
+        VDP_setTileMapDataColumnEx(plane, (u16*) FAR_SAFE(tilemap->tilemap + offset, mulu(tilemap->w, h) * 2), basetile, column, y, h, tilemap->w, tm);
+
+    return TRUE;
+}
+
+
+bool VDP_setMap(VDPPlane plane, const TileMap *tilemap, u16 basetile, u16 x, u16 y)
+{
+    return VDP_setTileMapEx(plane, tilemap, basetile, x, y, 0, 0, tilemap->w, tilemap->h, CPU);
+}
+
+bool VDP_setMapEx(VDPPlane plane, const TileMap *tilemap, u16 basetile, u16 x, u16 y, u16 xm, u16 ym, u16 wm, u16 hm)
+{
+    return VDP_setTileMapEx(plane, tilemap, basetile, x, y, xm, ym, wm, hm, CPU);
+}
+
+
+static void prepareTileMapDataColumn(u16* dest, u16 height, const u16 *data, u16 wm)
+{
+    u16* d = dest;
+    const u16* s = data;
+    u16 i;
+
+    i = height >> 2;
+    while (i--)
+    {
+        *d++ = *s;
+        s += wm;
+        *d++ = *s;
+        s += wm;
+        *d++ = *s;
+        s += wm;
+        *d++ = *s;
+        s += wm;
+    }
+
+    i = height & 3;
+    while (i--)
+    {
+        *d++ = *s;
+        s += wm;
+    }
+}
+
+static void prepareTileMapDataRowEx(u16* dest, u16 width, const u16* data, u16 basetile)
+{
+    // we can increment both index and palette
+    const u16 baseinc = basetile & (TILE_INDEX_MASK | TILE_ATTR_PALETTE_MASK);
+    // we can only do logical OR on priority and HV flip
+    const u16 baseor = basetile & (TILE_ATTR_PRIORITY_MASK | TILE_ATTR_VFLIP_MASK | TILE_ATTR_HFLIP_MASK);
+
+    const u16* s = data;
+    u16* d = dest;
+    u16 i;
+
+    i = width >> 2;
+    // prepare map data for row update
+    while (i--)
+    {
+        *d++ = baseor | (*s++ + baseinc);
+        *d++ = baseor | (*s++ + baseinc);
+        *d++ = baseor | (*s++ + baseinc);
+        *d++ = baseor | (*s++ + baseinc);
+    }
+
+    i = width & 3;
+    // prepare map data for row update
+    while (i--) *d++ = baseor | (*s++ + baseinc);
+}
+
+static void prepareTileMapDataColumnEx(u16* dest, u16 height, const u16 *data, u16 basetile, u16 wm)
+{
+    // we can increment both index and palette
+    const u16 baseinc = basetile & (TILE_INDEX_MASK | TILE_ATTR_PALETTE_MASK);
+    // we can only do logical OR on priority and HV flip
+    const u16 baseor = basetile & (TILE_ATTR_PRIORITY_MASK | TILE_ATTR_VFLIP_MASK | TILE_ATTR_HFLIP_MASK);
+
+    // prepare map data for column update
+    u16* d = dest;
+    const u16* s = data;
+    u16 i;
+
+    i = height >> 2;
+    while (i--)
+    {
+        *d++ = baseor | (*s + baseinc);
+        s += wm;
+        *d++ = baseor | (*s + baseinc);
+        s += wm;
+        *d++ = baseor | (*s + baseinc);
+        s += wm;
+        *d++ = baseor | (*s + baseinc);
+        s += wm;
+    }
+
+    i = height & 3;
+    while (i--)
+    {
+        *d++ = baseor | (*s + baseinc);
+        s += wm;
+    }
+}