Changeset 6404 for code/branches/presentation2/src

Timestamp:

Dec 23, 2009, 7:44:49 PM (15 years ago)

Author:

rgrieder

Message:

Simplified our resource system a bit by working with a single resource group on the user end.
However you can still declare resource groups for separate loading. But accessing the files will always look in all groups.

Location:

code/branches/presentation2/src

Files:

• libraries/core/GUIManager.cc (modified) (2 diffs)
• libraries/core/GraphicsManager.cc (modified) (3 diffs)
• libraries/core/Loader.cc (modified) (2 diffs)
• libraries/core/LuaState.cc (modified) (3 diffs)
• libraries/core/LuaState.h (modified) (2 diffs)
• libraries/core/Resource.cc (modified) (2 diffs)
• libraries/core/Resource.h (modified) (5 diffs)
• libraries/core/XMLFile.h (modified) (3 diffs)
• orxonox/LevelManager.cc (modified) (3 diffs)

code/branches/presentation2/src/libraries/core/GUIManager.cc

@@ -125 +125 @@
         // setup scripting
         luaState_.reset(new LuaState());
-        rootFileInfo_ = Resource::getInfo("InitialiseGUI.lua", "GUI");
+        rootFileInfo_ = Resource::getInfo("InitialiseGUI.lua");
         // This is necessary to ensure that input events also use the right resource info when triggering lua functions
         luaState_->setDefaultResourceInfo(this->rootFileInfo_);
@@ -142 +142 @@
 
         // Initialise the basic Lua code
-        this->luaState_->doFile("InitialiseGUI.lua", "GUI", false);
+        this->luaState_->doFile("InitialiseGUI.lua");
 
         // Align CEGUI mouse with OIS mouse

code/branches/presentation2/src/libraries/core/GraphicsManager.cc

@@ -100 +100 @@
 
         // At first, add the root paths of the data directories as resource locations
-        Ogre::ResourceGroupManager::getSingleton().addResourceLocation(PathConfig::getDataPathString(), "FileSystem", "dataRoot", false);
+        Ogre::ResourceGroupManager::getSingleton().addResourceLocation(PathConfig::getDataPathString(), "FileSystem");
         // Load resources
-        resources_.reset(new XMLFile("resources.oxr", "dataRoot"));
+        resources_.reset(new XMLFile("DefaultResources.oxr"));
         resources_->setLuaSupport(false);
         Loader::open(resources_.get());
