Commit d1120ace145bb3a2b0006659c128a4162df15985 - DiligentTools

GLTFLoader: added option to not load animation data and skin assiduous 2 years ago

3 changed file(s) with 72 addition(s) and 56 deletion(s). Raw diff Collapse all Expand all

+13

-8

AssetLoader/interface/GLTFLoader.hpp less more

283	283
284	284	struct Model
285	285	{
286		struct VertexAttribs0
	286	struct VertexBasicAttribs
287	287	{
288	288	float3 pos;
289	289	float3 normal;

291	291	float2 uv1;
292	292	};
293	293
294		struct VertexAttribs1
	294	struct VertexSkinAttribs
295	295	{
296	296	float4 joint0;
297	297	float4 weight0;

299	299
300	300	enum BUFFER_ID
301	301	{
302		BUFFER_ID_VERTEX0 = 0,
303		BUFFER_ID_VERTEX1,
	302	BUFFER_ID_VERTEX_BASIC_ATTRIBS = 0,
	303	BUFFER_ID_VERTEX_SKIN_ATTRIBS,
304	304	BUFFER_ID_INDEX,
305	305	BUFFER_ID_NUM_BUFFERS
306	306	};

347	347
348	348	/// Optional resource cache usage info.
349	349	ResourceCacheUseInfo* pCacheInfo = nullptr;
	350
	351	/// Whether to load animation and initialize skin attributes
	352	/// buffer.
	353	bool LoadAnimationAndSkin = true;
350	354	};
351	355	Model(IRenderDevice* pDevice,
352	356	IDeviceContext* pContext,

382	386
383	387	Uint32 GetBaseVertex() const
384	388	{
385		auto& VertBuff = Buffers[BUFFER_ID_VERTEX0];
386		VERIFY(!VertBuff.pSuballocation \|\| VertBuff.pSuballocation->GetOffset() % sizeof(VertexAttribs0) == 0,
	389	auto& VertBuff = Buffers[BUFFER_ID_VERTEX_BASIC_ATTRIBS];
	390	VERIFY(!VertBuff.pSuballocation \|\| VertBuff.pSuballocation->GetOffset() % sizeof(VertexBasicAttribs) == 0,
387	391	"Allocation offset is not multiple of sizeof(VertexAttribs0)");
388	392	return VertBuff.pSuballocation ?
389		static_cast<Uint32>(VertBuff.pSuballocation->GetOffset() / sizeof(VertexAttribs0)) :
	393	static_cast<Uint32>(VertBuff.pSuballocation->GetOffset() / sizeof(VertexBasicAttribs)) :
390	394	0;
391	395	}
392	396

399	403	Node* parent,
400	404	const tinygltf::Node& gltf_node,
401	405	uint32_t nodeIndex,
402		const tinygltf::Model& gltf_model);
	406	const tinygltf::Model& gltf_model,
	407	bool LoadSkin);
403	408
404	409	void LoadSkins(const tinygltf::Model& gltf_model);
405	410

-3

AssetLoader/interface/GLTFResourceManager.hpp less more

81	81
82	82	RefCntAutoPtr<ITextureAtlasSuballocation> FindAllocation(const char* CacheId);
83	83
84		Uint32 GetResourceVersion()
	84	Uint32 GetTextureVersion()
85	85	{
86	86	Uint32 Version = 0;
87	87

90	90	Version += atlas_it.second->GetVersion();
91	91
92	92	return Version;
	93	}
	94
	95	Uint32 GetBufferVersion(Uint32 Index) const
	96	{
	97	return m_BufferSuballocators[Index]->GetVersion();
93	98	}
94	99
95	100	IBuffer* GetBuffer(Uint32 Index, IRenderDevice* pDevice, IDeviceContext* pContext)

130	135	using TexAllocationsHashMapType = std::unordered_map<std::string, RefCntWeakPtr<ITextureAtlasSuballocation>>;
131	136	std::mutex m_TexAllocationsMtx;
132	137	TexAllocationsHashMapType m_TexAllocations;
133
134		std::atomic_uint32_t m_ResourceVersion = {};
135	138	};
136	139
137	140	} // namespace GLTF

+53

-45

AssetLoader/src/GLTFLoader.cpp less more

76	76	{
77	77	std::vector<TextureInitData> Textures;
78	78
79		std::vector<Uint32> IndexData;
80		std::vector<VertexAttribs0> VertexData0;
81		std::vector<VertexAttribs1> VertexData1;
	79	std::vector<Uint32> IndexData;
	80	std::vector<VertexBasicAttribs> VertexBasicData;
	81	std::vector<VertexSkinAttribs> VertexSkinData;
82	82	};
83	83
84	84

