Merge branch 'master' of https://github.com/zinnschlag/openmw.git into object_movement_creation

Conflicts:
	apps/openmw/mwscript/transformationextensions.cpp

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,22 +233,46 @@ 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)
+if (DEFINED CMAKE_BUILD_TYPE AND CMAKE_BUILD_TYPE STREQUAL "Debug" AND NOT APPLE)
-    if (CMAKE_BUILD_TYPE STREQUAL "Debug")
+	add_definitions(-DOGRE_PLUGIN_DEBUG_SUFFIX="_d")
-        set(DEBUG_SUFFIX "_d")
+else()
-        add_definitions(-DOGRE_PLUGIN_DEBUG_SUFFIX="_d")
+	add_definitions(-DOGRE_PLUGIN_DEBUG_SUFFIX="")
-    else()
-        add_definitions(-DOGRE_PLUGIN_DEBUG_SUFFIX="")
-    endif()
 endif()
+
 add_definitions(-DOGRE_PLUGIN_DIR_REL="${OGRE_PLUGIN_DIR_REL}")
 add_definitions(-DOGRE_PLUGIN_DIR_DBG="${OGRE_PLUGIN_DIR_DBG}")
-add_definitions(-DOGRE_PLUGIN_DIR="${OGRE_PLUGIN_DIR}")
+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/)
@@ -278,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
@@ -32,18 +33,18 @@ add_openmw_dir (mwgui
     )
 
 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,76 @@
+#ifndef GAME_MWBASE_JOURNAL_H
+#define GAME_MWBASE_JOURNAL_H
+
+#include <string>
+#include <deque>
+#include <map>
+
+namespace MWDialogue
+{
+    class Quest;
+    class Topic;
+    struct StampedJournalEntry;
+}
+
+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
@@ -39,7 +38,7 @@ namespace MWClass
             physics.insertObjectPhysics(ptr, model);
         }
     }
-    
+
     std::string Apparatus::getModel(const MWWorld::Ptr &ptr) const
     {
         MWWorld::LiveCellRef<ESM::Apparatus> *ref =
@@ -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
@@ -42,7 +41,7 @@ namespace MWClass
             physics.insertObjectPhysics(ptr, model);
         }
     }
-    
+
     std::string Armor::getModel(const MWWorld::Ptr &ptr) const
     {
         MWWorld::LiveCellRef<ESM::Armor> *ref =
@@ -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
@@ -38,7 +37,7 @@ namespace MWClass
             physics.insertObjectPhysics(ptr, model);
         }
     }
-    
+
     std::string Book::getModel(const MWWorld::Ptr &ptr) const
     {
         MWWorld::LiveCellRef<ESM::Book> *ref =

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
@@ -40,7 +39,7 @@ namespace MWClass
             physics.insertObjectPhysics(ptr, model);
         }
     }
-    
+
     std::string Clothing::getModel(const MWWorld::Ptr &ptr) const
     {
         MWWorld::LiveCellRef<ESM::Clothing> *ref =
@@ -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
@@ -69,7 +68,7 @@ namespace MWClass
             physics.insertObjectPhysics(ptr, model);
         }
     }
-    
+
     std::string Container::getModel(const MWWorld::Ptr &ptr) const
     {
         MWWorld::LiveCellRef<ESM::Container> *ref =

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
@@ -38,7 +37,7 @@ namespace MWClass
             physics.insertObjectPhysics(ptr, model);
         }
     }
-    
+
     std::string Ingredient::getModel(const MWWorld::Ptr &ptr) const
     {
         MWWorld::LiveCellRef<ESM::Ingredient> *ref =
@@ -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
@@ -40,7 +39,7 @@ namespace MWClass
             physics.insertObjectPhysics(ptr, model);
         }
     }
-    
+
     std::string Lockpick::getModel(const MWWorld::Ptr &ptr) const
     {
         MWWorld::LiveCellRef<ESM::Tool> *ref =
@@ -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
@@ -43,7 +42,7 @@ namespace MWClass
             physics.insertObjectPhysics(ptr, model);
         }
     }
-    
+
     std::string Miscellaneous::getModel(const MWWorld::Ptr &ptr) const
     {
         MWWorld::LiveCellRef<ESM::Miscellaneous> *ref =
@@ -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));
@@ -189,7 +188,7 @@ namespace MWClass
     Miscellaneous::copyToCellImpl(const MWWorld::Ptr &ptr, MWWorld::CellStore &cell) const
     {
         MWWorld::Ptr newPtr;
-        
+
         const ESMS::ESMStore &store =
             MWBase::Environment::get().getWorld()->getStore();
 

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
@@ -40,7 +39,7 @@ namespace MWClass
             physics.insertObjectPhysics(ptr, model);
         }
     }
-    
+
     std::string Probe::getModel(const MWWorld::Ptr &ptr) const
     {
         MWWorld::LiveCellRef<ESM::Probe> *ref =
@@ -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
@@ -38,7 +37,7 @@ namespace MWClass
             physics.insertObjectPhysics(ptr, model);
         }
     }
