Don't tween entities that are not visible on screen or when zoomed out

src/openrct2/entity/EntityTweener.cpp

@@ -10,6 +10,8 @@
 
 #include "../entity/Guest.h"
 #include "../entity/Staff.h"
+#include "../interface/Viewport.h"
+#include "../interface/Window.h"
 #include "../ride/Vehicle.h"
 #include "EntityList.h"
 #include "EntityRegistry.h"
@@ -17,37 +19,91 @@
 #include <algorithm>
 #include <cmath>
 
-void EntityTweener::AddEntity(EntityBase* entity)
+namespace OpenRCT2
 {
+    static inline ViewportList GetUnzoomedViewports() noexcept
+    {
+        ViewportList viewports;
+        WindowVisitEach([&](WindowBase* w) {
+            if (auto* vp = WindowGetViewport(w); vp != nullptr)
+            {
+                if (!vp->isVisible)
+                {
+                    // Ignore viewports that are not visible.
+                    return;
+                }
+                if (vp->zoom > ZoomLevel{ 0 })
+                {
+                    // Ignore viewports that are zoomed out, interpolation wouldn't have much of an effect
+                    // due to the loss of detail.
+                    return;
+                }
+                viewports.push_back(vp);
+            }
+        });
+        return viewports;
+    }
+
+    static inline bool IsEntityVisible(const ViewportList& vpList, const EntityBase* entity) noexcept
+    {
+        const auto worldLoc = entity->GetLocation();
+
+        for (const auto* vp : vpList)
+        {
+            const auto screenPos = Translate3DTo2DWithZ(vp->rotation, worldLoc);
+            if (vp->Contains(screenPos))
+            {
+                // Entity is visible in at least one viewport, tween.
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    void EntityTweener::AddEntity(const ViewportList& vpList, EntityBase* entity)
+    {
+        if (!IsEntityVisible(vpList, entity))
+        {
+            return;
+        }
+
         Entities.push_back(entity);
         PrePos.emplace_back(entity->GetLocation());
-}
+    }
+
+    void EntityTweener::PopulateEntities()
+    {
+        const auto vpList = GetUnzoomedViewports();
+        if (vpList.empty())
+        {
+            // No viewports that fit the criteria, bail.
+            return;
+        }
 
-void EntityTweener::PopulateEntities()
-{
         for (auto ent : EntityList<Guest>())
         {
-        AddEntity(ent);
+            AddEntity(vpList, ent);
         }
         for (auto ent : EntityList<Staff>())
         {
-        AddEntity(ent);
+            AddEntity(vpList, ent);
         }
         for (auto ent : EntityList<Vehicle>())
         {
-        AddEntity(ent);
+            AddEntity(vpList, ent);
+        }
     }
-}
 
-void EntityTweener::PreTick()
-{
+    void EntityTweener::PreTick()
+    {
         Restore();
         Reset();
         PopulateEntities();
-}
+    }
 
-void EntityTweener::PostTick()
-{
+    void EntityTweener::PostTick()
+    {
         for (auto* ent : Entities)
         {
             if (ent == nullptr)
@@ -60,17 +116,17 @@ void EntityTweener::PostTick()
                 PostPos.emplace_back(ent->GetLocation());
             }
         }
-}
+    }
 
-static bool CanTweenEntity(EntityBase* ent)
-{
+    static bool CanTweenEntity(EntityBase* ent)
+    {
         if (ent->Is<Guest>() || ent->Is<Staff>() || ent->Is<Vehicle>())
             return true;
         return false;
-}
+    }
 
-void EntityTweener::RemoveEntity(EntityBase* entity)
-{
+    void EntityTweener::RemoveEntity(EntityBase* entity)
+    {
         if (!CanTweenEntity(entity))
         {
             // Only peeps and vehicles are tweened, bail if type is incorrect.
@@ -80,10 +136,10 @@ void EntityTweener::RemoveEntity(EntityBase* entity)
         auto it = std::find(Entities.begin(), Entities.end(), entity);
         if (it != Entities.end())
             *it = nullptr;
-}
+    }
 
-void EntityTweener::Tween(float alpha)
-{
+    void EntityTweener::Tween(float alpha)
+    {
         const float inv = (1.0f - alpha);
         for (size_t i = 0; i < Entities.size(); ++i)
         {
@@ -101,10 +157,10 @@ void EntityTweener::Tween(float alpha)
                           static_cast<int32_t>(std::round(posB.y * alpha + posA.y * inv)),
                           static_cast<int32_t>(std::round(posB.z * alpha + posA.z * inv)) });
         }
-}
+    }
 
-void EntityTweener::Restore()
-{
+    void EntityTweener::Restore()
+    {
         for (size_t i = 0; i < Entities.size(); ++i)
         {
             auto* ent = Entities[i];
@@ -113,18 +169,20 @@ void EntityTweener::Restore()
 
             ent->MoveTo(PostPos[i]);
         }
-}
+    }
 
-void EntityTweener::Reset()
-{
+    void EntityTweener::Reset()
+    {
         Entities.clear();
         PrePos.clear();
         PostPos.clear();
-}
+    }
 
-static EntityTweener tweener;
+    static EntityTweener tweener;
 
-EntityTweener& EntityTweener::Get()
-{
+    EntityTweener& EntityTweener::Get()
+    {
         return tweener;
-}
+    }
+
+} // namespace OpenRCT2

src/openrct2/entity/EntityTweener.h

@@ -9,21 +9,30 @@
 
 #pragma once
 
+#include "../interface/Window.h"
 #include "EntityBase.h"
 
+#include <sfl/static_vector.hpp>
 #include <vector>
 
-class EntityTweener
+namespace OpenRCT2
 {
+    struct Viewport;
+
+    // TODO: Move this to somewhere else, currently filters also by zoom.
+    using ViewportList = sfl::static_vector<Viewport*, kWindowLimitMax>;
+
+    class EntityTweener
+    {
         std::vector<EntityBase*> Entities;
         std::vector<CoordsXYZ> PrePos;
         std::vector<CoordsXYZ> PostPos;
 
-private:
+    private:
         void PopulateEntities();
-    void AddEntity(EntityBase* entity);
+        void AddEntity(const ViewportList& vp, EntityBase* entity);
 
-public:
+    public:
         static EntityTweener& Get();
 
         void PreTick();
@@ -32,4 +41,6 @@ public:
         void Tween(float alpha);
         void Restore();
         void Reset();
-};
+    };
+
+} // namespace OpenRCT2