mirror/openmw
1
0
Fork 0
mirror of https://github.com/OpenMW/openmw.git synced 2025-03-01 12:09:50 +00:00
Code Issues Releases Wiki Activity

Restore the cell grid to its former non-exorbitant size, reducing stutter and also threw in a simple alternative fix for the actor position adjustment issue.

Browse source
This commit is contained in:
Bret Curtis 2021-09-30 22:58:16 +02:00
parent 5f3a36a9b7
commit 8309910d9d
22 changed files with 113 additions and 208 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
apps/openmw/mwclass/activator.cpp
View file

@ -38,15 +38,15 @@ namespace MWClass
} }
} }
void Activator::insertObject(const MWWorld::Ptr& ptr, const std::string& model, const osg::Quat& rotation, MWPhysics::PhysicsSystem& physics, bool skipAnimated) const void Activator::insertObject(const MWWorld::Ptr& ptr, const std::string& model, const osg::Quat& rotation, MWPhysics::PhysicsSystem& physics) const
{ {
insertObjectPhysics(ptr, model, rotation, physics, skipAnimated); insertObjectPhysics(ptr, model, rotation, physics);
} }
void Activator::insertObjectPhysics(const MWWorld::Ptr& ptr, const std::string& model, const osg::Quat& rotation, MWPhysics::PhysicsSystem& physics, bool skipAnimated) const void Activator::insertObjectPhysics(const MWWorld::Ptr& ptr, const std::string& model, const osg::Quat& rotation, MWPhysics::PhysicsSystem& physics) const
{ {
if(!model.empty()) if(!model.empty())
physics.addObject(ptr, model, rotation, MWPhysics::CollisionType_World, skipAnimated); physics.addObject(ptr, model, rotation, MWPhysics::CollisionType_World);
} }
std::string Activator::getModel(const MWWorld::ConstPtr &ptr) const std::string Activator::getModel(const MWWorld::ConstPtr &ptr) const

4
apps/openmw/mwclass/activator.hpp
View file

@ -17,9 +17,9 @@ namespace MWClass
void insertObjectRendering (const MWWorld::Ptr& ptr, const std::string& model, MWRender::RenderingInterface& renderingInterface) const override; void insertObjectRendering (const MWWorld::Ptr& ptr, const std::string& model, MWRender::RenderingInterface& renderingInterface) const override;
///< Add reference into a cell for rendering ///< Add reference into a cell for rendering
void insertObject(const MWWorld::Ptr& ptr, const std::string& model, const osg::Quat& rotation, MWPhysics::PhysicsSystem& physics, bool skipAnimated = false) const override; void insertObject(const MWWorld::Ptr& ptr, const std::string& model, const osg::Quat& rotation, MWPhysics::PhysicsSystem& physics) const override;
void insertObjectPhysics(const MWWorld::Ptr& ptr, const std::string& model, const osg::Quat& rotation, MWPhysics::PhysicsSystem& physics, bool skipAnimated) const override; void insertObjectPhysics(const MWWorld::Ptr& ptr, const std::string& model, const osg::Quat& rotation, MWPhysics::PhysicsSystem& physics) const override;
std::string getName (const MWWorld::ConstPtr& ptr) const override; std::string getName (const MWWorld::ConstPtr& ptr) const override;
///< \return name or ID; can return an empty string. ///< \return name or ID; can return an empty string.

2
apps/openmw/mwclass/actor.cpp
View file

@ -22,7 +22,7 @@ namespace MWClass
MWBase::Environment::get().getWorld()->adjustPosition(ptr, force); MWBase::Environment::get().getWorld()->adjustPosition(ptr, force);
} }
void Actor::insertObject(const MWWorld::Ptr& ptr, const std::string& model, const osg::Quat& rotation, MWPhysics::PhysicsSystem& physics, bool skipAnimated) const void Actor::insertObject(const MWWorld::Ptr& ptr, const std::string& model, const osg::Quat& rotation, MWPhysics::PhysicsSystem& physics) const
{ {
if (!model.empty()) if (!model.empty())
{ {

2
apps/openmw/mwclass/actor.hpp
View file

@ -24,7 +24,7 @@ namespace MWClass
///< Adjust position to stand on ground. Must be called post model load ///< Adjust position to stand on ground. Must be called post model load
/// @param force do this even if the ptr is flying /// @param force do this even if the ptr is flying
void insertObject(const MWWorld::Ptr& ptr, const std::string& model, const osg::Quat& rotation, MWPhysics::PhysicsSystem& physics, bool skipAnimated = false) const override; void insertObject(const MWWorld::Ptr& ptr, const std::string& model, const osg::Quat& rotation, MWPhysics::PhysicsSystem& physics) const override;
bool useAnim() const override; bool useAnim() const override;

8
apps/openmw/mwclass/container.cpp
View file

@ -106,15 +106,15 @@ namespace MWClass
} }
} }
void Container::insertObject(const MWWorld::Ptr& ptr, const std::string& model, const osg::Quat& rotation, MWPhysics::PhysicsSystem& physics, bool skipAnimated) const void Container::insertObject(const MWWorld::Ptr& ptr, const std::string& model, const osg::Quat& rotation, MWPhysics::PhysicsSystem& physics) const
{ {
insertObjectPhysics(ptr, model, rotation, physics, skipAnimated); insertObjectPhysics(ptr, model, rotation, physics);
} }
void Container::insertObjectPhysics(const MWWorld::Ptr& ptr, const std::string& model, const osg::Quat& rotation, MWPhysics::PhysicsSystem& physics, bool skipAnimated) const void Container::insertObjectPhysics(const MWWorld::Ptr& ptr, const std::string& model, const osg::Quat& rotation, MWPhysics::PhysicsSystem& physics) const
{ {
if(!model.empty()) if(!model.empty())
physics.addObject(ptr, model, rotation, MWPhysics::CollisionType_World, skipAnimated); physics.addObject(ptr, model, rotation, MWPhysics::CollisionType_World);
} }
std::string Container::getModel(const MWWorld::ConstPtr &ptr) const std::string Container::getModel(const MWWorld::ConstPtr &ptr) const

4
apps/openmw/mwclass/container.hpp
View file