264	264	Node* parent,
265	265	const tinygltf::Node& gltf_node,
266	266	uint32_t nodeIndex,
267		const tinygltf::Model& gltf_model)
	267	const tinygltf::Model& gltf_model,
	268	bool LoadSkin)
268	269	{
269	270	std::unique_ptr<Node> NewNode(new Node{});
270	271	NewNode->Index = nodeIndex;

304	305	{
305	306	for (size_t i = 0; i < gltf_node.children.size(); i++)
306	307	{
307		LoadNode(pDevice, NewNode.get(), gltf_model.nodes[gltf_node.children[i]], gltf_node.children[i], gltf_model);
	308	LoadNode(pDevice, NewNode.get(), gltf_model.nodes[gltf_node.children[i]], gltf_node.children[i], gltf_model, LoadSkin);
308	309	}
309	310	}
310	311

318	319	const tinygltf::Primitive& primitive = gltf_mesh.primitives[j];
319	320
320	321	uint32_t indexStart = static_cast<uint32_t>(InitData->IndexData.size());
321		uint32_t vertexStart = static_cast<uint32_t>(InitData->VertexData0.size());
322		VERIFY_EXPR(InitData->VertexData1.empty() \|\| InitData->VertexData0.size() == InitData->VertexData1.size());
	322	uint32_t vertexStart = static_cast<uint32_t>(InitData->VertexBasicData.size());
	323	VERIFY_EXPR(InitData->VertexSkinData.empty() \|\| InitData->VertexBasicData.size() == InitData->VertexSkinData.size());
323	324
324	325	uint32_t indexCount = 0;
325	326	uint32_t vertexCount = 0;

453	454
454	455	for (uint32_t v = 0; v < vertexCount; v++)
455	456	{
456		VertexAttribs0 vert0{};
457		vert0.pos = float4(float3::MakeVector(bufferPos + v * posStride), 1.0f);
	457	VertexBasicAttribs BasicAttribs{};
	458	BasicAttribs.pos = float4(float3::MakeVector(bufferPos + v * posStride), 1.0f);
458	459	// clang-format off
459		vert0.normal = bufferNormals != nullptr ? normalize(float3::MakeVector(bufferNormals + v * normalsStride)) : float3{};
460		vert0.uv0 = bufferTexCoordSet0 != nullptr ? float2::MakeVector(bufferTexCoordSet0 + v * texCoordSet0Stride) : float2{};
461		vert0.uv1 = bufferTexCoordSet1 != nullptr ? float2::MakeVector(bufferTexCoordSet1 + v * texCoordSet1Stride) : float2{};
	460	BasicAttribs.normal = bufferNormals != nullptr ? normalize(float3::MakeVector(bufferNormals + v * normalsStride)) : float3{};
	461	BasicAttribs.uv0 = bufferTexCoordSet0 != nullptr ? float2::MakeVector(bufferTexCoordSet0 + v * texCoordSet0Stride) : float2{};
	462	BasicAttribs.uv1 = bufferTexCoordSet1 != nullptr ? float2::MakeVector(bufferTexCoordSet1 + v * texCoordSet1Stride) : float2{};
462	463	// clang-format on
463		InitData->VertexData0.push_back(vert0);
464
465		VertexAttribs1 vert1{};
466		if (hasSkin)
	464	InitData->VertexBasicData.push_back(BasicAttribs);
	465
	466	if (LoadSkin)
467	467	{
468		vert1.joint0 = bufferJoints8 != nullptr ?
469		float4::MakeVector(bufferJoints8 + v * jointsStride) :
470		float4::MakeVector(bufferJoints16 + v * jointsStride);
471		vert1.weight0 = float4::MakeVector(bufferWeights + v * weightsStride);
	468	VertexSkinAttribs SkinAttribs{};
	469	if (hasSkin)
	470	{
	471	SkinAttribs.joint0 = bufferJoints8 != nullptr ?
	472	float4::MakeVector(bufferJoints8 + v * jointsStride) :
	473	float4::MakeVector(bufferJoints16 + v * jointsStride);
	474	SkinAttribs.weight0 = float4::MakeVector(bufferWeights + v * weightsStride);
	475	}
	476	InitData->VertexSkinData.push_back(SkinAttribs);
472	477	}
473		InitData->VertexData1.push_back(vert1);
474	478	}
475	479	}
476	480

