DALi Version 2.2.11
[platform/core/uifw/dali-toolkit.git] / automated-tests / src / dali-scene3d / utc-Dali-DliLoader.cpp
1 /*
2  * Copyright (c) 2022 Samsung Electronics Co., Ltd.
3  *
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
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
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.
15  *
16  */
17
18 // Enable debug log for test coverage
19 #define DEBUG_ENABLED 1
20
21 #include <dali-scene3d/internal/loader/json-util.h>
22 #include <dali-scene3d/public-api/loader/dli-loader.h>
23 #include <dali-scene3d/public-api/loader/load-result.h>
24 #include <dali-scene3d/public-api/loader/resource-bundle.h>
25 #include <dali-scene3d/public-api/loader/scene-definition.h>
26 #include <dali-test-suite-utils.h>
27 #include <string_view>
28
29 using namespace Dali;
30 using namespace Dali::Scene3D::Loader;
31
32 namespace
33 {
34 void ConfigureBlendShapeShaders(ResourceBundle& resources, const SceneDefinition& scene, Actor root, std::vector<BlendshapeShaderConfigurationRequest>&& requests)
35 {
36   std::vector<std::string> errors;
37   auto                     onError = [&errors](const std::string& msg) {
38     errors.push_back(msg);
39   };
40
41   if(!scene.ConfigureBlendshapeShaders(resources, root, std::move(requests), onError))
42   {
43     ExceptionFlinger flinger(ASSERT_LOCATION);
44     for(auto& msg : errors)
45     {
46       flinger << msg << '\n';
47     }
48   }
49 }
50
51 struct Context
52 {
53   ResourceBundle::PathProvider pathProvider = [](ResourceType::Value type) {
54     return TEST_RESOURCE_DIR "/";
55   };
56
57   ResourceBundle                        resources;
58   SceneDefinition                       scene;
59   std::vector<CameraParameters>         cameraParameters;
60   std::vector<LightParameters>          lights;
61   std::vector<AnimationDefinition>      animations;
62   std::vector<AnimationGroupDefinition> animGroups;
63
64   SceneMetadata metaData;
65
66   LoadResult output{
67     resources,
68     scene,
69     metaData,
70     animations,
71     animGroups,
72     cameraParameters,
73     lights};
74
75   DliLoader::InputParams input{
76     pathProvider(ResourceType::Mesh),
77     nullptr,
78     {},
79     {},
80     nullptr,
81   };
82   DliLoader::LoadParams loadParams{input, output};
83
84   std::vector<std::string> errors;
85   DliLoader                loader;
86
87   StringCallback onError = [this](const std::string& error) {
88     errors.push_back(error);
89     printf("%s\n", error.c_str());
90   };
91
92   Context()
93   {
94     loader.SetErrorCallback(onError);
95   }
96 };
97
98 bool StringHasTokens(const char* string, const std::vector<const char*>& tokens)
99 {
100   for(auto& token : tokens)
101   {
102     auto result = strstr(string, token);
103     if(nullptr == result)
104     {
105       return false;
106     }
107     string = result + strlen(token);
108   }
109   return true;
110 }
111
112 } // namespace
113
114 int UtcDaliDliLoaderLoadSceneNotFound(void)
115 {
116   Context ctx;
117
118   DALI_TEST_EQUAL(ctx.loader.LoadScene("does_not_exist.dli", ctx.loadParams), false);
119
120   auto error = ctx.loader.GetParseError();
121   DALI_TEST_CHECK(StringHasTokens(error.c_str(), {"Empty source buffer to parse."}));
122
123   END_TEST;
124 }
125
126 int UtcDaliDliLoaderLoadSceneFailParse(void)
127 {
128   Context ctx;
129
130   auto path = ctx.pathProvider(ResourceType::Mesh) + "invalid.gltf";
131   DALI_TEST_EQUAL(ctx.loader.LoadScene(path, ctx.loadParams), false);
132
133   auto error = ctx.loader.GetParseError();
134   DALI_TEST_CHECK(StringHasTokens(error.c_str(), {"Unexpected character."}));
135
136   END_TEST;
137 }
138
139 int UtcDaliDliLoaderLoadSceneAssertions(void)
140 {
141   const std::pair<std::string, std::string> pathExceptionPairs[]{
142     // from RequireChild()
143     {"scenes-nodes-missing", "Failed to find child node"},
144     {"scenes-missing", "Failed to find child node"},
145     {"nodes-missing", "Failed to find child node"},
146     // from ParseSceneInternal()
147     {"scene-out-of-bounds", "out of bounds"},
148     {"nodes-invalid-type", "invalid type; array required"},
149     {"nodes-array-empty", "must define a node id"},
150     {"root-id-invalid", "invalid value for root node index"},
151     {"root-id-out-of-bounds", "out of bounds"},
152     {"root-node-invalid-type", "invalid JSON type; object required"},
153     // from ParseSkeletons()
154     {"skeleton-node-missing", "Missing required attribute"},
155     {"skeleton-root-not-found", "not defined"},
156     // from ParseShaders()
157     {"shader-vertex-missing", "Missing vertex / fragment shader"},
158     {"shader-fragment-missing", "Missing vertex / fragment shader"},
159     // from ParseMeshes()
160     {"mesh-uri-missing", "Missing required attribute"},
161     {"mesh-indices-read-fail", "Failed to read indices"},
162     {"mesh-positions-read-fail", "Failed to read positions"},
163     // from ParseMaterials()
164     {"material-environment-out-of-bounds", "out of bounds"},
165     // from ParseNodes()
166     {"node-model-mesh-missing", "Missing mesh"},
167     {"node-arc-mesh-missing", "Missing mesh"},
168     {"node-animated-image-mesh-missing", "Missing mesh"},
169     {"node-renderable-mesh-invalid-type", "Invalid Mesh index type"},
170     {"node-renderable-mesh-out-of-bounds", "out of bounds"},
171     {"node-child-invalid-type", "invalid index type"},
172     // from ParseAnimations()
173     {"animation-failed-to-open", "Failed to open animation data"}};
174   for(auto& i : pathExceptionPairs)
175   {
176     Context ctx;
177
178     auto path = ctx.pathProvider(ResourceType::Mesh) + "dli/" + i.first + ".dli";
179     printf("\n\n%s: %s\n", path.c_str(), i.second.c_str());
180     DALI_TEST_ASSERTION(ctx.loader.LoadScene(path, ctx.loadParams), i.second.c_str());
181   }
182
183   END_TEST;
184 }
185
186 int UtcDaliDliLoaderLoadSceneExercise(void)
187 {
188   Context ctx;
189
190   auto path = ctx.pathProvider(ResourceType::Mesh) + "exercise.dli";
191   DALI_TEST_CHECK(ctx.loader.LoadScene(path, ctx.loadParams));
192   DALI_TEST_CHECK(ctx.errors.empty());
193
194   auto& scene = ctx.scene;
195   auto& roots = scene.GetRoots();
196   DALI_TEST_EQUAL(roots.size(), 2u);
197   DALI_TEST_EQUAL(scene.GetNode(roots[0])->mName, "Backdrop"); // default scene is scene 1 - this one.
198   DALI_TEST_EQUAL(scene.GetNode(roots[1])->mName, "ExerciseDemo");
199
200   DALI_TEST_EQUAL(scene.GetNodeCount(), 96u);
201
202   auto& resources = ctx.resources;
203   DALI_TEST_EQUAL(resources.mMeshes.size(), 11u);
204   DALI_TEST_EQUAL(resources.mMaterials.size(), 13u);
205   DALI_TEST_EQUAL(resources.mShaders.size(), 5u);
206   DALI_TEST_EQUAL(resources.mEnvironmentMaps.size(), 2u);
207   DALI_TEST_EQUAL(resources.mSkeletons.size(), 1u);
208
209   DALI_TEST_EQUAL(ctx.cameraParameters.size(), 1u);
210   DALI_TEST_EQUAL(ctx.lights.size(), 1u);
211   DALI_TEST_EQUAL(ctx.animations.size(), 18u);
212   DALI_TEST_EQUAL(ctx.animGroups.size(), 16u);
213
214   ViewProjection viewProjection;
215   Transforms     xforms{
216     MatrixStack{},
217     viewProjection};
218   NodeDefinition::CreateParams nodeParams{
219     resources,
220     xforms,
221   };
222
223   Customization::Choices choices;
224
225   TestApplication app;
226
227   Actor root = Actor::New();
228   SetActorCentered(root);
229   for(auto iRoot : scene.GetRoots())
230   {
231     auto resourceRefs = resources.CreateRefCounter();
232     scene.CountResourceRefs(iRoot, choices, resourceRefs);
233     resources.CountEnvironmentReferences(resourceRefs);
234     resources.LoadResources(resourceRefs, ctx.pathProvider);
235     if(auto actor = scene.CreateNodes(iRoot, choices, nodeParams))
236     {
237       scene.ConfigureSkeletonJoints(iRoot, resources.mSkeletons, actor);
238       scene.ConfigureSkinningShaders(resources, actor, std::move(nodeParams.mSkinnables));
239       ConfigureBlendShapeShaders(resources, scene, actor, std::move(nodeParams.mBlendshapeRequests));
240       scene.ApplyConstraints(actor, std::move(nodeParams.mConstrainables));
241       root.Add(actor);
242     }
243   }
244
245   DALI_TEST_EQUAL(root.GetChildCount(), 2u);
246   DALI_TEST_EQUAL(root.GetChildAt(0).GetProperty(Actor::Property::NAME).Get<std::string>(), "Backdrop");
247   DALI_TEST_EQUAL(root.GetChildAt(1).GetProperty(Actor::Property::NAME).Get<std::string>(), "ExerciseDemo");
248
249   END_TEST;
250 }
251
252 int UtcDaliDliLoaderLoadSceneMorph(void)
253 {
254   Context ctx;
255
256   std::vector<std::string> metadata;
257   uint32_t                 metadataCount = 0;
258   ctx.input.mPreNodeCategoryProcessors.push_back({"metadata",
259                                                   [&](const Property::Array& array, StringCallback) {
260                                                     std::string key, value;
261                                                     for(uint32_t i0 = 0, i1 = array.Count(); i0 < i1; ++i0)
262                                                     {
263                                                       auto& data = array.GetElementAt(i0);
264                                                       DALI_TEST_EQUAL(data.GetType(), Property::MAP);
265
266                                                       auto map   = data.GetMap();
267                                                       auto key   = map->Find("key");
268                                                       auto value = map->Find("value");
269                                                       DALI_TEST_EQUAL(key->GetType(), Property::STRING);
270                                                       DALI_TEST_EQUAL(value->GetType(), Property::STRING);
271                                                       metadata.push_back(key->Get<std::string>() + ":" + value->Get<std::string>());
272
273                                                       ++metadataCount;
274                                                     }
275                                                   }});
276
277   std::vector<std::string> behaviors;
278   uint32_t                 behaviorCount = 0;
279   ctx.input.mPostNodeCategoryProcessors.push_back({"behaviors",
280                                                    [&](const Property::Array& array, StringCallback) {
281                                                      for(uint32_t i0 = 0, i1 = array.Count(); i0 < i1; ++i0)
282                                                      {
283                                                        auto& data = array.GetElementAt(i0);
284                                                        DALI_TEST_EQUAL(data.GetType(), Property::MAP);
285
286                                                        auto map   = data.GetMap();
287                                                        auto event = map->Find("event");
288                                                        auto url   = map->Find("url");
289                                                        DALI_TEST_EQUAL(event->GetType(), Property::STRING);
290                                                        DALI_TEST_EQUAL(url->GetType(), Property::STRING);
291                                                        behaviors.push_back(event->Get<std::string>() + ":" + url->Get<std::string>());
292
293                                                        ++behaviorCount;
294                                                      }
295                                                    }});
296
297   size_t numNodes                  = 0;
298   ctx.input.mNodePropertyProcessor = [&](const NodeDefinition&, const Property::Map&, StringCallback) {
299     ++numNodes;
300   };
301
302   auto path = ctx.pathProvider(ResourceType::Mesh) + "morph.dli";
303   DALI_TEST_CHECK(ctx.loader.LoadScene(path, ctx.loadParams));
304   DALI_TEST_CHECK(ctx.errors.empty());
305
306   auto& scene = ctx.scene;
307   auto& roots = scene.GetRoots();
308   DALI_TEST_EQUAL(roots.size(), 1u);
309   DALI_TEST_EQUAL(scene.GetNode(roots[0])->mName, "HeadTest_002");
310
311   DALI_TEST_EQUAL(numNodes, 3u);
312   DALI_TEST_EQUAL(scene.GetNodeCount(), numNodes);
313
314   auto& resources = ctx.resources;
315   DALI_TEST_EQUAL(resources.mMeshes.size(), 2u);
316   DALI_TEST_EQUAL(resources.mMaterials.size(), 1u);
317   DALI_TEST_EQUAL(resources.mShaders.size(), 5u);
318   DALI_TEST_EQUAL(resources.mEnvironmentMaps.size(), 2u);
319   DALI_TEST_EQUAL(resources.mSkeletons.size(), 0u);
320
321   DALI_TEST_EQUAL(ctx.cameraParameters.size(), 1u);
322   DALI_TEST_EQUAL(ctx.lights.size(), 1u);
323   DALI_TEST_EQUAL(ctx.animations.size(), 1u);
324   DALI_TEST_EQUAL(ctx.animGroups.size(), 0u);
325
326   DALI_TEST_EQUAL(metadata.size(), 4u);
327   DALI_TEST_EQUAL(behaviors.size(), 1u);
328
329   ViewProjection viewProjection;
330   Transforms     xforms{
331     MatrixStack{},
332     viewProjection};
333   NodeDefinition::CreateParams nodeParams{
334     resources,
335     xforms,
336   };
337
338   Customization::Choices choices;
339
340   TestApplication app;
341
342   Actor root = Actor::New();
343   SetActorCentered(root);
344   for(auto iRoot : scene.GetRoots())
345   {
346     auto resourceRefs = resources.CreateRefCounter();
347     scene.CountResourceRefs(iRoot, choices, resourceRefs);
348     resources.CountEnvironmentReferences(resourceRefs);
349     resources.LoadResources(resourceRefs, ctx.pathProvider);
350     if(auto actor = scene.CreateNodes(iRoot, choices, nodeParams))
351     {
352       scene.ConfigureSkeletonJoints(iRoot, resources.mSkeletons, actor);
353       scene.ConfigureSkinningShaders(resources, actor, std::move(nodeParams.mSkinnables));
354       ConfigureBlendShapeShaders(resources, scene, actor, std::move(nodeParams.mBlendshapeRequests));
355       scene.ApplyConstraints(actor, std::move(nodeParams.mConstrainables));
356       root.Add(actor);
357     }
358   }
359
360   DALI_TEST_EQUAL(root.GetChildCount(), 1u);
361   DALI_TEST_EQUAL(root.GetChildAt(0).GetProperty(Actor::Property::NAME).Get<std::string>(), "HeadTest_002");
362
363   END_TEST;
364 }
365
366 int UtcDaliDliLoaderLoadSceneArc(void)
367 {
368   Context ctx;
369
370   auto path = ctx.pathProvider(ResourceType::Mesh) + "arc.dli";
371   DALI_TEST_CHECK(ctx.loader.LoadScene(path, ctx.loadParams));
372   DALI_TEST_CHECK(ctx.errors.empty());
373
374   auto& scene = ctx.scene;
375   auto& roots = scene.GetRoots();
376   DALI_TEST_EQUAL(roots.size(), 1u);
377   DALI_TEST_EQUAL(scene.GetNode(roots[0])->mName, "root");
378
379   DALI_TEST_EQUAL(scene.GetNodeCount(), 2u);
380
381   auto& resources = ctx.resources;
382   DALI_TEST_EQUAL(resources.mMeshes.size(), 1u);
383   DALI_TEST_EQUAL(resources.mMaterials.size(), 1u);
384   DALI_TEST_EQUAL(resources.mShaders.size(), 1u);
385   DALI_TEST_EQUAL(resources.mEnvironmentMaps.size(), 1u);
386   DALI_TEST_EQUAL(resources.mSkeletons.size(), 0u);
387
388   DALI_TEST_EQUAL(ctx.cameraParameters.size(), 0u);
389   DALI_TEST_EQUAL(ctx.lights.size(), 0u);
390   DALI_TEST_EQUAL(ctx.animations.size(), 0u);
391   DALI_TEST_EQUAL(ctx.animGroups.size(), 0u);
392
393   ViewProjection viewProjection;
394   Transforms     xforms{
395     MatrixStack{},
396     viewProjection};
397   NodeDefinition::CreateParams nodeParams{
398     resources,
399     xforms,
400   };
401
402   Customization::Choices choices;
403
404   TestApplication app;
405
406   Actor root = Actor::New();
407   SetActorCentered(root);
408   for(auto iRoot : scene.GetRoots())
409   {
410     auto resourceRefs = resources.CreateRefCounter();
411     scene.CountResourceRefs(iRoot, choices, resourceRefs);
412     resources.CountEnvironmentReferences(resourceRefs);
413     resources.LoadResources(resourceRefs, ctx.pathProvider);
414     if(auto actor = scene.CreateNodes(iRoot, choices, nodeParams))
415     {
416       scene.ConfigureSkeletonJoints(iRoot, resources.mSkeletons, actor);
417       scene.ConfigureSkinningShaders(resources, actor, std::move(nodeParams.mSkinnables));
418       ConfigureBlendShapeShaders(resources, scene, actor, std::move(nodeParams.mBlendshapeRequests));
419       scene.ApplyConstraints(actor, std::move(nodeParams.mConstrainables));
420       root.Add(actor);
421     }
422   }
423
424   DALI_TEST_EQUAL(root.GetChildCount(), 1u);
425   DALI_TEST_EQUAL(root.GetChildAt(0).GetProperty(Actor::Property::NAME).Get<std::string>(), "root");
426
427   END_TEST;
428 }
429
430 int UtcDaliDliLoaderLoadSceneShaderUniforms(void)
431 {
432   Context ctx;
433
434   auto path = ctx.pathProvider(ResourceType::Mesh) + "dli/shader-uniforms.dli";
435   DALI_TEST_CHECK(ctx.loader.LoadScene(path, ctx.loadParams));
436   DALI_TEST_EQUAL(ctx.errors.size(), 1u);
437   DALI_TEST_CHECK(ctx.errors[0].find("failed to infer type") != std::string::npos);
438
439   auto& scene = ctx.scene;
440   auto& roots = scene.GetRoots();
441   DALI_TEST_EQUAL(roots.size(), 1u);
442   DALI_TEST_EQUAL(scene.GetNode(roots[0])->mName, "root");
443
444   DALI_TEST_EQUAL(scene.GetNodeCount(), 1u);
445
446   auto& resources = ctx.resources;
447   DALI_TEST_EQUAL(resources.mMeshes.size(), 0u);
448   DALI_TEST_EQUAL(resources.mMaterials.size(), 0u);
449   DALI_TEST_EQUAL(resources.mShaders.size(), 1u);
450   DALI_TEST_EQUAL(resources.mEnvironmentMaps.size(), 0u);
451   DALI_TEST_EQUAL(resources.mSkeletons.size(), 0u);
452
453   auto raw = resources.mShaders[0].first.LoadRaw(ctx.pathProvider(ResourceType::Shader));
454
455   TestApplication app;
456
457   auto shader = resources.mShaders[0].first.Load(std::move(raw));
458   DALI_TEST_EQUAL(shader.GetProperty(shader.GetPropertyIndex("uBool")).Get<float>(), 1.0f);
459   DALI_TEST_EQUAL(shader.GetProperty(shader.GetPropertyIndex("uInt")).Get<float>(), 255.0f);
460   DALI_TEST_EQUAL(shader.GetProperty(shader.GetPropertyIndex("uFloat")).Get<float>(), -0.5f);
461   DALI_TEST_EQUAL(shader.GetProperty(shader.GetPropertyIndex("uVec2")).Get<Vector2>(), Vector2(100.0f, -100.0f));
462   DALI_TEST_EQUAL(shader.GetProperty(shader.GetPropertyIndex("uVec3")).Get<Vector3>(), Vector3(50.0f, 0.f, -200.0f));
463   DALI_TEST_EQUAL(shader.GetProperty(shader.GetPropertyIndex("uVec4")).Get<Vector4>(), Vector4(0.1774f, 1.0f, 0.5333f, 0.7997f));
464   DALI_TEST_EQUAL(shader.GetProperty(shader.GetPropertyIndex("uMat3")).Get<Matrix3>(), Matrix3(9.0f, 8.0f, 7.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f));
465
466   Matrix expectedMatrix;
467   expectedMatrix.SetTransformComponents(Vector3::ONE * 8.0, Quaternion::IDENTITY, Vector3::ZERO);
468   DALI_TEST_EQUAL(shader.GetProperty(shader.GetPropertyIndex("uMat4")).Get<Matrix>(), expectedMatrix);
469
470   END_TEST;
471 }
472
473 int UtcDaliDliLoaderLoadSceneExtras(void)
474 {
475   Context ctx;
476
477   auto path = ctx.pathProvider(ResourceType::Mesh) + "dli/extras.dli";
478   DALI_TEST_CHECK(ctx.loader.LoadScene(path, ctx.loadParams));
479   DALI_TEST_EQUAL(ctx.errors.size(), 3u);
480   DALI_TEST_CHECK(ctx.errors[0].find("already defined; overriding") != std::string::npos);
481   DALI_TEST_CHECK(ctx.errors[1].find("empty string is invalid for name") != std::string::npos);
482   DALI_TEST_CHECK(ctx.errors[2].find("failed to interpret value") != std::string::npos);
483
484   auto& scene = ctx.scene;
485   auto& roots = scene.GetRoots();
486   DALI_TEST_EQUAL(roots.size(), 1u);
487   DALI_TEST_EQUAL(scene.GetNode(roots[0])->mName, "root");
488
489   DALI_TEST_EQUAL(scene.GetNodeCount(), 1u);
490
491   ViewProjection viewProjection;
492   Transforms     xforms{
493     MatrixStack{},
494     viewProjection};
495   auto&                        resources = ctx.resources;
496   NodeDefinition::CreateParams nodeParams{
497     resources,
498     xforms,
499   };
500
501   Customization::Choices choices;
502
503   TestApplication app;
504   Actor           actor = scene.CreateNodes(0, choices, nodeParams);
505
506   DALI_TEST_EQUAL(actor.GetProperty(actor.GetPropertyIndex("fudgeFactor")).Get<float>(), 9000.1f);
507   DALI_TEST_EQUAL(actor.GetProperty(actor.GetPropertyIndex("fudgeVector")).Get<Vector2>(), Vector2(-.25f, 17.f));
508   DALI_TEST_EQUAL(actor.GetProperty(actor.GetPropertyIndex("isThisTheRealLife")).Get<bool>(), true);
509   DALI_TEST_EQUAL(actor.GetProperty(actor.GetPropertyIndex("isThisJustFantasy")).Get<bool>(), false);
510   DALI_TEST_EQUAL(actor.GetProperty(actor.GetPropertyIndex("velocity")).Get<Vector3>(), Vector3(.1f, 58.f, -.2f));
511   DALI_TEST_EQUAL(actor.GetProperty(actor.GetPropertyIndex("frameOfReference")).Get<Matrix>(), Matrix::IDENTITY);
512
513   END_TEST;
514 }
515
516 int UtcDaliDliLoaderLoadSceneConstraints(void)
517 {
518   Context ctx;
519
520   auto path = ctx.pathProvider(ResourceType::Mesh) + "dli/constraints.dli";
521   DALI_TEST_CHECK(ctx.loader.LoadScene(path, ctx.loadParams));
522   DALI_TEST_EQUAL(ctx.errors.size(), 1u);
523   DALI_TEST_CHECK(ctx.errors[0].find("invalid", ctx.errors[0].find("node ID")) != std::string::npos);
524
525   auto& scene = ctx.scene;
526   auto& roots = scene.GetRoots();
527   DALI_TEST_EQUAL(roots.size(), 1u);
528   DALI_TEST_EQUAL(scene.GetNode(0)->mName, "root");
529   DALI_TEST_EQUAL(scene.GetNode(1)->mName, "Alice");
530   DALI_TEST_EQUAL(scene.GetNode(2)->mName, "Bob");
531   DALI_TEST_EQUAL(scene.GetNode(3)->mName, "Charlie");
532
533   DALI_TEST_EQUAL(scene.GetNodeCount(), 4u);
534
535   ViewProjection viewProjection;
536   Transforms     xforms{
537     MatrixStack{},
538     viewProjection};
539   auto&                        resources = ctx.resources;
540   NodeDefinition::CreateParams nodeParams{
541     resources,
542     xforms,
543   };
544
545   Customization::Choices choices;
546
547   TestApplication app;
548
549   Actor root    = scene.CreateNodes(0, choices, nodeParams);
550   Actor alice   = root.FindChildByName("Alice");
551   Actor bob     = root.FindChildByName("Bob");
552   Actor charlie = root.FindChildByName("Charlie");
553
554   DALI_TEST_EQUAL(nodeParams.mConstrainables.size(), 3u);
555   DALI_TEST_EQUAL(bob.GetProperty(bob.GetPropertyIndex("angularVelocity")).Get<Vector2>(), Vector2(-0.5, 0.0004));
556
557   ctx.errors.clear();
558   scene.ApplyConstraints(root, std::move(nodeParams.mConstrainables), ctx.onError);
559   DALI_TEST_CHECK(ctx.errors.empty());
560
561   app.GetScene().Add(root);
562   app.SendNotification();
563   app.Render();
564   app.SendNotification();
565   app.Render();
566
567   DALI_TEST_EQUAL(charlie.GetCurrentProperty(Actor::Property::ORIENTATION), alice.GetProperty(Actor::Property::ORIENTATION));
568   DALI_TEST_EQUAL(charlie.GetCurrentProperty(Actor::Property::POSITION), bob.GetProperty(Actor::Property::POSITION));
569   DALI_TEST_EQUAL(charlie.GetCurrentProperty(charlie.GetPropertyIndex("angularVelocity")), bob.GetProperty(bob.GetPropertyIndex("angularVelocity")));
570
571   END_TEST;
572 }
573
574 int UtcDaliDliLoaderNodeProcessor(void)
575 {
576   Context ctx;
577
578   std::vector<Property::Map> nodeMaps;
579   ctx.input.mNodePropertyProcessor = [&](const NodeDefinition&, Property::Map&& map, StringCallback) {
580     nodeMaps.push_back(map);
581   };
582
583   auto path = ctx.pathProvider(ResourceType::Mesh) + "dli/node-processor.dli";
584   DALI_TEST_CHECK(ctx.loader.LoadScene(path, ctx.loadParams));
585
586   DALI_TEST_EQUAL(nodeMaps.size(), 2u);
587   DALI_TEST_EQUAL(nodeMaps[0].Count(), 5u);
588   DALI_TEST_EQUAL(nodeMaps[0].Find("name")->Get<std::string>(), "rootA");
589   DALI_TEST_EQUAL(nodeMaps[0].Find("nickname")->Get<std::string>(), "same as name");
590   DALI_TEST_EQUAL(nodeMaps[0].Find("favourite number")->Get<int32_t>(), 63478);
591
592   auto propArray = nodeMaps[0].Find("array");
593   DALI_TEST_EQUAL(propArray->GetType(), Property::ARRAY);
594
595   auto array = propArray->GetArray();
596   DALI_TEST_EQUAL(array->Count(), 5);
597   DALI_TEST_EQUAL(array->GetElementAt(0).Get<int32_t>(), 1);
598   DALI_TEST_EQUAL(array->GetElementAt(1).Get<int32_t>(), 2);
599   DALI_TEST_EQUAL(array->GetElementAt(2).Get<int32_t>(), 4);
600   DALI_TEST_EQUAL(array->GetElementAt(3).Get<int32_t>(), 8);
601   DALI_TEST_EQUAL(array->GetElementAt(4).Get<int32_t>(), -500);
602
603   auto propObject = nodeMaps[0].Find("object");
604   DALI_TEST_EQUAL(propObject->GetType(), Property::MAP);
605
606   auto object = propObject->GetMap();
607   DALI_TEST_EQUAL(object->Count(), 5);
608   DALI_TEST_EQUAL(object->Find("physics")->Get<bool>(), true);
609   DALI_TEST_EQUAL(object->Find("elasticity")->Get<float>(), .27f);
610   DALI_TEST_EQUAL(object->Find("drag")->Get<float>(), .91f);
611
612   auto propInnerArray = object->Find("inner array");
613   DALI_TEST_EQUAL(propInnerArray->GetType(), Property::ARRAY);
614
615   auto innerArray = propInnerArray->GetArray();
616   DALI_TEST_EQUAL(innerArray->Count(), 3);
617   DALI_TEST_EQUAL(innerArray->GetElementAt(0).Get<std::string>(), "why");
618   DALI_TEST_EQUAL(innerArray->GetElementAt(1).Get<std::string>(), "not");
619   DALI_TEST_EQUAL(innerArray->GetElementAt(2).Get<bool>(), false);
620
621   auto propInnerObject = object->Find("inner object");
622   DALI_TEST_EQUAL(propInnerObject->GetType(), Property::MAP);
623
624   auto innerObject = propInnerObject->GetMap();
625   DALI_TEST_EQUAL(innerObject->Count(), 1);
626   DALI_TEST_EQUAL(innerObject->Find("supported")->Get<bool>(), true);
627
628   DALI_TEST_EQUAL(nodeMaps[1].Count(), 1u);
629   DALI_TEST_EQUAL(nodeMaps[1].Find("name")->Get<std::string>(), "rootB");
630
631   END_TEST;
632 }
633
634 int UtcDaliDliLoaderLoadCoverageTest(void)
635 {
636   Context ctx;
637
638   auto path = ctx.pathProvider(ResourceType::Mesh) + "coverageTest.dli";
639   DALI_TEST_CHECK(ctx.loader.LoadScene(path, ctx.loadParams));
640   DALI_TEST_CHECK(ctx.errors.empty());
641
642   auto& scene = ctx.scene;
643   auto& roots = scene.GetRoots();
644   DALI_TEST_EQUAL(roots.size(), 1u);
645   DALI_TEST_EQUAL(scene.GetNode(roots[0])->mName, "root");
646
647   DALI_TEST_EQUAL(scene.GetNodeCount(), 1u);
648
649   auto& resources = ctx.resources;
650   DALI_TEST_EQUAL(resources.mMeshes.size(), 1u);
651   DALI_TEST_EQUAL(resources.mShaders.size(), 1u);
652   DALI_TEST_EQUAL(resources.mEnvironmentMaps.size(), 2u);
653   DALI_TEST_EQUAL(resources.mSkeletons.size(), 0u);
654
655   auto& materials = ctx.resources.mMaterials;
656   DALI_TEST_EQUAL(2u, materials.size());
657
658   auto  iMaterial = materials.begin();
659   auto& md        = iMaterial->first;
660   DALI_TEST_EQUAL(md.mTextureStages.size(), 1u);
661
662   auto iTexture = md.mTextureStages.begin();
663   DALI_TEST_CHECK(MaskMatch(iTexture->mSemantic, MaterialDefinition::OCCLUSION));
664   DALI_TEST_EQUAL(iTexture->mTexture.mImageUri, "exercise/Icons/Icon_Idle.png");
665   ++iTexture;
666
667   DALI_TEST_EQUAL(ctx.cameraParameters.size(), 1u);
668   DALI_TEST_EQUAL(ctx.lights.size(), 1u);
669   DALI_TEST_EQUAL(ctx.animations.size(), 0u);
670   DALI_TEST_EQUAL(ctx.animGroups.size(), 0u);
671
672   ViewProjection viewProjection;
673   Transforms     xforms{
674     MatrixStack{},
675     viewProjection};
676   NodeDefinition::CreateParams nodeParams{
677     resources,
678     xforms,
679   };
680
681   Customization::Choices choices;
682
683   TestApplication app;
684
685   Actor root = Actor::New();
686   SetActorCentered(root);
687   for(auto iRoot : scene.GetRoots())
688   {
689     auto resourceRefs = resources.CreateRefCounter();
690     scene.CountResourceRefs(iRoot, choices, resourceRefs);
691     resources.CountEnvironmentReferences(resourceRefs);
692     resources.LoadResources(resourceRefs, ctx.pathProvider);
693     if(auto actor = scene.CreateNodes(iRoot, choices, nodeParams))
694     {
695       scene.ConfigureSkeletonJoints(iRoot, resources.mSkeletons, actor);
696       scene.ConfigureSkinningShaders(resources, actor, std::move(nodeParams.mSkinnables));
697       ConfigureBlendShapeShaders(resources, scene, actor, std::move(nodeParams.mBlendshapeRequests));
698       scene.ApplyConstraints(actor, std::move(nodeParams.mConstrainables));
699       root.Add(actor);
700     }
701   }
702
703   DALI_TEST_EQUAL(root.GetChildCount(), 1u);
704   DALI_TEST_EQUAL(root.GetChildAt(0).GetProperty(Actor::Property::NAME).Get<std::string>(), "root");
705
706   END_TEST;
707 }