![[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] / quake1|
Return to model.c CVS log | Up to [Quake] / quake1 |
1.1 root 1: // models.c -- model loading and caching
2:
3: // models are the only shared resource between a client and server running
4: // on the same machine.
5:
6: #include "quakedef.h"
7: #include "r_local.h"
8:
9: model_t *loadmodel;
10: char loadname[32]; // for hunk tags
11:
12: void Mod_LoadSpriteModel (model_t *mod, void *buffer);
13: void Mod_LoadBrushModel (model_t *mod, void *buffer);
14: void Mod_LoadAliasModel (model_t *mod, void *buffer);
15: model_t *Mod_LoadModel (model_t *mod, qboolean crash);
16:
17: byte mod_novis[MAX_MAP_LEAFS/8];
18:
19: #define MAX_MOD_KNOWN 256
20: model_t mod_known[MAX_MOD_KNOWN];
21: int mod_numknown;
22:
23: /*
24: ===============
25: Mod_Init
26: ===============
27: */
28: void Mod_Init (void)
29: {
30: memset (mod_novis, 0xff, sizeof(mod_novis));
31: }
32:
33: /*
34: ===============
35: Mod_Init
36:
37: Caches the data if needed
38: ===============
39: */
40: void *Mod_Extradata (model_t *mod)
41: {
42: void *r;
43:
44: r = Cache_Check (&mod->cache);
45: if (r)
46: return r;
47:
48: Mod_LoadModel (mod, true);
49:
50: if (!mod->cache.data)
51: Sys_Error ("Mod_Extradata: caching failed");
52: return mod->cache.data;
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: Sys_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: Sys_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: Sys_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: Mod_TouchModel
193:
194: ==================
195: */
196: void Mod_TouchModel (char *name)
197: {
198: model_t *mod;
199:
200: mod = Mod_FindName (name);
201:
202: if (!mod->needload)
203: {
204: if (mod->type == mod_alias)
205: Cache_Check (&mod->cache);
206: }
207: }
208:
209: /*
210: ==================
211: Mod_LoadModel
212:
213: Loads a model into the cache
214: ==================
215: */
216: model_t *Mod_LoadModel (model_t *mod, qboolean crash)
217: {
218: void *d;
219: unsigned *buf;
220: byte stackbuf[1024]; // avoid dirtying the cache heap
221:
222: if (!mod->needload)
223: {
224: if (mod->type == mod_alias)
225: {
226: d = Cache_Check (&mod->cache);
227: if (d)
228: return mod;
229: }
230: else
231: return mod; // not cached at all
232: }
233:
234: //
235: // because the world is so huge, load it one piece at a time
236: //
237: if (!crash)
238: {
239:
240: }
241:
242: //
243: // load the file
244: //
245: buf = (unsigned *)COM_LoadStackFile (mod->name, stackbuf, sizeof(stackbuf));
246: if (!buf)
247: {
248: if (crash)
249: Sys_Error ("Mod_NumForName: %s not found", mod->name);
250: return NULL;
251: }
252:
253: //
254: // allocate a new model
255: //
256: COM_FileBase (mod->name, loadname);
257:
258: loadmodel = mod;
259:
260: //
261: // fill it in
262: //
263:
264: // call the apropriate loader
265: mod->needload = false;
266:
267: switch (LittleLong(*(unsigned *)buf))
268: {
269: case IDPOLYHEADER:
270: Mod_LoadAliasModel (mod, buf);
271: break;
272:
273: case IDSPRITEHEADER:
274: Mod_LoadSpriteModel (mod, buf);
275: break;
276:
277: default:
278: Mod_LoadBrushModel (mod, buf);
279: break;
280: }
281:
282: return mod;
283: }
284:
285: /*
286: ==================
287: Mod_ForName
288:
289: Loads in a model for the given name
290: ==================
291: */
292: model_t *Mod_ForName (char *name, qboolean crash)
293: {
294: model_t *mod;
295:
296: mod = Mod_FindName (name);
297:
298: return Mod_LoadModel (mod, crash);
299: }
300:
301:
302: /*
303: ===============================================================================
304:
305: BRUSHMODEL LOADING
306:
307: ===============================================================================
308: */
309:
310: byte *mod_base;
311:
312:
313: /*
314: =================
315: Mod_LoadTextures
316: =================
317: */
318: void Mod_LoadTextures (lump_t *l)
319: {
320: int i, j, pixels, num, max, altmax;
321: miptex_t *mt;
322: texture_t *tx, *tx2;
323: texture_t *anims[10];
324: texture_t *altanims[10];
325: dmiptexlump_t *m;
326:
327: if (!l->filelen)
328: {
329: loadmodel->textures = NULL;
330: return;
331: }
332: m = (dmiptexlump_t *)(mod_base + l->fileofs);
333:
334: m->nummiptex = LittleLong (m->nummiptex);
335:
336: loadmodel->numtextures = m->nummiptex;
337: loadmodel->textures = Hunk_AllocName (m->nummiptex * sizeof(*loadmodel->textures) , loadname);
338:
339: for (i=0 ; i<m->nummiptex ; i++)
340: {
341: m->dataofs[i] = LittleLong(m->dataofs[i]);
342: if (m->dataofs[i] == -1)
343: continue;
344: mt = (miptex_t *)((byte *)m + m->dataofs[i]);
345: mt->width = LittleLong (mt->width);
346: mt->height = LittleLong (mt->height);
347: for (j=0 ; j<MIPLEVELS ; j++)
348: mt->offsets[j] = LittleLong (mt->offsets[j]);
349:
350: if ( (mt->width & 15) || (mt->height & 15) )
351: Sys_Error ("Texture %s is not 16 aligned", mt->name);
352: pixels = mt->width*mt->height/64*85;
353: tx = Hunk_AllocName (sizeof(texture_t) +pixels, loadname );
354: loadmodel->textures[i] = tx;
355:
356: memcpy (tx->name, mt->name, sizeof(tx->name));
357: tx->width = mt->width;
358: tx->height = mt->height;
359: for (j=0 ; j<MIPLEVELS ; j++)
360: tx->offsets[j] = mt->offsets[j] + sizeof(texture_t) - sizeof(miptex_t);
361: // the pixels immediately follow the structures
362: memcpy ( tx+1, mt+1, pixels);
363:
364: if (!Q_strncmp(mt->name,"sky",3))
365: R_InitSky (tx);
366: }
367:
368: //
369: // sequence the animations
370: //
371: for (i=0 ; i<m->nummiptex ; i++)
372: {
373: tx = loadmodel->textures[i];
374: if (!tx || tx->name[0] != '+')
375: continue;
376: if (tx->anim_next)
377: continue; // allready sequenced
378:
379: // find the number of frames in the animation
380: memset (anims, 0, sizeof(anims));
381: memset (altanims, 0, sizeof(altanims));
382:
383: max = tx->name[1];
384: altmax = 0;
385: if (max >= 'a' && max <= 'z')
386: max -= 'a' - 'A';
387: if (max >= '0' && max <= '9')
388: {
389: max -= '0';
390: altmax = 0;
391: anims[max] = tx;
392: max++;
393: }
394: else if (max >= 'A' && max <= 'J')
395: {
396: altmax = max - 'A';
397: max = 0;
398: altanims[altmax] = tx;
399: altmax++;
400: }
401: else
402: Sys_Error ("Bad animating texture %s", tx->name);
403:
404: for (j=i+1 ; j<m->nummiptex ; j++)
405: {
406: tx2 = loadmodel->textures[j];
407: if (!tx2 || tx2->name[0] != '+')
408: continue;
409: if (strcmp (tx2->name+2, tx->name+2))
410: continue;
411:
412: num = tx2->name[1];
413: if (num >= 'a' && num <= 'z')
414: num -= 'a' - 'A';
415: if (num >= '0' && num <= '9')
416: {
417: num -= '0';
418: anims[num] = tx2;
419: if (num+1 > max)
420: max = num + 1;
421: }
422: else if (num >= 'A' && num <= 'J')
423: {
424: num = num - 'A';
425: altanims[num] = tx2;
426: if (num+1 > altmax)
427: altmax = num+1;
428: }
429: else
430: Sys_Error ("Bad animating texture %s", tx->name);
431: }
432:
433: #define ANIM_CYCLE 2
434: // link them all together
435: for (j=0 ; j<max ; j++)
436: {
437: tx2 = anims[j];
438: if (!tx2)
439: Sys_Error ("Missing frame %i of %s",j, tx->name);
440: tx2->anim_total = max * ANIM_CYCLE;
441: tx2->anim_min = j * ANIM_CYCLE;
442: tx2->anim_max = (j+1) * ANIM_CYCLE;
443: tx2->anim_next = anims[ (j+1)%max ];
444: if (altmax)
445: tx2->alternate_anims = altanims[0];
446: }
447: for (j=0 ; j<altmax ; j++)
448: {
449: tx2 = altanims[j];
450: if (!tx2)
451: Sys_Error ("Missing frame %i of %s",j, tx->name);
452: tx2->anim_total = altmax * ANIM_CYCLE;
453: tx2->anim_min = j * ANIM_CYCLE;
454: tx2->anim_max = (j+1) * ANIM_CYCLE;
455: tx2->anim_next = altanims[ (j+1)%altmax ];
456: if (max)
457: tx2->alternate_anims = anims[0];
458: }
459: }
460: }
461:
462: /*
463: =================
464: Mod_LoadLighting
465: =================
466: */
467: void Mod_LoadLighting (lump_t *l)
468: {
469: if (!l->filelen)
470: {
471: loadmodel->lightdata = NULL;
472: return;
473: }
474: loadmodel->lightdata = Hunk_AllocName ( l->filelen, loadname);
475: memcpy (loadmodel->lightdata, mod_base + l->fileofs, l->filelen);
476: }
477:
478:
479: /*
480: =================
481: Mod_LoadVisibility
482: =================
483: */
484: void Mod_LoadVisibility (lump_t *l)
485: {
486: if (!l->filelen)
487: {
488: loadmodel->visdata = NULL;
489: return;
490: }
491: loadmodel->visdata = Hunk_AllocName ( l->filelen, loadname);
492: memcpy (loadmodel->visdata, mod_base + l->fileofs, l->filelen);
493: }
494:
495:
496: /*
497: =================
498: Mod_LoadEntities
499: =================
500: */
501: void Mod_LoadEntities (lump_t *l)
502: {
503: if (!l->filelen)
504: {
505: loadmodel->entities = NULL;
506: return;
507: }
508: loadmodel->entities = Hunk_AllocName ( l->filelen, loadname);
509: memcpy (loadmodel->entities, mod_base + l->fileofs, l->filelen);
510: }
511:
512:
513: /*
514: =================
515: Mod_LoadVertexes
516: =================
517: */
518: void Mod_LoadVertexes (lump_t *l)
519: {
520: dvertex_t *in;
521: mvertex_t *out;
522: int i, count;
523:
524: in = (void *)(mod_base + l->fileofs);
525: if (l->filelen % sizeof(*in))
526: Sys_Error ("MOD_LoadBmodel: funny lump size in %s",loadmodel->name);
527: count = l->filelen / sizeof(*in);
528: out = Hunk_AllocName ( count*sizeof(*out), loadname);
529:
530: loadmodel->vertexes = out;
531: loadmodel->numvertexes = count;
532:
533: for ( i=0 ; i<count ; i++, in++, out++)
534: {
535: out->position[0] = LittleFloat (in->point[0]);
536: out->position[1] = LittleFloat (in->point[1]);
537: out->position[2] = LittleFloat (in->point[2]);
538: }
539: }
540:
541: /*
542: =================
543: Mod_LoadSubmodels
544: =================
545: */
546: void Mod_LoadSubmodels (lump_t *l)
547: {
548: dmodel_t *in;
549: dmodel_t *out;
550: int i, j, count;
551:
552: in = (void *)(mod_base + l->fileofs);
553: if (l->filelen % sizeof(*in))
554: Sys_Error ("MOD_LoadBmodel: funny lump size in %s",loadmodel->name);
555: count = l->filelen / sizeof(*in);
556: out = Hunk_AllocName ( count*sizeof(*out), loadname);
557:
558: loadmodel->submodels = out;
559: loadmodel->numsubmodels = count;
560:
561: for ( i=0 ; i<count ; i++, in++, out++)
562: {
563: for (j=0 ; j<3 ; j++)
564: { // spread the mins / maxs by a pixel
565: out->mins[j] = LittleFloat (in->mins[j]) - 1;
566: out->maxs[j] = LittleFloat (in->maxs[j]) + 1;
567: out->origin[j] = LittleFloat (in->origin[j]);
568: }
569: for (j=0 ; j<MAX_MAP_HULLS ; j++)
570: out->headnode[j] = LittleLong (in->headnode[j]);
571: out->visleafs = LittleLong (in->visleafs);
572: out->firstface = LittleLong (in->firstface);
573: out->numfaces = LittleLong (in->numfaces);
574: }
575: }
576:
577: /*
578: =================
579: Mod_LoadEdges
580: =================
581: */
582: void Mod_LoadEdges (lump_t *l)
583: {
584: dedge_t *in;
585: medge_t *out;
586: int i, count;
587:
588: in = (void *)(mod_base + l->fileofs);
589: if (l->filelen % sizeof(*in))
590: Sys_Error ("MOD_LoadBmodel: funny lump size in %s",loadmodel->name);
591: count = l->filelen / sizeof(*in);
592: out = Hunk_AllocName ( (count + 1) * sizeof(*out), loadname);
593:
594: loadmodel->edges = out;
595: loadmodel->numedges = count;
596:
597: for ( i=0 ; i<count ; i++, in++, out++)
598: {
599: out->v[0] = (unsigned short)LittleShort(in->v[0]);
600: out->v[1] = (unsigned short)LittleShort(in->v[1]);
601: }
602: }
603:
604: /*
605: =================
606: Mod_LoadTexinfo
607: =================
608: */
609: void Mod_LoadTexinfo (lump_t *l)
610: {
611: texinfo_t *in;
612: mtexinfo_t *out;
613: int i, j, count;
614: int miptex;
615: float len1, len2;
616:
617: in = (void *)(mod_base + l->fileofs);
618: if (l->filelen % sizeof(*in))
619: Sys_Error ("MOD_LoadBmodel: funny lump size in %s",loadmodel->name);
620: count = l->filelen / sizeof(*in);
621: out = Hunk_AllocName ( count*sizeof(*out), loadname);
622:
623: loadmodel->texinfo = out;
624: loadmodel->numtexinfo = count;
625:
626: for ( i=0 ; i<count ; i++, in++, out++)
627: {
628: for (j=0 ; j<8 ; j++)
629: out->vecs[0][j] = LittleFloat (in->vecs[0][j]);
630: len1 = Length (out->vecs[0]);
631: len2 = Length (out->vecs[1]);
632: len1 = (len1 + len2)/2;
633: if (len1 < 0.32)
634: out->mipadjust = 4;
635: else if (len1 < 0.49)
636: out->mipadjust = 3;
637: else if (len1 < 0.99)
638: out->mipadjust = 2;
639: else
640: out->mipadjust = 1;
641: #if 0
642: if (len1 + len2 < 0.001)
643: out->mipadjust = 1; // don't crash
644: else
645: out->mipadjust = 1 / floor( (len1+len2)/2 + 0.1 );
646: #endif
647:
648: miptex = LittleLong (in->miptex);
649: out->flags = LittleLong (in->flags);
650:
651: if (!loadmodel->textures)
652: {
653: out->texture = r_notexture_mip; // checkerboard texture
654: out->flags = 0;
655: }
656: else
657: {
658: if (miptex >= loadmodel->numtextures)
659: Sys_Error ("miptex >= loadmodel->numtextures");
660: out->texture = loadmodel->textures[miptex];
661: if (!out->texture)
662: {
663: out->texture = r_notexture_mip; // texture not found
664: out->flags = 0;
665: }
666: }
667: }
668: }
669:
670: /*
671: ================
672: CalcSurfaceExtents
673:
674: Fills in s->texturemins[] and s->extents[]
675: ================
676: */
677: void CalcSurfaceExtents (msurface_t *s)
678: {
679: float mins[2], maxs[2], val;
680: int i,j, e;
681: mvertex_t *v;
682: mtexinfo_t *tex;
683: int bmins[2], bmaxs[2];
684:
685: mins[0] = mins[1] = 999999;
686: maxs[0] = maxs[1] = -99999;
687:
688: tex = s->texinfo;
689:
690: for (i=0 ; i<s->numedges ; i++)
691: {
692: e = loadmodel->surfedges[s->firstedge+i];
693: if (e >= 0)
694: v = &loadmodel->vertexes[loadmodel->edges[e].v[0]];
695: else
696: v = &loadmodel->vertexes[loadmodel->edges[-e].v[1]];
697:
698: for (j=0 ; j<2 ; j++)
699: {
700: val = v->position[0] * tex->vecs[j][0] +
701: v->position[1] * tex->vecs[j][1] +
702: v->position[2] * tex->vecs[j][2] +
703: tex->vecs[j][3];
704: if (val < mins[j])
705: mins[j] = val;
706: if (val > maxs[j])
707: maxs[j] = val;
708: }
709: }
710:
711: for (i=0 ; i<2 ; i++)
712: {
713: bmins[i] = floor(mins[i]/16);
714: bmaxs[i] = ceil(maxs[i]/16);
715:
716: s->texturemins[i] = bmins[i] * 16;
717: s->extents[i] = (bmaxs[i] - bmins[i]) * 16;
718: if ( !(tex->flags & TEX_SPECIAL) && s->extents[i] > 256)
719: Sys_Error ("Bad surface extents");
720: }
721: }
722:
723:
724: /*
725: =================
726: Mod_LoadFaces
727: =================
728: */
729: void Mod_LoadFaces (lump_t *l)
730: {
731: dface_t *in;
732: msurface_t *out;
733: int i, count, surfnum;
734: int planenum, side;
735:
736: in = (void *)(mod_base + l->fileofs);
737: if (l->filelen % sizeof(*in))
738: Sys_Error ("MOD_LoadBmodel: funny lump size in %s",loadmodel->name);
739: count = l->filelen / sizeof(*in);
740: out = Hunk_AllocName ( count*sizeof(*out), loadname);
741:
742: loadmodel->surfaces = out;
743: loadmodel->numsurfaces = count;
744:
745: for ( surfnum=0 ; surfnum<count ; surfnum++, in++, out++)
746: {
747: out->firstedge = LittleLong(in->firstedge);
748: out->numedges = LittleShort(in->numedges);
749: out->flags = 0;
750:
751: planenum = LittleShort(in->planenum);
752: side = LittleShort(in->side);
753: if (side)
754: out->flags |= SURF_PLANEBACK;
755:
756: out->plane = loadmodel->planes + planenum;
757:
758: out->texinfo = loadmodel->texinfo + LittleShort (in->texinfo);
759:
760: CalcSurfaceExtents (out);
761:
762: // lighting info
763:
764: for (i=0 ; i<MAXLIGHTMAPS ; i++)
765: out->styles[i] = in->styles[i];
766: i = LittleLong(in->lightofs);
767: if (i == -1)
768: out->samples = NULL;
769: else
770: out->samples = loadmodel->lightdata + i;
771:
772: // set the drawing flags flag
773:
774: if (!Q_strncmp(out->texinfo->texture->name,"sky",3)) // sky
775: {
776: out->flags |= (SURF_DRAWSKY | SURF_DRAWTILED);
777: continue;
778: }
779:
780: if (!Q_strncmp(out->texinfo->texture->name,"*",1)) // turbulent
781: {
782: out->flags |= (SURF_DRAWTURB | SURF_DRAWTILED);
783: for (i=0 ; i<2 ; i++)
784: {
785: out->extents[i] = 16384;
786: out->texturemins[i] = -8192;
787: }
788: continue;
789: }
790: }
791: }
792:
793:
794: /*
795: =================
796: Mod_SetParent
797: =================
798: */
799: void Mod_SetParent (mnode_t *node, mnode_t *parent)
800: {
801: node->parent = parent;
802: if (node->contents < 0)
803: return;
804: Mod_SetParent (node->children[0], node);
805: Mod_SetParent (node->children[1], node);
806: }
807:
808: /*
809: =================
810: Mod_LoadNodes
811: =================
812: */
813: void Mod_LoadNodes (lump_t *l)
814: {
815: int i, j, count, p;
816: dnode_t *in;
817: mnode_t *out;
818:
819: in = (void *)(mod_base + l->fileofs);
820: if (l->filelen % sizeof(*in))
821: Sys_Error ("MOD_LoadBmodel: funny lump size in %s",loadmodel->name);
822: count = l->filelen / sizeof(*in);
823: out = Hunk_AllocName ( count*sizeof(*out), loadname);
824:
825: loadmodel->nodes = out;
826: loadmodel->numnodes = count;
827:
828: for ( i=0 ; i<count ; i++, in++, out++)
829: {
830: for (j=0 ; j<3 ; j++)
831: {
832: out->minmaxs[j] = LittleShort (in->mins[j]);
833: out->minmaxs[3+j] = LittleShort (in->maxs[j]);
834: }
835:
836: p = LittleLong(in->planenum);
837: out->plane = loadmodel->planes + p;
838:
839: out->firstsurface = LittleShort (in->firstface);
840: out->numsurfaces = LittleShort (in->numfaces);
841:
842: for (j=0 ; j<2 ; j++)
843: {
844: p = LittleShort (in->children[j]);
845: if (p >= 0)
846: out->children[j] = loadmodel->nodes + p;
847: else
848: out->children[j] = (mnode_t *)(loadmodel->leafs + (-1 - p));
849: }
850: }
851:
852: Mod_SetParent (loadmodel->nodes, NULL); // sets nodes and leafs
853: }
854:
855: /*
856: =================
857: Mod_LoadLeafs
858: =================
859: */
860: void Mod_LoadLeafs (lump_t *l)
861: {
862: dleaf_t *in;
863: mleaf_t *out;
864: int i, j, count, p;
865:
866: in = (void *)(mod_base + l->fileofs);
867: if (l->filelen % sizeof(*in))
868: Sys_Error ("MOD_LoadBmodel: funny lump size in %s",loadmodel->name);
869: count = l->filelen / sizeof(*in);
870: out = Hunk_AllocName ( count*sizeof(*out), loadname);
871:
872: loadmodel->leafs = out;
873: loadmodel->numleafs = count;
874:
875: for ( i=0 ; i<count ; i++, in++, out++)
876: {
877: for (j=0 ; j<3 ; j++)
878: {
879: out->minmaxs[j] = LittleShort (in->mins[j]);
880: out->minmaxs[3+j] = LittleShort (in->maxs[j]);
881: }
882:
883: p = LittleLong(in->contents);
884: out->contents = p;
885:
886: out->firstmarksurface = loadmodel->marksurfaces +
887: LittleShort(in->firstmarksurface);
888: out->nummarksurfaces = LittleShort(in->nummarksurfaces);
889:
890: p = LittleLong(in->visofs);
891: if (p == -1)
892: out->compressed_vis = NULL;
893: else
894: out->compressed_vis = loadmodel->visdata + p;
895: out->efrags = NULL;
896:
897: for (j=0 ; j<4 ; j++)
898: out->ambient_sound_level[j] = in->ambient_level[j];
899: }
900: }
901:
902: /*
903: =================
904: Mod_LoadClipnodes
905: =================
906: */
907: void Mod_LoadClipnodes (lump_t *l)
908: {
909: dclipnode_t *in, *out;
910: int i, count;
911: hull_t *hull;
912:
913: in = (void *)(mod_base + l->fileofs);
914: if (l->filelen % sizeof(*in))
915: Sys_Error ("MOD_LoadBmodel: funny lump size in %s",loadmodel->name);
916: count = l->filelen / sizeof(*in);
917: out = Hunk_AllocName ( count*sizeof(*out), loadname);
918:
919: loadmodel->clipnodes = out;
920: loadmodel->numclipnodes = count;
921:
922: hull = &loadmodel->hulls[1];
923: hull->clipnodes = out;
924: hull->firstclipnode = 0;
925: hull->lastclipnode = count-1;
926: hull->planes = loadmodel->planes;
927: hull->clip_mins[0] = -16;
928: hull->clip_mins[1] = -16;
929: hull->clip_mins[2] = -24;
930: hull->clip_maxs[0] = 16;
931: hull->clip_maxs[1] = 16;
932: hull->clip_maxs[2] = 32;
933:
934: hull = &loadmodel->hulls[2];
935: hull->clipnodes = out;
936: hull->firstclipnode = 0;
937: hull->lastclipnode = count-1;
938: hull->planes = loadmodel->planes;
939: hull->clip_mins[0] = -32;
940: hull->clip_mins[1] = -32;
941: hull->clip_mins[2] = -24;
942: hull->clip_maxs[0] = 32;
943: hull->clip_maxs[1] = 32;
944: hull->clip_maxs[2] = 64;
945:
946: for (i=0 ; i<count ; i++, out++, in++)
947: {
948: out->planenum = LittleLong(in->planenum);
949: out->children[0] = LittleShort(in->children[0]);
950: out->children[1] = LittleShort(in->children[1]);
951: }
952: }
953:
954: /*
955: =================
956: Mod_MakeHull0
957:
958: Deplicate the drawing hull structure as a clipping hull
959: =================
960: */
961: void Mod_MakeHull0 (void)
962: {
963: mnode_t *in, *child;
964: dclipnode_t *out;
965: int i, j, count;
966: hull_t *hull;
967:
968: hull = &loadmodel->hulls[0];
969:
970: in = loadmodel->nodes;
971: count = loadmodel->numnodes;
972: out = Hunk_AllocName ( count*sizeof(*out), loadname);
973:
974: hull->clipnodes = out;
975: hull->firstclipnode = 0;
976: hull->lastclipnode = count-1;
977: hull->planes = loadmodel->planes;
978:
979: for (i=0 ; i<count ; i++, out++, in++)
980: {
981: out->planenum = in->plane - loadmodel->planes;
982: for (j=0 ; j<2 ; j++)
983: {
984: child = in->children[j];
985: if (child->contents < 0)
986: out->children[j] = child->contents;
987: else
988: out->children[j] = child - loadmodel->nodes;
989: }
990: }
991: }
992:
993: /*
994: =================
995: Mod_LoadMarksurfaces
996: =================
997: */
998: void Mod_LoadMarksurfaces (lump_t *l)
999: {
1000: int i, j, count;
1001: short *in;
1002: msurface_t **out;
1003:
1004: in = (void *)(mod_base + l->fileofs);
1005: if (l->filelen % sizeof(*in))
1006: Sys_Error ("MOD_LoadBmodel: funny lump size in %s",loadmodel->name);
1007: count = l->filelen / sizeof(*in);
1008: out = Hunk_AllocName ( count*sizeof(*out), loadname);
1009:
1010: loadmodel->marksurfaces = out;
1011: loadmodel->nummarksurfaces = count;
1012:
1013: for ( i=0 ; i<count ; i++)
1014: {
1015: j = LittleShort(in[i]);
1016: if (j >= loadmodel->numsurfaces)
1017: Sys_Error ("Mod_ParseMarksurfaces: bad surface number");
1018: out[i] = loadmodel->surfaces + j;
1019: }
1020: }
1021:
1022: /*
1023: =================
1024: Mod_LoadSurfedges
1025: =================
1026: */
1027: void Mod_LoadSurfedges (lump_t *l)
1028: {
1029: int i, count;
1030: int *in, *out;
1031:
1032: in = (void *)(mod_base + l->fileofs);
1033: if (l->filelen % sizeof(*in))
1034: Sys_Error ("MOD_LoadBmodel: funny lump size in %s",loadmodel->name);
1035: count = l->filelen / sizeof(*in);
1036: out = Hunk_AllocName ( count*sizeof(*out), loadname);
1037:
1038: loadmodel->surfedges = out;
1039: loadmodel->numsurfedges = count;
1040:
1041: for ( i=0 ; i<count ; i++)
1042: out[i] = LittleLong (in[i]);
1043: }
1044:
1045: /*
1046: =================
1047: Mod_LoadPlanes
1048: =================
1049: */
1050: void Mod_LoadPlanes (lump_t *l)
1051: {
1052: int i, j;
1053: mplane_t *out;
1054: dplane_t *in;
1055: int count;
1056: int bits;
1057:
1058: in = (void *)(mod_base + l->fileofs);
1059: if (l->filelen % sizeof(*in))
1060: Sys_Error ("MOD_LoadBmodel: funny lump size in %s",loadmodel->name);
1061: count = l->filelen / sizeof(*in);
1062: out = Hunk_AllocName ( count*2*sizeof(*out), loadname);
1063:
1064: loadmodel->planes = out;
1065: loadmodel->numplanes = count;
1066:
1067: for ( i=0 ; i<count ; i++, in++, out++)
1068: {
1069: bits = 0;
1070: for (j=0 ; j<3 ; j++)
1071: {
1072: out->normal[j] = LittleFloat (in->normal[j]);
1073: if (out->normal[j] < 0)
1074: bits |= 1<<j;
1075: }
1076:
1077: out->dist = LittleFloat (in->dist);
1078: out->type = LittleLong (in->type);
1079: out->signbits = bits;
1080: }
1081: }
1082:
1083:
1084: /*
1085: =================
1086: Mod_LoadBrushModel
1087: =================
1088: */
1089: void Mod_LoadBrushModel (model_t *mod, void *buffer)
1090: {
1091: int i, j;
1092: dheader_t *header;
1093: dmodel_t *bm;
1094:
1095: loadmodel->type = mod_brush;
1096:
1097: header = (dheader_t *)buffer;
1098:
1099: i = LittleLong (header->version);
1100: if (i != BSPVERSION)
1101: Sys_Error ("Mod_LoadBrushModel: %s has wrong version number (%i should be %i)", mod->name, i, BSPVERSION);
1102:
1103: // swap all the lumps
1104: mod_base = (byte *)header;
1105:
1106: for (i=0 ; i<sizeof(dheader_t)/4 ; i++)
1107: ((int *)header)[i] = LittleLong ( ((int *)header)[i]);
1108:
1109: // load into heap
1110:
1111: Mod_LoadVertexes (&header->lumps[LUMP_VERTEXES]);
1112: Mod_LoadEdges (&header->lumps[LUMP_EDGES]);
1113: Mod_LoadSurfedges (&header->lumps[LUMP_SURFEDGES]);
1114: Mod_LoadTextures (&header->lumps[LUMP_TEXTURES]);
1115: Mod_LoadLighting (&header->lumps[LUMP_LIGHTING]);
1116: Mod_LoadPlanes (&header->lumps[LUMP_PLANES]);
1117: Mod_LoadTexinfo (&header->lumps[LUMP_TEXINFO]);
1118: Mod_LoadFaces (&header->lumps[LUMP_FACES]);
1119: Mod_LoadMarksurfaces (&header->lumps[LUMP_MARKSURFACES]);
1120: Mod_LoadVisibility (&header->lumps[LUMP_VISIBILITY]);
1121: Mod_LoadLeafs (&header->lumps[LUMP_LEAFS]);
1122: Mod_LoadNodes (&header->lumps[LUMP_NODES]);
1123: Mod_LoadClipnodes (&header->lumps[LUMP_CLIPNODES]);
1124: Mod_LoadEntities (&header->lumps[LUMP_ENTITIES]);
1125: Mod_LoadSubmodels (&header->lumps[LUMP_MODELS]);
1126:
1127: Mod_MakeHull0 ();
1128:
1129: mod->numframes = 2; // regular and alternate animation
1130:
1131: //
1132: // set up the submodels (FIXME: this is confusing)
1133: //
1134: for (i=0 ; i<mod->numsubmodels ; i++)
1135: {
1136: bm = &mod->submodels[i];
1137:
1138: mod->hulls[0].firstclipnode = bm->headnode[0];
1139: for (j=1 ; j<MAX_MAP_HULLS ; j++)
1140: {
1141: mod->hulls[j].firstclipnode = bm->headnode[j];
1142: mod->hulls[j].lastclipnode = mod->numclipnodes-1;
1143: }
1144:
1145: mod->firstmodelsurface = bm->firstface;
1146: mod->nummodelsurfaces = bm->numfaces;
1147:
1148: VectorCopy (bm->maxs, mod->maxs);
1149: VectorCopy (bm->mins, mod->mins);
1150:
1151: mod->numleafs = bm->visleafs;
1152:
1153: if (i < mod->numsubmodels-1)
1154: { // duplicate the basic information
1155: char name[10];
1156:
1157: sprintf (name, "*%i", i+1);
1158: loadmodel = Mod_FindName (name);
1159: *loadmodel = *mod;
1160: strcpy (loadmodel->name, name);
1161: mod = loadmodel;
1162: }
1163: }
1164: }
1165:
1166: /*
1167: ==============================================================================
1168:
1169: ALIAS MODELS
1170:
1171: ==============================================================================
1172: */
1173:
1174: /*
1175: =================
1176: Mod_LoadAliasFrame
1177: =================
1178: */
1179: void * Mod_LoadAliasFrame (void * pin, int *pframeindex, int numv,
1180: trivertx_t *pbboxmin, trivertx_t *pbboxmax, aliashdr_t *pheader, char *name)
1181: {
1182: trivertx_t *pframe, *pinframe;
1183: int i, j;
1184: daliasframe_t *pdaliasframe;
1185:
1186: pdaliasframe = (daliasframe_t *)pin;
1187:
1188: strcpy (name, pdaliasframe->name);
1189:
1190: for (i=0 ; i<3 ; i++)
1191: {
1192: // these are byte values, so we don't have to worry about
1193: // endianness
1194: pbboxmin->v[i] = pdaliasframe->bboxmin.v[i];
1195: pbboxmax->v[i] = pdaliasframe->bboxmax.v[i];
1196: }
1197:
1198: pinframe = (trivertx_t *)(pdaliasframe + 1);
1199: pframe = Hunk_AllocName (numv * sizeof(*pframe), loadname);
1200:
1201: *pframeindex = (byte *)pframe - (byte *)pheader;
1202:
1203: for (j=0 ; j<numv ; j++)
1204: {
1205: int k;
1206:
1207: // these are all byte values, so no need to deal with endianness
1208: pframe[j].lightnormalindex = pinframe[j].lightnormalindex;
1209:
1210: for (k=0 ; k<3 ; k++)
1211: {
1212: pframe[j].v[k] = pinframe[j].v[k];
1213: }
1214: }
1215:
1216: pinframe += numv;
1217:
1218: return (void *)pinframe;
1219: }
1220:
1221:
1222: /*
1223: =================
1224: Mod_LoadAliasGroup
1225: =================
1226: */
1227: void * Mod_LoadAliasGroup (void * pin, int *pframeindex, int numv,
1228: trivertx_t *pbboxmin, trivertx_t *pbboxmax, aliashdr_t *pheader, char *name)
1229: {
1230: daliasgroup_t *pingroup;
1231: maliasgroup_t *paliasgroup;
1232: int i, numframes;
1233: daliasinterval_t *pin_intervals;
1234: float *poutintervals;
1235: void *ptemp;
1236:
1237: pingroup = (daliasgroup_t *)pin;
1238:
1239: numframes = LittleLong (pingroup->numframes);
1240:
1241: paliasgroup = Hunk_AllocName (sizeof (maliasgroup_t) +
1242: (numframes - 1) * sizeof (paliasgroup->frames[0]), loadname);
1243:
1244: paliasgroup->numframes = numframes;
1245:
1246: for (i=0 ; i<3 ; i++)
1247: {
1248: // these are byte values, so we don't have to worry about endianness
1249: pbboxmin->v[i] = pingroup->bboxmin.v[i];
1250: pbboxmax->v[i] = pingroup->bboxmax.v[i];
1251: }
1252:
1253: *pframeindex = (byte *)paliasgroup - (byte *)pheader;
1254:
1255: pin_intervals = (daliasinterval_t *)(pingroup + 1);
1256:
1257: poutintervals = Hunk_AllocName (numframes * sizeof (float), loadname);
1258:
1259: paliasgroup->intervals = (byte *)poutintervals - (byte *)pheader;
1260:
1261: for (i=0 ; i<numframes ; i++)
1262: {
1263: *poutintervals = LittleFloat (pin_intervals->interval);
1264: if (*poutintervals <= 0.0)
1265: Sys_Error ("Mod_LoadAliasGroup: interval<=0");
1266:
1267: poutintervals++;
1268: pin_intervals++;
1269: }
1270:
1271: ptemp = (void *)pin_intervals;
1272:
1273: for (i=0 ; i<numframes ; i++)
1274: {
1275: ptemp = Mod_LoadAliasFrame (ptemp,
1276: &paliasgroup->frames[i].frame,
1277: numv,
1278: &paliasgroup->frames[i].bboxmin,
1279: &paliasgroup->frames[i].bboxmax,
1280: pheader, name);
1281: }
1282:
1283: return ptemp;
1284: }
1285:
1286:
1287: /*
1288: =================
1289: Mod_LoadAliasSkin
1290: =================
1291: */
1292: void * Mod_LoadAliasSkin (void * pin, int *pskinindex, int skinsize,
1293: aliashdr_t *pheader)
1294: {
1295: int i;
1296: byte *pskin, *pinskin;
1297: unsigned short *pusskin;
1298:
1299: pskin = Hunk_AllocName (skinsize * r_pixbytes, loadname);
1300: pinskin = (byte *)pin;
1301: *pskinindex = (byte *)pskin - (byte *)pheader;
1302:
1303: if (r_pixbytes == 1)
1304: {
1305: Q_memcpy (pskin, pinskin, skinsize);
1306: }
1307: else if (r_pixbytes == 2)
1308: {
1309: pusskin = (unsigned short *)pskin;
1310:
1311: for (i=0 ; i<skinsize ; i++)
1312: pusskin[i] = d_8to16table[pinskin[i]];
1313: }
1314: else
1315: {
1316: Sys_Error ("Mod_LoadAliasSkin: driver set invalid r_pixbytes: %d\n",
1317: r_pixbytes);
1318: }
1319:
1320: pinskin += skinsize;
1321:
1322: return ((void *)pinskin);
1323: }
1324:
1325:
1326: /*
1327: =================
1328: Mod_LoadAliasSkinGroup
1329: =================
1330: */
1331: void * Mod_LoadAliasSkinGroup (void * pin, int *pskinindex, int skinsize,
1332: aliashdr_t *pheader)
1333: {
1334: daliasskingroup_t *pinskingroup;
1335: maliasskingroup_t *paliasskingroup;
1336: int i, numskins;
1337: daliasskininterval_t *pinskinintervals;
1338: float *poutskinintervals;
1339: void *ptemp;
1340:
1341: pinskingroup = (daliasskingroup_t *)pin;
1342:
1343: numskins = LittleLong (pinskingroup->numskins);
1344:
1345: paliasskingroup = Hunk_AllocName (sizeof (maliasskingroup_t) +
1346: (numskins - 1) * sizeof (paliasskingroup->skindescs[0]),
1347: loadname);
1348:
1349: paliasskingroup->numskins = numskins;
1350:
1351: *pskinindex = (byte *)paliasskingroup - (byte *)pheader;
1352:
1353: pinskinintervals = (daliasskininterval_t *)(pinskingroup + 1);
1354:
1355: poutskinintervals = Hunk_AllocName (numskins * sizeof (float),loadname);
1356:
1357: paliasskingroup->intervals = (byte *)poutskinintervals - (byte *)pheader;
1358:
1359: for (i=0 ; i<numskins ; i++)
1360: {
1361: *poutskinintervals = LittleFloat (pinskinintervals->interval);
1362: if (*poutskinintervals <= 0)
1363: Sys_Error ("Mod_LoadAliasSkinGroup: interval<=0");
1364:
1365: poutskinintervals++;
1366: pinskinintervals++;
1367: }
1368:
1369: ptemp = (void *)pinskinintervals;
1370:
1371: for (i=0 ; i<numskins ; i++)
1372: {
1373: ptemp = Mod_LoadAliasSkin (ptemp,
1374: &paliasskingroup->skindescs[i].skin, skinsize, pheader);
1375: }
1376:
1377: return ptemp;
1378: }
1379:
1380:
1381: /*
1382: =================
1383: Mod_LoadAliasModel
1384: =================
1385: */
1386: void Mod_LoadAliasModel (model_t *mod, void *buffer)
1387: {
1388: int i;
1389: mdl_t *pmodel, *pinmodel;
1390: stvert_t *pstverts, *pinstverts;
1391: aliashdr_t *pheader;
1392: mtriangle_t *ptri;
1393: dtriangle_t *pintriangles;
1394: int version, numframes, numskins;
1395: int size;
1396: daliasframetype_t *pframetype;
1397: daliasskintype_t *pskintype;
1398: maliasskindesc_t *pskindesc;
1399: int skinsize;
1400: int start, end, total;
1401:
1402: start = Hunk_LowMark ();
1403:
1404: pinmodel = (mdl_t *)buffer;
1405:
1406: version = LittleLong (pinmodel->version);
1407: if (version != ALIAS_VERSION)
1408: Sys_Error ("%s has wrong version number (%i should be %i)",
1409: mod->name, version, ALIAS_VERSION);
1410:
1411: //
1412: // allocate space for a working header, plus all the data except the frames,
1413: // skin and group info
1414: //
1415: size = sizeof (aliashdr_t) + (LittleLong (pinmodel->numframes) - 1) *
1416: sizeof (pheader->frames[0]) +
1417: sizeof (mdl_t) +
1418: LittleLong (pinmodel->numverts) * sizeof (stvert_t) +
1419: LittleLong (pinmodel->numtris) * sizeof (mtriangle_t);
1420:
1421: pheader = Hunk_AllocName (size, loadname);
1422: pmodel = (mdl_t *) ((byte *)&pheader[1] +
1423: (LittleLong (pinmodel->numframes) - 1) *
1424: sizeof (pheader->frames[0]));
1425:
1426: // mod->cache.data = pheader;
1427: mod->flags = LittleLong (pinmodel->flags);
1428:
1429: //
1430: // endian-adjust and copy the data, starting with the alias model header
1431: //
1432: pmodel->boundingradius = LittleFloat (pinmodel->boundingradius);
1433: pmodel->numskins = LittleLong (pinmodel->numskins);
1434: pmodel->skinwidth = LittleLong (pinmodel->skinwidth);
1435: pmodel->skinheight = LittleLong (pinmodel->skinheight);
1436:
1437: if (pmodel->skinheight > MAX_LBM_HEIGHT)
1438: Sys_Error ("model %s has a skin taller than %d", mod->name,
1439: MAX_LBM_HEIGHT);
1440:
1441: pmodel->numverts = LittleLong (pinmodel->numverts);
1442:
1443: if (pmodel->numverts <= 0)
1444: Sys_Error ("model %s has no vertices", mod->name);
1445:
1446: if (pmodel->numverts > MAXALIASVERTS)
1447: Sys_Error ("model %s has too many vertices", mod->name);
1448:
1449: pmodel->numtris = LittleLong (pinmodel->numtris);
1450:
1451: if (pmodel->numtris <= 0)
1452: Sys_Error ("model %s has no triangles", mod->name);
1453:
1454: pmodel->numframes = LittleLong (pinmodel->numframes);
1455: pmodel->size = LittleFloat (pinmodel->size) * ALIAS_BASE_SIZE_RATIO;
1456: mod->synctype = LittleLong (pinmodel->synctype);
1457: mod->numframes = pmodel->numframes;
1458:
1459: for (i=0 ; i<3 ; i++)
1460: {
1461: pmodel->scale[i] = LittleFloat (pinmodel->scale[i]);
1462: pmodel->scale_origin[i] = LittleFloat (pinmodel->scale_origin[i]);
1463: pmodel->eyeposition[i] = LittleFloat (pinmodel->eyeposition[i]);
1464: }
1465:
1466: numskins = pmodel->numskins;
1467: numframes = pmodel->numframes;
1468:
1469: if (pmodel->skinwidth & 0x03)
1470: Sys_Error ("Mod_LoadAliasModel: skinwidth not multiple of 4");
1471:
1472: pheader->model = (byte *)pmodel - (byte *)pheader;
1473:
1474: //
1475: // load the skins
1476: //
1477: skinsize = pmodel->skinheight * pmodel->skinwidth;
1478:
1479: if (numskins < 1)
1480: Sys_Error ("Mod_LoadAliasModel: Invalid # of skins: %d\n", numskins);
1481:
1482: pskintype = (daliasskintype_t *)&pinmodel[1];
1483:
1484: pskindesc = Hunk_AllocName (numskins * sizeof (maliasskindesc_t),
1485: loadname);
1486:
1487: pheader->skindesc = (byte *)pskindesc - (byte *)pheader;
1488:
1489: for (i=0 ; i<numskins ; i++)
1490: {
1491: aliasskintype_t skintype;
1492:
1493: skintype = LittleLong (pskintype->type);
1494: pskindesc[i].type = skintype;
1495:
1496: if (skintype == ALIAS_SKIN_SINGLE)
1497: {
1498: pskintype = (daliasskintype_t *)
1499: Mod_LoadAliasSkin (pskintype + 1,
1500: &pskindesc[i].skin,
1501: skinsize, pheader);
1502: }
1503: else
1504: {
1505: pskintype = (daliasskintype_t *)
1506: Mod_LoadAliasSkinGroup (pskintype + 1,
1507: &pskindesc[i].skin,
1508: skinsize, pheader);
1509: }
1510: }
1511:
1512: //
1513: // set base s and t vertices
1514: //
1515: pstverts = (stvert_t *)&pmodel[1];
1516: pinstverts = (stvert_t *)pskintype;
1517:
1518: pheader->stverts = (byte *)pstverts - (byte *)pheader;
1519:
1520: for (i=0 ; i<pmodel->numverts ; i++)
1521: {
1522: pstverts[i].onseam = LittleLong (pinstverts[i].onseam);
1523: // put s and t in 16.16 format
1524: pstverts[i].s = LittleLong (pinstverts[i].s) << 16;
1525: pstverts[i].t = LittleLong (pinstverts[i].t) << 16;
1526: }
1527:
1528: //
1529: // set up the triangles
1530: //
1531: ptri = (mtriangle_t *)&pstverts[pmodel->numverts];
1532: pintriangles = (dtriangle_t *)&pinstverts[pmodel->numverts];
1533:
1534: pheader->triangles = (byte *)ptri - (byte *)pheader;
1535:
1536: for (i=0 ; i<pmodel->numtris ; i++)
1537: {
1538: int j;
1539:
1540: ptri[i].facesfront = LittleLong (pintriangles[i].facesfront);
1541:
1542: for (j=0 ; j<3 ; j++)
1543: {
1544: ptri[i].vertindex[j] =
1545: LittleLong (pintriangles[i].vertindex[j]);
1546: }
1547: }
1548:
1549: //
1550: // load the frames
1551: //
1552: if (numframes < 1)
1553: Sys_Error ("Mod_LoadAliasModel: Invalid # of frames: %d\n", numframes);
1554:
1555: pframetype = (daliasframetype_t *)&pintriangles[pmodel->numtris];
1556:
1557: for (i=0 ; i<numframes ; i++)
1558: {
1559: aliasframetype_t frametype;
1560:
1561: frametype = LittleLong (pframetype->type);
1562: pheader->frames[i].type = frametype;
1563:
1564:
1565: if (frametype == ALIAS_SINGLE)
1566: {
1567: pframetype = (daliasframetype_t *)
1568: Mod_LoadAliasFrame (pframetype + 1,
1569: &pheader->frames[i].frame,
1570: pmodel->numverts,
1571: &pheader->frames[i].bboxmin,
1572: &pheader->frames[i].bboxmax,
1573: pheader, pheader->frames[i].name);
1574: }
1575: else
1576: {
1577: pframetype = (daliasframetype_t *)
1578: Mod_LoadAliasGroup (pframetype + 1,
1579: &pheader->frames[i].frame,
1580: pmodel->numverts,
1581: &pheader->frames[i].bboxmin,
1582: &pheader->frames[i].bboxmax,
1583: pheader, pheader->frames[i].name);
1584: }
1585: }
1586:
1587: mod->type = mod_alias;
1588:
1589: // FIXME: do this right
1590: mod->mins[0] = mod->mins[1] = mod->mins[2] = -16;
1591: mod->maxs[0] = mod->maxs[1] = mod->maxs[2] = 16;
1592:
1593: //
1594: // move the complete, relocatable alias model to the cache
1595: //
1596: end = Hunk_LowMark ();
1597: total = end - start;
1598:
1599: Cache_Alloc (&mod->cache, total, loadname);
1600: if (!mod->cache.data)
1601: return;
1602: memcpy (mod->cache.data, pheader, total);
1603:
1604: Hunk_FreeToLowMark (start);
1605: }
1606:
1607: //=============================================================================
1608:
1609: /*
1610: =================
1611: Mod_LoadSpriteFrame
1612: =================
1613: */
1614: void * Mod_LoadSpriteFrame (void * pin, mspriteframe_t **ppframe)
1615: {
1616: dspriteframe_t *pinframe;
1617: mspriteframe_t *pspriteframe;
1618: int i, width, height, size, origin[2];
1619: unsigned short *ppixout;
1620: byte *ppixin;
1621:
1622: pinframe = (dspriteframe_t *)pin;
1623:
1624: width = LittleLong (pinframe->width);
1625: height = LittleLong (pinframe->height);
1626: size = width * height;
1627:
1628: pspriteframe = Hunk_AllocName (sizeof (mspriteframe_t) + size*r_pixbytes,
1629: loadname);
1630:
1631: Q_memset (pspriteframe, 0, sizeof (mspriteframe_t) + size);
1632: *ppframe = pspriteframe;
1633:
1634: pspriteframe->width = width;
1635: pspriteframe->height = height;
1636: origin[0] = LittleLong (pinframe->origin[0]);
1637: origin[1] = LittleLong (pinframe->origin[1]);
1638:
1639: pspriteframe->up = origin[1];
1640: pspriteframe->down = origin[1] - height;
1641: pspriteframe->left = origin[0];
1642: pspriteframe->right = width + origin[0];
1643:
1644: if (r_pixbytes == 1)
1645: {
1646: Q_memcpy (&pspriteframe->pixels[0], (byte *)(pinframe + 1), size);
1647: }
1648: else if (r_pixbytes == 2)
1649: {
1650: ppixin = (byte *)(pinframe + 1);
1651: ppixout = (unsigned short *)&pspriteframe->pixels[0];
1652:
1653: for (i=0 ; i<size ; i++)
1654: ppixout[i] = d_8to16table[ppixin[i]];
1655: }
1656: else
1657: {
1658: Sys_Error ("Mod_LoadSpriteFrame: driver set invalid r_pixbytes: %d\n",
1659: r_pixbytes);
1660: }
1661:
1662: return (void *)((byte *)pinframe + sizeof (dspriteframe_t) + size);
1663: }
1664:
1665:
1666: /*
1667: =================
1668: Mod_LoadSpriteGroup
1669: =================
1670: */
1671: void * Mod_LoadSpriteGroup (void * pin, mspriteframe_t **ppframe)
1672: {
1673: dspritegroup_t *pingroup;
1674: mspritegroup_t *pspritegroup;
1675: int i, numframes;
1676: dspriteinterval_t *pin_intervals;
1677: float *poutintervals;
1678: void *ptemp;
1679:
1680: pingroup = (dspritegroup_t *)pin;
1681:
1682: numframes = LittleLong (pingroup->numframes);
1683:
1684: pspritegroup = Hunk_AllocName (sizeof (mspritegroup_t) +
1685: (numframes - 1) * sizeof (pspritegroup->frames[0]), loadname);
1686:
1687: pspritegroup->numframes = numframes;
1688:
1689: *ppframe = (mspriteframe_t *)pspritegroup;
1690:
1691: pin_intervals = (dspriteinterval_t *)(pingroup + 1);
1692:
1693: poutintervals = Hunk_AllocName (numframes * sizeof (float), loadname);
1694:
1695: pspritegroup->intervals = poutintervals;
1696:
1697: for (i=0 ; i<numframes ; i++)
1698: {
1699: *poutintervals = LittleFloat (pin_intervals->interval);
1700: if (*poutintervals <= 0.0)
1701: Sys_Error ("Mod_LoadSpriteGroup: interval<=0");
1702:
1703: poutintervals++;
1704: pin_intervals++;
1705: }
1706:
1707: ptemp = (void *)pin_intervals;
1708:
1709: for (i=0 ; i<numframes ; i++)
1710: {
1711: ptemp = Mod_LoadSpriteFrame (ptemp, &pspritegroup->frames[i]);
1712: }
1713:
1714: return ptemp;
1715: }
1716:
1717:
1718: /*
1719: =================
1720: Mod_LoadSpriteModel
1721: =================
1722: */
1723: void Mod_LoadSpriteModel (model_t *mod, void *buffer)
1724: {
1725: int i;
1726: int version;
1727: dsprite_t *pin;
1728: msprite_t *psprite;
1729: int numframes;
1730: int size;
1731: dspriteframetype_t *pframetype;
1732:
1733: pin = (dsprite_t *)buffer;
1734:
1735: version = LittleLong (pin->version);
1736: if (version != SPRITE_VERSION)
1737: Sys_Error ("%s has wrong version number "
1738: "(%i should be %i)", mod->name, version, SPRITE_VERSION);
1739:
1740: numframes = LittleLong (pin->numframes);
1741:
1742: size = sizeof (msprite_t) + (numframes - 1) * sizeof (psprite->frames);
1743:
1744: psprite = Hunk_AllocName (size, loadname);
1745:
1746: mod->cache.data = psprite;
1747:
1748: psprite->type = LittleLong (pin->type);
1749: psprite->maxwidth = LittleLong (pin->width);
1750: psprite->maxheight = LittleLong (pin->height);
1751: psprite->beamlength = LittleFloat (pin->beamlength);
1752: mod->synctype = LittleLong (pin->synctype);
1753: psprite->numframes = numframes;
1754:
1755: mod->mins[0] = mod->mins[1] = -psprite->maxwidth/2;
1756: mod->maxs[0] = mod->maxs[1] = psprite->maxwidth/2;
1757: mod->mins[2] = -psprite->maxheight/2;
1758: mod->maxs[2] = psprite->maxheight/2;
1759:
1760: //
1761: // load the frames
1762: //
1763: if (numframes < 1)
1764: Sys_Error ("Mod_LoadSpriteModel: Invalid # of frames: %d\n", numframes);
1765:
1766: mod->numframes = numframes;
1767:
1768: pframetype = (dspriteframetype_t *)(pin + 1);
1769:
1770: for (i=0 ; i<numframes ; i++)
1771: {
1772: spriteframetype_t frametype;
1773:
1774: frametype = LittleLong (pframetype->type);
1775: psprite->frames[i].type = frametype;
1776:
1777: if (frametype == SPR_SINGLE)
1778: {
1779: pframetype = (dspriteframetype_t *)
1780: Mod_LoadSpriteFrame (pframetype + 1,
1781: &psprite->frames[i].frameptr);
1782: }
1783: else
1784: {
1785: pframetype = (dspriteframetype_t *)
1786: Mod_LoadSpriteGroup (pframetype + 1,
1787: &psprite->frames[i].frameptr);
1788: }
1789: }
1790:
1791: mod->type = mod_sprite;
1792: }
1793:
1794: //=============================================================================
1795:
1796: /*
1797: ================
1798: Mod_Print
1799: ================
1800: */
1801: void Mod_Print (void)
1802: {
1803: int i;
1804: model_t *mod;
1805:
1806: Con_Printf ("Cached models:\n");
1807: for (i=0, mod=mod_known ; i < mod_numknown ; i++, mod++)
1808: {
1809: Con_Printf ("%8p : %s\n",mod->cache.data, mod->name);
1810: }
1811: }
1812:
1813:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.