GLMAZE.C
#include "pch.c"
#pragma hdrstop
#include <time.h>
#include "mazedlg.h"
#include <assert.h>
MazeView vw;
MazeSolution sol;
MazeOptions maze_options =
{
FALSE, // depth_test
RENDER_FLAT, // render mode (WALLS)
RENDER_FLAT, // render mode (FLOOR)
RENDER_FLAT, // render mode (CEILING)
FALSE, // frame_count
FALSE, // top_view
TRUE, // eye_view
FALSE, // single_step
FALSE, // all_alpha
FALSE, // bDither
1 // nrats
};
float gfAspect = 1.0f; // aspect ratio
#define SST_NEW_MAZE 0
#define SST_MAZE_GROW 1
#define SST_SOLVING 2
#define SST_MAZE_SHRINK 3
#define SST_ROTATE 4
int solve_state = SST_NEW_MAZE;
// Table of textures used. The first entries contain 1 texture for each main
// surface, followed by textures used for various objects
TEXTURE all_textures[NUM_TEXTURES];
// Environment associated with the texture (repetition, palette rotation,..)
// For now, have one for each of the textures in all_textures. But, this
// could be a per-object thing.
TEX_ENV gTexEnv[NUM_TEXTURES];
// texture environment mode
int gTexEnvMode;
// Texture resources for the main surfaces
TEX_RES gTexResSurf[NUM_DEF_SURFACE_TEXTURES] = {
{TEX_BMP, IDB_BRICK}, // default textures
{TEX_BMP, IDB_WOOD},
{TEX_BMP, IDB_CASTLE},
{TEX_A8, IDB_CURL4}, // mandelbrot textures
{TEX_A8, IDB_BHOLE4},
{TEX_A8, IDB_SNOWFLAK},
{TEX_A8, IDB_SWIRLX4}
};
// Texture resources for objects
TEX_RES gTexResObject[NUM_OBJECT_TEXTURES] = {
{TEX_A8, IDB_START},
{TEX_A8, IDB_END},
{TEX_A8, IDB_RAT},
{TEX_A8, IDB_AD},
{TEX_BMP, IDB_COVER}
};
SSContext gssc;
void maze_Init( void *data );
void RotateTexturePalettes( TEX_ENV *pTexEnv, int count, int iRot );
enum {
TIMER_START = 0,
TIMER_STOP
};
void Draw(void)
{
GLbitfield mask;
mask = 0;
if (maze_options.depth_test)
{
mask |= GL_DEPTH_BUFFER_BIT;
}
if (maze_options.render[FLOOR] == RENDER_NONE ||
maze_options.render[CEILING] == RENDER_NONE ||
maze_options.render[WALLS] == RENDER_NONE ||
maze_height < 1.0f)
{
mask |= GL_COLOR_BUFFER_BIT;
}
if (mask != 0)
{
glClear(mask);
}
// Rotate the palettes of any paletted texures by 1
RotateTexturePalettes( gTexEnv, NUM_TEXTURES, 1 );
if (maze_options.eye_view)
{
DrawMaze(&vw);
}
if (maze_options.top_view)
{
DrawTopView(&vw);
}
glFlush();
}
MazeGoal maze_goals[MAX_GOALS];
int ngoals;
Object special_obj[MAX_SPECIALS];
#define MAX_LETTERS 3
Object letters_obj[MAX_LETTERS];
typedef struct _Rat
{
Object obj;
MazeView vw;
MazeSolution sol;
} Rat;
Rat rats[MAX_RATS];
void NewMazeList(void)
{
glNewList(maze_walls_list, GL_COMPILE);
DrawMazeWalls();
glEndList();
}
void UpdateRatPosition(Rat *rat)
{
MoveObject(&rat->obj, rat->vw.pos.x, rat->vw.pos.y);
// Invert the angle because view angles move opposite to
// object angles
rat->obj.ang = FaAdd(0, -rat->vw.ang);
}
// Simple routines to pick cells at random while guaranteeing
// that those cells are unoccupied
static int rnd_cells[MAZE_CELLS];
static int nrnd_cells;
void InitRandomCells(void)
{
int i;
nrnd_cells = MAZE_CELLS;
for (i = 0; i < nrnd_cells; i++)
{
rnd_cells[i] = i;
}
}
void PickRandomCell(IntPt2 *pos)
{
int idx, t;
#if DBG
if (nrnd_cells == 0)
{
MessageBox(GetDesktopWindow(), TEXT("Out of random cells"),
NULL, MB_OK);
pos->x = 0;
pos->y = 0;
return;
}
#endif
idx = rand() % nrnd_cells;
nrnd_cells--;
t = rnd_cells[idx];
rnd_cells[idx] = rnd_cells[nrnd_cells];
pos->x = t % MAZE_GRID;
pos->y = t / MAZE_GRID;
}
void RemoveRandomCell(IntPt2 *pos)
{
int i, idx;
for (i = 0; i < nrnd_cells; i++)
{
idx = rnd_cells[i];
if ((idx % MAZE_GRID) == pos->x &&
(idx / MAZE_GRID) == pos->y)
{
nrnd_cells--;
rnd_cells[i] = rnd_cells[nrnd_cells];
return;
}
}
}
void NewMaze(void)
{
IntPt2 cell, start_cell;
int i, nspecials, nads;
static BOOL firstMaze = TRUE;
// If not in full screen mode, move the maze window around after it's solved
if( !gbTurboMode && !firstMaze )
ss_RandomWindowPos();
InitRandomCells();
if (!InitMaze(&start_cell, maze_goals, &ngoals))
{
printf("InitMaze failed\n");
exit(1);
}
RemoveRandomCell(&start_cell);
cell.x = maze_goals[GOAL_END].clx;
cell.y = maze_goals[GOAL_END].cly;
RemoveRandomCell(&cell);
nspecials = rand() % MAX_SPECIALS;
for (i = 0; i < nspecials; i++)
{
PickRandomCell(&cell);
maze_goals[ngoals].clx = cell.x;
maze_goals[ngoals].cly = cell.y;
maze_goals[ngoals].user = &special_obj[i];
special_obj[i].w = FMAZE_CELL_SIZE/4;
special_obj[i].h = FxFltVal(.25);
special_obj[i].z = special_obj[i].h;
special_obj[i].col = 15;
special_obj[i].draw_style = DRAW_SPECIAL;
special_obj[i].draw_arg = rand() % SPECIAL_ARG_COUNT;
special_obj[i].ang = FaDeg(0);
special_obj[i].user1 = (rand() % 6)+2;
special_obj[i].user2 = rand() % 5;
special_obj[i].user3 = 0;
PlaceObject(&special_obj[i],
CellToMfx(maze_goals[ngoals].clx)+FMAZE_CELL_SIZE/2,
CellToMfx(maze_goals[ngoals].cly)+FMAZE_CELL_SIZE/2);
ngoals++;
}
while (i < MAX_SPECIALS)
{
special_obj[i].cell = NULL;
i++;
}
nads = (rand() % (MAX_LETTERS*2))-MAX_LETTERS+1;
for (i = 0; i < nads; i++)
{
PickRandomCell(&cell);
letters_obj[i].w = FMAZE_CELL_SIZE/3;
letters_obj[i].h = FxFltVal(.33);
letters_obj[i].z = FxFltVal(.5);
letters_obj[i].col = 15;
letters_obj[i].draw_style = DRAW_POLYGON;
letters_obj[i].pTexEnv = &gTexEnv[ TEX_AD ];
letters_obj[i].ang = FaDeg(0);
PlaceObject(&letters_obj[i],
CellToMfx(cell.x)+FMAZE_CELL_SIZE/2,
CellToMfx(cell.y)+FMAZE_CELL_SIZE/2);
}
while (i < MAX_LETTERS)
{
letters_obj[i].cell = NULL;
i++;
}
for (i = 0; i < maze_options.nrats; i++)
{
PickRandomCell(&cell);
rats[i].obj.w = FMAZE_CELL_SIZE/4;
rats[i].obj.h = FxFltVal(.125);
rats[i].obj.z = rats[i].obj.h;
rats[i].obj.col = 16;
rats[i].obj.draw_style = DRAW_POLYGON;
rats[i].obj.pTexEnv = &gTexEnv[ TEX_RAT ];
SolveMazeStart(&rats[i].vw, &maze_cells[0][0], MAZE_GRID, MAZE_GRID,
&cell, SOL_DIR_LEFT,
NULL, 0,
(rand() % 1000) > 500 ? SOL_TURN_LEFT : SOL_TURN_RIGHT,
&rats[i].sol);
// Need to force this to NULL when a new maze is generated so
// that moving doesn't try to use old maze data
rats[i].obj.cell = NULL;
UpdateRatPosition(&rats[i]);
}
NewMazeList();
SolveMazeStart(&vw, &maze_cells[0][0], MAZE_GRID, MAZE_GRID,
&start_cell, SOL_DIR_RIGHT,
maze_goals, ngoals,
(rand() % 1000) > 500 ? SOL_TURN_LEFT : SOL_TURN_RIGHT,
&sol);
solve_state = SST_MAZE_GROW;
firstMaze = FALSE;
}
/**************************************************************************\
* Step
*
* Main draw proc
*
\**************************************************************************/
static MazeGoal *found_goal = NULL;
static int rot_step;
void Step(void *data)
{
int i;
MazeGoal *goal;
switch(solve_state)
{
case SST_NEW_MAZE:
view_rot = 0;
maze_height = 0.0f;
NewMaze();
break;
case SST_SOLVING:
for (i = 0; i < maze_options.nrats; i++)
{
SolveMazeStep(&rats[i].vw, &rats[i].sol);
UpdateRatPosition(&rats[i]);
}
goal = SolveMazeStep(&vw, &sol);
if (goal == &maze_goals[GOAL_END])
{
solve_state = SST_MAZE_SHRINK;
}
else if (goal != NULL)
{
solve_state = SST_ROTATE;
found_goal = goal;
rot_step = 0;
}
break;
case SST_MAZE_GROW:
maze_height += .025f;
if (maze_height >= 1.0f)
{
solve_state = SST_SOLVING;
}
break;
case SST_MAZE_SHRINK:
maze_height -= .025f;
if (maze_height <= 0.0f)
{
solve_state = SST_NEW_MAZE;
}
break;
case SST_ROTATE:
view_rot += 10.0;
if (++rot_step == 18)
{
Object *sp_obj;
sp_obj = (Object *)found_goal->user;
RemoveObject(sp_obj);
solve_state = SST_SOLVING;
ngoals--;
if (found_goal < maze_goals+ngoals)
{
memmove(found_goal, found_goal+1,
sizeof(MazeGoal)*(ngoals-(found_goal-maze_goals)));
}
SolveMazeSetGoals(&sol, maze_goals, ngoals);
found_goal = NULL;
if (view_rot >= 360.0)
{
view_rot = 0.0;
}
else
{
view_rot = 180.0;
}
}
break;
}
Draw();
for (i = 0; i < MAX_SPECIALS; i++)
{
// Increment rotations of any specials still present in the maze
if (special_obj[i].cell != NULL)
{
special_obj[i].ang = FaAdd(special_obj[i].ang,
FaDeg(special_obj[i].user1));
special_obj[i].user3 += special_obj[i].user2;
}
}
}
void UpdateModes(void)
{
if (maze_options.depth_test)
{
glEnable(GL_DEPTH_TEST);
}
else
{
glDisable(GL_DEPTH_TEST);
}
}
/**************************************************************************\
* Reshape
*
* - called on resize, expose
* - always called on app startup
*
\**************************************************************************/
void
Reshape(int width, int height, void *data )
{
gfAspect = height == 0 ? 1.0f: (float) width / (float) height;
}
/******************************Public*Routine******************************\
* VerifyTextureFiles
*
* Check that any user specified textures are valid
* - MUST be called at ss_Init, or any error msgs will not display properly
*
\**************************************************************************/
void VerifyTextureFiles(void)
{
int i;
ss_DisableTextureErrorMsgs();
for (i = 0; i < NUM_SURFACES; i++) {
if( gTexInfo[i].bTex && !gTexInfo[i].bDefTex ) {
if( !ss_VerifyTextureFile( &gTexInfo[i].texFile ) )
// use default texture
gTexInfo[i].bDefTex = TRUE;
}
}
}
/******************************Public*Routine******************************\
* CalcRep
*
* Figure out repetion based on size.
*
* - Use 128 pixels as a unit repetition reference
* - Size is always a power of 2
*
\**************************************************************************/
static int
CalcRep( int size )
{
double pow2;
int pow2ref = 8;
int rep;
pow2 = log((double)size) / log((double)2.0);
rep = 1 + pow2ref - (int)pow2;
return rep;
}
// tradeoff
#define MAX_TEX_DIM 128
//#define MAX_TEX_DIM 256
/******************************Public*Routine******************************\
* CalcTexRep
*
* Figure out texture repetition based on texture size.
*
* - mf: ? double for walls/ceiling ?
*
\**************************************************************************/
static void
CalcTexRep( TEXTURE *pTex, IPOINT2D *pTexRep )
{
if( pTex->width >= MAX_TEX_DIM )
pTexRep->x = 1;
else
pTexRep->x = CalcRep( pTex->width );
if( pTex->height >= MAX_TEX_DIM )
pTexRep->y = 1;
else
pTexRep->y = CalcRep( pTex->height );
}
/******************************Public*Routine******************************\
* LoadTextures
*
* Load textures from .bmp files or from embedded resources, using
* global texture info structure.
*
* For now, this also sets render modes, since if texturing is off for a
* surface, we always use RENDER_FLAT
*
\**************************************************************************/
static void
LoadTextures(void)
{
int i;
TEXTURE *pTex = all_textures;
TEX_ENV *pTexEnv = gTexEnv;
TEX_RES *pTexRes;
assert( (NUM_SURFACES + NUM_OBJECT_TEXTURES) == NUM_TEXTURES );
// load surface textures (wall, floor, ceiling)
for (i = 0; i < NUM_SURFACES; i++, pTex++, pTexEnv++) {
maze_options.render[i] = RENDER_FLAT;
if( gTexInfo[i].bTex ) {
pTexEnv->pTex = pTex;
pTexEnv->bTransp = FALSE;
// Load user or default texture for the surface
if( !gTexInfo[i].bDefTex &&
ss_LoadTextureFile( &gTexInfo[i].texFile, pTex )) {
} else
{
// Load default resource texture
pTexRes = &gTexResSurf[ gTexInfo[i].iDefTex ];
if( !ss_LoadTextureResource( pTexRes, pTex ) )
continue;
if( ss_PalettedTextureEnabled() &&
(pTexRes->type == TEX_A8) )
{
pTexEnv->bPalRot = TRUE;
pTexEnv->iPalRot = ss_iRand( 0xff );
} else
pTexEnv->bPalRot = FALSE;
}
maze_options.render[i] = RENDER_TEXTURED;
// Figure out texture repetition
CalcTexRep( pTex, &pTexEnv->texRep );
// We would have to set texture parameters per object here,
// but we just use default ones already set by ss_LoadTexture*
}
}
// load object textures
pTexRes = gTexResObject;
for( i = 0; i < NUM_OBJECT_TEXTURES; i++, pTex++, pTexEnv++, pTexRes++ ) {
if( ss_LoadTextureResource( pTexRes, pTex ) )
pTexEnv->pTex = pTex;
else
pTexEnv->pTex = NULL;
pTexEnv->bTransp = FALSE;
// For now we don't do palrot's on any of the object textures
pTexEnv->bPalRot = FALSE;
// No repetition
pTexEnv->texRep.x = pTexEnv->texRep.y = 1;
}
// Set transparency for some of the textures
ss_SetTextureTransparency( gTexEnv[TEX_START].pTex, 0.42f, FALSE );
ss_SetTextureTransparency( gTexEnv[TEX_END].pTex, 0.4f, FALSE );
ss_SetTextureTransparency( gTexEnv[TEX_AD].pTex, 0.4f, FALSE );
// Enable transparency for some of the texture environments
gTexEnv[TEX_START].bTransp = TRUE;
gTexEnv[TEX_END].bTransp = TRUE;
gTexEnv[TEX_AD].bTransp = TRUE;
}
void UseTextureEnv( TEX_ENV *pTexEnv )
{
static HTEXTURE hCurTex = (HTEXTURE) -1;
HTEXTURE hTex = pTexEnv->pTex;
// We cache the current texture for 'no texture object' case
if( !ss_TextureObjectsEnabled() &&
(hCurTex == hTex) )
return; // same texture, no need to send it down
// Make this texture current
ss_SetTexture( hTex );
// Set texture palette if necessary
if( pTexEnv->bPalRot &&
!ss_TextureObjectsEnabled() &&
ss_PalettedTextureEnabled() ) {
// We need to send down the (rotated) palette
ss_SetTexturePalette( hTex, pTexEnv->iPalRot );
}
hCurTex = hTex;
}
/******************************Public*Routine******************************\
* RotateTexturePalettes
*
* If paletted texturing is enabled, go through the supplied list of texture
* environments, and if any have a palette, increment its rotation by the
* supplied iRot value.
*
\**************************************************************************/
void
RotateTexturePalettes( TEX_ENV *pTexEnv, int count, int iRot )
{
if( !ss_PalettedTextureEnabled() || !pTexEnv )
return;
for( ; count; count--, pTexEnv++ ) {
if( !pTexEnv->pTex || !pTexEnv->pTex->pal )
continue;
if( pTexEnv->bPalRot ) {
// increment palette rotation
pTexEnv->iPalRot += iRot;
if( pTexEnv->iPalRot >= pTexEnv->pTex->pal_size )
pTexEnv->iPalRot = 0;
// Only send down the new palette if texture objects are enabled,
// since otherwise it will be sent down when texture is
// 'made current'
if( ss_TextureObjectsEnabled() ) {
ss_SetTexturePalette( pTexEnv->pTex, pTexEnv->iPalRot );
}
}
}
}
/******************************Public*Routine******************************\
* InitStretchInfo
*
\**************************************************************************/
static void
InitStretchInfo( STRETCH_INFO *pStretch )
{
pStretch->baseWidth = 320;
pStretch->baseHeight = 200;
pStretch->bRatioMode = FALSE;
}
/******************************Public*Routine******************************\
* SetFloaterInfo
*
* Set the size and position of the floating child window
*
\**************************************************************************/
static void
SetFloaterInfo( ISIZE *pParentSize, CHILD_INFO *pChild )
{
float hdtvAspect = 9.0f / 16.0f;
ISIZE *pChildSize = &pChild->size;
// Set width according to user-specified size
// (giSize range is 0..100)
// set min size as 1/3 parent width
pChildSize->width =
(int) ((0.333f + 2.0f*giSize/300.0f) * pParentSize->width);
// Scale height for hdtv aspect ratio
pChildSize->height = (int) (hdtvAspect * pChildSize->width + 0.5f);
// Ensure height not too big
SS_CLAMP_TO_RANGE2( pChildSize->height, 0, pParentSize->height );
pChild->pos.x = (pParentSize->width - pChildSize->width) / 2;
pChild->pos.y = (pParentSize->height - pChildSize->height) / 2;
}
/******************************Public*Routine******************************\
* ss_Init
*
* Initialize - called on first entry into ss.
* Called BEFORE gl is initialized!
* Just do basic stuff here, like set up callbacks, verify dialog stuff, etc.
*
* Fills global SSContext structure with required data, and returns ptr
* to it.
*
\**************************************************************************/
SSContext *
ss_Init( void )
{
getIniSettings();
VerifyTextureFiles();
// Set callbacks
ss_InitFunc( maze_Init );
ss_UpdateFunc( Step );
ss_ReshapeFunc( Reshape );
gssc.depthType = (maze_options.depth_test) ? SS_DEPTH16 : SS_DEPTH_NONE;
// Currently stretch and floater mutex
gssc.bDoubleBuf = TRUE; // will get turned off if stretch used
if( gbTurboMode ) {
// We stretch out the drawing area to the full size of the main window
gssc.bFloater = FALSE;
gssc.bStretch = TRUE;
InitStretchInfo( &gssc.stretchInfo );
} else {
// A static centered floating window is created in the main window
FLOATER_INFO *pFloater = &gssc.floaterInfo;
gssc.bFloater = TRUE;
gssc.bStretch = FALSE;
pFloater->bMotion = FALSE;
pFloater->ChildSizeFunc = SetFloaterInfo;
}
return &gssc;
}
/******************************Public*Routine******************************\
* maze_Init
*
* Initializes OpenGL state
*
\**************************************************************************/
void
maze_Init( void *data )
{
float fv4[4];
if (!FxInitialize(FA_TABLE_SIZE, 0))
{
printf("FxInit failed\n");
exit(1);
}
glShadeModel( GL_FLAT );
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
glClearDepth(1);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
if( (giImageQual == IMAGEQUAL_DEFAULT) || gbTurboMode ) {
maze_options.bDither = FALSE;
glDisable( GL_DITHER );
} else {
maze_options.bDither = TRUE;
glEnable( GL_DITHER );
}
// Load textures and set render modes
LoadTextures();
fv4[0] = MAZE_SIZE/2.0f;
fv4[1] = MAZE_SIZE/2.0f;
fv4[2] = 10.0f;
fv4[3] = 1.0f;
glLightfv(GL_LIGHT0, GL_POSITION, fv4);
glEnable(GL_LIGHT0);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
// Check which texture environment function to use for objects
if( ss_fOnGL11() )
gTexEnvMode = GL_REPLACE;
else
gTexEnvMode = GL_MODULATE;
maze_walls_list = glGenLists(1);
UpdateModes();
}