GameMgr.c

Go to the documentation of this file.

/****************************************************************************************/
/*  GameMgr.c                                                                           */
/*                                                                                      */
/*  Author: John Pollard                                                                */
/*  Description:                                                                        */
/*                                                                                      */
/*  Copyright (c) 1997, 1999, Eclipse Entertainment; All rights reserved.               */
/*                                                                                      */
/*  See the accompanying file LICENSE.TXT for terms on the use of this library.         */
/*  This library is distributed in the hope that it will be useful but WITHOUT          */
/*  ANY WARRANTY OF ANY KIND and without any implied warranty of MERCHANTABILITY        */
/*  or FITNESS FOR ANY PURPOSE.  Refer to LICENSE.TXT for more details.                 */
/*                                                                                      */
/****************************************************************************************/
#include <Windows.h>
#include <Assert.h>
#include <stdio.h>
#include <direct.h>

#include "Ram.h"
#include "Errorlog.h"

#include "GameMgr.h"

#include "Procedurals\gebmutil.h"
#include "procedurals/ProcEng.h"


extern void     GenVS_Error(const char *Msg, ...);

extern geVFile *MainFS;


//====================================================================================
//      Misc defs
//====================================================================================
static HWND CreateMainWindow(HANDLE hInstance, const char *AppName, int32 Width, int32 Height);

//====================================================================================
//      Structure defs
//====================================================================================
typedef struct
{
        geWorld                         *World;                                                         // World pointer for this world data set
        char                            WorldName[GAMEMGR_MAX_WORLD_NAME];

        int32                           NumModels;
        geWorld_Model           *Models[GAMEMGR_MAX_MODELS];

} GameMgr_WorldInfo;

// The GameMgr object
typedef struct GameMgr
{
        GameMgr                         *SelfCheck1;                                            // Head self valid check

        float                           Time;

        // Objects the the game mgr maintains...
        geEngine                        *Engine;                                                        // Engine object
        geSound_System          *SoundSys;                                                      // Soundsystem object
        Console_Console         *Console;

        HWND                            hWnd;

        GameMgr_FrameState      FrameState;
        Fx_System                       *FxSystem;
        geBitmap                        *ShadowMap;


        GameMgr_WorldInfo       WorldInfo[GAMEMGR_MAX_WORLDS];

        // Mode specific stuff
        VidMode                         VidMode;                                                        // Current VidMode
        geCamera                        *Camera;

        GameMgr_ActorIndex              ActorIndex[GAMEMGR_MAX_ACTOR_INDEX];
        GameMgr_MotionIndexDef  MotionIndexDefs[GAMEMGR_MAX_MOTION_INDEX];
        GameMgr_BoneIndex               BoneIndex[GAMEMGR_MAX_BONE_INDEX];
        GameMgr_TextureIndex    TextureIndex[GAMEMGR_MAX_TEXTURE_INDEX];
        GameMgr_SoundIndex              SoundIndex[GAMEMGR_MAX_SOUND_INDEX];

        ProcEng                         *ProcEng;

        GameMgr                         *SelfCheck2;                                            // Tail self valid check
} GameMgr;

//====================================================================================
//      GameMgr_FreeAllObjects
//====================================================================================
void GameMgr_FreeAllObjects(GameMgr *GMgr)
{
        assert(GMgr);

        if (GMgr->Camera)
                geCamera_Destroy(&GMgr->Camera);

        GameMgr_FreeWorld(GMgr);                // Make sure no old world is laying around
        
        if (GMgr->FxSystem)
                Fx_SystemDestroy(GMgr->FxSystem);

        if (GMgr->Console)
                Console_Destroy(GMgr->Console);

        if (GMgr->SoundSys)
                geSound_DestroySoundSystem(GMgr->SoundSys);

        if (GMgr->Engine)
                geEngine_Free(GMgr->Engine);

        GMgr->FxSystem  = NULL;
        GMgr->Engine    = NULL;
        GMgr->Console   = NULL;
        GMgr->SoundSys  = NULL;
        GMgr->Camera    = NULL;

        geRam_Free(GMgr);                               // Free the manager itself...
}

//====================================================================================
//      GameMgr_Create
//====================================================================================
GameMgr *GameMgr_Create(HINSTANCE hInstance, int32 Width, int32 Height, const char *AppName)
{
        GameMgr *GMgr;
        char    PathBuf[_MAX_PATH];

        assert(AppName);

        // Allocate the GameMgr structure
        GMgr = GE_RAM_ALLOCATE_STRUCT(GameMgr);

        if (!GMgr)
        {
                geErrorLog_AddString(-1, "GameMgr_Create:  Out of memory for GameMgr.", NULL);
                return NULL;
        }

        // Zero out memory
        memset(GMgr, 0, sizeof(GameMgr));

        // Save self check flags
        GMgr->SelfCheck1 = GMgr;
        GMgr->SelfCheck2 = GMgr;

        // Create the window
        GMgr->hWnd = CreateMainWindow(hInstance, AppName, Width, Height);
        
        // Create an engine object
        if (_getcwd(PathBuf,_MAX_PATH)==NULL)
                {
                        geErrorLog_AddString(-1, "GameMgr_Create:  Could not get current working directory.", NULL);
                        goto ExitWithError;
                }
        GMgr->Engine = geEngine_Create(GMgr->hWnd, AppName, PathBuf);
        
        if (!GMgr->Engine)
        {
                geErrorLog_AddString(-1, "GameMgr_Create:  Could not create the geEngine object.", NULL);
                goto ExitWithError;
        }

        #ifdef _DEBUG
        geXForm3d_SetMaximalAssertionMode(GE_FALSE);
        #endif
        
        //
        // Create the sound system
        //
        GMgr->SoundSys = geSound_CreateSoundSystem(GMgr->hWnd);

        if (!GMgr->SoundSys)
        {
                geErrorLog_AddString(-1, "GameMgr_Create:  Could not create the geSound_System object. (continuing)", NULL);
                //goto ExitWithError;
        }

        GMgr->ProcEng = NULL;

        return GMgr;

        ExitWithError:
        {
                if (GMgr)
                        GameMgr_FreeAllObjects(GMgr);

                return NULL;
        }
}

