//-----------------------------------------------------------------------
SceneNode* PCZSceneNode::createChildSceneNode(const String& name, const Vector3& inTranslate,
const Quaternion& inRotate)
{
PCZSceneNode * childSceneNode = (PCZSceneNode*)(this->createChild(name, inTranslate, inRotate));
if (mHomeZone)
{
childSceneNode->setHomeZone(mHomeZone);
mHomeZone->_addNode(childSceneNode);
}
return static_cast<SceneNode*>(childSceneNode);
}
//-----------------------------------------------------------------------
void PCZLight::updateZones(PCZone * defaultZone, unsigned long frameCount)
{
//update the zones this light affects
PCZone * homeZone;
affectedZonesList.clear();
mAffectsVisibleZone = false;
PCZSceneNode * sn = (PCZSceneNode*)(this->getParentSceneNode());
if (sn)
{
// start with the zone the light is in
homeZone = sn->getHomeZone();
if (homeZone)
{
affectedZonesList.push_back(homeZone);
if (homeZone->getLastVisibleFrame() == frameCount)
{
mAffectsVisibleZone = true;
}
}
else
{
// error - scene node has no homezone!
// just say it affects the default zone and leave it at that.
affectedZonesList.push_back(defaultZone);
if (defaultZone->getLastVisibleFrame() == frameCount)
{
mAffectsVisibleZone = true;
}
return;
}
}
else
{
// ERROR! not connected to a scene node,
// just say it affects the default zone and leave it at that.
affectedZonesList.push_back(defaultZone);
if (defaultZone->getLastVisibleFrame() == frameCount)
{
mAffectsVisibleZone = true;
}
return;
}
// now check visibility of each portal in the home zone. If visible to
// the light then add the target zone of the portal to the list of
// affected zones and recurse into the target zone
static PCZFrustum portalFrustum;
Vector3 v = getDerivedPosition();
portalFrustum.setOrigin(v);
homeZone->_checkLightAgainstPortals(this, frameCount, &portalFrustum, 0);
}
/* if destroySceneNodes is true, then all nodes which have the destroyed
zone as their homezone are desroyed too. If destroySceneNodes is false
then all scene nodes which have the zone as their homezone will have
their homezone pointer set to 0, which will allow them to be re-assigned
either by the user or via the automatic re-assignment routine */
void PCZSceneManager::destroyZone(PCZone* zone, bool destroySceneNodes)
{
// need to remove this zone from all lights affected zones list,
// otherwise next frame _calcZonesAffectedByLights will call PCZLight::getNeedsUpdate()
// which will try to access the zone pointer and will cause an access violation
MovableObjectCollection* lights =
getMovableObjectCollection(PCZLightFactory::FACTORY_TYPE_NAME);
{
OGRE_LOCK_MUTEX(lights->mutex) // Is locking necessary in destroyZone? I don't know..
MovableObjectIterator it(lights->map.begin(), lights->map.end());
while(it.hasMoreElements())
{
PCZLight* l = static_cast<PCZLight*>(it.getNext());
if(l)
{
// no need to check, this function does that anyway. if exists, is erased.
l->removeZoneFromAffectedZonesList(zone);
}
}
}
// if not destroying scene nodes, then make sure any nodes who have
// this zone as homezone are set to have 0 for a homezone
for (SceneNodeList::iterator i = mSceneNodes.begin();
i != mSceneNodes.end(); ++i)
{
PCZSceneNode * pczsn = (PCZSceneNode*)(i->second);
if (!destroySceneNodes)
{
if (pczsn->getHomeZone() == zone)
{
pczsn->setHomeZone(0);
}
}
// reset all node visitor lists
// note, it might be more efficient to only do this to nodes which
// are actually visiting the zone being destroyed, but visitor lists
// get cleared every frame anyway, so it's not THAT big a deal.
pczsn->clearNodeFromVisitedZones();
}
ZoneMap::iterator it;
it = mZones.find(zone->getName());
if (it != mZones.end())
{
mZones.erase(zone->getName());
}
OGRE_DELETE zone;
}
//-------------------------------------------------------------------------
void DefaultZone::setZoneGeometry(const String &filename, PCZSceneNode * parentNode)
{
String entityName, nodeName;
entityName = this->getName() + "_entity";
nodeName = this->getName() + "_Node";
Entity *ent = mPCZSM->createEntity(entityName , filename );
// create a node for the entity
PCZSceneNode * node;
node = (PCZSceneNode*)(parentNode->createChildSceneNode(nodeName));
// attach the entity to the node
node->attachObject(ent);
// set the node as the enclosure node
setEnclosureNode(node);
}
/** Removes all references to the node from every zone in the scene.
*/
void PCZSceneManager::removeSceneNode( SceneNode * sn )
{
// Skip if mDefaultZone has been destroyed (shutdown conditions)
if (!mDefaultZone)
return;
PCZSceneNode * pczsn = (PCZSceneNode*)sn;
// clear all references to the node in visited zones
pczsn->clearNodeFromVisitedZones();
// tell the node it's not in a zone
pczsn->setHomeZone(0);
}
//---------------------------------------------------------------------
void PCZSceneManager::ensureShadowTexturesCreated()
{
bool shadowTextureConfigDirty = mShadowTextureConfigDirty;
SceneManager::ensureShadowTexturesCreated();
if (!shadowTextureConfigDirty) return;
size_t count = mShadowTextureCameras.size();
for (size_t i = 0; i < count; ++i)
{
PCZSceneNode* node = (PCZSceneNode*)mSceneRoot->createChildSceneNode(
mShadowTextureCameras[i]->getName());
node->attachObject(mShadowTextureCameras[i]);
addPCZSceneNode(node, mDefaultZone);
}
}
/* Update all PCZSceneNodes.
*/
void PCZSceneManager::_updatePCZSceneNodes(void)
{
SceneNodeList::iterator it = mSceneNodes.begin();
PCZSceneNode * pczsn;
while ( it != mSceneNodes.end() )
{
pczsn = (PCZSceneNode*)(it->second);
if (pczsn->isMoved() && pczsn->isEnabled())
{
// Update a single entry
_updatePCZSceneNode(pczsn);
// reset moved state.
pczsn->setMoved(false);
}
// proceed to next entry in the list
++it;
}
}
//---------------------------------------------------------------------
void PCZSceneManager::fireShadowTexturesPreCaster(Light* light, Camera* camera, size_t iteration)
{
PCZSceneNode* camNode = (PCZSceneNode*)camera->getParentSceneNode();
if (light->getType() == Light::LT_DIRECTIONAL)
{
if (camNode->getHomeZone() != mActiveCameraZone)
addPCZSceneNode(camNode, mActiveCameraZone);
}
else
{
PCZSceneNode* lightNode = (PCZSceneNode*)light->getParentSceneNode();
assert(lightNode);
PCZone* lightZone = lightNode->getHomeZone();
if (camNode->getHomeZone() != lightZone)
addPCZSceneNode(camNode, lightZone);
}
SceneManager::fireShadowTexturesPreCaster(light, camera, iteration);
}
void Octree::_findNodes(const PlaneBoundedVolume &t,
PCZSceneNodeList &list,
PCZSceneNode *exclude,
bool includeVisitors,
bool full )
{
if ( !full )
{
AxisAlignedBox obox;
_getCullBounds( &obox );
Intersection isect = intersect( t, obox );
if ( isect == OUTSIDE )
return ;
full = ( isect == INSIDE );
}
PCZSceneNodeList::iterator it = mNodes.begin();
while ( it != mNodes.end() )
{
PCZSceneNode * on = ( *it );
if ( on != exclude && (on->getHomeZone() == mZone || includeVisitors ))
{
if ( full )
{
// make sure the node isn't already on the list
list.insert( on );
}
else
{
Intersection nsect = intersect( t, on -> _getWorldAABB() );
if ( nsect != OUTSIDE )
{
// make sure the node isn't already on the list
list.insert( on );
}
}
}
++it;
}
Octree* child;
if ( (child=mChildren[ 0 ][ 0 ][ 0 ]) != 0 )
child->_findNodes( t, list, exclude, includeVisitors, full );
if ( (child=mChildren[ 1 ][ 0 ][ 0 ]) != 0 )
child->_findNodes( t, list, exclude, includeVisitors, full );
if ( (child=mChildren[ 0 ][ 1 ][ 0 ]) != 0 )
child->_findNodes( t, list, exclude, includeVisitors, full );
if ( (child=mChildren[ 1 ][ 1 ][ 0 ]) != 0 )
child->_findNodes( t, list, exclude, includeVisitors, full );
if ( (child=mChildren[ 0 ][ 0 ][ 1 ]) != 0 )
child->_findNodes( t, list, exclude, includeVisitors, full );
if ( (child=mChildren[ 1 ][ 0 ][ 1 ]) != 0 )
child->_findNodes( t, list, exclude, includeVisitors, full );
if ( (child=mChildren[ 0 ][ 1 ][ 1 ]) != 0 )
child->_findNodes( t, list, exclude, includeVisitors, full );
if ( (child=mChildren[ 1 ][ 1 ][ 1 ]) != 0 )
child->_findNodes( t, list, exclude, includeVisitors, full );
}
/*
// Recursively walk the zones, adding all visible SceneNodes to the list of visible nodes.
*/
void DefaultZone::findVisibleNodes(PCZCamera *camera,
NodeList & visibleNodeList,
RenderQueue * queue,
VisibleObjectsBoundsInfo* visibleBounds,
bool onlyShadowCasters,
bool displayNodes,
bool showBoundingBoxes)
{
//return immediately if nothing is in the zone.
if (mHomeNodeList.size() == 0 &&
mVisitorNodeList.size() == 0 &&
mPortals.size() == 0)
return ;
// Else, the zone is automatically assumed to be visible since either
// it is the camera the zone is in, or it was reached because
// a connecting portal was deemed visible to the camera.
// enable sky if called to do so for this zone
if (mHasSky)
{
// enable sky
mPCZSM->enableSky(true);
}
// find visible nodes at home in the zone
bool vis;
PCZSceneNodeList::iterator it = mHomeNodeList.begin();
while ( it != mHomeNodeList.end() )
{
PCZSceneNode * pczsn = *it;
// if the scene node is already visible, then we can skip it
if (pczsn->getLastVisibleFrame() != mLastVisibleFrame ||
pczsn->getLastVisibleFromCamera() != camera)
{
// for a scene node, check visibility using AABB
vis = camera ->isVisible( pczsn -> _getWorldAABB() );
if ( vis )
{
// add it to the list of visible nodes
visibleNodeList.push_back( pczsn );
// add the node to the render queue
pczsn -> _addToRenderQueue(camera, queue, onlyShadowCasters, visibleBounds );
// if we are displaying nodes, add the node renderable to the queue
if ( displayNodes )
{
queue -> addRenderable( pczsn->getDebugRenderable() );
}
// if the scene manager or the node wants the bounding box shown, add it to the queue
if (pczsn->getShowBoundingBox() || showBoundingBoxes)
{
pczsn->_addBoundingBoxToQueue(queue);
}
// flag the node as being visible this frame
pczsn->setLastVisibleFrame(mLastVisibleFrame);
pczsn->setLastVisibleFromCamera(camera);
}
}
++it;
}
// find visible visitor nodes
it = mVisitorNodeList.begin();
while ( it != mVisitorNodeList.end() )
{
PCZSceneNode * pczsn = *it;
// if the scene node is already visible, then we can skip it
if (pczsn->getLastVisibleFrame() != mLastVisibleFrame ||
pczsn->getLastVisibleFromCamera() != camera)
{
// for a scene node, check visibility using AABB
vis = camera ->isVisible( pczsn -> _getWorldAABB() );
if ( vis )
{
// add it to the list of visible nodes
visibleNodeList.push_back( pczsn );
// add the node to the render queue
pczsn->_addToRenderQueue(camera, queue, onlyShadowCasters, visibleBounds );
// if we are displaying nodes, add the node renderable to the queue
if ( displayNodes )
{
queue -> addRenderable( pczsn->getDebugRenderable() );
}
// if the scene manager or the node wants the bounding box shown, add it to the queue
if (pczsn->getShowBoundingBox() || showBoundingBoxes)
{
pczsn->_addBoundingBoxToQueue(queue);
}
// flag the node as being visible this frame
pczsn->setLastVisibleFrame(mLastVisibleFrame);
pczsn->setLastVisibleFromCamera(camera);
}
}
++it;
}
// Here we merge both portal and antiportal visible to the camera into one list.
// Then we sort them in the order from nearest to furthest from camera.
PortalBaseList sortedPortalList;
for (AntiPortalList::iterator iter = mAntiPortals.begin(); iter != mAntiPortals.end(); ++iter)
{
AntiPortal* portal = *iter;
if (camera->isVisible(portal))
{
sortedPortalList.push_back(portal);
}
}
for (PortalList::iterator iter = mPortals.begin(); iter != mPortals.end(); ++iter)
{
Portal* portal = *iter;
if (camera->isVisible(portal))
{
sortedPortalList.push_back(portal);
}
}
const Vector3& cameraOrigin(camera->getDerivedPosition());
std::sort(sortedPortalList.begin(), sortedPortalList.end(),
PortalSortDistance(cameraOrigin));
// create a standalone frustum for anti portal use.
// we're doing this instead of using camera because we don't need
// to do camera frustum check again.
PCZFrustum antiPortalFrustum;
antiPortalFrustum.setOrigin(cameraOrigin);
antiPortalFrustum.setProjectionType(camera->getProjectionType());
// now we do culling check and remove hidden portals.
// whenever we get a portal in the main loop, we can be sure that it is not
// occluded by AntiPortal. So we do traversal right there and then.
// This is because the portal list has been sorted.
size_t sortedPortalListCount = sortedPortalList.size();
for (size_t i = 0; i < sortedPortalListCount; ++i)
{
PortalBase* portalBase = sortedPortalList[i];
if (!portalBase) continue; // skip removed portal.
if (portalBase->getTypeFlags() == PortalFactory::FACTORY_TYPE_FLAG)
{
Portal* portal = static_cast<Portal*>(portalBase);
// portal is visible. Add the portal as extra culling planes to camera
int planes_added = camera->addPortalCullingPlanes(portal);
// tell target zone it's visible this frame
portal->getTargetZone()->setLastVisibleFrame(mLastVisibleFrame);
portal->getTargetZone()->setLastVisibleFromCamera(camera);
// recurse into the connected zone
portal->getTargetZone()->findVisibleNodes(camera,
visibleNodeList,
queue,
visibleBounds,
onlyShadowCasters,
displayNodes,
showBoundingBoxes);
if (planes_added > 0)
{
// Then remove the extra culling planes added before going to the next portal in the list.
camera->removePortalCullingPlanes(portal);
}
}
else if (i < sortedPortalListCount) // skip antiportal test if it is the last item in the list.
{
// this is an anti portal. So we use it to test preceding portals in the list.
AntiPortal* antiPortal = static_cast<AntiPortal*>(portalBase);
int planes_added = antiPortalFrustum.addPortalCullingPlanes(antiPortal);
for (size_t j = i + 1; j < sortedPortalListCount; ++j)
{
PortalBase* otherPortal = sortedPortalList[j];
// Since this is an antiportal, we are doing the inverse of the test.
// Here if the portal is fully visible in the anti portal fustrum, it means it's hidden.
if (otherPortal && antiPortalFrustum.isFullyVisible(otherPortal))
sortedPortalList[j] = NULL;
}
if (planes_added > 0)
{
// Then remove the extra culling planes added before going to the next portal in the list.
antiPortalFrustum.removePortalCullingPlanes(antiPortal);
}
}
}
}
// set the home zone for a scene node
void PCZSceneManager::setNodeHomeZone(SceneNode *node, PCZone *zone)
{
// cast the Ogre::SceneNode to a PCZSceneNode
PCZSceneNode * pczsn = (PCZSceneNode*)node;
pczsn->setHomeZone(zone);
}
