Refactoring renderer

include/anki/Renderer.h

@@ -7,6 +7,7 @@
 #define ANKI_RENDERER_H
 
 #include "anki/renderer/MainRenderer.h"
+#include "anki/renderer/Dbg.h"
 
 /// @defgroup renderer Renderering system
 

include/anki/renderer/Bl.h

@@ -1,83 +0,0 @@
-// Copyright (C) 2009-2015, Panagiotis Christopoulos Charitos.
-// All rights reserved.
-// Code licensed under the BSD License.
-// http://www.anki3d.org/LICENSE
-
-#ifndef ANKI_RENDERER_BL_H
-#define ANKI_RENDERER_BL_H
-
-#include "anki/renderer/RenderingPass.h"
-#include "anki/resource/TextureResource.h"
-#include "anki/resource/ShaderResource.h"
-#include "anki/Gr.h"
-
-namespace anki {
-
-class ShaderResource;
-
-/// Blurring rendering pass
-class Bl: public RenderingPass
-{
-public:
-	Bl(Renderer* r)
-	:	RenderingPass(r)
-	{}
-
-	void init(const ConfigSet& initializer);
-	void run();
-
-#if 0
-	/// @name Accessors
-	/// @{
-	F32 getSideBlurFactor() const
-	{
-		return sideBlurFactor;
-	}
-	F32& getSideBlurFactor()
-	{
-		return sideBlurFactor;
-	}
-	void setSideBlurFactor(const F32 x)
-	{
-		sideBlurFactor = x;
-	}
-
-	uint32_t getBlurringIterationsNum() const
-	{
-		return blurringIterationsNum;
-	}
-	uint32_t& getBlurringIterationsNum()
-	{
-		return blurringIterationsNum;
-	}
-	void setBlurringIterationsNum(const uint32_t x)
-	{
-		blurringIterationsNum = x;
-	}
-	/// @}
-#endif
-
-private:
-#if 0
-	Fbo hBlurFbo; ///< Fbo that writes to blurFai
-	Fbo vBlurFbo; ///< Fbo that writes to postPassSProg
-	Fbo sideBlurFbo;
-
-	ShaderResourcePointer hBlurSProg;
-	ShaderResourcePointer vBlurSProg;
-	ShaderResourcePointer sideBlurSProg;
-
-	Texture blurFai; ///< Temp FAI for blurring
-	TextureResourcePointer sideBlurMap;
-
-	uint32_t blurringIterationsNum; ///< How many times the pass will run
-	float sideBlurFactor;
-
-	void runBlur();
-	void runSideBlur();
-#endif
-};
-
-} // end namespace
-
-#endif

include/anki/renderer/Common.h