//====================================================================================
//      GameMgr_Destroy
//====================================================================================
void GameMgr_Destroy(GameMgr *GMgr)
{
        assert(GMgr);
        assert(GameMgr_IsValid(GMgr) == GE_TRUE);

        GameMgr_FreeAllObjects(GMgr);
}

/*
static  int32   WaterPosX = 2, WaterPosY = 64;
static  int32   NPage;
static  float   TimeToSplashWater = 0.0f;

static  uint8   OriginalBits[256*256];
static  int16   WaterData[2][256*256];

//static        uint8   Blend

void CalcRippleData(int16 *Src, int16 *Dest, int16 Density, int32 W, int32 H)
{
        int32   i,j;
        int16   Val;

        for(i=0; i< H; i++)
        {
                for(j=0; j< W; j++)
                {
                        if (i > 0)                                                      // Get top
                                Val = *(Dest - W);
                        else
                                Val = *(Dest + W * (H-1));

                        if (i < H-1)                                            // Get bottom
                                Val += *(Dest + W);
                        else
                                Val += *(Dest - W * (H-1));

                        if (j > 0)                                                      // Get left
                                Val += *(Dest - 1);
                        else
                                Val += *(Dest + (W-1));

                        if (j < W-1)                                            // Get right
                                Val += *(Dest + 1);
                        else
                                Val += *(Dest - (W-1));

                        Val >>= 1;
                        Val -= *Src;
                        Val -= (Val >> Density);

                        *Src = Val;

                        Src++;
                        Dest++;

                }
        }
}

void UpdateWaterTable(int32 Width, int32 Height, float Time)
{
        int16           *Page1, *Page2, *Page3;

        Page1 = WaterData[NPage];
        Page2 = WaterData[!NPage];

        Page3 = Page2;

        TimeToSplashWater += Time;

        if (TimeToSplashWater > 0.5f)
        {
                int32   px, py, cx, cy, c;
                
                TimeToSplashWater = 0.0f;
                
                for (c=0; c< 2; c++)
                {
                        px=(1+(rand()%(Width-1-3)));
                        py=(1+(rand()%(Height-1-3)));

                        for(cy=py; cy< (py+3); cy++)
                                for(cx=px; cx< (px+3); cx++)
                                        WaterData[!NPage][cy * Width + cx]=128;
                }
        }

        CalcRippleData(Page1, Page2, 4, Width, Height);

        NPage = !NPage;
}
*/

//====================================================================================
//      GameMgr_Frame
//====================================================================================
geBoolean GameMgr_Frame(GameMgr *GMgr, float Time)
{
        assert(GameMgr_IsValid(GMgr) == GE_TRUE);

        if (Time < 0.001f)
                Time = 0.001f;
        
        if (Time > 0.1f)
                Time = 0.1f;
        
        GMgr->Time += Time;

        //
        //      Do an fx system frame
        //
        if (GMgr->FxSystem)
        {
                if (!Fx_SystemFrame(GMgr->FxSystem, Time))
                        GenVS_Error("GameMgr_Frame:  Fx_SystemFrame failed.\n");
        }

        if (GMgr->ProcEng)
        {
                if (!ProcEng_Animate(GMgr->ProcEng, Time))
                        GenVS_Error("GameMgr_Frame:  ProcEng_Animate failed.\n");
        }

        return GE_TRUE;
}

//====================================================================================
//      GameMgr_IsValid
//====================================================================================
geBoolean GameMgr_IsValid(GameMgr *GMgr)
{
        if (!GMgr)
        {
                geErrorLog_AddString(-1, "GameMgr_IsValid:  The GameMgr object passed was NULL.", NULL);
                return GE_FALSE;
        }

        if (GMgr->SelfCheck1 != GMgr)                   // Check head of struct
        {
                geErrorLog_AddString(-1, "GameMgr_IsValid:  SelfCheck1 is invalid.", NULL);
                return GE_FALSE;
        }

        if (GMgr->SelfCheck2 != GMgr)                   // Check tail of struct
        {
                geErrorLog_AddString(-1, "GameMgr_IsValid:  SelfCheck2 is invalid.", NULL);
                return GE_FALSE;
        }

        if (!GMgr->Engine)
        {
                geErrorLog_AddString(-1, "GameMgr_IsValid:  Engine is NULL.", NULL);
                return GE_FALSE;
        }

        return GE_TRUE;
}

//====================================================================================
//      GameMgr_PrepareToChangeMode
//====================================================================================
void GameMgr_PrepareToChangeMode(GameMgr *GMgr)
{
        assert(GameMgr_IsValid(GMgr) == GE_TRUE);

        if (GMgr->Camera)
                geCamera_Destroy(&GMgr->Camera);
        GMgr->Camera = NULL;

        if (GMgr->Console)
                Console_Destroy(GMgr->Console);
        GMgr->Console = NULL;
}

//====================================================================================
//      GameMgr_SetDriverAndMode
//====================================================================================
geBoolean GameMgr_SetDriverAndMode(GameMgr *GMgr, geDriver *Driver, geDriver_Mode *DriverMode, int Width, int Height)
{
        geRect          CameraRect = {0, 0, 0, 0};

        assert(GameMgr_IsValid(GMgr) == GE_TRUE);

        if (VidMode_SetResolution(&(GMgr->VidMode),Width,Height)==GE_FALSE)
                GenVS_Error("GameMgr_SetDriverAndMode:  VidMode_SetResolution failed.\n");

        // Make the camera be a good default value...
        CameraRect.Left = 0;
        CameraRect.Right = Width-1;
        CameraRect.Top = 0;
        CameraRect.Bottom = Height-1;

        //
        // Then create a camera for client, etc to use for rendering, etc...
        //
        GMgr->Camera = geCamera_Create(2.0f, &CameraRect);

        if (!GMgr->Camera)
                GenVS_Error("GameMgr_SetDriverAndMode:  geCamera_Create failed.\n");

        // Set the camera ZScale
//      geCamera_SetZScale(GMgr->Camera, 0.5f);
        geCamera_SetZScale(GMgr->Camera, 1.0f);

        //
        // Create the console with the new vid mode...
        //
        GMgr->Console = Console_Create(GMgr->Engine, GMgr->VidMode);

        if (!GMgr->Console)
                GenVS_Error("GameMgr_SetDriverAndMode:  Console_Create failed.\n");

        Console_Printf(GMgr->Console, "Console Created...\n");

        return GE_TRUE;
}