-    
+
     std::string Repair::getModel(const MWWorld::Ptr &ptr) const
     {
         MWWorld::LiveCellRef<ESM::Repair> *ref =
@@ -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
@@ -40,7 +39,7 @@ namespace MWClass
             physics.insertObjectPhysics(ptr, model);
         }
     }
-    
+
     std::string Weapon::getModel(const MWWorld::Ptr &ptr) const
     {
         MWWorld::LiveCellRef<ESM::Weapon> *ref =
@@ -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,12 +598,12 @@ namespace MWDialogue
         }
     }
 
-    void DialogueManager::addTopic(std::string topic)
+    void DialogueManager::addTopic (const std::string& topic)
     {
         mKnownTopics[toLower(topic)] = true;
     }
 
-    void DialogueManager::parseText(std::string text)
+    void DialogueManager::parseText (std::string text)
     {
         std::list<std::string>::iterator it;
         for(it = mActorKnownTopics.begin();it != mActorKnownTopics.end();++it)
@@ -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())
@@ -882,13 +881,13 @@ namespace MWDialogue
         }
     }
 
-    void DialogueManager::printError(std::string error)
+    void DialogueManager::printError (std::string error)
     {
         MWGui::DialogueWindow* win = MWBase::Environment::get().getWindowManager()->getDialogueWindow();
         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_MMDIALOG_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/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
 #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/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/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/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"
@@ -75,9 +74,9 @@ namespace
         return boost::lexical_cast<std::string>(xaspect) + " : " + boost::lexical_cast<std::string>(yaspect);
     }
 
-    bool hasGLSL ()
+    std::string hlslGlsl ()
     {
-        return (Ogre::Root::getSingleton ().getRenderSystem ()->getName ().find("OpenGL") != std::string::npos);
+        return (Ogre::Root::getSingleton ().getRenderSystem ()->getName ().find("OpenGL") != std::string::npos) ? "glsl" : "hlsl";
     }
 }
 
@@ -393,12 +392,9 @@ namespace MWGui
         std::string val = static_cast<MyGUI::Button*>(_sender)->getCaption();
         if (val == "off")
         {
-            if (hasGLSL ())
+            val = hlslGlsl();
-                val = "glsl";
-            else
-                val = "cg";
         }
-        else if (val == "glsl")
+        else if (val == hlslGlsl())
             val = "cg";
         else
             val = "off";
@@ -411,6 +407,7 @@ namespace MWGui
 
             // water shader not supported with object shaders off
             mWaterShaderButton->setCaptionWithReplacing("#{sOff}");
+            mUnderwaterButton->setCaptionWithReplacing("#{sOff}");
             mWaterShaderButton->setEnabled(false);
             mReflectObjectsButton->setEnabled(false);
             mReflectActorsButton->setEnabled(false);

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

@@ -6,7 +6,6 @@
 #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,12 +15,12 @@
 
 #include <libs/platform/strings.h>
 
+#include "mouselookevent.hpp"
+
 #include "../engine.hpp"
 
 #include "../mwworld/player.hpp"
 
-#include "../mwrender/player.hpp"
-
 #include <boost/bind.hpp>
 #include <boost/filesystem.hpp>
 #include <OgreRoot.h>
@@ -82,7 +81,7 @@ namespace MWInput
     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 +89,7 @@ namespace MWInput
 
     bool mDragDrop;
 
+    std::map<std::string, bool> mControlSwitch;
 
    /* InputImpl Methods */
 public:
