home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Monster Media 1994 #1
/
monster.zip
/
monster
/
PROG_BAS
/
SVGAQB20.ZIP
/
SVGABC.TXT
< prev
next >
Wrap
Text File
|
1994-03-11
|
246KB
|
10,327 lines
REFERENCE MANUAL
FOR SVGAQB.LIB
AND SVGAPV.LIB
THE SUPER VGA
GRAPHICS LIBRARY
TO BE USED WITH
MICROSOFT QUICKBASIC,
VISUAL BASIC FOR DOS
AND BASIC PROFESSIONAL
DEVELOPMENT SYSTEM
1993-1994 by Zephyr Software - Stephen L. Balkum and Daniel A.
Sill
All rights reserved. No part of this book shall be reproduced or
transmitted by any means, electronic, mechanical, photocopying,
recording or otherwise, without written permission from Zephyr
Software - Stephen L. Balkum and Daniel A. Sill.
Although every effort has been made to insure the accuracy of the
material in this book, Zephyr Software, Stephen L. Balkum and
Daniel A. Sill assume no responsibility for errors or omissions.
In addition no liability is assumed for damages resulting from
the use of the information contained herein.
Printed in the United States of America
Trademarks
The Graphics Interchange Format (c) is the Copyright property of
CompuServe Incorporated.
GIF (sm) is a Service Mark property of CompuServe Incorporated.
Sound Blaster and Sound Blaster Pro are trademarks of Creative
Labs, Inc.
All others are trademarks of their respective owners.
ii
SOFTWARE LICENSE AGREEMENT
By using this software, you agree to the terms of this
agreement.
No warranties are expressed or implied. In no event
shall Zephyr Software, Stephen L. Balkum or Daniel A.
Sill be held liable for damages resulting from the use
or misuse of this product, including but not limited to
implied warranties of fitness for a particular purpose.
The shareware version may be freely distributed as long
as all files stay together and are not modified in any
way. No cost may be charged for the shareware version
beyond normal and reasonable copying and distribution
expenses.
No products developed with this software shall be sold
unless this software has been registered with Zephyr
Software, Stephen L. Balkum or Daniel A. Sill.
At no time for any reason shall this software be
reverse engineered, decompiled or disassembled.
This software may not be rented or leased.
This software may be used only on one terminal or one
computer at any one given moment in time. This
software may not be installed on a network of any type.
Contact Zephyr Software, Stephen L. Balkum or Daniel A.
Sill for networking options.
United States Government Restricted Rights:
Use, duplication or disclosure of this software and
documentation by the U.S. Government is subject to the
restrictions as set forth in subparagraph (c)(1)(ii) of
the Rights in Technical Data and Computer Software
clause at DFARS 252.227-7013. Contractor/manufacturer
is Stephen L. Balkum and Daniel A. Sill, P.O. Box 7704,
Austin, Texas 78713-7704.
The ownership of this software may be transferred as
long as Zephyr Software, Stephen L. Balkum or Daniel A.
Sill is notified in writing of the transfer date and
new owner. The new owner must agree to this contract.
The transfer must include all registered updates and
previously registered versions. The original owner may
not retain any copies in any form of the registered
software or its documents.
iii
INTRODUCTION
We spent weeks searching the depths of the internet ftp sites for
a library that would allow the programmer full access to the
abilities of Super VGA. We wanted the colors VGA could provide
and better resolution than EGA could provide. Professionally
developed libraries with this ability were definitely out of our
price range. After our searches continuously returned nothing,
we decided to fill the apparent void in the shareware market.
Our searches did give two useful packages: John Bridges' VGAKIT
and Finn Thoegersen's VGADOC. We began with these two works and
developed a graphics library intended to allow the programmer
access to the huge world of high resolution programming.
On the surface the task appeared quite simple. However, it
quickly became obvious that the routines in this library would be
required to affect extremely large amounts of data. Operations
must be quick to be successful. Therefore, every effort was made
to create the fastest code possible - even at the expense of
size. For this reason we opted to write code with the 32 bit
instructions of the 80386 and 80486 chips. It is our opinion
that anyone with a hi-res card in a lesser machine may have some
priorities out of order. All routines are written in assembly and
use absolutely no floating point values. Anytime a real number
was required, fixed point notation was used. In addition we
attempted to write the routines such that any reasonable argument
passed can be interpreted intelligently by the library.
With the numerous Super VGA cards available and no well
established standard we chose John Bridges' identification and
bank switching routines as a beginning. These two routines have
undergone some modification, but not enough to justify
copyrighting this portion of the library's code by Zephyr
Software. We have no intentions of releasing our changes to
these routines into the public domain. From that point onward
all code is original. In some instances common algorithms were
researched and original code written according to that algorithm.
This Super VGA library gives the programmer transparent access to
twenty different Super VGA cards. These cards include Acumos,
Ahead, ATI Technologies, Avance, Chips and Technologies, Cirrus
Logic, Everex, Genoa, MXIC, NCR, Oak Technologies,
Paradise/Western Digital, Primus, Realtek, Trident, Tseng Labs,
Video 7 and the VESA standard. Please see the WHICHVGA function
for the specific chipsets. The programmer only needs to verify
that the end user's card has been identified, but not which card
was recognized. After proper identification, all functions react
in exactly the same fashion. The library contains functions to
draw all of the major primitives. In addition there are
functions that modify the screen palette, write text on the
screen with a choice of fonts and modify the reaction of the
primitives. Identification routines include not only the video
card, but also the amount of video memory, type of processor and
2
installed pointing devices. Advanced functions provide full
mouse support (when used with a Microsoft compatible driver) and
joystick support. Finally, support for two dimensional and three
dimensional coordinate systems is provided including rotation,
translation, scaling and projection.
3
SUGGESTED METHODS FOR USING THIS LIBRARY
USE WITHIN THE BASIC ENVIRONMENT
We assume that the programmer is familiar with all of the
capabilities of the Microsoft QuickBasic, Visual Basic (VBDOS) or
Basic Professional Development System (PDS) compiler and
environment. Understanding of the LIB and LINK commands is
encouraged as well as the use of QuickLibraries. However, to
ensure you are able to get up and running quickly, the following
commands may be helpful:
To create a QuickLibrary from SVGAQB/PV.LIB, type the command:
LINK /QU SVGAQB/PV.LIB, SVGAQB/PV.QLB, NUL, QUICKQLB.LIB
where QUICKQLB.LIB is the name for your compiler's QuickLibrary
(BQLB45.LIB for QuickBasic 4.5, VBDOSQLB.LIB for VBDOS and
QBXQLB.LIB for PDS).
If you wish to create a QuickLibrary from SVGAQB/PV.LIB and
additional libraries, type the command:
LINK /QU SVGAQB/PV.LIB + ????.LIB (continue as desired),
NEWLIB.QLB, NUL, QUICKQLB.LIB
where QUICKQLB.LIB is the same as above and ????.LIB represents
the additional desired libraries.
After the QuickLibrary has been created, you should start your
development environment by typing:
QuickBasic: QB /L SVGAQB
VBDOS: VBDOS /L SVGAPV
PDS: QBX /L SVGAPV
This will tell the compiler to use the QuickLibrary when running
and when creating an executable.
VERIFICATION OF A COMPUTER'S HARDWARE
It is strongly recommended that any program written with this
library first verifies that the computer is a 80386 or better by
calling the WHICHCPU function. Many of the library's functions
use 386 exclusive code which may cause a computer with a lesser
processor to crash. In addition WHICHMOUSE must be called before
calling any of the mouse functions. Lastly, it is recommended
that WHICHJOYSTICK be called before a program uses the joystick
routines.
It is required that a program call WHICHVGA prior to any function
that communicates with the video card. If WHICHVGA returns a
zero for unknown card type, the program should not call any
graphics function. Without proper identification of the video
4
card any graphics function will likely cause a system failure.
It is recommended, although not necessary, that a program call
WHICHMEM prior to calling any RES function. Although the video
card was properly identified, it may not have sufficient onboard
memory to support the desired resolution. As a second check the
RES functions will do nothing if the video card has not been
identified or if the video card does not support the specified
resolution for memory or hardware reasons.
THE 256 COLOR PALETTE
The 256 color palette of the Super VGA cards is a six bit
palette. Each of the 256 colors of the palette are described by
three values representing the intensity of the colors red, blue
and green. These values can range from 0 to 63. Anytime a value
outside of this range is used, the video card simply ignores the
upper two bits. Therefore, 64 is the same as 0. This should be
taken into consideration when manipulating the palette or when
importing a palette from an external source such as a GIF image.
USE OF 2-D AND 3-D FUNCTIONS
In the interest of speed, the 2-D and 3-D functions were written
to best work on multiple points at once. We refer to these
functions as object-oriented. This means that the points
defining an object (a box, a house, etc.) should be contained
within one array or part of an array and calls to the functions
should act on all of the points in the array. Calls to functions
have a high speed overhead, therefore, placing more than one
object in the same array and passing the entire array to the
functions can be beneficial. However, these functions will work
on a single point as well.
Another consequence of our object-oriented 2-D and 3-D functions
is the use of the scaling functions. When scaling objects, we
recommend the object be defined about the origin. D2SCALE and
D3SCALE both work with respect to the origin. This eliminates a
significant number of translations that would otherwise be
required by having a definable scale origin. For example, to
draw two boxes, one scaled by one-half of the other, each rotated
by 45 degrees at the center of the screen, the recommended
procedure is as follows:
define an array BOX containing the 2-D points: (100, 100), (-
100, 100), (-100, -100), (100, -100), (note: the box is
centered about the origin.)
rotate BOX by 45 degrees about (0, 0) and place the output in
RBOX,
scale RBOX by 50% (scaling factor would be 128, or 80 hex) and
place output in SRBOX,
translate RBOX to the center of the screen - a translation of
320, 240 in 640x480 resolution - and place output in TRBOX,
translate SRBOX to the center of the screen - same translation
as for RBOX - and place output in TSRBOX,
5
draw TRBOX and TSRBOX on the screen.
Notice that by defining the box centered about the origin the
translation values were extremely intuitive. Also notice that if
we had scaled the second box after the translation, it would have
been draw in the upper left quadrant of the screen instead of the
center.
In mathematics and many sciences it is customary that in a 2-D
coordinate system the Y axis increases upward and the X axis
increases to the right. The computer industry has decided the Y
axis should increase downward. The 2-D functions are not
affected by the choice in coordinate systems. However, it is
important to remember that a positive rotation in D2ROTATE
rotates from the positive X axis to the positive Y axis.
Therefore, when using mathematical conventions, a positive
rotation moves counter-clockwise. On the computer screen a
positive rotation moves clockwise.
The 3-D coordinate system follows mathematical conventions by
using a right-handed coordinate system. The easiest way to
visualize this coordinate system is by using your right hand.
Place your index finger and thumb at a right angle to one another
as if to form an imaginary pistol. Now place your second finger
at a right angle to your index finger. It should be at a right
angle to your thumb as well. This represents the three axes.
The index finger is the X axis, the second finger is the Y axis
and the thumb is the Z axis. The easiest way to remember
rotation directions in this system is cyclically. A positive
rotation about the X axis rotates the Y axis into the Z axis. A
positive rotation about the Y axis rotates the Z axis into the X
axis. A positive rotation about the Z axis rotates the X axis
into the Y axis.
After doing all necessary 3-D transformations, projection onto
the 2-D computer screen is required. Although the computer
screen's coordinate system does not follow mathematical
conventions, the D3PROJECT function automatically takes care of
all conversions. The programmer only needs to draw the resulting
lines on the screen.
THE CONCEPT OF SPRITE GRAPHICS
The key to sprite graphics is the assumption that only a small
percentage of the pixels in a graphics block are used by the
animation and the remaining pixels should be treated as
transparent, revealing the background behind the sprite. The
sprite routines in this library only act on non-transparent
colors, thus, saving time by ignoring a large number of pixels.
When retrieving the background for a sprite, prior knowledge of
the sprite itself permits obtaining background only where it is
necessary.
6
The following steps outline an example of the recommended
procedure for using the sprite functions:
1. draw the sprite on the screen - a white stick figure on a
black background, for example
2. use BLKGET to place the sprite in an array STICK
3. use SPRITEGAP to simultaneously retrieve the background into
BACKSTICK and place STICK on the screen, declaring black as
the transparent color
4. use SPRITEPUT to replace the background BACKSTICK in the
same location as step 3
5. repeat steps 3 and 4 as many times and in as many locations
as desired
EXTENDED MEMORY SUPPORT
With the higher screen resolutions, more memory may be needed for
data storage. For this reason extended memory support is
provided. Accessing extended memory requires the computer to
switch into protected mode. The process of switching into
protected mode and returning is handled by the extended memory
manager, usually HIMEM.SYS. The switch is relatively slow.
Therefore, it should be used as fast storage access since it is
much faster than disk access.
Extended memory access is also limited by the number of available
handles. The limit is controlled by a switch on the extended
memory manager's command line and normally defaults to 32. Also,
it is imperative that all allocated extended memory blocks be
freed before the program terminates. Unfreed memory blocks will
be unavailable until the computer is rebooted.
CONVENTIONS USED IN THIS MANUAL
All parameters, other than strings, passed to and from functions
and procedures in this QuickBasic library are short (two byte)
integers. No floating point values are used.
Whenever a pixel is written on the screen, a mode is required.
Unless otherwise noted, there are four possible modes: SET, XOR,
OR and AND. These modes are represented by the numbers one
through four respectively. Technically, SET is the fastest mode.
However, XOR maybe the most useful. XOR'ing a point twice with
the same color returns the original color. This can be used to
cover and uncover graphics. In addition when a reference to a
color index is made, only values between and including 0 and 255
are valid. Any integer will work, but only the lowest eight bits
are recognized.
7
BLKGET
PROTOTYPE
SUB BLKGET (X1%, Y1%, X2%, Y2%, GfxBlk%)
INPUT
X1, Y1 - top left corner of block
X2, Y2 - bottom right corner of block
OUTPUT
If declared as a function, BLKGET returns 1 if successful, 0
if failed.
GfxBlk - integer destination array holding retrieved bitmap
USAGE
BLKGET stores the pixel data contained within the block
defined by (X1, Y1)-(X2, Y2) in the variable referenced by
GfxBlk. GfxBlk must be dimensioned as a short integer array
with a size in integers equal to
[(X2-X1+1)*(Y2-Y1+1)] / 2+3.
Note, however, that GfxBlk can be quite large. If the size of
GfxBlk is insufficient, BLKGET will overwrite any data in
memory contained beyond GfxBlk and may possibly cause the
system to crash. BLKGET enforces X2 X1 and Y2Y1. Also, the
coordinates must be valid on the screen at the current
resolution.
The bitmap is stored such that the first integer in the
destination array is the width and the second integer is the
height. The remaining bytes are the bitmap raster data stored
by rows starting at the top of the block.
Arrays should be passed by giving the element within the array
from where the action should take place. This allows the
programmer to store more than one item within the same array
or act on only a portion of the array.
SEE ALSO
BLKPUT, BLKRESIZE, BLKROTATE, GETLASTSTRING, SPRITEGAP,
SPRITEGET, SPRITEPUT
EXAMPLE
REM PLACES 1/4 OF A CIRCLE AT THE CENTER OF THE SCREEN
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
DIM BLOCKDATA(0 TO 483) AS INTEGER
IF WHICHVGA = 0 THEN STOP
8
DUMMY=RES640
DRWCIRCLE 1, 10, 30, 30, 20
FILLAREA 30, 30, 10, 7
BLKGET 0, 0, 30, 30, BLOCKDATA(0)
BLKPUT 1, 320, 240, BLOCKDATA(0)
WHILE INKEY$ = ""
WEND
DUMMY=RESTEXT
END
9
BLKPUT
PROTOTYPE
SUB BLKPUT (Mode%, X%, Y%, GfxBlk%)
INPUT
Mode - pixel write mode (SET=1, XOR=2, OR=3, AND=4)
X, Y - location for top left corner of block
GfxBlk - integer source array
OUTPUT
no value returned
USAGE
BLKPUT places the pixel data contained in the variable
referenced by GfxBlk on the screen. The top, left corner of
the block is specified by (X, Y). Any (X, Y) is acceptable
and any portion of the block that lies outside of the
currently defined viewport will not be drawn.
Arrays should be passed by giving the element within the array
from where the action should take place. This allows the
programmer to store more than one item within the same array
or act on only a portion of the array.
SEE ALSO
BLKGET, BLKRESIZE, BLKROTATE, GETLASTSTRING, SPRITEGAP,
SPRITEGET, SPRITEPUT, GIFPUT, SETVIEW
EXAMPLE
See BLKGET
10
BLKRESIZE
PROTOTYPE
SUB BLKRESIZE (NewXSize%, NewYSize%, SourceGfxBlk%,
DestGfxBlk%)
INPUT
NewXSize, NewYSize - size of resulting bitmap in DestGfxBlk
SourceGfxBlk - integer source array
OUTPUT
no value returned
DestGfxBlk - integer destination array holding resized bitmap
USAGE
BLKRESIZE takes the bitmap in SourceGfxBlk and scales it up or
down according the to values passed in NewXSize and NewYSize.
The resulting bitmap is returned in DestGfxBlk which should
already be declared with a size calculated according to the
equation in BLKGET. NewXSize and NewYSize should not be zero.
SEE ALSO
BLKGET, BLKPUT, BLKROTATE
EXAMPLE
REM RESIZE A BITMAP
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
DIM SRC%(0 TO 32000)
DIM DST%(0 TO 32000)
IF WHICHCPU < 386 THEN END
IF WHICHVGA = 0 THEN END
VMODE=VIDEOMODEGET
IF RES640 <> 1 THEN
DUMMY = RESTEXT
END
END IF
X1 = 0
Y1 = 0
X2 = 50
Y2 = 50
FOR I = 0 TO 25
XA = (RND * X2 - X1) + X1
YA = (RND * Y2 - Y1) + Y1
XB = (RND * X2 - X1) + X1
YB = (RND * Y2 - Y1) + Y1
C = RND * 16
11
DRWLINE 1, C, XA, YA, XB, YB
NEXT I
DRWBOX 1, 15, X1, Y1, X2, Y2
BLKGET X1, Y1, X2, Y2, SRC(0)
X1 = GETMAXX \ 2
Y1 = GETMAXY \ 2
X = SRC(0) + 1
Y = SRC(1) + 1
BLKRESIZE X, Y, SRC(0), DST(0)
BLKPUT 2, X1 - DST(0) \ 2, Y1 - DST(1) \ 2, DST(0)
FOR I = X TO X + 50
BLKPUT 2, X1 - DST(0) \ 2, Y1 - DST(1) \ 2, DST(0)
BLKRESIZE I, I, SRC(0), DST(0)
BLKPUT 2, X1 - DST(0) \ 2, Y1 - DST(1) \ 2, DST(0)
SDELAY 3
NEXT I
FOR I = X + 50 TO X - 50 STEP -1
BLKPUT 2, X1 - DST(0) \ 2, Y1 - DST(1) \ 2, DST(0)
BLKRESIZE I, I, SRC(0), DST(0)
BLKPUT 2, X1 - DST(0) \ 2, Y1 - DST(1) \ 2, DST(0)
SDELAY 3
NEXT I
FOR I = X - 50 TO X
BLKPUT 2, X1 - DST(0) \ 2, Y1 - DST(1) \ 2, DST(0)
BLKRESIZE I, I, SRC(0), DST(0)
BLKPUT 2, X1 - DST(0) \ 2, Y1 - DST(1) \ 2, DST(0)
SDELAY 3
NEXT I
VIDEOMODESET VMODE
END
12
BLKROTATE
PROTOTYPE
FUNCTION BLKROTATE% (Ang%, BackFillColor%, SourceGfxBlk%,
DestGfxBlk%)
INPUT
Ang - integer degree to rotate source bitmap
BackFillColor - index to color in current palette to fill
blank space in DestGfxBlk
SourceGfxBlk - integer source array
OUTPUT
BLKROTATE returns 1 if successful, 0 if unsuccessful.
DestGfxBlk - integer destination array holding rotated bitmap
USAGE
BLKROTATE takes the bitmap in SourceGfxBlk and rotates by the
number of degrees specified in Ang. The bitmap rotation
algorithm is a three-pass shear technique modified to make
efficient use of this library's internal buffers. Blank space
around the newly rotated block is filled with the color given
by BackFillColor. The resulting bitmap is stored in
DestGfxBlk. The size of DestGfxBlk should be at least as big
as given by BLKROTATESIZE.
The function will fail if it calculates that the internal
buffers would be overflowed or if the destination array would
be larger than 65536 bytes. BLKROTATESIZE should be called
first to ensure that buffer integrity is maintained.
SEE ALSO
BLKGET, BLKPUT, BLKRESIZE, BLKROTATESIZE
EXAMPLE
REM ROTATE A BITMAP
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
DIM SRC%(0 TO 32000)
DIM DST%(0 TO 32000)
IF WHICHCPU < 386 THEN END
IF WHICHVGA = 0 THEN END
VMODE = VIDEOMODEGET
IF RES640 <> 1 THEN
DUMMY = RESTEXT
END
END IF
X1 = 0
13
Y1 = 0
X2 = 110
Y2 = 110
FOR I = 0 TO 50
XA = (RND * X2 - X1) + X1
YA = (RND * Y2 - Y1) + Y1
XB = (RND * X2 - X1) + X1
YB = (RND * Y2 - Y1) + Y1
C = RND * 16
DRWLINE 1, C, XA, YA, XB, YB
NEXT I
DRWBOX 1, 15, X1, Y1, X2, Y2
BLKGET X1, Y1, X2, Y2, SRC(0)
X1 = GETMAXX \ 2
Y1 = GETMAXY \ 2
FOR I = 0 TO 359 STEP 6
IF BLKROTATESIZE(I, SRC(0)) <> 0 THEN
DUMMY = BLKROTATE(I, 0, SRC(0), DST(0))
BLKPUT 2, X1 - DST(0) \ 2, Y1 - DST(1) \ 2, DST(0)
SDELAY 3
BLKPUT 2, X1 - DST(0) \ 2, Y1 - DST(1) \ 2, DST(0)
END IF
NEXT I
VIDEOMODESET VMODE
END
14
BLKROTATESIZE
PROTOTYPE
FUNCTION BLKROTATESIZE& (Ang%, SourceGfxBlk%)
INPUT
Ang - integer degree to rotate source bitmap
SourceGfxBlk - integer source array
OUTPUT
BLKROTATESIZE returns the number of bytes needed for the
destination array if successful, 0 if unsuccessful.
USAGE
BLKROTATESIZE takes the bitmap in SourceGfxBlk calculates the
required size of the output buffer needed when BLKROTATE is
called. It also insures that the internal library buffers are
not overflowed. The function will fail if it calculates that
the internal buffers would be overflowed or if the destination
array would be larger than 65536 bytes. BLKROTATESIZE should
be called prior to BLKROTATE to ensure that buffer integrity
is maintained.
SEE ALSO
BLKGET, BLKPUT, BLKRESIZE, BLKROTATE
EXAMPLE
See BLKROTATE
15
BYTECOPY
PROTOTYPE
SUB BYTECOPY (SrcArray%, DestArray%, NumOfBytes&)
INPUT
SrcArray - integer array to be copied
NumBytes - number of bytes to copy from SrcArray to DestArray
OUTPUT
no value returned
DestArray - integer destination array holding copied data
USAGE
BYTECOPY copies the specified number of bytes from SrcArray to
DestArray. It is much faster than using a FOR/NEXT loop. The
arrays must be integer arrays. NumBytes is equal to twice the
number of elements to be copied. For example, if SrcArray
contains 10 integers to be copied, NumBytes is 2 * 10, or 20
bytes. The declaration for BYTECOPY can be changed to allow
real numbers in which case NumBytes is equal to 4 times the
number of elements to be copied. Note, however, that BYTECOPY
will not work with strings.
Arrays should be passed by giving the element within the array
from where the action should take place. This allows the
programmer to store more than one item within the same array
or act on only a portion of the array.
SEE ALSO
PALCOPY
EXAMPLE
REM COPIES AN ARRAY
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
DIM ARRAY1(1 TO 10) AS INTEGER
DIM ARRAY2(1 TO 10) AS INTEGER
CLS
FOR I=1 TO 10
ARRAY1(I) = I
ARRAY2(I) = 11 - I
NEXT I
PRINT "Before copying:"
FOR I=1 TO 10
PRINT ARRAY1(I);
NEXT I
16
PRINT
FOR I=1 TO 10
PRINT ARRAY2(I);
NEXT I
PRINT
BYTECOPY ARRAY1(1), ARRAY2(1), 20
PRINT "After copying:"
FOR I=1 TO 10
PRINT ARRAY1(I);
NEXT I
PRINT
FOR I=1 TO 10
PRINT ARRAY2(I);
NEXT I
PRINT
END
17
D2ROTATE
PROTOTYPE
SUB D2ROTATE (NumPoints%, XOrigin%, YOrigin%, Angle%,
InArray%, OutArray%)
INPUT
NumPoints - number of points to be rotated
Xorigin, Yorigin - center of rotation
Angle - angle of rotation about center
InArray - P2DType array containing points to rotate
OUTPUT
no value returned
OutArray - P2DType array holding rotated values
USAGE
D2ROTATE takes the two dimensional points given in InArray and
rotates them by the specified angle about Xorigin, Yorigin.
The results are returned in OutArray which can be the same as
InArray. A positive angle causes a clockwise rotation on the
screen, from the positive X axis to the positive Y axis.
Arrays should be passed by giving the element within the array
from where the action should take place. This allows the
programmer to store more than one item within the same array
or act on only a portion of the array.
SEE ALSO
D2SCALE, D2TRANSLATE
EXAMPLE
REM ROTATE A TRIANGLE ABOUT ONE CORNER
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
DIM TRIO(1 TO 3) AS P2DType
DIM TRI(1 TO 3) AS P2DType
DIM TRI2(1 TO 3) AS P2DType
TRIO(1).X = 0
TRIO(1).Y = 0
TRIO(2).X = -80
TRIO(2).Y = 60
TRIO(3).X = 80
TRIO(3).Y = 60
VMODE = VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
DUMMY=RES640
18
GOSUB DRWTRI
FOR I = 0 TO 360 STEP 2
D2ROTATE 3, 0, 0, I, TRIO(1).X, TRI(1).X
GOSUB DRWTRI
SDELAY 2
GOSUB ERTRI
NEXT I
GOSUB DRWTRI
WHILE INKEY$ = ""
WEND
VIDEOMODESET VMODE
END
DRWTRI:
D2TRANSLATE 3, 320, 240, TRI(1).X, TRI2(1).X
DRWLINE 1, 10, TRI2(1).X, TRI2(1).Y, TRI2(2).X, TRI2(2).Y
DRWLINE 1, 10, TRI2(2).X, TRI2(2).Y, TRI2(3).X, TRI2(3).Y
DRWLINE 1, 10, TRI2(3).X, TRI2(3).Y, TRI2(1).X, TRI2(1).Y
RETURN
ERTRI:
D2TRANSLATE 3, 320, 240, TRI(1).X, TRI2(1).X
DRWLINE 1, 0, TRI2(1).X, TRI2(1).Y, TRI2(2).X, TRI2(2).Y
DRWLINE 1, 0, TRI2(2).X, TRI2(2).Y, TRI2(3).X, TRI2(3).Y
DRWLINE 1, 0, TRI2(3).X, TRI2(3).Y, TRI2(1).X, TRI2(1).Y
RETURN
19
D2SCALE
PROTOTYPE
SUB D2SCALE (NumPoints%, ScaleX%, ScaleY%, InArray%,
OutArray%)
INPUT
NumPoints - number of points to scale
ScaleX - scale factor along X axis
ScaleY - scale factor along Y axis
InArray - P2DType array containing points to scale
OUTPUT
no value returned
OutArray - P2DType array holding scaled values
USAGE
D2SCALE multiplies each coordinate in the two dimensional
array InArray by the corresponding scale factor ScaleX or
ScaleY. The results are stored in OutArray which can be the
same as InArray. A scale factor of 256 (100 hex) is
considered 100 percent and results in no change. Therefore,
128 (80 hex) reduces values by one half and 512 (200 hex)
doubles values.
Arrays should be passed by giving the element within the array
from where the action should take place. This allows the
programmer to store more than one item within the same array
or act on only a portion of the array.
SEE ALSO
D2ROTATE, D2TRANSLATE
EXAMPLE
REM SCALE A TRIANGLE
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
DIM TRIO(1 TO 3) AS P2DType
DIM TRI(1 TO 3) AS P2DType
DIM TRI2(1 TO 3) AS P2DType
TRIO(1).X = 0
TRIO(1).Y = 0
TRIO(2).X = -80
TRIO(2).Y = 60
TRIO(3).X = 80
TRIO(3).Y = 60
VMODE = VIDEOMODEGET
20
IF WHICHVGA = 0 THEN STOP
DUMMY=RES640
GOSUB DRWTRI
FOR I = 256 TO 512 STEP 4
D2SCALE 3, I, I, TRIO(1).X, TRI(1).X
GOSUB DRWTRI
SDELAY 2
GOSUB ERTRI
NEXT I
FOR I = 512 TO 128 STEP -4
D2SCALE 3, I, I, TRIO(1).X, TRI(1).X
GOSUB DRWTRI
SDELAY 2
GOSUB ERTRI
NEXT I
FOR I = 128 TO 256 STEP 4
D2SCALE 3, I, I, TRIO(1).X, TRI(1).X
GOSUB DRWTRI
SDELAY 2
GOSUB ERTRI
NEXT I
GOSUB DRWTRI
WHILE INKEY$ = ""
WEND
VIDEOMODESET VMODE
END
DRWTRI:
D2TRANSLATE 3, 320, 240, TRI(1).X, TRI2(1).X
DRWLINE 1, 10, TRI2(1).X, TRI2(1).Y, TRI2(2).X, TRI2(2).Y
DRWLINE 1, 10, TRI2(2).X, TRI2(2).Y, TRI2(3).X, TRI2(3).Y
DRWLINE 1, 10, TRI2(3).X, TRI2(3).Y, TRI2(1).X, TRI2(1).Y
RETURN
ERTRI:
D2TRANSLATE 3, 320, 240, TRI(1).X, TRI2(1).X
DRWLINE 1, 0, TRI2(1).X, TRI2(1).Y, TRI2(2).X, TRI2(2).Y
DRWLINE 1, 0, TRI2(2).X, TRI2(2).Y, TRI2(3).X, TRI2(3).Y
DRWLINE 1, 0, TRI2(3).X, TRI2(3).Y, TRI2(1).X, TRI2(1).Y
RETURN
21
D2TRANSLATE
PROTOTYPE
SUB D2TRANSLATE (NumPoints%, TransX%, TransY%, InArray%,
OutArray%)
INPUT
NumPoints - number of points to be translated
TransX - distance to translate along X axis
TransY - distance to translate along Y axis
InArray - P2DType array containing points to translate
OUTPUT
no value returned
OutArray - P2DType array holding translated values
USAGE
D2TRANSLATE takes the two dimensional points given in InArray
and translates them by the specified number of pixels along
each axis. The results are returned in OutArray which can be
the same as InArray.
Arrays should be passed by giving the element within the array
from where the action should take place. This allows the
programmer to store more than one item within the same array
or act on only a portion of the array.
SEE ALSO
D2ROTATE, D2SCALE
EXAMPLE
REM TRANSLATE A TRIANGLE
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
DIM TRIO(1 TO 3) AS P2DType
DIM TRI(1 TO 3) AS P2DType
DIM TRI2(1 TO 3) AS P2DType
TRIO(1).X = 0
TRIO(1).Y = 0
TRIO(2).X = -80
TRIO(2).Y = 60
TRIO(3).X = 80
TRIO(3).Y = 60
VMODE = VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
DUMMY=RES640
GOSUB DRWTRI
22
FOR I = 0 TO 100 STEP 4
D2TRANSLATE 3, I, I, TRIO(1).X, TRI(1).X
GOSUB DRWTRI
SDELAY 2
GOSUB ERTRI
NEXT I
FOR I = 100 TO 0 STEP -4
D2TRANSLATE 3, I, I, TRIO(1).X, TRI(1).X
GOSUB DRWTRI
SDELAY 2
GOSUB ERTRI
NEXT I
GOSUB DRWTRI
WHILE INKEY$ = ""
WEND
VIDEOMODESET VMODE
END
DRWTRI:
D2TRANSLATE 3, 320, 240, TRI(1).X, TRI2(1).X
DRWLINE 1, 10, TRI2(1).X, TRI2(1).Y, TRI2(2).X, TRI2(2).Y
DRWLINE 1, 10, TRI2(2).X, TRI2(2).Y, TRI2(3).X, TRI2(3).Y
DRWLINE 1, 10, TRI2(3).X, TRI2(3).Y, TRI2(1).X, TRI2(1).Y
RETURN
ERTRI:
D2TRANSLATE 3, 320, 240, TRI(1).X, TRI2(1).X
DRWLINE 1, 0, TRI2(1).X, TRI2(1).Y, TRI2(2).X, TRI2(2).Y
DRWLINE 1, 0, TRI2(2).X, TRI2(2).Y, TRI2(3).X, TRI2(3).Y
DRWLINE 1, 0, TRI2(3).X, TRI2(3).Y, TRI2(1).X, TRI2(1).Y
RETURN
23
D3PROJECT
PROTOTYPE
FUNCTION D3PROJECT% (NumPoints%, ProjParams%, InArray%,
OutArray%)
INPUT
NumPoints - number of points to be projected
ProjParams - PROJType structure containing parameters used in
projection
EyeX, EyeY, EyeZ - 3D location of viewer
ScrD - distance from viewer to projection screen
Theta - angle from positive 3D X axis to viewing direction
Phi - angle from positive 3D Z axis to viewing direction
InArray - P3DType array containing points to project
OUTPUT
D3PROJECT returns 1 if successful, 0 if any one point failed.
OutArray - P2DType array holding projected values
USAGE
+Z axis
| /\
| / \
| ! \ * \
| !......X: /
| ! Phi / \/
| ! / :
| ! / :
| ! / :
| EyeX ! /ScrD :
| EyeY !/ :
| EyeZ *- - - -:- - - - -
| / ` :
| / ` :
| / ` :
| / ---` :
| /___----
| / Theta
|
|________________________________+Y axis
/
/
/
/
/
/
/
/
/
+X axis
24
D3PROJECT projects a specified number, NumPoints, of three
dimensional points starting at InArray into two dimensions
according to the parameters in ProjParams. The two
dimensional points are stored in OutArray. The location of
the viewer in this three dimensional space is given by EyeX,
EyeY, EyeZ in the ProjParams structure. The direction the
viewer is facing is specified with ScrD, Theta, Phi in the
ProjParams structure using spherical coordinates. A virtual
set of axes parallel to the true axes are placed at the
viewer's location. ScrD is the distance from the viewer to
the center of the projection screen, i.e. the currently
defined viewport on the monitor's screen. Theta is the angle
in the virtual X-Y plane from the virtual X axis to the
projection screen. Positive angles rotate clockwise in the X-
Y plane. Lastly, the angle of elevation above or below the
virtual X-Y plane is given by Phi. Positive angles direct
viewing above the plane; negative below.
If a point is projected to a location behind the viewer, i.e.
on the side of the viewer opposite the projection screen,
D3PROJECT returns a zero indicating one or more failed points.
The returned values of the X and Y for failed points will be -
32768 to make them easily identified.
Arrays should be passed by giving the element within the array
from where the action should take place. This allows the
programmer to store more than one item within the same array
or act on only a portion of the array.
SEE ALSO
D3ROTATE, D3TRANSLATE, D3SCALE, SETVIEW
EXAMPLE
REM DRAW A CUBE AT THE CENTER OF THE SCREEN
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
DIM CUBE(1 TO 8) AS P3DType
DIM PLOT(1 TO 8) AS P2DType
DIM PROJPARAMS AS PROJType
CUBE(1).X = 100 : CUBE(1).Y = -100 : CUBE(1).Z = 100
CUBE(2).X = 100 : CUBE(2).Y = -100 : CUBE(2).Z = -100
CUBE(3).X = 100 : CUBE(3).Y = 100 : CUBE(3).Z = -100
CUBE(4).X = 100 : CUBE(4).Y = 100 : CUBE(4).Z = 100
CUBE(5).X = -100 : CUBE(5).Y = -100 : CUBE(5).Z = 100
CUBE(6).X = -100 : CUBE(6).Y = -100 : CUBE(6).Z = -100
CUBE(7).X = -100 : CUBE(7).Y = 100 : CUBE(7).Z = -100
CUBE(8).X = -100 : CUBE(8).Y = 100 : CUBE(8).Z = 100
VMODE = VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
DUMMY=RES640
25
PROJPARAMS.EYEX = -1040
PROJPARAMS.EYEY = -600
PROJPARAMS.EYEZ = -1200
PROJPARAMS.SCRD = 1700
PROJPARAMS.THETA = 30
PROJPARAMS.PHI = 45
DUMMY = D3PROJECT(8,PROJPARAMS.EYEX,CUBE(1).X,PLOT(1).X)
GOSUB DRWCUBE
WHILE INKEY$ = ""
WEND
VIDEOMODESET VMODE
END
DRWCUBE:
FOR J=1 TO 3
DRWLINE 1, 10, PLOT(J).X, PLOT(J).Y, PLOT(J+1).X, PLOT(J+1).Y
NEXT J
DRWLINE 1, 10, PLOT(4).X, PLOT(4).Y, PLOT(1).X, PLOT(1).Y
FOR J=5 TO 7
DRWLINE 1, 10, PLOT(J).X, PLOT(J).Y, PLOT(J+1).X, PLOT(J+1).Y
NEXT J
DRWLINE 1, 10, PLOT(8).X, PLOT(8).Y, PLOT(5).X, PLOT(5).Y
FOR J=1 TO 4
DRWLINE 1, 10, PLOT(J).X, PLOT(J).Y, PLOT(J+4).X, PLOT(J+4).Y
NEXT J
RETURN
26
D3ROTATE
PROTOTYPE
SUB D3ROTATE (NumPoints%, X%, Y%, Z%, AngleZ%, AngleY%,
AngleX%, InArray%, OutArray%)
INPUT
NumPoints - number of points to be rotated
X, Y, Z - center of rotation
AngleZ - angle of rotation about the Z axis
AngleY - angle of rotation about the Y axis
AngleX - angle of rotation about the X axis
InArray - P3DType array containing points to rotate
OUTPUT
no value returned
OutArray - P3DType array holding rotated values
USAGE
D3ROTATE takes the three dimensional points given in InArray
and rotates them by the specified angles about Xorigin,
Yorigin, Zorigin. The results are returned in OutArray which
can be the same as InArray. A virtual set of axes are placed
at the origin of rotation and rotation takes place about these
axes. A positive angle causes a counter-clockwise rotation
from the positive X axis to the positive Y axis.
Arrays should be passed by giving the element within the array
from where the action should take place. This allows the
programmer to store more than one item within the same array
or act on only a portion of the array.
SEE ALSO
D3PROJECT, D3SCALE, D3TRANSLATE
EXAMPLE
REM ROTATE A CUBE AT THE CENTER OF THE SCREEN
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
DIM CUBE(1 TO 8) AS P3DType
DIM RCUBE(1 TO 8) AS P3DType
DIM PLOT(1 TO 8) AS P2DType
DIM PROJPARAMS AS PROJType
CUBE(1).X = 100 : CUBE(1).Y = -100 : CUBE(1).Z = 100
CUBE(2).X = 100 : CUBE(2).Y = -100 : CUBE(2).Z = -100
CUBE(3).X = 100 : CUBE(3).Y = 100 : CUBE(3).Z = -100
CUBE(4).X = 100 : CUBE(4).Y = 100 : CUBE(4).Z = 100
27
CUBE(5).X = -100 : CUBE(5).Y = -100 : CUBE(5).Z = 100
CUBE(6).X = -100 : CUBE(6).Y = -100 : CUBE(6).Z = -100
CUBE(7).X = -100 : CUBE(7).Y = 100 : CUBE(7).Z = -100
CUBE(8).X = -100 : CUBE(8).Y = 100 : CUBE(8).Z = 100
VMODE = VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
DUMMY=RES640
PROJPARAMS.EYEX = -1040
PROJPARAMS.EYEY = -600
PROJPARAMS.EYEZ = -1200
PROJPARAMS.SCRD = 1700
PROJPARAMS.THETA = 30
PROJPARAMS.PHI = 45
FOR I = 0 TO 360 STEP 5
D3ROTATE 8, 0, 0, 0, I, I, I, CUBE(1).X, RCUBE(1).X
DUMMY = D3PROJECT(8,PROJPARAMS.EYEX,RCUBE(1).X,PLOT(1).X)
GOSUB DRWCUBE
SDELAY 2
GOSUB DRWCUBE
NEXT I
WHILE INKEY$ = ""
WEND
VIDEOMODESET VMODE
END
DRWCUBE:
FOR J=1 TO 3
DRWLINE 2, 10, PLOT(J).X, PLOT(J).Y, PLOT(J+1).X, PLOT(J+1).Y
NEXT J
DRWLINE 2, 10, PLOT(4).X, PLOT(4).Y, PLOT(1).X, PLOT(1).Y
FOR J=5 TO 7
DRWLINE 2, 10, PLOT(J).X, PLOT(J).Y, PLOT(J+1).X, PLOT(J+1).Y
NEXT J
DRWLINE 2, 10, PLOT(8).X, PLOT(8).Y, PLOT(5).X, PLOT(5).Y
FOR J=1 TO 4
DRWLINE 2, 10, PLOT(J).X, PLOT(J).Y, PLOT(J+4).X, PLOT(J+4).Y
NEXT J
RETURN
28
D3SCALE
PROTOTYPE
SUB D3SCALE (NumPoints%, ScaleX%, ScaleY%, ScaleZ%, InArray%,
OutArray%)
INPUT
NumPoints - number of points to scale
ScaleX - scale factor along X axis
ScaleY - scale factor along Y axis
ScaleZ - scale factor along Z axis
InArray - P3DType array containing points to scale
OUTPUT
no value returned
OutArray - P3DType array holding scaled values
USAGE
D3SCALE multiplies each coordinate in the three dimensional
array InArray by the corresponding scale factor ScaleX, ScaleY
or ScaleZ. The results are stored in OutArray which can be
the same as InArray. A scale factor of 256 (100 hex) is
considered 100 percent and results in no change. Therefore,
128 (80 hex) reduces values by one half and 512 (200 hex)
doubles values.
Arrays should be passed by giving the element within the array
from where the action should take place. This allows the
programmer to store more than one item within the same array
or act on only a portion of the array.
SEE ALSO
D3PROJECT, D3ROTATE, D3TRANSLATE
EXAMPLE
REM SCALE A CUBE AT THE CENTER OF THE SCREEN
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
DIM CUBE(1 TO 8) AS P3DType
DIM SCUBE(1 TO 8) AS P3DType
DIM PLOT(1 TO 8) AS P2DType
DIM PROJPARAMS AS PROJType
CUBE(1).X = 100 : CUBE(1).Y = -100 : CUBE(1).Z = 100
CUBE(2).X = 100 : CUBE(2).Y = -100 : CUBE(2).Z = -100
CUBE(3).X = 100 : CUBE(3).Y = 100 : CUBE(3).Z = -100
CUBE(4).X = 100 : CUBE(4).Y = 100 : CUBE(4).Z = 100
CUBE(5).X = -100 : CUBE(5).Y = -100 : CUBE(5).Z = 100
29
CUBE(6).X = -100 : CUBE(6).Y = -100 : CUBE(6).Z = -100
CUBE(7).X = -100 : CUBE(7).Y = 100 : CUBE(7).Z = -100
CUBE(8).X = -100 : CUBE(8).Y = 100 : CUBE(8).Z = 100
VMODE = VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
DUMMY=RES640
PROJPARAMS.EYEX = -1040
PROJPARAMS.EYEY = -600
PROJPARAMS.EYEZ = -1200
PROJPARAMS.SCRD = 1700
PROJPARAMS.THETA = 30
PROJPARAMS.PHI = 45
FOR I = 256 TO 128 STEP -4
D3SCALE 8, I, I, I, CUBE(1).X, SCUBE(1).X
DUMMY = D3PROJECT(8,PROJPARAMS.EYEX,SCUBE(1).X,PLOT(1).X)
GOSUB DRWCUBE
SDELAY 2
GOSUB DRWCUBE
NEXT I
FOR I = 132 TO 256 STEP 4
D3SCALE 8, I, I, I, CUBE(1).X, SCUBE(1).X
DUMMY = D3PROJECT(8,PROJPARAMS.EYEX,SCUBE(1).X,PLOT(1).X)
GOSUB DRWCUBE
SDELAY 2
GOSUB DRWCUBE
NEXT I
WHILE INKEY$ = ""
WEND
VIDEOMODESET VMODE
END
DRWCUBE:
FOR J=1 TO 3
DRWLINE 2, 10, PLOT(J).X, PLOT(J).Y, PLOT(J+1).X, PLOT(J+1).Y
NEXT J
DRWLINE 2, 10, PLOT(4).X, PLOT(4).Y, PLOT(1).X, PLOT(1).Y
FOR J=5 TO 7
DRWLINE 2, 10, PLOT(J).X, PLOT(J).Y, PLOT(J+1).X, PLOT(J+1).Y
NEXT J
DRWLINE 2, 10, PLOT(8).X, PLOT(8).Y, PLOT(5).X, PLOT(5).Y
FOR J=1 TO 4
DRWLINE 2, 10, PLOT(J).X, PLOT(J).Y, PLOT(J+4).X, PLOT(J+4).Y
NEXT J
RETURN
30
D3TRANSLATE
PROTOTYPE
SUB D3TRANSLATE (NumPoints%, TransX%, TransY%, TransZ%,
InArray%, OutArray%)
INPUT
NumPoints - number of points to translate
TransX - distance to translate along X axis
TransY - distance to translate along Y axis
TransZ - distance to translate along Z axis
InArray - P3DType array containing points to translate
OUTPUT
no value returned
OutArray - P3DType array holding translated points
USAGE
D3TRANSLATE takes the three dimensional points given in
InArray and translates them by the specified number of pixels
along each axis. The results are returned in OutArray which
can be the same as InArray.
Arrays should be passed by giving the element within the array
from where the action should take place. This allows the
programmer to store more than one item within the same array
or act on only a portion of the array.
SEE ALSO
D3PROJECT, D3ROTATE, D3SCALE
EXAMPLE
REM TRANSLATE A CUBE NEAR THE CENTER OF THE SCREEN
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
DIM CUBE(1 TO 8) AS P3DType
DIM TCUBE(1 TO 8) AS P3DType
DIM PLOT(1 TO 8) AS P2DType
DIM PROJPARAMS AS PROJType
CUBE(1).X = 100 : CUBE(1).Y = -100 : CUBE(1).Z = 100
CUBE(2).X = 100 : CUBE(2).Y = -100 : CUBE(2).Z = -100
CUBE(3).X = 100 : CUBE(3).Y = 100 : CUBE(3).Z = -100
CUBE(4).X = 100 : CUBE(4).Y = 100 : CUBE(4).Z = 100
CUBE(5).X = -100 : CUBE(5).Y = -100 : CUBE(5).Z = 100
CUBE(6).X = -100 : CUBE(6).Y = -100 : CUBE(6).Z = -100
CUBE(7).X = -100 : CUBE(7).Y = 100 : CUBE(7).Z = -100
CUBE(8).X = -100 : CUBE(8).Y = 100 : CUBE(8).Z = 100
31
VMODE = VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
DUMMY=RES640
PROJPARAMS.EYEX = -1040
PROJPARAMS.EYEY = -600
PROJPARAMS.EYEZ = -1200
PROJPARAMS.SCRD = 1700
PROJPARAMS.THETA = 30
PROJPARAMS.PHI = 45
FOR I = 0 TO 100 STEP 2
D3TRANSLATE 8, I, I, I, CUBE(1).X, TCUBE(1).X
DUMMY = D3PROJECT(8,PROJPARAMS.EYEX,TCUBE(1).X,PLOT(1).X)
GOSUB DRWCUBE
SDELAY 2
GOSUB DRWCUBE
NEXT I
FOR I = 98 TO 0 STEP -2
D3TRANSLATE 8, I, I, I, CUBE(1).X, TCUBE(1).X
DUMMY = D3PROJECT(8,PROJPARAMS.EYEX,TCUBE(1).X,PLOT(1).X)
GOSUB DRWCUBE
SDELAY 2
GOSUB DRWCUBE
NEXT I
WHILE INKEY$ = ""
WEND
VIDEOMODESET VMODE
END
DRWCUBE:
FOR J=1 TO 3
DRWLINE 2, 10, PLOT(J).X, PLOT(J).Y, PLOT(J+1).X, PLOT(J+1).Y
NEXT J
DRWLINE 2, 10, PLOT(4).X, PLOT(4).Y, PLOT(1).X, PLOT(1).Y
FOR J=5 TO 7
DRWLINE 2, 10, PLOT(J).X, PLOT(J).Y, PLOT(J+1).X, PLOT(J+1).Y
NEXT J
DRWLINE 2, 10, PLOT(8).X, PLOT(8).Y, PLOT(5).X, PLOT(5).Y
FOR J=1 TO 4
DRWLINE 2, 10, PLOT(J).X, PLOT(J).Y, PLOT(J+4).X, PLOT(J+4).Y
NEXT J
RETURN
32
DRWBOX
PROTOTYPE
SUB DRWBOX (Mode%, Color%, X1%, Y1%, X2%, Y2%)
INPUT
Mode - pixel write mode (SET=1, XOR=2, OR=3, AND=4)
Color - index to color in current palette
X1, Y1 - location of top left corner
X2, Y2 - location of bottom right corner
OUTPUT
no value returned
USAGE
DRWBOX draws a rectangle of the color specified using Mode
with opposite vertices defined by (X1, Y1) and (X2, Y2). The
vertices given do not need to be exactly the top left and
bottom right. They only have to reference opposite sides of
the rectangle. Any portion of the rectangle that lies outside
of the currently defined viewport will not be drawn.
SEE ALSO
DRWFILLBOX, DRWLINE, SETVIEW
EXAMPLE
REM DRAWS A BOX AROUND THE WHOLE SCREEN
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
VMODE=VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
DUMMY=RES640
DRWBOX 1, 10, 0, 0, 639, 479
WHILE INKEY$ = ""
WEND
VIDEOMODESET VMODE
END
33
DRWCIRCLE
PROTOTYPE
SUB DRWCIRCLE (Mode%, Color%, Xcenter%, Ycenter%, Radius%)
INPUT
Mode - pixel write mode (SET=1, XOR=2, OR=3, AND=4)
Color - index to color in current palette
Xcenter, Ycenter - location of center of circle
Radius - distance from center to edge of circle
OUTPUT
no value returned
USAGE
DRWCIRCLE draws a circle of the specified color using Mode
with the center located at (Xcenter, Ycenter) and a radius of
Radius. All values of Xcenter, Ycenter and Radius are valid.
Any portion of the circle that lies outside of the currently
defined viewport will not be drawn.
SEE ALSO
DRWELLIPSE, DRWFILLCIRCLE, SETVIEW
EXAMPLE
REM DRAWS A CIRCLE AT THE CENTER OF THE SCREEN
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
VMODE=VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
DUMMY=RES640
DRWCIRCLE 1, 10, 320, 240, 200
WHILE INKEY$ = ""
WEND
VIDEOMODESET VMODE
END
34
DRWELLIPSE
PROTOTYPE
SUB DRWELLIPSE (Mode%, Color%, Xcenter%, Ycenter%, RadiusX%,
RadiusY%)
INPUT
Mode - pixel write mode (SET=1, XOR=2, OR=3, AND=4)
Color - index to color in current palette
Xcenter, Ycenter - location of center of ellipse
RadiusX - radius parallel to X axis
RadiusY - radius parallel to Y axis
OUTPUT
no value returned
USAGE
DRWELLIPSE draws an ellipse of the specified color using Mode
with the center defined by (Xcenter, Ycenter). The radius in
the horizontal direction is RaduisX and the radius in the
vertical direction is RadiusY. All values of Xcenter,
Ycenter, RadiusX and RadiusY are valid. Any portion of the
ellipse that lies outside of the currently defined viewport
will not be drawn.
SEE ALSO
DRWCIRCLE, DRWFILLELLIPSE, SETVIEW
EXAMPLE
REM DRAWS AN ELLIPSE AT THE CENTER OF THE SCREEN
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
VMODE=VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
DUMMY=RES640
DRWELLIPSE 1, 10, 320, 240, 318, 238
WHILE INKEY$ = ""
WEND
VIDEOMODESET VMODE
END
35
DRWFILLBOX
PROTOTYPE
SUB DRWFILLBOX (Mode%, Color%, X1%, Y1%, X2%, Y2%)
INPUT
Mode - pixel write mode (SET=1, XOR=2, OR=3, AND=4)
Color - index to color in current palette
X1, Y1 - location of top left corner
X2, Y2 - location of bottom right corner
OUTPUT
no value returned
USAGE
DRWBOX draws a filled rectangle of the color specified using
Mode with opposite vertices defined by (X1, Y1) and (X2, Y2).
The vertices given do not need to be exactly the top left and
bottom right. They only have to reference opposite sides of
the rectangle. Any portion of the rectangle that lies outside
of the currently defined viewport will not be drawn.
SEE ALSO
DRWBOX, DRWLINE, SETVIEW
EXAMPLE
REM DRAWS A FILLED BOX
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
VMODE = VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
DUMMY = RES640
DRWFILLBOX 1, 10, 100, 100, 200, 200
WHILE INKEY$ = ""
WEND
VIDEOMODESET VMODE
END
36
DRWFILLCIRCLE
PROTOTYPE
SUB DRWFILLCIRCLE (Mode%, Color%, Xcenter%, Ycenter%, Radius%)
INPUT
Mode - pixel write mode (SET=1, XOR=2, OR=3, AND=4)
Color - index to color in current palette
Xcenter, Ycenter - location of center of circle
Radius - distance from center to edge of circle
OUTPUT
no value returned
USAGE
DRWCIRCLE draws a filled circle of the specified color using
Mode with the center located at (Xcenter, Ycenter) and a
radius of Radius. All values of Xcenter, Ycenter and Radius
are valid. Any portion of the circle that lies outside of the
currently defined viewport will not be drawn.
SEE ALSO
DRWCIRCLE, SETVIEW
EXAMPLE
REM DRAWS A FILLED CIRCLE
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
VMODE = VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
DUMMY = RES640
DRWFILLCIRCLE 1, 10, 320, 240, 50
WHILE INKEY$ = ""
WEND
VIDEOMODESET VMODE
END
37
DRWFILLELLIPSE
PROTOTYPE
SUB DRWFILLELLIPSE (Mode%, Color%, Xcenter%, Ycenter%,
RadiusX%, RadiusY%)
INPUT
Mode - pixel write mode (SET=1, XOR=2, OR=3, AND=4)
Color - index to color in current palette
Xcenter, Ycenter - location of center of ellipse
RadiusX - radius parallel to X axis
RadiusY - radius parallel to Y axis
OUTPUT
no value returned
USAGE
DRWELLIPSE draws a filled ellipse of the specified color using
Mode with the center defined by (Xcenter, Ycenter). The
radius in the horizontal direction is RaduisX and the radius
in the vertical direction is RadiusY. All values of Xcenter,
Ycenter, RadiusX and RadiusY are valid. Any portion of the
ellipse that lies outside of the currently defined viewport
will not be drawn.
SEE ALSO
DRWELLIPSE, SETVIEW
EXAMPLE
REM DRAWS A FILLED ELLIPSE
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
VMODE = VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
DUMMY = RES640
DRWFILLELLIPSE 1, 10, 320, 240, 118, 50
WHILE INKEY$ = ""
WEND
VIDEOMODESET VMODE
END
38
DRWLINE
PROTOTYPE
SUB DRWLINE (Mode%, Color%, X1%, Y1%, X2%, Y2%)
INPUT
Mode - pixel write mode (SET=1, XOR=2, OR=3, AND=4)
Color - index to color in current palette
X1, Y1 - location of one endpoint of line
X2, Y2 - location of other endpoint of line
OUTPUT
no value returned
USAGE
DRWLINE draws a line of the specified color using Mode with
endpoints located at (X1, Y1) and (X2, Y2). All values of X1,
Y1, X2 and Y2 are valid. Any portion of the line that lies
outside of the currently defined viewport will not be drawn.
SEE ALSO
DRWBOX, SETVIEW
EXAMPLE
REM DRAWS A LINE FROM 0,0 TO THE CENTER OF THE SCREEN
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
VMODE=VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
DUMMY=RES640
DRWLINE 1, 10, 0, 0, 320, 240
WHILE INKEY$ = ""
WEND
VIDEOMODESET VMODE
END
39
DRWPOINT
PROTOTYPE
SUB DRWPOINT (Mode%, Color%, X%, Y%)
INPUT
Mode - pixel write mode (SET=1, XOR=2, OR=3, AND=4)
Color - index to color in current palette
X, Y - location of pixel to write
OUTPUT
no value returned
USAGE
DRWPOINT draws a single point of the specified color using
Mode at (X, Y). All values of X and Y are valid. If the
point (X, Y) lies outside of the currently defined viewport,
no drawing will take place.
SEE ALSO
GETPOINT, SETVIEW
EXAMPLE
REM DRAWS A POINT AT THE CENTER OF THE SCREEN
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
VMODE=VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
DUMMY=RES640
DRWPOINT 1, 10, 320, 240
WHILE INKEY$ = ""
WEND
VIDEOMODESET VMODE
END
40
DRWSTRING
PROTOTYPE
SUB DRWSTRING (Mode%, FColor%, BColor%, Strng$, X%, Y%)
INPUT
Mode - pixel write mode (no action=0, SET=1, XOR=2, OR=3,
AND=4)
FColor - foreground index to color in current palette
BColor - background index to color in current palette
Strng$ - string of ASCII characters to be drawn
X, Y - location of upper, left corner of block
OUTPUT
no value returned
USAGE
DRWSTRING takes the ASCII characters contained in Strng$ and
creates a graphics block similar to the blocks used by Blkget
and Blkput and places this block on the screen at the
specified coordinates. The characters are drawn with color
FColor using the current font and the background is color
BColor. When mode 0, no action, is used, the graphics block
is created in memory retrievable by GETLASTSTRING, but no text
is actually drawn on the screen. (Note: the system font is
automatically installed when WHICHVGA is called.)
SEE ALSO
FONTSET, FONTGETINFO, FONTSYSTEM, DRWSTRINGDN, DRWSTRINGLT,
DRWSTRINGRT, GETLASTSTRING
EXAMPLE
REM DRAWS SOME NORMAL TEXT AT THE CENTER OF THE SCREEN
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
VMODE=VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
DUMMY=RES640
A$ = "HELLO WORLD"
DRWSTRING 1, 10, 0, A$, 320, 240
WHILE INKEY$ = ""
WEND
VIDEOMODESET VMODE
END
41
DRWSTRINGDN
PROTOTYPE
SUB DRWSTRINGDN (Mode%, FColor%, BColor%, Strng$, X%, Y%)
INPUT
Mode - pixel write mode (no action=0, SET=1, XOR=2, OR=3,
AND=4)
FColor - foreground index to color in current palette
BColor - background index to color in current palette
Strng$ - string of ASCII characters to be drawn
X, Y - location of lower, right corner of block
OUTPUT
no value returned
USAGE
DRWSTRINGDN takes the ASCII characters contained in Strng$ and
creates a graphics block similar to the blocks used by Blkget
and Blkput. The characters are drawn with color FColor using
the current font and the background is color BColor. When
mode 0, no action, is used, the graphics block is created in
memory retrievable by GETLASTSTRING, but no text is actually
drawn on the screen. (Note: the system font is automatically
installed when WHICHVGA is called.) The text is drawn upside
down with X, Y specifying the lower, right corner. This
corner corresponds to the upper, left corner when the text is
oriented upright.
SEE ALSO
FONTSET, FONTGETINFO, FONTSYSTEM, DRWSTRING, DRWSTRINGLT,
DRWSTRINGRT, GETLASTSTRING
EXAMPLE
REM DRAWS SOME UP-SIDE-DOWN TEXT AT THE CENTER OF THE SCREEN
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
VMODE=VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
DUMMY=RES640
A$ = "HELLO WORLD"
DRWSTRINGDN 1, 10, 0, A$, 320, 240
WHILE INKEY$ = ""
WEND
VIDEOMODESET VMODE
END
42
DRWSTRINGLT
PROTOTYPE
SUB DRWSTRINGLT (Mode%, FColor%, BColor%, Strng$, X%, Y%)
INPUT
Mode - pixel write mode (no action=0, SET=1, XOR=2, OR=3,
AND=4)
FColor - foreground index to color in current palette
BColor - background index to color in current palette
Strng$ - string of ASCII characters to be drawn
X, Y - location of lower, left corner of block
OUTPUT
no value returned
USAGE
DRWSTRINGLT takes the ASCII characters contained in Strng$ and
creates a graphics block similar to the blocks used by Blkget
and Blkput. The characters are drawn with color FColor using
the current font and the background is color BColor. When
mode 0, no action, is used, the graphics block is created in
memory retrievable by GETLASTSTRING, but no text is actually
drawn on the screen. (Note: the system font is automatically
installed when WHICHVGA is called.) The text block is rotated
90 to the left with X, Y specifying the lower, left corner.
This corner corresponds to the upper, left corner when the
text is oriented upright.
SEE ALSO
FONTSET, FONTGETINFO, FONTSYSTEM, DRWSTRING, DRWSTRINGDN,
DRWSTRINGRT, GETLASTSTRING
EXAMPLE
REM DRAWS SOME TEXT ROTATED BY 90 DEGREES TO THE LEFT AT THE
REM CENTER OF THE SCREEN
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
VMODE=VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
DUMMY=RES640
A$ = "HELLO WORLD"
DRWSTRINGLT 1, 10, 0, A$, 320, 240
WHILE INKEY$ = ""
WEND
VIDEOMODESET VMODE
43
END
44
DRWSTRINGRT
PROTOTYPE
SUB DRWSTRINGRT (Mode%, FColor%, BColor%, Strng$, X%, Y%)
INPUT
Mode - pixel write mode (no action=0, SET=1, XOR=2, OR=3,
AND=4)
FColor - foreground index to color in current palette
BColor - background index to color in current palette
Strng$ - string of ASCII characters to be drawn
X, Y - location of upper, right corner of block
OUTPUT
no value returned
USAGE
DRWSTRINGRT takes the ASCII characters contained in Strng$ and
creates a graphics block similar to the blocks used by Blkget
and Blkput. The characters are drawn with color FColor using
the current font and the background is color BColor. When
mode 0, no action, is used, the graphics block is created in
memory retrievable by GETLASTSTRING, but no text is actually
drawn on the screen. (Note: the system font is automatically
installed when WHICHVGA is called.) The text block is rotated
90 to the right with X, Y specifying the upper, right corner.
This corner corresponds to the upper, left corner if the text
is oriented upright.
SEE ALSO
FONTSET, FONTGETINFO, FONTSYSTEM, DRWSTRING, DRWSTRINGDN,
DRWSTRINGLT, GETLASTSTRING
EXAMPLE
REM DRAWS SOME TEXT ROTATED BY 90 DEGREES TO THE RIGHT AT THE
REM CENTER OF THE SCREEN
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
VMODE=VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
DUMMY=RES640
A$ = "HELLO WORLD"
DRWSTRINGRT 1, 10, 0, A$, 320, 240
WHILE INKEY$ = ""
WEND
VIDEOMODESET VMODE
45
END
46
FILLAREA
PROTOTYPE
SUB FILLAREA (XSeed%, YSeed%, BorderColor%, FillColor%)
INPUT
XSeed, YSeed - seed location to start fill
BorderColor - index to color in current palette at which
filling stops
FillColor - index to color in current palette to fill within
the border
OUTPUT
no value returned
USAGE
FILLAREA fills a region with a new color specified by
FillColor. The region is defined by any line or curve of the
color BorderColor or by the edge of the viewport. All
graphics within the region are lost and covered with the
FillColor. The border is not effected.
SEE ALSO
DRWFILLBOX, DRWFILLCIRCLE, DRWFILLELLIPSE, FILLCOLOR,
FILLPAGE, FILLSCREEN, FILLVIEW, SETVIEW
EXAMPLE
REM FILLS A BOX WITH A COLOR
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
VMODE=VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
DUMMY=RES640
DRWBOX 1, 10, 0, 0, 100, 100
FILLAREA 1, 1, 10, 7
WHILE INKEY$ = ""
WEND
VIDEOMODESET VMODE
END
47
FILLCOLOR
PROTOTYPE
SUB FILLCOLOR (XSeed%, YSeed%, OldColor%, NewColor%)
INPUT
XSeed, YSeed - seed location to start fill
OldColor - index to color in current palette to change
NewColor - index to color in current palette to replace
OldColor
OUTPUT
no value returned
USAGE
FILLCOLOR replaces every existence of OldColor with NewColor
within a region. The region is defined as any pixel of
OldColor which has a path of pixels of OldColor or NewColor
with sides touching back to the seed point, (XSeed, YSeed).
Therefore, only pixels of OldColor are modified and no other
information is changed.
SEE ALSO
DRWFILLBOX, DRWFILLCIRCLE, DRWFILLELLIPSE, FILLAREA, FILLPAGE,
FILLSCREEN, FILLVIEW, SETVIEW
EXAMPLE
REM REPLACES THE BLACK COLOR WITH A NEW COLOR
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
VMODE=VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
DUMMY=RES640
DRWBOX 1, 10, 0, 0, 100, 100
DRWBOX 1, 12, 20, 20, 80, 80
FILLCOLOR 1, 1, 0, 7
WHILE INKEY$ = ""
WEND
VIDEOMODESET VMODE
END
48
FILLPAGE
PROTOTYPE
SUB FILLPAGE (Color%)
INPUT
Color - index to color in current palette
OUTPUT
no value returned
USAGE
FILLPAGE clears the currently active page with the specified
color. All information on the page is lost. (Note, a faster
method to clear the page is to call any of the 'RES###'
functions. These reset the graphics screen and automatically
clear it to color index zero as well as reset the default
palette.)
SEE ALSO
DRWFILLBOX, DRWFILLCIRCLE, DRWFILLELLIPSE, FILLAREA,
FILLCOLOR, FILLSCREEN, FILLVIEW
EXAMPLE
REM FILLS THE CURRENT VIDEO PAGE WITH A COLOR
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
VMODE=VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
DUMMY=RES640
DUMMY=PAGEACTIVE(0)
FILLPAGE 10
WHILE INKEY$ = ""
WEND
VIDEOMODESET VMODE
END
49
FILLSCREEN
PROTOTYPE
SUB FILLSCREEN (Color%)
INPUT
Color - index to color in current palette
OUTPUT
no value returned
USAGE
FILLSCREEN clears the entire screen with the specified color.
All information on the screen is lost. (Note, a faster method
to clear the screen is to call any of the 'RES###' functions.
These reset the graphics screen and automatically clear it to
color index zero as well as reset the default palette.)
SEE ALSO
DRWFILLBOX, DRWFILLCIRCLE, DRWFILLELLIPSE, FILLAREA,
FILLCOLOR, FILLPAGE, FILLVIEW
EXAMPLE
REM FILLS THE SCREEN WITH A COLOR
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
VMODE=VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
DUMMY=RES640
FILLSCREEN 10
WHILE INKEY$ = ""
WEND
VIDEOMODESET VMODE
END
50
FILLVIEW
PROTOTYPE
SUB FILLVIEW (Color%)
INPUT
Color - index to color in current palette
OUTPUT
no value returned
USAGE
FILLVIEW fills the currently defined viewport with the
specified color. All information in the viewport is lost.
SEE ALSO
DRWFILLBOX, DRWFILLCIRCLE, DRWFILLELLIPSE, FILLAREA,
FILLCOLOR, FILLPAGE, FILLSCREEN, SETVIEW
EXAMPLE
REM FILLS THE VIEWPORT WITH A COLOR
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
VMODE=VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
DUMMY=RES640
SETVIEW 100, 100, 539, 379
FILLVIEW 10
WHILE INKEY$ = ""
WEND
VIDEOMODESET VMODE
END
51
FONTGETINFO
PROTOTYPE
SUB FONTGETINFO (Width%, Height%)
INPUT
no input parameters
OUTPUT
no value returned
Width - width in pixels of current font
Height - height in pixels of current font
USAGE
FONTGETINFO returns in Width and Height the dimensions of the
currently loaded font.
SEE ALSO
FONTSET, FONTSYSTEM
EXAMPLE
REM GET INFO ON THE SYSTEM FONT
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
VMODE=VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
DUMMY=RES640
FONTGETINFO WDTH, HGTH
A$ = "SYSTEM FONT WIDTH =" + STR$(WDTH)
B$ = "SYSTEM FONT HEIGHT =" + STR$(HGTH)
DRWSTRING 1, 7, 0, A$, 0, 0
DRWSTRING 1, 7, 0, B$, 0, 20
WHILE INKEY$ = ""
WEND
VIDEOMODESET VMODE
END
52
FONTSET
PROTOTYPE
SUB FONTSET (Font$)
INPUT
Font$ - string * 4098 containing font data
OUTPUT
no value returned
USAGE
FONTSET loads the current font with the data in Font$. The
string must have at least 4098 members. The first byte of
Font$ holds the font width (1 to 8) and the second byte holds
the font height (1 to 16). The remaining 4096 bytes are the
character raster data, 16 bytes per character.
SEE ALSO
FONTGETINFO, FONTSYSTEM
EXAMPLE
See FONTSYSTEM
53
FONTSYSTEM
PROTOTYPE
SUB FONTSYSTEM ()
INPUT
no input parameters
OUTPUT
no value returned
USAGE
FONTSYSTEM sets the current font to the standard system font.
This font is automatically set when WHICHVGA is called.
SEE ALSO
WHICHVGA, FONTGETINFO, FONTSET
EXAMPLE
REM LOAD A FONT FROM DISK AND ENABLE IT
REM THEN GO BACK TO THE SYSTEM FONT
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
DIM NEWFONT AS STRING * 4098
VMODE = VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
DUMMY=RES640
OPEN "DRAGON.FNT" FOR BINARY AS #1
GET #1, , NEWFONT
CLOSE #1
FONTSET NEWFONT
DRWSTRING 1, 7, 0, "The Dragon Font!", 0, 0
FONTSYSTEM
DRWSTRING 1, 7, 0, "The System Font!", 0, 20
WHILE INKEY$ = ""
WEND
VIDEOMODESET VMODE
END
54
GETARCCOS
PROTOTYPE
FUNCTION GETARCCOS% (Value&)
INPUT
Value - number between -1 and +1 scaled up by 13 bits (8192)
OUTPUT
GETARCCOS returns the arc cosine of Value in degrees.
USAGE
GETARCCOS returns the arc cosine in degrees for the given
value. The return will be between 0 and 180 degrees. Value
should be between -8192 and +8192 representing the range -1 to
+1. Input values outside this range are invalid and GETARCCOS
will return -32768. Floating point values are ignored. This
function uses an integer lookup table stored within the
library in order to produce the fastest possible results. No
floating point arithmetic is used. The scale factor of 13
bits (8192) was chosen because this is the number of bits at
which every change of one degree gives a change in the value
of the sine (or cosine) function.
SEE ALSO
GETARCSIN, GETARCTAN, GETCOS, GETSIN, GETTAN
EXAMPLE
REM SHOW GETARCCOS
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
VMODE = VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
DUMMY=RES640
DRWBOX 1, 10, 0, 0, 639, 479
DRWLINE 1, 10, 0, 240, 639, 240
DRWLINE 1, 10, 320, 0, 320, 479
DEG2RAD! = 4 * ATN(1) / 180
FOR I = -8192 TO 8192 STEP 16
Y1& = GETARCCOS(I)
DRWPOINT 1, 12, 320 + Y1& * 3, 240 - I / 34
NEXT I
WHILE INKEY$ = ""
WEND
VIDEOMODESET VMODE
END
55
GETARCSIN
PROTOTYPE
FUNCTION GETARCSIN (Value&)
INPUT
Value - number between -1 and +1 scaled up by 13 bits (8192)
OUTPUT
GETARCSIN returns the arc sine of Value in degrees.
USAGE
GETARCSIN returns the arc sine in degrees for the given value.
The return will be between -90 and +90 degrees. Value should
be between -8192 and +8192 representing the range -1 to +1.
Input values outside this range are invalid and GETARCSIN will
return -32768. Floating point values are ignored. This
function uses an integer lookup table stored within the
library in order to produce the fastest possible results. No
floating point arithmetic is used. The scale factor of 13
bits (8192) was chosen because this is the number of bits at
which every change of one degree gives a change in the value
of the sine (or cosine) function.
SEE ALSO
GETARCCOS, GETARCTAN, GETCOS, GETSIN, GETTAN
EXAMPLE
REM SHOW GETARCSIN
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
VMODE = VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
DUMMY=RES640
DRWBOX 1, 10, 0, 0, 639, 479
DRWLINE 1, 10, 0, 240, 639, 240
DRWLINE 1, 10, 320, 0, 320, 479
DEG2RAD! = 4 * ATN(1) / 180
FOR I = -8192 TO 8192 STEP 16
Y1& = GETARCSIN(I)
DRWPOINT 1, 12, 320 + Y1& * 3, 240 - I / 34
NEXT I
WHILE INKEY$ = ""
WEND
VIDEOMODESET VMODE
END
56
GETARCTAN
PROTOTYPE
FUNCTION GETARCTAN (Value&)
INPUT
Value - long integer representing a decimal scaled up by 13
bits (8192)
OUTPUT
GETARCTAN returns the arc tangent of Value in degrees.
USAGE
GETARCTAN returns the arc cosine in degrees for the given
value. The return will be between -89 and +89 degrees. Value
can be any long integer. It is interpreted as a decimal
scaled up by 8192 (13 bits). Floating point values are
ignored. This function uses an integer lookup table stored
within the library in order to produce the fastest possible
results. No floating point arithmetic is used. The scale
factor of 13 bits (8192) was chosen because this is the number
of bits at which every change of one degree gives a change in
the value of the sine (or cosine) function.
SEE ALSO
GETARCCOS, GETARCSIN, GETCOS, GETSIN, GETTAN
EXAMPLE
REM SHOW GETARCTAN
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
VMODE = VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
DUMMY=RES640
DRWBOX 1, 10, 0, 0, 639, 479
DRWLINE 1, 10, 0, 240, 639, 240
DRWLINE 1, 10, 320, 0, 320, 479
DEG2RAD! = 4 * ATN(1) / 180
FOR I = -8192 TO 8192 STEP 16
Y1& = GETARCTAN(I)
Y2& = ATN(I / 8192) / DEG2RAD!
DRWPOINT 1, 12, 320 + Y1& * 6, 240 - I / 34
DRWPOINT 1, 15, 320 + Y2& * 6, 240 - I / 34
NEXT I
WHILE INKEY$ = ""
WEND
VIDEOMODESET VMODE
57
END
58
GETCOS
PROTOTYPE
FUNCTION GETCOS& (Angle&)
INPUT
Angle - angle in degrees
OUTPUT
GETCOS returns the cosine of Angle scaled up by 13 bits
(8192).
USAGE
GETCOS returns the cosine of the specified angle. Angle can
be any long value; floating point values are ignored. The
return value has been multiplied by 8192. This function uses
an integer lookup table stored within the library in order to
produce the fastest possible results. No floating point
arithmetic is used. The scale factor of 13 bits (8192) was
chosen because this is the number of bits at which every
change of one degree gives a change in the value of the sine
(or cosine) function.
SEE ALSO
GETARCCOS, GETARCSIN, GETARCTAN, GETSIN, GETTAN
EXAMPLE
REM SHOW GETCOS
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
VMODE = VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
DUMMY=RES640
DRWBOX 1, 10, 0, 0, 639, 479
DRWLINE 1, 10, 0, 240, 639, 240
DRWLINE 1, 10, 320, 0, 320, 479
DEG2RAD! = 4 * ATN(1) / 180
FOR I = -360 TO 360
Y1& = GETCOS(I)
Y1& = Y1& * 240 / 8192
Y2& = 240 * COS(I * DEG2RAD!)
DRWPOINT 1, 15, 320 + I, 240 - Y1&
DRWPOINT 1, 12, 320 + I, 240 - Y2&
NEXT I
WHILE INKEY$ = ""
WEND
VIDEOMODESET VMODE
59
END
60
GETLASTSTRING
PROTOTYPE
SUB GETLASTSTRING (GfxBlk%)
INPUT
no input parameters
OUTPUT
no value returned
GfxBlk - integer destination array holding bitmap of text
block
USAGE
GETLASTSTRING returns the text drawn on the screen by the last
called DRWSTRING function. The text is returned in GfxBlk
which may be used with BLKPUT or the sprite functions. The
text in GfxBlk is oriented in the same manner as the last
called DRWSTRING function. The intended use is to call the
DRWSTRING function using mode 0 which does not actually draw
text on the screen. GETLASTSTRING should be called
immediately after the DRWSTRING function to prevent possible
loss of data caused by other functions.
GfxBlk must be dimensioned as a short integer array with a
size in integers equal to
[(fontwidth*stringlength)*(fontheight)] / 2+3.
The font's dimensions can be obtained by calling FONTGETINFO
and the string's length can be obtained using Basic's LEN
function. Note, however, that GfxBlk can be quite large. If
the size of GfxBlk is insufficient, GETLASTSTRING will
overwrite any data in memory contained beyond GfxBlk and may
possibly cause the system to crash.
Arrays should be passed by giving the element within the array
from where the action should take place. This allows the
programmer to store more than one item within the same array
or act on only a portion of the array.
SEE ALSO
BLKPUT, DRWSTRING, DRWSTRINGDN, DRWSTRINGLT, DRWSTRINGRT,
FONTGETINFO
EXAMPLE
REM USES GETLASTSTRING TO DRAW SOME TEXT AT THE CENTER OF THE
SCREEN
61
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
VMODE=VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
DUMMY=RES640
A$ = "HELLO WORLD"
DRWSTRING 0, 10, 0, A$, 0, 0
FONTGETINFO W, H
L = LEN(A$)
BLKSIZE = ( (W*L)*H )\2 + 3
DIM BLK(0 TO BLKSIZE)
GETLASTSTRING BLK(0)
BLKPUT 1, 320, 240, BLK(0)
WHILE INKEY$ = ""
WEND
VIDEOMODESET VMODE
END
62
GETMAXX
PROTOTYPE
FUNCTION GETMAXX% ()
INPUT
no input parameters
OUTPUT
GETMAXX returns the current horizontal resolution of the
screen.
USAGE
GETMAXX returns the horizontal resolution of the screen in the
current mode. This function should only be called if one of
the RES### functions has been previously called. Otherwise,
the value returned is meaningless.
SEE ALSO
GETMAXY
EXAMPLE
REM SHOW GETMAXX
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
VMODE = VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
DUMMY=RES640
X$ = "MAX X SCREEN VALUE IS:" + STR$(GETMAXX)
DRWSTRING 1, 7, 0, X$, 0, 0
SETVIEW 0, 0, 400, 479
X$ = "MAX X SCREEN VALUE IS STILL:" + STR$(GETMAXX)
DRWSTRING 1, 7, 0, X$, 0, 20
WHILE INKEY$ = ""
WEND
VIDEOMODESET VMODE
END
63
GETMAXY
PROTOTYPE
FUNCTION GETMAXY% ()
INPUT
no input parameters
OUTPUT
GETMAXY returns the current vertical resolution of the screen.
USAGE
GETMAXY returns the vertical resolution of the screen in the
current mode. This function should only be called if one of
the RES### functions has been previously called. Otherwise,
the value returned is meaningless.
SEE ALSO
GETMAXX
EXAMPLE
REM SHOW GETMAXY
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
VMODE = VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
DUMMY=RES640
Y$ = "MAX Y SCREEN VALUE IS:" + STR$(GETMAXY)
DRWSTRING 1, 7, 0, Y$, 0, 0
SETVIEW 0, 0, 639, 200
Y$ = "MAX Y SCREEN VALUE IS STILL:" + STR$(GETMAXY)
DRWSTRING 1, 7, 0, Y$, 0, 20
WHILE INKEY$ = ""
WEND
VIDEOMODESET VMODE
END
64
GETPOINT
PROTOTYPE
FUNCTION GETPOINT% (X%, Y%)
INPUT
X, Y - location of pixel to read
OUTPUT
GETPOINT returns the color index of pixel at X, Y.
USAGE
GETPOINT returns the value of the pixel at location X, Y.
This value is a color index into the current palette.
SEE ALSO
DRWPOINT
EXAMPLE
REM DRAW A POINT AND CHECK TO MAKE SURE IT IS THERE
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
IF WHICHVGA = 0 THEN STOP
IF WHICHMEM < 512 THEN STOP
VMODE = VIDEOMODEGET
DUMMY=RES640
DRWPOINT 1, 10, 320, 240
POINTVALUE = GETPOINT(320, 240)
A$ = "THE POINT VALUE IS:" + STR$(POINTVALUE)
DRWSTRING 1, 7, 0, A$, 0, 0
WHILE INKEY$ = ""
WEND
VIDEOMODESET VMODE
END
65
GETSIN
PROTOTYPE
FUNCTION GETSIN& (Angle&)
INPUT
Angle - angle in degrees
OUTPUT
GETSIN returns the sine of Angle scaled up by 13 bits (8192).
USAGE
GETSIN returns the sine of the specified angle. Angle can be
any long value; floating point values are ignored. The return
value has been multiplied by 8192. This function uses an
integer lookup table stored within the library in order to
produce the fastest possible results. No floating point
arithmetic is used. The scale factor of 13 bits (8192) was
chosen because this is the number of bits at which every
change of one degree gives a change in the value of the sine
(or cosine) function.
SEE ALSO
GETARCCOS, GETARCSIN, GETARCTAN, GETCOS, GETTAN
EXAMPLE
REM SHOW GETSIN
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
VMODE = VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
DUMMY=RES640
DRWBOX 1, 10, 0, 0, 639, 479
DRWLINE 1, 10, 0, 240, 639, 240
DRWLINE 1, 10, 320, 0, 320, 479
DEG2RAD! = 4 * ATN(1) / 180
FOR I = -360 TO 360
Y1& = GETSIN(I)
Y1& = Y1& * 240 / 8192
Y2& = 240 * SIN(I * DEG2RAD!)
DRWPOINT 1, 15, 320 + I, 240 - Y1&
DRWPOINT 1, 12, 320 + I, 240 - Y2&
NEXT I
WHILE INKEY$ = ""
WEND
VIDEOMODESET VMODE
END
66
GETTAN
PROTOTYPE
FUNCTION GETTAN& (Angle%)
INPUT
Angle - angle in degrees
OUTPUT
GETTAN returns the tangent of Angle scaled up by 13 bits
(8192).
USAGE
GETTAN returns the tangent of the specified angle. Angle can
be any long value except +(90+n*180), where n is an integer.
Floating point values are ignored. The return value has been
multiplied by 8192. If an invalid angle is given, the GETTAN
will return &H80000000 (-2147483648). This function uses an
integer lookup table stored within the library in order to
produce the fastest possible results. No floating point
arithmetic is used. The scale factor of 13 bits (8192) was
chosen because this is the number of bits at which every
change of one degree gives a change in the value of the sine
(or cosine) function.
SEE ALSO
GETARCCOS, GETARCSIN, GETARCTAN, GETCOS, GETSIN
EXAMPLE
REM SHOW GETTAN
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
VMODE = VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
DUMMY=RES640
DRWBOX 1, 10, 0, 0, 639, 479
DRWLINE 1, 10, 0, 240, 639, 240
DRWLINE 1, 10, 320, 0, 320, 479
DEG2RAD! = 4 * ATN(1) / 180
FOR I = -360 TO 360
IF ((I - 90) / 180) <> INT((I - 90) / 180) THEN
Y1& = GETTAN(I)
Y1& = Y1& * 240 / 8192
Y2& = 240 * TAN(I * DEG2RAD!)
DRWPOINT 1, 15, 320 + I, 240 - Y1&
DRWPOINT 1, 12, 320 + I, 240 - Y2&
END IF
67
NEXT I
WHILE INKEY$ = ""
WEND
VIDEOMODESET VMODE
END
68
GIFGETINFO
PROTOTYPE
FUNCTION GIFGETINFO% (Filename$, Width%, Height%, NumColors%,
Palette$)
INPUT
Filename$ - the filename of the GIF image to read
OUTPUT
GIFGETINFO returns the status of the function (1 = success).
Width - the width in pixels of the image
Height - the height in pixels of the image
NumColors - the number of colors in the image palette
Palette$ - string*768 containing the image palette
USAGE
GIFGETINFO reads Filename$ and returns the characteristics of
the image. The dimensions of the image are returned in Width,
Height. The number of colors in the image's palette is
returned in NumColors and the palette is returned in Palette$.
Although the image's palette may contain less than 256 colors,
Palette$ must be 768 characters in length. The image's
palette will begin with the first character of Palette$.
For ease of programming the GIF decoder requires that the
image be non-interlaced, use only a global color map and be
compressed according to GIF87a specifications.
If GIFGETINFO determines that Filename$ is a satisfactory
file, the function will return a one. Otherwise, the function
will return one of several error codes concerning Filename$ as
listed below:
0 = does not exist or there is some disk I/O problem
-1 = does not have the GIF87a signature
-2 = image is interlaced
-3 = does not use a global color map
-4 = has some general error
SEE ALSO
GIFMAKE, GIFPUT
EXAMPLE
REM GET THE INFORMATION OF THE GIF FILE 'UTTOWER.GIF'
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
DIM GIFPAL AS STRING * 768
69
CLS
GIFFILENAME$="UTTOWER.GIF"
PRINT
OK = GIFGETINFO(GIFFILENAME$, XSIZE, YSIZE, NUMCOL, GIFPAL)
IF OK = 1 THEN
A$ = "'" + GIFFILENAME$ + "' is identified as a 'Non-
Interlaced' type GIF"
A$ = A$ + "'GIF87a' GIF."
PRINT A$
A$ = "Dimensions are:" + STR$(XSIZE) + " pixels wide and" +
STR$(YSIZE)
A$ = A$ + " pixels high"
PRINT A$
A$ = "Number of colors:" + STR$(NUMCOL)
PRINT A$
END IF
WHILE INKEY$ = ""
WEND
END
70
GIFMAKE
PROTOTYPE
FUNCTION GIFMAKE% (X1%, Y1%, X2%, Y2%, Filename$)
INPUT
X1, Y1 - the location of the top, left corner of the image
X2, Y2 - the bottom, right corner of the image
Filename$ - filename to store the GIF image
OUTPUT
GIFMAKE returns a 1 if successful, 0 if unsuccessful.
USAGE
GIFMAKE takes the bitmap enclosed in the box defined by (X1,
Y1) - (X2, Y2) and writes a GIF with the filename specified by
Filename$. The resulting file uses the GIF87a compression
specifications. X1, Y1, X2 and Y2 must be valid coordinates
on the currently active page. Filename$ may specify a full
path and drive letter, if necessary.
SEE ALSO
GIFGETINFO, GIFPUT
EXAMPLE
REM MAKE A 256 COLOR GIF FILE
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
DIM DT(0 TO 10000) AS INTEGER
IF WHICHCPU < 386 THEN END
IF WHICHVGA = 0 THEN END
VMODE = VIDEOMODEGET
DUMMY = RES640
FILLSCREEN 10
FOR A = 0 TO 200
X1 = RND * GETMAXX
Y1 = RND * GETMAXY
X2 = RND * GETMAXX
Y2 = RND * GETMAXY
C = RND * 255
DRWLINE 1, C, X1, Y1, X2, Y2
NEXT A
DRWBOX 1, 15, 0, 0, GETMAXX, GETMAXY
A$ = "This GIF file was created using Zephyr Software's
'GIFMAKE' function!"
DRWSTRING 1, 15, 0, A$, 2, 2
ER = GIFMAKE(0, 0, GETMAXX, GETMAXY, "TEST.GIF")
VIDEOMODESET VMODE
71
IF ER <> 1 THEN
PRINT "GIF MAKE ERROR!"
END IF
END
72
GIFPUT
PROTOTYPE
FUNCTION GIFPUT (Mode%, X%, Y%, Filename$)
INPUT
Mode - pixel write mode (SET=1, XOR=2, OR=3, AND=4)
X, Y - the location of the top, left corner of the GIF image
Filename$ - filename of the GIF image to read
OUTPUT
GIFPUT returns the status of the function (1 = success).
USAGE
GIFPUT reads the GIF image from Filename$ and places it on the
screen with the top, left corner at X, Y. The image is
automatically clipped to the currently defined viewport. The
image's palette should be previously obtained by using
GIFGETINFO.
For ease of programming the GIF decoder requires that the
image be non-interlaced, use only a global color map and be
compressed according to GIF87a specifications.
If GIFPUT encounters no problems, the function will return a
one. Otherwise, the function will return one of several error
codes concerning Filename$ as listed below:
0 = does not exist or there is some disk I/O problem
-1 = does not have the GIF87a signature
-2 = image is interlaced
-3 = does not use a global color map
-4 = has some general error
SEE ALSO
GIFGETINFO, GIFMAKE, SETVIEW
EXAMPLE
REM DISPLAY THE GIF FILE 'UTTOWER.GIF'
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
DIM GIFPAL AS STRING * 768
IF WHICHVGA = 0 THEN STOP
IF WHICHMEM < 512 THEN STOP
GIFFILENAME$="UTTOWER.GIF"
VMODE = VIDEOMODEGET
DUMMY=RES640
73
OK = GIFGETINFO(GIFFILENAME$, XSIZE, YSIZE, NUMCOL, GIFPAL)
IF OK = 1 THEN
FIXIT = 0
FOR A = 1 TO NUMCOL * 3 STEP 3
R = ASC(MID$(GIFPAL, A, 1))
G = ASC(MID$(GIFPAL, A + 1, 1))
B = ASC(MID$(GIFPAL, A + 2, 1))
IF R > 63 THEN
FIXIT = 1
EXIT FOR
END IF
IF G > 63 THEN
FIXIT = 1
EXIT FOR
END IF
IF B > 63 THEN
FIXIT = 1
EXIT FOR
END IF
NEXT A
IF FIXIT = 1 THEN
FOR A = 1 TO NUMCOL * 3
C = ASC(MID$(GIFPAL, A, 1))
MID$(GIFPAL, A, 1) = CHR$(C \ 4)
NEXT A
END IF
PALSET GIFPAL, 0, 255
OK = GIFPUT(1, 0, 0, GIFFILENAME$)
IF OK <> 1 THEN
SOUND 100, 5
END IF
END IF
WHILE INKEY$ = ""
WEND
VIDEOMODESET VMODE
END
74
JOYSTICKINFO
PROTOTYPE
SUB JOYSTICKINFO (JAX%, JAY%, JAButs%, JBX%, JBY%, JBButs%)
INPUT
no input parameters
OUTPUT
no value returned
JAX, JAY - horizontal and vertical values of joystick A
JAButs - button status of joystick A
JBX, JBY - horizontal and vertical values of joystick B
JBButs - button status of joystick B
USAGE
JOYSTICKINFO returns the current status of the two joysticks'
position and buttons. The position is returned in JAX, JAY
for joystick A and JBX, JBY for joystick B. The buttons'
status is held in JAButs and JBButs. For each joystick,
button A - usually the fire button - is held in bit zero and
button B is in bit one. Button status is most easily checked
with a bitwise AND of JAButs (or JBButs) and the desired bit.
Not all joysticks are constructed the same. In addition,
joysticks are not linear devices. The value of its center
will not necessarily be the mean of its extreme values.
Therefore, it is recommended that any program using the
joystick for more than just directional control complete a
calibration of the joystick prior to usage. For an example of
joystick calibration, see the SVGADEMO.EXE source code.
SEE ALSO
WHICHJOYSTICK
EXAMPLE
REM DISPLAY THE STATUS OF THE JOYSTICK PORT
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
CLS
WHILE INKEY$ = ""
JOYSTICKINFO JAX, JAY, JAButs, JBX, JBY, JBButs
LOCATE 1, 1
PRINT STRING$(40, 32)
LOCATE 1, 1
PRINT JAX; JAY; JAButs, JBX; JBY; JBButs;
SDELAY 4
75
WEND
END
76
MOUSEBUTPRESS
PROTOTYPE
SUB MOUSEBUTPRESS (ReqButton%, X%, Y%, Num%, MouseButs%)
INPUT
ReqButton - button for which information is requested
OUTPUT
no value returned
X, Y - current location of mouse cursor
Num - number of times button has been pressed since last
request
MouseButs - current status of the mouse buttons
USAGE
MOUSEBUTPRESS returns in Num the number of times a mouse
button has been pressed since the last call to MOUSEBUTPRESS.
In addition the current status of the mouse cursor and buttons
is returned. The position is returned in X, Y. The buttons'
status is held in MouseButs. The left button is held in bit
zero, right button in bit one and center button - for three
button mice - in bit two. Button status is most easily
checked with a bitwise AND of MouseButs and the desired bit.
The button for which a history is desired is identified by the
bits in ReqButton. However, only one bit may be set.
Therefore, only the values of 1, 2 and 4 are permitted. If
more than one bit in ReqButton is set, the function will exit
and no information will be returned.
SEE ALSO
MOUSEBUTRELEASE, MOUSESTATUS
EXAMPLE
REM ENABLE, SHOW, MOUSE / DISPLAY LEFT BUTTON PRESS HISTORY
REM FOR THE LAST 2 SECONDS
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
VMODE = VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
IF WHICHMOUSE = 0 THEN STOP
DUMMY=RES640
MOUSEENTER
MOUSESHOW
WHILE INKEY$ = ""
MOUSEBUTPRESS 1, X, Y, N, MBUTS
D$ = "MX=" + STR$(X)
77
L = LEN(D$)
IF L < 10 THEN
D$ = D$ + STRING$(8 - L, 32)
END IF
D$ = D$ + "MY=" + STR$(Y)
L = LEN(D$)
IF L < 20 THEN
D$ = D$ + STRING$(16 - L, 32)
END IF
D$ = D$ + "Number Of Times=" + STR$(N)
DRWSTRING 1, 15, 8, D$, 0, 0
SDELAY 80
WEND
MOUSEEXIT
VIDEOMODESET VMODE
END
78
MOUSEBUTRELEASE
PROTOTYPE
SUB MOUSEBUTRELEASE (ReqButton%, X%, Y%, Num%, MouseButs%)
INPUT
ReqButton - button for which information is requested
OUTPUT
no value returned
X, Y - current location of mouse cursor
Num - number of times button has been released since last
request
MouseButs - current status of mouse buttons
USAGE
MOUSEBUTRELEASE returns in Num the number of times a mouse
button has been released since the last call to
MOUSEBUTRELEASE. In addition the current status of the mouse
cursor and buttons is returned. The position is returned in
X, Y. The buttons' status is held in MouseButs. The left
button is held in bit zero, right button in bit one and center
button - for three button mice - in bit two. Button status is
most easily checked with a bitwise AND of MouseButs and the
desired bit. The button for which a history is desired is
identified by the bits in ReqButton. However, only one bit
may be set. Therefore, only the values of 1, 2 and 4 are
permitted. If more than one bit in ReqButton is set, the
function will exit and no information will be returned.
SEE ALSO
MOUSEBUTPRESS, MOUSESTATUS
EXAMPLE
REM ENABLE, SHOW, MOUSE / DISPLAY LEFT BUTTON RELEASE HISTORY
REM FOR THE LAST 2 SECONDS
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
VMODE = VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
IF WHICHMOUSE = 0 THEN STOP
DUMMY=RES640
MOUSEENTER
MOUSESHOW
WHILE INKEY$ = ""
MOUSEBUTRELEASE 1, X, Y, N, MBUTS
D$ = "MX=" + STR$(X)
79
L = LEN(D$)
IF L < 10 THEN
D$ = D$ + STRING$(8 - L, 32)
END IF
D$ = D$ + "MY=" + STR$(Y)
L = LEN(D$)
IF L < 20 THEN
D$ = D$ + STRING$(16 - L, 32)
END IF
D$ = D$ + "Number Of Times=" + STR$(N)
DRWSTRING 1, 15, 8, D$, 0, 0
SDELAY 80
WEND
MOUSEEXIT
VIDEOMODESET VMODE
END
80
MOUSECURSORDEFAULT
PROTOTYPE
SUB MOUSECURSORDEFAULT ()
INPUT
no input parameters
OUTPUT
no value returned
USAGE
MOUSECURSORDEFAULT defines the mouse cursor to be a small
arrow with the hot spot in the upper, left corner. This is
the cursor set when MOUSEENTER is called.
SEE ALSO
MOUSECURSORSET, MOUSEENTER
EXAMPLE
See MOUSECURSORSET
81
MOUSECURSORSET
PROTOTYPE
SUB MOUSECURSORSET (MouseCursor$)
INPUT
MouseCursor$ - string * 386 containing mouse cursor data
OUTPUT
no value returned
USAGE
MOUSECURSORSET defines the cursor according to the data in
MouseCursor$. The hot spot X and Y location for the cursor is
defined by the first two bytes of MouseCursor$. The values
for the hot spot must be within the cursor. Valid values are
from 0 to 15 for the X location and from 0 to 23 for the Y
location.
SEE ALSO
MOUSECURSORDEFAULT, MOUSEENTER, MOUSESHOW
EXAMPLE
REM MAKE A BIG CURSOR, THEN RESTORE IT BACK TO THE DEFAULT
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
VMODE = VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
IF WHICHMEM < 512 THEN STOP
IF WHICHMOUSE = 0 THEN STOP
DUMMY=RES640
MOUSEENTER
DIM BIGMOUSECURSOR AS STRING * 386
FOR I = 1 TO 386
READ A
MID$(BIGMOUSECURSOR, I, 1) = CHR$(A)
NEXT I
MOUSECURSORSET BIGMOUSECURSOR
MOUSERANGESET 0, 0, 639, 400
MOUSESHOW
A$ = "Press A Key To Return To The Default Cursor"
DRWSTRING 1, 7, 0, A$, 0, 420
WHILE INKEY$ = ""
WEND
MOUSECURSORDEFAULT
A$ = "Press A Key To End "
DRWSTRING 1, 7, 0, A$, 0, 420
82
WHILE INKEY$ = ""
WEND
MOUSEEXIT
VIDEOMODESET VMODE
END
REM *BIG ARROW MOUSE CURSOR DATA
DATA 2,2
DATA 0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255
DATA 0,15,15,0,0,255,255,255,255,255,255,255,255,255,255,255
DATA 0,15,15,15,15,0,0,0,255,255,255,255,255,255,255,255
DATA 0,15,15,15,15,15,15,15,0,0,255,255,255,255,255,255
DATA 0,15,15,15,15,15,15,15,15,15,0,0,0,255,255,255
DATA 0,15,15,15,15,15,15,15,15,15,15,15,15,0,0,255
DATA 0,15,15,15,15,15,15,15,15,15,15,15,15,15,0,255
DATA 0,15,15,15,15,15,15,15,15,15,15,15,0,0,255,255
DATA 0,15,15,15,15,15,15,15,15,15,15,0,255,255,255,255
DATA 0,15,15,15,15,15,15,15,15,0,0,255,255,255,255,255
DATA 0,15,15,15,15,15,15,15,15,0,255,255,255,255,255,255
DATA 0,15,15,15,15,15,0,15,15,15,0,255,255,255,255,255
DATA 0,15,15,15,15,0,0,15,15,15,0,255,255,255,255,255
DATA 0,15,15,0,0,255,255,0,15,15,15,0,255,255,255,255
DATA 0,15,0,255,255,255,255,0,15,15,15,0,255,255,255,255
DATA 0,0,255,255,255,255,255,255,0,15,15,15,0,255,255,255
DATA 255,255,255,255,255,255,255,255,255,0,15,15,15,0,255,255
DATA 255,255,255,255,255,255,255,255,255,0,15,15,15,0,255,255
DATA 255,255,255,255,255,255,255,255,255,255,0,15,15,15,0,255
DATA 255,255,255,255,255,255,255,255,255,255,255,0,15,15,15,0
DATA 255,255,255,255,255,255,255,255,255,255,255,0,15,15,15,0
DATA 255,255,255,255,255,255,255,255,255,255,255,255,0,15,15,0
DATA 255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0
DATA
255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,25
5
83
MOUSEENTER
PROTOTYPE
SUB MOUSEENTER ()
INPUT
no input parameters
OUTPUT
no value returned
USAGE
MOUSEENTER must be called before any other mouse functions.
It initializes all of the mouse abilities including installing
the Zephyr mouse display driver. MOUSEENTER initializes the
default mouse cursor, the default sensitivity and sets the
range to the current screen resolution. The mouse cursor
location is set to the middle of the screen.
SEE ALSO
MOUSEEXIT, MOUSEHIDE, MOUSESHOW
EXAMPLE
REM ENABLE AND SHOW THE MOUSE
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
VMODE = VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
IF WHICHMOUSE = 0 THEN STOP
DUMMY=RES640
MOUSEENTER
MOUSESHOW
WHILE INKEY$ = ""
WEND
MOUSEEXIT
VIDEOMODESET VMODE
END
84
MOUSEEXIT
PROTOTYPE
SUB MOUSEEXIT ()
INPUT
no input parameters
OUTPUT
no value returned
USAGE
MOUSEEXIT properly disables all of the mouse abilities. This
function also removes the Zephyr mouse display driver. This
function should be called prior to exiting any program that
previously called MOUSEENTER.
SEE ALSO
MOUSEENTER, MOUSEHIDE, MOUSESHOW
EXAMPLE
See MOUSEENTER
85
MOUSEHIDE
PROTOTYPE
SUB MOUSEHIDE ()
INPUT
no input parameters
OUTPUT
no value returned
USAGE
MOUSEHIDE turns off the mouse display driver and removes the
cursor from the display. It is recommended to hide the mouse
any time something will be drawn in its general vicinity.
Note, however, that although the cursor is not visible, all
other mouse abilities remain active.
SEE ALSO
MOUSEENTER, MOUSEEXIT, MOUSESHOW
EXAMPLE
REM ENABLE, SHOW, AND THE HIDE THE MOUSE
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
VMODE = VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
IF WHICHMOUSE = 0 THEN STOP
DUMMY=RES640
MOUSEENTER
MOUSESHOW
WHILE INKEY$ = ""
WEND
MOUSEHIDE
WHILE INKEY$ = ""
WEND
MOUSEEXIT
VIDEOMODESET VMODE
END
86
MOUSEINFO
PROTOTYPE
SUB MOUSEINFO (MajorVersion%, MinorVersion%, MouseType%, IRQ%)
INPUT
no input parameters
OUTPUT
no value returned
MajorVersion - Microsoft compatible mouse driver major version
number
MinorVersion - Microsoft compatible mouse driver minor version
number
MouseType - type of mouse installed
IRQ - the interrupt used by the mouse
USAGE
MOUSEINFO returns information about the mouse and its
installed driver. The driver must be Microsoft compatible.
This information can be used to determine whether the mouse
functions in this library will operate correctly. For proper
operation the driver version number must be greater than 1.00.
IRQ gives the interrupt number of the mouse - probably 3 or 4.
MouseType returns information about the type of hardware
installed according to the following table:
0 = unknown type
1 = bus mouse
2 = serial mouse
3 = Inport mouse
4 = PS/2 mouse
5 = HP mouse
SEE ALSO
WHICHMOUSE
EXAMPLE
REM RETURN INFORMATION ABOUT THE MOUSE
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
CLS
MOUSE = WHICHMOUSE
IF MOUSE > 0 THEN
MOUSEINFO MJV, MNV, TP, I
VER$ = STR$(MNV)
L = LEN(VER$)
87
VER$ = STR$(MJV) + "." + RIGHT$(VER$, L - 1)
VER$ = "Software driver version is" + VER$
VER$ = VER$ + " (Microsoft equivalent version)."
SELECT CASE TP
CASE IS = 1
TYPE$ = "bus mouse"
CASE IS = 2
TYPE$ = "serial mouse"
CASE IS = 3
TYPE$ = "Inport mouse"
CASE IS = 4
TYPE$ = "PS/2 mouse"
CASE IS = 5
TYPE$ = "HP mouse"
CASE ELSE
TYPE$ = "unknown type"
END SELECT
PRINT "Microsoft compatible " + TYPE$ + " detected with";
PRINT STR$(MOUSE) + " buttons on IRQ" + STR$(I) + "."
PRINT VER$
ELSE
PRINT "No Microsoft compatible mouse detected."
END IF
PRINT
WHILE INKEY$ = ""
WEND
END
88
MOUSELOCSET
PROTOTYPE
SUB MOUSELOCSET (X%, Y%)
INPUT
X, Y - location on screen
OUTPUT
no value returned
USAGE
MOUSELOCSET moves the mouse cursor the location on the screen
specified by X, Y. If either X or Y is outside of the
currently permitted mouse range, it is set to the closest
border. The currently permitted mouse range is the current
screen resolution or the last called MOUSERANGESET.
SEE ALSO
MOUSEENTER, MOUSERANGESET
EXAMPLE
REM ENABLE AND SHOW THE MOUSE THEN MOVE IT TO THE ORIGIN
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
VMODE = VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
IF WHICHMOUSE = 0 THEN STOP
DUMMY=RES640
MOUSEENTER
MOUSESHOW
WHILE INKEY$ = ""
WEND
MOUSELOCSET 0, 0
WHILE INKEY$ = ""
WEND
MOUSEEXIT
VIDEOMODESET VMODE
END
89
MOUSERANGESET
PROTOTYPE
SUB MOUSERANGESET (X1%, Y1%, X2%, Y2%)
INPUT
X1, Y1 - location on screen of top, left corner of range
X2, Y2 - location on screen of bottom, right corner of range
OUTPUT
no value returned
USAGE
MOUSERANGESET defines a permissible range on the screen for
mouse movement. The mouse is automatically positioned in the
center of this range.
SEE ALSO
MOUSELOCSET, MOUSESTATUS
EXAMPLE
REM ENABLE, SHOW, AND SET A RANGE FOR THE MOUSE
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
VMODE = VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
IF WHICHMOUSE = 0 THEN STOP
DUMMY=RES640
MOUSEENTER
DRWBOX 1, 10, 100, 100, 539, 379
MOUSERANGESET 100, 100, 539, 379
MOUSESHOW
WHILE INKEY$ = ""
WEND
MOUSEEXIT
VIDEOMODESET VMODE
END
90
MOUSERESTORESTATE
PROTOTYPE
SUB MOUSERESTORESTATE (MouseBuf%)
INPUT
MouseBuf - integer array holding complete mouse status
information
OUTPUT
no value returned
USAGE
MOUSERESTORESTATE completely restores a previously saved mouse
status as contained in MouseBuf. The mouse status must have
been already stored in MouseBuf by MOUSESAVESTATE.
SEE ALSO
MOUSESAVESTATE, MOUSESTORAGESIZE
EXAMPLE
REM SAVE THE CURRENT MOUSE DRIVER STATUS,SHELL OUT, RESTORE IT
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
IF WHICHMOUSE = 0 THEN STOP
BUFSIZE = MOUSESTORAGESIZE \ 2 + 1
DIM MBUFFER(0 TO BUFSIZE) AS INTEGER
MOUSESAVESTATE MBUFFER(0)
PRINT "TYPE 'EXIT' TO RETURN TO THE PROGRAM"
SHELL
CLS
MOUSERESTORESTATE MBUFFER(0)
PRINT "DRIVER RESTORED..."
WHILE INKEY$ = ""
WEND
END
91
MOUSESAVESTATE
PROTOTYPE
SUB MOUSESAVESTATE (MouseBuf%)
INPUT
no input parameters
OUTPUT
no value returned
MouseBuf - integer array holding complete mouse status
information
USAGE
MOUSESAVESTATE saves the complete mouse status in MouseBuf.
The size of MouseBuf in bytes is defined by MOUSESTORAGESIZE
which should called first.
SEE ALSO
MOUSERESTORESTATE, MOUSESTORAGESIZE
EXAMPLE
See MOUSESAVESTATE
92
MOUSESENSSET
PROTOTYPE
SUB MOUSESENSSET (XSens%, Ysens%, DblSpdTresh%)
INPUT
XSens - number of mickeys per 8 pixels horizontally (default =
8 mickeys per 8 pixels)
YSens - number of mickeys per 8 pixels vertically (default =
16 mickeys per 8 pixels)
DblSpdThresh = number of mickeys per second at which speed is
doubled (default = 64)
OUTPUT
no value returned
USAGE
MOUSESENSSET defines the relationship between mouse movement
and cursor movement on the screen. A mickey is defined as
1/200th of an inch. The ratio between mickeys and pixels is
specified by XSens and YSens in the horizontal and vertical
directions respectively. When the mouse movement is faster
than DblSpdThresh in mickeys per second, the speed is doubled.
The default values are assigned whenever MOUSEENTER or
MOUSEEXIT are called.
SEE ALSO
MOUSEENTER, MOUSEEXIT, MOUSESTATUS
EXAMPLE
REM ENABLE, SHOW THE MOUSE AND MAKE IT VERY SENSITIVE
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
VMODE = VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
IF WHICHMOUSE = 0 THEN STOP
DUMMY=RES640
MOUSEENTER
MOUSESHOW
MOUSESENSSET 50, 50, 10
WHILE INKEY$ = ""
WEND
MOUSEEXIT
VIDEOMODESET VMODE
END
93
MOUSESHOW
PROTOTYPE
SUB MOUSESHOW ()
INPUT
no input parameters
OUTPUT
no value returned
USAGE
MOUSESHOW enables the mouse display driver and places the
cursor on the screen. The cursor is only updated when the
mouse is moved. Therefore, it is recommended to hide the
cursor when drawing on the screen to avoid unexpected results.
SEE ALSO
MOUSEENTER, MOUSEEXIT, MOUSEHIDE
EXAMPLE
See MOUSEHIDE
94
MOUSESTATUS
PROTOTYPE
SUB MOUSESTATUS (X%, Y%, MouseButs%)
INPUT
no input parameters
OUTPUT
no value returned
X, Y - mouse position on screen
MouseButs - status of mouse buttons
USAGE
MOUSESTATUS returns the current status of the mouse position
and buttons. The position is returned in X, Y. The buttons'
status is held in MouseButs. The left button is held in bit
zero, right button in bit one and center button - for three
button mice - in bit two. Button status is most easily
checked with a bitwise AND of MouseButs and the desired bit.
SEE ALSO
MOUSERANGESET, MOUSESENSSET
EXAMPLE
REM ENABLE, SHOW, DISPLAY MOUSE STATUS
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
VMODE = VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
IF WHICHMOUSE = 0 THEN STOP
DUMMY=RES640
MOUSEENTER
MOUSESHOW
WHILE INKEY$ = ""
MOUSESTATUS X, Y, MButs
D$ = "MX=" + STR$(X)
L = LEN(D$)
IF L < 10 THEN
D$ = D$ + STRING$(8 - L, 32)
END IF
D$ = D$ + "MY=" + STR$(Y)
L = LEN(D$)
IF L < 20 THEN
D$ = D$ + STRING$(16 - L, 32)
END IF
D$ = D$ + "MBUTS=" + STR$(MButs)
DRWSTRING 1, 15, 8, D$, 0, 0
95
WEND
MOUSEEXIT
VIDEOMODESET VMODE
END
96
MOUSESTORAGESIZE
PROTOTYPE
FUNCTION MOUSESTORAGESIZE% ()
INPUT
no input parameters
OUTPUT
MOUSESTORAGESIZE returns the number of bytes needed to store
the complete mouse status.
USAGE
MOUSESTORAGESIZE determines the proper size buffer to hold the
complete mouse status information. This buffer should be
created before calling MOUSESAVESTATE.
SEE ALSO
MOUSERESTORESTATE, MOUSESAVESTATE
EXAMPLE
REM RETURN THE SIZE IN BYTES NEEDED TO SAVE THE MOUSE STATUS
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
CLS
IF WHICHMOUSE = 0 THEN STOP
A$ = "The Mouse Driver Requires A" + STR$(MOUSESTORAGESIZE) +
" Byte Buffer "
A$ = A$ + "To Save Current Status."
PRINT A$
PRINT
WHILE INKEY$ = ""
WEND
END
97
OVERSCANSET
PROTOTYPE
SUB OVERSCANSET (Color%)
INPUT
Color - index to color in current palette
OUTPUT
no value returned
USAGE
OVERSCANSET sets the overscan region to the specified color.
The overscan region is the area between the usable pixel area
and the region not scanned by the monitor. Normally, the
overscan is color zero which is defined as black the majority
of the time. The overscan color is reset to zero anytime a
RES### function is called.
Note: OVERSCANSET always works in the 320x200 resolution. In
the higher resolutions on many common SVGA cards this function
is ignored. Instead, the card always assigns the overscan
region to color zero. Therefore, it is recommended to not use
OVERSCANSET, but assign color zero as needed.
EXAMPLE
REM SET THE OVERSCAN COLOR TO GREEN
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
VMODE = VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
RES320
OVERSCANSET 10
WHILE INKEY$ = ""
WEND
VIDEOMODESET VMODE
END
98
PAGEACTIVE
PROTOTYPE
FUNCTION PAGEACTIVE (Page%)
INPUT
Page - number of page to make active
OUTPUT
PAGEACTIVE returns a 1 if successful, 0 if unsuccessful.
USAGE
PAGEACTIVE sets the active page as specified by Page. It
works by creating an offset to be added when any bank
switching is performed. This function does not affect the
actual display. A page is defined as the number of 64K blocks
necessary to contain the current screen resolution. For
example, 640x480 requires 307,200 bytes which is a little more
than 4.5 64K blocks. One page in this resolution will be 5
banks.
PAGEACTIVE does not work in 320x200 mode since this mode uses
no bank switching.
SEE ALSO
PAGEDISPLAY
EXAMPLE
REM SHOW PAGEACTIVE FUNCTION
REM THIS EXAMPLE REQUIRES 1 MEG OF VIDEO MEMORY
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
IF WHICHVGA = 0 THEN
END
END IF
IF WHICHMEM < 1024 THEN
END
END IF
IF RES640 = 0 THEN
END
END IF
REM MAKE SURE VIDEO CARD SUPPORTS PAGE FLIPPING
IF PAGEDISPLAY(0, 0, 0) = 0 THEN
DUMMY = RESTEXT
END
END IF
99
DUMMY = PAGEACTIVE(0)
FILLPAGE 0
DRWSTRING 1, 10, 0, "PAGE 0", 0, 0
DRWSTRING 1, 10, 0, "PRESS A KEY...", 0, 300
DUMMY = PAGEACTIVE(1)
FILLPAGE 0
DRWSTRING 1, 12, 0, "PAGE 1", 0, 20
DRWSTRING 1, 12, 0, "PRESS A KEY...", 0, 300
DUMMY = PAGEACTIVE(2)
FILLPAGE 0
DRWSTRING 1, 13, 0, "PAGE 2", 0, 40
DRWSTRING 1, 13, 0, "PRESS A KEY...", 0, 300
DUMMY = PAGEDISPLAY(0, 0, 0)
WHILE INKEY$ = ""
WEND
DUMMY = PAGEDISPLAY(0, 0, 1)
WHILE INKEY$ = ""
WEND
DUMMY = PAGEDISPLAY(0, 0, 2)
WHILE INKEY$ = ""
WEND
DUMMY = RESTEXT
CLS
END
100
PAGEDISPLAY
PROTOTYPE
FUNCTION PAGEDISPLAY (X%, Y%, Page%)
INPUT
X, Y - coordinate to place at top, left of display
Page - number of page to make active
OUTPUT
PAGEACTIVE returns a 1 if successful, 0 if unsuccessful.
USAGE
PAGEDISPLAY tells the video card where in video memory to
begin the display. This display offset is calculated from the
specified Page, X and Y. This is done by multiplying Y times
the width of the current resolution, adding X and then adding
the appropriate number of 64K blocks for Page. X, Y and Page
must all be positive numbers, but are otherwise not
restricted. The display will wrap if the values are
abnormally large. Wrapping will happen from side to side as
well as from top of memory to bottom of memory.
PAGEDISPLAY does not work in 320x200 mode since this mode uses
no bank switching. In addition, older models of some SVGA
cards operating in native mode do not support paging. In this
library these cards are: Acumos, Ahead version A, Everex and
Genoa. To ensure compatibility, a program should make a call
similar to:
RET = PAGEDISPLAY(0,0,0)
IF RET = 0 THEN PRINT "PAGING NOT SUPPORTED"
Note: SVGA cards by ATI Technologies appear to ignore bit 4
(counting from 0 to 19) in its linear addressing mode and
assume it is zero. Therefore, bit 4 of the x parameter will
be ignored by ATI chipsets.
SEE ALSO
PAGEACTIVE
EXAMPLE
See PAGEACTIVE
101
PALCHGAUTO
PROTOTYPE
SUB PALCHGAUTO (Pal$, NewPal$, FirstColor%, LastColor%,
Speed%)
INPUT
Pal$ - string * 768 containing initial palette
NewPal$ - string *768 containing new palette
FirstColor - index into palette where change will begin
LastColor - index into palette where change will end
Speed - speed of change
OUTPUT
no value returned
USAGE
PALCHGAUTO smoothly fades the colors between FirstColor and
LastColor from the palette Pal$ to NewPal$. The speed of the
fade is set by Speed which is percentage change between each
step of the fade. Only values between 1 and 128 are valid
where 1 represents a one percent change between steps and 128
(80 hex) represents fifty percent change between steps. A
Speed of 128 would then have only two steps. A Speed outside
of the valid range causes the function to immediately return
without making any changes. The time required to accomplish
the entire fade is approximately equal to 0.033 seconds times
256 divided by Speed. PALCHGAUTO does not modify either Pal$
or NewPal$.
SEE ALSO
PALCHGSTEP, PALDIMSTEP, PALIOAUTO
EXAMPLE
REM AUTOFADE FROM ONE PALETTE TO ANOTHER AND BACK AGAIN
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
DIM PAL AS STRING * 768
DIM NEWPAL AS STRING * 768
VMODE = VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
IF WHICHMEM < 512 THEN STOP
DUMMY=RES640
PALGET PAL, 0, 255
FOR I = 1 TO 768
MID$(NEWPAL, I, 1) = MID$(PAL, 769 - I, 1)
NEXT I
102
COLR = 0
FOR I = 0 TO 639
DRWLINE 1, COLR, I, 0, I, 479
COLR = COLR + 1
IF COLR > 255 THEN
COLR = 0
END IF
NEXT I
PALCHGAUTO PAL, NEWPAL, 0, 255, 2
PALCHGAUTO NEWPAL, PAL, 0, 255, 2
WHILE INKEY$ = ""
WEND
VIDEOMODESET VMODE
END
103
PALCHGSTEP
PROTOTYPE
SUB PALCHGSTEP (Pal$, NewPal$, FirstColor%, LastColor%,
Percent%)
INPUT
Pal$ - string * 768 containing initial palette
NewPal$ - string * 768 containing new palette
FirstColor - index into palette where change will begin
LastColor - index into palette where change will end
Percent - percent step from current palette to new palette
OUTPUT
no value returned
USAGE
PALCHGSTEP changes the palette colors between FirstColor and
LastColor by Percent from Pal$ to NewPal$. This function
works very much like PALCHGAUTO except it only takes a single
step and returns. The step taken is a percentage specified by
Percent where 256 (100 hex) is a 100 percent change. The
valid range for Percent is 0 to 256. Values beyond this range
cause the function to immediately return without making any
changes. A loop from 4 to 256 by fours using PALCHGSTEP would
have similar results as PALCHGAUTO with a speed of 4. Neither
Pal$, nor NewPal$ are modified.
SEE ALSO
PALCHGAUTO, PALDIMSTEP, PALIOAUTO
EXAMPLE
REM STEP FADE FROM ONE PALETTE TO ANOTHER AND BACK AGAIN FAST
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
DIM PAL AS STRING * 768
DIM NEWPAL AS STRING * 768
VMODE = VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
IF WHICHMEM < 512 THEN STOP
DUMMY=RES640
PALGET PAL, 0, 255
FOR I = 1 TO 768
MID$(NEWPAL, I, 1) = MID$(PAL, 769 - I, 1)
NEXT I
COLR = 0
FOR I = 0 TO 639
104
DRWLINE 1, COLR, I, 0, I, 479
COLR = COLR + 1
IF COLR > 255 THEN
COLR = 0
END IF
NEXT I
FOR I = 1 TO 255 STEP 2
PALCHGSTEP PAL, NEWPAL, 0, 255, I
NEXT I
FOR I = 1 TO 255 STEP 16
PALCHGSTEP NEWPAL, PAL, 0, 255, I
NEXT I
WHILE INKEY$ = ""
WEND
VIDEOMODESET VMODE
END
105
PALCOPY
PROTOTYPE
SUB PALCOPY (SrcPalette$, DestPalette$, FirstColor%,
LastColor%)
INPUT
SrcPalette$ - string * 768 containing source palette
FirstColor - index into palette where copy will begin
LastColor - index into palette where copy will end
OUTPUT
no value returned
DestPalette$ - string * 768 containing copy of source palette
USAGE
PALCOPY quickly copies a source palette into a second palette
array. The source and destination must both be defined as
string * 768 or PALCOPY will return without making any copy.
A portion of a palette may be copied by specifying first and
last colors.
SEE ALSO
BYTECOPY
EXAMPLE
REM SHOW PAL COPY
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
DIM PAL1 AS STRING * 768
DIM PAL2 AS STRING * 768
VMODE = VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
IF WHICHMEM < 512 THEN STOP
DUMMY = RES640
FOR I = 0 TO 255
MID$(PAL1, I * 3 + 1, 1) = CHR$(I)
MID$(PAL1, I * 3 + 2, 1) = CHR$(I)
MID$(PAL1, I * 3 + 3, 1) = CHR$(I)
NEXT I
COLR = 0
FOR I = 0 TO 639
DRWLINE 1, COLR, I, 0, I, 479
COLR = COLR + 1
IF COLR > 255 THEN COLR = 0
NEXT I
PALCOPY PAL1, PAL2, 0, 255
PALSET PAL2, 0, 255
106
WHILE INKEY$ = ""
WEND
VIDEOMODESET VMODE
END
107
PALDIMSTEP
PROTOTYPE
SUB PALDIMSTEP (Pal$, FirstColor%, LastColor%, Percent%)
INPUT
Pal$ - string * 768 containing initial palette
FirstColor - index into palette where dim will begin
LastColor - index into palette where dim will end
Percent - percent step from current palette to black
OUTPUT
no value returned
USAGE
PALDIMSTEP fades the specified palette to black by the given
percentage between FirstColor and LastColor. The percentage
step from Pal$ to black is specified by Percent where 256 (100
hex) is full black. The valid range for Percent is 0 to 256.
Values beyond this range cause the function to immediately
return without making any changes. Pal$ is not modified.
SEE ALSO
PALCHGAUTO, PALCHGSTEP, PALIOAUTO
EXAMPLE
REM STEP FADE OUT AND BACK IN FAST
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
DIM PAL AS STRING * 768
VMODE = VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
IF WHICHMEM < 512 THEN STOP
DUMMY=RES640
PALGET PAL, 0, 255
COLR = 0
FOR I = 0 TO 639
DRWLINE 1, COLR, I, 0, I, 479
COLR = COLR + 1
IF COLR > 255 THEN COLR = 0
NEXT I
FOR I = 255 TO 0 STEP -2
PALDIMSTEP PAL, 0, 255, I
NEXT I
FOR I = 1 TO 255 STEP 16
PALDIMSTEP PAL, 0, 255, I
NEXT I
108
WHILE INKEY$ = ""
WEND
VIDEOMODESET VMODE
END
109
PALGET
PROTOTYPE
SUB PALGET (Pal$, FirstColor, LastColor%)
INPUT
Pal$ - string * 768 to hold current palette
FirstColor - index into palette where get will begin
LastColor - index into palette where get will end
OUTPUT
Pal$ - string * 768 containing the current palette in the
specified range
USAGE
PALGET returns in Pal$ the colors from the current palette
between FirstColor and LastColor. Only colors in the
specified range are returned and all others in Pal$ are
unchanged. Pal$ must have a length of 768 characters despite
the number of colors retrieved.
SEE ALSO
PALROTATE, PALSET
EXAMPLE
REM GET THE CURRENT PALETTE IN THE VARIABLE 'PAL'
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
DIM PAL AS STRING * 768
VMODE = VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
IF WHICHMEM < 512 THEN STOP
DUMMY=RES640
PALGET PAL, 0, 255
VIDEOMODESET VMODE
CLS
PRINT "GOT IT IN 'PAL'..."
WHILE INKEY$ = ""
WEND
END
110
PALIOAUTO
PROTOTYPE
SUB PALIOAUTO (Pal$, FirstColor%, LastColor%, Speed%)
INPUT
Pal$ - string *768 containing initial palette
FirstColor - index into palette where fade will begin
LastColor - index into palette where fade will end
Speed - speed of fade
OUTPUT
no value returned
USAGE
PALIOAUTO smoothly fades the colors between FirstColor and
LastColor of Pal$ to or from solid black. The speed of the
fade is set by Speed which is the percentage change between
each step of the fade. A positive Speed corresponds to fading
from Pal$ to black and a negative Speed fades from black to
Pal$. Only values between -128 and +128 are valid where 1
represents a one percent change between steps and 128 ( 80
hex) represents fifty percent change between steps. A Speed
of 128 would then have only two steps. A Speed outside of the
valid range causes the function to immediately return without
making any changes. The time required to accomplish the
entire fade is approximately equal to 0.033 seconds times 256
divided by Speed. PALIOAUTO does not modify Pal$.
SEE ALSO
PALCHGAUTO, PALCHGSTEP, PALDIMSTEP
EXAMPLE
REM FADE OUT AND BACK IN FAST
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
DIM PAL AS STRING * 768
VMODE = VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
IF WHICHMEM < 512 THEN STOP
DUMMY=RES640
PALGET PAL, 0, 255
COLR = 0
FOR I = 0 TO 639
DRWLINE 1, COLR, I, 0, I, 479
COLR = COLR + 1
IF COLR > 255 THEN COLR = 0
NEXT I
111
PALIOAUTO PAL, 0, 255, -2
PALIOAUTO PAL, 0, 255, 16
WHILE INKEY$ = ""
WEND
VIDEOMODESET VMODE
END
112
PALROTATE
PROTOTYPE
SUB PALROTATE (Pal$, FirstColor%, LastColor%, Shift%)
INPUT
Pal$ - string * 768 containing current palette
FirstColor - index into palette where shift will begin
LastColor - index into palette where shift will end
Shift - number of locations to shift colors
OUTPUT
no value returned
USAGE
PALROTATE shifts the colors between FirstColor and LastColor
by a given number of locations. The number of locations the
colors are moved is specified by Shift which is between 1 and
256. Pal$ is not modified by PALROTATE.
SEE ALSO
PALGET, PALSET
EXAMPLE
REM ROTATE A FEW PALETTE ENTRIES AROUND
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
DIM PAL AS STRING * 768
VMODE = VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
IF WHICHMEM < 512 THEN STOP
DUMMY=RES640
PALGET PAL, 0, 255
COLR = 0
FOR I = 0 TO 639
DRWLINE 1, COLR, I, 0, I, 479
COLR = COLR + 1
IF COLR > 255 THEN COLR = 0
NEXT I
FOR I = 0 TO 100
PALROTATE PAL, 0, 127, 1
PALGET PAL, 0, 255
NEXT I
WHILE INKEY$ = ""
WEND
VIDEOMODESET VMODE
END
113
PALSET
PROTOTYPE
SUB PALSET (Pal$, FirstColor%, LastColor%)
INPUT
Pal$ - string * 768 containing the palette to set
FirstColor - index into palette where set will begin
LastColor - index into palette where set will end
OUTPUT
no value returned
USAGE
PALSET sets the specified range of colors in the current
palette with the corresponding range in the palette Pal$.
SEE ALSO
PALGET
EXAMPLE
REM SET A NEW PALETTE
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
DIM PAL AS STRING * 768
DIM NEWPAL AS STRING * 768
VMODE = VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
IF WHICHMEM < 512 THEN STOP
DUMMY=RES640
PALGET PAL, 0, 255
FOR I = 1 TO 768
MID$(NEWPAL, I, 1) = MID$(PAL, 769 - I, 1)
NEXT I
COLR = 0
FOR I = 0 TO 639
DRWLINE 1, COLR, I, 0, I, 479
COLR = COLR + 1
IF COLR > 255 THEN COLR = 0
NEXT I
PALSET NEWPAL, 0, 255
WHILE INKEY$ = ""
WEND
VIDEOMODESET VMODE
END
114
RES320
PROTOTYPE
FUNCTION RES320% ()
INPUT
no input parameters
OUTPUT
RES320 always returns a 1.
USAGE
RES320 sets video mode 0x13 which is the VGA standard 320x200
graphics mode with 256 colors. This function can be called
without calling WHICHVGA first as this function requires only
that a VGA card is present, not a Super VGA card. If a VGA is
not present, the system may crash.
SEE ALSO
RES640, RES640L, RES800, RES1024, WHICHVGA
EXAMPLE
REM SET THE VIDEO MODE TO 320x200x256
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
VMODE = VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
DUMMY=RES320
DRWSTRING 1, 7, 0, "THIS IS THE 320x200x256 VIDEO MODE...", 0,
0
WHILE INKEY$ = ""
WEND
VIDEOMODESET VMODE
END
115
RES640
PROTOTYPE
FUNCTION RES640% ()
INPUT
no input parameters
OUTPUT
RES640 returns 1 if successful, 0 otherwise.
USAGE
RES640 sets the video mode to 640x480 graphics mode with 256
colors. This function requires that a Super VGA card with at
least 512K of video memory be present. Also, WHICHVGA must be
called first or the function will fail without changing the
video mode. If the video card does not have sufficient
memory, RES640 will return without changing the video mode.
SEE ALSO
RES320, RES640L, RES800, RES1024, WHICHVGA
EXAMPLE
REM SET THE VIDEO MODE TO 640x480x256
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
VMODE = VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
IF WHICHMEM < 512 THEN STOP
DUMMY=RES640
DRWSTRING 1, 7, 0, "THIS IS THE 640x480x256 VIDEO MODE...", 0,
0
WHILE INKEY$ = ""
WEND
VIDEOMODESET VMODE
END
116
RES640L
PROTOTYPE
FUNCTION RES640L% ()
INPUT
no input parameters
OUTPUT
RES640L returns 1 if successful, 0 otherwise.
USAGE
RES640L sets the video mode to 640x400 graphics mode with 256
colors. This function requires that a Super VGA card with at
least 256K of video memory be present. Also, WHICHVGA must be
called first or the function will fail without changing the
video mode. If the video card does not have sufficient
memory, RES640L will return without changing the video mode.
Note: 640x400 is a non-standard resolution. Not all SVGA
cards recognized by this library support this video mode.
SEE ALSO
RES320, RES640, RES800, RES1024, WHICHVGA
EXAMPLE
REM SET THE VIDEO MODE TO 640x400x256
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
VMODE = VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
IF WHICHMEM < 256 THEN STOP
DUMMY=RES640L
DRWSTRING 1, 7, 0, "THIS IS THE 640x400x256 VIDEO MODE...", 0,
0
WHILE INKEY$ = ""
WEND
VIDEOMODESET VMODE
END
117
RES800
PROTOTYPE
FUNCTION RES800% ()
INPUT
no input parameters
OUTPUT
RES800 returns 1 if successful, 0 otherwise.
USAGE
RES800 sets the video mode to 800x600 graphics mode with 256
colors. This function requires that a Super VGA card with at
least 512K of video memory be present. Also, WHICHVGA must be
called first or the function will fail without changing the
video mode. If the video card does not have sufficient
memory, RES800 will return without changing the video mode.
SEE ALSO
RES320, RES640, RES640L, RES1024, WHICHVGA
EXAMPLE
REM SET THE VIDEO MODE TO 800x600x256
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
VMODE = VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
IF WHICHMEM < 512 THEN STOP
DUMMY=RES800
DRWSTRING 1, 7, 0, "THIS IS THE 800x600x256 VIDEO MODE...", 0,
0
WHILE INKEY$ = ""
WEND
VIDEOMODESET VMODE
END
118
RES1024
PROTOTYPE
FUNCTION RES1024% ()
INPUT
no input parameters
OUTPUT
RES1024 returns 1 if successful, 0 otherwise.
USAGE
RES1024 sets the video mode to 1024x768 graphics mode with 256
colors. This function requires that a Super VGA card with at
least 1 Megabyte of video memory be present. Also, WHICHVGA
must be called first or the function will fail without
changing the video mode. If the video card does not have
sufficient memory, RES1024 will return without changing the
video mode.
SEE ALSO
RES320, RES640, RES640L, RES800, WHICHVGA
EXAMPLE
REM SET THE VIDEO MODE TO 1024x768x256
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
VMODE = VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
IF WHICHMEM < 1024 THEN STOP
DUMMY=RES1024
DRWSTRING 1, 7, 0, "THIS IS THE 1024x768x256 VIDEO MODE...",
0, 0
WHILE INKEY$ = ""
WEND
VIDEOMODESET VMODE
END
119
RESTEXT
PROTOTYPE
FUNCTION RESTEXT% ()
INPUT
no input parameters
OUTPUT
RESTEXT always returns a 1.
USAGE
RESTEXT sets video mode three which is the VGA standard 80x25
text mode.
SEE ALSO
VIDEOMODEGET, VIDEOMODESET
EXAMPLE
REM SET THE VIDEO MODE TO STANDARD DOS TEXT MODE 3
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
VMODE = VIDEOMODEGET
RESTEXT
PRINT "THIS IS THE TEXT VIDEO MODE (DOS VIDEO MODE 3)...
WHILE INKEY$ = ""
WEND
VIDEOMODESET VMODE
END
120
SCROLLDN
PROTOTYPE
SUB SCROLLDN (X1%, Y1%, X2%, Y2%, Num%, Color%)
INPUT
X1, Y1 - top left corner of block
X2, Y2 - bottom right corner of block
Num - number of pixels to shift
Color - index to color in current palette
OUTPUT
no value returned
USAGE
SCROLLDN shifts the contents of the box described by (X1, Y1)
- (X2, Y2) down by the number of pixels specified by Num. The
empty pixels created at the top of the box are filled with
Color. The pixels that are shifted out of the box are lost.
SCROLLDN enforces X2 X1 and Y2Y1. When placed within a loop,
SCROLLDN will create a scrolling effect.
SEE ALSO
SCROLLLT, SCROLLRT, SCROLLUP
EXAMPLE
REM SCROLL SOME TEXT DOWN
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
VMODE = VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
IF WHICHMEM < 512 THEN STOP
DUMMY=RES640
DRWBOX 1, 10, 0, 0, 100, 100
DRWSTRING 1, 7, 0, "TEXT TEXT", 20, 43
FOR I = 0 TO 40
SCROLLDN 1, 1, 99, 99, 1, 0
SDELAY 2
NEXT I
WHILE INKEY$ = ""
WEND
VIDEOMODESET VMODE
END
121
SCROLLLT
PROTOTYPE
SUB SCROLLLT (X1%, Y1%, X2%, Y2%, Num%, Color%)
INPUT
X1, Y1 - top left corner of block
X2, Y2 - bottom right corner of block
Num - number of pixels to shift
Color - index to color in current palette
OUTPUT
no value returned
USAGE
SCROLLLT shifts the contents of the box described by (X1, Y1)
- (X2, Y2) down by the number of pixels specified by Num. The
empty pixels created at the right of the box are filled with
Color. The pixels that are shifted out of the box are lost.
SCROLLLT enforces X2 X1 and Y2Y1. When placed within a loop,
SCROLLRT will create a scrolling effect.
SEE ALSO
SCROLLDN, SCROLLRT, SCROLLUP
EXAMPLE
REM SCROLL SOME TEXT LEFT
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
VMODE = VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
IF WHICHMEM < 512 THEN STOP
DUMMY=RES640
DRWBOX 1, 10, 0, 0, 100, 100
DRWSTRING 1, 7, 0, "TEXT TEXT", 20, 43
FOR I = 0 TO 40
SCROLLLT 1, 1, 99, 99, 1, 0
SDELAY 2
NEXT I
WHILE INKEY$ = ""
WEND
VIDEOMODESET VMODE
END
122
SCROLLRT
PROTOTYPE
SUB SCROLLRT (X1%, Y1%, X2%, Y2%, Num%, Color%)
INPUT
X1, Y1 - top left corner of block
X2, Y2 - bottom right corner of block
Num - number of pixels to shift
Color - index to color in current palette
OUTPUT
no value returned
USAGE
SCROLLRT shifts the contents of the box described by (X1, Y1)
- (X2, Y2) down by the number of pixels specified by Num. The
empty pixels created at the left of the box are filled with
Color. The pixels that are shifted out of the box are lost.
SCROLLRT enforces X2 X1 and Y2Y1. When placed within a loop,
SCROLLRT will create a scrolling effect.
SEE ALSO
SCROLLDN, SCROLLLT, SCROLLUP
EXAMPLE
REM SCROLL SOME TEXT RIGHT
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
VMODE = VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
IF WHICHMEM < 512 THEN STOP
DUMMY=RES640
DRWBOX 1, 10, 0, 0, 100, 100
DRWSTRING 1, 7, 0, "TEXT TEXT", 20, 43
FOR I = 0 TO 40
SCROLLRT 1, 1, 99, 99, 1, 0
SDELAY 2
NEXT I
WHILE INKEY$ = ""
WEND
VIDEOMODESET VMODE
END
123
SCROLLUP
PROTOTYPE
SUB SCROLLUP (X1%, Y1%, X2%, Y2%, Num%, Color%)
INPUT
X1, Y1 - top left corner of block
X2, Y2 - bottom right corner of block
Num - number of pixels to shift
Color - index to color in current palette
OUTPUT
no value returned
USAGE
SCROLLUP shifts the contents of the box described by (X1, Y1)
- (X2, Y2) down by the number of pixels specified by Num. The
empty pixels created at the bottom of the box are filled with
Color. The pixels that are shifted out of the box are lost.
SCROLLUP enforces X2 X1 and Y2Y1. When placed within a loop,
SCROLLUP will create a scrolling effect.
SEE ALSO
SCROLLDN, SCROLLLT, SCROLLRT
EXAMPLE
REM SCROLL SOME TEXT UP
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
VMODE = VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
IF WHICHMEM < 512 THEN STOP
DUMMY=RES640
DRWBOX 1, 10, 0, 0, 100, 100
DRWSTRING 1, 7, 0, "TEXT TEXT", 20, 43
FOR I = 0 TO 40
SCROLLUP 1, 1, 99, 99, 1, 0
SDELAY 2
NEXT I
WHILE INKEY$ = ""
WEND
VIDEOMODESET VMODE
END
124
SDELAY
PROTOTYPE
SUB SDELAY (Count%)
INPUT
Count - number of vertical syncs to wait
OUTPUT
no value returned
USAGE
SDELAY pauses execution of the program for a period of time
specified by Count. This delay remains approximately constant
on all machines by using the vertical sync timer of the VGA
graphics card which is about 60 - 70 Hz.
EXAMPLE
REM MAKE A DELAY ABOUT 3 SECONDS LONG
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
CLS
PRINT "OK...STARTING DELAY NOW..."
PRINT "SHOULD BE ABOUT 3 SECONDS..."
PRINT
TIM! = TIMER
SDELAY 195
TOT! = TIMER - TIM!
PRINT "ACTUAL TIME WAS:"; TOT!
WHILE INKEY$ = ""
WEND
END
125
SETCARD
PROTOTYPE
SUB SETCARD (Chip%, Mem%)
INPUT
Chip - code for certain SVGA chip type
Mem - amount of video memory installed
OUTPUT
no value returned
USAGE
WARNING: USING SETCARD IMPROPERLY MAY CAUSE A SYSTEM FAILURE
OR DAMAGE.
SETCARD sets the card type and installed video memory. It can
be used instead of the WHICHVGA function. However, specifying
an incorrect chip type or installed video memory may cause
unpredictable results not excluding damage to the SVGA card
and/or monitor. Extreme caution is advised when using this
function. It is recommended that this function only be used
when it is suspected that the identification process in
WHICHVGA failed. Be absolutely certain that the chip type
specified is the actual chip type installed in the computer.
Mem should be a value of 256, 512 or 1024 representing the
kilobytes of video memory installed. Use the following table
to identify chip types:
1 Acumos AVGA2/3 SuperVGA
2 ATI Technologies 18/28/38/68800 SuperVGA
3 Ahead V5000 ver A SuperVGA
4 Ahead V5000 ver B SuperVGA
5 Chips and Technologies 82C45x SuperVGA
6 Cirrus Logic CL-GD 5xx, 6xx, 28xx, 54xx, 62xx SuperVGA
7 Everex Micro Enhancer Ev236/6xx SuperVGA
8 Genoa 61/62/63/64/6600 SuperVGA
9 NCR 77C21/22/22E/22E+ SuperVGA
10 Oak Technologies OTI-037C/067/077/087 SuperVGA
11 Paradise/Western Digital PVGA1A, WD90C00/1x/2x/3x SuperVGA
12 Realtek RT3106 SuperVGA
13 Trident 8800CS, 8900B/C/CL/CX, 90x0 SuperVGA
14 Tseng Labs ET3000-AX/BX/BP SuperVGA
15 Tseng Labs ET4000/W32/W32I SuperVGA
16 VESA compatible SuperVGA
17 Video 7 HT-208/16 SuperVGA
18 Avance Logic AL2101 SuperVGA
19 MXIC MX68000/10 SuperVGA
20 Primus P2000 SuperVGA
SEE ALSO
126
WHICHVGA
EXAMPLE
REM
!WARNING!WARNING!WARNING!WARNING!WARNING!WARNING!WARNING!WARNI
NG!
REM USE THIS FUNCTION CAREFULLY. IT WORKS AROUND THE "WHICHVGA
FUNCTION"
REM IMPROPER USE (I.E. SETTING THE CARD ID AND MEMORY TO
SOMETHING THAT
REM THAT IS NOT VALID) MIGHT DAMAGE YOUR VIDEO CARD/VIDEO
MONITOR OR
REM CAUSE UNPREDICTABLE RESULTS. IT IS PROVIDED AS A METHOD TO
FIND
REM FAULTS IN THE VIDEO CARD/CHIP ID PROCESS.
REM
!WARNING!WARNING!WARNING!WARNING!WARNING!WARNING!WARNING!WARNI
NG!
END
127
SETVIEW
PROTOTYPE
SUB SETVIEW (X1%, Y1%, X2%, Y2%)
INPUT
X1, Y1 - top, left corner of view port
X2, Y2 - bottom, right corner of view port
OUTPUT
no value returned
USAGE
SETVIEW defines a viewport for clipping output on the screen.
Nothing can be drawn outside of the currently defined
viewport. The RES### functions set the viewport to the full
screen. The restrictions on X1, Y1, X2 and Y2 are as follows:
0 X1 < X2 (screen width)
0 Y1 < Y2 (32767, effectively unbounded)
SEE ALSO
RES320, RES640, RES640L, RES800, RES1024
EXAMPLE
REM DRAW SOME LINES CLIPPED TO A VIEWPORT
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
VMODE = VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
IF WHICHMEM < 512 THEN STOP
DUMMY=RES640
DRWBOX 1, 15, 100, 100, 539, 379
SETVIEW 101, 101, 538, 378
FOR I = 0 TO 300
X1 = RND * 640
Y1 = RND * 480
X2 = RND * 640
Y2 = RND * 480
DRWLINE 1, 10, X1, Y1, X2, Y2
NEXT I
WHILE INKEY$ = ""
WEND
VIDEOMODESET VMODE
END
128
SPRITECOLLDETECT
PROTOTYPE
FUNCTION SPRITECOLLDETECT% (TransColor%, X1%, Y1%, X2%, Y2%,
GfxBlk1%, GfxBlk2%)
INPUT
TransColor - index to color in current palette
X1, Y1 - top, left corner of sprite number 1
X2, Y2 - top, left corner of sprite number 2
GfxBlk1 - predefined integer array containing the sprite
number 1
GfxBlk2 - predefined integer array containing the sprite
number 2
OUTPUT
SPRITECOLLDETECT returns the collision status of the two
sprites.
USAGE
SPRITECOLLDETECT is used in sprite graphics or animation to
report the collision status between two sprites. GfxBlk1, a
short integer array, contains the first sprite which should
have been previously defined by BLKGET or similar function.
GfxBlk2, likewise, contains the second sprite. The top, left
corner of the first and second sprites' locations are
specified by X1, Y1 and X2, Y2, respectively.
SPRITECOLLDETECT will return a zero if the sprites are not
colliding and the blocks are not overlapping. The return will
be one if the blocks overlap, but the sprites are not
colliding. A return value of two indicates that the sprites
have at least one overlapping pixel and are, therefore,
colliding.
Arrays should be passed by giving the element within the array
from where the action should take place. This allows the
programmer to store more than one item within the same array
or act on only a portion of the array.
SEE ALSO
BLKGET, BLKPUT, GETLASTSTRING, SPRITEGAP, SPRITEGET, SPRITEPUT
EXAMPLE
REM SHOW THE RESULTS OF THE SPRITE COLLISION DETECTION
FUNCTION
REM $INCLUDE: 'SVGABC.BI'
129
DEFINT A-Z
DIM D1(0 TO 4000) AS INTEGER
DIM D2(0 TO 4000) AS INTEGER
IF WHICHVGA < 0 THEN STOP
ORGMODE = VIDEOMODEGET
DUMMY=RES320
X1 = 0
Y1 = 0
X2 = 24
Y2 = 24
DRWLINE 1, 8, X1, Y1, X2, Y1
DRWLINE 1, 8, X2, Y1, X2, Y2
DRWLINE 1, 8, X2, Y2, X1, Y2
DRWLINE 1, 8, X1, Y2, X1, Y1
FILLAREA X1 + 1, Y1 + 1, 8, 8
DRWLINE 1, 10, X1, Y1, X2, Y2
DRWLINE 1, 10, X2, Y1, X1, Y2
BLKGET X1, Y1, X2, Y2, D1(0)
BLKPUT 2, X1, Y1, D1(0)
X1 = 0
Y1 = 0
X2 = 48
Y2 = 48
DRWLINE 1, 8, X1, Y1, X2, Y1
DRWLINE 1, 8, X2, Y1, X2, Y2
DRWLINE 1, 8, X2, Y2, X1, Y2
DRWLINE 1, 8, X1, Y2, X1, Y1
FILLAREA X1 + 1, Y1 + 1, 8, 8
DRWCIRCLE 1, 10, X1 + 24, Y1 + 24, 24
BLKGET X1, Y1, X2, Y2, D2(0)
BLKPUT 2, X1, Y1, D2(0)
X1 = 90
Y1 = 90
BLKPUT 2, X1, Y1, D2(0)
FOR X = 50 TO 150
BLKPUT 2, X, X, D1(0)
A = SPRITECOLLDETECT(8, X, X, X1, Y1, D1(0), D2(0))
A$ = STR$(A)
IF LEN(A$) < 5 THEN A$ = A$ + " "
DRWSTRING 1, 7, 0, A$, 0, 0
WHILE INKEY$ = ""
WEND
BLKPUT 2, X, X, D1(0)
NEXT X
VIDEOMODESET ORGMODE
END
130
SPRITEGAP
PROTOTYPE
SUB SPRITEGAP (TransColor%, X%, Y%, GfxBlk%, BkGndGfxBlk%)
INPUT
TransColor - index to color in current palette
X, Y - top, left corner of block
GfxBlk - predefined integer array containing the sprite
OUTPUT
no value returned
BkGndGfxBlk - integer array holding the sprite background
USAGE
SPRITEGAP ("Sprite-Get-And-Put") is used in sprite graphics or
animation to retrieve a sprite's background and then display
the sprite. GfxBlk, a short integer array, contains the
sprite which should have been previously defined by BLKGET or
similar function such as GETLASTSTRING. TransColor is the
transparent color assumed in GfxBlk. BkGndGfxBlk, an empty
short integer array the same size as GfxBlk, will receive the
sprite's background. The top, left corner of the sprite's
location is specified by X, Y.
Arrays should be passed by giving the element within the array
from where the action should take place. This allows the
programmer to store more than one item within the same array
or act on only a portion of the array.
SEE ALSO
BLKGET, BLKPUT, GETLASTSTRING, SPRITECOLLDETECT, SPRITEGET,
SPRITEPUT
EXAMPLE
REM SHOW SPRITEGAP
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
DIM GFXBLK1(10000)
DIM GFXBLK2(10000)
DIM GFXBLK3(10000)
IF WHICHVGA = 0 THEN STOP
VMODE = VIDEOMODEGET
IF RES640 <> 1 THEN
VIDEOMODESET VMODE
END
END IF
131
Colr = 1
FOR I = 0 TO GETMAXX \ 2
DRWCIRCLE 1, Colr, GETMAXX \ 4 + I, GETMAXY \ 2, GETMAXY \ 5
Colr = Colr + 1
IF Colr > 15 THEN
Colr = 1
END IF
NEXT I
XINC = GETMAXX \ 20
YINC = GETMAXY \ 20
X1 = GETMAXX \ 2 - XINC
Y1 = GETMAXY \ 2 - YINC
X2 = GETMAXX \ 2 + XINC
Y2 = GETMAXY \ 2 + YINC
X = (X2 - X1) \ 2 + X1
Y = (Y2 - Y1) \ 2 + Y1
BLKGET X1, Y1, X2, Y2, GFXBLK1(0)
DRWBOX 1, 0, X1, Y1, X2, Y2
FILLAREA X1 + 2, Y1 + 2, 0, 0
BLKGET X1, Y1, X2, Y2, GFXBLK3(0)
FOR I = 0 TO 360 STEP 3
DUMMY = BLKROTATE(I, 1, GFXBLK1(0), GFXBLK2(0))
SPRITEPUT 1, 1, X - GFXBLK3(0) \ 2, Y - GFXBLK3(1) \ 2,
GFXBLK3(0)
SPRITEGAP 1, X - GFXBLK2(0) \ 2, Y - GFXBLK2(1) \ 2,
GFXBLK2(0), GFXBLK3(0)
SDELAY 3
NEXT I
SPRITEPUT 1, 1, X - GFXBLK3(0) \ 2, Y - GFXBLK3(1) \ 2,
GFXBLK3(0)
BLKPUT 1, X1, Y1, GFXBLK1(0)
VIDEOMODESET VMODE
END
132
SPRITEGET
PROTOTYPE
SUB SPRITEGET (TransColor%, X%, Y%, GfxBlk%, BkGndGfxBlk%)
INPUT
TransColor - index to color in current palette
X, Y - top, left corner of block
GfxBlk - predefined integer array containing the sprite
OUTPUT
no value returned
BkGndGfxBlk - integer array holding the sprite background
USAGE
SPRITEGET is used in sprite graphics or animation to retrieve
the background for a sprite, normally just before using
SPRITEPUT. GfxBlk, a short integer array, contains the sprite
which should have been previously defined by BLKGET or similar
function. TransColor is the transparent color assumed in
GfxBlk. BkGndGfxBlk, an empty short integer array of the same
size as GfxBlk, will receive the sprite's background. The
top, left corner of the sprite's location is specified by X,
Y.
Arrays should be passed by giving the element within the array
from where the action should take place. This allows the
programmer to store more than one item within the same array
or act on only a portion of the array.
SEE ALSO
BLKGET, BLKPUT, GETLASTSTRING, SPRITECOLLDETECT, SPRITEGAP,
SPRITEPUT
EXAMPLE
REM SHOW SPRITEGET
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
DIM GFXBLK1(10000)
DIM GFXBLK2(10000)
DIM GFXBLK3(10000)
IF WHICHVGA = 0 THEN STOP
VMODE = VIDEOMODEGET
IF RES640 <> 1 THEN
VIDEOMODESET VMODE
END
END IF
133
Colr = 1
FOR I = 0 TO GETMAXX \ 2
DRWCIRCLE 1, Colr, GETMAXX \ 4 + I, GETMAXY \ 2, GETMAXY \ 5
Colr = Colr + 1
IF Colr > 15 THEN
Colr = 1
END IF
NEXT I
XINC = GETMAXX \ 20
YINC = GETMAXY \ 20
X1 = GETMAXX \ 2 - XINC
Y1 = GETMAXY \ 2 - YINC
X2 = GETMAXX \ 2 + XINC
Y2 = GETMAXY \ 2 + YINC
X = (X2 - X1) \ 2 + X1
Y = (Y2 - Y1) \ 2 + Y1
BLKGET X1, Y1, X2, Y2, GFXBLK1(0)
DRWBOX 1, 0, X1, Y1, X2, Y2
FILLAREA X1 + 2, Y1 + 2, 0, 0
BLKGET X1, Y1, X2, Y2, GFXBLK3(0)
FOR I = 0 TO 360 STEP 3
DUMMY = BLKROTATE(I, 1, GFXBLK1(0), GFXBLK2(0))
SPRITEPUT 1, 1, X - GFXBLK3(0) \ 2, Y - GFXBLK3(1) \ 2,
GFXBLK3(0)
SPRITEGET 1, X - GFXBLK2(0) \ 2, Y - GFXBLK2(1) \ 2,
GFXBLK2(0), GFXBLK3(0)
SPRITEPUT 1, 1, X - GFXBLK2(0) \ 2, Y - GFXBLK2(1) \ 2,
GFXBLK2(0)
SDELAY 3
NEXT I
SPRITEPUT 1, 1, X - GFXBLK3(0) \ 2, Y - GFXBLK3(1) \ 2,
GFXBLK3(0)
BLKPUT 1, X1, Y1, GFXBLK1(0)
VIDEOMODESET VMODE
END
134
SPRITEPUT
PROTOTYPE
SUB SPRITEPUT (Mode%, TransColor%, X%, Y%, GfxBlk%)
INPUT
Mode - pixel write mode (SET=1, XOR=2, OR=3, AND=4)
TransColor - index to color in current palette
X, Y - top, left corner of block
GfxBlk - predefined integer array containing the sprite
OUTPUT
no value returned
USAGE
SPRITEPUT is used in sprite graphics or animation to display a
sprite or, more commonly, its background. GfxBlk, a short
integer array, contains the sprite which should have been
previously defined by BLKGET, SPRITEGAP or SPRITEGET.
TransColor is the transparent color assumed in GfxBlk. The
top, left corner of the sprite's location is specified by X,
Y.
Arrays should be passed by giving the element within the array
from where the action should take place. This allows the
programmer to store more than one item within the same array
or act on only a portion of the array.
SEE ALSO
BLKGET, BLKPUT, GETLASTSTRING, SPRITECOLLDETECT, SPRITEGAP,
SPRITEGET
EXAMPLE
See SPRITEGAP
135
VIDEOMODEGET
PROTOTYPE
FUNCTION VIDEOMODEGET% ()
INPUT
no input parameters
OUTPUT
VIDEOMODEGET returns the current video mode.
USAGE
VIDEOMODEGET returns the current video mode. This function is
best used to retrieve the video mode being used when a program
begins. When the program ends, this video mode can then be
restored using VIDEOMODESET.
SEE ALSO
RES320, RES640, RES640L, RES800, RES1024, RESTEXT,
VIDEOMODESET
EXAMPLE
REM SAVE THE VIDEO MODE,SWITCH TO 640X480X256, RESTORE THE
ORIGINAL MODE
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
VMODE = VIDEOMODEGET
IF WHICHVGA = 0 THEN STOP
IF WHICHMEM < 512 THEN STOP
DUMMY=RES640
DRWSTRING 1, 7, 0, "PRESS A KEY...", 0, 0
WHILE INKEY$ = ""
WEND
VIDEOMODESET VMODE
END
136
VIDEOMODESET
PROTOTYPE
SUB VIDEOMODESET (Mode%)
INPUT
Mode - number of video mode
OUTPUT
no value returned
USAGE
VIDEOMODESET sets the video mode specified by Mode. This
function is best used at the end of a program to restore the
video mode to the mode in use when the program began. The
program should retrieve the video mode at the beginning by
using VIDEOMODEGET.
SEE ALSO
RES320, RES640, RES640L, RES800, RES1024, RESTEXT,
VIDEOMODEGET
EXAMPLE
See VIDEOMODEGET
137
VIDEOOFF
PROTOTYPE
SUB VIDEOOFF ()
INPUT
no input parameters
OUTPUT
no value returned
USAGE
VIDEOOFF turns the output display off. Graphics may still be
drawn to the screen. However, the computer's monitor will
display nothing and appear black. This function can be used
to hide graphics being drawn by initially using VIDEOOFF and
then later calling VIDEOON.
SEE ALSO
VIDEOON
EXAMPLE
REM DISABLE THE VIDEO FOR ABOUT 3 SEC
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
CLS
PRINT "PRESS A KEY TO DISABLE THE VIDEO DISPLAY FOR 3 SECONDS"
WHILE INKEY$ = ""
WEND
VIDEOOFF
SDELAY 195
VIDEOON
PRINT "OK...WE ARE BACK!"
WHILE INKEY$ = ""
WEND
END
138
VIDEOON
PROTOTYPE
SUB VIDEOON ()
INPUT
no input parameters
OUTPUT
no value returned
USAGE
VIDEOON turns the display back on. All graphics that were
drawn while the display was off are now visible. This
function can be used to hide graphics being drawn by initially
using VIDEOOFF and then later calling VIDEOON.
SEE ALSO
VIDEOOFF
EXAMPLE
See VIDEOOFF
139
WHICHCPU
PROTOTYPE
FUNCTION WHICHCPU% ()
INPUT
no input parameters
OUTPUT
WHICHCPU returns the processor type.
USAGE
WHICHCPU returns the computer's processor type as 86, 286, 386
or 486. This function should be called by any program using
this library's routines to insure that the computer is at
least 386 compatible or better.
SEE ALSO
WHICHJOYSTICK, WHICHMOUSE, WHICHVGA
EXAMPLE
REM FIND OUT WHAT KIND OF MICROPROCESSOR WE HAVE
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
CLS
CPU = WHICHCPU
CPU$ = STR$(CPU)
L = LEN(CPU$)
CPU$ = RIGHT$(CPU$, L - 1)
PRINT "Microprocessor is identified as a 80"; CPU$; "."
END
140
WHICHJOYSTICK
PROTOTYPE
FUNCTION WHICHJOYSTICK% ()
INPUT
no input parameters
OUTPUT
WHICHJOYSTICK returns the available joystick support.
USAGE
WHICHJOYSTICK returns the joystick support available on the
computer. This function should be called prior to use of the
joysticks to verify that joysticks are available. If the
function returns a -1, there is no joystick port present or no
BIOS support for a joystick. Joystick A is bit 1 and B is bit
2. Therefore, a return value of 1 means joystick A is
available, a value of 2 means B is available and a value of 3
means both are available. If no bits are set, there are no
joysticks present.
SEE ALSO
JOYSTICKINFO, WHICHCPU, WHICHMOUSE, WHICHVGA, APPENDIX B.
JOYSTICK Y-CABLES
EXAMPLE
REM FIND OUT IF WE HAVE ANY JOYSTICKS AVAILABLE
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
CLS
JOYSTICK = WHICHJOYSTICK
SELECT CASE JOYSTICK
CASE IS = -1
A$ = "No joystick port detected or no joystick BIOS
support present."
CASE IS = 0
A$ = "No joystick detected."
CASE IS = 1
A$ = "Joystick A is present and available."
CASE IS = 2
A$ = "Joystick B is present and available."
CASE IS = 3
A$ = "Both Joystick A and Joystick B are present and
available."
END SELECT
PRINT A$
141
END
142
WHICHMEM
PROTOTYPE
FUNCTION WHICHMEM% ()
INPUT
no input parameters
OUTPUT
WHICHMEM returns the installed video memory in kilobytes.
USAGE
WHICHMEM returns the amount of installed video memory as
previously determined by WHICHVGA. WHICHVGA should be called
prior to WHICHMEM. This function should be called prior to
any of the RES### functions to verify that there is enough
memory to support the resolution. If SETCARD was used to set
the video card and memory, WHICHMEM will return the amount of
memory as defined by SETCARD.
SEE ALSO
RES320, RES640, RES640L, RES800, RES1024, SETCARD, WHICHVGA
EXAMPLE
REM FIND OUT HOW MUCH VIDEO MEMORY WE HAVE
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
CLS
DUMMY = WHICHVGA
PRINT "INSTALLED VIDEO MEMORY IS IDENTIFIED AS"; WHICHMEM; "k
BYTES"
END
143
WHICHMOUSE
PROTOTYPE
FUNCTION WHICHMOUSE% ()
INPUT
no input parameters
OUTPUT
WHICHMOUSE returns the number of buttons on mouse.
USAGE
WHICHMOUSE returns a value indicating whether a Microsoft
compatible mouse is available. If the function returns 0, no
mouse is available. A non zero value indicates a mouse and
Microsoft compatible driver are installed and gives the number
of buttons available.
SEE ALSO
MOUSEINFO, WHICHCPU, WHICHJOYSTICK, WHICHVGA
EXAMPLE
REM FIND OUT WHAT KIND OF MOUSE WE HAVE
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
CLS
MOUSE = WHICHMOUSE
IF MOUSE > 0 THEN
MOUSEINFO MJV, MNV, TP, I
VER$ = STR$(MNV)
L = LEN(VER$)
VER$ = STR$(MJV) + "." + RIGHT$(VER$, L - 1)
VER$ = "Software driver version is" + VER$
VER$ = VER$ + " (Microsoft equivalent version)."
A$ = "Microsoft compatible mouse detected with"
A$ = A$ + STR$(MOUSE) + " buttons on IRQ" + STR$(I) + "."
PRINT A$
PRINT VER$
ELSE
PRINT "No Microsoft compatible mouse detected."
END IF
END
144
WHICHVGA
PROTOTYPE
FUNCTION WHICHVGA% ()
INPUT
no input parameters
OUTPUT
WHICHVGA returns a code identifying the video card.
USAGE
WHICHVGA identifies the video card installed and the amount of
video memory. In addition this function sets up the default
font and mouse cursor. This function must be called before
any other graphics function. The code returned identifies the
video card according to the following table:
1 Acumos AVGA2/3 SuperVGA
2 ATI Technologies 18/28/38/68800 SuperVGA
3 Ahead V5000 ver A SuperVGA
4 Ahead V5000 ver B SuperVGA
5 Chips and Technologies 82C45x SuperVGA
6 Cirrus Logic CL-GD 5xx, 6xx, 28xx, 54xx, 62xx SuperVGA
7 Everex Micro Enhancer Ev236/6xx SuperVGA
8 Genoa 61/62/63/64/6600 SuperVGA
9 NCR 77C21/22/22E/22E+ SuperVGA
10 Oak Technologies OTI-037C/067/077/087 SuperVGA
11 Paradise/Western Digital PVGA1A, WD90C00/1x/2x/3x SuperVGA
12 Realtek RT3106 SuperVGA
13 Trident 8800CS, 8900B/C/CL/CX, 90x0 SuperVGA
14 Tseng Labs ET3000-AX/BX/BP SuperVGA
15 Tseng Labs ET4000/W32/W32I SuperVGA
16 VESA compatible SuperVGA
17 Video 7 HT-208/16 SuperVGA
18 Avance Logic AL2101 SuperVGA
19 MXIC MX68000/10 SuperVGA
20 Primus P2000 SuperVGA
Any value returned not found on this table represents an
unidentified video card.
No graphics functions should be called unless the video card
is properly identified.
SEE ALSO
SETCARD, WHICHCPU, WHICHJOYSTICK, WHICHMOUSE, WHICHMEM
EXAMPLE
145
REM FIND OUT WHAT KIND OF VIDEO CARD WE HAVE
DEFINT A-Z
CLS
VGA = WHICHVGA
SELECT CASE VGA
CASE IS = 1
VGA$ = "Acumos AVGA2/3 SuperVGA"
CASE IS = 2
VGA$ = "ATI Technologies 18/28/38/68800 SuperVGA"
CASE IS = 3
VGA$ = "Ahead V5000 ver A SuperVGA"
CASE IS = 4
VGA$ = "Ahead V5000 ver B SuperVGA"
CASE IS = 5
VGA$ = "Chips and Technologies 82C450/1/2/3/5/6/7
SuperVGA"
CASE IS = 6
VGA$ = "Cirrus Logic CL-GD 5xx,6xx,28xx,54xx,62xx
SuperVGA"
CASE IS = 7
VGA$ = "Everex Ev236/6xx Micro Enhancer SuperVGA"
CASE IS = 8
VGA$ = "Genoa 61/62/63/64/6600 SuperVGA"
CASE IS = 9
VGA$ = "NCR 77C21/22/22E/22E+ SuperVGA"
CASE IS = 10
VGA$ = "Oak Technologies OTI-037C/067/077/087 SuperVGA"
CASE IS = 11
VGA$ = "Paradise/Western Digital
PVGA1A,WD90C00/1x/2x/3x SuperVGA"
CASE IS = 12
VGA$ = "Realtek RT3106 SuperVGA"
CASE IS = 13
VGA$ = "Trident 8800CS,8900B/C/CL/CX,90x0 SuperVGA"
CASE IS = 14
VGA$ = "Tseng Labs ET3000-AX/BX/BP SuperVGA"
CASE IS = 15
VGA$ = "Tseng Labs ET4000/W32/W32I SuperVGA"
CASE IS = 16
VGA$ = "VESA compatible SuperVGA"
CASE IS = 17
VGA$ = "Video 7 HT-208/16 SuperVGA"
CASE IS = 18
VGA$ = "Avance Logic AL2101 SuperVGA"
CASE IS = 19
VGA$ = "MXIC MX68000/10 SuperVGA"
CASE IS = 20
VGA$ = "Primus P2000 SuperVGA"
CASE ELSE
VGA$ = "Unknown"
VGA = 0
END SELECT
146
PRINT "Video card/chip is identified as a "; VGA$; "."
END
147
WHICHXMS
PROTOTYPE
FUNCTION WHICHXMS% (XmsKBytesAvailable%, XmsHandlesAvailable%)
INPUT
no input parameters
OUTPUT
WHICHXMS returns a 1 if extended memory support is detected, 0
otherwise.
XmsKBytesAvailable - number of free kilobytes in extended
memory
XmsHandlesAvailable - number of available free handles
USAGE
WHICHXMS detects the existence of extended memory support and
sets up the library function calls. This function must be
called before any other extended memory functions. WHICHXMS
also returns the number of free kilobytes of extended memory
and the number of available handles. The number of available
handles is limited, normally to 32. This limit can be
modified by changing the extended memory driver (Microsoft's
HIMEM.SYS is the most common) command line in the CONFIG.SYS
file.
SEE ALSO
XMSALLOCATE, XMSCOPY, XMSERROR, XMSFREE, XMSGET, XMSPUT
EXAMPLE
REM THIS WILL SHOW IF XMS MEMORY IS AVAILABLE AND HOW MUCH
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
IF WHICHXMS(MEM, HANDLES) = 1 THEN
PRINT "AN XMS MEMORY MANAGER IS INSTALLED (SUCH AS
'HIMEM.SYS')"
IF MEM > 0 THEN
TOTMEM& = 1024
TOTMEM& = TOTMEM& * MEM
PRINT "A TOTAL OF"; TOTMEM&; "BYTES ARE AVAILABLE"
IF HANDLES > 0 THEN
PRINT "A TOTAL OF"; HANDLES; "HANDLES(S) ARE AVAILABLE"
PRINT "XMS MEMORY IS READY FOR USE"
ELSE
PRINT "SORRY...ALL XMS HANDLES ARE BEING USED"
PRINT "CHANGE (OR ADD) THE '/numhandles' SWITCH ON YOUR
XMS MEMORY MANAGER"
END IF
148
ELSE
PRINT "SORRY...ALL XMS MEMORY IS ALLOCATED"
END IF
ELSE
PRINT "SORRY...NO ACTIVE XMS MEMORY MANAGER FOUND"
PRINT "MAKE SURE YOU HAVE AN XMS MEMORY MANAGER (SUCH AS
'HIMEM.SYS' INSTALLED)"
END IF
END
149
XMSALLOCATE
PROTOTYPE
FUNCTION XMSALLOCATE% (RequestedKBytes%)
INPUT
RequestedKBytes - requested number of kilobytes of extended
memory
OUTPUT
XMSALLOCATE returns the assigned memory handle if the
allocation is successful, 0 otherwise.
USAGE
XMSALLOCATE attempts to allocate the requested number of
kilobytes in extended memory. If successful, the function
returns the handle of the new memory block. If the function
returns zero, then the allocation was unsuccessful; check
XMSERROR for error codes.
All allocated blocks must be freed using XMSFREE before a
program terminates or the memory is lost until the machine is
rebooted. Simply exiting a program will not free allocated
extended memory blocks.
SEE ALSO
WHICHXMS, XMSCOPY, XMSERROR, XMSFREE, XMSGET, XMSPUT
EXAMPLE
See XMSCOPY
150
XMSCOPY
PROTOTYPE
FUNCTION XMSCOPY% (SrcXmsHandle%, SrcOffset&, DestXmsHandle%,
DestOffset&, NumBytes&)
INPUT
SrcXmsHandle - handle of source extended memory block
SrcOffset - number of bytes from beginning of source memory
block
DestXmsHandle - handle of destination extended memory block
DestOffset - number of bytes from beginning of destination
memory block
NumBytes - number of bytes to copy from source to destination
(must be even)
OUTPUT
XMSCOPY returns a 1 if copy was successful, 0 otherwise.
USAGE
XMSCOPY copies the number of bytes specified in NumBytes from
the source extended memory block to the destination extended
memory block. NumBytes must be an even number. The copy may
begin and/or end offset from the beginning of the source and
destination blocks by passing non zero values in SrcOffset
and/or DestOffset. The copy will occur faster if both offsets
are divisible by four. If the copy was unsuccessful, check
XMSERROR for error codes.
SEE ALSO
WHICHXMS, XMSALLOCATE, XMSERROR, XMSFREE, XMSGET, XMSPUT
EXAMPLE
REM THIS WILL COPY ONE ARRAY INTO ONE XMS BLOCK AND THEN COPY
IT
REM TO A DIFFERENT XMS BLOCK, AND THEN COPY THAT BACK INTO
ANOTHER ARRAY
REM $INCLUDE: 'SVGABC.BI'
DEFINT A-Z
REM *DIMENSION OUR SOURCE AND DESTINATION ARRAYS*
DIM TEST1(0 TO 9) AS INTEGER
DIM TEST2(0 TO 9) AS INTEGER
CLS
REM *MAKE SURE XMS IS READY AND AVAILBLE*
IF WHICHXMS(MEM, HANDLES) = 1 THEN
IF MEM < 1 OR HANDLES < 1 THEN
151
PRINT "SORRY...THERE IS EITHER NO FREE XMS MEMORY OR NO
FREE XMS HANDLES"
END
END IF
ELSE
PRINT "SORRY...NO ACTIVE XMS MEMORY MANAGER FOUND"
PRINT "MAKE SURE YOU HAVE A XMS MEMORY MANAGER (SUCH AS
'HIMEM.SYS' INSTALLED)"
END
END IF
REM *PUT SOME DATA INTO THE SOURCE ARRAY*
FOR I = 0 TO 9
TEST1(I) = I * 10
NEXT I
REM *ALLOCATE THE FIRST XMS MEMORY BLOCK*
OurHandle1 = XMSALLOCATE(1)
IF OurHandle1 = 0 THEN
PRINT "OPPS..THERE IS SOME ERROR...UNABLE TO ALLOCATE XMS"
PRINT "ERROR #"; XMSERROR
ER = XMSFREE(OurHandle1)
END
END IF
REM *ALLOCATE THE SECOND XMS MEMORY BLOCK*
OurHandle2 = XMSALLOCATE(1)
IF OurHandle2 = 0 THEN
PRINT "OPPS..THERE IS SOME ERROR...UNABLE TO ALLOCATE XMS"
PRINT "ERROR #"; XMSERROR
ER = XMSFREE(OurHandle1)
ER = XMSFREE(OurHandle2)
END
END IF
REM *COPY OUR SOURCE ARRAY INTO OUR FIRST XMS BLOCK*
I = XMSPUT(TEST1(0), OurHandle1, 0, 20)
IF I = 0 THEN
PRINT "OPPS..THERE IS SOME ERROR...SEE THE ERROR CODE
LIST..."
PRINT "ERROR #"; XMSERROR
ER = XMSFREE(OurHandle1)
ER = XMSFREE(OurHandle2)
END
END IF
REM *COPY THE FIRST XMS BLOCK TO THE SECOND XMS BLOCK*
IF XMSCOPY(OurHandle1, 0, OurHandle2, 0, 20) = 0 THEN
PRINT "OPPS..THERE IS SOME ERROR...SEE THE ERROR CODE
LIST..."
PRINT "ERROR #"; XMSERROR
ER = XMSFREE(OurHandle1)
ER = XMSFREE(OurHandle2)
END
152
END IF
REM *COPY DATA FROM THE SECOND XMS BLOCK TO OUR DESTINATION
ARRAY*
IF XMSGET(OurHandle2, 0, TEST2(0), 20) = 0 THEN
PRINT "OPPS..THERE IS SOME ERROR...SEE THE ERROR CODE
LIST..."
PRINT "ERROR #"; ER
ER = XMSFREE(OurHandle1)
ER = XMSFREE(OurHandle2)
END
END IF
REM *FREE THE XMS BLOCKS WE HAVE ALLOCATED*
ER = XMSFREE(OurHandle1)
ER = XMSFREE(OurHandle2)
REM *SHOW THE RESULTS*
PRINT "OK...WE INITILIZED ONE ARRAY,PUT A COPY OF IT INTO
XMS,"
PRINT "THEN WE COPIED THAT XMS BLOCK TO ANOTHER XMS BLOCK,
AND"
PRINT "THEN PUT A COPY OF THE SECOND XMS BLOCK INTO A NEW
ARRAY;"
PRINT "HERE ARE THE RESULTS:"
PRINT
PRINT "SOURCE ARRAY", , "DESTINATION ARRAY"
FOR I = 0 TO 9
PRINT TEST1(I), , TEST2(I)
NEXT I
END
153
XMSERROR
PROTOTYPE
FUNCTION XMSERROR% ()
INPUT
no input parameters
OUTPUT
XMSERROR returns the error code from the most recent XMS
function call.
USAGE
XMSERROR returns the error code from the most recent XMS
function call. Each XMS function resets the error code to
zero. Therefore, if there has been an error, the error code
should be checked immediately. The error code will be one of
the following:
0 no error
1 WHICHXMS has not been called
2 number of bytes to copy is zero
3 number of bytes to copy is odd
4 offset into XMS block is zero
128 Function not implemented
129 VDISK device driver was detected
142 General driver error
143 Unrecoverable driver error
146 DX is less than /HMAMIN= parameter
160 All extended memory is allocated
161 XMM handles are exhausted
162 Handle is invalid
163 Source handle is invalid
164 Source offset is invalid
165 Destination handle is invalid
166 Destination offset is invalid
167 Length is invalid
168 Overlap in move request is invalid
169 Parity error detected
171 Block locked
SEE ALSO
WHICHXMS, XMSALLOCATE, XMSCOPY, XMSFREE, XMSGET, XMSPUT
EXAMPLE
See XMSCOPY
154
XMSFREE
PROTOTYPE
FUNCTION XMSFREE% (XmsHandle%)
INPUT
XmsHandle - handle of extended memory block to free
OUTPUT
XMSFREE returns 1 if extended memory block was deallocated, 0
otherwise.
USAGE
XMSFREE deallocates the specified extended memory block. All
allocated blocks must be freed before a program terminates or
the memory is lost until the machine is rebooted. Simply
exiting a program will not free allocated extended memory
blocks. If the function was unsuccessful, check XMSERROR for
error codes.
SEE ALSO
WHICHXMS, XMSALLOCATE, XMSCOPY, XMSERROR, XMSGET, XMSPUT
EXAMPLE
See XMSCOPY
155
XMSGET
PROTOTYPE
FUNCTION XMSGET% (SrcXmsHandle%, SrcOffset&, DestVariable%,
NumBytes&)
INPUT
SrcXmsHandle - handle of source extended memory block
SrcOffset - number of bytes from beginning of source memory
block
NumBytes - number of bytes to copy from extended memory to
conventional memory (must be even)
OUTPUT
XMSGET returns 0 if the copy was successful, an error code
otherwise.
DestVariable - integer variable or array holding copied data
USAGE
XMSGET retrieves data from extended memory and places it in
conventional memory. The number of bytes copied must be an
even number and cannot be larger than 65536. The copy may
begin off the beginning of the source extended memory block by
specifying a non zero SrcOffset. If the function was
unsuccessful, check XMSERROR for error codes.
SEE ALSO
WHICHXMS, XMSALLOCATE, XMSCOPY, XMSERROR, XMSFREE, XMSPUT
EXAMPLE
See XMSCOPY
156
XMSPUT
PROTOTYPE
FUNCTION XMSPUT% (SrcVariable%, DestXmsHandle%, DestOffset&,
NumBytes&)
INPUT
SrcVariable - source variable or array in conventional memory
DestXmsHandle - handle of destination extended memory block
DestOffset - number of bytes from beginning of destination
memory block
NumBytes - number of bytes to copy from conventional memory to
extended memory (must be even)
OUTPUT
XMSPUT returns 1 if the copy was successful, 0 otherwise.
USAGE
XMSPUT copies data from conventional memory to extended
memory. The number of bytes copied must be an even number and
cannot be larger than 65536. The destination may begin off
the beginning of the extended memory block by specifying a non
zero DestOffset. If the function was unsuccessful, check
XMSERROR for error codes.
SEE ALSO
WHICHXMS, XMSALLOCATE, XMSCOPY, XMSERROR, XMSFREE, XMSGET
EXAMPLE
See XMSCOPY
157
APPENDIX A. SVGABC.BI
This is the header file containing function declarations and
structure definitions for SVGAQB.LIB and SVGAPV.LIB. This file
should be included in every program that uses this library. To
properly include the header file, place the following line at the
top of the every program module:
REM $INCLUDE: 'SVGABC.BI'
Without these declarations and definitions, the QuickBasic
compiler will be unable to compile any program using the commands
found in this library.
REM SVGAQB/PV GRAPHICS LIBRARY INCLUDE FILE FOR MS QuickBASIC
4.x/VBDOS/PDS
REM COPYRIGHT 1993-1994 BY STEPHEN L. BALKUM AND DANIEL A.
SILL
REM ZEPHYR SOFTWARE P.O. BOX 7704, AUSTIN, TEXAS 78713-7704
REM LAST UPDATE 3/1/94
TYPE P2DType
X AS INTEGER
Y AS INTEGER
END TYPE
TYPE P3Dtype
X AS INTEGER
Y AS INTEGER
Z AS INTEGER
END TYPE
TYPE PROJType
EYEX AS INTEGER
EYEY AS INTEGER
EYEZ AS INTEGER
SCRD AS INTEGER
THETA AS INTEGER
PHI AS INTEGER
END TYPE
DECLARE SUB BLKGET (BYVAL X1%, BYVAL Y1%, BYVAL X2%, BYVAL
Y2%, SEG GfxBlk%)
DECLARE SUB BLKPUT (BYVAL Mode%, BYVAL X%, BYVAL Y%, SEG
GfxBlk%)
DECLARE SUB BLKRESIZE (BYVAL X%, BYVAL Y%, SEG SourceGfxBlk%,
SEG DestGfxBlk%)
DECLARE FUNCTION BLKROTATE% (BYVAL Ang%, BYVAL BackFill%, SEG
SourceGfxBlk%, SEG DestGfxBlk%)
DECLARE FUNCTION BLKROTATESIZE& (BYVAL Ang%, SEG
SourceGfxBlk%)
DECLARE SUB BYTECOPY (SEG SourceArray%, SEG DestArray%, BYVAL
NumOfBytes&)
158
DECLARE SUB D2ROTATE (BYVAL Points%, BYVAL XOrigin%, BYVAL
YOrigin%, BYVAL Ang%, SEG InAry%, SEG OutAry%)
DECLARE SUB D2SCALE (BYVAL Points%, BYVAL XSCALE%, BYVAL
YSCALE%, SEG InAry%, SEG OutAry%)
DECLARE SUB D2TRANSLATE (BYVAL Points%, BYVAL XTRANS%, BYVAL
YTRANS%, SEG InAry%, SEG OutAry%)
DECLARE FUNCTION D3PROJECT% (BYVAL Points%, SEG ProjParms%,
SEG InAry%, SEG OutAry%)
DECLARE SUB D3ROTATE (BYVAL Points%, BYVAL XOrigin%, BYVAL
YOrigin%, BYVAL ZOrigin%, BYVAL ZRAng%, BYVAL YRAng%, BYVAL
XRAng%, SEG InAry%, SEG OutAry%)
DECLARE SUB D3SCALE (BYVAL Points%, BYVAL XSCALE%, BYVAL
YSCALE%, BYVAL ZScale%, SEG InAry%, SEG OutAry%)
DECLARE SUB D3TRANSLATE (BYVAL Points%, BYVAL XTRANS%, BYVAL
YTRANS%, BYVAL ZTrans%, SEG InAry%, SEG OutAry%)
DECLARE SUB DRWBOX (BYVAL Mode%, BYVAL Colr%, BYVAL X1%, BYVAL
Y1%, BYVAL X2%, BYVAL Y2%)
DECLARE SUB DRWCIRCLE (BYVAL Mode%, BYVAL Colr%, BYVAL
CenterX%, BYVAL CenterY%, BYVAL Radius%)
DECLARE SUB DRWELLIPSE (BYVAL Mode%, BYVAL Colr%, BYVAL
CenterX%, BYVAL CenterY%, BYVAL Radiusx%, BYVAL Radiusy%)
DECLARE SUB DRWFILLBOX (BYVAL Mode%, BYVAL Colr%, BYVAL X1%,
BYVAL Y1%, BYVAL X2%, BYVAL Y2%)
DECLARE SUB DRWFILLCIRCLE (BYVAL Mode%, BYVAL Colr%, BYVAL
CenterX%, BYVAL CenterY%, BYVAL Radius%)
DECLARE SUB DRWFILLELLIPSE (BYVAL Mode%, BYVAL Colr%, BYVAL
CenterX%, BYVAL CenterY%, BYVAL Radiusx%, BYVAL Radiusy%)
DECLARE SUB DRWLINE (BYVAL Mode%, BYVAL Colr%, BYVAL X1%,
BYVAL Y1%, BYVAL X2%, BYVAL Y2%)
DECLARE SUB DRWPOINT (BYVAL Mode%, BYVAL Colr%, BYVAL X%,
BYVAL Y%)
DECLARE SUB DRWSTRING (BYVAL Mode%, BYVAL FColr%, BYVAL
BColr%, Strng$, BYVAL X%, BYVAL Y%)
DECLARE SUB DRWSTRINGDN (BYVAL Mode%, BYVAL FColr%, BYVAL
BColr%, Strng$, BYVAL X%, BYVAL Y%)
DECLARE SUB DRWSTRINGLT (BYVAL Mode%, BYVAL FColr%, BYVAL
BColr%, Strng$, BYVAL X%, BYVAL Y%)
DECLARE SUB DRWSTRINGRT (BYVAL Mode%, BYVAL FColr%, BYVAL
BColr%, Strng$, BYVAL X%, BYVAL Y%)
DECLARE SUB FILLAREA (BYVAL Xseed%, BYVAL Yseed%, BYVAL
BorderColr%, BYVAL FillColr%)
DECLARE SUB FILLCOLOR (BYVAL Xseed%, BYVAL Yseed%, BYVAL
OldColr%, BYVAL NewColr%)
DECLARE SUB FILLSCREEN (BYVAL Colr%)
DECLARE SUB FILLPAGE (BYVAL Colr%)
DECLARE SUB FILLVIEW (BYVAL Colr%)
DECLARE SUB FONTGETINFO (SEG WDTH%, SEG HGHT%)
DECLARE SUB FONTSET (FONT$)
DECLARE SUB FONTSYSTEM ()
DECLARE FUNCTION GETARCCOS% (BYVAL Value&)
DECLARE FUNCTION GETARCSIN% (BYVAL Value&)
DECLARE FUNCTION GETARCTAN% (BYVAL Value&)
DECLARE FUNCTION GETCOS& (BYVAL Ang&)
DECLARE FUNCTION GETSIN& (BYVAL Ang&)
159
DECLARE FUNCTION GETTAN& (BYVAL Ang&)
DECLARE FUNCTION GETSQRT& (BYVAL Number&)
DECLARE FUNCTION GETMAXX% ()
DECLARE FUNCTION GETMAXY% ()
DECLARE SUB GETLASTSTRING (SEG StrngGfxBlk%)
DECLARE FUNCTION GETPOINT% (BYVAL X%, BYVAL Y%)
DECLARE FUNCTION GIFMAKE% (FileName$, BYVAL X1%, BYVAL Y1%,
BYVAL X2%, BYVAL Y2%)
DECLARE FUNCTION GIFGETINFO% (Name$, SEG GifXSize%, SEG
GifYSize%, SEG NumColors%, Pal$)
DECLARE FUNCTION GIFPUT% (BYVAL Mode%, BYVAL Xloc%, BYVAL
Yloc%, Name$)
DECLARE SUB JOYSTICKINFO (SEG JAX%, SEG JAY%, SEG JAButs%, SEG
JBX%, SEG JBY%, SEG JBButs%)
DECLARE SUB MOUSEBUTPRESS (BYVAL ReqBut%, SEG Xloc%, SEG
Yloc%, SEG Num%, SEG MButs%)
DECLARE SUB MOUSEBUTRELEASE (BYVAL ReqBut%, SEG Xloc%, SEG
Yloc%, SEG Num%, SEG MButs%)
DECLARE SUB MOUSECURSORDEFAULT ()
DECLARE SUB MOUSECURSORSET (MouseCursor$)
DECLARE SUB MOUSEENTER ()
DECLARE SUB MOUSEEXIT ()
DECLARE SUB MOUSEHIDE ()
DECLARE SUB MOUSEINFO (SEG DrvMajorVer%, SEG DrvMinorVer%, SEG
MouseType%, SEG IRQnumber%)
DECLARE SUB MOUSELOCSET (BYVAL Xloc%, BYVAL Yloc%)
DECLARE SUB MOUSERANGESET (BYVAL X1%, BYVAL Y1%, BYVAL X2%,
BYVAL Y2%)
DECLARE SUB MOUSERESTORESTATE (SEG MouseBuf%)
DECLARE SUB MOUSESAVESTATE (SEG MouseBuf%)
DECLARE SUB MOUSESENSSET (BYVAL Xsens%, BYVAL Ysens%)
DECLARE SUB MOUSESHOW ()
DECLARE SUB MOUSESTATUS (SEG X%, SEG Y%, SEG MButs%)
DECLARE FUNCTION MOUSESTORAGESIZE% ()
DECLARE SUB OVERSCANSET (BYVAL Colr%)
DECLARE FUNCTION PAGEDISPLAY% (BYVAL X%, BYVAL Y%, BYVAL
Page%)
DECLARE FUNCTION PAGEACTIVE% (BYVAL Page%)
DECLARE SUB PALCHGAUTO (PalString$, NewPalString$, BYVAL
FirstColr%, BYVAL LastColr%, BYVAL Speed%)
DECLARE SUB PALCHGSTEP (PalString$, NewPalString$, BYVAL
FirstColr%, BYVAL LastColr%, BYVAL Percent%)
DECLARE SUB PALCOPY (SourcePalString$, DestPalString$, BYVAL
FirstColr%, BYVAL LastColr%)
DECLARE SUB PALDIMSTEP (PalString$, BYVAL FirstColr%, BYVAL
LastColr%, BYVAL Percent%)
DECLARE SUB PALGET (PalString$, BYVAL FirstColr%, BYVAL
LastColr%)
DECLARE SUB PALIOAUTO (PalString$, BYVAL FirstColr%, BYVAL
LastColr%, BYVAL Speed%)
DECLARE SUB PALROTATE (PalString$, BYVAL FirstColr%, BYVAL
LastColr%, BYVAL Shift%)
DECLARE SUB PALSET (PalString$, BYVAL FirstColr%, BYVAL
LastColr%)
160
DECLARE FUNCTION RES320% ()
DECLARE FUNCTION RES640L% ()
DECLARE FUNCTION RES640% ()
DECLARE FUNCTION RES800% ()
DECLARE FUNCTION RES1024% ()
DECLARE FUNCTION RESTEXT% ()
DECLARE SUB SCROLLDN (BYVAL X1%, BYVAL Y1%, BYVAL X2%, BYVAL
Y2%, BYVAL Num%, BYVAL Colr%)
DECLARE SUB SCROLLLT (BYVAL X1%, BYVAL Y1%, BYVAL X2%, BYVAL
Y2%, BYVAL Num%, BYVAL Colr%)
DECLARE SUB SCROLLRT (BYVAL X1%, BYVAL Y1%, BYVAL X2%, BYVAL
Y2%, BYVAL Num%, BYVAL Colr%)
DECLARE SUB SCROLLUP (BYVAL X1%, BYVAL Y1%, BYVAL X2%, BYVAL
Y2%, BYVAL Num%, BYVAL Colr%)
DECLARE SUB SDELAY (BYVAL Count%)
DECLARE SUB SETCARD (BYVAL CHIP%, BYVAL MEM%)
DECLARE SUB SETVIEW (BYVAL X1%, BYVAL Y1%, BYVAL X2%, BYVAL
Y2%)
DECLARE SUB SPRITEGAP (BYVAL TransColr%, BYVAL X%, BYVAL Y%,
SEG SpriteGfxBlk%, SEG BkgndGfxBlk%)
DECLARE SUB SPRITEGET (BYVAL TransColr%, BYVAL X%, BYVAL Y%,
SEG SpriteGfxBlk%, SEG BkgndGfxBlk%)
DECLARE SUB SPRITEPUT (BYVAL Mode%, BYVAL TransColr%, BYVAL
X%, BYVAL Y%, SEG SpriteGfxBlk%)
DECLARE FUNCTION SPRITECOLLDETECT% (BYVAL TransColr%, BYVAL
Sprite1LocX%, BYVAL Sprite1LocY%, BYVAL Sprite2LocX%, BYVAL
Sprite2LocY%, SEG Sprite1GfxBlk%, SEG Sprite2GfxBlk%)
DECLARE FUNCTION VIDEOMODEGET% ()
DECLARE SUB VIDEOMODESET (BYVAL Mode%)
DECLARE SUB VIDEOOFF ()
DECLARE SUB VIDEOON ()
DECLARE FUNCTION WHICHCPU% ()
DECLARE FUNCTION WHICHJOYSTICK% ()
DECLARE FUNCTION WHICHMEM% ()
DECLARE FUNCTION WHICHMOUSE% ()
DECLARE FUNCTION WHICHVGA% ()
DECLARE FUNCTION WHICHXMS% (SEG XmsKbytesAvailable%, SEG
XmsHandlesAvailable%)
DECLARE FUNCTION XMSALLOCATE% (BYVAL ReqKbytesOfMem%)
DECLARE FUNCTION XMSERROR% ()
DECLARE FUNCTION XMSFREE% (BYVAL XmsHandle%)
DECLARE FUNCTION XMSGET% (BYVAL XmsHandle%, BYVAL
OffsetIntoXms&, SEG DestVar%, BYVAL NumOfBytes&)
DECLARE FUNCTION XMSPUT% (SEG SourceVar%, BYVAL XmsHandle%,
BYVAL OffsetIntoXms&, BYVAL NumOfBytes&)
DECLARE FUNCTION XMSCOPY% (BYVAL XmsHandle1%, BYVAL
OffsetIntoXms1&, BYVAL XmsHandle2%, BYVAL OffsetIntoXms2&,
BYVAL NumOfBytes&)
REM $DYNAMIC
161
APPENDIX B. JOYSTICK PORTS AND Y-CABLES
SCHEMATIC WIRING DIAGRAM FOR A STANDARD JOYSTICK PORT
DB15 male
connector
Joystick B ___ Joystick A
__/ |
/ o | 1 -------------------+
+------------------ 9 | o | ___Button A |
| Button A___ | o | 2 --o o-+ |
| +-o o-- 10 | o | | X Axis |
| X Axis | | o | 3 -------------+ |
| +------------ 11 | o | | | |
| | | | o | 4 ------+ | |
+--/\/\/\ +------ 12 | o | | /\/\/\--+
| | | o | 5 | |
| +------------ 13 | o | | |
| | | ___ | o | 6 -------------+ |
| | +-o o-- 14 | o | ___ | | |
| | Button B | o | 7 --o o-+ | |
| | 15 | o | Button B /\/\/\--+
+--/\/\/\ \__ o | 8 Y Axis
Y Axis \___|
Notes:
1)This diagram comes with NO warranties expressed or implied.
It is provided for information only. In no event shall
Stephen L. Balkum, Daniel A. Sill or Zephyr Software be held
liable for damages resulting from use, misuse, or inability to
use this information.
2)The x and y axis potentiometers have a typical range of 0 to
100k ohms. Buttons are normally open and close when pressed.
3)This diagram is correct for joystick ports that conform to the
standard set forth by IBM. Some specialty joystick cards
provide separate A and B joystick connectors. For these
cards, both connectors are wired to pins 1 through 8 as shown
in the diagram.
4)Many 'Super I/O' boards (2H/2F/2S/1P/1G) equipped with a
joystick port will support only one joystick. On these cards,
pins 9 through 15 are not used.
5)Commercially available joysticks are wired to use pins 1
through 8 and, therefore, will always be 'Joystick A' if
plugged directly into a dual joystick port connector.
6)Many sound cards provide joystick ports; however, their
connector wiring does not always conform to the standard shown
above. Some of these connectors may be used for other
162
purposes such as a MIDI port. See the documentation that
comes with the sound card.
7)If there is more than one joystick port on a computer
configured to operate the same joystick, only ONE port should
be enabled at any given time for proper operation. Disable
all but one joystick port. For example, if the computer has
both a Super I/O card and a sound card, the joystick port on
the Super I/O card should be disabled since the sound card's
port probably supports two joysticks and the I/O card supports
only one.
163
SCHEMATIC WIRING DIAGRAM FOR A JOYSTICK Y-CABLE
___
DB15 male __/ |
connector to / o | 1 --------+
Joystick Port 9 | o | |
on computer | o | 2 --------|-+
+-------- 10 | o | | |
| | o | 3 --------|-|-+
| +------ 11 | o | | | |
| | | o | 4 --------|-|-|-+
| | 12 | o | | | | |
| | | o | 5 | | | |
| | +---- 13 | o | | | | |
| | | | o | 6 --------|-|-|-|-+
| | | +-- 14 | o | | | | | |
| | | | | o | 7 --------|-|-|-|-|-+
| | | | 15 | o | | | | | | |
| | | | \__ o | 8 | | | | | |
| | | | \___| | | | | | |
| | | | | | | | | |
| | | | | | | | | |
| | | | +-----------------------+ | | | | |
| | | | | | | | | | |
| | | | | +---------------------|-|-|-+ | |
| | | | | | | | | | | |
| | | | | | | | | | | |
DB15 female | | | | | | DB15 female | | | | | |
connector to | | | | | | connector to | | | | | |
Joystick B | | | | | | Joystick A | | | | | |
___ | | | | | | ___ | | | | | |
__/ | | | | | | | __/ | | | | | | |
/ o | 1 ---|-|-|-|--+ | / o | 1 --+ | | | | |
9 | o | | | | | | 9 | o | | | | | |
| o | 2 ---+ | | | | | o | 2 ----+ | | | |
10 | o | | | | | 10 | o | | | | |
| o | 3 -----+ | | | | o | 3 ------+ | | |
11 | o | | | | 11 | o | | | |
| o | 4 -------|-|----+ | o | 4 --------+ | |
12 | o | | | 12 | o | | |
| o | 5 | | | o | 5 | |
13 | o | | | 13 | o | | |
| o | 6 -------+ | | o | 6 ----------+ |
14 | o | | 14 | o | |
| o | 7 ---------+ | o | 7 ------------+
15 | o | 15 | o |
\__ o | 8 \__ o | 8
\___| \___|
Notes:
1)This diagram comes with NO warranties expressed or implied.
It is provided for information only. In no event shall
Stephen L. Balkum, Daniel A. Sill or Zephyr Software be held
164
liable for damages resulting from use, misuse, or inability to
use this information.
2)This cable has worked with a standard joystick port connector,
a Sound Blaster port connector, and a Sound Blaster Pro
joystick port connector.
165