/*
=================
R_LoadMDM
=================
*/
qboolean R_LoadMDM(model_t * mod, void *buffer, const char *modName)
{
int i, j, k;
mdmHeader_t *mdm;
// 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;
mdm = (mdmHeader_t *) buffer;
version = LittleLong(mdm->version);
if(version != MDM_VERSION)
{
ri.Printf(PRINT_WARNING, "R_LoadMDM: %s has wrong version (%i should be %i)\n", modName, 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);
//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\n", 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)
{
ri.Error(ERR_DROP, "R_LoadMDM: %s has more than %i verts on a surface (%i)",
modName, SHADER_MAX_VERTEXES, mdmSurf->numVerts);
}
if(mdmSurf->numTriangles > SHADER_MAX_TRIANGLES)
{
ri.Error(ERR_DROP, "R_LoadMDM: %s has more than %i triangles on a surface (%i)",
modName, 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
ri.Error(ERR_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
ri.Printf(PRINT_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, modName);
#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);
//ri.Printf(PRINT_ALL, "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;
//ri.Printf(PRINT_ALL, "(%i -> %i) ", j, value);
}
//ri.Printf(PRINT_ALL, "\n");
#if 0
ri.Printf(PRINT_ALL, "collapse map for mdm surface '%s': ", surf->name);
for(j = 0, collapseMap = surf->collapseMap; j < mdmSurf->numVerts; j++, collapseMap++)
{
ri.Printf(PRINT_ALL, "(%i -> %i) ", j, *collapseMap);
}
ri.Printf(PRINT_ALL, "\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(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
{
int numRemaining;
growList_t sortedTriangles;
growList_t vboTriangles;
growList_t vboSurfaces;
int numBoneReferences;
int boneReferences[MAX_BONES];
Com_InitGrowList(&vboSurfaces, 10);
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);
//ri.Printf(PRINT_ALL, "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)
{
ri.Printf(PRINT_WARNING, "R_LoadMDM: could not add triangles to a remaining VBO surface for model '%s'\n", modName);
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_LoadMD5
=================
*/
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;
md5Triangle_t *tri;
md5Vertex_t *v;
md5Weight_t *weight;
int version;
shader_t *sh;
char *buf_p;
char *token;
vec3_t boneOrigin;
quat_t boneQuat;
matrix_t boneMat;
buf_p = ( char * ) buffer;
// skip MD5Version indent string
COM_ParseExt2( &buf_p, qfalse );
// check version
token = COM_ParseExt2( &buf_p, qfalse );
version = atoi( token );
if ( version != MD5_VERSION )
{
ri.Printf( PRINT_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->model.md5 = (md5Model_t*) ri.Hunk_Alloc( sizeof( md5Model_t ), h_low );
// skip commandline <arguments string>
token = COM_ParseExt2( &buf_p, qtrue );
token = COM_ParseExt2( &buf_p, qtrue );
// ri.Printf(PRINT_ALL, "%s\n", token);
// parse numJoints <number>
token = COM_ParseExt2( &buf_p, qtrue );
if ( Q_stricmp( token, "numJoints" ) )
{
ri.Printf( PRINT_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" ) )
{
ri.Printf( PRINT_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 );
//ri.Printf(PRINT_ALL, "R_LoadMD5: '%s' has %i surfaces\n", modName, md5->numSurfaces);
if ( md5->numBones < 1 )
{
ri.Printf( PRINT_WARNING, "R_LoadMD5: '%s' has no bones\n", modName );
return qfalse;
}
if ( md5->numBones > MAX_BONES )
{
ri.Printf( PRINT_WARNING, "R_LoadMD5: '%s' has more than %i bones (%i)\n", modName, MAX_BONES, md5->numBones );
return qfalse;
}
//ri.Printf(PRINT_ALL, "R_LoadMD5: '%s' has %i bones\n", modName, md5->numBones);
// parse all the bones
md5->bones = (md5Bone_t*) ri.Hunk_Alloc( sizeof( *bone ) * md5->numBones, h_low );
// parse joints {
token = COM_ParseExt2( &buf_p, qtrue );
if ( Q_stricmp( token, "joints" ) )
{
ri.Printf( PRINT_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, "{" ) )
{
ri.Printf( PRINT_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 ) );
//ri.Printf(PRINT_ALL, "R_LoadMD5: '%s' has bone '%s'\n", modName, bone->name);
token = COM_ParseExt2( &buf_p, qfalse );
bone->parentIndex = atoi( token );
//ri.Printf(PRINT_ALL, "R_LoadMD5: '%s' has bone '%s' with parent index %i\n", modName, bone->name, bone->parentIndex);
if ( bone->parentIndex >= md5->numBones )
{
ri.Error( ERR_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, "(" ) )
{
ri.Printf( PRINT_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, ")" ) )
{
ri.Printf( PRINT_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, "(" ) )
{
ri.Printf( PRINT_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 );
// skip )
token = COM_ParseExt2( &buf_p, qfalse );
if ( Q_stricmp( token, ")" ) )
{
ri.Printf( PRINT_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, "}" ) )
{
ri.Printf( PRINT_WARNING, "R_LoadMD5: expected '}' found '%s' in model '%s'\n", token, modName );
return qfalse;
}
// parse all the surfaces
if ( md5->numSurfaces < 1 )
{
ri.Printf( PRINT_WARNING, "R_LoadMD5: '%s' has no surfaces\n", modName );
return qfalse;
}
//ri.Printf(PRINT_ALL, "R_LoadMD5: '%s' has %i surfaces\n", modName, md5->numSurfaces);
md5->surfaces = (md5Surface_t*) 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" ) )
{
ri.Printf( PRINT_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, "{" ) )
{
ri.Printf( PRINT_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" ) )
{
Q_strncpyz( surf->shader, "<default>", sizeof( surf->shader ) );
surf->shaderIndex = 0;
}
else
{
token = COM_ParseExt2( &buf_p, qfalse );
Q_strncpyz( surf->shader, token, sizeof( surf->shader ) );
//ri.Printf(PRINT_ALL, "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);
//ri.Printf(PRINT_ALL, "R_LoadMD5: '%s' has surface '%s'\n", modName, surf->name);
// register the shaders
sh = R_FindShader( surf->shader, LIGHTMAP_NONE, qtrue );
if ( sh->defaultShader )
{
surf->shaderIndex = 0;
}
else
{
surf->shaderIndex = sh->index;
}
token = COM_ParseExt2( &buf_p, qtrue );
}
// parse numVerts <number>
if ( Q_stricmp( token, "numVerts" ) )
{
ri.Printf( PRINT_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 )
{
ri.Error( ERR_DROP, "R_LoadMD5: '%s' has more than %i verts on a surface (%i)",
modName, SHADER_MAX_VERTEXES, surf->numVerts );
}
surf->verts = (md5Vertex_t*) 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" ) )
{
ri.Printf( PRINT_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, "(" ) )
{
ri.Printf( PRINT_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, ")" ) )
{
ri.Printf( PRINT_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 )
{
ri.Error( ERR_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" ) )
{
ri.Printf( PRINT_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 )
{
ri.Error( ERR_DROP, "R_LoadMD5: '%s' has more than %i triangles on a surface (%i)",
modName, SHADER_MAX_TRIANGLES, surf->numTriangles );
}
surf->triangles = (md5Triangle_t*) 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" ) )
{
ri.Printf( PRINT_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" ) )
{
ri.Printf( PRINT_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 = (md5Weight_t*) 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" ) )
{
ri.Printf( PRINT_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, "(" ) )
{
ri.Printf( PRINT_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, ")" ) )
{
ri.Printf( PRINT_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, "}" ) )
{
ri.Printf( PRINT_WARNING, "R_LoadMD5: expected '}' found '%s' in model '%s'\n", token, modName );
return qfalse;
}
// loop through all vertices and set up the vertex weights and base positions
for ( j = 0, v = surf->verts; j < surf->numVerts; j++, v++ )
{
md5Weight_t *w = surf->weights + v->firstWeight;
Vector4Set( v->position, 0, 0, 0, 1 );
for ( k = 0; k < v->numWeights; k++, w++ )
{
vec3_t offsetVec;
v->boneIndexes[ k ] = w->boneIndex;
v->boneWeights[ k ] = w->boneWeight;
bone = &md5->bones[ w->boneIndex ];
QuatTransformVector( bone->rotation, w->offset, offsetVec );
VectorAdd( bone->origin, offsetVec, offsetVec );
VectorMA( v->position, w->boneWeight, offsetVec, v->position );
}
}
}
// 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++ )
{
AddPointToBounds( v->position, md5->bounds[ 0 ], md5->bounds[ 1 ] );
}
// calc normals
{
const float *v0, *v1, *v2;
const float *t0, *t1, *t2;
vec3_t normal;
for ( j = 0, v = surf->verts; j < surf->numVerts; j++, v++ )
{
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;
R_CalcNormalForTriangle( normal, v0, v1, v2 );
for ( k = 0; k < 3; k++ )
{
float *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->normal );
v->normal[ 3 ] = 0;
}
}
#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
}
return qtrue;
}
/*
* R_AddLightOccluder
*/
bool R_AddLightOccluder( const entity_t *ent )
{
int i;
float maxSide;
vec3_t origin;
unsigned int hash_key;
shadowGroup_t *group;
mleaf_t *leaf;
vec3_t mins, maxs, bbox[8];
bool bmodelRotated = false;
if( rn.refdef.rdflags & RDF_NOWORLDMODEL )
return false;
if( !ent->model || ent->model->type == mod_brush )
return false;
VectorCopy( ent->lightingOrigin, origin );
if( ent->model->type == mod_brush )
{
vec3_t t;
VectorAdd( ent->model->mins, ent->model->maxs, t );
VectorMA( ent->origin, 0.5, t, origin );
}
if( VectorCompare( origin, vec3_origin ) )
return false;
// find lighting group containing entities with same lightingOrigin as ours
hash_key = (unsigned int)( origin[0] * 7 + origin[1] * 5 + origin[2] * 3 );
hash_key &= ( SHADOWGROUPS_HASH_SIZE-1 );
for( group = r_shadowGroups_hash[hash_key]; group; group = group->hashNext )
{
if( VectorCompare( group->origin, origin ) )
goto add; // found an existing one, add
}
if( rsc.numShadowGroups == MAX_SHADOWGROUPS )
return false; // no free groups
leaf = Mod_PointInLeaf( origin, rsh.worldModel );
// start a new group
group = &rsc.shadowGroups[rsc.numShadowGroups];
memset( group, 0, sizeof( *group ) );
group->id = group - rsc.shadowGroups + 1;
group->bit = ( 1<<rsc.numShadowGroups );
group->vis = Mod_ClusterPVS( leaf->cluster, rsh.worldModel );
group->useOrtho = true;
group->alpha = r_shadows_alpha->value;
// clear group bounds
VectorCopy( origin, group->origin );
ClearBounds( group->mins, group->maxs );
ClearBounds( group->visMins, group->visMaxs );
// add to hash table
group->hashNext = r_shadowGroups_hash[hash_key];
r_shadowGroups_hash[hash_key] = group;
rsc.numShadowGroups++;
add:
// get model bounds
if( ent->model->type == mod_alias )
R_AliasModelBBox( ent, mins, maxs );
else if( ent->model->type == mod_skeletal )
R_SkeletalModelBBox( ent, mins, maxs );
else if( ent->model->type == mod_brush )
R_BrushModelBBox( ent, mins, maxs, &bmodelRotated );
else
ClearBounds( mins, maxs );
maxSide = 0;
for( i = 0; i < 3; i++ ) {
if( mins[i] >= maxs[i] )
return false;
maxSide = max( maxSide, maxs[i] - mins[i] );
}
// ignore tiny objects
if( maxSide < 10 ) {
return false;
}
rsc.entShadowGroups[R_ENT2NUM(ent)] = group->id;
if( ent->flags & RF_WEAPONMODEL )
return true;
if( ent->model->type == mod_brush )
{
VectorCopy( mins, group->mins );
VectorCopy( maxs, group->maxs );
}
else
{
// rotate local bounding box and compute the full bounding box for this group
R_TransformBounds( ent->origin, ent->axis, mins, maxs, bbox );
for( i = 0; i < 8; i++ ) {
AddPointToBounds( bbox[i], group->mins, group->maxs );
}
}
// increase projection distance if needed
VectorSubtract( group->mins, origin, mins );
VectorSubtract( group->maxs, origin, maxs );
group->radius = RadiusFromBounds( mins, maxs );
group->projDist = max( group->projDist, group->radius + min( r_shadows_projection_distance->value, 64.0f ) );
return true;
}
/*
=================
R_SubdividePatchToGrid
=================
*/
srfGridMesh_t *R_SubdividePatchToGrid( int width, int height, drawVert_t* points,
drawVert_t* ctrl, float* errorTable ) {
int i, j, k, l;
drawVert_t prev, next, mid;
float len, maxLen;
int dir;
int t;
srfGridMesh_t *grid;
drawVert_t *vert;
vec3_t tmpVec;
for ( i = 0 ; i < width ; i++ ) {
for ( j = 0 ; j < height ; j++ ) {
ctrl[j*MAX_GRID_SIZE+i] = points[j*width+i];
}
}
for ( dir = 0 ; dir < 2 ; dir++ ) {
for ( j = 0 ; j < MAX_GRID_SIZE ; j++ ) {
errorTable[dir*MAX_GRID_SIZE+j] = 0;
}
// horizontal subdivisions
for ( j = 0 ; j + 2 < width ; j += 2 ) {
// check subdivided midpoints against control points
maxLen = 0;
for ( i = 0 ; i < height ; i++ ) {
vec3_t midxyz;
vec3_t dir;
vec3_t projected;
float d;
// calculate the point on the curve
for ( l = 0 ; l < 3 ; l++ ) {
midxyz[l] = (ctrl[i*MAX_GRID_SIZE+j].xyz[l]
+ ctrl[i*MAX_GRID_SIZE+j+1].xyz[l] * 2
+ ctrl[i*MAX_GRID_SIZE+j+2].xyz[l] ) * 0.25;
}
// see how far off the line it is
// using dist-from-line will not account for internal
// texture warping, but it gives a lot less polygons than
// dist-from-midpoint
VectorSubtract( midxyz, ctrl[i*MAX_GRID_SIZE+j].xyz, midxyz );
VectorSubtract( ctrl[i*MAX_GRID_SIZE+j+2].xyz, ctrl[i*MAX_GRID_SIZE+j].xyz, dir );
VectorNormalize( dir );
d = DotProduct( midxyz, dir );
VectorScale( dir, d, projected );
VectorSubtract( midxyz, projected, midxyz);
len = VectorLengthSquared( midxyz );
if ( len > maxLen ) {
maxLen = len;
}
}
maxLen = sqrt(maxLen);
// if all the points are on the lines, remove the entire columns
if ( maxLen < 0.1 ) {
errorTable[dir*MAX_GRID_SIZE+j+1] = 999;
continue;
}
// see if we want to insert subdivided columns
if ( width + 2 > MAX_GRID_SIZE ) {
errorTable[dir*MAX_GRID_SIZE+j+1] = 1.0/maxLen;
continue; // can't subdivide any more
}
if ( maxLen <= r_subdivisions->value ) {
errorTable[dir*MAX_GRID_SIZE+j+1] = 1.0/maxLen;
continue; // didn't need subdivision
}
errorTable[dir*MAX_GRID_SIZE+j+2] = 1.0/maxLen;
// insert two columns and replace the peak
width += 2;
for ( i = 0 ; i < height ; i++ ) {
LerpDrawVert( &ctrl[i*MAX_GRID_SIZE+j], &ctrl[i*MAX_GRID_SIZE+j+1], &prev );
LerpDrawVert( &ctrl[i*MAX_GRID_SIZE+j+1], &ctrl[i*MAX_GRID_SIZE+j+2], &next );
LerpDrawVert( &prev, &next, &mid );
for ( k = width - 1 ; k > j + 3 ; k-- ) {
ctrl[i*MAX_GRID_SIZE+k] = ctrl[i*MAX_GRID_SIZE+k-2];
}
ctrl[i*MAX_GRID_SIZE+j + 1] = prev;
ctrl[i*MAX_GRID_SIZE+j + 2] = mid;
ctrl[i*MAX_GRID_SIZE+j + 3] = next;
}
// back up and recheck this set again, it may need more subdivision
j -= 2;
}
Transpose( width, height, ctrl );
t = width;
width = height;
height = t;
}
// put all the aproximating points on the curve
PutPointsOnCurve( ctrl, width, height );
// cull out any rows or columns that are colinear
for ( i = 1 ; i < width-1 ; i++ ) {
if ( errorTable[0*MAX_GRID_SIZE+i] != 999 ) {
continue;
}
for ( j = i+1 ; j < width ; j++ ) {
for ( k = 0 ; k < height ; k++ ) {
ctrl[k*MAX_GRID_SIZE+j-1] = ctrl[k*MAX_GRID_SIZE+j];
}
errorTable[0*MAX_GRID_SIZE+j-1] = errorTable[0*MAX_GRID_SIZE+j];
}
width--;
}
for ( i = 1 ; i < height-1 ; i++ ) {
if ( errorTable[1*MAX_GRID_SIZE+i] != 999 ) {
continue;
}
for ( j = i+1 ; j < height ; j++ ) {
for ( k = 0 ; k < width ; k++ ) {
ctrl[(j-1)*MAX_GRID_SIZE+k] = ctrl[j*MAX_GRID_SIZE+k];
}
errorTable[1*MAX_GRID_SIZE+j-1] = errorTable[1*MAX_GRID_SIZE+j];
}
height--;
}
#if 1
// flip for longest tristrips as an optimization
// the results should be visually identical with or
// without this step
if ( height > width ) {
Transpose( width, height, ctrl );
InvertErrorTable( errorTable, width, height );
t = width;
width = height;
height = t;
InvertCtrl( width, height, ctrl );
}
#endif
// calculate normals
MakeMeshNormals( width, height, ctrl );
// copy the results out to a grid
grid = (struct srfGridMesh_s *) Hunk_Alloc( (width * height - 1) * sizeof( drawVert_t ) + sizeof( *grid ) + width * 4 + height * 4, h_low );
grid->widthLodError = (float*)(((char*)grid) + (width * height - 1) *
sizeof(drawVert_t) + sizeof(*grid));
memcpy( grid->widthLodError, &errorTable[0*MAX_GRID_SIZE], width * 4 );
grid->heightLodError = (float*)(((char*)grid->widthLodError) + width * 4);
memcpy( grid->heightLodError, &errorTable[1*MAX_GRID_SIZE], height * 4 );
grid->width = width;
grid->height = height;
grid->surfaceType = SF_GRID;
ClearBounds( grid->meshBounds[0], grid->meshBounds[1] );
for ( i = 0 ; i < width ; i++ ) {
for ( j = 0 ; j < height ; j++ ) {
vert = &grid->verts[j*width+i];
*vert = ctrl[j*MAX_GRID_SIZE+i];
AddPointToBounds( vert->xyz, grid->meshBounds[0], grid->meshBounds[1] );
}
}
// compute local origin and bounds
VectorAdd( grid->meshBounds[0], grid->meshBounds[1], grid->localOrigin );
VectorScale( grid->localOrigin, 0.5f, grid->localOrigin );
VectorSubtract( grid->meshBounds[0], grid->localOrigin, tmpVec );
grid->meshRadius = VectorLength( tmpVec );
VectorCopy( grid->localOrigin, grid->lodOrigin );
grid->lodRadius = grid->meshRadius;
return grid;
}
/*
==============
RE_BuildSkeleton
==============
*/
int RE_BuildSkeleton( refSkeleton_t *skel, qhandle_t hAnim, int startFrame, int endFrame, float frac, qboolean clearOrigin )
{
skelAnimation_t *skelAnim;
skelAnim = R_GetAnimationByHandle( hAnim );
if ( skelAnim->type == AT_MD5 && skelAnim->md5 )
{
int i;
md5Animation_t *anim;
md5Channel_t *channel;
md5Frame_t *newFrame, *oldFrame;
vec3_t newOrigin, oldOrigin, lerpedOrigin;
quat_t newQuat, oldQuat, lerpedQuat;
int componentsApplied;
anim = skelAnim->md5;
// Validate the frames so there is no chance of a crash.
// This will write directly into the entity structure, so
// when the surfaces are rendered, they don't need to be
// range checked again.
/*
if((startFrame >= anim->numFrames) || (startFrame < 0) || (endFrame >= anim->numFrames) || (endFrame < 0))
{
ri.Printf(PRINT_DEVELOPER, "RE_BuildSkeleton: no such frame %d to %d for '%s'\n", startFrame, endFrame, anim->name);
//startFrame = 0;
//endFrame = 0;
}
*/
Q_clamp( startFrame, 0, anim->numFrames - 1 );
Q_clamp( endFrame, 0, anim->numFrames - 1 );
// compute frame pointers
oldFrame = &anim->frames[ startFrame ];
newFrame = &anim->frames[ endFrame ];
// calculate a bounding box in the current coordinate system
for ( i = 0; i < 3; i++ )
{
skel->bounds[ 0 ][ i ] =
oldFrame->bounds[ 0 ][ i ] < newFrame->bounds[ 0 ][ i ] ? oldFrame->bounds[ 0 ][ i ] : newFrame->bounds[ 0 ][ i ];
skel->bounds[ 1 ][ i ] =
oldFrame->bounds[ 1 ][ i ] > newFrame->bounds[ 1 ][ i ] ? oldFrame->bounds[ 1 ][ i ] : newFrame->bounds[ 1 ][ i ];
}
for ( i = 0, channel = anim->channels; i < anim->numChannels; i++, channel++ )
{
// set baseframe values
VectorCopy( channel->baseOrigin, newOrigin );
VectorCopy( channel->baseOrigin, oldOrigin );
QuatCopy( channel->baseQuat, newQuat );
QuatCopy( channel->baseQuat, oldQuat );
componentsApplied = 0;
// update tranlation bits
if ( channel->componentsBits & COMPONENT_BIT_TX )
{
oldOrigin[ 0 ] = oldFrame->components[ channel->componentsOffset + componentsApplied ];
newOrigin[ 0 ] = newFrame->components[ channel->componentsOffset + componentsApplied ];
componentsApplied++;
}
if ( channel->componentsBits & COMPONENT_BIT_TY )
{
oldOrigin[ 1 ] = oldFrame->components[ channel->componentsOffset + componentsApplied ];
newOrigin[ 1 ] = newFrame->components[ channel->componentsOffset + componentsApplied ];
componentsApplied++;
}
if ( channel->componentsBits & COMPONENT_BIT_TZ )
{
oldOrigin[ 2 ] = oldFrame->components[ channel->componentsOffset + componentsApplied ];
newOrigin[ 2 ] = newFrame->components[ channel->componentsOffset + componentsApplied ];
componentsApplied++;
}
// update quaternion rotation bits
if ( channel->componentsBits & COMPONENT_BIT_QX )
{
( ( vec_t * ) oldQuat ) [ 0 ] = oldFrame->components[ channel->componentsOffset + componentsApplied ];
( ( vec_t * ) newQuat ) [ 0 ] = newFrame->components[ channel->componentsOffset + componentsApplied ];
componentsApplied++;
}
if ( channel->componentsBits & COMPONENT_BIT_QY )
{
( ( vec_t * ) oldQuat ) [ 1 ] = oldFrame->components[ channel->componentsOffset + componentsApplied ];
( ( vec_t * ) newQuat ) [ 1 ] = newFrame->components[ channel->componentsOffset + componentsApplied ];
componentsApplied++;
}
if ( channel->componentsBits & COMPONENT_BIT_QZ )
{
( ( vec_t * ) oldQuat ) [ 2 ] = oldFrame->components[ channel->componentsOffset + componentsApplied ];
( ( vec_t * ) newQuat ) [ 2 ] = newFrame->components[ channel->componentsOffset + componentsApplied ];
}
QuatCalcW( oldQuat );
QuatNormalize( oldQuat );
QuatCalcW( newQuat );
QuatNormalize( newQuat );
#if 1
VectorLerp( oldOrigin, newOrigin, frac, lerpedOrigin );
QuatSlerp( oldQuat, newQuat, frac, lerpedQuat );
#else
VectorCopy( newOrigin, lerpedOrigin );
QuatCopy( newQuat, lerpedQuat );
#endif
// copy lerped information to the bone + extra data
skel->bones[ i ].parentIndex = channel->parentIndex;
if ( channel->parentIndex < 0 && clearOrigin )
{
VectorClear( skel->bones[ i ].origin );
QuatClear( skel->bones[ i ].rotation );
// move bounding box back
VectorSubtract( skel->bounds[ 0 ], lerpedOrigin, skel->bounds[ 0 ] );
VectorSubtract( skel->bounds[ 1 ], lerpedOrigin, skel->bounds[ 1 ] );
}
else
{
VectorCopy( lerpedOrigin, skel->bones[ i ].origin );
}
QuatCopy( lerpedQuat, skel->bones[ i ].rotation );
#if defined( REFBONE_NAMES )
Q_strncpyz( skel->bones[ i ].name, channel->name, sizeof( skel->bones[ i ].name ) );
#endif
}
skel->numBones = anim->numChannels;
skel->type = SK_RELATIVE;
return qtrue;
}
else if ( skelAnim->type == AT_PSA && skelAnim->psa )
{
int i;
psaAnimation_t *anim;
axAnimationKey_t *newKey, *oldKey;
axReferenceBone_t *refBone;
vec3_t newOrigin, oldOrigin, lerpedOrigin;
quat_t newQuat, oldQuat, lerpedQuat;
refSkeleton_t skeleton;
anim = skelAnim->psa;
Q_clamp( startFrame, 0, anim->info.numRawFrames - 1 );
Q_clamp( endFrame, 0, anim->info.numRawFrames - 1 );
ClearBounds( skel->bounds[ 0 ], skel->bounds[ 1 ] );
skel->numBones = anim->info.numBones;
for ( i = 0, refBone = anim->bones; i < anim->info.numBones; i++, refBone++ )
{
oldKey = &anim->keys[ startFrame * anim->info.numBones + i ];
newKey = &anim->keys[ endFrame * anim->info.numBones + i ];
VectorCopy( newKey->position, newOrigin );
VectorCopy( oldKey->position, oldOrigin );
QuatCopy( newKey->quat, newQuat );
QuatCopy( oldKey->quat, oldQuat );
//QuatCalcW(oldQuat);
//QuatNormalize(oldQuat);
//QuatCalcW(newQuat);
//QuatNormalize(newQuat);
VectorLerp( oldOrigin, newOrigin, frac, lerpedOrigin );
QuatSlerp( oldQuat, newQuat, frac, lerpedQuat );
// copy lerped information to the bone + extra data
skel->bones[ i ].parentIndex = refBone->parentIndex;
if ( refBone->parentIndex < 0 && clearOrigin )
{
VectorClear( skel->bones[ i ].origin );
QuatClear( skel->bones[ i ].rotation );
// move bounding box back
VectorSubtract( skel->bounds[ 0 ], lerpedOrigin, skel->bounds[ 0 ] );
VectorSubtract( skel->bounds[ 1 ], lerpedOrigin, skel->bounds[ 1 ] );
}
else
{
VectorCopy( lerpedOrigin, skel->bones[ i ].origin );
}
QuatCopy( lerpedQuat, skel->bones[ i ].rotation );
#if defined( REFBONE_NAMES )
Q_strncpyz( skel->bones[ i ].name, refBone->name, sizeof( skel->bones[ i ].name ) );
#endif
// calculate absolute values for the bounding box approximation
VectorCopy( skel->bones[ i ].origin, skeleton.bones[ i ].origin );
QuatCopy( skel->bones[ i ].rotation, skeleton.bones[ i ].rotation );
if ( refBone->parentIndex >= 0 )
{
vec3_t rotated;
quat_t quat;
refBone_t *parent;
refBone_t *bone;
bone = &skeleton.bones[ i ];
parent = &skeleton.bones[ refBone->parentIndex ];
QuatTransformVector( parent->rotation, bone->origin, rotated );
VectorAdd( parent->origin, rotated, bone->origin );
QuatMultiply1( parent->rotation, bone->rotation, quat );
QuatCopy( quat, bone->rotation );
AddPointToBounds( bone->origin, skel->bounds[ 0 ], skel->bounds[ 1 ] );
}
}
skel->numBones = anim->info.numBones;
skel->type = SK_RELATIVE;
return qtrue;
}
//ri.Printf(PRINT_WARNING, "RE_BuildSkeleton: bad animation '%s' with handle %i\n", anim->name, hAnim);
// FIXME: clear existing bones and bounds?
return qfalse;
}
/*
* Mod_LoadAliasMD3Model
*/
void Mod_LoadAliasMD3Model( model_t *mod, model_t *parent, void *buffer, bspFormatDesc_t *unused )
{
int version, i, j, l;
int bufsize, numverts;
uint8_t *buf;
dmd3header_t *pinmodel;
dmd3frame_t *pinframe;
dmd3tag_t *pintag;
dmd3mesh_t *pinmesh;
dmd3skin_t *pinskin;
dmd3coord_t *pincoord;
dmd3vertex_t *pinvert;
unsigned int *pinelem;
elem_t *poutelem;
maliasvertex_t *poutvert;
vec2_t *poutcoord;
maliasskin_t *poutskin;
maliasmesh_t *poutmesh;
maliastag_t *pouttag;
maliasframe_t *poutframe;
maliasmodel_t *poutmodel;
drawSurfaceAlias_t *drawSurf;
pinmodel = ( dmd3header_t * )buffer;
version = LittleLong( pinmodel->version );
if( version != MD3_ALIAS_VERSION )
ri.Com_Error( ERR_DROP, "%s has wrong version number (%i should be %i)",
mod->name, version, MD3_ALIAS_VERSION );
mod->type = mod_alias;
mod->extradata = poutmodel = ( maliasmodel_t * )Mod_Malloc( mod, sizeof( maliasmodel_t ) );
mod->radius = 0;
mod->registrationSequence = rsh.registrationSequence;
mod->touch = &Mod_TouchAliasModel;
ClearBounds( mod->mins, mod->maxs );
// byte swap the header fields and sanity check
poutmodel->numframes = LittleLong( pinmodel->num_frames );
poutmodel->numtags = LittleLong( pinmodel->num_tags );
poutmodel->nummeshes = LittleLong( pinmodel->num_meshes );
poutmodel->numskins = 0;
poutmodel->numverts = 0;
poutmodel->numtris = 0;
if( poutmodel->numframes <= 0 )
ri.Com_Error( ERR_DROP, "model %s has no frames", mod->name );
// else if( poutmodel->numframes > MD3_MAX_FRAMES )
// ri.Com_Error( ERR_DROP, "model %s has too many frames", mod->name );
if( poutmodel->numtags > MD3_MAX_TAGS )
ri.Com_Error( ERR_DROP, "model %s has too many tags", mod->name );
else if( poutmodel->numtags < 0 )
ri.Com_Error( ERR_DROP, "model %s has invalid number of tags", mod->name );
if( poutmodel->nummeshes < 0 )
ri.Com_Error( ERR_DROP, "model %s has invalid number of meshes", mod->name );
else if( !poutmodel->nummeshes && !poutmodel->numtags )
ri.Com_Error( ERR_DROP, "model %s has no meshes and no tags", mod->name );
// else if( poutmodel->nummeshes > MD3_MAX_MESHES )
// ri.Com_Error( ERR_DROP, "model %s has too many meshes", mod->name );
bufsize = poutmodel->numframes * ( sizeof( maliasframe_t ) + sizeof( maliastag_t ) * poutmodel->numtags ) +
poutmodel->nummeshes * sizeof( maliasmesh_t ) +
poutmodel->nummeshes * sizeof( drawSurfaceAlias_t );
buf = ( uint8_t * )Mod_Malloc( mod, bufsize );
//
// load the frames
//
pinframe = ( dmd3frame_t * )( ( uint8_t * )pinmodel + LittleLong( pinmodel->ofs_frames ) );
poutframe = poutmodel->frames = ( maliasframe_t * )buf; buf += sizeof( maliasframe_t ) * poutmodel->numframes;
for( i = 0; i < poutmodel->numframes; i++, pinframe++, poutframe++ )
{
memcpy( poutframe->translate, pinframe->translate, sizeof( vec3_t ) );
for( j = 0; j < 3; j++ )
{
poutframe->scale[j] = MD3_XYZ_SCALE;
poutframe->translate[j] = LittleFloat( poutframe->translate[j] );
}
// never trust the modeler utility and recalculate bbox and radius
ClearBounds( poutframe->mins, poutframe->maxs );
}
//
// load the tags
//
pintag = ( dmd3tag_t * )( ( uint8_t * )pinmodel + LittleLong( pinmodel->ofs_tags ) );
pouttag = poutmodel->tags = ( maliastag_t * )buf; buf += sizeof( maliastag_t ) * poutmodel->numframes * poutmodel->numtags;
for( i = 0; i < poutmodel->numframes; i++ )
{
for( l = 0; l < poutmodel->numtags; l++, pintag++, pouttag++ )
{
dmd3tag_t intag;
mat3_t axis;
memcpy( &intag, pintag, sizeof( dmd3tag_t ) );
for( j = 0; j < 3; j++ )
{
axis[AXIS_FORWARD+j] = LittleFloat( intag.axis[0][j] );
axis[AXIS_RIGHT+j] = LittleFloat( intag.axis[1][j] );
axis[AXIS_UP+j] = LittleFloat( intag.axis[2][j] );
pouttag->origin[j] = LittleFloat( intag.origin[j] );
}
Quat_FromMatrix3( axis, pouttag->quat );
Quat_Normalize( pouttag->quat );
Q_strncpyz( pouttag->name, intag.name, MD3_MAX_PATH );
}
}
//
// allocate drawSurfs
//
drawSurf = poutmodel->drawSurfs = ( drawSurfaceAlias_t * )buf; buf += sizeof( drawSurfaceAlias_t ) * poutmodel->nummeshes;
for( i = 0; i < poutmodel->nummeshes; i++, drawSurf++ )
{
drawSurf->type = ST_ALIAS;
drawSurf->model = mod;
drawSurf->mesh = poutmodel->meshes + i;
}
//
// load meshes
//
pinmesh = ( dmd3mesh_t * )( ( uint8_t * )pinmodel + LittleLong( pinmodel->ofs_meshes ) );
poutmesh = poutmodel->meshes = ( maliasmesh_t * )buf; buf += sizeof( maliasmesh_t ) * poutmodel->nummeshes;
for( i = 0; i < poutmodel->nummeshes; i++, poutmesh++ )
{
dmd3mesh_t inmesh;
memcpy( &inmesh, pinmesh, sizeof( dmd3mesh_t ) );
if( strncmp( (const char *)inmesh.id, IDMD3HEADER, 4 ) )
ri.Com_Error( ERR_DROP, "mesh %s in model %s has wrong id (%s should be %s)",
inmesh.name, mod->name, inmesh.id, IDMD3HEADER );
Q_strncpyz( poutmesh->name, inmesh.name, MD3_MAX_PATH );
Mod_StripLODSuffix( poutmesh->name );
poutmesh->numtris = LittleLong( inmesh.num_tris );
poutmesh->numskins = LittleLong( inmesh.num_skins );
poutmesh->numverts = numverts = LittleLong( inmesh.num_verts );
poutmodel->numverts += poutmesh->numverts;
poutmodel->numtris += poutmesh->numtris;
/* if( poutmesh->numskins <= 0 )
ri.Com_Error( ERR_DROP, "mesh %i in model %s has no skins", i, mod->name );
else*/ if( poutmesh->numskins > MD3_MAX_SHADERS )
ri.Com_Error( ERR_DROP, "mesh %i in model %s has too many skins", i, mod->name );
if( poutmesh->numtris <= 0 )
ri.Com_Error( ERR_DROP, "mesh %i in model %s has no elements", i, mod->name );
else if( poutmesh->numtris > MD3_MAX_TRIANGLES )
ri.Com_Error( ERR_DROP, "mesh %i in model %s has too many triangles", i, mod->name );
if( poutmesh->numverts <= 0 )
ri.Com_Error( ERR_DROP, "mesh %i in model %s has no vertices", i, mod->name );
else if( poutmesh->numverts > MD3_MAX_VERTS )
ri.Com_Error( ERR_DROP, "mesh %i in model %s has too many vertices", i, mod->name );
bufsize = ALIGN( sizeof( maliasskin_t ) * poutmesh->numskins, sizeof( vec_t ) ) +
numverts * ( sizeof( vec2_t ) + sizeof( maliasvertex_t ) * poutmodel->numframes ) +
poutmesh->numtris * sizeof( elem_t ) * 3;
buf = ( uint8_t * )Mod_Malloc( mod, bufsize );
//
// load the skins
//
pinskin = ( dmd3skin_t * )( ( uint8_t * )pinmesh + LittleLong( inmesh.ofs_skins ) );
poutskin = poutmesh->skins = ( maliasskin_t * )buf;
buf += ALIGN( sizeof( maliasskin_t ) * poutmesh->numskins, sizeof( vec_t ) );
for( j = 0; j < poutmesh->numskins; j++, pinskin++, poutskin++ ) {
Q_strncpyz( poutskin->name, pinskin->name, sizeof( poutskin->name ) );
poutskin->shader = R_RegisterSkin( poutskin->name );
}
//
// load the texture coordinates
//
pincoord = ( dmd3coord_t * )( ( uint8_t * )pinmesh + LittleLong( inmesh.ofs_tcs ) );
poutcoord = poutmesh->stArray = ( vec2_t * )buf; buf += poutmesh->numverts * sizeof( vec2_t );
for( j = 0; j < poutmesh->numverts; j++, pincoord++ )
{
memcpy( poutcoord[j], pincoord->st, sizeof( vec2_t ) );
poutcoord[j][0] = LittleFloat( poutcoord[j][0] );
poutcoord[j][1] = LittleFloat( poutcoord[j][1] );
}
//
// load the vertexes and normals
//
pinvert = ( dmd3vertex_t * )( ( uint8_t * )pinmesh + LittleLong( inmesh.ofs_verts ) );
poutvert = poutmesh->vertexes = ( maliasvertex_t * )buf;
buf += poutmesh->numverts * sizeof( maliasvertex_t ) * poutmodel->numframes;
for( l = 0, poutframe = poutmodel->frames; l < poutmodel->numframes; l++, poutframe++, pinvert += poutmesh->numverts, poutvert += poutmesh->numverts )
{
vec3_t v;
for( j = 0; j < poutmesh->numverts; j++ )
{
dmd3vertex_t invert;
memcpy( &invert, &( pinvert[j] ), sizeof( dmd3vertex_t ) );
poutvert[j].point[0] = LittleShort( invert.point[0] );
poutvert[j].point[1] = LittleShort( invert.point[1] );
poutvert[j].point[2] = LittleShort( invert.point[2] );
poutvert[j].latlong[0] = invert.norm[0];
poutvert[j].latlong[1] = invert.norm[1];
VectorCopy( poutvert[j].point, v );
AddPointToBounds( v, poutframe->mins, poutframe->maxs );
}
}
//
// load the elems
//
pinelem = ( unsigned int * )( ( uint8_t * )pinmesh + LittleLong( inmesh.ofs_elems ) );
poutelem = poutmesh->elems = ( elem_t * )buf;
for( j = 0; j < poutmesh->numtris; j++, pinelem += 3, poutelem += 3 )
{
unsigned int inelem[3];
memcpy( inelem, pinelem, sizeof( int ) * 3 );
poutelem[0] = (elem_t)LittleLong( inelem[0] );
poutelem[1] = (elem_t)LittleLong( inelem[1] );
poutelem[2] = (elem_t)LittleLong( inelem[2] );
}
pinmesh = ( dmd3mesh_t * )( ( uint8_t * )pinmesh + LittleLong( inmesh.meshsize ) );
}
//
// setup drawSurfs
//
for( i = 0; i < poutmodel->nummeshes; i++ )
{
drawSurf = poutmodel->drawSurfs + i;
drawSurf->type = ST_ALIAS;
drawSurf->model = mod;
drawSurf->mesh = poutmodel->meshes + i;
}
//
// build S and T vectors for frame 0
//
Mod_AliasBuildMeshesForFrame0( mod );
//
// calculate model bounds
//
poutframe = poutmodel->frames;
for( i = 0; i < poutmodel->numframes; i++, poutframe++ )
{
VectorMA( poutframe->translate, MD3_XYZ_SCALE, poutframe->mins, poutframe->mins );
VectorMA( poutframe->translate, MD3_XYZ_SCALE, poutframe->maxs, poutframe->maxs );
poutframe->radius = RadiusFromBounds( poutframe->mins, poutframe->maxs );
AddPointToBounds( poutframe->mins, mod->mins, mod->maxs );
AddPointToBounds( poutframe->maxs, mod->mins, mod->maxs );
mod->radius = max( mod->radius, poutframe->radius );
}
}
void CreateBrushFaces (void)
{
int i,j, k;
vec_t r;
face_t *f, *next;
winding_t *w;
plane_t clipplane, faceplane;
mface_t *mf;
vec3_t offset, point;
VectorClear(offset);
ClearBounds(brush_mins,brush_maxs);
brush_faces = NULL;
if(!strcmp(ValueForKey(CurrentEntity,"classname"),"area_rotate"))
{
entity_t *FoundEntity;
char *searchstring,
text[20];
searchstring = ValueForKey(CurrentEntity,"target");
FoundEntity = FindTargetEntity(searchstring);
if(FoundEntity)
GetVectorForKey(FoundEntity, "origin", offset);
sprintf(text, "%g %g %g", offset[0], offset[1], offset[2]);
SetKeyValue(CurrentEntity, "origin", text);
}
GetVectorForKey(CurrentEntity, "origin", offset);
//printf("%i brushfaces at offset %f %f %f\n", numbrushfaces, offset[0], offset[1], offset[2]);
for (i = 0;i < numbrushfaces;i++)
{
mf = &faces[i];
//printf("plane %f %f %f %f\n", mf->plane.normal[0], mf->plane.normal[1], mf->plane.normal[2], mf->plane.dist);
faceplane = mf->plane;
w = BaseWindingForPlane (&faceplane);
//VectorNegate( faceplane.normal, point );
for (j = 0;j < numbrushfaces && w;j++)
{
clipplane = faces[j].plane;
if(j == i)
continue;
// flip the plane, because we want to keep the back side
VectorNegate(clipplane.normal, clipplane.normal);
clipplane.dist *= -1;
w = ClipWindingEpsilon (w, &clipplane, ON_EPSILON, true);
}
if (!w)
//printf("----- skipped plane -----\n");
continue; // overcontrained plane
// this face is a keeper
f = AllocFace ();
f->winding = w;
for (j = 0;j < w->numpoints;j++)
{
for (k = 0;k < 3;k++)
{
point[k] = w->points[j][k] - offset[k];
r = Q_rint(point[k]);
if ( fabs( point[k] - r ) < ZERO_EPSILON)
w->points[j][k] = r;
else
w->points[j][k] = point[k];
// check for incomplete brushes
if( w->points[j][k] >= BOGUS_RANGE || w->points[j][k] <= -BOGUS_RANGE )
break;
}
// remove this brush
if(k < 3)
{
FreeFace(f);
for (f = brush_faces; f; f = next)
{
next = f->next;
FreeFace (f);
}
brush_faces = NULL;
printf("----- skipped brush -----\n");
return;
}
AddPointToBounds( w->points[j], brush_mins, brush_maxs );
}
CheckWinding(w);
faceplane.dist -= DotProduct(faceplane.normal, offset);
f->texturenum = mf->texinfo;
f->planenum = FindPlane (&faceplane, &f->planeside);
f->next = brush_faces;
brush_faces = f;
}
// Rotatable objects have to have a bounding box big enough
// to account for all its rotations.
if (DotProduct(offset, offset))
{
vec_t delta;
delta = RadiusFromBounds( brush_mins, brush_maxs );
for (k = 0;k < 3;k++)
{
brush_mins[k] = -delta;
brush_maxs[k] = delta;
}
}
//printf("%i : %f %f %f : %f %f %f\n", numbrushfaces, brush_mins[0], brush_mins[1], brush_mins[2], brush_maxs[0], brush_maxs[1], brush_maxs[2]);
}
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
int AAS_StoreArea(tmp_area_t *tmparea)
{
int side, edgenum, i;
plane_t *plane;
tmp_face_t *tmpface;
aas_area_t *aasarea;
aas_edge_t *edge;
aas_face_t *aasface;
aas_faceindex_t aasfacenum;
vec3_t facecenter;
winding_t *w;
//when the area is merged go to the merged area
//FIXME: this isn't necessary anymore because the tree
// is refreshed after area merging
while (tmparea->mergedarea)
tmparea = tmparea->mergedarea;
//
if (tmparea->invalid)
{
// RF, might be a removed non-grounded area
return 0;
//Error("AAS_StoreArea: tried to store invalid area");
}
//if there is an aas area already stored for this tmp area
if (tmparea->aasareanum)
{
return -tmparea->aasareanum;
}
//
if ((*aasworld).numareas >= max_aas.max_areas)
{
Error("AAS_MAX_AREAS = %d", max_aas.max_areas);
} //end if
//area zero is a dummy
if ((*aasworld).numareas == 0)
{
(*aasworld).numareas = 1;
}
//create an area from this leaf
aasarea = &(*aasworld).areas[(*aasworld).numareas];
aasarea->areanum = (*aasworld).numareas;
aasarea->numfaces = 0;
aasarea->firstface = (*aasworld).faceindexsize;
ClearBounds(aasarea->mins, aasarea->maxs);
VectorClear(aasarea->center);
//
// Log_Write("tmparea %d became aasarea %d\r\n", tmparea->areanum, aasarea->areanum);
//store the aas area number at the tmp area
tmparea->aasareanum = aasarea->areanum;
//
for (tmpface = tmparea->tmpfaces; tmpface; tmpface = tmpface->next[side])
{
side = tmpface->frontarea != tmparea;
//if there's an aas face created for the tmp face already
if (tmpface->aasfacenum)
{
//we're at the back of the face so use a negative index
aasfacenum = -tmpface->aasfacenum;
#ifdef DEBUG
if (tmpface->aasfacenum < 0 || tmpface->aasfacenum > max_aas.max_faces)
{
Error("AAS_CreateTree_r: face number out of range");
} //end if
#endif //DEBUG
aasface = &(*aasworld).faces[tmpface->aasfacenum];
aasface->backarea = aasarea->areanum;
} //end if
else
{
plane = &mapplanes[tmpface->planenum ^ side];
if (side)
{
w = tmpface->winding;
tmpface->winding = ReverseWinding(tmpface->winding);
} //end if
if (!AAS_GetFace(tmpface->winding, plane, 0, &aasfacenum))
{
continue;
}
if (side)
{
FreeWinding(tmpface->winding);
tmpface->winding = w;
} //end if
aasface = &(*aasworld).faces[aasfacenum];
aasface->frontarea = aasarea->areanum;
aasface->backarea = 0;
aasface->faceflags = tmpface->faceflags;
//set the face number at the tmp face
tmpface->aasfacenum = aasfacenum;
} //end else
//add face points to the area bounds and
//calculate the face 'center'
VectorClear(facecenter);
for (edgenum = 0; edgenum < aasface->numedges; edgenum++)
{
edge = &(*aasworld).edges[abs((*aasworld).edgeindex[aasface->firstedge + edgenum])];
for (i = 0; i < 2; i++)
{
AddPointToBounds((*aasworld).vertexes[edge->v[i]], aasarea->mins, aasarea->maxs);
VectorAdd((*aasworld).vertexes[edge->v[i]], facecenter, facecenter);
} //end for
} //end for
VectorScale(facecenter, 1.0 / (aasface->numedges * 2.0), facecenter);
//add the face 'center' to the area 'center'
VectorAdd(aasarea->center, facecenter, aasarea->center);
//
if ((*aasworld).faceindexsize >= max_aas.max_faceindexsize)
{
Error("AAS_MAX_FACEINDEXSIZE = %d", max_aas.max_faceindexsize);
} //end if
(*aasworld).faceindex[(*aasworld).faceindexsize++] = aasfacenum;
aasarea->numfaces++;
} //end for
//if the area has no faces at all (return 0, = solid leaf)
if (!aasarea->numfaces)
{
return 0;
}
//
VectorScale(aasarea->center, 1.0 / aasarea->numfaces, aasarea->center);
//Log_Write("area %d center %f %f %f\r\n", (*aasworld).numareas,
// aasarea->center[0], aasarea->center[1], aasarea->center[2]);
//store the area settings
AAS_StoreAreaSettings(tmparea->settings);
//
//Log_Write("tmp area %d became aas area %d\r\n", tmpareanum, aasarea->areanum);
qprintf("\r%6d", aasarea->areanum);
//
if ((*aasworld).areasettings[aasarea->areanum].contents & AREACONTENTS_CLUSTERPORTAL)
{
static int num;
Log_Write("***** area %d is a cluster portal %d\n", aasarea->areanum, num++);
} //end if
//
(*aasworld).numareas++;
return -((*aasworld).numareas - 1);
} //end of the function AAS_StoreArea
/*
=================
R_MarkFragments
=================
*/
int R_MarkFragments( int numPoints, const vec3_t *points, const vec3_t projection,
int maxPoints, vec3_t pointBuffer, int maxFragments, markFragment_t *fragmentBuffer )
{
int orientation = 0;
int numsurfaces, numPlanes;
int i, j, k, m, n;
surfaceType_t *surfaces[ 4096 ];
vec3_t mins, maxs;
int returnedFragments;
int returnedPoints;
vec3_t normals[ MAX_VERTS_ON_POLY + 2 ];
float dists[ MAX_VERTS_ON_POLY + 2 ];
vec3_t clipPoints[ 2 ][ MAX_VERTS_ON_POLY ];
int numClipPoints;
float *v;
srfSurfaceFace_t *surf;
srfGridMesh_t *cv;
drawVert_t *dv;
vec3_t normal;
vec3_t projectionDir;
vec3_t v1, v2;
int *indexes;
float radius;
vec3_t center; // center of original mark
//vec3_t bestCenter; // center point projected onto the closest surface
float texCoordScale;
//float dot;
qboolean oldMapping = qfalse;
//increment view count for double check prevention
tr.viewCount++;
// RF, negative maxFragments means we want original mapping
if ( maxFragments < 0 )
{
maxFragments = -maxFragments;
//return R_OldMarkFragments( numPoints, points, projection, maxPoints, pointBuffer, maxFragments, fragmentBuffer );
oldMapping = qtrue;
}
VectorClear( center );
for ( i = 0; i < numPoints; i++ )
{
VectorAdd( points[ i ], center, center );
}
VectorScale( center, 1.0 / numPoints, center );
//
radius = VectorNormalize2( projection, projectionDir ) / 2.0;
bestdist = 0;
VectorNegate( projectionDir, bestnormal );
// find all the brushes that are to be considered
ClearBounds( mins, maxs );
for ( i = 0; i < numPoints; i++ )
{
vec3_t temp;
AddPointToBounds( points[ i ], mins, maxs );
VectorMA( points[ i ], 1 * ( 1 + oldMapping * radius * 4 ), projection, temp );
AddPointToBounds( temp, mins, maxs );
// make sure we get all the leafs (also the one(s) in front of the hit surface)
VectorMA( points[ i ], -20 * ( 1.0 + ( float ) oldMapping * ( radius / 20.0 ) * 4 ), projectionDir, temp );
AddPointToBounds( temp, mins, maxs );
}
if ( numPoints > MAX_VERTS_ON_POLY )
{
numPoints = MAX_VERTS_ON_POLY;
}
// create the bounding planes for the to be projected polygon
for ( i = 0; i < numPoints; i++ )
{
VectorSubtract( points[( i + 1 ) % numPoints ], points[ i ], v1 );
VectorAdd( points[ i ], projection, v2 );
VectorSubtract( points[ i ], v2, v2 );
CrossProduct( v1, v2, normals[ i ] );
VectorNormalize( normals[ i ] );
dists[ i ] = DotProduct( normals[ i ], points[ i ] );
}
// add near and far clipping planes for projection
VectorCopy( projectionDir, normals[ numPoints ] );
dists[ numPoints ] = DotProduct( normals[ numPoints ], points[ 0 ] ) - radius * ( 1 + oldMapping * 10 );
VectorCopy( projectionDir, normals[ numPoints + 1 ] );
VectorInverse( normals[ numPoints + 1 ] );
dists[ numPoints + 1 ] = DotProduct( normals[ numPoints + 1 ], points[ 0 ] ) - radius * ( 1 + oldMapping * 10 );
numPlanes = numPoints + 2;
numsurfaces = 0;
R_BoxSurfaces_r( tr.world->nodes, mins, maxs, surfaces, 4096, &numsurfaces, projectionDir );
//assert(numsurfaces <= 64);
//assert(numsurfaces != 64);
texCoordScale = 0.5 * 1.0 / radius;
returnedPoints = 0;
returnedFragments = 0;
// find the closest surface to center the decal there, and wrap around other surfaces
if ( !oldMapping )
{
/*
for ( i = 0 ; i < numsurfaces ; i++ ) {
if (*surfaces[i] == SF_FACE) {
surf = ( srfSurfaceFace_t * ) surfaces[i];
// Ridah, check if this is the closest surface
dot = DotProduct( center, surf->plane.normal );
dot -= surf->plane.dist;
if (!bestdist) {
if (dot < 0)
bestdist = Q_fabs(dot) + 1000; // avoid this surface, since the point is behind it
else
bestdist = dot;
VectorCopy( surf->plane.normal, bestnormal );
VectorMA( center, -dot, surf->plane.normal, bestCenter );
} else if (dot >= 0 && dot < bestdist) {
bestdist = dot;
VectorCopy( surf->plane.normal, bestnormal );
VectorMA( center, -dot, surf->plane.normal, bestCenter );
}
}
}
// bestCenter is now the real center
VectorCopy( bestCenter, center );
Com_Printf("bestnormal: %1.1f %1.1f %1.1f \n", bestnormal[0], bestnormal[1], bestnormal[2] );
*/
VectorNegate( bestnormal, bestnormal );
}
for ( i = 0; i < numsurfaces; i++ )
{
if ( *surfaces[ i ] == SF_GRID )
{
cv = ( srfGridMesh_t * ) surfaces[ i ];
for ( m = 0; m < cv->height - 1; m++ )
{
for ( n = 0; n < cv->width - 1; n++ )
{
// We triangulate the grid and chop all triangles within
// the bounding planes of the to be projected polygon.
// LOD is not taken into account, not such a big deal though.
//
// It's probably much nicer to chop the grid itself and deal
// with this grid as a normal SF_GRID surface so LOD will
// be applied. However the LOD of that chopped grid must
// be synced with the LOD of the original curve.
// One way to do this; the chopped grid shares vertices with
// the original curve. When LOD is applied to the original
// curve the unused vertices are flagged. Now the chopped curve
// should skip the flagged vertices. This still leaves the
// problems with the vertices at the chopped grid edges.
//
// To avoid issues when LOD applied to "hollow curves" (like
// the ones around many jump pads) we now just add a 2 unit
// offset to the triangle vertices.
// The offset is added in the vertex normal vector direction
// so all triangles will still fit together.
// The 2 unit offset should avoid pretty much all LOD problems.
numClipPoints = 3;
dv = cv->verts + m * cv->width + n;
VectorCopy( dv[ 0 ].xyz, clipPoints[ 0 ][ 0 ] );
VectorMA( clipPoints[ 0 ][ 0 ], MARKER_OFFSET, dv[ 0 ].normal, clipPoints[ 0 ][ 0 ] );
VectorCopy( dv[ cv->width ].xyz, clipPoints[ 0 ][ 1 ] );
VectorMA( clipPoints[ 0 ][ 1 ], MARKER_OFFSET, dv[ cv->width ].normal, clipPoints[ 0 ][ 1 ] );
VectorCopy( dv[ 1 ].xyz, clipPoints[ 0 ][ 2 ] );
VectorMA( clipPoints[ 0 ][ 2 ], MARKER_OFFSET, dv[ 1 ].normal, clipPoints[ 0 ][ 2 ] );
// check the normal of this triangle
VectorSubtract( clipPoints[ 0 ][ 0 ], clipPoints[ 0 ][ 1 ], v1 );
VectorSubtract( clipPoints[ 0 ][ 2 ], clipPoints[ 0 ][ 1 ], v2 );
CrossProduct( v1, v2, normal );
VectorNormalize( normal );
if ( DotProduct( normal, projectionDir ) < -0.1 )
{
// add the fragments of this triangle
R_AddMarkFragments( numClipPoints, clipPoints,
numPlanes, normals, dists,
maxPoints, pointBuffer,
maxFragments, fragmentBuffer, &returnedPoints, &returnedFragments, mins, maxs );
if ( returnedFragments == maxFragments )
{
return returnedFragments; // not enough space for more fragments
}
}
VectorCopy( dv[ 1 ].xyz, clipPoints[ 0 ][ 0 ] );
VectorMA( clipPoints[ 0 ][ 0 ], MARKER_OFFSET, dv[ 1 ].normal, clipPoints[ 0 ][ 0 ] );
VectorCopy( dv[ cv->width ].xyz, clipPoints[ 0 ][ 1 ] );
VectorMA( clipPoints[ 0 ][ 1 ], MARKER_OFFSET, dv[ cv->width ].normal, clipPoints[ 0 ][ 1 ] );
VectorCopy( dv[ cv->width + 1 ].xyz, clipPoints[ 0 ][ 2 ] );
VectorMA( clipPoints[ 0 ][ 2 ], MARKER_OFFSET, dv[ cv->width + 1 ].normal, clipPoints[ 0 ][ 2 ] );
// check the normal of this triangle
VectorSubtract( clipPoints[ 0 ][ 0 ], clipPoints[ 0 ][ 1 ], v1 );
VectorSubtract( clipPoints[ 0 ][ 2 ], clipPoints[ 0 ][ 1 ], v2 );
CrossProduct( v1, v2, normal );
VectorNormalize( normal );
if ( DotProduct( normal, projectionDir ) < -0.05 )
{
// add the fragments of this triangle
R_AddMarkFragments( numClipPoints, clipPoints,
numPlanes, normals, dists,
maxPoints, pointBuffer,
maxFragments, fragmentBuffer, &returnedPoints, &returnedFragments, mins, maxs );
if ( returnedFragments == maxFragments )
{
return returnedFragments; // not enough space for more fragments
}
}
}
}
}
else if ( *surfaces[ i ] == SF_FACE )
{
extern float VectorDistance( vec3_t v1, vec3_t v2 );
vec3_t axis[ 3 ];
float texCoordScale, dot;
vec3_t originalPoints[ 4 ];
vec3_t newCenter, delta;
int oldNumPoints;
float epsilon = 0.5;
// duplicated so we don't mess with the original clips for the curved surfaces
vec3_t lnormals[ MAX_VERTS_ON_POLY + 2 ];
float ldists[ MAX_VERTS_ON_POLY + 2 ];
vec3_t lmins, lmaxs;
vec3_t surfnormal;
surf = ( srfSurfaceFace_t * ) surfaces[ i ];
if ( surf->plane.type == PLANE_NON_PLANAR )
{
VectorCopy( bestnormal, surfnormal );
}
else
{
VectorCopy( surf->plane.normal, surfnormal );
}
if ( !oldMapping )
{
// Ridah, create a new clip box such that this decal surface is mapped onto
// the current surface without distortion. To find the center of the new clip box,
// we project the center of the original impact center out along the projection vector,
// onto the current surface
if ( surf->plane.type == PLANE_NON_PLANAR )
{
VectorCopy( center, newCenter );
}
else
{
// find the center of the new decal
dot = DotProduct( center, surfnormal );
dot -= surf->plane.dist;
// check the normal of this face
if ( dot < -epsilon && DotProduct( surfnormal, projectionDir ) >= 0.01 )
{
continue;
}
else if ( Q_fabs( dot ) > radius )
{
continue;
}
// if the impact point is behind the surface, subtract the projection, otherwise add it
VectorMA( center, -dot, bestnormal, newCenter );
}
// recalc dot from the offset position
dot = DotProduct( newCenter, surfnormal );
dot -= surf->plane.dist;
VectorMA( newCenter, -dot, surfnormal, newCenter );
VectorMA( newCenter, MARKER_OFFSET, surfnormal, newCenter );
// create the texture axis
VectorNormalize2( surfnormal, axis[ 0 ] );
PerpendicularVector( axis[ 1 ], axis[ 0 ] );
RotatePointAroundVector( axis[ 2 ], axis[ 0 ], axis[ 1 ], ( float ) orientation );
CrossProduct( axis[ 0 ], axis[ 2 ], axis[ 1 ] );
texCoordScale = 0.5 * 1.0 / radius;
// create the full polygon
for ( j = 0; j < 3; j++ )
{
originalPoints[ 0 ][ j ] = newCenter[ j ] - radius * axis[ 1 ][ j ] - radius * axis[ 2 ][ j ];
originalPoints[ 1 ][ j ] = newCenter[ j ] + radius * axis[ 1 ][ j ] - radius * axis[ 2 ][ j ];
originalPoints[ 2 ][ j ] = newCenter[ j ] + radius * axis[ 1 ][ j ] + radius * axis[ 2 ][ j ];
originalPoints[ 3 ][ j ] = newCenter[ j ] - radius * axis[ 1 ][ j ] + radius * axis[ 2 ][ j ];
}
ClearBounds( lmins, lmaxs );
// create the bounding planes for the to be projected polygon
for ( j = 0; j < 4; j++ )
{
AddPointToBounds( originalPoints[ j ], lmins, lmaxs );
VectorSubtract( originalPoints[( j + 1 ) % numPoints ], originalPoints[ j ], v1 );
VectorSubtract( originalPoints[ j ], surfnormal, v2 );
VectorSubtract( originalPoints[ j ], v2, v2 );
CrossProduct( v1, v2, lnormals[ j ] );
VectorNormalize( lnormals[ j ] );
ldists[ j ] = DotProduct( lnormals[ j ], originalPoints[ j ] );
}
numPlanes = numPoints;
// done.
indexes = ( int * )( ( byte * ) surf + surf->ofsIndices );
for ( k = 0; k < surf->numIndices; k += 3 )
{
for ( j = 0; j < 3; j++ )
{
v = surf->points[ 0 ] + VERTEXSIZE * indexes[ k + j ];
VectorMA( v, MARKER_OFFSET, surfnormal, clipPoints[ 0 ][ j ] );
}
oldNumPoints = returnedPoints;
// add the fragments of this face
R_AddMarkFragments( 3, clipPoints,
numPlanes, lnormals, ldists,
maxPoints, pointBuffer,
maxFragments, fragmentBuffer, &returnedPoints, &returnedFragments, lmins, lmaxs );
if ( oldNumPoints != returnedPoints )
{
// flag this surface as already having computed ST's
fragmentBuffer[ returnedFragments - 1 ].numPoints *= -1;
// Ridah, calculate ST's
for ( j = 0; j < ( returnedPoints - oldNumPoints ); j++ )
{
VectorSubtract( ( float * ) pointBuffer + 5 * ( oldNumPoints + j ), newCenter, delta );
* ( ( float * ) pointBuffer + 5 * ( oldNumPoints + j ) + 3 ) =
0.5 + DotProduct( delta, axis[ 1 ] ) * texCoordScale;
* ( ( float * ) pointBuffer + 5 * ( oldNumPoints + j ) + 4 ) =
0.5 + DotProduct( delta, axis[ 2 ] ) * texCoordScale;
}
}
if ( returnedFragments == maxFragments )
{
return returnedFragments; // not enough space for more fragments
}
}
}
else
{
// old mapping
// check the normal of this face
// Arnout: wolf code was disabled, but differs from q3 code (maybe wolf one was broken and fixed in q3?):
/* if (DotProduct(surf->plane.normal, projectionDir) > -0.5) {
continue;
}*/
// Wolf code:
//if (DotProduct(surf->plane.normal, projectionDir) > 0.0) {
// continue;
//}
indexes = ( int * )( ( byte * ) surf + surf->ofsIndices );
for ( k = 0; k < surf->numIndices; k += 3 )
{
for ( j = 0; j < 3; j++ )
{
v = surf->points[ 0 ] + VERTEXSIZE * indexes[ k + j ];;
VectorMA( v, MARKER_OFFSET, surf->plane.normal, clipPoints[ 0 ][ j ] );
}
// add the fragments of this face
R_AddMarkFragments( 3, clipPoints,
numPlanes, normals, dists,
maxPoints, pointBuffer,
maxFragments, fragmentBuffer, &returnedPoints, &returnedFragments, mins, maxs );
if ( returnedFragments == maxFragments )
{
return returnedFragments; // not enough space for more fragments
}
}
}
continue;
}
// Arnout: projection on models (mainly for terrain though)
else if ( *surfaces[ i ] == SF_TRIANGLES )
{
#if 0
// duplicated so we don't mess with the original clips for the curved surfaces
vec3_t lnormals[ MAX_VERTS_ON_POLY + 2 ];
float ldists[ MAX_VERTS_ON_POLY + 2 ];
srfTriangles2_t *cts;
cts = ( srfTriangles2_t * ) surfaces[ i ];
if ( !oldMapping )
{
for ( k = 0; k < numPoints; k++ )
{
VectorNegate( normals[ k ], lnormals[ k ] );
ldists[ k ] = -dists[ k ];
}
VectorNegate( normals[ numPoints ], lnormals[ numPoints ] );
ldists[ numPoints ] = dists[ numPoints + 1 ];
VectorNegate( normals[ numPoints + 1 ], lnormals[ numPoints + 1 ] );
ldists[ numPoints + 1 ] = dists[ numPoints ];
indexes = cts->indexes;
for ( k = 0; k < cts->numIndexes; k += 3 )
{
for ( j = 0; j < 3; j++ )
{
VectorMA( cts->xyz[ indexes[ k + j ] ].v, MARKER_OFFSET, cts->normal[ indexes[ k + j ] ].v, clipPoints[ 0 ][ j ] );
}
// add the fragments of this face
R_AddMarkFragments( 3, clipPoints,
numPlanes, lnormals, ldists,
maxPoints, pointBuffer,
maxFragments, fragmentBuffer, &returnedPoints, &returnedFragments, mins, maxs );
if ( returnedFragments == maxFragments )
{
return returnedFragments; // not enough space for more fragments
}
}
}
else
{
indexes = cts->indexes;
for ( k = 0; k < cts->numIndexes; k += 3 )
{
for ( j = 0; j < 3; j++ )
{
VectorMA( cts->xyz[ indexes[ k + j ] ].v, MARKER_OFFSET, cts->normal[ indexes[ k + j ] ].v, clipPoints[ 0 ][ j ] );
}
// add the fragments of this face
R_AddMarkFragments( 3, clipPoints,
numPlanes, normals, dists,
maxPoints, pointBuffer,
maxFragments, fragmentBuffer, &returnedPoints, &returnedFragments, mins, maxs );
if ( returnedFragments == maxFragments )
{
return returnedFragments; // not enough space for more fragments
}
}
}
continue;
#else
// duplicated so we don't mess with the original clips for the curved surfaces
vec3_t lnormals[ MAX_VERTS_ON_POLY + 2 ];
float ldists[ MAX_VERTS_ON_POLY + 2 ];
//vec3_t lprojection, lprojectionDir;
srfTriangles_t *cts;
cts = ( srfTriangles_t * ) surfaces[ i ];
if ( !oldMapping )
{
/*VectorNegate( projection, lprojection );
VectorNormalize2( lprojection, lprojectionDir );
radius = VectorNormalize2( lprojection, lprojectionDir ) / 2.0;
// create the bounding planes for the to be projected polygon
for ( k = 0 ; k < numPoints ; k++ ) {
VectorSubtract(points[(k+1)%numPoints], points[k], v1);
VectorAdd(points[k], lprojection, v2);
VectorSubtract(points[k], v2, v2);
CrossProduct(v1, v2, lnormals[k]);
VectorNormalizeFast(lnormals[k]);
ldists[k] = DotProduct(lnormals[k], points[k]);
}
// add near and far clipping planes for projection
VectorCopy(lprojectionDir, lnormals[numPoints]);
ldists[numPoints] = DotProduct(lnormals[numPoints], points[0]) - radius;
VectorCopy(lprojectionDir, lnormals[numPoints+1]);
VectorInverse(lnormals[numPoints+1]);
ldists[numPoints+1] = DotProduct(lnormals[numPoints+1], points[0]) - radius; */
for ( k = 0; k < numPoints; k++ )
{
VectorCopy( normals[ k ], lnormals[ k ] );
ldists[ k ] = dists[ k ];
}
VectorCopy( normals[ numPoints ], lnormals[ numPoints ] );
ldists[ numPoints ] = dists[ numPoints ];
VectorCopy( normals[ numPoints + 1 ], lnormals[ numPoints + 1 ] );
ldists[ numPoints + 1 ] = dists[ numPoints + 1 ];
indexes = cts->indexes;
for ( k = 0; k < cts->numIndexes; k += 3 )
{
for ( j = 0; j < 3; j++ )
{
v = cts->verts[ indexes[ k + j ] ].xyz;
VectorMA( v, MARKER_OFFSET, cts->verts[ indexes[ k + j ] ].normal, clipPoints[ 0 ][ j ] );
}
// add the fragments of this face
R_AddMarkFragments( 3, clipPoints,
numPlanes, lnormals, ldists,
maxPoints, pointBuffer,
maxFragments, fragmentBuffer, &returnedPoints, &returnedFragments, mins, maxs );
if ( returnedFragments == maxFragments )
{
return returnedFragments; // not enough space for more fragments
}
}
}
else
{
/*
VectorSubtract(clipPoints[0][0], clipPoints[0][1], v1);
VectorSubtract(clipPoints[0][2], clipPoints[0][1], v2);
CrossProduct(v1, v2, normal);
VectorNormalize(normal);
if (DotProduct(normal, projectionDir) > -0.5) continue;
*/
indexes = cts->indexes;
for ( k = 0; k < cts->numIndexes; k += 3 )
{
for ( j = 0; j < 3; j++ )
{
v = cts->verts[ indexes[ k + j ] ].xyz;
VectorMA( v, MARKER_OFFSET, cts->verts[ indexes[ k + j ] ].normal, clipPoints[ 0 ][ j ] );
}
// add the fragments of this face
R_AddMarkFragments( 3, clipPoints,
numPlanes, normals, dists,
maxPoints, pointBuffer,
maxFragments, fragmentBuffer, &returnedPoints, &returnedFragments, mins, maxs );
if ( returnedFragments == maxFragments )
{
return returnedFragments; // not enough space for more fragments
}
}
}
continue;
#endif // 1
}
else
{
// ignore all other world surfaces
// might be cool to also project polygons on a triangle soup
// however this will probably create huge amounts of extra polys
// even more than the projection onto curves
continue;
}
}
return returnedFragments;
}
/*
============
ExpandBrush
=============
*/
void ExpandBrush (int hullnum)
{
int i, x, s;
vec3_t corner;
winding_t *w;
plane_t plane;
int j, k, numwindings;
vec_t r;
winding_t **windings;
plane_t clipplane, faceplane;
mface_t *mf;
vec3_t point;
vec3_t mins, maxs;
if (!numbrushfaces)
return;
num_hull_points = 0;
num_hull_edges = 0;
ClearBounds( mins, maxs );
// generate windings and bounds data
numwindings = 0;
windings = calloc(numbrushfaces, sizeof(*windings));
for (i = 0;i < numbrushfaces;i++)
{
mf = &faces[i];
windings[i] = NULL;
faceplane = mf->plane;
w = BaseWindingForPlane (&faceplane);
for (j = 0;j < numbrushfaces && w;j++)
{
clipplane = faces[j].plane;
if( j == i )
continue;
// flip the plane, because we want to keep the back side
VectorNegate(clipplane.normal, clipplane.normal);
clipplane.dist *= -1;
w = ClipWindingEpsilon (w, &clipplane, ON_EPSILON, true);
}
if (!w)
continue; // overcontrained plane
for (j = 0;j < w->numpoints;j++)
{
for (k = 0;k < 3;k++)
{
point[k] = w->points[j][k];
r = Q_rint(point[k]);
if ( fabs( point[k] - r ) < ZERO_EPSILON)
w->points[j][k] = r;
else
w->points[j][k] = point[k];
// check for incomplete brushes
if( w->points[j][k] >= BOGUS_RANGE || w->points[j][k] <= -BOGUS_RANGE )
return;
}
AddPointToBounds( w->points[j], mins, maxs );
}
windings[i] = w;
}
// add all of the corner offsets
for (i = 0;i < numwindings;i++)
{
w = windings[i];
for (j = 0;j < w->numpoints;j++)
AddHullPoint(w->points[j], hullnum);
}
// expand the face planes
for (i = 0;i < numbrushfaces;i++)
{
mf = &faces[i];
for (x=0 ; x<3 ; x++)
{
if (mf->plane.normal[x] > 0)
corner[x] = -hullinfo.hullsizes[hullnum][0][x];
else if (mf->plane.normal[x] < 0)
corner[x] = -hullinfo.hullsizes[hullnum][1][x];
}
mf->plane.dist += DotProduct (corner, mf->plane.normal);
}
// add any axis planes not contained in the brush to bevel off corners
for (x=0 ; x<3 ; x++)
for (s=-1 ; s<=1 ; s+=2)
{
// add the plane
VectorClear (plane.normal);
plane.normal[x] = s;
if (s == -1)
plane.dist = -mins[x] + hullinfo.hullsizes[hullnum][1][x];
else
plane.dist = maxs[x] + -hullinfo.hullsizes[hullnum][0][x];
AddBrushPlane (&plane);
}
// add all of the edge bevels
for (i = 0;i < numwindings;i++)
{
w = windings[i];
for (j = 0;j < w->numpoints;j++)
AddHullEdge(w->points[j], w->points[(j+1)%w->numpoints], hullnum);
}
// free the windings as we no longer need them
for (i = 0;i < numwindings;i++)
if (windings[i])
FreeWinding(windings[i]);
free(windings);
}
/*
===============
ParseTriSurf
===============
*/
static void ParseTriSurf( dsurface_t *ds, mapVert_t *verts, msurface_t *surf, int *indexes, world_t &worldData, int index ) {
srfTriangles_t *tri;
int i, j, k;
int numVerts, numIndexes;
// get fog volume
surf->fogIndex = LittleLong( ds->fogNum ) + 1;
if (index && !surf->fogIndex && tr.world && tr.world->globalFog != -1)
{
surf->fogIndex = worldData.globalFog;
}
// get shader
surf->shader = ShaderForShaderNum( ds->shaderNum, lightmapsVertex, ds->lightmapStyles, ds->vertexStyles, worldData );
if ( r_singleShader->integer && !surf->shader->sky ) {
surf->shader = tr.defaultShader;
}
numVerts = LittleLong( ds->numVerts );
numIndexes = LittleLong( ds->numIndexes );
if ( numVerts >= SHADER_MAX_VERTEXES ) {
Com_Error(ERR_DROP, "ParseTriSurf: verts > MAX (%d > %d) on misc_model %s", numVerts, SHADER_MAX_VERTEXES, surf->shader->name );
}
if ( numIndexes >= SHADER_MAX_INDEXES ) {
Com_Error(ERR_DROP, "ParseTriSurf: indices > MAX (%d > %d) on misc_model %s", numIndexes, SHADER_MAX_INDEXES, surf->shader->name );
}
tri = (srfTriangles_t *) Z_Malloc( sizeof( *tri ) + numVerts * sizeof( tri->verts[0] ) + numIndexes * sizeof( tri->indexes[0] ), TAG_HUNKMISCMODELS, qfalse );
tri->dlightBits = 0; //JIC
tri->surfaceType = SF_TRIANGLES;
tri->numVerts = numVerts;
tri->numIndexes = numIndexes;
tri->verts = (drawVert_t *)(tri + 1);
tri->indexes = (int *)(tri->verts + tri->numVerts );
surf->data = (surfaceType_t *)tri;
// copy vertexes
verts += LittleLong( ds->firstVert );
ClearBounds( tri->bounds[0], tri->bounds[1] );
for ( i = 0 ; i < numVerts ; i++ ) {
for ( j = 0 ; j < 3 ; j++ ) {
tri->verts[i].xyz[j] = LittleFloat( verts[i].xyz[j] );
tri->verts[i].normal[j] = LittleFloat( verts[i].normal[j] );
}
AddPointToBounds( tri->verts[i].xyz, tri->bounds[0], tri->bounds[1] );
for ( j = 0 ; j < 2 ; j++ ) {
tri->verts[i].st[j] = LittleFloat( verts[i].st[j] );
for(k=0;k<MAXLIGHTMAPS;k++)
{
tri->verts[i].lightmap[k][j] = LittleFloat( verts[i].lightmap[k][j] );
}
}
for(k=0;k<MAXLIGHTMAPS;k++)
{
R_ColorShiftLightingBytes( verts[i].color[k], tri->verts[i].color[k] );
}
}
// copy indexes
indexes += LittleLong( ds->firstIndex );
for ( i = 0 ; i < numIndexes ; i++ ) {
tri->indexes[i] = LittleLong( indexes[i] );
if ( tri->indexes[i] < 0 || tri->indexes[i] >= numVerts ) {
Com_Error( ERR_DROP, "Bad index in triangle surface" );
}
}
}
/*
RE_ProjectDecal()
creates a new decal projector from a triangle
projected polygons should be 3 or 4 points
if a single point is passed in (numPoints == 1) then the decal will be omnidirectional
omnidirectional decals use points[ 0 ] as center and projection[ 3 ] as radius
pass in lifeTime < 0 for a temporary mark
*/
void RE_ProjectDecal(qhandle_t hShader, int numPoints, vec3_t *points, vec4_t projection, vec4_t color, int lifeTime,
int fadeTime)
{
static int totalProjectors = 0;
int i;
float radius, iDist;
vec3_t xyz;
decalVert_t dv[4];
decalProjector_t *dp, temp;
if (r_numDecalProjectors >= MAX_DECAL_PROJECTORS)
{
Ren_Print("WARNING: RE_ProjectDecal() Max decal projectors reached (%d)\n", MAX_DECAL_PROJECTORS);
return;
}
// dummy check
if (numPoints != 1 && numPoints != 3 && numPoints != 4)
{
Ren_Warning("WARNING: Invalid number of decal points (%d)\n", numPoints);
return;
}
// early outs
if (lifeTime == 0)
{
return;
}
if (projection[3] <= 0.0f)
{
return;
}
// set times properly
if (lifeTime < 0 || fadeTime < 0)
{
lifeTime = 0;
fadeTime = 0;
}
// basic setup
temp.shader = R_GetShaderByHandle(hShader);
temp.color[0] = color[0] * 255;
temp.color[1] = color[1] * 255;
temp.color[2] = color[2] * 255;
temp.color[3] = color[3] * 255;
temp.numPlanes = numPoints + 2;
temp.fadeStartTime = tr.refdef.time + lifeTime - fadeTime; // FIXME: stale refdef time
temp.fadeEndTime = temp.fadeStartTime + fadeTime;
temp.projectorNum = 0;
// set up decal texcoords (FIXME: support arbitrary projector st coordinates in trapcall)
dv[0].st[0] = 0.0f;
dv[0].st[1] = 0.0f;
dv[1].st[0] = 0.0f;
dv[1].st[1] = 1.0f;
dv[2].st[0] = 1.0f;
dv[2].st[1] = 1.0f;
dv[3].st[0] = 1.0f;
dv[3].st[1] = 0.0f;
// omnidirectional?
if (numPoints == 1)
{
// set up omnidirectional
numPoints = 4;
temp.numPlanes = 6;
temp.omnidirectional = qtrue;
radius = projection[3];
Vector4Set(projection, 0.0f, 0.0f, -1.0f, radius * 2.0f);
iDist = 1.0f / (radius * 2.0f);
// set corner
VectorSet(xyz, points[0][0] - radius, points[0][1] - radius, points[0][2] + radius);
// make x axis texture matrix (yz)
VectorSet(temp.texMat[0][0], 0.0f, iDist, 0.0f);
temp.texMat[0][0][3] = -DotProduct(temp.texMat[0][0], xyz);
VectorSet(temp.texMat[0][1], 0.0f, 0.0f, iDist);
temp.texMat[0][1][3] = -DotProduct(temp.texMat[0][1], xyz);
// make y axis texture matrix (xz)
VectorSet(temp.texMat[1][0], iDist, 0.0f, 0.0f);
temp.texMat[1][0][3] = -DotProduct(temp.texMat[1][0], xyz);
VectorSet(temp.texMat[1][1], 0.0f, 0.0f, iDist);
temp.texMat[1][1][3] = -DotProduct(temp.texMat[1][1], xyz);
// make z axis texture matrix (xy)
VectorSet(temp.texMat[2][0], iDist, 0.0f, 0.0f);
temp.texMat[2][0][3] = -DotProduct(temp.texMat[2][0], xyz);
VectorSet(temp.texMat[2][1], 0.0f, iDist, 0.0f);
temp.texMat[2][1][3] = -DotProduct(temp.texMat[2][1], xyz);
// setup decal points
VectorSet(dv[0].xyz, points[0][0] - radius, points[0][1] - radius, points[0][2] + radius);
VectorSet(dv[1].xyz, points[0][0] - radius, points[0][1] + radius, points[0][2] + radius);
VectorSet(dv[2].xyz, points[0][0] + radius, points[0][1] + radius, points[0][2] + radius);
VectorSet(dv[3].xyz, points[0][0] + radius, points[0][1] - radius, points[0][2] + radius);
}
else
{
// set up unidirectional
temp.omnidirectional = qfalse;
// set up decal points
VectorCopy(points[0], dv[0].xyz);
VectorCopy(points[1], dv[1].xyz);
VectorCopy(points[2], dv[2].xyz);
VectorCopy(points[3], dv[3].xyz);
// make texture matrix
if (!MakeTextureMatrix(temp.texMat[0], projection, &dv[0], &dv[1], &dv[2]))
{
return;
}
}
// bound the projector
ClearBounds(temp.mins, temp.maxs);
for (i = 0; i < numPoints; i++)
{
AddPointToBounds(dv[i].xyz, temp.mins, temp.maxs);
VectorMA(dv[i].xyz, projection[3], projection, xyz);
AddPointToBounds(xyz, temp.mins, temp.maxs);
}
// make bounding sphere
VectorAdd(temp.mins, temp.maxs, temp.center);
VectorScale(temp.center, 0.5f, temp.center);
VectorSubtract(temp.maxs, temp.center, xyz);
temp.radius = VectorLength(xyz);
temp.radius2 = temp.radius * temp.radius;
// make the front plane
if (!PlaneFromPoints(temp.planes[0], dv[0].xyz, dv[1].xyz, dv[2].xyz))
{
return;
}
// make the back plane
VectorSubtract(vec3_origin, temp.planes[0], temp.planes[1]);
VectorMA(dv[0].xyz, projection[3], projection, xyz);
temp.planes[1][3] = DotProduct(xyz, temp.planes[1]);
// make the side planes
for (i = 0; i < numPoints; i++)
{
VectorMA(dv[i].xyz, projection[3], projection, xyz);
if (!PlaneFromPoints(temp.planes[i + 2], dv[(i + 1) % numPoints].xyz, dv[i].xyz, xyz))
{
return;
}
}
// create a new projector
dp = &backEndData->decalProjectors[r_numDecalProjectors];
Com_Memcpy(dp, &temp, sizeof(*dp));
dp->projectorNum = totalProjectors++;
// we have a winner
r_numDecalProjectors++;
}
static int MakeDecalProjector( int mapEntityNum, shaderInfo_t *si, vec4_t projection, float distance, int numVerts, bspDrawVert_t **dv, float backfacecull, float lightmapScale, vec3_t lightmapAxis, vec3_t minlight, vec3_t minvertexlight, vec3_t ambient, vec3_t colormod, int smoothNormals )
{
int i, j;
decalProjector_t *dp;
vec3_t xyz;
/* dummy check */
if( numVerts != 3 && numVerts != 4 )
return -1;
/* limit check */
if( numProjectors >= MAX_PROJECTORS )
{
Sys_Warning( mapEntityNum, "MAX_PROJECTORS (%d) exceeded, no more decal projectors available.", MAX_PROJECTORS );
return -2;
}
/* create a new projector */
dp = &projectors[ numProjectors ];
memset( dp, 0, sizeof( decalProjector_t ) );
/* basic setup */
dp->si = si;
dp->numPlanes = numVerts + 2;
dp->backfacecull = backfacecull;
dp->lightmapScale = lightmapScale;
VectorCopy( lightmapAxis, dp->lightmapAxis );
VectorCopy( minlight, dp->minlight );
VectorCopy( minvertexlight, dp->minvertexlight );
VectorCopy( ambient, dp->ambient );
VectorCopy( colormod, dp->colormod );
dp->smoothNormals = smoothNormals;
dp->mapEntityNum = mapEntityNum;
/* make texture matrix */
if( !MakeTextureMatrix( dp, projection, dv[ 0 ], dv[ 1 ], dv[ 2 ] ) )
return -1;
/* bound the projector */
ClearBounds( dp->mins, dp->maxs );
for( i = 0; i < numVerts; i++ )
{
AddPointToBounds( dv[ i ]->xyz, dp->mins, dp->maxs );
VectorMA( dv[ i ]->xyz, distance, projection, xyz );
AddPointToBounds( xyz, dp->mins, dp->maxs );
}
/* make bouding sphere */
VectorAdd( dp->mins, dp->maxs, dp->center );
VectorScale( dp->center, 0.5f, dp->center );
VectorSubtract( dp->maxs, dp->center, xyz );
dp->radius = VectorLength( xyz );
dp->radius2 = dp->radius * dp->radius;
/* make the front plane */
if( !PlaneFromPoints( dp->planes[ 0 ], dv[ 0 ]->xyz, dv[ 1 ]->xyz, dv[ 2 ]->xyz ) )
return -1;
/* make the back plane */
VectorSubtract( vec3_origin, dp->planes[ 0 ], dp->planes[ 1 ] );
VectorMA( dv[ 0 ]->xyz, distance, projection, xyz );
dp->planes[ 1 ][ 3 ] = DotProduct( xyz, dp->planes[ 1 ] );
/* make the side planes */
for( i = 0; i < numVerts; i++ )
{
j = (i + 1) % numVerts;
VectorMA( dv[ i ]->xyz, distance, projection, xyz );
if( !PlaneFromPoints( dp->planes[ i + 2 ], dv[ j ]->xyz, dv[ i ]->xyz, xyz ) )
return -1;
}
/* return ok */
numProjectors++;
return numProjectors - 1;
}
/*
============
BuildST
Builds the triangle_st array for the base frame and
model.skinwidth / model.skinheight
FIXME: allow this to be loaded from a file for
arbitrary mappings
============
*/
void BuildST (triangle_t *ptri, int numtri)
{
int i, j;
int width, height, iwidth, iheight, swidth;
float basex, basey;
float s_scale, t_scale;
float scale;
vec3_t mins, maxs;
float *pbasevert;
vec3_t vtemp1, vtemp2, normal;
//
// find bounds of all the verts on the base frame
//
ClearBounds (mins, maxs);
for (i=0 ; i<numtri ; i++)
for (j=0 ; j<3 ; j++)
AddPointToBounds (ptri[i].verts[j], mins, maxs);
for (i=0 ; i<3 ; i++)
{
mins[i] = floor(mins[i]);
maxs[i] = ceil(maxs[i]);
}
width = maxs[0] - mins[0];
height = maxs[2] - mins[2];
if (!g_fixedwidth)
{ // old style
scale = 8;
if (width*scale >= 150)
scale = 150.0 / width;
if (height*scale >= 190)
scale = 190.0 / height;
s_scale = t_scale = scale;
iwidth = ceil(width*s_scale);
iheight = ceil(height*t_scale);
iwidth += 4;
iheight += 4;
}
else
{ // new style
iwidth = g_fixedwidth / 2;
iheight = g_fixedheight;
s_scale = (float)(iwidth-4) / width;
t_scale = (float)(iheight-4) / height;
}
//
// determine which side of each triangle to map the texture to
//
for (i=0 ; i<numtri ; i++)
{
VectorSubtract (ptri[i].verts[0], ptri[i].verts[1], vtemp1);
VectorSubtract (ptri[i].verts[2], ptri[i].verts[1], vtemp2);
CrossProduct (vtemp1, vtemp2, normal);
if (normal[1] > 0)
{
basex = iwidth + 2;
}
else
{
basex = 2;
}
basey = 2;
for (j=0 ; j<3 ; j++)
{
pbasevert = ptri[i].verts[j];
triangle_st[i][j][0] = Q_rint((pbasevert[0] - mins[0]) * s_scale + basex);
triangle_st[i][j][1] = Q_rint((maxs[2] - pbasevert[2]) * t_scale + basey);
}
}
// make the width a multiple of 4; some hardware requires this, and it ensures
// dword alignment for each scan
swidth = iwidth*2;
model.skinwidth = (swidth + 3) & ~3;
model.skinheight = iheight;
}
void BeginModel( void ){
bspModel_t *mod;
brush_t *b;
entity_t *e;
vec3_t mins, maxs;
vec3_t lgMins, lgMaxs; /* ydnar: lightgrid mins/maxs */
parseMesh_t *p;
int i;
/* test limits */
if ( numBSPModels == MAX_MAP_MODELS ) {
Error( "MAX_MAP_MODELS" );
}
/* get model and entity */
mod = &bspModels[ numBSPModels ];
e = &entities[ mapEntityNum ];
/* ydnar: lightgrid mins/maxs */
ClearBounds( lgMins, lgMaxs );
/* bound the brushes */
ClearBounds( mins, maxs );
for ( b = e->brushes; b; b = b->next )
{
/* ignore non-real brushes (origin, etc) */
if ( b->numsides == 0 ) {
continue;
}
AddPointToBounds( b->mins, mins, maxs );
AddPointToBounds( b->maxs, mins, maxs );
/* ydnar: lightgrid bounds */
if ( b->compileFlags & C_LIGHTGRID ) {
AddPointToBounds( b->mins, lgMins, lgMaxs );
AddPointToBounds( b->maxs, lgMins, lgMaxs );
}
}
/* bound patches */
for ( p = e->patches; p; p = p->next )
{
for ( i = 0; i < ( p->mesh.width * p->mesh.height ); i++ )
AddPointToBounds( p->mesh.verts[i].xyz, mins, maxs );
}
/* ydnar: lightgrid mins/maxs */
if ( lgMins[ 0 ] < 99999 ) {
/* use lightgrid bounds */
VectorCopy( lgMins, mod->mins );
VectorCopy( lgMaxs, mod->maxs );
}
else
{
/* use brush/patch bounds */
VectorCopy( mins, mod->mins );
VectorCopy( maxs, mod->maxs );
}
/* note size */
Sys_FPrintf( SYS_VRB, "BSP bounds: { %f %f %f } { %f %f %f }\n", mins[ 0 ], mins[ 1 ], mins[ 2 ], maxs[ 0 ], maxs[ 1 ], maxs[ 2 ] );
Sys_FPrintf( SYS_VRB, "Lightgrid bounds: { %f %f %f } { %f %f %f }\n", lgMins[ 0 ], lgMins[ 1 ], lgMins[ 2 ], lgMaxs[ 0 ], lgMaxs[ 1 ], lgMaxs[ 2 ] );
/* set firsts */
mod->firstBSPSurface = numBSPDrawSurfaces;
mod->firstBSPBrush = numBSPBrushes;
}
/*
===============
GrabFrame
===============
*/
void GrabFrame (char *frame)
{
triangle_t *ptri;
int i, j;
trivert_t *ptrivert;
int num_tris;
char file1[1024];
frame_t *fr;
vertexnormals_t vnorms[MAX_VERTS];
int index_xyz;
char *framefile;
// the frame 'run1' will be looked for as either
// run.1 or run1.tri, so the new alias sequence save
// feature an be used
framefile = FindFrameFile (frame);
sprintf (file1, "%s/%s", cdarchive, framefile);
ExpandPathAndArchive (file1);
sprintf (file1, "%s/%s",cddir, framefile);
printf ("grabbing %s\n", file1);
if (model.num_frames >= MAX_FRAMES)
Error ("model.num_frames >= MAX_FRAMES");
fr = &g_frames[model.num_frames];
model.num_frames++;
strcpy (fr->name, frame);
//
// load the frame
//
if (do3ds)
Load3DSTriangleList (file1, &ptri, &num_tris);
else if(doobj)
LoadOBJTriangleList (file1, &ptri, &num_tris);
else
LoadTriangleList (file1, &ptri, &num_tris);
if (num_tris != model.num_tris)
Error ("%s: number of triangles doesn't match base frame\n", file1);
//
// allocate storage for the frame's vertices
//
ptrivert = fr->v;
for (i=0 ; i<model.num_xyz ; i++)
{
vnorms[i].numnormals = 0;
VectorClear (vnorms[i].normalsum);
}
ClearBounds (fr->mins, fr->maxs);
//
// store the frame's vertices in the same order as the base. This assumes the
// triangles and vertices in this frame are in exactly the same order as in the
// base
//
for (i=0 ; i<num_tris ; i++)
{
vec3_t vtemp1, vtemp2, normal;
float ftemp;
VectorSubtract (ptri[i].verts[0], ptri[i].verts[1], vtemp1);
VectorSubtract (ptri[i].verts[2], ptri[i].verts[1], vtemp2);
CrossProduct (vtemp1, vtemp2, normal);
VectorNormalize (normal, normal);
// rotate the normal so the model faces down the positive x axis
ftemp = normal[0];
normal[0] = -normal[1];
normal[1] = ftemp;
for (j=0 ; j<3 ; j++)
{
index_xyz = triangles[i].index_xyz[j];
// rotate the vertices so the model faces down the positive x axis
// also adjust the vertices to the desired origin
ptrivert[index_xyz].v[0] = ((-ptri[i].verts[j][1]) * scale_up) +
adjust[0];
ptrivert[index_xyz].v[1] = (ptri[i].verts[j][0] * scale_up) +
adjust[1];
ptrivert[index_xyz].v[2] = (ptri[i].verts[j][2] * scale_up) +
adjust[2];
AddPointToBounds (ptrivert[index_xyz].v, fr->mins, fr->maxs);
VectorAdd (vnorms[index_xyz].normalsum, normal, vnorms[index_xyz].normalsum);
vnorms[index_xyz].numnormals++;
}
}
//
// calculate the vertex normals, match them to the template list, and store the
// index of the best match
//
for (i=0 ; i<model.num_xyz ; i++)
{
int j;
vec3_t v;
float maxdot;
int maxdotindex;
int c;
c = vnorms[i].numnormals;
if (!c)
Error ("Vertex with no triangles attached");
VectorScale (vnorms[i].normalsum, 1.0/c, v);
VectorNormalize (v, v);
maxdot = -999999.0;
maxdotindex = -1;
for (j=0 ; j<NUMVERTEXNORMALS ; j++)
{
float dot;
dot = DotProduct (v, avertexnormals[j]);
if (dot > maxdot)
{
maxdot = dot;
maxdotindex = j;
}
}
ptrivert[i].lightnormalindex = maxdotindex;
}
free (ptri);
}
/*
=================
R_TraceLine
=================
*/
msurface_t *R_TransformedTraceLine( trace_t *tr, const vec3_t start, const vec3_t end, ref_entity_t *test, int umask )
{
ref_model_t *model;
r_fragmentframecount++; // for multi-check avoidance
// fill in a default trace
Mem_Set( tr, 0, sizeof( trace_t ));
trace_surface = NULL;
trace_umask = umask;
trace_fraction = 1;
VectorCopy( end, trace_impact );
Mem_Set( &trace_plane, 0, sizeof( trace_plane ));
ClearBounds( trace_absmins, trace_absmaxs );
AddPointToBounds( start, trace_absmins, trace_absmaxs );
AddPointToBounds( end, trace_absmins, trace_absmaxs );
model = test->model;
if( model )
{
if( model->type == mod_world || model->type == mod_brush )
{
mbrushmodel_t *bmodel = ( mbrushmodel_t * )model->extradata;
vec3_t temp, start_l, end_l, axis[3];
bool rotated = !Matrix3x3_Compare( test->axis, matrix3x3_identity );
// transform
VectorSubtract( start, test->origin, start_l );
VectorSubtract( end, test->origin, end_l );
if( rotated )
{
VectorCopy( start_l, temp );
Matrix3x3_Transform( test->axis, temp, start_l );
VectorCopy( end_l, temp );
Matrix3x3_Transform( test->axis, temp, end_l );
}
VectorCopy( start_l, trace_start );
VectorCopy( end_l, trace_end );
// world uses a recursive approach using BSP tree, submodels
// just walk the list of surfaces linearly
if( test->model->type == mod_world )
R_RecursiveHullCheck( bmodel->nodes, start_l, end_l );
else if( BoundsIntersect( model->mins, model->maxs, trace_absmins, trace_absmaxs ) )
R_TraceAgainstBmodel( bmodel );
// transform back
if( rotated && trace_fraction != 1 )
{
Matrix3x3_Transpose( axis, test->axis );
VectorCopy( tr->vecPlaneNormal, temp );
Matrix3x3_Transform( axis, temp, trace_plane.normal );
}
}
}
// calculate the impact plane, if any
if( trace_fraction < 1.0f )
{
VectorNormalize( trace_plane.normal );
trace_plane.dist = DotProduct( trace_plane.normal, trace_impact );
CategorizePlane( &trace_plane );
tr->flPlaneDist = trace_plane.dist;
VectorCopy( trace_plane.normal, tr->vecPlaneNormal );
tr->iContents = trace_surface->contents;
tr->pHit = (edict_t *)test;
}
tr->flFraction = trace_fraction;
VectorCopy( trace_impact, tr->vecEndPos );
return trace_surface;
}
void PatchMapDrawSurfs(entity_t * e)
{
int i, j, k, l, c1, c2;
parseMesh_t *pm;
parseMesh_t *check, *scan;
mapDrawSurface_t *ds;
int patchCount, groupCount;
bspDrawVert_t *v1, *v2;
vec3_t bounds[2];
byte *bordering;
/* ydnar: mac os x fails with these if not static */
static parseMesh_t *meshes[MAX_MAP_DRAW_SURFS];
static qb_t grouped[MAX_MAP_DRAW_SURFS];
static byte group[MAX_MAP_DRAW_SURFS];
/* note it */
Sys_FPrintf(SYS_VRB, "--- PatchMapDrawSurfs ---\n");
patchCount = 0;
for(pm = e->patches; pm; pm = pm->next)
{
meshes[patchCount] = pm;
patchCount++;
}
if(!patchCount)
{
return;
}
bordering = safe_malloc(patchCount * patchCount);
memset(bordering, 0, patchCount * patchCount);
// build the bordering matrix
for(k = 0; k < patchCount; k++)
{
bordering[k * patchCount + k] = 1;
for(l = k + 1; l < patchCount; l++)
{
check = meshes[k];
scan = meshes[l];
c1 = scan->mesh.width * scan->mesh.height;
v1 = scan->mesh.verts;
for(i = 0; i < c1; i++, v1++)
{
c2 = check->mesh.width * check->mesh.height;
v2 = check->mesh.verts;
for(j = 0; j < c2; j++, v2++)
{
if(fabs(v1->xyz[0] - v2->xyz[0]) < 1.0
&& fabs(v1->xyz[1] - v2->xyz[1]) < 1.0 && fabs(v1->xyz[2] - v2->xyz[2]) < 1.0)
{
break;
}
}
if(j != c2)
{
break;
}
}
if(i != c1)
{
// we have a connection
bordering[k * patchCount + l] = bordering[l * patchCount + k] = 1;
}
else
{
// no connection
bordering[k * patchCount + l] = bordering[l * patchCount + k] = 0;
}
}
}
/* build groups */
memset(grouped, 0, patchCount);
groupCount = 0;
for(i = 0; i < patchCount; i++)
{
/* get patch */
scan = meshes[i];
/* start a new group */
if(!grouped[i])
groupCount++;
/* recursively find all patches that belong in the same group */
memset(group, 0, patchCount);
GrowGroup_r(scan, i, patchCount, meshes, bordering, group);
/* bound them */
ClearBounds(bounds[0], bounds[1]);
for(j = 0; j < patchCount; j++)
{
if(group[j])
{
grouped[j] = qtrue;
check = meshes[j];
c1 = check->mesh.width * check->mesh.height;
v1 = check->mesh.verts;
for(k = 0; k < c1; k++, v1++)
AddPointToBounds(v1->xyz, bounds[0], bounds[1]);
}
}
/* debug code */
//% Sys_Printf( "Longest curve: %f Iterations: %d\n", scan->longestCurve, scan->maxIterations );
/* create drawsurf */
scan->grouped = qtrue;
ds = DrawSurfaceForMesh(e, scan, NULL); /* ydnar */
VectorCopy(bounds[0], ds->bounds[0]);
VectorCopy(bounds[1], ds->bounds[1]);
}
/* emit some statistics */
Sys_FPrintf(SYS_VRB, "%9d patches\n", patchCount);
Sys_FPrintf(SYS_VRB, "%9d patch LOD groups\n", groupCount);
}
/*
============
Brush_LoadEntity
============
*/
brushset_t *Brush_LoadEntity (entity_t *ent, int hullnum)
{
brush_t *b, *next, *water, *other;
mbrush_t *mbr;
int numbrushes, TotalBrushes = 0;
brushset_t *bset;
CurrEnt = ent;
bset = AllocOther (sizeof(brushset_t));
ClearBounds (bset);
numbrushes = 0;
other = water = NULL;
Message (MSGVERBOSE, "------ Brush_LoadEntity ------");
for (mbr = ent->brushes; mbr; mbr = mbr->next)
++TotalBrushes;
for (mbr = ent->brushes ; mbr ; mbr=mbr->next)
{
b = LoadBrush (mbr, hullnum);
if (!b)
continue;
numbrushes++;
if (b->contents != CONTENTS_SOLID)
{
b->next = water;
water = b;
}
else
{
b->next = other;
other = b;
}
AddToBounds (bset, b->mins);
AddToBounds (bset, b->maxs);
ShowBar(numbrushes, TotalBrushes);
}
ShowBar(-1, -1);
// add all of the water textures at the start
for (b=water ; b ; b=next)
{
next = b->next;
b->next = other;
other = b;
}
bset->brushes = other;
brushset = bset;
Message (MSGVERBOSE, "%6i brushes read",numbrushes);
return bset;
}
/**
* @brief R_LoadPSK
* @param[in,out] mod
* @param[in,out] buffer
* @param[in] bufferSize
* @param[in] modName
* @return
*/
qboolean R_LoadPSK(model_t *mod, void *buffer, int bufferSize, const char *modName)
{
int i, j, k;
memStream_t *stream = NULL;
axChunkHeader_t chunkHeader;
int numPoints;
axPoint_t *point;
axPoint_t *points = NULL;
int numVertexes;
axVertex_t *vertex;
axVertex_t *vertexes = NULL;
//int numSmoothGroups;
int numTriangles;
axTriangle_t *triangle;
axTriangle_t *triangles = NULL;
int numMaterials;
axMaterial_t *material;
axMaterial_t *materials = NULL;
int numReferenceBones;
axReferenceBone_t *refBone;
axReferenceBone_t *refBones = NULL;
int numWeights;
axBoneWeight_t *axWeight;
axBoneWeight_t *axWeights = NULL;
md5Model_t *md5;
md5Bone_t *md5Bone;
md5Weight_t *weight;
vec3_t boneOrigin;
quat_t boneQuat;
//mat4_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];
mat4_t unrealToQuake;
#define DeallocAll() Com_Dealloc(materials); \
Com_Dealloc(points); \
Com_Dealloc(vertexes); \
Com_Dealloc(triangles); \
Com_Dealloc(refBones); \
Com_Dealloc(axWeights); \
FreeMemStream(stream);
//MatrixSetupScale(unrealToQuake, 1, -1, 1);
mat4_from_angles(unrealToQuake, 0, 90, 0);
stream = AllocMemStream(buffer, bufferSize);
if (stream == NULL)
{
Ren_Warning("R_LoadPSK: can't allocate memory\n");
return qfalse;
}
GetChunkHeader(stream, &chunkHeader);
// check indent again
if (Q_stricmpn(chunkHeader.ident, "ACTRHEAD", 8))
{
Ren_Warning("R_LoadPSK: '%s' has wrong chunk indent ('%s' should be '%s')\n", modName, chunkHeader.ident, "ACTRHEAD");
DeallocAll();
return qfalse;
}
PrintChunkHeader(&chunkHeader);
mod->type = MOD_MD5;
mod->dataSize += sizeof(md5Model_t);
md5 = mod->md5 = ri.Hunk_Alloc(sizeof(md5Model_t), h_low);
// read points
GetChunkHeader(stream, &chunkHeader);
if (Q_stricmpn(chunkHeader.ident, "PNTS0000", 8))
{
Ren_Warning("R_LoadPSK: '%s' has wrong chunk indent ('%s' should be '%s')\n", modName, chunkHeader.ident, "PNTS0000");
DeallocAll();
return qfalse;
}
if (chunkHeader.dataSize != sizeof(axPoint_t))
{
Ren_Warning("R_LoadPSK: '%s' has wrong chunk dataSize ('%i' should be '%i')\n", modName, chunkHeader.dataSize, ( int ) sizeof(axPoint_t));
DeallocAll();
return qfalse;
}
PrintChunkHeader(&chunkHeader);
numPoints = chunkHeader.numData;
points = 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
// 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))
{
Ren_Warning("R_LoadPSK: '%s' has wrong chunk indent ('%s' should be '%s')\n", modName, chunkHeader.ident, "VTXW0000");
DeallocAll();
return qfalse;
}
if (chunkHeader.dataSize != sizeof(axVertex_t))
{
Ren_Warning("R_LoadPSK: '%s' has wrong chunk dataSize ('%i' should be '%i')\n", modName, chunkHeader.dataSize, ( int ) sizeof(axVertex_t));
DeallocAll();
return qfalse;
}
PrintChunkHeader(&chunkHeader);
numVertexes = chunkHeader.numData;
vertexes = Com_Allocate(numVertexes * sizeof(axVertex_t));
{
int tmpVertexInt = -1; // tmp vertex member values - MemStreamGet functions return -1 if they fail
// now we print a warning if they do or abort if pointIndex is invalid
for (i = 0, vertex = vertexes; i < numVertexes; i++, vertex++)
{
tmpVertexInt = MemStreamGetShort(stream);
if (tmpVertexInt < 0 || tmpVertexInt >= numPoints)
{
ri.Printf(PRINT_ERROR, "R_LoadPSK: '%s' has vertex with point index out of range (%i while max %i)\n", modName, tmpVertexInt, numPoints);
DeallocAll();
return qfalse;
}
vertex->pointIndex = tmpVertexInt;
tmpVertexInt = MemStreamGetShort(stream);
if (tmpVertexInt < 0)
{
Ren_Warning("R_LoadPSK: MemStream NULL or empty (vertex->unknownA)\n");
}
vertex->unknownA = tmpVertexInt;
vertex->st[0] = MemStreamGetFloat(stream);
if (vertex->st[0] == -1)
{
Ren_Warning("R_LoadPSK: MemStream possibly NULL or empty (vertex->st[0])\n");
}
vertex->st[1] = MemStreamGetFloat(stream);
if (vertex->st[1] == -1)
{
Ren_Warning("R_LoadPSK: MemStream possibly NULL or empty (vertex->st[1])\n");
}
tmpVertexInt = MemStreamGetC(stream);
if (tmpVertexInt < 0)
{
Ren_Warning("R_LoadPSK: MemStream NULL or empty (vertex->materialIndex)\n");
}
vertex->materialIndex = tmpVertexInt;
tmpVertexInt = MemStreamGetC(stream);
if (tmpVertexInt < 0)
{
Ren_Warning("R_LoadPSK: MemStream NULL or empty (vertex->materialIndex)\n");
}
vertex->reserved = tmpVertexInt;
tmpVertexInt = MemStreamGetShort(stream);
if (tmpVertexInt < 0)
{
Ren_Warning("R_LoadPSK: MemStream NULL or empty (vertex->materialIndex)\n");
}
vertex->unknownB = tmpVertexInt;
#if 0
Ren_Print("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))
{
Ren_Warning("R_LoadPSK: '%s' has wrong chunk indent ('%s' should be '%s')\n", modName, chunkHeader.ident, "FACE0000");
DeallocAll();
return qfalse;
}
if (chunkHeader.dataSize != sizeof(axTriangle_t))
{
Ren_Warning("R_LoadPSK: '%s' has wrong chunk dataSize ('%i' should be '%i')\n", modName, chunkHeader.dataSize, ( int ) sizeof(axTriangle_t));
DeallocAll();
return qfalse;
}
PrintChunkHeader(&chunkHeader);
numTriangles = chunkHeader.numData;
triangles = 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--)
{
tmpVertexInt = MemStreamGetShort(stream);
if (tmpVertexInt < 0)
{
Ren_Warning("R_LoadPSK: '%s' MemStream NULL or empty (triangle->indexes[%i])\n", modName, j);
DeallocAll();
return qfalse;
}
if (tmpVertexInt >= numVertexes)
{
Ren_Warning("R_LoadPSK: '%s' has triangle with vertex index out of range (%i while max %i)\n", modName, tmpVertexInt, numVertexes);
DeallocAll();
return qfalse;
}
triangle->indexes[j] = tmpVertexInt;
}
triangle->materialIndex = MemStreamGetC(stream);
triangle->materialIndex2 = MemStreamGetC(stream);
triangle->smoothingGroups = MemStreamGetLong(stream);
}
}
// read materials
GetChunkHeader(stream, &chunkHeader);
if (Q_stricmpn(chunkHeader.ident, "MATT0000", 8))
{
Ren_Warning("R_LoadPSK: '%s' has wrong chunk indent ('%s' should be '%s')\n", modName, chunkHeader.ident, "MATT0000");
DeallocAll();
return qfalse;
}
if (chunkHeader.dataSize != sizeof(axMaterial_t))
{
Ren_Warning("R_LoadPSK: '%s' has wrong chunk dataSize ('%i' should be '%i')\n", modName, chunkHeader.dataSize, ( int ) sizeof(axMaterial_t));
DeallocAll();
return qfalse;
}
PrintChunkHeader(&chunkHeader);
numMaterials = chunkHeader.numData;
materials = Com_Allocate(numMaterials * sizeof(axMaterial_t));
for (i = 0, material = materials; i < numMaterials; i++, material++)
{
(void) MemStreamRead(stream, material->name, sizeof(material->name));
Ren_Print("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 >= numMaterials)
{
Ren_Warning("R_LoadPSK: '%s' has vertex with material index out of range (%i while max %i)\n", modName, vertex->materialIndex, numMaterials);
DeallocAll();
return qfalse;
}
}
for (i = 0, triangle = triangles; i < numTriangles; i++, triangle++)
{
if (triangle->materialIndex >= numMaterials)
{
Ren_Warning("R_LoadPSK: '%s' has triangle with material index out of range (%i while max %i)\n", modName, triangle->materialIndex, numMaterials);
DeallocAll();
return qfalse;
}
}
// read reference bones
GetChunkHeader(stream, &chunkHeader);
if (Q_stricmpn(chunkHeader.ident, "REFSKELT", 8))
{
Ren_Warning("R_LoadPSK: '%s' has wrong chunk indent ('%s' should be '%s')\n", modName, chunkHeader.ident, "REFSKELT");
DeallocAll();
return qfalse;
}
if (chunkHeader.dataSize != sizeof(axReferenceBone_t))
{
Ren_Warning("R_LoadPSK: '%s' has wrong chunk dataSize ('%i' should be '%i')\n", modName, chunkHeader.dataSize, ( int ) sizeof(axReferenceBone_t));
DeallocAll();
return qfalse;
}
PrintChunkHeader(&chunkHeader);
numReferenceBones = chunkHeader.numData;
refBones = Com_Allocate(numReferenceBones * sizeof(axReferenceBone_t));
for (i = 0, refBone = refBones; i < numReferenceBones; i++, refBone++)
{
(void) MemStreamRead(stream, refBone->name, sizeof(refBone->name));
//Ren_Print("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
Ren_Print("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))
{
Ren_Warning("R_LoadPSK: '%s' has wrong chunk indent ('%s' should be '%s')\n", modName, chunkHeader.ident, "RAWWEIGHTS");
DeallocAll();
return qfalse;
}
if (chunkHeader.dataSize != sizeof(axBoneWeight_t))
{
Ren_Warning("R_LoadPSK: '%s' has wrong chunk dataSize ('%i' should be '%i')\n", modName, chunkHeader.dataSize, ( int ) sizeof(axBoneWeight_t));
DeallocAll();
return qfalse;
}
PrintChunkHeader(&chunkHeader);
numWeights = chunkHeader.numData;
axWeights = 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
Ren_Print("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)
{
Ren_Warning("R_LoadPSK: '%s' has no bones\n", modName);
DeallocAll();
return qfalse;
}
if (md5->numBones > MAX_BONES)
{
Ren_Warning("R_LoadPSK: '%s' has more than %i bones (%i)\n", modName, MAX_BONES, md5->numBones);
DeallocAll();
return qfalse;
}
//Ren_Print("R_LoadPSK: '%s' has %i bones\n", modName, md5->numBones);
// copy all reference bones
md5->bones = 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;
}
//Ren_Print("R_LoadPSK: '%s' has bone '%s' with parent index %i\n", modName, md5Bone->name, md5Bone->parentIndex);
if (md5Bone->parentIndex >= md5->numBones)
{
DeallocAll();
Ren_Drop("R_LoadPSK: '%s' has bone '%s' with bad parent index %i while numBones is %i", modName,
md5Bone->name, md5Bone->parentIndex, md5->numBones);
}
for (j = 0; j < 3; j++)
{
boneOrigin[j] = refBone->bone.position[j];
}
// 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);
quat_copy(boneQuat, md5Bone->rotation);
//QuatClear(md5Bone->rotation);
#if 0
Ren_Print("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);
quat_copy(quat, md5Bone->rotation);
}
MatrixSetupTransformFromQuat(md5Bone->inverseTransform, md5Bone->rotation, md5Bone->origin);
mat4_inverse_self(md5Bone->inverseTransform);
#if 0
Ren_Print("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 = 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)
{
DeallocAll();
Ren_Drop("R_LoadPSK: vertex %i requires more weights %i than the maximum of %i in model '%s'", i, vboVert->numWeights, MAX_WEIGHTS, modName);
//Ren_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 = 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 = 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
Ren_Print("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 = Com_Allocate(sizeof(*sortTri));
for (j = 0; j < 3; j++)
{
sortTri->indexes[j] = triangle->indexes[j];
sortTri->vertexes[j] = 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 = { 0, 0, 0 };
vec3_t binormal;
vec3_t normal;
for (j = 0; j < vboVertexes.currentElements; j++)
{
v0 = Com_GrowListElement(&vboVertexes, j);
VectorClear(v0->tangent);
VectorClear(v0->binormal);
VectorClear(v0->normal);
}
for (j = 0; j < sortedTriangles.currentElements; j++)
{
skelTriangle_t *tri = Com_GrowListElement(&sortedTriangles, j);
v0 = Com_GrowListElement(&vboVertexes, tri->indexes[0]);
v1 = Com_GrowListElement(&vboVertexes, tri->indexes[1]);
v2 = 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 = 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 = 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 (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 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 (r_smoothNormals->integer & FLAGS_SMOOTH_MDM) // do another extra smoothing for normals to avoid flat shading
{
md5Vertex_t *v0, *v1;
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);
}
}
// split the surfaces into VBO surfaces by the maximum number of GPU vertex skinning bones
Com_InitGrowList(&vboSurfaces, 10);
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 = 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)
{
Ren_Print("R_LoadPSK: referenced bone: '%s'\n", (j < numReferenceBones) ? refBones[j].name : NULL);
}
}
if (!vboTriangles.currentElements)
{
Ren_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 = Com_GrowListElement(&sortedTriangles, j);
Com_Dealloc(sortTri);
}
Com_DestroyGrowList(&sortedTriangles);
for (j = 0; j < vboVertexes.currentElements; j++)
{
md5Vertex_t *v = Com_GrowListElement(&vboVertexes, j);
Com_Dealloc(v);
}
Com_DestroyGrowList(&vboVertexes);
// 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);
DeallocAll();
Ren_Developer("%i VBO surfaces created for PSK model '%s'\n", md5->numVBOSurfaces, modName);
return qtrue;
}
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
void AAS_FixMapBrush(mapbrush_t *brush)
{
int i, j, planenum;
float dist;
winding_t *w;
plane_t *plane, *plane1, *plane2;
side_t *side;
vec3_t normal;
//calculate the brush bounds
ClearBounds(brush->mins, brush->maxs);
for (i = 0; i < brush->numsides; i++)
{
plane = &mapplanes[brush->original_sides[i].planenum];
w = BaseWindingForPlane(plane->normal, plane->dist);
for (j = 0; j < brush->numsides && w; j++)
{
if (i == j) continue;
//there are no brush bevels marked but who cares :)
if (brush->original_sides[j].flags & SFL_BEVEL) continue;
plane = &mapplanes[brush->original_sides[j].planenum^1];
ChopWindingInPlace(&w, plane->normal, plane->dist, 0); //CLIP_EPSILON);
} //end for
side = &brush->original_sides[i];
side->winding = w;
if (w)
{
for (j = 0; j < w->numpoints; j++)
{
AddPointToBounds(w->p[j], brush->mins, brush->maxs);
} //end for
} //end if
} //end for
//
for (i = 0; i < brush->numsides; i++)
{
for (j = 0; j < brush->numsides; j++)
{
if (i == j) continue;
plane1 = &mapplanes[brush->original_sides[i].planenum];
plane2 = &mapplanes[brush->original_sides[j].planenum];
if (WindingsNonConvex(brush->original_sides[i].winding,
brush->original_sides[j].winding,
plane1->normal, plane2->normal,
plane1->dist, plane2->dist))
{
Log_Print("non convex brush");
} //end if
} //end for
} //end for
//NOW close the f*****g brush!!
for (i = 0; i < 3; i++)
{
if (brush->mins[i] < -MAX_MAP_BOUNDS)
{
VectorClear(normal);
normal[i] = -1;
dist = MAX_MAP_BOUNDS - 10;
planenum = FindFloatPlane(normal, dist);
//
Log_Print("mins out of range: added extra brush side\n");
AAS_AddMapBrushSide(brush, planenum);
} //end if
if (brush->maxs[i] > MAX_MAP_BOUNDS)
{
VectorClear(normal);
normal[i] = 1;
dist = MAX_MAP_BOUNDS - 10;
planenum = FindFloatPlane(normal, dist);
//
Log_Print("maxs out of range: added extra brush side\n");
AAS_AddMapBrushSide(brush, planenum);
} //end if
if (brush->mins[i] > MAX_MAP_BOUNDS || brush->maxs[i] < -MAX_MAP_BOUNDS)
{
Log_Print("entity %i, brush %i: no visible sides on brush\n", brush->entitynum, brush->brushnum);
} //end if
} //end for
//free all the windings
FreeBrushWindings(brush);
} //end of the function AAS_FixMapBrush
void FogDrawSurfaces( entity_t *e )
{
int i, j, k, fogNum;
fog_t *fog;
mapDrawSurface_t *ds;
vec3_t mins, maxs;
int fogged, numFogged;
int numBaseDrawSurfs;
/* note it */
Sys_FPrintf( SYS_VRB, "----- FogDrawSurfs -----\n" );
/* reset counters */
numFogged = 0;
numFogFragments = 0;
/* walk fog list */
for( fogNum = 0; fogNum < numMapFogs; fogNum++ )
{
/* get fog */
fog = &mapFogs[ fogNum ];
/* clip each surface into this, but don't clip any of the resulting fragments to the same brush */
numBaseDrawSurfs = numMapDrawSurfs;
for( i = 0; i < numBaseDrawSurfs; i++ )
{
/* get the drawsurface */
ds = &mapDrawSurfs[ i ];
/* no fog? */
if( ds->shaderInfo->noFog )
continue;
/* global fog doesn't have a brush */
if( fog->brush == NULL )
{
/* don't re-fog already fogged surfaces */
if( ds->fogNum >= 0 )
continue;
fogged = 1;
}
else
{
/* find drawsurface bounds */
ClearBounds( mins, maxs );
for( j = 0; j < ds->numVerts; j++ )
AddPointToBounds( ds->verts[ j ].xyz, mins, maxs );
/* check against the fog brush */
for( k = 0; k < 3; k++ )
{
if( mins[ k ] > fog->brush->maxs[ k ] )
break;
if( maxs[ k ] < fog->brush->mins[ k ] )
break;
}
/* no intersection? */
if( k < 3 )
continue;
/* ydnar: gs mods: handle the various types of surfaces */
switch( ds->type )
{
/* handle brush faces */
case SURFACE_FACE:
fogged = ChopFaceSurfaceByBrush( e, ds, fog->brush );
break;
/* handle patches */
case SURFACE_PATCH:
fogged = ChopPatchSurfaceByBrush( e, ds, fog->brush );
break;
/* handle triangle surfaces (fixme: split triangle surfaces) */
case SURFACE_TRIANGLES:
case SURFACE_FORCED_META:
case SURFACE_META:
fogged = 1;
break;
/* no fogging */
default:
fogged = 0;
break;
}
}
/* is this surface fogged? */
if( fogged )
{
numFogged += fogged;
ds->fogNum = fogNum;
}
}
}
/* emit some statistics */
Sys_FPrintf( SYS_VRB, "%9d fog polygon fragments\n", numFogFragments );
Sys_FPrintf( SYS_VRB, "%9d fog patch fragments\n", numFogPatchFragments );
Sys_FPrintf( SYS_VRB, "%9d fogged drawsurfs\n", numFogged );
}
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
qboolean AAS_MakeBrushWindings(mapbrush_t *ob)
{
int i, j;
winding_t *w;
side_t *side;
plane_t *plane, *plane1, *plane2;
ClearBounds (ob->mins, ob->maxs);
for (i = 0; i < ob->numsides; i++)
{
plane = &mapplanes[ob->original_sides[i].planenum];
w = BaseWindingForPlane(plane->normal, plane->dist);
for (j = 0; j <ob->numsides && w; j++)
{
if (i == j) continue;
if (ob->original_sides[j].flags & SFL_BEVEL) continue;
plane = &mapplanes[ob->original_sides[j].planenum^1];
ChopWindingInPlace(&w, plane->normal, plane->dist, 0); //CLIP_EPSILON);
}
side = &ob->original_sides[i];
side->winding = w;
if (w)
{
side->flags |= SFL_VISIBLE;
for (j = 0; j < w->numpoints; j++)
AddPointToBounds (w->p[j], ob->mins, ob->maxs);
}
}
//check if the brush is convex
for (i = 0; i < ob->numsides; i++)
{
for (j = 0; j < ob->numsides; j++)
{
if (i == j) continue;
plane1 = &mapplanes[ob->original_sides[i].planenum];
plane2 = &mapplanes[ob->original_sides[j].planenum];
if (WindingsNonConvex(ob->original_sides[i].winding,
ob->original_sides[j].winding,
plane1->normal, plane2->normal,
plane1->dist, plane2->dist))
{
Log_Print("non convex brush");
} //end if
} //end for
} //end for
//check for out of bound brushes
for (i = 0; i < 3; i++)
{
//IDBUG: all the indexes into the mins and maxs were zero (not using i)
if (ob->mins[i] < -MAX_MAP_BOUNDS || ob->maxs[i] > MAX_MAP_BOUNDS)
{
Log_Print("entity %i, brush %i: bounds out of range\n", ob->entitynum, ob->brushnum);
Log_Print("ob->mins[%d] = %f, ob->maxs[%d] = %f\n", i, ob->mins[i], i, ob->maxs[i]);
ob->numsides = 0; //remove the brush
break;
} //end if
if (ob->mins[i] > MAX_MAP_BOUNDS || ob->maxs[i] < -MAX_MAP_BOUNDS)
{
Log_Print("entity %i, brush %i: no visible sides on brush\n", ob->entitynum, ob->brushnum);
Log_Print("ob->mins[%d] = %f, ob->maxs[%d] = %f\n", i, ob->mins[i], i, ob->maxs[i]);
ob->numsides = 0; //remove the brush
break;
} //end if
} //end for
return true;
} //end of the function AAS_MakeBrushWindings
/*
=================
R_MarkFragments
=================
*/
int R_MarkFragments( int numPoints, const vec3_t *points, const vec3_t projection,
int maxPoints, vec3_t pointBuffer, int maxFragments, markFragment_t *fragmentBuffer ) {
int numsurfaces, numPlanes;
int i, j, k, m, n;
surfaceType_t *surfaces[64];
vec3_t mins, maxs;
int returnedFragments;
int returnedPoints;
vec3_t normals[MAX_VERTS_ON_POLY+2];
float dists[MAX_VERTS_ON_POLY+2];
vec3_t clipPoints[2][MAX_VERTS_ON_POLY];
int numClipPoints;
float *v;
srfSurfaceFace_t *surf;
srfGridMesh_t *cv;
drawVert_t *dv;
vec3_t normal;
vec3_t projectionDir;
vec3_t v1, v2;
int *indexes;
//increment view count for double check prevention
tr.viewCount++;
//
VectorNormalize2( projection, projectionDir );
// find all the brushes that are to be considered
ClearBounds( mins, maxs );
for ( i = 0 ; i < numPoints ; i++ ) {
vec3_t temp;
AddPointToBounds( points[i], mins, maxs );
VectorAdd( points[i], projection, temp );
AddPointToBounds( temp, mins, maxs );
// make sure we get all the leafs (also the one(s) in front of the hit surface)
VectorMA( points[i], -20, projectionDir, temp );
AddPointToBounds( temp, mins, maxs );
}
if (numPoints > MAX_VERTS_ON_POLY) numPoints = MAX_VERTS_ON_POLY;
// create the bounding planes for the to be projected polygon
for ( i = 0 ; i < numPoints ; i++ ) {
VectorSubtract(points[(i+1)%numPoints], points[i], v1);
VectorAdd(points[i], projection, v2);
VectorSubtract(points[i], v2, v2);
CrossProduct(v1, v2, normals[i]);
VectorNormalizeFast(normals[i]);
dists[i] = DotProduct(normals[i], points[i]);
}
// add near and far clipping planes for projection
VectorCopy(projectionDir, normals[numPoints]);
dists[numPoints] = DotProduct(normals[numPoints], points[0]) - 32;
VectorCopy(projectionDir, normals[numPoints+1]);
VectorInverse(normals[numPoints+1]);
dists[numPoints+1] = DotProduct(normals[numPoints+1], points[0]) - 20;
numPlanes = numPoints + 2;
numsurfaces = 0;
R_BoxSurfaces_r(tr.world->nodes, mins, maxs, surfaces, 64, &numsurfaces, projectionDir);
//assert(numsurfaces <= 64);
//assert(numsurfaces != 64);
returnedPoints = 0;
returnedFragments = 0;
for ( i = 0 ; i < numsurfaces ; i++ ) {
if (*surfaces[i] == SF_GRID) {
cv = (srfGridMesh_t *) surfaces[i];
for ( m = 0 ; m < cv->height - 1 ; m++ ) {
for ( n = 0 ; n < cv->width - 1 ; n++ ) {
// We triangulate the grid and chop all triangles within
// the bounding planes of the to be projected polygon.
// LOD is not taken into account, not such a big deal though.
//
// It's probably much nicer to chop the grid itself and deal
// with this grid as a normal SF_GRID surface so LOD will
// be applied. However the LOD of that chopped grid must
// be synced with the LOD of the original curve.
// One way to do this; the chopped grid shares vertices with
// the original curve. When LOD is applied to the original
// curve the unused vertices are flagged. Now the chopped curve
// should skip the flagged vertices. This still leaves the
// problems with the vertices at the chopped grid edges.
//
// To avoid issues when LOD applied to "hollow curves" (like
// the ones around many jump pads) we now just add a 2 unit
// offset to the triangle vertices.
// The offset is added in the vertex normal vector direction
// so all triangles will still fit together.
// The 2 unit offset should avoid pretty much all LOD problems.
numClipPoints = 3;
dv = cv->verts + m * cv->width + n;
VectorCopy(dv[0].xyz, clipPoints[0][0]);
VectorMA(clipPoints[0][0], MARKER_OFFSET, dv[0].normal, clipPoints[0][0]);
VectorCopy(dv[cv->width].xyz, clipPoints[0][1]);
VectorMA(clipPoints[0][1], MARKER_OFFSET, dv[cv->width].normal, clipPoints[0][1]);
VectorCopy(dv[1].xyz, clipPoints[0][2]);
VectorMA(clipPoints[0][2], MARKER_OFFSET, dv[1].normal, clipPoints[0][2]);
// check the normal of this triangle
VectorSubtract(clipPoints[0][0], clipPoints[0][1], v1);
VectorSubtract(clipPoints[0][2], clipPoints[0][1], v2);
CrossProduct(v1, v2, normal);
VectorNormalizeFast(normal);
if (DotProduct(normal, projectionDir) < -0.1) {
// add the fragments of this triangle
R_AddMarkFragments(numClipPoints, clipPoints,
numPlanes, normals, dists,
maxPoints, pointBuffer,
maxFragments, fragmentBuffer,
&returnedPoints, &returnedFragments, mins, maxs);
if ( returnedFragments == maxFragments ) {
return returnedFragments; // not enough space for more fragments
}
}
VectorCopy(dv[1].xyz, clipPoints[0][0]);
VectorMA(clipPoints[0][0], MARKER_OFFSET, dv[1].normal, clipPoints[0][0]);
VectorCopy(dv[cv->width].xyz, clipPoints[0][1]);
VectorMA(clipPoints[0][1], MARKER_OFFSET, dv[cv->width].normal, clipPoints[0][1]);
VectorCopy(dv[cv->width+1].xyz, clipPoints[0][2]);
VectorMA(clipPoints[0][2], MARKER_OFFSET, dv[cv->width+1].normal, clipPoints[0][2]);
// check the normal of this triangle
VectorSubtract(clipPoints[0][0], clipPoints[0][1], v1);
VectorSubtract(clipPoints[0][2], clipPoints[0][1], v2);
CrossProduct(v1, v2, normal);
VectorNormalizeFast(normal);
if (DotProduct(normal, projectionDir) < -0.05) {
// add the fragments of this triangle
R_AddMarkFragments(numClipPoints, clipPoints,
numPlanes, normals, dists,
maxPoints, pointBuffer,
maxFragments, fragmentBuffer,
&returnedPoints, &returnedFragments, mins, maxs);
if ( returnedFragments == maxFragments ) {
return returnedFragments; // not enough space for more fragments
}
}
}
}
}
else if (*surfaces[i] == SF_FACE) {
surf = ( srfSurfaceFace_t * ) surfaces[i];
// check the normal of this face
if (DotProduct(surf->plane.normal, projectionDir) > -0.5) {
continue;
}
/*
VectorSubtract(clipPoints[0][0], clipPoints[0][1], v1);
VectorSubtract(clipPoints[0][2], clipPoints[0][1], v2);
CrossProduct(v1, v2, normal);
VectorNormalize(normal);
if (DotProduct(normal, projectionDir) > -0.5) continue;
*/
indexes = (int *)( (byte *)surf + surf->ofsIndices );
for ( k = 0 ; k < surf->numIndices ; k += 3 ) {
for ( j = 0 ; j < 3 ; j++ ) {
v = surf->points[0] + VERTEXSIZE * indexes[k+j];;
VectorMA( v, MARKER_OFFSET, surf->plane.normal, clipPoints[0][j] );
}
// add the fragments of this face
R_AddMarkFragments( 3 , clipPoints,
numPlanes, normals, dists,
maxPoints, pointBuffer,
maxFragments, fragmentBuffer,
&returnedPoints, &returnedFragments, mins, maxs);
if ( returnedFragments == maxFragments ) {
return returnedFragments; // not enough space for more fragments
}
}
continue;
}
else {
// ignore all other world surfaces
// might be cool to also project polygons on a triangle soup
// however this will probably create huge amounts of extra polys
// even more than the projection onto curves
continue;
}
}
return returnedFragments;
}
void RE_ProjectDecal( qhandle_t hShader, int numPoints, vec3_t *points, vec4_t projection, vec4_t color, int lifeTime, int fadeTime ) {
int i;
float radius, iDist;
vec3_t xyz;
vec4_t omniProjection;
decalVert_t dv[ 4 ];
decalProjector_t *dp, temp;
/* first frame rendered does not have a valid decals list */
if ( tr.refdef.decalProjectors == NULL ) {
return;
}
/* dummy check */
if ( numPoints != 1 && numPoints != 3 && numPoints != 4 ) {
ri.Printf( PRINT_WARNING, "WARNING: Invalid number of decal points (%d)\n", numPoints );
return;
}
/* early outs */
if ( lifeTime == 0 ) {
return;
}
if ( projection[ 3 ] <= 0.0f ) {
return;
}
/* set times properly */
if ( lifeTime < 0 || fadeTime < 0 ) {
lifeTime = 0;
fadeTime = 0;
}
/* basic setup */
temp.shader = R_GetShaderByHandle( hShader ); /* debug code */ temp.numPlanes = temp.shader->entityMergable;
temp.color[ 0 ] = color[ 0 ] * 255;
temp.color[ 1 ] = color[ 1 ] * 255;
temp.color[ 2 ] = color[ 2 ] * 255;
temp.color[ 3 ] = color[ 3 ] * 255;
temp.numPlanes = numPoints + 2;
temp.fadeStartTime = tr.refdef.time + lifeTime - fadeTime;
temp.fadeEndTime = temp.fadeStartTime + fadeTime;
/* set up decal texcoords (fixme: support arbitrary projector st coordinates in trapcall) */
dv[ 0 ].st[ 0 ] = 0.0f;
dv[ 0 ].st[ 1 ] = 0.0f;
dv[ 1 ].st[ 0 ] = 0.0f;
dv[ 1 ].st[ 1 ] = 1.0f;
dv[ 2 ].st[ 0 ] = 1.0f;
dv[ 2 ].st[ 1 ] = 1.0f;
dv[ 3 ].st[ 0 ] = 1.0f;
dv[ 3 ].st[ 1 ] = 0.0f;
/* omnidirectional? */
if ( numPoints == 1 ) {
/* set up omnidirectional */
numPoints = 4;
temp.numPlanes = 6;
temp.omnidirectional = qtrue;
radius = projection[ 3 ];
Vector4Set( omniProjection, 0.0f, 0.0f, -1.0f, radius * 2.0f );
projection = omniProjection;
iDist = 1.0f / ( radius * 2.0f );
/* set corner */
VectorSet( xyz, points[ 0 ][ 0 ] - radius, points[ 0 ][ 1 ] - radius, points[ 0 ][ 2 ] + radius );
/* make x axis texture matrix (yz) */
VectorSet( temp.texMat[ 0 ][ 0 ], 0.0f, iDist, 0.0f );
temp.texMat[ 0 ][ 0 ][ 3 ] = -DotProduct( temp.texMat[ 0 ][ 0 ], xyz );
VectorSet( temp.texMat[ 0 ][ 1 ], 0.0f, 0.0f, iDist );
temp.texMat[ 0 ][ 1 ][ 3 ] = -DotProduct( temp.texMat[ 0 ][ 1 ], xyz );
/* make y axis texture matrix (xz) */
VectorSet( temp.texMat[ 1 ][ 0 ], iDist, 0.0f, 0.0f );
temp.texMat[ 1 ][ 0 ][ 3 ] = -DotProduct( temp.texMat[ 1 ][ 0 ], xyz );
VectorSet( temp.texMat[ 1 ][ 1 ], 0.0f, 0.0f, iDist );
temp.texMat[ 1 ][ 1 ][ 3 ] = -DotProduct( temp.texMat[ 1 ][ 1 ], xyz );
/* make z axis texture matrix (xy) */
VectorSet( temp.texMat[ 2 ][ 0 ], iDist, 0.0f, 0.0f );
temp.texMat[ 2 ][ 0 ][ 3 ] = -DotProduct( temp.texMat[ 2 ][ 0 ], xyz );
VectorSet( temp.texMat[ 2 ][ 1 ], 0.0f, iDist, 0.0f );
temp.texMat[ 2 ][ 1 ][ 3 ] = -DotProduct( temp.texMat[ 2 ][ 1 ], xyz );
/* setup decal points */
VectorSet( dv[ 0 ].xyz, points[ 0 ][ 0 ] - radius, points[ 0 ][ 1 ] - radius, points[ 0 ][ 2 ] + radius );
VectorSet( dv[ 1 ].xyz, points[ 0 ][ 0 ] - radius, points[ 0 ][ 1 ] + radius, points[ 0 ][ 2 ] + radius );
VectorSet( dv[ 2 ].xyz, points[ 0 ][ 0 ] + radius, points[ 0 ][ 1 ] + radius, points[ 0 ][ 2 ] + radius );
VectorSet( dv[ 3 ].xyz, points[ 0 ][ 0 ] + radius, points[ 0 ][ 1 ] - radius, points[ 0 ][ 2 ] + radius );
} else
{
/* set up unidirectional */
temp.omnidirectional = qfalse;
/* set up decal points */
VectorCopy( points[ 0 ], dv[ 0 ].xyz );
VectorCopy( points[ 1 ], dv[ 1 ].xyz );
VectorCopy( points[ 2 ], dv[ 2 ].xyz );
VectorCopy( points[ 3 ], dv[ 3 ].xyz );
/* make texture matrix */
if ( !MakeTextureMatrix( temp.texMat[ 0 ], projection, &dv[ 0 ], &dv[ 1 ], &dv[ 2 ] ) ) {
return;
}
}
/* bound the projector */
ClearBounds( temp.mins, temp.maxs );
for ( i = 0; i < numPoints; i++ )
{
AddPointToBounds( dv[ i ].xyz, temp.mins, temp.maxs );
VectorMA( dv[ i ].xyz, projection[ 3 ], projection, xyz );
AddPointToBounds( xyz, temp.mins, temp.maxs );
}
/* make bounding sphere */
VectorAdd( temp.mins, temp.maxs, temp.center );
VectorScale( temp.center, 0.5f, temp.center );
VectorSubtract( temp.maxs, temp.center, xyz );
temp.radius = VectorLength( xyz );
temp.radius2 = temp.radius * temp.radius;
/* frustum cull the projector (fixme: this uses a stale frustum!) */
if ( R_CullPointAndRadius( temp.center, temp.radius ) == CULL_OUT ) {
return;
}
/* make the front plane */
if ( !PlaneFromPoints( temp.planes[ 0 ], dv[ 0 ].xyz, dv[ 1 ].xyz, dv[ 2 ].xyz ) ) {
return;
}
/* make the back plane */
VectorSubtract( vec3_origin, temp.planes[ 0 ], temp.planes[ 1 ] );
VectorMA( dv[ 0 ].xyz, projection[ 3 ], projection, xyz );
temp.planes[ 1 ][ 3 ] = DotProduct( xyz, temp.planes[ 1 ] );
/* make the side planes */
for ( i = 0; i < numPoints; i++ )
{
VectorMA( dv[ i ].xyz, projection[ 3 ], projection, xyz );
if ( !PlaneFromPoints( temp.planes[ i + 2 ], dv[ ( i + 1 ) % numPoints ].xyz, dv[ i ].xyz, xyz ) ) {
return;
}
}
/* create a new projector */
dp = &tr.refdef.decalProjectors[ r_numDecalProjectors & DECAL_PROJECTOR_MASK ];
Com_Memcpy( dp, &temp, sizeof( *dp ) );
/* we have a winner */
r_numDecalProjectors++;
}
/*
===================
CM_GeneratePatchCollide
Creates an internal structure that will be used to perform
collision detection with a patch mesh.
Points is packed as concatenated rows.
===================
*/
struct patchCollide_s *CM_GeneratePatchCollide( int width, int height, vec3_t *points ) {
patchCollide_t *pf;
cGrid_t grid;
int i, j;
if ( width <= 2 || height <= 2 || !points ) {
Com_Error( ERR_DROP, "CM_GeneratePatchFacets: bad parameters: (%i, %i, %p)",
width, height, (void *)points );
}
if ( !( width & 1 ) || !( height & 1 ) ) {
Com_Error( ERR_DROP, "CM_GeneratePatchFacets: even sizes are invalid for quadratic meshes" );
}
if ( width > MAX_GRID_SIZE || height > MAX_GRID_SIZE ) {
Com_Error( ERR_DROP, "CM_GeneratePatchFacets: source is > MAX_GRID_SIZE" );
}
// build a grid
grid.width = width;
grid.height = height;
grid.wrapWidth = qfalse;
grid.wrapHeight = qfalse;
for ( i = 0 ; i < width ; i++ ) {
for ( j = 0 ; j < height ; j++ ) {
VectorCopy( points[j * width + i], grid.points[i][j] );
}
}
// subdivide the grid
CM_SetGridWrapWidth( &grid );
CM_SubdivideGridColumns( &grid );
CM_RemoveDegenerateColumns( &grid );
CM_TransposeGrid( &grid );
CM_SetGridWrapWidth( &grid );
CM_SubdivideGridColumns( &grid );
CM_RemoveDegenerateColumns( &grid );
// we now have a grid of points exactly on the curve
// the aproximate surface defined by these points will be
// collided against
pf = Hunk_Alloc( sizeof( *pf ), h_high );
ClearBounds( pf->bounds[0], pf->bounds[1] );
for ( i = 0 ; i < grid.width ; i++ ) {
for ( j = 0 ; j < grid.height ; j++ ) {
AddPointToBounds( grid.points[i][j], pf->bounds[0], pf->bounds[1] );
}
}
c_totalPatchBlocks += ( grid.width - 1 ) * ( grid.height - 1 );
// generate a bsp tree for the surface
CM_PatchCollideFromGrid( &grid, pf );
// expand by one unit for epsilon purposes
pf->bounds[0][0] -= 1;
pf->bounds[0][1] -= 1;
pf->bounds[0][2] -= 1;
pf->bounds[1][0] += 1;
pf->bounds[1][1] += 1;
pf->bounds[1][2] += 1;
return pf;
}
/*
=================
R_CreateSurfaceGridMesh
=================
*/
srfGridMesh_t *R_CreateSurfaceGridMesh(int width, int height,
srfVert_t ctrl[MAX_GRID_SIZE][MAX_GRID_SIZE], float errorTable[2][MAX_GRID_SIZE],
int numTriangles, srfTriangle_t triangles[(MAX_GRID_SIZE - 1) * (MAX_GRID_SIZE - 1) * 2])
{
int i, j, size;
srfVert_t *vert;
vec3_t tmpVec;
srfGridMesh_t *grid;
// copy the results out to a grid
size = (width * height - 1) * sizeof(srfVert_t) + sizeof(*grid);
#ifdef PATCH_STITCHING
grid = /*ri.Hunk_Alloc*/ ri.Z_Malloc(size);
Com_Memset(grid, 0, size);
grid->widthLodError = /*ri.Hunk_Alloc*/ ri.Z_Malloc(width * 4);
memcpy(grid->widthLodError, errorTable[0], width * 4);
grid->heightLodError = /*ri.Hunk_Alloc*/ ri.Z_Malloc(height * 4);
memcpy(grid->heightLodError, errorTable[1], height * 4);
grid->numTriangles = numTriangles;
grid->triangles = ri.Z_Malloc(grid->numTriangles * sizeof(srfTriangle_t));
Com_Memcpy(grid->triangles, triangles, numTriangles * sizeof(srfTriangle_t));
grid->numVerts = (width * height);
grid->verts = ri.Z_Malloc(grid->numVerts * sizeof(srfVert_t));
#else
grid = ri.Hunk_Alloc(size, h_low);
memset(grid, 0, size);
grid->widthLodError = ri.Hunk_Alloc(width * 4, h_low);
memcpy(grid->widthLodError, errorTable[0], width * 4);
grid->heightLodError = ri.Hunk_Alloc(height * 4, h_low);
memcpy(grid->heightLodError, errorTable[1], height * 4);
grid->numTriangles = numTriangles;
grid->triangles = ri.Hunk_Alloc(grid->numTriangles * sizeof(srfTriangle_t), h_low);
Com_Memcpy(grid->triangles, triangles, numTriangles * sizeof(srfTriangle_t));
grid->numVerts = (width * height);
grid->verts = ri.Hunk_Alloc(grid->numVerts * sizeof(srfVert_t), h_low);
#endif
grid->width = width;
grid->height = height;
grid->surfaceType = SF_GRID;
ClearBounds(grid->meshBounds[0], grid->meshBounds[1]);
for (i = 0 ; i < width ; i++)
{
for (j = 0 ; j < height ; j++)
{
vert = &grid->verts[j * width + i];
*vert = ctrl[j][i];
AddPointToBounds(vert->xyz, grid->meshBounds[0], grid->meshBounds[1]);
}
}
// compute local origin and bounds
VectorAdd(grid->meshBounds[0], grid->meshBounds[1], grid->localOrigin);
VectorScale(grid->localOrigin, 0.5f, grid->localOrigin);
VectorSubtract(grid->meshBounds[0], grid->localOrigin, tmpVec);
grid->meshRadius = VectorLength(tmpVec);
VectorCopy(grid->localOrigin, grid->lodOrigin);
grid->lodRadius = grid->meshRadius;
//
return grid;
}