@@ -278,8 +278,7 @@ private:
       // 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 +295,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);
 
       /**********************************
@@ -366,38 +373,40 @@ private:
 
         // Configure player movement according to keyboard input. Actual movement will
         // be done in the physics system.
-        if (poller.isDown(A_MoveLeft))
+        if (mControlSwitch["playercontrols"]) {
-        {
+            if (poller.isDown(A_MoveLeft))
-            player.setAutoMove (false);
+            {
-            player.setLeftRight (1);
+                player.setAutoMove (false);
-        }
+                player.setLeftRight (1);
-        else if (poller.isDown(A_MoveRight))
+            }
-        {
+            else if (poller.isDown(A_MoveRight))
-            player.setAutoMove (false);
+            {
-            player.setLeftRight (-1);
+                player.setAutoMove (false);
-        }
+                player.setLeftRight (-1);
-        else
+            }
-            player.setLeftRight (0);
+            else
+                player.setLeftRight (0);
 
-        if (poller.isDown(A_MoveForward))
+            if (poller.isDown(A_MoveForward))
-        {
+            {
-            player.setAutoMove (false);
+                player.setAutoMove (false);
-            player.setForwardBackward (1);
+                player.setForwardBackward (1);
-        }
+            }
-        else if (poller.isDown(A_MoveBackward))
+            else if (poller.isDown(A_MoveBackward))
-        {
+            {
-            player.setAutoMove (false);
+                player.setAutoMove (false);
-            player.setForwardBackward (-1);
+                player.setForwardBackward (-1);
-        }
+            }
-        else
+            else
-            player.setForwardBackward (0);
+                player.setForwardBackward (0);
 
-        if (poller.isDown(A_Jump))
+            if (poller.isDown(A_Jump) && mControlSwitch["playerjumping"])
-            player.setUpDown (1);
+                player.setUpDown (1);
-        else if (poller.isDown(A_Crouch))
+            else if (poller.isDown(A_Crouch))
-            player.setUpDown (-1);
+                player.setUpDown (-1);
-        else
+            else
-            player.setUpDown (0);
+                player.setUpDown (0);
+        }
     }
 
     // Switch between gui modes. Besides controlling the Gui windows
@@ -408,21 +417,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 +506,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

@@ -146,9 +146,10 @@ Actors::updateObjectCell(const MWWorld::Ptr &ptr)
         node = mCellSceneNodes[newCell];
     }
     node->addChild(ptr.getRefData().getBaseNode());
-    if (Animation *anim = mAllActors[ptr]) {
+    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/player.cpp

@@ -1,34 +1,101 @@
-
 #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::SceneNode *sceneNode = mNode;
-            Ogre::Node* yawNode = sceneNode->getChildIterator().getNext();
+        Ogre::Node* yawNode = sceneNode->getChildIterator().getNext();
-            Ogre::Node* pitchNode = yawNode->getChildIterator().getNext();
+        Ogre::Node* pitchNode = yawNode->getChildIterator().getNext();
 
-            // we are only interested in X and Y rotation
+        // we are only interested in X and Y rotation
 
-            // Rotate around X axis
+        // Rotate around X axis
-            Ogre::Quaternion xr(Ogre::Radian(x), Ogre::Vector3::UNIT_X);
+        Ogre::Quaternion xr(Ogre::Degree(rot.x), Ogre::Vector3::UNIT_X);
 
-            // Rotate around Y axis
+        // Rotate around Y axis
-            Ogre::Quaternion yr(Ogre::Radian(-z), Ogre::Vector3::UNIT_Y);
+        Ogre::Quaternion yr(Ogre::Degree(-rot.z), Ogre::Vector3::UNIT_Y);
 
-            pitchNode->setOrientation(xr);
+        pitchNode->setOrientation(xr);
-            yawNode->setOrientation(yr);
+        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::Degree(rot.x));
+        yawNode->yaw(Ogre::Degree(-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,31 @@ namespace MWRender
         Ogre::Camera *mCamera;
         Ogre::SceneNode* mNode;
 
-            public:
+        bool mFirstPersonView;
+        bool mVanityModeEnabled;
 
-                Player (Ogre::Camera *camera, Ogre::SceneNode* mNode);
+        void controlFlip();
+        void updateListener();
 
-                Ogre::Camera *getCamera() { return mCamera; }
+    public:
 
-                /// Set where the player is looking at. Uses Morrowind (euler) angles
+        Player (Ogre::Camera *camera, Ogre::SceneNode* mNode);
-                void setRot(float x, float y, float z);
 
-                std::string getHandle() const;
+        /// Set where the player is looking at. Uses Morrowind (euler) angles
-                Ogre::SceneNode* getNode() {return mNode;}
+        bool setRotation(const Ogre::Vector3 &rot);
+        bool adjustRotation(const Ogre::Vector3 &rot);
+
+        std::string getHandle() const;
+
+        void attachTo(const MWWorld::Ptr &);
+
+        void toggleViewMode() {
+            mFirstPersonView = !mFirstPersonView;
+        }
+
+        void toggleVanityMode() {
+            mVanityModeEnabled = !mVanityModeEnabled;
+        }
     };
 }
 

apps/openmw/mwrender/renderinginterface.hpp

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

apps/openmw/mwrender/renderingmanager.cpp

@@ -43,12 +43,14 @@ RenderingManager::RenderingManager (OEngine::Render::OgreRenderer& _rend, const
     :mRendering(_rend), mObjects(mRendering), mActors(mRendering), mAmbientMode(0), mSunEnabled(0)
 {
     // select best shader mode
-    if (Settings::Manager::getString("shader mode", "General") == "")
+    bool openGL = (Ogre::Root::getSingleton ().getRenderSystem ()->getName().find("OpenGL") != std::string::npos);
+
+    // glsl is only supported in opengl mode and hlsl only in direct3d mode.
+    if (Settings::Manager::getString("shader mode", "General") == ""
+            || (openGL && Settings::Manager::getString("shader mode", "General") == "hlsl")
+            || (!openGL && Settings::Manager::getString("shader mode", "General") == "glsl"))
     {
-        if (Ogre::Root::getSingleton ().getRenderSystem ()->getName().find("OpenGL") == std::string::npos)
+        Settings::Manager::setString("shader mode", "General", openGL ? "glsl" : "hlsl");
-            Settings::Manager::setString("shader mode", "General", "cg");
-        else
-            Settings::Manager::setString("shader mode", "General", "glsl");
     }
 
     mRendering.createScene("PlayerCam", Settings::Manager::getFloat("field of view", "General"), 5);
@@ -74,10 +76,6 @@ RenderingManager::RenderingManager (OEngine::Render::OgreRenderer& _rend, const
     mFactory->setCurrentLanguage (lang);
     mFactory->loadAllFiles();
 
-    //The fog type must be set before any terrain objects are created as if the
-    //fog type is set to FOG_NONE then the initially created terrain won't have any fog
-    configureFog(1, ColourValue(1,1,1));
-
     // Set default mipmap level (NB some APIs ignore this)
     TextureManager::getSingleton().setDefaultNumMipmaps(Settings::Manager::getInt("num mipmaps", "General"));
 
@@ -185,10 +183,6 @@ MWRender::Actors& RenderingManager::getActors(){
     return mActors;
 }
 
-MWRender::Player& RenderingManager::getPlayer(){
-    return (*mPlayer);
-}
-
 OEngine::Render::Fader* RenderingManager::getFader()
 {
     return mRendering.getFader();
@@ -253,8 +247,34 @@ 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)
+{
+    if (ptr.getRefData().getHandle() == "player") {
+        if (adjust) {
+            return mPlayer->adjustRotation(rot);
+        } else {
+            return mPlayer->setRotation(rot);
+        }
+    }
+    MWWorld::Class::get(ptr).adjustRotation(ptr, rot.x, rot.y, rot.z);
+
+    if (adjust) {
+        float *f = ptr.getRefData().getPosition().rot;
+        rot.x += f[0], rot.y += f[1], rot.z += f[2];
+    }
+
+    Ogre::Quaternion xr(Ogre::Degree(rot.x), Ogre::Vector3::UNIT_X);
+    Ogre::Quaternion yr(Ogre::Degree(rot.y), Ogre::Vector3::UNIT_Y);
+    Ogre::Quaternion zr(Ogre::Degree(rot.z), Ogre::Vector3::UNIT_Z);
+
+    ptr.getRefData().getBaseNode()->setOrientation(xr * yr * zr);
+
+    return true;
 }
 
 void
@@ -292,11 +312,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))
@@ -476,13 +505,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)
@@ -787,4 +809,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,9 +85,8 @@ 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);
+    bool rotateObject (const MWWorld::Ptr& ptr, Ogre::Vector3 &rot, bool adjust = false);
 
-    void checkUnderwater();
     void setWaterHeight(const float height);
     void toggleWater();
 

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);
                 }
         };
 
@@ -124,11 +157,11 @@ namespace MWScript
                     {
                         runtime.push(ptr.getRefData().getPosition().pos[0]);
                     }
-                    if(axis == "y")
+                    else if(axis == "y")
                     {
                         runtime.push(ptr.getRefData().getPosition().pos[1]);
                     }
-                    if(axis == "z")
+                    else if(axis == "z")
                     {
                         runtime.push(ptr.getRefData().getPosition().pos[2]);
                     }
@@ -158,11 +191,11 @@ namespace MWScript
                     {
                         MWBase::Environment::get().getWorld()->moveObject(ptr,pos,ay,az);
                     }
-                    if(axis == "y")
+                    else if(axis == "y")
                     {
                         MWBase::Environment::get().getWorld()->moveObject(ptr,ax,pos,az);
                     }
-                    if(axis == "z")
+                    else if(axis == "z")
                     {
                         MWBase::Environment::get().getWorld()->moveObject(ptr,ax,ay,pos);
                     }
@@ -185,11 +218,11 @@ namespace MWScript
                     {
                         runtime.push(ptr.getCellRef().pos.pos[0]);
                     }
-                    if(axis == "y")
+                    else if(axis == "y")
                     {
                         runtime.push(ptr.getCellRef().pos.pos[1]);
                     }
-                    if(axis == "z")
+                    else if(axis == "z")
                     {
                         runtime.push(ptr.getCellRef().pos.pos[2]);
                     }

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/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,23 +134,33 @@ 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::Environment::get().getWorld()->getPlayer().setPos (position.pos[0], position.pos[1], position.pos[2]);
-            MWBase::Environment::get().getWorld()->getPlayer().setRot (position.rot[0], position.rot[1], position.rot[2]);
-        }
-
         MWBase::Environment::get().getWorld()->getPlayer().setCell (cell);
 
-        MWBase::Environment::get().getMechanicsManager()->addActor (MWBase::Environment::get().getWorld()->getPlayer().getPlayer());
+        bool hasWater = cell->cell->data.flags & cell->cell->HasWater;
-        MWBase::Environment::get().getMechanicsManager()->watchActor (MWBase::Environment::get().getWorld()->getPlayer().getPlayer());
+        mPhysics->setCurrentWater(hasWater, cell->cell->water);
 
-        MWBase::Environment::get().getWindowManager()->changeCell( mCurrentCell );
+        MWBase::World *world = MWBase::Environment::get().getWorld();
+        MWWorld::Ptr player = world->getPlayer().getPlayer();
+
+        if (adjustPlayerPos) {
+            world->moveObject(player, pos.pos[0], pos.pos[1], pos.pos[2]);
+            world->rotateObject(player, pos.rot[0], pos.rot[1], pos.rot[2]);
+        }
+        world->getPlayer().setCell(cell);
+
+        MWMechanics::MechanicsManager *mechMgr =
+            MWBase::Environment::get().getMechanicsManager();
+
+        mechMgr->addActor(player);
+        mechMgr->watchActor(player);
+
+        MWBase::Environment::get().getWindowManager()->changeCell(mCurrentCell);
     }
 
     void Scene::changeCell (int X, int Y, const ESM::Position& position, bool adjustPlayerPos)
@@ -224,7 +233,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();
@@ -337,7 +346,7 @@ namespace MWWorld
         mRendering.addObject(ptr);
         MWWorld::Class::get(ptr).insertObject(ptr, *mPhysics);
     }
-   
+
     void Scene::removeObjectFromScene (const Ptr& ptr)
     {
         MWBase::Environment::get().getMechanicsManager()->removeActor (ptr);
@@ -350,10 +359,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/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,80 +543,73 @@ namespace MWWorld
         }
     }
 
-    bool World::moveObjectImp (const Ptr& ptr, float x, float y, float z)
+    void World::moveObject(const Ptr &ptr, CellStore &newCell, float x, float y, float z)
     {
-        bool cellChanged = false, haveToMove = true;
-
         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;
+        CellStore *currCell = ptr.getCell();
-        /// \todo fix assertion fail on player ptr.getCell() on start
+        bool isPlayer = ptr == mPlayer->getPlayer();
-        if (ptr == mPlayer->getPlayer()) {
+        bool haveToMove = mWorldScene->isCellActive(*currCell) || isPlayer;
-            currCell = mWorldScene->getCurrentCell();
-        } else {
-            currCell = ptr.getCell();
-        }
 
-        if (currCell) {
+        if (*currCell != newCell) {
-            if (!(currCell->cell->data.flags & ESM::Cell::Interior)) {
+            if (isPlayer) {
-                // exterior -> adjust loaded cells
+                if (!newCell.isExterior()) {
-                int cellX = 0, cellY = 0;
+                    changeToInteriorCell(newCell.cell->name, pos);
-                positionToIndex (x, y, cellX, cellY);
+                } else {
-
+                    changeToExteriorCell(pos);
-                if (currCell->cell->data.gridX != cellX ||
-                    currCell->cell->data.gridY != cellY)
-                {
-                    if (ptr == mPlayer->getPlayer()) {
-                        mWorldScene->changeCell(cellX, cellY, pos, false);
-                    } else {
-                        CellStore *newCell =
-                            MWBase::Environment::get().getWorld()->getExterior(cellX, cellY);
-
-                        // placeObject() handles both target cell states
-                        // with active current cell
-                        if (!mWorldScene->isCellActive(*currCell)) {
-                            placeObject(ptr, *newCell, pos);
-                            haveToMove = false;
-                        } else if (!mWorldScene->isCellActive(*newCell)) {
-                            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);
-                    }
-                    cellChanged = true;
                 }
+            } 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);
         }
-        return cellChanged;
+    }
+
+    bool World::moveObjectImp(const Ptr& ptr, float x, float y, float z)
+    {
+        CellStore *cell = ptr.getCell();
+        if (cell->isExterior()) {
+            int cellX, cellY;
+            positionToIndex(x, y, cellX, cellY);
+        
+            cell = getExterior(cellX, cellY);
+        }
+        moveObject(ptr, *cell, x, y, z);
+       
+        return cell != ptr.getCell();
     }
 
     void World::moveObject (const Ptr& ptr, float x, float y, float z)
@@ -634,19 +627,20 @@ 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(x, y, z);
+        if (mRendering->rotateObject(ptr, rot, adjust)) {
+            float *objRot = ptr.getRefData().getPosition().rot;
+            objRot[0] = Ogre::Degree(rot.x).valueRadians();
+            objRot[1] = Ogre::Degree(rot.y).valueRadians();
+            objRot[2] = Ogre::Degree(rot.z).valueRadians();
 
-        ptr.getRefData().getPosition().rot[0] = Ogre::Degree(x).valueRadians();
+            mPhysics->rotateObject(
-        ptr.getRefData().getPosition().rot[1] = Ogre::Degree(y).valueRadians();
+                ptr.getRefData().getHandle(),
-        ptr.getRefData().getPosition().rot[2] = Ogre::Degree(z).valueRadians();
+                ptr.getRefData().getBaseNode()->getOrientation()
-
+            );
-        Ogre::Quaternion rotx(Ogre::Degree(x),Ogre::Vector3::UNIT_X);
+        }
-        Ogre::Quaternion roty(Ogre::Degree(y),Ogre::Vector3::UNIT_Y);
-        Ogre::Quaternion rotz(Ogre::Degree(z),Ogre::Vector3::UNIT_Z);
-        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
@@ -1057,7 +1051,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;
@@ -1075,7 +1069,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 =
@@ -1110,7 +1104,7 @@ namespace MWWorld
         Ogre::Vector3 orig =
             Ogre::Vector3(pos.pos[0], pos.pos[1], pos.pos[2]);
         Ogre::Vector3 dir = Ogre::Vector3(0, 0, -1);
-        
+
         float len = (pos.pos[2] >= 0) ? pos.pos[2] : -pos.pos[2];
         len += 100.0;
 
@@ -1118,7 +1112,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);
     }
 
@@ -1131,4 +1125,26 @@ 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,11 @@ 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);
+            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 +271,9 @@ 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
-SEPARATE_ARGUMENTS(MYGUI_INCLUDE_DIRS)
+IF (NOT WIN32) # This does not work on Windows for paths with spaces in them
-SEPARATE_ARGUMENTS(MYGUI_LIBRARIES)
+	SEPARATE_ARGUMENTS(MYGUI_INCLUDE_DIRS)
-SEPARATE_ARGUMENTS(MYGUI_PLATFORM_LIBRARIES)
+	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;
+    }
+}
+
+}

components/files/ogreplugin.hpp

@@ -0,0 +1,64 @@
+/**
+ *  Open Morrowind - an opensource Elder Scrolls III: Morrowind
+ *  engine implementation.
+ *
+ *  Copyright (C) 2011 Open Morrowind Team
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/** \file components/files/ogreplugin.hpp */
+
+#ifndef COMPONENTS_FILES_OGREPLUGIN_H
+#define COMPONENTS_FILES_OGREPLUGIN_H
+
+#include <string>
+
+#include <boost/filesystem.hpp>
+#include <boost/version.hpp>
+
+namespace Ogre {
+	class Root;
+}
+
+#if (BOOST_VERSION <= 104500)
+namespace boost {
+namespace filesystem {
+inline path absolute(const path& p, const path& base=current_path()) {
+	// call obsolete version of this function on older boost
+	return complete(p, base);
+}
+}
+}
+#endif /* (BOOST_VERSION <= 104300) */
+
+/**
+ * \namespace Files
+ */
+namespace Files {
+
+/**
+ * \brief Loads Ogre plugin with given name.
+ *
+ * \param pluginDir absolute path to plugins
+ * \param pluginName plugin name, for example "RenderSystem_GL"
+ * \param ogreRoot Ogre::Root instance
+ *
+ * \return whether plugin was located or not
+ */
+bool loadOgrePlugin(const std::string &pluginDir, std::string pluginName, Ogre::Root &ogreRoot);
+
+}
+
+#endif /* COMPONENTS_FILES_OGREPLUGIN_H */

