mirror of https://github.com/fadden/fdraw.git
589 lines
17 KiB
ArmAsm
589 lines
17 KiB
ArmAsm
********************************
|
|
* *
|
|
* Fast Apple II Graphics *
|
|
* By Andy McFadden *
|
|
* Version 0.3, Aug 2015 *
|
|
* *
|
|
* Point and line functions *
|
|
* (Included by FDRAW.S) *
|
|
* *
|
|
* Developed with Merlin-16 *
|
|
* *
|
|
********************************
|
|
|
|
|
|
********************************
|
|
*
|
|
* Draw a single point in the current color.
|
|
*
|
|
********************************
|
|
DrawPoint
|
|
]hbasl equ zptr0
|
|
|
|
ldy in_y0
|
|
lda ylooklo,y
|
|
sta ]hbasl
|
|
lda ylookhi,y
|
|
ora g_page
|
|
sta ]hbasl+1
|
|
|
|
ldx in_x0l ;x coord, lo
|
|
lda in_x0h ;>= 256?
|
|
beq :lotabl ;no, use the low table
|
|
ldy div7hi,x
|
|
lda mod7hi,x
|
|
bpl :plotit ;always
|
|
BREAK ;debug
|
|
:lotabl ldy div7lo,x
|
|
lda mod7lo,x
|
|
|
|
* Plot the point. The byte offset (0-39) is in Y,
|
|
* the bit offset (0-6) is in A.
|
|
:plotit
|
|
tax
|
|
lda colorline,y ;start with color pattern
|
|
eor (]hbasl),y ;flip all bits
|
|
and andmask,x ;clear other bits
|
|
eor (]hbasl),y ;restore ours, set theirs
|
|
sta (]hbasl),y
|
|
rts
|
|
|
|
|
|
********************************
|
|
*
|
|
* Draw a line between two points.
|
|
*
|
|
********************************
|
|
DrawLine
|
|
|
|
]hbasl equ zptr0
|
|
]xposl equ zloc0 ;always left edge
|
|
]xposh equ zloc1
|
|
]ypos equ zloc2 ;top or bottom
|
|
]deltaxl equ zloc3
|
|
]deltaxh equ zloc4
|
|
]deltay equ zloc5
|
|
]count equ zloc6
|
|
]counth equ zloc7
|
|
]diff equ zloc8
|
|
]diffh equ zloc9
|
|
]andmask equ zloc10
|
|
]wideflag equ zloc11 ;doesn't really need DP
|
|
|
|
* We use a traditional Bresenham run-length approach.
|
|
* Run-slicing is possible, but the code is larger
|
|
* and the increased cost means it's only valuable
|
|
* for longer lines. An optimal solution would switch
|
|
* approaches based on line length.
|
|
*
|
|
* Start by identifying where x0 or x1 is on the
|
|
* left. To make life simpler we always work from
|
|
* left to right, flipping the coordinates if
|
|
* needed.
|
|
*
|
|
* We also need to figure out if the line is more
|
|
* than 255 pixels long -- which, because of
|
|
* inclusive coordinates, means abs(x0-x1) > 254.
|
|
lda in_x1l ;assume x0 on left
|
|
sec
|
|
sbc in_x0l
|
|
tax
|
|
beq checkvert ;low bytes even, check hi
|
|
lda in_x1h
|
|
sbc in_x0h
|
|
bcs lx0left
|
|
|
|
* x1 is on the left, so the values are negative
|
|
* (hi byte in A, lo byte in X)
|
|
lx0right eor #$ff ;invert hi
|
|
sta ]deltaxh ;store
|
|
txa
|
|
eor #$ff ;invert lo
|
|
sta ]deltaxl
|
|
inc ]deltaxl ;add one for 2s complement
|
|
bne :noinchi ;rolled into high byte?
|
|
inc ]deltaxh ;yes
|
|
:noinchi lda in_x1l ;start with x1
|
|
sta ]xposl
|
|
lda in_x1h
|
|
sta ]xposh
|
|
lda in_y1
|
|
sta ]ypos
|
|
sec
|
|
sbc in_y0 ;compute deltay
|
|
jmp lncommon
|
|
|
|
checkvert
|
|
lda in_x1h ;diff high bytes
|
|
sbc in_x0h ;(carry still set)
|
|
blt lx0right ;width=256, x0 right
|
|
bne lx0left ;width=256, x0 left
|
|
jmp vertline ;all zero, go vert
|
|
|
|
* (branch back from below)
|
|
* This is a purely horizontal line. We farm the job
|
|
* out to the raster fill code for speed. (There's
|
|
* no problem with the line code handling it; its just
|
|
* more efficient to let the raster code do it.)
|
|
phorizontal
|
|
ldy ]ypos
|
|
sty rast_top
|
|
sty rast_bottom
|
|
lda ]xposl
|
|
sta rastx0l,y
|
|
clc
|
|
adc ]deltaxl ;easier to add delta back
|
|
sta rastx1l,y ; in than sort out which
|
|
lda ]xposh ; arg is left vs. right
|
|
sta rastx0h,y
|
|
adc ]deltaxh
|
|
sta rastx1h,y
|
|
jmp FillRaster
|
|
|
|
* x0 is on the left, so the values are positive
|
|
lx0left stx ]deltaxl
|
|
sta ]deltaxh
|
|
lda in_x0l ;start with x0
|
|
sta ]xposl
|
|
lda in_x0h
|
|
sta ]xposh
|
|
lda in_y0 ;and y0
|
|
sta ]ypos
|
|
sec
|
|
sbc in_y1 ;compute deltay
|
|
|
|
* Value of (starty - endy) is in A, flags still set.
|
|
lncommon
|
|
bcs :posy
|
|
eor #$ff ;negative, invert
|
|
adc #$01
|
|
sta ]deltay
|
|
lda #$e8 ;INX
|
|
bne gotdy
|
|
:posy
|
|
_lmb beq phorizontal
|
|
sta ]deltay
|
|
lda #$ca ;DEX
|
|
gotdy sta _hmody
|
|
sta _vmody
|
|
sta _wmody
|
|
|
|
do 0 ;***** for regression test
|
|
ldx #$01
|
|
lda ]deltaxh
|
|
bne :iswide
|
|
lda ]deltaxl
|
|
cmp #$ff ;== 255?
|
|
beq :iswide
|
|
ldx #$00 ;notwide
|
|
:iswide stx $300
|
|
lda ]xposl
|
|
sta $301
|
|
lda ]xposh
|
|
sta $302
|
|
lda ]ypos
|
|
sta $303
|
|
ldx ]deltaxl
|
|
stx $304
|
|
ldx ]deltaxh
|
|
stx $305
|
|
ldx ]deltay
|
|
stx $306
|
|
lda _hmody
|
|
and #$20 ;nonzero means inc,
|
|
sta $307 ; zero means dec
|
|
fin ;*****
|
|
|
|
* At this point we have the initial X position in
|
|
* ]startxl/h, the initial Y position in ]starty,
|
|
* deltax in ]deltaxl, deltay in ]deltay, and we've
|
|
* tweaked the Y-update instructions to either INC or
|
|
* DEC depending on the direction of movement.
|
|
*
|
|
* The next step is to decide whether the line is
|
|
* horizontal-dominant or vertical-dominant, and
|
|
* branch to the appropriate handler.
|
|
*
|
|
* The core loops for horiz and vert take about
|
|
* 80 cycles when moving diagonally, and about
|
|
* 20 fewer when moving in the primary direction.
|
|
* The wide-horiz is a bit slower.
|
|
ldy #$01 ;set "wide" flag to 1
|
|
lda ]deltaxl
|
|
ldx ]deltaxh
|
|
bne horzdom ;width >= 256
|
|
cmp #$ff ;width == 255
|
|
beq horzdom
|
|
dey ;not wide
|
|
cmp ]deltay
|
|
bge horzdom ; for diagonal lines
|
|
jmp vertdom
|
|
|
|
* We could special-case pure-diagonal lines here
|
|
* (just BEQ a couple lines up). It does
|
|
* represent our worst case. I'm not convinced
|
|
* we'll see them often enough to make it worthwhile.
|
|
|
|
|
|
* horizontal-dominant
|
|
horzdom
|
|
sty ]wideflag
|
|
sta ]count ;:count = deltax + 1
|
|
inc ]count
|
|
lsr ;:diff = deltax / 2
|
|
sta ]diff
|
|
|
|
* set Y to the byte offset in the line
|
|
* load the AND mask into ]andmask
|
|
ldx ]xposl
|
|
lda ]xposh ;>= 256?
|
|
beq :lotabl ;no, use the low table
|
|
ldy div7hi,x
|
|
lda mod7hi,x
|
|
bpl :gottab ;always
|
|
* BREAK ;debug
|
|
:lotabl ldy div7lo,x
|
|
lda mod7lo,x
|
|
:gottab
|
|
tax
|
|
lda andmask,x
|
|
sta ]andmask
|
|
|
|
* Set initial value for line address.
|
|
ldx ]ypos
|
|
lda ylooklo,x
|
|
sta ]hbasl
|
|
lda ylookhi,x
|
|
ora g_page
|
|
sta ]hbasl+1
|
|
|
|
lda ]wideflag ;is this a "wide" line?
|
|
beq :notwide ;nope, stay local
|
|
jmp widedom
|
|
|
|
:notwide lda colorline,y ;set initial color mask
|
|
sta _hlcolor+1
|
|
jmp horzloop
|
|
|
|
hrts rts
|
|
|
|
* bottom of loop, essentially
|
|
hnoroll sta ]diff ;3
|
|
hdecc dec ]count ;5 :count--
|
|
beq hrts ;2 :while (count != 0)
|
|
;= 7 or 10
|
|
|
|
* We keep the byte offset in the line in Y, and the
|
|
* line index in X, for the entire loop.
|
|
horzloop
|
|
_hlcolor lda #$00 ;2 start with color pattern
|
|
_lmdh eor (]hbasl),y ;5 flip all bits
|
|
and ]andmask ;3 clear other bits
|
|
eor (]hbasl),y ;5 restore ours, set theirs
|
|
sta (]hbasl),y ;6 = 21
|
|
|
|
* Move right. We shift the bit mask that determines
|
|
* the pixel. When we shift into bit 7, we know it's
|
|
* time to advance another byte.
|
|
*
|
|
* If this is a shallow line we would benefit from
|
|
* keeping the index in X and just doing a 4-cycle
|
|
* indexed load to get the mask. Not having the
|
|
* line number in X makes the line calc more
|
|
* expensive for steeper lines though.
|
|
lda ]andmask ;3
|
|
asl ;2 shift, losing hi bit
|
|
eor #$80 ;2 set the hi bit
|
|
bne :noh8 ;3 cleared hi bit?
|
|
* We could BEQ away and branch back in, but this
|
|
* happens every 7 iterations, so on average it's
|
|
* a very small improvement. If we happen to branch
|
|
* across a page boundary the double-branch adds
|
|
* two more cycles and we lose.
|
|
iny ;2 advance to next byte
|
|
lda colorline,y ;4 update color mask
|
|
sta _hlcolor+1 ;4
|
|
lda #$81 ;2 reset
|
|
:noh8 sta ]andmask ;3 = 13 + ((12-1)/7) = 14
|
|
|
|
* Update error diff.
|
|
lda ]diff ;3
|
|
sec ;2
|
|
sbc ]deltay ;3 :diff -= deltay
|
|
bcs hnoroll ;2+ :if (diff < 0) ...
|
|
;= 11 level, 10 up/down
|
|
adc ]deltaxl ;3 : diff += deltax
|
|
sta ]diff ;3
|
|
_hmody inx ;2 : ypos++ (or --)
|
|
lda ylooklo,x ;4 update hbasl after line
|
|
sta ]hbasl ;3 change
|
|
lda ylookhi,x ;4
|
|
_pg_or4 ora #$20 ;2
|
|
sta ]hbasl+1 ;3
|
|
bne hdecc ;3 = +27 this path -> 37
|
|
BREAK
|
|
* horizontal: 10+21+14+11=56 cycles/pixel
|
|
* diagonal: 7+21+14+37=79 cycles/pixel
|
|
|
|
|
|
* Vertical-dominant line. Could go up or down.
|
|
vertdom
|
|
ldx in_y0
|
|
cpx ]ypos ;starting at y0?
|
|
bne :endy0 ;yup
|
|
ldx in_y1 ;nope
|
|
:endy0 stx _vchk+1 ;end condition
|
|
|
|
lda ]deltay
|
|
lsr
|
|
sta ]diff ;:diff = deltay / 2
|
|
|
|
* set Y to the byte offset in the line
|
|
* load the AND mask into ]andmask
|
|
ldx ]xposl
|
|
lda ]xposh ;>= 256?
|
|
beq :lotabl ;no, use the low table
|
|
ldy div7hi,x
|
|
lda mod7hi,x
|
|
bpl :gottab ;always
|
|
BREAK ;debug
|
|
:lotabl ldy div7lo,x
|
|
lda mod7lo,x
|
|
:gottab
|
|
tax
|
|
lda andmask,x ;initial pixel mask
|
|
sta ]andmask
|
|
|
|
lda colorline,y ;initial color mask
|
|
sta _vlcolor+1
|
|
|
|
ldx ]ypos
|
|
jmp vertloop
|
|
|
|
* We keep the byte offset in the line in Y, and the
|
|
* line index in X, for the entire loop.
|
|
|
|
* Bottom of loop, essentially.
|
|
vnoroll sta ]diff ;3
|
|
|
|
vertloop
|
|
lda ylooklo,x ;4
|
|
sta ]hbasl ;3
|
|
lda ylookhi,x ;4
|
|
_pg_or5 ora #$20 ;2
|
|
sta ]hbasl+1 ;3 = 16
|
|
|
|
_vlcolor lda #$00 ;2 start with color pattern
|
|
_lmdv eor (]hbasl),y ;5 flip all bits
|
|
and ]andmask ;3 clear other bits
|
|
eor (]hbasl),y ;5 restore ours, set theirs
|
|
sta (]hbasl),y ;6 = 21
|
|
|
|
_vchk cpx #$00 ;2 was this last line?
|
|
beq vrts ;2 yes, done
|
|
_vmody inx ;2 :ypos++ (or --)
|
|
|
|
* Update error diff.
|
|
lda ]diff ;3
|
|
sec ;2
|
|
sbc ]deltaxl ;3 :diff -= deltax
|
|
bcs vnoroll ;2 :if (diff < 0) ...
|
|
;= 10 vert, 9 move right
|
|
|
|
adc ]deltay ;3 : diff += deltay
|
|
sta ]diff ;3
|
|
* Move right. We shift the bit mask that determines
|
|
* the pixel. When we shift into bit 7, we know it's
|
|
* time to advance another byte.
|
|
lda ]andmask ;3
|
|
asl ;2 shift, losing hi bit
|
|
eor #$80 ;2 set the hi bit
|
|
beq :is8 ;2+ goes to zero on 8th bit
|
|
sta ]andmask ;3
|
|
bne vertloop ;3 = 21 + (18/7) = 24
|
|
BREAK
|
|
|
|
:is8 iny ;2 advance to next byte
|
|
lda colorline,y ;4 update color
|
|
sta _vlcolor+1 ;4
|
|
lda #$81 ;2 reset
|
|
sta ]andmask ;3
|
|
bne vertloop ;3 = 18
|
|
BREAK
|
|
vrts rts
|
|
* vertical: 3 + 16 + 21 + 6 + 10 = 56 cycles
|
|
* diagonal: 16 + 21 + 6 + 9 + 24 = 76 cycles
|
|
|
|
|
|
* "Wide" horizontally-dominant loop. We have to
|
|
* maintain error-diff and deltax as 16-bit values.
|
|
* Most of the setup from the "narrow" version carried
|
|
* over, but we have to re-do the count and diff.
|
|
*
|
|
* Normally we set count to (deltax + 1) and decrement
|
|
* to zero, but it's actually easier to set it equal
|
|
* to deltax and check for -1.
|
|
widedom
|
|
lda ]deltaxh ;:count = deltax
|
|
sta ]counth
|
|
ldx ]deltaxl
|
|
stx ]count
|
|
stx ]diff
|
|
lsr ;:diff = deltax / 2
|
|
ror ]diff
|
|
sta ]diffh
|
|
ldx ]ypos
|
|
|
|
lda colorline,y ;set initial color mask
|
|
sta _wlcolor+1
|
|
|
|
* We keep the byte offset in the line in Y, and the
|
|
* line index in X, for the entire loop.
|
|
wideloop
|
|
_wlcolor lda #$00 ;2 start with color pattern
|
|
_lmdw eor (]hbasl),y ;5 flip all bits
|
|
and ]andmask ;3 clear other bits
|
|
eor (]hbasl),y ;5 restore ours, set theirs
|
|
sta (]hbasl),y ;6 = 21
|
|
|
|
* Move right. We shift the bit mask that determines
|
|
* the pixel. When we shift into bit 7, we know it's
|
|
* time to advance another byte.
|
|
lda ]andmask ;3
|
|
asl ;2 shift, losing hi bit
|
|
eor #$80 ;2 set the hi bit
|
|
bne :not7 ;3 goes to zero on 8th bit
|
|
iny ; 2 advance to next byte
|
|
lda colorline,y ; 4 update color mask
|
|
sta _hlcolor+1 ; 4
|
|
lda #$81 ; 2 reset
|
|
:not7 sta ]andmask ;3 = 13 usually, 25 every 7
|
|
|
|
* Update error diff, which is a positive number. If
|
|
* it goes negative ("if (diff < 0)") we act.
|
|
lda ]diff
|
|
sec
|
|
sbc ]deltay ;:diff -= deltay
|
|
bcs wnoroll ;didn't even roll low byte
|
|
dec ]diffh ;check hi byte
|
|
bpl wnoroll ;went 1->0, keep going
|
|
|
|
adc ]deltaxl ;: diff += deltax
|
|
sta ]diff
|
|
lda ]diffh
|
|
adc ]deltaxh
|
|
sta ]diffh
|
|
_wmody inx ;: ypos++ (or --)
|
|
lda ylooklo,x ;update hbasl after line
|
|
sta ]hbasl ; change
|
|
lda ylookhi,x
|
|
_pg_or6 ora #$20
|
|
sta ]hbasl+1
|
|
bne wdecc
|
|
BREAK
|
|
|
|
wnoroll sta ]diff
|
|
|
|
wdecc dec ]count ;5 :count--
|
|
lda ]count ;3
|
|
cmp #$ff ;2
|
|
bne wideloop ;3 :while (count > -1)
|
|
dec ]counth ;low rolled, decr high
|
|
beq wideloop ;went 1->0, keep going
|
|
rts
|
|
|
|
|
|
* Pure-vertical line. These are common in certain
|
|
* applications, and checking for it only adds two
|
|
* cycles to the general case.
|
|
vertline
|
|
ldx in_y0
|
|
ldy in_y1
|
|
cpx in_y1 ;y0 < y1?
|
|
blt :usey0 ;yes, go from y0 to y1
|
|
txa ;swap X/A
|
|
tay
|
|
ldx in_y1
|
|
:usey0 stx ]ypos
|
|
iny
|
|
sty _pvytest+1
|
|
|
|
ldx in_x0l ;xc lo
|
|
lda in_x0h ;>= 256?
|
|
beq :lotabl
|
|
ldy div7hi,x
|
|
lda mod7hi,x
|
|
bpl :gotit ;always
|
|
:lotabl ldy div7lo,x
|
|
lda mod7lo,x
|
|
|
|
* Byte offset is in Y, mod-7 value is in A.
|
|
:gotit tax
|
|
lda andmask,x
|
|
sta _pvand+1 ;this doesn't change
|
|
|
|
lda colorline,y
|
|
sta _pvcolor+1 ;nor does this
|
|
|
|
ldx ]ypos ;top line
|
|
|
|
* There's a trick where, when (linenum & 0x07) is
|
|
* nonzero, you just add 4 to hbasl+1 instead of
|
|
* re-doing the lookup. However, TXA+AND+BEQ
|
|
* followed by LDA+CLC+ADC+STA is 16 cycles, the same
|
|
* as our self-modified lookup, so it's not a win.
|
|
* (And if we used a second ylookhi and self-modded
|
|
* the table address, we could shave off another 2.)
|
|
|
|
* Main pure-vertical loop
|
|
pverloop
|
|
lda ylooklo,x ;4
|
|
sta ]hbasl ;3
|
|
lda ylookhi,x ;4
|
|
_pg_or7 ora #$20 ;2
|
|
sta ]hbasl+1 ;3 (= 16)
|
|
|
|
_pvcolor lda #$00 ;2 start with color pattern
|
|
_lmdpv eor (]hbasl),y ;5 flip all bits
|
|
_pvand and #$00 ;2 clear other bits
|
|
eor (]hbasl),y ;5
|
|
sta (]hbasl),y ;6 (= 20)
|
|
|
|
inx ;2
|
|
_pvytest cpx #$00 ;2 done?
|
|
bne pverloop ;3 = 7
|
|
rts
|
|
* 43 cycles/pixel
|
|
|
|
|
|
********************************
|
|
*
|
|
* Set the line mode according to in_arg
|
|
*
|
|
* A slightly silly feature to get xdraw lines
|
|
* without really working for it.
|
|
*
|
|
********************************
|
|
SetLineMode
|
|
lda in_arg
|
|
beq :standard
|
|
|
|
* configure for xdraw
|
|
lda #$24 ;BIT dp
|
|
sta _lmb
|
|
sta _lmdh
|
|
sta _lmdv
|
|
sta _lmdw
|
|
sta _lmdpv
|
|
rts
|
|
|
|
* configure for standard drawing
|
|
:standard lda #$f0 ;BEQ
|
|
sta _lmb
|
|
lda #$51 ;EOR (dp),y
|
|
sta _lmdh
|
|
sta _lmdv
|
|
sta _lmdw
|
|
sta _lmdpv
|
|
rts
|