implemented r_batch_dynamicbuffer which allows the rsurface batching
[xonotic/darkplaces.git] / 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