components/nif/nif_file.hpp

@@ -37,6 +37,8 @@
 #include <vector>
 #include <cassert>
 
+#include <libs/platform/stdint.h>
+
 #include "record.hpp"
 #include "nif_types.hpp"
 

credits.txt

@@ -14,6 +14,7 @@ Jason “jhooks” Hooks
 Karl-Felix “k1ll” Glatzer
 Lukasz “lgro” Gromanowski
 Marc “Zini” Zinnschlag
+Michael Mc Donnell
 Michael “werdanith” Papageorgiou
 Nikolay “corristo” Kasyanov
 Pieter “pvdk” van der Kloet

files/materials/core.h

@@ -1,20 +1,20 @@
-#if SH_HLSL == 1
+#if SH_HLSL == 1 || SH_CG == 1
-    #error "HLSL is unsupported"
-#endif
-
-#if SH_CG == 1
 
     #define shTexture2D sampler2D
     #define shSample(tex, coord) tex2D(tex, coord)
+    #define shCubicSample(tex, coord) texCUBE(tex, coord)
     #define shLerp(a, b, t) lerp(a, b, t)
     #define shSaturate(a) saturate(a)
 
     #define shSampler2D(name) , uniform sampler2D name : register(s@shCounter(0)) @shUseSampler(name)
