#include <cstddef>
#include <vector>
#include "gfx/vec.h"
#include "gfxlib_struct.h"

Macros
#define	GFXDRVAPI

Enumerations
enum	GFXTEXTUREWRAPMODES { GFXREPEATTEXTURE, GFXCLAMPTEXTURE, GFXBORDERTEXTURE }

enum	GFXTEXTUREENVMODES { GFXREPLACETEXTURE, GFXADDTEXTURE, GFXMODULATETEXTURE, GFXADDSIGNEDTEXTURE, GFXCOMPOSITETEXTURE, GFXINTERPOLATETEXTURE, GFXDETAILTEXTURE }

enum	GFXTEXTURECOORDMODE { NO_GEN, EYE_LINEAR_GEN, OBJECT_LINEAR_GEN, SPHERE_MAP_GEN, CUBE_MAP_GEN }

Functions
void	GFXInit (int, char **)
	Loads Glut and graphics drivers. More...

void	GFXLoop (void main_loop())
	loops on the function over and over More...

void	GFXShutdown ()
	Shuts down the graphics subsystem. More...

void	GFXBeginScene ()
	resets all local lights and sets identity matrix More...

void	GFXEndScene ()
	Flushes and Swaps buffers. More...

void	GFXClear (const GFXBOOL colorbuffer, const GFXBOOL depthbuffer=GFXTRUE, const GFXBOOL stencilbuffer=GFXTRUE)
	Clears the Z buffer. Also clears color buffer if GFXTRUE passed in. More...

void	GFXCreateLightContext (int &con_number)
	creates a light context (relevant to a star system) to add lights to More...

void	GFXDeleteLightContext (const int con_number)
	Deletes a light context (hence a star system) More...

void	GFXSetLightContext (const int con_number)
	Sets active light context (restores all gllights in such context) More...

GFXBOOL	GFXLightContextAmbient (const GFXColor &amb)
	Sets the ambient light value. More...

GFXBOOL	GFXGetLightContextAmbient (GFXColor &amb)
	Gets the ambient light value. More...

void	GFXPickLights (const Vector &center, const float radius)
	picks and activates local lights near to "center" More...

void	GFXPickLights (const Vector &center, const float radius, vector< int > &lights, const int maxlights, const bool pickglobals)
	picks and does not activate local lights near to "center" More...

void	GFXPickLights (vector< int >::const_iterator begin, vector< int >::const_iterator end)
	activates local lights picked by GFXPickLight More...

GFXBOOL	GFXSetSeparateSpecularColor (const GFXBOOL spec)
	Sets the light model to have separate specular color (if available) More...

GFXBOOL	GFXSetCutoff (const float cutoff)
	Sets the intensity cutoff before picked lights are ignored. More...

void	GFXSetOptimalIntensity (const float newint, const float saturatevalue)
	Sets the optimal intensity given that Optimal number of lights is fulfilled. More...

GFXBOOL	GFXSetOptimalNumLights (const int numlights)
	Sets number of lights graphics can handle optimally. More...

GFXBOOL	GFXCreateLight (int &light, const GFXLight &, const bool global)

void	GFXDeleteLight (const int light)
	Deletes a light, removing it from the light table if necessary. More...

GFXBOOL	GFXEnableLight (const int light)
	activates a light if not already activated More...

GFXBOOL	GFXDisableLight (const int light)
	Deactivates an active light. More...

GFXBOOL	GFXSetLight (const int light, const enum LIGHT_TARGET, const GFXColor &color)
	Modifies the parameters of the given light. More...

void	GFXPushGlobalEffects ()

GFXBOOL	GFXPopGlobalEffects ()
	This function undoes the above function to restore the global lights after specialFX phase. More...

void	GFXSetMaterial (unsigned int &number, const GFXMaterial &material)
	Creates a new material given a material struct. Will search through already made materials for matching materials to minimize switching. More...

void	GFXModifyMaterial (const unsigned int number, const GFXMaterial &material)
	Modifies the given material to be like the passed in structure. More...

GFXBOOL	GFXGetMaterial (const unsigned int number, GFXMaterial &material)
	Gets the statistics of the material stored in number. More...

const GFXMaterial &	GFXGetMaterial (const unsigned int number)

void	GFXSelectMaterialHighlights (const unsigned int number, const GFXColor &ambient, const GFXColor &diffuse, const GFXColor &specular, const GFXColor &emmissive)
	Tells Graphics library which material to use on next polygon if lighting enabled. More...

void	GFXSelectMaterial (const unsigned int number)

void	GFXHudMode (const bool Enter)

void	GFXRestoreHudMode ()

void	GFXCenterCamera (const bool Enter)

void	GFXTranslateView (const QVector &r)

void	GFXLoadMatrixView (const Matrix &matrix)

void	GFXGetMatrixView (Matrix &m)

void	GFXTranslateProjection (const Vector &r)
	Translates the current "mode" matrix by a given vector. More...

void	GFXTranslateModel (const QVector &r)

void	GFXMultMatrixModel (const Matrix &matrix)
	Multipliex the current "mode" matrix by a given matrix. More...

void	GFXLoadMatrixModel (const Matrix &matrix)
	loads a given matrix to the current "mode" More...

void	GFXLoadMatrixProjection (const float matrix[16])

void	GFXLoadIdentity (const MATRIXMODE mode)
	Loads the identity matrix for the given mode. More...

void	GFXGetMatrixModel (Matrix &matrix)
	retrieves the matrix for a given mode. More...

float	GFXGetZPerspective (const float z)
	Given the current projection matrix, how much will the model be divided by. More...

float	GFXGetXInvPerspective ()
	Screen to eye. More...

float	GFXGetYInvPerspective ()

