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