mirror of https://github.com/uffejakobsen/acme.git
635 lines
16 KiB
Plaintext
635 lines
16 KiB
Plaintext
;ACME 0.95
|
|
;!sl "ddrv.l"
|
|
; Name DuoDriver
|
|
; Purpose Input driver for mouse and joystick
|
|
; Author (c) Marco Baye, 1999
|
|
; Licence Free software
|
|
; Changes:
|
|
; 23 Apr 1999 Release 2.20. Internal info:
|
|
; DuoDriver v2.20 by Mac Bacon 23 Apr 1999. Freeware!
|
|
; Somewhen Added self-calibration, forming release 3.00. Internal info:
|
|
; Mac Bacon:DuoDrv3,PD
|
|
; 21 Jul 1999 Used reverse subtraction, forming release 3.01. Internal info:
|
|
; Mac Bacon:DuoDrv3,PD
|
|
; 1 Aug 1999 Release 4.00.
|
|
; Both 128 and 64 versions
|
|
; Now supports overlay-sprite mouse pointer
|
|
; Binary includes sprites
|
|
; Released in GO64 8/1999 (without release number).
|
|
; 3 Aug 1999 Same source file for both 128 and 64 versions. Release 4.01.
|
|
; Apart from that, virtually identical to release 4.00.
|
|
; 04 Feb 2003 Beautified
|
|
; 05 Feb 2003 Added "SpriteLine" macro and made sprites inline
|
|
; 26 May 2005 Release 4.02. All changes since release 4.00 are source-only!
|
|
; The resulting binaries are identical to those of release 4.00
|
|
; (which were included in GO64 magazine 8/1999)
|
|
; 26 Mar 2006 Release 4.03. Adjusted source to ACME 0.91 capabilities.
|
|
; 25 Nov 2007 Release 4.04. Adjusted source to ACME 0.94 capabilities.
|
|
; 7 Apr 2013 Slightly reformatted.
|
|
; 1 Jun 2014 Adjusted to experimental type system of ACME 0.95
|
|
|
|
; This source code file uses conditional assembly
|
|
; to decide which version to produce (C64 or C128).
|
|
|
|
; Select type of binary to assemble (64 => c64, anything else => c128)
|
|
!ifndef SYSTEM {
|
|
!warn "Label SYSTEM not defined. Use -DSYSTEM=64 to build C64 version, -DSYSTEM=128 to build C128 version. Will now default to C64 version."
|
|
SYSTEM = 64
|
|
}
|
|
!if SYSTEM != 64 & SYSTEM != 128 {
|
|
!serious "Please use either -DSYSTEM=64 or -DSYSTEM=128 when assembling this project."
|
|
}
|
|
|
|
|
|
; --- Configurable values
|
|
|
|
; Start address, output file name and VIC location
|
|
|
|
!if SYSTEM = 64 {
|
|
* = $c000
|
|
!to "ddrv64.prg", cbm
|
|
!addr VIC_Base = $d000
|
|
}
|
|
!if SYSTEM = 128 {
|
|
* = $0c00
|
|
!to "ddrv128.prg", cbm
|
|
!addr VIC_Base = $11d6 ; Location of mirror registers
|
|
}
|
|
|
|
; Pointer's maximum coordinates
|
|
MaximumCoordinateX = 319 ; VIC value
|
|
; MaximumCoordinateX = 639 ; VDC value
|
|
MaximumCoordinateY = 199
|
|
|
|
; Maximum pixel step size ("speed") for joystick acceleration routine.
|
|
MaxStep = $10 ; max $7f
|
|
|
|
; Distance before acceleration starts, in pixels.
|
|
MaxTime = $04 ; max $7f
|
|
|
|
; Sprites to use for overlay pointer
|
|
Sprite_A = 0
|
|
Sprite_B = 1
|
|
|
|
; Coordinates of "pointer pixel" within pointer sprites; adjust these
|
|
; if you use different sprites. (0,0) is sprite's upper left pixel.
|
|
Sprite_HotspotX = 1
|
|
Sprite_HotspotY = 1
|
|
|
|
; address definitions
|
|
!addr {
|
|
|
|
; Locations to store button states, $ff = pressed, $00 = not pressed.
|
|
; Mouse uses both buttons, joystick only uses "LeftButton".
|
|
; Location to store pointer's current character coordinates.
|
|
!if SYSTEM = 64 {
|
|
LeftButton = $a4
|
|
RightButton = $a5
|
|
CharX = $b3
|
|
CharY = $b4
|
|
tapebuf = $0340
|
|
spr_ptrs = 2040
|
|
}
|
|
!if SYSTEM = 128 {
|
|
LeftButton = $fa
|
|
RightButton = $ff
|
|
CharX = $9b
|
|
CharY = $9c
|
|
}
|
|
|
|
; Location to store pointer's current pixel coordinates. The driver
|
|
; code relies on having *four consecutive* bytes:
|
|
; x low, x high, y low, y high
|
|
Coordinates = $fb ; $fb..$fe
|
|
|
|
; --- System constants
|
|
|
|
; Interrupt vector
|
|
sys_iirq = $0314
|
|
|
|
; I/O registers
|
|
sid_pot = $d419
|
|
cia1_pra = $dc00
|
|
cia1_prb = $dc01
|
|
cia1_ddrb = $dc03
|
|
mmu_cr = $ff00 ; c128 only
|
|
|
|
; dummy value for self mod
|
|
MODIFIED16 = $ffff
|
|
|
|
};addr
|
|
|
|
; --- Label definitions
|
|
|
|
; New names for some precalculated values, only to improve
|
|
; readability. Don't change these.
|
|
PointerXnow = Coordinates
|
|
PointerYnow = Coordinates + 2
|
|
SpriteA_X = VIC_Base + 2 * Sprite_A
|
|
SpriteA_Y = VIC_Base + 2 * Sprite_A + 1
|
|
SpriteB_X = VIC_Base + 2 * Sprite_B
|
|
SpriteB_Y = VIC_Base + 2 * Sprite_B + 1
|
|
Sprites_OF = VIC_Base + 16 ; X Overflow
|
|
; The character "^" in the following calculation means "to the power
|
|
; of". It is ACME syntax - if your assembler cannot do this, you may
|
|
; want to use hardcoded values here instead of calculations.
|
|
Sprites_Bitmask = 2 ^ Sprite_A + 2 ^ Sprite_B
|
|
;alternative:
|
|
; Sprites_Bitmask = 1 << Sprite_A | 1 << Sprite_B
|
|
SpriteOffset_X = $18 - Sprite_HotspotX
|
|
SpriteOffset_Y = $32 - Sprite_HotspotY
|
|
; In the sprite coordinate system, the graphics pixel (0,0) has the
|
|
; coordinates ($18,$32), so these are needed for converting. Blame the
|
|
; VIC.
|
|
|
|
|
|
; --- Entry point
|
|
|
|
; Because this routine is the first, the file can be BOOTed on a c128.
|
|
; Initialisation code, installs driver on IRQ vector.
|
|
; Fetch IRQ vector and write to end
|
|
Init lda sys_iirq
|
|
ldx sys_iirq + 1
|
|
sta mod16
|
|
stx mod16 + 1
|
|
; Let IRQ vector point to driver code
|
|
lda #<Entry
|
|
ldx #>Entry
|
|
php
|
|
sei
|
|
sta sys_iirq
|
|
stx sys_iirq + 1
|
|
plp
|
|
!if SYSTEM = 128 {
|
|
lda mmu_cr
|
|
tay
|
|
and #$fe ; activate I/O chips
|
|
sta mmu_cr
|
|
}
|
|
|
|
; Init mouse buttons
|
|
lda #$11
|
|
sta cia1_prb
|
|
!if SYSTEM = 128 {
|
|
sty mmu_cr
|
|
}
|
|
!if SYSTEM = 64 {
|
|
; Copy sprites to tape buffer
|
|
ldx #127
|
|
- lda Sprites, x
|
|
sta tapebuf, x
|
|
dex
|
|
bpl -
|
|
lda #Sprites_Bitmask
|
|
; Set sprite block pointers
|
|
ldx #$0d
|
|
stx spr_ptrs + Sprite_A
|
|
inx
|
|
stx spr_ptrs + Sprite_B
|
|
; Activate pointer sprites
|
|
ora VIC_Base + 21
|
|
sta VIC_Base + 21
|
|
}
|
|
rts
|
|
|
|
|
|
; --- Variables
|
|
|
|
; Pixel counter before accelerating
|
|
JoyWaittime !byte 0
|
|
|
|
|
|
; --- Main code
|
|
|
|
Entry
|
|
; The driver consists of several distinct parts. To minimise
|
|
; performance wastage, you should remove all parts you don't need for
|
|
; the specific application.
|
|
|
|
|
|
; --- Part 0, initialisations
|
|
|
|
; Make sure decimal mode is off
|
|
cld
|
|
; Set button states to "not pressed", so the other parts only have to
|
|
; deal with setting them to "pressed".
|
|
lda #$00
|
|
sta LeftButton
|
|
sta RightButton
|
|
|
|
|
|
; --- Part 1, handling mouse movements
|
|
|
|
; mouse x
|
|
ldx #$00 ; 0 means "x stuff"
|
|
jsr PotDelta
|
|
; Now signed x movement is in A/Y. Add to current x value.
|
|
clc
|
|
adc PointerXnow
|
|
sta PointerXnow
|
|
tya
|
|
adc PointerXnow + 1
|
|
sta PointerXnow + 1
|
|
; mouse y
|
|
ldx #$01 ; 1 means "y stuff"
|
|
jsr PotDelta
|
|
; Now signed y movement is in A/Y. Mouse and computer use different y
|
|
; directions, so don't add to, but subtract from current y value.
|
|
; This is a reverse subtraction - it might be harder to understand,
|
|
; but it is both faster and smaller than the usual way.
|
|
clc
|
|
sbc PointerYnow
|
|
eor #$ff
|
|
sta PointerYnow
|
|
tya
|
|
sbc PointerYnow + 1
|
|
eor #$ff
|
|
sta PointerYnow + 1
|
|
|
|
|
|
; --- Part 2, handling mouse buttons
|
|
|
|
; Prepare CIA by setting bits to input
|
|
ldy #$11
|
|
sty cia1_ddrb
|
|
ldx #$ff ; $ff means "pressed"
|
|
lda #$10 ; check left button
|
|
bit cia1_prb
|
|
bne +
|
|
stx LeftButton ; store state
|
|
+ lda #$01 ; check right button
|
|
bit cia1_prb
|
|
bne +
|
|
stx RightButton ; store state
|
|
+
|
|
; Reset CIA to normal state
|
|
ldy #$00
|
|
sty cia1_ddrb
|
|
|
|
|
|
; --- Part 3, handling the joystick
|
|
|
|
; Fetch byte holding direction flags
|
|
lda cia1_pra
|
|
tax ; ...and remember it
|
|
; Check 'up' direction
|
|
ror
|
|
bcs ++
|
|
; Subtract current step size from y value if needed.
|
|
tay
|
|
sec
|
|
lda PointerYnow
|
|
sbc JoyStepsize
|
|
sta PointerYnow
|
|
bcs +
|
|
dec PointerYnow + 1
|
|
+ tya
|
|
++ ; Check 'down' direction
|
|
ror
|
|
bcs ++
|
|
; Add current step size to y value if needed.
|
|
tay
|
|
;clc ; C is always clear here
|
|
lda PointerYnow
|
|
adc JoyStepsize
|
|
sta PointerYnow
|
|
bcc +
|
|
inc PointerYnow + 1
|
|
+ tya
|
|
++ ; Check 'left' direction
|
|
ror
|
|
bcs ++
|
|
; Subtract current step size from x value if needed.
|
|
tay
|
|
sec
|
|
lda PointerXnow
|
|
sbc JoyStepsize
|
|
sta PointerXnow
|
|
bcs +
|
|
dec PointerXnow + 1
|
|
+ tya
|
|
++ ; Check 'right' direction
|
|
ror
|
|
bcs ++
|
|
; Add current step size to x value if needed.
|
|
tay
|
|
;clc ; C is always clear here
|
|
lda PointerXnow
|
|
adc JoyStepsize
|
|
sta PointerXnow
|
|
bcc +
|
|
inc PointerXnow + 1
|
|
+ tya
|
|
++
|
|
|
|
; --- Part 4, handling joystick button
|
|
|
|
ror
|
|
bcs +
|
|
lda #$ff ; $ff means "pressed"
|
|
sta LeftButton
|
|
+
|
|
|
|
; --- Part 5, joystick acceleration
|
|
|
|
; Restore joystick direction bits and check whether to set speed to
|
|
; zero.
|
|
txa
|
|
and #$0f ; Clear unneeded bits
|
|
cmp #$0f ; Any direction bit ?
|
|
bne +
|
|
; No direction was used, so reset speed and wait counter to normal.
|
|
lda #$01
|
|
sta JoyStepsize
|
|
lda #MaxTime
|
|
sta JoyWaittime
|
|
jmp Part5End
|
|
+
|
|
; A direction bit was used, so check whether to accelerate: If speed
|
|
; is already maximum speed, don't accelerate.
|
|
JoyStepsize = * + 1
|
|
lda #$00 ; (self-modifying)
|
|
; If the variable "JoyStepsize" would have been defined as a separate
|
|
; location (using "!byte"), it would have taken a byte of memory. By
|
|
; storing the value inside an LDA command's argument, we save that one
|
|
; byte. It might make a difference. :)
|
|
cmp #MaxStep ; If speed is max.,
|
|
bcs Part5End ; don't accelerate.
|
|
; Speed isn't maximum yet. Check whether
|
|
; we have to wait before accelerating.
|
|
dec JoyWaittime
|
|
bpl Part5End
|
|
; Counter has underrun, so accelerate.
|
|
inc JoyWaittime ; reset counter
|
|
inc JoyStepsize ; increase speed
|
|
Part5End
|
|
|
|
; --- Part 6, restrict coordinate range
|
|
|
|
; restrict x value
|
|
ldx #$00 ; 0 means "x stuff"
|
|
jsr Restrict
|
|
; restrict y value
|
|
ldx #$02 ; 2 means "y stuff"
|
|
jsr Restrict
|
|
|
|
; --- Part 7, positioning sprites
|
|
|
|
; Set sprites' x positions
|
|
lda PointerXnow
|
|
clc
|
|
adc #SpriteOffset_X
|
|
sta SpriteA_X ; set both sprites
|
|
sta SpriteB_X
|
|
lda Sprites_OF ; get x overflow
|
|
bcs SetOF
|
|
ldx PointerXnow + 1
|
|
bne SetOF
|
|
and #Sprites_Bitmask XOR $ff
|
|
bcc StoreOF ; C is clear here
|
|
SetOF ora #Sprites_Bitmask
|
|
StoreOF sta Sprites_OF ; set x overflow
|
|
|
|
; Set sprites' y positions
|
|
lda PointerYnow
|
|
clc
|
|
adc #SpriteOffset_Y
|
|
sta SpriteA_Y
|
|
sta SpriteB_Y
|
|
; The y value's high byte is useless in this case.
|
|
|
|
; --- Part 8, making char coordinates
|
|
|
|
; Convert x coordinate. There are different "best" routines for
|
|
; different resolutions, so I've given the VIC and VDC routines.
|
|
lda PointerXnow
|
|
lsr
|
|
lsr
|
|
lsr
|
|
ldx PointerXnow + 1
|
|
;ora OrTable,x ; VDC only (see below for data table)
|
|
beq + ; VIC only
|
|
ora #$20 ; VIC only
|
|
+ sta CharX
|
|
|
|
; Convert y coordinate.
|
|
lda PointerYnow
|
|
lsr
|
|
lsr
|
|
lsr
|
|
sta CharY
|
|
|
|
; --- Add further parts here
|
|
|
|
; Here you can add further routines, for example to use the button
|
|
; states to fake keypresses etc.
|
|
|
|
; --- The end
|
|
|
|
; The initialisation routine sets the argument to the address of the
|
|
; previous IRQ routine.
|
|
mod16 = * + 1: jmp MODIFIED16 ; (self-modifying)
|
|
|
|
; This table is for part 8.
|
|
;OrTable !byte 0, 32, 64 ; VDC only
|
|
|
|
; --- "Restrict" subroutine
|
|
|
|
PointerXmax !word MaximumCoordinateX
|
|
PointerYmax !word MaximumCoordinateY
|
|
; "y" word must follow directly after "x" word in memory.
|
|
|
|
Restrict
|
|
; Restrict internal coordinates to configured range. Entry conditions:
|
|
; X is direction handle (0 = x, 2 = y)
|
|
lda PointerXnow + 1, x
|
|
bmi SetTo0
|
|
cmp PointerXmax + 1, x
|
|
bcc Eosr
|
|
bne +
|
|
lda PointerXmax, x
|
|
cmp PointerXnow, x
|
|
bcs Eosr
|
|
+ lda PointerXmax, x
|
|
ldy PointerXmax + 1, x
|
|
jmp DefCo
|
|
|
|
SetTo0 lda #0
|
|
tay
|
|
DefCo sta PointerXnow, x
|
|
sty PointerXnow + 1, x
|
|
Eosr rts
|
|
|
|
; --- "Pot" subroutine
|
|
|
|
; This routine computes the mouse movements and therefore contains the
|
|
; self-calibration stuff and the other improvements over the standard
|
|
; 1351 driver.
|
|
PotMax !word 0 ; max. POTs yet plus 1 !
|
|
PotMin !word $ffff ; lowest POTs yet
|
|
PotOld !word 0 ; old values
|
|
PotWidth !word 0 ; interval width
|
|
HalfPotWidth !word 0 ; half width
|
|
; (buffered for speed increase)
|
|
; The above variables are not really words: The first byte is the x
|
|
; value, the second byte is the y value respectively.
|
|
|
|
|
|
; Compute the signed distance of mouse movement.
|
|
; Entry conditions: X is direction handle (0 = x, 1 = y)
|
|
; Exit conditions: A/Y are signed distance (low/high)
|
|
|
|
; First, get new value and clear "recalculate signal width" flag.
|
|
PotDelta lda sid_pot, x
|
|
ldy #$00
|
|
; Check whether new value is lower than lowest known.
|
|
cmp PotMin, x
|
|
bcs +
|
|
; Store new "lowest" und set "recalculate signal width" flag.
|
|
sta PotMin, x
|
|
ldy #$ff
|
|
+ ; Check whether new value is higher than highest known.
|
|
cmp PotMax, x
|
|
bcc +
|
|
; Set "recalculate signal width" flag and store new "highest".
|
|
ldy #$ff
|
|
pha ; Remember current value
|
|
adc #$00 ; Add one (C is set)
|
|
sta PotMax, x
|
|
; Value $ff (0 after adding) means that there is no mouse connected,
|
|
; so reset min/max in that case.
|
|
beq ResetMM ; Stack is untidy...
|
|
pla ; Restore current value
|
|
+ ; If flag is set, recalculate signal width.
|
|
iny ; Check flag
|
|
bne ++
|
|
tay ; Buffer current value.
|
|
lda PotMax,x ; Get highest + 1
|
|
sec ; Subtract lowest
|
|
sbc PotMin, x
|
|
bcc +
|
|
sta PotWidth, x ; Store signal
|
|
lsr ; width and half signal
|
|
sta HalfPotWidth, x ; width
|
|
+ tya ; Restore current value.
|
|
++ ; Calculate distance
|
|
tay ; Buffer current value.
|
|
sec
|
|
sbc PotOld, x
|
|
pha
|
|
tya
|
|
sta PotOld, x
|
|
pla
|
|
beq zero ; If not moved, exit.
|
|
bcc minus ; Negative difference
|
|
|
|
; Positive difference:
|
|
; Check whether movement caused a value wrap-around.
|
|
cmp HalfPotWidth, x
|
|
bcc Decrease
|
|
beq Decrease
|
|
; It did, so calculate "real" distance and jump to exit
|
|
;sec ; C is always set here
|
|
sbc PotWidth, x ; Fix distance
|
|
|
|
; We now know that the (fixed) distance is really negative, so we
|
|
; finally wipe out that annoying bit 0 noise by incrementing the
|
|
; value.
|
|
Increase ;clc ; C is always clear here
|
|
adc #$01
|
|
beq zero ; If increasing gives zero, jump to zero handler.
|
|
ldy #$ff ; Set up high byte for negative values.
|
|
rts
|
|
|
|
; Negative difference:
|
|
; Check whether movement caused a value wrap-around.
|
|
minus eor #$ff ; Complement
|
|
; If we would do a real negation (by adding "1"), then we would need
|
|
; to branch using BCC *and* BEQ. So the above way might be harder to
|
|
; understand, but it is both shorter *and* faster - which I like. :)
|
|
cmp HalfPotWidth, x
|
|
eor #$ff ; Restore value
|
|
bcc Increase
|
|
; Movement caused a value wrap-around, so calculate "real" distance and exit.
|
|
clc
|
|
adc PotWidth, x ; Fix distance
|
|
|
|
; We now know that the (fixed) distance is really positive, so we
|
|
; finally wipe out that annoying bit 0 noise by decrementing the value.
|
|
Decrease sec
|
|
sbc #$01
|
|
|
|
; No difference or positive difference; both need zero as the high byte.
|
|
zero ldy #0
|
|
rts
|
|
|
|
; If there is no mouse, reset "lowest" ("highest" will have been reset
|
|
; already) and return zero.
|
|
ResetMM tay ; Set Y to zero.
|
|
pla ; Tidy stack
|
|
lda #$ff ; Reset "lowest"
|
|
sta PotMin, x
|
|
tya ; Return with A/Y = 0
|
|
rts
|
|
|
|
; --- Include sprites
|
|
|
|
; Because the c64 version copies the sprite data into the tape buffer
|
|
; on initialisation, the data is included right here.
|
|
; In the c128 version, we skip memory until we reach $0e00 - this is
|
|
; where the sprites are stored by default.
|
|
|
|
!if SYSTEM = 128 {
|
|
!align $ffff, $e00, $0
|
|
}
|
|
|
|
!macro SpriteLine .v {
|
|
!by .v >> 16, (.v >> 8) & 255, .v & 255
|
|
}
|
|
|
|
Sprites ; 765432107654321076543210
|
|
+SpriteLine %........................
|
|
+SpriteLine %.#......................
|
|
+SpriteLine %.##.....................
|
|
+SpriteLine %.###....................
|
|
+SpriteLine %.####...................
|
|
+SpriteLine %.#####..................
|
|
+SpriteLine %.######.................
|
|
+SpriteLine %.#######................
|
|
+SpriteLine %.########...............
|
|
+SpriteLine %.#########..............
|
|
+SpriteLine %.########...............
|
|
+SpriteLine %.######.................
|
|
+SpriteLine %.######.................
|
|
+SpriteLine %.##..##.................
|
|
+SpriteLine %.#....##................
|
|
+SpriteLine %......##................
|
|
+SpriteLine %.......##...............
|
|
+SpriteLine %.......##...............
|
|
+SpriteLine %........##..............
|
|
+SpriteLine %........##..............
|
|
+SpriteLine %........................
|
|
!byte 0 ; pad to 64-byte block
|
|
; 765432107654321076543210
|
|
+SpriteLine %##......................
|
|
+SpriteLine %###.....................
|
|
+SpriteLine %####....................
|
|
+SpriteLine %#####...................
|
|
+SpriteLine %######..................
|
|
+SpriteLine %#######.................
|
|
+SpriteLine %########................
|
|
+SpriteLine %#########...............
|
|
+SpriteLine %##########..............
|
|
+SpriteLine %###########.............
|
|
+SpriteLine %###########.............
|
|
+SpriteLine %#########...............
|
|
+SpriteLine %########................
|
|
+SpriteLine %########................
|
|
+SpriteLine %###..####...............
|
|
+SpriteLine %##...####...............
|
|
+SpriteLine %......####..............
|
|
+SpriteLine %......####..............
|
|
+SpriteLine %.......####.............
|
|
+SpriteLine %.......####.............
|
|
+SpriteLine %........###.............
|