+    
+    #define shSamplerCube(name) , uniform samplerCUBE name : register(s@shCounter(0)) @shUseSampler(name)
 
     #define shMatrixMult(m, v) mul(m, v)
 
     #define shUniform(type, name) , uniform type name
 
+    #define shTangentInput(type) , in type tangent : TANGENT
     #define shVertexInput(type, name) , in type name : TEXCOORD@shCounter(1)
     #define shInput(type, name) , in type name : TEXCOORD@shCounter(1)
     #define shOutput(type, name) , out type name : TEXCOORD@shCounter(2)
@@ -65,9 +65,10 @@
     #define float4 vec4
     #define int2 ivec2
     #define int3 ivec3
-    #define int4 ivec4/
+    #define int4 ivec4
     #define shTexture2D sampler2D
     #define shSample(tex, coord) texture2D(tex, coord)
+    #define shCubicSample(tex, coord) textureCube(tex, coord)
     #define shLerp(a, b, t) mix(a, b, t)
     #define shSaturate(a) clamp(a, 0.0, 1.0)
 
@@ -75,11 +76,14 @@
 
     #define shSampler2D(name) uniform sampler2D name; @shUseSampler(name)
 
+    #define shSamplerCube(name) uniform samplerCube name; @shUseSampler(name)
+
     #define shMatrixMult(m, v) (m * v)
 
     #define shOutputPosition gl_Position
 
     #define float4x4 mat4
