GEEKING

Rendering/GfxRender/SpatialHashedScene.cpp

@@ -0,0 +1,265 @@
+#include "stdafx.h"
+#include "SpatialHashedScene.h"
+
+#include "v8World/SpatialHashMultiRes.h"
+#include "v8World/Contact.h"
+
+#include "GfxBase/FrameRateManager.h"
+
+#include "CullableSceneNode.h"
+#include "Util.h"
+#include "RenderCamera.h"
+
+#include "rbx/DenseHash.h"
+
+#include "rbx/Profiler.h"
+
+namespace RBX
+{
+namespace Graphics
+{
+
+#define GFXSPATIALHASHLEVELS 4
+#define GFXSPATIALHASH_MAX_CELLS_PER_PRIMITIVE 8
+
+class GfxSpatialHash : public RBX::SpatialHash<CullableSceneNode, RBX::Contact, RBX::ContactManager, GFXSPATIALHASHLEVELS>
+{
+public:
+    GfxSpatialHash()
+    : SpatialHash<CullableSceneNode, Contact, ContactManager, GFXSPATIALHASHLEVELS>(NULL, NULL, GFXSPATIALHASH_MAX_CELLS_PER_PRIMITIVE)
+	{
+	}
+};
+
+// 3 for 3D.
+// this cooresponds to 8x8x8 spatial hash blocks at the root level.
+const float SpatialHashedScene::maxAdmissibleVolume = pow((float)(8 <<GFXSPATIALHASHLEVELS), 3);
+// this corresponds to 22 spatial hash blocks at the root level.
+const float SpatialHashedScene::maxAdmissibleLength = (float)(22 <<GFXSPATIALHASHLEVELS);
+
+int SpatialHashedScene::globalFrameNumber = 0;
+
+SpatialHashedScene::SpatialHashedScene()
+{
+    spatialHash.reset(new GfxSpatialHash());
+}
+
+SpatialHashedScene::~SpatialHashedScene()
+{
+}
+
+bool SpatialHashedScene::isAdmissible(CullableSceneNode* child)
+{
+    const Extents& extents = child->getFastFuzzyExtents();
+
+    return !extents.isNull() && extents.volume() < maxAdmissibleVolume && extents.longestSide() < maxAdmissibleLength;
+}
+
+void SpatialHashedScene::internalUpdateChild(CullableSceneNode* child)
+{
+    if (child->IsInSpatialHash())
+    {
+        if (isAdmissible(child))
+        {
+            spatialHash->onPrimitiveExtentsChanged(child);
+        }
+        else
+        {
+            spatialHash->onPrimitiveRemoved(child);
+
+            unhashedNodes.insert(child);
+        }
+    }
+	else if (isAdmissible(child))
+    {
+		unhashedNodes.erase(child);
+        
+        spatialHash->onPrimitiveAdded(child);
+    }
+	else
+	{
+		unhashedNodes.insert(child);
+	}
+}
+
+void SpatialHashedScene::internalRemoveChild(CullableSceneNode* child)
+{
+    if (child->IsInSpatialHash())
+    {
+        spatialHash->onPrimitiveRemoved(child);
+    }
+    else
+    {
+		unhashedNodes.erase(child);
+    }
+}
+
+struct FrustumVisitor: public GfxSpatialHash::SpaceFilter
+{
+    std::vector<CullableSceneNode*>& nodes;
+    const RenderCamera& camera;
+    Vector3 pointOfInterest;
+    FrameRateManager* frm;
+    int frameNumber;
+
+	FrustumVisitor(std::vector<CullableSceneNode*>& nodes, const RenderCamera& camera, const Vector3& pointOfInterest, FrameRateManager* frm, int frameNumber)
+        : nodes(nodes)
+        , camera(camera)
+		, pointOfInterest(pointOfInterest)
+		, frm(frm)
+        , frameNumber(frameNumber)
+    {
+    }
+
+    IntersectResult Intersects(const Extents& extents)
+    {
+        return camera.intersects(extents);
+    }
+
+    float Distance(const Extents& extents)
+    {
+		return extents.computeClosestSqDistanceToPoint(pointOfInterest);
+    }
+
+    // return false to break iteration.
+    bool onPrimitive(CullableSceneNode* n, IntersectResult intersectResult, float distance)
+    {
+        // framenum check to eliminate double-visits.
+        if (n->lastFrustumVisibleFrameNumber < frameNumber)
+        {
+            n->lastFrustumVisibleFrameNumber = frameNumber;
+            
+            if (intersectResult == irFull || camera.isVisible(n->getWorldBounds()))
+                nodes.push_back(n);
+
+			if (distance > frm->GetViewCullSqDistance())
+                return false;
+
+            return true;
+        }
+
+        return true;
+    }
+};
+
+void SpatialHashedScene::queryFrustumOrdered(std::vector<CullableSceneNode*>& nodes, const RenderCamera& camera, const Vector3& pointOfInterest, FrameRateManager* frm)
+{
+    RBXPROFILER_SCOPE("Render", "queryFrustumOrdered");
+
+    for (UnhashedNodes::iterator it = unhashedNodes.begin(); it != unhashedNodes.end(); ++it)
+    {
+        CullableSceneNode* n = *it;
+        
+        if (camera.isVisible(n->getWorldBounds()))
+            nodes.push_back(n);
+    }
+
+    FrustumVisitor visitor(nodes, camera, pointOfInterest, frm, getNextFrame());
+
+    spatialHash->visitPrimitivesInSpace(&visitor);
+}
+
+static bool sphereIntersects(const Vector3& center, float radius, const Extents& extents)
+{
+    float d = extents.computeClosestSqDistanceToPoint(center);
+
+    return d <= radius * radius;
+}
+
+void SpatialHashedScene::querySphere(std::vector<CullableSceneNode*>& nodes, const Vector3& center, float radius, unsigned int flags)
+{
+	RBXPROFILER_SCOPE("Render", "querySphere");
+
+	for (CullableSceneNode* node: unhashedNodes)
+	{
+		if ((node->getFlags() & flags) == flags && sphereIntersects(center, radius, node->getWorldBounds()))
+			nodes.push_back(node);
+	}
+
+	DenseHashSet<CullableSceneNode*> result(NULL);
+	spatialHash->getPrimitivesOverlappingRec(Extents::fromCenterRadius(center, radius), result);
+
+	for (CullableSceneNode* node: result)
+	{
+		if ((node->getFlags() & flags) == flags && sphereIntersects(center, radius, node->getWorldBounds()))
+			nodes.push_back(node);
+	}
+}
+
+void SpatialHashedScene::queryExtents(std::vector<CullableSceneNode*>& nodes, const Extents& extents, unsigned int flags)
+{
+	RBXPROFILER_SCOPE("Render", "queryExtents");
+
+    for (CullableSceneNode* node: unhashedNodes)
+    {
+        if ((node->getFlags() & flags) == flags && extents.overlapsOrTouches(node->getWorldBounds()))
+            nodes.push_back(node);
+    }
+    
+    DenseHashSet<CullableSceneNode*> result(NULL);
+    spatialHash->getPrimitivesOverlappingRec(extents, result);
+
+    for (CullableSceneNode* node: result)
+    {
+        if ((node->getFlags() & flags) == flags)
+            nodes.push_back(node);
+    }
+}
+
+std::vector<CullableSceneNode*> SpatialHashedScene::getAllNodes() const
+{
+    struct NodeVisitor: public GfxSpatialHash::SpaceFilter
+    {
+		std::vector<CullableSceneNode*>& result;
+        int frameNumber;
+
+		NodeVisitor(std::vector<CullableSceneNode*>& result, int frameNumber)
+            : result(result) 
+            , frameNumber(frameNumber)
+        {
+        }
+
+        IntersectResult Intersects(const Extents& extents)
+        {
+			return irFull;
+        }
+
+        float Distance(const Extents& extents)
+        {
+			return 0;
+        }
+
+        // return false to break iteration.
+        bool onPrimitive(CullableSceneNode* n, IntersectResult intersectResult, float distance)
+        {
+            // framenum check to eliminate double-visits.
+            if (n->lastFrustumVisibleFrameNumber < frameNumber)
+            {
+                n->lastFrustumVisibleFrameNumber = frameNumber;
+
+				result.push_back(n);
+            }
+
+            return true;
+        }
+	};
+
+	std::vector<CullableSceneNode*> result;
+
+    for (UnhashedNodes::iterator it = unhashedNodes.begin(); it != unhashedNodes.end(); ++it)
+		result.push_back(*it);
+
+	NodeVisitor visitor(result, getNextFrame());
+
+    spatialHash->visitPrimitivesInSpace(&visitor);
+
+    return result;
+}
+
+int SpatialHashedScene::getNextFrame()
+{
+	return ++globalFrameNumber;
+}
+
+}
+}