resolving conflicts

pull/21/head
greye 13 years ago
commit 38b06aee6c

@ -37,6 +37,9 @@ option(USE_FFMPEG "use ffmpeg for sound" OFF)
option(USE_AUDIERE "use audiere for sound" OFF) option(USE_AUDIERE "use audiere for sound" OFF)
option(USE_MPG123 "use mpg123 + libsndfile for sound" ON) 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") find_program(DPKG_PROGRAM dpkg DOC "dpkg program of Debian-based systems")
# Location of morrowind data files # Location of morrowind data files
@ -230,22 +233,46 @@ if (APPLE)
${OGRE_Plugin_OctreeSceneManager_LIBRARY_REL} ${OGRE_Plugin_OctreeSceneManager_LIBRARY_REL}
${OGRE_Plugin_CgProgramManager_LIBRARY_REL} ${OGRE_Plugin_CgProgramManager_LIBRARY_REL}
${OGRE_Plugin_ParticleFX_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) endif (APPLE)
# Set up Ogre plugin folder & debug suffix # 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() endif()
add_definitions(-DOGRE_PLUGIN_DIR_REL="${OGRE_PLUGIN_DIR_REL}") 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_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/) add_subdirectory(files/)
@ -278,35 +305,6 @@ if (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
"${OpenMW_BINARY_DIR}/openmw.desktop") "${OpenMW_BINARY_DIR}/openmw.desktop")
endif() 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 # Compiler settings
if (CMAKE_COMPILER_IS_GNUCC) if (CMAKE_COMPILER_IS_GNUCC)
add_definitions (-Wall -Wextra -Wno-unused-parameter -Wno-reorder) add_definitions (-Wall -Wextra -Wno-unused-parameter -Wno-reorder)

@ -6,6 +6,7 @@
#include <boost/filesystem.hpp> #include <boost/filesystem.hpp>
#include <components/files/configurationmanager.hpp> #include <components/files/configurationmanager.hpp>
#include <components/files/ogreplugin.hpp>
#include <components/settings/settings.hpp> #include <components/settings/settings.hpp>
#include "graphicspage.hpp" #include "graphicspage.hpp"
@ -115,13 +116,12 @@ bool GraphicsPage::setupOgre()
#endif #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 #ifdef ENABLE_PLUGIN_GL
mGLPlugin = new Ogre::GLPlugin(); mGLPlugin = new Ogre::GLPlugin();

