Renderer debug stuff & a bit of sectors

include/anki/input/KeyCode.h

@@ -91,6 +91,19 @@ enum KeyCode
 	KC_LEFT,
 	KC_RIGHT,
 
+	KC_F1,
+	KC_F2,
+	KC_F3,
+	KC_F4,
+	KC_F5,
+	KC_F6,
+	KC_F7,
+	KC_F8,
+	KC_F9,
+	KC_F10,
+	KC_F11,
+	KC_F12,
+
 	KC_COUNT
 };
 

include/anki/renderer/Dbg.h

@@ -9,9 +9,21 @@
 namespace anki {
 
 /// Debugging stage
-class Dbg: public SwitchableRenderingPass
+class Dbg: public SwitchableRenderingPass, public Flags<U8>
 {
 public:
+	enum DebugFlag
+	{
+		DF_NONE = 0,
+		DF_SPATIAL = 1 << 0,
+		DF_FRUSTUMABLE = 1 << 1,
+		DF_SECTOR = 1 << 2,
+		DF_OCTREE = 1 << 3,
+		DF_PHYSICS = 1 << 4,
+		DF_ALL = DF_SPATIAL | DF_FRUSTUMABLE | DF_SECTOR | DF_OCTREE
+			| DF_PHYSICS
+	};
+
 	Dbg(Renderer* r_)
 		: SwitchableRenderingPass(r_)
 	{}

include/anki/renderer/DebugDrawer.h

@@ -158,20 +158,11 @@ class Camera;
 class Sector;
 
 /// This is a drawer for some scene nodes that need debug
-class SceneDebugDrawer: public Flags<U32>
+class SceneDebugDrawer
 {
 public:
-	enum DebugFlag
-	{
-		DF_NONE = 0,
-		DF_SPATIAL = 1 << 0,
-		DF_FRUSTUMABLE = 1 << 1,
-		DF_SECTOR = 1 << 2,
-		DF_OCTREE = 1 << 3
-	};
-
 	SceneDebugDrawer(DebugDrawer* d)
-		: Flags<U32>(DF_SPATIAL | DF_FRUSTUMABLE), dbg(d)
+		: dbg(d)
 	{}
 
 	virtual ~SceneDebugDrawer()

include/anki/renderer/Is.h

@@ -85,9 +85,6 @@ private:
 	/// Opt because many ask for it
 	Camera* cam;
 
-	Bool drawToDefaultFbo;
-	U32 width, height;
-
 	/// If enabled the ground emmits a light
 	Bool groundLightEnabled;
 	/// Keep the prev light dir to avoid uniform block updates

include/anki/renderer/MainRenderer.h

@@ -68,7 +68,7 @@ private:
 
 	U32 windowWidth, windowHeight;
 
-	Bool drawToDefaultFbo;
+	F32 renderingQuality;
 
 	std::unique_ptr<Deformer> deformer;
 

include/anki/renderer/Pps.h

@@ -15,7 +15,7 @@ class ShaderProgram;
 
 /// Post-processing stage.This stage is divided into 2 two parts. The first
 /// happens before blending stage and the second after
-class Pps: public SwitchableRenderingPass
+class Pps: public RenderingPass
 {
 public:
 	Pps(Renderer* r);
@@ -53,6 +53,11 @@ public:
 	{
 		return fai;
 	}
+
+	void setDrawToDefaultFbo(Bool x)
+	{
+		drawToDefaultFbo = x;
+	}
 	/// @}
 
 private:
@@ -68,6 +73,7 @@ private:
 	Texture fai;
 
 	Bool drawToDefaultFbo;
+	/// Used only if rendering to default FBO
 	U32 width, height;
 
 	void initInternal(const RendererInitializer& initializer);

include/anki/renderer/Renderer.h

@@ -43,7 +43,6 @@ struct RendererInitializer
 			U32 resolution = 512;
 			U32 maxLights = 4;
 		} sm;
-		Bool drawToDefaultFbo = false;
 		Bool groundLightEnabled = true;
 	} is;
 
@@ -77,7 +76,6 @@ struct RendererInitializer
 			F32 sideBlurFactor = 1.0;
 		} bl;
 		Bool enabled = false;
-		Bool drawToDefaultFbo = false;
 	} pps;
 
 	// Dbg
