void G2API_AddSkinGore(CGhoul2Info_v &ghoul2,SSkinGoreData &gore)
{
if (VectorLength(gore.rayDirection)<.1f)
{
assert(0); // can't add gore without a shot direction
return;
}
// make sure we have transformed the whole skeletons for each model
G2_ConstructGhoulSkeleton(ghoul2, gore.currentTime, NULL, true, gore.angles, gore.position, gore.scale, false);
// pre generate the world matrix - used to transform the incoming ray
G2_GenerateWorldMatrix(gore.angles, gore.position);
// first up, translate the ray to model space
vec3_t transRayDirection, transHitLocation;
TransformAndTranslatePoint(gore.hitLocation, transHitLocation, &worldMatrixInv);
TransformPoint(gore.rayDirection, transRayDirection, &worldMatrixInv);
int lod;
ResetGoreTag();
for (lod=0;lod<4;lod++)
{
// now having done that, time to build the model
// FIXME: where does G2VertSpaceServer come from?
// G2_TransformModel(ghoul2, gore.currentTime, gore.scale,G2VertSpaceServer, lod,true);
// now walk each model and compute new texture coordinates
G2_TraceModels(ghoul2, transHitLocation, transRayDirection, 0, gore.entNum, 0, lod);
}
}
void G2API_CollisionDetect(CollisionRecord_t *collRecMap, CGhoul2Info_v &ghoul2, const vec3_t angles, const vec3_t position,
int frameNumber, int entNum, vec3_t rayStart, vec3_t rayEnd, vec3_t scale, CMiniHeap *G2VertSpace, int traceFlags, int useLod)
{
if ((int)&ghoul2)
{
vec3_t transRayStart, transRayEnd;
// make sure we have transformed the whole skeletons for each model
G2_ConstructGhoulSkeleton(ghoul2, frameNumber, NULL, true, angles, position, scale, false);
// pre generate the world matrix - used to transform the incoming ray
G2_GenerateWorldMatrix(angles, position);
// now having done that, time to build the model
G2_TransformModel(ghoul2, frameNumber, scale, G2VertSpace, useLod);
// model is built. Lets check to see if any triangles are actually hit.
// first up, translate the ray to model space
TransformAndTranslatePoint(rayStart, transRayStart, &worldMatrixInv);
TransformAndTranslatePoint(rayEnd, transRayEnd, &worldMatrixInv);
// now walk each model and check the ray against each poly - sigh, this is SO expensive. I wish there was a better way to do this.
G2_TraceModels(ghoul2, transRayStart, transRayEnd, collRecMap, entNum, traceFlags, useLod);
// now sort the resulting array of collision records so they are distance ordered
qsort( collRecMap, MAX_G2_COLLISIONS,
sizeof( CCollisionRecord ), QsortDistance );
}
}
qboolean G2API_GetBoltMatrix_SPMethod(CGhoul2Info_v &ghoul2, const int modelIndex, const int boltIndex, mdxaBone_t *matrix, const vec3_t angles,
const vec3_t position, const int frameNum, qhandle_t *modelList, const vec3_t scale )
{
assert(ghoul2.size() > modelIndex);
if ((int)&ghoul2 && (ghoul2.size() > modelIndex))
{
CGhoul2Info *ghlInfo = &ghoul2[modelIndex];
//assert(boltIndex < ghlInfo->mBltlist.size());
if (ghlInfo && (boltIndex < ghlInfo->mBltlist.size()) && boltIndex >= 0 )
{
// make sure we have transformed the skeleton
if (!gG2_GBMNoReconstruct)
{
G2_ConstructGhoulSkeleton(ghoul2, frameNum, modelList, true, angles, position, scale, false);
}
gG2_GBMNoReconstruct = qfalse;
mdxaBone_t scaled;
mdxaBone_t *use;
use=&ghlInfo->mBltlist[boltIndex].position;
if (scale[0]||scale[1]||scale[2])
{
scaled=*use;
use=&scaled;
// scale the bolt position by the scale factor for this model since at this point its still in model space
if (scale[0])
{
scaled.matrix[0][3] *= scale[0];
}
if (scale[1])
{
scaled.matrix[1][3] *= scale[1];
}
if (scale[2])
{
scaled.matrix[2][3] *= scale[2];
}
}
// pre generate the world matrix
G2_GenerateWorldMatrix(angles, position);
VectorNormalize((float*)use->matrix[0]);
VectorNormalize((float*)use->matrix[1]);
VectorNormalize((float*)use->matrix[2]);
Multiply_3x4Matrix(matrix, &worldMatrix, use);
return qtrue;
}
}
return qfalse;
}
void G2API_CollisionDetect(CollisionRecord_t *collRecMap, g2handle_t g2h, const vec3_t angles, const vec3_t position, int frameNumber, int entNum, const vec3_t rayStart, const vec3_t rayEnd, const vec3_t scale, CMiniHeap *G2VertSpace, int traceFlags, int useLod, float fRadius)
{
CGhoul2Info_v *ghoul2 = G2API_GetGhoul2Model(g2h);
if (ghoul2)
{
vec3_t transRayStart, transRayEnd;
// make sure we have transformed the whole skeletons for each model
G2_ConstructGhoulSkeleton(*ghoul2, frameNumber, NULL, true, angles, position, scale, false);
// pre generate the world matrix - used to transform the incoming ray
G2_GenerateWorldMatrix(angles, position);
#ifdef G2_COLLISION_ENABLED
G2VertSpace->ResetHeap();
#endif
// now having done that, time to build the model
G2_TransformModel(*ghoul2, frameNumber, scale, G2VertSpace, useLod);
// model is built. Lets check to see if any triangles are actually hit.
// first up, translate the ray to model space
TransformAndTranslatePoint(rayStart, transRayStart, &worldMatrixInv);
TransformAndTranslatePoint(rayEnd, transRayEnd, &worldMatrixInv);
// now walk each model and check the ray against each poly - sigh, this is SO expensive. I wish there was a better way to do this.
G2_TraceModels(*ghoul2, transRayStart, transRayEnd, collRecMap, entNum, traceFlags, useLod, fRadius);
#ifdef G2_COLLISION_ENABLED
int i;
for ( i = 0; i < MAX_G2_COLLISIONS && collRecMap[i].mEntityNum != -1; i ++ );
// now sort the resulting array of collision records so they are distance ordered
qsort( collRecMap, i,
sizeof( CCollisionRecord ), QsortDistance );
#else
// now sort the resulting array of collision records so they are distance ordered
qsort( collRecMap, MAX_G2_COLLISIONS,
sizeof( CCollisionRecord ), QsortDistance );
#endif
}
}
qboolean G2API_GetBoltMatrix(CGhoul2Info_v &ghoul2, const int modelIndex, const int boltIndex, mdxaBone_t *matrix, const vec3_t angles, const vec3_t position, const int frameNum, qhandle_t *modelList, vec3_t scale )
{
assert(ghoul2.size() > modelIndex);
if (gG2_GBMUseSPMethod)
{
gG2_GBMUseSPMethod = qfalse;
return G2API_GetBoltMatrix_SPMethod(ghoul2, modelIndex, boltIndex, matrix, angles, position, frameNum, modelList, scale);
}
if ((int)&ghoul2 && (ghoul2.size() > modelIndex))
{
CGhoul2Info *ghlInfo = &ghoul2[modelIndex];
//assert(boltIndex < ghlInfo->mBltlist.size());
if (ghlInfo && (boltIndex < ghlInfo->mBltlist.size()) && boltIndex >= 0 )
{
// make sure we have transformed the skeleton
if (!gG2_GBMNoReconstruct)
{
G2_ConstructGhoulSkeleton(ghoul2, frameNum, modelList, true, angles, position, scale, false);
}
gG2_GBMNoReconstruct = qfalse;
mdxaBone_t scaled;
mdxaBone_t *use;
use=&ghlInfo->mBltlist[boltIndex].position;
if (scale[0]||scale[1]||scale[2])
{
scaled=*use;
use=&scaled;
// scale the bolt position by the scale factor for this model since at this point its still in model space
if (scale[0])
{
scaled.matrix[0][3] *= scale[0];
}
if (scale[1])
{
scaled.matrix[1][3] *= scale[1];
}
if (scale[2])
{
scaled.matrix[2][3] *= scale[2];
}
}
// pre generate the world matrix
G2_GenerateWorldMatrix(angles, position);
// for some reason we get the end matrix rotated by 90 degrees
mdxaBone_t rotMat, tempMatrix;
vec3_t newangles = {0,270,0};
Create_Matrix(newangles, &rotMat);
// make the model space matrix we have for this bolt into a world matrix
// Multiply_3x4Matrix(matrix, &worldMatrix,use);
Multiply_3x4Matrix(&tempMatrix, &worldMatrix,use);
vec3_t origin;
origin[0] = tempMatrix.matrix[0][3];
origin[1] = tempMatrix.matrix[1][3];
origin[2] = tempMatrix.matrix[2][3];
tempMatrix.matrix[0][3] = tempMatrix.matrix[1][3] = tempMatrix.matrix[2][3] = 0;
Multiply_3x4Matrix(matrix, &tempMatrix, &rotMat);
matrix->matrix[0][3] = origin[0];
matrix->matrix[1][3] = origin[1];
matrix->matrix[2][3] = origin[2];
return qtrue;
}
}
return qfalse;
}
qboolean G2API_GetBoltMatrix_SPMethod(g2handle_t g2h, const int modelIndex, const int boltIndex, mdxaBone_t *matrix, const vec3_t angles,
const vec3_t position, const int frameNum, const qhandle_t *modelList, const vec3_t scale )
{
CGhoul2Info_v *ghoul2 = G2API_GetGhoul2Model(g2h);
if (ghoul2 && (unsigned)modelIndex < ghoul2->size())
{
CGhoul2Info &ghlInfo = (*ghoul2)[modelIndex];
//assert(boltIndex < ghlInfo->mBltlist.size());
if ((unsigned)boltIndex < ghlInfo.mBltlist.size())
{
// make sure we have transformed the skeleton
if (ghlInfo.mSkelFrameNum != frameNum)
{
// make sure it's initialized even if noreconstruct is on
if (!gG2_GBMNoReconstruct || ghlInfo.mSkelFrameNum == -1)
{
G2_ConstructGhoulSkeleton(*ghoul2, frameNum, modelList, true, angles, position, scale, false);
}
}
gG2_GBMNoReconstruct = qfalse;
mdxaBone_t scaled;
mdxaBone_t *use;
use = &ghlInfo.mBltlist[boltIndex].position;
if (scale[0]||scale[1]||scale[2])
{
scaled=*use;
use=&scaled;
// scale the bolt position by the scale factor for this model since at this point its still in model space
if (scale[0])
{
scaled.matrix[0][3] *= scale[0];
}
if (scale[1])
{
scaled.matrix[1][3] *= scale[1];
}
if (scale[2])
{
scaled.matrix[2][3] *= scale[2];
}
}
// pre generate the world matrix
G2_GenerateWorldMatrix(angles, position);
VectorNormalize((float*)use->matrix[0]);
VectorNormalize((float*)use->matrix[1]);
VectorNormalize((float*)use->matrix[2]);
Multiply_3x4Matrix(matrix, &worldMatrix, use);
return qtrue;
}
}
return qfalse;
}