Refactor the scene in preperation for some more RT code

anki/Scene.h

@@ -7,7 +7,6 @@
 
 #include <anki/scene/SceneGraph.h>
 #include <anki/scene/ModelNode.h>
-#include <anki/scene/StaticGeometryNode.h>
 #include <anki/scene/ParticleEmitterNode.h>
 #include <anki/scene/GpuParticleEmitterNode.h>
 #include <anki/scene/CameraNode.h>
@@ -48,4 +47,4 @@
 #include <anki/scene/events/AnimationEvent.h>
 #include <anki/scene/events/JitterMoveEvent.h>
 #include <anki/scene/events/LightEvent.h>
-#include <anki/scene/events/ScriptEvent.h>
+#include <anki/scene/events/ScriptEvent.h>

anki/resource/ModelResource.h

@@ -141,6 +141,11 @@ public:
 	/// @return Return's false if the @a type is not supported.
 	Bool getRayTracingInfo(U32 lod, RayTracingMaterialType type, ModelRayTracingInfo& info) const;
 
+	Bool getRayTracingTypeSupported(RayTracingMaterialType type) const
+	{
+		return m_mtl->getRayTracingTypeSupported(type);
+	}
+
 private:
 	ModelResource* m_model ANKI_DEBUG_CODE(= nullptr);
 

anki/scene/Forward.h

@@ -14,7 +14,6 @@ class FrustumComponent;
 class InstanceComponent;
 class MoveComponent;
 class RenderComponent;
-class MaterialRenderComponent;
 class SpatialComponent;
 class DecalComponent;
 class ReflectionProxyComponent;

anki/scene/GpuParticleEmitterNode.cpp

@@ -148,8 +148,8 @@ Error GpuParticleEmitterNode::init(const CString& filename)
 			static_cast<const GpuParticleEmitterNode*>(userData)->simulate(ctx);
 		},
 		this);
