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/Sprite2.s

386 lines
14 KiB
ArmAsm
Raw Normal View History

Initial shell of generalize sprite size support; just for marking the dirty tiles
2021-11-11 23:06:38 +00:00
; Scratch space to lay out idealized _MakeDirtySprite
; On input, X register = Sprite Array Index
Sprite state rework; have run out of bank space
2022-02-07 07:19:31 +00:00
;Left equ tmp1
;Right equ tmp2
;Top equ tmp3
;Bottom equ tmp4
Initial shell of generalize sprite size support; just for marking the dirty tiles
2021-11-11 23:06:38 +00:00
Fix several bugs; biggest one in the SpriteStamp routine
2022-06-01 03:53:33 +00:00
;Origin equ tmp4
;TileTop equ tmp5
Sprite state rework; have run out of bank space
2022-02-07 07:19:31 +00:00
RowTop equ tmp6
AreaIndex equ tmp7
Initial shell of generalize sprite size support; just for marking the dirty tiles
2021-11-11 23:06:38 +00:00
Fix several bugs; biggest one in the SpriteStamp routine
2022-06-01 03:53:33 +00:00
;TileLeft equ tmp8
;ColLeft equ tmp9
Initial shell of generalize sprite size support; just for marking the dirty tiles
2021-11-11 23:06:38 +00:00
Sprite state rework; have run out of bank space
2022-02-07 07:19:31 +00:00
SpriteBit equ tmp10 ; set the bit of the value that if the current sprite index
Fix several bugs; biggest one in the SpriteStamp routine
2022-06-01 03:53:33 +00:00
; VBuffOrigin equ tmp11
Initial shell of generalize sprite size support; just for marking the dirty tiles
2021-11-11 23:06:38 +00:00
Fix vertical offset bug; was using the TileStore lookup index, not the TileStore offset
2022-06-01 14:19:28 +00:00
; Table of pre-multiplied vbuff strides
vbuff_mul
dw 0*VBUFF_STRIDE_BYTES
dw 1*VBUFF_STRIDE_BYTES
dw 2*VBUFF_STRIDE_BYTES
dw 3*VBUFF_STRIDE_BYTES
dw 4*VBUFF_STRIDE_BYTES
dw 5*VBUFF_STRIDE_BYTES
dw 6*VBUFF_STRIDE_BYTES
dw 7*VBUFF_STRIDE_BYTES
Fix dirty sprite renderer when StartX and StartY are not zero
2022-02-04 05:44:46 +00:00
; Marks a sprite as dirty. The work here is mapping from local screen coordinates to the
Fix sprite rendering with overlapping sprites. Must erase all sprites first, then re-render
2021-11-21 03:58:09 +00:00
; tile store indices. The first step is to adjust the sprite coordinates based on the current
; code field offsets and then cache variations of this value needed in the rest of the subroutine
;
; The SpriteX is always the MAXIMUM value of the corner coordinates. We subtract (SpriteX + StartX) mod 4
Checkpoint for sprite rewrite All of the sprite rendering has been deferred down to the level of the tile drawing. Sprites are no longer drawn/erased, but instead a sprite sheet is generated in AddSprite and referenced by the renderer. Because there is no longer a single off-screen buffer that holds a copy of all the rendered sprites, the TileStore size must be expanded to hold a reference to the sprite data address fo each tile. This increase in data structure size require the TileStore to be put into its own bank and appropriate code restructuring. The benefits to the rewrite are significant: 1. Sprites are never drawn/erased off-screen. They are only ever drawn directly to the screen or play field. 2. The concept of "damaged" sprites is gone. Every dirty tile automatically renders just to portion of a sprite that it intersects. These two properties result in a substantial increase in throughput.
2022-02-18 18:12:32 +00:00
; to find the coordinate in the sprite cache that matches up with the tile in the play field and
Fix sprite rendering with overlapping sprites. Must erase all sprites first, then re-render
2021-11-21 03:58:09 +00:00
; then use that to calculate the VBUFF address from which to copy sprite data.
;
; StartX SpriteX z = * mod 4 (SpriteX - z)
; ----------------------------------------------
; 0 8 0 8
; 1 8 1 7
; 2 8 2 6
; 3 8 3 5
; 4 9 1 8
; 5 9 2 7
; 6 9 3 6
; 7 9 0 9
; 8 10 2 8
; ...
;
; For the Y-coordinate, we just use "mod 8" instead of "mod 4"
Checkpoint
2022-05-27 00:36:40 +00:00
;
; When this subroutine is completed, the following values will be calculated
;
; _Sprites+TS_COVERAGE_SIZE : The number of horizontal and vertical playfield tiles covered by the sprite
; _Sprites+TS_LOOKUP_INDEX : TileStore index of the upper-left corner of the sprite
; _Sprites+TS_VBUFF_BASE : Address of the top-left corner of the sprite in the VBUFF sprite stamp memory
;
Rough outline of streamlined sprite subsystem * Split the creation of the sprite stamps from adding the sprites themselves. This allows for 48 stamps that can be pre-rendered and quickly reassigned to sprites for animations. * Inlined all calls to PushDirtyTile. This both removed significant overhead from calling the small function and, since almost all callers we checking multiple tiles, we were able to avoid incrementing the count each time and just add a single incrments at the end. * Switched from recording each tile that a sprite intersects with each from to only recording the top-left tile and the overlap size. This reduced overhead for larger sprites and removed the needs for an end-of-list marker. * Much more aggressive caching of Sprite and Tile Store values in order to streamline the inner tile dispatch routines. * Moving TileStore and Sprites (and other supporting data structures) into a separate data bank. Needed just for size purposes and provide micro-optimizations by opening up the use of abs,y addressing modes. * Revamped multi-sprite rendering code to avoid the need to copy any masks and all stacked sprites can be drawn via a sequence of and [addrX],y; ora (addrX),y where addrX is set once per tile. * General streamlining to reduct overhead. This work was focused on removing as much per-tile overhead as possible.
2022-04-20 12:43:16 +00:00
mdsOut2
lda #6 ; Pick a value for a 0x0 tile sprite
sta _Sprites+TS_COVERAGE_SIZE,y ; zero the list of tile store addresses
rts
Initial shell of generalize sprite size support; just for marking the dirty tiles
2021-11-11 23:06:38 +00:00
Checkpoint
2022-05-27 00:36:40 +00:00
_CalcDirtySprite
Sprite state rework; have run out of bank space
2022-02-07 07:19:31 +00:00
lda _Sprites+IS_OFF_SCREEN,y ; Check if the sprite is visible in the playfield
Rough outline of streamlined sprite subsystem * Split the creation of the sprite stamps from adding the sprites themselves. This allows for 48 stamps that can be pre-rendered and quickly reassigned to sprites for animations. * Inlined all calls to PushDirtyTile. This both removed significant overhead from calling the small function and, since almost all callers we checking multiple tiles, we were able to avoid incrementing the count each time and just add a single incrments at the end. * Switched from recording each tile that a sprite intersects with each from to only recording the top-left tile and the overlap size. This reduced overhead for larger sprites and removed the needs for an end-of-list marker. * Much more aggressive caching of Sprite and Tile Store values in order to streamline the inner tile dispatch routines. * Moving TileStore and Sprites (and other supporting data structures) into a separate data bank. Needed just for size purposes and provide micro-optimizations by opening up the use of abs,y addressing modes. * Revamped multi-sprite rendering code to avoid the need to copy any masks and all stacked sprites can be drawn via a sequence of and [addrX],y; ora (addrX),y where addrX is set once per tile. * General streamlining to reduct overhead. This work was focused on removing as much per-tile overhead as possible.
2022-04-20 12:43:16 +00:00
bne mdsOut2
Initial shell of generalize sprite size support; just for marking the dirty tiles
2021-11-11 23:06:38 +00:00
Checkpoint
2022-05-27 00:36:40 +00:00
; Copy the current values into the old value slots
Fix single-step vertical displacement issue
2022-06-01 12:50:19 +00:00
Checkpoint
2022-05-27 00:36:40 +00:00
lda _Sprites+TS_COVERAGE_SIZE,y
sta _Sprites+OLD_TS_COVERAGE_SIZE,y
lda _Sprites+TS_LOOKUP_INDEX,y
sta _Sprites+OLD_TS_LOOKUP_INDEX,y
Rough outline of streamlined sprite subsystem * Split the creation of the sprite stamps from adding the sprites themselves. This allows for 48 stamps that can be pre-rendered and quickly reassigned to sprites for animations. * Inlined all calls to PushDirtyTile. This both removed significant overhead from calling the small function and, since almost all callers we checking multiple tiles, we were able to avoid incrementing the count each time and just add a single incrments at the end. * Switched from recording each tile that a sprite intersects with each from to only recording the top-left tile and the overlap size. This reduced overhead for larger sprites and removed the needs for an end-of-list marker. * Much more aggressive caching of Sprite and Tile Store values in order to streamline the inner tile dispatch routines. * Moving TileStore and Sprites (and other supporting data structures) into a separate data bank. Needed just for size purposes and provide micro-optimizations by opening up the use of abs,y addressing modes. * Revamped multi-sprite rendering code to avoid the need to copy any masks and all stacked sprites can be drawn via a sequence of and [addrX],y; ora (addrX),y where addrX is set once per tile. * General streamlining to reduct overhead. This work was focused on removing as much per-tile overhead as possible.
2022-04-20 12:43:16 +00:00
; Add the first visible row of the sprite to the Y-scroll offset to find the first line in the
Continuing to tweak and debug
2022-05-31 21:31:44 +00:00
; code field that needs to be drawn. The range of values is 0 to 199+207 = [0, 406]. This
; value is dividede by 8, so the range of lookup values is [0, 50], so 51 possible values.
Initial shell of generalize sprite size support; just for marking the dirty tiles
2021-11-11 23:06:38 +00:00
clc
Sprite state rework; have run out of bank space
2022-02-07 07:19:31 +00:00
lda _Sprites+SPRITE_CLIP_TOP,y
Add more pre-computed values to the sprite structure
2022-02-21 19:33:39 +00:00
adc StartYMod208 ; Adjust for the scroll offset
Continuing to tweak and debug
2022-05-31 21:31:44 +00:00
pha ; Cache
Rough outline of streamlined sprite subsystem * Split the creation of the sprite stamps from adding the sprites themselves. This allows for 48 stamps that can be pre-rendered and quickly reassigned to sprites for animations. * Inlined all calls to PushDirtyTile. This both removed significant overhead from calling the small function and, since almost all callers we checking multiple tiles, we were able to avoid incrementing the count each time and just add a single incrments at the end. * Switched from recording each tile that a sprite intersects with each from to only recording the top-left tile and the overlap size. This reduced overhead for larger sprites and removed the needs for an end-of-list marker. * Much more aggressive caching of Sprite and Tile Store values in order to streamline the inner tile dispatch routines. * Moving TileStore and Sprites (and other supporting data structures) into a separate data bank. Needed just for size purposes and provide micro-optimizations by opening up the use of abs,y addressing modes. * Revamped multi-sprite rendering code to avoid the need to copy any masks and all stacked sprites can be drawn via a sequence of and [addrX],y; ora (addrX),y where addrX is set once per tile. * General streamlining to reduct overhead. This work was focused on removing as much per-tile overhead as possible.
2022-04-20 12:43:16 +00:00
and #$FFF8 ; mask first to ensure LSR will clear the carry
Initial shell of generalize sprite size support; just for marking the dirty tiles
2021-11-11 23:06:38 +00:00
lsr
Rough outline of streamlined sprite subsystem * Split the creation of the sprite stamps from adding the sprites themselves. This allows for 48 stamps that can be pre-rendered and quickly reassigned to sprites for animations. * Inlined all calls to PushDirtyTile. This both removed significant overhead from calling the small function and, since almost all callers we checking multiple tiles, we were able to avoid incrementing the count each time and just add a single incrments at the end. * Switched from recording each tile that a sprite intersects with each from to only recording the top-left tile and the overlap size. This reduced overhead for larger sprites and removed the needs for an end-of-list marker. * Much more aggressive caching of Sprite and Tile Store values in order to streamline the inner tile dispatch routines. * Moving TileStore and Sprites (and other supporting data structures) into a separate data bank. Needed just for size purposes and provide micro-optimizations by opening up the use of abs,y addressing modes. * Revamped multi-sprite rendering code to avoid the need to copy any masks and all stacked sprites can be drawn via a sequence of and [addrX],y; ora (addrX),y where addrX is set once per tile. * General streamlining to reduct overhead. This work was focused on removing as much per-tile overhead as possible.
2022-04-20 12:43:16 +00:00
lsr
Continuing to tweak and debug
2022-05-31 21:31:44 +00:00
tax
lda TileStoreLookupYTable,x
Another checkpoint; converging on the working implementation
2022-05-31 13:43:26 +00:00
sta RowTop ; Even numbers from [0, 100] (50 elements)
Initial shell of generalize sprite size support; just for marking the dirty tiles
2021-11-11 23:06:38 +00:00
Rough outline of streamlined sprite subsystem * Split the creation of the sprite stamps from adding the sprites themselves. This allows for 48 stamps that can be pre-rendered and quickly reassigned to sprites for animations. * Inlined all calls to PushDirtyTile. This both removed significant overhead from calling the small function and, since almost all callers we checking multiple tiles, we were able to avoid incrementing the count each time and just add a single incrments at the end. * Switched from recording each tile that a sprite intersects with each from to only recording the top-left tile and the overlap size. This reduced overhead for larger sprites and removed the needs for an end-of-list marker. * Much more aggressive caching of Sprite and Tile Store values in order to streamline the inner tile dispatch routines. * Moving TileStore and Sprites (and other supporting data structures) into a separate data bank. Needed just for size purposes and provide micro-optimizations by opening up the use of abs,y addressing modes. * Revamped multi-sprite rendering code to avoid the need to copy any masks and all stacked sprites can be drawn via a sequence of and [addrX],y; ora (addrX),y where addrX is set once per tile. * General streamlining to reduct overhead. This work was focused on removing as much per-tile overhead as possible.
2022-04-20 12:43:16 +00:00
; Get the position of the top edge within the tile and then add it to the sprite's height
; to calculate the number of tiles that are overlapped. We use the actual width and height
; values here so small sprites (like 4x4 bullets) only force an update to the actual tiles
; that are intersected, rather than assuming an 8x8 sprite always takes up that amount of
; space.
Checkpoint for sprite rewrite All of the sprite rendering has been deferred down to the level of the tile drawing. Sprites are no longer drawn/erased, but instead a sprite sheet is generated in AddSprite and referenced by the renderer. Because there is no longer a single off-screen buffer that holds a copy of all the rendered sprites, the TileStore size must be expanded to hold a reference to the sprite data address fo each tile. This increase in data structure size require the TileStore to be put into its own bank and appropriate code restructuring. The benefits to the rewrite are significant: 1. Sprites are never drawn/erased off-screen. They are only ever drawn directly to the screen or play field. 2. The concept of "damaged" sprites is gone. Every dirty tile automatically renders just to portion of a sprite that it intersects. These two properties result in a substantial increase in throughput.
2022-02-18 18:12:32 +00:00
Continuing to tweak and debug
2022-05-31 21:31:44 +00:00
pla
Add more pre-computed values to the sprite structure
2022-02-21 19:33:39 +00:00
and #$0007
Rough outline of streamlined sprite subsystem * Split the creation of the sprite stamps from adding the sprites themselves. This allows for 48 stamps that can be pre-rendered and quickly reassigned to sprites for animations. * Inlined all calls to PushDirtyTile. This both removed significant overhead from calling the small function and, since almost all callers we checking multiple tiles, we were able to avoid incrementing the count each time and just add a single incrments at the end. * Switched from recording each tile that a sprite intersects with each from to only recording the top-left tile and the overlap size. This reduced overhead for larger sprites and removed the needs for an end-of-list marker. * Much more aggressive caching of Sprite and Tile Store values in order to streamline the inner tile dispatch routines. * Moving TileStore and Sprites (and other supporting data structures) into a separate data bank. Needed just for size purposes and provide micro-optimizations by opening up the use of abs,y addressing modes. * Revamped multi-sprite rendering code to avoid the need to copy any masks and all stacked sprites can be drawn via a sequence of and [addrX],y; ora (addrX),y where addrX is set once per tile. * General streamlining to reduct overhead. This work was focused on removing as much per-tile overhead as possible.
2022-04-20 12:43:16 +00:00
tax ; cache again. This is a bit faster than recalculating
Fix masking bug in sprite pre-calc
2022-02-21 20:25:55 +00:00
Rough outline of streamlined sprite subsystem * Split the creation of the sprite stamps from adding the sprites themselves. This allows for 48 stamps that can be pre-rendered and quickly reassigned to sprites for animations. * Inlined all calls to PushDirtyTile. This both removed significant overhead from calling the small function and, since almost all callers we checking multiple tiles, we were able to avoid incrementing the count each time and just add a single incrments at the end. * Switched from recording each tile that a sprite intersects with each from to only recording the top-left tile and the overlap size. This reduced overhead for larger sprites and removed the needs for an end-of-list marker. * Much more aggressive caching of Sprite and Tile Store values in order to streamline the inner tile dispatch routines. * Moving TileStore and Sprites (and other supporting data structures) into a separate data bank. Needed just for size purposes and provide micro-optimizations by opening up the use of abs,y addressing modes. * Revamped multi-sprite rendering code to avoid the need to copy any masks and all stacked sprites can be drawn via a sequence of and [addrX],y; ora (addrX),y where addrX is set once per tile. * General streamlining to reduct overhead. This work was focused on removing as much per-tile overhead as possible.
2022-04-20 12:43:16 +00:00
adc _Sprites+SPRITE_CLIP_HEIGHT,y ; Nominal value between 0 and 16+7 = 23 = 10111
Add more pre-computed values to the sprite structure
2022-02-21 19:33:39 +00:00
dec
and #$0018
Initial shell of generalize sprite size support; just for marking the dirty tiles
2021-11-11 23:06:38 +00:00
sta AreaIndex
Another checkpoint; converging on the working implementation
2022-05-31 13:43:26 +00:00
txa ; Get the vertical offset in the VBUFF memory
Rough outline of streamlined sprite subsystem * Split the creation of the sprite stamps from adding the sprites themselves. This allows for 48 stamps that can be pre-rendered and quickly reassigned to sprites for animations. * Inlined all calls to PushDirtyTile. This both removed significant overhead from calling the small function and, since almost all callers we checking multiple tiles, we were able to avoid incrementing the count each time and just add a single incrments at the end. * Switched from recording each tile that a sprite intersects with each from to only recording the top-left tile and the overlap size. This reduced overhead for larger sprites and removed the needs for an end-of-list marker. * Much more aggressive caching of Sprite and Tile Store values in order to streamline the inner tile dispatch routines. * Moving TileStore and Sprites (and other supporting data structures) into a separate data bank. Needed just for size purposes and provide micro-optimizations by opening up the use of abs,y addressing modes. * Revamped multi-sprite rendering code to avoid the need to copy any masks and all stacked sprites can be drawn via a sequence of and [addrX],y; ora (addrX),y where addrX is set once per tile. * General streamlining to reduct overhead. This work was focused on removing as much per-tile overhead as possible.
2022-04-20 12:43:16 +00:00
asl
tax
Fix vertical offset bug; was using the TileStore lookup index, not the TileStore offset
2022-06-01 14:19:28 +00:00
ldal vbuff_mul,x
Rough outline of streamlined sprite subsystem * Split the creation of the sprite stamps from adding the sprites themselves. This allows for 48 stamps that can be pre-rendered and quickly reassigned to sprites for animations. * Inlined all calls to PushDirtyTile. This both removed significant overhead from calling the small function and, since almost all callers we checking multiple tiles, we were able to avoid incrementing the count each time and just add a single incrments at the end. * Switched from recording each tile that a sprite intersects with each from to only recording the top-left tile and the overlap size. This reduced overhead for larger sprites and removed the needs for an end-of-list marker. * Much more aggressive caching of Sprite and Tile Store values in order to streamline the inner tile dispatch routines. * Moving TileStore and Sprites (and other supporting data structures) into a separate data bank. Needed just for size purposes and provide micro-optimizations by opening up the use of abs,y addressing modes. * Revamped multi-sprite rendering code to avoid the need to copy any masks and all stacked sprites can be drawn via a sequence of and [addrX],y; ora (addrX),y where addrX is set once per tile. * General streamlining to reduct overhead. This work was focused on removing as much per-tile overhead as possible.
2022-04-20 12:43:16 +00:00
sta tmp0
; Add the horizontal position to the horizontal offset to find the first column in the
Continuing to tweak and debug
2022-05-31 21:31:44 +00:00
; code field that needs to be drawn. The range of values is 0 to 159+163 = [0, 322].
; This value is divided by 4, so 81 possible values
Initial shell of generalize sprite size support; just for marking the dirty tiles
2021-11-11 23:06:38 +00:00
clc
Sprite state rework; have run out of bank space
2022-02-07 07:19:31 +00:00
lda _Sprites+SPRITE_CLIP_LEFT,y
Initial shell of generalize sprite size support; just for marking the dirty tiles
2021-11-11 23:06:38 +00:00
adc StartXMod164
Fix vertical offset bug; was using the TileStore lookup index, not the TileStore offset
2022-06-01 14:19:28 +00:00
pha
Rough outline of streamlined sprite subsystem * Split the creation of the sprite stamps from adding the sprites themselves. This allows for 48 stamps that can be pre-rendered and quickly reassigned to sprites for animations. * Inlined all calls to PushDirtyTile. This both removed significant overhead from calling the small function and, since almost all callers we checking multiple tiles, we were able to avoid incrementing the count each time and just add a single incrments at the end. * Switched from recording each tile that a sprite intersects with each from to only recording the top-left tile and the overlap size. This reduced overhead for larger sprites and removed the needs for an end-of-list marker. * Much more aggressive caching of Sprite and Tile Store values in order to streamline the inner tile dispatch routines. * Moving TileStore and Sprites (and other supporting data structures) into a separate data bank. Needed just for size purposes and provide micro-optimizations by opening up the use of abs,y addressing modes. * Revamped multi-sprite rendering code to avoid the need to copy any masks and all stacked sprites can be drawn via a sequence of and [addrX],y; ora (addrX),y where addrX is set once per tile. * General streamlining to reduct overhead. This work was focused on removing as much per-tile overhead as possible.
2022-04-20 12:43:16 +00:00
and #$FFFC
Checkpoint
2022-05-27 00:36:40 +00:00
lsr ; Even numbers from [0, 160] (80 elements)
Rough outline of streamlined sprite subsystem * Split the creation of the sprite stamps from adding the sprites themselves. This allows for 48 stamps that can be pre-rendered and quickly reassigned to sprites for animations. * Inlined all calls to PushDirtyTile. This both removed significant overhead from calling the small function and, since almost all callers we checking multiple tiles, we were able to avoid incrementing the count each time and just add a single incrments at the end. * Switched from recording each tile that a sprite intersects with each from to only recording the top-left tile and the overlap size. This reduced overhead for larger sprites and removed the needs for an end-of-list marker. * Much more aggressive caching of Sprite and Tile Store values in order to streamline the inner tile dispatch routines. * Moving TileStore and Sprites (and other supporting data structures) into a separate data bank. Needed just for size purposes and provide micro-optimizations by opening up the use of abs,y addressing modes. * Revamped multi-sprite rendering code to avoid the need to copy any masks and all stacked sprites can be drawn via a sequence of and [addrX],y; ora (addrX),y where addrX is set once per tile. * General streamlining to reduct overhead. This work was focused on removing as much per-tile overhead as possible.
2022-04-20 12:43:16 +00:00
adc RowTop
sta _Sprites+TS_LOOKUP_INDEX,y ; This is the index into the TileStoreLookup table
Fix vertical offset bug; was using the TileStore lookup index, not the TileStore offset
2022-06-01 14:19:28 +00:00
; Create an offset value for loading the calculated VBUFF addresses within the core renderer by
; subtracting the actual TileStore offset from the sprite's vbuff address array
Another checkpoint; converging on the working implementation
2022-05-31 13:43:26 +00:00
Fix vertical offset bug; was using the TileStore lookup index, not the TileStore offset
2022-06-01 14:19:28 +00:00
tax
lda _Sprites+VBUFF_ARRAY_ADDR,y
Another checkpoint; converging on the working implementation
2022-05-31 13:43:26 +00:00
sec
Fix vertical offset bug; was using the TileStore lookup index, not the TileStore offset
2022-06-01 14:19:28 +00:00
sbc TileStoreLookup,x
Another checkpoint; converging on the working implementation
2022-05-31 13:43:26 +00:00
sta tmp1 ; Spill this value to direct page temp space
Rough outline of streamlined sprite subsystem * Split the creation of the sprite stamps from adding the sprites themselves. This allows for 48 stamps that can be pre-rendered and quickly reassigned to sprites for animations. * Inlined all calls to PushDirtyTile. This both removed significant overhead from calling the small function and, since almost all callers we checking multiple tiles, we were able to avoid incrementing the count each time and just add a single incrments at the end. * Switched from recording each tile that a sprite intersects with each from to only recording the top-left tile and the overlap size. This reduced overhead for larger sprites and removed the needs for an end-of-list marker. * Much more aggressive caching of Sprite and Tile Store values in order to streamline the inner tile dispatch routines. * Moving TileStore and Sprites (and other supporting data structures) into a separate data bank. Needed just for size purposes and provide micro-optimizations by opening up the use of abs,y addressing modes. * Revamped multi-sprite rendering code to avoid the need to copy any masks and all stacked sprites can be drawn via a sequence of and [addrX],y; ora (addrX),y where addrX is set once per tile. * General streamlining to reduct overhead. This work was focused on removing as much per-tile overhead as possible.
2022-04-20 12:43:16 +00:00
; Calculate the final address of the sprite data in the stamp buffer. We have to move earlier
; in the buffer based on the horizontal offset and move up for each vertical offset.
Initial shell of generalize sprite size support; just for marking the dirty tiles
2021-11-11 23:06:38 +00:00
Fix vertical offset bug; was using the TileStore lookup index, not the TileStore offset
2022-06-01 14:19:28 +00:00
pla
Add more pre-computed values to the sprite structure
2022-02-21 19:33:39 +00:00
and #$0003
Rough outline of streamlined sprite subsystem * Split the creation of the sprite stamps from adding the sprites themselves. This allows for 48 stamps that can be pre-rendered and quickly reassigned to sprites for animations. * Inlined all calls to PushDirtyTile. This both removed significant overhead from calling the small function and, since almost all callers we checking multiple tiles, we were able to avoid incrementing the count each time and just add a single incrments at the end. * Switched from recording each tile that a sprite intersects with each from to only recording the top-left tile and the overlap size. This reduced overhead for larger sprites and removed the needs for an end-of-list marker. * Much more aggressive caching of Sprite and Tile Store values in order to streamline the inner tile dispatch routines. * Moving TileStore and Sprites (and other supporting data structures) into a separate data bank. Needed just for size purposes and provide micro-optimizations by opening up the use of abs,y addressing modes. * Revamped multi-sprite rendering code to avoid the need to copy any masks and all stacked sprites can be drawn via a sequence of and [addrX],y; ora (addrX),y where addrX is set once per tile. * General streamlining to reduct overhead. This work was focused on removing as much per-tile overhead as possible.
2022-04-20 12:43:16 +00:00
tax
Fix several bugs; biggest one in the SpriteStamp routine
2022-06-01 03:53:33 +00:00
clc
Rough outline of streamlined sprite subsystem * Split the creation of the sprite stamps from adding the sprites themselves. This allows for 48 stamps that can be pre-rendered and quickly reassigned to sprites for animations. * Inlined all calls to PushDirtyTile. This both removed significant overhead from calling the small function and, since almost all callers we checking multiple tiles, we were able to avoid incrementing the count each time and just add a single incrments at the end. * Switched from recording each tile that a sprite intersects with each from to only recording the top-left tile and the overlap size. This reduced overhead for larger sprites and removed the needs for an end-of-list marker. * Much more aggressive caching of Sprite and Tile Store values in order to streamline the inner tile dispatch routines. * Moving TileStore and Sprites (and other supporting data structures) into a separate data bank. Needed just for size purposes and provide micro-optimizations by opening up the use of abs,y addressing modes. * Revamped multi-sprite rendering code to avoid the need to copy any masks and all stacked sprites can be drawn via a sequence of and [addrX],y; ora (addrX),y where addrX is set once per tile. * General streamlining to reduct overhead. This work was focused on removing as much per-tile overhead as possible.
2022-04-20 12:43:16 +00:00
adc tmp0 ; add to the vertical offset
; Subtract this value from the SPRITE_DISP address
eor #$FFFF ; A = -X - 1
sec ; C = 1
adc _Sprites+SPRITE_DISP,y ; A = SPRITE_DISP + (-X - 1) + 1 = SPRITE_DISP - X
Checkpoint
2022-05-27 00:36:40 +00:00
sta _Sprites+TS_VBUFF_BASE,y
Rough outline of streamlined sprite subsystem * Split the creation of the sprite stamps from adding the sprites themselves. This allows for 48 stamps that can be pre-rendered and quickly reassigned to sprites for animations. * Inlined all calls to PushDirtyTile. This both removed significant overhead from calling the small function and, since almost all callers we checking multiple tiles, we were able to avoid incrementing the count each time and just add a single incrments at the end. * Switched from recording each tile that a sprite intersects with each from to only recording the top-left tile and the overlap size. This reduced overhead for larger sprites and removed the needs for an end-of-list marker. * Much more aggressive caching of Sprite and Tile Store values in order to streamline the inner tile dispatch routines. * Moving TileStore and Sprites (and other supporting data structures) into a separate data bank. Needed just for size purposes and provide micro-optimizations by opening up the use of abs,y addressing modes. * Revamped multi-sprite rendering code to avoid the need to copy any masks and all stacked sprites can be drawn via a sequence of and [addrX],y; ora (addrX),y where addrX is set once per tile. * General streamlining to reduct overhead. This work was focused on removing as much per-tile overhead as possible.
2022-04-20 12:43:16 +00:00
; We know the starting corner of the TileStore. Now, we need to figure out now many tiles
; the sprite covers. This is a function of the sprite's width and height and the specific
; location of the upper-left corner of the sprite within the corner tile.
txa
Fix several bugs; biggest one in the SpriteStamp routine
2022-06-01 03:53:33 +00:00
clc
Rough outline of streamlined sprite subsystem * Split the creation of the sprite stamps from adding the sprites themselves. This allows for 48 stamps that can be pre-rendered and quickly reassigned to sprites for animations. * Inlined all calls to PushDirtyTile. This both removed significant overhead from calling the small function and, since almost all callers we checking multiple tiles, we were able to avoid incrementing the count each time and just add a single incrments at the end. * Switched from recording each tile that a sprite intersects with each from to only recording the top-left tile and the overlap size. This reduced overhead for larger sprites and removed the needs for an end-of-list marker. * Much more aggressive caching of Sprite and Tile Store values in order to streamline the inner tile dispatch routines. * Moving TileStore and Sprites (and other supporting data structures) into a separate data bank. Needed just for size purposes and provide micro-optimizations by opening up the use of abs,y addressing modes. * Revamped multi-sprite rendering code to avoid the need to copy any masks and all stacked sprites can be drawn via a sequence of and [addrX],y; ora (addrX),y where addrX is set once per tile. * General streamlining to reduct overhead. This work was focused on removing as much per-tile overhead as possible.
2022-04-20 12:43:16 +00:00
adc _Sprites+SPRITE_CLIP_WIDTH,y ; max width = 8 = 0x08
Add more pre-computed values to the sprite structure
2022-02-21 19:33:39 +00:00
dec
Rough outline of streamlined sprite subsystem * Split the creation of the sprite stamps from adding the sprites themselves. This allows for 48 stamps that can be pre-rendered and quickly reassigned to sprites for animations. * Inlined all calls to PushDirtyTile. This both removed significant overhead from calling the small function and, since almost all callers we checking multiple tiles, we were able to avoid incrementing the count each time and just add a single incrments at the end. * Switched from recording each tile that a sprite intersects with each from to only recording the top-left tile and the overlap size. This reduced overhead for larger sprites and removed the needs for an end-of-list marker. * Much more aggressive caching of Sprite and Tile Store values in order to streamline the inner tile dispatch routines. * Moving TileStore and Sprites (and other supporting data structures) into a separate data bank. Needed just for size purposes and provide micro-optimizations by opening up the use of abs,y addressing modes. * Revamped multi-sprite rendering code to avoid the need to copy any masks and all stacked sprites can be drawn via a sequence of and [addrX],y; ora (addrX),y where addrX is set once per tile. * General streamlining to reduct overhead. This work was focused on removing as much per-tile overhead as possible.
2022-04-20 12:43:16 +00:00
and #$000C
Fix masking bug in sprite pre-calc
2022-02-21 20:25:55 +00:00
lsr ; max value = 4 = 0x04
Rough outline of streamlined sprite subsystem * Split the creation of the sprite stamps from adding the sprites themselves. This allows for 48 stamps that can be pre-rendered and quickly reassigned to sprites for animations. * Inlined all calls to PushDirtyTile. This both removed significant overhead from calling the small function and, since almost all callers we checking multiple tiles, we were able to avoid incrementing the count each time and just add a single incrments at the end. * Switched from recording each tile that a sprite intersects with each from to only recording the top-left tile and the overlap size. This reduced overhead for larger sprites and removed the needs for an end-of-list marker. * Much more aggressive caching of Sprite and Tile Store values in order to streamline the inner tile dispatch routines. * Moving TileStore and Sprites (and other supporting data structures) into a separate data bank. Needed just for size purposes and provide micro-optimizations by opening up the use of abs,y addressing modes. * Revamped multi-sprite rendering code to avoid the need to copy any masks and all stacked sprites can be drawn via a sequence of and [addrX],y; ora (addrX),y where addrX is set once per tile. * General streamlining to reduct overhead. This work was focused on removing as much per-tile overhead as possible.
2022-04-20 12:43:16 +00:00
ora AreaIndex ; merge into the area index
Another checkpoint; converging on the working implementation
2022-05-31 13:43:26 +00:00
sta _Sprites+TS_COVERAGE_SIZE,y ; Save this value as a key to the coverage size of the sprite
Rough outline of streamlined sprite subsystem * Split the creation of the sprite stamps from adding the sprites themselves. This allows for 48 stamps that can be pre-rendered and quickly reassigned to sprites for animations. * Inlined all calls to PushDirtyTile. This both removed significant overhead from calling the small function and, since almost all callers we checking multiple tiles, we were able to avoid incrementing the count each time and just add a single incrments at the end. * Switched from recording each tile that a sprite intersects with each from to only recording the top-left tile and the overlap size. This reduced overhead for larger sprites and removed the needs for an end-of-list marker. * Much more aggressive caching of Sprite and Tile Store values in order to streamline the inner tile dispatch routines. * Moving TileStore and Sprites (and other supporting data structures) into a separate data bank. Needed just for size purposes and provide micro-optimizations by opening up the use of abs,y addressing modes. * Revamped multi-sprite rendering code to avoid the need to copy any masks and all stacked sprites can be drawn via a sequence of and [addrX],y; ora (addrX),y where addrX is set once per tile. * General streamlining to reduct overhead. This work was focused on removing as much per-tile overhead as possible.
2022-04-20 12:43:16 +00:00
Another checkpoint; converging on the working implementation
2022-05-31 13:43:26 +00:00
; Last task. Since we don't need to use the X-register to cache values; load the direct page 2
; offset for the SPRITE_VBUFF_PTR and save it
tya
ora #$100
tax
lda tmp1
sta SPRITE_VBUFF_PTR,x
Rough outline of streamlined sprite subsystem * Split the creation of the sprite stamps from adding the sprites themselves. This allows for 48 stamps that can be pre-rendered and quickly reassigned to sprites for animations. * Inlined all calls to PushDirtyTile. This both removed significant overhead from calling the small function and, since almost all callers we checking multiple tiles, we were able to avoid incrementing the count each time and just add a single incrments at the end. * Switched from recording each tile that a sprite intersects with each from to only recording the top-left tile and the overlap size. This reduced overhead for larger sprites and removed the needs for an end-of-list marker. * Much more aggressive caching of Sprite and Tile Store values in order to streamline the inner tile dispatch routines. * Moving TileStore and Sprites (and other supporting data structures) into a separate data bank. Needed just for size purposes and provide micro-optimizations by opening up the use of abs,y addressing modes. * Revamped multi-sprite rendering code to avoid the need to copy any masks and all stacked sprites can be drawn via a sequence of and [addrX],y; ora (addrX),y where addrX is set once per tile. * General streamlining to reduct overhead. This work was focused on removing as much per-tile overhead as possible.
2022-04-20 12:43:16 +00:00
Checkpoint
2022-05-27 00:36:40 +00:00
mdsOut rts
Rough outline of streamlined sprite subsystem * Split the creation of the sprite stamps from adding the sprites themselves. This allows for 48 stamps that can be pre-rendered and quickly reassigned to sprites for animations. * Inlined all calls to PushDirtyTile. This both removed significant overhead from calling the small function and, since almost all callers we checking multiple tiles, we were able to avoid incrementing the count each time and just add a single incrments at the end. * Switched from recording each tile that a sprite intersects with each from to only recording the top-left tile and the overlap size. This reduced overhead for larger sprites and removed the needs for an end-of-list marker. * Much more aggressive caching of Sprite and Tile Store values in order to streamline the inner tile dispatch routines. * Moving TileStore and Sprites (and other supporting data structures) into a separate data bank. Needed just for size purposes and provide micro-optimizations by opening up the use of abs,y addressing modes. * Revamped multi-sprite rendering code to avoid the need to copy any masks and all stacked sprites can be drawn via a sequence of and [addrX],y; ora (addrX),y where addrX is set once per tile. * General streamlining to reduct overhead. This work was focused on removing as much per-tile overhead as possible.
2022-04-20 12:43:16 +00:00
Clean up constants and fix bad addressing mode
2022-06-02 18:06:26 +00:00
; NOTE: The VBuffArray table is set up so that each sprite's vbuff address is stored in a
; parallel structure to the Tile Store. This allows up to use the same TileStoreLookup
; offset to index into the array of 16 sprite VBUFF addresses that are bound to a given tile
Checkpoint
2022-05-27 00:36:40 +00:00
_MarkDirtySpriteTiles
lda _SpriteBits,y
sta SpriteBit
clc
ldx _Sprites+TS_COVERAGE_SIZE,y
Fix vertical offset bug; was using the TileStore lookup index, not the TileStore offset
2022-06-01 14:19:28 +00:00
jmp (mdsmark,x)
Rough outline of streamlined sprite subsystem * Split the creation of the sprite stamps from adding the sprites themselves. This allows for 48 stamps that can be pre-rendered and quickly reassigned to sprites for animations. * Inlined all calls to PushDirtyTile. This both removed significant overhead from calling the small function and, since almost all callers we checking multiple tiles, we were able to avoid incrementing the count each time and just add a single incrments at the end. * Switched from recording each tile that a sprite intersects with each from to only recording the top-left tile and the overlap size. This reduced overhead for larger sprites and removed the needs for an end-of-list marker. * Much more aggressive caching of Sprite and Tile Store values in order to streamline the inner tile dispatch routines. * Moving TileStore and Sprites (and other supporting data structures) into a separate data bank. Needed just for size purposes and provide micro-optimizations by opening up the use of abs,y addressing modes. * Revamped multi-sprite rendering code to avoid the need to copy any masks and all stacked sprites can be drawn via a sequence of and [addrX],y; ora (addrX),y where addrX is set once per tile. * General streamlining to reduct overhead. This work was focused on removing as much per-tile overhead as possible.
2022-04-20 12:43:16 +00:00
Fix vertical offset bug; was using the TileStore lookup index, not the TileStore offset
2022-06-01 14:19:28 +00:00
mdsmark dw :mark1x1,:mark1x2,:mark1x3,mdsOut
Initial shell of generalize sprite size support; just for marking the dirty tiles
2021-11-11 23:06:38 +00:00
dw :mark2x1,:mark2x2,:mark2x3,mdsOut
dw :mark3x1,:mark3x2,:mark3x3,mdsOut
dw mdsOut,mdsOut,mdsOut,mdsOut
Checkpoint
2022-05-27 00:36:40 +00:00
; Pair of macros to make the unrolled loop more concise
Initial shell of generalize sprite size support; just for marking the dirty tiles
2021-11-11 23:06:38 +00:00
;
Checkpoint
2022-05-27 00:36:40 +00:00
; 1. Load the tile store address from a fixed offset
; 2. Set the sprite bit from the TS_SPRITE_FLAG location
; 3. Checks if the tile is dirty and marks it
; 4. If the tile was dirty, save the tile store address to be added to the DirtyTiles list later
; 5. Sets the VBUFF address for the current sprite slot
Initial shell of generalize sprite size support; just for marking the dirty tiles
2021-11-11 23:06:38 +00:00
;
Checkpoint
2022-05-27 00:36:40 +00:00
; The second macro is the same as the first, but the VBUFF calculation is moved up so that the value
; from the previous step can be reused and save a load every other step.
TSSetSprite mac
Fix several bugs; biggest one in the SpriteStamp routine
2022-06-01 03:53:33 +00:00
ldy TileStoreLookup+{]1},x
Rough outline of streamlined sprite subsystem * Split the creation of the sprite stamps from adding the sprites themselves. This allows for 48 stamps that can be pre-rendered and quickly reassigned to sprites for animations. * Inlined all calls to PushDirtyTile. This both removed significant overhead from calling the small function and, since almost all callers we checking multiple tiles, we were able to avoid incrementing the count each time and just add a single incrments at the end. * Switched from recording each tile that a sprite intersects with each from to only recording the top-left tile and the overlap size. This reduced overhead for larger sprites and removed the needs for an end-of-list marker. * Much more aggressive caching of Sprite and Tile Store values in order to streamline the inner tile dispatch routines. * Moving TileStore and Sprites (and other supporting data structures) into a separate data bank. Needed just for size purposes and provide micro-optimizations by opening up the use of abs,y addressing modes. * Revamped multi-sprite rendering code to avoid the need to copy any masks and all stacked sprites can be drawn via a sequence of and [addrX],y; ora (addrX),y where addrX is set once per tile. * General streamlining to reduct overhead. This work was focused on removing as much per-tile overhead as possible.
2022-04-20 12:43:16 +00:00
lda SpriteBit
ora TileStore+TS_SPRITE_FLAG,y
sta TileStore+TS_SPRITE_FLAG,y
lda TileStore+TS_DIRTY,y
Checkpoint
2022-05-27 00:36:40 +00:00
bne next
Rough outline of streamlined sprite subsystem * Split the creation of the sprite stamps from adding the sprites themselves. This allows for 48 stamps that can be pre-rendered and quickly reassigned to sprites for animations. * Inlined all calls to PushDirtyTile. This both removed significant overhead from calling the small function and, since almost all callers we checking multiple tiles, we were able to avoid incrementing the count each time and just add a single incrments at the end. * Switched from recording each tile that a sprite intersects with each from to only recording the top-left tile and the overlap size. This reduced overhead for larger sprites and removed the needs for an end-of-list marker. * Much more aggressive caching of Sprite and Tile Store values in order to streamline the inner tile dispatch routines. * Moving TileStore and Sprites (and other supporting data structures) into a separate data bank. Needed just for size purposes and provide micro-optimizations by opening up the use of abs,y addressing modes. * Revamped multi-sprite rendering code to avoid the need to copy any masks and all stacked sprites can be drawn via a sequence of and [addrX],y; ora (addrX),y where addrX is set once per tile. * General streamlining to reduct overhead. This work was focused on removing as much per-tile overhead as possible.
2022-04-20 12:43:16 +00:00
Checkpoint
2022-05-27 00:36:40 +00:00
inc
Rough outline of streamlined sprite subsystem * Split the creation of the sprite stamps from adding the sprites themselves. This allows for 48 stamps that can be pre-rendered and quickly reassigned to sprites for animations. * Inlined all calls to PushDirtyTile. This both removed significant overhead from calling the small function and, since almost all callers we checking multiple tiles, we were able to avoid incrementing the count each time and just add a single incrments at the end. * Switched from recording each tile that a sprite intersects with each from to only recording the top-left tile and the overlap size. This reduced overhead for larger sprites and removed the needs for an end-of-list marker. * Much more aggressive caching of Sprite and Tile Store values in order to streamline the inner tile dispatch routines. * Moving TileStore and Sprites (and other supporting data structures) into a separate data bank. Needed just for size purposes and provide micro-optimizations by opening up the use of abs,y addressing modes. * Revamped multi-sprite rendering code to avoid the need to copy any masks and all stacked sprites can be drawn via a sequence of and [addrX],y; ora (addrX),y where addrX is set once per tile. * General streamlining to reduct overhead. This work was focused on removing as much per-tile overhead as possible.
2022-04-20 12:43:16 +00:00
sta TileStore+TS_DIRTY,y
Checkpoint
2022-05-27 00:36:40 +00:00
tya
ldy DirtyTileCount
sta DirtyTiles,y
iny
iny
sty DirtyTileCount
next
<<<
Rough outline of streamlined sprite subsystem * Split the creation of the sprite stamps from adding the sprites themselves. This allows for 48 stamps that can be pre-rendered and quickly reassigned to sprites for animations. * Inlined all calls to PushDirtyTile. This both removed significant overhead from calling the small function and, since almost all callers we checking multiple tiles, we were able to avoid incrementing the count each time and just add a single incrments at the end. * Switched from recording each tile that a sprite intersects with each from to only recording the top-left tile and the overlap size. This reduced overhead for larger sprites and removed the needs for an end-of-list marker. * Much more aggressive caching of Sprite and Tile Store values in order to streamline the inner tile dispatch routines. * Moving TileStore and Sprites (and other supporting data structures) into a separate data bank. Needed just for size purposes and provide micro-optimizations by opening up the use of abs,y addressing modes. * Revamped multi-sprite rendering code to avoid the need to copy any masks and all stacked sprites can be drawn via a sequence of and [addrX],y; ora (addrX),y where addrX is set once per tile. * General streamlining to reduct overhead. This work was focused on removing as much per-tile overhead as possible.
2022-04-20 12:43:16 +00:00
Continuing to tweak and debug
2022-05-31 21:31:44 +00:00
ROW equ TILE_STORE_WIDTH*2 ; This many bytes to the next row in TileStore coordinates
COL equ 2 ; This many bytes for each element
Another checkpoint; converging on the working implementation
2022-05-31 13:43:26 +00:00
Initial shell of generalize sprite size support; just for marking the dirty tiles
2021-11-11 23:06:38 +00:00
:mark1x1
Another checkpoint; converging on the working implementation
2022-05-31 13:43:26 +00:00
ldx _Sprites+VBUFF_ARRAY_ADDR,y ; get the address of this sprite's vbuff values
Clean up constants and fix bad addressing mode
2022-06-02 18:06:26 +00:00
lda _Sprites+TS_VBUFF_BASE,y ; get the starting vbuff address
sta: {0*ROW}+{0*COL},x ; Put in the vbuff address
Another checkpoint; converging on the working implementation
2022-05-31 13:43:26 +00:00
Checkpoint
2022-05-27 00:36:40 +00:00
ldx _Sprites+TS_LOOKUP_INDEX,y
Another checkpoint; converging on the working implementation
2022-05-31 13:43:26 +00:00
TSSetSprite 0*{TS_LOOKUP_SPAN*2}
Initial shell of generalize sprite size support; just for marking the dirty tiles
2021-11-11 23:06:38 +00:00
rts
:mark1x2
Another checkpoint; converging on the working implementation
2022-05-31 13:43:26 +00:00
ldx _Sprites+VBUFF_ARRAY_ADDR,y
lda _Sprites+TS_VBUFF_BASE,y
sta: {0*ROW}+{0*COL},x
adc #VBUFF_TILE_COL_BYTES
sta: {0*ROW}+{1*COL},x
Checkpoint
2022-05-27 00:36:40 +00:00
ldx _Sprites+TS_LOOKUP_INDEX,y
Another checkpoint; converging on the working implementation
2022-05-31 13:43:26 +00:00
TSSetSprite 0*{TS_LOOKUP_SPAN*2}+0
TSSetSprite 0*{TS_LOOKUP_SPAN*2}+2
Initial shell of generalize sprite size support; just for marking the dirty tiles
2021-11-11 23:06:38 +00:00
rts
:mark1x3
Another checkpoint; converging on the working implementation
2022-05-31 13:43:26 +00:00
ldx _Sprites+VBUFF_ARRAY_ADDR,y
lda _Sprites+TS_VBUFF_BASE,y
sta: {0*ROW}+{0*COL},x
adc #VBUFF_TILE_COL_BYTES
sta: {0*ROW}+{1*COL},x
adc #VBUFF_TILE_COL_BYTES
sta: {0*ROW}+{2*COL},x
Checkpoint
2022-05-27 00:36:40 +00:00
ldx _Sprites+TS_LOOKUP_INDEX,y
Another checkpoint; converging on the working implementation
2022-05-31 13:43:26 +00:00
TSSetSprite 0*{TS_LOOKUP_SPAN*2}+0
TSSetSprite 0*{TS_LOOKUP_SPAN*2}+2
TSSetSprite 0*{TS_LOOKUP_SPAN*2}+4
Initial shell of generalize sprite size support; just for marking the dirty tiles
2021-11-11 23:06:38 +00:00
rts
Fix sprite rendering with overlapping sprites. Must erase all sprites first, then re-render
2021-11-21 03:58:09 +00:00
:mark2x1
Another checkpoint; converging on the working implementation
2022-05-31 13:43:26 +00:00
ldx _Sprites+VBUFF_ARRAY_ADDR,y
lda _Sprites+TS_VBUFF_BASE,y
sta: {0*ROW}+{0*COL},x
adc #VBUFF_TILE_ROW_BYTES
sta: {1*ROW}+{0*COL},x
Checkpoint
2022-05-27 00:36:40 +00:00
ldx _Sprites+TS_LOOKUP_INDEX,y
Another checkpoint; converging on the working implementation
2022-05-31 13:43:26 +00:00
TSSetSprite 0*{TS_LOOKUP_SPAN*2}+0
TSSetSprite 1*{TS_LOOKUP_SPAN*2}+0
Initial shell of generalize sprite size support; just for marking the dirty tiles
2021-11-11 23:06:38 +00:00
rts
:mark2x2
Another checkpoint; converging on the working implementation
2022-05-31 13:43:26 +00:00
ldx _Sprites+VBUFF_ARRAY_ADDR,y
lda _Sprites+TS_VBUFF_BASE,y
sta: {0*ROW}+{0*COL},x
adc #VBUFF_TILE_COL_BYTES
sta: {0*ROW}+{1*COL},x
adc #VBUFF_TILE_ROW_BYTES-VBUFF_TILE_COL_BYTES
sta: {1*ROW}+{0*COL},x
adc #VBUFF_TILE_COL_BYTES
sta: {1*ROW}+{1*COL},x
Checkpoint
2022-05-27 00:36:40 +00:00
ldx _Sprites+TS_LOOKUP_INDEX,y
Continuing to tweak and debug
2022-05-31 21:31:44 +00:00
TSSetSprite 0*{TS_LOOKUP_SPAN*2}+0
TSSetSprite 0*{TS_LOOKUP_SPAN*2}+2
TSSetSprite 1*{TS_LOOKUP_SPAN*2}+0
TSSetSprite 1*{TS_LOOKUP_SPAN*2}+2
Initial shell of generalize sprite size support; just for marking the dirty tiles
2021-11-11 23:06:38 +00:00
rts
:mark2x3
Another checkpoint; converging on the working implementation
2022-05-31 13:43:26 +00:00
ldx _Sprites+VBUFF_ARRAY_ADDR,y
lda _Sprites+TS_VBUFF_BASE,y
sta: {0*ROW}+{0*COL},x
adc #VBUFF_TILE_COL_BYTES
sta: {0*ROW}+{1*COL},x
adc #VBUFF_TILE_COL_BYTES
sta: {0*ROW}+{2*COL},x
adc #VBUFF_TILE_ROW_BYTES-{2*VBUFF_TILE_COL_BYTES}
sta: {1*ROW}+{0*COL},x
adc #VBUFF_TILE_COL_BYTES
sta: {1*ROW}+{1*COL},x
adc #VBUFF_TILE_COL_BYTES
sta: {1*ROW}+{2*COL},x
Checkpoint
2022-05-27 00:36:40 +00:00
ldx _Sprites+TS_LOOKUP_INDEX,y
Continuing to tweak and debug
2022-05-31 21:31:44 +00:00
TSSetSprite 0*{TS_LOOKUP_SPAN*2}+0
TSSetSprite 0*{TS_LOOKUP_SPAN*2}+2
TSSetSprite 0*{TS_LOOKUP_SPAN*2}+4
TSSetSprite 1*{TS_LOOKUP_SPAN*2}+0
TSSetSprite 1*{TS_LOOKUP_SPAN*2}+2
TSSetSprite 1*{TS_LOOKUP_SPAN*2}+4
Initial shell of generalize sprite size support; just for marking the dirty tiles
2021-11-11 23:06:38 +00:00
rts
:mark3x1
Another checkpoint; converging on the working implementation
2022-05-31 13:43:26 +00:00
ldx _Sprites+VBUFF_ARRAY_ADDR,y
lda _Sprites+TS_VBUFF_BASE,y
sta: {0*ROW}+{0*COL},x
adc #VBUFF_TILE_ROW_BYTES
sta: {1*ROW}+{0*COL},x
adc #VBUFF_TILE_ROW_BYTES
sta: {2*ROW}+{0*COL},x
Checkpoint
2022-05-27 00:36:40 +00:00
ldx _Sprites+TS_LOOKUP_INDEX,y
Continuing to tweak and debug
2022-05-31 21:31:44 +00:00
TSSetSprite 0*{TS_LOOKUP_SPAN*2}+0
TSSetSprite 1*{TS_LOOKUP_SPAN*2}+0
TSSetSprite 2*{TS_LOOKUP_SPAN*2}+0
Initial shell of generalize sprite size support; just for marking the dirty tiles
2021-11-11 23:06:38 +00:00
rts
:mark3x2
Another checkpoint; converging on the working implementation
2022-05-31 13:43:26 +00:00
ldx _Sprites+VBUFF_ARRAY_ADDR,y
lda _Sprites+TS_VBUFF_BASE,y
sta: {0*ROW}+{0*COL},x
adc #VBUFF_TILE_COL_BYTES
sta: {0*ROW}+{1*COL},x
adc #VBUFF_TILE_ROW_BYTES-VBUFF_TILE_COL_BYTES
sta: {1*ROW}+{0*COL},x
adc #VBUFF_TILE_COL_BYTES
sta: {1*ROW}+{1*COL},x
adc #VBUFF_TILE_ROW_BYTES-VBUFF_TILE_COL_BYTES
sta: {2*ROW}+{0*COL},x
adc #VBUFF_TILE_COL_BYTES
sta: {2*ROW}+{1*COL},x
Checkpoint
2022-05-27 00:36:40 +00:00
ldx _Sprites+TS_LOOKUP_INDEX,y
Continuing to tweak and debug
2022-05-31 21:31:44 +00:00
TSSetSprite 0*{TS_LOOKUP_SPAN*2}+0
TSSetSprite 0*{TS_LOOKUP_SPAN*2}+2
TSSetSprite 1*{TS_LOOKUP_SPAN*2}+0
TSSetSprite 1*{TS_LOOKUP_SPAN*2}+2
TSSetSprite 2*{TS_LOOKUP_SPAN*2}+0
TSSetSprite 2*{TS_LOOKUP_SPAN*2}+2
Initial shell of generalize sprite size support; just for marking the dirty tiles
2021-11-11 23:06:38 +00:00
rts
:mark3x3
Another checkpoint; converging on the working implementation
2022-05-31 13:43:26 +00:00
ldx _Sprites+VBUFF_ARRAY_ADDR,y
lda _Sprites+TS_VBUFF_BASE,y
sta: {0*ROW}+{0*COL},x
adc #VBUFF_TILE_COL_BYTES
sta: {0*ROW}+{1*COL},x
adc #VBUFF_TILE_COL_BYTES
sta: {0*ROW}+{2*COL},x
adc #VBUFF_TILE_ROW_BYTES-{2*VBUFF_TILE_COL_BYTES}
sta: {1*ROW}+{0*COL},x
adc #VBUFF_TILE_COL_BYTES
sta: {1*ROW}+{1*COL},x
adc #VBUFF_TILE_COL_BYTES
sta: {1*ROW}+{2*COL},x
adc #VBUFF_TILE_ROW_BYTES-{2*VBUFF_TILE_COL_BYTES}
sta: {2*ROW}+{0*COL},x
adc #VBUFF_TILE_COL_BYTES
sta: {2*ROW}+{1*COL},x
adc #VBUFF_TILE_COL_BYTES
sta: {2*ROW}+{2*COL},x
Checkpoint
2022-05-27 00:36:40 +00:00
ldx _Sprites+TS_LOOKUP_INDEX,y
Continuing to tweak and debug
2022-05-31 21:31:44 +00:00
TSSetSprite 0*{TS_LOOKUP_SPAN*2}+0
TSSetSprite 0*{TS_LOOKUP_SPAN*2}+2
TSSetSprite 0*{TS_LOOKUP_SPAN*2}+4
TSSetSprite 1*{TS_LOOKUP_SPAN*2}+0
TSSetSprite 1*{TS_LOOKUP_SPAN*2}+2
TSSetSprite 1*{TS_LOOKUP_SPAN*2}+4
TSSetSprite 2*{TS_LOOKUP_SPAN*2}+0
TSSetSprite 2*{TS_LOOKUP_SPAN*2}+2
TSSetSprite 2*{TS_LOOKUP_SPAN*2}+4
Initial shell of generalize sprite size support; just for marking the dirty tiles
2021-11-11 23:06:38 +00:00
rts