Merge branch 'master' into shadersystem

CMakeLists.txt

@@ -37,6 +37,9 @@ option(USE_FFMPEG "use ffmpeg for sound" OFF)
 option(USE_AUDIERE "use audiere for sound" OFF)
 option(USE_MPG123 "use mpg123 + libsndfile for sound" ON)
 
+# OS X deployment
+option(OPENMW_OSX_DEPLOYMENT OFF)
+
 find_program(DPKG_PROGRAM dpkg DOC "dpkg program of Debian-based systems")
 
 # Location of morrowind data files
@@ -230,13 +233,34 @@ if (APPLE)
                           ${OGRE_Plugin_OctreeSceneManager_LIBRARY_REL}
                           ${OGRE_Plugin_CgProgramManager_LIBRARY_REL}
                           ${OGRE_Plugin_ParticleFX_LIBRARY_REL})
+
+    if (${OGRE_PLUGIN_DIR_REL}})
+        set(OGRE_PLUGINS_REL_FOUND TRUE)
+    endif ()
+
+    if (${OGRE_PLUGIN_DIR_DBG})
+        set(OGRE_PLUGINS_DBG_FOUND TRUE)
+    endif ()
+
+    if (${OGRE_PLUGINS_REL_FOUND})
+        set(OGRE_PLUGIN_DIR ${OGRE_PLUGIN_DIR_REL})
+    else ()
+        set(OGRE_PLUGIN_DIR ${OGRE_PLUGIN_DIR_DBG})
+    endif ()
+    
+    #set(OGRE_PLUGIN_DIR "${OGRE_PLUGIN_DIR}/")
+
+    configure_file(${OpenMW_SOURCE_DIR}/files/mac/Info.plist
+        "${APP_BUNDLE_DIR}/Contents/Info.plist")
+
+    configure_file(${OpenMW_SOURCE_DIR}/files/mac/openmw.icns
+        "${APP_BUNDLE_DIR}/Contents/Resources/OpenMW.icns" COPYONLY)
 endif (APPLE)
 
 
 # Set up Ogre plugin folder & debug suffix
-set(DEBUG_SUFFIX "")
+# Ogre on OS X doesn't use "_d" suffix (see Ogre's CMakeLists.txt)
-if (DEFINED CMAKE_BUILD_TYPE AND CMAKE_BUILD_TYPE STREQUAL "Debug")
+if (DEFINED CMAKE_BUILD_TYPE AND CMAKE_BUILD_TYPE STREQUAL "Debug" AND NOT APPLE)
-	set(DEBUG_SUFFIX "_d")
 	add_definitions(-DOGRE_PLUGIN_DEBUG_SUFFIX="_d")
 else()
 	add_definitions(-DOGRE_PLUGIN_DEBUG_SUFFIX="")
@@ -244,7 +268,11 @@ endif()
 
 add_definitions(-DOGRE_PLUGIN_DIR_REL="${OGRE_PLUGIN_DIR_REL}")
 add_definitions(-DOGRE_PLUGIN_DIR_DBG="${OGRE_PLUGIN_DIR_DBG}")
+if (APPLE AND OPENMW_OSX_DEPLOYMENT)
+    add_definitions(-DOGRE_PLUGIN_DIR="${APP_BUNDLE_NAME}/Contents/Plugins")
+else()
     add_definitions(-DOGRE_PLUGIN_DIR="${OGRE_PLUGIN_DIR}")
+endif()
 
 
 add_subdirectory(files/)
@@ -277,35 +305,6 @@ if (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
         "${OpenMW_BINARY_DIR}/openmw.desktop")
 endif()
 
-if (APPLE)
-    if (${OGRE_PLUGIN_DIR_REL}})
-        set(OGRE_PLUGINS_REL_FOUND TRUE)
-    endif ()
-
-    if (${OGRE_PLUGIN_DIR_DBG})
-        set(OGRE_PLUGINS_DBG_FOUND TRUE)
-    endif ()
-
-    if (${OGRE_PLUGINS_REL_FOUND})
-        set(OGRE_PLUGIN_DIR ${OGRE_PLUGIN_DIR_REL})
-    else ()
-        set(OGRE_PLUGIN_DIR ${OGRE_PLUGIN_DIR_DBG})
-    endif ()
-
-    set(OGRE_PLUGIN_DIR "${OGRE_PLUGIN_DIR}/")
-
-    set(OGRE_PLUGIN_DIR_2 ${OGRE_PLUGIN_DIR})
-    set(OGRE_PLUGIN_DIR "")
-    set(OGRE_PLUGIN_DIR ${OGRE_PLUGIN_DIR_2})
-
-    configure_file(${OpenMW_SOURCE_DIR}/files/mac/Info.plist
-        "${APP_BUNDLE_DIR}/Contents/Info.plist")
-
-    configure_file(${OpenMW_SOURCE_DIR}/files/mac/openmw.icns
-        "${APP_BUNDLE_DIR}/Contents/Resources/OpenMW.icns" COPYONLY)
-endif (APPLE)
-
-
 # Compiler settings
 if (CMAKE_COMPILER_IS_GNUCC)
     add_definitions (-Wall -Wextra -Wno-unused-parameter -Wno-reorder)

apps/launcher/graphicspage.cpp

@@ -6,6 +6,7 @@
 #include <boost/filesystem.hpp>
 
 #include <components/files/configurationmanager.hpp>
+#include <components/files/ogreplugin.hpp>
 #include <components/settings/settings.hpp>
 
 #include "graphicspage.hpp"
@@ -115,13 +116,12 @@ bool GraphicsPage::setupOgre()
 #endif
     }
 
-    std::string glPlugin = std::string(pluginDir) + "/RenderSystem_GL" + OGRE_PLUGIN_DEBUG_SUFFIX;
+    boost::filesystem::path absPluginPath = boost::filesystem::absolute(boost::filesystem::path(pluginDir));
-    if (boost::filesystem::exists(glPlugin + ".so") || boost::filesystem::exists(glPlugin + ".dll"))
-        mOgre->loadPlugin (glPlugin);
 
-    std::string dxPlugin = std::string(pluginDir) + "/RenderSystem_Direct3D9" + OGRE_PLUGIN_DEBUG_SUFFIX;
+    pluginDir = absPluginPath.string();
-    if (boost::filesystem::exists(dxPlugin + ".so") || boost::filesystem::exists(dxPlugin + ".dll"))
+
-        mOgre->loadPlugin (dxPlugin);
+    Files::loadOgrePlugin(pluginDir, "RenderSystem_GL", *mOgre);
+    Files::loadOgrePlugin(pluginDir, "RenderSystem_Direct3D9", *mOgre);
 
 #ifdef ENABLE_PLUGIN_GL
     mGLPlugin = new Ogre::GLPlugin();

apps/openmw/CMakeLists.txt

