; Copyright 1996 Acorn Computers Ltd
;
; Licensed under the Apache License, Version 2.0 (the "License");
; you may not use this file except in compliance with the License.
; You may obtain a copy of the License at
;
; http://www.apache.org/licenses/LICENSE-2.0
;
; Unless required by applicable law or agreed to in writing, software
; distributed under the License is distributed on an "AS IS" BASIS,
; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
; See the License for the specific language governing permissions and
; limitations under the License.
;
; > &.Source.VduGrafG
;
; ARTHUR OPERATING SYSTEM - Vdu Drivers
; =======================
;
; Vdu driver code - Sprite stuff
;
; Author R C Manby
; Date 10.11.86
;
RangeB * 256
RangeC * 512
; Macros for various sprite operations
MACRO
KillSpChoosePtr
MOV R0, #0
STR R0, [WsPtr, #SpChoosePtr]
MEND
MACRO
CopyDown $to,$from,$bytes, $tmp, $tmp2
LDR $tmp2, [WsPtr, #VduSprite] ; sprite being output to by Vdu
ADD $tmp, $from, $bytes
SUB $tmp, $tmp, #1 ; from + bytes -1
CMP $tmp2, $to ; if VOTS >= to
CMPCS $tmp, $tmp2 ; and from+bytes-1 >= VOTS
BCC %FT00
Push "R0, R14"
SUB R0, $to, $from ; then adjust address vars
BL AdjustSpriteAddress ; by offset = to-from
Pull "R0, R14"
00
CMP $bytes, #0 ; bytes must be a multiple of 4
01
LDRNE $tmp, [$from], #4
STRNE $tmp, [$to], #4
SUBNES $bytes, $bytes, #4
BNE %BT01
MEND
MACRO
CopyUp $to,$from,$bytes, $tmp, $tmp2
LDR $tmp2, [WsPtr, #VduSprite] ; sprite being output to by Vdu
ADD $tmp, $to, $bytes
SUB $tmp, $tmp, #1 ; to + bytes -1
CMP $tmp2, $from ; if VOTS >= from
CMPCS $tmp, $tmp2 ; and to+bytes-1 >= VOTS
BCC %FT00
Push "R0, R14"
SUB R0, $to, $from ; then adjust address vars
BL AdjustSpriteAddress ; by offset = to-from
Pull "R0, R14"
00
01
SUBS $bytes, $bytes, #4
LDRCS $tmp, [$from, $bytes]
STRCS $tmp, [$to, $bytes]
BHI %BT01
MEND
; copy R0 bytes from R3 to R2 (R2+:=R0; R3+:=R0)
; corrupts R0, R4-R11, R14
; NB not used at present
MACRO
CopyDownFast
SUBS R0, R0, #9*4
10
LDMCSIA R3!, {R4-R11,R14}
STMCSIA R2!, {R4-R11,R14}
SUBCSS R0, R0, #9*4
BCS %BT10
ADDS R0, R0, #9*4
20
LDRNE R4, [R3], #4
STRNE R4, [R2], #4
SUBNES R0, R0, #4
BNE %BT20
MEND
MACRO
ClearWords $from,$words, $tmp
MOV $tmp,#0
01
SUBS $words, $words, #1
STRCS $tmp, [$from], #4
BHI %BT01
MEND
; *****************************************************************************
;
; AdjustSpriteAddress - Move VduSprite, ScreenStart, CursorAddr and
; InputCursorAddr by R0
;
; Internal routine, called by routines that use macros
; CopyDown, CopyUp
;
; in: R0 = no. of bytes to add on (can be -ve)
;
AdjustSpriteAddress ROUT
Push R14
LDR R14, [WsPtr, #VduSprite]
ADD R14, R14, R0
STR R14, [WsPtr, #VduSprite]
LDR R14, [WsPtr, #ScreenStart]
ADD R14, R14, R0
STR R14, [WsPtr, #ScreenStart]
B AdjustCursorVars ; update CursorAddr, InputCursorAddr
; *****************************************************************************
;
; SpriteInit - Setup sprite workspace on reset (called whenever break
; is pressed)
;
SpriteInit ROUT
Push R14
BL ClearSpritePtrName ; clear SpChoosePtr,SpChooseName
Pull PC
LTORG
; *****************************************************************************
;
; Vdu23_27 - SCHOOSE/SGET a numbered sprite
;
; in: QQ?0 = 0 => Select sprite STR$(QQ?1) for plotting
; QQ?0 = 1 => Sget an area of screen and put it in sprite STR$(QQ?1)
;
Vdu23_27 ROUT
LDRB R0, [WsPtr, #QQ+1]
CMP R0, #1
MOVCC R3, #SpriteReason_SelectSprite ; 0-Select sprite
MOVEQ R3, #SpriteReason_GetSprite ; 1-Pickup sprite
MOVHI PC, R14
Push R14
LDRB R0, [WsPtr, #QQ+2] ; sprite number
ADD R1, WsPtr, #NameBuf
MOV R2, #4
SWI XOS_BinaryToDecimal
MOV R0, #13
STRB R0, [R1, R2] ; $NameBuf := STR$(n)
MOV R0, R3 ; R0 = sprite-op reason code
MOV R2, R1 ; R2 -> sprite name
MOV R3, #0 ; extension gap size
SWI XOS_SpriteOp ; perform operation, ignore errors
Pull PC
; *****************************************************************************
;
; SpritePlot - PLOT &E8-&EF,X,Y
;
; in: R2 = plot code
;
; The 2 LSBits of the plot code specify fg/bg colour and action as :-
; 0 => No effect eqv. of Gcol(5,c)
; 1 => Plot sprite using foreground Gcol action
; 2 => Invert eqv. of Gcol(4,c)
; 3 => Plot mask in background colour and Gcol action
;
SpritePlot ROUT
Push R14
AND R3, R2, #3 ; 2 LSBits of plot code
CMP R3, #1
MOVCC R5, #5 ; gcol action - no effect
LDREQ R5, [WsPtr, #GPLFMD] ; foreground
MOVHI R5, #4 ; invert or background
AND R5, R5, #&0F ; knock out any ecf bits
LDR R2, [WsPtr, #SpChoosePtr] ; If ChoosePtr <> 0
CMP R2, #0
BNE %FT10 ; then use as pointer to sprite
MOV R0, #SpriteReason_SelectSprite ; else select it first
LDR R2, =SpChooseName
ADD R2, R2, WsPtr ; sprite name ptr
SWI XOS_SpriteOp
LDR R2, [WsPtr, #SpChoosePtr]
10 ; R2 points to the sprite
CMP R3, #3
MOVNE R0, #RangeC+SpriteReason_PutSprite
LDREQ R0, =RangeC+SpriteReason_PlotMask
LDR R1, [WsPtr, #SpAreaStart]
SWI XOS_SpriteOp ; perform operation, ignoring errors
Pull PC
; *****************************************************************************
;
; SwiSpriteOp - Entry point for SWI OS_SpriteOp
;
; in: R0 = sprite op reason code
; R1 -> sprite area (usually)
; R2 -> sprite (usually)
; R3..? parameters
;
SwiSpriteOp ROUT
Push R14
BranchNotJustUs %F10, SpriteV, R11, R14
; we are sole owners of SpriteV, so call our internal routine
Push PC ; push address of SwiSpriteReturn
B SpriteVecHandler
& 0
SwiSpriteReturn
Pull R14
ORRVS R14, R14, #V_bit ; if error, set V_bit in link
ExitSWIHandler
; we are not the sole owners of SpriteV, so call the vector
10
MOV R10, #SpriteV
BL %FT20
Pull R14
ORRVS R14, R14, #V_bit ; if error, set V_bit in link
ExitSWIHandler
20
CallAVector
; *****************************************************************************
;
; SpriteVecHandler - Default owner of SpriteV
;
; in: R0-R7 contain our entry parameters
;
; out: R0-R7 contain exit parameters
; R8-R12 are preserved
;
MACRO
SpriteOpDispatch $cond
ADD$cond PC, R10, R11, ASR #8
MEND
MACRO
SpriteOpEntry $addr, $flags
& (($addr - SwiSpriteOpCallTb) :SHL: 8) + $flags
MEND
; The end of this code is put before the beginning, so that
; SpriteDispatchReturn + SVC_mode is within ADR reach of the dispatcher
BadReasonCode ROUT
ADRL R0, SpriteErr_BadReasonCode
[ International
BL TranslateError
]
B %FT20
SpriteIsCurrentDest
ADRL R0, SpriteErr_SpriteIsCurrentDest
[ International
BL TranslateError
]
B %FT20
15
ADRL R0, SpriteErr_DoesntExist
[ International
BL TranslateError
]
20 ; Exit SWI with error, error code in R0
STR R0, [WsPtr, #RetnReg0]
30
SETV ; indicate an error
; and drop thru to...
SpriteDispatchReturn
ADD R11, WsPtr, #RetnReg0
LDMIA R11, {R0-R9} ; Restore R0-R9
MOV R10, R13 ; Point at old returned registers
Push "R0-R9" ; Save new returned registers on stack
LDMIA R10, {R0-R9} ; Load old returned registers
STMIA R11, {R0-R9} ; and put them in the dump area
Pull "R0-R9" ; restore new returned registers
ADD R13, R13, #10*4 ; remove stack frame
Pull "R10-R12,PC"
SpriteVecHandler
Push "R10-R12"
WritePSRc SVC_mode, WsPtr ; Re-enable interupts
VDWS WsPtr ; Point R12 at Vdu driver workspace
ADD R11, WsPtr, #RetnReg0
SUB R13, R13, #10*4 ; Create stack frame for old RetnRegs
MOV R10, R13 ; Keep pointer to this frame
Push "R0-R9" ; Save new regs while we copy old ones
LDMIA R11, {R0-R9} ; Load old regs
STMIA R10, {R0-R9} ; and push them onto stack
Pull "R0-R9" ; Restore new regs
STMIA R11, {R0-R9} ; Dump R0-R9
CMP R0, #RangeC + &100 ; if top bits out of range
BCS BadReasonCode ; then error
CMP R0, #RangeB ; if Range A type
LDRCC R1, [WsPtr, #SpAreaStart] ; then point at MOS sprite area
AND R0, R0, #&FF ; Kill the range bits
CMP R0, #(SwiSpriteOpCallTb_End-SwiSpriteOpCallTb)/4
BCS BadReasonCode
ADR R10, SwiSpriteOpCallTb
ADR R14, SpriteDispatchReturn ; return address
LDR R11, [R10, R0, LSL #2] ; load (offset<<8) + flags
TST R11, #SSO_ScreenNotAllowed ; if call can specify screen (R2=0)
TEQEQ R2, #0 ; and it is specified
MOVEQ R1, #0 ; then make sprite area ptr 0 as well
TSTNE R11, #SSO_NeedsSomething ; or nothing needed anyway
SpriteOpDispatch EQ ; then dispatch
TEQ R1, #0 ; else needs sprite area ptr
ADREQ R0, SpriteErr_NoWorkSpace ; so if zero then invalid
[ International
BLEQ TranslateError
]
BEQ %BT20
TST R11, #SSO_DangerAreaOp ; if not a danger area op
BEQ %FT32 ; then skip
LDR R9, [WsPtr, #VduSpriteArea] ; else check if sprite area is same
TEQ R9, R1
BEQ SpriteIsCurrentDest ; and error if so
32
TST R11, #SSO_NeedsSprite ; if doesn't need sprite
BNE %FT33
TEQ R0,#SpriteReason_CreateSprite
BEQ %FT21
TEQ R0,#SpriteReason_ScreenSave
TEQNE R0,#SpriteReason_GetSprite
TEQNE R0,#SpriteReason_GetSpriteUserCoords
SpriteOpDispatch NE ; let it go if we're not interested in it
LDR R9,[WsPtr, #Log2BPP] ; fetch the current bpp
CMP R9,#4
SpriteOpDispatch CC ; let it go if below 16bpp
22
CMP R3,#0
BNE %FT34 ; bang if it has a palette
SpriteOpDispatch ; then dispatch
21 ;createsprite. R6=mode number or sprite mode word, or => mode descriptor
Push "R0-R3,R14"
MOV R0,R6
MOV R1,#VduExt_Log2BPP
SWI XOS_ReadModeVariable
MOVCS R2,#0
CMP R2,#4
Pull "R0-R3,R14"
SpriteOpDispatch CC
B %BT22
33
TEQ R2, #0 ; if sprite ptr is zero it's a boob
BEQ %BT15 ; so say SpriteDoesntExist
LDR R9, [WsPtr, #RetnReg0]
CMP R9, #RangeC ; if not range C then must look up
BCS %FT35 ; sprite name and convert to pt4
Push R14
BL SpriteCtrlBlk ; in: R2 -> name; out: R2 -> sprite
Pull R14
BVS %BT15 ; no such sprite
35
;medusa note.
;
;On Medusa masks and palettes for 16/32bpp sprites are in a transient state
;Medusa will fault 16/32bpp mask/palette operations, in readiness for the
;introduction of new (more compact) mask/palette formats.
;
;another medusa note.
;
;Mask operations using 1bpp masks on new format sprites are now being included.
;However palettes on 16/32bpp are still not allowed.
;
;amg 12/11/93, sort out the logic here so that palettes on new format sprites
;really do get faulted
;amg 25th May 1994. We now allow palettes on new format sprites of 8bpp
;and below
; find the sprite type
Push "R14"
LDR R9,[R2,#spMode]
ANDS R14,R9,#15<<27 ; get the sprite type
BEQ %FT37 ; t=0 (ie old format)
CMP R14,#SpriteType_RISCOS5<<27 ; if it's a RISC OS 5 sprite mode word
MOVEQ R14,R9,LSR #20 ; then get the actual sprite type
MOVNE R14,R14,LSR #27
ANDEQS R14,R14,#127
MOVEQ R14,#SpriteType_Substitute ; Panic and treat as 32bpp?
CMP R14,#SpriteType_New16bpp ; check sprite type number
BCC %FT38 ; despatch if new format and under 16bpp
39
; so, does it have a palette
ADD R9,R2,#spImage
LDMIA R9,{R9,R14} ; pick up offsets to mask & image
CMP R9,R14
MOVGT R9,R14 ; R9->top of palette block
SUBS R9,R9,#spPalette ; R9 = size of palette block
BEQ %FT38 ; no palette, so no error
Pull "R14"
34
ADRL R0, SpriteErr_NoMaskOrPaletteAllowedInThisDepth
[ International
BL TranslateError
]
B %BT20
37 ;however, until mode selectors work there are some 16/32bpp old modes
Push "R0-R3" ; save context
MOV R0,R9
MOV R1,#VduExt_Log2BPP
SWI XOS_ReadModeVariable ; read log2bpp for the sprite's mode
MOV R9,R2 ; and move it for posterity
Pull "R0-R3"
CMP R9,#4
BCS %BT39 ; log2bpp of 4 = 16bpp, so see if we want to fault it
38
TST R11, #SSO_DangerOp ; if a destructive op
Pull "R14"
BEQ %FT40
LDR R9, [WsPtr, #VduSprite]
TEQ R9, R2
BEQ SpriteIsCurrentDest ; then stop him!
40
TST R11, #SSO_NeedsSpriteModeData
SpriteOpDispatch EQ
Push "R5-R7, R10, R11, R14"
BL SetupSprModeData
Pull "R5-R7, R10, R11, R14"
SpriteOpDispatch VC
B %BT30 ; Invalid spMode field
SSO_ScreenNotAllowed * 1 :SHL: 0
SSO_NeedsSomething * 1 :SHL: 1
SSO_NeedsSprite * 1 :SHL: 2
SSO_NeedsSpriteModeData * 1 :SHL: 3
SSO_DangerOp * 1 :SHL: 4
SSO_DangerAreaOp * 1 :SHL: 5
Group1 * SSO_ScreenNotAllowed
Group2 * Group1 + SSO_NeedsSomething
Group3 * Group2 + SSO_NeedsSprite
Group4 * Group3 + SSO_NeedsSpriteModeData
Group5 * SSO_NeedsSomething + SSO_NeedsSprite
SwiSpriteOpCallTb
SpriteOpEntry BadReasonCode, Group1
SpriteOpEntry BadReasonCode, Group1
SpriteOpEntry ScreenSave, Group1
SpriteOpEntry ScreenLoad, Group1
SpriteOpEntry BadReasonCode, Group1 ; 4
SpriteOpEntry BadReasonCode, Group1 ; 5
SpriteOpEntry BadReasonCode, Group1 ; 6
SpriteOpEntry BadReasonCode, Group1 ; 7
; The following need valid workspace
SpriteOpEntry ReadAreaCB, Group2
SpriteOpEntry ClearSprites, Group2 + SSO_DangerAreaOp ; *SNew
SpriteOpEntry LoadSpriteFile, Group2 + SSO_DangerAreaOp
; *SLoad <filename>
SpriteOpEntry MergeSpriteFile, Group2 + SSO_DangerAreaOp
; *SMerge <filename>
SpriteOpEntry SaveSpriteFile, Group2 ; *SSave <filename>
SpriteOpEntry ReturnName, Group2
SpriteOpEntry GetSprite, Group2 ; *SGet <name>
SpriteOpEntry CreateSprite, Group2
SpriteOpEntry GetSpriteUserCoords, Group2
SpriteOpEntry BadReasonCode, Group2 ; 17 CheckSpriteArea
SpriteOpEntry BadReasonCode, Group2 ; 18
SpriteOpEntry BadReasonCode, Group2 ; 19
SpriteOpEntry BadReasonCode, Group2 ; 20
SpriteOpEntry BadReasonCode, Group2 ; 21
SpriteOpEntry BadReasonCode, Group2 ; 22
SpriteOpEntry BadReasonCode, Group2 ; 23
; The following need a sprite
SpriteOpEntry SelectSprite, Group3 ; *SChoose <n> [<m>]
SpriteOpEntry DeleteSprite, Group3 + SSO_DangerOp ; *SDelete <n>
SpriteOpEntry RenameSprite, Group3 ; *SRename
SpriteOpEntry CopySprite, Group3 ; *SCopy
SpriteOpEntry PutSprite, Group3
SpriteOpEntry CreateMask, Group3
SpriteOpEntry RemoveMask, Group3 + SSO_DangerOp
SpriteOpEntry InsertRow, Group3 + SSO_DangerOp
SpriteOpEntry DeleteRow, Group3 + SSO_DangerOp
SpriteOpEntry FlipAboutXAxis, Group3
SpriteOpEntry PutSpriteUserCoords, Group3
SpriteOpEntry BadReasonCode, Group3 ; 35 AppendSprite
SpriteOpEntry BadReasonCode, Group3 ; 36 SetPointerShape
SpriteOpEntry BadReasonCode, Group3 ; 37 CreateRemovePalette
SpriteOpEntry BadReasonCode, Group3 ; 38 CreateRemoveAlpha
SpriteOpEntry BadReasonCode, Group3 ; 39
; The following need sprite mode data
SpriteOpEntry ReadSpriteSize, Group4
SpriteOpEntry ReadPixelColour, Group4
SpriteOpEntry WritePixelColour, Group4
SpriteOpEntry ReadPixelMask, Group4
SpriteOpEntry WritePixelMask, Group4
SpriteOpEntry InsertCol, Group4 + SSO_DangerOp
SpriteOpEntry DeleteCol, Group4 + SSO_DangerOp
SpriteOpEntry FlipAboutYAxis, Group4 + SSO_DangerOp
SpriteOpEntry PlotMask, Group4
SpriteOpEntry PlotMaskUserCoords, Group4
SpriteOpEntry BadReasonCode, Group4 ; 50 PlotMaskScaled
SpriteOpEntry BadReasonCode, Group4 ; 51 PaintCharScaled
SpriteOpEntry BadReasonCode, Group4 ; 52 PutSpriteScaled
SpriteOpEntry BadReasonCode, Group4 ; 53 PutSpriteGreyScaled
SpriteOpEntry RemoveLeftHandWastage, Group4
SpriteOpEntry BadReasonCode, Group4 ; 55 PlotMaskTransformed
SpriteOpEntry BadReasonCode, Group4 ; 56 PutSpriteTransformed
SpriteOpEntry BadReasonCode, Group4 ; 57 InsertDeleteRows
SpriteOpEntry BadReasonCode, Group4 ; 58 InsertDeleteColumns
SpriteOpEntry BadReasonCode, Group4 ; 59 pseudo reason used by Wimp
; The following need (sprite area + sprite) or (anything + 0), meaning screen
SpriteOpEntry SwitchOutputToSprite, Group5 ; 60
SpriteOpEntry SwitchOutputToMask, Group5 ; 61
SpriteOpEntry ReadSaveAreaSize, Group5 ; 62
SwiSpriteOpCallTb_End
; *****************************************************************************
;
; SetupSprModeData - Set up registers and variables from the sprite mode
;
; Internal routine: called by sprite dispatch, CreateHeader
;
; in: R2 -> sprite
;
; out: R0-R5 preserved
; R6 = ReadNColour (for a single screen pixel)
; R7 = WriteNColour (=R6 except in double pixel modes)
; R8 = BytesPerChar }
; R9 = XShftFactor } calculated from Log2BPC which is BitsPerPix
; R10 = NPix } corrected for double pixel modes
; R11 = Log2BPC }
;
; SprReadNColour..SprLog2BPC setup accordingly
;
; If error, then RetnReg0 updated
SetupSprModeData ROUT
Push R14
LDR R11, [R2, #spMode]
CMP r11, #&100 ; check for mode selector/new format sprite word
BCC %FT05 ; [it's a mode number so check for known ones]
TST r11, #1 ; if it's a new format sprite word
BNE %FT10 ; then call pushmodeinfo to get info on it
B %FT20 ; else it's a mode selector, which is illegal as a sprite mode word
05
BranchIfKnownMode R11, %FA10
Push "R2-R4"
MOV R2, R11
BL OfferModeExtensionAnyMonitor
Pull "R2-R4"
BNE %FT20
10
MOV R10, R11
BL PushModeInfoAnyMonitor
BVS %FT30 ; if duff new format sprite word, return error
LDR R11, [R13, #wkModeFlags]
TST R11, #ModeFlag_NonGraphic
BNE %FT15 ; non-graphic mode
STR R11, [WsPtr, #SprModeFlags]
LDR R11, [R13, #wkLog2BPC] ; Log2BPC
LDR R14, [R13, #wkLog2BPP] ; Log2BPP
ADD R13, R13, #PushedInfoSize
MOV R7, #1
RSB R9, R11, #5 ; XShftFactor
RSB R10, R7, R7, LSL R9 ; NPix
MOV R6, R7, LSL R14
MOV R8, R7, LSL R11 ; BytesPerChar
RSB R6, R7, R7, LSL R6 ; ReadNColour
RSB R7, R7, R7, LSL R8 ; WriteNColour
Push R5
ADD R5, WsPtr, #SprReadNColour
STMIA R5, {R6-R11,R14} ; SprRead..SprLog2BPP
CLRV
Pull "R5, PC"
15
ADD R13, R13, #PushedInfoSize
20
ADRL R0, SpriteErr_InvalidSpriteMode
[ International
BL TranslateError
]
30
STR R0, [WsPtr, #RetnReg0]
SETV
Pull pc
; *****************************************************************************
; Blocks for sprite errors
SpriteErr_NoWorkSpace MakeErrorBlock Sprite_NoWorkSpace
SpriteErr_NoRoom MakeErrorBlock Sprite_NoRoom
SpriteErr_DoesntExist MakeErrorBlock Sprite_DoesntExist
SpriteErr_NoSprites MakeErrorBlock Sprite_NoSprites
SpriteErr_NotGraphics MakeErrorBlock Sprite_NotGraphics
SpriteErr_NotEnoughRoom MakeErrorBlock Sprite_NotEnoughRoom
SpriteErr_BadSpriteFile MakeErrorBlock Sprite_BadSpriteFile
SpriteErr_NoRoomToMerge MakeErrorBlock Sprite_NoRoomToMerge
SpriteErr_Bad2ndPtr MakeErrorBlock Sprite_Bad2ndPtr
SpriteErr_InvalidRowOrCol MakeErrorBlock Sprite_InvalidRowOrCol
SpriteErr_InvalidHeight MakeErrorBlock Sprite_InvalidHeight
SpriteErr_InvalidWidth MakeErrorBlock Sprite_InvalidWidth
SpriteErr_NoRoomToInsert MakeErrorBlock Sprite_NoRoomToInsert
SpriteErr_SpriteAlreadyExists MakeErrorBlock Sprite_SpriteAlreadyExists
SpriteErr_InvalidSpriteMode MakeErrorBlock Sprite_InvalidSpriteMode
SpriteErr_BadReasonCode MakeErrorBlock Sprite_BadReasonCode
SpriteErr_CantInTeletext MakeErrorBlock Sprite_CantInTeletext
SpriteErr_InvalidSaveArea MakeErrorBlock Sprite_InvalidSaveArea
SpriteErr_SpriteIsCurrentDest MakeErrorBlock Sprite_SpriteIsCurrentDest
SpriteErr_NoMaskOrPaletteAllowedInThisDepth MakeErrorBlock Sprite_NoMaskOrPaletteAllowedInThisDepth
; *****************************************************************************
;
; ClearSprites - Clear sprite area (*SNEW)
;
; External routine + dropped thru to
;
ClearSprites ROUT
LDR R2, [R1, #saFirst]
STR R2, [R1, #saFree]
MOV R2, #0
STR R2, [R1,#saNumber]
LDR R0, [WsPtr, #RetnReg0] ; if rangeb or rangec
CMP R0, #RangeB
BHS DoesNowt ; exit immediately
; else its rangea, so drop thru to ...
ClearSpritePtrName ROUT
MOV R0, #0
STR R0, [WsPtr, #SpChoosePtr]
STR R0, [WsPtr, #SpChooseName]
STR R0, [WsPtr, #SpChooseName+4]
STR R0, [WsPtr, #SpChooseName+8]
MOV R0, #13
STRB R0, [WsPtr, #SpChooseName+12] ; *SChoose <null name>
DoesNowt
RETURNVC
; *****************************************************************************
;
; ReadAreaCB - Read information from sprite area CB into registers
;
; External routine
;
; in: R1 -> sprite area
;
; out: R2 = offset to end of sprite area (ie total size)
; R3 = number of sprites in area
; R4 = offset to first sprite
; R5 = offset to first free word
;
ReadAreaCB ROUT
LDMIA R1, {R2,R3,R4,R5} ; saEnd,saNumber,saFirst,saFree
ADD R11, WsPtr, #RetnReg2
STMIA R11, {R2,R3,R4,R5}
RETURNVC
; *****************************************************************************
;
; SelectSprite - Select a named sprite for use by PLOT &E8..&EF
;
; External routine + called by GetSprite
;
; in: R2 -> sprite CB
;
; out: R0, R9..R11 corrupted
; If not using system sprite area, then R2 -> address of sprite
;
SelectSprite ROUT
Push R14
LDR R0, [WsPtr, #RetnReg0] ; if not in system sprite area
CMP R0, #RangeB
STRCS R2, [WsPtr, #RetnReg2] ; return the sprite address
Pull PC, CS
STR R2, [WsPtr, #SpChoosePtr] ; else store name & address
ADD R14, R2, #spName ; for use by PLOT
LDMIA R14, {R9,R10,R11} ; load 12 bytes of name
LDR R14, =SpChooseName
ADD R14, R14, WsPtr ; RetnReg2 NOT altered, so user
STMIA R14, {R9,R10,R11} ; can't poke the workspace
Pull PC
; *****************************************************************************
;
; ReturnName - Return name of nth sprite in sprite area as a string
;
; External routine
;
; in: R1 -> sprite area
; R2 -> buffer
; R3 = max buffer length
; R4 = sprite number (n)
;
; out: R3 actual string length
; RetnReg3 updated
;
ReturnName ROUT
LDR R5, [R1, #saNumber] ; check for 1 <= R4 <= saNumber
CMP R4, #1
CMPGE R5, R4
BGE %FT05
ADRL R0, SpriteErr_DoesntExist ; out of range, so generate error
[ International
Push "lr"
BL TranslateError_VClear
Pull "lr"
]
STR R0, [WsPtr, #RetnReg0]
RETURNVS
05 LDR R5, [R1, #saFirst]
ADD R5, R5, R1 ; ptr to 1st sprite
10
SUBS R4, R4, #1
LDRNE R6, [R5, #spNext] ; if not sprite we want
ADDNE R5, R5, R6 ; chain to next one
BNE %BT10
ADD R5, R5, #spName ; found sprite, R5 -> name
SUBS R3, R3, #1
MOVLS R3, #0 ; if was 0 or 1 then set R3 to 0
STRLS R3, [WsPtr, #RetnReg3]
STREQB R3, [R2] ; if was 1 then store 0 terminator
MOVLS PC, R14 ; if was 0 or 1 then exit (assume SUB cleared V)
CMP R3, #SpriteNameSize ; if length > maximum sprite name len
MOVHI R3, #SpriteNameSize ; then limit to maximum sprite name len
; R3 is now maximum number of characters to store, excluding terminator
MOV R6, R2 ; remember start address
20
LDRB R4, [R5], #1 ; load a byte from sprite name
CMP R4, #" " ; if char > " "
STRHIB R4, [R2], #1 ; then store character and inc ptr
SUBHIS R3, R3, #1 ; and decrement character count
BHI %BT20 ; loop until char<=" " or count expired
MOV R4, #0 ; store terminating 0
STRB R4, [R2]
SUB R3, R2, R6 ; R3 = no. of characters,
STR R3, [WsPtr, #RetnReg3] ; excluding terminator
RETURNVC ; indicate no error
; *****************************************************************************
;
; RenameSprite - Rename a sprite
;
; External routine (AlreadyExists is used by CopySprite)
;
; in: R2 -> sprite
; R3 -> new name
;
RenameSprite ROUT
Push "R2, R14"
MOV R2, R3
BL GetName ; returns name in R9-R11
BL SpriteCtrlBlk ; try to find sprite of that name
BVC AlreadyExists
Pull "R2, R14"
ADD R8, R2, #spName
STMIA R8, {R9-R11}
KillSpChoosePtr ; in case it points to renamed sprite
RETURNVC
AlreadyExists ; sprite with new name already exists
Pull "R3, R14"
TEQ R2, R3 ; if it's the same one, then exit VC
RETURNVC ; (SRename/SCopy fred fred is allowed)
ADRL R0, SpriteErr_SpriteAlreadyExists
[ International
Push "lr"
BL TranslateError
Pull "lr"
]
STR R0, [WsPtr,#RetnReg0]
RETURNVS
; *****************************************************************************
;
; CopySprite - Make a copy of a sprite
;
; External routine
;
; in: R1 -> sprite area
; R2 -> sprite
; R3 -> new name
;
CopySprite ROUT
Push "R2, R14" ; save ptr to sprite to be copied
MOV R2, R3
BL GetName ; returns new name in R9-R11
BL SpriteCtrlBlk ; try to find sprite of that name
BVC AlreadyExists ; [we found one of that name]
Pull R2
LDR R8, [R1, #saFree]
ADD R8, R8, R1 ; address sprite will be copied to
ADD R8, R8, #spName ; address of its name field
BL AppendSprite ; copy it
STMVCIA R8, {R9-R11} ; if copy OK, rename it
Pull PC ; exit with V clear/set appropriately
; *****************************************************************************
;
; ReadSpriteSize - Read sprite size and other info
;
; External routine
;
; in: R2 -> sprite
;
; out: R1,R2 preserved
; R3 = width in pixels
; R4 = height in pixels
; R5 = 0/1 for solid/transparent
; R6 = mode sprite was defined in
;
; RetnReg3..RetnReg6 updated
;
ReadSpriteSize ROUT
ADD R3, R2, #spWidth
LDMIA R3, {R3,R4,R5,R6} ; spWidth,spHeight,spLBit,spRBit
ADD R4, R4, #1 ; R4 := height in pixels
ADD R3, R3, #1 ; R3 := width in words
RSB R3, R5, R3, LSL #5 ; convert to bits and sub LH wastage
SUB R3, R3, #31 ; subtract RH wastage
ADD R3, R3, R6
LDR R11, [WsPtr, #SprLog2BPC]
MOV R3, R3, LSR R11 ; number of pixels in row
LDR R5, [R2, #spImage]
LDR R6, [R2, #spTrans]
SUBS R5, R5, R6
MOVNE R5, #1 ; if spImage=spTrans then no mask
LDR R6, [R2, #spMode]
ADD R11, WsPtr, #RetnReg3
STMIA R11, {R3-R6}
RETURNVC
; *****************************************************************************
;
; ReadSpriteWidth - Read width of a sprite
;
; Internal routine, called by PlotMask, InsertCol, DeleteCol
;
; in: R2 -> sprite
;
; out: R0 = sprite width in pixels
; All other registers preserved
;
ReadSpriteWidth ROUT
Push "R4-R6, R14"
ADD R0, R2, #spWidth
LDMIA R0, {R0,R4,R5,R6} ; spWidth,spHeight,spLBit,spRBit
ADD R0, R0, #1 ; width in words
RSB R0, R5, R0, LSL #5
SUB R0, R0, #31
ADD R0, R0, R6 ; total number of bits in row
LDR R5, [WsPtr, #SprLog2BPC]
MOV R0, R0, LSR R5 ; number of pixels in row
Pull "R4-R6, PC"
; *****************************************************************************
;
; DeleteSpriteByName
;
; Internal routine, called by MergeSprite, GetSprite, CreateSprite
;
; in: R1 -> sprite area
; R2 -> name of sprite to be deleted
;
; out: All registers preserved
;
DeleteSpriteByName ROUT
Push "R2-R4, R14"
BL SpriteCtrlBlk ; R2: In , SpriteNamePtr
; Out, SpriteCBptr
BLVC DeleteSprite ; if found, then delete it
Pull "R2-R4, PC"
; *****************************************************************************
;
; DeleteSprite
;
; External routine + called by DeleteSpriteByName
;
; in: R1 -> sprite area
; R2 -> sprite
;
; out: All registers preserved
;
DeleteSprite ROUT
Push "R0, R3,R4, R14"
LDR R3, [R2, #spNext]
ADD R3, R3, R2
LDR R0, [R1, #saFree]
ADD R0, R0, R1
SUB R0, R0, R3
CopyDown R2, R3, R0, R14, R4
LDR R3, [R1, #saNumber] ; decrement sprite count
SUB R3, R3, #1
STR R3, [R1, #saNumber]
SUB R3, R2, R1 ; (R2 points to first free location)
STR R3, [R1, #saFree] ; update saFree
KillSpChoosePtr ;Because the sprites have moved
Pull "R0, R3,R4, PC"
; *****************************************************************************
;
; GetName - Read sprite name into buffer, lower cased, padded to 12 chars
;
; Internal routine, called by RenameSprite, CopySprite,
; SpriteCtrlBlk, CreateHeader
;
; in: R2 -> sprite name (terminated by char <= 32)
;
; out: Name returned in R9-R11 and NameBuf
; All other registers preserved
;
GetName ROUT
Push "R2-R5, R14"
ADD R3, WsPtr, #NameBuf
MOV R4, #SpriteNameSize
10
LDRB R5, [R2], #1
uk_LowerCase R5, R14
CMP R5, #" "
STRHIB R5, [R3], #1
SUBHIS R4, R4, #1 ; loop until char<=32 or done 12 chars
BHI %BT10
MOV R5, #0
CMP R4, #0 ; pad with 0 or more nulls
20
STRHIB R5, [R3], #1
SUBHIS R4, R4, #1
BHI %BT20
ADD R9, WsPtr, #NameBuf
LDMIA R9, {R9-R11} ; name returned in R9-R11 and NameBuf
Pull "R2-R5, PC"
; *****************************************************************************
;
; SpriteCtrlBlk - Search for control block of named sprite
;
; Internal routine, called by sprite dispatch, RenameSprite,
; CopySprite, DeleteSpriteByName
;
; in: R1 -> sprite area
; R2 -> sprite name
;
; out: V=0 => R2 -> sprite
; V=1 => sprite not found
; R2 -> first free byte (this fact not used by anyone yet)
; All other registers preserved
;
SpriteCtrlBlk ROUT
Entry "R3-R11"
ASSERT saNumber = 4
ASSERT saFirst = 8
LDMIB R1, {R4,R5} ; saNumber, saFirst
ADD R3, R5, R1 ; point to first sprite/free space
CMP R4, #0
BEQ %FT20 ; no sprites, exit with R3 pointing
; at free space and R4=0
BL GetName ; search name in R9-R11 and NameBuf
10
LDMIA R3, {R5, R6,R7,R8} ; spNext, spName(0..2)
CMP R6, R9
CMPEQ R7, R10
CMPEQ R8, R11 ; (V:=0 if equal)
BEQ %FT30 ; sprite found
ADD R3, R3, R5
SUBS R4, R4, #1 ; try next sprite
BNE %BT10
20
SETV ; indicate not found
30
MOV R2, R3 ; R2 -> sprite or to free space
EXIT
; As above, but uses source name directly without passing it through GetName
; Name must be word aligned and in correct format!
SpriteCtrlBlkNoGetName
ALTENTRY
ASSERT saNumber = 4
ASSERT saFirst = 8
LDMIB R1, {R4,R5} ; saNumber, saFirst
ADD R3, R5, R1 ; point to first sprite/free space
CMP R4, #0
BEQ %BT20 ; no sprites, exit with R3 pointing
LDMIA R2, {R9-R11}
B %BT10
LTORG
; *****************************************************************************
;
; InternaliseCoords - Convert from external to internal coords
; for sprite plotting
;
; Internal routine called by PutSpriteUserCoords, PlotMaskUserCoords
;
; in: R3 = external X coordinate
; R4 = external Y coordinate
;
; out: R3 = internal X coordinate
; R4 = internal Y coordinate
; R1, R2, R5 preserved
;
InternaliseCoords ROUT
Push "R1,R2,R5, R14"
MOV R0, R3 ; put external coordinate in R0,R1
MOV R1, R4
ADD R7, WsPtr, #GCsX
LDMIA R7, {R8,R9} ; preserve GCsX,GCsY around EIG
MOV R2, #4 ; indicate absolute coords
BL EIG
STMIA R7, {R8,R9} ; restore GcsX,GCsY
MOV R3, R0 ; internal coord of plotting point
MOV R4, R1
Pull "R1,R2,R5, PC"
; *****************************************************************************
;
; PutSpriteUserCoords - Draw sprite to screen using given ext. coords
;
; External routine
;
; in: R1 -> sprite area (not used)
; R2 -> sprite
; R3 = X coordinate to plot at
; R4 = Y coordinate to plot at
; R5 = GCOL action to be used
;
PutSpriteUserCoords ROUT
Push R14
BL InternaliseCoords
Pull R14
B PutSpri20
; *****************************************************************************
;
; PutSprite - Draw sprite to screen at NewPt
;
; External routine + PutSpri20 called by PutSpriteUserCoords
; (also external)
;
; in: R1 -> sprite area (not used)
; R2 -> sprite
; R5 = GCOL action to be used
;
; Values held in Ram
;
; N.B. The ordering of these variables is VERY important
; rearrange at your peril
;
; Within the 'memory to screen' drawing loop, WsPtr (R12) points at
; ScrAdr, variables either side being loaded/saved in groups using
; LDMDB / STMIA / LDMIB
;
; SPltWidth }
; SPltHeight }
; SPltScrOff }
; SPltMemOff } LDMDB
; WsPtr -> SPltScrAdr } STMIA
; SPltColCnt } } LDMIB
; SPltMemAdr }
; SPltShftR }
; SPltShftL }
;
; SPltMskAdr
;
; SPltLMask
; SPltRMask
;
; SPltzgooPtr
;
;
PutSprite ROUT
ASSERT NewPtY = NewPtX +4
ADD R3, WsPtr, #NewPtX
LDMIA R3, {R3, R4} ; plot sprite at NewPt(X,Y)
PutSpri20
GraphicsMode R0
BNE PutSpriNotGraphics ; quit with error if not graphics mode
Push "WsPtr, R14" ; push both so R12,R14 are free for use
Push "R2" ; save the pointer to the sprite
BL GenSpritePlotParmBlk
Pull "R11"
BVS SpriteOffScreen
SWI XOS_RemoveCursors ; assume no error can occur!
LDR R5, [WsPtr, #SPltMemAdr]
LDR R6, [WsPtr, #SPltMskAdr]
TEQ R6, #0
BEQ %FT20
ADD R6, R6, R5
STR R6, [WsPtr, #SPltMskAdr]
LDR R14, [R11, #spMode]
MOVS R8,R14,ASR #27 ; check for wide mask
BMI PutSpriWideMaskErr
TEQ R8,#SpriteType_RISCOS5
[ NoARMT2
ANDEQ R8, R14, #127<<20
MOVEQ R8, R8, LSR #20
|
UBFXEQ R8, R14, #20, #7
]
;note: new format 1bpp sprites are thrown at the old routine, since it
;will render them faster
CMP R8, #2
BCC TransPlot ; it's got transparent bits in it! (
BCS NewTransPlot ; it's got 1bpp transparent bits in it!!!
20
; Plot sprite ignoring transparency mask (if any)
ADD R11, WsPtr, #SPltzgooMasks
LDMIA R11, {R8-R11} ; masks for screen access (zgoo..zgee)
LDR R2, [WsPtr, #SPltAction] ; GCOL action
ADD WsPtr, WsPtr, #SPltScrAdr ; repoint WsPtr at SPltScrAdr
LDMIA WsPtr, {R0-R1,R5-R7}
TST R2, #7
BNE SolPl10 ; not store, do it slowly
; SimpleCase
SolPlFast10
; R0 ,R1 , R5 ,R6 ,R7 ,(R8 ,R9 ,R10 ,R11 )
; ScrAdr,ColCnt, MemAdr,ShftR,ShftL,(zgoo,zgeo,zgoe,zgee)
; Plot the first (leftmost) word
LDMIA R5, {R2,R3}
ADD R5, R5, #4
ShiftR R2,R3, R6,R7 ; shift R3,R2 right R6 places
; we only need result word R2
LDR R4, [WsPtr, #SPltLMask-SPltScrAdr] ; on leftmost word
AND R3, R2, R4 ; mask down to just the required pixels
[ AvoidScreenReads
CMP R4, #&FFFFFFFF
LDRNE R2, [R0] ; plot 1 word
BICNE R2, R2, R4 ; knock out mask bits
ORRNE R3, R2, R3 ; and or sprite bits
|
LDR R2, [R0] ; plot 1 word
BIC R2, R2, R4 ; knock out mask bits
ORR R3, R2, R3 ; and or sprite bits
]
STR R3, [R0], #4
SUBS R1, R1, #1
BLT SolPlFast50 ; if all plotted, try next scanline
; else try for blocks of 7
SUBS R1, R1, #7
BLT SolPlFast30
TEQ R6, #0 ; if shift needed, use loop 20
BNE SolPlFast20 ; else loop 15
SolPlFast15
; R0 ,R1 ,R5
; ScrAdr,ColCnt, ,MemAdr
LDMIA R5!, {R2-R4,R8-R11} ; read 7 words
STMIA R0!, {R2-R4,R8-R11} ; write 7 words back to screen
SUBS R1, R1, #7
BGE SolPlFast15
B SolPlFast30
SolPlFast20
; R0 ,R1 ,R5 ,R6 ,R7
; ScrAdr,ColCnt, ,MemAdr,ShftR,ShftL
LDMIA R5, {R2-R4,R8-R11,R14} ; 8 words needed, gives 7 after shift
ADD R5, R5, #7*4 ; advance source ptr 7 words
ShiftR R2,R3, R6,R7 ; shift right R6 bits
ShiftR R3,R4, R6,R7 ; we only want result words
ShiftR R4,R8, R6,R7 ; R2-R4, R8-R11
ShiftR R8,R9, R6,R7
ShiftR R9,R10, R6,R7
ShiftR R10,R11, R6,R7
ShiftR R11,R14, R6,R7
STMIA R0!, {R2-R4,R8-R11} ; write 7 words back to screen
SUBS R1, R1, #7
BGE SolPlFast20
SolPlFast30 ; try 1 word at a time
ADDS R1, R1, #7
; R0 ,R1 , R5 ,R6 ,R7
; ScrAdr,ColCnt, MemAdr,ShftR,ShftL
; If EQ this is rightmost word
SolPlFast40
LDMIA R5, {R2,R3}
ADD R5, R5, #4
ShiftR R2,R3, R6,R7 ; shift R3,R2 right R6 places
; we only need result word R2
BEQ SolPlFast45 ; if rightmost word, jump out.
STR R2, [R0], #4
SUBS R1, R1, #1
B SolPlFast40
SolPlFast45
LDR R4, [WsPtr, #SPltRMask-SPltScrAdr]
AND R3, R2, R4 ; mask down to just the required pixels
[ AvoidScreenReads
CMP R4, #&FFFFFFFF
LDRNE R2, [R0] ; plot 1 word
BICNE R2, R2, R4 ; knock out mask bits
ORRNE R3, R2, R3 ; and or sprite bits
|
LDR R2, [R0] ; plot 1 word
BIC R2, R2, R4 ; knock out mask bits
ORR R3, R2, R3 ; and or sprite bits
]
STR R3, [R0], #4
SolPlFast50 ; now try the next scanline
LDMDB WsPtr, {R1,R2,R3,R4} ; R1 ,R2 ,R3 ,R4
; Width,Height,ScrOff,MemOff
ADD R0, R0, R3
ADD R5, R5, R4
SUBS R2, R2, #1
STRGE R2, [WsPtr, #SPltHeight-SPltScrAdr]
BGE SolPlFast10 ; plot next scanline
ComplicatedExit
SWI XOS_RestoreCursors
SpriteOffScreen
Pull "WsPtr, R14"
RETURNVC
PutSpriWideMaskErr
; Not supported!
SWI XOS_RestoreCursors
Pull "WsPtr, R14"
PutSpriWideMaskErr2
ADRL R0, SpriteErr_InvalidSpriteMode
B %FT90
PutSpriNotGraphics
ADRL R0, SpriteErr_NotGraphics
90
[ International
Push "lr"
BL TranslateError
Pull "lr"
]
STR R0, [WsPtr, #RetnReg0]
RETURNVS
; Complicated case
SolPl10 ROUT
; R0 ,R1 , R5 ,R6 ,R7 ,R8 ,R9 ,R10 ,R11
; ScrAdr,ColCnt, MemAdr,ShftR,ShftL,zgoo,zgeo,zgoe,zgee
; Plot the first (leftmost) word
LDMIA R5, {R2,R3}
ADD R5, R5, #4
ShiftR R2,R3, R6,R7 ; shift R3,R2 right R6 places
; we only need result word R2
OrrEor R3,R2, R10,R11 ; form EOR mask
OrrEor R2,R2, R8,R9 ; form OR mask
LDR R4, [WsPtr, #SPltLMask-SPltScrAdr] ; on leftmost word
AND R2, R2, R4 ; mask down to just the required pixels
AND R3, R3, R4
LDR R4, [R0] ; plot 1 word
OrrEor R4,R4, R2,R3
STR R4, [R0], #4
SUBS R1, R1, #1
BLT SolPl50 ; if all plotted, try next scanline
; else try for blocks of 4
SUBS R1, R1, #4
BLT SolPl30
SolPl20
STMIA WsPtr, {R0,R1} ; save ScrAdr,ColCnt
; R0 ,R1 ,R5 ,R6 ,R7 ,R8 ,R9 ,R10 ,R11
; ScrAdr,ColCnt, ,MemAdr,ShftR,ShftL,zgoo,zgeo,zgoe,zgee
LDMIA R5, {R0-R4} ; 5 words needed, gives 4 after shift
ADD R5, R5, #16 ; advance source ptr 4 words
STR R5, [WsPtr, #SPltMemAdr-SPltScrAdr]
ShiftR R0,R1, R6,R7 ; shift R4-R0 right R6 bits
ShiftR R1,R2, R6,R7 ; we only want result words R3-R0
ShiftR R2,R3, R6,R7
ShiftR R3,R4, R6,R7
LDR R4, [WsPtr] ; get screen address
LDMIA R4, {R4-R7} ; get 4 screen words
ORoreorEORoreor R4,R0, R8,R9,R10,R11, R14
ORoreorEORoreor R5,R1, R8,R9,R10,R11, R14
ORoreorEORoreor R6,R2, R8,R9,R10,R11, R14
ORoreorEORoreor R7,R3, R8,R9,R10,R11, R14
LDR R0, [WsPtr] ; screen address
STMIA R0!, {R4-R7} ; write 4 words back to screen
LDMIB WsPtr, {R1,R5-R7} ; reload anything we shat on
SUBS R1, R1, #4
BGE SolPl20
SolPl30 ; try 1 word at a time
ADDS R1, R1, #4
; R0 ,R1 , R5 ,R6 ,R7 ,R8 ,R9 ,R10 ,R11
; ScrAdr,ColCnt, MemAdr,ShftR,ShftL,zgoo,zgeo,zgoe,zgee
; If EQ this is rightmost word
SolPl40
LDMIA R5, {R2,R3}
ADD R5, R5, #4
ShiftR R2,R3, R6,R7 ; shift R3,R2 right R6 places
; we only need result word R2
OrrEor R3,R2, R10,R11 ; form EOR mask
OrrEor R2,R2, R8,R9 ; form OR
LDREQ R4, [WsPtr, #SPltRMask-SPltScrAdr] ; if rightmost word,
ANDEQ R2, R2, R4 ; mask down to just the
ANDEQ R3, R3, R4 ; required pixels
LDR R4, [R0]
OrrEor R4,R4, R2,R3
STR R4, [R0], #4
SUBS R1, R1, #1
BGE SolPl40
SolPl50 ; now try the next scanline
LDMDB WsPtr, {R1,R2,R3,R4} ; R1 ,R2 ,R3 ,R4
; Width,Height,ScrOff,MemOff
ADD R0, R0, R3
ADD R5, R5, R4
SUBS R2, R2, #1
STRGE R2, [WsPtr, #SPltHeight-SPltScrAdr]
BGE SolPl10 ; plot next scanline
B ComplicatedExit
; *****************************************************************************
;
; NewTransPlot - Plot sprite using 1 bpp transparency mask
; Called with R11 -> sprite, R8 = sprite type
; TransPlot is used for 1bpp new sprites since it will be faster
NewTransPlot ROUT
; need to derive: bpp, and 1<<(5-log2bpp)
ADRL R0, NSM_bpptable-4
LDR R10, [R0, R8, LSL #2] ; get the log2bpp to R10
;R10=log2bpp, R11=>sprite
LDR R8, [R11, #spWidth] ; words-1
ADD R9, R8, #1
MOV R9, R9, LSL #2 ; number of bytes per row
STR R9, [WsPtr, #SPltMaskRowPtr]
LDR R9, [R11, #spRBit] ; last bit used
ADD R9, R9, #1 ; change to number of bits
MOV R9, R9, LSR R10 ; number of pixels
RSB R0, R10, #5
MOV R8, R8, LSL R0 ; number of pixels for full words
ADD R8, R8, R9 ; total number of pixels
ANDS R9, R8, #&1F
MOVNE R9, #4
BIC R8, R8, #&1F
ADD R9, R9, R8, LSR #3 ; number of bytes per mask row
STR R9, [WsPtr, #SPltMaskRowLen]
LDR R8, [R11, #spImage]
LDR R9, [R11, #spTrans]
ADD R8, R8, R11
ADD R9, R9, R11
;RSB R0, R10, #5 <- DONE ABOVE
MOV R1, #1
MOV R2, R1, LSL R0 ; r2 holds number of pixels per word
MOV R3, R1, LSL R10 ; r3 holds bits per pixel
ADD WsPtr, WsPtr, #SPltScrAdr ; repoint WsPtr, at SPltScrAdr
LDMIA WsPtr, {R0-R1,R5-R7,R14}
STR R2, [WsPtr, #SPltPixPerWord-SPltScrAdr]
STR R3, [WsPtr, #SPltBPP-SPltScrAdr]
; sort out where to begin in 1bpp mask (rewritten Aug '93)
MOV LR, R9 ; LR = mask pointer
MOV R3, #0 ; R3 = mask bit
CMP R5, R8 ; R5=>data to plot, R8=>start of sprite
BEQ %FT11 ; nothing to do, go store R3 & LR
BCC %FT13 ; start is before sprite data
;R3, R9, r10, R11 free
;R2 comes in holding pix per word
;if R6 is non zero the image will be a word early.
MOV R9, R5 ; working copy of pointer within sprite
CMP R6, #0
ADDNE R9, R9, #4 ; take out the extra word for now
LDR R11,[WsPtr, #SPltMaskRowLen-SPltScrAdr] ; bytes per mask row
SUBS R10, R9, R8 ; difference in bytes
LDR R8,[WsPtr, #SPltMaskRowPtr-SPltScrAdr] ; loaded with bytes per image row
BEQ %FT13
14
;is it less than a row of data
CMP R10, R8
BCC %FT12 ; yes it is
;deal with a row (or more of data)
SUB R10, R10, R8
ADD LR, LR, R11
B %BT14
12 ;start point is on this row. subtract 4 from difference and add
;pix per word to mask bit/ptr until diff=0
CMP R10, #0
BEQ %FT13
SUB R10, R10, #4
ADD R3, R3, R2
CMP R3, #32
SUBCS R3, R3, #32
ADDCS LR, LR, #4
CMP R10, #0
BNE %BT12
13
;deal with R6
CMP R6,#0
BEQ %FT11
SUBS R3, R3, R2 ;subtract pix per word
ADDMI R3, R3, #32
SUBMI LR, LR, #4 ;deal with going into previous word
11
STR R3, [WsPtr, #SPltMaskBit-SPltScrAdr]
STR LR, [WsPtr, #SPltMaskPtr-SPltScrAdr]
; and save it for the end of row increments
STR R3, [WsPtr, #SPltMaskRowBit-SPltScrAdr]
STR LR, [WsPtr, #SPltMaskRowPtr-SPltScrAdr]
ADD R11, WsPtr, #SPltzgooMasks-SPltScrAdr
LDMIA R11, {R8-R11} ; masks for screen access (zgoo..zgee)
NTrnPl10
; R0 ,R1 , R5 ,R6 ,R7 ,R8 ,R9 ,R10 ,R11, R14
; ScrAdr,ColCnt, MemAdr,ShftR,ShftL,zgoo,zgeo,zgoe,zgee,
;
; As far as possible this is based on the original transplot.
;
; Plot the first (leftmost) word
BL getmaskword
MOV R2, R3
BL getmaskword_noinc
ShiftR R2,R3, R6,R7 ; we only need result word R2
LDMIA R5, {R3,R4} ; fetch and shift image
ADD R5, R5, #4
ShiftR R3,R4, R6,R7 ; shift R4,R3 right R6 places
OrrEor R4,R3, R10,R11 ; form EOR mask
OrrEor R3,R3, R8,R9 ; form OR mask
AND R3, R3, R2 ; clear out any transparent pixels
AND R4, R4, R2
LDR R2, [WsPtr, #SPltLMask-SPltScrAdr] ; on leftmost word
AND R3, R3, R2 ; mask down to just the required pixels
AND R4, R4, R2
LDR R2, [R0] ; plot 1 word
OrrEor R2,R2, R3,R4
STR R2, [R0], #4
SUBS R1, R1, #1
BLT NTrnPl50 ; if all plotted, try next scanline
; else try for blocks of 2
SUBS R1, R1, #2
BLT NTrnPl30
NTrnPl20
STMIA WsPtr, {R0,R1} ; ScrAdr,ColCnt
; R0 ,R1 ,R5 ,R6 ,R7 ,R8 ,R9 ,R10 ,R11 , R14
; ScrAdr,ColCnt, ,MemAdr,ShftR,ShftL,zgoo,zgeo,zgoe,zgee, MskAdr
BL getmaskword
MOV R0, R3
BL getmaskword
MOV R1, R3
BL getmaskword_noinc
MOV R2, R3
ShiftR R0,R1, R6,R7
ShiftR R1,R2, R6,R7 ; aligned mask in R0,R1
LDMIA R5, {R2-R4} ; 3 image words needed, gives 2 after
ADD R5, R5, #8 ; shifting
STR R5, [WsPtr, #SPltMemAdr-SPltScrAdr]
ShiftR R2,R3, R6,R7
ShiftR R3,R4, R6,R7 ; aligned image in R2,R3
LDR R4, [WsPtr] ; screen address
LDMIA R4, {R4,R5} ; 2 screen words
ORoreorEORoreorMASK R4,R2,R0, R8,R9,R10,R11, R14
ORoreorEORoreorMASK R5,R3,R1, R8,R9,R10,R11, R14
LDR R0, [WsPtr] ; screen address
STMIA R0!, {R4,R5} ; write 2 words back to screen
LDMIB WsPtr, {R1,R5,R6} ; reload anything we shat on
SUBS R1, R1, #2
BGE NTrnPl20
NTrnPl30 ; try 1 word at a time
ADDS R1, R1, #2
; R0 ,R1 , R5 ,R6 ,R7 ,R8 ,R9 ,R10 ,R11
; ScrAdr,ColCnt, MemAdr,ShftR,ShftL,zgoo,zgeo,zgoe,zgee
; If EQ this is rightmost word
NTrnPl40
BL getmaskword
MOV R2, R3
BL getmaskword_noinc
ShiftR R2,R3, R6,R7 ; shift R3,R2 right R6 places, result in R2
LDMIA R5, {R3,R4} ; fetch and align image
ADD R5, R5, #4
ShiftR R3,R4, R6,R7 ; shift R4,R3 right R6 places, result in R3
OrrEor R4,R3, R10,R11 ; form EOR mask
OrrEor R3,R3, R8,R9 ; form OR
AND R3, R3, R2 ; clear out transparant pixels
AND R4, R4, R2
LDREQ R2, [WsPtr, #SPltRMask-SPltScrAdr] ; if rightmost word,
ANDEQ R3, R3, R2 ; mask down to just the
ANDEQ R4, R4, R2 ; required pixels
LDR R2, [R0]
OrrEor R2,R2, R3,R4
STR R2, [R0], #4
SUBS R1, R1, #1
BGE NTrnPl40
NTrnPl50
; now try the next scanline
; BEWARE ... genspriteplotparmblock returns values for memoff and
; scroff which take account of alignment of screen and sprite data
;
; Do not alter the logic below unless you really know what
; to expect from this routine!!
LDR LR, [WsPtr, #SPltMaskRowPtr-SPltScrAdr]
LDR R3, [WsPtr, #SPltMaskRowBit-SPltScrAdr]
LDR R2, [WsPtr, #SPltMaskRowLen-SPltScrAdr]
ADD LR, LR, R2
STR LR, [WsPtr, #SPltMaskPtr-SPltScrAdr]
STR R3, [WsPtr, #SPltMaskBit-SPltScrAdr]
STR LR, [WsPtr, #SPltMaskRowPtr-SPltScrAdr]
STR R3, [WsPtr, #SPltMaskRowBit-SPltScrAdr]
LDMDB WsPtr, {R1,R2,R3,R4} ; R1 ,R2 ,R3 ,R4
; Width,Height,ScrOff,MemOff
ADD R0, R0, R3
ADD R5, R5, R4
SUBS R2, R2, #1
STRGE R2, [WsPtr, #SPltHeight-SPltScrAdr]
BGE NTrnPl10 ; plot next scanline
SWI XOS_RestoreCursors
Pull "WsPtr, R14"
RETURNVC
; get a mask word without incrementing the pointers
getmaskword_noinc ROUT
Push "R4, R5, LR"
LDR R4, [WsPtr, #SPltMaskBit-SPltScrAdr]
LDR R5, [WsPtr, #SPltMaskPtr-SPltScrAdr]
BL getmaskword ; preserves flags
STR R4, [WsPtr, #SPltMaskBit-SPltScrAdr]
STR R5, [WsPtr, #SPltMaskPtr-SPltScrAdr]
LDMFD R13!,{R4,R5,R15} ; must preserve flags
; get a mask word, and increment pointers
getmaskword ROUT
Push "R2,R4,R5,R6,R7,R8,R14"
MRS R8, CPSR
;R6 -> mask
;R7 = bit offset
;return in R3, update R6, R7, restore other registers
MOV R3, #0 ; initial result
LDR LR, [WsPtr, #SPltPixPerWord-SPltScrAdr] ; pixels per word
LDR R2, [WsPtr, #SPltBPP-SPltScrAdr] ; bpp
LDR R7, [WsPtr, #SPltMaskBit-SPltScrAdr]
LDR R6, [WsPtr, #SPltMaskPtr-SPltScrAdr]
LDR R4, [R6] ; get the mask word
10
CMP R7, #0
LDREQ R4, [R6] ; fetch a new word if required
MOV R5, R4, LSR R7 ; shift desired bit down to bit 0
MOV R3, R3, LSR #1 ; shift down the result by one bit
ORR R3, R3, R5, LSL #31 ; and put bit 0 in at bit 31
; now use an ASR of bpp-1 to finish off
SUB R5, R2, #1
MOV R3, R3, ASR R5
ADD R7, R7, #1 ; next mask bit
CMP R7, #32 ; on to next word ?
ADDEQ R6, R6, #4 ; increment mask word pointer
MOVEQ R7, #0 ; bit pointer back to 0
; but don't fetch new word until it is needed!
SUBS LR, LR, #1 ; one pixel done
BNE %BT10
STR R7, [WsPtr, #SPltMaskBit-SPltScrAdr]
STR R6, [WsPtr, #SPltMaskPtr-SPltScrAdr]
;result in R3, MaskBit/MaskPtr adjusted
MSR CPSR_f, R8
LDMFD R13!,{R2,R4,R5,R6,R7,R8,R15} ; must save flags
LTORG
; *****************************************************************************
;
; TransPlot - Plot sprite using transparency mask
;
TransPlot
ADD R11, WsPtr, #SPltzgooMasks
LDMIA R11, {R8-R11} ; masks for screen access (zgoo..zgee)
ADD WsPtr, WsPtr, #SPltScrAdr ; repoint WsPtr, at SPltScrAdr
LDMIA WsPtr, {R0-R1,R5-R7,R14}
TrnPl10
; R0 ,R1 , R5 ,R6 ,R7 ,R8 ,R9 ,R10 ,R11, R14
; ScrAdr,ColCnt, MemAdr,ShftR,ShftL,zgoo,zgeo,zgoe,zgee, MskAdr
; Plot the first (leftmost) word
LDMIA R14, {R2,R3} ; fetch and shift mask right R6 places
ADD R14, R14, #4
ShiftR R2,R3, R6,R7 ; we only need result word R2
LDMIA R5, {R3,R4} ; fetch and shift image
ADD R5, R5, #4
ShiftR R3,R4, R6,R7 ; shift R4,R3 right R6 places
; we only need result word R3
OrrEor R4,R3, R10,R11 ; form EOR mask
OrrEor R3,R3, R8,R9 ; form OR mask
AND R3, R3, R2 ; clear out any transparent pixels
AND R4, R4, R2
LDR R2, [WsPtr, #SPltLMask-SPltScrAdr] ; on leftmost word
AND R3, R3, R2 ; mask down to just the required pixels
AND R4, R4, R2
LDR R2, [R0] ; plot 1 word
OrrEor R2,R2, R3,R4
STR R2, [R0], #4
SUBS R1, R1, #1
BLT TrnPl50 ; if all plotted, try next scanline
; else try for blocks of 2
SUBS R1, R1, #2
BLT TrnPl30
TrnPl20
STMIA WsPtr, {R0,R1} ; ScrAdr,ColCnt
; R0 ,R1 ,R5 ,R6 ,R7 ,R8 ,R9 ,R10 ,R11 , R14
; ScrAdr,ColCnt, ,MemAdr,ShftR,ShftL,zgoo,zgeo,zgoe,zgee, MskAdr
LDMIA R14, {R0-R2} ; 3 mask words, gives 2 after shifting
ADD R14, R14, #8 ; advance mask ptr 2 words
ShiftR R0,R1, R6,R7
ShiftR R1,R2, R6,R7 ; aligned mask in R0,R1
LDMIA R5, {R2-R4} ; 3 image words needed, gives 2 after
ADD R5, R5, #8 ; shifting
STR R5, [WsPtr, #SPltMemAdr-SPltScrAdr]
ShiftR R2,R3, R6,R7
ShiftR R3,R4, R6,R7 ; aligned image in R2,R3
LDR R4, [WsPtr] ; screen address
LDMIA R4, {R4,R5} ; 2 screen words
ORoreorEORoreorMASK R4,R2,R0, R8,R9,R10,R11, R6
ORoreorEORoreorMASK R5,R3,R1, R8,R9,R10,R11, R6
LDR R0, [WsPtr] ; screen address
STMIA R0!, {R4,R5} ; write 2 words back to screen
LDMIB WsPtr, {R1,R5-R6} ; reload anything we shat on
SUBS R1, R1, #2
BGE TrnPl20
TrnPl30 ; try 1 word at a time
ADDS R1, R1, #2
; R0 ,R1 , R5 ,R6 ,R7 ,R8 ,R9 ,R10 ,R11
; ScrAdr,ColCnt, MemAdr,ShftR,ShftL,zgoo,zgeo,zgoe,zgee
; If EQ this is rightmost word
TrnPl40
LDMIA R14, {R2,R3} ; fetch and align trans mask
ADD R14, R14, #4
ShiftR R2,R3, R6,R7 ; shift R3,R2 right R6 places, result in R2
LDMIA R5, {R3,R4} ; fetch and align image
ADD R5, R5, #4
ShiftR R3,R4, R6,R7 ; shift R4,R3 right R6 places, result in R3
OrrEor R4,R3, R10,R11 ; form EOR mask
OrrEor R3,R3, R8,R9 ; form OR
AND R3, R3, R2 ; clear out transparant pixels
AND R4, R4, R2
LDREQ R2, [WsPtr, #SPltRMask-SPltScrAdr] ; if rightmost word,
ANDEQ R3, R3, R2 ; mask down to just the
ANDEQ R4, R4, R2 ; required pixels
LDR R2, [R0]
OrrEor R2,R2, R3,R4
STR R2, [R0], #4
SUBS R1, R1, #1
BGE TrnPl40
TrnPl50 ; now try the next scanline
LDMDB WsPtr, {R1,R2,R3,R4} ; R1 ,R2 ,R3 ,R4
; Width,Height,ScrOff,MemOff
ADD R0, R0, R3
ADD R5, R5, R4
ADD R14, R14, R4
SUBS R2, R2, #1
STRGE R2, [WsPtr, #SPltHeight-SPltScrAdr]
BGE TrnPl10 ; plot next scanline
SWI XOS_RestoreCursors
Pull "WsPtr, R14"
RETURNVC
LTORG
; *****************************************************************************
;
; PlotMaskUserCoords - Draw a rectangle through a sprite mask
; using given external coordinates
;
; External routine
;
; in: R1 -> sprite area (not used)
; R2 -> sprite
; R3 = X coordinate to plot at
; R4 = Y coordinate to plot at
;
PlotMaskUserCoords ROUT
Push R14
BL InternaliseCoords
Pull R14
B PlotMa20
; *****************************************************************************
;
; PlotNewMask
;
; Version of PlotMask for new 1bpp format sprites
;
; R0 = sprite mode word
; R2 -> sprite
; R10 = bits 27-31 of mode word
PlotNewMask ROUT
TEQ R10, #SpriteType_RISCOS5
[ NoARMT2
ANDEQ R10, R0, #127<<20
MOVEQ R10, R10, LSR #20
|
UBFXEQ R10, R0, #20, #7
]
ADRL R0, NSM_bpptable-4
LDR R10, [R0, R10, LSL #2] ;get the log2bpp
;derive mask row length
;r10=log2bpp, r2=>sprite
LDR R8, [R2, #spWidth] ; words-1
ADD R9, R8, #1 ; total words for a line of image
MOV R9, R9, LSL #2 ; total bytes for a line of image
STR R9, [WsPtr, #SPltMaskRowPtr]
; save it for determining mask start position
LDR R9, [R2, #spRBit] ; last bit used
ADD R9, R9, #1 ; change to number of bits
MOV R9, R9, LSR R10 ; number of pixels
RSB R0, R10, #5
MOV R8, R8, LSL R0 ; number of pixels for full words
ADD R8, R8, R9 ; total number of pixels
ANDS R9, R8, #&1F
MOVNE R9, #4
BIC R8, R8, #&1F
ADD R9, R9, R8, LSR #3 ; number of bytes per mask row
STR R9, [WsPtr, #SPltMaskRowLen]
MOV R1, #1
MOV R0, R1, LSL R0 ;number of pixels
MOV R6, R1, LSL R10 ;bits per pixel
STR R0, [WsPtr, #SPltPixPerWord]
STR R6, [WsPtr, #SPltBPP]
LDR R0, [R2, #spHeight]
ADD R0, R0, R4
LDR R10, [WsPtr, #GWTRow]
Least R0, R0, R10 ; top scanline within window
LDR R10, [WsPtr, #YWindLimit]
SUB R0, R10, R0 ; flip Y
AND R0, R0, #7
STR R0, [WsPtr, #SPltEcfIndx] ; index into Ecf
ADD R0, WsPtr, R0, LSL #3
ADD R0, R0, #BgEcfOraEor
STR R0, [WsPtr, #SPltEcfPtr] ; ptr to ECF for highest row plotted
;STR R2, [WsPtr, #SPltMaskRowPtr] ;temp, to save it
LDR R8, [R2, #spImage]
LDR R9, [R2, #spTrans]
ADD R8, R8, R2
ADD R9, R9, R2
Push "WsPtr, R14" ; push both so R12,R14 are free for use
Push "R2"
BL GenSpritePlotParmBlk
Pull "R2"
BVS SpriteOffScreen
SWI XOS_RemoveCursors ; assume no error can occur!
;LDR R2, [WsPtr, #SPltMaskRowPtr] ;recover pointer to sprite
LDR R8, [R2, #spImage] ;offset to image
LDR R9, [R2, #spTrans] ;offset to mask
ADD R8, R8, R2 ;change to address of image
ADD R9, R9, R2 ;change to address of mask
LDR R5, [WsPtr, #SPltMemAdr] ;start memory address to plot
LDR LR, [WsPtr, #SPltMskAdr] ;start mask address to plot
TEQ LR, #0 ;off screen ?
BEQ SpriteOffScreen ;so plot nothing
;amg 19/1/94 rip out the original algorithm and replace it with the correct one
;used with newtransplot which correctly handles genspriteplotparmblk's oddities
;now deal with sprites where we aren't starting
;at the beginning....
LDR R2, [WsPtr, #SPltPixPerWord] ;pick up pixels per word
MOV LR, R9 ;save mask address
MOV R3, #0 ;set mask pixel counter to 0
CMP R5, R8 ;memory address to plot from = image address ?
BEQ %FT11 ;yes - no fudging needed
BCC %FT13
MOV R9, R5 ;working copy of plot start within sprite
CMP R6, #0
ADDNE R9, R9, #4 ;take out the extra word for now
LDR R11, [WsPtr, #SPltMaskRowLen] ;bytes per mask row
SUBS R10, R9, R8 ;difference between plot start & sprite start
LDR R8, [WsPtr, #SPltMaskRowPtr] ;bytes per image row
BEQ %FT13 ;no difference
14
;is it less than a row of data different ?
CMP R10, R8
BCC %FT12 ;yes, it is
;deal with whole rows
SUB R10, R10, R8 ;decrease difference by size of image row
ADD LR, LR, R11 ;increase mask pointer by size of mask row
B %BT14 ;and loop until less than a row to do
12 ;start pointer is on this row. reduce the difference and increase the mask start
;point until they match
CMP R10, #0 ;check for nothing to do
BEQ %FT13
SUB R10, R10, #4 ;reduce image by a word
ADD R3, R3, R2 ;increase mask start pixel by the number of
;pixels in that word
CMP R3, #32
SUBCS R3, R3, #32
ADDCS LR, LR, #4 ;get the mask bit back into a word's worth
CMP R10, #0 ;extra test down here to avoid taking two
BNE %BT12 ;branches
13 ;remember R6 ? uncompensate now
CMP R6, #0
BEQ %FT11
SUBS R3, R3, R2 ;go back by the number of pixels in a word
ADDMI R3, R3, #32
SUBMI LR, LR, #4 ;deal with going back into previous mask word
11
STR R3, [WsPtr, #SPltMaskBit] ;starting mask bit to plot
STR LR, [WsPtr, #SPltMaskPtr] ;starting mask word to plot
; and save it for the end of row increments
STR R3, [WsPtr, #SPltMaskRowBit]
STR LR, [WsPtr, #SPltMaskRowPtr]
STR LR, [WsPtr, #SPltMskAdr]
STR LR, [WsPtr, #SPltMemAdr]
ADD WsPtr, WsPtr, #SPltScrAdr ; repoint WsPtr at SPltScrAdr
LDMIA WsPtr, {R0-R1,R5-R7}
LDR R5, [WsPtr, #SPltMaskPtr-SPltScrAdr]
LDR R8, [WsPtr, #SPltEcfPtr-SPltScrAdr]
10
LDMIA R8, {R8,R9} ; ora,eor for this row
; R0 ,R1 , R5 ,R6 ,R7 ,R8 ,R9
; ScrAdr,ColCnt, MemAdr,ShftR,ShftL,ora,eor
; Plot the first (Leftmost) word
BL getmaskword
MOV R2, R3
BL getmaskword_noinc
ShiftR R2,R3, R6,R7 ; shift R3,R2 right R6 places
; we only need result word R2
LDR R10, [WsPtr, #SPltLMask-SPltScrAdr] ; on leftmost word
AND R2, R2, R10 ; mask down to just the required pixels
LDR R4, [R0] ; plot 1 word
OrrEorMASK R4,R2, R8,R9, R14
STR R4, [R0], #4
SUBS R1, R1, #1
BLT %FT50 ; if all plotted, try next scanline
; else try for blocks of 4
SUBS R1, R1, #4
BLT %FT30
20
STMIA WsPtr, {R0,R1} ; save ScrAdr,ColCnt
; R0 ,R1 ,R5 ,R6 ,R7
; ScrAdr,ColCnt, ,MemAdr,ShftR,ShftL
BL getmaskword
MOV R0, R3
BL getmaskword
MOV R1, R3
BL getmaskword
MOV R2, R3
BL getmaskword
MOV R8, R3
BL getmaskword_noinc
MOV R4,R3
MOV R3,R8
ShiftR R0,R1, R6,R7 ; shift R4-R0 right R6 bits
ShiftR R1,R2, R6,R7 ; we only want result words R3-R0
ShiftR R2,R3, R6,R7
ShiftR R3,R4, R6,R7
LDR R4, [WsPtr] ; get screen address
LDMIA R4, {R8-R11} ; get 4 screen words
LDR R6, [WsPtr, #SPltEcfPtr-SPltScrAdr]
LDMIA R6, {R6,R7} ; ora,eor for this row
OrrEorMASK R8,R0, R6,R7, R14 ; Scr:=ScrOR(oraANDmsk)EOR(eorANDmsk)
OrrEorMASK R9,R1, R6,R7, R14
OrrEorMASK R10,R2, R6,R7, R14
OrrEorMASK R11,R3, R6,R7, R14
LDR R0, [WsPtr] ; screen address
STMIA R0!, {R8-R11} ; write 4 words back to screen
LDMIB WsPtr, {R1,R5-R7} ; reload anything we shat on
SUBS R1, R1, #4
BGE %BT20
30 ; try 1 word at a time
ADDS R1, R1, #4
; R0 ,R1 , R5 ,R6 ,R7 ,R8 ,R9
; ScrAdr,ColCnt, MemAdr,ShftR,ShftL,ora,eor
; If EQ this is rightmost word
LDR R8, [WsPtr, #SPltEcfPtr-SPltScrAdr]
LDMIA R8, {R8,R9} ; ora,eor for this row
LDR R10, [WsPtr, #SPltRMask-SPltScrAdr]
40
BL getmaskword
MOV R2, R3
BL getmaskword_noinc
ShiftR R2,R3, R6,R7 ; shift R3,R2 right R6 places, result in R2
; we only need result word R2
ANDEQ R2, R2, R10 ; if rightmost word, mask down to just the
; required pixels
LDR R4, [R0]
OrrEorMASK R4,R2, R8,R9, R14
STR R4, [R0], #4
SUBS R1, R1, #1
BGE %BT40
50 ; now try the next scanline
; BEWARE ... genspriteplotparmblock returns values for memoff and
; scroff which take account of alignment of screen and sprite data
;
; Do not alter the logic below unless you really know what
; to expect from this routine!!
LDMDB WsPtr, {R1,R2,R3,R4} ; R1 ,R2 ,R3 ,R4
; Width,Height,ScrOff,MemOff
LDR LR, [WsPtr, #SPltMaskRowPtr-SPltScrAdr]
LDR R3, [WsPtr, #SPltMaskRowBit-SPltScrAdr]
LDR R2, [WsPtr, #SPltMaskRowLen-SPltScrAdr]
ADD LR, LR, R2
STR LR, [WsPtr, #SPltMaskPtr-SPltScrAdr]
STR R3, [WsPtr, #SPltMaskBit-SPltScrAdr]
STR LR, [WsPtr, #SPltMaskRowPtr-SPltScrAdr]
STR R3, [WsPtr, #SPltMaskRowBit-SPltScrAdr]
LDMDB WsPtr, {R1,R2,R3,R4} ; R1 ,R2 ,R3 ,R4
; Width,Height,ScrOff,MemOff
ADD R0, R0, R3
ADD R10, WsPtr, #(SPltEcfPtr-SPltScrAdr)
LDMIA R10, {R8,R9} ; EcfPtr,EcfIndx
ADD R8, R8, #8 ; step both to next row in Ecf
ADD R9, R9, #1
CMP R9, #8
MOVGE R9, #0 ; it's a wrap!
SUBGE R8, R8, #(8*8)
STMIA R10, {R8,R9}
SUBS R2, R2, #1
STRGE R2, [WsPtr, #SPltHeight-SPltScrAdr]
BGE %BT10 ; plot next scanline
SWI XOS_RestoreCursors
Pull "WsPtr, R14"
RETURNVC
; *****************************************************************************
;
; PlotMask - Draw a rectangle through a sprite mask
;
; External routine + PlotMa20 called by PlotMaskUserCoords
; (also external)
;
; in: R1 -> sprite area (not used)
; R2 -> sprite
;
PlotMask ROUT
ASSERT NewPtY = NewPtX +4
ADD R3, WsPtr, #NewPtX
LDMIA R3, {R3, R4} ; plot sprite at NewPt(X,Y)
PlotMa20
GraphicsMode R0
BNE PutSpriNotGraphics ; quit with error if not graphics mode
LDR R5, [WsPtr, #GPLBMD] ; background GCOL action
ORR R5, R5, #8 ; force 'use mask'
LDR R10, [R2, #spImage]
LDR R11, [R2, #spTrans]
TEQ R10, R11 ; spImage=spTrans if no mask
BEQ %FT90 ; so plot a rectangle
LDR R0, [R2, #spMode]
MOVS R10, R0, ASR #27
BMI PutSpriWideMaskErr2
BNE PlotNewMask
LDR R0, [R2, #spHeight]
ADD R0, R0, R4
LDR R10, [WsPtr, #GWTRow]
Least R0, R0, R10 ; top scanline within window
LDR R10, [WsPtr, #YWindLimit]
SUB R0, R10, R0 ; flip Y
AND R0, R0, #7
STR R0, [WsPtr, #SPltEcfIndx] ; index into Ecf
ADD R0, WsPtr, R0, LSL #3
ADD R0, R0, #BgEcfOraEor
STR R0, [WsPtr, #SPltEcfPtr] ; ptr to ECF for highest row plotted
Push "WsPtr, R14" ; push both so R12,R14 are free for use
BL GenSpritePlotParmBlk
BVS SpriteOffScreen
SWI XOS_RemoveCursors ; assume no error can occur!
LDR R5, [WsPtr, #SPltMemAdr]
LDR R6, [WsPtr, #SPltMskAdr]
TEQ R6, #0
BEQ SpriteOffScreen
ADD R6, R6, R5
STR R6, [WsPtr, #SPltMskAdr]
STR R6, [WsPtr, #SPltMemAdr]
ADD WsPtr, WsPtr, #SPltScrAdr ; repoint WsPtr at SPltScrAdr
LDMIA WsPtr, {R0-R1,R5-R7}
LDR R8, [WsPtr, #SPltEcfPtr-SPltScrAdr]
10
LDMIA R8, {R8,R9} ; ora,eor for this row
; R0 ,R1 , R5 ,R6 ,R7 ,R8 ,R9
; ScrAdr,ColCnt, MemAdr,ShftR,ShftL,ora,eor
; Plot the first (Leftmost) word
LDMIA R5, {R2,R3}
ADD R5, R5, #4
ShiftR R2,R3, R6,R7 ; shift R3,R2 right R6 places
; we only need result word R2
LDR R10, [WsPtr, #SPltLMask-SPltScrAdr] ; on leftmost word
AND R2, R2, R10 ; mask down to just the required pixels
LDR R4, [R0] ; plot 1 word
OrrEorMASK R4,R2, R8,R9, R14
STR R4, [R0], #4
SUBS R1, R1, #1
BLT %FT50 ; if all plotted, try next scanline
; else try for blocks of 4
SUBS R1, R1, #4
BLT %FT30
20
STMIA WsPtr, {R0,R1} ; save ScrAdr,ColCnt
; R0 ,R1 ,R5 ,R6 ,R7
; ScrAdr,ColCnt, ,MemAdr,ShftR,ShftL
LDMIA R5, {R0-R4} ; 5 words needed, gives 4 after shift
ADD R5, R5, #16 ; advance source ptr 4 words
STR R5, [WsPtr, #SPltMemAdr-SPltScrAdr]
ShiftR R0,R1, R6,R7 ; shift R4-R0 right R6 bits
ShiftR R1,R2, R6,R7 ; we only want result words R3-R0
ShiftR R2,R3, R6,R7
ShiftR R3,R4, R6,R7
LDR R4, [WsPtr] ; get screen address
LDMIA R4, {R8-R11} ; get 4 screen words
LDR R6, [WsPtr, #SPltEcfPtr-SPltScrAdr]
LDMIA R6, {R6,R7} ; ora,eor for this row
OrrEorMASK R8,R0, R6,R7, R14 ; Scr:=ScrOR(oraANDmsk)EOR(eorANDmsk)
OrrEorMASK R9,R1, R6,R7, R14
OrrEorMASK R10,R2, R6,R7, R14
OrrEorMASK R11,R3, R6,R7, R14
LDR R0, [WsPtr] ; screen address
STMIA R0!, {R8-R11} ; write 4 words back to screen
LDMIB WsPtr, {R1,R5-R7} ; reload anything we shat on
SUBS R1, R1, #4
BGE %BT20
30 ; try 1 word at a time
ADDS R1, R1, #4
; R0 ,R1 , R5 ,R6 ,R7 ,R8 ,R9
; ScrAdr,ColCnt, MemAdr,ShftR,ShftL,ora,eor
; If EQ this is rightmost word
LDR R8, [WsPtr, #SPltEcfPtr-SPltScrAdr]
LDMIA R8, {R8,R9} ; ora,eor for this row
LDR R10, [WsPtr, #SPltRMask-SPltScrAdr]
40
LDMIA R5, {R2,R3}
ADD R5, R5, #4
ShiftR R2,R3, R6,R7 ; shift R3,R2 right R6 places
; we only need result word R2
ANDEQ R2, R2, R10 ; if rightmost word, mask down to just the
; required pixels
LDR R4, [R0]
OrrEorMASK R4,R2, R8,R9, R14
STR R4, [R0], #4
SUBS R1, R1, #1
BGE %BT40
50 ; now try the next scanline
LDMDB WsPtr, {R1,R2,R3,R4} ; R1 ,R2 ,R3 ,R4
; Width,Height,ScrOff,MemOff
ADD R0, R0, R3
ADD R5, R5, R4
ADD R10, WsPtr, #(SPltEcfPtr-SPltScrAdr)
LDMIA R10, {R8,R9} ; EcfPtr,EcfIndx
ADD R8, R8, #8 ; step both to next row in Ecf
ADD R9, R9, #1
CMP R9, #8
MOVGE R9, #0 ; it's a wrap!
SUBGE R8, R8, #(8*8)
STMIA R10, {R8,R9}
SUBS R2, R2, #1
STRGE R2, [WsPtr, #SPltHeight-SPltScrAdr]
BGE %BT10 ; plot next scanline
SWI XOS_RestoreCursors
Pull "WsPtr, R14"
RETURNVC
; Sprite has no mask or gcol says dont use it, so draw a rectangle
90
Push R14
BL ReadSpriteWidth ; on exit R0=width in pixels
ADD R5, R3, R0
MOV R0, R3 ; x0
MOV R1, R4 ; y0
LDR R3, [R2, #spHeight]
ADD R3, R3, R4 ; y1
SUB R2, R5, #1 ; x1
LDR R4, [WsPtr, #CursorFlags]
TST R4, #ClipBoxEnableBit
BLNE ClipPlotMask
ADD R4, WsPtr, #BgEcfOraEor ; select Bg colour & action
STR R4, [WsPtr, #GColAdr]
B RectFillB
ClipPlotMask ROUT
Push "R0-R7,R10,R11, R14"
ADD R10, R13, #2*4 ; R10 -> last point (R2,R3)
MOV R11, #2 ; merge two points
BL MergeR11PointsFromR10
Pull "R0-R7,R10,R11, PC"
; *****************************************************************************
;
; GenSpritePlotParmBlk - Generate lots of useful variables to help us
; to plot sprite
;
; Internal routine, called by PutSprite, PlotMask, ScreenLoad
;
; in: R2 -> sprite
; R3 = X coordinate to plot at
; R4 = Y coordinate to plot at
; R5 = GCOL action
;
GenSpritePlotParmBlk ROUT
Push R14
AND R5, R5, #&F ; lose any ECF colour bits
LDR R6, [R2, #spImage]
LDR R7, [R2,#spTrans]
SUB R6, R7, R6 ; offset from Image to Trans mask
; =0 if no mask
STR R5, [WsPtr, #SPltAction] ; save action for simple case spotting
CMP R5, #8 ; if GCOL action < 8
MOVLT R6, #0 ; plot as solid anyway
STR R6, [WsPtr, #SPltMskAdr]
AND R5, R5, #7
MOV R5, R5, LSL #2 ; 4 bits for each
LDR R6, =TBscrmasks
MOV R6, R6, ROR R5 ; put correct bits in top 4 bits
MOV R7, R6, ASR #31 ; set R7 to 0 or -1 on bit 31
MOV R6, R6, LSL #1
MOV R8, R6, ASR #31 ; set R8 to 0 or -1 on bit 30
MOV R6, R6, LSL #1
MOV R9, R6, ASR #31 ; set R9 to 0 or -1 on bit 29
MOV R6, R6, LSL #1
MOV R10, R6, ASR #31 ; set R10 to 0 or -1 on bit 28
ADD R6, WsPtr, #SPltzgooMasks
STMIA R6, {R7-R10} ; store zgoo, zgeo, zgoe, zgee
MOV R14, R2 ; leave sprite CB ptr in R14
MOV R0, R3 ; leave X coord in R0
MOV R1, R4 ; leave Y coord in R1
ADD R11, R14, #spWidth
LDMIA R11, {R2,R3} ; Width-1, Height-1
ADD R4, WsPtr, #GWLCol ; R4 ,R5 ,R6 ,R7
LDMIA R4, {R4,R5,R6,R7} ; LCol,BRow,RCol,TRow
SUBS R5, R5, R1
MOVLT R5, #0 ; no. of rows below window
ADD R1, R1, R3 ; Coord of topLH of sprite
SUBS R7, R1, R7
MOVLT R7, #0 ; no. of rows above window
SUB R1, R1, R7 ; clipped topLH coord
ADD R5, R5, R7 ; reduction factor for height
ADD R2, R2, #1
MOV R8, R14
LDR R9, [WsPtr, #CursorFlags]
TST R9, #ClipBoxEnableBit
BLNE ClipSpritePlot
MOV R14, R8
MUL R3, R7, R2 ; word offset into sprite image
Push "R3,R5" ; word offset and height reduction
Push R14
BL ScreenAddr
Pull R14
MOV R4, R2 ; address of top left corner
LDR R5, [R14, #spImage]
ADD R5, R5, R14 ; address of sprite image
Pull R6
ADD R5, R5, R6, LSL #2
LDR R9, [WsPtr, #XShftFactor]
LDR R10, [WsPtr, #NPix]
LDR R11, [WsPtr, #Log2BPC]
BitLOffset R7,R0, R9,R10,R11 ; R7 := bit position to align to
WordOffset R8,R0, R9,R10,R11 ; R8 := word offset on line
LDR R0, [WsPtr, #GWRCol]
BitROffset R1,R0, R9,R10,R11
WordOffset R2,R0, R9,R10,R11
Push "R1,R2"
LDR R0, [WsPtr, #GWLCol]
BitLOffset R1,R0, R9,R10,R11
WordOffset R2,R0, R9,R10,R11
Push "R1,R2,R8"
ADD R11, R14, #spWidth
LDMIA R11, {R0,R1,R6,R8} ; Width-1, Height-1, LBit, RBit
MOV R3, #0 ; offset to next row in sprite
SUBS R6, R6, R7 ; no. of bits to shift sprite
; before plotting
; use R7 as LBit
SUBS R8, R8, R6 ; calculate new RBit
ADDLT R8, R8, #32
ADDLT R3, R3, #4
CMP R8, #32
SUBGE R8, R8, #32
SUBGE R3, R3, #4
; R9 Offset on line to plot point, R7 LBit
; R11 Offset on line to GWLCol R10 bit position
Pull "R10,R11"
Pull R9
SUBS R9, R11, R9
SUBLT R11, R11, R9
ADDGT R4, R4, R9, LSL #2
ADDGT R5, R5, R9, LSL #2
ADDGT R3, R3, R9, LSL #2
CMPEQ R10, R7
MOVGT R7, R10
; R10 Offset to GWRCol, R9 bit position
; R11 Offset to RHedge of sprite, R8 RBit
ADD R11, R11, R0
SUB R11, R11, R3, ASR #2
Pull "R9,R10"
SUBS R10, R11, R10
ADDGT R3, R3, R10, LSL #2
CMPEQ R8, R9
MOVGT R8, R9
Pull R10
SUBS R1, R1, R10 ; correct height
BLT %FT20
SUBS R0, R0, R3, ASR #2 ; corrected width
BLT %FT20
LDR R2,[WsPtr,#LineLength]
SUB R2, R2, #4
SUB R2, R2, R0, LSL #2 ; offset to next screen line
MOV R9, #&FFFFFFFE ; RHand partial word mask
MVN R9, R9, LSL R8
MOV R8, #&FFFFFFFF
MOV R8, R8, LSL R7 ; LHand partial word mask
ANDEQ R8, R8, R9 ; if width=0, combine LH & RH masks
MOVEQ R9, R8
CMP R6, #0
ADDLT R6, R6, #32 ; correct if neg
SUBLT R5, R5, #4
RSB R7, R6, #32 ; its complement
ADD R11, WsPtr, #SPltWidth
STMIA R11, {R0,R1,R2,R3,R4} ; SPltWidth..SPltScrAdr
ADD R11, WsPtr, #SPltColCnt
STMIA R11, {R0,R5,R6,R7} ; SPltColCnt..SPltShftL
ADD R11, WsPtr, #SPltMskAdr
STMIB R11, {R8,R9} ; SPltLMask,SPltRMask
CLRV
Pull PC
20
SETV
Pull PC
LTORG
END