Merge pull request #67 from Devsh-Graphics-Programming/animations

Skeletons, Skins, Keyframes and Animation Library

Author: devshgraphicsprogramming

examples_tests/04.Keyframe/main.cpp

@@ -90,7 +90,70 @@ int main()
 	auto* smgr = device->getSceneManager();
 
 	//
-	core::smart_refctd_ptr<video::IGPUMeshBuffer> mb;
+	asset::SBufferBinding<asset::ICPUBuffer> inverseBindPoses,jointAABBs;
+	core::smart_refctd_ptr<asset::ICPUSkeleton> skeleton;
+	{
+		constexpr uint32_t kJointCount = 2u;
+		asset::SBufferBinding<asset::ICPUBuffer> parentIDs,defaultTransforms,inverseBindPoses,jointAABBs;
+		{
+			parentIDs.buffer = core::make_smart_refctd_ptr<asset::ICPUBuffer>(sizeof(asset::ICPUSkeleton)*kJointCount);
+			{
+				asset::ICPUSkeleton::joint_id_t parentJointIDs[] = { asset::ICPUSkeleton::invalid_joint_id,0u };
+				memcpy(parentIDs.buffer->getPointer(),parentJointIDs,sizeof(parentJointIDs));
+			}
+			defaultTransforms.buffer = core::make_smart_refctd_ptr<asset::ICPUBuffer>(sizeof(matrix3x4SIMD)*kJointCount);
+			inverseBindPoses.buffer = core::make_smart_refctd_ptr<asset::ICPUBuffer>(sizeof(matrix3x4SIMD)*kJointCount);
+			{
+				auto* dftTransforms = reinterpret_cast<matrix3x4SIMD*>(defaultTransforms.buffer->getPointer());
+				auto* invBindPoses = reinterpret_cast<matrix3x4SIMD*>(inverseBindPoses.buffer->getPointer());
+				for (auto i=0u; i<kJointCount; i++)
+				{
+					dftTransforms[i] = matrix3x4SIMD();
+					dftTransforms[i].setTranslation(core::vectorSIMDf(0.f,float(i)*2.f-1.f,0.f));
+					dftTransforms[i].getInverse(invBindPoses[i]);
+				}
+			}
+			jointAABBs.buffer = core::make_smart_refctd_ptr<asset::ICPUBuffer>(sizeof(aabbox3df)*kJointCount);
+		}
+		const char* jointNames[] = {"root","bendy"};
+		skeleton = core::make_smart_refctd_ptr<asset::ICPUSkeleton>(std::move(parentIDs),std::move(defaultTransforms),&jointNames[0],&jointNames[0]+kJointCount);
+	}
+	core::smart_refctd_ptr<video::IGPUAnimationLibrary> gpuanimations;
+	{
+		constexpr uint32_t kKeyframeCount = 16u;
+		constexpr uint32_t kAnimationCount = 3u;
+		core::smart_refctd_ptr<asset::ICPUAnimationLibrary> animations;
+		{
+			asset::SBufferBinding<asset::ICPUBuffer> keyframes = {0ull,core::make_smart_refctd_ptr<asset::ICPUBuffer>(sizeof(asset::ICPUAnimationLibrary::Keyframe)*kKeyframeCount)};
+			asset::SBufferBinding<asset::ICPUBuffer> timestamps = {0ull,core::make_smart_refctd_ptr<asset::ICPUBuffer>(sizeof(asset::ICPUAnimationLibrary::timestamp_t)*kKeyframeCount)};
+			asset::SBufferRange<asset::ICPUBuffer> namedAnims;
+			namedAnims.offset = 0ull;
+			namedAnims.size = sizeof(asset::ICPUAnimationLibrary::Animation)*kAnimationCount;
+			namedAnims.buffer = core::make_smart_refctd_ptr<asset::ICPUBuffer>(namedAnims.size);
+			animations = core::make_smart_refctd_ptr<asset::ICPUAnimationLibrary>(std::move(keyframes),std::move(timestamps),kKeyframeCount,std::move(namedAnims));
+		}
+		{
+			const uint32_t animationOffsets[] = { 0u,1u,2u };
+			const asset::ICPUAnimationLibrary::Animation anims[] = {
+				{0u,kKeyframeCount,asset::ICPUAnimationLibrary::Animation::EIM_NEAREST},
+				{0u,kKeyframeCount,asset::ICPUAnimationLibrary::Animation::EIM_LINEAR},
+				{0u,kKeyframeCount,asset::ICPUAnimationLibrary::Animation::EIM_CUBIC},
+			};
+			for (auto i=0u; i<kAnimationCount; i++)
+				animations->getAnimation(animationOffsets[i]) = anims[i];
+			const char* animationNames[] = { "moveNearest","moveLinear","moveCubic" };
+			animations->addAnimationNames(animationNames,animationNames+kAnimationCount,animationOffsets);
+			
+			for (auto i=0u; i<kAnimationCount; i++)
+			{
+				assert(animations->getAnimationOffsetFromName(animationNames[i]) == animationOffsets[i]);
+			}
+		}
+		gpuanimations = driver->getGPUObjectsFromAssets<asset::ICPUAnimationLibrary>(&animations,&animations+1u)->begin()[0];
+	}
+
+	//
+	core::smart_refctd_ptr<video::IGPUMeshBuffer> gpumb;
     {
         VertexStruct vertices[8];
         vertices[0] = VertexStruct{{-1.f,-1.f,-1.f},{  0,  0}};
@@ -101,6 +164,8 @@ int main()
         vertices[5] = VertexStruct{{ 1.f,-1.f, 1.f},{255,127}};
         vertices[6] = VertexStruct{{-1.f, 1.f, 1.f},{  0,255}};
         vertices[7] = VertexStruct{{ 1.f, 1.f, 1.f},{127,255}};
+		asset::SBufferBinding<asset::ICPUBuffer> bindings[asset::ICPUMeshBuffer::MAX_ATTR_BUF_BINDING_COUNT];
+		bindings[0u] = {0u,core::make_smart_refctd_ptr<asset::CCustomAllocatorCPUBuffer<core::null_allocator<uint8_t>>>(sizeof(vertices),vertices,core::adopt_memory)};
 
         uint16_t indices_indexed16[] =
         {
@@ -111,27 +176,28 @@ int main()
             0,2,4,2,4,6,
             1,3,5,3,5,7
         };
+		asset::SBufferBinding<asset::ICPUBuffer> indexBinding{0u,core::make_smart_refctd_ptr<asset::CCustomAllocatorCPUBuffer<core::null_allocator<uint8_t>>>(sizeof(indices_indexed16),indices_indexed16,core::adopt_memory)};
 
 		asset::SPushConstantRange range[1] = {asset::ISpecializedShader::ESS_VERTEX,0u,sizeof(core::matrix4SIMD)};
 
-		auto createGPUSpecializedShaderFromSource = [=](const char* source, asset::ISpecializedShader::E_SHADER_STAGE stage)
+		auto createSpecializedShaderFromSource = [=](const char* source, asset::ISpecializedShader::E_SHADER_STAGE stage)
 		{
 			auto spirv = device->getAssetManager()->getGLSLCompiler()->createSPIRVFromGLSL(source, stage, "main", "runtimeID");
-			auto unspec = driver->createGPUShader(std::move(spirv));
-			return driver->createGPUSpecializedShader(unspec.get(), { nullptr,nullptr,"main",stage });
+			return core::make_smart_refctd_ptr<asset::ICPUSpecializedShader>(std::move(spirv),asset::ICPUSpecializedShader::SInfo{ nullptr,nullptr,"main",stage });
 		};
 		// origFilepath is only relevant when you have filesystem #includes in your shader
-		auto createGPUSpecializedShaderFromSourceWithIncludes = [&](const char* source, asset::ISpecializedShader::E_SHADER_STAGE stage, const char* origFilepath)
+		auto createSpecializedShaderFromSourceWithIncludes = [&](const char* source, asset::ISpecializedShader::E_SHADER_STAGE stage, const char* origFilepath)
 		{
 			auto resolved_includes = device->getAssetManager()->getGLSLCompiler()->resolveIncludeDirectives(source, stage, origFilepath);
-			return createGPUSpecializedShaderFromSource(reinterpret_cast<const char*>(resolved_includes->getSPVorGLSL()->getPointer()), stage);
+			return createSpecializedShaderFromSource(reinterpret_cast<const char*>(resolved_includes->getSPVorGLSL()->getPointer()), stage);
 		};
-		core::smart_refctd_ptr<video::IGPUSpecializedShader> shaders[2] =
+		constexpr uint32_t kShaderCount = 2u;
+		core::smart_refctd_ptr<asset::ICPUSpecializedShader> shaders[kShaderCount] =
 		{
-			createGPUSpecializedShaderFromSourceWithIncludes(vertexSource,asset::ISpecializedShader::ESS_VERTEX, "shader.vert"),
-			createGPUSpecializedShaderFromSource(fragmentSource,asset::ISpecializedShader::ESS_FRAGMENT)
+			createSpecializedShaderFromSourceWithIncludes(vertexSource,asset::ISpecializedShader::ESS_VERTEX, "shader.vert"),
+			createSpecializedShaderFromSource(fragmentSource,asset::ISpecializedShader::ESS_FRAGMENT)
 		};
-		auto shadersPtr = reinterpret_cast<video::IGPUSpecializedShader**>(shaders);
+		auto shadersPtr = reinterpret_cast<asset::ICPUSpecializedShader**>(shaders);
 
 		asset::SVertexInputParams inputParams;
 		inputParams.enabledAttribFlags = 0b11u;
@@ -152,17 +218,19 @@ int main()
 		asset::SStencilOpParams defaultStencil;
 		asset::SRasterizationParams rasterParams;
 		rasterParams.faceCullingMode = asset::EFCM_NONE;
-		auto pipeline = driver->createGPURenderpassIndependentPipeline(	nullptr,driver->createGPUPipelineLayout(range,range+1u,nullptr,nullptr,nullptr,nullptr),
-																		shadersPtr,shadersPtr+sizeof(shaders)/sizeof(core::smart_refctd_ptr<video::IGPUSpecializedShader>),
-																		inputParams,blendParams,assemblyParams,rasterParams);
-			
-		asset::SBufferBinding<video::IGPUBuffer> bindings[video::IGPUMeshBuffer::MAX_ATTR_BUF_BINDING_COUNT];
-		bindings[0u] = {0u,driver->createFilledDeviceLocalGPUBufferOnDedMem(sizeof(vertices),vertices)};
-		mb = core::make_smart_refctd_ptr<video::IGPUMeshBuffer>(std::move(pipeline),nullptr,bindings,asset::SBufferBinding<video::IGPUBuffer>{0u,driver->createFilledDeviceLocalGPUBufferOnDedMem(sizeof(indices_indexed16),indices_indexed16)});
+		auto pipeline = core::make_smart_refctd_ptr<asset::ICPURenderpassIndependentPipeline>(
+			core::make_smart_refctd_ptr<asset::ICPUPipelineLayout>(range,range+1u,nullptr,nullptr,nullptr,nullptr),
+			shadersPtr,shadersPtr+kShaderCount,
+			inputParams,blendParams,assemblyParams,rasterParams
+		);
+
+		auto mb = core::make_smart_refctd_ptr<asset::ICPUMeshBuffer>(std::move(pipeline),nullptr,bindings,std::move(indexBinding));
 		{
+			mb->setSkin(std::move(inverseBindPoses),std::move(jointAABBs),std::move(skeleton),1u);
 			mb->setIndexType(asset::EIT_16BIT);
 			mb->setIndexCount(2*3*6);
 		}
+		gpumb = driver->getGPUObjectsFromAssets<asset::ICPUMeshBuffer>(&mb,&mb+1u)->begin()[0];
 	}
 
 
