Changeset 5654 for code/branches/resource2

Timestamp:

Aug 17, 2009, 4:37:10 PM (15 years ago)

Author:

rgrieder

Message:

• Implemented file management via resource manager and loading of resource locations via XML. Changes made:
  • SoundManager loads via memory stream rather than via file
  • Loader uses LuaState::includeFile() to load an XML file and passes the lua tag remover function to its LuaState.
  • ConfigFileManager still loads with hard paths because the files are required before Ogre gets created
• Renamed LuaBind to LuaState, deSingletonised it and added new features:
  • doFile(), doString(), includeFile(), includeString() where include will preparse the string with a function provided with LuaState::setIncludeParser
  • Moved lua tags replace function to Loader (since it's actually an XML related task)
  • Using data_path/lua/LuaInitScript.lua to provide the following functions
    • logMessage(level, message)
    • doFile, dofile, include (all working with relative paths but within the same resource group)
• Modified Script class to work with LuaState and fixed its XML Loader
• Adjusted all level and include files (both "include" and "dofile" lua commands)

Location:

code/branches/resource2

Files:

• data/levels/empty_level.oxw (modified) (1 diff)
• data/levels/gametype_asteroids.oxw (modified) (1 diff)
• data/levels/gametype_underattack.oxw (modified) (1 diff)
• data/levels/old/CuboidSpaceStation.oxw (modified) (2 diffs)
• data/levels/old/physicstest2.oxw (modified) (1 diff)
• data/levels/old/planettest.oxw (modified) (1 diff)
• data/levels/old/presentation_physics.oxw (modified) (1 diff)
• data/levels/old/princessaeryn.oxw (modified) (1 diff)
• data/levels/old/questsystem.oxw (modified) (1 diff)
• data/levels/old/sample4.oxw (modified) (1 diff)
• data/levels/pickuptest.oxw (modified) (1 diff)
• data/levels/presentation.oxw (modified) (1 diff)
• data/levels/presentation09.oxw (modified) (1 diff)
• data/levels/presentation09b.oxw (modified) (1 diff)
• data/levels/presentation_dm.oxw (modified) (1 diff)
• data/levels/presentation_pong.oxw (modified) (2 diffs)
• data/levels/teambasematchlevel.oxw (modified) (1 diff)
• data/levels/teamdeathmatch.oxw (modified) (1 diff)
• data/levels/templates/spaceship_H2.oxt (modified) (1 diff)
• data/levels/templates/spaceship_assff.oxt (modified) (1 diff)
• data/levels/templates/spaceship_pirate.oxt (modified) (1 diff)
• data/levels/tutorial.oxw (modified) (1 diff)
• data/levels/waypoints.oxw (modified) (1 diff)
• data/lua (added)
• data/lua/LuaStateInit.lua (added)
• data/resources.cfg (deleted)
• data/resources.oxr (modified) (1 diff)
• data/resources_graphics.oxr (copied) (copied from code/branches/resource2/data/resources.oxr) (1 diff)
• src/core/CMakeLists.txt (modified) (2 diffs)
• src/core/Core.cc (modified) (6 diffs)
• src/core/Core.h (modified) (1 diff)
• src/core/CorePrereqs.h (modified) (1 diff)
• src/core/GUIManager.cc (modified) (3 diffs)
• src/core/GraphicsManager.cc (modified) (5 diffs)
• src/core/GraphicsManager.h (modified) (3 diffs)
• src/core/Loader.cc (modified) (4 diffs)
• src/core/Loader.h (modified) (1 diff)
• src/core/LuaState.cc (moved) (moved from code/branches/resource2/src/core/LuaBind.cc) (2 diffs)
• src/core/LuaState.h (moved) (moved from code/branches/resource2/src/core/LuaBind.h) (2 diffs)
• src/orxonox/gamestates/GSGraphics.cc (modified) (1 diff)
• src/orxonox/gamestates/GSLevel.cc (modified) (1 diff)
• src/orxonox/gamestates/GSRoot.cc (modified) (3 diffs)
• src/orxonox/objects/Level.cc (modified) (1 diff)
• src/orxonox/objects/Script.cc (modified) (1 diff)
• src/orxonox/objects/Script.h (modified) (1 diff)
• src/orxonox/sound/SoundBase.cc (modified) (3 diffs)
• src/orxonox/sound/SoundBase.h (modified) (1 diff)

code/branches/resource2/data/levels/empty_level.oxw

@@ -1 +1 @@
 <?lua
-  include("overlay/stats.oxo")
-  include("overlay/hudtemplates3.oxo")
+  include("stats.oxo")
+  include("hudtemplates3.oxo")
 ?>
 
 <?lua
-  include("levels/templates/spaceship_assff.oxt")
-  include("levels/templates/spaceship_pirate.oxt")
+  include("templates/spaceship_assff.oxt")
+  include("templates/spaceship_pirate.oxt")
 ?>
 

code/branches/resource2/data/levels/gametype_asteroids.oxw

@@ -1 +1 @@
 <?lua
-  include("overlay/hudtemplates3.oxo")
-  include("overlay/stats.oxo")
-  include("levels/templates/spaceship_assff.oxt")
+  include("hudtemplates3.oxo")
+  include("stats.oxo")
+  include("templates/spaceship_assff.oxt")
 ?>
 

code/branches/resource2/data/levels/gametype_underattack.oxw

@@ -1 +1 @@
 <?lua
-  include("overlay/hudtemplates3.oxo")
-  include("overlay/stats.oxo")
-  include("overlay/underattackhud.oxo")
-  include("levels/templates/spaceship_assff.oxt")
+  include("hudtemplates3.oxo")
+  include("stats.oxo")
+  include("underattackhud.oxo")
+  include("templates/spaceship_assff.oxt")
 ?>
 

code/branches/resource2/data/levels/old/CuboidSpaceStation.oxw

@@ -1 +1 @@
 <?lua
-        include("overlay/hudtemplates3.oxo")
+        include("hudtemplates3.oxo")
 ?>
 
 <?lua
-        include("levels/templates/spaceship_assff.oxt")
+        include("templates/spaceship_assff.oxt")
 ?>
 
@@ -20 +20 @@
 <!-------------------------------------------------------------------------------------------------------------------------------------------------------------------------->
 <?lua
-        dofile("../../media/levels/includes/CuboidSpaceStation.lua")
+        dofile("includes/CuboidSpaceStation.lua")
 ?>
 

code/branches/resource2/data/levels/old/physicstest2.oxw

@@ -1 +1 @@
 <?lua
-  include("levels/old/spaceshiptemplates_physics.oxw")
+  include("spaceshiptemplates_physics.oxw")
 ?>
 <?lua
-  include("overlay/hudtemplates3.oxo")
+  include("hudtemplates3.oxo")
 ?>
 

code/branches/resource2/data/levels/old/planettest.oxw

@@ -1 +1 @@
 <?lua
-  include("overlay/hudtemplates3.oxo")
+  include("hudtemplates3.oxo")
 ?>
 
 <?lua
-  include("levels/templates/spaceship_assff.oxt")
+  include("templates/spaceship_assff.oxt")
 ?>
 

code/branches/resource2/data/levels/old/presentation_physics.oxw

@@ -1 +1 @@
 <?lua
-  include("overlay/hudtemplates3.oxo")
-  include("overlay/stats.oxo")
-  include("levels/templates/spaceship_assff.oxt")
+  include("hudtemplates3.oxo")
+  include("stats.oxo")
+  include("templates/spaceship_assff.oxt")
   math.randomseed(344)
 ?>

code/branches/resource2/data/levels/old/princessaeryn.oxw

@@ -1 +1 @@
 <?lua
-  include("overlay/hudtemplates3.oxo")
-  include("overlay/stats.oxo")
-  include("levels/templates/spaceship_assff.oxt")
+  include("hudtemplates3.oxo")
+  include("stats.oxo")
+  include("templates/spaceship_assff.oxt")
 ?>
 
 <?lua
-        dofile("../../media/levels/includes/CuboidSpaceStation.lua")
+        dofile("includes/CuboidSpaceStation.lua")
 ?>
 

code/branches/resource2/data/levels/old/questsystem.oxw

@@ -1 +1 @@
 <?lua
-  include("overlay/hudtemplates3.oxo")
-  include("overlay/stats.oxo")
-  include("levels/templates/spaceship_assff.oxt")
+  include("hudtemplates3.oxo")
+  include("stats.oxo")
+  include("templates/spaceship_assff.oxt")
 ?>
 

code/branches/resource2/data/levels/old/sample4.oxw

@@ -1 +1 @@
 <?lua
-  include("overlay/hudtemplates3.oxo")
+  include("hudtemplates3.oxo")
 ?>
 
 <?lua
-  include("levels/templates/spaceship_assff.oxt")
+  include("templates/spaceship_assff.oxt")
 ?>
 

code/branches/resource2/data/levels/pickuptest.oxw

@@ -1 +1 @@
 <?lua
-  include("overlay/hudtemplates3.oxo")
-  include("overlay/stats.oxo")
-  include("levels/templates/spaceship_assff.oxt")
+  include("hudtemplates3.oxo")
+  include("stats.oxo")
+  include("templates/spaceship_assff.oxt")
 ?>
 

code/branches/resource2/data/levels/presentation.oxw

@@ -1 +1 @@
 <?lua
-  include("overlay/hudtemplates3.oxo")
-  include("overlay/stats.oxo")
-  include("levels/templates/spaceship_assff.oxt")
+  include("hudtemplates3.oxo")
+  include("stats.oxo")
+  include("templates/spaceship_assff.oxt")
 ?>
 

code/branches/resource2/data/levels/presentation09.oxw

@@ -1 +1 @@
 <?lua
-  include("overlay/hudtemplates3.oxo")
-  include("overlay/stats.oxo")
-  include("levels/templates/spaceship_assff.oxt")
-  include("levels/templates/spaceship_H2.oxt")
+  include("hudtemplates3.oxo")
+  include("stats.oxo")
+  include("templates/spaceship_assff.oxt")
+  include("templates/spaceship_H2.oxt")
 ?>
 

code/branches/resource2/data/levels/presentation09b.oxw

@@ -1 +1 @@
 <?lua
-  include("overlay/hudtemplates3.oxo")
-  include("overlay/stats.oxo")
-  include("levels/templates/spaceship_assff.oxt")
-  include("levels/templates/spaceship_H2.oxt")
-  include("levels/templates/spaceship_pirate.oxt")
+  include("hudtemplates3.oxo")
+  include("stats.oxo")
+  include("templates/spaceship_assff.oxt")
+  include("templates/spaceship_H2.oxt")
+  include("templates/spaceship_pirate.oxt")
 ?>
 

code/branches/resource2/data/levels/presentation_dm.oxw

@@ -1 +1 @@
 <?lua
-  include("overlay/hudtemplates3.oxo")
-  include("overlay/stats.oxo")
-  include("levels/templates/spaceship_assff.oxt")
-  include("levels/templates/spaceship_H2.oxt")
+  include("hudtemplates3.oxo")
+  include("stats.oxo")
+  include("templates/spaceship_assff.oxt")
+  include("templates/spaceship_H2.oxt")
 ?>
 

code/branches/resource2/data/levels/presentation_pong.oxw

@@ -1 +1 @@
 <?lua
-  include("overlay/hudtemplates3.oxo")
-  include("overlay/stats.oxo")
-  include("overlay/ponghud.oxo")
+  include("hudtemplates3.oxo")
+  include("stats.oxo")
+  include("ponghud.oxo")
 ?>
 
@@ -91 +91 @@
 
   <?lua
-    dofile("../../media/levels/includes/CuboidSpaceStation.lua")
+    dofile("includes/CuboidSpaceStation.lua")
   ?>
 

code/branches/resource2/data/levels/teambasematchlevel.oxw

@@ -1 +1 @@
 <?lua
-  include("overlay/hudtemplates3.oxo")
-  include("overlay/stats.oxo")
-  include("overlay/teambasematchhud.oxo")
-  include("levels/templates/spaceship_assff.oxt")
-  include("levels/templates/spaceship_pirate.oxt")
+  include("hudtemplates3.oxo")
+  include("stats.oxo")
+  include("teambasematchhud.oxo")
+  include("templates/spaceship_assff.oxt")
+  include("templates/spaceship_pirate.oxt")
 ?>
 

code/branches/resource2/data/levels/teamdeathmatch.oxw

@@ -1 +1 @@
 <?lua
-  include("overlay/hudtemplates3.oxo")
-  include("overlay/stats.oxo")
-  include("levels/templates/spaceship_assff.oxt")
-  include("levels/templates/spaceship_H2.oxt")
-  include("levels/templates/spaceship_pirate.oxt")
+  include("hudtemplates3.oxo")
+  include("stats.oxo")
+  include("templates/spaceship_assff.oxt")
+  include("templates/spaceship_H2.oxt")
+  include("templates/spaceship_pirate.oxt")
 ?>
 

code/branches/resource2/data/levels/templates/spaceship_H2.oxt

@@ -23 +23 @@
 
 <?lua
-  include("levels/includes/weaponsettings_H2.oxi")
+  include("includes/weaponsettings_H2.oxi")
 ?>
 

code/branches/resource2/data/levels/templates/spaceship_assff.oxt

@@ -35 +35 @@
     </collisionShapes>
 <?lua
-  include("levels/includes/weaponsettings3.oxi")
+  include("includes/weaponsettings3.oxi")
 ?>
   </SpaceShip>

code/branches/resource2/data/levels/templates/spaceship_pirate.oxt

@@ -38 +38 @@
 
 <?lua
-  include("levels/includes/weaponsettings_pirate.oxi")
+  include("includes/weaponsettings_pirate.oxi")
 ?>
   </SpaceShip>

code/branches/resource2/data/levels/tutorial.oxw

@@ -1 +1 @@
 <?lua
-  include("overlay/hudtemplates3.oxo")
-  include("overlay/stats.oxo")
-  include("levels/templates/spaceship_assff.oxt")
+  include("hudtemplates3.oxo")
+  include("stats.oxo")
+  include("templates/spaceship_assff.oxt")
 ?>
 

code/branches/resource2/data/levels/waypoints.oxw

@@ -1 +1 @@
 <?lua
-  include("overlay/hudtemplates3.oxo")
-  include("overlay/stats.oxo")
-  include("levels/templates/spaceship_assff.oxt")
-  include("levels/templates/spaceship_H2.oxt")
-  include("levels/templates/spaceship_pirate.oxt")
+  include("hudtemplates3.oxo")
+  include("stats.oxo")
+  include("templates/spaceship_assff.oxt")
+  include("templates/spaceship_H2.oxt")
+  include("templates/spaceship_pirate.oxt")
 ?>
 

code/branches/resource2/data/resources.oxr

@@ -1 @@
-<ResourceGroup name = "General" >
-    <ResourceLocation path = overlay />
-    <ResourceLocation path = particle />
-    <ResourceLocation path = defaultConfig />
-    <ResourceLocation path = levels />
-    <ResourceLocation path = tcl />
-    <ResourceLocation
-      path = test.zip
-      archive = Zip
-      recursive = true
-    />
-</ResourceGroup>
-
-<ResourceGroup name = "GUI" >
-    <ResourceLocation path = gui/configs />
-    <ResourceLocation path = gui/layouts />
-    <ResourceLocation path = gui/schemas />
-    <ResourceLocation path = gui/scripts />
-</ResourceGroup>
+<ResourceCollection resourceGroup = "General" >
+    <ResourceLocation path = "levels" />
+    <ResourceLocation path = "lua" />
+    <ResourceLocation path = "overlay" />
+    <ResourceLocation path = "tcl" />
+</ResourceCollection>

code/branches/resource2/data/resources_graphics.oxr

@@ -1 @@
-<ResourceGroup name = "General" >
-    <ResourceLocation path = overlay />
-    <ResourceLocation path = particle />
-    <ResourceLocation path = defaultConfig />
-    <ResourceLocation path = levels />
-    <ResourceLocation path = tcl />
-    <ResourceLocation
-      path = test.zip
-      archive = Zip
-      recursive = true
-    />
-</ResourceGroup>
+<ResourceCollection resourceGroup = "General" >
+    <ResourceLocation path = "particle" />
+</ResourceCollection>
 
-<ResourceGroup name = "GUI" >
-    <ResourceLocation path = gui/configs />
-    <ResourceLocation path = gui/layouts />
-    <ResourceLocation path = gui/schemas />
-    <ResourceLocation path = gui/scripts />
-</ResourceGroup>
+<ResourceCollection resourceGroup = "GUI" >
+    <ResourceLocation path = "gui/configs" />
+    <ResourceLocation path = "gui/layouts" />
+    <ResourceLocation path = "gui/schemes" />
+    <ResourceLocation path = "gui/scripts" />
+</ResourceCollection>

code/branches/resource2/src/core/CMakeLists.txt

@@ -30 +30 @@
   GUIManager.cc
   Language.cc
-  LuaBind.cc
+  LuaState.cc
   ObjectListBase.cc
   OrxonoxClass.cc
@@ -76 +76 @@
   TOLUA_FILES
     CommandExecutor.h
-    LuaBind.h
+    Loader.h
+    LuaState.h
   DEFINE_SYMBOL
     "CORE_SHARED_BUILD"

code/branches/resource2/src/core/Core.cc

@@ -74 +74 @@
 #include "Identifier.h"
 #include "Language.h"
-#include "LuaBind.h"
+#include "LuaState.h"
 #include "Shell.h"
 #include "TclBind.h"
 #include "TclThreadManager.h"
+#include "ToluaBindCore.h"
 #include "input/InputManager.h"
 
@@ -266 +267 @@
             setThreadAffinity(static_cast<unsigned int>(limitToCPU));
 #endif
+        // Add tolua interface
+        LuaState::addToluaInterface(&tolua_Core_open, "Core");
 
         // Manage ini files and set the default settings file (usually orxonox.ini)
@@ -275 +278 @@
         this->languageInstance_.reset(new Language());
 
+        // creates the class hierarchy for all classes with factories
+        Factory::createClassHierarchy();
+
         // Do this soon after the ConfigFileManager has been created to open up the
         // possibility to configure everything below here
         this->configuration_->initialise();
 
-        // Create the lua interface
-        this->luaBind_.reset(new LuaBind());
+        // Load OGRE excluding the renderer and the render window
+        this->graphicsManager_.reset(new GraphicsManager(false));
 
         // initialise Tcl
@@ -288 +294 @@
         // create a shell
         this->shell_.reset(new Shell());
-
-        // creates the class hierarchy for all classes with factories
-        Factory::createClassHierarchy();
-
-        // Load OGRE excluding the renderer and the render window
-        this->graphicsManager_.reset(new GraphicsManager(false));
     }
 
     /**
     @brief
-        All destruction code is handled by scoped_ptrs and SimpleScopeGuards.
+        All destruction code is handled by scoped_ptrs and ScopeGuards.
     */
     Core::~Core()
