//**************************************************************************
// IMAGES.CPP -source file for basic video operations in mode 0x13. *
// Copyright 1991 by the Gamers Programming Workshop, a function of the *
// GAMERS forum, Compuserve. For more info e-mail 76605,2346. *
// *
// License is granted for use or modification of this code as long as *
// this notice remains intact, and all improvements are listed in the *
// version history below, and uploaded to the GAMERS forum. This code *
// may not be used for any commercial purpose. *
// *
// PCX stuff adapted from "BitMapped Graphics" by Steve Rimmer (1990 *
// Windcrest) *
//**************************************************************************
//**************************************************************************
// Version history: *
// *
// Version 1.0 *
// Developed: May 2, 1991 *
// Author: Mark Betz, 76605, 2346 *
// Last update: July 5, 1991 *
//**************************************************************************
// INCLUDES ****************************************************************
#include <stdio.h>
#include <conio.h>
#include <dos.h>
#include <mem.h>
#include <alloc.h>
#include <io.h>
#include <fcntl.h>
#include "images.hpp"
#include "keyboard.hpp"
// *************************************************************************
// local constants *********************************************************
const int DacWrite = 0x3C8; // DAC write index register
const int DacRead = 0x3C7; // DAC read index register
const int DacData = 0x3C9; // DAC data register
const int input_status_1 = 0x3DA; // Port addr. of VGA input status 1 reg.
const int vbi_mask = 0x8; // test bit 3 of input_status_1
// *************************************************************************
// Variables ***************************************************************
static unsigned int GRAPH_SEG = 0xA000; // segment for video operations
static p_rec current; // palette record for fades
// *************************************************************************
// *************************************************************************
// *************************************************************************
// NOTE:
// The assembler functions in this module do not save any of the
// registers they use, with the exception of di and si, which are
// handled by the standard stack frame. When calling them expect
// register values to be altered.
//
// *************************************************************************
// *************************************************************************
// *************************************************************************
// reporterr() should be called anytime one of the routines in this module
// returns a code other that NoErr. Pass it the error code returned by the
// offending subroutine, and a max. 30 character string describing the loc-
// ation of the error.
// *************************************************************************
void reporterr(char type, char mess[30])
{
settextmode();
sound(300);
delay(200);
sound(250);
delay(150);
nosound();
switch (type)
{
case MemErr : printf("An error occured allocating memory...");
break;
case FileReadErr : printf("An error occured reading a file...");
break;
case FileWriteErr : printf("An error occured writing a file...");
break;
case FileMakeErr : printf("An error occured creating a file...");
break;
case FileOpenErr : printf("An error occured opening a file...");
break;
case FileFormatErr : printf("A file format error has occured...");
break;
case SecondaryErr : printf("An error has occured in a subroutine...");
break;
case UnknownErr : printf("An unknown error has occured...");
}
printf(" error occured in ");
printf(mess);
return;
}
// *************************************************************************
// UnpackPcx() unpacks the RLE encoded PCX data from a file if pcx != NULL,
// or the source buffer if pcx==NULL, to the Dest buffer. Unpacks NumBytes
// bytes of decompressed data. (max 64000) This is a pretty dumb routine.
// It's fast, but it expects you to know the uncompressed size of the data
// (the NumBytes parameter), and you have to do all of the file and buffer
// set-up elsewhere. Basically it's a core decoding engine. The InitPcxFile()
// function above is provided for opening a PCX file and saving the header
// and palette in data. For buffering and decoding of pcx's with various
// fade types see the fadeinpcx() function below.
// *************************************************************************
// *************************************************************************
// NOTE: this function isn't called by the PVC class objects when they dis-
// play themselves. It is an earlier version of the algrotihm, and they have
// their own version of it. I left this in in case anyone wanted to use it.
// **************************************************************************
void unpackpcx(FILE *pcx, const char far *source, char far *dest,
unsigned int num_bytes)
{
unsigned int bytes=0; // counts unpacked bytes
unsigned char c; // byte being processed
unsigned int src_cntr=0; // pointer into source buffer
unsigned int runlen; // length of packet
do
{
// get a key byte
if (pcx!=NULL)
c=fgetc(pcx);
else
c=source[src_cntr++] & 0xff;
// check if it's a packet
if ((c & 0xc0) == 0xc0)
{
// and off the high bits
runlen = (c & 0x3f);
// get the run value
if (pcx!=NULL)
c=fgetc(pcx);
else
c = source[src_cntr++];
// run it out
while(runlen--) (dest[bytes++]=c);
}
else
dest[bytes++]=c;
} while (bytes<num_bytes);
}
// *************************************************************************
// sets the segment address that will be used in all graphics operations
// within this module. Can be used to operate on a buffer offscreen. This
// is a fairly powerfull feature, as any of the functions provided which
// write or read video memory will act on the segment contained in GRAPH_
// SEG. If you allocate a 64k buffer, and call _setgraphseg() with it's
// segment you can then create the screen there, and block copy it to
// video ram when you're finished.
// *************************************************************************
void setgraphseg(unsigned int newseg)
{
GRAPH_SEG = newseg;
}
// *************************************************************************
// call bios interrupt 0x10, function 13, subfunction 00 to set up mode
// 0x13 graphics.
// *************************************************************************
void setgraphmode()
{
asm {
xor ah, ah // zero out ah, subfunction 00
mov al, 0x13 // function 0x13
int 0x10 // interrupt 0x10
}
}
// *************************************************************************
// call bios interrupt 0x10 in same manner as previous function to restore
// text mode
// *************************************************************************
void settextmode()
{
asm {
xor ah, ah
mov al, 0x03
int 0x10
}
}
// **************************************************************************
// wait_vbi() waits twice for the vertical blanking interval. Once to make
// sure any current vbi is completed, and once for the start of the next vbi
// **************************************************************************
void wait_vbi()
{
asm mov dx, input_status_1;
test_1:
asm {
in al, dx
test al,0x8
jnz test_1
}
test_2:
asm {
in al, dx
test al,0x8
jz test_2
}
}
// *************************************************************************
// loads the vga dac by direct method via the DAC access ports. Disables
// interrupts during load of each triplet. Does not do snow checking. Call
// with start = first register to load, number = number of registers to
// load, and palette pointing to a structure of type PRec containing the
// palette data. If start or number out of range, or palette is null then
// the function returns.
// *************************************************************************
void loadpalette(int start, int number, const p_rec palette)
{
unsigned int i;
if ((start>256) || (start<0) || ((start+number)>256))
return;
for (i=start;i<(start+number);i++)
{
asm cli;
outportb(DacWrite,i);
outportb(DacData,palette[i][Red]);
outportb(DacData,palette[i][Green]);
outportb(DacData,palette[i][Blue]);
asm sti;
}
}
// *************************************************************************
// same as previous function only reads the dac data into the supplied
// palette structure.
// *************************************************************************
void readpalette(int start, int number, p_rec palette)
{
unsigned int i;
if ((start>256) | (start<0) | ((start+number)>256))
return;
for (i=start;i<(start+number);i++)
{
asm cli;
outportb(DacRead,i);
palette[i][Red] = inportb(DacData);
palette[i][Green] = inportb(DacData);
palette[i][Blue] = inportb(DacData);
asm sti;
}
}
// **************************************************************************
// clears a range of palette registers to zero
// **************************************************************************
void clrpalette(int start, int number)
{
unsigned int i;
if ((start>256) | (start<0) | ((start+number)>256))
return;
for (i=start;i<(start+number);i++)
{
asm cli;
outportb(DacWrite,i);
outportb(DacData,0);
outportb(DacData,0);
outportb(DacData,0);
asm sti;
}
}
// **************************************************************************
// fadepalettein() fades the dac palette from 0 (black) to the default pal-
// ette values passed in palette structure. Fade is done in 64 passes, and
// is very smooth. Operates on count registers starting with register start.
// NOTE: this funtion expect the dac palette registers to be zero'd before
// it is called. Call clrpalette() to clear the registers.
// **************************************************************************
void fadepalettein(int start, int count, const p_rec palette)
{
int i, j, cycle;
memset((void *)current,0,sizeof(p_rec));
for (cycle=0;cycle<64;cycle++)
{
i=start;
wait_vbi();
outportb(DacWrite,i);
asm cli;
for (;i<((start+count)/2);i++)
{
for (j=0;j<3;j++)
{
if ((64-cycle)<=palette[i][j])
current[i][j]++;
outportb(DacData,current[i][j]);
}
}
asm sti;
wait_vbi();
asm cli;
for (;i<(start+count);i++)
{
for (j=0;j<3;j++)
{
if ((64-cycle)<=palette[i][j])
current[i][j]++;
outportb(DacData,current[i][j]);
}
}
asm sti;
}
}
// **************************************************************************
// fadepaletteout() fades the current palette to black. It operates on count
// registers starting with register start. NOTE: this function destroys the
// current contents of temp_pal (images.cpp internal palette structure).
// **************************************************************************
void fadepaletteout(int start, int count)
{
int i, j, cycle;
readpalette(0,256,current);
for (cycle=64;cycle>0;cycle--)
{
i=start;
wait_vbi();
outportb(DacWrite,i);
asm cli;
for (;i<((start+count)/2);i++)
{
for (j=0;j<3;j++)
{
if (current[i][j]!=0)
current[i][j]--;
outportb(DacData,current[i][j]);
}
}
asm sti;
wait_vbi();
asm cli;
for (;i<(start+count);i++)
{
for (j=0;j<3;j++)
{
if (current[i][j]!=0)
current[i][j]--;
outportb(DacData,current[i][j]);
}
}
asm sti;
}
clearscr(0);
}
// *************************************************************************
// clear the graphics screen to the color provided
// *************************************************************************
void clearscr(int color)
{
asm {
mov es, GRAPH_SEG
xor di, di
mov ax, color
mov cx, 32000
rep stosw
}
}
// *************************************************************************
// fill the rectangular area bounded by (tlx,tly)(brx,bry) with color.
// tlx = top left x, tly = top left y, brx = bottom right x, bry = bottom
// right y.
//
// This function needs to be recoded in assembler
// *************************************************************************
void barfill(int tlx, int tly, int brx, int bry, int color)
{
int row;
void far *line;
for (row=tly;row<bry;row++)
{
line = MK_FP(GRAPH_SEG,((row*320)+tlx));
_fmemset(line,color,(brx-tlx));
}
}
// *************************************************************************
// set the pixel at coordinate x,y to color
// This could be translated into assembler, but is probably fast enough
// *************************************************************************
void writepixel(int x, int y, int color)
{
*(char far *)MK_FP(GRAPH_SEG,(y*320)+x)=color;
}
// *************************************************************************
// read the color of the pixel at coordinate x,y
// Could also be done in assembler, but may be fast enough as is
// *************************************************************************
char readpixel(int x, int y)
{
return(*(char far *)MK_FP(GRAPH_SEG,(y*320)+x));
}
// *************************************************************************
// returns a void type pointer to video memory at pixel coordinate x,y
// *************************************************************************
void far *xy_to_ptr(int x, int y)
{
return((char *)MK_FP(GRAPH_SEG,(y*320)+x));
}
// *************************************************************************
// The following three functions make up the line drawing routine
//
// Draws a line in vga mode 13h only from (x0,y0) to (x1,y1) in color color.
// Drawing code adapted from Power Graphics Programming, Michael Abrash
// *************************************************************************
// *************************************************************************
// Octant0() and Octant1() are support functions for line()
// Adapted from "Power Graphics Programming", Michael Abrash.
// *************************************************************************
void static near Octant0(unsigned int x0,unsigned int y0,unsigned int deltaX,
unsigned int deltaY, int Xdirection, int color)
{
int deltaYx2;
int deltaYx2minusdeltaXx2;
int errorterm;
deltaYx2 = deltaY*2;
deltaYx2minusdeltaXx2=deltaYx2-(int)(deltaX*2);
errorterm=deltaYx2-(int)deltaX;
writepixel(x0,y0,color);
while (deltaX--)
{
if (errorterm>=0)
{
y0++;
errorterm+=deltaYx2minusdeltaXx2;
}
else
errorterm+=deltaYx2;
x0+=Xdirection;
writepixel(x0,y0,color);
}
}
void static near Octant1(unsigned int x0,unsigned int y0,unsigned int deltaX,
unsigned int deltaY, int Xdirection, int color)
{
int deltaXx2;
int deltaXx2minusdeltaYx2;
int errorterm;
deltaXx2=deltaX*2;
deltaXx2minusdeltaYx2=deltaXx2-(int)(deltaY*2);
errorterm=deltaXx2-(int)deltaY;
writepixel(x0,y0,color);
while (deltaY--)
{
if (errorterm>=0)
{
x0+=Xdirection;
errorterm+=deltaXx2minusdeltaYx2;
}
else
errorterm+=deltaXx2;
y0++;
writepixel(x0,y0,color);
}
}
// **************************************************************************
// takes the initial call and manages the line drawing
// Adapted from "Power Graphics Programming", Michael Abrash
// **************************************************************************
void line(int x0, int y0, int x1, int y1, int color)
{
int deltaX, deltaY;
int temp;
if (y0>y1)
{
temp=y0;
y0=y1;
y1=temp;
temp=x0;
x0=x1;
x1=temp;
}
deltaX=x1-x0;
deltaY=y1-y0;
if (deltaX > 0)
{
if (deltaX>deltaY)
Octant0(x0,y0,deltaX,deltaY,1,color);
else
Octant1(x0,y0,deltaX,deltaY,1,color);
}
else
{
deltaX= -deltaX;
if (deltaX > deltaY)
Octant0(x0,y0,deltaX,deltaY,-1,color);
else
Octant1(x0,y0,deltaX,deltaY,-1,color);
}
}
// **************************************************************************
// getimage() grabs the pixel values in the rectangle marked by (x0,y0) on
// the top left, and (x1,y1) on the bottom right. The data is placed in buff.
//
// NOTE: This function needs translating into assembler
// **************************************************************************
void getimage(int x0, int y0, int x1, int y1, char far *buff)
{
int i;
int deltaY=(y1-y0);
int xdim=(x1-x0);
for (i=0;i<=deltaY;i++)
{
_fmemcpy((void *)&buff[i*xdim],xy_to_ptr(x0,(y0+i)),xdim);
}
}
// **************************************************************************
// putimage() copies the data in *buff to a rectangular area of the screen
// marked by (x0,y0) on the top left, and (x1,y1) on the bottom right.
//
// NOTE: This function needs translating into assembler
// **************************************************************************
void putimage(int x0, int y0, int x1, int y1, char far *buff)
{
int i;
int deltaY=(y1-y0);
int xdim=(x1-x0);
for (i=0;i<=deltaY;i++)
{
_fmemcpy(xy_to_ptr(x0,(y0+i)),(void *)&buff[i*xdim],xdim);
}
}
// *************************************************************************
// copyimage copies a rectangular image bounded by (x0, y0) at top left, and
// (x1, y1) at bottom right, to the video buffer at (putx, puty). The func-
// tion is very fast, suitable for copying blocks of a virtual screen into
// the physical screen for animation. It does no clipping, or checking for
// the vertical blanking interval. If using it to copy from system ram to
// the video buffer, make sure to pass a pointer to the buffer in src_buff,
// and set GRAPH_SEG = to the video buffer before the call.
// *************************************************************************
void copyimage(int x0, int y0, int x1, int y1, int putx, int puty,
void far *src_buf)
{
int deltaY=(y1-y0);
int xdim=(x1-x0);
asm {
mov es, GRAPH_SEG // establish GRAPH_SEG as destination seg
mov bx, 320 // increment value to move down one line
mov ax, puty // calculate the start of the first line
mul bx // for the destination
add ax, putx
mov di, ax
mov ax, y0 // caluclate the start of the first line
mul bx // for the source
add ax, x0
push ds
lds si, src_buf
add si, ax
mov dx, deltaY // set dx up as loop counter
cld // clear the direction flag
}
mainloop: // frame drawing loop
asm {
mov cx, xdim // cx == frame width in pixels
push si // save the line pointers
push di
shr cx, 1 // optimized copy
rep movsw
rcl cx, 1
rep movsb
pop di // restore the line pointers
pop si
add di, 320 // point to next line in source, dest
add si, 320
dec dx // adjust the loop counter
jnz mainloop
pop ds
}
}
// *************************************************************************
// doSplitVerticalWipe causes the picture in pic_buf to be displayed by
// wiping from left and right to the center. If called with a null pointer
// it will clear the screen using palette register 0. Waits for the vertical
// blanking interval, producing a smooth motion. This function really doesn't
// need to be done in assembler, as the vbi test is the limiting factor (see
// below)
// *************************************************************************
void doSplitVerticalWipe(void far *pic_buf)
{
unsigned leftx = 0;
unsigned rightx = 319;
unsigned run_y; // counts rows
char far *lsrc_ptr; // pointer to left column in source
char far *ldst_ptr; // pointer to left column in dest
char far *rsrc_ptr; // pointer to right column in source
char far *rdst_ptr; // pointer to right column in dest
if (pic_buf != NULL)
{
while (rightx > leftx)
{
ldst_ptr = (char far *)xy_to_ptr(leftx, 0);
lsrc_ptr = (char far *)pic_buf+leftx;
rdst_ptr = (char far *)xy_to_ptr(rightx, 0);
rsrc_ptr = (char far *)pic_buf+rightx;
wait_vbi();
for (run_y = 0; run_y < 200; run_y++)
{
*ldst_ptr = *lsrc_ptr;
*rdst_ptr = *rsrc_ptr;
ldst_ptr += 320;
lsrc_ptr += 320;
rdst_ptr += 320;
rsrc_ptr += 320;
}
leftx++;
rightx--;
}
}
else
{
while (rightx > leftx)
{
ldst_ptr = (char far *)xy_to_ptr(leftx, 0);
rdst_ptr = (char far *)xy_to_ptr(rightx, 0);
wait_vbi();
for (run_y = 0; run_y < 200; run_y++)
{
*ldst_ptr = 0;
*rdst_ptr = 0;
ldst_ptr += 320;
rdst_ptr += 320;
}
leftx++;
rightx--;
}
}
}
// **************************************************************************
// doSplitHorizWipe displays the picture in pic_buf by wiping it down from
// top and bottom. If it's called with a null pointer it clears the screen
// with palette register 0. Waits for vertical blanking interval, producing
// a smooth wipe. This function really didn't need to be done in assembler.
// I realized after I did it that the test for the vertical blanking interval
// was the limiting factor, not the execution time. Lessons learned! <g>.
//
// This function moves the image data by copying lines to the top and bottom
// of the screen alternately. The key to this process is the value in the
// unsigned integer adjust. In the setup es:di and ds:si are set up to point
// to the first line of the dest and source memory areas respectively. The
// adjust variable is intialized to 64000, which, when added to the offset of
// the first line, yields the offset of the last. Then adjust is decremented,
// and subtracted from the offset of the last line to get the offset of the
// second, and so on. The value of adjust is not used directly, but is loaded
// into the bx register. Keep an eye on si and di, as they are saved and
// restored quite often in all of these dissolve functions.
// **************************************************************************
void doSplitHorizWipe(void far *pic_buf)
{
unsigned adjust = 64000U; // used to adjust di and si
asm {
mov dx, input_status_1 // used to test for vbi later
mov cx, 200 // line counter
mov bx, adjust // bx stores adjust value
mov es, GRAPH_SEG // else get video segment into es
xor di, di // zero out the offset
push ds
lds si, pic_buf // get pic_buf into es:di
mov ax, ds // check for a null pointer
cmp ax,0
je clearscr // if it's null clear the screen
cld // clear the direction flag
}
mainloop1: // outer line loop
asm {
push cx // save loop counter
mov cx, 160 // move 160 words
push si // save offsets
push di
}
test_11: // these lines wait for vbi
asm {
in al, dx // first test, out of vbi
test al,0x8
jnz test_11
}
test_12:
asm {
in al, dx // second test, in vbi
test al,0x8
jz test_12
rep movsw // copy words to video segment
pop di // restore the original offsets
pop si
sub bx, 320 // take one line off of bx
add si, bx // add it to the offsets
add di, bx
mov cx, 160 // move 160 more words
push si // save the offsets
push di
rep movsw // copy the data to video seg
pop di // restore the offsets
pop si
sub bx, 320 // take 1 line off of bx
sub si, bx // subtract it from the offsets
sub di, bx
pop cx // restore the outer loop counter
loop mainloop1 // do next two lines
jmp done // skip the next part
}
clearscr:
asm cld; // clear the direction flag
mainloop2:
asm {
push cx // save the loop counter
mov cx, 160 // move 160 words
push di // save the offset
}
test_21: // these lines test for vbi
asm {
in al, dx // first test, out of vbi
test al,0x8
jnz test_21
}
test_22:
asm {
in al, dx // second test, in vbi
test al,0x8
jz test_22
xor ax, ax // clear ax, value to be stored==0
rep stosw // clear the line
pop di // restore the offset
sub bx, 320 // take one line from bx
add di, bx // add it to the offset
mov cx, 160 // mov 160 more words
push di // save the offset
rep stosw // copy the data to video buff
pop di // restore the offset
sub bx, 320 // take one line from bx
sub di, bx // subtract it from the offset
pop cx // restore the loop counter
loop mainloop2
}
done:
asm pop ds;
}
// **************************************************************************
// doSlideVerticalWipe causes the image in pic_buf to be displayed by sliding
// it in from both sides toward the center. Does not check pic_buff for a non
// null address. Waits for vertical blanking interval between writes, produc-
// ing a smooth image motion.
//
// This function basically captures frames from the left and right sides of
// the source image and displays them in the video buffer so that the image
// appears to be sliding onto the screen. This is done by starting with very
// narrow slices, which are grabbed from the center of the source, and disp-
// layed at the outside edges of the screen. As the slices get wider they re-
// main rooted to the edges of the screen, so that they appear to slide into
// the center. The outer loop iterates 160 times, or half the screen width.
// On each iteration the width of the frame (i_wid) is increased by one, and
// es:di, ds:si point to the top left corner of the source frame.
// **************************************************************************
void doSlideVerticalWipe(void far *pic_buf)
{
int i_wid, x0, putx;
char ctrl; // controls branching
asm {
mov i_wid, 0 // zero out the outer loop counter
push ds // save the data segment
mov es, GRAPH_SEG // get the video segment into es
}
lefthalf:
asm {
mov ax, 160 // get center line into ax
sub ax, i_wid // i_wid is the offset from center
mov x0, ax // x0 is the top left of the source block
mov putx, 0 // putx is the top left of the dest block
mov ctrl, 0
jmp doframe // display the frame
}
righthalf:
asm {
mov ax, 160 // mostly same as above except for
mov x0, ax // right side
mov ax, 319
sub ax, i_wid
mov putx, ax
mov ctrl, 1
jmp doframe
}
checkloop:
asm {
inc i_wid
cmp i_wid, 160 // have 160 iterations
jna lefthalf
pop ds // restore data segment
}
return; // ** exit point **
doframe:
asm {
mov di, putx // di == top left corner of destination
mov dx, input_status_1 // used to test for vbi below
lds si, pic_buf // get picture pointe into ds:si
add si, x0 // set si == top left corner of source block
}
test_1: // these lines test for the vbi
asm {
in al, dx // first test, out of vbi
test al,0x8
jnz test_1
}
test_2:
asm {
in al, dx // second test, in vbi
test al,0x8
jz test_2
mov dx, 200 // set dx up as loop counter
cld // clear the direction flag
}
mainloop: // frame drawing loop
asm {
mov cx, i_wid // i_wid is equal to the block width
push si // save the offsets
push di
shr cx, 1 // optimized copy technique, cx==number of
rep movsw // number of bytes/2
rcl cx, 1 // now, if cx was odd, cx == 1, else cx ==0
rep movsb // catches any odd byte (thanks to Gus S.)
pop di // restore the offsets
pop si
add di, 320 // point to the next line
add si, 320
dec dx // adjust the outer loop counter
jnz mainloop
cmp ctrl, 0 // if last copy was lefthalf do righthalf
je righthalf
jmp checkloop
}
}
// **************************************************************************
// doSlideHorizWipe operates almost exactly like doSlideVerticalWipe above,
// except that the image slides in from top and bottom instead of from left
// and right. Like the other wipes it uses the wipe to clear the screen if
// called with pic_buf == NULL.
//
// This function operates almost exactly like the vertical version directly
// above.
// **************************************************************************
void doSlideHorizWipe(void far *pic_buf)
{
int i_wid, y0, puty;
char ctrl; // controls branching
asm {
mov i_wid, 1 // zero out the outer loop counter
push ds // save the data segment
mov es, GRAPH_SEG // get the video segment into es
}
tophalf:
asm {
mov ax, 100 // get center line into ax
sub ax, i_wid // i_wid is the offset from center
mov bx, 320
mul bx
mov y0, ax // x0 is the top left of the source block
mov puty, 0 // putx is the top left of the dest block
mov ctrl, 0
jmp doframe // display the frame
}
bottomhalf:
asm {
mov ax, 99 // mostly same as above except for
mov bx, 320
mul bx
mov y0, ax // right side
mov ax, 199
sub ax, i_wid
mul bx
mov puty, ax
mov ctrl, 1
jmp doframe
}
checkloop:
asm {
inc i_wid
cmp i_wid, 100 // have 160 iterations
jna tophalf
pop ds // restore data segment
}
return; // ** exit point **
doframe:
asm {
mov di, puty // di == top left corner of destination
mov dx, input_status_1 // used to test for vbi below
lds si, pic_buf // get picture pointe into ds:si
add si, y0 // set si == top left corner of source block
}
test_1: // these lines test for the vbi
asm {
in al, dx // first test, out of vbi
test al,0x8
jnz test_1
}
test_2:
asm {
in al, dx // second test, in vbi
test al,0x8
jz test_2
mov dx, i_wid // set dx up as loop counter
cld // clear the direction flag
}
mainloop: // frame drawing loop
asm {
mov cx, 160 // i_wid is equal to the block width
push si // save the offsets
push di
rep movsw // number of bytes/2
pop di // restore the offsets
pop si
add di, 320 // point to the next line
add si, 320
dec dx // adjust the outer loop counter
jnz mainloop
cmp ctrl, 0 // if last copy was lefthalf do righthalf
je bottomhalf
jmp checkloop
}
}
// *************************************************************************
// doVerticalDissolve causes the image stored in pic_buf to be displayed by
// fading in multiple vertical slices. It is the vertical equivalent of the
// doHorizDissolve function. When called with a null pointer it clears the
// screen.
//
// The function moves the image data to the screen by iterating through
// 16 vertical slices. On each iteration two lines are drawn, at an equal
// distance on either side of the center mark for that section. The outer-
// most loop counts the lines; it takes 10 iterations to fill one slice. The
// innermost loop cycles through the 16 slices. So, the first slice gets two
// lines, the second gets two, on up to the 16th, and then the first gets
// two more, and so on. Keep an eye on si and di.
// *************************************************************************
void doVerticalDissolve(void far *pic_buf)
{
int base_row; // base_row stores the line offset from x
asm {
mov es, GRAPH_SEG // get the video segment into es
mov base_row, 0 // start out drawing on the x pixel
mov cx, 11 // outer loop, 11 pixels to each side of
cld // the x pixel (in si and di) will be drawn
push ds // save the ds register value
lds si, pic_buf // get the picture pointer into ds:si
mov ax, ds // check for a NULL pointer and jmp to
cmp ax, 0 // clearscr if found
je clearscr
}
mainloop:
asm {
push cx // save the outer loop counter
push si // save original offset to byte 0 of pic
mov cx, 16 // process 16 vertical slices
add si, 9 // first x mark is on 9,0
mov di, 9
}
drawloop:
asm {
push cx // save the inner loop counter
push si // and the x mark, source and dest
push di
add di, base_row // add in the offset from x for first line
add si, base_row
mov cx, 200 // plot 200 pixels
}
lineloop1: // this loop draws a vertical line
asm {
movsb // move one byte
add si, 319 // move to next row
add di, 319
loop lineloop1 // do another
pop di // restore the starting points
pop si
push si // save them again
push di
sub di, base_row // drawing on the other side this time
sub si, base_row
mov cx, 200 // plot 200 pixels
}
lineloop2:
asm {
movsb // same as above
add si, 319
add di, 319
loop lineloop2
pop di // restore the starting point
pop si
pop cx // restore the inner loop counter
add si, 20 // adjust pointer to the next slice
add di, 20
loop drawloop // process it
inc base_row // increment the drawing offset
pop si // restore the offset to byte 0 of pic
pop cx // restore the outer loop counter
loop mainloop // do it all again
jmp done
}
clearscr: // this block functions exactly as the
asm { // previous one but clears the screen using
push cx // palette register 0
mov cx, 16
mov di, 9
}
drawloop2:
asm {
push cx
push di
add di, base_row
xor ax, ax
mov cx, 200
}
lineloop21:
asm {
stosb
add di, 319
loop lineloop21
pop di
push di
sub di, base_row
xor ax, ax
mov cx, 200
}
lineloop22:
asm {
stosb
add di, 319
loop lineloop22
pop di
pop cx
add di, 20
loop drawloop2
inc base_row
pop cx
loop clearscr
}
done:
asm pop ds; // restore the data segment
}
// **************************************************************************
// doHorizDissolve causes the image in pic_buf to be displayed by dissolving
// it in in 10 horizontal bands. If called with pic_buf==NULL it clears the
// screen by the same method.
//
// This function processes the data much like the Vertcal Dissolve funtion
// above. The screen in this case is divided into 10 horizontal slices. The
// center line starting points of these slices begin at 2880 bytes into the
// video buffer, and every 6400 bytes after that. Like the function above it
// cycles through the slices drawing two lines at each, progressively further
// from the center line with each iteration of the outer loop. Like the func-
// tion above, you have to keep a carefull eye on di and si to understand it.
// **************************************************************************
void doHorizDissolve(void far *pic_buf)
{
int base_line;
asm {
mov base_line, 0 // base_line is an offset from each line
mov es, GRAPH_SEG // get video segment into es
mov bx, 320 // bx * base_line == adjust value for si,di
mov cx, 20 // outer loop 20 iterations
cld // clear the direction flag
push ds // save the ds register value
lds si, pic_buf // get pic_buf into ds:si
mov ax, ds // if pic_buf == NULL jump to clearscr
cmp ax, 0
je clearscr
}
mainloop1: // main drawing loop, 20 iterations...
asm { // the number of offset lines to draw
push cx // save the counter
mov cx, 10 // inner loop, 10 iterations, draws lines
push si // save the offset of the pic_buf pointer
add si, 60480 // 60480, address of first line processed
mov di, 60480
mov dx, input_status_1 // used below to test for vbi
}
test_11: // these lines test for the vbi
asm {
in al, dx // first test, out of vbi
test al,0x8
jnz test_11
}
test_12:
asm {
in al, dx // second test, in vbi
test al,0x8
jz test_12
}
drawloop1: // drawloop processes the 10 base lines,
asm { // drawing 2 lines at offset ax from base
push cx // save the counter
push si // save the offset to the current base
push di
mov ax, base_line // calculate the pointer offset from base
mul bx // by multiplying base_line * 320
sub si, ax // subtract the offset from source and
sub di, ax // dest base pointers, and
mov cx, 160 // draw the first line
rep movsw
pop di // restore the base pointers
pop si
push si // save em again
push di
add si, ax // add the offset to the source and dest
add di, ax // base pointers and
mov cx, 160 // draw the second line
rep movsw
pop di // restore the base pointers
pop si
pop cx // restore the inner loop counter
sub si, 6400 // adjust base pointers to point to the
sub di, 6400 // next base, 20 lines up the screen
loop drawloop1 // process the next section
inc base_line // increment the base offset factor
pop si // restore the original pic_buf offset
pop cx // restore the outer loop counter
loop mainloop1 // do it all over again
jmp done // finished
}
clearscr: // this section executes if pic_buf==NULL
asm {
push cx // save the outer loop counter
mov cx, 10
mov di, 60480 // we can ignore ds:si since no source
mov dx, input_status_1 // used to test for vbi below
}
test_21: // these lines test for the vbi
asm {
in al, dx // first test, out of vbi
test al,0x8
jnz test_21
}
test_22:
asm {
in al, dx // second test, in vbi
test al,0x8
jz test_22
}
drawloop2:
asm {
push cx // save the inner loop counter
push di // save the base offset
mov ax, base_line // calculate the drawing offset from base
mul bx
sub di, ax // subtract the offset from the base pointer
push ax // save the offset
xor ax, ax // clear ax for use in stosw instruction
mov cx, 160
rep stosw // clear the first line
pop ax // restore the offset
pop di // restore the base pointer
push di // save it again
add di, ax // add the offset to the base pointer
xor ax, ax // clear ax for use in stosw instruction
mov cx, 160
rep stosw // clear the second line
pop di // restore the base pointer
pop cx // restore inner loop counter
sub di, 6400 // adjust base pointer to 20 lines up screen
loop drawloop2 // process the next section
inc base_line // increment the offset factor
pop cx // restore the outer loop counter
loop clearscr
}
done: // finished
asm pop ds; // restore ds value
}
void doSparkleDissolve(void far *pic_buf)
{
}
// *************************************************************************
// member function definitions for class font, declared in images.hpp
// *************************************************************************
// *************************************************************************
// constructor takes a char * filepath. It opens the fontfile, gets the
// font header into the member structure font_hdr, then allocates memory
// and reads the font data into it. Errors cause the constructor set the
// font status to 0, then return. The status can be checked via the
// font::getstatus() method.
// *************************************************************************
font::font(char *f_spec)
{
int handle;
int readsize;
int bytes_read=0;
char cursor_size;
if ((handle=open(f_spec,O_RDONLY|O_BINARY))==-1)
{
status = FileOpenErr;
return;
}
bytes_read+=(read(handle,&f_hdr,sizeof(f_hdr)));
bytes_read+=(read(handle,&width[0],sizeof(width)));
cursor_size=(f_hdr.fram_wid*f_hdr.fram_hit);
if (((void far *)cursor_mask=malloc(cursor_size)) ==NULL)
{
status = MemErr;
return;
}
bytes_read+=(read(handle,(void far*)cursor_mask,cursor_size));
readsize=(filelength(handle)-bytes_read);
if (((void far *)font_ptr=malloc(readsize)) ==NULL)
{
free(cursor_mask);
status = MemErr;
return;
}
read(handle,(void far *)font_ptr,readsize);
close(handle);
fore_color=0;
setstyle(0,15,1,opaque,4);
status=1;
}
// *************************************************************************
// destructor disposes of the memory allocated to the font
// *************************************************************************
font::~font()
{
free(font_ptr);
font_ptr=NULL;
free(cursor_mask);
cursor_mask=NULL;
}
// *************************************************************************
// get_width() returns the proportional width in pixels of char c
// *************************************************************************
char font::get_width(char c)
{
if ((c>=f_hdr.ascii_first)&&(c<=f_hdr.ascii_last))
return(width[c-f_hdr.ascii_first]);
else
return(0);
}
// *************************************************************************
// put_char displays one bitmapped character at the passed x,y location
// *************************************************************************
void font::put_char(int x, int y, char c)
{
int j;
int i;
unsigned char src,dst;
char far *p;
int char_ofs;
char_ofs=(c-f_hdr.ascii_first)*((f_hdr.fram_wid*f_hdr.fram_hit));
(void far *)p=MK_FP(FP_SEG(font_ptr),FP_OFF(font_ptr)+char_ofs);
for(j=0;j<f_hdr.fram_hit;j++)
{
for (i=0;i<f_hdr.fram_wid;i++)
{
src=p[(j*f_hdr.fram_wid)+i];
if (src==f_hdr.f_color)
{
dst=fore_color;
writepixel(x+i,y+j,dst);
}
else
{
if (see_thru==opaque)
{
dst=back_color;
writepixel(x+i,y+j,dst);
}
}
}
}
}
// *************************************************************************
// returns the current foreground color setting for text output
// *************************************************************************
int font::getforecolor()
{
return(fore_color);
}
// *************************************************************************
// returns the current background color setting for text output
// *************************************************************************
int font::getbackcolor()
{
return(back_color);
}
// *************************************************************************
// call this function to set the style parameters for text output. f_grnd=
// foreground color, b_grnd=background color, char_tab=pixels between
// characters, opacity={trans,opaque}, when opacity=trans the background
// pixels in the font are ingored, when opacity=opaque the background pixels
// are set to the color value passed in b_grnd, space_wid=width in pixels
// of ascii character 32 (20h), the space character.
// *************************************************************************
void font::setstyle(int f_grnd,int b_grnd,short char_tab,
opacity o, char space_wid)
{
spacing=char_tab;
see_thru=o;
fore_color=f_grnd;
back_color=b_grnd;
width[32-f_hdr.ascii_first]=space_wid;
}
// *************************************************************************
// ouput the string pointed to by str at the given x,y coordinate.
// *************************************************************************
void font::show(int x, int y, char *str)
{
int i;
int j;
for (j=0;str[j]!=0;j++); // one line gets length of string
for (i=0;i<j;i++)
{
put_char(x,y,str[i]);
x += get_width(str[i])+spacing;
}
}
// *************************************************************************
// read a string from the keyboard, echo to screen at x,y. Reads until it
// encouters a carriage return <ascii 13>, or the string reaches width
// bytes in length, whichever occurs first. Displays a blinking cursor using
// the cursor mask loaded with the font. Backspace enabled.
// *************************************************************************
void font::readstr(int x, int y, char *str, char length, char mask)
{
char c='\0'; // used in call to getfilteredkey()
extnd scan=NO_EXT; // ditto
int cursor_x=x; // cursor position/next letter position
int cursor_y=y; // ditto
char cur_toggle=0; // cursor display state
unsigned int tick; // last clock reading
volatile unsigned int *clock=(unsigned int *)MK_FP(0x0040,0x006C);
int str_len=0; // input string length
int i,j; // generic counters
str[str_len]='\0';
while((c!=13)&&(str_len<length))
{
do
{
tick= *clock;
while ((*clock<(tick+3))&&(!kbhit()));
cur_toggle = !cur_toggle;
for(j=0;j<f_hdr.fram_hit;j++)
{
for (i=0;i<(f_hdr.fram_wid-1);i++)
{
if ((cur_toggle==0)||(cursor_mask[(j*f_hdr.fram_wid+i)]==0))
writepixel(cursor_x+i,cursor_y+j,back_color);
else
writepixel(cursor_x+i,cursor_y+j,fore_color);
}
}
} while ((!kbhit())||(cur_toggle!=0));
if (getfilteredkey(mask,&c,&scan))
{
if ((c!=13)&&(c!=8)&&(c!=9)&&(c!=27))
{
str[str_len++]=c;
str[str_len]='\0';
put_char(cursor_x,cursor_y,c);
cursor_x+=(get_width(c)+spacing);
}
else
{
if ((c==8)&&(str_len!=0))
{
cursor_x-=(get_width(str[str_len-1])+spacing);
str[--str_len]='\0';
}
}
}
}
}
// **************************************************************************
// call installed() immediately after initializing an instance of class font.
// if it returns non-zero (true) the installation was successful. 0 indicates
// a file access or memory error during installation.
// **************************************************************************
int font::installed()
{
return(status);
}
// **************************************************************************
// member function definitions for i_stack pointer stack class
//
// these don't have any specific place in a graphics module, except that they
// were going to be used in a window manager, and I was too lazy to make them
// a module to live in.
// **************************************************************************
// **************************************************************************
// constructor clears the pointer stack to NULL
// **************************************************************************
i_stack::i_stack()
{
int i;
ptr_index=0;
for (i=0;i<20;i++)
{
ptr_array[i]=NULL;
}
}
// **************************************************************************
// push a pointer on to the stack. Returns 0 if stack full, 1 if success
// **************************************************************************
char i_stack::push_ptr(void far *ptr)
{
if (ptr_index!=20)
{
ptr_array[ptr_index++]=ptr;
return(1);
}
else
{
return(0);
}
}
// **************************************************************************
// pop a pointer from the stack. Returns NULL if stack empty.
// **************************************************************************
void far *i_stack::pop_ptr()
{
if (ptr_index!=0)
return(ptr_array[--ptr_index]);
else
return(NULL);
}
// **************************************************************************
// member function definitions for window class
// **************************************************************************
// **************************************************************************
// Constructor creates the window. See WIN.DOC for more information.
// **************************************************************************
win::win(int tlx, int tly, int xwid, int ywid, char far *bmap,
char brdrwid, char shdwwid, char bgrnd, char border)
{
if (shdwwid==0)
{
shdwon=0;
if ((backgrnd=new char[xwid*ywid])==NULL)
{
status = 0;
return;
}
getimage(tlx,tly,tlx+xwid,tly+ywid,backgrnd);
}
else
{
shdwon=1;
if ((backgrnd = new char[(xwid+shdwwid)*(ywid+shdwwid)])==NULL)
{
status=0;
return;
}
getimage(tlx,tly,tlx+xwid+shdwwid,tly+ywid+shdwwid,backgrnd);
barfill(tlx+xwid,tly+shdwwid,tlx+xwid+shdwwid,tly+ywid+shdwwid,0);
barfill(tlx+shdwwid,tly+ywid,tlx+xwid,tly+ywid+shdwwid,0);
}
if (bmap==NULL)
barfill(tlx,tly,tlx+xwid,tly+ywid,bgrnd);
else
putimage(tlx,tly,tlx+xwid,tly+ywid,bmap);
if (brdrwid!=0)
{
if (brdrwid>1)
{
barfill(tlx,tly,tlx+xwid,tly+brdrwid,border);
barfill(tlx+(xwid-brdrwid),tly,tlx+xwid,tly+ywid,border);
barfill(tlx,tly+(ywid-brdrwid),tlx+xwid,tly+ywid,border);
barfill(tlx,tly,tlx+brdrwid,tly+ywid,border);
}
else
{
line(tlx,tly,tlx+xwid,tly,border);
line(tlx+xwid,tly,tlx+xwid,tly+ywid,border);
line(tlx,tly+ywid,tlx+xwid,tly+ywid,border);
line(tlx,tly,tlx,tly+ywid,border);
}
}
origX=tlx;
origY=tly;
xsize=xwid;
ysize=ywid;
bdrwid=brdrwid;
shdwid=shdwwid;
b_grnd=bgrnd;
brdr=border;
status=1;
return;
}
win::~win()
{
if (shdwon)
putimage(origX,origY,origX+xsize+shdwid,origY+ysize+shdwid,backgrnd);
else
putimage(origX,origY,origX+xsize,origY+ysize,backgrnd);
delete(backgrnd);
return;
}
// **************************************************************************
// member function defintions for pcx class
// **************************************************************************
// **************************************************************************
// constructor opens the file as binary, readonly. It reads the dac palette
// into the member p_rec structure palette, corrects it for shift, sets sev-
// eral status variables, and closes the file. On error it sets pcx.status to
// Failed, and reports the error in the images module error record imag_err.
// **************************************************************************
pcx::pcx(char *fspec)
{
char check_pal;
int i,j;
FILE *filptr;
status = NoErr;
if ((filptr = fopen(fspec,"rb"))==NULL)
{
status = FileOpenErr;
return;
}
if (fseek(filptr,-769L,SEEK_END) != 0)
{
status= FileReadErr;
fclose(filptr);
return;
}
fread(&check_pal,1,1,filptr);
// check for 256 color PCX palette tag 0x0C at filelength-769
if (check_pal!=0x0C)
{
status = FileFormatErr;
fclose(filptr);
return;
}
// read in the palette and store in class member data palette
if (fread(palette,1,768,filptr) != 768)
{
status = FileReadErr;
fclose(filptr);
return;
}
// shift the palette values right by two bits (pcx specific detail)
for (i=0;i<256;i++)
{
for (j=0;j<3;j++)
{
palette[i][j]=palette[i][j]>>2;
}
}
// leave the file pointer on the first byte of image data
if (fseek(filptr,128,SEEK_SET) != 0)
{
status = FileReadErr;
fclose(filptr);
return;
}
fclose(filptr);
buffer=NULL; // pcx:image.buffer
for (j=0;fspec[j]!=0;j++); // these two lines copy the path to
memcpy(fpath,fspec,j+1); // to storage in the object data
in_ram = 0; // pcx.in_ram
packed = 0; // pcx.packed
return;
}
// **************************************************************************
// unpacktoram unpacks the rle encoded into the buffer pointed to by dest.
// No size checking is performed on the buffer. The unpacking process cont-
// inues until num_bytes have been moved to dest. The function checks the
// state of the in_ram member variable. If the image is not in memory it is
// unpacked from the disk file. If the image is in memory in compressed mode
// it is unpacked from memory. If the image is in memory, but is already
// uncompressed the function returns UnknownErr.
// **************************************************************************
char pcx::unpacktoram(char far *dest, unsigned int num_bytes)
{
unsigned int bytes=0; // counts unpacked bytes
char c; // byte being processed
int runlen; // length of packet
unsigned int src_cntr = 0; // counts through ram buffer if any
char far *streambuf;
FILE *filptr;
if (!in_ram)
{
if ((filptr=fopen(fpath,"rb"))==NULL)
return(FileOpenErr);
if ((streambuf=new char[5000]) != NULL)
{
setbuf(filptr,streambuf);
}
if (fseek(filptr,128L,SEEK_SET) != 0)
{
fclose(filptr);
if (streambuf != NULL)
delete(streambuf);
return(FileReadErr);
}
do
{
c=fgetc(filptr);
if ((c & 0xc0) == 0xc0)
{
runlen = (c & 0x3f);
c=fgetc(filptr);
while(runlen--) (dest[bytes++]=c);
}
else
dest[bytes++]=c;
} while (bytes<num_bytes);
fclose(filptr);
if (streambuf!=NULL)
delete(streambuf);
}
else
{
if (!packed)
return(UnknownErr);
else
{
do
{
c=buffer[src_cntr++];
if ((c & 0xc0) == 0xc0)
{
runlen = (c & 0x3f);
c=buffer[src_cntr++];
while(runlen--) (dest[bytes++]=c);
}
else
dest[bytes++]=c;
} while (bytes<num_bytes);
}
}
return(NoErr);
}
// **************************************************************************
// the load() member function reads the pcx file into a memory buffer. The
// pointer to the buffer and the buffer size are internal to the class, and
// do not need to be taken into account by the programmer. The data is loaded
// based on the value of method. A set of three constants is defined for this
// value; Packed, Unpacked, and Bestfit. If method = packed the data will be
// read into the memory buffer in compressed PCX format, but the palette and
// header data will be stripped. If method = unpacked the data is uncompress-
// to memory using the unpacktoram() function. In either case, if there is
// not sufficient memory, the function returns MemErr. If method = Bestfit
// the function will unpack the data is possible, or load it packed if not,
// and finally returns MemErr if neither method can be used. If successfull
// the function sets internal switches so that other pcx member functions
// will know that the image data is already loaded, and in what form it has
// been loaded.
// **************************************************************************
char pcx::load(char method)
{
unsigned readsize;
FILE *filptr;
// make sure the image isn't already loaded
if (!in_ram)
{
if (method == Bestfit)
{
// if enough ram for the image load unpacked
if (coreleft() >= 64000U)
{
method = Unpacked;
}
else
// if not enough ram open the file, compare it's size to the
// available memory, and load it packed if there's enough room
// or return a MemErr if there isn't.
{
if ((filptr=fopen(fpath,"rb"))==NULL)
{
return(FileOpenErr);
}
readsize = filelength(fileno(filptr))-(128+769);
fclose(filptr);
if (coreleft() >= readsize)
method = Packed;
else
return(MemErr);
}
}
// if method = packed then allocate a buffer the size of the image
// file with the header and palette data stripped out. Zero the
// buffer, then read the packed data into it. Finally, set in_ram
// and packed = 1 (pcx class member data used by display() member
// function)
if (method == Packed)
{
if ((filptr=fopen(fpath,"rb"))==NULL)
return(FileOpenErr);
readsize = filelength(fileno(filptr))-(128+769);
if ((buffer = new char[readsize]) == NULL)
{
fclose(filptr);
return(MemErr);
}
_fmemset(buffer,0,readsize);
if (fseek(filptr, 128L, SEEK_SET) != 0)
{
fclose(filptr);
delete(buffer);
return(FileReadErr);
}
if (fread(buffer, 1, readsize, filptr) != readsize)
{
fclose(filptr);
delete(buffer);
return(FileReadErr);
}
fclose(filptr);
in_ram = 1;
packed = 1;
}
else
// if method = Unpacked then allocate a 64000 byte buffer, and
// unpack the data into it.
{
if ((buffer = new char[64000U]) == NULL)
return(MemErr);
_fmemset(buffer,0,64000U);
if(unpacktoram(buffer,64000U) != NoErr)
{
delete(buffer);
in_ram = 0;
return(SecondaryErr);
}
else
{
in_ram = 1;
packed = 0;
}
}
}
return(NoErr);
}
// **************************************************************************
// the unload() member function frees the memory allocated to the pcx data,
// and updates the internal switches so that other member functions will
// know that the image is no longer in memory.
// **************************************************************************
void pcx::unload()
{
if (in_ram)
{
delete(buffer);
in_ram = 0;
packed = 0;
}
}
// **************************************************************************
// pcx::display can be used to display a PCX class object to screen using
// various fade types, wipes, and dissolves. All fade types other than Soft-
// Fade and SnapWipe require a screen buffer of 64000 bytes. If that memory
// is not available the function returns MemErr. The PCX will be displayed
// whether it is: on disk, in ram packed, or in ram unpacked (in order of
// decreasing execution time).
//
// The following fade types are available:
//
// SnapWipe - snaps the pcx to screen, basic block mem move.
// SplitVerticalWipe - fades from the top and bottom toward center.
// SplitHorizWipe - fades from the right and left toward center.
// SlideVerticalWipe - slides pic in from left and right
// SlideHorizWipe - slides pic in from top and bottom
// VerticalDissolve - overlays multiple vertical slices
// HorizDissolve - overlays multiple horizontal slices
// SparkleDissolve - fades with random block placement
// SoftFade - dac palette intensity fade, 64 passes
// **************************************************************************
char pcx::display(char fadetype)
{
char far *do_buffer;
char loaded_here = 0;
// SoftFade (palette fade) requires the palette to be cleared.
if (fadetype == SoftFade)
{
wait_vbi();
clrpalette(0,256);
}
else
// all other types require the new palette to be loaded
{
wait_vbi();
loadpalette(0,256,palette);
}
// if the image is not in ram, or is in ram compressed, then it
// needs to be unpacked, from either disk or memory, to either the
// video buffer or a memory buffer depending on the fade type.
if ((!in_ram) || ((in_ram) && (packed)))
{
// these two fade types simply require the data unpacked to vseg.
if ((fadetype == SoftFade) || (fadetype == SnapWipe))
{
if (unpacktoram((char far *)MK_FP(0xa000,0), 64000U) != NoErr)
return(SecondaryErr);
}
else
// all the others require the data in a 64K memory buffer
// so one is allocated, and the data is unpacked to it
{
if ((do_buffer = new char[64100U]) == NULL)
return(MemErr);
if (unpacktoram(do_buffer, 64000U) != NoErr)
{
delete(do_buffer);
return(SecondaryErr);
}
loaded_here = 1;
}
}
else
// if the data is in ram uncompressed it's ready to go. The only
// action necessary is to copy it to the video buffer for the two
// simple fade types. The buffer identifier is member data of the
// image class, and stores a pointer to the image buffer. In both
// cases do_buffer is assigned the value of buffer, and then the
// operations are performed on it. This simplifies the calls to
// the fade functions below.
{
do_buffer = buffer;
// for these two fade types copy the data over to vseg
if ((fadetype == SoftFade) || (fadetype == SnapWipe))
{
wait_vbi();
asm {
push es
push ds
push cx
push si
push di
mov es, GRAPH_SEG
xor di, di
lds si, do_buffer
mov cx, 32000
rep movsw
pop di
pop si
pop cx
pop ds
pop es
}
}
}
switch (fadetype)
{
case SoftFade: fadepalettein(0,256,palette); break;
case SplitVerticalWipe: doSplitVerticalWipe(do_buffer); break;
case SplitHorizWipe: doSplitHorizWipe(do_buffer); break;
case SlideVerticalWipe: doSlideVerticalWipe(do_buffer); break;
case SlideHorizWipe: doSlideHorizWipe(do_buffer); break;
case VerticalDissolve: doVerticalDissolve(do_buffer); break;
case HorizDissolve: doHorizDissolve(do_buffer); break;
case SparkleDissolve: doSparkleDissolve(do_buffer); break;
}
if (loaded_here)
delete(do_buffer);
return(NoErr);
}
// **************************************************************************
// remove() clears the current image from the screen using the passed fade
// type. It will clear the screen regardless of what image is on it. No
// checking is performed to be certain this function is called after a call
// to display() has been made for the object.
// **************************************************************************
void pcx::remove(char fadetype)
{
switch (fadetype)
{
case SoftFade: fadepaletteout(0,256); break;
case SnapWipe: clearscr(0); break;
case SplitVerticalWipe: doSplitVerticalWipe(NULL); break;
case SplitHorizWipe: doSplitHorizWipe(NULL); break;
case SlideVerticalWipe: break;
case SlideHorizWipe: break;
case VerticalDissolve: doVerticalDissolve(NULL); break;
case HorizDissolve: doHorizDissolve(NULL); break;
case SparkleDissolve: doSparkleDissolve(NULL); break;
}
return;
}
// **************************************************************************
// destructor frees memory allocated to pcx file, if any
// **************************************************************************
pcx::~pcx()
{
if (in_ram)
delete(buffer);
}