@@ -109 +109 @@
         if (PathConfig::isDevelopmentRun())
         {
-            Ogre::ResourceGroupManager::getSingleton().addResourceLocation(PathConfig::getExternalDataPathString(), "FileSystem", "externalDataRoot", false);
-            extResources_.reset(new XMLFile("resources.oxr", "externalDataRoot"));
+            Ogre::ResourceGroupManager::getSingleton().addResourceLocation(PathConfig::getExternalDataPathString(), "FileSystem");
+            extResources_.reset(new XMLFile("resources.oxr"));
             extResources_->setLuaSupport(false);
             Loader::open(extResources_.get());
@@ -395 +395 @@
     {
         int orxonoxLevel;
-        switch (lml)
-        {
-        case Ogre::LML_TRIVIAL:
-            orxonoxLevel = this->ogreLogLevelTrivial_;
-            break;
-        case Ogre::LML_NORMAL:
-            orxonoxLevel = this->ogreLogLevelNormal_;
-            break;
-        case Ogre::LML_CRITICAL:
-            orxonoxLevel = this->ogreLogLevelCritical_;
-            break;
-        default:
-            orxonoxLevel = 0;
+        std::string introduction;
+        // Do not show caught OGRE exceptions in front
+        if (message.find("OGRE_EXCEPTION"))
+        {
+            orxonoxLevel = OutputLevel::Debug;
+            introduction = "Ogre, caught exception: ";
+        }
+        else
+        {
+            switch (lml)
+            {
+            case Ogre::LML_TRIVIAL:
+                orxonoxLevel = this->ogreLogLevelTrivial_;
+                break;
+            case Ogre::LML_NORMAL:
+                orxonoxLevel = this->ogreLogLevelNormal_;
+                break;
+            case Ogre::LML_CRITICAL:
+                orxonoxLevel = this->ogreLogLevelCritical_;
+                break;
+            default:
+                orxonoxLevel = 0;
+            }
+            introduction = "Ogre: ";
         }
         OutputHandler::getOutStream(orxonoxLevel)
-            << "Ogre: " << message << std::endl;
+            << introduction << message << std::endl;
     }
 

code/branches/presentation2/src/libraries/core/Loader.cc

@@ -128 +128 @@
             scoped_ptr<LuaState> luaState(new LuaState());
             luaState->setIncludeParser(&Loader::replaceLuaTags);
-            luaState->includeFile(file->getFilename(), file->getResourceGroup(), false);
+            luaState->includeFile(file->getFilename());
             xmlInput = luaState->getOutput().str();
         }
         else
         {
-            shared_ptr<ResourceInfo> info = Resource::getInfo(file->getFilename(), file->getResourceGroup());
+            shared_ptr<ResourceInfo> info = Resource::getInfo(file->getFilename());
             if (info == NULL)
             {
@@ -139 +139 @@
                 return false;
             }
-            xmlInput = Resource::open(file->getFilename(), file->getResourceGroup())->getAsString();
+            xmlInput = Resource::open(file->getFilename())->getAsString();
         }
 

code/branches/presentation2/src/libraries/core/LuaState.cc

@@ -86 +86 @@
     }
 
