gtkradiant/include/qertypes.h

/*
Copyright (C) 1999-2007 id Software, Inc. and contributors.
For a list of contributors, see the accompanying CONTRIBUTORS file.

This file is part of GtkRadiant.

GtkRadiant 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.

GtkRadiant 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 GtkRadiant; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/

// qertypes.h
//
// common types
// merged from brush.h, etc. for plugin support
//
#ifndef _QERTYPES_H_
#define _QERTYPES_H_

#ifdef _WIN32
#include <wtypes.h>
#endif

#include <GL/gl.h>

#include "str.h"

#ifdef _WIN32
#define PATH_MAX 260
#endif

// HACK glib-2.0
#define NAME_MAX 255

typedef bool qboolean;

#define	MAXPOINTS	16

// merged from qedefs.h ------

#define	MAX_EDGES	512
#define	MAX_POINTS	1024

#define	COLOR_TEXTUREBACK	  0
#define	COLOR_GRIDBACK		  1
#define	COLOR_GRIDMINOR		  2
#define	COLOR_GRIDMAJOR		  3
#define	COLOR_CAMERABACK	  4
#define COLOR_ENTITY        5
#define COLOR_GRIDBLOCK     6
#define COLOR_GRIDTEXT      7
#define COLOR_BRUSHES       8
#define COLOR_SELBRUSHES    9
#define COLOR_CLIPPER       10
#define COLOR_VIEWNAME      11
#define COLOR_SELBRUSHES3D  12

#define COLOR_GRIDMINOR_ALT 13
#define COLOR_GRIDMAJOR_ALT 14

#define COLOR_LAST          15

// ----------------------------

typedef float vec_t;
typedef vec_t vec3_t[3];

// turn this on/off to use a static texdef or a memory one
// THIS MUST BE CONSISTENT throughout a whole build of Radiant / modules / plugins
// DO_TEXDEF_ALLOC is more memory efficient, but I suspect it to be wacky on win32 / C runtime etc.
#define DO_TEXDEF_ALLOC 1
#if DO_TEXDEF_ALLOC

class texdef_t
{
private:
  char *name;
public:
  texdef_t()
  {
    name = new char[1];
    name[0] = '\0';
    shift[0] = 0.0f;
    shift[1] = 0.0f;
    rotate = 0.0f;
    scale[0] = 1.0f;
    scale[1] = 1.0f;
    contents = 0;
    flags = 0;
    value = 0;
  }
  texdef_t(const texdef_t& other)
  {
    name = NULL;
    SetName(other.name);
    shift[0] = other.shift[0];
    shift[1] = other.shift[1];
    rotate = other.rotate;
    scale[0] = other.scale[0];
    scale[1] = other.scale[1];
    contents = other.contents;
    flags = other.flags;
    value = other.value;
  }
  ~texdef_t()
  {
    if (name)
    {
      delete []name;
      name = (char*)NULL;
    }
  }

  void SetName(const char *p)
  {
    if (name)
    {
      delete []name;
      name = NULL;
    }
    if (p)
    {
      name = strcpy(new char[strlen(p)+1], p);
    }
    else
    {
      name = new char[1];
      name[0] = '\0';
    }
  }

  const char * GetName() const
  {
    return name;
  }

  // NOTE TTimo when loading prefs as binary, we load a bogus value in texdef..
  void DropName()
  {
    name = NULL;
    SetName(NULL);
  }

  texdef_t& operator =(const texdef_t& rhs)
  {
    if (&rhs != this)
    {
      SetName(rhs.name);
      shift[0] = rhs.shift[0];
      shift[1] = rhs.shift[1];
      rotate = rhs.rotate;
      scale[0] = rhs.scale[0];
      scale[1] = rhs.scale[1];
      contents = rhs.contents;
      flags = rhs.flags;
      value = rhs.value;
    }
    return *this;
  }
	float	shift[2];
	float	rotate;
	float	scale[2];
	int		contents;
	int		flags;
	int		value;
};

#else

// max length of a vfs texture path
#define QPATH 64
class texdef_t
{
private:
  char name[QPATH];
public:
  texdef_t() { name[0] = '\0'; }
  ~texdef_t() {  }

  void SetName(const char *p)
  {
    strncpy(name, p, QPATH);
  }

  const char * GetName() const
  {
    return name;
  }

  // NOTE TTimo when loading prefs as binary, we load a bogus value in texdef..
  void DropName()
  {
    name[0] = '\0';
  }

  texdef_t& operator =(const texdef_t& rhs)
  {
    if (&rhs != this)
    {
      SetName(rhs.name);
      shift[0] = rhs.shift[0];
      shift[1] = rhs.shift[1];
      rotate = rhs.rotate;
      scale[0] = rhs.scale[0];
      scale[1] = rhs.scale[1];
      contents = rhs.contents;
      flags = rhs.flags;
      value = rhs.value;
    }
    return *this;
  }
	float	shift[2];
	float	rotate;
	float	scale[2];
	int		contents;
	int		flags;
	int		value;
};

#endif

// forward declare
class IShader;

// Timo
// new brush primitive texdef
typedef struct brushprimit_texdef_s
{
	vec_t	coords[2][3];
} brushprimit_texdef_t;

// this structure is used in Radiant to reflect the state of the texture window
// it gives information on current shader and various flags
class texturewin_t
{
public:
  texturewin_t()
  {
  }
  ~texturewin_t()
  {
  }
	int			width, height;
	int			originy;
	// add brushprimit_texdef_t for brush primitive coordinates storage
	brushprimit_texdef_t	brushprimit_texdef;
	int m_nTotalHeight;
	// surface plugin, must be casted to a IPluginTexdef*
	void* pTexdef;
	texdef_t	texdef;
 	// shader
 	// NOTE: never NULL, initialized in Texture_Init
 	// NOTE: the reference name of the shader is texdef.name (see QERApp_ReloadShaders for an example)
 	IShader *pShader;
};

#define QER_TRANS     0x00000001
#define QER_NOCARVE   0x00000002
#define QER_NODRAW    0x00000004
#define QER_NONSOLID  0x00000008
#define QER_WATER     0x00000010
#define QER_LAVA      0x00000020
#define QER_FOG       0x00000040
#define QER_ALPHAFUNC 0x00000080
#define QER_CULL      0x00000100


// describes a GL texture that Radiant uses to represent a shader
// NOTE: all qtexture_t are stored in a main list at g_qeglobals.d_qtextures
// shaders have reference couting, but qtexture_t don't (they're way too deep into Radiant)
typedef struct qtexture_s
{
  struct	qtexture_s *next;
  // name of the texture file (the physical image file we are using)
  // NOTE: used for lookup, must be unique .. vfs path of the texture, lowercase, NO FILE EXTENSION
  // ex textures/gothic_wall/iron
  // NOTE: the "textures/" prefix might seem unnecessary .. but it's better to stick to the vfs name
  char		  name[64];
  int		    width,  height;
  GLuint		texture_number;	// gl bind number (the qtexture_t are usually loaded and binded by the shaders module)
  vec3_t		color;			    // for flat shade mode
  qboolean	inuse;				  // true = is present on the level (for the texture browser interface)
} qtexture_t;

// NOTE: don't trust this definition!
// you should read float points[..][5]
// see NewWinding definition
// WARNING: don't touch anything to this struct unless you looked into winding.cpp and WINDING_SIZE(pt)
#define MAX_POINTS_ON_WINDING 64
typedef struct
{
  int		numpoints;
  int		maxpoints;
  float 	points[8][5];			// variable sized
} winding_t;

typedef struct
{
  vec3_t	normal;
  double	dist;
  int		type;
} plane_t;

// pShader is a shortcut to the shader
// it's only up-to-date after a Brush_Build call
// to initialize the pShader, use QERApp_Shader_ForName(texdef.name)
typedef struct face_s
{
	struct face_s			*next;
	struct face_s			*prev;
	struct face_s			*original;		//used for vertex movement
	vec3_t					planepts[3];
	texdef_t				texdef;
	plane_t					plane;

	// Nurail: Face Undo
	int				undoId;
	int				redoId;

	winding_t				*face_winding;

	vec3_t					d_color;
  vec_t           d_shade;
  // calls through here have indirections (pure virtual)
  // it would be good if the rendering loop would avoid scanning there (for the GL binding number for example)
	IShader					*pShader;
	//++timo FIXME: remove!
	qtexture_t				*d_texture;

	// Timo new brush primit texdef
	brushprimit_texdef_t	brushprimit_texdef;

	// cast this one to an IPluginTexdef if you are using it
	// NOTE: casting can be done with a GETPLUGINTEXDEF defined in isurfaceplugin.h
	// TODO: if the __ISURFACEPLUGIN_H_ header is used, use a union { void *pData; IPluginTexdef *pPluginTexdef } kind of thing ?
	void					*pData;
} face_t;

typedef struct {
  vec3_t	xyz;
  float	sideST[2];
  float	capST[2];
} curveVertex_t;

typedef struct {
  curveVertex_t	v[2];
} sideVertex_t;


#define	MIN_PATCH_WIDTH		3
#define	MIN_PATCH_HEIGHT 	3

#define	MAX_PATCH_WIDTH		16
#define	MAX_PATCH_HEIGHT	16

// patch type info
// type in lower 16 bits, flags in upper
// endcaps directly follow this patch in the list

// types
#define PATCH_GENERIC     0x00000000    // generic flat patch
#define PATCH_CYLINDER    0x00000001    // cylinder
#define PATCH_BEVEL       0x00000002    // bevel
#define PATCH_ENDCAP      0x00000004    // endcap
#define PATCH_HEMISPHERE  0x00000008    // hemisphere
#define PATCH_CONE        0x00000010    // cone
#define PATCH_TRIANGLE    0x00000020    // simple tri, assumes 3x3 patch

// behaviour styles
#define PATCH_CAP         0x00001000    // flat patch applied as a cap
#define PATCH_SEAM        0x00002000    // flat patch applied as a seam
#define PATCH_THICK       0x00004000    // patch applied as a thick portion

// styles
#define PATCH_BEZIER      0x00000000    // default bezier
#define PATCH_BSPLINE     0x10000000    // bspline

#define PATCH_TYPEMASK     0x00000fff    //
#define PATCH_BTYPEMASK    0x0000f000    //
#define PATCH_STYLEMASK    0xffff0000    //

typedef struct {
  vec3_t	xyz;
  float		st[2];
  float		lightmap[2];
  vec3_t	normal;
} drawVert_t;

// spog - used for patch LOD trees

struct BTNode_t
{
	BTNode_t *left, *right;
	drawVert_t info;
	drawVert_t vMid;
};

struct BTreeList_t
{
	BTreeList_t *next;
	BTNode_t *pBT;
	drawVert_t vLeft, vRight;
};

struct BTListList_t
{
	BTListList_t *next;
	BTreeList_t *list;
};

// used in brush primitive AND entities
typedef struct epair_s
{
  struct epair_s	*next;
  char	*key;
  char	*value;
} epair_t;

struct brush_s;
typedef struct brush_s brush_t;

typedef struct {
  int	width, height;		// in control points, not patches
  int   contents, flags, value, type;
  qtexture_t  *d_texture;
  IShader     *pShader;
  drawVert_t ctrl[MAX_PATCH_WIDTH][MAX_PATCH_HEIGHT];
  brush_t *pSymbiot;
  qboolean bSelected;
  qboolean bOverlay;
  qboolean bDirty;
  int  nListID;
  epair_t *epairs;
  // cast this one to an IPluginTexdef if you are using it
  // NOTE: casting can be done with a GETPLUGINTEXDEF defined in isurfaceplugin.h
  // TODO: if the __ISURFACEPLUGIN_H_ header is used, use a union { void *pData; IPluginTexdef *pPluginTexdef } kind of thing ?
  void					*pData;
  // spog - curve LOD binary trees and lists
  BTNode_t *rowLOD[((MAX_PATCH_WIDTH-1)/2) * MAX_PATCH_HEIGHT]; // = ((MAX_PATCH_WIDTH-1)/2) * MAX_PATCH_HEIGHT
  BTNode_t *colLOD[((MAX_PATCH_HEIGHT-1)/2) * MAX_PATCH_WIDTH]; // = ((MAX_PATCH_HEIGHT-1)/2) * MAX_PATCH_WIDTH
  bool rowDirty[((MAX_PATCH_WIDTH-1)-1)/2];
  bool colDirty[((MAX_PATCH_HEIGHT-1)-1)/2];
  bool LODUpdated;
  void *drawLists; // pointer to std::list
} patchMesh_t;

typedef struct brush_s
{
  struct brush_s	*prev, *next;	// links in active/selected
  struct brush_s	*oprev, *onext;	// links in entity
  struct entity_s	*owner;
  vec3_t	        mins, maxs;
  face_t                *brush_faces;

  qboolean bModelFailed;
  //
  // curve brush extensions
  // all are derived from brush_faces
  qboolean	patchBrush;
  qboolean	hiddenBrush;

  //int nPatchID;

  patchMesh_t *pPatch;
  struct entity_s *pUndoOwner;

  int undoId;						//undo ID
  int redoId;						//redo ID
  int ownerId;					//entityId of the owner entity for undo

  // TTimo: this is not legal, we are not supposed to put UI toolkit dependant stuff in the interfaces
  // NOTE: the grouping stuff never worked, there is embryonary code everywhere though
  int numberId;
  void* itemOwner; // GtkCTreeNode* ?

  // brush primitive only
  epair_t *epairs;

  // brush filtered toggle
  bool bFiltered;
  bool bCamCulled;
  bool bBrushDef;
} brush_t;

#define	MAX_FLAGS	16

typedef struct vertmodel_t
{
  float v[3];
  float st[2];
  float normal[3];
} vertmodel;

typedef struct triindex_t
{
  int indexes[3];
} triindex;

// TTimo: NOTE: we don't have dedicated stuff to copy/allocate/delete this structure like we do for entity_t and brush_t
//   could be necessary, I'm adding GString *strSkin that needs to be copied around
// TTimo 04/01/2001 removing the GString* for toolkit-independent interfaces .. cast it ..
typedef struct entitymodel_t
{
  struct entitymodel_t *pNext;
  int nTriCount;
  //trimodel *pTriList;
  //md3Triangle_t *pTriList;
  triindex *pTriList;
  vertmodel *pVertList;
  int numVerts;
  int nTextureBind;
  void *strSkin; // toolkit-independent .. cast to a GString*
  int nSkinWidth;
  int nSkinHeight;
  int	nModelPosition;
} entitymodel;

// eclass show flags

#define     ECLASS_LIGHT      0x00000001
#define     ECLASS_ANGLE      0x00000002
#define     ECLASS_PATH       0x00000004
#define     ECLASS_MISCMODEL  0x00000008

#ifdef USEPLUGINENTITIES
#define		ECLASS_PLUGINENTITY 0x00000010
#endif // USEPLUGINENTITIES

typedef struct eclass_s
{
	struct eclass_s *next;
	char	*name;
	qboolean	fixedsize;
	qboolean	unknown;		// wasn't found in source
	vec3_t	mins, maxs;
	vec3_t	color;
	texdef_t	texdef;
	char	*comments;
	char	flagnames[MAX_FLAGS][32];

  entitymodel *model;
  char	*modelpath;
  //++timo NOTE: I don't know what this is used for exactly. But don't trust it for the real skin paths on models (screws up with long/short path names)
  //++hydra NOTE: this, hopefully, will be used to use specific shaders on the bounding boxes of the eclass instead of a color.
  char	*skinpath;
  int   nFrame;
  unsigned int nShowFlags;

  void*	hPlug;
} eclass_t;

extern	eclass_t	*eclass;

/*
** window bits
*/
#define	W_CAMERA		  0x0001
#define	W_XY			    0x0002
#define	W_XY_OVERLAY	0x0004
#define	W_Z				    0x0008
#define	W_TEXTURE		  0x0010
#define	W_Z_OVERLAY		0x0020
#define W_CONSOLE		  0x0040
#define W_ENTITY		  0x0080
#define W_CAMERA_IFON 0x0100
#define W_XZ          0x0200  //--| only used for patch vertex manip stuff
#define W_YZ          0x0400  //--|
#define W_GROUP       0x0800
#define W_MEDIA       0x1000
#define	W_ALL			0xFFFFFFFF

