+
+ while (animbuffer < animbufferend)
+ {
+ pchunk = (pskchunk_t *)animbuffer;
+ animbuffer = (void *)((unsigned char *)animbuffer + sizeof(pskchunk_t));
+ version = LittleLong(pchunk->version);
+ recordsize = LittleLong(pchunk->recordsize);
+ numrecords = LittleLong(pchunk->numrecords);
+ if (developer.integer >= 100)
+ Con_Printf("%s: %s %x: %i * %i = %i\n", animname, pchunk->id, version, recordsize, numrecords, recordsize * numrecords);
+ if (version != 0x1e83b9 && version != 0x1e9179 && version != 0x2e && version != 0x12f2bc && version != 0x12f2f0)
+ Con_Printf ("%s: chunk %s has unknown version %x (0x1e83b9, 0x1e9179, 0x2e, 0x12f2bc, 0x12f2f0 are currently supported), trying to load anyway!\n", animname, pchunk->id, version);
+ if (!strcmp(pchunk->id, "ANIMHEAD"))
+ {
+ // nothing to do
+ }
+ else if (!strcmp(pchunk->id, "BONENAMES"))
+ {
+ pskboneinfo_t *p;
+ if (recordsize != sizeof(*p))
+ Host_Error("%s: %s has unsupported recordsize", animname, pchunk->id);
+ // byteswap in place and keep the pointer
+ numanimbones = numrecords;
+ animbones = (pskboneinfo_t *)animbuffer;
+ // NOTE: supposedly psa does not need to match the psk model, the
+ // bones missing from the psa would simply use their base
+ // positions from the psk, but this is hard for me to implement
+ // and people can easily make animations that match.
+ if (numanimbones != numbones)
+ Host_Error("%s: this loader only supports animations with the same bones as the mesh", loadmodel->name);
+ for (index = 0, p = (pskboneinfo_t *)animbuffer;index < numrecords;index++, p++)
+ {
+ p->numchildren = LittleLong(p->numchildren);
+ p->parent = LittleLong(p->parent);
+ p->basepose.quat[0] = LittleFloat(p->basepose.quat[0]);
+ p->basepose.quat[1] = LittleFloat(p->basepose.quat[1]);
+ p->basepose.quat[2] = LittleFloat(p->basepose.quat[2]);
+ p->basepose.quat[3] = LittleFloat(p->basepose.quat[3]);
+ p->basepose.origin[0] = LittleFloat(p->basepose.origin[0]);
+ p->basepose.origin[1] = LittleFloat(p->basepose.origin[1]);
+ p->basepose.origin[2] = LittleFloat(p->basepose.origin[2]);
+ p->basepose.unknown = LittleFloat(p->basepose.unknown);
+ p->basepose.size[0] = LittleFloat(p->basepose.size[0]);
+ p->basepose.size[1] = LittleFloat(p->basepose.size[1]);
+ p->basepose.size[2] = LittleFloat(p->basepose.size[2]);
+#ifdef PSKQUATNEGATIONS
+ if (index)
+ {
+ p->basepose.quat[0] *= -1;
+ p->basepose.quat[1] *= -1;
+ p->basepose.quat[2] *= -1;
+ }
+ else
+ {
+ p->basepose.quat[0] *= 1;
+ p->basepose.quat[1] *= -1;
+ p->basepose.quat[2] *= 1;
+ }
+#endif
+ if (p->parent < 0 || p->parent >= numanimbones)
+ {
+ Con_Printf("%s: bone->parent %i >= numanimbones %i\n", animname, p->parent, numanimbones);
+ p->parent = 0;
+ }
+ // check that bones are the same as in the base
+ if (strcmp(p->name, bones[index].name) || p->parent != bones[index].parent)
+ Host_Error("%s: this loader only supports animations with the same bones as the mesh", animname);
+ }
+ animbuffer = p;
+ }
+ else if (!strcmp(pchunk->id, "ANIMINFO"))
+ {
+ pskaniminfo_t *p;
+ if (recordsize != sizeof(*p))
+ Host_Error("%s: %s has unsupported recordsize", animname, pchunk->id);
+ // byteswap in place and keep the pointer
+ numanims = numrecords;
+ anims = (pskaniminfo_t *)animbuffer;
+ for (index = 0, p = (pskaniminfo_t *)animbuffer;index < numrecords;index++, p++)
+ {
+ p->numbones = LittleLong(p->numbones);
+ p->playtime = LittleFloat(p->playtime);
+ p->fps = LittleFloat(p->fps);
+ p->firstframe = LittleLong(p->firstframe);
+ p->numframes = LittleLong(p->numframes);
+ if (p->numbones != numbones)
+ Con_Printf("%s: animinfo->numbones != numbones, trying to load anyway!\n", animname);
+ }
+ animbuffer = p;
+ }
+ else if (!strcmp(pchunk->id, "ANIMKEYS"))
+ {
+ pskanimkeys_t *p;
+ if (recordsize != sizeof(*p))
+ Host_Error("%s: %s has unsupported recordsize", animname, pchunk->id);
+ numanimkeys = numrecords;
+ animkeys = (pskanimkeys_t *)animbuffer;
+ for (index = 0, p = (pskanimkeys_t *)animbuffer;index < numrecords;index++, p++)
+ {
+ p->origin[0] = LittleFloat(p->origin[0]);
+ p->origin[1] = LittleFloat(p->origin[1]);
+ p->origin[2] = LittleFloat(p->origin[2]);
+ p->quat[0] = LittleFloat(p->quat[0]);
+ p->quat[1] = LittleFloat(p->quat[1]);
+ p->quat[2] = LittleFloat(p->quat[2]);
+ p->quat[3] = LittleFloat(p->quat[3]);
+ p->frametime = LittleFloat(p->frametime);
+#ifdef PSKQUATNEGATIONS
+ if (index % numbones)
+ {
+ p->quat[0] *= -1;
+ p->quat[1] *= -1;
+ p->quat[2] *= -1;
+ }
+ else
+ {
+ p->quat[0] *= 1;
+ p->quat[1] *= -1;
+ p->quat[2] *= 1;
+ }
+#endif
+ }
+ animbuffer = p;
+ // TODO: allocate bonepose stuff
+ }
+ else
+ Con_Printf("%s: unknown chunk ID \"%s\"\n", animname, pchunk->id);
+ }
+
+ if (!numpnts || !pnts || !numvtxw || !vtxw || !numfaces || !faces || !nummatts || !matts || !numbones || !bones || !numrawweights || !rawweights || !numanims || !anims || !numanimkeys || !animkeys)
+ Host_Error("%s: missing required chunks", loadmodel->name);
+
+ loadmodel->numframes = 0;
+ for (index = 0;index < numanims;index++)
+ loadmodel->numframes += anims[index].numframes;
+
+ if (numanimkeys != numbones * loadmodel->numframes)
+ Host_Error("%s: %s has incorrect number of animation keys", animname, pchunk->id);
+
+ meshvertices = numvtxw;
+ meshtriangles = numfaces;
+
+ // load external .skin files if present
+ skinfiles = Mod_LoadSkinFiles();
+ if (loadmodel->numskins < 1)
+ loadmodel->numskins = 1;
+ loadmodel->num_bones = numbones;
+ loadmodel->num_poses = loadmodel->num_bones * loadmodel->numframes;
+ loadmodel->num_textures = loadmodel->nummodelsurfaces = loadmodel->num_surfaces = nummatts;
+ // do most allocations as one merged chunk
+ data = (unsigned char *)Mem_Alloc(loadmodel->mempool, loadmodel->num_surfaces * sizeof(msurface_t) + loadmodel->num_surfaces * sizeof(int) + loadmodel->num_surfaces * loadmodel->numskins * sizeof(texture_t) + meshtriangles * sizeof(int[3]) + meshtriangles * sizeof(int[3]) + meshvertices * (sizeof(float[14]) + sizeof(int[4]) + sizeof(float[4])) + loadmodel->num_poses * sizeof(float[36]) + loadmodel->numskins * sizeof(animscene_t) + loadmodel->num_bones * sizeof(aliasbone_t) + loadmodel->numframes * sizeof(animscene_t));
+ loadmodel->data_surfaces = (msurface_t *)data;data += loadmodel->num_surfaces * sizeof(msurface_t);
+ loadmodel->surfacelist = (int *)data;data += loadmodel->num_surfaces * sizeof(int);
+ loadmodel->data_textures = (texture_t *)data;data += loadmodel->num_surfaces * loadmodel->numskins * sizeof(texture_t);
+ loadmodel->surfmesh.num_vertices = meshvertices;
+ loadmodel->surfmesh.num_triangles = meshtriangles;
+ loadmodel->surfmesh.data_element3i = (int *)data;data += meshtriangles * sizeof(int[3]);
+ loadmodel->surfmesh.data_neighbor3i = (int *)data;data += meshtriangles * sizeof(int[3]);
+ loadmodel->surfmesh.data_vertex3f = (float *)data;data += meshvertices * sizeof(float[3]);
+ loadmodel->surfmesh.data_svector3f = (float *)data;data += meshvertices * sizeof(float[3]);
+ loadmodel->surfmesh.data_tvector3f = (float *)data;data += meshvertices * sizeof(float[3]);
+ loadmodel->surfmesh.data_normal3f = (float *)data;data += meshvertices * sizeof(float[3]);
+ loadmodel->surfmesh.data_texcoordtexture2f = (float *)data;data += meshvertices * sizeof(float[2]);
+ loadmodel->surfmesh.data_vertexweightindex4i = (int *)data;data += meshvertices * sizeof(int[4]);
+ loadmodel->surfmesh.data_vertexweightinfluence4f = (float *)data;data += meshvertices * sizeof(float[4]);
+ loadmodel->data_poses = (float *)data;data += loadmodel->num_poses * sizeof(float[12]);
+ loadmodel->data_basebonepose = (float *)data;data += loadmodel->num_poses * sizeof(float[12]);
+ loadmodel->data_baseboneposeinverse = (float *)data;data += loadmodel->num_poses * sizeof(float[12]);
+ loadmodel->skinscenes = (animscene_t *)data;data += loadmodel->numskins * sizeof(animscene_t);
+ loadmodel->data_bones = (aliasbone_t *)data;data += loadmodel->num_bones * sizeof(aliasbone_t);
+ loadmodel->animscenes = (animscene_t *)data;data += loadmodel->numframes * sizeof(animscene_t);
+
+ for (i = 0;i < loadmodel->numskins;i++)
+ {
+ loadmodel->skinscenes[i].firstframe = i;
+ loadmodel->skinscenes[i].framecount = 1;
+ loadmodel->skinscenes[i].loop = true;
+ loadmodel->skinscenes[i].framerate = 10;
+ }
+
+ // create surfaces
+ for (index = 0, i = 0;index < nummatts;index++)
+ {
+ // since psk models do not have named sections, reuse their shader name as the section name
+ if (matts[index].name[0])
+ Mod_BuildAliasSkinsFromSkinFiles(loadmodel->data_textures + index, skinfiles, matts[index].name, matts[index].name);
+ else
+ for (j = 0;j < loadmodel->numskins;j++)
+ Mod_BuildAliasSkinFromSkinFrame(loadmodel->data_textures + index + j * loadmodel->num_surfaces, NULL);
+ loadmodel->surfacelist[index] = index;
+ loadmodel->data_surfaces[index].texture = loadmodel->data_textures + index;
+ loadmodel->data_surfaces[index].num_firstvertex = 0;
+ loadmodel->data_surfaces[index].num_vertices = loadmodel->surfmesh.num_vertices;
+ }
+
+ // copy over the vertex locations and texcoords
+ for (index = 0;index < numvtxw;index++)
+ {
+ loadmodel->surfmesh.data_vertex3f[index*3+0] = pnts[vtxw[index].pntsindex].origin[0];
+ loadmodel->surfmesh.data_vertex3f[index*3+1] = pnts[vtxw[index].pntsindex].origin[1];
+ loadmodel->surfmesh.data_vertex3f[index*3+2] = pnts[vtxw[index].pntsindex].origin[2];
+ loadmodel->surfmesh.data_texcoordtexture2f[index*2+0] = vtxw[index].texcoord[0];
+ loadmodel->surfmesh.data_texcoordtexture2f[index*2+1] = vtxw[index].texcoord[1];
+ }
+
+ // loading the faces is complicated because we need to sort them into surfaces by mattindex
+ for (index = 0;index < numfaces;index++)
+ loadmodel->data_surfaces[faces[index].mattindex].num_triangles++;
+ for (index = 0, i = 0;index < nummatts;index++)
+ {
+ loadmodel->data_surfaces[index].num_firsttriangle = i;
+ i += loadmodel->data_surfaces[index].num_triangles;
+ loadmodel->data_surfaces[index].num_triangles = 0;
+ }
+ for (index = 0;index < numfaces;index++)
+ {
+ i = (loadmodel->data_surfaces[faces[index].mattindex].num_firsttriangle + loadmodel->data_surfaces[faces[index].mattindex].num_triangles++)*3;
+ loadmodel->surfmesh.data_element3i[i+0] = faces[index].vtxwindex[0];
+ loadmodel->surfmesh.data_element3i[i+1] = faces[index].vtxwindex[1];
+ loadmodel->surfmesh.data_element3i[i+2] = faces[index].vtxwindex[2];
+ }
+
+ // copy over the bones
+ for (index = 0;index < numbones;index++)
+ {
+ strlcpy(loadmodel->data_bones[index].name, bones[index].name, sizeof(loadmodel->data_bones[index].name));
+ loadmodel->data_bones[index].parent = (index || bones[index].parent > 0) ? bones[index].parent : -1;
+ if (loadmodel->data_bones[index].parent >= index)
+ Host_Error("%s bone[%i].parent >= %i", loadmodel->name, index, index);
+ }
+
+ // sort the psk point weights into the vertex weight tables
+ // (which only accept up to 4 bones per vertex)
+ for (index = 0;index < numvtxw;index++)
+ {
+ int l;
+ float sum;
+ for (j = 0;j < numrawweights;j++)
+ {
+ if (rawweights[j].pntsindex == vtxw[index].pntsindex)
+ {
+ int boneindex = rawweights[j].boneindex;
+ float influence = rawweights[j].weight;
+ for (l = 0;l < 4;l++)
+ {
+ if (loadmodel->surfmesh.data_vertexweightinfluence4f[index*4+l] < influence)
+ {
+ // move lower influence weights out of the way first
+ int l2;
+ for (l2 = 3;l2 > l;l2--)
+ {
+ loadmodel->surfmesh.data_vertexweightinfluence4f[index*4+l2] = loadmodel->surfmesh.data_vertexweightinfluence4f[index*4+l2-1];
+ loadmodel->surfmesh.data_vertexweightindex4i[index*4+l2] = loadmodel->surfmesh.data_vertexweightindex4i[index*4+l2-1];
+ }
+ // store the new weight
+ loadmodel->surfmesh.data_vertexweightinfluence4f[index*4+l] = influence;
+ loadmodel->surfmesh.data_vertexweightindex4i[index*4+l] = boneindex;
+ break;
+ }
+ }
+ }
+ }
+ sum = 0;
+ for (l = 0;l < 4;l++)
+ sum += loadmodel->surfmesh.data_vertexweightinfluence4f[index*4+l];
+ if (sum && fabs(sum - 1) > (1.0f / 256.0f))
+ {
+ float f = 1.0f / sum;
+ for (l = 0;l < 4;l++)
+ loadmodel->surfmesh.data_vertexweightinfluence4f[index*4+l] *= f;
+ }
+ }
+
+ // set up the animscenes based on the anims
+ for (index = 0, i = 0;index < numanims;index++)
+ {
+ for (j = 0;j < anims[index].numframes;j++, i++)
+ {
+ dpsnprintf(loadmodel->animscenes[i].name, sizeof(loadmodel->animscenes[i].name), "%s_%d", anims[index].name, j);
+ loadmodel->animscenes[i].firstframe = i;
+ loadmodel->animscenes[i].framecount = 1;
+ loadmodel->animscenes[i].loop = true;
+ loadmodel->animscenes[i].framerate = 10;
+ }
+ }
+
+ // load the poses from the animkeys
+ for (index = 0;index < numanimkeys;index++)
+ {
+ pskanimkeys_t *k = animkeys + index;
+ matrix4x4_t matrix;
+ Matrix4x4_FromOriginQuat(&matrix, k->origin[0], k->origin[1], k->origin[2], k->quat[0], k->quat[1], k->quat[2], k->quat[3]);
+ Matrix4x4_ToArray12FloatD3D(&matrix, loadmodel->data_poses + index*12);
+ }
+ Mod_FreeSkinFiles(skinfiles);
+ Mem_Free(animfilebuffer);
+
+ // compute all the mesh information that was not loaded from the file
+ // TODO: honor smoothing groups somehow?
+ Mod_ValidateElements(loadmodel->surfmesh.data_element3i, loadmodel->surfmesh.num_triangles, 0, loadmodel->surfmesh.num_vertices, __FILE__, __LINE__);
+ Mod_BuildBaseBonePoses();
+ Mod_BuildNormals(0, loadmodel->surfmesh.num_vertices, loadmodel->surfmesh.num_triangles, loadmodel->surfmesh.data_vertex3f, loadmodel->surfmesh.data_element3i, loadmodel->surfmesh.data_normal3f, true);
+ Mod_BuildTextureVectorsFromNormals(0, loadmodel->surfmesh.num_vertices, loadmodel->surfmesh.num_triangles, loadmodel->surfmesh.data_vertex3f, loadmodel->surfmesh.data_texcoordtexture2f, loadmodel->surfmesh.data_normal3f, loadmodel->surfmesh.data_element3i, loadmodel->surfmesh.data_svector3f, loadmodel->surfmesh.data_tvector3f, true);
+ Mod_BuildTriangleNeighbors(loadmodel->surfmesh.data_neighbor3i, loadmodel->surfmesh.data_element3i, loadmodel->surfmesh.num_triangles);
+ Mod_Alias_CalculateBoundingBox();
+
+ loadmodel->surfmesh.isanimated = loadmodel->numframes > 1 || loadmodel->animscenes[0].framecount > 1;