1 /* ------------------------------------------------------------------------------- 2 3 Copyright (C) 1999-2006 Id Software, Inc. and contributors. 4 For a list of contributors, see the accompanying CONTRIBUTORS file. 5 6 This file is part of GtkRadiant. 7 8 GtkRadiant is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 2 of the License, or 11 (at your option) any later version. 12 13 GtkRadiant is distributed in the hope that it will be useful, 14 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 GtkRadiant; if not, write to the Free Software 20 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 21 22 ---------------------------------------------------------------------------------- 23 24 This code has been altered significantly from its original form, to support 25 several games based on the Quake III Arena engine, in the form of "Q3Map2." 26 27 ------------------------------------------------------------------------------- */ 28 29 30 31 /* marker */ 32 #ifndef Q3MAP2_H 33 #define Q3MAP2_H 34 35 36 37 /* version */ 38 #define Q3MAP_VERSION "2.5.16" 39 #define Q3MAP_MOTD "Voter turnout" 40 41 42 43 /* ------------------------------------------------------------------------------- 44 45 dependencies 46 47 ------------------------------------------------------------------------------- */ 48 49 /* platform-specific */ 50 #if defined( __linux__ ) || defined( __APPLE__ ) || defined (__FreeBSD__) 51 #define Q_UNIX 52 #endif 53 54 #ifdef Q_UNIX 55 #include <unistd.h> 56 #include <pwd.h> 57 #include <limits.h> 58 #endif 59 60 #ifdef WIN32 61 #include <windows.h> 62 #endif 63 64 65 /* general */ 66 #include "version.h" /* ttimo: might want to guard that if built outside of the GtkRadiant tree */ 67 68 #include "cmdlib.h" 69 #include "mathlib.h" 70 #include "ddslib.h" 71 72 #include "picomodel.h" 73 74 #include "scriplib.h" 75 #include "polylib.h" 76 #include "imagelib.h" 77 #include "qthreads.h" 78 #include "inout.h" 79 #include "vfs.h" 80 #include "png.h" 81 #include "radiant_jpeglib.h" 82 #include "mhash.h" 83 84 #include <stdlib.h> 85 86 87 88 /* ------------------------------------------------------------------------------- 89 90 port-related hacks 91 92 ------------------------------------------------------------------------------- */ 93 94 #define MAC_STATIC_HACK 0 95 #if defined( __APPLE__ ) && MAC_STATIC_HACK 96 #define MAC_STATIC static 97 #else 98 #define MAC_STATIC 99 #endif 100 101 #if 1 102 #ifdef WIN32 103 #define Q_stricmp stricmp 104 #define Q_strncasecmp strnicmp 105 #else 106 #define Q_stricmp strcasecmp 107 #define Q_strncasecmp strncasecmp 108 #endif 109 #endif 110 111 /* macro version */ 112 #define VectorMA( a, s, b, c ) ((c)[ 0 ] = (a)[ 0 ] + (s) * (b)[ 0 ], (c)[ 1 ] = (a)[ 1 ] + (s) * (b)[ 1 ], (c)[ 2 ] = (a)[ 2 ] + (s) * (b)[ 2 ]) 113 114 115 116 /* ------------------------------------------------------------------------------- 117 118 constants 119 120 ------------------------------------------------------------------------------- */ 121 122 /* general */ 123 #define MAX_QPATH 64 124 125 #define MAX_IMAGES 512 126 #define DEFAULT_IMAGE "*default" 127 128 #define MAX_MODELS 512 129 130 #define DEF_BACKSPLASH_FRACTION 0.05f /* 5% backsplash by default */ 131 #define DEF_BACKSPLASH_DISTANCE 23 132 133 #define DEF_RADIOSITY_BOUNCE 1.0f /* ydnar: default to 100% re-emitted light */ 134 135 #define MAX_SHADER_INFO 8192 136 #define MAX_CUST_SURFACEPARMS 64 137 138 #define SHADER_MAX_VERTEXES 1000 139 #define SHADER_MAX_INDEXES (6 * SHADER_MAX_VERTEXES) 140 141 #define MAX_JITTERS 256 142 143 144 /* epair parsing (note case-sensitivity directive) */ 145 #define CASE_INSENSITIVE_EPAIRS 1 146 147 #if CASE_INSENSITIVE_EPAIRS 148 #define EPAIR_STRCMP Q_stricmp 149 #else 150 #define EPAIR_STRCMP strcmp 151 #endif 152 153 154 /* ydnar: compiler flags, because games have widely varying content/surface flags */ 155 #define C_SOLID 0x00000001 156 #define C_TRANSLUCENT 0x00000002 157 #define C_STRUCTURAL 0x00000004 158 #define C_HINT 0x00000008 159 #define C_NODRAW 0x00000010 160 #define C_LIGHTGRID 0x00000020 161 #define C_ALPHASHADOW 0x00000040 162 #define C_LIGHTFILTER 0x00000080 163 #define C_VERTEXLIT 0x00000100 164 #define C_LIQUID 0x00000200 165 #define C_FOG 0x00000400 166 #define C_SKY 0x00000800 167 #define C_ORIGIN 0x00001000 168 #define C_AREAPORTAL 0x00002000 169 #define C_ANTIPORTAL 0x00004000 /* like hint, but doesn't generate portals */ 170 #define C_SKIP 0x00008000 /* like hint, but skips this face (doesn't split bsp) */ 171 #define C_NOMARKS 0x00010000 /* no decals */ 172 173 #define C_DETAIL 0x08000000 /* THIS MUST BE THE SAME AS IN RADIANT! */ 174 175 176 /* shadow flags */ 177 #define WORLDSPAWN_CAST_SHADOWS 1 178 #define WORLDSPAWN_RECV_SHADOWS 1 179 #define ENTITY_CAST_SHADOWS 0 180 #define ENTITY_RECV_SHADOWS 1 181 182 183 /* bsp */ 184 #define MAX_PATCH_SIZE 32 185 #define MAX_BRUSH_SIDES 1024 186 #define MAX_BUILD_SIDES 300 187 188 #define MAX_EXPANDED_AXIS 128 189 190 #define CLIP_EPSILON 0.1f 191 #define PLANESIDE_EPSILON 0.001f 192 #define PLANENUM_LEAF -1 193 194 #define HINT_PRIORITY 1000 /* ydnar: force hint splits first and antiportal/areaportal splits last */ 195 #define ANTIPORTAL_PRIORITY -1000 196 #define AREAPORTAL_PRIORITY -1000 197 198 #define PSIDE_FRONT 1 199 #define PSIDE_BACK 2 200 #define PSIDE_BOTH (PSIDE_FRONT | PSIDE_BACK) 201 #define PSIDE_FACING 4 202 203 #define BPRIMIT_UNDEFINED 0 204 #define BPRIMIT_OLDBRUSHES 1 205 #define BPRIMIT_NEWBRUSHES 2 206 207 208 /* vis */ 209 #define VIS_HEADER_SIZE 8 210 211 #define SEPERATORCACHE /* seperator caching helps a bit */ 212 213 #define PORTALFILE "PRT1" 214 215 #define MAX_PORTALS 32768 216 #define MAX_SEPERATORS MAX_POINTS_ON_WINDING 217 #define MAX_POINTS_ON_FIXED_WINDING 24 /* ydnar: increased this from 12 at the expense of more memory */ 218 #define MAX_PORTALS_ON_LEAF 128 219 220 221 /* light */ 222 #define EMIT_POINT 0 223 #define EMIT_AREA 1 224 #define EMIT_SPOT 2 225 #define EMIT_SUN 3 226 227 #define LIGHT_ATTEN_LINEAR 1 228 #define LIGHT_ATTEN_ANGLE 2 229 #define LIGHT_ATTEN_DISTANCE 4 230 #define LIGHT_TWOSIDED 8 231 #define LIGHT_GRID 16 232 #define LIGHT_SURFACES 32 233 #define LIGHT_DARK 64 /* probably never use this */ 234 #define LIGHT_FAST 256 235 #define LIGHT_FAST_TEMP 512 236 #define LIGHT_FAST_ACTUAL (LIGHT_FAST | LIGHT_FAST_TEMP) 237 #define LIGHT_NEGATIVE 1024 238 239 #define LIGHT_SUN_DEFAULT (LIGHT_ATTEN_ANGLE | LIGHT_GRID | LIGHT_SURFACES) 240 #define LIGHT_AREA_DEFAULT (LIGHT_ATTEN_ANGLE | LIGHT_ATTEN_DISTANCE | LIGHT_GRID | LIGHT_SURFACES) /* q3a and wolf are the same */ 241 #define LIGHT_Q3A_DEFAULT (LIGHT_ATTEN_ANGLE | LIGHT_ATTEN_DISTANCE | LIGHT_GRID | LIGHT_SURFACES | LIGHT_FAST) 242 #define LIGHT_WOLF_DEFAULT (LIGHT_ATTEN_LINEAR | LIGHT_ATTEN_DISTANCE | LIGHT_GRID | LIGHT_SURFACES | LIGHT_FAST) 243 244 #define MAX_TRACE_TEST_NODES 256 245 #define DEFAULT_INHIBIT_RADIUS 1.5f 246 247 #define LUXEL_EPSILON 0.125f 248 #define VERTEX_EPSILON -0.125f 249 #define GRID_EPSILON 0.0f 250 251 #define DEFAULT_LIGHTMAP_SAMPLE_SIZE 16 252 #define DEFAULT_LIGHTMAP_SAMPLE_OFFSET 1.0f 253 #define DEFAULT_SUBDIVIDE_THRESHOLD 1.0f 254 255 #define EXTRA_SCALE 2 /* -extrawide = -super 2 */ 256 #define EXTRAWIDE_SCALE 2 /* -extrawide = -super 2 -filter */ 257 258 #define CLUSTER_UNMAPPED -1 259 #define CLUSTER_OCCLUDED -2 260 #define CLUSTER_FLOODED -3 261 262 #define VERTEX_LUXEL_SIZE 3 263 #define BSP_LUXEL_SIZE 3 264 #define RAD_LUXEL_SIZE 3 265 #define SUPER_LUXEL_SIZE 4 266 #define SUPER_ORIGIN_SIZE 3 267 #define SUPER_NORMAL_SIZE 4 268 #define SUPER_DELUXEL_SIZE 3 269 #define BSP_DELUXEL_SIZE 3 270 271 #define VERTEX_LUXEL( s, v ) (vertexLuxels[ s ] + ((v) * VERTEX_LUXEL_SIZE)) 272 #define RAD_VERTEX_LUXEL( s, v )(radVertexLuxels[ s ] + ((v) * VERTEX_LUXEL_SIZE)) 273 #define BSP_LUXEL( s, x, y ) (lm->bspLuxels[ s ] + ((((y) * lm->w) + (x)) * BSP_LUXEL_SIZE)) 274 #define RAD_LUXEL( s, x, y ) (lm->radLuxels[ s ] + ((((y) * lm->w) + (x)) * RAD_LUXEL_SIZE)) 275 #define SUPER_LUXEL( s, x, y ) (lm->superLuxels[ s ] + ((((y) * lm->sw) + (x)) * SUPER_LUXEL_SIZE)) 276 #define SUPER_DELUXEL( x, y ) (lm->superDeluxels + ((((y) * lm->sw) + (x)) * SUPER_DELUXEL_SIZE)) 277 #define BSP_DELUXEL( x, y ) (lm->bspDeluxels + ((((y) * lm->w) + (x)) * BSP_DELUXEL_SIZE)) 278 #define SUPER_CLUSTER( x, y ) (lm->superClusters + (((y) * lm->sw) + (x))) 279 #define SUPER_ORIGIN( x, y ) (lm->superOrigins + ((((y) * lm->sw) + (x)) * SUPER_ORIGIN_SIZE)) 280 #define SUPER_NORMAL( x, y ) (lm->superNormals + ((((y) * lm->sw) + (x)) * SUPER_NORMAL_SIZE)) 281 #define SUPER_DIRT( x, y ) (lm->superNormals + ((((y) * lm->sw) + (x)) * SUPER_NORMAL_SIZE) + 3) /* stash dirtyness in normal[ 3 ] */ 282 283 284 285 /* ------------------------------------------------------------------------------- 286 287 abstracted bsp file 288 289 ------------------------------------------------------------------------------- */ 290 291 #define EXTERNAL_LIGHTMAP "lm_%04d.tga" 292 293 #define MAX_LIGHTMAPS 4 /* RBSP */ 294 #define MAX_LIGHT_STYLES 64 295 #define MAX_SWITCHED_LIGHTS 32 296 #define LS_NORMAL 0x00 297 #define LS_UNUSED 0xFE 298 #define LS_NONE 0xFF 299 300 #define MAX_LIGHTMAP_SHADERS 256 301 302 /* ok to increase these at the expense of more memory */ 303 #define MAX_MAP_MODELS 0x400 304 #define MAX_MAP_BRUSHES 0x8000 305 #define MAX_MAP_ENTITIES 0x1000 //% 0x800 /* ydnar */ 306 #define MAX_MAP_ENTSTRING 0x80000 //% 0x40000 /* ydnar */ 307 #define MAX_MAP_SHADERS 0x800 //% 0x400 /* ydnar */ 308 309 #define MAX_MAP_AREAS 0x100 /* MAX_MAP_AREA_BYTES in q_shared must match! */ 310 #define MAX_MAP_FOGS 30 //& 0x100 /* RBSP (32 - world fog - goggles) */ 311 #define MAX_MAP_PLANES 0x100000 //% 0x20000 /* ydnar for md */ 312 #define MAX_MAP_NODES 0x20000 313 #define MAX_MAP_BRUSHSIDES 0x100000 //% 0x20000 /* ydnar */ 314 #define MAX_MAP_LEAFS 0x20000 315 #define MAX_MAP_LEAFFACES 0x100000 //% 0x20000 /* ydnar */ 316 #define MAX_MAP_LEAFBRUSHES 0x40000 317 #define MAX_MAP_PORTALS 0x20000 318 #define MAX_MAP_LIGHTING 0x800000 319 #define MAX_MAP_LIGHTGRID 0x100000 //% 0x800000 /* ydnar: set to points, not bytes */ 320 #define MAX_MAP_VISIBILITY 0x200000 321 322 #define MAX_MAP_DRAW_SURFS 0x20000 323 #define MAX_MAP_DRAW_VERTS 0x80000 324 #define MAX_MAP_DRAW_INDEXES 0x80000 325 326 327 /* key / value pair sizes in the entities lump */ 328 #define MAX_KEY 32 329 #define MAX_VALUE 1024 330 331 /* the editor uses these predefined yaw angles to orient entities up or down */ 332 #define ANGLE_UP -1 333 #define ANGLE_DOWN -2 334 335 #define LIGHTMAP_WIDTH 128 336 #define LIGHTMAP_HEIGHT 128 337 338 #define MIN_WORLD_COORD (-65536) 339 #define MAX_WORLD_COORD (65536) 340 #define WORLD_SIZE (MAX_WORLD_COORD - MIN_WORLD_COORD) 341 342 343 typedef void (*bspFunc)( const char * ); 344 345 346 typedef struct 347 { 348 int offset, length; 349 } 350 bspLump_t; 351 352 353 typedef struct 354 { 355 char ident[ 4 ]; 356 int version; 357 358 bspLump_t lumps[ 100 ]; /* theoretical maximum # of bsp lumps */ 359 } 360 bspHeader_t; 361 362 363 typedef struct 364 { 365 float mins[ 3 ], maxs[ 3 ]; 366 int firstBSPSurface, numBSPSurfaces; 367 int firstBSPBrush, numBSPBrushes; 368 } 369 bspModel_t; 370 371 372 typedef struct 373 { 374 char shader[ MAX_QPATH ]; 375 int surfaceFlags; 376 int contentFlags; 377 } 378 bspShader_t; 379 380 381 /* planes x^1 is allways the opposite of plane x */ 382 383 typedef struct 384 { 385 float normal[ 3 ]; 386 float dist; 387 } 388 bspPlane_t; 389 390 391 typedef struct 392 { 393 int planeNum; 394 int children[ 2 ]; /* negative numbers are -(leafs+1), not nodes */ 395 int mins[ 3 ]; /* for frustom culling */ 396 int maxs[ 3 ]; 397 } 398 bspNode_t; 399 400 401 typedef struct 402 { 403 int cluster; /* -1 = opaque cluster (do I still store these?) */ 404 int area; 405 406 int mins[ 3 ]; /* for frustum culling */ 407 int maxs[ 3 ]; 408 409 int firstBSPLeafSurface; 410 int numBSPLeafSurfaces; 411 412 int firstBSPLeafBrush; 413 int numBSPLeafBrushes; 414 } 415 bspLeaf_t; 416 417 418 typedef struct 419 { 420 int planeNum; /* positive plane side faces out of the leaf */ 421 int shaderNum; 422 int surfaceNum; /* RBSP */ 423 } 424 bspBrushSide_t; 425 426 427 typedef struct 428 { 429 int firstSide; 430 int numSides; 431 int shaderNum; /* the shader that determines the content flags */ 432 } 433 bspBrush_t; 434 435 436 typedef struct 437 { 438 char shader[ MAX_QPATH ]; 439 int brushNum; 440 int visibleSide; /* the brush side that ray tests need to clip against (-1 == none) */ 441 } 442 bspFog_t; 443 444 445 typedef struct 446 { 447 vec3_t xyz; 448 float st[ 2 ]; 449 float lightmap[ MAX_LIGHTMAPS ][ 2 ]; /* RBSP */ 450 vec3_t normal; 451 byte color[ MAX_LIGHTMAPS ][ 4 ]; /* RBSP */ 452 } 453 bspDrawVert_t; 454 455 456 typedef enum 457 { 458 MST_BAD, 459 MST_PLANAR, 460 MST_PATCH, 461 MST_TRIANGLE_SOUP, 462 MST_FLARE, 463 MST_FOLIAGE 464 } 465 bspSurfaceType_t; 466 467 468 typedef struct bspGridPoint_s 469 { 470 byte ambient[ MAX_LIGHTMAPS ][ 3 ]; 471 byte directed[ MAX_LIGHTMAPS ][ 3 ]; 472 byte styles[ MAX_LIGHTMAPS ]; 473 byte latLong[ 2 ]; 474 } 475 bspGridPoint_t; 476 477 478 typedef struct 479 { 480 int shaderNum; 481 int fogNum; 482 int surfaceType; 483 484 int firstVert; 485 int numVerts; 486 487 int firstIndex; 488 int numIndexes; 489 490 byte lightmapStyles[ MAX_LIGHTMAPS ]; /* RBSP */ 491 byte vertexStyles[ MAX_LIGHTMAPS ]; /* RBSP */ 492 int lightmapNum[ MAX_LIGHTMAPS ]; /* RBSP */ 493 int lightmapX[ MAX_LIGHTMAPS ], lightmapY[ MAX_LIGHTMAPS ]; /* RBSP */ 494 int lightmapWidth, lightmapHeight; 495 496 vec3_t lightmapOrigin; 497 vec3_t lightmapVecs[ 3 ]; /* on patches, [ 0 ] and [ 1 ] are lodbounds */ 498 499 int patchWidth; 500 int patchHeight; 501 } 502 bspDrawSurface_t; 503 504 505 506 /* ------------------------------------------------------------------------------- 507 508 general types 509 510 ------------------------------------------------------------------------------- */ 511 512 /* ydnar: for smaller structs */ 513 typedef char qb_t; 514 515 516 /* ydnar: for q3map_tcMod */ 517 typedef float tcMod_t[ 3 ][ 3 ]; 518 519 520 /* ydnar: for multiple game support */ 521 typedef struct surfaceParm_s 522 { 523 char *name; 524 int contentFlags, contentFlagsClear; 525 int surfaceFlags, surfaceFlagsClear; 526 int compileFlags, compileFlagsClear; 527 } 528 surfaceParm_t; 529 530 531 typedef struct game_s 532 { 533 char *arg; /* -game matches this */ 534 char *gamePath; /* main game data dir */ 535 char *homeBasePath; /* home sub-dir on unix */ 536 char *magic; /* magic word for figuring out base path */ 537 char *shaderPath; /* shader directory */ 538 int maxLMSurfaceVerts; /* default maximum meta surface verts */ 539 int maxSurfaceVerts; /* default maximum surface verts */ 540 int maxSurfaceIndexes; /* default maximum surface indexes (tris * 3) */ 541 qboolean emitFlares; /* when true, emit flare surfaces */ 542 char *flareShader; /* default flare shader (MUST BE SET) */ 543 qboolean wolfLight; /* when true, lights work like wolf q3map */ 544 int lightmapSize; /* bsp lightmap width/height */ 545 float lightmapGamma; /* default lightmap gamma */ 546 float lightmapCompensate; /* default lightmap compensate value */ 547 char *bspIdent; /* 4-letter bsp file prefix */ 548 int bspVersion; /* bsp version to use */ 549 qboolean lumpSwap; /* cod-style len/ofs order */ 550 bspFunc load, write; /* load/write function pointers */ 551 surfaceParm_t surfaceParms[ 128 ]; /* surfaceparm array */ 552 } 553 game_t; 554 555 556 typedef struct image_s 557 { 558 char *name, *filename; 559 int refCount; 560 int width, height; 561 byte *pixels; 562 } 563 image_t; 564 565 566 typedef struct sun_s 567 { 568 struct sun_s *next; 569 vec3_t direction, color; 570 float photons, deviance, filterRadius; 571 int numSamples, style; 572 } 573 sun_t; 574 575 576 typedef struct surfaceModel_s 577 { 578 struct surfaceModel_s *next; 579 char model[ MAX_QPATH ]; 580 float density, odds; 581 float minScale, maxScale; 582 float minAngle, maxAngle; 583 qboolean oriented; 584 } 585 surfaceModel_t; 586 587 588 /* ydnar/sd: foliage stuff for wolf et (engine-supported optimization of the above) */ 589 typedef struct foliage_s 590 { 591 struct foliage_s *next; 592 char model[ MAX_QPATH ]; 593 float scale, density, odds; 594 qboolean inverseAlpha; 595 } 596 foliage_t; 597 598 typedef struct foliageInstance_s 599 { 600 vec3_t xyz, normal; 601 } 602 foliageInstance_t; 603 604 605 typedef struct remap_s 606 { 607 struct remap_s *next; 608 char from[ 1024 ]; 609 char to[ MAX_QPATH ]; 610 } 611 remap_t; 612 613 614 /* wingdi.h hack, it's the same: 0 */ 615 #undef CM_NONE 616 617 typedef enum 618 { 619 CM_NONE, 620 CM_VOLUME, 621 CM_COLOR_SET, 622 CM_ALPHA_SET, 623 CM_COLOR_SCALE, 624 CM_ALPHA_SCALE, 625 CM_COLOR_DOT_PRODUCT, 626 CM_ALPHA_DOT_PRODUCT, 627 CM_COLOR_DOT_PRODUCT_2, 628 CM_ALPHA_DOT_PRODUCT_2 629 } 630 colorModType_t; 631 632 633 typedef struct colorMod_s 634 { 635 struct colorMod_s *next; 636 colorModType_t type; 637 vec_t data[ 16 ]; 638 } 639 colorMod_t; 640 641 642 typedef enum 643 { 644 IM_NONE, 645 IM_OPAQUE, 646 IM_MASKED, 647 IM_BLEND 648 } 649 implicitMap_t; 650 651 652 typedef struct shaderInfo_s 653 { 654 char shader[ MAX_QPATH ]; 655 int surfaceFlags; 656 int contentFlags; 657 int compileFlags; 658 float value; /* light value */ 659 660 char *flareShader; /* for light flares */ 661 char *damageShader; /* ydnar: sof2 damage shader name */ 662 char *backShader; /* for surfaces that generate different front and back passes */ 663 char *cloneShader; /* ydnar: for cloning of a surface */ 664 char *remapShader; /* ydnar: remap a shader in final stage */ 665 666 surfaceModel_t *surfaceModel; /* ydnar: for distribution of models */ 667 foliage_t *foliage; /* ydnar/splash damage: wolf et foliage */ 668 669 float subdivisions; /* from a "tesssize xxx" */ 670 float backsplashFraction; /* floating point value, usually 0.05 */ 671 float backsplashDistance; /* default 16 */ 672 float lightSubdivide; /* default 999 */ 673 float lightFilterRadius; /* ydnar: lightmap filtering/blurring radius for lights created by this shader (default: 0) */ 674 675 int lightmapSampleSize; /* lightmap sample size */ 676 float lightmapSampleOffset; /* ydnar: lightmap sample offset (default: 1.0) */ 677 678 float bounceScale; /* ydnar: radiosity re-emission [0,1.0+] */ 679 float offset; /* ydnar: offset in units */ 680 float shadeAngleDegrees; /* ydnar: breaking angle for smooth shading (degrees) */ 681 682 vec3_t mins, maxs; /* ydnar: for particle studio vertexDeform move support */ 683 684 qb_t legacyTerrain; /* ydnar: enable legacy terrain crutches */ 685 qb_t indexed; /* ydnar: attempt to use indexmap (terrain alphamap style) */ 686 qb_t forceMeta; /* ydnar: force metasurface path */ 687 qb_t noClip; /* ydnar: don't clip into bsp, preserve original face winding */ 688 qb_t noFast; /* ydnar: supress fast lighting for surfaces with this shader */ 689 qb_t invert; /* ydnar: reverse facing */ 690 qb_t nonplanar; /* ydnar: for nonplanar meta surface merging */ 691 qb_t tcGen; /* ydnar: has explicit texcoord generation */ 692 vec3_t vecs[ 2 ]; /* ydnar: explicit texture vectors for [0,1] texture space */ 693 tcMod_t mod; /* ydnar: q3map_tcMod matrix for djbob :) */ 694 vec3_t lightmapAxis; /* ydnar: explicit lightmap axis projection */ 695 colorMod_t *colorMod; /* ydnar: q3map_rgb/color/alpha/Set/Mod support */ 696 697 int furNumLayers; /* ydnar: number of fur layers */ 698 float furOffset; /* ydnar: offset of each layer */ 699 float furFade; /* ydnar: alpha fade amount per layer */ 700 701 qb_t splotchFix; /* ydnar: filter splotches on lightmaps */ 702 703 qb_t hasPasses; /* false if the shader doesn't define any rendering passes */ 704 qb_t globalTexture; /* don't normalize texture repeats */ 705 qb_t twoSided; /* cull none */ 706 qb_t autosprite; /* autosprite shaders will become point lights instead of area lights */ 707 qb_t polygonOffset; /* ydnar: don't face cull this or against this */ 708 qb_t patchShadows; /* have patches casting shadows when using -light for this surface */ 709 qb_t vertexShadows; /* shadows will be casted at this surface even when vertex lit */ 710 qb_t forceSunlight; /* force sun light at this surface even tho we might not calculate shadows in vertex lighting */ 711 qb_t notjunc; /* don't use this surface for tjunction fixing */ 712 qb_t fogParms; /* ydnar: has fogparms */ 713 qb_t noFog; /* ydnar: supress fogging */ 714 qb_t clipModel; /* ydnar: solid model hack */ 715 qb_t noVertexLight; /* ydnar: leave vertex color alone */ 716 717 byte styleMarker; /* ydnar: light styles hack */ 718 719 float vertexScale; /* vertex light scale */ 720 721 char skyParmsImageBase[ MAX_QPATH ]; /* ydnar: for skies */ 722 723 char editorImagePath[ MAX_QPATH ]; /* use this image to generate texture coordinates */ 724 char lightImagePath[ MAX_QPATH ]; /* use this image to generate color / averageColor */ 725 char normalImagePath[ MAX_QPATH ]; /* ydnar: normalmap image for bumpmapping */ 726 727 implicitMap_t implicitMap; /* ydnar: enemy territory implicit shaders */ 728 char implicitImagePath[ MAX_QPATH ]; 729 730 image_t *shaderImage; 731 image_t *lightImage; 732 image_t *normalImage; 733 734 float skyLightValue; /* ydnar */ 735 int skyLightIterations; /* ydnar */ 736 sun_t *sun; /* ydnar */ 737 738 vec3_t color; /* normalized color */ 739 vec3_t averageColor; 740 byte lightStyle; 741 742 qb_t lmMergable; /* ydnar */ 743 int lmCustomWidth, lmCustomHeight; /* ydnar */ 744 float lmBrightness; /* ydnar */ 745 float lmFilterRadius; /* ydnar: lightmap filtering/blurring radius for this shader (default: 0) */ 746 747 int shaderWidth, shaderHeight; /* ydnar */ 748 float stFlat[ 2 ]; 749 750 vec3_t fogDir; /* ydnar */ 751 752 char *shaderText; /* ydnar */ 753 qb_t custom; 754 qb_t finished; 755 } 756 shaderInfo_t; 757 758 759 760 /* ------------------------------------------------------------------------------- 761 762 bsp structures 763 764 ------------------------------------------------------------------------------- */ 765 766 typedef struct face_s 767 { 768 struct face_s *next; 769 int planenum; 770 int priority; 771 qboolean checked; 772 int compileFlags; 773 winding_t *w; 774 } 775 face_t; 776 777 778 typedef struct plane_s 779 { 780 vec3_t normal; 781 vec_t dist; 782 int type; 783 struct plane_s *hash_chain; 784 } 785 plane_t; 786 787 788 typedef struct side_s 789 { 790 int planenum; 791 792 int outputNum; /* set when the side is written to the file list */ 793 794 float texMat[ 2 ][ 3 ]; /* brush primitive texture matrix */ 795 float vecs[ 2 ][ 4 ]; /* old-style texture coordinate mapping */ 796 797 winding_t *winding; 798 winding_t *visibleHull; /* convex hull of all visible fragments */ 799 800 shaderInfo_t *shaderInfo; 801 802 int contentFlags; /* from shaderInfo */ 803 int surfaceFlags; /* from shaderInfo */ 804 int compileFlags; /* from shaderInfo */ 805 int value; /* from shaderInfo */ 806 807 qboolean visible; /* choose visble planes first */ 808 qboolean bevel; /* don't ever use for bsp splitting, and don't bother making windings for it */ 809 qboolean culled; /* ydnar: face culling */ 810 } 811 side_t; 812 813 814 typedef struct sideRef_s 815 { 816 struct sideRef_s *next; 817 side_t *side; 818 } 819 sideRef_t; 820 821 822 /* ydnar: generic index mapping for entities (natural extension of terrain texturing) */ 823 typedef struct indexMap_s 824 { 825 int w, h, numLayers; 826 char name[ MAX_QPATH ], shader[ MAX_QPATH ]; 827 float offsets[ 256 ]; 828 byte *pixels; 829 } 830 indexMap_t; 831 832 833 typedef struct brush_s 834 { 835 struct brush_s *next; 836 struct brush_s *nextColorModBrush; /* ydnar: colorMod volume brushes go here */ 837 struct brush_s *original; /* chopped up brushes will reference the originals */ 838 839 int entityNum, brushNum;/* editor numbering */ 840 int outputNum; /* set when the brush is written to the file list */ 841 842 /* ydnar: for shadowcasting entities */ 843 int castShadows; 844 int recvShadows; 845 846 shaderInfo_t *contentShader; 847 shaderInfo_t *celShader; /* :) */ 848 849 /* ydnar: gs mods */ 850 float lightmapScale; 851 vec3_t eMins, eMaxs; 852 indexMap_t *im; 853 854 int contentFlags; 855 int compileFlags; /* ydnar */ 856 qboolean detail; 857 qboolean opaque; 858 859 int portalareas[ 2 ]; 860 861 vec3_t mins, maxs; 862 int numsides; 863 864 side_t sides[ 6 ]; /* variably sized */ 865 } 866 brush_t; 867 868 869 typedef struct fog_s 870 { 871 shaderInfo_t *si; 872 brush_t *brush; 873 int visibleSide; /* the brush side that ray tests need to clip against (-1 == none) */ 874 } 875 fog_t; 876 877 878 typedef struct 879 { 880 int width, height; 881 bspDrawVert_t *verts; 882 } 883 mesh_t; 884 885 886 typedef struct parseMesh_s 887 { 888 struct parseMesh_s *next; 889 890 int entityNum, brushNum; /* ydnar: editor numbering */ 891 892 /* ydnar: for shadowcasting entities */ 893 int castShadows; 894 int recvShadows; 895 896 mesh_t mesh; 897 shaderInfo_t *shaderInfo; 898 shaderInfo_t *celShader; /* :) */ 899 900 /* ydnar: gs mods */ 901 float lightmapScale; 902 vec3_t eMins, eMaxs; 903 indexMap_t *im; 904 905 /* grouping */ 906 qboolean grouped; 907 float longestCurve; 908 int maxIterations; 909 } 910 parseMesh_t; 911 912 913 /* 914 ydnar: the drawsurf struct was extended to allow for: 915 - non-convex planar surfaces 916 - non-planar brushface surfaces 917 - lightmapped terrain 918 - planar patches 919 */ 920 921 typedef enum 922 { 923 /* ydnar: these match up exactly with bspSurfaceType_t */ 924 SURFACE_BAD, 925 SURFACE_FACE, 926 SURFACE_PATCH, 927 SURFACE_TRIANGLES, 928 SURFACE_FLARE, 929 SURFACE_FOLIAGE, /* wolf et */ 930 931 /* ydnar: compiler-relevant surface types */ 932 SURFACE_FORCED_META, 933 SURFACE_META, 934 SURFACE_FOGHULL, 935 SURFACE_DECAL, 936 SURFACE_SHADER, 937 938 NUM_SURFACE_TYPES 939 } 940 surfaceType_t; 941 942 // Q_EXTERN is defined only later :( 943 #ifndef MAIN_C 944 extern 945 #endif 946 char *surfaceTypes[ NUM_SURFACE_TYPES ] 947 #ifndef MAIN_C 948 ; 949 #else 950 = 951 { 952 "SURFACE_BAD", 953 "SURFACE_FACE", 954 "SURFACE_PATCH", 955 "SURFACE_TRIANGLES", 956 "SURFACE_FLARE", 957 "SURFACE_FOLIAGE", 958 "SURFACE_FORCED_META", 959 "SURFACE_META", 960 "SURFACE_FOGHULL", 961 "SURFACE_DECAL", 962 "SURFACE_SHADER" 963 }; 964 #endif 965 966 967 /* ydnar: this struct needs an overhaul (again, heh) */ 968 typedef struct mapDrawSurface_s 969 { 970 surfaceType_t type; 971 qboolean planar; 972 int outputNum; /* ydnar: to match this sort of thing up */ 973 974 qboolean fur; /* ydnar: this is kind of a hack, but hey... */ 975 qboolean skybox; /* ydnar: yet another fun hack */ 976 qboolean backSide; /* ydnar: q3map_backShader support */ 977 978 struct mapDrawSurface_s *parent; /* ydnar: for cloned (skybox) surfaces to share lighting data */ 979 struct mapDrawSurface_s *clone; /* ydnar: for cloned surfaces */ 980 struct mapDrawSurface_s *cel; /* ydnar: for cloned cel surfaces */ 981 982 shaderInfo_t *shaderInfo; 983 shaderInfo_t *celShader; 984 brush_t *mapBrush; 985 parseMesh_t *mapMesh; 986 sideRef_t *sideRef; 987 988 int fogNum; 989 990 int numVerts; /* vertexes and triangles */ 991 bspDrawVert_t *verts; 992 int numIndexes; 993 int *indexes; 994 995 int planeNum; 996 vec3_t lightmapOrigin; /* also used for flares */ 997 vec3_t lightmapVecs[ 3 ]; /* also used for flares */ 998 int lightStyle; /* used for flares */ 999 1000 /* ydnar: per-surface (per-entity, actually) lightmap sample size scaling */ 1001 float lightmapScale; 1002 1003 /* ydnar: surface classification */ 1004 vec3_t mins, maxs; 1005 vec3_t lightmapAxis; 1006 int sampleSize; 1007 1008 /* ydnar: shadow group support */ 1009 int castShadows, recvShadows; 1010 1011 /* ydnar: texture coordinate range monitoring for hardware with limited texcoord precision (in texel space) */ 1012 float bias[ 2 ]; 1013 int texMins[ 2 ], texMaxs[ 2 ], texRange[ 2 ]; 1014 1015 /* ydnar: for patches */ 1016 float longestCurve; 1017 int maxIterations; 1018 int patchWidth, patchHeight; 1019 vec3_t bounds[ 2 ]; 1020 1021 /* ydnar/sd: for foliage */ 1022 int numFoliageInstances; 1023 1024 /* ydnar: editor/useful numbering */ 1025 int entityNum; 1026 int surfaceNum; 1027 } 1028 mapDrawSurface_t; 1029 1030 1031 typedef struct drawSurfRef_s 1032 { 1033 struct drawSurfRef_s *nextRef; 1034 int outputNum; 1035 } 1036 drawSurfRef_t; 1037 1038 1039 /* ydnar: metasurfaces are constructed from lists of metatriangles so they can be merged in the best way */ 1040 typedef struct metaTriangle_s 1041 { 1042 shaderInfo_t *si; 1043 side_t *side; 1044 int entityNum, surfaceNum, planeNum, fogNum, sampleSize, castShadows, recvShadows; 1045 vec4_t plane; 1046 vec3_t lightmapAxis; 1047 int indexes[ 3 ]; 1048 } 1049 metaTriangle_t; 1050 1051 1052 typedef struct epair_s 1053 { 1054 struct epair_s *next; 1055 char *key, *value; 1056 } 1057 epair_t; 1058 1059 1060 typedef struct 1061 { 1062 vec3_t origin; 1063 brush_t *brushes, *lastBrush, *colorModBrushes; 1064 parseMesh_t *patches; 1065 int mapEntityNum, firstDrawSurf; 1066 int firstBrush, numBrushes; /* only valid during BSP compile */ 1067 epair_t *epairs; 1068 } 1069 entity_t; 1070 1071 1072 typedef struct node_s 1073 { 1074 /* both leafs and nodes */ 1075 int planenum; /* -1 = leaf node */ 1076 struct node_s *parent; 1077 vec3_t mins, maxs; /* valid after portalization */ 1078 brush_t *volume; /* one for each leaf/node */ 1079 1080 /* nodes only */ 1081 side_t *side; /* the side that created the node */ 1082 struct node_s *children[ 2 ]; 1083 int compileFlags; /* ydnar: hint, antiportal */ 1084 int tinyportals; 1085 vec3_t referencepoint; 1086 1087 /* leafs only */ 1088 qboolean opaque; /* view can never be inside */ 1089 qboolean areaportal; 1090 qboolean skybox; /* ydnar: a skybox leaf */ 1091 qboolean sky; /* ydnar: a sky leaf */ 1092 int cluster; /* for portalfile writing */ 1093 int area; /* for areaportals */ 1094 brush_t *brushlist; /* fragments of all brushes in this leaf */ 1095 drawSurfRef_t *drawSurfReferences; 1096 1097 int occupied; /* 1 or greater can reach entity */ 1098 entity_t *occupant; /* for leak file testing */ 1099 1100 struct portal_s *portals; /* also on nodes during construction */ 1101 } 1102 node_t; 1103 1104 1105 typedef struct portal_s 1106 { 1107 plane_t plane; 1108 node_t *onnode; /* NULL = outside box */ 1109 node_t *nodes[ 2 ]; /* [ 0 ] = front side of plane */ 1110 struct portal_s *next[ 2 ]; 1111 winding_t *winding; 1112 1113 qboolean sidefound; /* false if ->side hasn't been checked */ 1114 int compileFlags; /* from original face that caused the split */ 1115 side_t *side; /* NULL = non-visible */ 1116 } 1117 portal_t; 1118 1119 1120 typedef struct 1121 { 1122 node_t *headnode; 1123 node_t outside_node; 1124 vec3_t mins, maxs; 1125 } 1126 tree_t; 1127 1128 1129 1130 /* ------------------------------------------------------------------------------- 1131 1132 vis structures 1133 1134 ------------------------------------------------------------------------------- */ 1135 1136 typedef struct 1137 { 1138 vec3_t normal; 1139 float dist; 1140 } 1141 visPlane_t; 1142 1143 1144 typedef struct 1145 { 1146 int numpoints; 1147 vec3_t points[ MAX_POINTS_ON_FIXED_WINDING ]; /* variable sized */ 1148 } 1149 fixedWinding_t; 1150 1151 1152 typedef struct passage_s 1153 { 1154 struct passage_s *next; 1155 byte cansee[ 1 ]; /* all portals that can be seen through this passage */ 1156 } passage_t; 1157 1158 1159 typedef enum 1160 { 1161 stat_none, 1162 stat_working, 1163 stat_done 1164 } 1165 vstatus_t; 1166 1167 1168 typedef struct 1169 { 1170 int num; 1171 qboolean hint; /* true if this portal was created from a hint splitter */ 1172 qboolean removed; 1173 visPlane_t plane; /* normal pointing into neighbor */ 1174 int leaf; /* neighbor */ 1175 1176 vec3_t origin; /* for fast clip testing */ 1177 float radius; 1178 1179 fixedWinding_t *winding; 1180 vstatus_t status; 1181 byte *portalfront; /* [portals], preliminary */ 1182 byte *portalflood; /* [portals], intermediate */ 1183 byte *portalvis; /* [portals], final */ 1184 1185 int nummightsee; /* bit count on portalflood for sort */ 1186 passage_t *passages; /* there are just as many passages as there */ 1187 /* are portals in the leaf this portal leads */ 1188 } 1189 vportal_t; 1190 1191 1192 typedef struct leaf_s 1193 { 1194 int numportals; 1195 int merged; 1196 vportal_t *portals[MAX_PORTALS_ON_LEAF]; 1197 } 1198 leaf_t; 1199 1200 1201 typedef struct pstack_s 1202 { 1203 byte mightsee[ MAX_PORTALS / 8 ]; 1204 struct pstack_s *next; 1205 leaf_t *leaf; 1206 vportal_t *portal; /* portal exiting */ 1207 fixedWinding_t *source; 1208 fixedWinding_t *pass; 1209 1210 fixedWinding_t windings[ 3 ]; /* source, pass, temp in any order */ 1211 int freewindings[ 3 ]; 1212 1213 visPlane_t portalplane; 1214 int depth; 1215 #ifdef SEPERATORCACHE 1216 visPlane_t seperators[ 2 ][ MAX_SEPERATORS ]; 1217 int numseperators[ 2 ]; 1218 #endif 1219 } 1220 pstack_t; 1221 1222 1223 typedef struct 1224 { 1225 vportal_t *base; 1226 int c_chains; 1227 pstack_t pstack_head; 1228 } 1229 threaddata_t; 1230 1231 1232 1233 /* ------------------------------------------------------------------------------- 1234 1235 light structures 1236 1237 ------------------------------------------------------------------------------- */ 1238 1239 /* ydnar: new light struct with flags */ 1240 typedef struct light_s 1241 { 1242 struct light_s *next; 1243 1244 int type; 1245 int flags; /* ydnar: condensed all the booleans into one flags int */ 1246 shaderInfo_t *si; 1247 1248 vec3_t origin; 1249 vec3_t normal; /* for surfaces, spotlights, and suns */ 1250 float dist; /* plane location along normal */ 1251 1252 float photons; 1253 int style; 1254 vec3_t color; 1255 float radiusByDist; /* for spotlights */ 1256 float fade; /* ydnar: from wolf, for linear lights */ 1257 float angleScale; /* ydnar: stolen from vlight for K */ 1258 1259 float add; /* ydnar: used for area lights */ 1260 float envelope; /* ydnar: units until falloff < tolerance */ 1261 float envelope2; /* ydnar: envelope squared (tiny optimization) */ 1262 vec3_t mins, maxs; /* ydnar: pvs envelope */ 1263 int cluster; /* ydnar: cluster light falls into */ 1264 1265 winding_t *w; 1266 vec3_t emitColor; /* full out-of-gamut value */ 1267 1268 float falloffTolerance; /* ydnar: minimum attenuation threshold */ 1269 float filterRadius; /* ydnar: lightmap filter radius in world units, 0 == default */ 1270 } 1271 light_t; 1272 1273 1274 typedef struct 1275 { 1276 /* constant input */ 1277 qboolean testOcclusion, forceSunlight, testAll; 1278 int recvShadows; 1279 1280 int numSurfaces; 1281 int *surfaces; 1282 1283 int numLights; 1284 light_t **lights; 1285 1286 qboolean twoSided; 1287 1288 /* per-sample input */ 1289 int cluster; 1290 vec3_t origin, normal; 1291 vec_t inhibitRadius; /* sphere in which occluding geometry is ignored */ 1292 1293 /* per-light input */ 1294 light_t *light; 1295 vec3_t end; 1296 1297 /* calculated input */ 1298 vec3_t displacement, direction; 1299 vec_t distance; 1300 1301 /* input and output */ 1302 vec3_t color; /* starts out at full color, may be reduced if transparent surfaces are crossed */ 1303 1304 /* output */ 1305 vec3_t hit; 1306 int compileFlags; /* for determining surface compile flags traced through */ 1307 qboolean passSolid; 1308 qboolean opaque; 1309 1310 /* working data */ 1311 int numTestNodes; 1312 int testNodes[ MAX_TRACE_TEST_NODES ]; 1313 } 1314 trace_t; 1315 1316 1317 1318 /* must be identical to bspDrawVert_t except for float color! */ 1319 typedef struct 1320 { 1321 vec3_t xyz; 1322 float st[ 2 ]; 1323 float lightmap[ MAX_LIGHTMAPS ][ 2 ]; 1324 vec3_t normal; 1325 float color[ MAX_LIGHTMAPS ][ 4 ]; 1326 } 1327 radVert_t; 1328 1329 1330 typedef struct 1331 { 1332 int numVerts; 1333 radVert_t verts[ MAX_POINTS_ON_WINDING ]; 1334 } 1335 radWinding_t; 1336 1337 1338 /* crutch for poor local allocations in win32 smp */ 1339 typedef struct 1340 { 1341 vec_t dists[ MAX_POINTS_ON_WINDING + 4 ]; 1342 int sides[ MAX_POINTS_ON_WINDING + 4 ]; 1343 } 1344 clipWork_t; 1345 1346 1347 /* ydnar: new lightmap handling code */ 1348 typedef struct outLightmap_s 1349 { 1350 int lightmapNum, extLightmapNum; 1351 int customWidth, customHeight; 1352 int numLightmaps; 1353 int freeLuxels; 1354 int numShaders; 1355 shaderInfo_t *shaders[ MAX_LIGHTMAP_SHADERS ]; 1356 byte *lightBits; 1357 byte *bspLightBytes; 1358 byte *bspDirBytes; 1359 } 1360 outLightmap_t; 1361 1362 1363 typedef struct rawLightmap_s 1364 { 1365 qboolean finished, splotchFix, wrap[ 2 ]; 1366 int customWidth, customHeight; 1367 float brightness; 1368 float filterRadius; 1369 1370 int firstLightSurface, numLightSurfaces; /* index into lightSurfaces */ 1371 int numLightClusters, *lightClusters; 1372 1373 int sampleSize, actualSampleSize, axisNum; 1374 int entityNum; 1375 int recvShadows; 1376 vec3_t mins, maxs, axis, origin, *vecs; 1377 float *plane; 1378 int w, h, sw, sh, used; 1379 1380 qboolean solid[ MAX_LIGHTMAPS ]; 1381 vec3_t solidColor[ MAX_LIGHTMAPS ]; 1382 1383 int numStyledTwins; 1384 struct rawLightmap_s *twins[ MAX_LIGHTMAPS ]; 1385 1386 int outLightmapNums[ MAX_LIGHTMAPS ]; 1387 int twinNums[ MAX_LIGHTMAPS ]; 1388 int lightmapX[ MAX_LIGHTMAPS ], lightmapY[ MAX_LIGHTMAPS ]; 1389 byte styles[ MAX_LIGHTMAPS ]; 1390 float *bspLuxels[ MAX_LIGHTMAPS ]; 1391 float *radLuxels[ MAX_LIGHTMAPS ]; 1392 float *superLuxels[ MAX_LIGHTMAPS ]; 1393 float *superOrigins; 1394 float *superNormals; 1395 int *superClusters; 1396 1397 float *superDeluxels; /* average light direction */ 1398 float *bspDeluxels; 1399 } 1400 rawLightmap_t; 1401 1402 1403 typedef struct rawGridPoint_s 1404 { 1405 vec3_t ambient[ MAX_LIGHTMAPS ]; 1406 vec3_t directed[ MAX_LIGHTMAPS ]; 1407 vec3_t dir; 1408 byte styles[ MAX_LIGHTMAPS ]; 1409 } 1410 rawGridPoint_t; 1411 1412 1413 typedef struct surfaceInfo_s 1414 { 1415 bspModel_t *model; 1416 shaderInfo_t *si; 1417 rawLightmap_t *lm; 1418 int parentSurfaceNum, childSurfaceNum; 1419 int entityNum, castShadows, recvShadows, sampleSize, patchIterations; 1420 float longestCurve; 1421 float *plane; 1422 vec3_t axis, mins, maxs; 1423 qboolean hasLightmap, approximated; 1424 int firstSurfaceCluster, numSurfaceClusters; 1425 } 1426 surfaceInfo_t; 1427 1428 1429 1430 /* ------------------------------------------------------------------------------- 1431 1432 prototypes 1433 1434 ------------------------------------------------------------------------------- */ 1435 1436 /* main.c */ 1437 vec_t Random( void ); 1438 int BSPInfo( int count, char **fileNames ); 1439 int ScaleBSPMain( int argc, char **argv ); 1440 int ConvertMain( int argc, char **argv ); 1441 1442 1443 /* path_init.c */ 1444 game_t *GetGame( char *arg ); 1445 void InitPaths( int *argc, char **argv ); 1446 1447 1448 /* bsp.c */ 1449 int BSPMain( int argc, char **argv ); 1450 1451 1452 /* convert_map.c */ 1453 int ConvertBSPToMap( char *bspName ); 1454 1455 1456 /* convert_ase.c */ 1457 int ConvertBSPToASE( char *bspName ); 1458 1459 1460 /* brush.c */ 1461 sideRef_t *AllocSideRef( side_t *side, sideRef_t *next ); 1462 int CountBrushList( brush_t *brushes ); 1463 brush_t *AllocBrush( int numsides ); 1464 void FreeBrush( brush_t *brushes ); 1465 void FreeBrushList( brush_t *brushes ); 1466 brush_t *CopyBrush( brush_t *brush ); 1467 qboolean BoundBrush( brush_t *brush ); 1468 qboolean CreateBrushWindings( brush_t *brush ); 1469 brush_t *BrushFromBounds( vec3_t mins, vec3_t maxs ); 1470 vec_t BrushVolume( brush_t *brush ); 1471 void WriteBSPBrushMap( char *name, brush_t *list ); 1472 1473 void FilterDetailBrushesIntoTree( entity_t *e, tree_t *tree ); 1474 void FilterStructuralBrushesIntoTree( entity_t *e, tree_t *tree ); 1475 1476 int BoxOnPlaneSide( vec3_t mins, vec3_t maxs, plane_t *plane ); 1477 qboolean WindingIsTiny( winding_t *w ); 1478 1479 void SplitBrush( brush_t *brush, int planenum, brush_t **front, brush_t **back); 1480 1481 tree_t *AllocTree( void ); 1482 node_t *AllocNode( void ); 1483 1484 1485 /* mesh.c */ 1486 void LerpDrawVert( bspDrawVert_t *a, bspDrawVert_t *b, bspDrawVert_t *out ); 1487 void LerpDrawVertAmount( bspDrawVert_t *a, bspDrawVert_t *b, float amount, bspDrawVert_t *out ); 1488 void FreeMesh( mesh_t *m ); 1489 mesh_t *CopyMesh( mesh_t *mesh ); 1490 void PrintMesh( mesh_t *m ); 1491 mesh_t *TransposeMesh( mesh_t *in ); 1492 void InvertMesh( mesh_t *m ); 1493 mesh_t *SubdivideMesh( mesh_t in, float maxError, float minLength ); 1494 int IterationsForCurve( float len, int subdivisions ); 1495 mesh_t *SubdivideMesh2( mesh_t in, int iterations ); 1496 mesh_t *SubdivideMeshQuads( mesh_t *in, float minLength, int maxsize, int *widthtable, int *heighttable ); 1497 mesh_t *RemoveLinearMeshColumnsRows( mesh_t *in ); 1498 void MakeMeshNormals( mesh_t in ); 1499 void PutMeshOnCurve( mesh_t in ); 1500 1501 void MakeNormalVectors( vec3_t forward, vec3_t right, vec3_t up ); 1502 1503 1504 /* map.c */ 1505 void LoadMapFile( char *filename, qboolean onlyLights ); 1506 int FindFloatPlane( vec3_t normal, vec_t dist, int numPoints, vec3_t *points ); 1507 int PlaneTypeForNormal( vec3_t normal ); 1508 void AddBrushBevels( void ); 1509 brush_t *FinishBrush( void ); 1510 1511 1512 /* portals.c */ 1513 void MakeHeadnodePortals( tree_t *tree ); 1514 void MakeNodePortal( node_t *node ); 1515 void SplitNodePortals( node_t *node ); 1516 1517 qboolean PortalPassable( portal_t *p ); 1518 1519 qboolean FloodEntities( tree_t *tree ); 1520 void FillOutside( node_t *headnode); 1521 void FloodAreas( tree_t *tree); 1522 face_t *VisibleFaces( entity_t *e, tree_t *tree ); 1523 void FreePortal( portal_t *p ); 1524 1525 void MakeTreePortals( tree_t *tree ); 1526 1527 1528 /* leakfile.c */ 1529 xmlNodePtr LeakFile( tree_t *tree ); 1530 1531 1532 /* prtfile.c */ 1533 void NumberClusters( tree_t *tree ); 1534 void WritePortalFile( tree_t *tree ); 1535 1536 1537 /* writebsp.c */ 1538 void SetModelNumbers( void ); 1539 void SetLightStyles( void ); 1540 1541 int EmitShader( const char *shader, int *contentFlags, int *surfaceFlags ); 1542 1543 void BeginBSPFile( void ); 1544 void EndBSPFile( void ); 1545 void EmitBrushes( brush_t *brushes, int *firstBrush, int *numBrushes ); 1546 void EmitFogs( void ); 1547 1548 void BeginModel( void ); 1549 void EndModel( entity_t *e, node_t *headnode ); 1550 1551 1552 /* tree.c */ 1553 void FreeTree( tree_t *tree ); 1554 void FreeTree_r( node_t *node ); 1555 void PrintTree_r( node_t *node, int depth ); 1556 void FreeTreePortals_r( node_t *node ); 1557 1558 1559 /* patch.c */ 1560 void ParsePatch( qboolean onlyLights ); 1561 mesh_t *SubdivideMesh( mesh_t in, float maxError, float minLength ); 1562 void PatchMapDrawSurfs( entity_t *e ); 1563 1564 1565 /* tjunction.c */ 1566 void FixTJunctions( entity_t *e ); 1567 1568 1569 /* fog.c */ 1570 winding_t *WindingFromDrawSurf( mapDrawSurface_t *ds ); 1571 void FogDrawSurfaces( entity_t *e ); 1572 int FogForPoint( vec3_t point, float epsilon ); 1573 int FogForBounds( vec3_t mins, vec3_t maxs, float epsilon ); 1574 void CreateMapFogs( void ); 1575 1576 1577 /* facebsp.c */ 1578 face_t *MakeStructuralBSPFaceList( brush_t *list ); 1579 face_t *MakeVisibleBSPFaceList( brush_t *list ); 1580 tree_t *FaceBSP( face_t *list ); 1581 1582 1583 /* model.c */ 1584 void PicoPrintFunc( int level, const char *str ); 1585 void PicoLoadFileFunc( char *name, byte **buffer, int *bufSize ); 1586 picoModel_t *FindModel( char *name, int frame ); 1587 picoModel_t *LoadModel( char *name, int frame ); 1588 void InsertModel( char *name, int frame, m4x4_t transform, remap_t *remap, shaderInfo_t *celShader, int eNum, int castShadows, int recvShadows, int spawnFlags, float lightmapScale ); 1589 void AddTriangleModels( entity_t *e ); 1590 1591 1592 /* surface.c */ 1593 mapDrawSurface_t *AllocDrawSurface( surfaceType_t type ); 1594 void FinishSurface( mapDrawSurface_t *ds ); 1595 void StripFaceSurface( mapDrawSurface_t *ds ); 1596 qboolean CalcSurfaceTextureRange( mapDrawSurface_t *ds ); 1597 qboolean CalcLightmapAxis( vec3_t normal, vec3_t axis ); 1598 void ClassifySurfaces( int numSurfs, mapDrawSurface_t *ds ); 1599 void ClassifyEntitySurfaces( entity_t *e ); 1600 void TidyEntitySurfaces( entity_t *e ); 1601 mapDrawSurface_t *CloneSurface( mapDrawSurface_t *src, shaderInfo_t *si ); 1602 mapDrawSurface_t *MakeCelSurface( mapDrawSurface_t *src, shaderInfo_t *si ); 1603 qboolean IsTriangleDegenerate( bspDrawVert_t *points, int a, int b, int c ); 1604 void ClearSurface( mapDrawSurface_t *ds ); 1605 void AddEntitySurfaceModels( entity_t *e ); 1606 mapDrawSurface_t *DrawSurfaceForSide( entity_t *e, brush_t *b, side_t *s, winding_t *w ); 1607 mapDrawSurface_t *DrawSurfaceForMesh( entity_t *e, parseMesh_t *p, mesh_t *mesh ); 1608 mapDrawSurface_t *DrawSurfaceForFlare( int entNum, vec3_t origin, vec3_t normal, vec3_t color, char *flareShader, int lightStyle ); 1609 mapDrawSurface_t *DrawSurfaceForShader( char *shader ); 1610 void ClipSidesIntoTree( entity_t *e, tree_t *tree ); 1611 void MakeDebugPortalSurfs( tree_t *tree ); 1612 void MakeFogHullSurfs( entity_t *e, tree_t *tree, char *shader ); 1613 void SubdivideFaceSurfaces( entity_t *e, tree_t *tree ); 1614 void AddEntitySurfaceModels( entity_t *e ); 1615 int AddSurfaceModels( mapDrawSurface_t *ds ); 1616 void FilterDrawsurfsIntoTree( entity_t *e, tree_t *tree ); 1617 1618 1619 /* surface_fur.c */ 1620 void Fur( mapDrawSurface_t *src ); 1621 1622 1623 /* surface_foliage.c */ 1624 void Foliage( mapDrawSurface_t *src ); 1625 1626 1627 /* ydnar: surface_meta.c */ 1628 void ClearMetaTriangles( void ); 1629 int FindMetaTriangle( metaTriangle_t *src, bspDrawVert_t *a, bspDrawVert_t *b, bspDrawVert_t *c, int planeNum ); 1630 void MakeEntityMetaTriangles( entity_t *e ); 1631 void FixMetaTJunctions( void ); 1632 void SmoothMetaTriangles( void ); 1633 void MergeMetaTriangles( void ); 1634 1635 1636 /* surface_extra.c */ 1637 void SetDefaultSampleSize( int sampleSize ); 1638 1639 void SetSurfaceExtra( mapDrawSurface_t *ds, int num ); 1640 1641 shaderInfo_t *GetSurfaceExtraShaderInfo( int num ); 1642 int GetSurfaceExtraParentSurfaceNum( int num ); 1643 int GetSurfaceExtraEntityNum( int num ); 1644 int GetSurfaceExtraCastShadows( int num ); 1645 int GetSurfaceExtraRecvShadows( int num ); 1646 int GetSurfaceExtraSampleSize( int num ); 1647 float GetSurfaceExtraLongestCurve( int num ); 1648 void GetSurfaceExtraLightmapAxis( int num, vec3_t lightmapAxis ); 1649 1650 void WriteSurfaceExtraFile( const char *path ); 1651 void LoadSurfaceExtraFile( const char *path ); 1652 1653 1654 /* decals.c */ 1655 void ProcessDecals( void ); 1656 void MakeEntityDecals( entity_t *e ); 1657 1658 1659 /* brush_primit.c */ 1660 void ComputeAxisBase( vec3_t normal, vec3_t texX, vec3_t texY); 1661 1662 1663 /* vis.c */ 1664 fixedWinding_t *NewFixedWinding( int points ); 1665 int VisMain( int argc, char **argv ); 1666 1667 /* visflow.c */ 1668 int CountBits( byte *bits, int numbits ); 1669 void PassageFlow( int portalnum ); 1670 void CreatePassages( int portalnum ); 1671 void PassageMemory( void ); 1672 void BasePortalVis( int portalnum ); 1673 void BetterPortalVis( int portalnum ); 1674 void PortalFlow( int portalnum ); 1675 void PassagePortalFlow( int portalnum ); 1676 1677 1678 1679 /* light.c */ 1680 float PointToPolygonFormFactor( const vec3_t point, const vec3_t normal, const winding_t *w ); 1681 int LightContributionToSample( trace_t *trace ); 1682 void LightingAtSample( trace_t *trace, byte styles[ MAX_LIGHTMAPS ], vec3_t colors[ MAX_LIGHTMAPS ] ); 1683 int LightContributionToPoint( trace_t *trace ); 1684 int LightMain( int argc, char **argv ); 1685 1686 1687 /* light_trace.c */ 1688 void SetupTraceNodes( void ); 1689 void TraceLine( trace_t *trace ); 1690 float SetupTrace( trace_t *trace ); 1691 1692 1693 /* light_bounce.c */ 1694 qboolean RadSampleImage( byte *pixels, int width, int height, float st[ 2 ], float color[ 4 ] ); 1695 void RadLightForTriangles( int num, int lightmapNum, rawLightmap_t *lm, shaderInfo_t *si, float scale, float subdivide, clipWork_t *cw ); 1696 void RadLightForPatch( int num, int lightmapNum, rawLightmap_t *lm, shaderInfo_t *si, float scale, float subdivide, clipWork_t *cw ); 1697 void RadCreateDiffuseLights( void ); 1698 void RadFreeLights(); 1699 1700 1701 /* light_ydnar.c */ 1702 void ColorToBytes( const float *color, byte *colorBytes, float scale ); 1703 void SmoothNormals( void ); 1704 1705 void MapRawLightmap( int num ); 1706 1707 void SetupDirt(); 1708 float DirtForSample( trace_t *trace ); 1709 void DirtyRawLightmap( int num ); 1710 1711 void IlluminateRawLightmap( int num ); 1712 void IlluminateVertexes( int num ); 1713 1714 void SetupBrushes( void ); 1715 void SetupClusters( void ); 1716 qboolean ClusterVisible( int a, int b ); 1717 qboolean ClusterVisibleToPoint( vec3_t point, int cluster ); 1718 int ClusterForPoint( vec3_t point ); 1719 int ClusterForPointExt( vec3_t point, float epsilon ); 1720 int ClusterForPointExtFilter( vec3_t point, float epsilon, int numClusters, int *clusters ); 1721 int ShaderForPointInLeaf( vec3_t point, int leafNum, float epsilon, int wantContentFlags, int wantSurfaceFlags, int *contentFlags, int *surfaceFlags ); 1722 void SetupEnvelopes( qboolean forGrid, qboolean fastFlag ); 1723 void FreeTraceLights( trace_t *trace ); 1724 void CreateTraceLightsForBounds( vec3_t mins, vec3_t maxs, vec3_t normal, int numClusters, int *clusters, int flags, trace_t *trace ); 1725 void CreateTraceLightsForSurface( int num, trace_t *trace ); 1726 1727 1728 /* lightmaps_ydnar.c */ 1729 void ExportLightmaps( void ); 1730 1731 int ExportLightmapsMain( int argc, char **argv ); 1732 int ImportLightmapsMain( int argc, char **argv ); 1733 1734 void SetupSurfaceLightmaps( void ); 1735 void StitchSurfaceLightmaps( void ); 1736 void StoreSurfaceLightmaps( void ); 1737 1738 1739 /* image.c */ 1740 void ImageFree( image_t *image ); 1741 image_t *ImageFind( const char *filename ); 1742 image_t *ImageLoad( const char *filename ); 1743 1744 1745 /* shaders.c */ 1746 void ColorMod( colorMod_t *am, int numVerts, bspDrawVert_t *drawVerts ); 1747 1748 void TCMod( tcMod_t mod, float st[ 2 ] ); 1749 void TCModIdentity( tcMod_t mod ); 1750 void TCModMultiply( tcMod_t a, tcMod_t b, tcMod_t out ); 1751 void TCModTranslate( tcMod_t mod, float s, float t ); 1752 void TCModScale( tcMod_t mod, float s, float t ); 1753 void TCModRotate( tcMod_t mod, float euler ); 1754 1755 qboolean ApplySurfaceParm( char *name, int *contentFlags, int *surfaceFlags, int *compileFlags ); 1756 1757 void BeginMapShaderFile( const char *mapFile ); 1758 void WriteMapShaderFile( void ); 1759 shaderInfo_t *CustomShader( shaderInfo_t *si, char *find, char *replace ); 1760 void EmitVertexRemapShader( char *from, char *to ); 1761 1762 void LoadShaderInfo( void ); 1763 shaderInfo_t *ShaderInfoForShader( const char *shader ); 1764 1765 1766 /* bspfile_abstract.c */ 1767 void SetGridPoints( int n ); 1768 void SetDrawVerts( int n ); 1769 void IncDrawVerts(); 1770 void SetDrawSurfaces(int n); 1771 void SetDrawSurfacesBuffer(); 1772 void BSPFilesCleanup(); 1773 1774 void SwapBlock( int *block, int size ); 1775 1776 int GetLumpElements( bspHeader_t *header, int lump, int size ); 1777 void *GetLump( bspHeader_t *header, int lump ); 1778 int CopyLump( bspHeader_t *header, int lump, void *dest, int size ); 1779 void AddLump( FILE *file, bspHeader_t *header, int lumpNum, const void *data, int length ); 1780 1781 void LoadBSPFile( const char *filename ); 1782 void WriteBSPFile( const char *filename ); 1783 void PrintBSPFileSizes( void ); 1784 1785 epair_t *ParseEPair( void ); 1786 void ParseEntities( void ); 1787 void UnparseEntities( void ); 1788 void PrintEntity( const entity_t *ent ); 1789 void SetKeyValue( entity_t *ent, const char *key, const char *value ); 1790 const char *ValueForKey( const entity_t *ent, const char *key ); 1791 int IntForKey( const entity_t *ent, const char *key ); 1792 vec_t FloatForKey( const entity_t *ent, const char *key ); 1793 void GetVectorForKey( const entity_t *ent, const char *key, vec3_t vec ); 1794 entity_t *FindTargetEntity( const char *target ); 1795 void GetEntityShadowFlags( const entity_t *ent, const entity_t *ent2, int *castShadows, int *recvShadows ); 1796 1797 1798 /* bspfile_ibsp.c */ 1799 void LoadIBSPFile( const char *filename ); 1800 void WriteIBSPFile( const char *filename ); 1801 1802 1803 /* bspfile_rbsp.c */ 1804 void LoadRBSPFile( const char *filename ); 1805 void WriteRBSPFile( const char *filename ); 1806 1807 1808 1809 /* ------------------------------------------------------------------------------- 1810 1811 bsp/general global variables 1812 1813 ------------------------------------------------------------------------------- */ 1814 1815 #ifdef MAIN_C 1816 #define Q_EXTERN 1817 #define Q_ASSIGN( a ) = a 1818 #else 1819 #define Q_EXTERN extern 1820 #define Q_ASSIGN( a ) 1821 #endif 1822 1823 /* game support */ 1824 Q_EXTERN game_t games[] 1825 #ifndef MAIN_C 1826 ; 1827 #else 1828 = 1829 { 1830 #include "game_quake3.h" 1831 , 1832 #include "game_tenebrae.h" 1833 , 1834 #include "game_wolf.h" 1835 , 1836 #include "game_wolfet.h"/* most be after game_wolf.h as they share defines! */ 1837 , 1838 #include "game_etut.h" 1839 , 1840 #include "game_ef.h" 1841 , 1842 #include "game_sof2.h" 1843 , 1844 #include "game_jk2.h" /* most be after game_sof2.h as they share defines! */ 1845 , 1846 #include "game_ja.h" /* most be after game_jk2.h as they share defines! */ 1847 , 1848 { NULL } /* null game */ 1849 }; 1850 #endif 1851 Q_EXTERN game_t *game Q_ASSIGN( &games[ 0 ] ); 1852 1853 1854 /* general */ 1855 Q_EXTERN int numImages Q_ASSIGN( 0 ); 1856 Q_EXTERN image_t images[ MAX_IMAGES ]; 1857 1858 Q_EXTERN int numPicoModels Q_ASSIGN( 0 ); 1859 Q_EXTERN picoModel_t *picoModels[ MAX_MODELS ]; 1860 1861 Q_EXTERN shaderInfo_t *shaderInfo Q_ASSIGN( NULL ); 1862 Q_EXTERN int numShaderInfo Q_ASSIGN( 0 ); 1863 Q_EXTERN int numVertexRemaps Q_ASSIGN( 0 ); 1864 1865 Q_EXTERN surfaceParm_t custSurfaceParms[ MAX_CUST_SURFACEPARMS ]; 1866 Q_EXTERN int numCustSurfaceParms Q_ASSIGN( 0 ); 1867 1868 Q_EXTERN char mapName[ MAX_QPATH ]; /* ydnar: per-map custom shaders for larger lightmaps */ 1869 Q_EXTERN char mapShaderFile[ 1024 ]; 1870 Q_EXTERN qboolean warnImage Q_ASSIGN( qtrue ); 1871 1872 /* ydnar: sinusoid samples */ 1873 Q_EXTERN float jitters[ MAX_JITTERS ]; 1874 1875 1876 /* commandline arguments */ 1877 Q_EXTERN qboolean verboseEntities Q_ASSIGN( qfalse ); 1878 Q_EXTERN qboolean force Q_ASSIGN( qfalse ); 1879 Q_EXTERN qboolean infoMode Q_ASSIGN( qfalse ); 1880 Q_EXTERN qboolean useCustomInfoParms Q_ASSIGN( qfalse ); 1881 Q_EXTERN qboolean noprune Q_ASSIGN( qfalse ); 1882 Q_EXTERN qboolean leaktest Q_ASSIGN( qfalse ); 1883 Q_EXTERN qboolean nodetail Q_ASSIGN( qfalse ); 1884 Q_EXTERN qboolean nosubdivide Q_ASSIGN( qfalse ); 1885 Q_EXTERN qboolean notjunc Q_ASSIGN( qfalse ); 1886 Q_EXTERN qboolean fulldetail Q_ASSIGN( qfalse ); 1887 Q_EXTERN qboolean nowater Q_ASSIGN( qfalse ); 1888 Q_EXTERN qboolean noCurveBrushes Q_ASSIGN( qfalse ); 1889 Q_EXTERN qboolean fakemap Q_ASSIGN( qfalse ); 1890 Q_EXTERN qboolean coplanar Q_ASSIGN( qfalse ); 1891 Q_EXTERN qboolean nofog Q_ASSIGN( qfalse ); 1892 Q_EXTERN qboolean noHint Q_ASSIGN( qfalse ); /* ydnar */ 1893 Q_EXTERN qboolean renameModelShaders Q_ASSIGN( qfalse ); /* ydnar */ 1894 Q_EXTERN qboolean skyFixHack Q_ASSIGN( qfalse ); /* ydnar */ 1895 1896 Q_EXTERN int patchSubdivisions Q_ASSIGN( 8 ); /* ydnar: -patchmeta subdivisions */ 1897 1898 Q_EXTERN int maxLMSurfaceVerts Q_ASSIGN( 64 ); /* ydnar */ 1899 Q_EXTERN int maxSurfaceVerts Q_ASSIGN( 999 ); /* ydnar */ 1900 Q_EXTERN int maxSurfaceIndexes Q_ASSIGN( 6000 ); /* ydnar */ 1901 Q_EXTERN float npDegrees Q_ASSIGN( 0.0f ); /* ydnar: nonplanar degrees */ 1902 Q_EXTERN int bevelSnap Q_ASSIGN( 0 ); /* ydnar: bevel plane snap */ 1903 Q_EXTERN int texRange Q_ASSIGN( 0 ); 1904 Q_EXTERN qboolean flat Q_ASSIGN( qfalse ); 1905 Q_EXTERN qboolean meta Q_ASSIGN( qfalse ); 1906 Q_EXTERN qboolean patchMeta Q_ASSIGN( qfalse ); 1907 Q_EXTERN qboolean emitFlares Q_ASSIGN( qfalse ); 1908 Q_EXTERN qboolean debugSurfaces Q_ASSIGN( qfalse ); 1909 Q_EXTERN qboolean debugInset Q_ASSIGN( qfalse ); 1910 Q_EXTERN qboolean debugPortals Q_ASSIGN( qfalse ); 1911 1912 Q_EXTERN double normalEpsilon Q_ASSIGN( 0.00001 ); 1913 Q_EXTERN double distanceEpsilon Q_ASSIGN( 0.01 ); 1914 1915 1916 /* bsp */ 1917 Q_EXTERN int numMapEntities Q_ASSIGN( 0 ); 1918 1919 Q_EXTERN int blockSize[ 3 ] /* should be the same as in radiant */ 1920 #ifndef MAIN_C 1921 ; 1922 #else 1923 = { 1024, 1024, 1024 }; 1924 #endif 1925 1926 Q_EXTERN char name[ 1024 ]; 1927 Q_EXTERN char source[ 1024 ]; 1928 Q_EXTERN char outbase[ 32 ]; 1929 1930 Q_EXTERN int sampleSize; /* lightmap sample size in units */ 1931 1932 Q_EXTERN int mapEntityNum Q_ASSIGN( 0 ); 1933 1934 Q_EXTERN int entitySourceBrushes; 1935 1936 Q_EXTERN plane_t mapplanes[ MAX_MAP_PLANES ]; /* mapplanes[ num ^ 1 ] will always be the mirror or mapplanes[ num ] */ 1937 Q_EXTERN int nummapplanes; /* nummapplanes will always be even */ 1938 Q_EXTERN int numMapPatches; 1939 Q_EXTERN vec3_t mapMins, mapMaxs; 1940 1941 Q_EXTERN int defaultFogNum Q_ASSIGN( -1 ); /* ydnar: cleaner fog handling */ 1942 Q_EXTERN int numMapFogs Q_ASSIGN( 0 ); 1943 Q_EXTERN fog_t mapFogs[ MAX_MAP_FOGS ]; 1944 1945 Q_EXTERN entity_t *mapEnt; 1946 Q_EXTERN brush_t *buildBrush; 1947 Q_EXTERN int numActiveBrushes; 1948 Q_EXTERN int g_bBrushPrimit; 1949 1950 Q_EXTERN int numStrippedLights Q_ASSIGN( 0 ); 1951 1952 1953 /* surface stuff */ 1954 Q_EXTERN mapDrawSurface_t *mapDrawSurfs Q_ASSIGN( NULL ); 1955 Q_EXTERN int numMapDrawSurfs; 1956 1957 Q_EXTERN int numSurfacesByType[ NUM_SURFACE_TYPES ]; 1958 Q_EXTERN int numClearedSurfaces; 1959 Q_EXTERN int numStripSurfaces; 1960 Q_EXTERN int numFanSurfaces; 1961 Q_EXTERN int numMergedSurfaces; 1962 Q_EXTERN int numMergedVerts; 1963 1964 Q_EXTERN int numRedundantIndexes; 1965 1966 Q_EXTERN int numSurfaceModels Q_ASSIGN( 0 ); 1967 1968 Q_EXTERN byte debugColors[ 12 ][ 3 ] 1969 #ifndef MAIN_C 1970 ; 1971 #else 1972 = 1973 { 1974 { 255, 0, 0 }, 1975 { 192, 128, 128 }, 1976 { 255, 255, 0 }, 1977 { 192, 192, 128 }, 1978 { 0, 255, 255 }, 1979 { 128, 192, 192 }, 1980 { 0, 0, 255 }, 1981 { 128, 128, 192 }, 1982 { 255, 0, 255 }, 1983 { 192, 128, 192 }, 1984 { 0, 255, 0 }, 1985 { 128, 192, 128 } 1986 }; 1987 #endif 1988 1989 Q_EXTERN qboolean skyboxPresent Q_ASSIGN( qfalse ); 1990 Q_EXTERN int skyboxArea Q_ASSIGN( -1 ); 1991 Q_EXTERN m4x4_t skyboxTransform; 1992 1993 1994 1995 /* ------------------------------------------------------------------------------- 1996 1997 vis global variables 1998 1999 ------------------------------------------------------------------------------- */ 2000 2001 /* commandline arguments */ 2002 Q_EXTERN qboolean fastvis; 2003 Q_EXTERN qboolean noPassageVis; 2004 Q_EXTERN qboolean passageVisOnly; 2005 Q_EXTERN qboolean mergevis; 2006 Q_EXTERN qboolean nosort; 2007 Q_EXTERN qboolean saveprt; 2008 Q_EXTERN qboolean hint; /* ydnar */ 2009 Q_EXTERN char inbase[ MAX_QPATH ]; 2010 2011 /* other bits */ 2012 Q_EXTERN int totalvis; 2013 2014 Q_EXTERN float farPlaneDist; /* rr2do2, rf, mre, ydnar all contributed to this one... */ 2015 2016 Q_EXTERN int numportals; 2017 Q_EXTERN int portalclusters; 2018 2019 Q_EXTERN vportal_t *portals; 2020 Q_EXTERN leaf_t *leafs; 2021 2022 Q_EXTERN vportal_t *faces; 2023 Q_EXTERN leaf_t *faceleafs; 2024 2025 Q_EXTERN int numfaces; 2026 2027 Q_EXTERN int c_portaltest, c_portalpass, c_portalcheck; 2028 Q_EXTERN int c_portalskip, c_leafskip; 2029 Q_EXTERN int c_vistest, c_mighttest; 2030 Q_EXTERN int c_chains; 2031 2032 Q_EXTERN byte *vismap, *vismap_p, *vismap_end; 2033 2034 Q_EXTERN int testlevel; 2035 2036 Q_EXTERN byte *uncompressed; 2037 2038 Q_EXTERN int leafbytes, leaflongs; 2039 Q_EXTERN int portalbytes, portallongs; 2040 2041 Q_EXTERN vportal_t *sorted_portals[ MAX_MAP_PORTALS * 2 ]; 2042 2043 2044 2045 /* ------------------------------------------------------------------------------- 2046 2047 light global variables 2048 2049 ------------------------------------------------------------------------------- */ 2050 2051 /* commandline arguments */ 2052 Q_EXTERN qboolean wolfLight Q_ASSIGN( qfalse ); 2053 Q_EXTERN qboolean loMem Q_ASSIGN( qfalse ); 2054 Q_EXTERN qboolean noStyles Q_ASSIGN( qfalse ); 2055 2056 Q_EXTERN int sampleSize Q_ASSIGN( DEFAULT_LIGHTMAP_SAMPLE_SIZE ); 2057 Q_EXTERN qboolean noVertexLighting Q_ASSIGN( qfalse ); 2058 Q_EXTERN qboolean noGridLighting Q_ASSIGN( qfalse ); 2059 2060 Q_EXTERN qboolean noTrace Q_ASSIGN( qfalse ); 2061 Q_EXTERN qboolean noSurfaces Q_ASSIGN( qfalse ); 2062 Q_EXTERN qboolean patchShadows Q_ASSIGN( qfalse ); 2063 Q_EXTERN qboolean cpmaHack Q_ASSIGN( qfalse ); 2064 2065 Q_EXTERN qboolean deluxemap Q_ASSIGN( qfalse ); 2066 Q_EXTERN qboolean debugDeluxemap Q_ASSIGN( qfalse ); 2067 2068 Q_EXTERN qboolean fast Q_ASSIGN( qfalse ); 2069 Q_EXTERN qboolean faster Q_ASSIGN( qfalse ); 2070 Q_EXTERN qboolean fastgrid Q_ASSIGN( qfalse ); 2071 Q_EXTERN qboolean fastbounce Q_ASSIGN( qfalse ); 2072 Q_EXTERN qboolean cheap Q_ASSIGN( qfalse ); 2073 Q_EXTERN qboolean cheapgrid Q_ASSIGN( qfalse ); 2074 Q_EXTERN int bounce Q_ASSIGN( 0 ); 2075 Q_EXTERN qboolean bounceOnly Q_ASSIGN( qfalse ); 2076 Q_EXTERN qboolean bouncing Q_ASSIGN( qfalse ); 2077 Q_EXTERN qboolean bouncegrid Q_ASSIGN( qfalse ); 2078 Q_EXTERN qboolean normalmap Q_ASSIGN( qfalse ); 2079 Q_EXTERN qboolean trisoup Q_ASSIGN( qfalse ); 2080 Q_EXTERN qboolean shade Q_ASSIGN( qfalse ); 2081 Q_EXTERN float shadeAngleDegrees Q_ASSIGN( 0.0f ); 2082 Q_EXTERN int superSample Q_ASSIGN( 0 ); 2083 Q_EXTERN int lightSamples Q_ASSIGN( 1 ); 2084 Q_EXTERN qboolean filter Q_ASSIGN( qfalse ); 2085 Q_EXTERN qboolean dark Q_ASSIGN( qfalse ); 2086 Q_EXTERN qboolean sunOnly Q_ASSIGN( qfalse ); 2087 Q_EXTERN int approximateTolerance Q_ASSIGN( 0 ); 2088 Q_EXTERN qboolean noCollapse Q_ASSIGN( qfalse ); 2089 Q_EXTERN qboolean exportLightmaps Q_ASSIGN( qfalse ); 2090 Q_EXTERN qboolean externalLightmaps Q_ASSIGN( qfalse ); 2091 Q_EXTERN int lmCustomSize Q_ASSIGN( LIGHTMAP_WIDTH ); 2092 2093 Q_EXTERN qboolean dirty Q_ASSIGN( qfalse ); 2094 Q_EXTERN qboolean dirtDebug Q_ASSIGN( qfalse ); 2095 Q_EXTERN int dirtMode Q_ASSIGN( 0 ); 2096 Q_EXTERN float dirtDepth Q_ASSIGN( 128.0f ); 2097 Q_EXTERN float dirtScale Q_ASSIGN( 1.0f ); 2098 Q_EXTERN float dirtGain Q_ASSIGN( 1.0f ); 2099 2100 Q_EXTERN qboolean dump Q_ASSIGN( qfalse ); 2101 Q_EXTERN qboolean debug Q_ASSIGN( qfalse ); 2102 Q_EXTERN qboolean debugUnused Q_ASSIGN( qfalse ); 2103 Q_EXTERN qboolean debugAxis Q_ASSIGN( qfalse ); 2104 Q_EXTERN qboolean debugCluster Q_ASSIGN( qfalse ); 2105 Q_EXTERN qboolean debugOrigin Q_ASSIGN( qfalse ); 2106 Q_EXTERN qboolean lightmapBorder Q_ASSIGN( qfalse ); 2107 2108 /* longest distance across the map */ 2109 Q_EXTERN float maxMapDistance Q_ASSIGN( 0 ); 2110 2111 /* for run time tweaking of light sources */ 2112 Q_EXTERN float pointScale Q_ASSIGN( 7500.0f ); 2113 Q_EXTERN float areaScale Q_ASSIGN( 0.25f ); 2114 Q_EXTERN float skyScale Q_ASSIGN( 1.0f ); 2115 Q_EXTERN float bounceScale Q_ASSIGN( 0.25f ); 2116 2117 /* ydnar: lightmap gamma/compensation */ 2118 Q_EXTERN float lightmapGamma Q_ASSIGN( 1.0f ); 2119 Q_EXTERN float lightmapCompensate Q_ASSIGN( 1.0f ); 2120 2121 /* ydnar: for runtime tweaking of falloff tolerance */ 2122 Q_EXTERN float falloffTolerance Q_ASSIGN( 1.0f ); 2123 Q_EXTERN qboolean exactPointToPolygon Q_ASSIGN( qtrue ); 2124 Q_EXTERN float formFactorValueScale Q_ASSIGN( 3.0f ); 2125 Q_EXTERN float linearScale Q_ASSIGN( 1.0f / 8000.0f ); 2126 2127 Q_EXTERN light_t *lights; 2128 Q_EXTERN int numPointLights; 2129 Q_EXTERN int numSpotLights; 2130 Q_EXTERN int numSunLights; 2131 Q_EXTERN int numAreaLights; 2132 2133 /* ydnar: for luxel placement */ 2134 Q_EXTERN int numSurfaceClusters, maxSurfaceClusters; 2135 Q_EXTERN int *surfaceClusters; 2136 2137 /* ydnar: for radiosity */ 2138 Q_EXTERN int numDiffuseLights; 2139 Q_EXTERN int numBrushDiffuseLights; 2140 Q_EXTERN int numTriangleDiffuseLights; 2141 Q_EXTERN int numPatchDiffuseLights; 2142 2143 /* ydnar: general purpose extra copy of drawvert list */ 2144 Q_EXTERN bspDrawVert_t *yDrawVerts; 2145 2146 /* ydnar: for tracing statistics */ 2147 Q_EXTERN int minSurfacesTested; 2148 Q_EXTERN int maxSurfacesTested; 2149 Q_EXTERN int totalSurfacesTested; 2150 Q_EXTERN int totalTraces; 2151 2152 Q_EXTERN FILE *dumpFile; 2153 2154 Q_EXTERN int c_visible, c_occluded; 2155 Q_EXTERN int c_subsampled; /* ydnar */ 2156 2157 Q_EXTERN int defaultLightSubdivide Q_ASSIGN( 999 ); 2158 2159 Q_EXTERN vec3_t ambientColor; 2160 Q_EXTERN vec3_t minLight, minVertexLight, minGridLight; 2161 2162 Q_EXTERN int *entitySurface; 2163 Q_EXTERN vec3_t *surfaceOrigin; 2164 2165 Q_EXTERN vec3_t sunDirection; 2166 Q_EXTERN vec3_t sunLight; 2167 2168 /* tracing */ 2169 Q_EXTERN int c_totalTrace; 2170 Q_EXTERN int c_cullTrace, c_testTrace; 2171 Q_EXTERN int c_testFacets; 2172 2173 /* ydnar: light optimization */ 2174 Q_EXTERN float subdivideThreshold Q_ASSIGN( DEFAULT_SUBDIVIDE_THRESHOLD ); 2175 2176 Q_EXTERN int numOpaqueBrushes, maxOpaqueBrush; 2177 Q_EXTERN byte *opaqueBrushes; 2178 2179 Q_EXTERN int numLights; 2180 Q_EXTERN int numCulledLights; 2181 2182 Q_EXTERN int gridBoundsCulled; 2183 Q_EXTERN int gridEnvelopeCulled; 2184 2185 Q_EXTERN int lightsBoundsCulled; 2186 Q_EXTERN int lightsEnvelopeCulled; 2187 Q_EXTERN int lightsPlaneCulled; 2188 Q_EXTERN int lightsClusterCulled; 2189 2190 /* ydnar: radiosity */ 2191 Q_EXTERN float diffuseSubdivide Q_ASSIGN( 256.0f ); 2192 Q_EXTERN float minDiffuseSubdivide Q_ASSIGN( 64.0f ); 2193 Q_EXTERN int numDiffuseSurfaces Q_ASSIGN( 0 ); 2194 2195 /* ydnar: list of surface information necessary for lightmap calculation */ 2196 Q_EXTERN surfaceInfo_t *surfaceInfos Q_ASSIGN( NULL ); 2197 2198 /* ydnar: sorted list of surfaces */ 2199 Q_EXTERN int *sortSurfaces Q_ASSIGN( NULL ); 2200 2201 /* clumps of surfaces that share a raw lightmap */ 2202 Q_EXTERN int numLightSurfaces Q_ASSIGN( 0 ); 2203 Q_EXTERN int *lightSurfaces Q_ASSIGN( NULL ); 2204 2205 /* raw lightmaps */ 2206 Q_EXTERN int numRawSuperLuxels Q_ASSIGN( 0 ); 2207 Q_EXTERN int numRawLightmaps Q_ASSIGN( 0 ); 2208 Q_EXTERN rawLightmap_t *rawLightmaps Q_ASSIGN( NULL ); 2209 Q_EXTERN int *sortLightmaps Q_ASSIGN( NULL ); 2210 2211 /* vertex luxels */ 2212 Q_EXTERN float *vertexLuxels[ MAX_LIGHTMAPS ]; 2213 Q_EXTERN float *radVertexLuxels[ MAX_LIGHTMAPS ]; 2214 2215 /* bsp lightmaps */ 2216 Q_EXTERN int numLightmapShaders Q_ASSIGN( 0 ); 2217 Q_EXTERN int numSolidLightmaps Q_ASSIGN( 0 ); 2218 Q_EXTERN int numOutLightmaps Q_ASSIGN( 0 ); 2219 Q_EXTERN int numBSPLightmaps Q_ASSIGN( 0 ); 2220 Q_EXTERN int numExtLightmaps Q_ASSIGN( 0 ); 2221 Q_EXTERN outLightmap_t *outLightmaps Q_ASSIGN( NULL ); 2222 2223 /* grid points */ 2224 Q_EXTERN int numRawGridPoints Q_ASSIGN( 0 ); 2225 Q_EXTERN rawGridPoint_t *rawGridPoints Q_ASSIGN( NULL ); 2226 2227 Q_EXTERN int numSurfsVertexLit Q_ASSIGN( 0 ); 2228 Q_EXTERN int numSurfsVertexForced Q_ASSIGN( 0 ); 2229 Q_EXTERN int numSurfsVertexApproximated Q_ASSIGN( 0 ); 2230 Q_EXTERN int numSurfsLightmapped Q_ASSIGN( 0 ); 2231 Q_EXTERN int numPlanarsLightmapped Q_ASSIGN( 0 ); 2232 Q_EXTERN int numNonPlanarsLightmapped Q_ASSIGN( 0 ); 2233 Q_EXTERN int numPatchesLightmapped Q_ASSIGN( 0 ); 2234 Q_EXTERN int numPlanarPatchesLightmapped Q_ASSIGN( 0 ); 2235 2236 Q_EXTERN int numLuxels Q_ASSIGN( 0 ); 2237 Q_EXTERN int numLuxelsMapped Q_ASSIGN( 0 ); 2238 Q_EXTERN int numLuxelsOccluded Q_ASSIGN( 0 ); 2239 Q_EXTERN int numLuxelsIlluminated Q_ASSIGN( 0 ); 2240 Q_EXTERN int numVertsIlluminated Q_ASSIGN( 0 ); 2241 2242 /* lightgrid */ 2243 Q_EXTERN vec3_t gridMins; 2244 Q_EXTERN int gridBounds[ 3 ]; 2245 Q_EXTERN vec3_t gridSize 2246 #ifndef MAIN_C 2247 ; 2248 #else 2249 = { 64, 64, 128 }; 2250 #endif 2251 2252 2253 2254 /* ------------------------------------------------------------------------------- 2255 2256 abstracted bsp globals 2257 2258 ------------------------------------------------------------------------------- */ 2259 2260 Q_EXTERN int numEntities Q_ASSIGN( 0 ); 2261 Q_EXTERN int numBSPEntities Q_ASSIGN( 0 ); 2262 Q_EXTERN entity_t entities[ MAX_MAP_ENTITIES ]; 2263 2264 Q_EXTERN int numBSPModels Q_ASSIGN( 0 ); 2265 Q_EXTERN bspModel_t bspModels[ MAX_MAP_MODELS ]; 2266 2267 Q_EXTERN int numBSPShaders Q_ASSIGN( 0 ); 2268 Q_EXTERN bspShader_t bspShaders[ MAX_MAP_MODELS ]; 2269 2270 Q_EXTERN int bspEntDataSize Q_ASSIGN( 0 ); 2271 Q_EXTERN char bspEntData[ MAX_MAP_ENTSTRING ]; 2272 2273 Q_EXTERN int numBSPLeafs Q_ASSIGN( 0 ); 2274 Q_EXTERN bspLeaf_t bspLeafs[ MAX_MAP_LEAFS ]; 2275 2276 Q_EXTERN int numBSPPlanes Q_ASSIGN( 0 ); 2277 Q_EXTERN bspPlane_t bspPlanes[ MAX_MAP_PLANES ]; 2278 2279 Q_EXTERN int numBSPNodes Q_ASSIGN( 0 ); 2280 Q_EXTERN bspNode_t bspNodes[ MAX_MAP_NODES ]; 2281 2282 Q_EXTERN int numBSPLeafSurfaces Q_ASSIGN( 0 ); 2283 Q_EXTERN int bspLeafSurfaces[ MAX_MAP_LEAFFACES ]; 2284 2285 Q_EXTERN int numBSPLeafBrushes Q_ASSIGN( 0 ); 2286 Q_EXTERN int bspLeafBrushes[ MAX_MAP_LEAFBRUSHES ]; 2287 2288 Q_EXTERN int numBSPBrushes Q_ASSIGN( 0 ); 2289 Q_EXTERN bspBrush_t bspBrushes[ MAX_MAP_BRUSHES ]; 2290 2291 Q_EXTERN int numBSPBrushSides Q_ASSIGN( 0 ); 2292 Q_EXTERN bspBrushSide_t bspBrushSides[ MAX_MAP_BRUSHSIDES ]; 2293 2294 Q_EXTERN int numBSPLightBytes Q_ASSIGN( 0 ); 2295 Q_EXTERN byte *bspLightBytes Q_ASSIGN( NULL ); 2296 2297 //% Q_EXTERN int numBSPGridPoints Q_ASSIGN( 0 ); 2298 //% Q_EXTERN byte *bspGridPoints Q_ASSIGN( NULL ); 2299 2300 Q_EXTERN int numBSPGridPoints Q_ASSIGN( 0 ); 2301 Q_EXTERN bspGridPoint_t *bspGridPoints Q_ASSIGN( NULL ); 2302 2303 Q_EXTERN int numBSPVisBytes Q_ASSIGN( 0 ); 2304 Q_EXTERN byte bspVisBytes[ MAX_MAP_VISIBILITY ]; 2305 2306 Q_EXTERN int numBSPDrawVerts Q_ASSIGN( 0 ); 2307 Q_EXTERN bspDrawVert_t *bspDrawVerts Q_ASSIGN( NULL ); 2308 2309 Q_EXTERN int numBSPDrawIndexes Q_ASSIGN( 0 ); 2310 Q_EXTERN int bspDrawIndexes[ MAX_MAP_DRAW_INDEXES ]; 2311 2312 Q_EXTERN int numBSPDrawSurfaces Q_ASSIGN( 0 ); 2313 Q_EXTERN bspDrawSurface_t *bspDrawSurfaces Q_ASSIGN( NULL ); 2314 2315 Q_EXTERN int numBSPFogs Q_ASSIGN( 0 ); 2316 Q_EXTERN bspFog_t bspFogs[ MAX_MAP_FOGS ]; 2317 2318 2319 2320 /* end marker */ 2321 #endif 2322