// main visibility determination & render queue filling routine
// over-ridden from base/default scene manager. This is *the*
// main call.
void PCZSceneManager::_findVisibleObjects(Camera* cam,
VisibleObjectsBoundsInfo* visibleBounds,
bool onlyShadowCasters)
{
// clear the render queue
getRenderQueue()->clear();
// if we are re-rendering the scene again with the same camera, we can just use the cache.
// this helps post processing compositors.
unsigned long frameCount = Root::getSingleton().getNextFrameNumber();
if (mLastActiveCamera == cam && mFrameCount == frameCount)
{
RenderQueue* queue = getRenderQueue();
size_t count = mVisible.size();
for (size_t i = 0; i < count; ++i)
{
((PCZSceneNode*)mVisible[i])->_addToRenderQueue(
cam, queue, onlyShadowCasters, visibleBounds);
}
return;
}
// increment the visibility frame counter
mFrameCount = frameCount;
mLastActiveCamera = cam;
// clear the list of visible nodes
mVisible.clear();
// turn off sky
enableSky(false);
// remove all extra culling planes
((PCZCamera*)cam)->removeAllExtraCullingPlanes();
// update the camera
((PCZCamera*)cam)->update();
// get the home zone of the camera
PCZone* cameraHomeZone = ((PCZSceneNode*)(cam->getParentSceneNode()))->getHomeZone();
// walk the zones, starting from the camera home zone,
// adding all visible scene nodes to the mVisibles list
cameraHomeZone->setLastVisibleFrame(mFrameCount);
cameraHomeZone->findVisibleNodes((PCZCamera*)cam,
mVisible,
getRenderQueue(),
visibleBounds,
onlyShadowCasters,
mDisplayNodes,
mShowBoundingBoxes);
}
void Scene::getRenderQueue(SceneNode const& sn, std::multimap<int, SceneNode const*>& queue) const
{
queue.insert(std::pair<int,SceneNode const*>(sn.getLayer(), &sn));
std::vector<SceneNode*> const &children = sn.getChildren();
for (auto& it : children)
getRenderQueue(*it, queue);
}
void Scene::draw(sf::RenderTarget& target,sf::RenderStates states) const
{
std::multimap<int,SceneNode const*> _renderQueue;
getRenderQueue(getRootNode(), _renderQueue);
for (auto& it : _renderQueue)
target.draw(*it.second, states);
}
void OctreeSceneManager::_findVisibleObjects(Camera * cam,
VisibleObjectsBoundsInfo* visibleBounds, bool onlyShadowCasters )
{
getRenderQueue()->clear();
mBoxes.clear();
mVisible.clear();
mNumObjects = 0;
//walk the octree, adding all visible Octreenodes nodes to the render queue.
walkOctree( static_cast < OctreeCamera * > ( cam ), getRenderQueue(), mOctree,
visibleBounds, false, onlyShadowCasters );
// Show the octree boxes & cull camera if required
if ( mShowBoxes )
{
for ( BoxList::iterator it = mBoxes.begin(); it != mBoxes.end(); ++it )
{
getRenderQueue()->addRenderable(*it);
}
}
}
//-----------------------------------------------------------------------
void BspSceneManager::processVisibleLeaf(BspNode* leaf, Camera* cam,
VisibleObjectsBoundsInfo* visibleBounds, bool onlyShadowCasters)
{
MaterialPtr pMat;
// Skip world geometry if we're only supposed to process shadow casters
// World is pre-lit
if (!onlyShadowCasters)
{
// Parse the leaf node's faces, add face groups to material map
int numGroups = leaf->getNumFaceGroups();
int idx = leaf->getFaceGroupStart();
while (numGroups--)
{
int realIndex = mLevel->mLeafFaceGroups[idx++];
// Check not already included
if (mFaceGroupSet.find(realIndex) != mFaceGroupSet.end())
continue;
StaticFaceGroup* faceGroup = mLevel->mFaceGroups + realIndex;
// Get Material pointer by handle
pMat = MaterialManager::getSingleton().getByHandle(faceGroup->materialHandle);
assert (!pMat.isNull());
// Check normal (manual culling)
ManualCullingMode cullMode = pMat->getTechnique(0)->getPass(0)->getManualCullingMode();
if (cullMode != MANUAL_CULL_NONE)
{
Real dist = faceGroup->plane.getDistance(cam->getDerivedPosition());
if ( (dist < 0 && cullMode == MANUAL_CULL_BACK) ||
(dist > 0 && cullMode == MANUAL_CULL_FRONT) )
continue; // skip
}
mFaceGroupSet.insert(realIndex);
// Try to insert, will find existing if already there
std::pair<MaterialFaceGroupMap::iterator, bool> matgrpi;
matgrpi = mMatFaceGroupMap.insert(
MaterialFaceGroupMap::value_type(pMat.getPointer(), vector<StaticFaceGroup*>::type())
);
// Whatever happened, matgrpi.first is map iterator
// Need to get second part of that to get vector
matgrpi.first->second.push_back(faceGroup);
//if (firstTime)
//{
// of << " Emitting faceGroup: index=" << realIndex << ", " << *faceGroup << std::endl;
//}
}
}
// Add movables to render queue, provided it hasn't been seen already
const BspNode::IntersectingObjectSet& objects = leaf->getObjects();
BspNode::IntersectingObjectSet::const_iterator oi, oiend;
oiend = objects.end();
for (oi = objects.begin(); oi != oiend; ++oi)
{
if (mMovablesForRendering.find(*oi) == mMovablesForRendering.end())
{
// It hasn't been seen yet
MovableObject *mov = const_cast<MovableObject*>(*oi); // hacky
getRenderQueue()->processVisibleObject(mov, cam, onlyShadowCasters, visibleBounds);
}
}
}