@@ -561 +561 @@
             COUT(1) << "Running from the build tree." << std::endl;
             Core::bDevRun_ = true;
-            configuration_->dataPath_  = specialConfig::dataDevDirectory;
+            configuration_->dataPath_   = specialConfig::dataDevDirectory;
             configuration_->externalDataPath_ = specialConfig::externalDataDevDirectory;
             configuration_->configPath_ = specialConfig::configDevDirectory;
@@ -579 +579 @@
 
             // Using paths relative to the install prefix, complete them
-            configuration_->dataPath_  = configuration_->rootPath_ / specialConfig::defaultDataPath;
+            configuration_->dataPath_   = configuration_->rootPath_ / specialConfig::defaultDataPath;
             configuration_->configPath_ = configuration_->rootPath_ / specialConfig::defaultConfigPath;
             configuration_->logPath_    = configuration_->rootPath_ / specialConfig::defaultLogPath;

code/branches/resource2/src/core/Core.h

@@ -129 +129 @@
             scoped_ptr<Language>          languageInstance_;
             scoped_ptr<CoreConfiguration> configuration_;
-            scoped_ptr<LuaBind>           luaBind_;
             scoped_ptr<TclBind>           tclBind_;
             scoped_ptr<TclThreadManager>  tclThreadManager_;

