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