@ -21,6 +21,7 @@ add_openmw_dir (mwrender
add_openmw_dir (mwinput add_openmw_dir (mwinput
inputmanager inputmanager
mouselookevent
) )
add_openmw_dir (mwgui add_openmw_dir (mwgui
@ -32,18 +33,18 @@ add_openmw_dir (mwgui
) )
add_openmw_dir (mwdialogue add_openmw_dir (mwdialogue
dialoguemanager journal journalentry quest topic dialoguemanagerimp journalimp journalentry quest topic
) )
add_openmw_dir (mwscript add_openmw_dir (mwscript
locals scriptmanager compilercontext interpretercontext cellextensions miscextensions locals scriptmanagerimp compilercontext interpretercontext cellextensions miscextensions
guiextensions soundextensions skyextensions statsextensions containerextensions guiextensions soundextensions skyextensions statsextensions containerextensions
aiextensions controlextensions extensions globalscripts ref dialogueextensions aiextensions controlextensions extensions globalscripts ref dialogueextensions
animationextensions transformationextensions consoleextensions userextensions animationextensions transformationextensions consoleextensions userextensions
) )
add_openmw_dir (mwsound 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 add_openmw_dir (mwworld
@ -64,7 +65,7 @@ add_openmw_dir (mwmechanics
) )
add_openmw_dir (mwbase add_openmw_dir (mwbase
environment world environment world scriptmanager dialoguemanager journal soundmanager
) )
# Main executable # Main executable

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

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

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

@ -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

@ -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

@ -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

@ -46,6 +46,7 @@ namespace MWWorld
namespace MWBase namespace MWBase
{ {
/// \brief Interface for the World (implemented in MWWorld)
class World class World
{ {
World (const World&); World (const World&);
@ -54,14 +55,6 @@ namespace MWBase
World& operator= (const World&); World& operator= (const World&);
///< not implemented ///< not implemented
protected:
virtual void
copyObjectToCell(
const MWWorld::Ptr &ptr,
MWWorld::CellStore &cell,
const ESM::Position &pos) = 0;
public: public:
enum RenderMode enum RenderMode
@ -189,7 +182,7 @@ namespace MWBase
virtual void scaleObject (const MWWorld::Ptr& ptr, float scale) = 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) virtual void indexToPosition (int cellX, int cellY, float &x, float &y, bool centre = false)
const = 0; const = 0;
@ -252,6 +245,9 @@ namespace MWBase
///< @return true if it is possible to place on object at specified cursor location ///< @return true if it is possible to place on object at specified cursor location
virtual void processChangedSettings (const Settings::CategorySettingVector& settings) = 0; 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;
}; };
} }

@ -5,6 +5,7 @@
#include "../mwbase/environment.hpp" #include "../mwbase/environment.hpp"
#include "../mwbase/world.hpp" #include "../mwbase/world.hpp"
#include "../mwbase/soundmanager.hpp"
#include "../mwworld/ptr.hpp" #include "../mwworld/ptr.hpp"
#include "../mwworld/actiontake.hpp" #include "../mwworld/actiontake.hpp"
@ -18,8 +19,6 @@
#include "../mwgui/window_manager.hpp" #include "../mwgui/window_manager.hpp"
#include "../mwgui/tooltips.hpp" #include "../mwgui/tooltips.hpp"
#include "../mwsound/soundmanager.hpp"
namespace MWClass namespace MWClass
{ {
void Apparatus::insertObjectRendering (const MWWorld::Ptr& ptr, MWRender::RenderingInterface& renderingInterface) const void Apparatus::insertObjectRendering (const MWWorld::Ptr& ptr, MWRender::RenderingInterface& renderingInterface) const
@ -39,7 +38,7 @@ namespace MWClass
physics.insertObjectPhysics(ptr, model); physics.insertObjectPhysics(ptr, model);
} }
} }
std::string Apparatus::getModel(const MWWorld::Ptr &ptr) const std::string Apparatus::getModel(const MWWorld::Ptr &ptr) const
{ {
MWWorld::LiveCellRef<ESM::Apparatus> *ref = MWWorld::LiveCellRef<ESM::Apparatus> *ref =
@ -64,7 +63,7 @@ namespace MWClass
boost::shared_ptr<MWWorld::Action> Apparatus::activate (const MWWorld::Ptr& ptr, boost::shared_ptr<MWWorld::Action> Apparatus::activate (const MWWorld::Ptr& ptr,
const MWWorld::Ptr& actor) const 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> ( return boost::shared_ptr<MWWorld::Action> (
new MWWorld::ActionTake (ptr)); new MWWorld::ActionTake (ptr));

@ -7,6 +7,7 @@
#include "../mwbase/environment.hpp" #include "../mwbase/environment.hpp"
#include "../mwbase/world.hpp" #include "../mwbase/world.hpp"
#include "../mwbase/soundmanager.hpp"
#include "../mwworld/ptr.hpp" #include "../mwworld/ptr.hpp"
#include "../mwworld/actiontake.hpp" #include "../mwworld/actiontake.hpp"
@ -21,8 +22,6 @@
#include "../mwgui/window_manager.hpp" #include "../mwgui/window_manager.hpp"
#include "../mwgui/tooltips.hpp" #include "../mwgui/tooltips.hpp"
#include "../mwsound/soundmanager.hpp"
namespace MWClass namespace MWClass
{ {
void Armor::insertObjectRendering (const MWWorld::Ptr& ptr, MWRender::RenderingInterface& renderingInterface) const void Armor::insertObjectRendering (const MWWorld::Ptr& ptr, MWRender::RenderingInterface& renderingInterface) const
@ -42,7 +41,7 @@ namespace MWClass
physics.insertObjectPhysics(ptr, model); physics.insertObjectPhysics(ptr, model);
} }
} }
std::string Armor::getModel(const MWWorld::Ptr &ptr) const std::string Armor::getModel(const MWWorld::Ptr &ptr) const
{ {
MWWorld::LiveCellRef<ESM::Armor> *ref = MWWorld::LiveCellRef<ESM::Armor> *ref =
@ -67,7 +66,7 @@ namespace MWClass
boost::shared_ptr<MWWorld::Action> Armor::activate (const MWWorld::Ptr& ptr, boost::shared_ptr<MWWorld::Action> Armor::activate (const MWWorld::Ptr& ptr,
const MWWorld::Ptr& actor) const 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> ( return boost::shared_ptr<MWWorld::Action> (
new MWWorld::ActionTake (ptr)); new MWWorld::ActionTake (ptr));

@ -5,6 +5,7 @@
#include "../mwbase/environment.hpp" #include "../mwbase/environment.hpp"
#include "../mwbase/world.hpp" #include "../mwbase/world.hpp"
#include "../mwbase/soundmanager.hpp"
#include "../mwworld/ptr.hpp" #include "../mwworld/ptr.hpp"
#include "../mwworld/actionread.hpp" #include "../mwworld/actionread.hpp"
@ -17,8 +18,6 @@
#include "../mwgui/window_manager.hpp" #include "../mwgui/window_manager.hpp"
#include "../mwgui/tooltips.hpp" #include "../mwgui/tooltips.hpp"
#include "../mwsound/soundmanager.hpp"
namespace MWClass namespace MWClass
{ {
void Book::insertObjectRendering (const MWWorld::Ptr& ptr, MWRender::RenderingInterface& renderingInterface) const void Book::insertObjectRendering (const MWWorld::Ptr& ptr, MWRender::RenderingInterface& renderingInterface) const
@ -38,7 +37,7 @@ namespace MWClass
physics.insertObjectPhysics(ptr, model); physics.insertObjectPhysics(ptr, model);
} }
} }
std::string Book::getModel(const MWWorld::Ptr &ptr) const std::string Book::getModel(const MWWorld::Ptr &ptr) const
{ {
MWWorld::LiveCellRef<ESM::Book> *ref = MWWorld::LiveCellRef<ESM::Book> *ref =

@ -5,6 +5,7 @@
#include "../mwbase/environment.hpp" #include "../mwbase/environment.hpp"
#include "../mwbase/world.hpp" #include "../mwbase/world.hpp"
#include "../mwbase/soundmanager.hpp"
#include "../mwworld/ptr.hpp" #include "../mwworld/ptr.hpp"
#include "../mwworld/actiontake.hpp" #include "../mwworld/actiontake.hpp"
@ -19,8 +20,6 @@
#include "../mwrender/objects.hpp" #include "../mwrender/objects.hpp"
#include "../mwrender/renderinginterface.hpp" #include "../mwrender/renderinginterface.hpp"
#include "../mwsound/soundmanager.hpp"
namespace MWClass namespace MWClass
{ {
void Clothing::insertObjectRendering (const MWWorld::Ptr& ptr, MWRender::RenderingInterface& renderingInterface) const void Clothing::insertObjectRendering (const MWWorld::Ptr& ptr, MWRender::RenderingInterface& renderingInterface) const
@ -40,7 +39,7 @@ namespace MWClass
physics.insertObjectPhysics(ptr, model); physics.insertObjectPhysics(ptr, model);
} }
} }
std::string Clothing::getModel(const MWWorld::Ptr &ptr) const std::string Clothing::getModel(const MWWorld::Ptr &ptr) const
{ {
MWWorld::LiveCellRef<ESM::Clothing> *ref = MWWorld::LiveCellRef<ESM::Clothing> *ref =
@ -65,7 +64,7 @@ namespace MWClass
boost::shared_ptr<MWWorld::Action> Clothing::activate (const MWWorld::Ptr& ptr, boost::shared_ptr<MWWorld::Action> Clothing::activate (const MWWorld::Ptr& ptr,
const MWWorld::Ptr& actor) const 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> ( return boost::shared_ptr<MWWorld::Action> (
new MWWorld::ActionTake (ptr)); new MWWorld::ActionTake (ptr));

@ -5,6 +5,7 @@
#include "../mwbase/environment.hpp" #include "../mwbase/environment.hpp"
#include "../mwbase/world.hpp" #include "../mwbase/world.hpp"
#include "../mwbase/soundmanager.hpp"
#include "../mwworld/ptr.hpp" #include "../mwworld/ptr.hpp"
#include "../mwworld/nullaction.hpp" #include "../mwworld/nullaction.hpp"
@ -20,8 +21,6 @@
#include "../mwrender/objects.hpp" #include "../mwrender/objects.hpp"
#include "../mwrender/renderinginterface.hpp" #include "../mwrender/renderinginterface.hpp"
#include "../mwsound/soundmanager.hpp"
namespace namespace
{ {
struct CustomData : public MWWorld::CustomData struct CustomData : public MWWorld::CustomData
@ -69,7 +68,7 @@ namespace MWClass
physics.insertObjectPhysics(ptr, model); physics.insertObjectPhysics(ptr, model);
} }
} }
std::string Container::getModel(const MWWorld::Ptr &ptr) const std::string Container::getModel(const MWWorld::Ptr &ptr) const
{ {
MWWorld::LiveCellRef<ESM::Container> *ref = MWWorld::LiveCellRef<ESM::Container> *ref =

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

@ -5,6 +5,7 @@
#include "../mwbase/environment.hpp" #include "../mwbase/environment.hpp"
#include "../mwbase/world.hpp" #include "../mwbase/world.hpp"
#include "../mwbase/soundmanager.hpp"
#include "../mwworld/ptr.hpp" #include "../mwworld/ptr.hpp"
#include "../mwworld/actiontake.hpp" #include "../mwworld/actiontake.hpp"
@ -17,8 +18,6 @@
#include "../mwrender/objects.hpp" #include "../mwrender/objects.hpp"
#include "../mwrender/renderinginterface.hpp" #include "../mwrender/renderinginterface.hpp"
#include "../mwsound/soundmanager.hpp"
namespace MWClass namespace MWClass
{ {
void Ingredient::insertObjectRendering (const MWWorld::Ptr& ptr, MWRender::RenderingInterface& renderingInterface) const void Ingredient::insertObjectRendering (const MWWorld::Ptr& ptr, MWRender::RenderingInterface& renderingInterface) const
@ -38,7 +37,7 @@ namespace MWClass
physics.insertObjectPhysics(ptr, model); physics.insertObjectPhysics(ptr, model);
} }
} }
std::string Ingredient::getModel(const MWWorld::Ptr &ptr) const std::string Ingredient::getModel(const MWWorld::Ptr &ptr) const
{ {
MWWorld::LiveCellRef<ESM::Ingredient> *ref = MWWorld::LiveCellRef<ESM::Ingredient> *ref =
@ -63,7 +62,7 @@ namespace MWClass
boost::shared_ptr<MWWorld::Action> Ingredient::activate (const MWWorld::Ptr& ptr, boost::shared_ptr<MWWorld::Action> Ingredient::activate (const MWWorld::Ptr& ptr,
const MWWorld::Ptr& actor) const 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> ( return boost::shared_ptr<MWWorld::Action> (
new MWWorld::ActionTake (ptr)); new MWWorld::ActionTake (ptr));

@ -5,6 +5,7 @@
#include "../mwbase/environment.hpp" #include "../mwbase/environment.hpp"
#include "../mwbase/world.hpp" #include "../mwbase/world.hpp"
#include "../mwbase/soundmanager.hpp"
#include "../mwworld/ptr.hpp" #include "../mwworld/ptr.hpp"
#include "../mwworld/actiontake.hpp" #include "../mwworld/actiontake.hpp"
@ -17,8 +18,6 @@
#include "../mwgui/window_manager.hpp" #include "../mwgui/window_manager.hpp"
#include "../mwgui/tooltips.hpp" #include "../mwgui/tooltips.hpp"
#include "../mwsound/soundmanager.hpp"
#include "../mwrender/objects.hpp" #include "../mwrender/objects.hpp"
#include "../mwrender/renderinginterface.hpp" #include "../mwrender/renderinginterface.hpp"
@ -58,7 +57,7 @@ namespace MWClass
physics.insertObjectPhysics(ptr, "meshes\\" + model); physics.insertObjectPhysics(ptr, "meshes\\" + model);
} }
if (!ref->base->sound.empty()) { 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)) if (!(ref->base->data.flags & ESM::Light::Carry))
return boost::shared_ptr<MWWorld::Action> (new MWWorld::NullAction); 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> ( return boost::shared_ptr<MWWorld::Action> (
new MWWorld::ActionTake (ptr)); new MWWorld::ActionTake (ptr));

@ -5,6 +5,7 @@
#include "../mwbase/environment.hpp" #include "../mwbase/environment.hpp"
#include "../mwbase/world.hpp" #include "../mwbase/world.hpp"
#include "../mwbase/soundmanager.hpp"
#include "../mwworld/ptr.hpp" #include "../mwworld/ptr.hpp"
#include "../mwworld/actiontake.hpp" #include "../mwworld/actiontake.hpp"
@ -19,8 +20,6 @@
#include "../mwrender/objects.hpp" #include "../mwrender/objects.hpp"
#include "../mwrender/renderinginterface.hpp" #include "../mwrender/renderinginterface.hpp"
#include "../mwsound/soundmanager.hpp"
namespace MWClass namespace MWClass
{ {
void Lockpick::insertObjectRendering (const MWWorld::Ptr& ptr, MWRender::RenderingInterface& renderingInterface) const void Lockpick::insertObjectRendering (const MWWorld::Ptr& ptr, MWRender::RenderingInterface& renderingInterface) const
@ -40,7 +39,7 @@ namespace MWClass
physics.insertObjectPhysics(ptr, model); physics.insertObjectPhysics(ptr, model);
} }
} }
std::string Lockpick::getModel(const MWWorld::Ptr &ptr) const std::string Lockpick::getModel(const MWWorld::Ptr &ptr) const
{ {
MWWorld::LiveCellRef<ESM::Tool> *ref = MWWorld::LiveCellRef<ESM::Tool> *ref =
@ -65,7 +64,7 @@ namespace MWClass
boost::shared_ptr<MWWorld::Action> Lockpick::activate (const MWWorld::Ptr& ptr, boost::shared_ptr<MWWorld::Action> Lockpick::activate (const MWWorld::Ptr& ptr,
const MWWorld::Ptr& actor) const 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> ( return boost::shared_ptr<MWWorld::Action> (
new MWWorld::ActionTake (ptr)); new MWWorld::ActionTake (ptr));

@ -7,6 +7,7 @@
#include "../mwbase/environment.hpp" #include "../mwbase/environment.hpp"
#include "../mwbase/world.hpp" #include "../mwbase/world.hpp"
#include "../mwbase/soundmanager.hpp"
#include "../mwworld/ptr.hpp" #include "../mwworld/ptr.hpp"
#include "../mwworld/actiontake.hpp" #include "../mwworld/actiontake.hpp"
@ -20,8 +21,6 @@
#include "../mwrender/objects.hpp" #include "../mwrender/objects.hpp"
#include "../mwrender/renderinginterface.hpp" #include "../mwrender/renderinginterface.hpp"
#include "../mwsound/soundmanager.hpp"
#include <boost/lexical_cast.hpp> #include <boost/lexical_cast.hpp>
namespace MWClass namespace MWClass
@ -43,7 +42,7 @@ namespace MWClass
physics.insertObjectPhysics(ptr, model); physics.insertObjectPhysics(ptr, model);
} }
} }
std::string Miscellaneous::getModel(const MWWorld::Ptr &ptr) const std::string Miscellaneous::getModel(const MWWorld::Ptr &ptr) const
{ {
MWWorld::LiveCellRef<ESM::Miscellaneous> *ref = MWWorld::LiveCellRef<ESM::Miscellaneous> *ref =
@ -68,7 +67,7 @@ namespace MWClass
boost::shared_ptr<MWWorld::Action> Miscellaneous::activate (const MWWorld::Ptr& ptr, boost::shared_ptr<MWWorld::Action> Miscellaneous::activate (const MWWorld::Ptr& ptr,
const MWWorld::Ptr& actor) const 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> ( return boost::shared_ptr<MWWorld::Action> (
new MWWorld::ActionTake (ptr)); new MWWorld::ActionTake (ptr));
@ -189,7 +188,7 @@ namespace MWClass
Miscellaneous::copyToCellImpl(const MWWorld::Ptr &ptr, MWWorld::CellStore &cell) const Miscellaneous::copyToCellImpl(const MWWorld::Ptr &ptr, MWWorld::CellStore &cell) const
{ {
MWWorld::Ptr newPtr; MWWorld::Ptr newPtr;
const ESMS::ESMStore &store = const ESMS::ESMStore &store =
MWBase::Environment::get().getWorld()->getStore(); MWBase::Environment::get().getWorld()->getStore();

@ -5,6 +5,7 @@
#include "../mwbase/environment.hpp" #include "../mwbase/environment.hpp"
#include "../mwbase/world.hpp" #include "../mwbase/world.hpp"
#include "../mwbase/soundmanager.hpp"
#include "../mwworld/ptr.hpp" #include "../mwworld/ptr.hpp"
#include "../mwworld/actiontake.hpp" #include "../mwworld/actiontake.hpp"
@ -19,8 +20,6 @@
#include "../mwrender/objects.hpp" #include "../mwrender/objects.hpp"
#include "../mwrender/renderinginterface.hpp" #include "../mwrender/renderinginterface.hpp"
#include "../mwsound/soundmanager.hpp"
namespace MWClass namespace MWClass
{ {
void Potion::insertObjectRendering (const MWWorld::Ptr& ptr, MWRender::RenderingInterface& renderingInterface) const 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, boost::shared_ptr<MWWorld::Action> Potion::activate (const MWWorld::Ptr& ptr,
const MWWorld::Ptr& actor) const 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> ( return boost::shared_ptr<MWWorld::Action> (
new MWWorld::ActionTake (ptr)); new MWWorld::ActionTake (ptr));

@ -5,6 +5,7 @@
#include "../mwbase/environment.hpp" #include "../mwbase/environment.hpp"
#include "../mwbase/world.hpp" #include "../mwbase/world.hpp"
#include "../mwbase/soundmanager.hpp"
#include "../mwworld/ptr.hpp" #include "../mwworld/ptr.hpp"
#include "../mwworld/actiontake.hpp" #include "../mwworld/actiontake.hpp"
@ -19,8 +20,6 @@
#include "../mwrender/objects.hpp" #include "../mwrender/objects.hpp"
#include "../mwrender/renderinginterface.hpp" #include "../mwrender/renderinginterface.hpp"
#include "../mwsound/soundmanager.hpp"
namespace MWClass namespace MWClass
{ {
void Probe::insertObjectRendering (const MWWorld::Ptr& ptr, MWRender::RenderingInterface& renderingInterface) const void Probe::insertObjectRendering (const MWWorld::Ptr& ptr, MWRender::RenderingInterface& renderingInterface) const
@ -40,7 +39,7 @@ namespace MWClass
physics.insertObjectPhysics(ptr, model); physics.insertObjectPhysics(ptr, model);
} }
} }
std::string Probe::getModel(const MWWorld::Ptr &ptr) const std::string Probe::getModel(const MWWorld::Ptr &ptr) const
{ {
MWWorld::LiveCellRef<ESM::Probe> *ref = MWWorld::LiveCellRef<ESM::Probe> *ref =
@ -64,7 +63,7 @@ namespace MWClass
boost::shared_ptr<MWWorld::Action> Probe::activate (const MWWorld::Ptr& ptr, boost::shared_ptr<MWWorld::Action> Probe::activate (const MWWorld::Ptr& ptr,
const MWWorld::Ptr& actor) const 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> ( return boost::shared_ptr<MWWorld::Action> (
new MWWorld::ActionTake (ptr)); new MWWorld::ActionTake (ptr));
@ -174,4 +173,3 @@ namespace MWClass
return MWWorld::Ptr(&cell.probes.insert(*ref), &cell); return MWWorld::Ptr(&cell.probes.insert(*ref), &cell);
} }
} }

@ -5,6 +5,7 @@
#include "../mwbase/environment.hpp" #include "../mwbase/environment.hpp"
#include "../mwbase/world.hpp" #include "../mwbase/world.hpp"
#include "../mwbase/soundmanager.hpp"
#include "../mwworld/ptr.hpp" #include "../mwworld/ptr.hpp"
#include "../mwworld/actiontake.hpp" #include "../mwworld/actiontake.hpp"
@ -17,8 +18,6 @@
#include "../mwrender/objects.hpp" #include "../mwrender/objects.hpp"
#include "../mwrender/renderinginterface.hpp" #include "../mwrender/renderinginterface.hpp"
#include "../mwsound/soundmanager.hpp"
namespace MWClass namespace MWClass
{ {
void Repair::insertObjectRendering (const MWWorld::Ptr& ptr, MWRender::RenderingInterface& renderingInterface) const void Repair::insertObjectRendering (const MWWorld::Ptr& ptr, MWRender::RenderingInterface& renderingInterface) const
@ -38,7 +37,7 @@ namespace MWClass
physics.insertObjectPhysics(ptr, model); physics.insertObjectPhysics(ptr, model);
} }
} }
std::string Repair::getModel(const MWWorld::Ptr &ptr) const std::string Repair::getModel(const MWWorld::Ptr &ptr) const
{ {
MWWorld::LiveCellRef<ESM::Repair> *ref = MWWorld::LiveCellRef<ESM::Repair> *ref =
@ -63,7 +62,7 @@ namespace MWClass
boost::shared_ptr<MWWorld::Action> Repair::activate (const MWWorld::Ptr& ptr, boost::shared_ptr<MWWorld::Action> Repair::activate (const MWWorld::Ptr& ptr,
const MWWorld::Ptr& actor) const 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> ( return boost::shared_ptr<MWWorld::Action> (
new MWWorld::ActionTake (ptr)); new MWWorld::ActionTake (ptr));

@ -5,6 +5,7 @@
#include "../mwbase/environment.hpp" #include "../mwbase/environment.hpp"
#include "../mwbase/world.hpp" #include "../mwbase/world.hpp"
#include "../mwbase/soundmanager.hpp"
#include "../mwworld/ptr.hpp" #include "../mwworld/ptr.hpp"
#include "../mwworld/actiontake.hpp" #include "../mwworld/actiontake.hpp"
@ -19,8 +20,6 @@
#include "../mwrender/objects.hpp" #include "../mwrender/objects.hpp"
#include "../mwrender/renderinginterface.hpp" #include "../mwrender/renderinginterface.hpp"
#include "../mwsound/soundmanager.hpp"
namespace MWClass namespace MWClass
{ {
void Weapon::insertObjectRendering (const MWWorld::Ptr& ptr, MWRender::RenderingInterface& renderingInterface) const void Weapon::insertObjectRendering (const MWWorld::Ptr& ptr, MWRender::RenderingInterface& renderingInterface) const
@ -40,7 +39,7 @@ namespace MWClass
physics.insertObjectPhysics(ptr, model); physics.insertObjectPhysics(ptr, model);
} }
} }
std::string Weapon::getModel(const MWWorld::Ptr &ptr) const std::string Weapon::getModel(const MWWorld::Ptr &ptr) const
{ {
MWWorld::LiveCellRef<ESM::Weapon> *ref = MWWorld::LiveCellRef<ESM::Weapon> *ref =
@ -65,7 +64,7 @@ namespace MWClass
boost::shared_ptr<MWWorld::Action> Weapon::activate (const MWWorld::Ptr& ptr, boost::shared_ptr<MWWorld::Action> Weapon::activate (const MWWorld::Ptr& ptr,
const MWWorld::Ptr& actor) const 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> ( return boost::shared_ptr<MWWorld::Action> (
new MWWorld::ActionTake (ptr)); new MWWorld::ActionTake (ptr));

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

@ -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> #include <components/esm/loadinfo.hpp>
@ -8,12 +8,15 @@
#include "../mwscript/interpretercontext.hpp" #include "../mwscript/interpretercontext.hpp"
#include <components/compiler/output.hpp> #include <components/compiler/output.hpp>
#include "../mwbase/dialoguemanager.hpp"
#include "../mwworld/ptr.hpp" #include "../mwworld/ptr.hpp"
#include <map> #include <map>
namespace MWDialogue namespace MWDialogue
{ {
class DialogueManager class DialogueManager : public MWBase::DialogueManager
{ {
bool isMatching (const MWWorld::Ptr& actor, const ESM::DialInfo::SelectStruct& select) const; bool isMatching (const MWWorld::Ptr& actor, const ESM::DialInfo::SelectStruct& select) const;
@ -50,21 +53,21 @@ namespace MWDialogue
DialogueManager (const Compiler::Extensions& extensions); 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 ///get the faction of the actor you are talking with
std::string getFaction(); virtual std::string getFaction() const;
//calbacks for the GUI //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);
}; };
} }

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

@ -1,9 +1,7 @@
#ifndef GAME_MMDIALOG_JOURNAL_H #ifndef GAME_MMDIALOG_JOURNAL_H
#define GAME_MWDIALOG_JOURNAL_H #define GAME_MWDIALOG_JOURNAL_H
#include <string> #include "../mwbase/journal.hpp"
#include <deque>
#include <map>
#include "journalentry.hpp" #include "journalentry.hpp"
#include "quest.hpp" #include "quest.hpp"
@ -11,19 +9,8 @@
namespace MWDialogue namespace MWDialogue
{ {
/// \brief The player's journal /// \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; TEntryContainer mJournal;
TQuestContainer mQuests; TQuestContainer mQuests;
TTopicContainer mTopics; TTopicContainer mTopics;
@ -34,37 +21,37 @@ namespace MWDialogue
Journal(); Journal();
void addEntry (const std::string& id, int index); virtual void addEntry (const std::string& id, int index);
///< Add a journal entry. ///< 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. ///< 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. ///< 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. ///< Iterator pointing to the begin of the main journal.
/// ///
/// \note Iterators to main journal entries will never become invalid. /// \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. ///< 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) ///< Iterator pointing to the first quest (sorted by topic ID)
TQuestIter questEnd() const; virtual TQuestIter questEnd() const;
///< Iterator pointing past the last quest. ///< Iterator pointing past the last quest.
TTopicIter topicBegin() const; virtual TTopicIter topicBegin() const;
///< Iterator pointing to the first topic (sorted by topic ID) ///< Iterator pointing to the first topic (sorted by topic ID)
/// ///
/// \note The topic ID is identical with the user-visible topic string. /// \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. ///< Iterator pointing past the last topic.
}; };
} }

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

@ -4,8 +4,10 @@
#include "../mwbase/environment.hpp" #include "../mwbase/environment.hpp"
#include "../mwbase/world.hpp" #include "../mwbase/world.hpp"
#include "../mwbase/soundmanager.hpp"
#include "../mwinput/inputmanager.hpp" #include "../mwinput/inputmanager.hpp"
#include "../mwsound/soundmanager.hpp"
#include "../mwworld/actiontake.hpp" #include "../mwworld/actiontake.hpp"
#include "../mwworld/player.hpp" #include "../mwworld/player.hpp"
@ -98,7 +100,7 @@ void BookWindow::onCloseButtonClicked (MyGUI::Widget* _sender)
void BookWindow::onTakeButtonClicked (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); MWWorld::ActionTake take(mBook);
take.execute (MWBase::Environment::get().getWorld()->getPlayer().getPlayer()); take.execute (MWBase::Environment::get().getWorld()->getPlayer().getPlayer());

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

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

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

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

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

@ -2,10 +2,10 @@
#include "../mwbase/environment.hpp" #include "../mwbase/environment.hpp"
#include "../mwbase/world.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" #include "window_manager.hpp"

@ -2,10 +2,12 @@
#include "../mwbase/environment.hpp" #include "../mwbase/environment.hpp"
#include "../mwbase/world.hpp" #include "../mwbase/world.hpp"
#include "../mwbase/soundmanager.hpp"
#include "../mwinput/inputmanager.hpp" #include "../mwinput/inputmanager.hpp"
#include "../mwworld/actiontake.hpp" #include "../mwworld/actiontake.hpp"
#include "../mwworld/player.hpp" #include "../mwworld/player.hpp"
#include "../mwsound/soundmanager.hpp"
#include "formatting.hpp" #include "formatting.hpp"
#include "window_manager.hpp" #include "window_manager.hpp"
@ -62,7 +64,7 @@ void ScrollWindow::onCloseButtonClicked (MyGUI::Widget* _sender)
void ScrollWindow::onTakeButtonClicked (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); MWWorld::ActionTake take(mScroll);
take.execute (MWBase::Environment::get().getWorld()->getPlayer().getPlayer()); take.execute (MWBase::Environment::get().getWorld()->getPlayer().getPlayer());

@ -12,11 +12,10 @@
#include "../mwbase/environment.hpp" #include "../mwbase/environment.hpp"
#include "../mwbase/world.hpp" #include "../mwbase/world.hpp"
#include "../mwbase/soundmanager.hpp"
#include "../mwrender/renderingmanager.hpp" #include "../mwrender/renderingmanager.hpp"
#include "../mwsound/soundmanager.hpp"
#include "../mwinput/inputmanager.hpp" #include "../mwinput/inputmanager.hpp"
#include "window_manager.hpp" #include "window_manager.hpp"
@ -75,9 +74,9 @@ namespace
return boost::lexical_cast<std::string>(xaspect) + " : " + boost::lexical_cast<std::string>(yaspect); 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(); std::string val = static_cast<MyGUI::Button*>(_sender)->getCaption();
if (val == "off") if (val == "off")
{ {
if (hasGLSL ()) val = hlslGlsl();
val = "glsl";
else
val = "cg";
} }
else if (val == "glsl") else if (val == hlslGlsl())
val = "cg"; val = "cg";
else else
val = "off"; val = "off";
@ -411,6 +407,7 @@ namespace MWGui
// water shader not supported with object shaders off // water shader not supported with object shaders off
mWaterShaderButton->setCaptionWithReplacing("#{sOff}"); mWaterShaderButton->setCaptionWithReplacing("#{sOff}");
mUnderwaterButton->setCaptionWithReplacing("#{sOff}");
mWaterShaderButton->setEnabled(false); mWaterShaderButton->setEnabled(false);
mReflectObjectsButton->setEnabled(false); mReflectObjectsButton->setEnabled(false);
mReflectActorsButton->setEnabled(false); mReflectActorsButton->setEnabled(false);

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

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

@ -6,7 +6,6 @@
#include <openengine/gui/events.hpp> #include <openengine/gui/events.hpp>
#include <openengine/ogre/exitlistener.hpp> #include <openengine/ogre/exitlistener.hpp>
#include <openengine/ogre/mouselook.hpp>
#include <openengine/ogre/renderer.hpp> #include <openengine/ogre/renderer.hpp>
#include "../mwgui/window_manager.hpp" #include "../mwgui/window_manager.hpp"
@ -16,12 +15,12 @@
#include <libs/platform/strings.h> #include <libs/platform/strings.h>
#include "mouselookevent.hpp"
#include "../engine.hpp" #include "../engine.hpp"
#include "../mwworld/player.hpp" #include "../mwworld/player.hpp"
#include "../mwrender/player.hpp"
#include <boost/bind.hpp> #include <boost/bind.hpp>
#include <boost/filesystem.hpp> #include <boost/filesystem.hpp>
#include <OgreRoot.h> #include <OgreRoot.h>
@ -82,7 +81,7 @@ namespace MWInput
OEngine::Render::ExitListener exit; OEngine::Render::ExitListener exit;
Mangle::Input::OISDriver input; Mangle::Input::OISDriver input;
OEngine::Input::Poller poller; OEngine::Input::Poller poller;
OEngine::Render::MouseLookEventPtr mouse; MouseLookEventPtr mouse;
OEngine::GUI::EventInjectorPtr guiEvents; OEngine::GUI::EventInjectorPtr guiEvents;
MWWorld::Player &player; MWWorld::Player &player;
MWGui::WindowManager &windows; MWGui::WindowManager &windows;
@ -90,6 +89,7 @@ namespace MWInput
bool mDragDrop; bool mDragDrop;
std::map<std::string, bool> mControlSwitch;
/* InputImpl Methods */ /* InputImpl Methods */
public: public:
@ -278,8 +278,7 @@ private:
// Add the exit listener // Add the exit listener
ogre.getRoot()->addFrameListener(&exit); 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 // This event handler pumps events into MyGUI
guiEvents = EventInjectorPtr(new EventInjector(windows.getGui())); guiEvents = EventInjectorPtr(new EventInjector(windows.getGui()));
@ -296,6 +295,14 @@ private:
lst->add(guiEvents,Event::EV_ALL); 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); changeInputMode(false);
/********************************** /**********************************
@ -366,38 +373,40 @@ private:
// Configure player movement according to keyboard input. Actual movement will // Configure player movement according to keyboard input. Actual movement will
// be done in the physics system. // 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))
{
player.setAutoMove (false);
player.setLeftRight (-1);
}
else
player.setLeftRight (0);
if (poller.isDown(A_MoveForward))
{
player.setAutoMove (false);
player.setForwardBackward (1);
}
else if (poller.isDown(A_MoveBackward))
{
player.setAutoMove (false);
player.setForwardBackward (-1);
}
else
player.setForwardBackward (0);
if (poller.isDown(A_Jump) && mControlSwitch["playerjumping"])
player.setUpDown (1);
else if (poller.isDown(A_Crouch))
player.setUpDown (-1);
else
player.setUpDown (0);
} }
else if (poller.isDown(A_MoveRight))
{
player.setAutoMove (false);
player.setLeftRight (-1);
}
else
player.setLeftRight (0);
if (poller.isDown(A_MoveForward))
{
player.setAutoMove (false);
player.setForwardBackward (1);
}
else if (poller.isDown(A_MoveBackward))
{
player.setAutoMove (false);
player.setForwardBackward (-1);
}
else
player.setForwardBackward (0);
if (poller.isDown(A_Jump))
player.setUpDown (1);
else if (poller.isDown(A_Crouch))
player.setUpDown (-1);
else
player.setUpDown (0);
} }
// Switch between gui modes. Besides controlling the Gui windows // Switch between gui modes. Besides controlling the Gui windows
@ -408,21 +417,47 @@ private:
if(guiMode) if(guiMode)
{ {
// Disable mouse look // Disable mouse look
mouse->setCamera(NULL); mouse->disable();
// Enable GUI events // Enable GUI events
guiEvents->enabled = true; guiEvents->enabled = true;
} }
else 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 // Disable GUI events
guiEvents->enabled = false; 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***/ /***CONSTRUCTOR***/
@ -471,4 +506,9 @@ private:
if (changeRes) if (changeRes)
impl->adjustMouseRegion(Settings::Manager::getInt("resolution x", "Video"), Settings::Manager::getInt("resolution y", "Video")); 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);
}
} }

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