//====================================================================================
//      GameMgr_BeginFrame
//====================================================================================
geBoolean GameMgr_BeginFrame(GameMgr *GMgr, geWorld *World, geBoolean ClearScreen)
{
        geEngine        *Engine;
        geCamera        *Camera;

        assert(GameMgr_IsValid(GMgr) == GE_TRUE);

        if (GMgr->FrameState != FrameState_None)
                GenVS_Error("GameMgr_BeginFrame:  GMgr->FrameState != FrameState_None.\n");

        Engine = GameMgr_GetEngine(GMgr);
        assert(Engine);

        Camera = GameMgr_GetCamera(GMgr);
        assert(Camera);

        if (!geEngine_BeginFrame(Engine, Camera, ClearScreen))
        {
                GMgr->FrameState = FrameState_None;
                GenVS_Error("GameMgr_BeginFrame:  geEngine_BeginFrame failed.\n");
        }

        GMgr->FrameState = FrameState_Begin;

        return GE_TRUE;
}

//====================================================================================
//      GameMgr_EndFrame
//====================================================================================
geBoolean GameMgr_EndFrame(GameMgr *GMgr)
{
        geEngine        *Engine;

        assert(GameMgr_IsValid(GMgr) == GE_TRUE);

        if (GMgr->FrameState != FrameState_Begin)
                GenVS_Error("GameMgr_EndFrame:  GMgr->FrameState != FrameState_Begin.\n");

        Engine = GameMgr_GetEngine(GMgr);
        assert(Engine);

        if (!geEngine_EndFrame(Engine))
        {
                GMgr->FrameState = FrameState_None;
                GenVS_Error("GameMgr_EndFrame:  geEngine_EndFrame failed.\n");
        }
        
        GMgr->FrameState = FrameState_None;

        return GE_TRUE;
}

//=====================================================================================
//      GameMgr_ConsolePrintf
//=====================================================================================
void GameMgr_ConsolePrintf(GameMgr *GMgr, geBoolean DrawNow, const char *Str, ...)
{
        geCamera                        *Camera;
        geEngine                        *Engine;
        GameMgr_FrameState      OldFrameState;
        geWorld                         *World;

        Engine = GameMgr_GetEngine(GMgr);
        assert(Engine);

        Camera = GameMgr_GetCamera(GMgr);
        assert(Camera);

        World = GMgr->WorldInfo[0].World;
        
        OldFrameState = GMgr->FrameState;

        if (DrawNow && GMgr->FrameState != FrameState_Begin)
        {
                if (!GameMgr_BeginFrame(GMgr, World, GE_TRUE))
                        GenVS_Error("GameMgr_ConsolePrintf:  GameMgr_BeginFrame 1 failed.\n");
        }

        if (!Console_Printf(GMgr->Console, Str))
                GenVS_Error("GameMgr_ConsolePrintf:  Console_Printf failed.\n");

        if (DrawNow && GMgr->FrameState != FrameState_None)
        {
                Console_Frame(GMgr->Console, 0.0f);

                if (!GameMgr_EndFrame(GMgr))
                        GenVS_Error("GameMgr_ConsolePrintf:  GameMgr_EndFrame failed.\n");
                
                if (OldFrameState != GMgr->FrameState)          // Restore old state...
                {
                        if (!GameMgr_BeginFrame(GMgr, World, GE_TRUE))
                                GenVS_Error("GameMgr_ConsolePrintf:  GameMgr_BeginFrame 3 failed.\n");
                }
        }
}

//=====================================================================================
//      GameMgr_ClearBackground
//=====================================================================================
geBoolean GameMgr_ClearBackground(GameMgr *GMgr, int32 x, int32 y, const char *Str)
{
        geCamera                        *Camera;
        geEngine                        *Engine;
        GameMgr_FrameState      OldFrameState;
        geWorld                         *World;

        Engine = GameMgr_GetEngine(GMgr);
        assert(Engine);

        Camera = GameMgr_GetCamera(GMgr);
        assert(Camera);

        World = GMgr->WorldInfo[0].World;

        OldFrameState = GMgr->FrameState;

        if (GMgr->FrameState != FrameState_None)                // Make sure we are not in a nested begin/frame loop
        {
                if (!GameMgr_EndFrame(GMgr))
                        GenVS_Error("GameMgr_ClearBackground:  GameMgr_EndFrame 1 failed.\n");
        }
        
        if (!GameMgr_BeginFrame(GMgr, World, GE_TRUE))
                GenVS_Error("GameMgr_ClearBackground:  GameMgr_BeginFrame 1 failed.\n");

        if (!GameMgr_EndFrame(GMgr))
                GenVS_Error("GameMgr_ClearBackground:  GameMgr_EndFrame failed.\n");

        if (!GameMgr_BeginFrame(GMgr, World, GE_TRUE))
                GenVS_Error("GameMgr_ClearBackground:  GameMgr_BeginFrame 2 failed.\n");

        if (Str)
                geEngine_Printf(Engine, x, y, (char*)Str);

        if (!GameMgr_EndFrame(GMgr))
                GenVS_Error("GameMgr_ClearBackground:  GameMgr_EndFrame 2 failed.\n");

        if (OldFrameState != FrameState_None)           // Restore old state...
        {
                if (!GameMgr_BeginFrame(GMgr, World, GE_TRUE))
                        GenVS_Error("GameMgr_ClearBackground:  GameMgr_BeginFrame 3 failed.\n");
        }

        return GE_TRUE;
}

