Merge branch 'master' into terraincollision

Conflicts:
	apps/openmw/mwworld/scene.cpp

CMakeLists.txt

@@ -28,6 +28,7 @@ option(OGRE_STATIC "Link static build of Ogre and Ogre Plugins into the binaries
 
 # Sound source selection
 option(USE_FFMPEG "use ffmpeg for sound" OFF)
+option(USE_AUDIERE "use audiere for sound" OFF)
 option(USE_MPG123 "use mpg123 + libsndfile for sound" ON)
 
 find_program(DPKG_PROGRAM dpkg DOC "dpkg program of Debian-based systems")
@@ -133,6 +134,13 @@ if (USE_FFMPEG)
     set(SOUND_DEFINE ${SOUND_DEFINE} -DOPENMW_USE_FFMPEG)
 endif (USE_FFMPEG)
 
+if (USE_AUDIERE)
+    find_package(Audiere REQUIRED)
+    set(SOUND_INPUT_INCLUDES ${SOUND_INPUT_INCLUDES} ${AUDIERE_INCLUDE_DIR})
+    set(SOUND_INPUT_LIBRARY ${SOUND_INPUT_LIBRARY} ${AUDIERE_LIBRARY})
+    set(SOUND_DEFINE ${SOUND_DEFINE} -DOPENMW_USE_AUDIERE)
+endif (USE_AUDIERE)
+
 if (USE_MPG123)
     find_package(MPG123 REQUIRED)
     find_package(SNDFILE REQUIRED)
@@ -143,6 +151,7 @@ endif (USE_MPG123)
 
 # Platform specific
 if (WIN32)
+    set(Boost_USE_STATIC_LIBS   ON)
     set(PLATFORM_INCLUDE_DIR "platform")
     add_definitions(-DBOOST_ALL_NO_LIB)
 else (WIN32)
@@ -201,6 +210,7 @@ if(APPLE)
                           "Plugin_ParticleFX")
 endif(APPLE)
 
+add_subdirectory( files/)
 add_subdirectory( files/mygui )
 
 # Specify build paths
@@ -213,6 +223,9 @@ endif (APPLE)
 
 # Other files
 
+configure_file(${OpenMW_SOURCE_DIR}/files/settings-default.cfg
+    "${OpenMW_BINARY_DIR}/settings-default.cfg")
+
 configure_file(${OpenMW_SOURCE_DIR}/files/openmw.cfg.local
     "${OpenMW_BINARY_DIR}/openmw.cfg")
 configure_file(${OpenMW_SOURCE_DIR}/files/openmw.cfg
@@ -239,8 +252,14 @@ if (APPLE)
         "${APP_BUNDLE_DIR}/Contents/Resources/OpenMW.icns" COPYONLY)
 
     # prepare plugins
-    if (${CMAKE_BUILD_TYPE} MATCHES "Release" OR
-        ${CMAKE_BUILD_TYPE} MATCHES "RelWithDebugInfo")
+    if (${CMAKE_BUILD_TYPE} MATCHES "Release")
+        set(OPENMW_RELEASE_BUILD 1)
+    endif()
+    if (${CMAKE_BUILD_TYPE} MATCHES "RelWithDebugInfo")
+        set(OPENMW_RELEASE_BUILD 1)
+    endif()
+
+    if (${OPENMW_RELEASE_BUILD})
         set(OGRE_PLUGIN_DIR ${OGRE_PLUGIN_DIR_REL})
     else()
         set(OGRE_PLUGIN_DIR ${OGRE_PLUGIN_DIR_DBG})
@@ -287,6 +306,7 @@ if(DPKG_PROGRAM)
     INSTALL(FILES "${OpenMW_SOURCE_DIR}/apps/launcher/resources/images/openmw.png" DESTINATION "share/pixmaps/" PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ COMPONENT "openmw")
 
     #Install global configuration files
+    INSTALL(FILES "${OpenMW_BINARY_DIR}/settings-default.cfg" DESTINATION "../etc/openmw/" PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ COMPONENT "openmw")
     INSTALL(FILES "${OpenMW_BINARY_DIR}/openmw.cfg.install" DESTINATION "../etc/openmw/" RENAME "openmw.cfg" PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ COMPONENT "openmw")
     INSTALL(FILES "${OpenMW_BINARY_DIR}/plugins.cfg" DESTINATION "../etc/openmw/" PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ COMPONENT "openmw")
 
@@ -304,7 +324,7 @@ if(DPKG_PROGRAM)
  Data files from the original game is required to run it.")
     SET(CPACK_DEBIAN_PACKAGE_NAME "openmw")
     SET(CPACK_DEBIAN_PACKAGE_VERSION "${VERSION_STRING}")
-    SET(CPACK_PACKAGE_EXECUTABLES "openmw;OpenMW esmtool;Esmtool omwlauncher;OMWLauncher")
+    SET(CPACK_PACKAGE_EXECUTABLES "openmw;OpenMW esmtool;Esmtool omwlauncher;OMWLauncher mwiniimporter;MWiniImporter")
     SET(CPACK_DEBIAN_PACKAGE_DEPENDS "nvidia-cg-toolkit (>= 2.1),  libboost-filesystem1.46.1 (>= 1.46.1), libboost-program-options1.46.1 (>= 1.46.1), libboost-system1.46.1 (>= 1.46.1), libboost-thread1.46.1 (>= 1.46.1), libc6 (>= 2.11.2), libfreetype6 (>= 2.2.1), libgcc1 (>= 1:4.1.1), libmpg123-0 (>= 1.12.1), libois-1.3.0 (>= 1.3.0), libopenal1 (>= 1:1.12.854), libsndfile1 (>= 1.0.23), libstdc++6 (>= 4.4.5), libuuid1 (>= 2.17.2), libqtgui4 (>= 4.7.0)")
 
     SET(CPACK_DEBIAN_PACKAGE_SECTION "Games")
@@ -390,6 +410,11 @@ if (BUILD_LAUNCHER)
    add_subdirectory( apps/launcher )
 endif()
 
+option(BUILD_MWINIIMPORTER "build MWiniImporter inspector" ON)
+if (BUILD_MWINIIMPORTER)
+   add_subdirectory( apps/mwiniimporter )
+endif()
+
 if (WIN32)
   if (MSVC)
     if (USE_DEBUG_CONSOLE)

apps/launcher/CMakeLists.txt

@@ -95,5 +95,5 @@ else()
         "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/launcher.qss")
 
     configure_file(${CMAKE_SOURCE_DIR}/files/launcher.cfg
-        "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}launcher.cfg")
+        "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/launcher.cfg")
 endif()

apps/mwiniimporter/CMakeLists.txt

@@ -0,0 +1,20 @@
+set(MWINIIMPORT
+    main.cpp
+    importer.cpp
+)
+
+set(MWINIIMPORT_HEADER
+    importer.hpp
+)
+
+source_group(launcher FILES ${MWINIIMPORT} ${MWINIIMPORT_HEADER})
+
+add_executable(mwiniimport
+    ${MWINIIMPORT}
+)
+
+target_link_libraries(mwiniimport
+    ${Boost_LIBRARIES}
+    components
+)
+

apps/mwiniimporter/importer.cpp

@@ -0,0 +1,184 @@
+#include "importer.hpp"
+#include <boost/iostreams/device/file.hpp>
+#include <boost/iostreams/stream.hpp>
+#include <iostream>
+#include <string>
+#include <map>
+#include <vector>
+#include <algorithm>
+#include <sstream>
+
+MwIniImporter::MwIniImporter() {
+    const char *map[][2] =
+    {
+        { "fps", "General:Show FPS" },
+        { 0, 0 }
+    };
+
+    for(int i=0; map[i][0]; i++) {
+        mMergeMap.insert(std::make_pair<std::string, std::string>(map[i][0], map[i][1]));
+    }
+}
+
+void MwIniImporter::setVerbose(bool verbose) {
+    mVerbose = verbose;
+}
+
+std::string MwIniImporter::numberToString(int n) {
+    std::stringstream str;
+    str << n;
+    return str.str();
+}
+
+MwIniImporter::multistrmap MwIniImporter::loadIniFile(std::string filename) {
+    std::cout << "load ini file: " << filename << std::endl;
+
+    std::string section("");
+    MwIniImporter::multistrmap map;
+    boost::iostreams::stream<boost::iostreams::file_source>file(filename.c_str());
+
+    std::string line;
+    while (std::getline(file, line)) {
+
+        if(line[0] == '[') {
+            if(line.length() > 2) {
+                section = line.substr(1, line.length()-3);
+            }
+            continue;
+        }
+
+        int comment_pos = line.find(";");
+        if(comment_pos > 0) {
+            line = line.substr(0,comment_pos);
+        }
+
+        if(line.empty()) {
+            continue;
+        }
+
+        int pos = line.find("=");
+        if(pos < 1) {
+            continue;
+        }
+
+        std::string key(section + ":" + line.substr(0,pos));
+        std::string value(line.substr(pos+1));
+
+        multistrmap::iterator it;
+        if((it = map.find(key)) == map.end()) {
+            map.insert( std::make_pair<std::string, std::vector<std::string> > (key, std::vector<std::string>() ) );
+        }
+        map[key].push_back(value);
+    }
+
+    return map;
+}
+
+MwIniImporter::multistrmap MwIniImporter::loadCfgFile(std::string filename) {
+    std::cout << "load cfg file: " << filename << std::endl;
+
+    MwIniImporter::multistrmap map;
+    boost::iostreams::stream<boost::iostreams::file_source>file(filename.c_str());
+
+    std::string line;
+    while (std::getline(file, line)) {
+
+        // we cant say comment by only looking at first char anymore
+        int comment_pos = line.find("#");
+        if(comment_pos > 0) {
+            line = line.substr(0,comment_pos);
+        }
+
+        if(line.empty()) {
+            continue;
+        }
+
+        int pos = line.find("=");
+        if(pos < 1) {
+            continue;
+        }
+
+        std::string key(line.substr(0,pos));
+        std::string value(line.substr(pos+1));
+
+        multistrmap::iterator it;
+        if((it = map.find(key)) == map.end()) {
+            map.insert( std::make_pair<std::string, std::vector<std::string> > (key, std::vector<std::string>() ) );
+        }
+        map[key].push_back(value);
+    }
+
+    return map;
+}
+
+void MwIniImporter::merge(multistrmap &cfg, multistrmap &ini) {
+    multistrmap::iterator cfgIt;
+    multistrmap::iterator iniIt;
+    for(strmap::iterator it=mMergeMap.begin(); it!=mMergeMap.end(); it++) {
+        if((iniIt = ini.find(it->second)) != ini.end()) {
+            cfg.erase(it->first);
+            if(!this->specialMerge(it->first, it->second, cfg, ini)) {
+                cfg.insert(std::make_pair<std::string, std::vector<std::string> >(it->first, iniIt->second));
+            }
+        }
+    }
+}
+
+bool MwIniImporter::specialMerge(std::string cfgKey, std::string iniKey, multistrmap &cfg, multistrmap &ini) {
+    return false;
+}
+
+void MwIniImporter::importGameFiles(multistrmap &cfg, multistrmap &ini) {
+    std::vector<std::string> esmFiles;
+    std::vector<std::string> espFiles;
+    std::string baseGameFile("Game Files:GameFile");
+    std::string gameFile("");
+
+    multistrmap::iterator it = ini.begin();
+    for(int i=0; it != ini.end(); i++) {
+        gameFile = baseGameFile;
+        gameFile.append(this->numberToString(i));
+
+        it = ini.find(gameFile);
+        if(it == ini.end()) {
+            break;
+        }
+
+        for(std::vector<std::string>::iterator entry = it->second.begin(); entry!=it->second.end(); entry++) {
+            std::string filetype(entry->substr(entry->length()-4, 3));
+            std::transform(filetype.begin(), filetype.end(), filetype.begin(), ::tolower);
+
+            if(filetype.compare("esm") == 0) {
+                esmFiles.push_back(*entry);
+            }
+            else if(filetype.compare("esp") == 0) {
+                espFiles.push_back(*entry);
+            }
+        }
+
+        gameFile = "";
+    }
+
+    cfg.erase("master");
+    cfg.insert( std::make_pair<std::string, std::vector<std::string> > ("master", std::vector<std::string>() ) );
+
+    for(std::vector<std::string>::iterator it=esmFiles.begin(); it!=esmFiles.end(); it++) {
+        cfg["master"].push_back(*it);
+    }
+
+    cfg.erase("plugin");
+    cfg.insert( std::make_pair<std::string, std::vector<std::string> > ("plugin", std::vector<std::string>() ) );
+
+    for(std::vector<std::string>::iterator it=espFiles.begin(); it!=espFiles.end(); it++) {
+        cfg["plugin"].push_back(*it);
+    }
+}
+
+void MwIniImporter::writeToFile(boost::iostreams::stream<boost::iostreams::file_sink> &out, multistrmap &cfg) {
+
+    for(multistrmap::iterator it=cfg.begin(); it != cfg.end(); it++) {
+        for(std::vector<std::string>::iterator entry=it->second.begin(); entry != it->second.end(); entry++) {
+            out << (it->first) << "=" << (*entry) << std::endl;
+        }
+    }
+}

apps/mwiniimporter/importer.hpp

@@ -0,0 +1,32 @@
+#ifndef MWINIIMPORTER_IMPORTER
+#define MWINIIMPORTER_IMPORTER 1
+
+#include <boost/iostreams/device/file.hpp>
+#include <boost/iostreams/stream.hpp>
+#include <string>
+#include <map>
+#include <vector>
+#include <exception>
+
+class MwIniImporter {
+  public:
+    typedef std::map<std::string, std::string> strmap;
+    typedef std::map<std::string, std::vector<std::string> > multistrmap;
+
+    MwIniImporter();
+    void    setVerbose(bool verbose);
+    multistrmap  loadIniFile(std::string filename);
+    multistrmap  loadCfgFile(std::string filename);
+    void    merge(multistrmap &cfg, multistrmap &ini);
+    void    importGameFiles(multistrmap &cfg, multistrmap &ini);
+    void    writeToFile(boost::iostreams::stream<boost::iostreams::file_sink> &out, multistrmap &cfg);
+    
+  private:
+    bool specialMerge(std::string cfgKey, std::string iniKey, multistrmap &cfg, multistrmap &ini);
+    std::string numberToString(int n);
+    bool mVerbose;
+    strmap mMergeMap;
+};
+
+
+#endif

apps/mwiniimporter/main.cpp

@@ -0,0 +1,79 @@
+#include "importer.hpp"
+
+#include <iostream>
+#include <string>
+#include <boost/program_options.hpp>
+#include <boost/filesystem.hpp>
+
+namespace bpo = boost::program_options;
+
+int main(int argc, char *argv[]) {
+
+    bpo::options_description desc("Syntax: mwiniimporter <options>\nAllowed options");
+    desc.add_options()
+        ("help,h", "produce help message")
+        ("verbose,v", "verbose output")
+        ("ini,i", bpo::value<std::string>(), "morrowind.ini file")
+        ("cfg,c", bpo::value<std::string>(), "openmw.cfg file")
+        ("output,o", bpo::value<std::string>()->default_value(""), "openmw.cfg file")
+        ("game-files,g", "import esm and esp files")
+        ;
+
+    bpo::variables_map vm;
+    try {
+        bpo::store(boost::program_options::parse_command_line(argc, argv, desc), vm);
+
+        // parse help before calling notify because we dont want it to throw an error if help is set
+        if(vm.count("help")) {
+            std::cout << desc;
+            return 0;
+        }
+
+        bpo::notify(vm);
+
+    }
+    catch(std::exception& e) {
+        std::cerr << "Error:" << e.what() << std::endl;
+        return -1;
+    }
+    catch(...) {
+        std::cerr << "Error" << std::endl;
+        return -2;
+    }
+
+    std::string iniFile = vm["ini"].as<std::string>();
+    std::string cfgFile = vm["cfg"].as<std::string>();
+
+    // if no output is given, write back to cfg file
+    std::string outputFile(vm["output"].as<std::string>());
+    if(vm["output"].defaulted()) {
+        outputFile = vm["cfg"].as<std::string>();
+    }
+
+    if(!boost::filesystem::exists(iniFile)) {
+        std::cerr << "ini file does not exist" << std::endl;
+        return -3;
+    }
+    if(!boost::filesystem::exists(cfgFile)) {
+        std::cerr << "cfg file does not exist" << std::endl;
+        return -4;
+    }
+    
+    MwIniImporter importer;
+    importer.setVerbose(vm.count("verbose"));
+    boost::iostreams::stream<boost::iostreams::file_sink> file(outputFile);
+
+    MwIniImporter::multistrmap ini = importer.loadIniFile(iniFile);
+    MwIniImporter::multistrmap cfg = importer.loadCfgFile(cfgFile);
+
+    importer.merge(cfg, ini);
+    
+    if(vm.count("game-files")) {
+        importer.importGameFiles(cfg, ini);
+    }
+
+    std::cout << "write to: " << outputFile << std::endl;
+    importer.writeToFile(file, cfg);
+
+    return 0;
+}

apps/openmw/CMakeLists.txt

