tr_local.h

/*
===========================================================================
Copyright (C) 1999-2005 Id Software, Inc.
 
This file is part of Quake III Arena source code.
 
Quake III Arena source code 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.
 
Quake III Arena source code 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 Foobar; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
===========================================================================
*/
 
#pragma once
 
#include "../qcommon/q_shared.h"
#include "../qcommon/qfiles.h"
#include "../qcommon/qcommon.h"
#include "tr_public.h"
#include "../renderercommon/qgl.h"
#include "../renderercommon/tr_common.h"
#include "qgl.h"
 
#ifdef __cplusplus
#define GLE(ret, name, ...) extern "C" name##proc * qgl##name;
#else
#define GLE(ret, name, ...) extern name##proc * qgl##name;
#endif
 
QGL_1_1_PROCS;
QGL_1_1_FIXED_FUNCTION_PROCS;
QGL_1_3_PROCS;
QGL_DESKTOP_1_1_PROCS;
QGL_DESKTOP_1_1_FIXED_FUNCTION_PROCS;
QGL_3_0_PROCS;
 
#undef GLE
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define GL_INDEX_TYPE       GL_UNSIGNED_INT
typedef unsigned int glIndex_t;
 
// fast float to int conversion
#if id386 && !( (defined __linux__ || defined __FreeBSD__ ) && (defined __i386__ ) ) // rb010123
long myftol( float f );
#else
#define myftol(x) ((int)(x))
#endif
 
 
// everything that is needed by the backend needs
// to be double buffered to allow it to run in
// parallel on a dual cpu machine
#define SMP_FRAMES      2
 
// 12 bits
// see QSORT_SHADERNUM_SHIFT
#define MAX_SHADERS             16384
 
//#define MAX_SHADER_STATES 2048
#define MAX_STATES_PER_SHADER 32
#define MAX_STATE_NAME 32
 
// can't be increased without changing bit packing for drawsurfs
 
typedef struct skelSurfaceGame_s skelSurfaceGame_t;
typedef struct staticSurface_s staticSurface_t;
 
// any changes in surfaceType must be mirrored in rb_surfaceTable[]
typedef enum {
    SF_BAD,
    SF_SKIP,                // ignore
    SF_FACE,
    SF_GRID,
    SF_POLY,
    SF_MARK_FRAG,
    SF_FLARE,
    SF_ENTITY,              // beams, rails, lightning, etc that can be determined by entity
    SF_DISPLAY_LIST,
    SF_TIKI_SKEL,
    SF_TIKI_STATIC,
    SF_SWIPE,
    SF_SPRITE,
    SF_TERRAIN_PATCH,
    SF_TRIANGLES,
    SF_MD3,
    SF_MD4,
 
    SF_NUM_SURFACE_TYPES,
    SF_MAX = 0x7fffffff         // ensures that sizeof( surfaceType_t ) == sizeof( int )
} surfaceType_t;
 
typedef struct {
    struct mnode_s* cntNode;
    struct msurface_s* skySurfs[32];
    int numSurfs;
    vec3_t offset;
    vec3_t mins;
    vec3_t maxs;
} portalsky_t;
 
typedef struct {
    vec3_t transformed;
    int index;
} sphere_dlight_t;
 
typedef enum {
    LIGHT_POINT,
    LIGHT_DIRECTIONAL,
    LIGHT_SPOT,
    LIGHT_SPOT_FAST
} lighttype_t;
 
typedef struct reallightinfo_s {
    vec3_t color;
    lighttype_t eType;
    float fIntensity;
    float fDist;
    float fSpotSlope;
    float fSpotConst;
    float fSpotScale;
    vec3_t vOrigin;
    vec3_t vDirection;
} reallightinfo_t;
 
typedef float cube_entry_t[3][4];
 
typedef struct {
    vec3_t origin;
    vec3_t worldOrigin;
    vec3_t traceOrigin;
    float radius;
    struct mnode_s* leaves[8];
    void(*TessFunction) (unsigned char* dstColors);
    union {
        unsigned char level[4];
        int value;
    } ambient;
    int numRealLights;
    reallightinfo_t light[MAX_REAL_LIGHTS];
    int bUsesCubeMap;
    float cubemap[24][3][4];
} sphereor_t;
 
typedef struct spherel_s {
    vec3_t origin;
    vec3_t color;
    float intensity;
    struct mnode_s* leaf;
    int needs_trace;
    int spot_light;
    float spot_radiusbydistance;
    vec3_t spot_dir;
    int reference_count;
} spherel_t;
 
typedef struct dlight_s {
    vec3_t  origin;
    vec3_t  color;              // range from 0.0 to 1.0, should be color normalized
    float   radius;
 
    dlighttype_t type;
    vec3_t  transformed;        // origin in local coordinate system
} dlight_t;
 
 
// a trRefEntity_t has all the information passed in by
// the client game, as well as some locally derived info
typedef struct {
    refEntity_t  e;
 
    float       axisLength;     // compensate for non-normalized axis
 
    qboolean    needDlights;    // true for bmodels that touch a dlight
    qboolean    bLightGridCalculated;
    int         iGridLighting;
    float       lodpercentage[2];
    qboolean    sphereCalculated;
    int         lightingSphere;
 
    //
    // old lighting variables
    //
    vec3_t      lightDir;       // normalized direction towards light
    vec3_t      ambientLight;   // color normalized to 0-255
    int         ambientLightInt;    // 32 bit rgba packed
    vec3_t      directedLight;
} trRefEntity_t;
 
typedef struct refSprite_s {
    surfaceType_t surftype;
    int hModel;
    int shaderNum;
    float origin[3];
    float scale;
    float axis[3][3];
    unsigned char shaderRGBA[4];
    int renderfx;
    float shaderTime;
} refSprite_t;
 
typedef struct {
    vec3_t      origin;         // in world coordinates
    vec3_t      axis[3];        // orientation in world
    vec3_t      viewOrigin;     // viewParms->or.origin in local coordinates
    float       modelMatrix[16];
} orientationr_t;
 
/*
typedef struct image_s {
    char        imgName[MAX_QPATH];     // game path, including extension
    int         width, height;              // source image
    int         uploadWidth, uploadHeight;  // after power of two and picmip but not including clamp to MAX_TEXTURE_SIZE
    GLuint      texnum;                 // gl texture binding
 
    int         frameUsed;          // for texture usage in frame statistics
    int         bytesUsed;
 
    int         internalFormat;
    int         TMU;                // only needed for voodoo2
    int         numMipmaps;
 
    qboolean    dynamicallyUpdated;
    qboolean    allowPicmip;
    qboolean    force32bit;
    int         wrapClampModeX;
    int         wrapClampModeY;
    int         r_sequence;
    int         UseCount;
 
    struct image_s* next;
} image_t;
*/
 
//===============================================================================
 
typedef enum {
    SS_BAD,
    SS_PORTAL,          // mirrors, portals, viewscreens
    SS_PORTALSKY,
    SS_ENVIRONMENT,     // sky box
    SS_OPAQUE,          // opaque
 
    SS_DECAL,           // scorch marks, etc.
    SS_SEE_THROUGH,     // ladders, grates, grills that may have small blended edges
                        // in addition to alpha test
    SS_BANNER,
 
    SS_UNDERWATER,      // for items that should be drawn in front of the water plane
 
    SS_BLEND0,          // regular transparency and filters
    SS_BLEND1,          // generally only used for additive type effects
    SS_BLEND2,
    SS_BLEND3,
 
    SS_BLEND6,
    SS_STENCIL_SHADOW,
    SS_ALMOST_NEAREST,  // gun smoke puffs
 
    SS_NEAREST          // blood blobs
} shaderSort_t;
 
 
#define MAX_SHADER_STAGES 8
 
typedef enum {
    GF_NONE,
 
    GF_SIN,
    GF_SQUARE,
    GF_TRIANGLE,
    GF_SAWTOOTH, 
    GF_INVERSE_SAWTOOTH, 
 
    GF_NOISE
 
} genFunc_t;
 
typedef enum {
    USE_S_COORDS,
    USE_T_COORDS
} texDirection_t;
 
typedef enum {
    DEFORM_NONE,
    DEFORM_WAVE,
    DEFORM_NORMALS,
    DEFORM_BULGE,
    DEFORM_MOVE,
    DEFORM_AUTOSPRITE,
    DEFORM_AUTOSPRITE2,
    DEFORM_LIGHTGLOW,
    DEFORM_FLAP_S,
    DEFORM_FLAP_T
} deform_t;
 
typedef enum {
    AGEN_IDENTITY,
    AGEN_SKIP,
    AGEN_ENTITY,
    AGEN_ONE_MINUS_ENTITY,
    AGEN_VERTEX,
    AGEN_ONE_MINUS_VERTEX,
    AGEN_LIGHTING_SPECULAR,
    AGEN_WAVEFORM,
    AGEN_PORTAL,
    AGEN_NOISE,
    AGEN_DOT,
    AGEN_ONE_MINUS_DOT,
    AGEN_CONSTANT,
    AGEN_GLOBAL_ALPHA,
    AGEN_SKYALPHA,
    AGEN_ONE_MINUS_SKYALPHA,
    AGEN_SCOORD,
    AGEN_TCOORD,
    AGEN_DIST_FADE,
    AGEN_ONE_MINUS_DIST_FADE,
    AGEN_TIKI_DIST_FADE,
    AGEN_ONE_MINUS_TIKI_DIST_FADE,
    AGEN_DOT_VIEW,
    AGEN_ONE_MINUS_DOT_VIEW,
    AGEN_HEIGHT_FADE,
} alphaGen_t;
 
typedef enum {
    CGEN_BAD,
    CGEN_IDENTITY_LIGHTING, // tr.identityLight
    CGEN_IDENTITY,          // always (1,1,1,1)
    CGEN_ENTITY,            // grabbed from entity's modulate field
    CGEN_ONE_MINUS_ENTITY,  // grabbed from 1 - entity.modulate
    CGEN_EXACT_VERTEX,      // tess.vertexColors
    CGEN_VERTEX,            // tess.vertexColors * tr.identityLight
    CGEN_ONE_MINUS_VERTEX,
    CGEN_WAVEFORM,          // programmatically generated
    CGEN_MULTIPLY_BY_WAVEFORM,
    CGEN_LIGHTING_GRID,
    CGEN_LIGHTING_SPHERICAL,
    CGEN_CONSTANT,
    CGEN_NOISE,
    CGEN_GLOBAL_COLOR,
    CGEN_STATIC,
    CGEN_SCOORD,
    CGEN_TCOORD,
    CGEN_DOT,
    CGEN_ONE_MINUS_DOT
} colorGen_t;
 
typedef enum {
    TCGEN_BAD,
    TCGEN_IDENTITY,         // clear to 0,0
    TCGEN_LIGHTMAP,
    TCGEN_TEXTURE,
    TCGEN_ENVIRONMENT_MAPPED,
    TCGEN_VECTOR,           // S and T from world coordinates
    TCGEN_ENVIRONMENT_MAPPED2,
    TCGEN_SUN_REFLECTION,
    TCGEN_FOG
} texCoordGen_t;
 