+    #define float3x3 mat3
     
     // GLSL 1.3
     #if 0
@@ -89,8 +93,8 @@
 
     #define shOutputColour(num) oColor##num
 
-
+    #define shTangentInput(type) in type tangent;
-
+    #define shVertexInput(type, name) in type name;
     #define shInput(type, name) in type name;
     #define shOutput(type, name) out type name;
 
@@ -101,7 +105,7 @@
     #ifdef SH_VERTEX_SHADER
 
         #define SH_BEGIN_PROGRAM \
-            in float4 shInputPosition;
+            in float4 vertex;
         #define SH_START_PROGRAM \
             void main(void)
 
@@ -126,10 +130,11 @@
     #if 1
     
     // automatically recognized by ogre when the input name equals this
-    #define shInputPosition gl_Vertex
+    #define shInputPosition vertex
 
     #define shOutputColour(num) gl_FragData[num]
 
+    #define shTangentInput(type) attribute type tangent;
     #define shVertexInput(type, name) attribute type name;
     #define shInput(type, name) varying type name;
     #define shOutput(type, name) varying type name;
@@ -140,8 +145,8 @@
 
     #ifdef SH_VERTEX_SHADER
 
-        #define SH_BEGIN_PROGRAM 
+        #define SH_BEGIN_PROGRAM \
-
+            attribute vec4 vertex; 
         #define SH_START_PROGRAM \
             void main(void)
 

