crea IGPUSkeleton.h and attempt CPU to GPU conversion

devshgraphicsprogramming · devshgraphicsprogramming · commit 0da8774ed4f6 · 2021-02-17T17:49:03.000+01:00
diff --git a/examples_tests/04.Keyframe/main.cpp b/examples_tests/04.Keyframe/main.cpp
@@ -89,6 +89,30 @@ int main()
 	auto* driver = device->getVideoDriver();
 	auto* smgr = device->getSceneManager();
 
+	//
+	constexpr uint32_t kJointCount = 2u;
+	asset::SBufferBinding<asset::ICPUBuffer> parentIDs,inverseBindPoses;
+	{
+		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));
+		}
+		inverseBindPoses.buffer = core::make_smart_refctd_ptr<asset::ICPUBuffer>(sizeof(matrix3x4SIMD)*kJointCount);
+		{
+			auto* invBindPoses = reinterpret_cast<matrix3x4SIMD*>(inverseBindPoses.buffer->getPointer());
+			for (auto i=0u; i<kJointCount; i++)
+			{
+				matrix3x4SIMD tmp;
+				tmp.setTranslation(core::vectorSIMDf(0.f,float(i)*2.f-1.f,0.f));
+				tmp.getInverse(invBindPoses[i]);
+			}
+		}
+	}
+	const char* jointNames[] = {"root","bendy"};
+	auto skeleton = core::make_smart_refctd_ptr<asset::ICPUSkeleton>(std::move(parentIDs),std::move(inverseBindPoses),&jointNames[0],&jointNames[0]+kJointCount);
+	//auto gpuSkeleton = driver->getGPUObjectsFromAssets<asset::ICPUSkeleton>(&skeleton,&skeleton+1u); // TODO: Test conversion path, linker error
+
 	//
 	core::smart_refctd_ptr<video::IGPUMeshBuffer> mb;
     {
diff --git a/include/nbl/asset/IAsset.h b/include/nbl/asset/IAsset.h
@@ -164,7 +164,7 @@ class IAsset : virtual public core::IReferenceCounted
 			Additionally the size is used to determine compression level while writing process is performed.
 			As you expect, the bigger the size returned the more likely it is to be compressed with a more expensive (slower) algorithm.
 		*/
-		virtual size_t conservativeSizeEstimate() const = 0;
+		virtual size_t conservativeSizeEstimate() const = 0; // TODO: this shouldn't be a method of IAsset but BlobSerializable ?
 
 		//! creates a copy of the asset, duplicating dependant resources up to a certain depth (default duplicate everything)
         virtual core::smart_refctd_ptr<IAsset> clone(uint32_t _depth = ~0u) const = 0;
diff --git a/include/nbl/asset/ICPUSkeleton.h b/include/nbl/asset/ICPUSkeleton.h
@@ -13,35 +13,39 @@ namespace nbl
 namespace asset
 {
 
-class ICPUSkeleton : public ISkeleton<ICPUBuffer>, /*TODO: public BlobSerializable, */public IAsset
+class ICPUSkeleton final : public ISkeleton<ICPUBuffer>, /*TODO: public BlobSerializable, */public IAsset
 {
 	public:
-		using Base = ISkeleton<ICPUBuffer>;
+		using base_t = ISkeleton<ICPUBuffer>;
 
 		template<typename NameIterator>
-		ICPUSkeleton(SBufferBinding<BufferType>&& _parentJointIDsBinding, SBufferBinding<BufferType>&& _inverseBindPosesBinding, NameIterator begin, NameIterator end) : Base(std::move(_parentJointIDsBinding),std::move(_inverseBindPosesBinding))
+		inline ICPUSkeleton(SBufferBinding<ICPUBuffer>&& _parentJointIDsBinding, SBufferBinding<ICPUBuffer>&& _inverseBindPosesBinding, NameIterator begin, NameIterator end) : base_t(std::move(_parentJointIDsBinding),std::move(_inverseBindPosesBinding),std::distance(begin,end))
 		{
-			Base::setJointNames<NameIterator>(begin,end);
+			base_t::setJointNames<NameIterator>(begin,end);
 		}
+		template<typename... Args>
+		inline ICPUSkeleton(Args&&... args) : base_t(std::forward<Args>(args)...) {}
 
 		//
-		inline const core::matrix3x4SIMD& getInversePoseBindMatrix(Base::joint_id_t jointID) const
+		inline const core::matrix3x4SIMD& getInversePoseBindMatrix(base_t::joint_id_t jointID) const
 		{
-			return reinterpret_cast<const core::matrix3x4SIMD*>(m_inverseBindPoses.buffer->getPointer()+m_inverseBindPoses.offset)[jointID];
+			const uint8_t* ptr = reinterpret_cast<const uint8_t*>(m_inverseBindPoses.buffer->getPointer());
+			return reinterpret_cast<const core::matrix3x4SIMD*>(ptr+m_inverseBindPoses.offset)[jointID];
 		}
-		inline core::matrix3x4SIMD& getInversePoseBindMatrix(Base::joint_id_t jointID)
+		inline core::matrix3x4SIMD& getInversePoseBindMatrix(base_t::joint_id_t jointID)
 		{
 			return const_cast<core::matrix3x4SIMD&>(const_cast<const ICPUSkeleton*>(this)->getInversePoseBindMatrix(jointID));
 		}
 
 		//
-		inline const Base::joint_id_t& getParentJointID(Base::joint_id_t jointID) const
+		inline const base_t::joint_id_t& getParentJointID(base_t::joint_id_t jointID) const
 		{
-			return reinterpret_cast<const Base::joint_id_t*>(m_parentJointIDs.buffer->getPointer()+m_parentJointIDs.offset)[jointID];
+			const uint8_t* ptr = reinterpret_cast<const uint8_t*>(m_parentJointIDs.buffer->getPointer());
+			return reinterpret_cast<const base_t::joint_id_t*>(ptr+m_parentJointIDs.offset)[jointID];
 		}
-		inline Base::joint_id_t& getParentJointID(Base::joint_id_t jointID)
+		inline base_t::joint_id_t& getParentJointID(base_t::joint_id_t jointID)
 		{
-			return const_cast<Base::joint_id_t&>(const_cast<const ICPUSkeleton*>(this)->getParentJointID(jointID));
+			return const_cast<base_t::joint_id_t&>(const_cast<const ICPUSkeleton*>(this)->getParentJointID(jointID));
 		}
 
 		//! Serializes mesh to blob for *.baw file format.
@@ -55,31 +59,65 @@ class ICPUSkeleton : public ISkeleton<ICPUBuffer>, /*TODO: public BlobSerializab
 		}
 		*/
 
+		core::smart_refctd_ptr<IAsset> clone(uint32_t _depth = ~0u) const override
+		{
+			SBufferBinding<ICPUBuffer> _parentJointIDsBinding = {m_parentJointIDs.offset,_depth>0u&&m_parentJointIDs.buffer ? core::smart_refctd_ptr_static_cast<ICPUBuffer>(m_parentJointIDs.buffer->clone(_depth-1u)):m_parentJointIDs.buffer};
+			SBufferBinding<ICPUBuffer> _inverseBindPosesBinding = {m_inverseBindPoses.offset,_depth>0u&&m_inverseBindPoses.buffer ? core::smart_refctd_ptr_static_cast<ICPUBuffer>(m_inverseBindPoses.buffer->clone(_depth-1u)):m_inverseBindPoses.buffer};
+
+ 			auto cp = core::make_smart_refctd_ptr<ICPUSkeleton>(std::move(_parentJointIDsBinding),std::move(_inverseBindPosesBinding),m_jointCount);
+			clone_common(cp.get());
+			assert(!cp->m_stringPool);
+			cp->m_stringPoolSize = m_stringPoolSize;
+			cp->m_stringPool = _NBL_NEW_ARRAY(char,m_stringPoolSize);
+			memcpy(cp->m_stringPool,m_stringPool,m_stringPoolSize);
+			for (auto stringToID : m_nameToJointID)
+				cp->m_nameToJointID.emplace(stringToID.first-m_stringPool+cp->m_stringPool,stringToID.second);
+
+			return cp;
+		}
+
 		virtual void convertToDummyObject(uint32_t referenceLevelsBelowToConvert=0u) override
 		{
             convertToDummyObject_common(referenceLevelsBelowToConvert);
 
 			if (referenceLevelsBelowToConvert)
-			for (auto i=0u; i<getMeshBufferCount(); i++)
-				getMeshBuffer(i)->convertToDummyObject(referenceLevelsBelowToConvert-1u);
+			{
+				m_parentJointIDs.buffer->convertToDummyObject(referenceLevelsBelowToConvert-1u);
+				m_inverseBindPoses.buffer->convertToDummyObject(referenceLevelsBelowToConvert-1u);
+				// TODO: do we clear out the string pool and the name to bone ID mapping?
+			}
 		}
 
 		_NBL_STATIC_INLINE_CONSTEXPR auto AssetType = ET_SKELETON;
 		inline E_TYPE getAssetType() const override { return AssetType; }
-/* TODO
+
 		virtual size_t conservativeSizeEstimate() const override
 		{
-			size_t estimate = m_nameToJointID.size()*sizeof(std::pair<const char*,joint_id_t>);
+			size_t estimate = sizeof(SBufferBinding<ICPUBuffer>)*2ull;
+			estimate += sizeof(uint16_t);
+			estimate += m_stringPoolSize;
+			estimate += m_nameToJointID.size()*sizeof(std::pair<uint32_t,joint_id_t>);
 			// do we add other things to the size estimate?
 			return estimate;
 		}
-*/
+
 		bool canBeRestoredFrom(const IAsset* _other) const override
 		{
 			auto other = static_cast<const ICPUSkeleton*>(_other);
-			if (getJointCount()!=other->getJointCount())
-				return false;
-			if (!getMeshBuffer(i)->canBeRestoredFrom(other->getMeshBuffer(i)))
+			// if we decide to get rid of the string pool when converting to dummy, then we need to start checking stringpool and map properties here
+            if (m_parentJointIDs.offset != other->m_parentJointIDs.offset)
+                return false;
+            if ((!m_parentJointIDs.buffer) != (!other->m_parentJointIDs.buffer))
+                return false;
+            if (m_parentJointIDs.buffer && !m_parentJointIDs.buffer->canBeRestoredFrom(other->m_parentJointIDs.buffer.get()))
+                return false;
+            if (m_inverseBindPoses.offset != other->m_inverseBindPoses.offset)
+                return false;
+            if ((!m_inverseBindPoses.buffer) != (!other->m_inverseBindPoses.buffer))
+                return false;
+            if (m_inverseBindPoses.buffer && !m_inverseBindPoses.buffer->canBeRestoredFrom(other->m_inverseBindPoses.buffer.get()))
+                return false;
+			if (m_jointCount != other->m_jointCount)
 				return false;
 
 			return true;
@@ -93,15 +131,21 @@ class ICPUSkeleton : public ISkeleton<ICPUBuffer>, /*TODO: public BlobSerializab
 			if (_levelsBelow)
 			{
 				--_levelsBelow;
-				//for (uint32_t i = 0u; i < getMeshBufferCount(); i++)
-					//restoreFromDummy_impl_call(getMeshBuffer(i), other->getMeshBuffer(i), _levelsBelow);
+				
+                if (m_parentJointIDs.buffer)
+                    restoreFromDummy_impl_call(m_parentJointIDs.buffer.get(),other->m_parentJointIDs.buffer.get(),_levelsBelow);
+                if (m_inverseBindPoses.buffer)
+                    restoreFromDummy_impl_call(m_inverseBindPoses.buffer.get(),other->m_inverseBindPoses.buffer.get(),_levelsBelow);
 			}
 		}
 
 		bool isAnyDependencyDummy_impl(uint32_t _levelsBelow) const override
 		{
-			// TODO
-			return false;
+			--_levelsBelow;
+			if (m_parentJointIDs.buffer && m_parentJointIDs.buffer->isAnyDependencyDummy(_levelsBelow))
+					return true;
+
+			return m_inverseBindPoses.buffer && m_inverseBindPoses.buffer->isAnyDependencyDummy(_levelsBelow);
 		}
 };
 
diff --git a/include/nbl/asset/ISkeleton.h b/include/nbl/asset/ISkeleton.h
@@ -22,10 +22,14 @@ namespace asset
 	class ISkeleton : public virtual core::IReferenceCounted
 	{
 		public:
-			using joint_id_t = uint32_t;
+			using joint_id_t = uint16_t;
 			_NBL_STATIC_INLINE_CONSTEXPR joint_id_t invalid_joint_id = 0xffffu;
 
 
+			inline const auto& getJointNameToIDMap() const
+			{
+				return m_nameToJointID;
+			}
 			inline joint_id_t getJointIDFromName(const char* jointName) const
 			{
 				auto found = m_nameToJointID.find(jointName);
@@ -34,9 +38,9 @@ namespace asset
 				return invalid_joint_id;
 			}
 
-			inline uint32_t getJointCount() const
+			inline joint_id_t getJointCount() const
 			{
-				return jointCount;
+				return m_jointCount;
 			}
 
 			inline SBufferBinding<BufferType>& getParentJointIDBinding()
@@ -59,10 +63,15 @@ namespace asset
 
 
 		protected:
-			ISkeleton(SBufferBinding<BufferType>&& _parentJointIDsBinding, SBufferBinding<BufferType>&& _inverseBindPosesBinding)
-				:	m_nameToJointID(), m_stringPoolSize(0ull), m_stringPool(nullptr), m_jointCount(0u),
+			ISkeleton(SBufferBinding<BufferType>&& _parentJointIDsBinding, SBufferBinding<BufferType>&& _inverseBindPosesBinding, joint_id_t _jointCount = 0u)
+				:	m_nameToJointID(), m_stringPoolSize(0ull), m_stringPool(nullptr), m_jointCount(_jointCount),
 					m_parentJointIDs(std::move(_parentJointIDsBinding)), m_inverseBindPoses(std::move(_inverseBindPosesBinding))
 			{
+				if (m_jointCount==0u)
+					return;
+
+				assert(m_parentJointIDs.buffer->getSize()>=m_parentJointIDs.offset+sizeof(joint_id_t)*m_jointCount);
+				assert(m_inverseBindPoses.buffer->getSize()>=m_inverseBindPoses.offset+sizeof(core::matrix3x4SIMD)*m_jointCount);
 			}
 			virtual ~ISkeleton()
 			{
@@ -121,9 +130,8 @@ namespace asset
 			size_t m_stringPoolSize;
 			char* m_stringPool;
 
-			uint32_t m_jointCount;
-
 			SBufferBinding<BufferType> m_parentJointIDs,m_inverseBindPoses;
+			joint_id_t m_jointCount;
 	};
 
 } // end namespace asset
diff --git a/include/nbl/asset/asset.h b/include/nbl/asset/asset.h
@@ -46,8 +46,12 @@
 #include "nbl/asset/utils/IBuiltinIncludeLoader.h"
 #include "nbl/asset/utils/IGLSLCompiler.h"
 #include "nbl/asset/utils/CShaderIntrospector.h"
+
 // pipelines
 
+// skinning
+#include "nbl/asset/ICPUSkeleton.h"
+
 // meshes
 #include "nbl/asset/ICPUMeshBuffer.h"
 #include "nbl/asset/ICPUMesh.h"
diff --git a/include/nbl/video/IGPUObjectFromAssetConverter.h b/include/nbl/video/IGPUObjectFromAssetConverter.h
@@ -6,6 +6,8 @@
 #ifndef __NBL_VIDEO_I_GPU_OBJECT_FROM_ASSET_CONVERTER_H_INCLUDED__
 #define __NBL_VIDEO_I_GPU_OBJECT_FROM_ASSET_CONVERTER_H_INCLUDED__
 
+#include <iterator>
+
 #include "nbl/core/core.h"
 #include "nbl/asset/asset.h"
 
@@ -83,6 +85,7 @@ class IGPUObjectFromAssetConverter
 		virtual ~IGPUObjectFromAssetConverter() = default;
 
 		inline virtual created_gpu_object_array<asset::ICPUBuffer>				            create(const asset::ICPUBuffer** const _begin, const asset::ICPUBuffer** const _end, const SParams& _params);
+		inline virtual created_gpu_object_array<asset::ICPUSkeleton>			            create(const asset::ICPUSkeleton** const _begin, const asset::ICPUSkeleton** const _end, const SParams& _params);
 		inline virtual created_gpu_object_array<asset::ICPUMeshBuffer>			            create(const asset::ICPUMeshBuffer** const _begin, const asset::ICPUMeshBuffer** const _end, const SParams& _params);
 		inline virtual created_gpu_object_array<asset::ICPUMesh>				            create(const asset::ICPUMesh** const _begin, const asset::ICPUMesh** const _end, const SParams& _params);
 		inline virtual created_gpu_object_array<asset::ICPUImage>				            create(const asset::ICPUImage** const _begin, const asset::ICPUImage** const _end, const SParams& _params);
@@ -327,6 +330,103 @@ auto IGPUObjectFromAssetConverter::create(const asset::ICPUBuffer** const _begin
 
     return res;
 }
+namespace impl
+{
+template<typename MapIterator>
+struct CustomBoneNameIterator
+{
+        inline CustomBoneNameIterator(const MapIterator& it) : m_it(it) {}
+        inline CustomBoneNameIterator(MapIterator&& it) : m_it(std::move(it)) {}
+
+        inline bool operator!=(const CustomBoneNameIterator<MapIterator>& other) const
+        {
+            return m_it!=other.m_it;
+        }
+
+        inline CustomBoneNameIterator<MapIterator>& operator++()
+        {
+            ++m_it;
+            return *this;
+        }
+        inline CustomBoneNameIterator<MapIterator> operator++(int)
+        {
+            return m_it++;
+        }
+
+        inline CustomBoneNameIterator<MapIterator> operator-(const CustomBoneNameIterator<MapIterator>& other) const
+        {
+            return m_it-other.m_it;
+        }
+
+        inline const auto& operator*() const
+        {
+            return m_it->first;
+        }
+        inline auto& operator*()
+        {
+            return m_it->first;
+        }
+
+        using iterator_category = typename std::iterator_traits<MapIterator>::iterator_category;
+        using difference_type = typename std::iterator_traits<MapIterator>::difference_type;
+        using value_type = const char*;
+        using reference = std::add_lvalue_reference_t<value_type>;
+        using pointer = std::add_pointer_t<value_type>;
+
+    private:
+        MapIterator m_it;
+};
+}
+auto IGPUObjectFromAssetConverter::create(const asset::ICPUSkeleton** _begin, const asset::ICPUSkeleton** _end, const SParams& _params) -> created_gpu_object_array<asset::ICPUSkeleton>
+{
+	const size_t assetCount = std::distance(_begin, _end);
+	auto res = core::make_refctd_dynamic_array<created_gpu_object_array<asset::ICPUSkeleton> >(assetCount);
+
+    core::vector<const asset::ICPUBuffer*> cpuBuffers;
+    cpuBuffers.reserve(assetCount*2u);
+
+    for (ptrdiff_t i=0u; i<assetCount; i++)
+    {
+        const asset::ICPUSkeleton* cpusk = _begin[i];
+        if (const asset::ICPUBuffer* buf = cpusk->getParentJointIDBinding().buffer.get())
+            cpuBuffers.push_back(buf);;
+        if (const asset::ICPUBuffer* buf = cpusk->getInverseBindPosesBinding().buffer.get())
+            cpuBuffers.push_back(buf);
+    }
+
+    using redirs_t = core::vector<size_t>;
+    redirs_t bufRedirs = eliminateDuplicatesAndGenRedirs(cpuBuffers);
+
+    auto gpuBuffers = getGPUObjectsFromAssets<asset::ICPUBuffer>(cpuBuffers.data(), cpuBuffers.data()+cpuBuffers.size(), _params);
+
+    size_t bufIter = 0ull;
+    for (ptrdiff_t i = 0u; i < assetCount; ++i)
+    {
+        const asset::ICPUSkeleton* cpusk = _begin[i];
+
+		asset::SBufferBinding<IGPUBuffer> parentJointIDBinding;
+        if (cpusk->getParentJointIDBinding().buffer)
+        {
+            parentJointIDBinding.offset = cpusk->getParentJointIDBinding().offset;
+            auto& gpubuf = (*gpuBuffers)[bufRedirs[bufIter++]];
+            parentJointIDBinding.offset += gpubuf->getOffset();
+            parentJointIDBinding.buffer = core::smart_refctd_ptr<IGPUBuffer>(gpubuf->getBuffer());
+        }
+		asset::SBufferBinding<IGPUBuffer> inverseBindPosesBinding;
+        if (cpusk->getInverseBindPosesBinding().buffer)
+        {
+            inverseBindPosesBinding.offset = cpusk->getInverseBindPosesBinding().offset;
+            auto& gpubuf = (*gpuBuffers)[bufRedirs[bufIter++]];
+            inverseBindPosesBinding.offset += gpubuf->getOffset();
+            inverseBindPosesBinding.buffer = core::smart_refctd_ptr<IGPUBuffer>(gpubuf->getBuffer());
+        }
+
+        const auto& nameMap = cpusk->getJointNameToIDMap();
+        (*res)[i] = core::make_smart_refctd_ptr<IGPUSkeleton>(std::move(parentJointIDBinding),std::move(inverseBindPosesBinding),impl::CustomBoneNameIterator(nameMap.begin()),impl::CustomBoneNameIterator(nameMap.end()));
+    }
+
+    return res;
+}
 auto IGPUObjectFromAssetConverter::create(const asset::ICPUMeshBuffer** _begin, const asset::ICPUMeshBuffer** _end, const SParams& _params) -> created_gpu_object_array<asset::ICPUMeshBuffer>
 {
 	const size_t assetCount = std::distance(_begin, _end);
diff --git a/include/nbl/video/IGPUSkeleton.h b/include/nbl/video/IGPUSkeleton.h
diff --git a/include/nbl/video/asset_traits.h b/include/nbl/video/asset_traits.h
