model_alias.c

   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
  21 #include "quakedef.h"
  22
  23 cvar_t r_mipskins = {"r_mipskins", "1", true};
  24
  25 /*
  26 ===============
  27 Mod_AliasInit
  28 ===============
  29 */
  30 void Mod_AliasInit (void)
  31 {
  32         Cvar_RegisterVariable(&r_mipskins);
  33 }
  34
  35 int                     posenum;
  36
  37 float           aliasbboxmin[3], aliasbboxmax[3]; // LordHavoc: proper bounding box considerations
  38
  39 float vertst[MAXALIASVERTS][2];
  40 int vertusage[MAXALIASVERTS];
  41 int vertonseam[MAXALIASVERTS];
  42 int vertremap[MAXALIASVERTS];
  43 unsigned short temptris[MAXALIASTRIS][3];
  44
  45 void Mod_ConvertAliasVerts (int inverts, vec3_t scale, vec3_t translate, trivertx_t *v, trivertx_t *out)
  46 {
  47         int i, j, invalidnormals = 0;
  48         vec3_t temp;
  49         for (i = 0;i < inverts;i++)
  50         {
  51                 if (vertremap[i] < 0 && vertremap[i+inverts] < 0) // only used vertices need apply...
  52                         continue;
  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
  64                 if (j >= 0)
  65                 {
  66                         VectorCopy(v[i].v, out[j].v);
  67                         out[j].lightnormalindex = v[i].lightnormalindex;
  68                         if (out[j].lightnormalindex >= NUMVERTEXNORMALS)
  69                         {
  70                                 invalidnormals++;
  71                                 out[j].lightnormalindex = 0;
  72                         }
  73                 }
  74                 j = vertremap[i+inverts]; // onseam
  75                 if (j >= 0)
  76                 {
  77                         VectorCopy(v[i].v, out[j].v);
  78                         out[j].lightnormalindex = v[i].lightnormalindex;
  79                         if (out[j].lightnormalindex >= NUMVERTEXNORMALS)
  80                         {
  81                                 invalidnormals++;
  82                                 out[j].lightnormalindex = 0;
  83                         }
  84                 }
  85         }
  86         if (invalidnormals)
  87                 Con_Printf("Mod_ConvertAliasVerts: \"%s\", %i invalid normal indices found\n", loadname, invalidnormals);
  88 }
  89
  90 /*
  91 =================
  92 Mod_LoadAliasFrame
  93 =================
  94 */
  95 void * Mod_LoadAliasFrame (void *pin, maliashdr_t *mheader, int inverts, int outverts, trivertx_t **posevert, animscene_t *scene)
  96 {
  97         trivertx_t              *pinframe;
  98         daliasframe_t   *pdaliasframe;
  99
 100         pdaliasframe = (daliasframe_t *)pin;
 101
 102         strcpy(scene->name, pdaliasframe->name);
 103         scene->firstframe = posenum;
 104         scene->framecount = 1;
 105         scene->framerate = 10.0f; // unnecessary but...
 106         scene->loop = true;
 107
 108         pinframe = (trivertx_t *)(pdaliasframe + 1);
 109
 110         Mod_ConvertAliasVerts(inverts, mheader->scale, mheader->scale_origin, pinframe, *posevert);
 111         *posevert += outverts;
 112         posenum++;
 113
 114         pinframe += inverts;
 115
 116         return (void *)pinframe;
 117 }
 118
 119
 120 /*
 121 =================
 122 Mod_LoadAliasGroup
 123 =================
 124 */
 125 void *Mod_LoadAliasGroup (void *pin, maliashdr_t *mheader, int inverts, int outverts, trivertx_t **posevert, animscene_t *scene)
 126 {
 127         int             i, numframes;
 128         void    *ptemp;
 129         float   interval;
 130
 131         numframes = LittleLong (((daliasgroup_t *)pin)->numframes);
 132
 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;
 140         scene->loop = true;
 141
 142         ptemp = (void *)(((daliasinterval_t *)(((daliasgroup_t *)pin) + 1)) + numframes);
 143
 144         for (i=0 ; i<numframes ; i++)
 145         {
 146                 ((daliasframe_t *)ptemp)++;
 147                 Mod_ConvertAliasVerts(inverts, mheader->scale, mheader->scale_origin, ptemp, *posevert);
 148                 *posevert += outverts;
 149                 posenum++;
 150                 ptemp = (trivertx_t *)ptemp + inverts;
 151         }
 152
 153         return ptemp;
 154 }
 155
 156 //=========================================================
 157
 158 /*
 159 =================
 160 Mod_FloodFillSkin
 161
 162 Fill background pixels so mipmapping doesn't have haloes - Ed
 163 =================
 164 */
 165
 166 typedef struct
 167 {
 168         short           x, y;
 169 } floodfill_t;
 170
 171 // must be a power of 2
 172 #define FLOODFILL_FIFO_SIZE 0x1000
 173 #define FLOODFILL_FIFO_MASK (FLOODFILL_FIFO_SIZE - 1)
 174
 175 #define FLOODFILL_STEP( off, dx, dy ) \
 176 { \
 177         if (pos[off] == fillcolor) \
 178         { \
 179                 pos[off] = 255; \
 180                 fifo[inpt].x = x + (dx), fifo[inpt].y = y + (dy); \
 181                 inpt = (inpt + 1) & FLOODFILL_FIFO_MASK; \
 182         } \
 183         else if (pos[off] != 255) fdc = pos[off]; \
 184 }
 185
 186 void Mod_FloodFillSkin( byte *skin, int skinwidth, int skinheight )
 187 {
 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;
 192         int                                     i;
 193
 194         if (filledcolor == -1)
 195         {
 196                 filledcolor = 0;
 197                 // attempt to find opaque black
 198                 for (i = 0; i < 256; ++i)
 199                         if (d_8to24table[i] == (255 << 0)) // alpha 1.0
 200                         {
 201                                 filledcolor = i;
 202                                 break;
 203                         }
 204         }
 205
 206         // can't fill to filled color or to transparent color (used as visited marker)
 207         if ((fillcolor == filledcolor) || (fillcolor == 255))
 208         {
 209                 //printf( "not filling skin from %d to %d\n", fillcolor, filledcolor );
 210                 return;
 211         }
 212
 213         fifo[inpt].x = 0, fifo[inpt].y = 0;
 214         inpt = (inpt + 1) & FLOODFILL_FIFO_MASK;
 215
 216         while (outpt != inpt)
 217         {
 218                 int                     x = fifo[outpt].x, y = fifo[outpt].y;
 219                 int                     fdc = filledcolor;
 220                 byte            *pos = &skin[x + skinwidth * y];
 221
 222                 outpt = (outpt + 1) & FLOODFILL_FIFO_MASK;
 223
 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;
 229         }
 230 }
 231
 232 rtexture_t *GL_SkinSplitShirt(byte *in, byte *out, int width, int height, unsigned short bits, char *name, int precache)
 233 {
 234         int i, pixels, passed;
 235         byte pixeltest[16];
 236         for (i = 0;i < 16;i++)
 237                 pixeltest[i] = (bits & (1 << i)) != 0;
 238         pixels = width*height;
 239         passed = 0;
 240         while(pixels--)
 241         {
 242                 if (pixeltest[*in >> 4] && *in != 0 && *in != 255)
 243                 {
 244                         passed++;
 245                         // turn to white while copying
 246                         if (*in >= 128 && *in < 224) // backwards ranges
 247                                 *out = (*in & 15) ^ 15;
 248                         else
 249                                 *out = *in & 15;
 250                 }
 251                 else
 252                         *out = 0;
 253                 in++;
 254                 out++;
 255         }
 256         if (passed)
 257                 return R_LoadTexture (name, width, height, out - width*height, (r_mipskins.value ? TEXF_MIPMAP : 0) | (precache ? TEXF_PRECACHE : 0));
 258         else
 259                 return NULL;
 260 }
 261
 262 rtexture_t *GL_SkinSplit(byte *in, byte *out, int width, int height, unsigned short bits, char *name, int precache)
 263 {
 264         int i, pixels, passed;
 265         byte pixeltest[16];
 266         for (i = 0;i < 16;i++)
 267                 pixeltest[i] = (bits & (1 << i)) != 0;
 268         pixels = width*height;
 269         passed = 0;
 270         while(pixels--)
 271         {
 272                 if (pixeltest[*in >> 4] && *in != 0 && *in != 255)
 273                 {
 274                         passed++;
 275                         *out = *in;
 276                 }
 277                 else
 278                         *out = 0;
 279                 in++;
 280                 out++;
 281         }
 282         if (passed)
 283                 return R_LoadTexture (name, width, height, out - width*height, (r_mipskins.value ? TEXF_MIPMAP : 0) | (precache ? TEXF_PRECACHE : 0));
 284         else
 285                 return NULL;
 286 }
 287
 288 int GL_SkinCheck(byte *in, int width, int height, unsigned short bits)
 289 {
 290         int i, pixels, passed;
 291         byte pixeltest[16];
 292         for (i = 0;i < 16;i++)
 293                 pixeltest[i] = (bits & (1 << i)) != 0;
 294         pixels = width*height;
 295         passed = 0;
 296         while(pixels--)
 297         {
 298                 if (pixeltest[*in >> 4] && *in != 0 && *in != 255)
 299                         return true;
 300                 in++;
 301         }
 302         return false;
 303 }
 304
 305 void Mod_LoadSkin (maliashdr_t *mheader, char *basename, byte *skindata, byte *skintemp, int width, int height, rtexture_t **skintex)
 306 {
 307 #if 0
 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)
 317         {
 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;
 323         }
 324         else
 325         {
 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)
 333                 {
 334                         byte *saveskin;
 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)
 343                 }
 344                 else
 345                 {
 346                         skintexnum[0] = 0;
 347                         skintexnum[1] = 0;
 348                         skintexnum[2] = 0;
 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)
 351                 }
 352         }
 353 #else
 354         skintex[0] = loadtextureimage(va("%s_normal", basename), 0, 0, false, r_mipskins.value, true);
 355         skintex[1] = NULL;
 356         skintex[2] = NULL;
 357         skintex[3] = loadtextureimage(va("%s_glow"  , basename), 0, 0, false, r_mipskins.value, true);
 358         skintex[4] = NULL;
 359         if (skintex[0])
 360         {
 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);
 363         }
 364         else
 365         {
 366                 skintex[0] = loadtextureimage(basename, 0, 0, false, true, true);
 367                 if (!skintex[0])
 368                 {
 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])
 373                         {
 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)
 376                         }
 377                         else
 378                                 skintex[0] = GL_SkinSplit(skindata, skintemp, width, height, 0x3FFF, va("%s_base", basename), true); // no special colors
 379                 }
 380         }
 381 #endif
 382 }
 383
 384 /*
 385 ===============
 386 Mod_LoadAllSkins
 387 ===============
 388 */
 389 void *Mod_LoadAllSkins (maliashdr_t *mheader, int numskins, daliasskintype_t *pskintype, int width, int height)
 390 {
 391         int             i, j;
 392         char    name[32];
 393         int             s;
 394         byte    *skin;
 395         daliasskingroup_t               *pinskingroup;
 396         int             groupskins;
 397         daliasskininterval_t    *pinskinintervals;
 398         int             skinranges, skincount, *skinrange, skinnum;
 399         rtexture_t **skintex;
 400         void    *temp;
 401         byte    *skintemp = NULL;
 402
 403         skin = (byte *)(pskintype + 1);
 404
 405         if (numskins < 1 || numskins > MAX_SKINS)
 406                 Host_Error ("Mod_LoadAliasModel: Invalid # of skins: %d\n", numskins);
 407
 408         s = width * height;
 409         skintemp = qmalloc(s);
 410
 411         // LordHavoc: skim the data, measure the number of skins and number of groups
 412         skinranges = numskins;
 413         skincount = 0;
 414         temp = pskintype;
 415         for (i = 0;i < numskins;i++)
 416         {
 417                 pskintype++;
 418                 if (pskintype[-1].type == ALIAS_SKIN_SINGLE)
 419                 {
 420                         skincount++;
 421                         (byte *)pskintype += s;
 422                 }
 423                 else
 424                 {
 425                         groupskins = LittleLong (((daliasskingroup_t *)pskintype)->numskins);
 426                         skincount += groupskins;
 427                         (byte *)pskintype += (s + sizeof(daliasskininterval_t)) * groupskins + sizeof(daliasskingroup_t);
 428                 }
 429         }
 430         pskintype = temp;
 431
 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;
 438         skinnum = 0;
 439         for (i = 0;i < numskins;i++)
 440         {
 441                 *skinrange++ = skinnum; // start of the range
 442                 pskintype++;
 443                 if (pskintype[-1].type == ALIAS_SKIN_SINGLE)
 444                 {
 445                         *skinrange++ = 1; // single skin
 446                         skinnum++;
 447                         sprintf (name, "%s_%i", loadmodel->name, i);
 448                         Mod_LoadSkin(mheader, name, (byte *)pskintype, skintemp, width, height, skintex);
 449                         skintex += 5;
 450                         pskintype = (daliasskintype_t *)((byte *)(pskintype) + s);
 451                 }
 452                 else
 453                 {
 454                         // animating skin group.  yuck.
 455                         pinskingroup = (daliasskingroup_t *)pskintype;
 456                         groupskins = LittleLong (pinskingroup->numskins);
 457                         pinskinintervals = (daliasskininterval_t *)(pinskingroup + 1);
 458
 459                         pskintype = (void *)(pinskinintervals + groupskins);
 460
 461                         *skinrange++ = groupskins; // number of skins
 462                         skinnum += groupskins;
 463                         for (j = 0;j < groupskins;j++)
 464                         {
 465                                 sprintf (name, "%s_%i_%i", loadmodel->name, i, j);
 466                                 Mod_LoadSkin(mheader, name, (byte *)pskintype, skintemp, width, height, skintex);
 467                                 skintex += 5;
 468                                 pskintype = (daliasskintype_t *)((byte *)(pskintype) + s);
 469                         }
 470                 }
 471         }
 472         loadmodel->numskins = numskins;
 473         qfree(skintemp);
 474
 475         return (void *)pskintype;
 476 }
 477
 478 void *Mod_SkipAllSkins (int numskins, daliasskintype_t *pskintype, int skinsize)
 479 {
 480         int             i;
 481         for (i = 0;i < numskins;i++)
 482         {
 483                 pskintype++;
 484                 if (pskintype[-1].type == ALIAS_SKIN_SINGLE)
 485                         (byte *)pskintype += skinsize;
 486                 else
 487                         (byte *)pskintype += (skinsize + sizeof(daliasskininterval_t)) * LittleLong (((daliasskingroup_t *)pskintype)->numskins) + sizeof(daliasskingroup_t);
 488         }
 489         return pskintype;
 490 }
 491
 492 //=========================================================================
 493
 494 //void GL_MakeAliasModelDisplayLists (model_t *m, aliashdr_t *hdr);
 495
 496 /*
 497 =================
 498 Mod_LoadAliasModel
 499 =================
 500 */
 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)
 504 {
 505         int                                     i, j, version, numframes, start, end, total, numverts, numtris, numposes, numskins, skinwidth, skinheight, f, totalverts;
 506         mdl_t                           *pinmodel;
 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;
 516
 517         start = Hunk_LowMark ();
 518
 519         pinmodel = (mdl_t *)buffer;
 520
 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);
 525
 526         mod->type = mod_alias;
 527         mod->aliastype = ALIASTYPE_MDL;
 528
 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);
 541
 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];
 546
 547         numposes = 0;
 548         for (i=0 ; i<numframes ; i++)
 549         {
 550                 if ((aliasframetype_t) LittleLong (pframetype->type) == ALIAS_SINGLE)
 551                 {
 552                         numposes++;
 553                         pframetype = (daliasframetype_t *)((int)pframetype + sizeof(daliasframetype_t)                         + (sizeof(daliasframe_t)                            + sizeof(trivertx_t) * numverts)    );
 554                 }
 555                 else
 556                 {
 557                         f = LittleLong (((daliasgroup_t *)((int)pframetype + sizeof(daliasframetype_t)))->numframes);
 558                         numposes += f;
 559                         pframetype = (daliasframetype_t *)((int)pframetype + sizeof(daliasframetype_t) + sizeof(daliasgroup_t) + (sizeof(daliasframe_t) + sizeof(daliasinterval_t) + sizeof(trivertx_t) * numverts) * f);
 560                 }
 561         }
 562
 563         // rebuild the model
 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);
 572
 573         for (i=0 ; i<3 ; i++)
 574         {
 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);
 579         }
 580
 581         // load the skins
 582         pskintype = (daliasskintype_t *)&pinmodel[1];
 583         pskintype = Mod_LoadAllSkins(mheader, numskins, pskintype, skinwidth, skinheight);
 584
 585         // store texture coordinates into temporary array, they will be stored after usage is determined (triangle data)
 586         pinstverts = (stvert_t *)pskintype;
 587
 588         // LordHavoc: byteswap and convert stvert data
 589         scales = 1.0 / skinwidth;
 590         scalet = 1.0 / skinheight;
 591         for (i = 0;i < numverts;i++)
 592         {
 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];
 598                 vertusage[i] = 0;
 599                 vertusage[i+numverts] = 0;
 600         }
 601
 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];
 606
 607         // count the vertices used
 608         for (i = 0;i < numverts*2;i++)
 609                 vertusage[i] = 0;
 610         for (i = 0;i < numtris;i++)
 611         {
 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
 616                 {
 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;
 620                 }
 621                 vertusage[temptris[i][0]]++;
 622                 vertusage[temptris[i][1]]++;
 623                 vertusage[temptris[i][2]]++;
 624         }
 625         // build remapping table and compact array
 626         totalverts = 0;
 627         for (i = 0;i < numverts*2;i++)
 628         {
 629                 if (vertusage[i])
 630                 {
 631                         vertremap[i] = totalverts;
 632                         vertst[totalverts][0] = vertst[i][0];
 633                         vertst[totalverts][1] = vertst[i][1];
 634                         totalverts++;
 635                 }
 636                 else
 637                         vertremap[i] = -1; // not used at all
 638         }
 639         mheader->numverts = totalverts;
 640         // remap the triangle references
 641         for (i = 0;i < numtris;i++)
 642         {
 643                 *pouttris++ = vertremap[temptris[i][0]];
 644                 *pouttris++ = vertremap[temptris[i][1]];
 645                 *pouttris++ = vertremap[temptris[i][2]];
 646         }
 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++)
 651         {
 652                 *pouttexcoords++ = vertst[i][0];
 653                 *pouttexcoords++ = vertst[i][1];
 654         }
 655
 656 // load the frames
 657         posenum = 0;
 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];
 661
 662         // LordHavoc: doing proper bbox for model
 663         aliasbboxmin[0] = aliasbboxmin[1] = aliasbboxmin[2] = 1000000000;
 664         aliasbboxmax[0] = aliasbboxmax[1] = aliasbboxmax[2] = -1000000000;
 665
 666         animscenes = Hunk_AllocName(sizeof(animscene_t) * mod->numframes, va("%s sceneinfo", loadname));
 667
 668         for (i = 0;i < numframes;i++)
 669         {
 670                 if ((aliasframetype_t) LittleLong (pframetype->type) == ALIAS_SINGLE)
 671                         pframetype = (daliasframetype_t *) Mod_LoadAliasFrame (pframetype + 1, mheader, numverts, totalverts, &posevert, animscenes + i);
 672                 else
 673                         pframetype = (daliasframetype_t *) Mod_LoadAliasGroup (pframetype + 1, mheader, numverts, totalverts, &posevert, animscenes + i);
 674         }
 675
 676         mod->ofs_scenes = (int) animscenes - (int) mheader;
 677
 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++)
 682         {
 683                 mod->mins[j] = aliasbboxmin[j];
 684                 mod->maxs[j] = aliasbboxmax[j];
 685         }
 686
 687 // move the complete, relocatable alias model to the cache
 688         end = Hunk_LowMark ();
 689         mod->cachesize = total = end - start;
 690
 691         Cache_Alloc (&mod->cache, total, loadname);
 692         if (!mod->cache.data)
 693                 return;
 694         memcpy (mod->cache.data, mheader, total);
 695
 696         Hunk_FreeToLowMark (start);
 697 }
 698
 699 void Mod_ConvertQ2AliasVerts (int numverts, vec3_t scale, vec3_t translate, trivertx_t *v, trivertx_t *out)
 700 {
 701         int i, invalidnormals = 0;
 702         vec3_t temp;
 703         for (i = 0;i < numverts;i++)
 704         {
 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)
 718                 {
 719                         invalidnormals++;
 720                         out[i].lightnormalindex = 0;
 721                 }
 722         }
 723         if (invalidnormals)
 724                 Con_Printf("Mod_ConvertQ2AliasVerts: \"%s\", %i invalid normal indices found\n", loadname, invalidnormals);
 725 }
 726
 727 /*
 728 =================
 729 Mod_LoadQ2AliasModel
 730 =================
 731 */
 732 void Mod_LoadQ2AliasModel (model_t *mod, void *buffer)
 733 {
 734         int                                     i, j, version, size, *pinglcmd, *poutglcmd, start, end, total, framesize;
 735         md2_t                           *pinmodel;
 736         md2mem_t                        *pheader;
 737         md2triangle_t           *pintriangles, *pouttriangles;
 738         md2frame_t                      *pinframe;
 739         md2frame_t                      *poutframe;
 740         char                            *pinskins;
 741 //      temptris_t                      *tris;
 742         animscene_t                     *animscenes;
 743
 744         start = Hunk_LowMark ();
 745
 746 //      if (!temptris)
 747 //              temptris = qmalloc(sizeof(temptris_t) * MD2MAX_TRIANGLES);
 748
 749         pinmodel = (md2_t *)buffer;
 750
 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);
 755
 756         mod->type = mod_alias;
 757         mod->aliastype = ALIASTYPE_MD2;
 758
 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));
 769
 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
 774
 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);
 785
 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));
 794
 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);
 802
 803 // load the skins
 804         if (pheader->num_skins)
 805         {
 806                 rtexture_t **skin;
 807                 int *skinrange;
 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++)
 816                 {
 817                         *skinrange++ = i;
 818                         *skinrange++ = 1;
 819                         *skin++ = loadtextureimage (pinskins, 0, 0, true, r_mipskins.value, true);
 820                         *skin++ = NULL; // the extra 4 layers are currently unused
 821                         *skin++ = NULL;
 822                         *skin++ = NULL;
 823                         *skin++ = NULL;
 824                         pinskins += MD2MAX_SKINNAME;
 825                 }
 826         }
 827         loadmodel->numskins = pheader->num_skins;
 828
 829 // load triangles
 830         pintriangles = (void*)((int) pinmodel + LittleLong(pinmodel->ofs_tris));
 831         pouttriangles = (void*)&pheader[1];
 832         pheader->ofs_tris = (int) pouttriangles - (int) pheader;
 833 //      tris = temptris;
 834         // swap the triangle list
 835         for (i = 0;i < pheader->num_tris;i++)
 836         {
 837                 for (j = 0;j < 3;j++)
 838                 {
 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);
 845                 }
 846                 pintriangles++;
 847                 pouttriangles++;
 848         }
 849
 850         // LordHavoc: doing proper bbox for model
 851         aliasbboxmin[0] = aliasbboxmin[1] = aliasbboxmin[2] = 1000000000;
 852         aliasbboxmax[0] = aliasbboxmax[1] = aliasbboxmax[2] = -1000000000;
 853
 854 // load the frames
 855         pinframe = (void*) ((int) pinmodel + LittleLong(pinmodel->ofs_frames));
 856         poutframe = (void*) pouttriangles;
 857         pheader->ofs_frames = (int) poutframe - (int) pheader;
 858
 859         animscenes = Hunk_AllocName(sizeof(animscene_t) * mod->numframes, va("%s sceneinfo", loadname));
 860
 861         for (i = 0;i < pheader->num_frames;i++)
 862         {
 863                 strcpy(poutframe->name, pinframe->name);
 864                 for (j = 0;j < 3;j++)
 865                 {
 866                         poutframe->scale[j] = LittleFloat(pinframe->scale[j]);
 867                         poutframe->translate[j] = LittleFloat(pinframe->translate[j]);
 868                 }
 869                 Mod_ConvertQ2AliasVerts (pheader->num_xyz, poutframe->scale, poutframe->translate, &pinframe->verts[0], &poutframe->verts[0]);
 870
 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;
 876
 877                 pinframe = (void*) &pinframe->verts[j];
 878                 poutframe = (void*) &poutframe->verts[j];
 879         }
 880
 881         mod->ofs_scenes = (int) animscenes - (int) pheader;
 882
 883         // LordHavoc: model bbox
 884         for (j = 0;j < 3;j++)
 885         {
 886                 mod->mins[j] = aliasbboxmin[j];
 887                 mod->maxs[j] = aliasbboxmax[j];
 888         }
 889
 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++);
 896
 897 // move the complete, relocatable alias model to the cache
 898         end = Hunk_LowMark ();
 899         mod->cachesize = total = end - start;
 900
 901         Cache_Alloc (&mod->cache, total, loadname);
 902         if (!mod->cache.data)
 903                 return;
 904         memcpy (mod->cache.data, pheader, total);
 905
 906         Hunk_FreeToLowMark (start);
 907 }
 908
 909 void swapintblock(int *m, int size)
 910 {
 911         size /= 4;
 912         while(size--)
 913                 *m++ = BigLong(*m);
 914 }
 915
 916 void Mod_LoadZymoticModel (model_t *mod, void *buffer)
 917 {
 918         int i, pbase, start, end, total, *skinrange;
 919         rtexture_t **texture, **skin;
 920         char *shadername;
 921         zymtype1header_t *pinmodel, *pheader;
 922         zymscene_t *scene;
 923         zymbone_t *bone;
 924         animscene_t *animscenes;
 925
 926         start = Hunk_LowMark ();
 927
 928         pinmodel = (void *)buffer;
 929
 930         if (memcmp(pinmodel->id, "ZYMOTICMODEL", 12))
 931                 Host_Error ("Mod_LoadZymoticModel: %s is not a zymotic model\n");
 932
 933         if (BigLong(pinmodel->type) != 1)
 934                 Host_Error ("Mod_LoadZymoticModel: only type 1 (skeletal pose) models are currently supported\n");
 935
 936         mod->type = mod_alias;
 937         mod->aliastype = ALIASTYPE_ZYM;
 938
 939         pheader = Hunk_AllocName (BigLong(pinmodel->filesize), va("%s Zymotic model", loadname));
 940
 941         pbase = (int) pheader;
 942
 943         memcpy(pheader, pinmodel, BigLong(pinmodel->filesize));
 944
 945         // byteswap header
 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);
 961
 962
 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);
 972
 973         mod->flags = 0; // there are no flags
 974         mod->numframes = pheader->numscenes;
 975         mod->synctype = ST_SYNC;
 976         mod->numtris = pheader->numtris;
 977
 978         // FIXME: add skin support and texturing and shaders and...
 979 // load the skins
 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;
 986         *skinrange++ = 0;
 987         *skinrange++ = 1;
 988         *skin++ = NULL;
 989         *skin++ = NULL;
 990         *skin++ = NULL;
 991         *skin++ = NULL;
 992         *skin++ = NULL;
 993         loadmodel->numskins = 1;
 994
 995         // go through the lumps, swapping things
 996
 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++)