typedef enum {
    ACFF_NONE,
    ACFF_MODULATE_RGB,
    ACFF_MODULATE_RGBA,
    ACFF_MODULATE_ALPHA
} acff_t;
 
typedef struct {
    genFunc_t   func;
 
    float base;
    float amplitude;
    float phase;
    float frequency;
} waveForm_t;
 
#define TR_MAX_TEXMODS 4
 
typedef enum {
    TMOD_NONE,
    TMOD_TRANSFORM,
    TMOD_TURBULENT,
    TMOD_SCROLL,
    TMOD_SCALE,
    TMOD_STRETCH,
    TMOD_ROTATE,
    TMOD_ENTITY_TRANSLATE,
    TMOD_NOISE,
    TMOD_OFFSET,
    TMOD_PARALLAX,
    TMOD_MACRO,
    TMOD_WAVETRANS,
    TMOD_WAVETRANT,
    TMOD_BULGETRANS
} texMod_t;
 
#define MAX_SHADER_DEFORMS  3
typedef struct {
    deform_t    deformation;            // vertex coordinate modification type
 
    vec3_t      moveVector;
    waveForm_t    deformationWave;
    float       deformationSpread;
 
    float       bulgeWidth;
    float       bulgeHeight;
    float       bulgeSpeed;
} deformStage_t;
 
 
typedef struct {
    texMod_t        type;
 
    // used for TMOD_TURBULENT and TMOD_STRETCH
    waveForm_t        wave;
 
    // used for TMOD_TRANSFORM
    float           matrix[2][2];       // s' = s * m[0][0] + t * m[1][0] + trans[0]
    float           translate[2];       // t' = s * m[0][1] + t * m[0][1] + trans[1]
 
    // used for TMOD_SCALE
    float           scale[2];           // s *= scale[0]
                                        // t *= scale[1]
 
    // used for TMOD_PARALLAX
    float           rate[2];
 
    // used for TMOD_SCROLL
    float           scroll[2];          // s' = s + scroll[0] * time
                                        // t' = t + scroll[1] * time
 
    // + = clockwise
    // - = counterclockwise
    float           rotateSpeed;
    float           rotateStart;
    float           rotateCoef;
 
} texModInfo_t;
 
 
#define MAX_IMAGE_ANIMATIONS    64
#define BUNDLE_ANIMATE_ONCE     1
 
typedef struct {
    image_t         *image[MAX_IMAGE_ANIMATIONS];
    int             numImageAnimations;
    float           imageAnimationSpeed;
    float           imageAnimationPhase;
 
    texCoordGen_t   tcGen;
    vec3_t          tcGenVectors[2];
 
    int             numTexMods;
    texModInfo_t    *texMods;
 
    int             videoMapHandle;
    qboolean        isLightmap;
    qboolean        vertexLightmap;
    qboolean        isVideoMap;
    int             flags;
} textureBundle_t;
 
#define NUM_TEXTURE_BUNDLES 2
 
typedef struct {
    qboolean        active;
    qboolean        hasNormalMap;
    
    textureBundle_t  bundle[NUM_TEXTURE_BUNDLES];
    image_t         *normalMap;
    int             multitextureEnv;        // 0, GL_MODULATE, GL_ADD (FIXME: put in stage)
 
    waveForm_t        rgbWave;
    colorGen_t      rgbGen;
 
    waveForm_t        alphaWave;
    alphaGen_t      alphaGen;
 
    unsigned        stateBits;                  // GLS_xxxx mask
 
 
    qboolean        noMipMaps;
    qboolean        noPicMip;
    qboolean        force32bit;
 
    float           alphaMin;
    float           alphaMax;
    vec3_t          specOrigin;
 
    byte            colorConst[4];          // for CGEN_CONST and AGEN_CONST
    byte            alphaConst;
    byte            alphaConstMin;
} shaderStage_t;
 
struct shaderCommands_s;
 
#define LIGHTMAP_2D         -4      // shader is for 2D rendering
#define LIGHTMAP_BY_VERTEX  -3      // pre-lit triangle models
#define LIGHTMAP_WHITEIMAGE -2
#define LIGHTMAP_NONE       -1
 
typedef enum {
    CT_FRONT_SIDED,
    CT_BACK_SIDED,
    CT_TWO_SIDED
} cullType_t;
 
typedef enum {
    FP_NONE,        // surface is translucent and will just be adjusted properly
    FP_EQUAL,       // surface is opaque but possibly alpha tested
    FP_LE           // surface is trnaslucent, but still needs a fog pass (fog surface)
} fogPass_t;
 
typedef struct {
    float       cloudHeight;
    image_t     *outerbox[6], *innerbox[6];
} skyParms_t;
 
typedef enum {
    SPRITE_PARALLEL,
    SPRITE_PARALLEL_ORIENTED,
    SPRITE_ORIENTED,
    SPRITE_PARALLEL_UPRIGHT
} spriteType_t;
 
typedef struct {
  spriteType_t type;
  float scale;
} spriteParms_t;
 
typedef struct {
    vec3_t  color;
    float   depthForOpaque;
} fogParms_t;
 
 
typedef struct shader_s {
    char        name[MAX_QPATH];        // game path, including extension
    int         lightmapIndex;          // for a shader to match, both name and lightmapIndex must match
 
    int         index;                  // this shader == tr.shaders[index]
    int         sortedIndex;            // this shader == tr.sortedShaders[sortedIndex]
 
    float       sort;                   // lower numbered shaders draw before higher numbered
 
    qboolean    defaultShader;          // we want to return index 0 if the shader failed to
                                        // load for some reason, but R_FindShader should
                                        // still keep a name allocated for it, so if
                                        // something calls RE_RegisterShader again with
                                        // the same name, we don't try looking for it again
 
    qboolean    explicitlyDefined;      // found in a .shader file
 
    int         surfaceFlags;           // if explicitlyDefined, this will have SURF_* flags
    int         contentFlags;
 
    qboolean    entityMergable;         // merge across entites optimizable (smoke, blood)
 
    qboolean    isSky;
    skyParms_t    sky;
    spriteParms_t sprite;
    qboolean    isPortalSky;
    float subdivisions;
    float fDistRange;
    float fDistNear;
    fogParms_t    fogParms;
 
    float       portalRange;            // distance to fog out at
 
    cullType_t  cullType;               // CT_FRONT_SIDED, CT_BACK_SIDED, or CT_TWO_SIDED
    qboolean    polygonOffset;          // set for decals and other items that must be offset 
    qboolean    noMipMaps;              // for console fonts, 2D elements, etc.
    qboolean    noPicMip;               // for images that must always be full resolution
 
    fogPass_t   fogPass;                // draw a blended pass, possibly with depth test equals
 
    qboolean    needsNormal;            // not all shaders will need all data to be gathered
    qboolean    needsST1;
    qboolean    needsST2;
    qboolean    needsColor;
 
    int         numDeforms;
    deformStage_t  deforms[MAX_SHADER_DEFORMS];
 
    int         numUnfoggedPasses;
    shaderStage_t  * unfoggedStages[MAX_SHADER_STAGES];
 
    int         needsLGrid;
    int         needsLSpherical;
    int         stagesWithAlphaFog;
    int         flags;
 
    void        (*optimalStageIteratorFunc)( void );
 
  float clampTime;                                  // time this shader is clamped to
  float timeOffset;                                 // current time offset for this shader
 
  int numStates;                                    // if non-zero this is a state shader
  struct shader_s *currentShader;                   // current state if this is a state shader
  struct shader_s *parentShader;                    // current state if this is a state shader
  int currentState;                                 // current state index for cycle purposes
  long expireTime;                                  // time in milliseconds this expires
 
  struct shader_s *remappedShader;                  // current shader this one is remapped too
 
  int shaderStates[MAX_STATES_PER_SHADER];          // index to valid shader states
 
    struct  shader_s    *next;
} shader_t;
 
typedef struct shaderState_s {
  char shaderName[MAX_QPATH];     // name of shader this state belongs to
  char name[MAX_STATE_NAME];      // name of this state
  char stateShader[MAX_QPATH];    // shader this name invokes
  int cycleTime;                  // time this cycle lasts, <= 0 is forever
  shader_t *shader;
} shaderState_t;
 
 
// trRefdef_t holds everything that comes in refdef_t,
// as well as the locally generated scene information
typedef struct {
    int         x, y, width, height;
    float       fov_x, fov_y;
    vec3_t      vieworg;
    vec3_t      viewaxis[3];        // transformation matrix
 
    stereoFrame_t   stereoFrame;
 
    int         time;               // time in milliseconds for shader effects and other time dependent rendering issues
    int         rdflags;            // RDF_NOWORLDMODEL, etc
 
    // 1 bits will prevent the associated area from rendering at all
    byte        areamask[MAX_MAP_AREA_BYTES];
    qboolean    areamaskModified;   // qtrue if areamask changed since last scene
 
    float       floatTime;          // tr.refdef.time / 1000.0
 
    // text messages for deform text shaders
    char        text[MAX_RENDER_STRINGS][MAX_RENDER_STRING_LENGTH];
 
    int         num_entities;
    trRefEntity_t  *entities;
 
    int         num_sprites;
    refSprite_t *sprites;
 
    int         num_dlights;
    struct dlight_s *dlights;
 
    int         numTerMarks;
    struct srfMarkFragment_s *terMarks;
 
    int         numPolys;
    struct srfPoly_s   *polys;
 
    int         numDrawSurfs;
    struct drawSurf_s *drawSurfs;
 
    int         numSpriteSurfs;
    struct drawSurf_s *spriteSurfs;
 
    int         numStaticModels;
    struct cStaticModelUnpacked_s *staticModels;
 
    int         numStaticModelData;
    unsigned char       *staticModelData;
    qboolean sky_portal;
    float sky_alpha;
    vec3_t sky_origin;
    vec3_t sky_axis[3];
    // added in 2.0
    //==
    qboolean skybox_farplane;
    qboolean render_terrain;
    //==
 
} trRefdef_t;
 
 
//=================================================================================
 
// skins allow models to be retextured without modifying the model file
typedef struct {
    char        name[MAX_QPATH];
    shader_t    *shader;
} skinSurface_t;
 
typedef struct skin_s {
    char        name[MAX_QPATH];        // game path, including extension
    int         numSurfaces;
    skinSurface_t  *surfaces[MD3_MAX_SURFACES];
} skin_t;
 
 
typedef struct {
    int         originalBrushNumber;
    vec3_t      bounds[2];
 
    unsigned    colorInt;               // in packed byte format
    float       tcScale;                // texture coordinate vector scales
    fogParms_t    parms;
 
    // for clipping distance in fog when outside
    qboolean    hasSurface;
    float       surface[4];
} fog_t;
 
typedef struct depthfog_s {
    float len;
    float oolen;
    int enabled;
    int extrafrustums;
} depthfog_t;
 
