//============================================================================= // NodeMaterialOrig //============================================================================= NodeMaterialOrig::NodeMaterialOrig( Ogre::SceneNode* sceneNode ) : NodeMaterial(), _sceneNode( sceneNode ) { for( Ogre::SceneNode::ObjectIterator it = sceneNode->getAttachedObjectIterator() ; it.hasMoreElements() ; it.moveNext() ) { Ogre::MovableObject * currentMO = it.peekNextValue() ; if ( currentMO->getMovableType() == Ogre::EntityFactory::FACTORY_TYPE_NAME ) { //OMTRACEID( "DEBUG", "Create entity " << currentMO->getName() ) ; _entities[ it.peekNextKey() ] = new EntityMaterialOrig( static_cast< Ogre::Entity *> ( currentMO ) ) ; } } for( Ogre::Node::ChildNodeIterator it = sceneNode->getChildIterator() ; it.hasMoreElements() ; it.moveNext() ) { Ogre::SceneNode* childSceneNode = static_cast< Ogre::SceneNode* >( it.peekNextValue() ) ; //OMTRACEID( "DEBUG", "Create ChildSceneNode " << childSceneNode->getName() ) ; NodeMaterialOrig* child = new NodeMaterialOrig( childSceneNode ) ; _childs.push_back( child ) ; } }
//! //! Returns the first movable object of the given type name contained in //! the given scene node. //! //! \param sceneNode The scene node to find the first object in. //! \param typeName The name of the type of objects to look for. //! \return The first movable object of the given type name contained in the given scene node. //! Ogre::MovableObject * OgreTools::findFirstObject ( Ogre::SceneNode *sceneNode, const QString &typeName ) { // make sure the given scene node is valid if (!sceneNode) { Log::error("The given scene node is invalid.", "OgreTools::findFirstObject"); return 0; } // iterate over the list of attached objects Ogre::SceneNode::ObjectIterator objectIterator = sceneNode->getAttachedObjectIterator(); while (objectIterator.hasMoreElements()) { Ogre::MovableObject *movableObject = objectIterator.getNext(); if (movableObject && QString::compare(movableObject->getMovableType().c_str(), typeName) == 0) return movableObject; } // iterate over the list of child nodes Ogre::SceneNode::ChildNodeIterator childIter = sceneNode->getChildIterator(); while( childIter.hasMoreElements() ) { Ogre::SceneNode *childSceneNode = (Ogre::SceneNode *) childIter.getNext(); return findFirstObject(childSceneNode, typeName); } return 0; }
void OLMeshTracker::UpdateSubNodes(Ogre::Node* regionNode, Ogre::Node* node, bool recurse, Ogre::MeshPtr meshP) { if (recurse && node->numChildren() > 0) { // if node has more children nodes, visit them recursivily Ogre::SceneNode::ChildNodeIterator nodeChildIterator = node->getChildIterator(); while (nodeChildIterator.hasMoreElements()) { Ogre::Node* nodeChild = nodeChildIterator.getNext(); // 'false' causes it to not visit sub-children which are included in parent and pos relative to parent UpdateSubNodes(regionNode, nodeChild, true, meshP); } } // children taken care of... check for attached objects to this node Ogre::SceneNode* snode = (Ogre::SceneNode*)node; Ogre::SceneNode::ObjectIterator snodeObjectIterator = snode->getAttachedObjectIterator(); while (snodeObjectIterator.hasMoreElements()) { Ogre::MovableObject* snodeObject = snodeObjectIterator.getNext(); if (snodeObject->getMovableType() == "Entity") { Ogre::Entity* snodeEntity = (Ogre::Entity*)snodeObject; Ogre::MeshPtr entityMesh = snodeEntity->getMesh(); if (entityMesh == meshP) { snode->needUpdate(true); // LG::Log("OLMeshTracker::UpdateSubNodes: setting node update for %s", snode->getName().c_str()); } } } return; }
boolean COgreObject::getFirstEntityInHierarchy(Ogre::SceneNode* pNode, Ogre::Entity*& pEntity) const { for(uint32 i=0; i<pNode->numAttachedObjects(); i++) { Ogre::MovableObject* pMovableObject = pNode->getAttachedObject(0); if(pMovableObject->getMovableType() == Ogre::EntityFactory::FACTORY_TYPE_NAME) { pEntity = dynamic_cast<Ogre::Entity*>(pMovableObject); return true; } } for(uint32 i=0; i<pNode->numChildren(); i++) { Ogre::SceneNode* l_pChildNode = dynamic_cast<Ogre::SceneNode*>(pNode->getChild(i)); if(l_pChildNode != NULL && getFirstEntityInHierarchy(l_pChildNode, pEntity) == true) { return true; } } m_rKernelContext.getLogManager() << LogLevel_Trace << "Failed to retrieve Entity\n"; return false; }
void OGRE3DPointRenderable::destroyNode(Ogre::SceneNode* node) { if (node == 0) return; Ogre::SceneNode::ObjectIterator object_it = node->getAttachedObjectIterator(); Ogre::MovableObject *m; while(object_it.hasMoreElements()) { m = object_it.getNext(); // Move Cameras to RootSceneNodes if (m->getMovableType() == "Camera") { node->detachObject(m); mRenderSystem->getSceneManager()->getRootSceneNode()->attachObject(m); } // Everything else gets destroyed. else mRenderSystem->getSceneManager()->destroyMovableObject(m); } node->detachAllObjects(); node->removeAndDestroyAllChildren(); mRenderSystem->getSceneManager()->destroySceneNode(node); }
/*dumper*/ /*TODO: humanize*/ void DumpNodes(std::stringstream &ss, Ogre::Node *n, int level) { for(int i = 0; i < level; i++) { ss << " "; } ss << "SceneNode: " << n->getName() << " (parent: " << n->getParent()->getName() << ")" << std::endl; Ogre::SceneNode::ObjectIterator object_it = ((Ogre::SceneNode *)n)->getAttachedObjectIterator(); Ogre::Node::ChildNodeIterator node_it = n->getChildIterator(); Ogre::MovableObject *m; while(object_it.hasMoreElements()) { for(int i = 0; i < level + 2; i++) { ss << " "; } m = object_it.getNext(); ss << "parent(" << m->getParentSceneNode()->getName() << ") type " << m->getMovableType() << ": " << m->getName() << std::endl; } while(node_it.hasMoreElements()) { DumpNodes(ss, node_it.getNext(), level + 2); } }
void GameBodyObject::DumpNodes(NxOgre::StringPairList &l, Ogre::Node *n, int level, int nid) { Ogre::SceneNode::ObjectIterator object_it = ((Ogre::SceneNode *)n)->getAttachedObjectIterator(); Ogre::Node::ChildNodeIterator node_it = n->getChildIterator(); Ogre::MovableObject *m; Ogre::Entity *e; if (level != 0) { l.insert( "Node" + Ogre::StringConverter::toString(nid) + "-Position", Ogre::StringConverter::toString(n->getPosition())); } int i=0; while(object_it.hasMoreElements()) { m = object_it.getNext(); if (m->getMovableType() == "Entity") { e = static_cast<Ogre::Entity*>(m); NxOgre::NxString entitySuffix = ""; if (i > 0) { entitySuffix = Ogre::StringConverter::toString(i); } if (level == 0) { l.insert("Entity" + entitySuffix, e->getMesh()->getName()); } else { l.insert( "Node" + Ogre::StringConverter::toString(nid) + "-Entity" + entitySuffix, e->getMesh()->getName() ); } } i++; } while(node_it.hasMoreElements()) { DumpNodes(l, node_it.getNext(), level + 1, nid++); } }
void GameBodyObject::restoreCustom(NxOgre::StringPairList spl) { mNode = mpScene->getOgreSceneManager()->getRootSceneNode()->createChildSceneNode(); for (NxOgre::StringPairList::StringPair sp = spl.begin();spl.hasNext();) { sp = spl.next(); /* std::stringstream ss; ss << sp.first; ss << " => "; ss << sp.second; ss << std::endl; NxDebug(ss.str()); */ NxOgre::NxString key = sp.first; Ogre::StringUtil::toLowerCase(key); if (key == "entity" || key == "node") { Ogre::Entity* entity = mpScene->getOgreSceneManager()->createEntity( mName + "-" + sp.second + "-" + Ogre::StringConverter::toString(mNode->numAttachedObjects()), sp.second ); mNode->attachObject(entity); } if (key == "node-scale") { mNode->setScale(Ogre::StringConverter::parseVector3(sp.second)); } } // Assign first Attached Object that is an entity to mEntity Ogre::SceneNode::ObjectIterator object_it = mNode->getAttachedObjectIterator(); Ogre::MovableObject *m; while(object_it.hasMoreElements()) { m = object_it.getNext(); if (m->getMovableType() == "Entity") { mEntity = (Ogre::Entity*) m; break; } } mNode->setPosition(getGlobalPosition()); mNode->setOrientation(getGlobalOrientation()); }
void SelectionBox::performSelection(std::list<AgentId> &selection, Ogre::Camera *mCamera) { if((mRight - mLeft) * (mBottom - mTop) < 0.0001) return; float left = (mLeft + 1.f) / 2.f; float right = (mRight + 1.f) / 2.f; float top = (1.f - mBottom) / 2.f; float bottom = (1.f - mTop) / 2.f; Ogre::Ray topLeft = mCamera->getCameraToViewportRay(left, top); Ogre::Ray topRight = mCamera->getCameraToViewportRay(right, top); Ogre::Ray bottomLeft = mCamera->getCameraToViewportRay(left, bottom); Ogre::Ray bottomRight = mCamera->getCameraToViewportRay(right, bottom); // These planes have now defined an "open box" which extends to infinity in front of the camera. You can think of // the rectangle we drew with the mouse as being the termination point of the box just in front of the camera. Ogre::PlaneBoundedVolume vol; const Ogre::Real min = .1, max = 500; vol.planes.push_back(Ogre::Plane(topLeft.getPoint(min), topRight.getPoint(min), bottomRight.getPoint(min))); // front plane vol.planes.push_back(Ogre::Plane(topLeft.getOrigin(), topLeft.getPoint(max), topRight.getPoint(max))); // top plane vol.planes.push_back(Ogre::Plane(topLeft.getOrigin(), bottomLeft.getPoint(max), topLeft.getPoint(max))); // left plane vol.planes.push_back(Ogre::Plane(bottomLeft.getOrigin(), bottomRight.getPoint(max), bottomLeft.getPoint(max))); // bottom plane vol.planes.push_back(Ogre::Plane(topRight.getOrigin(), topRight.getPoint(max), bottomRight.getPoint(max))); // right plane Ogre::PlaneBoundedVolumeList volList; volList.push_back(vol); mVolQuery->setVolumes(volList); Ogre::SceneQueryResult result = mVolQuery->execute(); // Finally we need to handle the results of the query. First we will deselect all previously selected objects, // then we will select all objects which were found by the query. std::list<Ogre::SceneNode *> nodes; Ogre::SceneQueryResultMovableList::iterator iter; for(iter = result.movables.begin(); iter != result.movables.end(); ++iter) { Ogre::MovableObject *movable = *iter; if(movable->getMovableType().compare("Entity") == 0) { Ogre::Entity *pentity = static_cast<Ogre::Entity *>(movable); nodes.push_back(pentity->getParentSceneNode()); } } mEngine->level()->getAgentsIdsFromSceneNodes(nodes, selection); }
// BETWEEN FRAME OPERATION void VisCalcFrustDist::calculateEntityVisibility(Ogre::Node* regionNode, Ogre::Node* node, bool recurse) { if (recurse && node->numChildren() > 0) { // if node has more children nodes, visit them recursivily Ogre::SceneNode::ChildNodeIterator nodeChildIterator = node->getChildIterator(); while (nodeChildIterator.hasMoreElements()) { Ogre::Node* nodeChild = nodeChildIterator.getNext(); // 'false' causes it to not visit sub-children which are included in parent and pos relative to parent calculateEntityVisibility(regionNode, nodeChild, false); visChildren++; } } visNodes++; // children taken care of... check fo attached objects to this node Ogre::SceneNode* snode = (Ogre::SceneNode*)node; // the camera needs to be made relative to the region // Ogre::Vector3 relCameraPos = LG::RendererOgre::Instance()->m_camera->getPosition() - regionNode->getPosition(); // float snodeDistance = LG::RendererOgre::Instance()->m_camera->getPosition().distance(snode->_getWorldAABB().getCenter()); // float snodeDistance = relCameraPos.distance(snode->getPosition()); float snodeDistance = LG::RendererOgre::Instance()->m_camera->getDistanceFromCamera(regionNode, snode->getPosition()); Ogre::SceneNode::ObjectIterator snodeObjectIterator = snode->getAttachedObjectIterator(); while (snodeObjectIterator.hasMoreElements()) { Ogre::MovableObject* snodeObject = snodeObjectIterator.getNext(); if (snodeObject->getMovableType() == "Entity") { visEntities++; Ogre::Entity* snodeEntity = (Ogre::Entity*)snodeObject; // check it's visibility if it's not world geometry (terrain and ocean) if ((snodeEntity->getQueryFlags() & Ogre::SceneManager::WORLD_GEOMETRY_TYPE_MASK) == 0) { // computation if it should be visible // Note: this call is overridden by derived classes that do fancier visibility rules bool shouldBeVisible = this->CalculateVisibilityImpl(LG::RendererOgre::Instance()->m_camera, snodeEntity, snodeDistance); if (snodeEntity->isVisible()) { // we currently think this object is visible. make sure it should stay that way if (shouldBeVisible) { // it should stay visible visVisToVis++; } else { // not visible any more... make invisible nad unload it` /* Ogre::Vector3 cPos = LG::RendererOgre::Instance()->m_camera->getPosition(); Ogre::Vector3 rPos = regionNode->getPosition(); Ogre::Vector3 sPos = snode->getPosition(); LG::Log("VisToInVis: cPos=<%f,%f,%f>, rPos=<%f,%f,%f>, sPos(%s)=<%f,%f,%f>, d=%f", cPos.x, cPos.y, cPos.z, rPos.x, rPos.y, rPos.z, snode->getName().c_str(), sPos.x, sPos.y, sPos.z, snodeDistance); */ snodeEntity->setVisible(false); snode->needUpdate(true); visVisToInvis++; if (!snodeEntity->getMesh().isNull()) { queueMeshUnload(snodeEntity->getMesh()); } } } else { // the entity currently thinks it's not visible. // check to see if it should be visible by checking a fake bounding box if (shouldBeVisible) { // it should become visible again if (!snodeEntity->getMesh().isNull()) { // queueMeshLoad(snodeEntity, snodeEntity->getMesh()); LG::OLMeshTracker::Instance()->MakeLoaded(snodeEntity->getMesh()->getName(), Ogre::String(""), Ogre::String("visible"), snodeEntity); } // snodeEntity->setVisible(true); // must happen after mesh loaded visInvisToVis++; } else { visInvisToInvis++; } } } } } }
bool CollisionTools::raycast(const Ogre::Ray &ray, Ogre::Vector3 &result,Ogre::MovableObject* &target,float &closest_distance, const Ogre::uint32 queryMask) { target = NULL; // check we are initialised if (mRaySceneQuery != NULL) { // create a query object mRaySceneQuery->setRay(ray); mRaySceneQuery->setSortByDistance(true); mRaySceneQuery->setQueryMask(queryMask); // execute the query, returns a vector of hits if (mRaySceneQuery->execute().size() <= 0) { // raycast did not hit an objects bounding box return (false); } } else { //LOG_ERROR << "Cannot raycast without RaySceneQuery instance" << ENDLOG; return (false); } // at this point we have raycast to a series of different objects bounding boxes. // we need to test these different objects to see which is the first polygon hit. // there are some minor optimizations (distance based) that mean we wont have to // check all of the objects most of the time, but the worst case scenario is that // we need to test every triangle of every object. //Ogre::Ogre::Real closest_distance = -1.0f; closest_distance = -1.0f; Ogre::Vector3 closest_result; Ogre::RaySceneQueryResult &query_result = mRaySceneQuery->getLastResults(); #if 0 for (size_t qr_idx = 0; qr_idx < query_result.size(); qr_idx++) { const Ogre::RaySceneQueryResultEntry& result = query_result[qr_idx]; Ogre::Real distance = result.distance; Ogre::MovableObject* movable = static_cast<Ogre::MovableObject*>(result.movable); Ogre::SceneQuery::WorldFragment* worldFragment = result.worldFragment; if (movable) { const Ogre::String& type = movable->getMovableType(); const Ogre::String& name = movable->getName(); const Ogre::String& parentName = movable->getParentNode()->getName(); Ogre::uint32 flag = movable->getQueryFlags(); if (type.compare("Entity") == 0) { Ogre::Entity* ent = (Ogre::Entity*)movable; } std::ostrstream oss; oss<<"name:"<<name<<" distance:"<< distance <<" type:"<<type<<" flag:"<<flag<<" parent:"<<parentName<<std::endl; OutputDebugString(oss.str() ); } } #endif for (size_t qr_idx = 0; qr_idx < query_result.size(); qr_idx++) { // stop checking if we have found a raycast hit that is closer // than all remaining entities if ((closest_distance >= 0.0f) && (closest_distance < query_result[qr_idx].distance)) { break; } // only check this result if its a hit against an entity if ((query_result[qr_idx].movable != NULL) && (query_result[qr_idx].movable->getMovableType().compare("Entity") == 0)) { // get the entity to check Ogre::MovableObject *pentity = static_cast<Ogre::MovableObject*>(query_result[qr_idx].movable); // mesh data to retrieve size_t vertex_count; size_t index_count; Ogre::Vector3 *vertices = NULL; Ogre::uint32 *indices = NULL; // get the mesh information GetMeshInformation(((Ogre::Entity*)pentity)->getMesh(), vertex_count, vertices, index_count, indices, pentity->getParentNode()->_getDerivedPosition(), pentity->getParentNode()->_getDerivedOrientation(), pentity->getParentNode()->_getDerivedScale()); // test for hitting individual triangles on the mesh bool new_closest_found = false; for (size_t i = 0; i < index_count; i += 3) { // check for a hit against this triangle std::pair<bool, Ogre::Real> hit = Ogre::Math::intersects(ray, vertices[indices[i]], vertices[indices[i+1]], vertices[indices[i+2]], true, false); // if it was a hit check if its the closest if (hit.first) { if ((closest_distance < 0.0f) || (hit.second < closest_distance)) { // this is the closest so far, save it off closest_distance = hit.second; new_closest_found = true; } } } // free the verticies and indicies memory delete vertices; delete indices; // if we found a new closest raycast for this object, update the // closest_result before moving on to the next object. if (new_closest_found) { target = pentity; closest_result = ray.getPoint(closest_distance); } } } // return the result if (closest_distance >= 0.0f) { // raycast success result = closest_result; return (true); } else { // raycast failed return (false); } }
void RenderBoxWrap::synchronizeSceneNode(Ogre::SceneNode* _newNode, Ogre::SceneNode* _fromNode) { if (_newNode == nullptr || _fromNode == nullptr) { MYGUI_ASSERT(_newNode == nullptr || _fromNode == nullptr,"Synchronize scene node error."); return; } _newNode->setPosition(_fromNode->getPosition()); _newNode->setOrientation(_fromNode->getOrientation()); int i = 0; while (i < _newNode->numAttachedObjects()) { Ogre::MovableObject * object = _newNode->getAttachedObject(i); Ogre::Entity* entity = object->getMovableType() == "Entity" ? static_cast<Ogre::Entity*>(object) : nullptr; if(entity) { object = findMovableObject(_fromNode, entity->getName()); Ogre::Entity* oldEntity = (object != nullptr && object->getMovableType() == "Entity") ? static_cast<Ogre::Entity*>(object) : nullptr; if(!oldEntity) { removeEntity(entity->getName()); continue; } } i++; } for(i = 0; i < _fromNode->numAttachedObjects(); i++) { Ogre::MovableObject * object = _fromNode->getAttachedObject(i); Ogre::Entity* entity = object->getMovableType() == "Entity" ? static_cast<Ogre::Entity*>(object) : nullptr; if(entity) { object = findMovableObject(_newNode, entity->getName()); Ogre::Entity* newEntity = (object != nullptr && object->getMovableType() == "Entity") ? static_cast<Ogre::Entity*>(object) : nullptr; if(!newEntity) { //System::Console::WriteLine("create new entity {0}", gcnew System::String(entity->getName().c_str())); newEntity = mScene->createEntity(entity->getName(), entity->getMesh()->getName());//new Ogre::Entity(entity->getName(), (Ogre::MeshPtr)entity->getMesh().get()->getHandle()); _newNode->attachObject(newEntity); mVectorEntity.push_back(newEntity); if(mEntity == nullptr) { mEntity = newEntity; } } } } i = 0; while (i < _newNode->numChildren()) { Ogre::SceneNode* oldNode = findSceneNodeObject(_fromNode, _newNode->getChild(i)->getName()); if(!oldNode) { Ogre::SceneNode* forDelete = (Ogre::SceneNode*)_newNode->getChild(i); removeNode(forDelete); }else { i++; } } for(i = 0; i < _fromNode->numChildren(); i++) { if(_fromNode->getChild(i)->numChildren() != 0 && ((Ogre::SceneNode*)_fromNode->getChild(i))->numAttachedObjects() != 0) { Ogre::SceneNode* newChildNode = findSceneNodeObject(_newNode, _fromNode->getChild(i)->getName()); if(!newChildNode) { //System::Console::WriteLine("create new node {0}", gcnew System::String(_fromNode->getChild(i)->getName().c_str())); newChildNode = _newNode->createChildSceneNode(_fromNode->getChild(i)->getName(), _fromNode->getChild(i)->getPosition(), _fromNode->getChild(i)->getOrientation()); } synchronizeSceneNode(newChildNode, (Ogre::SceneNode*)_fromNode->getChild(i)); } } }
void CSaveSceneView::SceneNodeExplore(Ogre::SceneNode *SceneNode) { Ogre::Entity *Entity = NULL; Ogre::Camera *Camera = NULL; Ogre::Light *Light = NULL; Ogre::ParticleSystem *ParticleSystem = NULL; Ogre::ManualObject *ManualObject = NULL; Ogre::BillboardSet *BillboardSet = NULL; xmlTextWriterStartElement(m_XmlWriter, BAD_CAST "SceneNode"); Ogre::String SceneNodeName = SceneNode->getName(); xmlTextWriterWriteAttribute(m_XmlWriter, BAD_CAST "SceneNodeName", BAD_CAST SceneNodeName.c_str()); Ogre::SceneNode::ObjectIterator obji = SceneNode->getAttachedObjectIterator(); while (obji.hasMoreElements()) { Ogre::MovableObject* mobj = obji.getNext(); Ogre::String Type = mobj->getMovableType(); if (Type == "Entity") { Entity = (Ogre::Entity *)(mobj); Ogre::String EntityName = Entity->getName(); xmlTextWriterStartElement(m_XmlWriter, BAD_CAST "Entity"); xmlTextWriterWriteAttribute(m_XmlWriter, BAD_CAST "EntityName", BAD_CAST EntityName.c_str()); Ogre::MeshPtr Mesh = Entity->getMesh(); Ogre::String MeshName = Mesh->getName(); xmlTextWriterWriteAttribute(m_XmlWriter, BAD_CAST "MeshName", BAD_CAST MeshName.c_str()); xmlTextWriterEndElement(m_XmlWriter); } if (Type == "Camera") { Camera = (Ogre::Camera *)(mobj); Ogre::String CameraName = Camera->getName(); xmlTextWriterStartElement(m_XmlWriter, BAD_CAST "Camera"); xmlTextWriterWriteAttribute(m_XmlWriter, BAD_CAST "CameraName", BAD_CAST CameraName.c_str()); Ogre::Vector3 CameraPosition = Camera->getPosition(); xmlTextWriterWriteFormatAttribute(m_XmlWriter, BAD_CAST "XPosition", "%f",CameraPosition.x); xmlTextWriterWriteFormatAttribute(m_XmlWriter, BAD_CAST "YPosition", "%f",CameraPosition.y); xmlTextWriterWriteFormatAttribute(m_XmlWriter, BAD_CAST "ZPosition", "%f",CameraPosition.z); Ogre::Vector3 CameraDirection = Camera->getDirection(); xmlTextWriterWriteFormatAttribute(m_XmlWriter, BAD_CAST "XDirection", "%f",CameraDirection.x); xmlTextWriterWriteFormatAttribute(m_XmlWriter, BAD_CAST "YDirection", "%f",CameraDirection.y); xmlTextWriterWriteFormatAttribute(m_XmlWriter, BAD_CAST "ZDirection", "%f",CameraDirection.z); xmlTextWriterEndElement(m_XmlWriter); } if (Type == "Light") { Light = (Ogre::Light *)(mobj); } if (Type == "ParticleSystem") { ParticleSystem = (Ogre::ParticleSystem *)(mobj); } if (Type == "ManualObject") { ManualObject = (Ogre::ManualObject *)(mobj); } if (Type == "BillboardSet") { BillboardSet = (Ogre::BillboardSet *)(mobj); } } Ogre::Node::ChildNodeIterator nodei = SceneNode->getChildIterator(); while (nodei.hasMoreElements()) { Ogre::SceneNode* node = (Ogre::SceneNode*)(nodei.getNext()); // Add this subnode and its children... SceneNodeExplore(node); } xmlTextWriterEndElement(m_XmlWriter); //end SceneNode }
// Given a scene node for a terrain, find the manual object on that scene node and // update the manual object with the heightmap passed. If there is no manual object on // the scene node, remove all it's attachments and add the manual object. // The heightmap is passed in a 1D array ordered by width rows (for(width) {for(length) {hm[w,l]}}) // This must be called between frames since it touches the scene graph // BETWEEN FRAME OPERATION void Region::UpdateTerrain(const int hmWidth, const int hmLength, const float* hm) { Ogre::SceneNode* node = this->TerrainSceneNode; LG::Log("Region::UpdateTerrain: updating terrain for region %s", this->Name.c_str()); if (node == NULL) { LG::Log("Region::UpdateTerrain: terrain scene node doesn't exist. Not updating terrain."); return; } // Find the movable object attached to the scene node. If not found remove all. if (node->numAttachedObjects() > 0) { Ogre::MovableObject* attached = node->getAttachedObject(0); if (attached->getMovableType() != "ManualObject") { // don't know why this would ever happen but clean out the odd stuff LG::Log("Found extra stuff on terrain scene node"); node->detachAllObjects(); } } // if there is not a manual object on the node, create a new one if (node->numAttachedObjects() == 0) { LG::Log("Region::UpdateTerrain: creating terrain ManualObject for region %s", this->Name.c_str()); // if no attached objects, we add our dynamic ManualObject Ogre::ManualObject* mob = LG::RendererOgre::Instance()->m_sceneMgr->createManualObject("ManualObject/" + node->getName()); mob->addQueryFlags(Ogre::SceneManager::WORLD_GEOMETRY_TYPE_MASK); mob->setDynamic(true); mob->setCastShadows(true); mob->setVisible(true); node->attachObject(mob); // m_visCalc->RecalculateVisibility(); } Ogre::ManualObject* mo = (Ogre::ManualObject*)node->getAttachedObject(0); // stuff our heightmap information into the dynamic manual object mo->estimateVertexCount(hmWidth * hmLength); mo->estimateIndexCount(hmWidth * hmLength * 6); if (mo->getNumSections() == 0) { // if first time mo->begin(LG::GetParameter("Renderer.Ogre.DefaultTerrainMaterial")); } else { mo->beginUpdate(0); // we've been here before } int loc = 0; for (int xx = 0; xx < hmWidth; xx++) { for (int yy = 0; yy < hmLength; yy++) { mo->position((Ogre::Real)xx, (Ogre::Real)yy, hm[loc++]); mo->textureCoord((float)xx / (float)hmWidth, (float)yy / (float)hmLength); mo->normal(0.0, 1.0, 0.0); // always up (for the moment) } } for (int px = 0; px < hmLength-1; px++) { for (int py = 0; py < hmWidth-1; py++) { mo->quad(px + py * hmWidth, px + (py + 1) * hmWidth, (px + 1) + (py + 1) * hmWidth, (px + 1) + py * hmWidth ); } } mo->end(); return; }
void OgreInfo::diagnose(std::ostream& outputStream) { Ogre::SceneManagerEnumerator::SceneManagerIterator sceneManagerI = Ogre::Root::getSingleton().getSceneManagerIterator(); while (sceneManagerI.hasMoreElements()) { Ogre::SceneManager* sceneManager = sceneManagerI.getNext(); outputStream << "Scenemanager(" << sceneManager->getTypeName() << ") " << sceneManager->getName() << std::endl; outputStream << " Number of scene nodes: " << countNodes(sceneManager->getRootSceneNode()) << std::endl; outputStream << " Movable objects:" << std::endl; unsigned int movableObjectCounter = 0; Ogre::Root::MovableObjectFactoryIterator movableObjectFactoryI = Ogre::Root::getSingleton().getMovableObjectFactoryIterator(); while (movableObjectFactoryI.hasMoreElements()) { Ogre::MovableObjectFactory* factory = movableObjectFactoryI.getNext(); std::string type(factory->getType()); { Ogre::SceneManager::MovableObjectIterator I = sceneManager->getMovableObjectIterator(type); while (I.hasMoreElements()) { movableObjectCounter++; Ogre::MovableObject* movable = I.getNext(); if (movable->getMovableType() == "Light") { Ogre::Light* light = static_cast<Ogre::Light*> (movable); outputStream << " * Light " << light->getName() << "(" << (light->isInScene() ? "in scene" : "not in scene") << ")" << std::endl; outputStream << " Pos: " << light->getDerivedPosition() << std::endl; outputStream << " Direction: " << light->getDerivedDirection() << std::endl; } else { std::stringstream ssPosAndOrientation; if (movable->getParentSceneNode() && movable->isInScene()) { ssPosAndOrientation << " pos: " << movable->getParentSceneNode()->getPosition() << " orientation: " << movable->getParentSceneNode()->getOrientation(); } outputStream << " * " << type << " " << movable->getName() << "(" << (movable->isInScene() ? "in scene" : "not in scene") << ")" << ssPosAndOrientation.str() << std::endl; // outputStream << " Pos: " << light->getDerivedPosition() << std::endl; // outputStream << " Direction: " << light->getDerivedDirection() << std::endl; } } } } outputStream << " Number of movable objects: " << movableObjectCounter << std::endl; outputStream << " Cameras:" << std::endl; { Ogre::SceneManager::CameraIterator I = sceneManager->getCameraIterator(); while (I.hasMoreElements()) { Ogre::Camera* camera = I.getNext(); outputStream << " Camera " << camera->getName() << "(" << (camera->isInScene() ? "in scene" : "not in scene") << ")" << std::endl; outputStream << " Pos: " << camera->getDerivedPosition() << std::endl; outputStream << " Direction: " << camera->getDerivedDirection() << std::endl; outputStream << " Clip distances: " << camera->getNearClipDistance() << " - " << camera->getFarClipDistance() << std::endl; } } } size_t resourceMemoryUsage = 0; outputStream << "Resource Managers:" << std::endl; Ogre::ResourceGroupManager::ResourceManagerIterator I = Ogre::ResourceGroupManager::getSingleton().getResourceManagerIterator(); while (I.hasMoreElements()) { std::string name = I.peekNextKey(); Ogre::ResourceManager* manager = I.getNext(); outputStream << " Resource Manager: " << name << std::endl; if (manager->getMemoryBudget() == std::numeric_limits<size_t>::max()) { outputStream << " Memory budget: not set" << std::endl; } else { outputStream << " Memory budget: " << manager->getMemoryBudget() << " bytes" << std::endl; } outputStream << " Memory usage: " << manager->getMemoryUsage() << " bytes" << std::endl; resourceMemoryUsage += manager->getMemoryUsage(); Ogre::ResourceManager::ResourceMapIterator resourceI = manager->getResourceIterator(); if (resourceI.hasMoreElements()) { outputStream << " Resources: " << std::endl; int resourceCount = 0; int loadedResourceCount = 0; while (resourceI.hasMoreElements()) { Ogre::ResourcePtr resource = resourceI.getNext(); if (resource->isLoaded()) { std::string reloadable = resource->isReloadable() ? " reloadable" : ""; outputStream << " " << resource->getName() << " ( " << resource->getSize() << " bytes)" << reloadable; Ogre::Texture* texture = dynamic_cast<Ogre::Texture*>(resource.get()); if (texture) { outputStream << texture->getWidth() << "x" << texture->getHeight() << " "; } outputStream << std::endl; loadedResourceCount++; } resourceCount++; } outputStream << " Total number of resources: " << resourceCount << std::endl; outputStream << " Number of loaded resources: " << loadedResourceCount << std::endl; } } outputStream << "Total memory usage for all resource manager: " << resourceMemoryUsage << " bytes" << std::endl; outputStream << std::flush; }