[xonotic/netradiant.git] / 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

  // http://zerowing.idsoftware.com/bugzilla/show_bug.cgi?id=252
  // 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;
        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)
  // http://zerowing.idsoftware.com/bugzilla/show_bug.cgi?id=623
  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_