@ -42,8 +42,8 @@ namespace MWClass
void insertObjectRendering (const MWWorld::Ptr& ptr, const std::string& model, MWRender::RenderingInterface& renderingInterface) const override; void insertObjectRendering (const MWWorld::Ptr& ptr, const std::string& model, MWRender::RenderingInterface& renderingInterface) const override;
///< Add reference into a cell for rendering ///< Add reference into a cell for rendering
void insertObject(const MWWorld::Ptr& ptr, const std::string& model, const osg::Quat& rotation, MWPhysics::PhysicsSystem& physics, bool skipAnimated = false) const override; void insertObject(const MWWorld::Ptr& ptr, const std::string& model, const osg::Quat& rotation, MWPhysics::PhysicsSystem& physics) const override;
void insertObjectPhysics(const MWWorld::Ptr& ptr, const std::string& model, const osg::Quat& rotation, MWPhysics::PhysicsSystem& physics, bool skipAnimated = false) const override; void insertObjectPhysics(const MWWorld::Ptr& ptr, const std::string& model, const osg::Quat& rotation, MWPhysics::PhysicsSystem& physics) const override;
std::string getName (const MWWorld::ConstPtr& ptr) const override; std::string getName (const MWWorld::ConstPtr& ptr) const override;
///< \return name or ID; can return an empty string. ///< \return name or ID; can return an empty string.

8
apps/openmw/mwclass/door.cpp
View file

@ -55,9 +55,9 @@ namespace MWClass
} }
} }
void Door::insertObject(const MWWorld::Ptr& ptr, const std::string& model, const osg::Quat& rotation, MWPhysics::PhysicsSystem& physics, bool skipAnimated) const void Door::insertObject(const MWWorld::Ptr& ptr, const std::string& model, const osg::Quat& rotation, MWPhysics::PhysicsSystem& physics) const
{ {
insertObjectPhysics(ptr, model, rotation, physics, skipAnimated); insertObjectPhysics(ptr, model, rotation, physics);
// Resume the door's opening/closing animation if it wasn't finished // Resume the door's opening/closing animation if it wasn't finished
if (ptr.getRefData().getCustomData()) if (ptr.getRefData().getCustomData())
@ -70,10 +70,10 @@ namespace MWClass
} }
} }
void Door::insertObjectPhysics(const MWWorld::Ptr& ptr, const std::string& model, const osg::Quat& rotation, MWPhysics::PhysicsSystem& physics, bool skipAnimated) const void Door::insertObjectPhysics(const MWWorld::Ptr& ptr, const std::string& model, const osg::Quat& rotation, MWPhysics::PhysicsSystem& physics) const
{ {
if(!model.empty()) if(!model.empty())
physics.addObject(ptr, model, rotation, MWPhysics::CollisionType_Door, skipAnimated); physics.addObject(ptr, model, rotation, MWPhysics::CollisionType_Door);
} }
bool Door::isDoor() const bool Door::isDoor() const

4
apps/openmw/mwclass/door.hpp
View file

@ -18,8 +18,8 @@ namespace MWClass
void insertObjectRendering (const MWWorld::Ptr& ptr, const std::string& model, MWRender::RenderingInterface& renderingInterface) const override; void insertObjectRendering (const MWWorld::Ptr& ptr, const std::string& model, MWRender::RenderingInterface& renderingInterface) const override;
///< Add reference into a cell for rendering ///< Add reference into a cell for rendering
void insertObject(const MWWorld::Ptr& ptr, const std::string& model, const osg::Quat& rotation, MWPhysics::PhysicsSystem& physics, bool skipAnimated = false) const override; void insertObject(const MWWorld::Ptr& ptr, const std::string& model, const osg::Quat& rotation, MWPhysics::PhysicsSystem& physics) const override;
void insertObjectPhysics(const MWWorld::Ptr& ptr, const std::string& model, const osg::Quat& rotation, MWPhysics::PhysicsSystem& physics, bool skipAnimated = false) const override; void insertObjectPhysics(const MWWorld::Ptr& ptr, const std::string& model, const osg::Quat& rotation, MWPhysics::PhysicsSystem& physics) const override;
bool isDoor() const override; bool isDoor() const override;

8
apps/openmw/mwclass/light.cpp
View file

@ -33,13 +33,13 @@ namespace MWClass
renderingInterface.getObjects().insertModel(ptr, model, true, !(ref->mBase->mData.mFlags & ESM::Light::OffDefault)); renderingInterface.getObjects().insertModel(ptr, model, true, !(ref->mBase->mData.mFlags & ESM::Light::OffDefault));
} }
void Light::insertObject(const MWWorld::Ptr& ptr, const std::string& model, const osg::Quat& rotation, MWPhysics::PhysicsSystem& physics, bool skipAnimated) const void Light::insertObject(const MWWorld::Ptr& ptr, const std::string& model, const osg::Quat& rotation, MWPhysics::PhysicsSystem& physics) const
{ {
MWWorld::LiveCellRef<ESM::Light> *ref = MWWorld::LiveCellRef<ESM::Light> *ref =
ptr.get<ESM::Light>(); ptr.get<ESM::Light>();
assert (ref->mBase != nullptr); assert (ref->mBase != nullptr);
insertObjectPhysics(ptr, model, rotation, physics, skipAnimated); insertObjectPhysics(ptr, model, rotation, physics);
if (!ref->mBase->mSound.empty() && !(ref->mBase->mData.mFlags & ESM::Light::OffDefault)) if (!ref->mBase->mSound.empty() && !(ref->mBase->mData.mFlags & ESM::Light::OffDefault))
MWBase::Environment::get().getSoundManager()->playSound3D(ptr, ref->mBase->mSound, 1.0, 1.0, MWBase::Environment::get().getSoundManager()->playSound3D(ptr, ref->mBase->mSound, 1.0, 1.0,
@ -47,11 +47,11 @@ namespace MWClass
MWSound::PlayMode::Loop); MWSound::PlayMode::Loop);
} }
void Light::insertObjectPhysics(const MWWorld::Ptr& ptr, const std::string& model, const osg::Quat& rotation, MWPhysics::PhysicsSystem& physics, bool skipAnimated) const void Light::insertObjectPhysics(const MWWorld::Ptr& ptr, const std::string& model, const osg::Quat& rotation, MWPhysics::PhysicsSystem& physics) const
{ {
// TODO: add option somewhere to enable collision for placeable objects // TODO: add option somewhere to enable collision for placeable objects
if (!model.empty() && (ptr.get<ESM::Light>()->mBase->mData.mFlags & ESM::Light::Carry) == 0) if (!model.empty() && (ptr.get<ESM::Light>()->mBase->mData.mFlags & ESM::Light::Carry) == 0)
physics.addObject(ptr, model, rotation, MWPhysics::CollisionType_World, skipAnimated); physics.addObject(ptr, model, rotation, MWPhysics::CollisionType_World);
} }
bool Light::useAnim() const bool Light::useAnim() const

