//----------------------------------------------------------------------- void EntityRenderer::_destroyAll(void) { if (!mParentTechnique) return; // Delete the visual data vector<EntityRendererVisualData*>::const_iterator it; vector<EntityRendererVisualData*>::const_iterator itEnd = mAllVisualData.end(); for (it = mAllVisualData.begin(); it != itEnd; ++it) { PU_DELETE_T(*it, EntityRendererVisualData, MEMCATEGORY_SCENE_OBJECTS); } mAllVisualData.clear(); mVisualData.clear(); // V1.5: Destroy the created ChildSceneNodes (which leads to detaching the Entities) if (mParentTechnique->getParentSystem()) { Ogre::SceneNode* parentNode = mParentTechnique->getParentSystem()->getParentSceneNode(); if (parentNode) { String sceneNodeName; std::stringstream ss; unsigned short numChilds = parentNode->numChildren(); for (unsigned short i = 0; i < numChilds; ++i) { Ogre::Node* node = parentNode->getChild(i); if (node) { Ogre::String name = node->getName(); if (name.find("ParticleUniverse") != Ogre::String::npos) { parentNode->removeAndDestroyChild(i); } } } } } // V1.5 // Destroy the Entities. Do it like this, because it must be assured that the entity still exists // and has not already been destroyed. Ogre::SceneManager* sceneManager = mParentTechnique->getParentSystem()->getSceneManager(); for (size_t i = 0; i < mQuota; i++) { if (sceneManager->hasEntity(mEntityName + StringConverter::toString(i))) { sceneManager->destroyEntity(mEntityName + StringConverter::toString(i)); } } mEntities.clear(); // Reset the visual data in the pool mParentTechnique->initVisualDataInPool(); }
void StereoManager::destroyDebugPlane(void) { if(debug_plane_) { Ogre::SceneNode *parent = static_cast<Ogre::SceneNode*>(debug_plane_node_->getParent()); parent->removeAndDestroyChild("Stereo/DebugPlaneNode"); debug_plane_node_ = NULL; sceneMngr_->destroyEntity("Stereo/DebugPlane"); debug_plane_ = NULL; Ogre::MeshManager::getSingleton().remove("Stereo/Plane"); } }
void StereoManager::destroyDebugPlane(void) { if(mDebugPlane) { Ogre::SceneNode *parent = static_cast<Ogre::SceneNode*>(mDebugPlaneNode->getParent()); parent->removeAndDestroyChild("Stereo/DebugPlaneNode"); mDebugPlaneNode = NULL; mSceneMgr->destroyEntity("Stereo/DebugPlane"); mDebugPlane = NULL; Ogre::MeshManager::getSingleton().remove("Stereo/Plane"); } }
void MapManager::RemoveObstacle(MapArea* area, Objects* input) { char areaString[30]; sprintf(areaString, "map_area_%d", area->getIndex()); //get the area node from map node. Ogre::SceneNode* areaNode = (Ogre::SceneNode*)mMapNode->getChild(Ogre::String(areaString)); char cubeString[30]; sprintf(cubeString, "cube_%d", input->index); Ogre::SceneNode* objectNode = (Ogre::SceneNode*)areaNode->getChild(Ogre::String(cubeString)); objectNode->detachAllObjects(); mSceneMgr->destroyEntity(Ogre::String(cubeString)); //remove the object node from areanode areaNode->removeAndDestroyChild(Ogre::String(cubeString)); input->mLoaded = false; //we also need to remove rigid body std::vector<OgreBulletDynamics::RigidBody*>::iterator rigidBodyIterator; for(rigidBodyIterator = mRigidBodyList.begin(); rigidBodyIterator != mRigidBodyList.end(); rigidBodyIterator++) { //is this the rigid body for this cube? if((*rigidBodyIterator)->getName().compare("BoxRigid" + Ogre::StringConverter::toString(input->index))) { //yes! //get out of this loop break; } } //remove it from the physic manager PhysicManager::getSingletonPtr()->removeRigidBody((*rigidBodyIterator), BODIES_NONE); //remove from the list mRigidBodyList.erase(rigidBodyIterator); mNumEntitiesInstanced--; }
//----------------------------------------------------------------------- void SceneDecoratorExtern::_notifyStop (void) { if (mSubnode && mParentTechnique->getParentSystem()) { Ogre::SceneNode* sceneNode = mParentTechnique->getParentSystem()->getParentSceneNode(); Ogre::SceneNode::ChildNodeIterator it = sceneNode->getChildIterator(); unsigned int i = 0; while (it.hasMoreElements()) { Ogre::SceneNode* child = static_cast<Ogre::SceneNode*>(it.getNext()); if (child == mSubnode) { mSubnode->detachAllObjects(); sceneNode->removeAndDestroyChild(i); mSubnode = 0; } ++i; } destroyEntity(); } }
//----------------------------------------------------------------------- Ogre::SceneNode* OrthoCameraGizmo::detachFromNode(void) { Ogre::SceneNode* parent = 0; if (mOrthoCameraNodeBox) { parent = mOrthoCameraNodeBox->getParentSceneNode(); parent->removeAndDestroyChild(mOrthoCameraNodeBox->getName()); mOrthoCameraNodeBox = 0; } if (mOrthoCameraNodeX) { parent = mOrthoCameraNodeX->getParentSceneNode(); parent->removeAndDestroyChild(mOrthoCameraNodeX->getName()); mOrthoCameraNodeX = 0; } if (mOrthoCameraNodeMinX) { parent = mOrthoCameraNodeMinX->getParentSceneNode(); parent->removeAndDestroyChild(mOrthoCameraNodeMinX->getName()); mOrthoCameraNodeMinX = 0; } if (mOrthoCameraNodeY) { parent = mOrthoCameraNodeY->getParentSceneNode(); parent->removeAndDestroyChild(mOrthoCameraNodeY->getName()); mOrthoCameraNodeY = 0; } if (mOrthoCameraNodeZ) { parent = mOrthoCameraNodeZ->getParentSceneNode(); parent->removeAndDestroyChild(mOrthoCameraNodeZ->getName()); mOrthoCameraNodeZ = 0; } if (mOrthoCameraNodeMinZ) { parent = mOrthoCameraNodeMinZ->getParentSceneNode(); parent->removeAndDestroyChild(mOrthoCameraNodeMinZ->getName()); mOrthoCameraNodeMinZ = 0; } return parent; }
//update that checks the loaded list for adding or removing objects inside void MapManager::UpdateLoadedList(std::vector<MapArea*> *input) { //run through our current list //see if there is anything in the list to be updated std::vector<MapArea*>::iterator loadedIterator; for(loadedIterator = input->begin(); loadedIterator != input->end(); loadedIterator++) { //No matter if the area is fully inside or not, let's check if the area is now outside of the HOLDRADIUS if(!IsAreaInsideLoadRadius((*loadedIterator))) { if(!IsAreaInsideHoldRadius((*loadedIterator))) { //now, time to remove the area node //std::cout << "REMOVING AREA NODE!\n"; char areaString[30]; sprintf(areaString, "map_area_%d", (*loadedIterator)->getIndex()); //get the area node from map node. Ogre::SceneNode* areaNode = (Ogre::SceneNode*)mMapNode->getChild(Ogre::String(areaString)); //delete ground node char groundString[30]; sprintf(groundString, "map_area_ground_%d", (*loadedIterator)->getIndex()); Ogre::SceneNode* groundNode = (Ogre::SceneNode*)areaNode->getChild(Ogre::String(groundString)); groundNode->removeAndDestroyAllChildren(); groundNode->detachAllObjects(); areaNode->removeAndDestroyChild(groundString); areaNode->removeAndDestroyAllChildren(); areaNode->detachAllObjects(); mMapNode->removeAndDestroyChild(areaString); //set the map area to be unloaded (*loadedIterator)->setLoaded(false); //remove it from the list input->erase(loadedIterator); return; } } //since this area is not fully inside, lets check if this object is currently inside the scene std::vector<Objects*>::iterator obstacleIterator; for(obstacleIterator = (*loadedIterator)->_mObstacleList.begin(); obstacleIterator!=(*loadedIterator)->_mObstacleList.end(); obstacleIterator++) { //is this object in the load radius? if(IsObjectInsideRadius((*obstacleIterator), LOADRADIUS)) { //yes //is this object already loaded in the game? if((*obstacleIterator)->mLoaded) { //yes //skip continue; } else { //no //add it into the game AddObstacle((*loadedIterator), (*obstacleIterator)); } } //is this object out of hold radius? else if(!IsObjectInsideRadius((*obstacleIterator), HOLDRADIUS)) { //no //is this object already loaded in the game? if((*obstacleIterator)->mLoaded) { //yes //remove it RemoveObstacle((*loadedIterator),(*obstacleIterator)); } else { //no //skip continue; } } } std::vector<Objects*>::iterator enemyIterator; for(enemyIterator = (*loadedIterator)->_mEnemySpawnPointList.begin(); enemyIterator!=(*loadedIterator)->_mEnemySpawnPointList.end(); enemyIterator++) { //is this object inside the load radius? if(IsObjectInsideRadius((*enemyIterator), ENEMY_LOADRADIUS)) { //yes //is this enemy spawn point already loaded? if(!(*enemyIterator)->mLoaded) { //no //add enemy AddEnemy((*enemyIterator)); } } } std::vector<Objects*>::iterator flamethrowerIterator; for(flamethrowerIterator = (*loadedIterator)->_mFlameThrowerList.begin(); flamethrowerIterator!=(*loadedIterator)->_mFlameThrowerList.end(); flamethrowerIterator++) { //no //is this object inside the load radius? if(!IsObjectInsideRadius((*flamethrowerIterator), ENEMY_LOADRADIUS)) { //no //skip this object continue; } //yes continue whatever we need to do if(!(*flamethrowerIterator)->mLoaded) AddFlameThrower((*flamethrowerIterator)); } } }