files/materials/objects.shaderset

@@ -3,7 +3,7 @@ shader_set openmw_objects_vertex
     source objects.shader
     type vertex
     profiles_cg vs_2_0 vp40 arbvp1
-    profiles_hlsl vs_2_0
+    profiles_hlsl vs_3_0 vs_2_0
 }
 
 shader_set openmw_objects_fragment
@@ -11,5 +11,5 @@ shader_set openmw_objects_fragment
     source objects.shader
     type fragment
     profiles_cg ps_3_0 ps_2_x ps_2_0 fp40 arbfp1
-    profiles_hlsl ps_2_0
+    profiles_hlsl ps_3_0 ps_2_0
 }

files/materials/terrain.shaderset

@@ -3,7 +3,7 @@ shader_set terrain_vertex
     source terrain.shader
     type vertex
     profiles_cg vs_2_0 vp40 arbvp1
-    profiles_hlsl vs_2_0
+    profiles_hlsl vs_3_0 vs_2_0
 }
 
 shader_set terrain_fragment
@@ -11,5 +11,5 @@ shader_set terrain_fragment
     source terrain.shader
     type fragment
     profiles_cg ps_3_0 ps_2_x ps_2_0 fp40 arbfp1
-    profiles_hlsl ps_2_0
+    profiles_hlsl ps_3_0 ps_2_0
 }

files/materials/underwater.h

