Archive/openmohaa
0
0
Fork 0
mirror of https://github.com/openmoh/openmohaa.git synced 2025-04-28 13:47:58 +03:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

ioquake3 porting

Browse source
This commit is contained in:
OM 2023-05-24 19:03:05 +02:00
parent 2704b798e2
commit ca3340b158
449 changed files with 104109 additions and 77701 deletions
Download patch file Download diff file Expand all files Collapse all files

281
code/renderercommon/tr_public.h
View file

@ -26,219 +26,160 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
#define REF_API_VERSION 8
typedef struct dtiki_s dtiki_t;
typedef struct skelAnimFrame_s skelAnimFrame_t;
//
// these are the functions exported by the refresh module
//
typedef struct {
// called before the library is unloaded
// if the system is just reconfiguring, pass destroyWindow = qfalse,
// which will keep the screen from flashing to the desktop.
void (*Shutdown)(qboolean destroyWindow);
// called before the library is unloaded
// if the system is just reconfiguring, pass destroyWindow = qfalse,
// which will keep the screen from flashing to the desktop.
void (*Shutdown)( qboolean destroyWindow );
// All data that will be used in a level should be
// registered before rendering any frames to prevent disk hits,
// but they can still be registered at a later time
// if necessary.
//
// BeginRegistration makes any existing media pointers invalid
// and returns the current gl configuration, including screen width
// and height, which can be used by the client to intelligently
// size display elements
void (*BeginRegistration)(glconfig_t* glConfigOut);
qhandle_t(*RegisterModel)(const char* name);
qhandle_t(*SpawnEffectModel)(const char* name, vec3_t pos, vec3_t axis[3]);
qhandle_t(*RegisterServerModel)(const char* name);
void (*UnregisterServerModel)(qhandle_t model);
qhandle_t(*RegisterShader)(const char* name);
qhandle_t(*RegisterShaderNoMip)(const char* name);
qhandle_t(*RefreshShaderNoMip)(const char* name);
// All data that will be used in a level should be
// registered before rendering any frames to prevent disk hits,
// but they can still be registered at a later time
// if necessary.
//
// BeginRegistration makes any existing media pointers invalid
// and returns the current gl configuration, including screen width
// and height, which can be used by the client to intelligently
// size display elements
void (*BeginRegistration)( glconfig_t *config );
qhandle_t (*RegisterModel)( const char *name );
qhandle_t (*RegisterSkin)( const char *name );
qhandle_t (*RegisterShader)( const char *name );
qhandle_t (*RegisterShaderNoMip)( const char *name );
void (*LoadWorld)( const char *name );
// EndRegistration will draw a tiny polygon with each texture, forcing
// them to be loaded into card memory
void (*EndRegistration)();
void (*FreeModels)();
// the vis data is a large enough block of data that we go to the trouble
// of sharing it with the clipmodel subsystem
void (*SetWorldVisData)( const byte *vis );
// the vis data is a large enough block of data that we go to the trouble
// of sharing it with the clipmodel subsystem
void (*SetWorldVisData)(const byte* vis);
// EndRegistration will draw a tiny polygon with each texture, forcing
// them to be loaded into card memory
void (*EndRegistration)( void );
void (*LoadWorld)(const char* name);
void (*PrintBSPFileSizes)();
int (*MapVersion)();
// a scene is built up by calls to R_ClearScene and the various R_Add functions.
// Nothing is drawn until R_RenderScene is called.
void (*ClearScene)( void );
void (*AddRefEntityToScene)( const refEntity_t *re );
void (*AddPolyToScene)( qhandle_t hShader , int numVerts, const polyVert_t *verts, int num );
int (*LightForPoint)( vec3_t point, vec3_t ambientLight, vec3_t directedLight, vec3_t lightDir );
void (*AddLightToScene)( const vec3_t org, float intensity, float r, float g, float b );
void (*AddAdditiveLightToScene)( const vec3_t org, float intensity, float r, float g, float b );
void (*RenderScene)( const refdef_t *fd );
// a scene is built up by calls to R_ClearScene and the various R_Add functions.
// Nothing is drawn until R_RenderScene is called.
void (*ClearScene)(void);
void (*AddRefEntityToScene)(const refEntity_t* re, int parentEntityNumber);
void (*AddRefSpriteToScene)(const refEntity_t* ent);
qboolean(*AddPolyToScene)(qhandle_t hShader, int numVerts, const polyVert_t* verts, int renderfx);
void (*AddTerrainMarkToScene)(int terrainIndex, qhandle_t hShader, int numVerts, const polyVert_t* verts, int renderfx);
void (*AddLightToScene)(const vec3_t org, float intensity, float r, float g, float b, int type);
void (*RenderScene)(const refdef_t* fd);
void (*SetColor)( const float *rgba ); // NULL = 1,1,1,1
void (*DrawStretchPic) ( float x, float y, float w, float h,
float s1, float t1, float s2, float t2, qhandle_t hShader ); // 0 = white
refEntity_t* (*GetRenderEntity)(int entityNumber);
void (*SavePerformanceCounters)();
void (*SetColor)(const float* rgba); // NULL = 1,1,1,1
void (*Set2DWindow)(int x, int y, int w, int h, float left, float right, float bottom, float top, float n, float f);
void (*DrawStretchPic) (float x, float y, float w, float h,
float s1, float t1, float s2, float t2, qhandle_t hShader); // 0 = white
// Draw images for cinematic rendering, pass as 32 bit rgba
void (*DrawStretchRaw) (int x, int y, int w, int h, int cols, int rows, const byte *data, int client, qboolean dirty);
void (*UploadCinematic) (int w, int h, int cols, int rows, const byte *data, int client, qboolean dirty);
void (*DrawTilePic)(float x, float y, float w, float h, qhandle_t hShader);
void (*DrawTilePicOffset)(float x, float y, float w, float h, qhandle_t hShader, int offsetX, int offsetY);
void (*DrawTrianglePic)(vec2_t* points, vec2_t* texCoords, qhandle_t hShader);
void (*DrawBackground)(int cols, int rows, int bgr, uint8_t* data);
void (*BeginFrame)( stereoFrame_t stereoFrame );
// Draw images for cinematic rendering, pass as 32 bit rgba
void (*DrawStretchRaw) (int x, int y, int w, int h, int cols, int rows, int components, const byte* data);
void (*DebugLine)(const vec3_t start, const vec3_t end, float r, float g, float b, float alpha);
void (*DrawBox)(float x, float y, float w, float h);
void (*AddBox)(float x, float y, float w, float h);
void (*BeginFrame)(stereoFrame_t stereoFrame);
void (*Scissor)(int x, int y, int width, int height);
void (*DrawLineLoop)(const vec2_t* points, int count, int stippleFactor, int stippleMask);
// if the pointers are not NULL, timing info will be returned
void (*EndFrame)(int* frontEndMsec, int* backEndMsec);
// if the pointers are not NULL, timing info will be returned
void (*EndFrame)( int *frontEndMsec, int *backEndMsec );
int (*MarkFragments)(int numPoints, const vec3_t* points, const vec3_t projection,
int maxPoints, vec3_t pointBuffer, int maxFragments, markFragment_t* fragmentBuffer, float fRadiusSquared);
int (*MarkFragmentsForInlineModel)(clipHandle_t bmodel, const vec3_t angles, const vec3_t origin, int numPoints,
const vec3_t* points, const vec3_t projection, int maxPoints, vec3_t pointBuffer,
int maxFragments, markFragment_t* fragmentBuffer, float radiusSquared);
int (*MarkFragments)( int numPoints, const vec3_t *points, const vec3_t projection,
int maxPoints, vec3_t pointBuffer, int maxFragments, markFragment_t *fragmentBuffer );
void (*GetInlineModelBounds)(int index, vec3_t mins, vec3_t maxs);
void (*GetLightingForDecal)(vec3_t light, vec3_t facing, vec3_t origin);
void (*GetLightingForSmoke)(vec3_t light, vec3_t origin);
int (*R_GatherLightSources)(const vec3_t pos, vec3_t* lightPos, vec3_t* lightIntensity, int maxLights);
int (*LerpTag)( orientation_t *tag, qhandle_t model, int startFrame, int endFrame,
float frac, const char *tagName );
void (*ModelBounds)( qhandle_t model, vec3_t mins, vec3_t maxs );
void (*ModelBounds)(qhandle_t model, vec3_t mins, vec3_t maxs);
float (*ModelRadius)(qhandle_t handle);
#ifdef __USEA3D
void (*A3D_RenderGeometry) (void *pVoidA3D, void *pVoidGeom, void *pVoidMat, void *pVoidGeomStatus);
#endif
void (*RegisterFont)(const char *fontName, int pointSize, fontInfo_t *font);
void (*RemapShader)(const char *oldShader, const char *newShader, const char *offsetTime);
qboolean (*GetEntityToken)( char *buffer, int size );
qboolean (*inPVS)( const vec3_t p1, const vec3_t p2 );
dtiki_t* (*R_Model_GetHandle)(qhandle_t handle);
void (*DrawString)(const fontheader_t* font, const char* text, float x, float y, int maxLen, qboolean virtualScreen);
float (*GetFontHeight)(const fontheader_t* font);
float (*GetFontStringWidth)(const fontheader_t* font, char* string);
fontheader_t* (*LoadFont)(const char* name);
void (*SwipeBegin)(float thisTime, float life, qhandle_t hShader);
void (*SwipePoint)(vec3_t point1, vec3_t point2, float time);
void (*SwipeEnd)();
void (*SetRenderTime)(int t);
float (*Noise)(float x, float y, float z, float t);
qboolean(*SetMode)(int mode, const glconfig_t* glConfig);
void (*SetFullscreen)(qboolean fullScreen);
int (*GetShaderWidth)(qhandle_t hShader);
int (*GetShaderHeight)(qhandle_t hShader);
char* (*GetGraphicsInfo)();
void (*ForceUpdatePose)(refEntity_t* model);
orientation_t(*TIKI_Orientation)(refEntity_t* model, int tagNum);
qboolean(*TIKI_IsOnGround)(refEntity_t* model, int tagNum, float threshold);
void (*SetFrameNumber)(int frameNumber);
void (*TakeVideoFrame)( int h, int w, byte* captureBuffer, byte *encodeBuffer, qboolean motionJpeg );
} refexport_t;
//
// these are the functions imported by the refresh module
//
typedef struct {
// print message on the local console
void (QDECL* Printf)(int printLevel, const char* fmt, ...);
// print message on the local console
void (QDECL *Printf)( int printLevel, const char *fmt, ...) __attribute__ ((format (printf, 2, 3)));
// abort the game
void (QDECL* Error)(int errorLevel, const char* fmt, ...);
// abort the game
void (QDECL *Error)( int errorLevel, const char *fmt, ...) __attribute__ ((noreturn, format (printf, 2, 3)));
// milliseconds should only be used for profiling, never
// for anything game related. Get time from the refdef
int (*Milliseconds)(void);
// milliseconds should only be used for profiling, never
// for anything game related. Get time from the refdef
int (*Milliseconds)( void );
char* (*LV_ConvertString)(char* string);
void (*Hunk_Clear)();
// stack based memory allocation for per-level things that
// won't be freed
// stack based memory allocation for per-level things that
// won't be freed
#ifdef HUNK_DEBUG
void* (*Hunk_AllocDebug)(size_t size, const char* label, const char* file, int line);
void *(*Hunk_AllocDebug)( int size, ha_pref pref, char *label, char *file, int line );
#else
void* (*Hunk_Alloc)(size_t size);
void *(*Hunk_Alloc)( int size, ha_pref pref );
#endif
void* (*Hunk_AllocateTempMemory)(size_t size);
void (*Hunk_FreeTempMemory)(void* block);
void *(*Hunk_AllocateTempMemory)( int size );
void (*Hunk_FreeTempMemory)( void *block );
// dynamic memory allocator for things that need to be freed
void* (*Malloc)(size_t bytes);
void (*Free)(void* buf);
void (*Clear)();
// dynamic memory allocator for things that need to be freed
void *(*Malloc)( int bytes );
void (*Free)( void *buf );
cvar_t* (*Cvar_Get)(const char* name, const char* value, int flags);
void (*Cvar_Set)(const char* name, const char* value);
void (*Cvar_SetDefault)(cvar_t* var, const char* varValue);
cvar_t *(*Cvar_Get)( const char *name, const char *value, int flags );
void (*Cvar_Set)( const char *name, const char *value );
void (*Cvar_SetValue) (const char *name, float value);
void (*Cvar_CheckRange)( cvar_t *cv, float minVal, float maxVal, qboolean shouldBeIntegral );
void (*Cvar_SetDescription)( cvar_t *cv, const char *description );
void (*Cmd_AddCommand)(const char* name, void (*command) (void));
void (*Cmd_RemoveCommand)(const char* name);
int (*Cvar_VariableIntegerValue) (const char *var_name);
int (*Cmd_Argc) (void);
char* (*Cmd_Argv) (int i);
void (*Cmd_AddCommand)( const char *name, void(*cmd)(void) );
void (*Cmd_RemoveCommand)( const char *name );
void (*Cmd_ExecuteText) (cbufExec_t exec_when, const char* text);
int (*Cmd_Argc) (void);
char *(*Cmd_Argv) (int i);
// visualization for debugging collision detection
void (*CM_DrawDebugSurface)(void (*drawPoly)(int color, int numPoints, float* points));
void (*Cmd_ExecuteText) (int exec_when, const char *text);
// a -1 return means the file does not exist
// NULL can be passed for buf to just determine existance
int (*FS_OpenFile)(const char* qpath, fileHandle_t* file, qboolean uniqueFILE, qboolean quiet);
size_t(*FS_Read)(void* buffer, size_t len, fileHandle_t fileHandle);
void (*FS_CloseFile)(fileHandle_t fileHandle);
int (*FS_Seek)(fileHandle_t fileHandle, long offset, fsOrigin_t origin);
int (*FS_FileIsInPAK)(const char* name, int* pCheckSum);
int (*FS_ReadFile)(const char* name, void** buf);
int (*FS_ReadFileEx)(const char* qpath, void** buffer, qboolean quiet);
void (*FS_FreeFile)(void* buf);
char** (*FS_ListFiles)(const char* name, const char* extension, qboolean wantSubs, int* numFiles);
void (*FS_FreeFileList)(char** filelist);
int (*FS_WriteFile)(const char* qpath, const void* buffer, int size);
qboolean(*FS_FileExists)(const char* file);
byte *(*CM_ClusterPVS)(int cluster);
void (*CM_BoxTrace)(trace_t* results, const vec3_t start, const vec3_t end, const vec3_t mins, const vec3_t maxs, int model, int brushMask, int cylinder);
int (*CM_TerrainSquareType)(int terrainPatch, int i, int j);
char* (*CM_EntityString)();
const char* (*CM_MapTime)();
int (*CG_PermanentMark)(const vec3_t origin, const vec3_t dir, float orientation, float sScale, float tScale, float red, float green, float blue, float alpha, qboolean doLighting, float sCenter, float tCenter, markFragment_t* markFragments, void* polyVerts);
int (*CG_PermanentTreadMarkDecal)(treadMark_t* treadMark, qboolean startSegment, qboolean doLighting, markFragment_t* markFragments, void* polyVerts);
int (*CG_PermanentUpdateTreadMark)(treadMark_t* treadMark, float alpha, float minSegment, float maxSegment, float maxOffset, float texScale);
void (*CG_ProcessInitCommands)(dtiki_t* tiki, refEntity_t* ent);
void (*CG_EndTiki)(dtiki_t* tiki);
void (*SetPerformanceCounters)(int totalTris, int totalVerts, int totalTexels, int worldTris, int worldVerts, int characterLights);
// visualization for debugging collision detection
void (*CM_DrawDebugSurface)( void (*drawPoly)(int color, int numPoints, float *points) );
debugline_t** DebugLines;
int* numDebugLines;
debugstring_t** DebugStrings;
int* numDebugStrings;
// a -1 return means the file does not exist
// NULL can be passed for buf to just determine existence
int (*FS_FileIsInPAK)( const char *name, int *pCheckSum );
long (*FS_ReadFile)( const char *name, void **buf );
void (*FS_FreeFile)( void *buf );
char ** (*FS_ListFiles)( const char *name, const char *extension, int *numfilesfound );
void (*FS_FreeFileList)( char **filelist );
void (*FS_WriteFile)( const char *qpath, const void *buffer, int size );
qboolean (*FS_FileExists)( const char *file );
orientation_t(*TIKI_OrientationInternal)(dtiki_t* tiki, int entNum, int tagNum, float scale);
qboolean(*TIKI_IsOnGroundInternal)(dtiki_t* tiki, int entNum, int tagNum, float thresHold);
void (*TIKI_SetPoseInternal)(void* skeletor, const frameInfo_t* frameInfo, const int* boneTag, const vec4_t* boneQuat, float actionWeight);
void* (*TIKI_Alloc)(size_t size);
float (*GetRadiusInternal)(dtiki_t* tiki, int entNum, float scale);
float (*GetCentroidRadiusInternal)(dtiki_t* tiki, int entNum, float scale, vec3_t centroid);
void (*GetFrameInternal)(dtiki_t* tiki, int entNum, skelAnimFrame_t* newFrame);
// cinematic stuff
void (*CIN_UploadCinematic)(int handle);
int (*CIN_PlayCinematic)( const char *arg0, int xpos, int ypos, int width, int height, int bits);
e_status (*CIN_RunCinematic) (int handle);
// SDL/ioq3 stuff
void (*CL_WriteAVIVideoFrame)( const byte *buffer, int size );
// input event handling
void (*IN_Init)(void* windowData);
void (*IN_Shutdown)(void);
void (*IN_Restart)(void);
// input event handling
void (*IN_Init)( void *windowData );
void (*IN_Shutdown)( void );
void (*IN_Restart)( void );
// system stuff
void (*Sys_SetEnv)(const char* name, const char* value);
void (*Sys_GLimpSafeInit)(void);
void (*Sys_GLimpInit)(void);
qboolean(*Sys_LowPhysicalMemory)(void);
// math
long (*ftol)(float f);
// system stuff
void (*Sys_SetEnv)( const char *name, const char *value );
void (*Sys_GLimpSafeInit)( void );
void (*Sys_GLimpInit)( void );
qboolean (*Sys_LowPhysicalMemory)( void );
} refimport_t;

