Dream 44/Amiga_Dream_44.iso/RiscPc/jeux/biohazard.arc/s/SmallMapVG

Text File | 1995-06-02 | 22KB | 957 lines

; Use the GET directive to include register definitions as if typed here

      KEEP
          GET     h.WolfReg

; Use the GET directive to include a list of SWI names as if typed here

          GET     h.SWInames

; Area name C$$code advisable as wanted to link with C output

          AREA    |C$$code|, CODE, READONLY

; Export global symbols

      EXPORT  |PlotSmallMapVGA|
      EXPORT  |PlotSmallFadedMapVGA|

;on entry
;
; r0 = pointer to data block where :-
;
; 0 = pointer to x1
; 1 = pointer to y1
; 2 = screen address (of the first line to draw on)
; 3 = pointer to map data to use as map.
;        This is simply a 64x64 block of data
; 4 = x pixel increment
; 5 = y pixel increment
; 6 = x line increment
; 7 = y line increment

|PlotSmallMapVGA|
      STMFD   r13!,{r0-r12,link}

      ;load up block data
          MOV     r14,r0
          LDMIA   r14,{r0-r5}

          ;set outer counter
          MOV     r12,#64<<16

Outer_Draw_Line
      ;set inner counter
          ORR     r12,r12,#64

Draw_Line
          ;clear registers
          MOV     r8,#0
          MOV     r9,r8
          MOV     r10,r8
          MOV     r11,r8

      ;check limits of x and y
          CMP     r0,#64<<16
          BGE     skip_1
          CMP     r0,#0
          BLT     skip_1

          CMP     r1,#64<<16
          BGE     skip_1
          CMP     r1,#0
          BLT     skip_1

      ;construct address from x & y values
          MOV     r6,r0,ASR #16
          MOV     r7,r1,ASR #16
          ADD     r6,r6,r7,LSL #6

          ;load byte from map + (x + 64(y))
          LDRB    r8,[r3,r6]

skip_1    ;update x & y
          ADD     r0,r0,r4
          ADD     r1,r1,r5


      ;load byte 2 word 1
      ;check limits of x and y
          CMP     r0,#64<<16
          BGE     skip_2
          CMP     r0,#0
          BLT     skip_2

          CMP     r1,#64<<16
          BGE     skip_2
          CMP     r1,#0
          BLT     skip_2

      ;construct address from x & y values
          MOV     r6,r0,ASR #16
          MOV     r7,r1,ASR #16
          ADD     r6,r6,r7,LSL #6

          ;load byte from map + (x + 64(y))
          LDRB    r9,[r3,r6]
          ORR     r8,r8,r9,LSL #8

skip_2    ;update x & y
          ADD     r0,r0,r4
          ADD     r1,r1,r5


      ;load byte 3 word 1
      ;check limits of x and y
          CMP     r0,#64<<16
          BGE     skip_3
          CMP     r0,#0
          BLT     skip_3

          CMP     r1,#64<<16
          BGE     skip_3
          CMP     r1,#0
          BLT     skip_3

      ;construct address from x & y values
          MOV     r6,r0,ASR #16
          MOV     r7,r1,ASR #16
          ADD     r6,r6,r7,LSL #6

          ;load byte from map + (x + 64(y))
          LDRB    r9,[r3,r6]
          ORR     r8,r8,r9,LSL #16

skip_3    ;update x & y
          ADD     r0,r0,r4
          ADD     r1,r1,r5

      ;load byte 4 word 1
      ;check limits of x and y
          CMP     r0,#64<<16
          BGE     skip_4
          CMP     r0,#0
          BLT     skip_4

          CMP     r1,#64<<16
          BGE     skip_4
          CMP     r1,#0
          BLT     skip_4

      ;construct address from x & y values
          MOV     r6,r0,ASR #16
          MOV     r7,r1,ASR #16
          ADD     r6,r6,r7,LSL #6

          ;load byte from map + (x + 64(y))
          LDRB    r9,[r3,r6]
          ORR     r8,r8,r9,LSL #24

skip_4    ;update x & y
          ADD     r0,r0,r4
          ADD     r1,r1,r5

      ;load byte 1 word 2
      ;check limits of x and y
          CMP     r0,#64<<16
          BGE     skip_5
          CMP     r0,#0
          BLT     skip_5

          CMP     r1,#64<<16
          BGE     skip_5
          CMP     r1,#0
          BLT     skip_5

      ;construct address from x & y values
          MOV     r6,r0,ASR #16
          MOV     r7,r1,ASR #16
          ADD     r6,r6,r7,LSL #6

          ;load byte from map + (x + 64(y))
          LDRB    r9,[r3,r6]

