Change dali-scene-loader to dali-scene3d

[platform/core/uifw/dali-toolkit.git] / dali-scene3d / internal / controls / model-view / model-view-impl.cpp

diff --git a/dali-scene-loader/internal/controls/model-view/model-view-impl.cpp b/dali-scene3d/internal/controls/model-view/model-view-impl.cpp
similarity index 78%
rename from dali-scene-loader/internal/controls/model-view/model-view-impl.cpp
rename to dali-scene3d/internal/controls/model-view/model-view-impl.cpp
index f3b135a..568b899 100644 (file)
--- a/dali-scene-loader/internal/controls/model-view/model-view-impl.cpp
+++ b/dali-scene3d/internal/controls/model-view/model-view-impl.cpp
@@ -23,24 +23,24 @@
 #include <dali-toolkit/devel-api/controls/control-devel.h>
 #include <dali-toolkit/internal/controls/control/control-data-impl.h>
 #include <dali-toolkit/internal/graphics/builtin-shader-extern-gen.h>
+#include <dali/integration-api/debug.h>
 #include <dali/public-api/object/type-registry-helper.h>
 #include <dali/public-api/object/type-registry.h>
-#include <dali/integration-api/debug.h>
 #include <filesystem>
 
 // INTERNAL INCLUDES
-#include <dali-scene-loader/public-api/animation-definition.h>
-#include <dali-scene-loader/public-api/camera-parameters.h>
-#include <dali-scene-loader/public-api/dli-loader.h>
-#include <dali-scene-loader/public-api/gltf2-loader.h>
-#include <dali-scene-loader/public-api/light-parameters.h>
-#include <dali-scene-loader/public-api/load-result.h>
-#include <dali-scene-loader/public-api/node-definition.h>
-#include <dali-scene-loader/public-api/scene-definition.h>
-#include <dali-scene-loader/public-api/shader-definition-factory.h>
-#include <dali-scene-loader/public-api/controls/model-view/model-view.h>
-#include <dali-scene-loader/public-api/cube-map-loader.h>
-#include <dali-scene-loader/public-api/cube-data.h>
+#include <dali-scene3d/public-api/controls/model-view/model-view.h>
+#include <dali-scene3d/public-api/loader/animation-definition.h>
+#include <dali-scene3d/public-api/loader/camera-parameters.h>
+#include <dali-scene3d/public-api/loader/cube-data.h>
+#include <dali-scene3d/public-api/loader/cube-map-loader.h>
+#include <dali-scene3d/public-api/loader/dli-loader.h>
+#include <dali-scene3d/public-api/loader/gltf2-loader.h>
+#include <dali-scene3d/public-api/loader/light-parameters.h>
+#include <dali-scene3d/public-api/loader/load-result.h>
+#include <dali-scene3d/public-api/loader/node-definition.h>
+#include <dali-scene3d/public-api/loader/scene-definition.h>
+#include <dali-scene3d/public-api/loader/shader-definition-factory.h>
 
 using namespace Dali;
 