@@ -302,8 +300,6 @@ protected:
 	/// Height of the rendering. Don't confuse with the window width
 	U32 height;
 	Scene* scene; ///< Current scene
-	/// Max color attachments an FBO can accept
-	static int maxColorAtachments;
 	RenderableDrawer sceneDrawer;
 	F32 lodDistance; ///< Distance that used to calculate the LOD
 

include/anki/scene/Movable.h

@@ -161,7 +161,7 @@ protected:
 	void movableMarkUpdated()
 	{
 		timestamp = Timestamp::getTimestamp();
-		enableFlag(MF_TRANSFORM_DIRTY);
+		enableFlags(MF_TRANSFORM_DIRTY);
 	}
 };
 /// @}

include/anki/util/Flags.h

@@ -15,36 +15,44 @@ public:
 	Flags()
 	{}
 
-	Flags(T mask_)
-		: mask(mask_)
+	Flags(T bitmask_)
+		: bitmask(bitmask_)
 	{}
 
 	/// @name Flag manipulation
 	/// @{
-	void enableFlag(Value flag)
+	void enableFlags(Value mask)
 	{
-		mask |= flag;
+		bitmask |= mask;
 	}
-	void enableFlag(Value flag, Bool enable)
+	void enableFlags(Value mask, Bool enable)
 	{
-		mask = (enable) ? mask | flag : mask & ~flag;
+		bitmask = (enable) ? bitmask | mask : bitmask & ~mask;
 	}
-	void disableFlag(Value flag)
+
+	void disableFlags(Value mask)
+	{
+		bitmask &= ~mask;
+	}
+
+	void switchFlags(Value mask)
 	{
-		mask &= ~flag;
+		bitmask ^= mask;
 	}
-	Bool isFlagEnabled(Value flag) const
+
+	Bool flagsEnabled(Value mask) const
 	{
-		return mask & flag;
+		return bitmask & mask;
 	}
-	Value getFlagsBitmask() const
+
+	Value getFlagsBitbitmask() const
 	{
-		return mask;
+		return bitmask;
 	}
 	/// @}
 
 protected:
-	Value mask = 0;
+	Value bitmask = 0;
 };
 
 } // end namespace anki

src/input/InputX11.cpp