typedef struct {
    orientationr_t    ori;
    orientationr_t    world;
    vec3_t      pvsOrigin;          // may be different than or.origin for portals
    qboolean    isPortal;           // true if this view is through a portal
    qboolean    isMirror;           // the portal is a mirror, invert the face culling
    qboolean    isPortalSky;        // since 2.0 whether or not this view is a portal sky
    int         frameSceneNum;      // copied from tr.frameSceneNum
    int         frameCount;         // copied from tr.frameCount
    cplane_t    portalPlane;        // clip anything behind this if mirroring
    int         viewportX, viewportY, viewportWidth, viewportHeight;
    float       fovX, fovY;
    float       projectionMatrix[16];
    cplane_t    frustum[5];
    vec3_t      visBounds[2];
    float       zFar;
    depthfog_t  fog;
    float       farplane_distance;
    float       farplane_bias; // added in 2.0
    float       farplane_color[3];
    qboolean    farplane_cull;
    qboolean    renderTerrain; // added in 2.0
} viewParms_t;
 
 
/*
==============================================================================
 
SURFACES
 
==============================================================================
*/
 
typedef struct drawSurf_s {
    unsigned            sort;           // bit combination for fast compares
    surfaceType_t       *surface;       // any of surface*_t
} drawSurf_t;
 
#define MAX_FACE_POINTS     64
 
#define MAX_PATCH_SIZE      32          // max dimensions of a patch mesh in map file
#define MAX_GRID_SIZE       65          // max dimensions of a grid mesh in memory
 
// when cgame directly specifies a polygon, it becomes a srfPoly_t
// as soon as it is called
typedef struct srfPoly_s {
    surfaceType_t   surfaceType;
    qhandle_t       hShader;
    int             numVerts;
    polyVert_t        *verts;
    int             renderfx;
} srfPoly_t;
 
typedef struct srfMarkFragment_s {
    surfaceType_t surfaceType;
    int iIndex;
    int numVerts;
    polyVert_t* verts;
} srfMarkFragment_t;
 
typedef struct srfDisplayList_s {
    surfaceType_t   surfaceType;
    int             listNum;
} srfDisplayList_t;
 
 
typedef struct srfFlare_s {
    surfaceType_t   surfaceType;
    vec3_t          origin;
    vec3_t          normal;
    vec3_t          color;
} srfFlare_t;
 
typedef struct srfGridMesh_s {
    surfaceType_t   surfaceType;
 
    // dynamic lighting information
    int             dlightBits[SMP_FRAMES];
    int             dlightMap[SMP_FRAMES];
 
    // culling information
    vec3_t          meshBounds[2];
    vec3_t          localOrigin;
    float           meshRadius;
 
    // lightmap data
    float           lightmapOffset[2];
    int             lmX;
    int             lmY;
    int             lmWidth;
    int             lmHeight;
    unsigned char   *lmData;
 
    // lod information, which may be different
    // than the culling information to allow for
    // groups of curves that LOD as a unit
    vec3_t          lodOrigin;
    float           lodRadius;
    int             lodFixed;
    int             lodStitched;
 
    // vertexes
    int             width, height;
    float           *widthLodError;
    float           *heightLodError;
    drawVert_t        verts[1];       // variable sized
} srfGridMesh_t;
 
 
 
#define VERTEXSIZE  8
typedef struct {
    surfaceType_t   surfaceType;
    cplane_t    plane;
 
    // dynamic lighting information
    int         dlightBits[SMP_FRAMES];
    int         dlightMap[SMP_FRAMES];
    float       lightmapOffset[2];
    int         lmWidth;
    int         lmHeight;
    int         lmX;
    int         lmY;
    byte*       lmData;
    vec3_t      lmOrigin;
    vec3_t      lmVecs[2];
    vec3_t      lmInverseVecs[2];
 
    // triangle definitions (no normals at points)
    int         numPoints;
    int         numIndices;
    int         ofsIndices;
    float       points[1][VERTEXSIZE];  // variable sized
                                        // there is a variable length list of indices here also
} srfSurfaceFace_t;
 
 
// misc_models in maps are turned into direct geometry by q3map
typedef struct {
    surfaceType_t   surfaceType;
 
    // dynamic lighting information
    int             dlightBits[SMP_FRAMES];
 
    // culling information (FIXME: use this!)
    vec3_t          bounds[2];
    vec3_t          localOrigin;
    float           radius;
 
    // triangle definitions
    int             numIndexes;
    int             *indexes;
 
    int             numVerts;
    drawVert_t        *verts;
} srfTriangles_t;
 
typedef union varnodeUnpacked_u {
    float fVariance;
    int flags;
    /*
    struct {
#if !Q3_BIG_ENDIAN
        byte flags;
        unsigned char unused[3];
#else
        unsigned char unused[3];
        byte flags;
#endif
    } s;
    */
} varnodeUnpacked_t;
 
typedef unsigned short terraInt;
 
typedef struct terrainVert_s {
    vec3_t xyz;
    vec2_t texCoords[2];
    float fVariance;
    float fHgtAvg;
    float fHgtAdd;
    unsigned int uiDistRecalc;
    terraInt nRef;
    terraInt iVertArray;
    byte* pHgt;
    terraInt iNext;
    terraInt iPrev;
} terrainVert_t;
 
typedef struct terraTri_s {
    unsigned short iPt[3];
    terraInt nSplit;
    unsigned int uiDistRecalc;
    struct cTerraPatchUnpacked_s* patch;
    varnodeUnpacked_t* varnode;
    terraInt index;
    byte lod;
    byte byConstChecks;
    terraInt iLeft;
    terraInt iRight;
    terraInt iBase;
    terraInt iLeftChild;
    terraInt iRightChild;
    terraInt iParent;
    terraInt iPrev;
    terraInt iNext;
} terraTri_t;
 
typedef struct srfTerrain_s {
    surfaceType_t surfaceType;
    terraInt iVertHead;
    terraInt iTriHead;
    terraInt iTriTail;
    terraInt iMergeHead;
    int nVerts;
    int nTris;
    int lmapSize;
    int dlightBits[2];
    float lmapStep;
    int dlightMap[2];
    byte* lmData;
    float lmapX;
    float lmapY;
} srfTerrain_t;
 
typedef struct cTerraPatchUnpacked_s {
    srfTerrain_t drawinfo;
    int viewCount;
    int visCountCheck;
    int visCountDraw;
    int frameCount;
    unsigned int uiDistRecalc;
    float s;
    float t;
    vec2_t texCoord[2][2];
    float x0;
    float y0;
    float z0;
    float zmax;
    shader_t* shader;
    short int iNorth;
    short int iEast;
    short int iSouth;
    short int iWest;
    struct cTerraPatchUnpacked_s* pNextActive;
    varnodeUnpacked_t varTree[2][63];
    unsigned char heightmap[81];
    byte flags;
    byte byDirty;
} cTerraPatchUnpacked_t;
 
typedef struct srfStaticModel_s {
    surfaceType_t surfaceType;
    struct cStaticModelUnpacked_s* parent;
} srfStaticModel_t;
 
typedef struct cStaticModelUnpacked_s {
    qboolean useSpecialLighting;
    qboolean bLightGridCalculated;
    qboolean bRendered;
    char model[128];
    vec3_t origin;
    vec3_t angles;
    vec3_t axis[3];
    float scale;
    int firstVertexData;
    int numVertexData;
    int visCount;
    dtiki_t* tiki;
    sphere_dlight_t dlights[MAX_DLIGHTS];
    int numdlights;
    float radius;
    float cull_radius;
    int iGridLighting;
    float lodpercentage[2];
} cStaticModelUnpacked_t;
 
extern  void (*rb_surfaceTable[SF_NUM_SURFACE_TYPES])(void *);
 
/*
==============================================================================
 
BRUSH MODELS
 
==============================================================================
*/
 
 
//
// in memory representation
//
 
#define SIDE_FRONT  0
#define SIDE_BACK   1
#define SIDE_ON     2
 
typedef struct msurface_s {
    int                 viewCount;      // if == tr.viewCount, already added
    int                 frameCount;
    struct shader_s     *shader;
    int                 fogIndex;
 
    surfaceType_t       *data;          // any of srf*_t
} msurface_t;
 
 
 
#define CONTENTS_NODE       -1
typedef struct mnode_s {
    // common with leaf and node
    int         contents;       // -1 for nodes, to differentiate from leafs
    int         visframe;       // node needs to be traversed if current
    vec3_t      mins, maxs;     // for bounding box culling
    struct mnode_s   *parent;
 
    // node specific
    cplane_t    *plane;
    struct mnode_s   *children[2];   
 
    // leaf specific
    int         cluster;
    int         area;
    spherel_t** lights;
    int         numlights;
 
    msurface_t  **firstmarksurface;
    int         nummarksurfaces;
 
    int         firstTerraPatch;
    int         numTerraPatches;
    int         firstStaticModel;
    int         numStaticModels;
    void**      pFirstMarkFragment;
    int         iNumMarkFragment;
} mnode_t;
 
typedef struct {
    vec3_t      bounds[2];      // for culling
    msurface_t  *firstSurface;
    int         numSurfaces;
    void** pFirstMarkFragment;
    int iNumMarkFragment;
    int frameCount;
    qboolean hasLightmap;
} bmodel_t;
 
typedef struct {
    float width;
    float height;
    float origin_x;
    float origin_y;
    float scale;
    shader_t* shader;
} sprite_t;
 
typedef struct {
    char        name[MAX_QPATH];        // ie: maps/tim_dm2.bsp
    char        baseName[MAX_QPATH];    // ie: tim_dm2
 
    int         dataSize;
 
    int         numShaders;
    dshader_t  *shaders;
 
    int         numBmodels;
    bmodel_t    *bmodels;
 
    int         numplanes;
    cplane_t    *planes;
 
    int         numnodes;       // includes leafs
    int         numDecisionNodes;
    mnode_t     *nodes;
 
    int         numsurfaces;
    msurface_t  *surfaces;
 
    int         nummarksurfaces;
    msurface_t  **marksurfaces;
 
    vec3_t      lightGridMins;
    vec3_t      lightGridSize;
    vec3_t      lightGridOOSize;
    int         lightGridBounds[3];
    unsigned short* lightGridOffsets;
    byte        *lightGridData;
    byte        lightGridPalette[768];
 
    int numTerraPatches;
    cTerraPatchUnpacked_t* terraPatches;
    cTerraPatchUnpacked_t* activeTerraPatches;
 
    int numVisTerraPatches;
    cTerraPatchUnpacked_t** visTerraPatches;
 
    int numStaticModelData;
    byte* staticModelData;
 
    int numStaticModels;
    cStaticModelUnpacked_t* staticModels;
 
    int numVisStaticModels;
    cStaticModelUnpacked_t** visStaticModels;
 
    int         numClusters;
    int         clusterBytes;
    const byte  *vis;           // may be passed in by CM_LoadMap to save space
 
    byte        *novis;         // clusterBytes of 0xff
    byte        *lighting;
} world_t;
 
//======================================================================
 
typedef enum {
    MOD_BAD,
    MOD_BRUSH,
    MOD_TIKI,
    MOD_SPRITE
} modtype_t;
 
