void EC_Mesh::RemoveMesh()
{
OgreWorldPtr world = world_.lock();
if (entity_)
{
emit MeshAboutToBeDestroyed();
RemoveAllAttachments();
DetachEntity();
Ogre::SceneManager* sceneMgr = world->OgreSceneManager();
sceneMgr->destroyEntity(entity_);
entity_ = 0;
}
if (!cloned_mesh_name_.empty())
{
try
{
Ogre::MeshManager::getSingleton().remove(cloned_mesh_name_);
}
catch(Ogre::Exception& e)
{
LogWarning("EC_Mesh::RemoveMesh: Could not remove cloned mesh:" + std::string(e.what()));
}
cloned_mesh_name_ = std::string();
}
}
GameplayScreen::~GameplayScreen()
{
//Destroy our game objects
delete mWhacker;
for(unsigned int i=0; i<mDragons.size(); i++)
{
delete mDragons[i];
}
//Destroy all entities created
Ogre::SceneManager* mSceneManager = Ogre::Root::getSingletonPtr()->getSceneManager("ApplicationSceneManager");
mSceneManager->destroyEntity("Stage");
//Remove the stage mesh
mStageNode->removeAndDestroyAllChildren();
mStageNode->getParentSceneNode()->removeAndDestroyChild(mStageNode->getName());
//Destroy our score overlay
//To do this, we must traverse all elements contained within
//the overlay and remove them one at a time.
Ogre::OverlayManager* overlayMgr = Ogre::OverlayManager::getSingletonPtr();
Ogre::Overlay::Overlay2DElementsIterator iter = mOverlay->get2DElementsIterator();
for(;iter.hasMoreElements();)
{
Ogre::OverlayContainer * childContainer = iter.getNext();
Ogre::OverlayContainer::ChildIterator contIter = childContainer->getChildIterator();
for(;contIter.hasMoreElements();)
{
Ogre::OverlayElement* curElement = contIter.getNext();
overlayMgr->destroyOverlayElement(curElement->getName());
}
overlayMgr->destroyOverlayElement(childContainer->getName());
}
overlayMgr->destroy(mOverlay->getName());
}
void Obstacle::doDisable()
{
Ogre::SceneManager* sm = OgreGraphicsManager::getSingleton().getSceneManager();
_node->detachObject(_entity);
sm->destroySceneNode(_node);
sm->destroyEntity(_entity);
}
//-------------------------------------------------------------------------------------------
void MagickWidget::loadMesh(Ogre::MeshPtr pMesh)
{
QString directory(OgitorsRoot::getSingletonPtr()->GetProjectOptions()->ProjectDir.c_str());
if(directory.isEmpty())
directory = "./";
QDir(directory).mkpath("entitycache");
Ogre::TexturePtr texture = Ogre::TextureManager::getSingleton().createManual( "MeshMagickTex",
Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, Ogre::TEX_TYPE_2D,
512, 512, 0, Ogre::PF_R8G8B8A8 , Ogre::TU_RENDERTARGET );
Ogre::RenderTexture *rttTex = texture->getBuffer()->getRenderTarget();
Ogre::SceneManager *mSceneMgr = Ogre::Root::getSingletonPtr()->createSceneManager("OctreeSceneManager", "MeshMagickTexMgr");
Ogre::Light *dirl = mSceneMgr->createLight("DisplayLight");
dirl->setDirection(-1,-1,-1);
dirl->setDiffuseColour(1,1,1);
dirl->setType(Ogre::Light::LT_DIRECTIONAL);
Ogre::Camera* RTTCam = mSceneMgr->createCamera("MeshMagickCam");
RTTCam->setNearClipDistance(0.01F);
RTTCam->setFarClipDistance(0);
RTTCam->setAspectRatio(1);
RTTCam->setFOVy(Ogre::Degree(90));
RTTCam->setPosition(0,0,1);
RTTCam->lookAt(0,0,0);
Ogre::Viewport *v = rttTex->addViewport( RTTCam );
v->setClearEveryFrame( true );
v->setBackgroundColour(Ogre::ColourValue(0,0,0));
Ogre::Entity *mEntity;
mEntity = mSceneMgr->createEntity("scbDisplay", pMesh->getName());
mSceneMgr->getRootSceneNode()->attachObject(mEntity);
Ogre::Vector3 vSize = mEntity->getBoundingBox().getHalfSize();
Ogre::Vector3 vCenter = mEntity->getBoundingBox().getCenter();
vSize += Ogre::Vector3(vSize.z, vSize.z, vSize.z);
float maxsize = std::max(std::max(vSize.x,vSize.y),vSize.z);
vSize = Ogre::Vector3(0, 0, maxsize * 1.15f) + vCenter;
RTTCam->setPosition(vSize.x,vSize.y,vSize.z);
RTTCam->lookAt(vCenter.x,vCenter.y,vCenter.z);
rttTex->update();
Ogre::String imagefile = OgitorsUtils::QualifyPath(directory.toStdString() + "/entitycache/meshmagick.png");
rttTex->writeContentsToFile(imagefile);
mEntity->detachFromParent();
mSceneMgr->destroyEntity(mEntity);
rttTex->removeAllViewports();
Ogre::Root::getSingletonPtr()->destroySceneManager(mSceneMgr);
mDisplayWidget->setImage(QString(imagefile.c_str()));
}
void OgreEntityRenderer::unloadEntity()
{
setEntity(nullptr);
if (mEntity) {
Ogre::SceneManager* scenemgr = mTexture->getRenderContext()->getSceneManager();
scenemgr->destroyEntity(mEntity);
mEntity = nullptr;
}
}
Dragon::~Dragon()
{
//We only remove OGRE objects that were created in the Dragon class.
//The CollidableObject base class will take care of the rest
Ogre::SceneManager* mSceneManager = Ogre::Root::getSingletonPtr()->getSceneManager("ApplicationSceneManager");
mSceneManager->destroyEntity(mEntity->getName());
mSceneManager->destroyParticleSystem(mParticleSystem->getName());
mSceneNode->removeAndDestroyChild(mParticleNode->getName());
}
//-----------------------------------------------------------------------
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 OgreEntityRenderer::unloadEntity()
{
Ogre::SceneNode* node = mTexture->getRenderContext()->getSceneNode();
node->detachAllObjects();
if (mEntity) {
Ogre::SceneManager* scenemgr = mTexture->getRenderContext()->getSceneManager();
scenemgr->destroyEntity(mEntity);
mEntity = nullptr;
}
}
//-------------------------------------------------------------------
void Vob::destroyInvisibleVisual()
{
if(mInvisibleEntity)
{
SceneNode* sceneNode = mInvisibleEntity->getParentSceneNode();
Ogre::SceneManager* sceneManager = sceneNode->getCreator();
sceneNode->detachObject(mInvisibleEntity);
sceneManager->destroyEntity(mInvisibleEntity);
mInvisibleEntity = nullptr;
}
}
AreaEffect::~AreaEffect()
{
delete Ghost;
delete GraphicsSettings;
delete PhysicsSettings;
Ogre::SceneManager* OgreManager = Entresol::GetSingletonPtr()->GetSceneManager()->GetGraphicsWorldPointer();
if(GraphicsObject)
OgreManager->destroyEntity(GraphicsObject);
OgreManager->destroySceneNode(GraphicsNode);
}
void NpcAnimation::removeEntities(NifOgre::EntityList &entities)
{
assert(&entities != &mEntityList);
Ogre::SceneManager *sceneMgr = mInsert->getCreator();
for(size_t i = 0;i < entities.mEntities.size();i++)
{
entities.mEntities[i]->detachFromParent();
sceneMgr->destroyEntity(entities.mEntities[i]);
}
entities.mEntities.clear();
entities.mSkelBase = NULL;
}
//-----------------------------------------------------------------------
void SceneDecoratorExtern::destroyEntity(void)
{
if (mEntity)
{
Ogre::SceneManager* sceneManager = mParentTechnique->getParentSystem()->getSceneManager();
if (sceneManager)
{
sceneManager->destroyEntity(mEntityName);
mEntity = 0;
mEntityName = "";
}
}
}
void EC_WaterPlane::RemoveWaterPlane()
{
// Remove waterplane
if (world_.expired() || !entity_)
return;
DetachEntity();
Ogre::SceneManager* sceneMgr = world_.lock()->GetSceneManager();
sceneMgr->destroyEntity(entity_);
entity_ = 0;
Ogre::MeshManager::getSingleton().remove(Name().toStdString().c_str());
}
EC_Clone::~EC_Clone()
{
// OgreRendering module might be already deleted. If so, the cloned entity is also already deleted.
// In this case, just set pointer to 0.
if (!renderer_.expired())
{
Ogre::SceneManager *sceneMgr = renderer_.lock()->GetSceneManager();
if (entityClone_)
sceneMgr->destroyEntity(entityClone_);
}
else
{
entityClone_ = 0;
sceneNode_ = 0;
}
}
CollisionModel3D *EditorFrameHandler::GetCollisionModel(const char *modelname)
{
CollisionModel3D *hashres=NULL, *CollisionModel = NULL;
bool bres = CollisionModels.Find(modelname, &hashres);
if (!bres)
{
CollisionModel = newCollisionModel3D(false);
size_t vertex_count,index_count;
Ogre::Vector3* vertices;
unsigned long* indices;
Ogre::SceneManager *SceneMgr = CommonDeclarations::GetSceneManager();
Ogre::Entity *entity = SceneMgr->createEntity("tmpcollis", modelname);
Collidable::getMeshInformation(entity->getMesh().getPointer(),vertex_count,vertices,index_count,indices,Ogre::Vector3(0,0,0),Ogre::Quaternion::IDENTITY,Ogre::Vector3(1,1,1));
SceneMgr->destroyEntity(entity);
size_t index;
int numTris = (int)index_count / 3;
CollisionModel->setTriangleNumber(numTris);
for (unsigned i=0;i<index_count;i+=3)
{
index = indices[i];
CollisionModel->addTriangle(vertices[indices[i+0]].x,vertices[indices[i+0]].y,vertices[indices[i+0]].z,
vertices[indices[i+1]].x,vertices[indices[i+1]].y,vertices[indices[i+1]].z,
vertices[indices[i+2]].x,vertices[indices[i+2]].y,vertices[indices[i+2]].z);
}
CollisionModel->finalize();
delete[] vertices;
delete[] indices;
CollisionModels.Insert(modelname,CollisionModel);
} else
{
CollisionModel = hashres;
}
return CollisionModel;
}
void EC_Mesh::RemoveAttachmentMesh(uint index)
{
OgreWorldPtr world = world_.lock();
if (!entity_)
return;
if (index >= attachment_entities_.size())
return;
Ogre::SceneManager* sceneMgr = world->OgreSceneManager();
if (attachment_entities_[index] && attachment_nodes_[index])
{
// See if attached to a tagpoint or an ordinary node
Ogre::TagPoint* tag = dynamic_cast<Ogre::TagPoint*>(attachment_nodes_[index]);
if (tag)
{
entity_->detachObjectFromBone(attachment_entities_[index]);
}
else
{
Ogre::SceneNode* scenenode = dynamic_cast<Ogre::SceneNode*>(attachment_nodes_[index]);
if (scenenode)
{
scenenode->detachObject(attachment_entities_[index]);
sceneMgr->destroySceneNode(scenenode);
}
}
attachment_nodes_[index] = 0;
}
if (attachment_entities_[index])
{
if (attachment_entities_[index]->sharesSkeletonInstance())
attachment_entities_[index]->stopSharingSkeletonInstance();
sceneMgr->destroyEntity(attachment_entities_[index]);
attachment_entities_[index] = 0;
}
}
//!
//! Removes the OGRE entity containing the mesh geometry from the scene and
//! destroys it along with the OGRE scene node.
//!
void Model2SceneNode::destroyEntity ()
{
if (m_entity) {
// delete entity container
if (m_entityContainer) {
delete m_entityContainer;
m_entityContainer = 0;
}
// remove the entity from the scene node it is attached to
Ogre::SceneNode *parentSceneNode = m_entity->getParentSceneNode();
if (parentSceneNode)
parentSceneNode->detachObject(m_entity);
// destroy the entity through its scene manager
Ogre::SceneManager *sceneManager = OgreManager::getSceneManager();
if (sceneManager) {
sceneManager->destroyEntity(m_entity);
m_entity = 0;
}
}
}
bool operator()()
{
if(!component->ready())
return false;
Ogre::SceneManager* sm = GraphicsManager::get().sceneManager();
sm->destroySceneNode(
Ogre::StringConverter::toString(component->localId()));
sm->destroyEntity(
Ogre::StringConverter::toString(component->localId()));
component->m_sceneNode = 0;
component->m_particleSystem = 0;
ThreadPool::get().schedule(boost::bind(
&ComponentContainer::componentDetachedCallback,
component->parent(), component));
return true;
}
void
GraphicsMeshComponent::detachedCallback()
{
DEFERRED_CALL_VARS(DestroyGraphicsObjectCall)
ObjectId id;
GraphicsMeshComponentPtr component;
DEFERRED_CALL_CODE()
if(!component->ready())
return false;
Ogre::SceneManager* sm = GraphicsManager::get().sceneManager();
sm->destroyEntity(
Ogre::StringConverter::toString(component->localId()));
component->m_entity = 0;
sm->destroySceneNode(
Ogre::StringConverter::toString(component->localId()));
component->m_sceneNode = 0;
ThreadPool::get().schedule(boost::bind(
&ComponentContainer::componentDetachedCallback,
component->parent(), component));
return true;
DEFERRED_CALL_END()
DEFERRED_CALL_CREATE(DestroyGraphicsObjectCall)
call->id = parent()->id();
call->component = shared_from_this();
DEFERRED_CALL_ENQUEUE(GraphicsManager)
}
EC_Water::~EC_Water()
{
boost::shared_ptr<OgreRenderer::Renderer> renderer = framework_->GetServiceManager()->GetService
<OgreRenderer::Renderer>(Foundation::Service::ST_Renderer).lock();
if (!renderer) // Oops! Inconvenient dtor order - can't delete our own stuff since we can't get an instance to the owner.
return;
Ogre::SceneManager *sceneMgr = renderer->GetSceneManager();
if (!sceneMgr) // Oops! Same as above.
return;
//Sanity check
if ( scene_node_ == 0 || entity_ == 0)
return;
// Destroy the water node and entity.
scene_node_->detachObject(entity_);
sceneMgr->getRootSceneNode()->removeAndDestroyChild("WaterNode");
sceneMgr->destroyEntity(entity_);
entity_ = 0;
scene_node_ = 0;
framework_ = 0;
}
void ZoneListWidget::_createImages(ImageMap& retlist)
{
retlist.clear();
Ogre::TexturePtr texture = Ogre::TextureManager::getSingleton().createManual( "EntityTex",
Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, Ogre::TEX_TYPE_2D,
256, 256, 0, Ogre::PF_A8R8G8B8 , Ogre::TU_RENDERTARGET );
Ogre::RenderTexture *rttTex = texture->getBuffer()->getRenderTarget();
Ogre::SceneManager *mSceneMgr = Ogre::Root::getSingletonPtr()->createSceneManager("OctreeSceneManager", "EntityTexMgr");
Ogre::Light *dirl = mSceneMgr->createLight("DisplayLight");
dirl->setDirection(-1,-1,-1);
dirl->setDiffuseColour(1,1,1);
dirl->setType(Ogre::Light::LT_DIRECTIONAL);
Ogre::Camera* RTTCam = mSceneMgr->createCamera("EntityCam");
RTTCam->setNearClipDistance(0.01F);
RTTCam->setFarClipDistance(0);
RTTCam->setAspectRatio(1);
RTTCam->setFOVy(Ogre::Degree(90));
RTTCam->setPosition(0,0,1);
RTTCam->lookAt(0,0,0);
Ogre::Viewport *v = rttTex->addViewport( RTTCam );
v->setClearEveryFrame( true );
v->setBackgroundColour(Ogre::ColourValue(0,0,0,0));
ModularZoneFactory* factory = dynamic_cast<ModularZoneFactory*>(OgitorsRoot::getSingletonPtr()->GetEditorObjectFactory("Modular Zone Object"));
if(!factory)return;
factory->loadZoneTemplates();
ZoneInfoMap zoneTemplates = factory->getZoneTemplateMap();
Ogre::Entity *mEntity;
unsigned char dataptr[300 * 300 * 6];
unsigned char *dataptr2;
Ogre::PixelBox pb(256,256,1,Ogre::PF_A8R8G8B8, dataptr);
EntityMap entities;
ZoneInfoMap::iterator zi;
for(zi=zoneTemplates.begin();zi!=zoneTemplates.end();++zi)
{
Ogre::String addstr = (*zi).second.mMesh;
if(entities.find((*zi).first) == entities.end())
entities.insert(EntityMap::value_type((*zi).first,addstr));
}
EntityMap::const_iterator ite = entities.begin();
while(ite != entities.end())
{
Ogre::String addstr = ite->second;
mEntity = mSceneMgr->createEntity("MZP_Preview", addstr);
mSceneMgr->getRootSceneNode()->attachObject(mEntity);
//TODO: It would be nice to retrieve a Preview Camera Position from
//the .zone file
//TODO: also render portal outlines clearly so that the user can see
//how the zone is laid out
Ogre::Vector3 vSize = mEntity->getBoundingBox().getCorner(Ogre::AxisAlignedBox::NEAR_RIGHT_TOP);//.getHalfSize();//============
Ogre::Vector3 vCenter = mEntity->getBoundingBox().getCenter();
//FIXME ------ NICE PREVIEWS NEEDED - bigger
vSize += Ogre::Vector3(vSize.z, vSize.z, vSize.z);
float maxsize = std::max(std::max(vSize.x,vSize.y),vSize.z);
//vSize = Ogre::Vector3(0, 0, maxsize * 1.1f) + vCenter;
vSize = Ogre::Vector3(maxsize * 0.5f, vSize.y, maxsize * 0.5f) + vCenter;
//vSize.x +=vSize.x/2;//Maybe test to see which is larger x/2 or z/2 and use that?
//vSize.z +=vSize.x/2;
//RTTCam->setProjectionType(Ogre::PT_ORTHOGRAPHIC);
RTTCam->setPosition(vSize.x,vSize.y,vSize.z);
RTTCam->lookAt(vCenter.x,vCenter.y,vCenter.z);
rttTex->update();
rttTex->copyContentsToMemory(pb, Ogre::RenderTarget::FB_FRONT);
dataptr2 = new unsigned char[96 * 96 * 4];
Ogre::PixelBox pb2(96,96,1,Ogre::PF_A8R8G8B8, dataptr2);
Ogre::Image::scale(pb,pb2);
addstr.erase(addstr.length() - 5, 5);
retlist.insert(ImageMap::value_type((*ite).first, dataptr2));
mEntity->detachFromParent();
mSceneMgr->destroyEntity(mEntity);
ite++;
}
rttTex->removeAllViewports();
Ogre::Root::getSingletonPtr()->destroySceneManager(mSceneMgr);
Ogre::TextureManager::getSingletonPtr()->unload(texture->getName());
Ogre::TextureManager::getSingletonPtr()->remove(texture->getName());
}
void MaterialEditorFrame::OnFileOpen(wxCommandEvent& event)
{
wxFileDialog * openDialog = new wxFileDialog(this, wxT("Choose a file to open"), wxEmptyString, wxEmptyString,
wxT("All Ogre Files (*.material;*.mesh;*.program;*.cg;*.vert;*.frag)|*.material;*.mesh;*.program;*.cg;*.vert;*.frag|Material Files (*.material)|*.material|Mesh Files (*.mesh)|*.mesh|Program Files (*.program)|*.program|Cg Files (*.cg)|*.cg|GLSL Files(*.vert; *.frag)|*.vert;*.frag|All Files (*.*)|*.*"));
if(openDialog->ShowModal() == wxID_OK)
{
wxString path = openDialog->GetPath();
if(path.EndsWith(wxT(".material")) || path.EndsWith(wxT(".program")))
{
MaterialScriptEditor* editor = new MaterialScriptEditor(EditorManager::getSingletonPtr()->getEditorNotebook());
editor->loadFile(path);
int index = (int)path.find_last_of('\\');
if(index == -1) index = (int)path.find_last_of('/');
editor->setName((index != -1) ? path.substr(index + 1, path.Length()) : path);
EditorManager::getSingletonPtr()->openEditor(editor);
}
else if(path.EndsWith(wxT(".cg")))
{
CgEditor* editor = new CgEditor(EditorManager::getSingletonPtr()->getEditorNotebook());
editor->loadFile(path);
int index = (int)path.find_last_of('\\');
if(index == -1) index = (int)path.find_last_of('/');
editor->setName((index != -1) ? path.substr(index + 1, path.Length()) : path);
EditorManager::getSingletonPtr()->openEditor(editor);
}
else if(path.EndsWith(wxT(".mesh")))
{
Ogre::SceneManager *sceneMgr = wxOgre::getSingleton().getSceneManager();
Ogre::Camera *camera = wxOgre::getSingleton().getCamera();
if(mEntity)
{
sceneMgr->getRootSceneNode()->detachObject(mEntity);
sceneMgr->destroyEntity(mEntity);
mEntity = 0;
}
static int meshNumber = 0;
Ogre::String meshName = Ogre::String("Mesh") + Ogre::StringConverter::toString(meshNumber++);
int index = (int)path.find_last_of('\\');
if(index == -1) index = (int)path.find_last_of('/');
wxString mesh = (index != -1) ? path.substr(index + 1, path.Length()) : path;
mEntity = sceneMgr->createEntity(meshName, mesh.GetData());
sceneMgr->getRootSceneNode()->attachObject(mEntity);
Ogre::AxisAlignedBox box = mEntity->getBoundingBox();
Ogre::Vector3 minPoint = box.getMinimum();
Ogre::Vector3 maxPoint = box.getMaximum();
Ogre::Vector3 size = box.getSize();
wxOgre::getSingleton().setZoomScale(max(size.x, max(size.y, size.z)));
wxOgre::getSingleton().resetCamera();
Ogre::Vector3 camPos;
camPos.x = minPoint.x + (size.x / 2.0);
camPos.y = minPoint.y + (size.y / 2.0);
Ogre::Real width = max(size.x, size.y);
camPos.z = (width / tan(camera->getFOVy().valueRadians())) + size.z / 2;
wxOgre::getSingleton().getCamera()->setPosition(camPos);
wxOgre::getSingleton().getCamera()->lookAt(0,0,0);
wxOgre::getSingleton().getLight()->setPosition(maxPoint * 2);
}
}
}
SubModel::~SubModel()
{
Ogre::SceneManager* sceneManager = mEntity._getManager();
sceneManager->destroyEntity(&mEntity);
}