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);
}
static void displayStructureBar(WIDGET *psWidget, UDWORD xOffset, UDWORD yOffset)
{
int x = xOffset + psWidget->x();
int y = yOffset + psWidget->y();
int w = psWidget->width();
int h = psWidget->height();
STRUCTURE_STATS *stat = asStructureStats + psWidget->UserData;
Position position;
Vector3i rotation;
char str[20];
UDWORD scale,Radius;
drawBlueBox(x,y,w,h);
// draw image
pie_SetGeometricOffset(x + 35, y + psWidget->height()/2 + 9);
rotation.x = -15;
rotation.y = ((realTime/45)%360) ; //45
rotation.z = 0;
position.x = 0;
position.y = 0;
position.z = BUTTON_DEPTH*2;//getStructureStatSize(stat) * 38 * OBJECT_RADIUS;
Radius = getStructureStatSizeMax(stat);
if(Radius <= 128) {
scale = SMALL_STRUCT_SCALE;
} else if(Radius <= 256) {
scale = MED_STRUCT_SCALE;
} else {
scale = LARGE_STRUCT_SCALE;
}
pie_SetDepthBufferStatus(DEPTH_CMP_LEQ_WRT_ON);
displayStructureStatButton(stat, &rotation, &position, true, scale);
pie_SetDepthBufferStatus(DEPTH_CMP_ALWAYS_WRT_ON);
// draw name
iV_SetFont(font_regular); // font
iV_SetTextColour(WZCOL_TEXT_BRIGHT);
iV_DrawText(_(getName(stat->pName)), x + 80, y + psWidget->height()/2 + 3);
// draw limit
ssprintf(str, "%d", ((W_SLIDER *)widgGetFromID(psWScreen, psWidget->id + 1))->pos);
iV_DrawText(str, x + 270, y + psWidget->height()/2 + 3);
return;
}
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);
}
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 screen_Display()
{
pie_SetDepthBufferStatus(DEPTH_CMP_ALWAYS_WRT_OFF);
// Draw backdrop
glColor3f(1, 1, 1);
backdropGfx->draw();
if (mappreview)
{
int s1 = screenWidth / preview_width;
int s2 = screenHeight / preview_height;
int scale = MIN(s1, s2);
int w = preview_width * scale;
int h = preview_height * scale;
for (int i = 0; i < MAX_PLAYERS; i++)
{
int x = player_pos[i].x;
int y = player_pos[i].y;
char text[5];
if (x == 0x77777777)
{
continue;
}
x = screenWidth / 2 - w / 2 + x * scale;
y = screenHeight / 2 - h / 2 + y * scale;
ssprintf(text, "%d", i);
iV_SetFont(font_large);
iV_SetTextColour(WZCOL_BLACK);
iV_DrawText(text, x - 1, y - 1);
iV_DrawText(text, x + 1, y - 1);
iV_DrawText(text, x - 1, y + 1);
iV_DrawText(text, x + 1, y + 1);
iV_SetTextColour(WZCOL_WHITE);
iV_DrawText(text, x, y);
}
}
pie_SetDepthBufferStatus(DEPTH_CMP_LEQ_WRT_ON);
}
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);
}
/** 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);
}
}
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);
}
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;
}
// ///////////////// /////////////////////////////////////////////////
// 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(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(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);
}
}
/** 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;
}
}