code/branches/resource2/src/core/CorePrereqs.h

@@ -133 +133 @@
     class LanguageEntry;
     class Loader;
-    class LuaBind;
+    class LuaState;
     class MetaObjectList;
     class MetaObjectListElement;

code/branches/resource2/src/core/GUIManager.cc

@@ -59 +59 @@
 #include "Core.h"
 #include "Clock.h"
-#include "LuaBind.h"
+#include "LuaState.h"
 
 namespace orxonox
@@ -132 +132 @@
 
             // do this after 'new CEGUI::Sytem' because that creates the lua state in the first place
-            LuaBind::getInstance().openToluaInterfaces(this->luaState_);
+            LuaState::openToluaInterfaces(this->luaState_);
 
             // initialise the basic lua code
@@ -157 +157 @@
     {
         // destroy our own tolua interfaces
-        LuaBind::getInstance().closeToluaInterfaces(this->luaState_);
+        LuaState::closeToluaInterfaces(this->luaState_);
     }
 

code/branches/resource2/src/core/GraphicsManager.cc

@@ -45 +45 @@
 #include <OgreRenderWindow.h>
 #include <OgreRenderSystem.h>
+#include <OgreResourceGroupManager.h>
 #include <OgreViewport.h>
 #include <OgreWindowEventUtilities.h>
@@ -59 +60 @@
 #include "Game.h"
 #include "GameMode.h"
+#include "Loader.h"
 #include "WindowEventListener.h"
+#include "XMLFile.h"
 
 namespace orxonox
@@ -96 +99 @@
         this->loadOgrePlugins();
 
