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 extern cvar_t gl_max_size;
2192 static void Mod_Q1BSP_LoadFaces(lump_t *l)
2193 {
2194         dface_t *in;
2195         msurface_t *surface;
2196         int i, j, count, surfacenum, planenum, smax, tmax, ssize, tsize, firstedge, numedges, totalverts, totaltris, lightmapnumber, lightmapsize, totallightmapsamples;
2197         float texmins[2], texmaxs[2], val;
2198 #define LIGHTMAPSIZE 1024
2199         rtexture_t *lightmaptexture, *deluxemaptexture;
2200         int lightmap_lineused[LIGHTMAPSIZE];
2201
2202         in = (dface_t *)(mod_base + l->fileofs);
2203         if (l->filelen % sizeof(*in))
2204                 Host_Error("Mod_Q1BSP_LoadFaces: funny lump size in %s",loadmodel->name);
2205         count = l->filelen / sizeof(*in);
2206         loadmodel->data_surfaces = (msurface_t *)Mem_Alloc(loadmodel->mempool, count*sizeof(msurface_t));
2207         loadmodel->data_surfaces_lightmapinfo = (msurface_lightmapinfo_t *)Mem_Alloc(loadmodel->mempool, count*sizeof(msurface_lightmapinfo_t));
2208
2209         loadmodel->num_surfaces = count;
2210
2211         totalverts = 0;
2212         totaltris = 0;
2213         for (surfacenum = 0, in = (dface_t *)(mod_base + l->fileofs);surfacenum < count;surfacenum++, in++)
2214         {
2215                 numedges = LittleShort(in->numedges);
2216                 totalverts += numedges;
2217                 totaltris += numedges - 2;
2218         }
2219
2220         Mod_AllocSurfMesh(loadmodel->mempool, totalverts, totaltris, true, false, false);
2221
2222         lightmaptexture = NULL;
2223         deluxemaptexture = r_texture_blanknormalmap;
2224         lightmapnumber = 1;
2225         lightmapsize = bound(256, gl_max_size.integer, LIGHTMAPSIZE);
2226         totallightmapsamples = 0;
2227
2228         totalverts = 0;
2229         totaltris = 0;
2230         for (surfacenum = 0, in = (dface_t *)(mod_base + l->fileofs), surface = loadmodel->data_surfaces;surfacenum < count;surfacenum++, in++, surface++)
2231         {
2232                 surface->lightmapinfo = loadmodel->data_surfaces_lightmapinfo + surfacenum;
2233
2234                 // FIXME: validate edges, texinfo, etc?
2235                 firstedge = LittleLong(in->firstedge);
2236                 numedges = LittleShort(in->numedges);
2237                 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)
2238                         Host_Error("Mod_Q1BSP_LoadFaces: invalid edge range (firstedge %i, numedges %i, model edges %i)", firstedge, numedges, loadmodel->brushq1.numsurfedges);
2239                 i = LittleShort(in->texinfo);
2240                 if ((unsigned int) i >= (unsigned int) loadmodel->brushq1.numtexinfo)
2241                         Host_Error("Mod_Q1BSP_LoadFaces: invalid texinfo index %i(model has %i texinfos)", i, loadmodel->brushq1.numtexinfo);
2242                 surface->lightmapinfo->texinfo = loadmodel->brushq1.texinfo + i;
2243                 surface->texture = surface->lightmapinfo->texinfo->texture;
2244
2245                 planenum = LittleShort(in->planenum);
2246                 if ((unsigned int) planenum >= (unsigned int) loadmodel->brush.num_planes)
2247                         Host_Error("Mod_Q1BSP_LoadFaces: invalid plane index %i (model has %i planes)", planenum, loadmodel->brush.num_planes);
2248
2249                 //surface->flags = surface->texture->flags;
2250                 //if (LittleShort(in->side))
2251                 //      surface->flags |= SURF_PLANEBACK;
2252                 //surface->plane = loadmodel->brush.data_planes + planenum;
2253
2254                 surface->num_firstvertex = totalverts;
2255                 surface->num_vertices = numedges;
2256                 surface->num_firsttriangle = totaltris;
2257                 surface->num_triangles = numedges - 2;
2258                 totalverts += numedges;
2259                 totaltris += numedges - 2;
2260
2261                 // convert edges back to a normal polygon
2262                 for (i = 0;i < surface->num_vertices;i++)
2263                 {
2264                         int lindex = loadmodel->brushq1.surfedges[firstedge + i];
2265                         float s, t;
2266                         if (lindex > 0)
2267                                 VectorCopy(loadmodel->brushq1.vertexes[loadmodel->brushq1.edges[lindex].v[0]].position, (loadmodel->surfmesh.data_vertex3f + 3 * surface->num_firstvertex) + i * 3);
2268                         else
2269                                 VectorCopy(loadmodel->brushq1.vertexes[loadmodel->brushq1.edges[-lindex].v[1]].position, (loadmodel->surfmesh.data_vertex3f + 3 * surface->num_firstvertex) + i * 3);
2270                         s = DotProduct(((loadmodel->surfmesh.data_vertex3f + 3 * surface->num_firstvertex) + i * 3), surface->lightmapinfo->texinfo->vecs[0]) + surface->lightmapinfo->texinfo->vecs[0][3];
2271                         t = DotProduct(((loadmodel->surfmesh.data_vertex3f + 3 * surface->num_firstvertex) + i * 3), surface->lightmapinfo->texinfo->vecs[1]) + surface->lightmapinfo->texinfo->vecs[1][3];
2272                         (loadmodel->surfmesh.data_texcoordtexture2f + 2 * surface->num_firstvertex)[i * 2 + 0] = s / surface->texture->width;
2273                         (loadmodel->surfmesh.data_texcoordtexture2f + 2 * surface->num_firstvertex)[i * 2 + 1] = t / surface->texture->height;
2274                         (loadmodel->surfmesh.data_texcoordlightmap2f + 2 * surface->num_firstvertex)[i * 2 + 0] = 0;
2275                         (loadmodel->surfmesh.data_texcoordlightmap2f + 2 * surface->num_firstvertex)[i * 2 + 1] = 0;
2276                         (loadmodel->surfmesh.data_lightmapoffsets + surface->num_firstvertex)[i] = 0;
2277                 }
2278
2279                 for (i = 0;i < surface->num_triangles;i++)
2280                 {
2281                         (loadmodel->surfmesh.data_element3i + 3 * surface->num_firsttriangle)[i * 3 + 0] = 0 + surface->num_firstvertex;
2282                         (loadmodel->surfmesh.data_element3i + 3 * surface->num_firsttriangle)[i * 3 + 1] = i + 1 + surface->num_firstvertex;
2283                         (loadmodel->surfmesh.data_element3i + 3 * surface->num_firsttriangle)[i * 3 + 2] = i + 2 + surface->num_firstvertex;
2284                 }
2285
2286                 // compile additional data about the surface geometry
2287                 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);
2288                 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);
2289                 BoxFromPoints(surface->mins, surface->maxs, surface->num_vertices, (loadmodel->surfmesh.data_vertex3f + 3 * surface->num_firstvertex));
2290
2291                 // generate surface extents information
2292                 texmins[0] = texmaxs[0] = DotProduct((loadmodel->surfmesh.data_vertex3f + 3 * surface->num_firstvertex), surface->lightmapinfo->texinfo->vecs[0]) + surface->lightmapinfo->texinfo->vecs[0][3];
2293                 texmins[1] = texmaxs[1] = DotProduct((loadmodel->surfmesh.data_vertex3f + 3 * surface->num_firstvertex), surface->lightmapinfo->texinfo->vecs[1]) + surface->lightmapinfo->texinfo->vecs[1][3];
2294                 for (i = 1;i < surface->num_vertices;i++)
2295                 {
2296                         for (j = 0;j < 2;j++)
2297                         {
2298                                 val = DotProduct((loadmodel->surfmesh.data_vertex3f + 3 * surface->num_firstvertex) + i * 3, surface->lightmapinfo->texinfo->vecs[j]) + surface->lightmapinfo->texinfo->vecs[j][3];
2299                                 texmins[j] = min(texmins[j], val);
2300                                 texmaxs[j] = max(texmaxs[j], val);
2301                         }
2302                 }
2303                 for (i = 0;i < 2;i++)
2304                 {
2305                         surface->lightmapinfo->texturemins[i] = (int) floor(texmins[i] / 16.0) * 16;
2306                         surface->lightmapinfo->extents[i] = (int) ceil(texmaxs[i] / 16.0) * 16 - surface->lightmapinfo->texturemins[i];
2307                 }
2308
2309                 smax = surface->lightmapinfo->extents[0] >> 4;
2310                 tmax = surface->lightmapinfo->extents[1] >> 4;
2311                 ssize = (surface->lightmapinfo->extents[0] >> 4) + 1;
2312                 tsize = (surface->lightmapinfo->extents[1] >> 4) + 1;
2313
2314                 // lighting info
2315                 for (i = 0;i < MAXLIGHTMAPS;i++)
2316                         surface->lightmapinfo->styles[i] = in->styles[i];
2317                 surface->lightmaptexture = NULL;
2318                 surface->deluxemaptexture = r_texture_blanknormalmap;
2319                 i = LittleLong(in->lightofs);
2320                 if (i == -1)
2321                 {
2322                         surface->lightmapinfo->samples = NULL;
2323                         // give non-lightmapped water a 1x white lightmap
2324                         if ((surface->texture->basematerialflags & MATERIALFLAG_WATER) && (surface->lightmapinfo->texinfo->flags & TEX_SPECIAL) && ssize <= 256 && tsize <= 256)
2325                         {
2326                                 surface->lightmapinfo->samples = (unsigned char *)Mem_Alloc(loadmodel->mempool, ssize * tsize * 3);
2327                                 surface->lightmapinfo->styles[0] = 0;
2328                                 memset(surface->lightmapinfo->samples, 128, ssize * tsize * 3);
2329                         }
2330                 }
2331                 else if (loadmodel->brush.ishlbsp) // LordHavoc: HalfLife map (bsp version 30)
2332                         surface->lightmapinfo->samples = loadmodel->brushq1.lightdata + i;
2333                 else // LordHavoc: white lighting (bsp version 29)
2334                 {
2335                         surface->lightmapinfo->samples = loadmodel->brushq1.lightdata + (i * 3);
2336                         if (loadmodel->brushq1.nmaplightdata)
2337                                 surface->lightmapinfo->nmapsamples = loadmodel->brushq1.nmaplightdata + (i * 3);
2338                 }
2339
2340                 // check if we should apply a lightmap to this
2341                 if (!(surface->lightmapinfo->texinfo->flags & TEX_SPECIAL) || surface->lightmapinfo->samples)
2342                 {
2343                         if (ssize > 256 || tsize > 256)
2344                                 Host_Error("Bad surface extents");
2345
2346                         if (lightmapsize < ssize)
2347                                 lightmapsize = ssize;
2348                         if (lightmapsize < tsize)
2349                                 lightmapsize = tsize;
2350
2351                         totallightmapsamples += ssize*tsize;
2352
2353                         // force lightmap upload on first time seeing the surface
2354                         //
2355                         // additionally this is used by the later code to see if a
2356                         // lightmap is needed on this surface (rather than duplicating the
2357                         // logic above)
2358                         surface->cached_dlight = true;
2359                 }
2360         }
2361
2362         // small maps (such as ammo boxes especially) don't need big lightmap
2363         // textures, so this code tries to guess a good size based on
2364         // totallightmapsamples (size of the lightmaps lump basically), as well as
2365         // trying to max out the gl_max_size if there is a lot of lightmap data to
2366         // store
2367         // additionally, never choose a lightmapsize that is smaller than the
2368         // largest surface encountered (as it would fail)
2369         // and finally, limit it to the size of our lineused array
2370         i = lightmapsize;
2371         for (lightmapsize = 64;lightmapsize < LIGHTMAPSIZE && (lightmapsize < i || (lightmapsize < gl_max_size.integer && totallightmapsamples*2 > lightmapsize*lightmapsize));lightmapsize*=2)
2372                 ;
2373
2374         // now that we've decided the lightmap texture size, we can do the rest
2375         if (cls.state != ca_dedicated)
2376         {
2377                 for (surfacenum = 0, surface = loadmodel->data_surfaces;surfacenum < count;surfacenum++, surface++)
2378                 {
2379                         // check if we should apply a lightmap to this
2380                         if (surface->cached_dlight)
2381                         {
2382                                 int i, iu, iv, lightmapx, lightmapy;
2383                                 float u, v, ubase, vbase, uscale, vscale;
2384
2385                                 smax = surface->lightmapinfo->extents[0] >> 4;
2386                                 tmax = surface->lightmapinfo->extents[1] >> 4;
2387                                 ssize = (surface->lightmapinfo->extents[0] >> 4) + 1;
2388                                 tsize = (surface->lightmapinfo->extents[1] >> 4) + 1;
2389
2390                                 // stainmap for permanent marks on walls
2391                                 surface->lightmapinfo->stainsamples = (unsigned char *)Mem_Alloc(loadmodel->mempool, ssize * tsize * 3);
2392                                 // clear to white
2393                                 memset(surface->lightmapinfo->stainsamples, 255, ssize * tsize * 3);
2394
2395                                 // find a place for this lightmap
2396                                 if (!lightmaptexture || !Mod_Q1BSP_AllocLightmapBlock(lightmap_lineused, lightmapsize, lightmapsize, ssize, tsize, &lightmapx, &lightmapy))
2397                                 {
2398                                         // allocate a texture pool if we need it
2399                                         if (loadmodel->texturepool == NULL)
2400                                                 loadmodel->texturepool = R_AllocTexturePool();
2401                                         // could not find room, make a new lightmap
2402                                         lightmaptexture = R_LoadTexture2D(loadmodel->texturepool, va("lightmap%i", lightmapnumber), lightmapsize, lightmapsize, NULL, loadmodel->brushq1.lightmaprgba ? TEXTYPE_RGBA : TEXTYPE_RGB, TEXF_FORCELINEAR | TEXF_PRECACHE, NULL);
2403                                         if (loadmodel->brushq1.nmaplightdata)
2404                                                 deluxemaptexture = R_LoadTexture2D(loadmodel->texturepool, va("deluxemap%i", lightmapnumber), lightmapsize, lightmapsize, NULL, loadmodel->brushq1.lightmaprgba ? TEXTYPE_RGBA : TEXTYPE_RGB, TEXF_FORCELINEAR | TEXF_PRECACHE, NULL);
2405                                         lightmapnumber++;
2406                                         memset(lightmap_lineused, 0, sizeof(lightmap_lineused));
2407                                         Mod_Q1BSP_AllocLightmapBlock(lightmap_lineused, lightmapsize, lightmapsize, ssize, tsize, &lightmapx, &lightmapy);
2408                                 }
2409
2410                                 surface->lightmaptexture = lightmaptexture;
2411                                 surface->deluxemaptexture = deluxemaptexture;
2412                                 surface->lightmapinfo->lightmaporigin[0] = lightmapx;
2413                                 surface->lightmapinfo->lightmaporigin[1] = lightmapy;
2414
2415                                 uscale = 1.0f / (float)lightmapsize;
2416                                 vscale = 1.0f / (float)lightmapsize;
2417                                 ubase = lightmapx * uscale;
2418                                 vbase = lightmapy * vscale;
2419
2420                                 for (i = 0;i < surface->num_vertices;i++)
2421                                 {
2422                                         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);
2423                                         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);
2424                                         (loadmodel->surfmesh.data_texcoordlightmap2f + 2 * surface->num_firstvertex)[i * 2 + 0] = u * uscale + ubase;
2425                                         (loadmodel->surfmesh.data_texcoordlightmap2f + 2 * surface->num_firstvertex)[i * 2 + 1] = v * vscale + vbase;
2426                                         // LordHavoc: calc lightmap data offset for vertex lighting to use
2427                                         iu = (int) u;
2428                                         iv = (int) v;
2429                                         (loadmodel->surfmesh.data_lightmapoffsets + surface->num_firstvertex)[i] = (bound(0, iv, tmax) * ssize + bound(0, iu, smax)) * 3;
2430                                 }
2431                         }
2432                 }
2433         }
2434 }
2435
2436 static void Mod_Q1BSP_LoadNodes_RecursiveSetParent(mnode_t *node, mnode_t *parent)
2437 {
2438         //if (node->parent)
2439         //      Host_Error("Mod_Q1BSP_LoadNodes_RecursiveSetParent: runaway recursion");
2440         node->parent = parent;
2441         if (node->plane)
2442         {
2443                 // this is a node, recurse to children
2444                 Mod_Q1BSP_LoadNodes_RecursiveSetParent(node->children[0], node);
2445                 Mod_Q1BSP_LoadNodes_RecursiveSetParent(node->children[1], node);
2446                 // combine supercontents of children
2447                 node->combinedsupercontents = node->children[0]->combinedsupercontents | node->children[1]->combinedsupercontents;
2448         }
2449         else
2450         {
2451                 int j;
2452                 mleaf_t *leaf = (mleaf_t *)node;
2453                 // if this is a leaf, calculate supercontents mask from all collidable
2454                 // primitives in the leaf (brushes and collision surfaces)
2455                 // also flag if the leaf contains any collision surfaces
2456                 leaf->combinedsupercontents = 0;
2457                 // combine the supercontents values of all brushes in this leaf
2458                 for (j = 0;j < leaf->numleafbrushes;j++)
2459                         leaf->combinedsupercontents |= loadmodel->brush.data_brushes[leaf->firstleafbrush[j]].texture->supercontents;
2460                 // check if this leaf contains any collision surfaces (q3 patches)
2461                 for (j = 0;j < leaf->numleafsurfaces;j++)
2462                 {
2463                         msurface_t *surface = loadmodel->data_surfaces + leaf->firstleafsurface[j];
2464                         if (surface->num_collisiontriangles)
2465                         {
2466                                 leaf->containscollisionsurfaces = true;
2467                                 leaf->combinedsupercontents |= surface->texture->supercontents;
2468                         }
2469                 }
2470         }
2471 }
2472
2473 static void Mod_Q1BSP_LoadNodes(lump_t *l)
2474 {
2475         int                     i, j, count, p;
2476         dnode_t         *in;
2477         mnode_t         *out;
2478
2479         in = (dnode_t *)(mod_base + l->fileofs);
2480         if (l->filelen % sizeof(*in))
2481                 Host_Error("Mod_Q1BSP_LoadNodes: funny lump size in %s",loadmodel->name);
2482         count = l->filelen / sizeof(*in);
2483         out = (mnode_t *)Mem_Alloc(loadmodel->mempool, count*sizeof(*out));
2484
2485         loadmodel->brush.data_nodes = out;
2486         loadmodel->brush.num_nodes = count;
2487
2488         for ( i=0 ; i<count ; i++, in++, out++)
2489         {
2490                 for (j=0 ; j<3 ; j++)
2491                 {
2492                         out->mins[j] = LittleShort(in->mins[j]);
2493                         out->maxs[j] = LittleShort(in->maxs[j]);
2494                 }
2495
2496                 p = LittleLong(in->planenum);
2497                 out->plane = loadmodel->brush.data_planes + p;
2498
2499                 out->firstsurface = LittleShort(in->firstface);
2500                 out->numsurfaces = LittleShort(in->numfaces);
2501
2502                 for (j=0 ; j<2 ; j++)
2503                 {
2504                         p = LittleShort(in->children[j]);
2505                         if (p >= 0)
2506                                 out->children[j] = loadmodel->brush.data_nodes + p;
2507                         else
2508                                 out->children[j] = (mnode_t *)(loadmodel->brush.data_leafs + (-1 - p));
2509                 }
2510         }
2511
2512         Mod_Q1BSP_LoadNodes_RecursiveSetParent(loadmodel->brush.data_nodes, NULL);      // sets nodes and leafs
2513 }
2514
2515 static void Mod_Q1BSP_LoadLeafs(lump_t *l)
2516 {
2517         dleaf_t *in;
2518         mleaf_t *out;
2519         int i, j, count, p;
2520
2521         in = (dleaf_t *)(mod_base + l->fileofs);
2522         if (l->filelen % sizeof(*in))
2523                 Host_Error("Mod_Q1BSP_LoadLeafs: funny lump size in %s",loadmodel->name);
2524         count = l->filelen / sizeof(*in);
2525         out = (mleaf_t *)Mem_Alloc(loadmodel->mempool, count*sizeof(*out));
2526
2527         loadmodel->brush.data_leafs = out;
2528         loadmodel->brush.num_leafs = count;
2529         // get visleafs from the submodel data
2530         loadmodel->brush.num_pvsclusters = loadmodel->brushq1.submodels[0].visleafs;
2531         loadmodel->brush.num_pvsclusterbytes = (loadmodel->brush.num_pvsclusters+7)>>3;
2532         loadmodel->brush.data_pvsclusters = (unsigned char *)Mem_Alloc(loadmodel->mempool, loadmodel->brush.num_pvsclusters * loadmodel->brush.num_pvsclusterbytes);
2533         memset(loadmodel->brush.data_pvsclusters, 0xFF, loadmodel->brush.num_pvsclusters * loadmodel->brush.num_pvsclusterbytes);
2534
2535         for ( i=0 ; i<count ; i++, in++, out++)
2536         {
2537                 for (j=0 ; j<3 ; j++)
2538                 {
2539                         out->mins[j] = LittleShort(in->mins[j]);
2540                         out->maxs[j] = LittleShort(in->maxs[j]);
2541                 }
2542
2543                 // FIXME: this function could really benefit from some error checking
2544
2545                 out->contents = LittleLong(in->contents);
2546
2547                 out->firstleafsurface = loadmodel->brush.data_leafsurfaces + LittleShort(in->firstmarksurface);
2548                 out->numleafsurfaces = LittleShort(in->nummarksurfaces);
2549                 if (out->firstleafsurface < 0 || LittleShort(in->firstmarksurface) + out->numleafsurfaces > loadmodel->brush.num_leafsurfaces)
2550                 {
2551                         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);
2552                         out->firstleafsurface = NULL;
2553                         out->numleafsurfaces = 0;
2554                 }
2555
2556                 out->clusterindex = i - 1;
2557                 if (out->clusterindex >= loadmodel->brush.num_pvsclusters)
2558                         out->clusterindex = -1;
2559
2560                 p = LittleLong(in->visofs);
2561                 // ignore visofs errors on leaf 0 (solid)
2562                 if (p >= 0 && out->clusterindex >= 0)
2563                 {
2564                         if (p >= loadmodel->brushq1.num_compressedpvs)
2565                                 Con_Print("Mod_Q1BSP_LoadLeafs: invalid visofs\n");
2566                         else
2567                                 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);
2568                 }
2569
2570                 for (j = 0;j < 4;j++)
2571                         out->ambient_sound_level[j] = in->ambient_level[j];
2572
2573                 // FIXME: Insert caustics here
2574         }
2575 }
2576
2577 qboolean Mod_Q1BSP_CheckWaterAlphaSupport(void)
2578 {
2579         int i, j;
2580         mleaf_t *leaf;
2581         const unsigned char *pvs;
2582         // check all liquid leafs to see if they can see into empty leafs, if any
2583         // can we can assume this map supports r_wateralpha
2584         for (i = 0, leaf = loadmodel->brush.data_leafs;i < loadmodel->brush.num_leafs;i++, leaf++)
2585         {
2586                 if ((leaf->contents == CONTENTS_WATER || leaf->contents == CONTENTS_SLIME) && (leaf->clusterindex >= 0 && loadmodel->brush.data_pvsclusters))
2587                 {
2588                         pvs = loadmodel->brush.data_pvsclusters + leaf->clusterindex * loadmodel->brush.num_pvsclusterbytes;
2589                         for (j = 0;j < loadmodel->brush.num_leafs;j++)
2590                                 if (CHECKPVSBIT(pvs, loadmodel->brush.data_leafs[j].clusterindex) && loadmodel->brush.data_leafs[j].contents == CONTENTS_EMPTY)
2591                                         return true;
2592                 }
2593         }
2594         return false;
2595 }
2596
2597 static void Mod_Q1BSP_LoadClipnodes(lump_t *l, hullinfo_t *hullinfo)
2598 {
2599         dclipnode_t *in, *out;
2600         int                     i, count;
2601         hull_t          *hull;
2602
2603         in = (dclipnode_t *)(mod_base + l->fileofs);
2604         if (l->filelen % sizeof(*in))
2605                 Host_Error("Mod_Q1BSP_LoadClipnodes: funny lump size in %s",loadmodel->name);
2606         count = l->filelen / sizeof(*in);
2607         out = (dclipnode_t *)Mem_Alloc(loadmodel->mempool, count*sizeof(*out));
2608
2609         loadmodel->brushq1.clipnodes = out;
2610         loadmodel->brushq1.numclipnodes = count;
2611
2612         for (i = 1; i < hullinfo->numhulls; i++)
2613         {
2614                 hull = &loadmodel->brushq1.hulls[i];
2615                 hull->clipnodes = out;
2616                 hull->firstclipnode = 0;
2617                 hull->lastclipnode = count-1;
2618                 hull->planes = loadmodel->brush.data_planes;
2619                 hull->clip_mins[0] = hullinfo->hullsizes[i][0][0];
2620                 hull->clip_mins[1] = hullinfo->hullsizes[i][0][1];
2621                 hull->clip_mins[2] = hullinfo->hullsizes[i][0][2];
2622                 hull->clip_maxs[0] = hullinfo->hullsizes[i][1][0];
2623                 hull->clip_maxs[1] = hullinfo->hullsizes[i][1][1];
2624                 hull->clip_maxs[2] = hullinfo->hullsizes[i][1][2];
2625                 VectorSubtract(hull->clip_maxs, hull->clip_mins, hull->clip_size);
2626         }
2627
2628         for (i=0 ; i<count ; i++, out++, in++)
2629         {
2630                 out->planenum = LittleLong(in->planenum);
2631                 out->children[0] = LittleShort(in->children[0]);
2632                 out->children[1] = LittleShort(in->children[1]);
2633                 if (out->planenum < 0 || out->planenum >= loadmodel->brush.num_planes)
2634                         Host_Error("Corrupt clipping hull(out of range planenum)");
2635                 if (out->children[0] >= count || out->children[1] >= count)
2636                         Host_Error("Corrupt clipping hull(out of range child)");
2637         }
2638 }
2639
2640 //Duplicate the drawing hull structure as a clipping hull
2641 static void Mod_Q1BSP_MakeHull0(void)
2642 {
2643         mnode_t         *in;
2644         dclipnode_t *out;
2645         int                     i;
2646         hull_t          *hull;
2647
2648         hull = &loadmodel->brushq1.hulls[0];
2649
2650         in = loadmodel->brush.data_nodes;
2651         out = (dclipnode_t *)Mem_Alloc(loadmodel->mempool, loadmodel->brush.num_nodes * sizeof(dclipnode_t));
2652
2653         hull->clipnodes = out;
2654         hull->firstclipnode = 0;
2655         hull->lastclipnode = loadmodel->brush.num_nodes - 1;
2656         hull->planes = loadmodel->brush.data_planes;
2657
2658         for (i = 0;i < loadmodel->brush.num_nodes;i++, out++, in++)
2659         {
2660                 out->planenum = in->plane - loadmodel->brush.data_planes;
2661                 out->children[0] = in->children[0]->plane ? in->children[0] - loadmodel->brush.data_nodes : ((mleaf_t *)in->children[0])->contents;
2662                 out->children[1] = in->children[1]->plane ? in->children[1] - loadmodel->brush.data_nodes : ((mleaf_t *)in->children[1])->contents;
2663         }
2664 }
2665
2666 static void Mod_Q1BSP_LoadLeaffaces(lump_t *l)
2667 {
2668         int i, j;
2669         short *in;
2670
2671         in = (short *)(mod_base + l->fileofs);
2672         if (l->filelen % sizeof(*in))
2673                 Host_Error("Mod_Q1BSP_LoadLeaffaces: funny lump size in %s",loadmodel->name);
2674         loadmodel->brush.num_leafsurfaces = l->filelen / sizeof(*in);
2675         loadmodel->brush.data_leafsurfaces = (int *)Mem_Alloc(loadmodel->mempool, loadmodel->brush.num_leafsurfaces * sizeof(int));
2676
2677         for (i = 0;i < loadmodel->brush.num_leafsurfaces;i++)
2678         {
2679                 j = (unsigned) LittleShort(in[i]);
2680                 if (j >= loadmodel->num_surfaces)
2681                         Host_Error("Mod_Q1BSP_LoadLeaffaces: bad surface number");
2682                 loadmodel->brush.data_leafsurfaces[i] = j;
2683         }
2684 }
2685
2686 static void Mod_Q1BSP_LoadSurfedges(lump_t *l)
2687 {
2688         int             i;
2689         int             *in;
2690
2691         in = (int *)(mod_base + l->fileofs);
2692         if (l->filelen % sizeof(*in))
2693                 Host_Error("Mod_Q1BSP_LoadSurfedges: funny lump size in %s",loadmodel->name);
2694         loadmodel->brushq1.numsurfedges = l->filelen / sizeof(*in);
2695         loadmodel->brushq1.surfedges = (int *)Mem_Alloc(loadmodel->mempool, loadmodel->brushq1.numsurfedges * sizeof(int));
2696
2697         for (i = 0;i < loadmodel->brushq1.numsurfedges;i++)
2698                 loadmodel->brushq1.surfedges[i] = LittleLong(in[i]);
2699 }
2700
2701
2702 static void Mod_Q1BSP_LoadPlanes(lump_t *l)
2703 {
2704         int                     i;
2705         mplane_t        *out;
2706         dplane_t        *in;
2707
2708         in = (dplane_t *)(mod_base + l->fileofs);
2709         if (l->filelen % sizeof(*in))
2710                 Host_Error("Mod_Q1BSP_LoadPlanes: funny lump size in %s", loadmodel->name);
2711
2712         loadmodel->brush.num_planes = l->filelen / sizeof(*in);
2713         loadmodel->brush.data_planes = out = (mplane_t *)Mem_Alloc(loadmodel->mempool, loadmodel->brush.num_planes * sizeof(*out));
2714
2715         for (i = 0;i < loadmodel->brush.num_planes;i++, in++, out++)
2716         {
2717                 out->normal[0] = LittleFloat(in->normal[0]);
2718                 out->normal[1] = LittleFloat(in->normal[1]);
2719                 out->normal[2] = LittleFloat(in->normal[2]);
2720                 out->dist = LittleFloat(in->dist);
2721
2722                 PlaneClassify(out);
2723         }
2724 }
2725
2726 static void Mod_Q1BSP_LoadMapBrushes(void)
2727 {
2728 #if 0
2729 // unfinished
2730         int submodel, numbrushes;
2731         qboolean firstbrush;
2732         char *text, *maptext;
2733         char mapfilename[MAX_QPATH];
2734         FS_StripExtension (loadmodel->name, mapfilename, sizeof (mapfilename));
2735         strlcat (mapfilename, ".map", sizeof (mapfilename));
2736         maptext = (unsigned char*) FS_LoadFile(mapfilename, tempmempool, false, NULL);
2737         if (!maptext)
2738                 return;
2739         text = maptext;
2740         if (!COM_ParseToken_Simple(&data, false))
2741                 return; // error
2742         submodel = 0;
2743         for (;;)
2744         {
2745                 if (!COM_ParseToken_Simple(&data, false))
2746                         break;
2747                 if (com_token[0] != '{')
2748                         return; // error
2749                 // entity
2750                 firstbrush = true;
2751                 numbrushes = 0;
2752                 maxbrushes = 256;
2753                 brushes = Mem_Alloc(loadmodel->mempool, maxbrushes * sizeof(mbrush_t));
2754                 for (;;)
2755                 {
2756                         if (!COM_ParseToken_Simple(&data, false))
2757                                 return; // error
2758                         if (com_token[0] == '}')
2759                                 break; // end of entity
2760                         if (com_token[0] == '{')
2761                         {
2762                                 // brush
2763                                 if (firstbrush)
2764                                 {
2765                                         if (submodel)
2766                                         {
2767                                                 if (submodel > loadmodel->brush.numsubmodels)
2768                                                 {
2769                                                         Con_Printf("Mod_Q1BSP_LoadMapBrushes: .map has more submodels than .bsp!\n");
2770                                                         model = NULL;
2771                                                 }
2772                                                 else
2773                                                         model = loadmodel->brush.submodels[submodel];
2774                                         }
2775                                         else
2776                                                 model = loadmodel;
2777                                 }
2778                                 for (;;)
2779                                 {
2780                                         if (!COM_ParseToken_Simple(&data, false))
2781                                                 return; // error
2782                                         if (com_token[0] == '}')
2783                                                 break; // end of brush
2784                                         // each brush face should be this format:
2785                                         // ( x y z ) ( x y z ) ( x y z ) texture scroll_s scroll_t rotateangle scale_s scale_t
2786                                         // FIXME: support hl .map format
2787                                         for (pointnum = 0;pointnum < 3;pointnum++)
2788                                         {
2789                                                 COM_ParseToken_Simple(&data, false);
2790                                                 for (componentnum = 0;componentnum < 3;componentnum++)
2791                                                 {
2792                                                         COM_ParseToken_Simple(&data, false);
2793                                                         point[pointnum][componentnum] = atof(com_token);
2794                                                 }
2795                                                 COM_ParseToken_Simple(&data, false);
2796                                         }
2797                                         COM_ParseToken_Simple(&data, false);
2798                                         strlcpy(facetexture, com_token, sizeof(facetexture));
2799                                         COM_ParseToken_Simple(&data, false);
2800                                         //scroll_s = atof(com_token);
2801                                         COM_ParseToken_Simple(&data, false);
2802                                         //scroll_t = atof(com_token);
2803                                         COM_ParseToken_Simple(&data, false);
2804                                         //rotate = atof(com_token);
2805                                         COM_ParseToken_Simple(&data, false);
2806                                         //scale_s = atof(com_token);
2807                                         COM_ParseToken_Simple(&data, false);
2808                                         //scale_t = atof(com_token);
2809                                         TriangleNormal(point[0], point[1], point[2], planenormal);
2810                                         VectorNormalizeDouble(planenormal);
2811                                         planedist = DotProduct(point[0], planenormal);
2812                                         //ChooseTexturePlane(planenormal, texturevector[0], texturevector[1]);
2813                                 }
2814                                 continue;
2815                         }
2816                 }
2817         }
2818 #endif
2819 }
2820
2821
2822 #define MAX_PORTALPOINTS 64
2823
2824 typedef struct portal_s
2825 {
2826         mplane_t plane;
2827         mnode_t *nodes[2];              // [0] = front side of plane
2828         struct portal_s *next[2];
2829         int numpoints;
2830         double points[3*MAX_PORTALPOINTS];
2831         struct portal_s *chain; // all portals are linked into a list
2832 }
2833 portal_t;
2834
2835 static portal_t *portalchain;
2836
2837 /*
2838 ===========
2839 AllocPortal
2840 ===========
2841 */
2842 static portal_t *AllocPortal(void)
2843 {
2844         portal_t *p;
2845         p = (portal_t *)Mem_Alloc(loadmodel->mempool, sizeof(portal_t));
2846         p->chain = portalchain;
2847         portalchain = p;
2848         return p;
2849 }
2850
2851 static void FreePortal(portal_t *p)
2852 {
2853         Mem_Free(p);
2854 }
2855
2856 static void Mod_Q1BSP_RecursiveRecalcNodeBBox(mnode_t *node)
2857 {
2858         // process only nodes (leafs already had their box calculated)
2859         if (!node->plane)
2860                 return;
2861
2862         // calculate children first
2863         Mod_Q1BSP_RecursiveRecalcNodeBBox(node->children[0]);
2864         Mod_Q1BSP_RecursiveRecalcNodeBBox(node->children[1]);
2865
2866         // make combined bounding box from children
2867         node->mins[0] = min(node->children[0]->mins[0], node->children[1]->mins[0]);
2868         node->mins[1] = min(node->children[0]->mins[1], node->children[1]->mins[1]);
2869         node->mins[2] = min(node->children[0]->mins[2], node->children[1]->mins[2]);
2870         node->maxs[0] = max(node->children[0]->maxs[0], node->children[1]->maxs[0]);
2871         node->maxs[1] = max(node->children[0]->maxs[1], node->children[1]->maxs[1]);
2872         node->maxs[2] = max(node->children[0]->maxs[2], node->children[1]->maxs[2]);
2873 }
2874
2875 static void Mod_Q1BSP_FinalizePortals(void)
2876 {
2877         int i, j, numportals, numpoints;
2878         portal_t *p, *pnext;
2879         mportal_t *portal;
2880         mvertex_t *point;
2881         mleaf_t *leaf, *endleaf;
2882
2883         // tally up portal and point counts and recalculate bounding boxes for all
2884         // leafs (because qbsp is very sloppy)
2885         leaf = loadmodel->brush.data_leafs;
2886         endleaf = leaf + loadmodel->brush.num_leafs;
2887         for (;leaf < endleaf;leaf++)
2888         {
2889                 VectorSet(leaf->mins,  2000000000,  2000000000,  2000000000);
2890                 VectorSet(leaf->maxs, -2000000000, -2000000000, -2000000000);
2891         }
2892         p = portalchain;
2893         numportals = 0;
2894         numpoints = 0;
2895         while (p)
2896         {
2897                 // note: this check must match the one below or it will usually corrupt memory
2898                 // 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
2899                 if (p->numpoints >= 3 && p->nodes[0] != p->nodes[1] && ((mleaf_t *)p->nodes[0])->clusterindex >= 0 && ((mleaf_t *)p->nodes[1])->clusterindex >= 0)
2900                 {
2901                         numportals += 2;
2902                         numpoints += p->numpoints * 2;
2903                 }
2904                 p = p->chain;
2905         }
2906         loadmodel->brush.data_portals = (mportal_t *)Mem_Alloc(loadmodel->mempool, numportals * sizeof(mportal_t) + numpoints * sizeof(mvertex_t));
2907         loadmodel->brush.num_portals = numportals;
2908         loadmodel->brush.data_portalpoints = (mvertex_t *)((unsigned char *) loadmodel->brush.data_portals + numportals * sizeof(mportal_t));
2909         loadmodel->brush.num_portalpoints = numpoints;
2910         // clear all leaf portal chains
2911         for (i = 0;i < loadmodel->brush.num_leafs;i++)
2912                 loadmodel->brush.data_leafs[i].portals = NULL;
2913         // process all portals in the global portal chain, while freeing them
2914         portal = loadmodel->brush.data_portals;
2915         point = loadmodel->brush.data_portalpoints;
2916         p = portalchain;
2917         portalchain = NULL;
2918         while (p)
2919         {
2920                 pnext = p->chain;
2921
2922                 if (p->numpoints >= 3 && p->nodes[0] != p->nodes[1])
2923                 {
2924                         // note: this check must match the one above or it will usually corrupt memory
2925                         // 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
2926                         if (((mleaf_t *)p->nodes[0])->clusterindex >= 0 && ((mleaf_t *)p->nodes[1])->clusterindex >= 0)
2927                         {
2928                                 // first make the back to front portal(forward portal)
2929                                 portal->points = point;
2930                                 portal->numpoints = p->numpoints;
2931                                 portal->plane.dist = p->plane.dist;
2932                                 VectorCopy(p->plane.normal, portal->plane.normal);
2933                                 portal->here = (mleaf_t *)p->nodes[1];
2934                                 portal->past = (mleaf_t *)p->nodes[0];
2935                                 // copy points
2936                                 for (j = 0;j < portal->numpoints;j++)
2937                                 {
2938                                         VectorCopy(p->points + j*3, point->position);
2939                                         point++;
2940                                 }
2941                                 BoxFromPoints(portal->mins, portal->maxs, portal->numpoints, portal->points->position);
2942                                 PlaneClassify(&portal->plane);
2943
2944                                 // link into leaf's portal chain
2945                                 portal->next = portal->here->portals;
2946                                 portal->here->portals = portal;
2947
2948                                 // advance to next portal
2949                                 portal++;
2950
2951                                 // then make the front to back portal(backward portal)
2952                                 portal->points = point;
2953                                 portal->numpoints = p->numpoints;
2954                                 portal->plane.dist = -p->plane.dist;
2955                                 VectorNegate(p->plane.normal, portal->plane.normal);
2956                                 portal->here = (mleaf_t *)p->nodes[0];
2957                                 portal->past = (mleaf_t *)p->nodes[1];
2958                                 // copy points
2959                                 for (j = portal->numpoints - 1;j >= 0;j--)
2960                                 {
2961                                         VectorCopy(p->points + j*3, point->position);
2962                                         point++;
2963                                 }
2964                                 BoxFromPoints(portal->mins, portal->maxs, portal->numpoints, portal->points->position);
2965                                 PlaneClassify(&portal->plane);
2966
2967                                 // link into leaf's portal chain
2968                                 portal->next = portal->here->portals;
2969                                 portal->here->portals = portal;
2970
2971                                 // advance to next portal
2972                                 portal++;
2973                         }
2974                         // add the portal's polygon points to the leaf bounding boxes
2975                         for (i = 0;i < 2;i++)
2976                         {
2977                                 leaf = (mleaf_t *)p->nodes[i];
2978                                 for (j = 0;j < p->numpoints;j++)
2979                                 {
2980                                         if (leaf->mins[0] > p->points[j*3+0]) leaf->mins[0] = p->points[j*3+0];
2981                                         if (leaf->mins[1] > p->points[j*3+1]) leaf->mins[1] = p->points[j*3+1];
2982                                         if (leaf->mins[2] > p->points[j*3+2]) leaf->mins[2] = p->points[j*3+2];
2983                                         if (leaf->maxs[0] < p->points[j*3+0]) leaf->maxs[0] = p->points[j*3+0];
2984                                         if (leaf->maxs[1] < p->points[j*3+1]) leaf->maxs[1] = p->points[j*3+1];
2985                                         if (leaf->maxs[2] < p->points[j*3+2]) leaf->maxs[2] = p->points[j*3+2];
2986                                 }
2987                         }
2988                 }
2989                 FreePortal(p);
2990                 p = pnext;
2991         }
2992         // now recalculate the node bounding boxes from the leafs
2993         Mod_Q1BSP_RecursiveRecalcNodeBBox(loadmodel->brush.data_nodes);
2994 }
2995
2996 /*
2997 =============
2998 AddPortalToNodes
2999 =============
3000 */
3001 static void AddPortalToNodes(portal_t *p, mnode_t *front, mnode_t *back)
3002 {
3003         if (!front)
3004                 Host_Error("AddPortalToNodes: NULL front node");
3005         if (!back)
3006                 Host_Error("AddPortalToNodes: NULL back node");
3007         if (p->nodes[0] || p->nodes[1])
3008                 Host_Error("AddPortalToNodes: already included");
3009         // 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
3010
3011         p->nodes[0] = front;
3012         p->next[0] = (portal_t *)front->portals;
3013         front->portals = (mportal_t *)p;
3014
3015         p->nodes[1] = back;
3016         p->next[1] = (portal_t *)back->portals;
3017         back->portals = (mportal_t *)p;
3018 }
3019
3020 /*
3021 =============
3022 RemovePortalFromNode
3023 =============
3024 */
3025 static void RemovePortalFromNodes(portal_t *portal)
3026 {
3027         int i;
3028         mnode_t *node;
3029         void **portalpointer;
3030         portal_t *t;
3031         for (i = 0;i < 2;i++)
3032         {
3033                 node = portal->nodes[i];
3034
3035                 portalpointer = (void **) &node->portals;
3036                 while (1)
3037                 {
3038                         t = (portal_t *)*portalpointer;
3039                         if (!t)
3040                                 Host_Error("RemovePortalFromNodes: portal not in leaf");
3041
3042                         if (t == portal)
3043                         {
3044                                 if (portal->nodes[0] == node)
3045                                 {
3046                                         *portalpointer = portal->next[0];
3047                                         portal->nodes[0] = NULL;
3048                                 }
3049                                 else if (portal->nodes[1] == node)
3050                                 {
3051                                         *portalpointer = portal->next[1];
3052                                         portal->nodes[1] = NULL;
3053                                 }
3054                                 else
3055                                         Host_Error("RemovePortalFromNodes: portal not bounding leaf");
3056                                 break;
3057                         }
3058
3059                         if (t->nodes[0] == node)
3060                                 portalpointer = (void **) &t->next[0];
3061                         else if (t->nodes[1] == node)
3062                                 portalpointer = (void **) &t->next[1];
3063                         else
3064                                 Host_Error("RemovePortalFromNodes: portal not bounding leaf");
3065                 }
3066         }
3067 }
3068
3069 #define PORTAL_DIST_EPSILON (1.0 / 32.0)
3070 static void Mod_Q1BSP_RecursiveNodePortals(mnode_t *node)
3071 {
3072         int i, side;
3073         mnode_t *front, *back, *other_node;
3074         mplane_t clipplane, *plane;
3075         portal_t *portal, *nextportal, *nodeportal, *splitportal, *temp;
3076         int numfrontpoints, numbackpoints;
3077         double frontpoints[3*MAX_PORTALPOINTS], backpoints[3*MAX_PORTALPOINTS];
3078
3079         // if a leaf, we're done
3080         if (!node->plane)
3081                 return;
3082
3083         plane = node->plane;
3084
3085         front = node->children[0];
3086         back = node->children[1];
3087         if (front == back)
3088                 Host_Error("Mod_Q1BSP_RecursiveNodePortals: corrupt node hierarchy");
3089
3090         // create the new portal by generating a polygon for the node plane,
3091         // and clipping it by all of the other portals(which came from nodes above this one)
3092         nodeportal = AllocPortal();
3093         nodeportal->plane = *plane;
3094
3095         // 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)
3096         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);
3097         nodeportal->numpoints = 4;
3098         side = 0;       // shut up compiler warning
3099         for (portal = (portal_t *)node->portals;portal;portal = portal->next[side])
3100         {
3101                 clipplane = portal->plane;
3102                 if (portal->nodes[0] == portal->nodes[1])
3103                         Host_Error("Mod_Q1BSP_RecursiveNodePortals: portal has same node on both sides(1)");
3104                 if (portal->nodes[0] == node)
3105                         side = 0;
3106                 else if (portal->nodes[1] == node)
3107                 {
3108                         clipplane.dist = -clipplane.dist;
3109                         VectorNegate(clipplane.normal, clipplane.normal);
3110                         side = 1;
3111                 }
3112                 else
3113                         Host_Error("Mod_Q1BSP_RecursiveNodePortals: mislinked portal");
3114
3115                 for (i = 0;i < nodeportal->numpoints*3;i++)
3116                         frontpoints[i] = nodeportal->points[i];
3117                 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);
3118                 if (nodeportal->numpoints <= 0 || nodeportal->numpoints >= MAX_PORTALPOINTS)
3119                         break;
3120         }
3121
3122         if (nodeportal->numpoints < 3)
3123         {
3124                 Con_Print("Mod_Q1BSP_RecursiveNodePortals: WARNING: new portal was clipped away\n");
3125                 nodeportal->numpoints = 0;
3126         }
3127         else if (nodeportal->numpoints >= MAX_PORTALPOINTS)
3128         {
3129                 Con_Print("Mod_Q1BSP_RecursiveNodePortals: WARNING: new portal has too many points\n");
3130                 nodeportal->numpoints = 0;
3131         }
3132
3133         AddPortalToNodes(nodeportal, front, back);
3134
3135         // split the portals of this node along this node's plane and assign them to the children of this node
3136         // (migrating the portals downward through the tree)
3137         for (portal = (portal_t *)node->portals;portal;portal = nextportal)
3138         {
3139                 if (portal->nodes[0] == portal->nodes[1])
3140                         Host_Error("Mod_Q1BSP_RecursiveNodePortals: portal has same node on both sides(2)");
3141                 if (portal->nodes[0] == node)
3142                         side = 0;
3143                 else if (portal->nodes[1] == node)
3144                         side = 1;
3145                 else
3146                         Host_Error("Mod_Q1BSP_RecursiveNodePortals: mislinked portal");
3147                 nextportal = portal->next[side];
3148                 if (!portal->numpoints)
3149                         continue;
3150
3151                 other_node = portal->nodes[!side];
3152                 RemovePortalFromNodes(portal);
3153
3154                 // cut the portal into two portals, one on each side of the node plane
3155                 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);
3156
3157                 if (!numfrontpoints)
3158                 {
3159                         if (side == 0)
3160                                 AddPortalToNodes(portal, back, other_node);
3161                         else
3162                                 AddPortalToNodes(portal, other_node, back);
3163                         continue;
3164                 }
3165                 if (!numbackpoints)
3166                 {
3167                         if (side == 0)
3168                                 AddPortalToNodes(portal, front, other_node);
3169                         else
3170                                 AddPortalToNodes(portal, other_node, front);
3171                         continue;
3172                 }
3173
3174                 // the portal is split
3175                 splitportal = AllocPortal();
3176                 temp = splitportal->chain;
3177                 *splitportal = *portal;
3178                 splitportal->chain = temp;
3179                 for (i = 0;i < numbackpoints*3;i++)
3180                         splitportal->points[i] = backpoints[i];
3181                 splitportal->numpoints = numbackpoints;
3182                 for (i = 0;i < numfrontpoints*3;i++)
3183                         portal->points[i] = frontpoints[i];
3184                 portal->numpoints = numfrontpoints;
3185
3186                 if (side == 0)
3187                 {
3188                         AddPortalToNodes(portal, front, other_node);
3189                         AddPortalToNodes(splitportal, back, other_node);
3190                 }
3191                 else
3192                 {
3193                         AddPortalToNodes(portal, other_node, front);
3194                         AddPortalToNodes(splitportal, other_node, back);
3195                 }
3196         }
3197
3198         Mod_Q1BSP_RecursiveNodePortals(front);
3199         Mod_Q1BSP_RecursiveNodePortals(back);
3200 }
3201
3202 static void Mod_Q1BSP_MakePortals(void)
3203 {
3204         portalchain = NULL;
3205         Mod_Q1BSP_RecursiveNodePortals(loadmodel->brush.data_nodes);
3206         Mod_Q1BSP_FinalizePortals();
3207 }
3208
3209 static void Mod_Q1BSP_BuildLightmapUpdateChains(mempool_t *mempool, model_t *model)
3210 {
3211         int i, j, stylecounts[256], totalcount, remapstyles[256];
3212         msurface_t *surface;
3213         memset(stylecounts, 0, sizeof(stylecounts));
3214         for (i = 0;i < model->nummodelsurfaces;i++)
3215         {
3216                 surface = model->data_surfaces + model->firstmodelsurface + i;
3217                 for (j = 0;j < MAXLIGHTMAPS;j++)
3218                         stylecounts[surface->lightmapinfo->styles[j]]++;
3219         }
3220         totalcount = 0;
3221         model->brushq1.light_styles = 0;
3222         for (i = 0;i < 255;i++)
3223         {
3224                 if (stylecounts[i])
3225                 {
3226                         remapstyles[i] = model->brushq1.light_styles++;
3227                         totalcount += stylecounts[i] + 1;
3228                 }
3229         }
3230         if (!totalcount)
3231                 return;
3232         model->brushq1.light_style = (unsigned char *)Mem_Alloc(mempool, model->brushq1.light_styles * sizeof(unsigned char));
3233         model->brushq1.light_stylevalue = (int *)Mem_Alloc(mempool, model->brushq1.light_styles * sizeof(int));
3234         model->brushq1.light_styleupdatechains = (msurface_t ***)Mem_Alloc(mempool, model->brushq1.light_styles * sizeof(msurface_t **));
3235         model->brushq1.light_styleupdatechainsbuffer = (msurface_t **)Mem_Alloc(mempool, totalcount * sizeof(msurface_t *));
3236         model->brushq1.light_styles = 0;
3237         for (i = 0;i < 255;i++)
3238                 if (stylecounts[i])
3239                         model->brushq1.light_style[model->brushq1.light_styles++] = i;
3240         j = 0;
3241         for (i = 0;i < model->brushq1.light_styles;i++)
3242         {
3243                 model->brushq1.light_styleupdatechains[i] = model->brushq1.light_styleupdatechainsbuffer + j;
3244                 j += stylecounts[model->brushq1.light_style[i]] + 1;
3245         }
3246         for (i = 0;i < model->nummodelsurfaces;i++)
3247         {
3248                 surface = model->data_surfaces + model->firstmodelsurface + i;
3249                 for (j = 0;j < MAXLIGHTMAPS;j++)
3250                         if (surface->lightmapinfo->styles[j] != 255)
3251                                 *model->brushq1.light_styleupdatechains[remapstyles[surface->lightmapinfo->styles[j]]]++ = surface;
3252         }
3253         j = 0;
3254         for (i = 0;i < model->brushq1.light_styles;i++)
3255         {
3256                 *model->brushq1.light_styleupdatechains[i] = NULL;
3257                 model->brushq1.light_styleupdatechains[i] = model->brushq1.light_styleupdatechainsbuffer + j;
3258                 j += stylecounts[model->brushq1.light_style[i]] + 1;
3259         }
3260 }
3261
3262 //Returns PVS data for a given point
3263 //(note: can return NULL)
3264 static unsigned char *Mod_Q1BSP_GetPVS(model_t *model, const vec3_t p)
3265 {
3266         mnode_t *node;
3267         node = model->brush.data_nodes;
3268         while (node->plane)
3269                 node = node->children[(node->plane->type < 3 ? p[node->plane->type] : DotProduct(p,node->plane->normal)) < node->plane->dist];
3270         if (((mleaf_t *)node)->clusterindex >= 0)
3271                 return model->brush.data_pvsclusters + ((mleaf_t *)node)->clusterindex * model->brush.num_pvsclusterbytes;
3272         else
3273                 return NULL;
3274 }
3275
3276 static void Mod_Q1BSP_FatPVS_RecursiveBSPNode(model_t *model, const vec3_t org, vec_t radius, unsigned char *pvsbuffer, int pvsbytes, mnode_t *node)
3277 {
3278         while (node->plane)
3279         {
3280                 float d = PlaneDiff(org, node->plane);
3281                 if (d > radius)
3282                         node = node->children[0];
3283                 else if (d < -radius)
3284                         node = node->children[1];
3285                 else
3286                 {
3287                         // go down both sides
3288                         Mod_Q1BSP_FatPVS_RecursiveBSPNode(model, org, radius, pvsbuffer, pvsbytes, node->children[0]);
3289                         node = node->children[1];
3290                 }
3291         }
3292         // if this leaf is in a cluster, accumulate the pvs bits
3293         if (((mleaf_t *)node)->clusterindex >= 0)
3294         {
3295                 int i;
3296                 unsigned char *pvs = model->brush.data_pvsclusters + ((mleaf_t *)node)->clusterindex * model->brush.num_pvsclusterbytes;
3297                 for (i = 0;i < pvsbytes;i++)
3298                         pvsbuffer[i] |= pvs[i];
3299         }
3300 }
3301
3302 //Calculates a PVS that is the inclusive or of all leafs within radius pixels
3303 //of the given point.
3304 static int Mod_Q1BSP_FatPVS(model_t *model, const vec3_t org, vec_t radius, unsigned char *pvsbuffer, int pvsbufferlength)
3305 {
3306         int bytes = model->brush.num_pvsclusterbytes;
3307         bytes = min(bytes, pvsbufferlength);
3308         if (r_novis.integer || !model->brush.num_pvsclusters || !Mod_Q1BSP_GetPVS(model, org))
3309         {
3310                 memset(pvsbuffer, 0xFF, bytes);
3311                 return bytes;
3312         }
3313         memset(pvsbuffer, 0, bytes);
3314         Mod_Q1BSP_FatPVS_RecursiveBSPNode(model, org, radius, pvsbuffer, bytes, model->brush.data_nodes);
3315         return bytes;
3316 }
3317
3318 static void Mod_Q1BSP_RoundUpToHullSize(model_t *cmodel, const vec3_t inmins, const vec3_t inmaxs, vec3_t outmins, vec3_t outmaxs)
3319 {
3320         vec3_t size;
3321         const hull_t *hull;
3322
3323         VectorSubtract(inmaxs, inmins, size);
3324         if (cmodel->brush.ismcbsp)
3325         {
3326                 if (size[0] < 3)
3327                         hull = &cmodel->brushq1.hulls[0]; // 0x0x0
3328                 else if (size[2] < 48) // pick the nearest of 40 or 56
3329                         hull = &cmodel->brushq1.hulls[2]; // 16x16x40
3330                 else
3331                         hull = &cmodel->brushq1.hulls[1]; // 16x16x56
3332         }
3333         else if (cmodel->brush.ishlbsp)
3334         {
3335                 if (size[0] < 3)
3336                         hull = &cmodel->brushq1.hulls[0]; // 0x0x0
3337                 else if (size[0] <= 32)
3338                 {
3339                         if (size[2] < 54) // pick the nearest of 36 or 72
3340                                 hull = &cmodel->brushq1.hulls[3]; // 32x32x36
3341                         else
3342                                 hull = &cmodel->brushq1.hulls[1]; // 32x32x72
3343                 }
3344                 else
3345                         hull = &cmodel->brushq1.hulls[2]; // 64x64x64
3346         }
3347         else
3348         {
3349                 if (size[0] < 3)
3350                         hull = &cmodel->brushq1.hulls[0]; // 0x0x0
3351                 else if (size[0] <= 32)
3352                         hull = &cmodel->brushq1.hulls[1]; // 32x32x56
3353                 else
3354                         hull = &cmodel->brushq1.hulls[2]; // 64x64x88
3355         }
3356         VectorCopy(inmins, outmins);
3357         VectorAdd(inmins, hull->clip_size, outmaxs);
3358 }
3359
3360 void Mod_Q1BSP_Load(model_t *mod, void *buffer, void *bufferend)
3361 {
3362         int i, j, k;
3363         dheader_t *header;
3364         dmodel_t *bm;
3365         mempool_t *mainmempool;
3366         float dist, modelyawradius, modelradius, *vec;
3367         msurface_t *surface;
3368         int numshadowmeshtriangles;
3369         dheader_t _header;
3370         hullinfo_t hullinfo;
3371
3372         mod->modeldatatypestring = "Q1BSP";
3373
3374         mod->type = mod_brushq1;
3375
3376         if (!memcmp (buffer, "MCBSPpad", 8))
3377         {
3378                 unsigned char   *index;
3379
3380                 mod->brush.ismcbsp = true;
3381                 mod->brush.ishlbsp = false;
3382
3383                 mod_base = (unsigned char*)buffer;
3384
3385                 index = mod_base;
3386                 index += 8;
3387                 i = SB_ReadInt (&index);
3388                 if (i != MCBSPVERSION)
3389                         Host_Error("Mod_Q1BSP_Load: %s has wrong version number(%i should be %i)", mod->name, i, MCBSPVERSION);
3390
3391         // read hull info
3392                 hullinfo.numhulls = LittleLong(*(int*)index); index += 4;
3393                 hullinfo.filehulls = hullinfo.numhulls;
3394                 VectorClear (hullinfo.hullsizes[0][0]);
3395                 VectorClear (hullinfo.hullsizes[0][1]);
3396                 for (i = 1; i < hullinfo.numhulls; i++)
3397                 {
3398                         hullinfo.hullsizes[i][0][0] = SB_ReadFloat (&index);
3399                         hullinfo.hullsizes[i][0][1] = SB_ReadFloat (&index);
3400                         hullinfo.hullsizes[i][0][2] = SB_ReadFloat (&index);
3401                         hullinfo.hullsizes[i][1][0] = SB_ReadFloat (&index);
3402                         hullinfo.hullsizes[i][1][1] = SB_ReadFloat (&index);
3403                         hullinfo.hullsizes[i][1][2] = SB_ReadFloat (&index);
3404                 }
3405
3406         // read lumps
3407                 _header.version = 0;
3408                 for (i = 0; i < HEADER_LUMPS; i++)
3409                 {
3410                         _header.lumps[i].fileofs = SB_ReadInt (&index);
3411                         _header.lumps[i].filelen = SB_ReadInt (&index);
3412                 }
3413
3414                 header = &_header;
3415         }
3416         else
3417         {
3418                 header = (dheader_t *)buffer;
3419
3420                 i = LittleLong(header->version);
3421                 if (i != BSPVERSION && i != 30)
3422                         Host_Error("Mod_Q1BSP_Load: %s has wrong version number(%i should be %i(Quake) or 30(HalfLife)", mod->name, i, BSPVERSION);
3423                 mod->brush.ishlbsp = i == 30;
3424                 mod->brush.ismcbsp = false;
3425
3426         // fill in hull info
3427                 VectorClear (hullinfo.hullsizes[0][0]);
3428                 VectorClear (hullinfo.hullsizes[0][1]);
3429                 if (mod->brush.ishlbsp)
3430                 {
3431                         mod->modeldatatypestring = "HLBSP";
3432
3433                         hullinfo.numhulls = 4;
3434                         hullinfo.filehulls = 4;
3435                         VectorSet (hullinfo.hullsizes[1][0], -16, -16, -36);
3436                         VectorSet (hullinfo.hullsizes[1][1], 16, 16, 36);
3437                         VectorSet (hullinfo.hullsizes[2][0], -32, -32, -32);
3438                         VectorSet (hullinfo.hullsizes[2][1], 32, 32, 32);
3439                         VectorSet (hullinfo.hullsizes[3][0], -16, -16, -18);
3440                         VectorSet (hullinfo.hullsizes[3][1], 16, 16, 18);
3441                 }
3442                 else
3443                 {
3444                         hullinfo.numhulls = 3;
3445                         hullinfo.filehulls = 4;
3446                         VectorSet (hullinfo.hullsizes[1][0], -16, -16, -24);
3447                         VectorSet (hullinfo.hullsizes[1][1], 16, 16, 32);
3448                         VectorSet (hullinfo.hullsizes[2][0], -32, -32, -24);
3449                         VectorSet (hullinfo.hullsizes[2][1], 32, 32, 64);
3450                 }
3451
3452         // read lumps
3453                 mod_base = (unsigned char*)buffer;
3454                 for (i = 0; i < HEADER_LUMPS; i++)
3455                 {
3456                         header->lumps[i].fileofs = LittleLong(header->lumps[i].fileofs);
3457                         header->lumps[i].filelen = LittleLong(header->lumps[i].filelen);
3458                 }
3459         }
3460
3461         mod->soundfromcenter = true;
3462         mod->TraceBox = Mod_Q1BSP_TraceBox;
3463         mod->brush.TraceLineOfSight = Mod_Q1BSP_TraceLineOfSight;
3464         mod->brush.SuperContentsFromNativeContents = Mod_Q1BSP_SuperContentsFromNativeContents;
3465         mod->brush.NativeContentsFromSuperContents = Mod_Q1BSP_NativeContentsFromSuperContents;
3466         mod->brush.GetPVS = Mod_Q1BSP_GetPVS;
3467         mod->brush.FatPVS = Mod_Q1BSP_FatPVS;
3468         mod->brush.BoxTouchingPVS = Mod_Q1BSP_BoxTouchingPVS;
3469         mod->brush.BoxTouchingLeafPVS = Mod_Q1BSP_BoxTouchingLeafPVS;
3470         mod->brush.BoxTouchingVisibleLeafs = Mod_Q1BSP_BoxTouchingVisibleLeafs;
3471         mod->brush.FindBoxClusters = Mod_Q1BSP_FindBoxClusters;
3472         mod->brush.LightPoint = Mod_Q1BSP_LightPoint;
3473         mod->brush.FindNonSolidLocation = Mod_Q1BSP_FindNonSolidLocation;
3474         mod->brush.AmbientSoundLevelsForPoint = Mod_Q1BSP_AmbientSoundLevelsForPoint;
3475         mod->brush.RoundUpToHullSize = Mod_Q1BSP_RoundUpToHullSize;
3476         mod->brush.PointInLeaf = Mod_Q1BSP_PointInLeaf;
3477
3478         if (loadmodel->isworldmodel)
3479         {
3480                 Cvar_SetValue("halflifebsp", mod->brush.ishlbsp);
3481                 Cvar_SetValue("mcbsp", mod->brush.ismcbsp);
3482         }
3483
3484 // load into heap
3485
3486         // store which lightmap format to use
3487         mod->brushq1.lightmaprgba = r_lightmaprgba.integer;
3488
3489         mod->brush.qw_md4sum = 0;
3490         mod->brush.qw_md4sum2 = 0;
3491         for (i = 0;i < HEADER_LUMPS;i++)
3492         {
3493                 if (i == LUMP_ENTITIES)
3494                         continue;
3495                 mod->brush.qw_md4sum ^= LittleLong(Com_BlockChecksum(mod_base + header->lumps[i].fileofs, header->lumps[i].filelen));
3496                 if (i == LUMP_VISIBILITY || i == LUMP_LEAFS || i == LUMP_NODES)
3497                         continue;
3498                 mod->brush.qw_md4sum2 ^= LittleLong(Com_BlockChecksum(mod_base + header->lumps[i].fileofs, header->lumps[i].filelen));
3499         }
3500
3501         Mod_Q1BSP_LoadEntities(&header->lumps[LUMP_ENTITIES]);
3502         Mod_Q1BSP_LoadVertexes(&header->lumps[LUMP_VERTEXES]);
3503         Mod_Q1BSP_LoadEdges(&header->lumps[LUMP_EDGES]);
3504         Mod_Q1BSP_LoadSurfedges(&header->lumps[LUMP_SURFEDGES]);
3505         Mod_Q1BSP_LoadTextures(&header->lumps[LUMP_TEXTURES]);
3506         Mod_Q1BSP_LoadLighting(&header->lumps[LUMP_LIGHTING]);
3507         Mod_Q1BSP_LoadPlanes(&header->lumps[LUMP_PLANES]);
3508         Mod_Q1BSP_LoadTexinfo(&header->lumps[LUMP_TEXINFO]);
3509         Mod_Q1BSP_LoadFaces(&header->lumps[LUMP_FACES]);
3510         Mod_Q1BSP_LoadLeaffaces(&header->lumps[LUMP_MARKSURFACES]);
3511         Mod_Q1BSP_LoadVisibility(&header->lumps[LUMP_VISIBILITY]);
3512         // load submodels before leafs because they contain the number of vis leafs
3513         Mod_Q1BSP_LoadSubmodels(&header->lumps[LUMP_MODELS], &hullinfo);
3514         Mod_Q1BSP_LoadLeafs(&header->lumps[LUMP_LEAFS]);
3515         Mod_Q1BSP_LoadNodes(&header->lumps[LUMP_NODES]);
3516         Mod_Q1BSP_LoadClipnodes(&header->lumps[LUMP_CLIPNODES], &hullinfo);
3517
3518         // check if the map supports transparent water rendering
3519         loadmodel->brush.supportwateralpha = Mod_Q1BSP_CheckWaterAlphaSupport();
3520
3521         if (mod->brushq1.data_compressedpvs)
3522                 Mem_Free(mod->brushq1.data_compressedpvs);
3523         mod->brushq1.data_compressedpvs = NULL;
3524         mod->brushq1.num_compressedpvs = 0;
3525
3526         Mod_Q1BSP_MakeHull0();
3527         Mod_Q1BSP_MakePortals();
3528
3529         mod->numframes = 2;             // regular and alternate animation
3530         mod->numskins = 1;
3531
3532         mainmempool = mod->mempool;
3533
3534         // make a single combined shadow mesh to allow optimized shadow volume creation
3535         numshadowmeshtriangles = 0;
3536         for (j = 0, surface = loadmodel->data_surfaces;j < loadmodel->num_surfaces;j++, surface++)
3537         {
3538                 surface->num_firstshadowmeshtriangle = numshadowmeshtriangles;
3539                 numshadowmeshtriangles += surface->num_triangles;
3540         }
3541         loadmodel->brush.shadowmesh = Mod_ShadowMesh_Begin(loadmodel->mempool, numshadowmeshtriangles * 3, numshadowmeshtriangles, NULL, NULL, NULL, false, false, true);
3542         for (j = 0, surface = loadmodel->data_surfaces;j < loadmodel->num_surfaces;j++, surface++)
3543                 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));
3544         loadmodel->brush.shadowmesh = Mod_ShadowMesh_Finish(loadmodel->mempool, loadmodel->brush.shadowmesh, false, true, false);
3545         Mod_BuildTriangleNeighbors(loadmodel->brush.shadowmesh->neighbor3i, loadmodel->brush.shadowmesh->element3i, loadmodel->brush.shadowmesh->numtriangles);
3546
3547         if (loadmodel->brush.numsubmodels)
3548                 loadmodel->brush.submodels = (model_t **)Mem_Alloc(loadmodel->mempool, loadmodel->brush.numsubmodels * sizeof(model_t *));
3549
3550         if (loadmodel->isworldmodel)
3551         {
3552                 // clear out any stale submodels or worldmodels lying around
3553                 // if we did this clear before now, an error might abort loading and
3554                 // leave things in a bad state
3555                 Mod_RemoveStaleWorldModels(loadmodel);
3556         }
3557
3558         // LordHavoc: to clear the fog around the original quake submodel code, I
3559         // will explain:
3560         // first of all, some background info on the submodels:
3561         // model 0 is the map model (the world, named maps/e1m1.bsp for example)
3562         // model 1 and higher are submodels (doors and the like, named *1, *2, etc)
3563         // now the weird for loop itself:
3564         // the loop functions in an odd way, on each iteration it sets up the
3565         // current 'mod' model (which despite the confusing code IS the model of
3566         // the number i), at the end of the loop it duplicates the model to become
3567         // the next submodel, and loops back to set up the new submodel.
3568
3569         // LordHavoc: now the explanation of my sane way (which works identically):
3570         // set up the world model, then on each submodel copy from the world model
3571         // and set up the submodel with the respective model info.
3572         for (i = 0;i < mod->brush.numsubmodels;i++)
3573         {
3574                 // LordHavoc: this code was originally at the end of this loop, but
3575                 // has been transformed to something more readable at the start here.
3576
3577                 if (i > 0)
3578                 {
3579                         char name[10];
3580                         // LordHavoc: only register submodels if it is the world
3581                         // (prevents external bsp models from replacing world submodels with
3582                         //  their own)
3583                         if (!loadmodel->isworldmodel)
3584                                 continue;
3585                         // duplicate the basic information
3586                         sprintf(name, "*%i", i);
3587                         mod = Mod_FindName(name);
3588                         // copy the base model to this one
3589                         *mod = *loadmodel;
3590                         // rename the clone back to its proper name
3591                         strlcpy(mod->name, name, sizeof(mod->name));
3592                         // textures and memory belong to the main model
3593                         mod->texturepool = NULL;
3594                         mod->mempool = NULL;
3595                 }
3596
3597                 mod->brush.submodel = i;
3598
3599                 if (loadmodel->brush.submodels)
3600                         loadmodel->brush.submodels[i] = mod;
3601
3602                 bm = &mod->brushq1.submodels[i];
3603
3604                 mod->brushq1.hulls[0].firstclipnode = bm->headnode[0];
3605                 for (j=1 ; j<MAX_MAP_HULLS ; j++)
3606                 {
3607                         mod->brushq1.hulls[j].firstclipnode = bm->headnode[j];
3608                         mod->brushq1.hulls[j].lastclipnode = mod->brushq1.numclipnodes - 1;
3609                 }
3610
3611                 mod->firstmodelsurface = bm->firstface;
3612                 mod->nummodelsurfaces = bm->numfaces;
3613
3614                 // make the model surface list (used by shadowing/lighting)
3615                 mod->surfacelist = (int *)Mem_Alloc(loadmodel->mempool, mod->nummodelsurfaces * sizeof(*mod->surfacelist));
3616                 for (j = 0;j < mod->nummodelsurfaces;j++)
3617                         mod->surfacelist[j] = mod->firstmodelsurface + j;
3618
3619                 // this gets altered below if sky is used
3620                 mod->DrawSky = NULL;
3621                 mod->Draw = R_Q1BSP_Draw;
3622                 mod->DrawDepth = R_Q1BSP_DrawDepth;
3623                 mod->GetLightInfo = R_Q1BSP_GetLightInfo;
3624                 mod->CompileShadowVolume = R_Q1BSP_CompileShadowVolume;
3625                 mod->DrawShadowVolume = R_Q1BSP_DrawShadowVolume;
3626                 mod->DrawLight = R_Q1BSP_DrawLight;
3627                 if (i != 0)
3628                 {
3629                         mod->brush.TraceLineOfSight = NULL;
3630                         mod->brush.GetPVS = NULL;
3631                         mod->brush.FatPVS = NULL;
3632                         mod->brush.BoxTouchingPVS = NULL;
3633                         mod->brush.BoxTouchingLeafPVS = NULL;
3634                         mod->brush.BoxTouchingVisibleLeafs = NULL;
3635                         mod->brush.FindBoxClusters = NULL;
3636                         mod->brush.LightPoint = NULL;
3637                         mod->brush.AmbientSoundLevelsForPoint = NULL;
3638                 }
3639                 Mod_Q1BSP_BuildLightmapUpdateChains(loadmodel->mempool, mod);
3640                 if (mod->nummodelsurfaces)
3641                 {
3642                         // LordHavoc: calculate bmodel bounding box rather than trusting what it says
3643                         mod->normalmins[0] = mod->normalmins[1] = mod->normalmins[2] = 1000000000.0f;
3644                         mod->normalmaxs[0] = mod->normalmaxs[1] = mod->normalmaxs[2] = -1000000000.0f;
3645                         modelyawradius = 0;
3646                         modelradius = 0;
3647                         for (j = 0, surface = &mod->data_surfaces[mod->firstmodelsurface];j < mod->nummodelsurfaces;j++, surface++)
3648                         {
3649                                 // we only need to have a drawsky function if it is used(usually only on world model)
3650                                 if (surface->texture->basematerialflags & MATERIALFLAG_SKY)
3651                                         mod->DrawSky = R_Q1BSP_DrawSky;
3652                                 // calculate bounding shapes
3653                                 for (k = 0, vec = (loadmodel->surfmesh.data_vertex3f + 3 * surface->num_firstvertex);k < surface->num_vertices;k++, vec += 3)
3654                                 {
3655                                         if (mod->normalmins[0] > vec[0]) mod->normalmins[0] = vec[0];
3656                                         if (mod->normalmins[1] > vec[1]) mod->normalmins[1] = vec[1];
3657                                         if (mod->normalmins[2] > vec[2]) mod->normalmins[2] = vec[2];
3658                                         if (mod->normalmaxs[0] < vec[0]) mod->normalmaxs[0] = vec[0];
3659                                         if (mod->normalmaxs[1] < vec[1]) mod->normalmaxs[1] = vec[1];
3660                                         if (mod->normalmaxs[2] < vec[2]) mod->normalmaxs[2] = vec[2];
3661                                         dist = vec[0]*vec[0]+vec[1]*vec[1];
3662                                         if (modelyawradius < dist)
3663                                                 modelyawradius = dist;
3664                                         dist += vec[2]*vec[2];
3665                                         if (modelradius < dist)
3666                                                 modelradius = dist;
3667                                 }
3668                         }
3669                         modelyawradius = sqrt(modelyawradius);
3670                         modelradius = sqrt(modelradius);
3671                         mod->yawmins[0] = mod->yawmins[1] = - (mod->yawmaxs[0] = mod->yawmaxs[1] = modelyawradius);
3672                         mod->yawmins[2] = mod->normalmins[2];
3673                         mod->yawmaxs[2] = mod->normalmaxs[2];
3674                         mod->rotatedmins[0] = mod->rotatedmins[1] = mod->rotatedmins[2] = -modelradius;
3675                         mod->rotatedmaxs[0] = mod->rotatedmaxs[1] = mod->rotatedmaxs[2] = modelradius;
3676                         mod->radius = modelradius;
3677                         mod->radius2 = modelradius * modelradius;
3678                 }
3679                 else
3680                 {
3681                         // LordHavoc: empty submodel(lacrima.bsp has such a glitch)
3682                         Con_Printf("warning: empty submodel *%i in %s\n", i+1, loadmodel->name);
3683                 }
3684                 //mod->brushq1.num_visleafs = bm->visleafs;
3685         }
3686
3687         Mod_Q1BSP_LoadMapBrushes();
3688
3689         //Mod_Q1BSP_ProcessLightList();
3690
3691         if (developer.integer >= 10)
3692                 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);
3693 }
3694
3695 static void Mod_Q2BSP_LoadEntities(lump_t *l)
3696 {
3697 }
3698
3699 static void Mod_Q2BSP_LoadPlanes(lump_t *l)
3700 {
3701 /*
3702         d_t *in;
3703         m_t *out;
3704         int i, count;
3705
3706         in = (void *)(mod_base + l->fileofs);
3707         if (l->filelen % sizeof(*in))
3708                 Host_Error("Mod_Q2BSP_LoadPlanes: funny lump size in %s",loadmodel->name);
3709         count = l->filelen / sizeof(*in);
3710         out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
3711
3712         loadmodel-> = out;
3713         loadmodel->num = count;
3714
3715         for (i = 0;i < count;i++, in++, out++)
3716         {
3717         }
3718 */
3719 }
3720
3721 static void Mod_Q2BSP_LoadVertices(lump_t *l)
3722 {
3723 /*
3724         d_t *in;
3725         m_t *out;
3726         int i, count;
3727
3728         in = (void *)(mod_base + l->fileofs);
3729         if (l->filelen % sizeof(*in))
3730                 Host_Error("Mod_Q2BSP_LoadVertices: funny lump size in %s",loadmodel->name);
3731         count = l->filelen / sizeof(*in);
3732         out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
3733
3734         loadmodel-> = out;
3735         loadmodel->num = count;
3736
3737         for (i = 0;i < count;i++, in++, out++)
3738         {
3739         }
3740 */
3741 }
3742
3743 static void Mod_Q2BSP_LoadVisibility(lump_t *l)
3744 {
3745 /*
3746         d_t *in;
3747         m_t *out;
3748         int i, count;
3749
3750         in = (void *)(mod_base + l->fileofs);
3751         if (l->filelen % sizeof(*in))
3752                 Host_Error("Mod_Q2BSP_LoadVisibility: funny lump size in %s",loadmodel->name);
3753         count = l->filelen / sizeof(*in);
3754         out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
3755
3756         loadmodel-> = out;
3757         loadmodel->num = count;
3758
3759         for (i = 0;i < count;i++, in++, out++)
3760         {
3761         }
3762 */
3763 }
3764
3765 static void Mod_Q2BSP_LoadNodes(lump_t *l)
3766 {
3767 /*
3768         d_t *in;
3769         m_t *out;
3770         int i, count;
3771
3772         in = (void *)(mod_base + l->fileofs);
3773         if (l->filelen % sizeof(*in))
3774                 Host_Error("Mod_Q2BSP_LoadNodes: funny lump size in %s",loadmodel->name);
3775         count = l->filelen / sizeof(*in);
3776         out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
3777
3778         loadmodel-> = out;
3779         loadmodel->num = count;
3780
3781         for (i = 0;i < count;i++, in++, out++)
3782         {
3783         }
3784 */
3785 }
3786
3787 static void Mod_Q2BSP_LoadTexInfo(lump_t *l)
3788 {
3789 /*
3790         d_t *in;
3791         m_t *out;
3792         int i, count;
3793
3794         in = (void *)(mod_base + l->fileofs);
3795         if (l->filelen % sizeof(*in))
3796                 Host_Error("Mod_Q2BSP_LoadTexInfo: funny lump size in %s",loadmodel->name);
3797         count = l->filelen / sizeof(*in);
3798         out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
3799
3800         loadmodel-> = out;
3801         loadmodel->num = count;
3802
3803         for (i = 0;i < count;i++, in++, out++)
3804         {
3805         }
3806 */
3807 }
3808
3809 static void Mod_Q2BSP_LoadFaces(lump_t *l)
3810 {
3811 /*
3812         d_t *in;
3813         m_t *out;
3814         int i, count;
3815
3816         in = (void *)(mod_base + l->fileofs);
3817         if (l->filelen % sizeof(*in))
3818                 Host_Error("Mod_Q2BSP_LoadFaces: funny lump size in %s",loadmodel->name);
3819         count = l->filelen / sizeof(*in);
3820         out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
3821
3822         loadmodel-> = out;
3823         loadmodel->num = count;
3824
3825         for (i = 0;i < count;i++, in++, out++)
3826         {
3827         }
3828 */
3829 }
3830
3831 static void Mod_Q2BSP_LoadLighting(lump_t *l)
3832 {
3833 /*
3834         d_t *in;
3835         m_t *out;
3836         int i, count;
3837
3838         in = (void *)(mod_base + l->fileofs);
3839         if (l->filelen % sizeof(*in))
3840                 Host_Error("Mod_Q2BSP_LoadLighting: funny lump size in %s",loadmodel->name);
3841         count = l->filelen / sizeof(*in);
3842         out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
3843
3844         loadmodel-> = out;
3845         loadmodel->num = count;
3846
3847         for (i = 0;i < count;i++, in++, out++)
3848         {
3849         }
3850 */
3851 }
3852
3853 static void Mod_Q2BSP_LoadLeafs(lump_t *l)
3854 {
3855 /*
3856         d_t *in;
3857         m_t *out;
3858         int i, count;
3859
3860         in = (void *)(mod_base + l->fileofs);
3861         if (l->filelen % sizeof(*in))
3862                 Host_Error("Mod_Q2BSP_LoadLeafs: funny lump size in %s",loadmodel->name);
3863         count = l->filelen / sizeof(*in);
3864         out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
3865
3866         loadmodel-> = out;
3867         loadmodel->num = count;
3868
3869         for (i = 0;i < count;i++, in++, out++)
3870         {
3871         }
3872 */
3873 }
3874
3875 static void Mod_Q2BSP_LoadLeafFaces(lump_t *l)
3876 {
3877 /*
3878         d_t *in;
3879         m_t *out;
3880         int i, count;
3881
3882         in = (void *)(mod_base + l->fileofs);
3883         if (l->filelen % sizeof(*in))
3884                 Host_Error("Mod_Q2BSP_LoadLeafFaces: funny lump size in %s",loadmodel->name);
3885         count = l->filelen / sizeof(*in);
3886         out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
3887
3888         loadmodel-> = out;
3889         loadmodel->num = count;
3890
3891         for (i = 0;i < count;i++, in++, out++)
3892         {
3893         }
3894 */
3895 }
3896
3897 static void Mod_Q2BSP_LoadLeafBrushes(lump_t *l)
3898 {
3899 /*
3900         d_t *in;
3901         m_t *out;
3902         int i, count;
3903
3904         in = (void *)(mod_base + l->fileofs);
3905         if (l->filelen % sizeof(*in))
3906                 Host_Error("Mod_Q2BSP_LoadLeafBrushes: funny lump size in %s",loadmodel->name);
3907         count = l->filelen / sizeof(*in);
3908         out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
3909
3910         loadmodel-> = out;
3911         loadmodel->num = count;
3912
3913         for (i = 0;i < count;i++, in++, out++)
3914         {
3915         }
3916 */
3917 }
3918
3919 static void Mod_Q2BSP_LoadEdges(lump_t *l)
3920 {
3921 /*
3922         d_t *in;
3923         m_t *out;
3924         int i, count;
3925
3926         in = (void *)(mod_base + l->fileofs);
3927         if (l->filelen % sizeof(*in))
3928                 Host_Error("Mod_Q2BSP_LoadEdges: funny lump size in %s",loadmodel->name);
3929         count = l->filelen / sizeof(*in);
3930         out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
3931
3932         loadmodel-> = out;
3933         loadmodel->num = count;
3934
3935         for (i = 0;i < count;i++, in++, out++)
3936         {
3937         }
3938 */
3939 }
3940
3941 static void Mod_Q2BSP_LoadSurfEdges(lump_t *l)
3942 {
3943 /*
3944         d_t *in;
3945         m_t *out;
3946         int i, count;
3947
3948         in = (void *)(mod_base + l->fileofs);
3949         if (l->filelen % sizeof(*in))
3950                 Host_Error("Mod_Q2BSP_LoadSurfEdges: funny lump size in %s",loadmodel->name);
3951         count = l->filelen / sizeof(*in);
3952         out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
3953
3954         loadmodel-> = out;
3955         loadmodel->num = count;
3956
3957         for (i = 0;i < count;i++, in++, out++)
3958         {
3959         }
3960 */
3961 }
3962
3963 static void Mod_Q2BSP_LoadBrushes(lump_t *l)
3964 {
3965 /*
3966         d_t *in;
3967         m_t *out;
3968         int i, count;
3969
3970         in = (void *)(mod_base + l->fileofs);
3971         if (l->filelen % sizeof(*in))
3972                 Host_Error("Mod_Q2BSP_LoadBrushes: funny lump size in %s",loadmodel->name);
3973         count = l->filelen / sizeof(*in);
3974         out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
3975
3976         loadmodel-> = out;
3977         loadmodel->num = count;
3978
3979         for (i = 0;i < count;i++, in++, out++)
3980         {
3981         }
3982 */
3983 }
3984
3985 static void Mod_Q2BSP_LoadBrushSides(lump_t *l)
3986 {
3987 /*
3988         d_t *in;
3989         m_t *out;
3990         int i, count;
3991
3992         in = (void *)(mod_base + l->fileofs);
3993         if (l->filelen % sizeof(*in))
3994                 Host_Error("Mod_Q2BSP_LoadBrushSides: funny lump size in %s",loadmodel->name);
3995         count = l->filelen / sizeof(*in);
3996         out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
3997
3998         loadmodel-> = out;
3999         loadmodel->num = count;
4000
4001         for (i = 0;i < count;i++, in++, out++)
4002         {
4003         }
4004 */
4005 }
4006
4007 static void Mod_Q2BSP_LoadAreas(lump_t *l)
4008 {
4009 /*
4010         d_t *in;
4011         m_t *out;
4012         int i, count;
4013
4014         in = (void *)(mod_base + l->fileofs);
4015         if (l->filelen % sizeof(*in))
4016                 Host_Error("Mod_Q2BSP_LoadAreas: funny lump size in %s",loadmodel->name);
4017         count = l->filelen / sizeof(*in);
4018         out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
4019
4020         loadmodel-> = out;
4021         loadmodel->num = count;
4022
4023         for (i = 0;i < count;i++, in++, out++)
4024         {
4025         }
4026 */
4027 }
4028
4029 static void Mod_Q2BSP_LoadAreaPortals(lump_t *l)
4030 {
4031 /*
4032         d_t *in;
4033         m_t *out;
4034         int i, count;
4035
4036         in = (void *)(mod_base + l->fileofs);
4037         if (l->filelen % sizeof(*in))
4038                 Host_Error("Mod_Q2BSP_LoadAreaPortals: funny lump size in %s",loadmodel->name);
4039         count = l->filelen / sizeof(*in);
4040         out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
4041
4042         loadmodel-> = out;
4043         loadmodel->num = count;
4044
4045         for (i = 0;i < count;i++, in++, out++)
4046         {
4047         }
4048 */
4049 }
4050
4051 static void Mod_Q2BSP_LoadModels(lump_t *l)
4052 {
4053 /*
4054         d_t *in;
4055         m_t *out;
4056         int i, count;
4057
4058         in = (void *)(mod_base + l->fileofs);
4059         if (l->filelen % sizeof(*in))
4060                 Host_Error("Mod_Q2BSP_LoadModels: funny lump size in %s",loadmodel->name);
4061         count = l->filelen / sizeof(*in);
4062         out = Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
4063
4064         loadmodel-> = out;
4065         loadmodel->num = count;
4066
4067         for (i = 0;i < count;i++, in++, out++)
4068         {
4069         }
4070 */
4071 }
4072
4073 void static Mod_Q2BSP_Load(model_t *mod, void *buffer, void *bufferend)
4074 {
4075         int i;
4076         q2dheader_t *header;
4077
4078         Host_Error("Mod_Q2BSP_Load: not yet implemented");
4079
4080         mod->modeldatatypestring = "Q2BSP";
4081
4082         mod->type = mod_brushq2;
4083
4084         header = (q2dheader_t *)buffer;
4085
4086         i = LittleLong(header->version);
4087         if (i != Q2BSPVERSION)
4088                 Host_Error("Mod_Q2BSP_Load: %s has wrong version number (%i, should be %i)", mod->name, i, Q2BSPVERSION);
4089         mod->brush.ishlbsp = false;
4090         mod->brush.ismcbsp = false;
4091         if (loadmodel->isworldmodel)
4092         {
4093                 Cvar_SetValue("halflifebsp", mod->brush.ishlbsp);
4094                 Cvar_SetValue("mcbsp", mod->brush.ismcbsp);
4095         }
4096
4097         mod_base = (unsigned char *)header;
4098
4099         // swap all the lumps
4100         for (i = 0;i < (int) sizeof(*header) / 4;i++)
4101                 ((int *)header)[i] = LittleLong(((int *)header)[i]);
4102
4103         // store which lightmap format to use
4104         mod->brushq1.lightmaprgba = r_lightmaprgba.integer;
4105
4106         mod->brush.qw_md4sum = 0;
4107         mod->brush.qw_md4sum2 = 0;
4108         for (i = 0;i < Q2HEADER_LUMPS;i++)
4109         {
4110                 if (i == Q2LUMP_ENTITIES)
4111                         continue;
4112                 mod->brush.qw_md4sum ^= Com_BlockChecksum(mod_base + header->lumps[i].fileofs, header->lumps[i].filelen);
4113                 if (i == Q2LUMP_VISIBILITY || i == Q2LUMP_LEAFS || i == Q2LUMP_NODES)
4114                         continue;
4115                 mod->brush.qw_md4sum2 ^= Com_BlockChecksum(mod_base + header->lumps[i].fileofs, header->lumps[i].filelen);
4116         }
4117
4118         Mod_Q2BSP_LoadEntities(&header->lumps[Q2LUMP_ENTITIES]);
4119         Mod_Q2BSP_LoadPlanes(&header->lumps[Q2LUMP_PLANES]);
4120         Mod_Q2BSP_LoadVertices(&header->lumps[Q2LUMP_VERTEXES]);
4121         Mod_Q2BSP_LoadVisibility(&header->lumps[Q2LUMP_VISIBILITY]);
4122         Mod_Q2BSP_LoadNodes(&header->lumps[Q2LUMP_NODES]);
4123         Mod_Q2BSP_LoadTexInfo(&header->lumps[Q2LUMP_TEXINFO]);
4124         Mod_Q2BSP_LoadFaces(&header->lumps[Q2LUMP_FACES]);
4125         Mod_Q2BSP_LoadLighting(&header->lumps[Q2LUMP_LIGHTING]);
4126         Mod_Q2BSP_LoadLeafs(&header->lumps[Q2LUMP_LEAFS]);
4127         Mod_Q2BSP_LoadLeafFaces(&header->lumps[Q2LUMP_LEAFFACES]);
4128         Mod_Q2BSP_LoadLeafBrushes(&header->lumps[Q2LUMP_LEAFBRUSHES]);
4129         Mod_Q2BSP_LoadEdges(&header->lumps[Q2LUMP_EDGES]);
4130         Mod_Q2BSP_LoadSurfEdges(&header->lumps[Q2LUMP_SURFEDGES]);
4131         Mod_Q2BSP_LoadBrushes(&header->lumps[Q2LUMP_BRUSHES]);
4132         Mod_Q2BSP_LoadBrushSides(&header->lumps[Q2LUMP_BRUSHSIDES]);
4133         Mod_Q2BSP_LoadAreas(&header->lumps[Q2LUMP_AREAS]);
4134         Mod_Q2BSP_LoadAreaPortals(&header->lumps[Q2LUMP_AREAPORTALS]);
4135         // LordHavoc: must go last because this makes the submodels
4136         Mod_Q2BSP_LoadModels(&header->lumps[Q2LUMP_MODELS]);
4137 }
4138
4139 static int Mod_Q3BSP_SuperContentsFromNativeContents(model_t *model, int nativecontents);
4140 static int Mod_Q3BSP_NativeContentsFromSuperContents(model_t *model, int supercontents);
4141
4142 static void Mod_Q3BSP_LoadEntities(lump_t *l)
4143 {
4144         const char *data;
4145         char key[128], value[MAX_INPUTLINE];
4146         float v[3];
4147         loadmodel->brushq3.num_lightgrid_cellsize[0] = 64;
4148         loadmodel->brushq3.num_lightgrid_cellsize[1] = 64;
4149         loadmodel->brushq3.num_lightgrid_cellsize[2] = 128;
4150         if (!l->filelen)
4151                 return;
4152         loadmodel->brush.entities = (char *)Mem_Alloc(loadmodel->mempool, l->filelen);
4153         memcpy(loadmodel->brush.entities, mod_base + l->fileofs, l->filelen);
4154         data = loadmodel->brush.entities;
4155         // some Q3 maps override the lightgrid_cellsize with a worldspawn key
4156         if (data && COM_ParseToken_Simple(&data, false) && com_token[0] == '{')
4157         {
4158                 while (1)
4159                 {
4160                         if (!COM_ParseToken_Simple(&data, false))
4161                                 break; // error
4162                         if (com_token[0] == '}')
4163                                 break; // end of worldspawn
4164                         if (com_token[0] == '_')
4165                                 strlcpy(key, com_token + 1, sizeof(key));
4166                         else
4167                                 strlcpy(key, com_token, sizeof(key));
4168                         while (key[strlen(key)-1] == ' ') // remove trailing spaces
4169                                 key[strlen(key)-1] = 0;
4170                         if (!COM_ParseToken_Simple(&data, false))
4171                                 break; // error
4172                         strlcpy(value, com_token, sizeof(value));
4173                         if (!strcmp("gridsize", key))
4174                         {
4175                                 if (sscanf(value, "%f %f %f", &v[0], &v[1], &v[2]) == 3 && v[0] != 0 && v[1] != 0 && v[2] != 0)
4176                                         VectorCopy(v, loadmodel->brushq3.num_lightgrid_cellsize);
4177                         }
4178                 }
4179         }
4180 }
4181
4182 static void Mod_Q3BSP_LoadTextures(lump_t *l)
4183 {
4184         q3dtexture_t *in;
4185         texture_t *out;
4186         int i, count, c;
4187
4188         in = (q3dtexture_t *)(mod_base + l->fileofs);
4189         if (l->filelen % sizeof(*in))
4190                 Host_Error("Mod_Q3BSP_LoadTextures: funny lump size in %s",loadmodel->name);
4191         count = l->filelen / sizeof(*in);
4192         out = (texture_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
4193
4194         loadmodel->data_textures = out;
4195         loadmodel->num_textures = count;
4196         loadmodel->num_texturesperskin = loadmodel->num_textures;
4197
4198         for (i = 0;i < count;i++)
4199         {
4200                 strlcpy (out[i].name, in[i].name, sizeof (out[i].name));
4201                 out[i].surfaceflags = LittleLong(in[i].surfaceflags);
4202                 out[i].supercontents = Mod_Q3BSP_SuperContentsFromNativeContents(loadmodel, LittleLong(in[i].contents));
4203         }
4204
4205         if (cls.state == ca_dedicated)
4206                 return;
4207
4208         c = 0;
4209         for (i = 0;i < count;i++, in++, out++)
4210                 if (Mod_LoadTextureFromQ3Shader(out, out->name, false, true, false))
4211                         c++;
4212         if (c)
4213                 Con_DPrintf("%s: %i textures missing shaders\n", loadmodel->name, c);
4214 }
4215
4216 static void Mod_Q3BSP_LoadPlanes(lump_t *l)
4217 {
4218         q3dplane_t *in;
4219         mplane_t *out;
4220         int i, count;
4221
4222         in = (q3dplane_t *)(mod_base + l->fileofs);
4223         if (l->filelen % sizeof(*in))
4224                 Host_Error("Mod_Q3BSP_LoadPlanes: funny lump size in %s",loadmodel->name);
4225         count = l->filelen / sizeof(*in);
4226         out = (mplane_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
4227
4228         loadmodel->brush.data_planes = out;
4229         loadmodel->brush.num_planes = count;
4230
4231         for (i = 0;i < count;i++, in++, out++)
4232         {
4233                 out->normal[0] = LittleFloat(in->normal[0]);
4234                 out->normal[1] = LittleFloat(in->normal[1]);
4235                 out->normal[2] = LittleFloat(in->normal[2]);
4236                 out->dist = LittleFloat(in->dist);
4237                 PlaneClassify(out);
4238         }
4239 }
4240
4241 static void Mod_Q3BSP_LoadBrushSides(lump_t *l)
4242 {
4243         q3dbrushside_t *in;
4244         q3mbrushside_t *out;
4245         int i, n, count;
4246
4247         in = (q3dbrushside_t *)(mod_base + l->fileofs);
4248         if (l->filelen % sizeof(*in))
4249                 Host_Error("Mod_Q3BSP_LoadBrushSides: funny lump size in %s",loadmodel->name);
4250         count = l->filelen / sizeof(*in);
4251         out = (q3mbrushside_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
4252
4253         loadmodel->brush.data_brushsides = out;
4254         loadmodel->brush.num_brushsides = count;
4255
4256         for (i = 0;i < count;i++, in++, out++)
4257         {
4258                 n = LittleLong(in->planeindex);
4259                 if (n < 0 || n >= loadmodel->brush.num_planes)
4260                         Host_Error("Mod_Q3BSP_LoadBrushSides: invalid planeindex %i (%i planes)", n, loadmodel->brush.num_planes);
4261                 out->plane = loadmodel->brush.data_planes + n;
4262                 n = LittleLong(in->textureindex);
4263                 if (n < 0 || n >= loadmodel->num_textures)
4264                         Host_Error("Mod_Q3BSP_LoadBrushSides: invalid textureindex %i (%i textures)", n, loadmodel->num_textures);
4265                 out->texture = loadmodel->data_textures + n;
4266         }
4267 }
4268
4269 static void Mod_Q3BSP_LoadBrushes(lump_t *l)
4270 {
4271         q3dbrush_t *in;
4272         q3mbrush_t *out;
4273         int i, j, n, c, count, maxplanes;
4274         colplanef_t *planes;
4275
4276         in = (q3dbrush_t *)(mod_base + l->fileofs);
4277         if (l->filelen % sizeof(*in))
4278                 Host_Error("Mod_Q3BSP_LoadBrushes: funny lump size in %s",loadmodel->name);
4279         count = l->filelen / sizeof(*in);
4280         out = (q3mbrush_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
4281
4282         loadmodel->brush.data_brushes = out;
4283         loadmodel->brush.num_brushes = count;
4284
4285         maxplanes = 0;
4286         planes = NULL;
4287
4288         for (i = 0;i < count;i++, in++, out++)
4289         {
4290                 n = LittleLong(in->firstbrushside);
4291                 c = LittleLong(in->numbrushsides);
4292                 if (n < 0 || n + c > loadmodel->brush.num_brushsides)
4293                         Host_Error("Mod_Q3BSP_LoadBrushes: invalid brushside range %i : %i (%i brushsides)", n, n + c, loadmodel->brush.num_brushsides);
4294                 out->firstbrushside = loadmodel->brush.data_brushsides + n;
4295                 out->numbrushsides = c;
4296                 n = LittleLong(in->textureindex);
4297                 if (n < 0 || n >= loadmodel->num_textures)
4298                         Host_Error("Mod_Q3BSP_LoadBrushes: invalid textureindex %i (%i textures)", n, loadmodel->num_textures);
4299                 out->texture = loadmodel->data_textures + n;
4300
4301                 // make a list of mplane_t structs to construct a colbrush from
4302                 if (maxplanes < out->numbrushsides)
4303                 {
4304                         maxplanes = out->numbrushsides;
4305                         if (planes)
4306                                 Mem_Free(planes);
4307                         planes = (colplanef_t *)Mem_Alloc(tempmempool, sizeof(colplanef_t) * maxplanes);
4308                 }
4309                 for (j = 0;j < out->numbrushsides;j++)
4310                 {
4311                         VectorCopy(out->firstbrushside[j].plane->normal, planes[j].normal);
4312                         planes[j].dist = out->firstbrushside[j].plane->dist;
4313                         planes[j].q3surfaceflags = out->firstbrushside[j].texture->surfaceflags;
4314                         planes[j].texture = out->firstbrushside[j].texture;
4315                 }
4316                 // make the colbrush from the planes
4317                 out->colbrushf = Collision_NewBrushFromPlanes(loadmodel->mempool, out->numbrushsides, planes, out->texture->supercontents);
4318         }
4319         if (planes)
4320                 Mem_Free(planes);
4321 }
4322
4323 static void Mod_Q3BSP_LoadEffects(lump_t *l)
4324 {
4325         q3deffect_t *in;
4326         q3deffect_t *out;
4327         int i, n, count;
4328
4329         in = (q3deffect_t *)(mod_base + l->fileofs);
4330         if (l->filelen % sizeof(*in))
4331                 Host_Error("Mod_Q3BSP_LoadEffects: funny lump size in %s",loadmodel->name);
4332         count = l->filelen / sizeof(*in);
4333         out = (q3deffect_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
4334
4335         loadmodel->brushq3.data_effects = out;
4336         loadmodel->brushq3.num_effects = count;
4337
4338         for (i = 0;i < count;i++, in++, out++)
4339         {
4340                 strlcpy (out->shadername, in->shadername, sizeof (out->shadername));
4341                 n = LittleLong(in->brushindex);
4342                 if (n >= loadmodel->brush.num_brushes)
4343                 {
4344                         Con_Printf("Mod_Q3BSP_LoadEffects: invalid brushindex %i (%i brushes), setting to -1\n", n, loadmodel->brush.num_brushes);
4345                         n = -1;
4346                 }
4347                 out->brushindex = n;
4348                 out->unknown = LittleLong(in->unknown);
4349         }
4350 }
4351
4352 static void Mod_Q3BSP_LoadVertices(lump_t *l)
4353 {
4354         q3dvertex_t *in;
4355         int i, count;
4356
4357         in = (q3dvertex_t *)(mod_base + l->fileofs);
4358         if (l->filelen % sizeof(*in))
4359                 Host_Error("Mod_Q3BSP_LoadVertices: funny lump size in %s",loadmodel->name);
4360         loadmodel->brushq3.num_vertices = count = l->filelen / sizeof(*in);
4361         loadmodel->brushq3.data_vertex3f = (float *)Mem_Alloc(loadmodel->mempool, count * (sizeof(float) * (3 + 3 + 2 + 2 + 4)));
4362         loadmodel->brushq3.data_normal3f = loadmodel->brushq3.data_vertex3f + count * 3;
4363         loadmodel->brushq3.data_texcoordtexture2f = loadmodel->brushq3.data_normal3f + count * 3;
4364         loadmodel->brushq3.data_texcoordlightmap2f = loadmodel->brushq3.data_texcoordtexture2f + count * 2;
4365         loadmodel->brushq3.data_color4f = loadmodel->brushq3.data_texcoordlightmap2f + count * 2;
4366
4367         for (i = 0;i < count;i++, in++)
4368         {
4369                 loadmodel->brushq3.data_vertex3f[i * 3 + 0] = LittleFloat(in->origin3f[0]);
4370                 loadmodel->brushq3.data_vertex3f[i * 3 + 1] = LittleFloat(in->origin3f[1]);
4371                 loadmodel->brushq3.data_vertex3f[i * 3 + 2] = LittleFloat(in->origin3f[2]);
4372                 loadmodel->brushq3.data_normal3f[i * 3 + 0] = LittleFloat(in->normal3f[0]);
4373                 loadmodel->brushq3.data_normal3f[i * 3 + 1] = LittleFloat(in->normal3f[1]);
4374                 loadmodel->brushq3.data_normal3f[i * 3 + 2] = LittleFloat(in->normal3f[2]);
4375                 loadmodel->brushq3.data_texcoordtexture2f[i * 2 + 0] = LittleFloat(in->texcoord2f[0]);
4376                 loadmodel->brushq3.data_texcoordtexture2f[i * 2 + 1] = LittleFloat(in->texcoord2f[1]);
4377                 loadmodel->brushq3.data_texcoordlightmap2f[i * 2 + 0] = LittleFloat(in->lightmap2f[0]);
4378                 loadmodel->brushq3.data_texcoordlightmap2f[i * 2 + 1] = LittleFloat(in->lightmap2f[1]);
4379                 // svector/tvector are calculated later in face loading
4380                 loadmodel->brushq3.data_color4f[i * 4 + 0] = in->color4ub[0] * (1.0f / 255.0f);
4381                 loadmodel->brushq3.data_color4f[i * 4 + 1] = in->color4ub[1] * (1.0f / 255.0f);
4382                 loadmodel->brushq3.data_color4f[i * 4 + 2] = in->color4ub[2] * (1.0f / 255.0f);
4383                 loadmodel->brushq3.data_color4f[i * 4 + 3] = in->color4ub[3] * (1.0f / 255.0f);
4384         }
4385 }
4386
4387 static void Mod_Q3BSP_LoadTriangles(lump_t *l)
4388 {
4389         int *in;
4390         int *out;
4391         int i, count;
4392
4393         in = (int *)(mod_base + l->fileofs);
4394         if (l->filelen % sizeof(int[3]))
4395                 Host_Error("Mod_Q3BSP_LoadTriangles: funny lump size in %s",loadmodel->name);
4396         count = l->filelen / sizeof(*in);
4397         out = (int *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
4398
4399         loadmodel->brushq3.num_triangles = count / 3;
4400         loadmodel->brushq3.data_element3i = out;
4401
4402         for (i = 0;i < count;i++, in++, out++)
4403         {
4404                 *out = LittleLong(*in);
4405                 if (*out < 0 || *out >= loadmodel->brushq3.num_vertices)
4406                 {
4407                         Con_Printf("Mod_Q3BSP_LoadTriangles: invalid vertexindex %i (%i vertices), setting to 0\n", *out, loadmodel->brushq3.num_vertices);
4408                         *out = 0;
4409                 }
4410         }
4411 }
4412
4413 static void Mod_Q3BSP_LoadLightmaps(lump_t *l, lump_t *faceslump)
4414 {
4415         q3dlightmap_t *in;
4416         int i, j, count, power, power2, mask, endlightmap, mergewidth, mergeheight;
4417         unsigned char *c;
4418
4419         if (!l->filelen)
4420                 return;
4421         if (cls.state == ca_dedicated)
4422                 return;
4423         in = (q3dlightmap_t *)(mod_base + l->fileofs);
4424         if (l->filelen % sizeof(*in))
4425                 Host_Error("Mod_Q3BSP_LoadLightmaps: funny lump size in %s",loadmodel->name);
4426         count = l->filelen / sizeof(*in);
4427         loadmodel->brushq3.num_originallightmaps = count;
4428
4429         // now check the surfaces to see if any of them index an odd numbered
4430         // lightmap, if so this is not a deluxemapped bsp file
4431         //
4432         // also check what lightmaps are actually used, because q3map2 sometimes
4433         // (always?) makes an unused one at the end, which
4434         // q3map2 sometimes (or always?) makes a second blank lightmap for no
4435         // reason when only one lightmap is used, which can throw off the
4436         // deluxemapping detection method, so check 2-lightmap bsp's specifically
4437         // to see if the second lightmap is blank, if so it is not deluxemapped.
4438         loadmodel->brushq3.deluxemapping = !(count & 1);
4439         loadmodel->brushq3.deluxemapping_modelspace = true;
4440         endlightmap = 0;
4441         if (loadmodel->brushq3.deluxemapping)
4442         {
4443                 int facecount = faceslump->filelen / sizeof(q3dface_t);
4444                 q3dface_t *faces = (q3dface_t *)(mod_base + faceslump->fileofs);
4445                 for (i = 0;i < facecount;i++)
4446                 {
4447                         j = LittleLong(faces[i].lightmapindex);
4448                         if (j >= 0)
4449                         {
4450                                 endlightmap = max(endlightmap, j + 1);
4451                                 if ((j & 1) || j + 1 >= count)
4452                                 {
4453                                         loadmodel->brushq3.deluxemapping = false;
4454                                         break;
4455                                 }
4456                         }
4457                 }
4458         }
4459         if (endlightmap < 2)
4460                 loadmodel->brushq3.deluxemapping = false;
4461
4462         // q3map2 sometimes (or always?) makes a second blank lightmap for no
4463         // reason when only one lightmap is used, which can throw off the
4464         // deluxemapping detection method, so check 2-lightmap bsp's specifically
4465         // to see if the second lightmap is blank, if so it is not deluxemapped.
4466         if (endlightmap == 1 && count == 2)
4467         {
4468                 c = in[1].rgb;
4469                 for (i = 0;i < 128*128*3;i++)
4470                         if (c[i])
4471                                 break;
4472                 if (i == 128*128*3)
4473                 {
4474                         // all pixels in the unused lightmap were black...
4475                         loadmodel->brushq3.deluxemapping = false;
4476                 }
4477         }
4478
4479         Con_DPrintf("%s is %sdeluxemapped\n", loadmodel->name, loadmodel->brushq3.deluxemapping ? "" : "not ");
4480
4481         // figure out what the most reasonable merge power is within limits
4482         loadmodel->brushq3.num_lightmapmergepower = 0;
4483         for (power = 1;power <= mod_q3bsp_lightmapmergepower.integer && (128 << power) <= gl_max_texture_size && (1 << (power * 2)) < 4 * (count >> loadmodel->brushq3.deluxemapping);power++)
4484                 loadmodel->brushq3.num_lightmapmergepower = power;
4485         loadmodel->brushq3.num_lightmapmerge = 1 << loadmodel->brushq3.num_lightmapmergepower;
4486
4487         loadmodel->brushq3.num_mergedlightmaps = ((count >> loadmodel->brushq3.deluxemapping) + (1 << (loadmodel->brushq3.num_lightmapmergepower * 2)) - 1) >> (loadmodel->brushq3.num_lightmapmergepower * 2);
4488         loadmodel->brushq3.data_lightmaps = (rtexture_t **)Mem_Alloc(loadmodel->mempool, loadmodel->brushq3.num_mergedlightmaps * sizeof(rtexture_t *));
4489         if (loadmodel->brushq3.deluxemapping)
4490                 loadmodel->brushq3.data_deluxemaps = (rtexture_t **)Mem_Alloc(loadmodel->mempool, loadmodel->brushq3.num_mergedlightmaps * sizeof(rtexture_t *));
4491
4492         // allocate a texture pool if we need it
4493         if (loadmodel->texturepool == NULL && cls.state != ca_dedicated)
4494                 loadmodel->texturepool = R_AllocTexturePool();
4495
4496         if (loadmodel->brushq3.num_lightmapmergepower > 0)
4497         {
4498                 power = loadmodel->brushq3.num_lightmapmergepower;
4499                 power2 = power * 2;
4500                 mask = (1 << power) - 1;
4501                 for (i = 0;i < count;i++)
4502                 {
4503                         // figure out which merged lightmap texture this fits into
4504                         int lightmapindex = i >> (loadmodel->brushq3.deluxemapping + power2);
4505                         // if the lightmap has not been allocated yet, create it
4506                         if (!loadmodel->brushq3.data_lightmaps[lightmapindex])
4507                         {
4508                                 // create a lightmap only as large as necessary to hold the
4509                                 // remaining 128x128 blocks
4510                                 // if there are multiple merged lightmap textures then they will
4511                                 // all be full size except the last one which may be smaller
4512                                 // because it only needs to the remaining blocks, and it will often
4513                                 // be odd sizes like 2048x512 due to only being 25% full or so.
4514                                 j = (count >> loadmodel->brushq3.deluxemapping) - (lightmapindex << power2);
4515                                 for (mergewidth = 1;mergewidth < j && mergewidth < (1 << power);mergewidth *= 2)
4516                                         ;
4517                                 for (mergeheight = 1;mergewidth*mergeheight < j && mergeheight < (1 << power);mergeheight *= 2)
4518                                         ;
4519                                 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);
4520                                 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);
4521                                 if (loadmodel->brushq3.data_deluxemaps)
4522                                         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);
4523                         }
4524                         mergewidth = R_TextureWidth(loadmodel->brushq3.data_lightmaps[lightmapindex]) / 128;
4525                         mergeheight = R_TextureHeight(loadmodel->brushq3.data_lightmaps[lightmapindex]) / 128;
4526                         j = (i >> loadmodel->brushq3.deluxemapping) & ((1 << power2) - 1);
4527                         if (loadmodel->brushq3.deluxemapping && (i & 1))
4528                                 R_UpdateTexture(loadmodel->brushq3.data_deluxemaps[lightmapindex], in[i].rgb, (j % mergewidth) * 128, (j / mergewidth) * 128, 128, 128);
4529                         else
4530                                 R_UpdateTexture(loadmodel->brushq3.data_lightmaps     [lightmapindex], in[i].rgb, (j % mergewidth) * 128, (j / mergewidth) * 128, 128, 128);
4531                 }
4532         }
4533         else
4534         {
4535                 for (i = 0;i < count;i++)
4536                 {
4537                         // figure out which merged lightmap texture this fits into
4538                         int lightmapindex = i >> loadmodel->brushq3.deluxemapping;
4539                         if (loadmodel->brushq3.deluxemapping && (i & 1))
4540                                 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);
4541                         else
4542                                 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);
4543                 }
4544         }
4545 }
4546
4547 static void Mod_Q3BSP_LoadFaces(lump_t *l)
4548 {
4549         q3dface_t *in, *oldin;
4550         msurface_t *out, *oldout;
4551         int i, oldi, j, n, count, invalidelements, patchsize[2], finalwidth, finalheight, xtess, ytess, finalvertices, finaltriangles, firstvertex, firstelement, type, oldnumtriangles, oldnumtriangles2, meshvertices, meshtriangles, numvertices, numtriangles;
4552         float lightmaptcbase[2], lightmaptcscale[2];
4553         //int *originalelement3i;
4554         //int *originalneighbor3i;
4555         float *originalvertex3f;
4556         //float *originalsvector3f;
4557         //float *originaltvector3f;
4558         float *originalnormal3f;
4559         float *originalcolor4f;
4560         float *originaltexcoordtexture2f;
4561         float *originaltexcoordlightmap2f;
4562         float *v;
4563
4564         in = (q3dface_t *)(mod_base + l->fileofs);
4565         if (l->filelen % sizeof(*in))
4566                 Host_Error("Mod_Q3BSP_LoadFaces: funny lump size in %s",loadmodel->name);
4567         count = l->filelen / sizeof(*in);
4568         out = (msurface_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
4569
4570         loadmodel->data_surfaces = out;
4571         loadmodel->num_surfaces = count;
4572
4573         i = 0;
4574         oldi = i;
4575         oldin = in;
4576         oldout = out;
4577         meshvertices = 0;
4578         meshtriangles = 0;
4579         for (;i < count;i++, in++, out++)
4580         {
4581                 // check face type first
4582                 type = LittleLong(in->type);
4583                 if (type != Q3FACETYPE_POLYGON
4584                  && type != Q3FACETYPE_PATCH
4585                  && type != Q3FACETYPE_MESH
4586                  && type != Q3FACETYPE_FLARE)
4587                 {
4588                         Con_DPrintf("Mod_Q3BSP_LoadFaces: face #%i: unknown face type %i\n", i, type);
4589                         continue;
4590                 }
4591
4592                 n = LittleLong(in->textureindex);
4593                 if (n < 0 || n >= loadmodel->num_textures)
4594                 {
4595                         Con_DPrintf("Mod_Q3BSP_LoadFaces: face #%i: invalid textureindex %i (%i textures)\n", i, n, loadmodel->num_textures);
4596                         continue;
4597                 }
4598                 out->texture = loadmodel->data_textures + n;
4599                 n = LittleLong(in->effectindex);
4600                 if (n < -1 || n >= loadmodel->brushq3.num_effects)
4601                 {
4602                         if (developer.integer >= 100)
4603                                 Con_Printf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): invalid effectindex %i (%i effects)\n", i, out->texture->name, n, loadmodel->brushq3.num_effects);
4604                         n = -1;
4605                 }
4606                 if (n == -1)
4607                         out->effect = NULL;
4608                 else
4609                         out->effect = loadmodel->brushq3.data_effects + n;
4610
4611                 if (cls.state != ca_dedicated)
4612                 {
4613                         out->lightmaptexture = NULL;
4614                         out->deluxemaptexture = r_texture_blanknormalmap;
4615                         n = LittleLong(in->lightmapindex);
4616                         if (n < 0)
4617                                 n = -1;
4618                         else if (n >= loadmodel->brushq3.num_originallightmaps)
4619                         {
4620                                 Con_Printf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): invalid lightmapindex %i (%i lightmaps)\n", i, out->texture->name, n, loadmodel->brushq3.num_originallightmaps);
4621                                 n = -1;
4622                         }
4623                         else
4624                         {
4625                                 out->lightmaptexture = loadmodel->brushq3.data_lightmaps[n >> (loadmodel->brushq3.num_lightmapmergepower * 2 + loadmodel->brushq3.deluxemapping)];
4626                                 if (loadmodel->brushq3.deluxemapping)
4627                                         out->deluxemaptexture = loadmodel->brushq3.data_deluxemaps[n >> (loadmodel->brushq3.num_lightmapmergepower * 2 + loadmodel->brushq3.deluxemapping)];
4628                         }
4629                 }
4630
4631                 firstvertex = LittleLong(in->firstvertex);
4632                 numvertices = LittleLong(in->numvertices);
4633                 firstelement = LittleLong(in->firstelement);
4634                 numtriangles = LittleLong(in->numelements) / 3;
4635                 if (numtriangles * 3 != LittleLong(in->numelements))
4636                 {
4637                         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));
4638                         continue;
4639                 }
4640                 if (firstvertex < 0 || firstvertex + numvertices > loadmodel->brushq3.num_vertices)
4641                 {
4642                         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);
4643                         continue;
4644                 }
4645                 if (firstelement < 0 || firstelement + numtriangles * 3 > loadmodel->brushq3.num_triangles * 3)
4646                 {
4647                         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);
4648                         continue;
4649                 }
4650                 switch(type)
4651                 {
4652                 case Q3FACETYPE_POLYGON:
4653                 case Q3FACETYPE_MESH:
4654                         // no processing necessary
4655                         break;
4656                 case Q3FACETYPE_PATCH:
4657                         patchsize[0] = LittleLong(in->specific.patch.patchsize[0]);
4658                         patchsize[1] = LittleLong(in->specific.patch.patchsize[1]);
4659                         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))
4660                         {
4661                                 Con_Printf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): invalid patchsize %ix%i\n", i, out->texture->name, patchsize[0], patchsize[1]);
4662                                 continue;
4663                         }
4664                         originalvertex3f = loadmodel->brushq3.data_vertex3f + firstvertex * 3;
4665                         // convert patch to Q3FACETYPE_MESH
4666                         xtess = Q3PatchTesselationOnX(patchsize[0], patchsize[1], 3, originalvertex3f, r_subdivisions_tolerance.value);
4667                         ytess = Q3PatchTesselationOnY(patchsize[0], patchsize[1], 3, originalvertex3f, r_subdivisions_tolerance.value);
4668                         // bound to user settings
4669                         xtess = bound(r_subdivisions_mintess.integer, xtess, r_subdivisions_maxtess.integer);
4670                         ytess = bound(r_subdivisions_mintess.integer, ytess, r_subdivisions_maxtess.integer);
4671                         // bound to sanity settings
4672                         xtess = bound(1, xtess, 1024);
4673                         ytess = bound(1, ytess, 1024);
4674                         // bound to user limit on vertices
4675                         while ((xtess > 1 || ytess > 1) && (((patchsize[0] - 1) * xtess) + 1) * (((patchsize[1] - 1) * ytess) + 1) > min(r_subdivisions_maxvertices.integer, 262144))
4676                         {
4677                                 if (xtess > ytess)
4678                                         xtess--;
4679                                 else
4680                                         ytess--;
4681                         }
4682                         finalwidth = ((patchsize[0] - 1) * xtess) + 1;
4683                         finalheight = ((patchsize[1] - 1) * ytess) + 1;
4684                         numvertices = finalwidth * finalheight;
4685                         numtriangles = (finalwidth - 1) * (finalheight - 1) * 2;
4686                         break;
4687                 case Q3FACETYPE_FLARE:
4688                         if (developer.integer >= 100)
4689                                 Con_Printf("Mod_Q3BSP_LoadFaces: face #%i (texture \"%s\"): Q3FACETYPE_FLARE not supported (yet)\n", i, out->texture->name);
4690                         // don't render it
4691                         continue;
4692                 }
4693                 out->num_vertices = numvertices;
4694                 out->num_triangles = numtriangles;
4695                 meshvertices += out->num_vertices;
4696                 meshtriangles += out->num_triangles;
4697         }
4698
4699         i = oldi;
4700         in = oldin;
4701         out = oldout;
4702         Mod_AllocSurfMesh(loadmodel->mempool, meshvertices, meshtriangles, false, true, false);
4703         meshvertices = 0;
4704         meshtriangles = 0;
4705         for (;i < count && meshvertices + out->num_vertices <= loadmodel->surfmesh.num_vertices;i++, in++, out++)
4706         {
4707                 if (out->num_vertices < 3 || out->num_triangles < 1)
4708                         continue;
4709
4710                 type = LittleLong(in->type);
4711                 firstvertex = LittleLong(in->firstvertex);
4712                 firstelement = LittleLong(in->firstelement);
4713                 out->num_firstvertex = meshvertices;
4714                 out->num_firsttriangle = meshtriangles;
4715                 switch(type)
4716                 {
4717                 case Q3FACETYPE_POLYGON:
4718                 case Q3FACETYPE_MESH:
4719                         // no processing necessary, except for lightmap merging
4720                         for (j = 0;j < out->num_vertices;j++)
4721                         {
4722                                 (loadmodel->surfmesh.data_vertex3f + 3 * out->num_firstvertex)[j * 3 + 0] = loadmodel->brushq3.data_vertex3f[(firstvertex + j) * 3 + 0];
4723                                 (loadmodel->surfmesh.data_vertex3f + 3 * out->num_firstvertex)[j * 3 + 1] = loadmodel->brushq3.data_vertex3f[(firstvertex + j) * 3 + 1];
4724                                 (loadmodel->surfmesh.data_vertex3f + 3 * out->num_firstvertex)[j * 3 + 2] = loadmodel->brushq3.data_vertex3f[(firstvertex + j) * 3 + 2];
4725                                 (loadmodel->surfmesh.data_normal3f + 3 * out->num_firstvertex)[j * 3 + 0] = loadmodel->brushq3.data_normal3f[(firstvertex + j) * 3 + 0];
4726                                 (loadmodel->surfmesh.data_normal3f + 3 * out->num_firstvertex)[j * 3 + 1] = loadmodel->brushq3.data_normal3f[(firstvertex + j) * 3 + 1];
4727                                 (loadmodel->surfmesh.data_normal3f + 3 * out->num_firstvertex)[j * 3 + 2] = loadmodel->brushq3.data_normal3f[(firstvertex + j) * 3 + 2];
4728                                 (loadmodel->surfmesh.data_texcoordtexture2f + 2 * out->num_firstvertex)[j * 2 + 0] = loadmodel->brushq3.data_texcoordtexture2f[(firstvertex + j) * 2 + 0];
4729                                 (loadmodel->surfmesh.data_texcoordtexture2f + 2 * out->num_firstvertex)[j * 2 + 1] = loadmodel->brushq3.data_texcoordtexture2f[(firstvertex + j) * 2 + 1];
4730                                 (loadmodel->surfmesh.data_texcoordlightmap2f + 2 * out->num_firstvertex)[j * 2 + 0] = loadmodel->brushq3.data_texcoordlightmap2f[(firstvertex + j) * 2 + 0];
4731                                 (loadmodel->surfmesh.data_texcoordlightmap2f + 2 * out->num_firstvertex)[j * 2 + 1] = loadmodel->brushq3.data_texcoordlightmap2f[(firstvertex + j) * 2 + 1];
4732                                 (loadmodel->surfmesh.data_lightmapcolor4f + 4 * out->num_firstvertex)[j * 4 + 0] = loadmodel->brushq3.data_color4f[(firstvertex + j) * 4 + 0];
4733                                 (loadmodel->surfmesh.data_lightmapcolor4f + 4 * out->num_firstvertex)[j * 4 + 1] = loadmodel->brushq3.data_color4f[(firstvertex + j) * 4 + 1];
4734                                 (loadmodel->surfmesh.data_lightmapcolor4f + 4 * out->num_firstvertex)[j * 4 + 2] = loadmodel->brushq3.data_color4f[(firstvertex + j) * 4 + 2];
4735                                 (loadmodel->surfmesh.data_lightmapcolor4f + 4 * out->num_firstvertex)[j * 4 + 3] = loadmodel->brushq3.data_color4f[(firstvertex + j) * 4 + 3];
4736                         }
4737                         for (j = 0;j < out->num_triangles*3;j++)
4738                                 (loadmodel->surfmesh.data_element3i + 3 * out->num_firsttriangle)[j] = loadmodel->brushq3.data_element3i[firstelement + j] + out->num_firstvertex;
4739                         break;
4740                 case Q3FACETYPE_PATCH:
4741                         patchsize[0] = LittleLong(in->specific.patch.patchsize[0]);
4742                         patchsize[1] = LittleLong(in->specific.patch.patchsize[1]);
4743                         originalvertex3f = loadmodel->brushq3.data_vertex3f + firstvertex * 3;
4744                         originalnormal3f = loadmodel->brushq3.data_normal3f + firstvertex * 3;
4745                         originaltexcoordtexture2f = loadmodel->brushq3.data_texcoordtexture2f + firstvertex * 2;
4746                         originaltexcoordlightmap2f = loadmodel->brushq3.data_texcoordlightmap2f + firstvertex * 2;
4747                         originalcolor4f = loadmodel->brushq3.data_color4f + firstvertex * 4;
4748                         // convert patch to Q3FACETYPE_MESH
4749                         xtess = Q3PatchTesselationOnX(patchsize[0], patchsize[1], 3, originalvertex3f, r_subdivisions_tolerance.value);
4750                         ytess = Q3PatchTesselationOnY(patchsize[0], patchsize[1], 3, originalvertex3f, r_subdivisions_tolerance.value);
4751                         // bound to user settings
4752                         xtess = bound(r_subdivisions_mintess.integer, xtess, r_subdivisions_maxtess.integer);
4753                         ytess = bound(r_subdivisions_mintess.integer, ytess, r_subdivisions_maxtess.integer);
4754                         // bound to sanity settings
4755                         xtess = bound(1, xtess, 1024);
4756                         ytess = bound(1, ytess, 1024);
4757                         // bound to user limit on vertices
4758                         while ((xtess > 1 || ytess > 1) && (((patchsize[0] - 1) * xtess) + 1) * (((patchsize[1] - 1) * ytess) + 1) > min(r_subdivisions_maxvertices.integer, 262144))
4759                         {
4760                                 if (xtess > ytess)
4761                                         xtess--;
4762                                 else
4763                                         ytess--;
4764                         }
4765                         finalwidth = ((patchsize[0] - 1) * xtess) + 1;
4766                         finalheight = ((patchsize[1] - 1) * ytess) + 1;
4767                         finalvertices = finalwidth * finalheight;
4768                         finaltriangles = (finalwidth - 1) * (finalheight - 1) * 2;
4769                         type = Q3FACETYPE_MESH;
4770                         // generate geometry
4771                         // (note: normals are skipped because they get recalculated)
4772                         Q3PatchTesselateFloat(3, sizeof(float[3]), (loadmodel->surfmesh.data_vertex3f + 3 * out->num_firstvertex), patchsize[0], patchsize[1], sizeof(float[3]), originalvertex3f, xtess, ytess);
4773                         Q3PatchTesselateFloat(3, sizeof(float[3]), (loadmodel->surfmesh.data_normal3f + 3 * out->num_firstvertex), patchsize[0], patchsize[1], sizeof(float[3]), originalnormal3f, xtess, ytess);
4774                         Q3PatchTesselateFloat(2, sizeof(float[2]), (loadmodel->surfmesh.data_texcoordtexture2f + 2 * out->num_firstvertex), patchsize[0], patchsize[1], sizeof(float[2]), originaltexcoordtexture2f, xtess, ytess);
4775                         Q3PatchTesselateFloat(2, sizeof(float[2]), (loadmodel->surfmesh.data_texcoordlightmap2f + 2 * out->num_firstvertex), patchsize[0], patchsize[1], sizeof(float[2]), originaltexcoordlightmap2f, xtess, ytess);
4776                         Q3PatchTesselateFloat(4, sizeof(float[4]), (loadmodel->surfmesh.data_lightmapcolor4f + 4 * out->num_firstvertex), patchsize[0], patchsize[1], sizeof(float[4]), originalcolor4f, xtess, ytess);
4777                         Q3PatchTriangleElements((loadmodel->surfmesh.data_element3i + 3 * out->num_firsttriangle), finalwidth, finalheight, out->num_firstvertex);
4778                         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);
4779                         if (developer.integer >= 100)
4780                         {
4781                                 if (out->num_triangles < finaltriangles)
4782                                         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);
4783                                 else
4784                                         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);
4785                         }
4786                         // q3map does not put in collision brushes for curves... ugh
4787                         // build the lower quality collision geometry
4788                         xtess = Q3PatchTesselationOnX(patchsize[0], patchsize[1], 3, originalvertex3f, r_subdivisions_collision_tolerance.value);
4789                         ytess = Q3PatchTesselationOnY(patchsize[0], patchsize[1], 3, originalvertex3f, r_subdivisions_collision_tolerance.value);
4790                         // bound to user settings
4791                         xtess = bound(r_subdivisions_collision_mintess.integer, xtess, r_subdivisions_collision_maxtess.integer);
4792                         ytess = bound(r_subdivisions_collision_mintess.integer, ytess, r_subdivisions_collision_maxtess.integer);
4793                         // bound to sanity settings
4794                         xtess = bound(1, xtess, 1024);
4795                         ytess = bound(1, ytess, 1024);
4796                         // bound to user limit on vertices
4797                         while ((xtess > 1 || ytess > 1) && (((patchsize[0] - 1) * xtess) + 1) * (((patchsize[1] - 1) * ytess) + 1) > min(r_subdivisions_collision_maxvertices.integer, 262144))
4798                         {
4799                                 if (xtess > ytess)
4800                                         xtess--;
4801                                 else
4802                                         ytess--;
4803                         }
4804                         finalwidth = ((patchsize[0] - 1) * xtess) + 1;
4805                         finalheight = ((patchsize[1] - 1) * ytess) + 1;
4806                         finalvertices = finalwidth * finalheight;
4807                         finaltriangles = (finalwidth - 1) * (finalheight - 1) * 2;
4808
4809                         out->data_collisionvertex3f = (float *)Mem_Alloc(loadmodel->mempool, sizeof(float[3]) * finalvertices);
4810                         out->data_collisionelement3i = (int *)Mem_Alloc(loadmodel->mempool, sizeof(int[3]) * finaltriangles);
4811                         out->num_collisionvertices = finalvertices;
4812                         out->num_collisiontriangles = finaltriangles;
4813                         Q3PatchTesselateFloat(3, sizeof(float[3]), out->data_collisionvertex3f, patchsize[0], patchsize[1], sizeof(float[3]), originalvertex3f, xtess, ytess);
4814                         Q3PatchTriangleElements(out->data_collisionelement3i, finalwidth, finalheight, 0);
4815
4816                         //Mod_SnapVertices(3, out->num_vertices, (loadmodel->surfmesh.data_vertex3f + 3 * out->num_firstvertex), 0.25);
4817                         Mod_SnapVertices(3, out->num_collisionvertices, out->data_collisionvertex3f, 1);
4818
4819                         oldnumtriangles = out->num_triangles;
4820                         oldnumtriangles2 = out->num_collisiontriangles;
4821                         out->num_collisiontriangles = Mod_RemoveDegenerateTriangles(out->num_collisiontriangles, out->data_collisionelement3i, out->data_collisionelement3i, out->data_collisionvertex3f);
4822                         if (developer.integer >= 100)
4823                                 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);
4824                         break;
4825                 default:
4826                         break;
4827                 }
4828                 meshvertices += out->num_vertices;
4829                 meshtriangles += out->num_triangles;
4830                 for (j = 0, invalidelements = 0;j < out->num_triangles * 3;j++)
4831                         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)
4832                                 invalidelements++;
4833                 if (invalidelements)
4834                 {
4835                         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);
4836                         for (j = 0;j < out->num_triangles * 3;j++)
4837                         {
4838                                 Con_Printf(" %i", (loadmodel->surfmesh.data_element3i + 3 * out->num_firsttriangle)[j] - out->num_firstvertex);
4839                                 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)
4840                                         (loadmodel->surfmesh.data_element3i + 3 * out->num_firsttriangle)[j] = out->num_firstvertex;
4841                         }
4842                         Con_Print("\n");
4843                 }
4844                 // calculate a bounding box
4845                 VectorClear(out->mins);
4846                 VectorClear(out->maxs);
4847                 if (out->num_vertices)
4848                 {
4849                         if (cls.state != ca_dedicated && out->lightmaptexture)
4850                         {
4851                                 // figure out which part of the merged lightmap this fits into
4852                                 int lightmapindex = LittleLong(in->lightmapindex) >> loadmodel->brushq3.deluxemapping;
4853                                 int mergewidth = R_TextureWidth(out->lightmaptexture) / 128;
4854                                 int mergeheight = R_TextureHeight(out->lightmaptexture) / 128;
4855                                 lightmapindex &= mergewidth * mergeheight - 1;
4856                                 lightmaptcscale[0] = 1.0f / mergewidth;
4857                                 lightmaptcscale[1] = 1.0f / mergeheight;
4858                                 lightmaptcbase[0] = (lightmapindex % mergewidth) * lightmaptcscale[0];
4859                                 lightmaptcbase[1] = (lightmapindex / mergewidth) * lightmaptcscale[1];
4860                                 // modify the lightmap texcoords to match this region of the merged lightmap
4861                                 for (j = 0, v = loadmodel->surfmesh.data_texcoordlightmap2f + 2 * out->num_firstvertex;j < out->num_vertices;j++, v += 2)
4862                                 {
4863                                         v[0] = v[0] * lightmaptcscale[0] + lightmaptcbase[0];
4864                                         v[1] = v[1] * lightmaptcscale[1] + lightmaptcbase[1];
4865                                 }
4866                         }
4867                         VectorCopy((loadmodel->surfmesh.data_vertex3f + 3 * out->num_firstvertex), out->mins);
4868                         VectorCopy((loadmodel->surfmesh.data_vertex3f + 3 * out->num_firstvertex), out->maxs);
4869                         for (j = 1, v = (loadmodel->surfmesh.data_vertex3f + 3 * out->num_firstvertex) + 3;j < out->num_vertices;j++, v += 3)
4870                         {
4871                                 out->mins[0] = min(out->mins[0], v[0]);
4872                                 out->maxs[0] = max(out->maxs[0], v[0]);
4873                                 out->mins[1] = min(out->mins[1], v[1]);
4874                                 out->maxs[1] = max(out->maxs[1], v[1]);
4875                                 out->mins[2] = min(out->mins[2], v[2]);
4876                                 out->maxs[2] = max(out->maxs[2], v[2]);
4877                         }
4878                         out->mins[0] -= 1.0f;
4879                         out->mins[1] -= 1.0f;
4880                         out->mins[2] -= 1.0f;
4881                         out->maxs[0] += 1.0f;
4882                         out->maxs[1] += 1.0f;
4883                         out->maxs[2] += 1.0f;
4884                 }
4885                 // set lightmap styles for consistency with q1bsp
4886                 //out->lightmapinfo->styles[0] = 0;
4887                 //out->lightmapinfo->styles[1] = 255;
4888                 //out->lightmapinfo->styles[2] = 255;
4889                 //out->lightmapinfo->styles[3] = 255;
4890         }
4891
4892         // for per pixel lighting
4893         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);
4894
4895         // free the no longer needed vertex data
4896         loadmodel->brushq3.num_vertices = 0;
4897         if (loadmodel->brushq3.data_vertex3f)
4898                 Mem_Free(loadmodel->brushq3.data_vertex3f);
4899         loadmodel->brushq3.data_vertex3f = NULL;
4900         loadmodel->brushq3.data_normal3f = NULL;
4901         loadmodel->brushq3.data_texcoordtexture2f = NULL;
4902         loadmodel->brushq3.data_texcoordlightmap2f = NULL;
4903         loadmodel->brushq3.data_color4f = NULL;
4904         // free the no longer needed triangle data
4905         loadmodel->brushq3.num_triangles = 0;
4906         if (loadmodel->brushq3.data_element3i)
4907                 Mem_Free(loadmodel->brushq3.data_element3i);
4908         loadmodel->brushq3.data_element3i = NULL;
4909 }
4910
4911 static void Mod_Q3BSP_LoadModels(lump_t *l)
4912 {
4913         q3dmodel_t *in;
4914         q3dmodel_t *out;
4915         int i, j, n, c, count;
4916
4917         in = (q3dmodel_t *)(mod_base + l->fileofs);
4918         if (l->filelen % sizeof(*in))
4919                 Host_Error("Mod_Q3BSP_LoadModels: funny lump size in %s",loadmodel->name);
4920         count = l->filelen / sizeof(*in);
4921         out = (q3dmodel_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
4922
4923         loadmodel->brushq3.data_models = out;
4924         loadmodel->brushq3.num_models = count;
4925
4926         for (i = 0;i < count;i++, in++, out++)
4927         {
4928                 for (j = 0;j < 3;j++)
4929                 {
4930                         out->mins[j] = LittleFloat(in->mins[j]);
4931                         out->maxs[j] = LittleFloat(in->maxs[j]);
4932                 }
4933                 n = LittleLong(in->firstface);
4934                 c = LittleLong(in->numfaces);
4935                 if (n < 0 || n + c > loadmodel->num_surfaces)
4936                         Host_Error("Mod_Q3BSP_LoadModels: invalid face range %i : %i (%i faces)", n, n + c, loadmodel->num_surfaces);
4937                 out->firstface = n;
4938                 out->numfaces = c;
4939                 n = LittleLong(in->firstbrush);
4940                 c = LittleLong(in->numbrushes);
4941                 if (n < 0 || n + c > loadmodel->brush.num_brushes)
4942                         Host_Error("Mod_Q3BSP_LoadModels: invalid brush range %i : %i (%i brushes)", n, n + c, loadmodel->brush.num_brushes);
4943                 out->firstbrush = n;
4944                 out->numbrushes = c;
4945         }
4946 }
4947
4948 static void Mod_Q3BSP_LoadLeafBrushes(lump_t *l)
4949 {
4950         int *in;
4951         int *out;
4952         int i, n, count;
4953
4954         in = (int *)(mod_base + l->fileofs);
4955         if (l->filelen % sizeof(*in))
4956                 Host_Error("Mod_Q3BSP_LoadLeafBrushes: funny lump size in %s",loadmodel->name);
4957         count = l->filelen / sizeof(*in);
4958         out = (int *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
4959
4960         loadmodel->brush.data_leafbrushes = out;
4961         loadmodel->brush.num_leafbrushes = count;
4962
4963         for (i = 0;i < count;i++, in++, out++)
4964         {
4965                 n = LittleLong(*in);
4966                 if (n < 0 || n >= loadmodel->brush.num_brushes)
4967                         Host_Error("Mod_Q3BSP_LoadLeafBrushes: invalid brush index %i (%i brushes)", n, loadmodel->brush.num_brushes);
4968                 *out = n;
4969         }
4970 }
4971
4972 static void Mod_Q3BSP_LoadLeafFaces(lump_t *l)
4973 {
4974         int *in;
4975         int *out;
4976         int i, n, count;
4977
4978         in = (int *)(mod_base + l->fileofs);
4979         if (l->filelen % sizeof(*in))
4980                 Host_Error("Mod_Q3BSP_LoadLeafFaces: funny lump size in %s",loadmodel->name);
4981         count = l->filelen / sizeof(*in);
4982         out = (int *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
4983
4984         loadmodel->brush.data_leafsurfaces = out;
4985         loadmodel->brush.num_leafsurfaces = count;
4986
4987         for (i = 0;i < count;i++, in++, out++)
4988         {
4989                 n = LittleLong(*in);
4990                 if (n < 0 || n >= loadmodel->num_surfaces)
4991                         Host_Error("Mod_Q3BSP_LoadLeafFaces: invalid face index %i (%i faces)", n, loadmodel->num_surfaces);
4992                 *out = n;
4993         }
4994 }
4995
4996 static void Mod_Q3BSP_LoadLeafs(lump_t *l)
4997 {
4998         q3dleaf_t *in;
4999         mleaf_t *out;
5000         int i, j, n, c, count;
5001
5002         in = (q3dleaf_t *)(mod_base + l->fileofs);
5003         if (l->filelen % sizeof(*in))
5004                 Host_Error("Mod_Q3BSP_LoadLeafs: funny lump size in %s",loadmodel->name);
5005         count = l->filelen / sizeof(*in);
5006         out = (mleaf_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
5007
5008         loadmodel->brush.data_leafs = out;
5009         loadmodel->brush.num_leafs = count;
5010
5011         for (i = 0;i < count;i++, in++, out++)
5012         {
5013                 out->parent = NULL;
5014                 out->plane = NULL;
5015                 out->clusterindex = LittleLong(in->clusterindex);
5016                 out->areaindex = LittleLong(in->areaindex);
5017                 for (j = 0;j < 3;j++)
5018                 {
5019                         // yes the mins/maxs are ints
5020                         out->mins[j] = LittleLong(in->mins[j]) - 1;
5021                         out->maxs[j] = LittleLong(in->maxs[j]) + 1;
5022                 }
5023                 n = LittleLong(in->firstleafface);
5024                 c = LittleLong(in->numleaffaces);
5025                 if (n < 0 || n + c > loadmodel->brush.num_leafsurfaces)
5026                         Host_Error("Mod_Q3BSP_LoadLeafs: invalid leafsurface range %i : %i (%i leafsurfaces)", n, n + c, loadmodel->brush.num_leafsurfaces);
5027                 out->firstleafsurface = loadmodel->brush.data_leafsurfaces + n;
5028                 out->numleafsurfaces = c;
5029                 n = LittleLong(in->firstleafbrush);
5030                 c = LittleLong(in->numleafbrushes);
5031                 if (n < 0 || n + c > loadmodel->brush.num_leafbrushes)
5032                         Host_Error("Mod_Q3BSP_LoadLeafs: invalid leafbrush range %i : %i (%i leafbrushes)", n, n + c, loadmodel->brush.num_leafbrushes);
5033                 out->firstleafbrush = loadmodel->brush.data_leafbrushes + n;
5034                 out->numleafbrushes = c;
5035         }
5036 }
5037
5038 static void Mod_Q3BSP_LoadNodes(lump_t *l)
5039 {
5040         q3dnode_t *in;
5041         mnode_t *out;
5042         int i, j, n, count;
5043
5044         in = (q3dnode_t *)(mod_base + l->fileofs);
5045         if (l->filelen % sizeof(*in))
5046                 Host_Error("Mod_Q3BSP_LoadNodes: funny lump size in %s",loadmodel->name);
5047         count = l->filelen / sizeof(*in);
5048         out = (mnode_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
5049
5050         loadmodel->brush.data_nodes = out;
5051         loadmodel->brush.num_nodes = count;
5052
5053         for (i = 0;i < count;i++, in++, out++)
5054         {
5055                 out->parent = NULL;
5056                 n = LittleLong(in->planeindex);
5057                 if (n < 0 || n >= loadmodel->brush.num_planes)
5058                         Host_Error("Mod_Q3BSP_LoadNodes: invalid planeindex %i (%i planes)", n, loadmodel->brush.num_planes);
5059                 out->plane = loadmodel->brush.data_planes + n;
5060                 for (j = 0;j < 2;j++)
5061                 {
5062                         n = LittleLong(in->childrenindex[j]);
5063                         if (n >= 0)
5064                         {
5065                                 if (n >= loadmodel->brush.num_nodes)
5066                                         Host_Error("Mod_Q3BSP_LoadNodes: invalid child node index %i (%i nodes)", n, loadmodel->brush.num_nodes);
5067                                 out->children[j] = loadmodel->brush.data_nodes + n;
5068                         }
5069                         else
5070                         {
5071                                 n = -1 - n;
5072                                 if (n >= loadmodel->brush.num_leafs)
5073                                         Host_Error("Mod_Q3BSP_LoadNodes: invalid child leaf index %i (%i leafs)", n, loadmodel->brush.num_leafs);
5074                                 out->children[j] = (mnode_t *)(loadmodel->brush.data_leafs + n);
5075                         }
5076                 }
5077                 for (j = 0;j < 3;j++)
5078                 {
5079                         // yes the mins/maxs are ints
5080                         out->mins[j] = LittleLong(in->mins[j]) - 1;
5081                         out->maxs[j] = LittleLong(in->maxs[j]) + 1;
5082                 }
5083         }
5084
5085         // set the parent pointers
5086         Mod_Q1BSP_LoadNodes_RecursiveSetParent(loadmodel->brush.data_nodes, NULL);
5087 }
5088
5089 static void Mod_Q3BSP_LoadLightGrid(lump_t *l)
5090 {
5091         q3dlightgrid_t *in;
5092         q3dlightgrid_t *out;
5093         int count;
5094
5095         in = (q3dlightgrid_t *)(mod_base + l->fileofs);
5096         if (l->filelen % sizeof(*in))
5097                 Host_Error("Mod_Q3BSP_LoadLightGrid: funny lump size in %s",loadmodel->name);
5098         loadmodel->brushq3.num_lightgrid_scale[0] = 1.0f / loadmodel->brushq3.num_lightgrid_cellsize[0];
5099         loadmodel->brushq3.num_lightgrid_scale[1] = 1.0f / loadmodel->brushq3.num_lightgrid_cellsize[1];
5100         loadmodel->brushq3.num_lightgrid_scale[2] = 1.0f / loadmodel->brushq3.num_lightgrid_cellsize[2];
5101         loadmodel->brushq3.num_lightgrid_imins[0] = (int)ceil(loadmodel->brushq3.data_models->mins[0] * loadmodel->brushq3.num_lightgrid_scale[0]);
5102         loadmodel->brushq3.num_lightgrid_imins[1] = (int)ceil(loadmodel->brushq3.data_models->mins[1] * loadmodel->brushq3.num_lightgrid_scale[1]);
5103         loadmodel->brushq3.num_lightgrid_imins[2] = (int)ceil(loadmodel->brushq3.data_models->mins[2] * loadmodel->brushq3.num_lightgrid_scale[2]);
5104         loadmodel->brushq3.num_lightgrid_imaxs[0] = (int)floor(loadmodel->brushq3.data_models->maxs[0] * loadmodel->brushq3.num_lightgrid_scale[0]);
5105         loadmodel->brushq3.num_lightgrid_imaxs[1] = (int)floor(loadmodel->brushq3.data_models->maxs[1] * loadmodel->brushq3.num_lightgrid_scale[1]);
5106         loadmodel->brushq3.num_lightgrid_imaxs[2] = (int)floor(loadmodel->brushq3.data_models->maxs[2] * loadmodel->brushq3.num_lightgrid_scale[2]);
5107         loadmodel->brushq3.num_lightgrid_isize[0] = loadmodel->brushq3.num_lightgrid_imaxs[0] - loadmodel->brushq3.num_lightgrid_imins[0] + 1;
5108         loadmodel->brushq3.num_lightgrid_isize[1] = loadmodel->brushq3.num_lightgrid_imaxs[1] - loadmodel->brushq3.num_lightgrid_imins[1] + 1;
5109         loadmodel->brushq3.num_lightgrid_isize[2] = loadmodel->brushq3.num_lightgrid_imaxs[2] - loadmodel->brushq3.num_lightgrid_imins[2] + 1;
5110         count = loadmodel->brushq3.num_lightgrid_isize[0] * loadmodel->brushq3.num_lightgrid_isize[1] * loadmodel->brushq3.num_lightgrid_isize[2];
5111         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]);
5112         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]);
5113
5114         // if lump is empty there is nothing to load, we can deal with that in the LightPoint code
5115         if (l->filelen)
5116         {
5117                 if (l->filelen < count * (int)sizeof(*in))
5118                         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]);
5119                 if (l->filelen != count * (int)sizeof(*in))
5120                         Con_Printf("Mod_Q3BSP_LoadLightGrid: Warning: calculated lightgrid size %i bytes does not match lump size %i\n", (int)(count * sizeof(*in)), l->filelen);
5121                 out = (q3dlightgrid_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
5122                 loadmodel->brushq3.data_lightgrid = out;
5123                 loadmodel->brushq3.num_lightgrid = count;
5124                 // no swapping or validation necessary
5125                 memcpy(out, in, count * (int)sizeof(*out));
5126         }
5127 }
5128
5129 static void Mod_Q3BSP_LoadPVS(lump_t *l)
5130 {
5131         q3dpvs_t *in;
5132         int totalchains;
5133
5134         if (l->filelen == 0)
5135         {
5136                 int i;
5137                 // unvised maps often have cluster indices even without pvs, so check
5138                 // leafs to find real number of clusters
5139                 loadmodel->brush.num_pvsclusters = 1;
5140                 for (i = 0;i < loadmodel->brush.num_leafs;i++)
5141                         loadmodel->brush.num_pvsclusters = max(loadmodel->brush.num_pvsclusters, loadmodel->brush.data_leafs[i].clusterindex + 1);
5142
5143                 // create clusters
5144                 loadmodel->brush.num_pvsclusterbytes = (loadmodel->brush.num_pvsclusters + 7) / 8;
5145                 totalchains = loadmodel->brush.num_pvsclusterbytes * loadmodel->brush.num_pvsclusters;
5146                 loadmodel->brush.data_pvsclusters = (unsigned char *)Mem_Alloc(loadmodel->mempool, totalchains);
5147                 memset(loadmodel->brush.data_pvsclusters, 0xFF, totalchains);
5148                 return;
5149         }
5150
5151         in = (q3dpvs_t *)(mod_base + l->fileofs);
5152         if (l->filelen < 9)
5153                 Host_Error("Mod_Q3BSP_LoadPVS: funny lump size in %s",loadmodel->name);
5154
5155         loadmodel->brush.num_pvsclusters = LittleLong(in->numclusters);
5156         loadmodel->brush.num_pvsclusterbytes = LittleLong(in->chainlength);
5157         if (loadmodel->brush.num_pvsclusterbytes < ((loadmodel->brush.num_pvsclusters + 7) / 8))
5158                 Host_Error("Mod_Q3BSP_LoadPVS: (chainlength = %i) < ((numclusters = %i) + 7) / 8", loadmodel->brush.num_pvsclusterbytes, loadmodel->brush.num_pvsclusters);
5159         totalchains = loadmodel->brush.num_pvsclusterbytes * loadmodel->brush.num_pvsclusters;
5160         if (l->filelen < totalchains + (int)sizeof(*in))
5161                 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);
5162
5163         loadmodel->brush.data_pvsclusters = (unsigned char *)Mem_Alloc(loadmodel->mempool, totalchains);
5164         memcpy(loadmodel->brush.data_pvsclusters, (unsigned char *)(in + 1), totalchains);
5165 }
5166
5167 static void Mod_Q3BSP_LightPoint(model_t *model, const vec3_t p, vec3_t ambientcolor, vec3_t diffusecolor, vec3_t diffusenormal)
5168 {
5169         int i, j, k, index[3];
5170         float transformed[3], blend1, blend2, blend, stylescale;
5171         q3dlightgrid_t *a, *s;
5172
5173         // scale lighting by lightstyle[0] so that darkmode in dpmod works properly
5174         stylescale = r_refdef.lightstylevalue[0] * (1.0f / 264.0f);
5175
5176         if (!model->brushq3.num_lightgrid)
5177         {
5178                 ambientcolor[0] = stylescale;
5179                 ambientcolor[1] = stylescale;
5180                 ambientcolor[2] = stylescale;
5181                 return;
5182         }
5183
5184         Matrix4x4_Transform(&model->brushq3.num_lightgrid_indexfromworld, p, transformed);
5185         //Matrix4x4_Print(&model->brushq3.num_lightgrid_indexfromworld);
5186         //Con_Printf("%f %f %f transformed %f %f %f clamped ", p[0], p[1], p[2], transformed[0], transformed[1], transformed[2]);
5187         transformed[0] = bound(0, transformed[0], model->brushq3.num_lightgrid_isize[0] - 1);
5188         transformed[1] = bound(0, transformed[1], model->brushq3.num_lightgrid_isize[1] - 1);
5189         transformed[2] = bound(0, transformed[2], model->brushq3.num_lightgrid_isize[2] - 1);
5190         index[0] = (int)floor(transformed[0]);
5191         index[1] = (int)floor(transformed[1]);
5192         index[2] = (int)floor(transformed[2]);
5193         //Con_Printf("%f %f %f index %i %i %i:\n", transformed[0], transformed[1], transformed[2], index[0], index[1], index[2]);
5194
5195         // now lerp the values
5196         VectorClear(diffusenormal);
5197         a = &model->brushq3.data_lightgrid[(index[2] * model->brushq3.num_lightgrid_isize[1] + index[1]) * model->brushq3.num_lightgrid_isize[0] + index[0]];
5198         for (k = 0;k < 2;k++)
5199         {
5200                 blend1 = (k ? (transformed[2] - index[2]) : (1 - (transformed[2] - index[2])));
5201                 if (blend1 < 0.001f || index[2] + k >= model->brushq3.num_lightgrid_isize[2])
5202                         continue;
5203                 for (j = 0;j < 2;j++)
5204                 {
5205                         blend2 = blend1 * (j ? (transformed[1] - index[1]) : (1 - (transformed[1] - index[1])));
5206                         if (blend2 < 0.001f || index[1] + j >= model->brushq3.num_lightgrid_isize[1])
5207                                 continue;
5208                         for (i = 0;i < 2;i++)
5209                         {
5210                                 blend = blend2 * (i ? (transformed[0] - index[0]) : (1 - (transformed[0] - index[0]))) * stylescale;
5211                                 if (blend < 0.001f || index[0] + i >= model->brushq3.num_lightgrid_isize[0])
5212                                         continue;
5213                                 s = a + (k * model->brushq3.num_lightgrid_isize[1] + j) * model->brushq3.num_lightgrid_isize[0] + i;
5214                                 VectorMA(ambientcolor, blend * (1.0f / 128.0f), s->ambientrgb, ambientcolor);
5215                                 VectorMA(diffusecolor, blend * (1.0f / 128.0f), s->diffusergb, diffusecolor);
5216                                 // this uses the mod_md3_sin table because the values are
5217                                 // already in the 0-255 range, the 64+ bias fetches a cosine
5218                                 // instead of a sine value
5219                                 diffusenormal[0] += blend * (mod_md3_sin[64 + s->diffuseyaw] * mod_md3_sin[s->diffusepitch]);
5220                                 diffusenormal[1] += blend * (mod_md3_sin[     s->diffuseyaw] * mod_md3_sin[s->diffusepitch]);
5221                                 diffusenormal[2] += blend * (mod_md3_sin[64 + s->diffusepitch]);
5222                                 //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)));
5223                         }
5224                 }
5225         }
5226
5227         // normalize the light direction before turning
5228         VectorNormalize(diffusenormal);
5229         //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]);
5230 }
5231
5232 static void Mod_Q3BSP_TracePoint_RecursiveBSPNode(trace_t *trace, model_t *model, mnode_t *node, const vec3_t point, int markframe)
5233 {
5234         int i;
5235         mleaf_t *leaf;
5236         colbrushf_t *brush;
5237         // find which leaf the point is in
5238         while (node->plane)
5239                 node = node->children[DotProduct(point, node->plane->normal) < node->plane->dist];
5240         // point trace the brushes
5241         leaf = (mleaf_t *)node;
5242         for (i = 0;i < leaf->numleafbrushes;i++)
5243         {
5244                 brush = model->brush.data_brushes[leaf->firstleafbrush[i]].colbrushf;
5245                 if (brush && brush->markframe != markframe && BoxesOverlap(point, point, brush->mins, brush->maxs))
5246                 {
5247                         brush->markframe = markframe;
5248                         Collision_TracePointBrushFloat(trace, point, brush);
5249                 }
5250         }
5251         // can't do point traces on curves (they have no thickness)
5252 }
5253
5254 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)
5255 {
5256         int i, startside, endside;
5257         float dist1, dist2, midfrac, mid[3], nodesegmentmins[3], nodesegmentmaxs[3];
5258         mleaf_t *leaf;
5259         msurface_t *surface;
5260         mplane_t *plane;
5261         colbrushf_t *brush;
5262         // walk the tree until we hit a leaf, recursing for any split cases
5263         while (node->plane)
5264         {
5265                 // abort if this part of the bsp tree can not be hit by this trace
5266 //              if (!(node->combinedsupercontents & trace->hitsupercontentsmask))
5267 //                      return;
5268                 plane = node->plane;
5269                 // axial planes are much more common than non-axial, so an optimized
5270                 // axial case pays off here
5271                 if (plane->type < 3)
5272                 {
5273                         dist1 = start[plane->type] - plane->dist;
5274                         dist2 = end[plane->type] - plane->dist;
5275                 }
5276                 else
5277                 {
5278                         dist1 = DotProduct(start, plane->normal) - plane->dist;
5279                         dist2 = DotProduct(end, plane->normal) - plane->dist;
5280                 }
5281                 startside = dist1 < 0;
5282                 endside = dist2 < 0;
5283                 if (startside == endside)
5284                 {
5285                         // most of the time the line fragment is on one side of the plane
5286                         node = node->children[startside];
5287                 }
5288                 else
5289                 {
5290                         // line crosses node plane, split the line
5291                         dist1 = PlaneDiff(linestart, plane);
5292                         dist2 = PlaneDiff(lineend, plane);
5293                         midfrac = dist1 / (dist1 - dist2);
5294                         VectorLerp(linestart, midfrac, lineend, mid);
5295                         // take the near side first
5296                         Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace, model, node->children[startside], start, mid, startfrac, midfrac, linestart, lineend, markframe, segmentmins, segmentmaxs);
5297                         // if we found an impact on the front side, don't waste time
5298                         // exploring the far side
5299                         if (midfrac <= trace->realfraction)
5300                                 Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace, model, node->children[endside], mid, end, midfrac, endfrac, linestart, lineend, markframe, segmentmins, segmentmaxs);
5301                         return;
5302                 }
5303         }
5304         // abort if this part of the bsp tree can not be hit by this trace
5305 //      if (!(node->combinedsupercontents & trace->hitsupercontentsmask))
5306 //              return;
5307         // hit a leaf
5308         nodesegmentmins[0] = min(start[0], end[0]) - 1;
5309         nodesegmentmins[1] = min(start[1], end[1]) - 1;
5310         nodesegmentmins[2] = min(start[2], end[2]) - 1;
5311         nodesegmentmaxs[0] = max(start[0], end[0]) + 1;
5312         nodesegmentmaxs[1] = max(start[1], end[1]) + 1;
5313         nodesegmentmaxs[2] = max(start[2], end[2]) + 1;
5314         // line trace the brushes
5315         leaf = (mleaf_t *)node;
5316         for (i = 0;i < leaf->numleafbrushes;i++)
5317         {
5318                 brush = model->brush.data_brushes[leaf->firstleafbrush[i]].colbrushf;
5319                 if (brush && brush->markframe != markframe && BoxesOverlap(nodesegmentmins, nodesegmentmaxs, brush->mins, brush->maxs))
5320                 {
5321                         brush->markframe = markframe;
5322                         Collision_TraceLineBrushFloat(trace, linestart, lineend, brush, brush);
5323                 }
5324         }
5325         // can't do point traces on curves (they have no thickness)
5326         if (leaf->containscollisionsurfaces && mod_q3bsp_curves_collisions.integer && !VectorCompare(start, end))
5327         {
5328                 // line trace the curves
5329                 for (i = 0;i < leaf->numleafsurfaces;i++)
5330                 {
5331                         surface = model->data_surfaces + leaf->firstleafsurface[i];
5332                         if (surface->num_collisiontriangles && surface->collisionmarkframe != markframe && BoxesOverlap(nodesegmentmins, nodesegmentmaxs, surface->mins, surface->maxs))
5333                         {
5334                                 surface->collisionmarkframe = markframe;
5335                                 Collision_TraceLineTriangleMeshFloat(trace, linestart, lineend, surface->num_collisiontriangles, surface->data_collisionelement3i, surface->data_collisionvertex3f, surface->texture->supercontents, surface->texture->surfaceflags, surface->texture, segmentmins, segmentmaxs);
5336                         }
5337                 }
5338         }
5339 }
5340
5341 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)
5342 {
5343         int i;
5344         int sides;
5345         mleaf_t *leaf;
5346         colbrushf_t *brush;
5347         msurface_t *surface;
5348         mplane_t *plane;
5349         float nodesegmentmins[3], nodesegmentmaxs[3];
5350         // walk the tree until we hit a leaf, recursing for any split cases
5351         while (node->plane)
5352         {
5353                 // abort if this part of the bsp tree can not be hit by this trace
5354 //              if (!(node->combinedsupercontents & trace->hitsupercontentsmask))
5355 //                      return;
5356                 plane = node->plane;
5357                 // axial planes are much more common than non-axial, so an optimized
5358                 // axial case pays off here
5359                 if (plane->type < 3)
5360                 {
5361                         // this is an axial plane, compare bounding box directly to it and
5362                         // recurse sides accordingly
5363                         // recurse down node sides
5364                         // use an inlined axial BoxOnPlaneSide to slightly reduce overhead
5365                         //sides = BoxOnPlaneSide(nodesegmentmins, nodesegmentmaxs, plane);
5366                         //sides = ((segmentmaxs[plane->type] >= plane->dist) | ((segmentmins[plane->type] < plane->dist) << 1));
5367                         sides = ((segmentmaxs[plane->type] >= plane->dist) + ((segmentmins[plane->type] < plane->dist) * 2));
5368                 }
5369                 else
5370                 {
5371                         // this is a non-axial plane, so check if the start and end boxes
5372                         // are both on one side of the plane to handle 'diagonal' cases
5373                         sides = BoxOnPlaneSide(thisbrush_start->mins, thisbrush_start->maxs, plane) | BoxOnPlaneSide(thisbrush_end->mins, thisbrush_end->maxs, plane);
5374                 }
5375                 if (sides == 3)
5376                 {
5377                         // segment crosses plane
5378                         Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, model, node->children[0], thisbrush_start, thisbrush_end, markframe, segmentmins, segmentmaxs);
5379                         sides = 2;
5380                 }
5381                 // if sides == 0 then the trace itself is bogus (Not A Number values),
5382                 // in this case we simply pretend the trace hit nothing
5383                 if (sides == 0)
5384                         return; // ERROR: NAN bounding box!
5385                 // take whichever side the segment box is on
5386                 node = node->children[sides - 1];
5387         }
5388         // abort if this part of the bsp tree can not be hit by this trace
5389 //      if (!(node->combinedsupercontents & trace->hitsupercontentsmask))
5390 //              return;
5391         nodesegmentmins[0] = max(segmentmins[0], node->mins[0] - 1);
5392         nodesegmentmins[1] = max(segmentmins[1], node->mins[1] - 1);
5393         nodesegmentmins[2] = max(segmentmins[2], node->mins[2] - 1);
5394         nodesegmentmaxs[0] = min(segmentmaxs[0], node->maxs[0] + 1);
5395         nodesegmentmaxs[1] = min(segmentmaxs[1], node->maxs[1] + 1);
5396         nodesegmentmaxs[2] = min(segmentmaxs[2], node->maxs[2] + 1);
5397         // hit a leaf
5398         leaf = (mleaf_t *)node;
5399         for (i = 0;i < leaf->numleafbrushes;i++)
5400         {
5401                 brush = model->brush.data_brushes[leaf->firstleafbrush[i]].colbrushf;
5402                 if (brush && brush->markframe != markframe && BoxesOverlap(nodesegmentmins, nodesegmentmaxs, brush->mins, brush->maxs))
5403                 {
5404                         brush->markframe = markframe;
5405                         Collision_TraceBrushBrushFloat(trace, thisbrush_start, thisbrush_end, brush, brush);
5406                 }
5407         }
5408         if (leaf->containscollisionsurfaces && mod_q3bsp_curves_collisions.integer)
5409         {
5410                 for (i = 0;i < leaf->numleafsurfaces;i++)
5411                 {
5412                         surface = model->data_surfaces + leaf->firstleafsurface[i];
5413                         if (surface->num_collisiontriangles && surface->collisionmarkframe != markframe && BoxesOverlap(nodesegmentmins, nodesegmentmaxs, surface->mins, surface->maxs))
5414                         {
5415                                 surface->collisionmarkframe = markframe;
5416                                 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);
5417                         }
5418                 }
5419         }
5420 }
5421
5422 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)
5423 {
5424         int i;
5425         float segmentmins[3], segmentmaxs[3];
5426         static int markframe = 0;
5427         msurface_t *surface;
5428         q3mbrush_t *brush;
5429         memset(trace, 0, sizeof(*trace));
5430         trace->fraction = 1;
5431         trace->realfraction = 1;
5432         trace->hitsupercontentsmask = hitsupercontentsmask;
5433         if (mod_q3bsp_optimizedtraceline.integer && VectorLength2(boxmins) + VectorLength2(boxmaxs) == 0)
5434         {
5435                 if (VectorCompare(start, end))
5436                 {
5437                         // point trace
5438                         if (model->brush.submodel)
5439                         {
5440                                 for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++)
5441                                         if (brush->colbrushf)
5442                                                 Collision_TracePointBrushFloat(trace, start, brush->colbrushf);
5443                         }
5444                         else
5445                                 Mod_Q3BSP_TracePoint_RecursiveBSPNode(trace, model, model->brush.data_nodes, start, ++markframe);
5446                 }
5447                 else
5448                 {
5449                         // line trace
5450                         segmentmins[0] = min(start[0], end[0]) - 1;
5451                         segmentmins[1] = min(start[1], end[1]) - 1;
5452                         segmentmins[2] = min(start[2], end[2]) - 1;
5453                         segmentmaxs[0] = max(start[0], end[0]) + 1;
5454                         segmentmaxs[1] = max(start[1], end[1]) + 1;
5455                         segmentmaxs[2] = max(start[2], end[2]) + 1;
5456                         if (model->brush.submodel)
5457                         {
5458                                 for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++)
5459                                         if (brush->colbrushf)
5460                                                 Collision_TraceLineBrushFloat(trace, start, end, brush->colbrushf, brush->colbrushf);
5461                                 if (mod_q3bsp_curves_collisions.integer)
5462                                         for (i = 0, surface = model->data_surfaces + model->firstmodelsurface;i < model->nummodelsurfaces;i++, surface++)
5463                                                 if (surface->num_collisiontriangles)
5464                                                         Collision_TraceLineTriangleMeshFloat(trace, start, end, surface->num_collisiontriangles, surface->data_collisionelement3i, surface->data_collisionvertex3f, surface->texture->supercontents, surface->texture->surfaceflags, surface->texture, segmentmins, segmentmaxs);
5465                         }
5466                         else
5467                                 Mod_Q3BSP_TraceLine_RecursiveBSPNode(trace, model, model->brush.data_nodes, start, end, 0, 1, start, end, ++markframe, segmentmins, segmentmaxs);
5468                 }
5469         }
5470         else
5471         {
5472                 // box trace, performed as brush trace
5473                 colbrushf_t *thisbrush_start, *thisbrush_end;
5474                 vec3_t boxstartmins, boxstartmaxs, boxendmins, boxendmaxs;
5475                 segmentmins[0] = min(start[0], end[0]) + boxmins[0] - 1;
5476                 segmentmins[1] = min(start[1], end[1]) + boxmins[1] - 1;
5477                 segmentmins[2] = min(start[2], end[2]) + boxmins[2] - 1;
5478                 segmentmaxs[0] = max(start[0], end[0]) + boxmaxs[0] + 1;
5479                 segmentmaxs[1] = max(start[1], end[1]) + boxmaxs[1] + 1;
5480                 segmentmaxs[2] = max(start[2], end[2]) + boxmaxs[2] + 1;
5481                 VectorAdd(start, boxmins, boxstartmins);
5482                 VectorAdd(start, boxmaxs, boxstartmaxs);
5483                 VectorAdd(end, boxmins, boxendmins);
5484                 VectorAdd(end, boxmaxs, boxendmaxs);
5485                 thisbrush_start = Collision_BrushForBox(&identitymatrix, boxstartmins, boxstartmaxs, 0, 0, NULL);
5486                 thisbrush_end = Collision_BrushForBox(&identitymatrix, boxendmins, boxendmaxs, 0, 0, NULL);
5487                 if (model->brush.submodel)
5488                 {
5489                         for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++)
5490                                 if (brush->colbrushf)
5491                                         Collision_TraceBrushBrushFloat(trace, thisbrush_start, thisbrush_end, brush->colbrushf, brush->colbrushf);
5492                         if (mod_q3bsp_curves_collisions.integer)
5493                                 for (i = 0, surface = model->data_surfaces + model->firstmodelsurface;i < model->nummodelsurfaces;i++, surface++)
5494                                         if (surface->num_collisiontriangles)
5495                                                 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);
5496                 }
5497                 else
5498                         Mod_Q3BSP_TraceBrush_RecursiveBSPNode(trace, model, model->brush.data_nodes, thisbrush_start, thisbrush_end, ++markframe, segmentmins, segmentmaxs);
5499         }
5500 }
5501
5502 static int Mod_Q3BSP_SuperContentsFromNativeContents(model_t *model, int nativecontents)
5503 {
5504         int supercontents = 0;
5505         if (nativecontents & CONTENTSQ3_SOLID)
5506                 supercontents |= SUPERCONTENTS_SOLID;
5507         if (nativecontents & CONTENTSQ3_WATER)
5508                 supercontents |= SUPERCONTENTS_WATER;
5509         if (nativecontents & CONTENTSQ3_SLIME)
5510                 supercontents |= SUPERCONTENTS_SLIME;
5511         if (nativecontents & CONTENTSQ3_LAVA)
5512                 supercontents |= SUPERCONTENTS_LAVA;
5513         if (nativecontents & CONTENTSQ3_BODY)
5514                 supercontents |= SUPERCONTENTS_BODY;
5515         if (nativecontents & CONTENTSQ3_CORPSE)
5516                 supercontents |= SUPERCONTENTS_CORPSE;
5517         if (nativecontents & CONTENTSQ3_NODROP)
5518                 supercontents |= SUPERCONTENTS_NODROP;
5519         if (nativecontents & CONTENTSQ3_PLAYERCLIP)
5520                 supercontents |= SUPERCONTENTS_PLAYERCLIP;
5521         if (nativecontents & CONTENTSQ3_MONSTERCLIP)
5522                 supercontents |= SUPERCONTENTS_MONSTERCLIP;
5523         if (nativecontents & CONTENTSQ3_DONOTENTER)
5524                 supercontents |= SUPERCONTENTS_DONOTENTER;
5525         return supercontents;
5526 }
5527
5528 static int Mod_Q3BSP_NativeContentsFromSuperContents(model_t *model, int supercontents)
5529 {
5530         int nativecontents = 0;
5531         if (supercontents & SUPERCONTENTS_SOLID)
5532                 nativecontents |= CONTENTSQ3_SOLID;
5533         if (supercontents & SUPERCONTENTS_WATER)
5534                 nativecontents |= CONTENTSQ3_WATER;
5535         if (supercontents & SUPERCONTENTS_SLIME)
5536                 nativecontents |= CONTENTSQ3_SLIME;
5537         if (supercontents & SUPERCONTENTS_LAVA)
5538                 nativecontents |= CONTENTSQ3_LAVA;
5539         if (supercontents & SUPERCONTENTS_BODY)
5540                 nativecontents |= CONTENTSQ3_BODY;
5541         if (supercontents & SUPERCONTENTS_CORPSE)
5542                 nativecontents |= CONTENTSQ3_CORPSE;
5543         if (supercontents & SUPERCONTENTS_NODROP)
5544                 nativecontents |= CONTENTSQ3_NODROP;
5545         if (supercontents & SUPERCONTENTS_PLAYERCLIP)
5546                 nativecontents |= CONTENTSQ3_PLAYERCLIP;
5547         if (supercontents & SUPERCONTENTS_MONSTERCLIP)
5548                 nativecontents |= CONTENTSQ3_MONSTERCLIP;
5549         if (supercontents & SUPERCONTENTS_DONOTENTER)
5550                 nativecontents |= CONTENTSQ3_DONOTENTER;
5551         return nativecontents;
5552 }
5553
5554 void Mod_Q3BSP_RecursiveFindNumLeafs(mnode_t *node)
5555 {
5556         int numleafs;
5557         while (node->plane)
5558         {
5559                 Mod_Q3BSP_RecursiveFindNumLeafs(node->children[0]);
5560                 node = node->children[1];
5561         }
5562         numleafs = ((mleaf_t *)node - loadmodel->brush.data_leafs) + 1;
5563         if (loadmodel->brush.num_leafs < numleafs)
5564                 loadmodel->brush.num_leafs = numleafs;
5565 }
5566
5567 void Mod_Q3BSP_Load(model_t *mod, void *buffer, void *bufferend)
5568 {
5569         int i, j, numshadowmeshtriangles;
5570         q3dheader_t *header;
5571         float corner[3], yawradius, modelradius;
5572         msurface_t *surface;
5573
5574         mod->modeldatatypestring = "Q3BSP";
5575
5576         mod->type = mod_brushq3;
5577         mod->numframes = 2; // although alternate textures are not supported it is annoying to complain about no such frame 1
5578         mod->numskins = 1;
5579
5580         header = (q3dheader_t *)buffer;
5581
5582         i = LittleLong(header->version);
5583         if (i != Q3BSPVERSION)
5584                 Host_Error("Mod_Q3BSP_Load: %s has wrong version number (%i, should be %i)", mod->name, i, Q3BSPVERSION);
5585         mod->brush.ishlbsp = false;
5586         mod->brush.ismcbsp = false;
5587         if (loadmodel->isworldmodel)
5588         {
5589                 Cvar_SetValue("halflifebsp", mod->brush.ishlbsp);
5590                 Cvar_SetValue("mcbsp", mod->brush.ismcbsp);
5591         }
5592
5593         mod->soundfromcenter = true;
5594         mod->TraceBox = Mod_Q3BSP_TraceBox;
5595         mod->brush.TraceLineOfSight = Mod_Q1BSP_TraceLineOfSight;
5596         mod->brush.SuperContentsFromNativeContents = Mod_Q3BSP_SuperContentsFromNativeContents;
5597         mod->brush.NativeContentsFromSuperContents = Mod_Q3BSP_NativeContentsFromSuperContents;
5598         mod->brush.GetPVS = Mod_Q1BSP_GetPVS;
5599         mod->brush.FatPVS = Mod_Q1BSP_FatPVS;
5600         mod->brush.BoxTouchingPVS = Mod_Q1BSP_BoxTouchingPVS;
5601         mod->brush.BoxTouchingLeafPVS = Mod_Q1BSP_BoxTouchingLeafPVS;
5602         mod->brush.BoxTouchingVisibleLeafs = Mod_Q1BSP_BoxTouchingVisibleLeafs;
5603         mod->brush.FindBoxClusters = Mod_Q1BSP_FindBoxClusters;
5604         mod->brush.LightPoint = Mod_Q3BSP_LightPoint;
5605         mod->brush.FindNonSolidLocation = Mod_Q1BSP_FindNonSolidLocation;
5606         mod->brush.PointInLeaf = Mod_Q1BSP_PointInLeaf;
5607         mod->Draw = R_Q1BSP_Draw;
5608         mod->DrawDepth = R_Q1BSP_DrawDepth;
5609         mod->GetLightInfo = R_Q1BSP_GetLightInfo;
5610         mod->CompileShadowVolume = R_Q1BSP_CompileShadowVolume;
5611         mod->DrawShadowVolume = R_Q1BSP_DrawShadowVolume;
5612         mod->DrawLight = R_Q1BSP_DrawLight;
5613
5614         mod_base = (unsigned char *)header;
5615
5616         // swap all the lumps
5617         header->ident = LittleLong(header->ident);
5618         header->version = LittleLong(header->version);
5619         for (i = 0;i < Q3HEADER_LUMPS;i++)
5620         {
5621                 header->lumps[i].fileofs = LittleLong(header->lumps[i].fileofs);
5622                 header->lumps[i].filelen = LittleLong(header->lumps[i].filelen);
5623         }
5624
5625         mod->brush.qw_md4sum = 0;
5626         mod->brush.qw_md4sum2 = 0;
5627         for (i = 0;i < Q3HEADER_LUMPS;i++)
5628         {
5629                 if (i == Q3LUMP_ENTITIES)
5630                         continue;
5631                 mod->brush.qw_md4sum ^= Com_BlockChecksum(mod_base + header->lumps[i].fileofs, header->lumps[i].filelen);
5632                 if (i == Q3LUMP_PVS || i == Q3LUMP_LEAFS || i == Q3LUMP_NODES)
5633                         continue;
5634                 mod->brush.qw_md4sum2 ^= Com_BlockChecksum(mod_base + header->lumps[i].fileofs, header->lumps[i].filelen);
5635         }
5636
5637         Mod_Q3BSP_LoadEntities(&header->lumps[Q3LUMP_ENTITIES]);
5638         Mod_Q3BSP_LoadTextures(&header->lumps[Q3LUMP_TEXTURES]);
5639         Mod_Q3BSP_LoadPlanes(&header->lumps[Q3LUMP_PLANES]);
5640         Mod_Q3BSP_LoadBrushSides(&header->lumps[Q3LUMP_BRUSHSIDES]);
5641         Mod_Q3BSP_LoadBrushes(&header->lumps[Q3LUMP_BRUSHES]);
5642         Mod_Q3BSP_LoadEffects(&header->lumps[Q3LUMP_EFFECTS]);
5643         Mod_Q3BSP_LoadVertices(&header->lumps[Q3LUMP_VERTICES]);
5644         Mod_Q3BSP_LoadTriangles(&header->lumps[Q3LUMP_TRIANGLES]);
5645         Mod_Q3BSP_LoadLightmaps(&header->lumps[Q3LUMP_LIGHTMAPS], &header->lumps[Q3LUMP_FACES]);
5646         Mod_Q3BSP_LoadFaces(&header->lumps[Q3LUMP_FACES]);
5647         Mod_Q3BSP_LoadModels(&header->lumps[Q3LUMP_MODELS]);
5648         Mod_Q3BSP_LoadLeafBrushes(&header->lumps[Q3LUMP_LEAFBRUSHES]);
5649         Mod_Q3BSP_LoadLeafFaces(&header->lumps[Q3LUMP_LEAFFACES]);
5650         Mod_Q3BSP_LoadLeafs(&header->lumps[Q3LUMP_LEAFS]);
5651         Mod_Q3BSP_LoadNodes(&header->lumps[Q3LUMP_NODES]);
5652         Mod_Q3BSP_LoadLightGrid(&header->lumps[Q3LUMP_LIGHTGRID]);
5653         Mod_Q3BSP_LoadPVS(&header->lumps[Q3LUMP_PVS]);
5654         loadmodel->brush.numsubmodels = loadmodel->brushq3.num_models;
5655
5656         // the MakePortals code works fine on the q3bsp data as well
5657         Mod_Q1BSP_MakePortals();
5658
5659         // FIXME: shader alpha should replace r_wateralpha support in q3bsp
5660         loadmodel->brush.supportwateralpha = true;
5661
5662         // make a single combined shadow mesh to allow optimized shadow volume creation
5663         numshadowmeshtriangles = 0;
5664         for (j = 0, surface = loadmodel->data_surfaces;j < loadmodel->num_surfaces;j++, surface++)
5665         {
5666                 surface->num_firstshadowmeshtriangle = numshadowmeshtriangles;
5667                 numshadowmeshtriangles += surface->num_triangles;
5668         }
5669         loadmodel->brush.shadowmesh = Mod_ShadowMesh_Begin(loadmodel->mempool, numshadowmeshtriangles * 3, numshadowmeshtriangles, NULL, NULL, NULL, false, false, true);
5670         for (j = 0, surface = loadmodel->data_surfaces;j < loadmodel->num_surfaces;j++, surface++)
5671                 if (surface->num_triangles > 0)
5672                         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));
5673         loadmodel->brush.shadowmesh = Mod_ShadowMesh_Finish(loadmodel->mempool, loadmodel->brush.shadowmesh, false, true, false);
5674         Mod_BuildTriangleNeighbors(loadmodel->brush.shadowmesh->neighbor3i, loadmodel->brush.shadowmesh->element3i, loadmodel->brush.shadowmesh->numtriangles);
5675
5676         loadmodel->brush.num_leafs = 0;
5677         Mod_Q3BSP_RecursiveFindNumLeafs(loadmodel->brush.data_nodes);
5678
5679         if (loadmodel->isworldmodel)
5680         {
5681                 // clear out any stale submodels or worldmodels lying around
5682                 // if we did this clear before now, an error might abort loading and
5683                 // leave things in a bad state
5684                 Mod_RemoveStaleWorldModels(loadmodel);
5685         }
5686
5687         mod = loadmodel;
5688         for (i = 0;i < loadmodel->brush.numsubmodels;i++)
5689         {
5690                 if (i > 0)
5691                 {
5692                         char name[10];
5693                         // LordHavoc: only register submodels if it is the world
5694                         // (prevents external bsp models from replacing world submodels with
5695                         //  their own)
5696                         if (!loadmodel->isworldmodel)
5697                                 continue;
5698                         // duplicate the basic information
5699                         sprintf(name, "*%i", i);
5700                         mod = Mod_FindName(name);
5701                         *mod = *loadmodel;
5702                         strlcpy(mod->name, name, sizeof(mod->name));
5703                         // textures and memory belong to the main model
5704                         mod->texturepool = NULL;
5705                         mod->mempool = NULL;
5706                         mod->brush.TraceLineOfSight = NULL;
5707                         mod->brush.GetPVS = NULL;
5708                         mod->brush.FatPVS = NULL;
5709                         mod->brush.BoxTouchingPVS = NULL;
5710                         mod->brush.BoxTouchingLeafPVS = NULL;
5711                         mod->brush.BoxTouchingVisibleLeafs = NULL;
5712                         mod->brush.FindBoxClusters = NULL;
5713                         mod->brush.LightPoint = NULL;
5714                         mod->brush.FindNonSolidLocation = Mod_Q1BSP_FindNonSolidLocation;
5715                 }
5716                 mod->brush.submodel = i;
5717
5718                 // make the model surface list (used by shadowing/lighting)
5719                 mod->firstmodelsurface = mod->brushq3.data_models[i].firstface;
5720                 mod->nummodelsurfaces = mod->brushq3.data_models[i].numfaces;
5721                 mod->firstmodelbrush = mod->brushq3.data_models[i].firstbrush;
5722                 mod->nummodelbrushes = mod->brushq3.data_models[i].numbrushes;
5723                 mod->surfacelist = (int *)Mem_Alloc(loadmodel->mempool, mod->nummodelsurfaces * sizeof(*mod->surfacelist));
5724                 for (j = 0;j < mod->nummodelsurfaces;j++)
5725                         mod->surfacelist[j] = mod->firstmodelsurface + j;
5726
5727                 VectorCopy(mod->brushq3.data_models[i].mins, mod->normalmins);
5728                 VectorCopy(mod->brushq3.data_models[i].maxs, mod->normalmaxs);
5729                 corner[0] = max(fabs(mod->normalmins[0]), fabs(mod->normalmaxs[0]));
5730                 corner[1] = max(fabs(mod->normalmins[1]), fabs(mod->normalmaxs[1]));
5731                 corner[2] = max(fabs(mod->normalmins[2]), fabs(mod->normalmaxs[2]));
5732                 modelradius = sqrt(corner[0]*corner[0]+corner[1]*corner[1]+corner[2]*corner[2]);
5733                 yawradius = sqrt(corner[0]*corner[0]+corner[1]*corner[1]);
5734                 mod->rotatedmins[0] = mod->rotatedmins[1] = mod->rotatedmins[2] = -modelradius;
5735                 mod->rotatedmaxs[0] = mod->rotatedmaxs[1] = mod->rotatedmaxs[2] = modelradius;
5736                 mod->yawmaxs[0] = mod->yawmaxs[1] = yawradius;
5737                 mod->yawmins[0] = mod->yawmins[1] = -yawradius;
5738                 mod->yawmins[2] = mod->normalmins[2];
5739                 mod->yawmaxs[2] = mod->normalmaxs[2];
5740                 mod->radius = modelradius;
5741                 mod->radius2 = modelradius * modelradius;
5742
5743                 for (j = 0;j < mod->nummodelsurfaces;j++)
5744                         if (mod->data_surfaces[j + mod->firstmodelsurface].texture->surfaceflags & Q3SURFACEFLAG_SKY)
5745                                 break;
5746                 if (j < mod->nummodelsurfaces)
5747                         mod->DrawSky = R_Q1BSP_DrawSky;
5748                 else
5749                         mod->DrawSky = NULL;
5750         }
5751 }
5752
5753 void Mod_IBSP_Load(model_t *mod, void *buffer, void *bufferend)
5754 {
5755         int i = LittleLong(((int *)buffer)[1]);
5756         if (i == Q3BSPVERSION)
5757                 Mod_Q3BSP_Load(mod,buffer, bufferend);
5758         else if (i == Q2BSPVERSION)
5759                 Mod_Q2BSP_Load(mod,buffer, bufferend);
5760         else
5761                 Host_Error("Mod_IBSP_Load: unknown/unsupported version %i", i);
5762 }
5763
5764 void Mod_MAP_Load(model_t *mod, void *buffer, void *bufferend)
5765 {
5766         Host_Error("Mod_MAP_Load: not yet implemented");
5767 }
5768
5769 qboolean Mod_CanSeeBox_Trace(int numsamples, float t, model_t *model, vec3_t eye, vec3_t minsX, vec3_t maxsX)
5770 {
5771         // we already have done PVS culling at this point...
5772         // so we don't need to do it again.
5773
5774         int i;
5775         vec3_t testorigin, mins, maxs;
5776
5777         testorigin[0] = (minsX[0] + maxsX[0]) * 0.5;
5778         testorigin[1] = (minsX[1] + maxsX[1]) * 0.5;
5779         testorigin[2] = (minsX[2] + maxsX[2]) * 0.5;
5780
5781         if(model->brush.TraceLineOfSight(model, eye, testorigin))
5782                 return 1;
5783
5784         // expand the box a little
5785         mins[0] = (t+1) * minsX[0] - t * maxsX[0];
5786         maxs[0] = (t+1) * maxsX[0] - t * minsX[0];
5787         mins[1] = (t+1) * minsX[1] - t * maxsX[1];
5788         maxs[1] = (t+1) * maxsX[1] - t * minsX[1];
5789         mins[2] = (t+1) * minsX[2] - t * maxsX[2];
5790         maxs[2] = (t+1) * maxsX[2] - t * minsX[2];
5791
5792         for(i = 0; i != numsamples; ++i)
5793         {
5794                 testorigin[0] = lhrandom(mins[0], maxs[0]);
5795                 testorigin[1] = lhrandom(mins[1], maxs[1]);
5796                 testorigin[2] = lhrandom(mins[2], maxs[2]);
5797
5798                 if(model->brush.TraceLineOfSight(model, eye, testorigin))
5799                         return 1;
5800         }
5801
5802         return 0;
5803 }
5804