Small refactoring

include/anki/renderer/Drawer.h

@@ -16,6 +16,7 @@ namespace anki {
 
 // Forward
 class Renderer;
+class SetupRenderableVariableVisitor;
 
 /// @addtogroup renderer
 /// @{
@@ -33,7 +34,9 @@ class RenderableDrawer
 	friend class SetupRenderableVariableVisitor;
 
 public:
-	static const U32 MAX_UNIFORM_BUFFER_SIZE = 1024 * 1024 * 2;
+	RenderableDrawer();
+
+	~RenderableDrawer();
 
 	/// The one and only constructor
 	ANKI_USE_RESULT Error create(Renderer* r);
@@ -49,7 +52,7 @@ public:
 
 private:
 	Renderer* m_r;
-	SArray<U8> m_tempUniformBuffer;
+	UniquePtr<SetupRenderableVariableVisitor> m_variableVisitor;
 
 	/// @name State
 	/// @{

include/anki/renderer/Renderer.h

@@ -251,7 +251,7 @@ public:
 		return *m_gr;
 	}
 
-	HeapAllocator<U8>& _getAllocator()
+	HeapAllocator<U8>& getAllocator()
 	{
 		return m_alloc;
 	}

include/anki/util/Allocator.h

@@ -48,7 +48,7 @@ public:
 	using const_reference = const T&;
 	using value_type = T;
 
-	/// Move assignments between containers will copy the allocator as well. 
+	/// Move assignments between containers will copy the allocator as well.
 	/// If propagate_on_container_move_assignment is not defined then not moves
 	/// are going to happen
 	using propagate_on_container_move_assignment = std::true_type;
@@ -148,10 +148,10 @@ public:
 
 		size_type size = n * sizeof(value_type);
 
-		// Operator new doesn't respect alignment (in GCC at least) so use 
+		// Operator new doesn't respect alignment (in GCC at least) so use
 		// the type's alignment. If hint override the alignment
-		PtrSize alignment = (hint != nullptr) 
-			? *reinterpret_cast<const PtrSize*>(hint) 
+		PtrSize alignment = (hint != nullptr)
+			? *reinterpret_cast<const PtrSize*>(hint)
 			: alignof(value_type);
 
 		void* out = m_pool->allocate(size, alignment);
@@ -188,6 +188,7 @@ public:
 	/// Call destructor
 	void destroy(pointer p)
 	{
+		static_assert(sizeof(T) > 0, "Incomplete type");
 		ANKI_ASSERT(p != nullptr);
 		p->~T();
 	}
@@ -196,6 +197,7 @@ public:
 	template<typename Y>
 	void destroy(Y* p)
 	{
+		static_assert(sizeof(T) > 0, "Incomplete type");
 		ANKI_ASSERT(p != nullptr);
 		p->~Y();
 	}
@@ -392,7 +394,7 @@ inline Bool operator!=(
 template<typename T>
 using GenericMemoryPoolAllocator = GenericPoolAllocator<T, BaseMemoryPool>;
 
-/// Heap based allocator. The default allocator. It uses malloc and free for 
+/// Heap based allocator. The default allocator. It uses malloc and free for
 /// allocations/deallocations
 template<typename T>
 using HeapAllocator = GenericPoolAllocator<T, HeapMemoryPool>;

src/renderer/Drawer.cpp

@@ -33,9 +33,19 @@ public:
 	Ptr<RenderableDrawer> m_drawer;
 	U8 m_instanceCount;
 	CommandBufferHandle m_cmdBuff;
+	Array<U8, MATERIAL_BLOCK_MAX_SIZE> m_tempUniformBuffer;
 
 	F32 m_flod;
 
+	SetupRenderableVariableVisitor(RenderableDrawer* drawer)
+	:	m_drawer(drawer)
+	{}
+
+	HeapAllocator<U8> getAllocator() const
+	{
+		return m_drawer->m_r->getAllocator();
+	}
+
 	/// Set a uniform in a client block
 	template<typename T>
 	void uniSet(const MaterialVariable& mtlVar,
@@ -44,8 +54,8 @@ public:
 		mtlVar.writeShaderBlockMemory<T>(
 			value,
 			size,
-			&m_drawer->m_tempUniformBuffer[0],
-			&m_drawer->m_tempUniformBuffer[0] + MATERIAL_BLOCK_MAX_SIZE);
+			&m_tempUniformBuffer[0],
+			&m_tempUniformBuffer[0] + MATERIAL_BLOCK_MAX_SIZE);
 	}
 
 	template<typename TRenderableVariableTemplate>
