romdevtools 0.71.0 → 0.84.0

package/src/platforms/gametank/lib/gt/gfx/draw_queue.c

@@ -0,0 +1,177 @@
+#define MODULE_DRAWQUEUE_INTERNAL_USE
+#include "draw_queue.h"
+#include "gametank.h"
+#include "modules_enabled.h"
+
+#ifdef ENABLE_MODULE_DRAWQUEUE
+
+void pushRect();
+
+unsigned char queue_start = 0;
+unsigned char queue_end = 0;
+unsigned char queue_count = 0;
+unsigned char queue_pending = 0;
+
+void queue_draw_sprite_rect() {
+    if(queue_count >= QUEUE_MAX) {
+        asm("CLI");
+        await_drawing();
+    }
+
+    asm("SEI");
+    if(rect.b & SPRITE_OFFSET_X_MASK) { rect.gx |= 128; }
+    if(rect.b & SPRITE_OFFSET_Y_MASK) { rect.gy |= 128; }
+    rect.b = (rect.b & BANK_GRAM_MASK) | bankflip | CLIP_MODE_XY;
+    queue_flags_param = DMA_GCARRY;
+    pushRect();
+
+    if(queue_pending == 0) {
+        next_draw_queue();
+    }
+    asm("CLI");
+}
+
+void queue_draw_box(unsigned char x, unsigned char y, unsigned char w, unsigned char h, unsigned char c) {
+    if(x > 127) {
+        return;
+    }
+    if(y > 127) {
+        return;
+    }
+    if(w == 0) {
+        return;
+    }
+    if(h == 0) {
+        return;
+    }
+    while(queue_count >= QUEUE_MAX) {
+        asm("CLI");
+        await_drawing();
+    }
+    if(x + w >= 128) {
+        w = 128 - x;
+    }
+    if(y + h >= 128) {
+        h = 128 - y;
+    }
+    asm("SEI");
+
+    rect.x = x;
+    rect.y = y;
+    rect.w = w;
+    rect.h = h;
+    rect.gx = 0;
+    rect.gy = 0;
+    rect.b = bankflip;
+    rect.c = ~c;
+    queue_flags_param = DMA_COLORFILL_ENABLE | DMA_OPAQUE;
+    pushRect();
+    
+
+    if(queue_pending == 0) {
+        next_draw_queue();
+    }
+    asm("CLI");
+}
+
+void queue_clear_border(char c) {
+    queue_draw_box(
+        0,
+        0,
+        SCREEN_WIDTH-BORDER_RIGHT_WIDTH,
+        BORDER_TOP_HEIGHT,
+        c
+    );
+    queue_draw_box(
+        0,
+        BORDER_TOP_HEIGHT,
+        BORDER_LEFT_WIDTH,
+        SCREEN_HEIGHT-BORDER_TOP_HEIGHT,
+        c
+    );
+    queue_draw_box(
+        BORDER_LEFT_WIDTH,
+        SCREEN_HEIGHT-BORDER_BOTTOM_HEIGHT,
+        SCREEN_WIDTH-BORDER_LEFT_WIDTH,
+        BORDER_BOTTOM_HEIGHT,
+        c
+    );
+    queue_draw_box(
+        SCREEN_WIDTH-BORDER_RIGHT_WIDTH,
+        0,
+        BORDER_RIGHT_WIDTH,
+        SCREEN_HEIGHT-BORDER_BOTTOM_HEIGHT,
+        c
+    );
+}
+
+void queue_draw_sprite_frame(SpriteSlot sprite, char x, char y, char frame, char flip) {
+    while(queue_count >= QUEUE_MAX) {
+        asm("CLI");
+        await_drawing();
+    }
+    asm("SEI");
+    queue_flags_param = DMA_GCARRY;
+    sprite_fetch_frame(sprite, frame);
+    rect.b = (sprite & BANK_GRAM_MASK) | bankflip | CLIP_MODE_XY;
+
+    if(flip & SPRITE_FLIP_X) {
+        rect.x = (x - sprite_temp_frame.w - sprite_temp_frame.x - 1);
+    } else {
+        rect.x = (sprite_temp_frame.x + x);
+    }
+
+    if(flip & SPRITE_FLIP_Y) {
+        rect.y = (y - sprite_temp_frame.h - sprite_temp_frame.y - 1);
+    } else {
+        rect.y = (sprite_temp_frame.y + y);
+    }
+
+    rect.gx = sprite_temp_frame.gx;
+    if(sprite & SPRITE_OFFSET_X_MASK) { rect.gx |= 128; }
+    if(flip & SPRITE_FLIP_X) {
+        rect.gx ^= 0xFF;
+        rect.gx -= sprite_temp_frame.w - 1;
+    }
+
+    rect.gy = sprite_temp_frame.gy;
+    if(sprite & SPRITE_OFFSET_Y_MASK) { rect.gy |= 128; }
+    if(flip & SPRITE_FLIP_Y) {
+        rect.gy ^= 0xFF;
+        rect.gy -= sprite_temp_frame.h - 1;
+    }
+
+    rect.w = sprite_temp_frame.w | (flip & SPRITE_FLIP_X ? 128 : 0);
+    rect.h = sprite_temp_frame.h | (flip & SPRITE_FLIP_Y ? 128 : 0);
+
+    pushRect();
+
+    if(queue_pending == 0) {
+        next_draw_queue();
+    }
+    asm("CLI");
+}
+
+void queue_clear_screen(char c) {
+    queue_draw_box(1, 7, SCREEN_WIDTH-2, SCREEN_HEIGHT - 15, c);
+}
+
+#endif
+
+void await_draw_queue() {
+    //If draw queue isn't installed leave the stub in case something waits for it
+#ifdef ENABLE_MODULE_DRAWQUEUE
+    asm ("SEI");
+    if(queue_pending != 0) {
+        await_drawing();
+    }
+    while(queue_end != queue_start) {
+        next_draw_queue();
+        asm ("CLI");
+        await_drawing();
+    }
+    vram[START] = 0;
+    queue_pending = 0;
+    asm ("CLI");
+#endif
+}