typedef struct model_s {
    char        name[MAX_QPATH];
    modtype_t   type;
    int         index;              // model = tr.models[model->index]
 
    qboolean serveronly;
    union {
        bmodel_t* bmodel;
        dtiki_t* tiki;
        sprite_t* sprite;
    } d;
} model_t;
 
 
#define MAX_MOD_KNOWN   1024
 
void        R_ModelInit (void);
model_t     *R_GetModelByHandle( qhandle_t hModel );
int         R_LerpTag( orientation_t *tag, qhandle_t handle, int startFrame, int endFrame, 
                     float frac, const char *tagName );
 
void        R_Modellist_f (void);
 
//====================================================
extern  refimport_t      ri;
 
#define MAX_DRAWIMAGES          2048
#define MAX_LIGHTMAPS           256
#define MAX_SKINS               1024
#define MAX_SPHERE_LIGHTS       512
 
#define MAX_DRAWSURFS           0x10000
#define MAX_SPRITESURFS         0x8000
#define DRAWSURF_MASK           (MAX_DRAWSURFS-1)
 
#define MAX_SPRITE_DIST             16384.0f
#define MAX_SPRITE_DIST_SQUARED     (MAX_SPRITE_DIST * MAX_SPRITE_DIST)
 
/*
 
the drawsurf sort data is packed into a single 32 bit value so it can be
compared quickly during the qsorting process
 
the bits are allocated as follows:
 
21 - 31 : sorted shader index
11 - 20 : entity index
2 - 6   : fog index
//2     : used to be clipped flag REMOVED - 03.21.00 rad
0 - 1   : dlightmap index
 
    TTimo - 1.32
17-31 : sorted shader index
7-16  : entity index
2-6   : fog index
0-1   : dlightmap index
*/
#define QSORT_SHADERNUM_SHIFT   21 // was 22, decreased in 2.30
#define QSORT_ENTITYNUM_SHIFT   8
#define QSORT_FOGNUM_SHIFT      2
#define QSORT_REFENTITYNUM_SHIFT    7
#define QSORT_STATICMODEL_SHIFT 20 // was 21, decreased in 2.30
 
extern  int         gl_filter_min, gl_filter_max;
 
/*
** performanceCounters_t
*/
typedef struct {
    int     c_sphere_cull_patch_in, c_sphere_cull_patch_clip, c_sphere_cull_patch_out;
    int     c_box_cull_patch_in, c_box_cull_patch_clip, c_box_cull_patch_out;
    int     c_sphere_cull_md3_in, c_sphere_cull_md3_clip, c_sphere_cull_md3_out;
    int     c_box_cull_md3_in, c_box_cull_md3_clip, c_box_cull_md3_out;
 
    int     c_leafs;
    int     c_dlightSurfaces;
    int     c_dlightSurfacesCulled;
    int     c_dlightMaps;
    int     c_dlightTexels;
} frontEndCounters_t;
 
#define FOG_TABLE_SIZE      256
#define FUNCTABLE_SIZE      1024
#define FUNCTABLE_SIZE2     10
#define FUNCTABLE_MASK      (FUNCTABLE_SIZE-1)
 
 
// the renderer front end should never modify glstate_t
typedef struct {
    int         currenttextures[2];
    int         currenttmu;
    qboolean    finishCalled;
    int         texEnv[2];
    int         faceCulling;
    int         cntTexEnvExt;
    int         cntnvblendmode;
    long unsigned int glStateBits;
    long unsigned int externalSetState;
    vec4_t fFogColor;
} glstate_t;
 
 
typedef struct {
    int     c_surfaces, c_shaders, c_vertexes, c_indexes, c_totalIndexes, c_characterlights;
    float   c_overDraw;
    
    int     c_dlightVertexes;
    int     c_dlightIndexes;
 
    int     c_flareAdds;
    int     c_flareTests;
    int     c_flareRenders;
 
    int     msec;           // total msec for backend run
} backEndCounters_t;
 
// all state modified by the back end is seperated
// from the front end state
typedef struct {
    int         smpFrame;
    trRefdef_t    refdef;
    viewParms_t  viewParms;
    orientationr_t    ori;
    backEndCounters_t  pc;
    qboolean    isHyperspace;
    trRefEntity_t  *currentEntity;
    qboolean skyRenderedThisView;   // flag for drawing sun
    sphereor_t spheres[MAX_SPHERE_LIGHTS];
    unsigned short numSpheresUsed;
    sphereor_t* currentSphere;
    sphereor_t spareSphere;
    sphereor_t hudSphere;
    cStaticModelUnpacked_t* currentStaticModel;
    int dsStreamVert;
    qboolean in2D;  // if qtrue, drawstretchpic doesn't need to change modes
    byte color2D[4];
    qboolean vertexes2D;        // shader needs to be finished
    trRefEntity_t entity2D;    // currentEntity will point at this when doing 2D rendering
    int backEndMsec;
    float shaderStartTime;
} backEndState_t;
 
/*
** trGlobals_t 
**
** Most renderer globals are defined here.
** backend functions should never modify any of these fields,
** but may read fields that aren't dynamically modified
** by the frontend.
*/
typedef struct {
    qboolean                registered;     // cleared at shutdown, set at beginRegistration
 
    int                     visCount;       // incremented every time a new vis cluster is entered
    int                     frameCount;     // incremented every frame
    int                     sceneCount;     // incremented every scene
    int                     viewCount;      // incremented every view (twice a scene if portaled)
                                            // and every R_MarkFragments call
 
    int                     smpFrame;       // toggles from 0 to 1 every endFrame
 
    int                     frameSceneNum;  // zeroed at RE_BeginFrame
 
    qboolean                worldMapLoaded;
    world_t                  *world;
 
    const byte              *externalVisData;   // from RE_SetWorldVisData, shared with CM_Load
 
    image_t                 *defaultImage;
    image_t                 *scratchImage;
    image_t                 *fogImage;
    image_t                 *dlightImage;   // inverse-quare highlight for projective adding
    image_t                 *flareImage;
    image_t                 *whiteImage;            // full of 0xff
    image_t                 *identityLightImage;    // full of tr.identityLightByte
    image_t                 *dlightImages[15];
 
    shader_t                *defaultShader;
    shader_t                *shadowShader;
    shader_t                *projectionShadowShader;
 
    shader_t                *flareShader;
    shader_t                *sunShader;
 
    int                     numLightmaps;
    image_t                 *lightmaps[MAX_LIGHTMAPS];
 
    trRefEntity_t          *currentEntity;
    trRefEntity_t          worldEntity;        // point currentEntity at this when rendering world
    int                     currentEntityNum;
    int                     currentSpriteNum;
    int                     shiftedEntityNum;   // currentEntityNum << QSORT_ENTITYNUM_SHIFT
    int                     shiftedIsStatic;
    model_t                 *currentModel;
 
    viewParms_t              viewParms;
 
    float                   identityLight;      // 1.0 / ( 1 << overbrightBits )
    int                     identityLightByte;  // identityLight * 255
    int                     overbrightBits;     // r_overbrightBits->integer, but set to 0 if no hw gamma
    int                     overbrightShift;
    float                   overbrightMult;
    int                     needsLightScale;
 
    orientationr_t            ori;                // for current entity
 
    portalsky_t              portalsky;
    qboolean                skyRendered;
    qboolean                portalRendered;
    trRefdef_t                refdef;
 
    int                     viewCluster;
 
    vec3_t                  sunLight;           // from the sky shader for this level
    vec3_t                  sunDirection;
 
    frontEndCounters_t        pc;
    int                     frontEndMsec;       // not in pc due to clearing issue
 
    //
    // put large tables at the end, so most elements will be
    // within the +/32K indexed range on risc processors
    //
    model_t                 models[MAX_MOD_KNOWN];
    int                     numModels;
 
    int                     numImages;
    image_t                 images[MAX_DRAWIMAGES];
 
    // shader indexes from other modules will be looked up in tr.shaders[]
    // shader indexes from drawsurfs will be looked up in sortedShaders[]
    // lower indexed sortedShaders must be rendered first (opaque surfaces before translucent)
    int                     numShaders;
    shader_t                *shaders[MAX_SHADERS];
    shader_t                *sortedShaders[MAX_SHADERS];
 
    int                     numSkins;
    skin_t                  *skins[MAX_SKINS];
 
    float                   sinTable[FUNCTABLE_SIZE];
    float                   squareTable[FUNCTABLE_SIZE];
    float                   triangleTable[FUNCTABLE_SIZE];
    float                   sawToothTable[FUNCTABLE_SIZE];
    float                   inverseSawToothTable[FUNCTABLE_SIZE];
 
    spherel_t sSunLight;
    spherel_t sLights[1532];
    int numSLights;
    int rendererhandle;
    qboolean shadersParsed;
    int frame_skel_index;
    int skel_index[1024];
    fontheader_t* pFontDebugStrings;
 
    int farclip;
} trGlobals_t;
 
extern backEndState_t backEnd;
extern trGlobals_t   tr;
extern glconfig_t glConfig;       // outside of TR since it shouldn't be cleared during ref re-init
 
// These variables should live inside glConfig but can't because of
// compatibility issues to the original ID vms.  If you release a stand-alone
// game and your mod uses tr_types.h from this build you can safely move them
// to the glconfig_t struct.
extern qboolean  textureFilterAnisotropic;
extern int       maxAnisotropy;
extern float     displayAspect;
extern qboolean  haveClampToEdge;
 
extern glstate_t   glState;        // outside of TR since it shouldn't be cleared during ref re-init
extern int r_sequencenumber;
 
 
//
// cvars
//
extern cvar_t   *r_flareSize;
extern cvar_t   *r_flareFade;
 
extern cvar_t   *r_ignore;              // used for debugging anything
extern cvar_t   *r_verbose;             // used for verbose debug spew
extern cvar_t   *r_ignoreFastPath;      // allows us to ignore our Tess fast paths
 
extern cvar_t   *r_znear;               // near Z clip plane
 
extern cvar_t   *r_stencilbits;         // number of desired stencil bits
extern cvar_t   *r_depthbits;           // number of desired depth bits
extern cvar_t   *r_colorbits;           // number of desired color bits, only relevant for fullscreen
extern cvar_t   *r_stereo;              // desired pixelformat stereo flag
extern cvar_t   *r_textureDetails;
extern cvar_t   *r_texturebits;         // number of desired texture bits
                                        // 0 = use framebuffer depth
                                        // 16 = use 16-bit textures
                                        // 32 = use 32-bit textures
                                        // all else = error
 
extern cvar_t   *r_measureOverdraw;     // enables stencil buffer overdraw measurement
 
extern cvar_t   *r_lodscale;
 
extern cvar_t   *r_primitives;          // "0" = based on compiled vertex array existance
                                        // "1" = glDrawElemet tristrips
                                        // "2" = glDrawElements triangles
                                        // "-1" = no drawing
 
