1 /*
2 ===========================================================================
3
4 Return to Castle Wolfenstein single player GPL Source Code
5 Copyright (C) 1999-2010 id Software LLC, a ZeniMax Media company.
6
7 This file is part of the Return to Castle Wolfenstein single player GPL Source Code (“RTCW SP Source Code”).
8
9 RTCW SP Source Code is free software: you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation, either version 3 of the License, or
12 (at your option) any later version.
13
14 RTCW SP Source Code is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with RTCW SP Source Code. If not, see <http://www.gnu.org/licenses/>.
21
22 In addition, the RTCW SP Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the RTCW SP Source Code. If not, please request a copy in writing from id Software at the address below.
23
24 If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
25
26 ===========================================================================
27 */
28
29
30 #ifndef TR_LOCAL_H
31 #define TR_LOCAL_H
32
33 #include "../qcommon/q_shared.h"
34 #include "../qcommon/qfiles.h"
35 #include "../qcommon/qcommon.h"
36 #include "../renderer/tr_public.h"
37 #include "qgl.h"
38 #include "../renderer/iqm.h"
39
40 #define GLE(ret, name, ...) extern name##proc * qgl##name;
41 QGL_1_1_PROCS;
42 QGL_DESKTOP_1_1_PROCS;
43 QGL_1_3_PROCS;
44 QGL_1_5_PROCS;
45 QGL_2_0_PROCS;
46 QGL_3_0_PROCS;
47 QGL_ARB_occlusion_query_PROCS;
48 QGL_ARB_framebuffer_object_PROCS;
49 QGL_ARB_vertex_array_object_PROCS;
50 QGL_EXT_direct_state_access_PROCS;
51 #undef GLE
52
53 #define GL_INDEX_TYPE GL_UNSIGNED_INT
54 typedef unsigned int glIndex_t;
55
56 #define BUFFER_OFFSET(i) ((char *)NULL + (i))
57
58 // 11 bits
59 // can't be increased without changing bit packing for drawsurfs
60 // see QSORT_SHADERNUM_SHIFT
61
62 #define SHADERNUM_BITS 11
63 #define MAX_SHADERS (1<<SHADERNUM_BITS)
64
65 #define MAX_FBOS 64
66 #define MAX_VISCOUNTS 5
67 #define MAX_VAOS 4096
68
69 #define MAX_CALC_PSHADOWS 64
70 #define MAX_DRAWN_PSHADOWS 32 // do not increase past 32, because bit flags are used on surfaces
71 #define PSHADOW_MAP_SIZE 512
72
73 // a trRefEntity_t has all the information passed in by
74 // the client game, as well as some locally derived info
75 typedef struct {
76 refEntity_t e;
77
78 float axisLength; // compensate for non-normalized axis
79
80 qboolean needDlights; // true for bmodels that touch a dlight
81 qboolean lightingCalculated;
82 qboolean mirrored; // mirrored matrix, needs reversed culling
83 vec3_t lightDir; // normalized direction towards light, in world space
84 vec3_t modelLightDir; // normalized direction towards light, in model space
85 vec3_t ambientLight; // color normalized to 0-255
86 vec3_t directedLight;
87 float brightness;
88 } trRefEntity_t;
89
90 typedef struct {
91 vec3_t origin; // in world coordinates
92 vec3_t axis[3]; // orientation in world
93 vec3_t viewOrigin; // viewParms->or.origin in local coordinates
94 float modelMatrix[16];
95 float transformMatrix[16];
96 } orientationr_t;
97
98 typedef enum
99 {
100 IMGTYPE_COLORALPHA, // for color, lightmap, diffuse, and specular
101 IMGTYPE_NORMAL,
102 IMGTYPE_NORMALHEIGHT,
103 IMGTYPE_DELUXE, // normals are swizzled, deluxe are not
104 } imgType_t;
105
106 typedef enum
107 {
108 IMGFLAG_NONE = 0x0000,
109 IMGFLAG_MIPMAP = 0x0001,
110 IMGFLAG_PICMIP = 0x0002,
111 IMGFLAG_CUBEMAP = 0x0004,
112 IMGFLAG_NO_COMPRESSION = 0x0010,
113 IMGFLAG_NOLIGHTSCALE = 0x0020,
114 IMGFLAG_CLAMPTOEDGE = 0x0040,
115 IMGFLAG_GENNORMALMAP = 0x0080,
116 } imgFlags_t;
117
118 typedef struct image_s {
119 char imgName[MAX_QPATH]; // game path, including extension
120 int width, height; // source image
121 int uploadWidth, uploadHeight; // after power of two and picmip but not including clamp to MAX_TEXTURE_SIZE
122 GLuint texnum; // gl texture binding
123
124 int frameUsed; // for texture usage in frame statistics
125
126 int internalFormat;
127 int TMU; // only needed for voodoo2
128
129 imgType_t type;
130 imgFlags_t flags;
131
132 qboolean characterMIP; // independant 'character' mip scale ----(SA) added
133
134 int hash; // for fast building of the backupHash
135
136 struct image_s* next;
137 } image_t;
138
139 #include "tr_extratypes.h"
140 #include "tr_extramath.h"
141 #include "tr_fbo.h"
142 #include "tr_postprocess.h"
143
144 // Ensure this is >= the ATTR_INDEX_COUNT enum below
145 #define VAO_MAX_ATTRIBS 16
146
147 typedef enum
148 {
149 VAO_USAGE_STATIC,
150 VAO_USAGE_DYNAMIC
151 } vaoUsage_t;
152
153 typedef struct vaoAttrib_s
154 {
155 uint32_t enabled;
156 uint32_t count;
157 uint32_t type;
158 uint32_t normalized;
159 uint32_t stride;
160 uint32_t offset;
161 }
162 vaoAttrib_t;
163
164 typedef struct vao_s
165 {
166 char name[MAX_QPATH];
167
168 uint32_t vao;
169
170 uint32_t vertexesVBO;
171 int vertexesSize; // amount of memory data allocated for all vertices in bytes
172 vaoAttrib_t attribs[VAO_MAX_ATTRIBS];
173
174 uint32_t frameSize; // bytes to skip per frame when doing vertex animation
175
176 uint32_t indexesIBO;
177 int indexesSize; // amount of memory data allocated for all triangles in bytes
178 } vao_t;
179
180 //===============================================================================
181
182 typedef enum {
183 SS_BAD,
184 SS_PORTAL, // mirrors, portals, viewscreens
185 SS_ENVIRONMENT, // sky box
186 SS_OPAQUE, // opaque
187
188 SS_DECAL, // scorch marks, etc.
189 SS_SEE_THROUGH, // ladders, grates, grills that may have small blended edges
190 // in addition to alpha test
191 SS_BANNER,
192
193 SS_FOG,
194
195 SS_UNDERWATER, // for items that should be drawn in front of the water plane
196
197 SS_BLEND0, // regular transparency and filters
198 SS_BLEND1, // generally only used for additive type effects
199 SS_BLEND2,
200 SS_BLEND3,
201
202 SS_BLEND6,
203 SS_STENCIL_SHADOW,
204 SS_ALMOST_NEAREST, // gun smoke puffs
205
206 SS_NEAREST // blood blobs
207 } shaderSort_t;
208
209
210 #define MAX_SHADER_STAGES 8
211
212 typedef enum {
213 GF_NONE,
214
215 GF_SIN,
216 GF_SQUARE,
217 GF_TRIANGLE,
218 GF_SAWTOOTH,
219 GF_INVERSE_SAWTOOTH,
220
221 GF_NOISE
222
223 } genFunc_t;
224
225
226 typedef enum {
227 DEFORM_NONE,
228 DEFORM_WAVE,
229 DEFORM_NORMALS,
230 DEFORM_BULGE,
231 DEFORM_MOVE,
232 DEFORM_PROJECTION_SHADOW,
233 DEFORM_AUTOSPRITE,
234 DEFORM_AUTOSPRITE2,
235 DEFORM_TEXT0,
236 DEFORM_TEXT1,
237 DEFORM_TEXT2,
238 DEFORM_TEXT3,
239 DEFORM_TEXT4,
240 DEFORM_TEXT5,
241 DEFORM_TEXT6,
242 DEFORM_TEXT7
243 } deform_t;
244
245 // deformVertexes types that can be handled by the GPU
246 typedef enum
247 {
248 // do not edit: same as genFunc_t
249
250 DGEN_NONE,
251 DGEN_WAVE_SIN,
252 DGEN_WAVE_SQUARE,
253 DGEN_WAVE_TRIANGLE,
254 DGEN_WAVE_SAWTOOTH,
255 DGEN_WAVE_INVERSE_SAWTOOTH,
256 DGEN_WAVE_NOISE,
257
258 // do not edit until this line
259
260 DGEN_BULGE,
261 DGEN_MOVE
262 } deformGen_t;
263
264 typedef enum {
265 AGEN_IDENTITY,
266 AGEN_SKIP,
267 AGEN_ENTITY,
268 AGEN_ONE_MINUS_ENTITY,
269 AGEN_NORMALZFADE, // Ridah
270 AGEN_VERTEX,
271 AGEN_ONE_MINUS_VERTEX,
272 AGEN_LIGHTING_SPECULAR,
273 AGEN_WAVEFORM,
274 AGEN_PORTAL,
275 AGEN_CONST
276 } alphaGen_t;
277
278 typedef enum {
279 CGEN_BAD,
280 CGEN_IDENTITY_LIGHTING, // tr.identityLight
281 CGEN_IDENTITY, // always (1,1,1,1)
282 CGEN_ENTITY, // grabbed from entity's modulate field
283 CGEN_ONE_MINUS_ENTITY, // grabbed from 1 - entity.modulate
284 CGEN_EXACT_VERTEX, // tess.color
285 CGEN_VERTEX, // tess.color * tr.identityLight
286 CGEN_EXACT_VERTEX_LIT, // like CGEN_EXACT_VERTEX but takes a light direction from the lightgrid
287 CGEN_VERTEX_LIT, // like CGEN_VERTEX but takes a light direction from the lightgrid
288 CGEN_ONE_MINUS_VERTEX,
289 CGEN_WAVEFORM, // programmatically generated
290 CGEN_LIGHTING_DIFFUSE,
291 CGEN_FOG, // standard fog
292 CGEN_CONST // fixed color
293 } colorGen_t;
294
295 typedef enum {
296 TCGEN_BAD,
297 TCGEN_IDENTITY, // clear to 0,0
298 TCGEN_LIGHTMAP,
299 TCGEN_TEXTURE,
300 TCGEN_ENVIRONMENT_MAPPED,
301 TCGEN_FIRERISEENV_MAPPED,
302 TCGEN_FOG,
303 TCGEN_VECTOR // S and T from world coordinates
304 } texCoordGen_t;
305
306 typedef enum {
307 ACFF_NONE,
308 ACFF_MODULATE_RGB,
309 ACFF_MODULATE_RGBA,
310 ACFF_MODULATE_ALPHA
311 } acff_t;
312
313 typedef struct {
314 genFunc_t func;
315
316 float base;
317 float amplitude;
318 float phase;
319 float frequency;
320 } waveForm_t;
321
322 #define TR_MAX_TEXMODS 4
323
324 typedef enum {
325 TMOD_NONE,
326 TMOD_TRANSFORM,
327 TMOD_TURBULENT,
328 TMOD_SCROLL,
329 TMOD_SCALE,
330 TMOD_STRETCH,
331 TMOD_ROTATE,
332 TMOD_ENTITY_TRANSLATE,
333 TMOD_SWAP
334 } texMod_t;
335
336 #define MAX_SHADER_DEFORMS 3
337 typedef struct {
338 deform_t deformation; // vertex coordinate modification type
339
340 vec3_t moveVector;
341 waveForm_t deformationWave;
342 float deformationSpread;
343
344 float bulgeWidth;
345 float bulgeHeight;
346 float bulgeSpeed;
347 } deformStage_t;
348
349
350 typedef struct {
351 texMod_t type;
352
353 // used for TMOD_TURBULENT and TMOD_STRETCH
354 waveForm_t wave;
355
356 // used for TMOD_TRANSFORM
357 float matrix[2][2]; // s' = s * m[0][0] + t * m[1][0] + trans[0]
358 float translate[2]; // t' = s * m[0][1] + t * m[0][1] + trans[1]
359
360 // used for TMOD_SCALE
361 float scale[2]; // s *= scale[0]
362 // t *= scale[1]
363
364 // used for TMOD_SCROLL
365 float scroll[2]; // s' = s + scroll[0] * time
366 // t' = t + scroll[1] * time
367
368 // + = clockwise
369 // - = counterclockwise
370 float rotateSpeed;
371
372 } texModInfo_t;
373
374
375 // RF increased this for onfire animation
376 //#define MAX_IMAGE_ANIMATIONS 8
377 #define MAX_IMAGE_ANIMATIONS 16
378
379 typedef struct {
380 image_t *image[MAX_IMAGE_ANIMATIONS];
381 int numImageAnimations;
382 float imageAnimationSpeed;
383
384 texCoordGen_t tcGen;
385 vec3_t tcGenVectors[2];
386
387 int numTexMods;
388 texModInfo_t *texMods;
389
390 int videoMapHandle;
391 qboolean isLightmap;
392 qboolean isVideoMap;
393 } textureBundle_t;
394
395 enum
396 {
397 TB_COLORMAP = 0,
398 TB_DIFFUSEMAP = 0,
399 TB_LIGHTMAP = 1,
400 TB_LEVELSMAP = 1,
401 TB_SHADOWMAP3 = 1,
402 TB_NORMALMAP = 2,
403 TB_DELUXEMAP = 3,
404 TB_SHADOWMAP2 = 3,
405 TB_SPECULARMAP = 4,
406 TB_SHADOWMAP = 5,
407 TB_CUBEMAP = 6,
408 TB_SHADOWMAP4 = 6,
409 NUM_TEXTURE_BUNDLES = 7
410 };
411
412 typedef enum
413 {
414 // material shader stage types
415 ST_COLORMAP = 0, // vanilla Q3A style shader treatening
416 ST_DIFFUSEMAP = 0, // treat color and diffusemap the same
417 ST_NORMALMAP,
418 ST_NORMALPARALLAXMAP,
419 ST_SPECULARMAP,
420 ST_GLSL
421 } stageType_t;
422
423 typedef struct {
424 qboolean active;
425
426 textureBundle_t bundle[NUM_TEXTURE_BUNDLES];
427
428 waveForm_t rgbWave;
429 colorGen_t rgbGen;
430
431 waveForm_t alphaWave;
432 alphaGen_t alphaGen;
433
434 byte constantColor[4]; // for CGEN_CONST and AGEN_CONST
435
436 unsigned stateBits; // GLS_xxxx mask
437
438 acff_t adjustColorsForFog;
439
440 // Ridah
441 float zFadeBounds[2];
442
443 qboolean isDetail;
444 qboolean isFogged; // used only for shaders that have fog disabled, so we can enable it for individual stages
445
446 stageType_t type;
447 struct shaderProgram_s *glslShaderGroup;
448 int glslShaderIndex;
449
450 vec4_t normalScale;
451 vec4_t specularScale;
452
453 } shaderStage_t;
454
455 struct shaderCommands_s;
456
457 // any change in the LIGHTMAP_* defines here MUST be reflected in
458 // R_FindShader() in tr_bsp.c
459 #define LIGHTMAP_2D -4 // shader is for 2D rendering
460 #define LIGHTMAP_BY_VERTEX -3 // pre-lit triangle models
461 #define LIGHTMAP_WHITEIMAGE -2
462 #define LIGHTMAP_NONE -1
463
464 typedef enum {
465 CT_FRONT_SIDED,
466 CT_BACK_SIDED,
467 CT_TWO_SIDED
468 } cullType_t;
469
470 typedef enum {
471 FP_NONE, // surface is translucent and will just be adjusted properly
472 FP_EQUAL, // surface is opaque but possibly alpha tested
473 FP_LE // surface is trnaslucent, but still needs a fog pass (fog surface)
474 } fogPass_t;
475
476 typedef struct {
477 float cloudHeight;
478 image_t *outerbox[6], *innerbox[6];
479 } skyParms_t;
480
481 typedef struct {
482 vec3_t color;
483 float depthForOpaque;
484 } fogParms_t;
485
486
487 typedef struct shader_s {
488 char name[MAX_QPATH]; // game path, including extension
489 int lightmapIndex; // for a shader to match, both name and lightmapIndex must match
490
491 int index; // this shader == tr.shaders[index]
492 int sortedIndex; // this shader == tr.sortedShaders[sortedIndex]
493
494 float sort; // lower numbered shaders draw before higher numbered
495
496 qboolean defaultShader; // we want to return index 0 if the shader failed to
497 // load for some reason, but R_FindShader should
498 // still keep a name allocated for it, so if
499 // something calls RE_RegisterShader again with
500 // the same name, we don't try looking for it again
501
502 qboolean explicitlyDefined; // found in a .shader file
503
504 int surfaceFlags; // if explicitlyDefined, this will have SURF_* flags
505 int contentFlags;
506
507 qboolean entityMergable; // merge across entites optimizable (smoke, blood)
508
509 qboolean isSky;
510 skyParms_t sky;
511 fogParms_t fogParms;
512
513 float portalRange; // distance to fog out at
514 qboolean isPortal;
515
516 cullType_t cullType; // CT_FRONT_SIDED, CT_BACK_SIDED, or CT_TWO_SIDED
517 qboolean polygonOffset; // set for decals and other items that must be offset
518 qboolean noMipMaps; // for console fonts, 2D elements, etc.
519 qboolean noPicMip; // for images that must always be full resolution
520 qboolean characterMip; // use r_picmip2 rather than r_picmip
521
522 fogPass_t fogPass; // draw a blended pass, possibly with depth test equals
523
524 int vertexAttribs; // not all shaders will need all data to be gathered
525
526 // Ridah
527 qboolean noFog;
528
529 int numDeforms;
530 deformStage_t deforms[MAX_SHADER_DEFORMS];
531
532 int numUnfoggedPasses;
533 shaderStage_t *stages[MAX_SHADER_STAGES];
534
535 void ( *optimalStageIteratorFunc )( void );
536
537 double clampTime; // time this shader is clamped to
538 double timeOffset; // current time offset for this shader
539
540 struct shader_s *remappedShader; // current shader this one is remapped too
541
542 struct shader_s *next;
543 } shader_t;
544
545 typedef struct cubemap_s {
546 char name[MAX_QPATH];
547 vec3_t origin;
548 float parallaxRadius;
549 image_t *image;
550 } cubemap_t;
551
552 typedef struct corona_s {
553 vec3_t origin;
554 vec3_t color; // range from 0.0 to 1.0, should be color normalized
555 vec3_t transformed; // origin in local coordinate system
556 float scale; // uses r_flaresize as the baseline (1.0)
557 int id;
558 int flags; // '1' is 'visible'
559 // still send the corona request, even if not visible, for proper fading
560 } corona_t;
561
562 typedef struct dlight_s {
563 vec3_t origin;
564 vec3_t color; // range from 0.0 to 1.0, should be color normalized
565 float radius;
566
567 vec3_t transformed; // origin in local coordinate system
568 int additive; // texture detail is lost tho when the lightmap is dark
569
570 // Ridah
571 int overdraw;
572 // done.
573
574 shader_t *dlshader; //----(SA) adding a shader to dlights, so, if desired, we can change the blend or texture of a dlight
575
576 qboolean forced; //----(SA) use this dlight when r_dynamiclight is either 1 or 2 (rather than just 1) for "important" gameplay lights (alarm lights, etc)
577 //done
578
579 } dlight_t;
580
581 enum
582 {
583 ATTR_INDEX_POSITION = 0,
584 ATTR_INDEX_TEXCOORD = 1,
585 ATTR_INDEX_LIGHTCOORD = 2,
586 ATTR_INDEX_TANGENT = 3,
587 ATTR_INDEX_NORMAL = 4,
588 ATTR_INDEX_COLOR = 5,
589 ATTR_INDEX_PAINTCOLOR = 6,
590 ATTR_INDEX_LIGHTDIRECTION = 7,
591 ATTR_INDEX_BONE_INDEXES = 8,
592 ATTR_INDEX_BONE_WEIGHTS = 9,
593
594 // GPU vertex animations
595 ATTR_INDEX_POSITION2 = 10,
596 ATTR_INDEX_TANGENT2 = 11,
597 ATTR_INDEX_NORMAL2 = 12,
598
599 ATTR_INDEX_COUNT = 13
600 };
601
602 enum
603 {
604 ATTR_POSITION = 1 << ATTR_INDEX_POSITION,
605 ATTR_TEXCOORD = 1 << ATTR_INDEX_TEXCOORD,
606 ATTR_LIGHTCOORD = 1 << ATTR_INDEX_LIGHTCOORD,
607 ATTR_TANGENT = 1 << ATTR_INDEX_TANGENT,
608 ATTR_NORMAL = 1 << ATTR_INDEX_NORMAL,
609 ATTR_COLOR = 1 << ATTR_INDEX_COLOR,
610 ATTR_PAINTCOLOR = 1 << ATTR_INDEX_PAINTCOLOR,
611 ATTR_LIGHTDIRECTION = 1 << ATTR_INDEX_LIGHTDIRECTION,
612 ATTR_BONE_INDEXES = 1 << ATTR_INDEX_BONE_INDEXES,
613 ATTR_BONE_WEIGHTS = 1 << ATTR_INDEX_BONE_WEIGHTS,
614
615 // for .md3 interpolation
616 ATTR_POSITION2 = 1 << ATTR_INDEX_POSITION2,
617 ATTR_TANGENT2 = 1 << ATTR_INDEX_TANGENT2,
618 ATTR_NORMAL2 = 1 << ATTR_INDEX_NORMAL2,
619
620 ATTR_DEFAULT = ATTR_POSITION,
621 ATTR_BITS = ATTR_POSITION |
622 ATTR_TEXCOORD |
623 ATTR_LIGHTCOORD |
624 ATTR_TANGENT |
625 ATTR_NORMAL |
626 ATTR_COLOR |
627 ATTR_PAINTCOLOR |
628 ATTR_LIGHTDIRECTION |
629 ATTR_BONE_INDEXES |
630 ATTR_BONE_WEIGHTS |
631 ATTR_POSITION2 |
632 ATTR_TANGENT2 |
633 ATTR_NORMAL2
634 };
635
636 enum
637 {
638 GENERICDEF_USE_DEFORM_VERTEXES = 0x0001,
639 GENERICDEF_USE_TCGEN_AND_TCMOD = 0x0002,
640 GENERICDEF_USE_VERTEX_ANIMATION = 0x0004,
641 GENERICDEF_USE_FOG = 0x0008,
642 GENERICDEF_USE_RGBAGEN = 0x0010,
643 GENERICDEF_USE_WOLF_FOG_LINEAR = 0x0020,
644 GENERICDEF_USE_WOLF_FOG_EXPONENTIAL = 0x0040,
645 GENERICDEF_USE_BONE_ANIMATION = 0x0080,
646 GENERICDEF_ALL = 0x00FF,
647 GENERICDEF_COUNT = 0x0100,
648 };
649
650 enum
651 {
652 FOGDEF_USE_DEFORM_VERTEXES = 0x0001,
653 FOGDEF_USE_VERTEX_ANIMATION = 0x0002,
654 FOGDEF_USE_WOLF_FOG_LINEAR = 0x0004,
655 FOGDEF_USE_WOLF_FOG_EXPONENTIAL = 0x0008,
656 FOGDEF_USE_BONE_ANIMATION = 0x0010,
657 FOGDEF_ALL = 0x001F,
658 FOGDEF_COUNT = 0x0020,
659 };
660
661 enum
662 {
663 DLIGHTDEF_USE_DEFORM_VERTEXES = 0x0001,
664 DLIGHTDEF_ALL = 0x0001,
665 DLIGHTDEF_COUNT = 0x0002,
666 };
667
668 enum
669 {
670 LIGHTDEF_USE_LIGHTMAP = 0x0001,
671 LIGHTDEF_USE_LIGHT_VECTOR = 0x0002,
672 LIGHTDEF_USE_LIGHT_VERTEX = 0x0003,
673 LIGHTDEF_LIGHTTYPE_MASK = 0x0003,
674 LIGHTDEF_ENTITY_VERTEX_ANIMATION = 0x0004,
675 LIGHTDEF_USE_TCGEN_AND_TCMOD = 0x0008,
676 LIGHTDEF_USE_PARALLAXMAP = 0x0010,
677 LIGHTDEF_USE_SHADOWMAP = 0x0020,
678 LIGHTDEF_ENTITY_BONE_ANIMATION = 0x0040,
679 LIGHTDEF_ALL = 0x007F,
680 LIGHTDEF_COUNT = 0x0080
681 };
682
683 enum
684 {
685 SHADOWMAPDEF_USE_VERTEX_ANIMATION = 0x0001,
686 SHADOWMAPDEF_USE_BONE_ANIMATION = 0x0002,
687 SHADOWMAPDEF_ALL = 0x0003,
688 SHADOWMAPDEF_COUNT = 0x0004
689 };
690
691 enum
692 {
693 GLSL_INT,
694 GLSL_FLOAT,
695 GLSL_FLOAT5,
696 GLSL_VEC2,
697 GLSL_VEC3,
698 GLSL_VEC4,
699 GLSL_MAT16,
700 GLSL_MAT16_BONEMATRIX
701 };
702
703 typedef enum
704 {
705 UNIFORM_DIFFUSEMAP = 0,
706 UNIFORM_LIGHTMAP,
707 UNIFORM_NORMALMAP,
708 UNIFORM_DELUXEMAP,
709 UNIFORM_SPECULARMAP,
710
711 UNIFORM_TEXTUREMAP,
712 UNIFORM_LEVELSMAP,
713 UNIFORM_CUBEMAP,
714
715 UNIFORM_SCREENIMAGEMAP,
716 UNIFORM_SCREENDEPTHMAP,
717
718 UNIFORM_SHADOWMAP,
719 UNIFORM_SHADOWMAP2,
720 UNIFORM_SHADOWMAP3,
721 UNIFORM_SHADOWMAP4,
722
723 UNIFORM_SHADOWMVP,
724 UNIFORM_SHADOWMVP2,
725 UNIFORM_SHADOWMVP3,
726 UNIFORM_SHADOWMVP4,
727
728 UNIFORM_ENABLETEXTURES,
729
730 UNIFORM_DIFFUSETEXMATRIX,
731 UNIFORM_DIFFUSETEXOFFTURB,
732
733 UNIFORM_TCGEN0,
734 UNIFORM_TCGEN0VECTOR0,
735 UNIFORM_TCGEN0VECTOR1,
736
737 UNIFORM_DEFORMGEN,
738 UNIFORM_DEFORMPARAMS,
739
740 UNIFORM_COLORGEN,
741 UNIFORM_ALPHAGEN,
742 UNIFORM_COLOR,
743 UNIFORM_BASECOLOR,
744 UNIFORM_VERTCOLOR,
745
746 UNIFORM_DLIGHTINFO,
747 UNIFORM_LIGHTFORWARD,
748 UNIFORM_LIGHTUP,
749 UNIFORM_LIGHTRIGHT,
750 UNIFORM_LIGHTORIGIN,
751 UNIFORM_MODELLIGHTDIR,
752 UNIFORM_LIGHTRADIUS,
753 UNIFORM_AMBIENTLIGHT,
754 UNIFORM_DIRECTEDLIGHT,
755
756 UNIFORM_PORTALRANGE,
757
758 UNIFORM_FOGDISTANCE,
759 UNIFORM_FOGDEPTH,
760 UNIFORM_FOGEYET,
761 UNIFORM_FOGCOLORMASK,
762
763 UNIFORM_MODELMATRIX,
764 UNIFORM_MODELVIEWPROJECTIONMATRIX,
765
766 UNIFORM_TIME,
767 UNIFORM_VERTEXLERP,
768 UNIFORM_NORMALSCALE,
769 UNIFORM_SPECULARSCALE,
770
771 UNIFORM_VIEWINFO, // znear, zfar, width/2, height/2
772 UNIFORM_VIEWORIGIN,
773 UNIFORM_LOCALVIEWORIGIN,
774 UNIFORM_VIEWFORWARD,
775 UNIFORM_VIEWLEFT,
776 UNIFORM_VIEWUP,
777
778 UNIFORM_INVTEXRES,
779 UNIFORM_AUTOEXPOSUREMINMAX,
780 UNIFORM_TONEMINAVGMAXLINEAR,
781
782 UNIFORM_PRIMARYLIGHTORIGIN,
783 UNIFORM_PRIMARYLIGHTCOLOR,
784 UNIFORM_PRIMARYLIGHTAMBIENT,
785 UNIFORM_PRIMARYLIGHTRADIUS,
786
787 UNIFORM_CUBEMAPINFO,
788
789 UNIFORM_ALPHATEST,
790
791 UNIFORM_BONEMATRIX,
792
793 UNIFORM_FIRERISEDIR,
794 UNIFORM_ZFADELOWEST,
795 UNIFORM_ZFADEHIGHEST,
796
797 UNIFORM_COUNT
798 } uniform_t;
799
800 // shaderProgram_t represents a pair of one
801 // GLSL vertex and one GLSL fragment shader
802 typedef struct shaderProgram_s
803 {
804 char name[MAX_QPATH];
805
806 GLuint program;
807 GLuint vertexShader;
808 GLuint fragmentShader;
809 uint32_t attribs; // vertex array attributes
810
811 // uniform parameters
812 GLint uniforms[UNIFORM_COUNT];
813 short uniformBufferOffsets[UNIFORM_COUNT]; // max 32767/64=511 uniforms
814 char *uniformBuffer;
815 } shaderProgram_t;
816
817 // trRefdef_t holds everything that comes in refdef_t,
818 // as well as the locally generated scene information
819 typedef struct {
820 int x, y, width, height;
821 float fov_x, fov_y;
822 vec3_t vieworg;
823 vec3_t viewaxis[3]; // transformation matrix
824
825 stereoFrame_t stereoFrame;
826
827 int time; // time in milliseconds for shader effects and other time dependent rendering issues
828 int rdflags; // RDF_NOWORLDMODEL, etc
829
830 // 1 bits will prevent the associated area from rendering at all
831 byte areamask[MAX_MAP_AREA_BYTES];
832 qboolean areamaskModified; // qtrue if areamask changed since last scene
833
834 double floatTime; // tr.refdef.time / 1000.0
835
836 float blurFactor;
837
838 // text messages for deform text shaders
839 char text[MAX_RENDER_STRINGS][MAX_RENDER_STRING_LENGTH];
840
841 int num_entities;
842 trRefEntity_t *entities;
843
844 int num_dlights;
845 struct dlight_s *dlights;
846
847 int num_coronas;
848 struct corona_s *coronas;
849
850 int numPolys;
851 struct srfPoly_s *polys;
852
853 int numDrawSurfs;
854 struct drawSurf_s *drawSurfs;
855
856 unsigned int dlightMask;
857 int num_pshadows;
858 struct pshadow_s *pshadows;
859
860 float sunShadowMvp[4][16];
861 float sunDir[4];
862 float sunCol[4];
863 float sunAmbCol[4];
864
865 float autoExposureMinMax[2];
866 float toneMinAvgMaxLinear[3];
867 } trRefdef_t;
868
869
870 //=================================================================================
871
872 // max surfaces per-skin
873 // This is an arbitry limit. Vanilla Q3 only supported 32 surfaces in skins but failed to
874 // enforce the maximum limit when reading skin files. It was possile to use more than 32
875 // surfaces which accessed out of bounds memory past end of skin->surfaces hunk block.
876 #define MAX_SKIN_SURFACES 256
877
878 // skins allow models to be retextured without modifying the model file
879 typedef struct {
880 char name[MAX_QPATH];
881 shader_t *shader;
882 } skinSurface_t;
883
884 //----(SA) modified
885 #define MAX_PART_MODELS 5
886
887 typedef struct {
888 char type[MAX_QPATH]; // md3_lower, md3_lbelt, md3_rbelt, etc.
889 char model[MAX_QPATH]; // lower.md3, belt1.md3, etc.
890 } skinModel_t;
891
892 typedef struct skin_s {
893 char name[MAX_QPATH]; // game path, including extension
894 int numSurfaces;
895 int numModels;
896 skinSurface_t *surfaces; // dynamically allocated array of surfaces
897 skinModel_t *models[MAX_PART_MODELS];
898 vec3_t scale; //----(SA) added
899 } skin_t;
900 //----(SA) end
901
902 typedef struct {
903 int originalBrushNumber;
904 vec3_t bounds[2];
905
906 unsigned colorInt; // in packed byte format
907 float tcScale; // texture coordinate vector scales
908 fogParms_t parms;
909
910 // for clipping distance in fog when outside
911 qboolean hasSurface;
912 float surface[4];
913 } fog_t;
914
915 typedef enum {
916 VPF_NONE = 0x00,
917 VPF_NOVIEWMODEL = 0x01,
918 VPF_SHADOWMAP = 0x02,
919 VPF_DEPTHSHADOW = 0x04,
920 VPF_DEPTHCLAMP = 0x08,
921 VPF_ORTHOGRAPHIC = 0x10,
922 VPF_USESUNLIGHT = 0x20,
923 VPF_FARPLANEFRUSTUM = 0x40,
924 VPF_NOCUBEMAPS = 0x80
925 } viewParmFlags_t;
926
927 typedef struct {
928 orientationr_t or;
929 orientationr_t world;
930 vec3_t pvsOrigin; // may be different than or.origin for portals
931 qboolean isPortal; // true if this view is through a portal
932 qboolean isMirror; // the portal is a mirror, invert the face culling
933 viewParmFlags_t flags;
934 int frameSceneNum; // copied from tr.frameSceneNum
935 int frameCount; // copied from tr.frameCount
936 cplane_t portalPlane; // clip anything behind this if mirroring
937 int viewportX, viewportY, viewportWidth, viewportHeight;
938 FBO_t *targetFbo;
939 int targetFboLayer;
940 int targetFboCubemapIndex;
941 float fovX, fovY;
942 float projectionMatrix[16];
943 cplane_t frustum[5];
944 vec3_t visBounds[2];
945 float zFar;
946 float zNear;
947 stereoFrame_t stereoFrame;
948
949 int dirty;
950
951 glfog_t glFog; // fog parameters //----(SA) added
952
953 } viewParms_t;
954
955
956 /*
957 ==============================================================================
958
959 SURFACES
960
961 ==============================================================================
962 */
963
964 typedef byte color4ub_t[4];
965
966 // any changes in surfaceType must be mirrored in rb_surfaceTable[]
967 // NOTE: also mirror changes to max2skl.c
968 typedef enum {
969 SF_BAD,
970 SF_SKIP, // ignore
971 SF_FACE,
972 SF_GRID,
973 SF_TRIANGLES,
974 SF_POLY,
975 SF_MDV,
976 SF_MDS,
977 SF_MDR,
978 SF_IQM,
979 SF_FLARE,
980 SF_ENTITY, // beams, rails, lightning, etc that can be determined by entity
981 SF_VAO_MDVMESH,
982 SF_VAO_IQM,
983
984 SF_NUM_SURFACE_TYPES,
985 SF_MAX = 0xffffffff // ensures that sizeof( surfaceType_t ) == sizeof( int )
986 } surfaceType_t;
987
988 typedef struct drawSurf_s {
989 unsigned int sort; // bit combination for fast compares
990 int cubemapIndex;
991 surfaceType_t *surface; // any of surface*_t
992 } drawSurf_t;
993
994 #define MAX_FACE_POINTS 64
995
996 #define MAX_PATCH_SIZE 32 // max dimensions of a patch mesh in map file
997 #define MAX_GRID_SIZE 65 // max dimensions of a grid mesh in memory
998
999 // when cgame directly specifies a polygon, it becomes a srfPoly_t
1000 // as soon as it is called
1001 typedef struct srfPoly_s {
1002 surfaceType_t surfaceType;
1003 qhandle_t hShader;
1004 int fogIndex;
1005 int numVerts;
1006 polyVert_t *verts;
1007 } srfPoly_t;
1008
1009
1010 typedef struct srfFlare_s {
1011 surfaceType_t surfaceType;
1012 vec3_t origin;
1013 vec3_t normal;
1014 vec3_t color;
1015 } srfFlare_t;
1016
1017
1018 typedef struct
1019 {
1020 vec3_t xyz;
1021 vec2_t st;
1022 vec2_t lightmap;
1023 int16_t normal[4];
1024 int16_t tangent[4];
1025 int16_t lightdir[4];
1026 uint16_t color[4];
1027
1028 #if DEBUG_OPTIMIZEVERTICES
1029 unsigned int id;
1030 #endif
1031 } srfVert_t;
1032
1033 #define srfVert_t_cleared(x) srfVert_t (x) = {{0, 0, 0}, {0, 0}, {0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}}
1034
1035 // srfBspSurface_t covers SF_GRID, SF_TRIANGLES, and SF_POLY
1036 typedef struct srfBspSurface_s
1037 {
1038 surfaceType_t surfaceType;
1039
1040 // dynamic lighting information
1041 int dlightBits;
1042 int pshadowBits;
1043
1044 // culling information
1045 vec3_t cullBounds[2];
1046 vec3_t cullOrigin;
1047 float cullRadius;
1048 cplane_t cullPlane;
1049
1050 // indexes
1051 int numIndexes;
1052 glIndex_t *indexes;
1053
1054 // vertexes
1055 int numVerts;
1056 srfVert_t *verts;
1057
1058 // SF_GRID specific variables after here
1059
1060 // lod information, which may be different
1061 // than the culling information to allow for
1062 // groups of curves that LOD as a unit
1063 vec3_t lodOrigin;
1064 float lodRadius;
1065 int lodFixed;
1066 int lodStitched;
1067
1068 // vertexes
1069 int width, height;
1070 float *widthLodError;
1071 float *heightLodError;
1072 } srfBspSurface_t;
1073
1074 // inter-quake-model
1075 typedef struct {
1076 int num_vertexes;
1077 int num_triangles;
1078 int num_frames;
1079 int num_surfaces;
1080 int num_joints;
1081 int num_poses;
1082 struct srfIQModel_s *surfaces;
1083
1084 int *triangles;
1085
1086 // vertex arrays
1087 float *positions;
1088 float *texcoords;
1089 float *normals;
1090 float *tangents;
1091 byte *colors;
1092 int *influences; // [num_vertexes] indexes into influenceBlendVertexes
1093 // unique list of vertex blend indexes/weights for faster CPU vertex skinning
1094 byte *influenceBlendIndexes; // [num_influences]
1095 union {
1096 float *f;
1097 byte *b;
1098 } influenceBlendWeights; // [num_influences]
1099
1100 // depending upon the exporter, blend indices and weights might be int/float
1101 // as opposed to the recommended byte/byte, for example Noesis exports
1102 // int/float whereas the official IQM tool exports byte/byte
1103 int blendWeightsType; // IQM_UBYTE or IQM_FLOAT
1104
1105 char *jointNames;
1106 int *jointParents;
1107 float *jointMats;
1108 float *poseMats;
1109 float *bounds;
1110
1111 int numVaoSurfaces;
1112 struct srfVaoIQModel_s *vaoSurfaces;
1113 } iqmData_t;
1114
1115 // inter-quake-model surface
1116 typedef struct srfIQModel_s {
1117 surfaceType_t surfaceType;
1118 char name[MAX_QPATH];
1119 shader_t *shader;
1120 iqmData_t *data;
1121 int first_vertex, num_vertexes;
1122 int first_triangle, num_triangles;
1123 int first_influence, num_influences;
1124 } srfIQModel_t;
1125
1126 typedef struct srfVaoIQModel_s
1127 {
1128 surfaceType_t surfaceType;
1129 iqmData_t *iqmData;
1130 struct srfIQModel_s *iqmSurface;
1131 // backEnd stats
1132 int numIndexes;
1133 int numVerts;
1134 // static render data
1135 vao_t *vao;
1136 } srfVaoIQModel_t;
1137
1138 typedef struct srfVaoMdvMesh_s
1139 {
1140 surfaceType_t surfaceType;
1141
1142 struct mdvModel_s *mdvModel;
1143 struct mdvSurface_s *mdvSurface;
1144
1145 // backEnd stats
1146 int numIndexes;
1147 int numVerts;
1148
1149 // static render data
1150 vao_t *vao;
1151 } srfVaoMdvMesh_t;
1152
1153 extern void( *rb_surfaceTable[SF_NUM_SURFACE_TYPES] ) ( void * );
1154
1155 /*
1156 ==============================================================================
1157
1158 SHADOWS
1159
1160 ==============================================================================
1161 */
1162
1163 typedef struct pshadow_s
1164 {
1165 float sort;
1166
1167 int numEntities;
1168 int entityNums[8];
1169 vec3_t entityOrigins[8];
1170 float entityRadiuses[8];
1171
1172 float viewRadius;
1173 vec3_t viewOrigin;
1174
1175 vec3_t lightViewAxis[3];
1176 vec3_t lightOrigin;
1177 float lightRadius;
1178 cplane_t cullPlane;
1179 } pshadow_t;
1180
1181 /*
1182 ==============================================================================
1183
1184 BRUSH MODELS
1185
1186 ==============================================================================
1187 */
1188
1189
1190 //
1191 // in memory representation
1192 //
1193
1194 #define SIDE_FRONT 0
1195 #define SIDE_BACK 1
1196 #define SIDE_ON 2
1197
1198 #define CULLINFO_NONE 0
1199 #define CULLINFO_BOX 1
1200 #define CULLINFO_SPHERE 2
1201 #define CULLINFO_PLANE 4
1202
1203 typedef struct cullinfo_s {
1204 int type;
1205 vec3_t bounds[2];
1206 vec3_t localOrigin;
1207 float radius;
1208 cplane_t plane;
1209 } cullinfo_t;
1210
1211 typedef struct msurface_s {
1212 //int viewCount; // if == tr.viewCount, already added
1213 struct shader_s *shader;
1214 int fogIndex;
1215 int cubemapIndex;
1216 cullinfo_t cullinfo;
1217
1218 surfaceType_t *data; // any of srf*_t
1219 } msurface_t;
1220
1221
1222
1223 #define CONTENTS_NODE -1
1224 typedef struct mnode_s {
1225 // common with leaf and node
1226 int contents; // -1 for nodes, to differentiate from leafs
1227 int visCounts[MAX_VISCOUNTS]; // node needs to be traversed if current
1228 vec3_t mins, maxs; // for bounding box culling
1229 struct mnode_s *parent;
1230
1231 // node specific
1232 cplane_t *plane;
1233 struct mnode_s *children[2];
1234
1235 // leaf specific
1236 int cluster;
1237 int area;
1238
1239 int firstmarksurface;
1240 int nummarksurfaces;
1241 } mnode_t;
1242
1243 typedef struct {
1244 vec3_t bounds[2]; // for culling
1245 int firstSurface;
1246 int numSurfaces;
1247 } bmodel_t;
1248
1249 typedef struct {
1250 char name[MAX_QPATH]; // ie: maps/tim_dm2.bsp
1251 char baseName[MAX_QPATH]; // ie: tim_dm2
1252
1253 int dataSize;
1254
1255 int numShaders;
1256 dshader_t *shaders;
1257
1258 int numBModels;
1259 bmodel_t *bmodels;
1260
1261 int numplanes;
1262 cplane_t *planes;
1263
1264 int numnodes; // includes leafs
1265 int numDecisionNodes;
1266 mnode_t *nodes;
1267
1268 int numWorldSurfaces;
1269
1270 int numsurfaces;
1271 msurface_t *surfaces;
1272 int *surfacesViewCount;
1273 int *surfacesDlightBits;
1274 int *surfacesPshadowBits;
1275
1276 int nummarksurfaces;
1277 int *marksurfaces;
1278
1279 int numfogs;
1280 fog_t *fogs;
1281
1282 vec3_t lightGridOrigin;
1283 vec3_t lightGridSize;
1284 vec3_t lightGridInverseSize;
1285 int lightGridBounds[3];
1286 byte *lightGridData;
1287 uint16_t *lightGrid16;
1288
1289 int numClusters;
1290 int clusterBytes;
1291 const byte *vis; // may be passed in by CM_LoadMap to save space
1292
1293 char *entityString;
1294 char *entityParsePoint;
1295 } world_t;
1296
1297 /*
1298 ==============================================================================
1299 MDV MODELS - meta format for vertex animation models like .md2, .md3, .mdc
1300 ==============================================================================
1301 */
1302 typedef struct
1303 {
1304 float bounds[2][3];
1305 float localOrigin[3];
1306 float radius;
1307 } mdvFrame_t;
1308
1309 typedef struct
1310 {
1311 float origin[3];
1312 float axis[3][3];
1313 } mdvTag_t;
1314
1315 typedef struct
1316 {
1317 char name[MAX_QPATH]; // tag name
1318 } mdvTagName_t;
1319
1320 typedef struct
1321 {
1322 vec3_t xyz;
1323 int16_t normal[4];
1324 int16_t tangent[4];
1325 } mdvVertex_t;
1326
1327 typedef struct
1328 {
1329 float st[2];
1330 } mdvSt_t;
1331
1332 typedef struct mdvSurface_s
1333 {
1334 surfaceType_t surfaceType;
1335
1336 char name[MAX_QPATH]; // polyset name
1337
1338 int numShaderIndexes;
1339 int *shaderIndexes;
1340
1341 int numVerts;
1342 mdvVertex_t *verts;
1343 mdvSt_t *st;
1344
1345 int numIndexes;
1346 glIndex_t *indexes;
1347
1348 struct mdvModel_s *model;
1349 } mdvSurface_t;
1350
1351 typedef struct mdvModel_s
1352 {
1353 int numFrames;
1354 mdvFrame_t *frames;
1355
1356 int numTags;
1357 mdvTag_t *tags;
1358 mdvTagName_t *tagNames;
1359
1360 int numSurfaces;
1361 mdvSurface_t *surfaces;
1362
1363 int numVaoSurfaces;
1364 srfVaoMdvMesh_t *vaoSurfaces;
1365
1366 int numSkins;
1367 } mdvModel_t;
1368
1369 //======================================================================
1370
1371 typedef enum {
1372 MOD_BAD,
1373 MOD_BRUSH,
1374 MOD_MESH,
1375 MOD_MDS,
1376 MOD_MDC, // Ridah
1377 MOD_MDR,
1378 MOD_IQM
1379 } modtype_t;
1380
1381 typedef struct model_s {
1382 char name[MAX_QPATH];
1383 modtype_t type;
1384 int index; // model = tr.models[model->index]
1385
1386 int dataSize; // just for listing purposes
1387 bmodel_t *bmodel; // only if type == MOD_BRUSH
1388 mdvModel_t *mdv[MD3_MAX_LODS]; // only if type == MOD_MESH
1389 mdsHeader_t *mds; // only if type == MOD_MDS
1390 void *modelData; // only if type == (MOD_MDR | MOD_IQM)
1391
1392 int numLods;
1393
1394 // GR - model tessellation capability flag
1395 int ATI_tess;
1396 } model_t;
1397
1398
1399 #define MAX_MOD_KNOWN 2048
1400
1401 void R_ModelInit( void );
1402 model_t *R_GetModelByHandle( qhandle_t hModel );
1403 int R_LerpTag( orientation_t *tag, const refEntity_t *refent, const char *tagName, int startIndex );
1404 void R_ModelBounds( qhandle_t handle, vec3_t mins, vec3_t maxs );
1405
1406 void R_Modellist_f( void );
1407
1408 //====================================================
1409 extern refimport_t ri;
1410
1411 #define MAX_DRAWIMAGES 2048
1412 #define MAX_SKINS 1024
1413
1414
1415 #define MAX_DRAWSURFS 0x10000
1416 #define DRAWSURF_MASK ( MAX_DRAWSURFS - 1 )
1417
1418 /*
1419
1420 the drawsurf sort data is packed into a single 32 bit value so it can be
1421 compared quickly during the qsorting process
1422
1423 the bits are allocated as follows:
1424
1425 (SA) modified for Wolf (11 bits of entity num)
1426
1427 old:
1428
1429 22 - 31 : sorted shader index
1430 12 - 21 : entity index
1431 3 - 7 : fog index
1432 2 : used to be clipped flag
1433 0 - 1 : dlightmap index
1434
1435 #define QSORT_SHADERNUM_SHIFT 22
1436 #define QSORT_ENTITYNUM_SHIFT 12
1437 #define QSORT_FOGNUM_SHIFT 3
1438
1439 new:
1440
1441 22 - 31 : sorted shader index
1442 11 - 21 : entity index
1443 2 - 6 : fog index
1444 removed : used to be clipped flag
1445 0 - 1 : dlightmap index
1446
1447 SmileTheory - for pshadows
1448 17-31 : sorted shader index
1449 7-16 : entity index
1450 2-6 : fog index
1451 1 : pshadow flag
1452 0 : dlight flag
1453
1454 #define QSORT_SHADERNUM_SHIFT 22
1455 #define QSORT_ENTITYNUM_SHIFT 11
1456 #define QSORT_FOGNUM_SHIFT 2
1457
1458 */
1459
1460 #define QSORT_FOGNUM_SHIFT 2
1461 #define QSORT_REFENTITYNUM_SHIFT 11
1462 #define QSORT_SHADERNUM_SHIFT (QSORT_REFENTITYNUM_SHIFT+REFENTITYNUM_BITS)
1463 #if (QSORT_SHADERNUM_SHIFT+SHADERNUM_BITS) > 32
1464 #error "Need to update sorting, too many bits."
1465 #endif
1466
1467 #define QSORT_PSHADOW_SHIFT 1
1468
1469 // GR - tessellation flag in bit 8
1470 #define QSORT_ATI_TESS_SHIFT 8
1471 // GR - TruForm flags
1472 #define ATI_TESS_TRUFORM 1
1473 #define ATI_TESS_NONE 0
1474
1475 extern int gl_filter_min, gl_filter_max;
1476
1477 /*
1478 ** performanceCounters_t
1479 */
1480 typedef struct {
1481 int c_sphere_cull_patch_in, c_sphere_cull_patch_clip, c_sphere_cull_patch_out;
1482 int c_box_cull_patch_in, c_box_cull_patch_clip, c_box_cull_patch_out;
1483 int c_sphere_cull_md3_in, c_sphere_cull_md3_clip, c_sphere_cull_md3_out;
1484 int c_box_cull_md3_in, c_box_cull_md3_clip, c_box_cull_md3_out;
1485
1486 int c_leafs;
1487 int c_dlightSurfaces;
1488 int c_dlightSurfacesCulled;
1489 } frontEndCounters_t;
1490
1491 #define FOG_TABLE_SIZE 256
1492 #define FUNCTABLE_SIZE 1024
1493 #define FUNCTABLE_SIZE2 10
1494 #define FUNCTABLE_MASK ( FUNCTABLE_SIZE - 1 )
1495
1496
1497 // the renderer front end should never modify glstate_t
1498 typedef struct {
1499 qboolean finishCalled;
1500 int texEnv[2];
1501 int faceCulling;
1502 int faceCullFront;
1503 uint32_t glStateBits;
1504 uint32_t storedGlState;
1505 float vertexAttribsInterpolation;
1506 qboolean vertexAnimation;
1507 int boneAnimation; // number of bones
1508 mat4_t boneMatrix[IQM_MAX_JOINTS];
1509 uint32_t vertexAttribsEnabled; // global if no VAOs, tess only otherwise
1510 FBO_t *currentFBO;
1511 vao_t *currentVao;
1512 mat4_t modelview;
1513 mat4_t projection;
1514 mat4_t modelviewProjection;
1515 } glstate_t;
1516
1517 typedef enum {
1518 MI_NONE,
1519 MI_NVX,
1520 MI_ATI
1521 } memInfo_t;
1522
1523 typedef enum {
1524 TCR_NONE = 0x0000,
1525 TCR_RGTC = 0x0001,
1526 TCR_BPTC = 0x0002,
1527 } textureCompressionRef_t;
1528
1529 // We can't change glConfig_t without breaking DLL/vms compatibility, so
1530 // store extensions we have here.
1531 typedef struct {
1532 qboolean intelGraphics;
1533
1534 qboolean occlusionQuery;
1535
1536 int glslMajorVersion;
1537 int glslMinorVersion;
1538 int glslMaxAnimatedBones;
1539
1540 memInfo_t memInfo;
1541
1542 qboolean framebufferObject;
1543 int maxRenderbufferSize;
1544 int maxColorAttachments;
1545
1546 qboolean textureFloat;
1547 textureCompressionRef_t textureCompression;
1548 qboolean swizzleNormalmap;
1549
1550 qboolean framebufferMultisample;
1551 qboolean framebufferBlit;
1552
1553 qboolean depthClamp;
1554 qboolean seamlessCubeMap;
1555
1556 qboolean vertexArrayObject;
1557 qboolean directStateAccess;
1558 } glRefConfig_t;
1559
1560 typedef struct {
1561 int c_surfaces, c_shaders, c_vertexes, c_indexes, c_totalIndexes;
1562 int c_surfBatches;
1563 float c_overDraw;
1564
1565 int c_vaoBinds;
1566 int c_vaoVertexes;
1567 int c_vaoIndexes;
1568
1569 int c_staticVaoDraws;
1570 int c_dynamicVaoDraws;
1571
1572 int c_dlightVertexes;
1573 int c_dlightIndexes;
1574
1575 int c_flareAdds;
1576 int c_flareTests;
1577 int c_flareRenders;
1578
1579 int c_glslShaderBinds;
1580 int c_genericDraws;
1581 int c_lightallDraws;
1582 int c_fogDraws;
1583 int c_dlightDraws;
1584
1585 int msec; // total msec for backend run
1586 } backEndCounters_t;
1587
1588 // all state modified by the back end is seperated
1589 // from the front end state
1590 typedef struct {
1591 trRefdef_t refdef;
1592 viewParms_t viewParms;
1593 orientationr_t or;
1594 backEndCounters_t pc;
1595 qboolean isHyperspace;
1596 trRefEntity_t *currentEntity;
1597 qboolean skyRenderedThisView; // flag for drawing sun
1598
1599 qboolean projection2D; // if qtrue, drawstretchpic doesn't need to change modes
1600 byte color2D[4];
1601 qboolean vertexes2D; // shader needs to be finished
1602 trRefEntity_t entity2D; // currentEntity will point at this when doing 2D rendering
1603
1604 FBO_t *last2DFBO;
1605 qboolean colorMask[4];
1606 qboolean framePostProcessed;
1607 qboolean depthFill;
1608 } backEndState_t;
1609
1610 /*
1611 ** trGlobals_t
1612 **
1613 ** Most renderer globals are defined here.
1614 ** backend functions should never modify any of these fields,
1615 ** but may read fields that aren't dynamically modified
1616 ** by the frontend.
1617 */
1618 typedef struct {
1619 qboolean registered; // cleared at shutdown, set at beginRegistration
1620
1621 int visIndex;
1622 int visClusters[MAX_VISCOUNTS];
1623 int visCounts[MAX_VISCOUNTS]; // incremented every time a new vis cluster is entered
1624
1625 int frameCount; // incremented every frame
1626 int sceneCount; // incremented every scene
1627 int viewCount; // incremented every view (twice a scene if portaled)
1628 // and every R_MarkFragments call
1629
1630 int frameSceneNum; // zeroed at RE_BeginFrame
1631
1632 qboolean worldMapLoaded;
1633 qboolean worldDeluxeMapping;
1634 vec2_t autoExposureMinMax;
1635 vec3_t toneMinAvgMaxLevel;
1636 world_t *world;
1637
1638 const byte *externalVisData; // from RE_SetWorldVisData, shared with CM_Load
1639
1640 image_t *defaultImage;
1641 image_t *scratchImage[32];
1642 image_t *fogImage;
1643 image_t *dlightImage; // inverse-square highlight for projective adding
1644 image_t *flareImage;
1645 image_t *whiteImage; // full of 0xff
1646 image_t *identityLightImage; // full of tr.identityLightByte
1647
1648 image_t *shadowCubemaps[MAX_DLIGHTS];
1649
1650
1651 image_t *renderImage;
1652 image_t *sunRaysImage;
1653 image_t *renderDepthImage;
1654 image_t *pshadowMaps[MAX_DRAWN_PSHADOWS];
1655 image_t *screenScratchImage;
1656 image_t *textureScratchImage[2];
1657 image_t *quarterImage[2];
1658 image_t *calcLevelsImage;
1659 image_t *targetLevelsImage;
1660 image_t *fixedLevelsImage;
1661 image_t *sunShadowDepthImage[4];
1662 image_t *screenShadowImage;
1663 image_t *screenSsaoImage;
1664 image_t *hdrDepthImage;
1665 image_t *renderCubeImage;
1666
1667 image_t *textureDepthImage;
1668
1669 FBO_t *renderFbo;
1670 FBO_t *msaaResolveFbo;
1671 FBO_t *sunRaysFbo;
1672 FBO_t *depthFbo;
1673 FBO_t *pshadowFbos[MAX_DRAWN_PSHADOWS];
1674 FBO_t *screenScratchFbo;
1675 FBO_t *textureScratchFbo[2];
1676 FBO_t *quarterFbo[2];
1677 FBO_t *calcLevelsFbo;
1678 FBO_t *targetLevelsFbo;
1679 FBO_t *sunShadowFbo[4];
1680 FBO_t *screenShadowFbo;
1681 FBO_t *screenSsaoFbo;
1682 FBO_t *hdrDepthFbo;
1683 FBO_t *renderCubeFbo;
1684
1685 shader_t *defaultShader;
1686 shader_t *shadowShader;
1687 shader_t *projectionShadowShader;
1688 // shader_t *dlightShader; //----(SA) added
1689
1690 shader_t *flareShader;
1691 shader_t *spotFlareShader;
1692 char *sunShaderName;
1693 shader_t *sunShader;
1694 shader_t *sunFlareShader;
1695 shader_t *sunflareShader_old[6]; //----(SA) for the camera lens flare effect for sun
1696
1697 int numLightmaps;
1698 int lightmapSize;
1699 image_t **lightmaps;
1700 image_t **deluxemaps;
1701
1702 int fatLightmapCols;
1703 int fatLightmapRows;
1704
1705 int numCubemaps;
1706 cubemap_t *cubemaps;
1707
1708 trRefEntity_t *currentEntity;
1709 trRefEntity_t worldEntity; // point currentEntity at this when rendering world
1710 int currentEntityNum;
1711 int shiftedEntityNum; // currentEntityNum << QSORT_REFENTITYNUM_SHIFT
1712 model_t *currentModel;
1713
1714 //
1715 // GPU shader programs
1716 //
1717 shaderProgram_t genericShader[GENERICDEF_COUNT];
1718 shaderProgram_t textureColorShader;
1719 shaderProgram_t fogShader[FOGDEF_COUNT];
1720 shaderProgram_t dlightShader[DLIGHTDEF_COUNT];
1721 shaderProgram_t lightallShader[LIGHTDEF_COUNT];
1722 shaderProgram_t shadowmapShader[SHADOWMAPDEF_COUNT];
1723 shaderProgram_t pshadowShader;
1724 shaderProgram_t down4xShader;
1725 shaderProgram_t bokehShader;
1726 shaderProgram_t tonemapShader;
1727 shaderProgram_t calclevels4xShader[2];
1728 shaderProgram_t shadowmaskShader;
1729 shaderProgram_t ssaoShader;
1730 shaderProgram_t depthBlurShader[4];
1731 shaderProgram_t testcubeShader;
1732
1733
1734 // -----------------------------------------
1735
1736 viewParms_t viewParms;
1737
1738 float identityLight; // 1.0 / ( 1 << overbrightBits )
1739 int identityLightByte; // identityLight * 255
1740 int overbrightBits; // r_overbrightBits->integer, but set to 0 if no hw gamma
1741
1742 orientationr_t or; // for current entity
1743
1744 trRefdef_t refdef;
1745
1746 int viewCluster;
1747
1748 float sunShadowScale;
1749
1750 qboolean sunShadows;
1751
1752 vec3_t sunLight; // from the sky shader for this level
1753 vec3_t sunDirection;
1754 vec3_t lastCascadeSunDirection;
1755 float lastCascadeSunMvp[16];
1756
1757 //----(SA) added
1758 float lightGridMulAmbient; // lightgrid multipliers specified in sky shader
1759 float lightGridMulDirected; //
1760 //----(SA) end
1761
1762 // qboolean levelGLFog;
1763
1764 frontEndCounters_t pc;
1765 int frontEndMsec; // not in pc due to clearing issue
1766
1767 //
1768 // put large tables at the end, so most elements will be
1769 // within the +/32K indexed range on risc processors
1770 //
1771 model_t *models[MAX_MOD_KNOWN];
1772 int numModels;
1773
1774 int numImages;
1775 image_t *images[MAX_DRAWIMAGES];
1776
1777 int numFBOs;
1778 FBO_t *fbos[MAX_FBOS];
1779
1780 int numVaos;
1781 vao_t *vaos[MAX_VAOS];
1782
1783 // shader indexes from other modules will be looked up in tr.shaders[]
1784 // shader indexes from drawsurfs will be looked up in sortedShaders[]
1785 // lower indexed sortedShaders must be rendered first (opaque surfaces before translucent)
1786 int numShaders;
1787 shader_t *shaders[MAX_SHADERS];
1788 shader_t *sortedShaders[MAX_SHADERS];
1789
1790 int numSkins;
1791 skin_t *skins[MAX_SKINS];
1792
1793 GLuint sunFlareQuery[2];
1794 int sunFlareQueryIndex;
1795 qboolean sunFlareQueryActive[2];
1796
1797 float sinTable[FUNCTABLE_SIZE];
1798 float squareTable[FUNCTABLE_SIZE];
1799 float triangleTable[FUNCTABLE_SIZE];
1800 float sawToothTable[FUNCTABLE_SIZE];
1801 float inverseSawToothTable[FUNCTABLE_SIZE];
1802 float fogTable[FOG_TABLE_SIZE];
1803
1804 // RF, temp var used while parsing shader only
1805 int allowCompress;
1806
1807 } trGlobals_t;
1808
1809 extern backEndState_t backEnd;
1810 extern trGlobals_t tr;
1811 extern glconfig_t glConfig; // outside of TR since it shouldn't be cleared during ref re-init
1812 extern glstate_t glState; // outside of TR since it shouldn't be cleared during ref re-init
1813
1814 // These three variables should live inside glConfig but can't because of compatibility issues to the original ID vms.
1815 // If you release a stand-alone game and your mod uses tr_types.h from this build you can safely move them to
1816 // the glconfig_t struct.
1817 extern qboolean textureFilterAnisotropic;
1818 extern int maxAnisotropy;
1819 extern glRefConfig_t glRefConfig;
1820 extern float displayAspect;
1821
1822 //
1823 // cvars
1824 //
1825 extern cvar_t *r_flareSize;
1826 extern cvar_t *r_flareFade;
1827 // coefficient for the flare intensity falloff function.
1828 #define FLARE_STDCOEFF "150"
1829 extern cvar_t *r_flareCoeff;
1830
1831 extern cvar_t *r_railWidth;
1832 extern cvar_t *r_railCoreWidth;
1833 extern cvar_t *r_railSegmentLength;
1834
1835 extern cvar_t *r_ignore; // used for debugging anything
1836 extern cvar_t *r_verbose; // used for verbose debug spew
1837
1838 extern cvar_t *r_znear; // near Z clip plane
1839 extern cvar_t *r_zproj; // z distance of projection plane
1840 extern cvar_t *r_stereoSeparation; // separation of cameras for stereo rendering
1841 extern cvar_t *r_zfar; // far Z clip plane
1842
1843 extern cvar_t *r_stencilbits; // number of desired stencil bits
1844 extern cvar_t *r_depthbits; // number of desired depth bits
1845 extern cvar_t *r_colorbits; // number of desired color bits, only relevant for fullscreen
1846 extern cvar_t *r_texturebits; // number of desired texture bits
1847 // 0 = use framebuffer depth
1848 // 16 = use 16-bit textures
1849 // 32 = use 32-bit textures
1850 // all else = error
1851 extern cvar_t *r_ext_multisample;
1852
1853 extern cvar_t *r_measureOverdraw; // enables stencil buffer overdraw measurement
1854
1855 extern cvar_t *r_lodbias; // push/pull LOD transitions
1856 extern cvar_t *r_lodscale;
1857
1858 extern cvar_t *r_inGameVideo; // controls whether in game video should be draw
1859 extern cvar_t *r_fastsky; // controls whether sky should be cleared or drawn
1860 extern cvar_t *r_drawSun; // controls drawing of sun quad
1861 // "0" no sun
1862 // "1" draw sun
1863 // "2" also draw lens flare effect centered on sun
1864 extern cvar_t *r_dynamiclight; // dynamic lights enabled/disabled
1865 extern cvar_t *r_dlightScale; // global user attenuation of dlights
1866 extern cvar_t *r_dlightBacks; // dlight non-facing surfaces for continuity
1867
1868 extern cvar_t *r_norefresh; // bypasses the ref rendering
1869 extern cvar_t *r_drawentities; // disable/enable entity rendering
1870 extern cvar_t *r_drawworld; // disable/enable world rendering
1871 extern cvar_t *r_speeds; // various levels of information display
1872 extern cvar_t *r_detailTextures; // enables/disables detail texturing stages
1873 extern cvar_t *r_novis; // disable/enable usage of PVS
1874 extern cvar_t *r_nocull;
1875 extern cvar_t *r_facePlaneCull; // enables culling of planar surfaces with back side test
1876 extern cvar_t *r_nocurves;
1877 extern cvar_t *r_showcluster;
1878
1879 extern cvar_t *r_mode; // video mode
1880 extern cvar_t *r_fullscreen;
1881 extern cvar_t *r_noborder;
1882 extern cvar_t *r_gamma;
1883 extern cvar_t *r_ignorehwgamma; // overrides hardware gamma capabilities
1884 extern cvar_t *r_displayRefresh; // optional display refresh option
1885
1886 extern cvar_t *r_allowExtensions; // global enable/disable of OpenGL extensions
1887 extern cvar_t *r_ext_compressed_textures; // these control use of specific extensions
1888 extern cvar_t *r_ext_multitexture;
1889 extern cvar_t *r_ext_compiled_vertex_array;
1890 extern cvar_t *r_ext_texture_env_add;
1891 extern cvar_t *r_ext_texture_filter_anisotropic;
1892 extern cvar_t *r_ext_max_anisotropy;
1893
1894 //----(SA) added
1895 extern cvar_t *r_ext_ATI_pntriangles;
1896 extern cvar_t *r_ati_truform_tess;
1897 extern cvar_t *r_ati_truform_pointmode; //----(SA)
1898 extern cvar_t *r_ati_truform_normalmode; //----(SA)
1899 extern cvar_t *r_ati_fsaa_samples; //DAJ
1900 extern cvar_t *r_ext_NV_fog_dist;
1901 extern cvar_t *r_nv_fogdist_mode;
1902 //----(SA) end
1903
1904 extern cvar_t *r_ext_framebuffer_object;
1905 extern cvar_t *r_ext_texture_float;
1906 extern cvar_t *r_ext_framebuffer_multisample;
1907 extern cvar_t *r_arb_seamless_cube_map;
1908 extern cvar_t *r_arb_vertex_array_object;
1909 extern cvar_t *r_ext_direct_state_access;
1910
1911 extern cvar_t *r_waterFogColor; //----(SA) added
1912 extern cvar_t *r_mapFogColor; //----(SA) added
1913 extern cvar_t *r_savegameFogColor; //----(SA) added
1914
1915 extern cvar_t *r_nobind; // turns off binding to appropriate textures
1916 extern cvar_t *r_singleShader; // make most world faces use default shader
1917 extern cvar_t *r_roundImagesDown;
1918 extern cvar_t *r_lowMemTextureSize;
1919 extern cvar_t *r_lowMemTextureThreshold;
1920 extern cvar_t *r_rmse; // reduces textures to this root mean square error
1921 extern cvar_t *r_colorMipLevels; // development aid to see texture mip usage
1922 extern cvar_t *r_picmip; // controls picmip values
1923 extern cvar_t *r_picmip2; // controls picmip values for designated (character skin) textures
1924 extern cvar_t *r_finish;
1925 extern cvar_t *r_drawBuffer;
1926 extern cvar_t *r_glIgnoreWicked3D;
1927 extern cvar_t *r_swapInterval;
1928 extern cvar_t *r_textureMode;
1929 extern cvar_t *r_offsetFactor;
1930 extern cvar_t *r_offsetUnits;
1931
1932 extern cvar_t *r_fullbright; // avoid lightmap pass
1933 extern cvar_t *r_lightmap; // render lightmaps only
1934 extern cvar_t *r_vertexLight; // vertex lighting mode for better performance
1935 extern cvar_t *r_uiFullScreen; // ui is running fullscreen
1936
1937 extern cvar_t *r_logFile; // number of frames to emit GL logs
1938 extern cvar_t *r_showtris; // enables wireframe rendering of the world
1939 extern cvar_t *r_showsky; // forces sky in front of all surfaces
1940 extern cvar_t *r_shownormals; // draws wireframe normals
1941 extern cvar_t *r_clear; // force screen clear every frame
1942
1943 extern cvar_t *r_shadows; // controls shadows: 0 = none, 1 = blur, 2 = stencil, 3 = black planar projection
1944 extern cvar_t *r_flares; // light flares
1945
1946 extern cvar_t *r_portalsky; // (SA) added
1947 extern cvar_t *r_intensity;
1948
1949 extern cvar_t *r_lockpvs;
1950 extern cvar_t *r_noportals;
1951 extern cvar_t *r_portalOnly;
1952
1953 extern cvar_t *r_subdivisions;
1954 extern cvar_t *r_lodCurveError;
1955 extern cvar_t *r_skipBackEnd;
1956
1957 extern cvar_t *r_stereoEnabled;
1958 extern cvar_t *r_anaglyphMode;
1959
1960 extern cvar_t *r_externalGLSL;
1961
1962 extern cvar_t *r_hdr;
1963 extern cvar_t *r_floatLightmap;
1964 extern cvar_t *r_postProcess;
1965
1966 extern cvar_t *r_toneMap;
1967 extern cvar_t *r_forceToneMap;
1968 extern cvar_t *r_forceToneMapMin;
1969 extern cvar_t *r_forceToneMapAvg;
1970 extern cvar_t *r_forceToneMapMax;
1971
1972 extern cvar_t *r_autoExposure;
1973 extern cvar_t *r_forceAutoExposure;
1974 extern cvar_t *r_forceAutoExposureMin;
1975 extern cvar_t *r_forceAutoExposureMax;
1976
1977 extern cvar_t *r_cameraExposure;
1978
1979 extern cvar_t *r_depthPrepass;
1980 extern cvar_t *r_ssao;
1981
1982 extern cvar_t *r_normalMapping;
1983 extern cvar_t *r_specularMapping;
1984 extern cvar_t *r_deluxeMapping;
1985 extern cvar_t *r_parallaxMapping;
1986 extern cvar_t *r_parallaxMapShadows;
1987 extern cvar_t *r_cubeMapping;
1988 extern cvar_t *r_cubemapSize;
1989 extern cvar_t *r_deluxeSpecular;
1990 extern cvar_t *r_pbr;
1991 extern cvar_t *r_baseNormalX;
1992 extern cvar_t *r_baseNormalY;
1993 extern cvar_t *r_baseParallax;
1994 extern cvar_t *r_baseSpecular;
1995 extern cvar_t *r_baseGloss;
1996 extern cvar_t *r_glossType;
1997 extern cvar_t *r_dlightMode;
1998 extern cvar_t *r_pshadowDist;
1999 extern cvar_t *r_mergeLightmaps;
2000 extern cvar_t *r_imageUpsample;
2001 extern cvar_t *r_imageUpsampleMaxSize;
2002 extern cvar_t *r_imageUpsampleType;
2003 extern cvar_t *r_genNormalMaps;
2004 extern cvar_t *r_forceSun;
2005 extern cvar_t *r_forceSunLightScale;
2006 extern cvar_t *r_forceSunAmbientScale;
2007 extern cvar_t *r_sunlightMode;
2008 extern cvar_t *r_drawSunRays;
2009 extern cvar_t *r_sunShadows;
2010 extern cvar_t *r_shadowFilter;
2011 extern cvar_t *r_shadowBlur;
2012 extern cvar_t *r_shadowMapSize;
2013 extern cvar_t *r_shadowCascadeZNear;
2014 extern cvar_t *r_shadowCascadeZFar;
2015 extern cvar_t *r_shadowCascadeZBias;
2016 extern cvar_t *r_ignoreDstAlpha;
2017
2018 extern cvar_t *r_greyscale;
2019
2020 extern cvar_t *r_ignoreGLErrors;
2021
2022 extern cvar_t *r_overBrightBits;
2023 extern cvar_t *r_mapOverBrightBits;
2024
2025 extern cvar_t *r_debugSurface;
2026 extern cvar_t *r_simpleMipMaps;
2027
2028 extern cvar_t *r_showImages;
2029 extern cvar_t *r_debugSort;
2030
2031 extern cvar_t *r_printShaders;
2032 extern cvar_t *r_saveFontData;
2033
2034 extern cvar_t *r_marksOnTriangleMeshes;
2035
2036 // Ridah
2037 extern cvar_t *r_bonesDebug;
2038 // done.
2039
2040 // Rafael - wolf fog
2041 extern cvar_t *r_wolffog;
2042 // done
2043
2044 extern cvar_t *r_highQualityVideo;
2045 //====================================================================
2046
2047 float R_NoiseGet4f( float x, float y, float z, double t );
2048 void R_NoiseInit( void );
2049
ShaderRequiresCPUDeforms(const shader_t * shader)2050 static ID_INLINE qboolean ShaderRequiresCPUDeforms(const shader_t * shader)
2051 {
2052 if(shader->numDeforms)
2053 {
2054 const deformStage_t *ds = &shader->deforms[0];
2055
2056 if (shader->numDeforms > 1)
2057 return qtrue;
2058
2059 switch (ds->deformation)
2060 {
2061 case DEFORM_WAVE:
2062 case DEFORM_BULGE:
2063 // need CPU deforms at high level-times to avoid floating point percision loss
2064 return ( backEnd.refdef.floatTime != (float)backEnd.refdef.floatTime );
2065
2066 default:
2067 return qtrue;
2068 }
2069 }
2070
2071 return qfalse;
2072 }
2073
2074 //====================================================================
2075
2076 void R_SwapBuffers( int );
2077
2078 void R_RenderView( viewParms_t *parms );
2079 void R_RenderDlightCubemaps(const refdef_t *fd);
2080 void R_RenderPshadowMaps(const refdef_t *fd);
2081 void R_RenderSunShadowMaps(const refdef_t *fd, int level);
2082 void R_RenderCubemapSide( int cubemapIndex, int cubemapSide, qboolean subscene );
2083
2084 void R_AddMD3Surfaces( trRefEntity_t *e );
2085 void R_AddNullModelSurfaces( trRefEntity_t *e );
2086 void R_AddBeamSurfaces( trRefEntity_t *e );
2087 void R_AddRailSurfaces( trRefEntity_t *e, qboolean isUnderwater );
2088 void R_AddLightningBoltSurfaces( trRefEntity_t *e );
2089
2090 void R_TagInfo_f( void );
2091
2092 void R_AddPolygonSurfaces( void );
2093
2094 // GR - add tessellation flag
2095 void R_DecomposeSort( unsigned sort, int *entityNum, shader_t **shader,
2096 int *fogNum, int *dlightMap, int *pshadowMap, int *atiTess );
2097
2098 // GR - add tessellation flag
2099 void R_AddDrawSurf( surfaceType_t *surface, shader_t *shader,
2100 int fogIndex, int dlightMap, int pshadowMap, int cubemap, int atiTess );
2101
2102 void R_CalcTexDirs(vec3_t sdir, vec3_t tdir, const vec3_t v1, const vec3_t v2,
2103 const vec3_t v3, const vec2_t w1, const vec2_t w2, const vec2_t w3);
2104 vec_t R_CalcTangentSpace(vec3_t tangent, vec3_t bitangent, const vec3_t normal, const vec3_t sdir, const vec3_t tdir);
2105 qboolean R_CalcTangentVectors(srfVert_t * dv[3]);
2106
2107 #define CULL_IN 0 // completely unclipped
2108 #define CULL_CLIP 1 // clipped by one or more planes
2109 #define CULL_OUT 2 // completely outside the clipping planes
2110 void R_LocalNormalToWorld (const vec3_t local, vec3_t world);
2111 void R_LocalPointToWorld (const vec3_t local, vec3_t world);
2112 int R_CullBox (vec3_t bounds[2]);
2113 int R_CullLocalBox( vec3_t bounds[2] );
2114 int R_CullPointAndRadiusEx( const vec3_t origin, float radius, const cplane_t* frustum, int numPlanes );
2115 int R_CullPointAndRadius( const vec3_t origin, float radius );
2116 int R_CullLocalPointAndRadius( const vec3_t origin, float radius );
2117
2118 void R_SetupProjection(viewParms_t *dest, float zProj, float zFar, qboolean computeFrustum);
2119 void R_RotateForEntity( const trRefEntity_t * ent, const viewParms_t * viewParms, orientationr_t * or );
2120
2121 /*
2122 ** GL wrapper/helper functions
2123 */
2124 void GL_BindToTMU( image_t *image, int tmu );
2125 void GL_SetDefaultState( void );
2126 void GL_TextureMode( const char *string );
2127 void GL_CheckErrs( char *file, int line );
2128 #define GL_CheckErrors(...) GL_CheckErrs(__FILE__, __LINE__)
2129 void GL_State( unsigned long stateVector );
2130 void GL_SetProjectionMatrix(mat4_t matrix);
2131 void GL_SetModelviewMatrix(mat4_t matrix);
2132 void GL_Cull( int cullType );
2133
2134 #define GLS_SRCBLEND_ZERO 0x00000001
2135 #define GLS_SRCBLEND_ONE 0x00000002
2136 #define GLS_SRCBLEND_DST_COLOR 0x00000003
2137 #define GLS_SRCBLEND_ONE_MINUS_DST_COLOR 0x00000004
2138 #define GLS_SRCBLEND_SRC_ALPHA 0x00000005
2139 #define GLS_SRCBLEND_ONE_MINUS_SRC_ALPHA 0x00000006
2140 #define GLS_SRCBLEND_DST_ALPHA 0x00000007
2141 #define GLS_SRCBLEND_ONE_MINUS_DST_ALPHA 0x00000008
2142 #define GLS_SRCBLEND_ALPHA_SATURATE 0x00000009
2143 #define GLS_SRCBLEND_BITS 0x0000000f
2144
2145 #define GLS_DSTBLEND_ZERO 0x00000010
2146 #define GLS_DSTBLEND_ONE 0x00000020
2147 #define GLS_DSTBLEND_SRC_COLOR 0x00000030
2148 #define GLS_DSTBLEND_ONE_MINUS_SRC_COLOR 0x00000040
2149 #define GLS_DSTBLEND_SRC_ALPHA 0x00000050
2150 #define GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA 0x00000060
2151 #define GLS_DSTBLEND_DST_ALPHA 0x00000070
2152 #define GLS_DSTBLEND_ONE_MINUS_DST_ALPHA 0x00000080
2153 #define GLS_DSTBLEND_BITS 0x000000f0
2154
2155 #define GLS_DEPTHMASK_TRUE 0x00000100
2156
2157 #define GLS_POLYMODE_LINE 0x00001000
2158
2159 #define GLS_DEPTHTEST_DISABLE 0x00010000
2160 #define GLS_DEPTHFUNC_EQUAL 0x00020000
2161 #define GLS_DEPTHFUNC_GREATER 0x00040000
2162 #define GLS_DEPTHFUNC_BITS 0x00060000
2163
2164 #define GLS_ATEST_GT_0 0x10000000
2165 #define GLS_ATEST_LT_80 0x20000000
2166 #define GLS_ATEST_GE_80 0x40000000
2167 #define GLS_ATEST_BITS 0x70000000
2168
2169 #define GLS_DEFAULT GLS_DEPTHMASK_TRUE
2170
2171 void RE_StretchRaw( int x, int y, int w, int h, int cols, int rows, const byte *data, int client, qboolean dirty );
2172 void RE_UploadCinematic( int w, int h, int cols, int rows, const byte *data, int client, qboolean dirty );
2173
2174 void RE_BeginFrame( stereoFrame_t stereoFrame );
2175 void RE_BeginRegistration( glconfig_t *glconfig );
2176 void RE_LoadWorldMap( const char *mapname );
2177 void RE_SetWorldVisData( const byte *vis );
2178 qhandle_t RE_RegisterModel( const char *name );
2179 qhandle_t RE_RegisterSkin( const char *name );
2180 void RE_Shutdown( qboolean destroyWindow );
2181
2182 qboolean R_GetEntityToken( char *buffer, int size );
2183
2184 //----(SA)
2185 qboolean RE_GetSkinModel( qhandle_t skinid, const char *type, char *name );
2186 qhandle_t RE_GetShaderFromModel( qhandle_t modelid, int surfnum, int withlightmap ); //----(SA)
2187 //----(SA) end
2188
2189 model_t *R_AllocModel( void );
2190
2191 void R_Init( void );
2192 image_t *R_FindImageFile( const char *name, imgType_t type, imgFlags_t flags );
2193 image_t *R_FindImageFileExt( const char *name, imgType_t type, imgFlags_t flags, qboolean characterMip ); //----(SA) added
2194
2195 image_t *R_CreateImage( const char *name, byte *pic, int width, int height, imgType_t type, imgFlags_t flags, int internalFormat );
2196 //----(SA) added (didn't want to modify all instances of R_CreateImage()
2197 image_t *R_CreateImageExt( const char *name, byte *pic, int width, int height, imgType_t type, imgFlags_t flags, int internalFormat, qboolean characterMip );
2198 //----(SA) end
2199 void R_UpdateSubImage( image_t *image, byte *pic, int x, int y, int width, int height, GLenum picFormat );
2200 qboolean R_GetModeInfo( int *width, int *height, float *windowAspect, int mode );
2201
2202 void R_SetColorMappings( void );
2203 void R_GammaCorrect( byte *buffer, int bufSize );
2204
2205 void R_ImageList_f( void );
2206 void R_SkinList_f( void );
2207 // https://zerowing.idsoftware.com/bugzilla/show_bug.cgi?id=516
2208 const void *RB_TakeScreenshotCmd( const void *data );
2209 void R_ScreenShot_f( void );
2210 void R_ScreenShotJPEG_f( void );
2211
2212 void R_InitFogTable( void );
2213 float R_FogFactor( float s, float t );
2214 void R_InitImages( void );
2215 void R_DeleteTextures( void );
2216 int R_SumOfUsedImages( void );
2217 void R_InitSkins( void );
2218 skin_t *R_GetSkinByHandle( qhandle_t hSkin );
2219
2220 int R_ComputeLOD( trRefEntity_t *ent );
2221
2222 const void *RB_TakeVideoFrameCmd( const void *data );
2223
2224
2225 //
2226 // tr_shader.c
2227 //
2228 qhandle_t RE_RegisterShaderLightMap( const char *name, int lightmapIndex );
2229 qhandle_t RE_RegisterShader( const char *name );
2230 qhandle_t RE_RegisterShaderNoMip( const char *name );
2231 qhandle_t RE_RegisterShaderFromImage( const char *name, int lightmapIndex, image_t *image, qboolean mipRawImage );
2232
2233 shader_t *R_FindShader( const char *name, int lightmapIndex, qboolean mipRawImage );
2234 shader_t *R_GetShaderByHandle( qhandle_t hShader );
2235 shader_t *R_GetShaderByState( int index, long *cycleTime );
2236 shader_t *R_FindShaderByName( const char *name );
2237 void R_InitShaders( void );
2238 void R_ShaderList_f( void );
2239 void R_RemapShader( const char *oldShader, const char *newShader, const char *timeOffset );
2240
2241 /*
2242 ====================================================================
2243
2244 IMPLEMENTATION SPECIFIC FUNCTIONS
2245
2246 ====================================================================
2247 */
2248
2249 void GLimp_Init( qboolean fixedFunction );
2250 void GLimp_Shutdown( void );
2251 void GLimp_EndFrame( void );
2252
2253 void GLimp_LogComment( char *comment );
2254 void GLimp_Minimize(void);
2255
2256 void GLimp_SetGamma( unsigned char red[256],
2257 unsigned char green[256],
2258 unsigned char blue[256] );
2259
2260 void GLimp_InitExtraExtensions( void );
2261
2262 /*
2263 ====================================================================
2264
2265 TESSELATOR/SHADER DECLARATIONS
2266
2267 ====================================================================
2268 */
2269
2270 typedef struct stageVars
2271 {
2272 color4ub_t colors[SHADER_MAX_VERTEXES];
2273 vec2_t texcoords[NUM_TEXTURE_BUNDLES][SHADER_MAX_VERTEXES];
2274 } stageVars_t;
2275
2276 typedef struct shaderCommands_s
2277 {
2278 glIndex_t indexes[SHADER_MAX_INDEXES] QALIGN(16);
2279 vec4_t xyz[SHADER_MAX_VERTEXES] QALIGN(16);
2280 int16_t normal[SHADER_MAX_VERTEXES][4] QALIGN(16);
2281 int16_t tangent[SHADER_MAX_VERTEXES][4] QALIGN(16);
2282 vec2_t texCoords[SHADER_MAX_VERTEXES] QALIGN(16);
2283 vec2_t lightCoords[SHADER_MAX_VERTEXES] QALIGN(16);
2284 uint16_t color[SHADER_MAX_VERTEXES][4] QALIGN(16);
2285 int16_t lightdir[SHADER_MAX_VERTEXES][4] QALIGN(16);
2286 //int vertexDlightBits[SHADER_MAX_VERTEXES] QALIGN(16);
2287
2288 void *attribPointers[ATTR_INDEX_COUNT];
2289 vao_t *vao;
2290 qboolean useInternalVao;
2291 qboolean useCacheVao;
2292
2293 stageVars_t svars QALIGN(16);
2294
2295 //color4ub_t constantColor255[SHADER_MAX_VERTEXES] QALIGN(16);
2296
2297 shader_t *shader;
2298 double shaderTime;
2299 int fogNum;
2300 int cubemapIndex;
2301
2302 int dlightBits; // or together of all vertexDlightBits
2303 int pshadowBits;
2304
2305 int firstIndex;
2306
2307 int numIndexes;
2308 int numVertexes;
2309
2310 qboolean ATI_tess;
2311
2312 // info extracted from current shader
2313 int numPasses;
2314 void ( *currentStageIteratorFunc )( void );
2315 shaderStage_t **xstages;
2316 } shaderCommands_t;
2317
2318 extern shaderCommands_t tess;
2319
2320 void RB_BeginSurface( shader_t *shader, int fogNum, int cubemapIndex );
2321 void RB_EndSurface( void );
2322 void RB_CheckOverflow( int verts, int indexes );
2323 #define RB_CHECKOVERFLOW( v,i ) if ( tess.numVertexes + ( v ) >= SHADER_MAX_VERTEXES || tess.numIndexes + ( i ) >= SHADER_MAX_INDEXES ) {RB_CheckOverflow( v,i );}
2324
2325 void R_DrawElements( int numIndexes, int firstIndex );
2326 void RB_StageIteratorGeneric( void );
2327 void RB_StageIteratorSky( void );
2328 void RB_StageIteratorVertexLitTexture( void );
2329 void RB_StageIteratorLightmappedMultitexture( void );
2330
2331 void RB_AddQuadStamp( vec3_t origin, vec3_t left, vec3_t up, float color[4] );
2332 void RB_AddQuadStampExt( vec3_t origin, vec3_t left, vec3_t up, float color[4], float s1, float t1, float s2, float t2 );
2333 void RB_InstantQuad( vec4_t quadVerts[4] );
2334 //void RB_InstantQuad2(vec4_t quadVerts[4], vec2_t texCoords[4], vec4_t color, shaderProgram_t *sp, vec2_t invTexRes);
2335 void RB_InstantQuad2(vec4_t quadVerts[4], vec2_t texCoords[4]);
2336
2337 void RB_ShowImages( void );
2338
2339
2340 /*
2341 ============================================================
2342
2343 WORLD MAP
2344
2345 ============================================================
2346 */
2347
2348 void R_AddBrushModelSurfaces( trRefEntity_t *e );
2349 void R_AddWorldSurfaces( void );
2350
2351
2352 /*
2353 ============================================================
2354
2355 FLARES
2356
2357 ============================================================
2358 */
2359
2360 void R_ClearFlares( void );
2361
2362 void RB_AddFlare( void *surface, int fogNum, vec3_t point, vec3_t color, float scale, vec3_t normal, int id, int flags ); // TTimo updated prototype
2363 void RB_AddDlightFlares( void );
2364 void RB_RenderFlares( void );
2365
2366 /*
2367 ============================================================
2368
2369 LIGHTS
2370
2371 ============================================================
2372 */
2373
2374 void R_DlightBmodel( bmodel_t *bmodel );
2375 void R_SetupEntityLighting( const trRefdef_t *refdef, trRefEntity_t *ent );
2376 void R_TransformDlights( int count, dlight_t * dl, orientationr_t * or );
2377 int R_LightForPoint( vec3_t point, vec3_t ambientLight, vec3_t directedLight, vec3_t lightDir );
2378 int R_LightDirForPoint( vec3_t point, vec3_t lightDir, vec3_t normal, world_t *world );
2379 int R_CubemapForPoint( vec3_t point );
2380
2381
2382 /*
2383 ============================================================
2384
2385 SHADOWS
2386
2387 ============================================================
2388 */
2389
2390 void RB_ShadowTessEnd( void );
2391 void RB_ShadowFinish( void );
2392 void RB_ProjectionShadowDeform( void );
2393
2394 /*
2395 ============================================================
2396
2397 SKIES
2398
2399 ============================================================
2400 */
2401
2402 void R_BuildCloudData( shaderCommands_t *shader );
2403 void R_InitSkyTexCoords( float cloudLayerHeight );
2404 void R_DrawSkyBox( shaderCommands_t *shader );
2405 void RB_DrawSun( float scale, shader_t *shader );
2406 void RB_ClipSkyPolygons( shaderCommands_t *shader );
2407
2408 /*
2409 ============================================================
2410
2411 CURVE TESSELATION
2412
2413 ============================================================
2414 */
2415
2416 #define PATCH_STITCHING
2417
2418 void R_SubdividePatchToGrid( srfBspSurface_t *grid, int width, int height,
2419 srfVert_t points[MAX_PATCH_SIZE*MAX_PATCH_SIZE] );
2420 void R_GridInsertColumn( srfBspSurface_t *grid, int column, int row, vec3_t point, float loderror );
2421 void R_GridInsertRow( srfBspSurface_t *grid, int row, int column, vec3_t point, float loderror );
2422
2423 /*
2424 ============================================================
2425
2426 MARKERS, POLYGON PROJECTION ON WORLD POLYGONS
2427
2428 ============================================================
2429 */
2430
2431 int R_MarkFragments( int orientation, const vec3_t *points, const vec3_t projection,
2432 int maxPoints, vec3_t pointBuffer, int maxFragments, markFragment_t *fragmentBuffer );
2433
2434 /*
2435 ============================================================
2436
2437 VERTEX BUFFER OBJECTS
2438
2439 ============================================================
2440 */
2441
2442 void R_VaoPackTangent(int16_t *out, vec4_t v);
2443 void R_VaoPackNormal(int16_t *out, vec3_t v);
2444 void R_VaoPackColor(uint16_t *out, vec4_t c);
2445 void R_VaoUnpackTangent(vec4_t v, int16_t *pack);
2446 void R_VaoUnpackNormal(vec3_t v, int16_t *pack);
2447
2448 vao_t *R_CreateVao(const char *name, byte *vertexes, int vertexesSize, byte *indexes, int indexesSize, vaoUsage_t usage);
2449 vao_t *R_CreateVao2(const char *name, int numVertexes, srfVert_t *verts, int numIndexes, glIndex_t *inIndexes);
2450
2451 void R_BindVao(vao_t *vao);
2452 void R_BindNullVao(void);
2453
2454 void Vao_SetVertexPointers(vao_t *vao);
2455
2456 void R_InitVaos(void);
2457 void R_ShutdownVaos(void);
2458 void R_VaoList_f(void);
2459
2460 void RB_UpdateTessVao(unsigned int attribBits);
2461
2462 void VaoCache_Commit(void);
2463 void VaoCache_Init(void);
2464 void VaoCache_BindVao(void);
2465 void VaoCache_CheckAdd(qboolean *endSurface, qboolean *recycleVertexBuffer, qboolean *recycleIndexBuffer, int numVerts, int numIndexes);
2466 void VaoCache_RecycleVertexBuffer(void);
2467 void VaoCache_RecycleIndexBuffer(void);
2468 void VaoCache_InitQueue(void);
2469 void VaoCache_AddSurface(srfVert_t *verts, int numVerts, glIndex_t *indexes, int numIndexes);
2470
2471 /*
2472 ============================================================
2473
2474 GLSL
2475
2476 ============================================================
2477 */
2478
2479 void GLSL_InitGPUShaders(void);
2480 void GLSL_ShutdownGPUShaders(void);
2481 void GLSL_VertexAttribPointers(uint32_t attribBits);
2482 void GLSL_BindProgram(shaderProgram_t * program);
2483
2484 void GLSL_SetUniformInt(shaderProgram_t *program, int uniformNum, GLint value);
2485 void GLSL_SetUniformFloat(shaderProgram_t *program, int uniformNum, GLfloat value);
2486 void GLSL_SetUniformFloat5(shaderProgram_t *program, int uniformNum, const vec5_t v);
2487 void GLSL_SetUniformVec2(shaderProgram_t *program, int uniformNum, const vec2_t v);
2488 void GLSL_SetUniformVec3(shaderProgram_t *program, int uniformNum, const vec3_t v);
2489 void GLSL_SetUniformVec4(shaderProgram_t *program, int uniformNum, const vec4_t v);
2490 void GLSL_SetUniformMat4(shaderProgram_t *program, int uniformNum, const mat4_t matrix);
2491 void GLSL_SetUniformMat4BoneMatrix(shaderProgram_t *program, int uniformNum, /*const*/ mat4_t *matrix, int numMatricies);
2492
2493 shaderProgram_t *GLSL_GetGenericShaderProgram(int stage, glfog_t *glFog);
2494
2495 /*
2496 ============================================================
2497
2498 SCENE GENERATION
2499
2500 ============================================================
2501 */
2502
2503 void R_InitNextFrame( void );
2504
2505 void RE_ClearScene( void );
2506 void RE_AddRefEntityToScene( const refEntity_t *ent );
2507 void RE_AddPolyToScene( qhandle_t hShader, int numVerts, const polyVert_t *verts );
2508 // Ridah
2509 void RE_AddPolysToScene( qhandle_t hShader, int numVerts, const polyVert_t *verts, int numPolys );
2510 // done.
2511 // Ridah
2512 void RE_AddLightToScene( const vec3_t org, float intensity, float r, float g, float b, int overdraw );
2513 // done.
2514 //----(SA)
2515 void RE_AddCoronaToScene( const vec3_t org, float r, float g, float b, float scale, int id, int flags );
2516 //----(SA)
2517 void RE_BeginScene( const refdef_t *fd );
2518 void RE_RenderScene( const refdef_t *fd );
2519 void RE_EndScene( void );
2520
2521 /*
2522 =============================================================
2523
2524 UNCOMPRESSING BONES
2525
2526 =============================================================
2527 */
2528
2529 #define MC_BITS_X (16)
2530 #define MC_BITS_Y (16)
2531 #define MC_BITS_Z (16)
2532 #define MC_BITS_VECT (16)
2533
2534 #define MC_SCALE_X (1.0f/64)
2535 #define MC_SCALE_Y (1.0f/64)
2536 #define MC_SCALE_Z (1.0f/64)
2537
2538 void MC_UnCompress(float mat[3][4],const unsigned char * comp);
2539
2540 /*
2541 =============================================================
2542
2543 ANIMATED MODELS
2544
2545 =============================================================
2546 */
2547
2548 void R_AddAnimSurfaces( trRefEntity_t *ent );
2549 void RB_SurfaceAnim( mdsSurface_t *surfType );
2550 int R_GetBoneTag( orientation_t *outTag, mdsHeader_t *mds, int startTagIndex, const refEntity_t *refent, const char *tagName );
2551 void R_MDRAddAnimSurfaces( trRefEntity_t *ent );
2552 void RB_MDRSurfaceAnim( mdrSurface_t *surface );
2553 qboolean R_LoadIQM (model_t *mod, void *buffer, int filesize, const char *name );
2554 void R_AddIQMSurfaces( trRefEntity_t *ent );
2555 void RB_IQMSurfaceAnim( surfaceType_t *surface );
2556 void RB_IQMSurfaceAnimVao( srfVaoIQModel_t *surface );
2557 int R_IQMLerpTag( orientation_t *tag, iqmData_t *data,
2558 int startFrame, int endFrame,
2559 float frac, const char *tagName, int startIndex );
2560
2561 /*
2562 =============================================================
2563
2564 IMAGE LOADERS
2565
2566 =============================================================
2567 */
2568
2569 void R_LoadBMP( const char *name, byte **pic, int *width, int *height );
2570 void R_LoadJPG( const char *name, byte **pic, int *width, int *height );
2571 void R_LoadPCX( const char *name, byte **pic, int *width, int *height );
2572 void R_LoadPNG( const char *name, byte **pic, int *width, int *height );
2573 void R_LoadTGA( const char *name, byte **pic, int *width, int *height );
2574
2575 /*
2576 =============================================================
2577 =============================================================
2578 */
2579 void R_TransformModelToClip( const vec3_t src, const float *modelMatrix, const float *projectionMatrix,
2580 vec4_t eye, vec4_t dst );
2581 void R_TransformClipToWindow( const vec4_t clip, const viewParms_t *view, vec4_t normalized, vec4_t window );
2582
2583 void RB_DeformTessGeometry( void );
2584
2585 void RB_CalcFireRiseEnvTexCoords( float *st );
2586 void RB_CalcFogTexCoords( float *dstTexCoords );
2587 void RB_CalcSwapTexCoords( float *dstTexCoords );
2588
2589 void RB_CalcScaleTexMatrix( const float scale[2], float *matrix );
2590 void RB_CalcScrollTexMatrix( const float scrollSpeed[2], float *matrix );
2591 void RB_CalcRotateTexMatrix( float degsPerSecond, float *matrix );
2592 void RB_CalcTurbulentFactors( const waveForm_t *wf, float *amplitude, float *now );
2593 void RB_CalcTransformTexMatrix( const texModInfo_t *tmi, float *matrix );
2594 void RB_CalcStretchTexMatrix( const waveForm_t *wf, float *matrix );
2595
2596 void RB_CalcModulateColorsByFog( unsigned char *dstColors );
2597 float RB_CalcWaveAlphaSingle( const waveForm_t *wf );
2598 float RB_CalcWaveColorSingle( const waveForm_t *wf );
2599
2600 void RB_ZombieFXInit( void );
2601 void RB_ZombieFXAddNewHit( int entityNum, const vec3_t hitPos, const vec3_t hitDir );
2602
2603
2604 /*
2605 =============================================================
2606
2607 RENDERER BACK END FUNCTIONS
2608
2609 =============================================================
2610 */
2611
2612 void RB_ExecuteRenderCommands( const void *data );
2613
2614 /*
2615 =============================================================
2616
2617 RENDERER BACK END COMMAND QUEUE
2618
2619 =============================================================
2620 */
2621
2622 #define MAX_RENDER_COMMANDS 0x40000
2623
2624 typedef struct {
2625 byte cmds[MAX_RENDER_COMMANDS];
2626 int used;
2627 } renderCommandList_t;
2628
2629 typedef struct {
2630 int commandId;
2631 float color[4];
2632 } setColorCommand_t;
2633
2634 typedef struct {
2635 int commandId;
2636 int buffer;
2637 } drawBufferCommand_t;
2638
2639 typedef struct {
2640 int commandId;
2641 image_t *image;
2642 int width;
2643 int height;
2644 void *data;
2645 } subImageCommand_t;
2646
2647 typedef struct {
2648 int commandId;
2649 } swapBuffersCommand_t;
2650
2651 typedef struct {
2652 int commandId;
2653 int buffer;
2654 } endFrameCommand_t;
2655
2656 typedef struct {
2657 int commandId;
2658 shader_t *shader;
2659 float x, y;
2660 float w, h;
2661 float s1, t1;
2662 float s2, t2;
2663
2664 byte gradientColor[4]; // color values 0-255
2665 int gradientType; //----(SA) added
2666 float angle; // NERVE - SMF
2667 } stretchPicCommand_t;
2668
2669 typedef struct {
2670 int commandId;
2671 trRefdef_t refdef;
2672 viewParms_t viewParms;
2673 drawSurf_t *drawSurfs;
2674 int numDrawSurfs;
2675 } drawSurfsCommand_t;
2676
2677 typedef struct {
2678 int commandId;
2679 int x;
2680 int y;
2681 int width;
2682 int height;
2683 char *fileName;
2684 qboolean jpeg;
2685 } screenshotCommand_t;
2686
2687 typedef struct {
2688 int commandId;
2689 int width;
2690 int height;
2691 byte *captureBuffer;
2692 byte *encodeBuffer;
2693 qboolean motionJpeg;
2694 } videoFrameCommand_t;
2695
2696 typedef struct
2697 {
2698 int commandId;
2699
2700 GLboolean rgba[4];
2701 } colorMaskCommand_t;
2702
2703 typedef struct
2704 {
2705 int commandId;
2706 } clearDepthCommand_t;
2707
2708 typedef struct {
2709 int commandId;
2710 int map;
2711 int cubeSide;
2712 } capShadowmapCommand_t;
2713
2714 typedef struct {
2715 int commandId;
2716 trRefdef_t refdef;
2717 viewParms_t viewParms;
2718 } postProcessCommand_t;
2719
2720 typedef struct {
2721 int commandId;
2722 } exportCubemapsCommand_t;
2723
2724 typedef enum {
2725 RC_END_OF_LIST,
2726 RC_SET_COLOR,
2727 RC_STRETCH_PIC,
2728 RC_STRETCH_PIC_GRADIENT, // (SA) added
2729 RC_DRAW_SURFS,
2730 RC_DRAW_BUFFER,
2731 RC_SWAP_BUFFERS,
2732 RC_SCREENSHOT,
2733 RC_VIDEOFRAME,
2734 RC_COLORMASK,
2735 RC_CLEARDEPTH,
2736 RC_CAPSHADOWMAP,
2737 RC_POSTPROCESS,
2738 RC_EXPORT_CUBEMAPS
2739 } renderCommand_t;
2740
2741
2742 // these are sort of arbitrary limits.
2743 // the limits apply to the sum of all scenes in a frame --
2744 // the main view, all the 3D icons, etc
2745
2746 // Ridah, these aren't enough for cool effects
2747 //#define MAX_POLYS 256
2748 //#define MAX_POLYVERTS 1024
2749 #define MAX_POLYS 4096
2750 #define MAX_POLYVERTS 8192
2751 // done.
2752
2753 // all of the information needed by the back end must be
2754 // contained in a backEndData_t
2755 typedef struct {
2756 drawSurf_t drawSurfs[MAX_DRAWSURFS];
2757 dlight_t dlights[MAX_DLIGHTS];
2758 corona_t coronas[MAX_CORONAS]; //----(SA)
2759 trRefEntity_t entities[MAX_REFENTITIES];
2760 srfPoly_t *polys;//[MAX_POLYS];
2761 polyVert_t *polyVerts;//[MAX_POLYVERTS];
2762 pshadow_t pshadows[MAX_CALC_PSHADOWS];
2763 renderCommandList_t commands;
2764 } backEndData_t;
2765
2766 extern int max_polys;
2767 extern int max_polyverts;
2768
2769 extern backEndData_t *backEndData; // the second one may not be allocated
2770
2771 void *R_GetCommandBuffer( int bytes );
2772 void RB_ExecuteRenderCommands( const void *data );
2773
2774 void R_IssuePendingRenderCommands( void );
2775
2776 void R_AddDrawSurfCmd( drawSurf_t *drawSurfs, int numDrawSurfs );
2777 void R_AddCapShadowmapCmd( int dlight, int cubeSide );
2778 void R_AddPostProcessCmd (void);
2779
2780 void RE_SetColor( const float *rgba );
2781 void RE_StretchPic( float x, float y, float w, float h,
2782 float s1, float t1, float s2, float t2, qhandle_t hShader );
2783 void RE_StretchPicGradient( float x, float y, float w, float h,
2784 float s1, float t1, float s2, float t2, qhandle_t hShader, const float *gradientColor, int gradientType );
2785 void RE_BeginFrame( stereoFrame_t stereoFrame );
2786 void RE_EndFrame( int *frontEndMsec, int *backEndMsec );
2787 void RE_SaveJPG(char * filename, int quality, int image_width, int image_height,
2788 unsigned char *image_buffer, int padding);
2789 size_t RE_SaveJPGToBuffer(byte *buffer, size_t bufSize, int quality,
2790 int image_width, int image_height, byte *image_buffer, int padding);
2791 void RE_TakeVideoFrame( int width, int height,
2792 byte *captureBuffer, byte *encodeBuffer, qboolean motionJpeg );
2793
2794 // font stuff
2795 void R_InitFreeType( void );
2796 void R_DoneFreeType( void );
2797 void RE_RegisterFont( const char *fontName, int pointSize, fontInfo_t *font );
2798
2799
2800 //------------------------------------------------------------------------------
2801 // Ridah, mesh compression
2802 #define NUMMDCVERTEXNORMALS 256
2803
2804 extern float r_anormals[NUMMDCVERTEXNORMALS][3];
2805
2806 // NOTE: MDC_MAX_ERROR is effectively the compression level. the lower this value, the higher
2807 // the accuracy, but with lower compression ratios.
2808 #define MDC_MAX_ERROR 0.1 // if any compressed vert is off by more than this from the
2809 // actual vert, make this a baseframe
2810
2811 #define MDC_DIST_SCALE 0.05 // lower for more accuracy, but less range
2812
2813 // note: we are locked in at 8 or less bits since changing to byte-encoded normals
2814 #define MDC_BITS_PER_AXIS 8
2815 #define MDC_MAX_OFS 127.0 // to be safe
2816
2817 #define MDC_MAX_DIST ( MDC_MAX_OFS * MDC_DIST_SCALE )
2818
2819 #if 0
2820 void R_MDC_DecodeXyzCompressed( mdcXyzCompressed_t *xyzComp, vec3_t out, vec3_t normal );
2821 #else // optimized version
2822 #define R_MDC_DecodeXyzCompressed( ofsVec, out, normal ) \
2823 ( out )[0] = ( (float)( ( ofsVec ) & 255 ) - MDC_MAX_OFS ) * MDC_DIST_SCALE; \
2824 ( out )[1] = ( (float)( ( ofsVec >> 8 ) & 255 ) - MDC_MAX_OFS ) * MDC_DIST_SCALE; \
2825 ( out )[2] = ( (float)( ( ofsVec >> 16 ) & 255 ) - MDC_MAX_OFS ) * MDC_DIST_SCALE; \
2826 VectorCopy( ( r_anormals )[( ofsVec >> 24 )], normal );
2827 #endif
2828
2829 void R_AddMDCSurfaces( trRefEntity_t *ent );
2830 // done.
2831 //------------------------------------------------------------------------------
2832
2833
2834 /*
2835 ============================================================
2836
2837 GL FOG
2838
2839 ============================================================
2840 */
2841
2842 //extern glfog_t glfogCurrent;
2843 extern glfog_t glfogsettings[NUM_FOGS]; // [0] never used (FOG_NONE)
2844 extern glfogType_t glfogNum; // fog type to use (from the fog_t enum list)
2845
2846 extern void R_SetFog( int fogvar, int var1, int var2, float r, float g, float b, float density );
2847
2848 extern int skyboxportal;
2849 extern int drawskyboxportal;
2850
2851 // Ridah, virtual memory
2852 void *R_Hunk_Begin( void );
2853 void R_Hunk_End( void );
2854
2855 #endif //TR_LOCAL_H (THIS MUST BE LAST!!)
2856