package/src/platforms/gametank/lib/gt/gfx/draw_queue.h

@@ -0,0 +1,35 @@
+#ifndef DRAW_QUEUE_H
+#define DRAW_QUEUE_H
+#include "gfx_sys.h"
+#include "sprites.h"
+#include "modules_enabled.h"
+
+#ifdef ENABLE_MODULE_DRAWQUEUE
+
+#define QUEUE_MAX 250
+
+extern unsigned char queue_start, queue_end, queue_pending, queue_count;
+extern unsigned char queue_flags_param; //defined in draw_util.s
+
+void queue_draw_box(unsigned char x, unsigned char y, unsigned char w, unsigned char h, unsigned char c);
+void queue_draw_sprite_rect();
+
+#define queue_draw_sprite(X,Y,W,H,GX,GY,SPRITESLOT) rect.x=X;rect.y=Y;rect.w=W;rect.h=H;rect.gx=GX;rect.gy=GY;rect.b=SPRITESLOT;queue_draw_sprite_rect();
+void queue_draw_sprite_frame(SpriteSlot sprite, char x, char y, char frame, char flip);
+
+
+void queue_clear_border(char c);
+void queue_clear_screen(char c);
+
+//defined in draw_util.s
+void next_draw_queue();
+
+#else
+
+#ifndef MODULE_DRAWQUEUE_INTERNAL_USE
+#error "Module DRAWQUEUE included but not enabled!"
+#endif
+#endif
+
+void await_draw_queue();
+#endif

package/src/platforms/gametank/lib/gt/gfx/draw_util.s