extern cvar_t   *r_largemap;
extern cvar_t   *r_inGameVideo;             // controls whether in game video should be draw
extern cvar_t   *r_fastsky;             // controls whether sky should be cleared or drawn
extern cvar_t   *r_fastdlights;
extern cvar_t   *r_drawSun;             // controls drawing of sun quad
extern cvar_t   *r_dlightBacks;         // dlight non-facing surfaces for continuity
 
extern  cvar_t  *r_norefresh;           // bypasses the ref rendering
extern  cvar_t  *r_drawentities;        // disable/enable entity rendering
extern  cvar_t  *r_drawentitypoly;
extern  cvar_t  *r_drawstaticmodels;
extern  cvar_t  *r_drawstaticmodelpoly;
extern  cvar_t  *r_drawbrushes;
extern  cvar_t  *r_drawbrushmodels;
extern  cvar_t  *r_drawstaticdecals;
extern  cvar_t  *r_drawterrain;
extern  cvar_t  *r_drawsprites;
extern  cvar_t  *r_drawspherelights;
extern  cvar_t  *r_drawworld;           // disable/enable world rendering
extern  cvar_t  *r_speeds;              // various levels of information display
extern  cvar_t  *r_detailTextures;      // enables/disables detail texturing stages
extern  cvar_t  *r_novis;               // disable/enable usage of PVS
extern  cvar_t  *r_nocull;
extern  cvar_t  *r_showcull;
extern  cvar_t  *r_facePlaneCull;       // enables culling of planar surfaces with back side test
extern  cvar_t  *r_nocurves;
extern  cvar_t  *r_showcluster;
 
extern cvar_t   *r_mode;                // video mode
extern cvar_t   *r_maxmode;
extern cvar_t   *r_vidmode1024;
extern cvar_t   *r_vidmodemax;
extern cvar_t   *r_fullscreen;
extern cvar_t   *r_gamma;
extern cvar_t   *r_displayRefresh;      // optional display refresh option
extern cvar_t   *r_ignorehwgamma;       // overrides hardware gamma capabilities
 
extern cvar_t   *r_allowExtensions;             // global enable/disable of OpenGL extensions
extern cvar_t   *r_ext_compressed_textures;     // these control use of specific extensions
extern cvar_t   *r_ext_gamma_control;
extern cvar_t   *r_ext_texenv_op;
extern cvar_t   *r_ext_multitexture;
extern cvar_t   *r_ext_compiled_vertex_array;
extern cvar_t   *r_ext_texture_env_add;
extern cvar_t   *r_ext_texture_env_combine;
extern cvar_t   *r_ext_aniso_filter;
extern cvar_t   *r_ext_max_anisotropy;
extern cvar_t   *r_forceClampToEdge;
extern cvar_t   *r_geForce3WorkAround;
extern cvar_t   *r_reset_tc_array;
 
extern  cvar_t  *r_nobind;                      // turns off binding to appropriate textures
extern  cvar_t  *r_singleShader;                // make most world faces use default shader
extern  cvar_t  *r_lerpmodels;
extern  cvar_t  *r_roundImagesDown;
extern  cvar_t  *r_colorMipLevels;              // development aid to see texture mip usage
extern  cvar_t  *r_picmip;                      // controls picmip values
extern  cvar_t  *r_finish;
extern  cvar_t  *r_drawBuffer;
extern  cvar_t  *r_glDriver;
extern  cvar_t  *r_swapInterval;
extern  cvar_t  *r_textureMode;
extern  cvar_t  *r_offsetFactor;
extern  cvar_t  *r_offsetUnits;
 
extern  cvar_t  *r_fullbright;                  // avoid lightmap pass
extern  cvar_t  *r_lightmap;                    // render lightmaps only
extern  cvar_t  *r_vertexLight;                 // vertex lighting mode for better performance
 
extern  cvar_t  *r_logFile;                     // number of frames to emit GL logs
extern  cvar_t  *r_showtris;                    // enables wireframe rendering of the world
extern  cvar_t  *r_showsky;                     // forces sky in front of all surfaces
extern  cvar_t  *r_shownormals;                 // draws wireframe normals
extern  cvar_t  *r_showhbox;
extern  cvar_t  *r_showstaticbboxes;
extern  cvar_t  *r_clear;                       // force screen clear every frame
 
extern  cvar_t  *r_shadows;                     // controls shadows: 0 = none, 1 = blur, 2 = stencil, 3 = black planar projection
extern  cvar_t  *r_entlight_scale;
extern  cvar_t  *r_entlight_errbound;
extern  cvar_t  *r_entlight_cubelevel;
extern  cvar_t  *r_entlight_cubefraction;
extern  cvar_t  *r_entlight_maxcalc;
extern  cvar_t  *r_flares;                      // light flares
 
extern  cvar_t  *r_intensity;
 
extern  cvar_t  *r_lockpvs;
extern  cvar_t  *r_noportals;
extern  cvar_t  *r_entlightmap;
extern  cvar_t  *r_fastentlight;
extern  cvar_t  *r_portalOnly;
 
extern  cvar_t  *r_subdivisions;
extern  cvar_t  *r_lodCurveError;
extern  cvar_t  *r_skipBackEnd;
 
extern  cvar_t  *r_anaglyphMode;
 
extern  cvar_t  *r_ignoreGLErrors;
 
extern  cvar_t  *r_overBrightBits;
extern  cvar_t  *r_mapOverBrightBits;
 
extern  cvar_t  *r_debugSurface;
 
extern  cvar_t  *r_showImages;
extern  cvar_t  *r_showlod;
extern  cvar_t  *r_showstaticlod;
extern  cvar_t  *r_debugSort;
 
extern  cvar_t  *r_printShaders;
extern  cvar_t  *r_saveFontData;
 
extern  cvar_t* r_staticlod;
extern  cvar_t* r_lodscale;
extern  cvar_t* r_lodcap;
extern  cvar_t* r_lodviewmodelcap;
 
extern  cvar_t* r_uselod;
extern  cvar_t* lod_LOD;
extern  cvar_t* lod_minLOD;
extern  cvar_t* lod_maxLOD;
extern  cvar_t* lod_LOD_slider;
extern  cvar_t* lod_curve_0_val;
extern  cvar_t* lod_curve_1_val;
extern  cvar_t* lod_curve_2_val;
extern  cvar_t* lod_curve_3_val;
extern  cvar_t* lod_curve_4_val;
extern  cvar_t* lod_edit_0;
extern  cvar_t* lod_edit_1;
extern  cvar_t* lod_edit_2;
extern  cvar_t* lod_edit_3;
extern  cvar_t* lod_edit_4;
extern  cvar_t* lod_curve_0_slider;
extern  cvar_t* lod_curve_1_slider;
extern  cvar_t* lod_curve_2_slider;
extern  cvar_t* lod_curve_3_slider;
extern  cvar_t* lod_curve_4_slider;
extern  cvar_t* lod_pitch_val;
extern  cvar_t* lod_zee_val;
extern  cvar_t* lod_mesh;
extern  cvar_t* lod_meshname;
extern  cvar_t* lod_tikiname;
extern  cvar_t* lod_metric;
extern  cvar_t* lod_tris;
extern  cvar_t* lod_position;
extern  cvar_t* lod_save;
extern  cvar_t* lod_tool;
extern  cvar_t* sys_cpuid;
extern  cvar_t* r_sse;
extern  cvar_t* r_static_shaderdata0;
extern  cvar_t* r_static_shaderdata1;
extern  cvar_t* r_static_shaderdata2;
extern  cvar_t* r_static_shaderdata3;
extern  cvar_t* r_static_shadermultiplier0;
extern  cvar_t* r_static_shadermultiplier1;
extern  cvar_t* r_static_shadermultiplier2;
extern  cvar_t* r_static_shadermultiplier3;
 
extern  cvar_t* r_numdebuglines;
 
extern  cvar_t* r_stipplelines;
extern  cvar_t* r_light_lines;
extern  cvar_t* r_light_sun_line;
extern  cvar_t* r_light_int_scale;
extern  cvar_t* r_light_nolight;
extern  cvar_t* r_light_showgrid;
extern  cvar_t* r_skyportal;
extern  cvar_t* r_skyportal_origin;
extern  cvar_t* r_farplane;
extern  cvar_t* r_farplane_bias;
extern  cvar_t* r_farplane_color;
extern  cvar_t* r_farplane_nocull;
extern  cvar_t* r_farplane_nofog;
extern  cvar_t* r_skybox_farplane;
extern  cvar_t* r_farclip;
extern  cvar_t* r_lightcoronasize;
extern  cvar_t* r_useglfog;
extern  cvar_t* r_debuglines_depthmask;
extern  cvar_t* r_smoothsmokelight;
extern  cvar_t* r_showportal;
extern  cvar_t* ter_minMarkRadius;
extern  cvar_t* ter_fastMarks;
extern  cvar_t* r_alpha_foliage1;
extern  cvar_t* r_alpha_foliage2;
extern  cvar_t* r_blendtrees;
extern  cvar_t* r_blendbushes;
extern  cvar_t* r_bumpmap;
extern  cvar_t* r_loadjpg;
extern  cvar_t* r_loadftx;
 
extern  cvar_t* r_showSkeleton;
extern  cvar_t* r_developer;
extern  cvar_t* r_fps;
 
//====================================================================
 
void  R_NoiseInit( void );
 
void R_RenderView( viewParms_t *parms );
 
qboolean SurfIsOffscreen(const srfSurfaceFace_t* surface, shader_t* shader, int entityNum);
 
void R_AddMD3Surfaces( trRefEntity_t *e );
void R_AddNullModelSurfaces( trRefEntity_t *e );
void R_AddBeamSurfaces( trRefEntity_t *e );
void R_AddRailSurfaces( trRefEntity_t *e, qboolean isUnderwater );
void R_AddLightningBoltSurfaces( trRefEntity_t *e );
 
void R_AddPolygonSurfaces( void );
 
void R_DecomposeSort(unsigned int sort, int* entityNum, shader_t** shader, int* dlightMap, qboolean* bStaticModel);
 
void R_AddDrawSurf(surfaceType_t* surface, shader_t* shader, int dlightMap);
 
 
#define CULL_IN     0       // completely unclipped
#define CULL_CLIP   1       // clipped by one or more planes
#define CULL_OUT    2       // completely outside the clipping planes
void R_LocalNormalToWorld (const vec3_t local, vec3_t world);
void R_LocalPointToWorld (const vec3_t local, vec3_t world);
int R_CullLocalBoxOffset(const vec3_t offset, vec3_t bounds[2]);
int R_CullLocalBox (vec3_t bounds[2]);
int R_CullPointAndRadius( vec3_t origin, float radius );
int R_CullLocalPointAndRadius( vec3_t origin, float radius );
int R_DistanceCullLocalPointAndRadius(float fDist, const vec3_t pt, float radius);
int R_DistanceCullPointAndRadius(float fDist, const vec3_t pt, float radius);
 
void R_RotateForEntity( const trRefEntity_t *ent, const viewParms_t *viewParms, orientationr_t *ori );
void R_RotateForStaticModel(cStaticModelUnpacked_t* SM, const viewParms_t* viewParms, orientationr_t* ori );
void R_RotateForViewer(void);
void R_SetupFrustum(void);
 