@@ -187,9 +255,9 @@ int main()
 
         //! Stress test for memleaks aside from demo how to create meshes that live on the GPU RAM
         {
-			driver->bindGraphicsPipeline(mb->getPipeline());
-			driver->pushConstants(mb->getPipeline()->getLayout(), asset::ISpecializedShader::ESS_VERTEX, 0u, sizeof(core::matrix4SIMD), mvp.pointer());
-			driver->drawMeshBuffer(mb.get());
+			driver->bindGraphicsPipeline(gpumb->getPipeline());
+			driver->pushConstants(gpumb->getPipeline()->getLayout(), asset::ISpecializedShader::ESS_VERTEX, 0u, sizeof(core::matrix4SIMD), mvp.pointer());
+			driver->drawMeshBuffer(gpumb.get());
         }
 		driver->endScene();
 

examples_tests/18.MitsubaLoader/main.cpp

@@ -213,6 +213,8 @@ int main()
 
 		auto serializedLoader = core::make_smart_refctd_ptr<nbl::ext::MitsubaLoader::CSerializedLoader>(am);
 		auto mitsubaLoader = core::make_smart_refctd_ptr<nbl::ext::MitsubaLoader::CMitsubaLoader>(am,fs);
+		serializedLoader->initialize();
+		mitsubaLoader->initialize();
 		am->addAssetLoader(std::move(serializedLoader));
 		am->addAssetLoader(std::move(mitsubaLoader));
 