-    shared_ptr<ResourceInfo> LuaState::getFileInfo(const std::string& filename, const std::string& resourceGroup, bool bSearchOtherPaths)
-    {
-        shared_ptr<ResourceInfo> sourceInfo;
-        if (resourceGroup != "NoResourceGroupProvided")
-            sourceInfo = Resource::getInfo(filename, resourceGroup);
-
-        // Continue search if not explicitly forbidden
-        if (bSearchOtherPaths && sourceInfo == NULL)
-        {
-            // Call might be relative to the file currently being processed
-            sourceInfo = Resource::getInfo(sourceFileInfo_->path + filename, sourceFileInfo_->group);
-            if (sourceInfo == NULL)
-            {
-                // Maybe find something in the same group but in the root path
-                sourceInfo = Resource::getInfo(filename, sourceFileInfo_->group);
-            }
-        }
+    shared_ptr<ResourceInfo> LuaState::getFileInfo(const std::string& filename)
+    {
+        // Look in the current directory first
+        shared_ptr<ResourceInfo> sourceInfo = Resource::getInfo(sourceFileInfo_->path + filename);
+        // Continue search in root directories
+        if (sourceInfo == NULL && !sourceFileInfo_->path.empty())
+            sourceInfo = Resource::getInfo(filename);
         return sourceInfo;
     }
 
-    void LuaState::includeFile(const std::string& filename, const std::string& resourceGroup, bool bSearchOtherPaths)
-    {
-        shared_ptr<ResourceInfo> sourceInfo = this->getFileInfo(filename, resourceGroup, bSearchOtherPaths);
+    void LuaState::includeFile(const std::string& filename)
+    {
+        shared_ptr<ResourceInfo> sourceInfo = this->getFileInfo(filename);
         if (sourceInfo != NULL)
-            this->includeString(Resource::open(sourceInfo->filename, sourceInfo->group)->getAsString(), sourceInfo);
-        else
-            COUT(2) << "LuaState: Cannot include file '" << filename << "' in resource group '"
-                    << (resourceGroup == "NoResourceGroupProvided" ? sourceFileInfo_->group : resourceGroup) << "': group not found." << std::endl;
+            this->includeString(Resource::open(sourceInfo)->getAsString(), sourceInfo);
+        else
+            COUT(2) << "LuaState: Cannot include file '" << filename << "'." << std::endl;
     }
 
@@ -128 +117 @@
     }
 
-    void LuaState::doFile(const std::string& filename, const std::string& resourceGroup, bool bSearchOtherPaths)
-    {
-        shared_ptr<ResourceInfo> sourceInfo = this->getFileInfo(filename, resourceGroup, bSearchOtherPaths);
+    void LuaState::doFile(const std::string& filename)
+    {
+        shared_ptr<ResourceInfo> sourceInfo = this->getFileInfo(filename);
         if (sourceInfo != NULL)
-            this->doString(Resource::open(sourceInfo->filename, sourceInfo->group)->getAsString(), sourceInfo);
-        else
-            COUT(2) << "LuaState: Cannot do file '" << filename << "' in resource group '"
-                << (resourceGroup == "NoResourceGroupProvided" ? sourceFileInfo_->group : resourceGroup) << "': group not found." << std::endl;
+            this->doString(Resource::open(sourceInfo)->getAsString(), sourceInfo);
+        else
+            COUT(2) << "LuaState: Cannot do file '" << filename << "'." << std::endl;
     }
 
@@ -185 +173 @@
     }
 
-    bool LuaState::fileExists(const std::string& filename, const std::string& resourceGroup, bool bSearchOtherPaths)
-    {
-        shared_ptr<ResourceInfo> info =  this->getFileInfo(filename, resourceGroup, bSearchOtherPaths);
+    bool LuaState::fileExists(const std::string& filename)
+    {
+        shared_ptr<ResourceInfo> info = this->getFileInfo(filename);
         if (info == NULL)
             return false;

code/branches/presentation2/src/libraries/core/LuaState.h

@@ -71 +71 @@
         ~LuaState();
 
-        void doFile(const std::string& filename, const std::string& resourceGroup = "General", bool bSearchOtherPaths = true); // tolua_export
+        void doFile(const std::string& filename); // tolua_export
         void doString(const std::string& code, const shared_ptr<ResourceInfo>& sourceFileInfo = shared_ptr<ResourceInfo>());
 
-        void includeFile(const std::string& filename, const std::string& resourceGroup = "General", bool bSearchOtherPaths = true); // tolua_export
+        void includeFile(const std::string& filename); // tolua_export
         void includeString(const std::string& code, const shared_ptr<ResourceInfo>& sourceFileInfo = shared_ptr<ResourceInfo>());
 
         void luaPrint(const std::string& str); // tolua_export
         void luaLog(unsigned int level, const std::string& message); // tolua_export
-        bool fileExists(const std::string& filename, const std::string& resourceGroup = "General", bool bSearchOtherPaths = true); // tolua_export
+        bool fileExists(const std::string& filename); // tolua_export
 
         const std::stringstream& getOutput() const { return output_; }
@@ -98 +98 @@
 
     private:
-        shared_ptr<ResourceInfo> getFileInfo(const std::string& filename, const std::string& resourceGroup, bool bSearchOtherPaths);
+        shared_ptr<ResourceInfo> getFileInfo(const std::string& filename);
 
 #if LUA_VERSION_NUM != 501

code/branches/presentation2/src/libraries/core/Resource.cc

@@ -34 +34 @@
     std::string Resource::DEFAULT_GROUP(Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
 
-    DataStreamPtr Resource::open(const std::string& name, const std::string& group, bool bSearchGroupsIfNotFound)
+    DataStreamPtr Resource::open(const std::string& name)
     {
-        return Ogre::ResourceGroupManager::getSingleton().openResource(name, group, bSearchGroupsIfNotFound);
+        return Ogre::ResourceGroupManager::getSingleton().openResource(name,
+            Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, true);
     }
 
-    DataStreamListPtr Resource::openMulti(const std::string& pattern, const std::string& group)
+    DataStreamListPtr Resource::openMulti(const std::string& pattern)
     {
-        return Ogre::ResourceGroupManager::getSingleton().openResources(pattern, group);
+        DataStreamListPtr resources(new Ogre::DataStreamList());
+        const Ogre::StringVector& groups = Ogre::ResourceGroupManager::getSingleton().getResourceGroups();
+        for (Ogre::StringVector::const_iterator it = groups.begin(); it != groups.end(); ++it)
+        {
+            DataStreamListPtr temp = Ogre::ResourceGroupManager::getSingleton().openResources(pattern, *it);
+            resources->insert(resources->end(), temp->begin(), temp->end());
+        }
+        return resources;
     }
 
-    bool Resource::exists(const std::string& name, const std::string& group)
+    bool Resource::exists(const std::string& name)
     {
-        return Ogre::ResourceGroupManager::getSingleton().resourceExists(group, name);
+        try
+        {
+            Ogre::ResourceGroupManager::getSingleton().findGroupContainingResource(name);
+            return true;
+        }
+        catch (const Ogre::Exception&)
+        {
+            return false;
+        }
     }
 
-    shared_ptr<ResourceInfo> Resource::getInfo(const std::string& name, const std::string& group)
+    shared_ptr<ResourceInfo> Resource::getInfo(const std::string& name)
     {
+        std::string group;
+        try
+        {
+            group = Ogre::ResourceGroupManager::getSingleton().findGroupContainingResource(name);
+        }
+        catch (const Ogre::Exception&)
+        {
+            return shared_ptr<ResourceInfo>();
+        }
         Ogre::FileInfoListPtr infos = Ogre::ResourceGroupManager::getSingleton().findResourceFileInfo(group, name);
         for (std::vector<Ogre::FileInfo>::const_iterator it = infos->begin(); it != infos->end(); ++it)
@@ -67 +92 @@
         return shared_ptr<ResourceInfo>();
     }
+
+    StringVectorPtr Resource::findResourceNames(const std::string& pattern)
+    {
+        StringVectorPtr resourceNames(new Ogre::StringVector());
+        const Ogre::StringVector& groups = Ogre::ResourceGroupManager::getSingleton().getResourceGroups();
+        for (Ogre::StringVector::const_iterator it = groups.begin(); it != groups.end(); ++it)
+        {
+            StringVectorPtr temp = Ogre::ResourceGroupManager::getSingleton().findResourceNames(*it, pattern);
+            resourceNames->insert(resourceNames->end(), temp->begin(), temp->end());
+        }
+        return resourceNames;
+    }
 }

code/branches/presentation2/src/libraries/core/Resource.h

@@ -34 +34 @@
 #include <boost/shared_ptr.hpp>
 #include <OgreDataStream.h>
+#include <OgreStringVector.h>
 
 namespace orxonox
@@ -40 +41 @@
     using Ogre::DataStreamList;
     using Ogre::DataStreamListPtr;
+    using Ogre::StringVector;
+    using Ogre::StringVectorPtr;
 
     //! Stores basic information about a Resource from Ogre
@@ -56 +59 @@
     };
 
-    /**
-    @brief
-        Provides simple functions to easily access the Ogre::ResourceGroupManager
+    /** Provides simple functions to easily access the Ogre::ResourceGroupManager.
+        The wrapper functions also avoid having to deal with resource groups.
     */
     class _CoreExport Resource
@@ -72 +74 @@
             Even if resource locations are added recursively, you
             must provide a fully qualified name to this method.
-        @param groupName
-            The name of the resource group; this determines which
-            locations are searched.
-        @param searchGroupsIfNotFound
-            If true, if the resource is not found in
-            the group specified, other groups will be searched.
         @return
             Shared pointer to data stream containing the data. Will be
             destroyed automatically when no longer referenced.
         */
-        static DataStreamPtr open(const std::string& name,
-            const std::string& group = Resource::DEFAULT_GROUP,
-            bool bSearchGroupsIfNotFound = false);
+        static DataStreamPtr open(const std::string& name);
 
         //! Similar to open(string, string, bool), but with a fileInfo struct
-        static DataStreamPtr open(shared_ptr<ResourceInfo> fileInfo,
-            bool bSearchGroupsIfNotFound = false)
+        static DataStreamPtr open(shared_ptr<ResourceInfo> fileInfo)
         {
-            return open(fileInfo->filename, fileInfo->group, bSearchGroupsIfNotFound);
+            return open(fileInfo->filename);
         }
 
@@ -102 +95 @@
             added recursively, subdirectories will be searched too so this
             does not need to be fully qualified.
-        @param groupName
-            The resource group; this determines which locations
-            are searched.
         @return
             Shared pointer to a data stream list , will be
             destroyed automatically when no longer referenced
         */
-        static DataStreamListPtr openMulti(const std::string& pattern, const std::string& group = Resource::DEFAULT_GROUP);
+        static DataStreamListPtr openMulti(const std::string& pattern);
 
         /**
-            Find out if the named file exists in a group.
+            Find out if the named file exists.
         @param filename
             Fully qualified name of the file to test for
-        @param group
-            The name of the resource group
         */
-        static bool exists(const std::string& name, const std::string& group = Resource::DEFAULT_GROUP);
+        static bool exists(const std::string& name);
 
         /**
-            Get struct with information about group, path and size.
+            Get struct with information about path and size.
         @param filename
             Fully qualified name of the file to test for
-        @param group
-            The name of the resource group
         */
-        static shared_ptr<ResourceInfo> getInfo(const std::string& name, const std::string& group = Resource::DEFAULT_GROUP);
+        static shared_ptr<ResourceInfo> getInfo(const std::string& name);
+
+        /**
+            Retrieves a list with all resources matching a certain pattern.
+        @param pattern
+            The pattern to look for. If resource locations have been
+            added recursively, subdirectories will be searched too so this
+            does not need to be fully qualified.
+        */
+        static StringVectorPtr findResourceNames(const std::string& pattern);
 
         //! Name of the default resource group (usually "General")

code/branches/presentation2/src/libraries/core/XMLFile.h

@@ -40 +40 @@
     {
         public:
-            XMLFile(const std::string& filename, const std::string& resourceGroup = "General")
+            XMLFile(const std::string& filename)
                 : filename_(filename)
-                , group_(resourceGroup)
                 , bLuaSupport_(true)
             { }
-            XMLFile(const ClassTreeMask& mask, const std::string& filename, const std::string& resourceGroup = "General")
+            XMLFile(const ClassTreeMask& mask, const std::string& filename)
                 : filename_(filename)
-                , group_(resourceGroup)
                 , mask_(mask)
                 , bLuaSupport_(true)
@@ -55 +53 @@
 
             const std::string& getFilename() const { return this->filename_; }
-            const std::string& getResourceGroup() const { return this->group_; }
             const ClassTreeMask& getMask() const { return this->mask_; }
             bool getLuaSupport() const { return this->bLuaSupport_; }
@@ -61 +58 @@
         private:
             std::string filename_;
-            std::string group_;
             ClassTreeMask mask_;
             bool bLuaSupport_; // Default is true

code/branches/presentation2/src/orxonox/LevelManager.cc

@@ -30 +30 @@
 
 #include <map>
-#include <OgreResourceGroupManager.h>
 
 #include "core/CommandLineParser.h"
@@ -36 +35 @@
 #include "core/CoreIncludes.h"
 #include "core/Loader.h"
+#include "core/Resource.h"
 #include "core/ScopedSingletonManager.h"
 #include "PlayerManager.h"
@@ -132 +132 @@
     void LevelManager::compileAvailableLevelList()
     {
-        availableLevels_.clear();
-
-        availableLevels_ = *Ogre::ResourceGroupManager::getSingleton().findResourceNames(
-            Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, "*.oxw");
-
+        availableLevels_ = *Resource::findResourceNames("*.oxw");
         for (std::vector<std::string>::iterator it = availableLevels_.begin(); it != availableLevels_.end();)
             if (it->find("old/") == 0)