// fill buffers with the static screen
void initLoadingScreen( bool drawbdrop )
{
setupLoadingScreen();
wzShowMouse(false);
pie_SetFogStatus(false);
// setup the callback....
resSetLoadCallback(loadingScreenCallback);
if (drawbdrop)
{
if (!screen_GetBackDrop())
{
pie_LoadBackDrop(SCREEN_RANDOMBDROP);
}
screen_RestartBackDrop();
}
else
{
screen_StopBackDrop();
}
// Start with two cleared buffers as the hacky loading screen code re-uses old buffers to create its effect.
pie_ScreenFlip(CLEAR_BLACK);
pie_ScreenFlip(CLEAR_BLACK);
}
static void pie_Draw3DButton(iIMDShape *shape)
{
const PIELIGHT colour = WZCOL_WHITE;
const PIELIGHT teamcolour = pal_GetTeamColour(NetPlay.players[selectedPlayer].colour);
pie_SetFogStatus(false);
pie_SetDepthBufferStatus(DEPTH_CMP_LEQ_WRT_ON);
pie_ActivateShader(SHADER_BUTTON, shape, teamcolour, colour);
pie_SetRendMode(REND_OPAQUE);
glColor4ubv(colour.vector); // Only need to set once for entire model
pie_SetTexturePage(shape->texpage);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_NORMAL_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glBindBuffer(GL_ARRAY_BUFFER, shape->buffers[VBO_VERTEX]); glVertexPointer(3, GL_FLOAT, 0, NULL);
glBindBuffer(GL_ARRAY_BUFFER, shape->buffers[VBO_NORMAL]); glNormalPointer(GL_FLOAT, 0, NULL);
glBindBuffer(GL_ARRAY_BUFFER, shape->buffers[VBO_TEXCOORD]); glTexCoordPointer(2, GL_FLOAT, 0, NULL);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, shape->buffers[VBO_INDEX]);
glDrawElements(GL_TRIANGLES, shape->npolys * 3, GL_UNSIGNED_SHORT, NULL);
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
polyCount += shape->npolys;
pie_DeactivateShader();
pie_SetDepthBufferStatus(DEPTH_CMP_ALWAYS_WRT_ON);
}
void pie_SetDefaultStates(void)//Sets all states
{
// pie_SetFogColour(0x00B08f5f);//nicks colour
//fog off
rendStates.fogEnabled = FALSE;// enable fog before renderer
rendStates.fog = FALSE;//to force reset to false
pie_SetFogStatus(FALSE);
pie_SetFogColour(0x00000000);//nicks colour
//depth Buffer on
rendStates.depthBuffer = FALSE;//to force reset to true
pie_SetDepthBufferStatus(DEPTH_CMP_LEQ_WRT_ON);
//set render mode
pie_SetTranslucent(TRUE);
pie_SetAdditive(TRUE);
//basic gouraud textured rendering
rendStates.texCombine = TEX_NONE;//to force reset to GOURAUD_TEX
pie_SetTexCombine(TEX_LOCAL);
rendStates.colourCombine = COLOUR_FLAT_CONSTANT;//to force reset to GOURAUD_TEX
pie_SetColourCombine(COLOUR_TEX_ITERATED);
rendStates.alphaCombine = ALPHA_ITERATED;//to force reset to GOURAUD_TEX
pie_SetAlphaCombine(ALPHA_CONSTANT);
rendStates.transMode = TRANS_ALPHA;//to force reset to DECAL
pie_SetTranslucencyMode(TRANS_DECAL);
//chroma keying on black
rendStates.keyingOn = FALSE;//to force reset to true
pie_SetColourKeyedBlack(TRUE);
//bilinear filtering
rendStates.bilinearOn = FALSE;//to force reset to true
pie_SetBilinear(TRUE);
}
// fill buffers with the static screen
void startCreditsScreen(void)
{
lastChange = gameTime;
pie_LoadBackDrop(SCREEN_CREDITS);
pie_SetFogStatus(false);
pie_ScreenFlip(CLEAR_BLACK);//init loading
}
void displayIMDButton(iIMDShape *IMDShape, Vector3i *Rotation, Vector3i *Position, bool RotXYZ, SDWORD scale)
{
setMatrix(Position, Rotation, RotXYZ);
pie_MatScale(scale / 100.f);
pie_SetFogStatus(false);
pie_Draw3DShape(IMDShape, 0, getPlayerColour(selectedPlayer), WZCOL_WHITE, pie_BUTTON, 0);
unsetMatrix();
}
void loop_ClearVideoPlaybackMode(void)
{
videoMode -=1;
paused = false;
video = false;
gameTimeStart();
pie_SetFogStatus(true);
cdAudio_Resume();
wzShowMouse(true);
ASSERT( videoMode == 0, "loop_ClearVideoPlaybackMode: out of sync." );
}
// fill buffers with the static screen
void startCreditsScreen(void)
{
SCREENTYPE screen = SCREEN_CREDITS;
lastChange = gameTime;
// fill buffers
pie_LoadBackDrop(screen);
pie_SetFogStatus(false);
pie_ScreenFlip(CLEAR_BLACK);//init loading
}
void loop_SetVideoPlaybackMode(void)
{
videoMode += 1;
paused = true;
video = true;
gameTimeStop();
pie_SetFogStatus(false);
audio_StopAll();
wzShowMouse(false);
screen_StopBackDrop();
pie_ScreenFlip(CLEAR_BLACK);
}
// fill buffers with the static screen
void initLoadingScreen( bool drawbdrop )
{
pie_ShowMouse(false);
if (!drawbdrop) // fill buffers
{
//just init the load bar with the current screen
// setup the callback....
pie_SetFogStatus(false);
pie_ScreenFlip(CLEAR_BLACK);
resSetLoadCallback(loadingScreenCallback);
return;
}
pie_SetFogStatus(false);
pie_ScreenFlip(CLEAR_BLACK);//init loading
// setup the callback....
resSetLoadCallback(loadingScreenCallback);
// NOTE: When this is called, we stop the backdrop, but since the screen
// is double buffered, we only have the backdrop on 1 buffer, and not the other.
//screen_StopBackDrop();
}
/** Displays all the console messages */
void displayConsoleMessages(void)
{
// Check if we have any messages we want to show
if (!getNumberConsoleMessages() && !bConsoleDropped && !InfoMessages.size())
{
return;
}
// scripts can disable the console
if (!bConsoleDisplayEnabled && !InfoMessages.size())
{
return;
}
iV_SetFont(font_regular);
pie_SetDepthBufferStatus(DEPTH_CMP_ALWAYS_WRT_ON);
pie_SetFogStatus(false);
if (bConsoleDropped)
{
displayOldMessages(HistoryMode);
}
std::lock_guard<wz::mutex> lck(mtx); // Don't iterate without a lock.
if (InfoMessages.size())
{
auto i = InfoMessages.end() - 1; // we can only show the last one...
setConsoleTextColor(i->player);
int tmp = pie_GetVideoBufferWidth();
drawBlueBox(0, 0,tmp, 18);
tmp -= iV_GetTextWidth(i->text.c_str());
iV_DrawFormattedText(i->text.c_str(), tmp - 6, linePitch - 2, iV_GetTextWidth(i->text.c_str()), i->JustifyType);
}
int TextYpos = mainConsole.topY;
// Draw the blue background for the text (only in game, not lobby)
if (bTextBoxActive && GetGameMode() == GS_NORMAL)
{
iV_TransBoxFill(mainConsole.topX - CON_BORDER_WIDTH, mainConsole.topY - mainConsole.textDepth - CON_BORDER_HEIGHT,
mainConsole.topX + mainConsole.width, mainConsole.topY + (getNumberConsoleMessages() * linePitch) + CON_BORDER_HEIGHT - linePitch);
}
for (auto i = ActiveMessages.begin(); i != ActiveMessages.end(); ++i)
{
setConsoleTextColor(i->player);
TextYpos = iV_DrawFormattedText(i->text.c_str(), mainConsole.topX, TextYpos, mainConsole.width, i->JustifyType);
}
}
static void pie_Draw3DButton(iIMDShape *shape, PIELIGHT teamcolour)
{
const PIELIGHT colour = WZCOL_WHITE;
pie_SetFogStatus(false);
pie_SetDepthBufferStatus(DEPTH_CMP_LEQ_WRT_ON);
SHADER_PROGRAM &program = pie_ActivateShader(SHADER_BUTTON, shape, teamcolour, colour);
pie_SetRendMode(REND_OPAQUE);
pie_SetTexturePage(shape->texpage);
enableArray(shape->buffers[VBO_VERTEX], program.locVertex, 3, GL_FLOAT, false, 0, 0);
enableArray(shape->buffers[VBO_NORMAL], program.locNormal, 3, GL_FLOAT, false, 0, 0);
enableArray(shape->buffers[VBO_TEXCOORD], program.locTexCoord, 2, GL_FLOAT, false, 0, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, shape->buffers[VBO_INDEX]);
glDrawElements(GL_TRIANGLES, shape->npolys * 3, GL_UNSIGNED_SHORT, NULL);
disableArrays();
polyCount += shape->npolys;
pie_DeactivateShader();
pie_SetDepthBufferStatus(DEPTH_CMP_ALWAYS_WRT_ON);
}
void pie_SetDefaultStates()//Sets all states
{
PIELIGHT black;
//fog off
rendStates.fogEnabled = false;// enable fog before renderer
rendStates.fog = false;//to force reset to false
pie_SetFogStatus(false);
black.rgba = 0;
black.byte.a = 255;
pie_SetFogColour(black);
//depth Buffer on
pie_SetDepthBufferStatus(DEPTH_CMP_LEQ_WRT_ON);
rendStates.rendMode = REND_ALPHA; // to force reset to REND_OPAQUE
pie_SetRendMode(REND_OPAQUE);
}
void pie_ResetStates(void)//Sets all states
{
SDWORD temp;
// pie_SetFogColour(0x00B08f5f);//nicks colour
rendStates.fog = !rendStates.fog;//to force reset
pie_SetFogStatus(!rendStates.fog);
//depth Buffer on
temp = rendStates.depthBuffer;
rendStates.depthBuffer = -1;//to force reset
pie_SetDepthBufferStatus(temp);
//set render mode
// pie_SetTranslucent(TRUE);
// pie_SetAdditive(TRUE);
//basic gouraud textured rendering
temp = rendStates.texCombine;
rendStates.texCombine = -1;//to force reset
pie_SetTexCombine(temp);
temp = rendStates.colourCombine;
rendStates.colourCombine = -1;//to force reset
pie_SetColourCombine(temp);
temp = rendStates.alphaCombine;
rendStates.alphaCombine = -1;//to force reset
pie_SetAlphaCombine(temp);
temp = rendStates.transMode;
rendStates.transMode = -1;//to force reset
pie_SetTranslucencyMode(temp);
//chroma keying on black
temp = rendStates.keyingOn;
rendStates.keyingOn = -1;//to force reset
pie_SetColourKeyedBlack(temp);
//bilinear filtering
temp = rendStates.bilinearOn;
rendStates.bilinearOn = -1;//to force reset
pie_SetBilinear(temp);
}
void
arrowDrawAll( void )
{
ARROW *psArrow, *psArrowTemp;
pie_SetDepthBufferStatus(DEPTH_CMP_ALWAYS_WRT_ON);
pie_SetFogStatus(FALSE);
/* draw and clear list */
psArrow = g_psArrowList;
while ( psArrow != NULL )
{
draw3dLine( &psArrow->vecHead, &psArrow->vecBase, psArrow->iColour );
psArrowTemp = psArrow->psNext;
HEAP_FREE( g_psArrowHeap, psArrow );
psArrow = psArrowTemp;
}
/* reset list */
g_psArrowList = NULL;
pie_SetDepthBufferStatus(DEPTH_CMP_LEQ_WRT_ON);
}
int realmain(int argc, char *argv[])
{
// The libcrypto startup stuff... May or may not actually be needed for anything at all.
ERR_load_crypto_strings(); // This is needed for descriptive error messages.
OpenSSL_add_all_algorithms(); // Don't actually use the EVP functions, so probably not needed.
OPENSSL_config(nullptr); // What does this actually do?
#ifdef WZ_OS_WIN
RAND_screen(); // Uses a screenshot as a random seed, on systems lacking /dev/random.
#endif
wzMain(argc, argv);
int utfargc = argc;
const char** utfargv = (const char**)argv;
#ifdef WZ_OS_MAC
cocoaInit();
#endif
debug_init();
debug_register_callback( debug_callback_stderr, NULL, NULL, NULL );
#if defined(WZ_OS_WIN) && defined(DEBUG_INSANE)
debug_register_callback( debug_callback_win32debug, NULL, NULL, NULL );
#endif // WZ_OS_WIN && DEBUG_INSANE
// *****
// NOTE: Try *NOT* to use debug() output routines without some other method of informing the user. All this output is sent to /dev/nul at this point on some platforms!
// *****
if (!getUTF8CmdLine(&utfargc, &utfargv))
{
return EXIT_FAILURE;
}
QTextCodec::setCodecForCStrings(QTextCodec::codecForName("UTF-8")); // make Qt treat all C strings in Warzone as UTF-8
setupExceptionHandler(utfargc, utfargv, version_getFormattedVersionString());
/*** Initialize PhysicsFS ***/
initialize_PhysicsFS(utfargv[0]);
/*** Initialize translations ***/
initI18n();
// find early boot info
if (!ParseCommandLineEarly(utfargc, utfargv))
{
return EXIT_FAILURE;
}
/* Initialize the write/config directory for PhysicsFS.
* This needs to be done __after__ the early commandline parsing,
* because the user might tell us to use an alternative configuration
* directory.
*/
initialize_ConfigDir();
/*** Initialize directory structure ***/
make_dir(ScreenDumpPath, "screenshots", NULL);
make_dir(SaveGamePath, "savegames", NULL);
PHYSFS_mkdir("savegames/campaign");
PHYSFS_mkdir("savegames/skirmish");
make_dir(MultiCustomMapsPath, "maps", NULL); // MUST have this to prevent crashes when getting map
PHYSFS_mkdir("music");
PHYSFS_mkdir("logs"); // a place to hold our netplay, mingw crash reports & WZ logs
PHYSFS_mkdir("userdata"); // a place to store per-mod data user generated data
memset(rulesettag, 0, sizeof(rulesettag)); // tag to add to userdata to find user generated stuff
make_dir(MultiPlayersPath, "multiplay", NULL);
make_dir(MultiPlayersPath, "multiplay", "players");
if (!customDebugfile)
{
// there was no custom debug file specified (--debug-file=blah)
// so we use our write directory to store our logs.
time_t aclock;
struct tm *newtime;
char buf[PATH_MAX];
time( &aclock ); // Get time in seconds
newtime = localtime( &aclock ); // Convert time to struct
// Note: We are using fopen(), and not physfs routines to open the file
// log name is logs/(or \)WZlog-MMDD_HHMMSS.txt
snprintf(buf, sizeof(buf), "%slogs%sWZlog-%02d%02d_%02d%02d%02d.txt", PHYSFS_getWriteDir(), PHYSFS_getDirSeparator(),
newtime->tm_mon + 1, newtime->tm_mday, newtime->tm_hour, newtime->tm_min, newtime->tm_sec );
debug_register_callback( debug_callback_file, debug_callback_file_init, debug_callback_file_exit, buf );
// FIXME: Change this to LOG_WZ on next release
debug(LOG_INFO, "Using %s debug file", buf);
}
// NOTE: it is now safe to use debug() calls to make sure output gets captured.
check_Physfs();
debug(LOG_WZ, "Warzone 2100 - %s", version_getFormattedVersionString());
debug(LOG_WZ, "Using language: %s", getLanguage());
debug(LOG_WZ, "Backend: %s", BACKEND);
debug(LOG_MEMORY, "sizeof: SIMPLE_OBJECT=%ld, BASE_OBJECT=%ld, DROID=%ld, STRUCTURE=%ld, FEATURE=%ld, PROJECTILE=%ld",
(long)sizeof(SIMPLE_OBJECT), (long)sizeof(BASE_OBJECT), (long)sizeof(DROID), (long)sizeof(STRUCTURE), (long)sizeof(FEATURE), (long)sizeof(PROJECTILE));
/* Put in the writedir root */
sstrcpy(KeyMapPath, "keymap.map");
// initialise all the command line states
war_SetDefaultStates();
debug(LOG_MAIN, "initializing");
PhysicsEngineHandler engine; // register abstract physfs filesystem
loadConfig();
// parse the command line
if (!ParseCommandLine(utfargc, utfargv))
{
return EXIT_FAILURE;
}
// Save new (commandline) settings
saveConfig();
// Find out where to find the data
scanDataDirs();
// Now we check the mods to see if they exist or not (specified on the command line)
// They are all capped at 100 mods max(see clparse.c)
// FIX ME: I know this is a bit hackish, but better than nothing for now?
{
char *modname;
char modtocheck[256];
int i = 0;
int result = 0;
// check global mods
for(i=0; i < 100; i++)
{
modname = global_mods[i];
if (modname == NULL)
{
break;
}
ssprintf(modtocheck, "mods/global/%s", modname);
result = PHYSFS_exists(modtocheck);
result |= PHYSFS_isDirectory(modtocheck);
if (!result)
{
debug(LOG_ERROR, "The (global) mod (%s) you have specified doesn't exist!", modname);
}
else
{
info("(global) mod (%s) is enabled", modname);
}
}
// check campaign mods
for(i=0; i < 100; i++)
{
modname = campaign_mods[i];
if (modname == NULL)
{
break;
}
ssprintf(modtocheck, "mods/campaign/%s", modname);
result = PHYSFS_exists(modtocheck);
result |= PHYSFS_isDirectory(modtocheck);
if (!result)
{
debug(LOG_ERROR, "The mod_ca (%s) you have specified doesn't exist!", modname);
}
else
{
info("mod_ca (%s) is enabled", modname);
}
}
// check multiplay mods
for(i=0; i < 100; i++)
{
modname = multiplay_mods[i];
if (modname == NULL)
{
break;
}
ssprintf(modtocheck, "mods/multiplay/%s", modname);
result = PHYSFS_exists(modtocheck);
result |= PHYSFS_isDirectory(modtocheck);
if (!result)
{
debug(LOG_ERROR, "The mod_mp (%s) you have specified doesn't exist!", modname);
}
else
{
info("mod_mp (%s) is enabled", modname);
}
}
}
if (!wzMain2(war_getFSAA(), war_getFullscreen(), war_GetVsync()))
{
return EXIT_FAILURE;
}
int w = pie_GetVideoBufferWidth();
int h = pie_GetVideoBufferHeight();
char buf[256];
ssprintf(buf, "Video Mode %d x %d (%s)", w, h, war_getFullscreen() ? "fullscreen" : "window");
addDumpInfo(buf);
debug(LOG_MAIN, "Final initialization");
if (!frameInitialise())
{
return EXIT_FAILURE;
}
if (!screenInitialise())
{
return EXIT_FAILURE;
}
if (!pie_LoadShaders())
{
return EXIT_FAILURE;
}
war_SetWidth(pie_GetVideoBufferWidth());
war_SetHeight(pie_GetVideoBufferHeight());
pie_SetFogStatus(false);
pie_ScreenFlip(CLEAR_BLACK);
pal_Init();
pie_LoadBackDrop(SCREEN_RANDOMBDROP);
pie_SetFogStatus(false);
pie_ScreenFlip(CLEAR_BLACK);
if (!systemInitialise())
{
return EXIT_FAILURE;
}
//set all the pause states to false
setAllPauseStates(false);
// Copy this info to be used by the crash handler for the dump file
ssprintf(buf,"Using Backend: %s", BACKEND);
addDumpInfo(buf);
ssprintf(buf,"Using language: %s", getLanguageName());
addDumpInfo(buf);
// Do the game mode specific initialisation.
switch(GetGameMode())
{
case GS_TITLE_SCREEN:
startTitleLoop();
break;
case GS_SAVEGAMELOAD:
initSaveGameLoad();
break;
case GS_NORMAL:
startGameLoop();
break;
default:
debug(LOG_ERROR, "Weirdy game status, I'm afraid!!");
break;
}
#if defined(WZ_CC_MSVC) && defined(DEBUG)
debug_MEMSTATS();
#endif
debug(LOG_MAIN, "Entering main loop");
wzMain3();
saveConfig();
systemShutdown();
#ifdef WZ_OS_WIN // clean up the memory allocated for the command line conversion
for (int i=0; i<argc; i++)
{
const char*** const utfargvF = &utfargv;
free((void *)(*utfargvF)[i]);
}
free(utfargv);
#endif
wzShutdown();
debug(LOG_MAIN, "Completed shutting down Warzone 2100");
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
int utfargc = argc;
const char** utfargv = (const char**)argv;
#ifdef WZ_OS_MAC
cocoaInit();
#endif
debug_init();
debug_register_callback( debug_callback_stderr, NULL, NULL, NULL );
#if defined(WZ_OS_WIN) && defined(DEBUG_INSANE)
debug_register_callback( debug_callback_win32debug, NULL, NULL, NULL );
#endif // WZ_OS_WIN && DEBUG_INSANE
if (!getUTF8CmdLine(&utfargc, &utfargv))
{
return -1;
}
setupExceptionHandler(utfargc, utfargv);
/*** Initialize PhysicsFS ***/
initialize_PhysicsFS(utfargv[0]);
/*** Initialize translations ***/
initI18n();
// find early boot info
if ( !ParseCommandLineEarly(utfargc, utfargv) ) {
return -1;
}
debug(LOG_WZ, "Using language: %s", getLanguage());
debug(LOG_MEMORY, "sizeof: SIMPLE_OBJECT=%ld, BASE_OBJECT=%ld, DROID=%ld, STRUCTURE=%ld, FEATURE=%ld, PROJECTILE=%ld",
(long)sizeof(SIMPLE_OBJECT), (long)sizeof(BASE_OBJECT), (long)sizeof(DROID), (long)sizeof(STRUCTURE), (long)sizeof(FEATURE), (long)sizeof(PROJECTILE));
/* Initialize the write/config directory for PhysicsFS.
* This needs to be done __after__ the early commandline parsing,
* because the user might tell us to use an alternative configuration
* directory.
*/
initialize_ConfigDir();
/*** Initialize directory structure ***/
make_dir(ScreenDumpPath, "screenshots", NULL);
make_dir(SaveGamePath, "savegame", NULL);
make_dir(MultiCustomMapsPath, "maps", NULL); // MUST have this to prevent crashes when getting map
PHYSFS_mkdir("music");
PHYSFS_mkdir("logs"); // a place to hold our netplay, mingw crash reports & WZ logs
make_dir(MultiPlayersPath, "multiplay", NULL);
make_dir(MultiPlayersPath, "multiplay", "players");
if (!customDebugfile)
{
// there was no custom debug file specified (--debug-file=blah)
// so we use our write directory to store our logs.
time_t aclock;
struct tm *newtime;
char buf[PATH_MAX];
time( &aclock ); // Get time in seconds
newtime = localtime( &aclock ); // Convert time to struct
// Note: We are using fopen(), and not physfs routines to open the file
// log name is logs/(or \)WZlog-MMDD_HHMMSS.txt
snprintf(buf, sizeof(buf), "%slogs%sWZlog-%02d%02d_%02d%02d%02d.txt", PHYSFS_getWriteDir(), PHYSFS_getDirSeparator(),
newtime->tm_mon, newtime->tm_mday, newtime->tm_hour, newtime->tm_min, newtime->tm_sec );
debug_register_callback( debug_callback_file, debug_callback_file_init, debug_callback_file_exit, buf );
}
debug(LOG_WZ, "Warzone 2100 - %s", version_getFormattedVersionString());
/* Put these files in the writedir root */
setRegistryFilePath("config");
sstrcpy(KeyMapPath, "keymap.map");
// initialise all the command line states
war_SetDefaultStates();
debug(LOG_MAIN, "initializing");
loadConfig();
NETinit(true);
// parse the command line
if (!ParseCommandLine(utfargc, utfargv)) {
return -1;
}
// Save new (commandline) settings
saveConfig();
// Find out where to find the data
scanDataDirs();
// Must be run before OpenGL driver is properly initialized due to
// strange conflicts - Per
if (selfTest)
{
memset(enabled_debug, 0, sizeof(*enabled_debug) * LOG_LAST);
fprintf(stdout, "Carrying out self-test:\n");
playListTest();
audioTest();
soundTest();
}
// Now we check the mods to see if they exsist or not (specified on the command line)
// They are all capped at 100 mods max(see clparse.c)
// FIX ME: I know this is a bit hackish, but better than nothing for now?
{
char *modname;
char modtocheck[256];
int i = 0;
int result = 0;
// check global mods
for(i=0; i < 100; i++)
{
modname = global_mods[i];
if (modname == NULL)
{
break;
}
ssprintf(modtocheck, "mods/global/%s", modname);
result = PHYSFS_exists(modtocheck);
result |= PHYSFS_isDirectory(modtocheck);
if (!result)
{
debug(LOG_ERROR, "The (global) mod (%s) you have specified doesn't exist!", modname);
}
else
{
info("(global) mod (%s) is enabled", modname);
}
}
// check campaign mods
for(i=0; i < 100; i++)
{
modname = campaign_mods[i];
if (modname == NULL)
{
break;
}
ssprintf(modtocheck, "mods/campaign/%s", modname);
result = PHYSFS_exists(modtocheck);
result |= PHYSFS_isDirectory(modtocheck);
if (!result)
{
debug(LOG_ERROR, "The mod_ca (%s) you have specified doesn't exist!", modname);
}
else
{
info("mod_ca (%s) is enabled", modname);
}
}
// check multiplay mods
for(i=0; i < 100; i++)
{
modname = multiplay_mods[i];
if (modname == NULL)
{
break;
}
ssprintf(modtocheck, "mods/multiplay/%s", modname);
result = PHYSFS_exists(modtocheck);
result |= PHYSFS_isDirectory(modtocheck);
if (!result)
{
debug(LOG_ERROR, "The mod_mp (%s) you have specified doesn't exist!", modname);
}
else
{
info("mod_mp (%s) is enabled", modname);
}
}
}
if (!frameInitialise( "Warzone 2100", pie_GetVideoBufferWidth(), pie_GetVideoBufferHeight(), pie_GetVideoBufferDepth(), war_getFSAA(), war_getFullscreen(), war_GetVsync()))
{
return -1;
}
war_SetWidth(pie_GetVideoBufferWidth());
war_SetHeight(pie_GetVideoBufferHeight());
pie_SetFogStatus(false);
pie_ScreenFlip(CLEAR_BLACK);
pal_Init();
pie_LoadBackDrop(SCREEN_RANDOMBDROP);
pie_SetFogStatus(false);
pie_ScreenFlip(CLEAR_BLACK);
if (!systemInitialise())
{
return -1;
}
//set all the pause states to false
setAllPauseStates(false);
/* Runtime unit testing */
if (selfTest)
{
tagTest();
parseTest();
levTest();
mapTest();
fprintf(stdout, "All tests PASSED!\n");
exit(0);
}
{
// Copy this info to be used by the crash handler for the dump file
char buf[256];
ssprintf(buf,"Using language: %s", getLanguageName());
addDumpInfo(buf);
}
// Do the game mode specific initialisation.
switch(GetGameMode())
{
case GS_TITLE_SCREEN:
startTitleLoop();
break;
case GS_SAVEGAMELOAD:
initSaveGameLoad();
break;
case GS_NORMAL:
startGameLoop();
break;
default:
debug(LOG_ERROR, "Weirdy game status, I'm afraid!!");
break;
}
debug(LOG_MAIN, "Entering main loop");
// Enter the mainloop
mainLoop();
debug(LOG_MAIN, "Shutting down Warzone 2100");
#if defined(WZ_CC_MSVC) && defined(DEBUG)
debug_MEMSTATS();
#endif
atexit(systemShutdown);
return EXIT_SUCCESS;
}
static GAMECODE renderLoop()
{
if (bMultiPlayer && !NetPlay.isHostAlive && NetPlay.bComms && !NetPlay.isHost)
{
intAddInGamePopup();
}
int clearMode = 0;
if(getDrawShadows())
{
clearMode |= CLEAR_SHADOW;
}
if (loopMissionState == LMS_SAVECONTINUE)
{
pie_SetFogStatus(false);
clearMode = CLEAR_BLACK;
}
pie_ScreenFlip(clearMode);//gameloopflip
HandleClosingWindows(); // Needs to be done outside the pause case.
audio_Update();
wzShowMouse(true);
INT_RETVAL intRetVal = INT_NONE;
if (!paused)
{
/* Run the in game interface and see if it grabbed any mouse clicks */
if (!rotActive && getWidgetsStatus() && dragBox3D.status != DRAG_DRAGGING && wallDrag.status != DRAG_DRAGGING)
{
intRetVal = intRunWidgets();
}
//don't process the object lists if paused or about to quit to the front end
if (!gameUpdatePaused() && intRetVal != INT_QUIT)
{
if( dragBox3D.status != DRAG_DRAGGING
&& wallDrag.status != DRAG_DRAGGING
&& ( intRetVal == INT_INTERCEPT
|| ( radarOnScreen
&& CoordInRadar(mouseX(), mouseY())
&& getHQExists(selectedPlayer) ) ) )
{
// Using software cursors (when on) for these menus due to a bug in SDL's SDL_ShowCursor()
wzSetCursor(CURSOR_DEFAULT);
intRetVal = INT_INTERCEPT;
}
#ifdef DEBUG
// check all flag positions for duplicate delivery points
checkFactoryFlags();
#endif
//handles callbacks for positioning of DP's
process3DBuilding();
//ajl. get the incoming netgame messages and process them.
// FIXME Previous comment is deprecated. multiPlayerLoop does some other weird stuff, but not that anymore.
if (bMultiPlayer)
{
multiPlayerLoop();
}
for (unsigned i = 0; i < MAX_PLAYERS; i++)
{
for (DROID *psCurr = apsDroidLists[i]; psCurr; psCurr = psCurr->psNext)
{
// Don't copy the next pointer - if droids somehow get destroyed in the graphics rendering loop, who cares if we crash.
calcDroidIllumination(psCurr);
}
}
/* update animations */
animObj_Update();
}
if (!consolePaused())
{
/* Process all the console messages */
updateConsoleMessages();
}
if (!scrollPaused() && !getWarCamStatus() && dragBox3D.status != DRAG_DRAGGING && intMode != INT_INGAMEOP )
{
scroll();
}
}
else // paused
{
// Using software cursors (when on) for these menus due to a bug in SDL's SDL_ShowCursor()
wzSetCursor(CURSOR_DEFAULT);
if(dragBox3D.status != DRAG_DRAGGING)
{
scroll();
}
if(InGameOpUp || isInGamePopupUp) // ingame options menu up, run it!
{
unsigned widgval = widgRunScreen(psWScreen);
intProcessInGameOptions(widgval);
if(widgval == INTINGAMEOP_QUIT_CONFIRM || widgval == INTINGAMEOP_POPUP_QUIT)
{
if(gamePaused())
{
kf_TogglePauseMode();
}
intRetVal = INT_QUIT;
}
}
if(bLoadSaveUp && runLoadSave(true) && strlen(sRequestResult))
{
debug( LOG_NEVER, "Returned %s", sRequestResult );
if(bRequestLoad)
{
loopMissionState = LMS_LOADGAME;
NET_InitPlayers(); // otherwise alliances were not cleared
sstrcpy(saveGameName, sRequestResult);
}
else
{
char msgbuffer[256]= {'\0'};
if (saveInMissionRes())
{
if (saveGame(sRequestResult, GTYPE_SAVE_START))
{
sstrcpy(msgbuffer, _("GAME SAVED: "));
sstrcat(msgbuffer, sRequestResult);
addConsoleMessage( msgbuffer, LEFT_JUSTIFY, NOTIFY_MESSAGE);
}
else
{
ASSERT( false,"Mission Results: saveGame Failed" );
sstrcpy(msgbuffer, _("Could not save game!"));
addConsoleMessage( msgbuffer, LEFT_JUSTIFY, NOTIFY_MESSAGE);
deleteSaveGame(sRequestResult);
}
}
else if (bMultiPlayer || saveMidMission())
{
if (saveGame(sRequestResult, GTYPE_SAVE_MIDMISSION))//mid mission from [esc] menu
{
sstrcpy(msgbuffer, _("GAME SAVED: "));
sstrcat(msgbuffer, sRequestResult);
addConsoleMessage( msgbuffer, LEFT_JUSTIFY, NOTIFY_MESSAGE);
}
else
{
ASSERT(!"saveGame(sRequestResult, GTYPE_SAVE_MIDMISSION) failed", "Mid Mission: saveGame Failed" );
sstrcpy(msgbuffer, _("Could not save game!"));
addConsoleMessage( msgbuffer, LEFT_JUSTIFY, NOTIFY_MESSAGE);
deleteSaveGame(sRequestResult);
}
}
else
{
ASSERT( false, "Attempt to save game with incorrect load/save mode" );
}
}
}
}
/* Check for quit */
bool quitting = false;
if (intRetVal == INT_QUIT)
{
if (!loop_GetVideoStatus())
{
//quitting from the game to the front end
//so get a new backdrop
quitting = true;
pie_LoadBackDrop(SCREEN_RANDOMBDROP);
}
}
if (!loop_GetVideoStatus() && !quitting)
{
if (!gameUpdatePaused())
{
if (dragBox3D.status != DRAG_DRAGGING
&& wallDrag.status != DRAG_DRAGGING)
{
ProcessRadarInput();
}
processInput();
//no key clicks or in Intelligence Screen
if (intRetVal == INT_NONE && !InGameOpUp && !isInGamePopupUp)
{
processMouseClickInput();
}
displayWorld();
}
/* Display the in game interface */
pie_SetDepthBufferStatus(DEPTH_CMP_ALWAYS_WRT_ON);
pie_SetFogStatus(false);
if(bMultiPlayer && bDisplayMultiJoiningStatus)
{
intDisplayMultiJoiningStatus(bDisplayMultiJoiningStatus);
setWidgetsStatus(false);
}
if(getWidgetsStatus())
{
intDisplayWidgets();
}
pie_SetDepthBufferStatus(DEPTH_CMP_LEQ_WRT_ON);
pie_SetFogStatus(true);
}
pie_GetResetCounts(&loopPieCount, &loopPolyCount, &loopStateChanges);
if ((fogStatus & FOG_BACKGROUND) && (loopMissionState == LMS_SAVECONTINUE))
{
pie_SetFogStatus(false);
}
if (!quitting)
{
/* Check for toggling display mode */
if ((keyDown(KEY_LALT) || keyDown(KEY_RALT)) && keyPressed(KEY_RETURN))
{
screenToggleMode();
}
}
// deal with the mission state
switch (loopMissionState)
{
case LMS_CLEAROBJECTS:
missionDestroyObjects();
setScriptPause(true);
loopMissionState = LMS_SETUPMISSION;
break;
case LMS_NORMAL:
// default
break;
case LMS_SETUPMISSION:
setScriptPause(false);
if (!setUpMission(nextMissionType))
{
return GAMECODE_QUITGAME;
}
break;
case LMS_SAVECONTINUE:
// just wait for this to be changed when the new mission starts
break;
case LMS_NEWLEVEL:
//nextMissionType = MISSION_NONE;
nextMissionType = LDS_NONE;
return GAMECODE_NEWLEVEL;
break;
case LMS_LOADGAME:
return GAMECODE_LOADGAME;
break;
default:
ASSERT( false, "unknown loopMissionState" );
break;
}
if (quitting)
{
pie_SetFogStatus(false);
pie_ScreenFlip(CLEAR_BLACK);//gameloopflip
/* Check for toggling display mode */
if ((keyDown(KEY_LALT) || keyDown(KEY_RALT)) && keyPressed(KEY_RETURN))
{
screenToggleMode();
}
return GAMECODE_QUITGAME;
}
else if (loop_GetVideoStatus())
{
audio_StopAll();
return GAMECODE_PLAYVIDEO;
}
return GAMECODE_CONTINUE;
}
int WINAPI WinMain(
HINSTANCE hInstance, // handle to current instance
HINSTANCE hPrevInstance, // handle to previous instance
LPSTR lpCmdLine, // pointer to command line
int nShowCmd) // show state of window
{
FRAME_STATUS frameRet;
BOOL quit = FALSE;
BOOL Restart = FALSE;
BOOL paused = FALSE;//, firstTime = TRUE;
BOOL bGlide = FALSE;
BOOL bVidMem = FALSE;
SDWORD dispBitDepth = DISP_BITDEPTH;
SDWORD introVideoControl = 3;
GAMECODE loopStatus;
iColour* psPaletteBuffer;
SDWORD pSize;
(void)nShowCmd;
// (void)lpCmdLine;
(void)hPrevInstance;
// initialise all the command line states
clStartWindowed = FALSE;
clIntroVideo = FALSE;
// save debugging info to disk
DBOUTPUTFILE("debug.txt");
if (!pie_CheckForDX6())
{
DBERROR(("Unable to create DirectX 6 interface.\nPlease ensure DirectX 6 or later is installed."));
return -1;
}
war_SetDefaultStates();
war_SetRendMode(REND_MODE_HAL);
if (InitGlideDLL()) // In ivis02/3dfxdyn.c - returns FALSE if no glide2x.dll is not found
{
bGlideFound = TRUE;
war_SetRendMode(REND_MODE_GLIDE);//default to glide this will be over writen by Registry or Command line if found
}
init://jump here from the end if re_initialising
// initialise memory stuff, moved out of frameinit by ajl.
if (!memInitialise())
{
return FALSE;
}
if (!blkInitialise())
{
return FALSE;
}
loadRenderMode();//get the registry entry for clRendMode
bDisableLobby = FALSE;
// parse the command line
// if (bDisableLobby || !NetPlay.bLobbyLaunched)
// {
if(!reInit)
{
if(!ParseCommandLine(lpCmdLine,bGlideFound))
{
return -1;
}
}
// }
// find out if the lobby stuff has been disabled
// bDisableLobby = checkDisableLobby();
if (!bDisableLobby &&
!lobbyInitialise()) // ajl. Init net stuff. Lobby can modify startup conditions like commandline.
{
return -1;
}
reInit = FALSE;//just so we dont restart again
#ifdef USE_FILE_PATH
_chdir(FILE_PATH);
#endif
//always start windowed toggle to fullscreen later
if (war_GetRendMode() == REND_MODE_HAL)
{
bGlide = FALSE;
bVidMem = TRUE;
dispBitDepth = DISP_HARDBITDEPTH;
}
else if (war_GetRendMode() == REND_MODE_REF)
{
bGlide = FALSE;
bVidMem = TRUE;
dispBitDepth = DISP_HARDBITDEPTH;
}
else if (war_GetRendMode() == REND_MODE_RGB)
{
bGlide = FALSE;
bVidMem = FALSE;
dispBitDepth = DISP_HARDBITDEPTH;
}
else if (war_GetRendMode() == REND_MODE_GLIDE)
{
bGlide = TRUE;
bVidMem = FALSE;
dispBitDepth = DISP_HARDBITDEPTH;
}
else
{
bGlide = FALSE;
bVidMem = FALSE;
dispBitDepth = DISP_BITDEPTH;
}
// frameDDEnumerate();
if (!frameInitialise(hInstance, "Warzone 2100",
DISP_WIDTH,DISP_HEIGHT,dispBitDepth, !clStartWindowed, bVidMem, bGlide))
{
return -1;
}
if (!wdgLoadAllWDGCatalogs())
{
return -1;
}
pie_SetFogStatus(FALSE);
pie_ScreenFlip(CLEAR_BLACK);
pie_ScreenFlip(CLEAR_BLACK);
if (war_GetRendMode() == REND_MODE_GLIDE)
{
dbg_SetMessageBoxCallback(fxMBCallback);
dbg_SetErrorBoxCallback(fxMBCallback);
dbg_SetAssertCallback(fxMBCallback);
}
if(gameStatus == GS_VIDEO_MODE)
{
introVideoControl = 0;//play video
gameStatus = GS_TITLE_SCREEN;
}
//load palette
psPaletteBuffer = (iColour*)MALLOC(256 * sizeof(iColour)+1);
if (psPaletteBuffer == NULL)
{
DBERROR(("Out of memory"));
return -1;
}
if (!loadFileToBuffer("palette.bin", (UBYTE*)psPaletteBuffer, (256 * sizeof(iColour)+1),(UDWORD*)&pSize))
{
DBERROR(("Couldn't load palette data"));
return -1;
}
pal_AddNewPalette(psPaletteBuffer);
FREE(psPaletteBuffer);
if (war_GetRendMode() == REND_MODE_GLIDE)
{
pie_LoadBackDrop(SCREEN_RANDOMBDROP,TRUE);
}
else
{
pie_LoadBackDrop(SCREEN_RANDOMBDROP,FALSE);
}
pie_SetFogStatus(FALSE);
pie_ScreenFlip(CLEAR_BLACK);
quit = FALSE;
/* check CDROM drive available */
if ( cdspan_CheckCDAvailable() == FALSE )
{
DBERROR( ("Cannot detect CDROM drive\n") );
quit = TRUE;
}
if (!systemInitialise())
{
return -1;
}
// If windowed mode not requested then toggle to full screen. Doing
// it here rather than in the call to frameInitialise fixes a problem
// where machines with an NVidia and a 3DFX would kill the 3dfx display. (Definitly a HACK, PD)
/* if(!clStartWindowed)
{
screenToggleMode();
}
*/
//set all the pause states to false
setAllPauseStates(FALSE);
while (!quit)
{
// Do the game mode specific initialisation.
switch(gameStatus)
{
case GS_TITLE_SCREEN:
screen_RestartBackDrop();
if (!frontendInitialise("wrf\\frontend.wrf"))
{
goto exit;
}
frontendInitialised = TRUE;
frontendInitVars();
//if intro required set up the video
if (introVideoControl <= 1)
{
seq_ClearSeqList();
seq_AddSeqToList("eidos-logo.rpl",NULL, NULL, FALSE,0);
seq_AddSeqToList("pumpkin.rpl",NULL, NULL, FALSE,0);
seq_AddSeqToList("titles.rpl",NULL, NULL, FALSE,0);
seq_AddSeqToList("devastation.rpl",NULL,"devastation.txa", FALSE,0);
seq_StartNextFullScreenVideo();
introVideoControl = 2;
}
break;
case GS_SAVEGAMELOAD:
screen_RestartBackDrop();
gameStatus = GS_NORMAL;
// load up a save game
if (!loadGameInit(saveGameName,FALSE))
{
goto exit;
}
/*if (!levLoadData(pLevelName, saveGameName)) {
return -1;
}*/
screen_StopBackDrop();
break;
case GS_NORMAL:
if (!levLoadData(pLevelName, NULL, 0)) {
goto exit;
}
//after data is loaded check the research stats are valid
if (!checkResearchStats())
{
DBERROR(("Invalid Research Stats"));
goto exit;
}
//and check the structure stats are valid
if (!checkStructureStats())
{
DBERROR(("Invalid Structure Stats"));
goto exit;
}
//set a flag for the trigger/event system to indicate initialisation is complete
gameInitialised = TRUE;
screen_StopBackDrop();
break;
case GS_VIDEO_MODE:
DBERROR(("Video_mode no longer valid"));
if (introVideoControl == 0)
{
videoInitialised = TRUE;
}
break;
default:
DBERROR(("Unknown game status on startup!"));
}
DBPRINTF(("Entering main loop\n"));
Restart = FALSE;
//firstTime = TRUE;
while (!Restart)
{
frameRet = frameUpdate();
if (pie_GetRenderEngine() == ENGINE_D3D)
{
if ( frameRet == FRAME_SETFOCUS )
{
D3DTestCooperativeLevel( TRUE );
}
else
{
D3DTestCooperativeLevel( FALSE );
}
}
switch (frameRet)
{
case FRAME_KILLFOCUS:
paused = TRUE;
gameTimeStop();
if (pie_GetRenderEngine() == ENGINE_GLIDE)
{
if (!gl_Deactivate())
{
quit = TRUE;
Restart = TRUE;
}
}
mixer_SaveIngameVols();
mixer_RestoreWinVols();
audio_StopAll();
break;
case FRAME_SETFOCUS:
paused = FALSE;
gameTimeStart();
if (!dispModeChange())
{
quit = TRUE;
Restart = TRUE;
}
if (pie_GetRenderEngine() == ENGINE_GLIDE)
{
if (!gl_Reactivate())
{
quit = TRUE;
Restart = TRUE;
}
}
else if (pie_GetRenderEngine() == ENGINE_D3D)
{
dtm_RestoreTextures();
}
mixer_SaveWinVols();
mixer_RestoreIngameVols();
break;
case FRAME_QUIT:
quit = TRUE;
Restart = TRUE;
break;
}
lastStatus = gameStatus;
if ((!paused) && (!quit))
{
switch(gameStatus)
{
case GS_TITLE_SCREEN:
pie_SetSwirlyBoxes(TRUE);
if (loop_GetVideoStatus())
{
videoLoop();
}
else
{
switch(titleLoop()) {
case TITLECODE_QUITGAME:
DBPRINTF(("TITLECODE_QUITGAME\n"));
Restart = TRUE;
quit = TRUE;
break;
// case TITLECODE_ATTRACT:
// DBPRINTF(("TITLECODE_ATTRACT\n"));
// break;
case TITLECODE_SAVEGAMELOAD:
DBPRINTF(("TITLECODE_SAVEGAMELOAD\n"));
gameStatus = GS_SAVEGAMELOAD;
Restart = TRUE;
break;
case TITLECODE_STARTGAME:
DBPRINTF(("TITLECODE_STARTGAME\n"));
gameStatus = GS_NORMAL;
Restart = TRUE;
break;
case TITLECODE_SHOWINTRO:
DBPRINTF(("TITLECODE_SHOWINTRO\n"));
seq_ClearSeqList();
seq_AddSeqToList("eidos-logo.rpl",NULL,NULL, FALSE,0);
seq_AddSeqToList("pumpkin.rpl",NULL,NULL, FALSE,0);
seq_AddSeqToList("titles.rpl",NULL,NULL, FALSE,0);
seq_AddSeqToList("devastation.rpl",NULL,"devastation.txa", FALSE,0);
seq_StartNextFullScreenVideo();
introVideoControl = 2;//play the video but dont init the sound system
break;
case TITLECODE_CONTINUE:
break;
default:
DBERROR(("Unknown code returned by titleLoop"));
}
}
pie_SetSwirlyBoxes(FALSE);
break;
/* case GS_SAVEGAMELOAD:
if (loopNewLevel)
{
//the start of a campaign/expand mission
DBPRINTF(("GAMECODE_NEWLEVEL\n"));
loopNewLevel = FALSE;
// gameStatus is unchanged, just loading additional data
Restart = TRUE;
}
break;
*/
case GS_NORMAL:
if (loop_GetVideoStatus())
{
videoLoop();
}
else
{
loopStatus = gameLoop();
switch(loopStatus) {
case GAMECODE_QUITGAME:
DBPRINTF(("GAMECODE_QUITGAME\n"));
gameStatus = GS_TITLE_SCREEN;
Restart = TRUE;
/*#ifdef NON_INTERACT
quit = TRUE;
#endif*/
if(NetPlay.bLobbyLaunched)
{
// changeTitleMode(QUIT);
quit = TRUE;
}
break;
case GAMECODE_FASTEXIT:
DBPRINTF(("GAMECODE_FASTEXIT\n"));
Restart = TRUE;
quit = TRUE;
break;
case GAMECODE_LOADGAME:
DBPRINTF(("GAMECODE_LOADGAME\n"));
Restart = TRUE;
gameStatus = GS_SAVEGAMELOAD;
break;
case GAMECODE_PLAYVIDEO:
DBPRINTF(("GAMECODE_PLAYVIDEO\n"));
//dont schange mode any more gameStatus = GS_VIDEO_MODE;
Restart = FALSE;
break;
case GAMECODE_NEWLEVEL:
DBPRINTF(("GAMECODE_NEWLEVEL\n"));
// gameStatus is unchanged, just loading additional data
Restart = TRUE;
break;
case GAMECODE_RESTARTGAME:
DBPRINTF(("GAMECODE_RESTARTGAME\n"));
Restart = TRUE;
break;
case GAMECODE_CONTINUE:
break;
default:
DBERROR(("Unknown code returned by gameLoop"));
}
}
break;
case GS_VIDEO_MODE:
DBERROR(("Video_mode no longer valid"));
if (loop_GetVideoStatus())
{
videoLoop();
}
else
{
if (introVideoControl <= 1)
{
seq_ClearSeqList();
seq_AddSeqToList("factory.rpl",NULL,NULL, FALSE,0);
seq_StartNextFullScreenVideo();//"sequences\\factory.rpl","sequences\\factory.wav");
introVideoControl = 2;
}
else
{
DBPRINTF(("VIDEO_QUIT\n"));
if (introVideoControl == 2)//finished playing intro video
{
gameStatus = GS_TITLE_SCREEN;
if (videoInitialised)
{
Restart = TRUE;
}
introVideoControl = 3;
}
else
{
gameStatus = GS_NORMAL;
}
}
}
break;
default:
DBERROR(("Weirdy game status I'm afraid!!"));
break;
}
gameTimeUpdate();
}
} // End of !Restart loop.
// Do game mode specific shutdown.
switch(lastStatus) {
case GS_TITLE_SCREEN:
if (!frontendShutdown())
{
goto exit;
}
frontendInitialised = FALSE;
break;
/* case GS_SAVEGAMELOAD:
//get the next level to load up
gameStatus = GS_NORMAL;
break;*/
case GS_NORMAL:
if (loopStatus != GAMECODE_NEWLEVEL)
{
initLoadingScreen(TRUE,FALSE); // returning to f.e. do a loader.render not active
pie_EnableFog(FALSE);//dont let the normal loop code set status on
fogStatus = 0;
if (loopStatus != GAMECODE_LOADGAME)
{
levReleaseAll();
}
}
gameInitialised = FALSE;
break;
case GS_VIDEO_MODE:
DBERROR(("Video_mode no longer valid"));
if (videoInitialised)
{
videoInitialised = FALSE;
}
break;
default:
DBERROR(("Unknown game status on shutdown!"));
break;
}
} // End of !quit loop.
DBPRINTF(("Shuting down application\n"));
systemShutdown();
pal_ShutDown();
frameShutDown();
ShutdownGlideDLL();
if (reInit) goto init;
PostQuitMessage(0);
return 0;
exit:
DBPRINTF(("Shutting down after fail\n"));
systemShutdown();
pal_ShutDown();
frameShutDown();
ShutdownGlideDLL();
PostQuitMessage(1);
return 1;
}
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
int utfargc = argc;
const char** utfargv = (const char**)argv;
#ifdef WZ_OS_MAC
cocoaInit();
#endif
debug_init();
debug_register_callback( debug_callback_stderr, NULL, NULL, NULL );
#if defined(WZ_OS_WIN) && defined(DEBUG_INSANE)
debug_register_callback( debug_callback_win32debug, NULL, NULL, NULL );
#endif // WZ_OS_WIN && DEBUG_INSANE
// *****
// NOTE: Try *NOT* to use debug() output routines without some other method of informing the user. All this output is sent to /dev/nul at this point on some platforms!
// *****
if (!getUTF8CmdLine(&utfargc, &utfargv))
{
return EXIT_FAILURE;
}
QTextCodec::setCodecForCStrings(QTextCodec::codecForName("UTF-8")); // make Qt treat all C strings in Warzone as UTF-8
setupExceptionHandler(utfargc, utfargv, version_getFormattedVersionString());
/*** Initialize PhysicsFS ***/
initialize_PhysicsFS(utfargv[0]);
/*** Initialize translations ***/
initI18n();
// find early boot info
if (!ParseCommandLineEarly(utfargc, utfargv))
{
return EXIT_FAILURE;
}
/* Initialize the write/config directory for PhysicsFS.
* This needs to be done __after__ the early commandline parsing,
* because the user might tell us to use an alternative configuration
* directory.
*/
initialize_ConfigDir();
/*** Initialize directory structure ***/
make_dir(ScreenDumpPath, "screenshots", NULL);
make_dir(SaveGamePath, "savegames", NULL);
make_dir(MultiCustomMapsPath, "maps", NULL); // MUST have this to prevent crashes when getting map
PHYSFS_mkdir("music");
PHYSFS_mkdir("logs"); // a place to hold our netplay, mingw crash reports & WZ logs
make_dir(MultiPlayersPath, "multiplay", NULL);
make_dir(MultiPlayersPath, "multiplay", "players");
if (!customDebugfile)
{
// there was no custom debug file specified (--debug-file=blah)
// so we use our write directory to store our logs.
time_t aclock;
struct tm *newtime;
char buf[PATH_MAX];
time( &aclock ); // Get time in seconds
newtime = localtime( &aclock ); // Convert time to struct
// Note: We are using fopen(), and not physfs routines to open the file
// log name is logs/(or \)WZlog-MMDD_HHMMSS.txt
snprintf(buf, sizeof(buf), "%slogs%sWZlog-%02d%02d_%02d%02d%02d.txt", PHYSFS_getWriteDir(), PHYSFS_getDirSeparator(),
newtime->tm_mon, newtime->tm_mday, newtime->tm_hour, newtime->tm_min, newtime->tm_sec );
debug_register_callback( debug_callback_file, debug_callback_file_init, debug_callback_file_exit, buf );
}
// NOTE: it is now safe to use debug() calls to make sure output gets captured.
check_Physfs();
debug(LOG_WZ, "Warzone 2100 - %s", version_getFormattedVersionString());
debug(LOG_WZ, "Using language: %s", getLanguage());
debug(LOG_MEMORY, "sizeof: SIMPLE_OBJECT=%ld, BASE_OBJECT=%ld, DROID=%ld, STRUCTURE=%ld, FEATURE=%ld, PROJECTILE=%ld",
(long)sizeof(SIMPLE_OBJECT), (long)sizeof(BASE_OBJECT), (long)sizeof(DROID), (long)sizeof(STRUCTURE), (long)sizeof(FEATURE), (long)sizeof(PROJECTILE));
/* Put in the writedir root */
sstrcpy(KeyMapPath, "keymap.map");
// initialise all the command line states
war_SetDefaultStates();
debug(LOG_MAIN, "initializing");
PhysicsEngineHandler engine; // register abstract physfs filesystem
loadConfig();
// parse the command line
if (!ParseCommandLine(utfargc, utfargv))
{
return EXIT_FAILURE;
}
// Save new (commandline) settings
saveConfig();
// Find out where to find the data
scanDataDirs();
// This needs to be done after "scanDataDirs"
// for the root cert from cacert.
NETinit(true);
// Must be run before OpenGL driver is properly initialized due to
// strange conflicts - Per
if (selfTest)
{
memset(enabled_debug, 0, sizeof(*enabled_debug) * LOG_LAST);
fprintf(stdout, "Carrying out self-test:\n");
playListTest();
audioTest();
soundTest();
}
// Now we check the mods to see if they exist or not (specified on the command line)
// They are all capped at 100 mods max(see clparse.c)
// FIX ME: I know this is a bit hackish, but better than nothing for now?
{
char *modname;
char modtocheck[256];
int i = 0;
int result = 0;
// check global mods
for(i=0; i < 100; i++)
{
modname = global_mods[i];
if (modname == NULL)
{
break;
}
ssprintf(modtocheck, "mods/global/%s", modname);
result = PHYSFS_exists(modtocheck);
result |= PHYSFS_isDirectory(modtocheck);
if (!result)
{
debug(LOG_ERROR, "The (global) mod (%s) you have specified doesn't exist!", modname);
}
else
{
info("(global) mod (%s) is enabled", modname);
}
}
// check campaign mods
for(i=0; i < 100; i++)
{
modname = campaign_mods[i];
if (modname == NULL)
{
break;
}
ssprintf(modtocheck, "mods/campaign/%s", modname);
result = PHYSFS_exists(modtocheck);
result |= PHYSFS_isDirectory(modtocheck);
if (!result)
{
debug(LOG_ERROR, "The mod_ca (%s) you have specified doesn't exist!", modname);
}
else
{
info("mod_ca (%s) is enabled", modname);
}
}
// check multiplay mods
for(i=0; i < 100; i++)
{
modname = multiplay_mods[i];
if (modname == NULL)
{
break;
}
ssprintf(modtocheck, "mods/multiplay/%s", modname);
result = PHYSFS_exists(modtocheck);
result |= PHYSFS_isDirectory(modtocheck);
if (!result)
{
debug(LOG_ERROR, "The mod_mp (%s) you have specified doesn't exist!", modname);
}
else
{
info("mod_mp (%s) is enabled", modname);
}
}
}
debug(LOG_MAIN, "Qt initialization");
QGL::setPreferredPaintEngine(QPaintEngine::OpenGL); // Workaround for incorrect text rendering on nany platforms.
// Setting up OpenGL
QGLFormat format;
format.setDoubleBuffer(true);
format.setAlpha(true);
int w = pie_GetVideoBufferWidth();
int h = pie_GetVideoBufferHeight();
if (war_getFSAA())
{
format.setSampleBuffers(true);
format.setSamples(war_getFSAA());
}
WzMainWindow mainwindow(QSize(w, h), format);
mainwindow.setMinimumResolution(QSize(800, 600));
if (!mainwindow.context()->isValid())
{
QMessageBox::critical(NULL, "Oops!", "Warzone2100 failed to create an OpenGL context. This probably means that your graphics drivers are out of date. Try updating them!");
return EXIT_FAILURE;
}
screenWidth = w;
screenHeight = h;
if (war_getFullscreen())
{
mainwindow.resize(w,h);
mainwindow.showFullScreen();
if(w>mainwindow.width()) {
w = mainwindow.width();
}
if(h>mainwindow.height()) {
h = mainwindow.height();
}
pie_SetVideoBufferWidth(w);
pie_SetVideoBufferHeight(h);
}
else
{
mainwindow.show();
mainwindow.setMinimumSize(w, h);
mainwindow.setMaximumSize(w, h);
}
mainwindow.setSwapInterval(war_GetVsync());
war_SetVsync(mainwindow.swapInterval() > 0);
mainwindow.setReadyToPaint();
char buf[256];
ssprintf(buf, "Video Mode %d x %d (%s)", w, h, war_getFullscreen() ? "fullscreen" : "window");
addDumpInfo(buf);
debug(LOG_MAIN, "Final initialization");
if (!frameInitialise())
{
return EXIT_FAILURE;
}
war_SetWidth(pie_GetVideoBufferWidth());
war_SetHeight(pie_GetVideoBufferHeight());
pie_SetFogStatus(false);
pie_ScreenFlip(CLEAR_BLACK);
pal_Init();
pie_LoadBackDrop(SCREEN_RANDOMBDROP);
pie_SetFogStatus(false);
pie_ScreenFlip(CLEAR_BLACK);
if (!systemInitialise())
{
return EXIT_FAILURE;
}
//set all the pause states to false
setAllPauseStates(false);
/* Runtime unit testing */
if (selfTest)
{
parseTest();
levTest();
mapTest();
fprintf(stdout, "All tests PASSED!\n");
exit(0);
}
// Copy this info to be used by the crash handler for the dump file
ssprintf(buf,"Using language: %s", getLanguageName());
addDumpInfo(buf);
// Do the game mode specific initialisation.
switch(GetGameMode())
{
case GS_TITLE_SCREEN:
startTitleLoop();
break;
case GS_SAVEGAMELOAD:
initSaveGameLoad();
break;
case GS_NORMAL:
startGameLoop();
break;
default:
debug(LOG_ERROR, "Weirdy game status, I'm afraid!!");
break;
}
#if defined(WZ_CC_MSVC) && defined(DEBUG)
debug_MEMSTATS();
#endif
debug(LOG_MAIN, "Entering main loop");
app.exec();
saveConfig();
systemShutdown();
debug(LOG_MAIN, "Completed shutting down Warzone 2100");
return EXIT_SUCCESS;
}
/** Displays all the console messages */
void displayConsoleMessages( void )
{
CONSOLE_MESSAGE *psMessage;
int linePitch;
int boxDepth;
int drop;
int MesY;
int clipDepth;
unsigned int exceed, numProcessed;
/* Are there any to display? */
if(consoleMessages == NULL && !bConsoleDropped)
{
/* No point - so get out */
return;
}
/* Return if it's disabled */
if(!bConsoleDisplayEnabled)
{
return;
}
/* Get the travel to the next line */
linePitch = iV_GetTextLineSize();
pie_SetDepthBufferStatus(DEPTH_CMP_ALWAYS_WRT_ON);
pie_SetFogStatus(false);
drop = 0;
if(bConsoleDropped)
{
drop = displayOldMessages();
}
if(consoleMessages==NULL)
{
return;
}
/* Do we want a box under it? */
if(bTextBoxActive)
{
for (psMessage = consoleMessages, exceed = 0;
psMessage && consoleVisibleLines > 0 && exceed < 4; // ho ho ho!!!
psMessage = psMessage->psNext)
{
if (iV_GetTextWidth(psMessage->text) > mainConsole.width)
{
++exceed;
}
}
/* How big a box is necessary? */
boxDepth = (numActiveMessages> consoleVisibleLines ? consoleVisibleLines-1 : numActiveMessages-1);
/* Add on the extra - hope it doesn't exceed two lines! */
boxDepth += exceed;
/* GET RID OF THE MAGIC NUMBERS BELOW */
clipDepth = (mainConsole.topY+(boxDepth*linePitch)+CON_BORDER_HEIGHT+drop);
if(clipDepth > (pie_GetVideoBufferHeight() - linePitch))
{
clipDepth = (pie_GetVideoBufferHeight() - linePitch);
}
iV_TransBoxFill(mainConsole.topX - CON_BORDER_WIDTH,mainConsole.topY-mainConsole.textDepth-CON_BORDER_HEIGHT+drop+1,
mainConsole.topX+mainConsole.width ,clipDepth);
}
/* Stop when we've drawn enough or we're at the end */
MesY = mainConsole.topY + drop;
for (psMessage = consoleMessages, numProcessed = 0;
psMessage && numProcessed < consoleVisibleLines && MesY < (pie_GetVideoBufferHeight() - linePitch);
psMessage = psMessage->psNext)
{
/* Set text color depending on message type */
setConsoleTextColor(psMessage->player);
/* Draw the text string */
MesY = iV_DrawFormattedText(psMessage->text, mainConsole.topX, MesY,
mainConsole.width, psMessage->JustifyType);
/* Move on */
++numProcessed;
}
}
// ///////////////// /////////////////////////////////////////////////
// Main Front end game loop.
TITLECODE titleLoop(void)
{
TITLECODE RetCode = TITLECODE_CONTINUE;
pie_SetDepthBufferStatus(DEPTH_CMP_ALWAYS_WRT_ON);
pie_SetFogStatus(false);
screen_RestartBackDrop();
wzShowMouse(true);
// When we first init the game, firstcall is true.
if (firstcall)
{
firstcall = false;
// First check to see if --host was given as a command line option, if not,
// then check --join and if neither, run the normal game menu.
if( hostlaunch )
{
ingame.bHostSetup = true;
bMultiPlayer = true;
bMultiMessages = true;
game.type = SKIRMISH; // needed?
changeTitleMode(MULTIOPTION);
hostlaunch = false; // reset the bool to default state.
}
else if(strlen(iptoconnect) )
{
joinGame(iptoconnect, 0);
}
else
{
changeTitleMode(TITLE); // normal game, run main title screen.
}
// Using software cursors (when on) for these menus due to a bug in SDL's SDL_ShowCursor()
wzSetCursor(CURSOR_DEFAULT);
}
if (titleMode != MULTIOPTION && titleMode != MULTILIMIT && titleMode != STARTGAME)
screen_disableMapPreview();
switch(titleMode) // run relevant title screen code.
{
// MULTIPLAYER screens
case PROTOCOL:
runConnectionScreen(); // multiplayer connection screen.
break;
case MULTIOPTION:
runMultiOptions();
break;
case GAMEFIND:
runGameFind();
break;
case MULTI:
runMultiPlayerMenu();
break;
case MULTILIMIT:
runLimitScreen();
break;
case KEYMAP:
runKeyMapEditor();
break;
case TITLE:
runTitleMenu();
break;
case SINGLE:
runSinglePlayerMenu();
break;
case TUTORIAL:
runTutorialMenu();
break;
// case GRAPHICS:
// runGraphicsOptionsMenu();
// break;
case CREDITS:
runCreditsScreen();
break;
// case DEMOMODE:
// runDemoMenu();
// break;
// case VIDEO:
// runVideoOptionsMenu();
// break;
case OPTIONS:
runOptionsMenu();
break;
case GAME:
runGameOptionsMenu();
break;
case GRAPHICS_OPTIONS:
runGraphicsOptionsMenu();
break;
case AUDIO_OPTIONS:
runAudioOptionsMenu();
break;
case VIDEO_OPTIONS:
runVideoOptionsMenu();
break;
case MOUSE_OPTIONS:
runMouseOptionsMenu();
break;
case QUIT:
RetCode = TITLECODE_QUITGAME;
break;
case STARTGAME:
case LOADSAVEGAME:
if (titleMode == LOADSAVEGAME)
{
RetCode = TITLECODE_SAVEGAMELOAD;
}
else
{
RetCode = TITLECODE_STARTGAME;
}
return RetCode; // don't flip!
case SHOWINTRO:
pie_SetFogStatus(false);
pie_ScreenFlip(CLEAR_BLACK);
changeTitleMode(TITLE);
RetCode = TITLECODE_SHOWINTRO;
break;
default:
debug( LOG_FATAL, "unknown title screen mode" );
abort();
}
NETflush(); // Send any pending network data.
audio_Update();
pie_SetFogStatus(false);
pie_ScreenFlip(CLEAR_BLACK);//title loop
if ((keyDown(KEY_LALT) || keyDown(KEY_RALT))
/* Check for toggling display mode */
&& keyPressed(KEY_RETURN)) {
wzToggleFullscreen();
}
return RetCode;
}
static void pie_Draw3DShape2(const iIMDShape *shape, int frame, PIELIGHT colour, PIELIGHT teamcolour, int pieFlag, int pieFlagData, glm::mat4 &matrix)
{
bool light = true;
glLoadMatrixf(&matrix[0][0]);
/* Set fog status */
if (!(pieFlag & pie_FORCE_FOG) && (pieFlag & pie_ADDITIVE || pieFlag & pie_TRANSLUCENT || pieFlag & pie_PREMULTIPLIED))
{
pie_SetFogStatus(false);
}
else
{
pie_SetFogStatus(true);
}
/* Set tranlucency */
if (pieFlag & pie_ADDITIVE)
{
pie_SetRendMode(REND_ADDITIVE);
colour.byte.a = (UBYTE)pieFlagData;
light = false;
}
else if (pieFlag & pie_TRANSLUCENT)
{
pie_SetRendMode(REND_ALPHA);
colour.byte.a = (UBYTE)pieFlagData;
light = false;
}
else if (pieFlag & pie_PREMULTIPLIED)
{
pie_SetRendMode(REND_PREMULTIPLIED);
light = false;
}
else
{
pie_SetRendMode(REND_OPAQUE);
}
if ((pieFlag & pie_PREMULTIPLIED) == 0)
{
glEnable(GL_ALPHA_TEST);
glAlphaFunc(GL_GREATER, 0.001f);
}
if (pieFlag & pie_ECM)
{
pie_SetRendMode(REND_ALPHA);
light = true;
pie_SetShaderEcmEffect(true);
}
if (light)
{
if (shape->shaderProgram)
{
pie_ActivateShader(shape->shaderProgram, shape, teamcolour, colour);
}
else
{
pie_ActivateShader(SHADER_COMPONENT, shape, teamcolour, colour);
}
}
else
{
pie_DeactivateShader();
}
glColor4ubv(colour.vector); // Only need to set once for entire model
pie_SetTexturePage(shape->texpage);
frame %= MAX(1, shape->numFrames);
glBindBuffer(GL_ARRAY_BUFFER, shape->buffers[VBO_VERTEX]); glVertexPointer(3, GL_FLOAT, 0, NULL);
glBindBuffer(GL_ARRAY_BUFFER, shape->buffers[VBO_NORMAL]); glNormalPointer(GL_FLOAT, 0, NULL);
glBindBuffer(GL_ARRAY_BUFFER, shape->buffers[VBO_TEXCOORD]); glTexCoordPointer(2, GL_FLOAT, 0, NULL);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, shape->buffers[VBO_INDEX]);
glDrawElements(GL_TRIANGLES, shape->npolys * 3, GL_UNSIGNED_SHORT, BUFFER_OFFSET(frame * shape->npolys * 3 * sizeof(uint16_t)));
polyCount += shape->npolys;
pie_SetShaderEcmEffect(false);
glDisable(GL_ALPHA_TEST);
}
static void pie_Draw3DShape2(iIMDShape *shape, int frame, PIELIGHT colour, PIELIGHT teamcolour, int pieFlag, int pieFlagData)
{
iIMDPoly *pPolys;
bool light = true;
bool shaders = pie_GetShaderUsage();
pie_SetAlphaTest((pieFlag & pie_PREMULTIPLIED) == 0);
/* Set fog status */
if (!(pieFlag & pie_FORCE_FOG) &&
(pieFlag & pie_ADDITIVE || pieFlag & pie_TRANSLUCENT || pieFlag & pie_BUTTON || pieFlag & pie_PREMULTIPLIED))
{
pie_SetFogStatus(false);
}
else
{
pie_SetFogStatus(true);
}
/* Set tranlucency */
if (pieFlag & pie_ADDITIVE)
{
pie_SetRendMode(REND_ADDITIVE);
colour.byte.a = (UBYTE)pieFlagData;
light = false;
}
else if (pieFlag & pie_TRANSLUCENT)
{
pie_SetRendMode(REND_ALPHA);
colour.byte.a = (UBYTE)pieFlagData;
light = false;
}
else if (pieFlag & pie_PREMULTIPLIED)
{
pie_SetRendMode(REND_PREMULTIPLIED);
light = false;
}
else
{
if (pieFlag & pie_BUTTON)
{
pie_SetDepthBufferStatus(DEPTH_CMP_LEQ_WRT_ON);
light = false;
if (shaders)
{
pie_ActivateShader(SHADER_BUTTON, shape, teamcolour, colour);
}
else
{
pie_ActivateFallback(SHADER_BUTTON, shape, teamcolour, colour);
}
}
pie_SetRendMode(REND_OPAQUE);
}
if (pieFlag & pie_ECM)
{
pie_SetRendMode(REND_ALPHA);
light = true;
pie_SetShaderEcmEffect(true);
}
if (light)
{
glMaterialfv(GL_FRONT, GL_AMBIENT, shape->material[LIGHT_AMBIENT]);
glMaterialfv(GL_FRONT, GL_DIFFUSE, shape->material[LIGHT_DIFFUSE]);
glMaterialfv(GL_FRONT, GL_SPECULAR, shape->material[LIGHT_SPECULAR]);
glMaterialf(GL_FRONT, GL_SHININESS, shape->shininess);
glMaterialfv(GL_FRONT, GL_EMISSION, shape->material[LIGHT_EMISSIVE]);
if (shaders)
{
pie_ActivateShader(SHADER_COMPONENT, shape, teamcolour, colour);
}
else
{
pie_ActivateFallback(SHADER_COMPONENT, shape, teamcolour, colour);
}
}
if (pieFlag & pie_HEIGHT_SCALED) // construct
{
glScalef(1.0f, (float)pieFlagData / (float)pie_RAISE_SCALE, 1.0f);
}
if (pieFlag & pie_RAISE) // collapse
{
glTranslatef(1.0f, (-shape->max.y * (pie_RAISE_SCALE - pieFlagData)) * (1.0f / pie_RAISE_SCALE), 1.0f);
}
glColor4ubv(colour.vector); // Only need to set once for entire model
pie_SetTexturePage(shape->texpage);
frame %= MAX(1, shape->numFrames);
glBegin(GL_TRIANGLES);
for (pPolys = shape->polys; pPolys < shape->polys + shape->npolys; pPolys++)
{
Vector3f vertexCoords[3];
unsigned int n, frameidx = frame;
int *index;
if (!(pPolys->flags & iV_IMD_TEXANIM))
{
frameidx = 0;
}
for (n = 0, index = pPolys->pindex;
n < pPolys->npnts;
n++, index++)
{
vertexCoords[n].x = shape->points[*index].x;
vertexCoords[n].y = shape->points[*index].y;
vertexCoords[n].z = shape->points[*index].z;
}
polyCount++;
glNormal3fv((GLfloat*)&pPolys->normal);
for (n = 0; n < pPolys->npnts; n++)
{
GLfloat* texCoord = (GLfloat*)&pPolys->texCoord[frameidx * pPolys->npnts + n];
glTexCoord2fv(texCoord);
if (!shaders)
{
glMultiTexCoord2fv(GL_TEXTURE1, texCoord);
}
glVertex3fv((GLfloat*)&vertexCoords[n]);
}
}
glEnd();
if (light || (pieFlag & pie_BUTTON))
{
if (shaders)
{
pie_DeactivateShader();
}
else
{
pie_DeactivateFallback();
}
}
pie_SetShaderEcmEffect(false);
if (pieFlag & pie_BUTTON)
{
pie_SetDepthBufferStatus(DEPTH_CMP_ALWAYS_WRT_ON);
}
}
static void pie_Draw3DShape2(const iIMDShape *shape, int frame, PIELIGHT colour, PIELIGHT teamcolour, int pieFlag, int pieFlagData, glm::mat4 const &matrix)
{
bool light = true;
glLoadMatrixf(&matrix[0][0]);
/* Set fog status */
if (!(pieFlag & pie_FORCE_FOG) && (pieFlag & pie_ADDITIVE || pieFlag & pie_TRANSLUCENT || pieFlag & pie_PREMULTIPLIED))
{
pie_SetFogStatus(false);
}
else
{
pie_SetFogStatus(true);
}
/* Set tranlucency */
if (pieFlag & pie_ADDITIVE)
{
pie_SetRendMode(REND_ADDITIVE);
colour.byte.a = (UBYTE)pieFlagData;
light = false;
}
else if (pieFlag & pie_TRANSLUCENT)
{
pie_SetRendMode(REND_ALPHA);
colour.byte.a = (UBYTE)pieFlagData;
light = false;
}
else if (pieFlag & pie_PREMULTIPLIED)
{
pie_SetRendMode(REND_PREMULTIPLIED);
light = false;
}
else
{
pie_SetRendMode(REND_OPAQUE);
}
if (pieFlag & pie_ECM)
{
pie_SetRendMode(REND_ALPHA);
light = true;
pie_SetShaderEcmEffect(true);
}
SHADER_MODE mode = shape->shaderProgram == SHADER_NONE ? light ? SHADER_COMPONENT : SHADER_NOLIGHT : shape->shaderProgram;
SHADER_PROGRAM &program = pie_ActivateShader(mode, shape, teamcolour, colour);
glUniform1i(program.locAlphaTest, (pieFlag & pie_PREMULTIPLIED) == 0);
pie_SetTexturePage(shape->texpage);
frame %= std::max<int>(1, shape->numFrames);
enableArray(shape->buffers[VBO_VERTEX], program.locVertex, 3, GL_FLOAT, false, 0, 0);
enableArray(shape->buffers[VBO_NORMAL], program.locNormal, 3, GL_FLOAT, false, 0, 0);
enableArray(shape->buffers[VBO_TEXCOORD], program.locTexCoord, 2, GL_FLOAT, false, 0, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, shape->buffers[VBO_INDEX]);
glDrawElements(GL_TRIANGLES, shape->npolys * 3, GL_UNSIGNED_SHORT, BUFFER_OFFSET(frame * shape->npolys * 3 * sizeof(uint16_t)));
disableArrays();
polyCount += shape->npolys;
pie_SetShaderEcmEffect(false);
}
static void pie_Draw3DShape2(iIMDShape *shape, int frame, PIELIGHT colour, PIELIGHT teamcolour, WZ_DECL_UNUSED PIELIGHT specular, int pieFlag, int pieFlagData)
{
iIMDPoly *pPolys;
bool light = lighting;
pie_SetAlphaTest(true);
/* Set fog status */
if (!(pieFlag & pie_FORCE_FOG) &&
(pieFlag & pie_ADDITIVE || pieFlag & pie_TRANSLUCENT || pieFlag & pie_BUTTON))
{
pie_SetFogStatus(false);
}
else
{
pie_SetFogStatus(true);
}
/* Set tranlucency */
if (pieFlag & pie_ADDITIVE)
{
pie_SetRendMode(REND_ADDITIVE);
colour.byte.a = (UBYTE)pieFlagData;
light = false;
}
else if (pieFlag & pie_TRANSLUCENT)
{
pie_SetRendMode(REND_ALPHA);
colour.byte.a = (UBYTE)pieFlagData;
light = false;
}
else
{
if (pieFlag & pie_BUTTON)
{
pie_SetDepthBufferStatus(DEPTH_CMP_LEQ_WRT_ON);
}
pie_SetRendMode(REND_OPAQUE);
}
if (light)
{
const float ambient[4] = { 1.0f, 1.0f, 1.0f, 1.0f };
const float diffuse[4] = { 1.0f, 1.0f, 1.0f, 1.0f };
const float specular[4] = { 1.0f, 1.0f, 1.0f, 1.0f };
const float shininess = 10;
glEnable(GL_LIGHTING);
glEnable(GL_NORMALIZE);
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, ambient);
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, diffuse);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, specular);
glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, shininess);
}
if (pieFlag & pie_HEIGHT_SCALED) // construct
{
glScalef(1.0f, (float)pieFlagData / (float)pie_RAISE_SCALE, 1.0f);
}
if (pieFlag & pie_RAISE) // collapse
{
glTranslatef(1.0f, (-shape->max.y * (pie_RAISE_SCALE - pieFlagData)) / pie_RAISE_SCALE, 1.0f);
}
glColor4ubv(colour.vector); // Only need to set once for entire model
pie_SetTexturePage(shape->texpage);
// Activate TCMask if needed
if (shape->flags & iV_IMD_TCMASK && rendStates.rendMode == REND_OPAQUE)
{
#ifdef _DEBUG
glErrors();
#endif
if (pie_GetShadersStatus())
{
pie_ActivateShader_TCMask(teamcolour, shape->tcmaskpage);
}
else
{
//Set the environment colour with tcmask
GLfloat tc_env_colour[4];
pal_PIELIGHTtoRGBA4f(&tc_env_colour[0], teamcolour);
// TU0
glActiveTexture(GL_TEXTURE0);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, tc_env_colour);
// TU0 RGB
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_ADD_SIGNED);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_CONSTANT);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR);
// TU0 Alpha
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_REPLACE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
// TU1
glActiveTexture(GL_TEXTURE1);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, _TEX_PAGE[shape->tcmaskpage].id);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
// TU1 RGB
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_INTERPOLATE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_PREVIOUS);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_TEXTURE0);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB, GL_SRC_ALPHA);
// TU1 Alpha
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_REPLACE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_PREVIOUS);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
// This is why we are doing in opaque mode.
glEnable(GL_BLEND);
glBlendFunc(GL_CONSTANT_COLOR, GL_ZERO);
glBlendColor(colour.byte.r / 255.0, colour.byte.g / 255.0,
colour.byte.b / 255.0, colour.byte.a / 255.0);
}
#ifdef _DEBUG
glErrors();
#endif
}
for (pPolys = shape->polys; pPolys < shape->polys + shape->npolys; pPolys++)
{
Vector2f texCoords[pie_MAX_VERTICES_PER_POLYGON];
Vector3f vertexCoords[pie_MAX_VERTICES_PER_POLYGON];
unsigned int n;
VERTEXID *index;
for (n = 0, index = pPolys->pindex;
n < pPolys->npnts;
n++, index++)
{
vertexCoords[n].x = shape->points[*index].x;
vertexCoords[n].y = shape->points[*index].y;
vertexCoords[n].z = shape->points[*index].z;
texCoords[n].x = pPolys->texCoord[n].x;
texCoords[n].y = pPolys->texCoord[n].y;
}
polyCount++;
// Run TextureAnimation (exluding the new teamcoloured models)
if (frame && pPolys->flags & iV_IMD_TEXANIM && !(shape->flags & iV_IMD_TCMASK))
{
frame %= shape->numFrames;
if (frame > 0)
{
const int framesPerLine = OLD_TEXTURE_SIZE_FIX / (pPolys->texAnim.x * OLD_TEXTURE_SIZE_FIX);
const int uFrame = (frame % framesPerLine) * (pPolys->texAnim.x * OLD_TEXTURE_SIZE_FIX);
const int vFrame = (frame / framesPerLine) * (pPolys->texAnim.y * OLD_TEXTURE_SIZE_FIX);
for (n = 0; n < pPolys->npnts; n++)
{
texCoords[n].x += uFrame / OLD_TEXTURE_SIZE_FIX;
texCoords[n].y += vFrame / OLD_TEXTURE_SIZE_FIX;
}
}
}
glBegin(GL_TRIANGLE_FAN);
if (light)
{
glNormal3fv((GLfloat*)&pPolys->normal);
}
for (n = 0; n < pPolys->npnts; n++)
{
glTexCoord2fv((GLfloat*)&texCoords[n]);
if (shape->flags & iV_IMD_TCMASK && rendStates.rendMode == REND_OPAQUE &&
!pie_GetShadersStatus())
{
glMultiTexCoord2fv(GL_TEXTURE1, (GLfloat*)&texCoords[n]);
}
glVertex3fv((GLfloat*)&vertexCoords[n]);
}
glEnd();
}
// Deactivate TCMask if it was previously enabled
if (shape->flags & iV_IMD_TCMASK && rendStates.rendMode == REND_OPAQUE)
{
if (pie_GetShadersStatus())
{
pie_DeactivateShader();
}
else
{
glDisable(GL_BLEND);
glActiveTexture(GL_TEXTURE1);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glDisable(GL_TEXTURE_2D);
glActiveTexture(GL_TEXTURE0);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
}
}
if (pieFlag & pie_BUTTON)
{
pie_SetDepthBufferStatus(DEPTH_CMP_ALWAYS_WRT_ON);
}
if (light)
{
glDisable(GL_LIGHTING);
glDisable(GL_NORMALIZE);
}
}
static void pie_Draw3DShape2(const iIMDShape *shape, int frame, PIELIGHT colour, PIELIGHT teamcolour, int pieFlag, int pieFlagData, glm::mat4 const &matrix)
{
bool light = true;
/* Set fog status */
if (!(pieFlag & pie_FORCE_FOG) && (pieFlag & pie_ADDITIVE || pieFlag & pie_TRANSLUCENT || pieFlag & pie_PREMULTIPLIED))
{
pie_SetFogStatus(false);
}
else
{
pie_SetFogStatus(true);
}
/* Set tranlucency */
if (pieFlag & pie_ADDITIVE)
{
pie_SetRendMode(REND_ADDITIVE);
colour.byte.a = (UBYTE)pieFlagData;
light = false;
}
else if (pieFlag & pie_TRANSLUCENT)
{
pie_SetRendMode(REND_ALPHA);
colour.byte.a = (UBYTE)pieFlagData;
light = false;
}
else if (pieFlag & pie_PREMULTIPLIED)
{
pie_SetRendMode(REND_PREMULTIPLIED);
light = false;
}
else
{
pie_SetRendMode(REND_OPAQUE);
}
if (pieFlag & pie_ECM)
{
pie_SetRendMode(REND_ALPHA);
light = true;
pie_SetShaderEcmEffect(true);
}
glm::vec4 sceneColor(lighting0[LIGHT_EMISSIVE][0], lighting0[LIGHT_EMISSIVE][1], lighting0[LIGHT_EMISSIVE][2], lighting0[LIGHT_EMISSIVE][3]);
glm::vec4 ambient(lighting0[LIGHT_AMBIENT][0], lighting0[LIGHT_AMBIENT][1], lighting0[LIGHT_AMBIENT][2], lighting0[LIGHT_AMBIENT][3]);
glm::vec4 diffuse(lighting0[LIGHT_DIFFUSE][0], lighting0[LIGHT_DIFFUSE][1], lighting0[LIGHT_DIFFUSE][2], lighting0[LIGHT_DIFFUSE][3]);
glm::vec4 specular(lighting0[LIGHT_SPECULAR][0], lighting0[LIGHT_SPECULAR][1], lighting0[LIGHT_SPECULAR][2], lighting0[LIGHT_SPECULAR][3]);
SHADER_MODE mode = shape->shaderProgram == SHADER_NONE ? light ? SHADER_COMPONENT : SHADER_NOLIGHT : shape->shaderProgram;
pie_internal::SHADER_PROGRAM &program = pie_ActivateShaderDeprecated(mode, shape, teamcolour, colour, matrix, pie_PerspectiveGet(),
glm::vec4(currentSunPosition, 0.f), sceneColor, ambient, diffuse, specular);
if (program.locations.size() >= 9)
glUniform1i(program.locations[8], (pieFlag & pie_PREMULTIPLIED) == 0);
pie_SetTexturePage(shape->texpage);
frame %= std::max<int>(1, shape->numFrames);
enableArray(shape->buffers[VBO_VERTEX], program.locVertex, 3, GL_FLOAT, false, 0, 0);
enableArray(shape->buffers[VBO_NORMAL], program.locNormal, 3, GL_FLOAT, false, 0, 0);
enableArray(shape->buffers[VBO_TEXCOORD], program.locTexCoord, 2, GL_FLOAT, false, 0, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, shape->buffers[VBO_INDEX]);
glDrawElements(GL_TRIANGLES, shape->npolys * 3, GL_UNSIGNED_SHORT, BUFFER_OFFSET(frame * shape->npolys * 3 * sizeof(uint16_t)));
disableArrays();
polyCount += shape->npolys;
pie_SetShaderEcmEffect(false);
pie_DeactivateShader();
}