mirror of
https://github.com/TES3MP/openmw-tes3mp.git
synced 2025-01-16 01:49:54 +00:00
7d36a202a8
The cell loading threshold (default: 1024 units) prevents exterior cell loading until the player has travelled part-way into the next cell. This gets rid of excessive cell loadings when walking along an exterior cell border. Lower the maximum allowed view distance in options menu to accomodate. Change setting name so that old settings files are upgraded.
561 lines
19 KiB
C++
561 lines
19 KiB
C++
#include "scene.hpp"
|
|
|
|
#include <OgreSceneNode.h>
|
|
|
|
#include <components/nif/niffile.hpp>
|
|
|
|
#include "../mwbase/environment.hpp"
|
|
#include "../mwbase/world.hpp"
|
|
#include "../mwbase/soundmanager.hpp"
|
|
#include "../mwbase/mechanicsmanager.hpp"
|
|
#include "../mwbase/windowmanager.hpp"
|
|
|
|
#include "physicssystem.hpp"
|
|
#include "player.hpp"
|
|
#include "localscripts.hpp"
|
|
#include "esmstore.hpp"
|
|
#include "class.hpp"
|
|
#include "cellfunctors.hpp"
|
|
#include "cellstore.hpp"
|
|
|
|
namespace
|
|
{
|
|
void updateObjectLocalRotation (const MWWorld::Ptr& ptr, MWWorld::PhysicsSystem& physics,
|
|
MWRender::RenderingManager& rendering)
|
|
{
|
|
if (ptr.getRefData().getBaseNode() != NULL)
|
|
{
|
|
Ogre::Quaternion worldRotQuat(Ogre::Radian(ptr.getRefData().getPosition().rot[2]), Ogre::Vector3::NEGATIVE_UNIT_Z);
|
|
if (!ptr.getClass().isActor())
|
|
worldRotQuat = Ogre::Quaternion(Ogre::Radian(ptr.getRefData().getPosition().rot[0]), Ogre::Vector3::NEGATIVE_UNIT_X)*
|
|
Ogre::Quaternion(Ogre::Radian(ptr.getRefData().getPosition().rot[1]), Ogre::Vector3::NEGATIVE_UNIT_Y)* worldRotQuat;
|
|
|
|
float x = ptr.getRefData().getLocalRotation().rot[0];
|
|
float y = ptr.getRefData().getLocalRotation().rot[1];
|
|
float z = ptr.getRefData().getLocalRotation().rot[2];
|
|
|
|
Ogre::Quaternion rot(Ogre::Radian(z), Ogre::Vector3::NEGATIVE_UNIT_Z);
|
|
if (!ptr.getClass().isActor())
|
|
rot = Ogre::Quaternion(Ogre::Radian(x), Ogre::Vector3::NEGATIVE_UNIT_X)*
|
|
Ogre::Quaternion(Ogre::Radian(y), Ogre::Vector3::NEGATIVE_UNIT_Y)*rot;
|
|
|
|
ptr.getRefData().getBaseNode()->setOrientation(worldRotQuat*rot);
|
|
physics.rotateObject(ptr);
|
|
}
|
|
}
|
|
|
|
struct InsertFunctor
|
|
{
|
|
MWWorld::CellStore& mCell;
|
|
bool mRescale;
|
|
Loading::Listener& mLoadingListener;
|
|
MWWorld::PhysicsSystem& mPhysics;
|
|
MWRender::RenderingManager& mRendering;
|
|
|
|
InsertFunctor (MWWorld::CellStore& cell, bool rescale, Loading::Listener& loadingListener,
|
|
MWWorld::PhysicsSystem& physics, MWRender::RenderingManager& rendering);
|
|
|
|
bool operator() (const MWWorld::Ptr& ptr);
|
|
};
|
|
|
|
InsertFunctor::InsertFunctor (MWWorld::CellStore& cell, bool rescale,
|
|
Loading::Listener& loadingListener, MWWorld::PhysicsSystem& physics,
|
|
MWRender::RenderingManager& rendering)
|
|
: mCell (cell), mRescale (rescale), mLoadingListener (loadingListener),
|
|
mPhysics (physics), mRendering (rendering)
|
|
{}
|
|
|
|
bool InsertFunctor::operator() (const MWWorld::Ptr& ptr)
|
|
{
|
|
if (mRescale)
|
|
{
|
|
if (ptr.getCellRef().getScale()<0.5)
|
|
ptr.getCellRef().setScale(0.5);
|
|
else if (ptr.getCellRef().getScale()>2)
|
|
ptr.getCellRef().setScale(2);
|
|
}
|
|
|
|
if (ptr.getRefData().getCount() && ptr.getRefData().isEnabled())
|
|
{
|
|
try
|
|
{
|
|
mRendering.addObject (ptr);
|
|
ptr.getClass().insertObject (ptr, mPhysics);
|
|
|
|
updateObjectLocalRotation(ptr, mPhysics, mRendering);
|
|
MWBase::Environment::get().getWorld()->scaleObject (ptr, ptr.getCellRef().getScale());
|
|
ptr.getClass().adjustPosition (ptr, false);
|
|
}
|
|
catch (const std::exception& e)
|
|
{
|
|
std::string error ("error during rendering: ");
|
|
std::cerr << error + e.what() << std::endl;
|
|
}
|
|
}
|
|
|
|
mLoadingListener.increaseProgress (1);
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
|
|
namespace MWWorld
|
|
{
|
|
|
|
void Scene::updateObjectLocalRotation (const Ptr& ptr)
|
|
{
|
|
::updateObjectLocalRotation(ptr, *mPhysics, mRendering);
|
|
}
|
|
|
|
void Scene::updateObjectRotation (const Ptr& ptr)
|
|
{
|
|
if(ptr.getRefData().getBaseNode() != 0)
|
|
{
|
|
mRendering.rotateObject(ptr);
|
|
mPhysics->rotateObject(ptr);
|
|
}
|
|
}
|
|
|
|
void Scene::getGridCenter(int &cellX, int &cellY)
|
|
{
|
|
int maxX = std::numeric_limits<int>().min();
|
|
int maxY = std::numeric_limits<int>().min();
|
|
int minX = std::numeric_limits<int>().max();
|
|
int minY = std::numeric_limits<int>().max();
|
|
CellStoreCollection::iterator iter = mActiveCells.begin();
|
|
while (iter!=mActiveCells.end())
|
|
{
|
|
assert ((*iter)->getCell()->isExterior());
|
|
int x = (*iter)->getCell()->getGridX();
|
|
int y = (*iter)->getCell()->getGridY();
|
|
maxX = std::max(x, maxX);
|
|
maxY = std::max(y, maxY);
|
|
minX = std::min(x, minX);
|
|
minY = std::min(y, minY);
|
|
++iter;
|
|
}
|
|
cellX = (minX + maxX) / 2;
|
|
cellY = (minY + maxY) / 2;
|
|
}
|
|
|
|
void Scene::update (float duration, bool paused)
|
|
{
|
|
if (mNeedMapUpdate)
|
|
{
|
|
// Note: exterior cell maps must be updated, even if they were visited before, because the set of surrounding cells might be different
|
|
// (and objects in a different cell can "bleed" into another cells map if they cross the border)
|
|
for (CellStoreCollection::iterator active = mActiveCells.begin(); active!=mActiveCells.end(); ++active)
|
|
mRendering.requestMap(*active);
|
|
mNeedMapUpdate = false;
|
|
|
|
if (mCurrentCell->isExterior())
|
|
{
|
|
int cellX, cellY;
|
|
getGridCenter(cellX, cellY);
|
|
MWBase::Environment::get().getWindowManager()->setActiveMap(cellX,cellY,false);
|
|
}
|
|
}
|
|
|
|
mRendering.update (duration, paused);
|
|
}
|
|
|
|
void Scene::unloadCell (CellStoreCollection::iterator iter)
|
|
{
|
|
std::cout << "Unloading cell\n";
|
|
ListAndResetHandles functor;
|
|
|
|
(*iter)->forEach<ListAndResetHandles>(functor);
|
|
{
|
|
// silence annoying g++ warning
|
|
for (std::vector<Ogre::SceneNode*>::const_iterator iter2 (functor.mHandles.begin());
|
|
iter2!=functor.mHandles.end(); ++iter2)
|
|
{
|
|
Ogre::SceneNode* node = *iter2;
|
|
mPhysics->removeObject (node->getName());
|
|
}
|
|
}
|
|
|
|
if ((*iter)->getCell()->isExterior())
|
|
{
|
|
ESM::Land* land =
|
|
MWBase::Environment::get().getWorld()->getStore().get<ESM::Land>().search(
|
|
(*iter)->getCell()->getGridX(),
|
|
(*iter)->getCell()->getGridY()
|
|
);
|
|
if (land)
|
|
mPhysics->removeHeightField ((*iter)->getCell()->getGridX(), (*iter)->getCell()->getGridY());
|
|
}
|
|
|
|
mRendering.removeCell(*iter);
|
|
|
|
MWBase::Environment::get().getWorld()->getLocalScripts().clearCell (*iter);
|
|
|
|
MWBase::Environment::get().getMechanicsManager()->drop (*iter);
|
|
|
|
MWBase::Environment::get().getSoundManager()->stopSound (*iter);
|
|
mActiveCells.erase(*iter);
|
|
}
|
|
|
|
void Scene::loadCell (CellStore *cell, Loading::Listener* loadingListener)
|
|
{
|
|
std::pair<CellStoreCollection::iterator, bool> result = mActiveCells.insert(cell);
|
|
|
|
if(result.second)
|
|
{
|
|
float verts = ESM::Land::LAND_SIZE;
|
|
float worldsize = ESM::Land::REAL_SIZE;
|
|
|
|
// Load terrain physics first...
|
|
if (cell->getCell()->isExterior())
|
|
{
|
|
ESM::Land* land =
|
|
MWBase::Environment::get().getWorld()->getStore().get<ESM::Land>().search(
|
|
cell->getCell()->getGridX(),
|
|
cell->getCell()->getGridY()
|
|
);
|
|
if (land) {
|
|
mPhysics->addHeightField (
|
|
land->mLandData->mHeights,
|
|
cell->getCell()->getGridX(),
|
|
cell->getCell()->getGridY(),
|
|
0,
|
|
worldsize / (verts-1),
|
|
verts)
|
|
;
|
|
}
|
|
}
|
|
|
|
cell->respawn();
|
|
|
|
// ... then references. This is important for adjustPosition to work correctly.
|
|
/// \todo rescale depending on the state of a new GMST
|
|
insertCell (*cell, true, loadingListener);
|
|
|
|
mRendering.cellAdded (cell);
|
|
|
|
mRendering.configureAmbient(*cell);
|
|
}
|
|
|
|
// register local scripts
|
|
// ??? Should this go into the above if block ???
|
|
MWBase::Environment::get().getWorld()->getLocalScripts().addCell (cell);
|
|
}
|
|
|
|
void Scene::changeToVoid()
|
|
{
|
|
CellStoreCollection::iterator active = mActiveCells.begin();
|
|
while (active!=mActiveCells.end())
|
|
unloadCell (active++);
|
|
assert(mActiveCells.empty());
|
|
mCurrentCell = NULL;
|
|
}
|
|
|
|
void Scene::playerMoved(const Ogre::Vector3 &pos)
|
|
{
|
|
if (!mCurrentCell || !mCurrentCell->isExterior())
|
|
return;
|
|
|
|
// figure out the center of the current cell grid (*not* necessarily mCurrentCell, which is the cell the player is in)
|
|
int cellX, cellY;
|
|
getGridCenter(cellX, cellY);
|
|
float centerX, centerY;
|
|
MWBase::Environment::get().getWorld()->indexToPosition(cellX, cellY, centerX, centerY, true);
|
|
const float maxDistance = 8192/2 + 1024; // 1/2 cell size + threshold
|
|
float distance = std::max(std::abs(centerX-pos.x), std::abs(centerY-pos.y));
|
|
if (distance > maxDistance)
|
|
{
|
|
int newX, newY;
|
|
MWBase::Environment::get().getWorld()->positionToIndex(pos.x, pos.y, newX, newY);
|
|
changeCellGrid(newX, newY);
|
|
mRendering.updateTerrain();
|
|
}
|
|
}
|
|
|
|
void Scene::changeCellGrid (int X, int Y)
|
|
{
|
|
Loading::Listener* loadingListener = MWBase::Environment::get().getWindowManager()->getLoadingScreen();
|
|
Loading::ScopedLoad load(loadingListener);
|
|
|
|
mRendering.enableTerrain(true);
|
|
|
|
std::string loadingExteriorText = "#{sLoadingMessage3}";
|
|
loadingListener->setLabel(loadingExteriorText);
|
|
|
|
CellStoreCollection::iterator active = mActiveCells.begin();
|
|
while (active!=mActiveCells.end())
|
|
{
|
|
if ((*active)->getCell()->isExterior())
|
|
{
|
|
if (std::abs (X-(*active)->getCell()->getGridX())<=1 &&
|
|
std::abs (Y-(*active)->getCell()->getGridY())<=1)
|
|
{
|
|
// keep cells within the new 3x3 grid
|
|
++active;
|
|
continue;
|
|
}
|
|
}
|
|
unloadCell (active++);
|
|
}
|
|
|
|
int refsToLoad = 0;
|
|
// get the number of refs to load
|
|
for (int x=X-1; x<=X+1; ++x)
|
|
{
|
|
for (int y=Y-1; y<=Y+1; ++y)
|
|
{
|
|
CellStoreCollection::iterator iter = mActiveCells.begin();
|
|
|
|
while (iter!=mActiveCells.end())
|
|
{
|
|
assert ((*iter)->getCell()->isExterior());
|
|
|
|
if (x==(*iter)->getCell()->getGridX() &&
|
|
y==(*iter)->getCell()->getGridY())
|
|
break;
|
|
|
|
++iter;
|
|
}
|
|
|
|
if (iter==mActiveCells.end())
|
|
refsToLoad += MWBase::Environment::get().getWorld()->getExterior(x, y)->count();
|
|
}
|
|
}
|
|
|
|
loadingListener->setProgressRange(refsToLoad);
|
|
|
|
// Load cells
|
|
for (int x=X-1; x<=X+1; ++x)
|
|
{
|
|
for (int y=Y-1; y<=Y+1; ++y)
|
|
{
|
|
CellStoreCollection::iterator iter = mActiveCells.begin();
|
|
|
|
while (iter!=mActiveCells.end())
|
|
{
|
|
assert ((*iter)->getCell()->isExterior());
|
|
|
|
if (x==(*iter)->getCell()->getGridX() &&
|
|
y==(*iter)->getCell()->getGridY())
|
|
break;
|
|
|
|
++iter;
|
|
}
|
|
|
|
if (iter==mActiveCells.end())
|
|
{
|
|
CellStore *cell = MWBase::Environment::get().getWorld()->getExterior(x, y);
|
|
|
|
loadCell (cell, loadingListener);
|
|
}
|
|
}
|
|
}
|
|
|
|
CellStore* current = MWBase::Environment::get().getWorld()->getExterior(X,Y);
|
|
MWBase::Environment::get().getWindowManager()->changeCell(current);
|
|
|
|
mCellChanged = true;
|
|
|
|
// Delay the map update until scripts have been given a chance to run.
|
|
// If we don't do this, objects that should be disabled will still appear on the map.
|
|
mNeedMapUpdate = true;
|
|
}
|
|
|
|
void Scene::changePlayerCell(CellStore *cell, const ESM::Position &pos, bool adjustPlayerPos)
|
|
{
|
|
mCurrentCell = cell;
|
|
|
|
MWBase::World *world = MWBase::Environment::get().getWorld();
|
|
MWWorld::Ptr old = world->getPlayerPtr();
|
|
world->getPlayer().setCell(cell);
|
|
|
|
MWWorld::Ptr player = world->getPlayerPtr();
|
|
mRendering.updatePlayerPtr(player);
|
|
|
|
if (adjustPlayerPos) {
|
|
world->moveObject(player, pos.pos[0], pos.pos[1], pos.pos[2]);
|
|
|
|
float x = Ogre::Radian(pos.rot[0]).valueDegrees();
|
|
float y = Ogre::Radian(pos.rot[1]).valueDegrees();
|
|
float z = Ogre::Radian(pos.rot[2]).valueDegrees();
|
|
world->rotateObject(player, x, y, z);
|
|
|
|
player.getClass().adjustPosition(player, true);
|
|
}
|
|
|
|
MWBase::MechanicsManager *mechMgr =
|
|
MWBase::Environment::get().getMechanicsManager();
|
|
|
|
mechMgr->updateCell(old, player);
|
|
mechMgr->watchActor(player);
|
|
|
|
MWBase::Environment::get().getWorld()->adjustSky();
|
|
}
|
|
|
|
//We need the ogre renderer and a scene node.
|
|
Scene::Scene (MWRender::RenderingManager& rendering, PhysicsSystem *physics)
|
|
: mCurrentCell (0), mCellChanged (false), mPhysics(physics), mRendering(rendering), mNeedMapUpdate(false)
|
|
{
|
|
}
|
|
|
|
Scene::~Scene()
|
|
{
|
|
}
|
|
|
|
bool Scene::hasCellChanged() const
|
|
{
|
|
return mCellChanged;
|
|
}
|
|
|
|
const Scene::CellStoreCollection& Scene::getActiveCells() const
|
|
{
|
|
return mActiveCells;
|
|
}
|
|
|
|
void Scene::changeToInteriorCell (const std::string& cellName, const ESM::Position& position)
|
|
{
|
|
CellStore *cell = MWBase::Environment::get().getWorld()->getInterior(cellName);
|
|
bool loadcell = (mCurrentCell == NULL);
|
|
if(!loadcell)
|
|
loadcell = *mCurrentCell != *cell;
|
|
|
|
MWBase::Environment::get().getWindowManager()->fadeScreenOut(0.5);
|
|
|
|
Loading::Listener* loadingListener = MWBase::Environment::get().getWindowManager()->getLoadingScreen();
|
|
std::string loadingInteriorText = "#{sLoadingMessage2}";
|
|
loadingListener->setLabel(loadingInteriorText);
|
|
Loading::ScopedLoad load(loadingListener);
|
|
|
|
mRendering.enableTerrain(false);
|
|
|
|
if(!loadcell)
|
|
{
|
|
MWBase::World *world = MWBase::Environment::get().getWorld();
|
|
world->moveObject(world->getPlayerPtr(), position.pos[0], position.pos[1], position.pos[2]);
|
|
|
|
float x = Ogre::Radian(position.rot[0]).valueDegrees();
|
|
float y = Ogre::Radian(position.rot[1]).valueDegrees();
|
|
float z = Ogre::Radian(position.rot[2]).valueDegrees();
|
|
world->rotateObject(world->getPlayerPtr(), x, y, z);
|
|
|
|
world->getPlayerPtr().getClass().adjustPosition(world->getPlayerPtr(), true);
|
|
MWBase::Environment::get().getWindowManager()->fadeScreenIn(0.5);
|
|
return;
|
|
}
|
|
|
|
std::cout << "Changing to interior\n";
|
|
|
|
// unload
|
|
int current = 0;
|
|
CellStoreCollection::iterator active = mActiveCells.begin();
|
|
while (active!=mActiveCells.end())
|
|
{
|
|
unloadCell (active++);
|
|
++current;
|
|
}
|
|
|
|
int refsToLoad = cell->count();
|
|
loadingListener->setProgressRange(refsToLoad);
|
|
|
|
// Load cell.
|
|
std::cout << "cellName: " << cell->getCell()->mName << std::endl;
|
|
|
|
loadCell (cell, loadingListener);
|
|
|
|
changePlayerCell(cell, position, true);
|
|
|
|
// adjust fog
|
|
mRendering.configureFog(*mCurrentCell);
|
|
|
|
// Sky system
|
|
MWBase::Environment::get().getWorld()->adjustSky();
|
|
|
|
mCellChanged = true;
|
|
MWBase::Environment::get().getWindowManager()->fadeScreenIn(0.5);
|
|
|
|
MWBase::Environment::get().getWindowManager()->changeCell(mCurrentCell);
|
|
|
|
// Delay the map update until scripts have been given a chance to run.
|
|
// If we don't do this, objects that should be disabled will still appear on the map.
|
|
mNeedMapUpdate = true;
|
|
}
|
|
|
|
void Scene::changeToExteriorCell (const ESM::Position& position, bool adjustPlayerPos)
|
|
{
|
|
int x = 0;
|
|
int y = 0;
|
|
|
|
MWBase::Environment::get().getWorld()->positionToIndex (position.pos[0], position.pos[1], x, y);
|
|
|
|
changeCellGrid(x, y);
|
|
|
|
CellStore* current = MWBase::Environment::get().getWorld()->getExterior(x, y);
|
|
changePlayerCell(current, position, adjustPlayerPos);
|
|
|
|
mRendering.updateTerrain();
|
|
}
|
|
|
|
CellStore* Scene::getCurrentCell ()
|
|
{
|
|
return mCurrentCell;
|
|
}
|
|
|
|
void Scene::markCellAsUnchanged()
|
|
{
|
|
mCellChanged = false;
|
|
}
|
|
|
|
void Scene::insertCell (CellStore &cell, bool rescale, Loading::Listener* loadingListener)
|
|
{
|
|
InsertFunctor functor (cell, rescale, *loadingListener, *mPhysics, mRendering);
|
|
cell.forEach (functor);
|
|
}
|
|
|
|
void Scene::addObjectToScene (const Ptr& ptr)
|
|
{
|
|
mRendering.addObject(ptr);
|
|
ptr.getClass().insertObject(ptr, *mPhysics);
|
|
MWBase::Environment::get().getWorld()->rotateObject(ptr, 0, 0, 0, true);
|
|
MWBase::Environment::get().getWorld()->scaleObject(ptr, ptr.getCellRef().getScale());
|
|
}
|
|
|
|
void Scene::removeObjectFromScene (const Ptr& ptr)
|
|
{
|
|
MWBase::Environment::get().getMechanicsManager()->remove (ptr);
|
|
MWBase::Environment::get().getSoundManager()->stopSound3D (ptr);
|
|
mPhysics->removeObject (ptr.getRefData().getHandle());
|
|
mRendering.removeObject (ptr);
|
|
}
|
|
|
|
bool Scene::isCellActive(const CellStore &cell)
|
|
{
|
|
CellStoreCollection::iterator active = mActiveCells.begin();
|
|
while (active != mActiveCells.end()) {
|
|
if (**active == cell) {
|
|
return true;
|
|
}
|
|
++active;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
Ptr Scene::searchPtrViaHandle (const std::string& handle)
|
|
{
|
|
for (CellStoreCollection::const_iterator iter (mActiveCells.begin());
|
|
iter!=mActiveCells.end(); ++iter)
|
|
if (Ptr ptr = (*iter)->searchViaHandle (handle))
|
|
return ptr;
|
|
|
|
return Ptr();
|
|
}
|
|
|
|
Ptr Scene::searchPtrViaActorId (int actorId)
|
|
{
|
|
for (CellStoreCollection::const_iterator iter (mActiveCells.begin());
|
|
iter!=mActiveCells.end(); ++iter)
|
|
if (Ptr ptr = (*iter)->searchViaActorId (actorId))
|
|
return ptr;
|
|
|
|
return Ptr();
|
|
}
|
|
}
|