@ -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);
}

@ -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

@ -1,34 +1,101 @@
#include "player.hpp" #include "player.hpp"
#include <OgreSceneNode.h> #include <OgreSceneNode.h>
#include <OgreCamera.h>
#include "../mwbase/environment.hpp"
#include "../mwbase/soundmanager.hpp"
#include "../mwworld/ptr.hpp"
#include "../mwworld/refdata.hpp"
namespace MWRender namespace MWRender
{ {
Player::Player (Ogre::Camera *camera, Ogre::SceneNode* node) 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 std::string Player::getHandle() const
{ {
return mNode->getName(); 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);
}
} }

@ -3,12 +3,19 @@
#include <string> #include <string>
namespace Ogre namespace Ogre
{ {
class Vector3;
class Camera; class Camera;
class SceneNode; class SceneNode;
} }
namespace MWWorld
{
class Ptr;
}
namespace MWRender namespace MWRender
{ {
/// \brief Player character rendering and camera control /// \brief Player character rendering and camera control
@ -17,17 +24,31 @@ namespace MWRender
Ogre::Camera *mCamera; Ogre::Camera *mCamera;
Ogre::SceneNode* mNode; Ogre::SceneNode* mNode;
public: bool mFirstPersonView;
bool mVanityModeEnabled;
void controlFlip();
void updateListener();
public:
Player (Ogre::Camera *camera, Ogre::SceneNode* mNode);
/// Set where the player is looking at. Uses Morrowind (euler) angles
bool setRotation(const Ogre::Vector3 &rot);
bool adjustRotation(const Ogre::Vector3 &rot);
Player (Ogre::Camera *camera, Ogre::SceneNode* mNode); std::string getHandle() const;
Ogre::Camera *getCamera() { return mCamera; } void attachTo(const MWWorld::Ptr &);
/// Set where the player is looking at. Uses Morrowind (euler) angles void toggleViewMode() {
void setRot(float x, float y, float z); mFirstPersonView = !mFirstPersonView;
}
std::string getHandle() const; void toggleVanityMode() {
Ogre::SceneNode* getNode() {return mNode;} mVanityModeEnabled = !mVanityModeEnabled;
}
}; };
} }

