gfxlib.h

Go to the documentation of this file.

/*
 * Vega Strike
 * Copyright (C) 2001-2002 Daniel Horn
 *
 * http://vegastrike.sourceforge.net/
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */

#ifndef _GFXLIB_H
#define _GFXLIB_H
#if defined (_WIN32) && !defined (__CYGWIN__)
#ifdef GLDRV_EXPORTS
#define GFXDRVAPI __declspec( dllexport )
#else
#define GFXDRVAPI __declspec( dllimport )
#endif
#else
#define GFXDRVAPI
#endif
/*#if 0
 * #if defined(__APPLE__) || defined(MACOSX)
 * #include <GLUT/glut.h>
 * #else
 * #include <GL/glut.h>
 * #endif
 #endif*/
#include <cstddef>
#include <vector>
class Matrix;

using std::vector;

#include "gfx/vec.h"
#include "gfxlib_struct.h"

//Init functions

void /*GFXDRVAPI*/ GFXInit( int, char** );

void /*GFXDRVAPI*/ GFXLoop( void main_loop() );

void /*GFXDRVAPI*/ GFXShutdown();

//Misc functions

void /*GFXDRVAPI*/ GFXBeginScene();
void /*GFXDRVAPI*/ GFXEndScene();
void /*GFXDRVAPI*/ GFXClear( const GFXBOOL colorbuffer,
                             const GFXBOOL depthbuffer = GFXTRUE,
                             const GFXBOOL stencilbuffer = GFXTRUE );

void /*GFXDRVAPI*/ GFXCreateLightContext( int &con_number );
void /*GFXDRVAPI*/ GFXDeleteLightContext( const int con_number );
void /*GFXDRVAPI*/ GFXSetLightContext( const int con_number );
GFXBOOL /*GFXDRVAPI*/ GFXLightContextAmbient( const GFXColor &amb );
GFXBOOL /*GFXDRVAPI*/ GFXGetLightContextAmbient( GFXColor &amb );
void /*GFXDRVAPI*/ GFXPickLights( const Vector &center, const float radius );
void /*GFXDRVAPI*/ GFXPickLights( const Vector &center, const float radius, vector< int > &lights, const int maxlights, const bool pickglobals );
void /*GFXDRVAPI*/ GFXPickLights( vector< int >::const_iterator begin, vector< int >::const_iterator end );
GFXBOOL /*GFXDRVAPI*/ GFXSetSeparateSpecularColor( const GFXBOOL spec );
GFXBOOL /*GFXDRVAPI*/ GFXSetCutoff( const float cutoff );
void /*GFXDRVAPI*/ GFXSetOptimalIntensity( const float newint, const float saturatevalue );
GFXBOOL /*GFXDRVAPI*/ GFXSetOptimalNumLights( const int numlights );

GFXBOOL /*GFXDRVAPI*/ GFXCreateLight( int &light, const GFXLight&, const bool global );

void /*GFXDRVAPI*/ GFXDeleteLight( const int light );

GFXBOOL /*GFXDRVAPI*/ GFXEnableLight( const int light );

GFXBOOL /*GFXDRVAPI*/ GFXDisableLight( const int light );

GFXBOOL /*GFXDRVAPI*/ GFXSetLight( const int light, const enum LIGHT_TARGET, const GFXColor &color );

void /*GFXDRVAPI*/ GFXPushGlobalEffects();

GFXBOOL /*GFXDRVAPI*/ GFXPopGlobalEffects();

void /*GFXDRVAPI*/ GFXSetMaterial( unsigned int &number, const GFXMaterial &material );
void /*GFXDRVAPI*/ GFXModifyMaterial( const unsigned int number, const GFXMaterial &material );
GFXBOOL /*GFXDRVAPI*/ GFXGetMaterial( const unsigned int number, GFXMaterial &material );
const GFXMaterial& GFXGetMaterial( const unsigned int number );
void /*GFXDRVAPI*/ GFXSelectMaterialHighlights( const unsigned int number,
                                                const GFXColor &ambient,
                                                const GFXColor &diffuse,
                                                const GFXColor &specular,
                                                const GFXColor &emmissive );
void /*GFXDRVAPI*/ GFXSelectMaterial( const unsigned int number );

//Matrix
void /*GFXDRVAPI*/ GFXHudMode( const bool Enter );
//this resets the matrices to what they were when we entered it, without chanigng pushed orpoped matrices
void /*GFXDRVAPI*/ GFXRestoreHudMode();
void /*GFXDRVAPI*/ GFXCenterCamera( const bool Enter );
void /*GFXDRVAPI*/ GFXTranslateView( const QVector &r );
void /*GFXDRVAPI*/ GFXLoadMatrixView( const Matrix &matrix );
void /*GFXDRVAPI*/ GFXGetMatrixView( Matrix &m );