// used in some Drawing routines
enum VIEWTYPE {YZ, XZ, XY};
const char g_AxisName[3] = { 'X', 'Y', 'Z' };

// dynamically allocated string
class string_t
{
public:
  inline string_t()
  {
    copy("");
  }
  inline string_t(const string_t& other)
  {
    copy(other.m_string);
  }
  inline string_t(const char* string)
  {
    copy(string);
  }
  inline ~string_t()
  {
    destroy();
  }
  inline const string_t& operator=(const string_t& other)
  {
    destroy();
    copy(other.m_string);
    return *this;
  }
  inline const string_t& operator=(const char* string)
  {
    destroy();
    copy(string);
    return *this;
  }
  inline bool operator<(const string_t& other) const
  {
    return compare(other) < 0;
  }
  inline bool operator>(const string_t& other) const
  {
    return compare(other) > 0;
  }
  inline bool operator==(const string_t& other) const
  {
    return compare(other) == 0;
  }
  inline bool operator!=(const string_t& other) const
  {
    return compare(other) != 0;
  }
  inline const char* c_str() const
  {
    return m_string;
  }
private:
  inline void copy(const char* string)
  {
    m_string = new char[strlen(string)+1];
    strcpy(m_string, string);
  }
  inline void destroy()
  {
    delete[] m_string;
  }
  inline int compare(const string_t& other) const
  {
    return strcmp(m_string, other.m_string);
  }

