//=============================================================================
// 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;
}