@@ -15,7 +15,7 @@ source_group(game FILES ${GAME} ${GAME_HEADER})
 
 add_openmw_dir (mwrender
     renderingmanager debugging sky player animation npcanimation creatureanimation actors objects
-    renderinginterface localmap terrain terrainmaterial
+    renderinginterface localmap occlusionquery terrain terrainmaterial water
     )
 
 add_openmw_dir (mwinput
@@ -39,7 +39,7 @@ add_openmw_dir (mwscript
     )
 
 add_openmw_dir (mwsound
-    soundmanager openal_output mpgsnd_decoder ffmpeg_decoder
+    soundmanager openal_output audiere_decoder mpgsnd_decoder ffmpeg_decoder
     )
 
 add_openmw_dir (mwworld

apps/openmw/engine.cpp

@@ -20,6 +20,7 @@
 #include <components/esm/esm_reader.hpp>
 #include <components/files/fixedpath.hpp>
 #include <components/files/configurationmanager.hpp>
+#include <components/settings/settings.hpp>
 
 #include <components/nifbullet/bullet_nif_loader.hpp>
 #include <components/nifogre/ogre_nif_loader.hpp>
@@ -82,12 +83,20 @@ void OMW::Engine::updateFocusReport (float duration)
 
         if (!handle.empty())
         {
-            MWWorld::Ptr ptr = mEnvironment.mWorld->getPtrViaHandle (handle);
+            // the faced handle is not updated immediately, so on a cell change it might
+            // point to an object that doesn't exist anymore
+            // therefore, we are catching the "Unknown Ogre handle" exception that occurs in this case
+            try
+            {
+                MWWorld::Ptr ptr = mEnvironment.mWorld->getPtrViaHandle (handle);
 
-            if (!ptr.isEmpty()){
-                name = MWWorld::Class::get (ptr).getName (ptr);
+                if (!ptr.isEmpty()){
+                    name = MWWorld::Class::get (ptr).getName (ptr);
 
+                }
             }
+            catch (std::runtime_error& e)
+            {}
         }
 
         if (name!=mFocusName)
@@ -204,13 +213,18 @@ OMW::Engine::~Engine()
 void OMW::Engine::loadBSA()
 {
     const Files::MultiDirCollection& bsa = mFileCollections.getCollection (".bsa");
-    std::string dataDirectory;
+    
     for (Files::MultiDirCollection::TIter iter(bsa.begin()); iter!=bsa.end(); ++iter)
     {
         std::cout << "Adding " << iter->second.string() << std::endl;
         Bsa::addBSA(iter->second.string());
+    }
 
-        dataDirectory = iter->second.parent_path().string();
+    const Files::PathContainer& dataDirs = mFileCollections.getPaths();
+    std::string dataDirectory;
+    for (Files::PathContainer::const_iterator iter = dataDirs.begin(); iter != dataDirs.end(); ++iter)
+    {
+        dataDirectory = iter->string();
         std::cout << "Data dir " << dataDirectory << std::endl;
         Bsa::addDir(dataDirectory, mFSStrict);
     }
@@ -308,6 +322,29 @@ void OMW::Engine::go()
     {
         boost::filesystem::create_directories(configPath);
     }
+
+    // Create the settings manager and load default settings file
+    Settings::Manager settings;
+    const std::string localdefault = mCfgMgr.getLocalPath().string() + "/settings-default.cfg";
+    const std::string globaldefault = mCfgMgr.getGlobalPath().string() + "/settings-default.cfg";
+
+    // prefer local
+    if (boost::filesystem::exists(localdefault))
+        settings.loadDefault(localdefault);
+    else if (boost::filesystem::exists(globaldefault))
+        settings.loadDefault(globaldefault);
+
+    // load user settings if they exist, otherwise just load the default settings as user settings
+    const std::string settingspath = mCfgMgr.getUserPath().string() + "/settings.cfg";
+    if (boost::filesystem::exists(settingspath))
+        settings.loadUser(settingspath);
+    else if (boost::filesystem::exists(localdefault))
+        settings.loadUser(localdefault);
+    else if (boost::filesystem::exists(globaldefault))
+        settings.loadUser(globaldefault);
+
+    mFpsLevel = settings.getInt("fps", "HUD");
+
     mOgre->configure(!boost::filesystem::is_regular_file(mCfgMgr.getOgreConfigPath()),
         mCfgMgr.getOgreConfigPath().string(),
         mCfgMgr.getLogPath().string(),
@@ -315,7 +352,11 @@ void OMW::Engine::go()
 
     // This has to be added BEFORE MyGUI is initialized, as it needs
     // to find core.xml here.
+
+    //addResourcesDirectory(mResDir);
+   
     addResourcesDirectory(mResDir / "mygui");
+    addResourcesDirectory(mResDir / "water");
 
     // Create the window
     mOgre->createWindow("OpenMW");
@@ -398,6 +439,9 @@ void OMW::Engine::go()
     // Start the main rendering loop
     mOgre->start();
 
+    // Save user settings
+    settings.saveUser(settingspath);
+
     std::cout << "Quitting peacefully.\n";
 }
 
@@ -411,10 +455,21 @@ void OMW::Engine::activate()
     if (handle.empty())
         return;
 
-    MWWorld::Ptr ptr = mEnvironment.mWorld->getPtrViaHandle (handle);
+    // the faced handle is not updated immediately, so on a cell change it might
+    // point to an object that doesn't exist anymore
+    // therefore, we are catching the "Unknown Ogre handle" exception that occurs in this case
+    MWWorld::Ptr ptr;
+    try
+    {
+        ptr = mEnvironment.mWorld->getPtrViaHandle (handle);
 
-    if (ptr.isEmpty())
+        if (ptr.isEmpty())
+            return;
+    }
+    catch (std::runtime_error&)
+    {
         return;
+    }
 
     MWScript::InterpreterContext interpreterContext (mEnvironment,
         &ptr.getRefData().getLocals(), ptr);

apps/openmw/main.cpp

@@ -92,9 +92,6 @@ bool parseOptions (int argc, char** argv, OMW::Engine& engine, Files::Configurat
         ("plugin", bpo::value<StringsVector>()->default_value(StringsVector(), "")
             ->multitoken(), "plugin file(s)")
 
-        ("fps", boost::program_options::value<int>()->implicit_value(1)
-            ->default_value(0), "fps counter detail (0 = off, 1 = fps counter, 2 = full detail)")
-
         ("anim-verbose", boost::program_options::value<bool>()->implicit_value(true)
             ->default_value(false), "output animation indices files")
 
@@ -225,7 +222,6 @@ bool parseOptions (int argc, char** argv, OMW::Engine& engine, Files::Configurat
     engine.setNewGame(variables["new-game"].as<bool>());
 
     // other settings
-    engine.showFPS(variables["fps"].as<int>());
     engine.setDebugMode(variables["debug"].as<bool>());
     engine.setSoundUsage(!variables["nosound"].as<bool>());
     engine.setScriptsVerbosity(variables["script-verbose"].as<bool>());

apps/openmw/mwclass/apparatus.cpp

@@ -56,7 +56,7 @@ namespace MWClass
     boost::shared_ptr<MWWorld::Action> Apparatus::activate (const MWWorld::Ptr& ptr,
         const MWWorld::Ptr& actor, const MWWorld::Environment& environment) const
     {
-        environment.mSoundManager->playSound3D (ptr, getUpSoundId(ptr), 1.0, 1.0, false, true);
+        environment.mSoundManager->playSound3D (ptr, getUpSoundId(ptr), 1.0, 1.0, MWSound::Play_NoTrack);
 
         return boost::shared_ptr<MWWorld::Action> (
             new MWWorld::ActionTake (ptr));

apps/openmw/mwclass/armor.cpp

@@ -60,7 +60,7 @@ namespace MWClass
     boost::shared_ptr<MWWorld::Action> Armor::activate (const MWWorld::Ptr& ptr,
         const MWWorld::Ptr& actor, const MWWorld::Environment& environment) const
     {
-        environment.mSoundManager->playSound3D (ptr, getUpSoundId(ptr, environment), 1.0, 1.0, false, true);
+        environment.mSoundManager->playSound3D (ptr, getUpSoundId(ptr, environment), 1.0, 1.0, MWSound::Play_NoTrack);
 
         return boost::shared_ptr<MWWorld::Action> (
             new MWWorld::ActionTake (ptr));

apps/openmw/mwclass/book.cpp

@@ -58,7 +58,7 @@ namespace MWClass
     {
         // TODO implement reading
 
-        environment.mSoundManager->playSound3D (ptr, getUpSoundId(ptr, environment), 1.0, 1.0, false, true);
+        environment.mSoundManager->playSound3D (ptr, getUpSoundId(ptr, environment), 1.0, 1.0, MWSound::Play_NoTrack);
 
         return boost::shared_ptr<MWWorld::Action> (
             new MWWorld::ActionTake (ptr));

apps/openmw/mwclass/clothing.cpp

@@ -57,7 +57,7 @@ namespace MWClass
     boost::shared_ptr<MWWorld::Action> Clothing::activate (const MWWorld::Ptr& ptr,
         const MWWorld::Ptr& actor, const MWWorld::Environment& environment) const
     {
-         environment.mSoundManager->playSound3D (ptr, getUpSoundId(ptr, environment), 1.0, 1.0, false, true);
+         environment.mSoundManager->playSound3D (ptr, getUpSoundId(ptr, environment), 1.0, 1.0, MWSound::Play_NoTrack);
 
         return boost::shared_ptr<MWWorld::Action> (
             new MWWorld::ActionTake (ptr));

apps/openmw/mwclass/container.cpp

@@ -85,7 +85,7 @@ namespace MWClass
         {
             // TODO check for key
             std::cout << "Locked container" << std::endl;
-            environment.mSoundManager->playSound3D (ptr, lockedSound, 1.0, 1.0, false);
+            environment.mSoundManager->playSound3D (ptr, lockedSound, 1.0, 1.0);
             return boost::shared_ptr<MWWorld::Action> (new MWWorld::NullAction);
         }
         else
@@ -100,7 +100,7 @@ namespace MWClass
             {
                 // Trap activation goes here
                 std::cout << "Activated trap: " << ptr.getCellRef().trap << std::endl;
-                environment.mSoundManager->playSound3D (ptr, trapActivationSound, 1.0, 1.0, false);
+                environment.mSoundManager->playSound3D (ptr, trapActivationSound, 1.0, 1.0);
                 ptr.getCellRef().trap = "";
                 return boost::shared_ptr<MWWorld::Action> (new MWWorld::NullAction);
             }

apps/openmw/mwclass/door.cpp

@@ -73,7 +73,7 @@ namespace MWClass
             // TODO check for key
             // TODO report failure to player (message, sound?). Look up behaviour of original MW.
             std::cout << "Locked!" << std::endl;
-            environment.mSoundManager->playSound3D (ptr, lockedSound, 1.0, 1.0, false);
+            environment.mSoundManager->playSound3D (ptr, lockedSound, 1.0, 1.0);
             return boost::shared_ptr<MWWorld::Action> (new MWWorld::NullAction);
         }
 
@@ -81,7 +81,7 @@ namespace MWClass
         {
             // Trap activation
             std::cout << "Activated trap: " << ptr.getCellRef().trap << std::endl;
-            environment.mSoundManager->playSound3D(ptr, trapActivationSound, 1.0, 1.0, false);
+            environment.mSoundManager->playSound3D(ptr, trapActivationSound, 1.0, 1.0);
             ptr.getCellRef().trap = "";
             return boost::shared_ptr<MWWorld::Action> (new MWWorld::NullAction);
         }
@@ -110,7 +110,7 @@ namespace MWClass
             // TODO return action for rotating the door
 
             // This is a little pointless, but helps with testing
-            environment.mSoundManager->playSound3D (ptr, openSound, 1.0, 1.0, false);
+            environment.mSoundManager->playSound3D (ptr, openSound, 1.0, 1.0);
             return boost::shared_ptr<MWWorld::Action> (new MWWorld::NullAction);
         }
     }

apps/openmw/mwclass/ingredient.cpp

@@ -54,7 +54,7 @@ namespace MWClass
     boost::shared_ptr<MWWorld::Action> Ingredient::activate (const MWWorld::Ptr& ptr,
         const MWWorld::Ptr& actor, const MWWorld::Environment& environment) const
     {
-        environment.mSoundManager->playSound3D (ptr, getUpSoundId(ptr, environment), 1.0, 1.0, false, true);
+        environment.mSoundManager->playSound3D (ptr, getUpSoundId(ptr, environment), 1.0, 1.0, MWSound::Play_NoTrack);
 
         return boost::shared_ptr<MWWorld::Action> (
             new MWWorld::ActionTake (ptr));

apps/openmw/mwclass/light.cpp

@@ -59,7 +59,7 @@ namespace MWClass
 
         if (!ref->base->sound.empty())
         {
-            environment.mSoundManager->playSound3D (ptr, ref->base->sound, 1.0, 1.0, true);
+            environment.mSoundManager->playSound3D (ptr, ref->base->sound, 1.0, 1.0, MWSound::Play_Loop);
         }
     }
 
@@ -83,7 +83,7 @@ namespace MWClass
         if (!(ref->base->data.flags & ESM::Light::Carry))
             return boost::shared_ptr<MWWorld::Action> (new MWWorld::NullAction);
 
-        environment.mSoundManager->playSound3D (ptr, getUpSoundId(ptr, environment), 1.0, 1.0, false, true);
+        environment.mSoundManager->playSound3D (ptr, getUpSoundId(ptr, environment), 1.0, 1.0, MWSound::Play_NoTrack);
 
         return boost::shared_ptr<MWWorld::Action> (
             new MWWorld::ActionTake (ptr));

apps/openmw/mwclass/lockpick.cpp

@@ -58,7 +58,7 @@ namespace MWClass
     boost::shared_ptr<MWWorld::Action> Lockpick::activate (const MWWorld::Ptr& ptr,
         const MWWorld::Ptr& actor, const MWWorld::Environment& environment) const
     {
-        environment.mSoundManager->playSound3D (ptr, getUpSoundId(ptr, environment), 1.0, 1.0, false, true);
+        environment.mSoundManager->playSound3D (ptr, getUpSoundId(ptr, environment), 1.0, 1.0, MWSound::Play_NoTrack);
 
         return boost::shared_ptr<MWWorld::Action> (
             new MWWorld::ActionTake (ptr));

apps/openmw/mwclass/misc.cpp

@@ -56,7 +56,7 @@ namespace MWClass
     boost::shared_ptr<MWWorld::Action> Miscellaneous::activate (const MWWorld::Ptr& ptr,
         const MWWorld::Ptr& actor, const MWWorld::Environment& environment) const
     {
-        environment.mSoundManager->playSound3D (ptr, getUpSoundId(ptr, environment), 1.0, 1.0, false, true);
+        environment.mSoundManager->playSound3D (ptr, getUpSoundId(ptr, environment), 1.0, 1.0, MWSound::Play_NoTrack);
 
         return boost::shared_ptr<MWWorld::Action> (
             new MWWorld::ActionTake (ptr));

apps/openmw/mwclass/potion.cpp

@@ -56,7 +56,7 @@ namespace MWClass
     boost::shared_ptr<MWWorld::Action> Potion::activate (const MWWorld::Ptr& ptr,
         const MWWorld::Ptr& actor, const MWWorld::Environment& environment) const
     {
-        environment.mSoundManager->playSound3D (ptr, getUpSoundId(ptr, environment), 1.0, 1.0, false, true);
+        environment.mSoundManager->playSound3D (ptr, getUpSoundId(ptr, environment), 1.0, 1.0, MWSound::Play_NoTrack);
 
         return boost::shared_ptr<MWWorld::Action> (
             new MWWorld::ActionTake (ptr));

apps/openmw/mwclass/probe.cpp

@@ -57,7 +57,7 @@ namespace MWClass
     boost::shared_ptr<MWWorld::Action> Probe::activate (const MWWorld::Ptr& ptr,
         const MWWorld::Ptr& actor, const MWWorld::Environment& environment) const
     {
-        environment.mSoundManager->playSound3D (ptr, getUpSoundId(ptr, environment), 1.0, 1.0, false, true);
+        environment.mSoundManager->playSound3D (ptr, getUpSoundId(ptr, environment), 1.0, 1.0, MWSound::Play_NoTrack);
 
         return boost::shared_ptr<MWWorld::Action> (
             new MWWorld::ActionTake (ptr));

apps/openmw/mwclass/repair.cpp

@@ -56,7 +56,7 @@ namespace MWClass
     boost::shared_ptr<MWWorld::Action> Repair::activate (const MWWorld::Ptr& ptr,
         const MWWorld::Ptr& actor, const MWWorld::Environment& environment) const
     {
-        environment.mSoundManager->playSound3D (ptr, getUpSoundId(ptr, environment), 1.0, 1.0, false, true);
+        environment.mSoundManager->playSound3D (ptr, getUpSoundId(ptr, environment), 1.0, 1.0, MWSound::Play_NoTrack);
 
         return boost::shared_ptr<MWWorld::Action> (
             new MWWorld::ActionTake (ptr));

apps/openmw/mwclass/weapon.cpp

@@ -57,7 +57,7 @@ namespace MWClass
     boost::shared_ptr<MWWorld::Action> Weapon::activate (const MWWorld::Ptr& ptr,
         const MWWorld::Ptr& actor, const MWWorld::Environment& environment) const
     {
-        environment.mSoundManager->playSound3D (ptr, getUpSoundId(ptr, environment), 1.0, 1.0, false, true);
+        environment.mSoundManager->playSound3D (ptr, getUpSoundId(ptr, environment), 1.0, 1.0, MWSound::Play_NoTrack);
 
         return boost::shared_ptr<MWWorld::Action> (
             new MWWorld::ActionTake (ptr));

apps/openmw/mwgui/dialogue.cpp

@@ -43,9 +43,6 @@ DialogueWindow::DialogueWindow(WindowManager& parWindowManager,MWWorld::Environm
     // Centre dialog
     center();
 
-    //WindowManager *wm = environment.mWindowManager;
-    setText("NpcName", "Name of character");
-
     //History view
     getWidget(history, "History");
     history->setOverflowToTheLeft(true);
@@ -116,7 +113,8 @@ void DialogueWindow::onSelectTopic(MyGUI::ListBox* _sender, size_t _index)
 
 void DialogueWindow::startDialogue(std::string npcName)
 {
-    setText("NpcName", npcName);
+    static_cast<MyGUI::Window*>(mMainWidget)->setCaption(npcName);
+    adjustWindowCaption();
 }
 
 void DialogueWindow::setKeywords(std::list<std::string> keyWords)

apps/openmw/mwgui/layouts.cpp

@@ -182,7 +182,9 @@ void HUD::setPlayerPos(const float x, const float y)
 }
 
 MapWindow::MapWindow()
-  : Layout("openmw_map_window_layout.xml"), mGlobal(false)
+  : Layout("openmw_map_window_layout.xml")
+  , mGlobal(false)
+  , mVisible(false)
 {
     setCoord(500,0,320,300);
     setText("WorldButton", "World");
@@ -272,6 +274,17 @@ void MapWindow::onWorldButtonClicked(MyGUI::Widget* _sender)
     mButton->setCaption( mGlobal ? "Local" : "World" );
 }
 
+LocalMapBase::LocalMapBase()
+    : mCurX(0)
+    , mCurY(0)
+    , mInterior(false)
+    , mLocalMap(NULL)
+    , mPrefix()
+    , mChanged(true)
+    , mLayout(NULL)
+{
+}
+
 void LocalMapBase::init(MyGUI::ScrollView* widget, OEngine::GUI::Layout* layout)
 {
     mLocalMap = widget;

apps/openmw/mwgui/layouts.hpp

@@ -34,6 +34,7 @@ namespace MWGui
   class LocalMapBase
   {
   public:
+    LocalMapBase();
     void init(MyGUI::ScrollView* widget, OEngine::GUI::Layout* layout);
 
     void setCellPrefix(const std::string& prefix);
@@ -85,6 +86,7 @@ namespace MWGui
   {
   public:
     MapWindow();
+    virtual ~MapWindow(){}
 
     void setVisible(bool b);
     void setPlayerPos(const float x, const float y);

apps/openmw/mwgui/window_manager.cpp

@@ -180,71 +180,58 @@ void WindowManager::updateVisible()
     // Mouse is visible whenever we're not in game mode
     MyGUI::PointerManager::getInstance().setVisible(isGuiMode());
 
-    // If in game mode, don't show anything.
-    if(mode == GM_Game) //Use a switch/case structure
-    {
-        return;
-    }
+    switch(mode) {
+        case GM_Game:
+            // If in game mode, don't show anything.
+            break;
+        case GM_MainMenu:
+            menu->setVisible(true);
+            break;
+        case GM_Console:
+            console->enable();
+            break;
+        case GM_Name:
+        case GM_Race:
+        case GM_Class:
+        case GM_ClassPick:
+        case GM_ClassCreate:
+        case GM_Birth:
+        case GM_ClassGenerate:
+        case GM_Review:
+            mCharGen->spawnDialog(mode);
+            break;
+        case GM_Inventory:
+        {
+            // First, compute the effective set of windows to show.
+            // This is controlled both by what windows the
+            // user has opened/closed (the 'shown' variable) and by what
+            // windows we are allowed to show (the 'allowed' var.)
+            int eff = shown & allowed;
 
-    if(mode == GM_MainMenu)
-    {
-        // Enable the main menu
-        menu->setVisible(true);
-        return;
-    }
-
-    if(mode == GM_Console)
-    {
-        console->enable();
-        return;
-    }
-
-    //There must be a more elegant solution
-    if (mode == GM_Name || mode == GM_Race || mode == GM_Class || mode == GM_ClassPick || mode == GM_ClassCreate || mode == GM_Birth || mode == GM_ClassGenerate || mode == GM_Review)
-    {
-        mCharGen->spawnDialog(mode);
-        return;
-    }
-
-    if(mode == GM_Inventory)
-    {
-        // Ah, inventory mode. First, compute the effective set of
-        // windows to show. This is controlled both by what windows the
-        // user has opened/closed (the 'shown' variable) and by what
-        // windows we are allowed to show (the 'allowed' var.)
-        int eff = shown & allowed;
-
-        // Show the windows we want
-        map   -> setVisible( (eff & GW_Map) != 0 );
-        stats -> setVisible( (eff & GW_Stats) != 0 );
-        return;
-    }
-
-    if (mode == GM_Dialogue)
-    {
-        dialogueWindow->open();
-        return;
-    }
-
-    if(mode == GM_InterMessageBox)
-    {
-        if(!mMessageBoxManager->isInteractiveMessageBox()) {
-            setGuiMode(GM_Game);
+            // Show the windows we want
+            map   -> setVisible( (eff & GW_Map) != 0 );
+            stats -> setVisible( (eff & GW_Stats) != 0 );
+            break;
         }
-        return;
+        case GM_Dialogue:
+            dialogueWindow->open();
+            break;
+        case GM_InterMessageBox:
+            if(!mMessageBoxManager->isInteractiveMessageBox()) {
+                setGuiMode(GM_Game);
+            }
+            break;
+        case GM_Journal:
+            mJournal->setVisible(true);
+            mJournal->open();
+            break;
+        default:
+            // Unsupported mode, switch back to game
+            // Note: The call will eventually end up this method again but
+            // will stop at the check if mode is GM_Game.
+            setGuiMode(GM_Game);
+            break;
     }
-
-    if(mode == GM_Journal)
-    {
-        mJournal->setVisible(true);
-        mJournal->open();
-        return;
-    }
-
-    // Unsupported mode, switch back to game
-    // Note: The call will eventually end up this method again but
-    // will stop at the check if(mode == GM_Game) above.
-    setGuiMode(GM_Game);
 }
 
 void WindowManager::setValue (const std::string& id, const MWMechanics::Stat<int>& value)
@@ -371,7 +358,6 @@ void WindowManager::updateSkillArea()
 
 void WindowManager::removeDialog(OEngine::GUI::Layout*dialog)
 {
-    std::cout << "dialogue a la poubelle";
     assert(dialog);
     if (!dialog)
         return;

apps/openmw/mwrender/animation.cpp

@@ -126,6 +126,11 @@ namespace MWRender{
    void Animation::handleShapes(std::vector<Nif::NiTriShapeCopy>* allshapes, Ogre::Entity* creaturemodel, Ogre::SkeletonInstance *skel){
         shapeNumber = 0;
 
+        if (allshapes == NULL || creaturemodel == NULL || skel == NULL)
+        {
+            return;
+        }
+
         std::vector<Nif::NiTriShapeCopy>::iterator allshapesiter;
 	    for(allshapesiter = allshapes->begin(); allshapesiter != allshapes->end(); allshapesiter++)
 

apps/openmw/mwrender/debugging.cpp

@@ -2,37 +2,283 @@
 
 #include <assert.h>
 
-#include "OgreRoot.h"
-#include "OgreRenderWindow.h"
-#include "OgreSceneManager.h"
-#include "OgreViewport.h"
-#include "OgreCamera.h"
-#include "OgreTextureManager.h"
+#include <OgreNode.h>
+#include <OgreSceneManager.h>
+#include <OgreMaterial.h>
+#include <OgreMaterialManager.h>
 
 #include "../mwworld/world.hpp" // these includes can be removed once the static-hack is gone
+#include "../mwworld/environment.hpp"
 #include "../mwworld/ptr.hpp"
 #include <components/esm/loadstat.hpp>
+#include <components/esm/loadpgrd.hpp>
 
 #include "player.hpp"
 
-using namespace MWRender;
 using namespace Ogre;
 
-Debugging::Debugging(OEngine::Physic::PhysicEngine* engine){
-	eng = engine;
+namespace MWRender
+{
+
+static const std::string PATHGRID_POINT_MATERIAL = "pathgridPointMaterial";
+static const std::string PATHGRID_LINE_MATERIAL = "pathgridLineMaterial";
+static const std::string DEBUGGING_GROUP = "debugging";
+static const int POINT_MESH_BASE = 35;
+
+void Debugging::createGridMaterials()
+{
+    if (mGridMatsCreated) return;
+
+    if (MaterialManager::getSingleton().getByName(PATHGRID_LINE_MATERIAL, DEBUGGING_GROUP).isNull())
+    {
+        MaterialPtr lineMatPtr = MaterialManager::getSingleton().create(PATHGRID_LINE_MATERIAL, DEBUGGING_GROUP);
+        lineMatPtr->setReceiveShadows(false);
+        lineMatPtr->getTechnique(0)->setLightingEnabled(true);
+        lineMatPtr->getTechnique(0)->getPass(0)->setDiffuse(1,1,0,0);
+        lineMatPtr->getTechnique(0)->getPass(0)->setAmbient(1,1,0);
+        lineMatPtr->getTechnique(0)->getPass(0)->setSelfIllumination(1,1,0);
+    }
+
+    if (MaterialManager::getSingleton().getByName(PATHGRID_POINT_MATERIAL, DEBUGGING_GROUP).isNull())
+    {
+        MaterialPtr pointMatPtr = MaterialManager::getSingleton().create(PATHGRID_POINT_MATERIAL, DEBUGGING_GROUP);
+        pointMatPtr->setReceiveShadows(false);
+        pointMatPtr->getTechnique(0)->setLightingEnabled(true);
+        pointMatPtr->getTechnique(0)->getPass(0)->setDiffuse(1,0,0,0);
+        pointMatPtr->getTechnique(0)->getPass(0)->setAmbient(1,0,0);
+        pointMatPtr->getTechnique(0)->getPass(0)->setSelfIllumination(1,0,0);
+    }
+    mGridMatsCreated = true;
+}
+
+void Debugging::destroyGridMaterials()
+{
+    if (mGridMatsCreated)
+    {
+        MaterialManager::getSingleton().remove(PATHGRID_POINT_MATERIAL);
+        MaterialManager::getSingleton().remove(PATHGRID_LINE_MATERIAL);
+        mGridMatsCreated = false;
+    }
+}
+
+ManualObject *Debugging::createPathgridLines(const ESM::Pathgrid *pathgrid)
+{
+    ManualObject *result = mSceneMgr->createManualObject();
+
+    result->begin(PATHGRID_LINE_MATERIAL, RenderOperation::OT_LINE_LIST);
+    for(ESM::Pathgrid::EdgeList::const_iterator it = pathgrid->edges.begin();
+        it != pathgrid->edges.end();
+        it++)
+    {
+        const ESM::Pathgrid::Edge &edge = *it;
+        const ESM::Pathgrid::Point &p1 = pathgrid->points[edge.v0], &p2 = pathgrid->points[edge.v1];
+        Vector3 direction = (Vector3(p2.x, p2.y, p2.z) - Vector3(p1.x, p1.y, p1.z));
+        Vector3 lineDisplacement = direction.crossProduct(Vector3::UNIT_Z).normalisedCopy();
+        lineDisplacement = lineDisplacement * POINT_MESH_BASE +
+                                Vector3(0, 0, 10); // move lines up a little, so they will be less covered by meshes/landscape
+        result->position(Vector3(p1.x, p1.y, p1.z) + lineDisplacement);
+        result->position(Vector3(p2.x, p2.y, p2.z) + lineDisplacement);
+    }
+    result->end();
+
+    return result;
+}
+
+ManualObject *Debugging::createPathgridPoints(const ESM::Pathgrid *pathgrid)
+{
+    ManualObject *result = mSceneMgr->createManualObject();
+    const float height = POINT_MESH_BASE * sqrtf(2);
+
+    result->begin(PATHGRID_POINT_MATERIAL, RenderOperation::OT_TRIANGLE_STRIP);
+
+    bool first = true;
+    uint32 startIndex = 0;
+    for(ESM::Pathgrid::PointList::const_iterator it = pathgrid->points.begin();
+        it != pathgrid->points.end();
+        it++, startIndex += 6)
+    {
+        Vector3 pointPos(it->x, it->y, it->z);
+
+        if (!first)
+        {
+            // degenerate triangle from previous octahedron
+            result->index(startIndex - 4); // 2nd point of previous octahedron
+            result->index(startIndex); // start point of current octahedron
+        }
+
+        result->position(pointPos + Vector3(0, 0, height)); // 0
+        result->position(pointPos + Vector3(-POINT_MESH_BASE, -POINT_MESH_BASE, 0)); // 1
+        result->position(pointPos + Vector3(POINT_MESH_BASE, -POINT_MESH_BASE, 0)); // 2
+        result->position(pointPos + Vector3(POINT_MESH_BASE, POINT_MESH_BASE, 0)); // 3
+        result->position(pointPos + Vector3(-POINT_MESH_BASE, POINT_MESH_BASE, 0)); // 4
+        result->position(pointPos + Vector3(0, 0, -height)); // 5
+
+        result->index(startIndex + 0);
+        result->index(startIndex + 1);
+        result->index(startIndex + 2);
+        result->index(startIndex + 5);
+        result->index(startIndex + 3);
+        result->index(startIndex + 4);
+        // degenerates
+        result->index(startIndex + 4);
+        result->index(startIndex + 5);
+        result->index(startIndex + 5);
+        // end degenerates
+        result->index(startIndex + 1);
+        result->index(startIndex + 4);
+        result->index(startIndex + 0);
+        result->index(startIndex + 3);
+        result->index(startIndex + 2);
+
+        first = false;
+    }
+
+    result->end();
+
+    return result;
+}
+
+Debugging::Debugging(SceneNode *mwRoot, MWWorld::Environment &env, OEngine::Physic::PhysicEngine *engine) :
+    mMwRoot(mwRoot), mEnvironment(env), mEngine(engine),
+    mSceneMgr(mwRoot->getCreator()),
+    mPathgridEnabled(false),
+    mInteriorPathgridNode(NULL), mPathGridRoot(NULL),
+    mGridMatsCreated(false)
+{
+    ResourceGroupManager::getSingleton().createResourceGroup(DEBUGGING_GROUP);
+}
+
+Debugging::~Debugging()
+{
+    if (mPathgridEnabled)
+    {
+        togglePathgrid();
+    }
+
+    ResourceGroupManager::getSingleton().destroyResourceGroup(DEBUGGING_GROUP);
 }
 
 
 bool Debugging::toggleRenderMode (int mode){
-	 switch (mode)
+    switch (mode)
     {
         case MWWorld::World::Render_CollisionDebug:
 
-            // TODO use a proper function instead of accessing the member variable
-            // directly.
-            eng->setDebugRenderingMode (!eng->isDebugCreated);
-            return eng->isDebugCreated;
+            return mEngine->toggleDebugRendering();
+
+        case MWWorld::World::Render_Pathgrid:
+            togglePathgrid();
+            return mPathgridEnabled;
     }
 
     return false;
 }
+
+void Debugging::cellAdded(MWWorld::Ptr::CellStore *store)
+{
+    mActiveCells.push_back(store);
+    if (mPathgridEnabled)
+        enableCellPathgrid(store);
+}
+
+void Debugging::cellRemoved(MWWorld::Ptr::CellStore *store)
+{
+    mActiveCells.erase(std::remove(mActiveCells.begin(), mActiveCells.end(), store), mActiveCells.end());
+    if (mPathgridEnabled)
+        disableCellPathgrid(store);
+}
+
+void Debugging::togglePathgrid()
+{
+    mPathgridEnabled = !mPathgridEnabled;
+    if (mPathgridEnabled)
+    {
+        createGridMaterials();
+
+        // add path grid meshes to already loaded cells
+        mPathGridRoot = mMwRoot->createChildSceneNode();
+        for(CellList::iterator it = mActiveCells.begin(); it != mActiveCells.end(); it++)
+        {
+            enableCellPathgrid(*it);
+        }
+    }
+    else
+    {
+        // remove path grid meshes from already loaded cells
+        for(CellList::iterator it = mActiveCells.begin(); it != mActiveCells.end(); it++)
+        {
+            disableCellPathgrid(*it);
+        }
+        mPathGridRoot->removeAndDestroyAllChildren();
+        mSceneMgr->destroySceneNode(mPathGridRoot);
+        mPathGridRoot = NULL;
+        destroyGridMaterials();
+    }
+}
+
+void Debugging::enableCellPathgrid(MWWorld::Ptr::CellStore *store)
+{
+    ESM::Pathgrid *pathgrid = mEnvironment.mWorld->getStore().pathgrids.search(*store->cell);
+    if (!pathgrid) return;
+
+    Vector3 cellPathGridPos(0, 0, 0);
+    if (store->cell->isExterior())
+    {
+        cellPathGridPos.x = store->cell->data.gridX * ESM::Land::REAL_SIZE;
+        cellPathGridPos.y = store->cell->data.gridY * ESM::Land::REAL_SIZE;
+    }
+    SceneNode *cellPathGrid = mPathGridRoot->createChildSceneNode(cellPathGridPos);
+    cellPathGrid->attachObject(createPathgridLines(pathgrid));
+    cellPathGrid->attachObject(createPathgridPoints(pathgrid));
+
+    if (store->cell->isExterior())
+    {
+        mExteriorPathgridNodes[std::make_pair(store->cell->data.gridX, store->cell->data.gridY)] = cellPathGrid;
+    }
+    else
+    {
+        assert(mInteriorPathgridNode == NULL);
+        mInteriorPathgridNode = cellPathGrid;
+    }
+}
+
+void Debugging::disableCellPathgrid(MWWorld::Ptr::CellStore *store)
+{
+    if (store->cell->isExterior())
+    {
+        ExteriorPathgridNodes::iterator it =
+                mExteriorPathgridNodes.find(std::make_pair(store->cell->data.gridX, store->cell->data.gridY));
+        if (it != mExteriorPathgridNodes.end())
+        {
+            destroyCellPathgridNode(it->second);
+            mExteriorPathgridNodes.erase(it);
+        }
+    }
+    else
+    {
+        if (mInteriorPathgridNode)
+        {
+            destroyCellPathgridNode(mInteriorPathgridNode);
+            mInteriorPathgridNode = NULL;
+        }
+    }
+}
+
+void Debugging::destroyCellPathgridNode(SceneNode *node)
+{
+    mPathGridRoot->removeChild(node);
+    destroyAttachedObjects(node);
+    mSceneMgr->destroySceneNode(node);
+}
+
+void Debugging::destroyAttachedObjects(SceneNode *node)
+{
+    SceneNode::ObjectIterator objIt = node->getAttachedObjectIterator();
+    while (objIt.hasMoreElements())
+    {
+        MovableObject *mesh = static_cast<MovableObject *>(objIt.getNext());
+        mSceneMgr->destroyMovableObject(mesh);
+    }
+}
+
+}

apps/openmw/mwrender/debugging.hpp

@@ -4,6 +4,7 @@
 #include <utility>
 #include <openengine/ogre/renderer.hpp>
 #include <openengine/bullet/physic.hpp>
+#include "../mwworld/ptr.hpp"
 
 #include <vector>
 #include <string>
@@ -22,20 +23,58 @@ namespace Ogre
 namespace MWWorld
 {
     class World;
+    class Environment;
 }
 
 namespace MWRender
 {
     class Player;
 
-	class Debugging{
-	OEngine::Physic::PhysicEngine* eng;
+    class Debugging
+    {
+        OEngine::Physic::PhysicEngine* mEngine;
+        Ogre::SceneManager *mSceneMgr;
+        MWWorld::Environment& mEnvironment;
 
+        // Path grid stuff
+        bool mPathgridEnabled;
 
-	public:
-		Debugging(OEngine::Physic::PhysicEngine* engine);
-		bool toggleRenderMode (int mode);
-	};
+        void togglePathgrid();
+
+        typedef std::vector<MWWorld::Ptr::CellStore *> CellList;
+        CellList mActiveCells;
+
+        Ogre::SceneNode *mMwRoot;
+
+        Ogre::SceneNode *mPathGridRoot;
+
+        typedef std::map<std::pair<int,int>, Ogre::SceneNode *> ExteriorPathgridNodes;
+        ExteriorPathgridNodes mExteriorPathgridNodes;
+        Ogre::SceneNode *mInteriorPathgridNode;
+
+        void enableCellPathgrid(MWWorld::Ptr::CellStore *store);
+        void disableCellPathgrid(MWWorld::Ptr::CellStore *store);
+
+        // utility
+        void destroyCellPathgridNode(Ogre::SceneNode *node);
+        void destroyAttachedObjects(Ogre::SceneNode *node);
+
+        // materials
+        bool mGridMatsCreated;
+        void createGridMaterials();
+        void destroyGridMaterials();
+
+        // path grid meshes
+        Ogre::ManualObject *createPathgridLines(const ESM::Pathgrid *pathgrid);
+        Ogre::ManualObject *createPathgridPoints(const ESM::Pathgrid *pathgrid);
+    public:
+        Debugging(Ogre::SceneNode* mwRoot, MWWorld::Environment &env, OEngine::Physic::PhysicEngine *engine);
+        ~Debugging();
+        bool toggleRenderMode (int mode);
+
+        void cellAdded(MWWorld::Ptr::CellStore* store);
+        void cellRemoved(MWWorld::Ptr::CellStore* store);
+    };
 
 
 }

apps/openmw/mwrender/objects.cpp

@@ -3,6 +3,7 @@
 #include <OgreSceneNode.h>
 
 #include <components/nifogre/ogre_nif_loader.hpp>
+#include <components/settings/settings.hpp>
 
 using namespace MWRender;
 
@@ -88,38 +89,74 @@ void Objects::insertMesh (const MWWorld::Ptr& ptr, const std::string& mesh)
     NifOgre::NIFLoader::load(mesh);
     Ogre::Entity *ent = mRenderer.getScene()->createEntity(mesh);
 
-    if(!mIsStatic)
+
+    Ogre::Vector3 extents = ent->getBoundingBox().getSize();
+    extents *= insert->getScale();
+    float size = std::max(std::max(extents.x, extents.y), extents.z);
+
+    bool small = (size < Settings::Manager::getInt("small object size", "Viewing distance")) && Settings::Manager::getBool("limit small object distance", "Objects");
+
+    // do not fade out doors. that will cause holes and look stupid
+    if (ptr.getTypeName().find("Door") != std::string::npos)
+        small = false;
+
+    if (mBounds.find(ptr.getCell()) == mBounds.end())
+        mBounds[ptr.getCell()] = Ogre::AxisAlignedBox::BOX_NULL;
+
+    Ogre::AxisAlignedBox bounds = ent->getBoundingBox();
+    bounds = Ogre::AxisAlignedBox(
+        insert->_getDerivedPosition() + bounds.getMinimum(),
+        insert->_getDerivedPosition() + bounds.getMaximum()
+    );
+
+    bounds.scale(insert->getScale());
+    mBounds[ptr.getCell()].merge(bounds);
+
+    if(!mIsStatic || !Settings::Manager::getBool("use static geometry", "Objects"))
     {
         insert->attachObject(ent);
+
+        ent->setRenderingDistance(small ? Settings::Manager::getInt("small object distance", "Viewing distance") : 0); /// \todo config value
     }
     else
     {
         Ogre::StaticGeometry* sg = 0;
-        if(mStaticGeometry.find(ptr.getCell()) == mStaticGeometry.end())
+
+        if (small)
         {
-            uniqueID = uniqueID +1;
-            sg = mRenderer.getScene()->createStaticGeometry( "sg" + Ogre::StringConverter::toString(uniqueID));
-            //Create the scenenode and put it in the map
-            mStaticGeometry[ptr.getCell()] = sg;
+            if( mStaticGeometrySmall.find(ptr.getCell()) == mStaticGeometrySmall.end())
+            {
+                uniqueID = uniqueID +1;
+                sg = mRenderer.getScene()->createStaticGeometry( "sg" + Ogre::StringConverter::toString(uniqueID));
+                mStaticGeometrySmall[ptr.getCell()] = sg;
 
-            // This specifies the size of a single batch region.
-            // If it is set too high:
-            //  - there will be problems choosing the correct lights
-            //  - the culling will be more inefficient
-            // If it is set too low:
-            //  - there will be too many batches.
-            sg->setRegionDimensions(Ogre::Vector3(2500,2500,2500));
-
-            mBounds[ptr.getCell()] = Ogre::AxisAlignedBox::BOX_NULL;
-            mBounds[ptr.getCell()].merge(ent->getBoundingBox());
+                sg->setRenderingDistance(Settings::Manager::getInt("small object distance", "Viewing distance")); /// \todo config value
+            }
+            else
+                sg = mStaticGeometrySmall[ptr.getCell()];
         }
         else
         {
-            sg = mStaticGeometry[ptr.getCell()];
+            if( mStaticGeometry.find(ptr.getCell()) == mStaticGeometry.end())
+            {
+
+                uniqueID = uniqueID +1;
+                sg = mRenderer.getScene()->createStaticGeometry( "sg" + Ogre::StringConverter::toString(uniqueID));
+                mStaticGeometry[ptr.getCell()] = sg;
+            }
+            else
+                sg = mStaticGeometry[ptr.getCell()];
         }
 
+        // This specifies the size of a single batch region.
+        // If it is set too high:
+        //  - there will be problems choosing the correct lights
+        //  - the culling will be more inefficient
+        // If it is set too low:
+        //  - there will be too many batches.
+        sg->setRegionDimensions(Ogre::Vector3(2500,2500,2500));
+
         sg->addEntity(ent,insert->_getDerivedPosition(),insert->_getDerivedOrientation(),insert->_getDerivedScale());
-        mBounds[ptr.getCell()].merge(insert->_getDerivedPosition());
 
         mRenderer.getScene()->destroyEntity(ent);
     }
@@ -206,7 +243,14 @@ void Objects::removeCell(MWWorld::Ptr::CellStore* store)
         mRenderer.getScene()->destroyStaticGeometry (sg);
         sg = 0;
     }
-    
+    if(mStaticGeometrySmall.find(store) != mStaticGeometrySmall.end())
+    {
+        Ogre::StaticGeometry* sg = mStaticGeometrySmall[store];
+        mStaticGeometrySmall.erase(store);
+        mRenderer.getScene()->destroyStaticGeometry (sg);
+        sg = 0;
+    }
+
     if(mBounds.find(store) != mBounds.end())
         mBounds.erase(store);
 }
@@ -218,6 +262,11 @@ void Objects::buildStaticGeometry(ESMS::CellStore<MWWorld::RefData>& cell)
         Ogre::StaticGeometry* sg = mStaticGeometry[&cell];
         sg->build();
     }
+    if(mStaticGeometrySmall.find(&cell) != mStaticGeometrySmall.end())
+    {
+        Ogre::StaticGeometry* sg = mStaticGeometrySmall[&cell];
+        sg->build();
+    }
 }
 
 Ogre::AxisAlignedBox Objects::getDimensions(MWWorld::Ptr::CellStore* cell)

apps/openmw/mwrender/objects.hpp

@@ -14,6 +14,7 @@ class Objects{
     OEngine::Render::OgreRenderer &mRenderer;
     std::map<MWWorld::Ptr::CellStore *, Ogre::SceneNode *> mCellSceneNodes;
     std::map<MWWorld::Ptr::CellStore *, Ogre::StaticGeometry*> mStaticGeometry;
+    std::map<MWWorld::Ptr::CellStore *, Ogre::StaticGeometry*> mStaticGeometrySmall;
     std::map<MWWorld::Ptr::CellStore *, Ogre::AxisAlignedBox> mBounds;
     Ogre::SceneNode* mMwRoot;
     bool mIsStatic;

apps/openmw/mwrender/occlusionquery.cpp

@@ -0,0 +1,302 @@
+#include "occlusionquery.hpp"
+
+#include <OgreRenderSystem.h>
+#include <OgreRoot.h>
+#include <OgreBillboardSet.h>
+#include <OgreHardwareOcclusionQuery.h>
+#include <OgreEntity.h>
+#include <OgreSubEntity.h>
+
+using namespace MWRender;
+using namespace Ogre;
+
+OcclusionQuery::OcclusionQuery(OEngine::Render::OgreRenderer* renderer, SceneNode* sunNode) :
+    mSunTotalAreaQuery(0), mSunVisibleAreaQuery(0), mSingleObjectQuery(0), mActiveQuery(0),
+    mDoQuery(0), mSunVisibility(0), mQuerySingleObjectStarted(false), mTestResult(false),
+    mQuerySingleObjectRequested(false), mWasVisible(false), mObjectWasVisible(false), mDoQuery2(false),
+    mBBNode(0)
+{
+    mRendering = renderer;
+    mSunNode = sunNode;
+
+    try {
+        RenderSystem* renderSystem = Root::getSingleton().getRenderSystem();
+
+        mSunTotalAreaQuery = renderSystem->createHardwareOcclusionQuery();
+        mSunVisibleAreaQuery = renderSystem->createHardwareOcclusionQuery();
+        mSingleObjectQuery = renderSystem->createHardwareOcclusionQuery();
+
+        mSupported = (mSunTotalAreaQuery != 0) && (mSunVisibleAreaQuery != 0) && (mSingleObjectQuery != 0);
+    }
+    catch (Ogre::Exception e)
+    {
+        mSupported = false;
+    }
+
+    if (!mSupported)
+    {
+        std::cout << "Hardware occlusion queries not supported." << std::endl;
+        return;
+    }
+
+    // This means that everything up to RENDER_QUEUE_MAIN can occlude the objects that are tested
+    const int queue = RENDER_QUEUE_MAIN+1;
+
+    MaterialPtr matBase = MaterialManager::getSingleton().getByName("BaseWhiteNoLighting");
+    MaterialPtr matQueryArea = matBase->clone("QueryTotalPixels");
+    matQueryArea->setDepthWriteEnabled(false);
+    matQueryArea->setColourWriteEnabled(false);
+    matQueryArea->setDepthCheckEnabled(false); // Not occluded by objects
+    MaterialPtr matQueryVisible = matBase->clone("QueryVisiblePixels");
+    matQueryVisible->setDepthWriteEnabled(false);
+    matQueryVisible->setColourWriteEnabled(false); // Uncomment this to visualize the occlusion query
+    matQueryVisible->setDepthCheckEnabled(true); // Occluded by objects
+    matQueryVisible->setCullingMode(CULL_NONE);
+    matQueryVisible->setManualCullingMode(MANUAL_CULL_NONE);
+
+    if (sunNode)
+        mBBNode = mSunNode->getParentSceneNode()->createChildSceneNode();
+
+    mObjectNode = mRendering->getScene()->getRootSceneNode()->createChildSceneNode();
+    mBBNodeReal = mRendering->getScene()->getRootSceneNode()->createChildSceneNode();
+
+    mBBQueryTotal = mRendering->getScene()->createBillboardSet(1);
+    mBBQueryTotal->setDefaultDimensions(150, 150);
+    mBBQueryTotal->createBillboard(Vector3::ZERO);
+    mBBQueryTotal->setMaterialName("QueryTotalPixels");
+    mBBQueryTotal->setRenderQueueGroup(queue+1);
+    mBBNodeReal->attachObject(mBBQueryTotal);
+
+    mBBQueryVisible = mRendering->getScene()->createBillboardSet(1);
+    mBBQueryVisible->setDefaultDimensions(150, 150);
+    mBBQueryVisible->createBillboard(Vector3::ZERO);
+    mBBQueryVisible->setMaterialName("QueryVisiblePixels");
+    mBBQueryVisible->setRenderQueueGroup(queue+1);
+    mBBNodeReal->attachObject(mBBQueryVisible);
+
+    mBBQuerySingleObject = mRendering->getScene()->createBillboardSet(1);
+    /// \todo ideally this should occupy exactly 1 pixel on the screen
+    mBBQuerySingleObject->setDefaultDimensions(0.003, 0.003);
+    mBBQuerySingleObject->createBillboard(Vector3::ZERO);
+    mBBQuerySingleObject->setMaterialName("QueryVisiblePixels");
+    mBBQuerySingleObject->setRenderQueueGroup(queue);
+    mObjectNode->attachObject(mBBQuerySingleObject);
+
+    mRendering->getScene()->addRenderObjectListener(this);
+    mRendering->getScene()->addRenderQueueListener(this);
+    mDoQuery = true;
+}
+
+OcclusionQuery::~OcclusionQuery()
+{
+    RenderSystem* renderSystem = Root::getSingleton().getRenderSystem();
+    if (mSunTotalAreaQuery) renderSystem->destroyHardwareOcclusionQuery(mSunTotalAreaQuery);
+    if (mSunVisibleAreaQuery) renderSystem->destroyHardwareOcclusionQuery(mSunVisibleAreaQuery);
+    if (mSingleObjectQuery) renderSystem->destroyHardwareOcclusionQuery(mSingleObjectQuery);
+}
+
+bool OcclusionQuery::supported()
+{
+    return mSupported;
+}
+
+void OcclusionQuery::notifyRenderSingleObject(Renderable* rend, const Pass* pass, const AutoParamDataSource* source,
+			const LightList* pLightList, bool suppressRenderStateChanges)
+{
+    // The following code activates and deactivates the occlusion queries
+    // so that the queries only include the rendering of their intended targets
+
+    // Close the last occlusion query
+    // Each occlusion query should only last a single rendering
+    if (mActiveQuery != NULL)
+    {
+        mActiveQuery->endOcclusionQuery();
+        mActiveQuery = NULL;
+    }
+
+    // Open a new occlusion query
+    if (mDoQuery == true)
+    {
+        if (rend == mBBQueryTotal)
+        {
+            mActiveQuery = mSunTotalAreaQuery;
+            mWasVisible = true;
+        }
+        else if (rend == mBBQueryVisible)
+        {
+            mActiveQuery = mSunVisibleAreaQuery;
+        }
+    }
+    if (mDoQuery == true && rend == mBBQuerySingleObject)
+    {
+        mQuerySingleObjectStarted = true;
+        mQuerySingleObjectRequested = false;
+        mActiveQuery = mSingleObjectQuery;
+        mObjectWasVisible = true;
+    }
+
+    if (mActiveQuery != NULL)
+        mActiveQuery->beginOcclusionQuery();
+}
+
+void OcclusionQuery::renderQueueEnded(uint8 queueGroupId, const String& invocation, bool& repeatThisInvocation)
+{
+    if (mActiveQuery != NULL)
+    {
+        mActiveQuery->endOcclusionQuery();
+        mActiveQuery = NULL;
+    }
+    /**
+     * for every beginOcclusionQuery(), we want a respective pullOcclusionQuery() and vice versa
+     * this also means that results can be wrong at other places if we pull, but beginOcclusionQuery() was never called
+     * this can happen for example if the object that is tested is outside of the view frustum
+     * to prevent this, check if the queries have been performed after everything has been rendered and if not, start them manually
+     */
+    if (queueGroupId == RENDER_QUEUE_SKIES_LATE)
+    {
+        if (mWasVisible == false && mDoQuery)
+        {
+            mSunTotalAreaQuery->beginOcclusionQuery();
+            mSunTotalAreaQuery->endOcclusionQuery();
+            mSunVisibleAreaQuery->beginOcclusionQuery();
+            mSunVisibleAreaQuery->endOcclusionQuery();
+        }
+        if (mObjectWasVisible == false && mDoQuery)
+        {
+            mSingleObjectQuery->beginOcclusionQuery();
+            mSingleObjectQuery->endOcclusionQuery();
+            mQuerySingleObjectStarted = true;
+            mQuerySingleObjectRequested = false;
+        }
+    }
+}
+
+void OcclusionQuery::update(float duration)
+{
+    if (!mSupported) return;
+
+    mWasVisible = false;
+    mObjectWasVisible = false;
+
+    // Adjust the position of the sun billboards according to camera viewing distance
+    // we need to do this to make sure that _everything_ can occlude the sun
+    float dist = mRendering->getCamera()->getFarClipDistance();
+    if (dist==0) dist = 10000000;
+    dist -= 1000; // bias
+    dist /= 1000.f;
+    if (mBBNode)
+    {
+        mBBNode->setPosition(mSunNode->getPosition() * dist);
+        mBBNode->setScale(dist, dist, dist);
+        mBBNodeReal->setPosition(mBBNode->_getDerivedPosition());
+        mBBNodeReal->setScale(mBBNode->getScale());
+    }
+
+    // Stop occlusion queries until we get their information
+    // (may not happen on the same frame they are requested in)
+    mDoQuery = false;
+
+    if (!mSunTotalAreaQuery->isStillOutstanding()
+        && !mSunVisibleAreaQuery->isStillOutstanding()
+        && !mSingleObjectQuery->isStillOutstanding())
+    {
+        unsigned int totalPixels;
+        unsigned int visiblePixels;
+
+        mSunTotalAreaQuery->pullOcclusionQuery(&totalPixels);
+        mSunVisibleAreaQuery->pullOcclusionQuery(&visiblePixels);
+
+        if (totalPixels == 0)
+        {
+            // probably outside of the view frustum
+            mSunVisibility = 0;
+        }
+        else
+        {
+            mSunVisibility = float(visiblePixels) / float(totalPixels);
+            if (mSunVisibility > 1) mSunVisibility = 1;
+        }
+
+        unsigned int result;
+
+        mSingleObjectQuery->pullOcclusionQuery(&result);
+
+        mTestResult = (result != 0);
+
+        mQuerySingleObjectStarted = false;
+        mQuerySingleObjectRequested = false;
+
+        mDoQuery = true;
+    }
+}
+
+void OcclusionQuery::occlusionTest(const Ogre::Vector3& position, Ogre::SceneNode* object)
+{
+    assert( !occlusionTestPending()
+        && "Occlusion test still pending");
+
+    mBBQuerySingleObject->setVisible(true);
+
+    mObjectNode->setPosition(position);
+    // scale proportional to camera distance, in order to always give the billboard the same size in screen-space
+    mObjectNode->setScale( Vector3(1,1,1)*(position - mRendering->getCamera()->getRealPosition()).length() );
+
+    mQuerySingleObjectRequested = true;
+}
+
+bool OcclusionQuery::occlusionTestPending()
+{
+    return (mQuerySingleObjectRequested || mQuerySingleObjectStarted);
+}
+
+void OcclusionQuery::setSunNode(Ogre::SceneNode* node)
+{
+    mSunNode = node;
+    if (!mBBNode)
+        mBBNode = node->getParentSceneNode()->createChildSceneNode();
+}
+
+bool OcclusionQuery::getTestResult()
+{
+    assert( !occlusionTestPending()
+        && "Occlusion test still pending");
+
+    return mTestResult;
+}
+
+bool OcclusionQuery::isPotentialOccluder(Ogre::SceneNode* node)
+{
+    bool result = false;
+    for (unsigned int i=0; i < node->numAttachedObjects(); ++i)
+    {
+        MovableObject* ob = node->getAttachedObject(i);
+        std::string type = ob->getMovableType();
+        if (type == "Entity")
+        {
+            Entity* ent = static_cast<Entity*>(ob);
+            for (unsigned int j=0; j < ent->getNumSubEntities(); ++j)
+            {
+                // if any sub entity has a material with depth write off,
+                // consider the object as not an occluder
+                MaterialPtr mat = ent->getSubEntity(j)->getMaterial();
+
+                Material::TechniqueIterator techIt = mat->getTechniqueIterator();
+                while (techIt.hasMoreElements())
+                {
+                    Technique* tech = techIt.getNext();
+                    Technique::PassIterator passIt = tech->getPassIterator();
+                    while (passIt.hasMoreElements())
+                    {
+                        Pass* pass = passIt.getNext();
+
+                        if (pass->getDepthWriteEnabled() == false)
+                            return false;
+                        else
+                            result = true;
+                    }
+                }
+            }
+        }
+    }
+    return result;
+}

apps/openmw/mwrender/occlusionquery.hpp

@@ -0,0 +1,105 @@
+#ifndef _GAME_OCCLUSION_QUERY_H
+#define _GAME_OCCLUSION_QUERY_H
+
+#include <OgreRenderObjectListener.h>
+#include <OgreRenderQueueListener.h>
+
+namespace Ogre
+{
+    class HardwareOcclusionQuery;
+    class Entity;
+    class SceneNode;
+}
+
+#include <openengine/ogre/renderer.hpp>
+
+namespace MWRender
+{
+    ///
+    /// \brief Implements hardware occlusion queries on the GPU
+    ///
+    class OcclusionQuery : public Ogre::RenderObjectListener, public Ogre::RenderQueueListener
+    {
+    public:
+        OcclusionQuery(OEngine::Render::OgreRenderer*, Ogre::SceneNode* sunNode);
+        ~OcclusionQuery();
+
+        /**
+         * @return true if occlusion queries are supported on the user's hardware
+         */
+        bool supported();
+
+        /**
+         * per-frame update
+         */
+        void update(float duration);
+
+        /**
+         * request occlusion test for a billboard at the given position, omitting an entity
+         * @param position of the billboard in ogre coordinates
+         * @param object to exclude from the occluders
+         */
+        void occlusionTest(const Ogre::Vector3& position, Ogre::SceneNode* object);
+
+        /**
+         * @return true if a request is still outstanding
+         */
+        bool occlusionTestPending();
+
+        /**
+         * Checks if the objects held by this scenenode
+         * can be considered as potential occluders
+         * (which might not be the case when transparency is involved)
+         * @param Scene node
+         */
+        bool isPotentialOccluder(Ogre::SceneNode* node);
+
+        /**
+         * @return true if the object tested in the last request was occluded
+         */
+        bool getTestResult();
+
+        float getSunVisibility() const {return mSunVisibility;};
+
+        void setSunNode(Ogre::SceneNode* node);
+
+    private:
+        Ogre::HardwareOcclusionQuery* mSunTotalAreaQuery;
+        Ogre::HardwareOcclusionQuery* mSunVisibleAreaQuery;
+        Ogre::HardwareOcclusionQuery* mSingleObjectQuery;
+        Ogre::HardwareOcclusionQuery* mActiveQuery;
+
+        Ogre::BillboardSet* mBBQueryVisible;
+        Ogre::BillboardSet* mBBQueryTotal;
+        Ogre::BillboardSet* mBBQuerySingleObject;
+
+        Ogre::SceneNode* mSunNode;
+        Ogre::SceneNode* mBBNode;
+        Ogre::SceneNode* mBBNodeReal;
+        float mSunVisibility;
+
+        Ogre::SceneNode* mObjectNode;
+
+        bool mWasVisible;
+        bool mObjectWasVisible;
+
+        bool mTestResult;
+
+        bool mSupported;
+        bool mDoQuery;
+        bool mDoQuery2;
+
+        bool mQuerySingleObjectRequested;
+        bool mQuerySingleObjectStarted;
+
+        OEngine::Render::OgreRenderer* mRendering;
+
+    protected:
+        virtual void notifyRenderSingleObject(Ogre::Renderable* rend, const Ogre::Pass* pass, const Ogre::AutoParamDataSource* source, 
+			const Ogre::LightList* pLightList, bool suppressRenderStateChanges);
+
+        virtual void renderQueueEnded(Ogre::uint8 queueGroupId, const Ogre::String& invocation, bool& repeatThisInvocation);
+    };
+}
+
+#endif

apps/openmw/mwrender/renderingmanager.cpp

@@ -12,6 +12,7 @@
 #include "../mwworld/world.hpp" // these includes can be removed once the static-hack is gone
 #include "../mwworld/ptr.hpp"
 #include <components/esm/loadstat.hpp>
+#include <components/settings/settings.hpp>
 
 
 using namespace MWRender;
@@ -20,7 +21,7 @@ using namespace Ogre;
 namespace MWRender {
 
 RenderingManager::RenderingManager (OEngine::Render::OgreRenderer& _rend, const boost::filesystem::path& resDir, OEngine::Physic::PhysicEngine* engine, MWWorld::Environment& environment)
-:mRendering(_rend), mObjects(mRendering), mActors(mRendering, environment), mAmbientMode(0), mDebugging(engine)
+    :mRendering(_rend), mObjects(mRendering), mActors(mRendering, environment), mAmbientMode(0)
 {
     mRendering.createScene("PlayerCam", 55, 5);
     mTerrainManager = new TerrainManager(mRendering.getScene(),
@@ -46,22 +47,24 @@ RenderingManager::RenderingManager (OEngine::Render::OgreRenderer& _rend, const
     mMwRoot->pitch(Degree(-90));
     mObjects.setMwRoot(mMwRoot);
     mActors.setMwRoot(mMwRoot);
-        
-    //used to obtain ingame information of ogre objects (which are faced or selected)
-    mRaySceneQuery = mRendering.getScene()->createRayQuery(Ray());
 
     Ogre::SceneNode *playerNode = mMwRoot->createChildSceneNode ("player");
     playerNode->pitch(Degree(90));
     Ogre::SceneNode *cameraYawNode = playerNode->createChildSceneNode();
     Ogre::SceneNode *cameraPitchNode = cameraYawNode->createChildSceneNode();
     cameraPitchNode->attachObject(mRendering.getCamera());
-    
+
     //mSkyManager = 0;
     mSkyManager = new SkyManager(mMwRoot, mRendering.getCamera(), &environment);
 
+    mOcclusionQuery = new OcclusionQuery(&mRendering, mSkyManager->getSunNode());
+
+    mWater = 0;
+
     mPlayer = new MWRender::Player (mRendering.getCamera(), playerNode);
     mSun = 0;
 
+    mDebugging = new Debugging(mMwRoot, environment, engine);
     mLocalMap = new MWRender::LocalMap(&mRendering, &environment);
 }
 
@@ -70,8 +73,10 @@ RenderingManager::~RenderingManager ()
     //TODO: destroy mSun?
     delete mPlayer;
     delete mSkyManager;
+    delete mDebugging;
     delete mTerrainManager;
     delete mLocalMap;
+    delete mOcclusionQuery;
 }
 
 MWRender::SkyManager* RenderingManager::getSkyManager()
@@ -95,16 +100,33 @@ OEngine::Render::Fader* RenderingManager::getFader()
     return mRendering.getFader();
 }
 
-void RenderingManager::removeCell (MWWorld::Ptr::CellStore *store){
+void RenderingManager::removeCell (MWWorld::Ptr::CellStore *store)
+{
     mObjects.removeCell(store);
     mActors.removeCell(store);
+    mDebugging->cellRemoved(store);
     if (store->cell->isExterior())
       mTerrainManager->cellRemoved(store);
 }
 
+void RenderingManager::removeWater ()
+{
+    if(mWater){
+        delete mWater;
+        mWater = 0;
+    }
+}
+
+void RenderingManager::toggleWater()
+{
+    if (mWater)
+        mWater->toggle();
+}
+
 void RenderingManager::cellAdded (MWWorld::Ptr::CellStore *store)
 {
     mObjects.buildStaticGeometry (*store);
+    mDebugging->cellAdded(store);
     if (store->cell->isExterior())
       mTerrainManager->cellAdded(store);
 }
@@ -147,18 +169,45 @@ void RenderingManager::moveObjectToCell (const MWWorld::Ptr& ptr, const Ogre::Ve
 void RenderingManager::update (float duration){
 
     mActors.update (duration);
-    
+
+    mOcclusionQuery->update(duration);
+
     mSkyManager->update(duration);
-    
+
+    mSkyManager->setGlare(mOcclusionQuery->getSunVisibility());
+
     mRendering.update(duration);
 
     mLocalMap->updatePlayer( mRendering.getCamera()->getRealPosition(), mRendering.getCamera()->getRealDirection() );
+
+    checkUnderwater();
+}
+void RenderingManager::waterAdded (MWWorld::Ptr::CellStore *store){
+    if(store->cell->data.flags & store->cell->HasWater){
+        if(mWater == 0)
+            mWater = new MWRender::Water(mRendering.getCamera(), store->cell);
+        else
+            mWater->changeCell(store->cell);
+        //else
+
+    }
+    else
+        removeWater();
+
+}
+
+void RenderingManager::setWaterHeight(const float height)
+{
+    if (mWater)
+        mWater->setHeight(height);
 }
 
 void RenderingManager::skyEnable ()
 {
     if(mSkyManager)
     mSkyManager->enable();
+
+    mOcclusionQuery->setSunNode(mSkyManager->getSunNode());
 }
 
 void RenderingManager::skyDisable ()
@@ -182,7 +231,7 @@ void RenderingManager::skySetDate (int day, int month)
 
 int RenderingManager::skyGetMasserPhase() const
 {
-   
+
     return mSkyManager->getMasserPhase();
 }
 
@@ -198,8 +247,8 @@ void RenderingManager::skySetMoonColour (bool red){
 
 bool RenderingManager::toggleRenderMode(int mode)
 {
-    if (mode == MWWorld::World::Render_CollisionDebug)
-        return mDebugging.toggleRenderMode(mode);
+    if (mode != MWWorld::World::Render_Wireframe)
+        return mDebugging->toggleRenderMode(mode);
     else // if (mode == MWWorld::World::Render_Wireframe)
     {
         if (mRendering.getCamera()->getPolygonMode() == PM_SOLID)
@@ -224,19 +273,15 @@ void RenderingManager::configureFog(ESMS::CellStore<MWWorld::RefData> &mCell)
 }
 
 void RenderingManager::configureFog(const float density, const Ogre::ColourValue& colour)
-{  
-  /// \todo make the viewing distance and fog start/end configurable
+{
+  float max = Settings::Manager::getFloat("max viewing distance", "Viewing distance");
 
-  // right now we load 3x3 cells, so the maximum viewing distance we 
-  // can allow (to prevent objects suddenly popping up) equals:
-  // 8192            * 0.69
-  //   ^ cell size    ^ minimum density value used (clear weather)
-  float low = 5652.48 / density / 2.f;
-  float high = 5652.48 / density;
+  float low = max / (density) * Settings::Manager::getFloat("fog start factor", "Viewing distance");
+  float high = max / (density) * Settings::Manager::getFloat("fog end factor", "Viewing distance");
 
   mRendering.getScene()->setFog (FOG_LINEAR, colour, 0, low, high);
-  
-  mRendering.getCamera()->setFarClipDistance ( high );
+
+  mRendering.getCamera()->setFarClipDistance ( max / density );
   mRendering.getViewport()->setBackgroundColour (colour);
 }
 
@@ -297,6 +342,11 @@ void RenderingManager::toggleLight()
 
   setAmbientMode();
 }
+void RenderingManager::checkUnderwater(){
+    if(mWater){
+         mWater->checkUnderwater( mRendering.getCamera()->getRealPosition().y );
+    }
+}
 
 void RenderingManager::playAnimationGroup (const MWWorld::Ptr& ptr, const std::string& groupName,
      int mode, int number)
@@ -333,10 +383,10 @@ void RenderingManager::sunDisable()
 
 void RenderingManager::setSunDirection(const Ogre::Vector3& direction)
 {
-    // direction * -1 (because 'direction' is camera to sun vector and not sun to camera), 
+    // direction * -1 (because 'direction' is camera to sun vector and not sun to camera),
     // then convert from MW to ogre coordinates (swap y,z and make y negative)
     if (mSun) mSun->setDirection(Vector3(-direction.x, -direction.z, direction.y));
-    
+
     mSkyManager->setSunDirection(direction);
 }
 

apps/openmw/mwrender/renderingmanager.hpp

@@ -25,7 +25,9 @@
 #include "objects.hpp"
 #include "actors.hpp"
 #include "player.hpp"
+#include "water.hpp"
 #include "localmap.hpp"
+#include "occlusionquery.hpp"
 
 namespace Ogre
 {
@@ -60,6 +62,8 @@ class RenderingManager: private RenderingInterface {
     RenderingManager(OEngine::Render::OgreRenderer& _rend, const boost::filesystem::path& resDir, OEngine::Physic::PhysicEngine* engine, MWWorld::Environment& environment);
     virtual ~RenderingManager();
 
+
+
     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
@@ -68,7 +72,7 @@ class RenderingManager: private RenderingInterface {
 
     void toggleLight();
     bool toggleRenderMode(int mode);
-    
+
     OEngine::Render::Fader* getFader();
 
     void removeCell (MWWorld::Ptr::CellStore *store);
@@ -76,6 +80,9 @@ class RenderingManager: private RenderingInterface {
     /// \todo this function should be removed later. Instead the rendering subsystems should track
     /// when rebatching is needed and update automatically at the end of each frame.
     void cellAdded (MWWorld::Ptr::CellStore *store);
+    void waterAdded(MWWorld::Ptr::CellStore *store);
+
+    void removeWater();
 
     void preCellChange (MWWorld::Ptr::CellStore* store);
     ///< this event is fired immediately before changing cell
@@ -87,17 +94,24 @@ class RenderingManager: private RenderingInterface {
     void scaleObject (const MWWorld::Ptr& ptr, const Ogre::Vector3& scale);
     void rotateObject (const MWWorld::Ptr& ptr, const::Ogre::Quaternion& orientation);
 
+    void checkUnderwater();
+    void setWaterHeight(const float height);
+    void toggleWater();
+
     /// \param store Cell the object was in previously (\a ptr has already been updated to the new cell).
     void moveObjectToCell (const MWWorld::Ptr& ptr, const Ogre::Vector3& position, MWWorld::Ptr::CellStore *store);
 
     void update (float duration);
-    
+
     void setAmbientColour(const Ogre::ColourValue& colour);
     void setSunColour(const Ogre::ColourValue& colour);
     void setSunDirection(const Ogre::Vector3& direction);
     void sunEnable();
     void sunDisable();
-    
+
+    bool occlusionQuerySupported() { return mOcclusionQuery->supported(); };
+    OcclusionQuery* getOcclusionQuery() { return mOcclusionQuery; };
+
     void setGlare(bool glare);
     void skyEnable ();
     void skyDisable ();
@@ -110,13 +124,13 @@ class RenderingManager: private RenderingInterface {
 
     void requestMap (MWWorld::Ptr::CellStore* cell);
     ///< request the local map for a cell
-    
+
     /// configure fog according to cell
     void configureFog(ESMS::CellStore<MWWorld::RefData> &mCell);
-    
+
     /// configure fog manually
     void configureFog(const float density, const Ogre::ColourValue& colour);
-    
+
     void playAnimationGroup (const MWWorld::Ptr& ptr, const std::string& groupName, int mode,
         int number = 1);
     ///< Run animation for a MW-reference. Calls to this function for references that are currently not
@@ -132,10 +146,15 @@ class RenderingManager: private RenderingInterface {
   private:
 
     void setAmbientMode();
-    
+
     SkyManager* mSkyManager;
 
+    OcclusionQuery* mOcclusionQuery;
+
     TerrainManager* mTerrainManager;
+
+    MWRender::Water *mWater;
+
     OEngine::Render::OgreRenderer &mRendering;
 
     MWRender::Objects mObjects;
@@ -151,12 +170,12 @@ class RenderingManager: private RenderingInterface {
     /// that the OGRE coordinate system matches that used internally in
     /// Morrowind.
     Ogre::SceneNode *mMwRoot;
-    Ogre::RaySceneQuery *mRaySceneQuery;
 
     OEngine::Physic::PhysicEngine* mPhysicsEngine;
 
     MWRender::Player *mPlayer;
-    MWRender::Debugging mDebugging;
+
+    MWRender::Debugging *mDebugging;
 
     MWRender::LocalMap* mLocalMap;
 };

apps/openmw/mwrender/sky.cpp

@@ -12,6 +12,7 @@
 
 #include "../mwworld/environment.hpp"
 #include "../mwworld/world.hpp"
+#include "occlusionquery.hpp"
 
 using namespace MWRender;
 using namespace Ogre;
@@ -30,7 +31,7 @@ BillboardObject::BillboardObject()
 
 void BillboardObject::setVisible(const bool visible)
 {
-    mNode->setVisible(visible);
+    mBBSet->setVisible(visible);
 }
 
 void BillboardObject::setSize(const float size)
@@ -88,7 +89,7 @@ void BillboardObject::init(const String& textureName,
     /// \todo These billboards are not 100% correct, might want to revisit them later
     mBBSet = sceneMgr->createBillboardSet("SkyBillboardSet"+StringConverter::toString(bodyCount), 1);
     mBBSet->setDefaultDimensions(550.f*initialSize, 550.f*initialSize);
-    mBBSet->setRenderQueueGroup(RENDER_QUEUE_SKIES_EARLY+2);
+    mBBSet->setRenderQueueGroup(RENDER_QUEUE_MAIN+2);
     mBBSet->setBillboardType(BBT_PERPENDICULAR_COMMON);
     mBBSet->setCommonDirection( -position.normalisedCopy() );
     mNode = rootNode->createChildSceneNode();
@@ -319,19 +320,22 @@ SkyManager::SkyManager (SceneNode* pMwRoot, Camera* pCamera, MWWorld::Environmen
     , mThunderTextureUnit(NULL)
     , mRemainingTransitionTime(0.0f)
     , mGlareFade(0.0f)
+    , mGlare(0.0f)
     , mEnabled(true)
-    , mGlareEnabled(true)
     , mSunEnabled(true)
     , mMasserEnabled(true)
     , mSecundaEnabled(true)
+    , mCreated(false)
 {
-
     mViewport = pCamera->getViewport();
     mSceneMgr = pMwRoot->getCreator();
     mRootNode = pCamera->getParentSceneNode()->createChildSceneNode();
     mRootNode->pitch(Degree(-90)); // convert MW to ogre coordinates
     mRootNode->setInheritOrientation(false);
+}
 
+void SkyManager::create()
+{
     /// \todo preload all the textures and meshes that are used for sky rendering
 
     // Create overlay used for thunderstorm
@@ -532,7 +536,7 @@ SkyManager::SkyManager (SceneNode* pMwRoot, Camera* pCamera, MWWorld::Environmen
     "   uniform float4 emissive \n"
     ")	\n"
     "{	\n"
-    "   uv += float2(1,0) * time * speed * 0.003; \n" // Scroll in x direction
+    "   uv += float2(0,1) * time * speed * 0.003; \n" // Scroll in y direction
     "   float4 tex = lerp(tex2D(texture, uv), tex2D(secondTexture, uv), transitionFactor); \n"
     "   oColor = color * float4(emissive.xyz,1) * tex * float4(1,1,1,opacity); \n"
     "}";
@@ -561,6 +565,8 @@ SkyManager::SkyManager (SceneNode* pMwRoot, Camera* pCamera, MWWorld::Environmen
     mCloudMaterial->getTechnique(0)->getPass(0)->setSceneBlending(SBT_TRANSPARENT_ALPHA);
 
     mCloudMaterial->getTechnique(0)->getPass(0)->createTextureUnitState("");
+
+    mCreated = true;
 }
 
 SkyManager::~SkyManager()
@@ -573,11 +579,13 @@ SkyManager::~SkyManager()
 
 int SkyManager::getMasserPhase() const
 {
+    if (!mCreated) return 0;
     return mMasser->getPhaseInt();
 }
 
 int SkyManager::getSecundaPhase() const
 {
+    if (!mCreated) return 0;
     return mSecunda->getPhaseInt();
 }
 
@@ -592,10 +600,23 @@ void SkyManager::update(float duration)
     mMasser->setPhase( static_cast<Moon::Phase>( (int) ((mDay % 32)/4.f)) );
     mSecunda->setPhase ( static_cast<Moon::Phase>( (int) ((mDay % 32)/4.f)) );
 
-    // increase the strength of the sun glare effect depending
-    // on how directly the player is looking at the sun
+
     if (mSunEnabled)
     {
+        // take 1/5 sec for fading the glare effect from invisible to full
+        if (mGlareFade > mGlare)
+        {
+            mGlareFade -= duration*5;
+            if (mGlareFade < mGlare) mGlareFade = mGlare;
+        }
+        else if (mGlareFade < mGlare)
+        {
+            mGlareFade += duration*5;
+            if (mGlareFade > mGlare) mGlareFade = mGlare;
+        }
+
+        // increase the strength of the sun glare effect depending
+        // on how directly the player is looking at the sun
         Vector3 sun = mSunGlare->getPosition();
         sun = Vector3(sun.x, sun.z, -sun.y);
         Vector3 cam = mViewport->getCamera()->getRealDirection();
@@ -603,21 +624,10 @@ void SkyManager::update(float duration)
         float val = 1- (angle.valueDegrees() / 180.f);
         val = (val*val*val*val)*2;
 
-        if (mGlareEnabled)
-        {
-            mGlareFade += duration*3;
-            if (mGlareFade > 1) mGlareFade = 1;
-        }
-        else
-        {
-            mGlareFade -= duration*3;
-            if (mGlareFade < 0.3) mGlareFade = 0;
-        }
-
-        mSunGlare->setSize(val * (mGlareFade));
+        mSunGlare->setSize(val * mGlareFade);
     }
 
-    mSunGlare->setVisible(mGlareFade>0 && mSunEnabled);
+    mSunGlare->setVisible(mSunEnabled);
     mSun->setVisible(mSunEnabled);
     mMasser->setVisible(mMasserEnabled);
     mSecunda->setVisible(mSecundaEnabled);
@@ -628,6 +638,9 @@ void SkyManager::update(float duration)
 
 void SkyManager::enable()
 {
+    if (!mCreated)
+        create();
+
     mRootNode->setVisible(true);
     mEnabled = true;
 }
@@ -651,6 +664,7 @@ void SkyManager::setCloudsOpacity(float opacity)
 
 void SkyManager::setWeather(const MWWorld::WeatherResult& weather)
 {
+    if (!mCreated) return;
     if (mClouds != weather.mCloudTexture)
     {
         mCloudMaterial->getTechnique(0)->getPass(0)->getTextureUnitState(0)->setTextureName("textures\\"+weather.mCloudTexture);
@@ -719,15 +733,15 @@ void SkyManager::setWeather(const MWWorld::WeatherResult& weather)
     else
         strength = 1.f;
 
-    mSunGlare->setVisibility(weather.mGlareView * strength);
-    mSun->setVisibility(strength);
+    mSunGlare->setVisibility(weather.mGlareView * mGlareFade * strength);
+    mSun->setVisibility(mGlareFade >= 0.5 ? weather.mGlareView * mGlareFade * strength : 0);
 
     mAtmosphereNight->setVisible(weather.mNight && mEnabled);
 }
 
-void SkyManager::setGlare(bool glare)
+void SkyManager::setGlare(const float glare)
 {
-    mGlareEnabled = glare;
+    mGlare = glare;
 }
 
 Vector3 SkyManager::getRealSunPos()
@@ -747,17 +761,20 @@ void SkyManager::sunDisable()
 
 void SkyManager::setSunDirection(const Vector3& direction)
 {
+    if (!mCreated) return;
     mSun->setPosition(direction);
     mSunGlare->setPosition(direction);
 }
 
 void SkyManager::setMasserDirection(const Vector3& direction)
 {
+    if (!mCreated) return;
     mMasser->setPosition(direction);
 }
 
 void SkyManager::setSecundaDirection(const Vector3& direction)
 {
+    if (!mCreated) return;
     mSecunda->setPosition(direction);
 }
 
@@ -783,6 +800,7 @@ void SkyManager::secundaDisable()
 
 void SkyManager::setThunder(const float factor)
 {
+    if (!mCreated) return;
     if (factor > 0.f)
     {
         mThunderOverlay->show();
@@ -812,3 +830,9 @@ void SkyManager::setDate(int day, int month)
     mDay = day;
     mMonth = month;
 }
+
+Ogre::SceneNode* SkyManager::getSunNode()
+{
+    if (!mCreated) return 0;
+    return mSun->getNode();
+}

apps/openmw/mwrender/sky.hpp

@@ -109,61 +109,68 @@ namespace MWRender
     public:
         SkyManager(Ogre::SceneNode* pMwRoot, Ogre::Camera* pCamera, MWWorld::Environment* env);
         ~SkyManager();
-        
+
         void update(float duration);
-        
+
+        void create();
+        ///< no need to call this, automatically done on first enable()
+
         void enable();
-        
+
         void disable();
-        
+
         void setHour (double hour);
         ///< will be called even when sky is disabled.
-        
+
         void setDate (int day, int month);
         ///< will be called even when sky is disabled.
-        
+
         int getMasserPhase() const;
         ///< 0 new moon, 1 waxing or waning cresecent, 2 waxing or waning half,
         /// 3 waxing or waning gibbous, 4 full moon
-        
+
         int getSecundaPhase() const;
         ///< 0 new moon, 1 waxing or waning cresecent, 2 waxing or waning half,
         /// 3 waxing or waning gibbous, 4 full moon
-        
+
         void setMoonColour (bool red);
         ///< change Secunda colour to red
-        
+
         void setCloudsOpacity(float opacity);
         ///< change opacity of the clouds
-        
+
         void setWeather(const MWWorld::WeatherResult& weather);
-        
+
+        Ogre::SceneNode* getSunNode();
+
         void sunEnable();
-        
+
         void sunDisable();
-        
+
         void setSunDirection(const Ogre::Vector3& direction);
-        
+
         void setMasserDirection(const Ogre::Vector3& direction);
-        
+
         void setSecundaDirection(const Ogre::Vector3& direction);
-        
+
         void setMasserFade(const float fade);
-        
+
         void setSecundaFade(const float fade);
-        
+
         void masserEnable();
         void masserDisable();
 
         void secundaEnable();
         void secundaDisable();
-        
+
         void setThunder(const float factor);
-        
-        void setGlare(bool glare);
+
+        void setGlare(const float glare);
         Ogre::Vector3 getRealSunPos();
-        
+
     private:
+        bool mCreated;
+
         MWWorld::Environment* mEnvironment;
         float mHour;
         int mDay;
@@ -203,12 +210,12 @@ namespace MWRender
                 
         float mRemainingTransitionTime;
         
-        float mGlareFade;
+        float mGlare; // target
+        float mGlareFade; // actual
         
         void ModVertexAlpha(Ogre::Entity* ent, unsigned int meshType);
         
         bool mEnabled;
-        bool mGlareEnabled;
         bool mSunEnabled;
         bool mMasserEnabled;
         bool mSecundaEnabled;

apps/openmw/mwrender/terrain.cpp

@@ -14,7 +14,7 @@ namespace MWRender
 {
 
     //----------------------------------------------------------------------------------------------
-    
+
     TerrainManager::TerrainManager(Ogre::SceneManager* mgr, const MWWorld::Environment& evn) :
         mEnvironment(evn), mTerrainGroup(TerrainGroup(mgr, Terrain::ALIGN_X_Z, mLandSize, mWorldSize))
     {
@@ -42,7 +42,7 @@ namespace MWRender
         //due to the sudden flick between composite and non composite textures,
         //this seemed the distance where it wasn't too noticeable
         mTerrainGlobals.setCompositeMapDistance(mWorldSize*2);
-        
+
         mActiveProfile->setLightmapEnabled(false);
         mActiveProfile->setLayerSpecularMappingEnabled(false);
         mActiveProfile->setLayerNormalMappingEnabled(false);
@@ -73,16 +73,16 @@ namespace MWRender
     TerrainManager::~TerrainManager()
     {
     }
-    
+
     //----------------------------------------------------------------------------------------------
-    
+
     void TerrainManager::setDiffuse(const ColourValue& diffuse)
     {
         mTerrainGlobals.setCompositeMapDiffuse(diffuse);
     }
-    
+
     //----------------------------------------------------------------------------------------------
-    
+
     void TerrainManager::setAmbient(const ColourValue& ambient)
     {
         mTerrainGlobals.setCompositeMapAmbient(ambient);
@@ -160,7 +160,7 @@ namespace MWRender
                                          numTextures,
                                          indexes);
 
-                    if ( land->landData->usingColours )
+                    if ( land && land->landData->usingColours )
                     {
                         // disable or enable global colour map (depends on available vertex colours)
                         mActiveProfile->setGlobalColourMapEnabled(true);
@@ -253,7 +253,7 @@ namespace MWRender
 
                 assert( (int)mEnvironment.mWorld->getStore().landTexts.getSize() >= (int)ltexIndex - 1 &&
                        "LAND.VTEX must be within the bounds of the LTEX array");
-                
+
                 std::string texture;
                 if ( ltexIndex == 0 )
                 {
@@ -359,7 +359,7 @@ namespace MWRender
                             }
                             else
                             {
-                                //this provides a transition shading but also 
+                                //this provides a transition shading but also
                                 //rounds off the corners slightly
                                 pBlend[index] = std::min(1.0f, pBlend[index] + 0.5f);
                             }
@@ -458,10 +458,10 @@ namespace MWRender
                                    TEX_TYPE_2D, size, size, 0, PF_BYTE_BGR);
 
         HardwarePixelBufferSharedPtr pixelBuffer = tex->getBuffer();
-         
+
         pixelBuffer->lock(HardwareBuffer::HBL_DISCARD);
         const PixelBox& pixelBox = pixelBuffer->getCurrentLock();
-         
+
         uint8* pDest = static_cast<uint8*>(pixelBox.data);
 
         if ( land != NULL )
@@ -501,7 +501,7 @@ namespace MWRender
                 }
             }
         }
-         
+
         pixelBuffer->unlock();
 
         return tex;

apps/openmw/mwrender/terrainmaterial.cpp

@@ -36,7 +36,7 @@ THE SOFTWARE.
 #include "OgreHardwarePixelBuffer.h"
 #include "OgreShadowCameraSetupPSSM.h"
 
-#define POINTLIGHTS
+#include <components/settings/settings.hpp>
 
 namespace Ogre
 {
@@ -220,22 +220,10 @@ namespace Ogre
 		
 
 	}
-        int TerrainMaterialGeneratorB::SM2Profile::getNumberOfLightsSupported() const
-        {
-                #ifndef POINTLIGHTS
-                return 1;
-                #else
-                // number of supported lights depends on the number of available constant registers,
-                // which in turn depends on the shader profile used
-                if (GpuProgramManager::getSingleton().isSyntaxSupported("ps_3_0")
-                        || GpuProgramManager::getSingleton().isSyntaxSupported("ps_4_0")
-                        || GpuProgramManager::getSingleton().isSyntaxSupported("fp40")
-                )
-                        return 32;
-                else
-                        return 8;
-                #endif
-        }
+    int TerrainMaterialGeneratorB::SM2Profile::getNumberOfLightsSupported() const
+    {
+        return Settings::Manager::getInt("num lights", "Terrain");
+    }
 	//---------------------------------------------------------------------
 	MaterialPtr TerrainMaterialGeneratorB::SM2Profile::generate(const Terrain* terrain)
 	{
@@ -565,7 +553,8 @@ namespace Ogre
                 {
                         params->setNamedAutoConstant("lightPosObjSpace"+StringConverter::toString(i), GpuProgramParameters::ACT_LIGHT_POSITION_OBJECT_SPACE, i);
                         params->setNamedAutoConstant("lightDiffuseColour"+StringConverter::toString(i), GpuProgramParameters::ACT_LIGHT_DIFFUSE_COLOUR, i);
-                        params->setNamedAutoConstant("lightAttenuation"+StringConverter::toString(i), GpuProgramParameters::ACT_LIGHT_ATTENUATION, i);
+                        if (prof->getNumberOfLightsSupported() > 1)
+                            params->setNamedAutoConstant("lightAttenuation"+StringConverter::toString(i), GpuProgramParameters::ACT_LIGHT_ATTENUATION, i);
                         //params->setNamedAutoConstant("lightSpecularColour"+StringConverter::toString(i), GpuProgramParameters::ACT_LIGHT_SPECULAR_COLOUR, i);
                 }
                 
@@ -980,10 +969,9 @@ namespace Ogre
 			//"uniform float3 lightSpecularColour"<<i<<",\n"
                         ;
 
-                        #ifdef POINTLIGHTS
-                        outStream <<
-                        "uniform float4 lightAttenuation"<<i<<",\n";
-                        #endif
+                        if (prof->getNumberOfLightsSupported() > 1)
+                            outStream <<
+                            "uniform float4 lightAttenuation"<<i<<",\n";
 
                 }
 
@@ -1130,10 +1118,9 @@ namespace Ogre
 			}
 			else
 			{
-                                #ifdef POINTLIGHTS
-                                outStream << "float d; \n"
+                                if (prof->getNumberOfLightsSupported() > 1)
+                                    outStream << "float d; \n"
                                              "float attn; \n";
-                                #endif
 
                                 outStream <<
                                 "      eyeDir = normalize(eyeDir); \n";
@@ -1144,13 +1131,12 @@ namespace Ogre
                                         outStream << "	float3 halfAngle"<<i<<" = normalize(lightDir"<<i<<" + eyeDir);\n"
                                                 "	float4 litRes"<<i<<" = lit(dot(normalize(lightDir"<<i<<"), normal), dot(halfAngle"<<i<<", normal), scaleBiasSpecular.z);\n";
 
-                                        #ifdef POINTLIGHTS
+                                    if (prof->getNumberOfLightsSupported() > 1)
                                         outStream <<
                                         // pre-multiply light color with attenuation factor
                                            "d = length( lightDir"<<i<<" ); \n"
                                            "attn = ( 1.0 / (( lightAttenuation"<<i<<".y ) + ( lightAttenuation"<<i<<".z * d ) + ( lightAttenuation"<<i<<".w * d * d ))); \n"
                                            "lightDiffuseColour"<<i<<" *= attn; \n";
-                                        #endif
                                 }
 			}
 		}

apps/openmw/mwrender/terrainmaterial.hpp

@@ -50,7 +50,7 @@ namespace Ogre
 		terrain. 
 		@note Requires the Cg plugin to render correctly
 	*/
-	class _OgreTerrainExport TerrainMaterialGeneratorB : public TerrainMaterialGenerator
+	class TerrainMaterialGeneratorB : public TerrainMaterialGenerator
 	{
 	public:
 		TerrainMaterialGeneratorB();
@@ -58,7 +58,7 @@ namespace Ogre
 
 		/** Shader model 2 profile target. 
 		*/
-		class _OgreTerrainExport SM2Profile : public TerrainMaterialGenerator::Profile
+		class SM2Profile : public TerrainMaterialGenerator::Profile
 		{
 		public:
 			SM2Profile(TerrainMaterialGenerator* parent, const String& name, const String& desc);
@@ -161,7 +161,7 @@ namespace Ogre
 			void addTechnique(const MaterialPtr& mat, const Terrain* terrain, TechniqueType tt);
 
 			/// Interface definition for helper class to generate shaders
-			class _OgreTerrainExport ShaderHelper : public TerrainAlloc
+			class ShaderHelper : public TerrainAlloc
 			{
 			public:
 				ShaderHelper() {}
@@ -194,7 +194,7 @@ namespace Ogre
 			};
 
 			/// Utility class to help with generating shaders for Cg / HLSL.
-			class _OgreTerrainExport ShaderHelperCg : public ShaderHelper
+			class ShaderHelperCg : public ShaderHelper
 			{
 			protected:
 				HighLevelGpuProgramPtr createVertexProgram(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt);
@@ -212,7 +212,7 @@ namespace Ogre
 				void generateFpDynamicShadows(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, StringUtil::StrStreamType& outStream);
 			};
 
-			class _OgreTerrainExport ShaderHelperHLSL : public ShaderHelperCg
+			class ShaderHelperHLSL : public ShaderHelperCg
 			{
 			protected:
 				HighLevelGpuProgramPtr createVertexProgram(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt);
@@ -220,7 +220,7 @@ namespace Ogre
 			};
 
 			/// Utility class to help with generating shaders for GLSL.
-			class _OgreTerrainExport ShaderHelperGLSL : public ShaderHelper
+			class ShaderHelperGLSL : public ShaderHelper
 			{
 			protected:
 				HighLevelGpuProgramPtr createVertexProgram(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt);

apps/openmw/mwrender/water.cpp

@@ -0,0 +1,95 @@
+#include "water.hpp"
+
+namespace MWRender
+{
+
+Water::Water (Ogre::Camera *camera, const ESM::Cell* cell) :
+    mCamera (camera), mViewport (camera->getViewport()), mSceneManager (camera->getSceneManager()),
+    mIsUnderwater(false)
+{
+    try
+    {
+        Ogre::CompositorManager::getSingleton().addCompositor(mViewport, "Water", -1);
+        Ogre::CompositorManager::getSingleton().setCompositorEnabled(mViewport, "Water", false);
+    } catch(...) {}
+
+    mTop = cell->water;
+
+    mIsUnderwater = false;
+
+    mWaterPlane = Ogre::Plane(Ogre::Vector3::UNIT_Y, 0);
+
+    Ogre::MeshManager::getSingleton().createPlane("water", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,  mWaterPlane, CELL_SIZE*5, CELL_SIZE * 5, 10, 10, true, 1, 3,5, Ogre::Vector3::UNIT_Z);
+
+    mWater = mSceneManager->createEntity("water");
+
+    mWater->setMaterialName("Examples/Water0");
+
+    mWaterNode = mSceneManager->getRootSceneNode()->createChildSceneNode();
+    mWaterNode->setPosition(0, mTop, 0);
+
+    if(!(cell->data.flags & cell->Interior))
+    {
+        mWaterNode->setPosition(getSceneNodeCoordinates(cell->data.gridX, cell->data.gridY));
+    }
+    mWaterNode->attachObject(mWater);
+}
+
+
+Water::~Water()
+{
+    Ogre::MeshManager::getSingleton().remove("water");
+
+    mWaterNode->detachObject(mWater);
+    mSceneManager->destroyEntity(mWater);
+    mSceneManager->destroySceneNode(mWaterNode);
+
+    Ogre::CompositorManager::getSingleton().removeCompositorChain(mViewport);
+}
+
+void Water::changeCell(const ESM::Cell* cell)
+{
+    mTop = cell->water;
+
+    if(!(cell->data.flags & cell->Interior))
+        mWaterNode->setPosition(getSceneNodeCoordinates(cell->data.gridX, cell->data.gridY));
+    else
+        setHeight(mTop);
+}
+
+void Water::setHeight(const float height)
+{
+    mTop = height;
+    mWaterNode->setPosition(0, height, 0);
+}
+
+void Water::toggle()
+{
+    mWater->setVisible(!mWater->getVisible());
+}
+
+void Water::checkUnderwater(float y)
+{
+    if ((mIsUnderwater && y > mTop) || !mWater->isVisible())
+    {
+        try {
+            Ogre::CompositorManager::getSingleton().setCompositorEnabled(mViewport, "Water", false);
+        } catch(...) {}
+        mIsUnderwater = false;
+    } 
+
+    if (!mIsUnderwater && y < mTop && mWater->isVisible())
+    {
+        try {
+            Ogre::CompositorManager::getSingleton().setCompositorEnabled(mViewport, "Water", true);
+        } catch(...) {}
+        mIsUnderwater = true;
+    }
+}
+
+Ogre::Vector3 Water::getSceneNodeCoordinates(int gridX, int gridY)
+{
+    return Ogre::Vector3(gridX * CELL_SIZE + (CELL_SIZE / 2), mTop, -gridY * CELL_SIZE - (CELL_SIZE / 2));
+}
+
+} // namespace

apps/openmw/mwrender/water.hpp

@@ -0,0 +1,40 @@
+#ifndef GAME_MWRENDER_WATER_H
+#define GAME_MWRENDER_WATER_H
+
+#include <Ogre.h>
+#include <components/esm/loadcell.hpp>
+
+namespace MWRender {
+
+    /// Water rendering 	
+    class Water : Ogre::RenderTargetListener, Ogre::Camera::Listener
+    {
+        static const int CELL_SIZE = 8192;
+        Ogre::Camera *mCamera;
+        Ogre::SceneManager *mSceneManager;
+        Ogre::Viewport *mViewport;
+
+        Ogre::Plane mWaterPlane;
+        Ogre::SceneNode *mWaterNode;
+        Ogre::Entity *mWater;
+
+        bool mIsUnderwater;
+        int mTop;
+
+        Ogre::Vector3 getSceneNodeCoordinates(int gridX, int gridY);
+
+    public:
+        Water (Ogre::Camera *camera, const ESM::Cell* cell);
+        ~Water();
+
+        void toggle();
+
+        void checkUnderwater(float y);
+        void changeCell(const ESM::Cell* cell);
+        void setHeight(const float height);
+
+    };
+
+}
+
+#endif

apps/openmw/mwscript/cellextensions.cpp

@@ -133,11 +133,70 @@ namespace MWScript
                 }
         };
 
+        class OpGetWaterLevel : public Interpreter::Opcode0
+        {
+            public:
+
+                virtual void execute (Interpreter::Runtime& runtime)
+                {
+                    InterpreterContext& context
+                        = static_cast<InterpreterContext&> (runtime.getContext());
+
+                    MWWorld::Ptr::CellStore *cell = context.getWorld().getPlayer().getPlayer().getCell();
+                    runtime.push (cell->mWaterLevel);
+                }
+        };
+
+        class OpSetWaterLevel : public Interpreter::Opcode0
+        {
+            public:
+
+                virtual void execute (Interpreter::Runtime& runtime)
+                {
+                    InterpreterContext& context
+                        = static_cast<InterpreterContext&> (runtime.getContext());
+
+                    Interpreter::Type_Float level = runtime[0].mFloat;
+
+                    MWWorld::Ptr::CellStore *cell = context.getWorld().getPlayer().getPlayer().getCell();
+
+                    if (!(cell->cell->data.flags & ESM::Cell::Interior))
+                        throw std::runtime_error("Can't set water level in exterior cell");
+
+                    cell->mWaterLevel = level;
+                    context.getEnvironment().mWorld->setWaterHeight(cell->mWaterLevel);
+                }
+        };
+
+        class OpModWaterLevel : public Interpreter::Opcode0
+        {
+            public:
+
+                virtual void execute (Interpreter::Runtime& runtime)
+                {
+                    InterpreterContext& context
+                        = static_cast<InterpreterContext&> (runtime.getContext());
+
+                    Interpreter::Type_Float level = runtime[0].mFloat;
+
+                    MWWorld::Ptr::CellStore *cell = context.getWorld().getPlayer().getPlayer().getCell();
+
+                    if (!(cell->cell->data.flags & ESM::Cell::Interior))
+                        throw std::runtime_error("Can't set water level in exterior cell");
+                    
+                    cell->mWaterLevel +=level;
+                    context.getEnvironment().mWorld->setWaterHeight(cell->mWaterLevel);
+                }
+        };
+
         const int opcodeCellChanged = 0x2000000;
         const int opcodeCOC = 0x2000026;
         const int opcodeCOE = 0x200008e;
         const int opcodeGetInterior = 0x2000131;
         const int opcodeGetPCCell = 0x2000136;
+        const int opcodeGetWaterLevel = 0x2000141;
+        const int opcodeSetWaterLevel = 0x2000142;
+        const int opcodeModWaterLevel = 0x2000143;
 
         void registerExtensions (Compiler::Extensions& extensions)
         {
@@ -146,8 +205,11 @@ namespace MWScript
             extensions.registerInstruction ("centeroncell", "S", opcodeCOC);
             extensions.registerInstruction ("coe", "ll", opcodeCOE);
             extensions.registerInstruction ("centeronexterior", "ll", opcodeCOE);
+            extensions.registerInstruction ("setwaterlevel", "f", opcodeSetWaterLevel);
+            extensions.registerInstruction ("modwaterlevel", "f", opcodeModWaterLevel);
             extensions.registerFunction ("getinterior", 'l', "", opcodeGetInterior);
             extensions.registerFunction ("getpccell", 'l', "c", opcodeGetPCCell);
+            extensions.registerFunction ("getwaterlevel", 'f', "", opcodeGetWaterLevel);
         }
 
         void installOpcodes (Interpreter::Interpreter& interpreter)
@@ -157,6 +219,9 @@ namespace MWScript
             interpreter.installSegment5 (opcodeCOE, new OpCOE);
             interpreter.installSegment5 (opcodeGetInterior, new OpGetInterior);
             interpreter.installSegment5 (opcodeGetPCCell, new OpGetPCCell);
+            interpreter.installSegment5 (opcodeGetWaterLevel, new OpGetWaterLevel);
+            interpreter.installSegment5 (opcodeSetWaterLevel, new OpSetWaterLevel);
+            interpreter.installSegment5 (opcodeModWaterLevel, new OpModWaterLevel);
         }
     }
 }

apps/openmw/mwscript/docs/vmformat.txt

@@ -123,4 +123,9 @@ op 0x200013d: FadeOut
 op 0x200013e: FadeTo
 op 0x200013f: GetCurrentWeather
 op 0x2000140: ChangeWeather
-opcodes 0x2000141-0x3ffffff unused
+op 0x2000141: GetWaterLevel
+op 0x2000142: SetWaterLevel
+op 0x2000143: ModWaterLevel
+op 0x2000144: ToggleWater, twa
+op 0x2000145: TogglePathgrid
+opcodes 0x2000146-0x3ffffff unused

apps/openmw/mwscript/miscextensions.cpp

@@ -106,7 +106,7 @@ namespace MWScript
                         "Collision Mesh Rendering -> On" : "Collision Mesh Rendering -> Off");
                 }
         };
-        
+
         class OpToggleWireframe : public Interpreter::Opcode0
         {
             public:
@@ -123,7 +123,23 @@ namespace MWScript
                         "Wireframe Rendering -> On" : "Wireframe Rendering -> Off");
                 }
         };
-        
+
+        class OpTogglePathgrid : public Interpreter::Opcode0
+        {
+        public:
+            virtual void execute (Interpreter::Runtime& runtime)
+            {
+                InterpreterContext& context =
+                    static_cast<InterpreterContext&> (runtime.getContext());
+
+                bool enabled =
+                    context.getWorld().toggleRenderMode (MWWorld::World::Render_Pathgrid);
+
+                context.report (enabled ?
+                    "Path Grid rendering -> On" : "Path Grid Rendering -> Off");
+            }
+        };
+
         class OpFadeIn : public Interpreter::Opcode0
         {
             public:
@@ -135,11 +151,11 @@ namespace MWScript
 
                     Interpreter::Type_Float time = runtime[0].mFloat;
                     runtime.pop();
-                    
+
                     context.getWorld().getFader()->fadeIn(time);
                 }
         };
-        
+
         class OpFadeOut : public Interpreter::Opcode0
         {
             public:
@@ -151,11 +167,11 @@ namespace MWScript
 
                     Interpreter::Type_Float time = runtime[0].mFloat;
                     runtime.pop();
-                    
+
                     context.getWorld().getFader()->fadeOut(time);
                 }
         };
-        
+
         class OpFadeTo : public Interpreter::Opcode0
         {
             public:
@@ -167,14 +183,27 @@ namespace MWScript
 
                     Interpreter::Type_Float alpha = runtime[0].mFloat;
                     runtime.pop();
-                    
+
                     Interpreter::Type_Float time = runtime[0].mFloat;
                     runtime.pop();
-                    
+
                     context.getWorld().getFader()->fadeTo(alpha, time);
                 }
         };
 
+        class OpToggleWater : public Interpreter::Opcode0
+        {
+            public:
+
+                virtual void execute (Interpreter::Runtime& runtime)
+                {
+                    InterpreterContext& context =
+                        static_cast<InterpreterContext&> (runtime.getContext());
+
+                    context.getWorld().toggleWater();
+                }
+        };
+
         const int opcodeXBox = 0x200000c;
         const int opcodeOnActivate = 0x200000d;
         const int opcodeActivate = 0x2000075;
@@ -187,6 +216,8 @@ namespace MWScript
         const int opcodeFadeIn = 0x200013c;
         const int opcodeFadeOut = 0x200013d;
         const int opcodeFadeTo = 0x200013e;
+        const int opcodeToggleWater = 0x2000144;
+        const int opcodeTogglePathgrid = 0x2000145;
 
         void registerExtensions (Compiler::Extensions& extensions)
         {
@@ -204,6 +235,10 @@ namespace MWScript
             extensions.registerInstruction ("fadein", "f", opcodeFadeIn);
             extensions.registerInstruction ("fadeout", "f", opcodeFadeOut);
             extensions.registerInstruction ("fadeto", "ff", opcodeFadeTo);
+            extensions.registerInstruction ("togglewater", "", opcodeToggleWater);
+            extensions.registerInstruction ("twa", "", opcodeToggleWater);
+            extensions.registerInstruction ("togglepathgrid", "", opcodeTogglePathgrid);
+            extensions.registerInstruction ("tpg", "", opcodeTogglePathgrid);
         }
 
         void installOpcodes (Interpreter::Interpreter& interpreter)
@@ -220,6 +255,8 @@ namespace MWScript
             interpreter.installSegment5 (opcodeFadeIn, new OpFadeIn);
             interpreter.installSegment5 (opcodeFadeOut, new OpFadeOut);
             interpreter.installSegment5 (opcodeFadeTo, new OpFadeTo);
+            interpreter.installSegment5 (opcodeTogglePathgrid, new OpTogglePathgrid);
+            interpreter.installSegment5 (opcodeToggleWater, new OpToggleWater);
         }
     }
 }

apps/openmw/mwscript/soundextensions.cpp

@@ -130,7 +130,7 @@ namespace MWScript
                     std::string sound = runtime.getStringLiteral (runtime[0].mInteger);
                     runtime.pop();
 
-                    context.getSoundManager().playSound3D (ptr, sound, 1.0, 1.0, mLoop);
+                    context.getSoundManager().playSound3D (ptr, sound, 1.0, 1.0, mLoop ? MWSound::Play_Loop : 0);
                 }
         };
 
@@ -159,7 +159,7 @@ namespace MWScript
                     Interpreter::Type_Float pitch = runtime[0].mFloat;
                     runtime.pop();
 
-                    context.getSoundManager().playSound3D (ptr, sound, volume, pitch, mLoop);
+                    context.getSoundManager().playSound3D (ptr, sound, volume, pitch, mLoop ? MWSound::Play_Loop : 0);
 
                 }
         };

apps/openmw/mwsound/audiere_decoder.cpp

@@ -0,0 +1,122 @@
+#ifdef OPENMW_USE_AUDIERE
+
+#include <stdexcept>
+#include <iostream>
+
+#include "audiere_decoder.hpp"
+
+
+static void fail(const std::string &msg)
+{ throw std::runtime_error("Audiere exception: "+msg); }
+
+namespace MWSound
+{
+
+class OgreFile : public audiere::File
+{
+    Ogre::DataStreamPtr mStream;
+
+    ADR_METHOD(int) read(void* buffer, int size)
+    {
+        return mStream->read(buffer, size);
+    }
+
+    ADR_METHOD(bool) seek(int position, SeekMode mode)
+    {
+        if(mode == CURRENT)
+            mStream->seek(mStream->tell()+position);
+        else if(mode == BEGIN)
+            mStream->seek(position);
+        else if(mode == END)
+            mStream->seek(mStream->size()+position);
+        else
+            return false;
+
+        return true;
+    }
+
+    ADR_METHOD(int) tell()
+    {
+        return mStream->tell();
+    }
+
+    size_t refs;
+    virtual void ref() { ++refs; }
+    virtual void unref()
+    {
+        if(--refs == 0)
+            delete this;
+    }
+
+public:
+    OgreFile(const Ogre::DataStreamPtr &stream)
+      : mStream(stream), refs(1)
+    { }
+    virtual ~OgreFile() { }
+};
+
+
+void Audiere_Decoder::open(const std::string &fname)
+{
+    close();
+
+    audiere::FilePtr file(new OgreFile(mResourceMgr.openResource(fname)));
+    mSoundSource = audiere::OpenSampleSource(file);
+
+    int channels, srate;
+    audiere::SampleFormat format;
+
+    mSoundSource->getFormat(channels, srate, format);
+    if(format == audiere::SF_S16)
+        mSampleType = SampleType_Int16;
+    else if(format == audiere::SF_U8)
+        mSampleType = SampleType_UInt8;
+    else
+        fail("Unsupported sample type");
+
+    if(channels == 1)
+        mChannelConfig = ChannelConfig_Mono;
+    else if(channels == 2)
+        mChannelConfig = ChannelConfig_Stereo;
+    else
+        fail("Unsupported channel count");
+
+    mSampleRate = srate;
+}
+
+void Audiere_Decoder::close()
+{
+    mSoundSource = NULL;
+}
+
+void Audiere_Decoder::getInfo(int *samplerate, ChannelConfig *chans, SampleType *type)
+{
+    *samplerate = mSampleRate;
+    *chans = mChannelConfig;
+    *type = mSampleType;
+}
+
+size_t Audiere_Decoder::read(char *buffer, size_t bytes)
+{
+    int size = bytesToFrames(bytes, mChannelConfig, mSampleType);
+    size = mSoundSource->read(size, buffer);
+    return framesToBytes(size, mChannelConfig, mSampleType);
+}
+
+void Audiere_Decoder::rewind()
+{
+    mSoundSource->reset();
+}
+
+Audiere_Decoder::Audiere_Decoder()
+{
+}
+
+Audiere_Decoder::~Audiere_Decoder()
+{
+    close();
+}
+
+}
+
+#endif

apps/openmw/mwsound/audiere_decoder.hpp

@@ -0,0 +1,42 @@
+#ifndef GAME_SOUND_AUDIERE_DECODER_H
+#define GAME_SOUND_AUDIERE_DECODER_H
+
+#include <OgreDataStream.h>
+
+#include "audiere.h"
+
+#include "sound_decoder.hpp"
+
+
+namespace MWSound
+{
+    class Audiere_Decoder : public Sound_Decoder
+    {
+        audiere::SampleSourcePtr mSoundSource;
+        int mSampleRate;
+        SampleType mSampleType;
+        ChannelConfig mChannelConfig;
+
+        virtual void open(const std::string &fname);
+        virtual void close();
+
+        virtual void getInfo(int *samplerate, ChannelConfig *chans, SampleType *type);
+
+        virtual size_t read(char *buffer, size_t bytes);
+        virtual void rewind();
+
+        Audiere_Decoder& operator=(const Audiere_Decoder &rhs);
+        Audiere_Decoder(const Audiere_Decoder &rhs);
+
+        Audiere_Decoder();
+    public:
+        virtual ~Audiere_Decoder();
+
+        friend class SoundManager;
+    };
+#ifndef DEFAULT_DECODER
+#define DEFAULT_DECODER (::MWSound::Audiere_Decoder)
+#endif
+};
+
+#endif

apps/openmw/mwsound/openal_output.cpp

@@ -25,14 +25,20 @@ static void throwALCerror(ALCdevice *device)
 {
     ALCenum err = alcGetError(device);
     if(err != ALC_NO_ERROR)
-        fail(alcGetString(device, err));
+    {
+        const ALCchar *errstring = alcGetString(device, err);
+        fail(errstring ? errstring : "");
+    }
 }
 
 static void throwALerror()
 {
     ALenum err = alGetError();
     if(err != AL_NO_ERROR)
-        fail(alGetString(err));
+    {
+        const ALchar *errstring = alGetString(err);
+        fail(errstring ? errstring : "");
+    }
 }
 
 
@@ -89,8 +95,7 @@ public:
 
     virtual void stop();
     virtual bool isPlaying();
-    virtual void setVolume(float volume);
-    virtual void update(const float *pos);
+    virtual void update();
 
     void play();
     bool process();
@@ -187,7 +192,6 @@ OpenAL_SoundStream::OpenAL_SoundStream(OpenAL_Output &output, ALuint src, Decode
     }
     catch(std::exception &e)
     {
-        mOutput.mFreeSources.push_back(mSource);
         alDeleteBuffers(sNumBuffers, mBuffers);
         alGetError();
         throw;
@@ -255,16 +259,19 @@ bool OpenAL_SoundStream::isPlaying()
     return !mIsFinished;
 }
 
-void OpenAL_SoundStream::setVolume(float volume)
+void OpenAL_SoundStream::update()
 {
-    alSourcef(mSource, AL_GAIN, volume*mBaseVolume);
-    throwALerror();
-    mVolume = volume;
-}
+    ALfloat gain = mVolume*mBaseVolume;
+    ALfloat pitch = mPitch;
+    if(!(mFlags&Play_NoEnv) && mOutput.mLastEnvironment == Env_Underwater)
+    {
+        gain *= 0.9f;
+        pitch *= 0.7f;
+    }
 
-void OpenAL_SoundStream::update(const float *pos)
-{
-    alSource3f(mSource, AL_POSITION, pos[0], pos[2], -pos[1]);
+    alSourcef(mSource, AL_GAIN, gain);
+    alSourcef(mSource, AL_PITCH, pitch);
+    alSource3f(mSource, AL_POSITION, mPos[0], mPos[2], -mPos[1]);
     alSource3f(mSource, AL_DIRECTION, 0.0f, 0.0f, 0.0f);
     alSource3f(mSource, AL_VELOCITY, 0.0f, 0.0f, 0.0f);
     throwALerror();
@@ -321,15 +328,17 @@ bool OpenAL_SoundStream::process()
 }
 
 //
-// A regular OpenAL sound
+// A regular 2D OpenAL sound
 //
 class OpenAL_Sound : public Sound
 {
+protected:
     OpenAL_Output &mOutput;
 
     ALuint mSource;
     ALuint mBuffer;
 
+private:
     OpenAL_Sound(const OpenAL_Sound &rhs);
     OpenAL_Sound& operator=(const OpenAL_Sound &rhs);
 
@@ -339,8 +348,23 @@ public:
 
     virtual void stop();
     virtual bool isPlaying();
-    virtual void setVolume(float volume);
-    virtual void update(const float *pos);
+    virtual void update();
+};
+
+//
+// A regular 3D OpenAL sound
+//
+class OpenAL_Sound3D : public OpenAL_Sound
+{
+    OpenAL_Sound3D(const OpenAL_Sound &rhs);
+    OpenAL_Sound3D& operator=(const OpenAL_Sound &rhs);
+
+public:
+    OpenAL_Sound3D(OpenAL_Output &output, ALuint src, ALuint buf)
+      : OpenAL_Sound(output, src, buf)
+    { }
+
+    virtual void update();
 };
 
 OpenAL_Sound::OpenAL_Sound(OpenAL_Output &output, ALuint src, ALuint buf)
@@ -372,16 +396,39 @@ bool OpenAL_Sound::isPlaying()
     return state==AL_PLAYING;
 }
 
-void OpenAL_Sound::setVolume(float volume)
+void OpenAL_Sound::update()
 {
-    alSourcef(mSource, AL_GAIN, volume*mBaseVolume);
+    ALfloat gain = mVolume*mBaseVolume;
+    ALfloat pitch = mPitch;
+    if(!(mFlags&Play_NoEnv) && mOutput.mLastEnvironment == Env_Underwater)
+    {
+        gain *= 0.9f;
+        pitch *= 0.7f;
+    }
+
+    alSourcef(mSource, AL_GAIN, gain);
+    alSourcef(mSource, AL_PITCH, pitch);
+    alSource3f(mSource, AL_POSITION, mPos[0], mPos[2], -mPos[1]);
+    alSource3f(mSource, AL_DIRECTION, 0.0f, 0.0f, 0.0f);
+    alSource3f(mSource, AL_VELOCITY, 0.0f, 0.0f, 0.0f);
     throwALerror();
-    mVolume = volume;
 }
 
-void OpenAL_Sound::update(const float *pos)
+void OpenAL_Sound3D::update()
 {
-    alSource3f(mSource, AL_POSITION, pos[0], pos[2], -pos[1]);
+    ALfloat gain = mVolume*mBaseVolume;
+    ALfloat pitch = mPitch;
+    if(mPos.squaredDistance(mOutput.mPos) > mMaxDistance*mMaxDistance)
+        gain = 0.0f;
+    else if(!(mFlags&Play_NoEnv) && mOutput.mLastEnvironment == Env_Underwater)
+    {
+        gain *= 0.9f;
+        pitch *= 0.7f;
+    }
+
+    alSourcef(mSource, AL_GAIN, gain);
+    alSourcef(mSource, AL_PITCH, pitch);
+    alSource3f(mSource, AL_POSITION, mPos[0], mPos[2], -mPos[1]);
     alSource3f(mSource, AL_DIRECTION, 0.0f, 0.0f, 0.0f);
     alSource3f(mSource, AL_VELOCITY, 0.0f, 0.0f, 0.0f);
     throwALerror();
@@ -410,8 +457,7 @@ std::vector<std::string> OpenAL_Output::enumerate()
 
 void OpenAL_Output::init(const std::string &devname)
 {
-    if(mDevice || mContext)
-        fail("Device already open");
+    deinit();
 
     mDevice = alcOpenDevice(devname.c_str());
     if(!mDevice)
@@ -428,7 +474,12 @@ void OpenAL_Output::init(const std::string &devname)
 
     mContext = alcCreateContext(mDevice, NULL);
     if(!mContext || alcMakeContextCurrent(mContext) == ALC_FALSE)
+    {
+        if(mContext)
+            alcDestroyContext(mContext);
+        mContext = 0;
         fail(std::string("Failed to setup context: ")+alcGetString(mDevice, alcGetError(mDevice)));
+    }
 
     alDistanceModel(AL_LINEAR_DISTANCE_CLAMPED);
     throwALerror();
@@ -441,6 +492,8 @@ void OpenAL_Output::init(const std::string &devname)
     try
     {
         ALCuint maxtotal = std::min<ALCuint>(maxmono+maxstereo, 256);
+        if (maxtotal == 0) // workaround for broken implementations
+            maxtotal = 256;
         for(size_t i = 0;i < maxtotal;i++)
         {
             ALuint src = 0;
@@ -580,10 +633,8 @@ void OpenAL_Output::bufferFinished(ALuint buf)
 }
 
 
-SoundPtr OpenAL_Output::playSound(const std::string &fname, float volume, float pitch, bool loop)
+SoundPtr OpenAL_Output::playSound(const std::string &fname, float volume, float pitch, int flags)
 {
-    throwALerror();
-
     boost::shared_ptr<OpenAL_Sound> sound;
     ALuint src=0, buf=0;
 
@@ -614,11 +665,16 @@ SoundPtr OpenAL_Output::playSound(const std::string &fname, float volume, float
     alSourcef(src, AL_MAX_DISTANCE, 1000.0f);
     alSourcef(src, AL_ROLLOFF_FACTOR, 0.0f);
 
+    if(!(flags&Play_NoEnv) && mLastEnvironment == Env_Underwater)
+    {
+        volume *= 0.9f;
+        pitch *= 0.7f;
+    }
     alSourcef(src, AL_GAIN, volume);
     alSourcef(src, AL_PITCH, pitch);
 
     alSourcei(src, AL_SOURCE_RELATIVE, AL_TRUE);
-    alSourcei(src, AL_LOOPING, (loop?AL_TRUE:AL_FALSE));
+    alSourcei(src, AL_LOOPING, (flags&Play_Loop) ? AL_TRUE : AL_FALSE);
     throwALerror();
 
     alSourcei(src, AL_BUFFER, buf);
@@ -628,11 +684,9 @@ SoundPtr OpenAL_Output::playSound(const std::string &fname, float volume, float
     return sound;
 }
 
-SoundPtr OpenAL_Output::playSound3D(const std::string &fname, const float *pos, float volume, float pitch,
-                                    float min, float max, bool loop)
+SoundPtr OpenAL_Output::playSound3D(const std::string &fname, const Ogre::Vector3 &pos, float volume, float pitch,
+                                    float min, float max, int flags)
 {
-    throwALerror();
-
     boost::shared_ptr<OpenAL_Sound> sound;
     ALuint src=0, buf=0;
 
@@ -644,7 +698,7 @@ SoundPtr OpenAL_Output::playSound3D(const std::string &fname, const float *pos,
     try
     {
         buf = getBuffer(fname);
-        sound.reset(new OpenAL_Sound(*this, src, buf));
+        sound.reset(new OpenAL_Sound3D(*this, src, buf));
     }
     catch(std::exception &e)
     {
@@ -655,7 +709,7 @@ SoundPtr OpenAL_Output::playSound3D(const std::string &fname, const float *pos,
         throw;
     }
 
-    alSource3f(src, AL_POSITION, pos[0], pos[2], -pos[1]);
+    alSource3f(src, AL_POSITION, pos.x, pos.z, -pos.y);
     alSource3f(src, AL_DIRECTION, 0.0f, 0.0f, 0.0f);
     alSource3f(src, AL_VELOCITY, 0.0f, 0.0f, 0.0f);
 
@@ -663,11 +717,17 @@ SoundPtr OpenAL_Output::playSound3D(const std::string &fname, const float *pos,
     alSourcef(src, AL_MAX_DISTANCE, max);
     alSourcef(src, AL_ROLLOFF_FACTOR, 1.0f);
 
-    alSourcef(src, AL_GAIN, volume);
+    if(!(flags&Play_NoEnv) && mLastEnvironment == Env_Underwater)
+    {
+        volume *= 0.9f;
+        pitch *= 0.7f;
+    }
+    alSourcef(src, AL_GAIN, (pos.squaredDistance(mPos) > max*max) ?
+                             0.0f : volume);
     alSourcef(src, AL_PITCH, pitch);
 
     alSourcei(src, AL_SOURCE_RELATIVE, AL_FALSE);
-    alSourcei(src, AL_LOOPING, (loop?AL_TRUE:AL_FALSE));
+    alSourcei(src, AL_LOOPING, (flags&Play_Loop) ? AL_TRUE : AL_FALSE);
     throwALerror();
 
     alSourcei(src, AL_BUFFER, buf);
@@ -678,10 +738,8 @@ SoundPtr OpenAL_Output::playSound3D(const std::string &fname, const float *pos,
 }
 
 
-SoundPtr OpenAL_Output::streamSound(const std::string &fname, float volume, float pitch)
+SoundPtr OpenAL_Output::streamSound(const std::string &fname, float volume, float pitch, int flags)
 {
-    throwALerror();
-
     boost::shared_ptr<OpenAL_SoundStream> sound;
     ALuint src;
 
@@ -692,6 +750,8 @@ SoundPtr OpenAL_Output::streamSound(const std::string &fname, float volume, floa
 
     try
     {
+        if((flags&Play_Loop))
+            std::cout <<"Warning: cannot loop stream "<<fname<< std::endl;
         DecoderPtr decoder = mManager.getDecoder();
         decoder->open(fname);
         sound.reset(new OpenAL_SoundStream(*this, src, decoder));
@@ -710,6 +770,11 @@ SoundPtr OpenAL_Output::streamSound(const std::string &fname, float volume, floa
     alSourcef(src, AL_MAX_DISTANCE, 1000.0f);
     alSourcef(src, AL_ROLLOFF_FACTOR, 0.0f);
 
+    if(!(flags&Play_NoEnv) && mLastEnvironment == Env_Underwater)
+    {
+        volume *= 0.9f;
+        pitch *= 0.7f;
+    }
     alSourcef(src, AL_GAIN, volume);
     alSourcef(src, AL_PITCH, pitch);
 
@@ -721,67 +786,28 @@ SoundPtr OpenAL_Output::streamSound(const std::string &fname, float volume, floa
     return sound;
 }
 
-SoundPtr OpenAL_Output::streamSound3D(const std::string &fname, const float *pos, float volume, float pitch,
-                                      float min, float max)
+
+void OpenAL_Output::updateListener(const Ogre::Vector3 &pos, const Ogre::Vector3 &atdir, const Ogre::Vector3 &updir, Environment env)
 {
-    throwALerror();
+    mPos = pos;
+    mLastEnvironment = env;
 
-    boost::shared_ptr<OpenAL_SoundStream> sound;
-    ALuint src;
-
-    if(mFreeSources.empty())
-        fail("No free sources");
-    src = mFreeSources.front();
-    mFreeSources.pop_front();
-
-    try
+    if(mContext)
     {
-        DecoderPtr decoder = mManager.getDecoder();
-        decoder->open(fname);
-        sound.reset(new OpenAL_SoundStream(*this, src, decoder));
+        ALfloat orient[6] = {
+            atdir.x, atdir.z, -atdir.y,
+            updir.x, updir.z, -updir.y
+        };
+        alListener3f(AL_POSITION, mPos.x, mPos.z, -mPos.y);
+        alListenerfv(AL_ORIENTATION, orient);
+        throwALerror();
     }
-    catch(std::exception &e)
-    {
-        mFreeSources.push_back(src);
-        throw;
-    }
-
-    alSource3f(src, AL_POSITION, pos[0], pos[2], -pos[1]);
-    alSource3f(src, AL_DIRECTION, 0.0f, 0.0f, 0.0f);
-    alSource3f(src, AL_VELOCITY, 0.0f, 0.0f, 0.0f);
-
-    alSourcef(src, AL_REFERENCE_DISTANCE, min);
-    alSourcef(src, AL_MAX_DISTANCE, max);
-    alSourcef(src, AL_ROLLOFF_FACTOR, 1.0f);
-
-    alSourcef(src, AL_GAIN, volume);
-    alSourcef(src, AL_PITCH, pitch);
-
-    alSourcei(src, AL_SOURCE_RELATIVE, AL_FALSE);
-    alSourcei(src, AL_LOOPING, AL_FALSE);
-    throwALerror();
-
-    sound->play();
-    return sound;
-}
-
-
-void OpenAL_Output::updateListener(const float *pos, const float *atdir, const float *updir)
-{
-    float orient[6] = {
-        atdir[0], atdir[2], -atdir[1],
-        updir[0], updir[2], -updir[1]
-    };
-
-    alListener3f(AL_POSITION, pos[0], pos[2], -pos[1]);
-    alListenerfv(AL_ORIENTATION, orient);
-    throwALerror();
 }
 
 
 OpenAL_Output::OpenAL_Output(SoundManager &mgr)
   : Sound_Output(mgr), mDevice(0), mContext(0), mBufferCacheMemSize(0),
-    mStreamThread(new StreamThread)
+    mLastEnvironment(Env_Normal), mStreamThread(new StreamThread)
 {
 }
 

apps/openmw/mwsound/openal_output.hpp

@@ -36,19 +36,18 @@ namespace MWSound
         ALuint getBuffer(const std::string &fname);
         void bufferFinished(ALuint buffer);
 
+        Environment mLastEnvironment;
+
         virtual std::vector<std::string> enumerate();
         virtual void init(const std::string &devname="");
         virtual void deinit();
 
-        virtual SoundPtr playSound(const std::string &fname, float volume, float pitch, bool loop);
-        virtual SoundPtr playSound3D(const std::string &fname, const float *pos, float volume, float pitch,
-                                     float min, float max, bool loop);
+        virtual SoundPtr playSound(const std::string &fname, float volume, float pitch, int flags);
+        virtual SoundPtr playSound3D(const std::string &fname, const Ogre::Vector3 &pos,
+                                     float volume, float pitch, float min, float max, int flags);
+        virtual SoundPtr streamSound(const std::string &fname, float volume, float pitch, int flags);
 
-        virtual SoundPtr streamSound(const std::string &fname, float volume, float pitch);
-        virtual SoundPtr streamSound3D(const std::string &fname, const float *pos, float volume, float pitch,
-                                       float min, float max);
-
-        virtual void updateListener(const float *pos, const float *atdir, const float *updir);
+        virtual void updateListener(const Ogre::Vector3 &pos, const Ogre::Vector3 &atdir, const Ogre::Vector3 &updir, Environment env);
 
         OpenAL_Output& operator=(const OpenAL_Output &rhs);
         OpenAL_Output(const OpenAL_Output &rhs);
@@ -60,6 +59,7 @@ namespace MWSound
         std::auto_ptr<StreamThread> mStreamThread;
 
         friend class OpenAL_Sound;
+        friend class OpenAL_Sound3D;
         friend class OpenAL_SoundStream;
         friend class SoundManager;
     };

apps/openmw/mwsound/sound.hpp

@@ -1,30 +1,39 @@
 #ifndef GAME_SOUND_SOUND_H
 #define GAME_SOUND_SOUND_H
 
+#include <OgreVector3.h>
+
 namespace MWSound
 {
     class Sound
     {
-        virtual void update(const float *pos) = 0;
+        virtual void update() = 0;
 
         Sound& operator=(const Sound &rhs);
         Sound(const Sound &rhs);
 
     protected:
+        Ogre::Vector3 mPos;
         float mVolume; /* NOTE: Real volume = mVolume*mBaseVolume */
         float mBaseVolume;
+        float mPitch;
         float mMinDistance;
         float mMaxDistance;
+        int mFlags;
 
     public:
         virtual void stop() = 0;
         virtual bool isPlaying() = 0;
-        virtual void setVolume(float volume) = 0;
+        void setPosition(const Ogre::Vector3 &pos) { mPos = pos; }
+        void setVolume(float volume) { mVolume = volume; }
 
-        Sound() : mVolume(1.0f)
+        Sound() : mPos(0.0f, 0.0f, 0.0f)
+                , mVolume(1.0f)
                 , mBaseVolume(1.0f)
+                , mPitch(1.0f)
                 , mMinDistance(20.0f) /* 1 * min_range_scale */
                 , mMaxDistance(12750.0f) /* 255 * max_range_scale */
+                , mFlags(Play_Normal)
         { }
         virtual ~Sound() { }
 

apps/openmw/mwsound/sound_output.hpp

@@ -4,6 +4,8 @@
 #include <string>
 #include <memory>
 
+#include <OgreVector3.h>
+
 #include "soundmanager.hpp"
 
 #include "../mwworld/ptr.hpp"
@@ -22,19 +24,23 @@ namespace MWSound
         virtual void init(const std::string &devname="") = 0;
         virtual void deinit() = 0;
 
-        virtual SoundPtr playSound(const std::string &fname, float volume, float pitch, bool loop) = 0;
-        virtual SoundPtr playSound3D(const std::string &fname, const float *pos, float volume, float pitch,
-                                     float min, float max, bool loop) = 0;
-        virtual SoundPtr streamSound(const std::string &fname, float volume, float pitch) = 0;
-        virtual SoundPtr streamSound3D(const std::string &fname, const float *pos, float volume, float pitch,
-                                       float min, float max) = 0;
+        virtual SoundPtr playSound(const std::string &fname, float volume, float pitch, int flags) = 0;
+        virtual SoundPtr playSound3D(const std::string &fname, const Ogre::Vector3 &pos,
+                                     float volume, float pitch, float min, float max, int flags) = 0;
+        virtual SoundPtr streamSound(const std::string &fname, float volume, float pitch, int flags) = 0;
 
-        virtual void updateListener(const float *pos, const float *atdir, const float *updir) = 0;
+        virtual void updateListener(const Ogre::Vector3 &pos, const Ogre::Vector3 &atdir, const Ogre::Vector3 &updir, Environment env) = 0;
 
         Sound_Output& operator=(const Sound_Output &rhs);
         Sound_Output(const Sound_Output &rhs);
 
-        Sound_Output(SoundManager &mgr) : mManager(mgr) { }
+    protected:
+        Ogre::Vector3 mPos;
+
+        Sound_Output(SoundManager &mgr)
+          : mManager(mgr)
+          , mPos(0.0f, 0.0f, 0.0f)
+        { }
     public:
         virtual ~Sound_Output() { }
 

apps/openmw/mwsound/soundmanager.cpp

@@ -18,8 +18,8 @@
 
 #include "openal_output.hpp"
 #define SOUND_OUT "OpenAL"
-/* Set up the sound manager to use FFMPEG or MPG123+libsndfile for input. The
- * OPENMW_USE_x macros are set in CMakeLists.txt.
+/* Set up the sound manager to use FFMPEG, MPG123+libsndfile, or Audiere for
+ * input. The OPENMW_USE_x macros are set in CMakeLists.txt.
 */
 #ifdef OPENMW_USE_FFMPEG
 #include "ffmpeg_decoder.hpp"
@@ -28,6 +28,13 @@
 #endif
 #endif
 
+#ifdef OPENMW_USE_AUDIERE
+#include "audiere_decoder.hpp"
+#ifndef SOUND_IN
+#define SOUND_IN "Audiere"
+#endif
+#endif
+
 #ifdef OPENMW_USE_MPG123
 #include "mpgsnd_decoder.hpp"
 #ifndef SOUND_IN
@@ -41,6 +48,8 @@ namespace MWSound
     SoundManager::SoundManager(bool useSound, MWWorld::Environment& environment)
         : mResourceMgr(Ogre::ResourceGroupManager::getSingleton())
         , mEnvironment(environment)
+        , mOutput(new DEFAULT_OUTPUT(*this))
+
     {
         if(!useSound)
             return;
@@ -50,8 +59,6 @@ namespace MWSound
 
         try
         {
-            mOutput.reset(new DEFAULT_OUTPUT(*this));
-
             std::vector<std::string> names = mOutput->enumerate();
             std::cout <<"Enumerated output devices:"<< std::endl;
             for(size_t i = 0;i < names.size();i++)
@@ -62,8 +69,6 @@ namespace MWSound
         catch(std::exception &e)
         {
             std::cout <<"Sound init failed: "<<e.what()<< std::endl;
-            mOutput.reset();
-            return;
         }
     }
 
@@ -90,10 +95,7 @@ namespace MWSound
         if(snd == NULL)
             throw std::runtime_error(std::string("Failed to lookup sound ")+soundId);
 
-        if(snd->data.volume == 0)
-            volume = 0.0f;
-        else
-            volume *= pow(10.0, (snd->data.volume/255.0f*3348.0 - 3348.0) / 2000.0);
+        volume *= pow(10.0, (snd->data.volume/255.0*3348.0 - 3348.0) / 2000.0);
 
         if(snd->data.minRange == 0 && snd->data.maxRange == 0)
         {
@@ -108,7 +110,7 @@ namespace MWSound
             max = std::max(min, max);
         }
 
-        return std::string("Sound/")+snd->sound;
+        return "Sound/"+snd->sound;
     }
 
 
@@ -137,10 +139,10 @@ namespace MWSound
         std::cout <<"Playing "<<filename<< std::endl;
         try
         {
-            if(mMusic)
-                mMusic->stop();
-            mMusic = mOutput->streamSound(filename, 0.4f, 1.0f);
+            stopMusic();
+            mMusic = mOutput->streamSound(filename, 0.4f, 1.0f, Play_NoEnv);
             mMusic->mBaseVolume = 0.4f;
+            mMusic->mFlags = Play_NoEnv;
         }
         catch(std::exception &e)
         {
@@ -182,11 +184,13 @@ namespace MWSound
         {
             // The range values are not tested
             float basevol = 1.0f; /* TODO: volume settings */
-            std::string filePath = std::string("Sound/")+filename;
+            std::string filePath = "Sound/"+filename;
             const ESM::Position &pos = ptr.getCellRef().pos;
+            const Ogre::Vector3 objpos(pos.pos[0], pos.pos[1], pos.pos[2]);
 
-            SoundPtr sound = mOutput->playSound3D(filePath, pos.pos, basevol, 1.0f,
-                                                  20.0f, 12750.0f, false);
+            SoundPtr sound = mOutput->playSound3D(filePath, objpos, basevol, 1.0f,
+                                                  20.0f, 12750.0f, Play_Normal);
+            sound->mPos = objpos;
             sound->mBaseVolume = basevol;
 
             mActiveSounds[sound] = std::make_pair(ptr, std::string("_say_sound"));
@@ -203,7 +207,7 @@ namespace MWSound
     }
 
 
-    SoundPtr SoundManager::playSound(const std::string& soundId, float volume, float pitch, bool loop)
+    SoundPtr SoundManager::playSound(const std::string& soundId, float volume, float pitch, int mode)
     {
         SoundPtr sound;
         try
@@ -212,11 +216,13 @@ namespace MWSound
             float min, max;
             std::string file = lookup(soundId, basevol, min, max);
 
-            sound = mOutput->playSound(file, volume*basevol, pitch, loop);
+            sound = mOutput->playSound(file, volume*basevol, pitch, mode);
             sound->mVolume = volume;
             sound->mBaseVolume = basevol;
+            sound->mPitch = pitch;
             sound->mMinDistance = min;
             sound->mMaxDistance = max;
+            sound->mFlags = mode;
 
             mActiveSounds[sound] = std::make_pair(MWWorld::Ptr(), soundId);
         }
@@ -228,8 +234,7 @@ namespace MWSound
     }
 
     SoundPtr SoundManager::playSound3D(MWWorld::Ptr ptr, const std::string& soundId,
-                                       float volume, float pitch, bool loop,
-                                       bool untracked)
+                                       float volume, float pitch, int mode)
     {
         SoundPtr sound;
         try
@@ -239,15 +244,21 @@ namespace MWSound
             float min, max;
             std::string file = lookup(soundId, basevol, min, max);
             const ESM::Position &pos = ptr.getCellRef().pos;
+            const Ogre::Vector3 objpos(pos.pos[0], pos.pos[1], pos.pos[2]);
 
-            sound = mOutput->playSound3D(file, pos.pos, volume*basevol, pitch, min, max, loop);
+            sound = mOutput->playSound3D(file, objpos, volume*basevol, pitch, min, max, mode);
+            sound->mPos = objpos;
             sound->mVolume = volume;
             sound->mBaseVolume = basevol;
+            sound->mPitch = pitch;
             sound->mMinDistance = min;
             sound->mMaxDistance = max;
+            sound->mFlags = mode;
 
-            mActiveSounds[sound] = (!untracked ? std::make_pair(ptr, soundId) :
-                                    std::make_pair(MWWorld::Ptr(), soundId));
+            if((mode&Play_NoTrack))
+                mActiveSounds[sound] = std::make_pair(MWWorld::Ptr(), soundId);
+            else
+                mActiveSounds[sound] = std::make_pair(ptr, soundId);
         }
         catch(std::exception &e)
         {
@@ -326,11 +337,12 @@ namespace MWSound
     void SoundManager::updateObject(MWWorld::Ptr ptr)
     {
         const ESM::Position &pos = ptr.getCellRef().pos;
+        const Ogre::Vector3 objpos(pos.pos[0], pos.pos[1], pos.pos[2]);
         SoundMap::iterator snditer = mActiveSounds.begin();
         while(snditer != mActiveSounds.end())
         {
             if(snditer->second.first == ptr)
-                snditer->first->update(pos.pos);
+                snditer->first->setPosition(objpos);
             snditer++;
         }
     }
@@ -402,19 +414,25 @@ namespace MWSound
         if(!isMusicPlaying())
             startRandomTitle();
 
+        const ESM::Cell *cell = mEnvironment.mWorld->getPlayer().getPlayer().getCell()->cell;
         Ogre::Camera *cam = mEnvironment.mWorld->getPlayer().getRenderer()->getCamera();
         Ogre::Vector3 nPos, nDir, nUp;
         nPos = cam->getRealPosition();
         nDir = cam->getRealDirection();
         nUp  = cam->getRealUp();
 
+        Environment env = Env_Normal;
+        if((cell->data.flags&cell->HasWater) && nPos.y < cell->water)
+            env = Env_Underwater;
+
         // The output handler is expecting vectors oriented like the game
         // (that is, -Z goes down, +Y goes forward), but that's not what we
         // get from Ogre's camera, so we have to convert.
-        float pos[3] = { nPos[0], -nPos[2], nPos[1] };
-        float at[3] = { nDir[0], -nDir[2], nDir[1] };
-        float up[3] = { nUp[0], -nUp[2], nUp[1] };
-        mOutput->updateListener(pos, at, up);
+        const Ogre::Vector3 pos(nPos[0], -nPos[2], nPos[1]);
+        const Ogre::Vector3 at(nDir[0], -nDir[2], nDir[1]);
+        const Ogre::Vector3 up(nUp[0], -nUp[2], nUp[1]);
+
+        mOutput->updateListener(pos, at, up, env);
 
         // Check if any sounds are finished playing, and trash them
         SoundMap::iterator snditer = mActiveSounds.begin();
@@ -423,7 +441,10 @@ namespace MWSound
             if(!snditer->first->isPlaying())
                 mActiveSounds.erase(snditer++);
             else
+            {
+                snditer->first->update();
                 snditer++;
+            }
         }
     }
 

apps/openmw/mwsound/soundmanager.hpp

@@ -30,6 +30,24 @@ namespace MWSound
     typedef boost::shared_ptr<Sound_Decoder> DecoderPtr;
     typedef boost::shared_ptr<Sound> SoundPtr;
 
+    enum PlayMode {
+        Play_Normal  = 0, /* tracked, non-looping, multi-instance, environment */
+        Play_Loop    = 1<<0, /* Sound will continually loop until explicitly stopped */
+        Play_NoEnv   = 1<<1, /* Do not apply environment effects (eg, underwater filters) */
+        Play_NoTrack = 1<<2, /* (3D only) Play the sound at the given object's position
+                              * but do not keep it updated (the sound will not move with
+                              * the object and will not stop when the object is deleted. */
+    };
+    static inline int operator|(const PlayMode &a, const PlayMode &b)
+    { return (int)a | (int)b; }
+    static inline int operator&(const PlayMode &a, const PlayMode &b)
+    { return (int)a & (int)b; }
+
+    enum Environment {
+        Env_Normal,
+        Env_Underwater,
+    };
+
     class SoundManager
     {
         Ogre::ResourceGroupManager& mResourceMgr;
@@ -87,12 +105,11 @@ namespace MWSound
         bool sayDone(MWWorld::Ptr reference) const;
         ///< Is actor not speaking?
 
-        SoundPtr playSound(const std::string& soundId, float volume, float pitch, bool loop=false);
+        SoundPtr playSound(const std::string& soundId, float volume, float pitch, int mode=Play_Normal);
         ///< Play a sound, independently of 3D-position
 
         SoundPtr playSound3D(MWWorld::Ptr reference, const std::string& soundId,
-                             float volume, float pitch, bool loop,
-                             bool untracked=false);
+                             float volume, float pitch, int mode=Play_Normal);
         ///< Play a sound from an object
 
         void stopSound3D(MWWorld::Ptr reference, const std::string& soundId);

apps/openmw/mwworld/physicssystem.cpp

@@ -50,6 +50,28 @@ namespace MWWorld
 
         return mEngine->rayTest(from,to);
     }
+
+    std::vector < std::pair <float, std::string> > PhysicsSystem::getFacedObjects ()
+    {
+        //get a ray pointing to the center of the viewport
+        Ray centerRay = mRender.getCamera()->getCameraToViewportRay(
+        mRender.getViewport()->getWidth()/2,
+        mRender.getViewport()->getHeight()/2);
+        btVector3 from(centerRay.getOrigin().x,-centerRay.getOrigin().z,centerRay.getOrigin().y);
+        btVector3 to(centerRay.getPoint(500).x,-centerRay.getPoint(500).z,centerRay.getPoint(500).y);
+
+        return mEngine->rayTest2(from,to);
+    }
+
+    btVector3 PhysicsSystem::getRayPoint(float extent)
+    {
+        //get a ray pointing to the center of the viewport
+        Ray centerRay = mRender.getCamera()->getCameraToViewportRay(
+        mRender.getViewport()->getWidth()/2,
+        mRender.getViewport()->getHeight()/2);
+        btVector3 result(centerRay.getPoint(500*extent).x,-centerRay.getPoint(500*extent).z,centerRay.getPoint(500*extent).y);
+        return result;
+    }
     
     bool PhysicsSystem::castRay(const Vector3& from, const Vector3& to)
     {

apps/openmw/mwworld/physicssystem.hpp

@@ -41,7 +41,11 @@ namespace MWWorld
             bool toggleCollisionMode();
             
             std::pair<std::string, float> getFacedHandle (MWWorld::World& world);
-            
+
+            btVector3 getRayPoint(float extent);
+
+            std::vector < std::pair <float, std::string> > getFacedObjects ();
+
             // cast ray, return true if it hit something
             bool castRay(const Ogre::Vector3& from, const Ogre::Vector3& to);
 

apps/openmw/mwworld/scene.cpp

@@ -54,9 +54,11 @@ void insertCellRefList(MWRender::RenderingManager& rendering, MWWorld::Environme
 
 namespace MWWorld
 {
+
     void Scene::update (float duration){
         mRendering.update (duration);
     }
+
     void Scene::unloadCell (CellStoreCollection::iterator iter)
     {
         std::cout << "Unloading cell\n";
@@ -82,6 +84,7 @@ namespace MWWorld
             if (!((*iter)->cell->data.flags & ESM::Cell::Interior))
                 mPhysics->removeHeightField( (*iter)->cell->data.gridX, (*iter)->cell->data.gridY );
         }
+
 		mRendering.removeCell(*iter);
 		//mPhysics->removeObject("Unnamed_43");
 
@@ -90,6 +93,7 @@ namespace MWWorld
         mEnvironment.mSoundManager->stopSound (*iter);
 		mActiveCells.erase(*iter);
         
+
         
     }
 
@@ -209,6 +213,7 @@ namespace MWWorld
 
         mCurrentCell = *iter;
 
+
         // adjust player
         playerCellChange (mWorld->getExterior(X, Y), position, adjustPlayerPos);
 
@@ -216,6 +221,7 @@ namespace MWWorld
         mWorld->adjustSky();
 
         mCellChanged = true;
+        mRendering.waterAdded(mCurrentCell);
     }
 
     //We need the ogre renderer and a scene node.
@@ -255,6 +261,7 @@ namespace MWWorld
         Ptr::CellStore *cell = mWorld->getInterior(cellName);
 
         loadCell (cell);
+        
 
         // adjust player
         mCurrentCell = cell;
@@ -267,6 +274,8 @@ namespace MWWorld
         mWorld->adjustSky();
 
         mCellChanged = true;
+
+        mRendering.waterAdded(cell);
     }
 
     void Scene::changeToExteriorCell (const ESM::Position& position)

apps/openmw/mwworld/weather.cpp

@@ -34,7 +34,7 @@ const float WeatherGlobals::mThunderFrequency = .4;
 const float WeatherGlobals::mThunderThreshold = 0.6;
 const float WeatherGlobals::mThunderSoundDelay = 0.25;
 
-WeatherManager::WeatherManager(MWRender::RenderingManager* rendering, Environment* env) : 
+WeatherManager::WeatherManager(MWRender::RenderingManager* rendering, MWWorld::Environment* env) : 
      mHour(14), mCurrentWeather("clear"), mFirstUpdate(true), mWeatherUpdateTime(0),
      mThunderFlash(0), mThunderChance(0), mThunderChanceNeeded(50), mThunderSoundDelay(0)
 {

apps/openmw/mwworld/world.cpp

@@ -146,10 +146,10 @@ namespace MWWorld
             mRendering->skySetDate (mGlobalVariables->getInt ("day"),
                 mGlobalVariables->getInt ("month"));
 
-            mRendering->getSkyManager()->enable();
+            mRendering->skyEnable();
         }
         else
-            mRendering->getSkyManager()->disable();
+            mRendering->skyDisable();
     }
 
     World::World (OEngine::Render::OgreRenderer& renderer,
@@ -157,7 +157,8 @@ namespace MWWorld
         const std::string& master, const boost::filesystem::path& resDir,
         bool newGame, Environment& environment, const std::string& encoding)
     : mPlayer (0), mLocalScripts (mStore), mGlobalVariables (0),
-      mSky (true), mEnvironment (environment), mNextDynamicRecord (0), mCells (mStore, mEsm, *this)
+      mSky (true), mEnvironment (environment), mNextDynamicRecord (0), mCells (mStore, mEsm, *this),
+      mNumFacing(0)
     {
         mPhysics = new PhysicsSystem(renderer);
         mPhysEngine = mPhysics->getEngine();
@@ -498,13 +499,21 @@ namespace MWWorld
 
     std::string World::getFacedHandle()
     {
-        std::pair<std::string, float> result = mPhysics->getFacedHandle (*this);
+        if (!mRendering->occlusionQuerySupported())
+        {
+            std::pair<std::string, float> result = mPhysics->getFacedHandle (*this);
 
-        if (result.first.empty() ||
-            result.second>getStore().gameSettings.find ("iMaxActivateDist")->i)
-            return "";
+            if (result.first.empty() ||
+                result.second>getStore().gameSettings.find ("iMaxActivateDist")->i)
+                return "";
 
-        return result.first;
+            return result.first;
+        }
+        else
+        {
+            // updated every few frames in update()
+            return mFacedHandle;
+        }
     }
 
     void World::deleteObject (Ptr ptr)
@@ -531,9 +540,10 @@ namespace MWWorld
         ptr.getRefData().getPosition().pos[0] = x;
         ptr.getRefData().getPosition().pos[1] = y;
         ptr.getRefData().getPosition().pos[2] = z;
-
         if (ptr==mPlayer->getPlayer())
         {
+            //std::cout << "X:" <<   ptr.getRefData().getPosition().pos[0] << " Z: "  << ptr.getRefData().getPosition().pos[1] << "\n";
+
             Ptr::CellStore *currentCell = mWorldScene->getCurrentCell();
             if (currentCell)
             {
@@ -705,13 +715,113 @@ namespace MWWorld
 
         mWeatherManager->update (duration);
 
-        // cast a ray from player to sun to detect if the sun is visible
-        // this is temporary until we find a better place to put this code
-        // currently its here because we need to access the physics system
-        float* p = mPlayer->getPlayer().getRefData().getPosition().pos;
-        Vector3 sun = mRendering->getSkyManager()->getRealSunPos();
-        sun = Vector3(sun.x, -sun.z, sun.y);
-        mRendering->getSkyManager()->setGlare(!mPhysics->castRay(Ogre::Vector3(p[0], p[1], p[2]), sun));
+        if (!mRendering->occlusionQuerySupported())
+        {
+            // cast a ray from player to sun to detect if the sun is visible
+            // this is temporary until we find a better place to put this code
+            // currently its here because we need to access the physics system
+            float* p = mPlayer->getPlayer().getRefData().getPosition().pos;
+            Vector3 sun = mRendering->getSkyManager()->getRealSunPos();
+            sun = Vector3(sun.x, -sun.z, sun.y);
+            mRendering->getSkyManager()->setGlare(!mPhysics->castRay(Ogre::Vector3(p[0], p[1], p[2]), sun));
+        }
+
+        // update faced handle (object the player is looking at)
+        // this uses a mixture of raycasts and occlusion queries.
+        else // if (mRendering->occlusionQuerySupported())
+        {
+            MWRender::OcclusionQuery* query = mRendering->getOcclusionQuery();
+            if (!query->occlusionTestPending())
+            {
+                // get result of last query
+                if (mNumFacing == 0) mFacedHandle = "";
+                else if (mNumFacing == 1)
+                {
+                    bool result = query->getTestResult();
+                    mFacedHandle = result ? mFaced1Name : "";
+                }
+                else if (mNumFacing == 2)
+                {
+                    bool result = query->getTestResult();
+                    mFacedHandle = result ? mFaced2Name : mFaced1Name;
+                }
+
+                // send new query
+                // figure out which object we want to test against
+                std::vector < std::pair < float, std::string > > results = mPhysics->getFacedObjects();
+
+                // ignore the player and other things we're not interested in
+                std::vector < std::pair < float, std::string > >::iterator it = results.begin();
+                while (it != results.end())
+                {
+                    if ( (*it).second.find("HeightField") != std::string::npos // not interested in terrain
+                    || getPtrViaHandle((*it).second) == mPlayer->getPlayer() ) // not interested in player (unless you want to talk to yourself)
+                    {
+                        it = results.erase(it);
+                    }
+                    else
+                        ++it;
+                }
+
+                if (results.size() == 0)
+                {
+                    mNumFacing = 0;
+                }
+                else if (results.size() == 1)
+                {
+                    mFaced1 = getPtrViaHandle(results.front().second);
+                    mFaced1Name = results.front().second;
+                    mNumFacing = 1;
+
+                    btVector3 p = mPhysics->getRayPoint(results.front().first);
+                    Ogre::Vector3 pos(p.x(), p.z(), -p.y());
+                    Ogre::SceneNode* node = mFaced1.getRefData().getBaseNode();
+
+                    //std::cout << "Num facing 1 : " << mFaced1Name <<  std::endl;
+                    //std::cout << "Type 1 " << mFaced1.getTypeName() <<  std::endl;
+
+                    query->occlusionTest(pos, node);
+                }
+                else
+                {
+                    mFaced1Name = results.front().second;
+                    mFaced2Name = results[1].second;
+                    mFaced1 = getPtrViaHandle(results.front().second);
+                    mFaced2 = getPtrViaHandle(results[1].second);
+                    mNumFacing = 2;
+
+                    btVector3 p = mPhysics->getRayPoint(results[1].first);
+                    Ogre::Vector3 pos(p.x(), p.z(), -p.y());
+                    Ogre::SceneNode* node1 = mFaced1.getRefData().getBaseNode();
+                    Ogre::SceneNode* node2 = mFaced2.getRefData().getBaseNode();
+
+                    // no need to test if the first node is not occluder
+                    if (!query->isPotentialOccluder(node1) && (mFaced1.getTypeName().find("Static") == std::string::npos))
+                    {
+                        mFacedHandle = mFaced1Name;
+                        //std::cout << "node1 Not an occluder" << std::endl;
+                        return;
+                    }
+
+                    // no need to test if the second object is static (thus cannot be activated)
+                    if (mFaced2.getTypeName().find("Static") != std::string::npos)
+                    {
+                        mFacedHandle = mFaced1Name;
+                        return;
+                    }
+
+                    // work around door problems
+                    if (mFaced1.getTypeName().find("Static") != std::string::npos
+                        && mFaced2.getTypeName().find("Door") != std::string::npos)
+                    {
+                        mFacedHandle = mFaced2Name;
+                        return;
+                    }
+
+                    query->occlusionTest(pos, node2);
+                }
+            }
+        }
     }
 
     bool World::isCellExterior() const
@@ -754,4 +864,15 @@ namespace MWWorld
     {
         return mRendering->getFader();
     }
+
+    void World::setWaterHeight(const float height)
+    {
+        mRendering->setWaterHeight(height);
+    }
+
+    void World::toggleWater()
+    {
+        mRendering->toggleWater();
+    }
+
 }

apps/openmw/mwworld/world.hpp

@@ -63,13 +63,14 @@ namespace MWWorld
             enum RenderMode
             {
                 Render_CollisionDebug,
-                Render_Wireframe
+                Render_Wireframe,
+                Render_Pathgrid
             };
 
         private:
 
             MWRender::RenderingManager* mRendering;
-            
+
             MWWorld::WeatherManager* mWeatherManager;
 
             MWWorld::Scene *mWorldScene;
@@ -93,6 +94,12 @@ namespace MWWorld
 
             Ptr getPtrViaHandle (const std::string& handle, Ptr::CellStore& cellStore);
 
+            std::string mFacedHandle;
+            Ptr mFaced1;
+            Ptr mFaced2;
+            std::string mFaced1Name;
+            std::string mFaced2Name;
+            int mNumFacing;
 
             int getDaysPerMonth (int month) const;
 
@@ -106,13 +113,16 @@ namespace MWWorld
                 Environment& environment, const std::string& encoding);
 
             ~World();
-            
+
             OEngine::Render::Fader* getFader();
 
             Ptr::CellStore *getExterior (int x, int y);
 
             Ptr::CellStore *getInterior (const std::string& name);
-            
+
+            void setWaterHeight(const float height);
+            void toggleWater();
+
             void adjustSky();
 
             MWWorld::Player& getPlayer();
@@ -125,7 +135,7 @@ namespace MWWorld
 
             bool hasCellChanged() const;
             ///< Has the player moved to a different cell, since the last frame?
-            
+
             bool isCellExterior() const;
             bool isCellQuasiExterior() const;
 
@@ -163,9 +173,9 @@ namespace MWWorld
 
             bool toggleSky();
             ///< \return Resulting mode
-            
+
             void changeWeather(const std::string& region, const unsigned int id);
-            
+
             int getCurrentWeather() const;
 
             int getMasserPhase() const;

cmake/FindBullet.cmake

@@ -51,13 +51,13 @@ find_path(BULLET_INCLUDE_DIR NAMES btBulletCollisionCommon.h
 # Find the libraries
 
 _FIND_BULLET_LIBRARY(BULLET_DYNAMICS_LIBRARY        BulletDynamics)
-_FIND_BULLET_LIBRARY(BULLET_DYNAMICS_LIBRARY_DEBUG  BulletDynamics_d)
+_FIND_BULLET_LIBRARY(BULLET_DYNAMICS_LIBRARY_DEBUG  BulletDynamics_Debug BulletDynamics_d)
 _FIND_BULLET_LIBRARY(BULLET_COLLISION_LIBRARY       BulletCollision)
-_FIND_BULLET_LIBRARY(BULLET_COLLISION_LIBRARY_DEBUG BulletCollision_d)
-_FIND_BULLET_LIBRARY(BULLET_MATH_LIBRARY            LinearMath BulletMath)
-_FIND_BULLET_LIBRARY(BULLET_MATH_LIBRARY_DEBUG      LinearMath_d BulletMath_d)
+_FIND_BULLET_LIBRARY(BULLET_COLLISION_LIBRARY_DEBUG BulletCollision_Debug BulletCollision_d)
+_FIND_BULLET_LIBRARY(BULLET_MATH_LIBRARY            BulletMath LinearMath)
+_FIND_BULLET_LIBRARY(BULLET_MATH_LIBRARY_DEBUG      BulletMath_Debug BulletMath_d LinearMath_debug LinearMath_d)
 _FIND_BULLET_LIBRARY(BULLET_SOFTBODY_LIBRARY        BulletSoftBody)
-_FIND_BULLET_LIBRARY(BULLET_SOFTBODY_LIBRARY_DEBUG  BulletSoftBody_d)
+_FIND_BULLET_LIBRARY(BULLET_SOFTBODY_LIBRARY_DEBUG  BulletSoftBody_Debug BulletSoftBody_d)
 
 
 # handle the QUIETLY and REQUIRED arguments and set BULLET_FOUND to TRUE if

components/CMakeLists.txt

@@ -2,6 +2,10 @@ project (Components)
 
 # source files
 
+add_component_dir (settings
+    settings
+    )
+
 add_component_dir (bsa
     bsa_archive bsa_file
     )

components/bsa/bsa_archive.cpp

@@ -41,7 +41,21 @@ struct ciLessBoost : std::binary_function<std::string, std::string, bool>
 {
     bool operator() (const std::string & s1, const std::string & s2) const {
                                                //case insensitive version of is_less
-        return lexicographical_compare(s1, s2, boost::algorithm::is_iless());
+        return boost::ilexicographical_compare(s1, s2);
+    }
+};
+
+struct pathComparer
+{
+private:
+    std::string find;
+
+public:
+    pathComparer(const std::string& toFind) : find(toFind) { }
+
+    bool operator() (const std::string& other)
+    {
+        return boost::iequals(find, other);
     }
 };
 
@@ -55,16 +69,62 @@ class DirArchive: public Ogre::FileSystemArchive
     std::map<std::string, std::vector<std::string>, ciLessBoost> m;
     unsigned int cutoff;
 
-    bool comparePortion(std::string file1, std::string file2, int start, int size) const
+    bool findFile(const String& filename, std::string& copy) const
     {
-        for(int i = start; i < start+size; i++)
         {
-            char one = file1.at(i);
-            char two = file2.at(i);
-            if(tolower(one) != tolower(two) )
-                return false;
+            String passed = filename;
+	        if(filename.at(filename.length() - 1) == '*' || filename.at(filename.length() - 1) == '?' ||  filename.at(filename.length() - 1) == '<'
+		        || filename.at(filename.length() - 1) == '"' || filename.at(filename.length() - 1) == '>' ||  filename.at(filename.length() - 1) == ':'
+		        || filename.at(filename.length() - 1) == '|')
+	        {
+	           passed = filename.substr(0, filename.length() - 2);
+	        }
+	        if(filename.at(filename.length() - 2) == '>')
+		        passed = filename.substr(0, filename.length() - 6);
+            copy = passed;
         }
-        return true;
+
+        std::replace(copy.begin(), copy.end(), '\\', '/');
+
+        if(copy.at(0) == '/')
+            copy.erase(0, 1);
+
+        if(fsstrict == true)
+            return true;
+
+        std::string folder;
+        int delimiter = 0;
+        size_t lastSlash = copy.rfind('/');
+        if (lastSlash != std::string::npos)
+        {
+            folder = copy.substr(0, lastSlash);
+            delimiter = lastSlash+1;
+        }
+
+        std::vector<std::string> current;
+        {
+            std::map<std::string,std::vector<std::string>,ciLessBoost>::const_iterator found = m.find(folder);
+
+            if (found == m.end())
+            {
+                return false;
+            }
+            else
+                current = found->second;
+        }
+
+        std::vector<std::string>::iterator find = std::lower_bound(current.begin(), current.end(), copy, ciLessBoost());
+        if (find != current.end() && !ciLessBoost()(copy, current.front()))
+        {
+            if (!boost::iequals(copy, *find))
+                if ((find = std::find_if(current.begin(), current.end(), pathComparer(copy))) == current.end()) //\todo Check if this line is actually needed
+                    return false;
+
+            copy = *find;
+            return true;
+        }
+
+        return false;
     }
 
     public:
@@ -83,16 +143,14 @@ class DirArchive: public Ogre::FileSystemArchive
      //need to cut off first
       boost::filesystem::directory_iterator dir_iter(d), dir_end;
       std::vector<std::string> filesind;
-      boost::filesystem::path f;
       for(;dir_iter != dir_end; dir_iter++)
     {
         if(boost::filesystem::is_directory(*dir_iter))
             populateMap(*dir_iter);
         else
         {
-
-            f = *dir_iter;
-            std::string s = f.string();
+            std::string s = dir_iter->path().string();
+            std::replace(s.begin(), s.end(), '\\', '/');
 
             std::string small;
             if(cutoff < s.size())
@@ -103,14 +161,17 @@ class DirArchive: public Ogre::FileSystemArchive
             filesind.push_back(small);
         }
     }
+    std::sort(filesind.begin(), filesind.end(), ciLessBoost());
+
     std::string small;
     std::string original = d.string();
+    std::replace(original.begin(), original.end(), '\\', '/');
     if(cutoff < original.size())
         small = original.substr(cutoff, original.size() - cutoff);
     else
         small = original.substr(cutoff - 1, original.size() - cutoff);
-    m[small] = filesind;
 
+    m[small] = filesind;
   }
 
     bool isCaseSensitive() const { return fsstrict; }
@@ -120,97 +181,21 @@ class DirArchive: public Ogre::FileSystemArchive
     void unload() {}
 
      bool exists(const String& filename) {
-        std::string copy = filename;
+        std::string copy;
 
-
-
-      for (unsigned int i = 0; i < filename.size(); i++)
-      {
-          if(copy.at(i) == '\\' ){
-                copy.replace(i, 1, "/");
-          }
-      }
-
-
-      if(copy.at(0) == '\\' || copy.at(0) == '/')
-        {
-            copy.erase(0, 1);
-        }
-        if(fsstrict == true)
-        {
-            //std::cout << "fsstrict " << copy << "\n";
+        if (findFile(filename, copy))
             return FileSystemArchive::exists(copy);
-        }
-
-
-      int last = copy.size() - 1;
-      int i = last;
-
-      for (;last >= 0; i--)
-      {
-          if(copy.at(i) == '/' || copy.at(i) == '\\')
-                break;
-      }
-
-      std::string folder = copy.substr(0, i);                              //folder with no slash
-
-      std::vector<std::string>& current = m[folder];
-
-       for(std::vector<std::string>::iterator iter = current.begin(); iter != current.end(); iter++)
-       {
-            if(comparePortion(*iter, copy, i + 1, copy.size() - i -1) == true){
-            return FileSystemArchive::exists(*iter);
-            }
-       }
-
 
       return false;
      }
 
     DataStreamPtr open(const String& filename, bool readonly = true) const
   {
-     std::map<std::string, std::vector<std::string>, ciLessBoost> mlocal = m;
-        std::string copy = filename;
+        std::string copy;
 
-
-
-      for (unsigned int i = 0; i < filename.size(); i++)
-      {
-          if(copy.at(i) == '\\' ){
-                copy.replace(i, 1, "/");
-          }
-      }
-
-
-      if(copy.at(0) == '\\' || copy.at(0) == '/')
-        {
-            copy.erase(0, 1);
-        }
-
-        if(fsstrict == true)
-        {
+        if (findFile(filename, copy))
             return FileSystemArchive::open(copy, readonly);
-        }
 
-
-      int last = copy.size() - 1;
-      int i = last;
-
-      for (;last >= 0; i--)
-      {
-          if(copy.at(i) == '/' || copy.at(i) == '\\')
-                break;
-      }
-
-      std::string folder = copy.substr(0, i);                              //folder with no slash
-      std::vector<std::string> current = mlocal[folder];
-
-       for(std::vector<std::string>::iterator iter = current.begin(); iter != current.end(); iter++)
-       {
-            if(comparePortion(*iter, copy, i + 1, copy.size() - i -1) == true){
-            return FileSystemArchive::open(*iter, readonly);
-            }
-       }
         DataStreamPtr p;
       return p;
   }
@@ -261,7 +246,7 @@ bool exists(const String& filename) {
 }
 
   // Check if the file exists.
-  bool cexists(const String& filename) const { 
+  bool cexists(const String& filename) const {
     String passed = filename;
 	if(filename.at(filename.length() - 1) == '*' || filename.at(filename.length() - 1) == '?' ||  filename.at(filename.length() - 1) == '<'
 		|| filename.at(filename.length() - 1) == '"' || filename.at(filename.length() - 1) == '>' ||  filename.at(filename.length() - 1) == ':'
@@ -272,7 +257,7 @@ bool exists(const String& filename) {
 	if(filename.at(filename.length() - 2) == '>')
 		passed = filename.substr(0, filename.length() - 6);
 
-return arc.exists(passed.c_str()); 
+return arc.exists(passed.c_str());
 }
   time_t getModifiedTime(const String&) { return 0; }
 

components/esm/loadcell.cpp

@@ -21,8 +21,13 @@ void Cell::load(ESMReader &esm)
     if (data.flags & Interior)
     {
         // Interior cells
-
-        if (esm.isNextSub("INTV") || esm.isNextSub("WHGT"))
+        if (esm.isNextSub("INTV"))
+        {
+            int waterl;
+            esm.getHT(waterl);
+            water = (float) waterl;
+        }
+        else if (esm.isNextSub("WHGT"))
             esm.getHT(water);
 
         // Quasi-exterior cells have a region (which determines the

components/esm/loadcell.hpp

@@ -114,7 +114,7 @@ struct Cell
   ESM_Context context; // File position
   DATAstruct data;
   AMBIstruct ambi;
-  int water; // Water level
+  float water; // Water level
   int mapColor;
 
   void load(ESMReader &esm);

components/esm_store/cell_store.hpp

@@ -96,12 +96,16 @@ namespace ESMS
     };
 
     CellStore (const ESM::Cell *cell_) : cell (cell_), mState (State_Unloaded)
-                                         {}
+    {
+        mWaterLevel = cell->water;
+    }
 
     const ESM::Cell *cell;
     State mState;
     std::vector<std::string> mIds;
 
+    float mWaterLevel;
+
     // Lists for each individual object type
     CellRefList<Activator, D>         activators;
     CellRefList<Potion, D>            potions;

components/esm_store/reclists.hpp

@@ -457,7 +457,7 @@ namespace ESMS
           }
       }
 
-      Pathgrid *find(int cellX, int cellY, std::string cellName) const
+      Pathgrid *find(int cellX, int cellY, const std::string &cellName) const
       {
           Pathgrid *result = search(cellX, cellY, cellName);
           if (!result)
@@ -467,7 +467,7 @@ namespace ESMS
           return result;
       }
 
-      Pathgrid *search(int cellX, int cellY, std::string cellName) const
+      Pathgrid *search(int cellX, int cellY, const std::string &cellName) const
       {
           Pathgrid *result = NULL;
           if (cellX == 0 && cellY == 0) // possibly interior

components/files/collections.cpp

@@ -30,4 +30,9 @@ namespace Files
 
         return iter->second;
     }
+
+    const Files::PathContainer& Collections::getPaths() const
+    {
+        return mDirectories;
+    }
 }

components/files/collections.hpp

@@ -21,6 +21,8 @@ namespace Files
             /// leading dot and must be all lower-case.
             const MultiDirCollection& getCollection(const std::string& extension) const;
 
+            const Files::PathContainer& getPaths() const;
+
         private:
             typedef std::map<std::string, MultiDirCollection> MultiDirCollectionContainer;
             Files::PathContainer mDirectories;

components/nifogre/ogre_nif_loader.cpp

@@ -25,6 +25,7 @@
 
 #include "ogre_nif_loader.hpp"
 
+#include <components/settings/settings.hpp>
 
 typedef unsigned char ubyte;
 
@@ -299,138 +300,136 @@ void NIFLoader::createMaterial(const String &name,
     material->setSelfIllumination(emissive.array[0], emissive.array[1], emissive.array[2]);
     material->setShininess(glossiness);
 
-    // Create shader for the material
-    // vertex
-    HighLevelGpuProgramManager& mgr = HighLevelGpuProgramManager::getSingleton();
-
-    HighLevelGpuProgramPtr vertex;
-    if (mgr.getByName("main_vp").isNull())
+    if (Settings::Manager::getBool("shaders", "Objects"))
     {
-        vertex = mgr.createProgram("main_vp", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
-            "cg", GPT_VERTEX_PROGRAM);
-        vertex->setParameter("profiles", "vs_4_0 vs_2_x vp40 arbvp1");
-        vertex->setParameter("entry_point", "main_vp");
-        StringUtil::StrStreamType outStream;
-        outStream <<
-        "void main_vp(	\n"
-        "	float4 position : POSITION,	\n"
-        "   float4 normal : NORMAL, \n"
-        "   float4 colour : COLOR, \n"
-        "   in float2 uv : TEXCOORD0, \n"
-        "   out float2 oUV : TEXCOORD0, \n"
-        "	out float4 oPosition : POSITION,	\n"
-        "   out float4 oPositionObjSpace : TEXCOORD1, \n"
-        "   out float4 oNormal : TEXCOORD2, \n"
-        "   out float oFogValue : TEXCOORD3, \n"
-        "   out float4 oVertexColour : TEXCOORD4, \n"
-        "   uniform float4 fogParams, \n"
-        "	uniform float4x4 worldViewProj	\n"
-        ")	\n"
-        "{	\n"
-        "   oVertexColour = colour; \n"
-        "   oUV = uv; \n"
-        "   oNormal = normal; \n"
-        "	oPosition = mul( worldViewProj, position );  \n"
-        "   oFogValue = saturate((oPosition.z - fogParams.y) * fogParams.w); \n"
-        "   oPositionObjSpace = position; \n"
-        "}";
-        vertex->setSource(outStream.str());
-        vertex->load();
-        vertex->getDefaultParameters()->setNamedAutoConstant("worldViewProj", GpuProgramParameters::ACT_WORLDVIEWPROJ_MATRIX);
-        vertex->getDefaultParameters()->setNamedAutoConstant("fogParams", GpuProgramParameters::ACT_FOG_PARAMS);
-    }
-    else
-        vertex = mgr.getByName("main_vp");
-    material->getTechnique(0)->getPass(0)->setVertexProgram(vertex->getName());
+        // Create shader for the material
+        // vertex
+        HighLevelGpuProgramManager& mgr = HighLevelGpuProgramManager::getSingleton();
 
-    // the number of lights to support.
-    // when rendering an object, OGRE automatically picks the lights that are
-    // closest to the object being rendered. unfortunately this mechanism does
-    // not work perfectly for objects batched together (they will all use the same
-    // lights). to work around this, we are simply pushing the maximum number
-    // of lights here in order to minimize disappearing lights.
-    float num_lights;
-    if (GpuProgramManager::getSingleton().isSyntaxSupported("fp40") ||
-        GpuProgramManager::getSingleton().isSyntaxSupported("ps_4_0"))
-        num_lights = 8 /* 32 */;
-    else
-        num_lights = 8;
-
-    // fragment
-    HighLevelGpuProgramPtr fragment;
-    if (mgr.getByName("main_fp").isNull())
-    {
-        fragment = mgr.createProgram("main_fp", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
-            "cg", GPT_FRAGMENT_PROGRAM);
-        fragment->setParameter("profiles", "ps_4_0 ps_2_x fp40 arbfp1");
-        fragment->setParameter("entry_point", "main_fp");
-        StringUtil::StrStreamType outStream;
-        outStream <<
-        "void main_fp(	\n"
-        "   in float2 uv : TEXCOORD0, \n"
-        "	out float4 oColor    : COLOR, \n"
-        "   uniform sampler2D texture : TEXUNIT0, \n"
-        "   float4 positionObjSpace : TEXCOORD1, \n"
-        "   float4 normal : TEXCOORD2, \n"
-        "   float fogValue : TEXCOORD3, \n"
-        "   float4 vertexColour : TEXCOORD4, \n"
-        "   uniform float4 fogColour, \n";
-
-        for (int i=0; i<num_lights; ++i)
+        HighLevelGpuProgramPtr vertex;
+        if (mgr.getByName("main_vp").isNull())
         {
+            vertex = mgr.createProgram("main_vp", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
+                "cg", GPT_VERTEX_PROGRAM);
+            vertex->setParameter("profiles", "vs_4_0 vs_2_x vp40 arbvp1");
+            vertex->setParameter("entry_point", "main_vp");
+            StringUtil::StrStreamType outStream;
             outStream <<
-            "   uniform float4 lightDiffuse"<<i<<", \n"
-            "   uniform float4 lightPositionObjSpace"<<i<<", \n"
-            "   uniform float4 lightAttenuation"<<i<<", \n";
+            "void main_vp(	\n"
+            "	float4 position : POSITION,	\n"
+            "   float4 normal : NORMAL, \n"
+            "   float4 colour : COLOR, \n"
+            "   in float2 uv : TEXCOORD0, \n"
+            "   out float2 oUV : TEXCOORD0, \n"
+            "	out float4 oPosition : POSITION,	\n"
+            "   out float4 oPositionObjSpace : TEXCOORD1, \n"
+            "   out float4 oNormal : TEXCOORD2, \n"
+            "   out float oFogValue : TEXCOORD3, \n"
+            "   out float4 oVertexColour : TEXCOORD4, \n"
+            "   uniform float4 fogParams, \n"
+            "	uniform float4x4 worldViewProj	\n"
+            ")	\n"
+            "{	\n"
+            "   oVertexColour = colour; \n"
+            "   oUV = uv; \n"
+            "   oNormal = normal; \n"
+            "	oPosition = mul( worldViewProj, position );  \n"
+            "   oFogValue = saturate((oPosition.z - fogParams.y) * fogParams.w); \n"
+            "   oPositionObjSpace = position; \n"
+            "}";
+            vertex->setSource(outStream.str());
+            vertex->load();
+            vertex->getDefaultParameters()->setNamedAutoConstant("worldViewProj", GpuProgramParameters::ACT_WORLDVIEWPROJ_MATRIX);
+            vertex->getDefaultParameters()->setNamedAutoConstant("fogParams", GpuProgramParameters::ACT_FOG_PARAMS);
         }
-        outStream <<
-        "   uniform float4 lightAmbient, \n"
-        "   uniform float4 ambient, \n"
-        "   uniform float4 diffuse, \n"
-        "   uniform float4 emissive \n"
-        ")	\n"
-        "{	\n"
-        "   float4 tex =  tex2D(texture, uv); \n"
-        "   float d; \n"
-        "   float attn; \n"
-        "   float3 lightColour = float3(0, 0, 0); \n";
-        
-        for (int i=0; i<num_lights; ++i)
+        else
+            vertex = mgr.getByName("main_vp");
+        material->getTechnique(0)->getPass(0)->setVertexProgram(vertex->getName());
+
+        // the number of lights to support.
+        // when rendering an object, OGRE automatically picks the lights that are
+        // closest to the object being rendered. unfortunately this mechanism does
+        // not work perfectly for objects batched together (they will all use the same
+        // lights). to work around this, we are simply pushing the maximum number
+        // of lights here in order to minimize disappearing lights.
+        int num_lights = Settings::Manager::getInt("num lights", "Objects");
+
+        // fragment
+        HighLevelGpuProgramPtr fragment;
+        if (mgr.getByName("main_fp").isNull())
         {
+            fragment = mgr.createProgram("main_fp", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
+                "cg", GPT_FRAGMENT_PROGRAM);
+            fragment->setParameter("profiles", "ps_4_0 ps_2_x fp40 arbfp1");
+            fragment->setParameter("entry_point", "main_fp");
+            StringUtil::StrStreamType outStream;
             outStream <<
-            "   float3 lightDir"<<i<<" = lightPositionObjSpace"<<i<<".xyz - (positionObjSpace.xyz * lightPositionObjSpace"<<i<<".w); \n"
+            "void main_fp(	\n"
+            "   in float2 uv : TEXCOORD0, \n"
+            "	out float4 oColor    : COLOR, \n"
+            "   uniform sampler2D texture : TEXUNIT0, \n"
+            "   float4 positionObjSpace : TEXCOORD1, \n"
+            "   float4 normal : TEXCOORD2, \n"
+            "   float fogValue : TEXCOORD3, \n"
+            "   float4 vertexColour : TEXCOORD4, \n"
+            "   uniform float4 fogColour, \n";
 
-            // pre-multiply light color with attenuation factor
-            "   d = length( lightDir"<<i<<" ); \n"
-            "   attn = ( 1.0 / (( lightAttenuation"<<i<<".y ) + ( lightAttenuation"<<i<<".z * d ) + ( lightAttenuation"<<i<<".w * d * d ))); \n"
-            "   lightDiffuse"<<i<<" *= attn; \n"
+            for (int i=0; i<num_lights; ++i)
+            {
+                outStream <<
+                "   uniform float4 lightDiffuse"<<i<<", \n"
+                "   uniform float4 lightPositionObjSpace"<<i<<", \n"
+                "   uniform float4 lightAttenuation"<<i<<", \n";
+            }
+            outStream <<
+            "   uniform float4 lightAmbient, \n"
+            "   uniform float4 ambient, \n"
+            "   uniform float4 diffuse, \n"
+            "   uniform float4 emissive \n"
+            ")	\n"
+            "{	\n"
+            "   float4 tex =  tex2D(texture, uv); \n"
+            "   float d; \n"
+            "   float attn; \n"
+            "   float3 lightColour = float3(0, 0, 0); \n";
+            
+            for (int i=0; i<num_lights; ++i)
+            {
+                outStream <<
+                "   float3 lightDir"<<i<<" = lightPositionObjSpace"<<i<<".xyz - (positionObjSpace.xyz * lightPositionObjSpace"<<i<<".w); \n"
 
-            "	lightColour.xyz += lit(dot(normalize(lightDir"<<i<<"), normalize(normal)), 0, 0).y * lightDiffuse"<<i<<".xyz;\n";
+                // pre-multiply light color with attenuation factor
+                "   d = length( lightDir"<<i<<" ); \n"
+                "   attn = ( 1.0 / (( lightAttenuation"<<i<<".y ) + ( lightAttenuation"<<i<<".z * d ) + ( lightAttenuation"<<i<<".w * d * d ))); \n"
+                "   lightDiffuse"<<i<<" *= attn; \n"
+
+                "	lightColour.xyz += lit(dot(normalize(lightDir"<<i<<"), normalize(normal)), 0, 0).y * lightDiffuse"<<i<<".xyz;\n";
+            }
+            
+            outStream <<
+            "   float3 lightingFinal = lightColour.xyz * diffuse.xyz * vertexColour.xyz + ambient.xyz * lightAmbient.xyz + emissive.xyz; \n"
+            "   oColor.xyz = lerp(lightingFinal * tex.xyz, fogColour, fogValue); \n"
+            "   oColor.a = tex.a * diffuse.a * vertexColour.a; \n"
+            "}";
+            fragment->setSource(outStream.str());
+            fragment->load();
+
+            for (int i=0; i<num_lights; ++i)
+            {
+                fragment->getDefaultParameters()->setNamedAutoConstant("lightPositionObjSpace"+StringConverter::toString(i), GpuProgramParameters::ACT_LIGHT_POSITION_OBJECT_SPACE, i);
+                fragment->getDefaultParameters()->setNamedAutoConstant("lightDiffuse"+StringConverter::toString(i), GpuProgramParameters::ACT_LIGHT_DIFFUSE_COLOUR, i);
+                fragment->getDefaultParameters()->setNamedAutoConstant("lightAttenuation"+StringConverter::toString(i), GpuProgramParameters::ACT_LIGHT_ATTENUATION, i);
+            }
+            fragment->getDefaultParameters()->setNamedAutoConstant("emissive", GpuProgramParameters::ACT_SURFACE_EMISSIVE_COLOUR);
+            fragment->getDefaultParameters()->setNamedAutoConstant("diffuse", GpuProgramParameters::ACT_SURFACE_DIFFUSE_COLOUR);
+            fragment->getDefaultParameters()->setNamedAutoConstant("ambient", GpuProgramParameters::ACT_SURFACE_AMBIENT_COLOUR);
+            fragment->getDefaultParameters()->setNamedAutoConstant("lightAmbient", GpuProgramParameters::ACT_AMBIENT_LIGHT_COLOUR);
+            fragment->getDefaultParameters()->setNamedAutoConstant("fogColour", GpuProgramParameters::ACT_FOG_COLOUR);
         }
-        
-        outStream <<
-        "   float3 lightingFinal = lightColour.xyz * diffuse.xyz * vertexColour.xyz + ambient.xyz * lightAmbient.xyz + emissive.xyz; \n"
-        "   oColor.xyz = lerp(lightingFinal * tex.xyz, fogColour, fogValue); \n"
-        "   oColor.a = tex.a * diffuse.a * vertexColour.a; \n"
-        "}";
-        fragment->setSource(outStream.str());
-        fragment->load();
-
-        for (int i=0; i<num_lights; ++i)
-        {
-            fragment->getDefaultParameters()->setNamedAutoConstant("lightPositionObjSpace"+StringConverter::toString(i), GpuProgramParameters::ACT_LIGHT_POSITION_OBJECT_SPACE, i);
-            fragment->getDefaultParameters()->setNamedAutoConstant("lightDiffuse"+StringConverter::toString(i), GpuProgramParameters::ACT_LIGHT_DIFFUSE_COLOUR, i);
-            fragment->getDefaultParameters()->setNamedAutoConstant("lightAttenuation"+StringConverter::toString(i), GpuProgramParameters::ACT_LIGHT_ATTENUATION, i);
-        }
-        fragment->getDefaultParameters()->setNamedAutoConstant("emissive", GpuProgramParameters::ACT_SURFACE_EMISSIVE_COLOUR);
-        fragment->getDefaultParameters()->setNamedAutoConstant("diffuse", GpuProgramParameters::ACT_SURFACE_DIFFUSE_COLOUR);
-        fragment->getDefaultParameters()->setNamedAutoConstant("ambient", GpuProgramParameters::ACT_SURFACE_AMBIENT_COLOUR);
-        fragment->getDefaultParameters()->setNamedAutoConstant("lightAmbient", GpuProgramParameters::ACT_AMBIENT_LIGHT_COLOUR);
-        fragment->getDefaultParameters()->setNamedAutoConstant("fogColour", GpuProgramParameters::ACT_FOG_COLOUR);
+        else
+            fragment = mgr.getByName("main_fp");
+        material->getTechnique(0)->getPass(0)->setFragmentProgram(fragment->getName());
     }
-    else
-        fragment = mgr.getByName("main_fp");
-    material->getTechnique(0)->getPass(0)->setFragmentProgram(fragment->getName());
 }
 
 // Takes a name and adds a unique part to it. This is just used to
@@ -1368,7 +1367,7 @@ void NIFLoader::loadResource(Resource *resource)
 
     if (!vfs->isFile(resourceName))
     {
-        warn("File not found.");
+        warn("File "+resourceName+" not found.");
         return;
     }
 

components/settings/settings.cpp

@@ -0,0 +1,158 @@
+#include "settings.hpp"
+
+#include <fstream>
+
+#include <OgreResourceGroupManager.h>
+#include <OgreStringConverter.h>
+
+using namespace Settings;
+
+Ogre::ConfigFile Manager::mFile = Ogre::ConfigFile();
+Ogre::ConfigFile Manager::mDefaultFile = Ogre::ConfigFile();
+CategorySettingVector Manager::mChangedSettings = CategorySettingVector();
+CategorySettingValueMap Manager::mNewSettings = CategorySettingValueMap();
+
+void Manager::loadUser (const std::string& file)
+{
+    mFile.load(file);
+}
+
+void Manager::loadDefault (const std::string& file)
+{
+    mDefaultFile.load(file);
+}
+
+void Manager::saveUser(const std::string& file)
+{
+    std::fstream fout(file.c_str(), std::ios::out);
+
+    Ogre::ConfigFile::SectionIterator seci = mFile.getSectionIterator();
+
+    while (seci.hasMoreElements())
+    {
+        Ogre::String sectionName = seci.peekNextKey();
+
+        if (sectionName.length() > 0)
+            fout << '\n' << '[' << seci.peekNextKey() << ']' << '\n';
+
+        Ogre::ConfigFile::SettingsMultiMap *settings = seci.getNext();
+        Ogre::ConfigFile::SettingsMultiMap::iterator i;
+        for (i = settings->begin(); i != settings->end(); ++i)
+        {
+            fout << i->first.c_str() << " = " << i->second.c_str() << '\n';
+        }
+
+        CategorySettingValueMap::iterator it = mNewSettings.begin();
+        while (it != mNewSettings.end())
+        {
+            if (it->first.first == sectionName)
+            {
+                fout << it->first.second << " = " << it->second << '\n';
+                mNewSettings.erase(it++);
+            }
+            else
+                ++it;
+        }
+    }
+
+    std::string category = "";
+    for (CategorySettingValueMap::iterator it = mNewSettings.begin();
+            it != mNewSettings.end(); ++it)
+    {
+        if (category != it->first.first)
+        {
+            category = it->first.first;
+            fout << '\n' << '[' << category << ']' << '\n';
+        }
+        fout << it->first.second << " = " << it->second << '\n';
+    }
+}
+
+const std::string Manager::getString (const std::string& setting, const std::string& category)
+{
+    if (mNewSettings.find(std::make_pair(category, setting)) != mNewSettings.end())
+        return mNewSettings[std::make_pair(category, setting)];
+
+    std::string defaultval = mDefaultFile.getSetting(setting, category);
+    return mFile.getSetting(setting, category, defaultval);
+}
+
+const float Manager::getFloat (const std::string& setting, const std::string& category)
+{
+    return Ogre::StringConverter::parseReal( getString(setting, category) );
+}
+
+const int Manager::getInt (const std::string& setting, const std::string& category)
+{
+    return Ogre::StringConverter::parseInt( getString(setting, category) );
+}
+
+const bool Manager::getBool (const std::string& setting, const std::string& category)
+{
+    return Ogre::StringConverter::parseBool( getString(setting, category) );
+}
+
+void Manager::setString (const std::string& setting, const std::string& category, const std::string& value)
+{
+    CategorySetting s = std::make_pair(category, setting);
+
+    bool found=false;
+    try
+    {
+        Ogre::ConfigFile::SettingsIterator it = mFile.getSettingsIterator(category);
+        while (it.hasMoreElements())
+        {
+            Ogre::ConfigFile::SettingsMultiMap::iterator i = it.current();
+
+            if ((*i).first == setting)
+            {
+                if ((*i).second != value)
+                {
+                    mChangedSettings.push_back(std::make_pair(category, setting));
+                    (*i).second = value;
+                }
+                found = true;
+            }
+
+            it.getNext();
+        }
+    }
+    catch (Ogre::Exception&)
+    {}
+
+    if (!found)
+    {
+        if (mNewSettings.find(s) != mNewSettings.end())
+        {
+            if (mNewSettings[s] != value)
+            {
+                mChangedSettings.push_back(std::make_pair(category, setting));
+                mNewSettings[s] = value;
+            }
+        }
+        else
+            mNewSettings[s] = value;
+    }
+}
+
+void Manager::setInt (const std::string& setting, const std::string& category, const int value)
+{
+    setString(setting, category, Ogre::StringConverter::toString(value));
+}
+
+void Manager::setFloat (const std::string& setting, const std::string& category, const float value)
+{
+    setString(setting, category, Ogre::StringConverter::toString(value));
+}
+
+void Manager::setBool (const std::string& setting, const std::string& category, const bool value)
+{
+    setString(setting, category, Ogre::StringConverter::toString(value));
+}
+
+const CategorySettingVector Manager::apply()
+{
+    CategorySettingVector vec = mChangedSettings;
+    mChangedSettings.clear();
+    return vec;
+}

components/settings/settings.hpp

@@ -0,0 +1,52 @@
+#ifndef _COMPONENTS_SETTINGS_H
+#define _COMPONENTS_SETTINGS_H
+
+#include <OgreConfigFile.h>
+
+namespace Settings
+{
+    typedef std::pair < std::string, std::string > CategorySetting; 
+    typedef std::vector< std::pair<std::string, std::string> > CategorySettingVector;
+    typedef std::map < CategorySetting, std::string > CategorySettingValueMap;
+
+    ///
+    /// \brief Settings management (can change during runtime)
+    ///
+    class Manager
+    {
+    public:
+        static Ogre::ConfigFile mFile;
+        static Ogre::ConfigFile mDefaultFile;
+
+        static CategorySettingVector mChangedSettings;
+        ///< tracks all the settings that were changed since the last apply() call
+
+        static CategorySettingValueMap mNewSettings;
+        ///< tracks all the settings that are in the default file, but not in user file yet
+
+        void loadDefault (const std::string& file);
+        ///< load file as the default settings (can be overridden by user settings)
+
+        void loadUser (const std::string& file);
+        ///< load file as user settings
+
+        void saveUser (const std::string& file);
+        ///< save user settings to file
+
+        static const CategorySettingVector apply();
+        ///< returns the list of changed settings and then clears it
+
+        static const int getInt (const std::string& setting, const std::string& category);
+        static const float getFloat (const std::string& setting, const std::string& category);
+        static const std::string getString (const std::string& setting, const std::string& category);
+        static const bool getBool (const std::string& setting, const std::string& category);
+
+        static void setInt (const std::string& setting, const std::string& category, const int value);
+        static void setFloat (const std::string& setting, const std::string& category, const float value);
+        static void setString (const std::string& setting, const std::string& category, const std::string& value);
+        static void setBool (const std::string& setting, const std::string& category, const bool value);
+    };
+
+}
+
+#endif // _COMPONENTS_SETTINGS_H

files/CMakeLists.txt

@@ -0,0 +1,13 @@
+project(resources)
+
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/water/caustic_0.png "${OpenMW_BINARY_DIR}/resources/water/caustic_0.png" COPYONLY) 
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/water/Example_Fresnel.cg "${OpenMW_BINARY_DIR}/resources/water/Example_Fresnel.cg" COPYONLY) 
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/water/Example_FresnelPS.asm "${OpenMW_BINARY_DIR}/resources/water/Example_FresnelPS.asm" COPYONLY) 
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/water/GlassFP.cg "${OpenMW_BINARY_DIR}/resources/water/GlassFP.cg" COPYONLY) 
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/water/GlassVP.cg "${OpenMW_BINARY_DIR}/resources/water/GlassVP.cg" COPYONLY) 
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/water/perlinvolume.dds "${OpenMW_BINARY_DIR}/resources/water/perlinvolume.dds" COPYONLY) 
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/water/Water02.jpg "${OpenMW_BINARY_DIR}/resources/water/Water02.jpg" COPYONLY) 
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/water/water.compositor "${OpenMW_BINARY_DIR}/resources/water/water.compositor" COPYONLY)
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/water/waves2.dds "${OpenMW_BINARY_DIR}/resources/water/waves2.dds" COPYONLY)
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/water/Examples-Water.material "${OpenMW_BINARY_DIR}/resources/water/Examples-Water.material" COPYONLY)
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/water/WaterNormal1.tga "${OpenMW_BINARY_DIR}/resources/water/WaterNormal1.tga" COPYONLY)

files/mygui/openmw_dialogue_window_layout.xml

@@ -1,34 +1,29 @@
 <?xml version="1.0" encoding="UTF-8"?>
 
 <MyGUI type="Layout">
-    <Widget type="Window" skin="MW_Dialog" layer="Windows" position="0 0 588 433" name="_Main">
-        <!-- HEADER -->
-        <Widget type="TextBox" skin="HeaderText" position="0 0 588 18" name="NpcName" align="ALIGN_LEFT ALIGN_TOP">
-            <Property key="Caption" value="Name"/>
-            <Property key="TextAlign" value="ALIGN_CENTER"/>
-        </Widget>
+    <Widget type="Window" skin="MW_Window" layer="Windows" position="0 0 588 433" name="_Main">
 
         <!-- The Dialogue history -->
-        <Widget type="DialogueHistory" skin="MW_TextBoxEdit" position="8 39 400 375" name="History"  align="ALIGN_LEFT ALIGN_TOP STRETCH">
+        <Widget type="DialogueHistory" skin="MW_TextBoxEdit" position="8 8 415 381" name="History"  align="ALIGN_LEFT ALIGN_TOP ALIGN_STRETCH">
             <Property key="Static" value="true"/>
             <Property key="WordWrap" value="true"/>
             <Property key="MultiLine" value="1" />
             <Property key="VisibleVScroll" value="1" />
             <!-- invisible box for receiving mouse events -->
-            <Widget type="Widget" skin="" position="0 0 400 375" name="EventBox" align="ALIGN_LEFT ALIGN_TOP STRETCH"/>
+            <Widget type="Widget" skin="" position="0 0 400 375" name="EventBox" align="ALIGN_LEFT ALIGN_TOP ALIGN_STRETCH"/>
         </Widget>
 
 		<!-- The disposition bar-->
-        <Widget type="ProgressBar" skin="MW_EnergyBar_Blue" position="432 39 132 18"
+        <Widget type="ProgressBar" skin="MW_EnergyBar_Blue" position="432 8 132 18"
             align="Right Top" name="Disposition">
 			<Widget type="EditBox" skin="MW_DispositionEdit" position_real = "0.25 0 0.5 1" name = "DispositionText"/>
 		</Widget>
         <!-- The list of topics -->
-        <Widget type="ListBox" skin="MW_List" position="432 62 132 318" name="TopicsList">
+        <Widget type="ListBox" skin="MW_List" position="432 31 132 328" name="TopicsList" align="Right VStretch">
         </Widget>
 
         <!-- The Goodbye button -->
-        <Widget type="Button" skin="MW_Button" position="432 387 132 23" name="ByeButton">
+        <Widget type="Button" skin="MW_Button" position="432 366 132 23" name="ByeButton" align="Right Bottom">
             <Property key="Caption" value="Goodbye"/>
         </Widget>
     </Widget>

files/mygui/openmw_windows.skin.xml

@@ -294,7 +294,7 @@
         <Property key="TextAlign" value = "ALIGN_CENTER" />
         <Property key="TextColour" value = "0.8 0.8 0.8" />
 
-        <Child type="Widget" skin="DialogBG" offset = "4 4 248 46" align = "ALIGN_STRETCH" name = "Client"/>
+        <Child type="Widget" skin="BlackBG" offset = "4 4 248 46" align = "ALIGN_STRETCH" name = "Client"/>
 
         <!-- Outer borders -->
         <Child type="Widget" skin="DB_T" offset="4 0 248 4" align="ALIGN_TOP ALIGN_HSTRETCH" name="Border">

files/settings-default.cfg

@@ -0,0 +1,43 @@
+[HUD]
+
+# FPS counter
+# 0: not visible
+# 1: basic FPS display
+# 2: advanced FPS display (batches, triangles)
+fps = 0
+
+[Objects]
+
+shaders = true
+
+# Max. number of lights that affect objects. Setting to 1 will only reflect sunlight
+# Note: has no effect when shaders are turned off
+num lights = 8
+
+# Use static geometry for static objects. Improves rendering speed.
+use static geometry = true
+
+[Viewing distance]
+
+# Limit the rendering distance of small objects
+limit small object distance = false
+
+# Size below which an object is considered as small
+small object size = 250
+
+# Rendering distance for small objects
+small object distance = 3500
+
+# Max viewing distance at clear weather conditions
+max viewing distance = 5600
+
+# Distance at which fog starts (proportional to viewing distance)
+fog start factor = 0.5
+
+# Distance at which fog ends (proportional to viewing distance)
+fog end factor = 1.0
+
+[Terrain]
+
+# Max. number of lights that affect the terrain. Setting to 1 will only reflect sunlight
+num lights = 8

files/water/Example_Fresnel.cg

@@ -0,0 +1,116 @@
+// Vertex program for fresnel reflections / refractions
+void main_vp(
+		float4 pos			: POSITION,
+		float4 normal		: NORMAL,
+		float2 tex			: TEXCOORD0,
+		
+		out float4 oPos		: POSITION,
+		out float3 noiseCoord : TEXCOORD0,
+		out float4 projectionCoord : TEXCOORD1,
+		out float3 oEyeDir : TEXCOORD2, 
+		out float3 oNormal : TEXCOORD3, 
+
+		uniform float4x4 worldViewProjMatrix,
+		uniform float3 eyePosition, // object space
+		uniform float timeVal,
+		uniform float scale,  // the amount to scale the noise texture by
+		uniform float scroll, // the amount by which to scroll the noise
+		uniform float noise  // the noise perturb as a factor of the  time
+		)
+{
+	oPos = mul(worldViewProjMatrix, pos);
+	// Projective texture coordinates, adjust for mapping
+	float4x4 scalemat = float4x4(0.5,   0,   0, 0.5, 
+	                               0,-0.5,   0, 0.5,
+								   0,   0, 0.5, 0.5,
+								   0,   0,   0,   1);
+	projectionCoord = mul(scalemat, oPos);
+	// Noise map coords
+	noiseCoord.xy = (tex + (timeVal * scroll)) * scale;
+	noiseCoord.z = noise * timeVal;
+
+	oEyeDir = normalize(pos.xyz - eyePosition); 
+	oNormal = normal.rgb; 
+	
+}
+
+// Fragment program for distorting a texture using a 3D noise texture
+void main_fp(
+		float3 noiseCoord			: TEXCOORD0,
+		float4 projectionCoord		: TEXCOORD1,
+		float3 eyeDir				: TEXCOORD2,
+		float3 normal				: TEXCOORD3,
+		
+		out float4 col		: COLOR,
+		
+		uniform float4 tintColour,
+		uniform float noiseScale, 
+		uniform float fresnelBias,
+		uniform float fresnelScale,
+		uniform float fresnelPower,
+		uniform sampler2D waterTex : register(s0),
+		uniform sampler2D noiseMap : register(s1),
+		uniform sampler2D reflectMap : register(s2),
+		uniform sampler2D refractMap : register(s3)
+		)
+{
+	// Do the tex projection manually so we can distort _after_
+	float2 final = projectionCoord.xy / projectionCoord.w;
+
+	// Noise
+	float3 noiseNormal = (tex2D(noiseMap, (noiseCoord.xy / 5)).rgb - 0.5).rbg * noiseScale;
+	final += noiseNormal.xz;
+
+	// Fresnel
+	//normal = normalize(normal + noiseNormal.xz);
+	float fresnel = fresnelBias + fresnelScale * pow(1 + dot(eyeDir, normal), fresnelPower);
+
+	// Reflection / refraction
+	float4 reflectionColour = tex2D(reflectMap, final);
+	float4 refractionColour = tex2D(refractMap, final) + tintColour;
+
+	// Final colour
+	col = lerp(refractionColour, reflectionColour, fresnel) * tex2D(waterTex, noiseNormal) / 3 ;
+
+
+}
+
+
+// Old version to match ATI PS 1.3 implementation
+void main_vp_old(
+		float4 pos			: POSITION,
+		float4 normal		: NORMAL,
+		float2 tex			: TEXCOORD0,
+		
+		out float4 oPos		: POSITION,
+		out float fresnel   : COLOR,
+		out float3 noiseCoord : TEXCOORD0,
+		out float4 projectionCoord : TEXCOORD1,
+
+		uniform float4x4 worldViewProjMatrix,
+		uniform float3 eyePosition, // object space
+		uniform float fresnelBias,
+		uniform float fresnelScale,
+		uniform float fresnelPower,
+		uniform float timeVal,
+		uniform float scale,  // the amount to scale the noise texture by
+		uniform float scroll, // the amount by which to scroll the noise
+		uniform float noise  // the noise perturb as a factor of the  time
+		)
+{
+	oPos = mul(worldViewProjMatrix, pos);
+	// Projective texture coordinates, adjust for mapping
+	float4x4 scalemat = float4x4(0.5,   0,   0, 0.5, 
+	                               0,-0.5,   0, 0.5,
+								   0,   0, 0.5, 0.5,
+								   0,   0,   0,   1);
+	projectionCoord = mul(scalemat, oPos);
+	// Noise map coords
+	noiseCoord.xy = (tex + (timeVal * scroll)) * scale;
+	noiseCoord.z = noise * timeVal;
+
+	// calc fresnel factor (reflection coefficient)
+	float3 eyeDir = normalize(pos.xyz - eyePosition);
+	fresnel = fresnelBias + fresnelScale * pow(1 + dot(eyeDir, normal), fresnelPower);
+	
+}

files/water/Example_FresnelPS.asm

@@ -0,0 +1,72 @@
+ps.1.4
+  // conversion from Cg generated ARB_fragment_program to ps.1.4 by NFZ
+  // command line args: -profile arbfp1 -entry main_fp
+  // program main_fp
+  // c0 : distortionRange
+  // c1 : tintColour
+  // testure 0 : noiseMap
+  // texture 1 : reflectMap
+  // texture 2 : refractMap
+  // v0.x : fresnel 
+  // t0.xyz : noiseCoord
+  // t1.xyw : projectionCoord 
+
+def c2, 2, 1, 0, 0
+
+  // Cg:	distort.x = tex3D(noiseMap, noiseCoord).x;
+  // arbfp1:	TEX R0.x, fragment.texcoord[0], texture[0], 3D;
+  // sample noise map using noiseCoord in TEX unit 0 
+
+texld r0, t0.xyz
+
+  // get projected texture coordinates from TEX coord 1
+  // will be used in phase 2
+
+texcrd r1.xy, t1_dw.xyw
+mov r1.z, c2.y
+
+  // Cg:	distort.y = tex3D(noiseMap, noiseCoord + yoffset).x;
+  // arbfp1:	ADD R1.xyz, fragment.texcoord[0], c1;
+  // arbfp1:	TEX R1.x, R1, texture[0], 3D;
+  // arbfp1:	MOV R0.y, R1.x;
+
+  // Cg:	distort = (distort * 2 - 1) * distortionRange;
+  // arbfp1:	MAD R0.xy, R0, c0.x, -c0.y;
+  // arbfp1:	MUL R0.xy, R0, u0.x;
+  // (distort * 2 - 1) same as 2*(distort -.5) so use _bx2
+
+
+  // Cg:	final = projectionCoord.xy / projectionCoord.w;
+  // Cg:	final += distort;
+  // arbfp1:	RCP R0.w, fragment.texcoord[1].w;
+  // arbfp1:	MAD R0.xy, fragment.texcoord[1], R0.w, R0;
+  // 	final = (distort *  projectionCoord.w) + projectionCoord.xy
+  // for ps.1.4 have to re-arrange things a bit to perturb projected texture coordinates
+
+mad r0.xyz, r0_bx2, c0.x, r1
+
+phase
+
+  // do dependant texture reads
+  // Cg:	reflectionColour = tex2D(reflectMap, final);
+  // arbfp1:	TEX R0, R0, texture[1], 2D;
+  // sampe reflectMap using dependant read : texunit 1 
+
+texld r1, r0.xyz
+
+  // Cg:	refractionColour = tex2D(refractMap, final) + tintColour;
+  // arbfp1:	TEX R1, R0, texture[2], 2D;
+  // sample refractMap : texunit 2 
+
+texld r2, r0.xyz
+
+  // adding tintColour that is in global c1
+  // arbfp1:	ADD R1, R1, u1;
+
+add r2, r2, c1
+
+  // Cg:	col = lerp(refractionColour, reflectionColour, fresnel);
+  // arbfp1:	ADD R0, R0, -R1;
+  // arbfp1:	MAD result.color, fragment.color.primary.x, R0, R1;
+
+lrp r0, v0.x, r1, r2

files/water/Examples-Water.material

@@ -0,0 +1,149 @@
+
+vertex_program Water/GlassVP cg
+{
+	source GlassVP.cg
+	entry_point glass_vp
+	profiles vs_1_1 arbvp1
+
+	default_params 
+	{
+		param_named_auto worldViewProj worldviewproj_matrix
+	}
+}
+
+
+fragment_program Water/GlassFP cg
+{
+	source GlassFP.cg
+	entry_point main_ps
+	profiles ps_2_0 arbfp1
+}
+
+material Water/Compositor
+{
+	technique
+	{
+		pass
+		{
+			depth_check off
+			vertex_program_ref Water/GlassVP
+			{
+				param_named_auto timeVal time 0.25
+				param_named scale float 0.1
+			}
+
+			fragment_program_ref Water/GlassFP
+			{
+				param_named tintColour float4 0 0.35 0.35 1
+			}
+
+			texture_unit RT
+			{
+			        tex_coord_set 0
+				tex_address_mode clamp
+				filtering linear linear linear
+			}
+
+			texture_unit
+			{
+				texture WaterNormal1.tga 2d
+                		tex_coord_set 1
+				//tex_address_mode clamp
+				filtering linear linear linear
+			}
+			texture_unit
+			{
+				texture caustic_0.png 2d
+                		tex_coord_set 2
+				//tex_address_mode clamp
+				filtering linear linear linear
+			}
+		}
+	}
+}
+vertex_program Water/RefractReflectVP cg
+{
+	source Example_Fresnel.cg
+	entry_point main_vp
+	profiles vs_1_1 arbvp1
+}
+vertex_program Water/RefractReflectVPold cg
+{
+	source Example_Fresnel.cg
+	entry_point main_vp_old
+	profiles vs_1_1 arbvp1
+}
+
+fragment_program Water/RefractReflectFP cg
+{
+	source Example_Fresnel.cg
+	entry_point main_fp
+	// sorry, ps_1_1 and fp20 can't do this
+	profiles ps_2_0 arbfp1
+}
+
+fragment_program Water/RefractReflectPS asm
+{
+	source Example_FresnelPS.asm
+	// sorry, only for ps_1_4 :)
+	syntax ps_1_4
+
+}
+material Examples/Water0
+{
+
+	technique
+	{
+		pass 
+		{
+			//
+       			
+			depth_write off
+			vertex_program_ref Water/RefractReflectVP
+			{
+				param_named_auto worldViewProjMatrix worldviewproj_matrix
+				param_named_auto eyePosition camera_position_object_space
+				param_named_auto timeVal time 0.15
+				param_named scroll float 1  
+				param_named scale float 1 
+				param_named noise float 1 
+				// scroll and noisePos will need updating per frame
+			}
+			fragment_program_ref Water/RefractReflectFP
+			{
+				param_named fresnelBias float -0.1 
+				param_named fresnelScale float 0.8 
+				param_named fresnelPower float 20  
+				param_named tintColour float4 1 1 1 1
+				param_named noiseScale float 0.05 
+			}
+			// Water
+			scene_blend alpha_blend
+			texture_unit
+			{
+				
+				// Water texture
+				texture Water02.jpg
+				// min / mag filtering, no mip
+				filtering linear linear none
+				alpha_op_ex source1 src_manual src_current 0.9
+				
+			}
+			// Noise
+			texture_unit
+			{
+				alpha_op_ex source1 src_manual src_current 0.9
+				// Perlin noise volume
+				texture waves2.dds
+				// min / mag filtering, no mip
+				filtering linear linear none
+			}
+			
+		
+		}
+		
+			
+	}
+	
+}
+

files/water/GlassFP.cg

@@ -0,0 +1,15 @@
+sampler RT : register(s0);
+sampler NormalMap : register(s1);
+sampler CausticMap : register(s2);
+
+float4 main_ps(float2 iTexCoord : TEXCOORD0,
+       	       float3 noiseCoord : TEXCOORD1,
+       	       uniform float4 tintColour) : COLOR
+{
+	float4 normal = tex2D(NormalMap, noiseCoord);
+	
+
+	return tex2D(RT, iTexCoord + normal.xy * 0.05) +
+	       (tex2D(CausticMap, noiseCoord) / 5) +
+	       tintColour ;
+}

files/water/GlassVP.cg

@@ -0,0 +1,24 @@
+void glass_vp
+(
+    in float4 inPos : POSITION,
+
+    out float4 pos : POSITION,
+    out float2 uv0 : TEXCOORD0,
+    out float4 noiseCoord : TEXCOORD1,
+
+    uniform float4x4 worldViewProj,
+    uniform float timeVal,
+    uniform float scale
+)
+{
+    // Use standardise transform, so work accord with render system specific (RS depth, requires texture flipping, etc)
+    pos = mul(worldViewProj, inPos);
+
+    // The input positions adjusted by texel offsets, so clean up inaccuracies
+    inPos.xy = sign(inPos.xy);
+
+    // Convert to image-space
+    uv0 = (float2(inPos.x, -inPos.y) + 1.0f) * 0.5f;
+    noiseCoord = (pos + timeVal) * scale;
+}
+

files/water/water.compositor

@@ -0,0 +1,21 @@
+compositor Water
+{
+    technique
+    {
+        texture rt0 target_width target_height PF_R8G8B8
+
+        target rt0 { input previous }
+
+        target_output
+        {
+            // Start with clear output
+            input none
+
+            pass render_quad
+            {
+                material Water/Compositor
+                input 0 rt0
+            }
+        }
+    }
+}			

libs/openengine/bullet/physic.cpp

@@ -154,7 +154,8 @@ namespace Physic
 
 
 
-    PhysicEngine::PhysicEngine(BulletShapeLoader* shapeLoader)
+    PhysicEngine::PhysicEngine(BulletShapeLoader* shapeLoader) :
+        mDebugActive(0)
     {
         // Set up the collision configuration and dispatcher
         collisionConfiguration = new btDefaultCollisionConfiguration();
@@ -206,6 +207,13 @@ namespace Physic
             createDebugRendering();
         }
         mDebugDrawer->setDebugMode(mode);
+        mDebugActive = mode;
+    }
+
+    bool  PhysicEngine::toggleDebugRendering()
+    {
+        setDebugRenderingMode(!mDebugActive);
+        return mDebugActive;
     }
 
     PhysicEngine::~PhysicEngine()
@@ -475,4 +483,35 @@ namespace Physic
 
         return std::pair<std::string,float>(name,d);
     }
+
+    std::vector< std::pair<float, std::string> > PhysicEngine::rayTest2(btVector3& from, btVector3& to)
+    {
+        MyRayResultCallback resultCallback1;
+        resultCallback1.m_collisionFilterMask = COL_WORLD;
+        dynamicsWorld->rayTest(from, to, resultCallback1);
+        std::vector< std::pair<float, btCollisionObject*> > results = resultCallback1.results;
+
+        MyRayResultCallback resultCallback2;
+        resultCallback2.m_collisionFilterMask = COL_ACTOR_INTERNAL|COL_ACTOR_EXTERNAL;
+        dynamicsWorld->rayTest(from, to, resultCallback2);
+        std::vector< std::pair<float, btCollisionObject*> > actorResults = resultCallback2.results;
+
+        std::vector< std::pair<float, std::string> > results2;
+
+        for (std::vector< std::pair<float, btCollisionObject*> >::iterator it=results.begin();
+            it != results.end(); ++it)
+        {
+            results2.push_back( std::make_pair( (*it).first, static_cast<RigidBody&>(*(*it).second).mName ) );
+        }
+
+        for (std::vector< std::pair<float, btCollisionObject*> >::iterator it=actorResults.begin();
+            it != actorResults.end(); ++it)
+        {
+            results2.push_back( std::make_pair( (*it).first, static_cast<PairCachingGhostObject&>(*(*it).second).mName ) );
+        }
+
+        std::sort(results2.begin(), results2.end(), MyRayResultCallback::cmp);
+
+        return results2;
+    }
 }};

libs/openengine/bullet/physic.hpp

@@ -211,11 +211,18 @@ namespace Physic
          */
         void setDebugRenderingMode(int mode);
 
+        bool toggleDebugRendering();
+
         /**
          * Return the closest object hit by a ray. If there are no objects, it will return ("",-1).
          */
         std::pair<std::string,float> rayTest(btVector3& from,btVector3& to);
 
+        /**
+         * Return all objects hit by a ray.
+         */
+        std::vector< std::pair<float, std::string> > rayTest2(btVector3& from, btVector3& to);
+
         //event list of non player object
         std::list<PhysicEvent> NPEventList;
 
@@ -242,6 +249,26 @@ namespace Physic
         //debug rendering
         BtOgre::DebugDrawer* mDebugDrawer;
         bool isDebugCreated;
+        bool mDebugActive;
+    };
+
+
+    struct MyRayResultCallback : public btCollisionWorld::RayResultCallback
+    {
+        virtual btScalar addSingleResult( btCollisionWorld::LocalRayResult& rayResult, bool bNormalInWorldSpace)
+        {
+            results.push_back( std::make_pair(rayResult.m_hitFraction, rayResult.m_collisionObject) );
+            return rayResult.m_hitFraction;
+        }
+
+        static bool cmp( const std::pair<float, std::string>& i, const std::pair<float, std::string>& j )
+        {
+            if( i.first > j.first ) return false;
+            if( j.first > i.first ) return true;
+            return false;
+        }
+
+        std::vector < std::pair<float, btCollisionObject*> > results;
     };
 
 }}