@@ -28,7 +28,7 @@ float3 intercept(float3 lineP,
 
 float3 perturb1(shTexture2D tex, float2 coords, float bend, float2 windDir, float windSpeed, float timer)
 {
-    float2 nCoord = float2(0.0);
+    float2 nCoord = float2(0,0);
     bend *= WAVE_CHOPPYNESS;
   	nCoord = coords * (WAVE_SCALE * 0.05) + windDir * timer * (windSpeed*0.04);
     float3 normal0 = 2.0 * shSample(tex, nCoord + float2(-timer*0.015,-timer*0.05)).rgb - 1.0;
@@ -55,8 +55,8 @@ float3 perturb1(shTexture2D tex, float2 coords, float bend, float2 windDir, floa
 float3 perturb(shTexture2D tex, float2 coords, float bend, float2 windDir, float windSpeed, float timer)
 {
     bend *= WAVE_CHOPPYNESS;
-    float3 col = float3(0.0);
+    float3 col = float3(0,0,0);
-    float2 nCoord = float2(0.0); //normal coords
+    float2 nCoord = float2(0,0); //normal coords
 
     nCoord = coords * (WAVE_SCALE * 0.025) + windDir * timer * (windSpeed*0.03);
     col += shSample(tex,nCoord + float2(-timer*0.005,-timer*0.01)).rgb*0.20;
@@ -102,11 +102,11 @@ float3 getCaustics (shTexture2D causticMap, float3 worldPos, float3 waterEyePos,
     /// \todo sunFade
     
    // float3 caustics = clamp(pow(float3(causticR)*5.5,float3(5.5*causticdepth)),0.0,1.0)*NdotL*sunFade*causticdepth;
-    float3 caustics = clamp(pow(float3(causticR)*5.5,float3(5.5*causticdepth)),0.0,1.0)*NdotL*causticdepth;
+    float3 caustics = clamp(pow(float3(causticR,causticR,causticR)*5.5,float3(5.5*causticdepth,5.5*causticdepth,5.5*causticdepth)),0.0,1.0)*NdotL*causticdepth;
     float causticG = 1.0-perturb(causticMap,causticPos.xz+(1.0-causticdepth)*ABBERATION, causticdepth, windDir_windSpeed.xy, windDir_windSpeed.z, waterTimer).z;
     float causticB = 1.0-perturb(causticMap,causticPos.xz+(1.0-causticdepth)*ABBERATION*2.0, causticdepth, windDir_windSpeed.xy, windDir_windSpeed.z, waterTimer).z;
     //caustics = shSaturate(pow(float3(causticR,causticG,causticB)*5.5,float3(5.5*causticdepth)))*NdotL*sunFade*causticdepth;
-                caustics = shSaturate(pow(float3(causticR,causticG,causticB)*5.5,float3(5.5*causticdepth)))*NdotL*causticdepth;
+                caustics = shSaturate(pow(float3(causticR,causticG,causticB)*5.5,float3(5.5*causticdepth,5.5*causticdepth,5.5*causticdepth)))*NdotL*causticdepth;
 
     caustics *= 3;
     

files/materials/water.shader

@@ -198,7 +198,7 @@
         float depth = shSample(depthMap, screenCoords).x * far - depthPassthrough;
         float shoreFade = shSaturate(depth / 50.0);
 
-	    float2 nCoord = float2(0.0);
+	    float2 nCoord = float2(0,0);
 
       	nCoord = UV * (WAVE_SCALE * 0.05) + WIND_DIR * waterTimer * (WIND_SPEED*0.04);
 	    float3 normal0 = 2.0 * shSample(normalMap, nCoord + float2(-waterTimer*0.015,-waterTimer*0.005)).rgb - 1.0;
@@ -238,12 +238,12 @@
         
         // sunlight scattering
         float3 pNormal = float3(0,1,0);
-    	vec3 lR = reflect(lVec, lNormal);
+    	float3 lR = reflect(lVec, lNormal);
-        vec3 llR = reflect(lVec, pNormal);
+        float3 llR = reflect(lVec, pNormal);
         
         float s = shSaturate(dot(lR, vVec)*2.0-1.2);
         float lightScatter = shSaturate(dot(-lVec,lNormal)*0.7+0.3) * s * SCATTER_AMOUNT * waterSunFade_sunHeight.x * shSaturate(1.0-exp(-waterSunFade_sunHeight.y));
-        float3 scatterColour = shLerp(vec3(SCATTER_COLOUR)*vec3(1.0,0.4,0.0), SCATTER_COLOUR, shSaturate(1.0-exp(-waterSunFade_sunHeight.y*SUN_EXT)));
+        float3 scatterColour = shLerp(float3(SCATTER_COLOUR)*float3(1.0,0.4,0.0), SCATTER_COLOUR, shSaturate(1.0-exp(-waterSunFade_sunHeight.y*SUN_EXT)));
 
         // fresnel
         float ior = (cameraPos.y>0)?(1.333/1.0):(1.0/1.333); //air to water; water to air
@@ -284,7 +284,7 @@
             waterGradient = clamp((waterGradient*0.5+0.5),0.2,1.0);
             float3 watercolour = (float3(0.0078, 0.5176, 0.700)+waterSunColour)*waterGradient*2.0;
             float3 waterext = float3(0.6, 0.9, 1.0);//water extinction
-            watercolour = mix(watercolour*0.3*waterSunFade_sunHeight.x, watercolour, shSaturate(1.0-exp(-waterSunFade_sunHeight.y*SUN_EXT)));
+            watercolour = shLerp(watercolour*0.3*waterSunFade_sunHeight.x, watercolour, shSaturate(1.0-exp(-waterSunFade_sunHeight.y*SUN_EXT)));
         
             float darkness = VISIBILITY*2.0;
             darkness = clamp((cameraPos.y+darkness)/darkness,0.2,1.0);
@@ -299,6 +299,7 @@
             shOutputColour(0).xyz = shLerp (shOutputColour(0).xyz, fogColor, fogValue);
         }
 
+		shOutputColour(0).w = 1;
     }
 
 #endif

files/materials/water.shaderset

@@ -3,7 +3,7 @@ shader_set water_vertex
     source water.shader
     type vertex
     profiles_cg vs_2_0 vp40 arbvp1
-    profiles_hlsl vs_2_0
+    profiles_hlsl vs_3_0 vs_2_0
 }
 
 shader_set water_fragment
@@ -11,5 +11,5 @@ shader_set water_fragment
     source water.shader
     type fragment
     profiles_cg ps_2_x ps_2_0 ps fp40 arbfp1
-    profiles_hlsl ps_2_0
+    profiles_hlsl ps_3_0 ps_2_0
 }

libs/openengine/ogre/renderer.cpp

@@ -11,6 +11,8 @@
 
 #include <boost/filesystem.hpp>
 
+#include <components/files/ogreplugin.hpp>
+
 #include <cassert>
 #include <cstdlib>
 #include <stdexcept>
@@ -111,17 +113,13 @@ void OgreRenderer::configure(const std::string &logPath,
 #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"))
-        mRoot->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"))
-        mRoot->loadPlugin (dxPlugin);
 
-    std::string cgPlugin = std::string(pluginDir) + "/Plugin_CgProgramManager" + OGRE_PLUGIN_DEBUG_SUFFIX;
+    Files::loadOgrePlugin(pluginDir, "RenderSystem_GL", *mRoot);
-    if (boost::filesystem::exists(cgPlugin + ".so") || boost::filesystem::exists(cgPlugin + ".dll"))
+    Files::loadOgrePlugin(pluginDir, "RenderSystem_Direct3D9", *mRoot);
-        mRoot->loadPlugin (cgPlugin);
+    Files::loadOgrePlugin(pluginDir, "Plugin_CgProgramManager", *mRoot);
 
     RenderSystem* rs = mRoot->getRenderSystemByName(renderSystem);
     if (rs == 0)
@@ -143,7 +141,7 @@ void OgreRenderer::createWindow(const std::string &title, const WindowSettings&
 
     // create the semi-transparent black background texture used by the GUI.
     // has to be created in code with TU_DYNAMIC_WRITE_ONLY_DISCARDABLE param
-    // so that it can be modified at runtime. 
+    // so that it can be modified at runtime.
     Ogre::TextureManager::getSingleton().createManual(
                     "transparent.png",
                     Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,