Apple-2gs-SW
/
iigs-game-engine
mirror of https://github.com/lscharen/iigs-game-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
iigs-game-engine/src/Sprite.s

525 lines
15 KiB
ArmAsm
Raw Normal View History

Tile rendering reorganization This significantly simplifies the dispatch process by creating a proper backing store for the tiles. Most values that were calcualted on the fly are now stored as constants in the tile store. Also, all tile updated are run through the dirty tile list which solved a checken-and-egg problem of which order to do sprites vs new tiles and affords a lot of optimizations since tile rendering is deferred and each tile is only drawn at most once per frame.
2021-10-21 13:50:07 +00:00
; Functions for sprie handling. Mostly maintains the sprite list and provides
; utility functions to calculate sprite/tile intersections
Refactor GTE Core to be included as an independent Segment in other projects
2021-08-25 14:38:02 +00:00
;
Tile rendering reorganization This significantly simplifies the dispatch process by creating a proper backing store for the tiles. Most values that were calcualted on the fly are now stored as constants in the tile store. Also, all tile updated are run through the dirty tile list which solved a checken-and-egg problem of which order to do sprites vs new tiles and affords a lot of optimizations since tile rendering is deferred and each tile is only drawn at most once per frame.
2021-10-21 13:50:07 +00:00
; The sprite plane actually covers two banks so that more than 32K can be used as a virtual
; screen buffer. In order to be able to draw sprites offscreen, the virtual screen must be
; wider and taller than the physical graphics screen.
;
; Initialize the sprite plane data and mask banks (all data = $0000, all masks = $FFFF)
Continued bug fixing * Missed an XBA to swap tile command bits into a proper index range * Explicitly track the BASE_ADDR * Fix some register overwriting * Add an UpdateSprite method
2021-10-24 03:31:38 +00:00
InitSprites
Tile rendering reorganization This significantly simplifies the dispatch process by creating a proper backing store for the tiles. Most values that were calcualted on the fly are now stored as constants in the tile store. Also, all tile updated are run through the dirty tile list which solved a checken-and-egg problem of which order to do sprites vs new tiles and affords a lot of optimizations since tile rendering is deferred and each tile is only drawn at most once per frame.
2021-10-21 13:50:07 +00:00
ldx #$FFFE
lda #0
Continued bug fixing * Missed an XBA to swap tile command bits into a proper index range * Explicitly track the BASE_ADDR * Fix some register overwriting * Add an UpdateSprite method
2021-10-24 03:31:38 +00:00
:loop1 stal spritedata,x
Tile rendering reorganization This significantly simplifies the dispatch process by creating a proper backing store for the tiles. Most values that were calcualted on the fly are now stored as constants in the tile store. Also, all tile updated are run through the dirty tile list which solved a checken-and-egg problem of which order to do sprites vs new tiles and affords a lot of optimizations since tile rendering is deferred and each tile is only drawn at most once per frame.
2021-10-21 13:50:07 +00:00
dex
dex
Continued bug fixing * Missed an XBA to swap tile command bits into a proper index range * Explicitly track the BASE_ADDR * Fix some register overwriting * Add an UpdateSprite method
2021-10-24 03:31:38 +00:00
bpl :loop1
Tile rendering reorganization This significantly simplifies the dispatch process by creating a proper backing store for the tiles. Most values that were calcualted on the fly are now stored as constants in the tile store. Also, all tile updated are run through the dirty tile list which solved a checken-and-egg problem of which order to do sprites vs new tiles and affords a lot of optimizations since tile rendering is deferred and each tile is only drawn at most once per frame.
2021-10-21 13:50:07 +00:00
ldx #$FFFE
lda #$FFFF
Continued bug fixing * Missed an XBA to swap tile command bits into a proper index range * Explicitly track the BASE_ADDR * Fix some register overwriting * Add an UpdateSprite method
2021-10-24 03:31:38 +00:00
:loop2 stal spritemask,x
Tile rendering reorganization This significantly simplifies the dispatch process by creating a proper backing store for the tiles. Most values that were calcualted on the fly are now stored as constants in the tile store. Also, all tile updated are run through the dirty tile list which solved a checken-and-egg problem of which order to do sprites vs new tiles and affords a lot of optimizations since tile rendering is deferred and each tile is only drawn at most once per frame.
2021-10-21 13:50:07 +00:00
dex
dex
Continued bug fixing * Missed an XBA to swap tile command bits into a proper index range * Explicitly track the BASE_ADDR * Fix some register overwriting * Add an UpdateSprite method
2021-10-24 03:31:38 +00:00
bpl :loop2
Tile rendering reorganization This significantly simplifies the dispatch process by creating a proper backing store for the tiles. Most values that were calcualted on the fly are now stored as constants in the tile store. Also, all tile updated are run through the dirty tile list which solved a checken-and-egg problem of which order to do sprites vs new tiles and affords a lot of optimizations since tile rendering is deferred and each tile is only drawn at most once per frame.
2021-10-21 13:50:07 +00:00
rts
; This function looks at the sprite list and renders the sprite plane data into the appropriate
; tiles in the code field
_RenderSprites
ldx #0
:loop lda _Sprites+SPRITE_STATUS,x
beq :out
WIP: manual sprite rendering showing on screen
2021-10-29 02:41:01 +00:00
; cmp #SPRITE_STATUS_DIRTY
; beq :render
bra :render
Tile rendering reorganization This significantly simplifies the dispatch process by creating a proper backing store for the tiles. Most values that were calcualted on the fly are now stored as constants in the tile store. Also, all tile updated are run through the dirty tile list which solved a checken-and-egg problem of which order to do sprites vs new tiles and affords a lot of optimizations since tile rendering is deferred and each tile is only drawn at most once per frame.
2021-10-21 13:50:07 +00:00
:next inx
inx
bra :loop
:out rts
Add address in sprite plane for tile rendering; use in tile dispatcher
2021-10-27 05:14:19 +00:00
; This is the complicated part; we need to draw the sprite into the sprite plane, but then
Tile rendering reorganization This significantly simplifies the dispatch process by creating a proper backing store for the tiles. Most values that were calcualted on the fly are now stored as constants in the tile store. Also, all tile updated are run through the dirty tile list which solved a checken-and-egg problem of which order to do sprites vs new tiles and affords a lot of optimizations since tile rendering is deferred and each tile is only drawn at most once per frame.
2021-10-21 13:50:07 +00:00
; calculate the code field tiles that this sprite potentially overlaps with and mark those
Add address in sprite plane for tile rendering; use in tile dispatcher
2021-10-27 05:14:19 +00:00
; tiles as dirty and store the appropriate sprite plane address that those tiles need to copy
; from.
Continued bug fixing * Missed an XBA to swap tile command bits into a proper index range * Explicitly track the BASE_ADDR * Fix some register overwriting * Add an UpdateSprite method
2021-10-24 03:31:38 +00:00
:render
WIP: manual sprite rendering showing on screen
2021-10-29 02:41:01 +00:00
stx tmp0 ; stash the X register
; jsr _EraseSprite ; erase from the old position
ldx tmp0
Tile rendering reorganization This significantly simplifies the dispatch process by creating a proper backing store for the tiles. Most values that were calcualted on the fly are now stored as constants in the tile store. Also, all tile updated are run through the dirty tile list which solved a checken-and-egg problem of which order to do sprites vs new tiles and affords a lot of optimizations since tile rendering is deferred and each tile is only drawn at most once per frame.
2021-10-21 13:50:07 +00:00
jsr _DrawTileSprite ; draw the sprite into the sprite plane
WIP: manual sprite rendering showing on screen
2021-10-29 02:41:01 +00:00
ldy #0 ; flags to mark if the sprite is aligned to the code field grid or not
Tile rendering reorganization This significantly simplifies the dispatch process by creating a proper backing store for the tiles. Most values that were calcualted on the fly are now stored as constants in the tile store. Also, all tile updated are run through the dirty tile list which solved a checken-and-egg problem of which order to do sprites vs new tiles and affords a lot of optimizations since tile rendering is deferred and each tile is only drawn at most once per frame.
2021-10-21 13:50:07 +00:00
lda _Sprites+SPRITE_X,x ; Will need some special handling for X < 0
WIP: manual sprite rendering showing on screen
2021-10-29 02:41:01 +00:00
sta tmp3
Tile rendering reorganization This significantly simplifies the dispatch process by creating a proper backing store for the tiles. Most values that were calcualted on the fly are now stored as constants in the tile store. Also, all tile updated are run through the dirty tile list which solved a checken-and-egg problem of which order to do sprites vs new tiles and affords a lot of optimizations since tile rendering is deferred and each tile is only drawn at most once per frame.
2021-10-21 13:50:07 +00:00
clc
adc StartXMod164
bit #$0003 ; If the botton bit are zero, then we're aligned
WIP: manual sprite rendering showing on screen
2021-10-29 02:41:01 +00:00
beq :aligned_x
ldy #4
:aligned_x
Tile rendering reorganization This significantly simplifies the dispatch process by creating a proper backing store for the tiles. Most values that were calcualted on the fly are now stored as constants in the tile store. Also, all tile updated are run through the dirty tile list which solved a checken-and-egg problem of which order to do sprites vs new tiles and affords a lot of optimizations since tile rendering is deferred and each tile is only drawn at most once per frame.
2021-10-21 13:50:07 +00:00
cmp #164
bcc *+5
sbc #164
lsr
lsr
Continued bug fixing * Missed an XBA to swap tile command bits into a proper index range * Explicitly track the BASE_ADDR * Fix some register overwriting * Add an UpdateSprite method
2021-10-24 03:31:38 +00:00
pha ; Save the tile column
Tile rendering reorganization This significantly simplifies the dispatch process by creating a proper backing store for the tiles. Most values that were calcualted on the fly are now stored as constants in the tile store. Also, all tile updated are run through the dirty tile list which solved a checken-and-egg problem of which order to do sprites vs new tiles and affords a lot of optimizations since tile rendering is deferred and each tile is only drawn at most once per frame.
2021-10-21 13:50:07 +00:00
lda _Sprites+SPRITE_Y,x
WIP: manual sprite rendering showing on screen
2021-10-29 02:41:01 +00:00
sta tmp2
Tile rendering reorganization This significantly simplifies the dispatch process by creating a proper backing store for the tiles. Most values that were calcualted on the fly are now stored as constants in the tile store. Also, all tile updated are run through the dirty tile list which solved a checken-and-egg problem of which order to do sprites vs new tiles and affords a lot of optimizations since tile rendering is deferred and each tile is only drawn at most once per frame.
2021-10-21 13:50:07 +00:00
clc
adc StartYMod208
bit #$0007
WIP: manual sprite rendering showing on screen
2021-10-29 02:41:01 +00:00
beq :aligned_y
iny
iny
:aligned_y
Tile rendering reorganization This significantly simplifies the dispatch process by creating a proper backing store for the tiles. Most values that were calcualted on the fly are now stored as constants in the tile store. Also, all tile updated are run through the dirty tile list which solved a checken-and-egg problem of which order to do sprites vs new tiles and affords a lot of optimizations since tile rendering is deferred and each tile is only drawn at most once per frame.
2021-10-21 13:50:07 +00:00
cmp #208
bcc *+5
sbc #208
lsr
lsr
lsr
WIP: manual sprite rendering showing on screen
2021-10-29 02:41:01 +00:00
tyx ; stash the alignment in the x register for dispatch
jmp (:mark_dirty,x)
; :mark_dirty dw :corner,:column,:row,:square
:mark_dirty dw :corner,:corner,:corner,:corner
; Just mark the square with the sprite as dirty
:corner tay
plx
jsr _MarkAsDirty
ldx tmp0
brl :next
; Mark the left column (x, y) and (x, y+1) as dirty
:column tay
plx
jsr _MarkAsDirty
iny
cpy #26
bcc *+5
ldy #0
lda tmp2
clc
adc #8
sta tmp2
jsr _MarkAsDirty
ldx tmp0
brl :next
; Mark the top row (x, y) and (x+1, y) as dirty
:row tay
plx
jsr _MarkAsDirty
inx
cpx #41
bcc *+5
ldx #0
lda tmp3
clc
adc #4
sta tmp3
jsr _MarkAsDirty
ldx tmp0
brl :next
; Mark all four squares as dirty
:square tay
lda 1,s
tax
jsr _MarkAsDirty
inx
cpx #41
bcc *+5
ldx #0
lda tmp3
clc
adc #4
sta tmp3
jsr _MarkAsDirty
iny
cpy #26
bcc *+5
ldy #0
lda tmp2
clc
adc #8
sta tmp2
jsr _MarkAsDirty
plx
lda tmp3
sec
sbc #4
sta tmp3
jsr _MarkAsDirty
ldx tmp0
brl :next
_MarkAsDirty
phx
phy
Fix several incorrect uses of internal API; work toward functional demo
2021-10-22 05:56:12 +00:00
Add address in sprite plane for tile rendering; use in tile dispatcher
2021-10-27 05:14:19 +00:00
jsr _GetTileStoreOffset ; Get the tile store value
jsr _PushDirtyTile ; Enqueue for processing (Returns offset in Y-register)
Continued bug fixing * Missed an XBA to swap tile command bits into a proper index range * Explicitly track the BASE_ADDR * Fix some register overwriting * Add an UpdateSprite method
2021-10-24 03:31:38 +00:00
WIP: manual sprite rendering showing on screen
2021-10-29 02:41:01 +00:00
lda TileStore+TS_SPRITE_FLAG,y ; If this tile has already been flagged on this frame, avoid recalculating the address
beq :early_out
Add address in sprite plane for tile rendering; use in tile dispatcher
2021-10-27 05:14:19 +00:00
lda #TILE_SPRITE_BIT ; Mark this tile as having a sprite, regardless of whether it was already enqueued
Continued bug fixing * Missed an XBA to swap tile command bits into a proper index range * Explicitly track the BASE_ADDR * Fix some register overwriting * Add an UpdateSprite method
2021-10-24 03:31:38 +00:00
sta TileStore+TS_SPRITE_FLAG,y
Tile rendering reorganization This significantly simplifies the dispatch process by creating a proper backing store for the tiles. Most values that were calcualted on the fly are now stored as constants in the tile store. Also, all tile updated are run through the dirty tile list which solved a checken-and-egg problem of which order to do sprites vs new tiles and affords a lot of optimizations since tile rendering is deferred and each tile is only drawn at most once per frame.
2021-10-21 13:50:07 +00:00
WIP: manual sprite rendering showing on screen
2021-10-29 02:41:01 +00:00
jsr _SetSpriteAddr
Add address in sprite plane for tile rendering; use in tile dispatcher
2021-10-27 05:14:19 +00:00
WIP: manual sprite rendering showing on screen
2021-10-29 02:41:01 +00:00
:early_out
ply
plx
rts
; Set the TileStore+TS_SPRITE_ADDR for tile that a sprite is on.
;
Add address in sprite plane for tile rendering; use in tile dispatcher
2021-10-27 05:14:19 +00:00
; To calculate the sprite plane coordinate for this tile column. We really just have to compensate
; for the StartXMod164 mod 4 value, so the final value is (SPRITE_X + (StartXMod164 mod 4)) & 0xFFFC
; for the horizontal and (SPRITE_Y + (StartYMod208 mod 8)) & 0xFFF8
;
; The final address is (Y + NUM_BUFF_LINES) * 256 + X
WIP: manual sprite rendering showing on screen
2021-10-29 02:41:01 +00:00
;
; tmp2 = sprite Y coordinate
; tmp3 = sprite X coordinate
; Y = tile record index
_SetSpriteAddr
Add address in sprite plane for tile rendering; use in tile dispatcher
2021-10-27 05:14:19 +00:00
lda StartYMod208
and #$0007
clc
WIP: manual sprite rendering showing on screen
2021-10-29 02:41:01 +00:00
adc tmp2
Add address in sprite plane for tile rendering; use in tile dispatcher
2021-10-27 05:14:19 +00:00
and #$00F8
clc
adc #NUM_BUFF_LINES
xba
WIP: manual sprite rendering showing on screen
2021-10-29 02:41:01 +00:00
sta tmp4
Add address in sprite plane for tile rendering; use in tile dispatcher
2021-10-27 05:14:19 +00:00
lda StartXMod164
and #$0003
clc
WIP: manual sprite rendering showing on screen
2021-10-29 02:41:01 +00:00
adc tmp3
Add address in sprite plane for tile rendering; use in tile dispatcher
2021-10-27 05:14:19 +00:00
and #$00FC
clc
WIP: manual sprite rendering showing on screen
2021-10-29 02:41:01 +00:00
adc tmp4
Add address in sprite plane for tile rendering; use in tile dispatcher
2021-10-27 05:14:19 +00:00
sta TileStore+TS_SPRITE_ADDR,y
WIP: manual sprite rendering showing on screen
2021-10-29 02:41:01 +00:00
rts
Tile rendering reorganization This significantly simplifies the dispatch process by creating a proper backing store for the tiles. Most values that were calcualted on the fly are now stored as constants in the tile store. Also, all tile updated are run through the dirty tile list which solved a checken-and-egg problem of which order to do sprites vs new tiles and affords a lot of optimizations since tile rendering is deferred and each tile is only drawn at most once per frame.
2021-10-21 13:50:07 +00:00
; _GetTileAt
;
; Given a relative playfield coordinate [0, ScreenWidth), [0, ScreenHeight) return the
; X = horizontal point [0, ScreenTileWidth]
; Y = vertical point [0, ScreenTileHeight]
;
; Return
; C = 1, out of range
; C = 0, X = column, Y = row
_GetTileAt
cpx ScreenWidth
bcc *+3
rts
cpy ScreenHeight
bcc *+3
rts
tya ; carry is clear here
adc StartYMod208 ; This is the code field line that is at the top of the screen
cmp #208
bcc *+5
sbc #208
lsr
lsr
lsr
tay ; This is the code field row for this point
clc
txa
adc StartXMod164
cmp #164
bcc *+5
sbc #164
lsr
lsr
tax ; Could call _CopyBG0Tile with these arguments
clc
rts
; _DrawSprite
;
; Draw the sprites on the _Sprite list into the Sprite Plane data and mask buffers. This is using the
; tile data right now, but could be replaced with compiled sprite routines.
_DrawSprites
ldx #0
:loop lda _Sprites+SPRITE_STATUS,x
WIP: manual sprite rendering showing on screen
2021-10-29 02:41:01 +00:00
beq :out ; The first open slot is the end of the list
cmp #SPRITE_STATUS_DIRTY
bne :skip
Tile rendering reorganization This significantly simplifies the dispatch process by creating a proper backing store for the tiles. Most values that were calcualted on the fly are now stored as constants in the tile store. Also, all tile updated are run through the dirty tile list which solved a checken-and-egg problem of which order to do sprites vs new tiles and affords a lot of optimizations since tile rendering is deferred and each tile is only drawn at most once per frame.
2021-10-21 13:50:07 +00:00
WIP: manual sprite rendering showing on screen
2021-10-29 02:41:01 +00:00
phx
Tile rendering reorganization This significantly simplifies the dispatch process by creating a proper backing store for the tiles. Most values that were calcualted on the fly are now stored as constants in the tile store. Also, all tile updated are run through the dirty tile list which solved a checken-and-egg problem of which order to do sprites vs new tiles and affords a lot of optimizations since tile rendering is deferred and each tile is only drawn at most once per frame.
2021-10-21 13:50:07 +00:00
WIP: manual sprite rendering showing on screen
2021-10-29 02:41:01 +00:00
lda _Sprites+VBUFF_ADDR,x ; Load the address in the sprite plane
ldy _Sprites+TILE_DATA_OFFSET,x ; Load the address in the tile data bank
tax
Tile rendering reorganization This significantly simplifies the dispatch process by creating a proper backing store for the tiles. Most values that were calcualted on the fly are now stored as constants in the tile store. Also, all tile updated are run through the dirty tile list which solved a checken-and-egg problem of which order to do sprites vs new tiles and affords a lot of optimizations since tile rendering is deferred and each tile is only drawn at most once per frame.
2021-10-21 13:50:07 +00:00
jsr _DrawTileSprite
WIP: manual sprite rendering showing on screen
2021-10-29 02:41:01 +00:00
plx
:skip
inx
inx
Tile rendering reorganization This significantly simplifies the dispatch process by creating a proper backing store for the tiles. Most values that were calcualted on the fly are now stored as constants in the tile store. Also, all tile updated are run through the dirty tile list which solved a checken-and-egg problem of which order to do sprites vs new tiles and affords a lot of optimizations since tile rendering is deferred and each tile is only drawn at most once per frame.
2021-10-21 13:50:07 +00:00
bra :loop
WIP: manual sprite rendering showing on screen
2021-10-29 02:41:01 +00:00
:out rts
Tile rendering reorganization This significantly simplifies the dispatch process by creating a proper backing store for the tiles. Most values that were calcualted on the fly are now stored as constants in the tile store. Also, all tile updated are run through the dirty tile list which solved a checken-and-egg problem of which order to do sprites vs new tiles and affords a lot of optimizations since tile rendering is deferred and each tile is only drawn at most once per frame.
2021-10-21 13:50:07 +00:00
WIP: manual sprite rendering showing on screen
2021-10-29 02:41:01 +00:00
DrawTileSprite ENT
jsr _DrawTileSprite
rtl
Tile rendering reorganization This significantly simplifies the dispatch process by creating a proper backing store for the tiles. Most values that were calcualted on the fly are now stored as constants in the tile store. Also, all tile updated are run through the dirty tile list which solved a checken-and-egg problem of which order to do sprites vs new tiles and affords a lot of optimizations since tile rendering is deferred and each tile is only drawn at most once per frame.
2021-10-21 13:50:07 +00:00
WIP: manual sprite rendering showing on screen
2021-10-29 02:41:01 +00:00
_DrawTileSprite
Tile rendering reorganization This significantly simplifies the dispatch process by creating a proper backing store for the tiles. Most values that were calcualted on the fly are now stored as constants in the tile store. Also, all tile updated are run through the dirty tile list which solved a checken-and-egg problem of which order to do sprites vs new tiles and affords a lot of optimizations since tile rendering is deferred and each tile is only drawn at most once per frame.
2021-10-21 13:50:07 +00:00
phb
pea #^tiledata ; Set the bank to the tile data
plb
]line equ 0
lup 8
lda: tiledata+32+{]line*4},y
andl spritemask+{]line*256},x
stal spritemask+{]line*256},x
ldal spritedata+{]line*SPRITE_PLANE_SPAN},x
and: tiledata+32+{]line*4},y
Fix several incorrect uses of internal API; work toward functional demo
2021-10-22 05:56:12 +00:00
ora: tiledata+{]line*4},y
Tile rendering reorganization This significantly simplifies the dispatch process by creating a proper backing store for the tiles. Most values that were calcualted on the fly are now stored as constants in the tile store. Also, all tile updated are run through the dirty tile list which solved a checken-and-egg problem of which order to do sprites vs new tiles and affords a lot of optimizations since tile rendering is deferred and each tile is only drawn at most once per frame.
2021-10-21 13:50:07 +00:00
stal spritedata+{]line*SPRITE_PLANE_SPAN},x
lda: tiledata+32+{]line*4}+2,y
andl spritemask+{]line*SPRITE_PLANE_SPAN}+2,x
stal spritemask+{]line*SPRITE_PLANE_SPAN}+2,x
ldal spritedata+{]line*SPRITE_PLANE_SPAN}+2,x
and: tiledata+32+{]line*4}+2,y
Fix several incorrect uses of internal API; work toward functional demo
2021-10-22 05:56:12 +00:00
ora: tiledata+{]line*4}+2,y
Tile rendering reorganization This significantly simplifies the dispatch process by creating a proper backing store for the tiles. Most values that were calcualted on the fly are now stored as constants in the tile store. Also, all tile updated are run through the dirty tile list which solved a checken-and-egg problem of which order to do sprites vs new tiles and affords a lot of optimizations since tile rendering is deferred and each tile is only drawn at most once per frame.
2021-10-21 13:50:07 +00:00
stal spritedata+{]line*SPRITE_PLANE_SPAN}+2,x
]line equ ]line+1
--^
plb ; pop extra byte
plb
rts
; Erase is easy -- set an 8x8 area of the data region to all $0000 and the corresponding mask
; resgion to all $FFFF
;
; A = sprite ID
SPRITE_PLANE_SPAN equ 256
_EraseSprite
asl
tay
WIP: manual sprite rendering showing on screen
2021-10-29 02:41:01 +00:00
ldx _Sprites+OLD_VBUFF_ADDR,y
Tile rendering reorganization This significantly simplifies the dispatch process by creating a proper backing store for the tiles. Most values that were calcualted on the fly are now stored as constants in the tile store. Also, all tile updated are run through the dirty tile list which solved a checken-and-egg problem of which order to do sprites vs new tiles and affords a lot of optimizations since tile rendering is deferred and each tile is only drawn at most once per frame.
2021-10-21 13:50:07 +00:00
WIP: manual sprite rendering showing on screen
2021-10-29 02:41:01 +00:00
phb ; Save the bank to switch to the sprite plane
Tile rendering reorganization This significantly simplifies the dispatch process by creating a proper backing store for the tiles. Most values that were calcualted on the fly are now stored as constants in the tile store. Also, all tile updated are run through the dirty tile list which solved a checken-and-egg problem of which order to do sprites vs new tiles and affords a lot of optimizations since tile rendering is deferred and each tile is only drawn at most once per frame.
2021-10-21 13:50:07 +00:00
pea #^spritedata
plb
lda #0
sta: {0*SPRITE_PLANE_SPAN}+0,x
sta: {0*SPRITE_PLANE_SPAN}+2,x
sta: {1*SPRITE_PLANE_SPAN}+0,x
sta: {1*SPRITE_PLANE_SPAN}+2,x
sta: {2*SPRITE_PLANE_SPAN}+0,x
sta: {2*SPRITE_PLANE_SPAN}+2,x
sta: {3*SPRITE_PLANE_SPAN}+0,x
sta: {3*SPRITE_PLANE_SPAN}+2,x
sta: {4*SPRITE_PLANE_SPAN}+0,x
sta: {4*SPRITE_PLANE_SPAN}+2,x
sta: {5*SPRITE_PLANE_SPAN}+0,x
sta: {5*SPRITE_PLANE_SPAN}+2,x
sta: {6*SPRITE_PLANE_SPAN}+0,x
sta: {6*SPRITE_PLANE_SPAN}+2,x
sta: {7*SPRITE_PLANE_SPAN}+0,x
sta: {7*SPRITE_PLANE_SPAN}+2,x
pea #^spritemask
plb
lda #$FFFF
sta: {0*SPRITE_PLANE_SPAN}+0,x
sta: {0*SPRITE_PLANE_SPAN}+2,x
sta: {1*SPRITE_PLANE_SPAN}+0,x
sta: {1*SPRITE_PLANE_SPAN}+2,x
sta: {2*SPRITE_PLANE_SPAN}+0,x
sta: {2*SPRITE_PLANE_SPAN}+2,x
sta: {3*SPRITE_PLANE_SPAN}+0,x
sta: {3*SPRITE_PLANE_SPAN}+2,x
sta: {4*SPRITE_PLANE_SPAN}+0,x
sta: {4*SPRITE_PLANE_SPAN}+2,x
sta: {5*SPRITE_PLANE_SPAN}+0,x
sta: {5*SPRITE_PLANE_SPAN}+2,x
sta: {6*SPRITE_PLANE_SPAN}+0,x
sta: {6*SPRITE_PLANE_SPAN}+2,x
sta: {7*SPRITE_PLANE_SPAN}+0,x
sta: {7*SPRITE_PLANE_SPAN}+2,x
pla
plb
rts
; Add a new sprite to the rendering pipeline
;
; A = tileId
; X = x position
; Y = y position
AddSprite ENT
phb
phk
plb
jsr _AddSprite
plb
rtl
_AddSprite
Continued bug fixing * Missed an XBA to swap tile command bits into a proper index range * Explicitly track the BASE_ADDR * Fix some register overwriting * Add an UpdateSprite method
2021-10-24 03:31:38 +00:00
phx ; Save the horizontal position and tile ID
Tile rendering reorganization This significantly simplifies the dispatch process by creating a proper backing store for the tiles. Most values that were calcualted on the fly are now stored as constants in the tile store. Also, all tile updated are run through the dirty tile list which solved a checken-and-egg problem of which order to do sprites vs new tiles and affords a lot of optimizations since tile rendering is deferred and each tile is only drawn at most once per frame.
2021-10-21 13:50:07 +00:00
pha
ldx #0
:loop lda _Sprites+SPRITE_STATUS,x ; Look for an open slot
beq :open
inx
inx
cpx #MAX_SPRITES*2
bcc :loop
pla ; Early out
pla
Continued bug fixing * Missed an XBA to swap tile command bits into a proper index range * Explicitly track the BASE_ADDR * Fix some register overwriting * Add an UpdateSprite method
2021-10-24 03:31:38 +00:00
sec ; Signal that no sprite slot was available
Tile rendering reorganization This significantly simplifies the dispatch process by creating a proper backing store for the tiles. Most values that were calcualted on the fly are now stored as constants in the tile store. Also, all tile updated are run through the dirty tile list which solved a checken-and-egg problem of which order to do sprites vs new tiles and affords a lot of optimizations since tile rendering is deferred and each tile is only drawn at most once per frame.
2021-10-21 13:50:07 +00:00
rts
:open lda #SPRITE_STATUS_DIRTY
sta _Sprites+SPRITE_STATUS,x ; Mark this sprite slot as occupied and that it needs to be drawn
pla
jsr _GetTileAddr
sta _Sprites+TILE_DATA_OFFSET,x
tya
clc
adc #NUM_BUFF_LINES ; The virtual buffer has 24 lines of off-screen space
xba ; Each virtual scan line is 256 bytes wide for overdraw space
clc
Continued bug fixing * Missed an XBA to swap tile command bits into a proper index range * Explicitly track the BASE_ADDR * Fix some register overwriting * Add an UpdateSprite method
2021-10-24 03:31:38 +00:00
adc 1,s ; Add the horizontal position
Tile rendering reorganization This significantly simplifies the dispatch process by creating a proper backing store for the tiles. Most values that were calcualted on the fly are now stored as constants in the tile store. Also, all tile updated are run through the dirty tile list which solved a checken-and-egg problem of which order to do sprites vs new tiles and affords a lot of optimizations since tile rendering is deferred and each tile is only drawn at most once per frame.
2021-10-21 13:50:07 +00:00
sta _Sprites+VBUFF_ADDR,x
Continued bug fixing * Missed an XBA to swap tile command bits into a proper index range * Explicitly track the BASE_ADDR * Fix some register overwriting * Add an UpdateSprite method
2021-10-24 03:31:38 +00:00
pla ; Pop off the saved value
clc ; Mark that the sprite was successfully added
txa ; And return the sprite ID
rts
WIP: manual sprite rendering showing on screen
2021-10-29 02:41:01 +00:00
; X = x coordinate
; Y = y coordinate
GetSpriteVBuffAddr ENT
tya
clc
adc #NUM_BUFF_LINES ; The virtual buffer has 24 lines of off-screen space
xba ; Each virtual scan line is 256 bytes wide for overdraw space
phx
clc
adc 1,s
plx
rtl
Continued bug fixing * Missed an XBA to swap tile command bits into a proper index range * Explicitly track the BASE_ADDR * Fix some register overwriting * Add an UpdateSprite method
2021-10-24 03:31:38 +00:00
; Move a sprite to a new location. If the tile ID of the sprite needs to be changed, then
; a full remove/add cycle needs to happen
;
; A = sprite ID
; X = x position
; Y = y position
UpdateSprite ENT
phb
phk
plb
jsr _UpdateSprite
plb
rtl
_UpdateSprite
cmp #MAX_SPRITES*2 ; Make sure we're in bounds
bcc :ok
rts
:ok
WIP: manual sprite rendering showing on screen
2021-10-29 02:41:01 +00:00
stx tmp0 ; Save the horizontal position
and #$FFFE ; Defensive
Continued bug fixing * Missed an XBA to swap tile command bits into a proper index range * Explicitly track the BASE_ADDR * Fix some register overwriting * Add an UpdateSprite method
2021-10-24 03:31:38 +00:00
tax ; Get the sprite index
lda #SPRITE_STATUS_DIRTY ; Position is changing, mark as dirty
sta _Sprites+SPRITE_STATUS,x ; Mark this sprite slot as occupied and that it needs to be drawn
WIP: manual sprite rendering showing on screen
2021-10-29 02:41:01 +00:00
lda _Sprites+VBUFF_ADDR,x ; Save the previous draw location for erasing
sta _Sprites+OLD_VBUFF_ADDR,x
lda tmp0 ; Update the X coordinate
sta _Sprites+SPRITE_X,x
tya ; Update the Y coordinate
sta _Sprites+SPRITE_Y,x
Continued bug fixing * Missed an XBA to swap tile command bits into a proper index range * Explicitly track the BASE_ADDR * Fix some register overwriting * Add an UpdateSprite method
2021-10-24 03:31:38 +00:00
clc
adc #NUM_BUFF_LINES ; The virtual buffer has 24 lines of off-screen space
xba ; Each virtual scan line is 256 bytes wide for overdraw space
clc
WIP: manual sprite rendering showing on screen
2021-10-29 02:41:01 +00:00
adc tmp0 ; Add the horizontal position
Continued bug fixing * Missed an XBA to swap tile command bits into a proper index range * Explicitly track the BASE_ADDR * Fix some register overwriting * Add an UpdateSprite method
2021-10-24 03:31:38 +00:00
sta _Sprites+VBUFF_ADDR,x
Tile rendering reorganization This significantly simplifies the dispatch process by creating a proper backing store for the tiles. Most values that were calcualted on the fly are now stored as constants in the tile store. Also, all tile updated are run through the dirty tile list which solved a checken-and-egg problem of which order to do sprites vs new tiles and affords a lot of optimizations since tile rendering is deferred and each tile is only drawn at most once per frame.
2021-10-21 13:50:07 +00:00
rts
; Sprite data structures. We cache quite a few pieces of information about the sprite
; to make calculations faster, so this is hidden from the caller.
;
; Each sprite record contains the following properties:
;
; +0: Sprite status word (0 = unoccupied)
; +2: Tile data address
; +4: Screen offset address (used for data and masks)
; Number of "off-screen" lines above logical (0,0)
NUM_BUFF_LINES equ 24
MAX_SPRITES equ 64
WIP: manual sprite rendering showing on screen
2021-10-29 02:41:01 +00:00
SPRITE_REC_SIZE equ 12
Tile rendering reorganization This significantly simplifies the dispatch process by creating a proper backing store for the tiles. Most values that were calcualted on the fly are now stored as constants in the tile store. Also, all tile updated are run through the dirty tile list which solved a checken-and-egg problem of which order to do sprites vs new tiles and affords a lot of optimizations since tile rendering is deferred and each tile is only drawn at most once per frame.
2021-10-21 13:50:07 +00:00
SPRITE_STATUS_EMPTY equ 0
SPRITE_STATUS_CLEAN equ 1
SPRITE_STATUS_DIRTY equ 2
SPRITE_STATUS equ 0
TILE_DATA_OFFSET equ {MAX_SPRITES*2}
VBUFF_ADDR equ {MAX_SPRITES*4}
SPRITE_X equ {MAX_SPRITES*6}
SPRITE_Y equ {MAX_SPRITES*8}
WIP: manual sprite rendering showing on screen
2021-10-29 02:41:01 +00:00
OLD_VBUFF_ADDR equ {MAX_SPRITES*10}
Tile rendering reorganization This significantly simplifies the dispatch process by creating a proper backing store for the tiles. Most values that were calcualted on the fly are now stored as constants in the tile store. Also, all tile updated are run through the dirty tile list which solved a checken-and-egg problem of which order to do sprites vs new tiles and affords a lot of optimizations since tile rendering is deferred and each tile is only drawn at most once per frame.
2021-10-21 13:50:07 +00:00
_Sprites ds SPRITE_REC_SIZE*MAX_SPRITES