skip_5    ;update x & y
          ADD     r0,r0,r4
          ADD     r1,r1,r5

      ;load byte 2 word 2
      ;check limits of x and y
          CMP     r0,#64<<16
          BGE     skip_6
          CMP     r0,#0
          BLT     skip_6

          CMP     r1,#64<<16
          BGE     skip_6
          CMP     r1,#0
          BLT     skip_6

      ;construct address from x & y values
          MOV     r6,r0,ASR #16
          MOV     r7,r1,ASR #16
          ADD     r6,r6,r7,LSL #6

          ;load byte from map + (x + 64(y))
          LDRB    r10,[r3,r6]
          ORR     r9,r9,r10,LSL #8

skip_6    ;update x & y
          ADD     r0,r0,r4
          ADD     r1,r1,r5

      ;load byte 3 word 2
      ;check limits of x and y
          CMP     r0,#64<<16
          BGE     skip_7
          CMP     r0,#0
          BLT     skip_7

          CMP     r1,#64<<16
          BGE     skip_7
          CMP     r1,#0
          BLT     skip_7

      ;construct address from x & y values
          MOV     r6,r0,ASR #16
          MOV     r7,r1,ASR #16
          ADD     r6,r6,r7,LSL #6

          ;load byte from map + (x + 64(y))
          LDRB    r10,[r3,r6]
          ORR     r9,r9,r10,LSL #16

skip_7    ;update x & y
          ADD     r0,r0,r4
          ADD     r1,r1,r5

      ;load byte 4 word 2
      ;check limits of x and y
          CMP     r0,#64<<16
          BGE     skip_8
          CMP     r0,#0
          BLT     skip_8

          CMP     r1,#64<<16
          BGE     skip_8
          CMP     r1,#0
          BLT     skip_8

      ;construct address from x & y values
          MOV     r6,r0,ASR #16
          MOV     r7,r1,ASR #16
          ADD     r6,r6,r7,LSL #6

          ;load byte from map + (x + 64(y))
          LDRB    r10,[r3,r6]
          ORR     r9,r9,r10,LSL #24

skip_8    ;update x & y
          ADD     r0,r0,r4
          ADD     r1,r1,r5

      ;load byte 1 word 3
      ;check limits of x and y
          CMP     r0,#64<<16
          BGE     skip_9
          CMP     r0,#0
          BLT     skip_9

          CMP     r1,#64<<16
          BGE     skip_9
          CMP     r1,#0
          BLT     skip_9

      ;construct address from x & y values
          MOV     r6,r0,ASR #16
          MOV     r7,r1,ASR #16
          ADD     r6,r6,r7,LSL #6

          ;load byte from map + (x + 64(y))
          LDRB    r10,[r3,r6]

skip_9    ;update x & y
          ADD     r0,r0,r4
          ADD     r1,r1,r5

      ;load byte 2 word 3
      ;check limits of x and y
          CMP     r0,#64<<16
          BGE     skip_10
          CMP     r0,#0
          BLT     skip_10

          CMP     r1,#64<<16
          BGE     skip_10
          CMP     r1,#0
          BLT     skip_10

      ;construct address from x & y values
          MOV     r6,r0,ASR #16
          MOV     r7,r1,ASR #16
          ADD     r6,r6,r7,LSL #6

          ;load byte from map + (x + 64(y))
          LDRB    r11,[r3,r6]
          ORR     r10,r10,r11,LSL #8

skip_10   ;update x & y
          ADD     r0,r0,r4
          ADD     r1,r1,r5

      ;load byte 3 word 3
      ;check limits of x and y
          CMP     r0,#64<<16
          BGE     skip_11
          CMP     r0,#0
          BLT     skip_11

          CMP     r1,#64<<16
          BGE     skip_11
          CMP     r1,#0
          BLT     skip_11

      ;construct address from x & y values
          MOV     r6,r0,ASR #16
          MOV     r7,r1,ASR #16
          ADD     r6,r6,r7,LSL #6

          ;load byte from map + (x + 64(y))
          LDRB    r11,[r3,r6]
          ORR     r10,r10,r11,LSL #16