+        // At first, add the root paths of the data directories as resource locations
+        Ogre::ResourceGroupManager::getSingleton().addResourceLocation(Core::getDataPathString(), "FileSystem", "dataRoot", false);
+        // Load resources
+        resources_.reset(new XMLFile("resources.oxr", "dataRoot"));
+        Loader::open(resources_.get());
+
+        // Only for development runs
+        if (Core::isDevelopmentRun())
+        {
+            Ogre::ResourceGroupManager::getSingleton().addResourceLocation(Core::getExternalDataPathString(), "FileSystem", "externalDataRoot", false);
+            extResources_.reset(new XMLFile("resources.oxr", "externalDataRoot"));
+            Loader::open(extResources_.get());
+        }
+
         if (bLoadRenderer)
         {
             // Reads the ogre config and creates the render window
-            this->loadRenderer();
+            this->upgradeToGraphics();
         }
     }
@@ -109 +126 @@
     GraphicsManager::~GraphicsManager()
     {
+        // TODO: Destroy the console command
     }
 
@@ -137 +155 @@
     void GraphicsManager::upgradeToGraphics()
     {
-        if (renderWindow_ == NULL)
-        {
-            this->loadRenderer();
-        }
+        if (renderWindow_ != NULL)
+            return;
+
+        this->loadRenderer();
+
+        // RESOURCE MANAGEMENT
+
+        // Load graphical resources
+        resourcesGraphics_.reset(new XMLFile("resources_graphics.oxr", "dataRoot"));
+        Loader::open(resourcesGraphics_.get());
+
+        // Consider external data folder for dev runs
+        if (Core::isDevelopmentRun())
+        {
+            extResourcesGraphics_.reset(new XMLFile("resources_graphics.oxr", "externalDataRoot"));
+            Loader::open(extResourcesGraphics_.get());
+        }
+
+        // Initialise all resources
+        // Note: You can only do this once! Ogre will check whether a resource group has
+        // already been initialised. If you need to load resources later, you will have to
+        // choose another resource group.
+        Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
     }
 

code/branches/resource2/src/core/GraphicsManager.h

@@ -43 +43 @@
 #include <OgreLog.h>
 #include <boost/scoped_ptr.hpp>
+#include <boost/shared_ptr.hpp>
 
 #include "util/Singleton.h"
@@ -87 +88 @@
         void printScreen();
 
-    private:
         scoped_ptr<OgreWindowEventListener> ogreWindowEventListener_; //!< Pimpl to hide OgreWindowUtilities.h
         scoped_ptr<Ogre::LogManager>        ogreLogger_;
@@ -93 +93 @@
         Ogre::RenderWindow* renderWindow_;             //!< the one and only render window
         Ogre::Viewport*     viewport_;                 //!< default full size viewport
+
+        // XML files for the resources
+        shared_ptr<XMLFile> resources_;                //!< XML with resource locations
+        shared_ptr<XMLFile> extResources_;             //!< XML with resource locations in the external path (only for dev runs)
+        shared_ptr<XMLFile> resourcesGraphics_;        //!< XML with resource locations (with renderer)
+        shared_ptr<XMLFile> extResourcesGraphics_;     //!< XML with resource locations in the external path (only for dev runs) (with renderer)
 
         // config values

code/branches/resource2/src/core/Loader.cc

@@ -29 +29 @@
 #include "Loader.h"
 
+#include <sstream>
 #include <tinyxml/ticpp.h>
+#include <boost/scoped_ptr.hpp>
 
 #include "util/Debug.h"
 #include "util/Exception.h"
+#include "util/StringUtils.h"
 #include "BaseObject.h"
 #include "Iterator.h"
 #include "ObjectList.h"
-#include "LuaBind.h"
+#include "LuaState.h"
 #include "Namespace.h"
+#include "Resource.h"
 #include "XMLFile.h"
 
@@ -118 +122 @@
         Loader::currentMask_s = file->getMask() * mask;
 
-        // let Lua work this out:
-        LuaBind& lua = LuaBind::getInstance();
-        lua.clearLuaOutput();
-        lua.loadFile(file->getFilename(), true);
-        lua.run();
+        // Use the LuaState to replace the XML tags (calls our function)
+        scoped_ptr<LuaState> luaState(new LuaState());
+        luaState->setIncludeParser(&Loader::replaceLuaTags);
+        luaState->includeFile(file->getFilename(), file->getResourceGroup(), false);
+        //luaState->doString(luaInput);
 
         try
@@ -129 +133 @@
             COUT(3) << "Mask: " << Loader::currentMask_s << std::endl;
 
-            //ticpp::Document xmlfile(file->getFilename());
-            //xmlfile.LoadFile();
-            //ticpp::Element myelement(*Script::getFileString());
-            ticpp::Document xmlfile;
-            //xmlfile.ToDocument();
-            xmlfile.Parse(lua.getLuaOutput(), true);
+            ticpp::Document xmlfile(file->getFilename());
+            xmlfile.Parse(luaState->getOutput().str(), true);
 
             ticpp::Element rootElement;
@@ -208 +208 @@
         return Loader::load(file, mask);
     }
+
+    std::string Loader::replaceLuaTags(const std::string& text)
+    {
+        // chreate map with all Lua tags
+        std::map<size_t, bool> luaTags;
+        {
+            size_t pos = 0;
+            while ((pos = text.find("<?lua", pos)) != std::string::npos)
+                luaTags[pos++] = true;
+        }
+        {
+            size_t pos = 0;
+            while ((pos = text.find("?>", pos)) != std::string::npos)
+                luaTags[pos++] = false;
+        }
+
+        // erase all tags from the map that are between two quotes
+        {
+            std::map<size_t, bool>::iterator it = luaTags.begin();
+            std::map<size_t, bool>::iterator it2 = it;
+            bool bBetweenQuotes = false;
+            size_t pos = 0;
+            while ((pos = getNextQuote(text, pos)) != std::string::npos)
+            {
+                while ((it != luaTags.end()) && (it->first < pos))
+                {
+                    if (bBetweenQuotes)
+                    {
+                        it2++;
+                        if(it->second && !(it2->second) && it2->first < pos)
+                            it = ++it2;
+                        else
+                            luaTags.erase(it++);
+                    }
+                    else
+                        ++it;
+                }
+                bBetweenQuotes = !bBetweenQuotes;
+                pos++;
+            }
+        }
+
+        // check whether on every opening <?lua tag a closing ?> tag follows
+        {
+            bool expectedValue = true;
+            for (std::map<size_t, bool>::iterator it = luaTags.begin(); it != luaTags.end(); ++it)
+            {
+                if (it->second == expectedValue)
+                    expectedValue = !expectedValue;
+                else
+                {
+                    expectedValue = false;
+                    break;
+                }
+            }
+            if (!expectedValue)
+            {
+                COUT(2) << "Warning: Error in level file" << std::endl;
+                // todo: errorhandling
+                return "";
+            }
+        }
+
+        // Use a stringstream object to speed up the parsing
+        std::ostringstream output;
+
+        // cut the original string into pieces and put them together with print() instead of lua tags
+        {
+            std::map<size_t, bool>::iterator it = luaTags.begin();
+            bool bInPrintFunction = true;
+            size_t start = 0;
+            size_t end = 0;
+
+            do
+            {
+                if (it != luaTags.end())
+                    end = (*(it++)).first;
+                else
+                    end = std::string::npos;
+
+                unsigned int equalSignCounter = 0;
+
+                if (bInPrintFunction)
+                {
+                    // count ['='[ and ]'='] and replace tags with print([[ and ]])
+                    std::string temp = text.substr(start, end - start);
+                    {
+                    size_t pos = 0;
+                    while ((pos = temp.find('[', pos)) != std::string::npos)
+                    {
+                        unsigned int tempCounter = 1;
+                        size_t tempPos = pos++;
+                        while(temp[++tempPos] == '=')
+                        {
+                            tempCounter++;
+                        }
+                        if(temp[tempPos] != '[')
+                        {
+                            tempCounter = 0;
+                        }
+                        else if(tempCounter == 0)
+                        {
+                            tempCounter = 1;
+                        }
+                        if (tempCounter > equalSignCounter)
+                            equalSignCounter = tempCounter;
+                        }
+                    }
+                    {
+                        size_t pos = 0;
+                        while ((pos = temp.find(']', pos)) != std::string::npos)
+                        {
+                            unsigned int tempCounter = 1;
+                            size_t tempPos = pos++;
+                            while(temp[++tempPos] == '=')
+                            {
+                                tempCounter++;
+                            }
+                            if(temp[tempPos] != ']')
+                            {
+                                tempCounter = 0;
+                            }
+                            else if(tempCounter == 0)
+                            {
+                                tempCounter = 1;
+                            }
+                            if (tempCounter > equalSignCounter)
+                                equalSignCounter = tempCounter;
+                        }
+                    }
+                    std::string equalSigns = "";
+                    for(unsigned int i = 0; i < equalSignCounter; i++)
+                    {
+                        equalSigns += "=";
+                    }
+                    output << "print([" + equalSigns + "[" + temp + "]" + equalSigns +"])";
+                    start = end + 5;
+                }
+                else
+                {
+                    output << text.substr(start, end - start);
+                    start = end + 2;
+                }
+
+                bInPrintFunction = !bInPrintFunction;
+            }
+            while (end != std::string::npos);
+        }
+
+        return output.str();
+    }
 }

