home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
The Devil's Doorknob BBS Capture (1996-2003)
/
devilsdoorknobbbscapture1996-2003.iso
/
Dloads
/
PROGRAMM
/
FGL112B.ZIP
/
USER11.DOC
< prev
next >
Wrap
Text File
|
1992-10-05
|
22KB
|
521 lines
Chapter 11
Special Effects
200 Fastgraph User's Guide
Overview
This chapter will discuss the Fastgraph routines that help produce
special visual effects. These include the ability to dissolve the screen
contents in small increments, scroll areas of the screen, and change the
physical origin of the screen. The accompanying example programs illustrate
how to use these routines to produce some interesting effects.
Screen Dissolving
Screen dissolving is the process of replacing the entire screen contents
in random small increments instead of all at once. Fastgraph includes two
routines, fg_fadeout and fg_fadein, for this purpose. The fg_fadeout routine
incrementally replaces the visual page contents with pixels of the current
color, while fg_fadein incrementally replaces the visual page contents with
the hidden page contents (that is, the page defined in the most recent call
to fg_sethpage). Both routines accept an integer argument that defines the
delay between each incremental replacement. A value of zero means to perform
the replacement as quickly as possible, while 1 is slightly slower, 2 is
slower yet, and so forth. The fg_fadeout and fg_fadein routines have no
effect in text video modes.
Example 11-1 shows how to use the fg_fadeout routine. The program,
which runs in any graphics video mode, first fills the screen with a
rectangle of color 2. After waiting for a keystroke, the program
incrementally replaces the screen contents with pixels of color 15 (the
current color index when fg_fadeout is called). After another keystroke, the
program exits gracefully.
Example 11-1.
#include <fastgraf.h>
void main(void);
void main()
{
int old_mode;
old_mode = fg_getmode();
fg_setmode(fg_automode());
fg_setcolor(2);
fg_rect(0,fg_getmaxx(),0,fg_getmaxy());
fg_waitkey();
fg_setcolor(15);
fg_fadeout(0);
fg_waitkey();
fg_setmode(old_mode);
fg_reset();
}
Example 11-2 shows how to use the fg_fadein routine in any 320 by 200
color graphics video mode. The program first fills the screen with a
Chapter 11: Special Effects 201
rectangle of color 2 and then fills video page 1 with a rectangle of color 1.
After waiting for a keystroke, the program incrementally transfers the
contents of page 1 to the visual page. After the call to fg_fadein, both
page 0 (the visual page) and page 1 (the hidden page) will contain rectangles
of color 1 that fill the entire video page. Finally, the program waits for
another keystroke before returning to DOS.
Example 11-2.
#include <fastgraf.h>
#include <stdio.h>
#include <stdlib.h>
void main(void);
void main()
{
int new_mode, old_mode;
new_mode = fg_bestmode(320,200,2);
if (new_mode < 0 || new_mode == 12) {
printf("This program requires a 320 ");
printf("x 200 color graphics mode.\n");
exit(1);
}
old_mode = fg_getmode();
fg_setmode(new_mode);
fg_allocate(1);
fg_sethpage(1);
fg_setcolor(2);
fg_rect(0,319,0,199);
fg_setpage(1);
fg_setcolor(1);
fg_rect(0,319,0,199);
fg_waitkey();
fg_fadein(0);
fg_waitkey();
fg_freepage(1);
fg_setmode(old_mode);
fg_reset();
}
You also can produce some appealing visual effects by replacing the
screen contents in a non-random fashion using the fg_restore or fg_transfer
routines. For example, you could copy the hidden page contents to the visual
page with a through a series of concentric rectangular areas, each slightly
larger than the previous, until the entire screen is copied. Another
interesting effect is to start around the screen perimeter and proceed toward
the screen center, thus producing a "snake-like" effect. Experimenting with
such techniques may reveal other effects that suit your application.
202 Fastgraph User's Guide
Scrolling
Another useful effect is scrolling, and Fastgraph provides a routine
that performs vertical scrolling within a given region of the active video
page. The fg_scroll routine scrolls a region defined in screen space or
character space. It can scroll up or down and offers two types of scrolling:
circular and end-off. In circular scrolling, rows that scroll off one edge
of the defined region appear at its opposite edge. In end-off scrolling,
such rows are simply wind up above or below the scrolling area. The
following diagrams illustrate the two types of scrolling.
end-off scrolling circular scrolling
before after before after
C B
A A
A A
B B
In these diagrams, the area bounded by the double lines is the scrolling
region, as specified in the call to fg_scroll. Also, the scrolling direction
is assumed to be down (that is, toward the bottom of the screen), and the
number of rows to scroll is the height of the area designated B. The number
of rows to scroll is often called the scrolling increment.
For the end-off scrolling example, the scrolling operation transfers
region A downward so part of it is copied into area B. The area C (which is
the same size as area B) at the top of the scrolling region is filled with
pixels of the current color index (as defined in the most recent call to
fg_setcolor), and the original contents of area B are lost. The circular
scrolling example also copies region A downward into the original area B.
Unlike end-off scrolling, however, circular scrolling preserves the area B by
copying it to the opposite edge of the scrolling region.
The fg_scroll routine takes six arguments. The first four define the
scrolling region in the order minimum x coordinate, maximum x coordinate,
minimum y coordinate, and maximum y coordinate. In graphics video modes, the
x coordinates are extended by byte boundaries (see page 174) if needed. The
fifth argument is the scrolling increment. It specifies the number of rows
to scroll. If it is positive, the scrolling direction is toward the bottom
of the screen; if it is negative, the scrolling direction is toward the top
of the screen. The sixth and final argument specifies the scroll type. If
this value is zero, the scroll will be circular; if it is any other value,
the scroll will be end-off. If the scroll type is circular, Fastgraph will
use the hidden page (as defined in the most recent call to fg_sethpage) as a
workspace (more specifically, the area bounded by the scrolling region
extremes on the hidden page will be used). We'll now present three example
programs that use the fg_scroll routine.
Example 11-3 runs in any 320 by 200 graphics video mode. The program
displays two lines of text ("line one" and "line two") in the upper left
corner of the screen against a white background. It then uses the fg_scroll
routine to move the second line down four pixel rows using an end-off scroll.
After waiting for a keystroke, the program again uses fg_scroll to move the
Chapter 11: Special Effects 203
text back to its original position. Note especially how the fg_setcolor
routine appears before the first call to fg_scroll to replace the "scrolled
off" rows with pixels of color 15, thus preserving the white background.
Example 11-3.
#include <fastgraf.h>
#include <stdio.h>
#include <stdlib.h>
void main(void);
void main()
{
int new_mode, old_mode;
new_mode = fg_bestmode(320,200,1);
if (new_mode < 0 || new_mode == 12) {
printf("This program requires a 320 ");
printf("x 200 color graphics mode.\n");
exit(1);
}
old_mode = fg_getmode();
fg_setmode(new_mode);
fg_setcolor(15);
fg_rect(0,319,0,199);
fg_setcolor(10);
fg_text("line one",8);
fg_locate(1,0);
fg_text("line two",8);
fg_waitkey();
fg_setcolor(15);
fg_scroll(0,63,8,15,4,1);
fg_waitkey();
fg_scroll(0,63,12,19,-4,1);
fg_waitkey();
fg_setmode(old_mode);
fg_reset();
}
Example 11-4 is similar to example 11-3, but it runs in the 80-column
color text mode (mode 3). In text modes, we cannot scroll half a character
row (four pixels) as in example 11-3, so the program scrolls the minimum one
row instead.
Example 11-4.
#include <fastgraf.h>
void main(void);
void main()
{
int old_mode;
204 Fastgraph User's Guide
old_mode = fg_getmode();
fg_setmode(3);
fg_cursor(0);
fg_setcolor(7);
fg_rect(0,79,0,24);
fg_setattr(10,7,0);
fg_text("line one",8);
fg_locate(1,0);
fg_text("line two",8);
fg_waitkey();
fg_setcolor(7);
fg_scroll(0,7,1,1,1,1);
fg_waitkey();
fg_scroll(0,7,2,2,-1,1);
fg_waitkey();
fg_setmode(old_mode);
fg_reset();
}
Example 11-5, the final scrolling example, demonstrates a circular
scroll. The program runs in any 320 by 200 color graphics video mode; note
the use of video page 1 for the workspace required when the fg_scroll routine
performs a circular scroll. The program first fills the screen with a light
blue rectangle (cyan in CGA), displays a smaller white rectangle in the
center of the screen, and then uses fg_move, fg_draw, and fg_paint to display
a light green star (magenta in CGA) within the white rectangle. The program
executes a while loop to scroll the star upward in four pixel increments.
Because the scroll is circular, rows of the star that "scroll off" the top
edge of the white rectangle (whose height is the same as the scrolling
region) reappear at its bottom edge. The use of fg_waitfor within the loop
simply slows down the scroll. The scrolling continues until any key is
pressed.
Example 11-5.
#include <conio.h>
#include <fastgraf.h>
#include <stdio.h>
#include <stdlib.h>
void main(void);
void main()
{
int new_mode, old_mode;
new_mode = fg_bestmode(320,200,2);
if (new_mode < 0 || new_mode == 12) {
printf("This program requires a 320 ");
printf("x 200 color graphics mode.\n");
exit(1);
}
old_mode = fg_getmode();
fg_setmode(new_mode);
Chapter 11: Special Effects 205
fg_allocate(1);
fg_sethpage(1);
fg_setcolor(9);
fg_rect(0,319,0,199);
fg_setcolor(15);
fg_rect(132,188,50,150);
fg_setcolor(10);
fg_move(160,67);
fg_draw(175,107);
fg_draw(140,82);
fg_draw(180,82);
fg_draw(145,107);
fg_draw(160,67);
fg_paint(160,77);
fg_paint(150,87);
fg_paint(160,87);
fg_paint(170,87);
fg_paint(155,97);
fg_paint(165,97);
while (kbhit() == 0) {
fg_waitfor(1);
fg_scroll(136,184,50,150,-4,0);
}
fg_waitkey();
fg_freepage(1);
fg_setmode(old_mode);
fg_reset();
}
Changing the Screen Origin
Fastgraph includes two routines for changing the screen origin. By
changing the screen origin, we simply mean defining the (x,y) coordinate of
the upper left corner of the display area. The fg_pan routine performs this
function in screen space, while the fg_panw routine does in world space.
Neither routine changes the graphics cursor position.
Each of these routines has two arguments that specify the x and y
coordinates of the screen origin. For the fg_pan routine, the arguments are
integer quantities. For the fg_panw routine, they are floating point
quantities.
In the native EGA and VGA graphics modes (modes 13 through 18), you can
set the screen origin to any (x,y) coordinate position (that is, to any
pixel). In the other graphics modes, certain restrictions exist, as imposed
by specific video hardware. These constraints limit the coordinate positions
that can be used as the screen origin. Fastgraph compensates for these
restrictions by reducing the specified x and y coordinates to values that are
acceptable to the current video mode, as shown in the following table.
206 Fastgraph User's Guide
x will be reduced y will be reduced
video mode to a multiple of: to a multiple of:
4, 5 8 2
6 16 2
9 4 4
11 8 4
12 4 2 or 3
19 to 23 4 1
For example, in modes 4 and 5, the x coordinate will be reduced to a multiple
of 8 pixels, and the y coordinate will be reduced to a multiple of 2 pixels.
In the Hercules low resolution mode (mode 12), the y coordinate reduction
depends on whether or not the specified pixel row is scan doubled.
Example 11-6 shows a useful effect that can be made with the fg_pan or
fg_panw routines. This program uses the fg_automode routine to select a
video mode and then draws an unfilled rectangle in color 15 (bright white).
The top and bottom sides of the rectangle are intentionally drawn just
smaller than the physical screen size. After waiting for a keystroke, the
program uses a for loop to make the rectangle jiggle up and down. The
rectangle moves because the fg_pan routine is called inside the loop to
switch the screen origin between the rectangle's upper left corner and the
original origin. Note also the use of the fg_waitfor routine to cause slight
delays after each call to fg_pan. If we didn't use fg_waitfor, the changing
of the origin would occur so rapidly we wouldn't notice the effect. Finally,
the program restores the original video mode and screen attributes before
returning to DOS.
Example 11-6.
#include <fastgraf.h>
#include <stdio.h>
#include <stdlib.h>
void main(void);
#define DELAY 2
#define JUMP 4
void main()
{
int i;
int old_mode;
old_mode = fg_getmode();
fg_setmode(fg_automode());
fg_setcolor(15);
fg_move(0,JUMP);
fg_draw(fg_getmaxx(),JUMP);
fg_draw(fg_getmaxx(),fg_getmaxy()-JUMP);
fg_draw(0,fg_getmaxy()-JUMP);
fg_draw(0,JUMP);
fg_waitkey();
Chapter 11: Special Effects 207
for (i = 0; i < 6; i++) {
fg_pan(0,JUMP);
fg_waitfor(DELAY);
fg_pan(0,0);
fg_waitfor(DELAY);
}
fg_setmode(old_mode);
fg_reset();
}
The real power of the fg_pan routine becomes clear when it is used with
the fg_resize routine to perform smooth panning. Recall from Chapter 7 that
fg_resize changes the video page dimensions in native EGA graphics modes
(modes 13 through 16), native VGA graphics modes (modes 17 and 18), and the
extended VGA graphics modes (modes 20 through 23). We'll now present an
example that shows how to use these two routines to perform panning in the
low-resolution EGA graphics mode (mode 13). The method it uses also would
work in any mode that supports video page resizing.
Example 11-7 begins by establishing the video mode and then immediately
calls fg_resize to increase the video page size to 640 x 400 pixels. Thus,
the video page is now four times its original size. Following this, the
program fills the page (the entire page, not just what is displayed) with a
bright green rectangle with a white border around it. It then displays the
message "Press arrow keys to pan" as close as possible to the center of the
page.
The main part of the program is a loop that accepts keystrokes and then
calls fg_pan to perform the panning one pixel at a time. When you press any
of the four arrow keys, the program adjusts the x and y coordinates for the
screen origin as directed. For example, pressing the up arrow key scrolls
the screen upward one pixel. Note that when we reach the edge of the video
page, the program prevents further scrolling in that direction. This process
continues until you press the Esc key, at which time the program restores the
original video mode and screen attributes before exiting.
Example 11-7.
#include <fastgraf.h>
void main(void);
void main()
{
unsigned char key, aux;
int old_mode;
int x, y;
old_mode = fg_getmode();
fg_setmode(13);
fg_resize(640,400);
fg_setcolor(2);
fg_rect(0,fg_getmaxx(),0,fg_getmaxy());
fg_setcolor(15);
fg_box(0,fg_getmaxx(),0,fg_getmaxy());
208 Fastgraph User's Guide
fg_locate(24,28);
fg_text("Press arrow keys to pan.",24);
x = 0;
y = 0;
do {
fg_getkey(&key,&aux);
if (aux == 72 && y < 200)
y++;
else if (aux == 75 && x < 320)
x++;
else if (aux == 77 && x > 0)
x--;
else if (aux == 80 && y > 0)
y--;
fg_pan(x,y);
} while (key != 27);
fg_setmode(old_mode);
fg_reset();
}
Summary of Special Effects Routines
This section summarizes the functional descriptions of the Fastgraph
routines presented in this chapter. More detailed information about these
routines, including their arguments and return values, may be found in the
Fastgraph Reference Manual.
FG_FADEIN incrementally replaces the visual page contents with the
hidden page contents. This routine has no effect in text video modes.
FG_FADEOUT incrementally replaces the visual page contents with pixels
of the current color. This routine has no effect in text video modes.
FG_PAN changes the screen origin (the upper left corner of the screen)
to the specified screen space coordinates. This routine has no effect in
text video modes.
FG_PANW is the world space version of the fg_pan routine.
FG_RESIZE changes the dimensions of a video page in EGA and VGA graphics
modes.
FG_SCROLL vertically scrolls a region of the active video page. The
scrolling may be done either up or down, using either an end-off or circular
method. Circular scrolling uses part of the hidden page as a temporary
workspace.