skip_11   ;update x & y
          ADD     r0,r0,r4
          ADD     r1,r1,r5

      ;load byte 4 word 3
      ;check limits of x and y
          CMP     r0,#64<<16
          BGE     skip_12
          CMP     r0,#0
          BLT     skip_12

          CMP     r1,#64<<16
          BGE     skip_12
          CMP     r1,#0
          BLT     skip_12

      ;construct address from x & y values
          MOV     r6,r0,ASR #16
          MOV     r7,r1,ASR #16
          ADD     r6,r6,r7,LSL #6

          ;load byte from map + (x + 64(y))
          LDRB    r11,[r3,r6]
          ORR     r10,r10,r11,LSL #24

skip_12   ;update x & y
          ADD     r0,r0,r4
          ADD     r1,r1,r5

      ;load byte 1 word 4
      ;check limits of x and y
          CMP     r0,#64<<16
          BGE     skip_13
          CMP     r0,#0
          BLT     skip_13

          CMP     r1,#64<<16
          BGE     skip_13
          CMP     r1,#0
          BLT     skip_13

      ;construct address from x & y values
          MOV     r6,r0,ASR #16
          MOV     r7,r1,ASR #16
          ADD     r6,r6,r7,LSL #6

          ;load byte from map + (x + 64(y))
          LDRB    r11,[r3,r6]

skip_13   ;update x & y
          ADD     r0,r0,r4
          ADD     r1,r1,r5

      ;load byte 2 word 4
      ;check limits of x and y
          CMP     r0,#64<<16
          BGE     skip_14
          CMP     r0,#0
          BLT     skip_14

          CMP     r1,#64<<16
          BGE     skip_14
          CMP     r1,#0
          BLT     skip_14

      ;construct address from x & y values
          MOV     r6,r0,ASR #16
          MOV     r7,r1,ASR #16
          ADD     r6,r6,r7,LSL #6

          ;load byte from map + (x + 64(y))
          LDRB    r7,[r3,r6]
          ORR     r11,r11,r7,LSL #8

skip_14   ;update x & y
          ADD     r0,r0,r4
          ADD     r1,r1,r5

      ;load byte 3 word 4
      ;check limits of x and y
          CMP     r0,#64<<16
          BGE     skip_15
          CMP     r0,#0
          BLT     skip_15

          CMP     r1,#64<<16
          BGE     skip_15
          CMP     r1,#0
          BLT     skip_15

      ;construct address from x & y values
          MOV     r6,r0,ASR #16
          MOV     r7,r1,ASR #16
          ADD     r6,r6,r7,LSL #6

          ;load byte from map + (x + 64(y))
          LDRB    r7,[r3,r6]
          ORR     r11,r11,r7,LSL #16

skip_15   ;update x & y
          ADD     r0,r0,r4
          ADD     r1,r1,r5

      ;load byte 4 word 4
      ;check limits of x and y
          CMP     r0,#64<<16
          BGE     skip_16
          CMP     r0,#0
          BLT     skip_16

          CMP     r1,#64<<16
          BGE     skip_16
          CMP     r1,#0
          BLT     skip_16

      ;construct address from x & y values
          MOV     r6,r0,ASR #16
          MOV     r7,r1,ASR #16
          ADD     r6,r6,r7,LSL #6

          ;load byte from map + (x + 64(y))
          LDRB    r7,[r3,r6]
          ORR     r11,r11,r7,LSL #24

