Refactoring

include/anki/core/App.h

@@ -7,7 +7,7 @@
 namespace anki {
 
 class StdinListener;
-class Scene;
+class SceneGraph;
 class Camera;
 class Input;
 

include/anki/renderer/MainRenderer.h

@@ -49,7 +49,7 @@ public:
 	/// The same as Renderer::render but in addition it renders the final
 	/// FAI to the framebuffer
 	/// @param scene @see Renderer::render
-	void render(Scene& scene);
+	void render(SceneGraph& scene);
 
 	/// Save the color buffer to a tga (lossless & uncompressed & slow)
 	/// or jpeg (lossy & compressed fast)

include/anki/renderer/Renderer.h

@@ -185,11 +185,11 @@ public:
 		return viewProjectionMat;
 	}
 
-	const Scene& getScene() const
+	const SceneGraph& getSceneGraph() const
 	{
 		return *scene;
 	}
-	Scene& getScene()
+	SceneGraph& getSceneGraph()
 	{
 		return *scene;
 	}
@@ -226,7 +226,7 @@ public:
 	void init(const RendererInitializer& initializer);
 
 	/// This function does all the rendering stages and produces a final FAI
-	void render(Scene& scene);
+	void render(SceneGraph& scene);
 
 	/// My version of gluUnproject
 	/// @param windowCoords Window screen coords
@@ -299,7 +299,7 @@ protected:
 	U32 width;
 	/// Height of the rendering. Don't confuse with the window width
 	U32 height;
-	Scene* scene; ///< Current scene
+	SceneGraph* scene; ///< Current scene
 	RenderableDrawer sceneDrawer;
 	F32 lodDistance; ///< Distance that used to calculate the LOD
 

include/anki/scene/Camera.h

@@ -28,7 +28,7 @@ public:
 	/// @name Constructors/Destructor
 	/// @{
 	Camera(CameraType type_,
-		const char* name, Scene* scene, // SceneNode
+		const char* name, SceneGraph* scene, // SceneNode
 		U32 movableFlags, Movable* movParent, // Movable
 		Frustum* frustum); // Spatial & Frustumable
 
@@ -118,7 +118,7 @@ public:
 
 	/// @name Constructors
 	/// @{
-	PerspectiveCamera(const char* name, Scene* scene,
+	PerspectiveCamera(const char* name, SceneGraph* scene,
 		uint movableFlags, Movable* movParent);
 	/// @}
 
@@ -201,7 +201,7 @@ public:
 
 	/// @name Constructors
 	/// @{
-	OrthographicCamera(const char* name, Scene* scene,
+	OrthographicCamera(const char* name, SceneGraph* scene,
 		uint movableFlags, Movable* movParent);
 	/// @}
 

include/anki/scene/Light.h

@@ -39,7 +39,7 @@ public:
 	/// @name Constructors
 	/// @{
 	Light(LightType t, // Light
-		const char* name, Scene* scene, // Scene
+		const char* name, SceneGraph* scene, // Scene
 		U32 movableFlags, Movable* movParent, // Movable
 		CollisionShape* cs); // Spatial
 	/// @}
@@ -116,7 +116,7 @@ class PointLight: public Light
 public:
 	/// @name Constructors/Destructor
 	/// @{
-	PointLight(const char* name, Scene* scene,
+	PointLight(const char* name, SceneGraph* scene,
 		U32 movableFlags, Movable* movParent);
 	/// @}
 
@@ -163,7 +163,7 @@ public:
 
 	/// @name Constructors/Destructor
 	/// @{
-	SpotLight(const char* name, Scene* scene,
+	SpotLight(const char* name, SceneGraph* scene,
 		U32 movableFlags, Movable* movParent);
 	/// @}
 

include/anki/scene/ModelNode.h

@@ -22,7 +22,7 @@ public:
 	/// @name Constructors/Destructor
 	/// @{
 	ModelPatchNode(const ModelPatchBase* modelPatch_,
-		const char* name, Scene* scene, // Scene
+		const char* name, SceneGraph* scene, // Scene
 		U32 movableFlags, Movable* movParent); // Movable
 	/// @}
 
@@ -86,7 +86,7 @@ public:
 	/// @name Constructors/Destructor
 	/// @{
 	ModelNode(const char* modelFname,
-		const char* name, Scene* scene, // SceneNode
+		const char* name, SceneGraph* scene, // SceneNode
 		uint movableFlags, Movable* movParent); // Movable
 
 	virtual ~ModelNode();

include/anki/scene/ParticleEmitter.h

@@ -28,7 +28,7 @@ public:
 	ParticleBase(
 		ParticleType type,
 		// SceneNode
-		const char* name, Scene* scene, 
+		const char* name, SceneGraph* scene, 
 		// Movable
 		U32 movableFlags, Movable* movParent);
 
@@ -104,7 +104,7 @@ class ParticleSimple: public ParticleBase
 public:
 	ParticleSimple(
 		// SceneNode
-		const char* name, Scene* scene, 
+		const char* name, SceneGraph* scene, 
 		// Movable
 		U32 movableFlags, Movable* movParent);
 
@@ -125,7 +125,7 @@ class Particle: public ParticleBase, public RigidBody
 public:
 	Particle(
 		// SceneNode
-		const char* name, Scene* scene, 
+		const char* name, SceneGraph* scene, 
 		// Movable
 		U32 movableFlags, Movable* movParent,
 		// RigidBody
@@ -155,7 +155,7 @@ public:
 	ParticleEmitter(
 		const char* filename,
 		// SceneNode
-		const char* name, Scene* scene,
+		const char* name, SceneGraph* scene,
 		// Movable
 		U32 movableFlags, Movable* movParent);
 
@@ -217,8 +217,8 @@ private:
 
 	RenderableVariable* alphaRenderableVar = nullptr;
 
-	void createParticlesSimulation(Scene* scene);
-	void createParticlesSimpleSimulation(Scene* scene);
+	void createParticlesSimulation(SceneGraph* scene);
+	void createParticlesSimpleSimulation(SceneGraph* scene);
 };
 
 } // end namespace anki

include/anki/scene/Scene.h → include/anki/scene/SceneGraph.h

@@ -1,5 +1,5 @@
-#ifndef ANKI_SCENE_SCENE_H
-#define ANKI_SCENE_SCENE_H
+#ifndef ANKI_SCENE_SCENE_GRAPH_H
+#define ANKI_SCENE_SCENE_GRAPH_H
 
 #include "anki/scene/Common.h"
 #include "anki/scene/SceneNode.h"
@@ -19,8 +19,8 @@ class Camera;
 /// @addtogroup Scene
 /// @{
 
-/// The Scene contains all the dynamic entities
-class Scene
+/// The scene graph that  all the scene entities
+class SceneGraph
 {
 	friend class SceneNode;
 
@@ -37,8 +37,8 @@ public:
 
 	/// @name Constructors/Destructor
 	/// @{
-	Scene();
-	~Scene();
+	SceneGraph();
+	~SceneGraph();
 	/// @}
 
 	/// @name Accessors
@@ -201,7 +201,7 @@ private:
 	}
 };
 
-typedef Singleton<Scene> SceneSingleton;
+typedef Singleton<SceneGraph> SceneGraphSingleton;
 /// @}
 
 } // end namespace anki

include/anki/scene/SceneNode.h

@@ -7,7 +7,7 @@
 
 namespace anki {
 
-class Scene; // Don't include
+class SceneGraph; // Don't include
 
 // Components forward. Don't include
 class Movable;
@@ -32,7 +32,7 @@ public:
 	/// @param scene The scene that will register it
 	explicit SceneNode(
 		const char* name,
-		Scene* scene);
+		SceneGraph* scene);
 
 	/// Unregister node
 	virtual ~SceneNode();
@@ -45,7 +45,7 @@ public:
 		return name.c_str();
 	}
 