//====================================================================================
//      GameMgr_FreeWorld
//      Clears GameMgr of all world dependent objects.
//====================================================================================
geBoolean GameMgr_FreeWorld(GameMgr *GMgr)
{
        GameMgr_WorldInfo       *WInfo;
        int32                           i;
        geBoolean                       Ret;

        assert(GameMgr_IsValid(GMgr) == GE_TRUE);

        Ret = GE_TRUE;
        
        WInfo = &GMgr->WorldInfo[0];

        // There is nothing to fre in these arrays, so just zap them
        memset(GMgr->MotionIndexDefs, 0, sizeof(GMgr->MotionIndexDefs));
        memset(GMgr->BoneIndex, 0, sizeof(GMgr->BoneIndex));

        // Free all the actors
        for (i=0; i<GAMEMGR_MAX_ACTOR_INDEX; i++)
        {
                GameMgr_ActorIndex              *AIndex;

                AIndex = &GMgr->ActorIndex[i];
                
                if (AIndex->ActorDef)
                {
                        assert(WInfo->World);
                        assert(AIndex->Active == GE_TRUE);
                        assert(AIndex->ActorHack);
                        
                        if (!geWorld_RemoveActor(WInfo->World, AIndex->ActorHack))
                        {
                                geErrorLog_AddString(-1, "GameMgr_FreeWorld:  geWorld_RemoveActor failed.", NULL);
                                Ret = GE_FALSE;
                        }
                        
                        geActor_Destroy(&AIndex->ActorHack);

                        geActor_DefDestroy(&AIndex->ActorDef);
                }
                
                memset(AIndex, 0, sizeof(*AIndex));
        }

        // Free all the textures
        for (i=0; i<GAMEMGR_MAX_TEXTURE_INDEX; i++)
        {
                GameMgr_TextureIndex *TIndex;

                TIndex = &GMgr->TextureIndex[i];

                if (TIndex->TextureDef)
                {
                        assert(WInfo->World);                           // If there are bitmaps, there better be a world!!!
                        assert(TIndex->Active == GE_TRUE);

                        if (!geWorld_RemoveBitmap(WInfo->World, TIndex->TextureDef))
                                Ret = GE_FALSE;

                        geBitmap_Destroy(&TIndex->TextureDef);
                }

                memset(TIndex, 0, sizeof(*TIndex));
        }

        for (i=0; i<GAMEMGR_MAX_SOUND_INDEX; i++)
        {
                GameMgr_SoundIndex *SIndex;

                SIndex = &GMgr->SoundIndex[i];

                if (SIndex->SoundDef)
                {
                        assert(GMgr->SoundSys);                         // If there are sounds, there better be a sound system!!!
                        assert(SIndex->Active == GE_TRUE);
                        geSound_FreeSoundDef(GMgr->SoundSys, SIndex->SoundDef);
                }
                memset(SIndex, 0, sizeof(*SIndex));
        }

        if (GMgr->FxSystem)             // YES, Fx_System depends on a world, so it must be freed now, until a new world is loaded...
        {
                Fx_SystemDestroy(GMgr->FxSystem);
                GMgr->FxSystem = NULL;
        }

        if (GMgr->ShadowMap)
        {
                assert(WInfo->World);

                geWorld_RemoveBitmap(WInfo->World, GMgr->ShadowMap);
                geBitmap_Destroy( &(GMgr->ShadowMap) );
                GMgr->ShadowMap = NULL;
        }

        // Free the world last, so that all data contained in the world would have been freed above...
        // Free any previously existing world
        if (WInfo->World)
        {
                if (!Electric_Shutdown())
                {
                        geErrorLog_AddString(-1, "GameMgr_FreeWorld:  Electric_Shutdown failed...", NULL);
                        Ret = GE_FALSE;
                }

                if (!Corona_Shutdown())
                {
                        geErrorLog_AddString(-1, "GameMgr_FreeWorld:  Corona_Shutdown failed...", NULL);
                        Ret = GE_FALSE;
                }

                if (!geEngine_RemoveWorld(GMgr->Engine, WInfo->World))
                {
                        geErrorLog_AddString(-1, "GameMgr_FreeWorld:  geEngine_RemoveWorld failed...", NULL);
                        Ret = GE_FALSE;
                }

                geWorld_Free(WInfo->World);
                
                if ( GMgr->ProcEng )
                        ProcEng_Destroy(&(GMgr->ProcEng));
                GMgr->ProcEng = NULL;
        }

        WInfo->World = NULL;

        GMgr->Time = 0.0f;              // FIXME:  Take out?  Put in GameMgr_SetWorld?

        return Ret;
}

#define PATH_SEPERATOR '/'

//=====================================================================================
//      DefaultExtension
//=====================================================================================
void DefaultExtension (char *Path, const char *Ext)
{
        char    *Src;
        
        Src = Path + strlen(Path) - 1;

        while (*Src != PATH_SEPERATOR && Src != Path)
        {
                if (*Src == '.')
                        return;                 // it has an extension
                Src--;
        }

        strcat (Path, Ext);
}

