model_brush.c

   1 /*
   2 Copyright (C) 1996-1997 Id Software, Inc.
   3
   4 This program is free software; you can redistribute it and/or
   5 modify it under the terms of the GNU General Public License
   6 as published by the Free Software Foundation; either version 2
   7 of the License, or (at your option) any later version.
   8
   9 This program is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  12
  13 See the GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program; if not, write to the Free Software
  17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  18
  19 */
  20
  21 #include "quakedef.h"
  22 #include "image.h"
  23 #include "r_shadow.h"
  24 #include "polygon.h"
  25 #include "curves.h"
  26 #include "wad.h"
  27
  28
  29 //cvar_t r_subdivide_size = {CVAR_SAVE, "r_subdivide_size", "128", "how large water polygons should be (smaller values produce more polygons which give better warping effects)"};
  30 cvar_t halflifebsp = {0, "halflifebsp", "0", "indicates the current map is hlbsp format (useful to know because of different bounding box sizes)"};
  31 cvar_t mcbsp = {0, "mcbsp", "0", "indicates the current map is mcbsp format (useful to know because of different bounding box sizes)"};
  32 cvar_t r_novis = {0, "r_novis", "0", "draws whole level, see also sv_cullentities_pvs 0"};
  33 cvar_t r_lightmaprgba = {0, "r_lightmaprgba", "1", "whether to use RGBA (32bit) or RGB (24bit) lightmaps"};
  34 cvar_t r_nosurftextures = {0, "r_nosurftextures", "0", "pretends there was no texture lump found in the q1bsp/hlbsp loading (useful for debugging this rare case)"};
  35 cvar_t r_subdivisions_tolerance = {0, "r_subdivisions_tolerance", "4", "maximum error tolerance on curve subdivision for rendering purposes (in other words, the curves will be given as many polygons as necessary to represent curves at this quality)"};
  36 cvar_t r_subdivisions_mintess = {0, "r_subdivisions_mintess", "1", "minimum number of subdivisions (values above 1 will smooth curves that don't need it)"};
  37 cvar_t r_subdivisions_maxtess = {0, "r_subdivisions_maxtess", "1024", "maximum number of subdivisions (prevents curves beyond a certain detail level, limits smoothing)"};
  38 cvar_t r_subdivisions_maxvertices = {0, "r_subdivisions_maxvertices", "65536", "maximum vertices allowed per subdivided curve"};
  39 cvar_t r_subdivisions_collision_tolerance = {0, "r_subdivisions_collision_tolerance", "15", "maximum error tolerance on curve subdivision for collision purposes (usually a larger error tolerance than for rendering)"};
  40 cvar_t r_subdivisions_collision_mintess = {0, "r_subdivisions_collision_mintess", "1", "minimum number of subdivisions (values above 1 will smooth curves that don't need it)"};
  41 cvar_t r_subdivisions_collision_maxtess = {0, "r_subdivisions_collision_maxtess", "1024", "maximum number of subdivisions (prevents curves beyond a certain detail level, limits smoothing)"};
  42 cvar_t r_subdivisions_collision_maxvertices = {0, "r_subdivisions_collision_maxvertices", "4225", "maximum vertices allowed per subdivided curve"};
  43 cvar_t mod_q3bsp_curves_collisions = {0, "mod_q3bsp_curves_collisions", "1", "enables collisions with curves (SLOW)"};
  44 cvar_t mod_q3bsp_optimizedtraceline = {0, "mod_q3bsp_optimizedtraceline", "1", "whether to use optimized traceline code for line traces (as opposed to tracebox code)"};
  45 cvar_t mod_q3bsp_debugtracebrush = {0, "mod_q3bsp_debugtracebrush", "0", "selects different tracebrush bsp recursion algorithms (for debugging purposes only)"};
  46
  47 static texture_t mod_q1bsp_texture_solid;
  48 static texture_t mod_q1bsp_texture_sky;
  49 static texture_t mod_q1bsp_texture_lava;
  50 static texture_t mod_q1bsp_texture_slime;
  51 static texture_t mod_q1bsp_texture_water;
  52
  53 void Mod_BrushInit(void)
  54 {
  55 //      Cvar_RegisterVariable(&r_subdivide_size);
  56         Cvar_RegisterVariable(&halflifebsp);
  57         Cvar_RegisterVariable(&mcbsp);
  58         Cvar_RegisterVariable(&r_novis);
  59         Cvar_RegisterVariable(&r_lightmaprgba);
  60         Cvar_RegisterVariable(&r_nosurftextures);
  61         Cvar_RegisterVariable(&r_subdivisions_tolerance);
  62         Cvar_RegisterVariable(&r_subdivisions_mintess);
  63         Cvar_RegisterVariable(&r_subdivisions_maxtess);
  64         Cvar_RegisterVariable(&r_subdivisions_maxvertices);
  65         Cvar_RegisterVariable(&r_subdivisions_collision_tolerance);
  66         Cvar_RegisterVariable(&r_subdivisions_collision_mintess);
  67         Cvar_RegisterVariable(&r_subdivisions_collision_maxtess);
  68         Cvar_RegisterVariable(&r_subdivisions_collision_maxvertices);
  69         Cvar_RegisterVariable(&mod_q3bsp_curves_collisions);
  70         Cvar_RegisterVariable(&mod_q3bsp_optimizedtraceline);
  71         Cvar_RegisterVariable(&mod_q3bsp_debugtracebrush);
  72
  73         memset(&mod_q1bsp_texture_solid, 0, sizeof(mod_q1bsp_texture_solid));
  74         strlcpy(mod_q1bsp_texture_solid.name, "solid" , sizeof(mod_q1bsp_texture_solid.name));
  75         mod_q1bsp_texture_solid.surfaceflags = 0;
  76         mod_q1bsp_texture_solid.supercontents = SUPERCONTENTS_SOLID;
  77
  78         mod_q1bsp_texture_sky = mod_q1bsp_texture_solid;
  79         strlcpy(mod_q1bsp_texture_sky.name, "sky", sizeof(mod_q1bsp_texture_sky.name));
  80         mod_q1bsp_texture_sky.surfaceflags = Q3SURFACEFLAG_SKY | Q3SURFACEFLAG_NOIMPACT | Q3SURFACEFLAG_NOMARKS | Q3SURFACEFLAG_NODLIGHT | Q3SURFACEFLAG_NOLIGHTMAP;
  81         mod_q1bsp_texture_sky.supercontents = SUPERCONTENTS_SKY | SUPERCONTENTS_NODROP;
  82
  83         mod_q1bsp_texture_lava = mod_q1bsp_texture_solid;
  84         strlcpy(mod_q1bsp_texture_lava.name, "*lava", sizeof(mod_q1bsp_texture_lava.name));
  85         mod_q1bsp_texture_lava.surfaceflags = Q3SURFACEFLAG_NOMARKS;
  86         mod_q1bsp_texture_lava.supercontents = SUPERCONTENTS_LAVA | SUPERCONTENTS_NODROP;
  87
  88         mod_q1bsp_texture_slime = mod_q1bsp_texture_solid;
  89         strlcpy(mod_q1bsp_texture_slime.name, "*slime", sizeof(mod_q1bsp_texture_slime.name));
  90         mod_q1bsp_texture_slime.surfaceflags = Q3SURFACEFLAG_NOMARKS;
  91         mod_q1bsp_texture_slime.supercontents = SUPERCONTENTS_SLIME;
  92
  93         mod_q1bsp_texture_water = mod_q1bsp_texture_solid;
  94         strlcpy(mod_q1bsp_texture_water.name, "*water", sizeof(mod_q1bsp_texture_water.name));
  95         mod_q1bsp_texture_water.surfaceflags = Q3SURFACEFLAG_NOMARKS;
  96         mod_q1bsp_texture_water.supercontents = SUPERCONTENTS_WATER;
  97 }
  98
  99 static mleaf_t *Mod_Q1BSP_PointInLeaf(model_t *model, const vec3_t p)
 100 {
 101         mnode_t *node;
 102
 103         if (model == NULL)
 104                 return NULL;
 105
 106         // LordHavoc: modified to start at first clip node,
 107         // in other words: first node of the (sub)model
 108         node = model->brush.data_nodes + model->brushq1.hulls[0].firstclipnode;
 109         while (node->plane)
 110                 node = node->children[(node->plane->type < 3 ? p[node->plane->type] : DotProduct(p,node->plane->normal)) < node->plane->dist];
 111
 112         return (mleaf_t *)node;
 113 }
 114
 115 static void Mod_Q1BSP_AmbientSoundLevelsForPoint(model_t *model, const vec3_t p, unsigned char *out, int outsize)
 116 {
 117         int i;
 118         mleaf_t *leaf;
 119         leaf = Mod_Q1BSP_PointInLeaf(model, p);
 120         if (leaf)
 121         {
 122                 i = min(outsize, (int)sizeof(leaf->ambient_sound_level));
 123                 if (i)
 124                 {
 125                         memcpy(out, leaf->ambient_sound_level, i);
 126                         out += i;
 127                         outsize -= i;
 128                 }
 129         }
 130         if (outsize)
 131                 memset(out, 0, outsize);
 132 }
 133
 134 static int Mod_Q1BSP_FindBoxClusters(model_t *model, const vec3_t mins, const vec3_t maxs, int maxclusters, int *clusterlist)
 135 {
 136         int numclusters = 0;
 137         int nodestackindex = 0;
 138         mnode_t *node, *nodestack[1024];
 139         if (!model->brush.num_pvsclusters)
 140                 return -1;
 141         node = model->brush.data_nodes;
 142         for (;;)
 143         {
 144 #if 1
 145                 if (node->plane)
 146                 {
 147                         // node - recurse down the BSP tree
 148                         int sides = BoxOnPlaneSide(mins, maxs, node->plane);
 149                         if (sides < 3)
 150                         {
 151                                 if (sides == 0)
 152                                         return -1; // ERROR: NAN bounding box!
 153                                 // box is on one side of plane, take that path
 154                                 node = node->children[sides-1];
 155                         }
 156                         else
 157                         {
 158                                 // box crosses plane, take one path and remember the other
 159                                 if (nodestackindex < 1024)
 160                                         nodestack[nodestackindex++] = node->children[0];
 161                                 node = node->children[1];
 162                         }
 163                         continue;
 164                 }
 165                 else
 166                 {
 167                         // leaf - add clusterindex to list
 168                         if (numclusters < maxclusters)
 169                                 clusterlist[numclusters] = ((mleaf_t *)node)->clusterindex;
 170                         numclusters++;
 171                 }
 172 #else
 173                 if (BoxesOverlap(mins, maxs, node->mins, node->maxs))
 174                 {
 175                         if (node->plane)
 176                         {
 177                                 if (nodestackindex < 1024)
 178                                         nodestack[nodestackindex++] = node->children[0];
 179                                 node = node->children[1];
 180                                 continue;
 181                         }
 182                         else
 183                         {
 184                                 // leaf - add clusterindex to list
 185                                 if (numclusters < maxclusters)
 186                                         clusterlist[numclusters] = ((mleaf_t *)node)->clusterindex;
 187                                 numclusters++;
 188                         }
 189                 }
 190 #endif
 191                 // try another path we didn't take earlier
 192                 if (nodestackindex == 0)
 193                         break;
 194                 node = nodestack[--nodestackindex];
 195         }
 196         // return number of clusters found (even if more than the maxclusters)
 197         return numclusters;
 198 }
 199
 200 static int Mod_Q1BSP_BoxTouchingPVS(model_t *model, const unsigned char *pvs, const vec3_t mins, const vec3_t maxs)
 201 {
 202         int nodestackindex = 0;
 203         mnode_t *node, *nodestack[1024];
 204         if (!model->brush.num_pvsclusters)
 205                 return true;
 206         node = model->brush.data_nodes;
 207         for (;;)
 208         {
 209 #if 1
 210                 if (node->plane)
 211                 {
 212                         // node - recurse down the BSP tree
 213                         int sides = BoxOnPlaneSide(mins, maxs, node->plane);
 214                         if (sides < 3)
 215                         {
 216                                 if (sides == 0)
 217                                         return -1; // ERROR: NAN bounding box!
 218                                 // box is on one side of plane, take that path
 219                                 node = node->children[sides-1];
 220                         }
 221                         else
 222                         {
 223                                 // box crosses plane, take one path and remember the other
 224                                 if (nodestackindex < 1024)
 225                                         nodestack[nodestackindex++] = node->children[0];
 226                                 node = node->children[1];
 227                         }
 228                         continue;
 229                 }
 230                 else
 231                 {
 232                         // leaf - check cluster bit
 233                         int clusterindex = ((mleaf_t *)node)->clusterindex;
 234                         if (CHECKPVSBIT(pvs, clusterindex))
 235                         {
 236                                 // it is visible, return immediately with the news
 237                                 return true;
 238                         }
 239                 }
 240 #else
 241                 if (BoxesOverlap(mins, maxs, node->mins, node->maxs))
 242                 {
 243                         if (node->plane)
 244                         {
 245                                 if (nodestackindex < 1024)
 246                                         nodestack[nodestackindex++] = node->children[0];
 247                                 node = node->children[1];
 248                                 continue;
 249                         }
 250                         else
 251                         {
 252                                 // leaf - check cluster bit
 253                                 int clusterindex = ((mleaf_t *)node)->clusterindex;
 254                                 if (CHECKPVSBIT(pvs, clusterindex))
 255                                 {
 256                                         // it is visible, return immediately with the news
 257                                         return true;
 258                                 }
 259                         }
 260                 }
 261 #endif
 262                 // nothing to see here, try another path we didn't take earlier
 263                 if (nodestackindex == 0)
 264                         break;
 265                 node = nodestack[--nodestackindex];
 266         }
 267         // it is not visible
 268         return false;
 269 }
 270
 271 static int Mod_Q1BSP_BoxTouchingLeafPVS(model_t *model, const unsigned char *pvs, const vec3_t mins, const vec3_t maxs)
 272 {
 273         int nodestackindex = 0;
 274         mnode_t *node, *nodestack[1024];
 275         if (!model->brush.num_leafs)
 276                 return true;
 277         node = model->brush.data_nodes;
 278         for (;;)
 279         {
 280 #if 1
 281                 if (node->plane)
 282                 {
 283                         // node - recurse down the BSP tree
 284                         int sides = BoxOnPlaneSide(mins, maxs, node->plane);
 285                         if (sides < 3)
 286                         {
 287                                 if (sides == 0)
 288                                         return -1; // ERROR: NAN bounding box!
 289                                 // box is on one side of plane, take that path
 290                                 node = node->children[sides-1];
 291                         }
 292                         else
 293                         {
 294                                 // box crosses plane, take one path and remember the other
 295                                 if (nodestackindex < 1024)
 296                                         nodestack[nodestackindex++] = node->children[0];
 297                                 node = node->children[1];
 298                         }
 299                         continue;
 300                 }
 301                 else
 302                 {
 303                         // leaf - check cluster bit
 304                         int clusterindex = ((mleaf_t *)node) - model->brush.data_leafs;
 305                         if (CHECKPVSBIT(pvs, clusterindex))
 306                         {
 307                                 // it is visible, return immediately with the news
 308                                 return true;
 309                         }
 310                 }
 311 #else
 312                 if (BoxesOverlap(mins, maxs, node->mins, node->maxs))
 313                 {
 314                         if (node->plane)
 315                         {
 316                                 if (nodestackindex < 1024)
 317                                         nodestack[nodestackindex++] = node->children[0];
 318                                 node = node->children[1];
 319                                 continue;
 320                         }
 321                         else
 322                         {
 323                                 // leaf - check cluster bit
 324                                 int clusterindex = ((mleaf_t *)node) - model->brush.data_leafs;
 325                                 if (CHECKPVSBIT(pvs, clusterindex))
 326                                 {
 327                                         // it is visible, return immediately with the news
 328                                         return true;
 329                                 }
 330                         }
 331                 }
 332 #endif
 333                 // nothing to see here, try another path we didn't take earlier
 334                 if (nodestackindex == 0)
 335                         break;
 336                 node = nodestack[--nodestackindex];
 337         }
 338         // it is not visible
 339         return false;
 340 }
 341
 342 static int Mod_Q1BSP_BoxTouchingVisibleLeafs(model_t *model, const unsigned char *visibleleafs, const vec3_t mins, const vec3_t maxs)
 343 {
 344         int nodestackindex = 0;
 345         mnode_t *node, *nodestack[1024];
 346         if (!model->brush.num_leafs)
 347                 return true;
 348         node = model->brush.data_nodes;
 349         for (;;)
 350         {
 351 #if 1
 352                 if (node->plane)
 353                 {
 354                         // node - recurse down the BSP tree
 355                         int sides = BoxOnPlaneSide(mins, maxs, node->plane);
 356                         if (sides < 3)
 357                         {
 358                                 if (sides == 0)
 359                                         return -1; // ERROR: NAN bounding box!
 360                                 // box is on one side of plane, take that path
 361                                 node = node->children[sides-1];
 362                         }
 363                         else
 364                         {
 365                                 // box crosses plane, take one path and remember the other
 366                                 if (nodestackindex < 1024)
 367                                         nodestack[nodestackindex++] = node->children[0];
 368                                 node = node->children[1];
 369                         }
 370                         continue;
 371                 }
 372                 else
 373                 {
 374                         // leaf - check if it is visible
 375                         if (visibleleafs[(mleaf_t *)node - model->brush.data_leafs])
 376                         {
 377                                 // it is visible, return immediately with the news
 378                                 return true;
 379                         }
 380                 }
 381 #else
 382                 if (BoxesOverlap(mins, maxs, node->mins, node->maxs))
 383                 {
 384                         if (node->plane)
 385                         {
 386                                 if (nodestackindex < 1024)
 387                                         nodestack[nodestackindex++] = node->children[0];
 388                                 node = node->children[1];
 389                                 continue;
 390                         }
 391                         else
 392                         {
 393                                 // leaf - check if it is visible
 394                                 if (visibleleafs[(mleaf_t *)node - model->brush.data_leafs])
 395                                 {
 396                                         // it is visible, return immediately with the news
 397                                         return true;
 398                                 }
 399                         }
 400                 }
 401 #endif
 402                 // nothing to see here, try another path we didn't take earlier
 403                 if (nodestackindex == 0)
 404                         break;
 405                 node = nodestack[--nodestackindex];
 406         }
 407         // it is not visible
 408         return false;
 409 }
 410
 411 typedef struct findnonsolidlocationinfo_s
 412 {
 413         vec3_t center;
 414         vec_t radius;
 415         vec3_t nudge;
 416         vec_t bestdist;
 417         model_t *model;
 418 }
 419 findnonsolidlocationinfo_t;
 420
 421 static void Mod_Q1BSP_FindNonSolidLocation_r_Leaf(findnonsolidlocationinfo_t *info, mleaf_t *leaf)
 422 {
 423         int i, surfacenum, k, *tri, *mark;
 424         float dist, f, vert[3][3], edge[3][3], facenormal[3], edgenormal[3][3], point[3];
 425         msurface_t *surface;
 426         for (surfacenum = 0, mark = leaf->firstleafsurface;surfacenum < leaf->numleafsurfaces;surfacenum++, mark++)
 427         {
 428                 surface = info->model->data_surfaces + *mark;
 429                 if (surface->texture->supercontents & SUPERCONTENTS_SOLID)
 430                 {
 431                         for (k = 0;k < surface->num_triangles;k++)
 432                         {
 433                                 tri = (info->model->surfmesh.data_element3i + 3 * surface->num_firsttriangle) + k * 3;
 434                                 VectorCopy((info->model->surfmesh.data_vertex3f + tri[0] * 3), vert[0]);
 435                                 VectorCopy((info->model->surfmesh.data_vertex3f + tri[1] * 3), vert[1]);
 436                                 VectorCopy((info->model->surfmesh.data_vertex3f + tri[2] * 3), vert[2]);
 437                                 VectorSubtract(vert[1], vert[0], edge[0]);
 438                                 VectorSubtract(vert[2], vert[1], edge[1]);
 439                                 CrossProduct(edge[1], edge[0], facenormal);
 440                                 if (facenormal[0] || facenormal[1] || facenormal[2])
 441                                 {
 442                                         VectorNormalize(facenormal);
 443                                         f = DotProduct(info->center, facenormal) - DotProduct(vert[0], facenormal);
 444                                         if (f <= info->bestdist && f >= -info->bestdist)
 445                                         {
 446                                                 VectorSubtract(vert[0], vert[2], edge[2]);
 447                                                 VectorNormalize(edge[0]);
 448                                                 VectorNormalize(edge[1]);
 449                                                 VectorNormalize(edge[2]);
 450                                                 CrossProduct(facenormal, edge[0], edgenormal[0]);
 451                                                 CrossProduct(facenormal, edge[1], edgenormal[1]);
 452                                                 CrossProduct(facenormal, edge[2], edgenormal[2]);
 453                                                 // face distance
 454                                                 if (DotProduct(info->center, edgenormal[0]) < DotProduct(vert[0], edgenormal[0])
 455                                                  && DotProduct(info->center, edgenormal[1]) < DotProduct(vert[1], edgenormal[1])
 456                                                  && DotProduct(info->center, edgenormal[2]) < DotProduct(vert[2], edgenormal[2]))
 457                                                 {
 458                                                         // we got lucky, the center is within the face
 459                                                         dist = DotProduct(info->center, facenormal) - DotProduct(vert[0], facenormal);
 460                                                         if (dist < 0)
 461                                                         {
 462                                                                 dist = -dist;
 463                                                                 if (info->bestdist > dist)
 464                                                                 {
 465                                                                         info->bestdist = dist;
 466                                                                         VectorScale(facenormal, (info->radius - -dist), info->nudge);
 467                                                                 }
 468                                                         }
 469                                                         else
 470                                                         {
 471                                                                 if (info->bestdist > dist)
 472                                                                 {
 473                                                                         info->bestdist = dist;
 474                                                                         VectorScale(facenormal, (info->radius - dist), info->nudge);
 475                                                                 }
 476                                                         }
 477                                                 }
 478                                                 else
 479                                                 {
 480                                                         // check which edge or vertex the center is nearest
 481                                                         for (i = 0;i < 3;i++)
 482                                                         {
 483                                                                 f = DotProduct(info->center, edge[i]);
 484                                                                 if (f >= DotProduct(vert[0], edge[i])
 485                                                                  && f <= DotProduct(vert[1], edge[i]))
 486                                                                 {
 487                                                                         // on edge
 488                                                                         VectorMA(info->center, -f, edge[i], point);
 489                                                                         dist = sqrt(DotProduct(point, point));
 490                                                                         if (info->bestdist > dist)
 491                                                                         {
 492                                                                                 info->bestdist = dist;
 493                                                                                 VectorScale(point, (info->radius / dist), info->nudge);
 494                                                                         }
 495                                                                         // skip both vertex checks
 496                                                                         // (both are further away than this edge)
 497                                                                         i++;
 498                                                                 }
 499                                                                 else
 500                                                                 {
 501                                                                         // not on edge, check first vertex of edge
 502                                                                         VectorSubtract(info->center, vert[i], point);
 503                                                                         dist = sqrt(DotProduct(point, point));
 504                                                                         if (info->bestdist > dist)
 505                                                                         {
 506                                                                                 info->bestdist = dist;
 507                                                                                 VectorScale(point, (info->radius / dist), info->nudge);
 508                                                                         }
 509                                                                 }
 510                                                         }
 511                                                 }
 512                                         }
 513                                 }
 514                         }
 515                 }
 516         }
 517 }
 518
 519 static void Mod_Q1BSP_FindNonSolidLocation_r(findnonsolidlocationinfo_t *info, mnode_t *node)
 520 {
 521         if (node->plane)
 522         {
 523                 float f = PlaneDiff(info->center, node->plane);
 524                 if (f >= -info->bestdist)
 525                         Mod_Q1BSP_FindNonSolidLocation_r(info, node->children[0]);
 526                 if (f <= info->bestdist)
 527                         Mod_Q1BSP_FindNonSolidLocation_r(info, node->children[1]);
 528         }
 529         else
 530         {
 531                 if (((mleaf_t *)node)->numleafsurfaces)
 532                         Mod_Q1BSP_FindNonSolidLocation_r_Leaf(info, (mleaf_t *)node);
 533         }
 534 }
 535
 536 static void Mod_Q1BSP_FindNonSolidLocation(model_t *model, const vec3_t in, vec3_t out, float radius)
 537 {
 538         int i;
 539         findnonsolidlocationinfo_t info;
 540         if (model == NULL)
 541         {
 542                 VectorCopy(in, out);
 543                 return;
 544         }
 545         VectorCopy(in, info.center);
 546         info.radius = radius;
 547         info.model = model;
 548         i = 0;
 549         do
 550         {
 551                 VectorClear(info.nudge);
 552                 info.bestdist = radius;
 553                 Mod_Q1BSP_FindNonSolidLocation_r(&info, model->brush.data_nodes + model->brushq1.hulls[0].firstclipnode);
 554                 VectorAdd(info.center, info.nudge, info.center);
 555         }
 556         while (info.bestdist < radius && ++i < 10);
 557         VectorCopy(info.center, out);
 558 }
 559
 560 int Mod_Q1BSP_SuperContentsFromNativeContents(model_t *model, int nativecontents)
 561 {
 562         switch(nativecontents)
 563         {
 564                 case CONTENTS_EMPTY:
 565                         return 0;
 566                 case CONTENTS_SOLID:
 567                         return SUPERCONTENTS_SOLID;
 568                 case CONTENTS_WATER:
 569                         return SUPERCONTENTS_WATER;
 570                 case CONTENTS_SLIME:
 571                         return SUPERCONTENTS_SLIME;
 572                 case CONTENTS_LAVA:
 573                         return SUPERCONTENTS_LAVA | SUPERCONTENTS_NODROP;
 574                 case CONTENTS_SKY:
 575                         return SUPERCONTENTS_SKY | SUPERCONTENTS_NODROP;
 576         }
 577         return 0;
 578 }
 579
 580 int Mod_Q1BSP_NativeContentsFromSuperContents(model_t *model, int supercontents)
 581 {
 582         if (supercontents & (SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY))
 583                 return CONTENTS_SOLID;
 584         if (supercontents & SUPERCONTENTS_SKY)
 585                 return CONTENTS_SKY;
 586         if (supercontents & SUPERCONTENTS_LAVA)
 587                 return CONTENTS_LAVA;
 588         if (supercontents & SUPERCONTENTS_SLIME)
 589                 return CONTENTS_SLIME;
 590         if (supercontents & SUPERCONTENTS_WATER)
 591                 return CONTENTS_WATER;
 592         return CONTENTS_EMPTY;
 593 }
 594
 595 typedef struct RecursiveHullCheckTraceInfo_s
 596 {
 597         // the hull we're tracing through
 598         const hull_t *hull;
 599
 600         // the trace structure to fill in
 601         trace_t *trace;
 602
 603         // start, end, and end - start (in model space)
 604         double start[3];
 605         double end[3];
 606         double dist[3];
 607 }
 608 RecursiveHullCheckTraceInfo_t;
 609
 610 // 1/32 epsilon to keep floating point happy
 611 #define DIST_EPSILON (0.03125)
 612
 613 #define HULLCHECKSTATE_EMPTY 0
 614 #define HULLCHECKSTATE_SOLID 1
 615 #define HULLCHECKSTATE_DONE 2
 616
 617 extern cvar_t collision_prefernudgedfraction;
 618 static int Mod_Q1BSP_RecursiveHullCheck(RecursiveHullCheckTraceInfo_t *t, int num, double p1f, double p2f, double p1[3], double p2[3])
 619 {
 620         // status variables, these don't need to be saved on the stack when
 621         // recursing...  but are because this should be thread-safe
 622         // (note: tracing against a bbox is not thread-safe, yet)
 623         int ret;
 624         mplane_t *plane;
 625         double t1, t2;
 626
 627         // variables that need to be stored on the stack when recursing
 628         dclipnode_t *node;
 629         int side;
 630         double midf, mid[3];
 631
 632         // LordHavoc: a goto!  everyone flee in terror... :)
 633 loc0:
 634         // check for empty
 635         if (num < 0)
 636         {
 637                 num = Mod_Q1BSP_SuperContentsFromNativeContents(NULL, num);
 638                 if (!t->trace->startfound)
 639                 {
 640                         t->trace->startfound = true;
 641                         t->trace->startsupercontents |= num;
 642                 }
 643                 if (num & SUPERCONTENTS_LIQUIDSMASK)
 644                         t->trace->inwater = true;
 645                 if (num == 0)
 646                         t->trace->inopen = true;
 647                 if (num & SUPERCONTENTS_SOLID)
 648                         t->trace->hittexture = &mod_q1bsp_texture_solid;
 649                 else if (num & SUPERCONTENTS_SKY)
 650                         t->trace->hittexture = &mod_q1bsp_texture_sky;
 651                 else if (num & SUPERCONTENTS_LAVA)
 652                         t->trace->hittexture = &mod_q1bsp_texture_lava;
 653                 else if (num & SUPERCONTENTS_SLIME)
 654                         t->trace->hittexture = &mod_q1bsp_texture_slime;
 655                 else
 656                         t->trace->hittexture = &mod_q1bsp_texture_water;
 657                 t->trace->hitq3surfaceflags = t->trace->hittexture->surfaceflags;
 658                 t->trace->hitsupercontents = num;
 659                 if (num & t->trace->hitsupercontentsmask)
 660                 {
 661                         // if the first leaf is solid, set startsolid
 662                         if (t->trace->allsolid)
 663                                 t->trace->startsolid = true;
 664 #if COLLISIONPARANOID >= 3
 665                         Con_Print("S");
 666 #endif
 667                         return HULLCHECKSTATE_SOLID;
 668                 }
 669                 else
 670                 {
 671                         t->trace->allsolid = false;
 672 #if COLLISIONPARANOID >= 3
 673                         Con_Print("E");
 674 #endif
 675                         return HULLCHECKSTATE_EMPTY;
 676                 }
 677         }
 678
 679         // find the point distances
 680         node = t->hull->clipnodes + num;
 681
 682         plane = t->hull->planes + node->planenum;
 683         if (plane->type < 3)
 684         {
 685                 t1 = p1[plane->type] - plane->dist;
 686                 t2 = p2[plane->type] - plane->dist;
 687         }
 688         else
 689         {
 690                 t1 = DotProduct (plane->normal, p1) - plane->dist;
 691                 t2 = DotProduct (plane->normal, p2) - plane->dist;
 692         }
 693
 694         if (t1 < 0)
 695         {
 696                 if (t2 < 0)
 697                 {
 698 #if COLLISIONPARANOID >= 3
 699                         Con_Print("<");
 700 #endif
 701                         num = node->children[1];
 702                         goto loc0;
 703                 }
 704                 side = 1;
 705         }
 706         else
 707         {
 708                 if (t2 >= 0)
 709                 {
 710 #if COLLISIONPARANOID >= 3
 711                         Con_Print(">");
 712 #endif
 713                         num = node->children[0];
 714                         goto loc0;
 715                 }
 716                 side = 0;
 717         }
 718
 719         // the line intersects, find intersection point
 720         // LordHavoc: this uses the original trace for maximum accuracy
 721 #if COLLISIONPARANOID >= 3
 722         Con_Print("M");
 723 #endif
 724         if (plane->type < 3)
 725         {
 726                 t1 = t->start[plane->type] - plane->dist;
 727                 t2 = t->end[plane->type] - plane->dist;
 728         }
 729         else
 730         {
 731                 t1 = DotProduct (plane->normal, t->start) - plane->dist;
 732                 t2 = DotProduct (plane->normal, t->end) - plane->dist;
 733         }
 734
 735         midf = t1 / (t1 - t2);
 736         midf = bound(p1f, midf, p2f);
 737         VectorMA(t->start, midf, t->dist, mid);
 738
 739         // recurse both sides, front side first
 740         ret = Mod_Q1BSP_RecursiveHullCheck(t, node->children[side], p1f, midf, p1, mid);
 741         // if this side is not empty, return what it is (solid or done)
 742         if (ret != HULLCHECKSTATE_EMPTY)
 743                 return ret;
 744
 745         ret = Mod_Q1BSP_RecursiveHullCheck(t, node->children[side ^ 1], midf, p2f, mid, p2);
 746         // if other side is not solid, return what it is (empty or done)
 747         if (ret != HULLCHECKSTATE_SOLID)
 748                 return ret;
 749
 750         // front is air and back is solid, this is the impact point...
 751         if (side)
 752         {
 753                 t->trace->plane.dist = -plane->dist;
 754                 VectorNegate (plane->normal, t->trace->plane.normal);
 755         }
 756         else
 757         {
 758                 t->trace->plane.dist = plane->dist;
 759                 VectorCopy (plane->normal, t->trace->plane.normal);
 760         }
 761
 762         // calculate the true fraction
 763         t1 = DotProduct(t->trace->plane.normal, t->start) - t->trace->plane.dist;
 764         t2 = DotProduct(t->trace->plane.normal, t->end) - t->trace->plane.dist;
 765         midf = t1 / (t1 - t2);
 766         t->trace->realfraction = bound(0, midf, 1);
 767
 768         // calculate the return fraction which is nudged off the surface a bit
 769         midf = (t1 - DIST_EPSILON) / (t1 - t2);
 770         t->trace->fraction = bound(0, midf, 1);
 771
 772         if (collision_prefernudgedfraction.integer)
 773                 t->trace->realfraction = t->trace->fraction;
 774
 775 #if COLLISIONPARANOID >= 3
 776         Con_Print("D");
 777 #endif
 778         return HULLCHECKSTATE_DONE;
 779 }
 780
 781 //#if COLLISIONPARANOID < 2
 782 static int Mod_Q1BSP_RecursiveHullCheckPoint(RecursiveHullCheckTraceInfo_t *t, int num)
 783 {
 784         while (num >= 0)
 785                 num = t->hull->clipnodes[num].children[(t->hull->planes[t->hull->clipnodes[num].planenum].type < 3 ? t->start[t->hull->planes[t->hull->clipnodes[num].planenum].type] : DotProduct(t->hull->planes[t->hull->clipnodes[num].planenum].normal, t->start)) < t->hull->planes[t->hull->clipnodes[num].planenum].dist];
 786         num = Mod_Q1BSP_SuperContentsFromNativeContents(NULL, num);
 787         t->trace->startsupercontents |= num;
 788         if (num & SUPERCONTENTS_LIQUIDSMASK)
 789                 t->trace->inwater = true;
 790         if (num == 0)
 791                 t->trace->inopen = true;
 792         if (num & t->trace->hitsupercontentsmask)
 793         {
 794                 t->trace->allsolid = t->trace->startsolid = true;
 795                 return HULLCHECKSTATE_SOLID;
 796         }
 797         else
 798         {
 799                 t->trace->allsolid = t->trace->startsolid = false;
 800                 return HULLCHECKSTATE_EMPTY;
 801         }
 802 }
 803 //#endif
 804
 805 static void Mod_Q1BSP_TraceBox(struct model_s *model, int frame, trace_t *trace, const vec3_t start, const vec3_t boxmins, const vec3_t boxmaxs, const vec3_t end, int hitsupercontentsmask)
 806 {
 807         // this function currently only supports same size start and end
 808         double boxsize[3];
 809         RecursiveHullCheckTraceInfo_t rhc;
 810
 811         memset(&rhc, 0, sizeof(rhc));
 812         memset(trace, 0, sizeof(trace_t));
 813         rhc.trace = trace;
 814         rhc.trace->hitsupercontentsmask = hitsupercontentsmask;
 815         rhc.trace->fraction = 1;
 816         rhc.trace->realfraction = 1;
 817         rhc.trace->allsolid = true;
 818         VectorSubtract(boxmaxs, boxmins, boxsize);
 819         if (boxsize[0] < 3)
 820                 rhc.hull = &model->brushq1.hulls[0]; // 0x0x0
 821         else if (model->brush.ismcbsp)
 822         {
 823                 if (boxsize[2] < 48) // pick the nearest of 40 or 56
 824                         rhc.hull = &model->brushq1.hulls[2]; // 16x16x40
 825                 else
 826                         rhc.hull = &model->brushq1.hulls[1]; // 16x16x56
 827         }
 828         else if (model->brush.ishlbsp)
 829         {
 830                 // LordHavoc: this has to have a minor tolerance (the .1) because of
 831                 // minor float precision errors from the box being transformed around
 832                 if (boxsize[0] < 32.1)
 833                 {
 834                         if (boxsize[2] < 54) // pick the nearest of 36 or 72
 835                                 rhc.hull = &model->brushq1.hulls[3]; // 32x32x36
 836                         else
 837                                 rhc.hull = &model->brushq1.hulls[1]; // 32x32x72
 838                 }
 839                 else
 840                         rhc.hull = &model->brushq1.hulls[2]; // 64x64x64
 841         }
 842         else
 843         {
 844                 // LordHavoc: this has to have a minor tolerance (the .1) because of
 845                 // minor float precision errors from the box being transformed around
 846                 if (boxsize[0] < 32.1)
 847                         rhc.hull = &model->brushq1.hulls[1]; // 32x32x56
 848                 else
 849                         rhc.hull = &model->brushq1.hulls[2]; // 64x64x88
 850         }
 851         VectorMAMAM(1, start, 1, boxmins, -1, rhc.hull->clip_mins, rhc.start);
 852         VectorMAMAM(1, end, 1, boxmins, -1, rhc.hull->clip_mins, rhc.end);
 853         VectorSubtract(rhc.end, rhc.start, rhc.dist);
 854 #if COLLISIONPARANOID >= 2
 855         Con_Printf("t(%f %f %f,%f %f %f,%i %f %f %f)", rhc.start[0], rhc.start[1], rhc.start[2], rhc.end[0], rhc.end[1], rhc.end[2], rhc.hull - model->brushq1.hulls, rhc.hull->clip_mins[0], rhc.hull->clip_mins[1], rhc.hull->clip_mins[2]);
 856         Mod_Q1BSP_RecursiveHullCheck(&rhc, rhc.hull->firstclipnode, 0, 1, rhc.start, rhc.end);
 857         {
 858
 859                 double test[3];
 860                 trace_t testtrace;
 861                 VectorLerp(rhc.start, rhc.trace->fraction, rhc.end, test);
 862                 memset(&testtrace, 0, sizeof(trace_t));
 863                 rhc.trace = &testtrace;
 864                 rhc.trace->hitsupercontentsmask = hitsupercontentsmask;
 865                 rhc.trace->fraction = 1;
 866                 rhc.trace->realfraction = 1;
 867                 rhc.trace->allsolid = true;
 868                 VectorCopy(test, rhc.start);
 869                 VectorCopy(test, rhc.end);
 870                 VectorClear(rhc.dist);
 871                 Mod_Q1BSP_RecursiveHullCheckPoint(&rhc, rhc.hull->firstclipnode);
 872                 //Mod_Q1BSP_RecursiveHullCheck(&rhc, rhc.hull->firstclipnode, 0, 1, test, test);
 873                 if (!trace->startsolid && testtrace.startsolid)
 874                         Con_Printf(" - ended in solid!\n");
 875         }
 876         Con_Print("\n");
 877 #else
 878         if (VectorLength2(rhc.dist))
 879                 Mod_Q1BSP_RecursiveHullCheck(&rhc, rhc.hull->firstclipnode, 0, 1, rhc.start, rhc.end);
 880         else
 881                 Mod_Q1BSP_RecursiveHullCheckPoint(&rhc, rhc.hull->firstclipnode);
 882 #endif
 883 }
 884
 885 void Collision_ClipTrace_Box(trace_t *trace, const vec3_t cmins, const vec3_t cmaxs, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, int hitsupercontentsmask, int boxsupercontents, int boxq3surfaceflags, texture_t *boxtexture)
 886 {
 887 #if 1
 888         colbrushf_t cbox;
 889         colplanef_t cbox_planes[6];
 890         cbox.supercontents = boxsupercontents;
 891         cbox.numplanes = 6;
 892         cbox.numpoints = 0;
 893         cbox.numtriangles = 0;
 894         cbox.planes = cbox_planes;
 895         cbox.points = NULL;
 896         cbox.elements = NULL;
 897         cbox.markframe = 0;
 898         cbox.mins[0] = 0;
 899         cbox.mins[1] = 0;
 900         cbox.mins[2] = 0;
 901         cbox.maxs[0] = 0;
 902         cbox.maxs[1] = 0;
 903         cbox.maxs[2] = 0;
 904         cbox_planes[0].normal[0] =  1;cbox_planes[0].normal[1] =  0;cbox_planes[0].normal[2] =  0;cbox_planes[0].dist = cmaxs[0] - mins[0];
 905         cbox_planes[1].normal[0] = -1;cbox_planes[1].normal[1] =  0;cbox_planes[1].normal[2] =  0;cbox_planes[1].dist = maxs[0] - cmins[0];
 906         cbox_planes[2].normal[0] =  0;cbox_planes[2].normal[1] =  1;cbox_planes[2].normal[2] =  0;cbox_planes[2].dist = cmaxs[1] - mins[1];
 907         cbox_planes[3].normal[0] =  0;cbox_planes[3].normal[1] = -1;cbox_planes[3].normal[2] =  0;cbox_planes[3].dist = maxs[1] - cmins[1];
 908         cbox_planes[4].normal[0] =  0;cbox_planes[4].normal[1] =  0;cbox_planes[4].normal[2] =  1;cbox_planes[4].dist = cmaxs[2] - mins[2];
 909         cbox_planes[5].normal[0] =  0;cbox_planes[5].normal[1] =  0;cbox_planes[5].normal[2] = -1;cbox_planes[5].dist = maxs[2] - cmins[2];
 910         cbox_planes[0].q3surfaceflags = boxq3surfaceflags;cbox_planes[0].texture = boxtexture;
 911         cbox_planes[1].q3surfaceflags = boxq3surfaceflags;cbox_planes[1].texture = boxtexture;
 912         cbox_planes[2].q3surfaceflags = boxq3surfaceflags;cbox_planes[2].texture = boxtexture;
 913         cbox_planes[3].q3surfaceflags = boxq3surfaceflags;cbox_planes[3].texture = boxtexture;
 914         cbox_planes[4].q3surfaceflags = boxq3surfaceflags;cbox_planes[4].texture = boxtexture;
 915         cbox_planes[5].q3surfaceflags = boxq3surfaceflags;cbox_planes[5].texture = boxtexture;
 916         memset(trace, 0, sizeof(trace_t));
 917         trace->hitsupercontentsmask = hitsupercontentsmask;
 918         trace->fraction = 1;
 919         trace->realfraction = 1;
 920         Collision_TraceLineBrushFloat(trace, start, end, &cbox, &cbox);
 921 #else
 922         RecursiveHullCheckTraceInfo_t rhc;
 923         static hull_t box_hull;
 924         static dclipnode_t box_clipnodes[6];
 925         static mplane_t box_planes[6];
 926         // fill in a default trace
 927         memset(&rhc, 0, sizeof(rhc));
 928         memset(trace, 0, sizeof(trace_t));
 929         //To keep everything totally uniform, bounding boxes are turned into small
 930         //BSP trees instead of being compared directly.
 931         // create a temp hull from bounding box sizes
 932         box_planes[0].dist = cmaxs[0] - mins[0];
 933         box_planes[1].dist = cmins[0] - maxs[0];
 934         box_planes[2].dist = cmaxs[1] - mins[1];
 935         box_planes[3].dist = cmins[1] - maxs[1];
 936         box_planes[4].dist = cmaxs[2] - mins[2];
 937         box_planes[5].dist = cmins[2] - maxs[2];
 938 #if COLLISIONPARANOID >= 3
 939         Con_Printf("box_planes %f:%f %f:%f %f:%f\ncbox %f %f %f:%f %f %f\nbox %f %f %f:%f %f %f\n", box_planes[0].dist, box_planes[1].dist, box_planes[2].dist, box_planes[3].dist, box_planes[4].dist, box_planes[5].dist, cmins[0], cmins[1], cmins[2], cmaxs[0], cmaxs[1], cmaxs[2], mins[0], mins[1], mins[2], maxs[0], maxs[1], maxs[2]);
 940 #endif
 941
 942         if (box_hull.clipnodes == NULL)
 943         {
 944                 int i, side;
 945
 946                 //Set up the planes and clipnodes so that the six floats of a bounding box
 947                 //can just be stored out and get a proper hull_t structure.
 948
 949                 box_hull.clipnodes = box_clipnodes;
 950                 box_hull.planes = box_planes;
 951                 box_hull.firstclipnode = 0;
 952                 box_hull.lastclipnode = 5;
 953
 954                 for (i = 0;i < 6;i++)
 955                 {
 956                         box_clipnodes[i].planenum = i;
 957
 958                         side = i&1;
 959
 960                         box_clipnodes[i].children[side] = CONTENTS_EMPTY;
 961                         if (i != 5)
 962                                 box_clipnodes[i].children[side^1] = i + 1;
 963                         else
 964                                 box_clipnodes[i].children[side^1] = CONTENTS_SOLID;
 965
 966                         box_planes[i].type = i>>1;
 967                         box_planes[i].normal[i>>1] = 1;
 968                 }
 969         }
 970
 971         // trace a line through the generated clipping hull
 972         //rhc.boxsupercontents = boxsupercontents;
 973         rhc.hull = &box_hull;
 974         rhc.trace = trace;
 975         rhc.trace->hitsupercontentsmask = hitsupercontentsmask;
 976         rhc.trace->fraction = 1;
 977         rhc.trace->realfraction = 1;
 978         rhc.trace->allsolid = true;
 979         VectorCopy(start, rhc.start);
 980         VectorCopy(end, rhc.end);
 981         VectorSubtract(rhc.end, rhc.start, rhc.dist);
 982         Mod_Q1BSP_RecursiveHullCheck(&rhc, rhc.hull->firstclipnode, 0, 1, rhc.start, rhc.end);
 983         //VectorMA(rhc.start, rhc.trace->fraction, rhc.dist, rhc.trace->endpos);
 984         if (rhc.trace->startsupercontents)
 985                 rhc.trace->startsupercontents = boxsupercontents;
 986 #endif
 987 }
 988
 989 static int Mod_Q1BSP_LightPoint_RecursiveBSPNode(model_t *model, vec3_t ambientcolor, vec3_t diffusecolor, vec3_t diffusenormal, const mnode_t *node, float x, float y, float startz, float endz)
 990 {
 991         int side;
 992         float front, back;
 993         float mid, distz = endz - startz;
 994
 995 loc0:
 996         if (!node->plane)
 997                 return false;           // didn't hit anything
 998
 999         switch (node->plane->type)
1000         {
1001         case PLANE_X:
1002                 node = node->children[x < node->plane->dist];
1003                 goto loc0;
1004         case PLANE_Y:
1005                 node = node->children[y < node->plane->dist];
1006                 goto loc0;
1007         case PLANE_Z:
1008                 side = startz < node->plane->dist;
1009                 if ((endz < node->plane->dist) == side)
1010                 {
1011                         node = node->children[side];
1012                         goto loc0;
1013                 }
1014                 // found an intersection
1015                 mid = node->plane->dist;
1016                 break;
1017         default:
1018                 back = front = x * node->plane->normal[0] + y * node->plane->normal[1];
1019                 front += startz * node->plane->normal[2];
1020                 back += endz * node->plane->normal[2];
1021                 side = front < node->plane->dist;
1022                 if ((back < node->plane->dist) == side)
1023                 {
1024                         node = node->children[side];
1025                         goto loc0;
1026                 }
1027                 // found an intersection
1028                 mid = startz + distz * (front - node->plane->dist) / (front - back);
1029                 break;
1030         }
1031
1032         // go down front side
1033         if (node->children[side]->plane && Mod_Q1BSP_LightPoint_RecursiveBSPNode(model, ambientcolor, diffusecolor, diffusenormal, node->children[side], x, y, startz, mid))
1034                 return true;    // hit something
1035         else
1036         {
1037                 // check for impact on this node
1038                 if (node->numsurfaces)
1039                 {
1040                         int i, ds, dt;
1041                         msurface_t *surface;
1042
1043                         surface = model->data_surfaces + node->firstsurface;
1044                         for (i = 0;i < node->numsurfaces;i++, surface++)
1045                         {
1046                                 if (!(surface->texture->basematerialflags & MATERIALFLAG_WALL) || !surface->lightmapinfo->samples)
1047                                         continue;       // no lightmaps
1048
1049                                 ds = (int) (x * surface->lightmapinfo->texinfo->vecs[0][0] + y * surface->lightmapinfo->texinfo->vecs[0][1] + mid * surface->lightmapinfo->texinfo->vecs[0][2] + surface->lightmapinfo->texinfo->vecs[0][3]) - surface->lightmapinfo->texturemins[0];
1050                                 dt = (int) (x * surface->lightmapinfo->texinfo->vecs[1][0] + y * surface->lightmapinfo->texinfo->vecs[1][1] + mid * surface->lightmapinfo->texinfo->vecs[1][2] + surface->lightmapinfo->texinfo->vecs[1][3]) - surface->lightmapinfo->texturemins[1];
1051
1052                                 if (ds >= 0 && ds < surface->lightmapinfo->extents[0] && dt >= 0 && dt < surface->lightmapinfo->extents[1])
1053                                 {
1054                                         unsigned char *lightmap;
1055                                         int lmwidth, lmheight, maps, line3, size3, dsfrac = ds & 15, dtfrac = dt & 15, scale = 0, r00 = 0, g00 = 0, b00 = 0, r01 = 0, g01 = 0, b01 = 0, r10 = 0, g10 = 0, b10 = 0, r11 = 0, g11 = 0, b11 = 0;
1056                                         lmwidth = ((surface->lightmapinfo->extents[0]>>4)+1);
1057                                         lmheight = ((surface->lightmapinfo->extents[1]>>4)+1);
1058                                         line3 = lmwidth * 3; // LordHavoc: *3 for colored lighting
1059                                         size3 = lmwidth * lmheight * 3; // LordHavoc: *3 for colored lighting
1060
1061                                         lightmap = surface->lightmapinfo->samples + ((dt>>4) * lmwidth + (ds>>4))*3; // LordHavoc: *3 for colored lighting
1062
1063                                         for (maps = 0;maps < MAXLIGHTMAPS && surface->lightmapinfo->styles[maps] != 255;maps++)
1064                                         {
1065                                                 scale = r_refdef.lightstylevalue[surface->lightmapinfo->styles[maps]];
1066                                                 r00 += lightmap[      0] * scale;g00 += lightmap[      1] * scale;b00 += lightmap[      2] * scale;
1067                                                 r01 += lightmap[      3] * scale;g01 += lightmap[      4] * scale;b01 += lightmap[      5] * scale;
1068                                                 r10 += lightmap[line3+0] * scale;g10 += lightmap[line3+1] * scale;b10 += lightmap[line3+2] * scale;
1069                                                 r11 += lightmap[line3+3] * scale;g11 += lightmap[line3+4] * scale;b11 += lightmap[line3+5] * scale;
1070                                                 lightmap += size3;
1071                                         }
1072
1073 /*
1074 LordHavoc: here's the readable version of the interpolation
1075 code, not quite as easy for the compiler to optimize...
1076
1077 dsfrac is the X position in the lightmap pixel, * 16
1078 dtfrac is the Y position in the lightmap pixel, * 16
1079 r00 is top left corner, r01 is top right corner
1080 r10 is bottom left corner, r11 is bottom right corner
1081 g and b are the same layout.
1082 r0 and r1 are the top and bottom intermediate results
1083
1084 first we interpolate the top two points, to get the top
1085 edge sample
1086
1087         r0 = (((r01-r00) * dsfrac) >> 4) + r00;
1088         g0 = (((g01-g00) * dsfrac) >> 4) + g00;
1089         b0 = (((b01-b00) * dsfrac) >> 4) + b00;
1090
1091 then we interpolate the bottom two points, to get the
1092 bottom edge sample
1093
1094         r1 = (((r11-r10) * dsfrac) >> 4) + r10;
1095         g1 = (((g11-g10) * dsfrac) >> 4) + g10;
1096         b1 = (((b11-b10) * dsfrac) >> 4) + b10;
1097
1098 then we interpolate the top and bottom samples to get the
1099 middle sample (the one which was requested)
1100
1101         r = (((r1-r0) * dtfrac) >> 4) + r0;
1102         g = (((g1-g0) * dtfrac) >> 4) + g0;
1103         b = (((b1-b0) * dtfrac) >> 4) + b0;
1104 */
1105
1106                                         ambientcolor[0] += (float) ((((((((r11-r10) * dsfrac) >> 4) + r10)-((((r01-r00) * dsfrac) >> 4) + r00)) * dtfrac) >> 4) + ((((r01-r00) * dsfrac) >> 4) + r00)) * (1.0f / 32768.0f);
1107                                         ambientcolor[1] += (float) ((((((((g11-g10) * dsfrac) >> 4) + g10)-((((g01-g00) * dsfrac) >> 4) + g00)) * dtfrac) >> 4) + ((((g01-g00) * dsfrac) >> 4) + g00)) * (1.0f / 32768.0f);
1108                                         ambientcolor[2] += (float) ((((((((b11-b10) * dsfrac) >> 4) + b10)-((((b01-b00) * dsfrac) >> 4) + b00)) * dtfrac) >> 4) + ((((b01-b00) * dsfrac) >> 4) + b00)) * (1.0f / 32768.0f);
1109                                         return true; // success
1110                                 }
1111                         }
1112                 }
1113
1114                 // go down back side
1115                 node = node->children[side ^ 1];
1116                 startz = mid;
1117                 distz = endz - startz;
1118                 goto loc0;
1119         }
1120 }
1121
1122 void Mod_Q1BSP_LightPoint(model_t *model, const vec3_t p, vec3_t ambientcolor, vec3_t diffusecolor, vec3_t diffusenormal)
1123 {
1124         Mod_Q1BSP_LightPoint_RecursiveBSPNode(model, ambientcolor, diffusecolor, diffusenormal, model->brush.data_nodes + model->brushq1.hulls[0].firstclipnode, p[0], p[1], p[2] + 0.125, p[2] - 65536);
1125         // pretend lighting is coming down from above (due to lack of a lightgrid to know primary lighting direction)
1126         VectorSet(diffusenormal, 0, 0, 1);
1127 }
1128
1129 static void Mod_Q1BSP_DecompressVis(const unsigned char *in, const unsigned char *inend, unsigned char *out, unsigned char *outend)
1130 {
1131         int c;
1132         unsigned char *outstart = out;
1133         while (out < outend)
1134         {
1135                 if (in == inend)
1136                 {
1137                         Con_Printf("Mod_Q1BSP_DecompressVis: input underrun on model \"%s\" (decompressed %i of %i output bytes)\n", loadmodel->name, (int)(out - outstart), (int)(outend - outstart));
1138                         return;
1139                 }
1140                 c = *in++;
1141                 if (c)
1142                         *out++ = c;
1143                 else
1144                 {
1145                         if (in == inend)
1146                         {
1147                                 Con_Printf("Mod_Q1BSP_DecompressVis: input underrun (during zero-run) on model \"%s\" (decompressed %i of %i output bytes)\n", loadmodel->name, (int)(out - outstart), (int)(outend - outstart));
1148                                 return;
1149                         }
1150                         for (c = *in++;c > 0;c--)
1151                         {
1152                                 if (out == outend)
1153                                 {
1154                                         Con_Printf("Mod_Q1BSP_DecompressVis: output overrun on model \"%s\" (decompressed %i of %i output bytes)\n", loadmodel->name, (int)(out - outstart), (int)(outend - outstart));
1155                                         return;
1156                                 }
1157                                 *out++ = 0;
1158                         }
1159                 }
1160         }
1161 }
1162
1163 /*
1164 =============
1165 R_Q1BSP_LoadSplitSky
1166
1167 A sky texture is 256*128, with the right side being a masked overlay
1168 ==============
1169 */
1170 void R_Q1BSP_LoadSplitSky (unsigned char *src, int width, int height, int bytesperpixel)
1171 {
1172         int i, j;
1173         unsigned solidpixels[128*128], alphapixels[128*128];
1174
1175         // if sky isn't the right size, just use it as a solid layer
1176         if (width != 256 || height != 128)
1177         {
1178                 loadmodel->brush.solidskytexture = R_LoadTexture2D(loadmodel->texturepool, "sky_solidtexture", width, height, src, bytesperpixel == 4 ? TEXTYPE_RGBA : TEXTYPE_PALETTE, TEXF_PRECACHE, bytesperpixel == 1 ? palette_complete : NULL);
1179                 loadmodel->brush.alphaskytexture = NULL;
1180                 return;
1181         }
1182
1183         if (bytesperpixel == 4)
1184         {
1185                 for (i = 0;i < 128;i++)
1186                 {
1187                         for (j = 0;j < 128;j++)
1188                         {
1189                                 solidpixels[(i*128) + j] = ((unsigned *)src)[i*256+j+128];
1190                                 alphapixels[(i*128) + j] = ((unsigned *)src)[i*256+j];
1191                         }
1192                 }
1193         }
1194         else
1195         {
1196                 // make an average value for the back to avoid
1197                 // a fringe on the top level
1198                 int p, r, g, b;
1199                 union
1200                 {
1201                         unsigned int i;
1202                         unsigned char b[4];
1203                 }
1204                 rgba;
1205                 r = g = b = 0;
1206                 for (i = 0;i < 128;i++)
1207                 {
1208                         for (j = 0;j < 128;j++)
1209                         {
1210                                 rgba.i = palette_complete[src[i*256 + j + 128]];
1211                                 r += rgba.b[0];
1212                                 g += rgba.b[1];
1213                                 b += rgba.b[2];
1214                         }
1215                 }
1216                 rgba.b[0] = r/(128*128);
1217                 rgba.b[1] = g/(128*128);
1218                 rgba.b[2] = b/(128*128);
1219                 rgba.b[3] = 0;
1220                 for (i = 0;i < 128;i++)
1221                 {
1222                         for (j = 0;j < 128;j++)
1223                         {
1224                                 solidpixels[(i*128) + j] = palette_complete[src[i*256 + j + 128]];
1225                                 alphapixels[(i*128) + j] = (p = src[i*256 + j]) ? palette_complete[p] : rgba.i;
1226                         }
1227                 }
1228         }
1229
1230         loadmodel->brush.solidskytexture = R_LoadTexture2D(loadmodel->texturepool, "sky_solidtexture", 128, 128, (unsigned char *) solidpixels, TEXTYPE_RGBA, TEXF_PRECACHE, NULL);
1231         loadmodel->brush.alphaskytexture = R_LoadTexture2D(loadmodel->texturepool, "sky_alphatexture", 128, 128, (unsigned char *) alphapixels, TEXTYPE_RGBA, TEXF_ALPHA | TEXF_PRECACHE, NULL);
1232 }
1233
1234 static void Mod_Q1BSP_LoadTextures(lump_t *l)
1235 {
1236         int i, j, k, num, max, altmax, mtwidth, mtheight, *dofs, incomplete;
1237         miptex_t *dmiptex;
1238         texture_t *tx, *tx2, *anims[10], *altanims[10];
1239         dmiptexlump_t *m;
1240         unsigned char *data, *mtdata;
1241         const char *s;
1242         char mapname[MAX_QPATH], name[MAX_QPATH];
1243
1244         loadmodel->data_textures = NULL;
1245
1246         // add two slots for notexture walls and notexture liquids
1247         if (l->filelen)
1248         {
1249                 m = (dmiptexlump_t *)(mod_base + l->fileofs);
1250                 m->nummiptex = LittleLong (m->nummiptex);
1251                 loadmodel->num_textures = m->nummiptex + 2;
1252         }
1253         else
1254         {
1255                 m = NULL;
1256                 loadmodel->num_textures = 2;
1257         }
1258
1259         loadmodel->data_textures = (texture_t *)Mem_Alloc(loadmodel->mempool, loadmodel->num_textures * sizeof(texture_t));
1260
1261         // fill out all slots with notexture
1262         for (i = 0, tx = loadmodel->data_textures;i < loadmodel->num_textures;i++, tx++)
1263         {
1264                 strlcpy(tx->name, "NO TEXTURE FOUND", sizeof(tx->name));
1265                 tx->width = 16;
1266                 tx->height = 16;
1267                 tx->numskinframes = 1;
1268                 tx->skinframerate = 1;
1269                 tx->currentskinframe = tx->skinframes;
1270                 tx->skinframes[0].base = r_texture_notexture;
1271                 tx->backgroundcurrentskinframe = tx->backgroundskinframes;
1272                 tx->basematerialflags = 0;
1273                 if (i == loadmodel->num_textures - 1)
1274                 {
1275                         tx->basematerialflags |= MATERIALFLAG_WATER | MATERIALFLAG_LIGHTBOTHSIDES | MATERIALFLAG_NOSHADOW;
1276                         tx->supercontents = mod_q1bsp_texture_water.supercontents;
1277                         tx->surfaceflags = mod_q1bsp_texture_water.surfaceflags;
1278                 }
1279                 else
1280                 {
1281                         tx->basematerialflags |= MATERIALFLAG_WALL;
1282                         tx->supercontents = mod_q1bsp_texture_solid.supercontents;
1283                         tx->surfaceflags = mod_q1bsp_texture_solid.surfaceflags;
1284                 }
1285                 tx->currentframe = tx;
1286         }
1287
1288         if (!m)
1289                 return;
1290
1291         s = loadmodel->name;
1292         if (!strncasecmp(s, "maps/", 5))
1293                 s += 5;
1294         FS_StripExtension(s, mapname, sizeof(mapname));
1295
1296         // just to work around bounds checking when debugging with it (array index out of bounds error thing)
1297         dofs = m->dataofs;
1298         // LordHavoc: mostly rewritten map texture loader
1299         for (i = 0;i < m->nummiptex;i++)
1300         {
1301                 dofs[i] = LittleLong(dofs[i]);
1302                 if (dofs[i] == -1 || r_nosurftextures.integer)
1303                         continue;
1304                 dmiptex = (miptex_t *)((unsigned char *)m + dofs[i]);
1305
1306                 // make sure name is no more than 15 characters
1307                 for (j = 0;dmiptex->name[j] && j < 15;j++)
1308                         name[j] = dmiptex->name[j];
1309                 name[j] = 0;
1310
1311                 mtwidth = LittleLong(dmiptex->width);
1312                 mtheight = LittleLong(dmiptex->height);
1313                 mtdata = NULL;
1314                 j = LittleLong(dmiptex->offsets[0]);
1315                 if (j)
1316                 {
1317                         // texture included
1318                         if (j < 40 || j + mtwidth * mtheight > l->filelen)
1319                         {
1320                                 Con_Printf("Texture \"%s\" in \"%s\"is corrupt or incomplete\n", dmiptex->name, loadmodel->name);
1321                                 continue;
1322                         }
1323                         mtdata = (unsigned char *)dmiptex + j;
1324                 }
1325
1326                 if ((mtwidth & 15) || (mtheight & 15))
1327                         Con_Printf("warning: texture \"%s\" in \"%s\" is not 16 aligned\n", dmiptex->name, loadmodel->name);
1328
1329                 // LordHavoc: force all names to lowercase
1330                 for (j = 0;name[j];j++)
1331                         if (name[j] >= 'A' && name[j] <= 'Z')
1332                                 name[j] += 'a' - 'A';
1333
1334                 tx = loadmodel->data_textures + i;
1335                 strlcpy(tx->name, name, sizeof(tx->name));
1336                 tx->width = mtwidth;
1337                 tx->height = mtheight;
1338
1339                 if (!tx->name[0])
1340                 {
1341                         sprintf(tx->name, "unnamed%i", i);
1342                         Con_Printf("warning: unnamed texture in %s, renaming to %s\n", loadmodel->name, tx->name);
1343                 }
1344
1345                 if (cls.state != ca_dedicated)
1346                 {
1347                         // LordHavoc: HL sky textures are entirely different than quake
1348                         if (!loadmodel->brush.ishlbsp && !strncmp(tx->name, "sky", 3) && mtwidth == 256 && mtheight == 128)
1349                         {
1350                                 if (loadmodel->isworldmodel)
1351                                 {
1352                                         data = loadimagepixels(tx->name, false, 0, 0);
1353                                         if (data)
1354                                         {
1355                                                 R_Q1BSP_LoadSplitSky(data, image_width, image_height, 4);
1356                                                 Mem_Free(data);
1357                                         }
1358                                         else if (mtdata != NULL)
1359                                                 R_Q1BSP_LoadSplitSky(mtdata, mtwidth, mtheight, 1);
1360                                 }
1361                         }
1362                         else
1363                         {
1364                                 if (!Mod_LoadSkinFrame(&tx->skinframes[0], gamemode == GAME_TENEBRAE ? tx->name : va("textures/%s/%s", mapname, tx->name), TEXF_MIPMAP | TEXF_ALPHA | TEXF_PRECACHE | TEXF_PICMIP, false, true)
1365                                  && !Mod_LoadSkinFrame(&tx->skinframes[0], gamemode == GAME_TENEBRAE ? tx->name : va("textures/%s", tx->name), TEXF_MIPMAP | TEXF_ALPHA | TEXF_PRECACHE | TEXF_PICMIP, false, true))
1366                                 {
1367                                         // did not find external texture, load it from the bsp or wad3
1368                                         if (loadmodel->brush.ishlbsp)
1369                                         {
1370                                                 // internal texture overrides wad
1371                                                 unsigned char *pixels, *freepixels;
1372                                                 pixels = freepixels = NULL;
1373                                                 if (mtdata)
1374                                                         pixels = W_ConvertWAD3Texture(dmiptex);
1375                                                 if (pixels == NULL)
1376                                                         pixels = freepixels = W_GetTexture(tx->name);
1377                                                 if (pixels != NULL)
1378                                                 {
1379                                                         tx->width = image_width;
1380                                                         tx->height = image_height;
1381                                                         Mod_LoadSkinFrame_Internal(&tx->skinframes[0], tx->name, TEXF_MIPMAP | TEXF_ALPHA | TEXF_PRECACHE | TEXF_PICMIP, false, false, pixels, image_width, image_height, 32, NULL, NULL);
1382                                                 }
1383                                                 if (freepixels)
1384                                                         Mem_Free(freepixels);
1385                                         }
1386                                         else if (mtdata) // texture included
1387                                                 Mod_LoadSkinFrame_Internal(&tx->skinframes[0], tx->name, TEXF_MIPMAP | TEXF_PRECACHE | TEXF_PICMIP, false, r_fullbrights.integer, mtdata, tx->width, tx->height, 8, NULL, NULL);
1388                                 }
1389                         }
1390                         if (tx->skinframes[0].base == NULL)
1391                         {
1392                                 // no texture found
1393                                 tx->width = 16;
1394                                 tx->height = 16;
1395                                 tx->skinframes[0].base = r_texture_notexture;
1396                         }
1397                 }
1398
1399                 tx->basematerialflags = 0;
1400                 if (tx->name[0] == '*')
1401                 {
1402                         // LordHavoc: some turbulent textures should not be affected by wateralpha
1403                         if (strncmp(tx->name,"*lava",5)
1404                          && strncmp(tx->name,"*teleport",9)
1405                          && strncmp(tx->name,"*rift",5)) // Scourge of Armagon texture
1406                                 tx->basematerialflags |= MATERIALFLAG_WATERALPHA | MATERIALFLAG_NOSHADOW;
1407                         if (!strncmp(tx->name, "*lava", 5))
1408                         {
1409                                 tx->supercontents = mod_q1bsp_texture_lava.supercontents;
1410                                 tx->surfaceflags = mod_q1bsp_texture_lava.surfaceflags;
1411                         }
1412                         else if (!strncmp(tx->name, "*slime", 6))
1413                         {
1414                                 tx->supercontents = mod_q1bsp_texture_slime.supercontents;
1415                                 tx->surfaceflags = mod_q1bsp_texture_slime.surfaceflags;
1416                         }
1417                         else
1418                         {
1419                                 tx->supercontents = mod_q1bsp_texture_water.supercontents;
1420                                 tx->surfaceflags = mod_q1bsp_texture_water.surfaceflags;
1421                         }
1422                         tx->basematerialflags |= MATERIALFLAG_WATER | MATERIALFLAG_LIGHTBOTHSIDES | MATERIALFLAG_NOSHADOW;
1423                 }
1424                 else if (tx->name[0] == 's' && tx->name[1] == 'k' && tx->name[2] == 'y')
1425                 {
1426                         tx->supercontents = mod_q1bsp_texture_sky.supercontents;
1427                         tx->surfaceflags = mod_q1bsp_texture_sky.surfaceflags;
1428                         tx->basematerialflags |= MATERIALFLAG_SKY | MATERIALFLAG_NOSHADOW;
1429                 }
1430                 else
1431                 {
1432                         tx->supercontents = mod_q1bsp_texture_solid.supercontents;
1433                         tx->surfaceflags = mod_q1bsp_texture_solid.surfaceflags;
1434                         tx->basematerialflags |= MATERIALFLAG_WALL;
1435                 }
1436                 if (tx->skinframes[0].fog)
1437                         tx->basematerialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_TRANSPARENT | MATERIALFLAG_NOSHADOW;
1438
1439                 // start out with no animation
1440                 tx->currentframe = tx;
1441         }
1442
1443         // sequence the animations
1444         for (i = 0;i < m->nummiptex;i++)
1445         {
1446                 tx = loadmodel->data_textures + i;
1447                 if (!tx || tx->name[0] != '+' || tx->name[1] == 0 || tx->name[2] == 0)
1448                         continue;
1449                 if (tx->anim_total[0] || tx->anim_total[1])
1450                         continue;       // already sequenced
1451
1452                 // find the number of frames in the animation
1453                 memset(anims, 0, sizeof(anims));
1454                 memset(altanims, 0, sizeof(altanims));
1455
1456                 for (j = i;j < m->nummiptex;j++)
1457                 {
1458                         tx2 = loadmodel->data_textures + j;
1459                         if (!tx2 || tx2->name[0] != '+' || strcmp(tx2->name+2, tx->name+2))
1460                                 continue;
1461
1462                         num = tx2->name[1];
1463                         if (num >= '0' && num <= '9')
1464                                 anims[num - '0'] = tx2;
1465                         else if (num >= 'a' && num <= 'j')
1466                                 altanims[num - 'a'] = tx2;
1467                         else
1468                                 Con_Printf("Bad animating texture %s\n", tx->name);
1469                 }
1470
1471                 max = altmax = 0;
1472                 for (j = 0;j < 10;j++)
1473                 {
1474                         if (anims[j])
1475                                 max = j + 1;
1476                         if (altanims[j])
1477                                 altmax = j + 1;
1478                 }
1479                 //Con_Printf("linking animation %s (%i:%i frames)\n\n", tx->name, max, altmax);
1480
1481                 incomplete = false;
1482                 for (j = 0;j < max;j++)
1483                 {
1484                         if (!anims[j])
1485                         {
1486                                 Con_Printf("Missing frame %i of %s\n", j, tx->name);
1487                                 incomplete = true;
1488                         }
1489                 }
1490                 for (j = 0;j < altmax;j++)
1491                 {
1492                         if (!altanims[j])
1493                         {
1494                                 Con_Printf("Missing altframe %i of %s\n", j, tx->name);
1495                                 incomplete = true;
1496                         }
1497                 }
1498                 if (incomplete)
1499                         continue;
1500
1501                 if (altmax < 1)
1502                 {
1503                         // if there is no alternate animation, duplicate the primary
1504                         // animation into the alternate
1505                         altmax = max;
1506                         for (k = 0;k < 10;k++)
1507                                 altanims[k] = anims[k];
1508                 }
1509
1510                 // link together the primary animation
1511                 for (j = 0;j < max;j++)
1512                 {
1513                         tx2 = anims[j];
1514                         tx2->animated = true;
1515                         tx2->anim_total[0] = max;
1516                         tx2->anim_total[1] = altmax;
1517                         for (k = 0;k < 10;k++)
1518                         {
1519                                 tx2->anim_frames[0][k] = anims[k];
1520                                 tx2->anim_frames[1][k] = altanims[k];
1521                         }
1522                 }
1523
1524                 // if there really is an alternate anim...
1525                 if (anims[0] != altanims[0])
1526                 {
1527                         // link together the alternate animation
1528                         for (j = 0;j < altmax;j++)
1529                         {
1530                                 tx2 = altanims[j];
1531                                 tx2->animated = true;
1532                                 // the primary/alternate are reversed here
1533                                 tx2->anim_total[0] = altmax;
1534                                 tx2->anim_total[1] = max;
1535                                 for (k = 0;k < 10;k++)
1536                                 {
1537                                         tx2->anim_frames[0][k] = altanims[k];
1538                                         tx2->anim_frames[1][k] = anims[k];
1539                                 }
1540                         }
1541                 }
1542         }
1543 }
1544
1545 static void Mod_Q1BSP_LoadLighting(lump_t *l)
1546 {
1547         int i;
1548         unsigned char *in, *out, *data, d;
1549         char litfilename[MAX_QPATH];
1550         char dlitfilename[MAX_QPATH];
1551         fs_offset_t filesize;
1552         if (loadmodel->brush.ishlbsp) // LordHavoc: load the colored lighting data straight
1553         {
1554                 loadmodel->brushq1.lightdata = (unsigned char *)Mem_Alloc(loadmodel->mempool, l->filelen);
1555                 for (i=0; i<l->filelen; i++)
1556                         loadmodel->brushq1.lightdata[i] = mod_base[l->fileofs+i] >>= 1;
1557         }
1558         else if (loadmodel->brush.ismcbsp)
1559         {
1560                 loadmodel->brushq1.lightdata = (unsigned char *)Mem_Alloc(loadmodel->mempool, l->filelen);
1561                 memcpy(loadmodel->brushq1.lightdata, mod_base + l->fileofs, l->filelen);
1562         }
1563         else // LordHavoc: bsp version 29 (normal white lighting)
1564         {
1565                 // LordHavoc: hope is not lost yet, check for a .lit file to load
1566                 strlcpy (litfilename, loadmodel->name, sizeof (litfilename));
1567                 FS_StripExtension (litfilename, litfilename, sizeof (litfilename));
1568                 strlcpy (dlitfilename, litfilename, sizeof (dlitfilename));
1569                 strlcat (litfilename, ".lit", sizeof (litfilename));
1570                 strlcat (dlitfilename, ".dlit", sizeof (dlitfilename));
1571                 data = (unsigned char*) FS_LoadFile(litfilename, tempmempool, false, &filesize);
1572                 if (data)
1573                 {
1574                         if (filesize == (fs_offset_t)(8 + l->filelen * 3) && data[0] == 'Q' && data[1] == 'L' && data[2] == 'I' && data[3] == 'T')
1575                         {
1576                                 i = LittleLong(((int *)data)[1]);
1577                                 if (i == 1)
1578                                 {
1579                                         Con_DPrintf("loaded %s\n", litfilename);
1580                                         loadmodel->brushq1.lightdata = (unsigned char *)Mem_Alloc(loadmodel->mempool, filesize - 8);
1581                                         memcpy(loadmodel->brushq1.lightdata, data + 8, filesize - 8);
1582                                         Mem_Free(data);
1583                                         data = (unsigned char*) FS_LoadFile(dlitfilename, tempmempool, false, &filesize);
1584                                         if (data)
1585                                         {
1586                                                 if (filesize == (fs_offset_t)(8 + l->filelen * 3) && data[0] == 'Q' && data[1] == 'L' && data[2] == 'I' && data[3] == 'T')
1587                                                 {
1588                                                         i = LittleLong(((int *)data)[1]);
1589                                                         if (i == 1)
1590                                                         {
1591                                                                 Con_DPrintf("loaded %s\n", dlitfilename);
1592                                                                 loadmodel->brushq1.nmaplightdata = (unsigned char *)Mem_Alloc(loadmodel->mempool, filesize - 8);
1593                                                                 memcpy(loadmodel->brushq1.nmaplightdata, data + 8, filesize - 8);
1594                                                                 loadmodel->brushq3.deluxemapping_modelspace = false;
1595                                                                 loadmodel->brushq3.deluxemapping = true;
1596                                                         }
1597                                                 }
1598                                                 Mem_Free(data);
1599                                                 data = NULL;
1600                                         }
1601                                         return;
1602                                 }
1603                                 else
1604                                         Con_Printf("Unknown .lit file version (%d)\n", i);
1605                         }
1606                         else if (filesize == 8)
1607                                 Con_Print("Empty .lit file, ignoring\n");
1608                         else
1609                                 Con_Printf("Corrupt .lit file (file size %i bytes, should be %i bytes), ignoring\n", (int) filesize, (int) (8 + l->filelen * 3));
1610                         if (data)
1611                         {
1612                                 Mem_Free(data);
1613                                 data = NULL;
1614                         }
1615                 }
1616                 // LordHavoc: oh well, expand the white lighting data
1617                 if (!l->filelen)
1618                         return;
1619                 loadmodel->brushq1.lightdata = (unsigned char *)Mem_Alloc(loadmodel->mempool, l->filelen*3);
1620                 in = mod_base + l->fileofs;
1621                 out = loadmodel->brushq1.lightdata;
1622                 for (i = 0;i < l->filelen;i++)
1623                 {
1624                         d = *in++;
1625                         *out++ = d;
1626                         *out++ = d;
1627                         *out++ = d;
1628                 }
1629         }
1630 }
1631
1632 static void Mod_Q1BSP_LoadVisibility(lump_t *l)
1633 {
1634         loadmodel->brushq1.num_compressedpvs = 0;
1635         loadmodel->brushq1.data_compressedpvs = NULL;
1636         if (!l->filelen)
1637                 return;
1638         loadmodel->brushq1.num_compressedpvs = l->filelen;
1639         loadmodel->brushq1.data_compressedpvs = (unsigned char *)Mem_Alloc(loadmodel->mempool, l->filelen);
1640         memcpy(loadmodel->brushq1.data_compressedpvs, mod_base + l->fileofs, l->filelen);
1641 }
1642
1643 // used only for HalfLife maps
1644 static void Mod_Q1BSP_ParseWadsFromEntityLump(const char *data)
1645 {
1646         char key[128], value[4096];
1647         char wadname[128];
1648         int i, j, k;
1649         if (!data)
1650                 return;
1651         if (!COM_ParseTokenConsole(&data))
1652                 return; // error
1653         if (com_token[0] != '{')
1654                 return; // error
1655         while (1)
1656         {
1657                 if (!COM_ParseTokenConsole(&data))
1658                         return; // error
1659                 if (com_token[0] == '}')
1660                         break; // end of worldspawn
1661                 if (com_token[0] == '_')
1662                         strlcpy(key, com_token + 1, sizeof(key));
1663                 else
1664                         strlcpy(key, com_token, sizeof(key));
1665                 while (key[strlen(key)-1] == ' ') // remove trailing spaces
1666                         key[strlen(key)-1] = 0;
1667                 if (!COM_ParseTokenConsole(&data))
1668                         return; // error
1669                 dpsnprintf(value, sizeof(value), "%s", com_token);
1670                 if (!strcmp("wad", key)) // for HalfLife maps
1671                 {
1672                         if (loadmodel->brush.ishlbsp)
1673                         {
1674                                 j = 0;
1675                                 for (i = 0;i < (int)sizeof(value);i++)
1676                                         if (value[i] != ';' && value[i] != '\\' && value[i] != '/' && value[i] != ':')
1677                                                 break;
1678                                 if (value[i])
1679                                 {
1680                                         for (;i < (int)sizeof(value);i++)
1681                                         {
1682                                                 // ignore path - the \\ check is for HalfLife... stupid windoze 'programmers'...
1683                                                 if (value[i] == '\\' || value[i] == '/' || value[i] == ':')
1684                                                         j = i+1;
1685                                                 else if (value[i] == ';' || value[i] == 0)
1686                                                 {
1687                                                         k = value[i];
1688                                                         value[i] = 0;
1689                                                         strlcpy(wadname, "textures/", sizeof(wadname));
1690                                                         strlcat(wadname, &value[j], sizeof(wadname));
1691                                                         W_LoadTextureWadFile(wadname, false);
1692                                                         j = i+1;
1693                                                         if (!k)
1694                                                                 break;
1695                                                 }
1696                                         }
1697                                 }
1698                         }
1699                 }
1700         }
1701 }
1702
1703 static void Mod_Q1BSP_LoadEntities(lump_t *l)
1704 {
1705         loadmodel->brush.entities = NULL;
1706         if (!l->filelen)
1707                 return;
1708         loadmodel->brush.entities = (char *)Mem_Alloc(loadmodel->mempool, l->filelen);
1709         memcpy(loadmodel->brush.entities, mod_base + l->fileofs, l->filelen);
1710         if (loadmodel->brush.ishlbsp)
1711                 Mod_Q1BSP_ParseWadsFromEntityLump(loadmodel->brush.entities);
1712 }
1713
1714
1715 static void Mod_Q1BSP_LoadVertexes(lump_t *l)
1716 {
1717         dvertex_t       *in;
1718         mvertex_t       *out;
1719         int                     i, count;
1720
1721         in = (dvertex_t *)(mod_base + l->fileofs);
1722         if (l->filelen % sizeof(*in))
1723                 Host_Error("Mod_Q1BSP_LoadVertexes: funny lump size in %s",loadmodel->name);
1724         count = l->filelen / sizeof(*in);
1725         out = (mvertex_t *)Mem_Alloc(loadmodel->mempool, count*sizeof(*out));
1726
1727         loadmodel->brushq1.vertexes = out;
1728         loadmodel->brushq1.numvertexes = count;
1729
1730         for ( i=0 ; i<count ; i++, in++, out++)
1731         {
1732                 out->position[0] = LittleFloat(in->point[0]);
1733                 out->position[1] = LittleFloat(in->point[1]);
1734                 out->position[2] = LittleFloat(in->point[2]);
1735         }
1736 }
1737
1738 // The following two functions should be removed and MSG_* or SZ_* function sets adjusted so they
1739 // can be used for this
1740 // REMOVEME
1741 int SB_ReadInt (unsigned char **buffer)
1742 {
1743         int     i;
1744         i = ((*buffer)[0]) + 256*((*buffer)[1]) + 65536*((*buffer)[2]) + 16777216*((*buffer)[3]);
1745         (*buffer) += 4;
1746         return i;
1747 }
1748
1749 // REMOVEME
1750 float SB_ReadFloat (unsigned char **buffer)
1751 {
1752         union
1753         {
1754                 int             i;
1755                 float   f;
1756         } u;
1757
1758         u.i = SB_ReadInt (buffer);
1759         return u.f;
1760 }
1761
1762 static void Mod_Q1BSP_LoadSubmodels(lump_t *l, hullinfo_t *hullinfo)
1763 {
1764         unsigned char           *index;
1765         dmodel_t        *out;
1766         int                     i, j, count;
1767
1768         index = (unsigned char *)(mod_base + l->fileofs);
1769         if (l->filelen % (48+4*hullinfo->filehulls))
1770                 Host_Error ("Mod_Q1BSP_LoadSubmodels: funny lump size in %s", loadmodel->name);
1771
1772         count = l->filelen / (48+4*hullinfo->filehulls);
1773         out = (dmodel_t *)Mem_Alloc (loadmodel->mempool, count*sizeof(*out));
1774
1775         loadmodel->brushq1.submodels = out;
1776         loadmodel->brush.numsubmodels = count;
1777
1778         for (i = 0; i < count; i++, out++)
1779         {
1780         // spread out the mins / maxs by a pixel
1781                 out->mins[0] = SB_ReadFloat (&index) - 1;
1782                 out->mins[1] = SB_ReadFloat (&index) - 1;
1783                 out->mins[2] = SB_ReadFloat (&index) - 1;
1784                 out->maxs[0] = SB_ReadFloat (&index) + 1;
1785                 out->maxs[1] = SB_ReadFloat (&index) + 1;
1786                 out->maxs[2] = SB_ReadFloat (&index) + 1;
1787                 out->origin[0] = SB_ReadFloat (&index);
1788                 out->origin[1] = SB_ReadFloat (&index);
1789                 out->origin[2] = SB_ReadFloat (&index);
1790                 for (j = 0; j < hullinfo->filehulls; j++)
1791                         out->headnode[j] = SB_ReadInt (&index);
1792                 out->visleafs = SB_ReadInt (&index);
1793                 out->firstface = SB_ReadInt (&index);
1794                 out->numfaces = SB_ReadInt (&index);
1795         }
1796 }
1797
1798 static void Mod_Q1BSP_LoadEdges(lump_t *l)
1799 {
1800         dedge_t *in;
1801         medge_t *out;
1802         int     i, count;
1803
1804         in = (dedge_t *)(mod_base + l->fileofs);
1805         if (l->filelen % sizeof(*in))
1806                 Host_Error("Mod_Q1BSP_LoadEdges: funny lump size in %s",loadmodel->name);
1807         count = l->filelen / sizeof(*in);
1808         out = (medge_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
1809
1810         loadmodel->brushq1.edges = out;
1811         loadmodel->brushq1.numedges = count;
1812
1813         for ( i=0 ; i<count ; i++, in++, out++)
1814         {
1815                 out->v[0] = (unsigned short)LittleShort(in->v[0]);
1816                 out->v[1] = (unsigned short)LittleShort(in->v[1]);
1817                 if (out->v[0] >= loadmodel->brushq1.numvertexes || out->v[1] >= loadmodel->brushq1.numvertexes)
1818                 {
1819                         Con_Printf("Mod_Q1BSP_LoadEdges: %s has invalid vertex indices in edge %i (vertices %i %i >= numvertices %i)\n", loadmodel->name, i, out->v[0], out->v[1], loadmodel->brushq1.numvertexes);
1820                         out->v[0] = 0;
1821                         out->v[1] = 0;
1822                 }
1823         }
1824 }
1825
1826 static void Mod_Q1BSP_LoadTexinfo(lump_t *l)
1827 {
1828         texinfo_t *in;
1829         mtexinfo_t *out;
1830         int i, j, k, count, miptex;
1831
1832         in = (texinfo_t *)(mod_base + l->fileofs);
1833         if (l->filelen % sizeof(*in))
1834                 Host_Error("Mod_Q1BSP_LoadTexinfo: funny lump size in %s",loadmodel->name);
1835         count = l->filelen / sizeof(*in);
1836         out = (mtexinfo_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
1837
1838         loadmodel->brushq1.texinfo = out;
1839         loadmodel->brushq1.numtexinfo = count;
1840
1841         for (i = 0;i < count;i++, in++, out++)
1842         {
1843                 for (k = 0;k < 2;k++)
1844                         for (j = 0;j < 4;j++)
1845                                 out->vecs[k][j] = LittleFloat(in->vecs[k][j]);
1846
1847                 miptex = LittleLong(in->miptex);
1848                 out->flags = LittleLong(in->flags);
1849
1850                 out->texture = NULL;
1851                 if (loadmodel->data_textures)
1852                 {
1853                         if ((unsigned int) miptex >= (unsigned int) loadmodel->num_textures)
1854                                 Con_Printf("error in model \"%s\": invalid miptex index %i(of %i)\n", loadmodel->name, miptex, loadmodel->num_textures);
1855                         else
1856                                 out->texture = loadmodel->data_textures + miptex;
1857                 }
1858                 if (out->flags & TEX_SPECIAL)
1859                 {
1860                         // if texture chosen is NULL or the shader needs a lightmap,
1861                         // force to notexture water shader
1862                         if (out->texture == NULL || out->texture->basematerialflags & MATERIALFLAG_WALL)
1863                                 out->texture = loadmodel->data_textures + (loadmodel->num_textures - 1);
1864                 }
1865                 else
1866                 {
1867                         // if texture chosen is NULL, force to notexture
1868                         if (out->texture == NULL)
1869                                 out->texture = loadmodel->data_textures + (loadmodel->num_textures - 2);
1870                 }
1871         }
1872 }
1873
1874 #if 0
1875 void BoundPoly(int numverts, float *verts, vec3_t mins, vec3_t maxs)
1876 {
1877         int             i, j;
1878         float   *v;
1879
1880         mins[0] = mins[1] = mins[2] = 9999;
1881         maxs[0] = maxs[1] = maxs[2] = -9999;
1882         v = verts;
1883         for (i = 0;i < numverts;i++)
1884         {
1885                 for (j = 0;j < 3;j++, v++)
1886                 {
1887                         if (*v < mins[j])
1888                                 mins[j] = *v;
1889                         if (*v > maxs[j])
1890                                 maxs[j] = *v;
1891                 }
1892         }
1893 }
1894
1895 #define MAX_SUBDIVPOLYTRIANGLES 4096
1896 #define MAX_SUBDIVPOLYVERTS(MAX_SUBDIVPOLYTRIANGLES * 3)
1897
1898 static int subdivpolyverts, subdivpolytriangles;
1899 static int subdivpolyindex[MAX_SUBDIVPOLYTRIANGLES][3];
1900 static float subdivpolyvert[MAX_SUBDIVPOLYVERTS][3];
1901
1902 static int subdivpolylookupvert(vec3_t v)
1903 {
1904         int i;
1905         for (i = 0;i < subdivpolyverts;i++)
1906                 if (subdivpolyvert[i][0] == v[0]
1907                  && subdivpolyvert[i][1] == v[1]
1908                  && subdivpolyvert[i][2] == v[2])
1909                         return i;
1910         if (subdivpolyverts >= MAX_SUBDIVPOLYVERTS)
1911                 Host_Error("SubDividePolygon: ran out of vertices in buffer, please increase your r_subdivide_size");
1912         VectorCopy(v, subdivpolyvert[subdivpolyverts]);
1913         return subdivpolyverts++;
1914 }
1915
1916 static void SubdividePolygon(int numverts, float *verts)
1917 {
1918         int             i, i1, i2, i3, f, b, c, p;
1919         vec3_t  mins, maxs, front[256], back[256];
1920         float   m, *pv, *cv, dist[256], frac;
1921
1922         if (numverts > 250)
1923                 Host_Error("SubdividePolygon: ran out of verts in buffer");
1924
1925         BoundPoly(numverts, verts, mins, maxs);
1926
1927         for (i = 0;i < 3;i++)
1928         {
1929                 m = (mins[i] + maxs[i]) * 0.5;
1930                 m = r_subdivide_size.value * floor(m/r_subdivide_size.value + 0.5);
1931                 if (maxs[i] - m < 8)
1932                         continue;
1933                 if (m - mins[i] < 8)
1934                         continue;
1935
1936                 // cut it
1937                 for (cv = verts, c = 0;c < numverts;c++, cv += 3)
1938                         dist[c] = cv[i] - m;
1939
1940                 f = b = 0;
1941                 for (p = numverts - 1, c = 0, pv = verts + p * 3, cv = verts;c < numverts;p = c, c++, pv = cv, cv += 3)
1942                 {
1943                         if (dist[p] >= 0)
1944                         {
1945                                 VectorCopy(pv, front[f]);
1946                                 f++;
1947                         }
1948                         if (dist[p] <= 0)
1949                         {
1950                                 VectorCopy(pv, back[b]);
1951                                 b++;
1952                         }
1953                         if (dist[p] == 0 || dist[c] == 0)
1954                                 continue;
1955                         if ((dist[p] > 0) != (dist[c] > 0) )
1956                         {
1957                                 // clip point
1958                                 frac = dist[p] / (dist[p] - dist[c]);
1959                                 front[f][0] = back[b][0] = pv[0] + frac * (cv[0] - pv[0]);
1960                                 front[f][1] = back[b][1] = pv[1] + frac * (cv[1] - pv[1]);
1961                                 front[f][2] = back[b][2] = pv[2] + frac * (cv[2] - pv[2]);
1962                                 f++;
1963                                 b++;
1964                         }
1965                 }
1966
1967                 SubdividePolygon(f, front[0]);
1968                 SubdividePolygon(b, back[0]);
1969                 return;
1970         }
1971
1972         i1 = subdivpolylookupvert(verts);
1973         i2 = subdivpolylookupvert(verts + 3);
1974         for (i = 2;i < numverts;i++)
1975         {
1976                 if (subdivpolytriangles >= MAX_SUBDIVPOLYTRIANGLES)
1977                 {
1978                         Con_Print("SubdividePolygon: ran out of triangles in buffer, please increase your r_subdivide_size\n");
1979                         return;
1980                 }
1981
1982                 i3 = subdivpolylookupvert(verts + i * 3);
1983                 subdivpolyindex[subdivpolytriangles][0] = i1;
1984                 subdivpolyindex[subdivpolytriangles][1] = i2;
1985                 subdivpolyindex[subdivpolytriangles][2] = i3;
1986                 i2 = i3;
1987                 subdivpolytriangles++;
1988         }
1989 }
1990
1991 //Breaks a polygon up along axial 64 unit
1992 //boundaries so that turbulent and sky warps
1993 //can be done reasonably.
1994 static void Mod_Q1BSP_GenerateWarpMesh(msurface_t *surface)
1995 {
1996         int i, j;
1997         surfvertex_t *v;
1998         surfmesh_t *mesh;
1999
2000         subdivpolytriangles = 0;
2001         subdivpolyverts = 0;
2002         SubdividePolygon(surface->num_vertices, (surface->mesh->data_vertex3f + 3 * surface->num_firstvertex));
2003         if (subdivpolytriangles < 1)
2004                 Host_Error("Mod_Q1BSP_GenerateWarpMesh: no triangles?");
2005
2006         surface->mesh = mesh = Mem_Alloc(loadmodel->mempool, sizeof(surfmesh_t) + subdivpolytriangles * sizeof(int[3]) + subdivpolyverts * sizeof(surfvertex_t));
2007         mesh->num_vertices = subdivpolyverts;
2008         mesh->num_triangles = subdivpolytriangles;
2009         mesh->vertex = (surfvertex_t *)(mesh + 1);
2010         mesh->index = (int *)(mesh->vertex + mesh->num_vertices);
2011         memset(mesh->vertex, 0, mesh->num_vertices * sizeof(surfvertex_t));
2012
2013         for (i = 0;i < mesh->num_triangles;i++)
2014                 for (j = 0;j < 3;j++)
2015                         mesh->index[i*3+j] = subdivpolyindex[i][j];
2016
2017         for (i = 0, v = mesh->vertex;i < subdivpolyverts;i++, v++)
2018         {
2019                 VectorCopy(subdivpolyvert[i], v->v);
2020                 v->st[0] = DotProduct(v->v, surface->lightmapinfo->texinfo->vecs[0]);
2021                 v->st[1] = DotProduct(v->v, surface->lightmapinfo->texinfo->vecs[1]);
2022         }
2023 }
2024 #endif
2025
2026 static qboolean Mod_Q1BSP_AllocLightmapBlock(int *lineused, int totalwidth, int totalheight, int blockwidth, int blockheight, int *outx, int *outy)
2027 {
2028         int y, x2, y2;
2029         int bestx = totalwidth, besty = 0;
2030         // find the left-most space we can find
2031         for (y = 0;y <= totalheight - blockheight;y++)
2032         {
2033                 x2 = 0;
2034                 for (y2 = 0;y2 < blockheight;y2++)
2035                         x2 = max(x2, lineused[y+y2]);
2036                 if (bestx > x2)
2037                 {
2038                         bestx = x2;
2039                         besty = y;
2040                 }
2041         }
2042         // if the best was not good enough, return failure
2043         if (bestx > totalwidth - blockwidth)
2044                 return false;
2045         // we found a good spot
2046         if (outx)
2047                 *outx = bestx;
2048         if (outy)
2049                 *outy = besty;
2050         // now mark the space used
2051         for (y2 = 0;y2 < blockheight;y2++)
2052                 lineused[besty+y2] = bestx + blockwidth;
2053         // return success
2054         return true;
2055 }
2056
2057 static void Mod_Q1BSP_LoadFaces(lump_t *l)
2058 {
2059         dface_t *in;
2060         msurface_t *surface;
2061         int i, j, count, surfacenum, planenum, smax, tmax, ssize, tsize, firstedge, numedges, totalverts, totaltris, lightmapnumber;
2062         float texmins[2], texmaxs[2], val, lightmaptexcoordscale;
2063 #define LIGHTMAPSIZE 256
2064         rtexture_t *lightmaptexture, *deluxemaptexture;
2065         int lightmap_lineused[LIGHTMAPSIZE];
2066
2067         in = (dface_t *)(mod_base + l->fileofs);
2068         if (l->filelen % sizeof(*in))
2069                 Host_Error("Mod_Q1BSP_LoadFaces: funny lump size in %s",loadmodel->name);
2070         count = l->filelen / sizeof(*in);
2071         loadmodel->data_surfaces = (msurface_t *)Mem_Alloc(loadmodel->mempool, count*sizeof(msurface_t));
2072         loadmodel->data_surfaces_lightmapinfo = (msurface_lightmapinfo_t *)Mem_Alloc(loadmodel->mempool, count*sizeof(msurface_lightmapinfo_t));
2073
2074         loadmodel->num_surfaces = count;
2075
2076         totalverts = 0;
2077         totaltris = 0;
2078         for (surfacenum = 0, in = (dface_t *)(mod_base + l->fileofs);surfacenum < count;surfacenum++, in++)
2079         {
2080                 numedges = LittleShort(in->numedges);
2081                 totalverts += numedges;
2082                 totaltris += numedges - 2;
2083         }
2084
2085         Mod_AllocSurfMesh(loadmodel->mempool, totalverts, totaltris, true, false, false);
2086
2087         lightmaptexture = NULL;
2088         deluxemaptexture = r_texture_blanknormalmap;
2089         lightmapnumber = 1;
2090         lightmaptexcoordscale = 1.0f / (float)LIGHTMAPSIZE;
2091
2092         totalverts = 0;
2093         totaltris = 0;
2094         for (surfacenum = 0, in = (dface_t *)(mod_base + l->fileofs), surface = loadmodel->data_surfaces;surfacenum < count;surfacenum++, in++, surface++)
2095         {
2096                 surface->lightmapinfo = loadmodel->data_surfaces_lightmapinfo + surfacenum;
2097
2098                 // FIXME: validate edges, texinfo, etc?
2099                 firstedge = LittleLong(in->firstedge);
2100                 numedges = LittleShort(in->numedges);
2101                 if ((unsigned int) firstedge > (unsigned int) loadmodel->brushq1.numsurfedges || (unsigned int) numedges > (unsigned int) loadmodel->brushq1.numsurfedges || (unsigned int) firstedge + (unsigned int) numedges > (unsigned int) loadmodel->brushq1.numsurfedges)
2102                         Host_Error("Mod_Q1BSP_LoadFaces: invalid edge range (firstedge %i, numedges %i, model edges %i)", firstedge, numedges, loadmodel->brushq1.numsurfedges);
2103                 i = LittleShort(in->texinfo);
2104                 if ((unsigned int) i >= (unsigned int) loadmodel->brushq1.numtexinfo)
2105                         Host_Error("Mod_Q1BSP_LoadFaces: invalid texinfo index %i(model has %i texinfos)", i, loadmodel->brushq1.numtexinfo);
2106                 surface->lightmapinfo->texinfo = loadmodel->brushq1.texinfo + i;
2107                 surface->texture = surface->lightmapinfo->texinfo->texture;
2108
2109                 planenum = LittleShort(in->planenum);
2110                 if ((unsigned int) planenum >= (unsigned int) loadmodel->brush.num_planes)
2111                         Host_Error("Mod_Q1BSP_LoadFaces: invalid plane index %i (model has %i planes)", planenum, loadmodel->brush.num_planes);
2112
2113                 //surface->flags = surface->texture->flags;
2114                 //if (LittleShort(in->side))
2115                 //      surface->flags |= SURF_PLANEBACK;
2116                 //surface->plane = loadmodel->brush.data_planes + planenum;
2117
2118                 surface->num_firstvertex = totalverts;
2119                 surface->num_vertices = numedges;
2120                 surface->num_firsttriangle = totaltris;
2121                 surface->num_triangles = numedges - 2;
2122                 totalverts += numedges;
2123                 totaltris += numedges - 2;
2124
2125                 // convert edges back to a normal polygon
2126                 for (i = 0;i < surface->num_vertices;i++)
2127                 {
2128                         int lindex = loadmodel->brushq1.surfedges[firstedge + i];
2129                         float s, t;
2130                         if (lindex > 0)
2131                                 VectorCopy(loadmodel->brushq1.vertexes[loadmodel->brushq1.edges[lindex].v[0]].position, (loadmodel->surfmesh.data_vertex3f + 3 * surface->num_firstvertex) + i * 3);
2132                         else
2133                                 VectorCopy(loadmodel->brushq1.vertexes[loadmodel->brushq1.edges[-lindex].v[1]].position, (loadmodel->surfmesh.data_vertex3f + 3 * surface->num_firstvertex) + i * 3);
2134                         s = DotProduct(((loadmodel->surfmesh.data_vertex3f + 3 * surface->num_firstvertex) + i * 3), surface->lightmapinfo->texinfo->vecs[0]) + surface->lightmapinfo->texinfo->vecs[0][3];
2135                         t = DotProduct(((loadmodel->surfmesh.data_vertex3f + 3 * surface->num_firstvertex) + i * 3), surface->lightmapinfo->texinfo->vecs[1]) + surface->lightmapinfo->texinfo->vecs[1][3];
2136                         (loadmodel->surfmesh.data_texcoordtexture2f + 2 * surface->num_firstvertex)[i * 2 + 0] = s / surface->texture->width;
2137                         (loadmodel->surfmesh.data_texcoordtexture2f + 2 * surface->num_firstvertex)[i * 2 + 1] = t / surface->texture->height;
2138                         (loadmodel->surfmesh.data_texcoordlightmap2f + 2 * surface->num_firstvertex)[i * 2 + 0] = 0;
2139                         (loadmodel->surfmesh.data_texcoordlightmap2f + 2 * surface->num_firstvertex)[i * 2 + 1] = 0;
2140                         (loadmodel->surfmesh.data_lightmapoffsets + surface->num_firstvertex)[i] = 0;
2141                 }
2142
2143                 for (i = 0;i < surface->num_triangles;i++)
2144                 {
2145                         (loadmodel->surfmesh.data_element3i + 3 * surface->num_firsttriangle)[i * 3 + 0] = 0 + surface->num_firstvertex;
2146                         (loadmodel->surfmesh.data_element3i + 3 * surface->num_firsttriangle)[i * 3 + 1] = i + 1 + surface->num_firstvertex;
2147                         (loadmodel->surfmesh.data_element3i + 3 * surface->num_firsttriangle)[i * 3 + 2] = i + 2 + surface->num_firstvertex;
2148                 }
2149
2150                 // compile additional data about the surface geometry
2151                 Mod_BuildNormals(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, loadmodel->surfmesh.data_vertex3f, (loadmodel->surfmesh.data_element3i + 3 * surface->num_firsttriangle), loadmodel->surfmesh.data_normal3f, true);
2152                 Mod_BuildTextureVectorsFromNormals(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, loadmodel->surfmesh.data_vertex3f, loadmodel->surfmesh.data_texcoordtexture2f, loadmodel->surfmesh.data_normal3f, (loadmodel->surfmesh.data_element3i + 3 * surface->num_firsttriangle), loadmodel->surfmesh.data_svector3f, loadmodel->surfmesh.data_tvector3f, true);
2153                 BoxFromPoints(surface->mins, surface->maxs, surface->num_vertices, (loadmodel->surfmesh.data_vertex3f + 3 * surface->num_firstvertex));
2154
2155                 // generate surface extents information
2156                 texmins[0] = texmaxs[0] = DotProduct((loadmodel->surfmesh.data_vertex3f + 3 * surface->num_firstvertex), surface->lightmapinfo->texinfo->vecs[0]) + surface->lightmapinfo->texinfo->vecs[0][3];
2157                 texmins[1] = texmaxs[1] = DotProduct((loadmodel->surfmesh.data_vertex3f + 3 * surface->num_firstvertex), surface->lightmapinfo->texinfo->vecs[1]) + surface->lightmapinfo->texinfo->vecs[1][3];
2158                 for (i = 1;i < surface->num_vertices;i++)
2159                 {
2160                         for (j = 0;j < 2;j++)
2161                         {
2162                                 val = DotProduct((loadmodel->surfmesh.data_vertex3f + 3 * surface->num_firstvertex) + i * 3, surface->lightmapinfo->texinfo->vecs[j]) + surface->lightmapinfo->texinfo->vecs[j][3];
2163                                 texmins[j] = min(texmins[j], val);
2164                                 texmaxs[j] = max(texmaxs[j], val);
2165                         }
2166                 }
2167                 for (i = 0;i < 2;i++)
2168                 {
2169                         surface->lightmapinfo->texturemins[i] = (int) floor(texmins[i] / 16.0) * 16;
2170                         surface->lightmapinfo->extents[i] = (int) ceil(texmaxs[i] / 16.0) * 16 - surface->lightmapinfo->texturemins[i];
2171                 }
2172
2173                 smax = surface->lightmapinfo->extents[0] >> 4;
2174                 tmax = surface->lightmapinfo->extents[1] >> 4;
2175                 ssize = (surface->lightmapinfo->extents[0] >> 4) + 1;
2176                 tsize = (surface->lightmapinfo->extents[1] >> 4) + 1;
2177
2178                 // lighting info
2179                 for (i = 0;i < MAXLIGHTMAPS;i++)
2180                         surface->lightmapinfo->styles[i] = in->styles[i];
2181                 surface->lightmaptexture = NULL;
2182                 surface->deluxemaptexture = r_texture_blanknormalmap;
2183                 i = LittleLong(in->lightofs);
2184                 if (i == -1)
2185                 {
2186                         surface->lightmapinfo->samples = NULL;
2187                         // give non-lightmapped water a 1x white lightmap
2188                         if ((surface->texture->basematerialflags & MATERIALFLAG_WATER) && (surface->lightmapinfo->texinfo->flags & TEX_SPECIAL) && ssize <= 256 && tsize <= 256)
2189                         {
2190                                 surface->lightmapinfo->samples = (unsigned char *)Mem_Alloc(loadmodel->mempool, ssize * tsize * 3);
2191                                 surface->lightmapinfo->styles[0] = 0;
2192                                 memset(surface->lightmapinfo->samples, 128, ssize * tsize * 3);
2193                         }
2194                 }
2195                 else if (loadmodel->brush.ishlbsp) // LordHavoc: HalfLife map (bsp version 30)
2196                         surface->lightmapinfo->samples = loadmodel->brushq1.lightdata + i;
2197                 else // LordHavoc: white lighting (bsp version 29)
2198                 {
2199                         surface->lightmapinfo->samples = loadmodel->brushq1.lightdata + (i * 3);
2200                         if (loadmodel->brushq1.nmaplightdata)
2201                                 surface->lightmapinfo->nmapsamples = loadmodel->brushq1.nmaplightdata + (i * 3);
2202                 }
2203
2204                 // check if we should apply a lightmap to this
2205                 if (!(surface->lightmapinfo->texinfo->flags & TEX_SPECIAL) || surface->lightmapinfo->samples)
2206                 {
2207                         int i, iu, iv, lightmapx, lightmapy;
2208                         float u, v, ubase, vbase, uscale, vscale;
2209
2210                         if (ssize > 256 || tsize > 256)
2211                                 Host_Error("Bad surface extents");
2212                         // force lightmap upload on first time seeing the surface
2213                         surface->cached_dlight = true;
2214                         // stainmap for permanent marks on walls
2215                         surface->lightmapinfo->stainsamples = (unsigned char *)Mem_Alloc(loadmodel->mempool, ssize * tsize * 3);
2216                         // clear to white
2217                         memset(surface->lightmapinfo->stainsamples, 255, ssize * tsize * 3);
2218
2219                         // find a place for this lightmap
2220                         if (!lightmaptexture || !Mod_Q1BSP_AllocLightmapBlock(lightmap_lineused, LIGHTMAPSIZE, LIGHTMAPSIZE, ssize, tsize, &lightmapx, &lightmapy))
2221                         {
2222                                 // could not find room, make a new lightmap
2223                                 lightmaptexture = R_LoadTexture2D(loadmodel->texturepool, va("lightmap%i", lightmapnumber), LIGHTMAPSIZE, LIGHTMAPSIZE, NULL, loadmodel->brushq1.lightmaprgba ? TEXTYPE_RGBA : TEXTYPE_RGB, TEXF_FORCELINEAR | TEXF_PRECACHE, NULL);
2224                                 if (loadmodel->brushq1.nmaplightdata)
2225                                         deluxemaptexture = R_LoadTexture2D(loadmodel->texturepool, va("deluxemap%i", lightmapnumber), LIGHTMAPSIZE, LIGHTMAPSIZE, NULL, loadmodel->brushq1.lightmaprgba ? TEXTYPE_RGBA : TEXTYPE_RGB, TEXF_FORCELINEAR | TEXF_PRECACHE, NULL);
2226                                 lightmapnumber++;
2227                                 memset(lightmap_lineused, 0, sizeof(lightmap_lineused));
2228                                 Mod_Q1BSP_AllocLightmapBlock(lightmap_lineused, LIGHTMAPSIZE, LIGHTMAPSIZE, ssize, tsize, &lightmapx, &lightmapy);
2229                         }
2230
2231                         surface->lightmaptexture = lightmaptexture;
2232                         surface->deluxemaptexture = deluxemaptexture;
2233                         surface->lightmapinfo->lightmaporigin[0] = lightmapx;
2234                         surface->lightmapinfo->lightmaporigin[1] = lightmapy;
2235
2236                         ubase = lightmapx * lightmaptexcoordscale;
2237                         vbase = lightmapy * lightmaptexcoordscale;
2238                         uscale = lightmaptexcoordscale;
2239                         vscale = lightmaptexcoordscale;
2240
2241                         for (i = 0;i < surface->num_vertices;i++)
2242                         {
2243                                 u = ((DotProduct(((loadmodel->surfmesh.data_vertex3f + 3 * surface->num_firstvertex) + i * 3), surface->lightmapinfo->texinfo->vecs[0]) + surface->lightmapinfo->texinfo->vecs[0][3]) + 8 - surface->lightmapinfo->texturemins[0]) * (1.0 / 16.0);
2244                                 v = ((DotProduct(((loadmodel->surfmesh.data_vertex3f + 3 * surface->num_firstvertex) + i * 3), surface->lightmapinfo->texinfo->vecs[1]) + surface->lightmapinfo->texinfo->vecs[1][3]) + 8 - surface->lightmapinfo->texturemins[1]) * (1.0 / 16.0);
2245                                 (loadmodel->surfmesh.data_texcoordlightmap2f + 2 * surface->num_firstvertex)[i * 2 + 0] = u * uscale + ubase;
2246                                 (loadmodel->surfmesh.data_texcoordlightmap2f + 2 * surface->num_firstvertex)[i * 2 + 1] = v * vscale + vbase;
2247                                 // LordHavoc: calc lightmap data offset for vertex lighting to use
2248                                 iu = (int) u;
2249                                 iv = (int) v;
2250                                 (loadmodel->surfmesh.data_lightmapoffsets + surface->num_firstvertex)[i] = (bound(0, iv, tmax) * ssize + bound(0, iu, smax)) * 3;
2251                         }
2252                 }
2253         }
2254 }
2255
2256 static void Mod_Q1BSP_LoadNodes_RecursiveSetParent(mnode_t *node, mnode_t *parent)
2257 {
2258         //if (node->parent)
2259         //      Host_Error("Mod_Q1BSP_LoadNodes_RecursiveSetParent: runaway recursion");
2260         node->parent = parent;
2261         if (node->plane)
2262         {
2263                 // this is a node, recurse to children
2264                 Mod_Q1BSP_LoadNodes_RecursiveSetParent(node->children[0], node);
2265                 Mod_Q1BSP_LoadNodes_RecursiveSetParent(node->children[1], node);
2266                 // combine supercontents of children
2267                 node->combinedsupercontents = node->children[0]->combinedsupercontents | node->children[1]->combinedsupercontents;
2268         }
2269         else
2270         {
2271                 int j;
2272                 mleaf_t *leaf = (mleaf_t *)node;
2273                 // if this is a leaf, calculate supercontents mask from all collidable
2274                 // primitives in the leaf (brushes and collision surfaces)
2275                 // also flag if the leaf contains any collision surfaces
2276                 leaf->combinedsupercontents = 0;
2277                 // combine the supercontents values of all brushes in this leaf
2278                 for (j = 0;j < leaf->numleafbrushes;j++)
2279                         leaf->combinedsupercontents |= loadmodel->brush.data_brushes[leaf->firstleafbrush[j]].texture->supercontents;
2280                 // check if this leaf contains any collision surfaces (q3 patches)
2281                 for (j = 0;j < leaf->numleafsurfaces;j++)
2282                 {
2283                         msurface_t *surface = loadmodel->data_surfaces + leaf->firstleafsurface[j];
2284                         if (surface->num_collisiontriangles)
2285                         {
2286                                 leaf->containscollisionsurfaces = true;
2287                                 leaf->combinedsupercontents |= surface->texture->supercontents;
2288                         }
2289                 }
2290         }
2291 }
2292
2293 static void Mod_Q1BSP_LoadNodes(lump_t *l)
2294 {
2295         int                     i, j, count, p;
2296         dnode_t         *in;
2297         mnode_t         *out;
2298
2299         in = (dnode_t *)(mod_base + l->fileofs);
2300         if (l->filelen % sizeof(*in))
2301                 Host_Error("Mod_Q1BSP_LoadNodes: funny lump size in %s",loadmodel->name);
2302         count = l->filelen / sizeof(*in);
2303         out = (mnode_t *)Mem_Alloc(loadmodel->mempool, count*sizeof(*out));
2304
2305         loadmodel->brush.data_nodes = out;
2306         loadmodel->brush.num_nodes = count;
2307
2308         for ( i=0 ; i<count ; i++, in++, out++)
2309         {
2310                 for (j=0 ; j<3 ; j++)
2311                 {
2312                         out->mins[j] = LittleShort(in->mins[j]);
2313                         out->maxs[j] = LittleShort(in->maxs[j]);
2314                 }
2315
2316                 p = LittleLong(in->planenum);
2317                 out->plane = loadmodel->brush.data_planes + p;
2318
2319                 out->firstsurface = LittleShort(in->firstface);
2320                 out->numsurfaces = LittleShort(in->numfaces);
2321
2322                 for (j=0 ; j<2 ; j++)
2323                 {
2324                         p = LittleShort(in->children[j]);
2325                         if (p >= 0)
2326                                 out->children[j] = loadmodel->brush.data_nodes + p;
2327                         else
2328                                 out->children[j] = (mnode_t *)(loadmodel->brush.data_leafs + (-1 - p));
2329                 }
2330         }
2331
2332         Mod_Q1BSP_LoadNodes_RecursiveSetParent(loadmodel->brush.data_nodes, NULL);      // sets nodes and leafs
2333 }
2334
2335 static void Mod_Q1BSP_LoadLeafs(lump_t *l)
2336 {
2337         dleaf_t *in;
2338         mleaf_t *out;
2339         int i, j, count, p;
2340
2341         in = (dleaf_t *)(mod_base + l->fileofs);
2342         if (l->filelen % sizeof(*in))
2343                 Host_Error("Mod_Q1BSP_LoadLeafs: funny lump size in %s",loadmodel->name);
2344         count = l->filelen / sizeof(*in);
2345         out = (mleaf_t *)Mem_Alloc(loadmodel->mempool, count*sizeof(*out));
2346
2347         loadmodel->brush.data_leafs = out;
2348         loadmodel->brush.num_leafs = count;
2349         // get visleafs from the submodel data
2350         loadmodel->brush.num_pvsclusters = loadmodel->brushq1.submodels[0].visleafs;
2351         loadmodel->brush.num_pvsclusterbytes = (loadmodel->brush.num_pvsclusters+7)>>3;
2352         loadmodel->brush.data_pvsclusters = (unsigned char *)Mem_Alloc(loadmodel->mempool, loadmodel->brush.num_pvsclusters * loadmodel->brush.num_pvsclusterbytes);
2353         memset(loadmodel->brush.data_pvsclusters, 0xFF, loadmodel->brush.num_pvsclusters * loadmodel->brush.num_pvsclusterbytes);
2354
2355         for ( i=0 ; i<count ; i++, in++, out++)
2356         {
2357                 for (j=0 ; j<3 ; j++)
2358                 {
2359                         out->mins[j] = LittleShort(in->mins[j]);
2360                         out->maxs[j] = LittleShort(in->maxs[j]);
2361                 }
2362
2363                 // FIXME: this function could really benefit from some error checking
2364
2365                 out->contents = LittleLong(in->contents);
2366
2367                 out->firstleafsurface = loadmodel->brush.data_leafsurfaces + LittleShort(in->firstmarksurface);
2368                 out->numleafsurfaces = LittleShort(in->nummarksurfaces);
2369                 if (out->firstleafsurface < 0 || LittleShort(in->firstmarksurface) + out->numleafsurfaces > loadmodel->brush.num_leafsurfaces)
2370                 {
2371                         Con_Printf("Mod_Q1BSP_LoadLeafs: invalid leafsurface range %i:%i outside range %i:%i\n", (int)(out->firstleafsurface - loadmodel->brush.data_leafsurfaces), (int)(out->firstleafsurface + out->numleafsurfaces - loadmodel->brush.data_leafsurfaces), 0, loadmodel->brush.num_leafsurfaces);
2372                         out->firstleafsurface = NULL;
2373                         out->numleafsurfaces = 0;
2374                 }
2375
2376                 out->clusterindex = i - 1;
2377                 if (out->clusterindex >= loadmodel->brush.num_pvsclusters)
2378                         out->clusterindex = -1;
2379
2380                 p = LittleLong(in->visofs);
2381                 // ignore visofs errors on leaf 0 (solid)
2382                 if (p >= 0 && out->clusterindex >= 0)
2383                 {
2384                         if (p >= loadmodel->brushq1.num_compressedpvs)
2385                                 Con_Print("Mod_Q1BSP_LoadLeafs: invalid visofs\n");
2386                         else
2387                                 Mod_Q1BSP_DecompressVis(loadmodel->brushq1.data_compressedpvs + p, loadmodel->brushq1.data_compressedpvs + loadmodel->brushq1.num_compressedpvs, loadmodel->brush.data_pvsclusters + out->clusterindex * loadmodel->brush.num_pvsclusterbytes, loadmodel->brush.data_pvsclusters + (out->clusterindex + 1) * loadmodel->brush.num_pvsclusterbytes);
2388                 }
2389
2390                 for (j = 0;j < 4;j++)
2391                         out->ambient_sound_level[j] = in->ambient_level[j];
2392
2393                 // FIXME: Insert caustics here
2394         }
2395 }
2396
2397 qboolean Mod_Q1BSP_CheckWaterAlphaSupport(void)
2398 {
2399         int i, j;
2400         mleaf_t *leaf;
2401         const unsigned char *pvs;
2402         // check all liquid leafs to see if they can see into empty leafs, if any
2403         // can we can assume this map supports r_wateralpha
2404         for (i = 0, leaf = loadmodel->brush.data_leafs;i < loadmodel->brush.num_leafs;i++, leaf++)
2405         {
2406                 if ((leaf->contents == CONTENTS_WATER || leaf->contents == CONTENTS_SLIME) && (leaf->clusterindex >= 0 && loadmodel->brush.data_pvsclusters))
2407                 {
2408                         pvs = loadmodel->brush.data_pvsclusters + leaf->clusterindex * loadmodel->brush.num_pvsclusterbytes;
2409                         for (j = 0;j < loadmodel->brush.num_leafs;j++)
2410                                 if (CHECKPVSBIT(pvs, loadmodel->brush.data_leafs[j].clusterindex) && loadmodel->brush.data_leafs[j].contents == CONTENTS_EMPTY)
2411                                         return true;
2412                 }
2413         }
2414         return false;
2415 }
2416
2417 static void Mod_Q1BSP_LoadClipnodes(lump_t *l, hullinfo_t *hullinfo)
2418 {
2419         dclipnode_t *in, *out;
2420         int                     i, count;
2421         hull_t          *hull;
2422
2423         in = (dclipnode_t *)(mod_base + l->fileofs);
2424         if (l->filelen % sizeof(*in))
2425                 Host_Error("Mod_Q1BSP_LoadClipnodes: funny lump size in %s",loadmodel->name);
2426         count = l->filelen / sizeof(*in);
2427         out = (dclipnode_t *)Mem_Alloc(loadmodel->mempool, count*sizeof(*out));
2428
2429         loadmodel->brushq1.clipnodes = out;
2430         loadmodel->brushq1.numclipnodes = count;
2431
2432         for (i = 1; i < hullinfo->numhulls; i++)
2433         {
2434                 hull = &loadmodel->brushq1.hulls[i];
2435                 hull->clipnodes = out;
2436                 hull->firstclipnode = 0;
2437                 hull->lastclipnode = count-1;
2438                 hull->planes = loadmodel->brush.data_planes;
2439                 hull->clip_mins[0] = hullinfo->hullsizes[i][0][0];
2440                 hull->clip_mins[1] = hullinfo->hullsizes[i][0][1];
2441                 hull->clip_mins[2] = hullinfo->hullsizes[i][0][2];
2442                 hull->clip_maxs[0] = hullinfo->hullsizes[i][1][0];
2443                 hull->clip_maxs[1] = hullinfo->hullsizes[i][1][1];
2444                 hull->clip_maxs[2] = hullinfo->hullsizes[i][1][2];
2445                 VectorSubtract(hull->clip_maxs, hull->clip_mins, hull->clip_size);
2446         }
2447
2448         for (i=0 ; i<count ; i++, out++, in++)
2449         {
2450                 out->planenum = LittleLong(in->planenum);
2451                 out->children[0] = LittleShort(in->children[0]);
2452                 out->children[1] = LittleShort(in->children[1]);
2453                 if (out->planenum < 0 || out->planenum >= loadmodel->brush.num_planes)
2454                         Host_Error("Corrupt clipping hull(out of range planenum)");
2455                 if (out->children[0] >= count || out->children[1] >= count)
2456                         Host_Error("Corrupt clipping hull(out of range child)");
2457         }
2458 }
2459
2460 //Duplicate the drawing hull structure as a clipping hull
2461 static void Mod_Q1BSP_MakeHull0(void)
2462 {
2463         mnode_t         *in;
2464         dclipnode_t *out;
2465         int                     i;
2466         hull_t          *hull;
2467
2468         hull = &loadmodel->brushq1.hulls[0];
2469
2470         in = loadmodel->brush.data_nodes;
2471         out = (dclipnode_t *)Mem_Alloc(loadmodel->mempool, loadmodel->brush.num_nodes * sizeof(dclipnode_t));
2472
2473         hull->clipnodes = out;
2474         hull->firstclipnode = 0;
2475         hull->lastclipnode = loadmodel->brush.num_nodes - 1;
2476         hull->planes = loadmodel->brush.data_planes;
2477
2478         for (i = 0;i < loadmodel->brush.num_nodes;i++, out++, in++)
2479         {
2480                 out->planenum = in->plane - loadmodel->brush.data_planes;
2481                 out->children[0] = in->children[0]->plane ? in->children[0] - loadmodel->brush.data_nodes : ((mleaf_t *)in->children[0])->contents;
2482                 out->children[1] = in->children[1]->plane ? in->children[1] - loadmodel->brush.data_nodes : ((mleaf_t *)in->children[1])->contents;
2483         }
2484 }
2485
2486 static void Mod_Q1BSP_LoadLeaffaces(lump_t *l)
2487 {
2488         int i, j;
2489         short *in;
2490
2491         in = (short *)(mod_base + l->fileofs);
2492         if (l->filelen % sizeof(*in))
2493                 Host_Error("Mod_Q1BSP_LoadLeaffaces: funny lump size in %s",loadmodel->name);
2494         loadmodel->brush.num_leafsurfaces = l->filelen / sizeof(*in);
2495         loadmodel->brush.data_leafsurfaces = (int *)Mem_Alloc(loadmodel->mempool, loadmodel->brush.num_leafsurfaces * sizeof(int));
2496
2497         for (i = 0;i < loadmodel->brush.num_leafsurfaces;i++)
2498         {
2499                 j = (unsigned) LittleShort(in[i]);
2500                 if (j >= loadmodel->num_surfaces)
2501                         Host_Error("Mod_Q1BSP_LoadLeaffaces: bad surface number");
2502                 loadmodel->brush.data_leafsurfaces[i] = j;
2503         }
2504 }
2505
2506 static void Mod_Q1BSP_LoadSurfedges(lump_t *l)
2507 {
2508         int             i;
2509         int             *in;
2510
2511         in = (int *)(mod_base + l->fileofs);
2512         if (l->filelen % sizeof(*in))
2513                 Host_Error("Mod_Q1BSP_LoadSurfedges: funny lump size in %s",loadmodel->name);
2514         loadmodel->brushq1.numsurfedges = l->filelen / sizeof(*in);
2515         loadmodel->brushq1.surfedges = (int *)Mem_Alloc(loadmodel->mempool, loadmodel->brushq1.numsurfedges * sizeof(int));
2516
2517         for (i = 0;i < loadmodel->brushq1.numsurfedges;i++)
2518                 loadmodel->brushq1.surfedges[i] = LittleLong(in[i]);
2519 }
2520
2521
2522 static void Mod_Q1BSP_LoadPlanes(lump_t *l)
2523 {
2524         int                     i;
2525         mplane_t        *out;
2526         dplane_t        *in;
2527
2528         in = (dplane_t *)(mod_base + l->fileofs);
2529         if (l->filelen % sizeof(*in))
2530                 Host_Error("Mod_Q1BSP_LoadPlanes: funny lump size in %s", loadmodel->name);
2531
2532         loadmodel->brush.num_planes = l->filelen / sizeof(*in);
2533         loadmodel->brush.data_planes = out = (mplane_t *)Mem_Alloc(loadmodel->mempool, loadmodel->brush.num_planes * sizeof(*out));
2534
2535         for (i = 0;i < loadmodel->brush.num_planes;i++, in++, out++)
2536         {
2537                 out->normal[0] = LittleFloat(in->normal[0]);
2538                 out->normal[1] = LittleFloat(in->normal[1]);
2539                 out->normal[2] = LittleFloat(in->normal[2]);
2540                 out->dist = LittleFloat(in->dist);
2541
2542                 PlaneClassify(out);
2543         }
2544 }
2545
2546 static void Mod_Q1BSP_LoadMapBrushes(void)
2547 {
2548 #if 0
2549 // unfinished
2550         int submodel, numbrushes;
2551         qboolean firstbrush;
2552         char *text, *maptext;
2553         char mapfilename[MAX_QPATH];
2554         FS_StripExtension (loadmodel->name, mapfilename, sizeof (mapfilename));
2555         strlcat (mapfilename, ".map", sizeof (mapfilename));
2556         maptext = (unsigned char*) FS_LoadFile(mapfilename, tempmempool, false, NULL);
2557         if (!maptext)
2558                 return;
2559         text = maptext;
2560         if (!COM_ParseTokenConsole(&data))
2561                 return; // error
2562         submodel = 0;
2563         for (;;)
2564         {
2565                 if (!COM_ParseTokenConsole(&data))
2566                         break;
2567                 if (com_token[0] != '{')
2568                         return; // error
2569                 // entity
2570                 firstbrush = true;
2571                 numbrushes = 0;
2572                 maxbrushes = 256;
2573                 brushes = Mem_Alloc(loadmodel->mempool, maxbrushes * sizeof(mbrush_t));
2574                 for (;;)
2575                 {
2576                         if (!COM_ParseTokenConsole(&data))
2577                                 return; // error
2578                         if (com_token[0] == '}')
2579                                 break; // end of entity
2580                         if (com_token[0] == '{')
2581                         {
2582                                 // brush
2583                                 if (firstbrush)
2584                                 {
2585                                         if (submodel)
2586                                         {
2587                                                 if (submodel > loadmodel->brush.numsubmodels)
2588                                                 {
2589                                                         Con_Printf("Mod_Q1BSP_LoadMapBrushes: .map has more submodels than .bsp!\n");
2590                                                         model = NULL;
2591                                                 }
2592                                                 else
2593                                                         model = loadmodel->brush.submodels[submodel];
2594                                         }
2595                                         else
2596                                                 model = loadmodel;
2597                                 }
2598                                 for (;;)
2599                                 {
2600                                         if (!COM_ParseTokenConsole(&data))
2601                                                 return; // error
2602                                         if (com_token[0] == '}')
2603                                                 break; // end of brush
2604                                         // each brush face should be this format:
2605                                         // ( x y z ) ( x y z ) ( x y z ) texture scroll_s scroll_t rotateangle scale_s scale_t
2606                                         // FIXME: support hl .map format
2607                                         for (pointnum = 0;pointnum < 3;pointnum++)
2608                                         {
2609                                                 COM_ParseTokenConsole(&data);
2610                                                 for (componentnum = 0;componentnum < 3;componentnum++)
2611                                                 {
2612                                                         COM_ParseTokenConsole(&data);
2613                                                         point[pointnum][componentnum] = atof(com_token);
2614                                                 }
2615                                                 COM_ParseTokenConsole(&data);
2616                                         }
2617                                         COM_ParseTokenConsole(&data);
2618                                         strlcpy(facetexture, com_token, sizeof(facetexture));
2619                                         COM_ParseTokenConsole(&data);
2620                                         //scroll_s = atof(com_token);
2621                                         COM_ParseTokenConsole(&data);
2622                                         //scroll_t = atof(com_token);
2623                                         COM_ParseTokenConsole(&data);
2624                                         //rotate = atof(com_token);
2625                                         COM_ParseTokenConsole(&data);
2626                                         //scale_s = atof(com_token);
2627                                         COM_ParseTokenConsole(&data);
2628                                         //scale_t = atof(com_token);
2629                                         TriangleNormal(point[0], point[1], point[2], planenormal);
2630                                         VectorNormalizeDouble(planenormal);
2631                                         planedist = DotProduct(point[0], planenormal);
2632                                         //ChooseTexturePlane(planenormal, texturevector[0], texturevector[1]);
2633                                 }
2634                                 continue;
2635                         }
2636                 }
2637         }
2638 #endif
2639 }
2640
2641
2642 #define MAX_PORTALPOINTS 64
2643
2644 typedef struct portal_s
2645 {
2646         mplane_t plane;
2647         mnode_t *nodes[2];              // [0] = front side of plane
2648         struct portal_s *next[2];
2649         int numpoints;
2650         double points[3*MAX_PORTALPOINTS];
2651         struct portal_s *chain; // all portals are linked into a list
2652 }
2653 portal_t;
2654
2655 static portal_t *portalchain;
2656
2657 /*
2658 ===========
2659 AllocPortal
2660 ===========
2661 */
2662 static portal_t *AllocPortal(void)
2663 {
2664         portal_t *p;
2665         p = (portal_t *)Mem_Alloc(loadmodel->mempool, sizeof(portal_t));
2666         p->chain = portalchain;
2667         portalchain = p;
2668         return p;
2669 }
2670
2671 static void FreePortal(portal_t *p)
2672 {
2673         Mem_Free(p);
2674 }
2675
2676 static void Mod_Q1BSP_RecursiveRecalcNodeBBox(mnode_t *node)
2677 {
2678         // process only nodes (leafs already had their box calculated)
2679         if (!node->plane)
2680                 return;
2681
2682         // calculate children first
2683         Mod_Q1BSP_RecursiveRecalcNodeBBox(node->children[0]);
2684         Mod_Q1BSP_RecursiveRecalcNodeBBox(node->children[1]);
2685
2686         // make combined bounding box from children
2687         node->mins[0] = min(node->children[0]->mins[0], node->children[1]->mins[0]);
2688         node->mins[1] = min(node->children[0]->mins[1], node->children[1]->mins[1]);
2689         node->mins[2] = min(node->children[0]->mins[2], node->children[1]->mins[2]);
2690         node->maxs[0] = max(node->children[0]->maxs[0], node->children[1]->maxs[0]);
2691         node->maxs[1] = max(node->children[0]->maxs[1], node->children[1]->maxs[1]);
2692         node->maxs[2] = max(node->children[0]->maxs[2], node->children[1]->maxs[2]);
2693 }
2694
2695 static void Mod_Q1BSP_FinalizePortals(void)
2696 {
2697         int i, j, numportals, numpoints;
2698         portal_t *p, *pnext;
2699         mportal_t *portal;
2700         mvertex_t *point;
2701         mleaf_t *leaf, *endleaf;
2702
2703         // tally up portal and point counts and recalculate bounding boxes for all
2704         // leafs (because qbsp is very sloppy)
2705         leaf = loadmodel->brush.data_leafs;
2706         endleaf = leaf + loadmodel->brush.num_leafs;
2707         for (;leaf < endleaf;leaf++)
2708         {
2709                 VectorSet(leaf->mins,  2000000000,  2000000000,  2000000000);
2710                 VectorSet(leaf->maxs, -2000000000, -2000000000, -2000000000);
2711         }
2712         p = portalchain;
2713         numportals = 0;
2714         numpoints = 0;
2715         while (p)
2716         {
2717                 // note: this check must match the one below or it will usually corrupt memory
2718                 // the nodes[0] != nodes[1] check is because leaf 0 is the shared solid leaf, it can have many portals inside with leaf 0 on both sides
2719                 if (p->numpoints >= 3 && p->nodes[0] != p->nodes[1] && ((mleaf_t *)p->nodes[0])->clusterindex >= 0 && ((mleaf_t *)p->nodes[1])->clusterindex >= 0)
2720                 {
2721                         numportals += 2;
2722                         numpoints += p->numpoints * 2;
2723                 }
2724                 p = p->chain;
2725         }
2726         loadmodel->brush.data_portals = (mportal_t *)Mem_Alloc(loadmodel->mempool, numportals * sizeof(mportal_t) + numpoints * sizeof(mvertex_t));
2727         loadmodel->brush.num_portals = numportals;
2728         loadmodel->brush.data_portalpoints = (mvertex_t *)((unsigned char *) loadmodel->brush.data_portals + numportals * sizeof(mportal_t));
2729         loadmodel->brush.num_portalpoints = numpoints;
2730         // clear all leaf portal chains
2731         for (i = 0;i < loadmodel->brush.num_leafs;i++)
2732                 loadmodel->brush.data_leafs[i].portals = NULL;
2733         // process all portals in the global portal chain, while freeing them
2734         portal = loadmodel->brush.data_portals;
2735         point = loadmodel->brush.data_portalpoints;
2736         p = portalchain;
2737         portalchain = NULL;
2738         while (p)
2739         {
2740                 pnext = p->chain;
2741
2742                 if (p->numpoints >= 3 && p->nodes[0] != p->nodes[1])
2743                 {
2744                         // note: this check must match the one above or it will usually corrupt memory
2745                         // the nodes[0] != nodes[1] check is because leaf 0 is the shared solid leaf, it can have many portals inside with leaf 0 on both sides
2746                         if (((mleaf_t *)p->nodes[0])->clusterindex >= 0 && ((mleaf_t *)p->nodes[1])->clusterindex >= 0)
2747                         {
2748                                 // first make the back to front portal(forward portal)
2749                                 portal->points = point;
2750                                 portal->numpoints = p->numpoints;
2751                                 portal->plane.dist = p->plane.dist;
2752                                 VectorCopy(p->plane.normal, portal->plane.normal);
2753                                 portal->here = (mleaf_t *)p->nodes[1];
2754                                 portal->past = (mleaf_t *)p->nodes[0];
2755                                 // copy points
2756                                 for (j = 0;j < portal->numpoints;j++)
2757                                 {
2758                                         VectorCopy(p->points + j*3, point->position);
2759                                         point++;
2760                                 }
2761                                 BoxFromPoints(portal->mins, portal->maxs, portal->numpoints, portal->points->position);
2762                                 PlaneClassify(&portal->plane);
2763
2764                                 // link into leaf's portal chain
2765                                 portal->next = portal->here->portals;
2766                                 portal->here->portals = portal;
2767
2768                                 // advance to next portal
2769                                 portal++;
2770
2771                                 // then make the front to back portal(backward portal)
2772                                 portal->points = point;
2773                                 portal->numpoints = p->numpoints;
2774                                 portal->plane.dist = -p->plane.dist;
2775                                 VectorNegate(p->plane.normal, portal->plane.normal);
2776                                 portal->here = (mleaf_t *)p->nodes[0];
2777                                 portal->past = (mleaf_t *)p->nodes[1];
2778                                 // copy points
2779                                 for (j = portal->numpoints - 1;j >= 0;j--)
2780                                 {
2781                                         VectorCopy(p->points + j*3, point->position);
2782                                         point++;
2783                                 }
2784                                 BoxFromPoints(portal->mins, portal->maxs, portal->numpoints, portal->points->position);
2785                                 PlaneClassify(&portal->plane);
2786
2787                                 // link into leaf's portal chain
2788                                 portal->next = portal->here->portals;
2789                                 portal->here->portals = portal;
2790
2791                                 // advance to next portal
2792                                 portal++;
2793                         }
2794                         // add the portal's polygon points to the leaf bounding boxes
2795                         for (i = 0;i < 2;i++)
2796                         {
2797                                 leaf = (mleaf_t *)p->nodes[i];
2798                                 for (j = 0;j < p->numpoints;j++)
2799                                 {
2800                                         if (leaf->mins[0] > p->points[j*3+0]) leaf->mins[0] = p->points[j*3+0];
2801                                         if (leaf->mins[1] > p->points[j*3+1]) leaf->mins[1] = p->points[j*3+1];
2802                                         if (leaf->mins[2] > p->points[j*3+2]) leaf->mins[2] = p->points[j*3+2];
2803                                         if (leaf->maxs[0] < p->points[j*3+0]) leaf->maxs[0] = p->points[j*3+0];
2804                                         if (leaf->maxs[1] < p->points[j*3+1]) leaf->maxs[1] = p->points[j*3+1];
2805                                         if (leaf->maxs[2] < p->points[j*3+2]) leaf->maxs[2] = p->points[j*3+2];
2806                                 }
2807                         }
2808                 }
2809                 FreePortal(p);
2810                 p = pnext;
2811         }
2812         // now recalculate the node bounding boxes from the leafs
2813         Mod_Q1BSP_RecursiveRecalcNodeBBox(loadmodel->brush.data_nodes);
2814 }
2815
2816 /*
2817 =============
2818 AddPortalToNodes
2819 =============
2820 */
2821 static void AddPortalToNodes(portal_t *p, mnode_t *front, mnode_t *back)
2822 {
2823         if (!front)
2824                 Host_Error("AddPortalToNodes: NULL front node");
2825         if (!back)
2826                 Host_Error("AddPortalToNodes: NULL back node");
2827         if (p->nodes[0] || p->nodes[1])
2828                 Host_Error("AddPortalToNodes: already included");
2829         // note: front == back is handled gracefully, because leaf 0 is the shared solid leaf, it can often have portals with the same leaf on both sides
2830
2831         p->nodes[0] = front;
2832         p->next[0] = (portal_t *)front->portals;
2833         front->portals = (mportal_t *)p;
2834
2835         p->nodes[1] = back;
2836         p->next[1] = (portal_t *)back->portals;
2837         back->portals = (mportal_t *)p;
2838 }
2839
2840 /*
2841 =============
2842 RemovePortalFromNode
2843 =============
2844 */
2845 static void RemovePortalFromNodes(portal_t *portal)
2846 {
2847         int i;
2848         mnode_t *node;
2849         void **portalpointer;
2850         portal_t *t;
2851         for (i = 0;i < 2;i++)
2852         {
2853                 node = portal->nodes[i];
2854
2855                 portalpointer = (void **) &node->portals;
2856                 while (1)
2857                 {
2858                         t = (portal_t *)*portalpointer;
2859                         if (!t)
2860                                 Host_Error("RemovePortalFromNodes: portal not in leaf");
2861
2862                         if (t == portal)
2863                         {
2864                                 if (portal->nodes[0] == node)
2865                                 {
2866                                         *portalpointer = portal->next[0];
2867                                         portal->nodes[0] = NULL;
2868                                 }
2869                                 else if (portal->nodes[1] == node)
2870                                 {
2871                                         *portalpointer = portal->next[1];
2872                                         portal->nodes[1] = NULL;
2873                                 }
2874                                 else
2875                                         Host_Error("RemovePortalFromNodes: portal not bounding leaf");
2876                                 break;
2877                         }
2878
2879                         if (t->nodes[0] == node)
2880                                 portalpointer = (void **) &t->next[0];
2881                         else if (t->nodes[1] == node)
2882                                 portalpointer = (void **) &t->next[1];
2883                         else
2884                                 Host_Error("RemovePortalFromNodes: portal not bounding leaf");
2885                 }
2886         }
2887 }
2888
2889 #define PORTAL_DIST_EPSILON (1.0 / 32.0)
2890 static void Mod_Q1BSP_RecursiveNodePortals(mnode_t *node)
2891 {
2892         int i, side;
2893         mnode_t *front, *back, *other_node;
2894         mplane_t clipplane, *plane;
2895         portal_t *portal, *nextportal, *nodeportal, *splitportal, *temp;
2896         int numfrontpoints, numbackpoints;
2897         double frontpoints[3*MAX_PORTALPOINTS], backpoints[3*MAX_PORTALPOINTS];
2898
2899         // if a leaf, we're done
2900         if (!node->plane)
2901                 return;
2902
2903         plane = node->plane;
2904
2905         front = node->children[0];
2906         back = node->children[1];
2907         if (front == back)
2908                 Host_Error("Mod_Q1BSP_RecursiveNodePortals: corrupt node hierarchy");
2909
2910         // create the new portal by generating a polygon for the node plane,
2911         // and clipping it by all of the other portals(which came from nodes above this one)
2912         nodeportal = AllocPortal();
2913         nodeportal->plane = *plane;
2914
2915         // TODO: calculate node bounding boxes during recursion and calculate a maximum plane size accordingly to improve precision (as most maps do not need 1 billion unit plane polygons)
2916         PolygonD_QuadForPlane(nodeportal->points, nodeportal->plane.normal[0], nodeportal->plane.normal[1], nodeportal->plane.normal[2], nodeportal->plane.dist, 1024.0*1024.0*1024.0);
2917         nodeportal->numpoints = 4;
2918         side = 0;       // shut up compiler warning
2919         for (portal = (portal_t *)node->portals;portal;portal = portal->next[side])
2920         {
2921                 clipplane = portal->plane;
2922                 if (portal->nodes[0] == portal->nodes[1])
2923                         Host_Error("Mod_Q1BSP_RecursiveNodePortals: portal has same node on both sides(1)");
2924                 if (portal->nodes[0] == node)
2925                         side = 0;
2926                 else if (portal->nodes[1] == node)
2927                 {
2928                         clipplane.dist = -clipplane.dist;
2929                         VectorNegate(clipplane.normal, clipplane.normal);
2930                         side = 1;
2931                 }
2932                 else
2933                         Host_Error("Mod_Q1BSP_RecursiveNodePortals: mislinked portal");
2934
2935                 for (i = 0;i < nodeportal->numpoints*3;i++)
2936                         frontpoints[i] = nodeportal->points[i];
2937                 PolygonD_Divide(nodeportal->numpoints, frontpoints, clipplane.normal[0], clipplane.normal[1], clipplane.normal[2], clipplane.dist, PORTAL_DIST_EPSILON, MAX_PORTALPOINTS, nodeportal->points, &nodeportal->numpoints, 0, NULL, NULL, NULL);
2938                 if (nodeportal->numpoints <= 0 || nodeportal->numpoints >= MAX_PORTALPOINTS)
2939                         break;
2940         }
2941
2942         if (nodeportal->numpoints < 3)
2943         {
2944                 Con_Print("Mod_Q1BSP_RecursiveNodePortals: WARNING: new portal was clipped away\n");
2945                 nodeportal->numpoints = 0;
2946         }
2947         else if (nodeportal->numpoints >= MAX_PORTALPOINTS)
2948         {
2949                 Con_Print("Mod_Q1BSP_RecursiveNodePortals: WARNING: new portal has too many points\n");
2950                 nodeportal->numpoints = 0;
2951         }
2952
2953         AddPortalToNodes(nodeportal, front, back);
2954
2955         // split the portals of this node along this node's plane and assign them to the children of this node
2956         // (migrating the portals downward through the tree)
2957         for (portal = (portal_t *)node->portals;portal;portal = nextportal)
2958         {
2959                 if (portal->nodes[0] == portal->nodes[1])
2960                         Host_Error("Mod_Q1BSP_RecursiveNodePortals: portal has same node on both sides(2)");
2961                 if (portal->nodes[0] == node)
2962                         side = 0;
2963                 else if (portal->nodes[1] == node)
2964                         side = 1;
2965                 else
2966                         Host_Error("Mod_Q1BSP_RecursiveNodePortals: mislinked portal");
2967                 nextportal = portal->next[side];
2968                 if (!portal->numpoints)
2969                         continue;
2970
2971                 other_node = portal->nodes[!side];
2972                 RemovePortalFromNodes(portal);
2973
2974                 // cut the portal into two portals, one on each side of the node plane
2975                 PolygonD_Divide(portal->numpoints, portal->points, plane->normal[0], plane->normal[1], plane->normal[2], plane->dist, PORTAL_DIST_EPSILON, MAX_PORTALPOINTS, frontpoints, &numfrontpoints, MAX_PORTALPOINTS, backpoints, &numbackpoints, NULL);
2976
2977                 if (!numfrontpoints)
2978                 {
2979                         if (side == 0)
2980                                 AddPortalToNodes(portal, back, other_node);
2981                         else
2982                                 AddPortalToNodes(portal, other_node, back);
2983                         continue;
2984                 }
2985                 if (!numbackpoints)
2986                 {
2987                         if (side == 0)
2988                                 AddPortalToNodes(portal, front, other_node);
2989                         else
2990                                 AddPortalToNodes(portal, other_node, front);
2991                         continue;
2992                 }
2993
2994                 // the portal is split
2995                 splitportal = AllocPortal();
2996                 temp = splitportal->chain;
2997                 *splitportal = *portal;
2998                 splitportal->chain = temp;
2999                 for (i = 0;i < numbackpoints*3;i++)
3000                         splitportal->points[i] = backpoints[i];
3001                 splitportal->numpoints = numbackpoints;
3002                 for (i = 0;i < numfrontpoints*3;i++)
3003                         portal->points[i] = frontpoints[i];
3004                 portal->numpoints = numfrontpoints;
3005
3006                 if (side == 0)
3007                 {
3008                         AddPortalToNodes(portal, front, other_node);
3009                         AddPortalToNodes(splitportal, back, other_node);
3010                 }
3011                 else
3012                 {
3013                         AddPortalToNodes(portal, other_node, front);
3014                         AddPortalToNodes(splitportal, other_node, back);
3015                 }
3016         }
3017
3018         Mod_Q1BSP_RecursiveNodePortals(front);
3019         Mod_Q1BSP_RecursiveNodePortals(back);
3020 }
3021
3022 static void Mod_Q1BSP_MakePortals(void)
3023 {
3024         portalchain = NULL;
3025         Mod_Q1BSP_RecursiveNodePortals(loadmodel->brush.data_nodes);
3026         Mod_Q1BSP_FinalizePortals();
3027 }
3028
3029 static void Mod_Q1BSP_BuildLightmapUpdateChains(mempool_t *mempool, model_t *model)
3030 {
3031         int i, j, stylecounts[256], totalcount, remapstyles[256];
3032         msurface_t *surface;
3033         memset(stylecounts, 0, sizeof(stylecounts));
3034         for (i = 0;i < model->nummodelsurfaces;i++)
3035         {
3036                 surface = model->data_surfaces + model->firstmodelsurface + i;
3037                 for (j = 0;j < MAXLIGHTMAPS;j++)
3038                         stylecounts[surface->lightmapinfo->styles[j]]++;
3039         }
3040         totalcount = 0;
3041         model->brushq1.light_styles = 0;
3042         for (i = 0;i < 255;i++)
3043         {
3044                 if (stylecounts[i])
3045                 {
3046                         remapstyles[i] = model->brushq1.light_styles++;
3047                         totalcount += stylecounts[i] + 1;
3048                 }
3049         }
3050         if (!totalcount)
3051                 return;
3052         model->brushq1.light_style = (unsigned char *)Mem_Alloc(mempool, model->brushq1.light_styles * sizeof(unsigned char));
3053         model->brushq1.light_stylevalue = (int *)Mem_Alloc(mempool, model->brushq1.light_styles * sizeof(int));
3054         model->brushq1.light_styleupdatechains = (msurface_t ***)Mem_Alloc(mempool, model->brushq1.light_styles * sizeof(msurface_t **));
3055         model->brushq1.light_styleupdatechainsbuffer = (msurface_t **)Mem_Alloc(mempool, totalcount * sizeof(msurface_t *));
3056         model->brushq1.light_styles = 0;
3057         for (i = 0;i < 255;i++)
3058                 if (stylecounts[i])
3059                         model->brushq1.light_style[model->brushq1.light_styles++] = i;
3060         j = 0;
3061         for (i = 0;i < model->brushq1.light_styles;i++)
3062         {
3063                 model->brushq1.light_styleupdatechains[i] = model->brushq1.light_styleupdatechainsbuffer + j;
3064                 j += stylecounts[model->brushq1.light_style[i]] + 1;
3065         }
3066         for (i = 0;i < model->nummodelsurfaces;i++)
3067         {
3068                 surface = model->data_surfaces + model->firstmodelsurface + i;
3069                 for (j = 0;j < MAXLIGHTMAPS;j++)
3070                         if (surface->lightmapinfo->styles[j] != 255)
3071                                 *model->brushq1.light_styleupdatechains[remapstyles[surface->lightmapinfo->styles[j]]]++ = surface;
3072         }
3073         j = 0;
3074         for (i = 0;i < model->brushq1.light_styles;i++)
3075         {
3076                 *model->brushq1.light_styleupdatechains[i] = NULL;
3077                 model->brushq1.light_styleupdatechains[i] = model->brushq1.light_styleupdatechainsbuffer + j;
3078                 j += stylecounts[model->brushq1.light_style[i]] + 1;
3079         }
3080 }
3081
3082 //Returns PVS data for a given point
3083 //(note: can return NULL)
3084 static unsigned char *Mod_Q1BSP_GetPVS(model_t *model, const vec3_t p)
3085 {
3086         mnode_t *node;
3087         node = model->brush.data_nodes;
3088         while (node->plane)
3089                 node = node->children[(node->plane->type < 3 ? p[node->plane->type] : DotProduct(p,node->plane->normal)) < node->plane->dist];
3090         if (((mleaf_t *)node)->clusterindex >= 0)
3091                 return model->brush.data_pvsclusters + ((mleaf_t *)node)->clusterindex * model->brush.num_pvsclusterbytes;
3092         else
3093                 return NULL;
3094 }
3095
3096 static void Mod_Q1BSP_FatPVS_RecursiveBSPNode(model_t *model, const vec3_t org, vec_t radius, unsigned char *pvsbuffer, int pvsbytes, mnode_t *node)
3097 {
3098         while (node->plane)
3099         {
3100                 float d = PlaneDiff(org, node->plane);
3101                 if (d > radius)
3102                         node = node->children[0];
3103                 else if (d < -radius)
3104                         node = node->children[1];
3105                 else
3106                 {
3107                         // go down both sides
3108                         Mod_Q1BSP_FatPVS_RecursiveBSPNode(model, org, radius, pvsbuffer, pvsbytes, node->children[0]);
3109                         node = node->children[1];
3110                 }
3111         }
3112         // if this leaf is in a cluster, accumulate the pvs bits
3113         if (((mleaf_t *)node)->clusterindex >= 0)
3114         {
3115                 int i;
3116                 unsigned char *pvs = model->brush.data_pvsclusters + ((mleaf_t *)node)->clusterindex * model->brush.num_pvsclusterbytes;
3117                 for (i = 0;i < pvsbytes;i++)
3118                         pvsbuffer[i] |= pvs[i];
3119         }
3120 }
3121
3122 //Calculates a PVS that is the inclusive or of all leafs within radius pixels
3123 //of the given point.
3124 static int Mod_Q1BSP_FatPVS(model_t *model, const vec3_t org, vec_t radius, unsigned char *pvsbuffer, int pvsbufferlength)
3125 {
3126         int bytes = model->brush.num_pvsclusterbytes;
3127         bytes = min(bytes, pvsbufferlength);
3128         if (r_novis.integer || !model->brush.num_pvsclusters || !Mod_Q1BSP_GetPVS(model, org))
3129         {
3130                 memset(pvsbuffer, 0xFF, bytes);
3131                 return bytes;
3132         }
3133         memset(pvsbuffer, 0, bytes);
3134         Mod_Q1BSP_FatPVS_RecursiveBSPNode(model, org, radius, pvsbuffer, bytes, model->brush.data_nodes);
3135         return bytes;
3136 }
3137
3138 static void Mod_Q1BSP_RoundUpToHullSize(model_t *cmodel, const vec3_t inmins, const vec3_t inmaxs, vec3_t outmins, vec3_t outmaxs)
3139 {
3140         vec3_t size;
3141         const hull_t *hull;
3142
3143         VectorSubtract(inmaxs, inmins, size);
3144         if (cmodel->brush.ismcbsp)
3145         {
3146                 if (size[0] < 3)
3147                         hull = &cmodel->brushq1.hulls[0]; // 0x0x0
3148                 else if (size[2] < 48) // pick the nearest of 40 or 56
3149                         hull = &cmodel->brushq1.hulls[2]; // 16x16x40
3150                 else
3151                         hull = &cmodel->brushq1.hulls[1]; // 16x16x56
3152         }
3153         else if (cmodel->brush.ishlbsp)
3154         {
3155                 if (size[0] < 3)
3156                         hull = &cmodel->brushq1.hulls[0]; // 0x0x0
3157                 else if (size[0] <= 32)
3158                 {
3159                         if (size[2] < 54) // pick the nearest of 36 or 72
3160                                 hull = &cmodel->brushq1.hulls[3]; // 32x32x36
3161                         else
3162                                 hull = &cmodel->brushq1.hulls[1]; // 32x32x72
3163                 }
3164                 else
3165                         hull = &cmodel->brushq1.hulls[2]; // 64x64x64
3166         }
3167         else
3168         {
3169                 if (size[0] < 3)
3170                         hull = &cmodel->brushq1.hulls[0]; // 0x0x0
3171                 else if (size[0] <= 32)
3172                         hull = &cmodel->brushq1.hulls[1]; // 32x32x56
3173                 else
3174                         hull = &cmodel->brushq1.hulls[2]; // 64x64x88
3175         }
3176         VectorCopy(inmins, outmins);
3177         VectorAdd(inmins, hull->clip_size, outmaxs);
3178 }
3179
3180 void Mod_Q1BSP_Load(model_t *mod, void *buffer, void *bufferend)
3181 {
3182         int i, j, k;
3183         dheader_t *header;
3184         dmodel_t *bm;
3185         mempool_t *mainmempool;
3186         float dist, modelyawradius, modelradius, *vec;
3187         msurface_t *surface;
3188         int numshadowmeshtriangles;
3189         dheader_t _header;
3190         hullinfo_t hullinfo;
3191
3192         mod->type = mod_brushq1;
3193
3194         if (!memcmp (buffer, "MCBSPpad", 8))
3195         {
3196                 unsigned char   *index;
3197
3198                 mod->brush.ismcbsp = true;
3199                 mod->brush.ishlbsp = false;
3200
3201                 mod_base = (unsigned char*)buffer;
3202
3203                 index = mod_base;
3204                 index += 8;
3205                 i = SB_ReadInt (&index);
3206                 if (i != MCBSPVERSION)
3207                         Host_Error("Mod_Q1BSP_Load: %s has wrong version number(%i should be %i)", mod->name, i, MCBSPVERSION);
3208
3209         // read hull info
3210                 hullinfo.numhulls = LittleLong(*(int*)index); index += 4;
3211                 hullinfo.filehulls = hullinfo.numhulls;
3212                 VectorClear (hullinfo.hullsizes[0][0]);
3213                 VectorClear (hullinfo.hullsizes[0][1]);
3214                 for (i = 1; i < hullinfo.numhulls; i++)
3215                 {
3216                         hullinfo.hullsizes[i][0][0] = SB_ReadFloat (&index);
3217                         hullinfo.hullsizes[i][0][1] = SB_ReadFloat (&index);
3218                         hullinfo.hullsizes[i][0][2] = SB_ReadFloat (&index);
3219                         hullinfo.hullsizes[i][1][0] = SB_ReadFloat (&index);
3220                         hullinfo.hullsizes[i][1][1] = SB_ReadFloat (&index);
3221                         hullinfo.hullsizes[i][1][2] = SB_ReadFloat (&index);
3222                 }
3223
3224         // read lumps
3225                 _header.version = 0;
3226                 for (i = 0; i < HEADER_LUMPS; i++)
3227                 {
3228                         _header.lumps[i].fileofs = SB_ReadInt (&index);
3229                         _header.lumps[i].filelen = SB_ReadInt (&index);
3230                 }
3231
3232                 header = &_header;
3233         }
3234         else
3235         {
3236                 header = (dheader_t *)buffer;
3237
3238                 i = LittleLong(header->version);
3239                 if (i != BSPVERSION && i != 30)
3240                         Host_Error("Mod_Q1BSP_Load: %s has wrong version number(%i should be %i(Quake) or 30(HalfLife)", mod->name, i, BSPVERSION);
3241                 mod->brush.ishlbsp = i == 30;
3242                 mod->brush.ismcbsp = false;
3243
3244         // fill in hull info
3245                 VectorClear (hullinfo.hullsizes[0][0]);
3246                 VectorClear (hullinfo.hullsizes[0][1]);
3247                 if (mod->brush.ishlbsp)
3248                 {
3249                         hullinfo.numhulls = 4;
3250                         hullinfo.filehulls = 4;
3251                         VectorSet (hullinfo.hullsizes[1][0], -16, -16, -36);
3252                         VectorSet (hullinfo.hullsizes[1][1], 16, 16, 36);
3253                         VectorSet (hullinfo.hullsizes[2][0], -32, -32, -32);
3254                         VectorSet (hullinfo.hullsizes[2][1], 32, 32, 32);
3255                         VectorSet (hullinfo.hullsizes[3][0], -16, -16, -18);
3256                         VectorSet (hullinfo.hullsizes[3][1], 16, 16, 18);
3257                 }
3258                 else
3259                 {
3260                         hullinfo.numhulls = 3;
3261                         hullinfo.filehulls = 4;
3262                         VectorSet (hullinfo.hullsizes[1][0], -16, -16, -24);
3263                         VectorSet (hullinfo.hullsizes[1][1], 16, 16, 32);
3264                         VectorSet (hullinfo.hullsizes[2][0], -32, -32, -24);
3265                         VectorSet (hullinfo.hullsizes[2][1], 32, 32, 64);
3266                 }
3267
3268         // read lumps
3269                 mod_base = (unsigned char*)buffer;
3270                 for (i = 0; i < HEADER_LUMPS; i++)
3271                 {
3272                         header->lumps[i].fileofs = LittleLong(header->lumps[i].fileofs);
3273                         header->lumps[i].filelen = LittleLong(header->lumps[i].filelen);
3274                 }
3275         }
3276
3277         mod->soundfromcenter = true;
3278         mod->TraceBox = Mod_Q1BSP_TraceBox;
3279         mod->brush.SuperContentsFromNativeContents = Mod_Q1BSP_SuperContentsFromNativeContents;
3280         mod->brush.NativeContentsFromSuperContents = Mod_Q1BSP_NativeContentsFromSuperContents;
3281         mod->brush.GetPVS = Mod_Q1BSP_GetPVS;
3282         mod->brush.FatPVS = Mod_Q1BSP_FatPVS;
3283         mod->brush.BoxTouchingPVS = Mod_Q1BSP_BoxTouchingPVS;
3284         mod->brush.BoxTouchingLeafPVS = Mod_Q1BSP_BoxTouchingLeafPVS;
3285         mod->brush.BoxTouchingVisibleLeafs = Mod_Q1BSP_BoxTouchingVisibleLeafs;
3286         mod->brush.FindBoxClusters = Mod_Q1BSP_FindBoxClusters;
3287         mod->brush.LightPoint = Mod_Q1BSP_LightPoint;
3288         mod->brush.FindNonSolidLocation = Mod_Q1BSP_FindNonSolidLocation;
3289         mod->brush.AmbientSoundLevelsForPoint = Mod_Q1BSP_AmbientSoundLevelsForPoint;
3290         mod->brush.RoundUpToHullSize = Mod_Q1BSP_RoundUpToHullSize;
3291         mod->brush.PointInLeaf = Mod_Q1BSP_PointInLeaf;
3292
3293         if (loadmodel->isworldmodel)
3294         {
3295                 Cvar_SetValue("halflifebsp", mod->brush.ishlbsp);
3296                 Cvar_SetValue("mcbsp", mod->brush.ismcbsp);
3297         }
3298
3299 // load into heap
3300
3301         // store which lightmap format to use
3302         mod->brushq1.lightmaprgba = r_lightmaprgba.integer;
3303
3304         mod->brush.qw_md4sum = 0;
3305         mod->brush.qw_md4sum2 = 0;
3306         for (i = 0;i < HEADER_LUMPS;i++)
3307         {
3308                 if (i == LUMP_ENTITIES)
3309                         continue;
3310                 mod->brush.qw_md4sum ^= LittleLong(Com_BlockChecksum(mod_base + header->lumps[i].fileofs, header->lumps[i].filelen));
3311                 if (i == LUMP_VISIBILITY || i == LUMP_LEAFS || i == LUMP_NODES)
3312                         continue;
3313                 mod->brush.qw_md4sum2 ^= LittleLong(Com_BlockChecksum(mod_base + header->lumps[i].fileofs, header->lumps[i].filelen));
3314         }
3315
3316         Mod_Q1BSP_LoadEntities(&header->lumps[LUMP_ENTITIES]);
3317         Mod_Q1BSP_LoadVertexes(&header->lumps[LUMP_VERTEXES]);
3318         Mod_Q1BSP_LoadEdges(&header->lumps[LUMP_EDGES]);
3319         Mod_Q1BSP_LoadSurfedges(&header->lumps[LUMP_SURFEDGES]);
3320         Mod_Q1BSP_LoadTextures(&header->lumps[LUMP_TEXTURES]);
3321         Mod_Q1BSP_LoadLighting(&header->lumps[LUMP_LIGHTING]);
3322         Mod_Q1BSP_LoadPlanes(&header->lumps[LUMP_PLANES]);
3323         Mod_Q1BSP_LoadTexinfo(&header->lumps[LUMP_TEXINFO]);
3324         Mod_Q1BSP_LoadFaces(&header->lumps[LUMP_FACES]);
3325         Mod_Q1BSP_LoadLeaffaces(&header->lumps[LUMP_MARKSURFACES]);
3326         Mod_Q1BSP_LoadVisibility(&header->lumps[LUMP_VISIBILITY]);
3327         // load submodels before leafs because they contain the number of vis leafs
3328         Mod_Q1BSP_LoadSubmodels(&header->lumps[LUMP_MODELS], &hullinfo);
3329         Mod_Q1BSP_LoadLeafs(&header->lumps[LUMP_LEAFS]);
3330         Mod_Q1BSP_LoadNodes(&header->lumps[LUMP_NODES]);
3331         Mod_Q1BSP_LoadClipnodes(&header->lumps[LUMP_CLIPNODES], &hullinfo);
3332
3333         // check if the map supports transparent water rendering
3334         loadmodel->brush.supportwateralpha = Mod_Q1BSP_CheckWaterAlphaSupport();
3335
3336         if (!mod->brushq1.lightdata)
3337                 mod->brush.LightPoint = NULL;
3338
3339         if (mod->brushq1.data_compressedpvs)
3340                 Mem_Free(mod->brushq1.data_compressedpvs);
3341         mod->brushq1.data_compressedpvs = NULL;
3342         mod->brushq1.num_compressedpvs = 0;
3343
3344         Mod_Q1BSP_MakeHull0();
3345         Mod_Q1BSP_MakePortals();
3346
3347         mod->numframes = 2;             // regular and alternate animation
3348         mod->numskins = 1;
3349
3350         mainmempool = mod->mempool;
3351
3352         // make a single combined shadow mesh to allow optimized shadow volume creation
3353         numshadowmeshtriangles = 0;
3354         for (j = 0, surface = loadmodel->data_surfaces;j < loadmodel->num_surfaces;j++, surface++)
3355         {
3356                 surface->num_firstshadowmeshtriangle = numshadowmeshtriangles;
3357                 numshadowmeshtriangles += surface->num_triangles;
3358         }
3359         loadmodel->brush.shadowmesh = Mod_ShadowMesh_Begin(loadmodel->mempool, numshadowmeshtriangles * 3, numshadowmeshtriangles, NULL, NULL, NULL, false, false, true);
3360         for (j = 0, surface = loadmodel->data_surfaces;j < loadmodel->num_surfaces;j++, surface++)
3361                 Mod_ShadowMesh_AddMesh(loadmodel->mempool, loadmodel->brush.shadowmesh, NULL, NULL, NULL, loadmodel->surfmesh.data_vertex3f, NULL, NULL, NULL, NULL, surface->num_triangles, (loadmodel->surfmesh.data_element3i + 3 * surface->num_firsttriangle));
3362         loadmodel->brush.shadowmesh = Mod_ShadowMesh_Finish(loadmodel->mempool, loadmodel->brush.shadowmesh, false, true);
3363         Mod_BuildTriangleNeighbors(loadmodel->brush.shadowmesh->neighbor3i, loadmodel->brush.shadowmesh->element3i, loadmodel->brush.shadowmesh->numtriangles);
3364
3365         if (loadmodel->brush.numsubmodels)
3366                 loadmodel->brush.submodels = (model_t **)Mem_Alloc(loadmodel->mempool, loadmodel->brush.numsubmodels * sizeof(model_t *));
3367
3368         if (loadmodel->isworldmodel)
3369         {
3370                 // clear out any stale submodels or worldmodels lying around
3371                 // if we did this clear before now, an error might abort loading and
3372                 // leave things in a bad state
3373                 Mod_RemoveStaleWorldModels(loadmodel);
3374         }
3375
3376         // LordHavoc: to clear the fog around the original quake submodel code, I
3377         // will explain:
3378         // first of all, some background info on the submodels:
3379         // model 0 is the map model (the world, named maps/e1m1.bsp for example)
3380         // model 1 and higher are submodels (doors and the like, named *1, *2, etc)
3381         // now the weird for loop itself:
3382         // the loop functions in an odd way, on each iteration it sets up the
3383         // current 'mod' model (which despite the confusing code IS the model of
3384         // the number i), at the end of the loop it duplicates the model to become
3385         // the next submodel, and loops back to set up the new submodel.
3386
3387         // LordHavoc: now the explanation of my sane way (which works identically):
3388         // set up the world model, then on each submodel copy from the world model
3389         // and set up the submodel with the respective model info.
3390         for (i = 0;i < mod->brush.numsubmodels;i++)
3391         {
3392                 // LordHavoc: this code was originally at the end of this loop, but
3393                 // has been transformed to something more readable at the start here.
3394
3395                 if (i > 0)
3396                 {
3397                         char name[10];
3398                         // LordHavoc: only register submodels if it is the world
3399                         // (prevents external bsp models from replacing world submodels with
3400                         //  their own)
3401                         if (!loadmodel->isworldmodel)
3402                                 continue;
3403                         // duplicate the basic information
3404                         sprintf(name, "*%i", i);
3405                         mod = Mod_FindName(name);
3406                         // copy the base model to this one
3407                         *mod = *loadmodel;
3408                         // rename the clone back to its proper name
3409                         strlcpy(mod->name, name, sizeof(mod->name));
3410                         // textures and memory belong to the main model
3411                         mod->texturepool = NULL;
3412                         mod->mempool = NULL;
3413                 }
3414
3415                 mod->brush.submodel = i;
3416
3417                 if (loadmodel->brush.submodels)
3418                         loadmodel->brush.submodels[i] = mod;
3419
3420                 bm = &mod->brushq1.submodels[i];
3421
3422                 mod->brushq1.hulls[0].firstclipnode = bm->headnode[0];
3423                 for (j=1 ; j<MAX_MAP_HULLS ; j++)
3424                 {
3425                         mod->brushq1.hulls[j].firstclipnode = bm->headnode[j];
3426                         mod->brushq1.hulls[j].lastclipnode = mod->brushq1.numclipnodes - 1;
3427                 }
3428
3429                 mod->firstmodelsurface = bm->firstface;
3430                 mod->nummodelsurfaces = bm->numfaces;
3431
3432                 // make the model surface list (used by shadowing/lighting)
3433                 mod->surfacelist = (int *)Mem_Alloc(loadmodel->mempool, mod->nummodelsurfaces * sizeof(*mod->surfacelist));
3434                 for (j = 0;j < mod->nummodelsurfaces;j++)
3435                         mod->surfacelist[j] = mod->firstmodelsurface + j;
3436
3437                 // this gets altered below if sky is used
3438                 mod->DrawSky = NULL;
3439                 mod->Draw = R_Q1BSP_Draw;
3440                 mod->GetLightInfo = R_Q1BSP_GetLightInfo;
3441                 mod->CompileShadowVolume = R_Q1BSP_CompileShadowVolume;
3442                 mod->DrawShadowVolume = R_Q1BSP_DrawShadowVolume;
3443                 mod->DrawLight = R_Q1BSP_DrawLight;
3444                 if (i != 0)
3445                 {
3446                         mod->brush.GetPVS = NULL;
3447                         mod->brush.FatPVS = NULL;
3448                         mod->brush.BoxTouchingPVS = NULL;
3449                         mod->brush.BoxTouchingLeafPVS = NULL;
3450                         mod->brush.BoxTouchingVisibleLeafs = NULL;
3451                         mod->brush.FindBoxClusters = NULL;
3452                         mod->brush.LightPoint = NULL;
3453                         mod->brush.AmbientSoundLevelsForPoint = NULL;
3454                 }
3455                 Mod_Q1BSP_BuildLightmapUpdateChains(loadmodel->mempool, mod);
3456                 if (mod->nummodelsurfaces)
3457                 {
3458                         // LordHavoc: calculate bmodel bounding box rather than trusting what it says
3459                         mod->normalmins[0] = mod->normalmins[1] = mod->normalmins[2] = 1000000000.0f;
3460                         mod->normalmaxs[0] = mod->normalmaxs[1] = mod->normalmaxs[2] = -1000000000.0f;
3461                         modelyawradius = 0;
3462                         modelradius = 0;
3463                         for (j = 0, surface = &mod->data_surfaces[mod->firstmodelsurface];j < mod->nummodelsurfaces;j++, surface++)
3464                         {
3465                                 // we only need to have a drawsky function if it is used(usually only on world model)
3466                                 if (surface->texture->basematerialflags & MATERIALFLAG_SKY)
3467                                         mod->DrawSky = R_Q1BSP_DrawSky;
3468                                 // calculate bounding shapes
3469                                 for (k = 0, vec = (loadmodel->surfmesh.data_vertex3f + 3 * surface->num_firstvertex);k < surface->num_vertices;k++, vec += 3)
3470                                 {
3471                                         if (mod->normalmins[0] > vec[0]) mod->normalmins[0] = vec[0];
3472                                         if (mod->normalmins[1] > vec[1]) mod->normalmins[1] = vec[1];
3473                                         if (mod->normalmins[2] > vec[2]) mod->normalmins[2] = vec[2];
3474                                         if (mod->normalmaxs[0] < vec[0]) mod->normalmaxs[0] = vec[0];
3475                                         if (mod->normalmaxs[1] < vec[1]) mod->normalmaxs[1] = vec[1];
3476                                         if (mod->normalmaxs[2] < vec[2]) mod->normalmaxs[2] = vec[2];
3477                                         dist = vec[0]*vec[0]+vec[1]*vec[1];
3478                                         if (modelyawradius < dist)
3479                                                 modelyawradius = dist;
3480                                         dist += vec[2]*vec[2];
3481                                         if (modelradius < dist)
3482                                                 modelradius = dist;
3483                                 }
3484                         }
3485                         modelyawradius = sqrt(modelyawradius);
3486                         modelradius = sqrt(modelradius);
3487                         mod->yawmins[0] = mod->yawmins[1] = - (mod->yawmaxs[0] = mod->yawmaxs[1] = modelyawradius);
3488                         mod->yawmins[2] = mod->normalmins[2];
3489                         mod->yawmaxs[2] = mod->normalmaxs[2];
3490                         mod->rotatedmins[0] = mod->rotatedmins[1] = mod->rotatedmins[2] = -modelradius;
3491                         mod->rotatedmaxs[0] = mod->rotatedmaxs[1] = mod->rotatedmaxs[2] = modelradius;
3492                         mod->radius = modelradius;
3493                         mod->radius2 = modelradius * modelradius;
3494                 }
3495                 else
3496                 {
3497                         // LordHavoc: empty submodel(lacrima.bsp has such a glitch)
3498                         Con_Printf("warning: empty submodel *%i in %s\n", i+1, loadmodel->name);
3499                 }
3500                 //mod->brushq1.num_visleafs = bm->visleafs;
3501         }
3502
3503         Mod_Q1BSP_LoadMapBrushes();
3504
3505         //Mod_Q1BSP_ProcessLightList();
3506
3507         if (developer.integer >= 10)
3508                 Con_Printf("Some stats for q1bsp model \"%s\": %i faces, %i nodes, %i leafs, %i visleafs, %i visleafportals\n", loadmodel->name, loadmodel->num_surfaces, loadmodel->brush.num_nodes, loadmodel->brush.num_leafs, mod->brush.num_pvsclusters, loadmodel->brush.num_portals);
3509 }
3510
3511 static void Mod_Q2BSP_LoadEntities(lump_t *l)
3512 {
3513 }
3514
3515 static void Mod_Q2BSP_LoadPlanes(lump_t *l)
3516 {
3517 /*
3518         d_t *in;
3519         m_t *out;
3520         int i, count;
3521
3522         in = (void *)(mod_base + l->fileofs);
3523         if (l->filelen % sizeof(*in))
3524                 Host_Error("Mod_Q2BSP_LoadPlanes: funny lump size in %s",loadmodel->name);
3525         count = l->filelen / sizeof(*in);
3526         out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
3527
3528         loadmodel-> = out;
3529         loadmodel->num = count;
3530
3531         for (i = 0;i < count;i++, in++, out++)
3532         {
3533         }
3534 */
3535 }
3536
3537 static void Mod_Q2BSP_LoadVertices(lump_t *l)
3538 {
3539 /*
3540         d_t *in;
3541         m_t *out;
3542         int i, count;
3543
3544         in = (void *)(mod_base + l->fileofs);
3545         if (l->filelen % sizeof(*in))
3546                 Host_Error("Mod_Q2BSP_LoadVertices: funny lump size in %s",loadmodel->name);
3547         count = l->filelen / sizeof(*in);
3548         out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
3549
3550         loadmodel-> = out;
3551         loadmodel->num = count;
3552
3553         for (i = 0;i < count;i++, in++, out++)
3554         {
3555         }
3556 */
3557 }
3558
3559 static void Mod_Q2BSP_LoadVisibility(lump_t *l)
3560 {
3561 /*
3562         d_t *in;
3563         m_t *out;
3564         int i, count;
3565
3566         in = (void *)(mod_base + l->fileofs);
3567         if (l->filelen % sizeof(*in))
3568                 Host_Error("Mod_Q2BSP_LoadVisibility: funny lump size in %s",loadmodel->name);
3569         count = l->filelen / sizeof(*in);
3570         out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
3571
3572         loadmodel-> = out;
3573         loadmodel->num = count;
3574
3575         for (i = 0;i < count;i++, in++, out++)
3576         {
3577         }
3578 */
3579 }
3580
3581 static void Mod_Q2BSP_LoadNodes(lump_t *l)
3582 {
3583 /*
3584         d_t *in;
3585         m_t *out;
3586         int i, count;
3587
3588         in = (void *)(mod_base + l->fileofs);
3589         if (l->filelen % sizeof(*in))
3590                 Host_Error("Mod_Q2BSP_LoadNodes: funny lump size in %s",loadmodel->name);
3591         count = l->filelen / sizeof(*in);
3592         out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
3593
3594         loadmodel-> = out;
3595         loadmodel->num = count;
3596
3597         for (i = 0;i < count;i++, in++, out++)
3598         {
3599         }
3600 */
3601 }
3602
3603 static void Mod_Q2BSP_LoadTexInfo(lump_t *l)
3604 {
3605 /*
3606         d_t *in;
3607         m_t *out;
3608         int i, count;
3609
3610         in = (void *)(mod_base + l->fileofs);
3611         if (l->filelen % sizeof(*in))
3612                 Host_Error("Mod_Q2BSP_LoadTexInfo: funny lump size in %s",loadmodel->name);
3613         count = l->filelen / sizeof(*in);
3614         out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
3615
3616         loadmodel-> = out;
3617         loadmodel->num = count;
3618
3619         for (i = 0;i < count;i++, in++, out++)
3620         {
3621         }
3622 */
3623 }
3624
3625 static void Mod_Q2BSP_LoadFaces(lump_t *l)
3626 {
3627 /*
3628         d_t *in;
3629         m_t *out;
3630         int i, count;
3631
3632         in = (void *)(mod_base + l->fileofs);
3633         if (l->filelen % sizeof(*in))
3634                 Host_Error("Mod_Q2BSP_LoadFaces: funny lump size in %s",loadmodel->name);
3635         count = l->filelen / sizeof(*in);
3636         out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
3637
3638         loadmodel-> = out;
3639         loadmodel->num = count;
3640
3641         for (i = 0;i < count;i++, in++, out++)
3642         {
3643         }
3644 */
3645 }
3646
3647 static void Mod_Q2BSP_LoadLighting(lump_t *l)
3648 {
3649 /*
3650         d_t *in;
3651         m_t *out;
3652         int i, count;
3653
3654         in = (void *)(mod_base + l->fileofs);
3655         if (l->filelen % sizeof(*in))
3656                 Host_Error("Mod_Q2BSP_LoadLighting: funny lump size in %s",loadmodel->name);
3657         count = l->filelen / sizeof(*in);
3658         out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
3659
3660         loadmodel-> = out;
3661         loadmodel->num = count;
3662
3663         for (i = 0;i < count;i++, in++, out++)
3664         {
3665         }
3666 */
3667 }
3668
3669 static void Mod_Q2BSP_LoadLeafs(lump_t *l)
3670 {
3671 /*
3672         d_t *in;
3673         m_t *out;
3674         int i, count;
3675
3676         in = (void *)(mod_base + l->fileofs);
3677         if (l->filelen % sizeof(*in))
3678                 Host_Error("Mod_Q2BSP_LoadLeafs: funny lump size in %s",loadmodel->name);
3679         count = l->filelen / sizeof(*in);
3680         out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
3681
3682         loadmodel-> = out;
3683         loadmodel->num = count;
3684
3685         for (i = 0;i < count;i++, in++, out++)
3686         {
3687         }
3688 */
3689 }
3690
3691 static void Mod_Q2BSP_LoadLeafFaces(lump_t *l)
3692 {
3693 /*
3694         d_t *in;
3695         m_t *out;
3696         int i, count;
3697
3698         in = (void *)(mod_base + l->fileofs);
3699         if (l->filelen % sizeof(*in))
3700                 Host_Error("Mod_Q2BSP_LoadLeafFaces: funny lump size in %s",loadmodel->name);
3701         count = l->filelen / sizeof(*in);
3702         out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
3703
3704         loadmodel-> = out;
3705         loadmodel->num = count;
3706
3707         for (i = 0;i < count;i++, in++, out++)
3708         {
3709         }
3710 */
3711 }
3712
3713 static void Mod_Q2BSP_LoadLeafBrushes(lump_t *l)
3714 {
3715 /*
3716         d_t *in;
3717         m_t *out;
3718         int i, count;
3719
3720         in = (void *)(mod_base + l->fileofs);
3721         if (l->filelen % sizeof(*in))
3722                 Host_Error("Mod_Q2BSP_LoadLeafBrushes: funny lump size in %s",loadmodel->name);
3723         count = l->filelen / sizeof(*in);
3724         out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
3725
3726         loadmodel-> = out;
3727         loadmodel->num = count;
3728
3729         for (i = 0;i < count;i++, in++, out++)
3730         {
3731         }
3732 */
3733 }
3734
3735 static void Mod_Q2BSP_LoadEdges(lump_t *l)
3736 {
3737 /*
3738         d_t *in;
3739         m_t *out;
3740         int i, count;
3741
3742         in = (void *)(mod_base + l->fileofs);
3743         if (l->filelen % sizeof(*in))
3744                 Host_Error("Mod_Q2BSP_LoadEdges: funny lump size in %s",loadmodel->name);
3745         count = l->filelen / sizeof(*in);
3746         out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
3747
3748         loadmodel-> = out;
3749         loadmodel->num = count;
3750
3751         for (i = 0;i < count;i++, in++, out++)
3752         {
3753         }
3754 */
3755 }
3756
3757 static void Mod_Q2BSP_LoadSurfEdges(lump_t *l)
3758 {
3759 /*
3760         d_t *in;
3761         m_t *out;
3762         int i, count;
3763
3764         in = (void *)(mod_base + l->fileofs);
3765         if (l->filelen % sizeof(*in))
3766                 Host_Error("Mod_Q2BSP_LoadSurfEdges: funny lump size in %s",loadmodel->name);
3767         count = l->filelen / sizeof(*in);
3768         out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
3769
3770         loadmodel-> = out;
3771         loadmodel->num = count;
3772
3773         for (i = 0;i < count;i++, in++, out++)
3774         {
3775         }
3776 */
3777 }
3778
3779 static void Mod_Q2BSP_LoadBrushes(lump_t *l)
3780 {
3781 /*
3782         d_t *in;
3783         m_t *out;
3784         int i, count;
3785
3786         in = (void *)(mod_base + l->fileofs);
3787         if (l->filelen % sizeof(*in))
3788                 Host_Error("Mod_Q2BSP_LoadBrushes: funny lump size in %s",loadmodel->name);
3789         count = l->filelen / sizeof(*in);
3790         out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
3791
3792         loadmodel-> = out;
3793         loadmodel->num = count;
3794
3795         for (i = 0;i < count;i++, in++, out++)
3796         {
3797         }
3798 */
3799 }
3800
3801 static void Mod_Q2BSP_LoadBrushSides(lump_t *l)
3802 {
3803 /*
3804         d_t *in;
3805         m_t *out;
3806         int i, count;
3807
3808         in = (void *)(mod_base + l->fileofs);
3809         if (l->filelen % sizeof(*in))
3810                 Host_Error("Mod_Q2BSP_LoadBrushSides: funny lump size in %s",loadmodel->name);
3811         count = l->filelen / sizeof(*in);
3812         out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
3813
3814         loadmodel-> = out;
3815         loadmodel->num = count;
3816
3817         for (i = 0;i < count;i++, in++, out++)
3818         {
3819         }
3820 */
3821 }
3822
3823 static void Mod_Q2BSP_LoadAreas(lump_t *l)
3824 {
3825 /*
3826         d_t *in;
3827         m_t *out;
3828         int i, count;
3829
3830         in = (void *)(mod_base + l->fileofs);
3831         if (l->filelen % sizeof(*in))
3832                 Host_Error("Mod_Q2BSP_LoadAreas: funny lump size in %s",loadmodel->name);
3833         count = l->filelen / sizeof(*in);
3834         out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
3835
3836         loadmodel-> = out;
3837         loadmodel->num = count;
3838
3839         for (i = 0;i < count;i++, in++, out++)
3840         {
3841         }
3842 */
3843 }
3844
3845 static void Mod_Q2BSP_LoadAreaPortals(lump_t *l)
3846 {
3847 /*
3848         d_t *in;
3849         m_t *out;
3850         int i, count;
3851
3852         in = (void *)(mod_base + l->fileofs);
3853         if (l->filelen % sizeof(*in))
3854                 Host_Error("Mod_Q2BSP_LoadAreaPortals: funny lump size in %s",loadmodel->name);
3855         count = l->filelen / sizeof(*in);
3856         out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
3857
3858         loadmodel-> = out;
3859         loadmodel->num = count;
3860
3861         for (i = 0;i < count;i++, in++, out++)
3862         {
3863         }
3864 */
3865 }
3866
3867 static void Mod_Q2BSP_LoadModels(lump_t *l)
3868 {
3869 /*
3870         d_t *in;
3871         m_t *out;
3872         int i, count;
3873
3874         in = (void *)(mod_base + l->fileofs);
3875         if (l->filelen % sizeof(*in))
3876                 Host_Error("Mod_Q2BSP_LoadModels: funny lump size in %s",loadmodel->name);
3877         count = l->filelen / sizeof(*in);
3878         out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
3879
3880         loadmodel-> = out;
3881         loadmodel->num = count;
3882
3883         for (i = 0;i < count;i++, in++, out++)
3884         {
3885         }
3886 */
3887 }
3888
3889 void static Mod_Q2BSP_Load(model_t *mod, void *buffer, void *bufferend)
3890 {
3891         int i;
3892         q2dheader_t *header;
3893
3894         Host_Error("Mod_Q2BSP_Load: not yet implemented");
3895
3896         mod->type = mod_brushq2;
3897
3898         header = (q2dheader_t *)buffer;
3899
3900         i = LittleLong(header->version);
3901         if (i != Q2BSPVERSION)
3902                 Host_Error("Mod_Q2BSP_Load: %s has wrong version number (%i, should be %i)", mod->name, i, Q2BSPVERSION);
3903         mod->brush.ishlbsp = false;
3904         mod->brush.ismcbsp = false;
3905         if (loadmodel->isworldmodel)
3906         {
3907                 Cvar_SetValue("halflifebsp", mod->brush.ishlbsp);
3908                 Cvar_SetValue("mcbsp", mod->brush.ismcbsp);
3909         }
3910
3911         mod_base = (unsigned char *)header;
3912
3913         // swap all the lumps
3914         for (i = 0;i < (int) sizeof(*header) / 4;i++)
3915                 ((int *)header)[i] = LittleLong(((int *)header)[i]);
3916
3917         // store which lightmap format to use
3918         mod->brushq1.lightmaprgba = r_lightmaprgba.integer;
3919
3920         mod->brush.qw_md4sum = 0;
3921         mod->brush.qw_md4sum2 = 0;
3922         for (i = 0;i < Q2HEADER_LUMPS;i++)
3923         {
3924                 if (i == Q2LUMP_ENTITIES)
3925                         continue;
3926                 mod->brush.qw_md4sum ^= Com_BlockChecksum(mod_base + header->lumps[i].fileofs, header->lumps[i].filelen);
3927                 if (i == Q2LUMP_VISIBILITY || i == Q2LUMP_LEAFS || i == Q2LUMP_NODES)
3928                         continue;
3929                 mod->brush.qw_md4sum2 ^= Com_BlockChecksum(mod_base + header->lumps[i].fileofs, header->lumps[i].filelen);
3930         }
3931
3932         Mod_Q2BSP_LoadEntities(&header->lumps[Q2LUMP_ENTITIES]);
3933         Mod_Q2BSP_LoadPlanes(&header->lumps[Q2LUMP_PLANES]);
3934         Mod_Q2BSP_LoadVertices(&header->lumps[Q2LUMP_VERTEXES]);
3935         Mod_Q2BSP_LoadVisibility(&header->lumps[Q2LUMP_VISIBILITY]);
3936         Mod_Q2BSP_LoadNodes(&header->lumps[Q2LUMP_NODES]);
3937         Mod_Q2BSP_LoadTexInfo(&header->lumps[Q2LUMP_TEXINFO]);
3938         Mod_Q2BSP_LoadFaces(&header->lumps[Q2LUMP_FACES]);
3939         Mod_Q2BSP_LoadLighting(&header->lumps[Q2LUMP_LIGHTING]);
3940         Mod_Q2BSP_LoadLeafs(&header->lumps[Q2LUMP_LEAFS]);
3941         Mod_Q2BSP_LoadLeafFaces(&header->lumps[Q2LUMP_LEAFFACES]);
3942         Mod_Q2BSP_LoadLeafBrushes(&header->lumps[Q2LUMP_LEAFBRUSHES]);
3943         Mod_Q2BSP_LoadEdges(&header->lumps[Q2LUMP_EDGES]);
3944         Mod_Q2BSP_LoadSurfEdges(&header->lumps[Q2LUMP_SURFEDGES]);
3945         Mod_Q2BSP_LoadBrushes(&header->lumps[Q2LUMP_BRUSHES]);
3946         Mod_Q2BSP_LoadBrushSides(&header->lumps[Q2LUMP_BRUSHSIDES]);
3947         Mod_Q2BSP_LoadAreas(&header->lumps[Q2LUMP_AREAS]);
3948         Mod_Q2BSP_LoadAreaPortals(&header->lumps[Q2LUMP_AREAPORTALS]);
3949         // LordHavoc: must go last because this makes the submodels
3950         Mod_Q2BSP_LoadModels(&header->lumps[Q2LUMP_MODELS]);
3951 }
3952
3953 static int Mod_Q3BSP_SuperContentsFromNativeContents(model_t *model, int nativecontents);
3954 static int Mod_Q3BSP_NativeContentsFromSuperContents(model_t *model, int supercontents);
3955
3956 static void Mod_Q3BSP_LoadEntities(lump_t *l)
3957 {
3958         const char *data;
3959         char key[128], value[MAX_INPUTLINE];
3960         float v[3];
3961         loadmodel->brushq3.num_lightgrid_cellsize[0] = 64;
3962         loadmodel->brushq3.num_lightgrid_cellsize[1] = 64;
3963         loadmodel->brushq3.num_lightgrid_cellsize[2] = 128;
3964         if (!l->filelen)
3965                 return;
3966         loadmodel->brush.entities = (char *)Mem_Alloc(loadmodel->mempool, l->filelen);
3967         memcpy(loadmodel->brush.entities, mod_base + l->fileofs, l->filelen);
3968         data = loadmodel->brush.entities;
3969         // some Q3 maps override the lightgrid_cellsize with a worldspawn key
3970         if (data && COM_ParseTokenConsole(&data) && com_token[0] == '{')
3971         {
3972                 while (1)
3973                 {
3974                         if (!COM_ParseTokenConsole(&data))
3975                                 break; // error
3976                         if (com_token[0] == '}')
3977                                 break; // end of worldspawn
3978                         if (com_token[0] == '_')
3979                                 strlcpy(key, com_token + 1, sizeof(key));
3980                         else
3981                                 strlcpy(key, com_token, sizeof(key));
3982                         while (key[strlen(key)-1] == ' ') // remove trailing spaces
3983                                 key[strlen(key)-1] = 0;
3984                         if (!COM_ParseTokenConsole(&data))
3985                                 break; // error
3986                         strlcpy(value, com_token, sizeof(value));
3987                         if (!strcmp("gridsize", key))
3988                         {
3989                                 if (sscanf(value, "%f %f %f", &v[0], &v[1], &v[2]) == 3 && v[0] != 0 && v[1] != 0 && v[2] != 0)
3990                                         VectorCopy(v, loadmodel->brushq3.num_lightgrid_cellsize);
3991                         }
3992                 }
3993         }
3994 }
3995
3996 // FIXME: make MAXSHADERS dynamic
3997 #define Q3SHADER_MAXSHADERS 4096
3998 #define Q3SHADER_MAXLAYERS 8
3999
4000 typedef struct q3shaderinfo_layer_s
4001 {
4002         int alphatest;
4003         int clampmap;
4004         float framerate;
4005         int numframes;
4006         char texturename[TEXTURE_MAXFRAMES][Q3PATHLENGTH];
4007         int blendfunc[2];
4008         qboolean rgbgenvertex;
4009         qboolean alphagenvertex;
4010 }
4011 q3shaderinfo_layer_t;
4012
4013 typedef struct q3shaderinfo_s
4014 {
4015         char name[Q3PATHLENGTH];
4016         int surfaceparms;
4017         int textureflags;
4018         int numlayers;
4019         qboolean lighting;
4020         qboolean vertexalpha;
4021         qboolean textureblendalpha;
4022         q3shaderinfo_layer_t *primarylayer, *backgroundlayer;
4023         q3shaderinfo_layer_t layers[Q3SHADER_MAXLAYERS];
4024         char skyboxname[Q3PATHLENGTH];
4025 }
4026 q3shaderinfo_t;
4027
4028 int q3shaders_numshaders;
4029 q3shaderinfo_t q3shaders_shaders[Q3SHADER_MAXSHADERS];
4030
4031 static void Mod_Q3BSP_LoadShaders(void)
4032 {
4033         int j;
4034         int fileindex;
4035         fssearch_t *search;
4036         char *f;
4037         const char *text;
4038         q3shaderinfo_t *shader;
4039         q3shaderinfo_layer_t *layer;
4040         int numparameters;
4041         char parameter[TEXTURE_MAXFRAMES + 4][Q3PATHLENGTH];
4042         search = FS_Search("scripts/*.shader", true, false);
4043         if (!search)
4044                 return;
4045         q3shaders_numshaders = 0;
4046         for (fileindex = 0;fileindex < search->numfilenames;fileindex++)
4047         {
4048                 text = f = (char *)FS_LoadFile(search->filenames[fileindex], tempmempool, false, NULL);
4049                 if (!f)
4050                         continue;
4051                 while (COM_ParseToken(&text, false))
4052                 {
4053                         if (q3shaders_numshaders >= Q3SHADER_MAXSHADERS)
4054                         {
4055                                 Con_Printf("Mod_Q3BSP_LoadShaders: too many shaders!\n");
4056                                 break;
4057                         }
4058                         shader = q3shaders_shaders + q3shaders_numshaders++;
4059                         memset(shader, 0, sizeof(*shader));
4060                         strlcpy(shader->name, com_token, sizeof(shader->name));
4061                         if (!COM_ParseToken(&text, false) || strcasecmp(com_token, "{"))
4062                         {
4063                                 Con_Printf("%s parsing error - expected \"{\", found \"%s\"\n", search->filenames[fileindex], com_token);
4064                                 break;
4065                         }
4066                         while (COM_ParseToken(&text, false))
4067                         {
4068                                 if (!strcasecmp(com_token, "}"))
4069                                         break;
4070                                 if (!strcasecmp(com_token, "{"))
4071                                 {
4072                                         if (shader->numlayers < Q3SHADER_MAXLAYERS)
4073                                         {
4074                                                 layer = shader->layers + shader->numlayers++;
4075                                                 layer->rgbgenvertex = false;
4076                                                 layer->alphagenvertex = false;
4077                                                 layer->blendfunc[0] = GL_ONE;
4078                                                 layer->blendfunc[1] = GL_ZERO;
4079                                         }
4080                                         else
4081                                                 layer = NULL;
4082                                         while (COM_ParseToken(&text, false))
4083                                         {
4084                                                 if (!strcasecmp(com_token, "}"))
4085                                                         break;
4086                                                 if (!strcasecmp(com_token, "\n"))
4087                                                         continue;
4088                                                 if (layer == NULL)
4089                                                         continue;
4090                                                 numparameters = 0;
4091                                                 for (j = 0;strcasecmp(com_token, "\n") && strcasecmp(com_token, "}");j++)
4092                                                 {
4093                                                         if (j < TEXTURE_MAXFRAMES + 4)
4094                                                         {
4095                                                                 strlcpy(parameter[j], com_token, sizeof(parameter[j]));
4096                                                                 numparameters = j + 1;
4097                                                         }
4098                                                         if (!COM_ParseToken(&text, true))
4099                                                                 break;
4100                                                 }
4101                                                 if (developer.integer >= 100)
4102                                                 {
4103                                                         Con_Printf("%s %i: ", shader->name, shader->numlayers - 1);
4104                                                         for (j = 0;j < numparameters;j++)
4105                                                                 Con_Printf(" %s", parameter[j]);
4106                                                         Con_Print("\n");
4107                                                 }
4108                                                 if (numparameters >= 2 && !strcasecmp(parameter[0], "blendfunc"))
4109                                                 {
4110                                                         if (numparameters == 2)
4111                                                         {
4112                                                                 if (!strcasecmp(parameter[1], "add"))
4113                                                                 {
4114                                                                         layer->blendfunc[0] = GL_ONE;
4115                                                                         layer->blendfunc[1] = GL_ONE;
4116                                                                 }
4117                                                                 else if (!strcasecmp(parameter[1], "filter"))
4118                                                                 {
4119                                                                         layer->blendfunc[0] = GL_DST_COLOR;
4120                                                                         layer->blendfunc[1] = GL_ZERO;
4121                                                                 }
4122                                                                 else if (!strcasecmp(parameter[1], "blend"))
4123                                                                 {
4124                                                                         layer->blendfunc[0] = GL_SRC_ALPHA;
4125                                                                         layer->blendfunc[1] = GL_ONE_MINUS_SRC_ALPHA;
4126                                                                 }
4127                                                         }
4128                                                         else if (numparameters == 3)
4129                                                         {
4130                                                                 int k;
4131                                                                 for (k = 0;k < 2;k++)
4132                                                                 {
4133                                                                         if (!strcasecmp(parameter[k+1], "GL_ONE"))
4134                                                                                 layer->blendfunc[k] = GL_ONE;
4135                                                                         else if (!strcasecmp(parameter[k+1], "GL_ZERO"))
4136                                                                                 layer->blendfunc[k] = GL_ZERO;
4137                                                                         else if (!strcasecmp(parameter[k+1], "GL_SRC_COLOR"))
4138                                                                                 layer->blendfunc[k] = GL_SRC_COLOR;
4139                                                                         else if (!strcasecmp(parameter[k+1], "GL_SRC_ALPHA"))
4140                                                                                 layer->blendfunc[k] = GL_SRC_ALPHA;
4141                                                                         else if (!strcasecmp(parameter[k+1], "GL_DST_COLOR"))
4142                                                                                 layer->blendfunc[k] = GL_DST_COLOR;
4143                                                                         else if (!strcasecmp(parameter[k+1], "GL_DST_ALPHA"))
4144                                                                                 layer->blendfunc[k] = GL_ONE_MINUS_DST_ALPHA;
4145                                                                         else if (!strcasecmp(parameter[k+1], "GL_ONE_MINUS_SRC_COLOR"))
4146                                                                                 layer->blendfunc[k] = GL_ONE_MINUS_SRC_COLOR;
4147                                                                         else if (!strcasecmp(parameter[k+1], "GL_ONE_MINUS_SRC_ALPHA"))
4148                                                                                 layer->blendfunc[k] = GL_ONE_MINUS_SRC_ALPHA;
4149                                                                         else if (!strcasecmp(parameter[k+1], "GL_ONE_MINUS_DST_COLOR"))
4150                                                                                 layer->blendfunc[k] = GL_ONE_MINUS_DST_COLOR;
4151                                                                         else if (!strcasecmp(parameter[k+1], "GL_ONE_MINUS_DST_ALPHA"))
4152                                                                                 layer->blendfunc[k] = GL_ONE_MINUS_DST_ALPHA;
4153                                                                         else
4154                                                                                 layer->blendfunc[k] = GL_ONE; // default in case of parsing error
4155                                                                 }
4156                                                         }
4157                                                 }
4158                                                 if (numparameters >= 2 && !strcasecmp(parameter[0], "alphafunc"))
4159                                                         layer->alphatest = true;
4160                                                 if (numparameters >= 2 && (!strcasecmp(parameter[0], "map") || !strcasecmp(parameter[0], "clampmap")))
4161                                                 {
4162                                                         if (!strcasecmp(parameter[0], "clampmap"))
4163                                                                 layer->clampmap = true;
4164                                                         layer->numframes = 1;
4165                                                         layer->framerate = 1;
4166                                                         strlcpy(layer->texturename[0], parameter[1], sizeof(layer->texturename));
4167                                                         if (!strcasecmp(parameter[1], "$lightmap"))
4168                                                                 shader->lighting = true;
4169                                                 }
4170                                                 else if (numparameters >= 3 && (!strcasecmp(parameter[0], "animmap") || !strcasecmp(parameter[0], "animclampmap")))
4171                                                 {
4172                                                         int i;
4173                                                         layer->numframes = min(numparameters - 2, TEXTURE_MAXFRAMES);
4174                                                         layer->framerate = atof(parameter[1]);
4175                                                         for (i = 0;i < layer->numframes;i++)
4176                                                                 strlcpy(layer->texturename[i], parameter[i + 2], sizeof(layer->texturename));
4177                                                 }
4178                                                 else if (numparameters >= 2 && !strcasecmp(parameter[0], "rgbgen") && !strcasecmp(parameter[1], "vertex"))
4179                                                         layer->rgbgenvertex = true;
4180                                                 else if (numparameters >= 2 && !strcasecmp(parameter[0], "alphagen") && !strcasecmp(parameter[1], "vertex"))
4181                                                         layer->alphagenvertex = true;
4182                                                 // break out a level if it was }
4183                                                 if (!strcasecmp(com_token, "}"))
4184                                                         break;
4185                                         }
4186                                         if (layer->rgbgenvertex)
4187                                                 shader->lighting = true;
4188                                         if (layer->alphagenvertex)
4189                                         {
4190                                                 if (layer == shader->layers + 0)
4191                                                 {
4192                                                         // vertex controlled transparency
4193                                                         shader->vertexalpha = true;
4194                                                 }
4195                                                 else
4196                                                 {
4197                                                         // multilayer terrain shader or similar
4198                                                         shader->textureblendalpha = true;
4199                                                 }
4200                                         }
4201                                         continue;
4202                                 }
4203                                 numparameters = 0;
4204                                 for (j = 0;strcasecmp(com_token, "\n") && strcasecmp(com_token, "}");j++)
4205                                 {
4206                                         if (j < TEXTURE_MAXFRAMES + 4)
4207                                         {
4208                                                 strlcpy(parameter[j], com_token, sizeof(parameter[j]));
4209                                                 numparameters = j + 1;
4210                                         }
4211                                         if (!COM_ParseToken(&text, true))
4212                                                 break;
4213                                 }
4214                                 if (fileindex == 0 && !strcasecmp(com_token, "}"))
4215                                         break;
4216                                 if (developer.integer >= 100)
4217                                 {
4218                                         Con_Printf("%s: ", shader->name);
4219                                         for (j = 0;j < numparameters;j++)
4220                                                 Con_Printf(" %s", parameter[j]);
4221                                         Con_Print("\n");
4222                                 }
4223                                 if (numparameters < 1)
4224                                         continue;
4225                                 if (!strcasecmp(parameter[0], "surfaceparm") && numparameters >= 2)
4226                                 {
4227                                         if (!strcasecmp(parameter[1], "alphashadow"))
4228                                                 shader->surfaceparms |= Q3SURFACEPARM_ALPHASHADOW;
4229                                         else if (!strcasecmp(parameter[1], "areaportal"))
4230                                                 shader->surfaceparms |= Q3SURFACEPARM_AREAPORTAL;
4231                                         else if (!strcasecmp(parameter[1], "botclip"))
4232                                                 shader->surfaceparms |= Q3SURFACEPARM_BOTCLIP;
4233                                         else if (!strcasecmp(parameter[1], "clusterportal"))
4234                                                 shader->surfaceparms |= Q3SURFACEPARM_CLUSTERPORTAL;
4235                                         else if (!strcasecmp(parameter[1], "detail"))
4236                                                 shader->surfaceparms |= Q3SURFACEPARM_DETAIL;
4237                                         else if (!strcasecmp(parameter[1], "donotenter"))
4238                                                 shader->surfaceparms |= Q3SURFACEPARM_DONOTENTER;
4239                                         else if (!strcasecmp(parameter[1], "dust"))
4240                                                 shader->surfaceparms |= Q3SURFACEPARM_DUST;
4241                                         else if (!strcasecmp(parameter[1], "hint"))
4242                                                 shader->surfaceparms |= Q3SURFACEPARM_HINT;
4243                                         else if (!strcasecmp(parameter[1], "fog"))
4244                                                 shader->surfaceparms |= Q3SURFACEPARM_FOG;
4245                                         else if (!strcasecmp(parameter[1], "lava"))
4246                                                 shader->surfaceparms |= Q3SURFACEPARM_LAVA;
4247                                         else if (!strcasecmp(parameter[1], "lightfilter"))
4248                                                 shader->surfaceparms |= Q3SURFACEPARM_LIGHTFILTER;
4249                                         else if (!strcasecmp(parameter[1], "lightgrid"))
4250                                                 shader->surfaceparms |= Q3SURFACEPARM_LIGHTGRID;
4251                                         else if (!strcasecmp(parameter[1], "metalsteps"))
4252                                                 shader->surfaceparms |= Q3SURFACEPARM_METALSTEPS;
4253                                         else if (!strcasecmp(parameter[1], "nodamage"))
4254                                                 shader->surfaceparms |= Q3SURFACEPARM_NODAMAGE;
4255                                         else if (!strcasecmp(parameter[1], "nodlight"))
4256                                                 shader->surfaceparms |= Q3SURFACEPARM_NODLIGHT;
4257                                         else if (!strcasecmp(parameter[1], "nodraw"))
4258                                                 shader->surfaceparms |= Q3SURFACEPARM_NODRAW;
4259                                         else if (!strcasecmp(parameter[1], "nodrop"))
4260                                                 shader->surfaceparms |= Q3SURFACEPARM_NODROP;
4261                                         else if (!strcasecmp(parameter[1], "noimpact"))
4262                                                 shader->surfaceparms |= Q3SURFACEPARM_NOIMPACT;
4263                                         else if (!strcasecmp(parameter[1], "nolightmap"))
4264                                                 shader->surfaceparms |= Q3SURFACEPARM_NOLIGHTMAP;
4265                                         else if (!strcasecmp(parameter[1], "nomarks"))
4266                                                 shader->surfaceparms |= Q3SURFACEPARM_NOMARKS;
4267                                         else if (!strcasecmp(parameter[1], "nomipmaps"))
4268                                                 shader->surfaceparms |= Q3SURFACEPARM_NOMIPMAPS;
4269                                         else if (!strcasecmp(parameter[1], "nonsolid"))
4270                                                 shader->surfaceparms |= Q3SURFACEPARM_NONSOLID;
4271                                         else if (!strcasecmp(parameter[1], "origin"))
4272                                                 shader->surfaceparms |= Q3SURFACEPARM_ORIGIN;
4273                                         else if (!strcasecmp(parameter[1], "playerclip"))
4274                                                 shader->surfaceparms |= Q3SURFACEPARM_PLAYERCLIP;
4275                                         else if (!strcasecmp(parameter[1], "sky"))
4276                                                 shader->surfaceparms |= Q3SURFACEPARM_SKY;
4277                                         else if (!strcasecmp(parameter[1], "slick"))
4278                                                 shader->surfaceparms |= Q3SURFACEPARM_SLICK;
4279                                         else if (!strcasecmp(parameter[1], "slime"))
4280                                                 shader->surfaceparms |= Q3SURFACEPARM_SLIME;
4281                                         else if (!strcasecmp(parameter[1], "structural"))
4282                                                 shader->surfaceparms |= Q3SURFACEPARM_STRUCTURAL;
4283                                         else if (!strcasecmp(parameter[1], "trans"))
4284                                                 shader->surfaceparms |= Q3SURFACEPARM_TRANS;
4285                                         else if (!strcasecmp(parameter[1], "water"))
4286                                                 shader->surfaceparms |= Q3SURFACEPARM_WATER;
4287                                         else if (!strcasecmp(parameter[1], "pointlight"))
4288                                                 shader->surfaceparms |= Q3SURFACEPARM_POINTLIGHT;
4289                                         else if (!strcasecmp(parameter[1], "antiportal"))
4290                                                 shader->surfaceparms |= Q3SURFACEPARM_ANTIPORTAL;
4291                                         else
4292                                                 Con_DPrintf("%s parsing warning: unknown surfaceparm \"%s\"\n", search->filenames[fileindex], parameter[1]);
4293                                 }
4294                                 else if (!strcasecmp(parameter[0], "sky") && numparameters >= 2)
4295                                 {
4296                                         // some q3 skies don't have the sky parm set
4297                                         shader->surfaceparms |= Q3SURFACEPARM_SKY;
4298                                         strlcpy(shader->skyboxname, parameter[1], sizeof(shader->skyboxname));
4299                                 }
4300                                 else if (!strcasecmp(parameter[0], "skyparms") && numparameters >= 2)
4301                                 {
4302                                         // some q3 skies don't have the sky parm set
4303                                         shader->surfaceparms |= Q3SURFACEPARM_SKY;
4304                                         if (!atoi(parameter[1]) && strcasecmp(parameter[1], "-"))
4305                                                 strlcpy(shader->skyboxname, parameter[1], sizeof(shader->skyboxname));
4306                                 }
4307                                 else if (!strcasecmp(parameter[0], "cull") && numparameters >= 2)
4308                                 {
4309                                         if (!strcasecmp(parameter[1], "disable") || !strcasecmp(parameter[1], "none") || !strcasecmp(parameter[1], "twosided"))
4310                                                 shader->textureflags |= Q3TEXTUREFLAG_TWOSIDED;
4311                                 }
4312                                 else if (!strcasecmp(parameter[0], "nomipmaps"))
4313                                         shader->surfaceparms |= Q3SURFACEPARM_NOMIPMAPS;
4314                                 else if (!strcasecmp(parameter[0], "nopicmip"))
4315                                         shader->textureflags |= Q3TEXTUREFLAG_NOPICMIP;
4316                                 else if (!strcasecmp(parameter[0], "deformvertexes") && numparameters >= 2)
4317                                 {
4318                                         if (!strcasecmp(parameter[1], "autosprite") && numparameters == 2)
4319                                                 shader->textureflags |= Q3TEXTUREFLAG_AUTOSPRITE;
4320                                         if (!strcasecmp(parameter[1], "autosprite2") && numparameters == 2)
4321                                                 shader->textureflags |= Q3TEXTUREFLAG_AUTOSPRITE2;
4322                                 }
4323                         }
4324                         // identify if this is a blended terrain shader or similar
4325                         if (shader->numlayers)
4326                         {
4327                                 shader->primarylayer = shader->layers + 0;
4328                                 if ((shader->layers[1].blendfunc[0] == GL_SRC_ALPHA && shader->layers[1].blendfunc[1] == GL_ONE_MINUS_SRC_ALPHA) || shader->layers[1].alphatest)
4329                                 {
4330                                         // terrain blending or other effects
4331                                         shader->backgroundlayer = shader->layers + 0;
4332                                         shader->primarylayer = shader->layers + 1;
4333                                 }
4334                                 // now see if the lightmap came first, and if so choose the second texture instead
4335                                 if (!strcasecmp(shader->primarylayer->texturename[0], "$lightmap"))
4336                                         shader->primarylayer = shader->layers + 1;
4337                         }
4338                 }
4339                 Mem_Free(f);
4340         }
4341 }
4342
4343 q3shaderinfo_t *Mod_Q3BSP_LookupShader(const char *name)
4344 {
4345         int i;
4346         for (i = 0;i < Q3SHADER_MAXSHADERS;i++)
4347                 if (!strcasecmp(q3shaders_shaders[i].name, name))
4348                         return q3shaders_shaders + i;
4349         return NULL;
4350 }
4351
4352 static void Mod_Q3BSP_LoadTextures(lump_t *l)
4353 {
4354         q3dtexture_t *in;
4355         texture_t *out;
4356         int i, count, c;
4357
4358         in = (q3dtexture_t *)(mod_base + l->fileofs);
4359         if (l->filelen % sizeof(*in))
4360                 Host_Error("Mod_Q3BSP_LoadTextures: funny lump size in %s",loadmodel->name);
4361         count = l->filelen / sizeof(*in);
4362         out = (texture_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
4363
4364         loadmodel->data_textures = out;
4365         loadmodel->num_textures = count;
4366
4367         // parse the Q3 shader files
4368         Mod_Q3BSP_LoadShaders();
4369
4370         c = 0;
4371         for (i = 0;i < count;i++, in++, out++)
4372         {
4373                 q3shaderinfo_t *shader;
4374                 strlcpy (out->name, in->name, sizeof (out->name));
4375                 out->surfaceflags = LittleLong(in->surfaceflags);
4376                 out->supercontents = Mod_Q3BSP_SuperContentsFromNativeContents(loadmodel, LittleLong(in->contents));
4377                 shader = Mod_Q3BSP_LookupShader(out->name);
4378                 if (shader)
4379                 {
4380                         out->surfaceparms = shader->surfaceparms;
4381                         out->textureflags = shader->textureflags;
4382                         out->basematerialflags = 0;
4383                         if (shader->surfaceparms & Q3SURFACEPARM_SKY)
4384                         {
4385                                 out->basematerialflags |= MATERIALFLAG_SKY | MATERIALFLAG_NOSHADOW;
4386                                 if (shader->skyboxname[0])
4387                                 {
4388                                         // quake3 seems to append a _ to the skybox name, so this must do so as well
4389                                         dpsnprintf(loadmodel->brush.skybox, sizeof(loadmodel->brush.skybox), "%s_", shader->skyboxname);
4390                                 }
4391                         }
4392                         else if ((out->surfaceflags & Q3SURFACEFLAG_NODRAW) || shader->numlayers == 0)
4393                                 out->basematerialflags |= MATERIALFLAG_NODRAW | MATERIALFLAG_NOSHADOW;
4394                         else if (shader->surfaceparms & Q3SURFACEPARM_LAVA)
4395                                 out->basematerialflags |= MATERIALFLAG_WATER | MATERIALFLAG_LIGHTBOTHSIDES | MATERIALFLAG_FULLBRIGHT | MATERIALFLAG_NOSHADOW;
4396                         else if (shader->surfaceparms & Q3SURFACEPARM_SLIME)
4397                                 out->basematerialflags |= MATERIALFLAG_WATER | MATERIALFLAG_LIGHTBOTHSIDES | MATERIALFLAG_WATERALPHA | MATERIALFLAG_NOSHADOW;
4398                         else if (shader->surfaceparms & Q3SURFACEPARM_WATER)
4399                                 out->basematerialflags |= MATERIALFLAG_WATER | MATERIALFLAG_LIGHTBOTHSIDES | MATERIALFLAG_WATERALPHA | MATERIALFLAG_NOSHADOW;
4400                         else
4401                                 out->basematerialflags |= MATERIALFLAG_WALL;
4402                         if (shader->layers[0].alphatest)
4403                                 out->basematerialflags |= MATERIALFLAG_ALPHATEST | MATERIALFLAG_TRANSPARENT | MATERIALFLAG_NOSHADOW;
4404                         if (shader->textureflags & (Q3TEXTUREFLAG_TWOSIDED | Q3TEXTUREFLAG_AUTOSPRITE | Q3TEXTUREFLAG_AUTOSPRITE2))
4405                                 out->basematerialflags |= MATERIALFLAG_NOSHADOW;
4406                         out->customblendfunc[0] = GL_ONE;
4407                         out->customblendfunc[1] = GL_ZERO;
4408                         if (shader->numlayers > 0)
4409                         {
4410                                 out->customblendfunc[0] = shader->layers[0].blendfunc[0];
4411                                 out->customblendfunc[1] = shader->layers[0].blendfunc[1];
4412 /*
4413 Q3 shader blendfuncs actually used in the game (* = supported by DP)
4414 * additive               GL_ONE GL_ONE
4415   additive weird         GL_ONE GL_SRC_ALPHA
4416   additive weird 2       GL_ONE GL_ONE_MINUS_SRC_ALPHA
4417 * alpha                  GL_SRC_ALPHA GL_ONE_MINUS_SRC_ALPHA
4418   alpha inverse          GL_ONE_MINUS_SRC_ALPHA GL_SRC_ALPHA
4419   brighten               GL_DST_COLOR GL_ONE
4420   brighten               GL_ONE GL_SRC_COLOR
4421   brighten weird         GL_DST_COLOR GL_ONE_MINUS_DST_ALPHA
4422   brighten weird 2       GL_DST_COLOR GL_SRC_ALPHA
4423 * modulate               GL_DST_COLOR GL_ZERO
4424 * modulate               GL_ZERO GL_SRC_COLOR
4425   modulate inverse       GL_ZERO GL_ONE_MINUS_SRC_COLOR
4426   modulate inverse alpha GL_ZERO GL_SRC_ALPHA
4427   modulate weird inverse GL_ONE_MINUS_DST_COLOR GL_ZERO
4428 * modulate x2            GL_DST_COLOR GL_SRC_COLOR
4429 * no blend               GL_ONE GL_ZERO
4430   nothing                GL_ZERO GL_ONE
4431 */
4432                                 // if not opaque, figure out what blendfunc to use
4433                                 if (shader->layers[0].blendfunc[0] != GL_ONE || shader->layers[0].blendfunc[1] != GL_ZERO)
4434                                 {
4435                                         if (shader->layers[0].blendfunc[0] == GL_ONE && shader->layers[0].blendfunc[1] == GL_ONE)
4436                                                 out->basematerialflags |= MATERIALFLAG_ADD | MATERIALFLAG_BLENDED | MATERIALFLAG_TRANSPARENT | MATERIALFLAG_NOSHADOW;
4437                                         else if (shader->layers[0].blendfunc[0] == GL_SRC_ALPHA && shader->layers[0].blendfunc[1] == GL_ONE)
4438                                                 out->basematerialflags |= MATERIALFLAG_ADD | MATERIALFLAG_BLENDED | MATERIALFLAG_TRANSPARENT | MATERIALFLAG_NOSHADOW;
4439                                         else if (shader->layers[0].blendfunc[0] == GL_SRC_ALPHA && shader->layers[0].blendfunc[1] == GL_ONE_MINUS_SRC_ALPHA)
4440                                                 out->basematerialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_TRANSPARENT | MATERIALFLAG_NOSHADOW;
4441                                         else
4442                                                 out->basematerialflags |= MATERIALFLAG_CUSTOMBLEND | MATERIALFLAG_FULLBRIGHT | MATERIALFLAG_BLENDED | MATERIALFLAG_TRANSPARENT | MATERIALFLAG_NOSHADOW;
4443                                 }
4444                         }
4445                         if (!shader->lighting)
4446                                 out->basematerialflags |= MATERIALFLAG_FULLBRIGHT;
4447                         if (shader->primarylayer && cls.state != ca_dedicated)
4448                         {
4449                                 int j;
4450                                 out->numskinframes = shader->primarylayer->numframes;
4451                                 out->skinframerate = shader->primarylayer->framerate;
4452                                 for (j = 0;j < shader->primarylayer->numframes;j++)
4453                                         if (!Mod_LoadSkinFrame(&out->skinframes[j], shader->primarylayer->texturename[j], ((shader->surfaceparms & Q3SURFACEPARM_NOMIPMAPS) ? 0 : TEXF_MIPMAP) | TEXF_ALPHA | TEXF_PRECACHE | (shader->textureflags & Q3TEXTUREFLAG_NOPICMIP ? 0 : TEXF_PICMIP) | (shader->primarylayer->clampmap ? TEXF_CLAMP : 0), false, true))
4454                                                 Con_Printf("%s: could not load texture \"%s\" (frame %i) for shader \"%s\"\n", loadmodel->name, shader->primarylayer->texturename[j], j, out->name);
4455                         }
4456                         if (shader->backgroundlayer && cls.state != ca_dedicated)
4457                         {
4458                                 int j;
4459                                 out->backgroundnumskinframes = shader->backgroundlayer->numframes;
4460                                 out->backgroundskinframerate = shader->backgroundlayer->framerate;
4461                                 for (j = 0;j < shader->backgroundlayer->numframes;j++)
4462                                         if (!Mod_LoadSkinFrame(&out->backgroundskinframes[j], shader->backgroundlayer->texturename[j], ((shader->surfaceparms & Q3SURFACEPARM_NOMIPMAPS) ? 0 : TEXF_MIPMAP) | TEXF_ALPHA | TEXF_PRECACHE | (shader->textureflags & Q3TEXTUREFLAG_NOPICMIP ? 0 : TEXF_PICMIP) | (shader->backgroundlayer->clampmap ? TEXF_CLAMP : 0), false, true))
4463                                                 Con_Printf("%s: could not load texture \"%s\" (frame %i) for shader \"%s\"\n", loadmodel->name, shader->backgroundlayer->texturename[j], j, out->name);
4464                         }
4465                 }
4466                 else if (!strcmp(out->name, "noshader"))
4467                         out->surfaceparms = 0;
4468                 else
4469                 {
4470                         c++;
4471                         Con_DPrintf("%s: No shader found for texture \"%s\"\n", loadmodel->name, out->name);
4472                         out->surfaceparms = 0;
4473                         if (out->surfaceflags & Q3SURFACEFLAG_NODRAW)
4474                                 out->basematerialflags |= MATERIALFLAG_NODRAW | MATERIALFLAG_NOSHADOW;
4475                         else if (out->surfaceflags & Q3SURFACEFLAG_SKY)
4476                                 out->basematerialflags |= MATERIALFLAG_SKY | MATERIALFLAG_NOSHADOW;
4477                         else
4478                                 out->basematerialflags |= MATERIALFLAG_WALL;
4479                         // these are defaults
4480                         //if (!strncmp(out->name, "textures/skies/", 15))
4481                         //      out->surfaceparms |= Q3SURFACEPARM_SKY;
4482                         //if (!strcmp(out->name, "caulk") || !strcmp(out->name, "common/caulk") || !strcmp(out->name, "textures/common/caulk")
4483                         // || !strcmp(out->name, "nodraw") || !strcmp(out->name, "common/nodraw") || !strcmp(out->name, "textures/common/nodraw"))
4484                         //      out->surfaceparms |= Q3SURFACEPARM_NODRAW;
4485                         //if (R_TextureHasAlpha(out->skinframes[0].base))
4486                         //      out->surfaceparms |= Q3SURFACEPARM_TRANS;
4487                         if (cls.state != ca_dedicated)
4488                                 if (!Mod_LoadSkinFrame(&out->skinframes[0], out->name, TEXF_MIPMAP | TEXF_ALPHA | TEXF_PRECACHE | TEXF_PICMIP, false, true))
4489                                         Con_Printf("%s: could not load texture for missing shader \"%s\"\n", loadmodel->name, out->name);
4490                 }
4491                 // init the animation variables
4492                 out->currentframe = out;
4493                 out->currentskinframe = &out->skinframes[0];
4494                 out->backgroundcurrentskinframe = &out->backgroundskinframes[0];
4495         }
4496         if (c)
4497                 Con_DPrintf("%s: %i textures missing shaders\n", loadmodel->name, c);
4498 }
4499
4500 static void Mod_Q3BSP_LoadPlanes(lump_t *l)
4501 {
4502         q3dplane_t *in;
4503         mplane_t *out;
4504         int i, count;
4505
4506         in = (q3dplane_t *)(mod_base + l->fileofs);
4507         if (l->filelen % sizeof(*in))
4508                 Host_Error("Mod_Q3BSP_LoadPlanes: funny lump size in %s",loadmodel->name);
4509         count = l->filelen / sizeof(*in);
4510         out = (mplane_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
4511
4512         loadmodel->brush.data_planes = out;
4513         loadmodel->brush.num_planes = count;
4514
4515         for (i = 0;i < count;i++, in++, out++)
4516         {
4517                 out->normal[0] = LittleFloat(in->normal[0]);
4518                 out->normal[1] = LittleFloat(in->normal[1]);
4519                 out->normal[2] = LittleFloat(in->normal[2]);
4520                 out->dist = LittleFloat(in->dist);
4521                 PlaneClassify(out);
4522         }
4523 }
4524
4525 static void Mod_Q3BSP_LoadBrushSides(lump_t *l)
4526 {
4527         q3dbrushside_t *in;
4528         q3mbrushside_t *out;
4529         int i, n, count;
4530
4531         in = (q3dbrushside_t *)(mod_base + l->fileofs);
4532         if (l->filelen % sizeof(*in))
4533                 Host_Error("Mod_Q3BSP_LoadBrushSides: funny lump size in %s",loadmodel->name);
4534         count = l->filelen / sizeof(*in);
4535         out = (q3mbrushside_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
4536
4537         loadmodel->brush.data_brushsides = out;
4538         loadmodel->brush.num_brushsides = count;
4539
4540         for (i = 0;i < count;i++, in++, out++)
4541         {
4542                 n = LittleLong(in->planeindex);
4543                 if (n < 0 || n >= loadmodel->brush.num_planes)
4544                         Host_Error("Mod_Q3BSP_LoadBrushSides: invalid planeindex %i (%i planes)", n, loadmodel->brush.num_planes);
4545                 out->plane = loadmodel->brush.data_planes + n;
4546                 n = LittleLong(in->textureindex);
4547                 if (n < 0 || n >= loadmodel->num_textures)
4548                         Host_Error("Mod_Q3BSP_LoadBrushSides: invalid textureindex %i (%i textures)", n, loadmodel->num_textures);
4549                 out->texture = loadmodel->data_textures + n;
4550         }
4551 }
4552
4553 static void Mod_Q3BSP_LoadBrushes(lump_t *l)
4554 {
4555         q3dbrush_t *in;
4556         q3mbrush_t *out;
4557         int i, j, n, c, count, maxplanes;
4558         colplanef_t *planes;
4559
4560         in = (q3dbrush_t *)(mod_base + l->fileofs);
4561         if (l->filelen % sizeof(*in))
4562                 Host_Error("Mod_Q3BSP_LoadBrushes: funny lump size in %s",loadmodel->name);
4563         count = l->filelen / sizeof(*in);
4564         out = (q3mbrush_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
4565
4566         loadmodel->brush.data_brushes = out;
4567         loadmodel->brush.num_brushes = count;
4568
4569         maxplanes = 0;
4570         planes = NULL;
4571
4572         for (i = 0;i < count;i++, in++, out++)
4573         {
4574                 n = LittleLong(in->firstbrushside);
4575                 c = LittleLong(in->numbrushsides);
4576                 if (n < 0 || n + c > loadmodel->brush.num_brushsides)
4577                         Host_Error("Mod_Q3BSP_LoadBrushes: invalid brushside range %i : %i (%i brushsides)", n, n + c, loadmodel->brush.num_brushsides);
4578                 out->firstbrushside = loadmodel->brush.data_brushsides + n;
4579                 out->numbrushsides = c;
4580                 n = LittleLong(in->textureindex);
4581                 if (n < 0 || n >= loadmodel->num_textures)
4582                         Host_Error("Mod_Q3BSP_LoadBrushes: invalid textureindex %i (%i textures)", n, loadmodel->num_textures);
4583                 out->texture = loadmodel->data_textures + n;
4584
4585                 // make a list of mplane_t structs to construct a colbrush from
4586                 if (maxplanes < out->numbrushsides)
4587                 {
4588                         maxplanes = out->numbrushsides;
4589                         if (planes)
4590                                 Mem_Free(planes);
4591                         planes = (colplanef_t *)Mem_Alloc(tempmempool, sizeof(colplanef_t) * maxplanes);
4592                 }
4593                 for (j = 0;j < out->numbrushsides;j++)
4594                 {
4595                         VectorCopy(out->firstbrushside[j].plane->normal, planes[j].normal);
4596                         planes[j].dist = out->firstbrushside[j].plane->dist;
4597                         planes[j].q3surfaceflags = out->firstbrushside[j].texture->surfaceflags;
4598                         planes[j].texture = out->firstbrushside[j].texture;
4599                 }
4600                 // make the colbrush from the planes
4601                 out->colbrushf = Collision_NewBrushFromPlanes(loadmodel->mempool, out->numbrushsides, planes, out->texture->supercontents);
4602         }
4603         if (planes)
4604                 Mem_Free(planes);
4605 }
4606
4607 static void Mod_Q3BSP_LoadEffects(lump_t *l)
4608 {
4609         q3deffect_t *in;
4610         q3deffect_t *out;
4611         int i, n, count;
4612
4613         in = (q3deffect_t *)(mod_base + l->fileofs);
4614         if (l->filelen % sizeof(*in))
4615                 Host_Error("Mod_Q3BSP_LoadEffects: funny lump size in %s",loadmodel->name);
4616         count = l->filelen / sizeof(*in);
4617         out = (q3deffect_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
4618
4619         loadmodel->brushq3.data_effects = out;
4620         loadmodel->brushq3.num_effects = count;
4621
4622         for (i = 0;i < count;i++, in++, out++)
4623         {
4624                 strlcpy (out->shadername, in->shadername, sizeof (out->shadername));
4625                 n = LittleLong(in->brushindex);
4626                 if (n >= loadmodel->brush.num_brushes)
4627                 {
4628                         Con_Printf("Mod_Q3BSP_LoadEffects: invalid brushindex %i (%i brushes), setting to -1\n", n, loadmodel->brush.num_brushes);
4629                         n = -1;
4630                 }
4631                 out->brushindex = n;
4632                 out->unknown = LittleLong(in->unknown);
4633         }
4634 }
4635
4636 static void Mod_Q3BSP_LoadVertices(lump_t *l)
4637 {
4638         q3dvertex_t *in;
4639         int i, count;
4640
4641         in = (q3dvertex_t *)(mod_base + l->fileofs);
4642         if (l->filelen % sizeof(*in))
4643                 Host_Error("Mod_Q3BSP_LoadVertices: funny lump size in %s",loadmodel->name);
4644         loadmodel->brushq3.num_vertices = count = l->filelen / sizeof(*in);
4645         loadmodel->brushq3.data_vertex3f = (float *)Mem_Alloc(loadmodel->mempool, count * (sizeof(float) * (3 + 3 + 2 + 2 + 4)));
4646         loadmodel->brushq3.data_normal3f = loadmodel->brushq3.data_vertex3f + count * 3;
4647         loadmodel->brushq3.data_texcoordtexture2f = loadmodel->brushq3.data_normal3f + count * 3;
4648         loadmodel->brushq3.data_texcoordlightmap2f = loadmodel->brushq3.data_texcoordtexture2f + count * 2;
4649         loadmodel->brushq3.data_color4f = loadmodel->brushq3.data_texcoordlightmap2f + count * 2;
4650
4651         for (i = 0;i < count;i++, in++)
4652         {
4653                 loadmodel->brushq3.data_vertex3f[i * 3 + 0] = LittleFloat(in->origin3f[0]);
4654                 loadmodel->brushq3.data_vertex3f[i * 3 + 1] = LittleFloat(in->origin3f[1]);
4655                 loadmodel->brushq3.data_vertex3f[i * 3 + 2] = LittleFloat(in->origin3f[2]);
4656                 loadmodel->brushq3.data_normal3f[i * 3 + 0] = LittleFloat(in->normal3f[0]);
4657                 loadmodel->brushq3.data_normal3f[i * 3 + 1] = LittleFloat(in->normal3f[1]);
4658                 loadmodel->brushq3.data_normal3f[i * 3 + 2] = LittleFloat(in->normal3f[2]);
4659                 loadmodel->brushq3.data_texcoordtexture2f[i * 2 + 0] = LittleFloat(in->texcoord2f[0]);
4660                 loadmodel->brushq3.data_texcoordtexture2f[i * 2 + 1] = LittleFloat(in->texcoord2f[1]);
4661                 loadmodel->brushq3.data_texcoordlightmap2f[i * 2 + 0] = LittleFloat(in->lightmap2f[0]);
4662                 loadmodel->brushq3.data_texcoordlightmap2f[i * 2 + 1] = LittleFloat(in->lightmap2f[1]);
4663                 // svector/tvector are calculated later in face loading
4664                 loadmodel->brushq3.data_color4f[i * 4 + 0] = in->color4ub[0] * (1.0f / 255.0f);
4665                 loadmodel->brushq3.data_color4f[i * 4 + 1] = in->color4ub[1] * (1.0f / 255.0f);
4666                 loadmodel->brushq3.data_color4f[i * 4 + 2] = in->color4ub[2] * (1.0f / 255.0f);
4667                 loadmodel->brushq3.data_color4f[i * 4 + 3] = in->color4ub[3] * (1.0f / 255.0f);
4668         }
4669 }
4670
4671 static void Mod_Q3BSP_LoadTriangles(lump_t *l)
4672 {
4673         int *in;
4674         int *out;
4675         int i, count;
4676
4677         in = (int *)(mod_base + l->fileofs);
4678         if (l->filelen % sizeof(int[3]))
4679                 Host_Error("Mod_Q3BSP_LoadTriangles: funny lump size in %s",loadmodel->name);
4680         count = l->filelen / sizeof(*in);
4681         out = (int *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
4682
4683         loadmodel->brushq3.num_triangles = count / 3;
4684         loadmodel->brushq3.data_element3i = out;
4685
4686         for (i = 0;i < count;i++, in++, out++)
4687         {
4688                 *out = LittleLong(*in);
4689                 if (*out < 0 || *out >= loadmodel->brushq3.num_vertices)
4690                 {
4691                         Con_Printf("Mod_Q3BSP_LoadTriangles: invalid vertexindex %i (%i vertices), setting to 0\n", *out, loadmodel->brushq3.num_vertices);
4692                         *out = 0;
4693                 }
4694         }
4695 }
4696
4697 static void Mod_Q3BSP_LoadLightmaps(lump_t *l)
4698 {
4699         q3dlightmap_t *in;
4700         rtexture_t **out;
4701         int i, count;
4702         unsigned char *c;
4703
4704         if (!l->filelen)
4705                 return;
4706         in = (q3dlightmap_t *)(mod_base + l->fileofs);
4707         if (l->filelen % sizeof(*in))
4708                 Host_Error("Mod_Q3BSP_LoadLightmaps: funny lump size in %s",loadmodel->name);
4709         count = l->filelen / sizeof(*in);
4710         out = (rtexture_t **)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
4711
4712         loadmodel->brushq3.data_lightmaps = out;
4713         loadmodel->brushq3.num_lightmaps = count;
4714
4715         // deluxemapped q3bsp files have an even number of lightmaps, and surfaces
4716         // always index even numbered ones (0, 2, 4, ...), the odd numbered
4717         // lightmaps are the deluxemaps (light direction textures), so if we
4718         // encounter any odd numbered lightmaps it is not a deluxemapped bsp, it
4719         // is also not a deluxemapped bsp if it has an odd number of lightmaps or
4720         // less than 2
4721         loadmodel->brushq3.deluxemapping = true;
4722         loadmodel->brushq3.deluxemapping_modelspace = true;
4723         if (count < 2 || (count & 1))
4724                 loadmodel->brushq3.deluxemapping = false;
4725
4726         // q3map2 sometimes (or always?) makes a second blank lightmap for no
4727         // reason when only one lightmap is used, which can throw off the
4728         // deluxemapping detection method, so check 2-lightmap bsp's specifically
4729         // to see if the second lightmap is blank, if so it is not deluxemapped.
4730         if (count == 2)
4731         {
4732                 c = in[count - 1].rgb;
4733                 for (i = 0;i < 128*128*3;i++)
4734                         if (c[i])
4735                                 break;
4736                 if (i == 128*128*3)
4737                 {
4738                         // all pixels in the unused lightmap were black...
4739                         loadmodel->brushq3.deluxemapping = false;
4740                 }
4741         }
4742
4743         // further deluxemapping detection is done in Mod_Q3BSP_LoadFaces
4744
4745         for (i = 0;i < count;i++, in++, out++)
4746                 *out = R_LoadTexture2D(loadmodel->texturepool, va("lightmap%04i", i), 128, 128, in->rgb, TEXTYPE_RGB, TEXF_FORCELINEAR | TEXF_PRECACHE, NULL);
4747 }
4748
4749 static void Mod_Q3BSP_LoadFaces(lump_t *l)
4750 {
4751         q3dface_t *in, *oldin;
4752         msurface_t *out, *oldout;
4753         int i, oldi, j, n, count, invalidelements, patchsize[2], finalwidth, finalheight, xtess, ytess, finalvertices, finaltriangles, firstvertex, firstelement, type, oldnumtriangles, oldnumtriangles2, meshvertices, meshtriangles, numvertices, numtriangles;
4754         //int *originalelement3i;
4755         //int *originalneighbor3i;
4756         float *originalvertex3f;
4757         //float *originalsvector3f;
4758         //float *originaltvector3f;
4759         float *originalnormal3f;
4760         float *originalcolor4f;
4761         float *originaltexcoordtexture2f;
4762         float *originaltexcoordlightmap2f;
4763         float *v;
4764
4765         in = (q3dface_t *)(mod_base + l->fileofs);
4766         if (l->filelen % sizeof(*in))
4767                 Host_Error("Mod_Q3BSP_LoadFaces: funny lump size in %s",loadmodel->name);
4768         count = l->filelen / sizeof(*in);
4769         out = (msurface_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
4770
4771         loadmodel->data_surfaces = out;
4772         loadmodel->num_surfaces = count;
4773
4774         // now that we have surfaces to look at, see if any of them index an odd numbered lightmap, if so this is not a deluxemapped bsp file
4775         if (loadmodel->brushq3.deluxemapping)
4776         {
4777                 for (i = 0;i < count;i++)
4778                 {
4779                         n = LittleLong(in[i].lightmapindex);
4780                         if (n >= 0 && ((n & 1) || n + 1 >= loadmodel->brushq3.num_lightmaps))
4781                         {
4782                                 loadmodel->brushq3.deluxemapping = false;
4783                                 break;
4784                         }
4785                 }
4786         }
4787         Con_DPrintf("%s is %sdeluxemapped\n", loadmodel->name, loadmodel->brushq3.deluxemapping ? "" : "not ");
4788
4789         i = 0;
4790         oldi = i;
4791         oldin = in;
4792         oldout = out;
4793         meshvertices = 0;
4794         meshtriangles = 0;
4795         for (;i < count;i++, in++, out++)
4796         {
4797                 // check face type first
4798                 type = LittleLong(in->type);
4799                 if (type != Q3FACETYPE_POLYGON
4800                  && type != Q3FACETYPE_PATCH
4801                  && type != Q3FACETYPE_MESH
4802                  && type != Q3FACETYPE_FLARE)
4803                 {
4804                         Con_DPrintf("Mod_Q3BSP_LoadFaces: face #%i: unknown face type %i\n", i, type);
4805                         continue;
4806                 }
4807
4808                 n = LittleLong(in->textureindex);
4809                 if (n < 0 || n >= loadmodel->num_textures)
4810                 {
4811                         Con_DPrintf("Mod_Q3BSP_LoadFaces: face #%i: invalid textureindex %i (%i textures)\n", i, n, loadmodel->num_textures);
4812                         continue;
4813                 }
4814                 out->texture = loadmodel->data_textures + n;
4815                 n = LittleLong(in->effectindex);
4816                 if (n < -1 || n >= loadmodel->brushq3.num_effects)
4817                 {
4818                         if (developer.integer >= 100)
4819                                 Con_Printf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): invalid effectindex %i (%i effects)\n", i, out->texture->name, n, loadmodel->brushq3.num_effects);
4820                         n = -1;
4821                 }
4822                 if (n == -1)
4823                         out->effect = NULL;
4824                 else
4825                         out->effect = loadmodel->brushq3.data_effects + n;
4826                 n = LittleLong(in->lightmapindex);
4827                 if (n >= loadmodel->brushq3.num_lightmaps)
4828                 {
4829                         Con_Printf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): invalid lightmapindex %i (%i lightmaps)\n", i, out->texture->name, n, loadmodel->brushq3.num_lightmaps);
4830                         n = -1;
4831                 }
4832                 else if (n < 0)
4833                         n = -1;
4834                 if (n == -1)
4835                 {
4836                         out->lightmaptexture = NULL;
4837                         out->deluxemaptexture = r_texture_blanknormalmap;
4838                 }
4839                 else
4840                 {
4841                         out->lightmaptexture = loadmodel->brushq3.data_lightmaps[n];
4842                         if (loadmodel->brushq3.deluxemapping)
4843                                 out->deluxemaptexture = loadmodel->brushq3.data_lightmaps[n+1];
4844                         else
4845                                 out->deluxemaptexture = r_texture_blanknormalmap;
4846                 }
4847
4848                 firstvertex = LittleLong(in->firstvertex);
4849                 numvertices = LittleLong(in->numvertices);
4850                 firstelement = LittleLong(in->firstelement);
4851                 numtriangles = LittleLong(in->numelements) / 3;
4852                 if (numtriangles * 3 != LittleLong(in->numelements))
4853                 {
4854                         Con_Printf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): numelements %i is not a multiple of 3\n", i, out->texture->name, LittleLong(in->numelements));
4855                         continue;
4856                 }
4857                 if (firstvertex < 0 || firstvertex + numvertices > loadmodel->brushq3.num_vertices)
4858                 {
4859                         Con_Printf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): invalid vertex range %i : %i (%i vertices)\n", i, out->texture->name, firstvertex, firstvertex + numvertices, loadmodel->brushq3.num_vertices);
4860                         continue;
4861                 }
4862                 if (firstelement < 0 || firstelement + numtriangles * 3 > loadmodel->brushq3.num_triangles * 3)
4863                 {
4864                         Con_Printf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): invalid element range %i : %i (%i elements)\n", i, out->texture->name, firstelement, firstelement + numtriangles * 3, loadmodel->brushq3.num_triangles * 3);
4865                         continue;
4866                 }
4867                 switch(type)
4868                 {
4869                 case Q3FACETYPE_POLYGON:
4870                 case Q3FACETYPE_MESH:
4871                         // no processing necessary
4872                         break;
4873                 case Q3FACETYPE_PATCH:
4874                         patchsize[0] = LittleLong(in->specific.patch.patchsize[0]);
4875                         patchsize[1] = LittleLong(in->specific.patch.patchsize[1]);
4876                         if (numvertices != (patchsize[0] * patchsize[1]) || patchsize[0] < 3 || patchsize[1] < 3 || !(patchsize[0] & 1) || !(patchsize[1] & 1) || patchsize[0] * patchsize[1] >= min(r_subdivisions_maxvertices.integer, r_subdivisions_collision_maxvertices.integer))
4877                         {
4878                                 Con_Printf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): invalid patchsize %ix%i\n", i, out->texture->name, patchsize[0], patchsize[1]);
4879                                 continue;
4880                         }
4881                         originalvertex3f = loadmodel->brushq3.data_vertex3f + firstvertex * 3;
4882                         // convert patch to Q3FACETYPE_MESH
4883                         xtess = Q3PatchTesselationOnX(patchsize[0], patchsize[1], 3, originalvertex3f, r_subdivisions_tolerance.value);
4884                         ytess = Q3PatchTesselationOnY(patchsize[0], patchsize[1], 3, originalvertex3f, r_subdivisions_tolerance.value);
4885                         // bound to user settings
4886                         xtess = bound(r_subdivisions_mintess.integer, xtess, r_subdivisions_maxtess.integer);
4887                         ytess = bound(r_subdivisions_mintess.integer, ytess, r_subdivisions_maxtess.integer);
4888                         // bound to sanity settings
4889                         xtess = bound(1, xtess, 1024);
4890                         ytess = bound(1, ytess, 1024);
4891                         // bound to user limit on vertices
4892                         while ((xtess > 1 || ytess > 1) && (((patchsize[0] - 1) * xtess) + 1) * (((patchsize[1] - 1) * ytess) + 1) > min(r_subdivisions_maxvertices.integer, 262144))
4893                         {
4894                                 if (xtess > ytess)
4895                                         xtess--;
4896                                 else
4897                                         ytess--;
4898                         }
4899                         finalwidth = ((patchsize[0] - 1) * xtess) + 1;
4900                         finalheight = ((patchsize[1] - 1) * ytess) + 1;
4901                         numvertices = finalwidth * finalheight;
4902                         numtriangles = (finalwidth - 1) * (finalheight - 1) * 2;
4903                         break;
4904                 case Q3FACETYPE_FLARE:
4905                         if (developer.integer >= 100)
4906                                 Con_Printf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): Q3FACETYPE_FLARE not supported (yet)\n", i, out->texture->name);
4907                         // don't render it
4908                         continue;
4909                 }
4910                 out->num_vertices = numvertices;
4911                 out->num_triangles = numtriangles;
4912                 meshvertices += out->num_vertices;
4913                 meshtriangles += out->num_triangles;
4914         }
4915
4916         i = oldi;
4917         in = oldin;
4918         out = oldout;
4919         Mod_AllocSurfMesh(loadmodel->mempool, meshvertices, meshtriangles, false, true, false);
4920         meshvertices = 0;
4921         meshtriangles = 0;
4922         for (;i < count && meshvertices + out->num_vertices <= loadmodel->surfmesh.num_vertices;i++, in++, out++)
4923         {
4924                 if (out->num_vertices < 3 || out->num_triangles < 1)
4925                         continue;
4926
4927                 type = LittleLong(in->type);
4928                 firstvertex = LittleLong(in->firstvertex);
4929                 firstelement = LittleLong(in->firstelement);
4930                 out->num_firstvertex = meshvertices;
4931                 out->num_firsttriangle = meshtriangles;
4932                 switch(type)
4933                 {
4934                 case Q3FACETYPE_POLYGON:
4935                 case Q3FACETYPE_MESH:
4936                         // no processing necessary
4937                         for (j = 0;j < out->num_vertices;j++)
4938                         {
4939                                 (loadmodel->surfmesh.data_vertex3f + 3 * out->num_firstvertex)[j * 3 + 0] = loadmodel->brushq3.data_vertex3f[(firstvertex + j) * 3 + 0];
4940                                 (loadmodel->surfmesh.data_vertex3f + 3 * out->num_firstvertex)[j * 3 + 1] = loadmodel->brushq3.data_vertex3f[(firstvertex + j) * 3 + 1];
4941                                 (loadmodel->surfmesh.data_vertex3f + 3 * out->num_firstvertex)[j * 3 + 2] = loadmodel->brushq3.data_vertex3f[(firstvertex + j) * 3 + 2];
4942                                 (loadmodel->surfmesh.data_normal3f + 3 * out->num_firstvertex)[j * 3 + 0] = loadmodel->brushq3.data_normal3f[(firstvertex + j) * 3 + 0];
4943                                 (loadmodel->surfmesh.data_normal3f + 3 * out->num_firstvertex)[j * 3 + 1] = loadmodel->brushq3.data_normal3f[(firstvertex + j) * 3 + 1];
4944                                 (loadmodel->surfmesh.data_normal3f + 3 * out->num_firstvertex)[j * 3 + 2] = loadmodel->brushq3.data_normal3f[(firstvertex + j) * 3 + 2];
4945                                 (loadmodel->surfmesh.data_texcoordtexture2f + 2 * out->num_firstvertex)[j * 2 + 0] = loadmodel->brushq3.data_texcoordtexture2f[(firstvertex + j) * 2 + 0];
4946                                 (loadmodel->surfmesh.data_texcoordtexture2f + 2 * out->num_firstvertex)[j * 2 + 1] = loadmodel->brushq3.data_texcoordtexture2f[(firstvertex + j) * 2 + 1];
4947                                 (loadmodel->surfmesh.data_texcoordlightmap2f + 2 * out->num_firstvertex)[j * 2 + 0] = loadmodel->brushq3.data_texcoordlightmap2f[(firstvertex + j) * 2 + 0];
4948                                 (loadmodel->surfmesh.data_texcoordlightmap2f + 2 * out->num_firstvertex)[j * 2 + 1] = loadmodel->brushq3.data_texcoordlightmap2f[(firstvertex + j) * 2 + 1];
4949                                 (loadmodel->surfmesh.data_lightmapcolor4f + 4 * out->num_firstvertex)[j * 4 + 0] = loadmodel->brushq3.data_color4f[(firstvertex + j) * 4 + 0];
4950                                 (loadmodel->surfmesh.data_lightmapcolor4f + 4 * out->num_firstvertex)[j * 4 + 1] = loadmodel->brushq3.data_color4f[(firstvertex + j) * 4 + 1];
4951                                 (loadmodel->surfmesh.data_lightmapcolor4f + 4 * out->num_firstvertex)[j * 4 + 2] = loadmodel->brushq3.data_color4f[(firstvertex + j) * 4 + 2];
4952                                 (loadmodel->surfmesh.data_lightmapcolor4f + 4 * out->num_firstvertex)[j * 4 + 3] = loadmodel->brushq3.data_color4f[(firstvertex + j) * 4 + 3];
4953                         }
4954                         for (j = 0;j < out->num_triangles*3;j++)
4955                                 (loadmodel->surfmesh.data_element3i + 3 * out->num_firsttriangle)[j] = loadmodel->brushq3.data_element3i[firstelement + j] + out->num_firstvertex;
4956                         break;
4957                 case Q3FACETYPE_PATCH:
4958                         patchsize[0] = LittleLong(in->specific.patch.patchsize[0]);
4959                         patchsize[1] = LittleLong(in->specific.patch.patchsize[1]);
4960                         originalvertex3f = loadmodel->brushq3.data_vertex3f + firstvertex * 3;
4961                         originalnormal3f = loadmodel->brushq3.data_normal3f + firstvertex * 3;
4962                         originaltexcoordtexture2f = loadmodel->brushq3.data_texcoordtexture2f + firstvertex * 2;
4963                         originaltexcoordlightmap2f = loadmodel->brushq3.data_texcoordlightmap2f + firstvertex * 2;
4964                         originalcolor4f = loadmodel->brushq3.data_color4f + firstvertex * 4;
4965                         // convert patch to Q3FACETYPE_MESH
4966                         xtess = Q3PatchTesselationOnX(patchsize[0], patchsize[1], 3, originalvertex3f, r_subdivisions_tolerance.value);
4967                         ytess = Q3PatchTesselationOnY(patchsize[0], patchsize[1], 3, originalvertex3f, r_subdivisions_tolerance.value);
4968                         // bound to user settings
4969                         xtess = bound(r_subdivisions_mintess.integer, xtess, r_subdivisions_maxtess.integer);
4970                         ytess = bound(r_subdivisions_mintess.integer, ytess, r_subdivisions_maxtess.integer);
4971                         // bound to sanity settings
4972                         xtess = bound(1, xtess, 1024);
4973                         ytess = bound(1, ytess, 1024);
4974                         // bound to user limit on vertices
4975                         while ((xtess > 1 || ytess > 1) && (((patchsize[0] - 1) * xtess) + 1) * (((patchsize[1] - 1) * ytess) + 1) > min(r_subdivisions_maxvertices.integer, 262144))
4976                         {
4977                                 if (xtess > ytess)
4978                                         xtess--;
4979                                 else
4980                                         ytess--;
4981                         }
4982                         finalwidth = ((patchsize[0] - 1) * xtess) + 1;
4983                         finalheight = ((patchsize[1] - 1) * ytess) + 1;
4984                         finalvertices = finalwidth * finalheight;
4985                         finaltriangles = (finalwidth - 1) * (finalheight - 1) * 2;
4986                         type = Q3FACETYPE_MESH;
4987                         // generate geometry
4988                         // (note: normals are skipped because they get recalculated)
4989                         Q3PatchTesselateFloat(3, sizeof(float[3]), (loadmodel->surfmesh.data_vertex3f + 3 * out->num_firstvertex), patchsize[0], patchsize[1], sizeof(float[3]), originalvertex3f, xtess, ytess);
4990                         Q3PatchTesselateFloat(3, sizeof(float[3]), (loadmodel->surfmesh.data_normal3f + 3 * out->num_firstvertex), patchsize[0], patchsize[1], sizeof(float[3]), originalnormal3f, xtess, ytess);
4991                         Q3PatchTesselateFloat(2, sizeof(float[2]), (loadmodel->surfmesh.data_texcoordtexture2f + 2 * out->num_firstvertex), patchsize[0], patchsize[1], sizeof(float[2]), originaltexcoordtexture2f, xtess, ytess);
4992                         Q3PatchTesselateFloat(2, sizeof(float[2]), (loadmodel->surfmesh.data_texcoordlightmap2f + 2 * out->num_firstvertex), patchsize[0], patchsize[1], sizeof(float[2]), originaltexcoordlightmap2f, xtess, ytess);
4993                         Q3PatchTesselateFloat(4, sizeof(float[4]), (loadmodel->surfmesh.data_lightmapcolor4f + 4 * out->num_firstvertex), patchsize[0], patchsize[1], sizeof(float[4]), originalcolor4f, xtess, ytess);
4994                         Q3PatchTriangleElements((loadmodel->surfmesh.data_element3i + 3 * out->num_firsttriangle), finalwidth, finalheight, out->num_firstvertex);
4995                         out->num_triangles = Mod_RemoveDegenerateTriangles(out->num_triangles, (loadmodel->surfmesh.data_element3i + 3 * out->num_firsttriangle), (loadmodel->surfmesh.data_element3i + 3 * out->num_firsttriangle), loadmodel->surfmesh.data_vertex3f);
4996                         if (developer.integer >= 100)
4997                         {
4998                                 if (out->num_triangles < finaltriangles)
4999                                         Con_Printf("Mod_Q3BSP_LoadFaces: %ix%i curve subdivided to %i vertices / %i triangles, %i degenerate triangles removed (leaving %i)\n", patchsize[0], patchsize[1], out->num_vertices, finaltriangles, finaltriangles - out->num_triangles, out->num_triangles);
5000                                 else
5001                                         Con_Printf("Mod_Q3BSP_LoadFaces: %ix%i curve subdivided to %i vertices / %i triangles\n", patchsize[0], patchsize[1], out->num_vertices, out->num_triangles);
5002                         }
5003                         // q3map does not put in collision brushes for curves... ugh
5004                         // build the lower quality collision geometry
5005                         xtess = Q3PatchTesselationOnX(patchsize[0], patchsize[1], 3, originalvertex3f, r_subdivisions_collision_tolerance.value);
5006                         ytess = Q3PatchTesselationOnY(patchsize[0], patchsize[1], 3, originalvertex3f, r_subdivisions_collision_tolerance.value);
5007                         // bound to user settings
5008                         xtess = bound(r_subdivisions_collision_mintess.integer, xtess, r_subdivisions_collision_maxtess.integer);
5009                         ytess = bound(r_subdivisions_collision_mintess.integer, ytess, r_subdivisions_collision_maxtess.integer);
5010                         // bound to sanity settings
5011                         xtess = bound(1, xtess, 1024);
5012                         ytess = bound(1, ytess, 1024);
5013                         // bound to user limit on vertices
5014                         while ((xtess > 1 || ytess > 1) && (((patchsize[0] - 1) * xtess) + 1) * (((patchsize[1] - 1) * ytess) + 1) > min(r_subdivisions_collision_maxvertices.integer, 262144))
5015                         {
5016                                 if (xtess > ytess)
5017                                         xtess--;
5018                                 else
5019                                         ytess--;
5020                         }
5021                         finalwidth = ((patchsize[0] - 1) * xtess) + 1;
5022                         finalheight = ((patchsize[1] - 1) * ytess) + 1;
5023                         finalvertices = finalwidth * finalheight;
5024                         finaltriangles = (finalwidth - 1) * (finalheight - 1) * 2;
5025
5026                         out->data_collisionvertex3f = (float *)Mem_Alloc(loadmodel->mempool, sizeof(float[3]) * finalvertices);
5027                         out->data_collisionelement3i = (int *)Mem_Alloc(loadmodel->mempool, sizeof(int[3]) * finaltriangles);
5028                         out->num_collisionvertices = finalvertices;
5029                         out->num_collisiontriangles = finaltriangles;
5030                         Q3PatchTesselateFloat(3, sizeof(float[3]), out->data_collisionvertex3f, patchsize[0], patchsize[1], sizeof(float[3]), originalvertex3f, xtess, ytess);
5031                         Q3PatchTriangleElements(out->data_collisionelement3i, finalwidth, finalheight, 0);
5032
5033                         //Mod_SnapVertices(3, out->num_vertices, (loadmodel->surfmesh.data_vertex3f + 3 * out->num_firstvertex), 0.25);
5034                         Mod_SnapVertices(3, out->num_collisionvertices, out->data_collisionvertex3f, 1);
5035
5036                         oldnumtriangles = out->num_triangles;
5037                         oldnumtriangles2 = out->num_collisiontriangles;
5038                         out->num_collisiontriangles = Mod_RemoveDegenerateTriangles(out->num_collisiontriangles, out->data_collisionelement3i, out->data_collisionelement3i, out->data_collisionvertex3f);
5039                         if (developer.integer >= 100)
5040                                 Con_Printf("Mod_Q3BSP_LoadFaces: %ix%i curve became %i:%i vertices / %i:%i triangles (%i:%i degenerate)\n", patchsize[0], patchsize[1], out->num_vertices, out->num_collisionvertices, oldnumtriangles, oldnumtriangles2, oldnumtriangles - out->num_triangles, oldnumtriangles2 - out->num_collisiontriangles);
5041                         break;
5042                 default:
5043                         break;
5044                 }
5045                 meshvertices += out->num_vertices;
5046                 meshtriangles += out->num_triangles;
5047                 for (j = 0, invalidelements = 0;j < out->num_triangles * 3;j++)
5048                         if ((loadmodel->surfmesh.data_element3i + 3 * out->num_firsttriangle)[j] < out->num_firstvertex || (loadmodel->surfmesh.data_element3i + 3 * out->num_firsttriangle)[j] >= out->num_firstvertex + out->num_vertices)
5049                                 invalidelements++;
5050                 if (invalidelements)
5051                 {
5052                         Con_Printf("Mod_Q3BSP_LoadFaces: Warning: face #%i has %i invalid elements, type = %i, texture->name = \"%s\", texture->surfaceflags = %i, firstvertex = %i, numvertices = %i, firstelement = %i, numelements = %i, elements list:\n", i, invalidelements, type, out->texture->name, out->texture->surfaceflags, firstvertex, out->num_vertices, firstelement, out->num_triangles * 3);
5053                         for (j = 0;j < out->num_triangles * 3;j++)
5054                         {
5055                                 Con_Printf(" %i", (loadmodel->surfmesh.data_element3i + 3 * out->num_firsttriangle)[j] - out->num_firstvertex);
5056                                 if ((loadmodel->surfmesh.data_element3i + 3 * out->num_firsttriangle)[j] < out->num_firstvertex || (loadmodel->surfmesh.data_element3i + 3 * out->num_firsttriangle)[j] >= out->num_firstvertex + out->num_vertices)
5057                                         (loadmodel->surfmesh.data_element3i + 3 * out->num_firsttriangle)[j] = out->num_firstvertex;
5058                         }
5059                         Con_Print("\n");
5060                 }
5061                 // calculate a bounding box
5062                 VectorClear(out->mins);
5063                 VectorClear(out->maxs);
5064                 if (out->num_vertices)
5065                 {
5066                         VectorCopy((loadmodel->surfmesh.data_vertex3f + 3 * out->num_firstvertex), out->mins);
5067                         VectorCopy((loadmodel->surfmesh.data_vertex3f + 3 * out->num_firstvertex), out->maxs);
5068                         for (j = 1, v = (loadmodel->surfmesh.data_vertex3f + 3 * out->num_firstvertex) + 3;j < out->num_vertices;j++, v += 3)
5069                         {
5070                                 out->mins[0] = min(out->mins[0], v[0]);
5071                                 out->maxs[0] = max(out->maxs[0], v[0]);
5072                                 out->mins[1] = min(out->mins[1], v[1]);
5073                                 out->maxs[1] = max(out->maxs[1], v[1]);
5074                                 out->mins[2] = min(out->mins[2], v[2]);
5075                                 out->maxs[2] = max(out->maxs[2], v[2]);
5076                         }
5077                         out->mins[0] -= 1.0f;
5078                         out->mins[1] -= 1.0f;
5079                         out->mins[2] -= 1.0f;
5080                         out->maxs[0] += 1.0f;
5081                         out->maxs[1] += 1.0f;
5082                         out->maxs[2] += 1.0f;
5083                 }
5084                 // set lightmap styles for consistency with q1bsp
5085                 //out->lightmapinfo->styles[0] = 0;
5086                 //out->lightmapinfo->styles[1] = 255;
5087                 //out->lightmapinfo->styles[2] = 255;
5088                 //out->lightmapinfo->styles[3] = 255;
5089         }
5090
5091         // for per pixel lighting
5092         Mod_BuildTextureVectorsFromNormals(0, loadmodel->surfmesh.num_vertices, loadmodel->surfmesh.num_triangles, loadmodel->surfmesh.data_vertex3f, loadmodel->surfmesh.data_texcoordtexture2f, loadmodel->surfmesh.data_normal3f, loadmodel->surfmesh.data_element3i, loadmodel->surfmesh.data_svector3f, loadmodel->surfmesh.data_tvector3f, true);
5093
5094         // free the no longer needed vertex data
5095         loadmodel->brushq3.num_vertices = 0;
5096         if (loadmodel->brushq3.data_vertex3f)
5097                 Mem_Free(loadmodel->brushq3.data_vertex3f);
5098         loadmodel->brushq3.data_vertex3f = NULL;
5099         loadmodel->brushq3.data_normal3f = NULL;
5100         loadmodel->brushq3.data_texcoordtexture2f = NULL;
5101         loadmodel->brushq3.data_texcoordlightmap2f = NULL;
5102         loadmodel->brushq3.data_color4f = NULL;
5103         // free the no longer needed triangle data
5104         loadmodel->brushq3.num_triangles = 0;
5105         if (loadmodel->brushq3.data_element3i)
5106                 Mem_Free(loadmodel->brushq3.data_element3i);
5107         loadmodel->brushq3.data_element3i = NULL;
5108 }
5109
5110 static void Mod_Q3BSP_LoadModels(lump_t *l)
5111 {
5112         q3dmodel_t *in;
5113         q3dmodel_t *out;
5114         int i, j, n, c, count;
5115
5116         in = (q3dmodel_t *)(mod_base + l->fileofs);
5117         if (l->filelen % sizeof(*in))
5118                 Host_Error("Mod_Q3BSP_LoadModels: funny lump size in %s",loadmodel->name);
5119         count = l->filelen / sizeof(*in);
5120         out = (q3dmodel_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
5121
5122         loadmodel->brushq3.data_models = out;
5123         loadmodel->brushq3.num_models = count;
5124
5125         for (i = 0;i < count;i++, in++, out++)
5126         {
5127                 for (j = 0;j < 3;j++)
5128                 {
5129                         out->mins[j] = LittleFloat(in->mins[j]);
5130                         out->maxs[j] = LittleFloat(in->maxs[j]);
5131                 }
5132                 n = LittleLong(in->firstface);
5133                 c = LittleLong(in->numfaces);
5134                 if (n < 0 || n + c > loadmodel->num_surfaces)
5135                         Host_Error("Mod_Q3BSP_LoadModels: invalid face range %i : %i (%i faces)", n, n + c, loadmodel->num_surfaces);
5136                 out->firstface = n;
5137                 out->numfaces = c;
5138                 n = LittleLong(in->firstbrush);
5139                 c = LittleLong(in->numbrushes);
5140                 if (n < 0 || n + c > loadmodel->brush.num_brushes)
5141                         Host_Error("Mod_Q3BSP_LoadModels: invalid brush range %i : %i (%i brushes)", n, n + c, loadmodel->brush.num_brushes);
5142                 out->firstbrush = n;
5143                 out->numbrushes = c;
5144         }
5145 }
5146
5147 static void Mod_Q3BSP_LoadLeafBrushes(lump_t *l)
5148 {
5149         int *in;
5150         int *out;
5151         int i, n, count;
5152
5153         in = (int *)(mod_base + l->fileofs);
5154         if (l->filelen % sizeof(*in))
5155                 Host_Error("Mod_Q3BSP_LoadLeafBrushes: funny lump size in %s",loadmodel->name);
5156         count = l->filelen / sizeof(*in);
5157         out = (int *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
5158
5159         loadmodel->brush.data_leafbrushes = out;
5160         loadmodel->brush.num_leafbrushes = count;
5161
5162         for (i = 0;i < count;i++, in++, out++)
5163         {
5164                 n = LittleLong(*in);
5165                 if (n < 0 || n >= loadmodel->brush.num_brushes)
5166                         Host_Error("Mod_Q3BSP_LoadLeafBrushes: invalid brush index %i (%i brushes)", n, loadmodel->brush.num_brushes);
5167                 *out = n;
5168         }
5169 }
5170
5171 static void Mod_Q3BSP_LoadLeafFaces(lump_t *l)
5172 {
5173         int *in;
5174         int *out;
5175         int i, n, count;
5176
5177         in = (int *)(mod_base + l->fileofs);
5178         if (l->filelen % sizeof(*in))
5179                 Host_Error("Mod_Q3BSP_LoadLeafFaces: funny lump size in %s",loadmodel->name);
5180         count = l->filelen / sizeof(*in);
5181         out = (int *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
5182
5183         loadmodel->brush.data_leafsurfaces = out;
5184         loadmodel->brush.num_leafsurfaces = count;
5185
5186         for (i = 0;i < count;i++, in++, out++)
5187         {
5188                 n = LittleLong(*in);
5189                 if (n < 0 || n >= loadmodel->num_surfaces)
5190                         Host_Error("Mod_Q3BSP_LoadLeafFaces: invalid face index %i (%i faces)", n, loadmodel->num_surfaces);
5191                 *out = n;
5192         }
5193 }
5194
5195 static void Mod_Q3BSP_LoadLeafs(lump_t *l)
5196 {
5197         q3dleaf_t *in;
5198         mleaf_t *out;
5199         int i, j, n, c, count;
5200
5201         in = (q3dleaf_t *)(mod_base + l->fileofs);
5202         if (l->filelen % sizeof(*in))
5203                 Host_Error("Mod_Q3BSP_LoadLeafs: funny lump size in %s",loadmodel->name);
5204         count = l->filelen / sizeof(*in);
5205         out = (mleaf_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
5206
5207         loadmodel->brush.data_leafs = out;
5208         loadmodel->brush.num_leafs = count;
5209
5210         for (i = 0;i < count;i++, in++, out++)
5211         {
5212                 out->parent = NULL;
5213                 out->plane = NULL;
5214                 out->clusterindex = LittleLong(in->clusterindex);
5215                 out->areaindex = LittleLong(in->areaindex);
5216                 for (j = 0;j < 3;j++)
5217                 {
5218                         // yes the mins/maxs are ints
5219                         out->mins[j] = LittleLong(in->mins[j]) - 1;
5220                         out->maxs[j] = LittleLong(in->maxs[j]) + 1;
5221                 }
5222                 n = LittleLong(in->firstleafface);
5223                 c = LittleLong(in->numleaffaces);
5224                 if (n < 0 || n + c > loadmodel->brush.num_leafsurfaces)
5225                         Host_Error("Mod_Q3BSP_LoadLeafs: invalid leafsurface range %i : %i (%i leafsurfaces)", n, n + c, loadmodel->brush.num_leafsurfaces);
5226                 out->firstleafsurface = loadmodel->brush.data_leafsurfaces + n;
5227                 out->numleafsurfaces = c;
5228                 n = LittleLong(in->firstleafbrush);
5229                 c = LittleLong(in->numleafbrushes);
5230                 if (n < 0 || n + c > loadmodel->brush.num_leafbrushes)
5231                         Host_Error("Mod_Q3BSP_LoadLeafs: invalid leafbrush range %i : %i (%i leafbrushes)", n, n + c, loadmodel->brush.num_leafbrushes);
5232                 out->firstleafbrush = loadmodel->brush.data_leafbrushes + n;
5233                 out->numleafbrushes = c;
5234         }
5235 }
5236
5237 static void Mod_Q3BSP_LoadNodes(lump_t *l)
5238 {
5239         q3dnode_t *in;
5240         mnode_t *out;
5241         int i, j, n, count;
5242
5243         in = (q3dnode_t *)(mod_base + l->fileofs);
5244         if (l->filelen % sizeof(*in))
5245                 Host_Error("Mod_Q3BSP_LoadNodes: funny lump size in %s",loadmodel->name);
5246         count = l->filelen / sizeof(*in);
5247         out = (mnode_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
5248
5249         loadmodel->brush.data_nodes = out;
5250         loadmodel->brush.num_nodes = count;
5251
5252         for (i = 0;i < count;i++, in++, out++)
5253         {
5254                 out->parent = NULL;
5255                 n = LittleLong(in->planeindex);
5256                 if (n < 0 || n >= loadmodel->brush.num_planes)
5257                         Host_Error("Mod_Q3BSP_LoadNodes: invalid planeindex %i (%i planes)", n, loadmodel->brush.num_planes);
5258                 out->plane = loadmodel->brush.data_planes + n;
5259                 for (j = 0;j < 2;j++)
5260                 {
5261                         n = LittleLong(in->childrenindex[j]);
5262                         if (n >= 0)
5263                         {
5264                                 if (n >= loadmodel->brush.num_nodes)
5265                                         Host_Error("Mod_Q3BSP_LoadNodes: invalid child node index %i (%i nodes)", n, loadmodel->brush.num_nodes);
5266                                 out->children[j] = loadmodel->brush.data_nodes + n;
5267                         }
5268                         else
5269                         {
5270                                 n = -1 - n;
5271                                 if (n >= loadmodel->brush.num_leafs)
5272                                         Host_Error("Mod_Q3BSP_LoadNodes: invalid child leaf index %i (%i leafs)", n, loadmodel->brush.num_leafs);
5273                                 out->children[j] = (mnode_t *)(loadmodel->brush.data_leafs + n);
5274                         }
5275                 }
5276                 for (j = 0;j < 3;j++)
5277                 {
5278                         // yes the mins/maxs are ints
5279                         out->mins[j] = LittleLong(in->mins[j]) - 1;
5280                         out->maxs[j] = LittleLong(in->maxs[j]) + 1;
5281                 }
5282         }
5283
5284         // set the parent pointers
5285         Mod_Q1BSP_LoadNodes_RecursiveSetParent(loadmodel->brush.data_nodes, NULL);
5286 }
5287
5288 static void Mod_Q3BSP_LoadLightGrid(lump_t *l)
5289 {
5290         q3dlightgrid_t *in;
5291         q3dlightgrid_t *out;
5292         int count;
5293
5294         in = (q3dlightgrid_t *)(mod_base + l->fileofs);
5295         if (l->filelen % sizeof(*in))
5296                 Host_Error("Mod_Q3BSP_LoadLightGrid: funny lump size in %s",loadmodel->name);
5297         loadmodel->brushq3.num_lightgrid_scale[0] = 1.0f / loadmodel->brushq3.num_lightgrid_cellsize[0];
5298         loadmodel->brushq3.num_lightgrid_scale[1] = 1.0f / loadmodel->brushq3.num_lightgrid_cellsize[1];
5299         loadmodel->brushq3.num_lightgrid_scale[2] = 1.0f / loadmodel->brushq3.num_lightgrid_cellsize[2];
5300         loadmodel->brushq3.num_lightgrid_imins[0] = (int)ceil(loadmodel->brushq3.data_models->mins[0] * loadmodel->brushq3.num_lightgrid_scale[0]);
5301         loadmodel->brushq3.num_lightgrid_imins[1] = (int)ceil(loadmodel->brushq3.data_models->mins[1] * loadmodel->brushq3.num_lightgrid_scale[1]);
5302         loadmodel->brushq3.num_lightgrid_imins[2] = (int)ceil(loadmodel->brushq3.data_models->mins[2] * loadmodel->brushq3.num_lightgrid_scale[2]);
5303         loadmodel->brushq3.num_lightgrid_imaxs[0] = (int)floor(loadmodel->brushq3.data_models->maxs[0] * loadmodel->brushq3.num_lightgrid_scale[0]);
5304         loadmodel->brushq3.num_lightgrid_imaxs[1] = (int)floor(loadmodel->brushq3.data_models->maxs[1] * loadmodel->brushq3.num_lightgrid_scale[1]);
5305         loadmodel->brushq3.num_lightgrid_imaxs[2] = (int)floor(loadmodel->brushq3.data_models->maxs[2] * loadmodel->brushq3.num_lightgrid_scale[2]);
5306         loadmodel->brushq3.num_lightgrid_isize[0] = loadmodel->brushq3.num_lightgrid_imaxs[0] - loadmodel->brushq3.num_lightgrid_imins[0] + 1;
5307         loadmodel->brushq3.num_lightgrid_isize[1] = loadmodel->brushq3.num_lightgrid_imaxs[1] - loadmodel->brushq3.num_lightgrid_imins[1] + 1;
5308         loadmodel->brushq3.num_lightgrid_isize[2] = loadmodel->brushq3.num_lightgrid_imaxs[2] - loadmodel->brushq3.num_lightgrid_imins[2] + 1;
5309         count = loadmodel->brushq3.num_lightgrid_isize[0] * loadmodel->brushq3.num_lightgrid_isize[1] * loadmodel->brushq3.num_lightgrid_isize[2];
5310         Matrix4x4_CreateScale3(&loadmodel->brushq3.num_lightgrid_indexfromworld, loadmodel->brushq3.num_lightgrid_scale[0], loadmodel->brushq3.num_lightgrid_scale[1], loadmodel->brushq3.num_lightgrid_scale[2]);
5311         Matrix4x4_ConcatTranslate(&loadmodel->brushq3.num_lightgrid_indexfromworld, -loadmodel->brushq3.num_lightgrid_imins[0] * loadmodel->brushq3.num_lightgrid_cellsize[0], -loadmodel->brushq3.num_lightgrid_imins[1] * loadmodel->brushq3.num_lightgrid_cellsize[1], -loadmodel->brushq3.num_lightgrid_imins[2] * loadmodel->brushq3.num_lightgrid_cellsize[2]);
5312
5313         // if lump is empty there is nothing to load, we can deal with that in the LightPoint code
5314         if (l->filelen)
5315         {
5316                 if (l->filelen < count * (int)sizeof(*in))
5317                         Host_Error("Mod_Q3BSP_LoadLightGrid: invalid lightgrid lump size %i bytes, should be %i bytes (%ix%ix%i)", l->filelen, (int)(count * sizeof(*in)), loadmodel->brushq3.num_lightgrid_dimensions[0], loadmodel->brushq3.num_lightgrid_dimensions[1], loadmodel->brushq3.num_lightgrid_dimensions[2]);
5318                 if (l->filelen != count * (int)sizeof(*in))
5319                         Con_Printf("Mod_Q3BSP_LoadLightGrid: Warning: calculated lightgrid size %i bytes does not match lump size %i\n", (int)(count * sizeof(*in)), l->filelen);
5320                 out = (q3dlightgrid_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
5321                 loadmodel->brushq3.data_lightgrid = out;
5322                 loadmodel->brushq3.num_lightgrid = count;
5323                 // no swapping or validation necessary
5324                 memcpy(out, in, count * (int)sizeof(*out));
5325         }
5326 }
5327
5328 static void Mod_Q3BSP_LoadPVS(lump_t *l)
5329 {
5330         q3dpvs_t *in;
5331         int totalchains;
5332
5333         if (l->filelen == 0)
5334         {
5335                 int i;
5336                 // unvised maps often have cluster indices even without pvs, so check
5337                 // leafs to find real number of clusters
5338                 loadmodel->brush.num_pvsclusters = 1;
5339                 for (i = 0;i < loadmodel->brush.num_leafs;i++)
5340                         loadmodel->brush.num_pvsclusters = max(loadmodel->brush.num_pvsclusters, loadmodel->brush.data_leafs[i].clusterindex + 1);
5341
5342                 // create clusters
5343                 loadmodel->brush.num_pvsclusterbytes = (loadmodel->brush.num_pvsclusters + 7) / 8;
5344                 totalchains = loadmodel->brush.num_pvsclusterbytes * loadmodel->brush.num_pvsclusters;
5345                 loadmodel->brush.data_pvsclusters = (unsigned char *)Mem_Alloc(loadmodel->mempool, totalchains);
5346                 memset(loadmodel->brush.data_pvsclusters, 0xFF, totalchains);
5347                 return;
5348         }
5349
5350         in = (q3dpvs_t *)(mod_base + l->fileofs);
5351         if (l->filelen < 9)
5352                 Host_Error("Mod_Q3BSP_LoadPVS: funny lump size in %s",loadmodel->name);
5353
5354         loadmodel->brush.num_pvsclusters = LittleLong(in->numclusters);
5355         loadmodel->brush.num_pvsclusterbytes = LittleLong(in->chainlength);
5356         if (loadmodel->brush.num_pvsclusterbytes < ((loadmodel->brush.num_pvsclusters + 7) / 8))
5357                 Host_Error("Mod_Q3BSP_LoadPVS: (chainlength = %i) < ((numclusters = %i) + 7) / 8", loadmodel->brush.num_pvsclusterbytes, loadmodel->brush.num_pvsclusters);
5358         totalchains = loadmodel->brush.num_pvsclusterbytes * loadmodel->brush.num_pvsclusters;
5359         if (l->filelen < totalchains + (int)sizeof(*in))
5360                 Host_Error("Mod_Q3BSP_LoadPVS: lump too small ((numclusters = %i) * (chainlength = %i) + sizeof(q3dpvs_t) == %i bytes, lump is %i bytes)", loadmodel->brush.num_pvsclusters, loadmodel->brush.num_pvsclusterbytes, (int)(totalchains + sizeof(*in)), l->filelen);
5361
5362         loadmodel->brush.data_pvsclusters = (unsigned char *)Mem_Alloc(loadmodel->mempool, totalchains);
5363         memcpy(loadmodel->brush.data_pvsclusters, (unsigned char *)(in + 1), totalchains);
5364 }
5365
5366 static void Mod_Q3BSP_LightPoint(model_t *model, const vec3_t p, vec3_t ambientcolor, vec3_t diffusecolor, vec3_t diffusenormal)
5367 {
5368         int i, j, k, index[3];
5369         float transformed[3], blend1, blend2, blend, yaw, pitch, sinpitch, stylescale;
5370         q3dlightgrid_t *a, *s;
5371
5372         // scale lighting by lightstyle[0] so that darkmode in dpmod works properly
5373         stylescale = r_refdef.lightstylevalue[0] * (1.0f / 264.0f);
5374
5375         if (!model->brushq3.num_lightgrid)
5376         {
5377                 ambientcolor[0] = stylescale;
5378                 ambientcolor[1] = stylescale;
5379                 ambientcolor[2] = stylescale;
5380                 return;
5381         }
5382
5383         Matrix4x4_Transform(&model->brushq3.num_lightgrid_indexfromworld, p, transformed);
5384         //Matrix4x4_Print(&model->brushq3.num_lightgrid_indexfromworld);
5385         //Con_Printf("%f %f %f transformed %f %f %f clamped ", p[0], p[1], p[2], transformed[0], transformed[1], transformed[2]);
5386         transformed[0] = bound(0, transformed[0], model->brushq3.num_lightgrid_isize[0] - 1);
5387         transformed[1] = bound(0, transformed[1], model->brushq3.num_lightgrid_isize[1] - 1);
5388         transformed[2] = bound(0, transformed[2], model->brushq3.num_lightgrid_isize[2] - 1);
5389         index[0] = (int)floor(transformed[0]);
5390         index[1] = (int)floor(transformed[1]);
5391         index[2] = (int)floor(transformed[2]);
5392         //Con_Printf("%f %f %f index %i %i %i:\n", transformed[0], transformed[1], transformed[2], index[0], index[1], index[2]);
5393
5394         // now lerp the values
5395         VectorClear(diffusenormal);
5396         a = &model->brushq3.data_lightgrid[(index[2] * model->brushq3.num_lightgrid_isize[1] + index[1]) * model->brushq3.num_lightgrid_isize[0] + index[0]];
5397         for (k = 0;k < 2;k++)
5398         {
5399                 blend1 = (k ? (transformed[2] - index[2]) : (1 - (transformed[2] - index[2])));
5400                 if (blend1 < 0.001f || index[2] + k >= model->brushq3.num_lightgrid_isize[2])
5401                         continue;
5402                 for (j = 0;j < 2;j++)
5403                 {
5404                         blend2 = blend1 * (j ? (transformed[1] - index[1]) : (1 - (transformed[1] - index[1])));
5405                         if (blend2 < 0.001f || index[1] + j >= model->brushq3.num_lightgrid_isize[1])
5406                                 continue;
5407                         for (i = 0;i < 2;i++)
5408                         {
5409                                 blend = blend2 * (i ? (transformed[0] - index[0]) : (1 - (transformed[0] - index[0]))) * stylescale;
5410                                 if (blend < 0.001f || index[0] + i >= model->brushq3.num_lightgrid_isize[0])
5411                                         continue;
5412                                 s = a + (k * model->brushq3.num_lightgrid_isize[1] + j) * model->brushq3.num_lightgrid_isize[0] + i;
5413                                 VectorMA(ambientcolor, blend * (1.0f / 128.0f), s->ambientrgb, ambientcolor);
5414                                 VectorMA(diffusecolor, blend * (1.0f / 128.0f), s->diffusergb, diffusecolor);
5415                                 pitch = s->diffusepitch * M_PI / 128;
5416                                 yaw = s->diffuseyaw * M_PI / 128;
5417                                 sinpitch = sin(pitch);
5418                                 diffusenormal[0] += blend * (cos(yaw) * sinpitch);
5419                                 diffusenormal[1] += blend * (sin(yaw) * sinpitch);
5420                                 diffusenormal[2] += blend * (cos(pitch));
5421                                 //Con_Printf("blend %f: ambient %i %i %i, diffuse %i %i %i, diffusepitch %i diffuseyaw %i (%f %f, normal %f %f %f)\n", blend, s->ambientrgb[0], s->ambientrgb[1], s->ambientrgb[2], s->diffusergb[0], s->diffusergb[1], s->diffusergb[2], s->diffusepitch, s->diffuseyaw, pitch, yaw, (cos(yaw) * cospitch), (sin(yaw) * cospitch), (-sin(pitch)));
5422                         }
5423                 }
5424         }
5425
5426         // normalize the light direction before turning
5427         VectorNormalize(diffusenormal);
5428         //Con_Printf("result: ambient %f %f %f diffuse %f %f %f diffusenormal %f %f %f\n", ambientcolor[0], ambientcolor[1], ambientcolor[2], diffusecolor[0], diffusecolor[1], diffusecolor[2], diffusenormal[0], diffusenormal[1], diffusenormal[2]);
5429 }
5430
5431 static void Mod_Q3BSP_TracePoint_RecursiveBSPNode(trace_t *trace, model_t *model, mnode_t *node, const vec3_t point, int markframe)
5432 {
5433         int i;
5434         mleaf_t *leaf;
5435         colbrushf_t *brush;
5436         // find which leaf the point is in
5437         while (node->plane)
5438                 node = node->children[DotProduct(point, node->plane->normal) < node->plane->dist];
5439         // point trace the brushes
5440         leaf = (mleaf_t *)node;
5441         for (i = 0;i < leaf->numleafbrushes;i++)
5442         {
5443                 brush = model->brush.data_brushes[leaf->firstleafbrush[i]].colbrushf;
5444                 if (brush && brush->markframe != markframe && BoxesOverlap(point, point, brush->mins, brush->maxs))
5445                 {
5446                         brush->markframe = markframe;
5447                         Collision_TracePointBrushFloat(trace, point, brush);
5448                 }
5449         }
5450         // can't do point traces on curves (they have no thickness)
5451 }
5452
5453 static void Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace_t *trace, model_t *model, mnode_t *node, const vec3_t start, const vec3_t end, vec_t startfrac, vec_t endfrac, const vec3_t linestart, const vec3_t lineend, int markframe, const vec3_t segmentmins, const vec3_t segmentmaxs)
5454 {
5455         int i, startside, endside;
5456         float dist1, dist2, midfrac, mid[3], nodesegmentmins[3], nodesegmentmaxs[3];
5457         mleaf_t *leaf;
5458         msurface_t *surface;
5459         mplane_t *plane;
5460         colbrushf_t *brush;
5461         // walk the tree until we hit a leaf, recursing for any split cases
5462         while (node->plane)
5463         {
5464                 // abort if this part of the bsp tree can not be hit by this trace
5465 //              if (!(node->combinedsupercontents & trace->hitsupercontentsmask))
5466 //                      return;
5467                 plane = node->plane;
5468                 // axial planes are much more common than non-axial, so an optimized
5469                 // axial case pays off here
5470                 if (plane->type < 3)
5471                 {
5472                         dist1 = start[plane->type] - plane->dist;
5473                         dist2 = end[plane->type] - plane->dist;
5474                 }
5475                 else
5476                 {
5477                         dist1 = DotProduct(start, plane->normal) - plane->dist;
5478                         dist2 = DotProduct(end, plane->normal) - plane->dist;
5479                 }
5480                 startside = dist1 < 0;
5481                 endside = dist2 < 0;
5482                 if (startside == endside)
5483                 {
5484                         // most of the time the line fragment is on one side of the plane
5485                         node = node->children[startside];
5486                 }
5487                 else
5488                 {
5489                         // line crosses node plane, split the line
5490                         dist1 = PlaneDiff(linestart, plane);
5491                         dist2 = PlaneDiff(lineend, plane);
5492                         midfrac = dist1 / (dist1 - dist2);
5493                         VectorLerp(linestart, midfrac, lineend, mid);
5494                         // take the near side first
5495                         Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace, model, node->children[startside], start, mid, startfrac, midfrac, linestart, lineend, markframe, segmentmins, segmentmaxs);
5496                         // if we found an impact on the front side, don't waste time
5497                         // exploring the far side
5498                         if (midfrac <= trace->realfraction)
5499                                 Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace, model, node->children[endside], mid, end, midfrac, endfrac, linestart, lineend, markframe, segmentmins, segmentmaxs);
5500                         return;
5501                 }
5502         }
5503         // abort if this part of the bsp tree can not be hit by this trace
5504 //      if (!(node->combinedsupercontents & trace->hitsupercontentsmask))
5505 //              return;
5506         // hit a leaf
5507         nodesegmentmins[0] = min(start[0], end[0]) - 1;
5508         nodesegmentmins[1] = min(start[1], end[1]) - 1;
5509         nodesegmentmins[2] = min(start[2], end[2]) - 1;
5510         nodesegmentmaxs[0] = max(start[0], end[0]) + 1;
5511         nodesegmentmaxs[1] = max(start[1], end[1]) + 1;
5512         nodesegmentmaxs[2] = max(start[2], end[2]) + 1;
5513         // line trace the brushes
5514         leaf = (mleaf_t *)node;
5515         for (i = 0;i < leaf->numleafbrushes;i++)
5516         {
5517                 brush = model->brush.data_brushes[leaf->firstleafbrush[i]].colbrushf;
5518                 if (brush && brush->markframe != markframe && BoxesOverlap(nodesegmentmins, nodesegmentmaxs, brush->mins, brush->maxs))
5519                 {
5520                         brush->markframe = markframe;
5521                         Collision_TraceLineBrushFloat(trace, linestart, lineend, brush, brush);
5522                 }
5523         }
5524         // can't do point traces on curves (they have no thickness)
5525         if (leaf->containscollisionsurfaces && mod_q3bsp_curves_collisions.integer && !VectorCompare(start, end))
5526         {
5527                 // line trace the curves
5528                 for (i = 0;i < leaf->numleafsurfaces;i++)
5529                 {
5530                         surface = model->data_surfaces + leaf->firstleafsurface[i];
5531                         if (surface->num_collisiontriangles && surface->collisionmarkframe != markframe && BoxesOverlap(nodesegmentmins, nodesegmentmaxs, surface->mins, surface->maxs))
5532                         {
5533                                 surface->collisionmarkframe = markframe;
5534                                 Collision_TraceLineTriangleMeshFloat(trace, linestart, lineend, surface->num_collisiontriangles, surface->data_collisionelement3i, surface->data_collisionvertex3f, surface->texture->supercontents, surface->texture->surfaceflags, surface->texture, segmentmins, segmentmaxs);
5535                         }
5536                 }
5537         }
5538 }
5539
5540 static void Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace_t *trace, model_t *model, mnode_t *node, const colbrushf_t *thisbrush_start, const colbrushf_t *thisbrush_end, int markframe, const vec3_t segmentmins, const vec3_t segmentmaxs)
5541 {
5542         int i;
5543         int sides;
5544         mleaf_t *leaf;
5545         colbrushf_t *brush;
5546         msurface_t *surface;
5547         mplane_t *plane;
5548         float nodesegmentmins[3], nodesegmentmaxs[3];
5549         // walk the tree until we hit a leaf, recursing for any split cases
5550         while (node->plane)
5551         {
5552                 // abort if this part of the bsp tree can not be hit by this trace
5553 //              if (!(node->combinedsupercontents & trace->hitsupercontentsmask))
5554 //                      return;
5555                 plane = node->plane;
5556                 // axial planes are much more common than non-axial, so an optimized
5557                 // axial case pays off here
5558                 if (plane->type < 3)
5559                 {
5560                         // this is an axial plane, compare bounding box directly to it and
5561                         // recurse sides accordingly
5562                         // recurse down node sides
5563                         // use an inlined axial BoxOnPlaneSide to slightly reduce overhead
5564                         //sides = BoxOnPlaneSide(nodesegmentmins, nodesegmentmaxs, plane);
5565                         //sides = ((segmentmaxs[plane->type] >= plane->dist) | ((segmentmins[plane->type] < plane->dist) << 1));
5566                         sides = ((segmentmaxs[plane->type] >= plane->dist) + ((segmentmins[plane->type] < plane->dist) * 2));
5567                 }
5568                 else
5569                 {
5570                         // this is a non-axial plane, so check if the start and end boxes
5571                         // are both on one side of the plane to handle 'diagonal' cases
5572                         sides = BoxOnPlaneSide(thisbrush_start->mins, thisbrush_start->maxs, plane) | BoxOnPlaneSide(thisbrush_end->mins, thisbrush_end->maxs, plane);
5573                 }
5574                 if (sides == 3)
5575                 {
5576                         // segment crosses plane
5577                         Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, model, node->children[0], thisbrush_start, thisbrush_end, markframe, segmentmins, segmentmaxs);
5578                         sides = 2;
5579                 }
5580                 // if sides == 0 then the trace itself is bogus (Not A Number values),
5581                 // in this case we simply pretend the trace hit nothing
5582                 if (sides == 0)
5583                         return; // ERROR: NAN bounding box!
5584                 // take whichever side the segment box is on
5585                 node = node->children[sides - 1];
5586         }
5587         // abort if this part of the bsp tree can not be hit by this trace
5588 //      if (!(node->combinedsupercontents & trace->hitsupercontentsmask))
5589 //              return;
5590         nodesegmentmins[0] = max(segmentmins[0], node->mins[0] - 1);
5591         nodesegmentmins[1] = max(segmentmins[1], node->mins[1] - 1);
5592         nodesegmentmins[2] = max(segmentmins[2], node->mins[2] - 1);
5593         nodesegmentmaxs[0] = min(segmentmaxs[0], node->maxs[0] + 1);
5594         nodesegmentmaxs[1] = min(segmentmaxs[1], node->maxs[1] + 1);
5595         nodesegmentmaxs[2] = min(segmentmaxs[2], node->maxs[2] + 1);
5596         // hit a leaf
5597         leaf = (mleaf_t *)node;
5598         for (i = 0;i < leaf->numleafbrushes;i++)
5599         {
5600                 brush = model->brush.data_brushes[leaf->firstleafbrush[i]].colbrushf;
5601                 if (brush && brush->markframe != markframe && BoxesOverlap(nodesegmentmins, nodesegmentmaxs, brush->mins, brush->maxs))
5602                 {
5603                         brush->markframe = markframe;
5604                         Collision_TraceBrushBrushFloat(trace, thisbrush_start, thisbrush_end, brush, brush);
5605                 }
5606         }
5607         if (leaf->containscollisionsurfaces && mod_q3bsp_curves_collisions.integer)
5608         {
5609                 for (i = 0;i < leaf->numleafsurfaces;i++)
5610                 {
5611                         surface = model->data_surfaces + leaf->firstleafsurface[i];
5612                         if (surface->num_collisiontriangles && surface->collisionmarkframe != markframe && BoxesOverlap(nodesegmentmins, nodesegmentmaxs, surface->mins, surface->maxs))
5613                         {
5614                                 surface->collisionmarkframe = markframe;
5615                                 Collision_TraceBrushTriangleMeshFloat(trace, thisbrush_start, thisbrush_end, surface->num_collisiontriangles, surface->data_collisionelement3i, surface->data_collisionvertex3f, surface->texture->supercontents, surface->texture->surfaceflags, surface->texture, segmentmins, segmentmaxs);
5616                         }
5617                 }
5618         }
5619 }
5620
5621 static void Mod_Q3BSP_TraceBox(model_t *model, int frame, trace_t *trace, const vec3_t start, const vec3_t boxmins, const vec3_t boxmaxs, const vec3_t end, int hitsupercontentsmask)
5622 {
5623         int i;
5624         float segmentmins[3], segmentmaxs[3];
5625         static int markframe = 0;
5626         msurface_t *surface;
5627         q3mbrush_t *brush;
5628         memset(trace, 0, sizeof(*trace));
5629         trace->fraction = 1;
5630         trace->realfraction = 1;
5631         trace->hitsupercontentsmask = hitsupercontentsmask;
5632         if (mod_q3bsp_optimizedtraceline.integer && VectorLength2(boxmins) + VectorLength2(boxmaxs) == 0)
5633         {
5634                 if (VectorCompare(start, end))
5635                 {
5636                         // point trace
5637                         if (model->brush.submodel)
5638                         {
5639                                 for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++)
5640                                         if (brush->colbrushf)
5641                                                 Collision_TracePointBrushFloat(trace, start, brush->colbrushf);
5642                         }
5643                         else
5644                                 Mod_Q3BSP_TracePoint_RecursiveBSPNode(trace, model, model->brush.data_nodes, start, ++markframe);
5645                 }
5646                 else
5647                 {
5648                         // line trace
5649                         segmentmins[0] = min(start[0], end[0]) - 1;
5650                         segmentmins[1] = min(start[1], end[1]) - 1;
5651                         segmentmins[2] = min(start[2], end[2]) - 1;
5652                         segmentmaxs[0] = max(start[0], end[0]) + 1;
5653                         segmentmaxs[1] = max(start[1], end[1]) + 1;
5654                         segmentmaxs[2] = max(start[2], end[2]) + 1;
5655                         if (model->brush.submodel)
5656                         {
5657                                 for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++)
5658                                         if (brush->colbrushf)
5659                                                 Collision_TraceLineBrushFloat(trace, start, end, brush->colbrushf, brush->colbrushf);
5660                                 if (mod_q3bsp_curves_collisions.integer)
5661                                         for (i = 0, surface = model->data_surfaces + model->firstmodelsurface;i < model->nummodelsurfaces;i++, surface++)
5662                                                 if (surface->num_collisiontriangles)
5663                                                         Collision_TraceLineTriangleMeshFloat(trace, start, end, surface->num_collisiontriangles, surface->data_collisionelement3i, surface->data_collisionvertex3f, surface->texture->supercontents, surface->texture->surfaceflags, surface->texture, segmentmins, segmentmaxs);
5664                         }
5665                         else
5666                                 Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace, model, model->brush.data_nodes, start, end, 0, 1, start, end, ++markframe, segmentmins, segmentmaxs);
5667                 }
5668         }
5669         else
5670         {
5671                 // box trace, performed as brush trace
5672                 colbrushf_t *thisbrush_start, *thisbrush_end;
5673                 vec3_t boxstartmins, boxstartmaxs, boxendmins, boxendmaxs;
5674                 segmentmins[0] = min(start[0], end[0]) + boxmins[0] - 1;
5675                 segmentmins[1] = min(start[1], end[1]) + boxmins[1] - 1;
5676                 segmentmins[2] = min(start[2], end[2]) + boxmins[2] - 1;
5677                 segmentmaxs[0] = max(start[0], end[0]) + boxmaxs[0] + 1;
5678                 segmentmaxs[1] = max(start[1], end[1]) + boxmaxs[1] + 1;
5679                 segmentmaxs[2] = max(start[2], end[2]) + boxmaxs[2] + 1;
5680                 VectorAdd(start, boxmins, boxstartmins);
5681                 VectorAdd(start, boxmaxs, boxstartmaxs);
5682                 VectorAdd(end, boxmins, boxendmins);
5683                 VectorAdd(end, boxmaxs, boxendmaxs);
5684                 thisbrush_start = Collision_BrushForBox(&identitymatrix, boxstartmins, boxstartmaxs, 0, 0, NULL);
5685                 thisbrush_end = Collision_BrushForBox(&identitymatrix, boxendmins, boxendmaxs, 0, 0, NULL);
5686                 if (model->brush.submodel)
5687                 {
5688                         for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++)
5689                                 if (brush->colbrushf)
5690                                         Collision_TraceBrushBrushFloat(trace, thisbrush_start, thisbrush_end, brush->colbrushf, brush->colbrushf);
5691                         if (mod_q3bsp_curves_collisions.integer)
5692                                 for (i = 0, surface = model->data_surfaces + model->firstmodelsurface;i < model->nummodelsurfaces;i++, surface++)
5693                                         if (surface->num_collisiontriangles)
5694                                                 Collision_TraceBrushTriangleMeshFloat(trace, thisbrush_start, thisbrush_end, surface->num_collisiontriangles, surface->data_collisionelement3i, surface->data_collisionvertex3f, surface->texture->supercontents, surface->texture->surfaceflags, surface->texture, segmentmins, segmentmaxs);
5695                 }
5696                 else
5697                         Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, model, model->brush.data_nodes, thisbrush_start, thisbrush_end, ++markframe, segmentmins, segmentmaxs);
5698         }
5699 }
5700
5701 static int Mod_Q3BSP_SuperContentsFromNativeContents(model_t *model, int nativecontents)
5702 {
5703         int supercontents = 0;
5704         if (nativecontents & CONTENTSQ3_SOLID)
5705                 supercontents |= SUPERCONTENTS_SOLID;
5706         if (nativecontents & CONTENTSQ3_WATER)
5707                 supercontents |= SUPERCONTENTS_WATER;
5708         if (nativecontents & CONTENTSQ3_SLIME)
5709                 supercontents |= SUPERCONTENTS_SLIME;
5710         if (nativecontents & CONTENTSQ3_LAVA)
5711                 supercontents |= SUPERCONTENTS_LAVA;
5712         if (nativecontents & CONTENTSQ3_BODY)
5713                 supercontents |= SUPERCONTENTS_BODY;
5714         if (nativecontents & CONTENTSQ3_CORPSE)
5715                 supercontents |= SUPERCONTENTS_CORPSE;
5716         if (nativecontents & CONTENTSQ3_NODROP)
5717                 supercontents |= SUPERCONTENTS_NODROP;
5718         if (nativecontents & CONTENTSQ3_PLAYERCLIP)
5719                 supercontents |= SUPERCONTENTS_PLAYERCLIP;
5720         if (nativecontents & CONTENTSQ3_MONSTERCLIP)
5721                 supercontents |= SUPERCONTENTS_MONSTERCLIP;
5722         if (nativecontents & CONTENTSQ3_DONOTENTER)
5723                 supercontents |= SUPERCONTENTS_DONOTENTER;
5724         return supercontents;
5725 }
5726
5727 static int Mod_Q3BSP_NativeContentsFromSuperContents(model_t *model, int supercontents)
5728 {
5729         int nativecontents = 0;
5730         if (supercontents & SUPERCONTENTS_SOLID)
5731                 nativecontents |= CONTENTSQ3_SOLID;
5732         if (supercontents & SUPERCONTENTS_WATER)
5733                 nativecontents |= CONTENTSQ3_WATER;
5734         if (supercontents & SUPERCONTENTS_SLIME)
5735                 nativecontents |= CONTENTSQ3_SLIME;
5736         if (supercontents & SUPERCONTENTS_LAVA)
5737                 nativecontents |= CONTENTSQ3_LAVA;
5738         if (supercontents & SUPERCONTENTS_BODY)
5739                 nativecontents |= CONTENTSQ3_BODY;
5740         if (supercontents & SUPERCONTENTS_CORPSE)
5741                 nativecontents |= CONTENTSQ3_CORPSE;
5742         if (supercontents & SUPERCONTENTS_NODROP)
5743                 nativecontents |= CONTENTSQ3_NODROP;
5744         if (supercontents & SUPERCONTENTS_PLAYERCLIP)
5745                 nativecontents |= CONTENTSQ3_PLAYERCLIP;
5746         if (supercontents & SUPERCONTENTS_MONSTERCLIP)
5747                 nativecontents |= CONTENTSQ3_MONSTERCLIP;
5748         if (supercontents & SUPERCONTENTS_DONOTENTER)
5749                 nativecontents |= CONTENTSQ3_DONOTENTER;
5750         return nativecontents;
5751 }
5752
5753 void Mod_Q3BSP_RecursiveFindNumLeafs(mnode_t *node)
5754 {
5755         int numleafs;
5756         while (node->plane)
5757         {
5758                 Mod_Q3BSP_RecursiveFindNumLeafs(node->children[0]);
5759                 node = node->children[1];
5760         }
5761         numleafs = ((mleaf_t *)node - loadmodel->brush.data_leafs) + 1;
5762         if (loadmodel->brush.num_leafs < numleafs)
5763                 loadmodel->brush.num_leafs = numleafs;
5764 }
5765
5766 void Mod_Q3BSP_Load(model_t *mod, void *buffer, void *bufferend)
5767 {
5768         int i, j, numshadowmeshtriangles;
5769         q3dheader_t *header;
5770         float corner[3], yawradius, modelradius;
5771         msurface_t *surface;
5772
5773         mod->type = mod_brushq3;
5774         mod->numframes = 2; // although alternate textures are not supported it is annoying to complain about no such frame 1
5775         mod->numskins = 1;
5776
5777         header = (q3dheader_t *)buffer;
5778
5779         i = LittleLong(header->version);
5780         if (i != Q3BSPVERSION)
5781                 Host_Error("Mod_Q3BSP_Load: %s has wrong version number (%i, should be %i)", mod->name, i, Q3BSPVERSION);
5782         mod->brush.ishlbsp = false;
5783         mod->brush.ismcbsp = false;
5784         if (loadmodel->isworldmodel)
5785         {
5786                 Cvar_SetValue("halflifebsp", mod->brush.ishlbsp);
5787                 Cvar_SetValue("mcbsp", mod->brush.ismcbsp);
5788         }
5789
5790         mod->soundfromcenter = true;
5791         mod->TraceBox = Mod_Q3BSP_TraceBox;
5792         mod->brush.SuperContentsFromNativeContents = Mod_Q3BSP_SuperContentsFromNativeContents;
5793         mod->brush.NativeContentsFromSuperContents = Mod_Q3BSP_NativeContentsFromSuperContents;
5794         mod->brush.GetPVS = Mod_Q1BSP_GetPVS;
5795         mod->brush.FatPVS = Mod_Q1BSP_FatPVS;
5796         mod->brush.BoxTouchingPVS = Mod_Q1BSP_BoxTouchingPVS;
5797         mod->brush.BoxTouchingLeafPVS = Mod_Q1BSP_BoxTouchingLeafPVS;
5798         mod->brush.BoxTouchingVisibleLeafs = Mod_Q1BSP_BoxTouchingVisibleLeafs;
5799         mod->brush.FindBoxClusters = Mod_Q1BSP_FindBoxClusters;
5800         mod->brush.LightPoint = Mod_Q3BSP_LightPoint;
5801         mod->brush.FindNonSolidLocation = Mod_Q1BSP_FindNonSolidLocation;
5802         mod->brush.PointInLeaf = Mod_Q1BSP_PointInLeaf;
5803         mod->Draw = R_Q1BSP_Draw;
5804         mod->GetLightInfo = R_Q1BSP_GetLightInfo;
5805         mod->CompileShadowVolume = R_Q1BSP_CompileShadowVolume;
5806         mod->DrawShadowVolume = R_Q1BSP_DrawShadowVolume;
5807         mod->DrawLight = R_Q1BSP_DrawLight;
5808
5809         mod_base = (unsigned char *)header;
5810
5811         // swap all the lumps
5812         header->ident = LittleLong(header->ident);
5813         header->version = LittleLong(header->version);
5814         for (i = 0;i < Q3HEADER_LUMPS;i++)
5815         {
5816                 header->lumps[i].fileofs = LittleLong(header->lumps[i].fileofs);
5817                 header->lumps[i].filelen = LittleLong(header->lumps[i].filelen);
5818         }
5819
5820         mod->brush.qw_md4sum = 0;
5821         mod->brush.qw_md4sum2 = 0;
5822         for (i = 0;i < Q3HEADER_LUMPS;i++)
5823         {
5824                 if (i == Q3LUMP_ENTITIES)
5825                         continue;
5826                 mod->brush.qw_md4sum ^= Com_BlockChecksum(mod_base + header->lumps[i].fileofs, header->lumps[i].filelen);
5827                 if (i == Q3LUMP_PVS || i == Q3LUMP_LEAFS || i == Q3LUMP_NODES)
5828                         continue;
5829                 mod->brush.qw_md4sum2 ^= Com_BlockChecksum(mod_base + header->lumps[i].fileofs, header->lumps[i].filelen);
5830         }
5831
5832         Mod_Q3BSP_LoadEntities(&header->lumps[Q3LUMP_ENTITIES]);
5833         Mod_Q3BSP_LoadTextures(&header->lumps[Q3LUMP_TEXTURES]);
5834         Mod_Q3BSP_LoadPlanes(&header->lumps[Q3LUMP_PLANES]);
5835         Mod_Q3BSP_LoadBrushSides(&header->lumps[Q3LUMP_BRUSHSIDES]);
5836         Mod_Q3BSP_LoadBrushes(&header->lumps[Q3LUMP_BRUSHES]);
5837         Mod_Q3BSP_LoadEffects(&header->lumps[Q3LUMP_EFFECTS]);
5838         Mod_Q3BSP_LoadVertices(&header->lumps[Q3LUMP_VERTICES]);
5839         Mod_Q3BSP_LoadTriangles(&header->lumps[Q3LUMP_TRIANGLES]);
5840         Mod_Q3BSP_LoadLightmaps(&header->lumps[Q3LUMP_LIGHTMAPS]);
5841         Mod_Q3BSP_LoadFaces(&header->lumps[Q3LUMP_FACES]);
5842         Mod_Q3BSP_LoadModels(&header->lumps[Q3LUMP_MODELS]);
5843         Mod_Q3BSP_LoadLeafBrushes(&header->lumps[Q3LUMP_LEAFBRUSHES]);
5844         Mod_Q3BSP_LoadLeafFaces(&header->lumps[Q3LUMP_LEAFFACES]);
5845         Mod_Q3BSP_LoadLeafs(&header->lumps[Q3LUMP_LEAFS]);
5846         Mod_Q3BSP_LoadNodes(&header->lumps[Q3LUMP_NODES]);
5847         Mod_Q3BSP_LoadLightGrid(&header->lumps[Q3LUMP_LIGHTGRID]);
5848         Mod_Q3BSP_LoadPVS(&header->lumps[Q3LUMP_PVS]);
5849         loadmodel->brush.numsubmodels = loadmodel->brushq3.num_models;
5850
5851         // the MakePortals code works fine on the q3bsp data as well
5852         Mod_Q1BSP_MakePortals();
5853
5854         // FIXME: shader alpha should replace r_wateralpha support in q3bsp
5855         loadmodel->brush.supportwateralpha = true;
5856
5857         // make a single combined shadow mesh to allow optimized shadow volume creation
5858         numshadowmeshtriangles = 0;
5859         for (j = 0, surface = loadmodel->data_surfaces;j < loadmodel->num_surfaces;j++, surface++)
5860         {
5861                 surface->num_firstshadowmeshtriangle = numshadowmeshtriangles;
5862                 numshadowmeshtriangles += surface->num_triangles;
5863         }
5864         loadmodel->brush.shadowmesh = Mod_ShadowMesh_Begin(loadmodel->mempool, numshadowmeshtriangles * 3, numshadowmeshtriangles, NULL, NULL, NULL, false, false, true);
5865         for (j = 0, surface = loadmodel->data_surfaces;j < loadmodel->num_surfaces;j++, surface++)
5866                 if (surface->num_triangles > 0)
5867                         Mod_ShadowMesh_AddMesh(loadmodel->mempool, loadmodel->brush.shadowmesh, NULL, NULL, NULL, loadmodel->surfmesh.data_vertex3f, NULL, NULL, NULL, NULL, surface->num_triangles, (loadmodel->surfmesh.data_element3i + 3 * surface->num_firsttriangle));
5868         loadmodel->brush.shadowmesh = Mod_ShadowMesh_Finish(loadmodel->mempool, loadmodel->brush.shadowmesh, false, true);
5869         Mod_BuildTriangleNeighbors(loadmodel->brush.shadowmesh->neighbor3i, loadmodel->brush.shadowmesh->element3i, loadmodel->brush.shadowmesh->numtriangles);
5870
5871         loadmodel->brush.num_leafs = 0;
5872         Mod_Q3BSP_RecursiveFindNumLeafs(loadmodel->brush.data_nodes);
5873
5874         if (loadmodel->isworldmodel)
5875         {
5876                 // clear out any stale submodels or worldmodels lying around
5877                 // if we did this clear before now, an error might abort loading and
5878                 // leave things in a bad state
5879                 Mod_RemoveStaleWorldModels(loadmodel);
5880         }
5881
5882         mod = loadmodel;
5883         for (i = 0;i < loadmodel->brush.numsubmodels;i++)
5884         {
5885                 if (i > 0)
5886                 {
5887                         char name[10];
5888                         // LordHavoc: only register submodels if it is the world
5889                         // (prevents external bsp models from replacing world submodels with
5890                         //  their own)
5891                         if (!loadmodel->isworldmodel)
5892                                 continue;
5893                         // duplicate the basic information
5894                         sprintf(name, "*%i", i);
5895                         mod = Mod_FindName(name);
5896                         *mod = *loadmodel;
5897                         strlcpy(mod->name, name, sizeof(mod->name));
5898                         // textures and memory belong to the main model
5899                         mod->texturepool = NULL;
5900                         mod->mempool = NULL;
5901                         mod->brush.GetPVS = NULL;
5902                         mod->brush.FatPVS = NULL;
5903                         mod->brush.BoxTouchingPVS = NULL;
5904                         mod->brush.BoxTouchingLeafPVS = NULL;
5905                         mod->brush.BoxTouchingVisibleLeafs = NULL;
5906                         mod->brush.FindBoxClusters = NULL;
5907                         mod->brush.LightPoint = NULL;
5908                         mod->brush.FindNonSolidLocation = Mod_Q1BSP_FindNonSolidLocation;
5909                 }
5910                 mod->brush.submodel = i;
5911
5912                 // make the model surface list (used by shadowing/lighting)
5913                 mod->firstmodelsurface = mod->brushq3.data_models[i].firstface;
5914                 mod->nummodelsurfaces = mod->brushq3.data_models[i].numfaces;
5915                 mod->firstmodelbrush = mod->brushq3.data_models[i].firstbrush;
5916                 mod->nummodelbrushes = mod->brushq3.data_models[i].numbrushes;
5917                 mod->surfacelist = (int *)Mem_Alloc(loadmodel->mempool, mod->nummodelsurfaces * sizeof(*mod->surfacelist));
5918                 for (j = 0;j < mod->nummodelsurfaces;j++)
5919                         mod->surfacelist[j] = mod->firstmodelsurface + j;
5920
5921                 VectorCopy(mod->brushq3.data_models[i].mins, mod->normalmins);
5922                 VectorCopy(mod->brushq3.data_models[i].maxs, mod->normalmaxs);
5923                 corner[0] = max(fabs(mod->normalmins[0]), fabs(mod->normalmaxs[0]));
5924                 corner[1] = max(fabs(mod->normalmins[1]), fabs(mod->normalmaxs[1]));
5925                 corner[2] = max(fabs(mod->normalmins[2]), fabs(mod->normalmaxs[2]));
5926                 modelradius = sqrt(corner[0]*corner[0]+corner[1]*corner[1]+corner[2]*corner[2]);
5927                 yawradius = sqrt(corner[0]*corner[0]+corner[1]*corner[1]);
5928                 mod->rotatedmins[0] = mod->rotatedmins[1] = mod->rotatedmins[2] = -modelradius;
5929                 mod->rotatedmaxs[0] = mod->rotatedmaxs[1] = mod->rotatedmaxs[2] = modelradius;
5930                 mod->yawmaxs[0] = mod->yawmaxs[1] = yawradius;
5931                 mod->yawmins[0] = mod->yawmins[1] = -yawradius;
5932                 mod->yawmins[2] = mod->normalmins[2];
5933                 mod->yawmaxs[2] = mod->normalmaxs[2];
5934                 mod->radius = modelradius;
5935                 mod->radius2 = modelradius * modelradius;
5936
5937                 for (j = 0;j < mod->nummodelsurfaces;j++)
5938                         if (mod->data_surfaces[j + mod->firstmodelsurface].texture->surfaceflags & Q3SURFACEFLAG_SKY)
5939                                 break;
5940                 if (j < mod->nummodelsurfaces)
5941                         mod->DrawSky = R_Q1BSP_DrawSky;
5942                 else
5943                         mod->DrawSky = NULL;
5944         }
5945 }
5946
5947 void Mod_IBSP_Load(model_t *mod, void *buffer, void *bufferend)
5948 {
5949         int i = LittleLong(((int *)buffer)[1]);
5950         if (i == Q3BSPVERSION)
5951                 Mod_Q3BSP_Load(mod,buffer, bufferend);
5952         else if (i == Q2BSPVERSION)
5953                 Mod_Q2BSP_Load(mod,buffer, bufferend);
5954         else
5955                 Host_Error("Mod_IBSP_Load: unknown/unsupported version %i", i);
5956 }
5957
5958 void Mod_MAP_Load(model_t *mod, void *buffer, void *bufferend)
5959 {
5960         Host_Error("Mod_MAP_Load: not yet implemented");
5961 }
5962