dali-scene3d/public-api/loader/dli-loader.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 // CLASS HEADER
  19 #include "dali-scene3d/public-api/loader/dli-loader.h"
  20
  21 // EXTERNAL INCLUDES
  22 #include <algorithm>
  23 #include <cmath>
  24 #include <fstream>
  25 #include <limits>
  26 #include <memory>
  27 #include "dali-toolkit/devel-api/builder/json-parser.h"
  28 #include "dali/devel-api/common/map-wrapper.h"
  29 #include "dali/integration-api/debug.h"
  30 #include "dali/public-api/object/property-array.h"
  31
  32 // INTERNAL INCLUDES
  33 #include "dali-scene3d/internal/loader/json-util.h"
  34 #include "dali-scene3d/public-api/loader/alpha-function-helper.h"
  35 #include "dali-scene3d/public-api/loader/animation-definition.h"
  36 #include "dali-scene3d/public-api/loader/blend-shape-details.h"
  37 #include "dali-scene3d/public-api/loader/camera-parameters.h"
  38 #include "dali-scene3d/public-api/loader/ktx-loader.h"
  39 #include "dali-scene3d/public-api/loader/light-parameters.h"
  40 #include "dali-scene3d/public-api/loader/load-result.h"
  41 #include "dali-scene3d/public-api/loader/parse-renderer-state.h"
  42 #include "dali-scene3d/public-api/loader/scene-definition.h"
  43 #include "dali-scene3d/public-api/loader/skinning-details.h"
  44 #include "dali-scene3d/public-api/loader/utils.h"
  45
  46 #define DLI_0_1_COMPATIBILITY
  47
  48 namespace Dali
  49 {
  50 using namespace Toolkit;
  51
  52 namespace Scene3D
  53 {
  54 namespace Loader
  55 {
  56 namespace rs = RendererState;
  57
  58 namespace
  59 {
  60 const std::string NODES         = "nodes";
  61 const std::string SCENES        = "scenes";
  62 const std::string NODE          = "node";
  63 const std::string URI           = "uri";
  64 const std::string URL           = "url";
  65 const std::string CUSTOMIZATION = "customization";
  66 const std::string HINTS         = "hints";
  67 const std::string NAME("name");
  68 const std::string BLEND_SHAPE_HEADER("blendShapeHeader");
  69 const std::string BLEND_SHAPES("blendShapes");
  70 const std::string BLEND_SHAPE_VERSION_1_0("1.0");
  71 const std::string BLEND_SHAPE_VERSION_2_0("2.0");
  72 const std::string VERSION("version");
  73
  74 const char* const SHADOW_MAP_SIZE   = "shadowMapSize";
  75 const char* const ORTHOGRAPHIC_SIZE = "orthographicSize";
  76 const char* const PIXEL_UNITS       = "px";
  77
  78 const char SLASH = '/';
  79
  80 void ReadModelTransform(const TreeNode* node, Quaternion& orientation, Vector3& translation, Vector3& scale)
  81 {
  82   float num[16u] = {.0f};
  83
  84   if(ReadVector(node->GetChild("matrix"), num, 16u))
  85   {
  86     Matrix mat(num);
  87     mat.GetTransformComponents(translation, orientation, scale);
  88   }
  89   else
  90   {
  91     if(ReadVector(node->GetChild("angle"), num, 3u))
  92     {
  93       orientation = Quaternion(Radian(Degree(num[0u])), Radian(Degree(num[1u])), Radian(Degree(num[2u])));
  94     }
  95
  96     if(ReadVector(node->GetChild("position"), num, 3u))
  97     {
  98       translation = Vector3(num);
  99     }
 100   }
 101 }
 102
 103 bool ReadAttribBlob(const TreeNode* node, MeshDefinition::Blob& buffer)
 104 {
 105   return ReadBlob(node, buffer.mOffset, buffer.mLength);
 106 }
 107
 108 bool ReadAttribAccessor(const TreeNode* node, MeshDefinition::Accessor& accessor)
 109 {
 110   return ReadBlob(node, accessor.mBlob.mOffset, accessor.mBlob.mLength);
 111 }
 112
 113 bool ReadColorCode(const TreeNode* node, Vector4& color, DliLoader::ConvertColorCode convertColorCode)
 114 {
 115   if(!node || !convertColorCode)
 116   {
 117     return false;
 118   }
 119
 120   color = convertColorCode(node->GetString());
 121
 122   return true;
 123 }
 124
 125 bool ReadColorCodeOrColor(const TreeNode* node, Vector4& color, DliLoader::ConvertColorCode convertColorCode)
 126 {
 127   return ReadColorCode(node->GetChild("colorCode"), color, convertColorCode) ||
 128          ReadColor(node->GetChild("color"), color);
 129 }
 130
 131 RendererState::Type ReadRendererState(const TreeNode& tnRendererState)
 132 {
 133   if(tnRendererState.GetType() == TreeNode::INTEGER)
 134   {
 135     return static_cast<RendererState::Type>(tnRendererState.GetInteger());
 136   }
 137   else if(tnRendererState.GetType() == TreeNode::STRING)
 138   {
 139     return RendererState::Parse(tnRendererState.GetString());
 140   }
 141   else
 142   {
 143     return -1;
 144   }
 145 }
 146
 147 ///@brief Reads arc properties.
 148 void ReadArcField(const TreeNode* eArc, ArcNode& arc)
 149 {
 150   ReadBool(eArc->GetChild("antiAliasing"), arc.mAntiAliasing);
 151   ReadInt(eArc->GetChild("arcCaps"), arc.mArcCaps);
 152   ReadFloat(eArc->GetChild("radius"), arc.mRadius);
 153
 154   arc.mStartAngleDegrees = .0f;
 155   ReadFloat(eArc->GetChild("startAngle"), arc.mStartAngleDegrees);
 156
 157   arc.mEndAngleDegrees = .0f;
 158   ReadFloat(eArc->GetChild("endAngle"), arc.mEndAngleDegrees);
 159 }
 160
 161 const TreeNode* GetNthChild(const TreeNode* node, uint32_t index)
 162 {
 163   uint32_t i = 0;
 164   for(TreeNode::ConstIterator it = (*node).CBegin(); it != (*node).CEnd(); ++it, ++i)
 165   {
 166     if(i == index)
 167     {
 168       return &((*it).second);
 169     }
 170   }
 171   return NULL;
 172 }
 173
 174 const TreeNode* RequireChild(const TreeNode* node, const std::string& childName)
 175 {
 176   auto child = node->GetChild(childName);
 177   if(!child)
 178   {
 179     ExceptionFlinger flinger(ASSERT_LOCATION);
 180     flinger << "Failed to find child node '" << childName << "'";
 181     if(auto nodeName = node->GetName())
 182     {
 183       flinger << " on '" << nodeName << "'";
 184     }
 185     flinger << ".";
 186   }
 187   return child;
 188 }
 189
 190 void ParseProperties(const Toolkit::TreeNode& node, Property::Array& array);
 191
 192 void ParseProperties(const Toolkit::TreeNode& node, Property::Map& map)
 193 {
 194   DALI_ASSERT_DEBUG(node.GetType() == TreeNode::OBJECT);
 195   for(auto i0 = node.CBegin(), i1 = node.CEnd(); i0 != i1; ++i0)
 196   {
 197     auto kv = *i0;
 198     switch(kv.second.GetType())
 199     {
 200       case TreeNode::ARRAY:
 201       {
 202         Property::Array array;
 203         ParseProperties(kv.second, array);
 204         map.Insert(kv.first, array);
 205         break;
 206       }
 207
 208       case TreeNode::OBJECT:
 209       {
 210         Property::Map innerMap;
 211         ParseProperties(kv.second, innerMap);
 212         map.Insert(kv.first, innerMap);
 213         break;
 214       }
 215
 216       case TreeNode::STRING:
 217       {
 218         map.Insert(kv.first, kv.second.GetString());
 219         break;
 220       }
 221
 222       case TreeNode::INTEGER:
 223       {
 224         map.Insert(kv.first, kv.second.GetInteger());
 225         break;
 226       }
 227
 228       case TreeNode::BOOLEAN:
 229       {
 230         map.Insert(kv.first, kv.second.GetBoolean());
 231         break;
 232       }
 233
 234       case TreeNode::FLOAT:
 235       {
 236         map.Insert(kv.first, kv.second.GetFloat());
 237         break;
 238       }
 239
 240       case TreeNode::IS_NULL:
 241       {
 242         break;
 243       }
 244     }
 245   }
 246 }
 247
 248 void ParseProperties(const Toolkit::TreeNode& node, Property::Array& array)
 249 {
 250   DALI_ASSERT_DEBUG(node.GetType() == TreeNode::ARRAY);
 251   for(auto i0 = node.CBegin(), i1 = node.CEnd(); i0 != i1; ++i0)
 252   {
 253     auto kv = *i0;
 254     switch(kv.second.GetType())
 255     {
 256       case TreeNode::ARRAY:
 257       {
 258         Property::Array innerArray;
 259         ParseProperties(kv.second, innerArray);
 260         array.PushBack(innerArray);
 261         break;
 262       }
 263
 264       case TreeNode::OBJECT:
 265       {
 266         Property::Map map;
 267         ParseProperties(kv.second, map);
 268         array.PushBack(map);
 269         break;
 270       }
 271
 272       case TreeNode::STRING:
 273       {
 274         array.PushBack(kv.second.GetString());
 275         break;
 276       }
 277
 278       case TreeNode::INTEGER:
 279       {
 280         array.PushBack(kv.second.GetInteger());
 281         break;
 282       }
 283
 284       case TreeNode::BOOLEAN:
 285       {
 286         array.PushBack(kv.second.GetBoolean());
 287         break;
 288       }
 289
 290       case TreeNode::FLOAT:
 291       {
 292         array.PushBack(kv.second.GetFloat());
 293         break;
 294       }
 295
 296       case TreeNode::IS_NULL:
 297       {
 298         break;
 299       }
 300     }
 301   }
 302 }
 303
 304 } //namespace
 305
 306 struct DliLoader::Impl
 307 {
 308   StringCallback      mOnError = DefaultErrorCallback;
 309   Toolkit::JsonParser mParser;
 310
 311   void ParseScene(LoadParams& params);
 312
 313 private:
 314   std::map<Index, Matrix> mInverseBindMatrices;
 315
 316   /**
 317    * @brief Due to .dli nodes being processed in depth-first traversal with orphans being
 318    *  ignored, features that rely on node indices (which is more compact and closer to
 319    *  glTF) require a mapping from .dli node indices to those in the resulting SceneDefinition.
 320    *  The index mapper is responsible for maintaing this mapping, and resolving node IDs
 321    *  once the processing of the nodes has finished.
 322    * @note The resolution requires the whole scene graph to finish parsing, therefore any
 323    *  node extensions relying on node IDs will see the dli ID in their processor.
 324    */
 325   struct IIndexMapper
 326   {
 327     /**
 328      * @brief Attempts to create a mapping from a node's @a dli index to its @a scene
 329      *  index.
 330      * @return Whether the operation was successful.
 331      */
 332     virtual bool Map(Index iDli, Index iScene) = 0;
 333
 334     /**
 335      * @return The scene index for the node's @a dli index.
 336      */
 337     virtual Index Resolve(Index iDli) = 0;
 338   };
 339
 340   /**
 341    * @brief Traverses the DOM tree created by LoadDocument() in an attempt to create
 342    *  an intermediate representation of resources and nodes.
 343    */
 344   void ParseSceneInternal(Index iScene, const Toolkit::TreeNode* tnScenes, const Toolkit::TreeNode* tnNodes, LoadParams& params);
 345
 346   void ParseSkeletons(const Toolkit::TreeNode* skeletons, SceneDefinition& scene, ResourceBundle& resources);
 347   void ParseEnvironments(const Toolkit::TreeNode* environments, ResourceBundle& resources);
 348   void ParseMaterials(const Toolkit::TreeNode* materials, ConvertColorCode convertColorCode, ResourceBundle& resources);
 349
 350   void ParseNodes(const Toolkit::TreeNode* nodes, Index index, LoadParams& params);
 351   void ParseNodesInternal(const Toolkit::TreeNode* nodes, Index index, std::vector<Index>& inOutParentStack, LoadParams& params, IIndexMapper& indexMapper);
 352
 353   void ParseAnimations(const Toolkit::TreeNode* animations, LoadParams& params);
 354   void ParseAnimationGroups(const Toolkit::TreeNode* animationGroups, LoadParams& params);
 355
 356   void ParseShaders(const Toolkit::TreeNode* shaders, ResourceBundle& resources);
 357   void ParseMeshes(const Toolkit::TreeNode* meshes, ResourceBundle& resources);
 358
 359   void GetCameraParameters(std::vector<CameraParameters>& cameras) const;
 360   void GetLightParameters(std::vector<LightParameters>& lights) const;
 361 };
 362
 363 DliLoader::DliLoader()
 364 : mImpl{new Impl}
 365 {
 366 }
 367
 368 DliLoader::~DliLoader() = default;
 369
 370 void DliLoader::SetErrorCallback(StringCallback onError)
 371 {
 372   mImpl->mOnError = onError;
 373 }
 374
 375 bool DliLoader::LoadScene(const std::string& uri, LoadParams& params)
 376 {
 377   std::string daliBuffer = LoadTextFile(uri.c_str());
 378
 379   auto& parser = mImpl->mParser;
 380   parser       = JsonParser::New();
 381   if(!parser.Parse(daliBuffer))
 382   {
 383     return false;
 384   }
 385
 386   mImpl->ParseScene(params);
 387   return true;
 388 }
 389
 390 std::string DliLoader::GetParseError() const
 391 {
 392   std::stringstream stream;
 393
 394   auto& parser = mImpl->mParser;
 395   if(parser.ParseError())
 396   {
 397     stream << "position: " << parser.GetErrorPosition() << ", line: " << parser.GetErrorLineNumber() << ", column: " << parser.GetErrorColumn() << ", description: " << parser.GetErrorDescription() << ".";
 398   }
 399
 400   return stream.str();
 401 }
 402
 403 void DliLoader::Impl::ParseScene(LoadParams& params)
 404 {
 405   auto& input  = params.input;
 406   auto& output = params.output;
 407
 408   // get index of root node.
 409   auto docRoot = mParser.GetRoot();
 410   if(docRoot)
 411   {
 412     // Process resources first - these are shared
 413     if(auto environments = docRoot->GetChild("environment"))
 414     {
 415       ParseEnvironments(environments, output.mResources); // NOTE: must precede parsing of materials
 416     }
 417
 418     if(auto meshes = docRoot->GetChild("meshes"))
 419     {
 420       ParseMeshes(meshes, output.mResources);
 421     }
 422
 423     if(auto shaders = docRoot->GetChild("shaders"))
 424     {
 425       ParseShaders(shaders, output.mResources);
 426     }
 427
 428     if(auto materials = docRoot->GetChild("materials"))
 429     {
 430       ParseMaterials(materials, input.mConvertColorCode, output.mResources);
 431     }
 432
 433     for(auto& c : input.mPreNodeCategoryProcessors)
 434     {
 435       if(auto node = docRoot->GetChild(c.first))
 436       {
 437         Property::Array array;
 438         ParseProperties(*node, array);
 439         c.second(std::move(array), mOnError);
 440       }
 441     }
 442
 443     // Process scenes
 444     Index iScene = 0; // default scene
 445     ReadIndex(docRoot->GetChild("scene"), iScene);
 446
 447     auto tnScenes = RequireChild(docRoot, "scenes");
 448     auto tnNodes  = RequireChild(docRoot, "nodes");
 449     ParseSceneInternal(iScene, tnScenes, tnNodes, params);
 450
 451     ParseSkeletons(docRoot->GetChild("skeletons"), output.mScene, output.mResources);
 452
 453     output.mScene.EnsureUniqueSkinningShaderInstances(output.mResources);
 454     output.mScene.EnsureUniqueBlendShapeShaderInstances(output.mResources);
 455
 456     // Ger cameras and lights
 457     GetCameraParameters(output.mCameraParameters);
 458     GetLightParameters(output.mLightParameters);
 459
 460     // Post-node processors and animations last
 461     for(auto& c : input.mPostNodeCategoryProcessors)
 462     {
 463       if(auto node = docRoot->GetChild(c.first))
 464       {
 465         Property::Array array;
 466         ParseProperties(*node, array);
 467         c.second(std::move(array), mOnError);
 468       }
 469     }
 470
 471     if(auto animations = docRoot->GetChild("animations"))
 472     {
 473       ParseAnimations(animations, params);
 474     }
 475
 476     if(!output.mAnimationDefinitions.empty())
 477     {
 478       if(auto animationGroups = docRoot->GetChild("animationGroups"))
 479       {
 480         ParseAnimationGroups(animationGroups, params);
 481       }
 482     }
 483   }
 484 }
 485
 486 void DliLoader::Impl::ParseSceneInternal(Index iScene, const Toolkit::TreeNode* tnScenes, const Toolkit::TreeNode* tnNodes, LoadParams& params)
 487 {
 488   auto getSceneRootIdx = [tnScenes, tnNodes](Index iScene)
 489   {
 490     auto tn = GetNthChild(tnScenes, iScene); // now a "scene" object
 491     if(!tn)
 492     {
 493       ExceptionFlinger(ASSERT_LOCATION) << iScene << " is out of bounds access into " << SCENES << ".";
 494     }
 495
 496     tn = RequireChild(tn, NODES); // now a "nodes" array
 497     if(tn->GetType() != TreeNode::ARRAY)
 498     {
 499       ExceptionFlinger(ASSERT_LOCATION) << SCENES << "[" << iScene << "]." << NODES << " has an invalid type; array required.";
 500     }
 501
 502     if(tn->Size() < 1)
 503     {
 504       ExceptionFlinger(ASSERT_LOCATION) << SCENES << "[" << iScene << "]." << NODES << " must define a node id.";
 505     }
 506
 507     tn = GetNthChild(tn, 0); // now the first element of the array
 508     Index iRootNode;
 509     if(!ReadIndex(tn, iRootNode))
 510     {
 511       ExceptionFlinger(ASSERT_LOCATION) << SCENES << "[" << iScene << "]." << NODES << " has an invalid value for root node index: '" << iRootNode << "'.";
 512     }
 513
 514     if(iRootNode >= tnNodes->Size())
 515     {
 516       ExceptionFlinger(ASSERT_LOCATION) << "Root node index << " << iRootNode << " of scene " << iScene << " is out of bounds.";
 517     }
 518
 519     tn = GetNthChild(tnNodes, iRootNode); // now a "node" object
 520     if(tn->GetType() != TreeNode::OBJECT)
 521     {
 522       ExceptionFlinger(ASSERT_LOCATION) << "Root node of scene " << iScene << " is of invalid JSON type; object required";
 523     }
 524
 525     return iRootNode;
 526   };
 527
 528   Index iRootNode = getSceneRootIdx(iScene);
 529   ParseNodes(tnNodes, iRootNode, params);
 530
 531   auto& scene = params.output.mScene;
 532   scene.AddRootNode(0);
 533
 534   for(Index i = 0; i < iScene; ++i)
 535   {
 536     Index       iRootNode = getSceneRootIdx(i);
 537     const Index iRoot     = scene.GetNodeCount();
 538     ParseNodes(tnNodes, iRootNode, params);
 539     scene.AddRootNode(iRoot);
 540   }
 541
 542   auto numScenes = tnScenes->Size();
 543   for(Index i = iScene + 1; i < numScenes; ++i)
 544   {
 545     Index       iRootNode = getSceneRootIdx(i);
 546     const Index iRoot     = scene.GetNodeCount();
 547     ParseNodes(tnNodes, iRootNode, params);
 548     scene.AddRootNode(iRoot);
 549   }
 550 }
 551
 552 void DliLoader::Impl::ParseSkeletons(const TreeNode* skeletons, SceneDefinition& scene, ResourceBundle& resources)
 553 {
 554   if(skeletons)
 555   {
 556     auto iStart = skeletons->CBegin();
 557     for(auto i0 = iStart, i1 = skeletons->CEnd(); i0 != i1; ++i0)
 558     {
 559       auto&       node = (*i0).second;
 560       std::string skeletonRootName;
 561       if(ReadString(node.GetChild(NODE), skeletonRootName))
 562       {
 563         SkeletonDefinition skeleton;
 564         if(!scene.FindNode(skeletonRootName, &skeleton.mRootNodeIdx))
 565         {
 566           ExceptionFlinger(ASSERT_LOCATION) << FormatString("Skeleton %d: node '%s' not defined.", resources.mSkeletons.size(), skeletonRootName.c_str());
 567         }
 568
 569         uint32_t                   jointCount = 0;
 570         std::function<void(Index)> visitFn;
 571         auto&                      ibms = mInverseBindMatrices;
 572         visitFn                         = [&](Index id) {
 573           auto node = scene.GetNode(id);
 574           jointCount += ibms.find(id) != ibms.end();
 575
 576           for(auto i : node->mChildren)
 577           {
 578             visitFn(i);
 579           }
 580         };
 581         visitFn(skeleton.mRootNodeIdx);
 582
 583         if(jointCount > Skinning::MAX_JOINTS)
 584         {
 585           mOnError(FormatString("Skeleton %d: joint count exceeds supported limit.", resources.mSkeletons.size()));
 586           jointCount = Skinning::MAX_JOINTS;
 587         }
 588
 589         skeleton.mJoints.reserve(jointCount);
 590
 591         visitFn = [&](Index id) {
 592           auto iFind = ibms.find(id);
 593           if(iFind != ibms.end() && skeleton.mJoints.size() < Skinning::MAX_JOINTS)
 594           {
 595             skeleton.mJoints.push_back({id, iFind->second});
 596           }
 597
 598           auto node = scene.GetNode(id);
 599           for(auto i : node->mChildren)
 600           {
 601             visitFn(i);
 602           }
 603         };
 604         visitFn(skeleton.mRootNodeIdx);
 605
 606         resources.mSkeletons.push_back(std::move(skeleton));
 607       }
 608       else
 609       {
 610         ExceptionFlinger(ASSERT_LOCATION) << "skeleton " << std::distance(iStart, i0) << ": Missing required attribute '" << NODE << "'.";
 611       }
 612     }
 613   }
 614 }
 615
 616 void DliLoader::Impl::ParseEnvironments(const TreeNode* environments, ResourceBundle& resources)
 617 {
 618   Matrix cubeOrientation(Matrix::IDENTITY);
 619
 620   for(auto i0 = environments->CBegin(), i1 = environments->CEnd(); i0 != i1; ++i0)
 621   {
 622     auto& node = (*i0).second;
 623
 624     EnvironmentDefinition envDef;
 625     ReadString(node.GetChild("cubeSpecular"), envDef.mSpecularMapPath);
 626     ReadString(node.GetChild("cubeDiffuse"), envDef.mDiffuseMapPath);
 627     ToUnixFileSeparators(envDef.mSpecularMapPath);
 628     ToUnixFileSeparators(envDef.mDiffuseMapPath);
 629     envDef.mIblIntensity = 1.0f;
 630     ReadFloat(node.GetChild("iblIntensity"), envDef.mIblIntensity);
 631     if(ReadVector(node.GetChild("cubeInitialOrientation"), cubeOrientation.AsFloat(), 16u))
 632     {
 633       envDef.mCubeOrientation = Quaternion(cubeOrientation);
 634     }
 635
 636     resources.mEnvironmentMaps.emplace_back(std::move(envDef), EnvironmentDefinition::Textures());
 637   }
 638
 639   // NOTE: guarantees environmentMaps to have an empty environment.
 640   if(resources.mEnvironmentMaps.empty())
 641   {
 642     resources.mEnvironmentMaps.emplace_back(EnvironmentDefinition(), EnvironmentDefinition::Textures());
 643   }
 644 }
 645
 646 void DliLoader::Impl::ParseShaders(const TreeNode* shaders, ResourceBundle& resources)
 647 {
 648   uint32_t iShader = 0;
 649   for(auto i0 = shaders->CBegin(), i1 = shaders->CEnd(); i0 != i1; ++i0, ++iShader)
 650   {
 651     auto&            node = (*i0).second;
 652     ShaderDefinition shaderDef;
 653     ReadStringVector(node.GetChild("defines"), shaderDef.mDefines);
 654
 655     // Read shader hints. Possible values are:
 656     //                         Don't define for No hints.
 657     // "OUTPUT_IS_TRANSPARENT" Might generate transparent alpha from opaque inputs.
 658     //     "MODIFIES_GEOMETRY" Might change position of vertices, this option disables any culling optimizations.
 659
 660     ReadStringVector(node.GetChild(HINTS), shaderDef.mHints);
 661
 662     if(ReadString(node.GetChild("vertex"), shaderDef.mVertexShaderPath) &&
 663        ReadString(node.GetChild("fragment"), shaderDef.mFragmentShaderPath))
 664     {
 665       ToUnixFileSeparators(shaderDef.mVertexShaderPath);
 666       ToUnixFileSeparators(shaderDef.mFragmentShaderPath);
 667
 668       for(TreeNode::ConstIterator j0 = node.CBegin(), j1 = node.CEnd(); j0 != j1; ++j0)
 669       {
 670         const TreeNode::KeyNodePair& keyValue = *j0;
 671         const std::string&           key      = keyValue.first;
 672         const TreeNode&              value    = keyValue.second;
 673
 674         Property::Value uniformValue;
 675         if(key.compare("vertex") == 0 || key.compare("fragment") == 0 || key.compare("defines") == 0 || key.compare(HINTS) == 0)
 676         {
 677           continue;
 678         }
 679         else if(key.compare("rendererState") == 0)
 680         {
 681           shaderDef.mRendererState = ReadRendererState(keyValue.second);
 682         }
 683         else if(value.GetType() == TreeNode::INTEGER || value.GetType() == TreeNode::FLOAT)
 684         {
 685           float f = 0.f;
 686           ReadFloat(&value, f);
 687           uniformValue = f;
 688         }
 689         else if(value.GetType() == TreeNode::BOOLEAN)
 690         {
 691           DALI_LOG_WARNING("\"bool\" uniforms are handled as floats in shader");
 692           bool value = false;
 693           if(ReadBool(&keyValue.second, value))
 694           {
 695             uniformValue = value ? 1.0f : 0.0f;
 696           }
 697         }
 698         else
 699           switch(auto size = GetNumericalArraySize(&value))
 700           {
 701             case 16:
 702             {
 703               Matrix m;
 704               ReadVector(&value, m.AsFloat(), size);
 705               uniformValue = m;
 706               break;
 707             }
 708
 709             case 9:
 710             {
 711               Matrix3 m;
 712               ReadVector(&value, m.AsFloat(), size);
 713               uniformValue = m;
 714               break;
 715             }
 716
 717             case 4:
 718             {
 719               Vector4 v;
 720               ReadVector(&value, v.AsFloat(), size);
 721               uniformValue = v;
 722               break;
 723             }
 724
 725             case 3:
 726             {
 727               Vector3 v;
 728               ReadVector(&value, v.AsFloat(), size);
 729               uniformValue = v;
 730               break;
 731             }
 732
 733             case 2:
 734             {
 735               Vector2 v;
 736               ReadVector(&value, v.AsFloat(), size);
 737               uniformValue = v;
 738               break;
 739             }
 740
 741             default:
 742               mOnError(FormatString(
 743                 "shader %d: Ignoring uniform '%s': failed to infer type from %d elements.",
 744                 iShader,
 745                 key.c_str()));
 746               break;
 747           }
 748
 749         if(Property::NONE != uniformValue.GetType())
 750         {
 751           shaderDef.mUniforms.Insert(key, uniformValue);
 752         }
 753       }
 754
 755       resources.mShaders.emplace_back(std::move(shaderDef), Shader());
 756     }
 757     else
 758     {
 759       ExceptionFlinger(ASSERT_LOCATION) << "shader " << iShader << ": Missing vertex / fragment shader definition.";
 760     }
 761   }
 762 }
 763
 764 void DliLoader::Impl::ParseMeshes(const TreeNode* meshes, ResourceBundle& resources)
 765 {
 766   for(auto i0 = meshes->CBegin(), i1 = meshes->CEnd(); i0 != i1; ++i0)
 767   {
 768     auto& node = (*i0).second;
 769
 770     MeshDefinition meshDef;
 771     if(!ReadString(node.GetChild(URI), meshDef.mUri))
 772     {
 773       ExceptionFlinger(ASSERT_LOCATION) << "mesh " << resources.mMeshes.size() << ": Missing required attribute '" << URI << "'.";
 774     }
 775
 776     ToUnixFileSeparators(meshDef.mUri);
 777
 778     std::string primitive;
 779     if(ReadString(node.GetChild("primitive"), primitive))
 780     {
 781       if(primitive == "LINES")
 782       {
 783         meshDef.mPrimitiveType = Geometry::LINES;
 784       }
 785       else if(primitive == "POINTS")
 786       {
 787         meshDef.mPrimitiveType = Geometry::POINTS;
 788       }
 789       else if(primitive != "TRIANGLES")
 790       {
 791         mOnError(FormatString(
 792           "mesh %d: Using TRIANGLES instead of unsupported primitive type '%s'.",
 793           resources.mMeshes.size(),
 794           primitive.c_str()));
 795       }
 796     }
 797
 798     int attributes;
 799     if(ReadInt(node.GetChild("attributes"), attributes))
 800     {
 801       if(MaskMatch(attributes, MeshDefinition::INDICES) &&
 802          !ReadAttribAccessor(node.GetChild("indices"), meshDef.mIndices))
 803       {
 804         ExceptionFlinger(ASSERT_LOCATION) << FormatString("mesh %d: Failed to read %s.",
 805                                                           resources.mMeshes.size(),
 806                                                           "indices");
 807       }
 808
 809       if(MaskMatch(attributes, MeshDefinition::POSITIONS) &&
 810          !ReadAttribAccessor(node.GetChild("positions"), meshDef.mPositions))
 811       {
 812         ExceptionFlinger(ASSERT_LOCATION) << FormatString("mesh %d: Failed to read %s.",
 813                                                           resources.mMeshes.size(),
 814                                                           "positions");
 815       }
 816
 817       if(MaskMatch(attributes, MeshDefinition::NORMALS) &&
 818          !ReadAttribAccessor(node.GetChild("normals"), meshDef.mNormals))
 819       {
 820         mOnError(FormatString("mesh %d: Failed to read %s.", resources.mMeshes.size(), "normals"));
 821       }
 822
 823       if(MaskMatch(attributes, MeshDefinition::TEX_COORDS) &&
 824          !ReadAttribAccessor(node.GetChild("textures"), meshDef.mTexCoords))
 825       {
 826         mOnError(FormatString("mesh %d: Failed to read %s.", resources.mMeshes.size(), "textures"));
 827       }
 828
 829       if(MaskMatch(attributes, MeshDefinition::TANGENTS) &&
 830          !ReadAttribAccessor(node.GetChild("tangents"), meshDef.mTangents))
 831       {
 832         mOnError(FormatString("mesh %d: Failed to read %s.", resources.mMeshes.size(), "tangents"));
 833       }
 834
 835       // NOTE: we're no longer reading bitangents as these are calculated in the shaders.
 836       if(ReadIndex(node.GetChild("skeleton"), meshDef.mSkeletonIdx))
 837       {
 838         if(!MaskMatch(attributes, MeshDefinition::JOINTS_0) &&
 839            !MaskMatch(attributes, MeshDefinition::WEIGHTS_0))
 840         {
 841           mOnError(FormatString("mesh %d: Expected joints0 / weights0 attribute(s) missing.",
 842                                 resources.mMeshes.size()));
 843         }
 844         else if(!ReadAttribAccessor(node.GetChild("joints0"), meshDef.mJoints0) ||
 845                 !ReadAttribAccessor(node.GetChild("weights0"), meshDef.mWeights0))
 846         {
 847           mOnError(FormatString("mesh %d: Failed to read skinning information.",
 848                                 resources.mMeshes.size()));
 849         }
 850       }
 851
 852       if(auto blendshapeHeader = node.GetChild(BLEND_SHAPE_HEADER))
 853       {
 854         std::string blendShapeVersion;
 855         ReadString(blendshapeHeader->GetChild(VERSION), blendShapeVersion);
 856
 857         if(0u == blendShapeVersion.compare(BLEND_SHAPE_VERSION_1_0))
 858         {
 859           meshDef.mBlendShapeVersion = BlendShapes::Version::VERSION_1_0;
 860         }
 861         else if(0u == blendShapeVersion.compare(BLEND_SHAPE_VERSION_2_0))
 862         {
 863           meshDef.mBlendShapeVersion = BlendShapes::Version::VERSION_2_0;
 864         }
 865
 866         switch(meshDef.mBlendShapeVersion)
 867         {
 868           case BlendShapes::Version::VERSION_1_0:
 869           case BlendShapes::Version::VERSION_2_0: // FALL THROUGH
 870           {
 871             ReadAttribBlob(blendshapeHeader, meshDef.mBlendShapeHeader);
 872             break;
 873           }
 874           default:
 875           {
 876             // nothing to do
 877             break;
 878           }
 879         }
 880       }
 881
 882       if(auto blendShapes = node.GetChild(BLEND_SHAPES))
 883       {
 884         meshDef.mBlendShapes.resize(blendShapes->Size());
 885
 886         auto index = 0u;
 887         for(auto it = blendShapes->CBegin(), endIt = blendShapes->CEnd(); it != endIt; ++it, ++index)
 888         {
 889           // Each blend shape is stored as the difference with the original mesh.
 890
 891           auto& blendShapeNode = (*it).second;
 892
 893           auto& blendShape = meshDef.mBlendShapes[index];
 894           ReadString(blendShapeNode.GetChild("name"), blendShape.name);
 895           if(auto position = blendShapeNode.GetChild("positions"))
 896           {
 897             ReadAttribAccessor(position, blendShape.deltas);
 898           }
 899           if(auto normals = blendShapeNode.GetChild("normals"))
 900           {
 901             ReadAttribAccessor(normals, blendShape.normals);
 902           }
 903           if(auto tangents = blendShapeNode.GetChild("tangents"))
 904           {
 905             ReadAttribAccessor(tangents, blendShape.tangents);
 906           }
 907           ReadFloat(blendShapeNode.GetChild("weight"), blendShape.weight);
 908         }
 909       }
 910
 911       bool flipV;
 912       if(ReadBool(node.GetChild("flipV"), flipV))
 913       {
 914         meshDef.mFlags |= flipV * MeshDefinition::FLIP_UVS_VERTICAL;
 915       }
 916
 917       resources.mMeshes.emplace_back(std::move(meshDef), MeshGeometry());
 918     }
 919   }
 920 }
 921
 922 void DliLoader::Impl::ParseMaterials(const TreeNode* materials, ConvertColorCode convertColorCode, ResourceBundle& resources)
 923 {
 924   for(auto i0 = materials->CBegin(), i1 = materials->CEnd(); i0 != i1; ++i0)
 925   {
 926     auto& node = (*i0).second;
 927
 928     MaterialDefinition materialDef;
 929     if(auto eEnvironment = node.GetChild("environment"))
 930     {
 931       ReadIndex(eEnvironment, materialDef.mEnvironmentIdx);
 932       if(static_cast<unsigned int>(materialDef.mEnvironmentIdx) >= resources.mEnvironmentMaps.size())
 933       {
 934         ExceptionFlinger(ASSERT_LOCATION) << "material " << resources.mMaterials.size() << ": Environment index " << materialDef.mEnvironmentIdx << " out of bounds (" << resources.mEnvironmentMaps.size() << ").";
 935       }
 936     }
 937
 938     //TODO : need to consider AGIF
 939     std::vector<std::string> texturePaths;
 940     std::string              texturePath;
 941     if(ReadString(node.GetChild("albedoMap"), texturePath))
 942     {
 943       ToUnixFileSeparators(texturePath);
 944       const auto semantic = MaterialDefinition::ALBEDO;
 945       materialDef.mTextureStages.push_back({semantic, TextureDefinition{std::move(texturePath)}});
 946       materialDef.mFlags |= semantic | MaterialDefinition::TRANSPARENCY; // NOTE: only in dli does single / separate ALBEDO texture mean TRANSPARENCY.
 947     }
 948     if(ReadString(node.GetChild("albedoMetallicMap"), texturePath))
 949     {
 950       ToUnixFileSeparators(texturePath);
 951
 952       if(MaskMatch(materialDef.mFlags, MaterialDefinition::ALBEDO))
 953       {
 954         mOnError(FormatString("material %d: conflicting semantics; already set %s.", resources.mMaterials.size(), "albedo"));
 955       }
 956
 957       const auto semantic = MaterialDefinition::ALBEDO | MaterialDefinition::METALLIC;
 958       materialDef.mTextureStages.push_back({semantic, TextureDefinition{std::move(texturePath)}});
 959       materialDef.mFlags |= semantic;
 960     }
 961
 962     if(ReadString(node.GetChild("metallicRoughnessMap"), texturePath))
 963     {
 964       ToUnixFileSeparators(texturePath);
 965
 966       if(MaskMatch(materialDef.mFlags, MaterialDefinition::METALLIC))
 967       {
 968         mOnError(FormatString("material %d: conflicting semantics; already set %s.", resources.mMaterials.size(), "metallic"));
 969       }
 970
 971       const auto semantic = MaterialDefinition::METALLIC | MaterialDefinition::ROUGHNESS;
 972       materialDef.mTextureStages.push_back({semantic, TextureDefinition{std::move(texturePath)}});
 973       materialDef.mFlags |= semantic |
 974                             // We have a metallic-roughhness map and the first texture did not have albedo semantics - we're in the transparency workflow.
 975                             (MaskMatch(materialDef.mFlags, MaterialDefinition::ALBEDO) * MaterialDefinition::TRANSPARENCY);
 976     }
 977
 978     if(ReadString(node.GetChild("normalMap"), texturePath))
 979     {
 980       ToUnixFileSeparators(texturePath);
 981
 982       const auto semantic = MaterialDefinition::NORMAL;
 983       materialDef.mTextureStages.push_back({semantic, TextureDefinition{std::move(texturePath)}});
 984       materialDef.mFlags |= semantic |
 985                             // We have a standalone normal map and the first texture did not have albedo semantics - we're in the transparency workflow.
 986                             (MaskMatch(materialDef.mFlags, MaterialDefinition::ALBEDO) * MaterialDefinition::TRANSPARENCY);
 987     }
 988
 989     if(ReadString(node.GetChild("normalRoughnessMap"), texturePath))
 990     {
 991       ToUnixFileSeparators(texturePath);
 992
 993       if(MaskMatch(materialDef.mFlags, MaterialDefinition::NORMAL))
 994       {
 995         mOnError(FormatString("material %d: conflicting semantics; already set %s.", resources.mMaterials.size(), "normal"));
 996       }
 997
 998       if(MaskMatch(materialDef.mFlags, MaterialDefinition::ROUGHNESS))
 999       {
1000         mOnError(FormatString("material %d: conflicting semantics; already set %s.", resources.mMaterials.size(), "roughness"));
1001       }
1002
1003       if(MaskMatch(materialDef.mFlags, MaterialDefinition::TRANSPARENCY))
1004       {
1005         mOnError(FormatString("material %d: conflicting semantics; already set %s.", resources.mMaterials.size(), "transparency"));
1006       }
1007
1008       const auto semantic = MaterialDefinition::NORMAL | MaterialDefinition::ROUGHNESS;
1009       materialDef.mTextureStages.push_back({semantic, TextureDefinition{std::move(texturePath)}});
1010       materialDef.mFlags |= semantic;
1011     }
1012
1013     if(ReadString(node.GetChild("subsurfaceMap"), texturePath))
1014     {
1015       ToUnixFileSeparators(texturePath);
1016
1017       const auto semantic = MaterialDefinition::SUBSURFACE;
1018       materialDef.mTextureStages.push_back({semantic, TextureDefinition{std::move(texturePath)}});
1019       materialDef.mFlags |= semantic;
1020     }
1021
1022     if(ReadString(node.GetChild("occlusionMap"), texturePath))
1023     {
1024       ToUnixFileSeparators(texturePath);
1025       const auto semantic = MaterialDefinition::OCCLUSION;
1026       materialDef.mTextureStages.push_back({semantic, TextureDefinition{std::move(texturePath)}});
1027       materialDef.mFlags |= semantic;
1028     }
1029
1030     if(ReadColorCodeOrColor(&node, materialDef.mColor, convertColorCode) &&
1031        materialDef.mColor.a < 1.0f)
1032     {
1033       materialDef.mFlags |= MaterialDefinition::TRANSPARENCY;
1034     }
1035
1036     ReadFloat(node.GetChild("metallic"), materialDef.mMetallic);
1037     ReadFloat(node.GetChild("roughness"), materialDef.mRoughness);
1038
1039     bool mipmaps;
1040     if(ReadBool(node.GetChild("mipmap"), mipmaps) && mipmaps)
1041     {
1042       for(auto& ts : materialDef.mTextureStages)
1043       {
1044         ts.mTexture.mSamplerFlags |= SamplerFlags::FILTER_MIPMAP_LINEAR;
1045       }
1046     }
1047
1048     resources.mMaterials.emplace_back(std::move(materialDef), TextureSet());
1049   }
1050 }
1051
1052 void DliLoader::Impl::ParseNodes(const TreeNode* const nodes, Index index, LoadParams& params)
1053 {
1054   std::vector<Index> parents;
1055   parents.reserve(8);
1056
1057   struct IndexMapper : IIndexMapper
1058   {
1059     IndexMapper(size_t numNodes)
1060     {
1061       mIndices.reserve(numNodes);
1062     }
1063
1064     virtual bool Map(Index iDli, Index iScene) override
1065     {
1066       Entry idx{iDli, iScene};
1067       auto  iInsert = std::lower_bound(mIndices.begin(), mIndices.end(), idx);
1068       if(iInsert == mIndices.end() || iInsert->iDli != iDli)
1069       {
1070         mIndices.insert(iInsert, idx);
1071       }
1072       else if(iInsert->iScene != iScene)
1073       {
1074         return false;
1075       }
1076       return true;
1077     }
1078
1079     virtual unsigned int Resolve(Index iDli) override
1080     {
1081       auto iFind = std::lower_bound(mIndices.begin(), mIndices.end(), iDli, [](const Entry& idx, Index iDli) {
1082         return idx.iDli < iDli;
1083       });
1084       DALI_ASSERT_ALWAYS(iFind != mIndices.end());
1085       return iFind->iScene;
1086     }
1087
1088   private:
1089     struct Entry
1090     {
1091       unsigned int iDli;
1092       unsigned int iScene;
1093
1094       bool operator<(const Entry& other) const
1095       {
1096         return iDli < other.iDli;
1097       }
1098     };
1099     std::vector<Entry> mIndices;
1100   } mapper(nodes->Size());
1101   ParseNodesInternal(nodes, index, parents, params, mapper);
1102
1103   auto& scene = params.output.mScene;
1104   for(size_t i0 = 0, i1 = scene.GetNodeCount(); i0 < i1; ++i0)
1105   {
1106     for(auto& c : scene.GetNode(i0)->mConstraints)
1107     {
1108       c.mSourceIdx = mapper.Resolve(c.mSourceIdx);
1109     }
1110   }
1111 }
1112
1113 void DliLoader::Impl::ParseNodesInternal(const TreeNode* const nodes, Index index, std::vector<Index>& inOutParentStack, LoadParams& params, IIndexMapper& mapper)
1114 {
1115   // Properties that may be resolved from a JSON value with ReadInt() -- or default to 0.
1116   struct IndexProperty
1117   {
1118     ResourceType::Value type;
1119     const TreeNode*     source;
1120     Index&              target;
1121   };
1122   std::vector<IndexProperty> resourceIds;
1123   resourceIds.reserve(4);
1124
1125   if(auto node = GetNthChild(nodes, index))
1126   {
1127     NodeDefinition nodeDef;
1128     nodeDef.mParentIdx = inOutParentStack.empty() ? INVALID_INDEX : inOutParentStack.back();
1129
1130     // name
1131     ReadString(node->GetChild(NAME), nodeDef.mName);
1132
1133     // transform
1134     ReadModelTransform(node, nodeDef.mOrientation, nodeDef.mPosition, nodeDef.mScale);
1135
1136     // Reads the size of the node.
1137     //
1138     // * It can be given as 'size' or 'bounds'.
1139     // * The sdk saves the 'size' as a vector2 in some cases.
1140     // * To avoid size related issues the following code attemps
1141     //   to read the 'size/bounds' as a vector3 first, if it's
1142     //   not successful then reads it as a vector2.
1143     ReadVector(node->GetChild("size"), nodeDef.mSize.AsFloat(), 3) ||
1144       ReadVector(node->GetChild("size"), nodeDef.mSize.AsFloat(), 2) ||
1145       ReadVector(node->GetChild("bounds"), nodeDef.mSize.AsFloat(), 3) ||
1146       ReadVector(node->GetChild("bounds"), nodeDef.mSize.AsFloat(), 2);
1147
1148     // visibility
1149     ReadBool(node->GetChild("visible"), nodeDef.mIsVisible);
1150
1151     // type classification
1152     if(auto eCustomization = node->GetChild("customization")) // customization
1153     {
1154       std::string tag;
1155       if(ReadString(eCustomization->GetChild("tag"), tag))
1156       {
1157         nodeDef.mCustomization.reset(new NodeDefinition::CustomizationDefinition{tag});
1158       }
1159     }
1160     else // something renderable maybe
1161     {
1162       std::unique_ptr<NodeDefinition::Renderable> renderable;
1163       ModelNode*                                  modelNode = nullptr; // no ownership, aliasing renderable for the right type.
1164
1165       const TreeNode* eRenderable = nullptr;
1166       if((eRenderable = node->GetChild("model")))
1167       {
1168         // check for mesh before allocating - this can't be missing.
1169         auto eMesh = eRenderable->GetChild("mesh");
1170         if(!eMesh)
1171         {
1172           ExceptionFlinger(ASSERT_LOCATION) << "node " << nodeDef.mName << ": Missing mesh definition.";
1173         }
1174
1175         modelNode = new ModelNode();
1176         renderable.reset(modelNode);
1177
1178         resourceIds.push_back({ResourceType::Mesh, eMesh, modelNode->mMeshIdx});
1179       }
1180       else if((eRenderable = node->GetChild("arc")))
1181       {
1182         // check for mesh before allocating - this can't be missing.
1183         auto eMesh = eRenderable->GetChild("mesh");
1184         if(!eMesh)
1185         {
1186           ExceptionFlinger(ASSERT_LOCATION) << "node " << nodeDef.mName << ": Missing mesh definition.";
1187         }
1188
1189         auto arcNode = new ArcNode;
1190         renderable.reset(arcNode);
1191         modelNode = arcNode;
1192
1193         resourceIds.push_back({ResourceType::Mesh, eMesh, arcNode->mMeshIdx});
1194
1195         ReadArcField(eRenderable, *arcNode);
1196       }
1197
1198       if(renderable) // process common properties of all renderables + register payload
1199       {
1200         // shader
1201         renderable->mShaderIdx = 0;
1202         auto eShader           = eRenderable->GetChild("shader");
1203         resourceIds.push_back({ResourceType::Shader, eShader, renderable->mShaderIdx});
1204
1205         // color
1206         if(modelNode)
1207         {
1208           modelNode->mMaterialIdx = 0; // must offer default of 0
1209           auto eMaterial          = eRenderable->GetChild("material");
1210           resourceIds.push_back({ResourceType::Material, eMaterial, modelNode->mMaterialIdx});
1211
1212           if(!ReadColorCodeOrColor(eRenderable, modelNode->mColor, params.input.mConvertColorCode))
1213           {
1214             ReadColorCodeOrColor(node, modelNode->mColor, params.input.mConvertColorCode);
1215           }
1216         }
1217
1218         nodeDef.mRenderable = std::move(renderable);
1219       }
1220     }
1221
1222     // Resolve ints - default to 0 if undefined
1223     auto& output = params.output;
1224     for(auto& idRes : resourceIds)
1225     {
1226       Index iCheck = 0;
1227       switch(idRes.type)
1228       {
1229         case ResourceType::Shader:
1230           iCheck = output.mResources.mShaders.size();
1231           break;
1232
1233         case ResourceType::Mesh:
1234           iCheck = output.mResources.mMeshes.size();
1235           break;
1236
1237         case ResourceType::Material:
1238           iCheck = output.mResources.mMaterials.size();
1239           break;
1240
1241         default:
1242           ExceptionFlinger(ASSERT_LOCATION) << "node " << index << ": Invalid resource type: " << idRes.type << " (Programmer error)";
1243       }
1244
1245       if(!idRes.source)
1246       {
1247         idRes.target = 0;
1248       }
1249       else if(idRes.source->GetType() != TreeNode::INTEGER)
1250       {
1251         ExceptionFlinger(ASSERT_LOCATION) << "node " << index << ": Invalid " << GetResourceTypeName(idRes.type) << " index type.";
1252       }
1253       else
1254       {
1255         idRes.target = idRes.source->GetInteger();
1256       }
1257
1258       if(idRes.target >= iCheck)
1259       {
1260         ExceptionFlinger(ASSERT_LOCATION) << "node " << index << ": " << GetResourceTypeName(idRes.type) << " index " << idRes.target << " out of bounds (" << iCheck << ").";
1261       }
1262     }
1263     resourceIds.clear();
1264
1265     // Extra properties
1266     if(auto eExtras = node->GetChild("extras"))
1267     {
1268       auto& extras = nodeDef.mExtras;
1269       extras.reserve(eExtras->Size());
1270
1271       for(auto i0 = eExtras->CBegin(), i1 = eExtras->CEnd(); i0 != i1; ++i0)
1272       {
1273         NodeDefinition::Extra e;
1274
1275         auto eExtra = *i0;
1276         e.mKey      = eExtra.first;
1277         if(e.mKey.empty())
1278         {
1279           mOnError(FormatString("node %d: empty string is invalid for name of extra %d; ignored.",
1280                                 index,
1281                                 extras.size()));
1282           continue;
1283         }
1284
1285         e.mValue = ReadPropertyValue(eExtra.second);
1286         if(e.mValue.GetType() == Property::Type::NONE)
1287         {
1288           mOnError(FormatString("node %d: failed to interpret value of extra '%s' : %s; ignored.",
1289                                 index,
1290                                 e.mKey.c_str(),
1291                                 eExtra.second.GetString()));
1292         }
1293         else
1294         {
1295           auto iInsert = std::lower_bound(extras.begin(), extras.end(), e);
1296           if(iInsert != extras.end() && iInsert->mKey == e.mKey)
1297           {
1298             mOnError(FormatString("node %d: extra '%s' already defined; overriding with %s.",
1299                                   index,
1300                                   e.mKey.c_str(),
1301                                   eExtra.second.GetString()));
1302             *iInsert = std::move(e);
1303           }
1304           else
1305           {
1306             extras.insert(iInsert, e);
1307           }
1308         }
1309       }
1310     }
1311
1312     // Constraints
1313     if(auto eConstraints = node->GetChild("constraints"))
1314     {
1315       auto& constraints = nodeDef.mConstraints;
1316       constraints.reserve(eConstraints->Size());
1317
1318       ConstraintDefinition cDef;
1319       for(auto i0 = eConstraints->CBegin(), i1 = eConstraints->CEnd(); i0 != i1; ++i0)
1320       {
1321         auto eConstraint = *i0;
1322         if(!ReadIndex(&eConstraint.second, cDef.mSourceIdx))
1323         {
1324           mOnError(FormatString("node %d: node ID %s for constraint %d is invalid; ignored.",
1325                                 index,
1326                                 eConstraint.second.GetString(),
1327                                 constraints.size()));
1328         }
1329         else
1330         {
1331           cDef.mProperty = eConstraint.first;
1332
1333           auto iInsert = std::lower_bound(constraints.begin(), constraints.end(), cDef);
1334           if(iInsert != constraints.end() && *iInsert == cDef)
1335           {
1336             mOnError(FormatString("node %d: constraint %s@%d already defined; ignoring.",
1337                                   index,
1338                                   cDef.mProperty.c_str(),
1339                                   cDef.mSourceIdx));
1340           }
1341           else
1342           {
1343             constraints.insert(iInsert, cDef);
1344           }
1345         }
1346       }
1347     }
1348
1349     // Determine index for mapping
1350     const unsigned int myIndex = output.mScene.GetNodeCount();
1351     if(!mapper.Map(index, myIndex))
1352     {
1353       mOnError(FormatString("node %d: error mapping dli index %d: node has multiple parents. Ignoring subtree."));
1354       return;
1355     }
1356
1357     // if the node is a bone in a skeletal animation, it will have the inverse bind pose matrix.
1358     Matrix invBindMatrix{false};
1359     if(ReadVector(node->GetChild("inverseBindPoseMatrix"), invBindMatrix.AsFloat(), 16u)) // TODO: more robust error checking?
1360     {
1361       mInverseBindMatrices[myIndex] = invBindMatrix;
1362     }
1363
1364     // Register nodeDef
1365     auto rawDef = output.mScene.AddNode(std::make_unique<NodeDefinition>(std::move(nodeDef)));
1366     if(rawDef) // NOTE: no ownership. Guaranteed to stay in scope.
1367     {
1368       // ...And only then parse children.
1369       if(auto children = node->GetChild("children"))
1370       {
1371         inOutParentStack.push_back(myIndex);
1372
1373         rawDef->mChildren.reserve(children->Size());
1374
1375         uint32_t iChild = 0;
1376         for(auto j0 = children->CBegin(), j1 = children->CEnd(); j0 != j1; ++j0, ++iChild)
1377         {
1378           auto& child = (*j0).second;
1379           if(child.GetType() == TreeNode::INTEGER)
1380           {
1381             ParseNodesInternal(nodes, child.GetInteger(), inOutParentStack, params, mapper); // child object is created in scene definition.
1382           }
1383           else
1384           {
1385             ExceptionFlinger(ASSERT_LOCATION) << "node " << index << ", child " << iChild << ": invalid index type.";
1386           }
1387         }
1388
1389         inOutParentStack.pop_back();
1390       }
1391       else if(rawDef->mCustomization)
1392       {
1393         mOnError(FormatString("node %d: not an actual customization without children.", index));
1394       }
1395
1396       if(auto proc = params.input.mNodePropertyProcessor) // optional processing
1397       {
1398         // WARNING: constraint IDs are not resolved at this point.
1399         Property::Map nodeData;
1400         ParseProperties(*node, nodeData);
1401         proc(*rawDef, std::move(nodeData), mOnError);
1402       }
1403     }
1404     else
1405     {
1406       ExceptionFlinger(ASSERT_LOCATION) << "Node " << index << ": name already used.";
1407     }
1408   }
1409 }
1410
1411 void DliLoader::Impl::ParseAnimations(const TreeNode* tnAnimations, LoadParams& params)
1412 {
1413   auto& definitions = params.output.mAnimationDefinitions;
1414   definitions.reserve(definitions.size() + tnAnimations->Size());
1415
1416   for(TreeNode::ConstIterator iAnim = tnAnimations->CBegin(), iAnimEnd = tnAnimations->CEnd();
1417       iAnim != iAnimEnd;
1418       ++iAnim)
1419   {
1420     const TreeNode&     tnAnim = (*iAnim).second;
1421     AnimationDefinition animDef;
1422     ReadString(tnAnim.GetChild(NAME), animDef.mName);
1423
1424     auto       iFind     = std::lower_bound(definitions.begin(), definitions.end(), animDef, [](const AnimationDefinition& ad0, const AnimationDefinition& ad1) {
1425       return ad0.mName < ad1.mName;
1426     });
1427     const bool overwrite = iFind != definitions.end() && iFind->mName == animDef.mName;
1428     if(overwrite)
1429     {
1430       mOnError(FormatString("Pre-existing animation with name '%s' is being overwritten.", animDef.mName.c_str()));
1431     }
1432
1433     // Duration -- We need something that animated properties' delay / duration can
1434     // be expressed as a multiple of; 0 won't work. This is small enough (i.e. shorter
1435     // than our frame delay) to not be restrictive WRT replaying. If anything needs
1436     // to occur more frequently, then Animations are likely not your solution anyway.
1437     animDef.mDuration = AnimationDefinition::MIN_DURATION_SECONDS;
1438     if(!ReadFloat(tnAnim.GetChild("duration"), animDef.mDuration))
1439     {
1440       mOnError(FormatString("Animation '%s' fails to define '%s', defaulting to %f.",
1441                             animDef.mName.c_str(),
1442                             "duration",
1443                             animDef.mDuration));
1444     }
1445
1446     // Get loop count - # of playbacks. Default is once. 0 means repeat indefinitely.
1447     animDef.mLoopCount = 1;
1448     if(ReadInt(tnAnim.GetChild("loopCount"), animDef.mLoopCount) &&
1449        animDef.mLoopCount < 0)
1450     {
1451       animDef.mLoopCount = 0;
1452     }
1453
1454     std::string endAction;
1455     if(ReadString(tnAnim.GetChild("endAction"), endAction))
1456     {
1457       if("BAKE" == endAction)
1458       {
1459         animDef.mEndAction = Animation::BAKE;
1460       }
1461       else if("DISCARD" == endAction)
1462       {
1463         animDef.mEndAction = Animation::DISCARD;
1464       }
1465       else if("BAKE_FINAL" == endAction)
1466       {
1467         animDef.mEndAction = Animation::BAKE_FINAL;
1468       }
1469     }
1470
1471     if(ReadString(tnAnim.GetChild("disconnectAction"), endAction))
1472     {
1473       if("BAKE" == endAction)
1474       {
1475         animDef.mDisconnectAction = Animation::BAKE;
1476       }
1477       else if("DISCARD" == endAction)
1478       {
1479         animDef.mDisconnectAction = Animation::DISCARD;
1480       }
1481       else if("BAKE_FINAL" == endAction)
1482       {
1483         animDef.mDisconnectAction = Animation::BAKE_FINAL;
1484       }
1485     }
1486
1487     if(const TreeNode* tnProperties = tnAnim.GetChild("properties"))
1488     {
1489       animDef.mProperties.reserve(tnProperties->Size());
1490       for(TreeNode::ConstIterator iProperty = tnProperties->CBegin(), iPropertyEnd = tnProperties->CEnd();
1491           iProperty != iPropertyEnd;
1492           ++iProperty)
1493       {
1494         const TreeNode& tnProperty = (*iProperty).second;
1495
1496         AnimatedProperty animProp;
1497         if(!ReadString(tnProperty.GetChild("node"), animProp.mNodeName))
1498         {
1499           mOnError(FormatString("Animation '%s': Failed to read the 'node' tag.", animDef.mName.c_str()));
1500           continue;
1501         }
1502
1503         if(!ReadString(tnProperty.GetChild("property"), animProp.mPropertyName))
1504         {
1505           mOnError(FormatString("Animation '%s': Failed to read the 'property' tag", animDef.mName.c_str()));
1506           continue;
1507         }
1508
1509         // these are the defaults
1510         animProp.mTimePeriod.delaySeconds    = 0.f;
1511         animProp.mTimePeriod.durationSeconds = animDef.mDuration;
1512         if(!ReadTimePeriod(tnProperty.GetChild("timePeriod"), animProp.mTimePeriod))
1513         {
1514           mOnError(FormatString("Animation '%s': timePeriod missing in Property #%d: defaulting to %f.",
1515                                 animDef.mName.c_str(),
1516                                 animDef.mProperties.size(),
1517                                 animProp.mTimePeriod.durationSeconds));
1518         }
1519
1520         std::string alphaFunctionValue;
1521         if(ReadString(tnProperty.GetChild("alphaFunction"), alphaFunctionValue))
1522         {
1523           animProp.mAlphaFunction = GetAlphaFunction(alphaFunctionValue);
1524         }
1525
1526         if(const TreeNode* tnKeyFramesBin = tnProperty.GetChild("keyFramesBin"))
1527         {
1528           DALI_ASSERT_ALWAYS(!animProp.mPropertyName.empty() && "Animation must specify a property name");
1529
1530           std::ifstream binAniFile;
1531           std::string   animationFilename;
1532           if(ReadString(tnKeyFramesBin->GetChild(URL), animationFilename))
1533           {
1534             std::string animationFullPath = params.input.mAnimationsPath + animationFilename;
1535             binAniFile.open(animationFullPath, std::ios::binary);
1536             if(binAniFile.fail())
1537             {
1538               ExceptionFlinger(ASSERT_LOCATION) << "Failed to open animation data '" << animationFullPath << "'";
1539             }
1540           }
1541
1542           int byteOffset = 0;
1543           ReadInt(tnKeyFramesBin->GetChild("byteOffset"), byteOffset);
1544           DALI_ASSERT_ALWAYS(byteOffset >= 0);
1545
1546           binAniFile.seekg(byteOffset, std::ios::beg);
1547
1548           int numKeys = 0;
1549           ReadInt(tnKeyFramesBin->GetChild("numKeys"), numKeys);
1550           DALI_ASSERT_ALWAYS(numKeys >= 0);
1551
1552           animProp.mKeyFrames = KeyFrames::New();
1553
1554           //In binary animation file only is saved the position, rotation, scale and blend shape weight keys.
1555           //so, if it is vector3 we assume is position or scale keys, if it is vector4 we assume is rotation,
1556           // otherwise are blend shape weight keys.
1557           // TODO support for binary header with size information
1558           Property::Type propType = Property::FLOAT; // assume blend shape weights
1559           if(animProp.mPropertyName == "orientation")
1560           {
1561             propType = Property::VECTOR4;
1562           }
1563           else if((animProp.mPropertyName == "position") || (animProp.mPropertyName == "scale"))
1564           {
1565             propType = Property::VECTOR3;
1566           }
1567
1568           //alphafunction is reserved for future implementation
1569           // NOTE: right now we're just using AlphaFunction::LINEAR.
1570           unsigned char dummyAlphaFunction;
1571
1572           float           progress;
1573           Property::Value propValue;
1574           for(int key = 0; key < numKeys; key++)
1575           {
1576             binAniFile.read(reinterpret_cast<char*>(&progress), sizeof(float));
1577             if(propType == Property::VECTOR3)
1578             {
1579               Vector3 value;
1580               binAniFile.read(reinterpret_cast<char*>(value.AsFloat()), sizeof(float) * 3);
1581               propValue = Property::Value(value);
1582             }
1583             else if(propType == Property::VECTOR4)
1584             {
1585               Vector4 value;
1586               binAniFile.read(reinterpret_cast<char*>(value.AsFloat()), sizeof(float) * 4);
1587               propValue = Property::Value(Quaternion(value));
1588             }
1589             else
1590             {
1591               float value;
1592               binAniFile.read(reinterpret_cast<char*>(&value), sizeof(float));
1593               propValue = Property::Value(value);
1594             }
1595
1596             binAniFile.read(reinterpret_cast<char*>(&dummyAlphaFunction), sizeof(unsigned char));
1597
1598             animProp.mKeyFrames.Add(progress, propValue, AlphaFunction::LINEAR);
1599           }
1600         }
1601         else if(const TreeNode* tnKeyFrames = tnProperty.GetChild("keyFrames"))
1602         {
1603           DALI_ASSERT_ALWAYS(!animProp.mPropertyName.empty() && "Animation must specify a property name");
1604           animProp.mKeyFrames = KeyFrames::New();
1605
1606           float progress = 0.0f;
1607           for(auto i0 = tnKeyFrames->CBegin(), i1 = tnKeyFrames->CEnd(); i1 != i0; ++i0)
1608           {
1609             const TreeNode::KeyNodePair& kfKeyChild = *i0;
1610             bool                         readResult = ReadFloat(kfKeyChild.second.GetChild("progress"), progress);
1611             DALI_ASSERT_ALWAYS(readResult && "Key frame entry must have 'progress'");
1612
1613             const TreeNode* tnValue = kfKeyChild.second.GetChild("value");
1614             DALI_ASSERT_ALWAYS(tnValue && "Key frame entry must have 'value'");
1615
1616             // For the "orientation" property, convert from Vector4 -> Rotation value
1617             // This work-around is preferable to a null-pointer exception in the DALi update thread
1618             Property::Value propValue(ReadPropertyValue(*tnValue));
1619             if(propValue.GetType() == Property::VECTOR4 &&
1620                animProp.mPropertyName == "orientation")
1621             {
1622               Vector4 v;
1623               propValue.Get(v);
1624               propValue = Property::Value(Quaternion(v.w, v.x, v.y, v.z));
1625             }
1626
1627             AlphaFunction kfAlphaFunction(AlphaFunction::DEFAULT);
1628             std::string   alphaFuncStr;
1629             if(ReadString(kfKeyChild.second.GetChild("alphaFunction"), alphaFuncStr))
1630             {
1631               kfAlphaFunction = GetAlphaFunction(alphaFuncStr);
1632             }
1633
1634             animProp.mKeyFrames.Add(progress, propValue, kfAlphaFunction);
1635           }
1636         }
1637         else
1638         {
1639           const TreeNode* tnValue = tnProperty.GetChild("value");
1640           if(tnValue)
1641           {
1642             animProp.mValue.reset(new AnimatedProperty::Value{ReadPropertyValue(*tnValue)});
1643             ReadBool(tnProperty.GetChild("relative"), animProp.mValue->mIsRelative);
1644           }
1645           else
1646           {
1647             mOnError(FormatString("Property '%s' fails to define target value.",
1648                                   animProp.mPropertyName.c_str()));
1649           }
1650         }
1651
1652         animDef.mProperties.push_back(std::move(animProp));
1653       }
1654     }
1655
1656     if(overwrite)
1657     {
1658       *iFind = std::move(animDef);
1659     }
1660     else
1661     {
1662       iFind = definitions.insert(iFind, std::move(animDef));
1663     }
1664
1665     if(auto proc = params.input.mAnimationPropertyProcessor) // optional processing
1666     {
1667       Property::Map map;
1668       ParseProperties(tnAnim, map);
1669       proc(animDef, std::move(map), mOnError);
1670     }
1671   }
1672 }
1673
1674 void DliLoader::Impl::ParseAnimationGroups(const Toolkit::TreeNode* tnAnimationGroups, LoadParams& params)
1675 {
1676   auto& animGroups = params.output.mAnimationGroupDefinitions;
1677
1678   int numGroups = 0;
1679   for(auto iGroups = tnAnimationGroups->CBegin(), iGroupsEnd = tnAnimationGroups->CEnd();
1680       iGroups != iGroupsEnd;
1681       ++iGroups, ++numGroups)
1682   {
1683     const auto& tnGroup = *iGroups;
1684     auto        tnName  = tnGroup.second.GetChild(NAME);
1685     std::string groupName;
1686     if(!tnName || !ReadString(tnName, groupName))
1687     {
1688       mOnError(FormatString("Failed to get the name for the Animation group %d; ignoring.", numGroups));
1689       continue;
1690     }
1691
1692     auto iFind = std::lower_bound(animGroups.begin(), animGroups.end(), groupName, [](const AnimationGroupDefinition& group, const std::string& name) {
1693       return group.mName < name;
1694     });
1695     if(iFind != animGroups.end() && iFind->mName == groupName)
1696     {
1697       mOnError(FormatString("Animation group with name '%s' already exists; new entries will be merged.", groupName.c_str()));
1698     }
1699     else
1700     {
1701       iFind = animGroups.insert(iFind, AnimationGroupDefinition{});
1702     }
1703
1704     iFind->mName = groupName;
1705
1706     auto tnAnims = tnGroup.second.GetChild("animations");
1707     if(tnAnims && tnAnims->Size() > 0)
1708     {
1709       auto& anims = iFind->mAnimations;
1710       anims.reserve(anims.size() + tnAnims->Size());
1711       for(auto iAnims = tnAnims->CBegin(), iAnimsEnd = tnAnims->CEnd(); iAnims != iAnimsEnd; ++iAnims)
1712       {
1713         anims.push_back((*iAnims).second.GetString());
1714       }
1715     }
1716   }
1717 }
1718
1719 void DliLoader::Impl::GetCameraParameters(std::vector<CameraParameters>& cameras) const
1720 {
1721   if(mParser.GetRoot())
1722   {
1723     if(const TreeNode* jsonCameras = mParser.GetRoot()->GetChild("cameras"))
1724     {
1725       cameras.resize(jsonCameras->Size());
1726       auto iCamera = cameras.begin();
1727       for(auto i0 = jsonCameras->CBegin(), i1 = jsonCameras->CEnd(); i0 != i1; ++i0)
1728       {
1729         auto& jsonCamera = (*i0).second;
1730
1731         ReadFloat(jsonCamera.GetChild("fov"), iCamera->yFov);
1732         ReadFloat(jsonCamera.GetChild("near"), iCamera->zNear);
1733         ReadFloat(jsonCamera.GetChild("far"), iCamera->zFar);
1734         if(ReadVector(jsonCamera.GetChild("orthographic"), iCamera->orthographicSize.AsFloat(), 4u))
1735         {
1736           iCamera->isPerspective = false;
1737         }
1738
1739         if(auto jsonMatrix = jsonCamera.GetChild("matrix"))
1740         {
1741           ReadVector(jsonMatrix, iCamera->matrix.AsFloat(), 16u);
1742         }
1743
1744         ++iCamera;
1745       }
1746     }
1747   }
1748 }
1749
1750 void DliLoader::Impl::GetLightParameters(std::vector<LightParameters>& lights) const
1751 {
1752   if(mParser.GetRoot())
1753   {
1754     if(const TreeNode* jsonLights = mParser.GetRoot()->GetChild("lights"))
1755     {
1756       lights.resize(jsonLights->Size());
1757       auto iLight = lights.begin();
1758       for(auto i0 = jsonLights->CBegin(), i1 = jsonLights->CEnd(); i0 != i1; ++i0)
1759       {
1760         auto& jsonLight = (*i0).second;
1761         if(!ReadVector(jsonLight.GetChild("matrix"), iLight->transform.AsFloat(), 16))
1762         {
1763           mOnError(
1764             FormatString("Failed to parse light %d - \"matrix\" child with 16 floats expected.\n",
1765                          std::distance(jsonLights->CBegin(), i0)));
1766           continue;
1767         }
1768
1769         int shadowMapSize = 0;
1770         if(ReadInt(jsonLight.GetChild(SHADOW_MAP_SIZE), shadowMapSize) && shadowMapSize < 0)
1771         {
1772           mOnError(
1773             FormatString("Failed to parse light %d - %s has an invalid value.",
1774                          std::distance(jsonLights->CBegin(), i0),
1775                          SHADOW_MAP_SIZE));
1776           continue;
1777         }
1778         iLight->shadowMapSize = shadowMapSize;
1779
1780         float orthoSize = 0.f;
1781         if(ReadFloat(jsonLight.GetChild(ORTHOGRAPHIC_SIZE), orthoSize) &&
1782            (orthoSize < .0f || std::isnan(orthoSize) || std::isinf(orthoSize)))
1783         {
1784           mOnError(
1785             FormatString("Failed to parse light %d - %s has an invalid value.",
1786                          std::distance(jsonLights->CBegin(), i0),
1787                          ORTHOGRAPHIC_SIZE));
1788           continue;
1789         }
1790         iLight->orthographicSize = orthoSize;
1791
1792         if((iLight->shadowMapSize > 0) != (iLight->orthographicSize > .0f))
1793         {
1794           mOnError(FormatString(
1795             "Light %d: Both shadow map size and orthographic size must be set for shadows to work.",
1796             std::distance(jsonLights->CBegin(), i0)));
1797         }
1798
1799         if(!ReadVector(jsonLight.GetChild("color"), iLight->color.AsFloat(), 3)) // color is optional
1800         {
1801           iLight->color = Vector3::ONE; // default to white
1802         }
1803
1804         if(!ReadFloat(jsonLight.GetChild("intensity"), iLight->intensity)) // intensity is optional
1805         {
1806           iLight->intensity = 1.0f; // default to 1.0
1807         }
1808
1809         if(!ReadFloat(jsonLight.GetChild("shadowIntensity"), iLight->shadowIntensity)) // intensity is optional
1810         {
1811           iLight->shadowIntensity = 1.0f; // default to 1.0
1812         }
1813
1814         ++iLight;
1815       }
1816     }
1817   }
1818 }
1819
1820 } // namespace Loader
1821 } // namespace Scene3D
1822 } // namespace Dali