void	GFXPerspective (float fov, float aspect, float znear, float zfar, float cockpit_offset)
	Sets the Projection matrix to have fov and aspect as follows (fov is field of view in radians, aspect is width/height znear and zfar are clip planes. More...

void	GFXParallel (float left, float right, float bottom, float top, float znear, float zfar)
	Sets the Projection matrix to a parallel view with given paramters. More...

void	GFXViewPort (int minx, int miny, int maxx, int maxy)
	Sets the final translation to screen coordinates, Also adjusts range of clearing. More...

void	GFXLookAt (Vector eye, QVector center, Vector up)
	Sets the VIEW matrix to look from center in direction of eye with up vector up. More...

void	GFXGetFrustum (double f[6][4])
	Gets the 6 clip planes of the current Projection matrix. More...

void	GFXCalculateFrustum ()
	Calculates frustum matrix (internal use) More...

void	GFXCalculateFrustum (double frustum[6][4], const Matrix &modlmatrix, const float *projection)
	Calculates the planes for a given frustum in 3space given a matrix and a projection. More...

void	GFXGetFrustumVars (bool, float l, float r, float b, float t, float n, float f)
	Saves and restores last used left,right,bot,top,near,far vals (internal use) More...

float	GFXSphereInFrustum (const QVector &Center, float Radius)
	checks if a sphere is in the currently loaded Frustum given its center and radius More...

float	GFXSphereInFrustum (double f[6][4], const QVector &Center, float Radius)
	Checks if a sphere is in the given frustum calculated by GFXCalculateFrustum. Used in Unit clipping. More...

void	GFXBoxInFrustumModel (const Matrix &model)

CLIPSTATE	GFXBoxInFrustum (const Vector &min, const Vector &max)

CLIPSTATE	GFXBoxInFrustum (double f[6][4], const Vector &min, const Vector &max)

CLIPSTATE	GFXTransformedBoxInFrustum (const Vector &min, const Vector &max)

CLIPSTATE	GFXSpherePartiallyInFrustum (const Vector &cent, const float r)

CLIPSTATE	GFXTransformedSpherePartiallyInFrustum (const Vector &cent, const float r)

CLIPSTATE	GFXSpherePartiallyInFrustum (double f[6][4], const Vector &cent, const float r)

void	GFXFrustum (float mat, float inv, float left, float right, float bottom, float top, float nearval, float farval)
	Given matrices, calculates the matrix and inverse matrix of a projection matrix to go from screen to 3-space coordinates. More...

GFXBOOL	GFXCreateTexture (int width, int height, TEXTUREFORMAT externaltextureformat, int handle, char palette=0, int texturestage=0, enum FILTER mipmap=MIPMAP, enum TEXTURE_TARGET texture_target=TEXTURE2D, enum ADDRESSMODE address_mode=DEFAULT_ADDRESS_MODE)

void	GFXPrioritizeTexture (unsigned int handle, float priority)
	Sets the priority of the texture for memory management. More...

void	GFXAttachPalette (unsigned char *palette, int handle)
	Attaches a given palette to the current texture. More...

GFXBOOL	GFXTransferTexture (unsigned char *buffer, int handle, int inWidth, int inHeight, enum TEXTUREFORMAT internalformat, enum TEXTURE_IMAGE_TARGET image2D=TEXTURE_2D, int max_texture_dimension=65536, GFXBOOL detailtexture=GFXFALSE, unsigned int pageIndex=0)

GFXBOOL	GFXTransferSubTexture (unsigned char *buffer, int handle, int x, int y, unsigned int width, unsigned int height, enum TEXTURE_IMAGE_TARGET image2D=TEXTURE_2D)

void	GFXDeleteTexture (int handle)
	Deletes the texture from the graphics card. More...

void	GFXDestroyAllTextures ()
	Cleans up all textures. More...

void	GFXSelectTexture (int handle, int stage=0)
	Selects the current texture as being "active" so further drawn objects will have it. More...

GFXBOOL	GFXCapture (char *filename)
	Screen capture (FIXME) More...

void	GFXEnable (const enum STATE)
	Enables and disables given state. More...

void	GFXDisable (const enum STATE)

void	GFXToggleTexture (bool enable, int whichstage, enum TEXTURE_TARGET target=TEXTURE2D)

void	GFXTextureAddressMode (const ADDRESSMODE mode, enum TEXTURE_TARGET target=TEXTURE2D)
	Sets texture to clamp or wrap texture coordinates. More...

void	GFXBlendMode (const enum BLENDFUNC src, const enum BLENDFUNC dst)
	Sets the current blend mode to src,dst. More...

void	GFXGetBlendMode (enum BLENDFUNC &src, enum BLENDFUNC &dst)
	Gets the current blend mode to src,dst. More...

void	GFXColorMaterial (int LIGHTTARG)

void	GFXPointSize (const float size)
	Sets the size in pixels of a GFXPOINT. More...

void	GFXLineWidth (const float size)
	Sets the line width in pixels of a GFXLINE. More...

void	GFXPushBlendMode ()
	Pushes and saves current blend mode. More...

void	GFXPopBlendMode ()
	Restores previous blend mode. More...

void	GFXActiveTexture (const int stage)
	Sets the active texture stage in multitexture. More...

enum DEPTHFUNC	GFXDepthFunc ()
	Returns the current depth function. More...

void	GFXDepthFunc (const enum DEPTHFUNC)
	Sets up depth compare function. More...

enum DEPTHFUNC	GFXStencilFunc ()
	Returns the current stencil test function. More...

void	GFXStencilFunc (enum DEPTHFUNC pFunc, int pRef, int *pMask)
	Gets details about the current stancil compare function - Specify NULL for unwanted fields. More...

void	GFXStencilFunc (enum DEPTHFUNC sfunc, int ref, unsigned int mask)
	Sets up a stencil compare function. More...

void	GFXStencilOp (enum STENCILOP pFail, enum STENCILOP pZfail, enum STENCILOP *pZpass)
	Gets the current stencil write operations - Specify NULL for unwanted fields. More...

void	GFXStencilOp (enum STENCILOP fail, enum STENCILOP zfail, enum STENCILOP zpass)
	Sets up the stencil write operations. More...

unsigned int	GFXStencilMask ()
	Returns the current stencil write mask. More...

void	GFXStencilMask (unsigned int mask)
	Sets the stencil write mask. More...

void	GFXAlphaTest (const enum DEPTHFUNC, const float ref)
	Turns on alpha testing mode (or turns if off if DEPTHFUNC is set to ALWAYS. More...

void	GFXTextureWrap (int stage, GFXTEXTUREWRAPMODES mode, enum TEXTURE_TARGET target=TEXTURE2D)

void	GFXTextureEnv (int stage, GFXTEXTUREENVMODES mode, float arg2=0)

bool	GFXMultiTexAvailable ()

void	GFXPolygonOffset (float factor, float units)
	Sets Depth Offset for polgyons. More...

void	GFXGetPolygonOffset (float factor, float units)

void	GFXPolygonMode (const enum POLYMODE)
	Sets the polygon rasterization mode. More...

void	GFXCullFace (const enum POLYFACE)
	Sets the facecull mode. More...

void	GFXBegin (const enum POLYTYPE)
	Begins a polytype. More...

void	GFXColorf (const GFXColor &col)
	Specifies a color for henceforth drawn vertices to share. More...

void	GFXBlendColor (const GFXColor &col)
	specifies the current blend color More...

void	GFXColor4f (const float r, const float g, const float b, const float a=1.0)
	Specifies a color for henceforth drawn vertices to share. More...

GFXColor	GFXColorf ()
	Gets the current color. More...

void	GFXTexCoord2f (const float s, const float t)
	Specifies a pair of texture coordinates for given vertex. More...

void	GFXTexCoord4f (const float s, const float t, const float u, const float v)
	Specifies four texture coordinates for a given vertex (2 textures) More...

void	GFXTexCoord224f (const float s, const float t, const float s2, const float t2, const float s3, const float t3, const float u3, const float v3)
	Specifies four texture coordinates for a given vertex (3 textures) More...

void	GFXNormal3f (const float i, const float j, const float k)
	Specifies a normal with 3 floats. More...

void	GFXNormal (const Vector &n)
	Specifies a notmal with 1 vector. More...

void	GFXVertex3f (const float x, const float y, const float z=1.0)
	Specifies a vertex with 3 floats. More...

void	GFXVertex3f (const double x, const double y, const double z=1.0)

void	GFXVertex3d (const double x, const double y, const double z=1.0)

void	GFXVertexf (const Vector &v)
	Specifies a vertex with a vector. More...

void	GFXVertexf (const QVector &v)

void	GFXEnd ()
	Ends the current set of polytypes. More...

void	GFXCircle (float x, float y, float r1, float r2)

void	GFXOptimizeList (GFXVertex old, int numV, GFXVertex newlist, int numnewVertices, unsigned int **indices)
	Optimizes a list to reuse repeated vertices! More...

void	GFXFogMode (const FOGMODE fog)

void	GFXFogDensity (const float fogdensity)

void	GFXFogLimits (const float fognear, const float fogfar)

void	GFXFogColor (GFXColor c)

void	GFXFogIndex (const int index)

void	GFXCallList (int list)
	Draws a given display list. More...

void	GFXBeginPick (int x, int y, int xsize, int ysize)

void	GFXSetPickName (int name)

vector< PickData > *	GFXEndPick ()

void	GFXSubwindow (int x, int y, int xsize, int ysize)
	Creates a subwindow with the current parameters for center and size. More...

void	GFXSubwindow (float x, float y, float xsize, float ysize)

Vector	GFXDeviceToEye (int x, int y)
	convertes eyespace to 3space at the near plane More...

void	GFXTextureCoordGenMode (int stage, GFXTEXTURECOORDMODE tex, const float params[4], const float paramt[4])

int	GFXCreateProgram (const char vertex, const char fragment, const char *extra_defines)

void	GFXDestroyProgram (int program)

int	GFXActivateShader (const char *program=NULL)

int	GFXActivateShader (int program)

void	GFXDeactivateShader ()

int	GFXNamedShaderConstant (char progID, const char name)

int	GFXNamedShaderConstant (int progID, const char *name)

int	GFXShaderConstant (int name, Vector value)

int	GFXShaderConstant (int name, GFXColor value)

int	GFXShaderConstant (int name, const float *value)

int	GFXShaderConstanti (int name, int value)

int	GFXShaderConstant (int name, float v1, float v2, float v3, float v4)

int	GFXShaderConstant (int name, float v1)

int	GFXShaderConstant4v (int name, unsigned int numvals, const float *value)

int	GFXShaderConstantv (int name, unsigned int numvals, const float *value)

int	GFXShaderConstantv (int name, unsigned int numvals, const int *value)

bool	GFXDefaultShaderSupported ()

void	GFXReloadDefaultShader ()

void	GFXUploadLightState (int max_light_location, int active_light_array, int apparent_light_size_array, bool shader, vector< int >::const_iterator begin, vector< int >::const_iterator end)

bool	GFXShaderReloaded ()

int	GFXGetProgramVersion ()

Macro Definition Documentation

#define GFXDRVAPI

Definition at line 31 of file gfxlib.h.

Enumeration Type Documentation

enum GFXTEXTURECOORDMODE

Enumerator
NO_GEN
EYE_LINEAR_GEN
OBJECT_LINEAR_GEN
SPHERE_MAP_GEN
CUBE_MAP_GEN

Definition at line 444 of file gfxlib.h.

 {
     NO_GEN,
     EYE_LINEAR_GEN,
     OBJECT_LINEAR_GEN,
     SPHERE_MAP_GEN,
     CUBE_MAP_GEN
 };

enum GFXTEXTUREENVMODES

Enumerator
GFXREPLACETEXTURE
GFXADDTEXTURE
GFXMODULATETEXTURE
GFXADDSIGNEDTEXTURE
GFXCOMPOSITETEXTURE
GFXINTERPOLATETEXTURE
GFXDETAILTEXTURE

Definition at line 356 of file gfxlib.h.

 {
     GFXREPLACETEXTURE,
     GFXADDTEXTURE,
     GFXMODULATETEXTURE,
     GFXADDSIGNEDTEXTURE,
     GFXCOMPOSITETEXTURE,
     GFXINTERPOLATETEXTURE,
     GFXDETAILTEXTURE
 };

enum GFXTEXTUREWRAPMODES

Enumerator
GFXREPEATTEXTURE
GFXCLAMPTEXTURE
GFXBORDERTEXTURE

Definition at line 350 of file gfxlib.h.

 {
     GFXREPEATTEXTURE,
     GFXCLAMPTEXTURE,     //clamp to edge, not to border
     GFXBORDERTEXTURE     //clamp to border, not to edge
 };

Function Documentation

int GFXActivateShader ( const char * program = NULL)

Definition at line 519 of file gl_program.cpp.

References getDefaultProgram(), GFXActivateShader(), and GFXCreateProgram().

Referenced by GFXActivateShader(), GFXDeactivateShader(), and GFXShaderReloaded().

 {
     int defaultprogram = getDefaultProgram();
     int curprogram     = defaultprogram;
     if (program)
         curprogram = GFXCreateProgram( program, program, NULL );
     return GFXActivateShader( curprogram );
 }

int GFXActivateShader ( int program)

Definition at line 504 of file gl_program.cpp.

References glUseProgram_p, and programChanged.

 {
     static int lastprogram = 0;
     if (program != lastprogram)
         programChanged = true;
     if (program != lastprogram
 #ifndef __APPLE__
         && glUseProgram_p
 #endif
        ) {
         glUseProgram_p( program );
         lastprogram = program;
     } else {return 0; } return program;
 }

void GFXActiveTexture ( const int stage)

Sets the active texture stage in multitexture.

Definition at line 594 of file gl_state.cpp.

References activeTextureStage, gl_options, glActiveTextureARB_p, and gl_options_t::Multitexture.

Referenced by GameStarSystem::activateLightMap(), Background::Draw(), GFXCreateTexture(), GFXDisable(), GFXEnable(), GFXInit(), GFXSelectTexture(), GFXTextureCoordGenMode(), GFXTextureEnv(), GFXTextureWrap(), GFXToggleTexture(), LookAtHelper(), Texture::MakeActive(), RestoreSpecMapState(), and SetupSpecMapSecondPass().

 {
 #if !defined (IRIX)
     if (gl_options.Multitexture && stage != activeTextureStage && glActiveTextureARB_p) {
         glActiveTextureARB_p( GL_TEXTURE0_ARB+stage );
         activeTextureStage = stage;
     } else {
         activeTextureStage = stage;         //This ensures consistent behavior - they shouldn't even call us
     }
 #endif
 }

void GFXAlphaTest	(	const enum	DEPTHFUNC,
		const float	ref
	)

Turns on alpha testing mode (or turns if off if DEPTHFUNC is set to ALWAYS.

Definition at line 606 of file gl_state.cpp.

References ALWAYS, EQUAL, GEQUAL, GREATER, LEQUAL, LESS, NEQUAL, and NEVER.

Referenced by Bolt::Draw(), Stars::Draw(), GameCockpit::Draw(), BaseInterface::Room::BaseVSSprite::Draw(), DrawHUDSprite(), and setupGLState().

 {
     if (df == ALWAYS) {
         glDisable( GL_ALPHA_TEST );
         return;
     } else {
         glEnable( GL_ALPHA_TEST );
     }
     GLenum tmp;
     switch (df)
     {
     case NEVER:
         tmp = GL_NEVER;
         break;
     case LESS:
         tmp = GL_LESS;
         break;
     case EQUAL:
         tmp = GL_EQUAL;
         break;
     case LEQUAL:
         tmp = GL_LEQUAL;
         break;
     case GREATER:
         tmp = GL_GREATER;
         break;
     case NEQUAL:
         tmp = GL_NOTEQUAL;
         break;
     case GEQUAL:
         tmp = GL_GEQUAL;
         break;
     default:
     case ALWAYS:
         tmp = GL_ALWAYS;
         break;
     }
     glAlphaFunc( tmp, ref );
 }

void GFXAttachPalette	(	unsigned char *	palette,
		int	handle
	)

Attaches a given palette to the current texture.

Definition at line 410 of file gl_texture.cpp.

References ConvertPalette(), and textures.

 {
     ConvertPalette( textures[handle].palette, palette );
     //memcpy (textures[handle].palette,palette,768);
 }

void GFXBegin ( const enum POLYTYPE)

Begins a polytype.

Definition at line 152 of file gl_misc.cpp.

References GFXLINE, GFXLINESTRIP, GFXPOINT, GFXPOLY, GFXQUAD, GFXQUADSTRIP, GFXTRI, GFXTRIFAN, and GFXTRISTRIP.

 {
     GLenum mode;
     switch (ptype)
     {
     case GFXTRI:
         mode = GL_TRIANGLES;
         break;
     case GFXLINE:
         mode = GL_LINES;
         break;
     case GFXTRISTRIP:
         mode = GL_TRIANGLE_STRIP;
         break;
     case GFXTRIFAN:
         mode = GL_TRIANGLE_FAN;
         break;
     case GFXQUAD:
         mode = GL_QUADS;
         break;
     case GFXQUADSTRIP:
         mode = GL_QUAD_STRIP;
         break;
     case GFXLINESTRIP:
         mode = GL_LINE_STRIP;
         break;
     case GFXPOLY:
         mode = GL_POLYGON;
         break;
     case GFXPOINT:
         mode = GL_POINTS;
         break;
     default:
         mode = GL_POINTS;
         assert( 0 ||! "Bad case in gl_misc.cpp." );
         break;
     }
     glBegin( mode );
 }

void GFXBeginPick	(	int	x,
		int	y,
		int	xsize,
		int	ysize
	)

Definition at line 18 of file gl_pick.cpp.

References GFXGetFrustumVars(), picked_objects, GFXMatrices::projection, selectbuf, and SELECTBUF_SIZE.

 {
     //save and change gl projection matrix
     GLint viewport[4];
 
     float left, right, bottom, top, fnear, ffar;
     GFXGetFrustumVars( true, &left, &right, &bottom, &top, &fnear, &ffar );
 
     glMatrixMode( GL_PROJECTION );
     glPushMatrix();
     glLoadIdentity();
     glGetIntegerv( GL_VIEWPORT, viewport );
     gluPickMatrix( x, viewport[3]-y, xsize, ysize, viewport );
     glMultMatrixf( projection );
 
     glSelectBuffer( SELECTBUF_SIZE, selectbuf );
     glRenderMode( GL_SELECT );
     glGetError();
 
     delete picked_objects;
     picked_objects = new vector< PickData > ();
 }

void GFXBeginScene ( )

resets all local lights and sets identity matrix

Definition at line 54 of file gl_misc.cpp.

References GFXLoadIdentity(), light_rekey_frame(), and MODEL.

Referenced by base_main_loop(), bootstrap_draw(), gamemenu_draw(), nav_main_loop(), GameUniverse::StartDraw(), and GameUniverse::StartGFX().

 {
     GFXLoadIdentity( MODEL );     //bad this should instead load the cached view matrix
     light_rekey_frame();
 }

void GFXBlendColor ( const GFXColor & col)

specifies the current blend color

void GFXBlendMode	(	const enum BLENDFUNC	src,
		const enum BLENDFUNC	dst
	)

Sets the current blend mode to src,dst.

Definition at line 342 of file gl_state.cpp.

References blendToGL(), currBlendMode, BlendMode::dfactor, and BlendMode::sfactor.

 {
     GLenum sfactor = blendToGL(src);
     GLenum dfactor = blendToGL(dst);
     glBlendFunc( sfactor, dfactor );
     currBlendMode.sfactor = src;
     currBlendMode.dfactor = dst;
 }

CLIPSTATE GFXBoxInFrustum	(	const Vector &	min,
		const Vector &	max
	)

Definition at line 14 of file gl_clip.cpp.

References BoxFrust, and GFXBoxInFrustum().

Referenced by IdentityTransform::BoxInFrustum(), GFXBoxInFrustum(), and GFXTransformedBoxInFrustum().

 {
     return GFXBoxInFrustum( BoxFrust, min, max );
 }

CLIPSTATE GFXBoxInFrustum	(	double	f[6][4],
		const Vector &	min,
		const Vector &	max
	)

Definition at line 48 of file gl_clip.cpp.

References GFX_NOT_VISIBLE, GFX_PARTIALLY_VISIBLE, GFX_TOTALLY_VISIBLE, i, j, v, and Vector.

 {
     //Doesn't do a perfect test for NOT_VISIBLE.  Just checks to
     //see if all box vertices are outside at least one frustum
     //plane.  Some pathological boxes could return SOME_CLIP even
     //though they're really fully outside the frustum.  But that
     //won't hurt us too much if it isn't a common case; the
     //contents will just be culled/clipped at a later stage in the
     //pipeline.
 
     //Check each vertex of the box against the view frustum, and compute
     //bit codes for whether the point is outside each plane.
     int OrCodes = 0, AndCodes = ~0;
     for (int i = 0; i < 8; i++) {
         Vector v( min.i, min.j, min.k );
         if (i&1) v.i = (max.i);
         if (i&2) v.j = (max.j);
         if (i&4) v.k = (max.k);
         //Now check against the frustum planes.
         int Code = 0;
         int Bit  = 1;
         for (int j = 0; j < 6; j++, Bit <<= 1)
             if (v.i*f[j][0]+v.j*f[j][1]+v.k*f[j][2]+f[j][3] < 0)
                 //The point is outside this plane.
                 Code |= Bit;
         OrCodes  |= Code;
         AndCodes &= Code;
     }
     //Based on bit-codes, return culling results.
     if (OrCodes == 0)
         //The box is completely within the frustum.
         return GFX_TOTALLY_VISIBLE;
     else if (AndCodes != 0)
         //All the points are outside one of the frustum planes.
         return GFX_NOT_VISIBLE;
     else
         return GFX_PARTIALLY_VISIBLE;
 }

void GFXBoxInFrustumModel ( const Matrix & model)

Definition at line 187 of file gl_clip.cpp.

References BoxFrust, GFXCalculateFrustum(), MultMatrix(), GFXMatrices::projection, and GFXMatrices::view.

Referenced by QuadTree::Render().

 {
     Matrix tmp;
     MultMatrix( tmp, view, model );
     GFXCalculateFrustum( BoxFrust, tmp, projection );
 }

void GFXCalculateFrustum ( )

Calculates frustum matrix (internal use)

Definition at line 193 of file gl_clip.cpp.

References frust, GFXCalculateFrustum(), GFXMatrices::projection, and GFXMatrices::view.

Referenced by GFXBoxInFrustumModel(), GFXCalculateFrustum(), ClickList::requestIterator(), and Camera::UpdateGFX().

 {
     GFXCalculateFrustum( frust, view, projection );
 }

void GFXCalculateFrustum	(	double	frustum[6][4],
		const Matrix &	modlmatrix,
		const float *	projection
	)

Calculates the planes for a given frustum in 3space given a matrix and a projection.

Definition at line 223 of file gl_clip.cpp.

References UniverseUtil::sqrt(), and WackyMultFloatMatrix().

 {
     double clip[16];
     WackyMultFloatMatrix( clip, proj, modl );
     double t;
     /* Extract the numbers for the RIGHT plane */
     frustum[0][0] = clip[3]-clip[0];
     frustum[0][1] = clip[7]-clip[4];
     frustum[0][2] = clip[11]-clip[8];
     frustum[0][3] = clip[15]-clip[12];
 
     /* Normalize the result */
     t = sqrt( frustum[0][0]*frustum[0][0]+frustum[0][1]*frustum[0][1]+frustum[0][2]*frustum[0][2] );
     frustum[0][0] /= t;
     frustum[0][1] /= t;
     frustum[0][2] /= t;
     frustum[0][3] /= t;
 
     /* Extract the numbers for the LEFT plane */
     frustum[1][0]  = clip[3]+clip[0];
     frustum[1][1]  = clip[7]+clip[4];
     frustum[1][2]  = clip[11]+clip[8];
     frustum[1][3]  = clip[15]+clip[12];
 
     /* Normalize the result */
     t = sqrt( frustum[1][0]*frustum[1][0]+frustum[1][1]*frustum[1][1]+frustum[1][2]*frustum[1][2] );
     frustum[1][0] /= t;
     frustum[1][1] /= t;
     frustum[1][2] /= t;
     frustum[1][3] /= t;
 
     /* Extract the BOTTOM plane */
     frustum[2][0]  = clip[3]+clip[1];
     frustum[2][1]  = clip[7]+clip[5];
     frustum[2][2]  = clip[11]+clip[9];
     frustum[2][3]  = clip[15]+clip[13];
 
     /* Normalize the result */
     t = sqrt( frustum[2][0]*frustum[2][0]+frustum[2][1]*frustum[2][1]+frustum[2][2]*frustum[2][2] );
     frustum[2][0] /= t;
     frustum[2][1] /= t;
     frustum[2][2] /= t;
     frustum[2][3] /= t;
 
     /* Extract the TOP plane */
     frustum[3][0]  = clip[3]-clip[1];
     frustum[3][1]  = clip[7]-clip[5];
     frustum[3][2]  = clip[11]-clip[9];
     frustum[3][3]  = clip[15]-clip[13];
 
     /* Normalize the result */
     t = sqrt( frustum[3][0]*frustum[3][0]+frustum[3][1]*frustum[3][1]+frustum[3][2]*frustum[3][2] );
     frustum[3][0] /= t;
     frustum[3][1] /= t;
     frustum[3][2] /= t;
     frustum[3][3] /= t;
 
     /* Extract the FAR plane */
     frustum[5][0]  = clip[3]-clip[2];
     frustum[5][1]  = clip[7]-clip[6];
     frustum[5][2]  = clip[11]-clip[10];
     frustum[5][3]  = clip[15]-clip[14];
 
     /* Normalize the result */
     t = sqrt( frustum[5][0]*frustum[5][0]+frustum[5][1]*frustum[5][1]+frustum[5][2]*frustum[5][2] );
     frustum[5][0] /= t;
     frustum[5][1] /= t;
     frustum[5][2] /= t;
     frustum[5][3] /= t;
 
     /* Extract the NEAR plane */
     frustum[4][0]  = clip[3]+clip[2];
     frustum[4][1]  = clip[7]+clip[6];
     frustum[4][2]  = clip[11]+clip[10];
     frustum[4][3]  = clip[15]+clip[14];
 
     /* Normalize the result */
     t = sqrt( frustum[4][0]*frustum[4][0]+frustum[4][1]*frustum[4][1]+frustum[4][2]*frustum[4][2] );
     frustum[4][0] /= t;
     frustum[4][1] /= t;
     frustum[4][2] /= t;
     frustum[4][3] /= t;
 }

void GFXCallList ( int list)

Draws a given display list.

Definition at line 312 of file gl_misc.cpp.

Referenced by GFXVertexList::Draw().

 {
 //VSFileSystem::Fprintf (stderr,"CallListStart");///causes crash with GF2 privaledge instruction on Win2k in certain instances
 //fflush (stderr);
     glCallList( list );
 //VSFileSystem::Fprintf (stderr,"CallListEnd");
 //fflush (stderr);
 }

GFXBOOL GFXCapture ( char * filename)

Screen capture (FIXME)

Definition at line 73 of file gl_misc.cpp.

References GFXFALSE.

 {
     return GFXFALSE;
 }

void GFXCenterCamera ( const bool Enter)

Definition at line 224 of file gl_matrix.cpp.

References GFXLoadIdentity(), MODEL, Matrix::p, QVector, and GFXMatrices::view.

Referenced by Background::Draw(), and Mesh::DrawNow().

 {
     static QVector tmp;
     if (Enter) {
         tmp = view.p;
         view.p.Set( 0, 0, 0 );
         glMatrixMode( GL_MODELVIEW );
         glLoadIdentity();
     } else {
         view.p = tmp;
         GFXLoadIdentity( MODEL );
     }
 }

void GFXCircle	(	float	x,
		float	y,
		float	r1,
		float	r2
	)

Definition at line 37 of file gl_misc.cpp.

References UniverseUtil::cos(), f, g_game, VegaConfig::getVariable(), GFXBegin(), GFXEnd(), GFXLINESTRIP, GFXVertex3f(), i, int, M_PI, Magnitude(), XMLSupport::parse_float(), UniverseUtil::sin(), Vector, vs_config, game_data_t::x_resolution, and game_data_t::y_resolution.

Referenced by DrawCrosshairs().

 {
     static float aaccuracy = XMLSupport::parse_float( vs_config->getVariable( "graphics", "circle_accuracy", "0.1" ) );
     float segmag =
         ( Vector( wid*g_game.x_resolution, 0,
                   0 )
          -Vector( wid*g_game.x_resolution*cos( 2.*M_PI/360.0 ), hei*g_game.y_resolution*sin( 2.*M_PI/360.0 ), 0 ) ).Magnitude();
     int accuracy = (int) ( 360.0f*aaccuracy*(1.0f < segmag ? 1.0 : segmag) );
     if (accuracy < 4) accuracy = 4;
     //const int accuracy=((wid*g_game.x_resolution)+(hei*g_game.y_resolution))*M_PI;
     GFXBegin( GFXLINESTRIP );
     float iaccuracy = 1.0f/accuracy;
     for (int i = 0; i <= accuracy; i++)
         GFXVertex3f( x+wid*cos( i*2.*M_PI*iaccuracy ), y+hei*sin( i*2.*M_PI*iaccuracy ), 0 );
     GFXEnd();
 }

void GFXClear	(	const GFXBOOL	colorbuffer,
		const GFXBOOL	depthbuffer = `GFXTRUE`,
		const GFXBOOL	stencilbuffer = `GFXTRUE`
	)

Clears the Z buffer. Also clears color buffer if GFXTRUE passed in.

Definition at line 66 of file gl_misc.cpp.

Referenced by bootstrap_draw(), Background::Draw(), WindowManager::draw(), GameCockpit::Draw(), BaseInterface::Room::BaseShip::Draw(), Mesh::ProcessUndrawnMeshes(), Mesh::ProcessZFarMeshes(), Briefing::Render(), and StartGUIFrame().

 {
     glClear( (colorbuffer ? GL_COLOR_BUFFER_BIT : 0)
             |(depthbuffer ? GL_DEPTH_BUFFER_BIT : 0)
             |(stencilbuffer ? GL_STENCIL_BUFFER_BIT : 0) );
 }

void GFXColor4f	(	const float	r,
		const float	g,
		const float	b,
		const float	a = `1.0`
	)

Specifies a color for henceforth drawn vertices to share.

Definition at line 214 of file gl_misc.cpp.

Referenced by bootstrap_draw(), GuiTexture::draw(), Bolt::Draw(), GameStarSystem::Draw(), GameCockpit::Draw(), BaseInterface::Room::Draw(), NavigationSystem::Draw(), UnivMap::Draw(), DrawDamageFlash(), DrawDockingBoxes(), DrawGlutMouse(), DrawShield(), GFXVertexList::EndDrawState(), Box::ProcessDrawQueue(), Logo::ProcessDrawQueue(), SetupCloakState(), and StartGUIFrame().

 {
     glColor4f( r, g, b, a );
 }

void GFXColorf ( const GFXColor & col)

Specifies a color for henceforth drawn vertices to share.

Definition at line 192 of file gl_misc.cpp.

References GFXColor::r.

 {
     glColor4fv( &col.r );
 }

GFXColor GFXColorf ( )

Gets the current color.

Definition at line 197 of file gl_misc.cpp.

 {
     float col[4];
     glGetFloatv( GL_CURRENT_COLOR, col );     //It's best this way, we don't use it much, anyway.
     return GFXColor( col[0], col[1], col[2], col[3] );
 }

void GFXColorMaterial ( int LIGHTTARG)

Definition at line 365 of file gl_state.cpp.

References AMBIENT, DIFFUSE, EMISSION, and SPECULAR.

Referenced by PointStarVlist::BeginDrawState(), SpriteStarVlist::BeginDrawState(), PointStarVlist::EndDrawState(), SpriteStarVlist::EndDrawState(), quadsquare::Render(), RestoreCloakState(), and SetupCloakState().

 {
     if (LIGHTTARG) {
         glEnable( GL_COLOR_MATERIAL );
         switch (LIGHTTARG)
         {
         case EMISSION:
             glColorMaterial( GL_FRONT_AND_BACK, GL_EMISSION );
             break;
         case AMBIENT:
             glColorMaterial( GL_FRONT_AND_BACK, GL_AMBIENT );
             break;
         case DIFFUSE:
             glColorMaterial( GL_FRONT_AND_BACK, GL_DIFFUSE );
             break;
         case (AMBIENT|DIFFUSE):
             glColorMaterial( GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE );
             break;
         case SPECULAR:
             glColorMaterial( GL_FRONT_AND_BACK, GL_SPECULAR );
             break;
         }
     } else {
         glDisable( GL_COLOR_MATERIAL );
     }
 }

GFXBOOL GFXCreateLight	(	int &	light,
		const GFXLight &	,
		const bool	global
	)

GFXCreateLight gets a light as a parameter. It sets light to have the index of the created light for modification in the future. If the light is global, it will always affect objects in space. if the light is not global, it is local and goes into a 3d hashtable to be picked at a later point on a per object basis.

Definition at line 272 of file gl_light.cpp.

References _llights.

Referenced by Stars::Draw(), BaseInterface::Room::BaseShip::Draw(), Mesh::DrawNow(), SetupCloakState(), and Atmosphere::Update().

 {
     for (light = 0; light < static_cast<int>(_llights->size()); light++)
         if ( (*_llights)[light].Target() == -2 )
             break;
     if ( light == static_cast<int>(_llights->size()) )
         _llights->push_back( gfx_light() );
     return (*_llights)[light].Create( templatecopy, global );
 }

void GFXCreateLightContext ( int & con_number)

creates a light context (relevant to a star system) to add lights to

Definition at line 317 of file gl_light.cpp.

References _ambient_light, _currentContext, _local_lights_dat, GFXBOOL, GFXFALSE, GFXSetLightContext(), GFXTRUE, and SetupGLLightGlobals().

Referenced by GameStarSystem::GameStarSystem(), GFXInit(), and GameUniverse::StartGFX().

 {
     static GFXBOOL LightInit = GFXFALSE;
     if (!LightInit) {
         LightInit = GFXTRUE;
         SetupGLLightGlobals();
     }
     con_number = _local_lights_dat.size();
     _currentContext = con_number;
     _ambient_light.push_back( GFXColor( 0, 0, 0, 1 ) );
     _local_lights_dat.push_back( vector< gfx_light > () );
     GFXSetLightContext( con_number );
 }

int GFXCreateProgram	(	const char *	vertex,
		const char *	fragment,
		const char *	extra_defines
	)

Definition at line 302 of file gl_program.cpp.

References cacheKey(), GFXCreateProgramNoCache(), programCache, and programICache.

Referenced by Technique::Pass::compile(), getDefaultProgram(), GFXActivateShader(), GFXCreateProgram(), and GFXReloadDefaultShader().

 {
     ProgramCache::key_type key = cacheKey( vprogram, fprogram, extra_defines );
     ProgramCache::const_iterator it = programCache.find( key );
     if ( it != programCache.end() )
         return it->second;
     int rv = programCache[key] = GFXCreateProgramNoCache( vprogram, fprogram, extra_defines );
     programICache[rv] = key;
     return rv;
 }

GFXBOOL GFXCreateTexture	(	int	width,
		int	height,
		TEXTUREFORMAT	externaltextureformat,
		int *	handle,
		char *	palette = `0`,
		int	texturestage = `0`,
		enum FILTER	mipmap = `MIPMAP`,
		enum TEXTURE_TARGET	texture_target = `TEXTURE2D`,
		enum ADDRESSMODE	address_mode = `DEFAULT_ADDRESS_MODE`
	)

Creates a texture with given w,h & tex format. Returns handle in handle var The palette may be specified but defaults to NULL. Texture Stage indicates Which texture unit the texture must reside on. The filter indicates If linear, bilinear, mipmapping or trilinear filterring should be used. Filtering is clamped to g_game.mipmap so hardware isn't abused (3dfx had trilinear troubles, and it might be a memory constraint) Texture target defines the type of texture it is for eventual cube mapping

Definition at line 312 of file gl_texture.cpp.

References activetexture, ConvertPalette(), CUBEMAP, GetUncompressedTextureFormat(), GFXActiveTexture(), GFXTextureAddressMode(), GFXTRUE, gl_options, GL_TEXTURE_CUBE_MAP_EXT, GL_TEXTURE_RECTANGLE_ARB, height, isPowerOfTwo(), gl_options_t::mipmap, MIPMAP, NEAREST, PALETTE8, TEXTURE1D, TEXTURE2D, TEXTURE3D, TEXTURERECT, textures, TRILINEAR, VSFileSystem::vs_dprintf(), and width.

Referenced by Texture::Bind(), PipelinedTexture::Clone(), PipelinedTexture::PipelinedTexture(), StreamTexture::StreamTexture(), and PipelinedTexture::Swap().

 {
     int dummy = 0;
     if ( ( mipmap&(MIPMAP|TRILINEAR) ) && !isPowerOfTwo( width, dummy ) )
         VSFileSystem::vs_dprintf( 1, "Width %d not a power of two", width );
     if ( ( mipmap&(MIPMAP|TRILINEAR) ) && !isPowerOfTwo( height, dummy ) )
         VSFileSystem::vs_dprintf( 1, "Height %d not a power of two", height );
     GFXActiveTexture( texturestage );
     *handle = 0;
     while ( *handle < static_cast<int>(textures.size()) ) {
         if (!textures[*handle].alive)
             break;
         else
             (*handle)++;
     }
     if ( (*handle) == static_cast<int>(textures.size()) ) {
         textures.push_back( GLTexture() );
         textures.back().palette = NULL;
         textures.back().alive   = GFXTRUE;
         textures.back().name    = -1;
         textures.back().width   = textures.back().height = textures.back().iwidth = textures.back().iheight = 1;
     }
     switch (texture_target)
     {
     case TEXTURE1D:
         textures[*handle].targets = GL_TEXTURE_1D;
         break;
     case TEXTURE2D:
         textures[*handle].targets = GL_TEXTURE_2D;
         break;
 #ifdef GL_EXT_texture3D
     case TEXTURE3D:
         textures[*handle].targets = GL_TEXTURE_3D;
         break;
 #endif
     case CUBEMAP:
         textures[*handle].targets = GL_TEXTURE_CUBE_MAP_EXT;
         break;
     case TEXTURERECT:
         textures[*handle].targets = GL_TEXTURE_RECTANGLE_ARB;
         break;
     }
     //for those libs with stubbed out handle gen't
     textures[*handle].name = *handle+1;
     textures[*handle].alive = GFXTRUE;
     textures[*handle].texturestage = texturestage;
     textures[*handle].mipmapped    = mipmap;
     glGenTextures( 1, &textures[*handle].name );
     glBindTexture( textures[*handle].targets, textures[*handle].name );
     activetexture[texturestage] = *handle;
     GFXTextureAddressMode( address_mode, texture_target );
     if (textures[*handle].mipmapped&(TRILINEAR|MIPMAP) && gl_options.mipmap >= 2) {
         glTexParameteri( textures[*handle].targets, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
         if (textures[*handle].mipmapped&TRILINEAR && gl_options.mipmap >= 3)
             glTexParameteri( textures[*handle].targets, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR );
         else
             glTexParameteri( textures[*handle].targets, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST );
     } else {
         if (textures[*handle].mipmapped == NEAREST || gl_options.mipmap == 0) {
             glTexParameteri( textures[*handle].targets, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
             glTexParameteri( textures[*handle].targets, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
         } else {
             glTexParameteri( textures[*handle].targets, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
             glTexParameteri( textures[*handle].targets, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
         }
     }
     glTexParameterf( textures[*handle].targets, GL_TEXTURE_PRIORITY, .5 );
     textures[*handle].width   = width;
     textures[*handle].height  = height;
     textures[*handle].iwidth  = width;
     textures[*handle].iheight = height;
     textures[*handle].palette = NULL;
     if (palette && textureformat == PALETTE8) {
         VSFileSystem::vs_dprintf( 3, " palette " );
         textures[*handle].palette = (GLubyte*) malloc( sizeof (GLubyte)*1024 );
         ConvertPalette( textures[*handle].palette, (unsigned char*) palette );
     }
     textures[*handle].textureformat = GetUncompressedTextureFormat( textureformat );
     return GFXTRUE;
 }

void GFXCullFace ( const enum POLYFACE)

Sets the facecull mode.

Definition at line 123 of file gl_misc.cpp.

References GFXBACK, GFXFRONT, and GFXFRONTANDBACK.

Referenced by setupGLState().

 {
     GLenum face;
     switch (polyface)
     {
     case GFXFRONT:
         face = GL_FRONT;
         break;
     default:
     case GFXBACK:
         face = GL_BACK;
         break;
     case GFXFRONTANDBACK:
         face = GL_FRONT_AND_BACK;
         break;
     }
     glCullFace( face );
 }

void GFXDeactivateShader ( )

Definition at line 528 of file gl_program.cpp.

References GFXActivateShader().

Referenced by Mesh::ProcessUndrawnMeshes(), and Mesh::ProcessZFarMeshes().

 {
     GFXActivateShader( (int) 0 );
 }

bool GFXDefaultShaderSupported ( )

Definition at line 499 of file gl_program.cpp.

References getDefaultProgram().

Referenced by init_opengl_extensions().

 {
     return getDefaultProgram() != 0;
 }

void GFXDeleteLight ( const int light)

Deletes a light, removing it from the light table if necessary.

Definition at line 282 of file gl_light.cpp.

Referenced by Atmosphere::Draw(), Stars::Draw(), BaseInterface::Room::BaseShip::Draw(), Mesh::DrawNow(), and GamePlanet::Kill().

 {
     (*_llights)[light].Kill();
 }

void GFXDeleteLightContext ( const int con_number)

Deletes a light context (hence a star system)

Definition at line 331 of file gl_light.cpp.

References _local_lights_dat.

 {
     _local_lights_dat[con_number] = vector< gfx_light > ();
 }

void GFXDeleteTexture ( int handle)

Deletes the texture from the graphics card.

Definition at line 1039 of file gl_texture.cpp.

References activetexture, GFXFALSE, i, and textures.

Referenced by GFXDestroyAllTextures(), Texture::UnBind(), PipelinedTexture::~PipelinedTexture(), and StreamTexture::~StreamTexture().

 {
     if (textures[handle].alive) {
         glDeleteTextures( 1, &textures[handle].name );
         for (size_t i = 0; i < sizeof (activetexture)/sizeof (int); ++i)
             if (activetexture[i] == handle)
                 activetexture[i] = -1;
     }
     if (textures[handle].palette) {
         free( textures[handle].palette );
         textures[handle].palette = 0;
     }
     textures[handle].alive = GFXFALSE;
 }

enum DEPTHFUNC GFXDepthFunc ( )

Returns the current depth function.

Definition at line 394 of file gl_state.cpp.

References cur_depth_func.

Referenced by RestoreEnvmapState(), RestoreFirstPassState(), RestoreGlowMapState(), RestoreSpecMapState(), SetupDamageMapThirdPass(), SetupEnvmapPass(), SetupGlowMapFourthPass(), setupGLState(), SetupSpecMapFirstPass(), and SetupSpecMapSecondPass().

 {
     return cur_depth_func;
 }

void GFXDepthFunc ( const enum DEPTHFUNC)

Sets up depth compare function.

Definition at line 399 of file gl_state.cpp.

References ALWAYS, cur_depth_func, EQUAL, GEQUAL, GREATER, LEQUAL, LESS, NEQUAL, and NEVER.

 {
     GLenum func;
     switch (dfunc)
     {
     case NEVER:
         func = GL_NEVER;
         break;
     case LESS:
         func = GL_LESS;
         break;
     case EQUAL:
         func = GL_EQUAL;
         break;
     case LEQUAL:
         func = GL_LEQUAL;
         break;
     case GREATER:
         func = GL_GREATER;
         break;
     case NEQUAL:
         func = GL_NOTEQUAL;
         break;
     case GEQUAL:
         func = GL_GEQUAL;
         break;
     case ALWAYS:
         func = GL_ALWAYS;
         break;
     default:
         func = GL_NEVER;
         break;
     }
     glDepthFunc( func );
     cur_depth_func = dfunc;
 }

void GFXDestroyAllTextures ( )

Cleans up all textures.

Definition at line 1069 of file gl_texture.cpp.

References GFXDeleteTexture(), and textures.

Referenced by GFXShutdown().

 {
     for (size_t handle = 0; handle < textures.size(); handle++)
         GFXDeleteTexture( handle );
 }

void GFXDestroyProgram ( int program)

Definition at line 318 of file gl_program.cpp.

References programCache, and programICache.

Referenced by Technique::Pass::compile().

 {
     // Find program
     ProgramICache::iterator it = programICache.find( program );
     if (it != programICache.end()) {
         /*
         if (glDeleteProgram_p)
             glDeleteProgram_p( program );
         */
         // FIXME: Real problem here with program leakage, 
         //      but cannot destroy like this, brings all kind of issues
         //      since the caller may not hold the only reference.
         programCache.erase(it->second);
         programICache.erase(it);
     }
 }

Vector GFXDeviceToEye	(	int	x,
		int	y
	)

convertes eyespace to 3space at the near plane

Definition at line 343 of file gl_misc.cpp.

References b, f, g_game, GFXGetFrustumVars(), Vector, game_data_t::x_resolution, and game_data_t::y_resolution.

Referenced by MouseCoordinate().

 {
     float l, r, b, t, n, f;
     GFXGetFrustumVars( true, &l, &r, &b, &t, &n, &f );
     return Vector( (l+(r-l)*float(x)/g_game.x_resolution),
                   (t+(b-t)*float(y)/g_game.y_resolution),
                   n );
 }

void GFXDisable ( const enum STATE)

GFXBOOL GFXDisableLight ( const int light)

Deactivates an active light.

Definition at line 306 of file gl_light.cpp.

References _llights, GFXFALSE, and GFXTRUE.

Referenced by GamePlanet::DisableLights(), and Atmosphere::Draw().

 {
     assert( light >= 0 && light <= static_cast<int>(_llights->size()) );
     if ( (*_llights)[light].Target() == -2 )
         return GFXFALSE;
     (*_llights)[light].Disable();
     return GFXTRUE;
 }

void GFXEnable ( const enum STATE)

Enables and disables given state.

GFXBOOL GFXEnableLight ( const int light)

activates a light if not already activated

Definition at line 296 of file gl_light.cpp.

References _llights, GFXFALSE, and GFXTRUE.

Referenced by GamePlanet::EnableLights(), and Atmosphere::Update().

 {
     assert( light >= 0 && light <= static_cast<int>(_llights->size()) );
     //return FALSE;
     if ( (*_llights)[light].Target() == -2 )
         return GFXFALSE;
     (*_llights)[light].Enable();
     return GFXTRUE;
 }

void GFXEnd ( )

Ends the current set of polytypes.

Definition at line 293 of file gl_misc.cpp.

 {
     glEnd();
 }

vector< PickData >* GFXEndPick ( )

Definition at line 89 of file gl_pick.cpp.

References a, picked_objects, and selectbuf.

 {
     int num_hits  = glRenderMode( GL_RENDER );
     assert( num_hits != -1 );
     //num_hits could == -1, check for this case
     unsigned *ptr = selectbuf;
     for (int a = 0; a < num_hits; a++) {
         picked_objects->push_back( PickData( ptr[3], ptr[1], ptr[2] ) );
         ptr += ptr[0]+3;
     }
     //restore gl projection matrix
     glMatrixMode( GL_PROJECTION );
     glPopMatrix();
     return picked_objects;
 }

void GFXEndScene ( )

Flushes and Swaps buffers.

Definition at line 60 of file gl_misc.cpp.

References winsys_swap_buffers().

Referenced by base_main_loop(), bootstrap_draw(), gamemenu_draw(), nav_main_loop(), GameUniverse::StartDraw(), and GameUniverse::StartGFX().

 {
     glFlush();
     winsys_swap_buffers();     //swap the buffers
 }

void GFXFogColor ( GFXColor c)

Definition at line 69 of file gl_fog.cpp.

References GFXColor::a, GFXColor::b, _GFXFogState::c, c, GFXColor::g, GFXFogState, and GFXColor::r.

Referenced by GameNebula::SetFogState().

 {
     if (c.r != GFXFogState.c.r || c.g != GFXFogState.c.g || c.b != GFXFogState.c.b || c.a != GFXFogState.c.a) {
         glFogfv( GL_FOG_COLOR, &c.r );
         GFXFogState.c = c;
     }
 }

void GFXFogDensity ( const float fogdensity)

Definition at line 51 of file gl_fog.cpp.

References _GFXFogState::density, and GFXFogState.

Referenced by GameNebula::SetFogState().

 {
     if (fogdensity != GFXFogState.density) {
         glFogf( GL_FOG_DENSITY, fogdensity );
         GFXFogState.density = fogdensity;
     }
 }

void GFXFogIndex ( const int index)

Definition at line 77 of file gl_fog.cpp.

References GFXFogState, _GFXFogState::index, and index.

Referenced by GameNebula::SetFogState().

 {
     if (GFXFogState.index != index) {
         glFogi( GL_FOG_INDEX, index );
         GFXFogState.index = index;
     }
 }

void GFXFogLimits	(	const float	fognear,
		const float	fogfar
	)

Definition at line 59 of file gl_fog.cpp.

References _GFXFogState::ffar, GFXFogState, and _GFXFogState::nnear.

Referenced by GameNebula::SetFogState().

 {
     if (GFXFogState.nnear != fognear || GFXFogState.ffar != fogfar) {
         GFXFogState.nnear = fognear;
         GFXFogState.ffar  = fogfar;
         glFogf( GL_FOG_START, fognear );
         glFogf( GL_FOG_END, fogfar );
     }
 }

void GFXFogMode ( const FOGMODE fog)

Definition at line 23 of file gl_fog.cpp.

References _GFXFogState::curmode, _GFXFogState::enabled, FOG_EXP, FOG_EXP2, FOG_LINEAR, FOG_OFF, and GFXFogState.

Referenced by GameStarSystem::Draw(), Mesh::DrawNow(), Animation::ProcessDrawQueue(), GameNebula::SetFogState(), and SetupFogState().

 {
     if (GFXFogState.curmode != fog || !GFXFogState.enabled) {
         switch (fog)
         {
         case FOG_OFF:
             if (!GFXFogState.enabled)
                 return;
             glDisable( GL_FOG );
             GFXFogState.enabled = false;
             return;
         case FOG_EXP:
             glFogi( GL_FOG_MODE, GL_EXP );
             break;
         case FOG_EXP2:
             glFogi( GL_FOG_MODE, GL_EXP2 );
             break;
         case FOG_LINEAR:
             glFogi( GL_FOG_MODE, GL_LINEAR );
             break;
         }
     }
     if (!GFXFogState.enabled) glEnable( GL_FOG );
     GFXFogState.curmode = fog;
     GFXFogState.enabled = true;
     //glHint (GL_FOG_HINT,GL_NICEST );
 }

void GFXFrustum	(	float *	mat,
		float *	inv,
		float	left,
		float	right,
		float	bottom,
		float	top,
		float	nearval,
		float	farval
	)

Given matrices, calculates the matrix and inverse matrix of a projection matrix to go from screen to 3-space coordinates.

Definition at line 303 of file gl_matrix.cpp.

References a, b, c, d, float, M, x, and y.

Referenced by gl_Frustum(), and ClickList::requestIterator().

 {
     GLfloat x, y, a, b, c, d;
     x = ( ( (float) 2.0 )*nearval )/(right-left);
     y = ( ( (float) 2.0 )*nearval )/(top-bottom);
     a = (right+left)/(right-left);
     b = (top+bottom)/(top-bottom);
     //If farval == 0, we'll build an infinite-farplane projection matrix.
     if (farval == 0) {
         c = -1.0;
         d = -1.99*nearval;         //-2*nearval, but using exactly -2 might create artifacts
     } else {
         c = -(farval+nearval)/(farval-nearval);
         d = -( ( (float) 2.0 )*farval*nearval )/(farval-nearval);
     }
 #define M( row, col ) m[col*4+row]
     M( 0, 0 ) = x;
     M( 0, 1 ) = 0.0F;
     M( 0, 2 ) = a;
     M( 0, 3 ) = 0.0F;
     M( 1, 0 ) = 0.0F;
     M( 1, 1 ) = y;
     M( 1, 2 ) = b;
     M( 1, 3 ) = 0.0F;
     M( 2, 0 ) = 0.0F;
     M( 2, 1 ) = 0.0F;
     M( 2, 2 ) = c;
     M( 2, 3 ) = d;
     M( 3, 0 ) = 0.0F;
     M( 3, 1 ) = 0.0F;
     M( 3, 2 ) = -1.0F;
     M( 3, 3 ) = 0.0F;
 #undef M
 #define M( row, col ) i[col*4+row]
     M( 0, 0 ) = 1./x;
     M( 0, 1 ) = 0.0F;
     M( 0, 2 ) = 0.0F;
     M( 0, 3 ) = a/x;
     M( 1, 0 ) = 0.0F;
     M( 1, 1 ) = 1./y;
     M( 1, 2 ) = 0.0F;
     M( 1, 3 ) = b/y;
     M( 2, 0 ) = 0.0F;
     M( 2, 1 ) = 0.0F;
     M( 2, 2 ) = 0.0F;
     M( 2, 3 ) = -1.0F;
     M( 3, 0 ) = 0.0F;
     M( 3, 1 ) = 0.0F;
     M( 3, 2 ) = 1.F/d;
     M( 3, 3 ) = (float) c/d;
 #undef M
 }

void GFXGetBlendMode	(	enum BLENDFUNC &	src,
		enum BLENDFUNC &	dst
	)

Gets the current blend mode to src,dst.

Definition at line 311 of file gl_state.cpp.

References currBlendMode, BlendMode::dfactor, and BlendMode::sfactor.

Referenced by VSSprite::Draw(), GFXVertexList::Draw(), Animation::DrawAsVSSprite(), Animation::DrawNoTransform(), and Animation::DrawNow().

 {
     src = currBlendMode.sfactor;
     dst = currBlendMode.dfactor;
 }

void GFXGetFrustum ( double f[6][4])

Gets the 6 clip planes of the current Projection matrix.

Definition at line 183 of file gl_clip.cpp.

References frust.

 {
     f = frust;
 }

void GFXGetFrustumVars	(	bool	,
		float *	l,
		float *	r,
		float *	b,
		float *	t,
		float *	n,
		float *	f
	)

Saves and restores last used left,right,bot,top,near,far vals (internal use)

Definition at line 162 of file gl_clip.cpp.

References b.

Referenced by GFXBeginPick(), GFXDeviceToEye(), GFXGetZPerspective(), GFXParallel(), gl_Frustum(), ClickList::requestIterator(), and CoordinateSelect::UpdateMouse().

 {
     static float nnear, ffar, left, right, bot, top;     //Visual C++ reserves near and far
     if (!retr) {
         nnear = *n;
         ffar  = *f;
         left  = *l;
         right = *r;
         bot   = *b;
         top   = *t;
     } else {
         *l = left;
         *r = right;
         *b = bot;
         *t = top;
         *n = nnear;
         *f = ffar;
     }
     //VSFileSystem::Fprintf (stderr,"<FUN%f,%f,%f,%f,%f,%f>>",near,far,left,right,bot,top);
 }

GFXBOOL GFXGetLightContextAmbient ( GFXColor & amb)

Gets the ambient light value.

Definition at line 264 of file gl_light.cpp.

References _ambient_light, _currentContext, GFXFALSE, and GFXTRUE.

Referenced by GameStarSystem::Draw(), SphereMesh::ProcessDrawQueue(), CityLights::ProcessDrawQueue(), Terrain::Render(), and Terrain::RenderAll().

 {
     if ( _currentContext >= static_cast<int>(_ambient_light.size()) )
         return GFXFALSE;
     amb = (_ambient_light[_currentContext]);
     return GFXTRUE;
 }

GFXBOOL GFXGetMaterial	(	const unsigned int	number,
		GFXMaterial &	material
	)

Gets the statistics of the material stored in number.

Definition at line 67 of file gfxlib_struct_server.cpp.

References GFXFALSE, GFXTRUE, and materialinfo.

Referenced by Mission::call_unit_launch(), and Mesh::GetMaterial().

 {
     return GFXFALSE;
 }

const GFXMaterial& GFXGetMaterial ( const unsigned int number)

Definition at line 50 of file gl_material.cpp.

References materialinfo.

 {
     if ( number >= materialinfo.size() ) {
         static GFXMaterial tmp;
         return tmp;
     }
     return materialinfo[number];
 }

void GFXGetMatrixModel ( Matrix & matrix)

retrieves the matrix for a given mode.

Definition at line 292 of file gl_matrix.cpp.

References CopyMatrix(), and GFXMatrices::model.

Referenced by LocationSelect::Draw(), and GFXUploadLightState().

 {
     CopyMatrix( matrix, model );
 }

void GFXGetMatrixView ( Matrix & m)

Definition at line 288 of file gl_matrix.cpp.

References CopyMatrix(), and GFXMatrices::view.

Referenced by LocationSelect::Draw(), and Camera::GetView().

 {
     CopyMatrix( matrix, view );
 }

void GFXGetPolygonOffset	(	float *	factor,
		float *	units
	)

Definition at line 81 of file gl_misc.cpp.

References last_factor, and last_units.

Referenced by SetupSpecMapFirstPass().

 {
     *factor = last_factor;
     *units  = last_units;
 }

int GFXGetProgramVersion ( )

Definition at line 647 of file gl_program.cpp.

References programVersion.

Referenced by Technique::Pass::compile(), and Technique::compile().

 {
     return programVersion;
 }

float GFXGetXInvPerspective ( )

Screen to eye.

Definition at line 51 of file gl_matrix.cpp.

References GFXMatrices::invprojection.

Referenced by LocationSelect::Draw().

 {
     return /*invprojection[11]*  */ invprojection[0];     //invprojection[15];//should be??  c/d == invproj[15]
 }

float GFXGetYInvPerspective ( )

Definition at line 56 of file gl_matrix.cpp.

References GFXMatrices::invprojection.

Referenced by LocationSelect::Draw().

 {
     return /*invprojection[11]*  */ invprojection[5];     //invprojection[15];//should be??  c/d == invproj[15]
 }

float GFXGetZPerspective ( const float z)

Given the current projection matrix, how much will the model be divided by.

GFXGetZPerspective () returns the relative scale of an object placed at distance z from the camera with the current projection matrix.

GFXGetXPerspective () returns the number that x/z is multiplied by to land a pixel on the screen. | xs 0 a 0 |[x] [xs + az] [1/xs 0 0 a/xs][x] [x/xs+ aw/xs] | 0 ys b 0 |[y] = [ys + bz] ^-1 [ 0 1/ys 0 b/ys][y] = [y/ys+ bw/ys] | 0 0 c d |[z] [cz + dw] [ 0 0 0 -1 ][z] [0 ] | 0 0 -1 0 |[w] [-z ] [ 0 0 1/d c/d ][w] [z/d + cw/d ] therefore return 1/(xs *d) and 1/(ys * d) I'm not good with matrix math...tell me if I should ret 1/xs+c/d instead for test cases I can think of, it doesn't matter—

Definition at line 311 of file gl_clip.cpp.

References a, and GFXGetFrustumVars().

Referenced by perspectiveFactor().

 {
     /*
      *
      * | xs 0  a 0 |[x]   [xs + az]          [1/xs 0   0  a/xs][x]   [x/xs+ aw/xs]
      * | 0  ys b 0 |[y] = [ys + bz]    ^-1   [ 0  1/ys 0  b/ys][y] = [y/ys+ bw/ys]
      * | 0  0  c d |[z]   [cz + dw]          [ 0   0   0  -1  ][z]   [0          ]
      * | 0  0 -1 0 |[w]   [-z     ]          [ 0   0  1/d c/d ][w]   [z/d + cw/d ]
      *
      */
 
     float left, right, bottom, top, nearval, farval;
     GFXGetFrustumVars( true, &left, &right, &bottom, &top, &nearval, &farval );
 
     float xs = 2*nearval/(right-left);
     float a  = (right+left)/(right-left);
 
     //Compute homogeneus x,w for (1,0,z,0)
     float hx = xs+z*a;
     float hw = -z;
 
     //Translate into euclidean coordinates and return euclidean x
     return fabs( hx/hw );
 }

void GFXHudMode ( const bool Enter)

Hud Mode saves the current matrices and sets projection and view matrices to identity. Caution: use of other matrix functions in HudMode could alter state.

Definition at line 246 of file gl_matrix.cpp.

Referenced by bootstrap_draw(), WindowManager::draw(), GameCockpit::Draw(), BaseInterface::Room::BaseShip::Draw(), NavigationSystem::Draw(), EndGUIFrame(), and StartGUIFrame().

 {
     if (Enter) {
         glMatrixMode( GL_MODELVIEW );
         glPushMatrix();
         glLoadIdentity();
         glMatrixMode( GL_PROJECTION );
         glPushMatrix();
         glLoadIdentity();
     } else {
         glMatrixMode( GL_PROJECTION );
         glPopMatrix();
         glMatrixMode( GL_MODELVIEW );
         glPopMatrix();
     }
 }

void GFXInit	(	int	,
		char **
	)

Loads Glut and graphics drivers.

Definition at line 532 of file gl_init.cpp.

References gl_options_t::compression, CUBE_MAP_GEN, CUBEMAP, gl_options_t::display_lists, gl_options_t::ext_clamp_to_border, gl_options_t::ext_clamp_to_edge, g_game, VegaConfig::getColor(), VegaConfig::getVariable(), GFXActiveTexture(), GFXADDTEXTURE, GFXBlendMode(), GFXCreateLightContext(), GFXInitTextureManager(), GFXTextureCoordGenMode(), GFXTextureEnv(), GFXToggleTexture(), GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB, gl_options, i, init_opengl_extensions(), initfov(), gl_options_t::max_movie_dimension, gl_options_t::max_rect_dimension, gl_options_t::max_texture_dimension, gl_options_t::mipmap, gl_options_t::Multitexture, ONE, gl_options_t::PaletteExt, XMLSupport::parse_bool(), XMLSupport::parse_int(), gl_options_t::pot_video_textures, gl_options_t::rect_textures, Reshape(), gl_options_t::s3tc, gl_options_t::smooth_lines, gl_options_t::smooth_points, gl_options_t::smooth_shade, SPHERE_MAP_GEN, TEXTURE2D, vs_config, VSFileSystem::vs_dprintf(), vsExtensionSupported(), vsVendorMatch(), winsys_enable_key_repeat(), winsys_init(), winsys_set_reshape_func(), winsys_show_cursor(), winsys_swap_buffers(), gl_options_t::wireframe, game_data_t::x_resolution, game_data_t::y_resolution, and ZERO.

Referenced by GameUniverse::Init().

 {
     char vsname[12] = "Vega Strike";
     char vsicon[9] = "vega.ico";
     winsys_init (&argc,argv,&vsname[0],&vsicon[0]);
     /* Ingore key-repeat messages */
     winsys_enable_key_repeat( false );
 
     glViewport( 0, 0, g_game.x_resolution, g_game.y_resolution );
     float clearcol[4];
     gl_options.wireframe = XMLSupport::parse_bool( vs_config->getVariable( "graphics", "use_wireframe", "0" ) );
     gl_options.max_texture_dimension =
         XMLSupport::parse_int( vs_config->getVariable( "graphics", "max_texture_dimension", "65536" ) );
     gl_options.max_movie_dimension   =
         XMLSupport::parse_int( vs_config->getVariable( "graphics", "max_movie_dimension", "65536" ) );
         
     gl_options.rect_textures    =
         XMLSupport::parse_bool( vs_config->getVariable( "graphics", "rect_textures", 
             (   vsExtensionSupported( "GL_ARB_texture_non_power_of_two" )
              || vsExtensionSupported( "GL_ARB_texture_rectangle" )
              || vsExtensionSupported( "GL_NV_texture_rectangle" )  
             ) ? "true" : "false" ) );
 
     if (gl_options.rect_textures) {
         VSFileSystem::vs_dprintf(3, "RECT textures supported\n");
         
         // Fetch max rect textue dimension
         GLint max_rect_dimension = 65535;
         glGetIntegerv(
             GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB, 
             &max_rect_dimension);
         
         gl_options.max_rect_dimension = max_rect_dimension;
         VSFileSystem::vs_dprintf(3, "RECT max texture dimension: %d\n", max_rect_dimension);
     }
         
     gl_options.pot_video_textures    =
         XMLSupport::parse_bool( vs_config->getVariable( "graphics", "pot_video_textures", 
             (   gl_options.rect_textures
              || (   vsExtensionSupported( "GL_ARB_texture_non_power_of_two" )
                  && vsVendorMatch("nvidia")  )
             ) ? "false" : "true" ) );
     
     if (!gl_options.pot_video_textures && gl_options.rect_textures) {
         // Enforce max rect texture for movies, which use them
         if (gl_options.max_movie_dimension > gl_options.max_rect_dimension)
             gl_options.max_movie_dimension = gl_options.max_rect_dimension;
     }
     
     if (gl_options.pot_video_textures)
         VSFileSystem::vs_dprintf(1, "Forcing POT video textures\n");
     else
         VSFileSystem::vs_dprintf(3, "Using NPOT video textures\n");
     
     gl_options.smooth_shade        = XMLSupport::parse_bool( vs_config->getVariable( "graphics", "SmoothShade", "true" ) );
     gl_options.mipmap = XMLSupport::parse_int( vs_config->getVariable( "graphics", "mipmapdetail", "2" ) );
     gl_options.compression         = XMLSupport::parse_int( vs_config->getVariable( "graphics", "texture_compression", "0" ) );
     gl_options.Multitexture        = XMLSupport::parse_bool( vs_config->getVariable( "graphics", "reflection", "true" ) );
     gl_options.smooth_lines        = XMLSupport::parse_bool( vs_config->getVariable( "graphics/mesh", "smooth_lines", "true" ) );
     gl_options.smooth_points       = XMLSupport::parse_bool( vs_config->getVariable( "graphics/mesh", "smooth_points", "true" ) );
 
     gl_options.display_lists       = XMLSupport::parse_bool( vs_config->getVariable( "graphics", "displaylists", "false" ) );
     gl_options.s3tc = XMLSupport::parse_bool( vs_config->getVariable( "graphics", "s3tc", "true" ) );
     gl_options.ext_clamp_to_edge   = XMLSupport::parse_bool( vs_config->getVariable( "graphics", "ext_clamp_to_edge", "true" ) );
     gl_options.ext_clamp_to_border = XMLSupport::parse_bool( vs_config->getVariable( "graphics", "ext_clamp_to_border", "true" ) );
 
     vs_config->getColor( "space_background", clearcol );
     glClearColor( clearcol[0], clearcol[1], clearcol[2], clearcol[3] );
     winsys_set_reshape_func( Reshape );
     initfov();
     glShadeModel( GL_SMOOTH );
     glEnable( GL_CULL_FACE );
     glCullFace( GL_BACK );
     glShadeModel( GL_SMOOTH );
     glEnable( GL_DEPTH_TEST );
     glDepthFunc( GL_LESS );
     if (gl_options.wireframe)
         glPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
     if (gl_options.smooth_shade == 0)
         glShadeModel( GL_FLAT );
     glEnable( GL_ALPHA_TEST );
     glAlphaFunc( GL_GREATER, 0.0 );
 
     init_opengl_extensions();
     GFXInitTextureManager();
     if (gl_options.Multitexture)
         GFXActiveTexture( 0 );
     glEnable( GL_TEXTURE_2D );          //use two-dimensional texturing
     glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
     glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
 
 #if defined (IRIX)
     glEnable( GL_SHARED_TEXTURE_PALETTE_EXT );
 #endif
     if ( vsExtensionSupported( "GL_EXT_color_table" ) || vsExtensionSupported( "GL_EXT_shared_texture_palette" ) ) {
         gl_options.PaletteExt = 1;
         VSFileSystem::vs_dprintf(3, "OpenGL::EXTColorTable supported\n");
     } else {
         gl_options.PaletteExt = 0;
         VSFileSystem::vs_dprintf( 2, "OpenGL::EXTColorTable unsupported\n" );
     }
     glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT );
     glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT );
     glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
     if (gl_options.Multitexture) {
         for (int i = 1; i < 4; ++i) {
             GFXActiveTexture( i );
             glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
             glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
             glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT );
             glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT );
             GFXTextureEnv( i, GFXADDTEXTURE );
             glPixelStorei( GL_UNPACK_SKIP_ROWS, 0 );
             glPixelStorei( GL_UNPACK_SKIP_PIXELS, 0 );
             glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
             glPixelStorei( GL_UNPACK_SWAP_BYTES, 0 );
             // Choose cubemap or spheremap coordinates. 
             if (i == 1) {
 #ifdef NV_CUBE_MAP
                 GFXToggleTexture( true, 1, CUBEMAP );
                 GFXTextureCoordGenMode( 1, CUBE_MAP_GEN, NULL, NULL );
 #else
                 const float tempo[4] = {1, 0, 0, 0};
                 GFXToggleTexture( true, 1, TEXTURE2D );
                 GFXTextureCoordGenMode( 1, SPHERE_MAP_GEN, tempo, tempo );
 #endif
             }
         }
     }
     GFXActiveTexture( 0 );
     glClearDepth( 1 );
     glEnable( GL_BLEND );
     glDisable( GL_ALPHA_TEST );
     GFXBlendMode( ONE, ZERO );
 
     glColor3f( 0, 0, 0 );
     glMatrixMode( GL_MODELVIEW );
     glLoadIdentity();
     glMatrixMode( GL_TEXTURE );
     glLoadIdentity();     //set all matricies to identity
     glMatrixMode( GL_PROJECTION );
     glLoadIdentity();
 
     glEnable( GL_LIGHTING );
 
     glDisable( GL_NORMALIZE );
 
     glDisable( GL_LINE_SMOOTH );
     glDisable( GL_POINT_SMOOTH );
 
     int con;
     GFXCreateLightContext( con );
     //glutSetCursor(GLUT_CURSOR_NONE);
     /* Avoid scrambled screen on startup - Twice, for triple buffering */
     if ( XMLSupport::parse_bool( vs_config->getVariable( "graphics", "ClearOnStartup", "true" ) ) ) {
         glClear( GL_COLOR_BUFFER_BIT );
         winsys_swap_buffers();
         glClear( GL_COLOR_BUFFER_BIT );
         winsys_swap_buffers();
     }
     winsys_show_cursor( false );
 }

GFXBOOL GFXLightContextAmbient ( const GFXColor & amb)

Sets the ambient light value.

Definition at line 251 of file gl_light.cpp.

References _ambient_light, _currentContext, GFXColor::a, GFXColor::b, GFXColor::g, GFXFALSE, GFXTRUE, and GFXColor::r.

Referenced by GameStarSystem::Draw(), GFXPopGlobalEffects(), GFXPushGlobalEffects(), SphereMesh::ProcessDrawQueue(), CityLights::ProcessDrawQueue(), Terrain::Render(), Terrain::RenderAll(), and GameUniverse::StartGFX().

 {
     if ( _currentContext >= static_cast<int>(_ambient_light.size()) )
         return GFXFALSE;
     (_ambient_light[_currentContext]) = amb;
     //(_ambient_light[_currentContext])[1]=amb.g;
     //(_ambient_light[_currentContext])[2]=amb.b;
     //(_ambient_light[_currentContext])[3]=amb.a;
     float tmp[4] = {amb.r, amb.g, amb.b, amb.a};
     glLightModelfv( GL_LIGHT_MODEL_AMBIENT, tmp );
     return GFXTRUE;
 }

void GFXLineWidth ( const float size)

Sets the line width in pixels of a GFXLINE.

Definition at line 147 of file gl_misc.cpp.

Referenced by Radar::SphereDisplay::DrawBackground(), Radar::BubbleDisplay::DrawBackground(), Radar::PlaneDisplay::DrawGround(), DrawOneTargetBox(), Radar::PlaneDisplay::DrawTarget(), Radar::SphereDisplay::DrawTargetMarker(), Radar::BubbleDisplay::DrawTargetMarker(), Radar::PlaneDisplay::DrawTargetMarker(), and setupGLState().

 {
     glLineWidth( size );
 }

void GFXLoadIdentity ( const MATRIXMODE mode)

Loads the identity matrix for the given mode.

Definition at line 263 of file gl_matrix.cpp.

References ConstructAndLoadProjection(), GFX_SCALE, Identity(), IdentityFloat(), GFXMatrices::model, MODEL, Matrix::p, GFXMatrices::projection, PROJECTION, GFXMatrices::rotview, GFXMatrices::view, VIEW, and ViewToModel().

Referenced by bootstrap_draw(), CoordinateSelect::Draw(), LocationSelect::Draw(), GamePlanet::Draw(), Stars::Draw(), GameCockpit::Draw(), ParticleTrail::DrawAndUpdate(), Mesh::DrawNow(), GamePlanet::DrawTerrain(), GFXBeginScene(), GFXCenterCamera(), GFXUploadLightState(), Halo::ProcessDrawQueue(), Camera::UpdateGFX(), and Camera::UpdateGLCenter().

 {
     switch (mode)
     {
     case MODEL:
         Identity( model );
         glMatrixMode( GL_MODELVIEW );
         //glLoadMatrixf(transview);
         glLoadIdentity();
         glTranslated( -view.p.i*GFX_SCALE, -view.p.j*GFX_SCALE, -view.p.k*GFX_SCALE );
         glScalef( GFX_SCALE, GFX_SCALE, GFX_SCALE );
         break;
     case PROJECTION:
         IdentityFloat( projection );
         ConstructAndLoadProjection();
         break;
     case VIEW:
         Identity( view );
         ViewToModel();
         glMatrixMode( GL_PROJECTION );
         glLoadMatrixf( projection );
         break;
     }
 }

void GFXLoadMatrixModel ( const Matrix & matrix)

loads a given matrix to the current "mode"

Definition at line 207 of file gl_matrix.cpp.

References CopyMatrix(), GFXMatrices::model, and ViewToModel().

Referenced by bootstrap_draw(), Bolt::Draw(), Background::Draw(), Atmosphere::Draw(), Animation::DrawNow(), Mesh::DrawNow(), GFXUploadLightState(), Box::ProcessDrawQueue(), Logo::ProcessDrawQueue(), Beam::ProcessDrawQueue(), and QuadTree::Render().

 {
     CopyMatrix( model, matrix );
     ViewToModel();
 }

void GFXLoadMatrixProjection ( const float matrix[16])

Definition at line 213 of file gl_matrix.cpp.

References ConstructAndLoadProjection(), VsnetOSS::memcpy(), and GFXMatrices::projection.

Referenced by GFXParallel().

 {
     memcpy( projection, matrix, 16*sizeof (float) );
     ConstructAndLoadProjection();
 }

void GFXLoadMatrixView ( const Matrix & matrix)

Definition at line 200 of file gl_matrix.cpp.

References ConstructAndLoadProjection(), CopyMatrix(), GFXMatrices::view, and ViewToModel().

Referenced by GFXLookAt().

 {
     CopyMatrix( view, matrix );
     ViewToModel();
     ConstructAndLoadProjection();
 }

void GFXLookAt	(	Vector	eye,
		QVector	center,
		Vector	up
	)

Sets the VIEW matrix to look from center in direction of eye with up vector up.

Definition at line 495 of file gl_matrix.cpp.

References GFXLoadMatrixView(), LookAtHelper(), and GFXMatrices::view.

Referenced by Camera::UpdateGFX(), and Camera::UpdateGLCenter().

 {
     LookAtHelper( eye.i, eye.j, eye.k, center.i, center.j, center.k, up.i, up.j, up.k );
     GFXLoadMatrixView( view );
 }

void GFXLoop ( void main_loop())

loops on the function over and over

so we can call this function multiple times to change the display and idle functions

Definition at line 732 of file gl_init.cpp.

References main_loop(), winsys_process_events(), winsys_set_display_func(), and winsys_set_idle_func().

Referenced by BaseInterface::InitCallbacks(), GameUniverse::Loop(), GameMenu::processSinglePlayerButton(), restore_main_loop(), UniverseUtil::startMenuInterface(), and NavComputer::toggleVisibility().

 {
     winsys_set_display_func( main_loop );
     winsys_set_idle_func( main_loop );
 
     //glutDisplayFunc(main_loop);
     //glutIdleFunc (main_loop);
     static bool are_we_looping = false;
     if (!are_we_looping) {
         are_we_looping = true;
         winsys_process_events();
     }
 }

void GFXModifyMaterial	(	const unsigned int	number,
		const GFXMaterial &	material
	)

Modifies the given material to be like the passed in structure.

Definition at line 45 of file gl_material.cpp.

References materialinfo.

 {
     materialinfo[number] = material;
 }

bool GFXMultiTexAvailable ( )

Definition at line 32 of file gl_misc.cpp.

References gl_options, and gl_options_t::Multitexture.

 {
     return gl_options.Multitexture != 0;
 }

void GFXMultMatrixModel ( const Matrix & matrix)

Multipliex the current "mode" matrix by a given matrix.

Definition at line 189 of file gl_matrix.cpp.

References CopyMatrix(), GFXMatrices::model, MultMatrix(), and ViewToModel().

Referenced by LocationSelect::Draw().

 {
     Matrix t;
     MultMatrix( t, model, matrix );
     CopyMatrix( model, t );
     ViewToModel();
 }

int GFXNamedShaderConstant	(	char *	progID,
		const char *	name
	)

Definition at line 639 of file gl_program.cpp.

References cacheKey(), defaultprog, GFXNamedShaderConstant(), and programCache.

Referenced by Technique::Pass::compile(), and GFXNamedShaderConstant().

 {
     int programname = defaultprog;
     if (progID)
         programname = programCache[cacheKey( progID, progID, NULL )];
     return GFXNamedShaderConstant( programname, name );
 }

int GFXNamedShaderConstant	(	int	progID,
		const char *	name
	)

Definition at line 626 of file gl_program.cpp.

References glGetUniformLocation_p.

 {
     if (1
 #ifndef __APPLE__
         && glGetUniformLocation_p
 #endif
        ) {
         int varloc = glGetUniformLocation_p( progID, name );
         return varloc;
     }
     return -1;     //varloc cound be 0
 }

void GFXNormal ( const Vector & n)

Specifies a notmal with 1 vector.

Definition at line 263 of file gl_misc.cpp.

 {
     glNormal3fv( &n.i );
 }

void GFXNormal3f	(	const float	i,
		const float	j,
		const float	k
	)

Specifies a normal with 3 floats.

Definition at line 258 of file gl_misc.cpp.

 {
     glNormal3f( i, j, k );
 }

void GFXOptimizeList	(	GFXVertex *	old,
		int	numV,
		GFXVertex **	newlist,
		int *	numnewVertices,
		unsigned int **	indices
	)

Optimizes a list to reuse repeated vertices!

Definition at line 68 of file gl_vertex_list.cpp.

References i, VsnetOSS::memcpy(), and VSFileSystem::vs_dprintf().

Referenced by Mesh::PostProcessLoading().

 {
     std::map< GFXVertex*, int, VertexCompare >vtxcache;
     
     *ind   = (unsigned int*) malloc( sizeof (unsigned int)*numV );
     *nw    = (GFXVertex*) malloc( numV*sizeof (GFXVertex) );
     int _nnewV = *nnewV = 0;
     int i;
     bool quickpath = true;
     for (i = 0; i < numV; i++) {
         std::map< GFXVertex*, int, VertexCompare >::const_iterator it = vtxcache.find( old+i );
         if ( it != vtxcache.end() ) {
             if (quickpath && i > 0) {
                 quickpath = false;
                 memcpy( *nw, old, sizeof(GFXVertex)*size_t(i) );
             }
             (*ind)[i] = it->second;
         } else {
             if (!quickpath)
                 memcpy( (*nw)+_nnewV, old+i, sizeof (GFXVertex) );
             vtxcache[old+i] = ( (*ind)[i] ) = _nnewV;
             ++_nnewV;
         }
     }
     if (quickpath && i > 0)
         memcpy( *nw, old, sizeof(GFXVertex)*size_t(i) );
     *nnewV = _nnewV;
     
     VSFileSystem::vs_dprintf(3, "Optimized vertex list - vertices: %d -> %d\n", numV, *nnewV);
 }

void GFXParallel	(	float	left,
		float	right,
		float	bottom,
		float	top,
		float	znear,
		float	zfar
	)

Sets the Projection matrix to a parallel view with given paramters.

Definition at line 376 of file gl_matrix.cpp.

References GFXGetFrustumVars(), GFXLoadMatrix(), GFXLoadMatrixProjection(), M, GFXMatrices::projection, PROJECTION, x, y, and z.

Referenced by Camera::UpdateGFX(), and Camera::UpdateGLCenter().

 {
     float *m = projection, x, y, z, tx, ty, tz;
     x  = 2.0/(right-left);
     y  = 2.0/(top-bottom);
     z  = -2.0/(farval-nearval);
     tx = -(right+left)/(right-left);
     ty = -(top+bottom)/(top-bottom);
     tz = -(farval+nearval)/(farval-nearval);
 
 #define M( row, col ) m[col*4+row]
     M( 0, 0 ) = x;
     M( 0, 1 ) = 0.0F;
     M( 0, 2 ) = 0.0F;
     M( 0, 3 ) = tx;
     M( 1, 0 ) = 0.0F;
     M( 1, 1 ) = y;
     M( 1, 2 ) = 0.0F;
     M( 1, 3 ) = ty;
     M( 2, 0 ) = 0.0F;
     M( 2, 1 ) = 0.0F;
     M( 2, 2 ) = z;
     M( 2, 3 ) = tz;
     M( 3, 0 ) = 0.0F;
     M( 3, 1 ) = 0.0F;
     M( 3, 2 ) = 0.0F;
     M( 3, 3 ) = 1.0F;
 #undef M
     GFXLoadMatrixProjection( projection );
     GFXGetFrustumVars( false, &left, &right, &bottom, &top, &nearval, &farval );
 }

void GFXPerspective	(	float	fov,
		float	aspect,
		float	znear,
		float	zfar,
		float	cockpit_offset
	)

Sets the Projection matrix to have fov and aspect as follows (fov is field of view in radians, aspect is width/height znear and zfar are clip planes.

Definition at line 356 of file gl_matrix.cpp.

References ConstructAndLoadProjection(), GFX_SCALE, gl_Frustum(), M_PI, and GFXMatrices::projection.

Referenced by Camera::UpdateGFX(), and Camera::UpdateGLCenter().

 {
     znear *= GFX_SCALE;
     zfar  *= GFX_SCALE;
     cockpit_offset *= GFX_SCALE;
     //gluPerspective (fov,aspect,znear,zfar);
 
     float xmin, xmax, ymin, ymax;
 
     ymax  = znear*tanf( fov*M_PI/( (float) 360.0 ) );       //78.0 --> 4.7046
 
     ymin  = -ymax;     //-4.7046
 
     xmin  = (ymin-cockpit_offset/2)*aspect;       //-6.2571
     xmax  = (ymax+cockpit_offset/2)*aspect;       //6.2571
     ymin -= cockpit_offset;
     gl_Frustum( xmin, xmax, ymin, ymax, znear, zfar );
     ConstructAndLoadProjection();
 }

void GFXPickLights	(	const Vector &	center,
		const float	radius
	)

picks and activates local lights near to "center"

Definition at line 173 of file gl_light_pick.cpp.

References gfx_light::dopickenables(), GFXPickLights(), newpicked, and swappicked().

Referenced by Mesh::DrawNow(), and GFXPickLights().

 {
     swappicked();
     GFXPickLights( center, radius, *newpicked, 8, false );
     gfx_light::dopickenables();
 }

void GFXPickLights	(	const Vector &	center,
		const float	radius,
		vector< int > &	lights,
		const int	maxlights,
		const bool	pickglobals
	)

picks and does not activate local lights near to "center"

Definition at line 139 of file gl_light_pick.cpp.

References _GLLightsEnabled, GFX_MAX_LIGHTS, OpenGLL::GL_ENABLED, OpenGLL::GLL_LOCAL, GLLights, i, index, j, lighttable, picklight(), and QVector.

 {
     QVector     tmp;
     //Beware if re-using rndvar !! Because rand returns an int and on 64 bits archs sizeof( void*) != sizeof( int) !!!
     //void * rndvar = (void *)rand();
     int         lightsenabled = _GLLightsEnabled;
     tmp = QVector( radius, radius, radius );
 
     if (lightsenabled && pickglobals) {
         // Push global lights into the picked set
         for (int i = 0; i < GFX_MAX_LIGHTS; ++i) {
             if ((GLLights[i].options & (OpenGLL::GL_ENABLED|OpenGLL::GLL_LOCAL)) == OpenGLL::GL_ENABLED) {
                 // It's global and enabled
                 lights.push_back(GLLights[i].index);
             }
         }
     }
     
     veclinecol *tmppickt[2];
     lighttable.Get( center.Cast(), tmppickt );
 
     for (int j = 0; j < 2; j++) {
         veclinecol::iterator i;
 
         for (i = tmppickt[j]->begin(); i != tmppickt[j]->end(); i++) {
             if ( picklight( *i->lc, center, radius, lightsenabled, i->GetIndex() ) ) {
                 lights.push_back( i->GetIndex() );
                 lightsenabled++;
             }
         }
     }
     std::sort( lights.begin(), lights.end(), lightsort( center, radius ) );
 }

void GFXPickLights	(	vector< int >::const_iterator	begin,
		vector< int >::const_iterator	end
	)

activates local lights picked by GFXPickLight

Definition at line 180 of file gl_light_pick.cpp.

References gfx_light::dopickenables(), newpicked, and swappicked().

 {
     swappicked();
     newpicked->insert( newpicked->end(), begin, end );
     gfx_light::dopickenables();
 }

void GFXPointSize ( const float size)

Sets the size in pixels of a GFXPOINT.

Definition at line 142 of file gl_misc.cpp.

Referenced by Radar::SphereDisplay::Draw(), Radar::BubbleDisplay::Draw(), Radar::PlaneDisplay::Draw(), ParticleTrail::DrawAndUpdate(), DrawGun(), Radar::PlaneDisplay::DrawTarget(), Radar::SphereDisplay::DrawTrack(), and Radar::BubbleDisplay::DrawTrack().

 {
     glPointSize( size );
 }

void GFXPolygonMode ( const enum POLYMODE)

Sets the polygon rasterization mode.

Definition at line 104 of file gl_misc.cpp.

References GFXFILLMODE, GFXLINEMODE, and GFXPOINTMODE.

Referenced by setupGLState().

 {
     GLenum mode;
     switch (polymode)
     {
     default:
     case GFXFILLMODE:
         mode = GL_FILL;
         break;
     case GFXLINEMODE:
         mode = GL_LINE;
         break;
     case GFXPOINTMODE:
         mode = GL_POINT;
         break;
     }
     glPolygonMode( GL_FRONT_AND_BACK, mode );
 }

void GFXPolygonOffset	(	float	factor,
		float	units
	)

Sets Depth Offset for polgyons.

Definition at line 87 of file gl_misc.cpp.

References last_factor, and last_units.

Referenced by Logo::ProcessDrawQueue(), SphereMesh::ProcessDrawQueue(), CityLights::ProcessDrawQueue(), quadsquare::Render(), setupGLState(), and SetupSpecMapFirstPass().

 {
     last_factor = factor;
     last_units  = units;
     if (!factor && !units) {
         glDisable( GL_POLYGON_OFFSET_FILL );
         glDisable( GL_POLYGON_OFFSET_POINT );
         glDisable( GL_POLYGON_OFFSET_LINE );
         glPolygonOffset( 0, 0 );
     } else {
         glPolygonOffset( factor, units );
         glEnable( GL_POLYGON_OFFSET_FILL );
         glEnable( GL_POLYGON_OFFSET_POINT );
         glEnable( GL_POLYGON_OFFSET_LINE );
     }
 }

void GFXPopBlendMode ( )

Restores previous blend mode.

Definition at line 356 of file gl_state.cpp.

References blendstack, currBlendMode, BlendMode::dfactor, GFXBlendMode(), and BlendMode::sfactor.

Referenced by CoordinateSelect::Draw(), LocationSelect::Draw(), GFXVertexList::Draw(), Animation::DrawAsVSSprite(), DrawDamageFlash(), PaintText::drawLines(), DrawShield(), Halo::ProcessDrawQueue(), Beam::ProcessDrawQueue(), RestoreCloakState(), RestoreEnvmapState(), RestoreFirstPassState(), RestoreGlowMapState(), and RestoreSpecMapState().

 {
     if ( !blendstack.empty() ) {
         currBlendMode = blendstack.top();
         GFXBlendMode( currBlendMode.sfactor, currBlendMode.dfactor );
         blendstack.pop();
     }
 }

GFXBOOL GFXPopGlobalEffects ( )

This function undoes the above function to restore the global lights after specialFX phase.

Definition at line 67 of file gl_light.cpp.

References GFX_MAX_LIGHTS, GFXLightContextAmbient(), GlobalEffects, GlobalEffectsAmbient, GlobalEffectsFreelist, and i.

Referenced by GameStarSystem::Draw(), Stars::Draw(), and Mesh::ProcessUndrawnMeshes().

 {
     if ( GlobalEffects.empty() )
         return false;
     //VSFileSystem::Fprintf (stderr,"GES %d",GlobalEffects.size());
     for (int i = 0; i < GFX_MAX_LIGHTS; i++)
         if (GlobalEffects.top()[i])
             glEnable( GL_LIGHT0+i );
     
     if (GlobalEffectsFreelist.size() >= 10)
         delete[] GlobalEffects.top();
     else
         GlobalEffectsFreelist.push(GlobalEffects.top());
     GlobalEffects.pop();
     
     GFXLightContextAmbient( GlobalEffectsAmbient.top() );
     GlobalEffectsAmbient.pop();
     return true;
 }

void GFXPrioritizeTexture	(	unsigned int	handle,
		float	priority
	)

Sets the priority of the texture for memory management.

Definition at line 401 of file gl_texture.cpp.

Referenced by Texture::Prioritize().

 {
     glPrioritizeTextures( 1,
 #if defined (__APPLE__)
                           (GLuint*)
 #endif
                           &handle, &priority );
 }

void GFXPushBlendMode ( )

Pushes and saves current blend mode.

Definition at line 351 of file gl_state.cpp.

References blendstack, and currBlendMode.

Referenced by CoordinateSelect::Draw(), GFXVertexList::Draw(), Animation::DrawAsVSSprite(), DrawDamageFlash(), PaintText::drawLines(), DrawShield(), Halo::ProcessDrawQueue(), Beam::ProcessDrawQueue(), SetupCloakState(), SetupDamageMapThirdPass(), SetupEnvmapPass(), SetupGlowMapFourthPass(), SetupSpecMapFirstPass(), and SetupSpecMapSecondPass().

 {
     blendstack.push( currBlendMode );
 }

void GFXPushGlobalEffects ( )

In the case of shields and other T&L based effects, the global lights must be disabled yet saved for later use while the selected lights are used shortly then disabled. This saves values of global lights

Definition at line 45 of file gl_light.cpp.

References _ambient_light, _currentContext, GFX_MAX_LIGHTS, GFXLightContextAmbient(), OpenGLL::GL_ENABLED, GlobalEffects, GlobalEffectsAmbient, GlobalEffectsFreelist, i, OpenGLLights::options, and unpicklights().

Referenced by Stars::Draw(), and Mesh::ProcessUndrawnMeshes().

 {
     bool *tmp;
     if (GlobalEffectsFreelist.empty()) {
         tmp = new bool[GFX_MAX_LIGHTS];
     } else {
         tmp = GlobalEffectsFreelist.top();
         GlobalEffectsFreelist.pop();
     }
     
     unpicklights();     //costly but necessary to get rid of pesky local enables that shoudln't be tagged to get reenabled
     for (int i = 0; i < GFX_MAX_LIGHTS; i++) {
         tmp[i] = ( 0 != (GLLights[i].options&OpenGLL::GL_ENABLED) );
         if (GLLights[i].options&OpenGLL::GL_ENABLED)
             glDisable( GL_LIGHT0+i );
     }
     //VSFileSystem::Fprintf (stderr,"PUSH %d",GlobalEffects.size());
     GlobalEffects.push( tmp );
     GlobalEffectsAmbient.push( _ambient_light[_currentContext] );
     GFXLightContextAmbient( GFXColor( 0, 0, 0, 1 ) );
 }

void GFXReloadDefaultShader ( )

Definition at line 373 of file gl_program.cpp.

References defaultprog, GFXCreateProgram(), glDeleteProgram_p, hifiprog, hifiProgramName, lowfiprog, lowfiProgramName, programChanged, programVersion, and VSFileSystem::vs_fprintf().

Referenced by doReloadShader().

 {
     VSFileSystem::vs_fprintf(stderr, "Reloading all shaders\n");
     
     // Increasing the timestamp makes all programs elsewhere recompile
     ++programVersion;
     
     bool islow = (lowfiprog == defaultprog);
     if (glDeleteProgram_p && defaultprog) {
         glDeleteProgram_p( lowfiprog );
         glDeleteProgram_p( hifiprog );
     }
     programChanged = true;
     if (islow) {
         hifiprog    = GFXCreateProgram( hifiProgramName.c_str(), hifiProgramName.c_str(), NULL );
         if (hifiprog == 0) hifiprog = GFXCreateProgram( lowfiProgramName.c_str(), lowfiProgramName.c_str(), NULL );
         lowfiprog   = GFXCreateProgram( lowfiProgramName.c_str(), lowfiProgramName.c_str(), NULL );
         if (lowfiprog == 0) lowfiprog = GFXCreateProgram( hifiProgramName.c_str(), hifiProgramName.c_str(), NULL );
         defaultprog = lowfiprog;
     } else {
         lowfiprog   = GFXCreateProgram( lowfiProgramName.c_str(), lowfiProgramName.c_str(), NULL );
         if (lowfiprog == 0) lowfiprog = GFXCreateProgram( hifiProgramName.c_str(), hifiProgramName.c_str(), NULL );
         hifiprog    = GFXCreateProgram( hifiProgramName.c_str(), hifiProgramName.c_str(), NULL );
         if (hifiprog == 0) hifiprog = GFXCreateProgram( lowfiProgramName.c_str(), lowfiProgramName.c_str(), NULL );
         defaultprog = hifiprog;
     }
 }

void GFXRestoreHudMode ( )

Definition at line 238 of file gl_matrix.cpp.

 {
     glMatrixMode( GL_MODELVIEW );
     glLoadIdentity();
     glMatrixMode( GL_PROJECTION );
     glLoadIdentity();
 }

void GFXSelectMaterial ( const unsigned int number)

Definition at line 131 of file gl_material.cpp.

References materialinfo, power, and selectedmaterial.

Referenced by Stars::Draw(), Mesh::DrawNow(), setupGLState(), GameUniverse::StartGFX(), and TerrainMakeActive().

 {
     if (1 || static_cast<int>(number) != selectedmaterial) { //FIXME Last time I checked true or anything was true
         float matvect[4];
         matvect[0] = materialinfo[number].ar;
         matvect[1] = materialinfo[number].ag;
         matvect[2] = materialinfo[number].ab;
         matvect[3] = materialinfo[number].aa;
         glMaterialfv( GL_FRONT, GL_AMBIENT, matvect );
 
         matvect[0] = materialinfo[number].dr;
         matvect[1] = materialinfo[number].dg;
         matvect[2] = materialinfo[number].db;
         matvect[3] = materialinfo[number].da;
         glMaterialfv( GL_FRONT, GL_DIFFUSE, matvect );
 
         matvect[0] = materialinfo[number].sr;
         matvect[1] = materialinfo[number].sg;
         matvect[2] = materialinfo[number].sb;
         matvect[3] = materialinfo[number].sa;
         glMaterialfv( GL_FRONT, GL_SPECULAR, matvect );
 
         matvect[0] = materialinfo[number].er;
         matvect[1] = materialinfo[number].eg;
         matvect[2] = materialinfo[number].eb;
         matvect[3] = materialinfo[number].ea;
         glMaterialfv( GL_FRONT, GL_EMISSION, matvect );
 
         glMaterialfv( GL_FRONT, GL_SHININESS, &materialinfo[number].power );
         selectedmaterial = number;
     }
 }

void GFXSelectMaterialHighlights	(	const unsigned int	number,
		const GFXColor &	ambient,
		const GFXColor &	diffuse,
		const GFXColor &	specular,
		const GFXColor &	emmissive
	)

Tells Graphics library which material to use on next polygon if lighting enabled.

Definition at line 96 of file gl_material.cpp.

References GFXColor::a, GFXColor::b, GFXColor::g, materialinfo, power, GFXColor::r, and selectedmaterial.

Referenced by SetupCloakState(), SetupEnvmapPass(), SetupGlowMapFourthPass(), SetupSpecMapFirstPass(), and SetupSpecMapSecondPass().

 {
     selectedmaterial = -1;
     float matvect[4];
     matvect[0] = materialinfo[number].ar*ambient.r*ambient.a;
     matvect[1] = materialinfo[number].ag*ambient.g*ambient.a;
     matvect[2] = materialinfo[number].ab*ambient.b*ambient.a;
     matvect[3] = materialinfo[number].aa*ambient.a;
     glMaterialfv( GL_FRONT, GL_AMBIENT, matvect );
 
     matvect[0] = materialinfo[number].dr*diffuse.r*diffuse.a;
     matvect[1] = materialinfo[number].dg*diffuse.g*diffuse.a;
     matvect[2] = materialinfo[number].db*diffuse.b*diffuse.a;
     matvect[3] = materialinfo[number].da*diffuse.a;
     glMaterialfv( GL_FRONT, GL_DIFFUSE, matvect );
 
     matvect[0] = materialinfo[number].sr*specular.r*specular.a;
     matvect[1] = materialinfo[number].sg*specular.g*specular.a;
     matvect[2] = materialinfo[number].sb*specular.b*specular.a;
     matvect[3] = materialinfo[number].sa*specular.a;
     glMaterialfv( GL_FRONT, GL_SPECULAR, matvect );
 
     matvect[0] = emissive.r*emissive.a;
     matvect[1] = emissive.g*emissive.a;
     matvect[2] = emissive.b*emissive.a;
     matvect[3] = emissive.a;
     glMaterialfv( GL_FRONT, GL_EMISSION, matvect );
 
     glMaterialfv( GL_FRONT, GL_SHININESS, &materialinfo[number].power );
 }

void GFXSelectTexture	(	int	handle,
		int	stage = `0`
	)

Selects the current texture as being "active" so further drawn objects will have it.

Definition at line 1126 of file gl_texture.cpp.

References activetexture, GFXActiveTexture(), gl_options, gl_options_t::Multitexture, and textures.

Referenced by StreamTexture::MakeActive(), PipelinedTexture::MakeActive(), Texture::MakeActive(), PipelinedTexture::MakeBothActive(), and PipelinedTexture::MakeLastActive().

 {
     if (stage && stage >= static_cast<int>(gl_options.Multitexture)) return;
     if (activetexture[stage] != handle) {
         GFXActiveTexture( stage );
         activetexture[stage] = handle;
         if ( gl_options.Multitexture || (stage == 0) )
             glBindTexture( textures[handle].targets, textures[handle].name );
     }
 }

GFXBOOL GFXSetCutoff ( const float cutoff)

Sets the intensity cutoff before picked lights are ignored.

Definition at line 214 of file gl_light.cpp.

References GFXFALSE, GFXTRUE, and intensity_cutoff.

Referenced by SetupGLLightGlobals().

 {
     if (ttcutoff < 0)
         return GFXFALSE;
     intensity_cutoff = ttcutoff;
     return GFXTRUE;
 }

GFXBOOL GFXSetLight	(	const int	light,
		const enum	LIGHT_TARGET,
		const GFXColor &	color
	)

Modifies the parameters of the given light.

Definition at line 287 of file gl_light.cpp.

References _llights, GFXFALSE, and GFXTRUE.

Referenced by GamePlanet::Draw().

 {
     if ( (*_llights)[light].Target() == -2 )
         return GFXFALSE;
     (*_llights)[light].ResetProperties( lt, color );
 
     return GFXTRUE;
 }

void GFXSetLightContext ( const int con_number)

Sets active light context (restores all gllights in such context)

Definition at line 336 of file gl_light.cpp.

References _ambient_light, _currentContext, _llights, _local_lights_dat, GFX_MAX_LIGHTS, OpenGLL::GLL_OFF, i, OpenGLLights::index, lighttable, OpenGLLights::options, and unpicklights().

Referenced by ClientServerSetLightContext(), GFXCreateLightContext(), GameUniverse::StartGFX(), and GameStarSystem::SwapIn().

 {
     unpicklights();
     int GLLindex = 0;
     unsigned int i;
     lighttable.Clear();
     _currentContext = con_number;
     _llights = &_local_lights_dat[con_number];
     glLightModelfv( GL_LIGHT_MODEL_AMBIENT, (GLfloat*) &(_ambient_light[con_number]) );
     //reset all lights so they arean't in GLLights
     for (i = 0; i < _llights->size(); i++)
         (*_llights)[i].Target() = -1;
     for (i = 0; i < _llights->size() && GLLindex < GFX_MAX_LIGHTS; i++)
         if ( (*_llights)[i].enabled() ) {
             if ( (*_llights)[i].LocalLight() ) {
                 (*_llights)[i].AddToTable();
             } else {
                 GLLights[GLLindex].index = -1;                 //make it clobber completley! no trace of old light.
                 (*_llights)[i].ClobberGLLight( GLLindex );
                 GLLindex++;
             }
         }
     for (; GLLindex < GFX_MAX_LIGHTS; GLLindex++) {
         GLLights[GLLindex].index   = -1;
         GLLights[GLLindex].options = OpenGLL::GLL_OFF;
         glDisable( GL_LIGHT0+GLLindex );
     }
 }

void GFXSetMaterial	(	unsigned int &	number,
		const GFXMaterial &	material
	)

Creates a new material given a material struct. Will search through already made materials for matching materials to minimize switching.

Definition at line 71 of file gfxlib_struct_server.cpp.

References i, int, and materialinfo.

Referenced by Mesh::PostProcessLoading(), Mesh::SetMaterial(), and GameUniverse::StartGFX().

71 {}

void GFXSetOptimalIntensity	(	const float	newint,
		const float	saturatevalue
	)

Sets the optimal intensity given that Optimal number of lights is fulfilled.

Definition at line 222 of file gl_light.cpp.

References optintense, optsat, and saturate().

Referenced by SetupGLLightGlobals().

 {
     optintense = intensity;
     optsat     = saturate;
 }

GFXBOOL GFXSetOptimalNumLights ( const int numlights)

Sets number of lights graphics can handle optimally.

Definition at line 228 of file gl_light.cpp.

References GFX_MAX_LIGHTS, GFX_OPTIMAL_LIGHTS, GFXFALSE, and GFXTRUE.

Referenced by SetupGLLightGlobals().

 {
     if (numLights > GFX_MAX_LIGHTS || numLights < 0)
         return GFXFALSE;
     GFX_OPTIMAL_LIGHTS = numLights;
     return GFXTRUE;
 }

void GFXSetPickName ( int name)

Definition at line 41 of file gl_pick.cpp.

 {
     glInitNames();
     glPushName( name );
     glLoadName( name );
     glGetError();
 }

GFXBOOL GFXSetSeparateSpecularColor ( const GFXBOOL spec)

Sets the light model to have separate specular color (if available)

Definition at line 236 of file gl_light.cpp.

References GFXFALSE, and GFXTRUE.

Referenced by RestoreEnvmapState(), RestoreSpecMapState(), SetupEnvmapPass(), SetupGLLightGlobals(), SetupSpecMapFirstPass(), and SetupSpecMapSecondPass().

 {
 #if !defined (_WIN32) && !defined (__CYGWIN__)
     if (spec) {
         glLightModeli( GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR );
     } else {
         glLightModeli( GL_LIGHT_MODEL_COLOR_CONTROL, GL_SINGLE_COLOR );
         return GFXFALSE;
     }
 #else
     return GFXFALSE;
 #endif
     return GFXTRUE;
 }

int GFXShaderConstant	(	int	name,
		Vector	value
	)

Definition at line 556 of file gl_program.cpp.

References GFXShaderConstant().

Referenced by GFXShaderConstant().

 {
     return GFXShaderConstant( name, v.i, v.j, v.k, 0 );
 }

int GFXShaderConstant	(	int	name,
		GFXColor	value
	)

Definition at line 551 of file gl_program.cpp.

References GFXColor::a, GFXColor::b, GFXColor::g, GFXShaderConstant(), and GFXColor::r.

 {
     return GFXShaderConstant( name, v.r, v.g, v.b, v.a );
 }

int GFXShaderConstant	(	int	name,
		const float *	value
	)

Definition at line 546 of file gl_program.cpp.

References GFXShaderConstant().

 {
     return GFXShaderConstant( name, values[0], values[1], values[2], values[3] );
 }

int GFXShaderConstant	(	int	name,
		float	v1,
		float	v2,
		float	v3,
		float	v4
	)

Definition at line 533 of file gl_program.cpp.

References glUniform4f_p.

 {
     if (1
 #ifndef __APPLE__
         && glUniform4f_p
 #endif
        ) {
         glUniform4f_p( name, v1, v2, v3, v4 );
         return 1;
     }
     return 0;
 }

int GFXShaderConstant	(	int	name,
		float	v1
	)

Definition at line 561 of file gl_program.cpp.

References glUniform1f_p.

 {
     if (1
 #ifndef __APPLE__
         && glUniform1f_p
 #endif
        ) {
         glUniform1f_p( name, v1 );
         return 1;
     }
     return 0;
 }

int GFXShaderConstant4v	(	int	name,
		unsigned int	numvals,
		const float *	value
	)

Definition at line 587 of file gl_program.cpp.

References glUniform4fv_p.

Referenced by GFXUploadLightState().

 {
     if (1
 #ifndef __APPLE__
         && glUniform4fv_p
 #endif
        ) {
         glUniform4fv_p( name, count, values );
         return 1;
     }
     return 0;
 }

int GFXShaderConstanti	(	int	name,
		int	value
	)

Definition at line 600 of file gl_program.cpp.

References glUniform1i_p.

Referenced by GFXUploadLightState().

 {
     if (1
 #ifndef __APPLE__
         && glUniform1i_p
 #endif
        ) {
         glUniform1i_p( name, value );
         return 1;
     }
     return 0;
 }

int GFXShaderConstantv	(	int	name,
		unsigned int	numvals,
		const float *	value
	)

Definition at line 574 of file gl_program.cpp.

References glUniform1fv_p.

Referenced by GFXUploadLightState().

 {
     if (1
 #ifndef __APPLE__
         && glUniform1fv_p
 #endif
        ) {
         glUniform1fv_p( name, count, values );
         return 1;
     }
     return 0;
 }

int GFXShaderConstantv	(	int	name,
		unsigned int	numvals,
		const int *	value
	)

Definition at line 613 of file gl_program.cpp.

References glUniform1i_p, and glUniform1iv_p.

 {
     if (1
 #ifndef __APPLE__
         && glUniform1i_p
 #endif
        ) {
         glUniform1iv_p( name, count, (GLint*) value );
         return 1;
     }
     return 0;
 }

bool GFXShaderReloaded ( )

Definition at line 463 of file gl_program.cpp.

References defaultprog, VegaConfig::getVariable(), GFXActivateShader(), GFXGetFramerate(), hifiprog, lowfiprog, XMLSupport::parse_bool(), programChanged, TOOFAST, TOOSLOW, and vs_config.

 {
     bool retval = programChanged;
     static bool framerate_changes_shader =
         XMLSupport::parse_bool( vs_config->getVariable( "graphics", "framerate_changes_shader", "false" ) );
     if (framerate_changes_shader) {
         switch ( GFXGetFramerate() )
         {
         case TOOSLOW:
             if (defaultprog) {
                 retval = true;
                 if (defaultprog == hifiprog)
                     defaultprog = lowfiprog;
                 else
                     defaultprog = 0;
                 GFXActivateShader( (char*) NULL );
             }
             break;
         case TOOFAST:
             if (defaultprog != hifiprog) {
                 retval = true;
                 if (defaultprog == 0)
                     defaultprog = lowfiprog;
                 else
                     defaultprog = hifiprog;
                 GFXActivateShader( (char*) NULL );
             }
             break;
         default:
             break;
         }
     }
     programChanged = false;
     return retval;
 }

void GFXShutdown ( )

Shuts down the graphics subsystem.

Definition at line 748 of file gl_init.cpp.

References gl_options_t::fullscreen, GFXDestroyAllLights(), GFXDestroyAllTextures(), gl_options, and winsys_shutdown().

Referenced by GameUniverse::~GameUniverse().

 {
     extern void GFXDestroyAllLights();
 
     GFXDestroyAllTextures();
     GFXDestroyAllLights();
     if (gl_options.fullscreen)
         winsys_shutdown();
 }

float GFXSphereInFrustum	(	const QVector &	Center,
		float	Radius
	)

checks if a sphere is in the currently loaded Frustum given its center and radius

Definition at line 10 of file gl_clip.cpp.

References frust, and GFXSphereInFrustum().

Referenced by ContinuousTerrain::Draw(), GameUnit< UnitType >::Draw(), GameUnit< UnitType >::DrawNow(), GFXSphereInFrustum(), and GameUnit< UnitType >::queryFrustum().

 {
     return GFXSphereInFrustum( frust, Cnt, radius );
 }

float GFXSphereInFrustum	(	double	f[6][4],
		const QVector &	Center,
		float	Radius
	)

Checks if a sphere is in the given frustum calculated by GFXCalculateFrustum. Used in Unit clipping.

Definition at line 140 of file gl_clip.cpp.

References d.

 {
     /*
      *  static float lasttime = GetElapsedTime();
      *  if (lasttime!=GetElapsedTime()) {
      *  DrawFrustum (f);
      *  lasttime = GetElapsedTime();
      *  }*/
     int    p;
     double d;
     for (p = 0; p < 5; p++) {
         //does not evaluate for yon
         d = f[p][0]*Cnt.i+f[p][1]*Cnt.j+f[p][2]*Cnt.k+f[p][3];
         if (d < 0) {
             //VSFileSystem::Fprintf (stderr,"cin %f",d);
             if (d <= -radius)
                 return 0;
         }
     }
     return d;
 }

CLIPSTATE GFXSpherePartiallyInFrustum	(	const Vector &	cent,
		const float	r
	)

Definition at line 23 of file gl_clip.cpp.

References BoxFrust, and GFXSpherePartiallyInFrustum().

Referenced by SphericalTransform::BoxInFrustum(), GFXSpherePartiallyInFrustum(), and GFXTransformedSpherePartiallyInFrustum().

 {
     return GFXSpherePartiallyInFrustum( BoxFrust, Cnt, radius );
 }

CLIPSTATE GFXSpherePartiallyInFrustum	(	double	f[6][4],
		const Vector &	cent,
		const float	r
	)

Definition at line 32 of file gl_clip.cpp.

References d, GFX_NOT_VISIBLE, GFX_PARTIALLY_VISIBLE, and GFX_TOTALLY_VISIBLE.

 {
     int       p;
     float     d;
     CLIPSTATE retval = GFX_TOTALLY_VISIBLE;
     for (p = 0; p < 6; p++) {
         //does not evaluate for yon
         d = f[p][0]*Cnt.i+f[p][1]*Cnt.j+f[p][2]*Cnt.k+f[p][3];
         if (d <= -radius)
             return GFX_NOT_VISIBLE;
         else if (d <= radius)
             retval = GFX_PARTIALLY_VISIBLE;
     }
     return retval;
 }

enum DEPTHFUNC GFXStencilFunc ( )

Returns the current stencil test function.

Definition at line 444 of file gl_state.cpp.

References cur_stencil_func.

 {
     return cur_stencil_func;
 }

void GFXStencilFunc	(	enum DEPTHFUNC *	pFunc,
		int *	pRef,
		int *	pMask
	)

Gets details about the current stancil compare function - Specify NULL for unwanted fields.

Definition at line 449 of file gl_state.cpp.

References cur_stencil_func, cur_stencil_func_mask, and cur_stencil_func_ref.

 {
     if (pFunc) *pFunc = cur_stencil_func;
     if (pRef) *pRef = cur_stencil_func_ref;
     if (pMask) *pMask = cur_stencil_func_mask;
 }

void GFXStencilFunc	(	enum DEPTHFUNC	sfunc,
		int	ref,
		unsigned int	mask
	)

Sets up a stencil compare function.

Definition at line 456 of file gl_state.cpp.

References ALWAYS, cur_stencil_func, cur_stencil_func_mask, cur_stencil_func_ref, EQUAL, GEQUAL, GREATER, LEQUAL, LESS, NEQUAL, and NEVER.

 {
     GLenum func;
     switch (sfunc)
     {
     case NEVER:
         func = GL_NEVER;
         break;
     case LESS:
         func = GL_LESS;
         break;
     case EQUAL:
         func = GL_EQUAL;
         break;
     case LEQUAL:
         func = GL_LEQUAL;
         break;
     case GREATER:
         func = GL_GREATER;
         break;
     case NEQUAL:
         func = GL_NOTEQUAL;
         break;
     case GEQUAL:
         func = GL_GEQUAL;
         break;
     case ALWAYS:
         func = GL_ALWAYS;
         break;
     default:
         func = GL_NEVER;
         break;
     }
     glStencilFunc( func, (GLint) ref, (GLuint) mask );
     cur_stencil_func      = sfunc;
     cur_stencil_func_ref  = ref;
     cur_stencil_func_mask = mask;
 }

unsigned int GFXStencilMask ( )

Returns the current stencil write mask.

Definition at line 583 of file gl_state.cpp.

References cur_stencil_mask.

 {
     return cur_stencil_mask;
 }

void GFXStencilMask ( unsigned int mask)

Sets the stencil write mask.

Definition at line 588 of file gl_state.cpp.

References cur_stencil_mask.

 {
     glStencilMask( (GLuint) mask );
     cur_stencil_mask = mask;
 }

void GFXStencilOp	(	enum STENCILOP *	pFail,
		enum STENCILOP *	pZfail,
		enum STENCILOP *	pZpass
	)

Gets the current stencil write operations - Specify NULL for unwanted fields.

Definition at line 495 of file gl_state.cpp.

References cur_stencil_op_f, cur_stencil_op_zf, and cur_stencil_op_zp.

 {
     if (pFail) *pFail = cur_stencil_op_f;
     if (pZfail) *pZfail = cur_stencil_op_zf;
     if (pZpass) *pZpass = cur_stencil_op_zp;
 }

void GFXStencilOp	(	enum STENCILOP	fail,
		enum STENCILOP	zfail,
		enum STENCILOP	zpass
	)

Sets up the stencil write operations.

Definition at line 502 of file gl_state.cpp.

References CLEAR, cur_stencil_op_f, cur_stencil_op_zf, cur_stencil_op_zp, DECR, INCR, INVERT, KEEP, and REPLACE.

 {
     GLenum ffunc, zffunc, zpfunc;
     switch (fail)
     {
     case KEEP:
         ffunc = GL_KEEP;
         break;
     case CLEAR:
         ffunc = GL_ZERO;
         break;
     case REPLACE:
         ffunc = GL_REPLACE;
         break;
     case INCR:
         ffunc = GL_INCR;
         break;
     case DECR:
         ffunc = GL_DECR;
         break;
     case INVERT:
         ffunc = GL_INVERT;
         break;
     default:
         ffunc = GL_KEEP;
         break;
     }
     switch (zfail)
     {
     case KEEP:
         zffunc = GL_KEEP;
         break;
     case CLEAR:
         zffunc = GL_ZERO;
         break;
     case REPLACE:
         zffunc = GL_REPLACE;
         break;
     case INCR:
         zffunc = GL_INCR;
         break;
     case DECR:
         zffunc = GL_DECR;
         break;
     case INVERT:
         zffunc = GL_INVERT;
         break;
     default:
         zffunc = GL_KEEP;
         break;
     }
     switch (zpass)
     {
     case KEEP:
         zpfunc = GL_KEEP;
         break;
     case CLEAR:
         zpfunc = GL_ZERO;
         break;
     case REPLACE:
         zpfunc = GL_REPLACE;
         break;
     case INCR:
         zpfunc = GL_INCR;
         break;
     case DECR:
         zpfunc = GL_DECR;
         break;
     case INVERT:
         zpfunc = GL_INVERT;
         break;
     default:
         zpfunc = GL_KEEP;
         break;
     }
     glStencilOp( ffunc, zffunc, zpfunc );
     cur_stencil_op_f  = fail;
     cur_stencil_op_zf = zfail;
     cur_stencil_op_zp = zpass;
 }

void GFXSubwindow	(	int	x,
		int	y,
		int	xsize,
		int	ysize
	)

Creates a subwindow with the current parameters for center and size.

Definition at line 327 of file gl_misc.cpp.

References g_game, game_data_t::x_resolution, and game_data_t::y_resolution.

Referenced by GFXSubwindow(), Camera::RestoreViewPort(), and Camera::UpdateGFX().

 {
     glViewport( x, y, xsize, ysize );
     glScissor( x, y, xsize, ysize );
     if (x == 0 && y == 0 && xsize == g_game.x_resolution && ysize == g_game.y_resolution)
         glDisable( GL_SCISSOR_TEST );
     else
         glEnable( GL_SCISSOR_TEST );
 }

void GFXSubwindow	(	float	x,
		float	y,
		float	xsize,
		float	ysize
	)

Definition at line 337 of file gl_misc.cpp.

References g_game, GFXSubwindow(), game_data_t::x_resolution, and game_data_t::y_resolution.

 {
     GFXSubwindow( int(x*g_game.x_resolution), int(y*g_game.y_resolution), int(xsize*g_game.x_resolution),
                  int(ysize*g_game.y_resolution) );
 }

void GFXTexCoord224f	(	const float	s,
		const float	t,
		const float	s2,
		const float	t2,
		const float	s3,
		const float	t3,
		const float	u3,
		const float	v3
	)

Specifies four texture coordinates for a given vertex (3 textures)

Definition at line 237 of file gl_misc.cpp.

References gl_options, glMultiTexCoord2fARB_p, glMultiTexCoord4fARB_p, and gl_options_t::Multitexture.

Referenced by GFXVertexList::RefreshDisplayList().

 {
 #if !defined (IRIX)
     if (gl_options.Multitexture) {
         glMultiTexCoord2fARB_p( GL_TEXTURE0_ARB, s, t );
         glMultiTexCoord2fARB_p( GL_TEXTURE1_ARB, s2, t2 );
         glMultiTexCoord4fARB_p( GL_TEXTURE2_ARB, s3, t3, u3, v3 );
     } else
 #endif
     {
         glTexCoord2f( s, t );
     }
 }

void GFXTexCoord2f	(	const float	s,
		const float	t
	)

Specifies a pair of texture coordinates for given vertex.

Definition at line 219 of file gl_misc.cpp.

Referenced by AnimationDraw(), ParticlePoint::Draw(), GuiTexture::draw(), VSSprite::Draw(), Animation::DrawAsVSSprite(), DrawDamageFlash(), DrawHUDSprite(), Animation::DrawNoTransform(), and Animation::DrawNow().

 {
     glTexCoord2f( s, t );
 }

void GFXTexCoord4f	(	const float	s,
		const float	t,
		const float	u,
		const float	v
	)

Specifies four texture coordinates for a given vertex (2 textures)

Definition at line 224 of file gl_misc.cpp.

References gl_options, glMultiTexCoord2fARB_p, and gl_options_t::Multitexture.

Referenced by VSSprite::Draw(), Animation::DrawAsVSSprite(), Animation::DrawNoTransform(), and Animation::DrawNow().

 {
 #if !defined (IRIX)
     if (gl_options.Multitexture) {
         glMultiTexCoord2fARB_p( GL_TEXTURE0_ARB, s, t );
         glMultiTexCoord2fARB_p( GL_TEXTURE1_ARB, u, v );
     } else
 #endif
     {
         glTexCoord2f( s, t );
     }
 }

void GFXTextureAddressMode	(	const ADDRESSMODE	mode,
		enum TEXTURE_TARGET	target = `TEXTURE2D`
	)

Sets texture to clamp or wrap texture coordinates.

Definition at line 258 of file gl_state.cpp.

References _GFXActiveTextureValid(), BORDER, CLAMP, CUBEMAP, DEFAULT_ADDRESS_MODE, GetGLTextureTarget(), GL_CLAMP_TO_BORDER_ARB, GL_CLAMP_TO_EDGE_EXT, MIRROR, TEXTURE1D, TEXTURE3D, and WRAP.

Referenced by Background::Draw(), GFXCreateTexture(), and Texture::MakeActive().

 {
     if ( !_GFXActiveTextureValid() ) return;
     GLenum tt = GetGLTextureTarget( target );
     float  BColor[4] = {0, 0, 0, 0};      //set border color to clear... dunno if we wanna change?
     GLenum wm1, wm2;
     switch (mode)
     {
     case DEFAULT_ADDRESS_MODE:
     case WRAP:
         wm1 = GL_REPEAT;
         wm2 = 0;
         break;
     case BORDER:
         wm1 = GL_CLAMP;
         wm2 = GL_CLAMP_TO_BORDER_ARB;
         glTexParameterfv( GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, BColor );
         //nobreak
     case CLAMP:
         wm1 = GL_CLAMP;
         wm2 = GL_CLAMP_TO_EDGE_EXT;
         break;
     case MIRROR:     //nope not goin here I hope nVidia extension?
     default:
         return;              //won't work
     }
     glTexParameteri( tt, GL_TEXTURE_WRAP_S, wm1 );
     if (target != TEXTURE1D) 
         glTexParameteri( tt, GL_TEXTURE_WRAP_T, wm1 );
     if (target == TEXTURE3D || target == CUBEMAP) 
         glTexParameteri( tt, GL_TEXTURE_WRAP_R, wm1 );
     if (wm2) {
         glTexParameteri( tt, GL_TEXTURE_WRAP_S, wm2 );
         if (target != TEXTURE1D) 
             glTexParameteri( tt, GL_TEXTURE_WRAP_T, wm2 );
         if (target == TEXTURE3D || target == CUBEMAP) 
             glTexParameteri( tt, GL_TEXTURE_WRAP_R, wm2 );
     }
 }

void GFXTextureCoordGenMode	(	int	stage,
		GFXTEXTURECOORDMODE	tex,
		const float	params[4],
		const float	paramt[4]
	)

Definition at line 1075 of file gl_texture.cpp.

References CUBE_MAP_GEN, EYE_LINEAR_GEN, GFXActiveTexture(), gl_options, gl_options_t::Multitexture, NO_GEN, OBJECT_LINEAR_GEN, and SPHERE_MAP_GEN.

Referenced by GameStarSystem::activateLightMap(), Background::Draw(), VSSprite::Draw(), Animation::DrawAsVSSprite(), Animation::DrawNoTransform(), Animation::DrawNow(), GFXInit(), RestoreEnvmapState(), RestoreSpecMapState(), and SetupSpecMapFirstPass().

 {
     if (stage && stage >= static_cast<int>(gl_options.Multitexture)) return;
     GFXActiveTexture( stage );
     switch (tex)
     {
     case NO_GEN:
         glDisable( GL_TEXTURE_GEN_S );
         glDisable( GL_TEXTURE_GEN_T );
         glDisable( GL_TEXTURE_GEN_R );
         break;
     case EYE_LINEAR_GEN:
         glTexGeni( GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR );
         glTexGenfv( GL_S, GL_EYE_PLANE, params );
         glTexGeni( GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR );
         glTexGenfv( GL_T, GL_EYE_PLANE, paramt );
         glEnable( GL_TEXTURE_GEN_S );
         glEnable( GL_TEXTURE_GEN_T );
         glDisable( GL_TEXTURE_GEN_R );
         break;
     case OBJECT_LINEAR_GEN:
         glTexGeni( GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR );
         glTexGenfv( GL_S, GL_OBJECT_PLANE, params );
         glTexGeni( GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR );
         glTexGenfv( GL_T, GL_OBJECT_PLANE, paramt );
         glEnable( GL_TEXTURE_GEN_S );
         glEnable( GL_TEXTURE_GEN_T );
         glDisable( GL_TEXTURE_GEN_R );
         break;
     case SPHERE_MAP_GEN:
         glTexGeni( GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP );
         glTexGeni( GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP );
         glEnable( GL_TEXTURE_GEN_S );
         glEnable( GL_TEXTURE_GEN_T );
         glDisable( GL_TEXTURE_GEN_R );
         break;
     case CUBE_MAP_GEN:
 #ifdef NV_CUBE_MAP
         glTexGeni( GL_S, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV );
         glTexGeni( GL_T, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV );
         glTexGeni( GL_R, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_NV );
         glEnable( GL_TEXTURE_GEN_S );
         glEnable( GL_TEXTURE_GEN_T );
         glEnable( GL_TEXTURE_GEN_R );
 #else
         assert( 0 );
 #endif
         break;
     }
 }

void GFXTextureEnv	(	int	stage,
		GFXTEXTUREENVMODES	mode,
		float	arg2 = `0`
	)

Definition at line 1137 of file gl_texture.cpp.

References GFXActiveTexture(), GFXADDSIGNEDTEXTURE, GFXADDTEXTURE, GFXCOMPOSITETEXTURE, GFXDETAILTEXTURE, GFXINTERPOLATETEXTURE, GFXMODULATETEXTURE, GFXREPLACETEXTURE, gl_options, and gl_options_t::Multitexture.

Referenced by GameStarSystem::activateLightMap(), AnimationDraw(), Background::Draw(), VSSprite::Draw(), Animation::DrawAsVSSprite(), Animation::DrawNoTransform(), Animation::DrawNow(), Mesh::DrawNow(), GFXInit(), AnimatedTexture::MakeActive(), Beam::ProcessDrawQueue(), RestoreEnvmapState(), RestoreSpecMapState(), SetupEnvmapPass(), AnimatedTexture::SetupPass(), SetupSpecMapFirstPass(), and SetupSpecMapSecondPass().

 {
     if (stage && stage >= static_cast<int>(gl_options.Multitexture)) return;
     GLenum type;
     GFXActiveTexture( stage );
     switch (mode)
     {
     case GFXREPLACETEXTURE:
         type = GL_REPLACE;
         goto ENVMODE;
     case GFXADDTEXTURE:
         type = GL_ADD;
         goto ENVMODE;
     case GFXMODULATETEXTURE:
         type = GL_MODULATE;
 ENVMODE:
         glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, type );
         break;
     case GFXINTERPOLATETEXTURE:
         glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB );
         glTexEnvi( GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_PREVIOUS_ARB );
         glTexEnvi( GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR );
         glTexEnvi( GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_PREVIOUS_ARB );
         glTexEnvi( GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB, GL_SRC_ALPHA );
         glTexEnvi( GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_TEXTURE );
         glTexEnvi( GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, GL_SRC_COLOR );
         glTexEnvi( GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_ARB, GL_TEXTURE );
         glTexEnvi( GL_TEXTURE_ENV, GL_OPERAND1_ALPHA_ARB, GL_SRC_ALPHA );
         glTexEnvi( GL_TEXTURE_ENV, GL_SOURCE2_RGB_ARB, GL_CONSTANT );
         glTexEnvi( GL_TEXTURE_ENV, GL_OPERAND2_RGB_ARB, GL_SRC_ALPHA );
         glTexEnvi( GL_TEXTURE_ENV, GL_SOURCE2_ALPHA_ARB, GL_CONSTANT );
         glTexEnvi( GL_TEXTURE_ENV, GL_OPERAND2_ALPHA_ARB, GL_SRC_ALPHA );
         {
             GLfloat arg2v[4] = {
                 0, 0, 0, 1.0-arg2
             };
             glTexEnvfv( GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, arg2v );
         }
         glTexEnvi( GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_INTERPOLATE_ARB );
         glTexEnvi( GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_INTERPOLATE_ARB );
         glTexEnvi( GL_TEXTURE_ENV, GL_RGB_SCALE_ARB, 1 );
         glTexEnvi( GL_TEXTURE_ENV, GL_ALPHA_SCALE, 1 );
         break;
     case GFXCOMPOSITETEXTURE:
         glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB );
         glTexEnvi( GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_PREVIOUS_ARB );
         glTexEnvi( GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR );
         glTexEnvi( GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_CONSTANT );
         glTexEnvi( GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB, GL_SRC_ALPHA );
         glTexEnvi( GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_TEXTURE );
         glTexEnvi( GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, GL_SRC_COLOR );
         glTexEnvi( GL_TEXTURE_ENV, GL_SOURCE2_RGB_ARB, GL_TEXTURE );
         glTexEnvi( GL_TEXTURE_ENV, GL_OPERAND2_RGB_ARB, GL_ONE_MINUS_SRC_ALPHA );
         {
             GLfloat arg2v[4] = {
                 0, 0, 0, arg2
             };
             glTexEnvfv( GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, arg2v );
         }
         glTexEnvi( GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_INTERPOLATE_ARB );
         glTexEnvi( GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_REPLACE );
         glTexEnvi( GL_TEXTURE_ENV, GL_RGB_SCALE_ARB, 1 );
         glTexEnvi( GL_TEXTURE_ENV, GL_ALPHA_SCALE, 1 );
         break;
     case GFXADDSIGNEDTEXTURE:
         glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB );
         glTexEnvi( GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_PREVIOUS_ARB );
         glTexEnvi( GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR );
         glTexEnvi( GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_PREVIOUS_ARB );
         glTexEnvi( GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_TEXTURE );
         glTexEnvi( GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, GL_SRC_COLOR );
         glTexEnvi( GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_ADD_SIGNED_ARB );
         glTexEnvi( GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_REPLACE );
         glTexEnvi( GL_TEXTURE_ENV, GL_RGB_SCALE_ARB, 1 );
         glTexEnvi( GL_TEXTURE_ENV, GL_ALPHA_SCALE, 1 );
         break;
     case GFXDETAILTEXTURE:
         glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB );
         glTexEnvi( GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_PREVIOUS_ARB );
         glTexEnvi( GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_PREVIOUS_ARB );
         glTexEnvi( GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR );
         glTexEnvi( GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB, GL_SRC_ALPHA );
         glTexEnvi( GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_TEXTURE );
         glTexEnvi( GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_ARB, GL_TEXTURE );
         glTexEnvi( GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, GL_SRC_COLOR );
         glTexEnvi( GL_TEXTURE_ENV, GL_OPERAND1_ALPHA_ARB, GL_SRC_ALPHA );
         glTexEnvi( GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_MODULATE );
         glTexEnvi( GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_MODULATE );
         glTexEnvi( GL_TEXTURE_ENV, GL_RGB_SCALE_ARB, 2 );
         glTexEnvi( GL_TEXTURE_ENV, GL_ALPHA_SCALE, 2 );
         break;
     }
 }

