Linux GLX, a lot of code shrinkage/cleanup, assembly support.
[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
23 byte    mod_novis[MAX_MAP_LEAFS/8];
24
25 qboolean        hlbsp; // LordHavoc: true if it is a HalfLife BSP file (version 30)
26
27 cvar_t gl_subdivide_size = {"gl_subdivide_size", "128", true};
28 cvar_t halflifebsp = {"halflifebsp", "0"};
29
30 /*
31 ===============
32 Mod_BrushInit
33 ===============
34 */
35 void Mod_BrushInit (void)
36 {
37         Cvar_RegisterVariable (&gl_subdivide_size);
38         Cvar_RegisterVariable (&halflifebsp);
39         memset (mod_novis, 0xff, sizeof(mod_novis));
40 }
41
42 // Mod_PointInLeaf moved to cpu_noasm.c
43
44 /*
45 ===================
46 Mod_DecompressVis
47 ===================
48 */
49 byte *Mod_DecompressVis (byte *in, model_t *model)
50 {
51         static byte     decompressed[MAX_MAP_LEAFS/8];
52         int             c;
53         byte    *out;
54         int             row;
55
56         row = (model->numleafs+7)>>3;   
57         out = decompressed;
58
59         if (!in)
60         {       // no vis info, so make all visible
61                 while (row)
62                 {
63                         *out++ = 0xff;
64                         row--;
65                 }
66                 return decompressed;            
67         }
68
69         do
70         {
71                 if (*in)
72                 {
73                         *out++ = *in++;
74                         continue;
75                 }
76         
77                 c = in[1];
78                 in += 2;
79                 while (c)
80                 {
81                         *out++ = 0;
82                         c--;
83                 }
84         } while (out - decompressed < row);
85         
86         return decompressed;
87 }
88
89 byte *Mod_LeafPVS (mleaf_t *leaf, model_t *model)
90 {
91         if (leaf == model->leafs)
92                 return mod_novis;
93         return Mod_DecompressVis (leaf->compressed_vis, model);
94 }
95
96 extern byte     *mod_base;
97
98 extern cvar_t r_fullbrights;
99
100 /*
101 =================
102 Mod_LoadTextures
103 =================
104 */
105 void Mod_LoadTextures (lump_t *l)
106 {
107         int             i, j, num, max, altmax, bytesperpixel, freeimage, transparent, fullbrights;
108         miptex_t        *mt;
109         texture_t       *tx, *tx2;
110         texture_t       *anims[10];
111         texture_t       *altanims[10];
112         dmiptexlump_t *m;
113         byte *data;
114
115         if (!l->filelen)
116         {
117                 loadmodel->textures = NULL;
118                 return;
119         }
120
121         m = (dmiptexlump_t *)(mod_base + l->fileofs);
122         
123         m->nummiptex = LittleLong (m->nummiptex);
124         
125         loadmodel->numtextures = m->nummiptex;
126         loadmodel->textures = Hunk_AllocName (m->nummiptex * sizeof(*loadmodel->textures) , loadname);
127
128         for (i=0 ; i<m->nummiptex ; i++)
129         {
130                 m->dataofs[i] = LittleLong(m->dataofs[i]);
131                 if (m->dataofs[i] == -1)
132                         continue;
133                 mt = (miptex_t *)((byte *)m + m->dataofs[i]);
134                 mt->width = LittleLong (mt->width);
135                 mt->height = LittleLong (mt->height);
136                 for (j=0 ; j<MIPLEVELS ; j++)
137                         mt->offsets[j] = LittleLong (mt->offsets[j]);
138                 
139                 if ( (mt->width & 15) || (mt->height & 15) )
140                         Host_Error ("Texture %s is not 16 aligned", mt->name);
141                 // LordHavoc: rewriting the map texture loader for GLQuake
142                 tx = Hunk_AllocName (sizeof(texture_t), loadname );
143                 loadmodel->textures[i] = tx;
144
145                 memcpy (tx->name, mt->name, sizeof(tx->name));
146                 tx->width = mt->width;
147                 tx->height = mt->height;
148                 for (j=0 ; j<MIPLEVELS ; j++)
149                         tx->offsets[j] = 0;
150                 freeimage = TRUE;
151                 bytesperpixel = 4;
152                 fullbrights = FALSE;
153                 transparent = TRUE;
154                 data = loadimagepixels(mt->name, FALSE, 0, 0); //tx->width, tx->height);
155                 if (!data) // no external texture found
156                 {
157                         freeimage = FALSE;
158                         transparent = FALSE;
159                         bytesperpixel = 1;
160                         if (!hlbsp && mt->offsets[0]) // texture included
161                         {
162                                 data = (byte *)((int) mt + mt->offsets[0]);
163                                 if (r_fullbrights.value && mt->name[0] != '*')
164                                 {
165                                         for (j = 0;j < tx->width*tx->height;j++)
166                                                 if (data[j] >= 224) // fullbright
167                                                 {
168                                                         fullbrights = TRUE;
169                                                         break;
170                                                 }
171                                 }
172                         }
173                         else // no texture, and no external replacement texture was found
174                         {
175                                 tx->width = tx->height = 16;
176                                 data = (byte *)((int) r_notexture_mip + r_notexture_mip->offsets[0]);
177                         }
178                 }
179                 else
180                 {
181                         tx->width = image_width;
182                         tx->height = image_height;
183                 }
184                 if (!hlbsp && !strncmp(mt->name,"sky",3) && tx->width == 256 && tx->height == 128) // LordHavoc: HL sky textures are entirely unrelated
185                 {
186                         tx->transparent = FALSE;
187                         R_InitSky (data, bytesperpixel);
188                 }
189                 else
190                 {
191                         tx->transparent = transparent;
192                         if (fullbrights)
193                         {
194                                 char name[64];
195                                 byte *data2;
196                                 data2 = malloc(tx->width*tx->height);
197                                 for (j = 0;j < tx->width*tx->height;j++)
198                                         data2[j] = data[j] >= 224 ? 0 : data[j]; // no fullbrights
199                                 tx->gl_texturenum = GL_LoadTexture (tx->name, tx->width, tx->height, data2, true, transparent, 1);
200                                 strcpy(name, tx->name);
201                                 strcat(name, "_glow");
202                                 for (j = 0;j < tx->width*tx->height;j++)
203                                         data2[j] = data[j] >= 224 ? data[j] : 0; // only fullbrights
204                                 tx->gl_glowtexturenum = GL_LoadTexture (name, tx->width, tx->height, data2, true, transparent, 1);
205                                 free(data2);
206                         }
207                         else
208                         {
209                                 tx->gl_texturenum = GL_LoadTexture (tx->name, tx->width, tx->height, data, true, transparent, bytesperpixel);
210                                 tx->gl_glowtexturenum = 0;
211                         }
212                 }
213                 if (freeimage)
214                         free(data);
215
216                 /*
217                 pixels = mt->width*mt->height/64*85;
218                 tx = Hunk_AllocName (sizeof(texture_t) +pixels, loadname );
219                 loadmodel->textures[i] = tx;
220
221                 memcpy (tx->name, mt->name, sizeof(tx->name));
222                 tx->width = mt->width;
223                 tx->height = mt->height;
224                 for (j=0 ; j<MIPLEVELS ; j++)
225                         tx->offsets[j] = mt->offsets[j] + sizeof(texture_t) - sizeof(miptex_t);
226                 // the pixels immediately follow the structures
227                 memcpy ( tx+1, mt+1, pixels);
228                 
229
230                 if (!strncmp(mt->name,"sky",3)) 
231                         R_InitSky (tx);
232                 else
233                         tx->gl_texturenum = GL_LoadTexture (mt->name, tx->width, tx->height, (byte *)(tx+1), true, false, 1);
234                 */
235         }
236
237 //
238 // sequence the animations
239 //
240         for (i=0 ; i<m->nummiptex ; i++)
241         {
242                 tx = loadmodel->textures[i];
243                 if (!tx || tx->name[0] != '+')
244                         continue;
245                 if (tx->anim_next)
246                         continue;       // allready sequenced
247
248         // find the number of frames in the animation
249                 memset (anims, 0, sizeof(anims));
250                 memset (altanims, 0, sizeof(altanims));
251
252                 max = tx->name[1];
253                 altmax = 0;
254                 if (max >= 'a' && max <= 'z')
255                         max -= 'a' - 'A';
256                 if (max >= '0' && max <= '9')
257                 {
258                         max -= '0';
259                         altmax = 0;
260                         anims[max] = tx;
261                         max++;
262                 }
263                 else if (max >= 'A' && max <= 'J')
264                 {
265                         altmax = max - 'A';
266                         max = 0;
267                         altanims[altmax] = tx;
268                         altmax++;
269                 }
270                 else
271                         Host_Error ("Bad animating texture %s", tx->name);
272
273                 for (j=i+1 ; j<m->nummiptex ; j++)
274                 {
275                         tx2 = loadmodel->textures[j];
276                         if (!tx2 || tx2->name[0] != '+')
277                                 continue;
278                         if (strcmp (tx2->name+2, tx->name+2))
279                                 continue;
280
281                         num = tx2->name[1];
282                         if (num >= 'a' && num <= 'z')
283                                 num -= 'a' - 'A';
284                         if (num >= '0' && num <= '9')
285                         {
286                                 num -= '0';
287                                 anims[num] = tx2;
288                                 if (num+1 > max)
289                                         max = num + 1;
290                         }
291                         else if (num >= 'A' && num <= 'J')
292                         {
293                                 num = num - 'A';
294                                 altanims[num] = tx2;
295                                 if (num+1 > altmax)
296                                         altmax = num+1;
297                         }
298                         else
299                                 Host_Error ("Bad animating texture %s", tx->name);
300                 }
301                 
302 #define ANIM_CYCLE      2
303         // link them all together
304                 for (j=0 ; j<max ; j++)
305                 {
306                         tx2 = anims[j];
307                         if (!tx2)
308                                 Host_Error ("Missing frame %i of %s",j, tx->name);
309                         tx2->anim_total = max * ANIM_CYCLE;
310                         tx2->anim_min = j * ANIM_CYCLE;
311                         tx2->anim_max = (j+1) * ANIM_CYCLE;
312                         tx2->anim_next = anims[ (j+1)%max ];
313                         if (altmax)
314                                 tx2->alternate_anims = altanims[0];
315                 }
316                 for (j=0 ; j<altmax ; j++)
317                 {
318                         tx2 = altanims[j];
319                         if (!tx2)
320                                 Host_Error ("Missing frame %i of %s",j, tx->name);
321                         tx2->anim_total = altmax * ANIM_CYCLE;
322                         tx2->anim_min = j * ANIM_CYCLE;
323                         tx2->anim_max = (j+1) * ANIM_CYCLE;
324                         tx2->anim_next = altanims[ (j+1)%altmax ];
325                         if (max)
326                                 tx2->alternate_anims = anims[0];
327                 }
328         }
329 }
330
331 /*
332 =================
333 Mod_LoadLighting
334 =================
335 */
336 void Mod_LoadLighting (lump_t *l)
337 {
338         int i;
339         byte *in, *out, *data;
340         byte d;
341         char litfilename[1024];
342         loadmodel->lightdata = NULL;
343         if (!l->filelen)
344                 return;
345         if (hlbsp) // LordHavoc: load the colored lighting data straight
346         {
347                 loadmodel->lightdata = Hunk_AllocName ( l->filelen, loadname);
348                 memcpy (loadmodel->lightdata, mod_base + l->fileofs, l->filelen);
349         }
350         else // LordHavoc: bsp version 29 (normal white lighting)
351         {
352                 // LordHavoc: hope is not lost yet, check for a .lit file to load
353                 strcpy(litfilename, loadmodel->name);
354                 COM_StripExtension(litfilename, litfilename);
355                 strcat(litfilename, ".lit");
356                 data = (byte*) COM_LoadHunkFile (litfilename, false);
357                 if (data)
358                 {
359                         if (data[0] == 'Q' && data[1] == 'L' && data[2] == 'I' && data[3] == 'T')
360                         {
361                                 i = LittleLong(((int *)data)[1]);
362                                 if (i == 1)
363                                 {
364                                         loadmodel->lightdata = data + 8;
365                                         return;
366                                 }
367                                 else
368                                         Con_Printf("Unknown .lit file version (%d)\n", i);
369                         }
370                         else
371                                 Con_Printf("Corrupt .lit file (old version?), ignoring\n");
372                 }
373                 // LordHavoc: oh well, expand the white lighting data
374                 loadmodel->lightdata = Hunk_AllocName ( l->filelen*3, litfilename);
375                 in = loadmodel->lightdata + l->filelen*2; // place the file at the end, so it will not be overwritten until the very last write
376                 out = loadmodel->lightdata;
377                 memcpy (in, mod_base + l->fileofs, l->filelen);
378                 for (i = 0;i < l->filelen;i++)
379                 {
380                         d = *in++;
381                         *out++ = d;
382                         *out++ = d;
383                         *out++ = d;
384                 }
385         }
386 }
387
388
389 /*
390 =================
391 Mod_LoadVisibility
392 =================
393 */
394 void Mod_LoadVisibility (lump_t *l)
395 {
396         if (!l->filelen)
397         {
398                 loadmodel->visdata = NULL;
399                 return;
400         }
401         loadmodel->visdata = Hunk_AllocName ( l->filelen, loadname);    
402         memcpy (loadmodel->visdata, mod_base + l->fileofs, l->filelen);
403 }
404
405 void CL_ParseEntityLump(char *entdata);
406
407 extern qboolean isworldmodel;
408
409 /*
410 =================
411 Mod_LoadEntities
412 =================
413 */
414 void Mod_LoadEntities (lump_t *l)
415 {
416         if (!l->filelen)
417         {
418                 loadmodel->entities = NULL;
419                 return;
420         }
421         loadmodel->entities = Hunk_AllocName ( l->filelen, loadname);   
422         memcpy (loadmodel->entities, mod_base + l->fileofs, l->filelen);
423
424         if (isworldmodel)
425                 CL_ParseEntityLump(loadmodel->entities);
426 }
427
428
429 /*
430 =================
431 Mod_LoadVertexes
432 =================
433 */
434 void Mod_LoadVertexes (lump_t *l)
435 {
436         dvertex_t       *in;
437         mvertex_t       *out;
438         int                     i, count;
439
440         in = (void *)(mod_base + l->fileofs);
441         if (l->filelen % sizeof(*in))
442                 Host_Error ("MOD_LoadBmodel: funny lump size in %s",loadmodel->name);
443         count = l->filelen / sizeof(*in);
444         out = Hunk_AllocName ( count*sizeof(*out), loadname);   
445
446         loadmodel->vertexes = out;
447         loadmodel->numvertexes = count;
448
449         for ( i=0 ; i<count ; i++, in++, out++)
450         {
451                 out->position[0] = LittleFloat (in->point[0]);
452                 out->position[1] = LittleFloat (in->point[1]);
453                 out->position[2] = LittleFloat (in->point[2]);
454         }
455 }
456
457 /*
458 =================
459 Mod_LoadSubmodels
460 =================
461 */
462 void Mod_LoadSubmodels (lump_t *l)
463 {
464         dmodel_t        *in;
465         dmodel_t        *out;
466         int                     i, j, count;
467
468         in = (void *)(mod_base + l->fileofs);
469         if (l->filelen % sizeof(*in))
470                 Host_Error ("MOD_LoadBmodel: funny lump size in %s",loadmodel->name);
471         count = l->filelen / sizeof(*in);
472         out = Hunk_AllocName ( count*sizeof(*out), loadname);   
473
474         loadmodel->submodels = out;
475         loadmodel->numsubmodels = count;
476
477         for ( i=0 ; i<count ; i++, in++, out++)
478         {
479                 for (j=0 ; j<3 ; j++)
480                 {       // spread the mins / maxs by a pixel
481                         out->mins[j] = LittleFloat (in->mins[j]) - 1;
482                         out->maxs[j] = LittleFloat (in->maxs[j]) + 1;
483                         out->origin[j] = LittleFloat (in->origin[j]);
484                 }
485                 for (j=0 ; j<MAX_MAP_HULLS ; j++)
486                         out->headnode[j] = LittleLong (in->headnode[j]);
487                 out->visleafs = LittleLong (in->visleafs);
488                 out->firstface = LittleLong (in->firstface);
489                 out->numfaces = LittleLong (in->numfaces);
490         }
491 }
492
493 /*
494 =================
495 Mod_LoadEdges
496 =================
497 */
498 void Mod_LoadEdges (lump_t *l)
499 {
500         dedge_t *in;
501         medge_t *out;
502         int     i, count;
503
504         in = (void *)(mod_base + l->fileofs);
505         if (l->filelen % sizeof(*in))
506                 Host_Error ("MOD_LoadBmodel: funny lump size in %s",loadmodel->name);
507         count = l->filelen / sizeof(*in);
508         out = Hunk_AllocName ( (count + 1) * sizeof(*out), loadname);   
509
510         loadmodel->edges = out;
511         loadmodel->numedges = count;
512
513         for ( i=0 ; i<count ; i++, in++, out++)
514         {
515                 out->v[0] = (unsigned short)LittleShort(in->v[0]);
516                 out->v[1] = (unsigned short)LittleShort(in->v[1]);
517         }
518 }
519
520 /*
521 =================
522 Mod_LoadTexinfo
523 =================
524 */
525 void Mod_LoadTexinfo (lump_t *l)
526 {
527         texinfo_t *in;
528         mtexinfo_t *out;
529         int     i, j, count;
530         int             miptex;
531         float   len1, len2;
532
533         in = (void *)(mod_base + l->fileofs);
534         if (l->filelen % sizeof(*in))
535                 Host_Error ("MOD_LoadBmodel: funny lump size in %s",loadmodel->name);
536         count = l->filelen / sizeof(*in);
537         out = Hunk_AllocName ( count*sizeof(*out), loadname);   
538
539         loadmodel->texinfo = out;
540         loadmodel->numtexinfo = count;
541
542         for ( i=0 ; i<count ; i++, in++, out++)
543         {
544                 for (j=0 ; j<8 ; j++)
545                         out->vecs[0][j] = LittleFloat (in->vecs[0][j]);
546                 len1 = Length (out->vecs[0]);
547                 len2 = Length (out->vecs[1]);
548                 len1 = (len1 + len2)/2;
549                 if (len1 < 0.32)
550                         out->mipadjust = 4;
551                 else if (len1 < 0.49)
552                         out->mipadjust = 3;
553                 else if (len1 < 0.99)
554                         out->mipadjust = 2;
555                 else
556                         out->mipadjust = 1;
557 #if 0
558                 if (len1 + len2 < 0.001)
559                         out->mipadjust = 1;             // don't crash
560                 else
561                         out->mipadjust = 1 / floor( (len1+len2)/2 + 0.1 );
562 #endif
563
564                 miptex = LittleLong (in->miptex);
565                 out->flags = LittleLong (in->flags);
566         
567                 if (!loadmodel->textures)
568                 {
569                         out->texture = r_notexture_mip; // checkerboard texture
570                         out->flags = 0;
571                         out->texture->transparent = FALSE;
572                 }
573                 else
574                 {
575                         if (miptex >= loadmodel->numtextures)
576                                 Host_Error ("miptex >= loadmodel->numtextures");
577                         out->texture = loadmodel->textures[miptex];
578                         if (!out->texture)
579                         {
580                                 out->texture = r_notexture_mip; // texture not found
581                                 out->flags = 0;
582                                 out->texture->transparent = FALSE;
583                         }
584                 }
585         }
586 }
587
588 /*
589 ================
590 CalcSurfaceExtents
591
592 Fills in s->texturemins[] and s->extents[]
593 ================
594 */
595 void CalcSurfaceExtents (msurface_t *s)
596 {
597         float   mins[2], maxs[2], val;
598         int             i,j, e;
599         mvertex_t       *v;
600         mtexinfo_t      *tex;
601         int             bmins[2], bmaxs[2];
602
603         mins[0] = mins[1] = 999999;
604         maxs[0] = maxs[1] = -99999;
605
606         tex = s->texinfo;
607         
608         for (i=0 ; i<s->numedges ; i++)
609         {
610                 e = loadmodel->surfedges[s->firstedge+i];
611                 if (e >= 0)
612                         v = &loadmodel->vertexes[loadmodel->edges[e].v[0]];
613                 else
614                         v = &loadmodel->vertexes[loadmodel->edges[-e].v[1]];
615                 
616                 for (j=0 ; j<2 ; j++)
617                 {
618                         val = v->position[0] * tex->vecs[j][0] + 
619                                 v->position[1] * tex->vecs[j][1] +
620                                 v->position[2] * tex->vecs[j][2] +
621                                 tex->vecs[j][3];
622                         if (val < mins[j])
623                                 mins[j] = val;
624                         if (val > maxs[j])
625                                 maxs[j] = val;
626                 }
627         }
628
629         for (i=0 ; i<2 ; i++)
630         {       
631                 bmins[i] = floor(mins[i]/16);
632                 bmaxs[i] = ceil(maxs[i]/16);
633
634                 s->texturemins[i] = bmins[i] * 16;
635                 s->extents[i] = (bmaxs[i] - bmins[i]) * 16;
636                 if ( !(tex->flags & TEX_SPECIAL) && s->extents[i] > 512 /* 256 */ )
637                         Host_Error ("Bad surface extents");
638         }
639 }
640
641 void GL_SubdivideSurface (msurface_t *fa);
642
643 extern char skyname[];
644
645 /*
646 =================
647 Mod_LoadFaces
648 =================
649 */
650 void Mod_LoadFaces (lump_t *l)
651 {
652         dface_t         *in;
653         msurface_t      *out;
654         int                     i, count, surfnum;
655         int                     planenum, side;
656
657         in = (void *)(mod_base + l->fileofs);
658         if (l->filelen % sizeof(*in))
659                 Host_Error ("MOD_LoadBmodel: funny lump size in %s",loadmodel->name);
660         count = l->filelen / sizeof(*in);
661         out = Hunk_AllocName ( count*sizeof(*out), loadname);   
662
663         loadmodel->surfaces = out;
664         loadmodel->numsurfaces = count;
665
666         for ( surfnum=0 ; surfnum<count ; surfnum++, in++, out++)
667         {
668                 out->firstedge = LittleLong(in->firstedge);
669                 out->numedges = LittleShort(in->numedges);              
670                 out->flags = 0;
671
672                 planenum = LittleShort(in->planenum);
673                 side = LittleShort(in->side);
674                 if (side)
675                         out->flags |= SURF_PLANEBACK;                   
676
677                 out->plane = loadmodel->planes + planenum;
678
679                 out->texinfo = loadmodel->texinfo + LittleShort (in->texinfo);
680
681                 CalcSurfaceExtents (out);
682                                 
683         // lighting info
684
685                 for (i=0 ; i<MAXLIGHTMAPS ; i++)
686                         out->styles[i] = in->styles[i];
687                 i = LittleLong(in->lightofs);
688                 if (i == -1)
689                         out->samples = NULL;
690                 else if (hlbsp) // LordHavoc: HalfLife map (bsp version 30)
691                         out->samples = loadmodel->lightdata + i;
692                 else // LordHavoc: white lighting (bsp version 29)
693                         out->samples = loadmodel->lightdata + (i * 3); 
694                 
695         // set the drawing flags flag
696                 
697 //              if (!strncmp(out->texinfo->texture->name,"sky",3))      // sky
698                 // LordHavoc: faster check
699                 if ((out->texinfo->texture->name[0] == 's' || out->texinfo->texture->name[0] == 'S')
700                  && (out->texinfo->texture->name[1] == 'k' || out->texinfo->texture->name[1] == 'K')
701                  && (out->texinfo->texture->name[2] == 'y' || out->texinfo->texture->name[2] == 'Y'))
702                 {
703                         // LordHavoc: for consistency reasons, mark sky as fullbright and solid as well
704                         out->flags |= (SURF_DRAWSKY | SURF_DRAWTILED | SURF_DRAWFULLBRIGHT | SURF_DRAWNOALPHA);
705                         GL_SubdivideSurface (out);      // cut up polygon for warps
706                         continue;
707                 }
708                 
709 //              if (!strncmp(out->texinfo->texture->name,"*",1))                // turbulent
710                 if (out->texinfo->texture->name[0] == '*') // LordHavoc: faster check
711                 {
712                         out->flags |= (SURF_DRAWTURB | SURF_DRAWTILED);
713                         // LordHavoc: some turbulent textures should be fullbright and solid
714                         if (!strncmp(out->texinfo->texture->name,"*lava",5)
715                          || !strncmp(out->texinfo->texture->name,"*teleport",9)
716                          || !strncmp(out->texinfo->texture->name,"*rift",5)) // Scourge of Armagon texture
717                                 out->flags |= (SURF_DRAWFULLBRIGHT | SURF_DRAWNOALPHA);
718                         for (i=0 ; i<2 ; i++)
719                         {
720                                 out->extents[i] = 16384;
721                                 out->texturemins[i] = -8192;
722                         }
723                         GL_SubdivideSurface (out);      // cut up polygon for warps
724                         continue;
725                 }
726
727         }
728 }
729
730
731 /*
732 =================
733 Mod_SetParent
734 =================
735 */
736 void Mod_SetParent (mnode_t *node, mnode_t *parent)
737 {
738         node->parent = parent;
739         if (node->contents < 0)
740                 return;
741         Mod_SetParent (node->children[0], node);
742         Mod_SetParent (node->children[1], node);
743 }
744
745 /*
746 =================
747 Mod_LoadNodes
748 =================
749 */
750 void Mod_LoadNodes (lump_t *l)
751 {
752         int                     i, j, count, p;
753         dnode_t         *in;
754         mnode_t         *out;
755
756         in = (void *)(mod_base + l->fileofs);
757         if (l->filelen % sizeof(*in))
758                 Host_Error ("MOD_LoadBmodel: funny lump size in %s",loadmodel->name);
759         count = l->filelen / sizeof(*in);
760         out = Hunk_AllocName ( count*sizeof(*out), loadname);   
761
762         loadmodel->nodes = out;
763         loadmodel->numnodes = count;
764
765         for ( i=0 ; i<count ; i++, in++, out++)
766         {
767                 for (j=0 ; j<3 ; j++)
768                 {
769                         out->minmaxs[j] = LittleShort (in->mins[j]);
770                         out->minmaxs[3+j] = LittleShort (in->maxs[j]);
771                 }
772         
773                 p = LittleLong(in->planenum);
774                 out->plane = loadmodel->planes + p;
775
776                 out->firstsurface = LittleShort (in->firstface);
777                 out->numsurfaces = LittleShort (in->numfaces);
778                 
779                 for (j=0 ; j<2 ; j++)
780                 {
781                         p = LittleShort (in->children[j]);
782                         if (p >= 0)
783                                 out->children[j] = loadmodel->nodes + p;
784                         else
785                                 out->children[j] = (mnode_t *)(loadmodel->leafs + (-1 - p));
786                 }
787         }
788         
789         Mod_SetParent (loadmodel->nodes, NULL); // sets nodes and leafs
790 }
791
792 /*
793 =================
794 Mod_LoadLeafs
795 =================
796 */
797 void Mod_LoadLeafs (lump_t *l)
798 {
799         dleaf_t         *in;
800         mleaf_t         *out;
801         int                     i, j, count, p;
802
803         in = (void *)(mod_base + l->fileofs);
804         if (l->filelen % sizeof(*in))
805                 Host_Error ("MOD_LoadBmodel: funny lump size in %s",loadmodel->name);
806         count = l->filelen / sizeof(*in);
807         out = Hunk_AllocName ( count*sizeof(*out), loadname);   
808
809         loadmodel->leafs = out;
810         loadmodel->numleafs = count;
811
812         for ( i=0 ; i<count ; i++, in++, out++)
813         {
814                 for (j=0 ; j<3 ; j++)
815                 {
816                         out->minmaxs[j] = LittleShort (in->mins[j]);
817                         out->minmaxs[3+j] = LittleShort (in->maxs[j]);
818                 }
819
820                 p = LittleLong(in->contents);
821                 out->contents = p;
822
823                 out->firstmarksurface = loadmodel->marksurfaces +
824                         LittleShort(in->firstmarksurface);
825                 out->nummarksurfaces = LittleShort(in->nummarksurfaces);
826                 
827                 p = LittleLong(in->visofs);
828                 if (p == -1)
829                         out->compressed_vis = NULL;
830                 else
831                         out->compressed_vis = loadmodel->visdata + p;
832                 out->efrags = NULL;
833                 
834                 for (j=0 ; j<4 ; j++)
835                         out->ambient_sound_level[j] = in->ambient_level[j];
836
837                 // gl underwater warp
838                 // LordHavoc: disabled underwater warping
839                 /*
840                 if (out->contents != CONTENTS_EMPTY)
841                 {
842                         for (j=0 ; j<out->nummarksurfaces ; j++)
843                                 out->firstmarksurface[j]->flags |= SURF_UNDERWATER;
844                 }
845                 */
846         }       
847 }
848
849 /*
850 =================
851 Mod_LoadClipnodes
852 =================
853 */
854 void Mod_LoadClipnodes (lump_t *l)
855 {
856         dclipnode_t *in, *out;
857         int                     i, count;
858         hull_t          *hull;
859
860         in = (void *)(mod_base + l->fileofs);
861         if (l->filelen % sizeof(*in))
862                 Host_Error ("MOD_LoadBmodel: funny lump size in %s",loadmodel->name);
863         count = l->filelen / sizeof(*in);
864         out = Hunk_AllocName ( count*sizeof(*out), loadname);   
865
866         loadmodel->clipnodes = out;
867         loadmodel->numclipnodes = count;
868
869         hull = &loadmodel->hulls[1];
870         hull->clipnodes = out;
871         hull->firstclipnode = 0;
872         hull->lastclipnode = count-1;
873         hull->planes = loadmodel->planes;
874         hull->clip_mins[0] = -16;
875         hull->clip_mins[1] = -16;
876         hull->clip_mins[2] = -24;
877         hull->clip_maxs[0] = 16;
878         hull->clip_maxs[1] = 16;
879         hull->clip_maxs[2] = 32;
880
881         hull = &loadmodel->hulls[2];
882         hull->clipnodes = out;
883         hull->firstclipnode = 0;
884         hull->lastclipnode = count-1;
885         hull->planes = loadmodel->planes;
886         hull->clip_mins[0] = -32;
887         hull->clip_mins[1] = -32;
888         hull->clip_mins[2] = -24;
889         hull->clip_maxs[0] = 32;
890         hull->clip_maxs[1] = 32;
891         hull->clip_maxs[2] = 64;
892
893         for (i=0 ; i<count ; i++, out++, in++)
894         {
895                 out->planenum = LittleLong(in->planenum);
896                 out->children[0] = LittleShort(in->children[0]);
897                 out->children[1] = LittleShort(in->children[1]);
898                 if (out->children[0] >= count || out->children[1] >= count)
899                         Host_Error("Corrupt clipping hull (out of range child)\n");
900         }
901 }
902
903 /*
904 =================
905 Mod_MakeHull0
906
907 Duplicate the drawing hull structure as a clipping hull
908 =================
909 */
910 void Mod_MakeHull0 (void)
911 {
912         mnode_t         *in, *child;
913         dclipnode_t *out;
914         int                     i, j, count;
915         hull_t          *hull;
916         
917         hull = &loadmodel->hulls[0];    
918         
919         in = loadmodel->nodes;
920         count = loadmodel->numnodes;
921         out = Hunk_AllocName ( count*sizeof(*out), loadname);   
922
923         hull->clipnodes = out;
924         hull->firstclipnode = 0;
925         hull->lastclipnode = count-1;
926         hull->planes = loadmodel->planes;
927
928         for (i=0 ; i<count ; i++, out++, in++)
929         {
930                 out->planenum = in->plane - loadmodel->planes;
931                 for (j=0 ; j<2 ; j++)
932                 {
933                         child = in->children[j];
934                         if (child->contents < 0)
935                                 out->children[j] = child->contents;
936                         else
937                                 out->children[j] = child - loadmodel->nodes;
938                 }
939         }
940 }
941
942 /*
943 =================
944 Mod_LoadMarksurfaces
945 =================
946 */
947 void Mod_LoadMarksurfaces (lump_t *l)
948 {       
949         int             i, j, count;
950         short           *in;
951         msurface_t **out;
952         
953         in = (void *)(mod_base + l->fileofs);
954         if (l->filelen % sizeof(*in))
955                 Host_Error ("MOD_LoadBmodel: funny lump size in %s",loadmodel->name);
956         count = l->filelen / sizeof(*in);
957         out = Hunk_AllocName ( count*sizeof(*out), loadname);   
958
959         loadmodel->marksurfaces = out;
960         loadmodel->nummarksurfaces = count;
961
962         for ( i=0 ; i<count ; i++)
963         {
964                 j = LittleShort(in[i]);
965                 if (j >= loadmodel->numsurfaces)
966                         Host_Error ("Mod_ParseMarksurfaces: bad surface number");
967                 out[i] = loadmodel->surfaces + j;
968         }
969 }
970
971 /*
972 =================
973 Mod_LoadSurfedges
974 =================
975 */
976 void Mod_LoadSurfedges (lump_t *l)
977 {       
978         int             i, count;
979         int             *in, *out;
980         
981         in = (void *)(mod_base + l->fileofs);
982         if (l->filelen % sizeof(*in))
983                 Host_Error ("MOD_LoadBmodel: funny lump size in %s",loadmodel->name);
984         count = l->filelen / sizeof(*in);
985         out = Hunk_AllocName ( count*sizeof(*out), loadname);   
986
987         loadmodel->surfedges = out;
988         loadmodel->numsurfedges = count;
989
990         for ( i=0 ; i<count ; i++)
991                 out[i] = LittleLong (in[i]);
992 }
993
994
995 /*
996 =================
997 Mod_LoadPlanes
998 =================
999 */
1000 void Mod_LoadPlanes (lump_t *l)
1001 {
1002         int                     i, j;
1003         mplane_t        *out;
1004         dplane_t        *in;
1005         int                     count;
1006         int                     bits;
1007         
1008         in = (void *)(mod_base + l->fileofs);
1009         if (l->filelen % sizeof(*in))
1010                 Host_Error ("MOD_LoadBmodel: funny lump size in %s",loadmodel->name);
1011         count = l->filelen / sizeof(*in);
1012         out = Hunk_AllocName ( count*2*sizeof(*out), loadname); 
1013
1014         loadmodel->planes = out;
1015         loadmodel->numplanes = count;
1016
1017         for ( i=0 ; i<count ; i++, in++, out++)
1018         {
1019                 bits = 0;
1020                 for (j=0 ; j<3 ; j++)
1021                 {
1022                         out->normal[j] = LittleFloat (in->normal[j]);
1023 //                      if (out->normal[j] < 0)
1024 //                              bits |= 1<<j;
1025                 }
1026
1027                 out->dist = LittleFloat (in->dist);
1028                 out->type = LittleLong (in->type);
1029 //              out->signbits = bits;
1030                 BoxOnPlaneSideClassify(out);
1031         }
1032 }
1033
1034 /*
1035 =================
1036 Mod_LoadBrushModel
1037 =================
1038 */
1039 void Mod_LoadBrushModel (model_t *mod, void *buffer)
1040 {
1041         int                     i, j;
1042         dheader_t       *header;
1043         dmodel_t        *bm;
1044         
1045         loadmodel->type = mod_brush;
1046         
1047         header = (dheader_t *)buffer;
1048
1049         i = LittleLong (header->version);
1050         if (i != BSPVERSION && i != 30)
1051                 Host_Error ("Mod_LoadBrushModel: %s has wrong version number (%i should be %i or 30 (HalfLife))", mod->name, i, BSPVERSION);
1052         hlbsp = i == 30;
1053         halflifebsp.value = hlbsp;
1054
1055 // swap all the lumps
1056         mod_base = (byte *)header;
1057
1058         for (i=0 ; i<sizeof(dheader_t)/4 ; i++)
1059                 ((int *)header)[i] = LittleLong ( ((int *)header)[i]);
1060
1061 // load into heap
1062         
1063         // LordHavoc: had to move entity loading above everything to allow parsing various settings from worldspawn
1064         Mod_LoadEntities (&header->lumps[LUMP_ENTITIES]);
1065
1066         Mod_LoadVertexes (&header->lumps[LUMP_VERTEXES]);
1067         Mod_LoadEdges (&header->lumps[LUMP_EDGES]);
1068         Mod_LoadSurfedges (&header->lumps[LUMP_SURFEDGES]);
1069         Mod_LoadTextures (&header->lumps[LUMP_TEXTURES]);
1070         Mod_LoadLighting (&header->lumps[LUMP_LIGHTING]);
1071         Mod_LoadPlanes (&header->lumps[LUMP_PLANES]);
1072         Mod_LoadTexinfo (&header->lumps[LUMP_TEXINFO]);
1073         Mod_LoadFaces (&header->lumps[LUMP_FACES]);
1074         Mod_LoadMarksurfaces (&header->lumps[LUMP_MARKSURFACES]);
1075         Mod_LoadVisibility (&header->lumps[LUMP_VISIBILITY]);
1076         Mod_LoadLeafs (&header->lumps[LUMP_LEAFS]);
1077         Mod_LoadNodes (&header->lumps[LUMP_NODES]);
1078         Mod_LoadClipnodes (&header->lumps[LUMP_CLIPNODES]);
1079 //      Mod_LoadEntities (&header->lumps[LUMP_ENTITIES]);
1080         Mod_LoadSubmodels (&header->lumps[LUMP_MODELS]);
1081
1082         Mod_MakeHull0 ();
1083         
1084         mod->numframes = 2;             // regular and alternate animation
1085         
1086 //
1087 // set up the submodels (FIXME: this is confusing)
1088 //
1089         for (i=0 ; i<mod->numsubmodels ; i++)
1090         {
1091                 bm = &mod->submodels[i];
1092
1093                 mod->hulls[0].firstclipnode = bm->headnode[0];
1094                 for (j=1 ; j<MAX_MAP_HULLS ; j++)
1095                 {
1096                         mod->hulls[j].firstclipnode = bm->headnode[j];
1097                         mod->hulls[j].lastclipnode = mod->numclipnodes-1;
1098                 }
1099                 
1100                 mod->firstmodelsurface = bm->firstface;
1101                 mod->nummodelsurfaces = bm->numfaces;
1102                 
1103                 VectorCopy (bm->maxs, mod->maxs);
1104                 VectorCopy (bm->mins, mod->mins);
1105
1106                 mod->radius = RadiusFromBounds (mod->mins, mod->maxs);
1107
1108                 mod->numleafs = bm->visleafs;
1109
1110                 if (isworldmodel && i < (mod->numsubmodels-1)) // LordHavoc: only register submodels if it is the world (prevents bsp models from replacing world submodels)
1111                 {       // duplicate the basic information
1112                         char    name[10];
1113
1114                         sprintf (name, "*%i", i+1);
1115                         loadmodel = Mod_FindName (name);
1116                         *loadmodel = *mod;
1117                         strcpy (loadmodel->name, name);
1118                         mod = loadmodel;
1119                 }
1120         }
1121 }