-	MaterialRenderComponent* rcomp = newComponent<MaterialRenderComponent>(this, m_emitterRsrc->getMaterial());
-	rcomp->setup(
+	RenderComponent* rcomp = newComponent<RenderComponent>();
+	rcomp->setupRaster(
 		[](RenderQueueDrawContext& ctx, ConstWeakArray<void*> userData) {
 			ANKI_ASSERT(userData.getSize() == 1);
 			static_cast<const GpuParticleEmitterNode*>(userData[0])->draw(ctx);
@@ -157,6 +157,7 @@ Error GpuParticleEmitterNode::init(const CString& filename)
 		this,
 		0 // No merging
 	);
+	rcomp->setFlagsFromMaterial(m_emitterRsrc->getMaterial());
 
 	return Error::NONE;
 }
@@ -221,9 +222,9 @@ void GpuParticleEmitterNode::draw(RenderQueueDrawContext& ctx) const
 
 		// Resources
 		static const Mat4 identity = Mat4::getIdentity();
-		static_cast<const MaterialRenderComponent&>(getFirstComponentOfType<RenderComponent>())
-			.allocateAndSetupUniforms(ctx, ConstWeakArray<Mat4>(&identity, 1), ConstWeakArray<Mat4>(&identity, 1),
-									  *ctx.m_stagingGpuAllocator);
+
+		RenderComponent::allocateAndSetupUniforms(m_emitterRsrc->getMaterial(), ctx, ConstWeakArray<Mat4>(&identity, 1),
+												  ConstWeakArray<Mat4>(&identity, 1), *ctx.m_stagingGpuAllocator);
 
 		cmdb->bindStorageBuffer(0, 1, m_particlesBuff, 0, MAX_PTR_SIZE);
 

anki/scene/ModelNode.cpp

@@ -103,14 +103,14 @@ Error ModelNode::init(ModelResourcePtr resource, U32 modelPatchIdx)
 	newComponent<MoveComponent>();
 	newComponent<MoveFeedbackComponent>();
 	newComponent<SpatialComponent>(this, &m_obbWorld);
-	MaterialRenderComponent* rcomp =
-		newComponent<MaterialRenderComponent>(this, m_model->getModelPatches()[m_modelPatchIdx].getMaterial());
-	rcomp->setup(
+	RenderComponent* rcomp = newComponent<RenderComponent>();
+	rcomp->setupRaster(
 		[](RenderQueueDrawContext& ctx, ConstWeakArray<void*> userData) {
 			const ModelNode& self = *static_cast<const ModelNode*>(userData[0]);
 			self.draw(ctx, userData);
 		},
 		this, m_mergeKey);
+	rcomp->setFlagsFromMaterial(m_model->getModelPatches()[m_modelPatchIdx].getMaterial());
 
 	m_obbLocal = m_model->getModelPatches()[m_modelPatchIdx].getBoundingShape();
 
@@ -210,10 +210,10 @@ void ModelNode::draw(RenderQueueDrawContext& ctx, ConstWeakArray<void*> userData
 		cmdb->bindShaderProgram(modelInf.m_program);
 
 		// Uniforms
-		static_cast<const MaterialRenderComponent&>(getFirstComponentOfType<RenderComponent>())
-			.allocateAndSetupUniforms(ctx, ConstWeakArray<Mat4>(&trfs[0], userData.getSize()),
-									  ConstWeakArray<Mat4>(&prevTrfs[0], userData.getSize()),
-									  *ctx.m_stagingGpuAllocator);
+		RenderComponent::allocateAndSetupUniforms(m_model->getModelPatches()[m_modelPatchIdx].getMaterial(), ctx,
+												  ConstWeakArray<Mat4>(&trfs[0], userData.getSize()),
+												  ConstWeakArray<Mat4>(&prevTrfs[0], userData.getSize()),
+												  *ctx.m_stagingGpuAllocator);
 
 		// Set attributes
 		for(U i = 0; i < modelInf.m_vertexAttributeCount; ++i)

anki/scene/ParticleEmitterNode.cpp

@@ -253,9 +253,9 @@ Error ParticleEmitterNode::init(const CString& filename)
 	newComponent<SpatialComponent>(this, &m_obb);
 
 	// Render component
-	MaterialRenderComponent* rcomp =
-		newComponent<MaterialRenderComponent>(this, m_particleEmitterResource->getMaterial());
-	rcomp->setup(drawCallback, this, 0); // No merging
+	RenderComponent* rcomp = newComponent<RenderComponent>();
+	rcomp->setupRaster(drawCallback, this, 0); // No merging
+	rcomp->setFlagsFromMaterial(m_particleEmitterResource->getMaterial());
 
 	// Other
 	m_obb.setCenter(Vec4(0.0));
@@ -321,8 +321,8 @@ void ParticleEmitterNode::drawCallback(RenderQueueDrawContext& ctx, ConstWeakArr
 
 		// Uniforms
 		Array<Mat4, 1> trf = {Mat4::getIdentity()};
-		static_cast<const MaterialRenderComponent&>(self.getFirstComponentOfType<RenderComponent>())
-			.allocateAndSetupUniforms(ctx, trf, trf, *ctx.m_stagingGpuAllocator);
+		RenderComponent::allocateAndSetupUniforms(self.m_particleEmitterResource->getMaterial(), ctx, trf, trf,
+												  *ctx.m_stagingGpuAllocator);
 
 		// Draw
 		cmdb->drawArrays(PrimitiveTopology::TRIANGLE_STRIP, 4, self.m_aliveParticlesCount, 0, 0);

anki/scene/PhysicsDebugNode.cpp

@@ -27,9 +27,9 @@ public:
 	{
 		ANKI_ASSERT(node);
 		setFlags(RenderComponentFlag::NONE);
-		setup([](RenderQueueDrawContext& ctx,
-				 ConstWeakArray<void*> userData) { static_cast<MyRenderComponent*>(userData[0])->draw(ctx); },
-			  this, 0);
+		setupRaster([](RenderQueueDrawContext& ctx,
+					   ConstWeakArray<void*> userData) { static_cast<MyRenderComponent*>(userData[0])->draw(ctx); },
+					this, 0);
 	}
 
 	ANKI_USE_RESULT Error init()
@@ -71,4 +71,4 @@ Error PhysicsDebugNode::init()
 	return Error::NONE;
 }
 
-} // end namespace anki
+} // end namespace anki

anki/scene/StaticGeometryNode.cpp

@@ -1,69 +0,0 @@
-// Copyright (C) 2009-2020, Panagiotis Christopoulos Charitos and contributors.
-// All rights reserved.
-// Code licensed under the BSD License.
-// http://www.anki3d.org/LICENSE
-
-#include <anki/scene/StaticGeometryNode.h>
-#include <anki/scene/SceneGraph.h>
-#include <anki/resource/ResourceManager.h>
-#include <anki/resource/ModelResource.h>
-
-namespace anki
-{
-
-StaticGeometryPatchNode::StaticGeometryPatchNode(SceneGraph* scene, CString name)
-	: SceneNode(scene, name)
-{
-}
-
-StaticGeometryPatchNode::~StaticGeometryPatchNode()
-{
-}
-
-Error StaticGeometryPatchNode::init(const ModelPatch* modelPatch)
-{
-	ANKI_ASSERT(modelPatch);
-
-	m_modelPatch = modelPatch;
-
-	// Create spatial components
-	for(U32 i = 1; i < m_modelPatch->getSubMeshCount(); i++)
-	{
-		SpatialComponent* spatial = newComponent<SpatialComponent>(this, &m_modelPatch->getBoundingShapeSub(i));
-
-		spatial->setSpatialOrigin(m_modelPatch->getBoundingShapeSub(i).getCenter());
-	}
-
-	// Create render component
-	MaterialRenderComponent* rcomp = newComponent<MaterialRenderComponent>(this, m_modelPatch->getMaterial());
-	rcomp->setup([](RenderQueueDrawContext& ctx, ConstWeakArray<void*> userData) { ANKI_ASSERT(!"TODO"); }, this, 0);
-
-	return Error::NONE;
-}
-
-StaticGeometryNode::StaticGeometryNode(SceneGraph* scene, CString name)
-	: SceneNode(scene, name)
-{
-}
-
-StaticGeometryNode::~StaticGeometryNode()
-{
-}
-
-Error StaticGeometryNode::init(const CString& filename)
-{
-	ANKI_CHECK(getResourceManager().loadResource(filename, m_model));
-
-	U i = 0;
-	for(const ModelPatch& patch : m_model->getModelPatches())
-	{
-		StaticGeometryPatchNode* node;
-		ANKI_CHECK(getSceneGraph().newSceneNode<StaticGeometryPatchNode>(CString(), node, &patch));
-
-		++i;
-	}
-
-	return Error::NONE;
-}
-
-} // end namespace anki

anki/scene/StaticGeometryNode.h

@@ -1,51 +0,0 @@
-// Copyright (C) 2009-2020, Panagiotis Christopoulos Charitos and contributors.
-// All rights reserved.
-// Code licensed under the BSD License.
-// http://www.anki3d.org/LICENSE
-
-#pragma once
-
-#include <anki/scene/Common.h>
-#include <anki/scene/SceneNode.h>
-#include <anki/scene/components/SpatialComponent.h>
-#include <anki/scene/components/RenderComponent.h>
-
-namespace anki
-{
-
-// Forward
-class ModelPatch;
-
-/// @addtogroup scene
-/// @{
-
-/// Static geometry scene node patch
-class StaticGeometryPatchNode : public SceneNode
-{
-public:
-	StaticGeometryPatchNode(SceneGraph* scene, CString name);
-
-	~StaticGeometryPatchNode();
-
-	ANKI_USE_RESULT Error init(const ModelPatch* modelPatch);
-
-private:
-	const ModelPatch* m_modelPatch;
-};
-
-/// Static geometry scene node
-class StaticGeometryNode : public SceneNode
-{
-public:
-	StaticGeometryNode(SceneGraph* scene, CString name);
-
-	~StaticGeometryNode();
-
-	ANKI_USE_RESULT Error init(const CString& filename);
-
-private:
-	ModelResourcePtr m_model;
-};
-/// @}
-
-} // end namespace anki

anki/scene/Visibility.cpp

@@ -237,33 +237,9 @@ void VisibilityTestTask::test(ThreadHive& hive, U32 taskId)
 	Timestamp& timestamp = m_frcCtx->m_queueViews[taskId].m_timestamp;
 	timestamp = testedNode.getComponentMaxTimestamp();
 
-	const Bool wantsRenderComponents =
-		!!(enabledVisibilityTests & FrustumComponentVisibilityTestFlag::RENDER_COMPONENTS);
-
-	const Bool wantsLightComponents = !!(enabledVisibilityTests & FrustumComponentVisibilityTestFlag::LIGHT_COMPONENTS);
-
-	const Bool wantsFlareComponents =
-		!!(enabledVisibilityTests & FrustumComponentVisibilityTestFlag::LENS_FLARE_COMPONENTS);
-
-	const Bool wantsShadowCasters = !!(enabledVisibilityTests & FrustumComponentVisibilityTestFlag::SHADOW_CASTERS);
-
-	const Bool wantsReflectionProbes =
-		!!(enabledVisibilityTests & FrustumComponentVisibilityTestFlag::REFLECTION_PROBES);
-
-	const Bool wantsDecals = !!(enabledVisibilityTests & FrustumComponentVisibilityTestFlag::DECALS);
-
-	const Bool wantsFogDensityComponents =
-		!!(enabledVisibilityTests & FrustumComponentVisibilityTestFlag::FOG_DENSITY_COMPONENTS);
-
-	const Bool wantsGiProbeCoponents =
-		!!(enabledVisibilityTests & FrustumComponentVisibilityTestFlag::GLOBAL_ILLUMINATION_PROBES);
-
 	const Bool wantsEarlyZ = !!(enabledVisibilityTests & FrustumComponentVisibilityTestFlag::EARLY_Z)
 							 && m_frcCtx->m_visCtx->m_earlyZDist > 0.0f;
 
-	const Bool wantsGenericComputeJobCoponents =
-		!!(enabledVisibilityTests & FrustumComponentVisibilityTestFlag::GENERIC_COMPUTE_JOB_COMPONENTS);
-
 	// Iterate
 	RenderQueueView& result = m_frcCtx->m_queueViews[taskId];
 	for(U i = 0; i < m_spatialToTestCount; ++i)
@@ -282,32 +258,39 @@ void VisibilityTestTask::test(ThreadHive& hive, U32 taskId)
 		Bool wantNode = false;
 
 		const RenderComponent* rc = nullptr;
-		wantNode |= wantsRenderComponents && (rc = node.tryGetFirstComponentOfType<RenderComponent>());
+		wantNode |= !!(enabledVisibilityTests & FrustumComponentVisibilityTestFlag::RENDER_COMPONENTS)
+					&& (rc = node.tryGetFirstComponentOfType<RenderComponent>());
 
-		wantNode |= wantsShadowCasters && (rc = node.tryGetFirstComponentOfType<RenderComponent>())
+		wantNode |= !!(enabledVisibilityTests & FrustumComponentVisibilityTestFlag::SHADOW_CASTERS)
+					&& (rc = node.tryGetFirstComponentOfType<RenderComponent>())
 					&& !!(rc->getFlags() & RenderComponentFlag::CASTS_SHADOW);
 
 		const LightComponent* lc = nullptr;
-		wantNode |= wantsLightComponents && (lc = node.tryGetFirstComponentOfType<LightComponent>());
+		wantNode |= !!(enabledVisibilityTests & FrustumComponentVisibilityTestFlag::LIGHT_COMPONENTS)
+					&& (lc = node.tryGetFirstComponentOfType<LightComponent>());
 
 		const LensFlareComponent* lfc = nullptr;
-		wantNode |= wantsFlareComponents && (lfc = node.tryGetFirstComponentOfType<LensFlareComponent>());
+		wantNode |= !!(enabledVisibilityTests & FrustumComponentVisibilityTestFlag::LENS_FLARE_COMPONENTS)
+					&& (lfc = node.tryGetFirstComponentOfType<LensFlareComponent>());
 
 		const ReflectionProbeComponent* reflc = nullptr;
-		wantNode |= wantsReflectionProbes && (reflc = node.tryGetFirstComponentOfType<ReflectionProbeComponent>());
+		wantNode |= !!(enabledVisibilityTests & FrustumComponentVisibilityTestFlag::REFLECTION_PROBES)
+					&& (reflc = node.tryGetFirstComponentOfType<ReflectionProbeComponent>());
 
 		DecalComponent* decalc = nullptr;
-		wantNode |= wantsDecals && (decalc = node.tryGetFirstComponentOfType<DecalComponent>());
+		wantNode |= !!(enabledVisibilityTests & FrustumComponentVisibilityTestFlag::DECALS)
+					&& (decalc = node.tryGetFirstComponentOfType<DecalComponent>());
 
 		const FogDensityComponent* fogc = nullptr;
-		wantNode |= wantsFogDensityComponents && (fogc = node.tryGetFirstComponentOfType<FogDensityComponent>());
+		wantNode |= !!(enabledVisibilityTests & FrustumComponentVisibilityTestFlag::FOG_DENSITY_COMPONENTS)
+					&& (fogc = node.tryGetFirstComponentOfType<FogDensityComponent>());
 
 		GlobalIlluminationProbeComponent* giprobec = nullptr;
-		wantNode |=
-			wantsGiProbeCoponents && (giprobec = node.tryGetFirstComponentOfType<GlobalIlluminationProbeComponent>());
+		wantNode |= !!(enabledVisibilityTests & FrustumComponentVisibilityTestFlag::GLOBAL_ILLUMINATION_PROBES)
+					&& (giprobec = node.tryGetFirstComponentOfType<GlobalIlluminationProbeComponent>());
 
 		GenericGpuComputeJobComponent* computec = nullptr;
-		wantNode |= wantsGenericComputeJobCoponents
+		wantNode |= !!(enabledVisibilityTests & FrustumComponentVisibilityTestFlag::GENERIC_COMPUTE_JOB_COMPONENTS)
 					&& (computec = node.tryGetFirstComponentOfType<GenericGpuComputeJobComponent>());
 
 		if(ANKI_UNLIKELY(!wantNode))

anki/scene/components/RenderComponent.cpp

@@ -12,56 +12,27 @@
 namespace anki
 {
 
-MaterialRenderComponent::MaterialRenderComponent(SceneNode* node, MaterialResourcePtr mtl)
-	: m_node(node)
-	, m_mtl(mtl)
-{
-	ANKI_ASSERT(node);
-
-	// Create the material variables
-	m_vars.create(m_node->getAllocator(), m_mtl->getVariables().getSize());
-	U32 count = 0;
-	for(const MaterialVariable& mv : m_mtl->getVariables())
-	{
-		m_vars[count++].m_mvar = &mv;
-	}
-
-	RenderComponentFlag flags =
-		(mtl->isForwardShading()) ? RenderComponentFlag::FORWARD_SHADING : RenderComponentFlag::NONE;
-	flags |= (mtl->castsShadow()) ? RenderComponentFlag::CASTS_SHADOW : RenderComponentFlag::NONE;
-	setFlags(flags);
-}
-
-MaterialRenderComponent::~MaterialRenderComponent()
-{
-	m_vars.destroy(m_node->getAllocator());
-}
-
-void MaterialRenderComponent::allocateAndSetupUniforms(const RenderQueueDrawContext& ctx,
-													   ConstWeakArray<Mat4> transforms,
-													   ConstWeakArray<Mat4> prevTransforms,
-													   StagingGpuMemoryManager& alloc) const
+void RenderComponent::allocateAndSetupUniforms(const MaterialResourcePtr& mtl, const RenderQueueDrawContext& ctx,
+											   ConstWeakArray<Mat4> transforms, ConstWeakArray<Mat4> prevTransforms,
+											   StagingGpuMemoryManager& alloc)
 {
 	ANKI_ASSERT(transforms.getSize() <= MAX_INSTANCES);
 	ANKI_ASSERT(prevTransforms.getSize() == transforms.getSize());
 
-	const MaterialVariant& variant = m_mtl->getOrCreateVariant(ctx.m_key);
-	const U32 set = m_mtl->getDescriptorSetIndex();
+	const MaterialVariant& variant = mtl->getOrCreateVariant(ctx.m_key);
+	const U32 set = mtl->getDescriptorSetIndex();
 
 	// Allocate uniform memory
 	StagingGpuMemoryToken token;
 	void* const uniformsBegin =
 		alloc.allocateFrame(variant.getUniformBlockSize(), StagingGpuMemoryType::UNIFORM, token);
 	const void* const uniformsEnd = static_cast<U8*>(uniformsBegin) + variant.getUniformBlockSize();
-	ctx.m_commandBuffer->bindUniformBuffer(set, m_mtl->getUniformsBinding(), token.m_buffer, token.m_offset,
+	ctx.m_commandBuffer->bindUniformBuffer(set, mtl->getUniformsBinding(), token.m_buffer, token.m_offset,
 										   token.m_range);
 
 	// Iterate variables
-	for(auto it = m_vars.getBegin(); it != m_vars.getEnd(); ++it)
+	for(const MaterialVariable& mvar : mtl->getVariables())
 	{
-		const MaterialRenderComponentVariable& var = *it;
-		const MaterialVariable& mvar = var.getMaterialVariable();
-
 		if(!variant.isVariableActive(mvar))
 		{
 			continue;

anki/scene/components/RenderComponent.h

@@ -47,7 +47,15 @@ public:
 		m_flags = flags;
 	}
 
-	void setup(RenderQueueDrawCallback callback, const void* userData, U64 mergeKey)
+	void setFlagsFromMaterial(const MaterialResourcePtr& mtl)
+	{
+		RenderComponentFlag flags =
+			(mtl->isForwardShading()) ? RenderComponentFlag::FORWARD_SHADING : RenderComponentFlag::NONE;
+		flags |= (mtl->castsShadow()) ? RenderComponentFlag::CASTS_SHADOW : RenderComponentFlag::NONE;
+		setFlags(flags);
+	}
+
+	void setupRaster(RenderQueueDrawCallback callback, const void* userData, U64 mergeKey)
 	{
 		ANKI_ASSERT(callback != nullptr);
 		ANKI_ASSERT(userData != nullptr);
@@ -67,106 +75,17 @@ public:
 		el.m_mergeKey = m_mergeKey;
 	}
 
+	/// Helper function.
+	static void allocateAndSetupUniforms(const MaterialResourcePtr& mtl, const RenderQueueDrawContext& ctx,
+										 ConstWeakArray<Mat4> transforms, ConstWeakArray<Mat4> prevTransforms,
+										 StagingGpuMemoryManager& alloc);
+
 private:
 	RenderQueueDrawCallback m_callback ANKI_DEBUG_CODE(= nullptr);
 	const void* m_userData ANKI_DEBUG_CODE(= nullptr);
 	U64 m_mergeKey ANKI_DEBUG_CODE(= MAX_U64);
 	RenderComponentFlag m_flags = RenderComponentFlag::NONE;
 };
-
-/// A wrapper on top of MaterialVariable
-class MaterialRenderComponentVariable
-{
-	friend class MaterialRenderComponent;
-
-public:
-	MaterialRenderComponentVariable() = default;
-	~MaterialRenderComponentVariable() = default;
-
-	template<typename T>
-	const T& getValue() const
-	{
-		return m_mvar->getValue<T>();
-	}
-
-	const MaterialVariable& getMaterialVariable() const
-	{
-		return *m_mvar;
-	}
-
-private:
-	const MaterialVariable* m_mvar = nullptr;
-};
-
-/// Material render component interface.
-class MaterialRenderComponent : public RenderComponent
-{
-public:
-	using Variables = DynamicArray<MaterialRenderComponentVariable>;
-
-	MaterialRenderComponent(SceneNode* node, MaterialResourcePtr mtl);
-
-	~MaterialRenderComponent();
-
-	Variables::Iterator getVariablesBegin()
-	{
-		return m_vars.begin();
-	}
-
-	Variables::Iterator getVariablesEnd()
-	{
-		return m_vars.end();
-	}
-
-	Variables::ConstIterator getVariablesBegin() const
-	{
-		return m_vars.begin();
-	}
-
-	Variables::ConstIterator getVariablesEnd() const
-	{
-		return m_vars.end();
-	}
-
-	/// Access the material
-	const MaterialResource& getMaterial() const
-	{
-		ANKI_ASSERT(m_mtl);
-		return *m_mtl;
-	}
-
-	const SceneNode& getSceneNode() const
-	{
-		return *m_node;
-	}
-
-	SceneNode& getSceneNode()
-	{
-		return *m_node;
-	}
-
-	/// Iterate variables using a lambda
-	template<typename Func>
-	ANKI_USE_RESULT Error iterateVariables(Func func)
-	{
-		Error err = Error::NONE;
-		Variables::Iterator it = m_vars.getBegin();
-		for(; it != m_vars.getEnd() && !err; it++)
-		{
-			err = func(*it);
-		}
-
-		return err;
-	}
-
-	void allocateAndSetupUniforms(const RenderQueueDrawContext& ctx, ConstWeakArray<Mat4> transforms,
-								  ConstWeakArray<Mat4> prevTransforms, StagingGpuMemoryManager& alloc) const;
-
-private:
-	SceneNode* m_node;
-	Variables m_vars;
-	MaterialResourcePtr m_mtl;
-};
 /// @}
 
 } // end namespace anki