Garbo

home *** CD-ROM | disk | FTP | other *** search

/ Garbo / Garbo.cdr / pc / source / bgi.src < prev next >

Wrap

C/C++ Source or Header | 1989-05-12 | 46.2 KB | 2,186 lines

/* The following software can be used and modified freely. I can not however be sold in any way. This includes both seperately and compiled into programs. The following is the work I have done on creating .BGI driver files for TURBO-C 2.0 and TURBO PASCAL. Although the majority of the functions work and can be used as is, it is by no means a complete . My main reason for posting this is so that people who want to create their own BGI drivers have a good starting point and a good example to follow. The routines that to block fills/reads have been written a little trickier than need be. This was to make them fast enough to be usable (the tricks are somewhat described in the code where they are used). The two main ingredients that went into this were: 1. A skeleton of a BGI header which was posted to the net sometime ago. 2. The book "Graphics Programming in Turbo-C 2.0" written by Ben Ezzell and published by Addison-Wesley. I found it a B-Dalton. This book is almost a must if you hope to write a BGI driver. I will help answer questions (at least until I get tired of it). Mainly I will look gather up all the commo questions and post them to the net. I also want to make it clear that I am basically a High level language programmer and had to learn Assembly as I went to write this. Therefor, I DONT want to here any comments about my poor assembly language programming style. REMEMBER, THIS IS MAINLY INTENDED AS A DEVELOPEMENT EXAMPLE AND IS NOT INTENDED TO BE A RELEASED PRODUCT ( although almost all of the functions do work for this graphics card ). ======================= CUT APART HERE AND NAME BGITEST.C =========== /* This is a real hack of a demo program but it at least shows you what your C program must do to install and use a user-written device driver. I had most of the BORLAND SUPPLIED bgidemo.c program working after I took out their palette demo routine and change the program to use another font other than DEFAULT ( which I could not make work ). I didn't post I because I was afraid BORLAND could bust me for posting it. */ #include <graphics.h> #include <stdlib.h> #include <stdio.h> int huge detectLEEVGA(void); main() { int driver, mode; int ysize, xsize; int i; driver =installuserdriver ("LEEVGA", detectLEEVGA); { int ec; if ((ec=graphresult()) < 0) { printf("unable to register\n"); printf("reason <%s>\n", grapherrormsg(ec)); exit(-1); return(-1); } } driver = DETECT; initgraph(&driver, &mode, ""); { int ec; if ((ec=graphresult()) < 0) { printf("unable to open this graphics mode\n"); printf("reason <%s>\n", grapherrormsg(ec)); exit(-1); return(-1); } } printf(" max x= %d\n", xsize=getmaxx()); printf(" max y= %d\n", ysize=getmaxy()); printf(" modename= %s\n", getmodename(0)); printf(" drivername= %s\n", getdrivername()); printf(" maxcolors= %d\n", getmaxcolor()); printf(" palette size=%d\n", getpalettesize()); #define DO 1 #ifdef DO setfillstyle ( SOLID_FILL, 15 ); setcolor ( 12 ); outtextxy(xsize/6,ysize/3,"A b C d E f G h I J k"); getch(); printf(" Outtext ( DEFAULT FONT ) is done\n"); getch(); settextstyle(TRIPLEX_FONT,HORIZ_DIR,4); outtextxy(xsize/6,ysize/4,"0 1 2 3 4 5 6 7 8 9 0"); printf(" Outtext ( TRIPLEX_FONT ) is done\n"); getch(); setlinestyle(DASHED_LINE,0,NORM_WIDTH); for (i=10; i < xsize/3*2 ; i++) { putpixel(i,ysize/4,12); } printf(" pixel puts are done, press a key\n");getch(); #endif setfillstyle ( SLASH_FILL, 11 ); setlinestyle(DASHED_LINE,0,NORM_WIDTH); pieslice(xsize/2,ysize/2,45,45+90,ysize/3); circle (xsize/2, ysize/2,ysize/2); ellipse(xsize/2,ysize/2,0,0,100,100); printf(" circle done press a key\n");getch(); setlinestyle(CENTER_LINE,0,NORM_WIDTH); line ( 10,ysize/2,ysize-100,ysize/2); line ( xsize/2, 10 , xsize/2 , ysize/2 ); printf(" lines done, press a key\n");getch(); rectangle (10,20,xsize/6,ysize/2); printf(" rectangle done, press a key\n");getch(); setlinestyle(DOTTED_LINE,0,THICK_WIDTH); setfillstyle ( XHATCH_FILL, 21 ); setcolor(83); bar3d ( xsize/2,ysize/2, xsize/6*5,ysize, 50, 1); printf(" bar is done, press a key\n");getch(); setlinestyle(DASHED_LINE,0,NORM_WIDTH); { int pp[10]={100,100, 100,150, 180,195, 300,150, 330,100}; setfillstyle ( CLOSE_DOT_FILL, 11 ); fillpoly ( 5 , &pp ); printf(" filled polygon is done, press a key\n");getch(); } setrgbpalette(12,1,2,3); { typedef struct { char r,g,b; } entry; struct p { char size; entry index[256]; } palette; palette.size = 3*256; palette.index[0].r =1; palette.index[0].g =2; palette.index[0].b =3; setallpalette(&palette); } cleardevice(); printf(" clear done\n"); printf(" press a key\n");getch(); closegraph(); } /* ______________________ */ int huge detectLEEVGA(void) { printf("detecting\n"); /* You must write code here to detect whether or not the graphics card is available and what its maximum mode is. By returning the value of ONE here, I am telling it I have detected my graphics card and the mode I want it to use is ONE. */ return(1); } ======================== CUT APART HERE and NAME IT LEEVGA.ASM ========== ; know problems ; 1. the default font has not been done. ; 2. flood fill has not been done. ; to compile (create) the .BGI file use the following ; masm leevga.asm leevga.obj NUL.LST NUL.LST ; link leevga.obj,leevga.exe,NUL.MAP,.LIB ; exe2bin leevga.exe leevga.bgi ; del leevga.exe ; del leevga.obj ;------------------------------------------------------; ; LEEBGI.BGI ; ; Borland Graphic Interface for TP 5.0, TC2.0 ; ; Paridise VGA Graphics Board ; ; Copyright (c) 1989 Gene W. Lee ; ;------------------------------------------------------; ; ACODE segment 'BGI' ; ; astart DB 'pk' ; BGI magic word (Phillipe K.) DB 8,8 DB 'BGI Device Driver V1.0 Gene W. Lee - 1989 ' db 0Dh,0Ah DB 'Copyright (c) 1989 Gene W. Lee',0Dh,0Ah db 0,1Ah dw 00A0h,11 dw endofcode ; This is a label that precedes CODE ENDS dw 2 db 1,1 org 80h dw 00A0h,11 dw endofcode ; see above dw 2 db 1,1 ; The following is returned by GetDriverName. db 6,'LEEVGA' alen = $-astart ; Pad this segment out to db (160 - alen) dup(0) ; 160 bytes ACODE ends CODE SEGMENT 'BGI' ; ; Now for the real BGI driver code. A separate segment is required ; because although this code starts at offset 0A0h in the file ; ATTDEB.BGI, GRAPH will adjust its address up by 10 paras and then ; do a CALL FAR xxxx:[0000]. So all memrefs have to be 0 relative to ; the label BGIENTRY below. IMPORTANT: All code from here to JMP_TABLE ; needs to be exactly as it is. GRAPH expects the label EMULATE to be ; at the offset that it is in this code (GRAPH is going to shove code ; ASSUME CS:CODE,DS:CODE,ES:CODE BGIENTRY PROC FAR ; "FAR" So that the RET is a RETF PUSH DS PUSH CS POP DS CLD PUSH BP ; ; The Function number to be performed in SI. SI is used to index into ; a jump table. Note: all SI values are even. ; CALL [SI+JMP_TABLE] ; See JMP_TABLE POP BP POP DS RET BGIENTRY ENDP ; db 'CB' ; ? dw 0 ; EMULATE PROC NEAR ; This is the entry point of functions RET ; you want Turbo XX to emulate. Note: dw 0 ; only select entries may be emulated. dw 0 EMULATE ENDP NOP_02 PROC NEAR ; This is the entry point for all functions RET ; which are not implemented. NOP_02 ENDP ; Now for the Jump Table; The SVC_xx labels correspond to the ; value in SI when the driver is called(ie: SVC_00 is the entry point ; when SI = 0. IF the labels are EMULATE or NOP_02 the value of SI is ; to the right in braces. NOP_02 means this function is a NOP and ; GRAPH should never call it (at least relative to TP5). The label ; EMULATE is a JMP to a CALL back to GRAPH to perform the function. ; (Aren't you glad you don't have to write a Circle Drawing Algorithm!) ; ; It should also be noted that calls to the BGI code are both pre- ; processed and post-processed by GRAPH. Some calls never make it to ; your code. One example is the DisplayText functions. The only time ; that calls make it here is for the bit-map text displays. GRAPH ; handles all of the stroked CHR fonts. ; jmp_table dw install ; {0} Initialize dw init ; {2} Set Mode dw clear ; {4} Clear Graphics Screen dw nop_02 ; {06} POST dw move ; {8} current pointer (CP) dw draw ; {A} draw line from CP to new CP dw vect ; {C} Draw Line dw EMULATE ; {0E} Draw/Fill Poly dw emulate ; {10} Bar3D dw patbar ; {12} pattern Bar dw EMULATE ; {14} Draw Circle dw EMULATE ; {16} Draw Pie Slice dw EMULATE ; {18} Draw Ellipse dw palette ; {1A} Set Palette dw SVC_1C ; {1C} Set All Palette dw color ; {1E} Set Color dw fillstyle ; {20} Set Fill Style/Pattern dw linestyle ; {22} Set Line Style/Pattern dw textstyle ; {24} Set UserCharSize dw text ; {26} Display Text dw textsize ; {28} Text Width/Height dw EMULATE ; {2A} ; I never figured this one out ! dw flood_fill ; {2C} FloodFill dw get_pixel ; {2E} GetPixel dw put_pixel ; {30} SetPixel dw bitmaputil ; {32} Set CallTable dw get_image ; {34} GetImage dw put_image ; {36} PutImage dw set_clip ; {38} Set View Min/Max dw color_query ; {3A} SetParameters dw emulate ; {3C} reserved dw EMULATE ; {3E} symbol dw NOP_03 ; 40 dw NOP_03 ; 42 dw NOP_03 ; 44 dw NOP_03 ; 46 dw NOP_03 ; 48 dw NOP_03 ; 4A dw NOP_03 ; 4C dw NOP_03 ; 4E dw NOP_03 ; 50 dw NOP_03 ; 52 dw NOP_03 ; 54 dw NOP_03 ; 56 dw NOP_03 ; 46 dw NOP_03 ; 48 dw NOP_03 ; 4A dw NOP_03 ; 4C dw NOP_03 ; 4E dw NOP_03 ; 50 dw NOP_03 ; 52 dw NOP_03 ; 54 dw NOP_03 ; 56 dw NOP_03 ; 46 dw NOP_03 ; 48 dw NOP_03 ; 4A dw NOP_03 ; 4C dw NOP_03 ; 4E dw NOP_03 ; 50 dw NOP_03 ; 46 dw NOP_03 ; 48 dw NOP_03 ; 52 dw NOP_03 ; 54 dw NOP_03 ; 56 ; NOP_03 PROC FAR ; stub procedure for far returns RET NOP_03 ENDP ; ; structure for 320x200 256 color mode statustype0 struc db 0 ; current device status db 0 ; device type identifier ( must be zero ) dw 319 ; full resolution in the x direction dw 199 ; full resolution in the y direction xefres0 dw 319 ; effective resolution in x direction dw 199 ; effective resolution in y direction dw 9000 ; device x size in inches * 1000 dw 7000 ; device y size in inches * 1000 dw 8572 ; aspect ratio = ( ysize / xsize ) * 1000 ; next four bytes are for compatibilty db 8h db 8h db 90h db 90h statustype0 ends status0 statustype0<> ; structure for 640x400 256 color mode (0x5E) statustype1 struc db 0 ; current device status db 0 ; device type identifier ( must be zero ) dw 639 ; full resolution in the x direction dw 399 ; full resolution in the y direction xefres1 dw 639 ; effective resolution in x direction dw 399 ; effective resolution in y direction dw 9000 ; device x size in inches * 1000 dw 7000 ; device y size in inches * 1000 dw 8572 ; aspect ratio = ( ysize / xsize ) * 1000 ; next four bytes are for compatibilty db 8h db 8h db 90h db 90h statustype1 ends status1 statustype1<> active_mode db ? ; the currently active mode number modestring0 db 18,'320 x 200 VGA Mode',0 modestring1 db 18,'640 x 400 VGA Mode',0 xsize dw ? ; the xsize of the currently selected mode max_x dw ? ; the maximum value of x for the current mode ; table for ellipse function calls ; Let it used my put_pixel routine, there is not much I could do to speed ; up pixel writing anyway. the_util_table dw offset NOP_03 ; enter pixel mode dw offset NOP_03 ; Leave pixel mode dw offset NOP_03 ; write a pixel dw offset NOP_03 ; get a pixel dw offset bitsperpixel ; return bits per pixel in AX dw offset NOP_03 ; set draw page dw offset NOP_03 ; set visual page dw offset NOP_03 ; set xor mode enter_pixel_mode proc far call unlock_vga mov doing_ellipse,1 ret enter_pixel_mode endp exit_pixel_mode proc far call lock_vga mov doing_ellipse,0 ret exit_pixel_mode endp bitsperpixel proc far mov ax,8 ; eight bits per pixel in VGA mode ret bitsperpixel endp ; the bit patterns for default linestyles default_linestyles dw 0FFFFh ; SOLID_LINE dw 0CCCCh ; DOTTED_LINE dw 0FC78h ; CENTER_LINE dw 0F8F8h ; DASHED_LINE active_linestyle dw 0FFFFh ; the currently selected line style is written ; into this word. line_bit_ptr db 0 ; pointer into linestyle word (bit ptr) default_fillpaterns db 000h,000h,000h,000h,000h,000h,000h,000h ; No Fill db 0FFh,0FFh,0FFh,0FFh,0FFh,0FFh,0FFh,0FFh ; Solid fill db 0FFh,0FFh,000h,000h,0FFh,0FFh,000h,000h ; Line FIll db 001h,002h,004h,008h,010h,020h,040h,080h ; Lt Slash fil db 0E0h,0C1h,083h,007h,00Eh,01Ch,038h,070h ; Slash fill db 0F0h,078h,03Ch,01Eh,00Fh,087h,0C3h,0E1h ; Backslash db 0A5h,0D2h,069h,0B4h,05Ah,02Dh,096h,04Bh ; lt Backslash db 0FFh,088h,088h,088h,0FFh,088h,088h,088h ; Hatch Fill db 081h,042h,024h,018h,018h,024h,042h,081h ; XHatch Fill db 0CCh,033h,0CCh,033h,0CCh,033h,0CCh,033h ; interleave db 080h,000h,008h,000h,080h,000h,008h,000h ; Wide Dot db 088h,000h,022h,000h,088h,000h,022h,000h ; Close Dot active_fillpattern db ?,?,?,?,?,?,?,? ; the currently selected fill ; style is written into this array. fill_byte_ptr dw ? ; pointer to fill pattern byte fill_bit_ptr dw ? ; pointer to bit of fill pattern byte ; I don't really understand what this is all about. I just tell it I don't ; have a default color table color_table db 0 current_background_color db ? current_line_color db ? ; the currently selected color for lines current_fill_color db ? ; the currently selected fill color cp_x dw ? ; the current pointer - x cp_y dw ? ; the current pointer - y clip_x1 dw ? ; clipping window clip_y1 dw ? ; clipping window clip_x2 dw ? ; clipping window clip_y2 dw ? ; clipping window ; start x,y and end x,y for line draws x1 dw ? y1 dw ? x2 dw ? y2 dw ? ; vars used by line draw routine delta_x dw ? delta_y dw ? count dw ? halfx label word ; only need halfx or halfy at one time halfy dw ? ; vars used to do pixel read/writes in VGA mode lasthio dw -1 ; keeps track of the last hioffset value calculated next_row dw ? ; variable used by patbar, getimage and putimage ; vars used by palette routines red db ? green db ? blue db ? doing_ellipse db 0 ; set true when unlock has been called to start ; drawing an ellipse. Saves time on ellipse draws ; 0 ---------------------------------------------------------------------- ; if al=0 ( install device ) ; input: cl = mode number for device ; ch = autodetect maximum device number ; return: es:bx = pointer to device status table ; if al=1 ( mode query ) ; input: nothing ; return: cx = number of modes supported by this device ; if al=2 ( return mode name ) ; input cx: the mode number for query ; return es:bx = pointer to PASCAL string containing the name install: cmp al,0 jz installit cmp al,1 jz modequery ; else it must be a modename() call push cs pop es cmp cx,0 je modename0 mov bx, offset modestring1 ; return pointer to mode name ret modename0: mov bx, offset modestring0 ; return pointer to mode name ret installit: mov active_mode,cl ; remember what mode were in cmp cl,1 je install_mode1 ; else we install mode 0 ; keep track of current x and y screen size mov ax,status0.xefres0 mov max_x,ax inc ax mov xsize,ax push cs pop es mov bx,offset status0 ; return location of status table ret install_mode1: mov ax,status1.xefres1 ; keep track of current x and y screen size mov max_x,ax inc ax mov xsize,ax push cs pop es mov bx,offset status1 ; return location of status table ret modequery: mov cx,2 ; only two modes supported for now ret ; 2 ---------------------------------------------------------------------- ; input: ; es:bx = pointer to device table ; return: nothing init: cmp active_mode,1 je init_mode1 ; else we init mode 0 mov ax,13h int 10h ret init_mode1: mov ax,5Eh int 10h ret ; 4 ---------------------------------------------------------------------- ; input: nothing ; output: nothing ; clear the device clear: call init ret ; 8 ------------------------------------------------------------------------ ; input: ; ax = the new CP x coord ; bx = the new CP y coord ; return: nothing move: ; set current pointer (CP) ; load the new current pointer mov cp_x,ax mov cp_y,bx ret ; A ----------------------------------------------------------------------- ; draw line from CP to x,y ; input: ; ax: ending x coord ; bx: ending y coord ; output: ; nothing draw: ; draw line from CP to new CP push cx mov cx,cp_x ; draw starts at current position (cp) mov x1,cx mov cx,cp_y mov y1,cx pop cx mov x2,ax ; load the end points mov y2,bx mov cp_x,ax ; end points are now new current points mov cp_y,bx mov line_bit_ptr,0 ; reset the line style call draw_line ; draw the line from x1,y1 to x2,y2 ret ; C ---------------------------------------------------------------------- ; draw line from x1,y1 to x2,y2 ; input: ; ax = x1 ; bx = y1 ; cx = x2 ; dx = y1 ; output: ; nothing vect: ; Draw Line ; setup the start and end points mov x1,ax mov y1,bx mov x2,cx mov y2,dx mov line_bit_ptr,0 ; reset the line style call draw_line ; draw a line ret ; 1A -------------------------------------------------------------------- ; set a single palette entry ; input: ; ax = the index number to load ; bx = the color value ; return: nothing palette: push ax push cx mov cl,14 shr ax,cl ; only want upper to bits of cl cmp ax,010b ; set rgb palette pop cx pop ax jne p_done ; the other values are meaningless in vga mode mov red,bl mov green,cl mov blue,dl ; get rid of upper two control bits, leave index and ax,03FFFh mov dh,red mov ch,green mov cl,blue mov bx,ax mov ax,01010h ; set single palette entry int 10h p_done: ret ; 1C --------------------------------------------------------------------- ; Set all Palette entries with one call SVC_1C: ; Set All Palette ; not compatible with 256 color VGA modes, you have to provide ; the user with a library function to do this. ret ; 1E ------------------------------------------------------------------- ; input: ; al = index number of current drawing color ; ah = index number of current fill color ; return: nothing color: ; Set Color mov current_line_color,al mov current_fill_color,ah ret ; 20 ------------------------------------------------------------------ ; input: ; al = fill pattern number ; es:bx = if pattern number = 0FFh, this points to user fill pattern ; return: nothing fillstyle: ; Set Fill Style/Pattern cmp al,0FFh ; test if user defined fill jz user_fill cbw mov cl,3 ; multiply by 8 for eight bytes per fill type shl ax,cl mov si,ax add si,offset default_fillpaterns ; point to the selected fill patern jmp cont_fill ; ds:si point to selected fill pattern user_fill: ; user defined fill passed by pointer ES:BX push bx pop si push es pop ds ; setup so ds:si points to users fill pattern cont_fill: mov di,offset active_fillpattern push cs pop es ; es:cs is the destination of the copy mov cx,8 ; setup to copy eight bytes of pattern repz movsb ; copy pattern into active pattern ret ; 22 ------------------------------------------------------------------ ; input: ; al = line pattern number ; bx = user defined line pattern if al = 4 ; cx = line width ; return: nothing linestyle: ; set current line style cmp ax,4 jz user_defined ; check if its a user defined line and ax,0FFh ; pattern number in AL shl al,1 ; used two index by 2 bytes at a time mov si,ax mov bx,[default_linestyles +si] ; load a pre-defined pattern user_defined: ; user defined are passed in BX mov active_linestyle,bx ret ; 24 ------------------------------------------------------------------- ; input: ; al = hardware font number ; ah = hardware font orientation ; bx = desired X size ; cx = desired Y size ; return: ; bx = closest X size available ; cx = closest Y size available textstyle: ; Set UserCharSize ; this code works but thats about all mov bx,bx ; let say the characters are 8 x 16 mov cx,cx ret ; 26 -------------------------------------------------------------------- ; input: ; es:bx = pointer to ascii string to display ; cx = number of chars in string ; al = horizontal justification ( 0=left,1=center,2=right ) ; ah = vertical justification (0=bottom,1=center,2=top) ; return: ; bx = width of string in graphics units ; cx = height of string in graphics units text: ; Display Text ( DEFAULT FONT ) ; this is one of the things I could not figure out ; if you come up with something please let me know. push bx push cx ; hack here ; end hack pop cx pop bx mov bx,bx ; NOTE this should be 8 * length of string (cx) mov cx,cx ret ; 28 -------------------------------------------------------------------- ; input: ; es:bx = pointer to ascii text ; cx = number of chars in test ; return: ; bx = width of string in graphics units ; cx = height of string in graphics units textsize: ; Text Width/Height ( DEFAULT FONT ) ; again I did not know how to do this mov bx,bx ; NOTE this is not right mov cx,cx ret ; 2C -------------------------------------------------------------------- ; input: ; ax = x coord to start at ; bx = y coord to start at ; cl = boundry color ; return: nothing flood_fill: ; FloodFill ; flood fill needs implemented also ret ; 2E ----------------------------------------------------------------- ; input: ; ax = x coord ; bx = y coord ; return: ; dl = color get_pixel: ; GetPixel ; if you don't mind being slow, just use the bios calls ; mov cx,ax ; load x value ; mov dx,bx ; load y value ; mov bh,0 ; page zero ; mov ah,0Dh ; read pixel function ; ; int 10h ; ; mov dl,al ; return the color of pixel read ; ret cmp active_mode,1 je getpixel_mode1 ; else read pixels in mode 0 push di ; save these registers push es mov cx,ax ; save the column value (x) mov ax,bx ; load the row value (y) mul xsize ; offset =(xsize * y) add ax,cx ; + x mov di,ax ; load screen address into di mov ax,0A000h ; video ram segement address mov es,ax mov dl,es:[di] ; read the pixel pop es pop di ret getpixel_mode1: ; read pixel this way when in mode 1 push di ; save these registers push es mov cx,ax ; save the column value (x) mov ax,bx ; load the row value (y) call calc_hilow ; find vga offset values into screen memory cmp bx,lasthio ; see of hioffset is the same as last time je no_hio_chg_r ; if it is, save time by not resetting it cmp doing_ellipse,1 je no_unlock_get ; its already unlocked call unlock_vga no_unlock_get: mov ax,bx ; call set_hioffset ; sets the hioffset register for vga mem addressing cmp doing_ellipse,1 je no_lock_get call lock_vga no_lock_get: no_hio_chg_r: mov ax,0A000h ; video ram segement address mov es,ax mov dl,es:[di] ; read the pixel pop es pop di ret ; 30 ----------------------------------------------------------------- ; input: ; ax = x coord ; bx = y coord ; dl = color ; return: nothing put_pixel: ; SetPixel ; p[XSIZE*y+x] = color; for 320 x 200 - 256 mode ; if you don't mind being slow, just call the bios plot dot ; push dx ; save color value ; mov cx,ax ; load x value ; mov dx,bx ; load y value ; pop ax ; color value from pushed dx ; mov bh,0 ; page zero ; mov ah,0Ch ; write pixel function ; ; int 10h ; ret ; else get fancy to make it faster. cmp active_mode,1 je putpixel_mode1 ; else plot pixels in mode 0 push di ; save these registers push es push ax push bx push cx push dx push dx ; save the color mov cx,ax ; save the column value (x) mov ax,bx ; load the row value (y) mul xsize ; offset =(xsize * y) add ax,cx ; + x mov di,ax ; load screen address into di mov ax,0A000h ; video ram segement address mov es,ax pop dx ; get the color info back mov es:[di],dl ; plot the pixel pop dx pop cx pop bx pop ax pop es pop di ret putpixel_mode1: ; routine to plot pixels when in mode 1 push di ; save these registers push es push ax push bx push cx push dx push dx ; save the color mov cx,ax ; save the column value (x) mov ax,bx ; load the row value (y) call calc_hilow ; find vga hi and low offset value for screen mem cmp bx,lasthio ; see of hioffset is the same as last time je no_hio_chg_w ; if it is, save time by not resetting it cmp doing_ellipse,1 je no_unlock_put ; its already done call unlock_vga no_unlock_put: mov ax,bx ; call set_hioffset ; sets the hioffset register for vga mem addressing cmp doing_ellipse,1 je no_lock_put call lock_vga no_lock_put: no_hio_chg_w: mov ax,0A000h ; video ram segement address mov es,ax pop dx ; get the color info back mov es:[di],dl ; plot the pixel pop dx pop cx pop bx pop ax pop es pop di ret ; 32 ------------------------------------------------------------------- bitmaputil: ; Set CallTable ; see the book, basically don't worry (be happy) push cs pop es mov bx, offset the_util_table ret ; 34 ------------------------------------------------------------------- ; input: ; ax = x1 corner ; bx = y1 corner ; cx = x2 corner ; dx = y2 corner ; return: nothing patbar: ; fill the rectangle using current fillstyle and color ; this version of pattern filling uses the following trick to greatly ; improve speed. Instead of calling put_pixel for every pixel to plot ; it does the write to screen memory on its own. What makes it fast is ; that it only has to find the original offset by multipling XSIZE by ; y1. From then on it increments a pointer to find the next location ; in screen memory (not multiplies required after initial one). ; first, make sure x1 < x2 and y1 < y2 cmp ax,cx ; if x1 < x2 jle x_ok xchg ax,cx x_ok: cmp bx,dx ; if y1 < y2 jle y_ok xchg bx,dx y_ok: ; then load the start and end values mov x1,ax mov x2,cx mov y1,bx mov y2,dx cmp active_mode,1 je patbar_mode1 ; different way to calc pixel offset ; Next, setup the starting value of the VGA's hioffset reg push ax push bx push cx mov cx,ax ; load x value mov ax,bx ; load the y value mul xsize ; find the pixel offset add ax,cx ; add inthe x value mov di,ax mov ax,0a000h ; screen memory segment mov es,ax ; calculate ho many screen byte are from right edge of box ; to left edge of box on next row mov ax,max_x sub ax,x2 add ax,x1 mov next_row,ax pop cx pop bx pop ax again0: ; First, lets figure out the fill pattern parameters push ax push cx push si ; the bit/byte pointer are relative to the absolute ; screen position mod 8 mov fill_byte_ptr,bx ; load the current y value mov fill_bit_ptr,ax ; load the current x value and fill_byte_ptr,07h and fill_bit_ptr,07h mov si,fill_byte_ptr; mov al,[offset active_fillpattern + si] mov cx,fill_bit_ptr shl al,cl and al,80h cmp al,80h jne use_background0 ; if not plotting this dot mov dl,current_fill_color ; else load fill color jmp selected0 use_background0: mov dl,current_background_color ; assume background selected0: pop si pop cx pop ax ; this is the slow way, it has to recalute the offset into ; display memory every time it puts a pixel ; push ax ; push bx ; call put_pixel ; pop bx ; pop ax mov es:[di],dl inc di ; advvance screen mapped memory pointer inc ax ; advance in x dir till at right edge cmp ax,x2 jle again0 mov ax,x1 ; reset to left size of rectangle inc bx ; go to down to next row cmp bx,y2 jg fill_done0 ; Since were changing rows we'll find a new hi and low ; the trick is to add the number of bytes from the right side of the ; box to the left side of the box ( note: no multiplies needed ) add di,next_row jmp again0 fill_done0: ret ; end of patbar in mode 0 patbar_mode1: ; first, make sure x1 < x2 and y1 < y2 call unlock_vga ; keep vga ready to plot pixels ; Next, setup the starting value of the VGA's hioffset reg push ax push bx push cx mov cx,ax ; load x value mov ax,bx ; load the y value call calc_hilow ; find the values of hio and lowo mov ax,bx ; load hio call set_hioffset ; set the vga register for the hioffset mov ax,0a000h ; screen memory segment mov es,ax ; calculate ho many screen byte are from right edge of box ; to left edge of box on next row mov ax,max_x sub ax,x2 add ax,x1 mov next_row,ax pop cx pop bx pop ax again1: ; First, lets figure out the fill pattern parameters push ax push cx push si ; the bit/byte pointer are relative to the absolute ; screen position mod 8 mov fill_byte_ptr,bx ; load the current y value mov fill_bit_ptr,ax ; load the current x value and fill_byte_ptr,07h and fill_bit_ptr,07h mov si,fill_byte_ptr; mov al,[offset active_fillpattern + si] mov cx,fill_bit_ptr shl al,cl and al,80h cmp al,80h jne use_background1 ; if not plotting this dot mov dl,current_fill_color ; else load fill color jmp selected1 use_background1: mov dl,current_background_color ; assume background selected1: pop si pop cx pop ax ; this is the slow way, it has to recalute the offset into ; display memory every time it puts a pixel ; but it shows the easy way to do it. ; push ax ; push bx ; call put_pixel ; pop bx ; pop ax mov es:[di],dl inc di cmp di,0FFFh jle leave_hio1 sub di,1000h inc lasthio push ax ; let vga card know we incremented hi offset mov ax,lasthio call set_hioffset pop ax leave_hio1: inc ax ; advance in x dir till at right edge cmp ax,x2 jle again1 mov ax,x1 ; reset to left size of rectangle inc bx ; go to down to next row cmp bx,y2 jg fill_done1 ;Since were changing rows we'll find a new hi and low ; the trick is to add the number of bytes from the right side of the ; box to the left side of the box ( note: no multiplies needed ) add di,next_row cmp di,0FFFh jle no_bump1 sub di,1000h inc lasthio push ax mov ax,lasthio call set_hioffset pop ax no_bump1: jmp again1 fill_done1: call lock_vga ; protect the vgas register again ret ; 36 ------------------------------------------------------------------ buf_ptr dw ? ; pointer to the buffer for getimage/putimage put_mode db ? ; pixel writing mode for putting images (and,xor,etc) ; NOTE: the book has mistakes in input/output parameters ; input: ; es:bx = pointer to memory buffer ; buffer[0] = window width in x direction ; buffer[2] = window height in y direction ; cx = x1 corner of window ; dx = y1 corner of window ; return: nothing get_image: ; GetImage ; this version of pattern filling uses the following trick to greatly ; improve speed. Instead of calling put_pixel for every pixel to plot ; it does the write to screen memory on its own. What makes it fast is ; that it only has to find the original offset by multipling XSIZE by ; y1. From then on it increments a pointer to find the next location ; in screen memory. mov buf_ptr,bx ; pointer to the buffer where we'll store image mov ax,es:[bx] add ax,cx ; add x1 plus xsize of image window mov bx,es:[bx +2] add bx,dx ; add y1 plus ysize of image window mov x1,cx mov y1,dx mov x2,ax mov y2,bx mov bx,buf_ptr add bx,4 ; first word was used for xsize dimension mov buf_ptr,bx mov ax,x1 mov bx,y1 cmp active_mode,1 je getimage_mode1 ; different way to calc pixel offset ; Next, setup the starting value of the VGA's hioffset reg push ax push bx push cx mov cx,ax ; load x value mov ax,bx ; load the y value mul xsize ; find the pixel offset add ax,cx ; add inthe x value mov di,ax ; calculate ho many screen byte are from right edge of box ; to left edge of box on next row mov ax,max_x sub ax,x2 add ax,x1 mov next_row,ax pop cx pop bx pop ax g_again0: ; move a byte from the screen to the image buffer push ax push es mov ax,0A000h mov es,ax mov al,byte ptr es:[di] pop es push bx mov bx,buf_ptr mov byte ptr es:[bx],al pop bx pop ax inc buf_ptr ; point to next byte in the users buffer inc di ; advvance screen mapped memory pointer inc ax ; advance in x dir till at right edge cmp ax,x2 jle g_again0 mov ax,x1 ; reset to left size of rectangle inc bx ; go to down to next row cmp bx,y2 jg geti_done0 ;Since were changing rows we'll find a new hi and low ;the trick is to add the number of bytes from the right side of the ; box to the left side of the box ( note: no multiplies needed ) add di,next_row jmp g_again0 geti_done0: ret ; end of patbar in mode 0 getimage_mode1: ; first, make sure x1 < x2 and y1 < y2 call unlock_vga ; keep vga ready to plot pixels ; Next, setup the starting value of the VGA's hioffset reg push ax push bx push cx mov cx,ax ; load x value mov ax,bx ; load the y value call calc_hilow ; find the values of hio and lowo mov ax,bx ; load hio call set_hioffset ; set the vga register for the hioffset ; calculate ho many screen byte are from right edge of box ; to left edge of box on next row mov ax,max_x sub ax,x2 add ax,x1 mov next_row,ax pop cx pop bx pop ax g_again1: ; move a byte from the screen to the image buffer push ax push es mov ax,0A000h mov es,ax mov al,byte ptr es:[di] pop es push bx mov bx,buf_ptr mov byte ptr es:[bx],al pop bx pop ax inc buf_ptr ; point to next byte in the users buffer inc di cmp di,0FFFh jle g_leave_hio1 sub di,1000h inc lasthio push ax ; let vga card know we incremented hi offset mov ax,lasthio call set_hioffset pop ax g_leave_hio1: inc ax ; advance in x dir till at right edge cmp ax,x2 jle g_again1 mov ax,x1 ; reset to left size of rectangle inc bx ; go to down to next row cmp bx,y2 jg geti_done1 ;Since were changing rows we'll find a new hi and low ;the trick is to add the number of bytes from the right side of the ; box to the left side of the box ( note: no multiplies needed ) add di,next_row cmp di,0FFFh jle g_no_bump1 sub di,1000h inc lasthio push ax mov ax,lasthio call set_hioffset pop ax g_no_bump1: jmp g_again1 geti_done1: call lock_vga ; protect the vgas register again ret ; 38 ------------------------------------------------------------------------- ; NOTE: the book has mistakes in input/output parameters ; input: ; es:bx = pointer to memory buffer ; buffer[0] = window width in x direction ; buffer[2] = window height in y direction ; cx = x1 corner of window ; dx = y1 corner of window ; return: nothing put_image: ; putImage ; this version of pattern filling uses the following trick to greatly ; improve speed. Instead of calling put_pixel for every pixel to plot ; it does the write to screen memory on its own. What makes it fast is ; that it only has to find the original offset by multipling XSIZE by ; y1. From then on it increments a pointer to find the next location ; in screen memory. mov put_mode,al ; save the put image pixel writing mode mov buf_ptr,bx ; pointer to the buffer where we'll store image mov ax,es:[bx] add ax,cx ; add x1 plut xsize of image window mov bx,es:[bx +2] ; mov bx,di add bx,dx ; add y1 plus ysize of image window mov x1,cx mov y1,dx mov x2,ax mov y2,bx mov bx,buf_ptr add bx,4 ; first word was used for xsize dimension mov buf_ptr,bx mov ax,x1 mov bx,y1 cmp active_mode,1 je putimage_mode1 ; different way to calc pixel offset ; Next, setup the starting value of the VGA's hioffset reg push ax push bx push cx mov cx,ax ; load x value mov ax,bx ; load the y value mul xsize ; find the pixel offset add ax,cx ; add inthe x value mov di,ax ; calculate ho many screen byte are from right edge of box ; to left edge of box on next row mov ax,max_x sub ax,x2 add ax,x1 mov next_row,ax pop cx pop bx pop ax mov cl,put_mode ; keep the put_mode in cl for access speed p_again0: call buf_to_screen inc di ; advvance screen mapped memory pointer inc ax ; advance in x dir till at right edge cmp ax,x2 jle p_again0 mov ax,x1 ; reset to left size of rectangle inc bx ; go to down to next row cmp bx,y2 jg puti_done0 ;Since were changing rows we'll find a new hi and low ; the trick is to add the number of bytes from the right side of the ; box to the left side of the box ( note: no multiplies needed ) add di,next_row jmp p_again0 puti_done0: ret ; end of patbar in mode 0 ; ----------------- putimage for mode 1 ------------------ putimage_mode1: ; first, make sure x1 < x2 and y1 < y2 call unlock_vga ; keep vga ready to plot pixels ; Next, setup the starting value of the VGA's hioffset reg push ax push bx push cx mov cx,ax ; load x value mov ax,bx ; load the y value call calc_hilow ; find the values of hio and lowo mov ax,bx ; load hio call set_hioffset ; set the vga register for the hioffset ; calculate ho many screen byte are from right edge of box ; to left edge of box on next row mov ax,max_x sub ax,x2 add ax,x1 mov next_row,ax pop cx pop bx pop ax mov cl,put_mode ; keep the put_mode in cl for access speed p_again1: call buf_to_screen inc di cmp di,0FFFh jle p_leave_hio1 sub di,1000h inc lasthio push ax ; let vga card know we incremented hi offset mov ax,lasthio call set_hioffset pop ax p_leave_hio1: inc ax ; advance in x dir till at right edge cmp ax,x2 jle p_again1 mov ax,x1 ; reset to left size of rectangle inc bx ; go to down to next row cmp bx,y2 jg puti_done1 ;Since were changing rows we'll find a new hi and low ; the trick is to add the number of bytes from the right side of the ; box to the left side of the box ( note: no multiplies needed ) add di,next_row cmp di,0FFFh jle p_no_bump1 sub di,1000h inc lasthio push ax mov ax,lasthio call set_hioffset pop ax p_no_bump1: jmp p_again1 puti_done1: call lock_vga ; protect the vgas register again ret ; ---------------------------------------------- ; this code write the next byte from the put image buffer ; to the display screen buf_to_screen proc near ; move a byte from the image buffer to the screen push ax push bx ; get the byte out of the users buffer mov bx,buf_ptr mov al,byte ptr es:[bx] pop bx push es push ax mov ax,0A000h mov es,ax ; es reg is pointer to VGA screen pop ax ; write the byte to screen mem according to users mode ; mov cl,put_mode cmp cl,0 jne try_xor0 mov byte ptr es:[di],al jmp mode_found0 try_xor0: cmp cl,1 jne try_or0 xor byte ptr es:[di],al jmp mode_found0 try_or0: cmp cl,2 jne try_and0 or byte ptr es:[di],al jmp mode_found0 try_and0: cmp cl,3 jne then_comp0 and byte ptr es:[di],al jmp mode_found0 then_comp0: xor al,0FFh ; complement the byte and byte ptr es:[di],al mode_found0: pop es pop ax inc buf_ptr ; point to next byte in the users buffer ret buf_to_screen endp ; 40 ------------------------------------------------------------------- ; input: ; ax = x1 ; bx = y1 ; cx = x2 ; dx = y2 ; return: nothing set_clip: ; Set clipping ; load the limits of the clipping window mov clip_x1,ax mov clip_y1,bx mov clip_x2,cx mov clip_y2,dx ret ; 3A ------------------------------------------------------------------- ; if al = 0 ; input: nothing ; return: ; bx = size of color table ; cx = maximum color number ; if al = 1 ; input: nothing ; return: ; es:bx = pointer to default color table (first byte is size) color_query: ; SetParameters cmp al,0 jnz color_table_q mov bx,256 mov cx,255 ret color_table_q: push cs pop es mov bx,offset color_table ret ; ========================================================================= ; line drawing routine from Assembly language ; primer - The Waite Group - page 339-340 draw_line proc near mov ax,y2 sub ax,y1 mov si,1 jge store_y mov si,-1 neg ax store_y: mov delta_y,ax mov ax,x2 sub ax,x1 mov di,1 jge store_x mov di,-1 neg ax store_x: mov delta_x,ax mov ax,delta_x cmp ax,delta_y jl csteep call easy jmp finish_line csteep: call steep finish_line: ret draw_line endp ; --------------------------------- easy proc near mov ax,delta_x shr ax,1 mov halfx,ax mov cx,x1 mov dx,y1 mov bx,0 mov ax,delta_x mov count,ax newdot: call dotplot add cx,di add bx,delta_y cmp bx,halfx jle dcount sub bx,delta_x add dx,si dcount: dec count jge newdot ret easy endp ; -------------------------------- steep proc near mov ax,delta_y shr ax,1 mov halfy,ax mov cx,x1 mov dx,y1 mov bx,0 mov ax,delta_y mov count,ax newdot2: call dotplot add dx,si add bx,delta_x cmp bx,halfy jle dcount2 sub bx,delta_y add cx,di dcount2: dec count jge newdot2 ret steep endp ; ------------------------------ dotplot proc near push ax ; save old values push bx push cx push dx ; check to see if line style pattern dictates a plot or not ; if active_bit_pattern[line_bit_ptr] = 0 then dont plot a dot push ax push cx mov ax,active_linestyle mov cl,line_bit_ptr shl ax,cl and ax,8000h cmp ax,8000h pop cx pop ax mov ax,cx mov bx,dx jne no_dot_plot mov dl,current_line_color ; do plot dot, so load line color call put_pixel ; call the pixel writing routine no_dot_plot: inc line_bit_ptr ; move to next bit in pattern cmp line_bit_ptr,16 ; are we at the end of the pattern jne no_reset_linestyle ; if not do nothing mov line_bit_ptr,0 ; else start over at the pattern beginning no_reset_linestyle: pop dx ; save old values pop cx pop bx pop ax ret dotplot endp ; -------------------------------------------------------------------------- calc_hilow: ; find hi and low vga offsets for x,y location ; cx is column (x) , ax is row (y) ; uses value in varible 'xsize' ; results are lowoffset in di and hioffset in bx push dx mul xsize ; offset =(xsize * y) add ax,cx ; + x jnc nocarry_o inc dx ; (DxAx + Cx) nocarry_o: mov di,ax and di,0FFFh ; low offset is lowest 12 bits of offset mov cl,12 ; (hioffset = offset >> 12 shr ax,cl mov cl,4 shl dx,cl or dx,ax mov bx,dx ; hioffset saved in bx pop dx ret ; --------------------------------------------------------------------------- unlock_vga: ; unlock vga registers push ax push dx mov dx,03CEh ; vga I/O port mov ax,050Fh out dx,ax ; unlock vga registers pop dx pop ax ret ; --------------------------------------------------------------------------- lock_vga: ; lock vga registers push ax push dx mov dx,03CEh ; vga I/O port mov ax,000Fh out dx,ax ; unlock vga registers pop dx pop ax ret ; --------------------------------------------------------------------------- set_hioffset: ; sets the vga hi offset register ; ax contains the value for HIoffset push dx mov lasthio,ax mov ah,al ; hioffset goes in ah mov al,9 ; function code to set PR0A register mov dx,03CEh ; vga I/O address out dx,ax ; set the hioffset value pop dx ret ; --------------------------------------------------------------------------- ; . endofcode label byte ; This is the label ref'd in ACODE segment CODE ENDS END -- Gene Lee UUCP: ...!amdahl!ems!minnow!lee Unisys Corporation Phone: +1 612 635 3993 CSNET: lee@minnow.SP.Unisys.Com If not for the courage of the fearless manager, the paycheck would be lost.