void GFXTextureWrap	(	int	stage,
		GFXTEXTUREWRAPMODES	mode,
		enum TEXTURE_TARGET	target = `TEXTURE2D`
	)

Definition at line 1238 of file gl_texture.cpp.

References GetGLTextureTarget(), GFXActiveTexture(), GFXBORDERTEXTURE, GFXCLAMPTEXTURE, GFXREPEATTEXTURE, GL_CLAMP_TO_BORDER_ARB, GL_CLAMP_TO_EDGE_EXT, gl_options, gl_options_t::Multitexture, TEXTURE1D, and TEXTURE3D.

 {
     if (stage && stage >= static_cast<int>(gl_options.Multitexture)) return;
     GFXActiveTexture( stage );
     GLenum tt = GetGLTextureTarget( target );
     GLenum e1 = GL_REPEAT;
     GLenum e2 = 0;
     switch (mode)
     {
     case GFXCLAMPTEXTURE:
         e1 = GL_CLAMP;
         e2 = GL_CLAMP_TO_EDGE_EXT;
         break;
     case GFXREPEATTEXTURE:
         e1 = GL_REPEAT;
         e2 = 0;
         break;
     case GFXBORDERTEXTURE:
         e1 = GL_CLAMP;
         e2 = GL_CLAMP_TO_BORDER_ARB;
         break;
     }
     glTexParameteri( tt, GL_TEXTURE_WRAP_S, e1 );
     if (target != TEXTURE1D) glTexParameteri( tt, GL_TEXTURE_WRAP_T, e1 );
     if (target == TEXTURE3D) glTexParameteri( tt, GL_TEXTURE_WRAP_R, e1 );
     if (e2) {
         glTexParameteri( tt, GL_TEXTURE_WRAP_S, e2 );
         if (target != TEXTURE1D) glTexParameteri( tt, GL_TEXTURE_WRAP_T, e2 );
         if (target == TEXTURE3D) glTexParameteri( tt, GL_TEXTURE_WRAP_R, e2 );
     }
 }