//====================================================================================
//      GameMgr_SetWorld
//      Sets the current world in the GameMgr.
//====================================================================================
geBoolean GameMgr_SetWorld(GameMgr *GMgr, const char *WorldName)
{
        GameMgr_WorldInfo       *WInfo;
        geWorld_Model           *Model;
        geVFile *                       WorldFile;
        char                            TFile[GAMEMGR_MAX_WORLD_NAME+4];
        int                                     Width,Height;
        int                                     MessageWidth = 250;

        assert(GameMgr_IsValid(GMgr) == GE_TRUE);
        assert(strlen(WorldName) < GAMEMGR_MAX_WORLD_NAME);
        
        strcpy(TFile, WorldName);

        DefaultExtension(TFile, ".BSP");

        WInfo = &GMgr->WorldInfo[0];

        if (GameMgr_GetFrameState(GMgr) != FrameState_None)
                GenVS_Error("GameMgr_SetWorld:  GameMgr_GetFrameState(GMgr) != FrameState_None.\n");

        VidMode_GetResolution(GMgr->VidMode,&Width,&Height);

        if (!GameMgr_ClearBackground(GMgr, (Width/2)-(MessageWidth/2), Height/2-10, "Loading level, please wait..."))
                GenVS_Error("GameMgr_SetWorld:  GameMgr_ClearBackground failed.\n");
        //GameMgr_ConsolePrintf(GMgr, GE_TRUE, "Loading level, please wait...\n");

        // Make sure we free the old world!!!
        GameMgr_FreeWorld(GMgr);                // Clear all that belongs to world stuff

        WorldFile = geVFile_Open(MainFS, TFile, GE_VFILE_OPEN_READONLY);

        if      (!WorldFile)
                GenVS_Error("GameMgr_SetWorld:  geVFile_Open failed: %s.\n", TFile);

        WInfo->World = geWorld_Create(WorldFile);
        geVFile_Close(WorldFile);

        if (!WInfo->World)
                GenVS_Error("GameMgr_SetWorld:  geWorld_Create failed: %s.\n", TFile);

        if (!geEngine_AddWorld(GMgr->Engine, WInfo->World))
                GenVS_Error("GameMgr_SetWorld:  geEngine_AddWorld failed: %s.\n", TFile);

        {
        char ProcCfgName[1024];
        geVFile * ProcCfgFile;
                strcpy(ProcCfgName,TFile);
                assert( ProcCfgName[ strlen(TFile) - 4 ] == '.' );
                ProcCfgName[ strlen(TFile) - 4 ] = 0;
                strcat(ProcCfgName,".prc");
                ProcCfgFile = geVFile_Open(MainFS,ProcCfgName, GE_VFILE_OPEN_READONLY);
                
                if      (!ProcCfgFile)
                {
                }
                else
                {
                        GMgr->ProcEng = ProcEng_Create(ProcCfgFile, WInfo->World);
                        geVFile_Close(ProcCfgFile);
                }
        }

        GMgr->FxSystem = Fx_SystemCreate(WInfo->World, NULL);

        if (!GMgr->FxSystem)
                GenVS_Error("GameMgr_SetWorld:  Fx_SystemCreate failed.\n");

        // Create the gamemgr shadow map
        if (!(GMgr->ShadowMap = geBitmapUtil_CreateFromFileAndAlphaNames(MainFS, "Bmp\\Fx\\Smoke_05.bmp", "Bmp\\Fx\\A_Smk05.bmp")) )
                GenVS_Error("GameMgr_SetWorld:  geBitmapUtil_CreateFromFileAndAlphaNames failed.\n");

        if (!geWorld_AddBitmap( WInfo->World, GMgr->ShadowMap) )
                GenVS_Error("GameMgr_SetWorld:  geWorld_AddBitmap failed.\n");

        // Setup the models with the world
        WInfo->NumModels = 0;
        Model = NULL;

        while(1)
        {
                assert(WInfo->NumModels <= GAMEMGR_MAX_MODELS);

                Model = geWorld_GetNextModel(WInfo->World, Model);

                if (!Model)
                        break;

                WInfo->Models[WInfo->NumModels] = Model;
                WInfo->NumModels++;
        }

        // Set some light type defaults
        geWorld_SetLTypeTable(WInfo->World, 0, "z");
        geWorld_SetLTypeTable(WInfo->World, 1, "mmnmmommommnonmmonqnmmo");
        geWorld_SetLTypeTable(WInfo->World, 2, "abcdefghijklmnopqrstuvwxyzyxwvutsrqponmlkjihgfedcba");
        geWorld_SetLTypeTable(WInfo->World, 3, "mmmmmaaaaammmmmaaaaaabcdefgabcdefg");
        geWorld_SetLTypeTable(WInfo->World, 4, "mamamamamama");
        geWorld_SetLTypeTable(WInfo->World, 5, "jklmnopqrstuvwxyzyxwvutsrqponmlkj");
        geWorld_SetLTypeTable(WInfo->World, 6, "nmonqnmomnmomomno");
        geWorld_SetLTypeTable(WInfo->World, 7, "mmmaaaabcdefgmmmmaaaammmaamm");
        geWorld_SetLTypeTable(WInfo->World, 8, "mmmaaammmaaammmabcdefaaaammmmabcdefmmmaaaa");
        geWorld_SetLTypeTable(WInfo->World, 9, "aaaaaaaazzzzzzzz");
        geWorld_SetLTypeTable(WInfo->World, 10,"mmamammmmammamamaaamammma");
        geWorld_SetLTypeTable(WInfo->World, 11,"abcdefghijklmnopqrrqponmlkjihgfedcba");

        assert(GMgr->Engine);
        
        // Create the coronas
        if (!Corona_Init(GameMgr_GetEngine(GMgr), GameMgr_GetWorld(GMgr), MainFS))
                GenVS_Error("GameMgr_SetWorld:  Corona_Init failed.\n");

        // Create the electric interface
        if (!Electric_Init(GameMgr_GetEngine(GMgr), GameMgr_GetWorld(GMgr), MainFS, GameMgr_GetSoundSystem(GMgr)))
                GenVS_Error("GameMgr_SetWorld:  Electric_Init failed.\n");

        // Create the dynlight interface
        if (!DynLight_Init(GameMgr_GetEngine(GMgr), GameMgr_GetWorld(GMgr), MainFS))
                GenVS_Error("GameMgr_SetWorld:  DynLight_Init failed.\n");

        // Create the ModelCtl interface
        if (!ModelCtl_Init())
                GenVS_Error("GameMgr_SetWorld:  ModelCtl_Init failed.\n");

        return GE_TRUE;
}

