+ loadmodel->radius = pheader->allradius;
+ loadmodel->radius2 = pheader->allradius * pheader->allradius;
+
+ // load external .skin files if present
+ skinfiles = Mod_LoadSkinFiles();
+ if (loadmodel->numskins < 1)
+ loadmodel->numskins = 1;
+
+ meshvertices = 0;
+ meshtriangles = 0;
+
+ // gather combined statistics from the meshes
+ dpmmesh = (dpmmesh_t *) (pbase + pheader->ofs_meshs);
+ for (i = 0;i < (int)pheader->num_meshs;i++)
+ {
+ int numverts = BigLong(dpmmesh->num_verts);
+ meshvertices += numverts;
+ meshtriangles += BigLong(dpmmesh->num_tris);
+ dpmmesh++;
+ }
+
+ loadmodel->numframes = pheader->num_frames;
+ loadmodel->num_bones = pheader->num_bones;
+ loadmodel->num_poses = loadmodel->num_bones * loadmodel->numframes;
+ loadmodel->nummodelsurfaces = loadmodel->num_surfaces = pheader->num_meshs;
+ loadmodel->num_textures = loadmodel->num_surfaces * loadmodel->numskins;
+ loadmodel->num_texturesperskin = loadmodel->num_surfaces;
+ // 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]) + (meshvertices <= 65536 ? meshtriangles * sizeof(unsigned short[3]) : 0) + meshtriangles * sizeof(int[3]) + meshvertices * (sizeof(float[14]) + sizeof(int[4]) + sizeof(float[4])) + loadmodel->num_poses * sizeof(float[12]) + loadmodel->num_bones * sizeof(float[12]) + 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->sortedmodelsurfaces = (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_baseboneposeinverse = (float *)data;data += loadmodel->num_bones * 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);
+ if (meshvertices <= 65536)
+ {
+ loadmodel->surfmesh.data_element3s = (unsigned short *)data;data += meshtriangles * sizeof(unsigned short[3]);
+ for (i = 0;i < loadmodel->surfmesh.num_triangles*3;i++)
+ loadmodel->surfmesh.data_element3s[i] = loadmodel->surfmesh.data_element3i[i];
+ }
+
+ 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;
+ }
+
+ // load the bone info
+ bone = (dpmbone_t *) (pbase + pheader->ofs_bones);
+ for (i = 0;i < loadmodel->num_bones;i++)
+ {
+ memcpy(loadmodel->data_bones[i].name, bone[i].name, sizeof(bone[i].name));
+ loadmodel->data_bones[i].flags = BigLong(bone[i].flags);
+ loadmodel->data_bones[i].parent = BigLong(bone[i].parent);
+ if (loadmodel->data_bones[i].parent >= i)
+ Host_Error("%s bone[%i].parent >= %i", loadmodel->name, i, i);
+ }
+
+ // load the frames
+ frame = (dpmframe_t *) (pbase + pheader->ofs_frames);
+ for (i = 0;i < loadmodel->numframes;i++)
+ {
+ const float *poses;
+ memcpy(loadmodel->animscenes[i].name, frame->name, sizeof(frame->name));
+ loadmodel->animscenes[i].firstframe = i;
+ loadmodel->animscenes[i].framecount = 1;
+ loadmodel->animscenes[i].loop = true;
+ loadmodel->animscenes[i].framerate = 10;
+ // load the bone poses for this frame
+ poses = (float *) (pbase + BigLong(frame->ofs_bonepositions));
+ for (j = 0;j < loadmodel->num_bones*12;j++)
+ loadmodel->data_poses[i * loadmodel->num_bones*12 + j] = BigFloat(poses[j]);
+ // stuff not processed here: mins, maxs, yawradius, allradius
+ frame++;
+ }
+
+ // load the meshes now
+ dpmmesh = (dpmmesh_t *) (pbase + pheader->ofs_meshs);
+ meshvertices = 0;
+ meshtriangles = 0;
+ // reconstruct frame 0 matrices to allow reconstruction of the base mesh
+ // (converting from weight-blending skeletal animation to
+ // deformation-based skeletal animation)
+ bonepose = (float *)Z_Malloc(loadmodel->num_bones * sizeof(float[12]));
+ for (i = 0;i < loadmodel->num_bones;i++)
+ {
+ const float *m = loadmodel->data_poses + i * 12;
+ if (loadmodel->data_bones[i].parent >= 0)
+ R_ConcatTransforms(bonepose + 12 * loadmodel->data_bones[i].parent, m, bonepose + 12 * i);
+ else
+ for (k = 0;k < 12;k++)
+ bonepose[12*i+k] = m[k];
+ }
+ for (i = 0;i < loadmodel->num_surfaces;i++, dpmmesh++)
+ {
+ const int *inelements;
+ int *outelements;
+ const float *intexcoord;
+ msurface_t *surface;
+
+ loadmodel->sortedmodelsurfaces[i] = i;
+ surface = loadmodel->data_surfaces + i;
+ surface->texture = loadmodel->data_textures + i;
+ surface->num_firsttriangle = meshtriangles;
+ surface->num_triangles = BigLong(dpmmesh->num_tris);
+ surface->num_firstvertex = meshvertices;
+ surface->num_vertices = BigLong(dpmmesh->num_verts);
+ meshvertices += surface->num_vertices;
+ meshtriangles += surface->num_triangles;
+
+ inelements = (int *) (pbase + BigLong(dpmmesh->ofs_indices));
+ outelements = loadmodel->surfmesh.data_element3i + surface->num_firsttriangle * 3;
+ for (j = 0;j < surface->num_triangles;j++)
+ {
+ // swap element order to flip triangles, because Quake uses clockwise (rare) and dpm uses counterclockwise (standard)
+ outelements[0] = surface->num_firstvertex + BigLong(inelements[2]);
+ outelements[1] = surface->num_firstvertex + BigLong(inelements[1]);
+ outelements[2] = surface->num_firstvertex + BigLong(inelements[0]);
+ inelements += 3;
+ outelements += 3;
+ }
+
+ intexcoord = (float *) (pbase + BigLong(dpmmesh->ofs_texcoords));
+ for (j = 0;j < surface->num_vertices*2;j++)
+ loadmodel->surfmesh.data_texcoordtexture2f[j + surface->num_firstvertex * 2] = BigFloat(intexcoord[j]);
+
+ data = (unsigned char *) (pbase + BigLong(dpmmesh->ofs_verts));
+ for (j = surface->num_firstvertex;j < surface->num_firstvertex + surface->num_vertices;j++)
+ {
+ float sum;
+ int l;
+ int numweights = BigLong(((dpmvertex_t *)data)->numbones);
+ data += sizeof(dpmvertex_t);
+ for (k = 0;k < numweights;k++)
+ {
+ const dpmbonevert_t *vert = (dpmbonevert_t *) data;
+ int boneindex = BigLong(vert->bonenum);
+ const float *m = bonepose + 12 * boneindex;
+ float influence = BigFloat(vert->influence);
+ float relativeorigin[3], relativenormal[3];
+ relativeorigin[0] = BigFloat(vert->origin[0]);
+ relativeorigin[1] = BigFloat(vert->origin[1]);
+ relativeorigin[2] = BigFloat(vert->origin[2]);
+ relativenormal[0] = BigFloat(vert->normal[0]);
+ relativenormal[1] = BigFloat(vert->normal[1]);
+ relativenormal[2] = BigFloat(vert->normal[2]);
+ // blend the vertex bone weights into the base mesh
+ loadmodel->surfmesh.data_vertex3f[j*3+0] += relativeorigin[0] * m[0] + relativeorigin[1] * m[1] + relativeorigin[2] * m[ 2] + influence * m[ 3];
+ loadmodel->surfmesh.data_vertex3f[j*3+1] += relativeorigin[0] * m[4] + relativeorigin[1] * m[5] + relativeorigin[2] * m[ 6] + influence * m[ 7];
+ loadmodel->surfmesh.data_vertex3f[j*3+2] += relativeorigin[0] * m[8] + relativeorigin[1] * m[9] + relativeorigin[2] * m[10] + influence * m[11];
+ loadmodel->surfmesh.data_normal3f[j*3+0] += relativenormal[0] * m[0] + relativenormal[1] * m[1] + relativenormal[2] * m[ 2];
+ loadmodel->surfmesh.data_normal3f[j*3+1] += relativenormal[0] * m[4] + relativenormal[1] * m[5] + relativenormal[2] * m[ 6];
+ loadmodel->surfmesh.data_normal3f[j*3+2] += relativenormal[0] * m[8] + relativenormal[1] * m[9] + relativenormal[2] * m[10];
+ if (!k)
+ {
+ // store the first (and often only) weight
+ loadmodel->surfmesh.data_vertexweightinfluence4f[j*4+0] = influence;
+ loadmodel->surfmesh.data_vertexweightindex4i[j*4+0] = boneindex;
+ }
+ else
+ {
+ // sort the new weight into this vertex's weight table
+ // (which only accepts up to 4 bones per vertex)
+ for (l = 0;l < 4;l++)
+ {
+ if (loadmodel->surfmesh.data_vertexweightinfluence4f[j*4+l] < influence)
+ {
+ // move weaker influence weights out of the way first
+ int l2;
+ for (l2 = 3;l2 > l;l2--)
+ {
+ loadmodel->surfmesh.data_vertexweightinfluence4f[j*4+l2] = loadmodel->surfmesh.data_vertexweightinfluence4f[j*4+l2-1];
+ loadmodel->surfmesh.data_vertexweightindex4i[j*4+l2] = loadmodel->surfmesh.data_vertexweightindex4i[j*4+l2-1];
+ }
+ // store the new weight
+ loadmodel->surfmesh.data_vertexweightinfluence4f[j*4+l] = influence;
+ loadmodel->surfmesh.data_vertexweightindex4i[j*4+l] = boneindex;
+ break;
+ }
+ }
+ }
+ data += sizeof(dpmbonevert_t);
+ }
+ sum = 0;
+ for (l = 0;l < 4;l++)
+ sum += loadmodel->surfmesh.data_vertexweightinfluence4f[j*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[j*4+l] *= f;
+ }
+ }
+
+ // since dpm models do not have named sections, reuse their shader name as the section name
+ Mod_BuildAliasSkinsFromSkinFiles(loadmodel->data_textures + i, skinfiles, dpmmesh->shadername, dpmmesh->shadername);
+
+ Mod_ValidateElements(loadmodel->surfmesh.data_element3i + surface->num_firsttriangle * 3, surface->num_triangles, surface->num_firstvertex, surface->num_vertices, __FILE__, __LINE__);
+ }
+ Z_Free(bonepose);
+ Mod_FreeSkinFiles(skinfiles);
+ Mod_MakeSortedSurfaces(loadmodel);
+
+ // compute all the mesh information that was not loaded from the file
+ Mod_BuildBaseBonePoses();
+ 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);
+
+ loadmodel->surfmesh.isanimated = loadmodel->numframes > 1 || loadmodel->animscenes[0].framecount > 1;
+}
+
+// no idea why PSK/PSA files contain weird quaternions but they do...
+#define PSKQUATNEGATIONS
+void Mod_PSKMODEL_Load(dp_model_t *mod, void *buffer, void *bufferend)
+{
+ int i, j, index, version, recordsize, numrecords, meshvertices, meshtriangles;
+ int numpnts, numvtxw, numfaces, nummatts, numbones, numrawweights, numanimbones, numanims, numanimkeys;
+ fs_offset_t filesize;
+ pskpnts_t *pnts;
+ pskvtxw_t *vtxw;
+ pskface_t *faces;
+ pskmatt_t *matts;
+ pskboneinfo_t *bones;
+ pskrawweights_t *rawweights;
+ pskboneinfo_t *animbones;
+ pskaniminfo_t *anims;
+ pskanimkeys_t *animkeys;
+ void *animfilebuffer, *animbuffer, *animbufferend;
+ unsigned char *data;
+ pskchunk_t *pchunk;
+ skinfile_t *skinfiles;
+ char animname[MAX_QPATH];
+ size_t size;
+
+ pchunk = (pskchunk_t *)buffer;
+ if (strcmp(pchunk->id, "ACTRHEAD"))
+ Host_Error ("Mod_PSKMODEL_Load: %s is not an Unreal Engine ActorX (.psk + .psa) model", loadmodel->name);
+
+ loadmodel->modeldatatypestring = "PSK";
+
+ loadmodel->type = mod_alias;
+ loadmodel->AnimateVertices = Mod_Skeletal_AnimateVertices;
+ loadmodel->DrawSky = NULL;
+ loadmodel->DrawAddWaterPlanes = NULL;
+ loadmodel->Draw = R_Q1BSP_Draw;
+ loadmodel->DrawDepth = R_Q1BSP_DrawDepth;
+ loadmodel->DrawDebug = R_Q1BSP_DrawDebug;
+ loadmodel->CompileShadowVolume = R_Q1BSP_CompileShadowVolume;
+ loadmodel->DrawShadowVolume = R_Q1BSP_DrawShadowVolume;
+ loadmodel->DrawLight = R_Q1BSP_DrawLight;
+ loadmodel->TraceBox = Mod_MDLMD2MD3_TraceBox;
+ loadmodel->PointSuperContents = NULL;
+ loadmodel->synctype = ST_RAND;
+
+ FS_StripExtension(loadmodel->name, animname, sizeof(animname));
+ strlcat(animname, ".psa", sizeof(animname));
+ animbuffer = animfilebuffer = FS_LoadFile(animname, loadmodel->mempool, false, &filesize);
+ animbufferend = (void *)((unsigned char*)animbuffer + (int)filesize);
+ if (animbuffer == NULL)
+ Host_Error("%s: can't find .psa file (%s)", loadmodel->name, animname);
+
+ numpnts = 0;
+ pnts = NULL;
+ numvtxw = 0;
+ vtxw = NULL;
+ numfaces = 0;
+ faces = NULL;
+ nummatts = 0;
+ matts = NULL;
+ numbones = 0;
+ bones = NULL;
+ numrawweights = 0;
+ rawweights = NULL;
+ numanims = 0;
+ anims = NULL;
+ numanimkeys = 0;
+ animkeys = NULL;
+
+ while (buffer < bufferend)
+ {
+ pchunk = (pskchunk_t *)buffer;
+ buffer = (void *)((unsigned char *)buffer + 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", loadmodel->name, 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", loadmodel->name, pchunk->id, version);
+ if (!strcmp(pchunk->id, "ACTRHEAD"))
+ {
+ // nothing to do
+ }
+ else if (!strcmp(pchunk->id, "PNTS0000"))
+ {
+ pskpnts_t *p;
+ if (recordsize != sizeof(*p))
+ Host_Error("%s: %s has unsupported recordsize", loadmodel->name, pchunk->id);
+ // byteswap in place and keep the pointer
+ numpnts = numrecords;
+ pnts = (pskpnts_t *)buffer;
+ for (index = 0, p = (pskpnts_t *)buffer;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]);
+ }
+ buffer = p;
+ }
+ else if (!strcmp(pchunk->id, "VTXW0000"))
+ {
+ pskvtxw_t *p;
+ if (recordsize != sizeof(*p))
+ Host_Error("%s: %s has unsupported recordsize", loadmodel->name, pchunk->id);
+ // byteswap in place and keep the pointer
+ numvtxw = numrecords;
+ vtxw = (pskvtxw_t *)buffer;
+ for (index = 0, p = (pskvtxw_t *)buffer;index < numrecords;index++, p++)
+ {
+ p->pntsindex = LittleShort(p->pntsindex);
+ p->texcoord[0] = LittleFloat(p->texcoord[0]);
+ p->texcoord[1] = LittleFloat(p->texcoord[1]);
+ if (p->pntsindex >= numpnts)
+ {
+ Con_Printf("%s: vtxw->pntsindex %i >= numpnts %i\n", loadmodel->name, p->pntsindex, numpnts);
+ p->pntsindex = 0;
+ }
+ }
+ buffer = p;
+ }
+ else if (!strcmp(pchunk->id, "FACE0000"))
+ {
+ pskface_t *p;
+ if (recordsize != sizeof(*p))
+ Host_Error("%s: %s has unsupported recordsize", loadmodel->name, pchunk->id);
+ // byteswap in place and keep the pointer
+ numfaces = numrecords;
+ faces = (pskface_t *)buffer;
+ for (index = 0, p = (pskface_t *)buffer;index < numrecords;index++, p++)
+ {
+ p->vtxwindex[0] = LittleShort(p->vtxwindex[0]);
+ p->vtxwindex[1] = LittleShort(p->vtxwindex[1]);
+ p->vtxwindex[2] = LittleShort(p->vtxwindex[2]);
+ p->group = LittleLong(p->group);
+ if (p->vtxwindex[0] >= numvtxw)
+ {
+ Con_Printf("%s: face->vtxwindex[0] %i >= numvtxw %i\n", loadmodel->name, p->vtxwindex[0], numvtxw);
+ p->vtxwindex[0] = 0;
+ }
+ if (p->vtxwindex[1] >= numvtxw)
+ {
+ Con_Printf("%s: face->vtxwindex[1] %i >= numvtxw %i\n", loadmodel->name, p->vtxwindex[1], numvtxw);
+ p->vtxwindex[1] = 0;
+ }
+ if (p->vtxwindex[2] >= numvtxw)
+ {
+ Con_Printf("%s: face->vtxwindex[2] %i >= numvtxw %i\n", loadmodel->name, p->vtxwindex[2], numvtxw);
+ p->vtxwindex[2] = 0;
+ }
+ }
+ buffer = p;
+ }
+ else if (!strcmp(pchunk->id, "MATT0000"))
+ {
+ pskmatt_t *p;
+ if (recordsize != sizeof(*p))
+ Host_Error("%s: %s has unsupported recordsize", loadmodel->name, pchunk->id);
+ // byteswap in place and keep the pointer
+ nummatts = numrecords;
+ matts = (pskmatt_t *)buffer;
+ for (index = 0, p = (pskmatt_t *)buffer;index < numrecords;index++, p++)
+ {
+ // nothing to do
+ }
+ buffer = p;
+ }
+ else if (!strcmp(pchunk->id, "REFSKELT"))
+ {
+ pskboneinfo_t *p;
+ if (recordsize != sizeof(*p))
+ Host_Error("%s: %s has unsupported recordsize", loadmodel->name, pchunk->id);
+ // byteswap in place and keep the pointer
+ numbones = numrecords;
+ bones = (pskboneinfo_t *)buffer;
+ for (index = 0, p = (pskboneinfo_t *)buffer;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 >= numbones)
+ {
+ Con_Printf("%s: bone->parent %i >= numbones %i\n", loadmodel->name, p->parent, numbones);
+ p->parent = 0;
+ }
+ }
+ buffer = p;
+ }
+ else if (!strcmp(pchunk->id, "RAWWEIGHTS"))
+ {
+ pskrawweights_t *p;
+ if (recordsize != sizeof(*p))
+ Host_Error("%s: %s has unsupported recordsize", loadmodel->name, pchunk->id);
+ // byteswap in place and keep the pointer
+ numrawweights = numrecords;
+ rawweights = (pskrawweights_t *)buffer;
+ for (index = 0, p = (pskrawweights_t *)buffer;index < numrecords;index++, p++)
+ {
+ p->weight = LittleFloat(p->weight);
+ p->pntsindex = LittleLong(p->pntsindex);
+ p->boneindex = LittleLong(p->boneindex);
+ if (p->pntsindex < 0 || p->pntsindex >= numpnts)
+ {
+ Con_Printf("%s: weight->pntsindex %i >= numpnts %i\n", loadmodel->name, p->pntsindex, numpnts);
+ p->pntsindex = 0;
+ }
+ if (p->boneindex < 0 || p->boneindex >= numbones)
+ {
+ Con_Printf("%s: weight->boneindex %i >= numbones %i\n", loadmodel->name, p->boneindex, numbones);
+ p->boneindex = 0;
+ }
+ }
+ buffer = p;
+ }
+ }
+
+ 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->nummodelsurfaces = loadmodel->num_surfaces = nummatts;
+ loadmodel->num_textures = loadmodel->num_surfaces * loadmodel->numskins;
+ loadmodel->num_texturesperskin = loadmodel->num_surfaces;
+ loadmodel->surfmesh.num_vertices = meshvertices;
+ loadmodel->surfmesh.num_triangles = meshtriangles;
+ // do most allocations as one merged chunk
+ size = loadmodel->num_surfaces * sizeof(msurface_t) + loadmodel->num_surfaces * sizeof(int) + loadmodel->num_surfaces * loadmodel->numskins * sizeof(texture_t) + loadmodel->surfmesh.num_triangles * sizeof(int[3]) + loadmodel->surfmesh.num_triangles * sizeof(int[3]) + loadmodel->surfmesh.num_vertices * sizeof(float[3]) + loadmodel->surfmesh.num_vertices * sizeof(float[3]) + loadmodel->surfmesh.num_vertices * sizeof(float[3]) + loadmodel->surfmesh.num_vertices * sizeof(float[3]) + loadmodel->surfmesh.num_vertices * sizeof(float[2]) + loadmodel->surfmesh.num_vertices * sizeof(int[4]) + loadmodel->surfmesh.num_vertices * sizeof(float[4]) + /*loadmodel->num_poses * sizeof(float[12]) + */loadmodel->num_bones * sizeof(float[12]) + loadmodel->numskins * sizeof(animscene_t) + loadmodel->num_bones * sizeof(aliasbone_t) + loadmodel->numframes * sizeof(animscene_t) + ((loadmodel->surfmesh.num_vertices <= 65536) ? (loadmodel->surfmesh.num_triangles * sizeof(unsigned short[3])) : 0);
+ data = (unsigned char *)Mem_Alloc(loadmodel->mempool, size);
+ loadmodel->data_surfaces = (msurface_t *)data;data += loadmodel->num_surfaces * sizeof(msurface_t);
+ loadmodel->sortedmodelsurfaces = (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.data_element3i = (int *)data;data += loadmodel->surfmesh.num_triangles * sizeof(int[3]);
+ loadmodel->surfmesh.data_neighbor3i = (int *)data;data += loadmodel->surfmesh.num_triangles * sizeof(int[3]);
+ loadmodel->surfmesh.data_vertex3f = (float *)data;data += loadmodel->surfmesh.num_vertices * sizeof(float[3]);
+ loadmodel->surfmesh.data_svector3f = (float *)data;data += loadmodel->surfmesh.num_vertices * sizeof(float[3]);
+ loadmodel->surfmesh.data_tvector3f = (float *)data;data += loadmodel->surfmesh.num_vertices * sizeof(float[3]);
+ loadmodel->surfmesh.data_normal3f = (float *)data;data += loadmodel->surfmesh.num_vertices * sizeof(float[3]);
+ loadmodel->surfmesh.data_texcoordtexture2f = (float *)data;data += loadmodel->surfmesh.num_vertices * sizeof(float[2]);
+ loadmodel->surfmesh.data_vertexweightindex4i = (int *)data;data += loadmodel->surfmesh.num_vertices * sizeof(int[4]);
+ loadmodel->surfmesh.data_vertexweightinfluence4f = (float *)data;data += loadmodel->surfmesh.num_vertices * sizeof(float[4]);
+ //loadmodel->data_poses = (float *)data;data += loadmodel->num_poses * sizeof(float[12]);
+ loadmodel->data_baseboneposeinverse = (float *)data;data += loadmodel->num_bones * 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);
+ if (loadmodel->surfmesh.num_vertices <= 65536)
+ {
+ loadmodel->surfmesh.data_element3s = (unsigned short *)data;data += loadmodel->surfmesh.num_triangles * sizeof(unsigned short[3]);
+ for (i = 0;i < loadmodel->surfmesh.num_triangles*3;i++)
+ loadmodel->surfmesh.data_element3s[i] = loadmodel->surfmesh.data_element3i[i];
+ }
+ loadmodel->data_poses = (float *) Mem_Alloc(loadmodel->mempool, loadmodel->num_poses * sizeof(float[12]));
+
+ 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
+ Mod_BuildAliasSkinsFromSkinFiles(loadmodel->data_textures + index, skinfiles, matts[index].name, matts[index].name);
+ loadmodel->sortedmodelsurfaces[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);
+ Mod_MakeSortedSurfaces(loadmodel);
+
+ // 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;
+}
+
+void Mod_OBJ_Load(dp_model_t *mod, void *buffer, void *bufferend)
+{
+#if 0
+ const char *textbase = (char *)buffer, *text = textbase;
+ char *s;
+ char *argv[512];
+ char line[1024];
+ char materialname[MAX_QPATH];
+ int j, index1, index2, index3, first, prev, index;
+ int argc;
+ int linelen;
+ int numtriangles = 0;
+ int maxtriangles = 32768;
+ int *element3i = Mem_Alloc(tempmempool, maxtriangles * sizeof(int[3]));
+ int *oldelement3i;
+ int numsurfaces = 0;
+ int maxsurfaces = 0;
+ msurface_t *surfaces = NULL;
+ int linenumber = 0;
+ int hashindex;
+ float *v, *vt, *vn;
+ float *oldv, *oldvt, *oldvn;
+ int maxv = 65536, numv = 1;
+ int maxvt = 65536, numvt = 1;
+ int maxvn = 65536, numvn = 1;
+ int maxverthash = 65536, numverthash = 0;
+ int numhashindex = 65536;
+ struct objverthash_s
+ {
+ struct objverthash_s *next;
+ int s;
+ int v;
+ int vt;
+ int vn;
+ }
+ *hash, **verthash = Mem_Alloc(tempmempool, numhashindex * sizeof(*verthash)), *verthashdata = Mem_Alloc(tempmempool, maxverthash * sizeof(*verthashdata)), *oldverthashdata;
+ skinfile_t *skinfiles;
+
+ dpsnprintf(materialname, sizeof(materialname), "%s", loadmodel->name);
+
+ skinfiles = Mod_LoadSkinFiles();
+
+ loadmodel->modeldatatypestring = "OBJ";