4
apps/openmw/mwclass/light.hpp
View file

@ -14,8 +14,8 @@ namespace MWClass
void insertObjectRendering (const MWWorld::Ptr& ptr, const std::string& model, MWRender::RenderingInterface& renderingInterface) const override; void insertObjectRendering (const MWWorld::Ptr& ptr, const std::string& model, MWRender::RenderingInterface& renderingInterface) const override;
///< Add reference into a cell for rendering ///< Add reference into a cell for rendering
void insertObject(const MWWorld::Ptr& ptr, const std::string& model, const osg::Quat& rotation, MWPhysics::PhysicsSystem& physics, bool skipAnimated = false) const override; void insertObject(const MWWorld::Ptr& ptr, const std::string& model, const osg::Quat& rotation, MWPhysics::PhysicsSystem& physics) const override;
void insertObjectPhysics(const MWWorld::Ptr& ptr, const std::string& model, const osg::Quat& rotation, MWPhysics::PhysicsSystem& physics, bool skipAnimated = false) const override; void insertObjectPhysics(const MWWorld::Ptr& ptr, const std::string& model, const osg::Quat& rotation, MWPhysics::PhysicsSystem& physics) const override;
bool useAnim() const override; bool useAnim() const override;

8
apps/openmw/mwclass/static.cpp
View file

@ -23,15 +23,15 @@ namespace MWClass
} }
} }
void Static::insertObject(const MWWorld::Ptr& ptr, const std::string& model, const osg::Quat& rotation, MWPhysics::PhysicsSystem& physics, bool skipAnimated) const void Static::insertObject(const MWWorld::Ptr& ptr, const std::string& model, const osg::Quat& rotation, MWPhysics::PhysicsSystem& physics) const
{ {
insertObjectPhysics(ptr, model, rotation, physics, skipAnimated); insertObjectPhysics(ptr, model, rotation, physics);
} }
void Static::insertObjectPhysics(const MWWorld::Ptr& ptr, const std::string& model, const osg::Quat& rotation, MWPhysics::PhysicsSystem& physics, bool skipAnimated) const void Static::insertObjectPhysics(const MWWorld::Ptr& ptr, const std::string& model, const osg::Quat& rotation, MWPhysics::PhysicsSystem& physics) const
{ {
if(!model.empty()) if(!model.empty())
physics.addObject(ptr, model, rotation, MWPhysics::CollisionType_World, skipAnimated); physics.addObject(ptr, model, rotation, MWPhysics::CollisionType_World);
} }
std::string Static::getModel(const MWWorld::ConstPtr &ptr) const std::string Static::getModel(const MWWorld::ConstPtr &ptr) const

4
apps/openmw/mwclass/static.hpp
View file

@ -14,8 +14,8 @@ namespace MWClass
void insertObjectRendering (const MWWorld::Ptr& ptr, const std::string& model, MWRender::RenderingInterface& renderingInterface) const override; void insertObjectRendering (const MWWorld::Ptr& ptr, const std::string& model, MWRender::RenderingInterface& renderingInterface) const override;
///< Add reference into a cell for rendering ///< Add reference into a cell for rendering
void insertObject(const MWWorld::Ptr& ptr, const std::string& model, const osg::Quat& rotation, MWPhysics::PhysicsSystem& physics, bool skipAnimated = false) const override; void insertObject(const MWWorld::Ptr& ptr, const std::string& model, const osg::Quat& rotation, MWPhysics::PhysicsSystem& physics) const override;
void insertObjectPhysics(const MWWorld::Ptr& ptr, const std::string& model, const osg::Quat& rotation, MWPhysics::PhysicsSystem& physics, bool skipAnimated = false) const override; void insertObjectPhysics(const MWWorld::Ptr& ptr, const std::string& model, const osg::Quat& rotation, MWPhysics::PhysicsSystem& physics) const override;
std::string getName (const MWWorld::ConstPtr& ptr) const override; std::string getName (const MWWorld::ConstPtr& ptr) const override;
///< \return name or ID; can return an empty string. ///< \return name or ID; can return an empty string.

11
apps/openmw/mwmechanics/actor.cpp
View file

@ -5,6 +5,7 @@
namespace MWMechanics namespace MWMechanics
{ {
Actor::Actor(const MWWorld::Ptr &ptr, MWRender::Animation *animation) Actor::Actor(const MWWorld::Ptr &ptr, MWRender::Animation *animation)
: mPositionAdjusted(false)
{ {
mCharacterController.reset(new CharacterController(ptr, animation)); mCharacterController.reset(new CharacterController(ptr, animation));
} }
@ -58,4 +59,14 @@ namespace MWMechanics
{ {
mIsTurningToPlayer = turning; mIsTurningToPlayer = turning;
} }
void Actor::setPositionAdjusted(bool adjusted)
{
mPositionAdjusted = adjusted;
}
bool Actor::getPositionAdjusted() const
{
return mPositionAdjusted;
}
} }

4
apps/openmw/mwmechanics/actor.hpp
View file

