//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RivGridBoxGenerator::updateFromCamera(const cvf::Camera* camera)
{
m_gridBoxModel->removeAllParts();
if (m_gridBoxFaceParts.size() == 0) return;
std::vector<bool> faceVisibility(6, false);
for (size_t i = POS_X; i <= NEG_Z; i++)
{
bool isFaceVisible = false;
cvf::Vec3f sideNorm = sideNormalOutwards((FaceType)i);
if (camera->projection() == cvf::Camera::PERSPECTIVE)
{
cvf::Vec3d camToSide = camera->position() - pointOnSide((FaceType)i);
camToSide.normalize();
isFaceVisible = sideNorm.dot(cvf::Vec3f(camToSide)) < 0.0;
}
else
{
cvf::Vec3d camToSide = camera->direction();
isFaceVisible = sideNorm.dot(cvf::Vec3f(camToSide)) > 0.0;
}
if (isFaceVisible)
{
m_gridBoxModel->addPart(m_gridBoxFaceParts[i].p());
faceVisibility[i] = true;
}
}
std::vector<bool> edgeVisibility(12, false);
computeEdgeVisibility(faceVisibility, edgeVisibility);
CVF_ASSERT(m_gridBoxLegendParts.size() == (NEG_X_NEG_Y + 1)*2);
for (size_t i = POS_Z_POS_X; i <= NEG_X_NEG_Y; i++)
{
if (edgeVisibility[i])
{
// We have two parts for each edge - line and text
m_gridBoxModel->addPart(m_gridBoxLegendParts[2 * i].p());
m_gridBoxModel->addPart(m_gridBoxLegendParts[2 * i + 1].p());
}
}
m_gridBoxModel->updateBoundingBoxesRecursive();
}
void CelAnimMesh::render(RenderContext& rc,
const ShapeInstance* shapeInst,
MaterialList const& mats,
int frame,
int matFrameIndex,
int* matRemap ) const
{
if( !fFaces.size() )
return;
AssertFatal( fFrames.size() > 0, "Shape must have at least one frame." );
AssertFatal( frame >= 0 && frame < fFrames.size(),
"TS::CelAnimMesh: frame index out of range" );
// get the frame struct:
const Frame *frm = &fFrames[frame];
int FirstVert = frm->fFirstVert;
const Point3F *pScale = &frm->fScale;
const Point3F *pOrigin = &frm->fOrigin;
// unpack the min and max points for this frame:
Vertex minVert, maxVert;
minVert.set( fVerts[FirstVert], *pScale, *pOrigin );
maxVert.set( fVerts[FirstVert + 1], *pScale, *pOrigin );
// create bounding object and do vis test:
BoundingBox bb;
bb.setBox( minVert.fPoint,maxVert.fPoint );
int vis = bb.pushVisibility( rc ); // no longer need sphere for visibility check
if( vis != ClipNoneVis )
{
PointArray *pa = rc.getPointArray();
GFXSurface *srf = rc.getSurface();
// reset point array:
pa->reset();
// optimize lights and tell point array to use them:
bb.setSphere(); // need sphere for lighting
bb.prepareLights( rc );
// transform and project all points:
int first = pa->addPoints( fnVertsPerFrame,
&fVerts[FirstVert], *pScale, *pOrigin, &vis );
if( vis != ClipNoneVis )
{
AssertFatal(matFrameIndex*fnTextureVertsPerFrame<fTextureVerts.size(),
"TS::CelAnimMesh::render: texture verts index out of range");
pa->useTextures( &fTextureVerts[matFrameIndex*fnTextureVertsPerFrame] );
// set up some statics used by renderers
TSMaterial::prepareRender(fVerts.address(),first,*pScale,*pOrigin,srf,pa,shapeInst);
// render visible faces (lighting vertices as we go):
for( Vector<Face>::const_iterator pFace = fFaces.begin();
pFace != fFaces.end(); pFace++ )
{
#ifdef DEBUG
validateFace( mats, *pFace, matFrameIndex );
#endif
int faceVis = faceVisibility( pa, *pFace, first );
if( faceVis != ClipNoneVis )
{
// draw the face:
pa->setVisibility( faceVis );
if( faceVis != ClipAllVis )
pa->useBackFaceTest( TRUE );
if ( pFace->fMaterial != -1 )
{
int mat_id = matRemap? matRemap[ pFace->fMaterial ] :
pFace->fMaterial;
const Material& fmat = ShapeInstance::getAlwaysMat() ?
(*ShapeInstance::getAlwaysMat())[0] : mats[ mat_id ];
fmat.render((const char*)pFace);
}
if( faceVis != ClipAllVis )
pa->useBackFaceTest( FALSE );
}
}
}
}
bb.popVisibility( rc );
}