void GFXToggleTexture	(	bool	enable,
		int	whichstage,
		enum TEXTURE_TARGET	target = `TEXTURE2D`
	)

Definition at line 167 of file gl_state.cpp.

References bTex, GetGLTextureTarget(), GFXActiveTexture(), gl_options, and gl_options_t::Multitexture.

Referenced by GameStarSystem::activateLightMap(), Bolt::Draw(), Background::Draw(), VSSprite::Draw(), Animation::DrawAsVSSprite(), PaintText::drawLines(), Animation::DrawNoTransform(), Animation::DrawNow(), Mesh::DrawNow(), GFXInit(), Beam::ProcessDrawQueue(), Mesh::ProcessDrawQueue(), RestoreEnvmapState(), RestoreFirstPassState(), SetupEnvmapPass(), and SetupSpecMapFirstPass().

 {
     if ( (whichstage < static_cast<int>(gl_options.Multitexture)) || (whichstage == 0) ) {
         GLenum tt  = GetGLTextureTarget( target );
         GLenum btt = (enable ? tt : 0);
         if (bTex[whichstage] != btt) {
             GFXActiveTexture( whichstage );
             if (bTex[whichstage])
                 glDisable( bTex[whichstage] );
             if (enable)
                 glEnable( bTex[whichstage] = tt );
 
             else
                 bTex[whichstage] = 0;
         }
     }
 }