/*
** GL wrapper/helper functions
*/
void    GL_SetFogColor(const vec4_t fColor);
void    GL_Bind( image_t *image );
void    GL_SetDefaultState (void);
void    GL_SelectTexture( int unit );
void    GL_TextureMode( const char *string );
void    GL_CheckErrors( void );
void    GL_State( unsigned long stateVector );
void    GL_TexEnv( int env );
void    GL_Cull( int cullType );
 
#define GLS_SRCBLEND_ZERO                       0x00000001
#define GLS_SRCBLEND_ONE                        0x00000002
#define GLS_SRCBLEND_DST_COLOR                  0x00000003
#define GLS_SRCBLEND_ONE_MINUS_DST_COLOR        0x00000004
#define GLS_SRCBLEND_SRC_ALPHA                  0x00000005
#define GLS_SRCBLEND_ONE_MINUS_SRC_ALPHA        0x00000006
#define GLS_SRCBLEND_DST_ALPHA                  0x00000007
#define GLS_SRCBLEND_ONE_MINUS_DST_ALPHA        0x00000008
#define GLS_SRCBLEND_ALPHA_SATURATE             0x00000009
#define     GLS_SRCBLEND_BITS                   0x0000000f
 
#define GLS_DSTBLEND_ZERO                       0x00000010
#define GLS_DSTBLEND_ONE                        0x00000020
#define GLS_DSTBLEND_SRC_COLOR                  0x00000030
#define GLS_DSTBLEND_ONE_MINUS_SRC_COLOR        0x00000040
#define GLS_DSTBLEND_SRC_ALPHA                  0x00000050
#define GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA        0x00000060
#define GLS_DSTBLEND_DST_ALPHA                  0x00000070
#define GLS_DSTBLEND_ONE_MINUS_DST_ALPHA        0x00000080
#define     GLS_DSTBLEND_BITS                   0x000000f0
 
#define GLS_DEPTHMASK_TRUE                      0x00000100
#define GLS_COLOR_MASK                          0x00000200
#define GLS_POLYMODE_LINE                       0x00000400
#define GLS_DEPTHTEST_DISABLE                   0x00000800
#define GLS_DEPTHFUNC_EQUAL                     0x00001000
 
#define GLS_CLAMP_EDGE                          0x00002000
#define GLS_MULTITEXTURE                        0x00004000
#define GLS_MULTITEXTURE_ENV                    0x00008000
#define GLS_FOG                                 0x00010000
 
#define GLS_FOG_ENABLED                         0x00020000
#define GLS_FOG_BLACK                           0x00040000
#define GLS_FOG_WHITE                           0x00080000
#define GLS_FOG_COLOR                           (GLS_FOG_BLACK | GLS_FOG_WHITE)
#define GLS_FOG_BITS                            (GLS_FOG_WHITE|GLS_FOG_BLACK|GLS_FOG_ENABLED)
#define GLS_COLOR_NOMASK                        0x00100000
 
#define GLS_ATEST_GT_0                          0x10000000
#define GLS_ATEST_LT_80                         0x20000000
#define GLS_ATEST_GE_80                         0x30000000
#define GLS_ATEST_LT_FOLIAGE1                   0x40000000
#define GLS_ATEST_GE_FOLIAGE1                   0x50000000
#define GLS_ATEST_LT_FOLIAGE2                   0x60000000
#define GLS_ATEST_GE_FOLIAGE2                   0x70000000
#define GLS_ATEST_BITS                          0x70000000
 
#define GLS_DEFAULT         GLS_DEPTHMASK_TRUE
 
void Draw_SetColor(const vec4_t rgba);
void Draw_StretchPic(float x, float y, float w, float h, float s1, float t1, float s2, float t2, qhandle_t hShader);
void Draw_StretchPic2(float x, float y, float w, float h, float s1, float t1, float s2, float t2, float sx, float sy, qhandle_t hShader);
void Draw_TilePic(float x, float y, float w, float h, qhandle_t hShader);
void Draw_TilePicOffset(float x, float y, float w, float h, qhandle_t hShader, int offsetX, int offsetY);
void Draw_TrianglePic(const vec2_t vPoints[3], const vec2_t vTexCoords[3], qhandle_t hShader);
void DrawBox(float x, float y, float w, float h);
void AddBox(float x, float y, float w, float h);
void Set2DWindow(int x, int y, int w, int h, float left, float right, float bottom, float top, float n, float f);
void RE_Scissor(int x, int y, int width, int height);
void DrawLineLoop(const vec2_t* points, int count, int stipple_factor, int stipple_mask);
void RE_StretchRaw(int x, int y, int w, int h, int cols, int rows, int components, const byte* data);
void    RE_UploadCinematic (int w, int h, int cols, int rows, const byte *data, int client, qboolean dirty);
 
void        RE_BeginFrame( stereoFrame_t stereoFrame );
void        RE_BeginRegistration( glconfig_t *glconfig );
void        RE_LoadWorldMap( const char *mapname );
void        RE_PrintBSPFileSizes(void);
int         RE_MapVersion(void);
void        RE_SetWorldVisData( const byte *vis );
qhandle_t   RE_RegisterModel( const char *name );
qhandle_t   RE_RegisterSkin( const char *name );
void        RE_Shutdown( qboolean destroyWindow );
void        R_ClearWorld(void);
 
qboolean    R_GetEntityToken( char *buffer, int size );
 
model_t     *R_AllocModel( void );
 
void        R_Init( void );
 
image_t     *R_FindImageFileOld(const char* name, qboolean mipmap, qboolean allowPicmip, qboolean force32bit, int glWrapClampModeX, int glWrapClampModeY);
image_t     *R_RefreshImageFileOld(const char* name, qboolean mipmap, qboolean allowPicmip, qboolean force32bit, int glWrapClampModeX, int glWrapClampModeY);
 
image_t* R_CreateImageOld(
    const char* name,
    byte* pic,
    int width,
    int height,
    int numMipmaps,
    int iMipmapsAvailable,
    qboolean allowPicmip,
    qboolean force32bit,
    qboolean hasAlpha,
    int glCompressMode,
    int glWrapClampModeX,
    int glWrapClampModeY
);
 
qboolean R_ImageExists(const char* name);
int R_CountTextureMemory();
qboolean R_LoadRawImage(const char *name, byte **pic, int *width, int *height);
void R_FreeRawImage(byte *pic);
 
qboolean    R_GetModeInfo( int *width, int *height, float *windowAspect, int mode );
 
void        R_SetColorMappings( void );
void        R_GammaCorrect( byte *buffer, int bufSize );
 
void    R_ImageList_f( void );
void    R_SkinList_f( void );
// https://zerowing.idsoftware.com/bugzilla/show_bug.cgi?id=516
const void *RB_TakeScreenshotCmd( const void *data );
void    R_ScreenShot_f( void );
 
void    R_InitImages( void );
void    R_FreeImage(image_t* image);
void    R_DeleteTextures( void );
void    R_FreeUnusedImages( void );
int     R_SumOfUsedImages( void );
skin_t  *R_GetSkinByHandle( qhandle_t hSkin );
 
const void *RB_TakeVideoFrameCmd( const void *data );
 
//
// tr_shader.c
//
qhandle_t        RE_RegisterShader( const char *name );
qhandle_t        RE_RegisterShaderNoMip( const char *name );
qhandle_t       RE_RefreshShaderNoMip(const char* name);
qhandle_t RE_RegisterShaderFromImage(const char *name, int lightmapIndex, image_t *image, qboolean mipRawImage);
 
shader_t* R_FindShader(const char* name, int lightmapIndex, qboolean mipRawImage, qboolean picmip, qboolean wrapx, qboolean wrapy);
shader_t    *R_GetShaderByHandle( qhandle_t hShader );
shader_t    *R_GetShaderByState( int index, long *cycleTime );
void R_StartupShaders();
void R_ShutdownShaders();
void R_SetupShaders();
shader_t *R_FindShaderByName( const char *name );
void        R_ShaderList_f( void );
void    R_RemapShader(const char *oldShader, const char *newShader, const char *timeOffset);
 
/*
====================================================================
 
IMPLEMENTATION SPECIFIC FUNCTIONS
 
====================================================================
*/
 
void        GLimp_Init( qboolean fixedFunction );
void        GLimp_Shutdown( void );
void        GLimp_EndFrame( void );
 
qboolean    GLimp_SpawnRenderThread( void (*function)( void ) );
void        *GLimp_RendererSleep( void );
void        GLimp_FrontEndSleep( void );
void        GLimp_WakeRenderer( void *data );
 
void        GLimp_LogComment( char *comment );
 
// NOTE TTimo linux works with float gamma value, not the gamma table
//   the params won't be used, getting the r_gamma cvar directly
void        GLimp_SetGamma( unsigned char red[256], 
                            unsigned char green[256],
                            unsigned char blue[256] );
 
 
/*
====================================================================
 
TESSELATOR/SHADER DECLARATIONS
 
====================================================================
*/
typedef byte color4ub_t[4];
 
typedef struct stageVars
{
    color4ub_t  colors[SHADER_MAX_VERTEXES];
    vec2_t      texcoords[NUM_TEXTURE_BUNDLES][SHADER_MAX_VERTEXES];
} stageVars_t;
 
typedef struct shaderCommands_s 
{
    glIndex_t   indexes[SHADER_MAX_INDEXES] QALIGN(16);
    vec4_t      xyz[SHADER_MAX_VERTEXES] QALIGN(16);
    vec4_t      normal[SHADER_MAX_VERTEXES] QALIGN(16);
    vec2_t      texCoords[SHADER_MAX_VERTEXES][2] QALIGN(16);
    color4ub_t  vertexColors[SHADER_MAX_VERTEXES] QALIGN(16);
    int         vertexDlightBits[SHADER_MAX_VERTEXES] QALIGN(16);
 
    stageVars_t svars QALIGN(16);
 
    color4ub_t  constantColor255[SHADER_MAX_VERTEXES] QALIGN(16);
 
    shader_t    *shader;
    float       shaderTime;
    int         fogNum;
 
    int         dlightBits; // or together of all vertexDlightBits
    int         dlightMap;
 
    int         numIndexes;
    int         numVertexes;
 
    // info extracted from current shader
    int         numPasses;
    void        (*currentStageIteratorFunc)( void );
    shaderStage_t  **xstages;
    qboolean no_global_fog;
    qboolean vertexColorValid;
} shaderCommands_t;
 
extern  shaderCommands_t    tess;
 
void RB_BeginSurface(shader_t *shader );
void RB_EndSurface(void);
void RB_CheckOverflow( int verts, int indexes );
#define RB_CHECKOVERFLOW(v,i) if (tess.numVertexes + (v) >= SHADER_MAX_VERTEXES || tess.numIndexes + (i) >= SHADER_MAX_INDEXES ) {RB_CheckOverflow(v,i);}
 
void RB_StageIteratorGeneric( void );
void RB_StageIteratorSky( void );
void RB_StageIteratorVertexLitTextureUnfogged( void );
void RB_StageIteratorLightmappedMultitextureUnfogged( void );
 