-	Scene& getScene()
+	SceneGraph& getSceneGraph()
 	{
 		return *scene;
 	}
@@ -140,7 +140,7 @@ protected:
 
 private:
 	SceneString name; ///< A unique name
-	Scene* scene = nullptr; ///< Keep it here for unregistering
+	SceneGraph* scene = nullptr; ///< Keep it here for unregistering
 };
 /// @}
 

include/anki/scene/Sector.h

@@ -8,7 +8,7 @@ namespace anki {
 
 // Forward
 class SceneNode;
-class Scene;
+class SceneGraph;
 class Sector;
 class SectorGroup;
 class Renderer;
@@ -83,18 +83,18 @@ class SectorGroup
 {
 public:
 	/// Default constructor
-	SectorGroup(Scene* scene);
+	SectorGroup(SceneGraph* scene);
 
 	/// Destructor
 	~SectorGroup();
 
 	/// @name Accessors
 	/// @{
-	const Scene& getScene() const
+	const SceneGraph& getSceneGraph() const
 	{
 		return *scene;
 	}
-	Scene& getScene()
+	SceneGraph& getSceneGraph()
 	{
 		return *scene;
 	}
@@ -124,7 +124,7 @@ public:
 	Portal* createNewPortal(Sector* a, Sector* b, const Obb& collisionShape);
 
 private:
-	Scene* scene; ///< Keep it here to access various allocators
+	SceneGraph* scene; ///< Keep it here to access various allocators
 	SceneVector<Sector*> sectors;
 	SceneVector<Portal*> portals;
 

include/anki/scene/SkinNode.h

@@ -137,7 +137,7 @@ public:
 	/// @name Constructors/Destructor
 	/// @{
 	SkinPatchNode(const ModelPatchBase* modelPatch_,
-		const char* name, Scene* scene, // Scene
+		const char* name, SceneGraph* scene, // Scene
 		uint movableFlags, Movable* movParent, // Movable
 		CollisionShape* spatialCs); // Spatial
 	/// @}
@@ -187,7 +187,7 @@ public:
 	/// @name Constructors/Destructor
 	/// @{
 	SkinNode(const char* skinFname,
-		const char* name, Scene* scene, // SceneNode
+		const char* name, SceneGraph* scene, // SceneNode
 		uint movableFlags, Movable* movParent); // Movable
 
 	~SkinNode();

include/anki/scene/StaticGeometryNode.h

@@ -18,7 +18,7 @@ public:
 	/// @name Constructors/Destructor
 	/// @{
 	StaticGeometrySpatialNode(const Obb& obb,
-		const char* name, Scene* scene); // Scene
+		const char* name, SceneGraph* scene); // Scene
 	/// @}
 };
 