  char* m_string;
};

class filetype_t
{
public:
  filetype_t()
    : name(""), pattern("")
  {}
  filetype_t(const char* _name, const char* _pattern)
    : name(_name), pattern(_pattern)
  {}
  const char* name;
  const char* pattern;
};


/*
** Outline bits
*/
#define OUTLINE_ZBUF  0x01  // zbuffered outline
#define OUTLINE_BSEL  0x02  // selection overlay

#ifdef USEPLUGINENTITIES
// forward declare this one
class IPluginEntity;
#endif // USEPLUGINENTITIES

// MODEL

class IRender;
class ISelect;
class IEdit;

// NOTE TTimo about ~entity_interfaces_t
// using constructors / destructors on C structs is bad practice
struct entity_interfaces_t
{
  IRender *pRender;
  ISelect *pSelect;
  IEdit *pEdit;
};
// MODEL END

typedef struct entity_s
{
  struct entity_s	*prev, *next;

  /*!
  \todo can use a brushes list, or the blind data below
  for now, blind data should be interpreted as CPtrArray*, only use in the IMAP API
  */
  brush_t		brushes;					// head/tail of list
  void *pData;

  int			undoId, redoId, entityId;	// used for undo/redo
  vec3_t		origin;
  eclass_t	*eclass;
  epair_t		*epairs;
  entity_interfaces_t model;
#ifdef USEPLUGINENTITIES
  IPluginEntity *pPlugEnt;
#endif // USEPLUGINENTITIES

  // this is cam code addition?
  vec3_t color;

	// Arnout: HACK-ish and change for 1.3 (in 1.3 we have a blind data pointer according to TTimo)
	float fLightEnvelope1[3];
	float fLightEnvelope2[2];
} entity_t;