code/branches/resource2/src/core/Loader.h

@@ -55 +55 @@
             static bool reload(const XMLFile* file, const ClassTreeMask& mask = ClassTreeMask());
 
+            static std::string replaceLuaTags(const std::string& text);
+
             static ClassTreeMask currentMask_s;
 

code/branches/resource2/src/core/LuaState.cc

@@ -22 +22 @@
  *   Author:
  *      Benjamin Knecht
+ *      Reto Grieder
  *   Co-authors:
  *      ...
@@ -27 +28 @@
  */
 
-#include "LuaBind.h"
-
-#include <fstream>
-#include <map>
+#include "LuaState.h"
+
+#include <tolua/tolua++.h>
 extern "C" {
+#include <lua.h>
 #include <lualib.h>
 }
-#include <tolua/tolua++.h>
-#include <boost/filesystem.hpp>
 
 #include "util/Debug.h"
-#include "util/StringUtils.h"
 #include "Core.h"
+#include "Resource.h"
 
 namespace orxonox
 {
-  LuaBind* LuaBind::singletonPtr_s = NULL;
-
-  LuaBind::LuaBind()
-  {
-    this->includePath_ = Core::getDataPathString();
-
-    luaState_ = lua_open();
-    luaSource_ = "";
+    LuaState::ToluaInterfaceMap LuaState::toluaInterfaces_s;
+    std::vector<LuaState*> LuaState::instances_s;
+
+    LuaState::LuaState()
+        : bIsRunning_(false)
+        , includeParseFunction_(NULL)
+    {
+        // Create new lua state and configure it
+        luaState_ = lua_open();
 #if LUA_VERSION_NUM == 501
-    luaL_openlibs(luaState_);
+        luaL_openlibs(luaState_);
 #else
-    luaopen_base(luaState_);
-    luaopen_string(luaState_);
-    luaopen_table(luaState_);
-    luaopen_math(luaState_);
-    luaopen_io(luaState_);
-    luaopen_debug(luaState_);
+        luaopen_base(luaState_);
+        luaopen_string(luaState_);
+        luaopen_table(luaState_);
+        luaopen_math(luaState_);
+        luaopen_io(luaState_);
+        luaopen_debug(luaState_);
 #endif
 
-    // Open all available tolua interfaces
-    this->openToluaInterfaces(luaState_);
-
-    output_ = "";
-    isRunning_ = false;
-  }
-
-  LuaBind::~LuaBind()
-  {
-    this->closeToluaInterfaces(luaState_);
-  };
-
-  void LuaBind::luaPrint(const std::string& str)
-  {
-    output_ += str;
-//    COUT(4) << "Lua_output!:" << std::endl << str << std::endl << "***" << std::endl;
-    COUT(5) << str;
-  }
-
-  /**
-      @brief Loads the specified file line by line
-      @param filename The filename of the file
-      @param luaTags if true, the loaded file gets stripped off luaTags
-  */
-  void LuaBind::loadFile(const std::string& filename, bool luaTags)
-  {
-    boost::filesystem::path filepath(filename);
-
-    output_ = "";
-    std::ifstream file;
-    file.open(filepath.string().c_str(), std::fstream::in);
-
-    if (!file.is_open())
-    {
-      // some error msg
-    }
-
-    std::string levelString = "";
-
-    while (file.good() && !file.eof())
-    {
-      std::string line;
-      std::getline(file, line);
-      levelString += line;
-      levelString += "\n";
-    }
-
-    file.close();
-    //std::string output;
-
-    if (luaTags)
-      luaSource_ = replaceLuaTags(levelString);
-    else
-      luaSource_ = levelString;
-    COUT(5) << "ParsedSourceCode: " << luaSource_ << std::endl;
-  }
-
-  void LuaBind::loadString(const std::string& code)
-  {
-    luaSource_ = code;
-    output_ = "";
-  }
-
+        // Open all available tolua interfaces
+        this->openToluaInterfaces(luaState_);
+
+        // Create dummy file info
+        sourceFileInfo_.reset(new ResourceInfo());
+        sourceFileInfo_->group = "General";
+        sourceFileInfo_->size = 0;
+
+        // Push this pointer
+        tolua_pushusertype(luaState_, static_cast<void*>(this), "orxonox::LuaState");
+        lua_setglobal(luaState_, "luaState");
+
+        // Parse init script
+        // Note: We have to use a hard coded path because the script is required for the resource loading
+        this->doString("dofile(\"" + Core::getDataPathString() + "lua/LuaStateInit.lua\")");
+    }
+
+    LuaState::~LuaState()
+    {
+        lua_close(luaState_);
+    }
+
+    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 explicitely 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);
+            }
+        }
+        return sourceInfo;
+    }
+
+    void LuaState::includeFile(const std::string& filename, const std::string& resourceGroup, bool bSearchOtherPaths)
+    {
+        shared_ptr<ResourceInfo> sourceInfo = this->getFileInfo(filename, resourceGroup, bSearchOtherPaths);
+        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;
+    }
+
+    void LuaState::includeString(const std::string& code, shared_ptr<ResourceInfo> sourceFileInfo)
+    {
+        // Parse string with provided include parser (otherwise don't preparse at all)
+        std::string luaInput;
+        if (includeParseFunction_ != NULL)
+            luaInput = (*includeParseFunction_)(code);
+        else
+            luaInput = code;
+
+        this->doString(luaInput, sourceFileInfo);
+    }
+
+    void LuaState::doFile(const std::string& filename, const std::string& resourceGroup, bool bSearchOtherPaths)
+    {
+        shared_ptr<ResourceInfo> sourceInfo = this->getFileInfo(filename, resourceGroup, bSearchOtherPaths);
+        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;
+    }
+
+    void LuaState::doString(const std::string& code, shared_ptr<ResourceInfo> sourceFileInfo)
+    {
+        // Save the oold source file info
+        shared_ptr<ResourceInfo> oldSourceFileInfo = sourceFileInfo_;
+        // Only override if sourceFileInfo provides useful information
+        if (sourceFileInfo != NULL)
+            sourceFileInfo_ = sourceFileInfo;
+
+        //if (!bIsRunning_)
+        //{
+        //    bIsRunning_ = true;
+
+        int error = 0;
 #if LUA_VERSION_NUM != 501
-  const char * LuaBind::lua_Chunkreader(lua_State *L, void *data, size_t *size)
-  {
-    LoadS* ls = static_cast<LoadS*>(data);
-    if (ls->size == 0) return NULL;
-    *size = ls->size;
-    ls->size = 0;
-    return ls->s;
-  }
+        LoadS ls;
+        ls.s = code.c_str();
+        ls.size = code.size();
+        error = lua_load(luaState_, &orxonox::LuaState::lua_Chunkreader, &ls, code.c_str());
+#else
+        error = luaL_loadstring(luaState_, code.c_str());
 #endif
-  void LuaBind::run()
-  {
-    if (!isRunning_)
-    {
-      isRunning_ = true;
-      int error = 0;
-      std::string init =
-         "local scr = orxonox.LuaBind:getInstance()\n \
-          local debug = print\n \
-          print = function(s)\n \
-              scr:luaPrint(s)\n \
-          end\n \
-          include = function(f)\n \
-              file = assert(io.open(\"" + this->includePath_ + "\"..\"/\"..f))\n \
-              content = file:read(\"*a\")\n \
-              file:close()\n \
-              source = scr:replaceLuaTags(content)\n \
-              assert(loadstring(source))()\n \
-          end\n";
-      init += luaSource_;
-  #if LUA_VERSION_NUM == 501
-      error = luaL_loadstring(luaState_, init.c_str());
-  #else
-      LoadS ls;
-      ls.s = init.c_str();
-      ls.size = init.size();
-      error = lua_load(luaState_, &orxonox::LuaBind::lua_Chunkreader, &ls, init.c_str());
-  #endif
-      if (error == 0)
-      {
-        error = lua_pcall(luaState_, 0, 0, 0);
-      }
-      if (error != 0)
-      {
-        COUT(2) << "Error in Lua-script: " << lua_tostring(luaState_, -1) << std::endl;
-      }
-      isRunning_ = false;
-    }
-    else
-    {
-      COUT(2) << "Warning: Lua's run is called while running!" << std::endl;
-    }
-  }
-
-  std::string LuaBind::replaceLuaTags(const std::string& text)
-  {
-    // chreate map with all Lua tags
-    std::map<size_t, bool> luaTags;
-    {
-      size_t pos = 0;
-      while ((pos = text.find("<?lua", pos)) != std::string::npos)
-        luaTags[pos++] = true;
-    }
-    {
-      size_t pos = 0;
-      while ((pos = text.find("?>", pos)) != std::string::npos)
-        luaTags[pos++] = false;
-    }
-
-    // erase all tags from the map that are between two quotes
-    {
-      std::map<size_t, bool>::iterator it = luaTags.begin();
-      std::map<size_t, bool>::iterator it2 = it;
-      bool bBetweenQuotes = false;
-      size_t pos = 0;
-      while ((pos = getNextQuote(text, pos)) != std::string::npos)
-      {
-        while ((it != luaTags.end()) && (it->first < pos))
-        {
-          if (bBetweenQuotes) {
-            it2++;
-            if(it->second && !(it2->second) && it2->first < pos)
-              it = ++it2;
-            else
-              luaTags.erase(it++);
-          }
-          else
-            ++it;
-        }
-        bBetweenQuotes = !bBetweenQuotes;
-        pos++;
-      }
-    }
-
-    // check whether on every opening <?lua tag a closing ?> tag follows
-    {
-      bool expectedValue = true;
-      for (std::map<size_t, bool>::iterator it = luaTags.begin(); it != luaTags.end(); ++it)
-      {
-        if (it->second == expectedValue)
-          expectedValue = !expectedValue;
-        else
-        {
-          expectedValue = false;
-          break;
-        }
-      }
-      if (!expectedValue) {
-        COUT(2) << "Warning: Error in level file" << std::endl;
-        // todo: errorhandling
-        return "";
-      }
-    }
-
-    // cut the original string into pieces and put them together with print() instead of lua tags
-    std::string output;
-    {
-      std::map<size_t, bool>::iterator it = luaTags.begin();
-      bool bInPrintFunction = true;
-      size_t start = 0;
-      size_t end = 0;
-
-      do
-      {
-        if (it != luaTags.end())
-          end = (*(it++)).first;
-        else
-          end = std::string::npos;
-
-        unsigned int equalSignCounter = 0;
-
-        if (bInPrintFunction)
-        {
-          // count ['='[ and ]'='] and replace tags with print([[ and ]])
-          std::string temp = text.substr(start, end - start);
-          {
-            size_t pos = 0;
-            while ((pos = temp.find('[', pos)) != std::string::npos)
+
+        // execute the chunk
+        if (error == 0)
+            error = lua_pcall(luaState_, 0, 0, 0);
+        if (error != 0)
+        {
+            std::string origin;
+            if (sourceFileInfo != NULL)
+                origin = " originating from " + sourceFileInfo_->filename;
+            COUT(2) << "Error in Lua-script" << origin << ": " << lua_tostring(luaState_, -1) << std::endl;
+        }
+
+        //    bIsRunning_ = false;
+        //}
+        //else
+        //{
+        //    COUT(2) << "Warning: LuaState do function called while running!" << std::endl;
+        //}
+
+        // Load the old info again
+        sourceFileInfo_ = oldSourceFileInfo;
+    }
+
+    void LuaState::luaPrint(const std::string& str)
+    {
+        output_ << str;
+    }
+
+    void LuaState::luaLog(unsigned int level, const std::string& message)
+    {
+        OutputHandler::getOutStream().setOutputLevel(level) << message << std::endl;
+    }
+
+#if LUA_VERSION_NUM != 501
+    const char * LuaState::lua_Chunkreader(lua_State *L, void *data, size_t *size)
+    {
+        LoadS* ls = static_cast<LoadS*>(data);
+        if (ls->size == 0)
+            return NULL;
+        *size = ls->size;
+        ls->size = 0;
+        return ls->s;
+    }
+#endif
+
+    /*static*/ bool LuaState::addToluaInterface(int (*function)(lua_State*), const std::string& name)
+    {
+        for (ToluaInterfaceMap::const_iterator it = toluaInterfaces_s.begin(); it != toluaInterfaces_s.end(); ++it)
+        {
+            if (it->first == name || it->second == function)
             {
-              unsigned int tempCounter = 1;
-              size_t tempPos = pos++;
-              while(temp[++tempPos] == '=') {
-                tempCounter++;
-              }
-              if(temp[tempPos] != '[') {
-                tempCounter = 0;
-              }
-              else if(tempCounter == 0) {
-                tempCounter = 1;
-              }
-              if (tempCounter > equalSignCounter)
-                equalSignCounter = tempCounter;
+                COUT(2) << "Warning: Trying to add a Tolua interface with the same name or function." << std::endl;
+                return true;
             }
-          }
-          {
-            size_t pos = 0;
-            while ((pos = temp.find(']', pos)) != std::string::npos)
-            {
-              unsigned int tempCounter = 1;
-              size_t tempPos = pos++;
-              while(temp[++tempPos] == '=') {
-                tempCounter++;
-              }
-              if(temp[tempPos] != ']') {
-                tempCounter = 0;
-              }
-              else if(tempCounter == 0) {
-                tempCounter = 1;
-              }
-              if (tempCounter > equalSignCounter)
-                equalSignCounter = tempCounter;
-            }
-          }
-          std::string equalSigns = "";
-          for(unsigned int i = 0; i < equalSignCounter; i++) {
-            equalSigns += "=";
-          }
-          output += "print([" + equalSigns + "[" + temp + "]" + equalSigns +"])";
-          start = end + 5;
-        }
-        else
-        {
-          output += text.substr(start, end - start);
-          start = end + 2;
-        }
-
-        bInPrintFunction = !bInPrintFunction;
-      }
-      while (end != std::string::npos);
-    }
-
-    return output;
-  }
-
-  void LuaBind::addToluaInterface(int (*function)(lua_State*), const std::string& name)
-  {
-    toluaInterfaces_.push_back(std::make_pair(name, function));
-    // Apply changes to our own lua state as well 
-    (*function)(luaState_);
-  }
-
-  void LuaBind::openToluaInterfaces(lua_State* state)
-  {
-    for (unsigned int i = 0; i < toluaInterfaces_.size(); ++i)
-      (*toluaInterfaces_[i].second)(state);
-  }
-
-  void LuaBind::closeToluaInterfaces(lua_State* state)
-  {
-    for (unsigned int i = 0; i < toluaInterfaces_.size(); ++i)
-    {
-      lua_pushnil(state);
-      lua_setglobal(state, toluaInterfaces_[i].first.c_str());
-    }
-  }
-
+        }
+        toluaInterfaces_s[name] = function;
+
+        // Open interface in all LuaStates
+        for (std::vector<LuaState*>::const_iterator it = instances_s.begin(); it != instances_s.end(); ++it)
+            (*function)((*it)->luaState_);
+
+        // Return dummy bool
+        return true;
+    }
+
+    /*static*/ bool LuaState::removeToluaInterface(const std::string& name)
+    {
+        ToluaInterfaceMap::iterator it = toluaInterfaces_s.find(name);
+        if (it == toluaInterfaces_s.end())
+        {
+            COUT(2) << "Warning: Cannot remove Tolua interface '" << name << "': Not found" << std::endl;
+            return true;
+        }
+
+        // Close interface in all LuaStates
+        for (std::vector<LuaState*>::const_iterator itState = instances_s.begin(); itState != instances_s.end(); ++itState)
+        {
+            lua_pushnil((*itState)->luaState_);
+            lua_setglobal((*itState)->luaState_, it->first.c_str());
+        }
+
+        // Remove entry
+        toluaInterfaces_s.erase(it);
+
+        // Return dummy bool
+        return true;
+    }
+
+    /*static*/ void LuaState::openToluaInterfaces(lua_State* state)
+    {
+        for (ToluaInterfaceMap::const_iterator it = toluaInterfaces_s.begin(); it != toluaInterfaces_s.end(); ++it)
+            (*it->second)(state);
+    }
+
+    /*static*/ void LuaState::closeToluaInterfaces(lua_State* state)
+    {
+        for (ToluaInterfaceMap::const_iterator it = toluaInterfaces_s.begin(); it != toluaInterfaces_s.end(); ++it)
+        {
+            lua_pushnil(state);
+            lua_setglobal(state, it->first.c_str());
+        }
+    }
 }

