--- /dev/null
+; SPRITE routines\r
+MAX_SPRITE EQU 100\r
+\r
+RECTANGLE STRUCT 2,NONUNIQUE\r
+ X WORD 0\r
+ Y WORD 0\r
+ Wid4 BYTE 0\r
+ Ht BYTE 0\r
+ Color BYTE 0\r
+ Next WORD 0\r
+ ; DrawMe is used to not bother with sprites that you know\r
+ ; are contained totally within another, allowing animated\r
+ ; eyes, etc to be stored in separate sprites. These will be\r
+ ; drawn to the local buffer but skipped when copying to the\r
+ ; screen, so if they are not TOTALLY contained, they will\r
+ ; just get clipped away.\r
+ DrawMe BYTE 1 ; default, yes draw me.\r
+ ; (Storage from this point on ... NEVER provide anything but\r
+ ; default for these values!)\r
+ address_virt WORD 0\r
+ address_buf WORD 0\r
+ next_line_virt WORD 0\r
+ next_line_buf WORD 0\r
+RECTANGLE ENDS\r
+\r
+SPRITE STRUCT 2, NONUNIQUE\r
+ RECTANGLE <> ; Contains rectangle info\r
+SPRITE ENDS\r
+\r
+EVEN\r
+rect5 SPRITE <<40 ,60 , 2,8, C_TRANSPARENT, 0 , 0>>\r
+rect4 SPRITE <<80 ,30 , 2,8, C_TRANSPARENT, offset rect5, 0>>\r
+rect3 SPRITE <<120,60 , 2,8, C_TRANSPARENT, offset rect4, 0>>\r
+rect2 SPRITE <<55 ,100, 2,8, C_TRANSPARENT, offset rect3, 0>>\r
+rect1 SPRITE <<105,100, 2,8, C_TRANSPARENT, offset rect2, 0>>\r
+\r
+rect6 SPRITE <<36 ,56 , 4,16, C_BLUE, offset rect1, 1>>\r
+rect7 SPRITE <<76 ,26 , 4,16, C_BLUE, offset rect6, 1>>\r
+rect8 SPRITE <<116,56 , 4,16, C_BLUE, offset rect7, 1>>\r
+rect9 SPRITE <<51 ,96 , 4,16, C_BLUE, offset rect8, 1>>\r
+rect10 SPRITE <<101,96 , 4,16, C_BLUE, offset rect9, 1>>\r
+\r
+;; Simply adding in these 5 rectangles (~20000 pixels for both\r
+;; drawing and erasing) really slows things down! That's why\r
+;; it's important to optimize the sprite drawing routines!\r
+rect11 SPRITE <<35 ,55 ,14,36, C_GREEN, offset rect10, 1>>\r
+rect12 SPRITE <<75 ,25 ,14,36, C_GREEN, offset rect11, 1>>\r
+rect13 SPRITE <<115,55 ,14,36, C_GREEN, offset rect12, 1>>\r
+rect14 SPRITE <<50 ,95 ,14,36, C_GREEN, offset rect13, 1>>\r
+rect15 SPRITE <<100,95 ,14,36, C_GREEN, offset rect14, 1>>\r
+\r
+FIRST_SPRITE EQU rect10\r
+\r
+EVEN\r
+AnimateSprites PROC near\r
+ ret\r
+ ; Blank out the draw page, by copying from the blank page\r
+ ; to the draw page all rectangles which had changed. The\r
+ ; blank page must always be entirely blank if this is going\r
+ ; to work!\r
+ mov di,cs:DrawPage.UpperLeftAddress\r
+ add di,cs:DrawPage.ScrollOffset\r
+ mov si,cs:BlankPage.UpperLeftAddress\r
+ add si,cs:BlankPage.ScrollOffset\r
+ mov bp,cs:BlankPage.Rectangles\r
+ call CopyRectangles\r
+\r
+ ; Now draw the sprites. Uses a temporary buffer to ensure\r
+ ; minimal drawing to the screen, but that's not really necessary,\r
+ ; if memory is at a minimum. It's just faster...\r
+ mov bp,offset FIRST_SPRITE\r
+ mov cs:DrawPage.Rectangles,bp\r
+ call do_fill_buffer\r
+ mov di,cs:DrawPage.UpperLeftAddress\r
+ add di,cs:DrawPage.ScrollOffset\r
+ mov bh,cs:DrawPage.AlignmentMask\r
+ mov bp,offset FIRST_SPRITE\r
+ jmp smart_rects ; "call"\r
+AnimateSprites ENDP\r
+\r
+smart_dest DW 0\r
+out_di DW 0\r
+out_si DW 0\r
+\r
+EVEN\r
+smart_rects PROC near\r
+ add di,cs:DrawPage.Address\r
+ mov ds,cs:segBuffer\r
+ mov es,cs:segVideo\r
+ mov dx,3c4h\r
+ mov al,02h\r
+ out dx,al\r
+ inc dx\r
+ mov cs:smart_dest,di\r
+\r
+ ; === Beginning of loop through rectangles! ===\r
+sp_nextrect:\r
+ cmp cs:[bp].RECTANGLE.DrawMe,1\r
+ jne sp_next\r
+ ; Draw this rectangle from the buffer to screen memory.\r
+ ; Calculate the output address.\r
+ mov si,cs:[bp].RECTANGLE.address_buf\r
+ mov di,cs:[bp].RECTANGLE.address_virt\r
+ add di,cs:smart_dest\r
+\r
+ ; Loop over 4 planes\r
+ mov bl,4\r
+sp_plane_loop: mov al,bh\r
+ out dx,al\r
+\r
+ mov cs:out_di,di\r
+ mov cs:out_si,si\r
+\r
+ ; Loop over height\r
+ mov ch,cs:[bp].RECTANGLE.Ht\r
+sp_row_loop:\r
+\r
+ ; Loop over width of rectangle (Wid4 is actually width/4)\r
+ mov cl,cs:[bp].RECTANGLE.Wid4\r
+sp_col_loop:\r
+\r
+ ; Read a byte from the buffer\r
+ ; Is it transparent (no-modify)? If so, just jump over the draw\r
+ mov al,byte ptr ds:[si]\r
+ cmp al,C_TRANSPARENT\r
+ je sp_next_pixel\r
+ ; Otherwise, draw it on the spreen, and mark it transparent\r
+ ; so that it won't be drawn again.\r
+ mov byte ptr es:[di],al\r
+ mov byte ptr ds:[si],C_TRANSPARENT\r
+\r
+ ; Skip to next 4-byte group (next column that can be drawn in\r
+ ; Mode X) Also increment spreen draw address, but only by 1\r
+ ; because ModeX is 4 pixels per byte\r
+sp_next_pixel:\r
+ add si,4\r
+ inc di\r
+\r
+ dec cl\r
+ jnz sp_col_loop\r
+\r
+ ; End of row. Skip space to get to left edge of next row down\r
+ ; Skip SI = (SCREEN_WIDTH - #bytesdrawn)\r
+ ; Only draw up to height of rectangle\r
+ add si,cs:[bp].RECTANGLE.next_line_buf\r
+ add di,cs:[bp].RECTANGLE.next_line_virt\r
+ dec ch\r
+ jnz sp_row_loop\r
+\r
+ mov di,cs:out_di\r
+ mov si,cs:out_si\r
+ inc si\r
+ rol bh,1\r
+ adc di,0\r
+\r
+ dec bl\r
+ jnz sp_plane_loop\r
+\r
+ ; Follow chain to next rectangle\r
+sp_next: mov bp,cs:[bp].RECTANGLE.Next\r
+ cmp bp,0\r
+ jne sp_nextrect\r
+ ; All done\r
+sp_end: ret\r
+smart_rects ENDP\r
+\r
+; BP -> first rectangle. Follows BP->next, stops when BP = 0\r
+EVEN\r
+do_fill_buffer PROC near\r
+ mov es,cs:segBuffer\r
+\r
+ cmp bp,0\r
+ je fill_end\r
+fill_loop:\r
+\r
+ mov bx,cs:[bp].RECTANGLE.Y\r
+ shl bx,1 ; BX = word index y\r
+ mov di,cs:MultBufWidth[bx] ; DI = SW * y\r
+ mov cx,cs:[bp].RECTANGLE.X ; CX = x\r
+ add di,cx ; DI = (SW * y) + x\r
+ mov cs:[bp].RECTANGLE.address_buf,di ; (DI used later)\r
+\r
+ mov ax,cs:MultVirtWidth[bx] ; AX = (VW/4) * y\r
+ shr cx,2 ; CX = (x / 4)\r
+ add ax,cx ; AX = (VW * y + x)/4\r
+ mov cs:[bp].RECTANGLE.address_virt,ax\r
+\r
+ mov dx,(VIRTUAL_WIDTH / 4)\r
+ sub dl,cs:[bp].RECTANGLE.Wid4 ; DX = (VW - w) / 4\r
+ mov cs:[bp].RECTANGLE.next_line_virt,dx\r
+\r
+ mov dx,(SCREEN_WIDTH / 4)\r
+ sub dl,cs:[bp].RECTANGLE.Wid4 ; DX = (SW - w) / 4\r
+ shl dx,2 ; DX = SW - w\r
+ mov cs:[bp].RECTANGLE.next_line_buf,dx\r
+\r
+ mov ah,cs:[bp].RECTANGLE.Color\r
+ mov al,cs:[bp].RECTANGLE.Color\r
+\r
+ mov ch,cs:[bp].RECTANGLE.Ht\r
+fill_row_loop: mov cl,cs:[bp].RECTANGLE.Wid4\r
+fill_col_loop: mov es:[di],ax\r
+ mov es:[di+2],ax\r
+ add di,4\r
+ dec cl\r
+ jnz fill_col_loop\r
+ add di,dx\r
+ dec ch\r
+ jnz fill_row_loop\r
+\r
+ mov bp,cs:[bp].RECTANGLE.Next\r
+ cmp bp,0\r
+ jne fill_loop\r
+fill_end: ret\r
+do_fill_buffer ENDP\r
+\r
+EVEN\r
+CopyRectangles PROC near\r
+ mov ax,cs:segVideo\r
+ mov ds,ax\r
+ mov es,ax\r
+\r
+ ; Calculate the difference between the source and destination\r
+ ; pages. Since in a movsb loop the two would remain a constant\r
+ ; distance apart, we can just calculate a displacement and then\r
+ ; not have to worry about SI; instead use DI and DI+BX, thanks\r
+ ; to the thoughtful x86 ALU!\r
+ mov bx,di\r
+ sub bx,si\r
+\r
+ mov dx,GC_INDEX\r
+ mov ax,ALL_COPY_BITS\r
+ out dx,ax\r
+\r
+ mov dx,SC_INDEX\r
+ mov ax,0F02h\r
+ out dx,ax\r
+ mov si,di ;store destination\r
+\r
+ ; === Beginning of loop through rectangles! ===\r
+cr_nextrect: cmp cs:[bp].RECTANGLE.DrawMe,1\r
+ jne cr_next\r
+ ; Draw this rectangle from the buffer to screen memory.\r
+ ; Calculate the output address.\r
+ mov di,cs:[bp].RECTANGLE.address_virt\r
+ mov dx,cs:[bp].RECTANGLE.next_line_virt\r
+ add di,si\r
+\r
+ ; Loop over height\r
+ mov ch,cs:[bp].RECTANGLE.Ht\r
+cr_row_loop:\r
+\r
+ ; Loop over width of rectangle (Wid4 is actually width/4)\r
+ mov cl,cs:[bp].RECTANGLE.Wid4\r
+cr_col_loop: mov al,ds:[di + bx]\r
+ stosb\r
+ dec cl\r
+ jnz cr_col_loop\r
+ mov al,ds:[di + bx]\r
+ mov es:[di],al\r
+\r
+ ; End of row. Skip space to get to left edge of next row down\r
+ ; Only draw up to height of rectangle\r
+ add di,dx\r
+ dec ch\r
+ jnz cr_row_loop\r
+\r
+ ; Follow chain to next rectangle\r
+cr_next: mov bp,cs:[bp].RECTANGLE.Next\r
+ cmp bp,0\r
+ jne cr_nextrect\r
+ ; All done\r
+cr_end:\r
+ mov dx,GC_INDEX\r
+ mov ax,ALL_DRAW_BITS\r
+ out dx,ax\r
+ ret\r
+CopyRectangles ENDP\r
+\r
+\1a
\ No newline at end of file
projects / 16.git / blobdiff