GFXBOOL GFXTransferSubTexture	(	unsigned char *	buffer,
		int	handle,
		int	x,
		int	y,
		unsigned int	width,
		unsigned int	height,
		enum TEXTURE_IMAGE_TARGET	image2D = `TEXTURE_2D`
	)

Definition at line 683 of file gl_texture.cpp.

References GetImageTarget(), GFXTRUE, and textures.

Referenced by PipelinedTexture::endMutate().

 {
     GLenum image2D = GetImageTarget( imagetarget );
     glBindTexture( textures[handle].targets, textures[handle].name );
 
 //internalformat = GetTextureFormat (handle);
 
     glTexSubImage2D( image2D, 0, x, y, width, height, textures[handle].textureformat, GL_UNSIGNED_BYTE, buffer );
     return GFXTRUE;
 }

GFXBOOL GFXTransferTexture	(	unsigned char *	buffer,
		int	handle,
		int	inWidth,
		int	inHeight,
		enum TEXTUREFORMAT	internalformat,
		enum TEXTURE_IMAGE_TARGET	image2D = `TEXTURE_2D`,
		int	max_texture_dimension = `65536`,
		GFXBOOL	detailtexture = `GFXFALSE`,
		unsigned int	pageIndex = `0`
	)

Transfers texture to the graphics card with given buffer in previously specified format. Scales texture approrpiately to Max texture sizes gotten from vid card