@ -48,6 +48,9 @@ namespace MWMechanics
return mEngageCombat.update(duration); return mEngageCombat.update(duration);
} }
void setPositionAdjusted(bool adjusted);
bool getPositionAdjusted() const;
private: private:
std::unique_ptr<CharacterController> mCharacterController; std::unique_ptr<CharacterController> mCharacterController;
int mGreetingTimer{0}; int mGreetingTimer{0};
@ -55,6 +58,7 @@ namespace MWMechanics
GreetingState mGreetingState{Greet_None}; GreetingState mGreetingState{Greet_None};
bool mIsTurningToPlayer{false}; bool mIsTurningToPlayer{false};
Misc::DeviatingPeriodicTimer mEngageCombat{1.0f, 0.25f, Misc::Rng::deviate(0, 0.25f)}; Misc::DeviatingPeriodicTimer mEngageCombat{1.0f, 0.25f, Misc::Rng::deviate(0, 0.25f)};
bool mPositionAdjusted;
}; };
} }

7
apps/openmw/mwmechanics/actors.cpp
View file

@ -2157,7 +2157,14 @@ namespace MWMechanics
continue; continue;
} }
else if (!isPlayer) else if (!isPlayer)
{
iter->first.getRefData().getBaseNode()->setNodeMask(MWRender::Mask_Actor); iter->first.getRefData().getBaseNode()->setNodeMask(MWRender::Mask_Actor);
if (!iter->second->getPositionAdjusted())
{
iter->first.getClass().adjustPosition(iter->first, false);
iter->second->setPositionAdjusted(true);
}
}
const bool isDead = iter->first.getClass().getCreatureStats(iter->first).isDead(); const bool isDead = iter->first.getClass().getCreatureStats(iter->first).isDead();
if (!isDead && (!godmode || !isPlayer) && iter->first.getClass().getCreatureStats(iter->first).isParalyzed()) if (!isDead && (!godmode || !isPlayer) && iter->first.getClass().getCreatureStats(iter->first).isParalyzed())

5
apps/openmw/mwphysics/physicssystem.cpp
View file

@ -492,7 +492,7 @@ namespace MWPhysics
return heightField->second.get(); return heightField->second.get();
} }
void PhysicsSystem::addObject (const MWWorld::Ptr& ptr, const std::string& mesh, osg::Quat rotation, int collisionType, bool skipAnimated) void PhysicsSystem::addObject (const MWWorld::Ptr& ptr, const std::string& mesh, osg::Quat rotation, int collisionType)
{ {
if (ptr.mRef->mData.mPhysicsPostponed) if (ptr.mRef->mData.mPhysicsPostponed)
return; return;
@ -500,9 +500,6 @@ namespace MWPhysics
if (!shapeInstance || !shapeInstance->getCollisionShape()) if (!shapeInstance || !shapeInstance->getCollisionShape())
return; return;
if (skipAnimated && shapeInstance->isAnimated())
return;
assert(!getObject(ptr)); assert(!getObject(ptr));
auto obj = std::make_shared<Object>(ptr, shapeInstance, rotation, collisionType, mTaskScheduler.get()); auto obj = std::make_shared<Object>(ptr, shapeInstance, rotation, collisionType, mTaskScheduler.get());

2
apps/openmw/mwphysics/physicssystem.hpp
View file

@ -128,7 +128,7 @@ namespace MWPhysics
void setWaterHeight(float height); void setWaterHeight(float height);
void disableWater(); void disableWater();
void addObject (const MWWorld::Ptr& ptr, const std::string& mesh, osg::Quat rotation, int collisionType = CollisionType_World, bool skipAnimated = false); void addObject (const MWWorld::Ptr& ptr, const std::string& mesh, osg::Quat rotation, int collisionType = CollisionType_World);
void addActor (const MWWorld::Ptr& ptr, const std::string& mesh); void addActor (const MWWorld::Ptr& ptr, const std::string& mesh);
int addProjectile(const MWWorld::Ptr& caster, const osg::Vec3f& position, const std::string& mesh, bool computeRadius); int addProjectile(const MWWorld::Ptr& caster, const osg::Vec3f& position, const std::string& mesh, bool computeRadius);

10
apps/openmw/mwworld/cellvisitors.hpp
View file

@ -25,16 +25,6 @@ namespace MWWorld
} }
}; };
struct ListObjectsVisitor
{
std::vector<MWWorld::Ptr> mObjects;
bool operator() (const MWWorld::Ptr& ptr)
{
mObjects.push_back (ptr);
return true;
}
};
} }
#endif #endif

4
apps/openmw/mwworld/class.cpp
View file

@ -30,12 +30,12 @@ namespace MWWorld
} }
void Class::insertObject(const Ptr& ptr, const std::string& mesh, const osg::Quat& rotation, MWPhysics::PhysicsSystem& physics, bool skipAnimated) const void Class::insertObject(const Ptr& ptr, const std::string& mesh, const osg::Quat& rotation, MWPhysics::PhysicsSystem& physics) const
{ {
} }
void Class::insertObjectPhysics(const Ptr& ptr, const std::string& mesh, const osg::Quat& rotation, MWPhysics::PhysicsSystem& physics, bool skipAnimated) const void Class::insertObjectPhysics(const Ptr& ptr, const std::string& mesh, const osg::Quat& rotation, MWPhysics::PhysicsSystem& physics) const
{} {}
bool Class::apply (const MWWorld::Ptr& ptr, const std::string& id, const MWWorld::Ptr& actor) const bool Class::apply (const MWWorld::Ptr& ptr, const std::string& id, const MWWorld::Ptr& actor) const

4
apps/openmw/mwworld/class.hpp
View file

@ -78,9 +78,9 @@ namespace MWWorld
} }
virtual void insertObjectRendering (const Ptr& ptr, const std::string& mesh, MWRender::RenderingInterface& renderingInterface) const; virtual void insertObjectRendering (const Ptr& ptr, const std::string& mesh, MWRender::RenderingInterface& renderingInterface) const;
virtual void insertObject(const Ptr& ptr, const std::string& mesh, const osg::Quat& rotation, MWPhysics::PhysicsSystem& physics, bool skipAnimated = false) const; virtual void insertObject(const Ptr& ptr, const std::string& mesh, const osg::Quat& rotation, MWPhysics::PhysicsSystem& physics) const;
///< Add reference into a cell for rendering (default implementation: don't render anything). ///< Add reference into a cell for rendering (default implementation: don't render anything).
virtual void insertObjectPhysics(const Ptr& ptr, const std::string& mesh, const osg::Quat& rotation, MWPhysics::PhysicsSystem& physics, bool skipAnimated = false) const; virtual void insertObjectPhysics(const Ptr& ptr, const std::string& mesh, const osg::Quat& rotation, MWPhysics::PhysicsSystem& physics) const;
virtual std::string getName (const ConstPtr& ptr) const = 0; virtual std::string getName (const ConstPtr& ptr) const = 0;
///< \return name or ID; can return an empty string. ///< \return name or ID; can return an empty string.

