glTF-DXViewer/ModelViewer/ModelFactory.cpp at master · Schoxian/glTF-DXViewer · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
#include "pch.h"
#include "ModelFactory.h"
#include "EventShim.h"
#include "SceneManager.h"

using namespace std;

ModelFactory::ModelFactory()
{
}

void ModelFactory::CreateBuffer(GLTF_BufferData^ data)
{
	auto node = dynamic_cast<MeshNode *>(_currentNode);
	if (node)
	{
		node->CreateBuffer(data);
	}
}
void ModelFactory::CreateTexture(GLTF_TextureData^ data)
{
	auto node = dynamic_cast<MeshNode *>(_currentNode);
	if (node)
	{
		node->CreateTexture(data);
	}
}
void ModelFactory::CreateMaterial(GLTF_MaterialData^ data)
{
	auto node = dynamic_cast<MeshNode *>(_currentNode);
	if (node)
	{
		node->CreateMaterial(data);
	}
}
void ModelFactory::CreateTransform(GLTF_TransformData^ data)
{
	auto node = dynamic_cast<GraphContainerNode *>(_currentNode);
	if (node)
	{
		node->CreateTransform(data);
	}
}

GraphNode * ModelFactory::InitialiseMesh(GLTF_SceneNodeData^ data)
{
	auto mesh = new MeshNode(data->NodeIndex);
	_currentNode = mesh;

	auto devResources = SceneManager::Instance().DevResources();
	mesh->Initialise(devResources);

	return mesh;
}

void ModelFactory::CreateSceneNode(GLTF_SceneNodeData^ data)
{
	GraphNode *parent = nullptr;
	if (_root && data->ParentIndex != -1)
	{
		parent = _root->FindChildByIndex(data->ParentIndex);
	}

	if (data->IsMesh)
	{
		_currentNode = InitialiseMesh(data);
	}
	else
	{
		_currentNode = new GraphContainerNode(data->NodeIndex);
		auto devResources = SceneManager::Instance().DevResources();
		_currentNode->Initialise(devResources);
	}
	_currentNode->SetName(data->Name->Data());

	if (_root == nullptr)
	{
		_root = _currentNode;
	}
	else if (parent && _currentNode)
	{
		shared_ptr<GraphNode> sp;
		sp.reset(_currentNode);
		parent->AddChild(sp);
	}
}

future<shared_ptr<GraphNode>> ModelFactory::CreateFromFileAsync(StorageFile^ file)
{
	_parser = ref new GLTF_Parser();
	_root = _currentNode = nullptr;

	function<void(GLTF_SceneNodeData^)> snmmemfun = bind(&ModelFactory::CreateSceneNode, &(ModelFactory::Instance()), placeholders::_1);
	function<void(GLTF_BufferData^)> memfun = bind(&ModelFactory::CreateBuffer, &(ModelFactory::Instance()), placeholders::_1);
	function<void(GLTF_TextureData^)> tmemfun = bind(&ModelFactory::CreateTexture, &(ModelFactory::Instance()), placeholders::_1);
	function<void(GLTF_MaterialData^)> mmemfun = bind(&ModelFactory::CreateMaterial, &(ModelFactory::Instance()), placeholders::_1);
	function<void(GLTF_TransformData^)> tmmemfun = bind(&ModelFactory::CreateTransform, &(ModelFactory::Instance()), placeholders::_1);

	auto es = ref new EventShim(memfun, mmemfun, tmemfun, tmmemfun, snmmemfun);

	_parser->OnBufferEvent += ref new BufferEventHandler(es, &EventShim::OnBuffer);
	_parser->OnTextureEvent += ref new TextureEventHandler(es, &EventShim::OnTexture);
	_parser->OnMaterialEvent += ref new MaterialEventHandler(es, &EventShim::OnMaterial);
	_parser->OnTransformEvent += ref new TransformEventHandler(es, &EventShim::OnTransform);
	_parser->OnSceneNodeEvent += ref new SceneNodeEventHandler(es, &EventShim::OnSceneNode);

	co_await async([this, file]() { _parser->ParseFile(file); });

	_root->AfterLoad();

	// call afterLoad on all children...
	_root->ForAllChildrenRecursive([](GraphNode& node)
	{
		node.AfterLoad();
	});

	shared_ptr<GraphNode> sp;
	sp.reset(_root);
	co_return sp;
}