iigs-game-engine/demos/smb/Main.s
Lucas Scharenbroich 459bc645be Swizzle support
2023-06-02 00:37:14 -05:00

1524 lines
40 KiB
ArmAsm

REL
use Locator.Macs
use Load.Macs
use Mem.Macs
use Misc.Macs
use Util.Macs
use EDS.GSOS.Macs
use GTE.Macs
use Externals.s
; Keycodes
LEFT_ARROW equ $08
RIGHT_ARROW equ $15
UP_ARROW equ $0B
DOWN_ARROW equ $0A
; Nametable queue
NT_QUEUE_LEN equ $1000
NT_QUEUE_SIZE equ {2*NT_QUEUE_LEN}
NT_QUEUE_MOD equ {NT_QUEUE_SIZE-1}
mx %00
; Direct page space
MyUserId equ 0
ROMStk equ 2
ROMZeroPg equ 4
LastScroll equ 6
TileX equ 10 ; GTE tile store coordinates that correspond to the PPUSCROLL edge
TileY equ 12
ROMScreenEdge equ 14
ROMScrollEdge equ 16
ROMScrollDelta equ 18
OldROMScrollEdge equ 20
CurrScrollEdge equ 22
CurrNTQueueEnd equ 40
BGToggle equ 44
LastEnable equ 46
Tmp0 equ 240
Tmp1 equ 242
Tmp2 equ 244
Tmp3 equ 246
Tmp4 equ 248
Tmp5 equ 250
Tmp6 equ 252
FTblPtr equ 224
FTblTmp equ 228
phk
plb
sta MyUserId ; GS/OS passes the memory manager user ID for the application into the program
_MTStartUp ; GTE requires the miscellaneous toolset to be running
stz LastScroll
stz TileX
stz TileY
stz ROMScreenEdge
stz ROMScrollEdge
stz ROMScrollDelta
stz OldROMScrollEdge
lda #1
sta BGToggle
lda #$0008
sta LastEnable
; The next two direct pages will be used by GTE, so get another 2 pages beyond that for the ROM. We get
; 4K of DP/Stack space by default, so there is plenty to share
tdc
sta DPSave
clc
adc #$300
sta ROMZeroPg
clc
adc #$1FF ; Stack starts at the top of the page
sta ROMStk
; brl :debug
lda #ENGINE_MODE_USER_TOOL ; Engine in Fast Mode as a User Tool
jsr GTEStartUp ; Load and install the GTE User Tool
; Install a VBL callback task that we will use to invoke the NMI routine in the ROM
pea vblCallback
pea #^nmiTask
pea #nmiTask
_GTESetAddress
; Install a custom sprite renderer that will read directly off of the OAM table
pea extSpriteRenderer
pea #^drawOAMSprites
pea #drawOAMSprites
_GTESetAddress
; Install a custom callback to update the tile store as the screen scrolls
pea extBG0TileUpdate
pea #^UpdateFromPPU
pea #UpdateFromPPU
_GTESetAddress
; Install a custom tile blitter to merge PPU attributes with the extracted tile data
pea userTileCallback
pea #^NESTileBlitter
pea #NESTileBlitter
_GTESetAddress
; Get the address of a low-level routine that can be used to draw a tile directly to the graphics screen
pea rawDrawTile
_GTEGetAddress
lda 1,s
sta drawTilePatch+1
lda 2,s
sta drawTilePatch+2
pla
plx
; Initialize the graphics screen playfield (256x160). The NES is 240 lines high, so 160
; is a reasonable compromise.
pea #128
pea #200
; pea #80
; pea #144
_GTESetScreenMode
ldx #AreaPalette
lda #TmpPalette
jsr NESColorToIIgs
pea $0000
pea #^TmpPalette
pea #TmpPalette
_GTESetPalette
; Convert the CHR ROM from the cart into GTE tiles
:debug
ldx #0
ldy #0
:tloop
phx
phy
lda #TileBuff
jsr ConvertROMTile2
lda 1,s
pha ; start
inc
pha ; finish
pea #^TileBuff ; pointer
pea #TileBuff
_GTELoadTileSet
ply
iny
pla
clc
adc #16 ; NES tiles are 16 bytes
tax
cpx #512*16
bcc :tloop
; Set an internal flag to tell the VBL interrupt handler that it is
; ok to start invoking the game logic. The ROM code has to be run
; at 60 Hz because it controls the audio. Bad audio is way worse
; than a choppy refresh rate.
;
; Call the boot code in the ROM
ldx #SMBStart
jsr romxfer
; Apply hacks
;WorldNumber = $075f
;AreaNumber = $076
EvtLoop
:spin lda nmiCount
beq :spin
stz nmiCount
; lda #4
; stal ROMBase+$760
; The GTE playfield is 41 tiles wide, but the NES is 32 tiles wide. Fortunately, the game
; keeps track of the global coordinates of each level at
;
; ScreenEdge_PageLoc = $071a
; ScreenEdge_X_Pos = $071c
;
; So we can keep our scrolling in sync with the game. In order to efficiently update the
; GTE tile store, we handle this in two stages
;
; 1. When new column(s) are exposed, set the tiles directly from the PPU nametable memory
; 2. When the PPU nametable memory is updated in an area that is already on-screen, set the tile
lda singleStepMode
bne :skip_render
jsr RenderFrame
:skip_render
lda lastKey
bit #PAD_KEY_DOWN
beq EvtLoop
and #$007F
; Put the game in single-step mode
cmp #'s'
bne :not_s
lda #1 ; Stop the VBL interrupt from running the game logic
sta singleStepMode
jsr triggerNMI
jsr RenderFrame
brl EvtLoop
:not_s
cmp #'b' ; Togget background flag
bne :not_b
lda BGToggle
eor #$0001
sta BGToggle
pha
_GTEEnableBackground
:not_b
cmp #'g' ; Re-enable VBL-drive game logic
bne :not_g
stz singleStepMode
:not_g
cmp #'r' ; Refresh
bne :not_1
jsr CopyStatus
lda ROMScreenEdge ; global tile index
and #$003F ; mod the mirrored nametable size
ldx #33
ldy #0
jsr CopyNametable
brl EvtLoop
:not_1
cmp #'1'
bne :not_v
lda ROMScreenEdge
clc
adc #33
and #$003F
ldx #1
ldy #33
jsr CopyNametable
brl EvtLoop
:not_v
cmp #'q'
beq Exit
brl EvtLoop
Exit
_GTEShutDown
Quit
_QuitGS qtRec
qtRec adrl $0000
da $00
Greyscale dw $0000,$5555,$AAAA,$FFFF
dw $0000,$5555,$AAAA,$FFFF
dw $0000,$5555,$AAAA,$FFFF
dw $0000,$5555,$AAAA,$FFFF
TmpPalette ds 32
lastKey dw 0
singleStepMode dw 0
nmiCount dw 0
DPSave dw 0
; Convert NES palette entries to IIgs
; X = NES palette (16 color indices)
; A = 32 byte array to write results
NESColorToIIgs
sta Tmp0
stz Tmp1
:loop lda: 0,x
asl
tay
lda nesPalette,y
ldy Tmp1
sta (Tmp0),y
inx
inx
iny
iny
sty Tmp1
cpy #32
bcc :loop
rts
; Helper to perform the essential functions of rendering a frame
RenderFrame
; Get the current global coordinates
sei
lda nt_queue_end
sta CurrNTQueueEnd
lda ROMScrollEdge ; This is set in the VBL IRQ
sta CurrScrollEdge ; Freeze it, then we can let the IRQs continue
cli
lsr
lsr
lsr
sta ROMScreenEdge
; Calculate how many blocks have been scrolled into view
lda CurrScrollEdge
sec
sbc OldROMScrollEdge
sta Tmp1 ; This is the raw number of pixels moved
lda OldROMScrollEdge ; This is the number of partial pixels the old scroll position occupied
and #7
sta Tmp0
lda #7
sec
sbc Tmp0 ; This account for situations where going from 8 -> 9 reveals a new column
clc
adc Tmp1
lsr
lsr
lsr
sta ROMScrollDelta ; This many columns have been revealed
lda CurrScrollEdge
sta OldROMScrollEdge ; Stash a copy for the next round through
lsr
pha
pea $0000
_GTESetBG0Origin
lda ppumask
and #$0008 ; Isolate background enable/disable bit
cmp LastEnable
beq :bghop
sta LastEnable
pha
_GTEEnableBackground
:bghop
pea $FFFF ; NES mode
_GTERender
rts
; Take a PPU address and convert it to a tile store coordinate
;
; Inputs
; A = PPU address
; X = Global Address in GTE bytes
; Outputs
; X = relative tile store column
; Y = relative tile store row
PPUAddrToTileStore
:PPUAddr equ Tmp0
:PPUTopLeft equ Tmp1
sta :PPUAddr
; Based on the global coordiate, figure out whhat the left column in the PPU RAM is
txa
lsr ; Convert from bytes to tiles
lsr
and #$003F ; Logically there are 64 tiles in the mirrored PPU RAM
sta :PPUTopLeft
; Now we have the PPU address of the column that corresponds to the left edge of the GTE
; playfield. Now, calculate the relative coordinates of the passed PPU address
; The y-coordinate is easy. Since the top-left address is always on the top row (row = 0),
; we just have to extract the row that the PPU address occupies.
lda :PPUAddr
and #$03E0 ; Take the middle 5 bits (ignore nametable)
lsr
lsr
lsr
lsr
lsr
tay ; Save the y-index here
; The GTE playfield is positioned with the third PPU row as it's origin and is 25 tiles high.
; If the PPU tile is in rows 0, 1, 27, 28 or 29 then we can ignore it
cpy #2
bcc :outOfRange
cpy #27
bcs :outOfRange
; Adjust the relative position down by 2
dey
dey
; The horizontal coordinate is a bit trickier. We need to add 32 to the horizontal
; coordinate in it's in the second nametable
lda :PPUAddr
and #$041F ; Project it to the top row
bit #$0400
beq *+5
ora #$0020 ; Add 32
and #$003F ; Clamp to range of 0 - 63
; If we're in the top two row, they don't scroll, so skip the displacement
cpy #2
bcc :noshift
; Now calculate the difference between the PPUTopLeft index and this value
cmp :PPUTopLeft
bcs :ahead ; If the provided address is > than the origin, just calc the difference
adc #64 ; Else distance is (a - 0) + (64 - b) = a + 64 - b
sec
:ahead sbc :PPUTopLeft
:noshift
; If this value is larger than the payfield + 1, then we have the carry set or clear
tax
cmp #33
rts
:outOfRange
sec
rts
; If there is some other reason to draw the full screen, this will empty the queue
ClearNTQueue
lda CurrNTQueueEnd
sta nt_queue_front
rts
; Scan through the queue of tiles that need to be updated before applying the scroll change
DrainNTQueue
:GTELeftEdge equ Tmp3
:PPUAddr equ Tmp4
:Count equ Tmp5
stz :Count
; Prep item -- get the logical block of the left edge of the scroll window
lda CurrScrollEdge ; Global position that the GTE playfield was set to
lsr
sta :GTELeftEdge
lda nt_queue_front
cmp CurrNTQueueEnd
beq :out
:loop
tax
phx ; Save the x register
lda nt_queue,x ; get the PPU address that was stored
sta :PPUAddr ; save for later if we draw this tile
lda :PPUAddr
ldx :GTELeftEdge ; get the global coordinate
jsr PPUAddrToTileStore ; convert the PPU address to relative tile store coordinates
bcc :set_tile ; if it's onscreen, draw it
:skip
pla ; Pop the saved x-register into the accumulator
inc
inc
and #NT_QUEUE_MOD
cmp CurrNTQueueEnd
bne :loop
:out
sta nt_queue_front
rts
:set_tile
; Now we have the relative position from the left edge of the tile. Add the origin
; tile to it (uless we're in rows 0 or 1)
txa
cpy #2
bcc :toprow
clc
adc TileX
cmp #41
bcc *+5
sbc #41
:toprow
pha ; Tile Store horizontal tile coordinate
phy ; No translation needed for y
ldx :PPUAddr
lda PPU_MEM,x
and #$00FF
ora #$0100+TILE_USER_BIT
pha
jsr GetPaletteSelect
ora 1,s ; Merge bits 9 and 10 into the Tile ID that's on the stack
sta 1,s
_GTESetTile
inc :Count
brl :skip
; Do the calculation to get the palette select bits from the attribute byte that corresponds to the
; PPU address in the x-registers
GetPaletteSelect
; Get the palette select bits. We need to calculate both the address of the attribute value and
; which bits to isolate from the byte and then merge into the TileId. The most straighforward way
; is to identify the quadrant right away and have alternate code paths
txa
and #$2C00
ora #$03C0
sta Tmp6 ; Base attribute table address
; Not calculate the byte within the attribute table
txa
and #$001F ; 32 byte rows, divide by 4
lsr
lsr
ora Tmp6
sta Tmp6
txa
and #$0380 ; Isolate the top 3 bits
lsr
lsr
lsr
lsr
ora Tmp6
tay
lda PPU_MEM,y ; This is the attribute byte
and #$00FF
pha ; Which we save for a minute
; Now figure out the quadrant that this address is in for the attribute byte value
txa
bit #%01000010
beq :top_left
bit #%01000000
beq :top_right
bit #%00000010
beq :bot_left
:bot_right
pla
and #$00C0
asl
asl
asl
bra :set_palette
:bot_left
pla
and #$0030
xba
lsr
lsr
lsr
bra :set_palette
:top_right
pla
and #$000C
xba
lsr
bra :set_palette
:top_left
pla
and #$0003
xba
asl
:set_palette
rts
; Copy the necessary columns into the TileStore when setting a new scroll position
UpdateFromPPU
:StartXMod164 equ 36
phb
phd
; Snag the StartXmod164 value from the GTE direct page so we can calulate the tile origin
; ourselves
ldx :StartXMod164
phk
plb
lda DPSave
tcd
txa
lsr
lsr
sta TileX ; Tile column of playfield origin
; Debug the PPU writes
* ldy #0
* ldx #0
* lda #0
* :log_loop
* phy
* pha
* cpy ppu_write_log_len
* bcc :write_val
* pha
* tax
* ldy #$FFFF
* jsr ClearWord
* pla
* clc
* adc #160-16
* tax
* jsr ClearWord
* bra :next
* :write_val
* pha
* phy
* tax
* lda ppu_write_log,y
* ldy #$FFFF
* jsr DrawWord
* ply
* pla
* clc
* adc #160-16
* tax
* lda ppu_write_log+50,y
* ldy #$FFFF
* jsr DrawWord
* :next pla
* ply
* iny
* iny
* clc
* adc #8*160
* cpy #50
* bcc :log_loop
* stz ppu_write_log_len
; Show the queue depth
; lda CurrNTQueueEnd
; sec
; sbc nt_queue_front
; bpl *+5
; adc #NT_QUEUE_SIZE
; lsr ; Number of items in the queue
; ldx #0
; ldy #$FFFF
; jsr DrawWord
; Check the scroll delta, if it's negative or just large enough, do a whole copy of the current PPU
; memory into the TileStore
lda ROMScrollDelta
beq :queue
cmp #32
bcc :partial
jsr ClearNTQueue ; kill any pending updates
lda ROMScreenEdge ; global tile index
and #$003F ; mod the mirrored nametable size
ldx #33 ; do the full width
ldy #0
jsr CopyNametable
bra :done
; Calculate the difference between the old and new
:partial
jsr DrainNTQueue
lda #33
sec
sbc ROMScrollDelta
tay
ldx ROMScrollDelta
inx
inx
lda ROMScreenEdge
clc
adc #33
sec
sbc ROMScrollDelta
and #$003F
jsr CopyNametable
:done
pld
plb
rtl
; Just drain the queue of any on-screen changes and then exit
:queue
jsr DrainNTQueue
pld
plb
rtl
CopyStatus
; Copy the first two rows from $2400 because they don't scroll
ldy #0
:yloop
ldx #0
tya
clc
adc #2
asl
asl
asl
asl
asl
sta Tmp2
stz Tmp3
:xloop
phx ; Save X and Y
phy
phx ; x = GTE tile index = PPU tile index
phy ; No vertical scroll, so screen_y = tile_y
ldx Tmp2 ; Nametable address
lda PPU_MEM+$2000,x
and #$00FF
ora #$0100+TILE_USER_BIT
pha
jsr GetPaletteSelect
ora 1,s ; Merge bits 9 and 10 into the Tile ID that's on the stack
sta 1,s
; Advance to the next tile (no wrapping needed)
inx
stx Tmp2
_GTESetTile
ply
plx
inx
cpx #33
bcc :xloop
iny
cpy #2
bcc :yloop
rts
; Copy the tile and attribute bytes into the GTE buffer
;
; A = logical column in mirrored PPU memory (0 - 63)
; X = number of columns to copy
; Y = number of GTE tiles to offset
CopyNametable
; cmp #5
; bcc *+4
; brk $88
sta Tmp2
bit #$0020 ; Is it >32?
beq *+5
ora #$0400 ; Move to the next nametable
and #$041F ; Mask to the top of a valid column
clc ; Add in the offset since we only copy rows 2 - 27
adc #4*32
sta Tmp0 ; base address offset into nametable memory
stx Tmp4
tya
clc
adc TileX
cmp #41
bcc *+5
sbc #41
sta Tmp5
; NES RAM $6D = page, $86 = player_x_in_page can be used to get a global position in the level, then subtracting the
; player's x coordinate will give us the global coordinate of the left edge of the screen and allow us to map between
; the GTE tile buffer and the PPU nametables
; Skip the first two rows -- call CopyStatus to get those
ldy #2
:yloop
ldx #0
lda Tmp0 ; Get the base address for this row
sta Tmp2 ; coarse x-scroll
lda Tmp5
sta Tmp3 ; Keep a separate variable for the GTE tile position
:xloop
phx ; Save X and Y
phy
pei Tmp3 ; Wrap-around tile column
phy ; No vertical scroll, so screen_y = tile_y
ldx Tmp2 ; Nametable address
lda PPU_MEM+$2000,x
and #$00FF
ora #$0100+TILE_USER_BIT ; USe top 256 tiles and set as a user-defined tile
pha
jsr GetPaletteSelect
ora 1,s ; Merge bits 9 and 10 into the Tile ID that's on the stack
sta 1,s
; Advance to the next tile (handle nametable wrapping)
lda #$001F
and Tmp2
cmp #$001F
bne :inc_x
txa
and #$FFE0
eor #$0400
sta Tmp2
bra :x_hop
:inc_x inx
stx Tmp2
:x_hop
_GTESetTile
ply
plx
lda Tmp3
inc
cmp #41
bcc *+5
lda #0
sta Tmp3
inx
cpx Tmp4
bcc :xloop
lda Tmp0
clc
adc #32
sta Tmp0
iny
cpy #25
bcc :yloop
rts
; Trigger an NMI in the ROM
triggerNMI
ldal ppuctrl ; If the ROM has not enabled VBL NMI, also skip
bit #$80
beq :skip
ldal ppustatus ; Set the bit that the VBL has started
ora #$80
stal ppustatus
ldx #NonMaskableInterrupt
jsr romxfer
; Immediately after the NMI returns, freeze some of the global state variables so we can sync up with this frame when
; we render the next frame. Since we're in an interrupt handler here, sno change of the variables changing under
; our nose
sep #$20
ldal ROMBase+$071a
xba
ldal ROMBase+$071c
rep #$20
sta ROMScrollEdge
:skip rts
; Expose joypad bits from GTE to the ROM: A-B-Select-Start-Up-Down-Left-Right
native_joy ENT
db 0,0
; X = address in the rom file
; A = address to write
;
; This keeps the tile in 2-bit mode in a format that makes it easy to look up pixel data
; based on a dynamic palette selection
;
; Tiles are stored in a pre-shifted, 16-bit format (2 bits per pixel): 0000000w wxxyyzz0
; When rendered, the 2-bit palette selection is passed in bits 9 and 10 and ORed with
; the palette data to create a single word of 00000ppw wxxyyzz0. This value is used
; to index directly into a 2048-byte swizzel table that will load the appropriate
; pixel data for the word. There are 2 swizzle tables, one for tiles and one for sprites
; that take care of mapping the 25 possible on-screen colors to a 16-color palette.
ConvertROMTile2
:DPtr equ Tmp1
:MPtr equ Tmp2
jsr ROMTileToLookup
; Now we have 32 bytes (4 x 8) with each byte being a 4-bit value that holds two pairs of bits
; from the PPU pattern table. We use these 4-bit values as lookup indices into tables
; that decode the values differently depending on the use case.
sta :DPtr
clc
adc #32 ; Move to the mask
sta :MPtr
lda #0 ; Zero out high byte
sep #$30 ; 8-bit mode
ldy #0
:loop
lda (:DPtr),y ; Load the index for the initial high nibble
tax
lda MLUT4,x ; Look up the mask value for this byte. This table decodes the 4 bits into an 8-bit mask
sta (:MPtr),y
lda DLUT2,x ; Look up the two, 2-bit pixel values for this quad of bits. This remains a 4-bit value
asl
asl
asl
asl
sta Tmp3
iny
lda (:DPtr),y
tax
lda DLUT2,x ; Look up the two, 2-bit pixel values for next quad of bits
ora Tmp3 ; Move it int othe top nibble since it will decode to the top-byte on the SHR screen
dey
sta (:DPtr),y ; Put in low byte
iny
lda #0
sta (:DPtr),y ; Zero high byte
lda MLUT4,x
sta (:MPtr),y
iny
cpy #32
bcc :loop
; Reverse and shift the data
rep #$30
ldy #8
ldx :DPtr
:rloop
lda: 0,x ; Load the word: xx00
jsr reverse2 ; Reverse the bottom byte in chunks of 2 bits
asl ; Shift by 1 for indexing
sta: 66,x
asl: 0,x ; Shift the original word, too
lda: 2,x
jsr reverse2
asl
sta: 64,x
asl: 2,x
inx
inx
inx
inx
dey
bne :rloop
rts
; X = address in the rom file
; A = address to write
ConvertROMTile
:DPtr equ Tmp1
:MPtr equ Tmp2
jsr ROMTileToLookup
sta :DPtr
clc
adc #32 ; Move to the mask
sta :MPtr
sep #$30 ; 8-bit mode
ldy #0
:loop
lda (:DPtr),y ; Load the index for this tile byte
tax
lda DLUT4,x ; Look up the two, 4-bit pixel values for this quad of bits
sta (:DPtr),y
lda MLUT4,x ; Look up the mask value for this byte
sta (:MPtr),y
iny
cpy #32
bcc :loop
; Switch back to 16-bit mode and flip the tile data before returning
rep #$20
ldy #16
ldx :DPtr
:rloop
lda: 0,x
jsr reverse4
sta: 66,x
lda: 2,x
jsr reverse4
sta: 64,x
inx
inx
inx
inx
dey
bne :rloop
rts
; Build a table of index values for the ROM tile data. The different routines
; can mix and match the lookup table information as they see fit
;
; X = address in the rom file
; A = address to write
;
; For each byte of pattern table memory, we create two bytes in the DPtr with
; a lookup value for the pixels corresponding to bits in that location
;
; Example:
; Tile 0: $03,$0F,$1F,$1F,$1C,$24,$26,$66, $00,$00,$00,$00,$1F,$3F,$3F,$7F
;
; 0,1 2,3 4,5 6,7
;
; $03 | 00000011 | 00000000 | $00 -> 0000 0000 0000 0011 -> 00 00 05 00
; $0F | 00001111 | 00000000 | $00 -> 0000 0000 0011 0011 -> 00 00 55 00
; $1F | 00011111 | 00000000 | $00 -> 0000 0001 0011 0011 -> 01 00 55 00
; $1F | 00011111 | 00000000 | $00 -> 0000 0001 0011 0011 -> 01 00 55 00
; $1C | 00011100 | 00011111 | $1F -> 0000 0101 1111 1100 -> 03 00 FA 00
; $24 | 00100100 | 00111111 | $3F -> 0000 1110 1101 1100 -> 0E 00 BA 00
; $26 | 00100110 | 00111111 | $3F -> 0000 1110 1101 1110 -> 0E 00 BE 00
; $66 | 01100110 | 01111111 | $7F -> 0101 1110 1101 1110 -> 3E 00 BE 00
;
;
; e.g. Plane 0 = 0101 0001 (LSB)
; Plane 1 = 1001 0001 (MSB)
;
; For speed, use a table and convert one pair at a time
;
; Pair 1 = 1001 -> 1001
; Pair 2 = 0101 -> 0011
; Pair 3 = 0000 -> 0000
; Pair 4 = 0101 -> 0011
;
; Lookup[0] = 10 01 00 11
; Lookup[1] = 00 00 00 11
;
; Tile Data = 63 00 03 00
; Pixel Data = 12 03 00 03
mx %00
ROMTileToLookup
:DPtr equ Tmp1
pha
phx
sta :DPtr
lda #0 ; Clear A and B
sep #$20 ; 8-bit mode
ldy #0
:loop
; Top two bits from each byte defines the two left-most pixels
lda CHR_ROM,x ; Load the low bits
and #$C0
lsr
lsr
sta Tmp0
lda CHR_ROM+8,x ; Load the high bits
and #$C0
ora Tmp0
lsr
lsr
lsr
lsr
sta (:DPtr),y ; First byte
iny
; Repeat for bits 4 & 5
lda CHR_ROM,x
and #$30
lsr
lsr
sta Tmp0
lda CHR_ROM+8,x
and #$30
ora Tmp0
lsr
lsr
sta (:DPtr),y
iny
; Repeat for bits 2 & 3
lda CHR_ROM,x
and #$0C
lsr
lsr
sta Tmp0
lda CHR_ROM+8,x
and #$0C
ora Tmp0 ; Combine the two and create a lookup value
sta (:DPtr),y
iny
; Repeat for bits 0 & 1
lda CHR_ROM,x ; Load the high bits
and #$03
sta Tmp0
lda CHR_ROM+8,x
and #$03
asl
asl
ora Tmp0 ; Combine the two and create a lookup value
sta (:DPtr),y
iny
inx
cpy #32
bcc :loop
rep #$20
plx
pla
rts
; Reverse the 2-bit fields in a byte
mx %00
reverse2
php
sta Tmp0
stz Tmp1
sep #$20
and #$C0
lsr
lsr
lsr
lsr
lsr
lsr
tsb Tmp1
lda Tmp0
and #$30
lsr
lsr
tsb Tmp1
lda Tmp0
and #$0C
asl
asl
tsb Tmp1
lda Tmp0
and #$03
asl
asl
asl
asl
asl
asl
ora Tmp1
plp
rts
; Reverse the nibbles in a word
mx %00
reverse4
xba
sta Tmp0
and #$0F0F
asl
asl
asl
asl
sta Tmp1
lda Tmp0
and #$F0F0
lsr
lsr
lsr
lsr
ora Tmp1
rts
; Look up the 2-bit indexes for the data words
DLUT2 db $00,$01,$04,$05 ; CHR_ROM[0] = xy, CHR_ROM[8] = 00 -> 0x0y
db $02,$03,$06,$07 ; CHR_ROM[0] = xy, CHR_ROM[8] = 01 -> 0x1y
db $08,$09,$0C,$0D ; CHR_ROM[0] = xy, CHR_ROM[8] = 10 ->
db $0A,$0B,$0E,$0F ; CHR_ROM[0] = xy, CHR_ROM[8] = 11
; Look up the 4-bit indexes for the data words
DLUT4 db $00,$01,$10,$11 ; CHR_ROM[0] = xx, CHR_ROM[8] = 00
db $02,$03,$12,$13 ; CHR_ROM[0] = xx, CHR_ROM[8] = 01
db $20,$21,$30,$31 ; CHR_ROM[0] = xx, CHR_ROM[8] = 10
db $22,$23,$32,$33 ; CHR_ROM[0] = xx, CHR_ROM[8] = 11
;MLUT dw $FF,$F0,$0F,$00
; dw $F0,$F0,$00,$00
; dw $0F,$00,$0F,$00
; dw $00,$00,$00,$00
; Inverted mask for using eor/and/eor rendering
MLUT4 db $00,$0F,$F0,$FF
db $0F,$0F,$FF,$FF
db $F0,$FF,$F0,$FF
db $FF,$FF,$FF,$FF
; Extracted tiles
TileBuff ds 128
GTEStartUp
pha ; Save engine mode
pea $0000
_LoaderStatus
pla
pea $0000
pea $0000
pea $0000
pea $0000
pea $0000 ; result space
lda MyUserId
pha
pea #^ToolPath
pea #ToolPath
pea $0001 ; do not load into special memory
_InitialLoad
bcc *+4
brk $01
ply
pla ; Address of the loaded tool
plx
ply
ply
pea $8000 ; User toolset
pea $00A0 ; Set the tool set number
phx
pha ; Address of function pointer table
_SetTSPtr
bcc *+4
brk $02
plx ; Pop the Engine Mode value
clc ; Give GTE two pages of direct page memory
tdc
adc #$0100
pha
phx
lda MyUserId ; Pass the userId for memory allocation
pha
_GTEStartUp
bcc *+4
brk $03
rts
ToolPath str '1/Tool160'
* ; Store sprite and tile data as 0000000w wxxyyzz0 to facilitate swizzle loads
* ; sprite high priority (8-bit acc, compiled)
* ldy #PPU_DATA
* lda screen
* andl tilemask,x
* ora (palptr),y ; 512 byte lookup table per palette
* sta screen
* ; sprite low (this is just slow) ....
* lda screen
* beq empty
* ; do 4 bits to figure out a mask and then
* bit #$FF00
* ...
* ...
* ldy #PPU_DATA
* lda (palptr),y
* eor screen
* andl tilemask,x
* and bgmask
* eor screen
* sta screen
* ; tile
* ldy tiledata,x
* lda (palptr),y
* ldy tmp
* sta abs,y
* ; Custom tile renderer that swizzles the tile data based on the PPU attribute tables. This
* ; is more complicate than just combining the palette select bits with the tile index bits
* ; because the NES can have >16 colors on screen at once, we remap the possible colors
* ; onto a smaller set of indices.
* SwizzleTile
* tax
* ]line equ 0
* lup 8
* ldal tiledata+{]line*4},x ; Tile data is 00ww00xx 00yy00zz
* ora metatile ; Pre-calculated metatile mask
* and tilemask+{]line*4},x ; Set any zero indices to actual zero
* sta: $0004+{]line*$1000},y
* ldal tiledata+{]line*4}+2,x
* sta: $0001+{]line*$1000},y
* ]line equ ]line+1
* --^
* plb
* rts
; Transfer control to the ROM. This function is trampoline that is responsible for
; setting up the direct page and stack for the ROM and then passing control into
; the ROM wrapped in a JSL/RTL vector stashed in the ROM space.
;
; X = ROM Address
romxfer phb ; Save the bank and direct page
phd
tsc
sta StkSave+1 ; Save the current stack in the main program
pea #^ExtIn ; Set the bank to the ROM
plb
lda ROMStk ; Set the ROM stack address
tcs
lda ROMZeroPg ; Set the ROM zero page
tcd
jml ExtIn
ExtRtn ENT
tsx ; Copy the stack address returned by the emulator
StkSave lda #$0000
tcs
pld
plb
stx ROMStk ; Keep an updated copy of the stack address
rts
; VBL Interrupt task (called in native 8-bit mode)
mx %11
nmiTask
ldal nmiCount
inc
stal nmiCount
php
rep #$30
phb
phd
phk
plb
lda DPSave
tcd
jsr readInput
ldal singleStepMode
bne :no_nmi
; lda #1
; jsr setborder
jsr triggerNMI
; lda #0
; jsr setborder
:no_nmi
pld
plb
plp
:skip
rtl
mx %00
readInput
pha
_GTEReadControl
pla
stal lastKey ; Cache for other code
; Map the GTE field to the NES controller format: A-B-Select-Start-Up-Down-Left-Right
pha
and #PAD_BUTTON_A+PAD_BUTTON_B ; bits 0x200 and 0x100
lsr
lsr
sta native_joy
sep #$20
lda 1,s
cmp #'n'
bne *+6
lda #$20
bra :nes_merge
cmp #'m'
bne *+6
lda #$10
bra :nes_merge
cmp #UP_ARROW
bne *+6
lda #$08
bra :nes_merge
cmp #DOWN_ARROW
bne *+6
lda #$04
bra :nes_merge
cmp #LEFT_ARROW
bne *+6
lda #$02
bra :nes_merge
cmp #RIGHT_ARROW
bne *+6
lda #$01
bra :nes_merge
lda #0
:nes_merge ora native_joy
sta native_joy
sta native_joy+1
:nes_done
rep #$20
pla
rts
put App.Msg.s
put font.s
put palette.s
put ppu.s
ds \,$00 ; pad to the next page boundary
PPU_MEM
CHR_ROM put chr2.s ; 8K of CHR-ROM at PPU memory $0000 - $2000
PPU_NT ds $2000 ; Nametable memory from $2000 - $3000, $3F00 - $3F14 is palette RAM
PPU_OAM ds 256 ; 256 bytes of separate OAM RAM
; Palettes of NES color indexes
;AreaPalette dw $0F, $00, $29, $1A, $09, $36, $1C, $30, $21, $16, $27, $18, $17, $3C, $1D, $37
AreaPalette dw $22, $00, $29, $1A, $0F, $36, $17, $30, $21, $16, $27, $18, $1A, $00, $00, $37
; Palette remapping
put pal_w11.s