@@ -0,0 +1,157 @@
+.export _rect
+.importzp sp, ptr1
+
+.import incsp2, pushax
+.import _flagsMirror, _frameflip, _draw_busy
+.import _banksMirror
+
+.include "modules_enabled.inc"
+
+.ifdef ENABLE_MODULE_DRAWQUEUE
+.export _pushRect, _queue_flags_param, _next_draw_queue
+.import _queue_start,_queue_end, _queue_count, _queue_pending
+.endif
+
+BankReg = $2005
+DMAFlags = $2007
+
+Q_DMAFlags = $0200
+Q_VX       = $0300
+Q_VY       = $0400
+Q_GX       = $0500
+Q_GY       = $0600
+Q_WIDTH    = $0700
+Q_HEIGHT   = $0800
+Q_Color    = $0900
+Q_BankReg  = $0A00
+
+DMA_VX = $4000
+DMA_VY = $4001
+DMA_GX = $4002
+DMA_GY = $4003
+DMA_WIDTH = $4004
+DMA_HEIGHT = $4005
+DMA_Start = $4006
+DMA_Color = $4007
+
+_queue_flags_param = $3200
+_rect = $3201 ;borrow unbanked Audio RAM memory
+
+.ifdef ENABLE_MODULE_DRAWQUEUE
+; ---------------------------------------------------------------
+; void __near__ pushRect ()
+; ---------------------------------------------------------------
+
+.segment	"CODE"
+
+.proc	_pushRect: near
+
+.segment	"CODE"
+
+    jsr     pushax
+
+    ldy     _queue_end
+    inc     _queue_end
+    inc     _queue_count
+
+    lda     _banksMirror ;get current banks reg
+    tax
+    ora     #$40 ;make BANK1 version of same
+    sta     BankReg ;switch to BANK1
+
+
+    lda     _rect+7 ;bank
+    sta     Q_BankReg, y
+
+    lda     _rect+0 ;x
+    sta     Q_VX, y
+
+    lda     _rect+1 ;y
+    sta     Q_VY, y
+
+    lda     _rect+4 ;gx
+    sta     Q_GX, y
+
+    lda     _rect+5 ;gy
+    sta     Q_GY, y
+
+    lda     _rect+2 ;w
+    sta     Q_WIDTH, y
+
+    lda     _rect+3 ;h
+    sta     Q_HEIGHT, y
+
+    lda     _rect+6 ;color
+    sta     Q_Color, y
+
+    lda     _queue_flags_param ;flags
+    sta     Q_DMAFlags, y
+
+    ;now finally switch back to BANK0
+    stx     BankReg
+
+    jmp     incsp2
+
+.endproc
+
+.proc _next_draw_queue: near
+        ;determined that there is more to process
+        ;so load next set of parameters
+        STZ BankReg
+        LDA #1
+        STA _queue_pending
+
+        ;make sure DMA mode is set to input these params
+        LDA _flagsMirror
+        ORA #$01
+
+        LDY _queue_start
+
+        LDA #$40
+        STA BankReg
+
+        LDA Q_VX, y
+        STA DMA_VX
+
+        LDA Q_VY, y
+        STA DMA_VY
+
+        LDA Q_GX, y
+        STA DMA_GX
+
+        LDA Q_GY, y
+        STA DMA_GY
+
+        LDA Q_WIDTH, y
+        STA DMA_WIDTH
+
+        LDA Q_HEIGHT, y
+        STA DMA_HEIGHT
+
+        LDA Q_Color, y
+        STA DMA_Color
+
+        LDX Q_DMAFlags, y
+        LDA Q_BankReg, y
+
+        AND #$3F
+        STA BankReg
+        STA _banksMirror
+
+        TXA ;retrieve Q_DMAFlags value
+        ORA _frameflip
+        ORA #$45 ; DMA_ENABLE | DMA_NMI | DMA_IRQ
+        STA _flagsMirror
+        STA DMAFlags
+
+        INC _queue_start
+
+        LDA #1
+        STA _draw_busy
+        STA DMA_Start ;START
+
+        DEC _queue_count
+        RTS
+.endproc
+
+.endif

package/src/platforms/gametank/lib/gt/gfx/gfx_sys.c