code/branches/resource2/src/core/LuaState.h

@@ -22 +22 @@
  *   Author:
  *      Benjamin Knecht
+ *      Reto Grieder
  *   Co-authors:
  *      ...
@@ -27 +28 @@
  */
 
-/**
- @file
- @brief Representation of an interface to lua
- @author Benjamin Knecht <beni_at_orxonox.net>
- */
-
-#ifndef _LuaBind_H__
-#define _LuaBind_H__
+#ifndef _LuaState_H__
+#define _LuaState_H__
 
 #include "CorePrereqs.h"
 
-#include <cassert>
+#include <map>
+#include <sstream>
 #include <string>
 #include <vector>
-extern "C" {
-#include <lua.h>
-}
+#include <boost/shared_ptr.hpp>
 
-#include "util/Singleton.h"
+#include "util/ScopeGuard.h"
 
 // tolua_begin
 namespace orxonox
 {
-  class _CoreExport LuaBind : public Singleton<LuaBind>
-  {
+    /**
+    @brief
+        Representation of an interface to lua
+    */
+    class _CoreExport LuaState
+    {
 // tolua_end
-    friend class Singleton<LuaBind>;
+    public:
+        LuaState();
+        ~LuaState();
 
-    struct LoadS {
-      const char *s;
-      size_t size;
-    };
+        void doFile(const std::string& filename, const std::string& resourceGroup = "General", bool bSearchOtherPaths = true); // tolua_export
+        void doString(const std::string& code, shared_ptr<ResourceInfo> sourceFileInfo = shared_ptr<ResourceInfo>());
 
-    public:
-      LuaBind();
-      ~LuaBind();
+        void includeFile(const std::string& filename, const std::string& resourceGroup = "Genreal", bool bSearchOtherPaths = true); // tolua_export
+        void includeString(const std::string& code, shared_ptr<ResourceInfo> sourceFileInfo = shared_ptr<ResourceInfo>());
 
-      static LuaBind& getInstance() { return Singleton<LuaBind>::getInstance(); } // tolua_export
+        void luaPrint(const std::string& str); // tolua_export
+        void luaLog(unsigned int level, const std::string& message); // tolua_export
 
-    void loadFile(const std::string& filename, bool luaTags);
-    void loadString(const std::string& code);
-    //void init(lua_State *state_);
-    //void xmlToLua();
-    void run();
-    void luaPrint(const std::string& str); // tolua_export
+        const std::stringstream& getOutput() const { return output_; }
+        void clearOutput() { output_.clear(); } // tolua_export
+
+        void setIncludeParser(std::string (*function)(const std::string&)) { includeParseFunction_ = function; }
+        lua_State* getInternalLuaState() { return luaState_; }
+
+        static bool addToluaInterface(int (*function)(lua_State*), const std::string& name);
+        static bool removeToluaInterface(const std::string& name);
+        static void openToluaInterfaces(lua_State* state);
+        static void closeToluaInterfaces(lua_State* state);
+
+    private:
+        shared_ptr<ResourceInfo> getFileInfo(const std::string& filename, const std::string& resourceGroup, bool bSearchOtherPaths);
 
 #if LUA_VERSION_NUM != 501
-    static const char * lua_Chunkreader(lua_State *L, void *data, size_t *size);
+        struct LoadS
+        {
+            const char* s;
+            size_t size;
+        };
+
+        static const char * lua_Chunkreader(lua_State *L, void *data, size_t *size);
 #endif
 
-    inline lua_State* getLuaState() { return luaState_; };
-    inline const std::string& getLuaOutput() { return output_; };
-    //inline std::string* getFileString() { return &fileString_; };
-    inline void clearLuaOutput() { output_ = ""; }
+        std::stringstream output_;
+        lua_State* luaState_;
+        bool bIsRunning_;
+        shared_ptr<ResourceInfo> sourceFileInfo_;
+        std::string (*includeParseFunction_)(const std::string&);
 
-    std::string replaceLuaTags(const std::string& text); // tolua_export
+        typedef std::map<std::string, int (*)(lua_State *L)> ToluaInterfaceMap;
+        static ToluaInterfaceMap toluaInterfaces_s;
+        static std::vector<LuaState*> instances_s;
+    }; // tolua_export
+} // tolua_export
 
-    inline void setIncludePath(const std::string& includepath)
-        { this->includePath_ = includepath; }
-
-    void addToluaInterface(int (*function)(lua_State*), const std::string& name);
-    void openToluaInterfaces(lua_State* state);
-    void closeToluaInterfaces(lua_State* state);
-
-    private:
-      static LuaBind* singletonPtr_s;
-
-      std::string luaSource_;
-      std::string output_;
-      lua_State* luaState_;
-      bool isRunning_;
-      std::string includePath_;
-      std::vector<std::pair<std::string, int (*)(lua_State *L)> > toluaInterfaces_;
-
-  }; // tolua_export
-} // tolua_export
-#endif /* _LuaBind_H__ */
+#endif /* _LuaState_H__ */