typedef struct
{
  int	   p1, p2;
  face_t   *f1, *f2;
} pedge_t;

// window system independent camera view code
// NOTE TTimo taken from xy.h
typedef struct
{
  int	    width, height;

  qboolean  timing;

  vec3_t    origin;  // at center of window
  float	    scale;

  float	    topclip, bottomclip;

  qboolean  d_dirty;
} xy_t;

// spog - struct used for nodes in filters list
struct bfilter_t //c++ style
{
	bfilter_t	*next;
	int		attribute;		// 1=brush->face->pShader->getName()
							// 2=brush->pPatch->pShader->getFlags()
							// 3=brush->owner->eclass->name
							// 4=brush->owner->eclass->nShowFlags
							// 5=brush->face->texdef.flags (q2)
							// 6=brush->face->texdef.contents (q2)
	int		mask;
	const char	*string;
	bool	active;
};

// djbob: no longer any need to add only to end, versioning removed, it is no longer saved as binary
// IMPORTANT: whenever you update this struct, you need to add the relevant load/save code
// preferences.cpp LoadPref / SavePref
typedef struct
{
  int	      iTexMenu;		// nearest, linear, etc
  float	    fGamma;		  // gamma for textures
  vec3_t    colors[COLOR_LAST];
  int       exclude;
  int       include;
  texdef_t  m_SIIncrement;  // increments for the surface inspector
  texdef_t  m_PIIncrement;  // increments for the patch inspector
  vec3_t    AxisColors[3];  // colors used for X, Y Z axis
                            // these are in the View > Show menu with Show coordinates
  qboolean  show_names;
  qboolean  show_coordinates;
  qboolean  show_angles;
  qboolean  show_outline;
  qboolean  show_axis;
  qboolean  bNoSelectedOutlines;
  bfilter_t	*filters; // FIXME spog - might be better in another location?
  int       iSelectedOutlinesStyle;
} SavedInfo_t;