195
apps/openmw/mwworld/scene.cpp
View file

@ -104,7 +104,7 @@ namespace
} }
void addObject(const MWWorld::Ptr& ptr, MWPhysics::PhysicsSystem& physics, void addObject(const MWWorld::Ptr& ptr, MWPhysics::PhysicsSystem& physics,
MWRender::RenderingManager& rendering, std::set<ESM::RefNum>& pagedRefs, bool onlyPhysics) MWRender::RenderingManager& rendering, std::set<ESM::RefNum>& pagedRefs)
{ {
if (ptr.getRefData().getBaseNode() || physics.getActor(ptr)) if (ptr.getRefData().getBaseNode() || physics.getActor(ptr))
{ {
@ -114,12 +114,6 @@ namespace
std::string model = getModel(ptr, rendering.getResourceSystem()->getVFS()); std::string model = getModel(ptr, rendering.getResourceSystem()->getVFS());
const auto rotation = makeNodeRotation(ptr, RotationOrder::direct); const auto rotation = makeNodeRotation(ptr, RotationOrder::direct);
if (onlyPhysics && !physics.getObject(ptr) && !ptr.getClass().isActor())
{
// When we preload physics object we need to skip animated objects. They are dependant on the scene graph which doesn't yet exist.
ptr.getClass().insertObject (ptr, model, rotation, physics, true);
return;
}
const ESM::RefNum& refnum = ptr.getCellRef().getRefNum(); const ESM::RefNum& refnum = ptr.getCellRef().getRefNum();
if (!refnum.hasContentFile() || pagedRefs.find(refnum) == pagedRefs.end()) if (!refnum.hasContentFile() || pagedRefs.find(refnum) == pagedRefs.end())
@ -137,7 +131,6 @@ namespace
// Restore effect particles // Restore effect particles
MWBase::Environment::get().getWorld()->applyLoopingParticles(ptr); MWBase::Environment::get().getWorld()->applyLoopingParticles(ptr);
if (!physics.getObject(ptr))
ptr.getClass().insertObject (ptr, model, rotation, physics); ptr.getClass().insertObject (ptr, model, rotation, physics);
MWBase::Environment::get().getLuaManager()->objectAddedToScene(ptr); MWBase::Environment::get().getLuaManager()->objectAddedToScene(ptr);
@ -201,11 +194,10 @@ namespace
{ {
MWWorld::CellStore& mCell; MWWorld::CellStore& mCell;
Loading::Listener* mLoadingListener; Loading::Listener* mLoadingListener;
bool mOnlyObjects;
std::vector<MWWorld::Ptr> mToInsert; std::vector<MWWorld::Ptr> mToInsert;
InsertVisitor (MWWorld::CellStore& cell, Loading::Listener* loadingListener, bool onlyObjects); InsertVisitor (MWWorld::CellStore& cell, Loading::Listener* loadingListener);
bool operator() (const MWWorld::Ptr& ptr); bool operator() (const MWWorld::Ptr& ptr);
@ -213,8 +205,8 @@ namespace
void insert(AddObject&& addObject); void insert(AddObject&& addObject);
}; };
InsertVisitor::InsertVisitor (MWWorld::CellStore& cell, Loading::Listener* loadingListener, bool onlyObjects) InsertVisitor::InsertVisitor (MWWorld::CellStore& cell, Loading::Listener* loadingListener)
: mCell(cell), mLoadingListener(loadingListener), mOnlyObjects(onlyObjects) : mCell(cell), mLoadingListener(loadingListener)
{} {}
bool InsertVisitor::operator() (const MWWorld::Ptr& ptr) bool InsertVisitor::operator() (const MWWorld::Ptr& ptr)
@ -230,7 +222,7 @@ namespace
{ {
for (MWWorld::Ptr& ptr : mToInsert) for (MWWorld::Ptr& ptr : mToInsert)
{ {
if (!ptr.getRefData().isDeleted() && ptr.getRefData().isEnabled() && (!mOnlyObjects || !ptr.getClass().isActor())) if (!ptr.getRefData().isDeleted() && ptr.getRefData().isEnabled())
{ {
try try
{ {
@ -248,16 +240,6 @@ namespace
} }
} }
struct PositionVisitor
{
bool operator() (const MWWorld::Ptr& ptr)
{
if (!ptr.getRefData().isDeleted() && ptr.getRefData().isEnabled())
ptr.getClass().adjustPosition (ptr, false);
return true;
}
};
int getCellPositionDistanceToOrigin(const std::pair<int, int>& cellPosition) int getCellPositionDistanceToOrigin(const std::pair<int, int>& cellPosition)
{ {
return std::abs(cellPosition.first) + std::abs(cellPosition.second); return std::abs(cellPosition.first) + std::abs(cellPosition.second);
@ -324,39 +306,12 @@ namespace MWWorld
mRendering.update (duration, paused); mRendering.update (duration, paused);
} }
void Scene::unloadInactiveCell (CellStore* cell) void Scene::unloadCell(CellStore* cell)
{ {
assert(mActiveCells.find(cell) == mActiveCells.end());
assert(mInactiveCells.find(cell) != mInactiveCells.end());
Log(Debug::Info) << "Unloading cell " << cell->getCell()->getDescription();
ListObjectsVisitor visitor;
cell->forEach(visitor);
for (const auto& ptr : visitor.mObjects)
{
mPhysics->remove(ptr);
ptr.mRef->mData.mPhysicsPostponed = false;
}
if (cell->getCell()->isExterior())
{
const auto cellX = cell->getCell()->getGridX();
const auto cellY = cell->getCell()->getGridY();
mPhysics->removeHeightField(cellX, cellY);
}
mInactiveCells.erase(cell);
}
void Scene::deactivateCell(CellStore* cell)
{
assert(mInactiveCells.find(cell) != mInactiveCells.end());
if (mActiveCells.find(cell) == mActiveCells.end()) if (mActiveCells.find(cell) == mActiveCells.end())
return; return;
Log(Debug::Info) << "Deactivate cell " << cell->getCell()->getDescription(); Log(Debug::Info) << "Unloading cell " << cell->getCell()->getDescription();
ListAndResetObjectsVisitor visitor; ListAndResetObjectsVisitor visitor;
@ -367,8 +322,8 @@ namespace MWWorld
if (const auto object = mPhysics->getObject(ptr)) if (const auto object = mPhysics->getObject(ptr))
{ {
mNavigator.removeObject(DetourNavigator::ObjectId(object)); mNavigator.removeObject(DetourNavigator::ObjectId(object));
if (object->isAnimated())
mPhysics->remove(ptr); mPhysics->remove(ptr);
ptr.mRef->mData.mPhysicsPostponed = false;
} }
else if (mPhysics->getActor(ptr)) else if (mPhysics->getActor(ptr))
{ {
@ -386,6 +341,8 @@ namespace MWWorld
{ {
if (mPhysics->getHeightField(cellX, cellY) != nullptr) if (mPhysics->getHeightField(cellX, cellY) != nullptr)
mNavigator.removeHeightfield(osg::Vec2i(cellX, cellY)); mNavigator.removeHeightfield(osg::Vec2i(cellX, cellY));
mPhysics->removeHeightField(cellX, cellY);
} }
if (cell->getCell()->hasWater()) if (cell->getCell()->hasWater())
@ -408,12 +365,11 @@ namespace MWWorld
mActiveCells.erase(cell); mActiveCells.erase(cell);
} }
void Scene::activateCell(CellStore *cell, Loading::Listener* loadingListener, bool respawn) void Scene::loadCell(CellStore *cell, Loading::Listener* loadingListener, bool respawn)
{ {
using DetourNavigator::HeightfieldShape; using DetourNavigator::HeightfieldShape;
assert(mActiveCells.find(cell) == mActiveCells.end()); assert(mActiveCells.find(cell) == mActiveCells.end());
assert(mInactiveCells.find(cell) != mInactiveCells.end());
mActiveCells.insert(cell); mActiveCells.insert(cell);
Log(Debug::Info) << "Loading cell " << cell->getCell()->getDescription(); Log(Debug::Info) << "Loading cell " << cell->getCell()->getDescription();
@ -425,13 +381,25 @@ namespace MWWorld
if (cell->getCell()->isExterior()) if (cell->getCell()->isExterior())
{ {
osg::ref_ptr<const ESMTerrain::LandObject> land = mRendering.getLandManager()->getLand(cellX, cellY);
const ESM::Land::LandData* data = land ? land->getData(ESM::Land::DATA_VHGT) : nullptr;
const float verts = ESM::Land::LAND_SIZE;
const float worldsize = ESM::Land::REAL_SIZE;
if (data)
{
mPhysics->addHeightField (data->mHeights, cellX, cellY, worldsize / (verts-1), verts, data->mMinHeight, data->mMaxHeight, land.get());
}
else
{
static std::vector<float> defaultHeight;
defaultHeight.resize(verts*verts, ESM::Land::DEFAULT_HEIGHT);
mPhysics->addHeightField (&defaultHeight[0], cellX, cellY, worldsize / (verts-1), verts, ESM::Land::DEFAULT_HEIGHT, ESM::Land::DEFAULT_HEIGHT, land.get());
}
if (const auto heightField = mPhysics->getHeightField(cellX, cellY)) if (const auto heightField = mPhysics->getHeightField(cellX, cellY))
{ {
const osg::Vec2i cellPosition(cellX, cellY); const osg::Vec2i cellPosition(cellX, cellY);
const btVector3& origin = heightField->getCollisionObject()->getWorldTransform().getOrigin(); const btVector3& origin = heightField->getCollisionObject()->getWorldTransform().getOrigin();
const osg::Vec3f shift(origin.x(), origin.y(), origin.z()); const osg::Vec3f shift(origin.x(), origin.y(), origin.z());
const osg::ref_ptr<const ESMTerrain::LandObject> land = mRendering.getLandManager()->getLand(cellX, cellY);
const ESM::Land::LandData* const data = land == nullptr ? nullptr : land->getData(ESM::Land::DATA_VHGT);
const HeightfieldShape shape = [&] () -> HeightfieldShape const HeightfieldShape shape = [&] () -> HeightfieldShape
{ {
if (data == nullptr) if (data == nullptr)
@ -462,7 +430,7 @@ namespace MWWorld
if (respawn) if (respawn)
cell->respawn(); cell->respawn();
insertCell(*cell, loadingListener, false); insertCell(*cell, loadingListener);
mRendering.addCell(cell); mRendering.addCell(cell);
@ -511,49 +479,14 @@ namespace MWWorld
mPreloader->notifyLoaded(cell); mPreloader->notifyLoaded(cell);
} }
void Scene::loadInactiveCell(CellStore *cell, Loading::Listener* loadingListener)
{
assert(mActiveCells.find(cell) == mActiveCells.end());
assert(mInactiveCells.find(cell) == mInactiveCells.end());
mInactiveCells.insert(cell);
Log(Debug::Info) << "Loading inactive cell " << cell->getCell()->getDescription();
if (cell->getCell()->isExterior())
{
float verts = ESM::Land::LAND_SIZE;
float worldsize = ESM::Land::REAL_SIZE;
const int cellX = cell->getCell()->getGridX();
const int cellY = cell->getCell()->getGridY();
osg::ref_ptr<const ESMTerrain::LandObject> land = mRendering.getLandManager()->getLand(cellX, cellY);
const ESM::Land::LandData* data = land ? land->getData(ESM::Land::DATA_VHGT) : nullptr;
if (data)
{
mPhysics->addHeightField (data->mHeights, cellX, cellY, worldsize / (verts-1), verts, data->mMinHeight, data->mMaxHeight, land.get());
}
else
{
static std::vector<float> defaultHeight;
defaultHeight.resize(verts*verts, ESM::Land::DEFAULT_HEIGHT);
mPhysics->addHeightField (&defaultHeight[0], cellX, cellY, worldsize / (verts-1), verts, ESM::Land::DEFAULT_HEIGHT, ESM::Land::DEFAULT_HEIGHT, land.get());
}
}
insertCell(*cell, loadingListener, true);
}
void Scene::clear() void Scene::clear()
{ {
for (auto iter = mInactiveCells.begin(); iter!=mInactiveCells.end(); ) for (auto iter = mActiveCells.begin(); iter!=mActiveCells.end(); )
{ {
auto* cell = *iter++; auto* cell = *iter++;
deactivateCell(cell); unloadCell (cell);
unloadInactiveCell (cell);
} }
assert(mActiveCells.empty()); assert(mActiveCells.empty());
assert(mInactiveCells.empty());
mCurrentCell = nullptr; mCurrentCell = nullptr;
mPreloader->clear(); mPreloader->clear();
@ -595,7 +528,7 @@ namespace MWWorld
void Scene::changeCellGrid (const osg::Vec3f &pos, int playerCellX, int playerCellY, bool changeEvent) void Scene::changeCellGrid (const osg::Vec3f &pos, int playerCellX, int playerCellY, bool changeEvent)
{ {
for (auto iter = mInactiveCells.begin(); iter != mInactiveCells.end(); ) for (auto iter = mActiveCells.begin(); iter != mActiveCells.end(); )
{ {
auto* cell = *iter++; auto* cell = *iter++;
if (cell->getCell()->isExterior()) if (cell->getCell()->isExterior())
@ -603,16 +536,10 @@ namespace MWWorld
const auto dx = std::abs(playerCellX - cell->getCell()->getGridX()); const auto dx = std::abs(playerCellX - cell->getCell()->getGridX());
const auto dy = std::abs(playerCellY - cell->getCell()->getGridY()); const auto dy = std::abs(playerCellY - cell->getCell()->getGridY());
if (dx > mHalfGridSize || dy > mHalfGridSize) if (dx > mHalfGridSize || dy > mHalfGridSize)
deactivateCell(cell); unloadCell(cell);
if (dx > mHalfGridSize+1 || dy > mHalfGridSize+1)
unloadInactiveCell(cell);
} }
else else
{ unloadCell (cell);
deactivateCell(cell);
unloadInactiveCell(cell);
}
} }
mCurrentGridCenter = osg::Vec2i(playerCellX, playerCellY); mCurrentGridCenter = osg::Vec2i(playerCellX, playerCellY);
@ -662,7 +589,6 @@ namespace MWWorld
} }
auto cellsPositionsToLoad = cellsToLoad(mActiveCells,mHalfGridSize); auto cellsPositionsToLoad = cellsToLoad(mActiveCells,mHalfGridSize);
auto cellsPositionsToLoadInactive = cellsToLoad(mInactiveCells,mHalfGridSize+1);
Loading::Listener* loadingListener = MWBase::Environment::get().getWindowManager()->getLoadingScreen(); Loading::Listener* loadingListener = MWBase::Environment::get().getWindowManager()->getLoadingScreen();
Loading::ScopedLoad load(loadingListener); Loading::ScopedLoad load(loadingListener);
@ -685,26 +611,12 @@ namespace MWWorld
return getCellPositionPriority(lhs) < getCellPositionPriority(rhs); return getCellPositionPriority(lhs) < getCellPositionPriority(rhs);
}); });
std::sort(cellsPositionsToLoadInactive.begin(), cellsPositionsToLoadInactive.end(),
[&] (const std::pair<int, int>& lhs, const std::pair<int, int>& rhs) {
return getCellPositionPriority(lhs) < getCellPositionPriority(rhs);
});
// Load cells
for (const auto& [x,y] : cellsPositionsToLoadInactive)
{
if (!isCellInCollection(x, y, mInactiveCells))
{
CellStore *cell = MWBase::Environment::get().getWorld()->getExterior(x, y);
loadInactiveCell (cell, loadingListener);
}
}
for (const auto& [x,y] : cellsPositionsToLoad) for (const auto& [x,y] : cellsPositionsToLoad)
{ {
if (!isCellInCollection(x, y, mActiveCells)) if (!isCellInCollection(x, y, mActiveCells))
{ {
CellStore *cell = MWBase::Environment::get().getWorld()->getExterior(x, y); CellStore *cell = MWBase::Environment::get().getWorld()->getExterior(x, y);
activateCell (cell, loadingListener, changeEvent); loadCell (cell, loadingListener, changeEvent);
} }
} }
@ -737,17 +649,15 @@ namespace MWWorld
loadingListener->setLabel("Testing exterior cells ("+std::to_string(i)+"/"+std::to_string(cells.getExtSize())+")..."); loadingListener->setLabel("Testing exterior cells ("+std::to_string(i)+"/"+std::to_string(cells.getExtSize())+")...");
CellStore *cell = MWBase::Environment::get().getWorld()->getExterior(it->mData.mX, it->mData.mY); CellStore *cell = MWBase::Environment::get().getWorld()->getExterior(it->mData.mX, it->mData.mY);
loadInactiveCell(cell, nullptr); loadCell(cell, nullptr, false);
activateCell(cell, nullptr, false);
auto iter = mInactiveCells.begin(); auto iter = mActiveCells.begin();
while (iter != mInactiveCells.end()) while (iter != mActiveCells.end())
{ {
if (it->isExterior() && it->mData.mX == (*iter)->getCell()->getGridX() && if (it->isExterior() && it->mData.mX == (*iter)->getCell()->getGridX() &&
it->mData.mY == (*iter)->getCell()->getGridY()) it->mData.mY == (*iter)->getCell()->getGridY())
{ {
deactivateCell(*iter); unloadCell(*iter);
unloadInactiveCell(*iter);
break; break;
} }
@ -785,18 +695,16 @@ namespace MWWorld
loadingListener->setLabel("Testing interior cells ("+std::to_string(i)+"/"+std::to_string(cells.getIntSize())+")..."); loadingListener->setLabel("Testing interior cells ("+std::to_string(i)+"/"+std::to_string(cells.getIntSize())+")...");
CellStore *cell = MWBase::Environment::get().getWorld()->getInterior(it->mName); CellStore *cell = MWBase::Environment::get().getWorld()->getInterior(it->mName);
loadInactiveCell(cell, nullptr); loadCell(cell, nullptr, false);
activateCell(cell, nullptr, false);
auto iter = mInactiveCells.begin(); auto iter = mActiveCells.begin();
while (iter != mInactiveCells.end()) while (iter != mActiveCells.end())
{ {
assert (!(*iter)->getCell()->isExterior()); assert (!(*iter)->getCell()->isExterior());
if (it->mName == (*iter)->getCell()->mName) if (it->mName == (*iter)->getCell()->mName)
{ {
deactivateCell(*iter); unloadCell(*iter);
unloadInactiveCell(*iter);
break; break;
} }
@ -915,11 +823,10 @@ namespace MWWorld
Log(Debug::Info) << "Changing to interior"; Log(Debug::Info) << "Changing to interior";
// unload // unload
for (auto iter = mInactiveCells.begin(); iter!=mInactiveCells.end(); ) for (auto iter = mActiveCells.begin(); iter!=mActiveCells.end(); )
{ {
auto* cellToUnload = *iter++; auto* cellToUnload = *iter++;
deactivateCell(cellToUnload); unloadCell(cellToUnload);
unloadInactiveCell(cellToUnload);
} }
assert(mActiveCells.empty()); assert(mActiveCells.empty());
assert(mInactiveCells.empty()); assert(mInactiveCells.empty());
@ -928,8 +835,7 @@ namespace MWWorld
// Load cell. // Load cell.
mPagedRefs.clear(); mPagedRefs.clear();
loadInactiveCell (cell, loadingListener); loadCell(cell, loadingListener, changeEvent);
activateCell (cell, loadingListener, changeEvent);
changePlayerCell(cell, position, adjustPlayerPos); changePlayerCell(cell, position, adjustPlayerPos);
@ -979,26 +885,19 @@ namespace MWWorld
mCellChanged = false; mCellChanged = false;
} }
void Scene::insertCell (CellStore &cell, Loading::Listener* loadingListener, bool onlyObjects) void Scene::insertCell (CellStore &cell, Loading::Listener* loadingListener)
{ {
InsertVisitor insertVisitor(cell, loadingListener, onlyObjects); InsertVisitor insertVisitor(cell, loadingListener);
cell.forEach (insertVisitor); cell.forEach (insertVisitor);
insertVisitor.insert([&] (const MWWorld::Ptr& ptr) { addObject(ptr, *mPhysics, mRendering, mPagedRefs, onlyObjects); }); insertVisitor.insert([&] (const MWWorld::Ptr& ptr) { addObject(ptr, *mPhysics, mRendering, mPagedRefs); });
if (!onlyObjects)
{
insertVisitor.insert([&] (const MWWorld::Ptr& ptr) { addObject(ptr, *mPhysics, mNavigator); }); insertVisitor.insert([&] (const MWWorld::Ptr& ptr) { addObject(ptr, *mPhysics, mNavigator); });
// do adjustPosition (snapping actors to ground) after objects are loaded, so we don't depend on the loading order
PositionVisitor posVisitor;
cell.forEach (posVisitor);
}
} }
void Scene::addObjectToScene (const Ptr& ptr) void Scene::addObjectToScene (const Ptr& ptr)
{ {
try try
{ {
addObject(ptr, *mPhysics, mRendering, mPagedRefs, false); addObject(ptr, *mPhysics, mRendering, mPagedRefs);
addObject(ptr, *mPhysics, mNavigator); addObject(ptr, *mPhysics, mNavigator);
MWBase::Environment::get().getWorld()->scaleObject(ptr, ptr.getCellRef().getScale()); MWBase::Environment::get().getWorld()->scaleObject(ptr, ptr.getCellRef().getScale());
const auto player = MWBase::Environment::get().getWorld()->getPlayerPtr(); const auto player = MWBase::Environment::get().getWorld()->getPlayerPtr();

9
apps/openmw/mwworld/scene.hpp
View file

@ -77,7 +77,6 @@ namespace MWWorld
CellStore* mCurrentCell; // the cell the player is in CellStore* mCurrentCell; // the cell the player is in
CellStoreCollection mActiveCells; CellStoreCollection mActiveCells;
CellStoreCollection mInactiveCells;
bool mCellChanged; bool mCellChanged;
MWPhysics::PhysicsSystem *mPhysics; MWPhysics::PhysicsSystem *mPhysics;
MWRender::RenderingManager& mRendering; MWRender::RenderingManager& mRendering;
@ -100,7 +99,7 @@ namespace MWWorld
std::vector<osg::ref_ptr<SceneUtil::WorkItem>> mWorkItems; std::vector<osg::ref_ptr<SceneUtil::WorkItem>> mWorkItems;
void insertCell(CellStore &cell, Loading::Listener* loadingListener, bool onlyObjects); void insertCell(CellStore &cell, Loading::Listener* loadingListener);
osg::Vec2i mCurrentGridCenter; osg::Vec2i mCurrentGridCenter;
// Load and unload cells as necessary to create a cell grid with "X" and "Y" in the center // Load and unload cells as necessary to create a cell grid with "X" and "Y" in the center
@ -116,10 +115,8 @@ namespace MWWorld
osg::Vec4i gridCenterToBounds(const osg::Vec2i &centerCell) const; osg::Vec4i gridCenterToBounds(const osg::Vec2i &centerCell) const;
osg::Vec2i getNewGridCenter(const osg::Vec3f &pos, const osg::Vec2i *currentGridCenter = nullptr) const; osg::Vec2i getNewGridCenter(const osg::Vec3f &pos, const osg::Vec2i *currentGridCenter = nullptr) const;
void unloadInactiveCell(CellStore* cell); void unloadCell(CellStore* cell);
void deactivateCell(CellStore* cell); void loadCell(CellStore *cell, Loading::Listener* loadingListener, bool respawn);
void activateCell(CellStore *cell, Loading::Listener* loadingListener, bool respawn);
void loadInactiveCell(CellStore *cell, Loading::Listener* loadingListener);
public: public: