qboolean R_LoadMD5(model_t *mod, void *buffer, int bufferSize, const char *modName)
{
int i, j, k;
md5Model_t *md5;
md5Bone_t *bone;
md5Surface_t *surf;
srfTriangle_t *tri;
md5Vertex_t *v;
md5Weight_t *weight;
int version;
shader_t *sh;
char *buf_p = ( char * ) buffer;
char *token;
vec3_t boneOrigin;
quat_t boneQuat;
matrix_t boneMat;
int numRemaining;
growList_t sortedTriangles;
growList_t vboTriangles;
growList_t vboSurfaces;
int numBoneReferences;
int boneReferences[MAX_BONES];
// skip MD5Version indent string
COM_ParseExt2(&buf_p, qfalse);
// check version
token = COM_ParseExt2(&buf_p, qfalse);
version = atoi(token);
if (version != MD5_VERSION)
{
Ren_Warning("R_LoadMD5: %s has wrong version (%i should be %i)\n", modName, version, MD5_VERSION);
return qfalse;
}
mod->type = MOD_MD5;
mod->dataSize += sizeof(md5Model_t);
md5 = mod->md5 = ri.Hunk_Alloc(sizeof(md5Model_t), h_low);
// skip commandline <arguments string>
token = COM_ParseExt2(&buf_p, qtrue);
token = COM_ParseExt2(&buf_p, qtrue);
// Ren_Print("%s\n", token);
// parse numJoints <number>
token = COM_ParseExt2(&buf_p, qtrue);
if (Q_stricmp(token, "numJoints"))
{
Ren_Warning("R_LoadMD5: expected 'numJoints' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
token = COM_ParseExt2(&buf_p, qfalse);
md5->numBones = atoi(token);
// parse numMeshes <number>
token = COM_ParseExt2(&buf_p, qtrue);
if (Q_stricmp(token, "numMeshes"))
{
Ren_Warning("R_LoadMD5: expected 'numMeshes' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
token = COM_ParseExt2(&buf_p, qfalse);
md5->numSurfaces = atoi(token);
//Ren_Print("R_LoadMD5: '%s' has %i surfaces\n", modName, md5->numSurfaces);
if (md5->numBones < 1)
{
Ren_Warning("R_LoadMD5: '%s' has no bones\n", modName);
return qfalse;
}
if (md5->numBones > MAX_BONES)
{
Ren_Warning("R_LoadMD5: '%s' has more than %i bones (%i)\n", modName, MAX_BONES, md5->numBones);
return qfalse;
}
//Ren_Print("R_LoadMD5: '%s' has %i bones\n", modName, md5->numBones);
// parse all the bones
md5->bones = ri.Hunk_Alloc(sizeof(*bone) * md5->numBones, h_low);
// parse joints {
token = COM_ParseExt2(&buf_p, qtrue);
if (Q_stricmp(token, "joints"))
{
Ren_Warning("R_LoadMD5: expected 'joints' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
token = COM_ParseExt2(&buf_p, qfalse);
if (Q_stricmp(token, "{"))
{
Ren_Warning("R_LoadMD5: expected '{' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
for (i = 0, bone = md5->bones; i < md5->numBones; i++, bone++)
{
token = COM_ParseExt2(&buf_p, qtrue);
Q_strncpyz(bone->name, token, sizeof(bone->name));
//Ren_Print("R_LoadMD5: '%s' has bone '%s'\n", modName, bone->name);
token = COM_ParseExt2(&buf_p, qfalse);
bone->parentIndex = atoi(token);
//Ren_Print("R_LoadMD5: '%s' has bone '%s' with parent index %i\n", modName, bone->name, bone->parentIndex);
if (bone->parentIndex >= md5->numBones)
{
Ren_Drop("R_LoadMD5: '%s' has bone '%s' with bad parent index %i while numBones is %i", modName,
bone->name, bone->parentIndex, md5->numBones);
}
// skip (
token = COM_ParseExt2(&buf_p, qfalse);
if (Q_stricmp(token, "("))
{
Ren_Warning("R_LoadMD5: expected '(' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
for (j = 0; j < 3; j++)
{
token = COM_ParseExt2(&buf_p, qfalse);
boneOrigin[j] = atof(token);
}
// skip )
token = COM_ParseExt2(&buf_p, qfalse);
if (Q_stricmp(token, ")"))
{
Ren_Warning("R_LoadMD5: expected ')' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
// skip (
token = COM_ParseExt2(&buf_p, qfalse);
if (Q_stricmp(token, "("))
{
Ren_Warning("R_LoadMD5: expected '(' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
for (j = 0; j < 3; j++)
{
token = COM_ParseExt2(&buf_p, qfalse);
boneQuat[j] = atof(token);
}
QuatCalcW(boneQuat);
MatrixFromQuat(boneMat, boneQuat);
VectorCopy(boneOrigin, bone->origin);
QuatCopy(boneQuat, bone->rotation);
MatrixSetupTransformFromQuat(bone->inverseTransform, boneQuat, boneOrigin);
MatrixInverse(bone->inverseTransform);
// skip )
token = COM_ParseExt2(&buf_p, qfalse);
if (Q_stricmp(token, ")"))
{
Ren_Warning("R_LoadMD5: expected '(' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
}
// parse }
token = COM_ParseExt2(&buf_p, qtrue);
if (Q_stricmp(token, "}"))
{
Ren_Warning("R_LoadMD5: expected '}' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
// parse all the surfaces
if (md5->numSurfaces < 1)
{
Ren_Warning("R_LoadMD5: '%s' has no surfaces\n", modName);
return qfalse;
}
//Ren_Print("R_LoadMD5: '%s' has %i surfaces\n", modName, md5->numSurfaces);
md5->surfaces = ri.Hunk_Alloc(sizeof(*surf) * md5->numSurfaces, h_low);
for (i = 0, surf = md5->surfaces; i < md5->numSurfaces; i++, surf++)
{
// parse mesh {
token = COM_ParseExt2(&buf_p, qtrue);
if (Q_stricmp(token, "mesh"))
{
Ren_Warning("R_LoadMD5: expected 'mesh' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
token = COM_ParseExt2(&buf_p, qfalse);
if (Q_stricmp(token, "{"))
{
Ren_Warning("R_LoadMD5: expected '{' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
// change to surface identifier
surf->surfaceType = SF_MD5;
// give pointer to model for Tess_SurfaceMD5
surf->model = md5;
// parse shader <name>
token = COM_ParseExt2(&buf_p, qtrue);
if (Q_stricmp(token, "shader"))
{
Ren_Warning("R_LoadMD5: expected 'shader' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
token = COM_ParseExt2(&buf_p, qfalse);
Q_strncpyz(surf->shader, token, sizeof(surf->shader));
//Ren_Print("R_LoadMD5: '%s' uses shader '%s'\n", modName, surf->shader);
// FIXME .md5mesh meshes don't have surface names
// lowercase the surface name so skin compares are faster
//Q_strlwr(surf->name);
//Ren_Print("R_LoadMD5: '%s' has surface '%s'\n", modName, surf->name);
// register the shaders
sh = R_FindShader(surf->shader, SHADER_3D_DYNAMIC, qtrue);
if (sh->defaultShader)
{
surf->shaderIndex = 0;
}
else
{
surf->shaderIndex = sh->index;
}
// parse numVerts <number>
token = COM_ParseExt2(&buf_p, qtrue);
if (Q_stricmp(token, "numVerts"))
{
Ren_Warning("R_LoadMD5: expected 'numVerts' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
token = COM_ParseExt2(&buf_p, qfalse);
surf->numVerts = atoi(token);
if (surf->numVerts > SHADER_MAX_VERTEXES)
{
Ren_Drop("R_LoadMD5: '%s' has more than %i verts on a surface (%i)",
modName, SHADER_MAX_VERTEXES, surf->numVerts);
}
surf->verts = ri.Hunk_Alloc(sizeof(*v) * surf->numVerts, h_low);
for (j = 0, v = surf->verts; j < surf->numVerts; j++, v++)
{
// skip vert <number>
token = COM_ParseExt2(&buf_p, qtrue);
if (Q_stricmp(token, "vert"))
{
Ren_Warning("R_LoadMD5: expected 'vert' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
COM_ParseExt2(&buf_p, qfalse);
// skip (
token = COM_ParseExt2(&buf_p, qfalse);
if (Q_stricmp(token, "("))
{
Ren_Warning("R_LoadMD5: expected '(' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
for (k = 0; k < 2; k++)
{
token = COM_ParseExt2(&buf_p, qfalse);
v->texCoords[k] = atof(token);
}
// skip )
token = COM_ParseExt2(&buf_p, qfalse);
if (Q_stricmp(token, ")"))
{
Ren_Warning("R_LoadMD5: expected ')' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
token = COM_ParseExt2(&buf_p, qfalse);
v->firstWeight = atoi(token);
token = COM_ParseExt2(&buf_p, qfalse);
v->numWeights = atoi(token);
if (v->numWeights > MAX_WEIGHTS)
{
Ren_Drop("R_LoadMD5: vertex %i requires more than %i weights on surface (%i) in model '%s'",
j, MAX_WEIGHTS, i, modName);
}
}
// parse numTris <number>
token = COM_ParseExt2(&buf_p, qtrue);
if (Q_stricmp(token, "numTris"))
{
Ren_Warning("R_LoadMD5: expected 'numTris' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
token = COM_ParseExt2(&buf_p, qfalse);
surf->numTriangles = atoi(token);
if (surf->numTriangles > SHADER_MAX_TRIANGLES)
{
Ren_Drop("R_LoadMD5: '%s' has more than %i triangles on a surface (%i)",
modName, SHADER_MAX_TRIANGLES, surf->numTriangles);
}
surf->triangles = ri.Hunk_Alloc(sizeof(*tri) * surf->numTriangles, h_low);
for (j = 0, tri = surf->triangles; j < surf->numTriangles; j++, tri++)
{
// skip tri <number>
token = COM_ParseExt2(&buf_p, qtrue);
if (Q_stricmp(token, "tri"))
{
Ren_Warning("R_LoadMD5: expected 'tri' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
COM_ParseExt2(&buf_p, qfalse);
for (k = 0; k < 3; k++)
{
token = COM_ParseExt2(&buf_p, qfalse);
tri->indexes[k] = atoi(token);
}
}
// parse numWeights <number>
token = COM_ParseExt2(&buf_p, qtrue);
if (Q_stricmp(token, "numWeights"))
{
Ren_Warning("R_LoadMD5: expected 'numWeights' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
token = COM_ParseExt2(&buf_p, qfalse);
surf->numWeights = atoi(token);
surf->weights = ri.Hunk_Alloc(sizeof(*weight) * surf->numWeights, h_low);
for (j = 0, weight = surf->weights; j < surf->numWeights; j++, weight++)
{
// skip weight <number>
token = COM_ParseExt2(&buf_p, qtrue);
if (Q_stricmp(token, "weight"))
{
Ren_Warning("R_LoadMD5: expected 'weight' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
COM_ParseExt2(&buf_p, qfalse);
token = COM_ParseExt2(&buf_p, qfalse);
weight->boneIndex = atoi(token);
token = COM_ParseExt2(&buf_p, qfalse);
weight->boneWeight = atof(token);
// skip (
token = COM_ParseExt2(&buf_p, qfalse);
if (Q_stricmp(token, "("))
{
Ren_Warning("R_LoadMD5: expected '(' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
for (k = 0; k < 3; k++)
{
token = COM_ParseExt2(&buf_p, qfalse);
weight->offset[k] = atof(token);
}
// skip )
token = COM_ParseExt2(&buf_p, qfalse);
if (Q_stricmp(token, ")"))
{
Ren_Warning("R_LoadMD5: expected ')' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
}
// parse }
token = COM_ParseExt2(&buf_p, qtrue);
if (Q_stricmp(token, "}"))
{
Ren_Warning("R_LoadMD5: expected '}' found '%s' in model '%s'\n", token, modName);
return qfalse;
}
// loop trough all vertices and set up the vertex weights
for (j = 0, v = surf->verts; j < surf->numVerts; j++, v++)
{
v->weights = ri.Hunk_Alloc(sizeof(*v->weights) * v->numWeights, h_low);
for (k = 0; k < v->numWeights; k++)
{
v->weights[k] = surf->weights + (v->firstWeight + k);
}
}
}
// loading is done now calculate the bounding box and tangent spaces
ClearBounds(md5->bounds[0], md5->bounds[1]);
for (i = 0, surf = md5->surfaces; i < md5->numSurfaces; i++, surf++)
{
for (j = 0, v = surf->verts; j < surf->numVerts; j++, v++)
{
vec3_t tmpVert;
md5Weight_t *w;
VectorClear(tmpVert);
for (k = 0, w = v->weights[0]; k < v->numWeights; k++, w++)
{
vec3_t offsetVec;
bone = &md5->bones[w->boneIndex];
QuatTransformVector(bone->rotation, w->offset, offsetVec);
VectorAdd(bone->origin, offsetVec, offsetVec);
VectorMA(tmpVert, w->boneWeight, offsetVec, tmpVert);
}
VectorCopy(tmpVert, v->position);
AddPointToBounds(tmpVert, md5->bounds[0], md5->bounds[1]);
}
// calc tangent spaces
#if 1
{
const float *v0, *v1, *v2;
const float *t0, *t1, *t2;
vec3_t tangent;
vec3_t binormal;
vec3_t normal;
for (j = 0, v = surf->verts; j < surf->numVerts; j++, v++)
{
VectorClear(v->tangent);
VectorClear(v->binormal);
VectorClear(v->normal);
}
for (j = 0, tri = surf->triangles; j < surf->numTriangles; j++, tri++)
{
v0 = surf->verts[tri->indexes[0]].position;
v1 = surf->verts[tri->indexes[1]].position;
v2 = surf->verts[tri->indexes[2]].position;
t0 = surf->verts[tri->indexes[0]].texCoords;
t1 = surf->verts[tri->indexes[1]].texCoords;
t2 = surf->verts[tri->indexes[2]].texCoords;
#if 1
R_CalcTangentSpace(tangent, binormal, normal, v0, v1, v2, t0, t1, t2);
#else
R_CalcNormalForTriangle(normal, v0, v1, v2);
R_CalcTangentsForTriangle(tangent, binormal, v0, v1, v2, t0, t1, t2);
#endif
for (k = 0; k < 3; k++)
{
float *v;
v = surf->verts[tri->indexes[k]].tangent;
VectorAdd(v, tangent, v);
v = surf->verts[tri->indexes[k]].binormal;
VectorAdd(v, binormal, v);
v = surf->verts[tri->indexes[k]].normal;
VectorAdd(v, normal, v);
}
}
for (j = 0, v = surf->verts; j < surf->numVerts; j++, v++)
{
VectorNormalize(v->tangent);
VectorNormalize(v->binormal);
VectorNormalize(v->normal);
}
}
#else
{
int k;
float bb, s, t;
vec3_t bary;
vec3_t faceNormal;
md5Vertex_t *dv[3];
for (j = 0, tri = surf->triangles; j < surf->numTriangles; j++, tri++)
{
dv[0] = &surf->verts[tri->indexes[0]];
dv[1] = &surf->verts[tri->indexes[1]];
dv[2] = &surf->verts[tri->indexes[2]];
R_CalcNormalForTriangle(faceNormal, dv[0]->position, dv[1]->position, dv[2]->position);
// calculate barycentric basis for the triangle
bb = (dv[1]->texCoords[0] - dv[0]->texCoords[0]) * (dv[2]->texCoords[1] - dv[0]->texCoords[1]) - (dv[2]->texCoords[0] - dv[0]->texCoords[0]) * (dv[1]->texCoords[1] -
dv[0]->texCoords[1]);
if (fabs(bb) < 0.00000001f)
{
continue;
}
// do each vertex
for (k = 0; k < 3; k++)
{
// calculate s tangent vector
s = dv[k]->texCoords[0] + 10.0f;
t = dv[k]->texCoords[1];
bary[0] = ((dv[1]->texCoords[0] - s) * (dv[2]->texCoords[1] - t) - (dv[2]->texCoords[0] - s) * (dv[1]->texCoords[1] - t)) / bb;
bary[1] = ((dv[2]->texCoords[0] - s) * (dv[0]->texCoords[1] - t) - (dv[0]->texCoords[0] - s) * (dv[2]->texCoords[1] - t)) / bb;
bary[2] = ((dv[0]->texCoords[0] - s) * (dv[1]->texCoords[1] - t) - (dv[1]->texCoords[0] - s) * (dv[0]->texCoords[1] - t)) / bb;
dv[k]->tangent[0] = bary[0] * dv[0]->position[0] + bary[1] * dv[1]->position[0] + bary[2] * dv[2]->position[0];
dv[k]->tangent[1] = bary[0] * dv[0]->position[1] + bary[1] * dv[1]->position[1] + bary[2] * dv[2]->position[1];
dv[k]->tangent[2] = bary[0] * dv[0]->position[2] + bary[1] * dv[1]->position[2] + bary[2] * dv[2]->position[2];
VectorSubtract(dv[k]->tangent, dv[k]->position, dv[k]->tangent);
VectorNormalize(dv[k]->tangent);
// calculate t tangent vector (binormal)
s = dv[k]->texCoords[0];
t = dv[k]->texCoords[1] + 10.0f;
bary[0] = ((dv[1]->texCoords[0] - s) * (dv[2]->texCoords[1] - t) - (dv[2]->texCoords[0] - s) * (dv[1]->texCoords[1] - t)) / bb;
bary[1] = ((dv[2]->texCoords[0] - s) * (dv[0]->texCoords[1] - t) - (dv[0]->texCoords[0] - s) * (dv[2]->texCoords[1] - t)) / bb;
bary[2] = ((dv[0]->texCoords[0] - s) * (dv[1]->texCoords[1] - t) - (dv[1]->texCoords[0] - s) * (dv[0]->texCoords[1] - t)) / bb;
dv[k]->binormal[0] = bary[0] * dv[0]->position[0] + bary[1] * dv[1]->position[0] + bary[2] * dv[2]->position[0];
dv[k]->binormal[1] = bary[0] * dv[0]->position[1] + bary[1] * dv[1]->position[1] + bary[2] * dv[2]->position[1];
dv[k]->binormal[2] = bary[0] * dv[0]->position[2] + bary[1] * dv[1]->position[2] + bary[2] * dv[2]->position[2];
VectorSubtract(dv[k]->binormal, dv[k]->position, dv[k]->binormal);
VectorNormalize(dv[k]->binormal);
// calculate the normal as cross product N=TxB
#if 0
CrossProduct(dv[k]->tangent, dv[k]->binormal, dv[k]->normal);
VectorNormalize(dv[k]->normal);
// Gram-Schmidt orthogonalization process for B
// compute the cross product B=NxT to obtain
// an orthogonal basis
CrossProduct(dv[k]->normal, dv[k]->tangent, dv[k]->binormal);
if (DotProduct(dv[k]->normal, faceNormal) < 0)
{
VectorInverse(dv[k]->normal);
//VectorInverse(dv[k]->tangent);
//VectorInverse(dv[k]->binormal);
}
#else
VectorAdd(dv[k]->normal, faceNormal, dv[k]->normal);
#endif
}
}
#if 1
for (j = 0, v = surf->verts; j < surf->numVerts; j++, v++)
{
//VectorNormalize(v->tangent);
//VectorNormalize(v->binormal);
VectorNormalize(v->normal);
}
#endif
}
#endif
#if 0
// do another extra smoothing for normals to avoid flat shading
for (j = 0; j < surf->numVerts; j++)
{
for (k = 0; k < surf->numVerts; k++)
{
if (j == k)
{
continue;
}
if (VectorCompare(surf->verts[j].position, surf->verts[k].position))
{
VectorAdd(surf->verts[j].normal, surf->verts[k].normal, surf->verts[j].normal);
}
}
VectorNormalize(surf->verts[j].normal);
}
#endif
}
// split the surfaces into VBO surfaces by the maximum number of GPU vertex skinning bones
Com_InitGrowList(&vboSurfaces, 10);
for (i = 0, surf = md5->surfaces; i < md5->numSurfaces; i++, surf++)
{
// sort triangles
Com_InitGrowList(&sortedTriangles, 1000);
for (j = 0, tri = surf->triangles; j < surf->numTriangles; j++, tri++)
{
skelTriangle_t *sortTri = Com_Allocate(sizeof(*sortTri));
for (k = 0; k < 3; k++)
{
sortTri->indexes[k] = tri->indexes[k];
sortTri->vertexes[k] = &surf->verts[tri->indexes[k]];
}
sortTri->referenced = qfalse;
Com_AddToGrowList(&sortedTriangles, sortTri);
}
//qsort(sortedTriangles.elements, sortedTriangles.currentElements, sizeof(void *), CompareTrianglesByBoneReferences);
#if 0
for (j = 0; j < sortedTriangles.currentElements; j++)
{
int b[MAX_WEIGHTS * 3];
skelTriangle_t *sortTri = Com_GrowListElement(&sortedTriangles, j);
for (k = 0; k < 3; k++)
{
v = sortTri->vertexes[k];
for (l = 0; l < MAX_WEIGHTS; l++)
{
b[k * 3 + l] = (l < v->numWeights) ? v->weights[l]->boneIndex : 9999;
}
qsort(b, MAX_WEIGHTS * 3, sizeof(int), CompareBoneIndices);
//Ren_Print("bone indices: %i %i %i %i\n", b[k * 3 + 0], b[k * 3 + 1], b[k * 3 + 2], b[k * 3 + 3]);
}
}
#endif
numRemaining = sortedTriangles.currentElements;
while (numRemaining)
{
numBoneReferences = 0;
Com_Memset(boneReferences, 0, sizeof(boneReferences));
Com_InitGrowList(&vboTriangles, 1000);
for (j = 0; j < sortedTriangles.currentElements; j++)
{
skelTriangle_t *sortTri = Com_GrowListElement(&sortedTriangles, j);
if (sortTri->referenced)
{
continue;
}
if (AddTriangleToVBOTriangleList(&vboTriangles, sortTri, &numBoneReferences, boneReferences))
{
sortTri->referenced = qtrue;
}
}
if (!vboTriangles.currentElements)
{
Ren_Warning("R_LoadMD5: could not add triangles to a remaining VBO surfaces for model '%s'\n", modName);
Com_DestroyGrowList(&vboTriangles);
break;
}
AddSurfaceToVBOSurfacesList(&vboSurfaces, &vboTriangles, md5, surf, i, numBoneReferences, boneReferences);
numRemaining -= vboTriangles.currentElements;
Com_DestroyGrowList(&vboTriangles);
}
for (j = 0; j < sortedTriangles.currentElements; j++)
{
skelTriangle_t *sortTri = Com_GrowListElement(&sortedTriangles, j);
Com_Dealloc(sortTri);
}
Com_DestroyGrowList(&sortedTriangles);
}
// move VBO surfaces list to hunk
md5->numVBOSurfaces = vboSurfaces.currentElements;
md5->vboSurfaces = ri.Hunk_Alloc(md5->numVBOSurfaces * sizeof(*md5->vboSurfaces), h_low);
for (i = 0; i < md5->numVBOSurfaces; i++)
{
md5->vboSurfaces[i] = ( srfVBOMD5Mesh_t * ) Com_GrowListElement(&vboSurfaces, i);
}
Com_DestroyGrowList(&vboSurfaces);
return qtrue;
}
/*
=================
R_LoadMDC
=================
*/
qboolean R_LoadMDC(model_t * mod, int lod, void *buffer, int bufferSize, const char *modName)
{
int i, j, k, l;
mdcHeader_t *mdcModel;
md3Frame_t *mdcFrame;
mdcSurface_t *mdcSurf;
md3Shader_t *mdcShader;
md3Triangle_t *mdcTri;
md3St_t *mdcst;
md3XyzNormal_t *mdcxyz;
mdcXyzCompressed_t *mdcxyzComp;
mdcTag_t *mdcTag;
mdcTagName_t *mdcTagName;
mdvModel_t *mdvModel;
mdvFrame_t *frame;
mdvSurface_t *surf, *surface;
srfTriangle_t *tri;
mdvXyz_t *v;
mdvSt_t *st;
mdvTag_t *tag;
mdvTagName_t *tagName;
short *ps;
int version;
int size;
mdcModel = (mdcHeader_t *) buffer;
version = LittleLong(mdcModel->version);
if(version != MDC_VERSION)
{
ri.Printf(PRINT_WARNING, "R_LoadMD3: %s has wrong version (%i should be %i)\n", modName, version, MDC_VERSION);
return qfalse;
}
mod->type = MOD_MESH;
size = LittleLong(mdcModel->ofsEnd);
mod->dataSize += size;
mdvModel = mod->mdv[lod] = (mdvModel_t*)ri.Hunk_Alloc(sizeof(mdvModel_t), h_low);
LL(mdcModel->ident);
LL(mdcModel->version);
LL(mdcModel->numFrames);
LL(mdcModel->numTags);
LL(mdcModel->numSurfaces);
LL(mdcModel->ofsFrames);
LL(mdcModel->ofsTags);
LL(mdcModel->ofsSurfaces);
LL(mdcModel->ofsEnd);
LL(mdcModel->ofsEnd);
LL(mdcModel->flags);
LL(mdcModel->numSkins);
if(mdcModel->numFrames < 1)
{
ri.Printf(PRINT_WARNING, "R_LoadMDC: '%s' has no frames\n", modName);
return qfalse;
}
// swap all the frames
mdvModel->numFrames = mdcModel->numFrames;
mdvModel->frames = frame = (mdvFrame_t*)ri.Hunk_Alloc(sizeof(*frame) * mdcModel->numFrames, h_low);
mdcFrame = (md3Frame_t *) ((byte *) mdcModel + mdcModel->ofsFrames);
for(i = 0; i < mdcModel->numFrames; i++, frame++, mdcFrame++)
{
#if 1
// RB: ET HACK
if(strstr(mod->name, "sherman") || strstr(mod->name, "mg42"))
{
frame->radius = 256;
for(j = 0; j < 3; j++)
{
frame->bounds[0][j] = 128;
frame->bounds[1][j] = -128;
frame->localOrigin[j] = LittleFloat(mdcFrame->localOrigin[j]);
}
}
else
#endif
{
frame->radius = LittleFloat(mdcFrame->radius);
for(j = 0; j < 3; j++)
{
frame->bounds[0][j] = LittleFloat(mdcFrame->bounds[0][j]);
frame->bounds[1][j] = LittleFloat(mdcFrame->bounds[1][j]);
frame->localOrigin[j] = LittleFloat(mdcFrame->localOrigin[j]);
}
}
}
// swap all the tags
mdvModel->numTags = mdcModel->numTags;
mdvModel->tags = tag = (mdvTag_t*)ri.Hunk_Alloc(sizeof(*tag) * (mdcModel->numTags * mdcModel->numFrames), h_low);
mdcTag = (mdcTag_t *) ((byte *) mdcModel + mdcModel->ofsTags);
for(i = 0; i < mdcModel->numTags * mdcModel->numFrames; i++, tag++, mdcTag++)
{
vec3_t angles;
for(j = 0; j < 3; j++)
{
tag->origin[j] = (float)LittleShort(mdcTag->xyz[j]) * MD3_XYZ_SCALE;
angles[j] = (float)LittleShort(mdcTag->angles[j]) * MDC_TAG_ANGLE_SCALE;
}
AnglesToAxis(angles, tag->axis);
}
mdvModel->tagNames = tagName = (mdvTagName_t*)ri.Hunk_Alloc(sizeof(*tagName) * (mdcModel->numTags), h_low);
mdcTagName = (mdcTagName_t *) ((byte *) mdcModel + mdcModel->ofsTagNames);
for(i = 0; i < mdcModel->numTags; i++, tagName++, mdcTagName++)
{
Q_strncpyz(tagName->name, mdcTagName->name, sizeof(tagName->name));
}
// swap all the surfaces
mdvModel->numSurfaces = mdcModel->numSurfaces;
mdvModel->surfaces = surf = (mdvSurface_t*)ri.Hunk_Alloc(sizeof(*surf) * mdcModel->numSurfaces, h_low);
mdcSurf = (mdcSurface_t *) ((byte *) mdcModel + mdcModel->ofsSurfaces);
for(i = 0; i < mdcModel->numSurfaces; i++)
{
LL(mdcSurf->ident);
LL(mdcSurf->flags);
LL(mdcSurf->numBaseFrames);
LL(mdcSurf->numCompFrames);
LL(mdcSurf->numShaders);
LL(mdcSurf->numTriangles);
LL(mdcSurf->ofsTriangles);
LL(mdcSurf->numVerts);
LL(mdcSurf->ofsShaders);
LL(mdcSurf->ofsSt);
LL(mdcSurf->ofsXyzNormals);
LL(mdcSurf->ofsXyzNormals);
LL(mdcSurf->ofsXyzCompressed);
LL(mdcSurf->ofsFrameBaseFrames);
LL(mdcSurf->ofsFrameCompFrames);
LL(mdcSurf->ofsEnd);
if(mdcSurf->numVerts > SHADER_MAX_VERTEXES)
{
ri.Error(ERR_DROP, "R_LoadMDC: %s has more than %i verts on a surface (%i)",
modName, SHADER_MAX_VERTEXES, mdcSurf->numVerts);
}
if(mdcSurf->numTriangles > SHADER_MAX_TRIANGLES)
{
ri.Error(ERR_DROP, "R_LoadMDC: %s has more than %i triangles on a surface (%i)",
modName, SHADER_MAX_TRIANGLES, mdcSurf->numTriangles);
}
// change to surface identifier
surf->surfaceType = SF_MDV;
// give pointer to model for Tess_SurfaceMDX
surf->model = mdvModel;
// copy surface name
Q_strncpyz(surf->name, mdcSurf->name, sizeof(surf->name));
// lowercase the surface name so skin compares are faster
Q_strlwr(surf->name);
// strip off a trailing _1 or _2
// this is a crutch for q3data being a mess
j = strlen(surf->name);
if(j > 2 && surf->name[j - 2] == '_')
{
surf->name[j - 2] = 0;
}
// register the shaders
/*
surf->numShaders = md3Surf->numShaders;
surf->shaders = shader = ri.Hunk_Alloc(sizeof(*shader) * md3Surf->numShaders, h_low);
md3Shader = (md3Shader_t *) ((byte *) md3Surf + md3Surf->ofsShaders);
for(j = 0; j < md3Surf->numShaders; j++, shader++, md3Shader++)
{
shader_t *sh;
sh = R_FindShader(md3Shader->name, SHADER_3D_DYNAMIC, qtrue);
if(sh->defaultShader)
{
shader->shaderIndex = 0;
}
else
{
shader->shaderIndex = sh->index;
}
}
*/
// only consider the first shader
mdcShader = (md3Shader_t *) ((byte *) mdcSurf + mdcSurf->ofsShaders);
surf->shader = R_FindShader(mdcShader->name, SHADER_3D_DYNAMIC, qtrue);
// swap all the triangles
surf->numTriangles = mdcSurf->numTriangles;
surf->triangles = tri = (srfTriangle_t*)ri.Hunk_Alloc(sizeof(*tri) * mdcSurf->numTriangles, h_low);
mdcTri = (md3Triangle_t *) ((byte *) mdcSurf + mdcSurf->ofsTriangles);
for(j = 0; j < mdcSurf->numTriangles; j++, tri++, mdcTri++)
{
tri->indexes[0] = LittleLong(mdcTri->indexes[0]);
tri->indexes[1] = LittleLong(mdcTri->indexes[1]);
tri->indexes[2] = LittleLong(mdcTri->indexes[2]);
}
R_CalcSurfaceTriangleNeighbors(surf->numTriangles, surf->triangles);
// swap all the XyzNormals
mdcxyz = (md3XyzNormal_t *) ((byte *) mdcSurf + mdcSurf->ofsXyzNormals);
for(j = 0; j < mdcSurf->numVerts * mdcSurf->numBaseFrames; j++, mdcxyz++)
{
mdcxyz->xyz[0] = LittleShort(mdcxyz->xyz[0]);
mdcxyz->xyz[1] = LittleShort(mdcxyz->xyz[1]);
mdcxyz->xyz[2] = LittleShort(mdcxyz->xyz[2]);
mdcxyz->normal = LittleShort(mdcxyz->normal);
}
// swap all the XyzCompressed
mdcxyzComp = (mdcXyzCompressed_t *) ((byte *) mdcSurf + mdcSurf->ofsXyzCompressed);
for(j = 0; j < mdcSurf->numVerts * mdcSurf->numCompFrames; j++, mdcxyzComp++)
{
LL(mdcxyzComp->ofsVec);
}
// swap the frameBaseFrames
ps = (short *)((byte *) mdcSurf + mdcSurf->ofsFrameBaseFrames);
for(j = 0; j < mdcModel->numFrames; j++, ps++)
{
*ps = LittleShort(*ps);
}
// swap the frameCompFrames
ps = (short *)((byte *) mdcSurf + mdcSurf->ofsFrameCompFrames);
for(j = 0; j < mdcModel->numFrames; j++, ps++)
{
*ps = LittleShort(*ps);
}
surf->numVerts = mdcSurf->numVerts;
surf->verts = v = (mdvXyz_t*)ri.Hunk_Alloc(sizeof(*v) * (mdcSurf->numVerts * mdcModel->numFrames), h_low);
for(j = 0; j < mdcModel->numFrames; j++)
{
int baseFrame;
int compFrame;
baseFrame = (int) *((short *)((byte *) mdcSurf + mdcSurf->ofsFrameBaseFrames) + j);
mdcxyz = (md3XyzNormal_t *)((byte *) mdcSurf + mdcSurf->ofsXyzNormals + baseFrame * mdcSurf->numVerts * sizeof(md3XyzNormal_t));
if(mdcSurf->numCompFrames > 0)
{
compFrame = (int) *((short *)((byte *) mdcSurf + mdcSurf->ofsFrameCompFrames) + j);
if(compFrame >= 0)
{
mdcxyzComp = (mdcXyzCompressed_t *) ((byte *) mdcSurf + mdcSurf->ofsXyzCompressed + compFrame * mdcSurf->numVerts * sizeof(mdcXyzCompressed_t));
}
}
for(k = 0; k < mdcSurf->numVerts; k++, v++, mdcxyz++)
{
v->xyz[0] = LittleShort(mdcxyz->xyz[0]) * MD3_XYZ_SCALE;
v->xyz[1] = LittleShort(mdcxyz->xyz[1]) * MD3_XYZ_SCALE;
v->xyz[2] = LittleShort(mdcxyz->xyz[2]) * MD3_XYZ_SCALE;
if(mdcSurf->numCompFrames > 0 && compFrame >= 0)
{
vec3_t ofsVec;
vec3_t normal;
R_MDC_DecodeXyzCompressed(LittleShort(mdcxyzComp->ofsVec), ofsVec, normal);
VectorAdd(v->xyz, ofsVec, v->xyz);
mdcxyzComp++;
}
}
}
// swap all the ST
surf->st = st = (mdvSt_t*)ri.Hunk_Alloc(sizeof(*st) * mdcSurf->numVerts, h_low);
mdcst = (md3St_t *) ((byte *) mdcSurf + mdcSurf->ofsSt);
for(j = 0; j < mdcSurf->numVerts; j++, mdcst++, st++)
{
st->st[0] = LittleFloat(mdcst->st[0]);
st->st[1] = LittleFloat(mdcst->st[1]);
}
// find the next surface
mdcSurf = (mdcSurface_t *) ((byte *) mdcSurf + mdcSurf->ofsEnd);
surf++;
}
#if defined(USE_D3D10)
// TODO
#else
#if 1
// create VBO surfaces from md3 surfaces
{
mdvNormTanBi_t *vertexes;
mdvNormTanBi_t *vert;
growList_t vboSurfaces;
srfVBOMDVMesh_t *vboSurf;
byte *data;
int dataSize;
int dataOfs;
vec4_t tmp;
GLuint ofsTexCoords;
GLuint ofsTangents;
GLuint ofsBinormals;
GLuint ofsNormals;
GLuint sizeXYZ;
GLuint sizeTangents;
GLuint sizeBinormals;
GLuint sizeNormals;
int vertexesNum;
int f;
Com_InitGrowList(&vboSurfaces, 10);
for(i = 0, surf = mdvModel->surfaces; i < mdvModel->numSurfaces; i++, surf++)
{
//allocate temp memory for vertex data
vertexes = (mdvNormTanBi_t*)ri.Hunk_AllocateTempMemory( sizeof( *vertexes ) * surf->numVerts * mdvModel->numFrames );
// calc tangent spaces
{
const float *v0, *v1, *v2;
const float *t0, *t1, *t2;
vec3_t tangent;
vec3_t binormal;
vec3_t normal;
for ( j = 0, vert = vertexes; j < ( surf->numVerts * mdvModel->numFrames ); j++, vert++ )
{
VectorClear(vert->tangent);
VectorClear(vert->binormal);
VectorClear(vert->normal);
}
for(f = 0; f < mdvModel->numFrames; f++)
{
for(j = 0, tri = surf->triangles; j < surf->numTriangles; j++, tri++)
{
v0 = surf->verts[surf->numVerts * f + tri->indexes[0]].xyz;
v1 = surf->verts[surf->numVerts * f + tri->indexes[1]].xyz;
v2 = surf->verts[surf->numVerts * f + tri->indexes[2]].xyz;
t0 = surf->st[tri->indexes[0]].st;
t1 = surf->st[tri->indexes[1]].st;
t2 = surf->st[tri->indexes[2]].st;
#if 1
R_CalcTangentSpace(tangent, binormal, normal, v0, v1, v2, t0, t1, t2);
#else
R_CalcNormalForTriangle(normal, v0, v1, v2);
R_CalcTangentsForTriangle(tangent, binormal, v0, v1, v2, t0, t1, t2);
#endif
for(k = 0; k < 3; k++)
{
float *v;
v = vertexes[surf->numVerts * f + tri->indexes[k]].tangent;
VectorAdd(v, tangent, v);
v = vertexes[surf->numVerts * f + tri->indexes[k]].binormal;
VectorAdd(v, binormal, v);
v = vertexes[surf->numVerts * f + tri->indexes[k]].normal;
VectorAdd(v, normal, v);
}
}
}
for ( j = 0, vert = vertexes; j < ( surf->numVerts * mdvModel->numFrames ); j++, vert++ )
{
VectorNormalize(vert->tangent);
VectorNormalize(vert->binormal);
VectorNormalize(vert->normal);
}
}
//ri.Printf(PRINT_ALL, "...calculating MDC mesh VBOs ( '%s', %i verts %i tris )\n", surf->name, surf->numVerts, surf->numTriangles);
// create surface
vboSurf = (srfVBOMDVMesh_t*)ri.Hunk_Alloc(sizeof(*vboSurf), h_low);
Com_AddToGrowList(&vboSurfaces, vboSurf);
vboSurf->surfaceType = SF_VBO_MDVMESH;
vboSurf->mdvModel = mdvModel;
vboSurf->mdvSurface = surf;
vboSurf->numIndexes = surf->numTriangles * 3;
vboSurf->numVerts = surf->numVerts;
/*
vboSurf->vbo = R_CreateVBO2(va("staticWorldMesh_vertices %i", vboSurfaces.currentElements), numVerts, optimizedVerts,
ATTR_POSITION | ATTR_TEXCOORD | ATTR_LIGHTCOORD | ATTR_TANGENT | ATTR_BINORMAL | ATTR_NORMAL
| ATTR_COLOR);
*/
vboSurf->ibo = R_CreateIBO2(va("staticMDCMesh_IBO %s", surf->name), surf->numTriangles, surf->triangles, VBO_USAGE_STATIC);
// create VBO
vertexesNum = surf->numVerts;
dataSize = (surf->numVerts * mdvModel->numFrames * sizeof(vec4_t) * 4) + // xyz, tangent, binormal, normal
(surf->numVerts * sizeof(vec4_t)); // texcoords
data = (byte*)ri.Hunk_AllocateTempMemory(dataSize);
dataOfs = 0;
// feed vertex XYZ
for(f = 0; f < mdvModel->numFrames; f++)
{
for(j = 0; j < vertexesNum; j++)
{
for(k = 0; k < 3; k++)
{
tmp[k] = surf->verts[f * vertexesNum + j].xyz[k];
}
tmp[3] = 1;
Com_Memcpy(data + dataOfs, (vec_t *) tmp, sizeof(vec4_t));
dataOfs += sizeof(vec4_t);
}
if(f == 0)
{
sizeXYZ = dataOfs;
}
}
// feed vertex texcoords
ofsTexCoords = dataOfs;
for(j = 0; j < vertexesNum; j++)
{
for(k = 0; k < 2; k++)
{
tmp[k] = surf->st[j].st[k];
}
tmp[2] = 0;
tmp[3] = 1;
Com_Memcpy(data + dataOfs, (vec_t *) tmp, sizeof(vec4_t));
dataOfs += sizeof(vec4_t);
}
// feed vertex tangents
ofsTangents = dataOfs;
for(f = 0; f < mdvModel->numFrames; f++)
{
for(j = 0; j < vertexesNum; j++)
{
for(k = 0; k < 3; k++)
{
tmp[k] = vertexes[f * vertexesNum + j].tangent[k];
}
tmp[3] = 1;
Com_Memcpy(data + dataOfs, (vec_t *) tmp, sizeof(vec4_t));
dataOfs += sizeof(vec4_t);
}
if(f == 0)
{
sizeTangents = dataOfs - ofsTangents;
}
}
// feed vertex binormals
ofsBinormals = dataOfs;
for(f = 0; f < mdvModel->numFrames; f++)
{
for(j = 0; j < vertexesNum; j++)
{
for(k = 0; k < 3; k++)
{
tmp[k] = vertexes[f * vertexesNum + j].binormal[k];
}
tmp[3] = 1;
Com_Memcpy(data + dataOfs, (vec_t *) tmp, sizeof(vec4_t));
dataOfs += sizeof(vec4_t);
}
if(f == 0)
{
sizeBinormals = dataOfs - ofsBinormals;
}
}
// feed vertex normals
ofsNormals = dataOfs;
for(f = 0; f < mdvModel->numFrames; f++)
{
for(j = 0; j < vertexesNum; j++)
{
for(k = 0; k < 3; k++)
{
tmp[k] = vertexes[f * vertexesNum + j].normal[k];
}
tmp[3] = 1;
Com_Memcpy(data + dataOfs, (vec_t *) tmp, sizeof(vec4_t));
dataOfs += sizeof(vec4_t);
}
if(f == 0)
{
sizeNormals = dataOfs - ofsNormals;
}
}
vboSurf->vbo = R_CreateVBO(va("staticMDCMesh_VBO '%s'", surf->name), data, dataSize, VBO_USAGE_STATIC);
vboSurf->vbo->ofsXYZ = 0;
vboSurf->vbo->ofsTexCoords = ofsTexCoords;
vboSurf->vbo->ofsLightCoords = ofsTexCoords;
vboSurf->vbo->ofsTangents = ofsTangents;
vboSurf->vbo->ofsBinormals = ofsBinormals;
vboSurf->vbo->ofsNormals = ofsNormals;
vboSurf->vbo->sizeXYZ = sizeXYZ;
vboSurf->vbo->sizeTangents = sizeTangents;
vboSurf->vbo->sizeBinormals = sizeBinormals;
vboSurf->vbo->sizeNormals = sizeNormals;
ri.Hunk_FreeTempMemory(data);
ri.Hunk_FreeTempMemory(vertexes);
}
// move VBO surfaces list to hunk
mdvModel->numVBOSurfaces = vboSurfaces.currentElements;
mdvModel->vboSurfaces = (srfVBOMDVMesh_t**)ri.Hunk_Alloc(mdvModel->numVBOSurfaces * sizeof(*mdvModel->vboSurfaces), h_low);
for(i = 0; i < mdvModel->numVBOSurfaces; i++)
{
mdvModel->vboSurfaces[i] = (srfVBOMDVMesh_t *) Com_GrowListElement(&vboSurfaces, i);
}
Com_DestroyGrowList(&vboSurfaces);
}
#endif
#endif // USE_D3D10
return qtrue;
}
/**
* @brief AddSurfaceToVBOSurfacesListMDM
* @param[in] vboSurfaces
* @param[in] vboTriangles
* @param[in] mdm
* @param[in] surf
* @param[in] skinIndex
* @param numBoneReferences - unused
* @param[in] boneReferences
*/
static void AddSurfaceToVBOSurfacesListMDM(growList_t *vboSurfaces, growList_t *vboTriangles, mdmModel_t *mdm, mdmSurfaceIntern_t *surf, int skinIndex, int numBoneReferences, int boneReferences[MAX_BONES])
{
int j, k, lod;
int vertexesNum = surf->numVerts;
byte *data;
int dataSize;
int dataOfs;
GLuint ofsTexCoords;
GLuint ofsTangents;
GLuint ofsBinormals;
GLuint ofsNormals;
GLuint ofsBoneIndexes;
GLuint ofsBoneWeights;
int indexesNum = vboTriangles->currentElements * 3;
byte *indexes;
int indexesSize;
int indexesOfs;
skelTriangle_t *tri;
vec4_t tmp;
int index;
srfVBOMDMMesh_t *vboSurf;
md5Vertex_t *v;
//vec4_t tmpColor = { 1, 1, 1, 1 };
static int32_t collapse[MDM_MAX_VERTS];
// create surface
vboSurf = ri.Hunk_Alloc(sizeof(*vboSurf), h_low);
Com_AddToGrowList(vboSurfaces, vboSurf);
vboSurf->surfaceType = SF_VBO_MDMMESH;
vboSurf->mdmModel = mdm;
vboSurf->mdmSurface = surf;
vboSurf->shader = R_GetShaderByHandle(surf->shaderIndex);
vboSurf->skinIndex = skinIndex;
vboSurf->numIndexes = indexesNum;
vboSurf->numVerts = vertexesNum;
dataSize = vertexesNum * (sizeof(vec4_t) * 7);
data = ri.Hunk_AllocateTempMemory(dataSize);
dataOfs = 0;
//Ren_Print("AddSurfaceToVBOSurfacesList( %i verts, %i tris )\n", surf->numVerts, vboTriangles->currentElements);
vboSurf->numBoneRemap = 0;
Com_Memset(vboSurf->boneRemap, 0, sizeof(vboSurf->boneRemap));
Com_Memset(vboSurf->boneRemapInverse, 0, sizeof(vboSurf->boneRemapInverse));
//Ren_Print("original referenced bones: [ ");
//for(j = 0; j < surf->numBoneReferences; j++)
//{
// Ren_Print("%i, ", surf->boneReferences[j]);
//}
//Ren_Print("]\n");
//Ren_Print("new referenced bones: ");
for (j = 0; j < MAX_BONES; j++)
{
if (boneReferences[j] > 0)
{
vboSurf->boneRemap[j] = vboSurf->numBoneRemap;
vboSurf->boneRemapInverse[vboSurf->numBoneRemap] = j;
vboSurf->numBoneRemap++;
//Ren_Print("(%i -> %i) ", j, vboSurf->boneRemap[j]);
}
}
//Ren_Print("\n");
// feed vertex XYZ
for (j = 0; j < vertexesNum; j++)
{
for (k = 0; k < 3; k++)
{
tmp[k] = surf->verts[j].position[k];
}
tmp[3] = 1;
Com_Memcpy(data + dataOfs, ( vec_t * ) tmp, sizeof(vec4_t));
dataOfs += sizeof(vec4_t);
}
// feed vertex texcoords
ofsTexCoords = dataOfs;
for (j = 0; j < vertexesNum; j++)
{
for (k = 0; k < 2; k++)
{
tmp[k] = surf->verts[j].texCoords[k];
}
tmp[2] = 0;
tmp[3] = 1;
Com_Memcpy(data + dataOfs, ( vec_t * ) tmp, sizeof(vec4_t));
dataOfs += sizeof(vec4_t);
}
// feed vertex tangents
ofsTangents = dataOfs;
for (j = 0; j < vertexesNum; j++)
{
for (k = 0; k < 3; k++)
{
tmp[k] = surf->verts[j].tangent[k];
}
tmp[3] = 1;
Com_Memcpy(data + dataOfs, ( vec_t * ) tmp, sizeof(vec4_t));
dataOfs += sizeof(vec4_t);
}
// feed vertex binormals
ofsBinormals = dataOfs;
for (j = 0; j < vertexesNum; j++)
{
for (k = 0; k < 3; k++)
{
tmp[k] = surf->verts[j].binormal[k];
}
tmp[3] = 1;
Com_Memcpy(data + dataOfs, ( vec_t * ) tmp, sizeof(vec4_t));
dataOfs += sizeof(vec4_t);
}
// feed vertex normals
ofsNormals = dataOfs;
for (j = 0; j < vertexesNum; j++)
{
for (k = 0; k < 3; k++)
{
tmp[k] = surf->verts[j].normal[k];
}
tmp[3] = 1;
Com_Memcpy(data + dataOfs, ( vec_t * ) tmp, sizeof(vec4_t));
dataOfs += sizeof(vec4_t);
}
// feed bone indices
ofsBoneIndexes = dataOfs;
for (j = 0, v = surf->verts; j < surf->numVerts; j++, v++)
{
for (k = 0; k < MAX_WEIGHTS; k++)
{
if (k < v->numWeights)
{
index = vboSurf->boneRemap[v->weights[k]->boneIndex];
}
else
{
index = 0;
}
Com_Memcpy(data + dataOfs, &index, sizeof(int));
dataOfs += sizeof(int);
}
}
// feed bone weights
ofsBoneWeights = dataOfs;
for (j = 0, v = surf->verts; j < surf->numVerts; j++, v++)
{
for (k = 0; k < MAX_WEIGHTS; k++)
{
if (k < v->numWeights)
{
tmp[k] = v->weights[k]->boneWeight;
}
else
{
tmp[k] = 0;
}
}
Com_Memcpy(data + dataOfs, ( vec_t * ) tmp, sizeof(vec4_t));
dataOfs += sizeof(vec4_t);
}
vboSurf->vbo = R_CreateVBO(va("staticMDMMesh_VBO %i", vboSurfaces->currentElements), data, dataSize, VBO_USAGE_STATIC);
vboSurf->vbo->ofsXYZ = 0;
vboSurf->vbo->ofsTexCoords = ofsTexCoords;
vboSurf->vbo->ofsLightCoords = ofsTexCoords;
vboSurf->vbo->ofsTangents = ofsTangents;
vboSurf->vbo->ofsBinormals = ofsBinormals;
vboSurf->vbo->ofsNormals = ofsNormals;
vboSurf->vbo->ofsColors = ofsNormals;
//vboSurf->vbo->ofsLightCoords = 0; // not required anyway
//vboSurf->vbo->ofsLightDirections = 0; // not required anyway
vboSurf->vbo->ofsBoneIndexes = ofsBoneIndexes;
vboSurf->vbo->ofsBoneWeights = ofsBoneWeights;
// calculate LOD IBOs
lod = 0;
do
{
float flod;
int renderCount;
flod = mdmLODResolutions[lod];
renderCount = MIN(( int )(( float ) surf->numVerts * flod), surf->numVerts);
if (renderCount < surf->minLod)
{
renderCount = surf->minLod;
flod = ( float ) renderCount / surf->numVerts;
}
if (renderCount == surf->numVerts)
{
indexesNum = vboTriangles->currentElements * 3;
indexesSize = indexesNum * sizeof(int);
indexes = ri.Hunk_AllocateTempMemory(indexesSize);
indexesOfs = 0;
for (j = 0; j < vboTriangles->currentElements; j++)
{
tri = Com_GrowListElement(vboTriangles, j);
for (k = 0; k < 3; k++)
{
index = tri->indexes[k];
Com_Memcpy(indexes + indexesOfs, &index, sizeof(int));
indexesOfs += sizeof(int);
}
}
}
else
{
int ci[3];
int32_t *pCollapseMap;
int32_t *pCollapse;
pCollapse = collapse;
for (j = 0; j < renderCount; pCollapse++, j++)
{
*pCollapse = j;
}
pCollapseMap = &surf->collapseMap[renderCount];
for (j = renderCount; j < surf->numVerts; j++, pCollapse++, pCollapseMap++)
{
int32_t collapseValue = *pCollapseMap;
*pCollapse = collapse[collapseValue];
}
indexesNum = 0;
for (j = 0; j < vboTriangles->currentElements; j++)
{
tri = Com_GrowListElement(vboTriangles, j);
ci[0] = collapse[tri->indexes[0]];
ci[1] = collapse[tri->indexes[1]];
ci[2] = collapse[tri->indexes[2]];
// FIXME
// note: serious optimization opportunity here,
// by sorting the triangles the following "continue"
// could have been made into a "break" statement.
if (ci[0] == ci[1] || ci[1] == ci[2] || ci[2] == ci[0])
{
continue;
}
indexesNum += 3;
}
indexesSize = indexesNum * sizeof(int);
indexes = ri.Hunk_AllocateTempMemory(indexesSize);
indexesOfs = 0;
for (j = 0; j < vboTriangles->currentElements; j++)
{
tri = Com_GrowListElement(vboTriangles, j);
ci[0] = collapse[tri->indexes[0]];
ci[1] = collapse[tri->indexes[1]];
ci[2] = collapse[tri->indexes[2]];
// FIXME
// note: serious optimization opportunity here,
// by sorting the triangles the following "continue"
// could have been made into a "break" statement.
if (ci[0] == ci[1] || ci[1] == ci[2] || ci[2] == ci[0])
{
continue;
}
for (k = 0; k < 3; k++)
{
index = ci[k];
Com_Memcpy(indexes + indexesOfs, &index, sizeof(int));
indexesOfs += sizeof(int);
}
}
}
vboSurf->ibo[lod] = R_CreateIBO(va("staticMDMMesh_IBO_LOD_%f %i", flod, indexesNum / 3), indexes, indexesSize, VBO_USAGE_STATIC);
vboSurf->ibo[lod]->indexesNum = indexesNum;
ri.Hunk_FreeTempMemory(indexes);
if (vboTriangles->currentElements != surf->numTriangles)
{
Ren_Warning("Can't calculate LOD IBOs\n");
break;
}
lod++;
}
while (lod < MD3_MAX_LODS);
ri.Hunk_FreeTempMemory(data);
// megs
/*
Ren_Print("md5 mesh data VBO size: %d.%02d MB\n", dataSize / (1024 * 1024),
(dataSize % (1024 * 1024)) * 100 / (1024 * 1024));
Ren_Print("md5 mesh tris VBO size: %d.%02d MB\n", indexesSize / (1024 * 1024),
(indexesSize % (1024 * 1024)) * 100 / (1024 * 1024));
*/
}
/*
=================
R_LoadMDC
=================
*/
qboolean R_LoadMDC( model_t *mod, int lod, void *buffer, int bufferSize, const char *modName )
{
int i, j, k;
mdcHeader_t *mdcModel;
md3Frame_t *mdcFrame;
mdcSurface_t *mdcSurf;
md3Shader_t *mdcShader;
md3Triangle_t *mdcTri;
md3St_t *mdcst;
md3XyzNormal_t *mdcxyz;
mdcXyzCompressed_t *mdcxyzComp;
mdcTag_t *mdcTag;
mdcTagName_t *mdcTagName;
mdvModel_t *mdvModel;
mdvFrame_t *frame;
mdvSurface_t *surf; //, *surface; //unused
srfTriangle_t *tri;
mdvXyz_t *v;
mdvSt_t *st;
mdvTag_t *tag;
mdvTagName_t *tagName;
short *ps;
int version;
int size;
mdcModel = ( mdcHeader_t * ) buffer;
version = LittleLong( mdcModel->version );
if ( version != MDC_VERSION )
{
ri.Printf( PRINT_WARNING, "R_LoadMD3: %s has wrong version (%i should be %i)\n", modName, version, MDC_VERSION );
return qfalse;
}
mod->type = MOD_MESH;
size = LittleLong( mdcModel->ofsEnd );
mod->dataSize += size;
mdvModel = mod->mdv[ lod ] = (mdvModel_t*) ri.Hunk_Alloc( sizeof( mdvModel_t ), h_low );
LL( mdcModel->ident );
LL( mdcModel->version );
LL( mdcModel->numFrames );
LL( mdcModel->numTags );
LL( mdcModel->numSurfaces );
LL( mdcModel->ofsFrames );
LL( mdcModel->ofsTags );
LL( mdcModel->ofsSurfaces );
LL( mdcModel->ofsEnd );
LL( mdcModel->ofsEnd );
LL( mdcModel->flags );
LL( mdcModel->numSkins );
if ( mdcModel->numFrames < 1 )
{
ri.Printf( PRINT_WARNING, "R_LoadMDC: '%s' has no frames\n", modName );
return qfalse;
}
// swap all the frames
mdvModel->numFrames = mdcModel->numFrames;
mdvModel->frames = frame = (mdvFrame_t*) ri.Hunk_Alloc( sizeof( *frame ) * mdcModel->numFrames, h_low );
mdcFrame = ( md3Frame_t * )( ( byte * ) mdcModel + mdcModel->ofsFrames );
for ( i = 0; i < mdcModel->numFrames; i++, frame++, mdcFrame++ )
{
#if 1
// RB: ET HACK
if ( strstr( mod->name, "sherman" ) || strstr( mod->name, "mg42" ) )
{
frame->radius = 256;
for ( j = 0; j < 3; j++ )
{
frame->bounds[ 0 ][ j ] = 128;
frame->bounds[ 1 ][ j ] = -128;
frame->localOrigin[ j ] = LittleFloat( mdcFrame->localOrigin[ j ] );
}
}
else
#endif
{
frame->radius = LittleFloat( mdcFrame->radius );
for ( j = 0; j < 3; j++ )
{
frame->bounds[ 0 ][ j ] = LittleFloat( mdcFrame->bounds[ 0 ][ j ] );
frame->bounds[ 1 ][ j ] = LittleFloat( mdcFrame->bounds[ 1 ][ j ] );
frame->localOrigin[ j ] = LittleFloat( mdcFrame->localOrigin[ j ] );
}
}
}
// swap all the tags
mdvModel->numTags = mdcModel->numTags;
mdvModel->tags = tag = (mdvTag_t*) ri.Hunk_Alloc( sizeof( *tag ) * ( mdcModel->numTags * mdcModel->numFrames ), h_low );
mdcTag = ( mdcTag_t * )( ( byte * ) mdcModel + mdcModel->ofsTags );
for ( i = 0; i < mdcModel->numTags * mdcModel->numFrames; i++, tag++, mdcTag++ )
{
vec3_t angles;
for ( j = 0; j < 3; j++ )
{
tag->origin[ j ] = ( float ) LittleShort( mdcTag->xyz[ j ] ) * MD3_XYZ_SCALE;
angles[ j ] = ( float ) LittleShort( mdcTag->angles[ j ] ) * MDC_TAG_ANGLE_SCALE;
}
AnglesToAxis( angles, tag->axis );
}
mdvModel->tagNames = tagName = (mdvTagName_t*) ri.Hunk_Alloc( sizeof( *tagName ) * ( mdcModel->numTags ), h_low );
mdcTagName = ( mdcTagName_t * )( ( byte * ) mdcModel + mdcModel->ofsTagNames );
for ( i = 0; i < mdcModel->numTags; i++, tagName++, mdcTagName++ )
{
Q_strncpyz( tagName->name, mdcTagName->name, sizeof( tagName->name ) );
}
// swap all the surfaces
mdvModel->numSurfaces = mdcModel->numSurfaces;
mdvModel->surfaces = surf = (mdvSurface_t*) ri.Hunk_Alloc( sizeof( *surf ) * mdcModel->numSurfaces, h_low );
mdcSurf = ( mdcSurface_t * )( ( byte * ) mdcModel + mdcModel->ofsSurfaces );
for ( i = 0; i < mdcModel->numSurfaces; i++ )
{
LL( mdcSurf->ident );
LL( mdcSurf->flags );
LL( mdcSurf->numBaseFrames );
LL( mdcSurf->numCompFrames );
LL( mdcSurf->numShaders );
LL( mdcSurf->numTriangles );
LL( mdcSurf->ofsTriangles );
LL( mdcSurf->numVerts );
LL( mdcSurf->ofsShaders );
LL( mdcSurf->ofsSt );
LL( mdcSurf->ofsXyzNormals );
LL( mdcSurf->ofsXyzNormals );
LL( mdcSurf->ofsXyzCompressed );
LL( mdcSurf->ofsFrameBaseFrames );
LL( mdcSurf->ofsFrameCompFrames );
LL( mdcSurf->ofsEnd );
if ( mdcSurf->numVerts > SHADER_MAX_VERTEXES )
{
ri.Error( ERR_DROP, "R_LoadMDC: %s has more than %i verts on a surface (%i)",
modName, SHADER_MAX_VERTEXES, mdcSurf->numVerts );
}
if ( mdcSurf->numTriangles > SHADER_MAX_TRIANGLES )
{
ri.Error( ERR_DROP, "R_LoadMDC: %s has more than %i triangles on a surface (%i)",
modName, SHADER_MAX_TRIANGLES, mdcSurf->numTriangles );
}
// change to surface identifier
surf->surfaceType = SF_MDV;
// give pointer to model for Tess_SurfaceMDV
surf->model = mdvModel;
// copy surface name
Q_strncpyz( surf->name, mdcSurf->name, sizeof( surf->name ) );
// lowercase the surface name so skin compares are faster
Q_strlwr( surf->name );
// strip off a trailing _1 or _2
// this is a crutch for q3data being a mess
j = strlen( surf->name );
if ( j > 2 && surf->name[ j - 2 ] == '_' )
{
surf->name[ j - 2 ] = 0;
}
// register the shaders
/*
surf->numShaders = md3Surf->numShaders;
surf->shaders = shader = ri.Hunk_Alloc(sizeof(*shader) * md3Surf->numShaders, h_low);
md3Shader = (md3Shader_t *) ((byte *) md3Surf + md3Surf->ofsShaders);
for(j = 0; j < md3Surf->numShaders; j++, shader++, md3Shader++)
{
shader_t *sh;
sh = R_FindShader(md3Shader->name, SHADER_3D_DYNAMIC, RSF_DEFAULT);
if(sh->defaultShader)
{
shader->shaderIndex = 0;
}
else
{
shader->shaderIndex = sh->index;
}
}
*/
// only consider the first shader
mdcShader = ( md3Shader_t * )( ( byte * ) mdcSurf + mdcSurf->ofsShaders );
surf->shader = R_FindShader( mdcShader->name, SHADER_3D_DYNAMIC, RSF_DEFAULT );
// swap all the triangles
surf->numTriangles = mdcSurf->numTriangles;
surf->triangles = tri = (srfTriangle_t*) ri.Hunk_Alloc( sizeof( *tri ) * mdcSurf->numTriangles, h_low );
mdcTri = ( md3Triangle_t * )( ( byte * ) mdcSurf + mdcSurf->ofsTriangles );
for ( j = 0; j < mdcSurf->numTriangles; j++, tri++, mdcTri++ )
{
tri->indexes[ 0 ] = LittleLong( mdcTri->indexes[ 0 ] );
tri->indexes[ 1 ] = LittleLong( mdcTri->indexes[ 1 ] );
tri->indexes[ 2 ] = LittleLong( mdcTri->indexes[ 2 ] );
}
// swap all the XyzNormals
mdcxyz = ( md3XyzNormal_t * )( ( byte * ) mdcSurf + mdcSurf->ofsXyzNormals );
for ( j = 0; j < mdcSurf->numVerts * mdcSurf->numBaseFrames; j++, mdcxyz++ )
{
mdcxyz->xyz[ 0 ] = LittleShort( mdcxyz->xyz[ 0 ] );
mdcxyz->xyz[ 1 ] = LittleShort( mdcxyz->xyz[ 1 ] );
mdcxyz->xyz[ 2 ] = LittleShort( mdcxyz->xyz[ 2 ] );
mdcxyz->normal = LittleShort( mdcxyz->normal );
}
// swap all the XyzCompressed
mdcxyzComp = ( mdcXyzCompressed_t * )( ( byte * ) mdcSurf + mdcSurf->ofsXyzCompressed );
for ( j = 0; j < mdcSurf->numVerts * mdcSurf->numCompFrames; j++, mdcxyzComp++ )
{
LL( mdcxyzComp->ofsVec );
}
// swap the frameBaseFrames
ps = ( short * )( ( byte * ) mdcSurf + mdcSurf->ofsFrameBaseFrames );
for ( j = 0; j < mdcModel->numFrames; j++, ps++ )
{
*ps = LittleShort( *ps );
}
// swap the frameCompFrames
ps = ( short * )( ( byte * ) mdcSurf + mdcSurf->ofsFrameCompFrames );
for ( j = 0; j < mdcModel->numFrames; j++, ps++ )
{
*ps = LittleShort( *ps );
}
surf->numVerts = mdcSurf->numVerts;
surf->verts = v = (mdvXyz_t*) ri.Hunk_Alloc( sizeof( *v ) * ( mdcSurf->numVerts * mdcModel->numFrames ), h_low );
for ( j = 0; j < mdcModel->numFrames; j++ )
{
int baseFrame;
int compFrame = 0;
baseFrame = ( int ) * ( ( short * )( ( byte * ) mdcSurf + mdcSurf->ofsFrameBaseFrames ) + j );
mdcxyz = ( md3XyzNormal_t * )( ( byte * ) mdcSurf + mdcSurf->ofsXyzNormals + baseFrame * mdcSurf->numVerts * sizeof( md3XyzNormal_t ) );
if ( mdcSurf->numCompFrames > 0 )
{
compFrame = ( int ) * ( ( short * )( ( byte * ) mdcSurf + mdcSurf->ofsFrameCompFrames ) + j );
if ( compFrame >= 0 )
{
mdcxyzComp = ( mdcXyzCompressed_t * )( ( byte * ) mdcSurf + mdcSurf->ofsXyzCompressed + compFrame * mdcSurf->numVerts * sizeof( mdcXyzCompressed_t ) );
}
}
for ( k = 0; k < mdcSurf->numVerts; k++, v++, mdcxyz++ )
{
v->xyz[ 0 ] = LittleShort( mdcxyz->xyz[ 0 ] ) * MD3_XYZ_SCALE;
v->xyz[ 1 ] = LittleShort( mdcxyz->xyz[ 1 ] ) * MD3_XYZ_SCALE;
v->xyz[ 2 ] = LittleShort( mdcxyz->xyz[ 2 ] ) * MD3_XYZ_SCALE;
if ( mdcSurf->numCompFrames > 0 && compFrame >= 0 )
{
vec3_t ofsVec;
//vec3_t normal;
R_MDC_DecodeXyzCompressed2( LittleShort( mdcxyzComp->ofsVec ), ofsVec /*, normal*/ );
VectorAdd( v->xyz, ofsVec, v->xyz );
mdcxyzComp++;
}
}
}
// swap all the ST
surf->st = st = (mdvSt_t*) ri.Hunk_Alloc( sizeof( *st ) * mdcSurf->numVerts, h_low );
mdcst = ( md3St_t * )( ( byte * ) mdcSurf + mdcSurf->ofsSt );
for ( j = 0; j < mdcSurf->numVerts; j++, mdcst++, st++ )
{
st->st[ 0 ] = LittleFloat( mdcst->st[ 0 ] );
st->st[ 1 ] = LittleFloat( mdcst->st[ 1 ] );
}
// find the next surface
mdcSurf = ( mdcSurface_t * )( ( byte * ) mdcSurf + mdcSurf->ofsEnd );
surf++;
}
#if 1
// create VBO surfaces from md3 surfaces
{
growList_t vboSurfaces;
srfVBOMDVMesh_t *vboSurf;
vboData_t data;
int f;
Com_InitGrowList( &vboSurfaces, 10 );
for ( i = 0, surf = mdvModel->surfaces; i < mdvModel->numSurfaces; i++, surf++ )
{
//allocate temp memory for vertex data
memset( &data, 0, sizeof( data ) );
data.xyz = ( vec3_t * ) ri.Hunk_AllocateTempMemory( sizeof( *data.xyz ) * mdvModel->numFrames * surf->numVerts );
data.normal = ( vec3_t * ) ri.Hunk_AllocateTempMemory( sizeof( *data.normal ) * mdvModel->numFrames * surf->numVerts );
data.tangent = ( vec3_t * ) ri.Hunk_AllocateTempMemory( sizeof( *data.tangent ) * mdvModel->numFrames * surf->numVerts );
data.binormal = ( vec3_t * ) ri.Hunk_AllocateTempMemory( sizeof( *data.binormal ) * mdvModel->numFrames * surf->numVerts );
data.numFrames = mdvModel->numFrames;
data.st = ( vec2_t * ) ri.Hunk_AllocateTempMemory( sizeof( *data.st ) * surf->numVerts );
data.numVerts = surf->numVerts;
// feed vertex XYZ
for ( f = 0; f < mdvModel->numFrames; f++ )
{
for ( j = 0; j < surf->numVerts; j++ )
{
VectorCopy( surf->verts[ f * surf->numVerts + j ].xyz, data.xyz[ f * surf->numVerts + j ] );
}
}
// feed vertex texcoords
for ( j = 0; j < surf->numVerts; j++ )
{
data.st[ j ][ 0 ] = surf->st[ j ].st[ 0 ];
data.st[ j ][ 1 ] = surf->st[ j ].st[ 1 ];
}
// calc and feed tangent spaces
{
const float *v0, *v1, *v2;
const float *t0, *t1, *t2;
vec3_t tangent;
vec3_t binormal;
vec3_t normal;
for ( j = 0; j < ( surf->numVerts * mdvModel->numFrames ); j++ )
{
VectorClear( data.tangent[ j ] );
VectorClear( data.binormal[ j ] );
VectorClear( data.normal[ j ] );
}
for ( f = 0; f < mdvModel->numFrames; f++ )
{
for ( j = 0, tri = surf->triangles; j < surf->numTriangles; j++, tri++ )
{
v0 = surf->verts[ surf->numVerts * f + tri->indexes[ 0 ] ].xyz;
v1 = surf->verts[ surf->numVerts * f + tri->indexes[ 1 ] ].xyz;
v2 = surf->verts[ surf->numVerts * f + tri->indexes[ 2 ] ].xyz;
t0 = surf->st[ tri->indexes[ 0 ] ].st;
t1 = surf->st[ tri->indexes[ 1 ] ].st;
t2 = surf->st[ tri->indexes[ 2 ] ].st;
#if 1
R_CalcTangentSpace( tangent, binormal, normal, v0, v1, v2, t0, t1, t2 );
#else
R_CalcNormalForTriangle( normal, v0, v1, v2 );
R_CalcTangentsForTriangle( tangent, binormal, v0, v1, v2, t0, t1, t2 );
#endif
for ( k = 0; k < 3; k++ )
{
float *v;
v = data.tangent[ surf->numVerts * f + tri->indexes[ k ] ];
VectorAdd( v, tangent, v );
v = data.binormal[ surf->numVerts * f + tri->indexes[ k ] ];
VectorAdd( v, binormal, v );
v = data.normal[ surf->numVerts * f + tri->indexes[ k ] ];
VectorAdd( v, normal, v );
}
}
}
for ( j = 0; j < ( surf->numVerts * mdvModel->numFrames ); j++ )
{
VectorNormalize( data.tangent[ j ] );
VectorNormalize( data.binormal[ j ] );
VectorNormalize( data.normal[ j ] );
}
}
//ri.Printf(PRINT_ALL, "...calculating MD3 mesh VBOs ( '%s', %i verts %i tris )\n", surf->name, surf->numVerts, surf->numTriangles);
// create surface
vboSurf = (srfVBOMDVMesh_t*) ri.Hunk_Alloc( sizeof( *vboSurf ), h_low );
Com_AddToGrowList( &vboSurfaces, vboSurf );
vboSurf->surfaceType = SF_VBO_MDVMESH;
vboSurf->mdvModel = mdvModel;
vboSurf->mdvSurface = surf;
vboSurf->numIndexes = surf->numTriangles * 3;
vboSurf->numVerts = surf->numVerts;
vboSurf->ibo = R_CreateStaticIBO2( va( "staticMD3Mesh_IBO %s", surf->name ), surf->numTriangles, surf->triangles );
vboSurf->vbo = R_CreateStaticVBO( va( "staticMD3Mesh_VBO '%s'", surf->name ), data, VBO_LAYOUT_VERTEX_ANIMATION );
ri.Hunk_FreeTempMemory( data.st );
ri.Hunk_FreeTempMemory( data.binormal );
ri.Hunk_FreeTempMemory( data.tangent );
ri.Hunk_FreeTempMemory( data.normal );
ri.Hunk_FreeTempMemory( data.xyz );
}
// move VBO surfaces list to hunk
mdvModel->numVBOSurfaces = vboSurfaces.currentElements;
mdvModel->vboSurfaces = (srfVBOMDVMesh_t**) ri.Hunk_Alloc( mdvModel->numVBOSurfaces * sizeof( *mdvModel->vboSurfaces ), h_low );
for ( i = 0; i < mdvModel->numVBOSurfaces; i++ )
{
mdvModel->vboSurfaces[ i ] = ( srfVBOMDVMesh_t * ) Com_GrowListElement( &vboSurfaces, i );
}
Com_DestroyGrowList( &vboSurfaces );
}
#endif
return qtrue;
}
/*
============
R_CreateVBO
============
*/
VBO_t *R_CreateVBO(const char *name, byte *vertexes, int vertexesSize, vboUsage_t usage)
{
VBO_t *vbo;
int glUsage;
switch (usage)
{
case VBO_USAGE_STATIC:
glUsage = GL_STATIC_DRAW;
break;
case VBO_USAGE_DYNAMIC:
glUsage = GL_DYNAMIC_DRAW;
break;
default:
glUsage = 0; //Prevents warning
Com_Error(ERR_FATAL, "bad vboUsage_t given: %i", usage);
}
if (strlen(name) >= MAX_QPATH)
{
ri.Error(ERR_DROP, "R_CreateVBO: \"%s\" is too long\n", name);
}
// make sure the render thread is stopped
R_SyncRenderThread();
vbo = (VBO_t *)ri.Hunk_Alloc(sizeof(*vbo), h_low);
Com_AddToGrowList(&tr.vbos, vbo);
Q_strncpyz(vbo->name, name, sizeof(vbo->name));
vbo->ofsXYZ = 0;
vbo->ofsTexCoords = 0;
vbo->ofsLightCoords = 0;
vbo->ofsBinormals = 0;
vbo->ofsTangents = 0;
vbo->ofsNormals = 0;
vbo->ofsColors = 0;
vbo->ofsPaintColors = 0;
vbo->ofsLightDirections = 0;
vbo->ofsBoneIndexes = 0;
vbo->ofsBoneWeights = 0;
vbo->sizeXYZ = 0;
vbo->sizeTangents = 0;
vbo->sizeBinormals = 0;
vbo->sizeNormals = 0;
vbo->vertexesSize = vertexesSize;
glGenBuffers(1, &vbo->vertexesVBO);
glBindBuffer(GL_ARRAY_BUFFER, vbo->vertexesVBO);
glBufferData(GL_ARRAY_BUFFER, vertexesSize, vertexes, glUsage);
glBindBuffer(GL_ARRAY_BUFFER, 0);
GL_CheckErrors();
return vbo;
}
/**
* @brief R_LoadMDM
* @param[in,out] mod
* @param[in,out] buffer
* @param[in] name
* @return
*/
qboolean R_LoadMDM(model_t *mod, void *buffer, const char *name)
{
int i, j, k;
mdmHeader_t *mdm = ( mdmHeader_t * ) buffer;
// mdmFrame_t *frame;
mdmSurface_t *mdmSurf;
mdmTriangle_t *mdmTri;
mdmVertex_t *mdmVertex;
mdmTag_t *mdmTag;
int version;
// int size;
shader_t *sh;
int32_t *collapseMap, *collapseMapOut, *boneref, *bonerefOut;
mdmModel_t *mdmModel;
mdmTagIntern_t *tag;
mdmSurfaceIntern_t *surf;
srfTriangle_t *tri;
md5Vertex_t *v;
version = LittleLong(mdm->version);
if (version != MDM_VERSION)
{
Ren_Warning("R_LoadMDM: %s has wrong version (%i should be %i)\n", name, version, MDM_VERSION);
return qfalse;
}
mod->type = MOD_MDM;
//size = LittleLong(mdm->ofsEnd);
mod->dataSize += sizeof(mdmModel_t);
//mdm = mod->mdm = ri.Hunk_Alloc(size, h_low);
//Com_Memcpy(mdm, buffer, LittleLong(pinmodel->ofsEnd));
mdmModel = mod->mdm = ri.Hunk_Alloc(sizeof(mdmModel_t), h_low);
LL(mdm->ident);
LL(mdm->version);
//LL(mdm->numFrames);
LL(mdm->numTags);
LL(mdm->numSurfaces);
//LL(mdm->ofsFrames);
LL(mdm->ofsTags);
LL(mdm->ofsEnd);
LL(mdm->ofsSurfaces);
mdmModel->lodBias = LittleFloat(mdm->lodBias);
mdmModel->lodScale = LittleFloat(mdm->lodScale);
/* mdm->skel = RE_RegisterModel(mdm->bonesfile);
if (!mdm->skel) {
ri.Error(ERR_DROP, "R_LoadMDM: %s skeleton not found", mdm->bonesfile);
}
if ( mdm->numFrames < 1 ) {
ri.Printf( PRINT_WARNING, "R_LoadMDM: %s has no frames\n", modName );
return qfalse;
}*/
// swap all the frames
/*frameSize = (int) ( sizeof( mdmFrame_t ) );
for ( i = 0 ; i < mdm->numFrames ; i++, frame++) {
frame = (mdmFrame_t *) ( (byte *)mdm + mdm->ofsFrames + i * frameSize );
frame->radius = LittleFloat( frame->radius );
for ( j = 0 ; j < 3 ; j++ ) {
frame->bounds[0][j] = LittleFloat( frame->bounds[0][j] );
frame->bounds[1][j] = LittleFloat( frame->bounds[1][j] );
frame->localOrigin[j] = LittleFloat( frame->localOrigin[j] );
frame->parentOffset[j] = LittleFloat( frame->parentOffset[j] );
}
} */
// swap all the tags
mdmModel->numTags = mdm->numTags;
mdmModel->tags = tag = ri.Hunk_Alloc(sizeof(*tag) * mdm->numTags, h_low);
mdmTag = ( mdmTag_t * )(( byte * ) mdm + mdm->ofsTags);
for (i = 0; i < mdm->numTags; i++, tag++)
{
int ii;
Q_strncpyz(tag->name, mdmTag->name, sizeof(tag->name));
for (ii = 0; ii < 3; ii++)
{
tag->axis[ii][0] = LittleFloat(mdmTag->axis[ii][0]);
tag->axis[ii][1] = LittleFloat(mdmTag->axis[ii][1]);
tag->axis[ii][2] = LittleFloat(mdmTag->axis[ii][2]);
}
tag->boneIndex = LittleLong(mdmTag->boneIndex);
//tag->torsoWeight = LittleFloat( tag->torsoWeight );
tag->offset[0] = LittleFloat(mdmTag->offset[0]);
tag->offset[1] = LittleFloat(mdmTag->offset[1]);
tag->offset[2] = LittleFloat(mdmTag->offset[2]);
LL(mdmTag->numBoneReferences);
LL(mdmTag->ofsBoneReferences);
LL(mdmTag->ofsEnd);
tag->numBoneReferences = mdmTag->numBoneReferences;
tag->boneReferences = ri.Hunk_Alloc(sizeof(*bonerefOut) * mdmTag->numBoneReferences, h_low);
// swap the bone references
boneref = ( int32_t * )(( byte * ) mdmTag + mdmTag->ofsBoneReferences);
for (j = 0, bonerefOut = tag->boneReferences; j < mdmTag->numBoneReferences; j++, boneref++, bonerefOut++)
{
*bonerefOut = LittleLong(*boneref);
}
// find the next tag
mdmTag = ( mdmTag_t * )(( byte * ) mdmTag + mdmTag->ofsEnd);
}
// swap all the surfaces
mdmModel->numSurfaces = mdm->numSurfaces;
mdmModel->surfaces = ri.Hunk_Alloc(sizeof(*surf) * mdmModel->numSurfaces, h_low);
mdmSurf = ( mdmSurface_t * )(( byte * ) mdm + mdm->ofsSurfaces);
for (i = 0, surf = mdmModel->surfaces; i < mdm->numSurfaces; i++, surf++)
{
LL(mdmSurf->shaderIndex);
LL(mdmSurf->ofsHeader);
LL(mdmSurf->ofsCollapseMap);
LL(mdmSurf->numTriangles);
LL(mdmSurf->ofsTriangles);
LL(mdmSurf->numVerts);
LL(mdmSurf->ofsVerts);
LL(mdmSurf->numBoneReferences);
LL(mdmSurf->ofsBoneReferences);
LL(mdmSurf->ofsEnd);
surf->minLod = LittleLong(mdmSurf->minLod);
// change to surface identifier
surf->surfaceType = SF_MDM;
surf->model = mdmModel;
Q_strncpyz(surf->name, mdmSurf->name, sizeof(surf->name));
if (mdmSurf->numVerts > SHADER_MAX_VERTEXES)
{
Ren_Drop("R_LoadMDM: %s has more than %i verts on a surface (%i)",
name, SHADER_MAX_VERTEXES, mdmSurf->numVerts);
}
if (mdmSurf->numTriangles > SHADER_MAX_TRIANGLES)
{
Ren_Drop("R_LoadMDM: %s has more than %i triangles on a surface (%i)",
name, SHADER_MAX_TRIANGLES, mdmSurf->numTriangles);
}
// register the shaders
if (mdmSurf->shader[0])
{
Q_strncpyz(surf->shader, mdmSurf->shader, sizeof(surf->shader));
sh = R_FindShader(surf->shader, SHADER_3D_DYNAMIC, qtrue);
if (sh->defaultShader)
{
surf->shaderIndex = 0;
}
else
{
surf->shaderIndex = sh->index;
}
}
else
{
surf->shaderIndex = 0;
}
// swap all the triangles
surf->numTriangles = mdmSurf->numTriangles;
surf->triangles = ri.Hunk_Alloc(sizeof(*tri) * surf->numTriangles, h_low);
mdmTri = ( mdmTriangle_t * )(( byte * ) mdmSurf + mdmSurf->ofsTriangles);
for (j = 0, tri = surf->triangles; j < surf->numTriangles; j++, mdmTri++, tri++)
{
tri->indexes[0] = LittleLong(mdmTri->indexes[0]);
tri->indexes[1] = LittleLong(mdmTri->indexes[1]);
tri->indexes[2] = LittleLong(mdmTri->indexes[2]);
}
// swap all the vertexes
surf->numVerts = mdmSurf->numVerts;
surf->verts = ri.Hunk_Alloc(sizeof(*v) * surf->numVerts, h_low);
mdmVertex = ( mdmVertex_t * )(( byte * ) mdmSurf + mdmSurf->ofsVerts);
for (j = 0, v = surf->verts; j < mdmSurf->numVerts; j++, v++)
{
v->normal[0] = LittleFloat(mdmVertex->normal[0]);
v->normal[1] = LittleFloat(mdmVertex->normal[1]);
v->normal[2] = LittleFloat(mdmVertex->normal[2]);
v->texCoords[0] = LittleFloat(mdmVertex->texCoords[0]);
v->texCoords[1] = LittleFloat(mdmVertex->texCoords[1]);
v->numWeights = LittleLong(mdmVertex->numWeights);
if (v->numWeights > MAX_WEIGHTS)
{
#if 0
Ren_Drop("R_LoadMDM: vertex %i requires %i instead of maximum %i weights on surface (%i) in model '%s'",
j, v->numWeights, MAX_WEIGHTS, i, modName);
#else
Ren_Warning("WARNING: R_LoadMDM: vertex %i requires %i instead of maximum %i weights on surface (%i) in model '%s'\n",
j, v->numWeights, MAX_WEIGHTS, i, name);
#endif
}
v->weights = ri.Hunk_Alloc(sizeof(*v->weights) * v->numWeights, h_low);
for (k = 0; k < v->numWeights; k++)
{
md5Weight_t *weight = ri.Hunk_Alloc(sizeof(*weight), h_low);
weight->boneIndex = LittleLong(mdmVertex->weights[k].boneIndex);
weight->boneWeight = LittleFloat(mdmVertex->weights[k].boneWeight);
weight->offset[0] = LittleFloat(mdmVertex->weights[k].offset[0]);
weight->offset[1] = LittleFloat(mdmVertex->weights[k].offset[1]);
weight->offset[2] = LittleFloat(mdmVertex->weights[k].offset[2]);
v->weights[k] = weight;
}
mdmVertex = ( mdmVertex_t * ) &mdmVertex->weights[v->numWeights];
}
// swap the collapse map
surf->collapseMap = ri.Hunk_Alloc(sizeof(*collapseMapOut) * mdmSurf->numVerts, h_low);
collapseMap = ( int32_t * )(( byte * ) mdmSurf + mdmSurf->ofsCollapseMap);
//Ren_Print("collapse map for mdm surface '%s': ", surf->name);
for (j = 0, collapseMapOut = surf->collapseMap; j < mdmSurf->numVerts; j++, collapseMap++, collapseMapOut++)
{
int32_t value = LittleLong(*collapseMap);
//surf->collapseMap[j] = value;
*collapseMapOut = value;
//Ren_Print("(%i -> %i) ", j, value);
}
//Ren_Print("\n");
#if 0
Ren_Print("collapse map for mdm surface '%s': ", surf->name);
for (j = 0, collapseMap = surf->collapseMap; j < mdmSurf->numVerts; j++, collapseMap++)
{
Ren_Print("(%i -> %i) ", j, *collapseMap);
}
Ren_Print("\n");
#endif
// swap the bone references
surf->numBoneReferences = mdmSurf->numBoneReferences;
surf->boneReferences = ri.Hunk_Alloc(sizeof(*bonerefOut) * mdmSurf->numBoneReferences, h_low);
boneref = ( int32_t * )(( byte * ) mdmSurf + mdmSurf->ofsBoneReferences);
for (j = 0, bonerefOut = surf->boneReferences; j < surf->numBoneReferences; j++, boneref++, bonerefOut++)
{
*bonerefOut = LittleLong(*boneref);
}
// find the next surface
mdmSurf = ( mdmSurface_t * )(( byte * ) mdmSurf + mdmSurf->ofsEnd);
}
// loading is done now calculate the bounding box and tangent spaces
ClearBounds(mdmModel->bounds[0], mdmModel->bounds[1]);
for (i = 0, surf = mdmModel->surfaces; i < mdmModel->numSurfaces; i++, surf++)
{
for (j = 0, v = surf->verts; j < surf->numVerts; j++, v++)
{
vec3_t tmpVert;
md5Weight_t *w;
VectorClear(tmpVert);
for (k = 0, w = v->weights[0]; k < v->numWeights; k++, w++)
{
//vec3_t offsetVec;
//VectorClear(offsetVec);
//bone = &md5->bones[w->boneIndex];
//QuatTransformVector(bone->rotation, w->offset, offsetVec);
//VectorAdd(bone->origin, offsetVec, offsetVec);
VectorMA(tmpVert, w->boneWeight, w->offset, tmpVert);
}
VectorCopy(tmpVert, v->position);
AddPointToBounds(tmpVert, mdmModel->bounds[0], mdmModel->bounds[1]);
}
// calc tangent spaces
#if 0
{
const float *v0, *v1, *v2;
const float *t0, *t1, *t2;
vec3_t tangent;
vec3_t binormal;
vec3_t normal;
for (j = 0, v = surf->verts; j < surf->numVerts; j++, v++)
{
VectorClear(v->tangent);
VectorClear(v->binormal);
VectorClear(v->normal);
}
for (j = 0, tri = surf->triangles; j < surf->numTriangles; j++, tri++)
{
v0 = surf->verts[tri->indexes[0]].position;
v1 = surf->verts[tri->indexes[1]].position;
v2 = surf->verts[tri->indexes[2]].position;
t0 = surf->verts[tri->indexes[0]].texCoords;
t1 = surf->verts[tri->indexes[1]].texCoords;
t2 = surf->verts[tri->indexes[2]].texCoords;
#if 1
R_CalcTangentSpace(tangent, binormal, normal, v0, v1, v2, t0, t1, t2);
#else
R_CalcNormalForTriangle(normal, v0, v1, v2);
R_CalcTangentsForTriangle(tangent, binormal, v0, v1, v2, t0, t1, t2);
#endif
for (k = 0; k < 3; k++)
{
float *v;
v = surf->verts[tri->indexes[k]].tangent;
VectorAdd(v, tangent, v);
v = surf->verts[tri->indexes[k]].binormal;
VectorAdd(v, binormal, v);
v = surf->verts[tri->indexes[k]].normal;
VectorAdd(v, normal, v);
}
}
for (j = 0, v = surf->verts; j < surf->numVerts; j++, v++)
{
VectorNormalize(v->tangent);
VectorNormalize(v->binormal);
VectorNormalize(v->normal);
}
}
#else
{
int k;
float bb, s, t;
vec3_t bary;
vec3_t faceNormal;
md5Vertex_t *dv[3];
for (j = 0, tri = surf->triangles; j < surf->numTriangles; j++, tri++)
{
dv[0] = &surf->verts[tri->indexes[0]];
dv[1] = &surf->verts[tri->indexes[1]];
dv[2] = &surf->verts[tri->indexes[2]];
R_CalcNormalForTriangle(faceNormal, dv[0]->position, dv[1]->position, dv[2]->position);
// calculate barycentric basis for the triangle
bb = (dv[1]->texCoords[0] - dv[0]->texCoords[0]) * (dv[2]->texCoords[1] - dv[0]->texCoords[1]) - (dv[2]->texCoords[0] - dv[0]->texCoords[0]) * (dv[1]->texCoords[1] -
dv[0]->texCoords[1]);
if (Q_fabs(bb) < 0.00000001f)
{
continue;
}
// do each vertex
for (k = 0; k < 3; k++)
{
// calculate s tangent vector
s = dv[k]->texCoords[0] + 10.0f;
t = dv[k]->texCoords[1];
bary[0] = ((dv[1]->texCoords[0] - s) * (dv[2]->texCoords[1] - t) - (dv[2]->texCoords[0] - s) * (dv[1]->texCoords[1] - t)) / bb;
bary[1] = ((dv[2]->texCoords[0] - s) * (dv[0]->texCoords[1] - t) - (dv[0]->texCoords[0] - s) * (dv[2]->texCoords[1] - t)) / bb;
bary[2] = ((dv[0]->texCoords[0] - s) * (dv[1]->texCoords[1] - t) - (dv[1]->texCoords[0] - s) * (dv[0]->texCoords[1] - t)) / bb;
dv[k]->tangent[0] = bary[0] * dv[0]->position[0] + bary[1] * dv[1]->position[0] + bary[2] * dv[2]->position[0];
dv[k]->tangent[1] = bary[0] * dv[0]->position[1] + bary[1] * dv[1]->position[1] + bary[2] * dv[2]->position[1];
dv[k]->tangent[2] = bary[0] * dv[0]->position[2] + bary[1] * dv[1]->position[2] + bary[2] * dv[2]->position[2];
VectorSubtract(dv[k]->tangent, dv[k]->position, dv[k]->tangent);
VectorNormalize(dv[k]->tangent);
// calculate t tangent vector (binormal)
s = dv[k]->texCoords[0];
t = dv[k]->texCoords[1] + 10.0f;
bary[0] = ((dv[1]->texCoords[0] - s) * (dv[2]->texCoords[1] - t) - (dv[2]->texCoords[0] - s) * (dv[1]->texCoords[1] - t)) / bb;
bary[1] = ((dv[2]->texCoords[0] - s) * (dv[0]->texCoords[1] - t) - (dv[0]->texCoords[0] - s) * (dv[2]->texCoords[1] - t)) / bb;
bary[2] = ((dv[0]->texCoords[0] - s) * (dv[1]->texCoords[1] - t) - (dv[1]->texCoords[0] - s) * (dv[0]->texCoords[1] - t)) / bb;
dv[k]->binormal[0] = bary[0] * dv[0]->position[0] + bary[1] * dv[1]->position[0] + bary[2] * dv[2]->position[0];
dv[k]->binormal[1] = bary[0] * dv[0]->position[1] + bary[1] * dv[1]->position[1] + bary[2] * dv[2]->position[1];
dv[k]->binormal[2] = bary[0] * dv[0]->position[2] + bary[1] * dv[1]->position[2] + bary[2] * dv[2]->position[2];
VectorSubtract(dv[k]->binormal, dv[k]->position, dv[k]->binormal);
VectorNormalize(dv[k]->binormal);
// calculate the normal as cross product N=TxB
#if 0
CrossProduct(dv[k]->tangent, dv[k]->binormal, dv[k]->normal);
VectorNormalize(dv[k]->normal);
// Gram-Schmidt orthogonalization process for B
// compute the cross product B=NxT to obtain
// an orthogonal basis
CrossProduct(dv[k]->normal, dv[k]->tangent, dv[k]->binormal);
if (DotProduct(dv[k]->normal, faceNormal) < 0)
{
VectorInverse(dv[k]->normal);
//VectorInverse(dv[k]->tangent);
//VectorInverse(dv[k]->binormal);
}
#else
//VectorAdd(dv[k]->normal, faceNormal, dv[k]->normal);
#endif
}
}
#if 0
for (j = 0, v = surf->verts; j < surf->numVerts; j++, v++)
{
//VectorNormalize(v->tangent);
//VectorNormalize(v->binormal);
//VectorNormalize(v->normal);
}
#endif
}
#endif
if (r_smoothNormals->integer & FLAGS_SMOOTH_MDM) // do another extra smoothing for normals to avoid flat shading
{
for (j = 0; j < surf->numVerts; j++)
{
for (k = 0; k < surf->numVerts; k++)
{
if (j == k)
{
continue;
}
if (VectorCompare(surf->verts[j].position, surf->verts[k].position))
{
VectorAdd(surf->verts[j].normal, surf->verts[k].normal, surf->verts[j].normal);
}
}
VectorNormalize(surf->verts[j].normal);
}
}
}
// split the surfaces into VBO surfaces by the maximum number of GPU vertex skinning bones
{
int numRemaining;
growList_t sortedTriangles;
growList_t vboTriangles;
growList_t vboSurfaces;
int numBoneReferences;
int boneReferences[MAX_BONES];
Com_InitGrowList(&vboSurfaces, 32);
for (i = 0, surf = mdmModel->surfaces; i < mdmModel->numSurfaces; i++, surf++)
{
// sort triangles
Com_InitGrowList(&sortedTriangles, 1000);
for (j = 0, tri = surf->triangles; j < surf->numTriangles; j++, tri++)
{
skelTriangle_t *sortTri = Com_Allocate(sizeof(*sortTri));
for (k = 0; k < 3; k++)
{
sortTri->indexes[k] = tri->indexes[k];
sortTri->vertexes[k] = &surf->verts[tri->indexes[k]];
}
sortTri->referenced = qfalse;
Com_AddToGrowList(&sortedTriangles, sortTri);
}
//qsort(sortedTriangles.elements, sortedTriangles.currentElements, sizeof(void *), CompareTrianglesByBoneReferences);
#if 0
for (j = 0; j < sortedTriangles.currentElements; j++)
{
int b[MAX_WEIGHTS * 3];
skelTriangle_t *sortTri = Com_GrowListElement(&sortedTriangles, j);
for (k = 0; k < 3; k++)
{
v = sortTri->vertexes[k];
for (l = 0; l < MAX_WEIGHTS; l++)
{
b[k * 3 + l] = (l < v->numWeights) ? v->weights[l]->boneIndex : 9999;
}
qsort(b, MAX_WEIGHTS * 3, sizeof(int), CompareBoneIndices);
//Ren_Print("bone indices: %i %i %i %i\n", b[k * 3 + 0], b[k * 3 + 1], b[k * 3 + 2], b[k * 3 + 3]);
}
}
#endif
numRemaining = sortedTriangles.currentElements;
while (numRemaining)
{
numBoneReferences = 0;
Com_Memset(boneReferences, 0, sizeof(boneReferences));
Com_InitGrowList(&vboTriangles, 1000);
for (j = 0; j < sortedTriangles.currentElements; j++)
{
skelTriangle_t *sortTri = Com_GrowListElement(&sortedTriangles, j);
if (sortTri->referenced)
{
continue;
}
if (AddTriangleToVBOTriangleList(&vboTriangles, sortTri, &numBoneReferences, boneReferences))
{
sortTri->referenced = qtrue;
}
}
if (!vboTriangles.currentElements)
{
Ren_Warning("R_LoadMDM: could not add triangles to a remaining VBO surface for model '%s'\n", name);
break;
}
AddSurfaceToVBOSurfacesListMDM(&vboSurfaces, &vboTriangles, mdmModel, surf, i, numBoneReferences, boneReferences);
numRemaining -= vboTriangles.currentElements;
Com_DestroyGrowList(&vboTriangles);
}
for (j = 0; j < sortedTriangles.currentElements; j++)
{
skelTriangle_t *sortTri = Com_GrowListElement(&sortedTriangles, j);
Com_Dealloc(sortTri);
}
Com_DestroyGrowList(&sortedTriangles);
}
// move VBO surfaces list to hunk
mdmModel->numVBOSurfaces = vboSurfaces.currentElements;
mdmModel->vboSurfaces = ri.Hunk_Alloc(mdmModel->numVBOSurfaces * sizeof(*mdmModel->vboSurfaces), h_low);
for (i = 0; i < mdmModel->numVBOSurfaces; i++)
{
mdmModel->vboSurfaces[i] = ( srfVBOMDMMesh_t * ) Com_GrowListElement(&vboSurfaces, i);
}
Com_DestroyGrowList(&vboSurfaces);
}
return qtrue;
}
/*
============
R_CreateIBO2
============
*/
IBO_t *R_CreateIBO2(const char *name, int numTriangles, srfTriangle_t *triangles, vboUsage_t usage)
{
IBO_t *ibo;
int i, j;
byte *indexes;
int indexesSize;
int indexesOfs;
srfTriangle_t *tri;
glIndex_t index;
int glUsage;
switch (usage)
{
case VBO_USAGE_STATIC:
glUsage = GL_STATIC_DRAW;
break;
case VBO_USAGE_DYNAMIC:
glUsage = GL_DYNAMIC_DRAW;
break;
default:
glUsage = 0;
Com_Error(ERR_FATAL, "bad vboUsage_t given: %i", usage);
}
if (!numTriangles)
{
return NULL;
}
if (strlen(name) >= MAX_QPATH)
{
ri.Error(ERR_DROP, "R_CreateIBO2: \"%s\" is too long\n", name);
}
// make sure the render thread is stopped
R_SyncRenderThread();
ibo = (IBO_t *)ri.Hunk_Alloc(sizeof(*ibo), h_low);
Com_AddToGrowList(&tr.ibos, ibo);
Q_strncpyz(ibo->name, name, sizeof(ibo->name));
indexesSize = numTriangles * 3 * sizeof(glIndex_t);
indexes = (byte *)ri.Hunk_AllocateTempMemory(indexesSize);
indexesOfs = 0;
//ri.Printf(PRINT_ALL, "sizeof(glIndex_t) = %i\n", sizeof(glIndex_t));
for (i = 0, tri = triangles; i < numTriangles; i++, tri++)
{
for (j = 0; j < 3; j++)
{
index = tri->indexes[j];
memcpy(indexes + indexesOfs, &index, sizeof(glIndex_t));
indexesOfs += sizeof(glIndex_t);
}
}
ibo->indexesSize = indexesSize;
ibo->indexesNum = numTriangles * 3;
glGenBuffers(1, &ibo->indexesVBO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo->indexesVBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, indexesSize, indexes, glUsage);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
GL_CheckErrors();
ri.Hunk_FreeTempMemory(indexes);
return ibo;
}
/*
============
R_CreateVBO2
============
*/
VBO_t *R_CreateVBO2(const char *name, int numVertexes, srfVert_t *verts, unsigned int stateBits, vboUsage_t usage)
{
VBO_t *vbo;
int i, j;
byte *data;
int dataSize;
int dataOfs;
int glUsage;
switch (usage)
{
case VBO_USAGE_STATIC:
glUsage = GL_STATIC_DRAW;
break;
case VBO_USAGE_DYNAMIC:
glUsage = GL_DYNAMIC_DRAW;
break;
default:
glUsage = 0;
Com_Error(ERR_FATAL, "bad vboUsage_t given: %i", usage);
}
if (!numVertexes)
{
return NULL;
}
if (strlen(name) >= MAX_QPATH)
{
ri.Error(ERR_DROP, "R_CreateVBO2: \"%s\" is too long\n", name);
}
// make sure the render thread is stopped
R_SyncRenderThread();
vbo = (VBO_t *)ri.Hunk_Alloc(sizeof(*vbo), h_low);
Com_AddToGrowList(&tr.vbos, vbo);
Q_strncpyz(vbo->name, name, sizeof(vbo->name));
vbo->ofsXYZ = 0;
vbo->ofsTexCoords = 0;
vbo->ofsLightCoords = 0;
vbo->ofsBinormals = 0;
vbo->ofsTangents = 0;
vbo->ofsNormals = 0;
vbo->ofsColors = 0;
vbo->ofsPaintColors = 0;
vbo->ofsLightDirections = 0;
vbo->ofsBoneIndexes = 0;
vbo->ofsBoneWeights = 0;
vbo->sizeXYZ = 0;
vbo->sizeTangents = 0;
vbo->sizeBinormals = 0;
vbo->sizeNormals = 0;
// create VBO
dataSize = numVertexes * (sizeof(vec4_t) * 9);
data = (byte *)ri.Hunk_AllocateTempMemory(dataSize);
dataOfs = 0;
// since this is all float, point tmp directly into data
// 2-entry -> { memb[0], memb[1], 0, 1 }
// 3-entry -> { memb[0], memb[1], memb[2], 1 }
#define VERTEXSIZE(memb) (sizeof(verts->memb) / sizeof(verts->memb[0]))
#define VERTEXCOPY(memb) \
do { \
vec_t *tmp = (vec_t *) (data + dataOfs); \
for (i = 0; i < numVertexes; i++) \
{ \
for (j = 0; j < VERTEXSIZE(memb); j++) { *tmp++ = verts[i].memb[j]; } \
if (VERTEXSIZE(memb) < 3) { *tmp++ = 0; } \
if (VERTEXSIZE(memb) < 4) { *tmp++ = 1; } \
} \
dataOfs += i * sizeof(vec4_t); \
} while (0)
// set up xyz array
VERTEXCOPY(xyz);
// feed vertex texcoords
if (stateBits & ATTR_TEXCOORD)
{
vbo->ofsTexCoords = dataOfs;
VERTEXCOPY(st);
}
// feed vertex lightmap texcoords
if (stateBits & ATTR_LIGHTCOORD)
{
vbo->ofsLightCoords = dataOfs;
VERTEXCOPY(lightmap);
}
// feed vertex tangents
if (stateBits & ATTR_TANGENT)
{
vbo->ofsTangents = dataOfs;
VERTEXCOPY(tangent);
}
// feed vertex binormals
if (stateBits & ATTR_BINORMAL)
{
vbo->ofsBinormals = dataOfs;
VERTEXCOPY(binormal);
}
// feed vertex normals
if (stateBits & ATTR_NORMAL)
{
vbo->ofsNormals = dataOfs;
VERTEXCOPY(normal);
}
// feed vertex colors
if (stateBits & ATTR_COLOR)
{
vbo->ofsColors = dataOfs;
VERTEXCOPY(lightColor);
}
vbo->vertexesSize = dataSize;
vbo->vertexesNum = numVertexes;
glGenBuffers(1, &vbo->vertexesVBO);
glBindBuffer(GL_ARRAY_BUFFER, vbo->vertexesVBO);
glBufferData(GL_ARRAY_BUFFER, dataSize, data, glUsage);
glBindBuffer(GL_ARRAY_BUFFER, 0);
GL_CheckErrors();
ri.Hunk_FreeTempMemory(data);
return vbo;
}
static qboolean R_LoadPSA( skelAnimation_t *skelAnim, void *buffer, int bufferSize, const char *name )
{
int i, j, k;
memStream_t *stream;
axChunkHeader_t chunkHeader;
int numReferenceBones;
axReferenceBone_t *refBone;
axReferenceBone_t *refBones;
int numSequences;
axAnimationInfo_t *animInfo;
axAnimationKey_t *key;
psaAnimation_t *psa;
skelAnimation_t *extraAnim;
growList_t extraAnims;
stream = AllocMemStream( buffer, bufferSize );
GetChunkHeader( stream, &chunkHeader );
// check indent again
if ( Q_stricmpn( chunkHeader.ident, "ANIMHEAD", 8 ) )
{
ri.Printf( PRINT_WARNING, "R_LoadPSA: '%s' has wrong chunk indent ('%s' should be '%s')\n", name, chunkHeader.ident, "ANIMHEAD" );
FreeMemStream( stream );
return qfalse;
}
PrintChunkHeader( &chunkHeader );
// read reference bones
GetChunkHeader( stream, &chunkHeader );
if ( Q_stricmpn( chunkHeader.ident, "BONENAMES", 9 ) )
{
ri.Printf( PRINT_WARNING, "R_LoadPSA: '%s' has wrong chunk indent ('%s' should be '%s')\n", name, chunkHeader.ident, "BONENAMES" );
FreeMemStream( stream );
return qfalse;
}
if ( chunkHeader.dataSize != sizeof( axReferenceBone_t ) )
{
ri.Printf( PRINT_WARNING, "R_LoadPSA: '%s' has wrong chunk dataSize ('%i' should be '%i')\n", name, chunkHeader.dataSize, ( int ) sizeof( axReferenceBone_t ) );
FreeMemStream( stream );
return qfalse;
}
PrintChunkHeader( &chunkHeader );
numReferenceBones = chunkHeader.numData;
if ( numReferenceBones < 1 )
{
ri.Printf( PRINT_WARNING, "R_LoadPSA: '%s' has no bones\n", name );
FreeMemStream( stream );
return qfalse;
}
if ( numReferenceBones > MAX_BONES )
{
ri.Printf( PRINT_WARNING, "R_LoadPSA: '%s' has more than %i bones (%i)\n", name, MAX_BONES, numReferenceBones );
FreeMemStream( stream );
return qfalse;
}
refBones = ri.Hunk_Alloc( numReferenceBones * sizeof( axReferenceBone_t ), h_low );
for ( i = 0, refBone = refBones; i < numReferenceBones; i++, refBone++ )
{
MemStreamRead( stream, refBone->name, sizeof( refBone->name ) );
refBone->flags = MemStreamGetLong( stream );
refBone->numChildren = MemStreamGetLong( stream );
refBone->parentIndex = MemStreamGetLong( stream );
if ( i == 0 )
{
refBone->parentIndex = -1;
}
GetBone( stream, &refBone->bone );
#if 0
ri.Printf( PRINT_ALL, "R_LoadPSA: axReferenceBone_t(%i):\n"
"axReferenceBone_t::name: '%s'\n"
"axReferenceBone_t::flags: %i\n"
"axReferenceBone_t::numChildren %i\n"
"axReferenceBone_t::parentIndex: %i\n"
"axReferenceBone_t::quat: %f %f %f %f\n"
"axReferenceBone_t::position: %f %f %f\n"
"axReferenceBone_t::length: %f\n"
"axReferenceBone_t::xSize: %f\n"
"axReferenceBone_t::ySize: %f\n"
"axReferenceBone_t::zSize: %f\n",
i,
refBone->name,
refBone->flags,
refBone->numChildren,
refBone->parentIndex,
refBone->bone.quat[ 0 ], refBone->bone.quat[ 1 ], refBone->bone.quat[ 2 ], refBone->bone.quat[ 3 ],
refBone->bone.position[ 0 ], refBone->bone.position[ 1 ], refBone->bone.position[ 2 ],
refBone->bone.length,
refBone->bone.xSize,
refBone->bone.ySize,
refBone->bone.zSize );
#endif
}
// load animation info
GetChunkHeader( stream, &chunkHeader );
if ( Q_stricmpn( chunkHeader.ident, "ANIMINFO", 8 ) )
{
ri.Printf( PRINT_WARNING, "R_LoadPSA: '%s' has wrong chunk indent ('%s' should be '%s')\n", name, chunkHeader.ident, "ANIMINFO" );
FreeMemStream( stream );
return qfalse;
}
if ( chunkHeader.dataSize != sizeof( axAnimationInfo_t ) )
{
ri.Printf( PRINT_WARNING, "R_LoadPSA: '%s' has wrong chunk dataSize ('%i' should be '%i')\n", name, chunkHeader.dataSize, ( int ) sizeof( axAnimationInfo_t ) );
FreeMemStream( stream );
return qfalse;
}
PrintChunkHeader( &chunkHeader );
numSequences = chunkHeader.numData;
Com_InitGrowList( &extraAnims, numSequences - 1 );
for ( i = 0; i < numSequences; i++ )
{
if ( i == 0 )
{
Q_strncpyz( skelAnim->name, name, sizeof( skelAnim->name ) );
skelAnim->type = AT_PSA;
skelAnim->psa = psa = ri.Hunk_Alloc( sizeof( *psa ), h_low );
}
else
{
// allocate a new skelAnimation_t
if ( ( extraAnim = R_AllocAnimation() ) == NULL )
{
ri.Printf( PRINT_WARNING, "R_LoadPSA: R_AllocAnimation() failed for '%s'\n", name );
FreeMemStream( stream );
Com_DestroyGrowList( &extraAnims );
return qfalse;
}
Q_strncpyz( extraAnim->name, name, sizeof( extraAnim->name ) );
extraAnim->type = AT_PSA;
extraAnim->psa = psa = ri.Hunk_Alloc( sizeof( *psa ), h_low );
Com_AddToGrowList( &extraAnims, extraAnim );
}
psa->numBones = numReferenceBones;
psa->bones = refBones;
animInfo = &psa->info;
MemStreamRead( stream, animInfo->name, sizeof( animInfo->name ) );
MemStreamRead( stream, animInfo->group, sizeof( animInfo->group ) );
animInfo->numBones = MemStreamGetLong( stream );
if ( animInfo->numBones != numReferenceBones )
{
FreeMemStream( stream );
Com_DestroyGrowList( &extraAnims );
ri.Error( ERR_DROP, "R_LoadPSA: axAnimationInfo_t contains different number than reference bones exist: %i != %i for anim '%s'", animInfo->numBones, numReferenceBones, name );
}
animInfo->rootInclude = MemStreamGetLong( stream );
animInfo->keyCompressionStyle = MemStreamGetLong( stream );
animInfo->keyQuotum = MemStreamGetLong( stream );
animInfo->keyReduction = MemStreamGetFloat( stream );
animInfo->trackTime = MemStreamGetFloat( stream );
animInfo->frameRate = MemStreamGetFloat( stream );
animInfo->startBoneIndex = MemStreamGetLong( stream );
animInfo->firstRawFrame = MemStreamGetLong( stream );
animInfo->numRawFrames = MemStreamGetLong( stream );
#if 0
ri.Printf( PRINT_ALL, "R_LoadPSA: axAnimationInfo_t(%i):\n"
"axAnimationInfo_t::name: '%s'\n"
"axAnimationInfo_t::group: '%s'\n"
"axAnimationInfo_t::numBones: %i\n"
"axAnimationInfo_t::rootInclude: %i\n"
"axAnimationInfo_t::keyCompressionStyle: %i\n"
"axAnimationInfo_t::keyQuotum: %i\n"
"axAnimationInfo_t::keyReduction: %f\n"
"axAnimationInfo_t::trackTime: %f\n"
"axAnimationInfo_t::frameRate: %f\n"
"axAnimationInfo_t::startBoneIndex: %i\n"
"axAnimationInfo_t::firstRawFrame: %i\n"
"axAnimationInfo_t::numRawFrames: %i\n",
i,
animInfo->name,
animInfo->group,
animInfo->numBones,
animInfo->rootInclude,
animInfo->keyCompressionStyle,
animInfo->keyQuotum,
animInfo->keyReduction,
animInfo->trackTime,
animInfo->frameRate,
animInfo->startBoneIndex,
animInfo->firstRawFrame,
animInfo->numRawFrames );
#endif
}
// load the animation frame keys
GetChunkHeader( stream, &chunkHeader );
if ( Q_stricmpn( chunkHeader.ident, "ANIMKEYS", 8 ) )
{
ri.Printf( PRINT_WARNING, "R_LoadPSA: '%s' has wrong chunk indent ('%s' should be '%s')\n", name, chunkHeader.ident, "ANIMKEYS" );
FreeMemStream( stream );
Com_DestroyGrowList( &extraAnims );
return qfalse;
}
if ( chunkHeader.dataSize != sizeof( axAnimationKey_t ) )
{
ri.Printf( PRINT_WARNING, "R_LoadPSA: '%s' has wrong chunk dataSize ('%i' should be '%i')\n", name, chunkHeader.dataSize, ( int ) sizeof( axAnimationKey_t ) );
FreeMemStream( stream );
Com_DestroyGrowList( &extraAnims );
return qfalse;
}
PrintChunkHeader( &chunkHeader );
for ( i = 0; i < numSequences; i++ )
{
if ( i == 0 )
{
psa = skelAnim->psa;
}
else
{
extraAnim = Com_GrowListElement( &extraAnims, i - 1 );
psa = extraAnim->psa;
}
psa->numKeys = psa->info.numBones * psa->info.numRawFrames;
psa->keys = ri.Hunk_Alloc( psa->numKeys * sizeof( axAnimationKey_t ), h_low );
for ( j = 0, key = &psa->keys[ 0 ]; j < psa->numKeys; j++, key++ )
{
for ( k = 0; k < 3; k++ )
{
key->position[ k ] = MemStreamGetFloat( stream );
}
// Tr3B: see R_LoadPSK ...
if ( ( j % psa->info.numBones ) == 0 )
{
key->quat[ 0 ] = MemStreamGetFloat( stream );
key->quat[ 1 ] = -MemStreamGetFloat( stream );
key->quat[ 2 ] = MemStreamGetFloat( stream );
key->quat[ 3 ] = MemStreamGetFloat( stream );
}
else
{
key->quat[ 0 ] = -MemStreamGetFloat( stream );
key->quat[ 1 ] = -MemStreamGetFloat( stream );
key->quat[ 2 ] = -MemStreamGetFloat( stream );
key->quat[ 3 ] = MemStreamGetFloat( stream );
}
key->time = MemStreamGetFloat( stream );
}
}
Com_DestroyGrowList( &extraAnims );
FreeMemStream( stream );
return qtrue;
}
/*
============
R_CreateVBO2
RB: OPTIMIZE rewrite to not use memcpy
============
*/
VBO_t *R_CreateVBO2(const char *name, int numVertexes, srfVert_t * verts, unsigned int stateBits, vboUsage_t usage)
{
VBO_t *vbo;
int i, j;
byte *data;
int dataSize;
int dataOfs;
vec4_t tmp;
int glUsage;
switch (usage)
{
case VBO_USAGE_STATIC:
glUsage = GL_STATIC_DRAW_ARB;
break;
case VBO_USAGE_DYNAMIC:
glUsage = GL_DYNAMIC_DRAW_ARB;
break;
default:
Com_Error(ERR_FATAL, "bad vboUsage_t given: %i", usage);
}
if(!numVertexes)
return NULL;
if(strlen(name) >= MAX_QPATH)
{
ri.Error(ERR_DROP, "R_CreateVBO2: \"%s\" is too long\n", name);
}
// make sure the render thread is stopped
R_SyncRenderThread();
vbo = ri.Hunk_Alloc(sizeof(*vbo), h_low);
Com_AddToGrowList(&tr.vbos, vbo);
Q_strncpyz(vbo->name, name, sizeof(vbo->name));
vbo->ofsXYZ = 0;
vbo->ofsTexCoords = 0;
vbo->ofsLightCoords = 0;
vbo->ofsBinormals = 0;
vbo->ofsTangents = 0;
vbo->ofsNormals = 0;
vbo->ofsColors = 0;
vbo->ofsPaintColors = 0;
vbo->ofsLightDirections = 0;
vbo->ofsBoneIndexes = 0;
vbo->ofsBoneWeights = 0;
vbo->sizeXYZ = 0;
vbo->sizeTangents = 0;
vbo->sizeBinormals = 0;
vbo->sizeNormals = 0;
// create VBO
dataSize = numVertexes * (sizeof(vec4_t) * 9);
data = ri.Hunk_AllocateTempMemory(dataSize);
dataOfs = 0;
// set up xyz array
for(i = 0; i < numVertexes; i++)
{
for(j = 0; j < 3; j++)
{
tmp[j] = verts[i].xyz[j];
}
tmp[3] = 1;
memcpy(data + dataOfs, (vec_t *) tmp, sizeof(vec4_t));
dataOfs += sizeof(vec4_t);
}
// feed vertex texcoords
if(stateBits & ATTR_TEXCOORD)
{
vbo->ofsTexCoords = dataOfs;
for(i = 0; i < numVertexes; i++)
{
for(j = 0; j < 2; j++)
{
tmp[j] = verts[i].st[j];
}
tmp[2] = 0;
tmp[3] = 1;
memcpy(data + dataOfs, (vec_t *) tmp, sizeof(vec4_t));
dataOfs += sizeof(vec4_t);
}
}
// feed vertex lightmap texcoords
if(stateBits & ATTR_LIGHTCOORD)
{
vbo->ofsLightCoords = dataOfs;
for(i = 0; i < numVertexes; i++)
{
for(j = 0; j < 2; j++)
{
tmp[j] = verts[i].lightmap[j];
}
tmp[2] = 0;
tmp[3] = 1;
memcpy(data + dataOfs, (vec_t *) tmp, sizeof(vec4_t));
dataOfs += sizeof(vec4_t);
}
}
// feed vertex tangents
if(stateBits & ATTR_TANGENT)
{
vbo->ofsTangents = dataOfs;
for(i = 0; i < numVertexes; i++)
{
for(j = 0; j < 3; j++)
{
tmp[j] = verts[i].tangent[j];
}
tmp[3] = 1;
memcpy(data + dataOfs, (vec_t *) tmp, sizeof(vec4_t));
dataOfs += sizeof(vec4_t);
}
}
// feed vertex binormals
if(stateBits & ATTR_BINORMAL)
{
vbo->ofsBinormals = dataOfs;
for(i = 0; i < numVertexes; i++)
{
for(j = 0; j < 3; j++)
{
tmp[j] = verts[i].binormal[j];
}
tmp[3] = 1;
memcpy(data + dataOfs, (vec_t *) tmp, sizeof(vec4_t));
dataOfs += sizeof(vec4_t);
}
}
// feed vertex normals
if(stateBits & ATTR_NORMAL)
{
vbo->ofsNormals = dataOfs;
for(i = 0; i < numVertexes; i++)
{
for(j = 0; j < 3; j++)
{
tmp[j] = verts[i].normal[j];
}
tmp[3] = 1;
memcpy(data + dataOfs, (vec_t *) tmp, sizeof(vec4_t));
dataOfs += sizeof(vec4_t);
}
}
// feed vertex colors
if(stateBits & ATTR_COLOR)
{
vbo->ofsColors = dataOfs;
for(i = 0; i < numVertexes; i++)
{
for(j = 0; j < 4; j++)
{
tmp[j] = verts[i].lightColor[j];
}
memcpy(data + dataOfs, (vec_t *) tmp, sizeof(vec4_t));
dataOfs += sizeof(vec4_t);
}
}
#if !defined(COMPAT_Q3A) && !defined(COMPAT_ET)
// feed vertex paint colors
if(stateBits & ATTR_PAINTCOLOR)
{
vbo->ofsPaintColors = dataOfs;
for(i = 0; i < numVertexes; i++)
{
for(j = 0; j < 4; j++)
{
tmp[j] = verts[i].paintColor[j];
}
memcpy(data + dataOfs, (vec_t *) tmp, sizeof(vec4_t));
dataOfs += sizeof(vec4_t);
}
}
// feed vertex light directions
if(stateBits & ATTR_LIGHTDIRECTION)
{
vbo->ofsLightDirections = dataOfs;
for(i = 0; i < numVertexes; i++)
{
for(j = 0; j < 3; j++)
{
tmp[j] = verts[i].lightDirection[j];
}
tmp[3] = 1;
memcpy(data + dataOfs, (vec_t *) tmp, sizeof(vec4_t));
dataOfs += sizeof(vec4_t);
}
}
#endif
vbo->vertexesSize = dataSize;
vbo->vertexesNum = numVertexes;
glGenBuffersARB(1, &vbo->vertexesVBO);
glBindBufferARB(GL_ARRAY_BUFFER_ARB, vbo->vertexesVBO);
glBufferDataARB(GL_ARRAY_BUFFER_ARB, dataSize, data, glUsage);
glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
GL_CheckErrors();
ri.Hunk_FreeTempMemory(data);
return vbo;
}
/*
=================
R_LoadPSK
=================
*/
qboolean R_LoadPSK(model_t * mod, byte *buffer, int bufferSize, const char *modName)
{
int i, j, k;
memStream_t *stream;
axChunkHeader_t chunkHeader;
int numPoints;
axPoint_t *point;
axPoint_t *points;
int numVertexes;
axVertex_t *vertex;
axVertex_t *vertexes;
//int numSmoothGroups;
int numTriangles;
axTriangle_t *triangle;
axTriangle_t *triangles;
int numMaterials;
axMaterial_t *material;
axMaterial_t *materials;
int numReferenceBones;
axReferenceBone_t *refBone;
axReferenceBone_t *refBones;
int numWeights;
axBoneWeight_t *axWeight;
axBoneWeight_t *axWeights;
md5Model_t *md5;
md5Bone_t *md5Bone;
md5Weight_t *weight;
vec3_t boneOrigin;
quat_t boneQuat;
//matrix_t boneMat;
int materialIndex, oldMaterialIndex;
int numRemaining;
growList_t sortedTriangles;
growList_t vboVertexes;
growList_t vboTriangles;
growList_t vboSurfaces;
int numBoneReferences;
int boneReferences[MAX_BONES];
matrix_t unrealToQuake;
//MatrixSetupScale(unrealToQuake, 1, -1, 1);
MatrixFromAngles(unrealToQuake, 0, 90, 0);
stream = AllocMemStream(buffer, bufferSize);
GetChunkHeader(stream, &chunkHeader);
// check indent again
if(Q_stricmpn(chunkHeader.ident, "ACTRHEAD", 8))
{
ri.Printf(PRINT_WARNING, "R_LoadPSK: '%s' has wrong chunk indent ('%s' should be '%s')\n", modName, chunkHeader.ident, "ACTRHEAD");
FreeMemStream(stream);
return qfalse;
}
PrintChunkHeader(&chunkHeader);
mod->type = MOD_MD5;
mod->dataSize += sizeof(md5Model_t);
md5 = mod->md5 = (md5Model_t*)ri.Hunk_Alloc(sizeof(md5Model_t), h_low);
// read points
GetChunkHeader(stream, &chunkHeader);
if(Q_stricmpn(chunkHeader.ident, "PNTS0000", 8))
{
ri.Printf(PRINT_WARNING, "R_LoadPSK: '%s' has wrong chunk indent ('%s' should be '%s')\n", modName, chunkHeader.ident, "PNTS0000");
FreeMemStream(stream);
return qfalse;
}
if(chunkHeader.dataSize != sizeof(axPoint_t))
{
ri.Printf(PRINT_WARNING, "R_LoadPSK: '%s' has wrong chunk dataSize ('%i' should be '%i')\n", modName, chunkHeader.dataSize, sizeof(axPoint_t));
FreeMemStream(stream);
return qfalse;
}
PrintChunkHeader(&chunkHeader);
numPoints = chunkHeader.numData;
points = (axPoint_t*)Com_Allocate(numPoints * sizeof(axPoint_t));
for(i = 0, point = points; i < numPoints; i++, point++)
{
point->point[0] = MemStreamGetFloat(stream);
point->point[1] = MemStreamGetFloat(stream);
point->point[2] = MemStreamGetFloat(stream);
#if 0
// Tr3B: HACK convert from Unreal coordinate system to the Quake one
MatrixTransformPoint2(unrealToQuake, point->point);
#endif
}
// read vertices
GetChunkHeader(stream, &chunkHeader);
if(Q_stricmpn(chunkHeader.ident, "VTXW0000", 8))
{
ri.Printf(PRINT_WARNING, "R_LoadPSK: '%s' has wrong chunk indent ('%s' should be '%s')\n", modName, chunkHeader.ident, "VTXW0000");
FreeMemStream(stream);
Com_Dealloc(points);
return qfalse;
}
if(chunkHeader.dataSize != sizeof(axVertex_t))
{
ri.Printf(PRINT_WARNING, "R_LoadPSK: '%s' has wrong chunk dataSize ('%i' should be '%i')\n", modName, chunkHeader.dataSize, sizeof(axVertex_t));
FreeMemStream(stream);
Com_Dealloc(points);
return qfalse;
}
PrintChunkHeader(&chunkHeader);
numVertexes = chunkHeader.numData;
vertexes = (axVertex_t*)Com_Allocate(numVertexes * sizeof(axVertex_t));
for(i = 0, vertex = vertexes; i < numVertexes; i++, vertex++)
{
vertex->pointIndex = MemStreamGetShort(stream);
if(vertex->pointIndex < 0 || vertex->pointIndex >= numPoints)
{
ri.Printf(PRINT_WARNING, "R_LoadPSK: '%s' has vertex with point index out of range (%i while max %i)\n", modName, vertex->pointIndex, numPoints);
FreeMemStream(stream);
Com_Dealloc(points);
Com_Dealloc(vertexes);
return qfalse;
}
vertex->unknownA = MemStreamGetShort(stream);
vertex->st[0] = MemStreamGetFloat(stream);
vertex->st[1] = MemStreamGetFloat(stream);
vertex->materialIndex = MemStreamGetC(stream);
vertex->reserved = MemStreamGetC(stream);
vertex->unknownB = MemStreamGetShort(stream);
#if 0
ri.Printf(PRINT_ALL, "R_LoadPSK: axVertex_t(%i):\n"
"axVertex:pointIndex: %i\n"
"axVertex:unknownA: %i\n"
"axVertex::st: %f %f\n"
"axVertex:materialIndex: %i\n"
"axVertex:reserved: %d\n"
"axVertex:unknownB: %d\n",
i,
vertex->pointIndex,
vertex->unknownA,
vertex->st[0], vertex->st[1],
vertex->materialIndex,
vertex->reserved,
vertex->unknownB);
#endif
}
// read triangles
GetChunkHeader(stream, &chunkHeader);
if(Q_stricmpn(chunkHeader.ident, "FACE0000", 8))
{
ri.Printf(PRINT_WARNING, "R_LoadPSK: '%s' has wrong chunk indent ('%s' should be '%s')\n", modName, chunkHeader.ident, "FACE0000");
FreeMemStream(stream);
Com_Dealloc(points);
Com_Dealloc(vertexes);
return qfalse;
}
if(chunkHeader.dataSize != sizeof(axTriangle_t))
{
ri.Printf(PRINT_WARNING, "R_LoadPSK: '%s' has wrong chunk dataSize ('%i' should be '%i')\n", modName, chunkHeader.dataSize, sizeof(axTriangle_t));
FreeMemStream(stream);
Com_Dealloc(points);
Com_Dealloc(vertexes);
return qfalse;
}
PrintChunkHeader(&chunkHeader);
numTriangles = chunkHeader.numData;
triangles = (axTriangle_t*)Com_Allocate(numTriangles * sizeof(axTriangle_t));
for(i = 0, triangle = triangles; i < numTriangles; i++, triangle++)
{
for(j = 0; j < 3; j++)
//for(j = 2; j >= 0; j--)
{
triangle->indexes[j] = MemStreamGetShort(stream);
if(triangle->indexes[j] < 0 || triangle->indexes[j] >= numVertexes)
{
ri.Printf(PRINT_WARNING, "R_LoadPSK: '%s' has triangle with vertex index out of range (%i while max %i)\n", modName, triangle->indexes[j], numVertexes);
FreeMemStream(stream);
Com_Dealloc(points);
Com_Dealloc(vertexes);
Com_Dealloc(triangles);
return qfalse;
}
}
triangle->materialIndex = MemStreamGetC(stream);
triangle->materialIndex2 = MemStreamGetC(stream);
triangle->smoothingGroups = MemStreamGetLong(stream);
}
// read materials
GetChunkHeader(stream, &chunkHeader);
if(Q_stricmpn(chunkHeader.ident, "MATT0000", 8))
{
ri.Printf(PRINT_WARNING, "R_LoadPSK: '%s' has wrong chunk indent ('%s' should be '%s')\n", modName, chunkHeader.ident, "MATT0000");
FreeMemStream(stream);
Com_Dealloc(points);
Com_Dealloc(vertexes);
Com_Dealloc(triangles);
return qfalse;
}
if(chunkHeader.dataSize != sizeof(axMaterial_t))
{
ri.Printf(PRINT_WARNING, "R_LoadPSK: '%s' has wrong chunk dataSize ('%i' should be '%i')\n", modName, chunkHeader.dataSize, sizeof(axMaterial_t));
FreeMemStream(stream);
Com_Dealloc(points);
Com_Dealloc(vertexes);
Com_Dealloc(triangles);
return qfalse;
}
PrintChunkHeader(&chunkHeader);
numMaterials = chunkHeader.numData;
materials = (axMaterial_t*)Com_Allocate(numMaterials * sizeof(axMaterial_t));
for(i = 0, material = materials; i < numMaterials; i++, material++)
{
MemStreamRead(stream, material->name, sizeof(material->name));
ri.Printf(PRINT_ALL, "R_LoadPSK: material name: '%s'\n", material->name);
material->shaderIndex = MemStreamGetLong(stream);
material->polyFlags = MemStreamGetLong(stream);
material->auxMaterial = MemStreamGetLong(stream);
material->auxFlags = MemStreamGetLong(stream);
material->lodBias = MemStreamGetLong(stream);
material->lodStyle = MemStreamGetLong(stream);
}
for(i = 0, vertex = vertexes; i < numVertexes; i++, vertex++)
{
if(vertex->materialIndex < 0 || vertex->materialIndex >= numMaterials)
{
ri.Printf(PRINT_WARNING, "R_LoadPSK: '%s' has vertex with material index out of range (%i while max %i)\n", modName, vertex->materialIndex, numMaterials);
FreeMemStream(stream);
Com_Dealloc(points);
Com_Dealloc(vertexes);
Com_Dealloc(triangles);
Com_Dealloc(materials);
return qfalse;
}
}
for(i = 0, triangle = triangles; i < numTriangles; i++, triangle++)
{
if(triangle->materialIndex < 0 || triangle->materialIndex >= numMaterials)
{
ri.Printf(PRINT_WARNING, "R_LoadPSK: '%s' has triangle with material index out of range (%i while max %i)\n", modName, triangle->materialIndex, numMaterials);
FreeMemStream(stream);
Com_Dealloc(points);
Com_Dealloc(vertexes);
Com_Dealloc(triangles);
Com_Dealloc(materials);
return qfalse;
}
}
// read reference bones
GetChunkHeader(stream, &chunkHeader);
if(Q_stricmpn(chunkHeader.ident, "REFSKELT", 8))
{
ri.Printf(PRINT_WARNING, "R_LoadPSK: '%s' has wrong chunk indent ('%s' should be '%s')\n", modName, chunkHeader.ident, "REFSKELT");
FreeMemStream(stream);
Com_Dealloc(points);
Com_Dealloc(vertexes);
Com_Dealloc(triangles);
Com_Dealloc(materials);
return qfalse;
}
if(chunkHeader.dataSize != sizeof(axReferenceBone_t))
{
ri.Printf(PRINT_WARNING, "R_LoadPSK: '%s' has wrong chunk dataSize ('%i' should be '%i')\n", modName, chunkHeader.dataSize, sizeof(axReferenceBone_t));
FreeMemStream(stream);
Com_Dealloc(points);
Com_Dealloc(vertexes);
Com_Dealloc(triangles);
Com_Dealloc(materials);
return qfalse;
}
PrintChunkHeader(&chunkHeader);
numReferenceBones = chunkHeader.numData;
refBones = (axReferenceBone_t*)Com_Allocate(numReferenceBones * sizeof(axReferenceBone_t));
for(i = 0, refBone = refBones; i < numReferenceBones; i++, refBone++)
{
MemStreamRead(stream, refBone->name, sizeof(refBone->name));
//ri.Printf(PRINT_ALL, "R_LoadPSK: reference bone name: '%s'\n", refBone->name);
refBone->flags = MemStreamGetLong(stream);
refBone->numChildren = MemStreamGetLong(stream);
refBone->parentIndex = MemStreamGetLong(stream);
GetBone(stream, &refBone->bone);
#if 0
ri.Printf(PRINT_ALL, "R_LoadPSK: axReferenceBone_t(%i):\n"
"axReferenceBone_t::name: '%s'\n"
"axReferenceBone_t::flags: %i\n"
"axReferenceBone_t::numChildren %i\n"
"axReferenceBone_t::parentIndex: %i\n"
"axReferenceBone_t::quat: %f %f %f %f\n"
"axReferenceBone_t::position: %f %f %f\n"
"axReferenceBone_t::length: %f\n"
"axReferenceBone_t::xSize: %f\n"
"axReferenceBone_t::ySize: %f\n"
"axReferenceBone_t::zSize: %f\n",
i,
refBone->name,
refBone->flags,
refBone->numChildren,
refBone->parentIndex,
refBone->bone.quat[0], refBone->bone.quat[1], refBone->bone.quat[2], refBone->bone.quat[3],
refBone->bone.position[0], refBone->bone.position[1], refBone->bone.position[2],
refBone->bone.length,
refBone->bone.xSize,
refBone->bone.ySize,
refBone->bone.zSize);
#endif
}
// read bone weights
GetChunkHeader(stream, &chunkHeader);
if(Q_stricmpn(chunkHeader.ident, "RAWWEIGHTS", 10))
{
ri.Printf(PRINT_WARNING, "R_LoadPSK: '%s' has wrong chunk indent ('%s' should be '%s')\n", modName, chunkHeader.ident, "RAWWEIGHTS");
FreeMemStream(stream);
Com_Dealloc(points);
Com_Dealloc(vertexes);
Com_Dealloc(triangles);
Com_Dealloc(materials);
Com_Dealloc(refBones);
return qfalse;
}
if(chunkHeader.dataSize != sizeof(axBoneWeight_t))
{
ri.Printf(PRINT_WARNING, "R_LoadPSK: '%s' has wrong chunk dataSize ('%i' should be '%i')\n", modName, chunkHeader.dataSize, sizeof(axBoneWeight_t));
FreeMemStream(stream);
Com_Dealloc(points);
Com_Dealloc(vertexes);
Com_Dealloc(triangles);
Com_Dealloc(materials);
Com_Dealloc(refBones);
return qfalse;
}
PrintChunkHeader(&chunkHeader);
numWeights = chunkHeader.numData;
axWeights = (axBoneWeight_t*)Com_Allocate(numWeights * sizeof(axBoneWeight_t));
for(i = 0, axWeight = axWeights; i < numWeights; i++, axWeight++)
{
axWeight->weight = MemStreamGetFloat(stream);
axWeight->pointIndex = MemStreamGetLong(stream);
axWeight->boneIndex = MemStreamGetLong(stream);
#if 0
ri.Printf(PRINT_ALL, "R_LoadPSK: axBoneWeight_t(%i):\n"
"axBoneWeight_t::weight: %f\n"
"axBoneWeight_t::pointIndex %i\n"
"axBoneWeight_t::boneIndex: %i\n",
i,
axWeight->weight,
axWeight->pointIndex,
axWeight->boneIndex);
#endif
}
//
// convert the model to an internal MD5 representation
//
md5->numBones = numReferenceBones;
// calc numMeshes <number>
/*
numSmoothGroups = 0;
for(i = 0, triangle = triangles; i < numTriangles; i++, triangle++)
{
if(triangle->smoothingGroups)
{
}
}
*/
if(md5->numBones < 1)
{
ri.Printf(PRINT_WARNING, "R_LoadPSK: '%s' has no bones\n", modName);
Com_Dealloc(points);
Com_Dealloc(vertexes);
Com_Dealloc(triangles);
Com_Dealloc(materials);
Com_Dealloc(refBones);
Com_Dealloc(axWeights);
return qfalse;
}
if(md5->numBones > MAX_BONES)
{
ri.Printf(PRINT_WARNING, "R_LoadPSK: '%s' has more than %i bones (%i)\n", modName, MAX_BONES, md5->numBones);
Com_Dealloc(points);
Com_Dealloc(vertexes);
Com_Dealloc(triangles);
Com_Dealloc(materials);
Com_Dealloc(refBones);
Com_Dealloc(axWeights);
return qfalse;
}
//ri.Printf(PRINT_ALL, "R_LoadPSK: '%s' has %i bones\n", modName, md5->numBones);
// copy all reference bones
md5->bones = (md5Bone_t*)ri.Hunk_Alloc(sizeof(*md5Bone) * md5->numBones, h_low);
for(i = 0, md5Bone = md5->bones, refBone = refBones; i < md5->numBones; i++, md5Bone++, refBone++)
{
Q_strncpyz(md5Bone->name, refBone->name, sizeof(md5Bone->name));
if(i == 0)
{
md5Bone->parentIndex = refBone->parentIndex -1;
}
else
{
md5Bone->parentIndex = refBone->parentIndex;
}
//ri.Printf(PRINT_ALL, "R_LoadPSK: '%s' has bone '%s' with parent index %i\n", modName, md5Bone->name, md5Bone->parentIndex);
if(md5Bone->parentIndex >= md5->numBones)
{
ri.Error(ERR_DROP, "R_LoadPSK: '%s' has bone '%s' with bad parent index %i while numBones is %i\n", modName,
md5Bone->name, md5Bone->parentIndex, md5->numBones);
}
for(j = 0; j < 3; j++)
{
boneOrigin[j] = refBone->bone.position[j];
}
// Tr3B: I have really no idea why the .psk format stores the first quaternion with inverted quats.
// Furthermore only the X and Z components of the first quat are inverted ?!?!
if(i == 0)
{
boneQuat[0] = refBone->bone.quat[0];
boneQuat[1] = -refBone->bone.quat[1];
boneQuat[2] = refBone->bone.quat[2];
boneQuat[3] = refBone->bone.quat[3];
}
else
{
boneQuat[0] = -refBone->bone.quat[0];
boneQuat[1] = -refBone->bone.quat[1];
boneQuat[2] = -refBone->bone.quat[2];
boneQuat[3] = refBone->bone.quat[3];
}
VectorCopy(boneOrigin, md5Bone->origin);
//MatrixTransformPoint(unrealToQuake, boneOrigin, md5Bone->origin);
QuatCopy(boneQuat, md5Bone->rotation);
//QuatClear(md5Bone->rotation);
#if 0
ri.Printf(PRINT_ALL, "R_LoadPSK: md5Bone_t(%i):\n"
"md5Bone_t::name: '%s'\n"
"md5Bone_t::parentIndex: %i\n"
"md5Bone_t::quat: %f %f %f %f\n"
"md5bone_t::position: %f %f %f\n",
i,
md5Bone->name,
md5Bone->parentIndex,
md5Bone->rotation[0], md5Bone->rotation[1], md5Bone->rotation[2], md5Bone->rotation[3],
md5Bone->origin[0], md5Bone->origin[1], md5Bone->origin[2]);
#endif
if(md5Bone->parentIndex >= 0)
{
vec3_t rotated;
quat_t quat;
md5Bone_t *parent;
parent = &md5->bones[md5Bone->parentIndex];
QuatTransformVector(parent->rotation, md5Bone->origin, rotated);
//QuatTransformVector(md5Bone->rotation, md5Bone->origin, rotated);
VectorAdd(parent->origin, rotated, md5Bone->origin);
QuatMultiply1(parent->rotation, md5Bone->rotation, quat);
QuatCopy(quat, md5Bone->rotation);
}
MatrixSetupTransformFromQuat(md5Bone->inverseTransform, md5Bone->rotation, md5Bone->origin);
MatrixInverse(md5Bone->inverseTransform);
#if 0
ri.Printf(PRINT_ALL, "R_LoadPSK: md5Bone_t(%i):\n"
"md5Bone_t::name: '%s'\n"
"md5Bone_t::parentIndex: %i\n"
"md5Bone_t::quat: %f %f %f %f\n"
"md5bone_t::position: %f %f %f\n",
i,
md5Bone->name,
md5Bone->parentIndex,
md5Bone->rotation[0], md5Bone->rotation[1], md5Bone->rotation[2], md5Bone->rotation[3],
md5Bone->origin[0], md5Bone->origin[1], md5Bone->origin[2]);
#endif
}
Com_InitGrowList(&vboVertexes, 10000);
for(i = 0, vertex = vertexes; i < numVertexes; i++, vertex++)
{
md5Vertex_t *vboVert = (md5Vertex_t*)Com_Allocate(sizeof(*vboVert));
for(j = 0; j < 3; j++)
{
vboVert->position[j] = points[vertex->pointIndex].point[j];
}
vboVert->texCoords[0] = vertex->st[0];
vboVert->texCoords[1] = vertex->st[1];
// find number of associated weights
vboVert->numWeights = 0;
for(j = 0, axWeight = axWeights; j < numWeights; j++, axWeight++)
{
if(axWeight->pointIndex == vertex->pointIndex && axWeight->weight > 0.0f)
{
vboVert->numWeights++;
}
}
if(vboVert->numWeights > MAX_WEIGHTS)
{
ri.Error(ERR_DROP, "R_LoadPSK: vertex %i requires more weights %i than the maximum of %i in model '%s'", i, vboVert->numWeights, MAX_WEIGHTS, modName);
//ri.Printf(PRINT_WARNING, "R_LoadPSK: vertex %i requires more weights %i than the maximum of %i in model '%s'\n", i, vboVert->numWeights, MAX_WEIGHTS, modName);
}
vboVert->weights = (md5Weight_t**)ri.Hunk_Alloc(sizeof(*vboVert->weights) * vboVert->numWeights, h_low);
for(j = 0, axWeight = axWeights, k = 0; j < numWeights; j++, axWeight++)
{
if(axWeight->pointIndex == vertex->pointIndex && axWeight->weight > 0.0f)
{
weight = (md5Weight_t*)ri.Hunk_Alloc(sizeof(*weight), h_low);
weight->boneIndex = axWeight->boneIndex;
weight->boneWeight = axWeight->weight;
// FIXME?
weight->offset[0] = refBones[axWeight->boneIndex].bone.xSize;
weight->offset[1] = refBones[axWeight->boneIndex].bone.ySize;
weight->offset[2] = refBones[axWeight->boneIndex].bone.zSize;
vboVert->weights[k++] = weight;
}
}
Com_AddToGrowList(&vboVertexes, vboVert);
}
ClearBounds(md5->bounds[0], md5->bounds[1]);
for(i = 0, vertex = vertexes; i < numVertexes; i++, vertex++)
{
AddPointToBounds(points[vertex->pointIndex].point, md5->bounds[0], md5->bounds[1]);
}
#if 0
ri.Printf(PRINT_ALL, "R_LoadPSK: AABB (%i %i %i) (%i %i %i)\n",
(int)md5->bounds[0][0],
(int)md5->bounds[0][1],
(int)md5->bounds[0][2],
(int)md5->bounds[1][0],
(int)md5->bounds[1][1],
(int)md5->bounds[1][2]);
#endif
// sort triangles
qsort(triangles, numTriangles, sizeof(axTriangle_t), CompareTrianglesByMaterialIndex);
Com_InitGrowList(&sortedTriangles, 1000);
for(i = 0, triangle = triangles; i < numTriangles; i++, triangle++)
{
skelTriangle_t *sortTri = (skelTriangle_t*)Com_Allocate(sizeof(*sortTri));
for(j = 0; j < 3; j++)
{
sortTri->indexes[j] = triangle->indexes[j];
sortTri->vertexes[j] = (md5Vertex_t*)Com_GrowListElement(&vboVertexes, triangle->indexes[j]);
}
sortTri->referenced = qfalse;
Com_AddToGrowList(&sortedTriangles, sortTri);
}
// calc tangent spaces
#if 1
{
md5Vertex_t *v0, *v1, *v2;
const float *p0, *p1, *p2;
const float *t0, *t1, *t2;
vec3_t tangent;
vec3_t binormal;
vec3_t normal;
for(j = 0; j < vboVertexes.currentElements; j++)
{
v0 = (md5Vertex_t*)Com_GrowListElement(&vboVertexes, j);
VectorClear(v0->tangent);
VectorClear(v0->binormal);
VectorClear(v0->normal);
}
for(j = 0; j < sortedTriangles.currentElements; j++)
{
skelTriangle_t *tri = (skelTriangle_t*)Com_GrowListElement(&sortedTriangles, j);
v0 = (md5Vertex_t*)Com_GrowListElement(&vboVertexes, tri->indexes[0]);
v1 = (md5Vertex_t*)Com_GrowListElement(&vboVertexes, tri->indexes[1]);
v2 = (md5Vertex_t*)Com_GrowListElement(&vboVertexes, tri->indexes[2]);
p0 = v0->position;
p1 = v1->position;
p2 = v2->position;
t0 = v0->texCoords;
t1 = v1->texCoords;
t2 = v2->texCoords;
#if 1
R_CalcTangentSpace(tangent, binormal, normal, p0, p1, p2, t0, t1, t2);
#else
R_CalcNormalForTriangle(normal, p0, p1, p2);
R_CalcTangentsForTriangle(tangent, binormal, p0, p1, p2, t0, t1, t2);
#endif
for(k = 0; k < 3; k++)
{
float *v;
v0 = (md5Vertex_t*)Com_GrowListElement(&vboVertexes, tri->indexes[k]);
v = v0->tangent;
VectorAdd(v, tangent, v);
v = v0->binormal;
VectorAdd(v, binormal, v);
v = v0->normal;
VectorAdd(v, normal, v);
}
}
for(j = 0; j < vboVertexes.currentElements; j++)
{
v0 = (md5Vertex_t*)Com_GrowListElement(&vboVertexes, j);
VectorNormalize(v0->tangent);
VectorNormalize(v0->binormal);
VectorNormalize(v0->normal);
}
}
#else
{
float bb, s, t;
vec3_t bary;
vec3_t faceNormal;
md5Vertex_t *dv[3];
for(j = 0; j < sortedTriangles.currentElements; j++)
{
skelTriangle_t *tri = Com_GrowListElement(&sortedTriangles, j);
dv[0] = Com_GrowListElement(&vboVertexes, tri->indexes[0]);
dv[1] = Com_GrowListElement(&vboVertexes, tri->indexes[1]);
dv[2] = Com_GrowListElement(&vboVertexes, tri->indexes[2]);
R_CalcNormalForTriangle(faceNormal, dv[0]->position, dv[1]->position, dv[2]->position);
// calculate barycentric basis for the triangle
bb = (dv[1]->texCoords[0] - dv[0]->texCoords[0]) * (dv[2]->texCoords[1] - dv[0]->texCoords[1]) - (dv[2]->texCoords[0] - dv[0]->texCoords[0]) * (dv[1]->texCoords[1] -
dv[0]->texCoords[1]);
if(fabs(bb) < 0.00000001f)
continue;
// do each vertex
for(k = 0; k < 3; k++)
{
// calculate s tangent vector
s = dv[k]->texCoords[0] + 10.0f;
t = dv[k]->texCoords[1];
bary[0] = ((dv[1]->texCoords[0] - s) * (dv[2]->texCoords[1] - t) - (dv[2]->texCoords[0] - s) * (dv[1]->texCoords[1] - t)) / bb;
bary[1] = ((dv[2]->texCoords[0] - s) * (dv[0]->texCoords[1] - t) - (dv[0]->texCoords[0] - s) * (dv[2]->texCoords[1] - t)) / bb;
bary[2] = ((dv[0]->texCoords[0] - s) * (dv[1]->texCoords[1] - t) - (dv[1]->texCoords[0] - s) * (dv[0]->texCoords[1] - t)) / bb;
dv[k]->tangent[0] = bary[0] * dv[0]->position[0] + bary[1] * dv[1]->position[0] + bary[2] * dv[2]->position[0];
dv[k]->tangent[1] = bary[0] * dv[0]->position[1] + bary[1] * dv[1]->position[1] + bary[2] * dv[2]->position[1];
dv[k]->tangent[2] = bary[0] * dv[0]->position[2] + bary[1] * dv[1]->position[2] + bary[2] * dv[2]->position[2];
VectorSubtract(dv[k]->tangent, dv[k]->position, dv[k]->tangent);
VectorNormalize(dv[k]->tangent);
// calculate t tangent vector (binormal)
s = dv[k]->texCoords[0];
t = dv[k]->texCoords[1] + 10.0f;
bary[0] = ((dv[1]->texCoords[0] - s) * (dv[2]->texCoords[1] - t) - (dv[2]->texCoords[0] - s) * (dv[1]->texCoords[1] - t)) / bb;
bary[1] = ((dv[2]->texCoords[0] - s) * (dv[0]->texCoords[1] - t) - (dv[0]->texCoords[0] - s) * (dv[2]->texCoords[1] - t)) / bb;
bary[2] = ((dv[0]->texCoords[0] - s) * (dv[1]->texCoords[1] - t) - (dv[1]->texCoords[0] - s) * (dv[0]->texCoords[1] - t)) / bb;
dv[k]->binormal[0] = bary[0] * dv[0]->position[0] + bary[1] * dv[1]->position[0] + bary[2] * dv[2]->position[0];
dv[k]->binormal[1] = bary[0] * dv[0]->position[1] + bary[1] * dv[1]->position[1] + bary[2] * dv[2]->position[1];
dv[k]->binormal[2] = bary[0] * dv[0]->position[2] + bary[1] * dv[1]->position[2] + bary[2] * dv[2]->position[2];
VectorSubtract(dv[k]->binormal, dv[k]->position, dv[k]->binormal);
VectorNormalize(dv[k]->binormal);
// calculate the normal as cross product N=TxB
#if 0
CrossProduct(dv[k]->tangent, dv[k]->binormal, dv[k]->normal);
VectorNormalize(dv[k]->normal);
// Gram-Schmidt orthogonalization process for B
// compute the cross product B=NxT to obtain
// an orthogonal basis
CrossProduct(dv[k]->normal, dv[k]->tangent, dv[k]->binormal);
if(DotProduct(dv[k]->normal, faceNormal) < 0)
{
VectorInverse(dv[k]->normal);
//VectorInverse(dv[k]->tangent);
//VectorInverse(dv[k]->binormal);
}
#else
VectorAdd(dv[k]->normal, faceNormal, dv[k]->normal);
#endif
}
}
#if 1
for(j = 0; j < vboVertexes.currentElements; j++)
{
dv[0] = Com_GrowListElement(&vboVertexes, j);
//VectorNormalize(dv[0]->tangent);
//VectorNormalize(dv[0]->binormal);
VectorNormalize(dv[0]->normal);
}
#endif
}
#endif
#if 0
{
md5Vertex_t *v0, *v1;
// do another extra smoothing for normals to avoid flat shading
for(j = 0; j < vboVertexes.currentElements; j++)
{
v0 = Com_GrowListElement(&vboVertexes, j);
for(k = 0; k < vboVertexes.currentElements; k++)
{
if(j == k)
continue;
v1 = Com_GrowListElement(&vboVertexes, k);
if(VectorCompare(v0->position, v1->position))
{
VectorAdd(v0->position, v1->normal, v0->normal);
}
}
VectorNormalize(v0->normal);
}
}
#endif
// split the surfaces into VBO surfaces by the maximum number of GPU vertex skinning bones
Com_InitGrowList(&vboSurfaces, 10);
materialIndex = oldMaterialIndex = -1;
for(i = 0; i < numTriangles; i++)
{
triangle = &triangles[i];
materialIndex = triangle->materialIndex;
if(materialIndex != oldMaterialIndex)
{
oldMaterialIndex = materialIndex;
numRemaining = sortedTriangles.currentElements - i;
while(numRemaining)
{
numBoneReferences = 0;
Com_Memset(boneReferences, 0, sizeof(boneReferences));
Com_InitGrowList(&vboTriangles, 1000);
for(j = i; j < sortedTriangles.currentElements; j++)
{
skelTriangle_t *sortTri;
triangle = &triangles[j];
materialIndex = triangle->materialIndex;
if(materialIndex != oldMaterialIndex)
continue;
sortTri = (skelTriangle_t*)Com_GrowListElement(&sortedTriangles, j);
if(sortTri->referenced)
continue;
if(AddTriangleToVBOTriangleList(&vboTriangles, sortTri, &numBoneReferences, boneReferences))
{
sortTri->referenced = qtrue;
}
}
for(j = 0; j < MAX_BONES; j++)
{
if(boneReferences[j] > 0)
{
ri.Printf(PRINT_ALL, "R_LoadPSK: referenced bone: '%s'\n", (j < numReferenceBones) ? refBones[j].name : NULL);
}
}
if(!vboTriangles.currentElements)
{
ri.Printf(PRINT_WARNING, "R_LoadPSK: could not add triangles to a remaining VBO surface for model '%s'\n", modName);
break;
}
// FIXME skinIndex
AddSurfaceToVBOSurfacesList2(&vboSurfaces, &vboTriangles, &vboVertexes, md5, vboSurfaces.currentElements, materials[oldMaterialIndex].name, numBoneReferences, boneReferences);
numRemaining -= vboTriangles.currentElements;
Com_DestroyGrowList(&vboTriangles);
}
}
}
for(j = 0; j < sortedTriangles.currentElements; j++)
{
skelTriangle_t *sortTri = (skelTriangle_t*)Com_GrowListElement(&sortedTriangles, j);
Com_Dealloc(sortTri);
}
Com_DestroyGrowList(&sortedTriangles);
for(j = 0; j < vboVertexes.currentElements; j++)
{
md5Vertex_t *v = (md5Vertex_t*)Com_GrowListElement(&vboVertexes, j);
Com_Dealloc(v);
}
Com_DestroyGrowList(&vboVertexes);
// move VBO surfaces list to hunk
md5->numVBOSurfaces = vboSurfaces.currentElements;
md5->vboSurfaces = (srfVBOMD5Mesh_t**)ri.Hunk_Alloc(md5->numVBOSurfaces * sizeof(*md5->vboSurfaces), h_low);
for(i = 0; i < md5->numVBOSurfaces; i++)
{
md5->vboSurfaces[i] = (srfVBOMD5Mesh_t *) Com_GrowListElement(&vboSurfaces, i);
}
Com_DestroyGrowList(&vboSurfaces);
FreeMemStream(stream);
Com_Dealloc(points);
Com_Dealloc(vertexes);
Com_Dealloc(triangles);
Com_Dealloc(materials);
Com_Dealloc(refBones);
Com_Dealloc(axWeights);
ri.Printf(PRINT_ALL, "%i VBO surfaces created for PSK model '%s'\n", md5->numVBOSurfaces, modName);
return qtrue;
}