@@ -327,7 +329,11 @@ int main()
 	// look out for this!!!
 	// when added, CMitsubaLoader inserts its own include loader into GLSLCompiler
 	// thats why i have to add it again here (after device recreation) to be able to compile shaders
-	am->addAssetLoader(core::make_smart_refctd_ptr<nbl::ext::MitsubaLoader::CMitsubaLoader>(am, device->getFileSystem()));
+	{
+		auto mitsubaLoader = core::make_smart_refctd_ptr<nbl::ext::MitsubaLoader::CMitsubaLoader>(am, fs);
+		mitsubaLoader->initialize();
+		am->addAssetLoader(std::move(mitsubaLoader));
+	}
 
 	core::smart_refctd_ptr<asset::ICPUDescriptorSetLayout> ds2layout;
 	{

include/ISceneManager.h

@@ -34,11 +34,9 @@ namespace scene
 	class IDummyTransformationSceneNode;
 	class IMeshLoader;
 	class IMeshSceneNode;
-	class IMeshSceneNodeInstanced;
 	class IMeshWriter;
 	class ISceneNode;
 	class ISceneNodeAnimator;
-	class ISceneNodeAnimatorCollisionResponse;
 
 	//! The Scene Manager manages scene nodes, mesh recources, cameras and all the other stuff.
 	/** All Scene nodes can be created only here. There is a always growing
@@ -183,25 +181,6 @@ namespace scene
 			float jumpSpeed = 0.f, bool invertMouse=false,
 			bool makeActive=true) = 0;
 
-		//! Adds a dummy transformation scene node to the scene tree.
-		/** This scene node does not render itself, have a bounding box, a render method,
-        and is as-if always visible ISceneNode.
-		Its actually a base of ISceneNode, and it can be used for doing advanced transformations
-		or structuring the scene tree.
-		\return Pointer to the created scene node.
-		This pointer should not be dropped. See IReferenceCounted::drop() for more information. */
-		virtual IDummyTransformationSceneNode* addDummyTransformationSceneNode(
-			IDummyTransformationSceneNode* parent=0, int32_t id=-1) = 0;
-
-		//! Gets the root scene node.
-		/** This is the scene node which is parent
-		of all scene nodes. The root scene node is a special scene node which
-		only exists to manage all scene nodes. It will not be rendered and cannot
-		be removed from the scene.
-		\return Pointer to the root scene node.
-		This pointer should not be dropped. See IReferenceCounted::drop() for more information. */
-		virtual ISceneNode* getRootSceneNode() = 0;
-
 		//! Get the current active camera.
 		/** \return The active camera is returned. Note that this can
 		be NULL, if there was no camera created yet.
@@ -213,17 +192,6 @@ namespace scene
 		\param camera: The new camera which should be active. */
 		virtual void setActiveCamera(ICameraSceneNode* camera) = 0;
 
-		//! Adds a scene node to the deletion queue.
-		/** The scene node is immediatly
-		deleted when it's secure. Which means when the scene node does not
-		execute animators and things like that. This method is for example
-		used for deleting scene nodes by their scene node animators. In
-		most other cases, a ISceneNode::remove() call is enough, using this
-		deletion queue is not necessary.
-		See ISceneManager::createDeleteAnimator() for details.
-		\param node: Node to detete. */
-		virtual void addToDeletionQueue(IDummyTransformationSceneNode* node) = 0;
-
 		//! Posts an input event to the environment.
 		/** Usually you do not have to
 		use this method, it is used by the internal engine. */

include/ISceneNode.h

@@ -39,7 +39,7 @@ namespace scene
 				const core::vector3df& rotation = core::vector3df(0,0,0),
 				const core::vector3df& scale = core::vector3df(1.0f, 1.0f, 1.0f))
 			:   IDummyTransformationSceneNode(parent,position,rotation,scale),
