--- /dev/null
+;; Global variables used here ...\r
+EVEN\r
+ScrollPosX dw 0 ; Scroll origin, upper-left X\r
+ScrollPosY dw 0 ; Scroll origin, upper-left Y\r
+ScrollDX dw 0 ; Amount to change scroll origin, X\r
+ScrollDY dw 0 ; Amount to change scroll origin, Y\r
+\r
+;; SCROLL:\r
+;; This routine takes care of all of the scrolling, however it calls\r
+;; outside drawing routines to update the screen. Scrollx and\r
+;; Scrolly determine the amount to scroll by.\r
+;; Note that this does only RELATIVE scrolling, not absolute scrolling.\r
+;; Scroll saves time by updating only up to the one row or column of\r
+;; tiles which have come into view due to a change in scroll offset.\r
+;; In other words, it's not good for "jumping" to a particular point,\r
+;; although this effect can be accomplished in other ways -- the draw_full\r
+;; routine is available to draw a full screen again.\r
+;; Sometimes this means that you will have to calculate values ahead of\r
+;; time, for instance if you wish the scrolling to keep a certain sprite\r
+;; in the center of the screen. In this case, just set ScrollDX and\r
+;; ScrollDY to the delta-x and delta-y of the sprite.\r
+;; * Newly added:\r
+;; Since there are three pages, it is necessary to keep each one of them\r
+;; up to date with each scroll. Recently, I was doing some fast (8+\r
+;; pixels per frame) scrolling and noticed that there was a significant\r
+;; pause when the screen snapped to a new origin. (The origin is always\r
+;; at a square's corner, even though it may not look like it because it\r
+;; disguises things by smooth-panning the hardware.) Every time it\r
+;; scrolled, it was drawing the new information and copying it to the\r
+;; two other planes. I've now distributed the load over successive\r
+;; pages, in other words it doesn't copy the new info all at once, but\r
+;; over several frames. This really smoothed out the scrolling so that\r
+;; while there are still some jumps, they only occur very infrequently\r
+;; and then only at 15 or 16 pixel/frame scroll rates...) That's the\r
+;; "catchup" code at the bottom, and that's why it's more complex than\r
+;; it maybe could be...\r
+EVEN\r
+Scroll PROC near\r
+ ; Using the ScrollDX variable as delta-x, move the scroll-origin\r
+ ; in the x direction. Then, if the visible screen is now\r
+ ; viewing invalid data, snap the origin to a new point and\r
+ ; draw any new columns that are necessary.\r
+do_x_scroll: mov ax,cs:ScrollPosX\r
+ add ax,cs:ScrollDX ; ScrollDX is a delta-x\r
+ jl wrap_l ; wrap left if negative\r
+ cmp ax,VIRTUAL_WIDTH - SCREEN_WIDTH ; too far right?\r
+ jge wrap_r ; wrap right if too big\r
+ mov cs:ScrollPosX,ax ; Stores new scroll-x\r
+ ; (just like above, for y:)\r
+ ; Using the ScrollDY variable as delta-y, move the scroll-origin\r
+ ; in the y direction. Then, if the visible screen is now\r
+ ; viewing invalid data, snap the origin to a new point and\r
+ ; draw any new rows that are necessary.\r
+do_y_scroll: mov ax,cs:ScrollPosY\r
+ add ax,cs:ScrollDY ; ScrollDY is a delta-y\r
+ jl wrap_t ; wrap top if negative\r
+ cmp ax,(VIRTUAL_HEIGHT - SCREEN_HEIGHT) * VIRTUAL_WIDTH\r
+ jge wrap_b ; wrap bottom if too big\r
+ mov cs:ScrollPosY,ax ; Store the new scroll-y\r
+ jmp calculate\r
+\r
+ ; To wrap to the right:\r
+ ; Add a square's width to the origin's upper left corner, and\r
+ ; subtract the same amount from the scroll origin's upper left\r
+ ; corner. This makes no difference on the screen but allows\r
+ ; us to forget about the leftmost column on the screen (it's\r
+ ; offscreen now...) so we can take over the right column.\r
+ ; See any documentation I included for an explanation of the\r
+EVEN ; scrolling...\r
+wrap_r: add cs:upper_left,SQUARE_WIDTH / 4\r
+ sub ax,SQUARE_WIDTH\r
+ mov cs:ScrollPosX,ax\r
+\r
+ mov dx,MapInfo.Wid\r
+ mov bp,MapInfo.OffX1\r
+ inc bp\r
+ cmp bp,dx\r
+ jb wrap_r1_ok\r
+ sub bp,dx\r
+wrap_r1_ok: mov MapInfo.OffX1,bp\r
+\r
+ mov bp,MapInfo.OffX2\r
+ inc bp\r
+ cmp bp,dx\r
+ jb wrap_r2_ok\r
+ sub bp,dx\r
+wrap_r2_ok: mov MapInfo.OffX2,bp\r
+\r
+ mov bp,MapInfo.WrapX\r
+ dec bp\r
+ jnz wrap_r3_ok\r
+ add bp,dx\r
+wrap_r3_ok: mov MapInfo.WrapX,bp\r
+\r
+ call update_right\r
+ jmp do_y_scroll ; Jump back to do Y\r
+\r
+EVEN ; Same for left side\r
+wrap_l: sub cs:upper_left,SQUARE_WIDTH / 4\r
+ add ax,SQUARE_WIDTH\r
+ mov cs:ScrollPosX,ax\r
+\r
+ mov dx,MapInfo.Wid\r
+ mov bp,MapInfo.OffX1\r
+ dec bp\r
+ cmp bp,dx\r
+ jb wrap_l1_ok\r
+ add bp,dx\r
+wrap_l1_ok: mov MapInfo.OffX1,bp\r
+\r
+ mov bp,MapInfo.OffX2\r
+ dec bp\r
+ cmp bp,dx\r
+ jb wrap_l2_ok\r
+ add bp,dx\r
+wrap_l2_ok: mov MapInfo.OffX2,bp\r
+\r
+ mov bp,MapInfo.WrapX\r
+ inc bp\r
+ cmp bp,dx\r
+ jbe wrap_l3_ok\r
+ sub bp,dx\r
+wrap_l3_ok: mov MapInfo.WrapX,bp\r
+\r
+ call update_left\r
+ jmp do_y_scroll ; Jump back to do Y\r
+\r
+EVEN ; Same for bottom\r
+wrap_b: add cs:upper_left,(SQUARE_HEIGHT * VIRTUAL_WIDTH) / 4\r
+ sub ax,SQUARE_HEIGHT * VIRTUAL_WIDTH\r
+ mov cs:ScrollPosY,ax\r
+\r
+ mov bp,MapInfo.OffY1\r
+ mov dx,MapInfo.Extent\r
+ add bp,MapInfo.Wid\r
+ cmp bp,dx\r
+ jb wrap_b1_ok\r
+ sub bp,dx\r
+wrap_b1_ok: mov MapInfo.OffY1,bp\r
+\r
+ mov bp,MapInfo.OffY2\r
+ add bp,MapInfo.Wid\r
+ cmp bp,dx\r
+ jb wrap_b2_ok\r
+ sub bp,dx\r
+wrap_b2_ok: mov MapInfo.OffY2,bp\r
+\r
+ mov dx,MapInfo.Ht\r
+ mov bp,MapInfo.WrapY\r
+ dec bp\r
+ jg wrap_b3_ok\r
+ add bp,dx\r
+wrap_b3_ok: mov MapInfo.WrapY,bp\r
+\r
+ call update_bottom\r
+ mov ax,cs:ScrollPosY\r
+ jmp calculate ; Jump down to calc new offsets\r
+\r
+EVEN ; Same for top\r
+wrap_t: sub cs:upper_left,(SQUARE_HEIGHT * VIRTUAL_WIDTH) / 4\r
+ add ax,SQUARE_HEIGHT * VIRTUAL_WIDTH\r
+ mov cs:ScrollPosY,ax\r
+\r
+ mov bp,MapInfo.OffY1\r
+ mov dx,MapInfo.Extent\r
+ sub bp,MapInfo.Wid\r
+ cmp bp,dx\r
+ jb wrap_t1_ok\r
+ add bp,dx\r
+wrap_t1_ok: mov MapInfo.OffY1,bp\r
+\r
+ mov bp,MapInfo.OffY2\r
+ sub bp,MapInfo.Wid\r
+ cmp bp,dx\r
+ jb wrap_t2_ok\r
+ add bp,dx\r
+wrap_t2_ok: mov MapInfo.OffY2,bp\r
+\r
+ mov bp,MapInfo.WrapY\r
+ mov dx,MapInfo.Ht\r
+ inc bp\r
+ cmp bp,dx\r
+ jbe wrap_t3_ok\r
+ sub bp,dx\r
+wrap_t3_ok: mov MapInfo.WrapY,bp\r
+\r
+ call update_top\r
+ mov ax,cs:ScrollPosY\r
+ jmp calculate ; Jump down to calc new offsets\r
+\r
+EVEN\r
+align_mask_table DB 11h,22h,44h,88h\r
+calculate:\r
+ ; Calculate the scroll offset\r
+ ; AX already = ScrollPosY\r
+ add ax,cs:ScrollPosX ;Now AX = scroll offset\r
+\r
+ ; Calculate the plane alignment\r
+ mov bl,al\r
+ and bx,0003h\r
+ mov cs:DrawPage.Alignment,bl\r
+; mov bl,cs:align_mask_table[bx]\r
+; mov cs:DrawPage.AlignmentMask,bl\r
+\r
+ ; Now we don't need Scroll Offset on a pixel level any more,\r
+ ; so shift it to a byte level (/4) and store it away.\r
+ shr ax,2\r
+ mov cs:DrawPage.ScrollOffset,ax\r
+\r
+ ; Calculate the actual upper left corner address\r
+ mov si,cs:DrawPage.Address\r
+ add si,cs:upper_left\r
+ mov cs:DrawPage.UpperLeftAddress,si\r
+\r
+ ; And the map offset:\r
+ mov bx,MapInfo.WrapX\r
+ mov cs:DrawPage.MapPosX,bx\r
+ mov di,MapInfo.WrapY\r
+ mov cs:DrawPage.MapPosY,di\r
+\r
+ mov cs:DrawPage.Valid,1\r
+ cmp cs:BlankPage.Valid,0\r
+ je no_catch_up\r
+\r
+ ; Lastly, update dirty area (if any) on blank page.\r
+ ; BP still contains the draw page's mapoffset.\r
+ sub bx,cs:BlankPage.MapPosX\r
+ sub di,cs:BlankPage.MapPosY\r
+ jnz yes_catch_up\r
+ cmp bx,0\r
+ jnz yes_catch_up\r
+ ; No catchup necessary -- return.\r
+no_catch_up: ret\r
+\r
+;; Okay, this stuff is a mess. I've registerized everything except\r
+;; for the video data itself. I'll try to comment it best I can.\r
+EVEN\r
+yes_catch_up:\r
+ ; First, switch into full-copy mode. This means latching the\r
+ ; bit mask as coming entirely from the local 32-bit registers\r
+ ; and then setting the map mask to write to all 4 planes. This\r
+ ; is Mode X's greatest advantage, when you can do it! It\r
+ ; provides a 2x speedup or so...\r
+ mov dx,SC_INDEX ; Select Sequencer input\r
+ mov ax,0F02h\r
+ out dx,ax ; set map mask = all bits\r
+\r
+ mov dx,GC_INDEX\r
+ mov ax,ALL_COPY_BITS\r
+ out dx,ax\r
+\r
+ JKEYNP kB,isntbp\r
+isbp: nop\r
+isntbp:\r
+ ; Next, calculate the amount to catch up the top/bottom rows\r
+ ; If we just wrapped over the edge, it is possible that the\r
+ ; distance traveled will be as high as MapInfo.Ht - 1. So,\r
+ ; in the fashion of signed numbers, if the number is greater\r
+ ; than MapInfo.Ht / 2, we take it to mean negative. To convert\r
+ ; it to signed, we have to shift it into the proper range. But\r
+ ; if it's less than MapInfo.Ht / 2, then it's okay as it is.\r
+ mov ax,di\r
+ cmp ax,0\r
+ je y_mod\r
+\r
+ mov cx,MapInfo.Ht\r
+ cwd ; DX = -1 or 0 based on AX's sign.\r
+ and dx,cx ; DX = Ht or 0\r
+ add ax,dx ; AX = 0 ... Ht (unsigned)\r
+\r
+ mov di,ax\r
+ shl di,1\r
+ cmp di,cx\r
+ jb y_signed\r
+ sub ax,cx\r
+y_signed: neg ax\r
+\r
+ ; Find DI MOD MapInfo.Wid, and then convert to it into virtual\r
+ ; coordinates from map offset coordinates.\r
+ ; This routine also calculates BP, which will be used as a loop\r
+ ; counter to determine how many rows to draw on the left/right\r
+ ; column copy.\r
+y_mod: mov bp,ax\r
+ cwd\r
+ add bp,dx\r
+ xor bp,dx\r
+ shl bp,3 ; BP = (SQUARE_HEIGHT / 2) * dX\r
+ mov di,cs:MultVirtWidth[bp] ; Use multiplication table\r
+ add di,dx ; to calculate new DI, then\r
+ xor di,dx ; restore the sign.\r
+ sub bp,VIRTUAL_HEIGHT / 2\r
+ ; Out: DI = # of pixels traveled,\r
+ ; BP = (VIRTUAL_HEIGHT - # of rows) / 2\r
+\r
+ ; Change BX (delta-x) to signed from unsigned, store in AX\r
+ mov ax,bx\r
+ mov cx,MapInfo.Wid\r
+ cwd\r
+ and dx,cx ; DX = Wid or 0\r
+ add ax,dx ; AX = 0 ... Wid\r
+\r
+ mov bx,ax\r
+ shl bx,1\r
+ cmp bx,cx\r
+ jb x_signed\r
+ sub ax,cx\r
+x_signed:\r
+\r
+ ; The following is an optimization which would slow down on\r
+ ; normal memory, but I believe it will be okay on VGA memory,\r
+ ; which is so incredibly slow. Basically, I've replaced all\r
+ ; "rep movsb"'s with a loop that first calculates "bx = di - si",\r
+ ; and then loops performing "mov ds:[si],es:[si+bx]". Why?\r
+ ; Because of several reasons, none of which I'm sure actually\r
+ ; help out, but they do make for smaller code. 1) It means that\r
+ ; I only have to maintain SI, and "DI" is maintained automatically\r
+ ; (because DI - SI should remain constant). 2) Don't have to\r
+ ; calculate DS. Not much gain here. 3) Because I'd already\r
+ ; unrolled the loops, and the "rep movsb"'s had become instead\r
+ ; "mov al, ds:[si] / mov es:[di], al / mov al, ds:[si + 1] /\r
+ ; mov es:[di + 1],al ... etc ... add si, 4 / add di, 4". In\r
+ ; other words, I wasn't using MOVSB anyway. The only advantage\r
+ ; I can see in MOVSB is that it doesn't have to store the answer\r
+ ; in AL so it could be slightly faster. By unrolling the loops,\r
+ ; I'd already made up for that, I think. 4) Normally, using\r
+ ; [SI + BX + 1] would incur a penalty of an additional clock\r
+ ; cycle (because it has to add two indexs + an offset). But\r
+ ; the VGA memory and the '86 CPU can multi-task, and the VGA\r
+ ; is very slow. So by the time the VGA is ready to write the\r
+ ; next byte, the one extra clock cycle has already passed.\r
+ ;\r
+ ; Am I right? Does this make things faster? I have no idea.\r
+ ; I haven't bothered to check both ways. Please let me know\r
+ ; if I've missed something important...\r
+ ;\r
+ ; Here's the calculation of BX. SI is already set.\r
+ ; si already = DrawPage.UpperLeftAddress\r
+ mov bx,cs:BlankPage.Address\r
+ sub bx,cs:DrawPage.Address\r
+\r
+ ; Now, converts SI into "1/4" units. I do all the calculations\r
+ ; in "1/4" scale and then scale back up, mostly because it saved\r
+ ; me some instructions elsewhere.\r
+ shr si,2\r
+ ; Stores this value of SI. This will be restored after doing\r
+ ; the top/bottom copying.\r
+ mov dx,si\r
+\r
+ ; Check if it's necessary to catch up the top or bottom.\r
+catchup_tb: cmp di,0\r
+ je catchup_tb_end\r
+ jl catchup_t\r
+catchup_b: ; COPY BOTTOM\r
+ ; Move SI to point at the bottom of the screen - # of rows\r
+ ; to update.\r
+ add si,((VIRTUAL_WIDTH * VIRTUAL_HEIGHT) / 4) / 4\r
+ sub si,di\r
+ jmp copy_tb\r
+catchup_t: ; COPY_TOP\r
+ ; Leave SI, but add to the "pushed" value of SI the number of\r
+ ; rows that will be drawn. This prevents overlap between top\r
+ ; and right/left when moving diagonally. Also, DI = |DI|\r
+ neg di\r
+ add dx,di\r
+\r
+ ; Now do the actual copying. Shifts SI back into scale "1",\r
+ ; then performs an unrolled loop to copy the entire virtual\r
+ ; width * # of pixel rows. Since DI is already in "1/4" scale,\r
+ ; it is only decremented once for each four pixels drawn.\r
+copy_tb: shl si,2\r
+copy_tb_loop: mov cl,es:[si]\r
+ mov es:[si+bx],cl\r
+ mov cl,es:[si+1]\r
+ mov es:[si+bx+1],cl\r
+ mov cl,es:[si+2]\r
+ mov es:[si+bx+2],cl\r
+ mov cl,es:[si+3]\r
+ mov es:[si+bx+3],cl\r
+ add si,4\r
+ dec di\r
+ jnz copy_tb_loop\r
+catchup_tb_end:\r
+\r
+ ; Next, check to see if it's necessary to draw the right or\r
+ ; the left side.\r
+catchup_rl: cmp ax,0\r
+ je catchup_rl_end\r
+ jg catchup_l\r
+catchup_r: ; COPY RIGHT\r
+ ; Adds to the "pushed" SI the width of the screen, minus\r
+ ; the number of rows to be drawn.\r
+ neg ax\r
+ add dx,(VIRTUAL_WIDTH / 4) / 4\r
+ sub dx,ax\r
+catchup_l: ; COPY LEFT (or nothing)\r
+\r
+ ; Does the actual copying. First pops SI from its stored value\r
+ ; and shifts it back into scale "1"\r
+copy_rl: mov si,dx\r
+ shl si,2\r
+\r
+ ; This is a loop over BP -- which has already been set as\r
+ ; VIRTUAL_HEIGHT - (# of bytes drawn in vertical update)\r
+ ; Again, this loop is unrolled such that it does two rows @\r
+ ; 4 bytes each with every iteration.\r
+ ; This LEA instruction is just a quick MOV DI, SI + 2 *y\r
+ ; DI is used to push the next value of SI for each iteration\r
+ ; of the loop.\r
+copy_rl_loop: lea di,[si + 2*(VIRTUAL_WIDTH/4)]\r
+ mov cx,ax\r
+copy_rl_col: mov dl,es:[si]\r
+ mov es:[si+bx],dl\r
+ mov dl,es:[si+1]\r
+ mov es:[si+bx+1],dl\r
+ mov dl,es:[si+2]\r
+ mov es:[si+bx+2],dl\r
+ mov dl,es:[si+3]\r
+ mov es:[si+bx+3],dl\r
+ mov dl,es:[si+VIRTUAL_WIDTH/4]\r
+ mov es:[si+bx+VIRTUAL_WIDTH/4],dl\r
+ mov dl,es:[si+VIRTUAL_WIDTH/4+1]\r
+ mov es:[si+bx+VIRTUAL_WIDTH/4+1],dl\r
+ mov dl,es:[si+VIRTUAL_WIDTH/4+2]\r
+ mov es:[si+bx+VIRTUAL_WIDTH/4+2],dl\r
+ mov dl,es:[si+VIRTUAL_WIDTH/4+3]\r
+ mov es:[si+bx+VIRTUAL_WIDTH/4+3],dl\r
+ add si,4\r
+ dec cx\r
+ jnz copy_rl_col\r
+ mov si,di ; SI = pop (SI + VIRTUAL_WIDTH/4)\r
+ inc bp ; (BP is negative, so INC it)\r
+ jnz copy_rl_loop\r
+catchup_rl_end:\r
+\r
+ ; Switch back to all-draw mode.\r
+ mov dx,GC_INDEX\r
+ mov ax,ALL_DRAW_BITS\r
+ out dx,ax\r
+ ret\r
+Scroll ENDP\r
+\1a
\ No newline at end of file
projects / 16.git / blobdiff