code/branches/resource2/src/orxonox/gamestates/GSGraphics.cc

@@ -96 +96 @@
         // load debug overlay
         COUT(3) << "Loading Debug Overlay..." << std::endl;
-        this->debugOverlay_ = new XMLFile(Core::getDataPathString() + "overlay/debug.oxo");
+        this->debugOverlay_ = new XMLFile("debug.oxo");
         Loader::open(debugOverlay_);
 

code/branches/resource2/src/orxonox/gamestates/GSLevel.cc

@@ -246 +246 @@
         // call the loader
         COUT(0) << "Loading level..." << std::endl;
-        startFile_s = new XMLFile(Core::getDataPathString() + "levels" + '/' + LevelManager::getInstance().getDefaultLevel());
+        startFile_s = new XMLFile(LevelManager::getInstance().getDefaultLevel());
         Loader::open(startFile_s);
     }

code/branches/resource2/src/orxonox/gamestates/GSRoot.cc

@@ -33 +33 @@
 #include "core/Game.h"
 #include "core/GameMode.h"
-#include "core/LuaBind.h"
+#include "core/LuaState.h"
 #include "network/NetworkFunction.h"
-#include "ToluaBindCore.h"
 #include "ToluaBindOrxonox.h"
 #include "tools/Timer.h"