void /*GFXDRVAPI*/ GFXTranslateProjection( const Vector &r );
void /*GFXDRVAPI*/ GFXTranslateModel( const QVector &r );
void /*GFXDRVAPI*/ GFXMultMatrixModel( const Matrix &matrix );

void /*GFXDRVAPI*/ GFXLoadMatrixModel( const Matrix &matrix );
void /*GFXDRVAPI*/ GFXLoadMatrixProjection( const float matrix[16] );

void /*GFXDRVAPI*/ GFXLoadMatrixView( const Matrix &matrix );

void /*GFXDRVAPI*/ GFXLoadIdentity( const MATRIXMODE mode );

void /*GFXDRVAPI*/ GFXGetMatrixModel( Matrix &matrix );

float /*GFXDRVAPI*/ GFXGetZPerspective( const float z );
float /*GFXDRVAPI*/ GFXGetXInvPerspective();
float /*GFXDRVAPI*/ GFXGetYInvPerspective();

void /*GFXDRVAPI*/ GFXPerspective( float fov, float aspect, float znear, float zfar, float cockpit_offset );

void /*GFXDRVAPI*/ GFXParallel( float left, float right, float bottom, float top, float znear, float zfar );

void /*GFXDRVAPI*/ GFXViewPort( int minx, int miny, int maxx, int maxy );

void /*GFXDRVAPI*/ GFXLookAt( Vector eye, QVector center, Vector up );

void /*GFXDRVAPI*/ GFXGetFrustum( double f[6][4] );

void /*GFXDRVAPI*/ GFXCalculateFrustum();

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

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

float /*GFXDRVAPI*/ GFXSphereInFrustum( const QVector &Center, float Radius );

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

void /*GFXDRVAPI*/ GFXBoxInFrustumModel( const Matrix &model );

CLIPSTATE /*GFXDRVAPI*/ GFXBoxInFrustum( const Vector &min, const Vector &max );

CLIPSTATE /*GFXDRVAPI*/ GFXBoxInFrustum( double f[6][4], const Vector &min, const Vector &max );
CLIPSTATE /*GFXDRVAPI*/ GFXTransformedBoxInFrustum( const Vector &min, const Vector &max );
CLIPSTATE /*GFXDRVAPI*/ GFXSpherePartiallyInFrustum( const Vector &cent, const float r );
CLIPSTATE /*GFXDRVAPI*/ GFXTransformedSpherePartiallyInFrustum( const Vector &cent, const float r );
CLIPSTATE /*GFXDRVAPI*/ GFXSpherePartiallyInFrustum( double f[6][4], const Vector &cent, const float r );

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

//Textures
GFXBOOL /*GFXDRVAPI*/ 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 /*GFXDRVAPI*/ GFXPrioritizeTexture( unsigned int handle, float priority );

void /*GFXDRVAPI*/ GFXAttachPalette( unsigned char *palette, int handle );

GFXBOOL /*GFXDRVAPI*/ 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 /*make sure it's not bigger than this--usually maybe 65536*/,
                                          GFXBOOL detailtexture = GFXFALSE,
                                          unsigned int pageIndex = 0 );

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

void /*GFXDRVAPI*/ GFXDeleteTexture( int handle );

void /*GFXDRVAPI*/ GFXDestroyAllTextures();

void /*GFXDRVAPI*/ GFXSelectTexture( int handle, int stage = 0 );

GFXBOOL /*GFXDRVAPI*/ GFXCapture( char *filename );

//State
void /*GFXDRVAPI*/ GFXEnable( const enum STATE );
void /*GFXDRVAPI*/ GFXDisable( const enum STATE );
void /*GFXDRVAPI*/ GFXToggleTexture( bool enable, int whichstage, enum TEXTURE_TARGET target = TEXTURE2D );
void /*GFXDRVAPI*/ GFXTextureAddressMode( const ADDRESSMODE mode, enum TEXTURE_TARGET target = TEXTURE2D );

void /*GFXDRVAPI*/ GFXBlendMode( const enum BLENDFUNC src, const enum BLENDFUNC dst );

void /*GFXDRVAPI*/ GFXGetBlendMode( enum BLENDFUNC &src, enum BLENDFUNC &dst );

void /*GFXDRVAPI*/ GFXColorMaterial( int LIGHTTARG );

void /*GFXDRVAPI*/ GFXPointSize( const float size );

void /*GFXDRVAPI*/ GFXLineWidth( const float size );

void /*GFXDRVAPI*/ GFXPushBlendMode();

void /*GFXDRVAPI*/ GFXPopBlendMode();

void /*GFXDRVAPI*/ GFXActiveTexture( const int stage );

enum DEPTHFUNC /*GFXDRVAPI*/ GFXDepthFunc();

void /*GFXDRVAPI*/ GFXDepthFunc( const enum DEPTHFUNC );