@ -1,16 +1,17 @@
#ifndef _GAME_RENDERING_INTERFACE_H #ifndef _GAME_RENDERING_INTERFACE_H
#define _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: public:
virtual MWRender::Objects& getObjects() = 0; virtual MWRender::Objects& getObjects() = 0;
virtual MWRender::Player& getPlayer() = 0;
virtual MWRender::Actors& getActors() = 0; virtual MWRender::Actors& getActors() = 0;
virtual ~RenderingInterface(){}; virtual ~RenderingInterface(){};
}; };
} }
#endif #endif

@ -43,12 +43,14 @@ RenderingManager::RenderingManager (OEngine::Render::OgreRenderer& _rend, const
:mRendering(_rend), mObjects(mRendering), mActors(mRendering), mAmbientMode(0), mSunEnabled(0) :mRendering(_rend), mObjects(mRendering), mActors(mRendering), mAmbientMode(0), mSunEnabled(0)
{ {
// select best shader mode // 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); 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->setCurrentLanguage (lang);
mFactory->loadAllFiles(); 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) // Set default mipmap level (NB some APIs ignore this)
TextureManager::getSingleton().setDefaultNumMipmaps(Settings::Manager::getInt("num mipmaps", "General")); TextureManager::getSingleton().setDefaultNumMipmaps(Settings::Manager::getInt("num mipmaps", "General"));
@ -185,10 +183,6 @@ MWRender::Actors& RenderingManager::getActors(){
return mActors; return mActors;
} }
MWRender::Player& RenderingManager::getPlayer(){
return (*mPlayer);
}
OEngine::Render::Fader* RenderingManager::getFader() OEngine::Render::Fader* RenderingManager::getFader()
{ {
return mRendering.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::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 void
@ -292,11 +312,20 @@ void RenderingManager::update (float duration){
mLocalMap->updatePlayer( mRendering.getCamera()->getRealPosition(), mRendering.getCamera()->getRealOrientation() ); 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); mWater->update(duration);
}
} }
void RenderingManager::waterAdded (MWWorld::Ptr::CellStore *store){ void RenderingManager::waterAdded (MWWorld::Ptr::CellStore *store){
if(store->cell->data.flags & store->cell->HasWater if(store->cell->data.flags & store->cell->HasWater
|| ((!(store->cell->data.flags & ESM::Cell::Interior)) || ((!(store->cell->data.flags & ESM::Cell::Interior))
@ -476,13 +505,6 @@ void RenderingManager::toggleLight()
setAmbientMode(); setAmbientMode();
} }
void RenderingManager::checkUnderwater()
{
if(mWater)
{
mWater->checkUnderwater( mRendering.getCamera()->getRealPosition().y );
}
}
void RenderingManager::playAnimationGroup (const MWWorld::Ptr& ptr, const std::string& groupName, void RenderingManager::playAnimationGroup (const MWWorld::Ptr& ptr, const std::string& groupName,
int mode, int number) 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 } // namespace

@ -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); RenderingManager(OEngine::Render::OgreRenderer& _rend, const boost::filesystem::path& resDir, OEngine::Physic::PhysicEngine* engine);
virtual ~RenderingManager(); 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(); SkyManager* getSkyManager();
Compositors* getCompositors(); Compositors* getCompositors();
@ -89,9 +85,8 @@ class RenderingManager: private RenderingInterface, public Ogre::WindowEventList
void moveObject (const MWWorld::Ptr& ptr, const Ogre::Vector3& position); void moveObject (const MWWorld::Ptr& ptr, const Ogre::Vector3& position);
void scaleObject (const MWWorld::Ptr& ptr, const Ogre::Vector3& scale); 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 setWaterHeight(const float height);
void toggleWater(); void toggleWater();

@ -2,6 +2,8 @@
#include <OgreTerrain.h> #include <OgreTerrain.h>
#include <stdexcept>
#include <extern/shiny/Main/Factory.hpp> #include <extern/shiny/Main/Factory.hpp>
namespace namespace
@ -86,15 +88,15 @@ namespace MWRender
normalMap->setProperty ("direct_texture", sh::makeProperty<sh::StringValue> (new sh::StringValue(terrain->getTerrainNormalMap ()->getName()))); 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"))); 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_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)))); p->mShaderProperties.setProperty ("num_blendmaps", sh::makeProperty<sh::StringValue>(new sh::StringValue(Ogre::StringConverter::toString(numBlendTextures))));
// blend maps // 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)); sh::MaterialInstanceTextureUnit* blendTex = p->createTextureUnit ("blendMap" + Ogre::StringConverter::toString(i));
blendTex->setProperty ("direct_texture", sh::makeProperty<sh::StringValue> (new sh::StringValue(terrain->getBlendTextureName(i)))); blendTex->setProperty ("direct_texture", sh::makeProperty<sh::StringValue> (new sh::StringValue(terrain->getBlendTextureName(i))));
@ -102,7 +104,7 @@ namespace MWRender
} }
// layer maps // 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)); 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)))); diffuseTex->setProperty ("direct_texture", sh::makeProperty<sh::StringValue> (new sh::StringValue(terrain->getLayerTextureName(i, 0))));
@ -111,7 +113,7 @@ namespace MWRender
} }
// shadow // 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)); sh::MaterialInstanceTextureUnit* shadowTex = p->createTextureUnit ("shadowMap" + Ogre::StringConverter::toString(i));
shadowTex->setProperty ("content_type", sh::makeProperty<sh::StringValue> (new sh::StringValue("shadow"))); shadowTex->setProperty ("content_type", sh::makeProperty<sh::StringValue> (new sh::StringValue("shadow")));