190
code/renderercommon/tr_types.h
View file

@ -20,9 +20,8 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
===========================================================================
*/
//
#pragma once
#include "../cgame/tr_types.h"
#ifndef __TR_TYPES_H
#define __TR_TYPES_H
#define MAX_DLIGHTS 32 // can't be increased, because bit flags are used on surfaces
@ -33,3 +32,188 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
// and this is reflected by the value of MAX_REFENTITIES (which therefore is not a power-of-2)
#define MAX_REFENTITIES ((1<<REFENTITYNUM_BITS) - 1)
#define REFENTITYNUM_WORLD ((1<<REFENTITYNUM_BITS) - 1)
// renderfx flags
#define RF_MINLIGHT 0x0001 // allways have some light (viewmodel, some items)
#define RF_THIRD_PERSON 0x0002 // don't draw through eyes, only mirrors (player bodies, chat sprites)
#define RF_FIRST_PERSON 0x0004 // only draw through eyes (view weapon, damage blood blob)
#define RF_DEPTHHACK 0x0008 // for view weapon Z crunching
#define RF_CROSSHAIR 0x0010 // This item is a cross hair and will draw over everything similar to
// DEPTHHACK in stereo rendering mode, with the difference that the
// projection matrix won't be hacked to reduce the stereo separation as
// is done for the gun.
#define RF_NOSHADOW 0x0040 // don't add stencil shadows
#define RF_LIGHTING_ORIGIN 0x0080 // use refEntity->lightingOrigin instead of refEntity->origin
// for lighting. This allows entities to sink into the floor
// with their origin going solid, and allows all parts of a
// player to get the same lighting
#define RF_SHADOW_PLANE 0x0100 // use refEntity->shadowPlane
#define RF_WRAP_FRAMES 0x0200 // mod the model frames by the maxframes to allow continuous
// animation without needing to know the frame count
// refdef flags
#define RDF_NOWORLDMODEL 0x0001 // used for player configuration screen
#define RDF_HYPERSPACE 0x0004 // teleportation effect
typedef struct {
vec3_t xyz;
float st[2];
byte modulate[4];
} polyVert_t;
typedef struct poly_s {
qhandle_t hShader;
int numVerts;
polyVert_t *verts;
} poly_t;
typedef enum {
RT_MODEL,
RT_POLY,
RT_SPRITE,
RT_BEAM,
RT_RAIL_CORE,
RT_RAIL_RINGS,
RT_LIGHTNING,
RT_PORTALSURFACE, // doesn't draw anything, just info for portals
RT_MAX_REF_ENTITY_TYPE
} refEntityType_t;
typedef struct {
refEntityType_t reType;
int renderfx;
qhandle_t hModel; // opaque type outside refresh
// most recent data
vec3_t lightingOrigin; // so multi-part models can be lit identically (RF_LIGHTING_ORIGIN)
float shadowPlane; // projection shadows go here, stencils go slightly lower
vec3_t axis[3]; // rotation vectors
qboolean nonNormalizedAxes; // axis are not normalized, i.e. they have scale
float origin[3]; // also used as MODEL_BEAM's "from"
int frame; // also used as MODEL_BEAM's diameter
// previous data for frame interpolation
float oldorigin[3]; // also used as MODEL_BEAM's "to"
int oldframe;
float backlerp; // 0.0 = current, 1.0 = old
// texturing
int skinNum; // inline skin index
qhandle_t customSkin; // NULL for default skin
qhandle_t customShader; // use one image for the entire thing
// misc
byte shaderRGBA[4]; // colors used by rgbgen entity shaders
float shaderTexCoord[2]; // texture coordinates used by tcMod entity modifiers
float shaderTime; // subtracted from refdef time to control effect start times
// extra sprite information
float radius;
float rotation;
} refEntity_t;
#define MAX_RENDER_STRINGS 8
#define MAX_RENDER_STRING_LENGTH 32
typedef struct {
int x, y, width, height;
float fov_x, fov_y;
vec3_t vieworg;
vec3_t viewaxis[3]; // transformation matrix
// time in milliseconds for shader effects and other time dependent rendering issues
int time;
int rdflags; // RDF_NOWORLDMODEL, etc
// 1 bits will prevent the associated area from rendering at all
byte areamask[MAX_MAP_AREA_BYTES];
// text messages for deform text shaders
char text[MAX_RENDER_STRINGS][MAX_RENDER_STRING_LENGTH];
} refdef_t;
typedef enum {
STEREO_CENTER,
STEREO_LEFT,
STEREO_RIGHT
} stereoFrame_t;
/*
** glconfig_t
**
** Contains variables specific to the OpenGL configuration
** being run right now. These are constant once the OpenGL
** subsystem is initialized.
*/
typedef enum {
TC_NONE,
TC_S3TC, // this is for the GL_S3_s3tc extension.
TC_S3TC_ARB // this is for the GL_EXT_texture_compression_s3tc extension.
} textureCompression_t;
typedef enum {
GLDRV_ICD, // driver is integrated with window system
// WARNING: there are tests that check for
// > GLDRV_ICD for minidriverness, so this
// should always be the lowest value in this
// enum set
GLDRV_STANDALONE, // driver is a non-3Dfx standalone driver
GLDRV_VOODOO // driver is a 3Dfx standalone driver
} glDriverType_t;
typedef enum {
GLHW_GENERIC, // where everything works the way it should
GLHW_3DFX_2D3D, // Voodoo Banshee or Voodoo3, relevant since if this is
// the hardware type then there can NOT exist a secondary
// display adapter
GLHW_RIVA128, // where you can't interpolate alpha
GLHW_RAGEPRO, // where you can't modulate alpha on alpha textures
GLHW_PERMEDIA2 // where you don't have src*dst
} glHardwareType_t;
typedef struct {
char renderer_string[MAX_STRING_CHARS];
char vendor_string[MAX_STRING_CHARS];
char version_string[MAX_STRING_CHARS];
char extensions_string[BIG_INFO_STRING];
int maxTextureSize; // queried from GL
int numTextureUnits; // multitexture ability
int colorBits, depthBits, stencilBits;
glDriverType_t driverType;
glHardwareType_t hardwareType;
qboolean deviceSupportsGamma;
textureCompression_t textureCompression;
qboolean textureEnvAddAvailable;
int vidWidth, vidHeight;
// aspect is the screen's physical width / height, which may be different
// than scrWidth / scrHeight if the pixels are non-square
// normal screens should be 4/3, but wide aspect monitors may be 16/9
float windowAspect;
int displayFrequency;
// synonymous with "does rendering consume the entire screen?", therefore
// a Voodoo or Voodoo2 will have this set to TRUE, as will a Win32 ICD that
// used CDS.
qboolean isFullscreen;
qboolean stereoEnabled;
qboolean smpActive; // UNUSED, present for compatibility
} glconfig_t;
#endif // __TR_TYPES_H