@@ -0,0 +1,43 @@
+/*
+ * GameTank-specific implementation of drawing functions
+ */
+#include "gfx_sys.h"
+#include "gametank.h"
+#include "banking.h"
+
+char cursorX, cursorY;
+char draw_busy;
+
+void await_vsync(int frames) {
+    int i;
+    for(i = 0; i < frames; i++) {
+        frameflag = 1;
+        while(frameflag) {}
+    }
+}
+
+void flip_pages() {
+    frameflip ^= DMA_PAGE_OUT;
+    bankflip ^= BANK_SECOND_FRAMEBUFFER;
+    flagsMirror = DMA_NMI | DMA_ENABLE | DMA_IRQ | DMA_OPAQUE | frameflip | DMA_GCARRY;
+    *dma_flags = flagsMirror;
+    *bank_reg = bankflip;
+}
+
+void init_graphics() {
+    frameflip = 0;
+    draw_busy = 0;
+    flagsMirror = DMA_NMI | DMA_ENABLE | DMA_IRQ;
+    bankflip = BANK_SECOND_FRAMEBUFFER;
+    *dma_flags = flagsMirror;
+    banksMirror = bankflip;
+    *bank_reg = banksMirror;
+}
+
+void await_drawing() {
+    asm ("CLI");
+    while (draw_busy)
+    {
+        wait();
+    }
+}

package/src/platforms/gametank/lib/gt/gfx/gfx_sys.h

@@ -0,0 +1,46 @@
+#ifndef GFX_SYS_H
+
+#define GFX_SYS_H
+
+#define CLIP_MODE_NONE 0
+#define CLIP_MODE_X 16
+#define CLIP_MODE_Y 32
+#define CLIP_MODE_XY 48
+
+#define SPRITE_FLIP_NONE 0
+#define SPRITE_FLIP_X 1
+#define SPRITE_FLIP_Y 2
+#define SPRITE_FLIP_BOTH 3
+
+#define QUADRANT_0 0
+#define QUADRANT_1 8
+#define QUADRANT_2 16
+#define QUADRANT_3 24
+
+#define BORDER_BOTTOM_HEIGHT 8
+#define BORDER_TOP_HEIGHT 7
+#define BORDER_LEFT_WIDTH 1
+#define BORDER_RIGHT_WIDTH 1
+
+typedef struct Frame {
+    char x, y, w, h, gx, gy, c, b;
+} Frame;
+
+#define SET_RECT(xm,ym,wm,hm,gxm,gym,cm,bm) rect.x = xm;\
+    rect.y = ym; \
+    rect.w = wm; \
+    rect.h = hm; \
+    rect.gx = gxm; \
+    rect.gy = gym; \
+    rect.c = cm; \
+    rect.b = bm; \
+
+void await_vsync(int frames);
+void flip_pages();
+void init_graphics();
+void await_drawing();
+
+extern char draw_busy;
+extern Frame rect; //Defined in draw_util.s
+
+#endif

package/src/platforms/gametank/lib/gt/gfx/sprites.c

