2 Copyright (C) 1996-1997 Id Software, Inc.
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.
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.
13 See the GNU General Public License for more details.
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.
23 cvar_t r_mipskins = {"r_mipskins", "1", true};
30 void Mod_AliasInit (void)
32 Cvar_RegisterVariable(&r_mipskins);
37 float aliasbboxmin[3], aliasbboxmax[3]; // LordHavoc: proper bounding box considerations
39 float vertst[MAXALIASVERTS][2];
40 int vertusage[MAXALIASVERTS];
41 int vertonseam[MAXALIASVERTS];
42 int vertremap[MAXALIASVERTS];
43 unsigned short temptris[MAXALIASTRIS][3];
45 void Mod_ConvertAliasVerts (int inverts, vec3_t scale, vec3_t translate, trivertx_t *v, trivertx_t *out)
47 int i, j, invalidnormals = 0;
49 for (i = 0;i < inverts;i++)
51 if (vertremap[i] < 0 && vertremap[i+inverts] < 0) // only used vertices need apply...
53 temp[0] = v[i].v[0] * scale[0] + translate[0];
54 temp[1] = v[i].v[1] * scale[1] + translate[1];
55 temp[2] = v[i].v[2] * scale[2] + translate[2];
56 // update bounding box
57 if (temp[0] < aliasbboxmin[0]) aliasbboxmin[0] = temp[0];
58 if (temp[1] < aliasbboxmin[1]) aliasbboxmin[1] = temp[1];
59 if (temp[2] < aliasbboxmin[2]) aliasbboxmin[2] = temp[2];
60 if (temp[0] > aliasbboxmax[0]) aliasbboxmax[0] = temp[0];
61 if (temp[1] > aliasbboxmax[1]) aliasbboxmax[1] = temp[1];
62 if (temp[2] > aliasbboxmax[2]) aliasbboxmax[2] = temp[2];
63 j = vertremap[i]; // not onseam
66 VectorCopy(v[i].v, out[j].v);
67 out[j].lightnormalindex = v[i].lightnormalindex;
68 if (out[j].lightnormalindex >= NUMVERTEXNORMALS)
71 out[j].lightnormalindex = 0;
74 j = vertremap[i+inverts]; // onseam
77 VectorCopy(v[i].v, out[j].v);
78 out[j].lightnormalindex = v[i].lightnormalindex;
79 if (out[j].lightnormalindex >= NUMVERTEXNORMALS)
82 out[j].lightnormalindex = 0;
87 Con_Printf("Mod_ConvertAliasVerts: \"%s\", %i invalid normal indices found\n", loadname, invalidnormals);
95 void * Mod_LoadAliasFrame (void *pin, maliashdr_t *mheader, int inverts, int outverts, trivertx_t **posevert, animscene_t *scene)
98 daliasframe_t *pdaliasframe;
100 pdaliasframe = (daliasframe_t *)pin;
102 strcpy(scene->name, pdaliasframe->name);
103 scene->firstframe = posenum;
104 scene->framecount = 1;
105 scene->framerate = 10.0f; // unnecessary but...
108 pinframe = (trivertx_t *)(pdaliasframe + 1);
110 Mod_ConvertAliasVerts(inverts, mheader->scale, mheader->scale_origin, pinframe, *posevert);
111 *posevert += outverts;
116 return (void *)pinframe;
125 void *Mod_LoadAliasGroup (void *pin, maliashdr_t *mheader, int inverts, int outverts, trivertx_t **posevert, animscene_t *scene)
131 numframes = LittleLong (((daliasgroup_t *)pin)->numframes);
133 strcpy(scene->name, ((daliasframe_t *) (sizeof(daliasinterval_t) * numframes + sizeof(daliasgroup_t) + (int) pin))->name);
134 scene->firstframe = posenum;
135 scene->framecount = numframes;
136 interval = LittleFloat (((daliasinterval_t *)(((daliasgroup_t *)pin) + 1))->interval); // FIXME: support variable framerate groups?
137 if (interval < 0.01f)
138 Host_Error("Mod_LoadAliasGroup: invalid interval");
139 scene->framerate = 1.0f / interval;
142 ptemp = (void *)(((daliasinterval_t *)(((daliasgroup_t *)pin) + 1)) + numframes);
144 for (i=0 ; i<numframes ; i++)
146 ((daliasframe_t *)ptemp)++;
147 Mod_ConvertAliasVerts(inverts, mheader->scale, mheader->scale_origin, ptemp, *posevert);
148 *posevert += outverts;
150 ptemp = (trivertx_t *)ptemp + inverts;
156 //=========================================================
162 Fill background pixels so mipmapping doesn't have haloes - Ed
171 // must be a power of 2
172 #define FLOODFILL_FIFO_SIZE 0x1000
173 #define FLOODFILL_FIFO_MASK (FLOODFILL_FIFO_SIZE - 1)
175 #define FLOODFILL_STEP( off, dx, dy ) \
177 if (pos[off] == fillcolor) \
180 fifo[inpt].x = x + (dx), fifo[inpt].y = y + (dy); \
181 inpt = (inpt + 1) & FLOODFILL_FIFO_MASK; \
183 else if (pos[off] != 255) fdc = pos[off]; \
186 void Mod_FloodFillSkin( byte *skin, int skinwidth, int skinheight )
188 byte fillcolor = *skin; // assume this is the pixel to fill
189 floodfill_t fifo[FLOODFILL_FIFO_SIZE];
190 int inpt = 0, outpt = 0;
191 int filledcolor = -1;
194 if (filledcolor == -1)
197 // attempt to find opaque black
198 for (i = 0; i < 256; ++i)
199 if (d_8to24table[i] == (255 << 0)) // alpha 1.0
206 // can't fill to filled color or to transparent color (used as visited marker)
207 if ((fillcolor == filledcolor) || (fillcolor == 255))
209 //printf( "not filling skin from %d to %d\n", fillcolor, filledcolor );
213 fifo[inpt].x = 0, fifo[inpt].y = 0;
214 inpt = (inpt + 1) & FLOODFILL_FIFO_MASK;
216 while (outpt != inpt)
218 int x = fifo[outpt].x, y = fifo[outpt].y;
219 int fdc = filledcolor;
220 byte *pos = &skin[x + skinwidth * y];
222 outpt = (outpt + 1) & FLOODFILL_FIFO_MASK;
224 if (x > 0) FLOODFILL_STEP( -1, -1, 0 );
225 if (x < skinwidth - 1) FLOODFILL_STEP( 1, 1, 0 );
226 if (y > 0) FLOODFILL_STEP( -skinwidth, 0, -1 );
227 if (y < skinheight - 1) FLOODFILL_STEP( skinwidth, 0, 1 );
228 skin[x + skinwidth * y] = fdc;
232 rtexture_t *GL_SkinSplitShirt(byte *in, byte *out, int width, int height, unsigned short bits, char *name, int precache)
234 int i, pixels, passed;
236 for (i = 0;i < 16;i++)
237 pixeltest[i] = (bits & (1 << i)) != 0;
238 pixels = width*height;
242 if (pixeltest[*in >> 4] && *in != 0 && *in != 255)
245 // turn to white while copying
246 if (*in >= 128 && *in < 224) // backwards ranges
247 *out = (*in & 15) ^ 15;
257 return R_LoadTexture (name, width, height, out - width*height, (r_mipskins.value ? TEXF_MIPMAP : 0) | (precache ? TEXF_PRECACHE : 0));
262 rtexture_t *GL_SkinSplit(byte *in, byte *out, int width, int height, unsigned short bits, char *name, int precache)
264 int i, pixels, passed;
266 for (i = 0;i < 16;i++)
267 pixeltest[i] = (bits & (1 << i)) != 0;
268 pixels = width*height;
272 if (pixeltest[*in >> 4] && *in != 0 && *in != 255)
283 return R_LoadTexture (name, width, height, out - width*height, (r_mipskins.value ? TEXF_MIPMAP : 0) | (precache ? TEXF_PRECACHE : 0));
288 int GL_SkinCheck(byte *in, int width, int height, unsigned short bits)
290 int i, pixels, passed;
292 for (i = 0;i < 16;i++)
293 pixeltest[i] = (bits & (1 << i)) != 0;
294 pixels = width*height;
298 if (pixeltest[*in >> 4] && *in != 0 && *in != 255)
305 void Mod_LoadSkin (maliashdr_t *mheader, char *basename, byte *skindata, byte *skintemp, int width, int height, rtexture_t **skintex)
308 int skin_normal, skin_pants, skin_shirt, skin_glow, skin_body, temp;
309 skin_normal = loadtextureimage(va("%s_normal", basename));
310 skin_pants = loadtextureimage(va("%s_pants" , basename));
311 skin_shirt = loadtextureimage(va("%s_shirt" , basename));
312 skin_glow = loadtextureimage(va("%s_glow" , basename));
313 skin_body = loadtextureimage(va("%s_body" , basename));
314 if (!(skin_normal || skin_pants || skin_shirt || skin_glow || skin_body))
315 skin_body = loadtextureimage(name);
316 if (skin_normal || skin_pants || skin_shirt || skin_glow || skin_body)
318 skintexnum[0] = skin_normal;
319 skintexnum[1] = skin_pants;
320 skintexnum[2] = skin_shirt;
321 skintexnum[3] = skin_glow;
322 skintexnum[4] = skin_body;
326 Mod_FloodFillSkin(skin, width, height);
327 skin_normal = GL_SkinCheck((byte *)pskintype, width, height, 0x3FBD);
328 skin_pants = GL_SkinCheck((byte *)pskintype, width, height, 0x0040);
329 skin_shirt = GL_SkinCheck((byte *)pskintype, width, height, 0x0002);
330 skin_glow = GL_SkinCheck((byte *)pskintype, width, height, 0xC000);
331 skin_body = GL_SkinCheck((byte *)pskintype, width, height, 0x3FFF);
332 if (skin_pants || skin_shirt)
335 saveskin = Hunk_AllocName(width*height, va("%s skin", loadname));
336 memcpy((saveskin, byte *)pskintype, width*height);
337 temp = (int) saveskin - (int) mheader;
338 skintexnum[0] = skin_normal ? -temp : 0;
339 skintexnum[1] = skin_pants ? -temp : 0;
340 skintexnum[2] = skin_shirt ? -temp : 0;
341 skintexnum[3] = GL_SkinSplit((byte *)pskintype, skintemp, width, height, 0xC000, va("%s_glow", basename)); // glow
342 skintexnum[4] = GL_SkinSplit((byte *)pskintype, skintemp, width, height, 0x3FFF, va("%s_body", basename)); // body (normal + pants + shirt, but not glow)
349 skintexnum[3] = GL_SkinSplit((byte *)pskintype, skintemp, width, height, 0xC000, va("%s_glow", basename)); // glow
350 skintexnum[4] = GL_SkinSplit((byte *)pskintype, skintemp, width, height, 0x3FFF, va("%s_body", basename)); // body (normal + pants + shirt, but not glow)
354 skintex[0] = loadtextureimage(va("%s_normal", basename), 0, 0, false, r_mipskins.value, true);
357 skintex[3] = loadtextureimage(va("%s_glow" , basename), 0, 0, false, r_mipskins.value, true);
361 skintex[1] = loadtextureimage(va("%s_pants" , basename), 0, 0, false, r_mipskins.value, true);
362 skintex[2] = loadtextureimage(va("%s_shirt" , basename), 0, 0, false, r_mipskins.value, true);
366 skintex[0] = loadtextureimage(basename, 0, 0, false, true, true);
369 skintex[1] = GL_SkinSplitShirt(skindata, skintemp, width, height, 0x0040, va("%s_pants", basename), false); // pants
370 skintex[2] = GL_SkinSplitShirt(skindata, skintemp, width, height, 0x0002, va("%s_shirt", basename), false); // shirt
371 skintex[3] = GL_SkinSplit(skindata, skintemp, width, height, 0xC000, va("%s_glow", basename), true); // glow
372 if (skintex[1] || skintex[2])
374 skintex[0] = GL_SkinSplit(skindata, skintemp, width, height, 0x3FBD, va("%s_normal", basename), false); // normal (no special colors)
375 skintex[4] = GL_SkinSplit(skindata, skintemp, width, height, 0x3FFF, va("%s_body", basename), true); // body (normal + pants + shirt, but not glow)
378 skintex[0] = GL_SkinSplit(skindata, skintemp, width, height, 0x3FFF, va("%s_base", basename), true); // no special colors
389 void *Mod_LoadAllSkins (maliashdr_t *mheader, int numskins, daliasskintype_t *pskintype, int width, int height)
395 daliasskingroup_t *pinskingroup;
397 daliasskininterval_t *pinskinintervals;
398 int skinranges, skincount, *skinrange, skinnum;
399 rtexture_t **skintex;
401 byte *skintemp = NULL;
403 skin = (byte *)(pskintype + 1);
405 if (numskins < 1 || numskins > MAX_SKINS)
406 Host_Error ("Mod_LoadAliasModel: Invalid # of skins: %d\n", numskins);
409 skintemp = qmalloc(s);
411 // LordHavoc: skim the data, measure the number of skins and number of groups
412 skinranges = numskins;
415 for (i = 0;i < numskins;i++)
418 if (pskintype[-1].type == ALIAS_SKIN_SINGLE)
421 (byte *)pskintype += s;
425 groupskins = LittleLong (((daliasskingroup_t *)pskintype)->numskins);
426 skincount += groupskins;
427 (byte *)pskintype += (s + sizeof(daliasskininterval_t)) * groupskins + sizeof(daliasskingroup_t);
432 skinrange = loadmodel->skinanimrange;
433 skintex = loadmodel->skinanim;
434 // skinrange = Hunk_AllocName (sizeof(int) * (skinranges + skincount), loadname);
435 // skintexnum = skinrange + skinranges * 2;
436 // loadmodel->skinanimrange = (int) skinrange - (int) pheader;
437 // loadmodel->skinanim = (int) skintexnum - (int) pheader;
439 for (i = 0;i < numskins;i++)
441 *skinrange++ = skinnum; // start of the range
443 if (pskintype[-1].type == ALIAS_SKIN_SINGLE)
445 *skinrange++ = 1; // single skin
447 sprintf (name, "%s_%i", loadmodel->name, i);
448 Mod_LoadSkin(mheader, name, (byte *)pskintype, skintemp, width, height, skintex);
450 pskintype = (daliasskintype_t *)((byte *)(pskintype) + s);
454 // animating skin group. yuck.
455 pinskingroup = (daliasskingroup_t *)pskintype;
456 groupskins = LittleLong (pinskingroup->numskins);
457 pinskinintervals = (daliasskininterval_t *)(pinskingroup + 1);
459 pskintype = (void *)(pinskinintervals + groupskins);
461 *skinrange++ = groupskins; // number of skins
462 skinnum += groupskins;
463 for (j = 0;j < groupskins;j++)
465 sprintf (name, "%s_%i_%i", loadmodel->name, i, j);
466 Mod_LoadSkin(mheader, name, (byte *)pskintype, skintemp, width, height, skintex);
468 pskintype = (daliasskintype_t *)((byte *)(pskintype) + s);
472 loadmodel->numskins = numskins;
475 return (void *)pskintype;
478 void *Mod_SkipAllSkins (int numskins, daliasskintype_t *pskintype, int skinsize)
481 for (i = 0;i < numskins;i++)
484 if (pskintype[-1].type == ALIAS_SKIN_SINGLE)
485 (byte *)pskintype += skinsize;
487 (byte *)pskintype += (skinsize + sizeof(daliasskininterval_t)) * LittleLong (((daliasskingroup_t *)pskintype)->numskins) + sizeof(daliasskingroup_t);
492 //=========================================================================
494 //void GL_MakeAliasModelDisplayLists (model_t *m, aliashdr_t *hdr);
501 #define BOUNDI(VALUE,MIN,MAX) if (VALUE < MIN || VALUE >= MAX) Host_Error("model %s has an invalid ##VALUE (%d exceeds %d - %d)\n", mod->name, VALUE, MIN, MAX);
502 #define BOUNDF(VALUE,MIN,MAX) if (VALUE < MIN || VALUE >= MAX) Host_Error("model %s has an invalid ##VALUE (%f exceeds %f - %f)\n", mod->name, VALUE, MIN, MAX);
503 void Mod_LoadAliasModel (model_t *mod, void *buffer)
505 int i, j, version, numframes, start, end, total, numverts, numtris, numposes, numskins, skinwidth, skinheight, f, totalverts;
507 stvert_t *pinstverts;
508 dtriangle_t *pintriangles;
509 daliasframetype_t *pframetype;
510 daliasskintype_t *pskintype;
511 float *pouttexcoords, scales, scalet;
512 maliashdr_t *mheader;
513 unsigned short *pouttris;
514 trivertx_t *posevert;
515 animscene_t *animscenes;
517 start = Hunk_LowMark ();
519 pinmodel = (mdl_t *)buffer;
521 version = LittleLong (pinmodel->version);
522 if (version != ALIAS_VERSION)
523 Host_Error ("%s has wrong version number (%i should be %i)",
524 mod->name, version, ALIAS_VERSION);
526 mod->type = mod_alias;
527 mod->aliastype = ALIASTYPE_MDL;
529 numframes = LittleLong(pinmodel->numframes);
530 BOUNDI(numframes,0,65536);
531 numverts = LittleLong(pinmodel->numverts);
532 BOUNDI(numverts,0,MAXALIASVERTS);
533 numtris = LittleLong(pinmodel->numtris);
534 BOUNDI(numtris,0,MAXALIASTRIS);
535 numskins = LittleLong(pinmodel->numskins);
536 BOUNDI(numskins,0,256);
537 skinwidth = LittleLong (pinmodel->skinwidth);
538 BOUNDI(skinwidth,0,4096);
539 skinheight = LittleLong (pinmodel->skinheight);
540 BOUNDI(skinheight,0,1024);
542 pskintype = (daliasskintype_t *)&pinmodel[1];
543 pinstverts = (stvert_t *)Mod_SkipAllSkins (numskins, pskintype, skinwidth * skinheight);
544 pintriangles = (dtriangle_t *)&pinstverts[numverts];
545 pframetype = (daliasframetype_t *)&pintriangles[numtris];
548 for (i=0 ; i<numframes ; i++)
550 if ((aliasframetype_t) LittleLong (pframetype->type) == ALIAS_SINGLE)
553 pframetype = (daliasframetype_t *)((int)pframetype + sizeof(daliasframetype_t) + (sizeof(daliasframe_t) + sizeof(trivertx_t) * numverts) );
557 f = LittleLong (((daliasgroup_t *)((int)pframetype + sizeof(daliasframetype_t)))->numframes);
559 pframetype = (daliasframetype_t *)((int)pframetype + sizeof(daliasframetype_t) + sizeof(daliasgroup_t) + (sizeof(daliasframe_t) + sizeof(daliasinterval_t) + sizeof(trivertx_t) * numverts) * f);
564 mheader = Hunk_AllocName (sizeof(maliashdr_t), va("%s model header", loadname));
565 mod->flags = LittleLong (pinmodel->flags);
566 // endian-adjust and copy the data, starting with the alias model header
567 mheader->numverts = numverts;
568 mod->numtris = mheader->numtris = numtris;
569 mod->numframes = mheader->numframes = numframes;
570 mod->synctype = LittleLong (pinmodel->synctype);
571 BOUNDI(mod->synctype,0,2);
573 for (i=0 ; i<3 ; i++)
575 mheader->scale[i] = LittleFloat (pinmodel->scale[i]);
576 BOUNDF(mheader->scale[i],0,65536);
577 mheader->scale_origin[i] = LittleFloat (pinmodel->scale_origin[i]);
578 BOUNDF(mheader->scale_origin[i],-65536,65536);
582 pskintype = (daliasskintype_t *)&pinmodel[1];
583 pskintype = Mod_LoadAllSkins(mheader, numskins, pskintype, skinwidth, skinheight);
585 // store texture coordinates into temporary array, they will be stored after usage is determined (triangle data)
586 pinstverts = (stvert_t *)pskintype;
588 // LordHavoc: byteswap and convert stvert data
589 scales = 1.0 / skinwidth;
590 scalet = 1.0 / skinheight;
591 for (i = 0;i < numverts;i++)
593 vertonseam[i] = LittleLong(pinstverts[i].onseam);
594 vertst[i][0] = LittleLong(pinstverts[i].s) * scales;
595 vertst[i][1] = LittleLong(pinstverts[i].t) * scalet;
596 vertst[i+numverts][0] = vertst[i][0] + 0.5;
597 vertst[i+numverts][1] = vertst[i][1];
599 vertusage[i+numverts] = 0;
602 // load triangle data
603 pouttris = Hunk_AllocName(sizeof(unsigned short[3]) * numtris, va("%s triangles", loadname));
604 mheader->tridata = (int) pouttris - (int) mheader;
605 pintriangles = (dtriangle_t *)&pinstverts[mheader->numverts];
607 // count the vertices used
608 for (i = 0;i < numverts*2;i++)
610 for (i = 0;i < numtris;i++)
612 temptris[i][0] = LittleLong(pintriangles[i].vertindex[0]);
613 temptris[i][1] = LittleLong(pintriangles[i].vertindex[1]);
614 temptris[i][2] = LittleLong(pintriangles[i].vertindex[2]);
615 if (!LittleLong(pintriangles[i].facesfront)) // backface
617 if (vertonseam[temptris[i][0]]) temptris[i][0] += numverts;
618 if (vertonseam[temptris[i][1]]) temptris[i][1] += numverts;
619 if (vertonseam[temptris[i][2]]) temptris[i][2] += numverts;
621 vertusage[temptris[i][0]]++;
622 vertusage[temptris[i][1]]++;
623 vertusage[temptris[i][2]]++;
625 // build remapping table and compact array
627 for (i = 0;i < numverts*2;i++)
631 vertremap[i] = totalverts;
632 vertst[totalverts][0] = vertst[i][0];
633 vertst[totalverts][1] = vertst[i][1];
637 vertremap[i] = -1; // not used at all
639 mheader->numverts = totalverts;
640 // remap the triangle references
641 for (i = 0;i < numtris;i++)
643 *pouttris++ = vertremap[temptris[i][0]];
644 *pouttris++ = vertremap[temptris[i][1]];
645 *pouttris++ = vertremap[temptris[i][2]];
647 // store the texture coordinates
648 pouttexcoords = Hunk_AllocName(sizeof(float[2]) * totalverts, va("%s texcoords", loadname));
649 mheader->texdata = (int) pouttexcoords - (int) mheader;
650 for (i = 0;i < totalverts;i++)
652 *pouttexcoords++ = vertst[i][0];
653 *pouttexcoords++ = vertst[i][1];
658 posevert = Hunk_AllocName(sizeof(trivertx_t) * numposes * totalverts, va("%s vertex data", loadname));
659 mheader->posedata = (int) posevert - (int) mheader;
660 pframetype = (daliasframetype_t *)&pintriangles[numtris];
662 // LordHavoc: doing proper bbox for model
663 aliasbboxmin[0] = aliasbboxmin[1] = aliasbboxmin[2] = 1000000000;
664 aliasbboxmax[0] = aliasbboxmax[1] = aliasbboxmax[2] = -1000000000;
666 animscenes = Hunk_AllocName(sizeof(animscene_t) * mod->numframes, va("%s sceneinfo", loadname));
668 for (i = 0;i < numframes;i++)
670 if ((aliasframetype_t) LittleLong (pframetype->type) == ALIAS_SINGLE)
671 pframetype = (daliasframetype_t *) Mod_LoadAliasFrame (pframetype + 1, mheader, numverts, totalverts, &posevert, animscenes + i);
673 pframetype = (daliasframetype_t *) Mod_LoadAliasGroup (pframetype + 1, mheader, numverts, totalverts, &posevert, animscenes + i);
676 mod->ofs_scenes = (int) animscenes - (int) mheader;
678 // LordHavoc: fixed model bbox - was //FIXME: do this right
679 //mod->mins[0] = mod->mins[1] = mod->mins[2] = -16;
680 //mod->maxs[0] = mod->maxs[1] = mod->maxs[2] = 16;
681 for (j = 0;j < 3;j++)
683 mod->mins[j] = aliasbboxmin[j];
684 mod->maxs[j] = aliasbboxmax[j];
687 // move the complete, relocatable alias model to the cache
688 end = Hunk_LowMark ();
689 mod->cachesize = total = end - start;
691 Cache_Alloc (&mod->cache, total, loadname);
692 if (!mod->cache.data)
694 memcpy (mod->cache.data, mheader, total);
696 Hunk_FreeToLowMark (start);
699 void Mod_ConvertQ2AliasVerts (int numverts, vec3_t scale, vec3_t translate, trivertx_t *v, trivertx_t *out)
701 int i, invalidnormals = 0;
703 for (i = 0;i < numverts;i++)
705 VectorCopy(v[i].v, out[i].v);
706 temp[0] = v[i].v[0] * scale[0] + translate[0];
707 temp[1] = v[i].v[1] * scale[1] + translate[1];
708 temp[2] = v[i].v[2] * scale[2] + translate[2];
709 // update bounding box
710 if (temp[0] < aliasbboxmin[0]) aliasbboxmin[0] = temp[0];
711 if (temp[1] < aliasbboxmin[1]) aliasbboxmin[1] = temp[1];
712 if (temp[2] < aliasbboxmin[2]) aliasbboxmin[2] = temp[2];
713 if (temp[0] > aliasbboxmax[0]) aliasbboxmax[0] = temp[0];
714 if (temp[1] > aliasbboxmax[1]) aliasbboxmax[1] = temp[1];
715 if (temp[2] > aliasbboxmax[2]) aliasbboxmax[2] = temp[2];
716 out[i].lightnormalindex = v[i].lightnormalindex;
717 if (out[i].lightnormalindex >= NUMVERTEXNORMALS)
720 out[i].lightnormalindex = 0;
724 Con_Printf("Mod_ConvertQ2AliasVerts: \"%s\", %i invalid normal indices found\n", loadname, invalidnormals);
732 void Mod_LoadQ2AliasModel (model_t *mod, void *buffer)
734 int i, j, version, size, *pinglcmd, *poutglcmd, start, end, total, framesize;
737 md2triangle_t *pintriangles, *pouttriangles;
738 md2frame_t *pinframe;
739 md2frame_t *poutframe;
742 animscene_t *animscenes;
744 start = Hunk_LowMark ();
747 // temptris = qmalloc(sizeof(temptris_t) * MD2MAX_TRIANGLES);
749 pinmodel = (md2_t *)buffer;
751 version = LittleLong (pinmodel->version);
752 if (version != MD2ALIAS_VERSION)
753 Host_Error ("%s has wrong version number (%i should be %i)",
754 mod->name, version, MD2ALIAS_VERSION);
756 mod->type = mod_alias;
757 mod->aliastype = ALIASTYPE_MD2;
759 framesize = sizeof(md2framesize_t) + LittleLong(pinmodel->num_xyz) * sizeof(trivertx_t);
760 // LordHavoc: calculate size for in memory version
761 size = sizeof(md2mem_t)
762 + LittleLong(pinmodel->num_st) * sizeof(md2stvert_t)
763 + LittleLong(pinmodel->num_tris) * sizeof(md2triangle_t)
764 + LittleLong(pinmodel->num_frames) * framesize
765 + LittleLong(pinmodel->num_glcmds) * sizeof(int);
766 if (size <= 0 || size >= MD2MAX_SIZE)
767 Host_Error ("%s is not a valid model", mod->name);
768 pheader = Hunk_AllocName (size, va("%s Quake2 model", loadname));
770 mod->flags = 0; // there are no MD2 flags
771 mod->numframes = LittleLong(pinmodel->num_frames);
772 mod->synctype = ST_RAND;
773 mod->numtris = LittleLong(pinmodel->num_tris); // LordHavoc: to simplify renderer decisions
775 if (LittleLong(pinmodel->num_skins) >= 1 && (LittleLong(pinmodel->ofs_skins <= 0) || LittleLong(pinmodel->ofs_skins) >= LittleLong(pinmodel->ofs_end)))
776 Host_Error ("%s is not a valid model", mod->name);
777 if (LittleLong(pinmodel->ofs_st <= 0) || LittleLong(pinmodel->ofs_st) >= LittleLong(pinmodel->ofs_end))
778 Host_Error ("%s is not a valid model", mod->name);
779 if (LittleLong(pinmodel->ofs_tris <= 0) || LittleLong(pinmodel->ofs_tris) >= LittleLong(pinmodel->ofs_end))
780 Host_Error ("%s is not a valid model", mod->name);
781 if (LittleLong(pinmodel->ofs_frames <= 0) || LittleLong(pinmodel->ofs_frames) >= LittleLong(pinmodel->ofs_end))
782 Host_Error ("%s is not a valid model", mod->name);
783 if (LittleLong(pinmodel->ofs_glcmds <= 0) || LittleLong(pinmodel->ofs_glcmds) >= LittleLong(pinmodel->ofs_end))
784 Host_Error ("%s is not a valid model", mod->name);
786 if (LittleLong(pinmodel->num_tris < 1) || LittleLong(pinmodel->num_tris) > MD2MAX_TRIANGLES)
787 Host_Error ("%s has invalid number of triangles: %i", mod->name, LittleLong(pinmodel->num_tris));
788 if (LittleLong(pinmodel->num_xyz < 1) || LittleLong(pinmodel->num_xyz) > MD2MAX_VERTS)
789 Host_Error ("%s has invalid number of vertices: %i", mod->name, LittleLong(pinmodel->num_xyz));
790 if (LittleLong(pinmodel->num_frames < 1) || LittleLong(pinmodel->num_frames) > MD2MAX_FRAMES)
791 Host_Error ("%s has invalid number of frames: %i", mod->name, LittleLong(pinmodel->num_frames));
792 if (LittleLong(pinmodel->num_skins < 0) || LittleLong(pinmodel->num_skins) > MAX_SKINS)
793 Host_Error ("%s has invalid number of skins: %i", mod->name, LittleLong(pinmodel->num_skins));
795 pheader->framesize = framesize;
796 pheader->num_skins = LittleLong(pinmodel->num_skins);
797 pheader->num_xyz = LittleLong(pinmodel->num_xyz);
798 pheader->num_st = LittleLong(pinmodel->num_st);
799 pheader->num_tris = LittleLong(pinmodel->num_tris);
800 pheader->num_frames = LittleLong(pinmodel->num_frames);
801 pheader->num_glcmds = LittleLong(pinmodel->num_glcmds);
804 if (pheader->num_skins)
808 skinrange = loadmodel->skinanimrange;
809 skin = loadmodel->skinanim;
810 // skinrange = Hunk_AllocName (sizeof(int) * (pheader->num_skins * 2), loadname);
811 // skin = skinrange + pheader->num_skins * 2;
812 // loadmodel->skinanimrange = (int) skinrange - (int) pheader;
813 // loadmodel->skinanim = (int) skin - (int) pheader;
814 pinskins = (void*)((int) pinmodel + LittleLong(pinmodel->ofs_skins));
815 for (i = 0;i < pheader->num_skins;i++)
819 *skin++ = loadtextureimage (pinskins, 0, 0, true, r_mipskins.value, true);
820 *skin++ = NULL; // the extra 4 layers are currently unused
824 pinskins += MD2MAX_SKINNAME;
827 loadmodel->numskins = pheader->num_skins;
830 pintriangles = (void*)((int) pinmodel + LittleLong(pinmodel->ofs_tris));
831 pouttriangles = (void*)&pheader[1];
832 pheader->ofs_tris = (int) pouttriangles - (int) pheader;
834 // swap the triangle list
835 for (i = 0;i < pheader->num_tris;i++)
837 for (j = 0;j < 3;j++)
839 temptris[i][j] = pouttriangles->index_xyz[j] = LittleShort (pintriangles->index_xyz[j]);
840 pouttriangles->index_st[j] = LittleShort (pintriangles->index_st[j]);
841 if (pouttriangles->index_xyz[j] >= pheader->num_xyz)
842 Host_Error ("%s has invalid vertex indices", mod->name);
843 if (pouttriangles->index_st[j] >= pheader->num_st)
844 Host_Error ("%s has invalid vertex indices", mod->name);
850 // LordHavoc: doing proper bbox for model
851 aliasbboxmin[0] = aliasbboxmin[1] = aliasbboxmin[2] = 1000000000;
852 aliasbboxmax[0] = aliasbboxmax[1] = aliasbboxmax[2] = -1000000000;
855 pinframe = (void*) ((int) pinmodel + LittleLong(pinmodel->ofs_frames));
856 poutframe = (void*) pouttriangles;
857 pheader->ofs_frames = (int) poutframe - (int) pheader;
859 animscenes = Hunk_AllocName(sizeof(animscene_t) * mod->numframes, va("%s sceneinfo", loadname));
861 for (i = 0;i < pheader->num_frames;i++)
863 strcpy(poutframe->name, pinframe->name);
864 for (j = 0;j < 3;j++)
866 poutframe->scale[j] = LittleFloat(pinframe->scale[j]);
867 poutframe->translate[j] = LittleFloat(pinframe->translate[j]);
869 Mod_ConvertQ2AliasVerts (pheader->num_xyz, poutframe->scale, poutframe->translate, &pinframe->verts[0], &poutframe->verts[0]);
871 strcpy(animscenes[i].name, poutframe->name);
872 animscenes[i].firstframe = i;
873 animscenes[i].framecount = 1;
874 animscenes[i].framerate = 10;
875 animscenes[i].loop = true;
877 pinframe = (void*) &pinframe->verts[j];
878 poutframe = (void*) &poutframe->verts[j];
881 mod->ofs_scenes = (int) animscenes - (int) pheader;
883 // LordHavoc: model bbox
884 for (j = 0;j < 3;j++)
886 mod->mins[j] = aliasbboxmin[j];
887 mod->maxs[j] = aliasbboxmax[j];
890 // load the draw list
891 pinglcmd = (void*) ((int) pinmodel + LittleLong(pinmodel->ofs_glcmds));
892 poutglcmd = (void*) poutframe;
893 pheader->ofs_glcmds = (int) poutglcmd - (int) pheader;
894 for (i = 0;i < pheader->num_glcmds;i++)
895 *poutglcmd++ = LittleLong(*pinglcmd++);
897 // move the complete, relocatable alias model to the cache
898 end = Hunk_LowMark ();
899 mod->cachesize = total = end - start;
901 Cache_Alloc (&mod->cache, total, loadname);
902 if (!mod->cache.data)
904 memcpy (mod->cache.data, pheader, total);
906 Hunk_FreeToLowMark (start);
909 void swapintblock(int *m, int size)
916 void Mod_LoadZymoticModel (model_t *mod, void *buffer)
918 int i, pbase, start, end, total, *skinrange;
919 rtexture_t **texture, **skin;
921 zymtype1header_t *pinmodel, *pheader;
924 animscene_t *animscenes;
926 start = Hunk_LowMark ();
928 pinmodel = (void *)buffer;
930 if (memcmp(pinmodel->id, "ZYMOTICMODEL", 12))
931 Host_Error ("Mod_LoadZymoticModel: %s is not a zymotic model\n");
933 if (BigLong(pinmodel->type) != 1)
934 Host_Error ("Mod_LoadZymoticModel: only type 1 (skeletal pose) models are currently supported\n");
936 mod->type = mod_alias;
937 mod->aliastype = ALIASTYPE_ZYM;
939 pheader = Hunk_AllocName (BigLong(pinmodel->filesize), va("%s Zymotic model", loadname));
941 pbase = (int) pheader;
943 memcpy(pheader, pinmodel, BigLong(pinmodel->filesize));
946 memcpy(pheader->id, pinmodel->id, 12);
947 pheader->type = BigLong(pheader->type);
948 pheader->filesize = BigLong(pheader->filesize);
949 pheader->mins[0] = BigFloat(pheader->mins[0]);
950 pheader->mins[1] = BigFloat(pheader->mins[1]);
951 pheader->mins[2] = BigFloat(pheader->mins[2]);
952 pheader->maxs[0] = BigFloat(pheader->maxs[0]);
953 pheader->maxs[1] = BigFloat(pheader->maxs[1]);
954 pheader->maxs[2] = BigFloat(pheader->maxs[2]);
955 pheader->radius = BigFloat(pheader->radius);
956 pheader->numverts = BigLong(pheader->numverts);
957 pheader->numtris = BigLong(pheader->numtris);
958 pheader->numshaders = BigLong(pheader->numshaders);
959 pheader->numbones = BigLong(pheader->numbones);
960 pheader->numscenes = BigLong(pheader->numscenes);
963 pheader->lump_scenes.start = BigLong(pheader->lump_scenes.start);pheader->lump_scenes.length = BigLong(pheader->lump_scenes.length);
964 pheader->lump_poses.start = BigLong(pheader->lump_poses.start);pheader->lump_poses.length = BigLong(pheader->lump_poses.length);
965 pheader->lump_bones.start = BigLong(pheader->lump_bones.start);pheader->lump_bones.length = BigLong(pheader->lump_bones.length);
966 pheader->lump_vertbonecounts.start = BigLong(pheader->lump_vertbonecounts.start);pheader->lump_vertbonecounts.length = BigLong(pheader->lump_vertbonecounts.length);
967 pheader->lump_verts.start = BigLong(pheader->lump_verts.start);pheader->lump_verts.length = BigLong(pheader->lump_verts.length);
968 pheader->lump_texcoords.start = BigLong(pheader->lump_texcoords.start);pheader->lump_texcoords.length = BigLong(pheader->lump_texcoords.length);
969 pheader->lump_render.start = BigLong(pheader->lump_render.start);pheader->lump_render.length = BigLong(pheader->lump_render.length);
970 pheader->lump_shaders.start = BigLong(pheader->lump_shaders.start);pheader->lump_shaders.length = BigLong(pheader->lump_shaders.length);
971 pheader->lump_trizone.start = BigLong(pheader->lump_trizone.start);pheader->lump_trizone.length = BigLong(pheader->lump_trizone.length);
973 mod->flags = 0; // there are no flags
974 mod->numframes = pheader->numscenes;
975 mod->synctype = ST_SYNC;
976 mod->numtris = pheader->numtris;
978 // FIXME: add skin support and texturing and shaders and...
980 skinrange = loadmodel->skinanimrange;
981 skin = loadmodel->skinanim;
982 // skinrange = Hunk_AllocName (sizeof(int) * (pheader->num_skins * 2), loadname);
983 // skin = skinrange + pheader->num_skins * 2;
984 // loadmodel->skinanimrange = (int) skinrange - (int) pheader;
985 // loadmodel->skinanim = (int) skin - (int) pheader;
993 loadmodel->numskins = 1;
995 // go through the lumps, swapping things
997 // zymlump_t lump_scenes; // zymscene_t scene[numscenes]; // name and other information for each scene (see zymscene struct)
998 scene = (void *) (pheader->lump_scenes.start + pbase);
999 animscenes = Hunk_AllocName(sizeof(animscene_t) * mod->numframes, va("%s sceneinfo", loadname));
1000 for (i = 0;i < pheader->numscenes;i++)
1002 scene->mins[0] = BigFloat(scene->mins[0]);
1003 scene->mins[1] = BigFloat(scene->mins[1]);
1004 scene->mins[2] = BigFloat(scene->mins[2]);
1005 scene->maxs[0] = BigFloat(scene->maxs[0]);
1006 scene->maxs[1] = BigFloat(scene->maxs[1]);
1007 scene->maxs[2] = BigFloat(scene->maxs[2]);
1008 scene->radius = BigFloat(scene->radius);
1009 scene->framerate = BigFloat(scene->framerate);
1010 scene->flags = BigLong(scene->flags);
1011 scene->start = BigLong(scene->start);
1012 scene->length = BigLong(scene->length);
1014 memcpy(animscenes[i].name, scene->name, 32);
1015 animscenes[i].firstframe = scene->start;
1016 animscenes[i].framecount = scene->length;
1017 animscenes[i].framerate = scene->framerate;
1018 animscenes[i].loop = (scene->flags & ZYMSCENEFLAG_NOLOOP) == 0;
1022 mod->ofs_scenes = (int) animscenes - pbase;
1024 // zymlump_t lump_poses; // float pose[numposes][numbones][3][4]; // animation data
1025 swapintblock((void *) (pheader->lump_poses.start + pbase), pheader->lump_poses.length);
1027 // zymlump_t lump_bones; // zymbone_t bone[numbones];
1028 bone = (void *) (pheader->lump_bones.start + pbase);
1029 for (i = 0;i < pheader->numbones;i++)
1031 bone->flags = BigLong(bone->flags);
1032 bone->parent = BigLong(bone->parent);
1036 // zymlump_t lump_vertbonecounts; // int vertbonecounts[numvertices]; // how many bones influence each vertex (separate mainly to make this compress better)
1037 swapintblock((void *) (pheader->lump_vertbonecounts.start + pbase), pheader->lump_vertbonecounts.length);
1039 // zymlump_t lump_verts; // zymvertex_t vert[numvertices]; // see vertex struct
1040 swapintblock((void *) (pheader->lump_verts.start + pbase), pheader->lump_verts.length);
1042 // zymlump_t lump_texcoords; // float texcoords[numvertices][2];
1043 swapintblock((void *) (pheader->lump_texcoords.start + pbase), pheader->lump_texcoords.length);
1045 // zymlump_t lump_render; // int renderlist[rendersize]; // sorted by shader with run lengths (int count), shaders are sequentially used, each run can be used with glDrawElements (each triangle is 3 int indices)
1046 swapintblock((void *) (pheader->lump_render.start + pbase), pheader->lump_render.length);
1048 // zymlump_t lump_shaders; // char shadername[numshaders][32]; // shaders used on this model
1049 shadername = (void *) (pheader->lump_shaders.start + pbase);
1050 texture = (void *) shadername;
1051 for (i = 0;i < pheader->numshaders;i++)
1054 rt = loadtextureimage(shadername, 0, 0, true, r_mipskins.value, true);
1056 *texture++ = rt; // reuse shader name list for texture pointers
1059 // zymlump_t lump_trizone; // byte trizone[numtris]; // see trizone explanation
1060 swapintblock((void *) (pheader->lump_trizone.start + pbase), pheader->lump_trizone.length);
1063 for (i = 0;i < 3;i++)
1065 mod->mins[i] = pheader->mins[i];
1066 mod->maxs[i] = pheader->maxs[i];
1069 // move the complete, relocatable alias model to the cache
1070 end = Hunk_LowMark ();
1071 mod->cachesize = total = end - start;
1073 Cache_Alloc (&mod->cache, total, loadname);
1074 if (!mod->cache.data)
1076 memcpy (mod->cache.data, pheader, total);
1078 Hunk_FreeToLowMark (start);