GEEKING

Network/Replicator.GCJob.h

@@ -0,0 +1,105 @@
+#pragma once
+
+#include "ClientReplicator.h"
+#include "Util.h"
+#include "V8World/ContactManagerSpatialHash.h"
+#include "Util/StreamRegion.h"
+#include "GfxBase/IAdornable.h"
+#include <vector>
+
+
+namespace RBX {
+
+namespace Network {
+	
+    static const float kMaxRegionExpansionTimerLimit = 10.f;
+    static const float kRenderingDistanceUpdateInterval = 1.f;
+	struct RegionInfo
+	{
+		float distance;
+        int streamDistance;
+		StreamRegion::Id id;
+
+		explicit RegionInfo(StreamRegion::Id id) : id(id) {}
+
+		bool operator==(const RegionInfo& other) const
+		{
+			return id == other.id;
+		}
+
+        void computeRegionDistance(const StreamRegion::Id& focus)
+        {
+            streamDistance = StreamRegion::Id::getRegionLongestAxisDistance(id, focus);
+        }
+	};
+
+	typedef boost::unordered_map<StreamRegion::Id, RegionInfo> RegionsMap;
+	typedef std::list<RegionsMap::iterator> RegionList;
+
+	class ClientReplicator::GCJob : public ReplicatorJob,
+		public ContactManagerSpatialHash::CoarseMovementCallback
+	{	
+		ContactManagerSpatialHash* spatialHash;
+		RegionsMap streamedRegions;
+		RegionList streamedRegionList;
+
+		Vector3 lastPlayerPosition;
+		int numSorted;
+        int numRegionToGC;
+        float* renderingDistance;
+        float renderingRegionDistance;
+        short gcRegionDistance;
+        short maxRegionDistance;
+        StreamRegion::Id centerRegion;
+
+        RBX::Timer<RBX::Time::Fast> maxRegionExpansionTimer;
+        RBX::Timer<RBX::Time::Fast> renderingDistanceUpdateTimer;
+
+        std::vector<shared_ptr<PartInstance> > pendingRemovalPartInstances;
+
+		class RegionRemovalItem;
+		class InstanceRemovalItem;
+	
+	public:	
+		GCJob(Replicator& replicator);
+		virtual ~GCJob();
+		void insertRegion(const StreamRegion::Id& id);
+
+		// implement CoarseMovementCallback
+		virtual void coarsePrimitiveMovement(Primitive* p, const UpdateInfo& info);
+
+		void render3dAdorn(Adorn* adorn);
+        bool pendingGC()
+        {
+            return (numRegionToGC > 0);
+        }
+        void evaluateNumRegionToGC();
+
+        short getMaxRegionDistance() { return maxRegionDistance; }
+        bool updateMaxRegionDistance();
+        void updateGcRegionDistance();
+		void notifyServerGcingInstanceAndDescendants(shared_ptr<Instance> instance);
+
+        void unregisterCoarseMovementCallback();
+
+		// debug
+		int getNumRegionsToGC() { return numRegionToGC; }
+		short getGCDistance() { return gcRegionDistance; }
+		int getNumRegions() { return streamedRegionList.size(); }
+	
+	private:
+		virtual Time::Interval sleepTime(const Stats& stats)
+		{
+			return computeStandardSleepTime(stats, replicator->settings().getDataGCRate());
+		}
+		virtual Error error(const Stats& stats);
+		virtual TaskScheduler::StepResult stepDataModelJob(const Stats& stats);
+
+		void gcRegion(const StreamRegion::Id& regionId, RegionRemovalItem* removeItem);
+		void gcPartInstance(PartInstance* partInstance, RegionRemovalItem* removeItem);
+
+		void setMaxSimulationRadius(float radius);
+	};
+
+
+}} // name spaces