Cvar_RegisterVariable(&r_mipskins);
}
-static float vertst[MAXALIASVERTS][2];
-static int vertusage[MAXALIASVERTS];
-static int vertonseam[MAXALIASVERTS];
-static int vertremap[MAXALIASVERTS];
-static int temptris[MAXALIASTRIS][3];
-
static void Mod_CalcAliasModelBBoxes (void)
{
int vnum, meshnum;
float dist, yawradius, radius;
aliasmesh_t *mesh;
- aliasvertex_t *v;
+ float *v;
VectorClear(loadmodel->normalmins);
VectorClear(loadmodel->normalmaxs);
yawradius = 0;
radius = 0;
for (meshnum = 0, mesh = loadmodel->aliasdata_meshes;meshnum < loadmodel->aliasnum_meshes;meshnum++, mesh++)
{
- for (vnum = 0, v = mesh->data_vertices;vnum < mesh->num_vertices * mesh->num_frames;vnum++, v++)
+ for (vnum = 0, v = mesh->data_aliasvertex3f;vnum < mesh->num_vertices * mesh->num_frames;vnum++, v += 3)
{
- if (loadmodel->normalmins[0] > v->origin[0]) loadmodel->normalmins[0] = v->origin[0];
- if (loadmodel->normalmins[1] > v->origin[1]) loadmodel->normalmins[1] = v->origin[1];
- if (loadmodel->normalmins[2] > v->origin[2]) loadmodel->normalmins[2] = v->origin[2];
- if (loadmodel->normalmaxs[0] < v->origin[0]) loadmodel->normalmaxs[0] = v->origin[0];
- if (loadmodel->normalmaxs[1] < v->origin[1]) loadmodel->normalmaxs[1] = v->origin[1];
- if (loadmodel->normalmaxs[2] < v->origin[2]) loadmodel->normalmaxs[2] = v->origin[2];
- dist = v->origin[0] * v->origin[0] + v->origin[1] * v->origin[1];
+ if (loadmodel->normalmins[0] > v[0]) loadmodel->normalmins[0] = v[0];
+ if (loadmodel->normalmins[1] > v[1]) loadmodel->normalmins[1] = v[1];
+ if (loadmodel->normalmins[2] > v[2]) loadmodel->normalmins[2] = v[2];
+ if (loadmodel->normalmaxs[0] < v[0]) loadmodel->normalmaxs[0] = v[0];
+ if (loadmodel->normalmaxs[1] < v[1]) loadmodel->normalmaxs[1] = v[1];
+ if (loadmodel->normalmaxs[2] < v[2]) loadmodel->normalmaxs[2] = v[2];
+ dist = v[0] * v[0] + v[1] * v[1];
if (yawradius < dist)
yawradius = dist;
- dist += v->origin[2] * v->origin[2];
+ dist += v[2] * v[2];
if (radius < dist)
radius = dist;
}
loadmodel->radius2 = radius * radius;
}
-static void Mod_ConvertAliasVerts (int inverts, vec3_t scale, vec3_t translate, trivertx_t *v, aliasvertex_t *out)
+static void Mod_ConvertAliasVerts (int inverts, vec3_t scale, vec3_t translate, trivertx_t *v, float *out3f, int *vertremap)
{
int i, j;
vec3_t temp;
temp[2] = v[i].v[2] * scale[2] + translate[2];
j = vertremap[i]; // not onseam
if (j >= 0)
- VectorCopy(temp, out[j].origin);
+ VectorCopy(temp, out3f + j * 3);
j = vertremap[i+inverts]; // onseam
if (j >= 0)
- VectorCopy(temp, out[j].origin);
+ VectorCopy(temp, out3f + j * 3);
}
}
-static void Mod_BuildAliasVertexTextureVectors(int numverts, aliasvertex_t *vertices, const float *texcoords, float *vertexbuffer, float *svectorsbuffer, float *tvectorsbuffer, float *normalsbuffer, int numtriangles, const int *elements)
-{
- int i;
- for (i = 0;i < numverts;i++)
- VectorCopy(vertices[i].origin, &vertexbuffer[i * 4]);
- Mod_BuildTextureVectorsAndNormals(numverts, numtriangles, vertexbuffer, texcoords, elements, svectorsbuffer, tvectorsbuffer, normalsbuffer);
- for (i = 0;i < numverts;i++)
- {
- // LordHavoc: alias models are backwards, apparently
- vertices[i].normal[0] = normalsbuffer[i * 4 + 0];
- vertices[i].normal[1] = normalsbuffer[i * 4 + 1];
- vertices[i].normal[2] = normalsbuffer[i * 4 + 2];
- vertices[i].svector[0] = svectorsbuffer[i * 4 + 0];
- vertices[i].svector[1] = svectorsbuffer[i * 4 + 1];
- vertices[i].svector[2] = svectorsbuffer[i * 4 + 2];
- }
-}
-
-static void Mod_MDL_LoadFrames (qbyte* datapointer, int inverts, int outverts, vec3_t scale, vec3_t translate, float *texcoords, aliasvertex_t *posedata, int numtris, int *elements)
+static void Mod_MDL_LoadFrames (qbyte* datapointer, int inverts, vec3_t scale, vec3_t translate, int *vertremap)
{
int i, f, pose, groupframes;
- float interval, *vertexbuffer, *svectorsbuffer, *tvectorsbuffer, *normalsbuffer;
+ float interval;
daliasframetype_t *pframetype;
daliasframe_t *pinframe;
daliasgroup_t *group;
animscene_t *scene;
pose = 0;
scene = loadmodel->animscenes;
- vertexbuffer = Mem_Alloc(tempmempool, outverts * sizeof(float[4]) * 4);
- svectorsbuffer = vertexbuffer + outverts * 4;
- tvectorsbuffer = svectorsbuffer + outverts * 4;
- normalsbuffer = tvectorsbuffer + outverts * 4;
for (f = 0;f < loadmodel->numframes;f++)
{
pframetype = (daliasframetype_t *)datapointer;
{
pinframe = (daliasframe_t *)datapointer;
datapointer += sizeof(daliasframe_t);
- Mod_ConvertAliasVerts(inverts, scale, translate, (trivertx_t *)datapointer, posedata + pose * outverts);
- Mod_BuildAliasVertexTextureVectors(outverts, posedata + pose * outverts, texcoords, vertexbuffer, svectorsbuffer, tvectorsbuffer, normalsbuffer, numtris, elements);
+ Mod_ConvertAliasVerts(inverts, scale, translate, (trivertx_t *)datapointer, loadmodel->aliasdata_meshes->data_aliasvertex3f + pose * loadmodel->aliasdata_meshes->num_vertices * 3, vertremap);
+ Mod_BuildTextureVectorsAndNormals(loadmodel->aliasdata_meshes->num_vertices, loadmodel->aliasdata_meshes->num_triangles, loadmodel->aliasdata_meshes->data_aliasvertex3f + pose * loadmodel->aliasdata_meshes->num_vertices * 3, loadmodel->aliasdata_meshes->data_texcoord2f, loadmodel->aliasdata_meshes->data_element3i, loadmodel->aliasdata_meshes->data_aliassvector3f + pose * loadmodel->aliasdata_meshes->num_vertices * 3, loadmodel->aliasdata_meshes->data_aliastvector3f + pose * loadmodel->aliasdata_meshes->num_vertices * 3, loadmodel->aliasdata_meshes->data_aliasnormal3f + pose * loadmodel->aliasdata_meshes->num_vertices * 3);
datapointer += sizeof(trivertx_t) * inverts;
pose++;
}
}
- Mem_Free(vertexbuffer);
}
+aliaslayer_t mod_alias_layersbuffer[16]; // 7 currently used
void Mod_BuildAliasSkinFromSkinFrame(aliasskin_t *skin, skinframe_t *skinframe)
{
aliaslayer_t *layer;
- skin->flags = 0;
- // fog texture only exists if some pixels are transparent...
- if (skinframe->fog != NULL)
- skin->flags |= ALIASSKIN_TRANSPARENT;
- // fog and gloss layers always exist
- skin->num_layers = 2;
- if (skinframe->glow != NULL)
- skin->num_layers++;
- if (skinframe->merged != NULL)
- skin->num_layers += 2;
- if (skinframe->base != NULL)
- skin->num_layers += 2;
- if (skinframe->pants != NULL)
- skin->num_layers += 2;
- if (skinframe->shirt != NULL)
- skin->num_layers += 2;
- layer = skin->data_layers = Mem_Alloc(loadmodel->mempool, skin->num_layers * sizeof(aliaslayer_t));
- if (skinframe->glow != NULL)
- {
- layer->flags = 0;
- layer->texture = skinframe->glow;
- layer++;
- }
+
+ memset(&mod_alias_layersbuffer, 0, sizeof(mod_alias_layersbuffer));
+ layer = mod_alias_layersbuffer;
+ layer->flags = ALIASLAYER_SPECULAR;
+ layer->texture = skinframe->gloss;
+ layer->nmap = skinframe->nmap;
+ layer++;
if (skinframe->merged != NULL)
{
- layer->flags = ALIASLAYER_NODRAW_IF_COLORMAPPED | ALIASLAYER_DIFFUSE;
- if (skinframe->glow != NULL)
- layer->flags |= ALIASLAYER_ADD;
+ layer->flags = ALIASLAYER_DIFFUSE | ALIASLAYER_NODRAW_IF_COLORMAPPED;
layer->texture = skinframe->merged;
layer->nmap = skinframe->nmap;
layer++;
}
if (skinframe->base != NULL)
{
- layer->flags = ALIASLAYER_NODRAW_IF_NOTCOLORMAPPED | ALIASLAYER_DIFFUSE;
- if (skinframe->glow != NULL)
- layer->flags |= ALIASLAYER_ADD;
+ layer->flags = ALIASLAYER_DIFFUSE;
+ if (skinframe->merged != NULL)
+ layer->flags |= ALIASLAYER_NODRAW_IF_NOTCOLORMAPPED;
layer->texture = skinframe->base;
layer->nmap = skinframe->nmap;
layer++;
}
if (skinframe->pants != NULL)
{
- layer->flags = ALIASLAYER_NODRAW_IF_NOTCOLORMAPPED | ALIASLAYER_DIFFUSE | ALIASLAYER_COLORMAP_SHIRT;
- if (skinframe->glow != NULL || skinframe->base != NULL)
- layer->flags |= ALIASLAYER_ADD;
+ layer->flags = ALIASLAYER_DIFFUSE | ALIASLAYER_NODRAW_IF_NOTCOLORMAPPED | ALIASLAYER_COLORMAP_PANTS;
layer->texture = skinframe->pants;
layer->nmap = skinframe->nmap;
layer++;
}
if (skinframe->shirt != NULL)
{
- layer->flags = ALIASLAYER_NODRAW_IF_NOTCOLORMAPPED | ALIASLAYER_DIFFUSE | ALIASLAYER_COLORMAP_SHIRT;
- if (skinframe->glow != NULL || skinframe->base != NULL || skinframe->pants != NULL)
- layer->flags |= ALIASLAYER_ADD;
+ layer->flags = ALIASLAYER_DIFFUSE | ALIASLAYER_NODRAW_IF_NOTCOLORMAPPED | ALIASLAYER_COLORMAP_SHIRT;
layer->texture = skinframe->shirt;
layer->nmap = skinframe->nmap;
layer++;
}
- layer->flags = ALIASLAYER_FOG;
- layer->texture = skinframe->fog;
- layer++;
- layer->flags = ALIASLAYER_DRAW_PER_LIGHT | ALIASLAYER_SPECULAR;
- layer->texture = skinframe->gloss;
- layer->nmap = skinframe->nmap;
- layer++;
- if (skinframe->merged != NULL)
+
+ if (skinframe->glow != NULL)
{
- layer->flags = ALIASLAYER_DRAW_PER_LIGHT | ALIASLAYER_NODRAW_IF_COLORMAPPED | ALIASLAYER_DIFFUSE;
- layer->texture = skinframe->merged;
- layer->nmap = skinframe->nmap;
+ layer->flags = 0;
+ layer->texture = skinframe->glow;
layer++;
- }
- if (skinframe->base != NULL)
- {
- layer->flags = ALIASLAYER_DRAW_PER_LIGHT | ALIASLAYER_NODRAW_IF_NOTCOLORMAPPED | ALIASLAYER_DIFFUSE;
- layer->texture = skinframe->base;
- layer->nmap = skinframe->nmap;
+ layer->flags = ALIASLAYER_FOG;
+ layer->texture = skinframe->fog;
layer++;
}
- if (skinframe->pants != NULL)
+ else
{
- layer->flags = ALIASLAYER_DRAW_PER_LIGHT | ALIASLAYER_NODRAW_IF_NOTCOLORMAPPED | ALIASLAYER_DIFFUSE | ALIASLAYER_COLORMAP_PANTS;
- layer->texture = skinframe->pants;
- layer->nmap = skinframe->nmap;
+ layer->flags = ALIASLAYER_FOG | ALIASLAYER_FORCEDRAW_IF_FIRSTPASS;
+ layer->texture = skinframe->fog;
layer++;
}
- if (skinframe->shirt != NULL)
- {
- layer->flags = ALIASLAYER_DRAW_PER_LIGHT | ALIASLAYER_NODRAW_IF_NOTCOLORMAPPED | ALIASLAYER_DIFFUSE | ALIASLAYER_COLORMAP_SHIRT;
- layer->texture = skinframe->shirt;
- layer->nmap = skinframe->nmap;
- layer++;
- }
-}
-void Mod_BuildMDLMD2MeshInfo(int numverts, int numtris, int *elements, float *texcoords, aliasvertex_t *posedata)
-{
- int i;
- aliasmesh_t *mesh;
+ skin->flags = 0;
+ // fog texture only exists if some pixels are transparent...
+ if (skinframe->fog != NULL)
+ skin->flags |= ALIASSKIN_TRANSPARENT;
- loadmodel->aliasnum_meshes = 1;
- mesh = loadmodel->aliasdata_meshes = Mem_Alloc(loadmodel->mempool, loadmodel->aliasnum_meshes * sizeof(aliasmesh_t));
- mesh->num_skins = 0;
- mesh->num_frames = 0;
- for (i = 0;i < loadmodel->numframes;i++)
- mesh->num_frames += loadmodel->animscenes[i].framecount;
- for (i = 0;i < loadmodel->numskins;i++)
- mesh->num_skins += loadmodel->skinscenes[i].framecount;
- mesh->num_triangles = numtris;
- mesh->num_vertices = numverts;
- mesh->data_skins = Mem_Alloc(loadmodel->mempool, mesh->num_skins * sizeof(aliasskin_t));
- mesh->data_elements = elements;
- mesh->data_neighbors = Mem_Alloc(loadmodel->mempool, numtris * sizeof(int[3]));
- Mod_ValidateElements(mesh->data_elements, mesh->num_triangles, mesh->num_vertices, __FILE__, __LINE__);
- Mod_BuildTriangleNeighbors(mesh->data_neighbors, mesh->data_elements, mesh->num_triangles);
- mesh->data_texcoords = texcoords;
- mesh->data_vertices = posedata;
- for (i = 0;i < mesh->num_skins;i++)
- Mod_BuildAliasSkinFromSkinFrame(mesh->data_skins + i, loadmodel->skinframes + i);
- Mod_CalcAliasModelBBoxes();
+ skin->num_layers = layer - mod_alias_layersbuffer;
+ skin->data_layers = Mem_Alloc(loadmodel->mempool, skin->num_layers * sizeof(aliaslayer_t));
+ memcpy(skin->data_layers, mod_alias_layersbuffer, skin->num_layers * sizeof(aliaslayer_t));
}
#define BOUNDI(VALUE,MIN,MAX) if (VALUE < MIN || VALUE >= MAX) Host_Error("model %s has an invalid ##VALUE (%d exceeds %d - %d)\n", loadmodel->name, VALUE, MIN, MAX);
extern void R_Model_Alias_DrawFakeShadow(entity_render_t *ent);
extern void R_Model_Alias_DrawShadowVolume(entity_render_t *ent, vec3_t relativelightorigin, float lightradius);
extern void R_Model_Alias_DrawLight(entity_render_t *ent, vec3_t relativelightorigin, vec3_t relativeeyeorigin, float lightradius, float *lightcolor, const matrix4x4_t *matrix_modeltofilter, const matrix4x4_t *matrix_modeltoattenuationxyz, const matrix4x4_t *matrix_modeltoattenuationz);
-void Mod_LoadQ1AliasModel (model_t *mod, void *buffer)
+void Mod_IDP0_Load(model_t *mod, void *buffer)
{
- int i, j, version, totalposes, totalskins, skinwidth, skinheight, totalverts, groupframes, groupskins, *elements, numverts, numtris;
- float scales, scalet, scale[3], translate[3], interval, *texcoords;
+ int i, j, version, totalskins, skinwidth, skinheight, groupframes, groupskins, numverts;
+ float scales, scalet, scale[3], translate[3], interval;
mdl_t *pinmodel;
stvert_t *pinstverts;
dtriangle_t *pintriangles;
daliasskininterval_t *pinskinintervals;
daliasframetype_t *pinframetype;
daliasgroup_t *pinframegroup;
- aliasvertex_t *posedata;
qbyte *datapointer, *startframes, *startskins;
char name[MAX_QPATH];
skinframe_t tempskinframe;
animscene_t *tempskinscenes;
skinframe_t *tempskinframes;
+ float *vertst;
+ int *vertonseam, *vertremap;
datapointer = buffer;
pinmodel = (mdl_t *)datapointer;
loadmodel->DrawShadowVolume = R_Model_Alias_DrawShadowVolume;
loadmodel->DrawLight = R_Model_Alias_DrawLight;
+ loadmodel->aliasnum_meshes = 1;
+ loadmodel->aliasdata_meshes = Mem_Alloc(loadmodel->mempool, sizeof(aliasmesh_t));
+
loadmodel->numskins = LittleLong(pinmodel->numskins);
BOUNDI(loadmodel->numskins,0,256);
skinwidth = LittleLong (pinmodel->skinwidth);
skinheight = LittleLong (pinmodel->skinheight);
BOUNDI(skinheight,0,4096);
numverts = LittleLong(pinmodel->numverts);
- BOUNDI(numverts,0,MAXALIASVERTS);
- numtris = LittleLong(pinmodel->numtris);
- BOUNDI(numtris,0,MAXALIASTRIS);
+ BOUNDI(numverts,0,65536);
+ loadmodel->aliasdata_meshes->num_triangles = LittleLong(pinmodel->numtris);
+ BOUNDI(loadmodel->aliasdata_meshes->num_triangles,0,65536 / 3); // max elements limit, rather than max triangles limit
loadmodel->numframes = LittleLong(pinmodel->numframes);
BOUNDI(loadmodel->numframes,0,65536);
loadmodel->synctype = LittleLong (pinmodel->synctype);
datapointer += sizeof(stvert_t) * numverts;
pintriangles = (dtriangle_t *)datapointer;
- datapointer += sizeof(dtriangle_t) * numtris;
+ datapointer += sizeof(dtriangle_t) * loadmodel->aliasdata_meshes->num_triangles;
startframes = datapointer;
- totalposes = 0;
+ loadmodel->aliasdata_meshes->num_frames = 0;
for (i = 0;i < loadmodel->numframes;i++)
{
pinframetype = (daliasframetype_t *)datapointer;
{
datapointer += sizeof(daliasframe_t);
datapointer += sizeof(trivertx_t) * numverts;
- totalposes++;
+ loadmodel->aliasdata_meshes->num_frames++;
}
}
interval = LittleFloat(pinskinintervals[0].interval);
if (interval < 0.01f)
- Host_Error("Mod_LoadQ1AliasModel: invalid interval\n");
+ Host_Error("Mod_IDP0_Load: invalid interval\n");
}
sprintf(loadmodel->skinscenes[i].name, "skin %i", i);
sprintf (name, "%s_%i_%i", loadmodel->name, i, j);
else
sprintf (name, "%s_%i", loadmodel->name, i);
- if (!Mod_LoadSkinFrame(loadmodel->skinframes + totalskins, name, (r_mipskins.integer ? TEXF_MIPMAP : 0) | TEXF_ALPHA, true, false, true))
- Mod_LoadSkinFrame_Internal(loadmodel->skinframes + totalskins, name, (r_mipskins.integer ? TEXF_MIPMAP : 0) | TEXF_ALPHA, true, false, true, (qbyte *)datapointer, skinwidth, skinheight);
+ if (!Mod_LoadSkinFrame(loadmodel->skinframes + totalskins, name, (r_mipskins.integer ? TEXF_MIPMAP : 0) | TEXF_CLAMP | TEXF_ALPHA, true, false, true))
+ Mod_LoadSkinFrame_Internal(loadmodel->skinframes + totalskins, name, (r_mipskins.integer ? TEXF_MIPMAP : 0) | TEXF_CLAMP | TEXF_ALPHA, true, false, true, (qbyte *)datapointer, skinwidth, skinheight);
datapointer += skinwidth * skinheight;
totalskins++;
}
for (;;)
{
sprintf (name, "%s_%i", loadmodel->name, loadmodel->numskins);
- if (Mod_LoadSkinFrame (&tempskinframe, name, (r_mipskins.integer ? TEXF_MIPMAP : 0) | TEXF_ALPHA, true, false, true))
+ if (Mod_LoadSkinFrame(&tempskinframe, name, (r_mipskins.integer ? TEXF_MIPMAP : 0) | TEXF_CLAMP | TEXF_ALPHA, true, false, true))
{
// expand the arrays to make room
tempskinscenes = loadmodel->skinscenes;
break;
}
- // store texture coordinates into temporary array, they will be stored after usage is determined (triangle data)
+ loadmodel->aliasdata_meshes->num_skins = 0;
+ for (i = 0;i < loadmodel->numskins;i++)
+ loadmodel->aliasdata_meshes->num_skins += loadmodel->skinscenes[i].framecount;
+ loadmodel->aliasdata_meshes->data_skins = Mem_Alloc(loadmodel->mempool, loadmodel->aliasdata_meshes->num_skins * sizeof(aliasskin_t));
+
+ // store texture coordinates into temporary array, they will be stored
+ // after usage is determined (triangle data)
+ vertst = Mem_Alloc(tempmempool, numverts * 2 * sizeof(float[2]));
+ vertremap = Mem_Alloc(tempmempool, numverts * 3 * sizeof(int));
+ vertonseam = vertremap + numverts * 2;
+
scales = 1.0 / skinwidth;
scalet = 1.0 / skinheight;
for (i = 0;i < numverts;i++)
{
vertonseam[i] = LittleLong(pinstverts[i].onseam);
- vertst[i][0] = (LittleLong(pinstverts[i].s) + 0.5) * scales;
- vertst[i][1] = (LittleLong(pinstverts[i].t) + 0.5) * scalet;
- vertst[i+numverts][0] = vertst[i][0] + 0.5;
- vertst[i+numverts][1] = vertst[i][1];
- vertusage[i] = 0;
- vertusage[i+numverts] = 0;
+ vertst[i*2+0] = (LittleLong(pinstverts[i].s) + 0.5) * scales;
+ vertst[i*2+1] = (LittleLong(pinstverts[i].t) + 0.5) * scalet;
+ vertst[(i+numverts)*2+0] = vertst[i*2+0] + 0.5;
+ vertst[(i+numverts)*2+1] = vertst[i*2+1];
}
// load triangle data
- elements = Mem_Alloc(loadmodel->mempool, sizeof(int[3]) * numtris);
+ loadmodel->aliasdata_meshes->data_element3i = Mem_Alloc(loadmodel->mempool, sizeof(int[3]) * loadmodel->aliasdata_meshes->num_triangles);
- // count the vertices used
- for (i = 0;i < numverts*2;i++)
- vertusage[i] = 0;
- for (i = 0;i < numtris;i++)
- {
- temptris[i][0] = LittleLong(pintriangles[i].vertindex[0]);
- temptris[i][1] = LittleLong(pintriangles[i].vertindex[1]);
- temptris[i][2] = LittleLong(pintriangles[i].vertindex[2]);
+ // read the triangle elements
+ for (i = 0;i < loadmodel->aliasdata_meshes->num_triangles;i++)
+ for (j = 0;j < 3;j++)
+ loadmodel->aliasdata_meshes->data_element3i[i*3+j] = LittleLong(pintriangles[i].vertindex[j]);
+ // validate (note numverts is used because this is the original data)
+ Mod_ValidateElements(loadmodel->aliasdata_meshes->data_element3i, loadmodel->aliasdata_meshes->num_triangles, numverts, __FILE__, __LINE__);
+ // now butcher the elements according to vertonseam and tri->facesfront
+ // and then compact the vertex set to remove duplicates
+ for (i = 0;i < loadmodel->aliasdata_meshes->num_triangles;i++)
if (!LittleLong(pintriangles[i].facesfront)) // backface
- {
- if (vertonseam[temptris[i][0]]) temptris[i][0] += numverts;
- if (vertonseam[temptris[i][1]]) temptris[i][1] += numverts;
- if (vertonseam[temptris[i][2]]) temptris[i][2] += numverts;
- }
- vertusage[temptris[i][0]]++;
- vertusage[temptris[i][1]]++;
- vertusage[temptris[i][2]]++;
- }
+ for (j = 0;j < 3;j++)
+ if (vertonseam[loadmodel->aliasdata_meshes->data_element3i[i*3+j]])
+ loadmodel->aliasdata_meshes->data_element3i[i*3+j] += numverts;
+ // count the usage
+ // (this uses vertremap to count usage to save some memory)
+ for (i = 0;i < numverts*2;i++)
+ vertremap[i] = 0;
+ for (i = 0;i < loadmodel->aliasdata_meshes->num_triangles*3;i++)
+ vertremap[loadmodel->aliasdata_meshes->data_element3i[i]]++;
// build remapping table and compact array
- totalverts = 0;
+ loadmodel->aliasdata_meshes->num_vertices = 0;
for (i = 0;i < numverts*2;i++)
{
- if (vertusage[i])
+ if (vertremap[i])
{
- vertremap[i] = totalverts;
- vertst[totalverts][0] = vertst[i][0];
- vertst[totalverts][1] = vertst[i][1];
- totalverts++;
+ vertremap[i] = loadmodel->aliasdata_meshes->num_vertices;
+ vertst[loadmodel->aliasdata_meshes->num_vertices*2+0] = vertst[i*2+0];
+ vertst[loadmodel->aliasdata_meshes->num_vertices*2+1] = vertst[i*2+1];
+ loadmodel->aliasdata_meshes->num_vertices++;
}
else
vertremap[i] = -1; // not used at all
}
- // remap the triangle references
- for (i = 0;i < numtris;i++)
- {
- elements[i*3+0] = vertremap[temptris[i][0]];
- elements[i*3+1] = vertremap[temptris[i][1]];
- elements[i*3+2] = vertremap[temptris[i][2]];
- }
+ // remap the elements to the new vertex set
+ for (i = 0;i < loadmodel->aliasdata_meshes->num_triangles * 3;i++)
+ loadmodel->aliasdata_meshes->data_element3i[i] = vertremap[loadmodel->aliasdata_meshes->data_element3i[i]];
// store the texture coordinates
- texcoords = Mem_Alloc(loadmodel->mempool, sizeof(float[4]) * totalverts);
- for (i = 0;i < totalverts;i++)
+ loadmodel->aliasdata_meshes->data_texcoord2f = Mem_Alloc(loadmodel->mempool, sizeof(float[2]) * loadmodel->aliasdata_meshes->num_vertices);
+ for (i = 0;i < loadmodel->aliasdata_meshes->num_vertices;i++)
{
- texcoords[i*4+0] = vertst[i][0];
- texcoords[i*4+1] = vertst[i][1];
+ loadmodel->aliasdata_meshes->data_texcoord2f[i*2+0] = vertst[i*2+0];
+ loadmodel->aliasdata_meshes->data_texcoord2f[i*2+1] = vertst[i*2+1];
}
// load the frames
loadmodel->animscenes = Mem_Alloc(loadmodel->mempool, sizeof(animscene_t) * loadmodel->numframes);
- posedata = Mem_Alloc(loadmodel->mempool, sizeof(aliasvertex_t) * totalposes * totalverts);
- Mod_MDL_LoadFrames (startframes, numverts, totalverts, scale, translate, texcoords, posedata, numtris, elements);
- Mod_BuildMDLMD2MeshInfo(totalverts, numtris, elements, texcoords, posedata);
+ loadmodel->aliasdata_meshes->data_aliasvertex3f = Mem_Alloc(loadmodel->mempool, sizeof(float[4][3]) * loadmodel->aliasdata_meshes->num_frames * loadmodel->aliasdata_meshes->num_vertices);
+ loadmodel->aliasdata_meshes->data_aliassvector3f = loadmodel->aliasdata_meshes->data_aliasvertex3f + loadmodel->aliasdata_meshes->num_frames * loadmodel->aliasdata_meshes->num_vertices * 3 * 1;
+ loadmodel->aliasdata_meshes->data_aliastvector3f = loadmodel->aliasdata_meshes->data_aliasvertex3f + loadmodel->aliasdata_meshes->num_frames * loadmodel->aliasdata_meshes->num_vertices * 3 * 2;
+ loadmodel->aliasdata_meshes->data_aliasnormal3f = loadmodel->aliasdata_meshes->data_aliasvertex3f + loadmodel->aliasdata_meshes->num_frames * loadmodel->aliasdata_meshes->num_vertices * 3 * 3;
+ Mod_MDL_LoadFrames (startframes, numverts, scale, translate, vertremap);
+ loadmodel->aliasdata_meshes->data_neighbor3i = Mem_Alloc(loadmodel->mempool, loadmodel->aliasdata_meshes->num_triangles * sizeof(int[3]));
+ Mod_BuildTriangleNeighbors(loadmodel->aliasdata_meshes->data_neighbor3i, loadmodel->aliasdata_meshes->data_element3i, loadmodel->aliasdata_meshes->num_triangles);
+ for (i = 0;i < loadmodel->aliasdata_meshes->num_skins;i++)
+ Mod_BuildAliasSkinFromSkinFrame(loadmodel->aliasdata_meshes->data_skins + i, loadmodel->skinframes + i);
+ Mod_CalcAliasModelBBoxes();
+
+ Mem_Free(vertst);
+ Mem_Free(vertremap);
}
-static void Mod_MD2_ConvertVerts (vec3_t scale, vec3_t translate, trivertx_t *v, aliasvertex_t *out, int numverts, int *vertremap)
+static void Mod_MD2_ConvertVerts (vec3_t scale, vec3_t translate, trivertx_t *v, float *out3f, int numverts, int *vertremap)
{
int i;
trivertx_t *in;
- for (i = 0;i < numverts;i++)
+ for (i = 0;i < numverts;i++, out3f += 3)
{
in = v + vertremap[i];
- out[i].origin[0] = in->v[0] * scale[0] + translate[0];
- out[i].origin[1] = in->v[1] * scale[1] + translate[1];
- out[i].origin[2] = in->v[2] * scale[2] + translate[2];
+ out3f[0] = in->v[0] * scale[0] + translate[0];
+ out3f[1] = in->v[1] * scale[1] + translate[1];
+ out3f[2] = in->v[2] * scale[2] + translate[2];
}
}
-void Mod_LoadQ2AliasModel (model_t *mod, void *buffer)
+void Mod_IDP2_Load(model_t *mod, void *buffer)
{
- int i, j, k, hashindex, num, numxyz, numst, xyz, st, skinwidth, skinheight, *vertremap, version, end, *elements, numverts, numtris;
- float *stverts, s, t, scale[3], translate[3], *vertexbuffer, *svectorsbuffer, *tvectorsbuffer, *normalsbuffer, *texcoords;
- aliasvertex_t *posedata;
+ int i, j, k, hashindex, num, numxyz, numst, xyz, st, skinwidth, skinheight, *vertremap, version, end, numverts;
+ float *stverts, s, t, scale[3], translate[3];
md2_t *pinmodel;
qbyte *base, *datapointer;
md2frame_t *pinframe;
loadmodel->DrawShadowVolume = R_Model_Alias_DrawShadowVolume;
loadmodel->DrawLight = R_Model_Alias_DrawLight;
- if (LittleLong(pinmodel->num_tris < 1) || LittleLong(pinmodel->num_tris) > MD2MAX_TRIANGLES)
+ if (LittleLong(pinmodel->num_tris < 1) || LittleLong(pinmodel->num_tris) > (65536 / 3))
Host_Error ("%s has invalid number of triangles: %i", loadmodel->name, LittleLong(pinmodel->num_tris));
- if (LittleLong(pinmodel->num_xyz < 1) || LittleLong(pinmodel->num_xyz) > MD2MAX_VERTS)
+ if (LittleLong(pinmodel->num_xyz < 1) || LittleLong(pinmodel->num_xyz) > 65536)
Host_Error ("%s has invalid number of vertices: %i", loadmodel->name, LittleLong(pinmodel->num_xyz));
- if (LittleLong(pinmodel->num_frames < 1) || LittleLong(pinmodel->num_frames) > MD2MAX_FRAMES)
+ if (LittleLong(pinmodel->num_frames < 1) || LittleLong(pinmodel->num_frames) > 65536)
Host_Error ("%s has invalid number of frames: %i", loadmodel->name, LittleLong(pinmodel->num_frames));
- if (LittleLong(pinmodel->num_skins < 0) || LittleLong(pinmodel->num_skins) > MAX_SKINS)
+ if (LittleLong(pinmodel->num_skins < 0) || LittleLong(pinmodel->num_skins) > 256)
Host_Error ("%s has invalid number of skins: %i", loadmodel->name, LittleLong(pinmodel->num_skins));
end = LittleLong(pinmodel->ofs_end);
if (LittleLong(pinmodel->ofs_glcmds <= 0) || LittleLong(pinmodel->ofs_glcmds) >= end)
Host_Error ("%s is not a valid model", loadmodel->name);
+ loadmodel->aliasnum_meshes = 1;
+ loadmodel->aliasdata_meshes = Mem_Alloc(loadmodel->mempool, sizeof(aliasmesh_t));
+
loadmodel->numskins = LittleLong(pinmodel->num_skins);
numxyz = LittleLong(pinmodel->num_xyz);
numst = LittleLong(pinmodel->num_st);
- numtris = LittleLong(pinmodel->num_tris);
+ loadmodel->aliasdata_meshes->num_triangles = LittleLong(pinmodel->num_tris);
loadmodel->numframes = LittleLong(pinmodel->num_frames);
+ loadmodel->aliasdata_meshes->num_frames = loadmodel->numframes;
+ loadmodel->animscenes = Mem_Alloc(loadmodel->mempool, loadmodel->numframes * sizeof(animscene_t));
loadmodel->flags = 0; // there are no MD2 flags
loadmodel->synctype = ST_RAND;
inskin = (void*)(base + LittleLong(pinmodel->ofs_skins));
if (loadmodel->numskins)
{
- loadmodel->skinscenes = Mem_Alloc(loadmodel->mempool, sizeof(animscene_t) * loadmodel->numskins + sizeof(skinframe_t) * loadmodel->numskins);
- loadmodel->skinframes = (void *)(loadmodel->skinscenes + loadmodel->numskins);
- 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;
- Mod_LoadSkinFrame (loadmodel->skinframes + i, inskin, (r_mipskins.integer ? TEXF_MIPMAP : 0) | TEXF_ALPHA | TEXF_PRECACHE, true, false, true);
- inskin += MD2MAX_SKINNAME;
- }
+ // skins found (most likely not a player model)
+ loadmodel->skinframes = Mem_Alloc(loadmodel->mempool, sizeof(skinframe_t) * loadmodel->numskins);
+ for (i = 0;i < loadmodel->numskins;i++, inskin += MD2_SKINNAME)
+ Mod_LoadSkinFrame(loadmodel->skinframes + i, inskin, (r_mipskins.integer ? TEXF_MIPMAP : 0) | TEXF_ALPHA | TEXF_CLAMP | TEXF_PRECACHE, true, false, true);
}
+ else
+ {
+ // no skins (most likely a player model)
+ loadmodel->numskins = 1;
+ loadmodel->skinframes = Mem_Alloc(loadmodel->mempool, sizeof(skinframe_t) * loadmodel->numskins);
+ }
+ loadmodel->aliasdata_meshes->num_skins = loadmodel->numskins;
+ loadmodel->aliasdata_meshes->data_skins = Mem_Alloc(loadmodel->mempool, loadmodel->aliasdata_meshes->num_skins * sizeof(aliasskin_t));
+
+ loadmodel->skinscenes = Mem_Alloc(loadmodel->mempool, sizeof(animscene_t) * loadmodel->numskins);
+ 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 triangles and stvert data
inst = (void*)(base + LittleLong(pinmodel->ofs_st));
}
md2verthash = Mem_Alloc(tempmempool, 256 * sizeof(hash));
- md2verthashdata = Mem_Alloc(tempmempool, numtris * 3 * sizeof(*hash));
+ md2verthashdata = Mem_Alloc(tempmempool, loadmodel->aliasdata_meshes->num_triangles * 3 * sizeof(*hash));
// swap the triangle list
num = 0;
- elements = Mem_Alloc(loadmodel->mempool, numtris * sizeof(int[3]));
- for (i = 0;i < numtris;i++)
+ loadmodel->aliasdata_meshes->data_element3i = Mem_Alloc(loadmodel->mempool, loadmodel->aliasdata_meshes->num_triangles * sizeof(int[3]));
+ for (i = 0;i < loadmodel->aliasdata_meshes->num_triangles;i++)
{
for (j = 0;j < 3;j++)
{
hash->next = md2verthash[hashindex];
md2verthash[hashindex] = hash;
}
- elements[i*3+j] = (hash - md2verthashdata);
+ loadmodel->aliasdata_meshes->data_element3i[i*3+j] = (hash - md2verthashdata);
}
}
Mem_Free(stverts);
numverts = num;
+ loadmodel->aliasdata_meshes->num_vertices = numverts;
vertremap = Mem_Alloc(loadmodel->mempool, num * sizeof(int));
- texcoords = Mem_Alloc(loadmodel->mempool, num * sizeof(float[4]));
+ loadmodel->aliasdata_meshes->data_texcoord2f = Mem_Alloc(loadmodel->mempool, num * sizeof(float[2]));
for (i = 0;i < num;i++)
{
hash = md2verthashdata + i;
vertremap[i] = hash->xyz;
- texcoords[i*4+0] = hash->st[0];
- texcoords[i*4+1] = hash->st[1];
+ loadmodel->aliasdata_meshes->data_texcoord2f[i*2+0] = hash->st[0];
+ loadmodel->aliasdata_meshes->data_texcoord2f[i*2+1] = hash->st[1];
}
Mem_Free(md2verthash);
// load the frames
datapointer = (base + LittleLong(pinmodel->ofs_frames));
- loadmodel->animscenes = Mem_Alloc(loadmodel->mempool, loadmodel->numframes * sizeof(animscene_t));
- posedata = Mem_Alloc(loadmodel->mempool, numverts * loadmodel->numframes * sizeof(trivertx_t));
-
- vertexbuffer = Mem_Alloc(tempmempool, numverts * sizeof(float[4]) * 4);
- svectorsbuffer = vertexbuffer + numverts * 4;
- tvectorsbuffer = svectorsbuffer + numverts * 4;
- normalsbuffer = tvectorsbuffer + numverts * 4;
- for (i = 0;i < loadmodel->numframes;i++)
+ loadmodel->aliasdata_meshes->data_aliasvertex3f = Mem_Alloc(loadmodel->mempool, numverts * loadmodel->aliasdata_meshes->num_frames * sizeof(float[4][3]));
+ loadmodel->aliasdata_meshes->data_aliassvector3f = loadmodel->aliasdata_meshes->data_aliasvertex3f + numverts * loadmodel->aliasdata_meshes->num_frames * 3 * 1;
+ loadmodel->aliasdata_meshes->data_aliastvector3f = loadmodel->aliasdata_meshes->data_aliasvertex3f + numverts * loadmodel->aliasdata_meshes->num_frames * 3 * 2;
+ loadmodel->aliasdata_meshes->data_aliasnormal3f = loadmodel->aliasdata_meshes->data_aliasvertex3f + numverts * loadmodel->aliasdata_meshes->num_frames * 3 * 3;
+ for (i = 0;i < loadmodel->aliasdata_meshes->num_frames;i++)
{
pinframe = (md2frame_t *)datapointer;
datapointer += sizeof(md2frame_t);
scale[j] = LittleFloat(pinframe->scale[j]);
translate[j] = LittleFloat(pinframe->translate[j]);
}
- Mod_MD2_ConvertVerts(scale, translate, (void *)datapointer, posedata + i * numverts, numverts, vertremap);
- Mod_BuildAliasVertexTextureVectors(numverts, posedata + i * numverts, texcoords, vertexbuffer, svectorsbuffer, tvectorsbuffer, normalsbuffer, numtris, elements);
+ Mod_MD2_ConvertVerts(scale, translate, (void *)datapointer, loadmodel->aliasdata_meshes->data_aliasvertex3f + i * numverts * 3, numverts, vertremap);
+ Mod_BuildTextureVectorsAndNormals(loadmodel->aliasdata_meshes->num_vertices, loadmodel->aliasdata_meshes->num_triangles, loadmodel->aliasdata_meshes->data_aliasvertex3f + i * loadmodel->aliasdata_meshes->num_vertices * 3, loadmodel->aliasdata_meshes->data_texcoord2f, loadmodel->aliasdata_meshes->data_element3i, loadmodel->aliasdata_meshes->data_aliassvector3f + i * loadmodel->aliasdata_meshes->num_vertices * 3, loadmodel->aliasdata_meshes->data_aliastvector3f + i * loadmodel->aliasdata_meshes->num_vertices * 3, loadmodel->aliasdata_meshes->data_aliasnormal3f + i * loadmodel->aliasdata_meshes->num_vertices * 3);
datapointer += numxyz * sizeof(trivertx_t);
strcpy(loadmodel->animscenes[i].name, pinframe->name);
loadmodel->animscenes[i].framerate = 10;
loadmodel->animscenes[i].loop = true;
}
- Mem_Free(vertexbuffer);
Mem_Free(vertremap);
- Mod_BuildMDLMD2MeshInfo(numverts, numtris, elements, texcoords, posedata);
+ loadmodel->aliasdata_meshes->data_neighbor3i = Mem_Alloc(loadmodel->mempool, loadmodel->aliasdata_meshes->num_triangles * sizeof(int[3]));
+ Mod_BuildTriangleNeighbors(loadmodel->aliasdata_meshes->data_neighbor3i, loadmodel->aliasdata_meshes->data_element3i, loadmodel->aliasdata_meshes->num_triangles);
+ for (i = 0;i < loadmodel->aliasdata_meshes->num_skins;i++)
+ Mod_BuildAliasSkinFromSkinFrame(loadmodel->aliasdata_meshes->data_skins + i, loadmodel->skinframes + i);
+ Mod_CalcAliasModelBBoxes();
}
-void Mod_LoadQ3AliasModel(model_t *mod, void *buffer)
+void Mod_IDP3_Load(model_t *mod, void *buffer)
{
int i, j, version;
- float *vertexbuffer, *svectorsbuffer, *tvectorsbuffer, *normalsbuffer;
md3modelheader_t *pinmodel;
md3frameinfo_t *pinframe;
md3mesh_t *pinmesh;
for (i = 0, pinmesh = (md3mesh_t *)((qbyte *)pinmodel + LittleLong(pinmodel->lump_meshes));i < loadmodel->aliasnum_meshes;i++, pinmesh = (md3mesh_t *)((qbyte *)pinmesh + LittleLong(pinmesh->lump_end)))
{
if (memcmp(pinmesh->identifier, "IDP3", 4))
- Host_Error("Mod_LoadQ3AliasModel: invalid mesh identifier (not IDP3)\n");
+ Host_Error("Mod_IDP3_Load: invalid mesh identifier (not IDP3)\n");
mesh = loadmodel->aliasdata_meshes + i;
mesh->num_skins = loadmodel->numskins;
mesh->num_frames = LittleLong(pinmesh->num_frames);
mesh->num_vertices = LittleLong(pinmesh->num_vertices);
mesh->num_triangles = LittleLong(pinmesh->num_triangles);
mesh->data_skins = Mem_Alloc(loadmodel->mempool, mesh->num_skins * sizeof(aliasskin_t));
- mesh->data_elements = Mem_Alloc(loadmodel->mempool, mesh->num_triangles * sizeof(int[3]));
- mesh->data_neighbors = Mem_Alloc(loadmodel->mempool, mesh->num_triangles * sizeof(int[3]));
- mesh->data_texcoords = Mem_Alloc(loadmodel->mempool, mesh->num_vertices * sizeof(float[4]));
- mesh->data_vertices = Mem_Alloc(loadmodel->mempool, mesh->num_vertices * mesh->num_frames * sizeof(aliasvertex_t));
+ mesh->data_element3i = Mem_Alloc(loadmodel->mempool, mesh->num_triangles * sizeof(int[3]));
+ mesh->data_neighbor3i = Mem_Alloc(loadmodel->mempool, mesh->num_triangles * sizeof(int[3]));
+ mesh->data_texcoord2f = Mem_Alloc(loadmodel->mempool, mesh->num_vertices * sizeof(float[2]));
+ mesh->data_aliasvertex3f = Mem_Alloc(loadmodel->mempool, mesh->num_vertices * mesh->num_frames * sizeof(float[4][3]));
+ mesh->data_aliassvector3f = mesh->data_aliasvertex3f + mesh->num_vertices * mesh->num_frames * 3 * 1;
+ mesh->data_aliastvector3f = mesh->data_aliasvertex3f + mesh->num_vertices * mesh->num_frames * 3 * 2;
+ mesh->data_aliasnormal3f = mesh->data_aliasvertex3f + mesh->num_vertices * mesh->num_frames * 3 * 3;
for (j = 0;j < mesh->num_triangles * 3;j++)
- mesh->data_elements[j] = LittleLong(((int *)((qbyte *)pinmesh + pinmesh->lump_elements))[j]);
+ mesh->data_element3i[j] = LittleLong(((int *)((qbyte *)pinmesh + pinmesh->lump_elements))[j]);
for (j = 0;j < mesh->num_vertices;j++)
{
- mesh->data_texcoords[j * 4 + 0] = LittleLong(((float *)((qbyte *)pinmesh + pinmesh->lump_texcoords))[j * 2 + 0]);
- mesh->data_texcoords[j * 4 + 1] = LittleLong(((float *)((qbyte *)pinmesh + pinmesh->lump_texcoords))[j * 2 + 1]);
+ mesh->data_texcoord2f[j * 2 + 0] = LittleLong(((float *)((qbyte *)pinmesh + pinmesh->lump_texcoords))[j * 2 + 0]);
+ mesh->data_texcoord2f[j * 2 + 1] = LittleLong(((float *)((qbyte *)pinmesh + pinmesh->lump_texcoords))[j * 2 + 1]);
}
for (j = 0;j < mesh->num_vertices * mesh->num_frames;j++)
{
- mesh->data_vertices[j].origin[0] = LittleShort(((short *)((qbyte *)pinmesh + pinmesh->lump_framevertices))[j * 4 + 0]) * (1.0f / 64.0f);
- mesh->data_vertices[j].origin[1] = LittleShort(((short *)((qbyte *)pinmesh + pinmesh->lump_framevertices))[j * 4 + 1]) * (1.0f / 64.0f);
- mesh->data_vertices[j].origin[2] = LittleShort(((short *)((qbyte *)pinmesh + pinmesh->lump_framevertices))[j * 4 + 2]) * (1.0f / 64.0f);
+ mesh->data_aliasvertex3f[j * 3 + 0] = LittleShort(((short *)((qbyte *)pinmesh + pinmesh->lump_framevertices))[j * 4 + 0]) * (1.0f / 64.0f);
+ mesh->data_aliasvertex3f[j * 3 + 1] = LittleShort(((short *)((qbyte *)pinmesh + pinmesh->lump_framevertices))[j * 4 + 1]) * (1.0f / 64.0f);
+ mesh->data_aliasvertex3f[j * 3 + 2] = LittleShort(((short *)((qbyte *)pinmesh + pinmesh->lump_framevertices))[j * 4 + 2]) * (1.0f / 64.0f);
}
- vertexbuffer = Mem_Alloc(tempmempool, mesh->num_vertices * sizeof(float[4]) * 4);
- svectorsbuffer = vertexbuffer + mesh->num_vertices * 4;
- tvectorsbuffer = svectorsbuffer + mesh->num_vertices * 4;
- normalsbuffer = tvectorsbuffer + mesh->num_vertices * 4;
for (j = 0;j < mesh->num_frames;j++)
- Mod_BuildAliasVertexTextureVectors(mesh->num_vertices, mesh->data_vertices + j * mesh->num_vertices, mesh->data_texcoords, vertexbuffer, svectorsbuffer, tvectorsbuffer, normalsbuffer, mesh->num_triangles, mesh->data_elements);
- Mem_Free(vertexbuffer);
+ Mod_BuildTextureVectorsAndNormals(mesh->num_vertices, mesh->num_triangles, mesh->data_aliasvertex3f + j * mesh->num_vertices * 3, mesh->data_texcoord2f, mesh->data_element3i, mesh->data_aliassvector3f + j * mesh->num_vertices * 3, mesh->data_aliastvector3f + j * mesh->num_vertices * 3, mesh->data_aliasnormal3f + j * mesh->num_vertices * 3);
memset(&tempskinframe, 0, sizeof(tempskinframe));
if (LittleLong(pinmesh->num_shaders) >= 1 && ((md3shader_t *)((qbyte *) pinmesh + pinmesh->lump_shaders))->name[0])
- Mod_LoadSkinFrame (&tempskinframe, ((md3shader_t *)((qbyte *) pinmesh + pinmesh->lump_shaders))->name, (r_mipskins.integer ? TEXF_MIPMAP : 0) | TEXF_ALPHA | TEXF_PRECACHE, true, false, true);
- Mod_ValidateElements(mesh->data_elements, mesh->num_triangles, mesh->num_vertices, __FILE__, __LINE__);
- Mod_BuildTriangleNeighbors(mesh->data_neighbors, mesh->data_elements, mesh->num_triangles);
+ Mod_LoadSkinFrame(&tempskinframe, ((md3shader_t *)((qbyte *) pinmesh + pinmesh->lump_shaders))->name, (r_mipskins.integer ? TEXF_MIPMAP : 0) | TEXF_ALPHA | TEXF_CLAMP | TEXF_PRECACHE, true, false, true);
+ Mod_ValidateElements(mesh->data_element3i, mesh->num_triangles, mesh->num_vertices, __FILE__, __LINE__);
+ Mod_BuildTriangleNeighbors(mesh->data_neighbor3i, mesh->data_element3i, mesh->num_triangles);
Mod_BuildAliasSkinFromSkinFrame(mesh->data_skins, &tempskinframe);
}
Mod_CalcAliasModelBBoxes();
extern void R_Model_Zymotic_DrawFakeShadow(entity_render_t *ent);
extern void R_Model_Zymotic_DrawShadowVolume(entity_render_t *ent, vec3_t relativelightorigin, float lightradius);
extern void R_Model_Zymotic_DrawLight(entity_render_t *ent, vec3_t relativelightorigin, vec3_t relativeeyeorigin, float lightradius, float *lightcolor, const matrix4x4_t *matrix_modeltofilter, const matrix4x4_t *matrix_modeltoattenuationxyz, const matrix4x4_t *matrix_modeltoattenuationz);
-void Mod_LoadZymoticModel(model_t *mod, void *buffer)
+void Mod_ZYMOTICMODEL_Load(model_t *mod, void *buffer)
{
zymtype1header_t *pinmodel, *pheader;
qbyte *pbase;
pinmodel = (void *)buffer;
pbase = buffer;
if (memcmp(pinmodel->id, "ZYMOTICMODEL", 12))
- Host_Error ("Mod_LoadZymoticModel: %s is not a zymotic model\n");
+ Host_Error ("Mod_ZYMOTICMODEL_Load: %s is not a zymotic model\n");
if (BigLong(pinmodel->type) != 1)
- Host_Error ("Mod_LoadZymoticModel: only type 1 (skeletal pose) models are currently supported (name = %s)\n", loadmodel->name);
+ Host_Error ("Mod_ZYMOTICMODEL_Load: only type 1 (skeletal pose) models are currently supported (name = %s)\n", loadmodel->name);
loadmodel->type = mod_alias;
loadmodel->aliastype = ALIASTYPE_ZYM;
loadmodel->animscenes[i].framerate = BigFloat(scene->framerate);
loadmodel->animscenes[i].loop = (BigLong(scene->flags) & ZYMSCENEFLAG_NOLOOP) == 0;
if ((unsigned int) loadmodel->animscenes[i].firstframe >= (unsigned int) numposes)
- Host_Error("Mod_LoadZymoticModel: scene firstframe (%i) >= numposes (%i)\n", loadmodel->animscenes[i].firstframe, numposes);
+ Host_Error("Mod_ZYMOTICMODEL_Load: scene firstframe (%i) >= numposes (%i)\n", loadmodel->animscenes[i].firstframe, numposes);
if ((unsigned int) loadmodel->animscenes[i].firstframe + (unsigned int) loadmodel->animscenes[i].framecount > (unsigned int) numposes)
- Host_Error("Mod_LoadZymoticModel: scene firstframe (%i) + framecount (%i) >= numposes (%i)\n", loadmodel->animscenes[i].firstframe, loadmodel->animscenes[i].framecount, numposes);
+ Host_Error("Mod_ZYMOTICMODEL_Load: scene firstframe (%i) + framecount (%i) >= numposes (%i)\n", loadmodel->animscenes[i].firstframe, loadmodel->animscenes[i].framecount, numposes);
if (loadmodel->animscenes[i].framerate < 0)
- Host_Error("Mod_LoadZymoticModel: scene framerate (%f) < 0\n", loadmodel->animscenes[i].framerate);
+ Host_Error("Mod_ZYMOTICMODEL_Load: scene framerate (%f) < 0\n", loadmodel->animscenes[i].framerate);
scene++;
}
}
loadmodel->zymdata_bones[i].flags = BigLong(bone[i].flags);
loadmodel->zymdata_bones[i].parent = BigLong(bone[i].parent);
if (loadmodel->zymdata_bones[i].parent >= i)
- Host_Error("Mod_LoadZymoticModel: bone[%i].parent >= %i in %s\n", i, i, loadmodel->name);
+ Host_Error("Mod_ZYMOTICMODEL_Load: bone[%i].parent >= %i in %s\n", i, i, loadmodel->name);
}
}
{
loadmodel->zymdata_vertbonecounts[i] = BigLong(bonecount[i]);
if (loadmodel->zymdata_vertbonecounts[i] < 1)
- Host_Error("Mod_LoadZymoticModel: bone vertex count < 1 in %s\n", loadmodel->name);
+ Host_Error("Mod_ZYMOTICMODEL_Load: bone vertex count < 1 in %s\n", loadmodel->name);
}
}
{
int i;
- float *intexcoord, *outtexcoord;
+ float *intexcoord2f, *outtexcoord2f;
// zymlump_t lump_texcoords; // float texcoords[numvertices][2];
- loadmodel->zymdata_texcoords = outtexcoord = Mem_Alloc(loadmodel->mempool, pheader->numverts * sizeof(float[4]));
- intexcoord = (void *) (pheader->lump_texcoords.start + pbase);
+ loadmodel->zymdata_texcoords = outtexcoord2f = Mem_Alloc(loadmodel->mempool, pheader->numverts * sizeof(float[2]));
+ intexcoord2f = (void *) (pheader->lump_texcoords.start + pbase);
for (i = 0;i < pheader->numverts;i++)
{
- outtexcoord[i*4+0] = BigFloat(intexcoord[i*2+0]);
+ outtexcoord2f[i*2+0] = BigFloat(intexcoord2f[i*2+0]);
// flip T coordinate for OpenGL
- outtexcoord[i*4+1] = 1 - BigFloat(intexcoord[i*2+1]);
+ outtexcoord2f[i*2+1] = 1 - BigFloat(intexcoord2f[i*2+1]);
}
}
// byteswap, validate, and swap winding order of tris
count = pheader->numshaders * sizeof(int) + pheader->numtris * sizeof(int[3]);
if (pheader->lump_render.length != count)
- Host_Error("Mod_LoadZymoticModel: renderlist is wrong size in %s (is %i bytes, should be %i bytes)\n", loadmodel->name, pheader->lump_render.length, count);
+ Host_Error("Mod_ZYMOTICMODEL_Load: renderlist is wrong size in %s (is %i bytes, should be %i bytes)\n", loadmodel->name, pheader->lump_render.length, count);
outrenderlist = loadmodel->zymdata_renderlist = Mem_Alloc(loadmodel->mempool, count);
renderlist = (void *) (pheader->lump_render.start + pbase);
renderlistend = (void *) ((qbyte *) renderlist + pheader->lump_render.length);
for (i = 0;i < pheader->numshaders;i++)
{
if (renderlist >= renderlistend)
- Host_Error("Mod_LoadZymoticModel: corrupt renderlist in %s (wrong size)\n", loadmodel->name);
+ Host_Error("Mod_ZYMOTICMODEL_Load: corrupt renderlist in %s (wrong size)\n", loadmodel->name);
count = BigLong(*renderlist);renderlist++;
if (renderlist + count * 3 > renderlistend)
- Host_Error("Mod_LoadZymoticModel: corrupt renderlist in %s (wrong size)\n", loadmodel->name);
+ Host_Error("Mod_ZYMOTICMODEL_Load: corrupt renderlist in %s (wrong size)\n", loadmodel->name);
*outrenderlist++ = count;
while (count--)
{
if ((unsigned int)outrenderlist[0] >= (unsigned int)pheader->numverts
|| (unsigned int)outrenderlist[1] >= (unsigned int)pheader->numverts
|| (unsigned int)outrenderlist[2] >= (unsigned int)pheader->numverts)
- Host_Error("Mod_LoadZymoticModel: corrupt renderlist in %s (out of bounds index)\n", loadmodel->name);
+ Host_Error("Mod_ZYMOTICMODEL_Load: corrupt renderlist in %s (out of bounds index)\n", loadmodel->name);
renderlist += 3;
outrenderlist += 3;
}
projects / xonotic / darkplaces.git / blobdiff