typedef enum
{
  sel_brush,
  sel_brush_on,
  sel_brush_off,
  // sel_sticky_brush,
  // sel_face,
  sel_vertex,
  sel_edge,
  sel_singlevertex,
  sel_curvepoint,
  sel_area,
  sel_areatall,
  sel_facets_on,
  sel_facets_off,
} select_t;

// most of the QE globals are stored in this structure
typedef struct
{
  qboolean  d_showgrid;
  float     d_gridsize;
  qboolean  d_bSmallGrid; // we use this flag to hack our way into editing of <1 grids

  int      d_num_entities;

  entity_t *d_project_entity;

  // defines the boundaries of the current work area
  // is used to guess brushes and drop points third coordinate when creating from 2D view
  vec3_t    d_work_min,d_work_max;
  // not stored in registry, default is off
  qboolean	d_show_work;

  vec3_t       d_points[MAX_POINTS];
  int          d_numpoints;
  pedge_t      d_edges[MAX_EDGES];
  int          d_numedges;

  int          d_num_move_points;
  float        *d_move_points[4096];

  qtexture_t   *d_qtextures;
  // used to speedup access, specially in QERApp_Try_Texture_ForName
  // must always be kept up-to-date with d_qtextures*
  //++timo FIXME at some point in the future it would even be better to remove d_qtextures and use this instead
  GHashTable *d_qtexmap;

  texturewin_t d_texturewin;

  int	       d_pointfile_display_list;

  xy_t         d_xyOld;

  SavedInfo_t  d_savedinfo;

  int          d_workcount;

  // connect entities uses the last two brushes selected
  int	         d_select_count;
  brush_t      *d_select_order[2];
  vec3_t       d_select_translate;    // for dragging w/o making new display lists
  select_t     d_select_mode;

  int          d_parsed_brushes;

  qboolean     show_blocks;
  int		       blockSize;

  // NOTE TTimo
  // a lot of this data should be in a property bag and available to the other modules through an API
  // this is generated from game configuration and the project settings, and should be still be part of it

  // tells if we are internally using brush primitive (texture coordinates and map format)
  // this is a shortcut for IntForKey( g_qeglobals.d_project_entity, "brush_primit" )
  // NOTE: must keep the two ones in sync
  bool         m_bBrushPrimitMode;

  /*!
  win32: engine full path.
  unix: user home full path + engine dir.
  */
  Str         m_strHomeGame;
  /*!
  cache for m_strHomeGame + mod subdirectory.
  */
  Str         m_strHomeMaps;

  // used while importing brush data from file or memory buffer
  // tells if conversion between map format and internal preferences ( m_bBrushPrimitMode ) is needed
  qboolean     bNeedConvert;
  qboolean     bOldBrushes;
  qboolean     bPrimitBrushes;

  vec3_t       d_vAreaTL;
  vec3_t       d_vAreaBR;

  // tells if we are using .INI files for prefs instead of registry
  qboolean	use_ini;
  // even in .INI mode we use the registry for all void* prefs
  char		use_ini_registry[64];
  // disabled all INI / registry read write .. used when shutting down after registry cleanup
  qboolean disable_ini;

  // tells we are using a BSP frontend plugin
  qboolean	bBSPFrontendPlugin;

  // handle to the console log file
  // we use low level I/O to get rid of buffering and have everything on file if we crash
  int hLogFile;

  qboolean bTextureCompressionSupported; // is texture compression supported by hardware?
  GLint texture_components;

  // temporary values that should be initialised only once at run-time
  // there are too many uneccessary calls to Sys_QGL_ExtensionSupported
  // NOTE TTimo: those are unused atm (set right, but not used)
  bool m_bOpenGLCompressionSupported;
  bool m_bS3CompressionSupported;

  // set to true after OpenGL has been initialized and extensions have been tested
  bool m_bOpenGLReady;

} QEGlobals_t;

#endif // _QERTYPES_H_