@@ -228,10 +238,20 @@ void SetupRenderableVariableVisitor::uniSet<TextureResourcePointer>(
 	tex.bind(m_cmdBuff, unit);
 }
 
+//==============================================================================
+RenderableDrawer::RenderableDrawer()
+{}
+
+//==============================================================================
+RenderableDrawer::~RenderableDrawer()
+{}
+
 //==============================================================================
 Error RenderableDrawer::create(Renderer* r)
 {
 	m_r = r;
+	m_variableVisitor.reset(
+		m_r->getAllocator().newInstance<SetupRenderableVariableVisitor>(this));
 	return ErrorCode::NONE;
 }
 
@@ -248,30 +268,27 @@ void RenderableDrawer::setupUniforms(
 
 	// Call the visitor
 	//
-	SetupRenderableVariableVisitor vis;
-
-	vis.m_visibleNode = &visibleNode;
-	vis.m_renderable = &renderable;
-	vis.m_fr = &fr;
-	vis.m_drawer = this;
-	vis.m_instanceCount = visibleNode.m_spatialsCount;
-	vis.m_cmdBuff = m_cmdBuff;
-	vis.m_flod = flod;
+	m_variableVisitor->m_visibleNode = &visibleNode;
+	m_variableVisitor->m_renderable = &renderable;
+	m_variableVisitor->m_fr = &fr;
+	m_variableVisitor->m_instanceCount = visibleNode.m_spatialsCount;
+	m_variableVisitor->m_cmdBuff = m_cmdBuff;
+	m_variableVisitor->m_flod = flod;
 
 	for(auto it = renderable.getVariablesBegin();
 		it != renderable.getVariablesEnd(); ++it)
 	{
 		RenderComponentVariable* rvar = *it;
 
-		vis.m_rvar = rvar;
-		Error err = rvar->acceptVisitor(vis);
+		m_variableVisitor->m_rvar = rvar;
+		Error err = rvar->acceptVisitor(*m_variableVisitor);
 		(void)err;
 	}
 
 	// Update the uniforms
 	//
 	m_cmdBuff.updateDynamicUniforms(
-		&m_tempUniformBuffer[0], mtl.getDefaultBlockSize());
+		&m_variableVisitor->m_tempUniformBuffer[0], mtl.getDefaultBlockSize());
 }
 
 //==============================================================================
@@ -368,10 +385,6 @@ void RenderableDrawer::prepareDraw(RenderingStage stage, Pass pass,
 	{
 		m_cmdBuff.setPatchVertexCount(3);
 	}
-
-	m_tempUniformBuffer = SArray<U8>(
-		m_r->getFrameAllocator().allocate(MATERIAL_BLOCK_MAX_SIZE),
-		MATERIAL_BLOCK_MAX_SIZE);
 }
 
 //==============================================================================

src/renderer/MainRenderer.cpp

@@ -201,7 +201,7 @@ void MainRenderer::takeScreenshotTga(const char* filename)
 void MainRenderer::takeScreenshot(const char* filename)
 {
 #if 0
-	String ext = getFileExtension(filename, _getAllocator());
+	String ext = getFileExtension(filename, getAllocator());
 
 	// exec from this extension
 	if(ext == "tga")

src/renderer/RenderingPass.cpp

@@ -30,7 +30,7 @@ const GrManager& RenderingPass::getGrManager() const
 //==============================================================================
 HeapAllocator<U8> RenderingPass::getAllocator() const
 {
-	return m_r->_getAllocator();
+	return m_r->getAllocator();
 }
 
 //==============================================================================