/*-----------------------------------------------------------------------------
Name : svFirepowerRender
Description : Callback which draws the firepower stat in ship view.
Inputs : standard FE callback
Outputs : ..
Return : void
----------------------------------------------------------------------------*/
void svFirepowerRender(featom *atom, regionhandle region)
{
rectangle *rect = ®ion->rect;
fonthandle currentFont;
uword firepower;
char buftemp[50];
ShipStaticInfo *info = GetShipStaticInfoSafe(svShipType, universe.curPlayerPtr->race);
svFirepowerRegion = region;
if (FELASTCALL(atom))
{
svFirepowerRegion = NULL;
return;
}
if(svShipType == DefaultShip)
{
return;
}
if (info == NULL)
{
info = GetShipStaticInfoSafe(svShipType, GetValidRaceForShipType(svShipType));
}
if (info == NULL)
{
return;
}
currentFont = fontMakeCurrent(svShipStatFont);
if (RGLtype == SWtype) primRectSolid2(®ion->rect, FEC_Background);
if(info->svFirePower !=0)
{
firepower = (uword) info->svFirePower;
}
else
{
firepower = (uword) gunShipFirePower(info, Neutral);
}
if(firepower != 0)
{
sprintf(buftemp,"%d",firepower);
}
else
{
sprintf(buftemp,"%s","-");
}
sprintf(buf,ShipStatToNiceStr(Firepower),buftemp);
fontPrintf(
rect->x0,
rect->y0,
FEC_ListItemStandard,
"%s",
buf);
fontMakeCurrent(currentFont);
}
void hrDrawChatBox(featom *atom, regionhandle region)
{
fonthandle currentfont;
sdword x,y,i;
char name[128];
hrChatBoxRegion = region;
currentfont = fontMakeCurrent(playernamefont);
primRectSolid2(®ion->rect,colRGB(0,0,0));
feStaticRectangleDraw(region);
x = region->rect.x0+10;
y = region->rect.y0;
for (i=0;i<NUM_CHAT_LINES;i++)
{
if (chathistory[i].message[0]!=0)
{
x = region->rect.x0;
sprintf(name,"%s >",tpGameCreated.playerInfo[chathistory[i].packetheader.frame].PersonalName);
fontPrintf(x,y,tpGameCreated.playerInfo[chathistory[i].packetheader.frame].baseColor,"%s",name);
x+=fontWidth(name)+10;
//fontShadowSet(FS_E | FS_SE | FS_S);
fontPrintf(x,y,hrChatTextColor,"%s",chathistory[i].message);
//fontShadowSet(FS_NONE);
y+= fontHeight(" ");
}
}
fontMakeCurrent(currentfont);
}
/*-----------------------------------------------------------------------------
Name : tmNumberRUsDraw
Description : Callback to draw number of RU's available
Inputs :
Outputs :
Return :
----------------------------------------------------------------------------*/
void tmNumberRUsDraw(featom *atom, regionhandle region)
{
sdword width;
fonthandle oldfont;
rectangle rect = region->rect;
tmNumberRUsRegion = region;
oldfont = fontMakeCurrent(tmTechListFont);
width = fontWidthf("%d", universe.curPlayerPtr->resourceUnits);//width of number
primModeSet2();
primRectSolid2(&rect, colRGB(0, 0, 0));
glEnable(GL_SCISSOR_TEST);
glScissor(rect.x0, MAIN_WindowHeight - rect.y1, rect.x1 - rect.x0, rect.y1 - rect.y0);
glClear(GL_DEPTH_BUFFER_BIT);
glDisable(GL_SCISSOR_TEST);
feStaticRectangleDraw(region); //draw regular rectangle as backdrop
fontPrintf(region->rect.x1 - width - TM_RUMarginRight,
(region->rect.y1 - region->rect.y0 - fontHeight(NULL)) / 2 + region->rect.y0,
atom->borderColor, "%d", universe.curPlayerPtr->resourceUnits);
fontMakeCurrent(oldfont);
}
/*-----------------------------------------------------------------------------
Name : svCoverageRender
Description : Callback which draws the coverage stat in ship view.
Inputs : standard FE callback
Outputs : ..
Return : void
----------------------------------------------------------------------------*/
void svCoverageRender(featom *atom, regionhandle region)
{
rectangle *rect = ®ion->rect;
sdword width;
fonthandle currentFont;
char buftemp[50];
uword coverage;
ShipStaticInfo *info = GetShipStaticInfoSafe(svShipType, universe.curPlayerPtr->race);
svCoverageRegion = region;
if (FELASTCALL(atom))
{
svCoverageRegion = NULL;
return;
}
if(svShipType == DefaultShip)
{
return;
}
if (info == NULL)
{
info = GetShipStaticInfoSafe(svShipType, GetValidRaceForShipType(svShipType));
}
if (info == NULL)
{
return; //maybe print UNKNOWN!
}
currentFont = fontMakeCurrent(svShipStatFont);
coverage = svShipCoverage(info);
if(coverage != 0)
{
sprintf(buftemp,"%d %s",coverage,ShipStatToNiceStr(CoverageUnits));
}
else
{
sprintf(buftemp,"%s","-");
}
sprintf(buf,ShipStatToNiceStr(Coverage),buftemp);
width = fontWidthf("%s",buf);
if (RGLtype == SWtype) primRectSolid2(®ion->rect, FEC_Background);
fontPrintf(
rect->x0,//rect->x1 - width,
rect->y0,
FEC_ListItemStandard,
"%s",buf);
fontMakeCurrent(currentFont);
}
/*-----------------------------------------------------------------------------
Name : svTopSpeedRender
Description : Callback which draws the top speed stat in ship view.
Inputs : standard FE callback
Outputs : ..
Return : void
----------------------------------------------------------------------------*/
void svTopSpeedRender(featom *atom, regionhandle region)
{
rectangle *rect = ®ion->rect;
fonthandle currentFont;
char buftemp[50];
ShipStaticInfo *info = GetShipStaticInfoSafe(svShipType, universe.curPlayerPtr->race);
svTopSpeedRegion = region;
if (FELASTCALL(atom))
{
svTopSpeedRegion = NULL;
return;
}
if(svShipType == DefaultShip)
{
return;
}
if (info == NULL)
{
info = GetShipStaticInfoSafe(svShipType, GetValidRaceForShipType(svShipType));
}
if (info == NULL)
{
return;
}
currentFont = fontMakeCurrent(svShipStatFont);
if (RGLtype == SWtype) primRectSolid2(®ion->rect, FEC_Background);
//sprintf(buf,"%d", (uword)info->staticheader.maxvelocity);
//topspeed contains a %d for the numerical location of the maxvelocity
if(info->shiptype == Probe)
{
sprintf(buftemp,"%d",(udword) ((ProbeStatics *) info->custstatinfo)->ProbeDispatchMaxVelocity);
sprintf(buf,ShipStatToNiceStr(TopSpeed),buftemp);
}
else
{
sprintf(buftemp,"%d",(udword) info->staticheader.maxvelocity);
sprintf(buf,ShipStatToNiceStr(TopSpeed),buftemp);
}
fontPrintf(
rect->x0,
rect->y0,
FEC_ListItemStandard,
"%s",
buf);
fontMakeCurrent(currentFont);
}
/*-----------------------------------------------------------------------------
Name : svMassRender
Description : Callback which draws the mass stat in ship view.
Inputs : standard FE callback
Outputs : ..
Return : void
----------------------------------------------------------------------------*/
void svMassRender(featom *atom, regionhandle region)
{
rectangle *rect = ®ion->rect;
fonthandle currentFont;
sdword width;
char buftemp[50];
ShipStaticInfo *info = GetShipStaticInfoSafe(svShipType, universe.curPlayerPtr->race);
svMassRegion = region;
if (FELASTCALL(atom))
{
svMassRegion = NULL;
return;
}
if(svShipType == DefaultShip)
{
return;
}
if (info == NULL)
{
info = GetShipStaticInfoSafe(svShipType, GetValidRaceForShipType(svShipType));
}
if (info == NULL)
{
return;
}
currentFont = fontMakeCurrent(svShipStatFont);
//sprintf(buf, "%d", (uword)info->staticheader.mass);
//Mass str contains a %d for the mass to expand into
sprintf(buftemp,"%d",(udword)info->staticheader.mass);
sprintf(buf,ShipStatToNiceStr(Mass),buftemp);
width = fontWidthf("%s",
buf); //width of number
//ShipTypeStatToNiceStr(svShipType, Mass));//width of number
if (RGLtype == SWtype) primRectSolid2(®ion->rect, FEC_Background);
fontPrintf(
rect->x0,//rect->x1 - width,
rect->y0,
FEC_ListItemStandard,
"%s",
buf);
//ShipTypeStatToNiceStr(svShipType, Mass));
fontMakeCurrent(currentFont);
}
/*-----------------------------------------------------------------------------
Name : svArmorRender
Description : Callback which draws the armor stat in ship view.
Inputs : standard FE callback
Outputs : ..
Return : void
----------------------------------------------------------------------------*/
void svArmorRender(featom *atom, regionhandle region)
{
rectangle *rect = ®ion->rect;
sdword width;
char buftemp[50];
fonthandle currentFont;
ShipStaticInfo *info = GetShipStaticInfoSafe(svShipType, universe.curPlayerPtr->race);
svArmorRegion = region;
if (FELASTCALL(atom))
{
svArmorRegion = NULL;
return;
}
if(svShipType == DefaultShip)
{
return;
}
if (info == NULL)
{
info = GetShipStaticInfoSafe(svShipType, GetValidRaceForShipType(svShipType));
}
if (info == NULL)
{
return;
}
svArmorRegion = region;
currentFont = fontMakeCurrent(svShipStatFont);
sprintf(buftemp,"%d",(udword) info->maxhealth);
sprintf(buf,ShipStatToNiceStr(Armor),buftemp);
width = fontWidthf("%s",buf);
if (RGLtype == SWtype) primRectSolid2(®ion->rect, FEC_Background);
fontPrintf(
rect->x0,//rect->x1 - width,
rect->y0,
FEC_ListItemStandard,
"%s",buf);
fontMakeCurrent(currentFont);
}
void hrBarDraw(rectangle *rect, color back, color fore, real32 percent)
{
rectangle temp;
// primRectSolid2(rect, back);
if (percent > 1.0)
{
percent = 1.0;
}
temp.x0 = rect->x0;
temp.y0 = rect->y0;
temp.x1 = rect->x0 + (sdword)((rect->x1-rect->x0)*percent);
temp.y1 = rect->y1;
primRectSolid2(&temp, fore);
}
/*-----------------------------------------------------------------------------
Name : svManeuverRender
Description : Callback which draws the maneuver stat in ship view.
Inputs : standard FE callback
Outputs : ..
Return : void
----------------------------------------------------------------------------*/
void svManeuverRender(featom *atom, regionhandle region)
{
rectangle *rect = ®ion->rect;
fonthandle currentFont;
char maneuverability[100] = "";
ShipStaticInfo *info = GetShipStaticInfoSafe(svShipType, universe.curPlayerPtr->race);
svManeuverRegion = region;
if (FELASTCALL(atom))
{
svManeuverRegion = NULL;
return;
}
if (svShipType == DefaultShip)
{
return;
}
if (info == NULL)
{
info = GetShipStaticInfoSafe(svShipType, GetValidRaceForShipType(svShipType));
}
if (info == NULL)
{
return;
}
currentFont = fontMakeCurrent(svShipStatFont);
if (RGLtype == SWtype) primRectSolid2(®ion->rect, FEC_Background);
svShipManeuverability(info,maneuverability);
sprintf(buf,ShipStatToNiceStr(Maneuver),maneuverability);
fontPrintf(
rect->x0,
rect->y0,
FEC_ListItemStandard,
"%s",buf);
fontMakeCurrent(currentFont);
}
void hrDrawPlayersProgress(featom *atom, regionhandle region)
{
sdword index;
rectangle pos;
rectangle outline;
real32 percent;
fonthandle currentfont;
bool droppedOut;
hrProgressRegion = region;
pos = region->rect;
// primRectSolid2(&pos, colRGBA(0, 0, 0, 64));
pos.y0+=fontHeight(" ");
pos.y1=pos.y0+8;
currentfont = fontMakeCurrent(playernamefont);
if (multiPlayerGame)
{
dbgAssertOrIgnore(sigsNumPlayers == tpGameCreated.numPlayers);
for (index=0;index<sigsNumPlayers;index++)
{
droppedOut = playerHasDroppedOutOrQuit(index);
outline = pos;
outline.x0 -= 5;
outline.x1 += 10;
outline.y0 -= 3;
outline.y1 = outline.y0 + fontHeight(" ")*2 - 2;
if ((hrBackgroundDirty) || (!PlayersAlreadyDrawnDropped[index]))
{
PlayersAlreadyDrawnDropped[index] = droppedOut;
primRectSolid2(&outline, colBlack);
if (droppedOut)
{
fontPrintf(pos.x0,pos.y0,colBlack,"%s",tpGameCreated.playerInfo[index].PersonalName);
fontPrintf(pos.x0,pos.y0,HorseRaceDropoutColor,"%s",
(playersReadyToGo[index] == PLAYER_QUIT) ? strGetString(strQuit) : strGetString(strDroppedOut));
}
else
{
fontPrintf(pos.x0,pos.y0,tpGameCreated.playerInfo[index].baseColor,"%s",tpGameCreated.playerInfo[index].PersonalName);
if (horseracestatus.hrstatusstr[index][0])
{
fontPrintf(pos.x0+150,pos.y0,tpGameCreated.playerInfo[index].baseColor,"%s",horseracestatus.hrstatusstr[index]);
}
}
}
primRectOutline2(&outline, 1, (droppedOut) ? HorseRaceDropoutColor : tpGameCreated.playerInfo[index].stripeColor);
pos.y0+=fontHeight(" ");
pos.y1=pos.y0+4;
percent = horseracestatus.percent[index];
hrBarDraw(&pos,hrBackBarColor,(droppedOut) ? HorseRaceDropoutColor : tpGameCreated.playerInfo[index].baseColor,percent);
pos.y0+=fontHeight(" ");
}
}
else if (singlePlayerGame)
{
pos = hrSinglePlayerPos;
// progress bar
if (pos.x0 != 0)
{
percent = horseracestatus.percent[0];
//dbgMessagef("percent %f",percent);
hrBarDraw(&pos, colBlack, hrSinglePlayerLoadingBarColor/*teColorSchemes[0].textureColor.base*/, percent);
}
// blinking hyperspace destination (render every other call)
if (++hrProgressCounter % 2 == 0)
{
hrBackgroundDirty = 3; // 1 - nothing happens as decremented before rendered
// 2 - background is cleared but not redrawn
// 3 - 3's the charm
// hyperspace destination circled in first-person view
#define SP_LOADING_HYPERSPACE_DEST_CIRCLE_X 115
#define SP_LOADING_HYPERSPACE_DEST_CIRCLE_Y 342
// hyperspace destination arrowed in "as the bird flies" view
#define SP_LOADING_HYPERSPACE_DEST_ARROWS_X 195
#define SP_LOADING_HYPERSPACE_DEST_ARROWS_Y 134
// NB: hrDrawFile deals with coordinate mapping
#ifdef _WIN32
hrDrawFile("feman\\loadscreen\\ring.lif",
SP_LOADING_HYPERSPACE_DEST_CIRCLE_X, SP_LOADING_HYPERSPACE_DEST_CIRCLE_Y
);
hrDrawFile("feman\\loadscreen\\arrows.lif",
SP_LOADING_HYPERSPACE_DEST_ARROWS_X, SP_LOADING_HYPERSPACE_DEST_ARROWS_Y
);
#else
hrDrawFile("feman/loadscreen/ring.lif",
SP_LOADING_HYPERSPACE_DEST_CIRCLE_X, SP_LOADING_HYPERSPACE_DEST_CIRCLE_Y
);
hrDrawFile("feman/loadscreen/arrows.lif",
SP_LOADING_HYPERSPACE_DEST_ARROWS_X, SP_LOADING_HYPERSPACE_DEST_ARROWS_Y
);
#endif
}
}
else
{
if (hrBackgroundDirty)
{
outline = pos;
outline.x0 -= 5;
outline.x1 += 10;
outline.y0 -= 3;
outline.y1 = outline.y0 + fontHeight(" ")*2 - 2;
primRectTranslucent2(&outline, colRGBA(0,0,0,64));
primRectOutline2(&outline, 1, teColorSchemes[0].textureColor.detail);
fontPrintf(pos.x0,pos.y0,teColorSchemes[0].textureColor.base,"%s",playerNames[0]);
}
pos.y0+=fontHeight(" ");
pos.y1=pos.y0+4;
percent = horseracestatus.percent[0];
hrBarDraw(&pos,hrBackBarColor,teColorSchemes[0].textureColor.base,percent);
}
fontMakeCurrent(currentfont);
}
/*-----------------------------------------------------------------------------
Name : trkTrackValuesDisplayFn
Description : Renders all the track values
Inputs :
Outputs :
Return :
----------------------------------------------------------------------------*/
void trkTrackValuesDisplayFn(void)
{
sdword index, range;
sdword x, y, xMin, xMax, xMed, width, height;
real32 delta, timeElapsed;
rectangle rect;
if (keyIsStuck(TRK_ToggleKey))
{
keyClearSticky(TRK_ToggleKey);
trkTrackingVisual ^= TRUE;
}
if (!trkTrackingVisual || trkTrackIndex == 0)
{
return;
}
/*
if (timeElapsed == 0.0f)
{
return;
}
*/
height = fontHeight(" ") + 1;
y = (MAIN_WindowHeight - (height * trkTrackIndex)) / 2;
width = fontWidth("+100M") + 1;
x = MAIN_WindowWidth - width * 2 - TRK_TrackWidth;
xMin = x + width;
xMax = xMin + TRK_TrackWidth;
xMed = (xMin + xMax) / 2;
for (index = 0; index < trkTrackIndex; index++, y += height)
{
timeElapsed = *trkValue[index].timer - trkValue[index].lastTime;
trkValue[index].lastTime = *trkValue[index].timer;
if (timeElapsed == 0.0f)
{
continue;
}
//print the name of the value
fontPrint(x - fontWidth(trkValue[index].name), y, trkValue[index].c, trkValue[index].name);
delta = abs(*trkValue[index].value - trkValue[index].lastValue) / timeElapsed;//see how much it has changed
if (delta == 0.0f)
{ //don't do anything else if it has not changed
continue;
}
//find what range to print in
if (delta / trkRangeString[0].base > 10.0f)
{ //if it's bigger than the biggest range
continue;
}
for (range = 0; trkRangeString[range].minusString; range++)
{
if (delta / trkRangeString[range].base >= 1.0f)
{ //if this is the right range
//get the real delta and bias it against the base
delta = (trkValue[index].lastValue - *trkValue[index].value) / timeElapsed / trkRangeString[range].base;
rect.y0 = y;
rect.y1 = y + height - 1;
if (delta < 0.0f)
{
rect.x0 = xMed + (sdword)(delta * (real32)TRK_TrackWidth / 20.0f);
rect.x1 = xMed;
}
else
{
rect.x0 = xMed;
rect.x1 = xMed + (sdword)(delta * (real32)TRK_TrackWidth / 20.0f);
}
dbgAssert(rect.x0 != rect.x1);
primRectSolid2(&rect, trkValue[index].c);
fontPrint(xMin - fontWidth(trkRangeString[range].minusString) - 1, y, colWhite, trkRangeString[range].minusString);
fontPrint(xMax + 1, y, colWhite, trkRangeString[range].plusString);
break;
}
}
trkValue[index].lastValue = *trkValue[index].value;
}
}
/*-----------------------------------------------------------------------------
Name : svShipViewRender
Description : Callback which draws the main ship view.
Inputs : standard FE callback
Outputs : ..
Return : void
----------------------------------------------------------------------------*/
void svShipViewRender(featom* atom, regionhandle region)
{
rectangle drawRect;
rectangle* rect;
rectangle viewRect;
fonthandle currentFont;
GLint viewPort[4];
GLint box[4];
ShipStaticInfo* info;
real32 scale;
sdword width, height;
sdword x, y;
keyindex key;
char* keystring;
bool resetRender = FALSE;
char temp[100];
// facilitates smooth transition between auto/manual rotation of ship
static real32 angle_user_rotated_to = 0.0f;
static real32 declination_user_rotated_to = 0.0f;
static real32 time_user_rotated_view = 0.0f;
real32 real_time_angle = 0.0f;
static real32 user_real_angle_offset = 0.0f;
rect = ®ion->rect;
viewRect.x0 = 0;
viewRect.y0 = 0;
viewRect.x1 = MAIN_WindowWidth - 1;
viewRect.y1 = MAIN_WindowHeight - 1;
info = NULL;
if (svShipType != DefaultShip)
{
if (universe.curPlayerPtr)
{
info = GetShipStaticInfoSafe(svShipType, universe.curPlayerPtr->race);
}
if (info == NULL)
{
info = GetShipStaticInfoSafe(svShipType, GetValidRaceForShipType(svShipType));
}
if (info == NULL)
{
return;
}
}
svShipViewRegion = region;
if (!resetRender)
{
if (svMouseInside)
{
ferDrawFocusWindow(region, lw_focus);
}
else
{
ferDrawFocusWindow(region, lw_normal);
}
}
soundEventUpdate();
currentFont = fontMakeCurrent(svShipViewFont);
if (region->flags == 0 || region->flags == RPE_DrawFunctionAdded)
{ //if region not processed yet
region->flags =
RPE_Enter | RPE_Exit |
RPE_WheelDown | RPE_WheelUp |
RPE_PressLeft | RPE_ReleaseLeft |
RPE_PressRight | RPE_ReleaseRight;
regFunctionSet(region, (regionfunction) svReadMouseEvent); //set new region handler function
}
//scale = *svScale[svShipType];
//svCamera.closestZoom = *svMinZoom[svShipType];
//svCamera.farthestZoom = *svMaxZoom[svShipType];
scale = 1.0f; //*svScale[svShipType];
if(svShipType != DefaultShip)
{
svCamera.closestZoom = info->minimumZoomDistance*svZoomInScalar;
svCamera.farthestZoom = (svCamera.closestZoom+info->staticheader.staticCollInfo.approxcollspheresize)*svZoomOutScalar;
if(ReZoom)
{
ReZoom=FALSE;
cameraZoom(&svCamera,1.0f,FALSE);
}
if (svMouseInside && (wheel_down || wheel_up))
{
cameraControl(&svCamera, FALSE);
}
else if (svMouseInside && svMousePressRight)
{
camMouseX = (svMouseCentreX - mouseCursorX()) * 4; //was 2
camMouseY = (svMouseCentreY - mouseCursorY()) * 4;
savecamMouseX = savecamMouseX * SPIN_FEEDBACK +
(real32)camMouseX * (1.0f - SPIN_FEEDBACK);
cameraControl(&svCamera, FALSE); //update the camera
mouseCursorHide();
mousePositionSet(svMouseCentreX, svMouseCentreY); // Reset position so it doesn't walk off region
// keep track of where the user left the camera so we can sync auto-rotation with it
angle_user_rotated_to = svCamera.angle;
declination_user_rotated_to = svCamera.declination;
time_user_rotated_view = universe.totaltimeelapsed;
}
else // auto rotate ship model
{
// continual 360 degree yaw rotation
real_time_angle = DEG_TO_RAD(remainder(universe.totaltimeelapsed, SV_360_ROTATION_SECS) / SV_360_ROTATION_SECS * 360);
if (angle_user_rotated_to >= 0.0) {
user_real_angle_offset = angle_user_rotated_to - real_time_angle;
angle_user_rotated_to = -1.0;
}
svCamera.angle = real_time_angle + user_real_angle_offset;
// collapse pitch to default declination
if (time_user_rotated_view > 0.0) {
if (universe.totaltimeelapsed > time_user_rotated_view + SV_PITCH_FLATTEN_SECS) {
svCamera.declination = DEG_TO_RAD(svDeclination);
time_user_rotated_view = 0.0;
}
else {
svCamera.declination = declination_user_rotated_to + (DEG_TO_RAD(svDeclination) - declination_user_rotated_to) * ((universe.totaltimeelapsed - time_user_rotated_view) / SV_PITCH_FLATTEN_SECS);
}
}
if (svMouseInside) mouseCursorShow();
}
}
//rotation
drawRect.x0 = rect->x0 + SV_ViewMargin;
drawRect.y0 = rect->y0 + SV_ViewMargin;
drawRect.x1 = rect->x1 - SV_ViewMargin;
drawRect.y1 = rect->y1 - SV_ViewMargin;
width = drawRect.x1 - drawRect.x0;
height = drawRect.y1 - drawRect.y0;
glGetIntegerv(GL_VIEWPORT, viewPort);
glViewport(drawRect.x0, MAIN_WindowHeight - drawRect.y1, width, height);
primModeSet2();
if (!resetRender)
{
primRectSolid2(&viewRect, FEC_Background);
}
primModeClear2();
glEnable(GL_SCISSOR_TEST);
glGetIntegerv(GL_SCISSOR_BOX, box);
glScissor(drawRect.x0, MAIN_WindowHeight - drawRect.y1, width, height);
glClear(GL_DEPTH_BUFFER_BIT);
glDisable(GL_SCISSOR_TEST);
rndPerspectiveCorrection(TRUE);
//svCamera.lookatpoint.x = -info->staticheader.staticCollInfo.collsphereoffset.z * scale;
//svCamera.lookatpoint.y = -info->staticheader.staticCollInfo.collsphereoffset.x * scale;
//svCamera.lookatpoint.z = -info->staticheader.staticCollInfo.collsphereoffset.y * scale;
if (svShipType == DefaultShip)
{
svCamera.lookatpoint.x=0.0f;
svCamera.lookatpoint.y=0.0f;
svCamera.lookatpoint.z=0.0f;
}
else
{
svCamera.lookatpoint.x = -info->staticheader.staticCollInfo.collsphereoffset.z;
svCamera.lookatpoint.y = -info->staticheader.staticCollInfo.collsphereoffset.x;
svCamera.lookatpoint.z = -info->staticheader.staticCollInfo.collsphereoffset.y;
}
cameraSetEyePosition(&svCamera);
rndLightingEnable(TRUE);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
rgluPerspective(
svCamera.fieldofview,
(float)(width) / (float)(height) /*rndAspectRatio*/, //set projection matrix
svCamera.clipPlaneNear,
svCamera.clipPlaneFar);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
rgluLookAt(
svCamera.eyeposition.x,
svCamera.eyeposition.y,
svCamera.eyeposition.z,
svCamera.lookatpoint.x,
svCamera.lookatpoint.y,
svCamera.lookatpoint.z,
svCamera.upvector.x,
svCamera.upvector.y,
svCamera.upvector.z);
glPushMatrix();
glRotatef(-90.0f, 0.0f, 1.0f, 0.0f);
glGetFloatv(GL_MODELVIEW_MATRIX, (GLfloat *)(&rndCameraMatrix));
glGetFloatv(GL_PROJECTION_MATRIX, (GLfloat *)(&rndProjectionMatrix));
glEnable(GL_NORMALIZE);
glLightfv(GL_LIGHT0, GL_POSITION, lightPosition0); //position light(s) within world
glScalef(scale, scale, scale);
if (svShipType != DefaultShip)
{
sdword index;
//try player index colours first
index = universe.curPlayerIndex;
if (info->teamColor[index] == 0)
{
//colour scheme doesn't exist, search for something valid
for (index = 0; index < MAX_MULTIPLAYER_PLAYERS; index++)
{
if (info->teamColor[index] != 0)
{
break;
}
}
if (index == MAX_MULTIPLAYER_PLAYERS)
{
//this ship doesn't have any colour info,
//at least avoid a GPF
index = universe.curPlayerIndex;
}
}
meshRender((meshdata *)info->staticheader.LOD->level[0].pData, index);
}
glDisable(GL_NORMALIZE);
glPopMatrix();
primModeSet2();
glScissor(box[0], box[1], box[2], box[3]);
glViewport(viewPort[0], viewPort[1], viewPort[2], viewPort[3]);
rndLightingEnable(FALSE);
rndPerspectiveCorrection(FALSE);
x = rect->x0 + 2 + SV_ViewMargin;
y = rect->y0 + 2 + SV_ViewMargin;
if (svShipType != DefaultShip && !resetRender)
{
fontPrintf(
x,
y,
FEC_ListItemStandard,
"%s",
ShipTypeToNiceStr(svShipType));
y += fontHeight(" ");
sprintf(temp, "%s %d %s",strGetString(strSVCost),info->buildCost, strGetString(strSVRUs));
fontPrintf(
x,
y,
FEC_ListItemStandard,
temp);
if (cmPrintHotKey)
{
x = rect->x1 - 2 - SV_ViewMargin;
y = rect->y0 + 2 + SV_ViewMargin;
key = cmShipTypeToKey(svShipType);
keystring = opKeyToNiceString((keyindex)(key & 0x00ff));
if (key & CM_SHIFT)
{
width = fontWidthf("[SHIFT-%s]",keystring);
fontPrintf(
x-width,
y,
FEC_ListItemStandard,
"[SHIFT-%s]",
keystring);
}
else if (key)
{
width = fontWidthf("[%s]",keystring);
fontPrintf(
x-width,
y,
FEC_ListItemStandard,
"[%s]",
keystring);
}
}
}
fontMakeCurrent(currentFont);
svDirtyShipView();
}
/*-----------------------------------------------------------------------------
Name : spNewItem
Description : Called when a new item in the color picker list is selected.
Inputs :
Outputs :
Return :
----------------------------------------------------------------------------*/
void spNewItem(void)
{
char bitmapFile[_MAX_PATH];
char descriptionFile[_MAX_PATH];
char *chopBuffer;
sdword scen;
rectangle textureRect;
// rectangle rect = spScenarioBitmapWindow->rect;
color *bmpBuffer;
filehandle handle;
bmpheader header;
featom *atom;
scen = spScenarioListWindow->CurLineSelected->position;
atom = feAtomFindInScreen(feStack[feStackIndex].screen, "CS_ScenarioBitmap");
dbgAssert(atom != NULL);
if (scenarioTexture != TR_InvalidInternalHandle)
{ //delete the old texture before creating a new one
trRGBTextureDelete(scenarioTexture);
scenarioTexture = TR_InvalidInternalHandle;
if (spTextureData != NULL)
{
memFree(spTextureData);
spTextureData = NULL;
}
}
//free the previous text and set defaults
spDescriptionDefaultsAndFreeText();
spFindImage(bitmapFile, descriptionFile, spScenarios[scen].bitmapfileSpec);
if (strlen(bitmapFile) > 0)
{
handle = bmpFileOpen(&header, bitmapFile); //open the file
if (handle != 0)
{ //if opened properly
if (header.biWidth < SCP_PreviewWidthMin || header.biHeight > SCP_PreviewWidthMax)
{
#if SCP_VERBOSE_LEVEL >= 1
dbgMessagef("\n'%s': width of %d bad.", bitmapFile, header.biWidth);
#endif
bmpClose(handle);
return;
}
else if (header.biHeight < SCP_PreviewHeightMin || header.biHeight > SCP_PreviewHeightMax)
{
#if SCP_VERBOSE_LEVEL >= 1
dbgMessagef("\n'%s': height of %d bad.", bitmapFile, header.biHeight);
#endif
bmpClose(handle);
return;
}
//allocate the image buffer
bmpBuffer = memAlloc(header.biWidth * header.biHeight * sizeof(color), "TempBMPbuffer", Pyrophoric);
bmpBodyRead(bmpBuffer, handle, &header); //read in the body of the file
if (header.biWidth != SCP_PreviewWidth || header.biHeight != SCP_PreviewHeight)
{ //if the image is the wrong size
//rescale the image to the proper size
bmpBuffer = trImageScale(bmpBuffer, header.biWidth, header.biHeight, SCP_PreviewWidth, SCP_PreviewHeight, TRUE);
header.biWidth = SCP_PreviewWidth; //make it think we're the right size
header.biHeight = SCP_PreviewHeight;
}
scenarioTexture = trRGBTextureCreate(bmpBuffer, header.biWidth, header.biHeight, FALSE);
spTextureWidth = header.biWidth;
spTextureHeight = header.biHeight;
if (spTextureData != NULL)
{
memFree(spTextureData);
}
spTextureData = (ubyte*)memAlloc(4*spTextureWidth*spTextureHeight, "scenpick data", NonVolatile);
memcpy(spTextureData, bmpBuffer, 4*spTextureWidth*spTextureHeight);
memFree(bmpBuffer); //free the image
}
else
{
return;
}
}
else
{
#if SCP_VERBOSE_LEVEL >= 1
dbgMessage("\nNo preview image found!");
#endif
textureRect.x0 = atom->x + SCP_TEXTURE_INSET;
textureRect.y0 = atom->y + SCP_TEXTURE_INSET;
textureRect.x1 = atom->x + atom->width - SCP_TEXTURE_INSET;
textureRect.y1 = atom->y + atom->height - SCP_TEXTURE_INSET;
primRectSolid2(&textureRect, colBlack);
}
if (strlen(descriptionFile) > 0)
{ //if there is a description file
// load in the proper description based on the language
if (strCurLanguage==languageEnglish)
{
scriptSet(NULL, descriptionFile, spDescriptionTweaks);//load in the description text
}
else if (strCurLanguage==languageFrench)
{
scriptSet(NULL, descriptionFile, spDescriptionTweaksFrench);//load in the description text
if (spDescription==NULL)
{
// if french isn't found load in english
scriptSet(NULL, descriptionFile, spDescriptionTweaks);//load in the description text
}
}
else if (strCurLanguage==languageGerman)
{
scriptSet(NULL, descriptionFile, spDescriptionTweaksGerman);//load in the description text
if (spDescription==NULL)
{
// if german isn't found load in english
scriptSet(NULL, descriptionFile, spDescriptionTweaks);//load in the description text
}
}
else if (strCurLanguage==languageSpanish)
{
scriptSet(NULL, descriptionFile, spDescriptionTweaksSpanish);//load in the description text
if (spDescription==NULL)
{
// if german isn't found load in english
scriptSet(NULL, descriptionFile, spDescriptionTweaks);//load in the description text
}
}
else if (strCurLanguage==languageItalian)
{
scriptSet(NULL, descriptionFile, spDescriptionTweaksItalian);//load in the description text
if (spDescription==NULL)
{
// if german isn't found load in english
scriptSet(NULL, descriptionFile, spDescriptionTweaks);//load in the description text
}
}
if (spDescription != NULL)
{ //if there was real text in that file
if (spDescriptionFont == FONT_InvalidFontHandle)
{ //make sure we have a font
spDescriptionFont = frFontRegister("default.hff");
}
textureRect.x0 = atom->x + SCP_TEXTURE_INSET; //and a region to print into
textureRect.y0 = atom->y + SCP_TEXTURE_INSET;
textureRect.x1 = atom->x + atom->width - SCP_TEXTURE_INSET;
textureRect.y1 = atom->y + atom->height - SCP_TEXTURE_INSET;
spDescriptionLines = memAlloc(sizeof(char *) * (textureRect.y1 - textureRect.y0), "DescLines", NonVolatile);//allocate the chopping pointers
chopBuffer = memAlloc(strlen(spDescription) + textureRect.y1 - textureRect.y0, "DescChopped", NonVolatile);//allocate chop buffer
spNDescriptionLines = subStringsChop(&textureRect, spDescriptionFont, strlen(spDescription), spDescription, chopBuffer, spDescriptionLines);
memFree(spDescription); //free unchopped description
spDescription = chopBuffer; //keep pointer to chopped description
}
gameTypeFromDescription = memAlloc(sizeof(GameType), "DescGameType", 0);
memset(gameTypeFromDescription, 0xff, sizeof(GameType)); //flag all members as unused
gameTypeFromDescription->flag = gameTypeFromDescription->flagNeeded = 0; //flag none of the flags needed
scriptSetStruct(NULL, descriptionFile, StaticMGInfoScriptTable, (ubyte *)gameTypeFromDescription);
}
if (strlen(descriptionFile) > 0 || strlen(bitmapFile) > 0)
{ //if there is a description file or a bitmap
if (spPickerStarted)
{
spScenarioBitmap(atom, (regionhandle)atom->region);//draw it/them
}
}
}