@@ -30,7 +30,7 @@ public:
 	/// @name Constructors/Destructor
 	/// @{
 	StaticGeometryPatchNode(const ModelPatchBase* modelPatch,
-		const char* name, Scene* scene); // Scene
+		const char* name, SceneGraph* scene); // Scene
 
 	~StaticGeometryPatchNode();
 	/// @}
@@ -61,7 +61,7 @@ class StaticGeometryNode: public SceneNode
 {
 public:
 	StaticGeometryNode(const char* filename,
-		const char* name, Scene* scene); // Scene
+		const char* name, SceneGraph* scene); // Scene
 
 	~StaticGeometryNode();
 

include/anki/scene/Visibility.h

@@ -133,7 +133,7 @@ struct MaterialSortJob: ThreadJob
 };
 
 /// Do visibility tests bypassing portals 
-void doVisibilityTests(SceneNode& frustumable, Scene& scene, 
+void doVisibilityTests(SceneNode& frustumable, SceneGraph& scene, 
 	Renderer& renderer);
 
 /// @}

src/event/SceneColorEvent.cpp

@@ -1,5 +1,5 @@
 #include "anki/event/SceneColorEvent.h"
-#include "anki/scene/Scene.h"
+#include "anki/scene/SceneGraph.h"
 #include "anki/core/Logger.h"
 
 namespace anki {
@@ -9,7 +9,7 @@ SceneColorEvent::SceneColorEvent(float startTime, float duration,
 	const Vec3& finalColor_)
 	: Event(ET_SCENE_COLOR, startTime, duration), finalColor(finalColor_)
 {
-	originalColor = SceneSingleton::get().getAmbientColor();
+	originalColor = SceneGraphSingleton::get().getAmbientColor();
 }
 
 //==============================================================================
@@ -34,7 +34,7 @@ void SceneColorEvent::updateSp(float /*prevUpdateTime*/, float crntTime)
 	float d = crntTime - getStartTime(); // delta
 	float dp = d / float(getDuration()); // delta as persentage
 
-	SceneSingleton::get().setAmbientColor(
+	SceneGraphSingleton::get().setAmbientColor(
 		interpolate(originalColor, finalColor, dp));
 }
 

src/physics/RigidBody.cpp

@@ -1,6 +1,6 @@
 #include "anki/physics/RigidBody.h"
 #include "anki/physics/PhysWorld.h"
-#include "anki/scene/Scene.h"
+#include "anki/scene/SceneGraph.h"
 #include "anki/physics/MotionState.h"
 
 namespace anki {

src/renderer/Bs.cpp

@@ -1,6 +1,6 @@
 #include "anki/renderer/Bs.h"
 #include "anki/renderer/Renderer.h"
-#include "anki/scene/Scene.h"
+#include "anki/scene/SceneGraph.h"
 #include "anki/scene/Camera.h"
 
 namespace anki {
@@ -23,7 +23,7 @@ void Bs::run()
 
 	RenderableDrawer& drawer = r->getSceneDrawer();
 	drawer.prepareDraw();
-	Scene& scene = r->getScene();
+	SceneGraph& scene = r->getSceneGraph();
 	VisibilityTestResults& vi =
 		*scene.getActiveCamera().getFrustumable()->getVisibilityTestResults();
 

src/renderer/Dbg.cpp

@@ -1,7 +1,7 @@
 #include "anki/renderer/Dbg.h"
 #include "anki/renderer/Renderer.h"
 #include "anki/resource/ShaderProgramResource.h"
-#include "anki/scene/Scene.h"
+#include "anki/scene/SceneGraph.h"
 #include "anki/scene/Light.h"
 #include "anki/core/Logger.h"
 
@@ -42,7 +42,7 @@ void Dbg::run()
 {
 	ANKI_ASSERT(enabled);
 
-	Scene& scene = r->getScene();
+	SceneGraph& scene = r->getSceneGraph();
 
 	fbo.bind();
 

src/renderer/Ez.cpp

@@ -1,7 +1,7 @@
 #include "anki/renderer/Ez.h"
 #include "anki/renderer/Renderer.h"
 #include "anki/core/App.h"
-#include "anki/scene/Scene.h"
+#include "anki/scene/SceneGraph.h"
 #include "anki/scene/Camera.h"
 
 namespace anki {
@@ -24,7 +24,7 @@ void Ez::run()
 {
 	ANKI_ASSERT(enabled);
 
-	Scene& scene = r->getScene();
+	SceneGraph& scene = r->getSceneGraph();
 	Camera& cam = scene.getActiveCamera();
 
 	VisibilityTestResults& vi = 

src/renderer/Is.cpp

@@ -1,6 +1,6 @@
 #include "anki/renderer/Is.h"
 #include "anki/renderer/Renderer.h"
-#include "anki/scene/Scene.h"
+#include "anki/scene/SceneGraph.h"
 #include "anki/scene/Camera.h"
 #include "anki/scene/Light.h"
 #include "anki/core/ThreadPool.h"
@@ -607,7 +607,7 @@ void Is::lightPass()
 //==============================================================================
 void Is::run()
 {
-	Scene& scene = r->getScene();
+	SceneGraph& scene = r->getSceneGraph();
 	cam = &scene.getActiveCamera();
 
 	GlStateSingleton::get().disable(GL_BLEND);

src/renderer/MainRenderer.cpp

@@ -78,7 +78,7 @@ void MainRenderer::initGl()
 }
 
 //==============================================================================
-void MainRenderer::render(Scene& scene)
+void MainRenderer::render(SceneGraph& scene)
 {
 	Bool drawToDefaultFbo = renderingQuality > 0.9 && !dbg.getEnabled();
 

src/renderer/Ms.cpp

@@ -4,7 +4,7 @@
 
 #include "anki/core/Logger.h"
 #include "anki/scene/Camera.h"
-#include "anki/scene/Scene.h"
+#include "anki/scene/SceneGraph.h"
 
 namespace anki {
 
@@ -61,7 +61,7 @@ void Ms::run()
 	GlStateSingleton::get().enable(GL_DEPTH_TEST);
 
 	//GlStateMachineSingleton::get().enable(GL_DEPTH_TEST, true);
-	//app->getScene().skybox.Render(cam.getViewMatrix().getRotationPart());
+	//app->getSceneGraph().skybox.Render(cam.getViewMatrix().getRotationPart());
 	//glDepthFunc(GL_LEQUAL);
 
 	// if ez then change the default depth test and disable depth writing
@@ -74,11 +74,11 @@ void Ms::run()
 	// render all
 	r->getSceneDrawer().prepareDraw();
 	VisibilityTestResults& vi =
-		*r->getScene().getActiveCamera().getVisibilityTestResults();
+		*r->getSceneGraph().getActiveCamera().getVisibilityTestResults();
 
 	for(auto it = vi.getRenderablesBegin(); it != vi.getRenderablesEnd(); ++it)
 	{
-		r->getSceneDrawer().render(r->getScene().getActiveCamera(),
+		r->getSceneDrawer().render(r->getSceneGraph().getActiveCamera(),
 			RenderableDrawer::RS_MATERIAL, 0, *(*it));
 	}
 

src/renderer/Renderer.cpp

@@ -1,7 +1,7 @@
 #include "anki/renderer/Renderer.h"
 #include "anki/util/Exception.h"
 #include "anki/scene/Camera.h"
-#include "anki/scene/Scene.h"
+#include "anki/scene/SceneGraph.h"
 
 namespace anki {
 
@@ -56,7 +56,7 @@ void Renderer::init(const RendererInitializer& initializer)
 }
 
 //==============================================================================
-void Renderer::render(Scene& scene_)
+void Renderer::render(SceneGraph& scene_)
 {
 	scene = &scene_;
 	Camera& cam = scene->getActiveCamera();

src/renderer/Sm.cpp

@@ -1,7 +1,7 @@
 #include "anki/renderer/Sm.h"
 #include "anki/renderer/Renderer.h"
 #include "anki/core/App.h"
-#include "anki/scene/Scene.h"
+#include "anki/scene/SceneGraph.h"
 #include "anki/scene/Camera.h"
 #include "anki/scene/Light.h"
 

src/renderer/Ssao.cpp

@@ -2,7 +2,7 @@
 #include "anki/renderer/Ssao.h"
 #include "anki/renderer/Renderer.h"
 #include "anki/scene/Camera.h"
-#include "anki/scene/Scene.h"
+#include "anki/scene/SceneGraph.h"
 
 namespace anki {
 
@@ -126,7 +126,7 @@ void Ssao::run()
 {
 	ANKI_ASSERT(enabled);
 
-	const Camera& cam = r->getScene().getActiveCamera();
+	const Camera& cam = r->getSceneGraph().getActiveCamera();
 
 	GlStateSingleton::get().disable(GL_BLEND);
 	GlStateSingleton::get().disable(GL_DEPTH_TEST);

src/scene/Camera.cpp

@@ -8,7 +8,7 @@ namespace anki {
 
 //==============================================================================
 Camera::Camera(CameraType type_,
-	const char* name, Scene* scene, // SceneNode
+	const char* name, SceneGraph* scene, // SceneNode
 	U32 movableFlags, Movable* movParent, // Movable
 	Frustum* frustum) // Spatial & Frustumable
 	:	SceneNode(name, scene),
@@ -44,7 +44,7 @@ void Camera::lookAtPoint(const Vec3& point)
 //==============================================================================
 
 //==============================================================================
-PerspectiveCamera::PerspectiveCamera(const char* name, Scene* scene,
+PerspectiveCamera::PerspectiveCamera(const char* name, SceneGraph* scene,
 	uint movableFlags, Movable* movParent)
 	: Camera(CT_PERSPECTIVE, name, scene, movableFlags, movParent, 
 		&frustum)
@@ -55,7 +55,7 @@ PerspectiveCamera::PerspectiveCamera(const char* name, Scene* scene,
 //==============================================================================
 
 //==============================================================================
-OrthographicCamera::OrthographicCamera(const char* name, Scene* scene,
+OrthographicCamera::OrthographicCamera(const char* name, SceneGraph* scene,
 	uint movableFlags, Movable* movParent)
 	: Camera(CT_ORTHOGRAPHIC, name, scene, movableFlags, movParent, 
 		&frustum)

src/scene/Light.cpp

@@ -8,7 +8,7 @@ namespace anki {
 
 //==============================================================================
 Light::Light(LightType t, // Light
-	const char* name, Scene* scene, // Scene
+	const char* name, SceneGraph* scene, // Scene
 	U32 movableFlags, Movable* movParent, // Movable
 	CollisionShape* cs) // Spatial
 	: SceneNode(name, scene),
@@ -37,7 +37,7 @@ Light::~Light()
 //==============================================================================
 
 //==============================================================================
-PointLight::PointLight(const char* name, Scene* scene,
+PointLight::PointLight(const char* name, SceneGraph* scene,
 	U32 movableFlags, Movable* movParent)
 	: Light(LT_POINT, name, scene, movableFlags, movParent, &sphereW)
 {
@@ -50,7 +50,7 @@ PointLight::PointLight(const char* name, Scene* scene,
 //==============================================================================
 
 //==============================================================================
-SpotLight::SpotLight(const char* name, Scene* scene,
+SpotLight::SpotLight(const char* name, SceneGraph* scene,
 	U32 movableFlags, Movable* movParent)
 	: 	Light(LT_SPOT, name, scene, movableFlags, movParent, &frustum),
 		Frustumable(&frustum)

src/scene/ModelNode.cpp

@@ -10,7 +10,7 @@ namespace anki {
 
 //==============================================================================
 ModelPatchNode::ModelPatchNode(const ModelPatchBase *modelPatch_,
-	const char* name, Scene* scene,
+	const char* name, SceneGraph* scene,
 	U32 movableFlags, Movable* movParent)
 	:	SceneNode(name, scene),
 		Movable(movableFlags, movParent, *this, getSceneAllocator()),
@@ -30,7 +30,7 @@ ModelPatchNode::ModelPatchNode(const ModelPatchBase *modelPatch_,
 
 //==============================================================================
 ModelNode::ModelNode(const char* modelFname,
-	const char* name, Scene* scene,
+	const char* name, SceneGraph* scene,
 	uint movableFlags, Movable* movParent)
 	: 	SceneNode(name, scene),
 		Movable(movableFlags, movParent, *this, getSceneAllocator()),

src/scene/Octree.cpp

@@ -3,7 +3,7 @@
 #include "anki/scene/Frustumable.h"
 #include "anki/scene/Light.h"
 #include "anki/scene/Sector.h"
-#include "anki/scene/Scene.h"
+#include "anki/scene/SceneGraph.h"
 #include "anki/util/Exception.h"
 #include "anki/core/Logger.h"
 #include "anki/scene/Renderable.h"
@@ -147,7 +147,7 @@ Octree::Octree(Sector* sector_, const Aabb& aabb, U8 maxDepth_, F32 looseness_)
 	:	sector(sector_),
 		maxDepth(maxDepth_ < 1 ? 1 : maxDepth_), 
 		looseness(looseness_),
-		root(aabb, sector->getSectorGroup().getScene().getAllocator(), this)
+		root(aabb, sector->getSectorGroup().getSceneGraph().getAllocator(), this)
 {}
 
 //==============================================================================
@@ -228,7 +228,7 @@ OctreeNode* Octree::placeInternal(const Aabb& aabb, U depth, OctreeNode& node)
 #endif
 						{
 							SceneAllocator<U8> alloc =
-								sector->getSectorGroup().getScene().
+								sector->getSectorGroup().getSceneGraph().
 								getAllocator();
 
 							// Create new node if needed

src/scene/ParticleEmitter.cpp

@@ -1,5 +1,5 @@
 #include "anki/scene/ParticleEmitter.h"
-#include "anki/scene/Scene.h"
+#include "anki/scene/SceneGraph.h"
 #include "anki/resource/Model.h"
 #include "anki/util/Functions.h"
 #include "anki/physics/PhysWorld.h"
@@ -44,7 +44,7 @@ Vec3 getRandom(const Vec3& initial, const Vec3& deviation)
 ParticleBase::ParticleBase(
 	ParticleType type_,
 	// SceneNode
-	const char* name, Scene* scene, 
+	const char* name, SceneGraph* scene, 
 	// Movable
 	U32 movableFlags, Movable* movParent)
 	:	SceneNode(name, scene),
@@ -78,7 +78,7 @@ void ParticleBase::revive(const ParticleEmitter& pe,
 //==============================================================================
 ParticleSimple::ParticleSimple(
 	// SceneNode
-	const char* name, Scene* scene, 
+	const char* name, SceneGraph* scene, 
 	// Movable
 	U32 movableFlags, Movable* movParent)
 	: ParticleBase(PT_SIMPLE, name, scene, movableFlags, movParent)
@@ -136,7 +136,7 @@ void ParticleSimple::revive(const ParticleEmitter& pe,
 //==============================================================================
 Particle::Particle(
 	// Scene
-	const char* name, Scene* scene,
+	const char* name, SceneGraph* scene,
 	// Movable
 	U32 movableFlags, Movable* movParent, 
 	// RigidBody
@@ -224,7 +224,7 @@ void Particle::revive(const ParticleEmitter& pe,
 ParticleEmitter::ParticleEmitter(
 	const char* filename,
 	// SceneNode
-	const char* name, Scene* scene, 
+	const char* name, SceneGraph* scene, 
 	// Movable
 	U32 movableFlags, Movable* movParent)
 	:	SceneNode(name, scene),
@@ -303,7 +303,7 @@ void ParticleEmitter::movableUpdate()
 }
 
 //==============================================================================
-void ParticleEmitter::createParticlesSimulation(Scene* scene)
+void ParticleEmitter::createParticlesSimulation(SceneGraph* scene)
 {
 	collShape = ANKI_NEW(btSphereShape, getSceneAllocator(), particle.size);
 
@@ -332,7 +332,7 @@ void ParticleEmitter::createParticlesSimulation(Scene* scene)
 }
 
 //==============================================================================
-void ParticleEmitter::createParticlesSimpleSimulation(Scene* scene)
+void ParticleEmitter::createParticlesSimpleSimulation(SceneGraph* scene)
 {
 	for(U i = 0; i < maxNumOfParticles; i++)
 	{

src/scene/Scene.cpp → src/scene/SceneGraph.cpp

@@ -1,4 +1,4 @@
-#include "anki/scene/Scene.h"
+#include "anki/scene/SceneGraph.h"
 #include "anki/scene/Camera.h"
 #include "anki/util/Exception.h"
 #include "anki/core/ThreadPool.h"
@@ -12,7 +12,7 @@ namespace anki {
 //==============================================================================
 struct UpdateMovablesJob: ThreadJob
 {
-	Scene::Types<SceneNode>::Iterator movablesBegin;
+	SceneGraph::Types<SceneNode>::Iterator movablesBegin;
 	U32 movablesCount;
 
 	void operator()(U threadId, U threadsCount)
@@ -67,7 +67,7 @@ static void updateSceneNode(SceneNode& sn, F32 prevUpdateTime,
 //==============================================================================
 struct UpdateSceneNodesJob: ThreadJob
 {
-	Scene::Types<SceneNode>::Iterator sceneNodesBegin;
+	SceneGraph::Types<SceneNode>::Iterator sceneNodesBegin;
 	U32 sceneNodesCount;
 	F32 prevUpdateTime;
 	F32 crntTime;
@@ -91,7 +91,7 @@ struct UpdateSceneNodesJob: ThreadJob
 //==============================================================================
 
 //==============================================================================
-Scene::Scene()
+SceneGraph::SceneGraph()
 	:	alloc(ANKI_CFG_SCENE_ALLOCATOR_SIZE),
 		frameAlloc(ANKI_CFG_SCENE_FRAME_ALLOCATOR_SIZE),
 		nodes(alloc),
@@ -103,25 +103,25 @@ Scene::Scene()
 }
 
 //==============================================================================
-Scene::~Scene()
+SceneGraph::~SceneGraph()
 {}
 
 //==============================================================================
-void Scene::registerNode(SceneNode* node)
+void SceneGraph::registerNode(SceneNode* node)
 {
 	addC(nodes, node);
 	addDict(nameToNode, node);
 }
 
 //==============================================================================
-void Scene::unregisterNode(SceneNode* node)
+void SceneGraph::unregisterNode(SceneNode* node)
 {
 	removeC(nodes, node);
 	removeDict(nameToNode, node);
 }
 
 //==============================================================================
-void Scene::update(F32 prevUpdateTime, F32 crntTime, Renderer& renderer)
+void SceneGraph::update(F32 prevUpdateTime, F32 crntTime, Renderer& renderer)
 {
 	frameAlloc.reset();
 
@@ -209,14 +209,14 @@ void Scene::update(F32 prevUpdateTime, F32 crntTime, Renderer& renderer)
 }
 
 //==============================================================================
-SceneNode& Scene::findSceneNode(const char* name)
+SceneNode& SceneGraph::findSceneNode(const char* name)
 {
 	ANKI_ASSERT(nameToNode.find(name) != nameToNode.end());
 	return *(nameToNode.find(name)->second);
 }
 
 //==============================================================================
-SceneNode* Scene::tryFindSceneNode(const char* name)
+SceneNode* SceneGraph::tryFindSceneNode(const char* name)
 {
 	Types<SceneNode>::NameToItemMap::iterator it = nameToNode.find(name);
 	return (it == nameToNode.end()) ? nullptr : it->second;

src/scene/SceneNode.cpp

@@ -1,5 +1,5 @@
 #include "anki/scene/SceneNode.h"
-#include "anki/scene/Scene.h"
+#include "anki/scene/SceneGraph.h"
 #include "anki/scene/Movable.h"
 #include "anki/scene/Spatial.h"
 #include "anki/scene/Frustumable.h"
@@ -7,7 +7,7 @@
 namespace anki {
 
 //==============================================================================
-SceneNode::SceneNode(const char* name_, Scene* scene_)
+SceneNode::SceneNode(const char* name_, SceneGraph* scene_)
 	: name(name_, scene_->getAllocator()), scene(scene_)
 {
 	name.shrink_to_fit(); // Do that first

src/scene/Sector.cpp

@@ -5,7 +5,7 @@
 #include "anki/scene/Light.h"
 #include "anki/scene/Visibility.h"
 #include "anki/scene/Frustumable.h"
-#include "anki/scene/Scene.h"
+#include "anki/scene/SceneGraph.h"
 #include "anki/core/Logger.h"
 #include "anki/renderer/Renderer.h"
 #include "anki/core/ThreadPool.h"
@@ -30,7 +30,7 @@ Portal::Portal()
 //==============================================================================
 Sector::Sector(SectorGroup* group_, const Aabb& box)
 	: group(group_), octree(this, box, 3),
-		portals(group->getScene().getAllocator())
+		portals(group->getSceneGraph().getAllocator())
 {
 	// Reserve some space for portals
 	portals.reserve(AVERAGE_PORTALS_PER_SECTOR);
@@ -77,7 +77,7 @@ void Sector::removePortal(Portal* portal)
 //==============================================================================
 
 //==============================================================================
-SectorGroup::SectorGroup(Scene* scene_)
+SectorGroup::SectorGroup(SceneGraph* scene_)
 	:	scene(scene_),
 		sectors(scene->getAllocator()),
 		portals(scene->getAllocator())

src/scene/SkinNode.cpp

@@ -126,7 +126,7 @@ SkinModelPatch::SkinModelPatch(const ModelPatchBase* mpatch_,
 
 //==============================================================================
 SkinPatchNode::SkinPatchNode(const ModelPatchBase* modelPatch_,
-	const char* name, Scene* scene,
+	const char* name, SceneGraph* scene,
 	uint movableFlags, Movable* movParent,
 	CollisionShape* spatialCs)
 	: 	SceneNode(name, scene),
@@ -148,7 +148,7 @@ SkinPatchNode::SkinPatchNode(const ModelPatchBase* modelPatch_,
 
 //==============================================================================
 SkinNode::SkinNode(const char* skinFname,
-	const char* name, Scene* scene, // SceneNode
+	const char* name, SceneGraph* scene, // SceneNode
 	uint movableFlags, Movable* movParent) // Movable
 	:	SceneNode(name, scene),
 		Movable(movableFlags, movParent, *this, getSceneAllocator()),

src/scene/StaticGeometryNode.cpp

@@ -1,5 +1,5 @@
 #include "anki/scene/StaticGeometryNode.h"
-#include "anki/scene/Scene.h"
+#include "anki/scene/SceneGraph.h"
 
 namespace anki {
 
@@ -9,7 +9,7 @@ namespace anki {
 
 //==============================================================================
 StaticGeometrySpatialNode::StaticGeometrySpatialNode(const Obb& obb,
-	const char* name, Scene* scene)
+	const char* name, SceneGraph* scene)
 	: SceneNode(name, scene), Spatial(&obb)
 {
 	sceneNodeProtected.spatial = this;
@@ -21,7 +21,7 @@ StaticGeometrySpatialNode::StaticGeometrySpatialNode(const Obb& obb,
 
 //==============================================================================
 StaticGeometryPatchNode::StaticGeometryPatchNode(
-	const ModelPatchBase* modelPatch_, const char* name, Scene* scene)
+	const ModelPatchBase* modelPatch_, const char* name, SceneGraph* scene)
 	:	SceneNode(name, scene),
 		Spatial(&modelPatch->getBoundingShape()),
 		Renderable(getSceneAllocator()),
@@ -66,7 +66,7 @@ StaticGeometryPatchNode::~StaticGeometryPatchNode()
 
 //==============================================================================
 StaticGeometryNode::StaticGeometryNode(const char* filename,
-	const char* name, Scene* scene)
+	const char* name, SceneGraph* scene)
 	: SceneNode(name, scene)
 {
 	model.load(filename);

src/scene/Visibility.cpp

@@ -1,5 +1,5 @@
 #include "anki/scene/Visibility.h"
-#include "anki/scene/Scene.h"
+#include "anki/scene/SceneGraph.h"
 #include "anki/scene/Frustumable.h"
 #include "anki/scene/Light.h"
 #include "anki/renderer/Renderer.h"
@@ -10,7 +10,7 @@ namespace anki {
 struct VisibilityTestJob: ThreadJob
 {
 	U nodesCount = 0;
-	Scene::Types<SceneNode>::Container::iterator nodes;
+	SceneGraph::Types<SceneNode>::Container::iterator nodes;
 	Frustumable* frustumable = nullptr;
 	Renderer* renderer = nullptr;
 	SceneAllocator<U8> frameAlloc;
@@ -121,7 +121,7 @@ struct VisibilityTestJob: ThreadJob
 };
 
 //==============================================================================
-void doVisibilityTests(SceneNode& fsn, Scene& scene, 
+void doVisibilityTests(SceneNode& fsn, SceneGraph& scene, 
 	Renderer& r)
 {
 	Frustumable* fr = fsn.getFrustumable();

src/script/scene/Scene.cpp

@@ -1,5 +1,5 @@
 #include "anki/script/Common.h"
-#include "anki/scene/Scene.h"
+#include "anki/scene/SceneGraph.h"
 #include "anki/scene/Camera.h"
 #include "anki/scene/ModelNode.h"
 

testapp/Main.cpp

@@ -10,7 +10,7 @@
 #include "anki/resource/Mesh.h"
 #include "anki/scene/Light.h"
 #include "anki/resource/Material.h"
-#include "anki/scene/Scene.h"
+#include "anki/scene/SceneGraph.h"
 #include "anki/resource/SkelAnim.h"
 #include "anki/physics/Character.h"
 #include "anki/renderer/Renderer.h"
@@ -46,7 +46,7 @@ NativeWindow* win;
 //==============================================================================
 void initPhysics()
 {
-	Scene& scene = SceneSingleton::get();
+	SceneGraph& scene = SceneGraphSingleton::get();
 
 	scene.getPhysics().setDebugDrawer(
 		new PhysicsDebugDrawer(
@@ -66,7 +66,7 @@ void initPhysics()
 	init.group = PhysWorld::CG_MAP;
 	init.mask = PhysWorld::CG_ALL;
 
-	new RigidBody(&SceneSingleton::get().getPhysics(), init);
+	new RigidBody(&SceneGraphSingleton::get().getPhysics(), init);
 
 #if 1
 	btCollisionShape* colShape = new btBoxShape(
@@ -101,7 +101,7 @@ void initPhysics()
 				ModelNode* mnode = new ModelNode(
 					"data/models/crate0/crate0.mdl",
 					name.c_str(),
-					&SceneSingleton::get(), Movable::MF_NONE, nullptr);
+					&SceneGraphSingleton::get(), Movable::MF_NONE, nullptr);
 
 				init.movable = mnode;
 				ANKI_ASSERT(init.movable);
@@ -112,7 +112,7 @@ void initPhysics()
 
 				init.startTrf = trf;
 
-				new RigidBody(&SceneSingleton::get().getPhysics(), init);
+				new RigidBody(&SceneGraphSingleton::get().getPhysics(), init);
 			}
 		}
 	}
@@ -124,7 +124,7 @@ void init()
 {
 	ANKI_LOGI("Other init...");
 
-	Scene& scene = SceneSingleton::get();
+	SceneGraph& scene = SceneGraphSingleton::get();
 
 #if 0
 	painter = new UiPainter(Vec2(AppSingleton::get().getWindowWidth(),
@@ -302,42 +302,42 @@ void mainLoopExtra()
 	F32 mouseSensivity = 9.0;
 
 	// move the camera
-	static Movable* mover = SceneSingleton::get().getActiveCamera().getMovable();
+	static Movable* mover = SceneGraphSingleton::get().getActiveCamera().getMovable();
 	Input& in = InputSingleton::get();
 
 	if(in.getKey(KC_1))
 	{
-		mover = &SceneSingleton::get().getActiveCamera();
+		mover = &SceneGraphSingleton::get().getActiveCamera();
 	}
 	if(in.getKey(KC_2))
 	{
-		mover = SceneSingleton::get().findSceneNode("horse").getMovable();
+		mover = SceneGraphSingleton::get().findSceneNode("horse").getMovable();
 	}
 	if(in.getKey(KC_3))
 	{
-		mover = SceneSingleton::get().findSceneNode("spot0").getMovable();
+		mover = SceneGraphSingleton::get().findSceneNode("spot0").getMovable();
 	}
 	if(in.getKey(KC_4))
 	{
-		mover = SceneSingleton::get().findSceneNode("spot1").getMovable();
+		mover = SceneGraphSingleton::get().findSceneNode("spot1").getMovable();
 	}
 	if(in.getKey(KC_5))
 	{
-		mover = SceneSingleton::get().findSceneNode("pe").getMovable();
+		mover = SceneGraphSingleton::get().findSceneNode("pe").getMovable();
 	}
 	if(in.getKey(KC_6))
 	{
-		mover = SceneSingleton::get().findSceneNode("vase_plight0").getMovable();
+		mover = SceneGraphSingleton::get().findSceneNode("vase_plight0").getMovable();
 	}
 	if(in.getKey(KC_7))
 	{
-		mover = SceneSingleton::get().findSceneNode("sponza").getMovable();
+		mover = SceneGraphSingleton::get().findSceneNode("sponza").getMovable();
 		std::cout << mover->getWorldTransform() << std::endl;
 	}
 
 	if(in.getKey(KC_L) == 1)
 	{
-		Light* l = SceneSingleton::get().findSceneNode("point1").getLight();
+		Light* l = SceneGraphSingleton::get().findSceneNode("point1").getLight();
 		static_cast<PointLight*>(l)->setRadius(10.0);
 	}
 
@@ -439,10 +439,10 @@ void mainLoop()
 		InputSingleton::get().handleEvents();
 		InputSingleton::get().moveMouse(Vec2(0.0));
 		mainLoopExtra();
-		SceneSingleton::get().update(
+		SceneGraphSingleton::get().update(
 			prevUpdateTime, crntTime, MainRendererSingleton::get());
 		EventManagerSingleton::get().updateAllEvents(prevUpdateTime, crntTime);
-		MainRendererSingleton::get().render(SceneSingleton::get());
+		MainRendererSingleton::get().render(SceneGraphSingleton::get());
 
 		if(InputSingleton::get().getKey(KC_ESCAPE))
 		{

tools/shredder/src/Main.cpp

@@ -8,7 +8,7 @@
 #include "Input.h"
 #include "MainRenderer.h"
 #include "RendererInitializer.h"
-#include "Scene.h"
+#include "SceneGraph.h"
 #include "anki/gl/GlException.h"
 
 
@@ -214,8 +214,8 @@ int main(int argc, char** argv)
 			mover->getLocalTransform().rotation.reorthogonalize();
 
 			// Update
-			app->getScene().updateAllControllers();
-			app->getScene().updateAllWorldStuff();
+			app->getSceneGraph().updateAllControllers();
+			app->getSceneGraph().updateAllWorldStuff();
 
 			// Render
 			glClear(GL_COLOR_BUFFER_BIT);