@@ -0,0 +1,216 @@
+#include "sprites.h"
+#include "gametank.h"
+#include "banking.h"
+#include <zlib.h>
+#include "bank_nums.h"
+
+/*
+    For each sprite bank:
+        HEADS mask of which quadrants contain the anchor of a sheet
+        OCCUPIED mask of which quadrants are allocated
+        HEADS:4 | OCCUPIED:4
+*/
+static char bank_occupied[8] = { 0, 0, 0, 0, 0, 0, 0, 0};
+
+typedef union PointerUnion {
+    void* ptr;
+    struct {
+        char lsb, msb;
+    } b;
+} PointerUnion;
+
+#define SPRITE_SLOT_COUNT 32
+static char frametable_L[SPRITE_SLOT_COUNT];
+static char frametable_H[SPRITE_SLOT_COUNT];
+static char frametable_B[SPRITE_SLOT_COUNT];
+static char sprite_size_cache[SPRITE_SLOT_COUNT];
+
+#define HEAD_CORNER_NW 16
+#define HEAD_CORNER_NE 32
+#define HEAD_CORNER_SW 64
+#define HEAD_CORNER_SE 128
+
+void load_spritesheet(const unsigned char* spriteData, char srcBank, char ramBank) {
+    char oldFlags = flagsMirror;
+    char oldBanks = banksMirror;
+    char bankNum = ramBank & 7;
+    char xbit = (ramBank & 8) << 4;
+    char ybit = (ramBank & 16) << 3;
+    push_rom_bank();
+    change_rom_bank(srcBank);
+    flagsMirror = DMA_ENABLE;
+    *dma_flags = flagsMirror;
+    *vram_VX = 0;
+    *vram_VY = 0;
+    *vram_GX = xbit;
+    *vram_GY = ybit;
+    *vram_WIDTH = 1;
+    *vram_HEIGHT = 1;
+    *vram_START = 1;
+    *vram_START = 0;
+
+    flagsMirror = 0;
+    *dma_flags = flagsMirror;
+    banksMirror = bankflip | GRAM_PAGE(ramBank);
+    *bank_reg = banksMirror;
+    inflatemem(vram, spriteData);
+    flagsMirror = oldFlags;
+    banksMirror = oldBanks;
+    *dma_flags = flagsMirror;
+    *bank_reg = banksMirror;
+    pop_rom_bank();
+}
+
+void clear_spritebank(char bank) {
+    char oldFlags = flagsMirror;
+    char oldBanks = banksMirror;
+    char bankNum = bank & 7;
+    char xbit = (bank & 8) << 4;
+    char ybit = (bank & 16) << 3;
+    unsigned int i = 0;
+    flagsMirror = DMA_ENABLE;
+    *dma_flags = flagsMirror;
+    *vram_VX = 0;
+    *vram_VY = 0;
+    *vram_GX = xbit;
+    *vram_GY = ybit;
+    *vram_WIDTH = 1;
+    *vram_HEIGHT = 1;
+    *vram_START = 1;
+    *vram_START = 0;
+
+    flagsMirror = 0;
+    *dma_flags = flagsMirror;
+    banksMirror = bankflip | GRAM_PAGE(bank);
+    *bank_reg = banksMirror;
+    for(i = 0; i < 16384; i++) {
+        vram[i] = 0;
+    }
+    flagsMirror = oldFlags;
+    banksMirror = oldBanks;
+    *dma_flags = flagsMirror;
+    *bank_reg = banksMirror;
+}
+
+SpriteSlot allocate_sprite(const SpritePage* sprite) {
+    register const SpritePage* current;
+    register char mask, i, free_page;
+    push_rom_bank();
+    change_rom_bank(BANK_LOADERS);
+    mask = 0; i = 1;
+    for(current = sprite; current != 0; current = current->next) {
+        if(current->data != 0) {
+            mask |= i;
+        }
+        i = i << 1;
+    }
+    free_page = 0xFF;
+    for(i = 0; i < 8; ++i) {
+        if(!(bank_occupied[i] & mask)) {
+            bank_occupied[i] |= mask | HEAD_CORNER_NW;
+            free_page = i;
+            break;
+        }
+        if(mask == PAGE_MASK_FULL) {
+            continue;
+        }
+        if(mask != PAGE_MASK_WIDE) {
+            //if mask doesn't span horizontally
+            if(!(bank_occupied[i] & (mask << 1))) {
+                bank_occupied[i] |= ((mask << 1) & 0b1010) | HEAD_CORNER_NE;
+                free_page = i | SPRITE_OFFSET_X_MASK;
+                break;
+            }
+        }
+        if(mask != PAGE_MASK_TALL) {
+            //if mask doesn't span vertically
+            if(!(bank_occupied[i] & (mask << 2))) {
+                bank_occupied[i] |= ((mask << 2) & 0b1100) | HEAD_CORNER_SW;
+                free_page = i | SPRITE_OFFSET_Y_MASK;
+                break;
+            }
+        }
+        if(mask == 1) {
+            if(!(bank_occupied[i] & (mask << 3))) {
+                bank_occupied[i] |= ((mask << 3) & 0b1000) | HEAD_CORNER_SE;
+                free_page = i | SPRITE_OFFSET_XY_MASK;
+                break;
+            }
+        }
+    }
+
+    if(SPRITE_SLOT_INVALID(free_page)) {
+        pop_rom_bank();
+        return 0xFF;
+    }
+
+    sprite_size_cache[free_page] = mask;
+
+    i = 1;
+
+    mask = (free_page & SPRITE_OFFSET_XY_MASK);
+    for(current = sprite; current != 0; current = current->next) {
+        if(current->data != 0) {
+            load_spritesheet(current->data, current->bank, (free_page & 7) | mask);
+        }
+        i = i << 1;
+        mask += 8;
+    }
+    pop_rom_bank();
+    return free_page;
+}
+
+void set_sprite_frametable(SpriteSlot sprite, const Frame *frametable, char frametable_bank) {
+    frametable_B[sprite] = frametable_bank;
+    frametable_L[sprite] = (*((PointerUnion*)(&frametable))).b.lsb;
+    frametable_H[sprite] = (*((PointerUnion*)(&frametable))).b.msb;
+}
+
+void free_sprite(SpriteSlot slot) {
+    register char anchor, clear_mask, heads;
+    anchor = slot & SPRITE_OFFSET_XY_MASK;
+    heads = bank_occupied[slot & 7] >> 4;
+    clear_mask = ~heads;
+    switch(slot & SPRITE_OFFSET_XY_MASK) {
+        case 0:
+            clear_mask &= 0b1111;
+            clear_mask |= 1;
+            if((clear_mask & 0b0110) != 0b0110) {
+                clear_mask &= 7;
+            }
+            break;
+        case SPRITE_OFFSET_X_MASK:
+            clear_mask &= 0b1010;
+            clear_mask |= 2;
+            if(sprite_size_cache[slot] == 1) {
+                clear_mask &= 7;
+            }
+            break;
+        case SPRITE_OFFSET_Y_MASK:
+            clear_mask &= 0b1100;
+            clear_mask |= 4;
+            if(sprite_size_cache[slot] == 1) {
+                clear_mask &= 7;
+            }
+            break;
+        case SPRITE_OFFSET_XY_MASK:
+            clear_mask = 0b1000;
+            break;
+    }
+    clear_mask |= (clear_mask << 4);
+    bank_occupied[slot & 7] &= ~clear_mask;
+}
+
+Frame sprite_temp_frame;
+static PointerUnion dsf_frametable;
+
+void sprite_fetch_frame(SpriteSlot sprite, char frame) {
+    push_rom_bank();
+    change_rom_bank(frametable_B[sprite]);
+    dsf_frametable.b.lsb = frametable_L[sprite];
+    dsf_frametable.b.msb = frametable_H[sprite];
+    sprite_temp_frame = ((Frame*) dsf_frametable.ptr)[frame];
+    pop_rom_bank();
+}
+
+void pushRect();