//====================================================================================
//      GameMgr_SetActorIndex
//====================================================================================
geBoolean GameMgr_SetActorIndex(GameMgr *GMgr, int32 Index, const char *FileName)
{
        GameMgr_WorldInfo       *WInfo;
        GameMgr_ActorIndex      *ActorIndex;
        geVFile *                               File;

        assert(GameMgr_IsValid(GMgr) == GE_TRUE);
        assert(FileName);
        assert(strlen(FileName) < GAMEMGR_MAX_ACTOR_NAME);
        assert(Index < GAMEMGR_MAX_ACTOR_INDEX);

        ActorIndex = &GMgr->ActorIndex[Index];

        assert(ActorIndex->ActorDef == NULL);
        assert(ActorIndex->ActorHack == NULL);
        assert(ActorIndex->Active == GE_FALSE);
        assert(GameMgr_GetFrameState(GMgr) == FrameState_None);

        if (GameMgr_GetFrameState(GMgr) != FrameState_None)
                GenVS_Error("GameMgr_SetActorIndex:  GameMgr_GetFrameState(GMgr) != FrameState_None.\n");

        WInfo = &GMgr->WorldInfo[0];

        assert(WInfo->World);

        if (!WInfo->World)
                GenVS_Error("GameMgr_SetActorIndex:  NULL World.\n");

        // It is safe to load the mesh index at this point...
        File = geVFile_Open(MainFS, FileName, GE_VFILE_OPEN_READONLY);

        if      (!File)
                GenVS_Error("GameMgr_SetActorIndex:  geVFile_Open failed: %s.\n", FileName);

        ActorIndex->ActorDef = geActor_DefCreateFromFile(File);
        geVFile_Close(File);

        if (!ActorIndex->ActorDef)
                GenVS_Error("GameMgr_SetActorIndex:  geActor_DefCreateFromFile failed: %s.\n", FileName);

        // Make our "fake" player, do we know for sure that the textures will remain in memory...
        ActorIndex->ActorHack = geActor_Create(ActorIndex->ActorDef);
        geWorld_AddActor(WInfo->World, ActorIndex->ActorHack, 0, 0);
        
        if (!ActorIndex->ActorHack)
                GenVS_Error("GameMgr_SetActorIndex:  geWorld_AddActor failed: %s.\n", FileName);

        strcpy(ActorIndex->FileName, FileName);
        ActorIndex->Active = GE_TRUE;

        return GE_TRUE;
}

//====================================================================================
//      GameMgr_GetActorIndex
//====================================================================================
GameMgr_ActorIndex *GameMgr_GetActorIndex(GameMgr *GMgr, int32 Index)
{
        assert(GameMgr_IsValid(GMgr) == GE_TRUE);
        assert(Index >= 0 && Index < GAMEMGR_MAX_ACTOR_INDEX);

        return &GMgr->ActorIndex[Index];
}

//====================================================================================
//      GameMgr_MotionIndexIsValid
//====================================================================================
geBoolean GameMgr_MotionIndexIsValid(GameMgr *GMgr, GameMgr_MotionIndex Index)
{
        if (Index == GAMEMGR_MOTION_INDEX_NONE)
                return GE_FALSE;

        if (Index < 0 || Index >= GAMEMGR_MAX_MOTION_INDEX)
                return GE_FALSE;

        return GE_TRUE;
}

//=====================================================================================
//      GameMgr_SetMotionIndexDef
//=====================================================================================
geBoolean GameMgr_SetMotionIndexDef(GameMgr *GMgr, GameMgr_MotionIndex Index, const char *MotionName)
{
        assert(GameMgr_IsValid(GMgr) == GE_TRUE);
        assert(MotionName);
        assert(strlen(MotionName) < GAMEMGR_MAX_MOTION_NAME);
        assert(GameMgr_MotionIndexIsValid(GMgr, Index));
        assert(GMgr->MotionIndexDefs[Index].Active == GE_FALSE);

        strcpy(GMgr->MotionIndexDefs[Index].MotionName, MotionName);
        GMgr->MotionIndexDefs[Index].Active = GE_TRUE;

        return GE_TRUE;
}

//====================================================================================
//      GameMgr_GetMotionIndexDef
//====================================================================================
GameMgr_MotionIndexDef *GameMgr_GetMotionIndexDef(GameMgr *GMgr, GameMgr_MotionIndex Index)
{
        assert(GameMgr_IsValid(GMgr) == GE_TRUE);
        assert(GameMgr_MotionIndexIsValid(GMgr, Index));

        return &GMgr->MotionIndexDefs[Index];
}

//=====================================================================================
//      GameMgr_SetBoneIndex
//=====================================================================================
geBoolean GameMgr_SetBoneIndex(GameMgr *GMgr, int32 BoneIndex, const char *BoneName)
{
        assert(GameMgr_IsValid(GMgr) == GE_TRUE);
        assert(BoneName);
        assert(BoneIndex < GAMEMGR_MAX_BONE_INDEX);
        assert(strlen(BoneName) < GAMEMGR_MAX_BONE_NAME);
        assert(GMgr->BoneIndex[BoneIndex].Active == GE_FALSE);

        strcpy(GMgr->BoneIndex[BoneIndex].BoneName, BoneName);
        GMgr->BoneIndex[BoneIndex].Active = GE_TRUE;

        return GE_TRUE;
}

//====================================================================================
//      GameMgr_GetBoneIndex
//====================================================================================
GameMgr_BoneIndex *GameMgr_GetBoneIndex(GameMgr *GMgr, int32 Index)
{
        assert(GameMgr_IsValid(GMgr) == GE_TRUE);
        assert(Index >= 0 && Index < GAMEMGR_MAX_BONE_INDEX);

        return &GMgr->BoneIndex[Index];
}

