Category : Forth Source Code
Archive   : SMILY46B.ZIP
Filename : VGABIOS.SEQ

\ VGABIOS.SEQ the BIOS version of VGA.SEQ 30Nov89mds

comment:
ÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
º Dr. Mark Smiley º
º Department of Mathematics/CS º
º Goucher College º
º Towson, MD 21204 º
ÇÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄĶ
º (410)-337-6285 (W) º
ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍͼ

Added ['] BIOS-READ-DOT IS READ-DOT to (>BIOS) 01Jan89mds

First load VGA.SEQ, which contains the direct screen writing
routines, and MCOLOR. The routines in this file use INT $10 to write
dots and draw lines, whereas those in VGA.SEQ use direct screen
writing for that.

DOT isn't unique
CDOT isn't unique
XDOT isn't unique
COLOR-DOT isn't unique
CLIP-DOT isn't unique
X1 isn't unique
Y1 isn't unique
X2 isn't unique
Y2 isn't unique
LINE isn't unique
NLINE isn't unique
SET_HLINE isn't unique
HLINE isn't unique
HOR_LINE isn't unique
CLIP_HLINE isn't unique
SET_VLINE isn't unique
VLINE isn't unique
VER_LINE isn't unique

comment;

comment:
ÕÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÑÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÑÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ͸
³ VGA Graphics Routines ³ DOT Plotting ³ 26July88mds ³
ÔÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÏÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÏÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ;
comment;

ANEW BIOS-GRAPHICS

assembler inlineon \ speeds up assembler words
forth definitions

HEX
PREFIX

comment:
\ The older, slower routines for dot plotting are:
: B.DOT ( x y color -- ) ( column row color -- )
C00 + -ROT 0 -ROT 10 INTCALL DROP ;

: B.CDOT ( color x y -- ) ( color column row -- )
ROT DOT ;

: B.XDOT ( x y color -- ) ( XORs a dot )
C00 + 80 OR -ROT 0 -ROT 10 INTCALL DROP ;

\ A speed test for DOT
decimal
: White-Screen1 ( -- ) RES
VRES @ 0 DO HRES @ 0 DO I J 15 DOT LOOP LOOP ;
\ This takes 22 seconds on a 10Mhz AT in HIGH res, using the above old
\ DOT routine.
hex
comment;

\ Note, all these routines assume "color" is only a byte.

CODE B.DOT ( x y color -- ) ( column row color -- )
POP AX MOV AH, # 0C \ AH=function, AL=color
XOR BX, BX \ page
POP DX \ y-coord.
POP CX \ x-coord.
PUSH BP \ preserve BP register
INT 10 \ call BIOS
POP BP \ restore BP
NEXT END-CODE

comment: \ A speed test for DOT 26July88mds
base @ decimal
: White-Screen2 ( -- ) RES
VRES @ 0 DO HRES @ 0 DO I J 15 DOT LOOP LOOP ;
base !
\ This takes only 14 seconds in HIGH res on a 10Mhz AT in, using the
\ new DOT routine. But see the file: WHITE.SEQ for much faster
\ routines to white the screen.
comment;

CODE B.CDOT ( color x y -- ) ( color column row -- )
POP DX \ y-coord.
POP CX \ x-coord.
XOR BX, BX \ page
POP AX MOV AH, # 0C \ AH=function, AL=color
PUSH BP \ preserve BP register
INT 10 \ call BIOS
POP BP \ restore BP
NEXT END-CODE

CODE B.XDOT ( x y color -- ) ( XORs a dot )
POP AX ADD AX, # 0C80 \ AH=function, AL=color
\ the 80 sets the high bit in AL, for XORing,
\ which is why XDOT doesn't XOR in VGA320 mode.
XOR BX, BX \ page
POP DX \ y-coord.
POP CX \ x-coord.
PUSH BP \ preserve BP register
INT 10 \ call BIOS
POP BP \ restore BP
NEXT END-CODE

CODE B.COLOR-DOT ( x y -- ) ( column row -- )
MOV AX, COLOR \ gets its color from the variable COLOR
MOV AH, # 0C \ AH=function, AL=color
XOR BX, BX \ page
POP DX \ y-coord.
POP CX \ x-coord.
PUSH BP \ preserve BP register
INT 10 \ call BIOS
POP BP \ restore BP
NEXT END-CODE

CODE B.CLIP-DOT ( x y -- )
CLEAR_LABELS \ prepare to use labels

\ Check the coordinates, to see if
\ 0 <= x < HRES, and 0 <= y < VRES.
POP DX \ y-coord
POP CX \ x-coord
CMP DX, VRES \ Is y >= VRES ?
JGE 1 $ \ If so, exit.
CMP CX, HRES \ Is x >= HRES ?
JGE 1 $ \ If so, exit.
XOR BX, BX \ Set BX=0 ( BX is the video page if
\ the dot is plotted)
CMP DX, BX \ Is y < 0 ?
JL 1 $ \ If so, exit.
CMP CX, BX \ Is x < 0 ?
JL 1 $ \ If so, exit.

\ If the coordinates are within our range, plot the dot in the
\ current color. The rest of this routine is like COLOR-DOT.
MOV AX, COLOR \ gets its color from the variable COLOR
MOV AH, # 0C \ AH=function, AL=color
PUSH BP \ preserve BP register
INT 10 \ call BIOS
POP BP \ restore BP
1 $: NEXT END-CODE

comment: \ slower, high-level version of CLIP-DOT
: B.CLIP-DOT ( x y -- ) 2DUP
0 VRES @ WITHIN SWAP 0 HRES @ WITHIN AND
IF COLOR-DOT ELSE 2DROP THEN ;
comment;


comment:
ÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
º Bresenham's Line Drawing Algorithm º
ÇÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄĶ
º Implemented by Mark Smiley ³ 31Aug88 º
ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÏÍÍÍÍÍÍÍÍͼ
comment;

CR .( Loading BIOS Line Drawing Utility ...)

HEX
GRAPHICS DEFINITIONS

\ ANEW LINE.DRAWER

\ VARIABLE X1 VARIABLE Y1
\ VARIABLE X2 VARIABLE Y2
VARIABLE X2' VARIABLE Y2'
VARIABLE DELX VARIABLE DELY
VARIABLE HALFX VARIABLE HALFY
VARIABLE CHEC

CODE SHALLOW.UL>LR ( -- ) \ optimized by Mike Sperl
\ fixed 22Feb89mds
CLEAR_LABELS
PUSH SI PUSH BP
\ mov bx, dely ( all registers are now busy, and there's)
mov bp, delx ( no register free for halfx)
MOV SI, X2
XOR DI, DI
\ We must set bx = 0 for int $10 function $0C
\ sorry, Mike, but BX does need to be 0 on systems that
\ have more than one page of graphics memory, (like my VGA)
\ BX is the graphics page 22Feb89mds
mov bx, di ( the same is true in DOT )
MOV AX, COLOR
MOV AH, # 0C
MOV DX, Y1
MOV CX, X1
1 $:
INT $10
ADD DI, DELY ( moved DELY back out of BX )
CMP DI, HALFX
JL 2 $
SUB DI, bp ( DELX) ( moved DELX into a register )
INC DX
2 $:
inc cx ( add )
CMP CX, SI
jng 1 $ ( note, was JNE; jle is a synonym)
POP BP
POP SI
NEXT END-CODE

CODE STEEP.UL>LR ( -- )
CLEAR_LABELS
PUSH SI PUSH BP PUSH DI
MOV SI, Y2
XOR DI, DI \ initialize DI to 0
MOV AX, COLOR
MOV AH, # 0C
MOV BX, DI
MOV DX, Y1
MOV CX, X1
DEC DX
1 $:
INC DX
INT 10
ADD DI, DELX
CMP DI, HALFY
JL 2 $
SUB DI, DELY
INC CX
2 $:
CMP DX, SI
JNE 1 $
POP DI POP BP POP SI
NEXT END-CODE


CODE SHALLOW.LL>UR ( -- )
CLEAR_LABELS
PUSH SI PUSH BP PUSH DI
MOV SI, X2
XOR DI, DI \ initialize DI to 0
MOV AX, COLOR
MOV AH, # 0C
MOV BX, DI
MOV DX, Y1
MOV CX, X1
DEC CX
1 $:
INC CX
INT 10
ADD DI, DELY
CMP DI, HALFX
JL 2 $
SUB DI, DELX
DEC DX \ only difference with SHALLOW.UL>LR
2 $:
CMP CX, SI
JNE 1 $
POP DI POP BP POP SI
NEXT END-CODE


CODE STEEP.LL>UR ( -- )
CLEAR_LABELS
PUSH SI PUSH BP PUSH DI
MOV SI, Y2
XOR DI, DI \ initialize DI to 0
MOV AX, COLOR
MOV AH, # 0C
MOV BX, DI
MOV DX, Y1
MOV CX, X1
INC DX
1 $:
DEC DX \ only difference with STEEP.UL>LR
INT 10
ADD DI, DELX
CMP DI, HALFY
JL 2 $
SUB DI, DELY
INC CX
2 $:
CMP DX, SI
JNE 1 $
POP DI POP BP POP SI
NEXT END-CODE


: UL>LR
CHEC @ IF STEEP.UL>LR
ELSE SHALLOW.UL>LR
THEN ;

: LL>UR
CHEC @ IF STEEP.LL>UR
ELSE SHALLOW.LL>UR
THEN ;

: B.DIAGONAL
Y1 @ Y2 @ <
IF UL>LR
ELSE LL>UR THEN ;


CODE B.HORIZONTAL ( .L>R ) \ draws from left to right
CLEAR_LABELS
PUSH SI PUSH BP
MOV AX, COLOR
MOV AH, # 0C
XOR BX, BX
MOV DX, Y1
MOV CX, X1
MOV SI, X2
DEC CX
1 $:
INC CX
INT 10
CMP CX, SI
\ INC CX \ this must set a flag to mess up the jump
JNE 1 $
POP BP POP SI
NEXT END-CODE


CODE VERTICAL.T>B
CLEAR_LABELS
PUSH SI PUSH BP
MOV AX, COLOR
MOV AH, # 0C
XOR BX, BX
MOV DX, Y1
MOV CX, X1
MOV SI, Y2
DEC DX
1 $:
INC DX
INT 10
CMP DX, SI
JNE 1 $
POP BP POP SI
NEXT END-CODE


CODE VERTICAL.B>T
CLEAR_LABELS
PUSH SI PUSH BP
MOV AX, COLOR
MOV AH, # 0C
XOR BX, BX
MOV DX, Y1
MOV CX, X1
MOV SI, Y2
INC DX
1 $:
DEC DX
INT 10
CMP DX, SI
JNE 1 $
POP BP POP SI
NEXT END-CODE


: B.VERTICAL
Y1 @ Y2 @ <
IF VERTICAL.T>B
ELSE VERTICAL.B>T THEN ;

: SET ( x1 y1 x2 y2 -- )
2DUP Y2' ! X2' !
Y2 ! >R R@ X2 ! ( x1 y1 )
OVER R> ( x1 y1 x1 x2 )
- DUP ABS DUP DELX !
2/ HALFX ! ( x1 y1 )
0<= IF Y1 ! X1 !
ELSE X2 @ Y2 @ Y1 ! X1 ! Y2 ! X2 !
THEN
Y2 @ Y1 @ - ABS DUP DELY !
2/ HALFY !
DELY @ DELX @ > CHEC ! ;


FORTH DEFINITIONS GRAPHICS ALSO

\ The two callable routines of the LINE package:

: B.LINE ( x1 y1 x2 y2 -- )
SET
DELY @
IF ( y1 <> y2 )
DELX @
IF ( x1 <> x2 )
B.DIAGONAL
ELSE B.VERTICAL
THEN
ELSE B.HORIZONTAL ( takes care of the singleton case, too )
THEN
Y2' @ Y2 ! X2' @ X2 ! ; \ restores variables for NLINE


: B.NLINE ( nx ny -- ) X2 @ Y2 @ 2SWAP LINE ;

comment:
The two main user usable routines of the LINE package are LINE and
NLINE.

Line Algorithm User's Guide

Enter the endpoints of the segment you wish to draw followed by
the command: LINE.
Example: entering, 10 20 30 40 LINE, will cause a segment with
endpoints [10,20] and [30,40] to be drawn. If you wish to continue
drawing from [30,40], simply enter the next endpoint, followed by the
command, NLINE.
Example: To draw two segments from [10,20] to [30,40] to [70,80],
type in: 10 20 30 40 LINE, followed by: 70 80 NLINE.
comment;


comment: ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
³ Horizontal and Vertical Lines ³
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ
comment;

\ ONLY FORTH ALSO GRAPHICS ALSO
GRAPHICS DEFINITIONS

: SET_HLINE ( x1 x2 y1 )
Y1 ! X2 ! X1 ! ;

FORTH DEFINITIONS

: B.HLINE ( x1 x2 y1 ) \ draws a horizontal line, assumes x1 < x2
SET_HLINE
B.HORIZONTAL ; \ draws left to right

: B.HOR_LINE ( x1 x2 y1 ) \ draws a horizontal line, no assumptions
\ except that the values are within range
Y1 !
2DUP > IF SWAP THEN
X2 ! X1 !
B.HORIZONTAL ; \ draws left to right

comment:
: CLIP_HLINE ( x1 x2 y1 ) \ draws a horizontal line, if it's within
\ range of the screen, clips if necessary
DUP 0 VRES @ WITHIN \ if Y1 is in the proper vertical range
IF Y1 !
2DUP > IF SWAP THEN
HRES @ 1- MIN X2 ! \ clip the right
0 MAX X1 ! \ clip the left
B.HORIZONTAL \ draws left to right
ELSE 3DROP \ Y1 out of range so draw nothing
THEN ;
comment;


GRAPHICS DEFINITIONS

: B.SET_VLINE ( y1 y2 x1 )
X1 ! Y2 ! Y1 ! ;

\ FORTH DEFINITIONS

: B.VLINE ( y1 y2 x1 ) \ draws a vertical line, assumes y1 < y2
B.SET_VLINE
VERTICAL.T>B ; \ draws top to bottom

: B.VER_LINE ( y1 y2 x1 ) \ draws a vertical line, no assumptions
X1 !
2DUP > IF SWAP THEN
Y2 ! Y1 !
VERTICAL.T>B ; \ draws top to bottom

comment:
: CLIP_VLINE ( y1 y2 x1 ) \ draws a vertical line, if it's within
\ the range of the screen
DUP 0 HRES @ WITHIN \ if X1 is in the proper vertical range
if -rot
2DUP > IF SWAP THEN \ assure y1 < y2
VRES @ 1- MIN \ clip the bottom
swap 0 MAX swap \ clip the top
rot
B.VLINE
else 3drop
then ;
comment;


DECIMAL

comment:
\ tests for LINE 31Aug88mds
: tt 0 0 hres @ 1- vres @ 1- LINE ;

: vv 0 vres @ 1- hres @ 1- 0 LINE ;

: rr 1 3 hres @ 5 - 7 LINE
2 vres @ 2/ 1+ dup hres @ 3 - swap 5 - LINE
10 1 15 vres @ 1- LINE
101 vres @ 2- 105 0 LINE ;

: uu 1 3 hres @ 5 - 7 2swap LINE
2 vres @ 2/ 1+ dup hres @ 3 - swap 5 - 2swap LINE
10 1 15 vres @ 1- 2swap LINE
101 vres @ 2- 105 0 2swap LINE ;

: XX ." X1 = " X1 @ . ." Y1 = " Y1 @ . CR
." X2 = " X2 @ . ." Y2 = " Y2 @ . ;
comment;

DECIMAL

: B.XOR_COLOR
COLOR @ DUP 128 <=
IF 128 XOR COLOR !
ELSE DROP THEN ;

: B.XLINE ( x1 y1 x2 y2 -- )
B.XOR_COLOR B.LINE ;

: B.XHLINE ( x1 x2 y1 -- )
B.XOR_COLOR B.HOR_LINE ;

: B.XVLINE ( y1 y2 x1 -- )
B.XOR_COLOR B.VER_LINE ;



comment: ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
³ Changing Graphics (and Text) Modes ³
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ
comment;

: (>BIOS)
['] B.dot is dot
['] B.xdot is xdot
['] B.cdot is cdot
['] B.color-dot is color-dot
['] B.clip-dot is clip-dot
['] bios-read-dot is read-dot
['] B.line is line
['] B.HOR_line is hline
['] B.VER_line is vline
['] B.xline is xline
['] B.xhline is xhline
['] B.xvline is xvline
['] B.NLINE IS NLINE

['] SLOW-WHITE-SCREEN IS WHITE-SCREEN
['] SLOW-FILL-SCREEN IS FILL-SCREEN
['] Set-Res IS (CLEAR-SCREEN) \ clear screen using INT $10
;

comment:
\ items not set by (>BIOS) that should be so set
80 bytes/row !
4 =: #PLANES
\ $9600 = 80 x 480 or 38400 for one bit plane 640x480 ( mps )
38400 !> bit_plane.size
['] EGA>file IS SaveVID
['] file>EGA IS RestVID
['] (ega_brecall) is (brecall)
['] (ega_bsave) is (bsave) \ for "BSAVE
['] COPY_IMAGE IS BSAVE
comment;

\ direct graphics
( vidmode hres vres #colors vidseg bufsize vchip )
: (MED.D) ( -- ) 4 320 200 4 $B800 $4000 CGA !VMODE
BUF.SIZE @ !> bit_plane.size
['] mres.dot is dot
['] mres.xdot is xdot
['] mres.cdot is cdot
['] mres.color-dot is color-dot
['] mres.clip-dot is clip-dot
['] bios-read-dot is read-dot
['] cga.line is line
['] cga.hline is hline
['] cga.vline is vline
['] cga.NLINE IS NLINE

['] B.xline is xline \ uses BIOS
['] B.xhline is xhline \ uses BIOS
['] B.xvline is xvline \ uses BIOS

['] vid>buf IS SaveVID
\ ['] buf>vid IS RestVID
['] BUF_RestVid IS RestVID
['] (cga_brecall) is (brecall)
['] (cga_bsave) is (bsave) \ for "BSAVE & BUF_BSAVE
['] BUF_BSAVE IS BSAVE
['] WHITE-CGA IS WHITE-SCREEN
['] FILL-CGA IS FILL-SCREEN
['] (CLEAR-SCREEN.D) IS (CLEAR-SCREEN)
;
' (MED.D) IS (MED)



\ direct graphics
( vidmode hres vres #colors vidseg bufsize vchip )
: (HIGH.D) ( -- ) 6 640 200 2 $B800 $4000 CGA !VMODE
1 color !
BUF.SIZE @ !> bit_plane.size
['] hires.dot is dot
['] hires.xdot is xdot
['] hires.cdot is cdot
['] hires.color-dot is color-dot
['] hires.clip-dot is clip-dot
['] bios-read-dot is read-dot
['] cga.line is line
['] cga.hline is hline
\ ['] hline640 is hline \ This should also work, but it plays w/
\ the EGA/VGA ports, which is unnecessary
\ in CGA modes.
['] cga.vline is vline
['] cga.NLINE IS NLINE

['] B.xline is xline \ uses BIOS
['] B.xhline is xhline \ uses BIOS
['] B.xvline is xvline \ uses BIOS

['] vid>buf IS SaveVID
\ ['] buf>vid IS RestVID
['] BUF_RestVid IS RestVID
['] (cga_brecall) is (brecall)
['] (cga_bsave) is (bsave) \ for "BSAVE
['] BUF_BSAVE IS BSAVE
['] WHITE-CGA IS WHITE-SCREEN
['] FILL-CGA IS FILL-SCREEN
['] (CLEAR-SCREEN.D) IS (CLEAR-SCREEN)
;
' (HIGH.D) IS (HIGH)


}
( vidmode hres vres #colors vidseg bufsize vchip )
: (MED.B) ( -- ) 4 320 200 4 $B800 $4000 1 !VMODE
(>BIOS)
;
\ ' (MED.B) IS (MED)

( vidmode hres vres #colors vidseg bufsize vchip )
: (HIGH.B) ( -- ) 6 640 200 2 $B800 $4000 1 !VMODE
1 color !
(>BIOS)
;
\ ' (HIGH.B) IS (HIGH)

( vidmode hres vres #colors vidseg bufsize vchip )
: (EGA.B) ( -- ) 16 640 350 16 $A000 $9600 2 !VMODE
(>BIOS)
;
\ ' (EGA.B) IS (EGA)

( vidmode hres vres #colors vidseg bufsize vchip )
: (VGA320.B) ( -- ) 19 320 200 256 $A000 $FA00 3 !VMODE
(>BIOS)
;
\ ' (VGA320.B) IS (VGA320)

( vidmode hres vres #colors vidseg bufsize vchip )
: (VGA640.B) ( -- ) 18 640 480 16 $A000 $9600 3 !VMODE
(>BIOS)
;
\ ' (VGA640.B) IS (VGA640)

( vidmode hres vres #colors vidseg bufsize vchip )
: (VEGA.B) ( -- ) 22 800 600 16 $A000 $FA00 100 !VMODE
(>BIOS)
;
\ ' (VEGA.B) IS (VEGA)
{

: (MED.B) ( -- ) (MED.D) (>BIOS) ;
\ ' (MED.B) IS (MED)

: (HIGH.B) ( -- ) (HIGH.D) (>BIOS) ;
\ ' (HIGH.B) IS (HIGH)

: (EGA.B) ( -- ) (EGA.D) (>BIOS) ;
\ ' (EGA.B) IS (EGA)

: (VGA320.B) ( -- ) (VGA320.D) (>BIOS) ;
\ ' (VGA320.B) IS (VGA320)

: (VGA640.B) ( -- ) (VGA640.D) (>BIOS) ;
\ ' (VGA640.B) IS (VGA640)

: (VEGA.B) ( -- ) (VEGA.D) (>BIOS) ;
\ ' (VEGA.B) IS (VEGA)


FORTH DEFINITIONS


DEFER DIRECT_GRAPHICS \ make modes write directly to the screen
: (DIRECT_GRAPHICS) \ make modes write directly to the screen
\ DIRECT? ON
['] (MED.D) IS (MED)
['] (HIGH.D) IS (HIGH)
['] (EGA.D) IS (EGA)
['] (VGA320.D) IS (VGA320)
['] (VGA640.D) IS (VGA640)
['] (VEGA.D) IS (VEGA)
(RES) ; \ makes changes take effect
' (DIRECT_GRAPHICS) IS DIRECT_GRAPHICS
DIRECT_GRAPHICS


DEFER BIOS_GRAPHICS

: (BIOS_GRAPHICS)
\ DIRECT? OFF
['] (MED.B) IS (MED)
['] (HIGH.B) IS (HIGH)
['] (EGA.B) IS (EGA)
['] (VGA320.B) IS (VGA320)
['] (VGA640.B) IS (VGA640)
['] (VEGA.B) IS (VEGA)
(RES) ; \ makes changes take effect
' (BIOS_GRAPHICS) IS BIOS_GRAPHICS

VARIABLE DIRECT? DIRECT? ON \ flag: are graphics direct or bios?

' >buwt is >attrib5

: BIOS_OR_DIRECT?
>norm TEXT
>attrib5
13 5 59 12 BOX&FILL \ draw a box
CURSOR-OFF
>ATTRIB1 ." Choosing BIOS or Direct Graphics" BCR BCR
>attrib5
ASCII B SP.RED.EMIT ." Bios graphics routines (safer). " BCR BCR
ASCII D SP.RED.EMIT ." Direct screen writing graphics (faster)."
KEY UPC
ASCII B =
IF BIOS_GRAPHICS DIRECT? OFF
ELSE DIRECT_GRAPHICS DIRECT? ON
THEN
\ (RES) \ so the differences take effect
>NORM
CURSOR-ON ;

: REST_GRAPHICS ( -- ) \ restore the system graphics state
\ based on DIRECT? flag previously left on TOS
DIRECT? @
IF DIRECT_GRAPHICS
ELSE BIOS_GRAPHICS
THEN ;


assembler inlineoff