moving stuff from MWWorld::World to MWWorld::Scene but receiving segfault signals

apps/openmw/CMakeLists.txt

@@ -16,6 +16,7 @@ set(GAME_HEADER
 source_group(game FILES ${GAME} ${GAME_HEADER})
 
 set(GAMEREND
+    mwrender/render_manager.cpp
     mwrender/mwscene.cpp
     mwrender/cellimp.cpp
     mwrender/interior.cpp
@@ -24,6 +25,7 @@ set(GAMEREND
     mwrender/player.cpp
     )
 set(GAMEREND_HEADER
+    mwrender/render_manager.hpp
     mwrender/cell.hpp
     mwrender/cellimp.hpp
     mwrender/mwscene.hpp
@@ -137,6 +139,7 @@ source_group(apps\\openmw\\mwsound FILES ${GAMESOUND} ${GAMESOUND_HEADER})
 
 set(GAMEWORLD
     mwworld/world.cpp
+    mwworld/scene.cpp
     mwworld/globals.cpp
     mwworld/class.cpp
     mwworld/actionteleport.cpp
@@ -149,7 +152,7 @@ set(GAMEWORLD
 set(GAMEWORLD_HEADER
     mwworld/refdata.hpp
     mwworld/world.hpp
-    mwworld/ptr.hpp
+    mwworld/scene.hpp
     mwworld/environment.hpp
     mwworld/globals.hpp
     mwworld/class.hpp

apps/openmw/mwrender/player.hpp

@@ -22,7 +22,7 @@ namespace MWRender
 
                 Ogre::Camera *getCamera() { return mCamera; }
 
-                std::string getHandle() const { return mHandle; }
+                std::string getHandle() const { std::cout << "mHandle " << mHandle << std::endl; return mHandle; }
     };
 }
 

apps/openmw/mwrender/render_manager.cpp

@@ -0,0 +1 @@
+#include "render_manager.hpp"

apps/openmw/mwrender/render_manager.hpp

@@ -0,0 +1,9 @@
+#ifndef _GAME_RENDER_MANAGER_H
+#define _GAME_RENDER_MANAGER_H
+
+namespace MWRender
+{
+
+}
+
+#endif

apps/openmw/mwworld/physikssystem.cpp

@@ -0,0 +1,7 @@
+#include "physikssystem.hpp"
+
+
+namespace MWWorld
+{
+
+}

apps/openmw/mwworld/physikssystem.hpp

@@ -0,0 +1,4 @@
+#ifndef GAME_MWWORLD_PHYSIKSSYSTEM_H
+#define GAME_MWWORLD_PHYSIKSSYSTEM_H
+
+#endif

apps/openmw/mwworld/player.cpp

@@ -17,6 +17,9 @@ namespace MWWorld
         mMale = !(player->flags & ESM::NPC::Female);
         mRace = player->race;
         mPlayer.ref.pos.pos[0] = mPlayer.ref.pos.pos[1] = mPlayer.ref.pos.pos[2] = 0;
+        std::cout << "mData.setHandle" << std::endl;
+        std::cout << renderer->getHandle();
+        std::cout << "mData end" << std::endl;
         mPlayer.mData.setHandle (renderer->getHandle());
         mClass = new ESM::Class (*world.getStore().classes.find (player->cls));
     }

apps/openmw/mwworld/scene.cpp

@@ -0,0 +1,539 @@
+#include "scene.hpp"
+
+#include "world.hpp"
+#include "ptr.hpp"
+#include "environment.hpp"
+#include "class.hpp"
+#include "player.hpp"
+
+#include "refdata.hpp"
+#include "globals.hpp"
+#include "doingphysics.hpp"
+#include "cellfunctors.hpp"
+#include "environment.hpp"
+
+#include <cmath>
+#include <iostream>
+
+#include <components/bsa/bsa_archive.hpp>
+#include <components/files/collections.hpp>
+
+#include "../mwrender/sky.hpp"
+#include "../mwrender/interior.hpp"
+#include "../mwrender/exterior.hpp"
+
+#include "../mwmechanics/mechanicsmanager.hpp"
+
+#include "../mwsound/soundmanager.hpp"
+
+#include "ptr.hpp"
+#include "environment.hpp"
+#include "class.hpp"
+#include "player.hpp"
+
+#include "refdata.hpp"
+#include "globals.hpp"
+#include "doingphysics.hpp"
+#include "cellfunctors.hpp"
+
+namespace {
+
+    template<typename T>
+    ESMS::LiveCellRef<T, MWWorld::RefData> *searchViaHandle (const std::string& handle,
+        ESMS::CellRefList<T, MWWorld::RefData>& refList)
+    {
+        typedef typename ESMS::CellRefList<T, MWWorld::RefData>::List::iterator iterator;
+
+        for (iterator iter (refList.list.begin()); iter!=refList.list.end(); ++iter)
+        {
+            if (iter->mData.getHandle()==handle)
+            {
+                return &*iter;
+            }
+        }
+
+        return 0;
+    }
+}
+
+
+namespace MWWorld
+{
+
+    Scene::Scene(Environment& environment, World *world, MWRender::MWScene scene) :
+        mEnvironment(environment), mWorld(world), mScene(scene)
+    {
+    }
+    
+    Ptr Scene::getPtr (const std::string& name, Ptr::CellStore& cell)
+    {
+        if (ESMS::LiveCellRef<ESM::Activator, RefData> *ref = cell.activators.find (name))
+            return Ptr (ref, &cell);
+
+        if (ESMS::LiveCellRef<ESM::Potion, RefData> *ref = cell.potions.find (name))
+            return Ptr (ref, &cell);
+
+        if (ESMS::LiveCellRef<ESM::Apparatus, RefData> *ref = cell.appas.find (name))
+            return Ptr (ref, &cell);
+
+        if (ESMS::LiveCellRef<ESM::Armor, RefData> *ref = cell.armors.find (name))
+            return Ptr (ref, &cell);
+
+        if (ESMS::LiveCellRef<ESM::Book, RefData> *ref = cell.books.find (name))
+            return Ptr (ref, &cell);
+
+        if (ESMS::LiveCellRef<ESM::Clothing, RefData> *ref = cell.clothes.find (name))
+            return Ptr (ref, &cell);
+
+        if (ESMS::LiveCellRef<ESM::Container, RefData> *ref = cell.containers.find (name))
+            return Ptr (ref, &cell);
+
+        if (ESMS::LiveCellRef<ESM::Creature, RefData> *ref = cell.creatures.find (name))
+            return Ptr (ref, &cell);
+
+        if (ESMS::LiveCellRef<ESM::Door, RefData> *ref = cell.doors.find (name))
+            return Ptr (ref, &cell);
+
+        if (ESMS::LiveCellRef<ESM::Ingredient, RefData> *ref = cell.ingreds.find (name))
+            return Ptr (ref, &cell);
+
+        if (ESMS::LiveCellRef<ESM::CreatureLevList, RefData> *ref = cell.creatureLists.find (name))
+            return Ptr (ref, &cell);
+
+        if (ESMS::LiveCellRef<ESM::ItemLevList, RefData> *ref = cell.itemLists.find (name))
+            return Ptr (ref, &cell);
+
+        if (ESMS::LiveCellRef<ESM::Light, RefData> *ref = cell.lights.find (name))
+            return Ptr (ref, &cell);
+
+        if (ESMS::LiveCellRef<ESM::Tool, RefData> *ref = cell.lockpicks.find (name))
+            return Ptr (ref, &cell);
+
+        if (ESMS::LiveCellRef<ESM::Miscellaneous, RefData> *ref = cell.miscItems.find (name))
+            return Ptr (ref, &cell);
+
+        if (ESMS::LiveCellRef<ESM::NPC, RefData> *ref = cell.npcs.find (name))
+            return Ptr (ref, &cell);
+
+        if (ESMS::LiveCellRef<ESM::Probe, RefData> *ref = cell.probes.find (name))
+            return Ptr (ref, &cell);
+
+        if (ESMS::LiveCellRef<ESM::Repair, RefData> *ref = cell.repairs.find (name))
+            return Ptr (ref, &cell);
+
+        if (ESMS::LiveCellRef<ESM::Static, RefData> *ref = cell.statics.find (name))
+            return Ptr (ref, &cell);
+
+        if (ESMS::LiveCellRef<ESM::Weapon, RefData> *ref = cell.weapons.find (name))
+            return Ptr (ref, &cell);
+
+        return Ptr();
+    }
+    
+    
+
+    Ptr Scene::getPtrViaHandle (const std::string& handle, Ptr::CellStore& cell)
+    {
+        if (ESMS::LiveCellRef<ESM::Activator, RefData> *ref =
+            searchViaHandle (handle, cell.activators))
+            return Ptr (ref, &cell);
+
+        if (ESMS::LiveCellRef<ESM::Potion, RefData> *ref = searchViaHandle (handle, cell.potions))
+            return Ptr (ref, &cell);
+
+        if (ESMS::LiveCellRef<ESM::Apparatus, RefData> *ref = searchViaHandle (handle, cell.appas))
+            return Ptr (ref, &cell);
+
+        if (ESMS::LiveCellRef<ESM::Armor, RefData> *ref = searchViaHandle (handle, cell.armors))
+            return Ptr (ref, &cell);
+
+        if (ESMS::LiveCellRef<ESM::Book, RefData> *ref = searchViaHandle (handle, cell.books))
+            return Ptr (ref, &cell);
+
+        if (ESMS::LiveCellRef<ESM::Clothing, RefData> *ref = searchViaHandle (handle, cell.clothes))
+            return Ptr (ref, &cell);
+
+        if (ESMS::LiveCellRef<ESM::Container, RefData> *ref =
+            searchViaHandle (handle, cell.containers))
+            return Ptr (ref, &cell);
+
+        if (ESMS::LiveCellRef<ESM::Creature, RefData> *ref =
+            searchViaHandle (handle, cell.creatures))
+            return Ptr (ref, &cell);
+
+        if (ESMS::LiveCellRef<ESM::Door, RefData> *ref = searchViaHandle (handle, cell.doors))
+            return Ptr (ref, &cell);
+
+        if (ESMS::LiveCellRef<ESM::Ingredient, RefData> *ref =
+            searchViaHandle (handle, cell.ingreds))
+            return Ptr (ref, &cell);
+
+        if (ESMS::LiveCellRef<ESM::Light, RefData> *ref = searchViaHandle (handle, cell.lights))
+            return Ptr (ref, &cell);
+
+        if (ESMS::LiveCellRef<ESM::Tool, RefData> *ref = searchViaHandle (handle, cell.lockpicks))
+            return Ptr (ref, &cell);
+
+        if (ESMS::LiveCellRef<ESM::Miscellaneous, RefData> *ref = searchViaHandle (handle, cell.miscItems))
+            return Ptr (ref, &cell);
+
+        if (ESMS::LiveCellRef<ESM::NPC, RefData> *ref = searchViaHandle (handle, cell.npcs))
+            return Ptr (ref, &cell);
+
+        if (ESMS::LiveCellRef<ESM::Probe, RefData> *ref = searchViaHandle (handle, cell.probes))
+            return Ptr (ref, &cell);
+
+        if (ESMS::LiveCellRef<ESM::Repair, RefData> *ref = searchViaHandle (handle, cell.repairs))
+            return Ptr (ref, &cell);
+
+        if (ESMS::LiveCellRef<ESM::Static, RefData> *ref = searchViaHandle (handle, cell.statics))
+            return Ptr (ref, &cell);
+
+        if (ESMS::LiveCellRef<ESM::Weapon, RefData> *ref = searchViaHandle (handle, cell.weapons))
+            return Ptr (ref, &cell);
+
+        return Ptr();
+    }
+
+    MWRender::CellRender *Scene::searchRender (Ptr::CellStore *store)
+    {
+        CellRenderCollection::iterator iter = mActiveCells.find (store);
+
+        if (iter!=mActiveCells.end())
+        {
+            return iter->second;
+        }
+
+        return 0;
+    }
+    
+    void Scene::unloadCell (CellRenderCollection::iterator iter)
+    {
+        ListHandles functor;
+        iter->first->forEach<ListHandles>(functor);
+
+        { // silence annoying g++ warning
+            for (std::vector<std::string>::const_iterator iter (functor.mHandles.begin());
+                iter!=functor.mHandles.end(); ++iter)
+            {
+                mScene.removeObject (*iter); // FIXME
+            }
+        }
+
+        mEnvironment.mMechanicsManager->dropActors (iter->first);
+        mEnvironment.mSoundManager->stopSound (iter->first);
+        delete iter->second;
+        mActiveCells.erase (iter);
+    }
+    
+    void Scene::loadCell (Ptr::CellStore *cell, MWRender::CellRender *render)
+    {
+        // register local scripts
+        mWorld->insertInteriorScripts (*cell); // FIXME
+
+        // This connects the cell data with the rendering scene.
+        std::pair<CellRenderCollection::iterator, bool> result =
+            mActiveCells.insert (std::make_pair (cell, render));
+
+        if (result.second)
+        {
+            // Load the cell and insert it into the renderer
+            result.first->second->show();
+        }
+        
+    }
+    
+    void Scene::changeCell (int X, int Y, const ESM::Position& position, bool adjustPlayerPos)
+    {
+        SuppressDoingPhysics scopeGuard;
+
+        // remove active
+        mEnvironment.mMechanicsManager->removeActor (mWorld->getPlayer().getPlayer());
+
+        CellRenderCollection::iterator active = mActiveCells.begin();
+
+        while (active!=mActiveCells.end())
+        {
+            if (!(active->first->cell->data.flags & ESM::Cell::Interior))
+            {
+                if (std::abs (X-active->first->cell->data.gridX)<=1 &&
+                    std::abs (Y-active->first->cell->data.gridY)<=1)
+                {
+                    // keep cells within the new 3x3 grid
+                    ++active;
+                    continue;
+                }
+            }
+
+            unloadCell (active++);
+        }
+
+        // Load cells
+        for (int x=X-1; x<=X+1; ++x)
+            for (int y=Y-1; y<=Y+1; ++y)
+            {
+                CellRenderCollection::iterator iter = mActiveCells.begin();
+
+                while (iter!=mActiveCells.end())
+                {
+                    assert (!(iter->first->cell->data.flags & ESM::Cell::Interior));
+
+                    if (x==iter->first->cell->data.gridX &&
+                        y==iter->first->cell->data.gridY)
+                        break;
+
+                    ++iter;
+                }
+
+                if (iter==mActiveCells.end())
+                {
+                    mExteriors[std::make_pair (x, y)].loadExt (x, y, mWorld->getStore(), mWorld->getEsmReader());
+                    Ptr::CellStore *cell = &mExteriors[std::make_pair (x, y)];
+
+                    loadCell (cell, new MWRender::ExteriorCellRender (*cell, mEnvironment, mScene));
+                }
+            }
+
+        // find current cell
+        CellRenderCollection::iterator iter = mActiveCells.begin();
+
+        while (iter!=mActiveCells.end())
+        {
+            assert (!(iter->first->cell->data.flags & ESM::Cell::Interior));
+
+            if (X==iter->first->cell->data.gridX &&
+                Y==iter->first->cell->data.gridY)
+                break;
+
+            ++iter;
+        }
+
+        assert (iter!=mActiveCells.end());
+
+        mCurrentCell = iter->first;
+
+        // adjust player
+        playerCellChange (&mExteriors[std::make_pair (X, Y)], position, adjustPlayerPos);
+
+        // Sky system
+        mWorld->adjustSky(); // FIXME
+
+        mCellChanged = true;
+        
+    }
+    
+    Ptr Scene::getPtr (const std::string& name, bool activeOnly)
+    {
+        // the player is always in an active cell.
+        if (name=="player")
+        {
+            return mWorld->getPlayer().getPlayer();
+        }
+
+        // active cells
+        for (CellRenderCollection::iterator iter (mActiveCells.begin());
+            iter!=mActiveCells.end(); ++iter)
+        {
+            Ptr ptr = getPtr (name, *iter->first);
+
+            if (!ptr.isEmpty())
+                return ptr;
+        }
+
+        if (!activeOnly)
+        {
+            // TODO: inactive cells
+        }
+
+        throw std::runtime_error ("unknown ID: " + name);
+        
+    }
+    
+    Ptr Scene::getPtrViaHandle (const std::string& handle)
+    {
+        if (mWorld->getPlayer().getPlayer().getRefData().getHandle()==handle)
+            return mWorld->getPlayer().getPlayer();
+
+        for (CellRenderCollection::iterator iter (mActiveCells.begin());
+            iter!=mActiveCells.end(); ++iter)
+        {
+            Ptr ptr = getPtrViaHandle (handle, *iter->first);
+
+            if (!ptr.isEmpty())
+                return ptr;
+        }
+
+        throw std::runtime_error ("unknown Ogre handle: " + handle);
+        
+    }
+    
+    void Scene::playerCellChange (Ptr::CellStore *cell, const ESM::Position& position,
+        bool adjustPlayerPos)
+    {
+        if (adjustPlayerPos)
+            mWorld->getPlayer().setPos (position.pos[0], position.pos[1], position.pos[2], false);
+
+        mWorld->getPlayer().setCell (cell);
+        // TODO orientation
+        mEnvironment.mMechanicsManager->addActor (mWorld->getPlayer().getPlayer());
+        mEnvironment.mMechanicsManager->watchActor (mWorld->getPlayer().getPlayer());
+    
+    }
+    
+    void Scene::enable (Ptr reference)
+    {
+        if (!reference.getRefData().isEnabled())
+        {
+            reference.getRefData().enable();
+
+            if (MWRender::CellRender *render = searchRender (reference.getCell()))
+            {
+                render->enable (reference.getRefData().getHandle());
+
+                if (mActiveCells.find (reference.getCell())!=mActiveCells.end())
+                {
+                    Class::get (reference).enable (reference, mEnvironment); //FIXME
+                }
+            }
+        }
+    }
+    
+    void Scene::disable (Ptr reference)
+    {
+        if (reference.getRefData().isEnabled())
+        {
+            reference.getRefData().disable();
+
+            if (MWRender::CellRender *render = searchRender (reference.getCell()))
+            {
+                render->disable (reference.getRefData().getHandle());
+
+                if (mActiveCells.find (reference.getCell())!=mActiveCells.end())
+                {
+                    Class::get (reference).disable (reference, mEnvironment);
+                    mEnvironment.mSoundManager->stopSound3D (reference);
+                }
+            }
+        }
+    }
+    
+    void Scene::changeToInteriorCell (const std::string& cellName, const ESM::Position& position)
+    {
+        SuppressDoingPhysics scopeGuard;
+
+        // remove active
+        CellRenderCollection::iterator active = mActiveCells.begin();
+
+        while (active!=mActiveCells.end())
+        {
+            unloadCell (active++);
+        }
+
+        // Load cell.
+        mInteriors[cellName].loadInt (cellName, mWorld->getStore(), mWorld->getEsmReader());
+        Ptr::CellStore *cell = &mInteriors[cellName];
+
+        loadCell (cell, new MWRender::InteriorCellRender (*cell, mEnvironment, mScene));
+
+        // adjust player
+        mCurrentCell = cell;
+        playerCellChange (cell, position, true); // FIXME
+
+        // Sky system
+        mWorld->adjustSky(); // FIXME
+
+        mCellChanged = true;
+        //currentRegion->name = "";
+    }
+    
+    void Scene::changeToExteriorCell (const ESM::Position& position)
+    {
+        int x = 0;
+        int y = 0;
+
+        mWorld->positionToIndex (position.pos[0], position.pos[1], x, y);
+
+        changeCell (x, y, position, true);
+    }
+    
+    const ESM::Cell *Scene::getExterior (const std::string& cellName) const
+    {
+        // first try named cells
+        if (const ESM::Cell *cell = mWorld->getStore().cells.searchExtByName (cellName))
+            return cell;
+
+        // didn't work -> now check for regions
+        std::string cellName2 = ESMS::RecListT<ESM::Region>::toLower (cellName);
+
+        for (ESMS::RecListT<ESM::Region>::MapType::const_iterator iter (mWorld->getStore().regions.list.begin());
+            iter!=mWorld->getStore().regions.list.end(); ++iter)
+        {
+            if (ESMS::RecListT<ESM::Region>::toLower (iter->second.name)==cellName2)
+            {
+                if (const ESM::Cell *cell = mWorld->getStore().cells.searchExtByRegion (iter->first))
+                    return cell;
+
+                break;
+            }
+        }
+
+        return 0;
+    }
+    
+    void Scene::deleteObject (Ptr ptr)
+    {
+        if (ptr.getRefData().getCount()>0)
+        {
+            ptr.getRefData().setCount (0);
+
+            if (MWRender::CellRender *render = searchRender (ptr.getCell()))
+            {
+                if (mActiveCells.find (ptr.getCell())!=mActiveCells.end())
+                {
+                    Class::get (ptr).disable (ptr, mEnvironment);
+                    mEnvironment.mSoundManager->stopSound3D (ptr);
+
+                    if (!DoingPhysics::isDoingPhysics())
+                        mScene.removeObject (ptr.getRefData().getHandle());
+                }
+
+                render->deleteObject (ptr.getRefData().getHandle());
+                ptr.getRefData().setHandle ("");
+            }
+        }
+    }
+    
+    void Scene::moveObject (Ptr ptr, float x, float y, float z)
+    {
+        ptr.getCellRef().pos.pos[0] = x;
+        ptr.getCellRef().pos.pos[1] = y;
+        ptr.getCellRef().pos.pos[2] = z;
+
+        if (ptr==mWorld->getPlayer().getPlayer())
+        {
+            if (mCurrentCell)
+            {
+                if (!(mCurrentCell->cell->data.flags & ESM::Cell::Interior))
+                {
+                    // exterior -> adjust loaded cells
+                    int cellX = 0;
+                    int cellY = 0;
+
+                    mWorld->positionToIndex (x, y, cellX, cellY);
+
+                    if (mCurrentCell->cell->data.gridX!=cellX || mCurrentCell->cell->data.gridY!=cellY)
+                    {
+                        changeCell (cellX, cellY, mWorld->getPlayer().getPlayer().getCellRef().pos, false);
+                    }
+
+                }
+            }
+        }
+
+        mScene.moveObject (ptr.getRefData().getHandle(), Ogre::Vector3 (x, y, z),
+            !DoingPhysics::isDoingPhysics());
+
+        // TODO cell change for non-player ref
+    }
+
+}

apps/openmw/mwworld/scene.hpp

@@ -0,0 +1,65 @@
+#ifndef GAME_MWWORLD_SCENE_H
+#define GAME_MWWORLD_SCENE_H
+
+#include <components/esm_store/cell_store.hpp>
+#include "ptr.hpp"
+#include "environment.hpp"
+#include "../mwrender/mwscene.hpp"
+
+namespace Render
+{
+    class OgreRenderer;
+}
+
+namespace MWRender
+{
+    class SkyManager;
+    class CellRender;
+}
+
+namespace MWWorld
+{
+
+    class Scene
+    {
+        public:
+            Scene(Environment& environment, World *world, MWRender::MWScene scene);
+            
+        private:
+        
+            typedef std::map<Ptr::CellStore *, MWRender::CellRender *> CellRenderCollection;
+            
+            CellRenderCollection mActiveCells;
+            Ptr::CellStore *mCurrentCell; // the cell, the player is in
+            std::map<std::string, Ptr::CellStore> mInteriors;
+            std::map<std::pair<int, int>, Ptr::CellStore> mExteriors;
+            Environment& mEnvironment;
+            World *mWorld;
+            MWRender::MWScene mScene;
+            bool mCellChanged;
+            
+            Ptr getPtr (const std::string& name, Ptr::CellStore& cell);
+            Ptr getPtrViaHandle (const std::string& handle, Ptr::CellStore& cell);
+            
+        public:
+            
+            MWRender::CellRender *searchRender (Ptr::CellStore *store);
+            
+            void unloadCell (CellRenderCollection::iterator iter);
+            void loadCell (Ptr::CellStore *cell, MWRender::CellRender *render);
+            void changeCell (int X, int Y, const ESM::Position& position, bool adjustPlayerPos);
+            Ptr getPtr (const std::string& name, bool activeOnly);
+            Ptr getPtrViaHandle (const std::string& handle);
+            void playerCellChange (Ptr::CellStore *cell, const ESM::Position& position, bool adjustPlayerPos);
+            void enable (Ptr reference);
+            void disable (Ptr reference);
+            void changeToInteriorCell (const std::string& cellName, const ESM::Position& position);
+            void changeToExteriorCell (const ESM::Position& position);
+            const ESM::Cell *getExterior (const std::string& cellName) const;
+            void deleteObject (Ptr ptr);
+            void moveObject (Ptr ptr, float x, float y, float z);
+    };
+
+}
+
+#endif

apps/openmw/mwworld/world.cpp

@@ -1,4 +1,3 @@
-
 #include "world.hpp"
 
 #include <cmath>
@@ -466,6 +465,11 @@ namespace MWWorld
     {
         return mStore;
     }
+    
+    ESM::ESMReader& World::getEsmReader()
+    {
+        return mEsm;
+    }
 
     const World::ScriptList& World::getLocalScripts() const
     {
@@ -694,6 +698,7 @@ namespace MWWorld
 
     void World::changeToInteriorCell (const std::string& cellName, const ESM::Position& position)
     {
+        return mWorldScene->changeToInteriorCell(cellName, position);
         SuppressDoingPhysics scopeGuard;
 
         // remove active
@@ -904,3 +909,4 @@ namespace MWWorld
         return std::make_pair (stream.str(), created);
     }
 }
+

apps/openmw/mwworld/world.hpp

@@ -13,6 +13,7 @@
 #include "refdata.hpp"
 #include "ptr.hpp"
 #include "globals.hpp"
+#include "scene.hpp"
 
 #include <openengine/bullet/physic.hpp>
 
@@ -66,6 +67,7 @@ namespace MWWorld
 
             MWRender::SkyManager* mSkyManager;
             MWRender::MWScene mScene;
+            MWWorld::Scene *mWorldScene;
             MWWorld::Player *mPlayer;
             Ptr::CellStore *mCurrentCell; // the cell, the player is in
             CellRenderCollection mActiveCells;
@@ -87,8 +89,6 @@ namespace MWWorld
             World (const World&);
             World& operator= (const World&);
 
-            void insertInteriorScripts (ESMS::CellStore<RefData>& cell);
-
             Ptr getPtr (const std::string& name, Ptr::CellStore& cellStore);
 
             Ptr getPtrViaHandle (const std::string& handle, Ptr::CellStore& cellStore);
@@ -106,8 +106,6 @@ namespace MWWorld
             void playerCellChange (Ptr::CellStore *cell, const ESM::Position& position,
                 bool adjustPlayerPos = true);
 
-            void adjustSky();
-
             void changeCell (int X, int Y, const ESM::Position& position, bool adjustPlayerPos);
             ///< Move from exterior to interior or from interior cell to a different
             /// interior cell.
@@ -120,9 +118,15 @@ namespace MWWorld
 
             ~World();
 
+            void insertInteriorScripts (ESMS::CellStore<RefData>& cell);
+
+            void adjustSky();
+
             MWWorld::Player& getPlayer();
 
             const ESMS::ESMStore& getStore() const;
+            
+            ESM::ESMReader& getEsmReader();
 
             const ScriptList& getLocalScripts() const;
             ///< Names and local variable state of all local scripts in active cells.