void RB_AddQuadStamp( vec3_t origin, vec3_t left, vec3_t up, byte *color );
void RB_AddQuadStampExt( vec3_t origin, vec3_t left, vec3_t up, byte *color, float s1, float t1, float s2, float t2 );
 
void RB_ShowImages( qboolean quiet );
 
 
/*
============================================================
 
WORLD MAP
 
============================================================
*/
 
extern terraTri_t* g_pTris;
extern terrainVert_t* g_pVert;
 
void R_AddBrushModelSurfaces( trRefEntity_t *e );
void R_GetInlineModelBounds(int iIndex, vec3_t vMins, vec3_t vMaxs);
int R_SphereInLeafs(const vec3_t p, float r, mnode_t** nodes, int nMaxNodes);
mnode_t* R_PointInLeaf(const vec3_t p);
int R_DlightTerrain(cTerraPatchUnpacked_t* surf, int dlightBits);
int R_CheckDlightTerrain(cTerraPatchUnpacked_t* surf, int dlightBits);
void R_AddWorldSurfaces( void );
qboolean R_inPVS( const vec3_t p1, const vec3_t p2 );
 
 
/*
============================================================
 
FLARES
 
============================================================
*/
 
void R_ClearFlares( void );
 
void RB_AddFlare( void *surface, int fogNum, vec3_t point, vec3_t color, vec3_t normal );
void RB_AddDlightFlares( void );
void RB_RenderFlares (void);
 
/*
============================================================
 
LIGHTS
 
============================================================
*/
 
void R_DlightBmodel( bmodel_t *bmodel );
void R_GetLightingGridValue(const vec3_t vPos, vec3_t vLight);
void R_GetLightingGridValueFast(const vec3_t vPos, vec3_t vLight);
void R_GetLightingForDecal(vec3_t vLight, const vec3_t vFacing, const vec3_t vOrigin);
void R_GetLightingForSmoke(vec3_t vLight, const vec3_t vOrigin);
void R_SetupEntityLighting( const trRefdef_t *refdef, trRefEntity_t *ent );
void RB_SetupEntityGridLighting();
void RB_SetupStaticModelGridLighting(trRefdef_t* refdef, cStaticModelUnpacked_t* ent, const vec3_t lightOrigin);
int R_RealDlightPatch(srfGridMesh_t* srf, int dlightBit);
int R_RealDlightFace(srfSurfaceFace_t* srf, int dlightBits);
int R_RealDlightTerrain(cTerraPatchUnpacked_t* srf, int dlightBits);
void R_TransformDlights( int count, dlight_t *dl, orientationr_t *ori );
void RB_Light_Real(unsigned char* colors);
void RB_Sphere_BuildDLights();
void RB_Sphere_SetupEntity();
void RB_Grid_SetupEntity();
void RB_Grid_SetupStaticModel();
void RB_Light_Fullbright(unsigned char* colors);
void R_Sphere_InitLights();
int R_GatherLightSources(const vec3_t vPos, vec3_t* pvLightPos, vec3_t* pvLightIntensity, int iMaxLights);
void R_ClearRealDlights();
void R_UploadDlights();
 
int R_LightForPoint(vec3_t point, vec3_t ambientLight, vec3_t directedLight, vec3_t lightDir);
 
/*
============================================================
 
SHADOWS
 
============================================================
*/
 
void RB_ShadowTessEnd( void );
void RB_ComputeShadowVolume();
void RB_ShadowFinish( void );
void RB_ProjectionShadowDeform( void );
 
/*
============================================================
 
SKIES
 
============================================================
*/
 
void R_BuildCloudData( shaderCommands_t *shader );
void R_InitSkyTexCoords( float cloudLayerHeight );
void R_DrawSkyBox( shaderCommands_t *shader );
void RB_DrawSun( void );
void RB_ClipSkyPolygons( shaderCommands_t *shader );
 
/*
============================================================
 
CURVE TESSELATION
 
============================================================
*/
 
#define PATCH_STITCHING
 
srfGridMesh_t *R_SubdividePatchToGrid( int width, int height, float subdivide,
                                drawVert_t points[MAX_PATCH_SIZE*MAX_PATCH_SIZE] );
srfGridMesh_t *R_GridInsertColumn( srfGridMesh_t *grid, int column, int row, vec3_t point, float loderror );
srfGridMesh_t *R_GridInsertRow( srfGridMesh_t *grid, int row, int column, vec3_t point, float loderror );
void R_FreeSurfaceGridMesh( srfGridMesh_t *grid );
 
/*
============================================================
 
MARKERS, POLYGON PROJECTION ON WORLD POLYGONS
 
============================================================
*/
 
int R_MarkFragments( int numPoints, const vec3_t *points, const vec3_t projection,
                   int maxPoints, vec3_t pointBuffer, int maxFragments, markFragment_t *fragmentBuffer, float fRadiusSquared);
 
int R_MarkFragmentsForInlineModel(clipHandle_t bmodel, const vec3_t vAngles, const vec3_t vOrigin, int numPoints,
    const vec3_t* points, const vec3_t projection, int maxPoints, vec3_t pointBuffer,
    int maxFragments, markFragment_t* fragmentBuffer, float fRadiusSquared);
 
 
/*
============================================================
 
SCENE GENERATION
 
============================================================
*/
 
void R_InitNextFrame( void );
 
void RE_ClearScene( void );
void RE_AddRefEntityToScene( const refEntity_t *ent, int parentEntityNumber);
void RE_AddRefSpriteToScene(const refEntity_t* ent);
void RE_AddTerrainMarkToScene(int iTerrainIndex, qhandle_t hShader, int numVerts, const polyVert_t* verts, int renderfx);
refEntity_t* RE_GetRenderEntity(int entityNumber);
qboolean RE_AddPolyToScene(qhandle_t hShader, int numVerts, const polyVert_t* verts, int renderfx);
void RE_AddLightToScene( const vec3_t org, float intensity, float r, float g, float b, int type );
void RE_AddAdditiveLightToScene( const vec3_t org, float intensity, float r, float g, float b );
void RE_RenderScene( const refdef_t *fd );
 
/*
=============================================================
 
ANIMATED MODELS
 
=============================================================
*/
 
void R_MakeAnimModel( model_t *model );
void R_AddAnimSurfaces(trRefEntity_t* ent);
 
/*
=============================================================
 
FONT
 
=============================================================
*/
void R_ShutdownFont();
fontheader_t* R_LoadFont(const char* name);
void R_LoadFontShader(fontheader_sgl_t* font);
void R_DrawString(fontheader_t* font, const char* text, float x, float y, int maxlen, const float *pvVirtualScreen);
void R_DrawFloatingString(fontheader_t* font, const char* text, const vec3_t org, const vec4_t color, float scale, int maxlen);
float R_GetFontHeight(const fontheader_t* font);
float R_GetFontStringWidth(const fontheader_t* font, const char* s);
 
/*
=============================================================
 
GHOST
 
=============================================================
*/
 
void R_UpdateGhostTextures();
void R_SetGhostImage(const char* name, image_t* image);
void LoadGHOST(const char* name, byte** pic, int* width, int* height);
 
/*
=============================================================
 
MARKS
 
=============================================================
*/
void R_LevelMarksLoad(const char* szBSPName);
void R_LevelMarksInit();
void R_LevelMarksFree();
void R_UpdateLevelMarksSystem();
void R_AddPermanentMarkFragmentSurfaces(void** pFirstMarkFragment, int iNumMarkFragment);
 
/*
=============================================================
 
SKY PORTALS
 
=============================================================
*/
void R_Sky_Init();
void R_Sky_Reset();
void R_Sky_AddSurf(msurface_t* surf);
void R_Sky_Render();
 
/*
=============================================================
 
SPRITE
 
=============================================================
*/
sprite_t* SPR_RegisterSprite(const char* name);
void RB_DrawSprite(const refSprite_t* spr);
 
 
/*
=============================================================
 
SUN FLARE
 
=============================================================
*/
void R_InitLensFlare();
void R_DrawLensFlares();
 
/*
=============================================================
 
SWIPE
 
=============================================================
*/
void RB_DrawSwipeSurface(surfaceType_t* pswipe);
void RE_SwipeBegin(float thistime, float life, qhandle_t shader);
void RE_SwipeEnd();
void R_AddSwipeSurfaces();
 
/*
=============================================================
 
TERRAIN
 
=============================================================
*/
void R_MarkTerrainPatch(cTerraPatchUnpacked_t* pPatch);
void R_AddTerrainSurfaces();
void R_AddTerrainMarkSurfaces();
void R_InitTerrain();
void R_ShutdownTerrain();
void R_TerrainFree();
void R_TerrainPrepareFrame();
qboolean R_TerrainHeightForPoly(cTerraPatchUnpacked_t* pPatch, polyVert_t* pVerts, int nVerts);
void R_SwapTerraPatch(cTerraPatch_t* pPatch);
 
void R_TerrainCrater_f(void);
 
/*
=============================================================
 
TIKI
 
=============================================================
*/
struct skelHeaderGame_s;
struct skelAnimFrame_s;
 
void R_InitStaticModels(void);
void RE_FreeModels(void);
qhandle_t RE_SpawnEffectModel(const char* szModel, vec3_t vPos, vec3_t* axis);
qhandle_t RE_RegisterServerModel(const char* name);
void RE_UnregisterServerModel(qhandle_t hModel);
orientation_t RE_TIKI_Orientation(refEntity_t* model, int tagnum);
qboolean RE_TIKI_IsOnGround(refEntity_t* model, int tagnum, float threshold);
float R_ModelRadius(qhandle_t handle);
void R_ModelBounds(qhandle_t handle, vec3_t mins, vec3_t maxs);
dtiki_t* R_Model_GetHandle(qhandle_t handle);
 
float R_GetRadius(refEntity_t* model);
void R_GetFrame(refEntity_t* model, struct skelAnimFrame_s* newFrame);
void RE_ForceUpdatePose(refEntity_t* model);
void RE_SetFrameNumber(int frameNumber);
void R_UpdatePoseInternal(refEntity_t* model);
void RB_SkelMesh(skelSurfaceGame_t* sf);
void RB_StaticMesh(staticSurface_t* staticSurf);
void RB_Static_BuildDLights();
void R_InfoStaticModels_f(void);
void R_PrintInfoStaticModels();
void R_AddSkelSurfaces(trRefEntity_t* ent);
void R_AddStaticModelSurfaces(void);
void R_CountTikiLodTris(dtiki_t* tiki, float lodpercentage, int* render_tris, int* total_tris);
float R_CalcLod(const vec3_t origin, float radius);
int GetLodCutoff(struct skelHeaderGame_s* skelmodel, float lod_val, int renderfx);
int GetToolLodCutoff(struct skelHeaderGame_s* skelmodel, float lod_val);
void R_InfoWorldTris_f(void);
void R_PrintInfoWorldtris(void);
void R_DebugSkeleton(void);
 
extern int g_nStaticSurfaces;
extern qboolean g_bInfostaticmodels;
extern qboolean g_bInfoworldtris;
 