skip_16   ;update x & y
          ADD     r0,r0,r4
          ADD     r1,r1,r5

      ;store on screen
      STMIA   r2,{r8-r11}
      ADD     r2,r2,#320
      STMIA   r2!,{r8-r11}
      SUB     r2,r2,#320

      ;update inner counter
          SUB     r12,r12,#16
          MOVS    r6,r12,LSL #16
      BNE     Draw_Line

             ;update line start coordinates

          ;load original points from last line
      LDMIA   r14,{r0,r1}
          ;load line increments
          LDR     r6,[r14,#24]
          LDR     r7,[r14,#28]

      ADD     r0,r0,r6
          ADD     r1,r1,r7

      STMIA   r14,{r0,r1}

      ;update screen start for next line
      ADD     r2,r2,#256
      ADD     r2,r2,#320

          ;update inner counter
          SUB     r12,r12,#1<<16
      MOVS    r6,r12,LSR #16
      BNE     Outer_Draw_Line

EndPlotMap
          LDMFD   r13!,{r0-r12,pc}

;on entry
;
; r0 = pointer to data block where :-
;
; 0 = pointer to x1
; 1 = pointer to y1
; 2 = screen address (of the first line to draw on)
; 3 = pointer to map data to use as map.
;        This is simply a 64x64 block of data
; 4 = x pixel increment
; 5 = y pixel increment
; 6 = x line increment
; 7 = y line increment

|PlotSmallFadedMapVGA|
      STMFD   r13!,{r0-r12,link}

      ;load up block data
          MOV     r14,r0
          LDMIA   r14,{r0-r5}

          ;set outer counter
          MOV     r12,#64<<16

FOuter_Draw_Line
      ;set inner counter
          ORR     r12,r12,#64

FDraw_Line
          ;clear registers
          MOV     r8,#0
          MOV     r9,r8
          MOV     r10,r8
          MOV     r11,r8

      ;check limits of x and y
          CMP     r0,#64<<16
          BGE     Fskip_1
          CMP     r0,#0
          BLT     Fskip_1

          CMP     r1,#64<<16
          BGE     Fskip_1
          CMP     r1,#0
          BLT     Fskip_1

      ;construct address from x & y values
          MOV     r6,r0,ASR #16
          MOV     r7,r1,ASR #16
          ADD     r6,r6,r7,LSL #6

          ;load byte from map + (x + 64(y))
          LDRB    r8,[r3,r6]

Fskip_1    ;update x & y
          ADD     r0,r0,r4
          ADD     r1,r1,r5


      ;load byte 2 word 1
      ;check limits of x and y
          CMP     r0,#64<<16
          BGE     Fskip_2
          CMP     r0,#0
          BLT     Fskip_2

          CMP     r1,#64<<16
          BGE     Fskip_2
          CMP     r1,#0
          BLT     Fskip_2

      ;construct address from x & y values
          MOV     r6,r0,ASR #16
          MOV     r7,r1,ASR #16
          ADD     r6,r6,r7,LSL #6

          ;load byte from map + (x + 64(y))
          LDRB    r9,[r3,r6]
          ORR     r8,r8,r9,LSL #8

Fskip_2    ;update x & y
          ADD     r0,r0,r4
          ADD     r1,r1,r5


      ;load byte 3 word 1
      ;check limits of x and y
          CMP     r0,#64<<16
          BGE     Fskip_3
          CMP     r0,#0
          BLT     Fskip_3

          CMP     r1,#64<<16
          BGE     Fskip_3
          CMP     r1,#0
          BLT     Fskip_3

      ;construct address from x & y values
          MOV     r6,r0,ASR #16
          MOV     r7,r1,ASR #16
          ADD     r6,r6,r7,LSL #6

          ;load byte from map + (x + 64(y))
          LDRB    r9,[r3,r6]
          ORR     r8,r8,r9,LSL #16

Fskip_3    ;update x & y
          ADD     r0,r0,r4
          ADD     r1,r1,r5

      ;load byte 4 word 1
      ;check limits of x and y
          CMP     r0,#64<<16
          BGE     Fskip_4
          CMP     r0,#0
          BLT     Fskip_4

          CMP     r1,#64<<16
          BGE     Fskip_4
          CMP     r1,#0
          BLT     Fskip_4

      ;construct address from x & y values
          MOV     r6,r0,ASR #16
          MOV     r7,r1,ASR #16
          ADD     r6,r6,r7,LSL #6

          ;load byte from map + (x + 64(y))
          LDRB    r9,[r3,r6]
          ORR     r8,r8,r9,LSL #24

Fskip_4    ;update x & y
          ADD     r0,r0,r4
          ADD     r1,r1,r5

      ;load byte 1 word 2
      ;check limits of x and y
          CMP     r0,#64<<16
          BGE     Fskip_5
          CMP     r0,#0
          BLT     Fskip_5

          CMP     r1,#64<<16
          BGE     Fskip_5
          CMP     r1,#0
          BLT     Fskip_5

      ;construct address from x & y values
          MOV     r6,r0,ASR #16
          MOV     r7,r1,ASR #16
          ADD     r6,r6,r7,LSL #6

          ;load byte from map + (x + 64(y))
          LDRB    r9,[r3,r6]

Fskip_5    ;update x & y
          ADD     r0,r0,r4
          ADD     r1,r1,r5

      ;load byte 2 word 2
      ;check limits of x and y
          CMP     r0,#64<<16
          BGE     Fskip_6
          CMP     r0,#0
          BLT     Fskip_6

          CMP     r1,#64<<16
          BGE     Fskip_6
          CMP     r1,#0
          BLT     Fskip_6

      ;construct address from x & y values
          MOV     r6,r0,ASR #16
          MOV     r7,r1,ASR #16
          ADD     r6,r6,r7,LSL #6

          ;load byte from map + (x + 64(y))
          LDRB    r10,[r3,r6]
          ORR     r9,r9,r10,LSL #8

Fskip_6    ;update x & y
          ADD     r0,r0,r4
          ADD     r1,r1,r5

      ;load byte 3 word 2
      ;check limits of x and y
          CMP     r0,#64<<16
          BGE     Fskip_7
          CMP     r0,#0
          BLT     Fskip_7

          CMP     r1,#64<<16
          BGE     Fskip_7
          CMP     r1,#0
          BLT     Fskip_7

      ;construct address from x & y values
          MOV     r6,r0,ASR #16
          MOV     r7,r1,ASR #16
          ADD     r6,r6,r7,LSL #6

          ;load byte from map + (x + 64(y))
          LDRB    r10,[r3,r6]
          ORR     r9,r9,r10,LSL #16

Fskip_7    ;update x & y
          ADD     r0,r0,r4
          ADD     r1,r1,r5

      ;load byte 4 word 2
      ;check limits of x and y
          CMP     r0,#64<<16
          BGE     Fskip_8
          CMP     r0,#0
          BLT     Fskip_8

          CMP     r1,#64<<16
          BGE     Fskip_8
          CMP     r1,#0
          BLT     Fskip_8

      ;construct address from x & y values
          MOV     r6,r0,ASR #16
          MOV     r7,r1,ASR #16
          ADD     r6,r6,r7,LSL #6

          ;load byte from map + (x + 64(y))
          LDRB    r10,[r3,r6]
          ORR     r9,r9,r10,LSL #24

Fskip_8    ;update x & y
          ADD     r0,r0,r4
          ADD     r1,r1,r5

      ;load byte 1 word 3
      ;check limits of x and y
          CMP     r0,#64<<16
          BGE     Fskip_9
          CMP     r0,#0
          BLT     Fskip_9

          CMP     r1,#64<<16
          BGE     Fskip_9
          CMP     r1,#0
          BLT     Fskip_9

      ;construct address from x & y values
          MOV     r6,r0,ASR #16
          MOV     r7,r1,ASR #16
          ADD     r6,r6,r7,LSL #6

          ;load byte from map + (x + 64(y))
          LDRB    r10,[r3,r6]

Fskip_9    ;update x & y
          ADD     r0,r0,r4
          ADD     r1,r1,r5

      ;load byte 2 word 3
      ;check limits of x and y
          CMP     r0,#64<<16
          BGE     Fskip_10
          CMP     r0,#0
          BLT     Fskip_10

          CMP     r1,#64<<16
          BGE     Fskip_10
          CMP     r1,#0
          BLT     Fskip_10

      ;construct address from x & y values
          MOV     r6,r0,ASR #16
          MOV     r7,r1,ASR #16
          ADD     r6,r6,r7,LSL #6

          ;load byte from map + (x + 64(y))
          LDRB    r11,[r3,r6]
          ORR     r10,r10,r11,LSL #8

Fskip_10   ;update x & y
          ADD     r0,r0,r4
          ADD     r1,r1,r5

      ;load byte 3 word 3
      ;check limits of x and y
          CMP     r0,#64<<16
          BGE     Fskip_11
          CMP     r0,#0
          BLT     Fskip_11

          CMP     r1,#64<<16
          BGE     Fskip_11
          CMP     r1,#0
          BLT     Fskip_11

      ;construct address from x & y values
          MOV     r6,r0,ASR #16
          MOV     r7,r1,ASR #16
          ADD     r6,r6,r7,LSL #6

          ;load byte from map + (x + 64(y))
          LDRB    r11,[r3,r6]
          ORR     r10,r10,r11,LSL #16

Fskip_11   ;update x & y
          ADD     r0,r0,r4
          ADD     r1,r1,r5

      ;load byte 4 word 3
      ;check limits of x and y
          CMP     r0,#64<<16
          BGE     Fskip_12
          CMP     r0,#0
          BLT     Fskip_12

          CMP     r1,#64<<16
          BGE     Fskip_12
          CMP     r1,#0
          BLT     Fskip_12

      ;construct address from x & y values
          MOV     r6,r0,ASR #16
          MOV     r7,r1,ASR #16
          ADD     r6,r6,r7,LSL #6

          ;load byte from map + (x + 64(y))
          LDRB    r11,[r3,r6]
          ORR     r10,r10,r11,LSL #24

Fskip_12   ;update x & y
          ADD     r0,r0,r4
          ADD     r1,r1,r5

      ;load byte 1 word 4
      ;check limits of x and y
          CMP     r0,#64<<16
          BGE     Fskip_13
          CMP     r0,#0
          BLT     Fskip_13

          CMP     r1,#64<<16
          BGE     Fskip_13
          CMP     r1,#0
          BLT     Fskip_13

      ;construct address from x & y values
          MOV     r6,r0,ASR #16
          MOV     r7,r1,ASR #16
          ADD     r6,r6,r7,LSL #6

          ;load byte from map + (x + 64(y))
          LDRB    r11,[r3,r6]

Fskip_13   ;update x & y
          ADD     r0,r0,r4
          ADD     r1,r1,r5

      ;load byte 2 word 4
      ;check limits of x and y
          CMP     r0,#64<<16
          BGE     Fskip_14
          CMP     r0,#0
          BLT     Fskip_14

          CMP     r1,#64<<16
          BGE     Fskip_14
          CMP     r1,#0
          BLT     Fskip_14

      ;construct address from x & y values
          MOV     r6,r0,ASR #16
          MOV     r7,r1,ASR #16
          ADD     r6,r6,r7,LSL #6

          ;load byte from map + (x + 64(y))
          LDRB    r7,[r3,r6]
          ORR     r11,r11,r7,LSL #8

Fskip_14   ;update x & y
          ADD     r0,r0,r4
          ADD     r1,r1,r5

      ;load byte 3 word 4
      ;check limits of x and y
          CMP     r0,#64<<16
          BGE     Fskip_15
          CMP     r0,#0
          BLT     Fskip_15

          CMP     r1,#64<<16
          BGE     Fskip_15
          CMP     r1,#0
          BLT     Fskip_15

      ;construct address from x & y values
          MOV     r6,r0,ASR #16
          MOV     r7,r1,ASR #16
          ADD     r6,r6,r7,LSL #6

          ;load byte from map + (x + 64(y))
          LDRB    r7,[r3,r6]
          ORR     r11,r11,r7,LSL #16

Fskip_15   ;update x & y
          ADD     r0,r0,r4
          ADD     r1,r1,r5

      ;load byte 4 word 4
      ;check limits of x and y
          CMP     r0,#64<<16
          BGE     Fskip_16
          CMP     r0,#0
          BLT     Fskip_16

          CMP     r1,#64<<16
          BGE     Fskip_16
          CMP     r1,#0
          BLT     Fskip_16

      ;construct address from x & y values
          MOV     r6,r0,ASR #16
          MOV     r7,r1,ASR #16
          ADD     r6,r6,r7,LSL #6

          ;load byte from map + (x + 64(y))
          LDRB    r7,[r3,r6]
          ORR     r11,r11,r7,LSL #24

Fskip_16   ;update x & y
          ADD     r0,r0,r4
          ADD     r1,r1,r5

      ;store on screen
      STMIA   r2,{r8-r11}
      ADD     r2,r2,#320
      STMIA   r2!,{r8-r11}
      SUB     r2,r2,#320

      ;update inner counter
          SUB     r12,r12,#16
          MOVS    r6,r12,LSL #16
      BNE     FDraw_Line

             ;update line start coordinates

          ;load original points from last line
      LDMIA   r14,{r0,r1}
          ;load line increments
          LDR     r6,[r14,#24]
          LDR     r7,[r14,#28]

      ADD     r0,r0,r6,LSL #1
          ADD     r1,r1,r7,LSL #1

      STMIA   r14,{r0,r1}

      ;update screen start for next line
      ADD     r2,r2,#256
      ADD     r2,r2,#960

          ;update inner counter
          SUB     r12,r12,#2<<16
      MOVS    r6,r12,LSR #16
      BNE     FOuter_Draw_Line

EndPlotFadedMap
          LDMFD   r13!,{r0-r12,pc}


      END