vdugrafd

; 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.VduGrafD

;
; ARTHUR OPERATING SYSTEM - Vdu Drivers
; =======================
;
; Vdu driver code - Block Copy and Move
;
; Author R C Manby
; Date   2.10.86
;

; *****************************************************************************
;
;       BlockCopyMove - Copy/Move a rectangular area
;
; in:   OldCs marks start of area to copy/move
;       ICursor marks end of area to copy/move
;       NewPt is lower left of destination area
;       R2 = plot number &B8..&BF
;
; out:  R0..R11 corrupt
;

BlockCopyMove ROUT
        TST     R2, #3                          ; Do nowt on 'MoveOnly' codes
        MOVEQ   PC, R14

        SaveRetAdr

        ADD     R0, WsPtr, #BgEcfStore          ; Select 'store' in background
        STR     R0, [WsPtr, #GColAdr]           ; to be used by HLine when
                                                ; clearing source & dest lines

; Build up source & destination data as follows
;
; R0   R1   R2   R3   R4    R5    R6    R7    R8
; SrcL,SrcB,SrcR,SrcT,DestL,DestB,DestR,DestT,CopyFlag

        AND     R8, R2, #2                      ; 0/2 means Move/Copy

        ADD     R11, WsPtr, #OldCsX
        LDMIA   R11, {R0,R1, R2,R3, R4,R5}      ; OldCs, ICursor, NewPt

        SortT   R0, R2, R6                      ; Order SrcL,SrcB,SrcR,SrcT
        SortT   R1, R3, R6                      ;       R0 , R1 , R2 , R3

        SUB     R6, R2, R0
        ADD     R6, R6, R4                      ; DestR := SrcR-SrcL+DestL

        SUB     R7, R3, R1
        ADD     R7, R7, R5                      ; DestT := SrcT-SrcB+DestB

        ADD     R11, WsPtr, #CMSrc
        STMIA   R11, {R0-R7,R8}                 ; Unclipped src & dest areas
                                                ; and CopyFlag
        LDR     R11, [WsPtr, #CursorFlags]
        TST     R11, #ClipBoxEnableBit
        BLNE    ClipBlockCopyMove

; now work out ACTUAL area to copy
; first, we window destination area

        LDR     R10, [WsPtr, #GWLCol]
        LDR     R11, [WsPtr, #GWRCol]

        SUBS    R8, R10, R4                     ; R8 = GWLCol - DestL
        ADDGT   R4, R4, R8                      ; if > 0 then DestL := GWLCol
        ADDGT   R0, R0, R8                      ; and adjust SrcL to match

        SUBS    R8, R6, R11                     ; R8 = DestR - GWRCol
        SUBGT   R6, R6, R8                      ; if > 0 then DestR := GWRCol
        SUBGT   R2, R2, R8                      ; and adjust SrcR to match

        CMP     R6, R4                          ; check DestR >= DestL
        BLT     EraseSource                     ; if not then just erase source
                                                ; if a block move

        STR     R4, [WsPtr, #CMDest2L]          ; save horizontal dest coords
        STR     R6, [WsPtr, #CMDest2R]          ; windowed at dest

        SUBS    R8, R10, R0                     ; R8 = GWLCol - SrcL
        ADDGT   R0, R0, R8                      ; if > 0 then SrcL := GWLCol
        ADDGT   R4, R4, R8                      ; and adjust DestL to match

        SUBS    R8, R2, R11                     ; R8 = SrcR - GWRCol
        SUBGT   R2, R2, R8                      ; if > 0 then SrcR := GWRCol
        SUBGT   R6, R6, R8                      ; and adjust DestR to match

        LDR     R10, [WsPtr, #GWBRow]
        LDR     R11, [WsPtr, #GWTRow]

        SUBS    R8, R10, R5                     ; R8 = GWBRow - DestB
        ADDGT   R5, R5, R8                      ; if > 0 then DestB := GWBRow
        ADDGT   R1, R1, R8                      ; and adjust SrcB to match

        SUBS    R8, R7, R11                     ; R8 = DestT - GWTRow
        SUBGT   R7, R7, R8                      ; if > 0 then DestT := GWTRow
        SUBGT   R3, R3, R8                      ; and adjust SrcT to match

        CMP     R7, R5                          ; check DestT >= DestB
        BLT     EraseSource                     ; if not then just erase source
                                                ; if a block move

        STR     R5, [WsPtr, #CMDest2B]          ; save vertical dest coords
        STR     R7, [WsPtr, #CMDest2T]          ; windowed at dest

        SUBS    R8, R10, R1                     ; R8 = GWBRow - SrcB
        ADDGT   R1, R1, R8                      ; if > 0 then SrcB := GWBRow
        ADDGT   R5, R5, R8                      ; and adjust DestB to match

        SUBS    R8, R3, R11                     ; R8 = SrcT - GWTRow
        SUBGT   R3, R3, R8                      ; if > 0 then SrcT := GWTRow
        SUBGT   R7, R7, R8                      ; and adjust DestT to match

; now R0-R3 is source windowed both ways
;     R4-R7 is dest   windowed both ways

        ADD     R8, WsPtr, #CMDest3L
        STMIA   R8, {R4-R7}                     ; save destination windowed
                                                ; both ways

        LDR     R9, [WsPtr, #VduSprite]

        CMP     R2, R0                          ; check SrcR >= SrcL
        SUBGES  R8, R3, R1                      ; and SrcT >= SrcB (R8=lines-1)
        BLT     EraseDest                       ; if not, then go to wiping out
                                                ; destination stage

        STR     R8, [WsPtr, #CMVertCount]       ; no. of vertical lines -1

        BL      CheckAcceleration               ; okay to accelerate?
        BNE     %FT05

; not redirected to sprite - try calling GraphicsV for some acceleration

        Push    "R2"
        Push    "R8"
        SUB     R14, R2, R0
        Push    "R0,R1,R4,R5,R14"               ; srcL,srcB,dstL,dstB,W-1,H-1
        MOV     R0, #GVRender_Sync
        MOV     R1, #GVRender_CopyRectangle
        MOV     R2, R13
        LDR     R4, [WsPtr, #CurrentGraphicsVDriver]
        MOV     R4, R4, LSL #24
        ORR     R4, R4, #GraphicsV_Render
        BL      CallGraphicsV                   ; (R0,R1,R2,R4->R4)
        TEQ     R4, #GraphicsV_Complete         ; did it do it?
        Pull    "R0,R1,R4"
        ADD     R13, R13, #3*4
        Pull    "R2"
        BEQ     EraseDest                       ; then go straight to erase

05      LDR     R9, [WsPtr, #Log2BPC]
        LDR     R10, [WsPtr, #XShftFactor]
        LDR     R11, [WsPtr, #NPix]

        MOV     R8, R6, LSR R10                 ; DestR word offset
        SUB     R8, R8, R4, LSR R10             ; -DestL word offset
        STR     R8, [WsPtr, #CMDestCount]       ; No. of dest words -1

        AND     R8, R6, R11                     ; R8 = DestR pixel offset
        ADD     R14, WsPtr,#RAMMaskTb
        LDR     R8, [R14, R8, LSL #2]           ; R8 = mask for right pixel
        SUB     R14, R8, #1             ; In rh mask, set all bits lower than
        ORR     R14, R14, R8            ; pixel, RHM := RHM OR (RHM-1)
        STR     R14, [WsPtr, #CMRMask]

        AND     R8, R4, R11                     ; R8 = DestL pixel offset
        ADD     R14, WsPtr, #RAMMaskTb
        LDR     R8, [R14, R8, LSL #2]           ; R8 = mask for left pixel
        RSB     R14, R8, #0             ; In lh mask, set all bits higher than
        ORR     R14, R14, R8            ; pixel, LHM := LHM OR (0-LHM)
        STR     R14, [WsPtr, #CMLMask]

        CMP     R0, R4                          ; test whether SrcL >= DestL
        BLT     SrcHLTDest

; source is to the right of dest, so start at left hand side

        AND     R8, R4, R11                     ; R8 = DestL pixel offset
        AND     R14, R0, R11                    ; R14 = SrcL pixel offset
        SUB     R11, R14, R8                    ; R11 = Src-Dest pixel offset
        MOV     R11, R11, LSL R9                ; R11 = Src-Dest bit offset

        CMP     R11, #0                         ; if rightshift < 0
        ADDLT   R11, R11, #32                   ; if < 0, correct result
        MOVGE   R10, #0
        MOVLT   R10, #-4                        ; and subtract 4 off src addr

        STR     R11, [WsPtr, #CMRShift]
        RSB     R11, R11, #32
        STR     R11, [WsPtr, #CMLShift]

        LDR     R6, [WsPtr, #LineLength]        ; (no longer need DestR)

        CMP     R1, R5                          ; if SrcB >= DestB
        RSBGE   R6, R6, #0                      ; then go upwards
        STR     R6, [WsPtr, #CMVertDir]

        MOVLT   R1, R3                          ; else go down
        MOVLT   R5, R7                          ; so use top coords

        BL      ScreenAddr                      ; R2 = address of src corner
        ADD     R2, R2, R10
        STR     R2, [WsPtr, #CMSourceAddr]

        MOV     R0, R4
        MOV     R1, R5
        BL      ScreenAddr                      ; R2 = address of dest corner
        STR     R2, [WsPtr, #CMDestAddr]

        ADD     R11, WsPtr, #CMStuff
        LDMIA   R11, {R0-R6}            ; src,dest,cnt,rtshf,lfshf,rtmsk,ltmsk
10
        TEQ     R2, #0                  ; only one word on a line ?
        ANDEQ   R5, R5, R6              ; then rightmask:=rightmask AND lftmask
        LDREQ   R14, [R0], #4           ; and load first word up
        BEQ     %FT45                   ; and do endword

; do first word

        LDMIA   R0!, {R11,R14}          ; load 2 words
        ShiftR  R11, R14, R3, R4        ; shift them
        AND     R11, R11, R6            ; AND with leftmask
        LDR     R10, [R1]               ; load word from dest
        BIC     R10, R10, R6            ; clear out bits in leftmask
        ORR     R10, R10, R11           ; OR in new bits
        STR     R10, [R1], #4
        SUBS    R2, R2, #1              ; decrement count
        BEQ     %FT40                   ; if zero, do finish word

        SUBS    R2, R2, #7              ; can we do 7 words ?
        BCC     %FT30                   ; no, then do 1 word at a time

; do 7 words at a time

        TEQ     R3, #0                  ; if rightshf = 0
        BEQ     %FT60                   ; then do non-shifting version
20
 [ {TRUE}                               ; TMD optimisation 12-May-93
        MOV     R5, R14, LSR R3
        LDMIA   R0!, {R6-R11,R14}
        ORR     R5, R5, R6, LSL R4
 |
        MOV     R5, R14
        LDMIA   R0!, {R6-R11,R14}       ; load next 7 words
        ShiftR  R5, R6, R3, R4
 ]
        ShiftR  R6, R7, R3, R4
        ShiftR  R7, R8, R3, R4
        ShiftR  R8, R9, R3, R4
        ShiftR  R9, R10, R3, R4
        ShiftR  R10, R11, R3, R4
        ShiftR  R11, R14, R3, R4
        STMIA   R1!, {R5-R11}
        SUBS    R2, R2, #7
        BCS     %BT20

30
        ADDS    R2, R2, #7
        BEQ     %FT40                   ; if count expired, do last word

; do 1 word at a time

35
        MOV     R5, R14
        LDR     R14, [R0], #4
        ShiftR  R5, R14, R3, R4
        STR     R5, [R1], #4
        SUBS    R2, R2, #1
        BNE     %BT35

; do last word

40
        LDR     R5, [WsPtr, #CMRMask]   ; load right mask
45

; now test if any bits would be used (so we don't go off end of memory)

        MOV     R11, #&FFFFFFFF
        TST     R5, R11, LSL R4         ; NE => safe to read from here
        LDRNE   R11, [R0], #4           ; R14 = left word; R11 = right word
        ShiftR  R14, R11, R3, R4        ; form single word
        AND     R14, R14, R5            ; mask source word
        LDR     R10, [R1]               ; load dest word
        BIC     R10, R10, R5            ; mask dest word
        ORR     R10, R10, R14           ; OR two words
        STR     R10, [R1], #4           ; store back

; now go on to next row

        LDR     R7, [WsPtr, #CMVertCount]
        SUBS    R7, R7, #1
        BCC     EraseDest               ; finished, so go to erase dest stage
        STR     R7, [WsPtr, #CMVertCount]
        ADD     R11, WsPtr, #CMStuff
        LDMIA   R11, {R0-R6}            ; load up info again
        LDR     R7, [WsPtr, #CMVertDir]
        ADD     R0, R0, R7              ; move source pointer
        ADD     R1, R1, R7              ; and dest pointer
        STMIA   R11, {R0,R1}            ; store these back
        B       %BT10                   ; and loop

; non-shifting version, for speed
; do 7 words at a time

60
        MOV     R5, R14
        LDMIA   R0!, {R6-R11,R14}       ; load next 7 words
        STMIA   R1!, {R5-R11}
        SUBS    R2, R2, #7
        BCS     %BT60
        ADDS    R2, R2, #7
        BNE     %BT35                   ; count not expired, do last few words
        B       %BT40                   ; count expired, do last word

; *****************************************************************************

; source is to the left of dest, so start at right hand side

SrcHLTDest ROUT
        MOV     R0, R2                          ; rt coords are relevant ones
        MOV     R4, R6

        AND     R8, R4, R11                     ; R8 = DestR pixel offset
        AND     R14, R0, R11                    ; R14 = SrcR pixel offset
        SUB     R11, R14, R8                    ; R11 = Src-Dest pixel offset
        MOV     R11, R11, LSL R9                ; R11 = Src-Dest bit offset

        RSB     R11, R11, #32                   ; R11 = leftshift
        CMP     R11, #32                        ; if >= 32
        SUBCS   R11, R11, #32                   ; then put in range
        MOVCC   R10, #4                         ; else add 4
        MOVCS   R10, #0                         ; to src addr

        STR     R11, [WsPtr, #CMLShift]
        RSB     R11, R11, #32
        STR     R11, [WsPtr, #CMRShift]

        LDR     R6, [WsPtr, #LineLength]        ; (no longer need R6)

        CMP     R1, R5                          ; if SrcB >= DestB
        RSBGE   R6, R6, #0                      ; then go upwards
        STR     R6, [WsPtr, #CMVertDir]

        MOVLT   R1, R3                          ; else go down
        MOVLT   R5, R7                          ; so use top coords

        BL      ScreenAddr                      ; R2 = address of src corner
        ADD     R2, R2, R10
        STR     R2, [WsPtr, #CMSourceAddr]

        MOV     R0, R4
        MOV     R1, R5
        BL      ScreenAddr                      ; R2 = address of dest corner
        STR     R2, [WsPtr, #CMDestAddr]

        ADD     R11, WsPtr, #CMStuff
        LDMIA   R11, {R0-R6}            ; src,dest,cnt,rtshf,lfshf,rtmsk,ltmsk
10
        TEQ     R2, #0                  ; only one word on a line ?
        ANDEQ   R6, R6, R5              ; then leftmask:=leftmask AND rightmask
        LDREQ   R5, [R0], #-4           ; and load first word up
        BEQ     %FT45                   ; and do endword

; do first word

        LDMDA   R0!, {R11,R14}          ; load 2 words
        ShiftL  R11, R14, R3, R4        ; shift them
        AND     R14, R14, R5            ; AND with rightmask
        LDR     R10, [R1]               ; load word from dest
        BIC     R10, R10, R5            ; clear out bits in rightmask
        ORR     R10, R10, R14           ; OR in new bits
        STR     R10, [R1], #-4
        MOV     R5, R11
        SUBS    R2, R2, #1              ; decrement count
        BEQ     %FT40                   ; if zero, do finish word

        SUBS    R2, R2, #7              ; can we do 7 words ?
        BCC     %FT30                   ; no, then do 1 word at a time

; do 7 words at a time

        TEQ     R4, #0                  ; if leftshf=0
        BEQ     %FT60                   ; then do non-shifting version
20
 [ {TRUE}                               ; TMD optimisation 12-May-93
        MOV     R14, R5, LSL R4
        LDMDA   R0!, {R5-R11}
        ORR     R14, R14, R11, LSR R3
 |
        MOV     R14, R5
        LDMDA   R0!, {R5-R11}           ; load next 7 words
        ShiftL  R11, R14, R3, R4
 ]
        ShiftL  R10, R11, R3, R4
        ShiftL  R9, R10, R3, R4
        ShiftL  R8, R9, R3, R4
        ShiftL  R7, R8, R3, R4
        ShiftL  R6, R7, R3, R4
        ShiftL  R5, R6, R3, R4
        STMDA   R1!, {R6-R11,R14}
        SUBS    R2, R2, #7
        BCS     %BT20

30
        ADDS    R2, R2, #7
        BEQ     %FT40                   ; if count expired, do last word

; do 1 word at a time

35
        MOV     R14, R5
        LDR     R5, [R0], #-4
        ShiftL  R5, R14, R3, R4
        STR     R14, [R1], #-4
        SUBS    R2, R2, #1
        BNE     %BT35

; do last word

40
        LDR     R6, [WsPtr, #CMLMask]   ; load left mask
45

; now test if any bits would be used (so we don't go off start of memory)

        MOV     R11, #&FFFFFFFF
        TST     R6, R11, LSR R3         ; NE => safe to read from here
        LDRNE   R11, [R0], #-4          ; R11 = left word; R5 = right word
        ShiftL  R11, R5, R3, R4         ; form single word
        AND     R5, R5, R6              ; mask source word
        LDR     R10, [R1]               ; load dest word
        BIC     R10, R10, R6            ; mask dest word
        ORR     R10, R10, R5            ; OR two words
        STR     R10, [R1], #-4          ; store back

; now go on to next row

        LDR     R7, [WsPtr, #CMVertCount]
        SUBS    R7, R7, #1
        BCC     EraseDest               ; finished, so go to erase dest stage
        STR     R7, [WsPtr, #CMVertCount]
        ADD     R11, WsPtr, #CMStuff
        LDMIA   R11, {R0-R6}            ; load up info again
        LDR     R7, [WsPtr, #CMVertDir]
        ADD     R0, R0, R7              ; move source pointer
        ADD     R1, R1, R7              ; and dest pointer
        STMIA   R11, {R0,R1}            ; store these back
        B       %BT10                   ; and loop

; non-shifting version, for speed
; do 7 words at a time

60
        MOV     R14, R5
        LDMDA   R0!, {R5-R11}           ; load next 8 words
      [ SupportARMX
        MOV     R11, R11                ; Dummy instruction for XScale weirdness
      ]
        STMDA   R1!, {R6-R11,R14}
        SUBS    R2, R2, #7
        BCS     %BT60
        ADDS    R2, R2, #7
        BNE     %BT35                   ; count not expired, do last few words
        B       %BT40                   ; count expired, do last word

; *****************************************************************************

; Erase the area Dest2\Dest3

EraseDest ROUT

; first do the flat rectangle

        ADD     R8, WsPtr, #CMDest2L
        LDMIA   R8, {R0-R7}             ; R0..R3 = Dest2; R4..R7 = Dest3
        BL      EraseDifference

; and drop thru to ...

EraseSource
        LDR     R8, [WsPtr, #CMCopyFlag] ; 0 => move, 2 => copy
        TEQ     R8, #0                  ; is it a move
        Return  NE                      ; no, then exit

        ADD     R8, WsPtr, #CMSrc       ; R0..R3 = unclipped src
        LDMIA   R8, {R0-R7}             ; R4..R7 = unclipped dest

; window both source and destination in source domain

        LDR     R10, [WsPtr, #GWLCol]
        LDR     R11, [WsPtr, #GWRCol]

        SUBS    R8, R10, R0             ; R8 = GWLCol - SrcL
        ADDGT   R0, R0, R8              ; if > 0 then SrcL := GWLCol
        ADDGT   R4, R4, R8              ; and adjust DestL to match

        SUBS    R8, R2, R11             ; R8 = SrcR - GWRCol
        SUBGT   R2, R2, R8              ; if > 0 then SrcR := GWRCol
        SUBGT   R6, R6, R8              ; and adjust DestR to match

        CMP     R2, R0                  ; check SrcR >= SrcL
        Return  LT                      ; if not then nothing to erase

        LDR     R10, [WsPtr, #GWBRow]
        LDR     R11, [WsPtr, #GWTRow]

        SUBS    R8, R10, R1             ; R8 = GWBRow - SrcB
        ADDGT   R1, R1, R8              ; if > 0 then SrcB := GWBRow
        ADDGT   R5, R5, R8              ; and adjust DestB to match

        SUBS    R8, R3, R11             ; R8 = SrcT - GWTRow
        SUBGT   R3, R3, R8              ; if > 0 then SrcT := GWTRow
        SUBGT   R7, R7, R8              ; and adjust DestT to match

        CMP     R3, R1                  ; check SrcT >= SrcB
        Return  LT                      ; if not then nothing to erase

; now window the dest coords to the source

        CMP     R7, R3                  ; if DestT >= SrcT
        MOVGE   R7, R3                  ; then DestT := SrcT
        MOVLT   R5, R1                  ; else DestB := SrcB
        CMP     R6, R2                  ; if DestR >= SrcR
        MOVGE   R6, R2                  ; then DestR := SrcR
        MOVLT   R4, R0                  ; else DestL := SrcL

        Pull    R14

; and drop thru to ...

; *****************************************************************************
;
;       EraseDifference - Erase the difference between two rectangles with at
;                         least one vertical and one horizontal shared boundary
;
; in:   R0-R3 = larger one
;       R4-R7 = smaller one
;

EraseDifference ROUT

; first do the flat rectangle

        CMP     R6, R4                  ; check for Dest3 being null
        CMPGE   R7, R5
        BLT     RectFillA               ; if is, just clear Dest2

        Push    "R0-R7,R14"

        TEQ     R3, R7                  ; if Dest2T = Dest3T
        SUBEQ   R3, R5, #1              ; then top = Dest3B -1
        ADDNE   R1, R7, #1              ; else bottom = Dest3T +1
        CMP     R3, R1                  ; if top >= bottom
        BLGE    RectFillA

; now do the tall rectangle

        Pull    "R0-R7"

        TEQ     R3, R7                  ; if Dest2T = Dest3T
        MOVEQ   R1, R5                  ; then bottom = Dest3B
        MOVNE   R3, R7                  ; else top = Dest3T

        TEQ     R0, R4                  ; if Dest2L = Dest3L
        ADDEQ   R0, R6, #1              ; then left = Dest3R +1
        SUBNE   R2, R4, #1              ; else right = Dest3L -1

        CMP     R3, R1                  ; if top >= bottom
        CMPGE   R2, R0                  ; and right >= left
        BLGE    RectFillA               ; then fill it

        Pull    PC


        END