1 /* 2 =========================================================================== 3 Copyright (C) 1999-2005 Id Software, Inc. 4 Copyright (C) 2006 Robert Beckebans <trebor_7@users.sourceforge.net> 5 6 This file is part of XreaL source code. 7 8 XreaL source code is free software; you can redistribute it 9 and/or modify it under the terms of the GNU General Public License as 10 published by the Free Software Foundation; either version 2 of the License, 11 or (at your option) any later version. 12 13 XreaL source code is distributed in the hope that it will be 14 useful, but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with XreaL source code; if not, write to the Free Software 20 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 21 =========================================================================== 22 */ 23 24 #ifndef TR_LOCAL_H 25 #define TR_LOCAL_H 26 27 #include "../qcommon/q_shared.h" 28 #include "../qcommon/qfiles.h" 29 #include "../qcommon/qcommon.h" 30 #include "tr_public.h" 31 #include "qgl.h" 32 33 #define GL_INDEX_TYPE GL_UNSIGNED_INT 34 typedef unsigned int glIndex_t; 35 36 #define BUFFER_OFFSET(i) ((char *)NULL + (i)) 37 38 // fast float to int conversion 39 #if id386 && !( (defined __linux__ || defined __FreeBSD__ ) && (defined __i386__ ) ) // rb010123 40 long myftol(float f); 41 #else 42 #define myftol(x) ((int)(x)) 43 #endif 44 45 // everything that is needed by the backend needs 46 // to be double buffered to allow it to run in 47 // parallel on a dual cpu machine 48 #define SMP_FRAMES 2 49 50 #define MAX_SHADERS (1 << 12) 51 #define SHADERS_MASK (MAX_SHADERS -1) 52 53 #define MAX_SHADER_TABLES 1024 54 #define MAX_SHADER_STAGES 16 55 56 //#define MAX_SHADER_STATES 2048 57 #define MAX_STATES_PER_SHADER 32 58 #define MAX_STATE_NAME 32 59 60 #define MAX_OCCLUSION_QUERIES 128 61 62 #define MAX_FBOS 64 63 64 // can't be increased without changing bit packing for drawsurfs 65 66 typedef enum 67 { 68 CULL_IN, // completely unclipped 69 CULL_CLIP, // clipped by one or more planes 70 CULL_OUT, // completely outside the clipping planes 71 } cullResult_t; 72 73 typedef struct screenRect_s 74 { 75 int coords[4]; 76 struct screenRect_s *next; 77 } screenRect_t; 78 79 typedef enum 80 { 81 FRUSTUM_NEAR, 82 FRUSTUM_LEFT, 83 FRUSTUM_RIGHT, 84 FRUSTUM_BOTTOM, 85 FRUSTUM_TOP, 86 FRUSTUM_FAR, 87 FRUSTUM_PLANES = 5, 88 FRUSTUM_CLIPALL = 1 | 2 | 4 | 8 | 16 //| 32 89 } frustumBits_t; 90 91 typedef cplane_t frustum_t[6]; 92 93 94 // a trRefDlight_t has all the information passed in by 95 // the client game, as well as some locally derived info 96 typedef struct trRefDlight_s 97 { 98 // public from client game 99 refLight_t l; 100 101 // local 102 qboolean isStatic; // loaded from the BSP entities lump 103 qboolean additive; // texture detail is lost tho when the lightmap is dark 104 vec3_t origin; // l.origin + rotated l.center 105 vec3_t transformed; // origin in local coordinate system 106 matrix_t transformMatrix; // light to world 107 matrix_t viewMatrix; // object to light 108 matrix_t projectionMatrix; // light frustum 109 110 matrix_t attenuationMatrix; // attenuation * (light view * entity transform) 111 matrix_t attenuationMatrix2; // attenuation * tcMod matrices 112 113 cullResult_t cull; 114 vec3_t localBounds[2]; 115 vec3_t worldBounds[2]; 116 117 float depthBounds[2]; // zNear, zFar for GL_EXT_depth_bounds_test 118 qboolean noDepthBoundsTest; 119 120 frustum_t frustum; 121 122 screenRect_t scissor; 123 124 struct interactionCache_s *firstInteractionCache; // only used by static lights 125 struct interactionCache_s *lastInteractionCache; // only used by static lights 126 127 int numInteractions; // total interactions 128 int numShadowOnlyInteractions; 129 int numLightOnlyInteractions; 130 int firstInteractionIndex; 131 int lastInteractionIndex; 132 qboolean noSort; // don't sort interactions by material 133 134 int visCount; // node needs to be traversed if current 135 struct mnode_s **leafs; 136 int numLeafs; 137 } trRefDlight_t; 138 139 140 // a trRefEntity_t has all the information passed in by 141 // the client game, as well as some locally derived info 142 typedef struct 143 { 144 // public from client game 145 refEntity_t e; 146 147 // local 148 float axisLength; // compensate for non-normalized axis 149 qboolean lightingCalculated; 150 vec3_t lightDir; // normalized direction towards light 151 vec3_t ambientLight; // color normalized to 0-255 152 int ambientLightInt; // 32 bit rgba packed 153 vec3_t directedLight; 154 qboolean needZFail; 155 156 cullResult_t cull; 157 vec3_t localBounds[2]; 158 vec3_t worldBounds[2]; // only set when not completely culled. use them for light interactions 159 } trRefEntity_t; 160 161 typedef struct 162 { 163 vec3_t origin; // in world coordinates 164 vec3_t axis[3]; // orientation in world 165 vec3_t viewOrigin; // viewParms->or.origin in local coordinates 166 matrix_t transformMatrix; // transforms object to world: either used by camera, model or light 167 matrix_t viewMatrix; // affine inverse of transform matrix to transform other objects into this space 168 matrix_t modelViewMatrix; // only used by models, camera viewMatrix * transformMatrix 169 } orientationr_t; 170 171 enum 172 { 173 IF_NONE, 174 IF_INTERNAL = (1 << 0), 175 IF_NOPICMIP = (1 << 1), 176 IF_NOCOMPRESSION = (1 << 2), 177 IF_INTENSITY = (1 << 3), 178 IF_ALPHA = (1 << 4), 179 IF_NORMALMAP = (1 << 5), 180 IF_LIGHTMAP = (1 << 6), 181 IF_CUBEMAP = (1 << 7) 182 }; 183 184 typedef enum 185 { 186 FT_DEFAULT, 187 FT_LINEAR, 188 FT_NEAREST 189 } filterType_t; 190 191 typedef enum 192 { 193 WT_REPEAT, 194 WT_CLAMP, // don't repeat the texture for texture coords outside [0, 1] 195 WT_EDGE_CLAMP, 196 WT_ZERO_CLAMP, // guarantee 0,0,0,255 edge for projected textures 197 WT_ALPHA_ZERO_CLAMP // guarante 0 alpha edge for projected textures 198 } wrapType_t; 199 200 typedef struct image_s 201 { 202 char name[1024]; // formerly MAX_QPATH, game path, including extension 203 // can contain stuff like this now: 204 // addnormals ( textures/base_floor/stetile4_local.tga , 205 // heightmap ( textures/base_floor/stetile4_bmp.tga , 4 ) ) 206 GLenum type; 207 int width, height; // source image 208 int uploadWidth, uploadHeight; // after power of two and picmip but not including clamp to MAX_TEXTURE_SIZE 209 GLuint texnum; // gl texture binding 210 211 int frameUsed; // for texture usage in frame statistics 212 213 int internalFormat; 214 215 unsigned bits; 216 filterType_t filterType; 217 wrapType_t wrapType; // GL_CLAMP or GL_REPEAT 218 219 struct image_s *next; 220 } image_t; 221 222 typedef struct frameBuffer_s 223 { 224 char name[MAX_QPATH]; 225 226 int index; 227 228 GLuint frameBuffer; 229 230 GLuint colorBuffers[16]; 231 int colorFormat; 232 233 GLuint depthBuffer; 234 int depthFormat; 235 236 GLuint stencilBuffer; 237 int stencilFormat; 238 239 int width; 240 int height; 241 242 // struct frameBuffer_s *next; 243 } frameBuffer_t; 244 245 //=============================================================================== 246 247 typedef enum 248 { 249 SS_BAD, 250 SS_PORTAL, // mirrors, portals, viewscreens 251 SS_ENVIRONMENT, // sky box 252 SS_OPAQUE, // opaque 253 254 SS_DECAL, // scorch marks, etc. 255 SS_SEE_THROUGH, // ladders, grates, grills that may have small blended edges 256 // in addition to alpha test 257 SS_BANNER, 258 259 SS_FOG, 260 261 SS_UNDERWATER, // for items that should be drawn in front of the water plane 262 SS_WATER, 263 264 SS_FAR, 265 SS_MEDIUM, 266 SS_CLOSE, 267 268 SS_BLEND0, // regular transparency and filters 269 SS_BLEND1, // generally only used for additive type effects 270 SS_BLEND2, 271 SS_BLEND3, 272 273 SS_BLEND6, 274 275 SS_ALMOST_NEAREST, // gun smoke puffs 276 277 SS_NEAREST, // blood blobs 278 SS_POST_PROCESS 279 } shaderSort_t; 280 281 typedef struct shaderTable_s 282 { 283 char name[MAX_QPATH]; 284 285 int index; 286 287 qboolean clamp; 288 qboolean snap; 289 290 float *values; 291 int numValues; 292 293 struct shaderTable_s *next; 294 } shaderTable_t; 295 296 typedef enum 297 { 298 GF_NONE, 299 300 GF_SIN, 301 GF_SQUARE, 302 GF_TRIANGLE, 303 GF_SAWTOOTH, 304 GF_INVERSE_SAWTOOTH, 305 306 GF_NOISE 307 } genFunc_t; 308 309 310 typedef enum 311 { 312 DEFORM_NONE, 313 DEFORM_WAVE, 314 DEFORM_NORMALS, 315 DEFORM_BULGE, 316 DEFORM_MOVE, 317 DEFORM_PROJECTION_SHADOW, 318 DEFORM_AUTOSPRITE, 319 DEFORM_AUTOSPRITE2, 320 DEFORM_TEXT0, 321 DEFORM_TEXT1, 322 DEFORM_TEXT2, 323 DEFORM_TEXT3, 324 DEFORM_TEXT4, 325 DEFORM_TEXT5, 326 DEFORM_TEXT6, 327 DEFORM_TEXT7, 328 DEFORM_SPRITE, 329 DEFORM_FLARE 330 } deform_t; 331 332 typedef enum 333 { 334 AGEN_IDENTITY, 335 AGEN_SKIP, 336 AGEN_ENTITY, 337 AGEN_ONE_MINUS_ENTITY, 338 AGEN_VERTEX, 339 AGEN_ONE_MINUS_VERTEX, 340 AGEN_LIGHTING_SPECULAR, 341 AGEN_WAVEFORM, 342 AGEN_PORTAL, 343 AGEN_CONST, 344 AGEN_CUSTOM 345 } alphaGen_t; 346 347 typedef enum 348 { 349 CGEN_BAD, 350 CGEN_IDENTITY_LIGHTING, // tr.identityLight 351 CGEN_IDENTITY, // always (1,1,1,1) 352 CGEN_ENTITY, // grabbed from entity's modulate field 353 CGEN_ONE_MINUS_ENTITY, // grabbed from 1 - entity.modulate 354 CGEN_EXACT_VERTEX, // tess.vertexColors 355 CGEN_VERTEX, // tess.vertexColors * tr.identityLight 356 CGEN_ONE_MINUS_VERTEX, 357 CGEN_WAVEFORM, // programmatically generated 358 CGEN_LIGHTING_DIFFUSE, 359 CGEN_FOG, // standard fog 360 CGEN_CONST, // fixed color 361 CGEN_CUSTOM_RGB, // like fixed color but generated dynamically, single arithmetic expression 362 CGEN_CUSTOM_RGBs, // multiple expressions 363 } colorGen_t; 364 365 typedef enum 366 { 367 TCGEN_BAD, 368 TCGEN_SKIP, 369 TCGEN_IDENTITY, // clear to 0,0 370 TCGEN_LIGHTMAP, 371 TCGEN_TEXTURE, 372 TCGEN_ENVIRONMENT_MAPPED, 373 TCGEN_FOG, 374 TCGEN_VECTOR // S and T from world coordinates 375 } texCoordGen_t; 376 377 typedef enum 378 { 379 ACFF_NONE, 380 ACFF_MODULATE_RGB, 381 ACFF_MODULATE_RGBA, 382 ACFF_MODULATE_ALPHA 383 } acff_t; 384 385 typedef enum { 386 OP_BAD, 387 // logic operators 388 OP_LAND, 389 OP_LOR, 390 OP_GE, 391 OP_LE, 392 OP_LEQ, 393 OP_LNE, 394 // arithmetic operators 395 OP_ADD, 396 OP_SUB, 397 OP_DIV, 398 OP_MOD, 399 OP_MUL, 400 OP_NEG, 401 // logic operators 402 OP_LT, 403 OP_GT, 404 // embracements 405 OP_LPAREN, 406 OP_RPAREN, 407 OP_LBRACKET, 408 OP_RBRACKET, 409 // constants or variables 410 OP_NUM, 411 OP_TIME, 412 OP_PARM0, 413 OP_PARM1, 414 OP_PARM2, 415 OP_PARM3, 416 OP_PARM4, 417 OP_PARM5, 418 OP_PARM6, 419 OP_PARM7, 420 OP_PARM8, 421 OP_PARM9, 422 OP_PARM10, 423 OP_PARM11, 424 OP_GLOBAL0, 425 OP_GLOBAL1, 426 OP_GLOBAL2, 427 OP_GLOBAL3, 428 OP_GLOBAL4, 429 OP_GLOBAL5, 430 OP_GLOBAL6, 431 OP_GLOBAL7, 432 OP_FRAGMENTPROGRAMS, 433 OP_SOUND, 434 // table access 435 OP_TABLE 436 } opcode_t; 437 438 typedef struct 439 { 440 const char *s; 441 opcode_t type; 442 } opstring_t; 443 444 typedef struct 445 { 446 opcode_t type; 447 float value; 448 } expOperation_t; 449 450 #define MAX_EXPRESSION_OPS 32 451 typedef struct 452 { 453 expOperation_t ops[MAX_EXPRESSION_OPS]; 454 int numOps; 455 456 qboolean active; // no parsing problems 457 } expression_t; 458 459 typedef struct 460 { 461 genFunc_t func; 462 463 float base; 464 float amplitude; 465 float phase; 466 float frequency; 467 } waveForm_t; 468 469 #define TR_MAX_TEXMODS 4 470 471 typedef enum 472 { 473 TMOD_NONE, 474 TMOD_TRANSFORM, 475 TMOD_TURBULENT, 476 TMOD_SCROLL, 477 TMOD_SCALE, 478 TMOD_STRETCH, 479 TMOD_ROTATE, 480 TMOD_ENTITY_TRANSLATE, 481 482 TMOD_SCROLL2, 483 TMOD_SCALE2, 484 TMOD_CENTERSCALE, 485 TMOD_SHEAR, 486 TMOD_ROTATE2 487 } texMod_t; 488 489 #define MAX_SHADER_DEFORMS 3 490 typedef struct 491 { 492 deform_t deformation; // vertex coordinate modification type 493 494 vec3_t moveVector; 495 waveForm_t deformationWave; 496 float deformationSpread; 497 498 float bulgeWidth; 499 float bulgeHeight; 500 float bulgeSpeed; 501 502 float flareSize; 503 } deformStage_t; 504 505 typedef struct 506 { 507 texMod_t type; 508 509 // used for TMOD_TURBULENT and TMOD_STRETCH 510 waveForm_t wave; 511 512 // used for TMOD_TRANSFORM 513 float matrix[2][2]; // s' = s * m[0][0] + t * m[1][0] + trans[0] 514 float translate[2]; // t' = s * m[0][1] + t * m[0][1] + trans[1] 515 516 // used for TMOD_SCALE 517 float scale[2]; // s *= scale[0] 518 // t *= scale[1] 519 520 // used for TMOD_SCROLL 521 float scroll[2]; // s' = s + scroll[0] * time 522 // t' = t + scroll[1] * time 523 524 // + = clockwise 525 // - = counterclockwise 526 float rotateSpeed; 527 528 // used by everything else 529 expression_t sExp; 530 expression_t tExp; 531 expression_t rExp; 532 533 } texModInfo_t; 534 535 536 #define MAX_IMAGE_ANIMATIONS 8 537 538 enum 539 { 540 TB_COLORMAP = 0, 541 TB_DIFFUSEMAP = 0, 542 TB_NORMALMAP, 543 TB_SPECULARMAP, 544 TB_LIGHTMAP, 545 MAX_TEXTURE_BUNDLES = 4 546 }; 547 548 typedef struct 549 { 550 image_t *image[MAX_IMAGE_ANIMATIONS]; 551 int numImageAnimations; 552 float imageAnimationSpeed; 553 554 texCoordGen_t tcGen; 555 vec3_t tcGenVectors[2]; 556 557 int numTexMods; 558 texModInfo_t *texMods; 559 560 int videoMapHandle; 561 qboolean isLightMap; 562 qboolean isVideoMap; 563 } textureBundle_t; 564 565 typedef enum 566 { 567 // material shader stage types 568 ST_COLORMAP, // vanilla Q3A style shader treatening 569 ST_DIFFUSEMAP, 570 ST_NORMALMAP, 571 ST_SPECULARMAP, 572 ST_HEATHAZEMAP, // heatHaze post process effect 573 ST_GLOWMAP, // glow post process effect 574 ST_LIGHTMAP, 575 ST_DELUXEMAP, 576 ST_REFLECTIONMAP, // cubeMap based reflection 577 ST_REFRACTIONMAP, 578 ST_DISPERSIONMAP, 579 ST_SKYBOXMAP, 580 ST_LIQUIDMAP, // reflective water shader 581 582 ST_COLLAPSE_Generic_multi, // two colormaps 583 ST_COLLAPSE_lighting_D_radiosity, // diffusemap + lightmap 584 ST_COLLAPSE_lighting_DB_radiosity, // diffusemap + bumpmap + lightmap 585 ST_COLLAPSE_lighting_DBS_radiosity, // diffusemap + bumpmap + specularmap + lightmap 586 ST_COLLAPSE_lighting_DB_direct, // directional entity lighting like rgbGen lightingDiffuse 587 ST_COLLAPSE_lighting_DBS_direct, // direction entity lighting with diffuse + bump + specular 588 ST_COLLAPSE_lighting_DB_generic, // diffusemap + bumpmap 589 ST_COLLAPSE_lighting_DBS_generic, // diffusemap + bumpmap + specularmap + lightmap 590 591 // light shader stage types 592 ST_ATTENUATIONMAP_XY, 593 ST_ATTENUATIONMAP_Z 594 } stageType_t; 595 596 typedef enum 597 { 598 COLLAPSE_none, 599 COLLAPSE_Generic_multi, 600 COLLAPSE_lighting_D_radiosity, 601 COLLAPSE_lighting_DB_radiosity, 602 COLLAPSE_lighting_DBS_radiosity, 603 COLLAPSE_lighting_DB_direct, 604 COLLAPSE_lighting_DBS_direct, 605 COLLAPSE_lighting_DB_generic, 606 COLLAPSE_lighting_DBS_generic, 607 } collapseType_t; 608 609 typedef struct 610 { 611 stageType_t type; 612 613 qboolean active; 614 615 textureBundle_t bundle[MAX_TEXTURE_BUNDLES]; 616 617 expression_t ifExp; 618 619 waveForm_t rgbWave; 620 colorGen_t rgbGen; 621 expression_t rgbExp; 622 expression_t redExp; 623 expression_t greenExp; 624 expression_t blueExp; 625 626 waveForm_t alphaWave; 627 alphaGen_t alphaGen; 628 expression_t alphaExp; 629 630 expression_t alphaTestExp; 631 632 byte constantColor[4]; // for CGEN_CONST and AGEN_CONST 633 634 unsigned stateBits; // GLS_xxxx mask 635 636 acff_t adjustColorsForFog; 637 638 qboolean isDetail; 639 640 qboolean overrideNoPicMip; // for images that must always be full resolution 641 qboolean overrideFilterType; // for console fonts, 2D elements, etc. 642 filterType_t filterType; 643 qboolean overrideWrapType; 644 wrapType_t wrapType; 645 646 qboolean uncompressed; 647 qboolean highQuality; 648 qboolean forceHighQuality; 649 650 qboolean privatePolygonOffset; // set for decals and other items that must be offset 651 float privatePolygonOffsetValue; 652 653 expression_t specularExponentExp; 654 655 expression_t refractionIndexExp; 656 657 expression_t fresnelPowerExp; 658 expression_t fresnelScaleExp; 659 expression_t fresnelBiasExp; 660 661 expression_t etaExp; 662 expression_t etaDeltaExp; 663 664 expression_t heightScaleExp; 665 expression_t heightBiasExp; 666 667 expression_t deformMagnitudeExp; 668 669 expression_t blurMagnitudeExp; 670 } shaderStage_t; 671 672 struct shaderCommands_s; 673 674 typedef enum 675 { 676 CT_FRONT_SIDED, 677 CT_BACK_SIDED, 678 CT_TWO_SIDED 679 } cullType_t; 680 681 typedef enum 682 { 683 FP_NONE, // surface is translucent and will just be adjusted properly 684 FP_EQUAL, // surface is opaque but possibly alpha tested 685 FP_LE // surface is trnaslucent, but still needs a fog pass (fog surface) 686 } fogPass_t; 687 688 typedef struct 689 { 690 float cloudHeight; 691 image_t *outerbox[6], *innerbox[6]; 692 } skyParms_t; 693 694 typedef struct 695 { 696 vec3_t color; 697 float depthForOpaque; 698 } fogParms_t; 699 700 typedef enum 701 { 702 SHADER_2D, // surface material: shader is for 2D rendering 703 SHADER_3D_DYNAMIC, // surface material: shader is for cGen diffuseLighting lighting 704 SHADER_3D_STATIC, // surface material: pre-lit triangle models 705 SHADER_3D_LIGHTMAP, 706 SHADER_LIGHT // light material: attenuation 707 } shaderType_t; 708 709 typedef struct shader_s 710 { 711 char name[MAX_QPATH]; // game path, including extension 712 shaderType_t type; 713 714 int index; // this shader == tr.shaders[index] 715 int sortedIndex; // this shader == tr.sortedShaders[sortedIndex] 716 717 float sort; // lower numbered shaders draw before higher numbered 718 719 qboolean defaultShader; // we want to return index 0 if the shader failed to 720 // load for some reason, but R_FindShader should 721 // still keep a name allocated for it, so if 722 // something calls RE_RegisterShader again with 723 // the same name, we don't try looking for it again 724 725 qboolean explicitlyDefined; // found in a .shader file 726 qboolean createdByGuide; // created using a shader .guide template 727 728 int surfaceFlags; // if explicitlyDefined, this will have SURF_* flags 729 int contentFlags; 730 731 qboolean entityMergable; // merge across entites optimizable (smoke, blood) 732 733 qboolean noShadows; 734 qboolean fogLight; 735 qboolean blendLight; 736 qboolean ambientLight; 737 qboolean translucent; 738 qboolean forceOpaque; 739 qboolean isSky; 740 skyParms_t sky; 741 fogParms_t fogParms; 742 743 float portalRange; // distance to fog out at 744 745 collapseType_t collapseType; 746 int collapseTextureEnv; // 0, GL_MODULATE, GL_ADD (FIXME: put in stage) 747 748 cullType_t cullType; // CT_FRONT_SIDED, CT_BACK_SIDED, or CT_TWO_SIDED 749 qboolean polygonOffset; // set for decals and other items that must be offset 750 float polygonOffsetValue; 751 752 qboolean noPicMip; // for images that must always be full resolution 753 filterType_t filterType; // for console fonts, 2D elements, etc. 754 wrapType_t wrapType; 755 756 fogPass_t fogPass; // draw a blended pass, possibly with depth test equals 757 758 // spectrums are used for "invisible writing" that can only be illuminated by a light of matching spectrum 759 qboolean spectrum; 760 int spectrumValue; 761 762 qboolean interactLight; // this shader can interact with light shaders 763 764 int numDeforms; 765 deformStage_t deforms[MAX_SHADER_DEFORMS]; 766 767 int numStages; 768 shaderStage_t *stages[MAX_SHADER_STAGES]; 769 770 void (*optimalStageIteratorFunc) (); 771 772 float clampTime; // time this shader is clamped to 773 float timeOffset; // current time offset for this shader 774 775 int numStates; // if non-zero this is a state shader 776 struct shader_s *currentShader; // current state if this is a state shader 777 struct shader_s *parentShader; // current state if this is a state shader 778 int currentState; // current state index for cycle purposes 779 long expireTime; // time in milliseconds this expires 780 781 struct shader_s *remappedShader; // current shader this one is remapped too 782 783 int shaderStates[MAX_STATES_PER_SHADER]; // index to valid shader states 784 785 struct shader_s *next; 786 } shader_t; 787 788 typedef struct shaderState_s 789 { 790 char shaderName[MAX_QPATH]; // name of shader this state belongs to 791 char name[MAX_STATE_NAME]; // name of this state 792 char stateShader[MAX_QPATH]; // shader this name invokes 793 int cycleTime; // time this cycle lasts, <= 0 is forever 794 shader_t *shader; 795 } shaderState_t; 796 797 // Tr3B - shaderProgram_t represents a pair of one 798 // GLSL vertex and one GLSL fragment shader 799 typedef struct shaderProgram_s 800 { 801 802 GLhandleARB program; 803 int attribs; // vertex array attributes 804 805 // uniform parameters 806 GLint u_ColorMap; 807 GLint u_ContrastMap; 808 GLint u_DiffuseMap; 809 GLint u_NormalMap; 810 GLint u_SpecularMap; 811 GLint u_LightMap; 812 GLint u_DeluxeMap; 813 GLint u_AttenuationMapXY; 814 GLint u_AttenuationMapZ; 815 816 GLint u_ViewOrigin; 817 818 GLint u_AmbientColor; 819 820 GLint u_LightDir; 821 GLint u_LightOrigin; 822 GLint u_LightColor; 823 GLint u_LightScale; 824 825 GLint u_SpecularExponent; 826 827 GLint u_RefractionIndex; 828 829 GLint u_FresnelPower; 830 GLint u_FresnelScale; 831 GLint u_FresnelBias; 832 833 GLint u_EtaRatio; 834 835 GLint u_HeightScale; 836 GLint u_HeightBias; 837 838 GLint u_DeformMagnitude; 839 GLint u_BlurMagnitude; 840 841 GLint u_FBufScale; 842 GLint u_NPotScale; 843 844 GLint u_ProjectionMatrixTranspose; 845 } shaderProgram_t; 846 847 848 // trRefdef_t holds everything that comes in refdef_t, 849 // as well as the locally generated scene information 850 typedef struct 851 { 852 int x, y, width, height; 853 float fov_x, fov_y; 854 vec3_t vieworg; 855 vec3_t viewaxis[3]; // transformation matrix 856 857 int time; // time in milliseconds for shader effects and other time dependent rendering issues 858 int rdflags; // RDF_NOWORLDMODEL, etc 859 860 // 1 bits will prevent the associated area from rendering at all 861 byte areamask[MAX_MAP_AREA_BYTES]; 862 qboolean areamaskModified; // qtrue if areamask changed since last scene 863 864 float floatTime; // tr.refdef.time / 1000.0 865 866 // text messages for deform text shaders 867 char text[MAX_RENDER_STRINGS][MAX_RENDER_STRING_LENGTH]; 868 869 int numEntities; 870 trRefEntity_t *entities; 871 872 int numDlights; 873 trRefDlight_t *dlights; 874 875 int numPolys; 876 struct srfPoly_s *polys; 877 878 int numDrawSurfs; 879 struct drawSurf_s *drawSurfs; 880 881 int numInteractions; 882 struct interaction_s *interactions; 883 } trRefdef_t; 884 885 886 //================================================================================= 887 888 // skins allow models to be retextured without modifying the model file 889 typedef struct 890 { 891 char name[MAX_QPATH]; 892 shader_t *shader; 893 } skinSurface_t; 894 895 typedef struct skin_s 896 { 897 char name[MAX_QPATH]; // game path, including extension 898 int numSurfaces; 899 skinSurface_t *surfaces[MD3_MAX_SURFACES]; 900 } skin_t; 901 902 903 typedef struct 904 { 905 int originalBrushNumber; 906 vec3_t bounds[2]; 907 908 unsigned colorInt; // in packed byte format 909 float tcScale; // texture coordinate vector scales 910 fogParms_t parms; 911 912 // for clipping distance in fog when outside 913 qboolean hasSurface; 914 float surface[4]; 915 } fog_t; 916 917 typedef struct 918 { 919 orientationr_t or; 920 orientationr_t world; 921 vec3_t pvsOrigin; // may be different than or.origin for portals 922 qboolean isPortal; // true if this view is through a portal 923 qboolean isMirror; // the portal is a mirror, invert the face culling 924 int frameSceneNum; // copied from tr.frameSceneNum 925 int frameCount; // copied from tr.frameCount 926 cplane_t portalPlane; // clip anything behind this if mirroring 927 int viewportX, viewportY, viewportWidth, viewportHeight; 928 float fovX, fovY; 929 float projectionMatrix[16]; 930 frustum_t frustum; 931 vec3_t visBounds[2]; 932 float skyFar; 933 } viewParms_t; 934 935 936 /* 937 ============================================================================== 938 939 SURFACES 940 941 ============================================================================== 942 */ 943 944 // any changes in surfaceType must be mirrored in tess_surfaceTable[] 945 typedef enum 946 { 947 SF_BAD, 948 SF_SKIP, // ignore 949 SF_FACE, 950 SF_GRID, 951 SF_TRIANGLES, 952 SF_POLY, 953 SF_MDX, 954 SF_MD5, 955 SF_FLARE, 956 SF_ENTITY, // beams, rails, lightning, etc that can be determined by entity 957 958 SF_NUM_SURFACE_TYPES, 959 SF_MAX = 0x7fffffff // ensures that sizeof( surfaceType_t ) == sizeof( int ) 960 } surfaceType_t; 961 962 typedef struct drawSurf_s 963 { 964 trRefEntity_t *entity; 965 int shaderNum; 966 int lightmapNum; 967 int fogNum; 968 969 surfaceType_t *surface; // any of surface*_t 970 } drawSurf_t; 971 972 typedef enum 973 { 974 IA_DEFAULT, // lighting and shadowing 975 IA_SHADOWONLY, 976 IA_LIGHTONLY 977 } interactionType_t; 978 979 // an interactionCache is a node between a dlight and a precached world surface 980 typedef struct interactionCache_s 981 { 982 struct interactionCache_s *next; 983 984 struct msurface_s *surface; 985 986 int numLightIndexes; 987 int *lightIndexes; // precached triangle indices facing light 988 989 int numShadowIndexes; 990 int *shadowIndexes; // precached triangle indices of shadow edges 991 } interactionCache_t; 992 993 // an interaction is a node between a dlight and any surface 994 typedef struct interaction_s 995 { 996 struct interaction_s *next; 997 998 interactionType_t type; 999 1000 trRefDlight_t *dlight; 1001 shader_t *dlightShader; 1002 1003 trRefEntity_t *entity; 1004 surfaceType_t *surface; // any of surface*_t 1005 shader_t *surfaceShader; 1006 1007 int numLightIndexes; 1008 int *lightIndexes; // precached triangle indices facing light 1009 1010 int numShadowIndexes; 1011 int *shadowIndexes; // precached triangle indices of shadow edges 1012 1013 int scissorX, scissorY, scissorWidth, scissorHeight; 1014 1015 float depthNear; // for GL_EXT_depth_bounds_test 1016 float depthFar; 1017 qboolean noDepthBoundsTest; 1018 1019 int occlusionQuerySamples; // visible fragment count 1020 } interaction_t; 1021 1022 #define MAX_EDGES 32 1023 typedef struct 1024 { 1025 int i2; 1026 qboolean facing; 1027 } edge_t; 1028 1029 typedef struct 1030 { 1031 edge_t edges[SHADER_MAX_VERTEXES][MAX_EDGES]; 1032 int numEdges[SHADER_MAX_VERTEXES]; 1033 1034 qboolean facing[SHADER_MAX_INDEXES / 3]; 1035 int numFacing; 1036 1037 int numIndexes; 1038 int indexes[SHADER_MAX_INDEXES]; 1039 } shadowState_t; 1040 1041 extern shadowState_t sh; 1042 1043 #define MAX_FACE_POINTS 64 1044 1045 #define MAX_PATCH_SIZE 32 // max dimensions of a patch mesh in map file 1046 #define MAX_GRID_SIZE 65 // max dimensions of a grid mesh in memory 1047 1048 // when cgame directly specifies a polygon, it becomes a srfPoly_t 1049 // as soon as it is called 1050 typedef struct srfPoly_s 1051 { 1052 surfaceType_t surfaceType; 1053 qhandle_t hShader; 1054 int fogIndex; 1055 int numVerts; 1056 polyVert_t *verts; 1057 } srfPoly_t; 1058 1059 typedef struct srfFlare_s 1060 { 1061 surfaceType_t surfaceType; 1062 vec3_t origin; 1063 vec3_t normal; 1064 vec3_t color; 1065 } srfFlare_t; 1066 1067 typedef struct 1068 { 1069 vec3_t xyz; 1070 vec2_t st; 1071 vec2_t lightmap; 1072 vec3_t tangent; 1073 vec3_t binormal; 1074 vec3_t normal; 1075 byte color[4]; 1076 } srfVert_t; 1077 1078 typedef struct 1079 { 1080 int indexes[3]; 1081 int neighbors[3]; 1082 vec4_t plane; 1083 } srfTriangle_t; 1084 1085 typedef struct srfGridMesh_s 1086 { 1087 surfaceType_t surfaceType; 1088 1089 // culling information 1090 vec3_t meshBounds[2]; 1091 vec3_t localOrigin; 1092 float meshRadius; 1093 1094 // lod information, which may be different 1095 // than the culling information to allow for 1096 // groups of curves that LOD as a unit 1097 vec3_t lodOrigin; 1098 float lodRadius; 1099 int lodFixed; 1100 int lodStitched; 1101 1102 // triangle definitions 1103 int width, height; 1104 float *widthLodError; 1105 float *heightLodError; 1106 1107 int numTriangles; 1108 srfTriangle_t *triangles; 1109 GLuint indexesVBO; 1110 1111 int numVerts; 1112 srfVert_t *verts; 1113 GLuint vertsVBO; 1114 GLuint ofsXYZ; 1115 GLuint ofsTexCoords; 1116 GLuint ofsTexCoords2; 1117 GLuint ofsTangents; 1118 GLuint ofsBinormals; 1119 GLuint ofsNormals; 1120 GLuint ofsColors; 1121 } srfGridMesh_t; 1122 1123 typedef struct 1124 { 1125 surfaceType_t surfaceType; 1126 1127 // culling information 1128 cplane_t plane; 1129 vec3_t bounds[2]; 1130 1131 // triangle definitions 1132 int numTriangles; 1133 srfTriangle_t *triangles; 1134 GLuint indexesVBO; 1135 1136 int numVerts; 1137 srfVert_t *verts; 1138 GLuint vertsVBO; 1139 GLuint ofsXYZ; 1140 GLuint ofsTexCoords; 1141 GLuint ofsTexCoords2; 1142 GLuint ofsTangents; 1143 GLuint ofsBinormals; 1144 GLuint ofsNormals; 1145 GLuint ofsColors; 1146 } srfSurfaceFace_t; 1147 1148 1149 // misc_models in maps are turned into direct geometry by q3map 1150 typedef struct 1151 { 1152 surfaceType_t surfaceType; 1153 1154 // culling information (FIXME: use this!) 1155 vec3_t bounds[2]; 1156 vec3_t localOrigin; 1157 float radius; 1158 1159 // triangle definitions 1160 int numTriangles; 1161 srfTriangle_t *triangles; 1162 GLuint indexesVBO; 1163 1164 int numVerts; 1165 srfVert_t *verts; 1166 GLuint vertsVBO; 1167 GLuint ofsXYZ; 1168 GLuint ofsTexCoords; 1169 GLuint ofsTangents; 1170 GLuint ofsBinormals; 1171 GLuint ofsNormals; 1172 GLuint ofsColors; 1173 } srfTriangles_t; 1174 1175 1176 extern void (*tess_surfaceTable[SF_NUM_SURFACE_TYPES]) (void *, int numLightIndexes, int *lightIndexes, int numShadowIndexes, int *shadowIndexes); 1177 1178 /* 1179 ============================================================================== 1180 BRUSH MODELS - in memory representation 1181 ============================================================================== 1182 */ 1183 typedef struct msurface_s 1184 { 1185 int viewCount; // if == tr.viewCount, already added 1186 int lightCount; 1187 struct shader_s *shader; 1188 int lightmapNum; // -1 = no lightmap 1189 int fogIndex; 1190 1191 surfaceType_t *data; // any of srf*_t 1192 } msurface_t; 1193 1194 1195 #define CONTENTS_NODE -1 1196 typedef struct mnode_s 1197 { 1198 // common with leaf and node 1199 int contents; // -1 for nodes, to differentiate from leafs 1200 int visCount; // node needs to be traversed if current 1201 int lightCount; 1202 vec3_t mins, maxs; // for bounding box culling 1203 struct mnode_s *parent; 1204 1205 // node specific 1206 cplane_t *plane; 1207 struct mnode_s *children[2]; 1208 1209 // leaf specific 1210 int cluster; 1211 int area; 1212 1213 msurface_t **firstmarksurface; 1214 int nummarksurfaces; 1215 } mnode_t; 1216 1217 typedef struct 1218 { 1219 vec3_t bounds[2]; // for culling 1220 msurface_t *firstSurface; 1221 int numSurfaces; 1222 } bmodel_t; 1223 1224 typedef struct 1225 { 1226 char name[MAX_QPATH]; // ie: maps/tim_dm2.bsp 1227 char baseName[MAX_QPATH]; // ie: tim_dm2 1228 1229 int dataSize; 1230 1231 int numShaders; 1232 dshader_t *shaders; 1233 1234 bmodel_t *bmodels; 1235 1236 int numplanes; 1237 cplane_t *planes; 1238 1239 int numnodes; // includes leafs 1240 int numDecisionNodes; 1241 mnode_t *nodes; 1242 1243 int numsurfaces; 1244 msurface_t *surfaces; 1245 1246 int nummarksurfaces; 1247 msurface_t **marksurfaces; 1248 1249 int numfogs; 1250 fog_t *fogs; 1251 1252 vec3_t lightGridOrigin; 1253 vec3_t lightGridSize; 1254 vec3_t lightGridInverseSize; 1255 int lightGridBounds[3]; 1256 byte *lightGridData; 1257 1258 int numDlights; 1259 trRefDlight_t *dlights; 1260 1261 int numInteractions; // should be always numSurfaces * 32 1262 interactionCache_t *interactions; 1263 1264 int numClusters; 1265 int clusterBytes; 1266 const byte *vis; // may be passed in by CM_LoadMap to save space 1267 1268 byte *novis; // clusterBytes of 0xff 1269 1270 char *entityString; 1271 char *entityParsePoint; 1272 } world_t; 1273 1274 1275 1276 /* 1277 ============================================================================== 1278 1279 MDX MODELS - meta format for .md2, .md3, .mdc and so on 1280 1281 ============================================================================== 1282 */ 1283 typedef struct 1284 { 1285 float bounds[2][3]; 1286 float localOrigin[3]; 1287 float radius; 1288 } mdxFrame_t; 1289 1290 typedef struct 1291 { 1292 char name[MAX_QPATH]; // tag name 1293 float origin[3]; 1294 float axis[3][3]; 1295 } mdxTag_t; 1296 1297 typedef struct 1298 { 1299 short xyz[3]; 1300 } mdxVertex_t; 1301 1302 typedef struct 1303 { 1304 float st[2]; 1305 } mdxSt_t; 1306 1307 typedef struct 1308 { 1309 int shaderIndex; // for in-game use 1310 } mdxShader_t; 1311 1312 typedef struct 1313 { 1314 surfaceType_t surfaceType; 1315 1316 char name[MAX_QPATH]; // polyset name 1317 1318 int numShaders; // all surfaces in a model should have the same 1319 mdxShader_t *shaders; 1320 1321 int numVerts; 1322 mdxVertex_t *verts; 1323 mdxSt_t *st; 1324 1325 int numTriangles; 1326 srfTriangle_t *triangles; 1327 1328 struct mdxModel_s *model; 1329 } mdxSurface_t; 1330 1331 typedef struct mdxModel_s 1332 { 1333 int numFrames; 1334 mdxFrame_t *frames; 1335 1336 int numTags; 1337 mdxTag_t *tags; 1338 1339 int numSurfaces; 1340 mdxSurface_t *surfaces; 1341 1342 int numSkins; 1343 } mdxModel_t; 1344 1345 1346 /* 1347 ============================================================================== 1348 1349 MD5 MODELS - in memory representation 1350 1351 ============================================================================== 1352 */ 1353 #define MD5_IDENTSTRING "MD5Version" 1354 #define MD5_VERSION 10 1355 #define MD5_MAX_BONES 128 1356 1357 typedef struct 1358 { 1359 int boneIndex; // these are indexes into the boneReferences, 1360 float boneWeight; // not the global per-frame bone list 1361 float offset[3]; 1362 } md5Weight_t; 1363 1364 typedef struct 1365 { 1366 float texCoords[2]; 1367 int firstWeight; 1368 int numWeights; 1369 md5Weight_t **weights; 1370 } md5Vertex_t; 1371 1372 /* 1373 typedef struct 1374 { 1375 int indexes[3]; 1376 int neighbors[3]; 1377 } md5Triangle_t; 1378 */ 1379 1380 typedef struct 1381 { 1382 surfaceType_t surfaceType; 1383 1384 // char name[MAX_QPATH]; // polyset name 1385 char shader[MAX_QPATH]; 1386 int shaderIndex; // for in-game use 1387 1388 int numVerts; 1389 md5Vertex_t *verts; 1390 1391 int numTriangles; 1392 srfTriangle_t *triangles; 1393 1394 int numWeights; 1395 md5Weight_t *weights; 1396 1397 struct md5Model_s *model; 1398 } md5Surface_t; 1399 1400 typedef struct 1401 { 1402 char name[MAX_QPATH]; 1403 int parentIndex; // parent index (-1 if root) 1404 #ifdef USE_BONEMATRIX 1405 matrix_t transform; 1406 #else 1407 vec3_t origin; 1408 quat_t rotation; 1409 #endif 1410 } md5Bone_t; 1411 1412 typedef struct md5Model_s 1413 { 1414 int numBones; 1415 md5Bone_t *bones; 1416 1417 int numSurfaces; 1418 md5Surface_t *surfaces; 1419 } md5Model_t; 1420 1421 1422 typedef enum 1423 { 1424 AT_BAD, 1425 AT_MD5 1426 } animType_t; 1427 1428 enum 1429 { 1430 COMPONENT_BIT_TX = 1 << 0, 1431 COMPONENT_BIT_TY = 1 << 1, 1432 COMPONENT_BIT_TZ = 1 << 2, 1433 COMPONENT_BIT_QX = 1 << 3, 1434 COMPONENT_BIT_QY = 1 << 4, 1435 COMPONENT_BIT_QZ = 1 << 5 1436 }; 1437 1438 typedef struct 1439 { 1440 char name[MAX_QPATH]; 1441 int parentIndex; 1442 1443 int componentsBits; // e.g. (COMPONENT_BIT_TX | COMPONENT_BIT_TY | COMPONENT_BIT_TZ) 1444 int componentsOffset; 1445 1446 vec3_t baseOrigin; 1447 quat_t baseQuat; 1448 } md5Channel_t; 1449 1450 typedef struct 1451 { 1452 vec3_t bounds[2]; // bounds of all surfaces of all LOD's for this frame 1453 float *components; // numAnimatedComponents many 1454 } md5Frame_t; 1455 1456 typedef struct md5Animation_s 1457 { 1458 char name[MAX_QPATH]; // game path, including extension 1459 animType_t type; 1460 int index; // anim = tr.animations[anim->index] 1461 1462 int numFrames; 1463 md5Frame_t *frames; 1464 1465 int numChannels; // same as numBones in model 1466 md5Channel_t *channels; 1467 1468 int frameRate; 1469 1470 int numAnimatedComponents; 1471 1472 // struct md5Animation_s *next; 1473 } md5Animation_t; 1474 1475 //====================================================================== 1476 1477 typedef enum 1478 { 1479 MOD_BAD, 1480 MOD_BRUSH, 1481 MOD_MDX, 1482 MOD_MD5 1483 } modtype_t; 1484 1485 typedef struct model_s 1486 { 1487 char name[MAX_QPATH]; 1488 modtype_t type; 1489 int index; // model = tr.models[model->index] 1490 1491 int dataSize; // just for listing purposes 1492 bmodel_t *bmodel; // only if type == MOD_BRUSH 1493 mdxModel_t *mdx[MD3_MAX_LODS]; // only if type == MOD_MD3 1494 md5Model_t *md5; // only if type == MOD_MD5 1495 1496 int numLods; 1497 } model_t; 1498 1499 void R_ModelInit(void); 1500 model_t *R_GetModelByHandle(qhandle_t hModel); 1501 1502 int RE_LerpTag(orientation_t * tag, qhandle_t handle, int startFrame, int endFrame, 1503 float frac, const char *tagName); 1504 1505 int RE_BoneIndex(qhandle_t hModel, const char *boneName); 1506 1507 void R_ModelBounds(qhandle_t handle, vec3_t mins, vec3_t maxs); 1508 1509 void R_Modellist_f(void); 1510 1511 //==================================================== 1512 1513 extern refimport_t ri; 1514 1515 #define MAX_MOD_KNOWN 1024 1516 #define MAX_ANIMATIONFILES 4096 1517 1518 #define MAX_DRAWIMAGES 4096 1519 #define MAX_LIGHTMAPS 256 1520 #define MAX_SKINS 1024 1521 1522 1523 #define MAX_DRAWSURFS 0x10000 1524 #define DRAWSURF_MASK (MAX_DRAWSURFS-1) 1525 1526 #define MAX_INTERACTIONS MAX_DRAWSURFS*16 1527 #define INTERACTION_MASK (MAX_INTERACTIONS-1) 1528 1529 extern int gl_filter_min, gl_filter_max; 1530 1531 /* 1532 ** performanceCounters_t 1533 */ 1534 typedef struct 1535 { 1536 int c_sphere_cull_patch_in, c_sphere_cull_patch_clip, c_sphere_cull_patch_out; 1537 int c_box_cull_patch_in, c_box_cull_patch_clip, c_box_cull_patch_out; 1538 1539 int c_sphere_cull_mdx_in, c_sphere_cull_mdx_clip, c_sphere_cull_mdx_out; 1540 int c_box_cull_mdx_in, c_box_cull_mdx_clip, c_box_cull_mdx_out; 1541 1542 int c_box_cull_md5_in, c_box_cull_md5_clip, c_box_cull_md5_out; 1543 1544 int c_box_cull_dlight_in, c_box_cull_dlight_clip, c_box_cull_dlight_out; 1545 int c_box_cull_slight_in, c_box_cull_slight_clip, c_box_cull_slight_out; 1546 int c_pvs_cull_slight_out; 1547 1548 int c_leafs; 1549 1550 int c_slights; 1551 int c_slightSurfaces; 1552 int c_slightInteractions; 1553 1554 int c_dlights; 1555 int c_dlightSurfaces; 1556 int c_dlightSurfacesCulled; 1557 int c_dlightInteractions; 1558 1559 int c_depthBoundsTests, c_depthBoundsTestsRejected; 1560 } frontEndCounters_t; 1561 1562 #define FOG_TABLE_SIZE 256 1563 #define FUNCTABLE_SIZE 1024 1564 #define FUNCTABLE_SIZE2 10 1565 #define FUNCTABLE_MASK (FUNCTABLE_SIZE-1) 1566 1567 // the renderer front end should never modify glstate_t 1568 typedef struct 1569 { 1570 int currenttextures[32]; 1571 int currenttmu; 1572 qboolean finishCalled; 1573 int texEnv[2]; 1574 int faceCulling; 1575 unsigned long glStateBits; 1576 unsigned long glClientStateBits; 1577 GLhandleARB currentProgram; 1578 frameBuffer_t *currentFBO; 1579 } glstate_t; 1580 1581 typedef struct 1582 { 1583 int c_batches; 1584 int c_surfaces; 1585 int c_vertexes; 1586 int c_indexes; 1587 int c_drawElements; 1588 float c_overDraw; 1589 int c_vboVertexBuffers; 1590 int c_vboIndexBuffers; 1591 int c_vboVertexes; 1592 int c_vboIndexes; 1593 1594 int c_dlightVertexes; 1595 int c_dlightIndexes; 1596 1597 int c_shadowBatches; 1598 int c_shadowSurfaces; 1599 int c_shadowVertexes; 1600 int c_shadowIndexes; 1601 1602 int c_fogSurfaces; 1603 int c_fogBatches; 1604 1605 int c_flareAdds; 1606 int c_flareTests; 1607 int c_flareRenders; 1608 1609 int c_occlusionQueries; 1610 int c_occlusionQueriesAvailable; 1611 int c_occlusionQueriesCulled; 1612 1613 int msec; // total msec for backend run 1614 } backEndCounters_t; 1615 1616 // all state modified by the back end is seperated 1617 // from the front end state 1618 typedef struct 1619 { 1620 int smpFrame; 1621 trRefdef_t refdef; 1622 viewParms_t viewParms; 1623 orientationr_t or; 1624 backEndCounters_t pc; 1625 qboolean isHyperspace; 1626 trRefEntity_t *currentEntity; 1627 trRefDlight_t *currentLight; // only used when lighting interactions 1628 qboolean skyRenderedThisView; // flag for drawing sun 1629 1630 qboolean projection2D; // if qtrue, drawstretchpic doesn't need to change modes 1631 byte color2D[4]; 1632 qboolean vertexes2D; // shader needs to be finished 1633 trRefEntity_t entity2D; // currentEntity will point at this when doing 2D rendering 1634 } backEndState_t; 1635 1636 /* 1637 ** trGlobals_t 1638 ** 1639 ** Most renderer globals are defined here. 1640 ** backend functions should never modify any of these fields, 1641 ** but may read fields that aren't dynamically modified 1642 ** by the frontend. 1643 */ 1644 typedef struct 1645 { 1646 qboolean registered; // cleared at shutdown, set at beginRegistration 1647 1648 int visCount; // incremented every time a new vis cluster is entered 1649 int frameCount; // incremented every frame 1650 int sceneCount; // incremented every scene 1651 int viewCount; // incremented every view (twice a scene if portaled) 1652 int lightCount; // incremented every time a light traverses the world and every R_MarkFragments call 1653 1654 int smpFrame; // toggles from 0 to 1 every endFrame 1655 1656 int frameSceneNum; // zeroed at RE_BeginFrame 1657 1658 qboolean worldMapLoaded; 1659 qboolean worldDeluxeMapping; 1660 world_t *world; 1661 1662 const byte *externalVisData; // from RE_SetWorldVisData, shared with CM_Load 1663 1664 image_t *defaultImage; 1665 image_t *scratchImage[32]; 1666 image_t *fogImage; 1667 image_t *flareImage; 1668 image_t *whiteImage; // full of 0xff 1669 image_t *blackImage; // full of 0x0 1670 image_t *flatImage; // use this as default normalmap 1671 image_t *identityLightImage; // full of tr.identityLightByte 1672 image_t *noFalloffImage; 1673 image_t *attenuationXYImage; 1674 image_t *currentRenderImage; 1675 image_t *currentRenderLinearImage; 1676 image_t *currentRenderNearestImage; 1677 1678 // internal shaders 1679 shader_t *defaultShader; 1680 shader_t *defaultPointLightShader; 1681 shader_t *defaultProjectedLightShader; 1682 shader_t *defaultDynamicLightShader; 1683 1684 // external shaders 1685 shader_t *projectionShadowShader; 1686 shader_t *flareShader; 1687 shader_t *sunShader; 1688 1689 int numLightmaps; 1690 image_t *lightmaps[MAX_LIGHTMAPS]; 1691 1692 // render entities 1693 trRefEntity_t *currentEntity; 1694 trRefEntity_t worldEntity; // point currentEntity at this when rendering world 1695 model_t *currentModel; 1696 1697 // render lights 1698 trRefDlight_t *currentDlight; 1699 1700 1701 // 1702 // GPU shader programs 1703 // 1704 1705 // Q3A standard simple vertex color rendering 1706 shaderProgram_t genericShader_single; 1707 1708 // directional lighting 1709 shaderProgram_t lightShader_D_direct; 1710 shaderProgram_t lightShader_DB_direct; 1711 shaderProgram_t lightShader_DBS_direct; 1712 1713 // directional light mapping 1714 shaderProgram_t lightShader_D_radiosity; 1715 shaderProgram_t lightShader_DB_radiosity; 1716 shaderProgram_t lightShader_DBS_radiosity; 1717 1718 // black depth fill rendering with textures 1719 shaderProgram_t depthFillShader; 1720 1721 // stencil shadow volume extrusion 1722 shaderProgram_t shadowShader; 1723 1724 // Doom3 style omni-directional multi-pass lighting 1725 shaderProgram_t lightShader_D_omni; 1726 shaderProgram_t lightShader_DB_omni; 1727 shaderProgram_t lightShader_DBS_omni; 1728 shaderProgram_t lightShader_D_proj; 1729 1730 // environment mapping effects 1731 shaderProgram_t reflectionShader_C; 1732 shaderProgram_t refractionShader_C; 1733 shaderProgram_t dispersionShader_C; 1734 shaderProgram_t skyBoxShader; 1735 1736 // post process effects 1737 shaderProgram_t heatHazeShader; 1738 shaderProgram_t glowShader; 1739 shaderProgram_t bloomShader; 1740 shaderProgram_t contrastShader; 1741 shaderProgram_t blurXShader; 1742 shaderProgram_t blurYShader; 1743 1744 viewParms_t viewParms; 1745 1746 float identityLight; // 1.0 / ( 1 << overbrightBits ) 1747 int identityLightByte; // identityLight * 255 1748 int overbrightBits; // r_overbrightBits->integer, but set to 0 if no hw gamma 1749 1750 orientationr_t or; // for current entity 1751 1752 trRefdef_t refdef; 1753 1754 int viewCluster; 1755 1756 vec3_t sunLight; // from the sky shader for this level 1757 vec3_t sunDirection; 1758 1759 frontEndCounters_t pc; 1760 int frontEndMsec; // not in pc due to clearing issue 1761 1762 // 1763 // put large tables at the end, so most elements will be 1764 // within the +/32K indexed range on risc processors 1765 // 1766 model_t *models[MAX_MOD_KNOWN]; 1767 int numModels; 1768 1769 int numAnimations; 1770 md5Animation_t *animations[MAX_ANIMATIONFILES]; 1771 1772 int numImages; 1773 image_t *images[MAX_DRAWIMAGES]; 1774 1775 int numFBOs; 1776 frameBuffer_t *fbos[MAX_FBOS]; 1777 1778 // shader indexes from other modules will be looked up in tr.shaders[] 1779 // shader indexes from drawsurfs will be looked up in sortedShaders[] 1780 // lower indexed sortedShaders must be rendered first (opaque surfaces before translucent) 1781 int numShaders; 1782 shader_t *shaders[MAX_SHADERS]; 1783 shader_t *sortedShaders[MAX_SHADERS]; 1784 1785 int numSkins; 1786 skin_t *skins[MAX_SKINS]; 1787 1788 int numTables; 1789 shaderTable_t *shaderTables[MAX_SHADER_TABLES]; 1790 1791 float sinTable[FUNCTABLE_SIZE]; 1792 float squareTable[FUNCTABLE_SIZE]; 1793 float triangleTable[FUNCTABLE_SIZE]; 1794 float sawToothTable[FUNCTABLE_SIZE]; 1795 float inverseSawToothTable[FUNCTABLE_SIZE]; 1796 float fogTable[FOG_TABLE_SIZE]; 1797 1798 int occlusionQueryObjects[MAX_OCCLUSION_QUERIES]; 1799 } trGlobals_t; 1800 1801 extern const matrix_t quakeToOpenGLMatrix; 1802 extern const matrix_t openGLToQuakeMatrix; 1803 1804 extern backEndState_t backEnd; 1805 extern trGlobals_t tr; 1806 extern glConfig_t glConfig; // outside of TR since it shouldn't be cleared during ref re-init 1807 extern glConfig2_t glConfig2; // outside of TR since it shouldn't be cleared during ref re-init 1808 extern glstate_t glState; // outside of TR since it shouldn't be cleared during ref re-init 1809 1810 1811 // 1812 // cvars 1813 // 1814 extern cvar_t *r_flareSize; 1815 extern cvar_t *r_flareFade; 1816 extern cvar_t *r_flareCoeff; 1817 1818 extern cvar_t *r_railWidth; 1819 extern cvar_t *r_railCoreWidth; 1820 extern cvar_t *r_railSegmentLength; 1821 1822 extern cvar_t *r_ignore; // used for debugging anything 1823 extern cvar_t *r_verbose; // used for verbose debug spew 1824 1825 extern cvar_t *r_znear; // near Z clip plane 1826 extern cvar_t *r_zfar; 1827 1828 extern cvar_t *r_stencilbits; // number of desired stencil bits 1829 extern cvar_t *r_depthbits; // number of desired depth bits 1830 extern cvar_t *r_colorbits; // number of desired color bits, only relevant for fullscreen 1831 extern cvar_t *r_stereo; // desired pixelformat stereo flag 1832 extern cvar_t *r_texturebits; // number of desired texture bits 1833 1834 // 0 = use framebuffer depth 1835 // 16 = use 16-bit textures 1836 // 32 = use 32-bit textures 1837 // all else = error 1838 1839 extern cvar_t *r_measureOverdraw; // enables stencil buffer overdraw measurement 1840 1841 extern cvar_t *r_lodbias; // push/pull LOD transitions 1842 extern cvar_t *r_lodscale; 1843 1844 extern cvar_t *r_ambientScale; 1845 extern cvar_t *r_directedScale; 1846 extern cvar_t *r_lightScale; 1847 1848 extern cvar_t *r_inGameVideo; // controls whether in game video should be draw 1849 extern cvar_t *r_fastsky; // controls whether sky should be cleared or drawn 1850 extern cvar_t *r_drawSun; // controls drawing of sun quad 1851 extern cvar_t *r_drawBloom; // controls drawing of bloom post process effect 1852 extern cvar_t *r_bloomBlur; 1853 extern cvar_t *r_lighting; // lighting mode, 0 = diffuse, 1 = bump mapping and so on 1854 extern cvar_t *r_dynamicLighting; // dynamic lights enabled/disabled 1855 1856 extern cvar_t *r_norefresh; // bypasses the ref rendering 1857 extern cvar_t *r_drawentities; // disable/enable entity rendering 1858 extern cvar_t *r_drawworld; // disable/enable world rendering 1859 extern cvar_t *r_speeds; // various levels of information display 1860 extern cvar_t *r_detailTextures; // enables/disables detail texturing stages 1861 extern cvar_t *r_novis; // disable/enable usage of PVS 1862 extern cvar_t *r_nocull; 1863 extern cvar_t *r_nocurves; 1864 extern cvar_t *r_nobatching; 1865 extern cvar_t *r_noLightScissors; 1866 extern cvar_t *r_noLightVisCull; 1867 extern cvar_t *r_noInteractionSort; 1868 extern cvar_t *r_showcluster; 1869 1870 extern cvar_t *r_mode; // video mode 1871 extern cvar_t *r_fullscreen; 1872 extern cvar_t *r_gamma; 1873 extern cvar_t *r_displayRefresh; // optional display refresh option 1874 extern cvar_t *r_ignorehwgamma; // overrides hardware gamma capabilities 1875 1876 extern cvar_t *r_allowExtensions; // global enable/disable of OpenGL extensions 1877 extern cvar_t *r_ext_compressed_textures; // these control use of specific extensions 1878 extern cvar_t *r_ext_multitexture; 1879 extern cvar_t *r_ext_compiled_vertex_array; 1880 extern cvar_t *r_ext_texture_env_add; 1881 extern cvar_t *r_ext_multisample; 1882 extern cvar_t *r_ext_texture_non_power_of_two; 1883 extern cvar_t *r_ext_texture_cube_map; 1884 extern cvar_t *r_ext_depth_texture; 1885 extern cvar_t *r_ext_vertex_program; 1886 extern cvar_t *r_ext_vertex_buffer_object; 1887 extern cvar_t *r_ext_occlusion_query; 1888 extern cvar_t *r_ext_shading_language_100; 1889 extern cvar_t *r_ext_stencil_wrap; 1890 extern cvar_t *r_ext_texture_filter_anisotropic; 1891 extern cvar_t *r_ext_stencil_two_side; 1892 extern cvar_t *r_ext_depth_bounds_test; 1893 extern cvar_t *r_ext_framebuffer_object; 1894 extern cvar_t *r_ext_generate_mipmap; 1895 1896 extern cvar_t *r_nobind; // turns off binding to appropriate textures 1897 extern cvar_t *r_collapseStages; 1898 extern cvar_t *r_singleShader; // make most world faces use default shader 1899 extern cvar_t *r_roundImagesDown; 1900 extern cvar_t *r_colorMipLevels; // development aid to see texture mip usage 1901 extern cvar_t *r_picmip; // controls picmip values 1902 extern cvar_t *r_finish; 1903 extern cvar_t *r_drawBuffer; 1904 extern cvar_t *r_swapInterval; 1905 extern cvar_t *r_textureMode; 1906 extern cvar_t *r_offsetFactor; 1907 extern cvar_t *r_offsetUnits; 1908 extern cvar_t *r_specularExponent; 1909 1910 extern cvar_t *r_fullbright; // avoid lightmap pass 1911 extern cvar_t *r_uiFullScreen; // ui is running fullscreen 1912 1913 extern cvar_t *r_logFile; // number of frames to emit GL logs 1914 extern cvar_t *r_showtris; // enables wireframe rendering of the world 1915 extern cvar_t *r_showsky; // forces sky in front of all surfaces 1916 extern cvar_t *r_shownormals; // draws wireframe normals 1917 extern cvar_t *r_showTangentSpaces; // draws wireframe tangents, binormals and normals 1918 extern cvar_t *r_clear; // force screen clear every frame 1919 1920 extern cvar_t *r_shadows; // controls shadows: 0 = none, 1 = blur, 2 = planar, 3 = robust stencil shadow volumes 1921 1922 extern cvar_t *r_shadowOffsetFactor; 1923 extern cvar_t *r_shadowOffsetUnits; 1924 extern cvar_t *r_noLightFrustums; 1925 extern cvar_t *r_drawFlares; // light flares 1926 1927 extern cvar_t *r_intensity; 1928 1929 extern cvar_t *r_lockpvs; 1930 extern cvar_t *r_noportals; 1931 extern cvar_t *r_portalOnly; 1932 1933 extern cvar_t *r_subdivisions; 1934 extern cvar_t *r_smp; 1935 extern cvar_t *r_showSmp; 1936 extern cvar_t *r_skipBackEnd; 1937 1938 extern cvar_t *r_ignoreGLErrors; 1939 1940 extern cvar_t *r_overBrightBits; 1941 extern cvar_t *r_mapOverBrightBits; 1942 1943 extern cvar_t *r_simpleMipMaps; 1944 1945 extern cvar_t *r_showImages; 1946 extern cvar_t *r_debugLight; 1947 extern cvar_t *r_debugSort; 1948 1949 extern cvar_t *r_showLightMaps; // render lightmaps only 1950 extern cvar_t *r_showDeluxeMaps; 1951 extern cvar_t *r_showNormalMaps; 1952 extern cvar_t *r_showShadowVolumes; 1953 extern cvar_t *r_showSkeleton; 1954 extern cvar_t *r_showEntityTransforms; 1955 extern cvar_t *r_showLightTransforms; 1956 extern cvar_t *r_showLightInteractions; 1957 extern cvar_t *r_showLightScissors; 1958 extern cvar_t *r_showOcclusionQueries; 1959 1960 extern cvar_t *r_vboFaces; 1961 extern cvar_t *r_vboCurves; 1962 extern cvar_t *r_vboTriangles; 1963 1964 extern float displayAspect; 1965 1966 //==================================================================== 1967 1968 float R_NoiseGet4f(float x, float y, float z, float t); 1969 void R_NoiseInit(void); 1970 1971 void R_SwapBuffers(int); 1972 1973 void R_RenderView(viewParms_t * parms); 1974 1975 void R_AddMDXSurfaces(trRefEntity_t * e); 1976 void R_AddMDXInteractions(trRefEntity_t * e, trRefDlight_t * light); 1977 void R_AddNullModelSurfaces(trRefEntity_t * e); 1978 void R_AddBeamSurfaces(trRefEntity_t * e); 1979 void R_AddRailSurfaces(trRefEntity_t * e, qboolean isUnderwater); 1980 void R_AddLightningBoltSurfaces(trRefEntity_t * e); 1981 1982 void R_AddPolygonSurfaces(void); 1983 1984 void R_AddDrawSurf(surfaceType_t * surface, shader_t * shader, int lightmapIndex, int fogIndex); 1985 1986 1987 void R_LocalNormalToWorld(const vec3_t local, vec3_t world); 1988 void R_LocalPointToWorld(const vec3_t local, vec3_t world); 1989 1990 int R_CullLocalBox(vec3_t bounds[2]); 1991 int R_CullLocalPointAndRadius(vec3_t origin, float radius); 1992 int R_CullPointAndRadius(vec3_t origin, float radius); 1993 1994 int R_FogLocalPointAndRadius(const vec3_t pt, float radius); 1995 int R_FogPointAndRadius(const vec3_t pt, float radius); 1996 int R_FogWorldBox(vec3_t bounds[2]); 1997 1998 void R_SetupEntityWorldBounds(trRefEntity_t * ent); 1999 2000 void R_RotateForEntity(const trRefEntity_t * ent, const viewParms_t * viewParms, orientationr_t * or); 2001 void R_RotateForDlight(const trRefDlight_t * ent, const viewParms_t * viewParms, orientationr_t * or); 2002 2003 2004 void R_CalcNormalForTriangle(vec3_t normal, const vec3_t v0, const vec3_t v1, const vec3_t v2); 2005 2006 void R_CalcTangentsForTriangle(vec3_t tangent, vec3_t binormal, 2007 const vec3_t v0, const vec3_t v1, const vec3_t v2, 2008 const vec2_t t0, const vec2_t t1, const vec2_t t2); 2009 2010 void R_CalcTangentSpace(vec3_t tangent, vec3_t binormal, vec3_t normal, 2011 const vec3_t v0, const vec3_t v1, const vec3_t v2, 2012 const vec2_t t0, const vec2_t t1, const vec2_t t2, 2013 const vec3_t n); 2014 2015 void R_CalcSurfaceTriangleNeighbors(int numTriangles, srfTriangle_t * triangles); 2016 void R_CalcSurfaceTrianglePlanes(int numTriangles, srfTriangle_t * triangles, srfVert_t * verts); 2017 2018 float R_CalcFov(float fovX, float width, float height); 2019 2020 // Tr3B - visualisation tools to help debugging the renderer frontend 2021 void R_DebugAxis(const vec3_t origin, const matrix_t transformMatrix); 2022 void R_DebugBoundingBox(const vec3_t origin, const vec3_t mins, const vec3_t maxs, vec4_t color); 2023 2024 /* 2025 ** GL wrapper/helper functions 2026 */ 2027 void GL_Bind(image_t * image); 2028 void GL_Program(GLhandleARB program); 2029 void GL_SetDefaultState(void); 2030 void GL_SelectTexture(int unit); 2031 void GL_TextureMode(const char *string); 2032 2033 void GL_CheckErrors_(const char *filename, int line); 2034 #define GL_CheckErrors() GL_CheckErrors_(__FILE__, __LINE__) 2035 2036 void GL_State(unsigned long stateVector); 2037 void GL_ClientState(unsigned long stateBits); 2038 void GL_TexEnv(int env); 2039 void GL_Cull(int cullType); 2040 2041 enum 2042 { 2043 GLS_SRCBLEND_ZERO = (1 << 0), 2044 GLS_SRCBLEND_ONE = (1 << 1), 2045 GLS_SRCBLEND_DST_COLOR = (1 << 2), 2046 GLS_SRCBLEND_ONE_MINUS_DST_COLOR = (1 << 3), 2047 GLS_SRCBLEND_SRC_ALPHA = (1 << 4), 2048 GLS_SRCBLEND_ONE_MINUS_SRC_ALPHA = (1 << 5), 2049 GLS_SRCBLEND_DST_ALPHA = (1 << 6), 2050 GLS_SRCBLEND_ONE_MINUS_DST_ALPHA = (1 << 7), 2051 GLS_SRCBLEND_ALPHA_SATURATE = (1 << 8), 2052 2053 GLS_SRCBLEND_BITS = GLS_SRCBLEND_ZERO 2054 | GLS_SRCBLEND_ONE 2055 | GLS_SRCBLEND_DST_COLOR 2056 | GLS_SRCBLEND_ONE_MINUS_DST_COLOR 2057 | GLS_SRCBLEND_SRC_ALPHA 2058 | GLS_SRCBLEND_ONE_MINUS_SRC_ALPHA 2059 | GLS_SRCBLEND_DST_ALPHA 2060 | GLS_SRCBLEND_ONE_MINUS_DST_ALPHA 2061 | GLS_SRCBLEND_ALPHA_SATURATE, 2062 2063 GLS_DSTBLEND_ZERO = (1 << 9), 2064 GLS_DSTBLEND_ONE = (1 << 10), 2065 GLS_DSTBLEND_SRC_COLOR = (1 << 11), 2066 GLS_DSTBLEND_ONE_MINUS_SRC_COLOR = (1 << 12), 2067 GLS_DSTBLEND_SRC_ALPHA = (1 << 13), 2068 GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA = (1 << 14), 2069 GLS_DSTBLEND_DST_ALPHA = (1 << 15), 2070 GLS_DSTBLEND_ONE_MINUS_DST_ALPHA = (1 << 16), 2071 2072 GLS_DSTBLEND_BITS = GLS_DSTBLEND_ZERO 2073 | GLS_DSTBLEND_ONE 2074 | GLS_DSTBLEND_SRC_COLOR 2075 | GLS_DSTBLEND_ONE_MINUS_SRC_COLOR 2076 | GLS_DSTBLEND_SRC_ALPHA 2077 | GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA 2078 | GLS_DSTBLEND_DST_ALPHA 2079 | GLS_DSTBLEND_ONE_MINUS_DST_ALPHA, 2080 2081 GLS_DEPTHMASK_TRUE = (1 << 17), 2082 2083 GLS_POLYMODE_LINE = (1 << 18), 2084 2085 GLS_DEPTHTEST_DISABLE = (1 << 19), 2086 2087 GLS_DEPTHFUNC_LESS = (1 << 20), 2088 GLS_DEPTHFUNC_EQUAL = (1 << 21), 2089 2090 GLS_DEPTHFUNC_BITS = GLS_DEPTHFUNC_LESS 2091 | GLS_DEPTHFUNC_EQUAL, 2092 2093 GLS_ATEST_GT_0 = (1 << 22), 2094 GLS_ATEST_LT_80 = (1 << 23), 2095 GLS_ATEST_GE_80 = (1 << 24), 2096 GLS_ATEST_GT_CUSTOM = (1 << 25), 2097 2098 GLS_ATEST_BITS = GLS_ATEST_GT_0 2099 | GLS_ATEST_LT_80 2100 | GLS_ATEST_GE_80 2101 | GLS_ATEST_GT_CUSTOM, 2102 2103 GLS_REDMASK_FALSE = (1 << 26), 2104 GLS_GREENMASK_FALSE = (1 << 27), 2105 GLS_BLUEMASK_FALSE = (1 << 28), 2106 GLS_ALPHAMASK_FALSE = (1 << 29), 2107 2108 GLS_COLORMASK_BITS = GLS_REDMASK_FALSE 2109 | GLS_GREENMASK_FALSE 2110 | GLS_BLUEMASK_FALSE 2111 | GLS_ALPHAMASK_FALSE, 2112 2113 GLS_STENCILTEST_ENABLE = (1 << 30), 2114 2115 GLS_DEFAULT = GLS_DEPTHMASK_TRUE 2116 }; 2117 2118 enum 2119 { 2120 GLCS_VERTEX = (1 << 0), 2121 GLCS_TEXCOORD0 = (1 << 1), 2122 GLCS_TEXCOORD1 = (1 << 2), 2123 GLCS_TEXCOORD2 = (1 << 3), 2124 GLCS_TEXCOORD3 = (1 << 4), 2125 GLCS_TANGENT = (1 << 5), 2126 GLCS_BINORMAL = (1 << 6), 2127 GLCS_NORMAL = (1 << 7), 2128 GLCS_COLOR = (1 << 8), 2129 2130 GLCS_DEFAULT = GLCS_VERTEX 2131 }; 2132 2133 2134 void RE_StretchRaw(int x, int y, int w, int h, int cols, int rows, const byte * data, int client, 2135 qboolean dirty); 2136 void RE_UploadCinematic(int w, int h, int cols, int rows, const byte * data, int client, 2137 qboolean dirty); 2138 2139 void RE_BeginFrame(stereoFrame_t stereoFrame); 2140 void RE_BeginRegistration(glConfig_t * glconfig, glConfig2_t * glconfig2); 2141 void RE_LoadWorldMap(const char *mapname); 2142 void RE_SetWorldVisData(const byte * vis); 2143 qhandle_t RE_RegisterModel(const char *name); 2144 qhandle_t RE_RegisterSkin(const char *name); 2145 void RE_Shutdown(qboolean destroyWindow); 2146 2147 qboolean R_GetEntityToken(char *buffer, int size); 2148 2149 model_t *R_AllocModel(void); 2150 2151 void R_Init(void); 2152 image_t *R_FindImageFile(const char *name, int bits, filterType_t filterType, wrapType_t wrapType); 2153 image_t *R_FindCubeImage(const char *name, int bits, filterType_t filterType, wrapType_t wrapType); 2154 2155 image_t *R_CreateImage(const char *name, const byte * pic, int width, int height, int bits, filterType_t filterType, wrapType_t wrapType); 2156 qboolean R_GetModeInfo(int *width, int *height, float *windowAspect, int mode); 2157 2158 void R_SetColorMappings(void); 2159 void R_GammaCorrect(byte * buffer, int bufSize); 2160 2161 void R_ImageList_f(void); 2162 void R_SkinList_f(void); 2163 2164 // https://zerowing.idsoftware.com/bugzilla/show_bug.cgi?id=516 2165 const void *RB_TakeScreenshotCmd(const void *data); 2166 void R_ScreenShot_f(void); 2167 2168 void R_InitFogTable(void); 2169 float R_FogFactor(float s, float t); 2170 void R_InitImages(void); 2171 void R_ShutdownImages(void); 2172 int R_SumOfUsedImages(void); 2173 void R_InitSkins(void); 2174 skin_t *R_GetSkinByHandle(qhandle_t hSkin); 2175 2176 void R_DeleteSurfaceVBOs(); 2177 2178 // 2179 // tr_shader.c 2180 // 2181 qhandle_t RE_RegisterShaderLightMap(const char *name, int lightmapIndex); 2182 qhandle_t RE_RegisterShader(const char *name); 2183 qhandle_t RE_RegisterShaderNoMip(const char *name); 2184 qhandle_t RE_RegisterShaderLightAttenuation(const char *name); 2185 qhandle_t RE_RegisterShaderFromImage(const char *name, image_t * image, qboolean mipRawImage); 2186 2187 shader_t *R_FindShader(const char *name, shaderType_t type, qboolean mipRawImage); 2188 shader_t *R_GetShaderByHandle(qhandle_t hShader); 2189 shader_t *R_GetShaderByState(int index, long *cycleTime); 2190 shader_t *R_FindShaderByName(const char *name); 2191 void R_InitShaders(void); 2192 void R_ShaderList_f(void); 2193 void R_ShaderExp_f(void); 2194 void R_RemapShader(const char *oldShader, const char *newShader, const char *timeOffset); 2195 2196 /* 2197 ==================================================================== 2198 2199 IMPLEMENTATION SPECIFIC FUNCTIONS 2200 2201 ==================================================================== 2202 */ 2203 2204 void GLimp_Init(void); 2205 void GLimp_Shutdown(void); 2206 void GLimp_EndFrame(void); 2207 2208 qboolean GLimp_SpawnRenderThread(void (*function) (void)); 2209 void *GLimp_RendererSleep(void); 2210 void GLimp_FrontEndSleep(void); 2211 void GLimp_WakeRenderer(void *data); 2212 2213 void GLimp_LogComment(char *comment); 2214 2215 // NOTE TTimo linux works with float gamma value, not the gamma table 2216 // the params won't be used, getting the r_gamma cvar directly 2217 void GLimp_SetGamma(unsigned char red[256], unsigned char green[256], unsigned char blue[256]); 2218 2219 2220 /* 2221 ==================================================================== 2222 TESSELATOR/SHADER DECLARATIONS 2223 ==================================================================== 2224 */ 2225 2226 typedef enum 2227 { 2228 SIT_DEFAULT, 2229 SIT_LIGHTING, 2230 SIT_LIGHTING_STENCIL 2231 } stageIteratorType_t; 2232 2233 typedef byte color4ub_t[4]; 2234 typedef float color4f_t[4]; 2235 2236 typedef struct stageVars 2237 { 2238 color4f_t color; 2239 color4ub_t colors[SHADER_MAX_VERTEXES]; 2240 qboolean skipCoords[MAX_TEXTURE_BUNDLES]; 2241 vec2_t texCoords[MAX_TEXTURE_BUNDLES][SHADER_MAX_VERTEXES]; 2242 matrix_t texMatrices[MAX_TEXTURE_BUNDLES]; 2243 } stageVars_t; 2244 2245 typedef struct shaderCommands_s 2246 { 2247 glIndex_t indexes[SHADER_MAX_INDEXES]; 2248 vec4_t xyz[SHADER_MAX_VERTEXES]; 2249 vec4_t tangents[SHADER_MAX_VERTEXES]; 2250 vec4_t binormals[SHADER_MAX_VERTEXES]; 2251 vec4_t normals[SHADER_MAX_VERTEXES]; 2252 vec2_t texCoords[SHADER_MAX_VERTEXES][2]; 2253 color4ub_t colors[SHADER_MAX_VERTEXES]; 2254 2255 GLuint indexesVBO; 2256 GLuint vertexesVBO; 2257 GLuint ofsXYZ; 2258 GLuint ofsTexCoords; 2259 GLuint ofsTexCoords2; 2260 GLuint ofsTangents; 2261 GLuint ofsBinormals; 2262 GLuint ofsNormals; 2263 GLuint ofsColors; 2264 2265 stageVars_t svars; 2266 2267 color4ub_t constantColor255[SHADER_MAX_VERTEXES]; 2268 2269 shader_t *surfaceShader; 2270 shader_t *lightShader; 2271 2272 float shaderTime; 2273 2274 int lightmapNum; 2275 2276 int fogNum; 2277 2278 qboolean skipTangentSpaces; 2279 qboolean shadowVolume; 2280 2281 int numIndexes; 2282 int numVertexes; 2283 2284 // info extracted from current shader or backend mode 2285 stageIteratorType_t currentStageIteratorType; 2286 void (*currentStageIteratorFunc) (); 2287 2288 int numSurfaceStages; 2289 shaderStage_t **surfaceStages; 2290 } shaderCommands_t; 2291 2292 extern shaderCommands_t tess; 2293 2294 void Tess_Begin(shader_t * surfaceShader, shader_t * lightShader, 2295 int lightmapNum, 2296 int fogNum, 2297 qboolean skipTangentSpaces, 2298 qboolean shadowVolume); 2299 void Tess_End(void); 2300 void Tess_CheckOverflow(int verts, int indexes); 2301 2302 void RB_InitGPUShaders(); 2303 void RB_ShutdownGPUShaders(); 2304 2305 void Tess_StageIteratorLighting(); 2306 void Tess_StageIteratorGeneric(); 2307 void Tess_StageIteratorSky(); 2308 2309 void Tess_AddQuadStamp(vec3_t origin, vec3_t left, vec3_t up, byte * color); 2310 void Tess_AddQuadStampExt(vec3_t origin, vec3_t left, vec3_t up, byte * color, float s1, float t1, 2311 float s2, float t2); 2312 2313 void RB_ShowImages(void); 2314 2315 2316 /* 2317 ============================================================ 2318 2319 WORLD MAP 2320 2321 ============================================================ 2322 */ 2323 2324 void R_AddBrushModelSurfaces(trRefEntity_t * e); 2325 void R_AddWorldSurfaces(void); 2326 qboolean R_inPVS(const vec3_t p1, const vec3_t p2); 2327 2328 void R_AddWorldInteractions(trRefDlight_t * light); 2329 void R_AddPrecachedWorldInteractions(trRefDlight_t * light); 2330 void R_ShutdownVBOs(); 2331 2332 /* 2333 ============================================================ 2334 2335 FLARES 2336 2337 ============================================================ 2338 */ 2339 2340 void R_ClearFlares(void); 2341 2342 void RB_AddFlare(void *surface, int fogNum, vec3_t point, vec3_t color, vec3_t normal); 2343 void RB_AddDlightFlares(void); 2344 void RB_RenderFlares(void); 2345 2346 /* 2347 ============================================================ 2348 2349 LIGHTS 2350 2351 ============================================================ 2352 */ 2353 2354 void R_AddBrushModelInteractions(trRefEntity_t * ent, trRefDlight_t * light); 2355 void R_SetupEntityLighting(const trRefdef_t * refdef, trRefEntity_t * ent); 2356 void R_TransformDlights(int count, trRefDlight_t * dl, orientationr_t * or); 2357 int R_LightForPoint(vec3_t point, vec3_t ambientLight, vec3_t directedLight, vec3_t lightDir); 2358 2359 void R_SetupDlightOrigin(trRefDlight_t * dl); 2360 void R_SetupDlightLocalBounds(trRefDlight_t * light); 2361 void R_SetupDlightWorldBounds(trRefDlight_t * light); 2362 2363 void R_SetupDlightFrustum(trRefDlight_t * dl); 2364 void R_SetupDlightProjection(trRefDlight_t * dl); 2365 2366 void R_AddDlightInteraction(trRefDlight_t * light, surfaceType_t * surface, shader_t * surfaceShader, 2367 int numLightIndexes, int *lightIndexes, 2368 int numShadowIndexes, int *shadowIndexes, 2369 interactionType_t iaType); 2370 2371 void R_SortInteractions(trRefDlight_t * light); 2372 qboolean R_DlightIntersectsPoint(trRefDlight_t * light, const vec3_t p); 2373 2374 void R_SetupDlightScissor(trRefDlight_t * light); 2375 void R_SetupDlightDepthBounds(trRefDlight_t * light); 2376 2377 2378 int R_CullLightPoint(trRefDlight_t * light, const vec3_t p); 2379 int R_CullLightTriangle(trRefDlight_t * light, vec3_t verts[3]); 2380 int R_CullLightWorldBounds(trRefDlight_t * light, vec3_t worldBounds[2]); 2381 2382 /* 2383 ============================================================ 2384 2385 SKIES 2386 2387 ============================================================ 2388 */ 2389 2390 void R_BuildCloudData(shaderCommands_t * shader); 2391 void R_InitSkyTexCoords(float cloudLayerHeight); 2392 void R_DrawSkyBox(shaderCommands_t * shader); 2393 void RB_DrawSun(void); 2394 void RB_ClipSkyPolygons(shaderCommands_t * shader); 2395 2396 /* 2397 ============================================================ 2398 2399 CURVE TESSELATION 2400 2401 ============================================================ 2402 */ 2403 2404 //#define PATCH_STITCHING 2405 2406 srfGridMesh_t *R_SubdividePatchToGrid(int width, int height, srfVert_t points[MAX_PATCH_SIZE * MAX_PATCH_SIZE]); 2407 srfGridMesh_t *R_GridInsertColumn(srfGridMesh_t * grid, int column, int row, vec3_t point, float loderror); 2408 srfGridMesh_t *R_GridInsertRow(srfGridMesh_t * grid, int row, int column, vec3_t point, float loderror); 2409 void R_FreeSurfaceGridMesh(srfGridMesh_t * grid); 2410 2411 /* 2412 ============================================================ 2413 2414 MARKERS, POLYGON PROJECTION ON WORLD POLYGONS 2415 2416 ============================================================ 2417 */ 2418 2419 int R_MarkFragments(int numPoints, const vec3_t * points, const vec3_t projection, 2420 int maxPoints, vec3_t pointBuffer, int maxFragments, 2421 markFragment_t * fragmentBuffer); 2422 2423 2424 /* 2425 ============================================================ 2426 2427 FRAME BUFFER OBJECTS 2428 2429 ============================================================ 2430 */ 2431 frameBuffer_t *R_CreateFBO(const char *name, int width, int height); 2432 2433 void R_CreateFBOColorBuffer(frameBuffer_t * fbo, int format, int index); 2434 void R_CreateFBODepthBuffer(frameBuffer_t * fbo, int format); 2435 void R_CreateFBOStencilBuffer(frameBuffer_t * fbo, int format); 2436 2437 void R_AttachFBOTexture1D(int texId, int attachmentIndex); 2438 void R_AttachFBOTexture2D(int target, int texId, int attachmentIndex); 2439 void R_AttachFBOTexture3D(int texId, int attachmentIndex, int zOffset); 2440 void R_AttachFBOTextureDepth(int texId); 2441 2442 void R_BindFBO(frameBuffer_t * fbo); 2443 void R_BindNullFBO(void); 2444 2445 void R_InitFBOs(void); 2446 void R_ShutdownFBOs(void); 2447 void R_FBOList_f(void); 2448 2449 2450 /* 2451 ============================================================ 2452 2453 SCENE GENERATION 2454 2455 ============================================================ 2456 */ 2457 2458 void R_ToggleSmpFrame(void); 2459 2460 void RE_ClearScene(void); 2461 void RE_AddRefEntityToScene(const refEntity_t * ent); 2462 void RE_AddRefDlightToScene(const refLight_t * light); 2463 void RE_AddPolyToScene(qhandle_t hShader, int numVerts, const polyVert_t * verts, int num); 2464 void RE_AddLightToScene(const vec3_t org, float intensity, float r, float g, float b); 2465 void RE_AddAdditiveLightToScene(const vec3_t org, float intensity, float r, float g, float b); 2466 void RE_RenderScene(const refdef_t * fd); 2467 2468 /* 2469 ============================================================= 2470 2471 ANIMATED MODELS 2472 2473 ============================================================= 2474 */ 2475 2476 void R_InitAnimations(void); 2477 qhandle_t RE_RegisterAnimation(const char *name); 2478 md5Animation_t *R_GetAnimationByHandle(qhandle_t hAnim); 2479 void R_AnimationList_f(void); 2480 2481 void R_AddMDSSurfaces(trRefEntity_t * ent); 2482 2483 void R_AddMD5Surfaces(trRefEntity_t * ent); 2484 void R_AddMD5Interactions(trRefEntity_t * ent, trRefDlight_t * light); 2485 2486 int RE_BuildSkeleton(refSkeleton_t * skel, qhandle_t anim, int startFrame, int endFrame, float frac, 2487 qboolean clearOrigin); 2488 int RE_BlendSkeleton(refSkeleton_t * skel, const refSkeleton_t * blend, float frac); 2489 int RE_AnimNumFrames(qhandle_t hAnim); 2490 int RE_AnimFrameRate(qhandle_t hAnim); 2491 2492 /* 2493 ============================================================= 2494 ============================================================= 2495 */ 2496 2497 void R_TransformWorldToClip(const vec3_t src, const float *cameraViewMatrix, 2498 const float *projectionMatrix, vec4_t eye, vec4_t dst); 2499 void R_TransformModelToClip(const vec3_t src, const float *modelViewMatrix, 2500 const float *projectionMatrix, vec4_t eye, vec4_t dst); 2501 void R_TransformClipToWindow(const vec4_t clip, const viewParms_t * view, vec4_t normalized, vec4_t window); 2502 2503 void RB_DeformTessGeometry(void); 2504 2505 float RB_EvalExpression(const expression_t * exp, float defaultValue); 2506 2507 void RB_CalcEnvironmentTexCoords(float *dstTexCoords); 2508 void RB_CalcFogTexCoords(float *dstTexCoords); 2509 void RB_CalcScrollTexCoords(const float scroll[2], float *dstTexCoords); 2510 void RB_CalcRotateTexCoords(float rotSpeed, float *dstTexCoords); 2511 void RB_CalcScaleTexCoords(const float scale[2], float *dstTexCoords); 2512 void RB_CalcTurbulentTexCoords(const waveForm_t * wf, float *dstTexCoords); 2513 void RB_CalcTransformTexCoords(const texModInfo_t * tmi, float *dstTexCoords); 2514 void RB_CalcScrollTexCoords2(const expression_t * sExp, const expression_t * tExp, float *dstTexCoords); 2515 void RB_CalcScaleTexCoords2(const expression_t * sExp, const expression_t * tExp, float *dstTexCoords); 2516 void RB_CalcCenterScaleTexCoords(const expression_t * sExp, const expression_t * tExp, float *dstTexCoords); 2517 void RB_CalcShearTexCoords(const expression_t * sExp, const expression_t * tExp, float *dstTexCoords); 2518 void RB_CalcRotateTexCoords2(const expression_t * rExp, float *dstTexCoords); 2519 2520 void RB_CalcModulateColorsByFog(unsigned char *dstColors); 2521 void RB_CalcModulateAlphasByFog(unsigned char *dstColors); 2522 void RB_CalcModulateRGBAsByFog(unsigned char *dstColors); 2523 void RB_CalcWaveAlpha(const waveForm_t * wf, unsigned char *dstColors); 2524 void RB_CalcWaveColor(const waveForm_t * wf, unsigned char *dstColors); 2525 void RB_CalcAlphaFromEntity(unsigned char *dstColors); 2526 void RB_CalcAlphaFromOneMinusEntity(unsigned char *dstColors); 2527 void RB_CalcStretchTexCoords(const waveForm_t * wf, float *texCoords); 2528 void RB_CalcColorFromEntity(unsigned char *dstColors); 2529 void RB_CalcColorFromOneMinusEntity(unsigned char *dstColors); 2530 void RB_CalcSpecularAlpha(unsigned char *alphas); 2531 void RB_CalcDiffuseColor(unsigned char *colors); 2532 void RB_CalcCustomColor(const expression_t * rgbExp, unsigned char *dstColors); 2533 void RB_CalcCustomColors(const expression_t * redExp, const expression_t * greenExp, const expression_t * blueExp, unsigned char *dstColors); 2534 void RB_CalcCustomAlpha(const expression_t * alphaExp, unsigned char *dstColors); 2535 2536 /* 2537 ============================================================= 2538 2539 RENDERER BACK END FUNCTIONS 2540 2541 ============================================================= 2542 */ 2543 2544 void RB_RenderThread(void); 2545 void RB_ExecuteRenderCommands(const void *data); 2546 2547 /* 2548 ============================================================= 2549 2550 RENDERER BACK END COMMAND QUEUE 2551 2552 ============================================================= 2553 */ 2554 2555 #define MAX_RENDER_COMMANDS 0x40000 2556 2557 typedef struct 2558 { 2559 byte cmds[MAX_RENDER_COMMANDS]; 2560 int used; 2561 } renderCommandList_t; 2562 2563 typedef struct 2564 { 2565 int commandId; 2566 float color[4]; 2567 } setColorCommand_t; 2568 2569 typedef struct 2570 { 2571 int commandId; 2572 int buffer; 2573 } drawBufferCommand_t; 2574 2575 typedef struct 2576 { 2577 int commandId; 2578 image_t *image; 2579 int width; 2580 int height; 2581 void *data; 2582 } subImageCommand_t; 2583 2584 typedef struct 2585 { 2586 int commandId; 2587 } swapBuffersCommand_t; 2588 2589 typedef struct 2590 { 2591 int commandId; 2592 int buffer; 2593 } endFrameCommand_t; 2594 2595 typedef struct 2596 { 2597 int commandId; 2598 shader_t *shader; 2599 float x, y; 2600 float w, h; 2601 float s1, t1; 2602 float s2, t2; 2603 } stretchPicCommand_t; 2604 2605 typedef struct 2606 { 2607 int commandId; 2608 trRefdef_t refdef; 2609 viewParms_t viewParms; 2610 drawSurf_t *drawSurfs; 2611 int numDrawSurfs; 2612 interaction_t *interactions; 2613 int numInteractions; 2614 } drawSurfsCommand_t; 2615 2616 typedef struct 2617 { 2618 int commandId; 2619 int x; 2620 int y; 2621 int width; 2622 int height; 2623 char *fileName; 2624 qboolean jpeg; 2625 } screenshotCommand_t; 2626 2627 typedef enum 2628 { 2629 RC_END_OF_LIST, 2630 RC_SET_COLOR, 2631 RC_STRETCH_PIC, 2632 RC_DRAW_SURFS, 2633 RC_DRAW_BUFFER, 2634 RC_SWAP_BUFFERS, 2635 RC_SCREENSHOT 2636 } renderCommand_t; 2637 2638 2639 // these are sort of arbitrary limits. 2640 // the limits apply to the sum of all scenes in a frame -- 2641 // the main view, all the 3D icons, etc 2642 #define MAX_POLYS 600 2643 #define MAX_POLYVERTS 3000 2644 2645 // all of the information needed by the back end must be 2646 // contained in a backEndData_t. This entire structure is 2647 // duplicated so the front and back end can run in parallel 2648 // on an SMP machine 2649 typedef struct 2650 { 2651 drawSurf_t drawSurfs[MAX_DRAWSURFS]; 2652 interaction_t interactions[MAX_INTERACTIONS]; 2653 2654 trRefDlight_t dlights[MAX_LIGHTS]; 2655 trRefEntity_t entities[MAX_ENTITIES]; 2656 2657 srfPoly_t *polys; //[MAX_POLYS]; 2658 polyVert_t *polyVerts; //[MAX_POLYVERTS]; 2659 2660 renderCommandList_t commands; 2661 } backEndData_t; 2662 2663 extern int max_polys; 2664 extern int max_polyverts; 2665 2666 extern backEndData_t *backEndData[SMP_FRAMES]; // the second one may not be allocated 2667 2668 extern volatile renderCommandList_t *renderCommandList; 2669 2670 extern volatile qboolean renderThreadActive; 2671 2672 2673 void *R_GetCommandBuffer(int bytes); 2674 void RB_ExecuteRenderCommands(const void *data); 2675 2676 void R_InitCommandBuffers(void); 2677 void R_ShutdownCommandBuffers(void); 2678 2679 void R_SyncRenderThread(void); 2680 2681 void R_AddDrawSurfCmd(drawSurf_t * drawSurfs, int numDrawSurfs, interaction_t * interactions, int numInteractions); 2682 2683 void RE_SetColor(const float *rgba); 2684 void RE_StretchPic(float x, float y, float w, float h, float s1, float t1, float s2, float t2, qhandle_t hShader); 2685 void RE_BeginFrame(stereoFrame_t stereoFrame); 2686 void RE_EndFrame(int *frontEndMsec, int *backEndMsec); 2687 2688 // font stuff 2689 void R_InitFreeType(); 2690 void R_DoneFreeType(); 2691 void RE_RegisterFont(const char *fontName, int pointSize, fontInfo_t * font); 2692 2693 2694 #endif // TR_LOCAL_H 2695