home *** CD-ROM | disk | FTP | other *** search
/ Graphics Programming Black Book (Special Edition) / BlackBook.bin / disk1 / source / chapter24 / l24-1.asm next >
Assembly Source File  |  1997-06-18  |  10KB  |  254 lines
  1. ; Program to illustrate operation of ALUs and latches of the VGA's
  2. ;  Graphics Controller.  Draws a variety of patterns against
  3. ;  a horizontally striped background, using each of the 4 available
  4. ;  logical functions (data unmodified, AND, OR, XOR) in turn to combine
  5. ;  the images with the background.
  6. ; Assembled with TASM 4.0, linked with TLINK 6.10
  7. ; Checked by Jim Mischel, 11/21/94
  8. ;
  9. stack   segment para stack 'STACK'
  10.         db      512 dup(?)
  11. stack   ends
  12. ;
  13. VGA_VIDEO_SEGMENT       equ     0a000h  ;VGA display memory segment
  14. SCREEN_HEIGHT           equ     350
  15. SCREEN_WIDTH_IN_BYTES   equ     80
  16. DEMO_AREA_HEIGHT        equ     336     ;# of scan lines in area
  17.                                         ; logical function operation
  18.                                         ; is demonstrated in
  19. DEMO_AREA_WIDTH_IN_BYTES equ    40      ;width in bytes of area
  20.                                         ; logical function operation
  21.                                         ; is demonstrated in
  22. VERTICAL_BOX_WIDTH_IN_BYTES equ 10      ;width in bytes of the box used to
  23.                                         ; demonstrate each logical function
  24. ;
  25. ; VGA register equates.
  26. ;
  27. GC_INDEX        equ     3ceh    ;GC index register
  28. GC_ROTATE       equ     3       ;GC data rotate/logical function
  29.                                 ; register index
  30. GC_MODE         equ     5       ;GC mode register index
  31. ;
  32. dseg    segment para common 'DATA'
  33. ;
  34. ; String used to label logical functions.
  35. ;
  36. LabelString     label   byte
  37.         db      'UNMODIFIED    AND       OR        XOR   '
  38. LABEL_STRING_LENGTH     equ     $-LabelString
  39. ;
  40. ; Strings used to label fill patterns.
  41. ;
  42. FillPatternFF   db      'Fill Pattern: 0FFh'
  43. FILL_PATTERN_FF_LENGTH  equ     $ - FillPatternFF
  44. FillPattern00   db      'Fill Pattern: 000h'
  45. FILL_PATTERN_00_LENGTH  equ     $ - FillPattern00
  46. FillPatternVert db      'Fill Pattern: Vertical Bar'
  47. FILL_PATTERN_VERT_LENGTH        equ     $ - FillPatternVert
  48. FillPatternHorz db      'Fill Pattern: Horizontal Bar'
  49. FILL_PATTERN_HORZ_LENGTH equ    $ - FillPatternHorz
  50. ;
  51. dseg    ends
  52. ;
  53. ; Macro to set indexed register INDEX of GC chip to SETTING.
  54. ;
  55. SETGC   macro   INDEX, SETTING
  56.         mov     dx,GC_INDEX
  57.         mov     ax,(SETTING SHL 8) OR INDEX
  58.         out     dx,ax
  59.         endm
  60. ;
  61. ;
  62. ; Macro to call BIOS write string function to display text string
  63. ;  TEXT_STRING, of length TEXT_LENGTH, at location ROW,COLUMN.
  64. ;
  65. TEXT_UP macro   TEXT_STRING, TEXT_LENGTH, ROW, COLUMN
  66.         mov     ah,13h                  ;BIOS write string function
  67.         mov     bp,offset TEXT_STRING   ;ES:BP points to string
  68.         mov     cx,TEXT_LENGTH
  69.         mov     dx,(ROW SHL 8) OR COLUMN        ;position
  70.         sub     al,al           ;string is chars only, cursor not moved
  71.         mov     bl,7            ;text attribute is white (light gray)
  72.         int     10h
  73.         endm
  74. ;
  75. cseg    segment para public 'CODE'
  76.         assume  cs:cseg, ds:dseg
  77. start   proc    near
  78.         mov     ax,dseg
  79.         mov     ds,ax
  80. ;
  81. ; Select 640x350 graphics mode.
  82. ;
  83.         mov     ax,010h
  84.         int     10h
  85. ;
  86. ; ES points to VGA memory.
  87. ;
  88.         mov     ax,VGA_VIDEO_SEGMENT
  89.         mov     es,ax
  90. ;
  91. ; Draw background of horizontal bars.
  92. ;
  93.         mov     dx,SCREEN_HEIGHT/4
  94.                                 ;# of bars to draw (each 4 pixels high)
  95.         sub     di,di           ;start at offset 0 in display memory
  96.         mov     ax,0ffffh       ;fill pattern for light areas of bars
  97.         mov     bx,DEMO_AREA_WIDTH_IN_BYTES / 2 ;length of each bar
  98.         mov     si,SCREEN_WIDTH_IN_BYTES - DEMO_AREA_WIDTH_IN_BYTES
  99.         mov     bp,(SCREEN_WIDTH_IN_BYTES * 3) - DEMO_AREA_WIDTH_IN_BYTES
  100. BackgroundLoop:
  101.         mov     cx,bx           ;length of bar
  102.     rep stosw                   ;draw top half of bar
  103.         add     di,si           ;point to start of bottom half of bar
  104.         mov     cx,bx           ;length of bar
  105.     rep stosw                   ;draw bottom half of bar
  106.         add     di,bp           ;point to start of top of next bar
  107.         dec     dx
  108.         jnz     BackgroundLoop
  109. ;
  110. ; Draw vertical boxes filled with a variety of fill patterns
  111. ;  using each of the 4 logical functions in turn.
  112. ; 
  113.         SETGC   GC_ROTATE, 0            ;select data unmodified
  114.                                         ; logical function...
  115.         mov     di,0
  116.         call    DrawVerticalBox         ;...and draw box
  117. ;
  118.         SETGC   GC_ROTATE, 08h          ;select AND logical function...
  119.         mov     di,10
  120.         call    DrawVerticalBox         ;...and draw box
  121. ;
  122.         SETGC   GC_ROTATE, 10h          ;select OR logical function...
  123.         mov     di,20
  124.         call    DrawVerticalBox         ;...and draw box
  125. ;
  126.         SETGC   GC_ROTATE, 18h          ;select XOR logical function...
  127.         mov     di,30
  128.         call    DrawVerticalBox         ;...and draw box
  129. ;
  130. ; Reset the logical function to data unmodified, the default state.
  131. ;
  132.         SETGC   GC_ROTATE, 0
  133. ;
  134. ; Label the screen.
  135. ;
  136.         push    ds
  137.         pop     es      ;strings we'll display are passed to BIOS
  138.                         ; by pointing ES:BP to them
  139. ;
  140. ; Label the logical functions, using the VGA BIOS's
  141. ;  write string function.
  142. ;
  143.         TEXT_UP LabelString, LABEL_STRING_LENGTH, 24, 0
  144. ;
  145. ; Label the fill patterns, using the VGA BIOS's
  146. ;  write string function.
  147. ;
  148.         TEXT_UP FillPatternFF, FILL_PATTERN_FF_LENGTH, 3, 42
  149.         TEXT_UP FillPattern00, FILL_PATTERN_00_LENGTH, 9, 42
  150.         TEXT_UP FillPatternVert, FILL_PATTERN_VERT_LENGTH, 15, 42
  151.         TEXT_UP FillPatternHorz, FILL_PATTERN_HORZ_LENGTH, 21, 42
  152. ;
  153. ; Wait until a key's been hit to reset screen mode & exit.
  154. ;
  155. WaitForKey:
  156.         mov     ah,1
  157.         int     16h
  158.         jz      WaitForKey
  159. ;
  160. ; Finished.  Clear key, reset screen mode and exit.
  161. ;
  162. Done:
  163.         mov     ah,0    ;clear key that we just detected
  164.         int     16h
  165. ;
  166.         mov     ax,3    ;reset to text mode
  167.         int     10h
  168. ;
  169.         mov     ah,4ch  ;exit to DOS
  170.         int     21h
  171. ;
  172. start   endp
  173. ; 
  174. ; Subroutine to draw a box 80x336 in size, using currently selected
  175. ;  logical function, with upper left corner at the display memory offset
  176. ;  in DI.  Box is filled with four patterns.  Top quarter of area is
  177. ;  filled with 0FFh (solid) pattern, next quarter is filled with 00h
  178. ;  (empty) pattern, next quarter is filled with 33h (double pixel wide
  179. ;  vertical bar) pattern, and bottom quarter is filled with double pixel
  180. ;  high horizontal bar pattern.
  181. ;
  182. ; Macro to draw a column of the specified width in bytes, one- quarter
  183. ;  of the height of the box, with the specified fill pattern.
  184. ;
  185. DRAW_BOX_QUARTER        macro   FILL, WIDTH
  186.         local   RowLoop, ColumnLoop
  187.         mov     al,FILL                 ;fill pattern
  188.         mov     dx,DEMO_AREA_HEIGHT / 4 ;1/4 of the full box height
  189. RowLoop:
  190.         mov     cx,WIDTH
  191. ColumnLoop:
  192.         mov     ah,es:[di]      ;load display memory contents into
  193.                                 ; GC latches (we don't actually care
  194.                                 ; about value read into AH)
  195.         stosb                   ;write pattern, which is logically
  196.                                 ; combined with latch contents for each
  197.                                 ; plane and then written to display
  198.                                 ; memory
  199.         loop    ColumnLoop
  200.         add     di,SCREEN_WIDTH_IN_BYTES - WIDTH
  201.                                 ;point to start of next line down in box
  202.         dec     dx
  203.         jnz     RowLoop
  204.         endm
  205. ;
  206. DrawVerticalBox proc    near
  207.         DRAW_BOX_QUARTER        0ffh, VERTICAL_BOX_WIDTH_IN_BYTES
  208.                                         ;first fill pattern: solid fill
  209.         DRAW_BOX_QUARTER        0, VERTICAL_BOX_WIDTH_IN_BYTES
  210.                                         ;second fill pattern: empty fill
  211.         DRAW_BOX_QUARTER        033h, VERTICAL_BOX_WIDTH_IN_BYTES
  212.                                         ;third fill pattern: double-pixel
  213.                                         ; wide vertical bars
  214.         mov     dx,DEMO_AREA_HEIGHT / 4 / 4
  215.                                 ;fourth fill pattern: horizontal bars in
  216.                                 ; sets of 4 scan lines
  217.         sub     ax,ax
  218.         mov     si,VERTICAL_BOX_WIDTH_IN_BYTES  ;width of fill area
  219. HorzBarLoop:
  220.         dec     ax              ;0ffh fill (faster to do word than byte DEC)
  221.         mov     cx,si           ;width to fill
  222. HBLoop1:
  223.         mov     bl,es:[di]      ;load latches (don't care about value)
  224.         stosb                   ;write solid pattern, through ALUs
  225.         loop    HBLoop1
  226.         add     di,SCREEN_WIDTH_IN_BYTES - VERTICAL_BOX_WIDTH_IN_BYTES
  227.         mov     cx,si           ;width to fill
  228. HBLoop2:
  229.         mov     bl,es:[di]      ;load latches
  230.         stosb                   ;write solid pattern, through ALUs
  231.         loop    HBLoop2
  232.         add     di,SCREEN_WIDTH_IN_BYTES - VERTICAL_BOX_WIDTH_IN_BYTES
  233.         inc     ax              ;0 fill (faster to do word than byte DEC)
  234.         mov     cx,si           ;width to fill
  235. HBLoop3:
  236.         mov     bl,es:[di]      ;load latches
  237.         stosb                   ;write empty pattern, through ALUs
  238.         loop    HBLoop3
  239.         add     di,SCREEN_WIDTH_IN_BYTES - VERTICAL_BOX_WIDTH_IN_BYTES
  240.         mov     cx,si           ;width to fill
  241. HBLoop4:
  242.         mov     bl,es:[di]      ;load latches
  243.         stosb                   ;write empty pattern, through ALUs
  244.         loop    HBLoop4
  245.         add     di,SCREEN_WIDTH_IN_BYTES - VERTICAL_BOX_WIDTH_IN_BYTES
  246.         dec     dx
  247.         jnz     HorzBarLoop
  248. ;       
  249.         ret
  250. DrawVerticalBox endp
  251. cseg    ends
  252.         end     start
  253.  
  254.