/*
=============================================================
 
UTIL
 
=============================================================
*/
 
void RB_StreamBegin(shader_t* shader);
void RB_StreamEnd(void);
void RB_StreamBeginDrawSurf(void);
void RB_StreamEndDrawSurf(void);
static void addTriangle(void);
void RB_Vertex3fv(vec3_t v);
void RB_Vertex3f(vec_t x, vec_t y, vec_t z);
void RB_Vertex2f(vec_t x, vec_t y);
void RB_Color4f(vec_t r, vec_t g, vec_t b, vec_t a);
void RB_Color3f(vec_t r, vec_t g, vec_t b);
void RB_Color3fv(vec3_t col);
void RB_Color4bv(unsigned char* colors);
void RB_Texcoord2f(float s, float t);
void RB_Texcoord2fv(vec2_t st);
void R_DrawDebugNumber(const vec3_t org, float number, float scale, float r, float g, float b, int precision);
void R_DebugRotatedBBox(const vec3_t org, const vec3_t ang, const vec3_t mins, const vec3_t maxs, float r, float g, float b, float alpha);
void R_DebugCircle(const vec3_t org, float radius, float r, float g, float b, float alpha, qboolean horizontal);
void R_DebugLine(const vec3_t start, const vec3_t end, float r, float g, float b, float alpha);
int RE_GetShaderWidth(qhandle_t hShader);
int RE_GetShaderHeight(qhandle_t hShader);
const char* RE_GetShaderName(qhandle_t hShader);
const char* RE_GetModelName(qhandle_t hModel);
 
/*
=============================================================
=============================================================
*/
void    R_TransformModelToClip( const vec3_t src, const float *modelMatrix, const float *projectionMatrix,
                            vec4_t eye, vec4_t dst );
void    R_TransformClipToWindow( const vec4_t clip, const viewParms_t *view, vec4_t normalized, vec4_t window );
 
void    RB_DeformTessGeometry( void );
 
void    RB_CalcEnvironmentTexCoords( float *dstTexCoords );
void    RB_CalcEnvironmentTexCoords2( float *dstTexCoords );
void    RB_CalcSunReflectionTexCoords( float *dstTexCoords );
void    RB_CalcOffsetTexCoords(const float* offset, float* st);
void    RB_CalcParallaxTexCoords(const float* rate, float* st);
void    RB_TextureAxisFromPlane(const vec3_t normal, vec3_t xv, vec3_t yv);
void    RB_QuakeTextureVecs(const vec3_t normal, const vec2_t scale, vec3_t mappingVecs[2]);
void    RB_CalcMacroTexCoords(const  float* rate, float* st);
void    RB_CalcScrollTexCoords( const float scroll[2], float *dstTexCoords );
void    RB_CalcRotateTexCoords( float degsPerSecond, float degsPerSecondCoef, float* st, float start );
void    RB_CalcScaleTexCoords( const float scale[2], float *dstTexCoords );
void    RB_CalcTurbulentTexCoords( const waveForm_t *wf, float *dstTexCoords );
void    RB_CalcTransformTexCoords( const texModInfo_t *tmi, float *dstTexCoords );
void    RB_CalcWaveAlpha( const waveForm_t *wf, unsigned char *dstColors );
void    RB_CalcWaveColor(const waveForm_t* wf, unsigned char* dstColors, unsigned char* constantColor);
void    RB_CalcAlphaFromEntity( unsigned char *dstColors );
void    RB_CalcAlphaFromOneMinusEntity( unsigned char *dstColors );
void    RB_CalcStretchTexCoords( const waveForm_t *wf, float *texCoords );
void    RB_CalcColorFromEntity( unsigned char *dstColors );
void    RB_CalcColorFromOneMinusEntity( unsigned char *dstColors );
void    RB_CalcColorFromConstant(unsigned char* dstColors, unsigned char* constantColor);
void    RB_CalcRGBFromDot(unsigned char* colors, float alphaMin, float alphaMax);
void    RB_CalcRGBFromOneMinusDot(unsigned char* colors, float alphaMin, float alphaMax);
void    RB_CalcAlphaFromConstant(unsigned char* dstColors, int constantAlpha);
void    RB_CalcAlphaFromDot(unsigned char* colors, float alphaMin, float alphaMax);
void    RB_CalcAlphaFromHeightFade(unsigned char* colors, float alphaMin, float alphaMax);
void    RB_CalcAlphaFromOneMinusDot(unsigned char* colors, float alphaMin, float alphaMax);
void    RB_CalcAlphaFromTexCoords(unsigned char* colors, float alphaMin, float alphaMax, int alphaMinCap, int alphaCap, float sWeight, float tWeight, float* st);
void    RB_CalcRGBFromTexCoords(unsigned char* colors, float alphaMin, float alphaMax, int alphaMinCap, int alphaCap, float sWeight, float tWeight, float* st);
void    RB_CalcSpecularAlpha(unsigned char* alphas, float alphaMax, vec3_t lightOrigin);
void    RB_CalcLightGridColor(unsigned char* colors);
void    RB_CalcAlphaFromDotView(unsigned char* colors, float alphaMin, float alphaMax);
void    RB_CalcAlphaFromOneMinusDotView(unsigned char* colors, float alphaMin, float alphaMax);
void    RB_CalcDiffuseColor( unsigned char *colors );
 
void    RB_CalcStretchTexCoords(const waveForm_t* wf, float* st);
void    RB_CalcTransWaveTexCoords(const waveForm_t* wf, float* st);
void    RB_CalcTransWaveTexCoordsT(const waveForm_t* wf, float* st);
void    RB_CalcBulgeTexCoords(const waveForm_t* wf, float* st);
 
/*
=============================================================
 
RENDERER BACK END FUNCTIONS
 
=============================================================
*/
 
void RB_RenderThread( void );
void RB_ExecuteRenderCommands( const void *data );
 
/*
=============================================================
 
RENDERER BACK END COMMAND QUEUE
 
=============================================================
*/
 
#define MAX_RENDER_COMMANDS 0x40000
 
typedef struct suninfo_s {
    vec3_t color;
    vec3_t direction;
    vec3_t flaredirection;
    char szFlareName[64];
    qboolean exists;
} suninfo_t;
 
extern suninfo_t s_sun;
 
typedef struct {
    byte    cmds[MAX_RENDER_COMMANDS];
    int     used;
} renderCommandList_t;
 
typedef struct {
    int     commandId;
    float   color[4];
} setColorCommand_t;
 
typedef struct {
    int     commandId;
    int     buffer;
} drawBufferCommand_t;
 
typedef struct {
    int     commandId;
    image_t *image;
    int     width;
    int     height;
    void    *data;
} subImageCommand_t;
 
typedef struct {
    int     commandId;
} swapBuffersCommand_t;
 
typedef struct {
    int     commandId;
    int     buffer;
} endFrameCommand_t;
 
typedef struct {
    int     commandId;
    shader_t    *shader;
    float   x, y;
    float   w, h;
    float   s1, t1;
    float   s2, t2;
} stretchPicCommand_t;
 
typedef struct {
    int     commandId;
    trRefdef_t    refdef;
    viewParms_t  viewParms;
    drawSurf_t *drawSurfs;
    int     numDrawSurfs;
} drawSurfsCommand_t;
 
typedef struct {
    int commandId;
    int x;
    int y;
    int width;
    int height;
    char *fileName;
    qboolean jpeg;
} screenshotCommand_t;
 
typedef struct {
    int                     commandId;
    int                     width;
    int                     height;
    byte                    *captureBuffer;
    byte                    *encodeBuffer;
    qboolean            motionJpeg;
} videoFrameCommand_t;
 
typedef struct
{
    int commandId;
 
    GLboolean rgba[4];
} colorMaskCommand_t;
 
typedef struct
{
    int commandId;
} clearDepthCommand_t;
 
typedef enum {
    RC_END_OF_LIST,
    RC_SET_COLOR,
    RC_STRETCH_PIC,
    RC_DRAW_SURFS,
    RC_SPRITE_SURFS,
    RC_DRAW_BUFFER,
    RC_SWAP_BUFFERS,
    RC_SCREENSHOT,
    RC_VIDEOFRAME,
    RC_COLORMASK,
    RC_CLEARDEPTH
} renderCommand_t;
 
 
// these are sort of arbitrary limits.
// the limits apply to the sum of all scenes in a frame --
// the main view, all the 3D icons, etc
#define MAX_POLYS       4096
#define MAX_POLYVERTS   16384
#define MAX_TERMARKS    1024
 
// all of the information needed by the back end must be
// contained in a backEndData_t.  This entire structure is
// duplicated so the front and back end can run in parallel
// on an SMP machine
typedef struct {
    drawSurf_t  drawSurfs[MAX_DRAWSURFS];
    drawSurf_t  spriteSurfs[MAX_SPRITESURFS];
    dlight_t    dlights[MAX_DLIGHTS];
    trRefEntity_t  entities[MAX_ENTITIES];
    srfMarkFragment_t* terMarks;
    srfPoly_t   *polys;
    polyVert_t    *polyVerts;
    refSprite_t sprites[2048];
    cStaticModelUnpacked_t* staticModels;
    byte* staticModelData;
    renderCommandList_t  commands;
} backEndData_t;
 
extern  int     max_polys;
extern  int     max_polyverts;
extern  int     max_termarks;
 
extern  backEndData_t  *backEndData;   // the second one may not be allocated
 
extern  volatile renderCommandList_t *renderCommandList;
 
extern  volatile qboolean   renderThreadActive;
 
 
void *R_GetCommandBuffer( int bytes );
void R_AddDrawSurfCmd( drawSurf_t *drawSurfs, int numDrawSurfs );
void R_AddSpriteSurfCmd( drawSurf_t* drawSurfs, int numDrawSurfs );
void RB_ExecuteRenderCommands( const void *data );
 
void R_SavePerformanceCounters(void);
void R_InitCommandBuffers( void );
void R_ShutdownCommandBuffers( void );
 
void R_SyncRenderThread( void );
 
void R_AddDrawSurfCmd( drawSurf_t *drawSurfs, int numDrawSurfs );
 
void RE_SetColor( const float *rgba );
void RE_StretchPic ( float x, float y, float w, float h, 
                      float s1, float t1, float s2, float t2, qhandle_t hShader );
void RE_BeginFrame( stereoFrame_t stereoFrame );
void RE_EndFrame( int *frontEndMsec, int *backEndMsec );
void RE_SaveJPG(char* filename, int quality, int image_width, int image_height,
    unsigned char* image_buffer, int padding);
size_t RE_SaveJPGToBuffer(byte* buffer, size_t bufSize, int quality,
    int image_width, int image_height, byte* image_buffer, int padding);
void RE_TakeVideoFrame( int width, int height,
        byte *captureBuffer, byte *encodeBuffer, qboolean motionJpeg );
 
void SaveJPG(char * filename, int quality, int image_width, int image_height, unsigned char *image_buffer);
 
void UI_LoadResource(const char* name);
 
#ifdef __cplusplus
}
#endif