// set a named surface offFlags - if it doesn't find a surface with this name in the list then it will add one.
qboolean G2_SetSurfaceOnOff (CGhoul2Info *ghlInfo, surfaceInfo_v &slist, const char *surfaceName, const int offFlags)
{
int surfIndex = -1;
surfaceInfo_t temp_slist_entry;
mdxmSurface_t *surf;
// find the model we want
model_t *mod = (model_t *)ghlInfo->currentModel;
// did we find a ghoul 2 model or not?
if (!mod->mdxm)
{
assert(0);
return qfalse;
}
// first find if we already have this surface in the list
surf = G2_FindSurface(ghlInfo, slist, surfaceName, &surfIndex);
if (surf)
{
// set descendants value
// slist[surfIndex].offFlags = offFlags;
// seems to me that we shouldn't overwrite the other flags.
// the only bit we really care about in the incoming flags is the off bit
slist[surfIndex].offFlags &= ~(G2SURFACEFLAG_OFF | G2SURFACEFLAG_NODESCENDANTS);
slist[surfIndex].offFlags |= offFlags & (G2SURFACEFLAG_OFF | G2SURFACEFLAG_NODESCENDANTS);
return qtrue;
}
else
{
// ok, not in the list already - in that case, lets verify this surface exists in the model mesh
int flags;
int surfaceNum = G2_IsSurfaceLegal((void*)mod, surfaceName, &flags);
if (surfaceNum != -1)
{
int newflags = flags;
// the only bit we really care about in the incoming flags is the off bit
newflags &= ~(G2SURFACEFLAG_OFF | G2SURFACEFLAG_NODESCENDANTS);
newflags |= offFlags & (G2SURFACEFLAG_OFF | G2SURFACEFLAG_NODESCENDANTS);
if (newflags != flags)
{ // insert here then because it changed, no need to add an override otherwise
temp_slist_entry.offFlags = newflags;
temp_slist_entry.surface = surfaceNum;
slist.push_back(temp_slist_entry);
}
return qtrue;
}
}
return qfalse;
}
int G2_GetParentSurface(CGhoul2Info *ghlInfo, const int index)
{
assert(ghlInfo->currentModel);
assert(ghlInfo->currentModel->mdxm);
const mdxmHierarchyOffsets_t *surfIndexes = (mdxmHierarchyOffsets_t *)((byte *)ghlInfo->currentModel->mdxm + sizeof(mdxmHeader_t));
// walk each surface and see if this index is listed in it's children
const mdxmSurface_t *surf = (mdxmSurface_t *)G2_FindSurface(ghlInfo->currentModel, index, 0);
const mdxmSurfHierarchy_t *surfInfo = (mdxmSurfHierarchy_t *)((byte *)surfIndexes + surfIndexes->offsets[surf->thisSurfaceIndex]);
return surfInfo->parentIndex;
}
/************************************************************************************************
* G2_FindSurface
* find a surface in a ghoul2 surface override list based on it's name
*
* Input
* filename of model, surface list of model instance, name of surface, int to be filled in
* with the index of this surface (defaults to NULL)
*
* Output
* pointer to surface if successful, false otherwise
*
************************************************************************************************/
mdxmSurface_t *G2_FindSurface(CGhoul2Info *ghlInfo, surfaceInfo_v &slist, const char *surfaceName,
int *surfIndex/*NULL*/)
{
int i = 0;
// find the model we want
model_t *mod = (model_t *)ghlInfo->currentModel;
mdxmHierarchyOffsets_t *surfIndexes = (mdxmHierarchyOffsets_t *)((byte *)mod->mdxm + sizeof(mdxmHeader_t));
mdxmSurfHierarchy_t *surfInfo;
// did we find a ghoul 2 model or not?
if (!mod->mdxm)
{
assert(0);
if (surfIndex)
{
*surfIndex = -1;
}
return 0;
}
// first find if we already have this surface in the list
for (i = slist.size() - 1; i >= 0; i--)
{
if ((slist[i].surface != 10000) && (slist[i].surface != -1))
{
mdxmSurface_t *surf = (mdxmSurface_t *)G2_FindSurface((void *)mod, slist[i].surface, 0);
// back track and get the surfinfo struct for this surface
surfInfo = (mdxmSurfHierarchy_t *)((byte *)surfIndexes + surfIndexes->offsets[surf->thisSurfaceIndex]);
// are these the droids we're looking for?
if (!stricmp (surfInfo->name, surfaceName))
{
// yup
if (surfIndex)
{
*surfIndex = i;
}
return surf;
}
}
}
// didn't find it
if (surfIndex)
{
*surfIndex = -1;
}
return 0;
}
char *G2API_GetSurfaceName(CGhoul2Info *ghlInfo, int surfNumber)
{
static char noSurface[1] = "";
model_t *mod = R_GetModelByHandle(RE_RegisterModel(ghlInfo->mFileName));
mdxmSurface_t *surf = 0;
mdxmSurfHierarchy_t *surfInfo = 0;
surf = (mdxmSurface_t *)G2_FindSurface((void *)mod, surfNumber, 0);
if (surf)
{
mdxmHierarchyOffsets_t *surfIndexes = (mdxmHierarchyOffsets_t *)((byte *)mod->mdxm + sizeof(mdxmHeader_t));
surfInfo = (mdxmSurfHierarchy_t *)((byte *)surfIndexes + surfIndexes->offsets[surf->thisSurfaceIndex]);
return surfInfo->name;
}
return noSurface;
}
void G2_FindRecursiveSurface(const model_t *currentModel, int surfaceNum, surfaceInfo_v &rootList, int *activeSurfaces)
{
assert(currentModel);
assert(currentModel->mdxm);
int i;
const mdxmSurface_t *surface = (mdxmSurface_t *)G2_FindSurface(currentModel, surfaceNum, 0);
const mdxmHierarchyOffsets_t *surfIndexes = (mdxmHierarchyOffsets_t *)((byte *)currentModel->mdxm + sizeof(mdxmHeader_t));
const mdxmSurfHierarchy_t *surfInfo = (mdxmSurfHierarchy_t *)((byte *)surfIndexes + surfIndexes->offsets[surface->thisSurfaceIndex]);
// see if we have an override surface in the surface list
const surfaceInfo_t *surfOverride = G2_FindOverrideSurface(surfaceNum, rootList);
// really, we should use the default flags for this surface unless it's been overriden
int offFlags = surfInfo->flags;
// set the off flags if we have some
if (surfOverride)
{
offFlags = surfOverride->offFlags;
}
// if this surface is not off, indicate as such in the active surface list
if (!(offFlags & G2SURFACEFLAG_OFF))
{
activeSurfaces[surfaceNum] = 1;
}
else
// if we are turning off all descendants, then stop this recursion now
if (offFlags & G2SURFACEFLAG_NODESCENDANTS)
{
return;
}
// now recursively call for the children
for (i=0; i< surfInfo->numChildren; i++)
{
surfaceNum = surfInfo->childIndexes[i];
G2_FindRecursiveSurface(currentModel, surfaceNum, rootList, activeSurfaces);
}
}
void G2_TransformSurfaces(int surfaceNum, surfaceInfo_v &rootSList,
CBoneCache *boneCache, const model_t *currentModel, int lod, vec3_t scale, CMiniHeap *G2VertSpace, int *TransformedVertArray, bool secondTimeAround)
{
int i;
assert(currentModel);
assert(currentModel->mdxm);
// back track and get the surfinfo struct for this surface
const mdxmSurface_t *surface = (mdxmSurface_t *)G2_FindSurface(currentModel, surfaceNum, lod);
const mdxmHierarchyOffsets_t *surfIndexes = (mdxmHierarchyOffsets_t *)((byte *)currentModel->mdxm + sizeof(mdxmHeader_t));
const mdxmSurfHierarchy_t *surfInfo = (mdxmSurfHierarchy_t *)((byte *)surfIndexes + surfIndexes->offsets[surface->thisSurfaceIndex]);
// see if we have an override surface in the surface list
const surfaceInfo_t *surfOverride = G2_FindOverrideSurface(surfaceNum, rootSList);
// really, we should use the default flags for this surface unless it's been overriden
int offFlags = surfInfo->flags;
if (surfOverride)
{
offFlags = surfOverride->offFlags;
}
// if this surface is not off, add it to the shader render list
if (!offFlags)
{
R_TransformEachSurface(surface, scale, G2VertSpace, TransformedVertArray, boneCache);
}
// if we are turning off all descendants, then stop this recursion now
if (offFlags & G2SURFACEFLAG_NODESCENDANTS)
{
return;
}
// now recursively call for the children
for (i=0; i< surfInfo->numChildren; i++)
{
G2_TransformSurfaces(surfInfo->childIndexes[i], rootSList, boneCache, currentModel, lod, scale, G2VertSpace, TransformedVertArray, secondTimeAround);
}
}
// return a named surfaces off flags - should tell you if this surface is on or off.
int G2_IsSurfaceOff (CGhoul2Info *ghlInfo, surfaceInfo_v &slist, const char *surfaceName)
{
model_t *mod = (model_t *)ghlInfo->currentModel;
int surfIndex = -1;
mdxmSurface_t *surf = 0;
// did we find a ghoul 2 model or not?
if (!mod->mdxm)
{
return 0;
}
// first find if we already have this surface in the list
surf = G2_FindSurface(ghlInfo, slist, surfaceName, &surfIndex);
if (surf)
{
// set descendants value
return slist[surfIndex].offFlags;
}
// ok, we didn't find it in the surface list. Lets look at the original surface then.
mdxmSurfHierarchy_t *surface = (mdxmSurfHierarchy_t *) ( (byte *)mod->mdxm + mod->mdxm->ofsSurfHierarchy );
for ( int i = 0 ; i < mod->mdxm->numSurfaces ; i++)
{
if (!stricmp(surfaceName, surface->name))
{
return surface->flags;
}
// find the next surface
surface = (mdxmSurfHierarchy_t *)( (byte *)surface + (intptr_t)( &((mdxmSurfHierarchy_t *)0)->childIndexes[ surface->numChildren ] ));
}
assert(0);
return 0;
}
// look at a surface and then do the trace on each poly
static void G2_TraceSurfaces(CTraceSurface &TS)
{
int i;
// back track and get the surfinfo struct for this surface
assert(TS.currentModel);
assert(TS.currentModel->mdxm);
const mdxmSurface_t *surface = (mdxmSurface_t *)G2_FindSurface(TS.currentModel, TS.surfaceNum, TS.lod);
const mdxmHierarchyOffsets_t *surfIndexes = (mdxmHierarchyOffsets_t *)((byte *)TS.currentModel->mdxm + sizeof(mdxmHeader_t));
const mdxmSurfHierarchy_t *surfInfo = (mdxmSurfHierarchy_t *)((byte *)surfIndexes + surfIndexes->offsets[surface->thisSurfaceIndex]);
// see if we have an override surface in the surface list
const surfaceInfo_t *surfOverride = G2_FindOverrideSurface(TS.surfaceNum, TS.rootSList);
// don't allow recursion if we've already hit a polygon
if (TS.hitOne)
{
return;
}
// really, we should use the default flags for this surface unless it's been overriden
int offFlags = surfInfo->flags;
// set the off flags if we have some
if (surfOverride)
{
offFlags = surfOverride->offFlags;
}
// if this surface is not off, try to hit it
if (!offFlags)
{
if (!(fabs(TS.m_fRadius) < 0.1)) // if not a point-trace
{
// .. then use radius check
//
if (G2_RadiusTracePolys(surface, // const mdxmSurface_t *surface,
TS
)
&& (TS.eG2TraceType == G2_RETURNONHIT)
)
{
TS.hitOne = true;
return;
}
}
else
{
// go away and trace the polys in this surface
if (G2_TracePolys(surface, surfInfo, TS)
&& (TS.eG2TraceType == G2_RETURNONHIT)
)
{
// ok, we hit one, *and* we want to return instantly because the returnOnHit is set
// so indicate we've hit one, so other surfaces don't get hit and return
TS.hitOne = true;
return;
}
}
}
// if we are turning off all descendants, then stop this recursion now
if (offFlags & G2SURFACEFLAG_NODESCENDANTS)
{
return;
}
// now recursively call for the children
for (i=0; i< surfInfo->numChildren && !TS.hitOne; i++)
{
TS.surfaceNum = surfInfo->childIndexes[i];
G2_TraceSurfaces(TS);
}
}
int G2_IsSurfaceRendered(CGhoul2Info *ghlInfo, const char *surfaceName, surfaceInfo_v &slist)
{
int flags = 0;//, surfFlags = 0;
int surfIndex = 0;
assert(ghlInfo->currentModel);
assert(ghlInfo->currentModel->mdxm);
if (!ghlInfo->currentModel->mdxm)
{
return -1;
}
// now travel up the skeleton to see if any of it's ancestors have a 'no descendants' turned on
// find the original surface in the surface list
int surfNum = G2_IsSurfaceLegal(ghlInfo->currentModel, surfaceName, &flags);
if ( surfNum != -1 )
{//must be legal
const mdxmHierarchyOffsets_t *surfIndexes = (mdxmHierarchyOffsets_t *)((byte *)ghlInfo->currentModel->mdxm + sizeof(mdxmHeader_t));
const mdxmSurfHierarchy_t *surfInfo = (mdxmSurfHierarchy_t *)((byte *)surfIndexes + surfIndexes->offsets[surfNum]);
surfNum = surfInfo->parentIndex;
// walk the surface hierarchy up until we hit the root
while (surfNum != -1)
{
const mdxmSurface_t *parentSurf;
int parentFlags;
const mdxmSurfHierarchy_t *parentSurfInfo;
parentSurfInfo = (mdxmSurfHierarchy_t *)((byte *)surfIndexes + surfIndexes->offsets[surfNum]);
// find the original surface in the surface list
//G2 was bug, above comment was accurate, but we don't want the original flags, we want the parent flags
G2_IsSurfaceLegal(ghlInfo->currentModel, parentSurfInfo->name, &parentFlags);
// now see if we already have overriden this surface in the slist
parentSurf = G2_FindSurface(ghlInfo, slist, parentSurfInfo->name, &surfIndex);
if (parentSurf)
{
// set descendants value
parentFlags = slist[surfIndex].offFlags;
}
// now we have the parent flags, lets see if any have the 'no descendants' flag set
if (parentFlags & G2SURFACEFLAG_NODESCENDANTS)
{
flags |= G2SURFACEFLAG_OFF;
break;
}
// set up scan of next parent
surfNum = parentSurfInfo->parentIndex;
}
}
else
{
return -1;
}
if ( flags == 0 )
{//it's not being overridden by a parent
// now see if we already have overriden this surface in the slist
const mdxmSurface_t *surf = G2_FindSurface(ghlInfo, slist, surfaceName, &surfIndex);
if (surf)
{
// set descendants value
flags = slist[surfIndex].offFlags;
}
// ok, at this point in flags we have what this surface is set to, and the index of the surface itself
}
return flags;
}