+ int i;
+ Cvar_RegisterVariable(&r_skeletal_debugbone);
+ Cvar_RegisterVariable(&r_skeletal_debugbonecomponent);
+ Cvar_RegisterVariable(&r_skeletal_debugbonevalue);
+ Cvar_RegisterVariable(&r_skeletal_debugtranslatex);
+ Cvar_RegisterVariable(&r_skeletal_debugtranslatey);
+ Cvar_RegisterVariable(&r_skeletal_debugtranslatez);
+ Cvar_RegisterVariable(&mod_alias_supporttagscale);
+ for (i = 0;i < 320;i++)
+ mod_md3_sin[i] = sin(i * M_PI * 2.0f / 256.0);
+}
+
+int Mod_Skeletal_AddBlend(dp_model_t *model, const int *newindex, const float *newinfluence)
+{
+ int i, total;
+ float scale;
+ blendweights_t *weights;
+ blendweights_t newweights;
+ if(!newinfluence[1])
+ return newindex[0];
+ scale = 0;
+ for (i = 0;i < 4;i++)
+ scale += newinfluence[i];
+ scale = 255.0f / scale;
+ total = 0;
+ for (i = 0;i < 4;i++)
+ {
+ newweights.index[i] = newindex[i];
+ newweights.influence[i] = (unsigned char)(newinfluence[i] * scale);
+ total += newweights.influence[i];
+ }
+ while (total > 255)
+ {
+ for (i = 0;i < 4;i++)
+ {
+ if(newweights.influence[i] > 0 && total > 255)
+ {
+ newweights.influence[i]--;
+ total--;
+ }
+ }
+ }
+ while (total < 255)
+ {
+ for (i = 0; i < 4;i++)
+ {
+ if(newweights.influence[i] < 255 && total < 255)
+ {
+ newweights.influence[i]++;
+ total++;
+ }
+ }
+ }
+ weights = model->surfmesh.data_blendweights;
+ for (i = 0;i < model->surfmesh.num_blends;i++, weights++)
+ {
+ if (!memcmp(weights, &newweights, sizeof(blendweights_t)))
+ return model->num_bones + i;
+ }
+ model->surfmesh.num_blends++;
+ memcpy(weights, &newweights, sizeof(blendweights_t));
+ return model->num_bones + i;
+}
+
+static int maxbonepose = 0;
+static float (*bonepose)[12] = NULL;
+
+void Mod_Skeletal_FreeBuffers(void)
+{
+ if(bonepose)
+ Mem_Free(bonepose);
+ maxbonepose = 0;
+ bonepose = NULL;
+}
+
+#if defined(__GNUC__) || (defined(_MSC_VER) && _MSC_VER >= 1400)
+#define RESTRICT __restrict
+#else
+#define RESTRICT
+#endif
+
+void Mod_Skeletal_AnimateVertices(const dp_model_t * RESTRICT model, const frameblend_t * RESTRICT frameblend, const skeleton_t *skeleton, float * RESTRICT vertex3f, float * RESTRICT normal3f, float * RESTRICT svector3f, float * RESTRICT tvector3f)
+{
+ // vertex weighted skeletal
+ int i, k;
+ int blends;
+ float m[12];
+ float (*boneposerelative)[12];
+ const blendweights_t * RESTRICT weights;
+
+ if (maxbonepose < model->num_bones*2 + model->surfmesh.num_blends)
+ {
+ if (bonepose)
+ Mem_Free(bonepose);
+ maxbonepose = model->num_bones*2 + model->surfmesh.num_blends;
+ bonepose = (float (*)[12])Mem_Alloc(r_main_mempool, maxbonepose * sizeof(float[12]));
+ }
+
+ boneposerelative = bonepose + model->num_bones;
+
+ if (skeleton && !skeleton->relativetransforms)
+ skeleton = NULL;
+
+ // interpolate matrices
+ if (skeleton)
+ {
+ for (i = 0;i < model->num_bones;i++)
+ {
+ Matrix4x4_ToArray12FloatD3D(&skeleton->relativetransforms[i], m);
+ if (model->data_bones[i].parent >= 0)
+ R_ConcatTransforms(bonepose[model->data_bones[i].parent], m, bonepose[i]);
+ else
+ memcpy(bonepose[i], m, sizeof(m));
+
+ // create a relative deformation matrix to describe displacement
+ // from the base mesh, which is used by the actual weighting
+ R_ConcatTransforms(bonepose[i], model->data_baseboneposeinverse + i * 12, boneposerelative[i]);
+ }
+ }
+ else
+ {
+ float originscale = model->num_posescale;
+ float x,y,z,w,lerp;
+ const short * RESTRICT pose6s;
+ for (i = 0;i < model->num_bones;i++)
+ {
+ memset(m, 0, sizeof(m));
+ for (blends = 0;blends < MAX_FRAMEBLENDS && frameblend[blends].lerp > 0;blends++)
+ {
+ pose6s = model->data_poses6s + 6 * (frameblend[blends].subframe * model->num_bones + i);
+ lerp = frameblend[blends].lerp;
+ x = pose6s[3] * (1.0f / 32767.0f);
+ y = pose6s[4] * (1.0f / 32767.0f);
+ z = pose6s[5] * (1.0f / 32767.0f);
+ w = 1.0f - (x*x+y*y+z*z);
+ w = w > 0.0f ? -sqrt(w) : 0.0f;
+ m[ 0] += (1-2*(y*y+z*z)) * lerp;
+ m[ 1] += ( 2*(x*y-z*w)) * lerp;
+ m[ 2] += ( 2*(x*z+y*w)) * lerp;
+ m[ 3] += (pose6s[0] * originscale) * lerp;
+ m[ 4] += ( 2*(x*y+z*w)) * lerp;
+ m[ 5] += (1-2*(x*x+z*z)) * lerp;
+ m[ 6] += ( 2*(y*z-x*w)) * lerp;
+ m[ 7] += (pose6s[1] * originscale) * lerp;
+ m[ 8] += ( 2*(x*z-y*w)) * lerp;
+ m[ 9] += ( 2*(y*z+x*w)) * lerp;
+ m[10] += (1-2*(x*x+y*y)) * lerp;
+ m[11] += (pose6s[2] * originscale) * lerp;
+ }
+ VectorNormalize(m );
+ VectorNormalize(m + 4);
+ VectorNormalize(m + 8);
+ if (i == r_skeletal_debugbone.integer)
+ m[r_skeletal_debugbonecomponent.integer % 12] += r_skeletal_debugbonevalue.value;
+ m[3] *= r_skeletal_debugtranslatex.value;
+ m[7] *= r_skeletal_debugtranslatey.value;
+ m[11] *= r_skeletal_debugtranslatez.value;
+ if (model->data_bones[i].parent >= 0)
+ R_ConcatTransforms(bonepose[model->data_bones[i].parent], m, bonepose[i]);
+ else
+ memcpy(bonepose[i], m, sizeof(m));
+ // create a relative deformation matrix to describe displacement
+ // from the base mesh, which is used by the actual weighting
+ R_ConcatTransforms(bonepose[i], model->data_baseboneposeinverse + i * 12, boneposerelative[i]);
+ }
+ }
+
+ // generate matrices for all blend combinations
+ weights = model->surfmesh.data_blendweights;
+ for (i = 0;i < model->surfmesh.num_blends;i++, weights++)
+ {
+ float * RESTRICT b = boneposerelative[model->num_bones + i];
+ const float * RESTRICT m = boneposerelative[weights->index[0]];
+ float f = weights->influence[0] * (1.0f / 255.0f);
+ b[ 0] = f*m[ 0]; b[ 1] = f*m[ 1]; b[ 2] = f*m[ 2]; b[ 3] = f*m[ 3];
+ b[ 4] = f*m[ 4]; b[ 5] = f*m[ 5]; b[ 6] = f*m[ 6]; b[ 7] = f*m[ 7];
+ b[ 8] = f*m[ 8]; b[ 9] = f*m[ 9]; b[10] = f*m[10]; b[11] = f*m[11];
+ for (k = 1;k < 4 && weights->influence[k];k++)
+ {
+ m = boneposerelative[weights->index[k]];
+ f = weights->influence[k] * (1.0f / 255.0f);
+ b[ 0] += f*m[ 0]; b[ 1] += f*m[ 1]; b[ 2] += f*m[ 2]; b[ 3] += f*m[ 3];
+ b[ 4] += f*m[ 4]; b[ 5] += f*m[ 5]; b[ 6] += f*m[ 6]; b[ 7] += f*m[ 7];
+ b[ 8] += f*m[ 8]; b[ 9] += f*m[ 9]; b[10] += f*m[10]; b[11] += f*m[11];
+ }
+ }
+
+ // transform vertex attributes by blended matrices
+ if (vertex3f)
+ {
+ const float * RESTRICT v = model->surfmesh.data_vertex3f;
+ const unsigned short * RESTRICT b = model->surfmesh.blends;
+ // special case common combinations of attributes to avoid repeated loading of matrices
+ if (normal3f)
+ {
+ const float * RESTRICT n = model->surfmesh.data_normal3f;
+ if (svector3f && tvector3f)
+ {
+ const float * RESTRICT sv = model->surfmesh.data_svector3f;
+ const float * RESTRICT tv = model->surfmesh.data_tvector3f;
+ for (i = 0;i < model->surfmesh.num_vertices;i++, v += 3, n += 3, sv += 3, tv += 3, b++, vertex3f += 3, normal3f += 3, svector3f += 3, tvector3f += 3)
+ {
+ const float * RESTRICT m = boneposerelative[*b];
+ vertex3f[0] = (v[0] * m[0] + v[1] * m[1] + v[2] * m[ 2] + m[ 3]);
+ vertex3f[1] = (v[0] * m[4] + v[1] * m[5] + v[2] * m[ 6] + m[ 7]);
+ vertex3f[2] = (v[0] * m[8] + v[1] * m[9] + v[2] * m[10] + m[11]);
+ normal3f[0] = (n[0] * m[0] + n[1] * m[1] + n[2] * m[ 2]);
+ normal3f[1] = (n[0] * m[4] + n[1] * m[5] + n[2] * m[ 6]);
+ normal3f[2] = (n[0] * m[8] + n[1] * m[9] + n[2] * m[10]);
+ svector3f[0] = (sv[0] * m[0] + sv[1] * m[1] + sv[2] * m[ 2]);
+ svector3f[1] = (sv[0] * m[4] + sv[1] * m[5] + sv[2] * m[ 6]);
+ svector3f[2] = (sv[0] * m[8] + sv[1] * m[9] + sv[2] * m[10]);
+ tvector3f[0] = (tv[0] * m[0] + tv[1] * m[1] + tv[2] * m[ 2]);
+ tvector3f[1] = (tv[0] * m[4] + tv[1] * m[5] + tv[2] * m[ 6]);
+ tvector3f[2] = (tv[0] * m[8] + tv[1] * m[9] + tv[2] * m[10]);
+ }
+ return;
+ }
+ for (i = 0;i < model->surfmesh.num_vertices;i++, v += 3, n += 3, b++, vertex3f += 3, normal3f += 3)
+ {
+ const float * RESTRICT m = boneposerelative[*b];
+ vertex3f[0] = (v[0] * m[0] + v[1] * m[1] + v[2] * m[ 2] + m[ 3]);
+ vertex3f[1] = (v[0] * m[4] + v[1] * m[5] + v[2] * m[ 6] + m[ 7]);
+ vertex3f[2] = (v[0] * m[8] + v[1] * m[9] + v[2] * m[10] + m[11]);
+ normal3f[0] = (n[0] * m[0] + n[1] * m[1] + n[2] * m[ 2]);
+ normal3f[1] = (n[0] * m[4] + n[1] * m[5] + n[2] * m[ 6]);
+ normal3f[2] = (n[0] * m[8] + n[1] * m[9] + n[2] * m[10]);
+ }
+ }
+ else
+ {
+ for (i = 0;i < model->surfmesh.num_vertices;i++, v += 3, b++, vertex3f += 3)
+ {
+ const float * RESTRICT m = boneposerelative[*b];
+ vertex3f[0] = (v[0] * m[0] + v[1] * m[1] + v[2] * m[ 2] + m[ 3]);
+ vertex3f[1] = (v[0] * m[4] + v[1] * m[5] + v[2] * m[ 6] + m[ 7]);
+ vertex3f[2] = (v[0] * m[8] + v[1] * m[9] + v[2] * m[10] + m[11]);
+ }
+ }
+ }
+ else if (normal3f)
+ {
+ const float * RESTRICT n = model->surfmesh.data_normal3f;
+ const unsigned short * RESTRICT b = model->surfmesh.blends;
+ for (i = 0;i < model->surfmesh.num_vertices;i++, n += 3, b++, normal3f += 3)
+ {
+ const float * RESTRICT m = boneposerelative[*b];
+ normal3f[0] = (n[0] * m[0] + n[1] * m[1] + n[2] * m[ 2]);
+ normal3f[1] = (n[0] * m[4] + n[1] * m[5] + n[2] * m[ 6]);
+ normal3f[2] = (n[0] * m[8] + n[1] * m[9] + n[2] * m[10]);
+ }
+ }
+
+ if (svector3f)
+ {
+ const float * RESTRICT sv = model->surfmesh.data_svector3f;
+ const unsigned short * RESTRICT b = model->surfmesh.blends;
+ for (i = 0;i < model->surfmesh.num_vertices;i++, sv += 3, b++, svector3f += 3)
+ {
+ const float * RESTRICT m = boneposerelative[*b];
+ svector3f[0] = (sv[0] * m[0] + sv[1] * m[1] + sv[2] * m[ 2]);
+ svector3f[1] = (sv[0] * m[4] + sv[1] * m[5] + sv[2] * m[ 6]);
+ svector3f[2] = (sv[0] * m[8] + sv[1] * m[9] + sv[2] * m[10]);
+ }
+ }
+
+ if (tvector3f)
+ {
+ const float * RESTRICT tv = model->surfmesh.data_tvector3f;
+ const unsigned short * RESTRICT b = model->surfmesh.blends;
+ for (i = 0;i < model->surfmesh.num_vertices;i++, tv += 3, b++, tvector3f += 3)
+ {
+ const float * RESTRICT m = boneposerelative[*b];
+ tvector3f[0] = (tv[0] * m[0] + tv[1] * m[1] + tv[2] * m[ 2]);
+ tvector3f[1] = (tv[0] * m[4] + tv[1] * m[5] + tv[2] * m[ 6]);
+ tvector3f[2] = (tv[0] * m[8] + tv[1] * m[9] + tv[2] * m[10]);
+ }
+ }
+}
+
+void Mod_MD3_AnimateVertices(const dp_model_t *model, const frameblend_t *frameblend, const skeleton_t *skeleton, float *vertex3f, float *normal3f, float *svector3f, float *tvector3f)
+{
+ // vertex morph
+ int i, numblends, blendnum;
+ int numverts = model->surfmesh.num_vertices;
+ numblends = 0;
+ for (blendnum = 0;blendnum < MAX_FRAMEBLENDS;blendnum++)
+ {
+ //VectorMA(translate, model->surfmesh.num_morphmdlframetranslate, frameblend[blendnum].lerp, translate);
+ if (frameblend[blendnum].lerp > 0)
+ numblends = blendnum + 1;
+ }
+ // special case for the first blend because it avoids some adds and the need to memset the arrays first
+ for (blendnum = 0;blendnum < numblends;blendnum++)
+ {
+ const md3vertex_t *verts = model->surfmesh.data_morphmd3vertex + numverts * frameblend[blendnum].subframe;
+ if (vertex3f)
+ {
+ float scale = frameblend[blendnum].lerp * (1.0f / 64.0f);
+ if (blendnum == 0)
+ {
+ for (i = 0;i < numverts;i++)
+ {
+ vertex3f[i * 3 + 0] = verts[i].origin[0] * scale;
+ vertex3f[i * 3 + 1] = verts[i].origin[1] * scale;
+ vertex3f[i * 3 + 2] = verts[i].origin[2] * scale;
+ }
+ }
+ else
+ {
+ for (i = 0;i < numverts;i++)
+ {
+ vertex3f[i * 3 + 0] += verts[i].origin[0] * scale;
+ vertex3f[i * 3 + 1] += verts[i].origin[1] * scale;
+ vertex3f[i * 3 + 2] += verts[i].origin[2] * scale;
+ }
+ }
+ }
+ // the yaw and pitch stored in md3 models are 8bit quantized angles
+ // (0-255), and as such a lookup table is very well suited to
+ // decoding them, and since cosine is equivilant to sine with an
+ // extra 45 degree rotation, this uses one lookup table for both
+ // sine and cosine with a +64 bias to get cosine.
+ if (normal3f)
+ {
+ float lerp = frameblend[blendnum].lerp;
+ if (blendnum == 0)
+ {
+ for (i = 0;i < numverts;i++)
+ {
+ normal3f[i * 3 + 0] = mod_md3_sin[verts[i].yaw + 64] * mod_md3_sin[verts[i].pitch ] * lerp;
+ normal3f[i * 3 + 1] = mod_md3_sin[verts[i].yaw ] * mod_md3_sin[verts[i].pitch ] * lerp;
+ normal3f[i * 3 + 2] = mod_md3_sin[verts[i].pitch + 64] * lerp;
+ }
+ }
+ else
+ {
+ for (i = 0;i < numverts;i++)
+ {
+ normal3f[i * 3 + 0] += mod_md3_sin[verts[i].yaw + 64] * mod_md3_sin[verts[i].pitch ] * lerp;
+ normal3f[i * 3 + 1] += mod_md3_sin[verts[i].yaw ] * mod_md3_sin[verts[i].pitch ] * lerp;
+ normal3f[i * 3 + 2] += mod_md3_sin[verts[i].pitch + 64] * lerp;
+ }
+ }
+ }
+ if (svector3f)
+ {
+ const texvecvertex_t *texvecvert = model->surfmesh.data_morphtexvecvertex + numverts * frameblend[blendnum].subframe;
+ float f = frameblend[blendnum].lerp * (1.0f / 127.0f);
+ if (blendnum == 0)
+ {
+ for (i = 0;i < numverts;i++, texvecvert++)
+ {
+ VectorScale(texvecvert->svec, f, svector3f + i*3);
+ VectorScale(texvecvert->tvec, f, tvector3f + i*3);
+ }
+ }
+ else
+ {
+ for (i = 0;i < numverts;i++, texvecvert++)
+ {
+ VectorMA(svector3f + i*3, f, texvecvert->svec, svector3f + i*3);
+ VectorMA(tvector3f + i*3, f, texvecvert->tvec, tvector3f + i*3);
+ }
+ }
+ }
+ }
+}
+
+void Mod_MDL_AnimateVertices(const dp_model_t *model, const frameblend_t *frameblend, const skeleton_t *skeleton, float *vertex3f, float *normal3f, float *svector3f, float *tvector3f)
+{
+ // vertex morph
+ int i, numblends, blendnum;
+ int numverts = model->surfmesh.num_vertices;
+ float translate[3];
+ VectorClear(translate);
+ numblends = 0;
+ // blend the frame translates to avoid redundantly doing so on each vertex
+ // (a bit of a brain twister but it works)
+ for (blendnum = 0;blendnum < MAX_FRAMEBLENDS;blendnum++)
+ {
+ if (model->surfmesh.data_morphmd2framesize6f)
+ VectorMA(translate, frameblend[blendnum].lerp, model->surfmesh.data_morphmd2framesize6f + frameblend[blendnum].subframe * 6 + 3, translate);
+ else
+ VectorMA(translate, frameblend[blendnum].lerp, model->surfmesh.num_morphmdlframetranslate, translate);
+ if (frameblend[blendnum].lerp > 0)
+ numblends = blendnum + 1;
+ }
+ // special case for the first blend because it avoids some adds and the need to memset the arrays first
+ for (blendnum = 0;blendnum < numblends;blendnum++)
+ {
+ const trivertx_t *verts = model->surfmesh.data_morphmdlvertex + numverts * frameblend[blendnum].subframe;
+ if (vertex3f)
+ {
+ float scale[3];
+ if (model->surfmesh.data_morphmd2framesize6f)
+ VectorScale(model->surfmesh.data_morphmd2framesize6f + frameblend[blendnum].subframe * 6, frameblend[blendnum].lerp, scale);
+ else
+ VectorScale(model->surfmesh.num_morphmdlframescale, frameblend[blendnum].lerp, scale);
+ if (blendnum == 0)
+ {
+ for (i = 0;i < numverts;i++)
+ {
+ vertex3f[i * 3 + 0] = translate[0] + verts[i].v[0] * scale[0];
+ vertex3f[i * 3 + 1] = translate[1] + verts[i].v[1] * scale[1];
+ vertex3f[i * 3 + 2] = translate[2] + verts[i].v[2] * scale[2];
+ }
+ }
+ else
+ {
+ for (i = 0;i < numverts;i++)
+ {
+ vertex3f[i * 3 + 0] += verts[i].v[0] * scale[0];
+ vertex3f[i * 3 + 1] += verts[i].v[1] * scale[1];
+ vertex3f[i * 3 + 2] += verts[i].v[2] * scale[2];
+ }
+ }
+ }
+ // the vertex normals in mdl models are an index into a table of
+ // 162 unique values, this very crude quantization reduces the
+ // vertex normal to only one byte, which saves a lot of space but
+ // also makes lighting pretty coarse
+ if (normal3f)
+ {
+ float lerp = frameblend[blendnum].lerp;
+ if (blendnum == 0)
+ {
+ for (i = 0;i < numverts;i++)
+ {
+ const float *vn = m_bytenormals[verts[i].lightnormalindex];
+ VectorScale(vn, lerp, normal3f + i*3);
+ }
+ }
+ else
+ {
+ for (i = 0;i < numverts;i++)
+ {
+ const float *vn = m_bytenormals[verts[i].lightnormalindex];
+ VectorMA(normal3f + i*3, lerp, vn, normal3f + i*3);
+ }
+ }
+ }
+ if (svector3f)
+ {
+ const texvecvertex_t *texvecvert = model->surfmesh.data_morphtexvecvertex + numverts * frameblend[blendnum].subframe;
+ float f = frameblend[blendnum].lerp * (1.0f / 127.0f);
+ if (blendnum == 0)
+ {
+ for (i = 0;i < numverts;i++, texvecvert++)
+ {
+ VectorScale(texvecvert->svec, f, svector3f + i*3);
+ VectorScale(texvecvert->tvec, f, tvector3f + i*3);
+ }
+ }
+ else
+ {
+ for (i = 0;i < numverts;i++, texvecvert++)
+ {
+ VectorMA(svector3f + i*3, f, texvecvert->svec, svector3f + i*3);
+ VectorMA(tvector3f + i*3, f, texvecvert->tvec, tvector3f + i*3);
+ }
+ }
+ }
+ }
+}
+
+int Mod_Alias_GetTagMatrix(const dp_model_t *model, const frameblend_t *frameblend, const skeleton_t *skeleton, int tagindex, matrix4x4_t *outmatrix)
+{
+ matrix4x4_t temp;
+ matrix4x4_t parentbonematrix;
+ matrix4x4_t tempbonematrix;
+ matrix4x4_t bonematrix;
+ matrix4x4_t blendmatrix;
+ int blendindex;
+ int parenttagindex;
+ int k;
+ float lerp;
+ const float *input;
+ float blendtag[12];
+ *outmatrix = identitymatrix;
+ if (skeleton && skeleton->relativetransforms)
+ {
+ if (tagindex < 0 || tagindex >= skeleton->model->num_bones)
+ return 4;
+ *outmatrix = skeleton->relativetransforms[tagindex];
+ while ((tagindex = model->data_bones[tagindex].parent) >= 0)
+ {
+ temp = *outmatrix;
+ Matrix4x4_Concat(outmatrix, &skeleton->relativetransforms[tagindex], &temp);
+ }
+ }
+ else if (model->num_bones)
+ {
+ if (tagindex < 0 || tagindex >= model->num_bones)
+ return 4;
+ Matrix4x4_Clear(&blendmatrix);
+ for (blendindex = 0;blendindex < MAX_FRAMEBLENDS && frameblend[blendindex].lerp > 0;blendindex++)
+ {
+ lerp = frameblend[blendindex].lerp;
+ Matrix4x4_FromBonePose6s(&bonematrix, model->num_posescale, model->data_poses6s + 6 * (frameblend[blendindex].subframe * model->num_bones + tagindex));
+ parenttagindex = tagindex;
+ while ((parenttagindex = model->data_bones[parenttagindex].parent) >= 0)
+ {
+ Matrix4x4_FromBonePose6s(&parentbonematrix, model->num_posescale, model->data_poses6s + 6 * (frameblend[blendindex].subframe * model->num_bones + parenttagindex));
+ tempbonematrix = bonematrix;
+ Matrix4x4_Concat(&bonematrix, &parentbonematrix, &tempbonematrix);
+ }
+ Matrix4x4_Accumulate(&blendmatrix, &bonematrix, lerp);
+ }
+ *outmatrix = blendmatrix;
+ }
+ else if (model->num_tags)
+ {
+ if (tagindex < 0 || tagindex >= model->num_tags)
+ return 4;
+ for (k = 0;k < 12;k++)
+ blendtag[k] = 0;
+ for (blendindex = 0;blendindex < MAX_FRAMEBLENDS && frameblend[blendindex].lerp > 0;blendindex++)
+ {
+ lerp = frameblend[blendindex].lerp;
+ input = model->data_tags[frameblend[blendindex].subframe * model->num_tags + tagindex].matrixgl;
+ for (k = 0;k < 12;k++)
+ blendtag[k] += input[k] * lerp;
+ }
+ Matrix4x4_FromArray12FloatGL(outmatrix, blendtag);
+ }
+
+ if(!mod_alias_supporttagscale.integer)
+ Matrix4x4_Normalize3(outmatrix, outmatrix);
+
+ return 0;
+}
+
+int Mod_Alias_GetExtendedTagInfoForIndex(const dp_model_t *model, unsigned int skin, const frameblend_t *frameblend, const skeleton_t *skeleton, int tagindex, int *parentindex, const char **tagname, matrix4x4_t *tag_localmatrix)
+{
+ int blendindex;
+ int k;
+ float lerp;
+ matrix4x4_t bonematrix;
+ matrix4x4_t blendmatrix;
+ const float *input;
+ float blendtag[12];
+
+ if (skeleton && skeleton->relativetransforms)
+ {
+ if (tagindex < 0 || tagindex >= skeleton->model->num_bones)
+ return 1;
+ *parentindex = skeleton->model->data_bones[tagindex].parent;
+ *tagname = skeleton->model->data_bones[tagindex].name;
+ *tag_localmatrix = skeleton->relativetransforms[tagindex];
+ return 0;
+ }
+ else if (model->num_bones)
+ {
+ if (tagindex < 0 || tagindex >= model->num_bones)
+ return 1;
+ *parentindex = model->data_bones[tagindex].parent;
+ *tagname = model->data_bones[tagindex].name;
+ Matrix4x4_Clear(&blendmatrix);
+ for (blendindex = 0;blendindex < MAX_FRAMEBLENDS && frameblend[blendindex].lerp > 0;blendindex++)
+ {
+ lerp = frameblend[blendindex].lerp;
+ Matrix4x4_FromBonePose6s(&bonematrix, model->num_posescale, model->data_poses6s + 6 * (frameblend[blendindex].subframe * model->num_bones + tagindex));
+ Matrix4x4_Accumulate(&blendmatrix, &bonematrix, lerp);
+ }
+ *tag_localmatrix = blendmatrix;
+ return 0;
+ }
+ else if (model->num_tags)
+ {
+ if (tagindex < 0 || tagindex >= model->num_tags)
+ return 1;
+ *parentindex = -1;
+ *tagname = model->data_tags[tagindex].name;
+ for (k = 0;k < 12;k++)
+ blendtag[k] = 0;
+ for (blendindex = 0;blendindex < MAX_FRAMEBLENDS && frameblend[blendindex].lerp > 0;blendindex++)
+ {
+ lerp = frameblend[blendindex].lerp;
+ input = model->data_tags[frameblend[blendindex].subframe * model->num_tags + tagindex].matrixgl;
+ for (k = 0;k < 12;k++)
+ blendtag[k] += input[k] * lerp;
+ }
+ Matrix4x4_FromArray12FloatGL(tag_localmatrix, blendtag);
+ return 0;
+ }
+
+ return 2;
+}
+
+int Mod_Alias_GetTagIndexForName(const dp_model_t *model, unsigned int skin, const char *tagname)
+{
+ int i;
+ if(skin >= (unsigned int)model->numskins)
+ skin = 0;
+ if (model->num_bones)
+ for (i = 0;i < model->num_bones;i++)
+ if (!strcasecmp(tagname, model->data_bones[i].name))
+ return i + 1;
+ if (model->num_tags)
+ for (i = 0;i < model->num_tags;i++)
+ if (!strcasecmp(tagname, model->data_tags[i].name))
+ return i + 1;
+ return 0;
+}
+
+static void Mod_BuildBaseBonePoses(void)
+{
+ int boneindex;
+ matrix4x4_t *basebonepose;
+ float *outinvmatrix = loadmodel->data_baseboneposeinverse;
+ matrix4x4_t bonematrix;
+ matrix4x4_t tempbonematrix;
+ if (!loadmodel->num_bones)
+ return;
+ basebonepose = (matrix4x4_t *)Mem_Alloc(tempmempool, loadmodel->num_bones * sizeof(matrix4x4_t));
+ for (boneindex = 0;boneindex < loadmodel->num_bones;boneindex++)
+ {
+ Matrix4x4_FromBonePose6s(&bonematrix, loadmodel->num_posescale, loadmodel->data_poses6s + 6 * boneindex);
+ if (loadmodel->data_bones[boneindex].parent >= 0)
+ {
+ tempbonematrix = bonematrix;
+ Matrix4x4_Concat(&bonematrix, basebonepose + loadmodel->data_bones[boneindex].parent, &tempbonematrix);
+ }
+ basebonepose[boneindex] = bonematrix;
+ Matrix4x4_Invert_Simple(&tempbonematrix, basebonepose + boneindex);
+ Matrix4x4_ToArray12FloatD3D(&tempbonematrix, outinvmatrix + 12*boneindex);
+ }
+ Mem_Free(basebonepose);