@@ -21,6 +21,7 @@ add_openmw_dir (mwrender
 
 add_openmw_dir (mwinput
     inputmanager
+    mouselookevent
     )
 
 add_openmw_dir (mwgui
@@ -28,22 +29,22 @@ add_openmw_dir (mwgui
     dialogue_history window_base stats_window messagebox journalwindow charactercreation
     map_window window_pinnable_base cursorreplace tooltips scrollwindow bookwindow list
     formatting inventorywindow container hud countdialog tradewindow settingswindow
-    confirmationdialog alchemywindow referenceinterface spellwindow
+    confirmationdialog alchemywindow referenceinterface spellwindow mainmenu
     )
 
 add_openmw_dir (mwdialogue
-    dialoguemanager journal journalentry quest topic
+    dialoguemanagerimp journalimp journalentry quest topic
     )
 
 add_openmw_dir (mwscript
-    locals scriptmanager compilercontext interpretercontext cellextensions miscextensions
+    locals scriptmanagerimp compilercontext interpretercontext cellextensions miscextensions
     guiextensions soundextensions skyextensions statsextensions containerextensions
     aiextensions controlextensions extensions globalscripts ref dialogueextensions
     animationextensions transformationextensions consoleextensions userextensions
     )
 
 add_openmw_dir (mwsound
-    soundmanager openal_output audiere_decoder mpgsnd_decoder ffmpeg_decoder
+    soundmanagerimp openal_output audiere_decoder mpgsnd_decoder ffmpeg_decoder
     )
 
 add_openmw_dir (mwworld
@@ -64,7 +65,7 @@ add_openmw_dir (mwmechanics
     )
 
 add_openmw_dir (mwbase
-    environment world
+    environment world scriptmanager dialoguemanager journal soundmanager
     )
 
 # Main executable

apps/openmw/engine.cpp

@@ -18,10 +18,10 @@
 #include "mwgui/window_manager.hpp"
 #include "mwgui/cursorreplace.hpp"
 
-#include "mwscript/scriptmanager.hpp"
+#include "mwscript/scriptmanagerimp.hpp"
 #include "mwscript/extensions.hpp"
 
-#include "mwsound/soundmanager.hpp"
+#include "mwsound/soundmanagerimp.hpp"
 
 #include "mwworld/class.hpp"
 #include "mwworld/player.hpp"
@@ -29,8 +29,8 @@
 
 #include "mwclass/classes.hpp"
 
-#include "mwdialogue/dialoguemanager.hpp"
+#include "mwdialogue/dialoguemanagerimp.hpp"
-#include "mwdialogue/journal.hpp"
+#include "mwdialogue/journalimp.hpp"
 
 #include "mwmechanics/mechanicsmanager.hpp"
 

apps/openmw/mwbase/dialoguemanager.hpp

@@ -0,0 +1,46 @@
+#ifndef GAME_MWBASE_DIALOGUEMANAGER_H
+#define GAME_MWBASE_DIALOGUEMANAGER_H
+
+#include <string>
+
+namespace MWWorld
+{
+    class Ptr;
+}
+
+namespace MWBase
+{
+    /// \brief Interface for dialogue manager (implemented in MWDialogue)
+    class DialogueManager
+    {
+            DialogueManager (const DialogueManager&);
+            ///< not implemented
+
+            DialogueManager& operator= (const DialogueManager&);
+            ///< not implemented
+
+        public:
+
+            DialogueManager() {}
+
+            virtual ~DialogueManager() {}
+
+            virtual void startDialogue (const MWWorld::Ptr& actor) = 0;
+
+            virtual void addTopic (const std::string& topic) = 0;
+
+            virtual void askQuestion (const std::string& question,int choice) = 0;
+
+            virtual void goodbye() = 0;
+
+            ///get the faction of the actor you are talking with
+            virtual std::string getFaction() const = 0;
+
+            //calbacks for the GUI
+            virtual void keywordSelected (const std::string& keyword) = 0;
+            virtual void goodbyeSelected() = 0;
+            virtual void questionAnswered (const std::string& answer) = 0;
+    };
+}
+
+#endif

apps/openmw/mwbase/environment.cpp

@@ -5,16 +5,13 @@
 
 #include "../mwinput/inputmanager.hpp"
 
-#include "../mwscript/scriptmanager.hpp"
-
-#include "../mwsound/soundmanager.hpp"
-
-#include "../mwdialogue/dialoguemanager.hpp"
-#include "../mwdialogue/journal.hpp"
-
 #include "../mwmechanics/mechanicsmanager.hpp"
 
 #include "world.hpp"
+#include "scriptmanager.hpp"
+#include "dialoguemanager.hpp"
+#include "journal.hpp"
+#include "soundmanager.hpp"
 
 MWBase::Environment *MWBase::Environment::sThis = 0;
 
@@ -37,12 +34,12 @@ void MWBase::Environment::setWorld (World *world)
     mWorld = world;
 }
 
-void MWBase::Environment::setSoundManager (MWSound::SoundManager *soundManager)
+void MWBase::Environment::setSoundManager (SoundManager *soundManager)
 {
     mSoundManager = soundManager;
 }
 
-void MWBase::Environment::setScriptManager (MWScript::ScriptManager *scriptManager)
+void MWBase::Environment::setScriptManager (ScriptManager *scriptManager)
 {
     mScriptManager = scriptManager;
 }
@@ -57,12 +54,12 @@ void MWBase::Environment::setMechanicsManager (MWMechanics::MechanicsManager *me
     mMechanicsManager = mechanicsManager;
 }
 
-void MWBase::Environment::setDialogueManager (MWDialogue::DialogueManager *dialogueManager)
+void MWBase::Environment::setDialogueManager (DialogueManager *dialogueManager)
 {
     mDialogueManager = dialogueManager;
 }
 
-void MWBase::Environment::setJournal (MWDialogue::Journal *journal)
+void MWBase::Environment::setJournal (Journal *journal)
 {
     mJournal = journal;
 }
@@ -83,13 +80,13 @@ MWBase::World *MWBase::Environment::getWorld() const
     return mWorld;
 }
 
-MWSound::SoundManager *MWBase::Environment::getSoundManager() const
+MWBase::SoundManager *MWBase::Environment::getSoundManager() const
 {
     assert (mSoundManager);
     return mSoundManager;
 }
 
-MWScript::ScriptManager *MWBase::Environment::getScriptManager() const
+MWBase::ScriptManager *MWBase::Environment::getScriptManager() const
 {
     assert (mScriptManager);
     return mScriptManager;
@@ -107,13 +104,13 @@ MWMechanics::MechanicsManager *MWBase::Environment::getMechanicsManager() const
     return mMechanicsManager;
 }
 
-MWDialogue::DialogueManager *MWBase::Environment::getDialogueManager() const
+MWBase::DialogueManager *MWBase::Environment::getDialogueManager() const
 {
     assert (mDialogueManager);
     return mDialogueManager;
 }
 
-MWDialogue::Journal *MWBase::Environment::getJournal() const
+MWBase::Journal *MWBase::Environment::getJournal() const
 {
     assert (mJournal);
     return mJournal;

apps/openmw/mwbase/environment.hpp

@@ -1,16 +1,6 @@
 #ifndef GAME_BASE_INVIRONMENT_H
 #define GAME_BASE_INVIRONMENT_H
 
-namespace MWSound
-{
-    class SoundManager;
-}
-
-namespace MWScript
-{
-    class ScriptManager;
-}
-
 namespace MWGui
 {
     class WindowManager;
@@ -21,12 +11,6 @@ namespace MWMechanics
     class MechanicsManager;
 }
 
-namespace MWDialogue
-{
-    class DialogueManager;
-    class Journal;
-}
-
 namespace MWInput
 {
     struct MWInputManager;
@@ -35,6 +19,10 @@ namespace MWInput
 namespace MWBase
 {
     class World;
+    class ScriptManager;
+    class DialogueManager;
+    class Journal;
+    class SoundManager;
 
     /// \brief Central hub for mw-subsystems
     ///
@@ -47,12 +35,12 @@ namespace MWBase
             static Environment *sThis;
 
             World *mWorld;
-            MWSound::SoundManager *mSoundManager;
+            SoundManager *mSoundManager;
-            MWScript::ScriptManager *mScriptManager;
+            ScriptManager *mScriptManager;
             MWGui::WindowManager *mWindowManager;
             MWMechanics::MechanicsManager *mMechanicsManager;
-            MWDialogue::DialogueManager *mDialogueManager;
+            DialogueManager *mDialogueManager;
-            MWDialogue::Journal *mJournal;
+            Journal *mJournal;
             MWInput::MWInputManager *mInputManager;
             float mFrameDuration;
 
@@ -70,17 +58,17 @@ namespace MWBase
 
             void setWorld (World *world);
 
-            void setSoundManager (MWSound::SoundManager *soundManager);
+            void setSoundManager (SoundManager *soundManager);
 
-            void setScriptManager (MWScript::ScriptManager *scriptManager);
+            void setScriptManager (MWBase::ScriptManager *scriptManager);
 
             void setWindowManager (MWGui::WindowManager *windowManager);
 
             void setMechanicsManager (MWMechanics::MechanicsManager *mechanicsManager);
 
-            void setDialogueManager (MWDialogue::DialogueManager *dialogueManager);
+            void setDialogueManager (DialogueManager *dialogueManager);
 
-            void setJournal (MWDialogue::Journal *journal);
+            void setJournal (Journal *journal);
 
             void setInputManager (MWInput::MWInputManager *inputManager);
 
@@ -89,17 +77,17 @@ namespace MWBase
 
             World *getWorld() const;
 
-            MWSound::SoundManager *getSoundManager() const;
+            SoundManager *getSoundManager() const;
 
-            MWScript::ScriptManager *getScriptManager() const;
+            MWBase::ScriptManager *getScriptManager() const;
 
             MWGui::WindowManager *getWindowManager() const;
 
             MWMechanics::MechanicsManager *getMechanicsManager() const;
 
-            MWDialogue::DialogueManager *getDialogueManager() const;
+            DialogueManager *getDialogueManager() const;
 
-            MWDialogue::Journal *getJournal() const;
+            Journal *getJournal() const;
 
             MWInput::MWInputManager *getInputManager() const;
 

apps/openmw/mwbase/journal.hpp

@@ -0,0 +1,73 @@
+#ifndef GAME_MWBASE_JOURNAL_H
+#define GAME_MWBASE_JOURNAL_H
+
+#include <string>
+#include <deque>
+#include <map>
+
+#include "../mwdialogue/journalentry.hpp"
+#include "../mwdialogue/topic.hpp"
+#include "../mwdialogue/quest.hpp"
+
+namespace MWBase
+{
+    /// \brief Interface for the player's journal (implemented in MWDialogue)
+    class Journal
+    {
+            Journal (const Journal&);
+            ///< not implemented
+
+            Journal& operator= (const Journal&);
+            ///< not implemented
+
+        public:
+
+            typedef std::deque<MWDialogue::StampedJournalEntry> TEntryContainer;
+            typedef TEntryContainer::const_iterator TEntryIter;
+            typedef std::map<std::string, MWDialogue::Quest> TQuestContainer; // topc, quest
+            typedef TQuestContainer::const_iterator TQuestIter;
+            typedef std::map<std::string, MWDialogue::Topic> TTopicContainer; // topic-id, topic-content
+            typedef TTopicContainer::const_iterator TTopicIter;
+
+        public:
+
+            Journal() {}
+
+            virtual ~Journal() {}
+
+            virtual void addEntry (const std::string& id, int index) = 0;
+            ///< Add a journal entry.
+
+            virtual void setJournalIndex (const std::string& id, int index) = 0;
+            ///< Set the journal index without adding an entry.
+
+            virtual int getJournalIndex (const std::string& id) const = 0;
+            ///< Get the journal index.
+
+            virtual void addTopic (const std::string& topicId, const std::string& infoId) = 0;
+
+            virtual TEntryIter begin() const = 0;
+            ///< Iterator pointing to the begin of the main journal.
+            ///
+            /// \note Iterators to main journal entries will never become invalid.
+
+            virtual TEntryIter end() const = 0;
+            ///< Iterator pointing past the end of the main journal.
+
+            virtual TQuestIter questBegin() const = 0;
+            ///< Iterator pointing to the first quest (sorted by topic ID)
+
+            virtual TQuestIter questEnd() const = 0;
+            ///< Iterator pointing past the last quest.
+
+            virtual TTopicIter topicBegin() const = 0;
+            ///< Iterator pointing to the first topic (sorted by topic ID)
+            ///
+            /// \note The topic ID is identical with the user-visible topic string.
+
+            virtual TTopicIter topicEnd() const = 0;
+            ///< Iterator pointing past the last topic.
+    };
+}
+
+#endif

apps/openmw/mwbase/scriptmanager.hpp

@@ -0,0 +1,62 @@
+#ifndef GAME_MWBASE_SCRIPTMANAGER_H
+#define GAME_MWBASE_SCRIPTMANAGER_H
+
+#include <string>
+
+namespace Interpreter
+{
+    class Context;
+}
+
+namespace Compiler
+{
+    class Locals;
+}
+
+namespace MWScript
+{
+    class GlobalScripts;
+}
+
+namespace MWBase
+{
+    /// \brief Interface for script manager (implemented in MWScript)
+    class ScriptManager
+    {
+            ScriptManager (const ScriptManager&);
+            ///< not implemented
+
+            ScriptManager& operator= (const ScriptManager&);
+            ///< not implemented
+
+        public:
+
+            ScriptManager() {}
+
+            virtual ~ScriptManager() {}
+
+            virtual void run (const std::string& name, Interpreter::Context& interpreterContext) = 0;
+            ///< Run the script with the given name (compile first, if not compiled yet)
+
+            virtual bool compile (const std::string& name) = 0;
+            ///< Compile script with the given namen
+            /// \return Success?
+
+            virtual std::pair<int, int> compileAll() = 0;
+            ///< Compile all scripts
+            /// \return count, success
+
+            virtual Compiler::Locals& getLocals (const std::string& name) = 0;
+            ///< Return locals for script \a name.
+
+            virtual MWScript::GlobalScripts& getGlobalScripts() = 0;
+
+            virtual int getLocalIndex (const std::string& scriptId, const std::string& variable,
+                char type) = 0;
+            ///< Return index of the variable of the given name and type in the given script. Will
+            /// throw an exception, if there is no such script or variable or the type does not match.
+
+    };
+}
+
+#endif

apps/openmw/mwbase/soundmanager.hpp

@@ -0,0 +1,129 @@
+#ifndef GAME_MWBASE_SOUNDMANAGER_H
+#define GAME_MWBASE_SOUNDMANAGER_H
+
+#include <string>
+
+#include <boost/shared_ptr.hpp>
+
+#include <components/settings/settings.hpp>
+
+#include "../mwworld/ptr.hpp"
+
+namespace Ogre
+{
+    class Vector3;
+}
+
+namespace MWWorld
+{
+    class CellStore;
+}
+
+namespace MWSound
+{
+    class Sound;
+}
+
+namespace MWBase
+{
+    typedef boost::shared_ptr<MWSound::Sound> SoundPtr;
+
+    /// \brief Interface for sound manager (implemented in MWSound)
+    class SoundManager
+    {
+        public:
+
+            enum PlayMode {
+                Play_Normal  = 0, /* tracked, non-looping, multi-instance, environment */
+                Play_Loop    = 1<<0, /* Sound will continually loop until explicitly stopped */
+                Play_NoEnv   = 1<<1, /* Do not apply environment effects (eg, underwater filters) */
+                Play_NoTrack = 1<<2, /* (3D only) Play the sound at the given object's position
+                                      * but do not keep it updated (the sound will not move with
+                                      * the object and will not stop when the object is deleted. */
+            };
+
+        private:
+
+            SoundManager (const SoundManager&);
+            ///< not implemented
+
+            SoundManager& operator= (const SoundManager&);
+            ///< not implemented
+
+        public:
+
+            SoundManager() {}
+
+            virtual ~SoundManager() {}
+
+            virtual void processChangedSettings(const Settings::CategorySettingVector& settings) = 0;
+
+            virtual void stopMusic() = 0;
+            ///< Stops music if it's playing
+
+            virtual void streamMusic(const std::string& filename) = 0;
+            ///< Play a soundifle
+            /// \param filename name of a sound file in "Music/" in the data directory.
+
+            virtual void startRandomTitle() = 0;
+            ///< Starts a random track from the current playlist
+
+            virtual bool isMusicPlaying() = 0;
+            ///< Returns true if music is playing
+
+            virtual void playPlaylist(const std::string &playlist) = 0;
+            ///< Start playing music from the selected folder
+            /// \param name of the folder that contains the playlist
+
+            virtual void say(MWWorld::Ptr reference, const std::string& filename) = 0;
+            ///< Make an actor say some text.
+            /// \param filename name of a sound file in "Sound/" in the data directory.
+
+            virtual void say(const std::string& filename) = 0;
+            ///< Say some text, without an actor ref
+            /// \param filename name of a sound file in "Sound/" in the data directory.
+
+            virtual bool sayDone(MWWorld::Ptr reference=MWWorld::Ptr()) const = 0;
+            ///< Is actor not speaking?
+
+            virtual void stopSay(MWWorld::Ptr reference=MWWorld::Ptr()) = 0;
+            ///< Stop an actor speaking
+
+            virtual SoundPtr playSound(const std::string& soundId, float volume, float pitch,
+                int mode=Play_Normal) = 0;
+            ///< Play a sound, independently of 3D-position
+
+            virtual SoundPtr playSound3D(MWWorld::Ptr reference, const std::string& soundId,
+                                 float volume, float pitch, int mode=Play_Normal) = 0;
+            ///< Play a sound from an object
+
+            virtual void stopSound3D(MWWorld::Ptr reference, const std::string& soundId) = 0;
+            ///< Stop the given object from playing the given sound,
+
+            virtual void stopSound3D(MWWorld::Ptr reference) = 0;
+            ///< Stop the given object from playing all sounds.
+
+            virtual void stopSound(const MWWorld::CellStore *cell) = 0;
+            ///< Stop all sounds for the given cell.
+
+            virtual void stopSound(const std::string& soundId) = 0;
+            ///< Stop a non-3d looping sound
+
+            virtual bool getSoundPlaying(MWWorld::Ptr reference, const std::string& soundId) const = 0;
+            ///< Is the given sound currently playing on the given object?
+
+            virtual void updateObject(MWWorld::Ptr reference) = 0;
+            ///< Update the position of all sounds connected to the given object.
+
+            virtual void update(float duration) = 0;
+
+            virtual void setListenerPosDir(const Ogre::Vector3 &pos, const Ogre::Vector3 &dir) = 0;
+    };
+
+    inline int operator|(SoundManager::PlayMode a, SoundManager::PlayMode b)
+    { return static_cast<int> (a) | static_cast<int> (b); }
+    inline int operator&(SoundManager::PlayMode a, SoundManager::PlayMode b)
+    { return static_cast<int> (a) & static_cast<int> (b); }
+}
+
+#endif

apps/openmw/mwbase/world.hpp

@@ -46,6 +46,7 @@ namespace MWWorld
 
 namespace MWBase
 {
+    /// \brief Interface for the World (implemented in MWWorld)
     class World
     {
             World (const World&);
@@ -54,14 +55,6 @@ namespace MWBase
             World& operator= (const World&);
             ///< not implemented
 
-        protected:
-
-            virtual void
-            placeObject(
-                const MWWorld::Ptr &ptr,
-                MWWorld::CellStore &cell,
-                const ESM::Position &pos) = 0;
-
         public:
 
             enum RenderMode
@@ -184,9 +177,12 @@ namespace MWBase
 
             virtual void moveObject (const MWWorld::Ptr& ptr, float x, float y, float z) = 0;
 
+            virtual void
+            moveObject(const MWWorld::Ptr &ptr, MWWorld::CellStore &newCell, float x, float y, float z) = 0;
+
             virtual void scaleObject (const MWWorld::Ptr& ptr, float scale) = 0;
 
-            virtual void rotateObject(const MWWorld::Ptr& ptr,float x,float y,float z) = 0;
+            virtual void rotateObject(const MWWorld::Ptr& ptr,float x,float y,float z, bool adjust = false) = 0;
 
             virtual void indexToPosition (int cellX, int cellY, float &x, float &y, bool centre = false)
                 const = 0;
@@ -249,6 +245,9 @@ namespace MWBase
             ///< @return true if it is possible to place on object at specified cursor location
 
             virtual void processChangedSettings (const Settings::CategorySettingVector& settings) = 0;
+
+            virtual bool isSwimming(const MWWorld::Ptr &object) = 0;
+            virtual bool isUnderwater(const ESM::Cell &cell, const Ogre::Vector3 &pos) = 0;
     };
 }
 

apps/openmw/mwclass/apparatus.cpp

@@ -5,6 +5,7 @@
 
 #include "../mwbase/environment.hpp"
 #include "../mwbase/world.hpp"
+#include "../mwbase/soundmanager.hpp"
 
 #include "../mwworld/ptr.hpp"
 #include "../mwworld/actiontake.hpp"
@@ -18,8 +19,6 @@
 #include "../mwgui/window_manager.hpp"
 #include "../mwgui/tooltips.hpp"
 
-#include "../mwsound/soundmanager.hpp"
-
 namespace MWClass
 {
     void Apparatus::insertObjectRendering (const MWWorld::Ptr& ptr, MWRender::RenderingInterface& renderingInterface) const
@@ -64,7 +63,7 @@ namespace MWClass
     boost::shared_ptr<MWWorld::Action> Apparatus::activate (const MWWorld::Ptr& ptr,
         const MWWorld::Ptr& actor) const
     {
-        MWBase::Environment::get().getSoundManager()->playSound3D (ptr, getUpSoundId(ptr), 1.0, 1.0, MWSound::Play_NoTrack);
+        MWBase::Environment::get().getSoundManager()->playSound3D (ptr, getUpSoundId(ptr), 1.0, 1.0, MWBase::SoundManager::Play_NoTrack);
 
         return boost::shared_ptr<MWWorld::Action> (
             new MWWorld::ActionTake (ptr));

apps/openmw/mwclass/armor.cpp

@@ -7,6 +7,7 @@
 
 #include "../mwbase/environment.hpp"
 #include "../mwbase/world.hpp"
+#include "../mwbase/soundmanager.hpp"
 
 #include "../mwworld/ptr.hpp"
 #include "../mwworld/actiontake.hpp"
@@ -21,8 +22,6 @@
 #include "../mwgui/window_manager.hpp"
 #include "../mwgui/tooltips.hpp"
 
-#include "../mwsound/soundmanager.hpp"
-
 namespace MWClass
 {
     void Armor::insertObjectRendering (const MWWorld::Ptr& ptr, MWRender::RenderingInterface& renderingInterface) const
@@ -67,7 +66,7 @@ namespace MWClass
     boost::shared_ptr<MWWorld::Action> Armor::activate (const MWWorld::Ptr& ptr,
         const MWWorld::Ptr& actor) const
     {
-        MWBase::Environment::get().getSoundManager()->playSound3D (ptr, getUpSoundId(ptr), 1.0, 1.0, MWSound::Play_NoTrack);
+        MWBase::Environment::get().getSoundManager()->playSound3D (ptr, getUpSoundId(ptr), 1.0, 1.0, MWBase::SoundManager::Play_NoTrack);
 
         return boost::shared_ptr<MWWorld::Action> (
             new MWWorld::ActionTake (ptr));

apps/openmw/mwclass/book.cpp

@@ -5,6 +5,7 @@
 
 #include "../mwbase/environment.hpp"
 #include "../mwbase/world.hpp"
+#include "../mwbase/soundmanager.hpp"
 
 #include "../mwworld/ptr.hpp"
 #include "../mwworld/actionread.hpp"
@@ -17,8 +18,6 @@
 #include "../mwgui/window_manager.hpp"
 #include "../mwgui/tooltips.hpp"
 
-#include "../mwsound/soundmanager.hpp"
-
 namespace MWClass
 {
     void Book::insertObjectRendering (const MWWorld::Ptr& ptr, MWRender::RenderingInterface& renderingInterface) const

apps/openmw/mwclass/clothing.cpp

@@ -5,6 +5,7 @@
 
 #include "../mwbase/environment.hpp"
 #include "../mwbase/world.hpp"
+#include "../mwbase/soundmanager.hpp"
 
 #include "../mwworld/ptr.hpp"
 #include "../mwworld/actiontake.hpp"
@@ -19,8 +20,6 @@
 #include "../mwrender/objects.hpp"
 #include "../mwrender/renderinginterface.hpp"
 
-#include "../mwsound/soundmanager.hpp"
-
 namespace MWClass
 {
     void Clothing::insertObjectRendering (const MWWorld::Ptr& ptr, MWRender::RenderingInterface& renderingInterface) const
@@ -65,7 +64,7 @@ namespace MWClass
     boost::shared_ptr<MWWorld::Action> Clothing::activate (const MWWorld::Ptr& ptr,
         const MWWorld::Ptr& actor) const
     {
-         MWBase::Environment::get().getSoundManager()->playSound3D (ptr, getUpSoundId(ptr), 1.0, 1.0, MWSound::Play_NoTrack);
+         MWBase::Environment::get().getSoundManager()->playSound3D (ptr, getUpSoundId(ptr), 1.0, 1.0, MWBase::SoundManager::Play_NoTrack);
 
         return boost::shared_ptr<MWWorld::Action> (
             new MWWorld::ActionTake (ptr));

apps/openmw/mwclass/container.cpp

@@ -5,6 +5,7 @@
 
 #include "../mwbase/environment.hpp"
 #include "../mwbase/world.hpp"
+#include "../mwbase/soundmanager.hpp"
 
 #include "../mwworld/ptr.hpp"
 #include "../mwworld/nullaction.hpp"
@@ -20,8 +21,6 @@
 #include "../mwrender/objects.hpp"
 #include "../mwrender/renderinginterface.hpp"
 
-#include "../mwsound/soundmanager.hpp"
-
 namespace
 {
     struct CustomData : public MWWorld::CustomData

apps/openmw/mwclass/creature.hpp

@@ -59,6 +59,11 @@ namespace MWClass
             static void registerSelf();
 
             virtual std::string getModel(const MWWorld::Ptr &ptr) const;
+
+            virtual bool
+            isActor() const {
+                return true;
+            }
     };
 }
 

apps/openmw/mwclass/door.cpp

@@ -5,6 +5,7 @@
 
 #include "../mwbase/environment.hpp"
 #include "../mwbase/world.hpp"
+#include "../mwbase/soundmanager.hpp"
 
 #include "../mwworld/player.hpp"
 #include "../mwworld/ptr.hpp"
@@ -19,8 +20,6 @@
 #include "../mwrender/objects.hpp"
 #include "../mwrender/renderinginterface.hpp"
 
-#include "../mwsound/soundmanager.hpp"
-
 namespace MWClass
 {
     void Door::insertObjectRendering (const MWWorld::Ptr& ptr, MWRender::RenderingInterface& renderingInterface) const

apps/openmw/mwclass/ingredient.cpp

@@ -5,6 +5,7 @@
 
 #include "../mwbase/environment.hpp"
 #include "../mwbase/world.hpp"
+#include "../mwbase/soundmanager.hpp"
 
 #include "../mwworld/ptr.hpp"
 #include "../mwworld/actiontake.hpp"
@@ -17,8 +18,6 @@
 #include "../mwrender/objects.hpp"
 #include "../mwrender/renderinginterface.hpp"
 
-#include "../mwsound/soundmanager.hpp"
-
 namespace MWClass
 {
     void Ingredient::insertObjectRendering (const MWWorld::Ptr& ptr, MWRender::RenderingInterface& renderingInterface) const
@@ -63,7 +62,7 @@ namespace MWClass
     boost::shared_ptr<MWWorld::Action> Ingredient::activate (const MWWorld::Ptr& ptr,
         const MWWorld::Ptr& actor) const
     {
-        MWBase::Environment::get().getSoundManager()->playSound3D (ptr, getUpSoundId(ptr), 1.0, 1.0, MWSound::Play_NoTrack);
+        MWBase::Environment::get().getSoundManager()->playSound3D (ptr, getUpSoundId(ptr), 1.0, 1.0, MWBase::SoundManager::Play_NoTrack);
 
         return boost::shared_ptr<MWWorld::Action> (
             new MWWorld::ActionTake (ptr));

apps/openmw/mwclass/light.cpp

@@ -5,6 +5,7 @@
 
 #include "../mwbase/environment.hpp"
 #include "../mwbase/world.hpp"
+#include "../mwbase/soundmanager.hpp"
 
 #include "../mwworld/ptr.hpp"
 #include "../mwworld/actiontake.hpp"
@@ -17,8 +18,6 @@
 #include "../mwgui/window_manager.hpp"
 #include "../mwgui/tooltips.hpp"
 
-#include "../mwsound/soundmanager.hpp"
-
 #include "../mwrender/objects.hpp"
 #include "../mwrender/renderinginterface.hpp"
 
@@ -58,7 +57,7 @@ namespace MWClass
             physics.insertObjectPhysics(ptr, "meshes\\" + model);
         }
         if (!ref->base->sound.empty()) {
-            MWBase::Environment::get().getSoundManager()->playSound3D(ptr, ref->base->sound, 1.0, 1.0, MWSound::Play_Loop);
+            MWBase::Environment::get().getSoundManager()->playSound3D(ptr, ref->base->sound, 1.0, 1.0, MWBase::SoundManager::Play_Loop);
         }
     }
 
@@ -95,7 +94,7 @@ namespace MWClass
         if (!(ref->base->data.flags & ESM::Light::Carry))
             return boost::shared_ptr<MWWorld::Action> (new MWWorld::NullAction);
 
-        MWBase::Environment::get().getSoundManager()->playSound3D (ptr, getUpSoundId(ptr), 1.0, 1.0, MWSound::Play_NoTrack);
+        MWBase::Environment::get().getSoundManager()->playSound3D (ptr, getUpSoundId(ptr), 1.0, 1.0, MWBase::SoundManager::Play_NoTrack);
 
         return boost::shared_ptr<MWWorld::Action> (
             new MWWorld::ActionTake (ptr));

apps/openmw/mwclass/lockpick.cpp

@@ -5,6 +5,7 @@
 
 #include "../mwbase/environment.hpp"
 #include "../mwbase/world.hpp"
+#include "../mwbase/soundmanager.hpp"
 
 #include "../mwworld/ptr.hpp"
 #include "../mwworld/actiontake.hpp"
@@ -19,8 +20,6 @@
 #include "../mwrender/objects.hpp"
 #include "../mwrender/renderinginterface.hpp"
 
-#include "../mwsound/soundmanager.hpp"
-
 namespace MWClass
 {
     void Lockpick::insertObjectRendering (const MWWorld::Ptr& ptr, MWRender::RenderingInterface& renderingInterface) const
@@ -65,7 +64,7 @@ namespace MWClass
     boost::shared_ptr<MWWorld::Action> Lockpick::activate (const MWWorld::Ptr& ptr,
         const MWWorld::Ptr& actor) const
     {
-        MWBase::Environment::get().getSoundManager()->playSound3D (ptr, getUpSoundId(ptr), 1.0, 1.0, MWSound::Play_NoTrack);
+        MWBase::Environment::get().getSoundManager()->playSound3D (ptr, getUpSoundId(ptr), 1.0, 1.0, MWBase::SoundManager::Play_NoTrack);
 
         return boost::shared_ptr<MWWorld::Action> (
             new MWWorld::ActionTake (ptr));

apps/openmw/mwclass/misc.cpp

@@ -7,6 +7,7 @@
 
 #include "../mwbase/environment.hpp"
 #include "../mwbase/world.hpp"
+#include "../mwbase/soundmanager.hpp"
 
 #include "../mwworld/ptr.hpp"
 #include "../mwworld/actiontake.hpp"
@@ -20,8 +21,6 @@
 #include "../mwrender/objects.hpp"
 #include "../mwrender/renderinginterface.hpp"
 
-#include "../mwsound/soundmanager.hpp"
-
 #include <boost/lexical_cast.hpp>
 
 namespace MWClass
@@ -68,7 +67,7 @@ namespace MWClass
     boost::shared_ptr<MWWorld::Action> Miscellaneous::activate (const MWWorld::Ptr& ptr,
         const MWWorld::Ptr& actor) const
     {
-        MWBase::Environment::get().getSoundManager()->playSound3D (ptr, getUpSoundId(ptr), 1.0, 1.0, MWSound::Play_NoTrack);
+        MWBase::Environment::get().getSoundManager()->playSound3D (ptr, getUpSoundId(ptr), 1.0, 1.0, MWBase::SoundManager::Play_NoTrack);
 
         return boost::shared_ptr<MWWorld::Action> (
             new MWWorld::ActionTake (ptr));

apps/openmw/mwclass/npc.hpp

@@ -93,6 +93,11 @@ namespace MWClass
             static void registerSelf();
 
             virtual std::string getModel(const MWWorld::Ptr &ptr) const;
+
+            virtual bool
+            isActor() const {
+                return true;
+            }
     };
 }
 

apps/openmw/mwclass/potion.cpp

@@ -5,6 +5,7 @@
 
 #include "../mwbase/environment.hpp"
 #include "../mwbase/world.hpp"
+#include "../mwbase/soundmanager.hpp"
 
 #include "../mwworld/ptr.hpp"
 #include "../mwworld/actiontake.hpp"
@@ -19,8 +20,6 @@
 #include "../mwrender/objects.hpp"
 #include "../mwrender/renderinginterface.hpp"
 
-#include "../mwsound/soundmanager.hpp"
-
 namespace MWClass
 {
     void Potion::insertObjectRendering (const MWWorld::Ptr& ptr, MWRender::RenderingInterface& renderingInterface) const
@@ -65,7 +64,7 @@ namespace MWClass
     boost::shared_ptr<MWWorld::Action> Potion::activate (const MWWorld::Ptr& ptr,
         const MWWorld::Ptr& actor) const
     {
-        MWBase::Environment::get().getSoundManager()->playSound3D (ptr, getUpSoundId(ptr), 1.0, 1.0, MWSound::Play_NoTrack);
+        MWBase::Environment::get().getSoundManager()->playSound3D (ptr, getUpSoundId(ptr), 1.0, 1.0, MWBase::SoundManager::Play_NoTrack);
 
         return boost::shared_ptr<MWWorld::Action> (
             new MWWorld::ActionTake (ptr));

apps/openmw/mwclass/probe.cpp

@@ -5,6 +5,7 @@
 
 #include "../mwbase/environment.hpp"
 #include "../mwbase/world.hpp"
+#include "../mwbase/soundmanager.hpp"
 
 #include "../mwworld/ptr.hpp"
 #include "../mwworld/actiontake.hpp"
@@ -19,8 +20,6 @@
 #include "../mwrender/objects.hpp"
 #include "../mwrender/renderinginterface.hpp"
 
-#include "../mwsound/soundmanager.hpp"
-
 namespace MWClass
 {
     void Probe::insertObjectRendering (const MWWorld::Ptr& ptr, MWRender::RenderingInterface& renderingInterface) const
@@ -64,7 +63,7 @@ namespace MWClass
     boost::shared_ptr<MWWorld::Action> Probe::activate (const MWWorld::Ptr& ptr,
         const MWWorld::Ptr& actor) const
     {
-        MWBase::Environment::get().getSoundManager()->playSound3D (ptr, getUpSoundId(ptr), 1.0, 1.0, MWSound::Play_NoTrack);
+        MWBase::Environment::get().getSoundManager()->playSound3D (ptr, getUpSoundId(ptr), 1.0, 1.0, MWBase::SoundManager::Play_NoTrack);
 
         return boost::shared_ptr<MWWorld::Action> (
             new MWWorld::ActionTake (ptr));
@@ -174,4 +173,3 @@ namespace MWClass
         return MWWorld::Ptr(&cell.probes.insert(*ref), &cell);
     }
 }
-

apps/openmw/mwclass/repair.cpp

@@ -5,6 +5,7 @@
 
 #include "../mwbase/environment.hpp"
 #include "../mwbase/world.hpp"
+#include "../mwbase/soundmanager.hpp"
 
 #include "../mwworld/ptr.hpp"
 #include "../mwworld/actiontake.hpp"
@@ -17,8 +18,6 @@
 #include "../mwrender/objects.hpp"
 #include "../mwrender/renderinginterface.hpp"
 
-#include "../mwsound/soundmanager.hpp"
-
 namespace MWClass
 {
     void Repair::insertObjectRendering (const MWWorld::Ptr& ptr, MWRender::RenderingInterface& renderingInterface) const
@@ -63,7 +62,7 @@ namespace MWClass
     boost::shared_ptr<MWWorld::Action> Repair::activate (const MWWorld::Ptr& ptr,
         const MWWorld::Ptr& actor) const
     {
-        MWBase::Environment::get().getSoundManager()->playSound3D (ptr, getUpSoundId(ptr), 1.0, 1.0, MWSound::Play_NoTrack);
+        MWBase::Environment::get().getSoundManager()->playSound3D (ptr, getUpSoundId(ptr), 1.0, 1.0, MWBase::SoundManager::Play_NoTrack);
 
         return boost::shared_ptr<MWWorld::Action> (
             new MWWorld::ActionTake (ptr));

apps/openmw/mwclass/weapon.cpp

@@ -5,6 +5,7 @@
 
 #include "../mwbase/environment.hpp"
 #include "../mwbase/world.hpp"
+#include "../mwbase/soundmanager.hpp"
 
 #include "../mwworld/ptr.hpp"
 #include "../mwworld/actiontake.hpp"
@@ -19,8 +20,6 @@
 #include "../mwrender/objects.hpp"
 #include "../mwrender/renderinginterface.hpp"
 
-#include "../mwsound/soundmanager.hpp"
-
 namespace MWClass
 {
     void Weapon::insertObjectRendering (const MWWorld::Ptr& ptr, MWRender::RenderingInterface& renderingInterface) const
@@ -65,7 +64,7 @@ namespace MWClass
     boost::shared_ptr<MWWorld::Action> Weapon::activate (const MWWorld::Ptr& ptr,
         const MWWorld::Ptr& actor) const
     {
-        MWBase::Environment::get().getSoundManager()->playSound3D (ptr, getUpSoundId(ptr), 1.0, 1.0, MWSound::Play_NoTrack);
+        MWBase::Environment::get().getSoundManager()->playSound3D (ptr, getUpSoundId(ptr), 1.0, 1.0, MWBase::SoundManager::Play_NoTrack);
 
         return boost::shared_ptr<MWWorld::Action> (
             new MWWorld::ActionTake (ptr));

apps/openmw/mwdialogue/dialoguemanagerimp.cpp

@@ -1,5 +1,5 @@
 
-#include "dialoguemanager.hpp"
+#include "dialoguemanagerimp.hpp"
 
 #include <cctype>
 #include <algorithm>
@@ -11,6 +11,8 @@
 
 #include "../mwbase/environment.hpp"
 #include "../mwbase/world.hpp"
+#include "../mwbase/scriptmanager.hpp"
+#include "../mwbase/journal.hpp"
 
 #include "../mwworld/class.hpp"
 #include "../mwworld/refdata.hpp"
@@ -21,12 +23,9 @@
 #include "../mwgui/dialogue.hpp"
 #include "../mwgui/window_manager.hpp"
 
-#include "journal.hpp"
-
 #include <iostream>
 
 #include "../mwscript/extensions.hpp"
-#include "../mwscript/scriptmanager.hpp"
 
 #include <components/compiler/exception.hpp>
 #include <components/compiler/errorhandler.hpp>
@@ -599,7 +598,7 @@ namespace MWDialogue
         }
     }
 
-    void DialogueManager::addTopic(std::string topic)
+    void DialogueManager::addTopic (const std::string& topic)
     {
         mKnownTopics[toLower(topic)] = true;
     }
@@ -804,7 +803,7 @@ namespace MWDialogue
         mChoice = choice;
     }
 
-    void DialogueManager::keywordSelected(std::string keyword)
+    void DialogueManager::keywordSelected (const std::string& keyword)
     {
         if(!mIsInChoice)
         {
@@ -846,11 +845,11 @@ namespace MWDialogue
         MWBase::Environment::get().getWindowManager()->removeGuiMode(MWGui::GM_Dialogue);
     }
 
-    void DialogueManager::questionAnswered(std::string answere)
+    void DialogueManager::questionAnswered (const std::string& answer)
     {
-        if(mChoiceMap.find(answere) != mChoiceMap.end())
+        if(mChoiceMap.find(answer) != mChoiceMap.end())
         {
-            mChoice = mChoiceMap[answere];
+            mChoice = mChoiceMap[answer];
 
             std::vector<ESM::DialInfo>::const_iterator iter;
             if(mDialogueMap.find(mLastTopic) != mDialogueMap.end())
@@ -888,7 +887,7 @@ namespace MWDialogue
         win->addText(error);
     }
 
-    void DialogueManager::askQuestion(std::string question, int choice)
+    void DialogueManager::askQuestion (const std::string& question, int choice)
     {
         MWGui::DialogueWindow* win = MWBase::Environment::get().getWindowManager()->getDialogueWindow();
         win->askQuestion(question);
@@ -896,7 +895,7 @@ namespace MWDialogue
         mIsInChoice = true;
     }
 
-    std::string DialogueManager::getFaction()
+    std::string DialogueManager::getFaction() const
     {
         if (mActor.getTypeName() != typeid(ESM::NPC).name())
             return "";

apps/openmw/mwdialogue/dialoguemanagerimp.hpp

@@ -1,5 +1,5 @@
-#ifndef GAME_MMDIALOG_DIALOGUEMANAGER_H
+#ifndef GAME_MWDIALOG_DIALOGUEMANAGERIMP_H
-#define GAME_MWDIALOG_DIALOGUEMANAGER_H
+#define GAME_MWDIALOG_DIALOGUEMANAGERIMP_H
 
 #include <components/esm/loadinfo.hpp>
 
@@ -8,12 +8,15 @@
 #include "../mwscript/interpretercontext.hpp"
 #include <components/compiler/output.hpp>
 
+#include "../mwbase/dialoguemanager.hpp"
+
 #include "../mwworld/ptr.hpp"
+
 #include <map>
 
 namespace MWDialogue
 {
-    class DialogueManager
+    class DialogueManager : public MWBase::DialogueManager
     {
             bool isMatching (const MWWorld::Ptr& actor, const ESM::DialInfo::SelectStruct& select) const;
 
@@ -50,21 +53,21 @@ namespace MWDialogue
 
             DialogueManager (const Compiler::Extensions& extensions);
 
-            void startDialogue (const MWWorld::Ptr& actor);
+            virtual void startDialogue (const MWWorld::Ptr& actor);
 
-            void addTopic(std::string topic);
+            virtual void addTopic (const std::string& topic);
 
-            void askQuestion(std::string question,int choice);
+            virtual void askQuestion (const std::string& question,int choice);
 
-            void goodbye();
+            virtual void goodbye();
 
             ///get the faction of the actor you are talking with
-            std::string getFaction();
+            virtual std::string getFaction() const;
 
             //calbacks for the GUI
-            void keywordSelected(std::string keyword);
+            virtual void keywordSelected (const std::string& keyword);
-            void goodbyeSelected();
+            virtual void goodbyeSelected();
-            void questionAnswered(std::string answere);
+            virtual void questionAnswered (const std::string& answer);
 
     };
 }

apps/openmw/mwdialogue/journalentry.hpp

@@ -1,5 +1,5 @@
-#ifndef GAME_MMDIALOGUE_JOURNALENTRY_H
+#ifndef GAME_MWDIALOGUE_JOURNALENTRY_H
-#define GAME_MMDIALOGUE_JOURNALENTRY_H
+#define GAME_MWDIALOGUE_JOURNALENTRY_H
 
 #include <string>
 

apps/openmw/mwdialogue/journalimp.cpp

@@ -1,5 +1,5 @@
 
-#include "journal.hpp"
+#include "journalimp.hpp"
 
 #include "../mwbase/environment.hpp"
 #include "../mwbase/world.hpp"

apps/openmw/mwdialogue/journalimp.hpp

@@ -1,9 +1,7 @@
-#ifndef GAME_MMDIALOG_JOURNAL_H
+#ifndef GAME_MWDIALOG_JOURNAL_H
 #define GAME_MWDIALOG_JOURNAL_H
 
-#include <string>
+#include "../mwbase/journal.hpp"
-#include <deque>
-#include <map>
 
 #include "journalentry.hpp"
 #include "quest.hpp"
@@ -11,19 +9,8 @@
 namespace MWDialogue
 {
     /// \brief The player's journal
-    class Journal
+    class Journal : public MWBase::Journal
     {
-        public:
-
-            typedef std::deque<StampedJournalEntry> TEntryContainer;
-            typedef TEntryContainer::const_iterator TEntryIter;
-            typedef std::map<std::string, Quest> TQuestContainer; // topc, quest
-            typedef TQuestContainer::const_iterator TQuestIter;
-            typedef std::map<std::string, Topic> TTopicContainer; // topic-id, topic-content
-            typedef TTopicContainer::const_iterator TTopicIter;
-
-        private:
-
             TEntryContainer mJournal;
             TQuestContainer mQuests;
             TTopicContainer mTopics;
@@ -34,37 +21,37 @@ namespace MWDialogue
 
             Journal();
 
-            void addEntry (const std::string& id, int index);
+            virtual void addEntry (const std::string& id, int index);
             ///< Add a journal entry.
 
-            void setJournalIndex (const std::string& id, int index);
+            virtual void setJournalIndex (const std::string& id, int index);
             ///< Set the journal index without adding an entry.
 
-            int getJournalIndex (const std::string& id) const;
+            virtual int getJournalIndex (const std::string& id) const;
             ///< Get the journal index.
 
-            void addTopic (const std::string& topicId, const std::string& infoId);
+            virtual void addTopic (const std::string& topicId, const std::string& infoId);
 
-            TEntryIter begin() const;
+            virtual TEntryIter begin() const;
             ///< Iterator pointing to the begin of the main journal.
             ///
             /// \note Iterators to main journal entries will never become invalid.
 
-            TEntryIter end() const;
+            virtual TEntryIter end() const;
             ///< Iterator pointing past the end of the main journal.
 
-            TQuestIter questBegin() const;
+            virtual TQuestIter questBegin() const;
             ///< Iterator pointing to the first quest (sorted by topic ID)
 
-            TQuestIter questEnd() const;
+            virtual TQuestIter questEnd() const;
             ///< Iterator pointing past the last quest.
 
-            TTopicIter topicBegin() const;
+            virtual TTopicIter topicBegin() const;
             ///< Iterator pointing to the first topic (sorted by topic ID)
             ///
             /// \note The topic ID is identical with the user-visible topic string.
 
-            TTopicIter topicEnd() const;
+            virtual TTopicIter topicEnd() const;
             ///< Iterator pointing past the last topic.
     };
 }

apps/openmw/mwdialogue/quest.hpp

@@ -1,4 +1,4 @@
-#ifndef GAME_MMDIALOG_QUEST_H
+#ifndef GAME_MWDIALOG_QUEST_H
 #define GAME_MWDIALOG_QUEST_H
 
 #include "topic.hpp"

apps/openmw/mwdialogue/topic.hpp

@@ -1,4 +1,4 @@
-#ifndef GAME_MMDIALOG_TOPIC_H
+#ifndef GAME_MWDIALOG_TOPIC_H
 #define GAME_MWDIALOG_TOPIC_H
 
 #include <string>

apps/openmw/mwgui/alchemywindow.cpp

@@ -4,13 +4,12 @@
 
 #include "../mwbase/environment.hpp"
 #include "../mwbase/world.hpp"
+#include "../mwbase/soundmanager.hpp"
 
 #include "../mwworld/player.hpp"
 #include "../mwworld/manualref.hpp"
 #include "../mwworld/containerstore.hpp"
 
-#include "../mwsound/soundmanager.hpp"
-
 #include "window_manager.hpp"
 
 namespace

apps/openmw/mwgui/bookwindow.cpp

@@ -4,8 +4,10 @@
 
 #include "../mwbase/environment.hpp"
 #include "../mwbase/world.hpp"
+#include "../mwbase/soundmanager.hpp"
+
 #include "../mwinput/inputmanager.hpp"
-#include "../mwsound/soundmanager.hpp"
+
 #include "../mwworld/actiontake.hpp"
 #include "../mwworld/player.hpp"
 
@@ -98,7 +100,7 @@ void BookWindow::onCloseButtonClicked (MyGUI::Widget* _sender)
 
 void BookWindow::onTakeButtonClicked (MyGUI::Widget* _sender)
 {
-    MWBase::Environment::get().getSoundManager()->playSound ("Item Book Up", 1.0, 1.0, MWSound::Play_NoTrack);
+    MWBase::Environment::get().getSoundManager()->playSound ("Item Book Up", 1.0, 1.0, MWBase::SoundManager::Play_NoTrack);
 
     MWWorld::ActionTake take(mBook);
     take.execute (MWBase::Environment::get().getWorld()->getPlayer().getPlayer());

apps/openmw/mwgui/charactercreation.cpp

@@ -9,7 +9,7 @@
 #include "mode.hpp"
 
 #include "../mwbase/environment.hpp"
-#include "../mwsound/soundmanager.hpp"
+#include "../mwbase/soundmanager.hpp"
 
 namespace
 {

apps/openmw/mwgui/container.cpp

@@ -10,6 +10,7 @@
 
 #include "../mwbase/environment.hpp"
 #include "../mwbase/world.hpp"
+#include "../mwbase/soundmanager.hpp"
 
 #include "../mwworld/manualref.hpp"
 #include "../mwworld/containerstore.hpp"
@@ -20,8 +21,6 @@
 
 #include "../mwinput/inputmanager.hpp"
 
-#include "../mwsound/soundmanager.hpp"
-
 #include "window_manager.hpp"
 #include "widgets.hpp"
 #include "countdialog.hpp"

apps/openmw/mwgui/cursorreplace.cpp

@@ -16,4 +16,5 @@ CursorReplace::CursorReplace()
     OEngine::Render::ImageRotate::rotate("textures\\tx_cursormove.dds", "mwpointer_dresize2.png", 45);
 
     OEngine::Render::Atlas::createFromFile("atlas1.cfg", "mwgui1", "textures\\");
+    OEngine::Render::Atlas::createFromFile("mainmenu.cfg", "mwgui2", "textures\\");
 }

apps/openmw/mwgui/dialogue.cpp

@@ -9,7 +9,8 @@
 #include <components/esm_store/store.hpp>
 
 #include "../mwbase/environment.hpp"
-#include "../mwdialogue/dialoguemanager.hpp"
+#include "../mwbase/dialoguemanager.hpp"
+#include "../mwbase/world.hpp"
 
 #include "dialogue_history.hpp"
 #include "window_manager.hpp"

apps/openmw/mwgui/hud.cpp

@@ -8,12 +8,11 @@
 
 #include "../mwbase/environment.hpp"
 #include "../mwbase/world.hpp"
+#include "../mwbase/soundmanager.hpp"
 
 #include "../mwworld/class.hpp"
 #include "../mwworld/player.hpp"
 
-#include "../mwsound/soundmanager.hpp"
-
 #include "../mwgui/widgets.hpp"
 
 #include "inventorywindow.hpp"

apps/openmw/mwgui/inventorywindow.cpp

@@ -9,6 +9,7 @@
 
 #include "../mwbase/world.hpp"
 #include "../mwbase/environment.hpp"
+#include "../mwbase/soundmanager.hpp"
 
 #include "../mwworld/containerstore.hpp"
 #include "../mwworld/class.hpp"
@@ -17,10 +18,6 @@
 #include "../mwworld/actiontake.hpp"
 #include "../mwworld/inventorystore.hpp"
 
-#include "../mwsound/soundmanager.hpp"
-
-#include "../mwclass/container.hpp"
-
 #include "window_manager.hpp"
 #include "widgets.hpp"
 #include "bookwindow.hpp"

apps/openmw/mwgui/journalwindow.cpp

@@ -2,10 +2,10 @@
 
 #include "../mwbase/environment.hpp"
 #include "../mwbase/world.hpp"
+#include "../mwbase/journal.hpp"
+#include "../mwbase/soundmanager.hpp"
 
-#include "../mwdialogue/journal.hpp"
+#include "../mwdialogue/journalentry.hpp"
-
-#include "../mwsound/soundmanager.hpp"
 
 #include "window_manager.hpp"
 

apps/openmw/mwgui/mainmenu.cpp

@@ -0,0 +1,78 @@
+#include "mainmenu.hpp"
+
+#include <OgreRoot.h>
+
+
+#include "../mwbase/environment.hpp"
+#include "../mwbase/world.hpp"
+
+#include "window_manager.hpp"
+
+namespace MWGui
+{
+
+    MainMenu::MainMenu(int w, int h)
+        : OEngine::GUI::Layout("openmw_mainmenu.layout")
+    {
+        setCoord(0,0,w,h);
+
+        int height = 64 * 3;
+
+        mButtonBox = mMainWidget->createWidget<MyGUI::Widget>("", MyGUI::IntCoord(w/2 - 64, h/2 - height/2, 128, height), MyGUI::Align::Default);
+        int curH = 0;
+
+        mReturn = mButtonBox->createWidget<MyGUI::Button> ("ButtonImage", MyGUI::IntCoord(0, curH, 128, 64), MyGUI::Align::Default);
+        mReturn->setImageResource ("Menu_Return");
+        mReturn->eventMouseButtonClick += MyGUI::newDelegate(this, &MainMenu::returnToGame);
+        curH += 64;
+
+
+        /*
+        mNewGame = mButtonBox->createWidget<MyGUI::Button> ("ButtonImage", MyGUI::IntCoord(0, curH, 128, 64), MyGUI::Align::Default);
+        mNewGame->setImageResource ("Menu_NewGame");
+        curH += 64;
+
+        mLoadGame = mButtonBox->createWidget<MyGUI::Button> ("ButtonImage", MyGUI::IntCoord(0, curH, 128, 64), MyGUI::Align::Default);
+        mLoadGame->setImageResource ("Menu_LoadGame");
+        curH += 64;
+
+
+        mSaveGame = mButtonBox->createWidget<MyGUI::Button> ("ButtonImage", MyGUI::IntCoord(0, curH, 128, 64), MyGUI::Align::Default);
+        mSaveGame->setImageResource ("Menu_SaveGame");
+        curH += 64;
+        */
+
+        mOptions = mButtonBox->createWidget<MyGUI::Button> ("ButtonImage", MyGUI::IntCoord(0, curH, 128, 64), MyGUI::Align::Default);
+        mOptions->setImageResource ("Menu_Options");
+        mOptions->eventMouseButtonClick += MyGUI::newDelegate(this, &MainMenu::showOptions);
+        curH += 64;
+
+        /*
+        mCredits = mButtonBox->createWidget<MyGUI::Button> ("ButtonImage", MyGUI::IntCoord(0, curH, 128, 64), MyGUI::Align::Default);
+        mCredits->setImageResource ("Menu_Credits");
+        curH += 64;
+        */
+
+        mExitGame = mButtonBox->createWidget<MyGUI::Button> ("ButtonImage", MyGUI::IntCoord(0, curH, 128, 64), MyGUI::Align::Default);
+        mExitGame->setImageResource ("Menu_ExitGame");
+        mExitGame->eventMouseButtonClick += MyGUI::newDelegate(this, &MainMenu::exitGame);
+        curH += 64;
+
+    }
+
+    void MainMenu::returnToGame(MyGUI::Widget* sender)
+    {
+        MWBase::Environment::get().getWindowManager ()->removeGuiMode (GM_MainMenu);
+    }
+
+    void MainMenu::showOptions(MyGUI::Widget* sender)
+    {
+        MWBase::Environment::get().getWindowManager ()->pushGuiMode (GM_Settings);
+    }
+
+    void MainMenu::exitGame(MyGUI::Widget* sender)
+    {
+        Ogre::Root::getSingleton ().queueEndRendering ();
+    }
+
+}

apps/openmw/mwgui/mainmenu.hpp

@@ -6,11 +6,22 @@ namespace MWGui
     class MainMenu : public OEngine::GUI::Layout
     {
     public:
-        MainMenu(int w, int h)
+        MainMenu(int w, int h);
-        : Layout("openmw_mainmenu.layout")
+
-        {
+    private:
-            setCoord(0,0,w,h);
+        MyGUI::Button* mReturn;
-        }
+        MyGUI::Button* mNewGame;
+        MyGUI::Button* mLoadGame;
+        MyGUI::Button* mSaveGame;
+        MyGUI::Button* mOptions;
+        MyGUI::Button* mCredits;
+        MyGUI::Button* mExitGame;
+
+        MyGUI::Widget* mButtonBox;
+
+        void returnToGame(MyGUI::Widget* sender);
+        void showOptions(MyGUI::Widget* sender);
+        void exitGame(MyGUI::Widget* sender);
     };
 
 }

apps/openmw/mwgui/scrollwindow.cpp

@@ -2,10 +2,12 @@
 
 #include "../mwbase/environment.hpp"
 #include "../mwbase/world.hpp"
+#include "../mwbase/soundmanager.hpp"
+
 #include "../mwinput/inputmanager.hpp"
+
 #include "../mwworld/actiontake.hpp"
 #include "../mwworld/player.hpp"
-#include "../mwsound/soundmanager.hpp"
 
 #include "formatting.hpp"
 #include "window_manager.hpp"
@@ -62,7 +64,7 @@ void ScrollWindow::onCloseButtonClicked (MyGUI::Widget* _sender)
 
 void ScrollWindow::onTakeButtonClicked (MyGUI::Widget* _sender)
 {
-    MWBase::Environment::get().getSoundManager()->playSound ("Item Book Up", 1.0, 1.0, MWSound::Play_NoTrack);
+    MWBase::Environment::get().getSoundManager()->playSound ("Item Book Up", 1.0, 1.0, MWBase::SoundManager::Play_NoTrack);
 
     MWWorld::ActionTake take(mScroll);
     take.execute (MWBase::Environment::get().getWorld()->getPlayer().getPlayer());

apps/openmw/mwgui/settingswindow.cpp

@@ -12,11 +12,10 @@
 
 #include "../mwbase/environment.hpp"
 #include "../mwbase/world.hpp"
+#include "../mwbase/soundmanager.hpp"
 
 #include "../mwrender/renderingmanager.hpp"
 
-#include "../mwsound/soundmanager.hpp"
-
 #include "../mwinput/inputmanager.hpp"
 
 #include "window_manager.hpp"
@@ -264,6 +263,7 @@ namespace MWGui
         dialog->eventOkClicked.clear();
         dialog->eventOkClicked += MyGUI::newDelegate(this, &SettingsWindow::onResolutionAccept);
         dialog->eventCancelClicked.clear();
+        dialog->eventCancelClicked += MyGUI::newDelegate(this, &SettingsWindow::onResolutionCancel);
     }
 
     void SettingsWindow::onResolutionAccept()

apps/openmw/mwgui/spellwindow.cpp

@@ -8,6 +8,7 @@
 
 #include "../mwbase/world.hpp"
 #include "../mwbase/environment.hpp"
+#include "../mwbase/soundmanager.hpp"
 
 #include "../mwworld/player.hpp"
 #include "../mwworld/inventorystore.hpp"
@@ -16,8 +17,6 @@
 #include "../mwmechanics/creaturestats.hpp"
 #include "../mwmechanics/spellsuccess.hpp"
 
-#include "../mwsound/soundmanager.hpp"
-
 #include "window_manager.hpp"
 #include "inventorywindow.hpp"
 #include "confirmationdialog.hpp"

apps/openmw/mwgui/tradewindow.cpp

@@ -4,10 +4,10 @@
 
 #include "../mwbase/environment.hpp"
 #include "../mwbase/world.hpp"
+#include "../mwbase/soundmanager.hpp"
 
 #include "../mwworld/inventorystore.hpp"
 #include "../mwworld/manualref.hpp"
-#include "../mwsound/soundmanager.hpp"
 
 #include "window_manager.hpp"
 #include "inventorywindow.hpp"

apps/openmw/mwinput/inputmanager.cpp

@@ -1,12 +1,12 @@
 #include "inputmanager.hpp"
 
+#include <OgreRoot.h>
+
 #include <openengine/input/dispatcher.hpp>
 #include <openengine/input/poller.hpp>
 
 #include <openengine/gui/events.hpp>
 
-#include <openengine/ogre/exitlistener.hpp>
-#include <openengine/ogre/mouselook.hpp>
 #include <openengine/ogre/renderer.hpp>
 
 #include "../mwgui/window_manager.hpp"
@@ -16,11 +16,12 @@
 
 #include <libs/platform/strings.h>
 
+#include "mouselookevent.hpp"
+
 #include "../engine.hpp"
 
 #include "../mwworld/player.hpp"
-
+#include "../mwbase/world.hpp"
-#include "../mwrender/player.hpp"
 
 #include <boost/bind.hpp>
 #include <boost/filesystem.hpp>
@@ -69,8 +70,6 @@ namespace MWInput
       A_ToggleWeapon,
       A_ToggleSpell,
 
-      A_Settings, // Temporary hotkey
-
       A_LAST            // Marker for the last item
     };
 
@@ -79,10 +78,9 @@ namespace MWInput
   {
     OEngine::Input::DispatcherPtr disp;
     OEngine::Render::OgreRenderer &ogre;
-    OEngine::Render::ExitListener exit;
     Mangle::Input::OISDriver input;
     OEngine::Input::Poller poller;
-    OEngine::Render::MouseLookEventPtr mouse;
+    MouseLookEventPtr mouse;
     OEngine::GUI::EventInjectorPtr guiEvents;
     MWWorld::Player &player;
     MWGui::WindowManager &windows;
@@ -90,6 +88,7 @@ namespace MWInput
 
     bool mDragDrop;
 
+    std::map<std::string, bool> mControlSwitch;
 
    /* InputImpl Methods */
 public:
@@ -140,15 +139,6 @@ private:
         windows.messageBox ("Screenshot saved", empty);
     }
 
-    void showSettings()
-    {
-        if (mDragDrop)
-            return;
-
-        if (!windows.isGuiMode() || windows.getMode() != MWGui::GM_Settings)
-            windows.pushGuiMode(MWGui::GM_Settings);
-    }
-
     /* toggleInventory() is called when the user presses the button to toggle the inventory screen. */
     void toggleInventory()
     {
@@ -222,11 +212,19 @@ private:
         player.toggleRunning();
     }
 
+    void toggleMainMenu()
+    {
+        if (windows.isGuiMode () && windows.getMode () == MWGui::GM_MainMenu)
+            windows.removeGuiMode (MWGui::GM_MainMenu);
+        else
+            windows.pushGuiMode (MWGui::GM_MainMenu);
+    }
+
     // Exit program now button (which is disabled in GUI mode)
     void exitNow()
     {
         if(!windows.isGuiMode())
-            exit.exitNow();
+            Ogre::Root::getSingleton().queueEndRendering ();
     }
 
   public:
@@ -236,7 +234,6 @@ private:
                    bool debug,
                    OMW::Engine& engine)
       : ogre(_ogre),
-        exit(ogre.getWindow()),
         input(ogre.getWindow(), !debug),
         poller(input),
         player(_player),
@@ -273,13 +270,10 @@ private:
                       "Draw Weapon");
       disp->funcs.bind(A_ToggleSpell,boost::bind(&InputImpl::toggleSpell,this),
                       "Ready hands");
-      disp->funcs.bind(A_Settings, boost::bind(&InputImpl::showSettings, this),
+      disp->funcs.bind(A_GameMenu, boost::bind(&InputImpl::toggleMainMenu, this),
-                      "Show settings window");
+                      "Toggle main menu");
-      // Add the exit listener
-      ogre.getRoot()->addFrameListener(&exit);
 
-      // Set up the mouse handler and tell it about the player camera
+      mouse = MouseLookEventPtr(new MouseLookEvent());
-      mouse = MouseLookEventPtr(new MouseLookEvent(player.getRenderer()->getCamera()));
 
       // This event handler pumps events into MyGUI
       guiEvents = EventInjectorPtr(new EventInjector(windows.getGui()));
@@ -296,6 +290,14 @@ private:
         lst->add(guiEvents,Event::EV_ALL);
       }
 
+      mControlSwitch["playercontrols"]      = true;
+      mControlSwitch["playerfighting"]      = true;
+      mControlSwitch["playerjumping"]       = true;
+      mControlSwitch["playerlooking"]       = true;
+      mControlSwitch["playermagic"]         = true;
+      mControlSwitch["playerviewswitch"]    = true;
+      mControlSwitch["vanitymode"]          = true;
+
       changeInputMode(false);
 
       /**********************************
@@ -309,7 +311,7 @@ private:
       // NOTE: These keys do not require constant polling - use in conjuction with variables in loops.
 
       disp->bind(A_Quit, KC_Q);
-      disp->bind(A_Quit, KC_ESCAPE);
+      disp->bind(A_GameMenu, KC_ESCAPE);
       disp->bind(A_Screenshot, KC_SYSRQ);
       disp->bind(A_Inventory, KC_I);
       disp->bind(A_Console, KC_F1);
@@ -320,7 +322,6 @@ private:
       disp->bind(A_ToggleWalk, KC_C);
       disp->bind(A_ToggleWeapon,KC_F);
       disp->bind(A_ToggleSpell,KC_R);
-      disp->bind(A_Settings, KC_F2);
 
       // Key bindings for polled keys
       // NOTE: These keys are constantly being polled. Only add keys that must be checked each frame.
@@ -366,6 +367,7 @@ private:
 
         // Configure player movement according to keyboard input. Actual movement will
         // be done in the physics system.
+        if (mControlSwitch["playercontrols"]) {
             if (poller.isDown(A_MoveLeft))
             {
                 player.setAutoMove (false);
@@ -392,13 +394,14 @@ private:
             else
                 player.setForwardBackward (0);
 
-        if (poller.isDown(A_Jump))
+            if (poller.isDown(A_Jump) && mControlSwitch["playerjumping"])
                 player.setUpDown (1);
             else if (poller.isDown(A_Crouch))
                 player.setUpDown (-1);
             else
                 player.setUpDown (0);
         }
+    }
 
     // Switch between gui modes. Besides controlling the Gui windows
     // this also makes sure input is directed to the right place
@@ -408,21 +411,47 @@ private:
       if(guiMode)
         {
           // Disable mouse look
-          mouse->setCamera(NULL);
+          mouse->disable();
 
           // Enable GUI events
           guiEvents->enabled = true;
         }
       else
         {
-          // Start mouse-looking again. TODO: This should also allow
+            // Start mouse-looking again if allowed.
-          // for other ways to disable mouselook, like paralyzation.
+            if (mControlSwitch["playerlooking"]) {
-          mouse->setCamera(player.getRenderer()->getCamera());
+                mouse->enable();
+            }
 
           // Disable GUI events
           guiEvents->enabled = false;
         }
     }
+
+    void toggleControlSwitch(std::string sw, bool value)
+    {
+        if (mControlSwitch[sw] == value) {
+            return;
+        }
+        /// \note 7 switches at all, if-else is relevant
+        if (sw == "playercontrols" && !value) {
+            player.setLeftRight(0);
+            player.setForwardBackward(0);
+            player.setAutoMove(false);
+            player.setUpDown(0);
+        } else if (sw == "playerjumping" && !value) {
+            /// \fixme maybe crouching at this time
+            player.setUpDown(0);
+        } else if (sw == "playerlooking") {
+            if (value) {
+                mouse->enable();
+            } else {
+                mouse->disable();
+            }
+        }
+        mControlSwitch[sw] = value;
+    }
+
   };
 
   /***CONSTRUCTOR***/
@@ -471,4 +500,9 @@ private:
       if (changeRes)
           impl->adjustMouseRegion(Settings::Manager::getInt("resolution x", "Video"), Settings::Manager::getInt("resolution y", "Video"));
   }
+
+    void MWInputManager::toggleControlSwitch(std::string sw, bool value)
+    {
+        impl->toggleControlSwitch(sw, value); 
+    }
 }

apps/openmw/mwinput/inputmanager.hpp

@@ -57,6 +57,8 @@ namespace MWInput
     void processChangedSettings(const Settings::CategorySettingVector& changed);
 
     void setDragDrop(bool dragDrop);
+
+    void toggleControlSwitch(std::string sw, bool value);
   };
 }
 #endif

apps/openmw/mwinput/mouselookevent.cpp

@@ -0,0 +1,28 @@
+#include "mouselookevent.hpp"
+
+#include "../mwbase/environment.hpp"
+#include "../mwbase/world.hpp"
+
+#include "../mwworld/player.hpp"
+
+#include <OIS/OIS.h>
+#include <OgreCamera.h>
+#include <OgreSceneNode.h>
+
+using namespace OIS;
+using namespace MWInput;
+
+void MouseLookEvent::event(Type type, int index, const void *p)
+{
+    if (type != EV_MouseMove || mDisabled) {
+        return;
+    }
+
+    MouseEvent *arg = (MouseEvent*)(p);
+
+    float x = arg->state.X.rel * sensX;
+    float y = arg->state.Y.rel * sensY;
+
+    MWBase::World *world = MWBase::Environment::get().getWorld();
+    world->rotateObject(world->getPlayer().getPlayer(), -y, 0.f, x, true);
+}

apps/openmw/mwinput/mouselookevent.hpp

@@ -0,0 +1,57 @@
+#ifndef _MWINPUT_MOUSELOOKEVENT_H
+#define _MWINPUT_MOUSELOOKEVENT_H
+
+/*
+  A mouse-look class for Ogre. Accepts input events from Mangle::Input
+  and translates them.
+
+  You can adjust the mouse sensibility and switch to a different
+  camera. The mouselook class also has an optional wrap protection
+  that keeps the camera from flipping upside down.
+
+  You can disable the mouse looker at any time by calling
+  setCamera(NULL), and reenable it by setting the camera back.
+
+  NOTE: The current implementation will ONLY work for native OIS
+  events.
+ */
+
+#include <mangle/input/event.hpp>
+
+namespace MWInput
+{
+    class MouseLookEvent : public Mangle::Input::Event
+    {
+        float sensX, sensY; // Mouse sensibility
+        bool flipProt;      // Flip protection
+        bool mDisabled;
+
+    public:
+        MouseLookEvent(float sX = 0.2, float sY = 0.2, bool prot=true)
+          : sensX(sX), sensY(sY), flipProt(prot)
+        {}
+
+        void setSens(float sX, float sY) {
+            sensX = sX;
+            sensY = sY;
+        }
+
+        void setProt(bool p) {
+            flipProt = p;
+        }
+
+        void disable() {
+            mDisabled = true;
+        }
+
+        void enable() {
+            mDisabled = false;
+        }
+
+        void event(Type type, int index, const void *p);
+  };
+
+  typedef boost::shared_ptr<MouseLookEvent> MouseLookEventPtr;
+}
+
+#endif

apps/openmw/mwrender/actors.cpp

@@ -132,3 +132,25 @@ void Actors::update (float duration){
     for(std::map<MWWorld::Ptr, Animation*>::iterator iter = mAllActors.begin(); iter != mAllActors.end(); iter++)
         iter->second->runAnimation(duration);
 }
+
+void
+Actors::updateObjectCell(const MWWorld::Ptr &ptr)
+{
+    Ogre::SceneNode *node;
+    MWWorld::CellStore *newCell = ptr.getCell();
+
+    if(mCellSceneNodes.find(newCell) == mCellSceneNodes.end()) {
+        node = mMwRoot->createChildSceneNode();
+        mCellSceneNodes[newCell] = node;
+    } else {
+        node = mCellSceneNodes[newCell];
+    }
+    node->addChild(ptr.getRefData().getBaseNode());
+    if (mAllActors.find(ptr) != mAllActors.end()) {
+        /// \note Update key (Ptr's are compared only with refdata so mCell
+        /// on key is outdated), maybe redundant
+        Animation *anim = mAllActors[ptr];
+        mAllActors.erase(ptr);
+        mAllActors[ptr] = anim;
+    }
+}

apps/openmw/mwrender/actors.hpp

@@ -45,6 +45,8 @@ namespace MWRender{
 
         void update (float duration);
 
+        /// Updates containing cell for object rendering data
+        void updateObjectCell(const MWWorld::Ptr &ptr);
     };
 }
 #endif

apps/openmw/mwrender/objects.cpp

@@ -11,6 +11,7 @@
 #include <components/settings/settings.hpp>
 
 #include "../mwworld/ptr.hpp"
+#include "../mwworld/class.hpp"
 
 #include "renderconst.hpp"
 
@@ -474,3 +475,23 @@ void Objects::rebuildStaticGeometry()
         it->second->build();
     }
 }
+
+void
+Objects::updateObjectCell(const MWWorld::Ptr &ptr)
+{
+    Ogre::SceneNode *node;
+    MWWorld::CellStore *newCell = ptr.getCell();
+
+    if(mCellSceneNodes.find(newCell) == mCellSceneNodes.end()) {
+        node = mMwRoot->createChildSceneNode();
+        mCellSceneNodes[newCell] = node;
+    } else {
+        node = mCellSceneNodes[newCell];
+    }
+    node->addChild(ptr.getRefData().getBaseNode());
+
+    /// \note Still unaware how to move aabb and static w/o full rebuild,
+    /// moving static objects may cause problems
+    insertMesh(ptr, MWWorld::Class::get(ptr).getModel(ptr));
+}
+

apps/openmw/mwrender/objects.hpp

@@ -95,6 +95,9 @@ public:
     void setMwRoot(Ogre::SceneNode* root);
 
     void rebuildStaticGeometry();
+
+    /// Updates containing cell for object rendering data
+    void updateObjectCell(const MWWorld::Ptr &ptr);
 };
 }
 #endif

apps/openmw/mwrender/player.cpp

@@ -1,15 +1,24 @@
-
 #include "player.hpp"
 
 #include <OgreSceneNode.h>
+#include <OgreCamera.h>
+
+#include "../mwbase/environment.hpp"
+#include "../mwbase/soundmanager.hpp"
+
+#include "../mwworld/ptr.hpp"
+#include "../mwworld/refdata.hpp"
 
 namespace MWRender
 {
     Player::Player (Ogre::Camera *camera, Ogre::SceneNode* node)
-    : mCamera (camera), mNode (node)
+    : mCamera (camera),
+      mNode (node),
+      mFirstPersonView(true),
+      mVanityModeEnabled(false)
     {}
 
-    void Player::setRot(float x, float y, float z)
+    bool Player::setRotation(const Ogre::Vector3 &rot)
     {
         Ogre::SceneNode *sceneNode = mNode;
         Ogre::Node* yawNode = sceneNode->getChildIterator().getNext();
@@ -18,17 +27,75 @@ namespace MWRender
         // we are only interested in X and Y rotation
 
         // Rotate around X axis
-            Ogre::Quaternion xr(Ogre::Radian(x), Ogre::Vector3::UNIT_X);
+        Ogre::Quaternion xr(Ogre::Radian(rot.x), Ogre::Vector3::UNIT_X);
 
         // Rotate around Y axis
-            Ogre::Quaternion yr(Ogre::Radian(-z), Ogre::Vector3::UNIT_Y);
+        Ogre::Quaternion yr(Ogre::Radian(-rot.z), Ogre::Vector3::UNIT_Y);
 
         pitchNode->setOrientation(xr);
         yawNode->setOrientation(yr);
+
+        controlFlip();
+        updateListener();
+
+        return !mVanityModeEnabled;
     }
 
     std::string Player::getHandle() const
     {
         return mNode->getName();
     }
+
+    void Player::attachTo(const MWWorld::Ptr &ptr)
+    {
+        ptr.getRefData().setBaseNode(mNode);
+    }
+
+    bool Player::adjustRotation(const Ogre::Vector3 &rot)
+    {
+        Ogre::SceneNode *pitchNode = mCamera->getParentSceneNode();
+        Ogre::SceneNode *yawNode = pitchNode->getParentSceneNode();
+
+        pitchNode->pitch(Ogre::Radian(rot.x));
+        yawNode->yaw(Ogre::Radian(-rot.z));
+
+        controlFlip();
+        updateListener();
+
+        return !mVanityModeEnabled;
+    }
+
+    void Player::controlFlip()
+    {
+        Ogre::SceneNode *pitchNode = mCamera->getParentSceneNode();
+        Ogre::Quaternion orient = pitchNode->getOrientation();
+
+        float pitchAngle =
+            (2 * Ogre::Degree(Ogre::Math::ACos(orient.w)).valueDegrees());
+
+        // Limit the pitch between -90 degress and +90 degrees, Quake3-style.
+        if (pitchAngle > 90.0f)
+        {
+            Ogre::Real sqrt = Ogre::Math::Sqrt(0.5f);
+            if (orient.x > 0) {
+                // Set orientation to 90 degrees on X-axis.
+                pitchNode->setOrientation(Ogre::Quaternion(sqrt, sqrt, 0, 0));
+            } else if (orient.x < 0) {
+                // Sets orientation to -90 degrees on X-axis.
+                pitchNode->setOrientation(Ogre::Quaternion(sqrt, -sqrt, 0, 0));
+            }
+        }
+    }
+
+    void Player::updateListener()
+    {
+        Ogre::Vector3 pos = mCamera->getRealPosition();
+        Ogre::Vector3 dir = mCamera->getRealDirection();
+
+        Ogre::Real xch;
+        xch = pos.y, pos.y = -pos.z, pos.z = xch;
+        xch = dir.y, dir.y = -dir.z, dir.z = xch;
+
+        MWBase::Environment::get().getSoundManager()->setListenerPosDir(pos, dir);
+    }
 }

apps/openmw/mwrender/player.hpp

@@ -3,12 +3,19 @@
 
 #include <string>
 
+
 namespace Ogre
 {   
+    class Vector3;
     class Camera;
     class SceneNode;
 }
 
+namespace MWWorld
+{
+    class Ptr;
+}
+
 namespace MWRender
 {
     /// \brief Player character rendering and camera control
@@ -17,17 +24,41 @@ namespace MWRender
         Ogre::Camera *mCamera;
         Ogre::SceneNode* mNode;
 
+        bool mFirstPersonView;
+        bool mVanityModeEnabled;
+
+        void controlFlip();
+
+        /// Updates sound manager listener data
+        void updateListener();
+
     public:
 
         Player (Ogre::Camera *camera, Ogre::SceneNode* mNode);
 
-                Ogre::Camera *getCamera() { return mCamera; }
-
         /// Set where the player is looking at. Uses Morrowind (euler) angles
-                void setRot(float x, float y, float z);
+        /// \param rot Rotation angles in radians
+        /// \return true if player object needs to bo rotated physically
+        bool setRotation(const Ogre::Vector3 &rot);
+
+        /// \param rot Rotation angles in radians
+        /// \return true if player object needs to bo rotated physically
+        bool adjustRotation(const Ogre::Vector3 &rot);
 
         std::string getHandle() const;
-                Ogre::SceneNode* getNode() {return mNode;}
+
+        /// Attach camera to object
+        /// \note there is no protection from attaching the same camera to
+        /// several different objects
+        void attachTo(const MWWorld::Ptr &);
+
+        void toggleViewMode() {
+            mFirstPersonView = !mFirstPersonView;
+        }
+
+        void toggleVanityMode() {
+            mVanityModeEnabled = !mVanityModeEnabled;
+        }
     };
 }
 

apps/openmw/mwrender/renderinginterface.hpp

@@ -1,14 +1,15 @@
 #ifndef _GAME_RENDERING_INTERFACE_H
 #define _GAME_RENDERING_INTERFACE_H
-namespace MWRender{
+
+namespace MWRender
+{
     class Objects;
     class Actors;
-      class Player;
       
-class RenderingInterface{
+    class RenderingInterface
+    {
     public:
         virtual MWRender::Objects& getObjects() = 0;
-	    virtual MWRender::Player& getPlayer() = 0;
         virtual MWRender::Actors& getActors() = 0;
         virtual ~RenderingInterface(){};
     };

apps/openmw/mwrender/renderingmanager.cpp

@@ -183,10 +183,6 @@ MWRender::Actors& RenderingManager::getActors(){
     return mActors;
 }
 
-MWRender::Player& RenderingManager::getPlayer(){
-    return (*mPlayer);
-}
-
 OEngine::Render::Fader* RenderingManager::getFader()
 {
     return mRendering.getFader();
@@ -251,11 +247,58 @@ void RenderingManager::moveObject (const MWWorld::Ptr& ptr, const Ogre::Vector3&
 void RenderingManager::scaleObject (const MWWorld::Ptr& ptr, const Ogre::Vector3& scale){
 
 }
-void RenderingManager::rotateObject (const MWWorld::Ptr& ptr, const::Ogre::Quaternion& orientation){
 
+bool
+RenderingManager::rotateObject(
+    const MWWorld::Ptr &ptr,
+    Ogre::Vector3 &rot,
+    bool adjust)
+{
+    bool isPlayer = ptr.getRefData().getHandle() == "player";
+    bool force = true;
+    
+    if (isPlayer) {
+        if (adjust) {
+            force = mPlayer->adjustRotation(rot);
+        } else {
+            force = mPlayer->setRotation(rot);
         }
-void RenderingManager::moveObjectToCell (const MWWorld::Ptr& ptr, const Ogre::Vector3& position, MWWorld::Ptr::CellStore *store){
+    }
+    MWWorld::Class::get(ptr).adjustRotation(ptr, rot.x, rot.y, rot.z);
 
+    if (adjust) {
+        /// \note Stored and passed in radians
+        float *f = ptr.getRefData().getPosition().rot;
+        rot.x += f[0], rot.y += f[1], rot.z += f[2];
+    }
+    if (!isPlayer) {
+        Ogre::Quaternion xr(Ogre::Radian(rot.x), Ogre::Vector3::UNIT_X);
+        Ogre::Quaternion yr(Ogre::Radian(rot.y), Ogre::Vector3::UNIT_Y);
+        Ogre::Quaternion zr(Ogre::Radian(rot.z), Ogre::Vector3::UNIT_Z);
+
+        ptr.getRefData().getBaseNode()->setOrientation(xr * yr * zr);
+    }
+    return force;
+}
+
+void
+RenderingManager::moveObjectToCell(
+    const MWWorld::Ptr& ptr,
+    const Ogre::Vector3& pos,
+    MWWorld::CellStore *store)
+{
+    Ogre::SceneNode *child =
+        mRendering.getScene()->getSceneNode(ptr.getRefData().getHandle());
+
+    Ogre::SceneNode *parent = child->getParentSceneNode();
+    parent->removeChild(child);
+
+    if (MWWorld::Class::get(ptr).isActor()) {
+        mActors.updateObjectCell(ptr);
+    } else {
+        mObjects.updateObjectCell(ptr);
+    }
+    child->setPosition(pos);
 }
 
 void RenderingManager::update (float duration){
@@ -273,11 +316,20 @@ void RenderingManager::update (float duration){
 
     mLocalMap->updatePlayer( mRendering.getCamera()->getRealPosition(), mRendering.getCamera()->getRealOrientation() );
 
-    checkUnderwater();
+    if (mWater) {
+        Ogre::Vector3 cam = mRendering.getCamera()->getRealPosition();
 
-    if (mWater)
+        MWBase::World *world = MWBase::Environment::get().getWorld();
+
+        mWater->updateUnderwater(
+            world->isUnderwater(
+                *world->getPlayer().getPlayer().getCell()->cell,
+                Ogre::Vector3(cam.x, -cam.z, cam.y))
+        );
         mWater->update(duration);
     }
+}
+
 void RenderingManager::waterAdded (MWWorld::Ptr::CellStore *store){
     if(store->cell->data.flags & store->cell->HasWater
         || ((!(store->cell->data.flags & ESM::Cell::Interior))
@@ -457,13 +509,6 @@ void RenderingManager::toggleLight()
 
     setAmbientMode();
 }
-void RenderingManager::checkUnderwater()
-{
-    if(mWater)
-    {
-         mWater->checkUnderwater( mRendering.getCamera()->getRealPosition().y );
-    }
-}
 
 void RenderingManager::playAnimationGroup (const MWWorld::Ptr& ptr, const std::string& groupName,
      int mode, int number)
@@ -768,4 +813,9 @@ void RenderingManager::getTriangleBatchCount(unsigned int &triangles, unsigned i
     }
 }
 
+void RenderingManager::attachCameraTo(const MWWorld::Ptr &ptr)
+{
+    mPlayer->attachTo(ptr);
+}
+
 } // namespace

apps/openmw/mwrender/renderingmanager.hpp

@@ -56,11 +56,7 @@ class RenderingManager: private RenderingInterface, public Ogre::WindowEventList
     RenderingManager(OEngine::Render::OgreRenderer& _rend, const boost::filesystem::path& resDir, OEngine::Physic::PhysicEngine* engine);
     virtual ~RenderingManager();
 
-
+    void attachCameraTo(const MWWorld::Ptr &ptr);
-
-    virtual MWRender::Player& getPlayer(); /// \todo move this to private again as soon as
-                                            /// MWWorld::Player has been rewritten to not need access
-                                            /// to internal details of the rendering system anymore
 
     SkyManager* getSkyManager();
     Compositors* getCompositors();
@@ -89,12 +85,17 @@ class RenderingManager: private RenderingInterface, public Ogre::WindowEventList
 
     void moveObject (const MWWorld::Ptr& ptr, const Ogre::Vector3& position);
     void scaleObject (const MWWorld::Ptr& ptr, const Ogre::Vector3& scale);
-    void rotateObject (const MWWorld::Ptr& ptr, const::Ogre::Quaternion& orientation);
 
-    void checkUnderwater();
+    /// Rotates object accordingly to its type
+    /// \param rot euler angles in radians
+    /// \param adjust indicates should rotation be set or adjusted
+    /// \return true if object needs to be rotated physically
+    bool rotateObject (const MWWorld::Ptr& ptr, Ogre::Vector3 &rot, bool adjust = false);
+
     void setWaterHeight(const float height);
     void toggleWater();
 
+    /// Moves object rendering part to proper container
     /// \param store Cell the object was in previously (\a ptr has already been updated to the new cell).
     void moveObjectToCell (const MWWorld::Ptr& ptr, const Ogre::Vector3& position, MWWorld::CellStore *store);
 

apps/openmw/mwrender/terrainmaterial.cpp

@@ -2,6 +2,8 @@
 
 #include <OgreTerrain.h>
 
+#include <stdexcept>
+
 #include <extern/shiny/Main/Factory.hpp>
 
 namespace
@@ -86,15 +88,15 @@ namespace MWRender
         normalMap->setProperty ("direct_texture", sh::makeProperty<sh::StringValue> (new sh::StringValue(terrain->getTerrainNormalMap ()->getName())));
         normalMap->setProperty ("tex_address_mode", sh::makeProperty<sh::StringValue> (new sh::StringValue("clamp")));
 
-        uint maxLayers = getMaxLayers(terrain);
+        Ogre::uint maxLayers = getMaxLayers(terrain);
-        uint numBlendTextures = std::min(terrain->getBlendTextureCount(maxLayers), terrain->getBlendTextureCount());
+        Ogre::uint numBlendTextures = std::min(terrain->getBlendTextureCount(maxLayers), terrain->getBlendTextureCount());
-        uint numLayers = std::min(maxLayers, static_cast<uint>(terrain->getLayerCount()));
+        Ogre::uint numLayers = std::min(maxLayers, static_cast<Ogre::uint>(terrain->getLayerCount()));
 
         p->mShaderProperties.setProperty ("num_layers", sh::makeProperty<sh::StringValue>(new sh::StringValue(Ogre::StringConverter::toString(numLayers))));
         p->mShaderProperties.setProperty ("num_blendmaps", sh::makeProperty<sh::StringValue>(new sh::StringValue(Ogre::StringConverter::toString(numBlendTextures))));
 
         // blend maps
-        for (uint i = 0; i < numBlendTextures; ++i)
+        for (Ogre::uint i = 0; i < numBlendTextures; ++i)
         {
             sh::MaterialInstanceTextureUnit* blendTex = p->createTextureUnit ("blendMap" + Ogre::StringConverter::toString(i));
             blendTex->setProperty ("direct_texture", sh::makeProperty<sh::StringValue> (new sh::StringValue(terrain->getBlendTextureName(i))));
@@ -102,7 +104,7 @@ namespace MWRender
         }
 
         // layer maps
-        for (uint i = 0; i < numLayers; ++i)
+        for (Ogre::uint i = 0; i < numLayers; ++i)
         {
             sh::MaterialInstanceTextureUnit* diffuseTex = p->createTextureUnit ("diffuseMap" + Ogre::StringConverter::toString(i));
             diffuseTex->setProperty ("direct_texture", sh::makeProperty<sh::StringValue> (new sh::StringValue(terrain->getLayerTextureName(i, 0))));
@@ -111,7 +113,7 @@ namespace MWRender
         }
 
         // shadow
-        for (uint i = 0; i < 3; ++i)
+        for (Ogre::uint i = 0; i < 3; ++i)
         {
             sh::MaterialInstanceTextureUnit* shadowTex = p->createTextureUnit ("shadowMap" + Ogre::StringConverter::toString(i));
             shadowTex->setProperty ("content_type", sh::makeProperty<sh::StringValue> (new sh::StringValue("shadow")));

apps/openmw/mwrender/water.cpp

@@ -184,22 +184,16 @@ void Water::toggle()
     updateVisible();
 }
 
-void Water::checkUnderwater(float y)
+void
-{
+Water::updateUnderwater(bool underwater)
-    if (!mActive)
 {
+    if (!mActive) {
         return;
     }
-
+    mIsUnderwater =
-    if ((mIsUnderwater && y > mTop) || !mWater->isVisible() || mCamera->getPolygonMode() != Ogre::PM_SOLID)
+        underwater &&
-    {
+        mWater->isVisible() &&
-        mIsUnderwater = false;
+        mCamera->getPolygonMode() == Ogre::PM_SOLID;
-    }
-
-    if (!mIsUnderwater && y < mTop && mWater->isVisible() && mCamera->getPolygonMode() == Ogre::PM_SOLID)
-    {
-        mIsUnderwater = true;
-    }
 
     updateVisible();
 }

apps/openmw/mwrender/water.hpp

@@ -101,7 +101,8 @@ namespace MWRender {
 
         void processChangedSettings(const Settings::CategorySettingVector& settings);
 
-        void checkUnderwater(float y);
+        /// Updates underwater state accordingly
+        void updateUnderwater(bool underwater);
         void changeCell(const ESM::Cell* cell);
         void setHeight(const float height);
 

apps/openmw/mwscript/compilercontext.cpp

@@ -3,14 +3,15 @@
 
 #include <components/esm_store/store.hpp>
 
+#include <components/compiler/locals.hpp>
+
 #include "../mwbase/environment.hpp"
 #include "../mwbase/world.hpp"
+#include "../mwbase/scriptmanager.hpp"
 
 #include "../mwworld/ptr.hpp"
 #include "../mwworld/class.hpp"
 
-#include "scriptmanager.hpp"
-
 namespace MWScript
 {
     CompilerContext::CompilerContext (Type type)

apps/openmw/mwscript/controlextensions.cpp

@@ -14,6 +14,8 @@
 
 #include "../mwmechanics/npcstats.hpp"
 
+#include "../mwinput/inputmanager.hpp"
+
 #include "interpretercontext.hpp"
 #include "ref.hpp"
 
@@ -36,6 +38,10 @@ namespace MWScript
 
                 virtual void execute (Interpreter::Runtime& runtime)
                 {
+                    MWBase::Environment::get()
+                        .getInputManager()
+                        ->toggleControlSwitch(mControl, mEnable);
+
                     if (mEnable)
                         std::cout << "enable: " << mControl << std::endl;
                     else

apps/openmw/mwscript/dialogueextensions.cpp

@@ -7,8 +7,9 @@
 #include <components/interpreter/runtime.hpp>
 #include <components/interpreter/opcodes.hpp>
 
-#include "../mwdialogue/journal.hpp"
+#include "../mwbase/environment.hpp"
-#include "../mwdialogue/dialoguemanager.hpp"
+#include "../mwbase/dialoguemanager.hpp"
+#include "../mwbase/journal.hpp"
 
 #include "interpretercontext.hpp"
 #include "ref.hpp"
@@ -84,7 +85,7 @@ namespace MWScript
 
                 virtual void execute (Interpreter::Runtime& runtime, unsigned int arg0)
                 {
-                    MWDialogue::DialogueManager* dialogue = MWBase::Environment::get().getDialogueManager();
+                    MWBase::DialogueManager* dialogue = MWBase::Environment::get().getDialogueManager();
                     while(arg0>0)
                     {
                         std::string question = runtime.getStringLiteral (runtime[0].mInteger);

apps/openmw/mwscript/docs/vmformat.txt

@@ -179,4 +179,6 @@ op 0x200016e: user3, explicit reference (console only, requires --script-console
 op 0x200016f: user3 (implicit reference, console only, requires --script-console switch)
 op 0x2000170: user4, explicit reference (console only, requires --script-console switch)
 op 0x2000171: user4 (implicit reference, console only, requires --script-console switch)
-opcodes 0x2000172-0x3ffffff unused
+op 0x2000172: GetStartingAngle
+op 0x2000173: GetStartingAngle, explicit reference
+opcodes 0x2000174-0x3ffffff unused

apps/openmw/mwscript/globalscripts.cpp

@@ -6,13 +6,15 @@
 #include <components/esm_store/reclists.hpp>
 #include <components/esm_store/store.hpp>
 
+#include "../mwbase/environment.hpp"
+#include "../mwbase/scriptmanager.hpp"
+
 #include "interpretercontext.hpp"
-#include "scriptmanager.hpp"
 
 namespace MWScript
 {
-    GlobalScripts::GlobalScripts (const ESMS::ESMStore& store, ScriptManager& scriptManager)
+    GlobalScripts::GlobalScripts (const ESMS::ESMStore& store)
-    : mStore (store), mScriptManager (scriptManager)
+    : mStore (store)
     {
         addScript ("Main");
 
@@ -63,9 +65,8 @@ namespace MWScript
             {
                 MWScript::InterpreterContext interpreterContext (
                     &iter->second.second, MWWorld::Ptr());
-                mScriptManager.run (iter->first, interpreterContext);
+                MWBase::Environment::get().getScriptManager()->run (iter->first, interpreterContext);
             }
         }
-
     }
 }

apps/openmw/mwscript/globalscripts.hpp

@@ -13,17 +13,14 @@ namespace ESMS
 
 namespace MWScript
 {
-    class ScriptManager;
-
     class GlobalScripts
     {
             const ESMS::ESMStore& mStore;
-            ScriptManager& mScriptManager;
             std::map<std::string, std::pair<bool, Locals> > mScripts; // running, local variables
 
         public:
 
-            GlobalScripts (const ESMS::ESMStore& store, ScriptManager& scriptManager);
+            GlobalScripts (const ESMS::ESMStore& store);
 
             void addScript (const std::string& name);
 

apps/openmw/mwscript/interpretercontext.cpp

@@ -8,6 +8,7 @@
 
 #include "../mwbase/environment.hpp"
 #include "../mwbase/world.hpp"
+#include "../mwbase/scriptmanager.hpp"
 
 #include "../mwworld/class.hpp"
 #include "../mwworld/player.hpp"
@@ -18,7 +19,6 @@
 
 #include "locals.hpp"
 #include "globalscripts.hpp"
-#include "scriptmanager.hpp"
 
 namespace MWScript
 {

apps/openmw/mwscript/scriptmanagerimp.cpp

@@ -1,5 +1,5 @@
 
-#include "scriptmanager.hpp"
+#include "scriptmanagerimp.hpp"
 
 #include <cassert>
 #include <iostream>
@@ -21,7 +21,7 @@ namespace MWScript
         Compiler::Context& compilerContext)
     : mErrorHandler (std::cerr), mStore (store), mVerbose (verbose),
       mCompilerContext (compilerContext), mParser (mErrorHandler, mCompilerContext),
-      mOpcodesInstalled (false), mGlobalScripts (store, *this)
+      mOpcodesInstalled (false), mGlobalScripts (store)
     {}
 
     bool ScriptManager::compile (const std::string& name)

apps/openmw/mwscript/scriptmanagerimp.hpp

@@ -10,6 +10,8 @@
 #include <components/interpreter/interpreter.hpp>
 #include <components/interpreter/types.hpp>
 
+#include "../mwbase/scriptmanager.hpp"
+
 #include "globalscripts.hpp"
 
 namespace ESMS
@@ -30,7 +32,7 @@ namespace Interpreter
 
 namespace MWScript
 {
-    class ScriptManager
+    class ScriptManager : public MWBase::ScriptManager
     {
             Compiler::StreamErrorHandler mErrorHandler;
             const ESMS::ESMStore& mStore;
@@ -51,23 +53,24 @@ namespace MWScript
             ScriptManager (const ESMS::ESMStore& store, bool verbose,
                 Compiler::Context& compilerContext);
 
-            void run (const std::string& name, Interpreter::Context& interpreterContext);
+            virtual void run (const std::string& name, Interpreter::Context& interpreterContext);
             ///< Run the script with the given name (compile first, if not compiled yet)
 
-            bool compile (const std::string& name);
+            virtual bool compile (const std::string& name);
             ///< Compile script with the given namen
             /// \return Success?
 
-            std::pair<int, int> compileAll();
+            virtual std::pair<int, int> compileAll();
             ///< Compile all scripts
             /// \return count, success
 
-            Compiler::Locals& getLocals (const std::string& name);
+            virtual Compiler::Locals& getLocals (const std::string& name);
             ///< Return locals for script \a name.
 
-            GlobalScripts& getGlobalScripts();
+            virtual GlobalScripts& getGlobalScripts();
 
-            int getLocalIndex (const std::string& scriptId, const std::string& variable, char type);
+            virtual int getLocalIndex (const std::string& scriptId, const std::string& variable,
+                char type);
             ///< Return index of the variable of the given name and type in the given script. Will
             /// throw an exception, if there is no such script or variable or the type does not match.
     };

apps/openmw/mwscript/soundextensions.cpp

@@ -9,8 +9,7 @@
 
 #include "../mwbase/environment.hpp"
 #include "../mwbase/world.hpp"
-
+#include "../mwbase/soundmanager.hpp"
-#include "../mwsound/soundmanager.hpp"
 
 #include "interpretercontext.hpp"
 #include "ref.hpp"
@@ -116,7 +115,7 @@ namespace MWScript
                     std::string sound = runtime.getStringLiteral (runtime[0].mInteger);
                     runtime.pop();
 
-                    MWBase::Environment::get().getSoundManager()->playSound3D (ptr, sound, 1.0, 1.0, mLoop ? MWSound::Play_Loop : 0);
+                    MWBase::Environment::get().getSoundManager()->playSound3D (ptr, sound, 1.0, 1.0, mLoop ? MWBase::SoundManager::Play_Loop : 0);
                 }
         };
 
@@ -142,7 +141,7 @@ namespace MWScript
                     Interpreter::Type_Float pitch = runtime[0].mFloat;
                     runtime.pop();
 
-                    MWBase::Environment::get().getSoundManager()->playSound3D (ptr, sound, volume, pitch, mLoop ? MWSound::Play_Loop : 0);
+                    MWBase::Environment::get().getSoundManager()->playSound3D (ptr, sound, volume, pitch, mLoop ? MWBase::SoundManager::Play_Loop : 0);
 
                 }
         };

apps/openmw/mwscript/statsextensions.cpp

@@ -16,6 +16,7 @@
 #include <components/interpreter/opcodes.hpp>
 
 #include "../mwbase/environment.hpp"
+#include "../mwbase/dialoguemanager.hpp"
 
 #include "../mwworld/class.hpp"
 #include "../mwworld/player.hpp"
@@ -26,7 +27,6 @@
 #include "interpretercontext.hpp"
 #include "ref.hpp"
 
-#include "../mwdialogue/dialoguemanager.hpp"
 
 namespace MWScript
 {

apps/openmw/mwscript/transformationextensions.cpp

@@ -66,18 +66,49 @@ namespace MWScript
                     float ay = Ogre::Radian(ptr.getRefData().getPosition().rot[1]).valueDegrees();
                     float az = Ogre::Radian(ptr.getRefData().getPosition().rot[2]).valueDegrees();
 
-                    if(axis == "X")
+                    if (axis == "x")
                     {
                         MWBase::Environment::get().getWorld()->rotateObject(ptr,angle,ay,az);
                     }
-                    if(axis == "Y")
+                    else if (axis == "y")
                     {
                         MWBase::Environment::get().getWorld()->rotateObject(ptr,ax,angle,az);
                     }
-                    if(axis == "Z")
+                    else if (axis == "z")
                     {
                         MWBase::Environment::get().getWorld()->rotateObject(ptr,ax,ay,angle);
                     }
+                    else
+                        throw std::runtime_error ("invalid ration axis: " + axis);
+                }
+        };
+
+        template<class R>
+        class OpGetStartingAngle : public Interpreter::Opcode0
+        {
+            public:
+
+                virtual void execute (Interpreter::Runtime& runtime)
+                {
+                    MWWorld::Ptr ptr = R()(runtime);
+
+                    std::string axis = runtime.getStringLiteral (runtime[0].mInteger);
+                    runtime.pop();
+
+                    if (axis == "x")
+                    {
+                        runtime.push(Ogre::Radian(ptr.getRefData().getPosition().rot[0]).valueDegrees());
+                    }
+                    else if (axis == "y")
+                    {
+                        runtime.push(Ogre::Radian(ptr.getRefData().getPosition().rot[1]).valueDegrees());
+                    }
+                    else if (axis == "z")
+                    {
+                        runtime.push(Ogre::Radian(ptr.getRefData().getPosition().rot[2]).valueDegrees());
+                    }
+                    else
+                        throw std::runtime_error ("invalid ration axis: " + axis);
                 }
         };
 
@@ -93,18 +124,20 @@ namespace MWScript
                     std::string axis = runtime.getStringLiteral (runtime[0].mInteger);
                     runtime.pop();
 
-                    if(axis == "X")
+                    if (axis=="x")
                     {
-                        runtime.push(Ogre::Radian(ptr.getRefData().getPosition().rot[0]).valueDegrees());
+                        runtime.push(Ogre::Radian(ptr.getCellRef().pos.rot[0]).valueDegrees());
                     }
-                    if(axis == "Y")
+                    else if (axis=="y")
                     {
-                        runtime.push(Ogre::Radian(ptr.getRefData().getPosition().rot[1]).valueDegrees());
+                        runtime.push(Ogre::Radian(ptr.getCellRef().pos.rot[1]).valueDegrees());
                     }
-                    if(axis == "Z")
+                    else if (axis=="z")
                     {
-                        runtime.push(Ogre::Radian(ptr.getRefData().getPosition().rot[2]).valueDegrees());
+                        runtime.push(Ogre::Radian(ptr.getCellRef().pos.rot[2]).valueDegrees());
                     }
+                    else
+                        throw std::runtime_error ("invalid ration axis: " + axis);
                 }
         };
 
@@ -116,13 +149,16 @@ namespace MWScript
         const int opcodeGetScaleExplicit = 0x2000169;
         const int opcodeGetAngle = 0x200016a;
         const int opcodeGetAngleExplicit = 0x200016b;
+        const int opcodeGetStartingAngle = 0x2000172;
+        const int opcodeGetStartingAngleExplicit = 0x2000173;
 
         void registerExtensions (Compiler::Extensions& extensions)
         {
             extensions.registerInstruction("setscale","f",opcodeSetScale,opcodeSetScaleExplicit);
             extensions.registerFunction("getscale",'f',"",opcodeGetScale,opcodeGetScaleExplicit);
-            extensions.registerInstruction("setangle","Sf",opcodeSetAngle,opcodeSetAngleExplicit);
+            extensions.registerInstruction("setangle","cf",opcodeSetAngle,opcodeSetAngleExplicit);
-            extensions.registerFunction("getangle",'f',"S",opcodeGetAngle,opcodeGetAngleExplicit);
+            extensions.registerFunction("getangle",'f',"c",opcodeGetAngle,opcodeGetAngleExplicit);
+            extensions.registerFunction("getstartingangle",'f',"c",opcodeGetStartingAngle,opcodeGetStartingAngleExplicit);
         }
 
         void installOpcodes (Interpreter::Interpreter& interpreter)
@@ -135,6 +171,8 @@ namespace MWScript
             interpreter.installSegment5(opcodeGetScaleExplicit,new OpGetScale<ExplicitRef>);
             interpreter.installSegment5(opcodeGetAngle,new OpGetAngle<ImplicitRef>);
             interpreter.installSegment5(opcodeGetAngleExplicit,new OpGetAngle<ExplicitRef>);
+            interpreter.installSegment5(opcodeGetStartingAngle,new OpGetStartingAngle<ImplicitRef>);
+            interpreter.installSegment5(opcodeGetStartingAngleExplicit,new OpGetStartingAngle<ExplicitRef>);
         }
     }
 }

apps/openmw/mwsound/openal_output.cpp

@@ -8,7 +8,7 @@
 #include "openal_output.hpp"
 #include "sound_decoder.hpp"
 #include "sound.hpp"
-#include "soundmanager.hpp"
+#include "soundmanagerimp.hpp"
 
 #ifndef ALC_ALL_DEVICES_SPECIFIER
 #define ALC_ALL_DEVICES_SPECIFIER 0x1013
@@ -263,7 +263,7 @@ void OpenAL_SoundStream::update()
 {
     ALfloat gain = mVolume*mBaseVolume;
     ALfloat pitch = mPitch;
-    if(!(mFlags&Play_NoEnv) && mOutput.mLastEnvironment == Env_Underwater)
+    if(!(mFlags&MWBase::SoundManager::Play_NoEnv) && mOutput.mLastEnvironment == Env_Underwater)
     {
         gain *= 0.9f;
         pitch *= 0.7f;
@@ -400,7 +400,7 @@ void OpenAL_Sound::update()
 {
     ALfloat gain = mVolume*mBaseVolume;
     ALfloat pitch = mPitch;
-    if(!(mFlags&Play_NoEnv) && mOutput.mLastEnvironment == Env_Underwater)
+    if(!(mFlags&MWBase::SoundManager::Play_NoEnv) && mOutput.mLastEnvironment == Env_Underwater)
     {
         gain *= 0.9f;
         pitch *= 0.7f;
@@ -420,7 +420,7 @@ void OpenAL_Sound3D::update()
     ALfloat pitch = mPitch;
     if(mPos.squaredDistance(mOutput.mPos) > mMaxDistance*mMaxDistance)
         gain = 0.0f;
-    else if(!(mFlags&Play_NoEnv) && mOutput.mLastEnvironment == Env_Underwater)
+    else if(!(mFlags&MWBase::SoundManager::Play_NoEnv) && mOutput.mLastEnvironment == Env_Underwater)
     {
         gain *= 0.9f;
         pitch *= 0.7f;
@@ -642,7 +642,7 @@ void OpenAL_Output::bufferFinished(ALuint buf)
 }
 
 
-SoundPtr OpenAL_Output::playSound(const std::string &fname, float volume, float pitch, int flags)
+MWBase::SoundPtr OpenAL_Output::playSound(const std::string &fname, float volume, float pitch, int flags)
 {
     boost::shared_ptr<OpenAL_Sound> sound;
     ALuint src=0, buf=0;
@@ -674,7 +674,7 @@ SoundPtr OpenAL_Output::playSound(const std::string &fname, float volume, float
     alSourcef(src, AL_MAX_DISTANCE, 1000.0f);
     alSourcef(src, AL_ROLLOFF_FACTOR, 0.0f);
 
-    if(!(flags&Play_NoEnv) && mLastEnvironment == Env_Underwater)
+    if(!(flags&MWBase::SoundManager::Play_NoEnv) && mLastEnvironment == Env_Underwater)
     {
         volume *= 0.9f;
         pitch *= 0.7f;
@@ -683,7 +683,7 @@ SoundPtr OpenAL_Output::playSound(const std::string &fname, float volume, float
     alSourcef(src, AL_PITCH, pitch);
 
     alSourcei(src, AL_SOURCE_RELATIVE, AL_TRUE);
-    alSourcei(src, AL_LOOPING, (flags&Play_Loop) ? AL_TRUE : AL_FALSE);
+    alSourcei(src, AL_LOOPING, (flags&MWBase::SoundManager::Play_Loop) ? AL_TRUE : AL_FALSE);
     throwALerror();
 
     alSourcei(src, AL_BUFFER, buf);
@@ -693,7 +693,7 @@ SoundPtr OpenAL_Output::playSound(const std::string &fname, float volume, float
     return sound;
 }
 
-SoundPtr OpenAL_Output::playSound3D(const std::string &fname, const Ogre::Vector3 &pos, float volume, float pitch,
+MWBase::SoundPtr OpenAL_Output::playSound3D(const std::string &fname, const Ogre::Vector3 &pos, float volume, float pitch,
                                     float min, float max, int flags)
 {
     boost::shared_ptr<OpenAL_Sound> sound;
@@ -726,7 +726,7 @@ SoundPtr OpenAL_Output::playSound3D(const std::string &fname, const Ogre::Vector
     alSourcef(src, AL_MAX_DISTANCE, max);
     alSourcef(src, AL_ROLLOFF_FACTOR, 1.0f);
 
-    if(!(flags&Play_NoEnv) && mLastEnvironment == Env_Underwater)
+    if(!(flags&MWBase::SoundManager::Play_NoEnv) && mLastEnvironment == Env_Underwater)
     {
         volume *= 0.9f;
         pitch *= 0.7f;
@@ -736,7 +736,7 @@ SoundPtr OpenAL_Output::playSound3D(const std::string &fname, const Ogre::Vector
     alSourcef(src, AL_PITCH, pitch);
 
     alSourcei(src, AL_SOURCE_RELATIVE, AL_FALSE);
-    alSourcei(src, AL_LOOPING, (flags&Play_Loop) ? AL_TRUE : AL_FALSE);
+    alSourcei(src, AL_LOOPING, (flags&MWBase::SoundManager::Play_Loop) ? AL_TRUE : AL_FALSE);
     throwALerror();
 
     alSourcei(src, AL_BUFFER, buf);
@@ -747,7 +747,7 @@ SoundPtr OpenAL_Output::playSound3D(const std::string &fname, const Ogre::Vector
 }
 
 
-SoundPtr OpenAL_Output::streamSound(const std::string &fname, float volume, float pitch, int flags)
+MWBase::SoundPtr OpenAL_Output::streamSound(const std::string &fname, float volume, float pitch, int flags)
 {
     boost::shared_ptr<OpenAL_SoundStream> sound;
     ALuint src;
@@ -759,7 +759,7 @@ SoundPtr OpenAL_Output::streamSound(const std::string &fname, float volume, floa
 
     try
     {
-        if((flags&Play_Loop))
+        if((flags&MWBase::SoundManager::Play_Loop))
             std::cout <<"Warning: cannot loop stream "<<fname<< std::endl;
         DecoderPtr decoder = mManager.getDecoder();
         decoder->open(fname);
@@ -779,7 +779,7 @@ SoundPtr OpenAL_Output::streamSound(const std::string &fname, float volume, floa
     alSourcef(src, AL_MAX_DISTANCE, 1000.0f);
     alSourcef(src, AL_ROLLOFF_FACTOR, 0.0f);
 
-    if(!(flags&Play_NoEnv) && mLastEnvironment == Env_Underwater)
+    if(!(flags&MWBase::SoundManager::Play_NoEnv) && mLastEnvironment == Env_Underwater)
     {
         volume *= 0.9f;
         pitch *= 0.7f;

apps/openmw/mwsound/openal_output.hpp

@@ -42,10 +42,10 @@ namespace MWSound
         virtual void init(const std::string &devname="");
         virtual void deinit();
 
-        virtual SoundPtr playSound(const std::string &fname, float volume, float pitch, int flags);
+        virtual MWBase::SoundPtr playSound(const std::string &fname, float volume, float pitch, int flags);
-        virtual SoundPtr playSound3D(const std::string &fname, const Ogre::Vector3 &pos,
+        virtual MWBase::SoundPtr playSound3D(const std::string &fname, const Ogre::Vector3 &pos,
                                      float volume, float pitch, float min, float max, int flags);
-        virtual SoundPtr streamSound(const std::string &fname, float volume, float pitch, int flags);
+        virtual MWBase::SoundPtr streamSound(const std::string &fname, float volume, float pitch, int flags);
 
         virtual void updateListener(const Ogre::Vector3 &pos, const Ogre::Vector3 &atdir, const Ogre::Vector3 &updir, Environment env);
 

apps/openmw/mwsound/sound.hpp

@@ -3,7 +3,7 @@
 
 #include <OgreVector3.h>
 
-#include "soundmanager.hpp"
+#include "soundmanagerimp.hpp"
 
 namespace MWSound
 {
@@ -35,7 +35,7 @@ namespace MWSound
                 , mPitch(1.0f)
                 , mMinDistance(20.0f) /* 1 * min_range_scale */
                 , mMaxDistance(12750.0f) /* 255 * max_range_scale */
-                , mFlags(Play_Normal)
+                , mFlags(MWBase::SoundManager::Play_Normal)
         { }
         virtual ~Sound() { }
 

apps/openmw/mwsound/sound_output.hpp

@@ -6,7 +6,7 @@
 
 #include <OgreVector3.h>
 
-#include "soundmanager.hpp"
+#include "soundmanagerimp.hpp"
 
 #include "../mwworld/ptr.hpp"
 
@@ -24,10 +24,10 @@ namespace MWSound
         virtual void init(const std::string &devname="") = 0;
         virtual void deinit() = 0;
 
-        virtual SoundPtr playSound(const std::string &fname, float volume, float pitch, int flags) = 0;
+        virtual MWBase::SoundPtr playSound(const std::string &fname, float volume, float pitch, int flags) = 0;
-        virtual SoundPtr playSound3D(const std::string &fname, const Ogre::Vector3 &pos,
+        virtual MWBase::SoundPtr playSound3D(const std::string &fname, const Ogre::Vector3 &pos,
                                      float volume, float pitch, float min, float max, int flags) = 0;
-        virtual SoundPtr streamSound(const std::string &fname, float volume, float pitch, int flags) = 0;
+        virtual MWBase::SoundPtr streamSound(const std::string &fname, float volume, float pitch, int flags) = 0;
 
         virtual void updateListener(const Ogre::Vector3 &pos, const Ogre::Vector3 &atdir, const Ogre::Vector3 &updir, Environment env) = 0;
 

apps/openmw/mwsound/soundmanagerimp.cpp

@@ -1,11 +1,9 @@
-#include "soundmanager.hpp"
+#include "soundmanagerimp.hpp"
 
 #include <iostream>
 #include <algorithm>
 #include <map>
 
-#include <OgreRoot.h>
-
 #include <components/esm_store/store.hpp>
 
 #include "../mwbase/environment.hpp"
@@ -13,8 +11,6 @@
 
 #include "../mwworld/player.hpp"
 
-#include "../mwrender/player.hpp"
-
 #include "sound_output.hpp"
 #include "sound_decoder.hpp"
 #include "sound.hpp"
@@ -222,7 +218,7 @@ namespace MWSound
             const ESM::Position &pos = ptr.getCellRef().pos;
             const Ogre::Vector3 objpos(pos.pos[0], pos.pos[1], pos.pos[2]);
 
-            SoundPtr sound = mOutput->playSound3D(filePath, objpos, basevol, 1.0f,
+            MWBase::SoundPtr sound = mOutput->playSound3D(filePath, objpos, basevol, 1.0f,
                                                   20.0f, 12750.0f, Play_Normal);
             sound->mPos = objpos;
             sound->mBaseVolume = basevol;
@@ -244,7 +240,7 @@ namespace MWSound
             float basevol = mMasterVolume * mVoiceVolume;
             std::string filePath = "Sound/"+filename;
 
-            SoundPtr sound = mOutput->playSound(filePath, basevol, 1.0f, Play_Normal);
+            MWBase::SoundPtr sound = mOutput->playSound(filePath, basevol, 1.0f, Play_Normal);
             sound->mBaseVolume = basevol;
 
             mActiveSounds[sound] = std::make_pair(MWWorld::Ptr(), std::string("_say_sound"));
@@ -277,9 +273,9 @@ namespace MWSound
 
 
 
-    SoundPtr SoundManager::playSound(const std::string& soundId, float volume, float pitch, int mode)
+    MWBase::SoundPtr SoundManager::playSound(const std::string& soundId, float volume, float pitch, int mode)
     {
-        SoundPtr sound;
+        MWBase::SoundPtr sound;
         if(!mOutput->isInitialized())
             return sound;
         try
@@ -305,10 +301,10 @@ namespace MWSound
         return sound;
     }
 
-    SoundPtr SoundManager::playSound3D(MWWorld::Ptr ptr, const std::string& soundId,
+    MWBase::SoundPtr SoundManager::playSound3D(MWWorld::Ptr ptr, const std::string& soundId,
                                        float volume, float pitch, int mode)
     {
-        SoundPtr sound;
+        MWBase::SoundPtr sound;
         if(!mOutput->isInitialized())
             return sound;
         try
@@ -491,25 +487,20 @@ namespace MWSound
         if(!isMusicPlaying())
             startRandomTitle();
 
-        const ESM::Cell *cell = MWBase::Environment::get().getWorld()->getPlayer().getPlayer().getCell()->cell;
+        MWWorld::Ptr player =
-        Ogre::Camera *cam = MWBase::Environment::get().getWorld()->getPlayer().getRenderer()->getCamera();
+            MWBase::Environment::get().getWorld()->getPlayer().getPlayer();
-        Ogre::Vector3 nPos, nDir, nUp;
+        const ESM::Cell *cell = player.getCell()->cell;
-        nPos = cam->getRealPosition();
-        nDir = cam->getRealDirection();
-        nUp  = cam->getRealUp();
 
         Environment env = Env_Normal;
-        if((cell->data.flags&cell->HasWater) && nPos.y < cell->water)
+        if((cell->data.flags&cell->HasWater) && mListenerPos.z < cell->water)
             env = Env_Underwater;
 
-        // The output handler is expecting vectors oriented like the game
+        mOutput->updateListener(
-        // (that is, -Z goes down, +Y goes forward), but that's not what we
+            mListenerPos,
-        // get from Ogre's camera, so we have to convert.
+            mListenerDir,
-        const Ogre::Vector3 pos(nPos[0], -nPos[2], nPos[1]);
+            Ogre::Vector3::UNIT_Z,
-        const Ogre::Vector3 at(nDir[0], -nDir[2], nDir[1]);
+            env
-        const Ogre::Vector3 up(nUp[0], -nUp[2], nUp[1]);
+        );
-
-        mOutput->updateListener(pos, at, up, env);
 
         // Check if any sounds are finished playing, and trash them
         SoundMap::iterator snditer = mActiveSounds.begin();
@@ -567,6 +558,12 @@ namespace MWSound
         }
     }
 
+    void SoundManager::setListenerPosDir(const Ogre::Vector3 &pos, const Ogre::Vector3 &dir)
+    {
+        mListenerPos = pos;
+        mListenerDir = dir;
+    }
+
     // Default readAll implementation, for decoders that can't do anything
     // better
     void Sound_Decoder::readAll(std::vector<char> &output)

apps/openmw/mwsound/soundmanagerimp.hpp

@@ -7,19 +7,15 @@
 
 #include <boost/shared_ptr.hpp>
 
+#include <OgreVector3.h>
 #include <OgreResourceGroupManager.h>
 
 #include <components/settings/settings.hpp>
 
+#include "../mwbase/soundmanager.hpp"
+
 #include "../mwworld/ptr.hpp"
 
-
-namespace Ogre
-{
-    class Root;
-    class Camera;
-}
-
 namespace MWSound
 {
     class Sound_Output;
@@ -27,27 +23,13 @@ namespace MWSound
     class Sound;
 
     typedef boost::shared_ptr<Sound_Decoder> DecoderPtr;
-    typedef boost::shared_ptr<Sound> SoundPtr;
-
-    enum PlayMode {
-        Play_Normal  = 0, /* tracked, non-looping, multi-instance, environment */
-        Play_Loop    = 1<<0, /* Sound will continually loop until explicitly stopped */
-        Play_NoEnv   = 1<<1, /* Do not apply environment effects (eg, underwater filters) */
-        Play_NoTrack = 1<<2, /* (3D only) Play the sound at the given object's position
-                              * but do not keep it updated (the sound will not move with
-                              * the object and will not stop when the object is deleted. */
-    };
-    static inline int operator|(const PlayMode &a, const PlayMode &b)
-    { return (int)a | (int)b; }
-    static inline int operator&(const PlayMode &a, const PlayMode &b)
-    { return (int)a & (int)b; }
 
     enum Environment {
         Env_Normal,
         Env_Underwater,
     };
 
-    class SoundManager
+    class SoundManager : public MWBase::SoundManager
     {
         Ogre::ResourceGroupManager& mResourceMgr;
 
@@ -65,9 +47,12 @@ namespace MWSound
         std::string mCurrentPlaylist;
 
         typedef std::pair<MWWorld::Ptr,std::string> PtrIDPair;
-        typedef std::map<SoundPtr,PtrIDPair> SoundMap;
+        typedef std::map<MWBase::SoundPtr,PtrIDPair> SoundMap;
         SoundMap mActiveSounds;
 
+        Ogre::Vector3 mListenerPos;
+        Ogre::Vector3 mListenerDir;
+
         std::string lookup(const std::string &soundId,
                   float &volume, float &min, float &max);
         void streamMusicFull(const std::string& filename);
@@ -84,67 +69,69 @@ namespace MWSound
 
     public:
         SoundManager(bool useSound);
-        ~SoundManager();
+        virtual ~SoundManager();
 
-        void processChangedSettings(const Settings::CategorySettingVector& settings);
+        virtual void processChangedSettings(const Settings::CategorySettingVector& settings);
 
-        void stopMusic();
+        virtual void stopMusic();
         ///< Stops music if it's playing
 
-        void streamMusic(const std::string& filename);
+        virtual void streamMusic(const std::string& filename);
         ///< Play a soundifle
         /// \param filename name of a sound file in "Music/" in the data directory.
 
-        void startRandomTitle();
+        virtual void startRandomTitle();
         ///< Starts a random track from the current playlist
 
-        bool isMusicPlaying();
+        virtual bool isMusicPlaying();
         ///< Returns true if music is playing
 
-        void playPlaylist(const std::string &playlist);
+        virtual void playPlaylist(const std::string &playlist);
         ///< Start playing music from the selected folder
         /// \param name of the folder that contains the playlist
 
-        void say(MWWorld::Ptr reference, const std::string& filename);
+        virtual void say(MWWorld::Ptr reference, const std::string& filename);
         ///< Make an actor say some text.
         /// \param filename name of a sound file in "Sound/" in the data directory.
 
-        void say(const std::string& filename);
+        virtual void say(const std::string& filename);
         ///< Say some text, without an actor ref
         /// \param filename name of a sound file in "Sound/" in the data directory.
 
-        bool sayDone(MWWorld::Ptr reference=MWWorld::Ptr()) const;
+        virtual bool sayDone(MWWorld::Ptr reference=MWWorld::Ptr()) const;
         ///< Is actor not speaking?
 
-        void stopSay(MWWorld::Ptr reference=MWWorld::Ptr());
+        virtual void stopSay(MWWorld::Ptr reference=MWWorld::Ptr());
         ///< Stop an actor speaking
 
-        SoundPtr playSound(const std::string& soundId, float volume, float pitch, int mode=Play_Normal);
+        virtual MWBase::SoundPtr playSound(const std::string& soundId, float volume, float pitch, int mode=Play_Normal);
         ///< Play a sound, independently of 3D-position
 
-        SoundPtr playSound3D(MWWorld::Ptr reference, const std::string& soundId,
+        virtual MWBase::SoundPtr playSound3D(MWWorld::Ptr reference, const std::string& soundId,
                              float volume, float pitch, int mode=Play_Normal);
         ///< Play a sound from an object
 
-        void stopSound3D(MWWorld::Ptr reference, const std::string& soundId);
+        virtual void stopSound3D(MWWorld::Ptr reference, const std::string& soundId);
         ///< Stop the given object from playing the given sound,
 
-        void stopSound3D(MWWorld::Ptr reference);
+        virtual void stopSound3D(MWWorld::Ptr reference);
         ///< Stop the given object from playing all sounds.
 
-        void stopSound(const MWWorld::CellStore *cell);
+        virtual void stopSound(const MWWorld::CellStore *cell);
         ///< Stop all sounds for the given cell.
 
-        void stopSound(const std::string& soundId);
+        virtual void stopSound(const std::string& soundId);
         ///< Stop a non-3d looping sound
 
-        bool getSoundPlaying(MWWorld::Ptr reference, const std::string& soundId) const;
+        virtual bool getSoundPlaying(MWWorld::Ptr reference, const std::string& soundId) const;
         ///< Is the given sound currently playing on the given object?
 
-        void updateObject(MWWorld::Ptr reference);
+        virtual void updateObject(MWWorld::Ptr reference);
         ///< Update the position of all sounds connected to the given object.
 
-        void update(float duration);
+        virtual void update(float duration);
+
+        virtual void setListenerPosDir(const Ogre::Vector3 &pos, const Ogre::Vector3 &dir);
     };
 }
 

apps/openmw/mwworld/action.cpp

@@ -2,8 +2,7 @@
 #include "action.hpp"
 
 #include "../mwbase/environment.hpp"
-
+#include "../mwbase/soundmanager.hpp"
-#include "../mwsound/soundmanager.hpp"
 
 MWWorld::Action::Action() {}
 
@@ -13,7 +12,7 @@ void MWWorld::Action::execute (const Ptr& actor)
 {
     if (!mSoundId.empty())
         MWBase::Environment::get().getSoundManager()->playSound3D (actor, mSoundId, 1.0, 1.0,
-            MWSound::Play_NoTrack);
+            MWBase::SoundManager::Play_NoTrack);
 
     executeImp (actor);
 }

apps/openmw/mwworld/actiontalk.cpp

@@ -2,8 +2,7 @@
 #include "actiontalk.hpp"
 
 #include "../mwbase/environment.hpp"
-#include "../mwgui/window_manager.hpp"
+#include "../mwbase/dialoguemanager.hpp"
-#include "../mwdialogue/dialoguemanager.hpp"
 
 namespace MWWorld
 {

apps/openmw/mwworld/cells.cpp

@@ -167,67 +167,71 @@ MWWorld::Ptr MWWorld::Cells::getPtr (const std::string& name, Ptr::CellStore& ce
         else
             return Ptr();
     }
+    MWWorld::Ptr ptr;
 
     if (MWWorld::LiveCellRef<ESM::Activator> *ref = cell.activators.find (name))
-        return Ptr (ref, &cell);
+        ptr = Ptr (ref, &cell);
 
     if (MWWorld::LiveCellRef<ESM::Potion> *ref = cell.potions.find (name))
-        return Ptr (ref, &cell);
+        ptr = Ptr (ref, &cell);
 
     if (MWWorld::LiveCellRef<ESM::Apparatus> *ref = cell.appas.find (name))
-        return Ptr (ref, &cell);
+        ptr = Ptr (ref, &cell);
 
     if (MWWorld::LiveCellRef<ESM::Armor> *ref = cell.armors.find (name))
-        return Ptr (ref, &cell);
+        ptr = Ptr (ref, &cell);
 
     if (MWWorld::LiveCellRef<ESM::Book> *ref = cell.books.find (name))
-        return Ptr (ref, &cell);
+        ptr = Ptr (ref, &cell);
 
     if (MWWorld::LiveCellRef<ESM::Clothing> *ref = cell.clothes.find (name))
-        return Ptr (ref, &cell);
+        ptr = Ptr (ref, &cell);
 
     if (MWWorld::LiveCellRef<ESM::Container> *ref = cell.containers.find (name))
-        return Ptr (ref, &cell);
+        ptr = Ptr (ref, &cell);
 
     if (MWWorld::LiveCellRef<ESM::Creature> *ref = cell.creatures.find (name))
-        return Ptr (ref, &cell);
+        ptr = Ptr (ref, &cell);
 
     if (MWWorld::LiveCellRef<ESM::Door> *ref = cell.doors.find (name))
-        return Ptr (ref, &cell);
+        ptr = Ptr (ref, &cell);
 
     if (MWWorld::LiveCellRef<ESM::Ingredient> *ref = cell.ingreds.find (name))
-        return Ptr (ref, &cell);
+        ptr = Ptr (ref, &cell);
 
     if (MWWorld::LiveCellRef<ESM::CreatureLevList> *ref = cell.creatureLists.find (name))
-        return Ptr (ref, &cell);
+        ptr = Ptr (ref, &cell);
 
     if (MWWorld::LiveCellRef<ESM::ItemLevList> *ref = cell.itemLists.find (name))
-        return Ptr (ref, &cell);
+        ptr = Ptr (ref, &cell);
 
     if (MWWorld::LiveCellRef<ESM::Light> *ref = cell.lights.find (name))
-        return Ptr (ref, &cell);
+        ptr = Ptr (ref, &cell);
 
     if (MWWorld::LiveCellRef<ESM::Tool> *ref = cell.lockpicks.find (name))
-        return Ptr (ref, &cell);
+        ptr = Ptr (ref, &cell);
 
     if (MWWorld::LiveCellRef<ESM::Miscellaneous> *ref = cell.miscItems.find (name))
-        return Ptr (ref, &cell);
+        ptr = Ptr (ref, &cell);
 
     if (MWWorld::LiveCellRef<ESM::NPC> *ref = cell.npcs.find (name))
-        return Ptr (ref, &cell);
+        ptr = Ptr (ref, &cell);
 
     if (MWWorld::LiveCellRef<ESM::Probe> *ref = cell.probes.find (name))
-        return Ptr (ref, &cell);
+        ptr = Ptr (ref, &cell);
 
     if (MWWorld::LiveCellRef<ESM::Repair> *ref = cell.repairs.find (name))
-        return Ptr (ref, &cell);
+        ptr = Ptr (ref, &cell);
 
     if (MWWorld::LiveCellRef<ESM::Static> *ref = cell.statics.find (name))
-        return Ptr (ref, &cell);
+        ptr = Ptr (ref, &cell);
 
     if (MWWorld::LiveCellRef<ESM::Weapon> *ref = cell.weapons.find (name))
-        return Ptr (ref, &cell);
+        ptr = Ptr (ref, &cell);
 
+    if (!ptr.isEmpty() && ptr.getRefData().getCount() > 0) {
+        return ptr;
+    }
     return Ptr();
 }
 

apps/openmw/mwworld/cellstore.hpp

@@ -69,7 +69,7 @@ namespace MWWorld
     {
         for (typename std::list<LiveRef>::iterator iter (list.begin()); iter!=list.end(); ++iter)
         {
-            if (iter->ref.refID==name)
+            if (iter->mData.getCount() > 0 && iter->ref.refID == name)
                 return &*iter;
         }
 
@@ -155,6 +155,20 @@ namespace MWWorld
             forEachImp (functor, weapons);
     }
 
+    bool operator==(const CellStore &cell) {
+        return  this->cell->name == cell.cell->name &&
+                this->cell->data.gridX == cell.cell->data.gridX &&
+                this->cell->data.gridY == cell.cell->data.gridY;
+    }
+
+    bool operator!=(const CellStore &cell) {
+        return !(*this == cell);
+    }
+
+    bool isExterior() const {
+        return cell->isExterior();
+    }
+
   private:
 
     template<class Functor, class List>

apps/openmw/mwworld/class.hpp

@@ -220,6 +220,11 @@ namespace MWWorld
 
             virtual Ptr
             copyToCell(const Ptr &ptr, CellStore &cell, const ESM::Position &pos) const;
+            
+            virtual bool
+            isActor() const {
+                return false;
+            }
     };
 }
 

apps/openmw/mwworld/player.cpp

@@ -6,8 +6,6 @@
 #include "../mwbase/environment.hpp"
 #include "../mwbase/world.hpp"
 
-#include "../mwrender/player.hpp"
-
 #include "../mwmechanics/movement.hpp"
 #include "../mwmechanics/npcstats.hpp"
 
@@ -15,8 +13,8 @@
 
 namespace MWWorld
 {
-    Player::Player (MWRender::Player *renderer, const ESM::NPC *player, const MWBase::World& world) :
+    Player::Player (const ESM::NPC *player, const MWBase::World& world) :
-      mCellStore (0), mRenderer (renderer), mClass (0),
+      mCellStore (0), mClass (0),
       mAutoMove (false), mForwardBackward (0)
     {
         mPlayer.base = player;
@@ -28,7 +26,6 @@ namespace MWWorld
         float* playerPos = mPlayer.mData.getPosition().pos;
         playerPos[0] = playerPos[1] = playerPos[2] = 0;
 
-        mPlayer.mData.setBaseNode(renderer->getNode());
         /// \todo Do not make a copy of classes defined in esm/p records.
         mClass = new ESM::Class (*world.getStore().classes.find (player->cls));
     }
@@ -38,17 +35,6 @@ namespace MWWorld
         delete mClass;
     }
 
-    void Player::setPos(float x, float y, float z)
-    {
-        /// \todo This fcuntion should be removed during the mwrender-refactoring.
-        MWBase::Environment::get().getWorld()->moveObject (getPlayer(), x, y, z);
-    }
-
-    void Player::setRot(float x, float y, float z)
-    {
-        mRenderer->setRot(x, y, z);
-    }
-
     void Player::setClass (const ESM::Class& class_)
     {
         ESM::Class *new_class = new ESM::Class (class_);

apps/openmw/mwworld/player.hpp

@@ -14,11 +14,6 @@ namespace MWBase
     class World;
 }
 
-namespace MWRender
-{
-    class Player;
-}
-
 namespace MWWorld
 {
     class CellStore;
@@ -28,7 +23,6 @@ namespace MWWorld
     {
         LiveCellRef<ESM::NPC> mPlayer;
         MWWorld::CellStore *mCellStore;
-        MWRender::Player *mRenderer;
         std::string mName;
         bool mMale;
         std::string mRace;
@@ -38,16 +32,10 @@ namespace MWWorld
         int mForwardBackward;
     public:
 
-        Player(MWRender::Player *renderer, const ESM::NPC *player, const MWBase::World& world);
+        Player(const ESM::NPC *player, const MWBase::World& world);
 
         ~Player();
 
-        /// Set the player position. Uses Morrowind coordinates.
-        void setPos(float x, float y, float z);
-
-        /// Set where the player is looking at. Uses Morrowind (euler) angles
-        void setRot(float x, float y, float z);
-
         void setCell (MWWorld::CellStore *cellStore)
         {
             mCellStore = cellStore;
@@ -59,8 +47,6 @@ namespace MWWorld
             return ptr;
         }
 
-        MWRender::Player *getRenderer() { return mRenderer; }
-
         void setName (const std::string& name)
         {
             mName = name;

apps/openmw/mwworld/scene.cpp

@@ -2,11 +2,10 @@
 
 #include "../mwbase/environment.hpp"
 #include "../mwbase/world.hpp" /// FIXME
+#include "../mwbase/soundmanager.hpp"
 
 #include "../mwmechanics/mechanicsmanager.hpp"
 
-#include "../mwsound/soundmanager.hpp"
-
 #include "../mwgui/window_manager.hpp"
 
 #include "player.hpp"
@@ -135,21 +134,34 @@ namespace MWWorld
 
     }
 
-    void Scene::playerCellChange (Ptr::CellStore *cell, const ESM::Position& position,
+    void
+    Scene::playerCellChange(
+        MWWorld::CellStore *cell,
+        const ESM::Position& pos,
         bool adjustPlayerPos)
     {
         bool hasWater = cell->cell->data.flags & cell->cell->HasWater;
         mPhysics->setCurrentWater(hasWater, cell->cell->water);
-        if (adjustPlayerPos)
+
-        {
+        MWBase::World *world = MWBase::Environment::get().getWorld();
-            MWBase::Environment::get().getWorld()->getPlayer().setPos (position.pos[0], position.pos[1], position.pos[2]);
+        world->getPlayer().setCell(cell);
-            MWBase::Environment::get().getWorld()->getPlayer().setRot (position.rot[0], position.rot[1], position.rot[2]);
+
+        MWWorld::Ptr player = world->getPlayer().getPlayer();
+
+        if (adjustPlayerPos) {
+            world->moveObject(player, pos.pos[0], pos.pos[1], pos.pos[2]);
+
+            float x = Ogre::Radian(pos.rot[0]).valueDegrees();
+            float y = Ogre::Radian(pos.rot[1]).valueDegrees();
+            float z = Ogre::Radian(pos.rot[2]).valueDegrees();
+            world->rotateObject(player, x, y, z);
         }
 
-        MWBase::Environment::get().getWorld()->getPlayer().setCell (cell);
+        MWMechanics::MechanicsManager *mechMgr =
+            MWBase::Environment::get().getMechanicsManager();
 
-        MWBase::Environment::get().getMechanicsManager()->addActor (MWBase::Environment::get().getWorld()->getPlayer().getPlayer());
+        mechMgr->addActor(player);
-        MWBase::Environment::get().getMechanicsManager()->watchActor (MWBase::Environment::get().getWorld()->getPlayer().getPlayer());
+        mechMgr->watchActor(player);
 
         MWBase::Environment::get().getWindowManager()->changeCell(mCurrentCell);
     }
@@ -224,7 +236,7 @@ namespace MWWorld
 
 
         // adjust player
-        playerCellChange (MWBase::Environment::get().getWorld()->getExterior(X, Y), position, adjustPlayerPos);
+        playerCellChange (mCurrentCell, position, adjustPlayerPos);
 
         // Sky system
         MWBase::Environment::get().getWorld()->adjustSky();
@@ -350,10 +362,7 @@ namespace MWWorld
     {
         CellStoreCollection::iterator active = mActiveCells.begin();
         while (active != mActiveCells.end()) {
-            if ((*active)->cell->name == cell.cell->name &&
+            if (**active == cell) {
-                (*active)->cell->data.gridX == cell.cell->data.gridX &&
-                (*active)->cell->data.gridY == cell.cell->data.gridY)
-            {
                 return true;
             }
             ++active;

apps/openmw/mwworld/timestamp.cpp

@@ -76,12 +76,12 @@ namespace MWWorld
 
     TimeStamp operator+ (const TimeStamp& stamp, double hours)
     {
-        return TimeStamp (stamp) + hours;
+        return TimeStamp (stamp) += hours;
     }
 
     TimeStamp operator+ (double hours, const TimeStamp& stamp)
     {
-        return TimeStamp (stamp) + hours;
+        return TimeStamp (stamp) += hours;
     }
 
     double operator- (const TimeStamp& left, const TimeStamp& right)

apps/openmw/mwworld/weather.cpp

@@ -9,11 +9,10 @@
 
 #include "../mwbase/environment.hpp"
 #include "../mwbase/world.hpp"
+#include "../mwbase/soundmanager.hpp"
 
 #include "../mwrender/renderingmanager.hpp"
 
-#include "../mwsound/soundmanager.hpp"
-
 #include "player.hpp"
 
 using namespace Ogre;

apps/openmw/mwworld/worldimp.cpp

@@ -4,14 +4,13 @@
 #include <components/files/collections.hpp>
 
 #include "../mwbase/environment.hpp"
+#include "../mwbase/soundmanager.hpp"
 
 #include "../mwrender/sky.hpp"
 #include "../mwrender/player.hpp"
 
 #include "../mwmechanics/mechanicsmanager.hpp"
 
-#include "../mwsound/soundmanager.hpp"
-
 #include "../mwgui/window_manager.hpp"
 
 #include "player.hpp"
@@ -51,7 +50,7 @@ namespace
 
         for (iterator iter (refList.list.begin()); iter!=refList.list.end(); ++iter)
         {
-            if(iter->mData.getBaseNode()){
+            if(iter->mData.getCount() > 0 && iter->mData.getBaseNode()){
             if (iter->mData.getHandle()==handle)
             {
                 return &*iter;
@@ -189,8 +188,9 @@ namespace MWWorld
         mEsm.open (masterPath.string());
         mStore.load (mEsm);
 
-        MWRender::Player* play = &(mRendering->getPlayer());
+        mPlayer = new MWWorld::Player (mStore.npcs.find ("player"), *this);
-        mPlayer = new MWWorld::Player (play, mStore.npcs.find ("player"), *this);
+        mRendering->attachCameraTo(mPlayer->getPlayer());
+
         mPhysics->addActor (mPlayer->getPlayer().getRefData().getHandle(), "", Ogre::Vector3 (0, 0, 0));
 
         // global variables
@@ -543,49 +543,78 @@ namespace MWWorld
         }
     }
 
+    void World::moveObject(const Ptr &ptr, CellStore &newCell, float x, float y, float z)
+    {
+        ESM::Position &pos = ptr.getRefData().getPosition();
+        pos.pos[0] = x, pos.pos[1] = y, pos.pos[2] = z;
+        Ogre::Vector3 vec(x, y, z);
+
+        CellStore *currCell = ptr.getCell();
+        bool isPlayer = ptr == mPlayer->getPlayer();
+        bool haveToMove = mWorldScene->isCellActive(*currCell) || isPlayer;
+
+        if (*currCell != newCell) {
+            if (isPlayer) {
+                if (!newCell.isExterior()) {
+                    changeToInteriorCell(newCell.cell->name, pos);
+                } else {
+                    changeToExteriorCell(pos);
+                }
+            } else {
+                if (!mWorldScene->isCellActive(newCell)) {
+                    copyObjectToCell(ptr, newCell, pos);
+                } else if (!mWorldScene->isCellActive(*currCell)) {
+                    MWWorld::Class::get(ptr).copyToCell(ptr, newCell);
+                    mWorldScene->removeObjectFromScene(ptr);
+                    mLocalScripts.remove(ptr);
+                    haveToMove = false;
+                } else {
+                    MWWorld::Ptr copy =
+                        MWWorld::Class::get(ptr).copyToCell(ptr, newCell);
+
+                    mRendering->moveObjectToCell(copy, vec, currCell);
+
+                    if (MWWorld::Class::get(ptr).isActor()) {
+                        MWMechanics::MechanicsManager *mechMgr =
+                            MWBase::Environment::get().getMechanicsManager();
+
+                        mechMgr->removeActor(ptr);
+                        mechMgr->addActor(copy);
+                    } else {
+                        std::string script =
+                            MWWorld::Class::get(ptr).getScript(ptr);
+                        if (!script.empty()) {
+                            mLocalScripts.remove(ptr);
+                            mLocalScripts.add(script, copy);
+                        }
+                    }
+                }
+                ptr.getRefData().setCount(0);
+            }
+        }
+        if (haveToMove) {
+            mRendering->moveObject(ptr, vec);
+            mPhysics->moveObject(ptr.getRefData().getHandle(), vec);
+        }
+    }
+
     bool World::moveObjectImp(const Ptr& ptr, float x, float y, float z)
     {
-        bool ret = false;
+        CellStore *cell = ptr.getCell();
-        ptr.getRefData().getPosition().pos[0] = x;
+        if (cell->isExterior()) {
-        ptr.getRefData().getPosition().pos[1] = y;
+            int cellX, cellY;
-        ptr.getRefData().getPosition().pos[2] = z;
-        if (ptr==mPlayer->getPlayer())
-        {
-            //std::cout << "X:" <<   ptr.getRefData().getPosition().pos[0] << " Z: "  << ptr.getRefData().getPosition().pos[1] << "\n";
-
-            Ptr::CellStore *currentCell = mWorldScene->getCurrentCell();
-            if (currentCell)
-            {
-                if (!(currentCell->cell->data.flags & ESM::Cell::Interior))
-                {
-                    // exterior -> adjust loaded cells
-                    int cellX = 0;
-                    int cellY = 0;
-
             positionToIndex(x, y, cellX, cellY);
         
-                    if (currentCell->cell->data.gridX!=cellX || currentCell->cell->data.gridY!=cellY)
+            cell = getExterior(cellX, cellY);
-                    {
-                        mWorldScene->changeCell (cellX, cellY, mPlayer->getPlayer().getRefData().getPosition(), false);
-                        ret = true;
         }
+        moveObject(ptr, *cell, x, y, z);
        
-                }
+        return cell != ptr.getCell();
-            }
-        }
-
-        /// \todo cell change for non-player ref
-
-        mRendering->moveObject (ptr, Ogre::Vector3 (x, y, z));
-
-        return ret;
     }
 
     void World::moveObject (const Ptr& ptr, float x, float y, float z)
     {
         moveObjectImp(ptr, x, y, z);
-
-        mPhysics->moveObject (ptr.getRefData().getHandle(), Ogre::Vector3 (x, y, z));
     }
 
     void World::scaleObject (const Ptr& ptr, float scale)
@@ -598,19 +627,22 @@ namespace MWWorld
         mPhysics->scaleObject( ptr.getRefData().getHandle(), scale );
     }
 
-    void World::rotateObject (const Ptr& ptr,float x,float y,float z)
+    void World::rotateObject (const Ptr& ptr,float x,float y,float z, bool adjust)
     {
-        MWWorld::Class::get(ptr).adjustRotation(ptr,x,y,z);
+        Ogre::Vector3 rot;
+        rot.x = Ogre::Degree(x).valueRadians();
+        rot.y = Ogre::Degree(y).valueRadians();
+        rot.z = Ogre::Degree(z).valueRadians();
 
-        ptr.getRefData().getPosition().rot[0] = Ogre::Degree(x).valueRadians();
+        if (mRendering->rotateObject(ptr, rot, adjust)) {
-        ptr.getRefData().getPosition().rot[1] = Ogre::Degree(y).valueRadians();
+            float *objRot = ptr.getRefData().getPosition().rot;
-        ptr.getRefData().getPosition().rot[2] = Ogre::Degree(z).valueRadians();
+            objRot[0] = rot.x, objRot[1] = rot.y, objRot[2] = rot.z;
 
-        Ogre::Quaternion rotx(Ogre::Degree(x),Ogre::Vector3::UNIT_X);
+            mPhysics->rotateObject(
-        Ogre::Quaternion roty(Ogre::Degree(y),Ogre::Vector3::UNIT_Y);
+                ptr.getRefData().getHandle(),
-        Ogre::Quaternion rotz(Ogre::Degree(z),Ogre::Vector3::UNIT_Z);
+                ptr.getRefData().getBaseNode()->getOrientation()
-        ptr.getRefData().getBaseNode()->setOrientation(rotz*roty*rotx);
+            );
-        mPhysics->rotateObject(ptr.getRefData().getHandle(),ptr.getRefData().getBaseNode()->getOrientation());
+        }
     }
 
     void World::indexToPosition (int cellX, int cellY, float &x, float &y, bool centre) const
@@ -1021,7 +1053,7 @@ namespace MWWorld
         pos.pos[1] = -result.second[2];
         pos.pos[2] = result.second[1];
 
-        placeObject(object, *cell, pos);
+        copyObjectToCell(object, *cell, pos);
         object.getRefData().setCount(0);
 
         return true;
@@ -1039,7 +1071,7 @@ namespace MWWorld
     }
 
     void
-    World::placeObject(const Ptr &object, CellStore &cell, const ESM::Position &pos)
+    World::copyObjectToCell(const Ptr &object, CellStore &cell, const ESM::Position &pos)
     {
         /// \todo add searching correct cell for position specified
         MWWorld::Ptr dropped =
@@ -1082,7 +1114,7 @@ namespace MWWorld
             mPhysics->castRay(orig, dir, len);
         pos.pos[2] = hit.second.z;
 
-        placeObject(object, *cell, pos);
+        copyObjectToCell(object, *cell, pos);
         object.getRefData().setCount(0);
     }
 
@@ -1095,4 +1127,27 @@ namespace MWWorld
     {
         mRendering->getTriangleBatchCount(triangles, batches);
     }
+
+    bool
+    World::isSwimming(const MWWorld::Ptr &object)
+    {
+        /// \todo add check ifActor() - only actors can swim
+        float *fpos = object.getRefData().getPosition().pos;
+        Ogre::Vector3 pos(fpos[0], fpos[1], fpos[2]);
+
+        /// \fixme should rely on object height
+        pos.z += 30;
+
+        return isUnderwater(*object.getCell()->cell, pos);
+    }
+
+    bool
+    World::isUnderwater(const ESM::Cell &cell, const Ogre::Vector3 &pos)
+    {
+        if (!(cell.data.flags & ESM::Cell::HasWater)) {
+            return false;
+        }
+        return pos.z < cell.water;
+    }
+
 }

apps/openmw/mwworld/worldimp.hpp

@@ -90,7 +90,7 @@ namespace MWWorld
             ///< @return true if the active cell (cell player is in) changed
 
             virtual void
-            placeObject(const Ptr &ptr, CellStore &cell, const ESM::Position &pos);
+            copyObjectToCell(const Ptr &ptr, CellStore &cell, const ESM::Position &pos);
 
         public:
 
@@ -206,10 +206,13 @@ namespace MWWorld
             virtual void deleteObject (const Ptr& ptr);
 
             virtual void moveObject (const Ptr& ptr, float x, float y, float z);
+            virtual void moveObject (const Ptr& ptr, CellStore &newCell, float x, float y, float z);
 
             virtual void scaleObject (const Ptr& ptr, float scale);
 
-            virtual void rotateObject (const Ptr& ptr,float x,float y,float z);
+            /// Rotates object, uses degrees
+            /// \param adjust indicates rotation should be set or adjusted
+            virtual void rotateObject (const Ptr& ptr,float x,float y,float z, bool adjust = false);
 
             virtual void indexToPosition (int cellX, int cellY, float &x, float &y, bool centre = false)
                 const;
@@ -270,6 +273,10 @@ namespace MWWorld
             ///< @return true if it is possible to place on object at specified cursor location
 
             virtual void processChangedSettings(const Settings::CategorySettingVector& settings);
+
+            virtual bool isSwimming(const MWWorld::Ptr &object);
+            virtual bool isUnderwater(const ESM::Cell &cell, const Ogre::Vector3 &pos);
+
     };
 }
 

cmake/FindMyGUI.cmake

@@ -128,9 +128,11 @@ ELSE (WIN32) #Unix
 ENDIF (WIN32)
 
 #Do some preparation
+IF (NOT WIN32) # This does not work on Windows for paths with spaces in them
 	SEPARATE_ARGUMENTS(MYGUI_INCLUDE_DIRS)
 	SEPARATE_ARGUMENTS(MYGUI_LIBRARIES)
 	SEPARATE_ARGUMENTS(MYGUI_PLATFORM_LIBRARIES)
+ENDIF (NOT WIN32)
 
 SET(MYGUI_LIBRARIES ${MYGUI_LIBRARIES} ${FREETYPE_LIBRARIES})
 

components/CMakeLists.txt

@@ -52,7 +52,7 @@ add_component_dir (misc
 
 add_component_dir (files
     linuxpath windowspath macospath fixedpath multidircollection collections fileops configurationmanager
-    filelibrary
+    filelibrary ogreplugin
     )
 
 add_component_dir (compiler

components/bsa/bsa_file.cpp

@@ -200,7 +200,7 @@ void BSAFile::readHeader()
     input.read(&stringBuf[0], stringBuf.size());
 
     // Check our position
-    assert(input.tellg() == static_cast<int> (12+dirsize));
+    assert(input.tellg() == std::streampos(12+dirsize));
 
     // Calculate the offset of the data buffer. All file offsets are
     // relative to this. 12 header bytes + directory + hash table

components/esm/esm_reader.cpp

@@ -1,4 +1,5 @@
 #include "esm_reader.hpp"
+#include <stdexcept>
 
 namespace ESM
 {

components/files/ogreplugin.cpp

@@ -0,0 +1,37 @@
+#include "ogreplugin.hpp"
+
+#include <OgrePrerequisites.h>
+#include <OgreRoot.h>
+
+namespace Files {
+
+bool loadOgrePlugin(const std::string &pluginDir, std::string pluginName, Ogre::Root &ogreRoot) {
+	pluginName = pluginName + OGRE_PLUGIN_DEBUG_SUFFIX;
+#if OGRE_PLATFORM == OGRE_PLATFORM_APPLE
+	std::ostringstream verStream;
+	verStream << "." << OGRE_VERSION_MAJOR << "." << OGRE_VERSION_MINOR << "." << OGRE_VERSION_PATCH;
+	pluginName = pluginName + verStream.str();
+#endif
+
+	std::string pluginExt;
+#if OGRE_PLATFORM == OGRE_PLATFORM_WIN32
+    pluginExt = ".dll";
+#endif
+#if OGRE_PLATFORM == OGRE_PLATFORM_APPLE
+    pluginExt = ".dylib";
+#endif
+#if OGRE_PLATFORM == OGRE_PLATFORM_LINUX
+    pluginExt = ".so";
+#endif
+
+    std::string pluginPath = pluginDir + "/" + pluginName + pluginExt;
+    if (boost::filesystem::exists(pluginPath)) {
+    	ogreRoot.loadPlugin(pluginPath);
+    	return true;
+    }
+    else {
+    	return false;
+    }
+}
+
+}