-                AutomaticCullingState(true), IsVisible(true), renderPriority(0x80000000u)
+                AutomaticCullingState(true), IsVisible(true)
 		{
 		}
 
@@ -61,31 +61,6 @@ namespace scene
 		virtual void render() = 0;
 
 
-		//! Get the axis aligned, not transformed bounding box of this node.
-		/** This means that if this node is an animated 3d character,
-		moving in a room, the bounding box will always be around the
-		origin. To get the box in real world coordinates, just
-		transform it with the matrix you receive with
-		getAbsoluteTransformation() or simply use
-		getTransformedBoundingBox(), which does the same.
-		\return The non-transformed bounding box. */
-		virtual const core::aabbox3d<float>& getBoundingBox() = 0;
-
-
-		//! Get the axis aligned, transformed and animated absolute bounding box of this node.
-		/** \return The transformed bounding box. */
-		virtual const core::aabbox3d<float> getTransformedBoundingBox()
-		{
-			core::aabbox3d<float> box = getBoundingBox();
-			AbsoluteTransformation.transformBoxEx(box);
-			return box;
-		}
-
-		inline const uint32_t& getRenderPriorityScore() const {return renderPriority;}
-
-		inline void setRenderPriorityScore(const uint32_t& nice) {renderPriority = nice;}
-
-
 		//! Returns whether the node should be visible (only matters if all of its parents are visible).
 		/** This is only an option set by the user, but has nothing to
 		do with geometry culling
@@ -126,8 +101,6 @@ namespace scene
 		//! Is the node visible?
 		bool IsVisible;
 
-		uint32_t renderPriority;
-
         static void OnAnimate_static(IDummyTransformationSceneNode* node, uint32_t timeMs) // could be pushed up to IDummyTransformationSceneNode
 		{
             ISceneNode* tmp = static_cast<ISceneNode*>(node);