//====================================================================================
//      GameMgr_SetTextureIndex
//====================================================================================
geBoolean GameMgr_SetTextureIndex(GameMgr *GMgr, int32 Index, const char *FileName, const char *AFileName)
{
        GameMgr_WorldInfo               *WInfo;
        const char                              *pFileName, *pAFileName;
        GameMgr_TextureIndex    *TextureIndex;
        geBitmap                                *ABitmap;

        ABitmap = NULL;

        assert(GameMgr_IsValid(GMgr) == GE_TRUE);
        assert(Index >= 0 && Index < GAMEMGR_MAX_TEXTURE_INDEX);
        assert(FileName);
        assert(FileName[0]);
        assert(strlen(FileName) < GAMEMGR_MAX_FILENAME);

        TextureIndex = &GMgr->TextureIndex[Index];

        assert(TextureIndex->TextureDef == NULL);
        assert(TextureIndex->Active == GE_FALSE);
        assert(GameMgr_GetFrameState(GMgr) == FrameState_None);

        if (GameMgr_GetFrameState(GMgr) != FrameState_None)
                GenVS_Error("GameMgr_SetTextureIndex:  GameMgr_GetFrameState(GMgr) != FrameState_None.\n");

        WInfo = &GMgr->WorldInfo[0];

        assert(WInfo->World);

        if (!WInfo->World)
                GenVS_Error("GameMgr_SetTextureIndex:  NULL World.\n");

        // It is now safe to load the texture...
        // It better be NULL first!!! ot somthing went wrong...
        pFileName = FileName;
        
        if (AFileName && AFileName[0])
        {
                assert(strlen(AFileName) < GAMEMGR_MAX_FILENAME);
                pAFileName = AFileName;
        }
        else
                pAFileName = NULL;

        // Create the bitmaps
        TextureIndex->TextureDef = geBitmap_CreateFromFileName(MainFS, pFileName);

        if (!TextureIndex->TextureDef)
        {
                geErrorLog_AddString(-1, "GameMgr_SetTextureIndex:  geBitmap_CreateFromFileName failed:", pFileName);
                goto ExitWithError;
        }

        // Load the alpha bitmap
        if (pAFileName)
        {
                ABitmap = geBitmap_CreateFromFileName(MainFS, pAFileName);

                if (!geBitmap_SetAlpha(TextureIndex->TextureDef, ABitmap))
                {
                        geErrorLog_AddString(-1, "GameMgr_SetTextureIndex:  geBitmap_SetAlpha failed.", NULL);
                        goto ExitWithError;
                }
                
                // Don't need this anymore
                geBitmap_Destroy(&ABitmap);
        }

        if (!geWorld_AddBitmap(WInfo->World, TextureIndex->TextureDef))
        {
                geErrorLog_AddString(-1, "GameMgr_SetTextureIndex:  geWorld_AddBimap failed.", NULL);
                goto ExitWithError;
        }

        strcpy(TextureIndex->FileName, FileName);
        strcpy(TextureIndex->AFileName, AFileName);
        TextureIndex->Active = GE_TRUE;

        return GE_TRUE;

        ExitWithError:
        {
                if (TextureIndex->TextureDef)
                {
                        geBitmap_Destroy(&TextureIndex->TextureDef);
                        TextureIndex->TextureDef = NULL;
                }

                if (ABitmap)
                {
                        geBitmap_Destroy(&ABitmap);
                        ABitmap = NULL;
                }

                GenVS_Error("GameMgr_SetTextureIndex:  Failed.\n");
                return GE_FALSE;                // Shut up compiler
        }
}

//====================================================================================
//      GameMgr_GetTextureIndex
//====================================================================================
GameMgr_TextureIndex *GameMgr_GetTextureIndex(GameMgr *GMgr, int32 Index)
{
        assert(GameMgr_IsValid(GMgr) == GE_TRUE);
        assert(Index >= 0 && Index < GAMEMGR_MAX_TEXTURE_INDEX);

        return &GMgr->TextureIndex[Index];
}

//=====================================================================================
//      GameMgr_SetSoundIndex
//=====================================================================================
geBoolean GameMgr_SetSoundIndex(GameMgr *GMgr, int32 SoundIndex, const char *FileName)
{
        GameMgr_SoundIndex      *pSoundIndex;
        geVFile *                               File;

        assert(GameMgr_IsValid(GMgr) == GE_TRUE);
        
        if (!GMgr->SoundSys)
                return GE_TRUE;
        
        assert(FileName);
        assert(SoundIndex < GAMEMGR_MAX_SOUND_INDEX);
        assert(strlen(FileName) < GAMEMGR_MAX_FILENAME);
        
        pSoundIndex = &GMgr->SoundIndex[SoundIndex];

        assert(pSoundIndex->Active == GE_FALSE);
        assert(pSoundIndex->SoundDef == NULL);

        File = geVFile_Open(MainFS, FileName, GE_VFILE_OPEN_READONLY);

        if (!File)
                GenVS_Error("GameMgr_SetSoundIndex:  geVFile_Open failed: %s.\n", FileName);

        pSoundIndex->SoundDef = geSound_LoadSoundDef(GMgr->SoundSys, File);
        geVFile_Close(File);

        if (!pSoundIndex->SoundDef)
                GenVS_Error("geSound_LoadSoundDef:  geVFile_Open failed: %s.\n", FileName);

        assert(pSoundIndex->SoundDef);

        strcpy(pSoundIndex->FileName, FileName);
        pSoundIndex->Active = GE_TRUE;

        return GE_TRUE;
}

//====================================================================================
//      GameMgr_GetSoundIndex
//====================================================================================
GameMgr_SoundIndex *GameMgr_GetSoundIndex(GameMgr *GMgr, int32 Index)
{
        assert(GameMgr_IsValid(GMgr) == GE_TRUE);
        assert(Index >= 0 && Index < GAMEMGR_MAX_SOUND_INDEX);

        return &GMgr->SoundIndex[Index];
}

//====================================================================================
//      GameMgr_GetEngine
//====================================================================================
geEngine *GameMgr_GetEngine(GameMgr *GMgr)
{
        assert(GameMgr_IsValid(GMgr) == GE_TRUE);

        return GMgr->Engine;
}

//====================================================================================
//      GameMgr_GetSoundSystem
//====================================================================================
geSound_System *GameMgr_GetSoundSystem(GameMgr *GMgr)
{
        assert(GameMgr_IsValid(GMgr) == GE_TRUE);

        return GMgr->SoundSys;
}

//====================================================================================
//      GameMgr_GetConsole
//====================================================================================
Console_Console *GameMgr_GetConsole(GameMgr *GMgr)
{
        assert(GameMgr_IsValid(GMgr) == GE_TRUE);

        return GMgr->Console;
}

//====================================================================================
//      GameMgr_GetWorld
//====================================================================================
geWorld *GameMgr_GetWorld(GameMgr *GMgr)
{
        assert(GameMgr_IsValid(GMgr) == GE_TRUE);

        return GMgr->WorldInfo[0].World;
}

//====================================================================================
//      GameMgr_GetCamera
//====================================================================================
geCamera *GameMgr_GetCamera(GameMgr *GMgr)
{
        assert(GameMgr_IsValid(GMgr) == GE_TRUE);

        return GMgr->Camera;
}

