added some tolerances in Mod_Q1BSP_RecursiveHullCheck so that it is
[divverent/darkplaces.git] / model_brush.c
1 /*
2 Copyright (C) 1996-1997 Id Software, Inc.
3
4 This program is free software; you can redistribute it and/or
5 modify it under the terms of the GNU General Public License
6 as published by the Free Software Foundation; either version 2
7 of the License, or (at your option) any later version.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
12
13 See the GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
18
19 */
20
21 #include "quakedef.h"
22 #include "image.h"
23 #include "r_shadow.h"
24 #include "polygon.h"
25 #include "curves.h"
26 #include "wad.h"
27
28
29 //cvar_t r_subdivide_size = {CVAR_SAVE, "r_subdivide_size", "128", "how large water polygons should be (smaller values produce more polygons which give better warping effects)"};
30 cvar_t halflifebsp = {0, "halflifebsp", "0", "indicates the current map is hlbsp format (useful to know because of different bounding box sizes)"};
31 cvar_t mcbsp = {0, "mcbsp", "0", "indicates the current map is mcbsp format (useful to know because of different bounding box sizes)"};
32 cvar_t r_novis = {0, "r_novis", "0", "draws whole level, see also sv_cullentities_pvs 0"};
33 cvar_t r_lightmaprgba = {0, "r_lightmaprgba", "1", "whether to use RGBA (32bit) or RGB (24bit) lightmaps"};
34 cvar_t r_picmipworld = {CVAR_SAVE, "r_picmipworld", "1", "whether gl_picmip shall apply to world textures too"};
35 cvar_t r_nosurftextures = {0, "r_nosurftextures", "0", "pretends there was no texture lump found in the q1bsp/hlbsp loading (useful for debugging this rare case)"};
36 cvar_t r_subdivisions_tolerance = {0, "r_subdivisions_tolerance", "4", "maximum error tolerance on curve subdivision for rendering purposes (in other words, the curves will be given as many polygons as necessary to represent curves at this quality)"};
37 cvar_t r_subdivisions_mintess = {0, "r_subdivisions_mintess", "1", "minimum number of subdivisions (values above 1 will smooth curves that don't need it)"};
38 cvar_t r_subdivisions_maxtess = {0, "r_subdivisions_maxtess", "1024", "maximum number of subdivisions (prevents curves beyond a certain detail level, limits smoothing)"};
39 cvar_t r_subdivisions_maxvertices = {0, "r_subdivisions_maxvertices", "65536", "maximum vertices allowed per subdivided curve"};
40 cvar_t r_subdivisions_collision_tolerance = {0, "r_subdivisions_collision_tolerance", "15", "maximum error tolerance on curve subdivision for collision purposes (usually a larger error tolerance than for rendering)"};
41 cvar_t r_subdivisions_collision_mintess = {0, "r_subdivisions_collision_mintess", "1", "minimum number of subdivisions (values above 1 will smooth curves that don't need it)"};
42 cvar_t r_subdivisions_collision_maxtess = {0, "r_subdivisions_collision_maxtess", "1024", "maximum number of subdivisions (prevents curves beyond a certain detail level, limits smoothing)"};
43 cvar_t r_subdivisions_collision_maxvertices = {0, "r_subdivisions_collision_maxvertices", "4225", "maximum vertices allowed per subdivided curve"};
44 cvar_t mod_q3bsp_curves_collisions = {0, "mod_q3bsp_curves_collisions", "1", "enables collisions with curves (SLOW)"};
45 cvar_t mod_q3bsp_optimizedtraceline = {0, "mod_q3bsp_optimizedtraceline", "1", "whether to use optimized traceline code for line traces (as opposed to tracebox code)"};
46 cvar_t mod_q3bsp_debugtracebrush = {0, "mod_q3bsp_debugtracebrush", "0", "selects different tracebrush bsp recursion algorithms (for debugging purposes only)"};
47 cvar_t mod_q3bsp_lightmapmergepower = {CVAR_SAVE, "mod_q3bsp_lightmapmergepower", "4", "merges the quake3 128x128 lightmap textures into larger lightmap group textures to speed up rendering, 1 = 256x256, 2 = 512x512, 3 = 1024x1024, 4 = 2048x2048, 5 = 4096x4096, ..."};
48
49 static texture_t mod_q1bsp_texture_solid;
50 static texture_t mod_q1bsp_texture_sky;
51 static texture_t mod_q1bsp_texture_lava;
52 static texture_t mod_q1bsp_texture_slime;
53 static texture_t mod_q1bsp_texture_water;
54
55 void Mod_BrushInit(void)
56 {
57 //      Cvar_RegisterVariable(&r_subdivide_size);
58         Cvar_RegisterVariable(&halflifebsp);
59         Cvar_RegisterVariable(&mcbsp);
60         Cvar_RegisterVariable(&r_novis);
61         Cvar_RegisterVariable(&r_lightmaprgba);
62         Cvar_RegisterVariable(&r_picmipworld);
63         Cvar_RegisterVariable(&r_nosurftextures);
64         Cvar_RegisterVariable(&r_subdivisions_tolerance);
65         Cvar_RegisterVariable(&r_subdivisions_mintess);
66         Cvar_RegisterVariable(&r_subdivisions_maxtess);
67         Cvar_RegisterVariable(&r_subdivisions_maxvertices);
68         Cvar_RegisterVariable(&r_subdivisions_collision_tolerance);
69         Cvar_RegisterVariable(&r_subdivisions_collision_mintess);
70         Cvar_RegisterVariable(&r_subdivisions_collision_maxtess);
71         Cvar_RegisterVariable(&r_subdivisions_collision_maxvertices);
72         Cvar_RegisterVariable(&mod_q3bsp_curves_collisions);
73         Cvar_RegisterVariable(&mod_q3bsp_optimizedtraceline);
74         Cvar_RegisterVariable(&mod_q3bsp_debugtracebrush);
75         Cvar_RegisterVariable(&mod_q3bsp_lightmapmergepower);
76
77         memset(&mod_q1bsp_texture_solid, 0, sizeof(mod_q1bsp_texture_solid));
78         strlcpy(mod_q1bsp_texture_solid.name, "solid" , sizeof(mod_q1bsp_texture_solid.name));
79         mod_q1bsp_texture_solid.surfaceflags = 0;
80         mod_q1bsp_texture_solid.supercontents = SUPERCONTENTS_SOLID;
81
82         mod_q1bsp_texture_sky = mod_q1bsp_texture_solid;
83         strlcpy(mod_q1bsp_texture_sky.name, "sky", sizeof(mod_q1bsp_texture_sky.name));
84         mod_q1bsp_texture_sky.surfaceflags = Q3SURFACEFLAG_SKY | Q3SURFACEFLAG_NOIMPACT | Q3SURFACEFLAG_NOMARKS | Q3SURFACEFLAG_NODLIGHT | Q3SURFACEFLAG_NOLIGHTMAP;
85         mod_q1bsp_texture_sky.supercontents = SUPERCONTENTS_SKY | SUPERCONTENTS_NODROP;
86
87         mod_q1bsp_texture_lava = mod_q1bsp_texture_solid;
88         strlcpy(mod_q1bsp_texture_lava.name, "*lava", sizeof(mod_q1bsp_texture_lava.name));
89         mod_q1bsp_texture_lava.surfaceflags = Q3SURFACEFLAG_NOMARKS;
90         mod_q1bsp_texture_lava.supercontents = SUPERCONTENTS_LAVA | SUPERCONTENTS_NODROP;
91
92         mod_q1bsp_texture_slime = mod_q1bsp_texture_solid;
93         strlcpy(mod_q1bsp_texture_slime.name, "*slime", sizeof(mod_q1bsp_texture_slime.name));
94         mod_q1bsp_texture_slime.surfaceflags = Q3SURFACEFLAG_NOMARKS;
95         mod_q1bsp_texture_slime.supercontents = SUPERCONTENTS_SLIME;
96
97         mod_q1bsp_texture_water = mod_q1bsp_texture_solid;
98         strlcpy(mod_q1bsp_texture_water.name, "*water", sizeof(mod_q1bsp_texture_water.name));
99         mod_q1bsp_texture_water.surfaceflags = Q3SURFACEFLAG_NOMARKS;
100         mod_q1bsp_texture_water.supercontents = SUPERCONTENTS_WATER;
101 }
102
103 static mleaf_t *Mod_Q1BSP_PointInLeaf(model_t *model, const vec3_t p)
104 {
105         mnode_t *node;
106
107         if (model == NULL)
108                 return NULL;
109
110         // LordHavoc: modified to start at first clip node,
111         // in other words: first node of the (sub)model
112         node = model->brush.data_nodes + model->brushq1.hulls[0].firstclipnode;
113         while (node->plane)
114                 node = node->children[(node->plane->type < 3 ? p[node->plane->type] : DotProduct(p,node->plane->normal)) < node->plane->dist];
115
116         return (mleaf_t *)node;
117 }
118
119 static void Mod_Q1BSP_AmbientSoundLevelsForPoint(model_t *model, const vec3_t p, unsigned char *out, int outsize)
120 {
121         int i;
122         mleaf_t *leaf;
123         leaf = Mod_Q1BSP_PointInLeaf(model, p);
124         if (leaf)
125         {
126                 i = min(outsize, (int)sizeof(leaf->ambient_sound_level));
127                 if (i)
128                 {
129                         memcpy(out, leaf->ambient_sound_level, i);
130                         out += i;
131                         outsize -= i;
132                 }
133         }
134         if (outsize)
135                 memset(out, 0, outsize);
136 }
137
138 static int Mod_Q1BSP_FindBoxClusters(model_t *model, const vec3_t mins, const vec3_t maxs, int maxclusters, int *clusterlist)
139 {
140         int numclusters = 0;
141         int nodestackindex = 0;
142         mnode_t *node, *nodestack[1024];
143         if (!model->brush.num_pvsclusters)
144                 return -1;
145         node = model->brush.data_nodes;
146         for (;;)
147         {
148 #if 1
149                 if (node->plane)
150                 {
151                         // node - recurse down the BSP tree
152                         int sides = BoxOnPlaneSide(mins, maxs, node->plane);
153                         if (sides < 3)
154                         {
155                                 if (sides == 0)
156                                         return -1; // ERROR: NAN bounding box!
157                                 // box is on one side of plane, take that path
158                                 node = node->children[sides-1];
159                         }
160                         else
161                         {
162                                 // box crosses plane, take one path and remember the other
163                                 if (nodestackindex < 1024)
164                                         nodestack[nodestackindex++] = node->children[0];
165                                 node = node->children[1];
166                         }
167                         continue;
168                 }
169                 else
170                 {
171                         // leaf - add clusterindex to list
172                         if (numclusters < maxclusters)
173                                 clusterlist[numclusters] = ((mleaf_t *)node)->clusterindex;
174                         numclusters++;
175                 }
176 #else
177                 if (BoxesOverlap(mins, maxs, node->mins, node->maxs))
178                 {
179                         if (node->plane)
180                         {
181                                 if (nodestackindex < 1024)
182                                         nodestack[nodestackindex++] = node->children[0];
183                                 node = node->children[1];
184                                 continue;
185                         }
186                         else
187                         {
188                                 // leaf - add clusterindex to list
189                                 if (numclusters < maxclusters)
190                                         clusterlist[numclusters] = ((mleaf_t *)node)->clusterindex;
191                                 numclusters++;
192                         }
193                 }
194 #endif
195                 // try another path we didn't take earlier
196                 if (nodestackindex == 0)
197                         break;
198                 node = nodestack[--nodestackindex];
199         }
200         // return number of clusters found (even if more than the maxclusters)
201         return numclusters;
202 }
203
204 static int Mod_Q1BSP_BoxTouchingPVS(model_t *model, const unsigned char *pvs, const vec3_t mins, const vec3_t maxs)
205 {
206         int nodestackindex = 0;
207         mnode_t *node, *nodestack[1024];
208         if (!model->brush.num_pvsclusters)
209                 return true;
210         node = model->brush.data_nodes;
211         for (;;)
212         {
213 #if 1
214                 if (node->plane)
215                 {
216                         // node - recurse down the BSP tree
217                         int sides = BoxOnPlaneSide(mins, maxs, node->plane);
218                         if (sides < 3)
219                         {
220                                 if (sides == 0)
221                                         return -1; // ERROR: NAN bounding box!
222                                 // box is on one side of plane, take that path
223                                 node = node->children[sides-1];
224                         }
225                         else
226                         {
227                                 // box crosses plane, take one path and remember the other
228                                 if (nodestackindex < 1024)
229                                         nodestack[nodestackindex++] = node->children[0];
230                                 node = node->children[1];
231                         }
232                         continue;
233                 }
234                 else
235                 {
236                         // leaf - check cluster bit
237                         int clusterindex = ((mleaf_t *)node)->clusterindex;
238                         if (CHECKPVSBIT(pvs, clusterindex))
239                         {
240                                 // it is visible, return immediately with the news
241                                 return true;
242                         }
243                 }
244 #else
245                 if (BoxesOverlap(mins, maxs, node->mins, node->maxs))
246                 {
247                         if (node->plane)
248                         {
249                                 if (nodestackindex < 1024)
250                                         nodestack[nodestackindex++] = node->children[0];
251                                 node = node->children[1];
252                                 continue;
253                         }
254                         else
255                         {
256                                 // leaf - check cluster bit
257                                 int clusterindex = ((mleaf_t *)node)->clusterindex;
258                                 if (CHECKPVSBIT(pvs, clusterindex))
259                                 {
260                                         // it is visible, return immediately with the news
261                                         return true;
262                                 }
263                         }
264                 }
265 #endif
266                 // nothing to see here, try another path we didn't take earlier
267                 if (nodestackindex == 0)
268                         break;
269                 node = nodestack[--nodestackindex];
270         }
271         // it is not visible
272         return false;
273 }
274
275 static int Mod_Q1BSP_BoxTouchingLeafPVS(model_t *model, const unsigned char *pvs, const vec3_t mins, const vec3_t maxs)
276 {
277         int nodestackindex = 0;
278         mnode_t *node, *nodestack[1024];
279         if (!model->brush.num_leafs)
280                 return true;
281         node = model->brush.data_nodes;
282         for (;;)
283         {
284 #if 1
285                 if (node->plane)
286                 {
287                         // node - recurse down the BSP tree
288                         int sides = BoxOnPlaneSide(mins, maxs, node->plane);
289                         if (sides < 3)
290                         {
291                                 if (sides == 0)
292                                         return -1; // ERROR: NAN bounding box!
293                                 // box is on one side of plane, take that path
294                                 node = node->children[sides-1];
295                         }
296                         else
297                         {
298                                 // box crosses plane, take one path and remember the other
299                                 if (nodestackindex < 1024)
300                                         nodestack[nodestackindex++] = node->children[0];
301                                 node = node->children[1];
302                         }
303                         continue;
304                 }
305                 else
306                 {
307                         // leaf - check cluster bit
308                         int clusterindex = ((mleaf_t *)node) - model->brush.data_leafs;
309                         if (CHECKPVSBIT(pvs, clusterindex))
310                         {
311                                 // it is visible, return immediately with the news
312                                 return true;
313                         }
314                 }
315 #else
316                 if (BoxesOverlap(mins, maxs, node->mins, node->maxs))
317                 {
318                         if (node->plane)
319                         {
320                                 if (nodestackindex < 1024)
321                                         nodestack[nodestackindex++] = node->children[0];
322                                 node = node->children[1];
323                                 continue;
324                         }
325                         else
326                         {
327                                 // leaf - check cluster bit
328                                 int clusterindex = ((mleaf_t *)node) - model->brush.data_leafs;
329                                 if (CHECKPVSBIT(pvs, clusterindex))
330                                 {
331                                         // it is visible, return immediately with the news
332                                         return true;
333                                 }
334                         }
335                 }
336 #endif
337                 // nothing to see here, try another path we didn't take earlier
338                 if (nodestackindex == 0)
339                         break;
340                 node = nodestack[--nodestackindex];
341         }
342         // it is not visible
343         return false;
344 }
345
346 static int Mod_Q1BSP_BoxTouchingVisibleLeafs(model_t *model, const unsigned char *visibleleafs, const vec3_t mins, const vec3_t maxs)
347 {
348         int nodestackindex = 0;
349         mnode_t *node, *nodestack[1024];
350         if (!model->brush.num_leafs)
351                 return true;
352         node = model->brush.data_nodes;
353         for (;;)
354         {
355 #if 1
356                 if (node->plane)
357                 {
358                         // node - recurse down the BSP tree
359                         int sides = BoxOnPlaneSide(mins, maxs, node->plane);
360                         if (sides < 3)
361                         {
362                                 if (sides == 0)
363                                         return -1; // ERROR: NAN bounding box!
364                                 // box is on one side of plane, take that path
365                                 node = node->children[sides-1];
366                         }
367                         else
368                         {
369                                 // box crosses plane, take one path and remember the other
370                                 if (nodestackindex < 1024)
371                                         nodestack[nodestackindex++] = node->children[0];
372                                 node = node->children[1];
373                         }
374                         continue;
375                 }
376                 else
377                 {
378                         // leaf - check if it is visible
379                         if (visibleleafs[(mleaf_t *)node - model->brush.data_leafs])
380                         {
381                                 // it is visible, return immediately with the news
382                                 return true;
383                         }
384                 }
385 #else
386                 if (BoxesOverlap(mins, maxs, node->mins, node->maxs))
387                 {
388                         if (node->plane)
389                         {
390                                 if (nodestackindex < 1024)
391                                         nodestack[nodestackindex++] = node->children[0];
392                                 node = node->children[1];
393                                 continue;
394                         }
395                         else
396                         {
397                                 // leaf - check if it is visible
398                                 if (visibleleafs[(mleaf_t *)node - model->brush.data_leafs])
399                                 {
400                                         // it is visible, return immediately with the news
401                                         return true;
402                                 }
403                         }
404                 }
405 #endif
406                 // nothing to see here, try another path we didn't take earlier
407                 if (nodestackindex == 0)
408                         break;
409                 node = nodestack[--nodestackindex];
410         }
411         // it is not visible
412         return false;
413 }
414
415 typedef struct findnonsolidlocationinfo_s
416 {
417         vec3_t center;
418         vec_t radius;
419         vec3_t nudge;
420         vec_t bestdist;
421         model_t *model;
422 }
423 findnonsolidlocationinfo_t;
424
425 static void Mod_Q1BSP_FindNonSolidLocation_r_Leaf(findnonsolidlocationinfo_t *info, mleaf_t *leaf)
426 {
427         int i, surfacenum, k, *tri, *mark;
428         float dist, f, vert[3][3], edge[3][3], facenormal[3], edgenormal[3][3], point[3];
429         msurface_t *surface;
430         for (surfacenum = 0, mark = leaf->firstleafsurface;surfacenum < leaf->numleafsurfaces;surfacenum++, mark++)
431         {
432                 surface = info->model->data_surfaces + *mark;
433                 if (surface->texture->supercontents & SUPERCONTENTS_SOLID)
434                 {
435                         for (k = 0;k < surface->num_triangles;k++)
436                         {
437                                 tri = (info->model->surfmesh.data_element3i + 3 * surface->num_firsttriangle) + k * 3;
438                                 VectorCopy((info->model->surfmesh.data_vertex3f + tri[0] * 3), vert[0]);
439                                 VectorCopy((info->model->surfmesh.data_vertex3f + tri[1] * 3), vert[1]);
440                                 VectorCopy((info->model->surfmesh.data_vertex3f + tri[2] * 3), vert[2]);
441                                 VectorSubtract(vert[1], vert[0], edge[0]);
442                                 VectorSubtract(vert[2], vert[1], edge[1]);
443                                 CrossProduct(edge[1], edge[0], facenormal);
444                                 if (facenormal[0] || facenormal[1] || facenormal[2])
445                                 {
446                                         VectorNormalize(facenormal);
447                                         f = DotProduct(info->center, facenormal) - DotProduct(vert[0], facenormal);
448                                         if (f <= info->bestdist && f >= -info->bestdist)
449                                         {
450                                                 VectorSubtract(vert[0], vert[2], edge[2]);
451                                                 VectorNormalize(edge[0]);
452                                                 VectorNormalize(edge[1]);
453                                                 VectorNormalize(edge[2]);
454                                                 CrossProduct(facenormal, edge[0], edgenormal[0]);
455                                                 CrossProduct(facenormal, edge[1], edgenormal[1]);
456                                                 CrossProduct(facenormal, edge[2], edgenormal[2]);
457                                                 // face distance
458                                                 if (DotProduct(info->center, edgenormal[0]) < DotProduct(vert[0], edgenormal[0])
459                                                  && DotProduct(info->center, edgenormal[1]) < DotProduct(vert[1], edgenormal[1])
460                                                  && DotProduct(info->center, edgenormal[2]) < DotProduct(vert[2], edgenormal[2]))
461                                                 {
462                                                         // we got lucky, the center is within the face
463                                                         dist = DotProduct(info->center, facenormal) - DotProduct(vert[0], facenormal);
464                                                         if (dist < 0)
465                                                         {
466                                                                 dist = -dist;
467                                                                 if (info->bestdist > dist)
468                                                                 {
469                                                                         info->bestdist = dist;
470                                                                         VectorScale(facenormal, (info->radius - -dist), info->nudge);
471                                                                 }
472                                                         }
473                                                         else
474                                                         {
475                                                                 if (info->bestdist > dist)
476                                                                 {
477                                                                         info->bestdist = dist;
478                                                                         VectorScale(facenormal, (info->radius - dist), info->nudge);
479                                                                 }
480                                                         }
481                                                 }
482                                                 else
483                                                 {
484                                                         // check which edge or vertex the center is nearest
485                                                         for (i = 0;i < 3;i++)
486                                                         {
487                                                                 f = DotProduct(info->center, edge[i]);
488                                                                 if (f >= DotProduct(vert[0], edge[i])
489                                                                  && f <= DotProduct(vert[1], edge[i]))
490                                                                 {
491                                                                         // on edge
492                                                                         VectorMA(info->center, -f, edge[i], point);
493                                                                         dist = sqrt(DotProduct(point, point));
494                                                                         if (info->bestdist > dist)
495                                                                         {
496                                                                                 info->bestdist = dist;
497                                                                                 VectorScale(point, (info->radius / dist), info->nudge);
498                                                                         }
499                                                                         // skip both vertex checks
500                                                                         // (both are further away than this edge)
501                                                                         i++;
502                                                                 }
503                                                                 else
504                                                                 {
505                                                                         // not on edge, check first vertex of edge
506                                                                         VectorSubtract(info->center, vert[i], point);
507                                                                         dist = sqrt(DotProduct(point, point));
508                                                                         if (info->bestdist > dist)
509                                                                         {
510                                                                                 info->bestdist = dist;
511                                                                                 VectorScale(point, (info->radius / dist), info->nudge);
512                                                                         }
513                                                                 }
514                                                         }
515                                                 }
516                                         }
517                                 }
518                         }
519                 }
520         }
521 }
522
523 static void Mod_Q1BSP_FindNonSolidLocation_r(findnonsolidlocationinfo_t *info, mnode_t *node)
524 {
525         if (node->plane)
526         {
527                 float f = PlaneDiff(info->center, node->plane);
528                 if (f >= -info->bestdist)
529                         Mod_Q1BSP_FindNonSolidLocation_r(info, node->children[0]);
530                 if (f <= info->bestdist)
531                         Mod_Q1BSP_FindNonSolidLocation_r(info, node->children[1]);
532         }
533         else
534         {
535                 if (((mleaf_t *)node)->numleafsurfaces)
536                         Mod_Q1BSP_FindNonSolidLocation_r_Leaf(info, (mleaf_t *)node);
537         }
538 }
539
540 static void Mod_Q1BSP_FindNonSolidLocation(model_t *model, const vec3_t in, vec3_t out, float radius)
541 {
542         int i;
543         findnonsolidlocationinfo_t info;
544         if (model == NULL)
545         {
546                 VectorCopy(in, out);
547                 return;
548         }
549         VectorCopy(in, info.center);
550         info.radius = radius;
551         info.model = model;
552         i = 0;
553         do
554         {
555                 VectorClear(info.nudge);
556                 info.bestdist = radius;
557                 Mod_Q1BSP_FindNonSolidLocation_r(&info, model->brush.data_nodes + model->brushq1.hulls[0].firstclipnode);
558                 VectorAdd(info.center, info.nudge, info.center);
559         }
560         while (info.bestdist < radius && ++i < 10);
561         VectorCopy(info.center, out);
562 }
563
564 int Mod_Q1BSP_SuperContentsFromNativeContents(model_t *model, int nativecontents)
565 {
566         switch(nativecontents)
567         {
568                 case CONTENTS_EMPTY:
569                         return 0;
570                 case CONTENTS_SOLID:
571                         return SUPERCONTENTS_SOLID;
572                 case CONTENTS_WATER:
573                         return SUPERCONTENTS_WATER;
574                 case CONTENTS_SLIME:
575                         return SUPERCONTENTS_SLIME;
576                 case CONTENTS_LAVA:
577                         return SUPERCONTENTS_LAVA | SUPERCONTENTS_NODROP;
578                 case CONTENTS_SKY:
579                         return SUPERCONTENTS_SKY | SUPERCONTENTS_NODROP;
580         }
581         return 0;
582 }
583
584 int Mod_Q1BSP_NativeContentsFromSuperContents(model_t *model, int supercontents)
585 {
586         if (supercontents & (SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY))
587                 return CONTENTS_SOLID;
588         if (supercontents & SUPERCONTENTS_SKY)
589                 return CONTENTS_SKY;
590         if (supercontents & SUPERCONTENTS_LAVA)
591                 return CONTENTS_LAVA;
592         if (supercontents & SUPERCONTENTS_SLIME)
593                 return CONTENTS_SLIME;
594         if (supercontents & SUPERCONTENTS_WATER)
595                 return CONTENTS_WATER;
596         return CONTENTS_EMPTY;
597 }
598
599 typedef struct RecursiveHullCheckTraceInfo_s
600 {
601         // the hull we're tracing through
602         const hull_t *hull;
603
604         // the trace structure to fill in
605         trace_t *trace;
606
607         // start, end, and end - start (in model space)
608         double start[3];
609         double end[3];
610         double dist[3];
611 }
612 RecursiveHullCheckTraceInfo_t;
613
614 // 1/32 epsilon to keep floating point happy
615 #define DIST_EPSILON (0.03125)
616 #define DIST_EPSILON2 (0)
617
618 #define HULLCHECKSTATE_EMPTY 0
619 #define HULLCHECKSTATE_SOLID 1
620 #define HULLCHECKSTATE_DONE 2
621
622 extern cvar_t collision_prefernudgedfraction;
623 static int Mod_Q1BSP_RecursiveHullCheck(RecursiveHullCheckTraceInfo_t *t, int num, double p1f, double p2f, double p1[3], double p2[3])
624 {
625         // status variables, these don't need to be saved on the stack when
626         // recursing...  but are because this should be thread-safe
627         // (note: tracing against a bbox is not thread-safe, yet)
628         int ret;
629         mplane_t *plane;
630         double t1, t2;
631
632         // variables that need to be stored on the stack when recursing
633         dclipnode_t *node;
634         int side;
635         double midf, mid[3];
636
637         // LordHavoc: a goto!  everyone flee in terror... :)
638 loc0:
639         // check for empty
640         if (num < 0)
641         {
642                 num = Mod_Q1BSP_SuperContentsFromNativeContents(NULL, num);
643                 if (!t->trace->startfound)
644                 {
645                         t->trace->startfound = true;
646                         t->trace->startsupercontents |= num;
647                 }
648                 if (num & SUPERCONTENTS_LIQUIDSMASK)
649                         t->trace->inwater = true;
650                 if (num == 0)
651                         t->trace->inopen = true;
652                 if (num & SUPERCONTENTS_SOLID)
653                         t->trace->hittexture = &mod_q1bsp_texture_solid;
654                 else if (num & SUPERCONTENTS_SKY)
655                         t->trace->hittexture = &mod_q1bsp_texture_sky;
656                 else if (num & SUPERCONTENTS_LAVA)
657                         t->trace->hittexture = &mod_q1bsp_texture_lava;
658                 else if (num & SUPERCONTENTS_SLIME)
659                         t->trace->hittexture = &mod_q1bsp_texture_slime;
660                 else
661                         t->trace->hittexture = &mod_q1bsp_texture_water;
662                 t->trace->hitq3surfaceflags = t->trace->hittexture->surfaceflags;
663                 t->trace->hitsupercontents = num;
664                 if (num & t->trace->hitsupercontentsmask)
665                 {
666                         // if the first leaf is solid, set startsolid
667                         if (t->trace->allsolid)
668                                 t->trace->startsolid = true;
669 #if COLLISIONPARANOID >= 3
670                         Con_Print("S");
671 #endif
672                         return HULLCHECKSTATE_SOLID;
673                 }
674                 else
675                 {
676                         t->trace->allsolid = false;
677 #if COLLISIONPARANOID >= 3
678                         Con_Print("E");
679 #endif
680                         return HULLCHECKSTATE_EMPTY;
681                 }
682         }
683
684         // find the point distances
685         node = t->hull->clipnodes + num;
686
687         plane = t->hull->planes + node->planenum;
688         if (plane->type < 3)
689         {
690                 t1 = p1[plane->type] - plane->dist;
691                 t2 = p2[plane->type] - plane->dist;
692         }
693         else
694         {
695                 t1 = DotProduct (plane->normal, p1) - plane->dist;
696                 t2 = DotProduct (plane->normal, p2) - plane->dist;
697         }
698
699         // this has some tolerances so that it never intersects with a plane if
700         // one of the endpoints lies exactly on it
701         // the objective of this code is to allow points that are exactly on a
702         // plane to still give sane results (improving physics stability)
703         if (t2 < t1)
704         {
705                 if (t2 >= -DIST_EPSILON2)
706                 {
707 #if COLLISIONPARANOID >= 3
708                         Con_Print(">");
709 #endif
710                         num = node->children[0];
711                         goto loc0;
712                 }
713                 if (t1 <= DIST_EPSILON2)
714                 {
715 #if COLLISIONPARANOID >= 3
716                         Con_Print("<");
717 #endif
718                         num = node->children[1];
719                         goto loc0;
720                 }
721                 side = 0;
722         }
723         else
724         {
725                 if (t1 >= -DIST_EPSILON2)
726                 {
727 #if COLLISIONPARANOID >= 3
728                         Con_Print(">");
729 #endif
730                         num = node->children[0];
731                         goto loc0;
732                 }
733                 if (t2 <= DIST_EPSILON2)
734                 {
735 #if COLLISIONPARANOID >= 3
736                         Con_Print("<");
737 #endif
738                         num = node->children[1];
739                         goto loc0;
740                 }
741                 side = 1;
742         }
743
744         // the line intersects, find intersection point
745         // LordHavoc: this uses the original trace for maximum accuracy
746 #if COLLISIONPARANOID >= 3
747         Con_Print("M");
748 #endif
749         if (plane->type < 3)
750         {
751                 t1 = t->start[plane->type] - plane->dist;
752                 t2 = t->end[plane->type] - plane->dist;
753         }
754         else
755         {
756                 t1 = DotProduct (plane->normal, t->start) - plane->dist;
757                 t2 = DotProduct (plane->normal, t->end) - plane->dist;
758         }
759
760         midf = t1 / (t1 - t2);
761         midf = bound(p1f, midf, p2f);
762         VectorMA(t->start, midf, t->dist, mid);
763
764         // recurse both sides, front side first
765         ret = Mod_Q1BSP_RecursiveHullCheck(t, node->children[side], p1f, midf, p1, mid);
766         // if this side is not empty, return what it is (solid or done)
767         if (ret != HULLCHECKSTATE_EMPTY)
768                 return ret;
769
770         ret = Mod_Q1BSP_RecursiveHullCheck(t, node->children[side ^ 1], midf, p2f, mid, p2);
771         // if other side is not solid, return what it is (empty or done)
772         if (ret != HULLCHECKSTATE_SOLID)
773                 return ret;
774
775         // front is air and back is solid, this is the impact point...
776         if (side)
777         {
778                 t->trace->plane.dist = -plane->dist;
779                 VectorNegate (plane->normal, t->trace->plane.normal);
780         }
781         else
782         {
783                 t->trace->plane.dist = plane->dist;
784                 VectorCopy (plane->normal, t->trace->plane.normal);
785         }
786
787         // calculate the true fraction
788         t1 = DotProduct(t->trace->plane.normal, t->start) - t->trace->plane.dist;
789         t2 = DotProduct(t->trace->plane.normal, t->end) - t->trace->plane.dist;
790         midf = t1 / (t1 - t2);
791         t->trace->realfraction = bound(0, midf, 1);
792
793         // calculate the return fraction which is nudged off the surface a bit
794         midf = (t1 - DIST_EPSILON) / (t1 - t2);
795         t->trace->fraction = bound(0, midf, 1);
796
797         if (collision_prefernudgedfraction.integer)
798                 t->trace->realfraction = t->trace->fraction;
799
800 #if COLLISIONPARANOID >= 3
801         Con_Print("D");
802 #endif
803         return HULLCHECKSTATE_DONE;
804 }
805
806 //#if COLLISIONPARANOID < 2
807 static int Mod_Q1BSP_RecursiveHullCheckPoint(RecursiveHullCheckTraceInfo_t *t, int num)
808 {
809         while (num >= 0)
810                 num = t->hull->clipnodes[num].children[(t->hull->planes[t->hull->clipnodes[num].planenum].type < 3 ? t->start[t->hull->planes[t->hull->clipnodes[num].planenum].type] : DotProduct(t->hull->planes[t->hull->clipnodes[num].planenum].normal, t->start)) < t->hull->planes[t->hull->clipnodes[num].planenum].dist];
811         num = Mod_Q1BSP_SuperContentsFromNativeContents(NULL, num);
812         t->trace->startsupercontents |= num;
813         if (num & SUPERCONTENTS_LIQUIDSMASK)
814                 t->trace->inwater = true;
815         if (num == 0)
816                 t->trace->inopen = true;
817         if (num & t->trace->hitsupercontentsmask)
818         {
819                 t->trace->allsolid = t->trace->startsolid = true;
820                 return HULLCHECKSTATE_SOLID;
821         }
822         else
823         {
824                 t->trace->allsolid = t->trace->startsolid = false;
825                 return HULLCHECKSTATE_EMPTY;
826         }
827 }
828 //#endif
829
830 static void Mod_Q1BSP_TraceBox(struct model_s *model, int frame, trace_t *trace, const vec3_t start, const vec3_t boxmins, const vec3_t boxmaxs, const vec3_t end, int hitsupercontentsmask)
831 {
832         // this function currently only supports same size start and end
833         double boxsize[3];
834         RecursiveHullCheckTraceInfo_t rhc;
835
836         memset(&rhc, 0, sizeof(rhc));
837         memset(trace, 0, sizeof(trace_t));
838         rhc.trace = trace;
839         rhc.trace->hitsupercontentsmask = hitsupercontentsmask;
840         rhc.trace->fraction = 1;
841         rhc.trace->realfraction = 1;
842         rhc.trace->allsolid = true;
843         VectorSubtract(boxmaxs, boxmins, boxsize);
844         if (boxsize[0] < 3)
845                 rhc.hull = &model->brushq1.hulls[0]; // 0x0x0
846         else if (model->brush.ismcbsp)
847         {
848                 if (boxsize[2] < 48) // pick the nearest of 40 or 56
849                         rhc.hull = &model->brushq1.hulls[2]; // 16x16x40
850                 else
851                         rhc.hull = &model->brushq1.hulls[1]; // 16x16x56
852         }
853         else if (model->brush.ishlbsp)
854         {
855                 // LordHavoc: this has to have a minor tolerance (the .1) because of
856                 // minor float precision errors from the box being transformed around
857                 if (boxsize[0] < 32.1)
858                 {
859                         if (boxsize[2] < 54) // pick the nearest of 36 or 72
860                                 rhc.hull = &model->brushq1.hulls[3]; // 32x32x36
861                         else
862                                 rhc.hull = &model->brushq1.hulls[1]; // 32x32x72
863                 }
864                 else
865                         rhc.hull = &model->brushq1.hulls[2]; // 64x64x64
866         }
867         else
868         {
869                 // LordHavoc: this has to have a minor tolerance (the .1) because of
870                 // minor float precision errors from the box being transformed around
871                 if (boxsize[0] < 32.1)
872                         rhc.hull = &model->brushq1.hulls[1]; // 32x32x56
873                 else
874                         rhc.hull = &model->brushq1.hulls[2]; // 64x64x88
875         }
876         VectorMAMAM(1, start, 1, boxmins, -1, rhc.hull->clip_mins, rhc.start);
877         VectorMAMAM(1, end, 1, boxmins, -1, rhc.hull->clip_mins, rhc.end);
878         VectorSubtract(rhc.end, rhc.start, rhc.dist);
879 #if COLLISIONPARANOID >= 2
880         Con_Printf("t(%f %f %f,%f %f %f,%i %f %f %f)", rhc.start[0], rhc.start[1], rhc.start[2], rhc.end[0], rhc.end[1], rhc.end[2], rhc.hull - model->brushq1.hulls, rhc.hull->clip_mins[0], rhc.hull->clip_mins[1], rhc.hull->clip_mins[2]);
881         Mod_Q1BSP_RecursiveHullCheck(&rhc, rhc.hull->firstclipnode, 0, 1, rhc.start, rhc.end);
882         {
883
884                 double test[3];
885                 trace_t testtrace;
886                 VectorLerp(rhc.start, rhc.trace->fraction, rhc.end, test);
887                 memset(&testtrace, 0, sizeof(trace_t));
888                 rhc.trace = &testtrace;
889                 rhc.trace->hitsupercontentsmask = hitsupercontentsmask;
890                 rhc.trace->fraction = 1;
891                 rhc.trace->realfraction = 1;
892                 rhc.trace->allsolid = true;
893                 VectorCopy(test, rhc.start);
894                 VectorCopy(test, rhc.end);
895                 VectorClear(rhc.dist);
896                 Mod_Q1BSP_RecursiveHullCheckPoint(&rhc, rhc.hull->firstclipnode);
897                 //Mod_Q1BSP_RecursiveHullCheck(&rhc, rhc.hull->firstclipnode, 0, 1, test, test);
898                 if (!trace->startsolid && testtrace.startsolid)
899                         Con_Printf(" - ended in solid!\n");
900         }
901         Con_Print("\n");
902 #else
903         if (VectorLength2(rhc.dist))
904                 Mod_Q1BSP_RecursiveHullCheck(&rhc, rhc.hull->firstclipnode, 0, 1, rhc.start, rhc.end);
905         else
906                 Mod_Q1BSP_RecursiveHullCheckPoint(&rhc, rhc.hull->firstclipnode);
907 #endif
908 }
909
910 void Collision_ClipTrace_Box(trace_t *trace, const vec3_t cmins, const vec3_t cmaxs, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, int hitsupercontentsmask, int boxsupercontents, int boxq3surfaceflags, texture_t *boxtexture)
911 {
912 #if 1
913         colbrushf_t cbox;
914         colplanef_t cbox_planes[6];
915         cbox.supercontents = boxsupercontents;
916         cbox.numplanes = 6;
917         cbox.numpoints = 0;
918         cbox.numtriangles = 0;
919         cbox.planes = cbox_planes;
920         cbox.points = NULL;
921         cbox.elements = NULL;
922         cbox.markframe = 0;
923         cbox.mins[0] = 0;
924         cbox.mins[1] = 0;
925         cbox.mins[2] = 0;
926         cbox.maxs[0] = 0;
927         cbox.maxs[1] = 0;
928         cbox.maxs[2] = 0;
929         cbox_planes[0].normal[0] =  1;cbox_planes[0].normal[1] =  0;cbox_planes[0].normal[2] =  0;cbox_planes[0].dist = cmaxs[0] - mins[0];
930         cbox_planes[1].normal[0] = -1;cbox_planes[1].normal[1] =  0;cbox_planes[1].normal[2] =  0;cbox_planes[1].dist = maxs[0] - cmins[0];
931         cbox_planes[2].normal[0] =  0;cbox_planes[2].normal[1] =  1;cbox_planes[2].normal[2] =  0;cbox_planes[2].dist = cmaxs[1] - mins[1];
932         cbox_planes[3].normal[0] =  0;cbox_planes[3].normal[1] = -1;cbox_planes[3].normal[2] =  0;cbox_planes[3].dist = maxs[1] - cmins[1];
933         cbox_planes[4].normal[0] =  0;cbox_planes[4].normal[1] =  0;cbox_planes[4].normal[2] =  1;cbox_planes[4].dist = cmaxs[2] - mins[2];
934         cbox_planes[5].normal[0] =  0;cbox_planes[5].normal[1] =  0;cbox_planes[5].normal[2] = -1;cbox_planes[5].dist = maxs[2] - cmins[2];
935         cbox_planes[0].q3surfaceflags = boxq3surfaceflags;cbox_planes[0].texture = boxtexture;
936         cbox_planes[1].q3surfaceflags = boxq3surfaceflags;cbox_planes[1].texture = boxtexture;
937         cbox_planes[2].q3surfaceflags = boxq3surfaceflags;cbox_planes[2].texture = boxtexture;
938         cbox_planes[3].q3surfaceflags = boxq3surfaceflags;cbox_planes[3].texture = boxtexture;
939         cbox_planes[4].q3surfaceflags = boxq3surfaceflags;cbox_planes[4].texture = boxtexture;
940         cbox_planes[5].q3surfaceflags = boxq3surfaceflags;cbox_planes[5].texture = boxtexture;
941         memset(trace, 0, sizeof(trace_t));
942         trace->hitsupercontentsmask = hitsupercontentsmask;
943         trace->fraction = 1;
944         trace->realfraction = 1;
945         Collision_TraceLineBrushFloat(trace, start, end, &cbox, &cbox);
946 #else
947         RecursiveHullCheckTraceInfo_t rhc;
948         static hull_t box_hull;
949         static dclipnode_t box_clipnodes[6];
950         static mplane_t box_planes[6];
951         // fill in a default trace
952         memset(&rhc, 0, sizeof(rhc));
953         memset(trace, 0, sizeof(trace_t));
954         //To keep everything totally uniform, bounding boxes are turned into small
955         //BSP trees instead of being compared directly.
956         // create a temp hull from bounding box sizes
957         box_planes[0].dist = cmaxs[0] - mins[0];
958         box_planes[1].dist = cmins[0] - maxs[0];
959         box_planes[2].dist = cmaxs[1] - mins[1];
960         box_planes[3].dist = cmins[1] - maxs[1];
961         box_planes[4].dist = cmaxs[2] - mins[2];
962         box_planes[5].dist = cmins[2] - maxs[2];
963 #if COLLISIONPARANOID >= 3
964         Con_Printf("box_planes %f:%f %f:%f %f:%f\ncbox %f %f %f:%f %f %f\nbox %f %f %f:%f %f %f\n", box_planes[0].dist, box_planes[1].dist, box_planes[2].dist, box_planes[3].dist, box_planes[4].dist, box_planes[5].dist, cmins[0], cmins[1], cmins[2], cmaxs[0], cmaxs[1], cmaxs[2], mins[0], mins[1], mins[2], maxs[0], maxs[1], maxs[2]);
965 #endif
966
967         if (box_hull.clipnodes == NULL)
968         {
969                 int i, side;
970
971                 //Set up the planes and clipnodes so that the six floats of a bounding box
972                 //can just be stored out and get a proper hull_t structure.
973
974                 box_hull.clipnodes = box_clipnodes;
975                 box_hull.planes = box_planes;
976                 box_hull.firstclipnode = 0;
977                 box_hull.lastclipnode = 5;
978
979                 for (i = 0;i < 6;i++)
980                 {
981                         box_clipnodes[i].planenum = i;
982
983                         side = i&1;
984
985                         box_clipnodes[i].children[side] = CONTENTS_EMPTY;
986                         if (i != 5)
987                                 box_clipnodes[i].children[side^1] = i + 1;
988                         else
989                                 box_clipnodes[i].children[side^1] = CONTENTS_SOLID;
990
991                         box_planes[i].type = i>>1;
992                         box_planes[i].normal[i>>1] = 1;
993                 }
994         }
995
996         // trace a line through the generated clipping hull
997         //rhc.boxsupercontents = boxsupercontents;
998         rhc.hull = &box_hull;
999         rhc.trace = trace;
1000         rhc.trace->hitsupercontentsmask = hitsupercontentsmask;
1001         rhc.trace->fraction = 1;
1002         rhc.trace->realfraction = 1;
1003         rhc.trace->allsolid = true;
1004         VectorCopy(start, rhc.start);
1005         VectorCopy(end, rhc.end);
1006         VectorSubtract(rhc.end, rhc.start, rhc.dist);
1007         Mod_Q1BSP_RecursiveHullCheck(&rhc, rhc.hull->firstclipnode, 0, 1, rhc.start, rhc.end);
1008         //VectorMA(rhc.start, rhc.trace->fraction, rhc.dist, rhc.trace->endpos);
1009         if (rhc.trace->startsupercontents)
1010                 rhc.trace->startsupercontents = boxsupercontents;
1011 #endif
1012 }
1013
1014 static int Mod_Q1BSP_TraceLineOfSight_RecursiveNodeCheck(mnode_t *node, double p1[3], double p2[3])
1015 {
1016         double t1, t2;
1017         double midf, mid[3];
1018         int ret, side;
1019
1020         // check for empty
1021         while (node->plane)
1022         {
1023                 // find the point distances
1024                 mplane_t *plane = node->plane;
1025                 if (plane->type < 3)
1026                 {
1027                         t1 = p1[plane->type] - plane->dist;
1028                         t2 = p2[plane->type] - plane->dist;
1029                 }
1030                 else
1031                 {
1032                         t1 = DotProduct (plane->normal, p1) - plane->dist;
1033                         t2 = DotProduct (plane->normal, p2) - plane->dist;
1034                 }
1035
1036                 if (t1 < 0)
1037                 {
1038                         if (t2 < 0)
1039                         {
1040                                 node = node->children[1];
1041                                 continue;
1042                         }
1043                         side = 1;
1044                 }
1045                 else
1046                 {
1047                         if (t2 >= 0)
1048                         {
1049                                 node = node->children[0];
1050                                 continue;
1051                         }
1052                         side = 0;
1053                 }
1054
1055                 midf = t1 / (t1 - t2);
1056                 VectorLerp(p1, midf, p2, mid);
1057
1058                 // recurse both sides, front side first
1059                 // return 2 if empty is followed by solid (hit something)
1060                 // do not return 2 if both are solid or both empty,
1061                 // or if start is solid and end is empty
1062                 // as these degenerate cases usually indicate the eye is in solid and
1063                 // should see the target point anyway
1064                 ret = Mod_Q1BSP_TraceLineOfSight_RecursiveNodeCheck(node->children[side    ], p1, mid);
1065                 if (ret != 0)
1066                         return ret;
1067                 ret = Mod_Q1BSP_TraceLineOfSight_RecursiveNodeCheck(node->children[side ^ 1], mid, p2);
1068                 if (ret != 1)
1069                         return ret;
1070                 return 2;
1071         }
1072         return ((mleaf_t *)node)->clusterindex < 0;
1073 }
1074
1075 static qboolean Mod_Q1BSP_TraceLineOfSight(struct model_s *model, const vec3_t start, const vec3_t end)
1076 {
1077         // this function currently only supports same size start and end
1078         double tracestart[3], traceend[3];
1079         VectorCopy(start, tracestart);
1080         VectorCopy(end, traceend);
1081         return Mod_Q1BSP_TraceLineOfSight_RecursiveNodeCheck(model->brush.data_nodes, tracestart, traceend) != 2;
1082 }
1083
1084 static int Mod_Q1BSP_LightPoint_RecursiveBSPNode(model_t *model, vec3_t ambientcolor, vec3_t diffusecolor, vec3_t diffusenormal, const mnode_t *node, float x, float y, float startz, float endz)
1085 {
1086         int side;
1087         float front, back;
1088         float mid, distz = endz - startz;
1089
1090 loc0:
1091         if (!node->plane)
1092                 return false;           // didn't hit anything
1093
1094         switch (node->plane->type)
1095         {
1096         case PLANE_X:
1097                 node = node->children[x < node->plane->dist];
1098                 goto loc0;
1099         case PLANE_Y:
1100                 node = node->children[y < node->plane->dist];
1101                 goto loc0;
1102         case PLANE_Z:
1103                 side = startz < node->plane->dist;
1104                 if ((endz < node->plane->dist) == side)
1105                 {
1106                         node = node->children[side];
1107                         goto loc0;
1108                 }
1109                 // found an intersection
1110                 mid = node->plane->dist;
1111                 break;
1112         default:
1113                 back = front = x * node->plane->normal[0] + y * node->plane->normal[1];
1114                 front += startz * node->plane->normal[2];
1115                 back += endz * node->plane->normal[2];
1116                 side = front < node->plane->dist;
1117                 if ((back < node->plane->dist) == side)
1118                 {
1119                         node = node->children[side];
1120                         goto loc0;
1121                 }
1122                 // found an intersection
1123                 mid = startz + distz * (front - node->plane->dist) / (front - back);
1124                 break;
1125         }
1126
1127         // go down front side
1128         if (node->children[side]->plane && Mod_Q1BSP_LightPoint_RecursiveBSPNode(model, ambientcolor, diffusecolor, diffusenormal, node->children[side], x, y, startz, mid))
1129                 return true;    // hit something
1130         else
1131         {
1132                 // check for impact on this node
1133                 if (node->numsurfaces)
1134                 {
1135                         int i, ds, dt;
1136                         msurface_t *surface;
1137
1138                         surface = model->data_surfaces + node->firstsurface;
1139                         for (i = 0;i < node->numsurfaces;i++, surface++)
1140                         {
1141                                 if (!(surface->texture->basematerialflags & MATERIALFLAG_WALL) || !surface->lightmapinfo->samples)
1142                                         continue;       // no lightmaps
1143
1144                                 ds = (int) (x * surface->lightmapinfo->texinfo->vecs[0][0] + y * surface->lightmapinfo->texinfo->vecs[0][1] + mid * surface->lightmapinfo->texinfo->vecs[0][2] + surface->lightmapinfo->texinfo->vecs[0][3]) - surface->lightmapinfo->texturemins[0];
1145                                 dt = (int) (x * surface->lightmapinfo->texinfo->vecs[1][0] + y * surface->lightmapinfo->texinfo->vecs[1][1] + mid * surface->lightmapinfo->texinfo->vecs[1][2] + surface->lightmapinfo->texinfo->vecs[1][3]) - surface->lightmapinfo->texturemins[1];
1146
1147                                 if (ds >= 0 && ds < surface->lightmapinfo->extents[0] && dt >= 0 && dt < surface->lightmapinfo->extents[1])
1148                                 {
1149                                         unsigned char *lightmap;
1150                                         int lmwidth, lmheight, maps, line3, size3, dsfrac = ds & 15, dtfrac = dt & 15, scale = 0, r00 = 0, g00 = 0, b00 = 0, r01 = 0, g01 = 0, b01 = 0, r10 = 0, g10 = 0, b10 = 0, r11 = 0, g11 = 0, b11 = 0;
1151                                         lmwidth = ((surface->lightmapinfo->extents[0]>>4)+1);
1152                                         lmheight = ((surface->lightmapinfo->extents[1]>>4)+1);
1153                                         line3 = lmwidth * 3; // LordHavoc: *3 for colored lighting
1154                                         size3 = lmwidth * lmheight * 3; // LordHavoc: *3 for colored lighting
1155
1156                                         lightmap = surface->lightmapinfo->samples + ((dt>>4) * lmwidth + (ds>>4))*3; // LordHavoc: *3 for colored lighting
1157
1158                                         for (maps = 0;maps < MAXLIGHTMAPS && surface->lightmapinfo->styles[maps] != 255;maps++)
1159                                         {
1160                                                 scale = r_refdef.lightstylevalue[surface->lightmapinfo->styles[maps]];
1161                                                 r00 += lightmap[      0] * scale;g00 += lightmap[      1] * scale;b00 += lightmap[      2] * scale;
1162                                                 r01 += lightmap[      3] * scale;g01 += lightmap[      4] * scale;b01 += lightmap[      5] * scale;
1163                                                 r10 += lightmap[line3+0] * scale;g10 += lightmap[line3+1] * scale;b10 += lightmap[line3+2] * scale;
1164                                                 r11 += lightmap[line3+3] * scale;g11 += lightmap[line3+4] * scale;b11 += lightmap[line3+5] * scale;
1165                                                 lightmap += size3;
1166                                         }
1167
1168 /*
1169 LordHavoc: here's the readable version of the interpolation
1170 code, not quite as easy for the compiler to optimize...
1171
1172 dsfrac is the X position in the lightmap pixel, * 16
1173 dtfrac is the Y position in the lightmap pixel, * 16
1174 r00 is top left corner, r01 is top right corner
1175 r10 is bottom left corner, r11 is bottom right corner
1176 g and b are the same layout.
1177 r0 and r1 are the top and bottom intermediate results
1178
1179 first we interpolate the top two points, to get the top
1180 edge sample
1181
1182         r0 = (((r01-r00) * dsfrac) >> 4) + r00;
1183         g0 = (((g01-g00) * dsfrac) >> 4) + g00;
1184         b0 = (((b01-b00) * dsfrac) >> 4) + b00;
1185
1186 then we interpolate the bottom two points, to get the
1187 bottom edge sample
1188
1189         r1 = (((r11-r10) * dsfrac) >> 4) + r10;
1190         g1 = (((g11-g10) * dsfrac) >> 4) + g10;
1191         b1 = (((b11-b10) * dsfrac) >> 4) + b10;
1192
1193 then we interpolate the top and bottom samples to get the
1194 middle sample (the one which was requested)
1195
1196         r = (((r1-r0) * dtfrac) >> 4) + r0;
1197         g = (((g1-g0) * dtfrac) >> 4) + g0;
1198         b = (((b1-b0) * dtfrac) >> 4) + b0;
1199 */
1200
1201                                         ambientcolor[0] += (float) ((((((((r11-r10) * dsfrac) >> 4) + r10)-((((r01-r00) * dsfrac) >> 4) + r00)) * dtfrac) >> 4) + ((((r01-r00) * dsfrac) >> 4) + r00)) * (1.0f / 32768.0f);
1202                                         ambientcolor[1] += (float) ((((((((g11-g10) * dsfrac) >> 4) + g10)-((((g01-g00) * dsfrac) >> 4) + g00)) * dtfrac) >> 4) + ((((g01-g00) * dsfrac) >> 4) + g00)) * (1.0f / 32768.0f);
1203                                         ambientcolor[2] += (float) ((((((((b11-b10) * dsfrac) >> 4) + b10)-((((b01-b00) * dsfrac) >> 4) + b00)) * dtfrac) >> 4) + ((((b01-b00) * dsfrac) >> 4) + b00)) * (1.0f / 32768.0f);
1204                                         return true; // success
1205                                 }
1206                         }
1207                 }
1208
1209                 // go down back side
1210                 node = node->children[side ^ 1];
1211                 startz = mid;
1212                 distz = endz - startz;
1213                 goto loc0;
1214         }
1215 }
1216
1217 void Mod_Q1BSP_LightPoint(model_t *model, const vec3_t p, vec3_t ambientcolor, vec3_t diffusecolor, vec3_t diffusenormal)
1218 {
1219         // pretend lighting is coming down from above (due to lack of a lightgrid to know primary lighting direction)
1220         VectorSet(diffusenormal, 0, 0, 1);
1221
1222         if (!model->brushq1.lightdata)
1223         {
1224                 VectorSet(ambientcolor, 1, 1, 1);
1225                 VectorSet(diffusecolor, 0, 0, 0);
1226                 return;
1227         }
1228
1229         Mod_Q1BSP_LightPoint_RecursiveBSPNode(model, ambientcolor, diffusecolor, diffusenormal, model->brush.data_nodes + model->brushq1.hulls[0].firstclipnode, p[0], p[1], p[2] + 0.125, p[2] - 65536);
1230 }
1231
1232 static void Mod_Q1BSP_DecompressVis(const unsigned char *in, const unsigned char *inend, unsigned char *out, unsigned char *outend)
1233 {
1234         int c;
1235         unsigned char *outstart = out;
1236         while (out < outend)
1237         {
1238                 if (in == inend)
1239                 {
1240                         Con_Printf("Mod_Q1BSP_DecompressVis: input underrun on model \"%s\" (decompressed %i of %i output bytes)\n", loadmodel->name, (int)(out - outstart), (int)(outend - outstart));
1241                         return;
1242                 }
1243                 c = *in++;
1244                 if (c)
1245                         *out++ = c;
1246                 else
1247                 {
1248                         if (in == inend)
1249                         {
1250                                 Con_Printf("Mod_Q1BSP_DecompressVis: input underrun (during zero-run) on model \"%s\" (decompressed %i of %i output bytes)\n", loadmodel->name, (int)(out - outstart), (int)(outend - outstart));
1251                                 return;
1252                         }
1253                         for (c = *in++;c > 0;c--)
1254                         {
1255                                 if (out == outend)
1256                                 {
1257                                         Con_Printf("Mod_Q1BSP_DecompressVis: output overrun on model \"%s\" (decompressed %i of %i output bytes)\n", loadmodel->name, (int)(out - outstart), (int)(outend - outstart));
1258                                         return;
1259                                 }
1260                                 *out++ = 0;
1261                         }
1262                 }
1263         }
1264 }
1265
1266 /*
1267 =============
1268 R_Q1BSP_LoadSplitSky
1269
1270 A sky texture is 256*128, with the right side being a masked overlay
1271 ==============
1272 */
1273 void R_Q1BSP_LoadSplitSky (unsigned char *src, int width, int height, int bytesperpixel)
1274 {
1275         int i, j;
1276         unsigned solidpixels[128*128], alphapixels[128*128];
1277
1278         // allocate a texture pool if we need it
1279         if (loadmodel->texturepool == NULL && cls.state != ca_dedicated)
1280                 loadmodel->texturepool = R_AllocTexturePool();
1281
1282         // if sky isn't the right size, just use it as a solid layer
1283         if (width != 256 || height != 128)
1284         {
1285                 loadmodel->brush.solidskytexture = R_LoadTexture2D(loadmodel->texturepool, "sky_solidtexture", width, height, src, bytesperpixel == 4 ? TEXTYPE_RGBA : TEXTYPE_PALETTE, TEXF_PRECACHE, bytesperpixel == 1 ? palette_complete : NULL);
1286                 loadmodel->brush.alphaskytexture = NULL;
1287                 return;
1288         }
1289
1290         if (bytesperpixel == 4)
1291         {
1292                 for (i = 0;i < 128;i++)
1293                 {
1294                         for (j = 0;j < 128;j++)
1295                         {
1296                                 solidpixels[(i*128) + j] = ((unsigned *)src)[i*256+j+128];
1297                                 alphapixels[(i*128) + j] = ((unsigned *)src)[i*256+j];
1298                         }
1299                 }
1300         }
1301         else
1302         {
1303                 // make an average value for the back to avoid
1304                 // a fringe on the top level
1305                 int p, r, g, b;
1306                 union
1307                 {
1308                         unsigned int i;
1309                         unsigned char b[4];
1310                 }
1311                 rgba;
1312                 r = g = b = 0;
1313                 for (i = 0;i < 128;i++)
1314                 {
1315                         for (j = 0;j < 128;j++)
1316                         {
1317                                 rgba.i = palette_complete[src[i*256 + j + 128]];
1318                                 r += rgba.b[0];
1319                                 g += rgba.b[1];
1320                                 b += rgba.b[2];
1321                         }
1322                 }
1323                 rgba.b[0] = r/(128*128);
1324                 rgba.b[1] = g/(128*128);
1325                 rgba.b[2] = b/(128*128);
1326                 rgba.b[3] = 0;
1327                 for (i = 0;i < 128;i++)
1328                 {
1329                         for (j = 0;j < 128;j++)
1330                         {
1331                                 solidpixels[(i*128) + j] = palette_complete[src[i*256 + j + 128]];
1332                                 alphapixels[(i*128) + j] = (p = src[i*256 + j]) ? palette_complete[p] : rgba.i;
1333                         }
1334                 }
1335         }
1336
1337         loadmodel->brush.solidskytexture = R_LoadTexture2D(loadmodel->texturepool, "sky_solidtexture", 128, 128, (unsigned char *) solidpixels, TEXTYPE_RGBA, TEXF_PRECACHE, NULL);
1338         loadmodel->brush.alphaskytexture = R_LoadTexture2D(loadmodel->texturepool, "sky_alphatexture", 128, 128, (unsigned char *) alphapixels, TEXTYPE_RGBA, TEXF_ALPHA | TEXF_PRECACHE, NULL);
1339 }
1340
1341 static void Mod_Q1BSP_LoadTextures(lump_t *l)
1342 {
1343         int i, j, k, num, max, altmax, mtwidth, mtheight, *dofs, incomplete;
1344         skinframe_t *skinframe;
1345         miptex_t *dmiptex;
1346         texture_t *tx, *tx2, *anims[10], *altanims[10];
1347         dmiptexlump_t *m;
1348         unsigned char *data, *mtdata;
1349         const char *s;
1350         char mapname[MAX_QPATH], name[MAX_QPATH];
1351
1352         loadmodel->data_textures = NULL;
1353
1354         // add two slots for notexture walls and notexture liquids
1355         if (l->filelen)
1356         {
1357                 m = (dmiptexlump_t *)(mod_base + l->fileofs);
1358                 m->nummiptex = LittleLong (m->nummiptex);
1359                 loadmodel->num_textures = m->nummiptex + 2;
1360                 loadmodel->num_texturesperskin = loadmodel->num_textures;
1361         }
1362         else
1363         {
1364                 m = NULL;
1365                 loadmodel->num_textures = 2;
1366                 loadmodel->num_texturesperskin = loadmodel->num_textures;
1367         }
1368
1369         loadmodel->data_textures = (texture_t *)Mem_Alloc(loadmodel->mempool, loadmodel->num_textures * sizeof(texture_t));
1370
1371         // fill out all slots with notexture
1372         if (cls.state != ca_dedicated)
1373                 skinframe = R_SkinFrame_LoadMissing();
1374         else
1375                 skinframe = NULL;
1376         for (i = 0, tx = loadmodel->data_textures;i < loadmodel->num_textures;i++, tx++)
1377         {
1378                 strlcpy(tx->name, "NO TEXTURE FOUND", sizeof(tx->name));
1379                 tx->width = 16;
1380                 tx->height = 16;
1381                 if (cls.state != ca_dedicated)
1382                 {
1383                         tx->numskinframes = 1;
1384                         tx->skinframerate = 1;
1385                         tx->skinframes[0] = skinframe;
1386                         tx->currentskinframe = tx->skinframes[0];
1387                         tx->basematerialflags = 0;
1388                 }
1389                 if (i == loadmodel->num_textures - 1)
1390                 {
1391                         tx->basematerialflags |= MATERIALFLAG_WATER | MATERIALFLAG_LIGHTBOTHSIDES | MATERIALFLAG_NOSHADOW;
1392                         tx->supercontents = mod_q1bsp_texture_water.supercontents;
1393                         tx->surfaceflags = mod_q1bsp_texture_water.surfaceflags;
1394                 }
1395                 else
1396                 {
1397                         tx->basematerialflags |= MATERIALFLAG_WALL;
1398                         tx->supercontents = mod_q1bsp_texture_solid.supercontents;
1399                         tx->surfaceflags = mod_q1bsp_texture_solid.surfaceflags;
1400                 }
1401                 tx->currentframe = tx;
1402         }
1403
1404         if (!m)
1405         {
1406                 Con_Printf("%s: no miptex lump to load textures from\n", loadmodel->name);
1407                 return;
1408         }
1409
1410         s = loadmodel->name;
1411         if (!strncasecmp(s, "maps/", 5))
1412                 s += 5;
1413         FS_StripExtension(s, mapname, sizeof(mapname));
1414
1415         // just to work around bounds checking when debugging with it (array index out of bounds error thing)
1416         dofs = m->dataofs;
1417         // LordHavoc: mostly rewritten map texture loader
1418         for (i = 0;i < m->nummiptex;i++)
1419         {
1420                 dofs[i] = LittleLong(dofs[i]);
1421                 if (r_nosurftextures.integer)
1422                         continue;
1423                 if (dofs[i] == -1)
1424                 {
1425                         Con_DPrintf("%s: miptex #%i missing\n", loadmodel->name, i);
1426                         continue;
1427                 }
1428                 dmiptex = (miptex_t *)((unsigned char *)m + dofs[i]);
1429
1430                 // copy name, but only up to 16 characters
1431                 // (the output buffer can hold more than this, but the input buffer is
1432                 //  only 16)
1433                 for (j = 0;dmiptex->name[j] && j < 16;j++)
1434                         name[j] = dmiptex->name[j];
1435                 name[j] = 0;
1436
1437                 if (!name[0])
1438                 {
1439                         sprintf(name, "unnamed%i", i);
1440                         Con_DPrintf("%s: warning: renaming unnamed texture to %s\n", loadmodel->name, name);
1441                 }
1442
1443                 mtwidth = LittleLong(dmiptex->width);
1444                 mtheight = LittleLong(dmiptex->height);
1445                 mtdata = NULL;
1446                 j = LittleLong(dmiptex->offsets[0]);
1447                 if (j)
1448                 {
1449                         // texture included
1450                         if (j < 40 || j + mtwidth * mtheight > l->filelen)
1451                         {
1452                                 Con_Printf("%s: Texture \"%s\" is corrupt or incomplete\n", loadmodel->name, dmiptex->name);
1453                                 continue;
1454                         }
1455                         mtdata = (unsigned char *)dmiptex + j;
1456                 }
1457
1458                 if ((mtwidth & 15) || (mtheight & 15))
1459                         Con_DPrintf("%s: warning: texture \"%s\" is not 16 aligned\n", loadmodel->name, dmiptex->name);
1460
1461                 // LordHavoc: force all names to lowercase
1462                 for (j = 0;name[j];j++)
1463                         if (name[j] >= 'A' && name[j] <= 'Z')
1464                                 name[j] += 'a' - 'A';
1465
1466                 if (dmiptex->name[0] && Mod_LoadTextureFromQ3Shader(loadmodel->data_textures + i, name, true, false, false))
1467                         continue;
1468
1469                 tx = loadmodel->data_textures + i;
1470                 strlcpy(tx->name, name, sizeof(tx->name));
1471                 tx->width = mtwidth;
1472                 tx->height = mtheight;
1473
1474                 if (tx->name[0] == '*')
1475                 {
1476                         if (!strncmp(tx->name, "*lava", 5))
1477                         {
1478                                 tx->supercontents = mod_q1bsp_texture_lava.supercontents;
1479                                 tx->surfaceflags = mod_q1bsp_texture_lava.surfaceflags;
1480                         }
1481                         else if (!strncmp(tx->name, "*slime", 6))
1482                         {
1483                                 tx->supercontents = mod_q1bsp_texture_slime.supercontents;
1484                                 tx->surfaceflags = mod_q1bsp_texture_slime.surfaceflags;
1485                         }
1486                         else
1487                         {
1488                                 tx->supercontents = mod_q1bsp_texture_water.supercontents;
1489                                 tx->surfaceflags = mod_q1bsp_texture_water.surfaceflags;
1490                         }
1491                 }
1492                 else if (!strncmp(tx->name, "sky", 3))
1493                 {
1494                         tx->supercontents = mod_q1bsp_texture_sky.supercontents;
1495                         tx->surfaceflags = mod_q1bsp_texture_sky.surfaceflags;
1496                 }
1497                 else
1498                 {
1499                         tx->supercontents = mod_q1bsp_texture_solid.supercontents;
1500                         tx->surfaceflags = mod_q1bsp_texture_solid.surfaceflags;
1501                 }
1502
1503                 if (cls.state != ca_dedicated)
1504                 {
1505                         // LordHavoc: HL sky textures are entirely different than quake
1506                         if (!loadmodel->brush.ishlbsp && !strncmp(tx->name, "sky", 3) && mtwidth == 256 && mtheight == 128)
1507                         {
1508                                 if (loadmodel->isworldmodel)
1509                                 {
1510                                         data = loadimagepixels(tx->name, false, 0, 0);
1511                                         if (data)
1512                                         {
1513                                                 R_Q1BSP_LoadSplitSky(data, image_width, image_height, 4);
1514                                                 Mem_Free(data);
1515                                         }
1516                                         else if (mtdata != NULL)
1517                                                 R_Q1BSP_LoadSplitSky(mtdata, mtwidth, mtheight, 1);
1518                                 }
1519                         }
1520                         else
1521                         {
1522                                 skinframe = R_SkinFrame_LoadExternal(gamemode == GAME_TENEBRAE ? tx->name : va("textures/%s/%s", mapname, tx->name), TEXF_MIPMAP | TEXF_ALPHA | TEXF_PRECACHE | (r_picmipworld.integer ? TEXF_PICMIP : 0), false);
1523                                 if (!skinframe)
1524                                         skinframe = R_SkinFrame_LoadExternal(gamemode == GAME_TENEBRAE ? tx->name : va("textures/%s", tx->name), TEXF_MIPMAP | TEXF_ALPHA | TEXF_PRECACHE | (r_picmipworld.integer ? TEXF_PICMIP : 0), false);
1525                                 if (!skinframe)
1526                                 {
1527                                         // did not find external texture, load it from the bsp or wad3
1528                                         if (loadmodel->brush.ishlbsp)
1529                                         {
1530                                                 // internal texture overrides wad
1531                                                 unsigned char *pixels, *freepixels;
1532                                                 pixels = freepixels = NULL;
1533                                                 if (mtdata)
1534                                                         pixels = W_ConvertWAD3Texture(dmiptex);
1535                                                 if (pixels == NULL)
1536                                                         pixels = freepixels = W_GetTexture(tx->name);
1537                                                 if (pixels != NULL)
1538                                                 {
1539                                                         tx->width = image_width;
1540                                                         tx->height = image_height;
1541                                                         skinframe = R_SkinFrame_LoadInternal(tx->name, TEXF_MIPMAP | TEXF_ALPHA | TEXF_PRECACHE | (r_picmipworld.integer ? TEXF_PICMIP : 0), false, false, pixels, image_width, image_height, 32, NULL, NULL);
1542                                                 }
1543                                                 if (freepixels)
1544                                                         Mem_Free(freepixels);
1545                                         }
1546                                         else if (mtdata) // texture included
1547                                                 skinframe = R_SkinFrame_LoadInternal(tx->name, TEXF_MIPMAP | TEXF_PRECACHE | (r_picmipworld.integer ? TEXF_PICMIP : 0), false, r_fullbrights.integer, mtdata, tx->width, tx->height, 8, NULL, NULL);
1548                                 }
1549                                 // if skinframe is still NULL the "missing" texture will be used
1550                                 if (skinframe)
1551                                         tx->skinframes[0] = skinframe;
1552                         }
1553
1554                         tx->basematerialflags = 0;
1555                         if (tx->name[0] == '*')
1556                         {
1557                                 // LordHavoc: some turbulent textures should not be affected by wateralpha
1558                                 if (strncmp(tx->name,"*lava",5)
1559                                  && strncmp(tx->name,"*teleport",9)
1560                                  && strncmp(tx->name,"*rift",5)) // Scourge of Armagon texture
1561                                         tx->basematerialflags |= MATERIALFLAG_WATERALPHA | MATERIALFLAG_NOSHADOW;
1562                                 tx->basematerialflags |= MATERIALFLAG_WATER | MATERIALFLAG_LIGHTBOTHSIDES | MATERIALFLAG_NOSHADOW;
1563                         }
1564                         else if (!strncmp(tx->name, "sky", 3))
1565                                 tx->basematerialflags |= MATERIALFLAG_SKY | MATERIALFLAG_NOSHADOW;
1566                         else
1567                                 tx->basematerialflags |= MATERIALFLAG_WALL;
1568                         if (tx->skinframes[0] && tx->skinframes[0]->fog)
1569                                 tx->basematerialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW;
1570
1571                         // start out with no animation
1572                         tx->currentframe = tx;
1573                         tx->currentskinframe = tx->skinframes[0];
1574                 }
1575         }
1576
1577         // sequence the animations
1578         for (i = 0;i < m->nummiptex;i++)
1579         {
1580                 tx = loadmodel->data_textures + i;
1581                 if (!tx || tx->name[0] != '+' || tx->name[1] == 0 || tx->name[2] == 0)
1582                         continue;
1583                 if (tx->anim_total[0] || tx->anim_total[1])
1584                         continue;       // already sequenced
1585
1586                 // find the number of frames in the animation
1587                 memset(anims, 0, sizeof(anims));
1588                 memset(altanims, 0, sizeof(altanims));
1589
1590                 for (j = i;j < m->nummiptex;j++)
1591                 {
1592                         tx2 = loadmodel->data_textures + j;
1593                         if (!tx2 || tx2->name[0] != '+' || strcmp(tx2->name+2, tx->name+2))
1594                                 continue;
1595
1596                         num = tx2->name[1];
1597                         if (num >= '0' && num <= '9')
1598                                 anims[num - '0'] = tx2;
1599                         else if (num >= 'a' && num <= 'j')
1600                                 altanims[num - 'a'] = tx2;
1601                         else
1602                                 Con_Printf("Bad animating texture %s\n", tx->name);
1603                 }
1604
1605                 max = altmax = 0;
1606                 for (j = 0;j < 10;j++)
1607                 {
1608                         if (anims[j])
1609                                 max = j + 1;
1610                         if (altanims[j])
1611                                 altmax = j + 1;
1612                 }
1613                 //Con_Printf("linking animation %s (%i:%i frames)\n\n", tx->name, max, altmax);
1614
1615                 incomplete = false;
1616                 for (j = 0;j < max;j++)
1617                 {
1618                         if (!anims[j])
1619                         {
1620                                 Con_Printf("Missing frame %i of %s\n", j, tx->name);
1621                                 incomplete = true;
1622                         }
1623                 }
1624                 for (j = 0;j < altmax;j++)
1625                 {
1626                         if (!altanims[j])
1627                         {
1628                                 Con_Printf("Missing altframe %i of %s\n", j, tx->name);
1629                                 incomplete = true;
1630                         }
1631                 }
1632                 if (incomplete)
1633                         continue;
1634
1635                 if (altmax < 1)
1636                 {
1637                         // if there is no alternate animation, duplicate the primary
1638                         // animation into the alternate
1639                         altmax = max;
1640                         for (k = 0;k < 10;k++)
1641                                 altanims[k] = anims[k];
1642                 }
1643
1644                 // link together the primary animation
1645                 for (j = 0;j < max;j++)
1646                 {
1647                         tx2 = anims[j];
1648                         tx2->animated = true;
1649                         tx2->anim_total[0] = max;
1650                         tx2->anim_total[1] = altmax;
1651                         for (k = 0;k < 10;k++)
1652                         {
1653                                 tx2->anim_frames[0][k] = anims[k];
1654                                 tx2->anim_frames[1][k] = altanims[k];
1655                         }
1656                 }
1657
1658                 // if there really is an alternate anim...
1659                 if (anims[0] != altanims[0])
1660                 {
1661                         // link together the alternate animation
1662                         for (j = 0;j < altmax;j++)
1663                         {
1664                                 tx2 = altanims[j];
1665                                 tx2->animated = true;
1666                                 // the primary/alternate are reversed here
1667                                 tx2->anim_total[0] = altmax;
1668                                 tx2->anim_total[1] = max;
1669                                 for (k = 0;k < 10;k++)
1670                                 {
1671                                         tx2->anim_frames[0][k] = altanims[k];
1672                                         tx2->anim_frames[1][k] = anims[k];
1673                                 }
1674                         }
1675                 }
1676         }
1677 }
1678
1679 static void Mod_Q1BSP_LoadLighting(lump_t *l)
1680 {
1681         int i;
1682         unsigned char *in, *out, *data, d;
1683         char litfilename[MAX_QPATH];
1684         char dlitfilename[MAX_QPATH];
1685         fs_offset_t filesize;
1686         if (loadmodel->brush.ishlbsp) // LordHavoc: load the colored lighting data straight
1687         {
1688                 loadmodel->brushq1.lightdata = (unsigned char *)Mem_Alloc(loadmodel->mempool, l->filelen);
1689                 for (i=0; i<l->filelen; i++)
1690                         loadmodel->brushq1.lightdata[i] = mod_base[l->fileofs+i] >>= 1;
1691         }
1692         else if (loadmodel->brush.ismcbsp)
1693         {
1694                 loadmodel->brushq1.lightdata = (unsigned char *)Mem_Alloc(loadmodel->mempool, l->filelen);
1695                 memcpy(loadmodel->brushq1.lightdata, mod_base + l->fileofs, l->filelen);
1696         }
1697         else // LordHavoc: bsp version 29 (normal white lighting)
1698         {
1699                 // LordHavoc: hope is not lost yet, check for a .lit file to load
1700                 strlcpy (litfilename, loadmodel->name, sizeof (litfilename));
1701                 FS_StripExtension (litfilename, litfilename, sizeof (litfilename));
1702                 strlcpy (dlitfilename, litfilename, sizeof (dlitfilename));
1703                 strlcat (litfilename, ".lit", sizeof (litfilename));
1704                 strlcat (dlitfilename, ".dlit", sizeof (dlitfilename));
1705                 data = (unsigned char*) FS_LoadFile(litfilename, tempmempool, false, &filesize);
1706                 if (data)
1707                 {
1708                         if (filesize == (fs_offset_t)(8 + l->filelen * 3) && data[0] == 'Q' && data[1] == 'L' && data[2] == 'I' && data[3] == 'T')
1709                         {
1710                                 i = LittleLong(((int *)data)[1]);
1711                                 if (i == 1)
1712                                 {
1713                                         Con_DPrintf("loaded %s\n", litfilename);
1714                                         loadmodel->brushq1.lightdata = (unsigned char *)Mem_Alloc(loadmodel->mempool, filesize - 8);
1715                                         memcpy(loadmodel->brushq1.lightdata, data + 8, filesize - 8);
1716                                         Mem_Free(data);
1717                                         data = (unsigned char*) FS_LoadFile(dlitfilename, tempmempool, false, &filesize);
1718                                         if (data)
1719                                         {
1720                                                 if (filesize == (fs_offset_t)(8 + l->filelen * 3) && data[0] == 'Q' && data[1] == 'L' && data[2] == 'I' && data[3] == 'T')
1721                                                 {
1722                                                         i = LittleLong(((int *)data)[1]);
1723                                                         if (i == 1)
1724                                                         {
1725                                                                 Con_DPrintf("loaded %s\n", dlitfilename);
1726                                                                 loadmodel->brushq1.nmaplightdata = (unsigned char *)Mem_Alloc(loadmodel->mempool, filesize - 8);
1727                                                                 memcpy(loadmodel->brushq1.nmaplightdata, data + 8, filesize - 8);
1728                                                                 loadmodel->brushq3.deluxemapping_modelspace = false;
1729                                                                 loadmodel->brushq3.deluxemapping = true;
1730                                                         }
1731                                                 }
1732                                                 Mem_Free(data);
1733                                                 data = NULL;
1734                                         }
1735                                         return;
1736                                 }
1737                                 else
1738                                         Con_Printf("Unknown .lit file version (%d)\n", i);
1739                         }
1740                         else if (filesize == 8)
1741                                 Con_Print("Empty .lit file, ignoring\n");
1742                         else
1743                                 Con_Printf("Corrupt .lit file (file size %i bytes, should be %i bytes), ignoring\n", (int) filesize, (int) (8 + l->filelen * 3));
1744                         if (data)
1745                         {
1746                                 Mem_Free(data);
1747                                 data = NULL;
1748                         }
1749                 }
1750                 // LordHavoc: oh well, expand the white lighting data
1751                 if (!l->filelen)
1752                         return;
1753                 loadmodel->brushq1.lightdata = (unsigned char *)Mem_Alloc(loadmodel->mempool, l->filelen*3);
1754                 in = mod_base + l->fileofs;
1755                 out = loadmodel->brushq1.lightdata;
1756                 for (i = 0;i < l->filelen;i++)
1757                 {
1758                         d = *in++;
1759                         *out++ = d;
1760                         *out++ = d;
1761                         *out++ = d;
1762                 }
1763         }
1764 }
1765
1766 static void Mod_Q1BSP_LoadVisibility(lump_t *l)
1767 {
1768         loadmodel->brushq1.num_compressedpvs = 0;
1769         loadmodel->brushq1.data_compressedpvs = NULL;
1770         if (!l->filelen)
1771                 return;
1772         loadmodel->brushq1.num_compressedpvs = l->filelen;
1773         loadmodel->brushq1.data_compressedpvs = (unsigned char *)Mem_Alloc(loadmodel->mempool, l->filelen);
1774         memcpy(loadmodel->brushq1.data_compressedpvs, mod_base + l->fileofs, l->filelen);
1775 }
1776
1777 // used only for HalfLife maps
1778 static void Mod_Q1BSP_ParseWadsFromEntityLump(const char *data)
1779 {
1780         char key[128], value[4096];
1781         char wadname[128];
1782         int i, j, k;
1783         if (!data)
1784                 return;
1785         if (!COM_ParseToken_Simple(&data, false))
1786                 return; // error
1787         if (com_token[0] != '{')
1788                 return; // error
1789         while (1)
1790         {
1791                 if (!COM_ParseToken_Simple(&data, false))
1792                         return; // error
1793                 if (com_token[0] == '}')
1794                         break; // end of worldspawn
1795                 if (com_token[0] == '_')
1796                         strlcpy(key, com_token + 1, sizeof(key));
1797                 else
1798                         strlcpy(key, com_token, sizeof(key));
1799                 while (key[strlen(key)-1] == ' ') // remove trailing spaces
1800                         key[strlen(key)-1] = 0;
1801                 if (!COM_ParseToken_Simple(&data, false))
1802                         return; // error
1803                 dpsnprintf(value, sizeof(value), "%s", com_token);
1804                 if (!strcmp("wad", key)) // for HalfLife maps
1805                 {
1806                         if (loadmodel->brush.ishlbsp)
1807                         {
1808                                 j = 0;
1809                                 for (i = 0;i < (int)sizeof(value);i++)
1810                                         if (value[i] != ';' && value[i] != '\\' && value[i] != '/' && value[i] != ':')
1811                                                 break;
1812                                 if (value[i])
1813                                 {
1814                                         for (;i < (int)sizeof(value);i++)
1815                                         {
1816                                                 // ignore path - the \\ check is for HalfLife... stupid windoze 'programmers'...
1817                                                 if (value[i] == '\\' || value[i] == '/' || value[i] == ':')
1818                                                         j = i+1;
1819                                                 else if (value[i] == ';' || value[i] == 0)
1820                                                 {
1821                                                         k = value[i];
1822                                                         value[i] = 0;
1823                                                         strlcpy(wadname, "textures/", sizeof(wadname));
1824                                                         strlcat(wadname, &value[j], sizeof(wadname));
1825                                                         W_LoadTextureWadFile(wadname, false);
1826                                                         j = i+1;
1827                                                         if (!k)
1828                                                                 break;
1829                                                 }
1830                                         }
1831                                 }
1832                         }
1833                 }
1834         }
1835 }
1836
1837 static void Mod_Q1BSP_LoadEntities(lump_t *l)
1838 {
1839         loadmodel->brush.entities = NULL;
1840         if (!l->filelen)
1841                 return;
1842         loadmodel->brush.entities = (char *)Mem_Alloc(loadmodel->mempool, l->filelen);
1843         memcpy(loadmodel->brush.entities, mod_base + l->fileofs, l->filelen);
1844         if (loadmodel->brush.ishlbsp)
1845                 Mod_Q1BSP_ParseWadsFromEntityLump(loadmodel->brush.entities);
1846 }
1847
1848
1849 static void Mod_Q1BSP_LoadVertexes(lump_t *l)
1850 {
1851         dvertex_t       *in;
1852         mvertex_t       *out;
1853         int                     i, count;
1854
1855         in = (dvertex_t *)(mod_base + l->fileofs);
1856         if (l->filelen % sizeof(*in))
1857                 Host_Error("Mod_Q1BSP_LoadVertexes: funny lump size in %s",loadmodel->name);
1858         count = l->filelen / sizeof(*in);
1859         out = (mvertex_t *)Mem_Alloc(loadmodel->mempool, count*sizeof(*out));
1860
1861         loadmodel->brushq1.vertexes = out;
1862         loadmodel->brushq1.numvertexes = count;
1863
1864         for ( i=0 ; i<count ; i++, in++, out++)
1865         {
1866                 out->position[0] = LittleFloat(in->point[0]);
1867                 out->position[1] = LittleFloat(in->point[1]);
1868                 out->position[2] = LittleFloat(in->point[2]);
1869         }
1870 }
1871
1872 // The following two functions should be removed and MSG_* or SZ_* function sets adjusted so they
1873 // can be used for this
1874 // REMOVEME
1875 int SB_ReadInt (unsigned char **buffer)
1876 {
1877         int     i;
1878         i = ((*buffer)[0]) + 256*((*buffer)[1]) + 65536*((*buffer)[2]) + 16777216*((*buffer)[3]);
1879         (*buffer) += 4;
1880         return i;
1881 }
1882
1883 // REMOVEME
1884 float SB_ReadFloat (unsigned char **buffer)
1885 {
1886         union
1887         {
1888                 int             i;
1889                 float   f;
1890         } u;
1891
1892         u.i = SB_ReadInt (buffer);
1893         return u.f;
1894 }
1895
1896 static void Mod_Q1BSP_LoadSubmodels(lump_t *l, hullinfo_t *hullinfo)
1897 {
1898         unsigned char           *index;
1899         dmodel_t        *out;
1900         int                     i, j, count;
1901
1902         index = (unsigned char *)(mod_base + l->fileofs);
1903         if (l->filelen % (48+4*hullinfo->filehulls))
1904                 Host_Error ("Mod_Q1BSP_LoadSubmodels: funny lump size in %s", loadmodel->name);
1905
1906         count = l->filelen / (48+4*hullinfo->filehulls);
1907         out = (dmodel_t *)Mem_Alloc (loadmodel->mempool, count*sizeof(*out));
1908
1909         loadmodel->brushq1.submodels = out;
1910         loadmodel->brush.numsubmodels = count;
1911
1912         for (i = 0; i < count; i++, out++)
1913         {
1914         // spread out the mins / maxs by a pixel
1915                 out->mins[0] = SB_ReadFloat (&index) - 1;
1916                 out->mins[1] = SB_ReadFloat (&index) - 1;
1917                 out->mins[2] = SB_ReadFloat (&index) - 1;
1918                 out->maxs[0] = SB_ReadFloat (&index) + 1;
1919                 out->maxs[1] = SB_ReadFloat (&index) + 1;
1920                 out->maxs[2] = SB_ReadFloat (&index) + 1;
1921                 out->origin[0] = SB_ReadFloat (&index);
1922                 out->origin[1] = SB_ReadFloat (&index);
1923                 out->origin[2] = SB_ReadFloat (&index);
1924                 for (j = 0; j < hullinfo->filehulls; j++)
1925                         out->headnode[j] = SB_ReadInt (&index);
1926                 out->visleafs = SB_ReadInt (&index);
1927                 out->firstface = SB_ReadInt (&index);
1928                 out->numfaces = SB_ReadInt (&index);
1929         }
1930 }
1931
1932 static void Mod_Q1BSP_LoadEdges(lump_t *l)
1933 {
1934         dedge_t *in;
1935         medge_t *out;
1936         int     i, count;
1937
1938         in = (dedge_t *)(mod_base + l->fileofs);
1939         if (l->filelen % sizeof(*in))
1940                 Host_Error("Mod_Q1BSP_LoadEdges: funny lump size in %s",loadmodel->name);
1941         count = l->filelen / sizeof(*in);
1942         out = (medge_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
1943
1944         loadmodel->brushq1.edges = out;
1945         loadmodel->brushq1.numedges = count;
1946
1947         for ( i=0 ; i<count ; i++, in++, out++)
1948         {
1949                 out->v[0] = (unsigned short)LittleShort(in->v[0]);
1950                 out->v[1] = (unsigned short)LittleShort(in->v[1]);
1951                 if (out->v[0] >= loadmodel->brushq1.numvertexes || out->v[1] >= loadmodel->brushq1.numvertexes)
1952                 {
1953                         Con_Printf("Mod_Q1BSP_LoadEdges: %s has invalid vertex indices in edge %i (vertices %i %i >= numvertices %i)\n", loadmodel->name, i, out->v[0], out->v[1], loadmodel->brushq1.numvertexes);
1954                         out->v[0] = 0;
1955                         out->v[1] = 0;
1956                 }
1957         }
1958 }
1959
1960 static void Mod_Q1BSP_LoadTexinfo(lump_t *l)
1961 {
1962         texinfo_t *in;
1963         mtexinfo_t *out;
1964         int i, j, k, count, miptex;
1965
1966         in = (texinfo_t *)(mod_base + l->fileofs);
1967         if (l->filelen % sizeof(*in))
1968                 Host_Error("Mod_Q1BSP_LoadTexinfo: funny lump size in %s",loadmodel->name);
1969         count = l->filelen / sizeof(*in);
1970         out = (mtexinfo_t *)Mem_Alloc(loadmodel->mempool, count * sizeof(*out));
1971
1972         loadmodel->brushq1.texinfo = out;
1973         loadmodel->brushq1.numtexinfo = count;
1974
1975         for (i = 0;i < count;i++, in++, out++)
1976         {
1977                 for (k = 0;k < 2;k++)
1978                         for (j = 0;j < 4;j++)
1979                                 out->vecs[k][j] = LittleFloat(in->vecs[k][j]);
1980
1981                 miptex = LittleLong(in->miptex);
1982                 out->flags = LittleLong(in->flags);
1983
1984                 out->texture = NULL;
1985                 if (loadmodel->data_textures)
1986                 {
1987                         if ((unsigned int) miptex >= (unsigned int) loadmodel->num_textures)
1988                                 Con_Printf("error in model \"%s\": invalid miptex index %i(of %i)\n", loadmodel->name, miptex, loadmodel->num_textures);
1989                         else
1990                                 out->texture = loadmodel->data_textures + miptex;
1991                 }
1992                 if (out->flags & TEX_SPECIAL)
1993                 {
1994                         // if texture chosen is NULL or the shader needs a lightmap,
1995                         // force to notexture water shader
1996                         if (out->texture == NULL || out->texture->basematerialflags & MATERIALFLAG_WALL)
1997                                 out->texture = loadmodel->data_textures + (loadmodel->num_textures - 1);
1998                 }
1999                 else
2000                 {
2001                         // if texture chosen is NULL, force to notexture
2002                         if (out->texture == NULL)
2003                                 out->texture = loadmodel->data_textures + (loadmodel->num_textures - 2);
2004                 }
2005         }
2006 }
2007
2008 #if 0
2009 void BoundPoly(int numverts, float *verts, vec3_t mins, vec3_t maxs)
2010 {
2011         int             i, j;
2012         float   *v;
2013
2014         mins[0] = mins[1] = mins[2] = 9999;
2015         maxs[0] = maxs[1] = maxs[2] = -9999;
2016         v = verts;
2017         for (i = 0;i < numverts;i++)
2018         {
2019                 for (j = 0;j < 3;j++, v++)
2020                 {
2021                         if (*v < mins[j])
2022                                 mins[j] = *v;
2023                         if (*v > maxs[j])
2024                                 maxs[j] = *v;
2025                 }
2026         }
2027 }
2028
2029 #define MAX_SUBDIVPOLYTRIANGLES 4096
2030 #define MAX_SUBDIVPOLYVERTS(MAX_SUBDIVPOLYTRIANGLES * 3)
2031
2032 static int subdivpolyverts, subdivpolytriangles;
2033 static int subdivpolyindex[MAX_SUBDIVPOLYTRIANGLES][3];
2034 static float subdivpolyvert[MAX_SUBDIVPOLYVERTS][3];
2035
2036 static int subdivpolylookupvert(vec3_t v)
2037 {
2038         int i;
2039         for (i = 0;i < subdivpolyverts;i++)
2040                 if (subdivpolyvert[i][0] == v[0]
2041                  && subdivpolyvert[i][1] == v[1]
2042                  && subdivpolyvert[i][2] == v[2])
2043                         return i;
2044         if (subdivpolyverts >= MAX_SUBDIVPOLYVERTS)
2045                 Host_Error("SubDividePolygon: ran out of vertices in buffer, please increase your r_subdivide_size");
2046         VectorCopy(v, subdivpolyvert[subdivpolyverts]);
2047         return subdivpolyverts++;
2048 }
2049
2050 static void SubdividePolygon(int numverts, float *verts)
2051 {
2052         int             i, i1, i2, i3, f, b, c, p;
2053         vec3_t  mins, maxs, front[256], back[256];
2054         float   m, *pv, *cv, dist[256], frac;
2055
2056         if (numverts > 250)
2057                 Host_Error("SubdividePolygon: ran out of verts in buffer");
2058
2059         BoundPoly(numverts, verts, mins, maxs);
2060
2061         for (i = 0;i < 3;i++)
2062         {
2063                 m = (mins[i] + maxs[i]) * 0.5;
2064                 m = r_subdivide_size.value * floor(m/r_subdivide_size.value + 0.5);
2065                 if (maxs[i] - m < 8)
2066                         continue;
2067                 if (m - mins[i] < 8)
2068                         continue;
2069
2070                 // cut it
2071                 for (cv = verts, c = 0;c < numverts;c++, cv += 3)
2072                         dist[c] = cv[i] - m;
2073
2074                 f = b = 0;
2075                 for (p = numverts - 1, c = 0, pv = verts + p * 3, cv = verts;c < numverts;p = c, c++, pv = cv, cv += 3)
2076                 {
2077                         if (dist[p] >= 0)
2078                         {
2079                                 VectorCopy(pv, front[f]);
2080                                 f++;
2081                         }
2082                         if (dist[p] <= 0)
2083                         {
2084                                 VectorCopy(pv, back[b]);
2085                                 b++;
2086                         }
2087                         if (dist[p] == 0 || dist[c] == 0)
2088                                 continue;
2089                         if ((dist[p] > 0) != (dist[c] > 0) )
2090                         {
2091                                 // clip point
2092                                 frac = dist[p] / (dist[p] - dist[c]);
2093                                 front[f][0] = back[b][0] = pv[0] + frac * (cv[0] - pv[0]);
2094                                 front[f][1] = back[b][1] = pv[1] + frac * (cv[1] - pv[1]);
2095                                 front[f][2] = back[b][2] = pv[2] + frac * (cv[2] - pv[2]);
2096                                 f++;
2097                                 b++;
2098                         }
2099                 }
2100
2101                 SubdividePolygon(f, front[0]);
2102                 SubdividePolygon(b, back[0]);
2103                 return;
2104         }
2105
2106         i1 = subdivpolylookupvert(verts);
2107         i2 = subdivpolylookupvert(verts + 3);
2108         for (i = 2;i < numverts;i++)
2109         {
2110                 if (subdivpolytriangles >= MAX_SUBDIVPOLYTRIANGLES)
2111                 {
2112                         Con_Print("SubdividePolygon: ran out of triangles in buffer, please increase your r_subdivide_size\n");
2113                         return;
2114                 }
2115
2116                 i3 = subdivpolylookupvert(verts + i * 3);
2117                 subdivpolyindex[subdivpolytriangles][0] = i1;
2118                 subdivpolyindex[subdivpolytriangles][1] = i2;
2119                 subdivpolyindex[subdivpolytriangles][2] = i3;
2120                 i2 = i3;
2121                 subdivpolytriangles++;
2122         }
2123 }
2124
2125 //Breaks a polygon up along axial 64 unit
2126 //boundaries so that turbulent and sky warps
2127 //can be done reasonably.
2128 static void Mod_Q1BSP_GenerateWarpMesh(msurface_t *surface)
2129 {
2130         int i, j;
2131         surfvertex_t *v;
2132         surfmesh_t *mesh;
2133
2134         subdivpolytriangles = 0;
2135         subdivpolyverts = 0;
2136         SubdividePolygon(surface->num_vertices, (surface->mesh->data_vertex3f + 3 * surface->num_firstvertex));
2137         if (subdivpolytriangles < 1)
2138                 Host_Error("Mod_Q1BSP_GenerateWarpMesh: no triangles?");
2139
2140         surface->mesh = mesh = Mem_Alloc(loadmodel->mempool, sizeof(surfmesh_t) + subdivpolytriangles * sizeof(int[3]) + subdivpolyverts * sizeof(surfvertex_t));
2141         mesh->num_vertices = subdivpolyverts;
2142         mesh->num_triangles = subdivpolytriangles;
2143         mesh->vertex = (surfvertex_t *)(mesh + 1);
2144         mesh->index = (int *)(mesh->vertex + mesh->num_vertices);
2145         memset(mesh->vertex, 0, mesh->num_vertices * sizeof(surfvertex_t));
2146
2147         for (i = 0;i < mesh->num_triangles;i++)
2148                 for (j = 0;j < 3;j++)
2149                         mesh->index[i*3+j] = subdivpolyindex[i][j];
2150
2151         for (i = 0, v = mesh->vertex;i < subdivpolyverts;i++, v++)
2152         {
2153                 VectorCopy(subdivpolyvert[i], v->v);
2154                 v->st[0] = DotProduct(v->v, surface->lightmapinfo->texinfo->vecs[0]);
2155                 v->st[1] = DotProduct(v->v, surface->lightmapinfo->texinfo->vecs[1]);
2156         }
2157 }
2158 #endif
2159
2160 static qboolean Mod_Q1BSP_AllocLightmapBlock(int *lineused, int totalwidth, int totalheight, int blockwidth, int blockheight, int *outx, int *outy)
2161 {
2162         int y, x2, y2;
2163         int bestx = totalwidth, besty = 0;
2164         // find the left-most space we can find
2165         for (y = 0;y <= totalheight - blockheight;y++)
2166         {
2167                 x2 = 0;
2168                 for (y2 = 0;y2 < blockheight;y2++)
2169                         x2 = max(x2, lineused[y+y2]);
2170                 if (bestx > x2)
2171                 {
2172                         bestx = x2;
2173                         besty = y;
2174                 }
2175         }
2176         // if the best was not good enough, return failure
2177         if (bestx > totalwidth - blockwidth)
2178                 return false;
2179         // we found a good spot
2180         if (outx)
2181                 *outx = bestx;
2182         if (outy)
2183                 *outy = besty;
2184         // now mark the space used
2185         for (y2 = 0;y2 < blockheight;y2++)
2186                 lineused[besty+y2] = bestx + blockwidth;
2187         // return success
2188         return true;
2189 }
2190
2191 static void Mod_Q1BSP_LoadFaces(lump_t *l)
2192 {
2193         dface_t *in;
2194         msurface_t *surface;
2195         int i, j, count, surfacenum, planenum, smax, tmax, ssize, tsize, firstedge, numedges, totalverts, totaltris, lightmapnumber;
2196         float texmins[2], texmaxs[2], val, lightmaptexcoordscale;
2197 #define LIGHTMAPSIZE 256
2198         rtexture_t *lightmaptexture, *deluxemaptexture;
2199         int lightmap_lineused[LIGHTMAPSIZE];
2200
2201         in = (dface_t *)(mod_base + l->fileofs);
2202         if (l->filelen % sizeof(*in))
2203                 Host_Error("Mod_Q1BSP_LoadFaces: funny lump size in %s",loadmodel->name);
2204         count = l->filelen / sizeof(*in);
2205         loadmodel->data_surfaces = (msurface_t *)Mem_Alloc(loadmodel->mempool, count*sizeof(msurface_t));
2206         loadmodel->data_surfaces_lightmapinfo = (msurface_lightmapinfo_t *)Mem_Alloc(loadmodel->mempool, count*sizeof(msurface_lightmapinfo_t));
2207
2208         loadmodel->num_surfaces = count;
2209
2210         totalverts = 0;
2211         totaltris = 0;
2212         for (surfacenum = 0, in = (dface_t *)(mod_base + l->fileofs);surfacenum < count;surfacenum++, in++)
2213         {
2214                 numedges = LittleShort(in->numedges);
2215                 totalverts += numedges;
2216                 totaltris += numedges - 2;
2217         }
2218
2219         Mod_AllocSurfMesh(loadmodel->mempool, totalverts, totaltris, true, false, false);
2220
2221         lightmaptexture = NULL;
2222         deluxemaptexture = r_texture_blanknormalmap;
2223         lightmapnumber = 1;
2224         lightmaptexcoordscale = 1.0f / (float)LIGHTMAPSIZE;
2225
2226         totalverts = 0;
2227         totaltris = 0;
2228         for (surfacenum = 0, in = (dface_t *)(mod_base + l->fileofs), surface = loadmodel->data_surfaces;surfacenum < count;surfacenum++, in++, surface++)
2229         {
2230                 surface->lightmapinfo = loadmodel->data_surfaces_lightmapinfo + surfacenum;
2231
2232                 // FIXME: validate edges, texinfo, etc?
2233                 firstedge = LittleLong(in->firstedge);
2234                 numedges = LittleShort(in->numedges);
2235                 if ((unsigned int) firstedge > (unsigned int) loadmodel->brushq1.numsurfedges || (unsigned int) numedges > (unsigned int) loadmodel->brushq1.numsurfedges || (unsigned int) firstedge + (unsigned int) numedges > (unsigned int) loadmodel->brushq1.numsurfedges)
2236                         Host_Error("Mod_Q1BSP_LoadFaces: invalid edge range (firstedge %i, numedges %i, model edges %i)", firstedge, numedges, loadmodel->brushq1.numsurfedges);
2237                 i = LittleShort(in->texinfo);
2238                 if ((unsigned int) i >= (unsigned int) loadmodel->brushq1.numtexinfo)
2239                         Host_Error("Mod_Q1BSP_LoadFaces: invalid texinfo index %i(model has %i texinfos)", i, loadmodel->brushq1.numtexinfo);
2240                 surface->lightmapinfo->texinfo = loadmodel->brushq1.texinfo + i;
2241                 surface->texture = surface->lightmapinfo->texinfo->texture;
2242
2243                 planenum = LittleShort(in->planenum);
2244                 if ((unsigned int) planenum >= (unsigned int) loadmodel->brush.num_planes)
2245                         Host_Error("Mod_Q1BSP_LoadFaces: invalid plane index %i (model has %i planes)", planenum, loadmodel->brush.num_planes);
2246
2247                 //surface->flags = surface->texture->flags;
2248                 //if (LittleShort(in->side))
2249                 //      surface->flags |= SURF_PLANEBACK;
2250                 //surface->plane = loadmodel->brush.data_planes + planenum;
2251
2252                 surface->num_firstvertex = totalverts;
2253                 surface->num_vertices = numedges;
2254                 surface->num_firsttriangle = totaltris;
2255                 surface->num_triangles = numedges - 2;
2256                 totalverts += numedges;
2257                 totaltris += numedges - 2;
2258
2259                 // convert edges back to a normal polygon
2260                 for (i = 0;i < surface->num_vertices;i++)
2261                 {
2262                         int lindex = loadmodel->brushq1.surfedges[firstedge + i];
2263                         float s, t;
2264                         if (lindex > 0)
2265                                 VectorCopy(loadmodel->brushq1.vertexes[loadmodel->brushq1.edges[lindex].v[0]].position, (loadmodel->surfmesh.data_vertex3f + 3 * surface->num_firstvertex) + i * 3);
2266                         else
2267                                 VectorCopy(loadmodel->brushq1.vertexes[loadmodel->brushq1.edges[-lindex].v[1]].position, (loadmodel->surfmesh.data_vertex3f + 3 * surface->num_firstvertex) + i * 3);
2268                         s = DotProduct(((loadmodel->surfmesh.data_vertex3f + 3 * surface->num_firstvertex) + i * 3), surface->lightmapinfo->texinfo->vecs[0]) + surface->lightmapinfo->texinfo->vecs[0][3];
2269                         t = DotProduct(((loadmodel->surfmesh.data_vertex3f + 3 * surface->num_firstvertex) + i * 3), surface->lightmapinfo->texinfo->vecs[1]) + surface->lightmapinfo->texinfo->vecs[1][3];
2270                         (loadmodel->surfmesh.data_texcoordtexture2f + 2 * surface->num_firstvertex)[i * 2 + 0] = s / surface->texture->width;
2271                         (loadmodel->surfmesh.data_texcoordtexture2f + 2 * surface->num_firstvertex)[i * 2 + 1] = t / surface->texture->height;
2272                         (loadmodel->surfmesh.data_texcoordlightmap2f + 2 * surface->num_firstvertex)[i * 2 + 0] = 0;
2273                         (loadmodel->surfmesh.data_texcoordlightmap2f + 2 * surface->num_firstvertex)[i * 2 + 1] = 0;
2274                         (loadmodel->surfmesh.data_lightmapoffsets + surface->num_firstvertex)[i] = 0;
2275                 }
2276
2277                 for (i = 0;i < surface->num_triangles;i++)
2278                 {
2279                         (loadmodel->surfmesh.data_element3i + 3 * surface->num_firsttriangle)[i * 3 + 0] = 0 + surface->num_firstvertex;
2280                         (loadmodel->surfmesh.data_element3i + 3 * surface->num_firsttriangle)[i * 3 + 1] = i + 1 + surface->num_firstvertex;
2281                         (loadmodel->surfmesh.data_element3i + 3 * surface->num_firsttriangle)[i * 3 + 2] = i + 2 + surface->num_firstvertex;
2282                 }
2283
2284                 // compile additional data about the surface geometry
2285                 Mod_BuildNormals(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, loadmodel->surfmesh.data_vertex3f, (loadmodel->surfmesh.data_element3i + 3 * surface->num_firsttriangle), loadmodel->surfmesh.data_normal3f, true);
2286                 Mod_BuildTextureVectorsFromNormals(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, loadmodel->surfmesh.data_vertex3f, loadmodel->surfmesh.data_texcoordtexture2f, loadmodel->surfmesh.data_normal3f, (loadmodel->surfmesh.data_element3i + 3 * surface->num_firsttriangle), loadmodel->surfmesh.data_svector3f, loadmodel->surfmesh.data_tvector3f, true);
2287                 BoxFromPoints(surface->mins, surface->maxs, surface->num_vertices, (loadmodel->surfmesh.data_vertex3f + 3 * surface->num_firstvertex));
2288
2289                 // generate surface extents information
2290                 texmins[0] = texmaxs[0] = DotProduct((loadmodel->surfmesh.data_vertex3f + 3 * surface->num_firstvertex), surface->lightmapinfo->texinfo->vecs[0]) + surface->lightmapinfo->texinfo->vecs[0][3];
2291                 texmins[1] = texmaxs[1] = DotProduct((loadmodel->surfmesh.data_vertex3f + 3 * surface->num_firstvertex), surface->lightmapinfo->texinfo->vecs[1]) + surface->lightmapinfo->texinfo->vecs[1][3];
2292                 for (i = 1;i < surface->num_vertices;i++)
2293                 {
2294                         for (j = 0;j < 2;j++)
2295                         {
2296                                 val = DotProduct((loadmodel->surfmesh.data_vertex3f + 3 * surface->num_firstvertex) + i * 3, surface->lightmapinfo->texinfo->vecs[j]) + surface->lightmapinfo->texinfo->vecs[j][3];
2297                                 texmins[j] = min(texmins[j], val);
2298                                 texmaxs[j] = max(texmaxs[j], val);
2299                         }
2300                 }
2301                 for (i = 0;i < 2;i++)
2302                 {
2303                         surface->lightmapinfo->texturemins[i] = (int) floor(texmins[i] / 16.0) * 16;
2304                         surface->lightmapinfo->extents[i] = (int) ceil(texmaxs[i] / 16.0) * 16 - surface->lightmapinfo->texturemins[i];
2305                 }
2306
2307                 smax = surface->lightmapinfo->extents[0] >> 4;
2308                 tmax = surface->lightmapinfo->extents[1] >> 4;
2309                 ssize = (surface->lightmapinfo->extents[0] >> 4) + 1;
2310                 tsize = (surface->lightmapinfo->extents[1] >> 4) + 1;
2311
2312                 // lighting info
2313                 for (i = 0;i < MAXLIGHTMAPS;i++)
2314                         surface->lightmapinfo->styles[i] = in->styles[i];
2315                 surface->lightmaptexture = NULL;
2316                 surface->deluxemaptexture = r_texture_blanknormalmap;
2317                 i = LittleLong(in->lightofs);
2318                 if (i == -1)
2319                 {
2320                         surface->lightmapinfo->samples = NULL;
2321                         // give non-lightmapped water a 1x white lightmap
2322                         if ((surface->texture->basematerialflags & MATERIALFLAG_WATER) && (surface->lightmapinfo->texinfo->flags & TEX_SPECIAL) && ssize <= 256 && tsize <= 256)
2323                         {
2324                                 surface->lightmapinfo->samples = (unsigned char *)Mem_Alloc(loadmodel->mempool, ssize * tsize * 3);
2325                                 surface->lightmapinfo->styles[0] = 0;
2326                                 memset(surface->lightmapinfo->samples, 128, ssize * tsize * 3);
2327                         }
2328                 }
2329                 else if (loadmodel->brush.ishlbsp) // LordHavoc: HalfLife map (bsp version 30)
2330                         surface->lightmapinfo->samples = loadmodel->brushq1.lightdata + i;
2331                 else // LordHavoc: white lighting (bsp version 29)
2332                 {
2333                         surface->lightmapinfo->samples = loadmodel->brushq1.lightdata + (i * 3);
2334                         if (loadmodel->brushq1.nmaplightdata)
2335                                 surface->lightmapinfo->nmapsamples = loadmodel->brushq1.nmaplightdata + (i * 3);
2336                 }
2337
2338                 // check if we should apply a lightmap to this
2339                 if (!(surface->lightmapinfo->texinfo->flags & TEX_SPECIAL) || surface->lightmapinfo->samples)
2340                 {
2341                         int i, iu, iv, lightmapx, lightmapy;
2342                         float u, v, ubase, vbase, uscale, vscale;
2343
2344                         if (ssize > 256 || tsize > 256)
2345                                 Host_Error("Bad surface extents");
2346                         // force lightmap upload on first time seeing the surface
2347                         surface->cached_dlight = true;
2348                         // stainmap for permanent marks on walls
2349                         surface->lightmapinfo->stainsamples = (unsigned char *)Mem_Alloc(loadmodel->mempool, ssize * tsize * 3);
2350                         // clear to white
2351                         memset(surface->lightmapinfo->stainsamples, 255, ssize * tsize * 3);
2352
2353                         // find a place for this lightmap
2354                         if (!lightmaptexture || !Mod_Q1BSP_AllocLightmapBlock(lightmap_lineused, LIGHTMAPSIZE, LIGHTMAPSIZE, ssize, tsize, &lightmapx, &lightmapy))
2355                         {
2356                                 // allocate a texture pool if we need it
2357                                 if (loadmodel->texturepool == NULL && cls.state != ca_dedicated)
2358                                         loadmodel->texturepool = R_AllocTexturePool();
2359                                 // could not find room, make a new lightmap
2360                                 lightmaptexture = R_LoadTexture2D(loadmodel->texturepool, va("lightmap%i", lightmapnumber), LIGHTMAPSIZE, LIGHTMAPSIZE, NULL, loadmodel->brushq1.lightmaprgba ? TEXTYPE_RGBA : TEXTYPE_RGB, TEXF_FORCELINEAR | TEXF_PRECACHE, NULL);
2361                                 if (loadmodel->brushq1.nmaplightdata)
2362                                         deluxemaptexture = R_LoadTexture2D(loadmodel->texturepool, va("deluxemap%i", lightmapnumber), LIGHTMAPSIZE, LIGHTMAPSIZE, NULL, loadmodel->brushq1.lightmaprgba ? TEXTYPE_RGBA : TEXTYPE_RGB, TEXF_FORCELINEAR | TEXF_PRECACHE, NULL);
2363                                 lightmapnumber++;
2364                                 memset(lightmap_lineused, 0, sizeof(lightmap_lineused));
2365                                 Mod_Q1BSP_AllocLightmapBlock(lightmap_lineused, LIGHTMAPSIZE, LIGHTMAPSIZE, ssize, tsize, &lightmapx, &lightmapy);
2366                         }
2367
2368                         surface->lightmaptexture = lightmaptexture;
2369                         surface->deluxemaptexture = deluxemaptexture;
2370                         surface->lightmapinfo->lightmaporigin[0] = lightmapx;
2371                         surface->lightmapinfo->lightmaporigin[1] = lightmapy;
2372
2373                         ubase = lightmapx * lightmaptexcoordscale;
2374                         vbase = lightmapy * lightmaptexcoordscale;
2375                         uscale = lightmaptexcoordscale;
2376                         vscale = lightmaptexcoordscale;
2377
2378                         for (i = 0;i < surface->num_vertices;i++)
2379                         {
2380                                 u = ((DotProduct(((loadmodel->surfmesh.data_vertex3f + 3 * surface->num_firstvertex) + i * 3), surface->lightmapinfo->texinfo->vecs[0]) + surface->lightmapinfo->texinfo->vecs[0][3]) + 8 - surface->lightmapinfo->texturemins[0]) * (1.0 / 16.0);
2381                                 v = ((DotProduct(((loadmodel->surfmesh.data_vertex3f + 3 * surface->num_firstvertex) + i * 3), surface->lightmapinfo->texinfo->vecs[1]) + surface->lightmapinfo->texinfo->vecs[1][3]) + 8 - surface->lightmapinfo->texturemins[1]) * (1.0 / 16.0);
2382                                 (loadmodel->surfmesh.data_texcoordlightmap2f + 2 * surface->num_firstvertex)[i * 2 + 0] = u * uscale + ubase;
2383                                 (loadmodel->surfmesh.data_texcoordlightmap2f + 2 * surface->num_firstvertex)[i * 2 + 1] = v * vscale + vbase;
2384                                 // LordHavoc: calc lightmap data offset for vertex lighting to use
2385                                 iu = (int) u;
2386                                 iv = (int) v;
2387                                 (loadmodel->surfmesh.data_lightmapoffsets + surface->num_firstvertex)[i] = (bound(0, iv, tmax) * ssize + bound(0, iu, smax)) * 3;
2388                         }
2389                 }
2390         }
2391 }
2392
2393 static void Mod_Q1BSP_LoadNodes_RecursiveSetParent(mnode_t *node, mnode_t *parent)
2394 {
2395         //if (node->parent)
2396         //      Host_Error("Mod_Q1BSP_LoadNodes_RecursiveSetParent: runaway recursion");
2397         node->parent = parent;
2398         if (node->plane)
2399         {
2400                 // this is a node, recurse to children
2401                 Mod_Q1BSP_LoadNodes_RecursiveSetParent(node->children[0], node);
2402                 Mod_Q1BSP_LoadNodes_RecursiveSetParent(node->children[1], node);
2403                 // combine supercontents of children
2404                 node->combinedsupercontents = node->children[0]->combinedsupercontents | node->children[1]->combinedsupercontents;
2405         }
2406         else
2407         {
2408                 int j;
2409                 mleaf_t *leaf = (mleaf_t *)node;
2410                 // if this is a leaf, calculate supercontents mask from all collidable
2411                 // primitives in the leaf (brushes and collision surfaces)
2412                 // also flag if the leaf contains any collision surfaces
2413                 leaf->combinedsupercontents = 0;
2414                 // combine the supercontents values of all brushes in this leaf
2415                 for (j = 0;j < leaf->numleafbrushes;j++)
2416                         leaf->combinedsupercontents |= loadmodel->brush.data_brushes[leaf->firstleafbrush[j]].texture->supercontents;
2417                 // check if this leaf contains any collision surfaces (q3 patches)
2418                 for (j = 0;j < leaf->numleafsurfaces;j++)
2419                 {
2420                         msurface_t *surface = loadmodel->data_surfaces + leaf->firstleafsurface[j];
2421                         if (surface->num_collisiontriangles)
2422                         {
2423                                 leaf->containscollisionsurfaces = true;
2424                                 leaf->combinedsupercontents |= surface->texture->supercontents;
2425                         }
2426                 }
2427         }
2428 }
2429
2430 static void Mod_Q1BSP_LoadNodes(lump_t *l)
2431 {
2432         int                     i, j, count, p;
2433         dnode_t         *in;
2434         mnode_t         *out;
2435
2436         in = (dnode_t *)(mod_base + l->fileofs);
2437         if (l->filelen % sizeof(*in))
2438                 Host_Error("Mod_Q1BSP_LoadNodes: funny lump size in %s",loadmodel->name);
2439         count = l->filelen / sizeof(*in);
2440         out = (mnode_t *)Mem_Alloc(loadmodel->mempool, count*sizeof(*out));
2441
2442         loadmodel->brush.data_nodes = out;
2443         loadmodel->brush.num_nodes = count;
2444
2445         for ( i=0 ; i<count ; i++, in++, out++)
2446         {
2447                 for (j=0 ; j<3 ; j++)
2448                 {
2449                         out->mins[j] = LittleShort(in->mins[j]);
2450                         out->maxs[j] = LittleShort(in->maxs[j]);
2451                 }
2452
2453                 p = LittleLong(in->planenum);
2454                 out->plane = loadmodel->brush.data_planes + p;
2455
2456                 out->firstsurface = LittleShort(in->firstface);
2457                 out->numsurfaces = LittleShort(in->numfaces);
2458
2459                 for (j=0 ; j<2 ; j++)
2460                 {
2461                         p = LittleShort(in->children[j]);
2462                         if (p >= 0)
2463                                 out->children[j] = loadmodel->brush.data_nodes + p;
2464                         else
2465                                 out->children[j] = (mnode_t *)(loadmodel->brush.data_leafs + (-1 - p));
2466                 }
2467         }
2468
2469         Mod_Q1BSP_LoadNodes_RecursiveSetParent(loadmodel->brush.data_nodes, NULL);      // sets nodes and leafs
2470 }
2471
2472 static void Mod_Q1BSP_LoadLeafs(lump_t *l)
2473 {
2474         dleaf_t *in;
2475         mleaf_t *out;
2476         int i, j, count, p;
2477
2478         in = (dleaf_t *)(mod_base + l->fileofs);
2479         if (l->filelen % sizeof(*in))
2480                 Host_Error("Mod_Q1BSP_LoadLeafs: funny lump size in %s",loadmodel->name);
2481         count = l->filelen / sizeof(*in);
2482         out = (mleaf_t *)Mem_Alloc(loadmodel->mempool, count*sizeof(*out));
2483
2484         loadmodel->brush.data_leafs = out;
2485         loadmodel->brush.num_leafs = count;
2486         // get visleafs from the submodel data
2487         loadmodel->brush.num_pvsclusters = loadmodel->brushq1.submodels[0].visleafs;
2488         loadmodel->brush.num_pvsclusterbytes = (loadmodel->brush.num_pvsclusters+7)>>3;
2489         loadmodel->brush.data_pvsclusters = (unsigned char *)Mem_Alloc(loadmodel->mempool, loadmodel->brush.num_pvsclusters * loadmodel->brush.num_pvsclusterbytes);
2490         memset(loadmodel->brush.data_pvsclusters, 0xFF, loadmodel->brush.num_pvsclusters * loadmodel->brush.num_pvsclusterbytes);
2491
2492         for ( i=0 ; i<count ; i++, in++, out++)
2493         {
2494                 for (j=0 ; j<3 ; j++)
2495                 {
2496                         out->mins[j] = LittleShort(in->mins[j]);
2497                         out->maxs[j] = LittleShort(in->maxs[j]);
2498                 }
2499
2500                 // FIXME: this function could really benefit from some error checking
2501
2502                 out->contents = LittleLong(in->contents);
2503
2504                 out->firstleafsurface = loadmodel->brush.data_leafsurfaces + LittleShort(in->firstmarksurface);
2505                 out->numleafsurfaces = LittleShort(in->nummarksurfaces);
2506                 if (out->firstleafsurface < 0 || LittleShort(in->firstmarksurface) + out->numleafsurfaces > loadmodel->brush.num_leafsurfaces)
2507                 {
2508                         Con_Printf("Mod_Q1BSP_LoadLeafs: invalid leafsurface range %i:%i outside range %i:%i\n", (int)(out->firstleafsurface - loadmodel->brush.data_leafsurfaces), (int)(out->firstleafsurface + out->numleafsurfaces - loadmodel->brush.data_leafsurfaces), 0, loadmodel->brush.num_leafsurfaces);
2509                         out->firstleafsurface = NULL;
2510                         out->numleafsurfaces = 0;
2511                 }
2512
2513                 out->clusterindex = i - 1;
2514                 if (out->clusterindex >= loadmodel->brush.num_pvsclusters)
2515                         out->clusterindex = -1;
2516
2517                 p = LittleLong(in->visofs);
2518                 // ignore visofs errors on leaf 0 (solid)
2519                 if (p >= 0 && out->clusterindex >= 0)
2520                 {
2521                         if (p >= loadmodel->brushq1.num_compressedpvs)
2522                                 Con_Print("Mod_Q1BSP_LoadLeafs: invalid visofs\n");
2523                         else
2524                                 Mod_Q1BSP_DecompressVis(loadmodel->brushq1.data_compressedpvs + p, loadmodel->brushq1.data_compressedpvs + loadmodel->brushq1.num_compressedpvs, loadmodel->brush.data_pvsclusters + out->clusterindex * loadmodel->brush.num_pvsclusterbytes, loadmodel->brush.data_pvsclusters + (out->clusterindex + 1) * loadmodel->brush.num_pvsclusterbytes);
2525                 }
2526
2527                 for (j = 0;j < 4;j++)
2528                         out->ambient_sound_level[j] = in->ambient_level[j];
2529
2530                 // FIXME: Insert caustics here
2531         }
2532 }
2533
2534 qboolean Mod_Q1BSP_CheckWaterAlphaSupport(void)
2535 {
2536         int i, j;
2537         mleaf_t *leaf;
2538         const unsigned char *pvs;
2539         // check all liquid leafs to see if they can see into empty leafs, if any
2540         // can we can assume this map supports r_wateralpha
2541         for (i = 0, leaf = loadmodel->brush.data_leafs;i < loadmodel->brush.num_leafs;i++, leaf++)
2542         {
2543                 if ((leaf->contents == CONTENTS_WATER || leaf->contents == CONTENTS_SLIME) && (leaf->clusterindex >= 0 && loadmodel->brush.data_pvsclusters))
2544                 {
2545                         pvs = loadmodel->brush.data_pvsclusters + leaf->clusterindex * loadmodel->brush.num_pvsclusterbytes;
2546                         for (j = 0;j < loadmodel->brush.num_leafs;j++)
2547                                 if (CHECKPVSBIT(pvs, loadmodel->brush.data_leafs[j].clusterindex) && loadmodel->brush.data_leafs[j].contents == CONTENTS_EMPTY)
2548                                         return true;
2549                 }
2550         }
2551         return false;
2552 }
2553
2554 static void Mod_Q1BSP_LoadClipnodes(lump_t *l, hullinfo_t *hullinfo)
2555 {
2556         dclipnode_t *in, *out;
2557         int                     i, count;
2558         hull_t          *hull;
2559
2560         in = (dclipnode_t *)(mod_base + l->fileofs);
2561         if (l->filelen % sizeof(*in))
2562                 Host_Error("Mod_Q1BSP_LoadClipnodes: funny lump size in %s",loadmodel->name);
2563         count = l->filelen / sizeof(*in);
2564         out = (dclipnode_t *)Mem_Alloc(loadmodel->mempool, count*sizeof(*out));
2565
2566         loadmodel->brushq1.clipnodes = out;
2567         loadmodel->brushq1.numclipnodes = count;
2568
2569         for (i = 1; i < hullinfo->numhulls; i++)
2570         {
2571                 hull = &loadmodel->brushq1.hulls[i];
2572                 hull->clipnodes = out;
2573                 hull->firstclipnode = 0;
2574                 hull->lastclipnode = count-1;
2575                 hull->planes = loadmodel->brush.data_planes;
2576                 hull->clip_mins[0] = hullinfo->hullsizes[i][0][0];
2577                 hull->clip_mins[1] = hullinfo->hullsizes[i][0][1];
2578                 hull->clip_mins[2] = hullinfo->hullsizes[i][0][2];
2579                 hull->clip_maxs[0] = hullinfo->hullsizes[i][1][0];
2580                 hull->clip_maxs[1] = hullinfo->hullsizes[i][1][1];
2581                 hull->clip_maxs[2] = hullinfo->hullsizes[i][1][2];
2582                 VectorSubtract(hull->clip_maxs, hull->clip_mins, hull->clip_size);
2583         }
2584
2585         for (i=0 ; i<count ; i++, out++, in++)
2586         {
2587                 out->planenum = LittleLong(in->planenum);
2588                 out->children[0] = LittleShort(in->children[0]);
2589                 out->children[1] = LittleShort(in->children[1]);
2590                 if (out->planenum < 0 || out->planenum >= loadmodel->brush.num_planes)
2591                         Host_Error("Corrupt clipping hull(out of range planenum)");
2592                 if (out->children[0] >= count || out->children[1] >= count)
2593                         Host_Error("Corrupt clipping hull(out of range child)");
2594         }
2595 }
2596
2597 //Duplicate the drawing hull structure as a clipping hull
2598 static void Mod_Q1BSP_MakeHull0(void)
2599 {
2600         mnode_t         *in;
2601         dclipnode_t *out;
2602         int                     i;
2603         hull_t          *hull;
2604
2605         hull = &loadmodel->brushq1.hulls[0];
2606
2607         in = loadmodel->brush.data_nodes;
2608         out = (dclipnode_t *)Mem_Alloc(loadmodel->mempool, loadmodel->brush.num_nodes * sizeof(dclipnode_t));
2609
2610         hull->clipnodes = out;
2611         hull->firstclipnode = 0;
2612         hull->lastclipnode = loadmodel->brush.num_nodes - 1;
2613         hull->planes = loadmodel->brush.data_planes;
2614
2615         for (i = 0;i < loadmodel->brush.num_nodes;i++, out++, in++)
2616         {
2617                 out->planenum = in->plane - loadmodel->brush.data_planes;
2618                 out->children[0] = in->children[0]->plane ? in->children[0] - loadmodel->brush.data_nodes : ((mleaf_t *)in->children[0])->contents;
2619                 out->children[1] = in->children[1]->plane ? in->children[1] - loadmodel->brush.data_nodes : ((mleaf_t *)in->children[1])->contents;
2620         }
2621 }
2622
2623 static void Mod_Q1BSP_LoadLeaffaces(lump_t *l)
2624 {
2625         int i, j;
2626         short *in;
2627
2628         in = (short *)(mod_base + l->fileofs);
2629         if (l->filelen % sizeof(*in))
2630                 Host_Error("Mod_Q1BSP_LoadLeaffaces: funny lump size in %s",loadmodel->name);
2631         loadmodel->brush.num_leafsurfaces = l->filelen / sizeof(*in);
2632         loadmodel->brush.data_leafsurfaces = (int *)Mem_Alloc(loadmodel->mempool, loadmodel->brush.num_leafsurfaces * sizeof(int));
2633
2634         for (i = 0;i < loadmodel->brush.num_leafsurfaces;i++)
2635         {
2636                 j = (unsigned) LittleShort(in[i]);
2637                 if (j >= loadmodel->num_surfaces)
2638                         Host_Error("Mod_Q1BSP_LoadLeaffaces: bad surface number");
2639                 loadmodel->brush.data_leafsurfaces[i] = j;
2640         }
2641 }
2642
2643 static void Mod_Q1BSP_LoadSurfedges(lump_t *l)
2644 {
2645         int             i;
2646         int             *in;
2647
2648         in = (int *)(mod_base + l->fileofs);
2649         if (l->filelen % sizeof(*in))
2650                 Host_Error("Mod_Q1BSP_LoadSurfedges: funny lump size in %s",loadmodel->name);
2651         loadmodel->brushq1.numsurfedges = l->filelen / sizeof(*in);
2652         loadmodel->brushq1.surfedges = (int *)Mem_Alloc(loadmodel->mempool, loadmodel->brushq1.numsurfedges * sizeof(int));
2653
2654         for (i = 0;i < loadmodel->brushq1.numsurfedges;i++)
2655                 loadmodel->brushq1.surfedges[i] = LittleLong(in[i]);
2656 }
2657
2658
2659 static void Mod_Q1BSP_LoadPlanes(lump_t *l)
2660 {
2661         int                     i;
2662         mplane_t        *out;
2663         dplane_t        *in;
2664
2665         in = (dplane_t *)(mod_base + l->fileofs);
2666         if (l->filelen % sizeof(*in))
2667                 Host_Error("Mod_Q1BSP_LoadPlanes: funny lump size in %s", loadmodel->name);
2668
2669         loadmodel->brush.num_planes = l->filelen / sizeof(*in);
2670         loadmodel->brush.data_planes = out = (mplane_t *)Mem_Alloc(loadmodel->mempool, loadmodel->brush.num_planes * sizeof(*out));
2671
2672         for (i = 0;i < loadmodel->brush.num_planes;i++, in++, out++)
2673         {
2674                 out->normal[0] = LittleFloat(in->normal[0]);
2675                 out->normal[1] = LittleFloat(in->normal[1]);
2676                 out->normal[2] = LittleFloat(in->normal[2]);
2677                 out->dist = LittleFloat(in->dist);
2678
2679                 PlaneClassify(out);
2680         }
2681 }
2682
2683 static void Mod_Q1BSP_LoadMapBrushes(void)
2684 {
2685 #if 0
2686 // unfinished
2687         int submodel, numbrushes;
2688         qboolean firstbrush;
2689         char *text, *maptext;
2690         char mapfilename[MAX_QPATH];
2691         FS_StripExtension (loadmodel->name, mapfilename, sizeof (mapfilename));
2692         strlcat (mapfilename, ".map", sizeof (mapfilename));
2693         maptext = (unsigned char*) FS_LoadFile(mapfilename, tempmempool, false, NULL);
2694         if (!maptext)
2695                 return;
2696         text = maptext;
2697         if (!COM_ParseToken_Simple(&data, false))
2698                 return; // error
2699         submodel = 0;
2700         for (;;)
2701         {
2702                 if (!COM_ParseToken_Simple(&data, false))
2703                         break;
2704                 if (com_token[0] != '{')
2705                         return; // error
2706                 // entity
2707                 firstbrush = true;
2708                 numbrushes = 0;
2709                 maxbrushes = 256;
2710                 brushes = Mem_Alloc(loadmodel->mempool, maxbrushes * sizeof(mbrush_t));
2711                 for (;;)
2712                 {
2713                         if (!COM_ParseToken_Simple(&data, false))
2714                                 return; // error
2715                         if (com_token[0] == '}')
2716                                 break; // end of entity
2717                         if (com_token[0] == '{')
2718                         {
2719                                 // brush
2720                                 if (firstbrush)
2721                                 {
2722                                         if (submodel)
2723                                         {
2724                                                 if (submodel > loadmodel->brush.numsubmodels)
2725                                                 {
2726                                                         Con_Printf("Mod_Q1BSP_LoadMapBrushes: .map has more submodels than .bsp!\n");
2727                                                         model = NULL;
2728                                                 }
2729                                                 else
2730                                                         model = loadmodel->brush.submodels[submodel];
2731                                         }
2732                                         else
2733                                                 model = loadmodel;
2734                                 }
2735                                 for (;;)
2736                                 {
2737                                         if (!COM_ParseToken_Simple(&data, false))
2738                                                 return; // error
2739                                         if (com_token[0] == '}')
2740                                                 break; // end of brush
2741                                         // each brush face should be this format:
2742                                         // ( x y z ) ( x y z ) ( x y z ) texture scroll_s scroll_t rotateangle scale_s scale_t
2743                                         // FIXME: support hl .map format
2744                                         for (pointnum = 0;pointnum < 3;pointnum++)
2745                                         {
2746                                                 COM_ParseToken_Simple(&data, false);
2747                                                 for (componentnum = 0;componentnum < 3;componentnum++)
2748                                                 {
2749                                                         COM_ParseToken_Simple(&data, false);
2750                                                         point[pointnum][componentnum] = atof(com_token);
2751                                                 }
2752                                                 COM_ParseToken_Simple(&data, false);
2753                                         }
2754                                         COM_ParseToken_Simple(&data, false);
2755                                         strlcpy(facetexture, com_token, sizeof(facetexture));
2756                                         COM_ParseToken_Simple(&data, false);
2757                                         //scroll_s = atof(com_token);
2758                                         COM_ParseToken_Simple(&data, false);
2759                                         //scroll_t = atof(com_token);
2760                                         COM_ParseToken_Simple(&data, false);
2761                                         //rotate = atof(com_token);
2762                                         COM_ParseToken_Simple(&data, false);
2763                                         //scale_s = atof(com_token);
2764                                         COM_ParseToken_Simple(&data, false);
2765                                         //scale_t = atof(com_token);
2766                                         TriangleNormal(point[0], point[1], point[2], planenormal);
2767                                         VectorNormalizeDouble(planenormal);
2768                                         planedist = DotProduct(point[0], planenormal);
2769                                         //ChooseTexturePlane(planenormal, texturevector[0], texturevector[1]);
2770                                 }
2771                                 continue;
2772                         }
2773                 }
2774         }
2775 #endif
2776 }
2777
2778
2779 #define MAX_PORTALPOINTS 64
2780
2781 typedef struct portal_s
2782 {
2783         mplane_t plane;
2784         mnode_t *nodes[2];              // [0] = front side of plane
2785         struct portal_s *next[2];
2786         int numpoints;
2787         double points[3*MAX_PORTALPOINTS];
2788         struct portal_s *chain; // all portals are linked into a list
2789 }
2790 portal_t;
2791
2792 static portal_t *portalchain;
2793
2794 /*
2795 ===========
2796 AllocPortal
2797 ===========
2798 */
2799 static portal_t *AllocPortal(void)
2800 {
2801         portal_t *p;
2802         p = (portal_t *)Mem_Alloc(loadmodel->mempool, sizeof(portal_t));
2803         p->chain = portalchain;
2804         portalchain = p;
2805         return p;
2806 }
2807
2808 static void FreePortal(portal_t *p)
2809 {
2810         Mem_Free(p);
2811 }
2812
2813 static void Mod_Q1BSP_RecursiveRecalcNodeBBox(mnode_t *node)
2814 {
2815         // process only nodes (leafs already had their box calculated)
2816         if (!node->plane)
2817                 return;
2818
2819         // calculate children first
2820         Mod_Q1BSP_RecursiveRecalcNodeBBox(node->children[0]);
2821         Mod_Q1BSP_RecursiveRecalcNodeBBox(node->children[1]);
2822
2823         // make combined bounding box from children
2824         node->mins[0] = min(node->children[0]->mins[0], node->children[1]->mins[0]);
2825         node->mins[1] = min(node->children[0]->mins[1], node->children[1]->mins[1]);
2826         node->mins[2] = min(node->children[0]->mins[2], node->children[1]->mins[2]);
2827         node->maxs[0] = max(node->children[0]->maxs[0], node->children[1]->maxs[0]);
2828         node->maxs[1] = max(node->children[0]->maxs[1], node->children[1]->maxs[1]);
2829         node->maxs[2] = max(node->children[0]->maxs[2], node->children[1]->maxs[2]);
2830 }
2831
2832 static void Mod_Q1BSP_FinalizePortals(void)
2833 {
2834         int i, j, numportals, numpoints;
2835         portal_t *p, *pnext;
2836         mportal_t *portal;
2837         mvertex_t *point;
2838         mleaf_t *leaf, *endleaf;
2839
2840         // tally up portal and point counts and recalculate bounding boxes for all
2841         // leafs (because qbsp is very sloppy)
2842         leaf = loadmodel->brush.data_leafs;
2843         endleaf = leaf + loadmodel->brush.num_leafs;
2844         for (;leaf < endleaf;leaf++)
2845         {
2846                 VectorSet(leaf->mins,  2000000000,  2000000000,  2000000000);
2847                 VectorSet(leaf->maxs, -2000000000, -2000000000, -2000000000);
2848         }
2849         p = portalchain;
2850         numportals = 0;
2851         numpoints = 0;
2852         while (p)
2853         {
2854                 // note: this check must match the one below or it will usually corrupt memory
2855                 // the nodes[0] != nodes[1] check is because leaf 0 is the shared solid leaf, it can have many portals inside with leaf 0 on both sides
2856                 if (p->numpoints >= 3 && p->nodes[0] != p->nodes[1] && ((mleaf_t *)p->nodes[0])->clusterindex >= 0 && ((mleaf_t *)p->nodes[1])->clusterindex >= 0)
2857                 {
2858                         numportals += 2;
2859                         numpoints += p->numpoints * 2;
2860                 }
2861                 p = p->chain;
2862         }
2863         loadmodel->brush.data_portals = (mportal_t *)Mem_Alloc(loadmodel->mempool, numportals * sizeof(mportal_t) + numpoints * sizeof(mvertex_t));
2864         loadmodel->brush.num_portals = numportals;
2865         loadmodel->brush.data_portalpoints = (mvertex_t *)((unsigned char *) loadmodel->brush.data_portals + numportals * sizeof(mportal_t));
2866         loadmodel->brush.num_portalpoints = numpoints;
2867         // clear all leaf portal chains
2868         for (i = 0;i < loadmodel->brush.num_leafs;i++)
2869                 loadmodel->brush.data_leafs[i].portals = NULL;
2870         // process all portals in the global portal chain, while freeing them
2871         portal = loadmodel->brush.data_portals;
2872         point = loadmodel->brush.data_portalpoints;
2873         p = portalchain;
2874         portalchain = NULL;
2875         while (p)
2876         {
2877                 pnext = p->chain;
2878
2879                 if (p->numpoints >= 3 && p->nodes[0] != p->nodes[1])
2880                 {
2881                         // note: this check must match the one above or it will usually corrupt memory
2882                         // the nodes[0] != nodes[1] check is because leaf 0 is the shared solid leaf, it can have many portals inside with leaf 0 on both sides
2883                         if (((mleaf_t *)p->nodes[0])->clusterindex >= 0 && ((mleaf_t *)p->nodes[1])->clusterindex >= 0)
2884                         {
2885                                 // first make the back to front portal(forward portal)
2886                                 portal->points = point;
2887                                 portal->numpoints = p->numpoints;
2888                                 portal->plane.dist = p->plane.dist;
2889                                 VectorCopy(p->plane.normal, portal->plane.normal);
2890                                 portal->here = (mleaf_t *)p->nodes[1];
2891                                 portal->past = (mleaf_t *)p->nodes[0];
2892                                 // copy points
2893                                 for (j = 0;j < portal->numpoints;j++)
2894                                 {
2895                                         VectorCopy(p->points + j*3, point->position);
2896                                         point++;
2897                                 }
2898                                 BoxFromPoints(portal->mins, portal->maxs, portal->numpoints, portal->points->position);
2899                                 PlaneClassify(&portal->plane);
2900
2901                                 // link into leaf's portal chain
2902                                 portal->next = portal->here->portals;
2903                                 portal->here->portals = portal;
2904
2905                                 // advance to next portal
2906                                 portal++;
2907
2908                                 // then make the front to back portal(backward portal)
2909                                 portal->points = point;
2910                                 portal->numpoints = p->numpoints;
2911                                 portal->plane.dist = -p->plane.dist;
2912                                 VectorNegate(p->plane.normal, portal->plane.normal);
2913                                 portal->here = (mleaf_t *)p->nodes[0];
2914                                 portal->past = (mleaf_t *)p->nodes[1];
2915                                 // copy points
2916                                 for (j = portal->numpoints - 1;j >= 0;j--)
2917                                 {
2918                                         VectorCopy(p->points + j*3, point->position);