@@ -115,9 +115,9 @@ struct BoundingVolume
 
 Texture LoadCubeMap(const std::string& cubeMapPath)
 {
-  Texture               cubeTexture;
-  SceneLoader::CubeData cubeData;
-  if(SceneLoader::LoadCubeMapData(cubeMapPath, cubeData))
+  Texture                         cubeTexture;
+  Dali::Scene3D::Loader::CubeData cubeData;
+  if(Dali::Scene3D::Loader::LoadCubeMapData(cubeMapPath, cubeData))
   {
     cubeTexture = cubeData.CreateTexture();
   }
@@ -130,13 +130,13 @@ Texture LoadCubeMap(const std::string& cubeMapPath)
 }
 
 void ConfigureBlendShapeShaders(
-  SceneLoader::ResourceBundle& resources, const SceneLoader::SceneDefinition& scene, Actor root, std::vector<SceneLoader::BlendshapeShaderConfigurationRequest>&& requests)
+  Dali::Scene3D::Loader::ResourceBundle& resources, const Dali::Scene3D::Loader::SceneDefinition& scene, Actor root, std::vector<Dali::Scene3D::Loader::BlendshapeShaderConfigurationRequest>&& requests)
 {
   std::vector<std::string> errors;
   auto                     onError = [&errors](const std::string& msg) { errors.push_back(msg); };
   if(!scene.ConfigureBlendshapeShaders(resources, root, std::move(requests), onError))
   {
-    SceneLoader::ExceptionFlinger flinger(ASSERT_LOCATION);
+    Dali::Scene3D::Loader::ExceptionFlinger flinger(ASSERT_LOCATION);
     for(auto& msg : errors)
     {
       flinger << msg << '\n';
@@ -144,14 +144,14 @@ void ConfigureBlendShapeShaders(
   }
 }
 
-void AddModelTreeToAABB(BoundingVolume& AABB, const SceneLoader::SceneDefinition& scene, const Dali::SceneLoader::Customization::Choices& choices, Dali::SceneLoader::Index iNode, Dali::SceneLoader::NodeDefinition::CreateParams& nodeParams, Matrix parentMatrix)
+void AddModelTreeToAABB(BoundingVolume& AABB, const Dali::Scene3D::Loader::SceneDefinition& scene, const Dali::Scene3D::Loader::Customization::Choices& choices, Dali::Scene3D::Loader::Index iNode, Dali::Scene3D::Loader::NodeDefinition::CreateParams& nodeParams, Matrix parentMatrix)
 {
   static constexpr uint32_t BOX_POINT_COUNT             = 8;
   static uint32_t           BBIndex[BOX_POINT_COUNT][3] = {{0, 0, 0}, {0, 1, 0}, {1, 0, 0}, {1, 1, 0}, {0, 0, 1}, {0, 1, 1}, {1, 0, 1}, {1, 1, 1}};
 
-  Matrix nodeMatrix;
-  const SceneLoader::NodeDefinition* node        = scene.GetNode(iNode);
-  Matrix                             localMatrix = node->GetLocalSpace();
+  Matrix                                       nodeMatrix;
+  const Dali::Scene3D::Loader::NodeDefinition* node        = scene.GetNode(iNode);
+  Matrix                                       localMatrix = node->GetLocalSpace();
   Matrix::Multiply(nodeMatrix, localMatrix, parentMatrix);
 
   Vector3 volume[2];
@@ -171,8 +171,8 @@ void AddModelTreeToAABB(BoundingVolume& AABB, const SceneLoader::SceneDefinition
   {
     if(!node->mChildren.empty())
     {
-      auto                     choice = choices.Get(node->mCustomization->mTag);
-      Dali::SceneLoader::Index i      = std::min(choice != Dali::SceneLoader::Customization::NONE ? choice : 0, static_cast<Dali::SceneLoader::Index>(node->mChildren.size() - 1));
+      auto                         choice = choices.Get(node->mCustomization->mTag);
+      Dali::Scene3D::Loader::Index i      = std::min(choice != Dali::Scene3D::Loader::Customization::NONE ? choice : 0, static_cast<Dali::Scene3D::Loader::Index>(node->mChildren.size() - 1));
 
       AddModelTreeToAABB(AABB, scene, choices, node->mChildren[i], nodeParams, nodeMatrix);
     }
@@ -357,42 +357,42 @@ void ModelView::LoadModel()
   std::string extension = modelPath.extension();
   std::transform(extension.begin(), extension.end(), extension.begin(), ::tolower);
 
-  SceneLoader::ResourceBundle::PathProvider pathProvider = [&](SceneLoader::ResourceType::Value type) {
+  Dali::Scene3D::Loader::ResourceBundle::PathProvider pathProvider = [&](Dali::Scene3D::Loader::ResourceType::Value type) {
     return mResourcePath;
   };
 
-  SceneLoader::ResourceBundle                        resources;
-  SceneLoader::SceneDefinition                       scene;
-  std::vector<SceneLoader::AnimationGroupDefinition> animGroups;
-  std::vector<SceneLoader::CameraParameters>         cameraParameters;
-  std::vector<SceneLoader::LightParameters>          lights;
+  Dali::Scene3D::Loader::ResourceBundle                        resources;
+  Dali::Scene3D::Loader::SceneDefinition                       scene;
+  std::vector<Dali::Scene3D::Loader::AnimationGroupDefinition> animGroups;
+  std::vector<Dali::Scene3D::Loader::CameraParameters>         cameraParameters;
+  std::vector<Dali::Scene3D::Loader::LightParameters>          lights;
 
-  std::vector<Dali::SceneLoader::AnimationDefinition> animations;
+  std::vector<Dali::Scene3D::Loader::AnimationDefinition> animations;
   animations.clear();
 
-  SceneLoader::LoadResult output{resources, scene, animations, animGroups, cameraParameters, lights};
+  Dali::Scene3D::Loader::LoadResult output{resources, scene, animations, animGroups, cameraParameters, lights};
 
   if(extension == DLI_EXTENSION)
   {
-    SceneLoader::DliLoader              loader;
-    SceneLoader::DliLoader::InputParams input{
-      pathProvider(SceneLoader::ResourceType::Mesh),
+    Dali::Scene3D::Loader::DliLoader              loader;
+    Dali::Scene3D::Loader::DliLoader::InputParams input{
+      pathProvider(Dali::Scene3D::Loader::ResourceType::Mesh),
       nullptr,
       {},
       {},
       nullptr,
       {}};
-    SceneLoader::DliLoader::LoadParams loadParams{input, output};
+    Dali::Scene3D::Loader::DliLoader::LoadParams loadParams{input, output};
     if(!loader.LoadScene(mModelPath, loadParams))
     {
-      SceneLoader::ExceptionFlinger(ASSERT_LOCATION) << "Failed to load scene from '" << mModelPath << "': " << loader.GetParseError();
+      Dali::Scene3D::Loader::ExceptionFlinger(ASSERT_LOCATION) << "Failed to load scene from '" << mModelPath << "': " << loader.GetParseError();
     }
   }
   else if(extension == GLTF_EXTENSION)
   {
-    SceneLoader::ShaderDefinitionFactory sdf;
+    Dali::Scene3D::Loader::ShaderDefinitionFactory sdf;
     sdf.SetResources(resources);
-    SceneLoader::LoadGltfScene(mModelPath, sdf, output);
+    Dali::Scene3D::Loader::LoadGltfScene(mModelPath, sdf, output);
 
     resources.mEnvironmentMaps.push_back({});
   }
@@ -401,9 +401,9 @@ void ModelView::LoadModel()
     DALI_LOG_ERROR("Unsupported model type.\n");
   }
 
-  SceneLoader::Transforms                   xforms{SceneLoader::MatrixStack{}, SceneLoader::ViewProjection{}};
-  SceneLoader::NodeDefinition::CreateParams nodeParams{resources, xforms, {}, {}, {}};
-  SceneLoader::Customization::Choices       choices;
+  Dali::Scene3D::Loader::Transforms                   xforms{Dali::Scene3D::Loader::MatrixStack{}, Dali::Scene3D::Loader::ViewProjection{}};
+  Dali::Scene3D::Loader::NodeDefinition::CreateParams nodeParams{resources, xforms, {}, {}, {}};
+  Dali::Scene3D::Loader::Customization::Choices       choices;
 
   mModelRoot = Actor::New();
 
@@ -455,7 +455,7 @@ void ModelView::LoadModel()
   SetImageBasedLight(mModelRoot);
 
   mNaturalSize = AABB.CalculateSize();
-  mModelPivot = AABB.CalculatePivot();
+  mModelPivot  = AABB.CalculatePivot();
   mModelRoot.SetProperty(Dali::Actor::Property::SIZE, mNaturalSize);
 
   FitModelPosition();
@@ -518,7 +518,7 @@ void ModelView::SetImageBasedLight(Actor node)
   uint32_t rendererCount = node.GetRendererCount();
   if(rendererCount)
   {
-    node.RegisterProperty(SceneLoader::NodeDefinition::GetIblScaleFactorUniformName().data(), mIblScaleFactor);
+    node.RegisterProperty(Dali::Scene3D::Loader::NodeDefinition::GetIblScaleFactorUniformName().data(), mIblScaleFactor);
   }
 
   for(uint32_t i = 0; i < rendererCount; ++i)