package/src/platforms/gametank/lib/gt/gfx/sprites.h

@@ -0,0 +1,41 @@
+#ifndef SPRITES_H
+#define SPRITES_H
+#include "gfx_sys.h"
+
+#define SPRITE_SLOT_INVALID(x) (x & 0b11100000)
+
+//Sprite sheets MUST be one of these
+#define PAGE_MASK_SINGLE 1
+#define PAGE_MASK_WIDE 3
+#define PAGE_MASK_TALL 5
+#define PAGE_MASK_FULL 15
+
+#define SPRITE_OFFSET_X_MASK 8
+#define SPRITE_OFFSET_Y_MASK 16
+#define SPRITE_OFFSET_XY_MASK 24
+
+#define SPRITE_OFFSET_X(slot) ((slot & SPRITE_OFFSET_X_MASK) ? 128 : 0)
+#define SPRITE_OFFSET_Y(slot) ((slot & SPRITE_OFFSET_Y_MASK) ? 128 : 0)
+
+#define CONSTRUCT_SPRITE_SLOT(slot, quadrant) ((slot) | (quadrant))
+
+typedef char SpriteSlot;
+
+typedef struct SpritePage {
+    const unsigned char* data;
+    char bank;
+    const struct SpritePage* next;
+} SpritePage;
+
+extern Frame sprite_temp_frame;
+
+void load_spritesheet(const unsigned char* spriteData, char srcBank, char ramBank);
+void clear_spritebank(char bank);
+
+void sprite_fetch_frame(SpriteSlot sprite, char frame);
+
+SpriteSlot allocate_sprite(const SpritePage* sprite);
+void set_sprite_frametable(SpriteSlot sprite, const Frame *frametable, char frametable_bank);
+void free_sprite(SpriteSlot slot);
+
+#endif