void primRectSolidTexturedFullRectC2(rectangle *rect, color c)
{
glColor4ub(colRed(c), colGreen(c), colBlue(c), colAlpha(c));
rndTextureEnable(TRUE);
glBegin(GL_QUADS);
COORD(0.0f, 0.0f, rect->x0, rect->y0);
COORD(0.0f, 1.0f, rect->x0, rect->y1);
COORD(1.0f, 1.0f, rect->x1, rect->y1);
COORD(1.0f, 0.0f, rect->x1, rect->y0);
glEnd();
rndTextureEnable(FALSE);
}
void hrDrawBackground(void)
{
rndClearToBlack();
if (hrBackgroundTexture)
{
real32 x = -((real32)hrBackXSize / (real32)MAIN_WindowWidth);
real32 y = -((real32)hrBackYSize / (real32)MAIN_WindowHeight);
GLfloat v[8], t[8];
sdword oldTex = rndTextureEnable(TRUE);
udword oldMode = rndTextureEnvironment(RTE_Replace);
bool cull = glIsEnabled(GL_CULL_FACE) ? TRUE : FALSE;
bool blend = glIsEnabled(GL_BLEND) ? TRUE : FALSE;
glDisable(GL_CULL_FACE);
glEnable(GL_BLEND);
trClearCurrent();
glBindTexture(GL_TEXTURE_2D, hrBackgroundTexture);
t[0] = 0.0f; t[1] = 0.0f;
t[2] = hrBackXFrac; t[3] = 0.0f;
t[4] = 0.0f; t[5] = hrBackYFrac;
t[6] = hrBackXFrac; t[7] = hrBackYFrac;
v[0] = primScreenToGLX(hrScaleMissionLoadingScreens ? feResRepositionScaledX(0) : feResRepositionCentredX(0));
v[1] = primScreenToGLY(hrScaleMissionLoadingScreens ? feResRepositionScaledY(0) : feResRepositionCentredY(0));
v[2] = primScreenToGLX(hrScaleMissionLoadingScreens ? feResRepositionScaledX(640) : feResRepositionCentredX(640));
v[3] = primScreenToGLY(hrScaleMissionLoadingScreens ? feResRepositionScaledY(0) : feResRepositionCentredY(0));
v[4] = primScreenToGLX(hrScaleMissionLoadingScreens ? feResRepositionScaledX(0) : feResRepositionCentredX(0));
v[5] = primScreenToGLY(hrScaleMissionLoadingScreens ? feResRepositionScaledY(480) : feResRepositionCentredY(480));
v[6] = primScreenToGLX(hrScaleMissionLoadingScreens ? feResRepositionScaledX(640) : feResRepositionCentredX(640));
v[7] = primScreenToGLY(hrScaleMissionLoadingScreens ? feResRepositionScaledY(480) : feResRepositionCentredY(480));
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, 0, t);
glVertexPointer(2, GL_FLOAT, 0, v);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
rndTextureEnvironment(oldMode);
rndTextureEnable(oldTex);
if (cull) glEnable(GL_CULL_FACE);
if (!blend) glDisable(GL_BLEND);
}
}
void hrRectSolidTextured2(rectangle *rect)
{
glColor3ub(255, 255, 255);
rndTextureEnvironment(RTE_Replace);
rndTextureEnable(TRUE);
glBegin(GL_QUADS);
COORD(0.0f, 0.0f, rect->x0, rect->y0);
COORD(0.0f, 1.0f, rect->x0, rect->y1 - 1);
COORD(1.0f, 1.0f, rect->x1, rect->y1 - 1);
COORD(1.0f, 0.0f, rect->x1, rect->y0);
glEnd();
rndTextureEnable(FALSE);
rndTextureEnvironment(RTE_Modulate);
}
/*-----------------------------------------------------------------------------
Name : primModeClearFunction2
Description : Disables the primitive drawing mode.
Inputs : void
Outputs : sets primModeEnabled FALSE
Return : void
----------------------------------------------------------------------------*/
void primModeClearFunction2(void)
{
glShadeModel(GL_SMOOTH);
glEnable(GL_DEPTH_TEST);
rndLightingEnable(TRUE); //and lighting
rndTextureEnable(TRUE);
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
primModeEnabled = FALSE;
}
void primSolidTexture3Fade(vector *p1, real32 size, color c, trhandle tex, real32 fade)
{
real32 halfsize = size / 2;
real32 biasRed, biasGreen, biasBlue;
texreg* reg;
rndTextureEnable(TRUE);
trMakeCurrent(tex);
reg = trStructureGet(tex);
if (bitTest(reg->flags, TRF_Alpha))
{
glEnable(GL_BLEND);
glDisable(GL_ALPHA_TEST);
rndAdditiveBlends(TRUE);
}
biasRed = colReal32(colRed(c));
biasGreen = colReal32(colGreen(c));
biasBlue = colReal32(colBlue(c));
if (RGL)
{
glPixelTransferf(GL_RED_BIAS, biasRed);
glPixelTransferf(GL_GREEN_BIAS, biasGreen);
glPixelTransferf(GL_BLUE_BIAS, biasBlue);
}
glColor4f(biasRed, biasGreen, biasBlue, fade);
glBegin(GL_QUADS);
glTexCoord2f(0.0f, 0.0f);
glVertex3f(p1->x-halfsize, p1->y-halfsize, 0.0f);
glTexCoord2f(1.0f, 0.0f);
glVertex3f(p1->x+halfsize, p1->y-halfsize, 0.0f);
glTexCoord2f(1.0f, 1.0f);
glVertex3f(p1->x+halfsize, p1->y+halfsize, 0.0f);
glTexCoord2f(0.0f, 1.0f);
glVertex3f(p1->x-halfsize, p1->y+halfsize, 0.0f);
glEnd();
if (RGL)
{
glPixelTransferf(GL_RED_BIAS, 0.0f);
glPixelTransferf(GL_GREEN_BIAS, 0.0f);
glPixelTransferf(GL_BLUE_BIAS, 0.0f);
}
glDisable(GL_BLEND);
rndAdditiveBlends(FALSE);
}
static void primSolidTexture3_multi(vector* p1, real32 size, color c, trhandle tex)
{
real32 halfsize;
texreg* reg;
extern udword gDevcaps;
halfsize = 0.5f * size;
rndTextureEnable(TRUE);
trMakeCurrent(tex);
reg = trStructureGet(tex);
if (bitTest(reg->flags, TRF_Alpha))
{
glEnable(GL_BLEND);
glDisable(GL_ALPHA_TEST);
rndAdditiveBlends(TRUE);
}
glBegin(GL_QUADS);
glColor3ub(colRed(c), colGreen(c), colBlue(c));
glTexCoord2f(0.0f, 0.0f);
glVertex3f(p1->x-halfsize, p1->y-halfsize, 0.0f);
glTexCoord2f(1.0f, 0.0f);
glVertex3f(p1->x+halfsize, p1->y-halfsize, 0.0f);
glTexCoord2f(1.0f, 1.0f);
glVertex3f(p1->x+halfsize, p1->y+halfsize, 0.0f);
glTexCoord2f(0.0f, 1.0f);
glVertex3f(p1->x-halfsize, p1->y+halfsize, 0.0f);
if (!bitTest(gDevcaps, DEVSTAT_NO_GETTEXIMAGE))
{
glColor3ub(172, 172, 172);
glTexCoord2f(0.0f, 0.0f);
glVertex3f(p1->x-halfsize, p1->y-halfsize, 0.0f);
glTexCoord2f(1.0f, 0.0f);
glVertex3f(p1->x+halfsize, p1->y-halfsize, 0.0f);
glTexCoord2f(1.0f, 1.0f);
glVertex3f(p1->x+halfsize, p1->y+halfsize, 0.0f);
glTexCoord2f(0.0f, 1.0f);
glVertex3f(p1->x-halfsize, p1->y+halfsize, 0.0f);
}
glEnd();
glDisable(GL_BLEND);
rndAdditiveBlends(FALSE);
}
void hrRectSolidTextured2(rectangle *rect)
{
GLfloat t[8] = { 0.0f, 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f };
GLfloat v[8] = { primScreenToGLX(rect->x0), primScreenToGLY(rect->y1 - 1),
primScreenToGLX(rect->x1), primScreenToGLY(rect->y1 - 1),
primScreenToGLX(rect->x0), primScreenToGLY(rect->y0),
primScreenToGLX(rect->x1), primScreenToGLY(rect->y0) };
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
rndTextureEnvironment(RTE_Replace);
rndTextureEnable(TRUE);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glVertexPointer(2, GL_FLOAT, 0, v);
glTexCoordPointer(2, GL_FLOAT, 0, t);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
rndTextureEnable(FALSE);
rndTextureEnvironment(RTE_Modulate);
}
/*-----------------------------------------------------------------------------
Name : primModeSetFunction2
Description : Enables the primitive drawing mode.
Inputs : void
Outputs : sets primModeEnabled TRUE
Return : void
----------------------------------------------------------------------------*/
void primModeSetFunction2(void)
{
glShadeModel(GL_FLAT);
glDisable(GL_ALPHA_TEST);
glDisable(GL_BLEND);
glPushMatrix();
glLoadIdentity();
glMatrixMode(GL_PROJECTION);
glPushMatrix(); //perform no transformations on the 2D primitives
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
rndLightingEnable(FALSE); //mouse is self-illuminated
rndTextureEnable(FALSE);
glDisable(GL_DEPTH_TEST);
primModeEnabled = TRUE;
}
//don't mind if this is inefficient as it only
//gets called once per image anyway
void hrDrawFile(char* filename, sdword x, sdword y)
{
udword handle;
rectangle rect;
lifheader* lif = trLIFFileLoad(filename, Pyrophoric);
rndTextureEnable(TRUE);
rndAdditiveBlends(FALSE);
glEnable(GL_BLEND);
glGenTextures(1, &handle);
trClearCurrent();
glBindTexture(GL_TEXTURE_2D, handle);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, lif->width, lif->height,
0, GL_RGBA, GL_UNSIGNED_BYTE, lif->data);
// FIXME: there's no LiF scaling here, just translation of the image
x = hrScaleMissionLoadingScreens
? feResRepositionScaledX(x)
: feResRepositionCentredX(x);
y = hrScaleMissionLoadingScreens
? feResRepositionScaledY(y)
: feResRepositionCentredY(y);
x -= lif->width >> 1;
y -= lif->height >> 1;
rect.x0 = x;
rect.y0 = y;
rect.x1 = x + lif->width;
rect.y1 = y + lif->height;
hrRectSolidTextured2(&rect);
glDeleteTextures(1, &handle);
memFree(lif);
glDisable(GL_BLEND);
}
void hrDrawBackground(void)
{
real32 x, y;
rndClearToBlack();
// Draw the cached background bitmap using glDrawPixels
if (hrBackgroundImage)
{
x = -((real32)hrBackXSize / (real32)MAIN_WindowWidth);
y = -((real32)hrBackYSize / (real32)MAIN_WindowHeight);
rndTextureEnable(FALSE);
rndLightingEnable(FALSE);
glDisable(GL_BLEND);
glDisable(GL_DEPTH_TEST);
glRasterPos2f(x, y);
if (hrDrawPixelsSupported())
{
glDrawPixels(hrBackXSize, hrBackYSize, GL_RGBA, GL_UNSIGNED_BYTE, hrBackgroundImage);
}
}
}
/*-----------------------------------------------------------------------------
Name : primSolidTexture3
Description : Draw a 3D point with size
Inputs : p1 - location of point
size - physical size of point
c - color of point
Outputs :
Return : void
----------------------------------------------------------------------------*/
void primSolidTexture3(vector *p1, real32 size, color c, trhandle tex)
{
real32 halfsize;
real32 biasRed, biasGreen, biasBlue;
texreg* reg;
if (!glCapFeatureExists(RGL_COLOROP_ADD))
{
//multi-pass render to approximate a missing feature
primSolidTexture3_multi(p1, size, c, tex);
return;
}
halfsize = 0.5f * size;
rndTextureEnable(TRUE);
// glDepthMask(GL_FALSE);
trMakeCurrent(tex);
reg = trStructureGet(tex);
if (bitTest(reg->flags, TRF_Alpha))
{
glEnable(GL_BLEND);
glDisable(GL_ALPHA_TEST);
rndAdditiveBlends(TRUE);
}
biasRed = colReal32(colRed(c));
biasGreen = colReal32(colGreen(c));
biasBlue = colReal32(colBlue(c));
if (RGL)
{
glPixelTransferf(GL_RED_BIAS, biasRed);
glPixelTransferf(GL_GREEN_BIAS, biasGreen);
glPixelTransferf(GL_BLUE_BIAS, biasBlue);
}
glColor3f(biasRed, biasGreen, biasBlue);
glBegin(GL_QUADS);
glTexCoord2f(0.0f, 0.0f);
glVertex3f(p1->x-halfsize, p1->y-halfsize, 0.0f);
glTexCoord2f(1.0f, 0.0f);
glVertex3f(p1->x+halfsize, p1->y-halfsize, 0.0f);
glTexCoord2f(1.0f, 1.0f);
glVertex3f(p1->x+halfsize, p1->y+halfsize, 0.0f);
glTexCoord2f(0.0f, 1.0f);
glVertex3f(p1->x-halfsize, p1->y+halfsize, 0.0f);
glEnd();
if (RGL)
{
glPixelTransferf(GL_RED_BIAS, 0.0f);
glPixelTransferf(GL_GREEN_BIAS, 0.0f);
glPixelTransferf(GL_BLUE_BIAS, 0.0f);
}
glDisable(GL_BLEND);
// glDepthMask(GL_TRUE);
rndAdditiveBlends(FALSE);
}
/*-----------------------------------------------------------------------------
Name : RenderNAVLights
Description : TODO: render sorted by projected depth value so alpha sorts correctly
Inputs : ship - the ship whose navlights we are to render
Outputs :
Return :
----------------------------------------------------------------------------*/
void RenderNAVLights(Ship *ship)
{
sdword i;
NAVLight *navLight;
NAVLightInfo *navLightInfo;
ShipStaticInfo *shipStaticInfo;
NAVLightStatic *navLightStatic;
vector origin = {0.0f, 0.0f, 0.0f};
NAVLightStaticInfo *navLightStaticInfo;
real32 fade;
bool lightOn;
extern bool bFade;
extern real32 meshFadeAlpha;
fade = bFade ? meshFadeAlpha : 1.0f;
shipStaticInfo = (ShipStaticInfo *)ship->staticinfo;
navLightInfo = ship->navLightInfo;
if(shipStaticInfo->navlightStaticInfo && navLightInfo != NULL)
{
glDepthMask(GL_FALSE);
rndAdditiveBlends(TRUE);
lightOn = rndLightingEnable(FALSE);
navLightStaticInfo = shipStaticInfo->navlightStaticInfo;
navLightStatic = navLightStaticInfo->navlightstatics;
navLight = navLightInfo->navLights;
for( i=0 ; i<navLightStaticInfo->numNAVLights ; i++, navLight ++, navLightStatic ++)
{
// Account for the startdelay.
if(navLight->lastTimeFlashed == navLightStatic->startdelay)
{
navLight->lastTimeFlashed = universe.totaltimeelapsed + navLightStatic->startdelay;
}
if(universe.totaltimeelapsed > navLight->lastTimeFlashed)
{
if(navLight->lightstate == 1)
{
navLight->lastTimeFlashed = universe.totaltimeelapsed + navLightStatic->flashrateoff;
}
else
{
navLight->lastTimeFlashed = universe.totaltimeelapsed + navLightStatic->flashrateon;
}
navLight->lightstate = 1 - navLight->lightstate;
}
if(navLight->lightstate)
{
if (ship->currentLOD <= (sdword)navLightStatic->minLOD)
{
navLightBillboardEnable(ship, navLightStatic);
if(navLightStatic->texturehandle == TR_InvalidHandle)
{
primCircleSolid3Fade(&origin, navLightStatic->size, 10, navLightStatic->color, fade);
}
else
{
primSolidTexture3Fade(&origin, navLightStatic->size, navLightStatic->color, navLightStatic->texturehandle, fade);
}
navLightBillboardDisable();
}
else
{
color tempColor;
tempColor = colRGB(colRed(navLightStatic->color) * 2 / 3,
colGreen(navLightStatic->color) * 2 / 3,
colBlue(navLightStatic->color) * 2 / 3);
rndTextureEnable(FALSE);
if (RGL)
{
if (glCapFastFeature(GL_BLEND))
{
rndAdditiveBlends(TRUE);
primPointSize3(&navLightStatic->position, 2.0f, tempColor);
}
else
{
primPointSize3(&navLightStatic->position, 1.0f, tempColor);
}
}
else
{
rndAdditiveBlends(TRUE);
glEnable(GL_POINT_SMOOTH);
primPointSize3Fade(&navLightStatic->position, 2.0f, tempColor, fade);
glDisable(GL_POINT_SMOOTH);
}
}
}
}
rndLightingEnable(lightOn);
rndAdditiveBlends(FALSE);
glDepthMask(GL_TRUE);
}
}