@@ -103,6 +103,19 @@ static const X11KeyCodeToAnki x2a[] = {
 	{XK_z, KC_Z},
 	{XK_Delete, KC_DELETE},
 
+	{XK_F1, KC_F1},
+	{XK_F2, KC_F2},
+	{XK_F3, KC_F3},
+	{XK_F4, KC_F4},
+	{XK_F5, KC_F5},
+	{XK_F6, KC_F6},
+	{XK_F7, KC_F7},
+	{XK_F8, KC_F8},
+	{XK_F9, KC_F9},
+	{XK_F10, KC_F10},
+	{XK_F11, KC_F11},
+	{XK_F12, KC_F12},
+
 	{XK_Up,  KC_UP},
 	{XK_Down, KC_DOWN},
 	{XK_Left, KC_LEFT},

src/renderer/Dbg.cpp

@@ -15,11 +15,7 @@ Dbg::~Dbg()
 void Dbg::init(const Renderer::Initializer& initializer)
 {
 	enabled = initializer.dbg.enabled;
-
-	if(!enabled)
-	{
-		return;
-	}
+	enableFlags(DF_ALL);
 
 	try
 	{
@@ -62,7 +58,7 @@ void Dbg::run()
 	{
 		SceneNode* node = *it;
 		Spatial* sp = node->getSpatial();
-		if(sp)
+		if(flagsEnabled(DF_SPATIAL) && sp)
 		{
 			sceneDrawer->draw(*node);
 		}
@@ -73,11 +69,23 @@ void Dbg::run()
 	{
 		if(sector->isVisible())
 		{
-			sceneDrawer->draw(*sector);
+			if(flagsEnabled(DF_SPATIAL))
+			{
+				sceneDrawer->draw(*sector);
+			}
+
+			if(flagsEnabled(DF_OCTREE))
+			{
+				sceneDrawer->draw(sector->getOctree());
+			}
 		}
 	}
 
-	scene.getPhysics().debugDraw();
+	// Physics
+	if(flagsEnabled(DF_PHYSICS))
+	{
+		scene.getPhysics().debugDraw();
+	}
 
 	drawer->flush();
 }

src/renderer/DebugDrawer.cpp

@@ -463,12 +463,6 @@ void PhysicsDebugDrawer::draw3dText(const btVector3& /*location*/,
 //==============================================================================
 void SceneDebugDrawer::draw(SceneNode& node)
 {
-	// Nothing to render?
-	if(getFlagsBitmask() == 0)
-	{
-		return;
-	}
-
 	Movable* mv = node.getMovable();
 	if(mv)
 	{
@@ -480,14 +474,14 @@ void SceneDebugDrawer::draw(SceneNode& node)
 	}
 
 	Frustumable* fr;
-	if(isFlagEnabled(DF_FRUSTUMABLE) && (fr = node.getFrustumable()))
+	if((fr = node.getFrustumable()))
 	{
 		draw(*fr);
 	}
 
 	Spatial* sp;
-	if(isFlagEnabled(DF_SPATIAL) && (sp = node.getSpatial())
-		&& sp->isFlagEnabled(Spatial::SF_VISIBLE_CAMERA))
+	if((sp = node.getSpatial())
+		&& sp->flagsEnabled(Spatial::SF_VISIBLE_CAMERA))
 	{
 		draw(*sp);
 	}
@@ -547,11 +541,6 @@ void SceneDebugDrawer::draw(const OctreeNode& octnode, U32 depth,
 //==============================================================================
 void SceneDebugDrawer::draw(const Sector& sector)
 {
-	if(!isFlagEnabled(DF_SECTOR))
-	{
-		return;
-	}
-
 	// Draw the sector
 	dbg->setColor(Vec3(0.5, 0.5, 1.0));
 	CollisionDebugDrawer v(dbg);
@@ -566,12 +555,6 @@ void SceneDebugDrawer::draw(const Sector& sector)
 			portal->shape.accept(v);
 		}
 	}
-
-	// Draw the octree
-	if(isFlagEnabled(DF_OCTREE))
-	{
-		draw(sector.getOctree());
-	}
 }
 
 }  // end namespace anki

src/renderer/Is.cpp

@@ -288,9 +288,6 @@ void Is::init(const RendererInitializer& initializer)
 //==============================================================================
 void Is::initInternal(const RendererInitializer& initializer)
 {
-	drawToDefaultFbo = initializer.is.drawToDefaultFbo;
-	width = initializer.width / initializer.renderingQuality;
-	height = initializer.height / initializer.renderingQuality;
 	groundLightEnabled = initializer.is.groundLightEnabled;
 
 	//
@@ -473,24 +470,11 @@ void Is::lightPass()
 	sm.run(&shadowCasters[0], spotsShadowCount, shadowmapLayers);
 
 	// Prepare state
-	if(drawToDefaultFbo)
-	{
-		ANKI_ASSERT(!r->getPps().getEnabled());
-		Fbo::bindDefault();
-		r->clearAfterBindingFbo(
-			GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
-		GlStateSingleton::get().setViewport(
-			0, 0, width, height);
-	}
-	else
-	{
-		ANKI_ASSERT(r->getPps().getEnabled());
-		fbo.bind();
-		r->clearAfterBindingFbo(
-			GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
-		GlStateSingleton::get().setViewport(
-			0, 0, r->getWidth(), r->getHeight());
-	}
+	fbo.bind();
+	r->clearAfterBindingFbo(
+		GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
+	GlStateSingleton::get().setViewport(
+		0, 0, r->getWidth(), r->getHeight());
 	GlStateSingleton::get().disable(GL_DEPTH_TEST);
 	GlStateSingleton::get().disable(GL_BLEND);
 

src/renderer/MainRenderer.cpp

@@ -20,10 +20,9 @@ void MainRenderer::init(const Renderer::Initializer& initializer_)
 	ANKI_LOGI("Initializing main renderer...");
 	initGl();
 
-	const F32 renderingQuality = initializer_.renderingQuality;
+	renderingQuality = initializer_.renderingQuality;
 	windowWidth = initializer_.width;
 	windowHeight = initializer_.height;
-	drawToDefaultFbo = (renderingQuality > 0.9 && !initializer_.dbg.enabled);
 
 	// init the offscreen Renderer
 	//
@@ -31,17 +30,7 @@ void MainRenderer::init(const Renderer::Initializer& initializer_)
 	initializer.width *= renderingQuality;
 	initializer.height *= renderingQuality;
 
-	if(drawToDefaultFbo)
-	{
-		initializer.pps.drawToDefaultFbo = true;
-		initializer.is.drawToDefaultFbo = !initializer.pps.enabled;
-	}
-	else
-	{
-		initializer.pps.drawToDefaultFbo = false;
-		initializer.is.drawToDefaultFbo = false;
-		sProg.load("shaders/Final.glsl");
-	}
+	sProg.load("shaders/Final.glsl");
 
 	Renderer::init(initializer);
 	dbg.init(initializer);
@@ -53,12 +42,6 @@ void MainRenderer::init(const Renderer::Initializer& initializer_)
 //==============================================================================
 void MainRenderer::initGl()
 {
-	/*glewExperimental = GL_TRUE;
-	if(glewInit() != GLEW_OK)
-	{
-		throw ANKI_EXCEPTION("GLEW initialization failed");
-	}*/
-
 	// Ignore the first error
 	glGetError();
 
@@ -97,6 +80,10 @@ void MainRenderer::initGl()
 //==============================================================================
 void MainRenderer::render(Scene& scene)
 {
+	Bool drawToDefaultFbo = renderingQuality > 0.9 && !dbg.getEnabled();
+
+	pps.setDrawToDefaultFbo(drawToDefaultFbo);
+
 	Renderer::render(scene);
 
 	if(dbg.getEnabled())

src/renderer/Pps.cpp

@@ -2,12 +2,13 @@
 #include "anki/renderer/Renderer.h"
 #include "anki/renderer/Hdr.h"
 #include "anki/renderer/Ssao.h"
+#include "anki/core/Logger.h"
 
 namespace anki {
 
 //==============================================================================
 Pps::Pps(Renderer* r_)
-	: SwitchableRenderingPass(r_), hdr(r_), ssao(r_), bl(r_)
+	: RenderingPass(r_), hdr(r_), ssao(r_), bl(r_)
 {}
 
 //==============================================================================
@@ -17,33 +18,21 @@ Pps::~Pps()
 //==============================================================================
 void Pps::initInternal(const RendererInitializer& initializer)
 {
-	enabled = initializer.pps.enabled;
-	if(!enabled)
-	{
-		return;
-	}
-
 	ssao.init(initializer);
 	hdr.init(initializer);
-	drawToDefaultFbo = initializer.pps.drawToDefaultFbo;
+
+	width = initializer.width / initializer.renderingQuality;
+	height = initializer.height / initializer.renderingQuality;
 
 	// FBO
-	if(!drawToDefaultFbo)
-	{
-		Renderer::createFai(r->getWidth(), r->getHeight(), GL_RGB, GL_RGB,
-			GL_FLOAT, fai);
-
-		fbo.create();
-		fbo.setColorAttachments({&fai});
-		if(!fbo.isComplete())
-		{
-			throw ANKI_EXCEPTION("Fbo not complete");
-		}
-	}
-	else
+	Renderer::createFai(r->getWidth(), r->getHeight(), GL_RGB, GL_RGB,
+		GL_FLOAT, fai);
+
+	fbo.create();
+	fbo.setColorAttachments({&fai});
+	if(!fbo.isComplete())
 	{
-		width = initializer.width / initializer.renderingQuality;
-		height = initializer.height / initializer.renderingQuality;
+		throw ANKI_EXCEPTION("Fbo not complete");
 	}
 
 	// SProg
@@ -78,8 +67,6 @@ void Pps::init(const Renderer::Initializer& initializer)
 //==============================================================================
 void Pps::run()
 {
-	ANKI_ASSERT(enabled);
-
 	GlStateSingleton::get().disable(GL_BLEND);
 
 	// First SSAO because it depends on MS where HDR depends on IS

src/renderer/Renderer.cpp

@@ -85,10 +85,7 @@ void Renderer::render(Scene& scene_)
 	ms.run();
 	is.run();
 	bs.run();
-	if(pps.getEnabled())
-	{
-		pps.run();
-	}
+	pps.run();
 
 	ANKI_CHECK_GL_ERROR();
 	++framesNum;

src/scene/Movable.cpp

@@ -35,14 +35,14 @@ void Movable::updateWorldTransform()
 {
 	prevWTrf = wTrf;
 	const Movable* parent = getParent();
-	const Bool dirty = isFlagEnabled(MF_TRANSFORM_DIRTY);
+	const Bool dirty = flagsEnabled(MF_TRANSFORM_DIRTY);
 
 	// If dirty then update world transform
 	if(dirty)
 	{
 		if(parent)
 		{
-			if(isFlagEnabled(MF_IGNORE_LOCAL_TRANSFORM))
+			if(flagsEnabled(MF_IGNORE_LOCAL_TRANSFORM))
 			{
 				wTrf = parent->getWorldTransform();
 			}
@@ -74,7 +74,7 @@ void Movable::updateWorldTransform()
 	}
 
 	// Now it's a good time to cleanse parent
-	disableFlag(MF_TRANSFORM_DIRTY);
+	disableFlags(MF_TRANSFORM_DIRTY);
 }
 
 } // end namespace anki

src/scene/Scene.cpp

@@ -104,19 +104,15 @@ void Scene::update(F32 prevUpdateTime, F32 crntTime, Renderer& r)
 		Spatial* sp = n->getSpatial();
 		if(sp && sp->getSpatialTimestamp() == Timestamp::getTimestamp())
 		{
-			for(Sector* sector : sectors)
-			{
-				if(sector->placeSceneNode(n))
-				{
-					//ANKI_LOGI("Placing: " << n->getName());
-					continue;
-				}
-			}
+			sectorGroup.placeSceneNode(n);
 		}
 	}
 
 	doVisibilityTests(*mainCam, r);
 
+	sectorGroup.doVisibilityTests(*mainCam,
+		VisibilityTest(VT_RENDERABLES | VT_LIGHTS), &r);
+
 #if 0
 	for(SceneNode* n : nodes)
 	{

src/scene/VisibilityTester.cpp

@@ -109,7 +109,7 @@ struct VisibilityTestJob: ThreadJob
 				}
 			}
 
-			sp->enableFlag(Spatial::SF_VISIBLE_CAMERA);
+			sp->enableFlags(Spatial::SF_VISIBLE_CAMERA);
 		} // end for
 
 		VisibilityInfo& vinfo = frustumable->getVisibilityInfo();
@@ -165,7 +165,7 @@ struct VisibilityTestJob: ThreadJob
 				continue;
 			}
 
-			sp->enableFlag(Spatial::SF_VISIBLE_LIGHT);
+			sp->enableFlags(Spatial::SF_VISIBLE_LIGHT);
 
 			Renderable* r = node->getRenderable();
 			if(r)
@@ -217,7 +217,7 @@ void VisibilityTester::test(Frustumable& ref, Scene& scene, Renderer& r)
 
 		if(sp)
 		{
-			sp->disableFlag(Spatial::SF_VISIBLE_ANY);
+			sp->disableFlags(Spatial::SF_VISIBLE_ANY);
 		}
 	}
 

testapp/Main.cpp

@@ -344,6 +344,22 @@ void mainLoopExtra()
 			!MainRendererSingleton::get().getDbg().getDepthTestEnabled());
 	}
 
+	if(in.getKey(KC_F1) == 1)
+	{
+		MainRendererSingleton::get().getDbg().setEnabled(
+			!MainRendererSingleton::get().getDbg().getEnabled());
+	}
+	if(in.getKey(KC_F2) == 1)
+	{
+		MainRendererSingleton::get().getDbg().switchFlags(
+			Dbg::DF_SPATIAL);
+	}
+	if(in.getKey(KC_F3) == 1)
+	{
+		MainRendererSingleton::get().getDbg().switchFlags(
+			Dbg::DF_PHYSICS);
+	}
+
 	if(in.getKey(KC_UP)) mover->rotateLocalX(ang);
 	if(in.getKey(KC_DOWN)) mover->rotateLocalX(-ang);
 	if(in.getKey(KC_LEFT)) mover->rotateLocalY(ang);