2 * Copyright (c) 2020 Samsung Electronics Co., Ltd.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
17 #include "dali-scene-loader/public-api/load-result.h"
18 #include "dali-scene-loader/public-api/scene-definition.h"
19 #include "dali-scene-loader/public-api/resource-bundle.h"
20 #include "dali-scene-loader/public-api/gltf2-loader.h"
21 #include "dali-scene-loader/public-api/utils.h"
22 #include "dali-scene-loader/public-api/shader-definition-factory.h"
23 #include "dali-scene-loader/internal/gltf2-asset.h"
24 #include "dali/public-api/math/quaternion.h"
27 #define ENUM_STRING_MAPPING(t, x) { #x, t::x }
38 const std::string POSITION_PROPERTY("position");
39 const std::string ORIENTATION_PROPERTY("orientation");
40 const std::string SCALE_PROPERTY("scale");
41 const std::string BLEND_SHAPE_WEIGHTS_UNIFORM("uBlendShapeWeight");
43 const Geometry::Type GLTF2_TO_DALI_PRIMITIVES[]{
49 Geometry::TRIANGLE_STRIP,
50 Geometry::TRIANGLE_FAN
51 }; //...because Dali swaps the last two.
53 struct AttributeMapping
55 gt::Attribute::Type mType;
56 MeshDefinition::Accessor MeshDefinition::* mAccessor;
57 uint16_t mElementSizeRequired;
58 } ATTRIBUTE_MAPPINGS[]{
59 { gt::Attribute::NORMAL, &MeshDefinition::mNormals, sizeof(Vector3) },
60 { gt::Attribute::TANGENT, &MeshDefinition::mTangents, sizeof(Vector3) },
61 { gt::Attribute::TEXCOORD_0, &MeshDefinition::mTexCoords, sizeof(Vector2) },
62 { gt::Attribute::JOINTS_0, &MeshDefinition::mJoints0, sizeof(Vector4) },
63 { gt::Attribute::WEIGHTS_0, &MeshDefinition::mWeights0, sizeof(Vector4) },
66 std::vector<gt::Animation> ReadAnimationArray(const json_value_s& j)
69 SetRefReaderObject(proxy);
71 auto results = js::Read::Array<gt::Animation, js::ObjectReader<gt::Animation>::Read>(j);
73 for (auto& animation : results)
75 for (auto& channel : animation.mChannels)
77 channel.mSampler.UpdateVector(animation.mSamplers);
84 void ApplyAccessorMinMax(const gt::Accessor& acc, float* values)
86 DALI_ASSERT_ALWAYS(acc.mMax.empty() || gt::AccessorType::ElementCount(acc.mType) == acc.mMax.size());
87 DALI_ASSERT_ALWAYS(acc.mMin.empty() || gt::AccessorType::ElementCount(acc.mType) == acc.mMin.size());
88 MeshDefinition::Blob::ApplyMinMax(acc.mMin, acc.mMax, acc.mCount, values);
91 const auto BUFFER_READER = std::move(js::Reader<gt::Buffer>()
92 .Register(*js::MakeProperty("byteLength", js::Read::Number<uint32_t>, >::Buffer::mByteLength))
93 .Register(*js::MakeProperty("uri", js::Read::StringView, >::Buffer::mUri))
96 const auto BUFFER_VIEW_READER = std::move(js::Reader<gt::BufferView>()
97 .Register(*js::MakeProperty("buffer", gt::RefReader<gt::Document>::Read<gt::Buffer, >::Document::mBuffers>, >::BufferView::mBuffer))
98 .Register(*js::MakeProperty("byteOffset", js::Read::Number<uint32_t>, >::BufferView::mByteOffset))
99 .Register(*js::MakeProperty("byteLength", js::Read::Number<uint32_t>, >::BufferView::mByteLength))
100 .Register(*js::MakeProperty("byteStride", js::Read::Number<uint32_t>, >::BufferView::mByteStride))
101 .Register(*js::MakeProperty("target", js::Read::Number<uint32_t>, >::BufferView::mTarget))
104 const auto BUFFER_VIEW_CLIENT_READER = std::move(js::Reader<gt::BufferViewClient>()
105 .Register(*js::MakeProperty("bufferView", gt::RefReader<gt::Document>::Read<gt::BufferView, >::Document::mBufferViews>, >::BufferViewClient::mBufferView))
106 .Register(*js::MakeProperty("byteOffset", js::Read::Number<uint32_t>, >::BufferViewClient::mByteOffset))
109 const auto COMPONENT_TYPED_BUFFER_VIEW_CLIENT_READER = std::move(js::Reader<gt::ComponentTypedBufferViewClient>()
110 .Register(*new js::Property<gt::ComponentTypedBufferViewClient, gt::Ref<gt::BufferView>>("bufferView", gt::RefReader<gt::Document>::Read<gt::BufferView, >::Document::mBufferViews>, >::ComponentTypedBufferViewClient::mBufferView))
111 .Register(*new js::Property<gt::ComponentTypedBufferViewClient, uint32_t>("byteOffset", js::Read::Number<uint32_t>, >::ComponentTypedBufferViewClient::mByteOffset))
112 .Register(*js::MakeProperty("componentType", js::Read::Enum<gt::Component::Type>, >::ComponentTypedBufferViewClient::mComponentType))
115 const auto ACCESSOR_SPARSE_READER = std::move(js::Reader<gt::Accessor::Sparse>()
116 .Register(*js::MakeProperty("count", js::Read::Number<uint32_t>, >::Accessor::Sparse::mCount))
117 .Register(*js::MakeProperty("indices", js::ObjectReader<gt::ComponentTypedBufferViewClient>::Read,
118 >::Accessor::Sparse::mIndices))
119 .Register(*js::MakeProperty("values", js::ObjectReader<gt::BufferViewClient>::Read,
120 >::Accessor::Sparse::mValues))
123 const auto ACCESSOR_READER = std::move(js::Reader<gt::Accessor>()
124 .Register(*new js::Property<gt::Accessor, gt::Ref<gt::BufferView>>("bufferView",
125 gt::RefReader<gt::Document>::Read<gt::BufferView, >::Document::mBufferViews>, >::Accessor::mBufferView))
126 .Register(*new js::Property<gt::Accessor, uint32_t>("byteOffset",
127 js::Read::Number<uint32_t>, >::Accessor::mByteOffset))
128 .Register(*new js::Property<gt::Accessor, gt::Component::Type>("componentType",
129 js::Read::Enum<gt::Component::Type>, >::Accessor::mComponentType))
130 .Register(*new js::Property<gt::Accessor, std::string_view>("name", js::Read::StringView, >::Accessor::mName))
131 .Register(*js::MakeProperty("count", js::Read::Number<uint32_t>, >::Accessor::mCount))
132 .Register(*js::MakeProperty("normalized", js::Read::Boolean, >::Accessor::mNormalized))
133 .Register(*js::MakeProperty("type", gt::ReadStringEnum<gt::AccessorType>, >::Accessor::mType))
134 .Register(*js::MakeProperty("min", js::Read::Array<float, js::Read::Number>, >::Accessor::mMin))
135 .Register(*js::MakeProperty("max", js::Read::Array<float, js::Read::Number>, >::Accessor::mMax))
136 .Register(*new js::Property<gt::Accessor, gt::Accessor::Sparse>("sparse", js::ObjectReader<gt::Accessor::Sparse>::Read,
137 >::Accessor::SetSparse))
140 const auto IMAGE_READER = std::move(js::Reader<gt::Image>()
141 .Register(*new js::Property<gt::Image, std::string_view>("name", js::Read::StringView, >::Material::mName))
142 .Register(*js::MakeProperty("uri", js::Read::StringView, >::Image::mUri))
143 .Register(*js::MakeProperty("mimeType", js::Read::StringView, >::Image::mMimeType))
144 .Register(*js::MakeProperty("bufferView", gt::RefReader<gt::Document>::Read<gt::BufferView, >::Document::mBufferViews>, >::Image::mBufferView))
147 const auto SAMPLER_READER = std::move(js::Reader<gt::Sampler>()
148 .Register(*js::MakeProperty("minFilter", js::Read::Enum<gt::Filter::Type>, >::Sampler::mMinFilter))
149 .Register(*js::MakeProperty("magFilter", js::Read::Enum<gt::Filter::Type>, >::Sampler::mMagFilter))
150 .Register(*js::MakeProperty("wrapS", js::Read::Enum<gt::Wrap::Type>, >::Sampler::mWrapS))
151 .Register(*js::MakeProperty("wrapT", js::Read::Enum<gt::Wrap::Type>, >::Sampler::mWrapT))
154 const auto TEXURE_READER = std::move(js::Reader<gt::Texture>()
155 .Register(*js::MakeProperty("source", gt::RefReader<gt::Document>::Read<gt::Image, >::Document::mImages>, >::Texture::mSource))
156 .Register(*js::MakeProperty("sampler", gt::RefReader<gt::Document>::Read<gt::Sampler, >::Document::mSamplers>, >::Texture::mSampler))
159 const auto TEXURE_INFO_READER = std::move(js::Reader<gt::TextureInfo>()
160 .Register(*js::MakeProperty("index", gt::RefReader<gt::Document>::Read<gt::Texture, >::Document::mTextures>, >::TextureInfo::mTexture))
161 .Register(*js::MakeProperty("texCoord", js::Read::Number<uint32_t>, >::TextureInfo::mTexCoord))
162 .Register(*js::MakeProperty("scale", js::Read::Number<float>, >::TextureInfo::mScale))
165 const auto MATERIAL_PBR_READER = std::move(js::Reader<gt::Material::Pbr>()
166 .Register(*js::MakeProperty("baseColorFactor", gt::ReadDaliVector<Vector4>, >::Material::Pbr::mBaseColorFactor))
167 .Register(*js::MakeProperty("baseColorTexture", js::ObjectReader<gt::TextureInfo>::Read,
168 >::Material::Pbr::mBaseColorTexture))
169 .Register(*js::MakeProperty("metallicFactor", js::Read::Number<float>, >::Material::Pbr::mMetallicFactor))
170 .Register(*js::MakeProperty("roughnessFactor", js::Read::Number<float>, >::Material::Pbr::mRoughnessFactor))
171 .Register(*js::MakeProperty("metallicRoughnessTexture", js::ObjectReader<gt::TextureInfo>::Read,
172 >::Material::Pbr::mMetallicRoughnessTexture))
175 const auto MATERIAL_READER = std::move(js::Reader<gt::Material>()
176 .Register(*new js::Property<gt::Material, std::string_view>("name", js::Read::StringView, >::Material::mName))
177 .Register(*js::MakeProperty("pbrMetallicRoughness", js::ObjectReader<gt::Material::Pbr>::Read, >::Material::mPbrMetallicRoughness))
178 .Register(*js::MakeProperty("normalTexture", js::ObjectReader<gt::TextureInfo>::Read, >::Material::mNormalTexture))
179 .Register(*js::MakeProperty("occlusionTexture", js::ObjectReader<gt::TextureInfo>::Read, >::Material::mOcclusionTexture))
180 .Register(*js::MakeProperty("emissiveTexture", js::ObjectReader<gt::TextureInfo>::Read, >::Material::mEmissiveTexture))
181 .Register(*js::MakeProperty("emissiveFactor", gt::ReadDaliVector<Vector3>, >::Material::mEmissiveFactor))
182 .Register(*js::MakeProperty("alphaMode", gt::ReadStringEnum<gt::AlphaMode>, >::Material::mAlphaMode))
183 .Register(*js::MakeProperty("alphaCutoff", js::Read::Number<float>, >::Material::mAlphaCutoff))
186 std::map<gt::Attribute::Type, gt::Ref<gt::Accessor>> ReadMeshPrimitiveAttributes(const json_value_s& j)
188 auto& jo = js::Cast<json_object_s>(j);
189 std::map<gt::Attribute::Type, gt::Ref<gt::Accessor>> result;
194 auto jstr = *i->name;
195 result[gt::Attribute::FromString(jstr.string, jstr.string_size)] = gt::RefReader<gt::Document>::Read<gt::Accessor, >::Document::mAccessors>(*i->value);
201 std::vector<std::map<gt::Attribute::Type, gt::Ref<gt::Accessor>>> ReadMeshPrimitiveTargets(const json_value_s& j)
203 auto& jo = js::Cast<json_array_s>(j);
204 std::vector<std::map<gt::Attribute::Type, gt::Ref<gt::Accessor>>> result;
206 result.reserve(jo.length);
211 result.push_back(std::move(ReadMeshPrimitiveAttributes(*i->value)));
218 const auto MESH_PRIMITIVE_READER = std::move(js::Reader<gt::Mesh::Primitive>()
219 .Register(*js::MakeProperty("attributes", ReadMeshPrimitiveAttributes, >::Mesh::Primitive::mAttributes))
220 .Register(*js::MakeProperty("indices", gt::RefReader<gt::Document>::Read<gt::Accessor, >::Document::mAccessors>, >::Mesh::Primitive::mIndices))
221 .Register(*js::MakeProperty("material", gt::RefReader<gt::Document>::Read<gt::Material, >::Document::mMaterials>, >::Mesh::Primitive::mMaterial))
222 .Register(*js::MakeProperty("mode", js::Read::Enum<gt::Mesh::Primitive::Mode>, >::Mesh::Primitive::mMode))
223 .Register(*js::MakeProperty("targets", ReadMeshPrimitiveTargets, >::Mesh::Primitive::mTargets))
226 const auto MESH_READER = std::move(js::Reader<gt::Mesh>()
227 .Register(*new js::Property<gt::Mesh, std::string_view>("name", js::Read::StringView, >::Mesh::mName))
228 .Register(*js::MakeProperty("primitives",
229 js::Read::Array<gt::Mesh::Primitive, js::ObjectReader<gt::Mesh::Primitive>::Read>, >::Mesh::mPrimitives))
230 .Register(*js::MakeProperty("weights", js::Read::Array<float, js::Read::Number>, >::Mesh::mWeights))
233 const auto SKIN_READER = std::move(js::Reader<gt::Skin>()
234 .Register(*new js::Property<gt::Skin, std::string_view>("name", js::Read::StringView, >::Skin::mName))
235 .Register(*js::MakeProperty("inverseBindMatrices",
236 gt::RefReader<gt::Document>::Read<gt::Accessor, >::Document::mAccessors>, >::Skin::mInverseBindMatrices))
237 .Register(*js::MakeProperty("skeleton",
238 gt::RefReader<gt::Document>::Read<gt::Node, >::Document::mNodes>, >::Skin::mSkeleton))
239 .Register(*js::MakeProperty("joints",
240 js::Read::Array<gt::Ref<gt::Node>, gt::RefReader<gt::Document>::Read<gt::Node, >::Document::mNodes>>, >::Skin::mJoints))
243 const auto CAMERA_PERSPECTIVE_READER = std::move(js::Reader<gt::Camera::Perspective>()
244 .Register(*js::MakeProperty("aspectRatio", js::Read::Number<float>, >::Camera::Perspective::mAspectRatio))
245 .Register(*js::MakeProperty("yfov", js::Read::Number<float>, >::Camera::Perspective::mYFov))
246 .Register(*js::MakeProperty("zfar", js::Read::Number<float>, >::Camera::Perspective::mZFar))
247 .Register(*js::MakeProperty("znear", js::Read::Number<float>, >::Camera::Perspective::mZNear))
248 ); // TODO: infinite perspective projection, where znear is omitted
250 const auto CAMERA_ORTHOGRAPHIC_READER = std::move(js::Reader<gt::Camera::Orthographic>()
251 .Register(*js::MakeProperty("xmag", js::Read::Number<float>, >::Camera::Orthographic::mXMag))
252 .Register(*js::MakeProperty("ymag", js::Read::Number<float>, >::Camera::Orthographic::mXMag))
253 .Register(*js::MakeProperty("zfar", js::Read::Number<float>, >::Camera::Orthographic::mZFar))
254 .Register(*js::MakeProperty("znear", js::Read::Number<float>, >::Camera::Orthographic::mZNear))
257 const auto CAMERA_READER = std::move(js::Reader<gt::Camera>()
258 .Register(*new js::Property<gt::Camera, std::string_view>("name", js::Read::StringView, >::Camera::mName))
259 .Register(*js::MakeProperty("type", js::Read::StringView, >::Camera::mType))
260 .Register(*js::MakeProperty("perspective", js::ObjectReader<gt::Camera::Perspective>::Read, >::Camera::mPerspective))
261 .Register(*js::MakeProperty("orthographic", js::ObjectReader<gt::Camera::Orthographic>::Read, >::Camera::mOrthographic))
264 const auto NODE_READER = std::move(js::Reader<gt::Node>()
265 .Register(*new js::Property<gt::Node, std::string_view>("name", js::Read::StringView, >::Node::mName))
266 .Register(*js::MakeProperty("translation", gt::ReadDaliVector<Vector3>, >::Node::mTranslation))
267 .Register(*js::MakeProperty("rotation", gt::ReadQuaternion, >::Node::mRotation))
268 .Register(*js::MakeProperty("scale", gt::ReadDaliVector<Vector3>, >::Node::mScale))
269 .Register(*new js::Property<gt::Node, Matrix>("matrix", gt::ReadDaliVector<Matrix>, >::Node::SetMatrix))
270 .Register(*js::MakeProperty("camera", gt::RefReader<gt::Document>::Read<gt::Camera, >::Document::mCameras>,
272 .Register(*js::MakeProperty("children", js::Read::Array<gt::Ref<gt::Node>, gt::RefReader<gt::Document>::Read<gt::Node, >::Document::mNodes>>,
273 >::Node::mChildren))
274 .Register(*js::MakeProperty("mesh", gt::RefReader<gt::Document>::Read<gt::Mesh, >::Document::mMeshes>, >::Node::mMesh))
275 .Register(*js::MakeProperty("skin", gt::RefReader<gt::Document>::Read<gt::Skin, >::Document::mSkins>, >::Node::mSkin))
278 const auto ANIMATION_SAMPLER_READER = std::move(js::Reader<gt::Animation::Sampler>()
279 .Register(*js::MakeProperty("input", gt::RefReader<gt::Document>::Read<gt::Accessor, >::Document::mAccessors>,
280 >::Animation::Sampler::mInput))
281 .Register(*js::MakeProperty("output", gt::RefReader<gt::Document>::Read<gt::Accessor, >::Document::mAccessors>,
282 >::Animation::Sampler::mOutput))
283 .Register(*js::MakeProperty("interpolation", gt::ReadStringEnum<gt::Animation::Sampler::Interpolation>, >::Animation::Sampler::mInterpolation))
286 const auto ANIMATION_TARGET_READER = std::move(js::Reader<gt::Animation::Channel::Target>()
287 .Register(*js::MakeProperty("node", gt::RefReader<gt::Document>::Read<gt::Node, >::Document::mNodes>,
288 >::Animation::Channel::Target::mNode))
289 .Register(*js::MakeProperty("path", gt::ReadStringEnum<gt::Animation::Channel::Target>,
290 >::Animation::Channel::Target::mPath))
293 const auto ANIMATION_CHANNEL_READER = std::move(js::Reader<gt::Animation::Channel>()
294 .Register(*js::MakeProperty("target", js::ObjectReader<gt::Animation::Channel::Target>::Read, >::Animation::Channel::mTarget))
295 .Register(*js::MakeProperty("sampler", gt::RefReader<gt::Animation>::Read<gt::Animation::Sampler, >::Animation::mSamplers>, >::Animation::Channel::mSampler))
298 const auto ANIMATION_READER = std::move(js::Reader<gt::Animation>()
299 .Register(*new js::Property<gt::Animation, std::string_view>("name", js::Read::StringView, >::Animation::mName))
300 .Register(*js::MakeProperty("samplers",
301 js::Read::Array<gt::Animation::Sampler, js::ObjectReader<gt::Animation::Sampler>::Read>, >::Animation::mSamplers))
302 .Register(*js::MakeProperty("channels",
303 js::Read::Array<gt::Animation::Channel, js::ObjectReader<gt::Animation::Channel>::Read>, >::Animation::mChannels))
306 const auto SCENE_READER = std::move(js::Reader<gt::Scene>()
307 .Register(*new js::Property<gt::Scene, std::string_view>("name", js::Read::StringView, >::Scene::mName))
308 .Register(*js::MakeProperty("nodes",
309 js::Read::Array<gt::Ref<gt::Node>, gt::RefReader<gt::Document>::Read<gt::Node, >::Document::mNodes>>, >::Scene::mNodes))
312 const auto DOCUMENT_READER = std::move(js::Reader<gt::Document>()
313 .Register(*js::MakeProperty("buffers",
314 js::Read::Array<gt::Buffer, js::ObjectReader<gt::Buffer>::Read>, >::Document::mBuffers))
315 .Register(*js::MakeProperty("bufferViews",
316 js::Read::Array<gt::BufferView, js::ObjectReader<gt::BufferView>::Read>, >::Document::mBufferViews))
317 .Register(*js::MakeProperty("accessors",
318 js::Read::Array<gt::Accessor, js::ObjectReader<gt::Accessor>::Read>, >::Document::mAccessors))
319 .Register(*js::MakeProperty("images",
320 js::Read::Array<gt::Image, js::ObjectReader<gt::Image>::Read>, >::Document::mImages))
321 .Register(*js::MakeProperty("samplers",
322 js::Read::Array<gt::Sampler, js::ObjectReader<gt::Sampler>::Read>, >::Document::mSamplers))
323 .Register(*js::MakeProperty("textures",
324 js::Read::Array<gt::Texture, js::ObjectReader<gt::Texture>::Read>, >::Document::mTextures))
325 .Register(*js::MakeProperty("materials",
326 js::Read::Array<gt::Material, js::ObjectReader<gt::Material>::Read>, >::Document::mMaterials))
327 .Register(*js::MakeProperty("meshes",
328 js::Read::Array<gt::Mesh, js::ObjectReader<gt::Mesh>::Read>, >::Document::mMeshes))
329 .Register(*js::MakeProperty("skins",
330 js::Read::Array<gt::Skin, js::ObjectReader<gt::Skin>::Read>, >::Document::mSkins))
331 .Register(*js::MakeProperty("cameras",
332 js::Read::Array<gt::Camera, js::ObjectReader<gt::Camera>::Read>, >::Document::mCameras))
333 .Register(*js::MakeProperty("nodes",
334 js::Read::Array<gt::Node, js::ObjectReader<gt::Node>::Read>, >::Document::mNodes))
335 .Register(*js::MakeProperty("animations",
336 ReadAnimationArray, >::Document::mAnimations))
337 .Register(*js::MakeProperty("scenes",
338 js::Read::Array<gt::Scene, js::ObjectReader<gt::Scene>::Read>, >::Document::mScenes))
339 .Register(*js::MakeProperty("scene", gt::RefReader<gt::Document>::Read<gt::Scene, >::Document::mScenes>, >::Document::mScene))
348 bool operator<(const NodeMapping& mapping, Index gltfIdx)
350 return mapping.gltfIdx < gltfIdx;
353 class NodeIndexMapper
356 NodeIndexMapper() = default;
357 NodeIndexMapper(const NodeIndexMapper&) = delete;
358 NodeIndexMapper& operator=(const NodeIndexMapper&) = delete;
360 ///@brief Registers a mapping of the @a gltfIdx of a node to its @a runtimeIdx .
361 ///@note If the indices are the same, the registration is omitted, in order to
362 /// save growing a vector.
363 void RegisterMapping(Index gltfIdx, Index runtimeIdx)
365 if (gltfIdx != runtimeIdx)
367 auto iInsert = std::lower_bound(mNodes.begin(), mNodes.end(), gltfIdx);
368 DALI_ASSERT_DEBUG(iInsert == mNodes.end() || iInsert->gltfIdx != gltfIdx);
369 mNodes.insert(iInsert, NodeMapping{ gltfIdx, runtimeIdx });
373 ///@brief Retrieves the runtime index of a Node, mapped to the given @a gltfIdx.
374 Index GetRuntimeId(Index gltfIdx) const
376 auto iFind = std::lower_bound(mNodes.begin(), mNodes.end(), gltfIdx); // using custom operator<
377 return (iFind != mNodes.end() && iFind->gltfIdx == gltfIdx) ? iFind->runtimeIdx : gltfIdx;
381 std::vector<NodeMapping> mNodes;
384 struct ConversionContext
389 Index mDefaultMaterial;
391 std::vector<Index> mMeshIds;
392 NodeIndexMapper mNodeIndices;
395 SamplerFlags::Type ConvertWrapMode(gt::Wrap::Type w)
399 case gt::Wrap::REPEAT:
400 return SamplerFlags::WRAP_REPEAT;
401 case gt::Wrap::CLAMP_TO_EDGE:
402 return SamplerFlags::WRAP_CLAMP;
403 case gt::Wrap::MIRRORED_REPEAT:
404 return SamplerFlags::WRAP_MIRROR;
406 throw std::runtime_error("Invalid wrap type.");
410 SamplerFlags::Type ConvertSampler(const gt::Ref<gt::Sampler>& s)
414 return (s->mMinFilter < gt::Filter::NEAREST_MIPMAP_NEAREST) ? (s->mMinFilter - gt::Filter::NEAREST) :
415 ((s->mMinFilter - gt::Filter::NEAREST_MIPMAP_NEAREST) + 2) |
416 ((s->mMagFilter - gt::Filter::NEAREST) << SamplerFlags::FILTER_MAG_SHIFT) |
417 (ConvertWrapMode(s->mWrapS) << SamplerFlags::WRAP_S_SHIFT) |
418 (ConvertWrapMode(s->mWrapT) << SamplerFlags::WRAP_T_SHIFT);
422 // https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#texturesampler
423 // "The index of the sampler used by this texture. When undefined, a sampler with repeat wrapping and auto filtering should be used."
424 // "What is an auto filtering", I hear you ask. Since there's nothing else to determine mipmapping from - including glTF image
425 // properties, if not in some extension -, we will simply assume linear filtering.
426 return SamplerFlags::FILTER_LINEAR | (SamplerFlags::FILTER_LINEAR << SamplerFlags::FILTER_MAG_SHIFT) |
427 (SamplerFlags::WRAP_REPEAT << SamplerFlags::WRAP_S_SHIFT) | (SamplerFlags::WRAP_REPEAT << SamplerFlags::WRAP_T_SHIFT);
431 TextureDefinition ConvertTextureInfo(const gt::TextureInfo& mm)
433 return TextureDefinition{ std::string(mm.mTexture->mSource->mUri), ConvertSampler(mm.mTexture->mSampler) };
436 void ConvertMaterial(const gt::Material& m, decltype(ResourceBundle::mMaterials)& outMaterials)
438 MaterialDefinition matDef;
440 auto& pbr = m.mPbrMetallicRoughness;
441 if (m.mAlphaMode != gt::AlphaMode::OPAQUE || pbr.mBaseColorFactor.a < 1.f)
443 matDef.mFlags |= MaterialDefinition::TRANSPARENCY;
446 if (m.mAlphaMode == gt::AlphaMode::MASK)
448 matDef.SetAlphaCutoff(std::min(1.f, std::max(0.f, m.mAlphaCutoff)));
451 matDef.mColor = pbr.mBaseColorFactor;
453 matDef.mTextureStages.reserve(!!pbr.mBaseColorTexture + !!pbr.mMetallicRoughnessTexture + !!m.mNormalTexture);
454 if (pbr.mBaseColorTexture)
456 const auto semantic = MaterialDefinition::ALBEDO;
457 matDef.mTextureStages.push_back({ semantic, ConvertTextureInfo(pbr.mBaseColorTexture) });
458 // TODO: and there had better be one
459 matDef.mFlags |= semantic;
462 matDef.mMetallic = pbr.mMetallicFactor;
463 matDef.mRoughness = pbr.mRoughnessFactor;
465 if (pbr.mMetallicRoughnessTexture)
467 const auto semantic = MaterialDefinition::METALLIC | MaterialDefinition::ROUGHNESS |
468 MaterialDefinition::GLTF_CHANNELS;
469 matDef.mTextureStages.push_back({ semantic, ConvertTextureInfo(pbr.mMetallicRoughnessTexture) });
470 // TODO: and there had better be one
471 matDef.mFlags |= semantic;
474 if (m.mNormalTexture)
476 const auto semantic = MaterialDefinition::NORMAL;
477 matDef.mTextureStages.push_back({ semantic, ConvertTextureInfo(m.mNormalTexture) });
478 // TODO: and there had better be one
479 matDef.mFlags |= semantic;
482 // TODO: handle doubleSided
484 outMaterials.emplace_back(std::move(matDef), TextureSet());
487 void ConvertMaterials(const gt::Document& doc, ConversionContext& cctx)
489 auto& outMaterials = cctx.mOutput.mResources.mMaterials;
490 outMaterials.reserve(doc.mMaterials.size());
492 for (auto& m : doc.mMaterials)
494 ConvertMaterial(m, outMaterials);
498 MeshDefinition::Accessor ConvertMeshPrimitiveAccessor(const gt::Accessor& acc)
500 DALI_ASSERT_ALWAYS((acc.mBufferView &&
501 (acc.mBufferView->mByteStride < std::numeric_limits<uint16_t>::max())) ||
502 (acc.mSparse && !acc.mBufferView));
504 DALI_ASSERT_ALWAYS(!acc.mSparse ||
505 ((acc.mSparse->mIndices.mBufferView && (acc.mSparse->mIndices.mBufferView->mByteStride < std::numeric_limits<uint16_t>::max())) &&
506 (acc.mSparse->mValues.mBufferView && (acc.mSparse->mValues.mBufferView->mByteStride < std::numeric_limits<uint16_t>::max()))));
509 MeshDefinition::SparseBlob sparseBlob;
512 const gt::Accessor::Sparse& sparse = *acc.mSparse;
513 const gt::ComponentTypedBufferViewClient& indices = sparse.mIndices;
514 const gt::BufferViewClient& values = sparse.mValues;
516 MeshDefinition::Blob indicesBlob(
517 indices.mBufferView->mByteOffset + indices.mByteOffset,
518 sparse.mCount * indices.GetBytesPerComponent(),
519 static_cast<uint16_t>(indices.mBufferView->mByteStride),
520 static_cast<uint16_t>(indices.GetBytesPerComponent()),
523 MeshDefinition::Blob valuesBlob(
524 values.mBufferView->mByteOffset + values.mByteOffset,
525 sparse.mCount * acc.GetElementSizeBytes(),
526 static_cast<uint16_t>(values.mBufferView->mByteStride),
527 static_cast<uint16_t>(acc.GetElementSizeBytes()),
531 sparseBlob = std::move(MeshDefinition::SparseBlob(std::move(indicesBlob), std::move(valuesBlob), acc.mSparse->mCount));
534 uint32_t bufferViewOffset = 0u;
535 uint32_t bufferViewStride = 0u;
538 bufferViewOffset = acc.mBufferView->mByteOffset;
539 bufferViewStride = acc.mBufferView->mByteStride;
542 return MeshDefinition::Accessor{
543 std::move(MeshDefinition::Blob{bufferViewOffset + acc.mByteOffset,
544 acc.GetBytesLength(),
545 static_cast<uint16_t>(bufferViewStride),
546 static_cast<uint16_t>(acc.GetElementSizeBytes()),
549 std::move(sparseBlob) };
552 void ConvertMeshes(const gt::Document& doc, ConversionContext& cctx)
554 uint32_t meshCount = 0;
555 cctx.mMeshIds.reserve(doc.mMeshes.size());
556 for (auto& m : doc.mMeshes)
558 cctx.mMeshIds.push_back(meshCount);
559 meshCount += m.mPrimitives.size();
562 auto& outMeshes = cctx.mOutput.mResources.mMeshes;
563 outMeshes.reserve(meshCount);
564 for (auto& m : doc.mMeshes)
566 for (auto& p : m.mPrimitives)
568 MeshDefinition meshDef;
570 auto& attribs = p.mAttributes;
571 meshDef.mUri = attribs.begin()->second->mBufferView->mBuffer->mUri;
572 meshDef.mPrimitiveType = GLTF2_TO_DALI_PRIMITIVES[p.mMode];
574 auto& accPositions = *attribs.find(gt::Attribute::POSITION)->second;
575 meshDef.mPositions = ConvertMeshPrimitiveAccessor(accPositions);
577 const bool needNormalsTangents = accPositions.mType == gt::AccessorType::VEC3;
578 for (auto& am : ATTRIBUTE_MAPPINGS)
580 auto iFind = attribs.find(am.mType);
581 if (iFind != attribs.end())
583 DALI_ASSERT_DEBUG(iFind->second->mBufferView->mBuffer->mUri.compare(meshDef.mUri) == 0);
584 auto& accessor = meshDef.*(am.mAccessor);
585 accessor = ConvertMeshPrimitiveAccessor(*iFind->second);
587 // Fixing up -- a few of glTF2 sample models have VEC4 tangents; we need VEC3s.
588 if (iFind->first == gt::Attribute::TANGENT && (accessor.mBlob.mElementSizeHint > am.mElementSizeRequired))
590 accessor.mBlob.mStride = std::max(static_cast<uint16_t>(accessor.mBlob.mStride + accessor.mBlob.mElementSizeHint - am.mElementSizeRequired),
591 accessor.mBlob.mElementSizeHint);
592 accessor.mBlob.mElementSizeHint = am.mElementSizeRequired;
595 if (iFind->first == gt::Attribute::JOINTS_0)
597 meshDef.mFlags |= (iFind->second->mComponentType == gt::Component::UNSIGNED_SHORT) * MeshDefinition::U16_JOINT_IDS;
598 DALI_ASSERT_DEBUG(MaskMatch(meshDef.mFlags, MeshDefinition::U16_JOINT_IDS) || iFind->second->mComponentType == gt::Component::FLOAT);
601 else if (needNormalsTangents)
605 case gt::Attribute::NORMAL:
606 meshDef.RequestNormals();
609 case gt::Attribute::TANGENT:
610 meshDef.RequestTangents();
621 meshDef.mIndices = ConvertMeshPrimitiveAccessor(*p.mIndices);
622 meshDef.mFlags |= (p.mIndices->mComponentType == gt::Component::UNSIGNED_INT) * MeshDefinition::U32_INDICES;
623 DALI_ASSERT_DEBUG(MaskMatch(meshDef.mFlags, MeshDefinition::U32_INDICES) || p.mIndices->mComponentType == gt::Component::UNSIGNED_SHORT);
626 if (!p.mTargets.empty())
628 meshDef.mBlendShapes.reserve(p.mTargets.size());
629 meshDef.mBlendShapeVersion = BlendShapes::Version::VERSION_2_0;
630 for (const auto& target : p.mTargets)
632 MeshDefinition::BlendShape blendShape;
634 auto endIt = target.end();
635 auto it = target.find(gt::Attribute::POSITION);
638 blendShape.deltas = ConvertMeshPrimitiveAccessor(*it->second);
640 it = target.find(gt::Attribute::NORMAL);
643 blendShape.normals = ConvertMeshPrimitiveAccessor(*it->second);
645 it = target.find(gt::Attribute::TANGENT);
648 blendShape.tangents = ConvertMeshPrimitiveAccessor(*it->second);
651 if (!m.mWeights.empty())
653 blendShape.weight = m.mWeights[meshDef.mBlendShapes.size()];
656 meshDef.mBlendShapes.push_back(std::move(blendShape));
660 outMeshes.push_back({ std::move(meshDef), MeshGeometry{} });
665 ModelNode* MakeModelNode(const gt::Mesh::Primitive& prim, ConversionContext& cctx)
667 auto modelNode = new ModelNode();
669 modelNode->mShaderIdx = 0; // TODO: further thought
671 auto materialIdx = prim.mMaterial.GetIndex();
672 if (INVALID_INDEX == materialIdx)
674 // https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#default-material
675 if (INVALID_INDEX == cctx.mDefaultMaterial)
677 auto& outMaterials = cctx.mOutput.mResources.mMaterials;
678 cctx.mDefaultMaterial = outMaterials.size();
680 ConvertMaterial(gt::Material{}, outMaterials);
683 materialIdx = cctx.mDefaultMaterial;
686 modelNode->mMaterialIdx = materialIdx;
691 void ConvertCamera(const gt::Camera& camera, CameraParameters& camParams)
693 camParams.isPerspective = camera.mType.compare("perspective") == 0;
694 if (camParams.isPerspective)
696 auto& perspective = camera.mPerspective;
697 camParams.yFov = Degree(Radian(perspective.mYFov)).degree;
698 camParams.zNear = perspective.mZNear;
699 camParams.zFar = perspective.mZFar;
700 // TODO: yes, we seem to ignore aspectRatio in CameraParameters.
704 auto& ortho = camera.mOrthographic;
705 camParams.orthographicSize = Vector4(-ortho.mXMag, ortho.mXMag, ortho.mYMag, -ortho.mYMag) * .5f;
706 camParams.zNear = ortho.mZNear;
707 camParams.zFar = ortho.mZFar;
711 void ConvertNode(gt::Node const& node, const Index gltfIdx, Index parentIdx, ConversionContext& cctx)
713 auto& output = cctx.mOutput;
714 auto& scene = output.mScene;
715 auto& resources = output.mResources;
717 const auto idx = scene.GetNodeCount();
718 auto weakNode = scene.AddNode([&]() {
719 std::unique_ptr<NodeDefinition> nodeDef{ new NodeDefinition() };
721 nodeDef->mParentIdx = parentIdx;
722 nodeDef->mName = node.mName;
723 if (nodeDef->mName.empty())
725 // TODO: Production quality generation of unique names.
726 nodeDef->mName = std::to_string(reinterpret_cast<uintptr_t>(nodeDef.get()));
729 if (!node.mSkin) // Nodes with skinned meshes are not supposed to have local transforms.
731 nodeDef->mPosition = node.mTranslation;
732 nodeDef->mOrientation = node.mRotation;
733 nodeDef->mScale = node.mScale;
740 ExceptionFlinger(ASSERT_LOCATION) << "Node name '" << node.mName << "' is not unique; scene is invalid.";
743 cctx.mNodeIndices.RegisterMapping(gltfIdx, idx);
745 Index skeletonIdx = node.mSkin ? node.mSkin.GetIndex() : INVALID_INDEX;
746 if (node.mMesh && !node.mMesh->mPrimitives.empty())
748 auto& mesh = *node.mMesh;
750 auto iPrim = mesh.mPrimitives.begin();
751 auto modelNode = MakeModelNode(*iPrim, cctx);
752 auto meshIdx = cctx.mMeshIds[node.mMesh.GetIndex()];
753 modelNode->mMeshIdx = meshIdx;
755 weakNode->mRenderable.reset(modelNode);
757 DALI_ASSERT_DEBUG(resources.mMeshes[meshIdx].first.mSkeletonIdx == INVALID_INDEX ||
758 resources.mMeshes[meshIdx].first.mSkeletonIdx == skeletonIdx);
759 resources.mMeshes[meshIdx].first.mSkeletonIdx = skeletonIdx;
761 // As does model-exporter, we'll create anonymous child nodes for additional mesh( primitiv)es.
762 while (++iPrim != mesh.mPrimitives.end())
764 std::unique_ptr<NodeDefinition> child{ new NodeDefinition };
765 child->mParentIdx = idx;
767 auto childModel = MakeModelNode(*iPrim, cctx);
770 childModel->mMeshIdx = meshIdx;
772 child->mRenderable.reset(childModel);
774 scene.AddNode(std::move(child));
776 DALI_ASSERT_DEBUG(resources.mMeshes[meshIdx].first.mSkeletonIdx == INVALID_INDEX ||
777 resources.mMeshes[meshIdx].first.mSkeletonIdx == skeletonIdx);
778 resources.mMeshes[meshIdx].first.mSkeletonIdx = skeletonIdx;
784 CameraParameters camParams;
785 ConvertCamera(*node.mCamera, camParams);
787 camParams.matrix.SetTransformComponents(node.mScale, node.mRotation, node.mTranslation);
788 output.mCameraParameters.push_back(camParams);
791 for (auto& n : node.mChildren)
793 ConvertNode(*n, n.GetIndex(), idx, cctx);
797 void ConvertSceneNodes(const gt::Scene& scene, ConversionContext& cctx)
799 auto& outScene = cctx.mOutput.mScene;
800 Index rootIdx = outScene.GetNodeCount();
801 switch (scene.mNodes.size())
807 ConvertNode(*scene.mNodes[0], scene.mNodes[0].GetIndex(), INVALID_INDEX, cctx);
808 outScene.AddRootNode(rootIdx);
813 std::unique_ptr<NodeDefinition> sceneRoot{ new NodeDefinition() };
814 sceneRoot->mName = "GLTF_LOADER_SCENE_ROOT_" + std::to_string(outScene.GetRoots().size());
816 outScene.AddNode(std::move(sceneRoot));
817 outScene.AddRootNode(rootIdx);
819 for (auto& n : scene.mNodes)
821 ConvertNode(*n, n.GetIndex(), rootIdx, cctx);
828 void ConvertNodes(const gt::Document& doc, ConversionContext& cctx)
830 ConvertSceneNodes(*doc.mScene, cctx);
832 for (uint32_t i = 0, i1 = doc.mScene.GetIndex(); i < i1; ++i)
834 ConvertSceneNodes(doc.mScenes[i], cctx);
837 for (uint32_t i = doc.mScene.GetIndex() + 1; i < doc.mScenes.size(); ++i)
839 ConvertSceneNodes(doc.mScenes[i], cctx);
843 template <typename T>
844 void LoadDataFromAccessor(const std::string& path, Vector<T>& dataBuffer, uint32_t offset, uint32_t size)
846 std::ifstream animationBinaryFile(path, std::ifstream::binary);
848 if (!animationBinaryFile.is_open())
850 throw std::runtime_error("Failed to load " + path);
853 animationBinaryFile.seekg(offset);
854 animationBinaryFile.read(reinterpret_cast<char*>(dataBuffer.Begin()), size);
855 animationBinaryFile.close();
858 template <typename T>
859 float LoadDataFromAccessors(const std::string& path, const gltf2::Accessor& input, const gltf2::Accessor& output, Vector<float>& inputDataBuffer, Vector<T>& outputDataBuffer)
861 inputDataBuffer.Resize(input.mCount);
862 outputDataBuffer.Resize(output.mCount);
864 const uint32_t inputDataBufferSize = input.GetBytesLength();
865 const uint32_t outputDataBufferSize = output.GetBytesLength();
867 LoadDataFromAccessor<float>(path + std::string(input.mBufferView->mBuffer->mUri), inputDataBuffer,
868 input.mBufferView->mByteOffset + input.mByteOffset, inputDataBufferSize);
869 LoadDataFromAccessor<T>(path + std::string(output.mBufferView->mBuffer->mUri), outputDataBuffer,
870 output.mBufferView->mByteOffset + output.mByteOffset, outputDataBufferSize);
871 ApplyAccessorMinMax(output, reinterpret_cast<float*>(outputDataBuffer.begin()));
873 return inputDataBuffer[input.mCount - 1u];
877 float LoadKeyFrames(const std::string& path, const gt::Animation::Channel& channel, KeyFrames& keyFrames, gt::Animation::Channel::Target::Type type)
879 const gltf2::Accessor& input = *channel.mSampler->mInput;
880 const gltf2::Accessor& output = *channel.mSampler->mOutput;
882 Vector<float> inputDataBuffer;
883 Vector<T> outputDataBuffer;
885 const float duration = LoadDataFromAccessors<T>(path, input, output, inputDataBuffer, outputDataBuffer);
887 for (uint32_t i = 0; i < input.mCount; ++i)
889 keyFrames.Add(inputDataBuffer[i] / duration, outputDataBuffer[i]);
895 float LoadBlendShapeKeyFrames(const std::string& path, const gt::Animation::Channel& channel, const std::string& nodeName, uint32_t& propertyIndex, std::vector<SceneLoader::AnimatedProperty>& properties)
897 const gltf2::Accessor& input = *channel.mSampler->mInput;
898 const gltf2::Accessor& output = *channel.mSampler->mOutput;
900 Vector<float> inputDataBuffer;
901 Vector<float> outputDataBuffer;
903 const float duration = LoadDataFromAccessors<float>(path, input, output, inputDataBuffer, outputDataBuffer);
905 char weightNameBuffer[32];
906 auto prefixSize = snprintf(weightNameBuffer, sizeof(weightNameBuffer), "%s[", BLEND_SHAPE_WEIGHTS_UNIFORM.c_str());
907 char* const pWeightName = weightNameBuffer + prefixSize;
908 const auto remainingSize = sizeof(weightNameBuffer) - prefixSize;
909 for (uint32_t weightIndex = 0u, endWeightIndex = channel.mSampler->mOutput->mCount / channel.mSampler->mInput->mCount; weightIndex < endWeightIndex; ++weightIndex)
911 AnimatedProperty& animatedProperty = properties[propertyIndex++];
913 animatedProperty.mNodeName = nodeName;
914 snprintf(pWeightName, remainingSize, "%d]", weightIndex);
915 animatedProperty.mPropertyName = std::string(weightNameBuffer);
917 animatedProperty.mKeyFrames = KeyFrames::New();
918 for (uint32_t i = 0; i < input.mCount; ++i)
920 animatedProperty.mKeyFrames.Add(inputDataBuffer[i] / duration, outputDataBuffer[i*endWeightIndex + weightIndex]);
923 animatedProperty.mTimePeriod = { 0.f, duration };
929 void ConvertAnimations(const gt::Document& doc, ConversionContext& cctx)
931 auto& output = cctx.mOutput;
933 output.mAnimationDefinitions.reserve(output.mAnimationDefinitions.size() + doc.mAnimations.size());
935 for (const auto& animation : doc.mAnimations)
937 AnimationDefinition animationDef;
939 if (!animation.mName.empty())
941 animationDef.mName = animation.mName;
944 uint32_t numberOfProperties = 0u;
946 for (const auto& channel : animation.mChannels)
948 numberOfProperties += channel.mSampler->mOutput->mCount;
950 animationDef.mProperties.resize(numberOfProperties);
952 Index propertyIndex = 0u;
953 for (const auto& channel : animation.mChannels)
955 std::string nodeName;
956 if (!channel.mTarget.mNode->mName.empty())
958 nodeName = channel.mTarget.mNode->mName;
962 Index index = cctx.mNodeIndices.GetRuntimeId(channel.mTarget.mNode.GetIndex());
963 nodeName = cctx.mOutput.mScene.GetNode(index)->mName;
966 float duration = 0.f;
968 switch (channel.mTarget.mPath)
970 case gt::Animation::Channel::Target::TRANSLATION:
972 AnimatedProperty& animatedProperty = animationDef.mProperties[propertyIndex];
974 animatedProperty.mNodeName = nodeName;
975 animatedProperty.mPropertyName = POSITION_PROPERTY;
977 animatedProperty.mKeyFrames = KeyFrames::New();
978 duration = LoadKeyFrames<Vector3>(cctx.mPath, channel, animatedProperty.mKeyFrames, channel.mTarget.mPath);
980 animatedProperty.mTimePeriod = { 0.f, duration };
983 case gt::Animation::Channel::Target::ROTATION:
985 AnimatedProperty& animatedProperty = animationDef.mProperties[propertyIndex];
987 animatedProperty.mNodeName = nodeName;
988 animatedProperty.mPropertyName = ORIENTATION_PROPERTY;
990 animatedProperty.mKeyFrames = KeyFrames::New();
991 duration = LoadKeyFrames<Quaternion>(cctx.mPath, channel, animatedProperty.mKeyFrames, channel.mTarget.mPath);
993 animatedProperty.mTimePeriod = { 0.f, duration };
996 case gt::Animation::Channel::Target::SCALE:
998 AnimatedProperty& animatedProperty = animationDef.mProperties[propertyIndex];
1000 animatedProperty.mNodeName = nodeName;
1001 animatedProperty.mPropertyName = SCALE_PROPERTY;
1003 animatedProperty.mKeyFrames = KeyFrames::New();
1004 duration = LoadKeyFrames<Vector3>(cctx.mPath, channel, animatedProperty.mKeyFrames, channel.mTarget.mPath);
1006 animatedProperty.mTimePeriod = { 0.f, duration };
1009 case gt::Animation::Channel::Target::WEIGHTS:
1011 duration = LoadBlendShapeKeyFrames(cctx.mPath, channel, nodeName, propertyIndex, animationDef.mProperties);
1017 // nothing to animate.
1022 animationDef.mDuration = std::max(duration, animationDef.mDuration);
1027 output.mAnimationDefinitions.push_back(std::move(animationDef));
1031 void ProcessSkins(const gt::Document& doc, ConversionContext& cctx)
1033 // https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#skininversebindmatrices
1034 // If an inverseBindMatrices accessor was provided, we'll load the joint data from the buffer,
1035 // otherwise we'll set identity matrices for inverse bind pose.
1036 struct IInverseBindMatrixProvider
1038 virtual ~IInverseBindMatrixProvider() {}
1039 virtual void Provide(Matrix& ibm) = 0;
1042 struct InverseBindMatrixAccessor : public IInverseBindMatrixProvider
1044 std::ifstream mStream;
1045 const uint32_t mElementSizeBytes;
1047 InverseBindMatrixAccessor(const gt::Accessor& accessor, const std::string& path)
1048 : mStream(path + std::string(accessor.mBufferView->mBuffer->mUri), std::ios::binary),
1049 mElementSizeBytes(accessor.GetElementSizeBytes())
1051 DALI_ASSERT_ALWAYS(mStream);
1052 DALI_ASSERT_DEBUG(accessor.mType == gt::AccessorType::MAT4 && accessor.mComponentType == gt::Component::FLOAT);
1054 mStream.seekg(accessor.mBufferView->mByteOffset + accessor.mByteOffset);
1057 virtual void Provide(Matrix& ibm) override
1059 DALI_ASSERT_ALWAYS(mStream.read(reinterpret_cast<char*>(ibm.AsFloat()), mElementSizeBytes));
1063 struct DefaultInverseBindMatrixProvider : public IInverseBindMatrixProvider
1065 virtual void Provide(Matrix& ibm) override
1067 ibm = Matrix::IDENTITY;
1071 auto& resources = cctx.mOutput.mResources;
1072 resources.mSkeletons.reserve(doc.mSkins.size());
1074 for (auto& s : doc.mSkins)
1076 std::unique_ptr<IInverseBindMatrixProvider> ibmProvider;
1077 if (s.mInverseBindMatrices)
1079 ibmProvider.reset(new InverseBindMatrixAccessor(*s.mInverseBindMatrices, cctx.mPath));
1083 ibmProvider.reset(new DefaultInverseBindMatrixProvider());
1086 SkeletonDefinition skeleton;
1087 if (s.mSkeleton.GetIndex() != INVALID_INDEX)
1089 skeleton.mRootNodeIdx = cctx.mNodeIndices.GetRuntimeId(s.mSkeleton.GetIndex());
1092 skeleton.mJoints.resize(s.mJoints.size());
1093 auto iJoint = skeleton.mJoints.begin();
1094 for (auto& j : s.mJoints)
1096 iJoint->mNodeIdx = cctx.mNodeIndices.GetRuntimeId(j.GetIndex());
1098 ibmProvider->Provide(iJoint->mInverseBindMatrix);
1103 resources.mSkeletons.push_back(std::move(skeleton));
1107 void ProduceShaders(ShaderDefinitionFactory& shaderFactory, SceneDefinition& scene)
1109 for (size_t i0 = 0, i1 = scene.GetNodeCount(); i0 != i1; ++i0)
1111 auto nodeDef = scene.GetNode(i0);
1112 if (auto renderable = nodeDef->mRenderable.get())
1114 renderable->mShaderIdx = shaderFactory.ProduceShader(*nodeDef);
1119 void SetObjectReaders()
1121 js::SetObjectReader(BUFFER_READER);
1122 js::SetObjectReader(BUFFER_VIEW_READER);
1123 js::SetObjectReader(BUFFER_VIEW_CLIENT_READER);
1124 js::SetObjectReader(COMPONENT_TYPED_BUFFER_VIEW_CLIENT_READER);
1125 js::SetObjectReader(ACCESSOR_SPARSE_READER);
1126 js::SetObjectReader(ACCESSOR_READER);
1127 js::SetObjectReader(IMAGE_READER);
1128 js::SetObjectReader(SAMPLER_READER);
1129 js::SetObjectReader(TEXURE_READER);
1130 js::SetObjectReader(TEXURE_INFO_READER);
1131 js::SetObjectReader(MATERIAL_PBR_READER);
1132 js::SetObjectReader(MATERIAL_READER);
1133 js::SetObjectReader(MESH_PRIMITIVE_READER);
1134 js::SetObjectReader(MESH_READER);
1135 js::SetObjectReader(SKIN_READER);
1136 js::SetObjectReader(CAMERA_PERSPECTIVE_READER);
1137 js::SetObjectReader(CAMERA_ORTHOGRAPHIC_READER);
1138 js::SetObjectReader(CAMERA_READER);
1139 js::SetObjectReader(NODE_READER);
1140 js::SetObjectReader(ANIMATION_SAMPLER_READER);
1141 js::SetObjectReader(ANIMATION_TARGET_READER);
1142 js::SetObjectReader(ANIMATION_CHANNEL_READER);
1143 js::SetObjectReader(ANIMATION_READER);
1144 js::SetObjectReader(SCENE_READER);
1149 void LoadGltfScene(const std::string& url, ShaderDefinitionFactory& shaderFactory, LoadResult& params)
1151 bool failed = false;
1152 auto js = LoadTextFile(url.c_str(), &failed);
1155 throw std::runtime_error("Failed to load " + url);
1158 json::unique_ptr root(json_parse(js.c_str(), js.size()));
1161 throw std::runtime_error("Failed to parse " + url);
1164 static bool setObjectReaders = true;
1165 if (setObjectReaders)
1167 // NOTE: only referencing own, anonymous namespace, const objects; the pointers will never need to change.
1169 setObjectReaders = false;
1174 auto& rootObj = js::Cast<json_object_s>(*root);
1175 auto jsAsset = js::FindObjectChild("asset", rootObj);
1176 auto jsAssetVersion = js::FindObjectChild("version", js::Cast<json_object_s>(*jsAsset));
1177 doc.mAsset.mVersion = js::Read::StringView(*jsAssetVersion);
1179 gt::SetRefReaderObject(doc);
1180 DOCUMENT_READER.Read(rootObj, doc);
1182 auto path = url.substr(0, url.rfind('/') + 1);
1183 ConversionContext cctx{ params, path, INVALID_INDEX };
1185 ConvertMaterials(doc, cctx);
1186 ConvertMeshes(doc, cctx);
1187 ConvertNodes(doc, cctx);
1188 ConvertAnimations(doc, cctx);
1190 ProcessSkins(doc, cctx);
1192 ProduceShaders(shaderFactory, params.mScene);
1193 params.mScene.EnsureUniqueSkinningShaderInstances(params.mResources);