render.h

   1 /*
   2 Copyright (C) 1996-1997 Id Software, Inc.
   3
   4 This program is free software; you can redistribute it and/or
   5 modify it under the terms of the GNU General Public License
   6 as published by the Free Software Foundation; either version 2
   7 of the License, or (at your option) any later version.
   8
   9 This program is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  12
  13 See the GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program; if not, write to the Free Software
  17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  18
  19 */
  20
  21 #ifndef RENDER_H
  22 #define RENDER_H
  23
  24 #include "svbsp.h"
  25
  26 // 1.0f / N table
  27 extern float ixtable[4096];
  28
  29 // fog stuff
  30 void FOG_clear(void);
  31
  32 // sky stuff
  33 extern cvar_t r_sky;
  34 extern cvar_t r_skyscroll1;
  35 extern cvar_t r_skyscroll2;
  36 extern int skyrenderlater, skyrendermasked;
  37 int R_SetSkyBox(const char *sky);
  38 void R_SkyStartFrame(void);
  39 void R_Sky(void);
  40 void R_ResetSkyBox(void);
  41
  42 // SHOWLMP stuff (Nehahra)
  43 void SHOWLMP_decodehide(void);
  44 void SHOWLMP_decodeshow(void);
  45 void SHOWLMP_drawall(void);
  46
  47 // render profiling stuff
  48 extern int r_timereport_active;
  49
  50 // lighting stuff
  51 extern cvar_t r_ambient;
  52 extern cvar_t gl_flashblend;
  53
  54 // vis stuff
  55 extern cvar_t r_novis;
  56
  57 extern cvar_t r_trippy;
  58
  59 extern cvar_t r_lerpsprites;
  60 extern cvar_t r_lerpmodels;
  61 extern cvar_t r_lerplightstyles;
  62 extern cvar_t r_waterscroll;
  63
  64 extern cvar_t developer_texturelogging;
  65
  66 // shadow volume bsp struct with automatically growing nodes buffer
  67 extern svbsp_t r_svbsp;
  68
  69 typedef struct rmesh_s
  70 {
  71         // vertices of this mesh
  72         int maxvertices;
  73         int numvertices;
  74         float *vertex3f;
  75         float *svector3f;
  76         float *tvector3f;
  77         float *normal3f;
  78         float *texcoord2f;
  79         float *texcoordlightmap2f;
  80         float *color4f;
  81         // triangles of this mesh
  82         int maxtriangles;
  83         int numtriangles;
  84         int *element3i;
  85         int *neighbor3i;
  86         // snapping epsilon
  87         float epsilon2;
  88 }
  89 rmesh_t;
  90
  91 // useful functions for rendering
  92 void R_ModulateColors(float *in, float *out, int verts, float r, float g, float b);
  93 void R_FillColors(float *out, int verts, float r, float g, float b, float a);
  94 int R_Mesh_AddVertex3f(rmesh_t *mesh, const float *v);
  95 void R_Mesh_AddPolygon3f(rmesh_t *mesh, int numvertices, float *vertex3f);
  96 void R_Mesh_AddBrushMeshFromPlanes(rmesh_t *mesh, int numplanes, mplane_t *planes);
  97
  98 #define TOP_RANGE               16                      // soldier uniform colors
  99 #define BOTTOM_RANGE    96
 100
 101 //=============================================================================
 102
 103 extern cvar_t r_nearclip;
 104
 105 // forces all rendering to draw triangle outlines
 106 extern cvar_t r_showoverdraw;
 107 extern cvar_t r_showtris;
 108 extern cvar_t r_shownormals;
 109 extern cvar_t r_showlighting;
 110 extern cvar_t r_showshadowvolumes;
 111 extern cvar_t r_showcollisionbrushes;
 112 extern cvar_t r_showcollisionbrushes_polygonfactor;
 113 extern cvar_t r_showcollisionbrushes_polygonoffset;
 114 extern cvar_t r_showdisabledepthtest;
 115
 116 extern cvar_t r_drawentities;
 117 extern cvar_t r_draw2d;
 118 extern qboolean r_draw2d_force;
 119 extern cvar_t r_drawviewmodel;
 120 extern cvar_t r_drawworld;
 121 extern cvar_t r_speeds;
 122 extern cvar_t r_fullbright;
 123 extern cvar_t r_wateralpha;
 124 extern cvar_t r_dynamic;
 125
 126 void R_Init(void);
 127 void R_UpdateVariables(void); // must call after setting up most of r_refdef, but before calling R_RenderView
 128 void R_RenderView(void); // must set r_refdef and call R_UpdateVariables first
 129 void R_RenderView_UpdateViewVectors(void); // just updates r_refdef.view.{forward,left,up,origin,right,inverse_matrix}
 130
 131 typedef enum r_refdef_scene_type_s {
 132         RST_CLIENT,
 133         RST_MENU,
 134         RST_COUNT
 135 } r_refdef_scene_type_t;
 136
 137 void R_SelectScene( r_refdef_scene_type_t scenetype );
 138 r_refdef_scene_t * R_GetScenePointer( r_refdef_scene_type_t scenetype );
 139
 140 void R_SkinFrame_PrepareForPurge(void);
 141 void R_SkinFrame_MarkUsed(skinframe_t *skinframe);
 142 void R_SkinFrame_Purge(void);
 143 // set last to NULL to start from the beginning
 144 skinframe_t *R_SkinFrame_FindNextByName( skinframe_t *last, const char *name );
 145 skinframe_t *R_SkinFrame_Find(const char *name, int textureflags, int comparewidth, int compareheight, int comparecrc, qboolean add);
 146 skinframe_t *R_SkinFrame_LoadExternal(const char *name, int textureflags, qboolean complain);
 147 skinframe_t *R_SkinFrame_LoadInternalBGRA(const char *name, int textureflags, const unsigned char *skindata, int width, int height, qboolean sRGB);
 148 skinframe_t *R_SkinFrame_LoadInternalQuake(const char *name, int textureflags, int loadpantsandshirt, int loadglowtexture, const unsigned char *skindata, int width, int height);
 149 skinframe_t *R_SkinFrame_LoadInternal8bit(const char *name, int textureflags, const unsigned char *skindata, int width, int height, const unsigned int *palette, const unsigned int *alphapalette);
 150 skinframe_t *R_SkinFrame_LoadMissing(void);
 151
 152 rtexture_t *R_GetCubemap(const char *basename);
 153
 154 void R_View_WorldVisibility(qboolean forcenovis);
 155 void R_DrawDecals(void);
 156 void R_DrawParticles(void);
 157 void R_DrawExplosions(void);
 158
 159 #define gl_solid_format 3
 160 #define gl_alpha_format 4
 161
 162 int R_CullBox(const vec3_t mins, const vec3_t maxs);
 163 int R_CullBoxCustomPlanes(const vec3_t mins, const vec3_t maxs, int numplanes, const mplane_t *planes);
 164
 165 #include "r_modules.h"
 166
 167 #include "meshqueue.h"
 168
 169 /// free all R_FrameData memory
 170 void R_FrameData_Reset(void);
 171 /// prepare for a new frame, recycles old buffers if a resize occurred previously
 172 void R_FrameData_NewFrame(void);
 173 /// allocate some temporary memory for your purposes
 174 void *R_FrameData_Alloc(size_t size);
 175 /// allocate some temporary memory and copy this data into it
 176 void *R_FrameData_Store(size_t size, void *data);
 177 /// set a marker that allows you to discard the following temporary memory allocations
 178 void R_FrameData_SetMark(void);
 179 /// discard recent memory allocations (rewind to marker)
 180 void R_FrameData_ReturnToMark(void);
 181
 182 /// enum of the various types of hardware buffer object used in rendering
 183 /// note that the r_bufferdatasize[] array must be maintained to match this
 184 typedef enum r_bufferdata_type_e
 185 {
 186         R_BUFFERDATA_VERTEX, /// vertex buffer
 187         R_BUFFERDATA_INDEX16, /// index buffer - 16bit (because D3D cares)
 188         R_BUFFERDATA_INDEX32, /// index buffer - 32bit (because D3D cares)
 189         R_BUFFERDATA_UNIFORM, /// uniform buffer
 190         R_BUFFERDATA_COUNT /// how many kinds of buffer we have
 191 }
 192 r_bufferdata_type_t;
 193
 194 /// free all dynamic vertex/index/uniform buffers
 195 void R_BufferData_Reset(void);
 196 /// begin a new frame (recycle old buffers)
 197 void R_BufferData_NewFrame(void);
 198 /// request space in a vertex/index/uniform buffer for the chosen data, returns the buffer pointer and offset, if allowfail is true it may return NULL if the growth limit has been reached, false will cause it to allocate additional memory despite this (warning: may run out of memory)
 199 r_meshbuffer_t *R_BufferData_Store(size_t size, void *data, r_bufferdata_type_t type, int *returnbufferoffset, qboolean allowfail);
 200
 201 /// free all R_AnimCache memory
 202 void R_AnimCache_Free(void);
 203 /// clear the animcache pointers on all known render entities
 204 void R_AnimCache_ClearCache(void);
 205 /// get the skeletal data or cached animated mesh data for an entity (optionally with normals and tangents)
 206 qboolean R_AnimCache_GetEntity(entity_render_t *ent, qboolean wantnormals, qboolean wanttangents);
 207 /// generate animcache data for all entities marked visible
 208 void R_AnimCache_CacheVisibleEntities(void);
 209
 210 #include "r_lerpanim.h"
 211
 212 extern cvar_t r_render;
 213 extern cvar_t r_renderview;
 214 extern cvar_t r_waterwarp;
 215
 216 extern cvar_t r_textureunits;
 217
 218 extern cvar_t r_glsl_offsetmapping;
 219 extern cvar_t r_glsl_offsetmapping_reliefmapping;
 220 extern cvar_t r_glsl_offsetmapping_scale;
 221 extern cvar_t r_glsl_offsetmapping_lod;
 222 extern cvar_t r_glsl_offsetmapping_lod_distance;
 223 extern cvar_t r_glsl_deluxemapping;
 224
 225 extern cvar_t gl_polyblend;
 226 extern cvar_t gl_dither;
 227
 228 extern cvar_t cl_deathfade;
 229
 230 extern cvar_t r_smoothnormals_areaweighting;
 231
 232 extern cvar_t r_test;
 233
 234 #include "gl_backend.h"
 235
 236 extern rtexture_t *r_texture_blanknormalmap;
 237 extern rtexture_t *r_texture_white;
 238 extern rtexture_t *r_texture_grey128;
 239 extern rtexture_t *r_texture_black;
 240 extern rtexture_t *r_texture_notexture;
 241 extern rtexture_t *r_texture_whitecube;
 242 extern rtexture_t *r_texture_normalizationcube;
 243 extern rtexture_t *r_texture_fogattenuation;
 244 extern rtexture_t *r_texture_fogheighttexture;
 245
 246 extern unsigned int r_queries[MAX_OCCLUSION_QUERIES];
 247 extern unsigned int r_numqueries;
 248 extern unsigned int r_maxqueries;
 249
 250 void R_TimeReport(const char *name);
 251
 252 // r_stain
 253 void R_Stain(const vec3_t origin, float radius, int cr1, int cg1, int cb1, int ca1, int cr2, int cg2, int cb2, int ca2);
 254
 255 void R_CalcBeam_Vertex3f(float *vert, const float *org1, const float *org2, float width);
 256 void R_CalcSprite_Vertex3f(float *vertex3f, const float *origin, const float *left, const float *up, float scalex1, float scalex2, float scaley1, float scaley2);
 257
 258 extern mempool_t *r_main_mempool;
 259
 260 typedef struct rsurfacestate_s
 261 {
 262         // current model array pointers
 263         // these may point to processing buffers if model is animated,
 264         // otherwise they point to static data.
 265         // these are not directly used for rendering, they are just another level
 266         // of processing
 267         //
 268         // these either point at array_model* buffers (if the model is animated)
 269         // or the model->surfmesh.data_* buffers (if the model is not animated)
 270         //
 271         // these are only set when an entity render begins, they do not change on
 272         // a per surface basis.
 273         //
 274         // this indicates the model* arrays are pointed at array_model* buffers
 275         // (in other words, the model has been animated in software)
 276         qboolean                    forcecurrenttextureupdate; // set for RSurf_ActiveCustomEntity to force R_GetCurrentTexture to recalculate the texture parameters (such as entity alpha)
 277         qboolean                    modelgeneratedvertex;
 278         // skeletal animation can be done by entity (animcache) or per batch,
 279         // batch may be non-skeletal even if entity is skeletal, indicating that
 280         // the dynamicvertex code path had to apply skeletal manually for a case
 281         // where gpu-skinning is not possible, for this reason batch has its own
 282         // variables
 283         int                         entityskeletalnumtransforms; // how many transforms are used for this mesh
 284         float                      *entityskeletaltransform3x4; // use gpu-skinning shader on this mesh
 285         const r_meshbuffer_t       *entityskeletaltransform3x4buffer; // uniform buffer
 286         int                         entityskeletaltransform3x4offset;
 287         int                         entityskeletaltransform3x4size;
 288         float                      *modelvertex3f;
 289         const r_meshbuffer_t       *modelvertex3f_vertexbuffer;
 290         int                         modelvertex3f_bufferoffset;
 291         float                      *modelsvector3f;
 292         const r_meshbuffer_t       *modelsvector3f_vertexbuffer;
 293         int                         modelsvector3f_bufferoffset;
 294         float                      *modeltvector3f;
 295         const r_meshbuffer_t       *modeltvector3f_vertexbuffer;
 296         int                         modeltvector3f_bufferoffset;
 297         float                      *modelnormal3f;
 298         const r_meshbuffer_t       *modelnormal3f_vertexbuffer;
 299         int                         modelnormal3f_bufferoffset;
 300         float                      *modellightmapcolor4f;
 301         const r_meshbuffer_t       *modellightmapcolor4f_vertexbuffer;
 302         int                         modellightmapcolor4f_bufferoffset;
 303         float                      *modeltexcoordtexture2f;
 304         const r_meshbuffer_t       *modeltexcoordtexture2f_vertexbuffer;
 305         int                         modeltexcoordtexture2f_bufferoffset;
 306         float                      *modeltexcoordlightmap2f;
 307         const r_meshbuffer_t       *modeltexcoordlightmap2f_vertexbuffer;
 308         int                         modeltexcoordlightmap2f_bufferoffset;
 309         unsigned char              *modelskeletalindex4ub;
 310         const r_meshbuffer_t       *modelskeletalindex4ub_vertexbuffer;
 311         int                         modelskeletalindex4ub_bufferoffset;
 312         unsigned char              *modelskeletalweight4ub;
 313         const r_meshbuffer_t       *modelskeletalweight4ub_vertexbuffer;
 314         int                         modelskeletalweight4ub_bufferoffset;
 315         r_vertexmesh_t             *modelvertexmesh;
 316         const r_meshbuffer_t       *modelvertexmesh_vertexbuffer;
 317         int                         modelvertexmesh_bufferoffset;
 318         int                        *modelelement3i;
 319         const r_meshbuffer_t       *modelelement3i_indexbuffer;
 320         int                         modelelement3i_bufferoffset;
 321         unsigned short             *modelelement3s;
 322         const r_meshbuffer_t       *modelelement3s_indexbuffer;
 323         int                         modelelement3s_bufferoffset;
 324         int                        *modellightmapoffsets;
 325         int                         modelnumvertices;
 326         int                         modelnumtriangles;
 327         const msurface_t           *modelsurfaces;
 328         // current rendering array pointers
 329         // these may point to any of several different buffers depending on how
 330         // much processing was needed to prepare this model for rendering
 331         // these usually equal the model* pointers, they only differ if
 332         // deformvertexes is used in a q3 shader, and consequently these can
 333         // change on a per-surface basis (according to rsurface.texture)
 334         qboolean                    batchgeneratedvertex;
 335         qboolean                    batchmultidraw;
 336         int                         batchmultidrawnumsurfaces;
 337         const msurface_t          **batchmultidrawsurfacelist;
 338         int                         batchfirstvertex;
 339         int                         batchnumvertices;
 340         int                         batchfirsttriangle;
 341         int                         batchnumtriangles;
 342         r_vertexmesh_t             *batchvertexmesh;
 343         const r_meshbuffer_t       *batchvertexmesh_vertexbuffer;
 344         int                         batchvertexmesh_bufferoffset;
 345         float                      *batchvertex3f;
 346         const r_meshbuffer_t       *batchvertex3f_vertexbuffer;
 347         int                         batchvertex3f_bufferoffset;
 348         float                      *batchsvector3f;
 349         const r_meshbuffer_t       *batchsvector3f_vertexbuffer;
 350         int                         batchsvector3f_bufferoffset;
 351         float                      *batchtvector3f;
 352         const r_meshbuffer_t       *batchtvector3f_vertexbuffer;
 353         int                         batchtvector3f_bufferoffset;
 354         float                      *batchnormal3f;
 355         const r_meshbuffer_t       *batchnormal3f_vertexbuffer;
 356         int                         batchnormal3f_bufferoffset;
 357         float                      *batchlightmapcolor4f;
 358         const r_meshbuffer_t       *batchlightmapcolor4f_vertexbuffer;
 359         int                         batchlightmapcolor4f_bufferoffset;
 360         float                      *batchtexcoordtexture2f;
 361         const r_meshbuffer_t       *batchtexcoordtexture2f_vertexbuffer;
 362         int                         batchtexcoordtexture2f_bufferoffset;
 363         float                      *batchtexcoordlightmap2f;
 364         const r_meshbuffer_t       *batchtexcoordlightmap2f_vertexbuffer;
 365         int                         batchtexcoordlightmap2f_bufferoffset;
 366         unsigned char              *batchskeletalindex4ub;
 367         const r_meshbuffer_t       *batchskeletalindex4ub_vertexbuffer;
 368         int                         batchskeletalindex4ub_bufferoffset;
 369         unsigned char              *batchskeletalweight4ub;
 370         const r_meshbuffer_t       *batchskeletalweight4ub_vertexbuffer;
 371         int                         batchskeletalweight4ub_bufferoffset;
 372         int                        *batchelement3i;
 373         const r_meshbuffer_t       *batchelement3i_indexbuffer;
 374         int                         batchelement3i_bufferoffset;
 375         unsigned short             *batchelement3s;
 376         const r_meshbuffer_t       *batchelement3s_indexbuffer;
 377         int                         batchelement3s_bufferoffset;
 378         int                         batchskeletalnumtransforms;
 379         float                      *batchskeletaltransform3x4;
 380         const r_meshbuffer_t       *batchskeletaltransform3x4buffer; // uniform buffer
 381         int                         batchskeletaltransform3x4offset;
 382         int                         batchskeletaltransform3x4size;
 383         // rendering pass processing arrays in GL11 and GL13 paths
 384         float                      *passcolor4f;
 385         const r_meshbuffer_t       *passcolor4f_vertexbuffer;
 386         int                         passcolor4f_bufferoffset;
 387
 388         // some important fields from the entity
 389         int ent_skinnum;
 390         int ent_qwskin;
 391         int ent_flags;
 392         int ent_alttextures; // used by q1bsp animated textures (pressed buttons)
 393         double shadertime; // r_refdef.scene.time - ent->shadertime
 394         // transform matrices to render this entity and effects on this entity
 395         matrix4x4_t matrix;
 396         matrix4x4_t inversematrix;
 397         // scale factors for transforming lengths into/out of entity space
 398         float matrixscale;
 399         float inversematrixscale;
 400         // animation blending state from entity
 401         frameblend_t frameblend[MAX_FRAMEBLENDS];
 402         skeleton_t *skeleton;
 403         // directional model shading state from entity
 404         vec3_t modellight_ambient;
 405         vec3_t modellight_diffuse;
 406         vec3_t modellight_lightdir;
 407         // colormapping state from entity (these are black if colormapping is off)
 408         vec3_t colormap_pantscolor;
 409         vec3_t colormap_shirtcolor;
 410         // special coloring of ambient/diffuse textures (gloss not affected)
 411         // colormod[3] is the alpha of the entity
 412         float colormod[4];
 413         // special coloring of glow textures
 414         float glowmod[3];
 415         // view location in model space
 416         vec3_t localvieworigin;
 417         // polygon offset data for submodels
 418         float basepolygonfactor;
 419         float basepolygonoffset;
 420         // current textures in batching code
 421         texture_t *texture;
 422         rtexture_t *lightmaptexture;
 423         rtexture_t *deluxemaptexture;
 424         // whether lightmapping is active on this batch
 425         // (otherwise vertex colored)
 426         qboolean uselightmaptexture;
 427         // fog plane in model space for direct application to vertices
 428         float fograngerecip;
 429         float fogmasktabledistmultiplier;
 430         float fogplane[4];
 431         float fogheightfade;
 432         float fogplaneviewdist;
 433
 434         // rtlight rendering
 435         // light currently being rendered
 436         const rtlight_t *rtlight;
 437
 438         // this is the location of the light in entity space
 439         vec3_t entitylightorigin;
 440         // this transforms entity coordinates to light filter cubemap coordinates
 441         // (also often used for other purposes)
 442         matrix4x4_t entitytolight;
 443         // based on entitytolight this transforms -1 to +1 to 0 to 1 for purposes
 444         // of attenuation texturing in full 3D (Z result often ignored)
 445         matrix4x4_t entitytoattenuationxyz;
 446         // this transforms only the Z to S, and T is always 0.5
 447         matrix4x4_t entitytoattenuationz;
 448
 449         // user wavefunc parameters (from csqc)
 450         float userwavefunc_param[Q3WAVEFUNC_USER_COUNT];
 451
 452         // pointer to an entity_render_t used only by R_GetCurrentTexture and
 453         // RSurf_ActiveWorldEntity/RSurf_ActiveModelEntity as a unique id within
 454         // each frame (see r_frame also)
 455         entity_render_t *entity;
 456 }
 457 rsurfacestate_t;
 458
 459 extern rsurfacestate_t rsurface;
 460
 461 void R_HDR_UpdateIrisAdaptation(const vec3_t point);
 462
 463 void RSurf_ActiveWorldEntity(void);
 464 void RSurf_ActiveModelEntity(const entity_render_t *ent, qboolean wantnormals, qboolean wanttangents, qboolean prepass);
 465 void RSurf_ActiveCustomEntity(const matrix4x4_t *matrix, const matrix4x4_t *inversematrix, int entflags, double shadertime, float r, float g, float b, float a, int numvertices, const float *vertex3f, const float *texcoord2f, const float *normal3f, const float *svector3f, const float *tvector3f, const float *color4f, int numtriangles, const int *element3i, const unsigned short *element3s, qboolean wantnormals, qboolean wanttangents);
 466 void RSurf_SetupDepthAndCulling(void);
 467
 468 void R_Mesh_ResizeArrays(int newvertices);
 469
 470 texture_t *R_GetCurrentTexture(texture_t *t);
 471 void R_DrawWorldSurfaces(qboolean skysurfaces, qboolean writedepth, qboolean depthonly, qboolean debug, qboolean prepass);
 472 void R_DrawModelSurfaces(entity_render_t *ent, qboolean skysurfaces, qboolean writedepth, qboolean depthonly, qboolean debug, qboolean prepass);
 473 void R_AddWaterPlanes(entity_render_t *ent);
 474 void R_DrawCustomSurface(skinframe_t *skinframe, const matrix4x4_t *texmatrix, int materialflags, int firstvertex, int numvertices, int firsttriangle, int numtriangles, qboolean writedepth, qboolean prepass);
 475 void R_DrawCustomSurface_Texture(texture_t *texture, const matrix4x4_t *texmatrix, int materialflags, int firstvertex, int numvertices, int firsttriangle, int numtriangles, qboolean writedepth, qboolean prepass);
 476
 477 #define BATCHNEED_VERTEXMESH_VERTEX      (1<< 1) // set up rsurface.batchvertexmesh
 478 #define BATCHNEED_VERTEXMESH_NORMAL      (1<< 2) // set up normals in rsurface.batchvertexmesh if BATCHNEED_MESH, set up rsurface.batchnormal3f if BATCHNEED_ARRAYS
 479 #define BATCHNEED_VERTEXMESH_VECTOR      (1<< 3) // set up vectors in rsurface.batchvertexmesh if BATCHNEED_MESH, set up rsurface.batchsvector3f and rsurface.batchtvector3f if BATCHNEED_ARRAYS
 480 #define BATCHNEED_VERTEXMESH_VERTEXCOLOR (1<< 4) // set up vertex colors in rsurface.batchvertexmesh if BATCHNEED_MESH, set up rsurface.batchlightmapcolor4f if BATCHNEED_ARRAYS
 481 #define BATCHNEED_VERTEXMESH_TEXCOORD    (1<< 5) // set up vertex colors in rsurface.batchvertexmesh if BATCHNEED_MESH, set up rsurface.batchlightmapcolor4f if BATCHNEED_ARRAYS
 482 #define BATCHNEED_VERTEXMESH_LIGHTMAP    (1<< 6) // set up vertex colors in rsurface.batchvertexmesh if BATCHNEED_MESH, set up rsurface.batchlightmapcolor4f if BATCHNEED_ARRAYS
 483 #define BATCHNEED_VERTEXMESH_SKELETAL    (1<< 7) // set up skeletal index and weight data for vertex shader
 484 #define BATCHNEED_ARRAY_VERTEX           (1<< 8) // set up rsurface.batchvertex3f and optionally others
 485 #define BATCHNEED_ARRAY_NORMAL           (1<< 9) // set up normals in rsurface.batchvertexmesh if BATCHNEED_MESH, set up rsurface.batchnormal3f if BATCHNEED_ARRAYS
 486 #define BATCHNEED_ARRAY_VECTOR           (1<<10) // set up vectors in rsurface.batchvertexmesh if BATCHNEED_MESH, set up rsurface.batchsvector3f and rsurface.batchtvector3f if BATCHNEED_ARRAYS
 487 #define BATCHNEED_ARRAY_VERTEXCOLOR      (1<<11) // set up vertex colors in rsurface.batchvertexmesh if BATCHNEED_MESH, set up rsurface.batchlightmapcolor4f if BATCHNEED_ARRAYS
 488 #define BATCHNEED_ARRAY_TEXCOORD         (1<<12) // set up vertex colors in rsurface.batchvertexmesh if BATCHNEED_MESH, set up rsurface.batchlightmapcolor4f if BATCHNEED_ARRAYS
 489 #define BATCHNEED_ARRAY_LIGHTMAP         (1<<13) // set up vertex colors in rsurface.batchvertexmesh if BATCHNEED_MESH, set up rsurface.batchlightmapcolor4f if BATCHNEED_ARRAYS
 490 #define BATCHNEED_ARRAY_SKELETAL         (1<<14) // set up skeletal index and weight data for vertex shader
 491 #define BATCHNEED_NOGAPS                 (1<<15) // force vertex copying if firstvertex is not zero or there are gaps
 492 #define BATCHNEED_ALLOWMULTIDRAW         (1<<16) // allow multiple draws
 493 void RSurf_PrepareVerticesForBatch(int batchneed, int texturenumsurfaces, const msurface_t **texturesurfacelist);
 494 void RSurf_DrawBatch(void);
 495
 496 void R_DecalSystem_SplatEntities(const vec3_t org, const vec3_t normal, float r, float g, float b, float a, float s1, float t1, float s2, float t2, float size);
 497
 498 typedef enum rsurfacepass_e
 499 {
 500         RSURFPASS_BASE,
 501         RSURFPASS_BACKGROUND,
 502         RSURFPASS_RTLIGHT,
 503         RSURFPASS_DEFERREDGEOMETRY
 504 }
 505 rsurfacepass_t;
 506
 507 void R_SetupShader_Generic(rtexture_t *first, rtexture_t *second, int texturemode, int rgbscale, qboolean usegamma, qboolean notrippy, qboolean suppresstexalpha);
 508 void R_SetupShader_Generic_NoTexture(qboolean usegamma, qboolean notrippy);
 509 void R_SetupShader_DepthOrShadow(qboolean notrippy, qboolean depthrgb, qboolean skeletal);
 510 void R_SetupShader_Surface(const vec3_t lightcolorbase, qboolean modellighting, float ambientscale, float diffusescale, float specularscale, rsurfacepass_t rsurfacepass, int texturenumsurfaces, const msurface_t **texturesurfacelist, void *waterplane, qboolean notrippy);
 511 void R_SetupShader_DeferredLight(const rtlight_t *rtlight);
 512
 513 typedef struct r_waterstate_waterplane_s
 514 {
 515         rtexture_t *texture_refraction; // MATERIALFLAG_WATERSHADER or MATERIALFLAG_REFRACTION
 516         rtexture_t *texture_reflection; // MATERIALFLAG_WATERSHADER or MATERIALFLAG_REFLECTION
 517         rtexture_t *texture_camera; // MATERIALFLAG_CAMERA
 518         int fbo_refraction;
 519         int fbo_reflection;
 520         int fbo_camera;
 521         mplane_t plane;
 522         int materialflags; // combined flags of all water surfaces on this plane
 523         unsigned char pvsbits[(MAX_MAP_LEAFS+7)>>3]; // FIXME: buffer overflow on huge maps
 524         qboolean pvsvalid;
 525         int camera_entity;
 526         vec3_t mins, maxs;
 527 }
 528 r_waterstate_waterplane_t;
 529
 530 typedef struct r_waterstate_s
 531 {
 532         int waterwidth, waterheight;
 533         int texturewidth, textureheight;
 534         int camerawidth, cameraheight;
 535         rtexture_t *depthtexture;
 536
 537         int maxwaterplanes; // same as MAX_WATERPLANES
 538         int numwaterplanes;
 539         r_waterstate_waterplane_t waterplanes[MAX_WATERPLANES];
 540
 541         float screenscale[2];
 542         float screencenter[2];
 543
 544         qboolean enabled;
 545
 546         qboolean renderingscene; // true while rendering a refraction or reflection texture, disables water surfaces
 547         qboolean hideplayer;
 548 }
 549 r_waterstate_t;
 550
 551 typedef struct r_framebufferstate_s
 552 {
 553         textype_t textype; // type of color buffer we're using (dependent on r_viewfbo cvar)
 554         int fbo; // non-zero if r_viewfbo is enabled and working
 555         int screentexturewidth, screentextureheight; // dimensions of texture
 556
 557         rtexture_t *colortexture; // non-NULL if fbo is non-zero
 558         rtexture_t *depthtexture; // non-NULL if fbo is non-zero
 559         rtexture_t *ghosttexture; // for r_motionblur (not recommended on multi-GPU hardware!)
 560         rtexture_t *bloomtexture[2]; // for r_bloom, multi-stage processing
 561         int bloomfbo[2]; // fbos for rendering into bloomtexture[]
 562         int bloomindex; // which bloomtexture[] contains the final image
 563
 564         int bloomwidth, bloomheight;
 565         int bloomtexturewidth, bloomtextureheight;
 566
 567         // arrays for rendering the screen passes
 568         float screentexcoord2f[8]; // texcoords for colortexture or ghosttexture
 569         float bloomtexcoord2f[8]; // texcoords for bloomtexture[]
 570         float offsettexcoord2f[8]; // temporary use while updating bloomtexture[]
 571
 572         r_viewport_t bloomviewport;
 573
 574         r_waterstate_t water;
 575
 576         qboolean ghosttexture_valid; // don't draw garbage on first frame with motionblur
 577         qboolean usedepthtextures; // use depth texture instead of depth renderbuffer (faster if you need to read it later anyway)
 578 }
 579 r_framebufferstate_t;
 580
 581 extern r_framebufferstate_t r_fb;
 582
 583 extern cvar_t r_viewfbo;
 584
 585 void R_ResetViewRendering2D_Common(int fbo, rtexture_t *depthtexture, rtexture_t *colortexture, float x2, float y2); // this is called by R_ResetViewRendering2D and _DrawQ_Setup and internal
 586 void R_ResetViewRendering2D(int fbo, rtexture_t *depthtexture, rtexture_t *colortexture);
 587 void R_ResetViewRendering3D(int fbo, rtexture_t *depthtexture, rtexture_t *colortexture);
 588 void R_SetupView(qboolean allowwaterclippingplane, int fbo, rtexture_t *depthtexture, rtexture_t *colortexture);
 589 extern const float r_screenvertex3f[12];
 590 extern cvar_t r_shadows;
 591 extern cvar_t r_shadows_darken;
 592 extern cvar_t r_shadows_drawafterrtlighting;
 593 extern cvar_t r_shadows_castfrombmodels;
 594 extern cvar_t r_shadows_throwdistance;
 595 extern cvar_t r_shadows_throwdirection;
 596 extern cvar_t r_shadows_focus;
 597 extern cvar_t r_shadows_shadowmapscale;
 598 extern cvar_t r_shadows_shadowmapbias;
 599 extern cvar_t r_transparent_alphatocoverage;
 600 extern cvar_t r_transparent_sortsurfacesbynearest;
 601 extern cvar_t r_transparent_useplanardistance;
 602 extern cvar_t r_transparent_sortarraysize;
 603 extern cvar_t r_transparent_sortmindist;
 604 extern cvar_t r_transparent_sortmaxdist;
 605
 606 void R_Model_Sprite_Draw(entity_render_t *ent);
 607
 608 struct prvm_prog_s;
 609 void R_UpdateFog(void);
 610 qboolean CL_VM_UpdateView(void);
 611 void SCR_DrawConsole(void);
 612 void R_Shadow_EditLights_DrawSelectedLightProperties(void);
 613 void R_DecalSystem_Reset(decalsystem_t *decalsystem);
 614 void R_Shadow_UpdateBounceGridTexture(void);
 615 void R_DrawLightningBeams(void);
 616 void VM_CL_AddPolygonsToMeshQueue(struct prvm_prog_s *prog);
 617 void R_DrawPortals(void);
 618 void R_DrawModelShadows(int fbo, rtexture_t *depthtexture, rtexture_t *colortexture);
 619 void R_DrawModelShadowMaps(int fbo, rtexture_t *depthtexture, rtexture_t *colortexture);
 620 void R_BuildLightMap(const entity_render_t *ent, msurface_t *surface);
 621 void R_Water_AddWaterPlane(msurface_t *surface, int entno);
 622 int R_Shadow_GetRTLightInfo(unsigned int lightindex, float *origin, float *radius, float *color);
 623 dp_font_t *FindFont(const char *title, qboolean allocate_new);
 624 void LoadFont(qboolean override, const char *name, dp_font_t *fnt, float scale, float voffset);
 625
 626 void Render_Init(void);
 627
 628 // these are called by Render_Init
 629 void R_Textures_Init(void);
 630 void GL_Draw_Init(void);
 631 void GL_Main_Init(void);
 632 void R_Shadow_Init(void);
 633 void R_Sky_Init(void);
 634 void GL_Surf_Init(void);
 635 void R_Particles_Init(void);
 636 void R_Explosion_Init(void);
 637 void gl_backend_init(void);
 638 void Sbar_Init(void);
 639 void R_LightningBeams_Init(void);
 640 void Mod_RenderInit(void);
 641 void Font_Init(void);
 642
 643 qboolean R_CompileShader_CheckStaticParms(void);
 644 void R_GLSL_Restart_f(void);
 645
 646 #endif