@@ -56 +55 @@
 
         // Tell LuaBind about all tolua interfaces
-        LuaBind::getInstance().addToluaInterface(&tolua_Core_open, "Core");
-        LuaBind::getInstance().addToluaInterface(&tolua_Orxonox_open, "Orxonox");
+        LuaState::addToluaInterface(&tolua_Orxonox_open, "Orxonox");
     }
 
@@ -86 +84 @@
         }
 
-        // create the global LevelManager
+        // create the LevelManager
         this->levelManager_ = new LevelManager();
     }

code/branches/resource2/src/orxonox/objects/Level.cc

@@ -53 +53 @@
         this->registerVariables();
         this->xmlfilename_ = this->getFilename();
-
-        if (this->xmlfilename_.length() >= Core::getDataPathString().length())
-            this->xmlfilename_ = this->xmlfilename_.substr(Core::getDataPathString().length());
     }
 

code/branches/resource2/src/orxonox/objects/Script.cc

@@ -29 +29 @@
 #include "Script.h"
 
-#include <tinyxml/ticpp.h>
 #include "core/CoreIncludes.h"
-#include "core/LuaBind.h"
+#include "core/LuaState.h"
+#include "core/XMLPort.h"
 
 namespace orxonox
 {
-  CreateFactory(Script);
+    CreateFactory(Script);
 
-  Script::Script(BaseObject* creator) : BaseObject(creator)
-  {
-    RegisterObject(Script);
+    Script::Script(BaseObject* creator) : BaseObject(creator)
+    {
+        RegisterObject(Script);
 
-    code_ = "";
-  }
+        // Get a new LuaState
+        luaState_ = new LuaState();
+    }
 
-  Script::~Script()
-  {
-  }
+    Script::~Script()
+    {
+        if (this->isInitialized())
+            delete luaState_;
+    }
 
-  /**
-  @brief XML loading and saving.
-  @param xmlelement The XML-element
-  @param loading Loading (true) or saving (false)
-   */
-  void Script::XMLPort(Element& xmlelement, XMLPort::Mode mode)
-  {
-    BaseObject::XMLPort(xmlelement, mode);
+    void Script::XMLPort(Element& xmlelement, XMLPort::Mode mode)
+    {
+        BaseObject::XMLPort(xmlelement, mode);
 
-    code_ = xmlelement.GetText(false);
-  }
+        XMLPortParam(Script, "code", setCode, getCode, xmlelement, mode);
+    }
 
-  void Script::execute()
-  {
-    LuaBind& lua = LuaBind::getInstance();
-    lua.loadString(this->code_);
-    lua.run();
-  }
+    void Script::execute()
+    {
+        luaState_->doString(code_);
+    }
 }

code/branches/resource2/src/orxonox/objects/Script.h

@@ -37 +37 @@
 namespace orxonox
 {
-  class _OrxonoxExport Script : public BaseObject
-  {
+    class _OrxonoxExport Script : public BaseObject
+    {
     public:
-      Script(BaseObject* creator);
-      ~Script();
-      void XMLPort(Element& xmlelement, XMLPort::Mode mode);
-      void execute();
+        Script(BaseObject* creator);
+        ~Script();
+        void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+        void execute();
+
+        void setCode(const std::string& code) { code_ = code; }
+        const std::string& getCode() const { return code_; }
 
     private:
-      std::string code_;
-  };
+        std::string code_;
+        LuaState* luaState_;
+    };
 }
 

code/branches/resource2/src/orxonox/sound/SoundBase.cc

@@ -36 +36 @@
 #include "util/Math.h"
 #include "core/Core.h"
+#include "core/Resource.h"
 #include "orxonox/objects/worldentities/WorldEntity.h"
 #include "SoundManager.h"
@@ -134 +135 @@
     }
 
-    bool SoundBase::loadFile(std::string filename) {
-        filename = Core::getDataPathString() + "/audio/" + filename;
-
+    bool SoundBase::loadFile(const std::string& filename) {
         if(!SoundManager::getInstance().isSoundAvailable())
         {
@@ -144 +143 @@
 
         COUT(3) << "Sound: OpenAL ALUT: loading file " << filename << std::endl;
-        this->buffer_ = alutCreateBufferFromFile(filename.c_str());
+        // Get DataStream from the resources
+        shared_ptr<ResourceInfo> fileInfo = Resource::getInfo(filename);
+        if (fileInfo == NULL) {
+            COUT(2) << "Warning: Sound file '" << filename << "' not found" << std::endl;
+            return false;
+        }
+        DataStreamPtr stream = Resource::open(filename);
+        // Read everything into a temporary buffer
+        char* buffer = new char[fileInfo->size];
+        stream->read(buffer, fileInfo->size);
+
+        this->buffer_ = alutCreateBufferFromFileImage(buffer, fileInfo->size);
+        delete[] buffer;
+
         if(this->buffer_ == AL_NONE) {
             COUT(2) << "Sound: OpenAL ALUT: " << alutGetErrorString(alutGetError()) << std::endl;

code/branches/resource2/src/orxonox/sound/SoundBase.h

@@ -55 +55 @@
         bool isStopped();
 
-        bool loadFile(std::string filename);
+        bool loadFile(const std::string& filename);
 
     private: