2nd step towards the render queue: Move the draw logic in the scene and strip the drawer

src/anki/renderer/Drawer.cpp

@@ -18,154 +18,30 @@
 namespace anki
 {
 
-class CompleteRenderingBuildInfo
-{
-public:
-	F32 m_flod = 0.0;
-	RenderComponent* m_rc = nullptr;
-	RenderingBuildInfoIn m_in;
-	RenderingBuildInfoOut m_out;
-};
-
 /// Drawer's context
 class DrawContext
 {
 public:
-	Pass m_pass;
-	Mat4 m_viewMat;
-	Mat4 m_viewProjMat;
-	CommandBufferPtr m_cmdb;
+	RenderQueueDrawContext m_queueCtx;
 
 	const VisibleNode* m_visibleNode = nullptr;
 
-	Array<Mat4, MAX_INSTANCES> m_cachedTrfs;
-	U m_cachedTrfCount = 0;
-
-	StagingGpuMemoryToken m_uboToken;
-
-	U m_nodeProcessedCount = 0;
-
-	Array<CompleteRenderingBuildInfo, 2> m_buildInfo;
-	U m_crntBuildInfo = 0;
+	Array<RenderQueueElement, MAX_INSTANCES> m_cachedRenderElements;
+	Array<U8, MAX_INSTANCES> m_cachedRenderElementLods;
+	U m_cachedRenderElementCount = 0;
 };
 
 /// Check if the drawcalls can be merged.
-static Bool canMergeBuildInfo(const CompleteRenderingBuildInfo& abi, const CompleteRenderingBuildInfo& bbi)
+static Bool canMergeRenderQueueElements(const RenderQueueElement& a, const RenderQueueElement& b)
 {
-	const RenderingBuildInfoOut& a = abi.m_out;
-	const RenderingBuildInfoOut& b = bbi.m_out;
-
-	if(!a.m_hasTransform || !b.m_hasTransform)
-	{
-		// Cannot merge if there is no transform
-		return false;
-	}
-
-	ANKI_ASSERT(a.m_hasTransform == b.m_hasTransform);
-
-	if(abi.m_rc->getMaterial().getUuid() != bbi.m_rc->getMaterial().getUuid())
-	{
-		return false;
-	}
-
-	if(a.m_program != b.m_program)
-	{
-		return false;
-	}
-
-	if(a.m_vertexBufferBindingCount != b.m_vertexBufferBindingCount
-		|| a.m_vertexAttributeCount != b.m_vertexAttributeCount)
-	{
-		return false;
-	}
-
-	for(U i = 0; i < a.m_vertexBufferBindingCount; ++i)
-	{
-		if(a.m_vertexBufferBindings[i] != b.m_vertexBufferBindings[i])
-		{
-			return false;
-		}
-	}
-
-	for(U i = 0; i < a.m_vertexAttributeCount; ++i)
-	{
-		if(a.m_vertexAttributes[i] != b.m_vertexAttributes[i])
-		{
-			return false;
-		}
-	}
-
-	if(a.m_indexBuffer != b.m_indexBuffer)
-	{
-		return false;
-	}
-
-	if(a.m_indexBufferToken != b.m_indexBufferToken)
-	{
-		return false;
-	}
-
-	// Drawcall
-	if(a.m_drawArrays != b.m_drawArrays)
-	{
-		return false;
-	}
-
-	if(a.m_drawArrays && a.m_drawcall.m_arrays != b.m_drawcall.m_arrays)
-	{
-		return false;
-	}
-
-	if(!a.m_drawArrays && a.m_drawcall.m_elements != b.m_drawcall.m_elements)
-	{
-		return false;
-	}
-
-	if(a.m_topology != b.m_topology)
-	{
-		return false;
-	}
-
-	return true;
-}
-
-static void resetRenderingBuildInfoOut(RenderingBuildInfoOut& b)
-{
-	b.m_hasTransform = false;
-	b.m_program = {};
-
-	b.m_vertexBufferBindingCount = 0;
-	b.m_vertexAttributeCount = 0;
-
-	b.m_indexBuffer = {};
-	b.m_indexBufferToken = {};
-
-	b.m_drawcall.m_elements = DrawElementsIndirectInfo();
-	b.m_drawArrays = false;
-	b.m_topology = PrimitiveTopology::TRIANGLES;
+	return a.m_callback == b.m_callback && a.m_mergeKey != 0 && a.m_mergeKey == b.m_mergeKey;
 }
 
 RenderableDrawer::~RenderableDrawer()
 {
 }
 
-void RenderableDrawer::setupUniforms(DrawContext& ctx, CompleteRenderingBuildInfo& build)
-{
-	RenderQueueDrawContext dctx;
-	dctx.m_cameraTransform = ctx.m_viewMat.getInverse();
-	dctx.m_commandBuffer = ctx.m_cmdb;
-	dctx.m_key = build.m_in.m_key;
-	dctx.m_projectionMatrix = Mat4::getIdentity();
-	dctx.m_viewMatrix = ctx.m_viewMat;
-	dctx.m_viewProjectionMatrix = ctx.m_viewProjMat;
-
-	build.m_rc->allocateAndSetupUniforms(dctx,
-		WeakArray<const Mat4>(&ctx.m_cachedTrfs[0], ctx.m_cachedTrfCount),
-		m_r->getStagingGpuMemoryManager(),
-		ctx.m_uboToken);
-}
-
-Error RenderableDrawer::drawRange(Pass pass,
+void RenderableDrawer::drawRange(Pass pass,
 	const Mat4& viewMat,
 	const Mat4& viewProjMat,
 	CommandBufferPtr cmdb,
@@ -175,165 +51,69 @@ Error RenderableDrawer::drawRange(Pass pass,
 	ANKI_ASSERT(begin && end && begin < end);
 
 	DrawContext ctx;
-	ctx.m_viewMat = viewMat;
-	ctx.m_viewProjMat = viewProjMat;
-	ctx.m_pass = pass;
-	ctx.m_cmdb = cmdb;
+	ctx.m_queueCtx.m_viewMatrix = viewMat;
+	ctx.m_queueCtx.m_viewProjectionMatrix = viewProjMat;
+	ctx.m_queueCtx.m_projectionMatrix = Mat4::getIdentity(); // TODO
+	ctx.m_queueCtx.m_cameraTransform = ctx.m_queueCtx.m_viewMatrix.getInverse();
+	ctx.m_queueCtx.m_stagingGpuAllocator = &m_r->getStagingGpuMemoryManager();
+	ctx.m_queueCtx.m_commandBuffer = cmdb;
+	ctx.m_queueCtx.m_key = RenderingKey(pass, 0, 1);
 
 	for(; begin != end; ++begin)
 	{
 		ctx.m_visibleNode = begin;
 
-		ANKI_CHECK(drawSingle(ctx));
-
-		++ctx.m_nodeProcessedCount;
+		drawSingle(ctx);
 	}
 
 	// Flush the last drawcall
-	CompleteRenderingBuildInfo& build = ctx.m_buildInfo[!ctx.m_crntBuildInfo];
-	ANKI_CHECK(flushDrawcall(ctx, build));
-
-	return ErrorCode::NONE;
+	flushDrawcall(ctx);
 }
 
-Error RenderableDrawer::flushDrawcall(DrawContext& ctx, CompleteRenderingBuildInfo& build)
+void RenderableDrawer::flushDrawcall(DrawContext& ctx)
 {
-	RenderComponent& rc = *build.m_rc;
-
-	// Get the new info with the correct instance count
-	if(ctx.m_cachedTrfCount > 1)
-	{
-		build.m_in.m_key.m_instanceCount = ctx.m_cachedTrfCount;
-		ANKI_CHECK(rc.buildRendering(build.m_in, build.m_out));
-	}
-
-	// Enqueue uniform state updates
-	setupUniforms(ctx, build);
-
-	// Finaly, touch the command buffer
-	CommandBufferPtr& cmdb = ctx.m_cmdb;
-
-	cmdb->bindUniformBuffer(0, 0, ctx.m_uboToken.m_buffer, ctx.m_uboToken.m_offset, ctx.m_uboToken.m_range);
-	cmdb->bindShaderProgram(build.m_out.m_program);
-
-	for(U i = 0; i < build.m_out.m_vertexBufferBindingCount; ++i)
-	{
-		const RenderingVertexBufferBinding& binding = build.m_out.m_vertexBufferBindings[i];
-		if(binding.m_buffer)
-		{
-			cmdb->bindVertexBuffer(i, binding.m_buffer, binding.m_offset, binding.m_stride, binding.m_stepRate);
-		}
-		else
-		{
-			ANKI_ASSERT(!!(binding.m_token));
-			cmdb->bindVertexBuffer(
-				i, binding.m_token.m_buffer, binding.m_token.m_offset, binding.m_stride, binding.m_stepRate);
-		}
-	}
-
-	for(U i = 0; i < build.m_out.m_vertexAttributeCount; ++i)
-	{
-		const RenderingVertexAttributeInfo& attrib = build.m_out.m_vertexAttributes[i];
-
-		cmdb->setVertexAttribute(i, attrib.m_bufferBinding, attrib.m_format, attrib.m_relativeOffset);
-	}
+	ctx.m_queueCtx.m_key.m_lod = ctx.m_cachedRenderElementLods[0];
+	ctx.m_queueCtx.m_key.m_instanceCount = ctx.m_cachedRenderElementCount;
 
-	if(!build.m_out.m_drawArrays)
-	{
-		const DrawElementsIndirectInfo& drawc = build.m_out.m_drawcall.m_elements;
-
-		if(build.m_out.m_indexBuffer)
-		{
-			cmdb->bindIndexBuffer(build.m_out.m_indexBuffer, 0, IndexType::U16);
-		}
-		else
-		{
-			ANKI_ASSERT(!!(build.m_out.m_indexBufferToken));
-			cmdb->bindIndexBuffer(
-				build.m_out.m_indexBufferToken.m_buffer, build.m_out.m_indexBufferToken.m_offset, IndexType::U16);
-		}
-
-		cmdb->drawElements(build.m_out.m_topology,
-			drawc.m_count,
-			drawc.m_instanceCount,
-			drawc.m_firstIndex,
-			drawc.m_baseVertex,
-			drawc.m_baseInstance);
-	}
-	else
-	{
-		const DrawArraysIndirectInfo& drawc = build.m_out.m_drawcall.m_arrays;
-
-		cmdb->drawArrays(
-			build.m_out.m_topology, drawc.m_count, drawc.m_instanceCount, drawc.m_first, drawc.m_baseInstance);
-	}
+	ctx.m_cachedRenderElements[0].m_callback(ctx.m_queueCtx,
+		WeakArray<const RenderQueueElement>(&ctx.m_cachedRenderElements[0], ctx.m_cachedRenderElementCount));
 
 	// Rendered something, reset the cached transforms
-	if(ctx.m_cachedTrfCount > 1)
+	if(ctx.m_cachedRenderElementCount > 1)
 	{
-		ANKI_TRACE_INC_COUNTER(RENDERER_MERGED_DRAWCALLS, ctx.m_cachedTrfCount - 1);
+		ANKI_TRACE_INC_COUNTER(RENDERER_MERGED_DRAWCALLS, ctx.m_cachedRenderElementCount - 1);
 	}
-	ctx.m_cachedTrfCount = 0;
-
-	return ErrorCode::NONE;
+	ctx.m_cachedRenderElementCount = 0;
 }
 
-Error RenderableDrawer::drawSingle(DrawContext& ctx)
+void RenderableDrawer::drawSingle(DrawContext& ctx)
 {
-	// Get components
-	RenderComponent& renderable = ctx.m_visibleNode->m_node->getComponent<RenderComponent>();
+	const RenderComponent& rc = ctx.m_visibleNode->m_node->getComponent<RenderComponent>();
 
-	// Get info of current
-	CompleteRenderingBuildInfo& crntBuild = ctx.m_buildInfo[ctx.m_crntBuildInfo];
-	CompleteRenderingBuildInfo& prevBuild = ctx.m_buildInfo[!ctx.m_crntBuildInfo];
-	ctx.m_crntBuildInfo = !ctx.m_crntBuildInfo;
-
-	// Fill the crntBuild
-	F32 flod = m_r->calculateLod(ctx.m_visibleNode->m_frustumDistance);
-	flod = min<F32>(flod, MAX_LOD_COUNT - 1);
-
-	crntBuild.m_rc = &renderable;
-	crntBuild.m_flod = flod;
-
-	crntBuild.m_in.m_key.m_lod = flod;
-	crntBuild.m_in.m_key.m_pass = ctx.m_pass;
-	crntBuild.m_in.m_key.m_instanceCount = 1;
-	crntBuild.m_in.m_subMeshIndicesArray = &ctx.m_visibleNode->m_spatialIndices[0];
-	crntBuild.m_in.m_subMeshIndicesCount = ctx.m_visibleNode->m_spatialsCount;
-
-	resetRenderingBuildInfoOut(crntBuild.m_out);
-	ANKI_CHECK(renderable.buildRendering(crntBuild.m_in, crntBuild.m_out));
-
-	if(ANKI_UNLIKELY(ctx.m_nodeProcessedCount == 0))
+	if(ctx.m_cachedRenderElementCount == MAX_INSTANCES)
 	{
-		// First drawcall, cache it
-
-		if(crntBuild.m_out.m_hasTransform)
-		{
-			ctx.m_cachedTrfs[ctx.m_cachedTrfCount++] = crntBuild.m_out.m_transform;
-		}
+		flushDrawcall(ctx);
 	}
-	else if(crntBuild.m_out.m_hasTransform && canMergeBuildInfo(crntBuild, prevBuild)
-		&& ctx.m_cachedTrfCount < MAX_INSTANCES - 1)
-	{
-		// Can merge, will cache the drawcall and skip the drawcall
 
-		ctx.m_cachedTrfs[ctx.m_cachedTrfCount++] = crntBuild.m_out.m_transform;
-	}
-	else
-	{
-		// Cannot merge, flush the previous build info
+	RenderQueueElement rqel;
+	rc.setupRenderQueueElement(rqel);
 
-		ANKI_CHECK(flushDrawcall(ctx, prevBuild));
+	const F32 flod = min<F32>(m_r->calculateLod(ctx.m_visibleNode->m_frustumDistance), MAX_LOD_COUNT - 1);
+	const U8 lod = U8(flod);
 
-		// Cache the current build
-		if(crntBuild.m_out.m_hasTransform)
-		{
-			ctx.m_cachedTrfs[ctx.m_cachedTrfCount++] = crntBuild.m_out.m_transform;
-		}
+	const Bool shouldFlush = ctx.m_cachedRenderElementCount > 0
+		&& (!canMergeRenderQueueElements(ctx.m_cachedRenderElements[ctx.m_cachedRenderElementCount - 1], rqel)
+			   || ctx.m_cachedRenderElementLods[ctx.m_cachedRenderElementCount - 1] != lod);
+
+	if(shouldFlush)
+	{
+		flushDrawcall(ctx);
 	}
 
-	return ErrorCode::NONE;
+	// Cache the new one
+	ctx.m_cachedRenderElements[ctx.m_cachedRenderElementCount] = rqel;
+	ctx.m_cachedRenderElementLods[ctx.m_cachedRenderElementCount] = lod;
+	++ctx.m_cachedRenderElementCount;
 }
 
 } // end namespace anki

src/anki/renderer/Drawer.h

@@ -15,15 +15,13 @@ namespace anki
 // Forward
 class Renderer;
 class DrawContext;
-class CompleteRenderingBuildInfo;
 
 /// @addtogroup renderer
 /// @{
 
-/// It includes all the functions to render a Renderable
+/// It uses the render queue to batch and render.
 class RenderableDrawer
 {
-	friend class SetupRenderableVariableVisitor;
 	friend class RenderTask;
 
 public:
@@ -34,7 +32,7 @@ public:
 
 	~RenderableDrawer();
 
-	ANKI_USE_RESULT Error drawRange(Pass pass,
+	void drawRange(Pass pass,
 		const Mat4& viewMat,
 		const Mat4& viewProjMat,
 		CommandBufferPtr cmdb,
@@ -44,10 +42,9 @@ public:
 private:
 	Renderer* m_r;
 
-	ANKI_USE_RESULT Error flushDrawcall(DrawContext& ctx, CompleteRenderingBuildInfo& build);
-	void setupUniforms(DrawContext& ctx, CompleteRenderingBuildInfo& build);
+	void flushDrawcall(DrawContext& ctx);
 
-	ANKI_USE_RESULT Error drawSingle(DrawContext& ctx);
+	void drawSingle(DrawContext& ctx);
 };
 /// @}
 

src/anki/renderer/ForwardShading.cpp

@@ -108,7 +108,7 @@ void ForwardShading::drawVolumetric(RenderingContext& ctx, CommandBufferPtr cmdb
 	cmdb->setDepthCompareOperation(CompareOperation::LESS);
 }
 
-Error ForwardShading::buildCommandBuffers(RenderingContext& ctx, U threadId, U threadCount) const
+void ForwardShading::buildCommandBuffers(RenderingContext& ctx, U threadId, U threadCount) const
 {
 	U problemSize = ctx.m_visResults->getCount(VisibilityGroupType::RENDERABLES_FS);
 	PtrSize start, end;
@@ -117,7 +117,7 @@ Error ForwardShading::buildCommandBuffers(RenderingContext& ctx, U threadId, U t
 	if(start == end)
 	{
 		// Early exit
-		return ErrorCode::NONE;
+		return;
 	}
 
 	// Create the command buffer and set some state
@@ -151,14 +151,12 @@ Error ForwardShading::buildCommandBuffers(RenderingContext& ctx, U threadId, U t
 	cmdb->setDepthWrite(false);
 
 	// Start drawing
-	Error err = m_r->getSceneDrawer().drawRange(Pass::GB_FS,
+	m_r->getSceneDrawer().drawRange(Pass::GB_FS,
 		ctx.m_viewMat,
 		ctx.m_viewProjMat,
 		cmdb,
 		ctx.m_visResults->getBegin(VisibilityGroupType::RENDERABLES_FS) + start,
 		ctx.m_visResults->getBegin(VisibilityGroupType::RENDERABLES_FS) + end);
-
-	return err;
 }
 
 void ForwardShading::setPreRunBarriers(RenderingContext& ctx)

src/anki/renderer/ForwardShading.h

@@ -26,7 +26,7 @@ anki_internal:
 
 	ANKI_USE_RESULT Error init(const ConfigSet& initializer);
 
-	ANKI_USE_RESULT Error buildCommandBuffers(RenderingContext& ctx, U threadId, U threadCount) const;
+	void buildCommandBuffers(RenderingContext& ctx, U threadId, U threadCount) const;
 
 	void setPreRunBarriers(RenderingContext& ctx);
 

src/anki/renderer/GBuffer.cpp

@@ -100,9 +100,9 @@ Error GBuffer::initInternal(const ConfigSet& initializer)
 	return ErrorCode::NONE;
 }
 
-Error GBuffer::buildCommandBuffers(RenderingContext& ctx, U threadId, U threadCount) const
+void GBuffer::buildCommandBuffers(RenderingContext& ctx, U threadId, U threadCount) const
 {
-	ANKI_TRACE_START_EVENT(RENDER_MS);
+	ANKI_TRACE_SCOPED_EVENT(RENDER_MS);
 
 	// Get some stuff
 	const VisibilityTestResults& vis = *ctx.m_visResults;
@@ -135,21 +135,18 @@ Error GBuffer::buildCommandBuffers(RenderingContext& ctx, U threadId, U threadCo
 		cmdb->setViewport(0, 0, m_r->getWidth(), m_r->getHeight());
 
 		// Start drawing
-		ANKI_CHECK(m_r->getSceneDrawer().drawRange(Pass::GB_FS,
+		m_r->getSceneDrawer().drawRange(Pass::GB_FS,
 			ctx.m_viewMat,
 			ctx.m_viewProjMatJitter,
 			cmdb,
 			vis.getBegin(VisibilityGroupType::RENDERABLES_MS) + start,
-			vis.getBegin(VisibilityGroupType::RENDERABLES_MS) + end));
+			vis.getBegin(VisibilityGroupType::RENDERABLES_MS) + end);
 	}
-
-	ANKI_TRACE_STOP_EVENT(RENDER_MS);
-	return ErrorCode::NONE;
 }
 
 void GBuffer::run(RenderingContext& ctx)
 {
-	ANKI_TRACE_START_EVENT(RENDER_MS);
+	ANKI_TRACE_SCOPED_EVENT(RENDER_MS);
 
 	CommandBufferPtr& cmdb = ctx.m_commandBuffer;
 	cmdb->beginRenderPass(m_fb);
@@ -166,13 +163,11 @@ void GBuffer::run(RenderingContext& ctx)
 	}
 
 	cmdb->endRenderPass();
-
-	ANKI_TRACE_STOP_EVENT(RENDER_MS);
 }
 
 void GBuffer::setPreRunBarriers(RenderingContext& ctx)
 {
-	ANKI_TRACE_START_EVENT(RENDER_MS);
+	ANKI_TRACE_SCOPED_EVENT(RENDER_MS);
 
 	CommandBufferPtr& cmdb = ctx.m_commandBuffer;
 	TextureSurfaceInfo surf(0, 0, 0, 0);
@@ -182,13 +177,11 @@ void GBuffer::setPreRunBarriers(RenderingContext& ctx)
 	cmdb->setTextureSurfaceBarrier(m_rt2, TextureUsageBit::NONE, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE, surf);
 	cmdb->setTextureSurfaceBarrier(
 		m_depthRt, TextureUsageBit::NONE, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ_WRITE, surf);
-
-	ANKI_TRACE_STOP_EVENT(RENDER_MS);
 }
 
 void GBuffer::setPostRunBarriers(RenderingContext& ctx)
 {
-	ANKI_TRACE_START_EVENT(RENDER_MS);
+	ANKI_TRACE_SCOPED_EVENT(RENDER_MS);
 
 	CommandBufferPtr& cmdb = ctx.m_commandBuffer;
 	TextureSurfaceInfo surf(0, 0, 0, 0);
@@ -204,8 +197,6 @@ void GBuffer::setPostRunBarriers(RenderingContext& ctx)
 
 	cmdb->setTextureSurfaceBarrier(
 		m_depthRt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ_WRITE, TextureUsageBit::SAMPLED_FRAGMENT, surf);
-
-	ANKI_TRACE_STOP_EVENT(RENDER_MS);
 }
 
 } // end namespace anki

src/anki/renderer/GBuffer.h

@@ -32,7 +32,7 @@ anki_internal:
 
 	ANKI_USE_RESULT Error init(const ConfigSet& initializer);
 
-	ANKI_USE_RESULT Error buildCommandBuffers(RenderingContext& ctx, U threadId, U threadCount) const;
+	void buildCommandBuffers(RenderingContext& ctx, U threadId, U threadCount) const;
 
 	void setPreRunBarriers(RenderingContext& ctx);
 

src/anki/renderer/Indirect.cpp

@@ -310,7 +310,7 @@ Error Indirect::initIrradiance()
 	return ErrorCode::NONE;
 }
 
-Error Indirect::runMs(RenderingContext& rctx, FrustumComponent& frc, U layer, U faceIdx)
+void Indirect::runMs(RenderingContext& rctx, FrustumComponent& frc, U layer, U faceIdx)
 {
 	CommandBufferPtr& cmdb = rctx.m_commandBuffer;
 	VisibilityTestResults& vis = frc.getVisibilityTestResults();
@@ -341,12 +341,12 @@ Error Indirect::runMs(RenderingContext& rctx, FrustumComponent& frc, U layer, U
 	cmdb->setViewport(0, 0, m_fbSize, m_fbSize);
 
 	/// Draw
-	ANKI_CHECK(m_r->getSceneDrawer().drawRange(Pass::GB_FS,
+	m_r->getSceneDrawer().drawRange(Pass::GB_FS,
 		frc.getViewMatrix(),
 		frc.getViewProjectionMatrix(),
 		cmdb,
 		vis.getBegin(VisibilityGroupType::RENDERABLES_MS),
-		vis.getEnd(VisibilityGroupType::RENDERABLES_MS)));
+		vis.getEnd(VisibilityGroupType::RENDERABLES_MS));
 
 	// End and set barriers
 	cmdb->endRenderPass();
@@ -363,8 +363,6 @@ Error Indirect::runMs(RenderingContext& rctx, FrustumComponent& frc, U layer, U
 		TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ_WRITE,
 		TextureUsageBit::SAMPLED_FRAGMENT | TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ,
 		TextureSurfaceInfo(0, 0, 0, 0));
-
-	return ErrorCode::NONE;
 }
 
 void Indirect::runIs(RenderingContext& rctx, FrustumComponent& frc, U layer, U faceIdx)
@@ -546,9 +544,9 @@ void Indirect::computeIrradiance(RenderingContext& rctx, U layer, U faceIdx)
 		TextureSurfaceInfo(0, 0, faceIdx, layer));
 }
 
-Error Indirect::run(RenderingContext& rctx)
+void Indirect::run(RenderingContext& rctx)
 {
-	ANKI_TRACE_START_EVENT(RENDER_IR);
+	ANKI_TRACE_SCOPED_EVENT(RENDER_IR);
 	const VisibilityTestResults& visRez = *rctx.m_visResults;
 
 	if(visRez.getCount(VisibilityGroupType::REFLECTION_PROBES) > m_cubemapArrSize)
@@ -565,7 +563,7 @@ Error Indirect::run(RenderingContext& rctx)
 	while(it != end)
 	{
 		// Write and render probe
-		ANKI_CHECK(tryRender(rctx, *it->m_node, probesRendered));
+		tryRender(rctx, *it->m_node, probesRendered);
 
 		++it;
 		++probeIdx;
@@ -576,13 +574,9 @@ Error Indirect::run(RenderingContext& rctx)
 	CommandBufferPtr& cmdb = rctx.m_commandBuffer;
 	cmdb->informTextureCurrentUsage(m_irradiance.m_cubeArr, TextureUsageBit::SAMPLED_FRAGMENT);
 	cmdb->informTextureCurrentUsage(m_is.m_lightRt, TextureUsageBit::SAMPLED_FRAGMENT);
-
-	// Bye
-	ANKI_TRACE_STOP_EVENT(RENDER_IR);
-	return ErrorCode::NONE;
 }
 
-Error Indirect::tryRender(RenderingContext& ctx, SceneNode& node, U& probesRendered)
+void Indirect::tryRender(RenderingContext& ctx, SceneNode& node, U& probesRendered)
 {
 	ReflectionProbeComponent& reflc = node.getComponent<ReflectionProbeComponent>();
 
@@ -597,7 +591,7 @@ Error Indirect::tryRender(RenderingContext& ctx, SceneNode& node, U& probesRende
 	{
 		++probesRendered;
 		reflc.setMarkedForRendering(false);
-		ANKI_CHECK(renderReflection(ctx, node, entry));
+		renderReflection(ctx, node, entry);
 	}
 
 	// If you need to render it mark it for the next frame
@@ -605,11 +599,9 @@ Error Indirect::tryRender(RenderingContext& ctx, SceneNode& node, U& probesRende
 	{
 		reflc.setMarkedForRendering(true);
 	}
-
-	return ErrorCode::NONE;
 }
 
-Error Indirect::renderReflection(RenderingContext& ctx, SceneNode& node, U cubemapIdx)
+void Indirect::renderReflection(RenderingContext& ctx, SceneNode& node, U cubemapIdx)
 {
 	ANKI_TRACE_INC_COUNTER(RENDERER_REFLECTIONS, 1);
 
@@ -626,7 +618,7 @@ Error Indirect::renderReflection(RenderingContext& ctx, SceneNode& node, U cubem
 	// Render cubemap
 	for(U i = 0; i < 6; ++i)
 	{
-		ANKI_CHECK(runMs(ctx, *frustumComponents[i], cubemapIdx, i));
+		runMs(ctx, *frustumComponents[i], cubemapIdx, i);
 		runIs(ctx, *frustumComponents[i], cubemapIdx, i);
 	}
 
@@ -634,8 +626,6 @@ Error Indirect::renderReflection(RenderingContext& ctx, SceneNode& node, U cubem
 	{
 		computeIrradiance(ctx, cubemapIdx, i);
 	}
-
-	return ErrorCode::NONE;
 }
 
 void Indirect::findCacheEntry(SceneNode& node, U& entry, Bool& render)

src/anki/renderer/Indirect.h

@@ -34,7 +34,7 @@ anki_internal:
 
 	ANKI_USE_RESULT Error init(const ConfigSet& cfg);
 
-	ANKI_USE_RESULT Error run(RenderingContext& ctx);
+	void run(RenderingContext& ctx);
 
 	U getReflectionTextureMipmapCount() const
 	{
@@ -142,13 +142,13 @@ private:
 	ANKI_USE_RESULT Error loadMesh(CString fname, BufferPtr& vert, BufferPtr& idx, U32& idxCount);
 
 	// Rendering
-	ANKI_USE_RESULT Error tryRender(RenderingContext& ctx, SceneNode& node, U& probesRendered);
+	void tryRender(RenderingContext& ctx, SceneNode& node, U& probesRendered);
 
-	ANKI_USE_RESULT Error runMs(RenderingContext& rctx, FrustumComponent& frc, U layer, U faceIdx);
+	void runMs(RenderingContext& rctx, FrustumComponent& frc, U layer, U faceIdx);
 	void runIs(RenderingContext& rctx, FrustumComponent& frc, U layer, U faceIdx);
 	void computeIrradiance(RenderingContext& rctx, U layer, U faceIdx);
 
-	ANKI_USE_RESULT Error renderReflection(RenderingContext& ctx, SceneNode& node, U cubemapIdx);
+	void renderReflection(RenderingContext& ctx, SceneNode& node, U cubemapIdx);
 
 	/// Find a cache entry to store the reflection.
 	void findCacheEntry(SceneNode& node, U& entry, Bool& render);

src/anki/renderer/Renderer.cpp

@@ -256,7 +256,7 @@ Error Renderer::render(RenderingContext& ctx)
 	}
 
 	// Run stages
-	ANKI_CHECK(m_indirect->run(ctx));
+	m_indirect->run(ctx);
 
 	ANKI_CHECK(m_lightShading->binLights(ctx));
 
@@ -500,11 +500,11 @@ TexturePtr Renderer::createAndClearRenderTarget(const TextureInitInfo& inf)
 	return tex;
 }
 
-Error Renderer::buildCommandBuffersInternal(RenderingContext& ctx, U32 threadId, PtrSize threadCount)
+void Renderer::buildCommandBuffersInternal(RenderingContext& ctx, U32 threadId, PtrSize threadCount)
 {
 	// MS
 	//
-	ANKI_CHECK(m_gbuffer->buildCommandBuffers(ctx, threadId, threadCount));
+	m_gbuffer->buildCommandBuffers(ctx, threadId, threadCount);
 
 	// Append to the last MS's cmdb the occlusion tests
 	if(ctx.m_gbuffer.m_lastThreadWithWork == threadId)
@@ -519,11 +519,11 @@ Error Renderer::buildCommandBuffersInternal(RenderingContext& ctx, U32 threadId,
 
 	// SM
 	//
-	ANKI_CHECK(m_shadowMapping->buildCommandBuffers(ctx, threadId, threadCount));
+	m_shadowMapping->buildCommandBuffers(ctx, threadId, threadCount);
 
 	// FS
 	//
-	ANKI_CHECK(m_forwardShading->buildCommandBuffers(ctx, threadId, threadCount));
+	m_forwardShading->buildCommandBuffers(ctx, threadId, threadCount);
 
 	// Append to the last FB's cmdb the other passes
 	if(ctx.m_forwardShading.m_lastThreadWithWork == threadId)
@@ -561,13 +561,11 @@ Error Renderer::buildCommandBuffersInternal(RenderingContext& ctx, U32 threadId,
 	{
 		ctx.m_forwardShading.m_commandBuffers[threadId]->flush();
 	}
-
-	return ErrorCode::NONE;
 }
 
 Error Renderer::buildCommandBuffers(RenderingContext& ctx)
 {
-	ANKI_TRACE_START_EVENT(RENDERER_COMMAND_BUFFER_BUILDING);
+	ANKI_TRACE_SCOPED_EVENT(RENDERER_COMMAND_BUFFER_BUILDING);
 	ThreadPool& threadPool = getThreadPool();
 
 	// Prepare
@@ -605,7 +603,8 @@ Error Renderer::buildCommandBuffers(RenderingContext& ctx)
 
 		Error operator()(U32 threadId, PtrSize threadCount)
 		{
-			return m_r->buildCommandBuffersInternal(*m_ctx, threadId, threadCount);
+			m_r->buildCommandBuffersInternal(*m_ctx, threadId, threadCount);
+			return ErrorCode::NONE;
 		}
 	};
 
@@ -617,10 +616,9 @@ Error Renderer::buildCommandBuffers(RenderingContext& ctx)
 		threadPool.assignNewTask(i, &task);
 	}
 
-	Error err = threadPool.waitForAllThreadsToFinish();
-	ANKI_TRACE_STOP_EVENT(RENDERER_COMMAND_BUFFER_BUILDING);
+	ANKI_CHECK(threadPool.waitForAllThreadsToFinish());
 
-	return err;
+	return ErrorCode::NONE;
 }
 
 Error Renderer::createShader(CString fname, ShaderResourcePtr& shader, CString extra)

src/anki/renderer/Renderer.h

@@ -451,7 +451,7 @@ private:
 	ANKI_USE_RESULT Error initInternal(const ConfigSet& initializer);
 
 	ANKI_USE_RESULT Error buildCommandBuffers(RenderingContext& ctx);
-	ANKI_USE_RESULT Error buildCommandBuffersInternal(RenderingContext& ctx, U32 threadId, PtrSize threadCount);
+	void buildCommandBuffersInternal(RenderingContext& ctx, U32 threadId, PtrSize threadCount);
 
 	void initJitteredMats();
 };

src/anki/renderer/ShadowMapping.cpp

@@ -225,37 +225,34 @@ Bool ShadowMapping::skip(SceneNode& light, ShadowmapBase& sm)
 	return !shouldUpdate;
 }
 
-Error ShadowMapping::buildCommandBuffers(RenderingContext& ctx, U threadId, U threadCount) const
+void ShadowMapping::buildCommandBuffers(RenderingContext& ctx, U threadId, U threadCount) const
 {
-	ANKI_TRACE_START_EVENT(RENDER_SM);
+	ANKI_TRACE_SCOPED_EVENT(RENDER_SM);
 
 	for(U i = 0; i < ctx.m_shadowMapping.m_spots.getSize(); ++i)
 	{
 		U idx = i * threadCount + threadId;
 
-		ANKI_CHECK(doSpotLight(*ctx.m_shadowMapping.m_spots[i],
+		doSpotLight(*ctx.m_shadowMapping.m_spots[i],
 			ctx.m_shadowMapping.m_spotCommandBuffers[idx],
 			ctx.m_shadowMapping.m_spotFramebuffers[i],
 			threadId,
-			threadCount));
+			threadCount);
 	}
 
 	for(U i = 0; i < ctx.m_shadowMapping.m_omnis.getSize(); ++i)
 	{
 		U idx = i * threadCount * 6 + threadId * 6 + 0;
 
-		ANKI_CHECK(doOmniLight(*ctx.m_shadowMapping.m_omnis[i],
+		doOmniLight(*ctx.m_shadowMapping.m_omnis[i],
 			&ctx.m_shadowMapping.m_omniCommandBuffers[idx],
 			ctx.m_shadowMapping.m_omniFramebuffers[i],
 			threadId,
-			threadCount));
+			threadCount);
 	}
-
-	ANKI_TRACE_STOP_EVENT(RENDER_SM);
-	return ErrorCode::NONE;
 }
 
-Error ShadowMapping::doSpotLight(
+void ShadowMapping::doSpotLight(
 	SceneNode& light, CommandBufferPtr& cmdb, FramebufferPtr& fb, U threadId, U threadCount) const
 {
 	FrustumComponent& frc = light.getComponent<FrustumComponent>();
@@ -266,7 +263,7 @@ Error ShadowMapping::doSpotLight(
 
 	if(start == end)
 	{
-		return ErrorCode::NONE;
+		return;
 	}
 
 	CommandBufferInitInfo cinf;
@@ -287,7 +284,7 @@ Error ShadowMapping::doSpotLight(
 	cmdb->setViewport(0, 0, m_resolution, m_resolution);
 	cmdb->setPolygonOffset(1.0, 2.0);
 
-	Error err = m_r->getSceneDrawer().drawRange(Pass::SM,
+	m_r->getSceneDrawer().drawRange(Pass::SM,
 		frc.getViewMatrix(),
 		frc.getViewProjectionMatrix(),
 		cmdb,
@@ -295,11 +292,9 @@ Error ShadowMapping::doSpotLight(
 		vis.getBegin(VisibilityGroupType::RENDERABLES_MS) + end);
 
 	cmdb->flush();
-
-	return err;
 }
 
-Error ShadowMapping::doOmniLight(
+void ShadowMapping::doOmniLight(
 	SceneNode& light, CommandBufferPtr cmdbs[], Array<FramebufferPtr, 6>& fbs, U threadId, U threadCount) const
 {
 	U frCount = 0;
@@ -330,12 +325,12 @@ Error ShadowMapping::doOmniLight(
 			cmdbs[frCount]->setViewport(0, 0, m_resolution, m_resolution);
 			cmdbs[frCount]->setPolygonOffset(1.0, 2.0);
 
-			ANKI_CHECK(m_r->getSceneDrawer().drawRange(Pass::SM,
+			m_r->getSceneDrawer().drawRange(Pass::SM,
 				frc.getViewMatrix(),
 				frc.getViewProjectionMatrix(),
 				cmdbs[frCount],
 				vis.getBegin(VisibilityGroupType::RENDERABLES_MS) + start,
-				vis.getBegin(VisibilityGroupType::RENDERABLES_MS) + end));
+				vis.getBegin(VisibilityGroupType::RENDERABLES_MS) + end);
 
 			cmdbs[frCount]->flush();
 		}
@@ -343,13 +338,12 @@ Error ShadowMapping::doOmniLight(
 		++frCount;
 		return ErrorCode::NONE;
 	});
-
-	return err;
+	(void)err;
 }
 
 void ShadowMapping::prepareBuildCommandBuffers(RenderingContext& ctx)
 {
-	ANKI_TRACE_START_EVENT(RENDER_SM);
+	ANKI_TRACE_SCOPED_EVENT(RENDER_SM);
 
 	// Gather the lights
 	const VisibilityTestResults& vi = *ctx.m_visResults;
@@ -460,13 +454,11 @@ void ShadowMapping::prepareBuildCommandBuffers(RenderingContext& ctx)
 			ctx.m_shadowMapping.m_omniCacheIndices[i] = idx;
 		}
 	}
-
-	ANKI_TRACE_STOP_EVENT(RENDER_SM);
 }
 
 void ShadowMapping::setPreRunBarriers(RenderingContext& ctx)
 {
-	ANKI_TRACE_START_EVENT(RENDER_SM);
+	ANKI_TRACE_SCOPED_EVENT(RENDER_SM);
 	CommandBufferPtr& cmdb = ctx.m_commandBuffer;
 
 	// Spot lights
@@ -493,13 +485,11 @@ void ShadowMapping::setPreRunBarriers(RenderingContext& ctx)
 				TextureSurfaceInfo(0, 0, j, layer));
 		}
 	}
-
-	ANKI_TRACE_STOP_EVENT(RENDER_SM);
 }
 
 void ShadowMapping::setPostRunBarriers(RenderingContext& ctx)
 {
-	ANKI_TRACE_START_EVENT(RENDER_SM);
+	ANKI_TRACE_SCOPED_EVENT(RENDER_SM);
 	CommandBufferPtr& cmdb = ctx.m_commandBuffer;
 
 	// Spot lights
@@ -529,8 +519,6 @@ void ShadowMapping::setPostRunBarriers(RenderingContext& ctx)
 
 	cmdb->informTextureCurrentUsage(m_spotTexArray, TextureUsageBit::SAMPLED_FRAGMENT);
 	cmdb->informTextureCurrentUsage(m_omniTexArray, TextureUsageBit::SAMPLED_FRAGMENT);
-
-	ANKI_TRACE_STOP_EVENT(RENDER_SM);
 }
 
 } // end namespace anki

src/anki/renderer/ShadowMapping.h

@@ -42,7 +42,7 @@ anki_internal:
 
 	void prepareBuildCommandBuffers(RenderingContext& ctx);
 
-	ANKI_USE_RESULT Error buildCommandBuffers(RenderingContext& ctx, U threadId, U threadCount) const;
+	void buildCommandBuffers(RenderingContext& ctx, U threadId, U threadCount) const;
 
 	void setPreRunBarriers(RenderingContext& ctx);
 
@@ -89,10 +89,9 @@ private:
 	/// Check if a shadow pass can be skipped.
 	Bool skip(SceneNode& light, ShadowmapBase& sm);
 
-	ANKI_USE_RESULT Error doSpotLight(
-		SceneNode& light, CommandBufferPtr& cmdBuff, FramebufferPtr& fb, U threadId, U threadCount) const;
+	void doSpotLight(SceneNode& light, CommandBufferPtr& cmdBuff, FramebufferPtr& fb, U threadId, U threadCount) const;
 
-	ANKI_USE_RESULT Error doOmniLight(
+	void doOmniLight(
 		SceneNode& light, CommandBufferPtr cmdbs[], Array<FramebufferPtr, 6>& fbs, U threadId, U threadCount) const;
 };
 

src/anki/scene/ModelNode.cpp

@@ -29,11 +29,6 @@ public:
 	{
 	}
 
-	ANKI_USE_RESULT Error buildRendering(const RenderingBuildInfoIn& in, RenderingBuildInfoOut& out) const override
-	{
-		return getNode().buildRendering(in, out);
-	}
-
 	void setupRenderQueueElement(RenderQueueElement& el) const override
 	{
 		getNode().setupRenderQueueElement(el);
@@ -59,8 +54,7 @@ Error ModelPatchNode::init(const ModelPatch* modelPatch, U idx, const ModelNode&
 	newComponent<SpatialComponent>(this, &m_obb);
 
 	// Render component
-	RenderComponent* rcomp = newComponent<ModelPatchRenderComponent>(this);
-	ANKI_CHECK(rcomp->init());
+	newComponent<ModelPatchRenderComponent>(this);
 
 	// Merge key
 	Array<U64, 2> toHash;
@@ -71,43 +65,6 @@ Error ModelPatchNode::init(const ModelPatch* modelPatch, U idx, const ModelNode&
 	return ErrorCode::NONE;
 }
 
-Error ModelPatchNode::buildRendering(const RenderingBuildInfoIn& in, RenderingBuildInfoOut& out) const
-{
-	// That will not work on multi-draw and instanced at the same time. Make sure that there is no multi-draw anywhere
-	ANKI_ASSERT(m_modelPatch->getSubMeshesCount() == 0);
-
-	// State
-	ModelRenderingInfo modelInf;
-	m_modelPatch->getRenderingDataSub(in.m_key, WeakArray<U8>(), modelInf);
-
-	out.m_vertexBufferBindingCount = modelInf.m_vertexBufferBindingCount;
-	for(U i = 0; i < modelInf.m_vertexBufferBindingCount; ++i)
-	{
-		static_cast<VertexBufferBinding&>(out.m_vertexBufferBindings[i]) = modelInf.m_vertexBufferBindings[i];
-	}
-
-	out.m_vertexAttributeCount = modelInf.m_vertexAttributeCount;
-	for(U i = 0; i < modelInf.m_vertexAttributeCount; ++i)
-	{
-		out.m_vertexAttributes[i] = modelInf.m_vertexAttributes[i];
-	}
-
-	out.m_indexBuffer = modelInf.m_indexBuffer;
-
-	out.m_program = modelInf.m_program;
-
-	// Other
-	ANKI_ASSERT(modelInf.m_drawcallCount == 1 && "Cannot accept multi-draw");
-	out.m_drawcall.m_elements.m_count = modelInf.m_indicesCountArray[0];
-	out.m_drawcall.m_elements.m_instanceCount = in.m_key.m_instanceCount;
-	out.m_drawcall.m_elements.m_firstIndex = modelInf.m_indicesOffsetArray[0] / sizeof(U16);
-
-	out.m_hasTransform = true;
-	out.m_transform = Mat4(getParent()->getComponent<MoveComponent>().getWorldTransform());
-
-	return ErrorCode::NONE;
-}
-
 void ModelPatchNode::drawCallback(RenderQueueDrawContext& ctx, WeakArray<const RenderQueueElement> elements)
 {
 	ANKI_ASSERT(elements.getSize() > 0 && elements.getSize() <= MAX_INSTANCES);
@@ -146,13 +103,15 @@ void ModelPatchNode::drawCallback(RenderQueueDrawContext& ctx, WeakArray<const R
 	// Uniforms
 	Array<Mat4, MAX_INSTANCES> trfs;
 	trfs[0] = Mat4(self.getParent()->getComponent<MoveComponent>().getWorldTransform());
-	for(U i = 0; i < elements.getSize(); ++i)
+	for(U i = 1; i < elements.getSize(); ++i)
 	{
-		trfs[i] = trfs[0];
+		const ModelPatchNode& self2 = *static_cast<const ModelPatchNode*>(elements[i].m_userData);
+		trfs[i] = Mat4(self2.getParent()->getComponent<MoveComponent>().getWorldTransform());
 	}
 
 	StagingGpuMemoryToken token;
-	self.getComponent<RenderComponent>().allocateAndSetupUniforms(ctx, trfs, *ctx.m_stagingGpuAllocator, token);
+	self.getComponent<RenderComponent>().allocateAndSetupUniforms(
+		ctx, WeakArray<const Mat4>(&trfs[0], elements.getSize()), *ctx.m_stagingGpuAllocator, token);
 	cmdb->bindUniformBuffer(0, 0, token.m_buffer, token.m_offset, token.m_range);
 
 	// Draw

src/anki/scene/ModelNode.h

@@ -41,8 +41,6 @@ private:
 	const ModelPatch* m_modelPatch = nullptr; ///< The resource
 	U64 m_mergeKey = 0;
 
-	ANKI_USE_RESULT Error buildRendering(const RenderingBuildInfoIn& in, RenderingBuildInfoOut& out) const;
-
 	void setupRenderQueueElement(RenderQueueElement& el) const
 	{
 		el.m_callback = drawCallback;

src/anki/scene/ParticleEmitter.cpp

@@ -174,11 +174,6 @@ public:
 	{
 	}
 
-	ANKI_USE_RESULT Error buildRendering(const RenderingBuildInfoIn& in, RenderingBuildInfoOut& out) const override
-	{
-		return getNode().buildRendering(in, out);
-	}
-
 	void setupRenderQueueElement(RenderQueueElement& el) const override
 	{
 		getNode().setupRenderQueueElement(el);
@@ -242,8 +237,7 @@ Error ParticleEmitter::init(const CString& filename)
 	newComponent<SpatialComponent>(this, &m_obb);
 
 	// Render component
-	ParticleEmitterRenderComponent* rcomp = newComponent<ParticleEmitterRenderComponent>(this);
-	ANKI_CHECK(rcomp->init());
+	newComponent<ParticleEmitterRenderComponent>(this);
 
 	// Other
 	m_obb.setCenter(Vec4(0.0));
@@ -272,41 +266,6 @@ Error ParticleEmitter::init(const CString& filename)
 	return ErrorCode::NONE;
 }
 
-Error ParticleEmitter::buildRendering(const RenderingBuildInfoIn& in, RenderingBuildInfoOut& out) const
-{
-	ANKI_ASSERT(in.m_subMeshIndicesCount == 1);
-
-	m_particleEmitterResource->getRenderingInfo(in.m_key.m_lod, out.m_program);
-
-	out.m_vertexBufferBindingCount = 1;
-	out.m_vertexBufferBindings[0].m_token = m_vertBuffToken;
-	out.m_vertexBufferBindings[0].m_stride = VERTEX_SIZE;
-	out.m_vertexBufferBindings[0].m_stepRate = VertexStepRate::INSTANCE;
-
-	out.m_vertexAttributeCount = 3;
-	out.m_vertexAttributes[0].m_bufferBinding = 0;
-	out.m_vertexAttributes[0].m_format = PixelFormat(ComponentFormat::R32G32B32, TransformFormat::FLOAT);
-	out.m_vertexAttributes[0].m_relativeOffset = 0;
-	out.m_vertexAttributes[1].m_bufferBinding = 0;
-	out.m_vertexAttributes[1].m_format = PixelFormat(ComponentFormat::R32, TransformFormat::FLOAT);
-	out.m_vertexAttributes[1].m_relativeOffset = sizeof(Vec3);
-	out.m_vertexAttributes[2].m_bufferBinding = 0;
-	out.m_vertexAttributes[2].m_format = PixelFormat(ComponentFormat::R32, TransformFormat::FLOAT);
-	out.m_vertexAttributes[2].m_relativeOffset = sizeof(Vec3) + sizeof(F32);
-
-	out.m_topology = PrimitiveTopology::TRIANGLE_STRIP;
-
-	out.m_drawArrays = true;
-	out.m_drawcall.m_arrays.m_instanceCount = m_aliveParticlesCount;
-	out.m_drawcall.m_arrays.m_count = 4;
-
-	// The particles are already in world position but materials use the MVP
-	out.m_hasTransform = true;
-	out.m_transform = Mat4::getIdentity();
-
-	return ErrorCode::NONE;
-}
-
 void ParticleEmitter::drawCallback(RenderQueueDrawContext& ctx, WeakArray<const RenderQueueElement> elements)
 {
 	ANKI_ASSERT(elements.getSize() == 1);

src/anki/scene/ParticleEmitter.h

@@ -198,8 +198,6 @@ private:
 	void createParticlesSimulation(SceneGraph* scene);
 	void createParticlesSimpleSimulation();
 
-	ANKI_USE_RESULT Error buildRendering(const RenderingBuildInfoIn& in, RenderingBuildInfoOut& out) const;
-
 	void onMoveComponentUpdate(MoveComponent& move);
 
 	void setupRenderQueueElement(RenderQueueElement& el) const

src/anki/scene/RenderComponent.cpp

@@ -16,26 +16,18 @@ RenderComponent::RenderComponent(SceneNode* node, MaterialResourcePtr mtl)
 	: SceneComponent(SceneComponentType::RENDER, node)
 	, m_mtl(mtl)
 {
-}
-
-RenderComponent::~RenderComponent()
-{
-	m_vars.destroy(getAllocator());
-}
-
-Error RenderComponent::init()
-{
-	const Material& mtl = getMaterial();
-
 	// Create the material variables
-	m_vars.create(getAllocator(), mtl.getVariables().getSize());
+	m_vars.create(getAllocator(), m_mtl->getVariables().getSize());
 	U count = 0;
-	for(const MaterialVariable& mv : mtl.getVariables())
+	for(const MaterialVariable& mv : m_mtl->getVariables())
 	{
 		m_vars[count++].m_mvar = &mv;
 	}
+}
 
-	return ErrorCode::NONE;
+RenderComponent::~RenderComponent()
+{
+	m_vars.destroy(getAllocator());
 }
 
 void RenderComponent::allocateAndSetupUniforms(const RenderQueueDrawContext& ctx,

src/anki/scene/RenderComponent.h

@@ -8,7 +8,6 @@
 #include <anki/scene/Common.h>
 #include <anki/scene/SceneComponent.h>
 #include <anki/resource/Material.h>
-#include <anki/resource/Model.h>
 #include <anki/core/StagingGpuMemoryManager.h>
 #include <anki/renderer/RenderQueue.h>
 
@@ -42,109 +41,6 @@ private:
 	const MaterialVariable* m_mvar = nullptr;
 };
 
-/// Rendering data input.
-class RenderingBuildInfoIn
-{
-public:
-	RenderingKey m_key;
-	const U8* m_subMeshIndicesArray; ///< @note indices != drawing indices
-	U32 m_subMeshIndicesCount;
-};
-
-/// Info on the vertex buffer binding.
-class RenderingVertexBufferBinding : public VertexBufferBinding
-{
-public:
-	StagingGpuMemoryToken m_token;
-	VertexStepRate m_stepRate = VertexStepRate::VERTEX;
-
-	Bool operator==(const RenderingVertexBufferBinding& b) const
-	{
-		if(m_token)
-		{
-			return m_token == b.m_token && m_stepRate == b.m_stepRate;
-		}
-		else
-		{
-			return static_cast<const VertexBufferBinding&>(*this) == static_cast<const VertexBufferBinding&>(b)
-				&& m_stepRate == b.m_stepRate;
-		}
-	}
-
-	Bool operator!=(const RenderingVertexBufferBinding& b) const
-	{
-		return !(*this == b);
-	}
-};
-
-using RenderingVertexAttributeInfo = VertexAttributeInfo;
-
-/// Rendering data output.
-class RenderingBuildInfoOut
-{
-public:
-	Mat4 m_transform;
-	Bool8 m_hasTransform = false;
-
-	ShaderProgramPtr m_program;
-
-	Array<RenderingVertexBufferBinding, MAX_VERTEX_ATTRIBUTES> m_vertexBufferBindings;
-	U32 m_vertexBufferBindingCount;
-	Array<RenderingVertexAttributeInfo, MAX_VERTEX_ATTRIBUTES> m_vertexAttributes;
-	U32 m_vertexAttributeCount;
-
-	BufferPtr m_indexBuffer;
-	StagingGpuMemoryToken m_indexBufferToken;
-
-	union A
-	{
-		DrawArraysIndirectInfo m_arrays;
-		DrawElementsIndirectInfo m_elements;
-
-		A()
-			: m_elements() // This is safe because of the nature of structs.
-		{
-		}
-	} m_drawcall;
-	Bool m_drawArrays = false;
-
-	PrimitiveTopology m_topology = PrimitiveTopology::TRIANGLES;
-
-	RenderingBuildInfoOut() = default;
-
-	RenderingBuildInfoOut(const RenderingBuildInfoOut& b)
-	{
-		*this = b;
-	}
-
-	RenderingBuildInfoOut& operator=(const RenderingBuildInfoOut& b)
-	{
-		m_transform = b.m_transform;
-		m_hasTransform = b.m_hasTransform;
-
-		m_vertexBufferBindingCount = b.m_vertexBufferBindingCount;
-		for(U i = 0; i < m_vertexBufferBindingCount; ++i)
-		{
-			m_vertexBufferBindings[i] = b.m_vertexBufferBindings[i];
-		}
-
-		m_vertexAttributeCount = b.m_vertexAttributeCount;
-		for(U i = 0; i < m_vertexAttributeCount; ++i)
-		{
-			m_vertexAttributes[i] = b.m_vertexAttributes[i];
-		}
-
-		m_indexBuffer = b.m_indexBuffer;
-		m_indexBufferToken = b.m_indexBufferToken;
-
-		m_drawArrays = b.m_drawArrays;
-
-		m_topology = b.m_topology;
-
-		return *this;
-	}
-};
-
 /// RenderComponent interface. Implemented by renderable scene nodes
 class RenderComponent : public SceneComponent
 {
@@ -157,8 +53,6 @@ public:
 
 	~RenderComponent();
 
-	ANKI_USE_RESULT Error init();
-
 	Variables::Iterator getVariablesBegin()
 	{
 		return m_vars.begin();
@@ -179,9 +73,6 @@ public:
 		return m_vars.end();
 	}
 
-	/// Build up the rendering.
-	virtual ANKI_USE_RESULT Error buildRendering(const RenderingBuildInfoIn& in, RenderingBuildInfoOut& out) const = 0;
-
 	/// Access the material
 	const Material& getMaterial() const
 	{

src/anki/scene/StaticGeometryNode.cpp

@@ -23,11 +23,6 @@ public:
 	{
 	}
 
-	Error buildRendering(const RenderingBuildInfoIn& in, RenderingBuildInfoOut& out) const override
-	{
-		return m_node->buildRendering(in, out);
-	}
-
 	void setupRenderQueueElement(RenderQueueElement& el) const override
 	{
 		ANKI_ASSERT(!"TODO");
@@ -63,12 +58,6 @@ Error StaticGeometryPatchNode::init(const ModelPatch* modelPatch)
 	return ErrorCode::NONE;
 }
 
-Error StaticGeometryPatchNode::buildRendering(const RenderingBuildInfoIn& in, RenderingBuildInfoOut& out) const
-{
-	ANKI_ASSERT(!"TODO");
-	return ErrorCode::NONE;
-}
-
 StaticGeometryNode::StaticGeometryNode(SceneGraph* scene, CString name)
 	: SceneNode(scene, name)
 {

src/anki/scene/StaticGeometryNode.h

@@ -33,8 +33,6 @@ public:
 
 private:
 	const ModelPatch* m_modelPatch;
-
-	ANKI_USE_RESULT Error buildRendering(const RenderingBuildInfoIn& in, RenderingBuildInfoOut& out) const;
 };
 
 /// Static geometry scene node