enum DEPTHFUNC /*GFXDRVAPI*/ GFXStencilFunc();

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

void /*GFXDRVAPI*/ GFXStencilFunc( enum DEPTHFUNC sfunc, int ref, unsigned int mask );

void /*GFXDRVAPI*/ GFXStencilOp( enum STENCILOP *pFail, enum STENCILOP *pZfail, enum STENCILOP *pZpass );

void /*GFXDRVAPI*/ GFXStencilOp( enum STENCILOP fail, enum STENCILOP zfail, enum STENCILOP zpass );

unsigned int /*GFXDRVAPI*/ GFXStencilMask();

void /*GFXDRVAPI*/ GFXStencilMask( unsigned int mask );

void /*GFXDRVALP*/ GFXAlphaTest( const enum DEPTHFUNC, const float ref );
enum GFXTEXTUREWRAPMODES
{
    GFXREPEATTEXTURE,
    GFXCLAMPTEXTURE,     //clamp to edge, not to border
    GFXBORDERTEXTURE     //clamp to border, not to edge
};
enum GFXTEXTUREENVMODES
{
    GFXREPLACETEXTURE,
    GFXADDTEXTURE,
    GFXMODULATETEXTURE,
    GFXADDSIGNEDTEXTURE,
    GFXCOMPOSITETEXTURE,
    GFXINTERPOLATETEXTURE,
    GFXDETAILTEXTURE
};
void GFXTextureWrap( int stage, GFXTEXTUREWRAPMODES mode, enum TEXTURE_TARGET target = TEXTURE2D );
void GFXTextureEnv( int stage, GFXTEXTUREENVMODES mode, float arg2 = 0 );
bool GFXMultiTexAvailable();
void /*GFXDRVAPI*/ GFXPolygonOffset( float factor, float units );
void GFXGetPolygonOffset( float *factor, float *units );
void /*GFXDRVAPI*/ GFXPolygonMode( const enum POLYMODE );
void /*GFXDRVAPI*/ GFXCullFace( const enum POLYFACE );
void /*GFXDRVAPI*/ GFXBegin( const enum POLYTYPE );

void /*GFXDRVAPI*/ GFXColorf( const GFXColor &col );
void /*GFXDRVAPI*/ GFXBlendColor( const GFXColor &col );
void /*GFXDRVAPI*/ GFXColor4f( const float r, const float g, const float b, const float a = 1.0 );
GFXColor /*GFXDRVAPI*/ GFXColorf();

void /*GFXDRVAPI*/ GFXTexCoord2f( const float s, const float t );

void /*GFXDRVAPI*/ GFXTexCoord4f( const float s, const float t, const float u, const float v );
void /*GFXDRVAPI*/ 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 );
void /*GFXDRVAPI*/ GFXNormal3f( const float i, const float j, const float k );
void /*GFXDRVAPI*/ GFXNormal( const Vector &n );

void /*GFXDRVAPI*/ GFXVertex3f( const float x, const float y, const float z = 1.0 );
void /*GFXDRVAPI*/ GFXVertex3f( const double x, const double y, const double z = 1.0 );
void /*GFXDRVAPI*/ GFXVertex3d( const double x, const double y, const double z = 1.0 );

void /*GFXDRVAPI*/ GFXVertexf( const Vector &v );
void /*GFXDRVAPI*/ GFXVertexf( const QVector &v );
void /*GFXDRVAPI*/ GFXEnd();
void /*GFXDRVAPI*/ GFXCircle( float x, float y, float r1, float r2 );
void GFXOptimizeList( GFXVertex *old, int numV, GFXVertex **newlist, int *numnewVertices, unsigned int **indices );

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 );
//display list
void /*GFXDRVAPI*/ GFXCallList( int list );

//pick mode
void /*GFXDRVAPI*/ GFXBeginPick( int x, int y, int xsize, int ysize );
void /*GFXDRVAPI*/ GFXSetPickName( int name );
//bool GFXCheckPicked();
vector< PickData >* /*GFXDRVAPI*/ GFXEndPick();

//Subwindow management
void /*GFXDRVAPI*/ GFXSubwindow( int x, int y, int xsize, int ysize );
void /*GFXDRVAPI*/ GFXSubwindow( float x, float y, float xsize, float ysize );

//Coordinate system conversion
Vector /*GFXDRVAPI*/ GFXDeviceToEye( int x, int y );
enum GFXTEXTURECOORDMODE
{
    NO_GEN,
    EYE_LINEAR_GEN,
    OBJECT_LINEAR_GEN,
    SPHERE_MAP_GEN,
    CUBE_MAP_GEN
};
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 );
//program created if necessary and active
int GFXActivateShader( const char *program = NULL /*null for default prog*/ );
int GFXActivateShader( int program );
void GFXDeactivateShader();
//return location of named value
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();
#endif