@ -184,22 +184,16 @@ void Water::toggle()
updateVisible(); updateVisible();
} }
void Water::checkUnderwater(float y) void
Water::updateUnderwater(bool underwater)
{ {
if (!mActive) if (!mActive) {
{
return; 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(); updateVisible();
} }

@ -101,7 +101,8 @@ namespace MWRender {
void processChangedSettings(const Settings::CategorySettingVector& settings); 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 changeCell(const ESM::Cell* cell);
void setHeight(const float height); void setHeight(const float height);

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

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

@ -7,8 +7,9 @@
#include <components/interpreter/runtime.hpp> #include <components/interpreter/runtime.hpp>
#include <components/interpreter/opcodes.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 "interpretercontext.hpp"
#include "ref.hpp" #include "ref.hpp"
@ -84,7 +85,7 @@ namespace MWScript
virtual void execute (Interpreter::Runtime& runtime, unsigned int arg0) 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) while(arg0>0)
{ {
std::string question = runtime.getStringLiteral (runtime[0].mInteger); std::string question = runtime.getStringLiteral (runtime[0].mInteger);

@ -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 0x200016f: user3 (implicit reference, console only, requires --script-console switch)
op 0x2000170: user4, explicit 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) 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

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

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

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

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

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

@ -9,8 +9,7 @@
#include "../mwbase/environment.hpp" #include "../mwbase/environment.hpp"
#include "../mwbase/world.hpp" #include "../mwbase/world.hpp"
#include "../mwbase/soundmanager.hpp"
#include "../mwsound/soundmanager.hpp"
#include "interpretercontext.hpp" #include "interpretercontext.hpp"
#include "ref.hpp" #include "ref.hpp"
@ -116,7 +115,7 @@ namespace MWScript
std::string sound = runtime.getStringLiteral (runtime[0].mInteger); std::string sound = runtime.getStringLiteral (runtime[0].mInteger);
runtime.pop(); 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; Interpreter::Type_Float pitch = runtime[0].mFloat;
runtime.pop(); 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);
} }
}; };

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

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

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

