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