model_brush.c

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