@ -42,10 +42,10 @@ namespace MWSound
virtual void init(const std::string &devname=""); virtual void init(const std::string &devname="");
virtual void deinit(); 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); 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); virtual void updateListener(const Ogre::Vector3 &pos, const Ogre::Vector3 &atdir, const Ogre::Vector3 &updir, Environment env);

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

@ -6,7 +6,7 @@
#include <OgreVector3.h> #include <OgreVector3.h>
#include "soundmanager.hpp" #include "soundmanagerimp.hpp"
#include "../mwworld/ptr.hpp" #include "../mwworld/ptr.hpp"
@ -24,10 +24,10 @@ namespace MWSound
virtual void init(const std::string &devname="") = 0; virtual void init(const std::string &devname="") = 0;
virtual void deinit() = 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; 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; virtual void updateListener(const Ogre::Vector3 &pos, const Ogre::Vector3 &atdir, const Ogre::Vector3 &updir, Environment env) = 0;

@ -1,11 +1,9 @@
#include "soundmanager.hpp" #include "soundmanagerimp.hpp"
#include <iostream> #include <iostream>
#include <algorithm> #include <algorithm>
#include <map> #include <map>
#include <OgreRoot.h>
#include <components/esm_store/store.hpp> #include <components/esm_store/store.hpp>
#include "../mwbase/environment.hpp" #include "../mwbase/environment.hpp"
@ -13,8 +11,6 @@
#include "../mwworld/player.hpp" #include "../mwworld/player.hpp"
#include "../mwrender/player.hpp"
#include "sound_output.hpp" #include "sound_output.hpp"
#include "sound_decoder.hpp" #include "sound_decoder.hpp"
#include "sound.hpp" #include "sound.hpp"
@ -222,7 +218,7 @@ namespace MWSound
const ESM::Position &pos = ptr.getCellRef().pos; const ESM::Position &pos = ptr.getCellRef().pos;
const Ogre::Vector3 objpos(pos.pos[0], pos.pos[1], pos.pos[2]); 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); 20.0f, 12750.0f, Play_Normal);
sound->mPos = objpos; sound->mPos = objpos;
sound->mBaseVolume = basevol; sound->mBaseVolume = basevol;
@ -244,7 +240,7 @@ namespace MWSound
float basevol = mMasterVolume * mVoiceVolume; float basevol = mMasterVolume * mVoiceVolume;
std::string filePath = "Sound/"+filename; 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; sound->mBaseVolume = basevol;
mActiveSounds[sound] = std::make_pair(MWWorld::Ptr(), std::string("_say_sound")); 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()) if(!mOutput->isInitialized())
return sound; return sound;
try try
@ -305,10 +301,10 @@ namespace MWSound
return sound; 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) float volume, float pitch, int mode)
{ {
SoundPtr sound; MWBase::SoundPtr sound;
if(!mOutput->isInitialized()) if(!mOutput->isInitialized())
return sound; return sound;
try try
@ -491,25 +487,20 @@ namespace MWSound
if(!isMusicPlaying()) if(!isMusicPlaying())
startRandomTitle(); 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; 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; 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 // Check if any sounds are finished playing, and trash them
SoundMap::iterator snditer = mActiveSounds.begin(); 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 // Default readAll implementation, for decoders that can't do anything
// better // better
void Sound_Decoder::readAll(std::vector<char> &output) void Sound_Decoder::readAll(std::vector<char> &output)

@ -7,18 +7,14 @@
#include <boost/shared_ptr.hpp> #include <boost/shared_ptr.hpp>
#include <OgreVector3.h>
#include <OgreResourceGroupManager.h> #include <OgreResourceGroupManager.h>
#include <components/settings/settings.hpp> #include <components/settings/settings.hpp>
#include "../mwworld/ptr.hpp" #include "../mwbase/soundmanager.hpp"
namespace Ogre #include "../mwworld/ptr.hpp"
{
class Root;
class Camera;
}
namespace MWSound namespace MWSound
{ {
@ -27,27 +23,13 @@ namespace MWSound
class Sound; class Sound;
typedef boost::shared_ptr<Sound_Decoder> DecoderPtr; 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 { enum Environment {
Env_Normal, Env_Normal,
Env_Underwater, Env_Underwater,
}; };
class SoundManager class SoundManager : public MWBase::SoundManager
{ {
Ogre::ResourceGroupManager& mResourceMgr; Ogre::ResourceGroupManager& mResourceMgr;
@ -65,9 +47,12 @@ namespace MWSound
std::string mCurrentPlaylist; std::string mCurrentPlaylist;
typedef std::pair<MWWorld::Ptr,std::string> PtrIDPair; typedef std::pair<MWWorld::Ptr,std::string> PtrIDPair;
typedef std::map<SoundPtr,PtrIDPair> SoundMap; typedef std::map<MWBase::SoundPtr,PtrIDPair> SoundMap;
SoundMap mActiveSounds; SoundMap mActiveSounds;
Ogre::Vector3 mListenerPos;
Ogre::Vector3 mListenerDir;
std::string lookup(const std::string &soundId, std::string lookup(const std::string &soundId,
float &volume, float &min, float &max); float &volume, float &min, float &max);
void streamMusicFull(const std::string& filename); void streamMusicFull(const std::string& filename);
@ -84,67 +69,69 @@ namespace MWSound
public: public:
SoundManager(bool useSound); 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 ///< Stops music if it's playing
void streamMusic(const std::string& filename); virtual void streamMusic(const std::string& filename);
///< Play a soundifle ///< Play a soundifle
/// \param filename name of a sound file in "Music/" in the data directory. /// \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 ///< Starts a random track from the current playlist
bool isMusicPlaying(); virtual bool isMusicPlaying();
///< Returns true if music is playing ///< 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 ///< Start playing music from the selected folder
/// \param name of the folder that contains the playlist /// \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. ///< Make an actor say some text.
/// \param filename name of a sound file in "Sound/" in the data directory. /// \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 ///< Say some text, without an actor ref
/// \param filename name of a sound file in "Sound/" in the data directory. /// \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? ///< Is actor not speaking?
void stopSay(MWWorld::Ptr reference=MWWorld::Ptr()); virtual void stopSay(MWWorld::Ptr reference=MWWorld::Ptr());
///< Stop an actor speaking ///< 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 ///< 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); float volume, float pitch, int mode=Play_Normal);
///< Play a sound from an object ///< 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, ///< 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. ///< 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. ///< 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 ///< 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? ///< 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. ///< 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);
}; };
} }

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

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

@ -6,8 +6,6 @@
#include "../mwbase/environment.hpp" #include "../mwbase/environment.hpp"
#include "../mwbase/world.hpp" #include "../mwbase/world.hpp"
#include "../mwrender/player.hpp"
#include "../mwmechanics/movement.hpp" #include "../mwmechanics/movement.hpp"
#include "../mwmechanics/npcstats.hpp" #include "../mwmechanics/npcstats.hpp"
@ -15,8 +13,8 @@
namespace MWWorld 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) mAutoMove (false), mForwardBackward (0)
{ {
mPlayer.base = player; mPlayer.base = player;
@ -28,7 +26,6 @@ namespace MWWorld
float* playerPos = mPlayer.mData.getPosition().pos; float* playerPos = mPlayer.mData.getPosition().pos;
playerPos[0] = playerPos[1] = playerPos[2] = 0; 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. /// \todo Do not make a copy of classes defined in esm/p records.
mClass = new ESM::Class (*world.getStore().classes.find (player->cls)); mClass = new ESM::Class (*world.getStore().classes.find (player->cls));
} }
@ -38,17 +35,6 @@ namespace MWWorld
delete mClass; 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_) void Player::setClass (const ESM::Class& class_)
{ {
ESM::Class *new_class = new ESM::Class (class_); ESM::Class *new_class = new ESM::Class (class_);

@ -14,11 +14,6 @@ namespace MWBase
class World; class World;
} }
namespace MWRender
{
class Player;
}
namespace MWWorld namespace MWWorld
{ {
class CellStore; class CellStore;
@ -28,7 +23,6 @@ namespace MWWorld
{ {
LiveCellRef<ESM::NPC> mPlayer; LiveCellRef<ESM::NPC> mPlayer;
MWWorld::CellStore *mCellStore; MWWorld::CellStore *mCellStore;
MWRender::Player *mRenderer;
std::string mName; std::string mName;
bool mMale; bool mMale;
std::string mRace; std::string mRace;
@ -38,16 +32,10 @@ namespace MWWorld
int mForwardBackward; int mForwardBackward;
public: public:
Player(MWRender::Player *renderer, const ESM::NPC *player, const MWBase::World& world); Player(const ESM::NPC *player, const MWBase::World& world);
~Player(); ~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) void setCell (MWWorld::CellStore *cellStore)
{ {
mCellStore = cellStore; mCellStore = cellStore;
@ -59,8 +47,6 @@ namespace MWWorld
return ptr; return ptr;
} }
MWRender::Player *getRenderer() { return mRenderer; }
void setName (const std::string& name) void setName (const std::string& name)
{ {
mName = name; mName = name;

@ -2,11 +2,10 @@
#include "../mwbase/environment.hpp" #include "../mwbase/environment.hpp"
#include "../mwbase/world.hpp" /// FIXME #include "../mwbase/world.hpp" /// FIXME
#include "../mwbase/soundmanager.hpp"
#include "../mwmechanics/mechanicsmanager.hpp" #include "../mwmechanics/mechanicsmanager.hpp"
#include "../mwsound/soundmanager.hpp"
#include "../mwgui/window_manager.hpp" #include "../mwgui/window_manager.hpp"
#include "player.hpp" #include "player.hpp"
@ -135,24 +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 adjustPlayerPos)
{ {
MWBase::Environment::get().getWorld()->getPlayer().setCell (cell); MWBase::Environment::get().getWorld()->getPlayer().setCell (cell);
bool hasWater = cell->cell->data.flags & cell->cell->HasWater; bool hasWater = cell->cell->data.flags & cell->cell->HasWater;
mPhysics->setCurrentWater(hasWater, cell->cell->water); mPhysics->setCurrentWater(hasWater, cell->cell->water);
if (adjustPlayerPos)
{ MWBase::World *world = MWBase::Environment::get().getWorld();
MWBase::Environment::get().getWorld()->getPlayer().setPos (position.pos[0], position.pos[1], position.pos[2]); MWWorld::Ptr player = world->getPlayer().getPlayer();
MWBase::Environment::get().getWorld()->getPlayer().setRot (position.rot[0], position.rot[1], position.rot[2]);
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();
MWBase::Environment::get().getMechanicsManager()->addActor (MWBase::Environment::get().getWorld()->getPlayer().getPlayer()); mechMgr->addActor(player);
MWBase::Environment::get().getMechanicsManager()->watchActor (MWBase::Environment::get().getWorld()->getPlayer().getPlayer()); mechMgr->watchActor(player);
MWBase::Environment::get().getWindowManager()->changeCell( mCurrentCell ); MWBase::Environment::get().getWindowManager()->changeCell(mCurrentCell);
} }
void Scene::changeCell (int X, int Y, const ESM::Position& position, bool adjustPlayerPos) void Scene::changeCell (int X, int Y, const ESM::Position& position, bool adjustPlayerPos)
@ -338,7 +346,7 @@ namespace MWWorld
mRendering.addObject(ptr); mRendering.addObject(ptr);
MWWorld::Class::get(ptr).insertObject(ptr, *mPhysics); MWWorld::Class::get(ptr).insertObject(ptr, *mPhysics);
} }
void Scene::removeObjectFromScene (const Ptr& ptr) void Scene::removeObjectFromScene (const Ptr& ptr)
{ {
MWBase::Environment::get().getMechanicsManager()->removeActor (ptr); MWBase::Environment::get().getMechanicsManager()->removeActor (ptr);

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

@ -4,14 +4,13 @@
#include <components/files/collections.hpp> #include <components/files/collections.hpp>
#include "../mwbase/environment.hpp" #include "../mwbase/environment.hpp"
#include "../mwbase/soundmanager.hpp"
#include "../mwrender/sky.hpp" #include "../mwrender/sky.hpp"
#include "../mwrender/player.hpp" #include "../mwrender/player.hpp"
#include "../mwmechanics/mechanicsmanager.hpp" #include "../mwmechanics/mechanicsmanager.hpp"
#include "../mwsound/soundmanager.hpp"
#include "../mwgui/window_manager.hpp" #include "../mwgui/window_manager.hpp"
#include "player.hpp" #include "player.hpp"
@ -189,8 +188,9 @@ namespace MWWorld
mEsm.open (masterPath.string()); mEsm.open (masterPath.string());
mStore.load (mEsm); 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)); mPhysics->addActor (mPlayer->getPlayer().getRefData().getHandle(), "", Ogre::Vector3 (0, 0, 0));
// global variables // global variables
@ -627,19 +627,20 @@ namespace MWWorld
mPhysics->scaleObject( ptr.getRefData().getHandle(), scale ); 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 void World::indexToPosition (int cellX, int cellY, float &x, float &y, bool centre) const
@ -1103,7 +1104,7 @@ namespace MWWorld
Ogre::Vector3 orig = Ogre::Vector3 orig =
Ogre::Vector3(pos.pos[0], pos.pos[1], pos.pos[2]); Ogre::Vector3(pos.pos[0], pos.pos[1], pos.pos[2]);
Ogre::Vector3 dir = Ogre::Vector3(0, 0, -1); Ogre::Vector3 dir = Ogre::Vector3(0, 0, -1);
float len = (pos.pos[2] >= 0) ? pos.pos[2] : -pos.pos[2]; float len = (pos.pos[2] >= 0) ? pos.pos[2] : -pos.pos[2];
len += 100.0; len += 100.0;
@ -1124,4 +1125,26 @@ namespace MWWorld
{ {
mRendering->getTriangleBatchCount(triangles, batches); 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;
}
} }

@ -210,7 +210,7 @@ namespace MWWorld
virtual void scaleObject (const Ptr& ptr, float scale); 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) virtual void indexToPosition (int cellX, int cellY, float &x, float &y, bool centre = false)
const; const;
@ -271,6 +271,9 @@ namespace MWWorld
///< @return true if it is possible to place on object at specified cursor location ///< @return true if it is possible to place on object at specified cursor location
virtual void processChangedSettings(const Settings::CategorySettingVector& settings); 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);
}; };
} }