945	949	}
946	950	};
947	951
948		if (!InitData->VertexData0.empty())
949		{
950		const auto& VertexData = InitData->VertexData0;
951		UpdateBuffer(BUFFER_ID_VERTEX0, VertexData.data(), VertexData.size() * sizeof(VertexData[0]));
952		}
953		if (!InitData->VertexData1.empty())
954		{
955		const auto& VertexData = InitData->VertexData1;
956		UpdateBuffer(BUFFER_ID_VERTEX1, VertexData.data(), VertexData.size() * sizeof(VertexData[0]));
	952	if (!InitData->VertexBasicData.empty())
	953	{
	954	const auto& VertexData = InitData->VertexBasicData;
	955	UpdateBuffer(BUFFER_ID_VERTEX_BASIC_ATTRIBS, VertexData.data(), VertexData.size() * sizeof(VertexData[0]));
	956	}
	957	if (!InitData->VertexSkinData.empty())
	958	{
	959	const auto& VertexData = InitData->VertexSkinData;
	960	UpdateBuffer(BUFFER_ID_VERTEX_SKIN_ATTRIBS, VertexData.data(), VertexData.size() * sizeof(VertexData[0]));
957	961	}
958	962	if (!InitData->IndexData.empty())
959	963	{

1667	1671	for (size_t i = 0; i < scene.nodes.size(); i++)
1668	1672	{
1669	1673	const tinygltf::Node node = gltf_model.nodes[scene.nodes[i]];
1670		LoadNode(pDevice, nullptr, node, scene.nodes[i], gltf_model);
1671		}
1672
1673		if (gltf_model.animations.size() > 0)
1674		{
1675		LoadAnimations(gltf_model);
1676		}
1677		LoadSkins(gltf_model);
	1674	LoadNode(pDevice, nullptr, node, scene.nodes[i], gltf_model, CI.LoadAnimationAndSkin);
	1675	}
	1676
	1677	if (CI.LoadAnimationAndSkin)
	1678	{
	1679	if (gltf_model.animations.size() > 0)
	1680	{
	1681	LoadAnimations(gltf_model);
	1682	}
	1683	LoadSkins(gltf_model);
	1684	}
1678	1685
1679	1686	for (auto* node : LinearNodes)
1680	1687	{

1696	1703	Extensions = gltf_model.extensionsUsed;
1697	1704
1698	1705	{
1699		auto& VertexData0 = InitData->VertexData0;
	1706	auto& VertexData0 = InitData->VertexBasicData;
1700	1707	auto BufferSize = static_cast<Uint32>(VertexData0.size() * sizeof(VertexData0[0]));
1701	1708	if (pResourceMgr != nullptr)
1702	1709	{
1703		Buffers[BUFFER_ID_VERTEX0].pSuballocation = pResourceMgr->AllocateBufferSpace(CI.pCacheInfo->VertexBuffer0Idx, BufferSize, 1);
	1710	Buffers[BUFFER_ID_VERTEX_BASIC_ATTRIBS].pSuballocation = pResourceMgr->AllocateBufferSpace(CI.pCacheInfo->VertexBuffer0Idx, BufferSize, 1);
1704	1711	}
1705	1712	else
1706	1713	{

1713	1720	VBDesc.Usage = USAGE_IMMUTABLE;
1714	1721
1715	1722	BufferData BuffData(VertexData0.data(), VBDesc.uiSizeInBytes);
1716		pDevice->CreateBuffer(VBDesc, &BuffData, &Buffers[BUFFER_ID_VERTEX0].pBuffer);
	1723	pDevice->CreateBuffer(VBDesc, &BuffData, &Buffers[BUFFER_ID_VERTEX_BASIC_ATTRIBS].pBuffer);
1717	1724
1718	1725	VertexData0.clear();
1719	1726	}
1720	1727	}
1721	1728
1722		{
1723		auto& VertexData1 = InitData->VertexData1;
	1729	if (CI.LoadAnimationAndSkin)
	1730	{
	1731	auto& VertexData1 = InitData->VertexSkinData;
1724	1732	auto BufferSize = static_cast<Uint32>(VertexData1.size() * sizeof(VertexData1[0]));
1725	1733	if (pResourceMgr != nullptr)
1726	1734	{
1727		Buffers[BUFFER_ID_VERTEX1].pSuballocation = pResourceMgr->AllocateBufferSpace(CI.pCacheInfo->VertexBuffer1Idx, BufferSize, 1);
	1735	Buffers[BUFFER_ID_VERTEX_SKIN_ATTRIBS].pSuballocation = pResourceMgr->AllocateBufferSpace(CI.pCacheInfo->VertexBuffer1Idx, BufferSize, 1);
1728	1736	}
1729	1737	else
1730	1738	{

1736	1744	VBDesc.Usage = USAGE_IMMUTABLE;
1737	1745
1738	1746	BufferData BuffData(VertexData1.data(), VBDesc.uiSizeInBytes);
1739		pDevice->CreateBuffer(VBDesc, &BuffData, &Buffers[BUFFER_ID_VERTEX1].pBuffer);
	1747	pDevice->CreateBuffer(VBDesc, &BuffData, &Buffers[BUFFER_ID_VERTEX_SKIN_ATTRIBS].pBuffer);
1740	1748
1741	1749	VertexData1.clear();
1742	1750	}