+ Mod_FreeSkinFiles(skinfiles);
+ if (animfilebuffer)
+ Mem_Free(animfilebuffer);
+ Mod_MakeSortedSurfaces(loadmodel);
+
+ // compute all the mesh information that was not loaded from the file
+ // TODO: honor smoothing groups somehow?
+ if (loadmodel->surfmesh.data_element3s)
+ for (i = 0;i < loadmodel->surfmesh.num_triangles*3;i++)
+ loadmodel->surfmesh.data_element3s[i] = loadmodel->surfmesh.data_element3i[i];
+ Mod_ValidateElements(loadmodel->surfmesh.data_element3i, loadmodel->surfmesh.data_element3s, loadmodel->surfmesh.num_triangles, 0, loadmodel->surfmesh.num_vertices, __FILE__, __LINE__);
+ Mod_BuildNormals(0, loadmodel->surfmesh.num_vertices, loadmodel->surfmesh.num_triangles, loadmodel->surfmesh.data_vertex3f, loadmodel->surfmesh.data_element3i, loadmodel->surfmesh.data_normal3f, r_smoothnormals_areaweighting.integer != 0);
+ 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, r_smoothnormals_areaweighting.integer != 0);
+ loadmodel->surfmesh.isanimated = Mod_Alias_CalculateBoundingBox();
+ if(mod_alias_force_animated.string[0])
+ loadmodel->surfmesh.isanimated = mod_alias_force_animated.integer != 0;
+
+ // Always make a BIH for the first frame, we can use it where possible.
+ Mod_MakeCollisionBIH(loadmodel, true, &loadmodel->collision_bih);
+ if (!loadmodel->surfmesh.isanimated)
+ {
+ loadmodel->TraceBox = Mod_CollisionBIH_TraceBox;
+ loadmodel->TraceBrush = Mod_CollisionBIH_TraceBrush;
+ loadmodel->TraceLine = Mod_CollisionBIH_TraceLine;
+ loadmodel->TracePoint = Mod_CollisionBIH_TracePoint_Mesh;
+ loadmodel->PointSuperContents = Mod_CollisionBIH_PointSuperContents_Mesh;
+ }
+
+ // because shaders can do somewhat unexpected things, check for unusual features now
+ for (i = 0;i < loadmodel->num_textures;i++)
+ {
+ if (loadmodel->data_textures[i].basematerialflags & (MATERIALFLAG_SKY))
+ mod->DrawSky = R_Q1BSP_DrawSky;
+ if (loadmodel->data_textures[i].basematerialflags & (MATERIALFLAG_WATERSHADER | MATERIALFLAG_REFRACTION | MATERIALFLAG_REFLECTION | MATERIALFLAG_CAMERA))
+ mod->DrawAddWaterPlanes = R_Q1BSP_DrawAddWaterPlanes;
+ }
+}
+
+void Mod_INTERQUAKEMODEL_Load(dp_model_t *mod, void *buffer, void *bufferend)
+{
+ unsigned char *data;
+ const char *text;
+ const unsigned char *pbase, *pend;
+ iqmheader_t header;
+ skinfile_t *skinfiles;
+ int i, j, k, meshvertices, meshtriangles;
+ float biggestorigin;
+ const unsigned int *inelements;
+ int *outelements;
+ float *outvertex, *outnormal, *outtexcoord, *outsvector, *outtvector, *outcolor;
+ // this pointers into the file data are read only through Little* functions so they can be unaligned memory
+ const float *vnormal = NULL;
+ const float *vposition = NULL;
+ const float *vtangent = NULL;
+ const float *vtexcoord = NULL;
+ const float *vcolor4f = NULL;
+ const unsigned char *vblendindexes = NULL;
+ const unsigned char *vblendweights = NULL;
+ const unsigned char *vcolor4ub = NULL;
+ const unsigned short *framedata = NULL;
+ // temporary memory allocations (because the data in the file may be misaligned)
+ iqmanim_t *anims = NULL;
+ iqmbounds_t *bounds = NULL;
+ iqmjoint1_t *joint1 = NULL;
+ iqmjoint_t *joint = NULL;
+ iqmmesh_t *meshes = NULL;
+ iqmpose1_t *pose1 = NULL;
+ iqmpose_t *pose = NULL;
+ iqmvertexarray_t *vas = NULL;
+
+ pbase = (unsigned char *)buffer;
+ pend = (unsigned char *)bufferend;
+
+ if (pbase + sizeof(iqmheader_t) > pend)
+ Host_Error ("Mod_INTERQUAKEMODEL_Load: %s is not an Inter-Quake Model %d", loadmodel->name, (int)(pend - pbase));
+
+ // copy struct (otherwise it may be misaligned)
+ // LadyHavoc: okay it's definitely not misaligned here, but for consistency...
+ memcpy(&header, pbase, sizeof(iqmheader_t));
+
+ if (memcmp(header.id, "INTERQUAKEMODEL", 16))
+ Host_Error ("Mod_INTERQUAKEMODEL_Load: %s is not an Inter-Quake Model", loadmodel->name);
+ if (LittleLong(header.version) != 1 && LittleLong(header.version) != 2)
+ Host_Error ("Mod_INTERQUAKEMODEL_Load: only version 1 and 2 models are currently supported (name = %s)", loadmodel->name);
+
+ loadmodel->modeldatatypestring = "IQM";
+
+ loadmodel->type = mod_alias;
+ loadmodel->synctype = ST_RAND;
+
+ // byteswap header
+ header.version = LittleLong(header.version);
+ header.filesize = LittleLong(header.filesize);
+ header.flags = LittleLong(header.flags);
+ header.num_text = LittleLong(header.num_text);
+ header.ofs_text = LittleLong(header.ofs_text);
+ header.num_meshes = LittleLong(header.num_meshes);
+ header.ofs_meshes = LittleLong(header.ofs_meshes);
+ header.num_vertexarrays = LittleLong(header.num_vertexarrays);
+ header.num_vertexes = LittleLong(header.num_vertexes);
+ header.ofs_vertexarrays = LittleLong(header.ofs_vertexarrays);
+ header.num_triangles = LittleLong(header.num_triangles);
+ header.ofs_triangles = LittleLong(header.ofs_triangles);
+ header.ofs_neighbors = LittleLong(header.ofs_neighbors);
+ header.num_joints = LittleLong(header.num_joints);
+ header.ofs_joints = LittleLong(header.ofs_joints);
+ header.num_poses = LittleLong(header.num_poses);
+ header.ofs_poses = LittleLong(header.ofs_poses);
+ header.num_anims = LittleLong(header.num_anims);
+ header.ofs_anims = LittleLong(header.ofs_anims);
+ header.num_frames = LittleLong(header.num_frames);
+ header.num_framechannels = LittleLong(header.num_framechannels);
+ header.ofs_frames = LittleLong(header.ofs_frames);
+ header.ofs_bounds = LittleLong(header.ofs_bounds);
+ header.num_comment = LittleLong(header.num_comment);
+ header.ofs_comment = LittleLong(header.ofs_comment);
+ header.num_extensions = LittleLong(header.num_extensions);
+ header.ofs_extensions = LittleLong(header.ofs_extensions);
+
+ if (header.version == 1)
+ {
+ if (pbase + header.ofs_joints + header.num_joints*sizeof(iqmjoint1_t) > pend ||
+ pbase + header.ofs_poses + header.num_poses*sizeof(iqmpose1_t) > pend)
+ {
+ Con_Printf("%s has invalid size or offset information\n", loadmodel->name);
+ return;
+ }
+ }
+ else
+ {
+ if (pbase + header.ofs_joints + header.num_joints*sizeof(iqmjoint_t) > pend ||
+ pbase + header.ofs_poses + header.num_poses*sizeof(iqmpose_t) > pend)
+ {
+ Con_Printf("%s has invalid size or offset information\n", loadmodel->name);
+ return;
+ }
+ }
+ if (pbase + header.ofs_text + header.num_text > pend ||
+ pbase + header.ofs_meshes + header.num_meshes*sizeof(iqmmesh_t) > pend ||
+ pbase + header.ofs_vertexarrays + header.num_vertexarrays*sizeof(iqmvertexarray_t) > pend ||
+ pbase + header.ofs_triangles + header.num_triangles*sizeof(int[3]) > pend ||
+ (header.ofs_neighbors && pbase + header.ofs_neighbors + header.num_triangles*sizeof(int[3]) > pend) ||
+ pbase + header.ofs_anims + header.num_anims*sizeof(iqmanim_t) > pend ||
+ pbase + header.ofs_frames + header.num_frames*header.num_framechannels*sizeof(unsigned short) > pend ||
+ (header.ofs_bounds && pbase + header.ofs_bounds + header.num_frames*sizeof(iqmbounds_t) > pend) ||
+ pbase + header.ofs_comment + header.num_comment > pend)
+ {
+ Con_Printf("%s has invalid size or offset information\n", loadmodel->name);
+ return;
+ }
+
+ // copy structs to make them aligned in memory (otherwise we crash on Sparc and PowerPC and others)
+ if (header.num_vertexarrays)
+ vas = (iqmvertexarray_t *)(pbase + header.ofs_vertexarrays);
+ if (header.num_anims)
+ anims = (iqmanim_t *)(pbase + header.ofs_anims);
+ if (header.ofs_bounds)
+ bounds = (iqmbounds_t *)(pbase + header.ofs_bounds);
+ if (header.num_meshes)
+ meshes = (iqmmesh_t *)(pbase + header.ofs_meshes);
+
+ for (i = 0;i < (int)header.num_vertexarrays;i++)
+ {
+ iqmvertexarray_t va;
+ size_t vsize;
+ va.type = LittleLong(vas[i].type);
+ va.flags = LittleLong(vas[i].flags);
+ va.format = LittleLong(vas[i].format);
+ va.size = LittleLong(vas[i].size);
+ va.offset = LittleLong(vas[i].offset);
+ vsize = header.num_vertexes*va.size;
+ switch (va.format)
+ {
+ case IQM_FLOAT: vsize *= sizeof(float); break;
+ case IQM_UBYTE: vsize *= sizeof(unsigned char); break;
+ default: continue;
+ }
+ if (pbase + va.offset + vsize > pend)
+ continue;
+ // no need to copy the vertex data for alignment because LittleLong/LittleShort will be invoked on reading them, and the destination is aligned
+ switch (va.type)
+ {
+ case IQM_POSITION:
+ if (va.format == IQM_FLOAT && va.size == 3)
+ vposition = (const float *)(pbase + va.offset);
+ break;
+ case IQM_TEXCOORD:
+ if (va.format == IQM_FLOAT && va.size == 2)
+ vtexcoord = (const float *)(pbase + va.offset);
+ break;
+ case IQM_NORMAL:
+ if (va.format == IQM_FLOAT && va.size == 3)
+ vnormal = (const float *)(pbase + va.offset);
+ break;
+ case IQM_TANGENT:
+ if (va.format == IQM_FLOAT && va.size == 4)
+ vtangent = (const float *)(pbase + va.offset);
+ break;
+ case IQM_BLENDINDEXES:
+ if (va.format == IQM_UBYTE && va.size == 4)
+ vblendindexes = (const unsigned char *)(pbase + va.offset);
+ break;
+ case IQM_BLENDWEIGHTS:
+ if (va.format == IQM_UBYTE && va.size == 4)
+ vblendweights = (const unsigned char *)(pbase + va.offset);
+ break;
+ case IQM_COLOR:
+ if (va.format == IQM_FLOAT && va.size == 4)
+ vcolor4f = (const float *)(pbase + va.offset);
+ if (va.format == IQM_UBYTE && va.size == 4)
+ vcolor4ub = (const unsigned char *)(pbase + va.offset);
+ break;
+ }
+ }
+ if (header.num_vertexes > 0 && (!vposition || !vtexcoord || ((header.num_frames > 0 || header.num_anims > 0) && (!vblendindexes || !vblendweights))))
+ {
+ Con_Printf("%s is missing vertex array data\n", loadmodel->name);
+ return;
+ }
+
+ text = header.num_text && header.ofs_text ? (const char *)(pbase + header.ofs_text) : "";
+
+ loadmodel->DrawSky = NULL;
+ loadmodel->DrawAddWaterPlanes = NULL;
+ loadmodel->Draw = R_Q1BSP_Draw;
+ loadmodel->DrawDepth = R_Q1BSP_DrawDepth;
+ loadmodel->DrawDebug = R_Q1BSP_DrawDebug;
+ loadmodel->DrawPrepass = R_Q1BSP_DrawPrepass;
+ loadmodel->CompileShadowMap = R_Q1BSP_CompileShadowMap;
+ loadmodel->DrawShadowMap = R_Q1BSP_DrawShadowMap;
+ loadmodel->DrawLight = R_Q1BSP_DrawLight;
+ loadmodel->TraceBox = Mod_MDLMD2MD3_TraceBox;
+ loadmodel->TraceLine = Mod_MDLMD2MD3_TraceLine;
+ loadmodel->PointSuperContents = NULL;
+ loadmodel->AnimateVertices = Mod_Skeletal_AnimateVertices;
+
+ // load external .skin files if present
+ skinfiles = Mod_LoadSkinFiles();
+ if (loadmodel->numskins < 1)
+ loadmodel->numskins = 1;
+
+ loadmodel->numframes = max(header.num_anims, 1);
+ loadmodel->num_bones = header.num_joints;
+ loadmodel->num_poses = max(header.num_frames, 1);
+ loadmodel->nummodelsurfaces = loadmodel->num_surfaces = header.num_meshes;
+ loadmodel->num_textures = loadmodel->num_surfaces * loadmodel->numskins;
+ loadmodel->num_texturesperskin = loadmodel->num_surfaces;
+
+ meshvertices = header.num_vertexes;
+ meshtriangles = header.num_triangles;
+
+ // 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) + meshvertices * (sizeof(float[14]) + (vcolor4f || vcolor4ub ? sizeof(float[4]) : 0)) + (vblendindexes && vblendweights ? meshvertices * (sizeof(unsigned short) + sizeof(unsigned char[2][4])) : 0) + loadmodel->num_poses * loadmodel->num_bones * sizeof(short[7]) + 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_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]);
+ if (vcolor4f || vcolor4ub)
+ {
+ loadmodel->surfmesh.data_lightmapcolor4f = (float *)data;data += meshvertices * sizeof(float[4]);
+ }
+ if (vblendindexes && vblendweights)
+ {
+ loadmodel->surfmesh.data_skeletalindex4ub = (unsigned char *)data;data += meshvertices * sizeof(unsigned char[4]);
+ loadmodel->surfmesh.data_skeletalweight4ub = (unsigned char *)data;data += meshvertices * sizeof(unsigned char[4]);
+ }
+ 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 (vblendindexes && vblendweights)
+ {
+ loadmodel->surfmesh.num_blends = 0;
+ loadmodel->surfmesh.blends = (unsigned short *)data;data += meshvertices * sizeof(unsigned short);
+ }
+ if (meshvertices <= 65536)
+ {
+ loadmodel->surfmesh.data_element3s = (unsigned short *)data;data += meshtriangles * sizeof(unsigned short[3]);
+ }
+ loadmodel->data_poses7s = (short *)data;data += loadmodel->num_poses * loadmodel->num_bones * sizeof(short[7]);
+ if (vblendindexes && vblendweights)
+ loadmodel->surfmesh.data_blendweights = (blendweights_t *)Mem_Alloc(loadmodel->mempool, meshvertices * sizeof(blendweights_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;
+ }
+
+ // load the bone info
+ if (header.version == 1)
+ {
+ iqmjoint1_t *injoint1 = (iqmjoint1_t *)(pbase + header.ofs_joints);
+ if (loadmodel->num_bones)
+ joint1 = (iqmjoint1_t *)Mem_Alloc(loadmodel->mempool, loadmodel->num_bones * sizeof(iqmjoint1_t));
+ for (i = 0;i < loadmodel->num_bones;i++)
+ {
+ matrix4x4_t relbase, relinvbase, pinvbase, invbase;
+ joint1[i].name = LittleLong(injoint1[i].name);
+ joint1[i].parent = LittleLong(injoint1[i].parent);
+ for (j = 0;j < 3;j++)
+ {
+ joint1[i].origin[j] = LittleFloat(injoint1[i].origin[j]);
+ joint1[i].rotation[j] = LittleFloat(injoint1[i].rotation[j]);
+ joint1[i].scale[j] = LittleFloat(injoint1[i].scale[j]);
+ }
+ strlcpy(loadmodel->data_bones[i].name, &text[joint1[i].name], sizeof(loadmodel->data_bones[i].name));
+ loadmodel->data_bones[i].parent = joint1[i].parent;
+ if (loadmodel->data_bones[i].parent >= i)
+ Host_Error("%s bone[%i].parent >= %i", loadmodel->name, i, i);
+ Matrix4x4_FromDoom3Joint(&relbase, joint1[i].origin[0], joint1[i].origin[1], joint1[i].origin[2], joint1[i].rotation[0], joint1[i].rotation[1], joint1[i].rotation[2]);
+ Matrix4x4_Invert_Simple(&relinvbase, &relbase);
+ if (loadmodel->data_bones[i].parent >= 0)
+ {
+ Matrix4x4_FromArray12FloatD3D(&pinvbase, loadmodel->data_baseboneposeinverse + 12*loadmodel->data_bones[i].parent);
+ Matrix4x4_Concat(&invbase, &relinvbase, &pinvbase);
+ Matrix4x4_ToArray12FloatD3D(&invbase, loadmodel->data_baseboneposeinverse + 12*i);
+ }
+ else Matrix4x4_ToArray12FloatD3D(&relinvbase, loadmodel->data_baseboneposeinverse + 12*i);
+ }
+ }
+ else
+ {
+ iqmjoint_t *injoint = (iqmjoint_t *)(pbase + header.ofs_joints);
+ if (header.num_joints)
+ joint = (iqmjoint_t *)Mem_Alloc(loadmodel->mempool, loadmodel->num_bones * sizeof(iqmjoint_t));
+ for (i = 0;i < loadmodel->num_bones;i++)
+ {
+ matrix4x4_t relbase, relinvbase, pinvbase, invbase;
+ joint[i].name = LittleLong(injoint[i].name);
+ joint[i].parent = LittleLong(injoint[i].parent);
+ for (j = 0;j < 3;j++)
+ {
+ joint[i].origin[j] = LittleFloat(injoint[i].origin[j]);
+ joint[i].rotation[j] = LittleFloat(injoint[i].rotation[j]);
+ joint[i].scale[j] = LittleFloat(injoint[i].scale[j]);
+ }
+ joint[i].rotation[3] = LittleFloat(injoint[i].rotation[3]);
+ strlcpy(loadmodel->data_bones[i].name, &text[joint[i].name], sizeof(loadmodel->data_bones[i].name));
+ loadmodel->data_bones[i].parent = joint[i].parent;
+ if (loadmodel->data_bones[i].parent >= i)
+ Host_Error("%s bone[%i].parent >= %i", loadmodel->name, i, i);
+ if (joint[i].rotation[3] > 0)
+ Vector4Negate(joint[i].rotation, joint[i].rotation);
+ Vector4Normalize2(joint[i].rotation, joint[i].rotation);
+ Matrix4x4_FromDoom3Joint(&relbase, joint[i].origin[0], joint[i].origin[1], joint[i].origin[2], joint[i].rotation[0], joint[i].rotation[1], joint[i].rotation[2]);
+ Matrix4x4_Invert_Simple(&relinvbase, &relbase);
+ if (loadmodel->data_bones[i].parent >= 0)
+ {
+ Matrix4x4_FromArray12FloatD3D(&pinvbase, loadmodel->data_baseboneposeinverse + 12*loadmodel->data_bones[i].parent);
+ Matrix4x4_Concat(&invbase, &relinvbase, &pinvbase);
+ Matrix4x4_ToArray12FloatD3D(&invbase, loadmodel->data_baseboneposeinverse + 12*i);
+ }
+ else Matrix4x4_ToArray12FloatD3D(&relinvbase, loadmodel->data_baseboneposeinverse + 12*i);
+ }
+ }
+
+ // set up the animscenes based on the anims
+ for (i = 0;i < (int)header.num_anims;i++)
+ {
+ iqmanim_t anim;
+ anim.name = LittleLong(anims[i].name);
+ anim.first_frame = LittleLong(anims[i].first_frame);
+ anim.num_frames = LittleLong(anims[i].num_frames);
+ anim.framerate = LittleFloat(anims[i].framerate);
+ anim.flags = LittleLong(anims[i].flags);
+ strlcpy(loadmodel->animscenes[i].name, &text[anim.name], sizeof(loadmodel->animscenes[i].name));
+ loadmodel->animscenes[i].firstframe = anim.first_frame;
+ loadmodel->animscenes[i].framecount = anim.num_frames;
+ loadmodel->animscenes[i].loop = ((anim.flags & IQM_LOOP) != 0);
+ loadmodel->animscenes[i].framerate = anim.framerate;
+ }
+ if (header.num_anims <= 0)
+ {
+ strlcpy(loadmodel->animscenes[0].name, "static", sizeof(loadmodel->animscenes[0].name));
+ loadmodel->animscenes[0].firstframe = 0;
+ loadmodel->animscenes[0].framecount = 1;
+ loadmodel->animscenes[0].loop = true;
+ loadmodel->animscenes[0].framerate = 10;
+ }
+
+ loadmodel->surfmesh.isanimated = loadmodel->num_bones > 1 || loadmodel->numframes > 1 || (loadmodel->animscenes && loadmodel->animscenes[0].framecount > 1);
+ if(mod_alias_force_animated.string[0])
+ loadmodel->surfmesh.isanimated = mod_alias_force_animated.integer != 0;
+