@ -128,9 +128,11 @@ ELSE (WIN32) #Unix
ENDIF (WIN32) ENDIF (WIN32)
#Do some preparation #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}) SET(MYGUI_LIBRARIES ${MYGUI_LIBRARIES} ${FREETYPE_LIBRARIES})

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

@ -200,7 +200,7 @@ void BSAFile::readHeader()
input.read(&stringBuf[0], stringBuf.size()); input.read(&stringBuf[0], stringBuf.size());
// Check our position // 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 // Calculate the offset of the data buffer. All file offsets are
// relative to this. 12 header bytes + directory + hash table // relative to this. 12 header bytes + directory + hash table

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

@ -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;
}
}
}

@ -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 */

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

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

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

@ -3,7 +3,7 @@ shader_set openmw_objects_vertex
source objects.shader source objects.shader
type vertex type vertex
profiles_cg vs_2_0 vp40 arbvp1 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 shader_set openmw_objects_fragment
@ -11,5 +11,5 @@ shader_set openmw_objects_fragment
source objects.shader source objects.shader
type fragment type fragment
profiles_cg ps_3_0 ps_2_x ps_2_0 fp40 arbfp1 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
} }

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

@ -28,7 +28,7 @@ float3 intercept(float3 lineP,
float3 perturb1(shTexture2D tex, float2 coords, float bend, float2 windDir, float windSpeed, float timer) 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; bend *= WAVE_CHOPPYNESS;
nCoord = coords * (WAVE_SCALE * 0.05) + windDir * timer * (windSpeed*0.04); 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; 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) float3 perturb(shTexture2D tex, float2 coords, float bend, float2 windDir, float windSpeed, float timer)
{ {
bend *= WAVE_CHOPPYNESS; 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); 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; 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 /// \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*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 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; 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*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; caustics *= 3;

@ -198,7 +198,7 @@
float depth = shSample(depthMap, screenCoords).x * far - depthPassthrough; float depth = shSample(depthMap, screenCoords).x * far - depthPassthrough;
float shoreFade = shSaturate(depth / 50.0); 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); 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; float3 normal0 = 2.0 * shSample(normalMap, nCoord + float2(-waterTimer*0.015,-waterTimer*0.005)).rgb - 1.0;
@ -238,12 +238,12 @@
// sunlight scattering // sunlight scattering
float3 pNormal = float3(0,1,0); 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 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)); 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 // fresnel
float ior = (cameraPos.y>0)?(1.333/1.0):(1.0/1.333); //air to water; water to air 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); 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 watercolour = (float3(0.0078, 0.5176, 0.700)+waterSunColour)*waterGradient*2.0;
float3 waterext = float3(0.6, 0.9, 1.0);//water extinction 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; float darkness = VISIBILITY*2.0;
darkness = clamp((cameraPos.y+darkness)/darkness,0.2,1.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).xyz = shLerp (shOutputColour(0).xyz, fogColor, fogValue);
} }
shOutputColour(0).w = 1;
} }
#endif #endif

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

@ -11,6 +11,8 @@
#include <boost/filesystem.hpp> #include <boost/filesystem.hpp>
#include <components/files/ogreplugin.hpp>
#include <cassert> #include <cassert>
#include <cstdlib> #include <cstdlib>
#include <stdexcept> #include <stdexcept>
@ -111,17 +113,13 @@ void OgreRenderer::configure(const std::string &logPath,
#endif #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); RenderSystem* rs = mRoot->getRenderSystemByName(renderSystem);
if (rs == 0) 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. // create the semi-transparent black background texture used by the GUI.
// has to be created in code with TU_DYNAMIC_WRITE_ONLY_DISCARDABLE param // 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( Ogre::TextureManager::getSingleton().createManual(
"transparent.png", "transparent.png",
Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,

Loading…
Cancel
Save