Definition at line 700 of file gl_texture.cpp.

References gl_options_t::compression, ddsDecompress(), DownSampleTexture(), DXT1, DXT1RGBA, DXT3, DXT5, GetImageTarget(), GetImageTargetName(), GetTextureFormat(), VegaConfig::getVariable(), GFXFALSE, GFXTransferTexture(), GFXTRUE, gl_options, glColorTable_p, glCompressedTexImage2D_p, i, isPowerOfTwo(), j, gl_options_t::max_texture_dimension, MAX_TEXTURE_SIZE, gl_options_t::mipmap, MIPMAP, PALETTE8, gl_options_t::PaletteExt, XMLSupport::parse_bool(), XMLSupport::parse_int(), PNGPALETTE8, PNGRGB24, PNGRGBA32, RGB16, RGB24, RGB32, RGBA16, RGBA32, gl_options_t::s3tc, size, textures, TRILINEAR, vs_config, and VSFileSystem::vs_dprintf().

Referenced by PipelinedTexture::Clone(), GFXTransferTexture(), PipelinedTexture::PipelinedTexture(), StreamTexture::StreamTexture(), Texture::Transfer(), and StreamTexture::UnMap().

 {
     if (handle < 0)
         return GFXFALSE;
     int    error   = 0;
 
     int    logsize = 1;
     int    logwid  = 1;
     unsigned char *data    = NULL;
     unsigned char *tempbuf = NULL;
     GLenum internalformat;
     GLenum image2D   = GetImageTarget( imagetarget );
     glBindTexture( textures[handle].targets, textures[handle].name );
     int    blocksize = 16;
     bool   comptemp  = gl_options.compression;
 
     //Read in the number of mipmaps from buffer
     int    offset1   = 2;
     int    offset2;
     int    mips = 0;
     if (internformat >= DXT1 && internformat <= DXT5) {
         mips = 0;
         if (buffer[0]) mips = mips*10+(buffer[0]-'0');
         if (buffer[1]) mips = mips*10+(buffer[1]-'0');
     }
     if (inWidth > 0)
         textures[handle].iwidth = textures[handle].width = inWidth;
     if (inHeight > 0)
         textures[handle].iheight = textures[handle].height = inHeight;
     //This code i believe is executed if our texture isn't power of two
     if ( ( textures[handle].mipmapped&(TRILINEAR|MIPMAP) )
         && ( !isPowerOfTwo( textures[handle].width, logwid ) || !isPowerOfTwo( textures[handle].height, logsize ) ) ) {
         static unsigned char NONPOWEROFTWO[1024] = {
             255, 127, 127, 255,
             255, 255, 0,   255,
             255, 255, 0,   255,
             255, 127, 127, 255
         };
         buffer = NONPOWEROFTWO;
         textures[handle].width  = 2;
         textures[handle].height = 2;
         //assert (false);
     }
     logsize = logsize > logwid ? logsize : logwid;
     //By default, if we have no limit set, aux_texture sends us a high number
     //for the max dimension, so that we know to grep the GL max number.
     //Otherwise maxdimension is set by some user argument based on quality settings.
     if (maxdimension == 65536)
         maxdimension = gl_options.max_texture_dimension;
     VSFileSystem::vs_dprintf( 3,
                               "Transferring %dx%d texture, page %d (eff: %dx%d - limited at %d - %d mips), onto name %d (%s)\n",
                               textures[handle].iwidth,
                               textures[handle].iheight,
                               pageIndex,
                               textures[handle].width,
                               textures[handle].height,
                               maxdimension,
                               mips,
                               textures[handle].name,
                               GetImageTargetName( imagetarget )
                             );
     if (maxdimension == 44) {
         detail_texture = 0;
         maxdimension   = 256;
         if (internformat == DXT1 || internformat == DXT1RGBA)
             blocksize = 8;
         glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
         glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
         if (internformat >= DXT1 && internformat <= DXT5) {
             if (textures[handle].width > 8 && textures[handle].height > 8 && mips > 0) {
                 offset1 += ( (textures[handle].width+3)/4 )*( (textures[handle].height+3)/4 )*blocksize;
                 if (textures[handle].width > 1) textures[handle].width   >>= 1;
                 if (textures[handle].height > 1) textures[handle].height  >>= 1;
                 if (textures[handle].iwidth > 1) textures[handle].iwidth  >>= 1;
                 if (textures[handle].iheight > 1) textures[handle].iheight >>= 1;
                 --mips;
             }
         }
     }
     //If we are DDS, we can scale to max dimension by choosing a pre-made mipmap.
     if (internformat == DXT1 || internformat == DXT1RGBA)
         blocksize = 8;
     if (internformat >= DXT1 && internformat <= DXT5) {
         while ( (textures[handle].width > maxdimension || textures[handle].height > maxdimension) && mips > 0 ) {
             offset1 += ( (textures[handle].width+3)/4 )*( (textures[handle].height+3)/4 )*blocksize;
             if (textures[handle].width > 1) textures[handle].width   >>= 1;
             if (textures[handle].height > 1) textures[handle].height  >>= 1;
             if (textures[handle].iwidth > 1) textures[handle].iwidth  >>= 1;
             if (textures[handle].iheight > 1) textures[handle].iheight >>= 1;
             --mips;
         }
         offset2 = offset1;
         int w = textures[handle].width;
         int h = textures[handle].height;
         for (int i = 0; i < mips; ++i) {
             offset2 += ( (w+3)/4 )*( (h+3)/4 )*blocksize;
             if (w > 1) w >>= 1;
             if (h > 1) h >>= 1;
         }
     } else {
         //If we're not DDS, we have to generate a scaled version of the image
         if (textures[handle].iwidth > maxdimension || textures[handle].iheight > maxdimension || textures[handle].iwidth
             > MAX_TEXTURE_SIZE || textures[handle].iheight > MAX_TEXTURE_SIZE) {
 #if !defined (GL_COLOR_INDEX8_EXT)
             if (internformat != PALETTE8) {
 #else
             if (internformat != PALETTE8 || gl_options.PaletteExt) {
 #endif
                 textures[handle].height = textures[handle].iheight;
                 textures[handle].width  = textures[handle].iwidth;
                 DownSampleTexture( &tempbuf,
                                    buffer,
                                    textures[handle].height,
                                    textures[handle].width,
                                    ( internformat == PALETTE8 ? 1 : (internformat == RGBA32 ? 4 : 3) )*sizeof (unsigned char),
                                    handle,
                                    maxdimension,
                                    maxdimension,
                                    1 );
                 buffer = tempbuf;
                 VSFileSystem::vs_dprintf( 2, "Downsampled %dx%d texture (target: %dx%d - limited at %d)\n",
                                           textures[handle].iwidth,
                                           textures[handle].iheight,
                                           textures[handle].width,
                                           textures[handle].height,
                                           maxdimension
                                         );
             }
             offset2 = 2;
         } else {
             offset2 = offset1;
             int w = textures[handle].width;
             int h = textures[handle].height;
             switch (internformat)
             {
             case PALETTE8:
                 offset2 += (w*h);
                 break;
             case RGB16:
             case RGBA16:
                 offset2 += (w*h)*2;
                 break;
             case RGB24:
                 offset2 += (w*h)*3;
                 break;
             case RGBA32:
             case RGB32:
                 offset2 += (w*h)*4;
                 break;
             case DXT1:
             case DXT1RGBA:
                 offset2 += ( ( (w+3)/4 )*( (h+3)/4 ) )*8;
                 break;
             case DXT3:
             case DXT5:
                 offset2 += ( ( (w+3)/4 )*( (h+3)/4 ) )*16;
                 break;
             case PNGPALETTE8:
                 offset2 += (w*h);
                 break;
             case PNGRGB24:
                 offset2 += (w*h)*3;
                 break;
             case PNGRGBA32:
                 offset2 += (w*h)*4;
                 break;
             default:
                 offset2  = 2;
             }
         }
     }
     //skip to desired page
     offset1 += pageIndex*(offset2-2);
 
     int height = textures[handle].height;
     int width  = textures[handle].width;
     //If s3tc compression is disabled, our DDS files must be software decompressed
     if (internformat >= DXT1 && internformat <= DXT5 && !gl_options.s3tc) {
         unsigned char *tmpbuffer = buffer+offset1;
         ddsDecompress( tmpbuffer, data, internformat, textures[handle].height, textures[handle].width );
         buffer = data;
         internformat = RGBA32;
         textures[handle].textureformat = GL_RGBA;
     }
     if (internformat != PALETTE8 && internformat != PNGPALETTE8) {
         internalformat = GetTextureFormat( internformat );
         if ( ( ( textures[handle].mipmapped&(TRILINEAR|MIPMAP) ) && gl_options.mipmap >= 2 ) || detail_texture ) {
             if (detail_texture) {
                 static FILTER fil =
                     XMLSupport::parse_bool( vs_config->getVariable( "graphics", "detail_texture_trilinear",
                                                                     "true" ) ) ? TRILINEAR : MIPMAP;
                 textures[handle].mipmapped = fil;
                 glTexParameteri( textures[handle].targets, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
                 if (fil&TRILINEAR)
                     glTexParameteri( textures[handle].targets, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR );
                 else
                     glTexParameteri( textures[handle].targets, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST );
             }
             XMLSupport::parse_int( vs_config->getVariable( "graphics", "detail_texture_full_color", "1" ) );
             //If we are DDS and we need to generate mipmaps (almost everything gets sent here, even non-3d visuals)
             if (internformat >= DXT1 && internformat <= DXT5) {
                 int size = 0;
                 int i    = 0;
                 unsigned int offset = 0;
                 //The following takes into account C/C++'s catenation of floats to int
                 //by adding 3, we ensure that when width or height is 1, we get a 1 rather than 0
                 //from the division by 4. Because of catenation, all other numbers will result with
                 //the expected number as if the +3 wasn't there. same as max(1,width/4)
                 size = ( (width+3)/4 )*( (height+3)/4 )*blocksize;
                 for (i = 0; i < mips; ++i) {
                     glCompressedTexImage2D_p( image2D, i, internalformat, width, height, 0, size, buffer+offset1+offset );
                     //We halve width and height until they reach 1, or i == mips
                     if (width != 1)
                         width >>= 1;
                     if (height != 1)
                         height >>= 1;
                     if (i < mips-1)
                         offset += size;
                     size = ( (width+3)/4 )*( (height+3)/4 )*blocksize;
                 }
                 /* HACK */
                 //This is a workaround for ani_texture which hates not having
                 //mipmaps.
                 if (mips == 0) {
                     size = ( (width+3)/4 )*( (height+3)/4 )*blocksize;
                     //We need to reverse some parameters that are set cuz
                     //we're supposed to have mipmaps here.  But ani_texture hates us.
                     glTexParameteri( textures[handle].targets, GL_TEXTURE_BASE_LEVEL, 0 );
                     glTexParameteri( textures[handle].targets, GL_TEXTURE_MAX_LEVEL, 0 );
                     glCompressedTexImage2D_p( image2D, 0, internalformat, width, height, 0, size, buffer+offset1 );
                 }
                 /* END HACK */
             } else {
                 //We want mipmaps but we have uncompressed data
                 gluBuild2DMipmaps( image2D,
                                    internalformat,
                                    textures[handle].width,
                                    textures[handle].height,
                                    textures[handle].textureformat,
                                    GL_UNSIGNED_BYTE,
                                    buffer );
             }
             if (tempbuf)
                 free( tempbuf );
             tempbuf = NULL;
         } else {
             //WE HAVE NO MIPMAPS HERE
             if (internformat >= DXT1 && internformat <= DXT5) {
                 int size = 0;
                 size = ( (width+3)/4 )*( (height+3)/4 )*blocksize;
                 //force GL to only display our one texture (just in case)
                 glTexParameteri( textures[handle].targets, GL_TEXTURE_BASE_LEVEL, 0 );
                 glTexParameteri( textures[handle].targets, GL_TEXTURE_MAX_LEVEL, 0 );
                 glCompressedTexImage2D_p( image2D, 0, internalformat, width, height, 0, size, buffer+offset1 );
             } else {
                 glTexImage2D( image2D,
                               0,
                               internalformat,
                               textures[handle].width,
                               textures[handle].height,
                               0,
                               textures[handle].textureformat,
                               GL_UNSIGNED_BYTE,
                               buffer );
             }
         }
     } else {
         //THIS IS 8bpp LAND
         internalformat = GetTextureFormat( internformat );
         //IRIX has no GL_COLOR_INDEX8 extension
 #if defined (GL_COLOR_INDEX8_EXT)
         if (gl_options.PaletteExt) {
             error = glGetError();
             glColorTable_p( textures[handle].targets, GL_RGBA, 256, GL_RGBA, GL_UNSIGNED_BYTE, textures[handle].palette );
             error = glGetError();
             if (error) {
                 if (tempbuf)
                     free( tempbuf );
                 gl_options.compression = comptemp;
                 if (data)
                     free( data );
                 return GFXFALSE;
             }
             if ( ( textures[handle].mipmapped&(MIPMAP|TRILINEAR) ) && gl_options.mipmap >= 2 )
                 gluBuild2DMipmaps( image2D,
                                    GL_COLOR_INDEX8_EXT,
                                    textures[handle].width,
                                    textures[handle].height,
                                    GL_COLOR_INDEX,
                                    GL_UNSIGNED_BYTE,
                                    buffer );
             else
                 glTexImage2D( image2D,
                               0,
                               GL_COLOR_INDEX8_EXT,
                               textures[handle].width,
                               textures[handle].height,
                               0,
                               GL_COLOR_INDEX,
                               GL_UNSIGNED_BYTE,
                               buffer );
         } else
 #endif
         {
             int nsize = 4*textures[handle].iheight*textures[handle].iwidth;
             unsigned char *tbuf = (unsigned char*) malloc( sizeof (unsigned char)*nsize );
             //textures[handle].texture = tbuf;
             int j     = 0;
             for (int i = 0; i < nsize; i += 4) {
                 tbuf[i]   = textures[handle].palette[4*buffer[j]];
                 tbuf[i+1] = textures[handle].palette[4*buffer[j]+1];
                 tbuf[i+2] = textures[handle].palette[4*buffer[j]+2];
                 //used to be 255
                 tbuf[i+3] = textures[handle].palette[4*buffer[j]+3];
                 j++;
             }
             GFXTransferTexture(
                 tbuf, handle,
                 textures[handle].iwidth, textures[handle].iheight,
                 RGBA32, imagetarget, maxdimension, detail_texture );
             free( tbuf );
         }
     }
     if (tempbuf)
         free( tempbuf );
     gl_options.compression = comptemp;
     if (data)
         free( data );
     return GFXTRUE;
 }

CLIPSTATE GFXTransformedBoxInFrustum	(	const Vector &	min,
		const Vector &	max
	)

Definition at line 18 of file gl_clip.cpp.

References frust, and GFXBoxInFrustum().

 {
     return GFXBoxInFrustum( frust, min, max );
 }

CLIPSTATE GFXTransformedSpherePartiallyInFrustum	(	const Vector &	cent,
		const float	r
	)

Definition at line 27 of file gl_clip.cpp.

References frust, and GFXSpherePartiallyInFrustum().

 {
     return GFXSpherePartiallyInFrustum( frust, Cnt, radius );
 }

void GFXTranslateModel ( const QVector & r)

Definition at line 175 of file gl_matrix.cpp.

References GFXMatrices::model, Matrix::p, TransformNormal(), and ViewToModel().

Referenced by Stars::Draw(), and ParticleTrail::DrawAndUpdate().

 {
     model.p += TransformNormal( model, a );
     ViewToModel();
 }

void GFXTranslateProjection ( const Vector & r)

Translates the current "mode" matrix by a given vector.

Definition at line 181 of file gl_matrix.cpp.

References ConstructAndLoadProjection(), and GFXMatrices::projection.

 {
     projection[12] += a.i*projection[0]+a.j*projection[4]+a.k*projection[8];
     projection[13] += a.i*projection[1]+a.j*projection[5]+a.k*projection[9];
     projection[14] += a.i*projection[2]+a.j*projection[6]+a.k*projection[10];
     ConstructAndLoadProjection();
 }

void GFXTranslateView ( const QVector & r)

Definition at line 165 of file gl_matrix.cpp.

References Matrix::p, TransformNormal(), GFXMatrices::view, and ViewToModel().

 {
     view.p += TransformNormal( view, a );
     //glPopMatrix();
     //glLoadIdentity();
     //glTranslatef(-view[12],-view[13],-view[14]);
     //glPushMatrix();
     ViewToModel();
 }

void GFXUploadLightState	(	int	max_light_location,
		int	active_light_array,
		int	apparent_light_size_array,
		bool	shader,
		vector< int >::const_iterator	begin,
		vector< int >::const_iterator	end
	)

Definition at line 14 of file gl_light_state.cpp.

References gfx_light::ContextSwitchClobberLight(), gfx_light::enabled(), float, GFXLight::getPosition(), GFXLight::getSize(), GFX_MAX_LIGHTS, GFXGetMatrixModel(), GFXLoadIdentity(), GFXLoadMatrixModel(), GFXShaderConstant4v(), GFXShaderConstanti(), GFXShaderConstantv(), i, M_PI, MODEL, Matrix::p, QVector, and UniverseUtil::sqrt().

 {
     // FIXME: (klauss) Very bad thing: static variables initialized with heap-allocated arrays...
     static GLint *lightData = new GLint[GFX_MAX_LIGHTS];
     static float *lightSizes = new float[GFX_MAX_LIGHTS*4];
     
     Matrix modelview;
     
     // if we're using shaders, we'll need the modelview matrix
     // to properly compute light-model apparent light sizes
     GFXGetMatrixModel(modelview);
     
     size_t maxval = 0;
     size_t i = 0;
     
     for (vector<int>::const_iterator lightit = begin; lightit != end; ++i, ++lightit) {
         const gfx_light &light = (*_llights)[*lightit];
         if (light.enabled()) {
             lightData[i] = 1;
             maxval = i;
             
             // Only bother with apparent light size if there is a shader
             if (shader) {
                 // We'll compute apparent light size by transforming the origin
                 // position by the modelview matrix, and computing the apparent
                 // size of a lightsource to that center and the proper size
                 // as entered in _gllights.
                 //
                 // This assumes the modelview matrix will be already set to
                 // the proper value when the light is enabled. It should.
                 //
                 // NOTE: We explicitly ignore rotation and scaling parts of the
                 // matrix. For one, rotation is meaningless for this calculation.
                 // For two, scaling would be nullified when scaling both distance
                 // and light size, so it would only waste time.
                 
                 QVector lightPos = light.getPosition() - modelview.p;
                 
                 double lightDistance = lightPos.Magnitude();
                 double lightSize = light.getSize() * 0.5;
                 double lightCosAngle;
                 double lightSolidAngle;
                 if (lightSize <= 0.0) {
                     // Point light always has zero solid angle
                     lightCosAngle = 1.0;
                     lightSolidAngle = 0.0;
                 } else {
                     // NOTE: assuming lightSize > 0, the following condition
                     //  assures a nonzero distance to light, which would produce
                     //  NaNs in the following math.
                     if (lightDistance > lightSize) {
                         // Light cos angle is:
                         //  Vector(1, 0, 0) . Vector(lightDistance, lightSize, 0).Normalize()
                         // Which happens to resolve to:
                         //lightCosAngle = float(lightDistance / (lightDistance + lightSize));
                         lightCosAngle = lightDistance / sqrt( lightDistance*lightDistance + lightSize*lightSize );
                         lightSolidAngle = 2.0 * M_PI * ( 1.0 - lightCosAngle );
                         // Light steradians is:
                         //  Steradians = Fractional Area * 4 * Pi
                         //  Fractional Area = Apparent light area / Sky area at light distance
                         //  Apparent light area = Pi * lightSize^2
                         //  Sky area = 4 * Pi * lightDistance^2
                         // Do the math...
                         /*lightSolidAngle = float(M_PI
                             * ( lightSize / lightDistance )
                             * ( lightSize / lightDistance ));*/
                     } else {
                         // nil distance, avoid infinites that kill shaders
                         // NOTE: the constants aren't capricious, they're the right
                         //  constants for a light coming from all around.
                         lightCosAngle = 0.0;
                         lightSolidAngle = 2.0 * M_PI;
                     }
                 }
                 lightSizes[i*4+0] = float(lightSize);
                 lightSizes[i*4+1] = float(lightCosAngle);
                 lightSizes[i*4+2] = float(lightSolidAngle);
                 lightSizes[i*4+3] = 0.f;
             }
         }
         else {
             lightData[i] = 0;
             lightSizes[i*4+0] = 0.f;
             lightSizes[i*4+1] = 0.f;
             lightSizes[i*4+2] = 0.f;
             lightSizes[i*4+3] = 0.f;
         }
     }
     
     for (; i < (size_t)GFX_MAX_LIGHTS; ++i) {
         lightData[i] = 0;
         lightSizes[i*4+0] = 0.f;
         lightSizes[i*4+1] = 0.f;
         lightSizes[i*4+2] = 0.f;
         lightSizes[i*4+3] = 0.f;
     }
     
     if (!shader) {
         //only bother with actual GL state in the event of lack of shaders
         for (size_t i = 0; i < (size_t) GFX_MAX_LIGHTS; ++i) {
             int isenabled = glIsEnabled( GL_LIGHT0+i );
             if (isenabled && !lightData[i])
                 glDisable( GL_LIGHT0+i );
             else if (lightData[i] && !isenabled)
                 glEnable( GL_LIGHT0+i );
         }
     } else {
         //only bother with shader constants it there is a shader
         GFXLoadIdentity( MODEL );
         for (size_t i = 0; i <= maxval; ++i) {
             if (lightData[i]) {
                 const gfx_light &light = (*_llights)[*(begin+i)];
                 light.ContextSwitchClobberLight(GL_LIGHT0+i, -1);
             }
         }
         GFXLoadMatrixModel( modelview );
         if (active_light_array >= 0)
             GFXShaderConstantv( active_light_array, GFX_MAX_LIGHTS, (int*) lightData );
         if (max_light_location >= 0)
             GFXShaderConstanti( max_light_location, maxval );
         if (apparent_light_size_array >= 0)
             GFXShaderConstant4v( apparent_light_size_array, GFX_MAX_LIGHTS, (float*)lightSizes );
     }
 }

void GFXVertex3d	(	const double	x,
		const double	y,
		const double	z = `1.0`
	)

Definition at line 278 of file gl_misc.cpp.

Referenced by ParticlePoint::Draw(), DrawGun(), and DrawShield().

 {
     glVertex3d( x, y, z );
 }

void GFXVertex3f	(	const float	x,
		const float	y,
		const float	z = `1.0`
	)

Specifies a vertex with 3 floats.

Definition at line 268 of file gl_misc.cpp.

 {
     glVertex3f( x, y, z );
 }

void GFXVertex3f	(	const double	x,
		const double	y,
		const double	z = `1.0`
	)

Definition at line 273 of file gl_misc.cpp.

 {
     glVertex3d( x, y, z );
 }

void GFXVertexf ( const Vector & v)

Specifies a vertex with a vector.

Definition at line 283 of file gl_misc.cpp.

Referenced by ParticlePoint::Draw(), GuiTexture::draw(), VSSprite::Draw(), BaseInterface::Room::Draw(), Animation::DrawAsVSSprite(), Radar::SphereDisplay::DrawBackground(), DrawFrustum(), Radar::PlaneDisplay::DrawGround(), DrawGun(), DrawHUDSprite(), DrawITTSLine(), DrawITTSMark(), DrawOneTargetBox(), Radar::PlaneDisplay::DrawTarget(), Radar::PlaneDisplay::DrawTargetMarker(), Radar::SphereDisplay::DrawTrack(), and Radar::BubbleDisplay::DrawTrack().

 {
     glVertex3f( v.i, v.j, v.k );
 }

void GFXVertexf ( const QVector & v)

Definition at line 288 of file gl_misc.cpp.

 {
     glVertex3d( v.i, v.j, v.k );
 }

void GFXViewPort	(	int	minx,
		int	miny,
		int	maxx,
		int	maxy
	)

Sets the final translation to screen coordinates, Also adjusts range of clearing.

Definition at line 219 of file gl_matrix.cpp.

Referenced by GameCockpit::SetupViewPort().

 {
     glViewport( minx, miny, maxx, maxy );
 }

Macros

Enumerations

Functions

Macro Definition Documentation

Enumeration Type Documentation

Function Documentation