bool MapSystem::AddEmptyMap(const std::string& dataPath, const std::string& mapname)
{
if(IsMapLoaded(mapname))
{
return false;
}
if(GetSystemInterface()->FindDataFile(mapname) != "")
{
mLoadedMaps.push_back(MapData(mapname, dataPath, static_cast<unsigned int>(mLoadedMaps.size())));
return false;
}
std::string mappathrel = GetFilePath(mapname);
std::ostringstream os; os << dataPath << "/" << mappathrel;
std::string mappathabs = os.str();
if(!GetSystemInterface()->FileExists(mappathabs))
{
LOG_ERROR("Cannot create map in directory " << mappathabs << "! Does it exist?");
return false;
}
MapBeginLoadMessage msg;
msg.SetMapPath(mapname);
GetEntityManager().EmitMessage(msg);
mLoadedMaps.push_back(MapData(mapname, dataPath, static_cast<unsigned int>(mLoadedMaps.size())));
MapLoadedMessage msg2;
msg2.SetMapPath(mapname);
GetEntityManager().EmitMessage(msg2);
return true;
}
//----------------------------------------------------------------------------------------
void MegaDriveCOFLoader::UnloadROMFileFromModulePath(const std::wstring& targetROMModulePath) const
{
//Retrieve the set of ID numbers for all currently loaded modules
std::list<unsigned int> loadedModuleIDs = GetSystemInterface().GetLoadedModuleIDs();
//Attempt to retrieve the ID of the first matching loaded module file
bool foundLoadedModuleID = false;
unsigned int loadedModuleID;
std::list<unsigned int>::const_iterator loadedModuleIDIterator = loadedModuleIDs.begin();
while(!foundLoadedModuleID && (loadedModuleIDIterator != loadedModuleIDs.end()))
{
LoadedModuleInfo moduleInfo;
if(GetSystemInterface().GetLoadedModuleInfo(*loadedModuleIDIterator, moduleInfo))
{
if(moduleInfo.GetModuleFilePath() == targetROMModulePath)
{
foundLoadedModuleID = true;
loadedModuleID = moduleInfo.GetModuleID();
}
}
++loadedModuleIDIterator;
}
//If we managed to locate a module which was loaded from the target module file,
//unload it.
if(foundLoadedModuleID)
{
GetGUIInterface().UnloadModule(loadedModuleID);
}
}
bool MapSystem::LoadScene(const std::string& path)
{
// get data path containing this map
std::string abspath = GetSystemInterface()->FindDataFile(path);
if(abspath == "")
{
LOG_ERROR("Cannot find scene file: " << path);
return false;
}
std::string scenedatapath = GetSystemInterface()->GetDataFilePathFromFilePath(abspath);
if(scenedatapath == "")
{
LOG_ERROR("No data path for scene found!");
return false;
}
MapEncoder* enc = GetEncoderForScene(GetFileExtension(path));
if(!enc)
{
LOG_ERROR("Could not load scene: Loader not found for extension " << GetFileExtension(path));
return false;
}
bool success = enc->LoadSceneFromFile(path);
SceneLoadedMessage msg;
msg.SetSceneName(path);
GetEntityManager().EmitMessage(msg);
return success;
}
// If the requested texture is already in the database, it will be returned with an extra reference count. If not, it
// will be loaded through the application's render interface.
TextureResource* TextureDatabase::Fetch(const String& source, const String& source_directory)
{
String path;
if (source.Substring(0, 1) == "?")
path = source;
else
GetSystemInterface()->JoinPath(path, source_directory.Replace("|", ":"), source);
TextureMap::iterator iterator = instance->textures.find(path);
if (iterator != instance->textures.end())
{
(*iterator).second->AddReference();
return (*iterator).second;
}
TextureResource* resource = new TextureResource();
if (!resource->Load(path))
{
resource->RemoveReference();
return NULL;
}
instance->textures[resource->GetSource()] = resource;
return resource;
}
float Clock::GetElapsedTime()
{
SystemInterface* system_interface = GetSystemInterface();
if (system_interface != NULL)
return system_interface->GetElapsedTime();
else
return 0;
}
/** load all dlls in dir and check for plugin factories */
void ComponentPluginManager::LoadPluginsInDir(const std::string& path)
{
std::string cleanedPath(path);
if (path[path.size() - 1] == GetNativePathSeparator())
{
// remove the trailing path separator as this causes issues...
cleanedPath = path.substr(0, path.size() - 1);
}
if(!GetSystemInterface()->FileExists(cleanedPath))
{
LOG_ALWAYS("Plugin folder not found! Path: " + cleanedPath);
return;
}
std::string libExtension = GetLibExtension();
LOG_DEBUG("Looking for plugins with extension: " + libExtension);
// get libs from directory
SystemInterface::DirectoryContents files = GetSystemInterface()->GetDirectoryContents(cleanedPath);
// for each library in dir
SystemInterface::DirectoryContents::const_iterator i;
for(i = files.begin(); i != files.end(); ++i)
{
std::string fileName = *i;
if(fileName.size() <= libExtension.size())
continue;
std::string ending = fileName.substr(fileName.size() - libExtension.size(), fileName.size());
if(ending.compare(libExtension) != 0)
{
continue;
}
std::ostringstream libpath;
libpath << cleanedPath << GetNativePathSeparator() << fileName;
AddPlugin(libpath.str());
LOG_DEBUG("Loaded plugin: " + libpath.str());
}
}
std::set<ComponentType> ComponentPluginManager::AddPlugin(const std::string& path, const std::string& libname, bool saveWithScene)
{
std::string filename = GetSharedLibNameFromPluginName(libname);
std::string p = path + "/" + filename;
if(!GetSystemInterface()->FileExists(p))
{
std::set<ComponentType> ret;
return ret;
}
return AddPlugin(p, saveWithScene);
}
//----------------------------------------------------------------------------------------
void MegaDriveCOFLoader::UnloadROMFile()
{
//If at least one ROM module is currently loaded, unload the oldest module.
if(!currentlyLoadedROMModuleFilePaths.empty())
{
//Stop the system if it is currently running
GetSystemInterface().StopSystem();
//Unload the oldest currently loaded ROM module
std::wstring oldestLoadedROMModule = *currentlyLoadedROMModuleFilePaths.begin();
UnloadROMFileFromModulePath(oldestLoadedROMModule);
currentlyLoadedROMModuleFilePaths.pop_front();
}
}
bool MapSystem::LoadMap(const std::string& path)
{
if(IsMapLoaded(path))
{
LOG_ERROR("Map already loaded: " + path);
return false;
}
if(!MapExists(path))
{
LOG_ERROR("Map not found: " + path);
return false;
}
MapEncoder* enc = GetEncoderForMap(GetFileExtension(path));
if(!enc)
{
LOG_ERROR("Could not load map: Loader not found for extension " << GetFileExtension(path));
return false;
}
// get data path containing this map
std::string abspath = GetSystemInterface()->FindDataFile(path);
std::string mapdatapath = dtEntity::GetSystemInterface()->GetDataFilePathFromFilePath(abspath);
assert(mapdatapath != "");
LoadedMaps::size_type mapsaveorder = mLoadedMaps.size();
MapBeginLoadMessage msg;
msg.SetMapPath(path);
msg.SetDataPath(mapdatapath);
msg.SetSaveOrder(mapsaveorder);
GetEntityManager().EmitMessage(msg);
bool success = enc->LoadMapFromFile(path);
if(success)
{
mLoadedMaps.push_back(MapData(path, mapdatapath, static_cast<unsigned int>(mLoadedMaps.size())));
MapLoadedMessage msg1;
msg1.SetMapPath(path);
msg1.SetDataPath(mapdatapath);
msg1.SetSaveOrder(mapsaveorder);
GetEntityManager().EmitMessage(msg1);
}
return success;
}
//----------------------------------------------------------------------------------------
//Window functions
//----------------------------------------------------------------------------------------
bool ExodusSystemMenus::RegisterSystemMenuHandler()
{
//Retrieve the system GUI interface
model = &((ISystemGUIInterface&)GetSystemInterface());
//Create all menu handlers
debugMenuHandler = new DebugMenuHandler(*this, *model);
debugMenuHandler->LoadMenuItems();
settingsMenuHandler = new SettingsMenuHandler(*this, *model);
settingsMenuHandler->LoadMenuItems();
systemMenuHandler = new SystemMenuHandler(*this, *model);
systemMenuHandler->LoadMenuItems();
return true;
}
bool XMLNodeHandlerHead::ElementData(XMLParser* parser, const String& data)
{
const String& tag = parser->GetParseFrame()->tag;
// Store the title
if (tag == "title")
{
SystemInterface* system_interface = GetSystemInterface();
if (system_interface != NULL)
system_interface->TranslateString(parser->GetDocumentHeader()->title, data);
}
// Store an inline script
if (tag == "script" && data.Length() > 0)
parser->GetDocumentHeader()->scripts_inline.push_back(data);
// Store an inline style
if (tag == "style" && data.Length() > 0)
parser->GetDocumentHeader()->rcss_inline.push_back(data);
return true;
}
bool Assert(const char* msg, const char* file, int line)
{
Rocket::Core::String message(1024, "%s\n%s:%d", msg, file, line);
return GetSystemInterface()->LogMessage(Log::LT_ASSERT, message);
}
// Instances a single text element containing a string.
bool Factory::InstanceElementText(Element* parent, const String& text)
{
SystemInterface* system_interface = GetSystemInterface();
// Do any necessary translation. If any substitutions were made then new XML may have been introduced, so we'll
// have to run the data through the XML parser again.
String translated_data;
if (system_interface != NULL &&
(system_interface->TranslateString(translated_data, text) > 0 ||
translated_data.Find("<") != String::npos))
{
StreamMemory* stream = new StreamMemory(translated_data.Length() + 32);
stream->Write("<body>", 6);
stream->Write(translated_data);
stream->Write("</body>", 7);
stream->Seek(0, SEEK_SET);
InstanceElementStream(parent, stream);
stream->RemoveReference();
}
else
{
// Check if this text node contains only white-space; if so, we don't want to construct it.
bool only_white_space = true;
for (size_t i = 0; i < translated_data.Length(); ++i)
{
if (!StringUtilities::IsWhitespace(translated_data[i]))
{
only_white_space = false;
break;
}
}
if (only_white_space)
return true;
// Attempt to instance the element.
XMLAttributes attributes;
Element* element = Factory::InstanceElement(parent, "#text", "#text", attributes);
if (!element)
{
Log::Message(Log::LT_ERROR, "Failed to instance text element '%s', instancer returned NULL.", translated_data.CString());
return false;
}
// Assign the element its text value.
ElementText* text_element = dynamic_cast< ElementText* >(element);
if (text_element == NULL)
{
Log::Message(Log::LT_ERROR, "Failed to instance text element '%s'. Found type '%s', was expecting a derivative of ElementText.", translated_data.CString(), typeid(element).name());
element->RemoveReference();
return false;
}
text_element->SetText(translated_data);
// Add to active node.
parent->AppendChild(element);
element->RemoveReference();
}
return true;
}
bool MapSystem::MapExists(const std::string& path)
{
return (GetSystemInterface()->FindDataFile(path) != "");
}
osg::ref_ptr<osg::Node> ResourceManager::GetNode(EntityManager& em, const std::string& path, unsigned int options)
{
osg::Node* ret = NULL;
std::string abspath = GetSystemInterface()->FindDataFile(path);
if(abspath.empty())
{
LOG_ERROR("Error loading node, could not find data file: " << path);
return NULL;
}
if((options & ResourceManagerOptions::CopyNodes) != 0)
{
NodeStore::iterator i = mNodeStore.find(abspath);
if(i != mNodeStore.end())
{
ret = osg::clone(i->second.get(), osg::CopyOp(
osg::CopyOp::DEEP_COPY_OBJECTS |
osg::CopyOp::DEEP_COPY_NODES |
osg::CopyOp::DEEP_COPY_USERDATA
));
}
}
else if((options & ResourceManagerOptions::ShallowCopy) != 0)
{
NodeStore::iterator i = mNodeStore.find(abspath);
if(i != mNodeStore.end())
{
ret = osg::clone(i->second.get(), osg::CopyOp(
osg::CopyOp::DEEP_COPY_USERDATA
));
}
}
else if((options & ResourceManagerOptions::CopyHardwareMeshes) != 0)
{
NodeStore::iterator i = mNodeStore.find(abspath);
if(i != mNodeStore.end())
{
ret = osg::clone(i->second.get(), osg::CopyOp(
osg::CopyOp::DEEP_COPY_ALL
& ~osg::CopyOp::DEEP_COPY_PRIMITIVES
& ~osg::CopyOp::DEEP_COPY_ARRAYS
& ~osg::CopyOp::DEEP_COPY_TEXTURES
& ~osg::CopyOp::DEEP_COPY_STATEATTRIBUTES
& ~osg::CopyOp::DEEP_COPY_IMAGES
& ~osg::CopyOp::DEEP_COPY_SHAPES
& ~osg::CopyOp::DEEP_COPY_UNIFORMS
));
}
}
else if((options & ResourceManagerOptions::DeepCopy) != 0)
{
NodeStore::iterator i = mNodeStore.find(abspath);
if(i != mNodeStore.end())
{
ret = osg::clone(i->second.get(), osg::CopyOp(
osg::CopyOp::DEEP_COPY_ALL
));
}
}
if(ret != NULL)
{
ret->setUserData(NULL);
return ret;
}
osg::Node* node = osgDB::readNodeFile(abspath);
if(node == NULL)
{
LOG_ERROR("Error loading node, could not interpret data file: " << abspath);
return NULL;
}
if((options & ResourceManagerOptions::DoOptimization) != 0)
{
osgUtil::Optimizer optimizer;
optimizer.optimize(node);
}
if((options & ResourceManagerOptions::DeepCopy) == 0)
{
mNodeStore[abspath] = node;
}
ResourceLoadedMessage msg;
msg.SetPath(abspath);
em.EmitMessage(msg);
if((options & ResourceManagerOptions::CopyHardwareMeshes) != 0)
{
return osg::clone(node, osg::CopyOp(
osg::CopyOp::DEEP_COPY_ALL &
~osg::CopyOp::DEEP_COPY_PRIMITIVES &
~osg::CopyOp::DEEP_COPY_ARRAYS &
~osg::CopyOp::DEEP_COPY_TEXTURES
));
}
else
{
return node;
}
}
//----------------------------------------------------------------------------------------
//ROM loading functions
//----------------------------------------------------------------------------------------
void MegaDriveCOFLoader::LoadROMFile()
{
//##TODO## Add a path for autogenerated modules to our global preferences?
std::wstring autoGeneratedROMModuleFolderPath = PathCombinePaths(GetGUIInterface().GetGlobalPreferencePathModules(), L"AutoGenerated");
//Obtain the current working directory of the process, and use it as the initial
//folder location when searching for the target ROM file, unless this is the first
//time we're making a file selection. The current working directory is reserved within
//the Exodus platform for use by content loaders. We don't use the current working
//directory initially however, as Windows is kind enough to remember the last used
//folder path for a browse dialog between sessions, and we want to allow the last used
//path to be retrieved here by not specifying any initial path. Although this will not
//always do what we want, as any instance of the open file dialog in the application
//will alter the initial path we display here on startup, it's the best option we've
//found so far without persisting the last used path between sessions ourselves.
std::wstring initialSearchFolderPath;
if(selectionMadeThisSession)
{
initialSearchFolderPath = PathGetCurrentWorkingDirectory();
}
//Select a target file
std::wstring selectedFilePath;
if(!GetGUIInterface().SelectExistingFile(L"Mega Drive SNASM68K COF file|cof", L"cof", L"", initialSearchFolderPath, true, selectedFilePath))
{
return;
}
//Set the current working directory of the process to the directory of the selected
//file. We do this so that the selected directory path will be remembered when this
//dialog is next opened.
selectionMadeThisSession = true;
std::wstring selectedFileDirectory = PathGetDirectory(selectedFilePath);
PathSetCurrentWorkingDirectory(selectedFileDirectory);
//Build a module definition for the target ROM file
std::wstring romName;
HierarchicalStorageTree tree;
if(!BuildROMFileModuleFromFile(selectedFilePath, tree.GetRootNode(), romName))
{
return;
}
//Generate the file path for the output XML file
std::wstring autoGeneratedModuleOutputPath = PathCombinePaths(autoGeneratedROMModuleFolderPath, GetExtensionInstanceName());
std::wstring moduleFileName = romName + L".xml";
std::wstring moduleFilePath = PathCombinePaths(autoGeneratedModuleOutputPath, moduleFileName);
//Write the generated module structure to the target output file
if(!SaveOutputROMModule(tree, moduleFilePath))
{
return;
}
//Retrieve the current running state of the system, and stop the system if it is
//currently running.
ISystemExtensionInterface& system = GetSystemInterface();
bool systemRunningState = system.SystemRunning();
system.StopSystem();
//If we currently have at least one ROM module loaded, and the system reports that we
//can't currently load the new ROM module, assume we're currently using up all
//available connectors, and unload the oldest of the currently loaded ROM modules.
IGUIExtensionInterface& gui = GetGUIInterface();
if(!currentlyLoadedROMModuleFilePaths.empty() && !gui.CanModuleBeLoaded(moduleFilePath))
{
//Unload the oldest currently loaded ROM module
std::wstring oldestLoadedROMModule = *currentlyLoadedROMModuleFilePaths.begin();
UnloadROMFileFromModulePath(oldestLoadedROMModule);
currentlyLoadedROMModuleFilePaths.pop_front();
}
//Trigger an initialization of the system now that we're about to load a new ROM
//module
system.FlagInitialize();
//Attempt to load the module file we just generated back into the system
if(!gui.LoadModuleFromFile(moduleFilePath))
{
std::wstring text = L"Failed to load the generated module definition file. Check the event log for further info.";
std::wstring title = L"Error loading ROM!";
SafeMessageBox((HWND)GetGUIInterface().GetMainWindowHandle(), text, title, MB_ICONEXCLAMATION);
return;
}
//Restore the running state of the system
if(systemRunningState)
{
system.RunSystem();
}
//Record information on this loaded module
currentlyLoadedROMModuleFilePaths.push_back(moduleFilePath);
}