1001         {
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);
1013
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;
1019
1020                 scene++;
1021         }
1022         mod->ofs_scenes = (int) animscenes - pbase;
1023
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);
1026
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++)
1030         {
1031                 bone->flags = BigLong(bone->flags);
1032                 bone->parent = BigLong(bone->parent);
1033                 bone++;
1034         }
1035
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);
1038
1039 //      zymlump_t lump_verts; // zymvertex_t vert[numvertices]; // see vertex struct
1040         swapintblock((void *) (pheader->lump_verts.start + pbase), pheader->lump_verts.length);
1041
1042 //      zymlump_t lump_texcoords; // float texcoords[numvertices][2];
1043         swapintblock((void *) (pheader->lump_texcoords.start + pbase), pheader->lump_texcoords.length);
1044
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);
1047
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++)
1052         {
1053                 rtexture_t *rt;
1054                 rt = loadtextureimage(shadername, 0, 0, true, r_mipskins.value, true);
1055                 shadername += 32;
1056                 *texture++ = rt; // reuse shader name list for texture pointers
1057         }
1058
1059 //      zymlump_t lump_trizone; // byte trizone[numtris]; // see trizone explanation
1060         swapintblock((void *) (pheader->lump_trizone.start + pbase), pheader->lump_trizone.length);
1061
1062         // model bbox
1063         for (i = 0;i < 3;i++)
1064         {
1065                 mod->mins[i] = pheader->mins[i];
1066                 mod->maxs[i] = pheader->maxs[i];
1067         }
1068
1069 // move the complete, relocatable alias model to the cache
1070         end = Hunk_LowMark ();
1071         mod->cachesize = total = end - start;
1072
1073         Cache_Alloc (&mod->cache, total, loadname);
1074         if (!mod->cache.data)
1075                 return;
1076         memcpy (mod->cache.data, pheader, total);
1077
1078         Hunk_FreeToLowMark (start);
1079 }