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