{

char path[1024];

CFBundleRef mainBundle = CFBundleGetMainBundle();

assert(mainBundle);

CFURLRef mainBundleURL = CFBundleCopyBundleURL(mainBundle);

assert(mainBundleURL);

CFStringRef cfStringRef = CFURLCopyFileSystemPath( mainBundleURL, kCFURLPOSIXPathStyle);

assert(cfStringRef);

CFStringGetCString(cfStringRef, path, 1024, kCFStringEncodingASCII);

CFRelease(mainBundleURL);

CFRelease(cfStringRef);

return std::string(path);

{

if (m_pSingleton != nullptr)

{

TransformOperator::kill();

SelectionSet::kill();

delete m_pSingleton;

m_pSingleton = nullptr;

}

mRoot(nullptr), mSceneMgr(nullptr), mPlane(nullptr), m_pMainWindow(parent), m_pViewportGrid(nullptr)

{

initRoot(); // Init Ogre Root

initRenderSystem(); // Init Ogre Render System

initSceneMgr(); // Init Ogre SceneManager

{

const bool previousState = mInitializingScene;

mInitializingScene = true;

{ //TODO: Add the hability of the user adding/removing lights

mSceneMgr->setAmbientLight(Ogre::ColourValue(0.3f, 0.3f, 0.3f));

Ogre::Light* light = mSceneMgr->createLight();

light->setType(Ogre::Light::LT_DIRECTIONAL);

light->setDiffuseColour(1.0f, 1.0f, 1.0f);

light->setSpecularColour(.8f, .8f, .8f);// color of 'reflected' light

Ogre::SceneNode* lightSceneNode = mSceneMgr->getRootSceneNode()->createChildSceneNode();

lightSceneNode->attachObject(light);

lightSceneNode->setDirection(1, -1, 1);

}

m_pViewportGrid = new ViewportGrid();

mInitializingScene = previousState;

{

if (!groupNode || !mSceneMgr) return;

SentryReporter::addBreadcrumb("ui.action", "Ungroup node");

Ogre::SceneNode* parentNode = static_cast<Ogre::SceneNode*>(groupNode->getParent());

if (!parentNode)

parentNode = mSceneMgr->getRootSceneNode();

// Collect children (cannot modify during iteration)

QList<Ogre::SceneNode*> children;

for (auto& child : groupNode->getChildren()) {

Ogre::SceneNode* childNode = static_cast<Ogre::SceneNode*>(child);

if (!isForbiddenNodeName(QString::fromStdString(childNode->getName())))

children.append(childNode);

}

// Reparent children to the group's parent, preserving world transforms

for (Ogre::SceneNode* child : children) {

Ogre::Vector3 worldPos = child->_getDerivedPosition();

Ogre::Quaternion worldOrient = child->_getDerivedOrientation();

Ogre::Vector3 worldScale = child->_getDerivedScale();

groupNode->removeChild(child);

parentNode->addChild(child);

// Compute local transform relative to the new parent

Ogre::Quaternion parentWorldOrient = parentNode->_getDerivedOrientation();

Ogre::Vector3 parentWorldScale = parentNode->_getDerivedScale();

Ogre::Vector3 parentDerivedPos = parentNode->_getDerivedPosition();

child->setOrientation(parentWorldOrient.Inverse() * worldOrient);

child->setScale(worldScale / parentWorldScale);

child->setPosition(parentWorldOrient.Inverse() *

((worldPos - parentDerivedPos) / parentWorldScale));

}

// Destroy the now-empty group node

emit sceneNodeDestroyed(groupNode);

destroyAllAttachedMovableObjects(groupNode);

mSceneMgr->destroySceneNode(groupNode);

// Select the ungrouped children

if (!children.isEmpty()) {

SelectionSet::getSingleton()->selectOne(children.first());

for (int i = 1; i < children.size(); ++i)

SelectionSet::getSingleton()->append(children[i]);

}

{

if (!node) return false;

// A group node has no attached objects (entities) and has children

return node->numAttachedObjects() == 0 && node->numChildren() > 0;

{

if (!candidate || !ancestor) return false;

Ogre::Node* current = candidate->getParent();

while (current) {

if (current == ancestor) return true;

current = current->getParent();

}

return false;

{

if (!node || !newParent || !mSceneMgr) return false;

// Prevent reparenting to self

if (node == newParent) return false;

// Prevent cycles: newParent must not be a descendant of node

if (isDescendantOf(newParent, node)) return false;

// Already a child of newParent — nothing to do

if (node->getParent() == newParent) return false;

SentryReporter::addBreadcrumb("scene",

QString("Reparent '%1' under '%2'")

.arg(QString::fromStdString(node->getName()))

.arg(QString::fromStdString(newParent->getName())));

// Save world transform before reparenting

node->_update(true, true);

Ogre::Vector3 worldPos = node->_getDerivedPosition();

Ogre::Quaternion worldOrient = node->_getDerivedOrientation();

Ogre::Vector3 worldScale = node->_getDerivedScale();

// Reparent

Ogre::SceneNode* oldParent = static_cast<Ogre::SceneNode*>(node->getParent());

if (oldParent)

oldParent->removeChild(node);

newParent->addChild(node);

// Restore world transform as new local transform relative to newParent

newParent->_update(true, true);

Ogre::Quaternion parentWorldOrient = newParent->_getDerivedOrientation();

Ogre::Vector3 parentWorldScale = newParent->_getDerivedScale();

Ogre::Vector3 parentDerivedPos = newParent->_getDerivedPosition();

node->setOrientation(parentWorldOrient.Inverse() * worldOrient);

node->setScale(worldScale / parentWorldScale);

node->setPosition(parentWorldOrient.Inverse() *

((worldPos - parentDerivedPos) / parentWorldScale));

// Cascade-delete empty group ancestors: if removing this child left

// the old parent empty, destroy it — then check ITS parent, and so on.

Ogre::SceneNode* emptyCheck = oldParent;

while (emptyCheck && emptyCheck != mSceneMgr->getRootSceneNode()

&& emptyCheck->numAttachedObjects() == 0

&& emptyCheck->numChildren() == 0) {

Ogre::SceneNode* nextParent = static_cast<Ogre::SceneNode*>(emptyCheck->getParent());

emit sceneNodeDestroyed(emptyCheck);

destroyAllAttachedMovableObjects(emptyCheck);

mSceneMgr->destroySceneNode(emptyCheck);

emptyCheck = nextParent;

}

// Trigger scene tree rebuild

emit sceneNodeCreated(node);

return true;

{

SentryReporter::addBreadcrumb("scene", "Destroy scene node");

if (!mSceneMgr)

return;

try {

Ogre::SceneNode* node = mSceneMgr->getSceneNode(name.toStdString().data());

if (node)

{

destroySceneNode(node);

}

} catch (...) {

// Node may not exist or scene manager may be shutting down

}

{

if (!mSceneMgr)

return;

SentryReporter::addBreadcrumb("scene", "Destroy all user root scene nodes");

Ogre::SceneNode* root = mSceneMgr->getRootSceneNode();

QStringList names;

for (const auto& child : root->getChildren())

{

auto* childNode = static_cast<Ogre::SceneNode*>(child);

const QString name = QString::fromStdString(childNode->getName());

if (name.isEmpty() || isForbiddenNodeName(name))

continue;

// Match SceneTreeModel::buildChildren — skip transient gizmo rigs.

if (name == QStringLiteral("BevelGizmo_Node")

|| name == QStringLiteral("BevelGizmo_Shaft")

|| name == QStringLiteral("BevelGizmo_Handle"))

continue;

names.append(name);

}

for (const QString& name : names)

destroySceneNode(name);

{

if(!node || !mSceneMgr || isForbiddenNodeName(node->getName().c_str()))

return;

// Check if node still exists and belongs to our scene manager

try {

if (node->getCreator() != mSceneMgr)

return;

} catch (...) {

// Node may already be destroyed or invalid

return;

}

if(PrimitiveObject::isPrimitive(node))

{

PrimitiveObject* primitive = PrimitiveObject::getPrimitiveFromSceneNode(node);

node->getUserObjectBindings().clear();

delete primitive;

}

//TODO if custom class has to be provided for object, userany object should be inside so that this delete is not required...

emit sceneNodeDestroyed(node); // emitted before destruction so listeners can clean up while entities are still valid

destroyAllAttachedMovableObjects(node);

node->removeAndDestroyAllChildren();

// Safely destroy the scene node

try {

mSceneMgr->destroySceneNode(node);

} catch (...) {

// Ignore exceptions during shutdown

}

{

if(!node || !mSceneMgr)

return;

// Check if node is still valid

try {

if (node->getCreator() != mSceneMgr)

return;

} catch (...) {

// Node may already be destroyed or invalid

return;

}

// Collect mesh/skeleton resource names before destroying entities

std::vector<Ogre::String> meshNames;

std::vector<Ogre::String> skeletonNames;

try {

auto attachedObjects = node->getAttachedObjects();

for(auto attachedObject : attachedObjects)

{

try {

if (attachedObject->getMovableType() == "Entity")

{

auto* entity = static_cast<Ogre::Entity*>(attachedObject);

auto mesh = entity->getMesh();

if (mesh)

{

meshNames.push_back(mesh->getName());

if (!mesh->getSkeletonName().empty())

skeletonNames.push_back(mesh->getSkeletonName());

}

}

node->getCreator()->destroyMovableObject(attachedObject);

} catch (...) {

// Ignore exceptions during cleanup

}

}

} catch (...) {

// Ignore exceptions during cleanup

}

// Remove mesh/skeleton resources no longer in use by any entity

for (const auto& name : meshNames)

{

try {

auto mesh = Ogre::MeshManager::getSingleton().getByName(name);

// use_count == 2 means only MeshManager + this local variable hold it

if (mesh && mesh.use_count() <= 2)

Ogre::MeshManager::getSingleton().remove(mesh);

} catch (...) {}

}

for (const auto& name : skeletonNames)

{

try {

auto skel = Ogre::SkeletonManager::getSingleton().getByName(name);

if (skel && skel.use_count() <= 2)

Ogre::SkeletonManager::getSingleton().remove(skel);

} catch (...) {}

}

// Recurse to child SceneNodes

try {

auto children = node->getChildren();

for(auto child : children)

{

Ogre::SceneNode* pChildNode = static_cast<Ogre::SceneNode*>(child);

destroyAllAttachedMovableObjects( pChildNode );

}

} catch (...) {

// Ignore exceptions during cleanup

}

{

try {

return mSceneMgr->hasSceneNode(_name.toStdString());

} catch (...) {

return false;

}

{

for (Ogre::Node* child : parent->getChildren())

{

Ogre::SceneNode* pSN = static_cast<Ogre::SceneNode*>(child);

QString name = pSN->getName().data();

if (!Manager::getSingletonPtr()->isForbiddenNodeName(name))

{

out.append(pSN);

// Recurse into children (groups)

if (pSN->numChildren() > 0)

collectSceneNodesRecursive(pSN, out);

}

}

{

for (Ogre::Node* child : parent->getChildren())

{

Ogre::SceneNode* pSN = static_cast<Ogre::SceneNode*>(child);

QString name = pSN->getName().data();

if (!Manager::getSingletonPtr()->isForbiddenNodeName(name))

{

for (int entIndex = 0; entIndex < static_cast<int>(pSN->numAttachedObjects()); entIndex++)

{

Ogre::MovableObject* obj = pSN->getAttachedObject(entIndex);

if (obj->getMovableType() == "Entity")

out.append(static_cast<Ogre::Entity*>(obj));

}

// Recurse into children (groups)

if (pSN->numChildren() > 0)

collectEntitiesRecursive(pSN, out);

}

}

{

return (_name.isEmpty() //Ogre 14 creates unnamed nodes with empty string (e.g. SpaceCamera nodes)

||_name=="TPCameraChildSceneNode" //TODO add a define for TPCameraChildSceneNode

||_name=="GridLine_node" //TODO add a define for GridLine_node

||_name==SELECTIONBOX_OBJECT_NAME

||_name==TRANSFORM_OBJECT_NAME

||_name.startsWith("Unnamed_")); //This is the cameras's nodes

{

if(!entity->hasSkeleton()) return false;

auto animationStateSet = entity->getAllAnimationStates();

return std::any_of(animationStateSet->getAnimationStates().begin(), animationStateSet->getAnimationStates().end(),

[&_name](const std::pair<std::string, Ogre::AnimationState*>& animState)

{

return _name.toStdString() == animState.second->getAnimationName();

});

{

try

{

QString appDir = QCoreApplication::applicationDirPath();

// Use user-writable directory for config files (Video.cfg, Graphics.log)

QString userConfigDir = QStandardPaths::writableLocation(QStandardPaths::AppConfigLocation);

QDir configDir(userConfigDir);

if (!configDir.exists()) {

configDir.mkpath(".");

}

// Plugins config is read from installation directory (read-only is fine)

QString pluginsCfgPath = appDir + "/cfg/" + mPluginsCfg;

// User-specific config files go to writable location

QString videoCfgPath = userConfigDir + "/Video.cfg";

QString logPath = userConfigDir + "/Graphics.log";

qDebug() << "OGRE config paths:";

qDebug() << " Plugins:" << pluginsCfgPath;

qDebug() << " Video config:" << videoCfgPath;

qDebug() << " Log:" << logPath;

mRoot = new Ogre::Root(pluginsCfgPath.toStdString().data(),

videoCfgPath.toStdString().data(),

logPath.toStdString().data());

if (!mRoot)

{

throw std::logic_error("Erro: Iniciando Root\nFILE: "+std::string(__FILE__)+"\nLINE: "+QString::number(__LINE__).toStdString());

}

}

catch (std::logic_error const& le)

{

QMessageBox mBox;

mBox.setText(le.what());

mBox.exec();

}

{

Ogre::RenderSystem *renderSystem = mRoot->getRenderSystemByName("OpenGL Rendering Subsystem");

if (!renderSystem)

{

renderSystem = mRoot->getRenderSystemByName("OpenGL 3+ Rendering Subsystem");

}

if (!renderSystem)

{

OGRE_EXCEPT(Ogre::Exception::ERR_RENDERINGAPI_ERROR,

"No OpenGL rendering subsystem found. Check that Ogre plugins are installed correctly.",

"Manager::initRenderSystem");

}

mRoot->setRenderSystem( renderSystem );

SentryReporter::setTag("ogre_renderer", QString::fromStdString(renderSystem->getName()));

try {

mRoot->saveConfig();

} catch (const Ogre::Exception& e) {

qWarning() << "saveConfig failed (non-critical):" << e.getFullDescription().c_str();

}

mRoot->initialise(false); // don't create a window

// All objects will be build on this flag

Ogre::MovableObject::setDefaultQueryFlags(SCENE_QUERY_FLAGS);

{

/* Akira

mSceneMgr = mRoot->createSceneManager();

if (!mSceneMgr)

{

QMessageBox mBox;

mBox.setText(QStringLiteral("Error: Failed to create SceneManager"));

mBox.exec();

}

{

// RTSS must be initialized after a render window (GL context) exists

initRTShaderSystem();

QString file = QCoreApplication::applicationDirPath();

// Load resource paths from config file

Ogre::ConfigFile cf;

cf.load(QString(file+"/cfg/"+mResourcesCfg).toStdString());

// Go through all sections & settings in the file

const auto& seci = cf.getSettingsBySection();

for (const auto& [secName, settings] : seci)

{

for (const auto& [typeName, archName] : settings)

{

// Resolve relative paths against the application directory so that

// resources are found regardless of the current working directory

// (e.g., when launched from an installed .deb package).

QString archPath = QString::fromStdString(archName);

if (!QDir::isAbsolutePath(archPath)) {

#if OGRE_PLATFORM == OGRE_PLATFORM_APPLE

archPath = QString::fromStdString(macBundlePath()) + "/" + archPath;

#else

archPath = file + "/" + archPath;

#endif

}

Ogre::ResourceGroupManager::getSingleton().addResourceLocation(

archPath.toStdString(), typeName, secName);

}

}

Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();

// Material for all the GUI object

Ogre::MaterialPtr matptr = Ogre::MaterialManager::getSingleton().getByName(GUI_MATERIAL_NAME, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);

if(!matptr)

matptr = Ogre::static_pointer_cast<Ogre::Material>(Ogre::MaterialManager::getSingleton().create(GUI_MATERIAL_NAME, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME));

matptr->getTechnique(0)->setLightingEnabled(false);

matptr->getTechnique(0)->setSceneBlending(Ogre::SBT_TRANSPARENT_ALPHA);

matptr->getTechnique(0)->setDepthCheckEnabled( false ); //IMPORTANT when setRenderQueueGroup(Ogre::RENDER_QUEUE_OVERLAY);

{

const auto extensions = mValidFileExtention.split(" ");

for (const auto &ext : extensions)

if (_uri.endsWith(ext, Qt::CaseInsensitive))