//====================================================================================
//      GameMgr_GetFrameState
//====================================================================================
GameMgr_FrameState GameMgr_GetFrameState(GameMgr *GMgr)
{
        assert(GameMgr_IsValid(GMgr) == GE_TRUE);

        return GMgr->FrameState;
}

//====================================================================================
//      GameMgr_GetNumModels
//====================================================================================
int32 GameMgr_GetNumModels(GameMgr *GMgr)
{
        assert(GameMgr_IsValid(GMgr) == GE_TRUE);

        return GMgr->WorldInfo[0].NumModels;
}

//====================================================================================
//      GameMgr_GetModel
//====================================================================================
geWorld_Model *GameMgr_GetModel(GameMgr *GMgr, int32 Index)
{
        assert(GameMgr_IsValid(GMgr) == GE_TRUE);

        assert(Index >= 0 && Index < GameMgr_GetNumModels(GMgr));

        return GMgr->WorldInfo[0].Models[Index];
}

//====================================================================================
//      GameMgr_GetFxSystem
//====================================================================================
Fx_System *GameMgr_GetFxSystem(GameMgr *GMgr)
{
        assert(GameMgr_IsValid(GMgr) == GE_TRUE);

        return GMgr->FxSystem;
}

//====================================================================================
//      GameMgr_GetShadowMap
//====================================================================================
geBitmap *GameMgr_GetShadowMap(GameMgr *GMgr)
{
        assert(GameMgr_IsValid(GMgr) == GE_TRUE);

        return GMgr->ShadowMap;
}

//====================================================================================
//      GameMgr_GetTime
//====================================================================================
float GameMgr_GetTime(GameMgr *GMgr)
{
        assert(GameMgr_IsValid(GMgr) == GE_TRUE);

        return GMgr->Time;
}

//====================================================================================
//      GameMgr_GethWnd
//====================================================================================
HWND GameMgr_GethWnd(GameMgr *GMgr)
{
        assert(GameMgr_IsValid(GMgr) == GE_TRUE);

        return GMgr->hWnd;
}

//====================================================================================
//      GameMgr_GetVidMode
//====================================================================================
VidMode GameMgr_GetVidMode(GameMgr *GMgr)
{
        assert(GameMgr_IsValid(GMgr) == GE_TRUE);

        return GMgr->VidMode;
}

LRESULT CALLBACK WndProc(HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam);


void GameMgr_ResetMainWindow(HWND hWnd, int32 Width, int32 Height)
{
        RECT ScreenRect;

        GetWindowRect(GetDesktopWindow(),&ScreenRect);

        SetWindowLong(hWnd, 
                 GWL_STYLE, 
                 GetWindowLong(hWnd, GWL_STYLE) & ~WS_POPUP);

        SetWindowLong(hWnd, 
                 GWL_STYLE, 
                 GetWindowLong(hWnd, GWL_STYLE) | (WS_OVERLAPPED  | 
                                                   WS_CAPTION     | 
                                                   WS_SYSMENU     | 
                                                   WS_MINIMIZEBOX));

        SetWindowLong(hWnd, 
                  GWL_STYLE, 
                  GetWindowLong(hWnd, GWL_STYLE) | WS_THICKFRAME |
                                                     WS_MAXIMIZEBOX);

        //SetWindowLong(hWnd, 
    //              GWL_EXSTYLE, 
    //              GetWindowLong(hWnd, GWL_EXSTYLE) | WS_EX_TOPMOST);

        {
                RECT ClientRect;
                int Style = GetWindowLong (hWnd, GWL_STYLE);
                
                ClientRect.left = 0;
                ClientRect.top = 0;
                ClientRect.right = Width - 1;
                ClientRect.bottom = Height - 1;
                AdjustWindowRect (&ClientRect, Style, FALSE);   // FALSE == No menu     
                
                {
                        int WindowWidth = ClientRect.right - ClientRect.left + 1;
                        int WindowHeight = ClientRect.bottom - ClientRect.top + 1;
                        SetWindowPos 
                        (
                                hWnd, HWND_TOP,
                                (ScreenRect.right+ScreenRect.left)/2 - WindowWidth/2,
                                (ScreenRect.bottom+ScreenRect.top)/2 - WindowHeight/2, 
                                WindowWidth, WindowHeight,
                                SWP_NOCOPYBITS | SWP_NOZORDER
                        );
                }
        }

        ShowWindow(hWnd, SW_SHOWNORMAL);
        UpdateWindow(hWnd);
        SetFocus(hWnd);
}

//=====================================================================================
//      CreateMainWindow
//=====================================================================================
static HWND CreateMainWindow(HANDLE hInstance, const char *AppName, int32 Width, int32 Height)
{
        WNDCLASS                wc;
        HWND                    hWnd;
        RECT                ScreenRect;
        
        //
        // Set up and register application window class
        //
        wc.style         = CS_HREDRAW | CS_VREDRAW;
        wc.lpfnWndProc   = WndProc;
        wc.cbClsExtra    = 0;
        wc.cbWndExtra    = 0;
        wc.hInstance     = hInstance;
        // change this if we ever make an icon.
        wc.hIcon         = NULL; //LoadIcon(hInstance, IDI_APPLICATION);
        wc.hCursor       = LoadCursor(NULL, IDC_ARROW);
        wc.hbrBackground = GetStockObject(BLACK_BRUSH);
        wc.lpszMenuName  = (const char*)NULL;
        wc.lpszClassName = AppName;

        RegisterClass(&wc);

        //
        // Create application's main window
        //
        GetWindowRect(GetDesktopWindow(),&ScreenRect);
        hWnd = CreateWindowEx(
                0,
                AppName,
                AppName,
                0,
                (ScreenRect.right+ScreenRect.left)/2 - Width/2,
                (ScreenRect.bottom+ScreenRect.top)/2 - Height/2, 
                Width,
                Height,
                NULL,
                NULL,
                hInstance,
                NULL);

        if (!hWnd)
        {
                MessageBox(0, "Could not create window.", "** ERROR **", MB_OK);
                _exit(1);
        }       

        
        GameMgr_ResetMainWindow(hWnd, Width, Height);
        SetFocus(hWnd);

        return hWnd;

}

---