@@ -12,7 +12,9 @@
 namespace anki {
 
 // Forward
+class Renderer;
 class Ms;
+class Is;
 class Fs;
 class Lf;
 class Ssao;
@@ -21,13 +23,20 @@ class Sslf;
 class Tm;
 class Bloom;
 class Pps;
+class Dbg;
+class Tiler;
+
+/// Cut the job submition into multiple chains. We want to avoid feeding
+/// GL with a huge job chain
+const U RENDERER_COMMAND_BUFFERS_COUNT = 2;
 
 // Render target formats
-const U MS_COLOR_ATTACHMENTS_COUNT = 2;
+const U MS_COLOR_ATTACHMENTS_COUNT = 3;
 
-const Array<PixelFormat, MS_COLOR_ATTACHMENTS_COUNT> 
+const Array<PixelFormat, MS_COLOR_ATTACHMENTS_COUNT>
 	MS_COLOR_ATTACHMENTS_PIXEL_FORMAT = {{
 	{ComponentFormat::R8G8B8A8, TransformFormat::UNORM, false},
+	{ComponentFormat::R8G8B8A8, TransformFormat::UNORM, false},
 	{ComponentFormat::R8G8B8A8, TransformFormat::UNORM, false}}};
 
 const PixelFormat MS_DEPTH_STENCIL_ATTACHMENT_FORMAT = {

include/anki/renderer/Dbg.h

@@ -37,11 +37,21 @@ ANKI_ENUM_ALLOW_NUMERIC_OPERATIONS(DbgFlag, inline)
 /// Debugging stage
 class Dbg: public RenderingPass, public Bitset<detail::DbgFlag>
 {
-	friend class Renderer;
-
 public:
 	using Flag = detail::DbgFlag;
 
+	/// @privatesection
+	/// @{
+	Dbg(Renderer* r)
+	:	RenderingPass(r)
+	{}
+
+	~Dbg();
+
+	ANKI_USE_RESULT Error init(const ConfigSet& initializer);
+
+	ANKI_USE_RESULT Error run(CommandBufferPtr& jobs);
+
 	Bool getDepthTestEnabled() const
 	{
 		return m_depthTest;
@@ -56,27 +66,17 @@ public:
 	{
 		m_depthTest = !m_depthTest;
 	}
+	/// @}
 
 private:
 	FramebufferPtr m_fb;
 	DebugDrawer* m_drawer = nullptr;
 	// Have it as ptr because the constructor calls opengl
 	SceneDebugDrawer* m_sceneDrawer = nullptr;
-	Bool8 m_depthTest = true;
-
-	Dbg(Renderer* r)
-	:	RenderingPass(r)
-	{}
-	
-	~Dbg();
-
-	ANKI_USE_RESULT Error init(const ConfigSet& initializer);
-
-	ANKI_USE_RESULT Error run(CommandBufferPtr& jobs);
+	Bool m_depthTest = true;
 };
-
 /// @}
 
-} // end namespace
+} // end namespace anki
 
 #endif

include/anki/renderer/Is.h

@@ -34,7 +34,7 @@ class TaskCommonData;
 /// @{
 
 /// Illumination stage
-class Is: private RenderingPass
+class Is: public RenderingPass
 {
 	friend class Renderer;
 	friend class Sslr;
@@ -45,6 +45,14 @@ public:
 
 	/// @privatesection
 	/// @{
+	Is(Renderer* r);
+
+	~Is();
+
+	ANKI_USE_RESULT Error init(const ConfigSet& initializer);
+
+	ANKI_USE_RESULT Error run(CommandBufferPtr& cmdBuff);
+
 	TexturePtr& _getRt()
 	{
 		return m_rt;
@@ -54,6 +62,11 @@ public:
 	{
 		m_rt.generateMipmaps(cmdb);
 	}
+
+	void setAmbientColor(const Vec4& color)
+	{
+		m_ambientColor = color;
+	}
 	/// @}
 
 private:
@@ -107,7 +120,7 @@ private:
 	Sm m_sm;
 
 	/// Opt because many ask for it
-	Camera* m_cam;
+	SceneNode* m_cam;
 
 	/// If enabled the ground emmits a light
 	Bool8 m_groundLightEnabled;
@@ -128,11 +141,7 @@ private:
 	U32 m_maxLightIds;
 	/// @}
 
-	Is(Renderer* r);
-	~Is();
-
-	ANKI_USE_RESULT Error init(const ConfigSet& initializer);
-	ANKI_USE_RESULT Error run(CommandBufferPtr& cmdBuff);
+	Vec4 m_ambientColor = Vec4(0.0);
 
 	/// Called by init
 	ANKI_USE_RESULT Error initInternal(const ConfigSet& initializer);
@@ -155,11 +164,11 @@ private:
 	void binLights(U32 threadId, PtrSize threadsCount, TaskCommonData& data);
 	I writePointLight(const LightComponent& light, const MoveComponent& move,
 		const FrustumComponent& camfrc, TaskCommonData& task);
-	I writeSpotLight(const LightComponent& lightc, 
-		const MoveComponent& lightMove, const FrustumComponent* lightFrc, 
-		const MoveComponent& camMove, const FrustumComponent& camFrc, 
+	I writeSpotLight(const LightComponent& lightc,
+		const MoveComponent& lightMove, const FrustumComponent* lightFrc,
+		const MoveComponent& camMove, const FrustumComponent& camFrc,
 		TaskCommonData& task);
-	void binLight(SpatialComponent& sp, U pos, U lightType, 
+	void binLight(SpatialComponent& sp, U pos, U lightType,
 		TaskCommonData& task);
 };
 

include/anki/renderer/MainRenderer.h

@@ -6,15 +6,22 @@
 #ifndef ANKI_RENDERER_MAIN_RENDERER_H
 #define ANKI_RENDERER_MAIN_RENDERER_H
 
-#include "anki/renderer/Renderer.h"
+#include "anki/renderer/Common.h"
+#include "anki/core/Timestamp.h"
+#include "anki/resource/Forward.h"
 
 namespace anki {
 
+// Forward
+class ResourceManager;
+class ConfigSet;
+class SceneGraph;
+
 /// @addtogroup renderer
 /// @{
 
 /// Main onscreen renderer
-class MainRenderer: public Renderer
+class MainRenderer
 {
 public:
 	MainRenderer();
@@ -32,19 +39,35 @@ public:
 
 	ANKI_USE_RESULT Error render(SceneGraph& scene);
 
-	/// Save the color buffer to a tga (lossless & uncompressed & slow)
-	/// or jpeg (lossy & compressed fast)
-	/// @param filename The file to save
-	void takeScreenshot(const char* filename);
+	const String& getMaterialShaderSource() const
+	{
+		return m_materialShaderSource;
+	}
+
+	Dbg& getDbg();
+
+	F32 getAspectRatio() const;
 
 private:
+	HeapAllocator<U8> m_alloc;
+	StackAllocator<U8> m_frameAlloc;
+
+	UniquePtr<Renderer> m_r;
+
 	ShaderResourcePointer m_blitFrag;
 	PipelinePtr m_blitPpline;
 
+	FramebufferPtr m_defaultFb;
+	U32 m_width = 0; ///< Default FB size.
+	U32 m_height = 0; ///< Default FB size.
+
+	String m_materialShaderSource; ///< String to append in user shaders
+
+	F32 m_renderingQuality = 1.0;
+
 	/// Optimize job chain
-	Array<CommandBufferInitHints, JOB_CHAINS_COUNT> m_jobsInitHints;
+	Array<CommandBufferInitHints, RENDERER_COMMAND_BUFFERS_COUNT> m_cbInitHints;
 
-	void takeScreenshotTga(const char* filename);
 	void initGl();
 };
 /// @}

include/anki/renderer/Ms.h

@@ -18,11 +18,20 @@ namespace anki {
 /// Material stage also known as G buffer stage. It populates the G buffer
 class Ms: public RenderingPass
 {
-	friend class Renderer;
-
 public:
 	/// @privatesection
 	/// @{
+	Ms(Renderer* r)
+	:	RenderingPass(r),
+		m_ez(r)
+	{}
+
+	~Ms();
+
+	ANKI_USE_RESULT Error init(const ConfigSet& initializer);
+
+	ANKI_USE_RESULT Error run(CommandBufferPtr& jobs);
+
 	TexturePtr& getRt0()
 	{
 		return m_planes[1].m_rt0;
@@ -76,16 +85,7 @@ private:
 	/// One for multisampled and one for not. 0: multisampled, 1: not
 	Array<Plane, 2> m_planes;
 
-	Ms(Renderer* r)
-	:	RenderingPass(r),
-		m_ez(r)
-	{}
-
-	~Ms();
-
-	ANKI_USE_RESULT Error init(const ConfigSet& initializer);
 	ANKI_USE_RESULT Error initInternal(const ConfigSet& initializer);
-	ANKI_USE_RESULT Error run(CommandBufferPtr& jobs);
 
 	/// Create a G buffer FBO
 	ANKI_USE_RESULT Error createRt(U32 index, U32 samples);

include/anki/renderer/Renderer.h

@@ -7,25 +7,19 @@
 #define ANKI_RENDERER_RENDERER_H
 
 #include "anki/renderer/Common.h"
+#include "anki/renderer/Drawer.h"
 #include "anki/Math.h"
-#include "anki/resource/ResourceManager.h"
-#include "anki/resource/TextureResource.h"
-#include "anki/resource/ShaderResource.h"
 #include "anki/Gr.h"
-#include "anki/util/HighRezTimer.h"
 #include "anki/scene/Forward.h"
-
-#include "anki/renderer/Ms.h"
-#include "anki/renderer/Is.h"
-#include "anki/renderer/Pps.h"
-#include "anki/renderer/Dbg.h"
-#include "anki/renderer/Tiler.h"
-#include "anki/renderer/Drawer.h"
+#include "anki/resource/Forward.h"
+#include "anki/resource/ShaderResource.h"
+#include "anki/core/Timestamp.h"
 
 namespace anki {
 
 // Forward
 class ConfigSet;
+class ResourceManager;
 
 /// @addtogroup renderer
 /// @{
@@ -35,10 +29,6 @@ class ConfigSet;
 class Renderer
 {
 public:
-	/// Cut the job submition into multiple chains. We want to avoid feeding
-	/// GL with a huge job chain
-	static const U32 JOB_CHAINS_COUNT = 2;
-
 	const U TILE_SIZE = 64;
 
 	Renderer();
@@ -47,47 +37,52 @@ public:
 
 	const Ms& getMs() const
 	{
-		return m_ms;
+		return *m_ms;
 	}
+
 	Ms& getMs()
 	{
-		return m_ms;
+		return *m_ms;
 	}
 
 	const Is& getIs() const
 	{
-		return m_is;
+		return *m_is;
 	}
+
 	Is& getIs()
 	{
-		return m_is;
+		return *m_is;
 	}
 
 	const Tiler& getTiler() const
 	{
-		return m_tiler;
+		return *m_tiler;
 	}
+
 	Tiler& getTiler()
 	{
-		return m_tiler;
+		return *m_tiler;
 	}
 
 	const Pps& getPps() const
 	{
-		return m_pps;
+		return *m_pps;
 	}
+
 	Pps& getPps()
 	{
-		return m_pps;
+		return *m_pps;
 	}
 
 	const Dbg& getDbg() const
 	{
-		return m_dbg;
+		return *m_dbg;
 	}
+
 	Dbg& getDbg()
 	{
-		return m_dbg;
+		return *m_dbg;
 	}
 
 	U32 getWidth() const
@@ -100,23 +95,6 @@ public:
 		return m_height;
 	}
 
-	U32 getDefaultFramebufferWidth() const
-	{
-		ANKI_ASSERT(!m_isOffscreen);
-		return m_defaultFbWidth;
-	}
-
-	U32 getDefaultFramebufferHeight() const
-	{
-		ANKI_ASSERT(!m_isOffscreen);
-		return m_defaultFbHeight;
-	}
-
-	F32 getRenderingQuality() const
-	{
-		return m_renderingQuality;
-	}
-
 	F32 getAspectRatio() const
 	{
 		return F32(m_width) / m_height;
@@ -127,19 +105,21 @@ public:
 		return m_framesNum;
 	}
 
-	const SceneGraph& getSceneGraph() const
+	const SceneNode& getActiveCamera() const
 	{
-		return *m_scene;
+		return *m_frustumable;
 	}
-	SceneGraph& getSceneGraph()
+
+	SceneNode& getActiveCamera()
 	{
-		return *m_scene;
+		return *m_frustumable;
 	}
 
 	const RenderableDrawer& getSceneDrawer() const
 	{
 		return m_sceneDrawer;
 	}
+
 	RenderableDrawer& getSceneDrawer()
 	{
 		return m_sceneDrawer;
@@ -149,6 +129,7 @@ public:
 	{
 		return m_projectionParamsUpdateTimestamp;
 	}
+
 	const Vec4& getProjectionParameters() const
 	{
 		return m_projectionParams;
@@ -159,11 +140,6 @@ public:
 		return m_samples;
 	}
 
-	Bool getIsOffscreen() const
-	{
-		return m_isOffscreen;
-	}
-
 	Bool getTessellationEnabled() const
 	{
 		return m_tessellation;
@@ -189,14 +165,27 @@ public:
 		return m_drawQuadVert->getGrShader();
 	}
 
-	FramebufferPtr& getDefaultFramebuffer()
+	/// Set the output of the renderer.
+	void setOutputFramebuffer(FramebufferPtr outputFb, U32 width, U32 height)
 	{
-		return m_defaultFb;
+		m_outputFb = outputFb;
+		m_outputFbSize = UVec2(width, height);
 	}
 
-	/// This function does all the rendering stages and produces a final FAI
-	ANKI_USE_RESULT Error render(SceneGraph& scene,
-		Array<CommandBufferPtr, JOB_CHAINS_COUNT>& cmdBuff);
+	void getOutputFramebuffer(FramebufferPtr& outputFb, U32& width, U32& height)
+	{
+		if(m_outputFb.isCreated())
+		{
+			outputFb = m_outputFb;
+			width = m_outputFbSize.x();
+			height = m_outputFbSize.y();
+		}
+	}
+
+	/// This function does all the rendering stages and produces a final result.
+	ANKI_USE_RESULT Error render(
+		SceneNode& frustumableNode,
+		Array<CommandBufferPtr, RENDERER_COMMAND_BUFFERS_COUNT>& cmdBuff);
 
 	/// My version of gluUnproject
 	/// @param windowCoords Window screen coords
@@ -239,14 +228,14 @@ public:
 		Threadpool* threadpool,
 		ResourceManager* resources,
 		GrManager* gl,
-		AllocAlignedCallback allocCb,
-		void* allocCbUserData,
+		HeapAllocator<U8> alloc,
+		StackAllocator<U8> frameAlloc,
 		const ConfigSet& config,
 		const Timestamp* globalTimestamp);
 
 	/// @privatesection
 	/// @{
-	GrManager& _getGrManager()
+	GrManager& getGrManager()
 	{
 		return *m_gr;
 	}
@@ -261,24 +250,19 @@ public:
 		return m_frameAlloc;
 	}
 
-	ResourceManager& _getResourceManager()
+	ResourceManager& getResourceManager()
 	{
 		return *m_resources;
 	}
 
-	Threadpool& _getThreadpool()
+	Threadpool& getThreadpool()
 	{
 		return *m_threadpool;
 	}
 
-	const String& _getShadersPrependedSource() const
-	{
-		return m_shadersPrependedSource;
-	}
-
 	Timestamp getGlobalTimestamp() const
 	{
-		return *m_grobalTimestamp;
+		return *m_globalTimestamp;
 	}
 	/// @}
 
@@ -288,24 +272,21 @@ private:
 	GrManager* m_gr;
 	HeapAllocator<U8> m_alloc;
 	StackAllocator<U8> m_frameAlloc;
-	const Timestamp* m_grobalTimestamp = nullptr;
+	const Timestamp* m_globalTimestamp = nullptr;
 
 	/// @name Rendering stages
 	/// @{
-	Ms m_ms; ///< Material rendering stage
-	Is m_is; ///< Illumination rendering stage
-	Pps m_pps; ///< Postprocessing rendering stage
-	Fs* m_fs = nullptr; ///< Forward shading.
-	Lf* m_lf = nullptr; ///< Forward shading lens flares.
-	Dbg m_dbg; ///< Debug stage
-	Tiler m_tiler;
+	UniquePtr<Ms> m_ms; ///< Material rendering stage
+	UniquePtr<Is> m_is; ///< Illumination rendering stage
+	UniquePtr<Pps> m_pps; ///< Postprocessing rendering stage
+	UniquePtr<Fs> m_fs; ///< Forward shading.
+	UniquePtr<Lf> m_lf; ///< Forward shading lens flares.
+	UniquePtr<Tiler> m_tiler;
+	UniquePtr<Dbg> m_dbg; ///< Debug stage.
 	/// @}
 
 	U32 m_width;
 	U32 m_height;
-	U32 m_defaultFbWidth;
-	U32 m_defaultFbHeight;
-	F32 m_renderingQuality;
 
 	F32 m_lodDistance; ///< Distance that used to calculate the LOD
 	U8 m_samples; ///< Number of sample in multisampling
@@ -326,23 +307,21 @@ private:
 
 	/// A vector that contains useful numbers for calculating the view space
 	/// position from the depth
-	Vec4 m_projectionParams;
+	Vec4 m_projectionParams = Vec4(0.0);
 
 	Timestamp m_projectionParamsUpdateTimestamp = 0;
 	/// @}
 
-	SceneGraph* m_scene; ///< Current scene
+	SceneNode* m_frustumable = nullptr; ///< Cache current frustumable node.
 	RenderableDrawer m_sceneDrawer;
 
 	U m_framesNum; ///< Frame number
 
-	FramebufferPtr m_defaultFb;
-
-	String m_shadersPrependedSource; ///< String to append in user shaders
+	FramebufferPtr m_outputFb;
+	UVec2 m_outputFbSize;
 
 	ANKI_USE_RESULT Error initInternal(const ConfigSet& initializer);
 };
-
 /// @}
 
 } // end namespace anki

include/anki/scene/SceneGraph.h

@@ -20,7 +20,7 @@
 namespace anki {
 
 // Forward
-class Renderer;
+class MainRenderer;
 class ResourceManager;
 class Camera;
 class Input;
@@ -117,8 +117,8 @@ public:
 		return *m_threadpool;
 	}
 
-	ANKI_USE_RESULT Error update(
-		F32 prevUpdateTime, F32 crntTime, Renderer& renderer);
+	ANKI_USE_RESULT Error update(F32 prevUpdateTime, F32 crntTime,
+		MainRenderer& renderer);
 
 	SceneNode& findSceneNode(const CString& name);
 	SceneNode* tryFindSceneNode(const CString& name);

include/anki/scene/Visibility.h

@@ -16,7 +16,7 @@
 namespace anki {
 
 // Forward
-class Renderer;
+class MainRenderer;
 
 /// @addtogroup scene
 /// @{
@@ -89,8 +89,8 @@ public:
 
 	void prepareMerge()
 	{
-		ANKI_ASSERT(m_renderablesCount == 0 
-			&& m_lightsCount == 0 
+		ANKI_ASSERT(m_renderablesCount == 0
+			&& m_lightsCount == 0
 			&& m_flaresCount == 0);
 		m_renderablesCount = m_renderables.getSize();
 		m_lightsCount = m_lights.getSize();
@@ -104,7 +104,7 @@ public:
 
 	VisibleNode* getRenderablesEnd()
 	{
-		return (m_renderablesCount) 
+		return (m_renderablesCount)
 			? (&m_renderables[0] + m_renderablesCount) : nullptr;
 	}
 
@@ -166,15 +166,15 @@ private:
 	U32 m_lightsCount = 0;
 	U32 m_flaresCount = 0;
 
-	void moveBack(SceneFrameAllocator<U8> alloc, 
+	void moveBack(SceneFrameAllocator<U8> alloc,
 		Container& c, U32& count, VisibleNode& x);
 };
 
-/// Do visibility tests bypassing portals 
+/// Do visibility tests bypassing portals
 ANKI_USE_RESULT Error doVisibilityTests(
-	SceneNode& frustumable, 
-	SceneGraph& scene, 
-	Renderer& renderer);
+	SceneNode& frustumable,
+	SceneGraph& scene,
+	MainRenderer& renderer);
 /// @}
 
 } // end namespace anki

src/core/App.cpp

@@ -244,7 +244,7 @@ Error App::createInternal(const ConfigSet& config_,
 		&m_globalTimestamp));
 
 	m_resources->_setShadersPrependedSource(
-		m_renderer->_getShadersPrependedSource().toCString());
+		m_renderer->getMaterialShaderSource().toCString());
 
 	// Scene
 	m_scene = m_heapAlloc.newInstance<SceneGraph>();

src/renderer/Bl.cpp

@@ -1,146 +0,0 @@
-// Copyright (C) 2009-2015, Panagiotis Christopoulos Charitos.
-// All rights reserved.
-// Code licensed under the BSD License.
-// http://www.anki3d.org/LICENSE
-
-#include "anki/renderer/Bl.h"
-#include "anki/renderer/Renderer.h"
-#include "anki/resource/ShaderResource.h"
-
-namespace anki {
-
-#if 0
-//==============================================================================
-void Bl::init(const ConfigSet& initializer)
-{
-	enabled = initializer.pps.bl.enabled;
-	blurringIterationsNum = initializer.pps.bl.blurringIterationsNum;
-	sideBlurFactor = initializer.pps.bl.sideBlurFactor;
-
-	if(!enabled)
-	{
-		return;
-	}
-
-	// Horizontal
-	//
-	try
-	{
-		Renderer::createFai(r->getWidth(), r->getHeight(), GL_RGB, GL_RGB,
-			GL_FLOAT, blurFai);
-
-		hBlurFbo.create();
-		hBlurFbo.setColorAttachments({&blurFai});
-	}
-	catch(const std::exception& e)
-	{
-		throw ANKI_EXCEPTION("Cannot create horizontal blur "
-			"post-processing stage FBO") << e;
-	}
-
-	hBlurSProg.load(ShaderResource::createSrcCodeToCache(
-		"shaders/PpsBlurGeneric.glsl", "#define HPASS\n").c_str());
-
-	// Vertical
-	//
-	try
-	{
-		vBlurFbo.create();
-		vBlurFbo.setColorAttachments({&r->getPps().getPostPassFai()});
-	}
-	catch(std::exception& e)
-	{
-		throw ANKI_EXCEPTION("Cannot create vertical blur "
-			"post-processing stage FBO") << e;
-	}
-
-	vBlurSProg.load(ShaderResource::createSrcCodeToCache(
-		"shaders/PpsBlurGeneric.glsl", "#define VPASS\n").c_str());
-
-	// Side blur
-	//
-	try
-	{
-		sideBlurFbo.create();
-		sideBlurFbo.setColorAttachments({&r->getMs().getFai0()});
-	}
-	catch(std::exception& e)
-	{
-		throw ANKI_EXCEPTION("Cannot create side blur "
-			"post-processing stage FBO") << e;
-	}
-
-	sideBlurMap.load("engine-rsrc/side-blur.png");
-	sideBlurSProg.load("shaders/PpsSideBlur.glsl");
-}
-
-//==============================================================================
-void Bl::runSideBlur()
-{
-	if(sideBlurFactor == 0.0)
-	{
-		return;
-	}
-
-	sideBlurFbo.bind();
-	sideBlurSProg->bind();
-
-	GlStateSingleton::get().enable(GL_BLEND);
-	glBlendFunc(GL_ONE, GL_ONE);
-
-	sideBlurSProg->findUniformVariable("tex").set(
-		static_cast<const Texture&>(*sideBlurMap));
-	sideBlurSProg->findUniformVariable("factor").set(sideBlurFactor);
-
-	r->drawQuad();
-}
-
-//==============================================================================
-void Bl::runBlur()
-{
-	GlStateSingleton::get().disable(GL_BLEND);
-
-	// Setup programs here. Reverse order
-	vBlurSProg->bind();
-	vBlurSProg->findUniformVariable("img").set(blurFai);
-	vBlurSProg->findUniformVariable("msNormalFai").set(
-		r->getMs().getFai0());
-	vBlurSProg->findUniformVariable("imgDimension").set(
-		float(r->getHeight()));
-
-	hBlurSProg->bind();
-	hBlurSProg->findUniformVariable("img").set(
-		r->getPps().getPostPassFai());
-	hBlurSProg->findUniformVariable("msNormalFai").set(
-		r->getMs().getFai0());
-	hBlurSProg->findUniformVariable("imgDimension").set(
-		float(r->getWidth()));
-
-	for(uint32_t i = 0; i < blurringIterationsNum; i++)
-	{
-		// hpass
-		hBlurFbo.bind();
-		hBlurSProg->bind();
-		r->drawQuad();
-
-		// vpass
-		vBlurFbo.bind();
-		vBlurSProg->bind();
-		r->drawQuad();
-	}
-}
-
-//==============================================================================
-void Bl::run()
-{
-	if(!enabled)
-	{
-		return;
-	}
-
-	runSideBlur();
-	runBlur();
-}
-#endif
-
-} // end namespace anki

src/renderer/Bloom.cpp

@@ -4,6 +4,8 @@
 // http://www.anki3d.org/LICENSE
 
 #include "anki/renderer/Bloom.h"
+#include "anki/renderer/Is.h"
+#include "anki/renderer/Pps.h"
 #include "anki/renderer/Renderer.h"
 #include "anki/renderer/Tm.h"
 #include "anki/misc/ConfigSet.h"
@@ -71,9 +73,15 @@ Error Bloom::initInternal(const ConfigSet& initializer)
 
 	cmdb.flush();
 
+	StringAuto pps(getAllocator());
+	pps.sprintf(
+		"#define ANKI_RENDERER_WIDTH %u\n"
+		"#define ANKI_RENDERER_HEIGHT %u\n",
+		m_r->getWidth(),
+		m_r->getHeight());
+
 	ANKI_CHECK(m_toneFrag.loadToCache(&getResourceManager(),
-		"shaders/PpsBloom.frag.glsl",
-		m_r->_getShadersPrependedSource().toCString(), "r_"));
+		"shaders/PpsBloom.frag.glsl", pps.toCString(), "r_"));
 
 	ANKI_CHECK(m_r->createDrawQuadPipeline(
 		m_toneFrag->getGrShader(), m_tonePpline));
@@ -81,7 +89,7 @@ Error Bloom::initInternal(const ConfigSet& initializer)
 	const char* SHADER_FILENAME =
 		"shaders/VariableSamplingBlurGeneric.frag.glsl";
 
-	StringAuto pps(getAllocator());
+	pps.destroy(getAllocator());
 	pps.sprintf(
 		"#define HPASS\n"
 		"#define COL_RGB\n"

src/renderer/Dbg.cpp

@@ -5,6 +5,9 @@
 
 #include "anki/renderer/Dbg.h"
 #include "anki/renderer/Renderer.h"
+#include "anki/renderer/Ms.h"
+#include "anki/renderer/Is.h"
+#include "anki/renderer/Pps.h"
 #include "anki/resource/ShaderResource.h"
 #include "anki/scene/SceneGraph.h"
 #include "anki/scene/Sector.h"
@@ -35,8 +38,6 @@ Dbg::~Dbg()
 //==============================================================================
 Error Dbg::init(const ConfigSet& initializer)
 {
-	Error err = ErrorCode::NONE;
-
 	m_enabled = initializer.get("dbg.enabled");
 	enableBits(Flag::ALL);
 
@@ -56,16 +57,13 @@ Error Dbg::init(const ConfigSet& initializer)
 		AttachmentLoadOperation::LOAD;
 
 	m_fb.create(&getGrManager(), fbInit);
-	m_drawer = getAllocator().newInstance<DebugDrawer>();
 
-	err = m_drawer->create(m_r);
+	m_drawer = getAllocator().newInstance<DebugDrawer>();
+	ANKI_CHECK(m_drawer->create(m_r));
 
-	if(!err)
-	{
-		m_sceneDrawer = getAllocator().newInstance<SceneDebugDrawer>(m_drawer);
-	}
+	m_sceneDrawer = getAllocator().newInstance<SceneDebugDrawer>(m_drawer);
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 //==============================================================================
@@ -75,18 +73,18 @@ Error Dbg::run(CommandBufferPtr& cmdb)
 
 	ANKI_ASSERT(m_enabled);
 
-	SceneGraph& scene = m_r->getSceneGraph();
-
 	m_fb.bind(cmdb);
 	cmdb.enableDepthTest(m_depthTest);
 
-	Camera& cam = scene.getActiveCamera();
+	SceneNode& cam = m_r->getActiveCamera();
 	FrustumComponent& camFr = cam.getComponent<FrustumComponent>();
 	m_drawer->prepareDraw(cmdb);
 	m_drawer->setViewProjectionMatrix(camFr.getViewProjectionMatrix());
 	m_drawer->setModelMatrix(Mat4::getIdentity());
 	m_drawer->drawGrid();
 
+	SceneGraph& scene = cam.getSceneGraph();
+
 	err = scene.iterateSceneNodes([&](SceneNode& node) -> Error
 	{
 		SpatialComponent* sp = node.tryGetComponent<SpatialComponent>();

src/renderer/DebugDrawer.cpp

@@ -30,10 +30,10 @@ DebugDrawer::~DebugDrawer()
 //==============================================================================
 Error DebugDrawer::create(Renderer* r)
 {
-	GrManager& gl = r->_getGrManager();
+	GrManager& gl = r->getGrManager();
 
-	ANKI_CHECK(m_vert.load("shaders/Dbg.vert.glsl", &r->_getResourceManager()));
-	ANKI_CHECK(m_frag.load("shaders/Dbg.frag.glsl", &r->_getResourceManager()));
+	ANKI_CHECK(m_vert.load("shaders/Dbg.vert.glsl", &r->getResourceManager()));
+	ANKI_CHECK(m_frag.load("shaders/Dbg.frag.glsl", &r->getResourceManager()));
 
 	PipelinePtr::Initializer init;
 	init.m_shaders[U(ShaderType::VERTEX)] = m_vert->getGrShader();

src/renderer/Drawer.cpp

@@ -4,6 +4,7 @@
 // http://www.anki3d.org/LICENSE
 
 #include "anki/renderer/Drawer.h"
+#include "anki/renderer/Ms.h"
 #include "anki/resource/ShaderResource.h"
 #include "anki/scene/FrustumComponent.h"
 #include "anki/resource/Material.h"
@@ -89,7 +90,7 @@ public:
 		case BuildinMaterialVariableId::MVP_MATRIX:
 			if(hasWorldTrfs)
 			{
-				Mat4* mvp = m_drawer->m_r->getSceneGraph().getFrameAllocator().
+				Mat4* mvp = m_drawer->m_r->getFrameAllocator().
 					newInstance<Mat4>(arraySize);
 
 				for(U i = 0; i < arraySize; i++)
@@ -113,7 +114,7 @@ public:
 		case BuildinMaterialVariableId::MV_MATRIX:
 			{
 				ANKI_ASSERT(hasWorldTrfs);
-				Mat4* mv = m_drawer->m_r->getSceneGraph().getFrameAllocator().
+				Mat4* mv = m_drawer->m_r->getFrameAllocator().
 					newInstance<Mat4>(arraySize);
 
 				for(U i = 0; i < arraySize; i++)
@@ -136,7 +137,7 @@ public:
 			if(hasWorldTrfs)
 			{
 				Mat3* normMats =
-					m_drawer->m_r->getSceneGraph().getFrameAllocator().
+					m_drawer->m_r->getFrameAllocator().
 					newInstance<Mat3>(arraySize);
 
 				for(U i = 0; i < arraySize; i++)
@@ -170,7 +171,7 @@ public:
 					m_fr->getViewMatrix().getRotationPart().getTransposed();
 
 				Mat4* bmvp =
-					m_drawer->m_r->getSceneGraph().getFrameAllocator().
+					m_drawer->m_r->getFrameAllocator().
 					newInstance<Mat4>(arraySize);
 
 				for(U i = 0; i < arraySize; i++)

src/renderer/Ez.cpp

@@ -27,8 +27,7 @@ Error Ez::run(CommandBufferPtr& cmdBuff)
 	ANKI_ASSERT(m_enabled);
 
 	Error err = ErrorCode::NONE;
-	SceneGraph& scene = m_r->getSceneGraph();
-	Camera& cam = scene.getActiveCamera();
+	SceneNode& cam = m_r->getActiveCamera();
 	FrustumComponent& camFr = cam.getComponent<FrustumComponent>();
 
 	m_r->getSceneDrawer().prepareDraw(

src/renderer/Fs.cpp

@@ -5,6 +5,8 @@
 
 #include "anki/renderer/Fs.h"
 #include "anki/renderer/Renderer.h"
+#include "anki/renderer/Ms.h"
+#include "anki/renderer/Is.h"
 #include "anki/scene/SceneGraph.h"
 #include "anki/scene/Camera.h"
 
@@ -43,7 +45,7 @@ Error Fs::run(CommandBufferPtr& cmdb)
 	RenderableDrawer& drawer = m_r->getSceneDrawer();
 	drawer.prepareDraw(RenderingStage::BLEND, Pass::COLOR, cmdb);
 
-	Camera& cam = m_r->getSceneGraph().getActiveCamera();
+	SceneNode& cam = m_r->getActiveCamera();
 	FrustumComponent& camFr = cam.getComponent<FrustumComponent>();
 
 	auto it = camFr.getVisibilityTestResults().getRenderablesBegin();

src/renderer/Is.cpp

@@ -5,9 +5,13 @@
 
 #include "anki/renderer/Is.h"
 #include "anki/renderer/Renderer.h"
-#include "anki/scene/SceneGraph.h"
+#include "anki/renderer/Ms.h"
+#include "anki/renderer/Pps.h"
+#include "anki/renderer/Dbg.h"
+#include "anki/renderer/Tiler.h"
 #include "anki/scene/Camera.h"
 #include "anki/scene/Light.h"
+#include "anki/scene/Visibility.h"
 #include "anki/core/Counters.h"
 #include "anki/util/Logger.h"
 #include "anki/misc/ConfigSet.h"
@@ -217,7 +221,6 @@ Error Is::initInternal(const ConfigSet& config)
 	ANKI_CHECK(m_r->createRenderTarget(
 		m_r->getWidth(), m_r->getHeight(),
 		PixelFormat(ComponentFormat::R11G11B10, TransformFormat::FLOAT),
-		//PixelFormat(ComponentFormat::R8G8B8, TransformFormat::UNORM),
 		1, SamplingFilter::LINEAR, MIPMAPS_COUNT, m_rt));
 
 	FramebufferPtr::Initializer fbInit;
@@ -283,8 +286,8 @@ Error Is::initInternal(const ConfigSet& config)
 Error Is::lightPass(CommandBufferPtr& cmdBuff)
 {
 	Error err = ErrorCode::NONE;
-	Threadpool& threadPool = m_r->_getThreadpool();
-	m_cam = &m_r->getSceneGraph().getActiveCamera();
+	Threadpool& threadPool = m_r->getThreadpool();
+	m_cam = &m_r->getActiveCamera();
 	FrustumComponent& fr = m_cam->getComponent<FrustumComponent>();
 	VisibilityTestResults& vi = fr.getVisibilityTestResults();
 
@@ -754,27 +757,20 @@ void Is::binLight(
 //==============================================================================
 void Is::setState(CommandBufferPtr& cmdBuff)
 {
-#if 1
-	Bool drawToDefaultFbo = !m_r->getPps().getEnabled()
-		&& !m_r->getDbg().getEnabled()
-		&& !m_r->getIsOffscreen()
-		&& m_r->getRenderingQuality() == 1.0;
-#else
-	Bool drawToDefaultFbo = false;
-#endif
-
-	if(drawToDefaultFbo)
-	{
-		m_r->getDefaultFramebuffer().bind(cmdBuff);
-		cmdBuff.setViewport(0, 0,
-			m_r->getDefaultFramebufferWidth(),
-			m_r->getDefaultFramebufferHeight());
-	}
-	else
+	Bool isLastStage =
+		!m_r->getPps().getEnabled() && !m_r->getDbg().getEnabled();
+
+	FramebufferPtr fb = m_fb;
+	U32 width = m_r->getWidth();
+	U32 height = m_r->getHeight();
+
+	if(isLastStage)
 	{
-		m_fb.bind(cmdBuff);
-		cmdBuff.setViewport(0, 0, m_r->getWidth(), m_r->getHeight());
+		m_r->getOutputFramebuffer(fb, width, height);
 	}
+
+	fb.bind(cmdBuff);
+	cmdBuff.setViewport(0, 0, width, height);
 }
 
 //==============================================================================
@@ -787,12 +783,11 @@ Error Is::run(CommandBufferPtr& cmdBuff)
 //==============================================================================
 Error Is::updateCommonBlock(CommandBufferPtr& cmdBuff)
 {
-	SceneGraph& scene = m_r->getSceneGraph();
 	shader::CommonUniforms blk;
 
 	// Start writing
 	blk.m_projectionParams = m_r->getProjectionParameters();
-	blk.m_sceneAmbientColor = scene.getAmbientColor();
+	blk.m_sceneAmbientColor = m_ambientColor;
 
 	Vec3 groundLightDir;
 	if(m_groundLightEnabled)

src/renderer/Lf.cpp

@@ -79,7 +79,7 @@ Error Lf::initSprite(const ConfigSet& config)
 
 	// Create buffer
 	PtrSize uboAlignment =
-		m_r->_getGrManager().getBufferOffsetAlignment(GL_UNIFORM_BUFFER);
+		m_r->getGrManager().getBufferOffsetAlignment(GL_UNIFORM_BUFFER);
 	m_flareSize = getAlignedRoundUp(
 		uboAlignment, sizeof(Sprite) * m_maxSpritesPerFlare);
 	PtrSize blockSize = m_flareSize * m_maxFlares;
@@ -140,9 +140,8 @@ Error Lf::initInternal(const ConfigSet& config)
 void Lf::runOcclusionTests(CommandBufferPtr& cmdb)
 {
 	// Retrieve some things
-	SceneGraph& scene = m_r->getSceneGraph();
-	Camera& cam = scene.getActiveCamera();
-	FrustumComponent& camFr = cam.getComponent<FrustumComponent>();
+	FrustumComponent& camFr =
+		m_r->getActiveCamera().getComponent<FrustumComponent>();
 	VisibilityTestResults& vi = camFr.getVisibilityTestResults();
 
 	U totalCount = min<U>(vi.getLensFlaresCount(), m_maxFlares);
@@ -208,8 +207,7 @@ void Lf::runOcclusionTests(CommandBufferPtr& cmdb)
 void Lf::run(CommandBufferPtr& cmdb)
 {
 	// Retrieve some things
-	SceneGraph& scene = m_r->getSceneGraph();
-	Camera& cam = scene.getActiveCamera();
+	SceneNode& cam = m_r->getActiveCamera();
 	FrustumComponent& camFr = cam.getComponent<FrustumComponent>();
 	VisibilityTestResults& vi = camFr.getVisibilityTestResults();
 
@@ -218,7 +216,7 @@ void Lf::run(CommandBufferPtr& cmdb)
 	{
 		// Allocate client buffer
 		const U uboAlignment =
-			m_r->_getGrManager().getBufferOffsetAlignment(GL_UNIFORM_BUFFER);
+			m_r->getGrManager().getBufferOffsetAlignment(GL_UNIFORM_BUFFER);
 		const U bufferSize = m_flareSize * totalCount;
 
 		// Set common rendering state

src/renderer/MainRenderer.cpp

@@ -4,6 +4,12 @@
 // http://www.anki3d.org/LICENSE
 
 #include "anki/renderer/MainRenderer.h"
+#include "anki/renderer/Renderer.h"
+#include "anki/renderer/Is.h"
+#include "anki/renderer/Pps.h"
+#include "anki/renderer/Dbg.h"
+#include "anki/scene/SceneGraph.h"
+#include "anki/scene/Camera.h"
 #include "anki/util/Logger.h"
 #include "anki/renderer/Deformer.h"
 #include "anki/util/File.h"
@@ -20,13 +26,15 @@ MainRenderer::MainRenderer()
 
 //==============================================================================
 MainRenderer::~MainRenderer()
-{}
+{
+	m_materialShaderSource.destroy(m_alloc);
+}
 
 //==============================================================================
 Error MainRenderer::create(
 	Threadpool* threadpool,
 	ResourceManager* resources,
-	GrManager* gl,
+	GrManager* gr,
 	AllocAlignedCallback allocCb,
 	void* allocCbUserData,
 	const ConfigSet& config,
@@ -34,19 +42,43 @@ Error MainRenderer::create(
 {
 	ANKI_LOGI("Initializing main renderer...");
 
-	ANKI_CHECK(Renderer::init(threadpool, resources, gl, allocCb,
-		allocCbUserData, config, globalTimestamp));
+	m_alloc = HeapAllocator<U8>(allocCb, allocCbUserData);
+	m_frameAlloc = StackAllocator<U8>(allocCb, allocCbUserData, 1024 * 1024);
+
+	// Init default FB
+	m_width = config.get("width");
+	m_height = config.get("height");
+	FramebufferPtr::Initializer fbInit;
+	m_defaultFb.create(gr, fbInit);
+
+	// Init renderer
+	ConfigSet config2 = config;
+	m_renderingQuality = config.get("renderingQuality");
+	config2.set("width", m_renderingQuality * F32(m_width));
+	config2.set("height", m_renderingQuality * F32(m_height));
+
+	m_r.reset(m_alloc.newInstance<Renderer>());
+	ANKI_CHECK(m_r->init(threadpool, resources, gr, m_alloc,
+		m_frameAlloc, config2, globalTimestamp));
 
 	initGl();
 
-	ANKI_CHECK(
-		m_blitFrag.load("shaders/Final.frag.glsl", &_getResourceManager()));
+	// Set the default preprocessor string
+	m_materialShaderSource.sprintf(
+		m_alloc,
+		"#define ANKI_RENDERER_WIDTH %u\n"
+		"#define ANKI_RENDERER_HEIGHT %u\n",
+		m_r->getWidth(), m_r->getHeight());
 
-	ANKI_CHECK(createDrawQuadPipeline(
+	// Init other
+	ANKI_CHECK(m_blitFrag.load(
+		"shaders/Final.frag.glsl", &m_r->getResourceManager()));
+
+	ANKI_CHECK(m_r->createDrawQuadPipeline(
 		m_blitFrag->getGrShader(), m_blitPpline));
 
 	ANKI_LOGI("Main renderer initialized. Rendering size %dx%d",
-		getWidth(), getHeight());
+		m_width, m_height);
 
 	return ErrorCode::NONE;
 }
@@ -56,63 +88,74 @@ Error MainRenderer::render(SceneGraph& scene)
 {
 	ANKI_COUNTER_START_TIMER(MAIN_RENDERER_TIME);
 
-	GrManager& gl = _getGrManager();
-	Array<CommandBufferPtr, JOB_CHAINS_COUNT> jobs;
-	CommandBufferPtr& lastJobs = jobs[JOB_CHAINS_COUNT - 1];
+	GrManager& gl = m_r->getGrManager();
+	Array<CommandBufferPtr, RENDERER_COMMAND_BUFFERS_COUNT> cmdbs;
+	CommandBufferPtr& cmdb = cmdbs[RENDERER_COMMAND_BUFFERS_COUNT - 1];
 
-	for(U i = 0; i < JOB_CHAINS_COUNT; i++)
+	for(U i = 0; i < RENDERER_COMMAND_BUFFERS_COUNT; i++)
+	{
+		cmdbs[i].create(&gl, m_cbInitHints[i]);
+	}
+
+	// Find where the m_r should draw
+	Bool rDrawToDefault;
+	if(m_renderingQuality == 1.0 && !m_r->getDbg().getEnabled())
+	{
+		rDrawToDefault = true;
+	}
+	else
 	{
-		jobs[i].create(&gl, m_jobsInitHints[i]);
+		rDrawToDefault = false;
 	}
 
-	ANKI_CHECK(Renderer::render(scene, jobs));
+	if(rDrawToDefault)
+	{
+		m_r->setOutputFramebuffer(m_defaultFb, m_width, m_height);
+	}
+	else
+	{
+		m_r->setOutputFramebuffer(FramebufferPtr(), 0, 0);
+	}
 
-#if 1
-	Bool alreadyDrawnToDefault =
-		!getDbg().getEnabled()
-		&& getRenderingQuality() == 1.0;
-#else
-	const Bool alreadyDrawnToDefault = false;
-	ANKI_LOGW("Have a debug code enabled");
-#endif
+	// Run renderer
+	m_r->getIs().setAmbientColor(scene.getAmbientColor());
+	ANKI_CHECK(m_r->render(scene.getActiveCamera(), cmdbs));
 
-	if(!alreadyDrawnToDefault)
+	if(!rDrawToDefault)
 	{
-		getDefaultFramebuffer().bind(lastJobs);
-		lastJobs.setViewport(0, 0,
-			getDefaultFramebufferWidth(), getDefaultFramebufferHeight());
+		m_defaultFb.bind(cmdb);
+		cmdb.setViewport(0, 0, m_width, m_height);
 
-		m_blitPpline.bind(lastJobs);
+		m_blitPpline.bind(cmdb);
 
 		TexturePtr* rt;
 
-		if(getPps().getEnabled())
+		if(m_r->getPps().getEnabled())
 		{
-			rt = &getPps().getRt();
+			rt = &m_r->getPps().getRt();
 		}
 		else
 		{
-			rt = &getIs()._getRt();
+			rt = &m_r->getIs()._getRt();
 		}
 
 		//rt = &getMs().getRt2();
 		//rt = &getPps().getHdr()._getRt();
 
-		rt->bind(lastJobs, 0);
+		rt->bind(cmdb, 0);
 
-		drawQuad(lastJobs);
+		m_r->drawQuad(cmdb);
 	}
 
+	// Flush the last command buffer
+	cmdb.flush();
+
 	// Set the hints
-	for(U i = 0; i < JOB_CHAINS_COUNT; i++)
+	for(U i = 0; i < RENDERER_COMMAND_BUFFERS_COUNT; i++)
 	{
-		m_jobsInitHints[i] = jobs[i].computeInitHints();
+		m_cbInitHints[i] = cmdbs[i].computeInitHints();
 	}
 
-	// Flush the last job chain
-	//ANKI_ASSERT(lastJobs.get().getReferenceCount() == 1);
-	lastJobs.flush();
-
 	ANKI_COUNTER_STOP_TIMER_INC(MAIN_RENDERER_TIME);
 
 	return ErrorCode::NONE;
@@ -121,9 +164,8 @@ Error MainRenderer::render(SceneGraph& scene)
 //==============================================================================
 void MainRenderer::initGl()
 {
-	// get max texture units
 	CommandBufferPtr cmdb;
-	cmdb.create(&_getGrManager());
+	cmdb.create(&m_r->getGrManager());
 
 	cmdb.enableCulling(true);
 	cmdb.setCullFace(GL_BACK);
@@ -132,82 +174,15 @@ void MainRenderer::initGl()
 }
 
 //==============================================================================
-void MainRenderer::takeScreenshotTga(const char* filename)
+Dbg& MainRenderer::getDbg()
 {
-#if 0
-	// open file and check
-	File fs;
-	try
-	{
-		fs.open(filename, File::OF_WRITE | File::OF_BINARY);
-	}
-	catch(const std::exception& e)
-	{
-		throw ANKI_EXCEPTION("Cannot write screenshot file") << e;
-	}
-
-	// write headers
-	static const U8 tgaHeaderUncompressed[12] = {
-		0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0};
-	Array<U8, 6> header;
-
-	header[1] = getWidth() / 256;
-	header[0] = getWidth() % 256;
-	header[3] = getHeight() / 256;
-	header[2] = getHeight() % 256;
-	header[4] = 24;
-	header[5] = 0;
-
-	fs.write((char*)tgaHeaderUncompressed, sizeof(tgaHeaderUncompressed));
-	fs.write((char*)&header[0], sizeof(header));
-
-	// Create the buffers
-	U outBufferSize = getWidth() * getHeight() * 3;
-	Vector<U8> outBuffer;
-	outBuffer.resize(outBufferSize);
-
-	U rgbaBufferSize = getWidth() * getHeight() * 4;
-	Vector<U8> rgbaBuffer;
-	rgbaBuffer.resize(rgbaBufferSize);
-
-	// Read pixels
-	glReadPixels(0, 0, getWidth(), getHeight(), GL_RGBA, GL_UNSIGNED_BYTE,
-		&rgbaBuffer[0]);
-
-	U j = 0;
-	for(U i = 0; i < outBufferSize; i += 3)
-	{
-		outBuffer[i] = rgbaBuffer[j + 2];
-		outBuffer[i + 1] = rgbaBuffer[j + 1];
-		outBuffer[i + 2] = rgbaBuffer[j];
-
-		j += 4;
-	}
-
-	fs.write((char*)&outBuffer[0], outBufferSize);
-
-	// end
-	ANKI_CHECK_GL_ERROR();
-#endif
+	return m_r->getDbg();
 }
 
 //==============================================================================
-void MainRenderer::takeScreenshot(const char* filename)
+F32 MainRenderer::getAspectRatio() const
 {
-#if 0
-	String ext = getFileExtension(filename, getAllocator());
-
-	// exec from this extension
-	if(ext == "tga")
-	{
-		takeScreenshotTga(filename);
-	}
-	else
-	{
-		throw ANKI_EXCEPTION("Unsupported file extension");
-	}
-	ANKI_LOGI("Screenshot %s saved", filename);
-#endif
+	return m_r->getAspectRatio();
 }
 
 } // end namespace anki

src/renderer/Ms.cpp

@@ -121,11 +121,10 @@ Error Ms::run(CommandBufferPtr& cmdb)
 	m_r->getSceneDrawer().prepareDraw(RenderingStage::MATERIAL, Pass::COLOR,
 		cmdb);
 
-	Camera& cam = m_r->getSceneGraph().getActiveCamera();
+	SceneNode& cam = m_r->getActiveCamera();
 
 	VisibilityTestResults& vi =
-		m_r->getSceneGraph().getActiveCamera().
-		getComponent<FrustumComponent>().getVisibilityTestResults();
+		cam.getComponent<FrustumComponent>().getVisibilityTestResults();
 
 	auto it = vi.getRenderablesBegin();
 	auto end = vi.getRenderablesEnd();

src/renderer/Pps.cpp

@@ -11,6 +11,7 @@
 #include "anki/renderer/Sslr.h"
 #include "anki/renderer/Tm.h"
 #include "anki/renderer/Is.h"
+#include "anki/renderer/Dbg.h"
 #include "anki/util/Logger.h"
 #include "anki/misc/ConfigSet.h"
 
@@ -143,24 +144,19 @@ Error Pps::run(CommandBufferPtr& cmdb)
 		m_sslf->run(cmdb);
 	}
 
-	Bool drawToDefaultFbo =
-		!m_r->getDbg().getEnabled()
-		&& !m_r->getIsOffscreen()
-		&& m_r->getRenderingQuality() == 1.0;
+	FramebufferPtr fb = m_fb;
+	U32 width = m_r->getWidth();
+	U32 height = m_r->getHeight();
 
-	if(drawToDefaultFbo)
+	Bool isLastStage = !m_r->getDbg().getEnabled();
+	if(isLastStage)
 	{
-		m_r->getDefaultFramebuffer().bind(cmdb);
-		cmdb.setViewport(0, 0,
-			m_r->getDefaultFramebufferWidth(),
-			m_r->getDefaultFramebufferHeight());
-	}
-	else
-	{
-		m_fb.bind(cmdb);
-		cmdb.setViewport(0, 0, m_r->getWidth(), m_r->getHeight());
+		m_r->getOutputFramebuffer(fb, width, height);
 	}
 
+	fb.bind(cmdb);
+	cmdb.setViewport(0, 0, width, height);
+
 	m_ppline.bind(cmdb);
 
 	m_r->getIs()._getRt().bind(cmdb, 0);

src/renderer/Renderer.cpp

@@ -9,53 +9,40 @@
 #include "anki/core/Counters.h"
 #include "anki/misc/ConfigSet.h"
 
+#include "anki/renderer/Ms.h"
+#include "anki/renderer/Is.h"
+#include "anki/renderer/Pps.h"
 #include "anki/renderer/Fs.h"
 #include "anki/renderer/Lf.h"
-#include "anki/renderer/Is.h"
+#include "anki/renderer/Dbg.h"
+#include "anki/renderer/Tiler.h"
 
 namespace anki {
 
 //==============================================================================
 Renderer::Renderer()
-:	m_ms(this),
-	m_is(this),
-	m_pps(this),
-	m_dbg(this),
-	m_tiler(this)
 {}
 
 //==============================================================================
 Renderer::~Renderer()
-{
-	m_shadersPrependedSource.destroy(m_alloc);
-
-	if(m_fs)
-	{
-		m_alloc.deleteInstance(m_fs);
-	}
-
-	if(m_lf)
-	{
-		m_alloc.deleteInstance(m_lf);
-	}
-}
+{}
 
 //==============================================================================
 Error Renderer::init(
 	Threadpool* threadpool,
 	ResourceManager* resources,
 	GrManager* gl,
-	AllocAlignedCallback allocCb,
-	void* allocCbUserData,
+	HeapAllocator<U8> alloc,
+	StackAllocator<U8> frameAlloc,
 	const ConfigSet& config,
 	const Timestamp* globalTimestamp)
 {
-	m_grobalTimestamp = globalTimestamp;
+	m_globalTimestamp = globalTimestamp;
 	m_threadpool = threadpool;
 	m_resources = resources;
 	m_gr = gl;
-	m_alloc = HeapAllocator<U8>(allocCb, allocCbUserData);
-	m_frameAlloc = StackAllocator<U8>(allocCb, allocCbUserData, 1024 * 1024);
+	m_alloc = alloc;
+	m_frameAlloc = frameAlloc;
 
 	Error err = initInternal(config);
 	if(err)
@@ -70,17 +57,11 @@ Error Renderer::init(
 Error Renderer::initInternal(const ConfigSet& config)
 {
 	// Set from the config
-	m_renderingQuality = config.get("renderingQuality");
-	m_defaultFbWidth = config.get("width");
-	m_defaultFbHeight = config.get("height");
-	m_width = getAlignedRoundDown(
-		TILE_SIZE, U(m_defaultFbWidth * m_renderingQuality));
-	m_height = getAlignedRoundDown(
-		TILE_SIZE, U(m_defaultFbHeight * m_renderingQuality));
+	m_width = getAlignedRoundDown(TILE_SIZE, U(config.get("width")));
+	m_height = getAlignedRoundDown(TILE_SIZE, U(config.get("height")));
 	m_lodDistance = config.get("lodDistance");
 	m_framesNum = 0;
 	m_samples = config.get("samples");
-	m_isOffscreen = config.get("offscreen");
 	m_tilesCount.x() = m_width / TILE_SIZE;
 	m_tilesCount.y() = m_height / TILE_SIZE;
 	m_tilesCountXY = m_tilesCount.x() * m_tilesCount.y();
@@ -113,13 +94,6 @@ Error Renderer::initInternal(const ConfigSet& config)
 		return ErrorCode::USER_DATA;
 	}
 
-	// Set the default preprocessor string
-	m_shadersPrependedSource.sprintf(
-		m_alloc,
-		"#define ANKI_RENDERER_WIDTH %u\n"
-		"#define ANKI_RENDERER_HEIGHT %u\n",
-		m_width, m_height);
-
 	// Drawer
 	ANKI_CHECK(m_sceneDrawer.create(this));
 
@@ -133,78 +107,75 @@ Error Renderer::initInternal(const ConfigSet& config)
 	ANKI_CHECK(m_drawQuadVert.load("shaders/Quad.vert.glsl", m_resources));
 
 	// Init the stages. Careful with the order!!!!!!!!!!
-	ANKI_CHECK(m_tiler.init());
+	m_tiler.reset(m_alloc.newInstance<Tiler>(this));
+	ANKI_CHECK(m_tiler->init());
+
+	m_ms.reset(m_alloc.newInstance<Ms>(this));
+	ANKI_CHECK(m_ms->init(config));
 
-	ANKI_CHECK(m_ms.init(config));
-	ANKI_CHECK(m_is.init(config));
+	m_is.reset(m_alloc.newInstance<Is>(this));
+	ANKI_CHECK(m_is->init(config));
 
-	m_fs = m_alloc.newInstance<Fs>(this);
+	m_fs.reset(m_alloc.newInstance<Fs>(this));
 	ANKI_CHECK(m_fs->init(config));
 
-	m_lf = m_alloc.newInstance<Lf>(this);
+	m_lf.reset(m_alloc.newInstance<Lf>(this));
 	ANKI_CHECK(m_lf->init(config));
 
-	ANKI_CHECK(m_pps.init(config));
-	ANKI_CHECK(m_dbg.init(config));
+	m_pps.reset(m_alloc.newInstance<Pps>(this));
+	ANKI_CHECK(m_pps->init(config));
 
-	// Default FB
-	FramebufferPtr::Initializer fbInit;
-	m_defaultFb.create(m_gr, fbInit);
+	m_dbg.reset(m_alloc.newInstance<Dbg>(this));
+	ANKI_CHECK(m_dbg->init(config));
 
 	return ErrorCode::NONE;
 }
 
 //==============================================================================
-Error Renderer::render(SceneGraph& scene,
-	Array<CommandBufferPtr, JOB_CHAINS_COUNT>& cmdBuff)
+Error Renderer::render(SceneNode& frustumableNode,
+	Array<CommandBufferPtr, RENDERER_COMMAND_BUFFERS_COUNT>& cmdBuff)
 {
-	m_scene = &scene;
+	m_frustumable = &frustumableNode;
 	m_frameAlloc.getMemoryPool().reset();
-	Camera& cam = m_scene->getActiveCamera();
 
 	// Calc a few vars
 	//
-	const FrustumComponent& fr = cam.getComponent<FrustumComponent>();
-	Timestamp camUpdateTimestamp = fr.getTimestamp();
-	if(m_projectionParamsUpdateTimestamp
-			< m_scene->getActiveCameraChangeTimestamp()
-		|| m_projectionParamsUpdateTimestamp < camUpdateTimestamp
-		|| m_projectionParamsUpdateTimestamp == 0)
+	const FrustumComponent& frc =
+		m_frustumable->getComponent<FrustumComponent>();
+	if(frc.getProjectionParameters() != m_projectionParams)
 	{
-		const FrustumComponent& frc = cam.getComponent<FrustumComponent>();
-
 		m_projectionParams = frc.getProjectionParameters();
 		m_projectionParamsUpdateTimestamp = getGlobalTimestamp();
 	}
 
 	ANKI_COUNTER_START_TIMER(RENDERER_MS_TIME);
-	ANKI_CHECK(m_ms.run(cmdBuff[0]));
+	ANKI_CHECK(m_ms->run(cmdBuff[0]));
 	ANKI_COUNTER_STOP_TIMER_INC(RENDERER_MS_TIME);
 
 	m_lf->runOcclusionTests(cmdBuff[0]);
 
-	m_ms.generateMipmaps(cmdBuff[0]);
+	m_ms->generateMipmaps(cmdBuff[0]);
 
-	m_tiler.runMinMax(cmdBuff[0]);
+	m_tiler->runMinMax(cmdBuff[0]);
 	cmdBuff[0].flush();
 
 	ANKI_COUNTER_START_TIMER(RENDERER_IS_TIME);
-	ANKI_CHECK(m_is.run(cmdBuff[1]));
+	ANKI_CHECK(m_is->run(cmdBuff[1]));
 	ANKI_COUNTER_STOP_TIMER_INC(RENDERER_IS_TIME);
 
 	ANKI_CHECK(m_fs->run(cmdBuff[1]));
 	m_lf->run(cmdBuff[1]);
 
 	ANKI_COUNTER_START_TIMER(RENDERER_PPS_TIME);
-	if(m_pps.getEnabled())
+	if(m_pps->getEnabled())
 	{
-		ANKI_CHECK(m_pps.run(cmdBuff[1]));
+		ANKI_CHECK(m_pps->run(cmdBuff[1]));
 	}
 	ANKI_COUNTER_STOP_TIMER_INC(RENDERER_PPS_TIME);
 
-	if(m_dbg.getEnabled())
+	if(m_dbg->getEnabled())
 	{
-		ANKI_CHECK(m_dbg.run(cmdBuff[1]));
+		ANKI_CHECK(m_dbg->run(cmdBuff[1]));
 	}
 
 	++m_framesNum;

src/renderer/RenderingPass.cpp

@@ -18,13 +18,13 @@ Timestamp RenderingPass::getGlobalTimestamp() const
 //==============================================================================
 GrManager& RenderingPass::getGrManager()
 {
-	return m_r->_getGrManager();
+	return m_r->getGrManager();
 }
 
 //==============================================================================
 const GrManager& RenderingPass::getGrManager() const
 {
-	return m_r->_getGrManager();
+	return m_r->getGrManager();
 }
 
 //==============================================================================
@@ -42,7 +42,7 @@ StackAllocator<U8> RenderingPass::getFrameAllocator() const
 //==============================================================================
 ResourceManager& RenderingPass::getResourceManager()
 {
-	return m_r->_getResourceManager();
+	return m_r->getResourceManager();
 }
 
 //==============================================================================

src/renderer/Ssao.cpp

@@ -5,6 +5,7 @@
 
 #include "anki/renderer/Ssao.h"
 #include "anki/renderer/Renderer.h"
+#include "anki/renderer/Ms.h"
 #include "anki/scene/Camera.h"
 #include "anki/scene/SceneGraph.h"
 #include "anki/util/Functions.h"
@@ -235,8 +236,6 @@ Error Ssao::run(CommandBufferPtr& cmdb)
 {
 	ANKI_ASSERT(m_enabled);
 
-	const Camera& cam = m_r->getSceneGraph().getActiveCamera();
-
 	cmdb.setViewport(0, 0, m_width, m_height);
 
 	// 1st pass
@@ -253,7 +252,8 @@ Error Ssao::run(CommandBufferPtr& cmdb)
 	cmdb.bindTextures(0, tarr.begin(), tarr.getSize());
 
 	// Write common block
-	const FrustumComponent& camFr = cam.getComponent<FrustumComponent>();
+	const FrustumComponent& camFr =
+		m_r->getActiveCamera().getComponent<FrustumComponent>();
 
 	if(m_commonUboUpdateTimestamp
 			< m_r->getProjectionParametersUpdateTimestamp()

src/renderer/Sslr.cpp

@@ -5,6 +5,9 @@
 
 #include "anki/renderer/Sslr.h"
 #include "anki/renderer/Ssao.h"
+#include "anki/renderer/Ms.h"
+#include "anki/renderer/Is.h"
+#include "anki/renderer/Pps.h"
 #include "anki/renderer/Renderer.h"
 #include "anki/misc/ConfigSet.h"
 

src/renderer/Tiler.cpp

@@ -5,6 +5,7 @@
 
 #include "anki/renderer/Tiler.h"
 #include "anki/renderer/Renderer.h"
+#include "anki/renderer/Ms.h"
 #include "anki/resource/ShaderResource.h"
 #include "anki/scene/Camera.h"
 #include "anki/scene/SceneGraph.h"
@@ -202,7 +203,7 @@ void Tiler::updateTiles(Camera& cam)
 	Bool frustumChanged =
 		camTimestamp >= m_planes4UpdateTimestamp || m_prevCam != &cam;
 
-	Threadpool& threadPool = m_r->_getThreadpool();
+	Threadpool& threadPool = m_r->getThreadpool();
 	for(U i = 0; i < threadPool.getThreadsCount(); i++)
 	{
 		jobs[i].m_tiler = this;
@@ -452,7 +453,7 @@ void Tiler::testRange(const CollisionShape& cs, Bool nearPlane,
 void Tiler::testFastSphere(const Sphere& s, const Aabb& aabb,
 	TestResult* visible, U& count) const
 {
-	const Camera& cam = m_r->getSceneGraph().getActiveCamera();
+	const SceneNode& cam = m_r->getActiveCamera();
 	const FrustumComponent& frc = cam.getComponent<FrustumComponent>();
 	const Mat4& vp = frc.getViewProjectionMatrix();
 	const Mat4& v = frc.getViewMatrix();

src/scene/SceneGraph.cpp

@@ -9,7 +9,6 @@
 #include "anki/scene/InstanceNode.h"
 #include "anki/scene/Sector.h"
 #include "anki/core/Counters.h"
-#include "anki/renderer/Renderer.h"
 #include "anki/physics/PhysicsWorld.h"
 
 namespace anki {
@@ -249,7 +248,8 @@ void SceneGraph::deleteNodesMarkedForDeletion()
 }
 
 //==============================================================================
-Error SceneGraph::update(F32 prevUpdateTime, F32 crntTime, Renderer& renderer)
+Error SceneGraph::update(F32 prevUpdateTime, F32 crntTime,
+	MainRenderer& renderer)
 {
 	ANKI_ASSERT(m_mainCam);
 
@@ -259,10 +259,6 @@ Error SceneGraph::update(F32 prevUpdateTime, F32 crntTime, Renderer& renderer)
 
 	ANKI_COUNTER_START_TIMER(SCENE_UPDATE_TIME);
 
-	//
-	// Sync point. Here we wait for all scene's threads
-	//
-
 	// Reset the framepool
 	m_frameAlloc.getMemoryPool().reset();
 
@@ -275,7 +271,6 @@ Error SceneGraph::update(F32 prevUpdateTime, F32 crntTime, Renderer& renderer)
 
 	// Update
 	m_physics->updateAsync(crntTime - prevUpdateTime);
-	renderer.getTiler().updateTiles(*m_mainCam);
 	m_physics->waitUpdate();
 	err = m_events.updateAllEvents(prevUpdateTime, crntTime);
 	if(err) return err;

src/scene/Visibility.cpp

@@ -9,7 +9,7 @@
 #include "anki/scene/FrustumComponent.h"
 #include "anki/scene/LensFlareComponent.h"
 #include "anki/scene/Light.h"
-#include "anki/renderer/Renderer.h"
+#include "anki/renderer/MainRenderer.h"
 #include "anki/util/Logger.h"
 
 namespace anki {
@@ -404,7 +404,7 @@ void VisibilityTestResults::moveBack(
 //==============================================================================
 
 //==============================================================================
-Error doVisibilityTests(SceneNode& fsn, SceneGraph& scene, Renderer& r)
+Error doVisibilityTests(SceneNode& fsn, SceneGraph& scene, MainRenderer& r)
 {
 	// Do the tests in parallel
 	Threadpool& threadPool = scene._getThreadpool();

testapp/Main.cpp

@@ -4,13 +4,11 @@
 
 #include "anki/input/Input.h"
 #include "anki/Math.h"
-#include "anki/renderer/Renderer.h"
+#include "anki/Renderer.h"
 #include "anki/core/App.h"
 #include "anki/resource/Mesh.h"
 #include "anki/resource/Material.h"
 #include "anki/resource/SkelAnim.h"
-#include "anki/renderer/Renderer.h"
-#include "anki/renderer/MainRenderer.h"
 #include "anki/script/ScriptManager.h"
 #include "anki/core/StdinListener.h"
 #include "anki/resource/Model.h"
@@ -414,7 +412,7 @@ Error mainLoopExtra(App& app, void*, Bool& quit)
 	}
 	if(in.getKey(KeyCode::F12) == 1)
 	{
-		renderer.takeScreenshot("screenshot.tga");
+		//renderer.takeScreenshot("screenshot.tga");
 	}
 
 #if NO_PLAYER