dali-scene3d/internal/controls/model/model-impl.h

   1 #ifndef DALI_SCENE3D_INTERNAL_MODEL_H
   2 #define DALI_SCENE3D_INTERNAL_MODEL_H
   3
   4 /*
   5  * Copyright (c) 2022 Samsung Electronics Co., Ltd.
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  * http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  */
  20
  21 // EXTERNAL INCLUDES
  22 #include <dali-toolkit/public-api/controls/control-impl.h>
  23 #include <dali/public-api/actors/layer.h>
  24 #include <dali/public-api/animation/animation.h>
  25 #include <dali/public-api/rendering/texture.h>
  26 #include <dali/public-api/object/weak-handle.h>
  27
  28 // INTERNAL INCLUDES
  29 #include <dali-scene3d/public-api/controls/model/model.h>
  30 #include <dali-scene3d/public-api/controls/scene-view/scene-view.h>
  31
  32 namespace Dali
  33 {
  34 namespace Scene3D
  35 {
  36 class Model;
  37
  38 namespace Internal
  39 {
  40 /**
  41  * @brief Impl class for Model.
  42  */
  43 class Model : public Dali::Toolkit::Internal::Control
  44 {
  45 public:
  46   using AnimationData = std::pair<std::string, Dali::Animation>;
  47
  48   /**
  49    * @brief Creates a new Model.
  50    *
  51    * @return A public handle to the newly allocated Model.
  52    */
  53   static Dali::Scene3D::Model New(const std::string& modelUrl, const std::string& resourceDirectoryUrl);
  54
  55   /**
  56    * @copydoc Model::GetModelRoot()
  57    */
  58   const Actor GetModelRoot() const;
  59
  60   /**
  61    * @copydoc Model::SetImageBasedLightSource()
  62    */
  63   void SetImageBasedLightSource(const std::string& diffuseUrl, const std::string& specularUrl, float scaleFactor);
  64
  65   /**
  66    * @copydoc Model::SetImageBasedLightTexture()
  67    */
  68   void SetImageBasedLightTexture(Dali::Texture diffuseTexture, Dali::Texture specularTexture, float scaleFactor);
  69
  70   /**
  71    * @copydoc Model::SetImageBasedLightScaleFactor()
  72    */
  73   void SetImageBasedLightScaleFactor(float scaleFactor);
  74
  75   /**
  76    * @copydoc Model::GetImageBasedLightScaleFactor()
  77    */
  78   float GetImageBasedLightScaleFactor() const;
  79
  80   /**
  81    * @copydoc Model::GetAnimationCount()
  82    */
  83   uint32_t GetAnimationCount() const;
  84
  85   /**
  86    * @copydoc Model::GetAnimation()
  87    */
  88   Dali::Animation GetAnimation(uint32_t index) const;
  89
  90   /**
  91    * @copydoc Model::GetAnimation()
  92    */
  93   Dali::Animation GetAnimation(const std::string& name) const;
  94
  95 protected:
  96   /**
  97    * @brief Constructs a new Model.
  98    */
  99   Model(const std::string& modelUrl, const std::string& resourceDirectoryUrl);
 100
 101   /**
 102    * A reference counted object may only be deleted by calling Unreference()
 103    */
 104   virtual ~Model();
 105
 106 private:
 107   /**
 108    * @copydoc CustomActorImpl::OnSceneConnection()
 109    */
 110   void OnSceneConnection(int depth) override;
 111
 112   /**
 113    * @copydoc CustomActorImpl::OnSceneDisconnection()
 114    */
 115   void OnSceneDisconnection() override;
 116
 117   /**
 118    * @copydoc Toolkit::Control::GetNaturalSize
 119    */
 120   Vector3 GetNaturalSize() override;
 121
 122   /**
 123    * @copydoc Toolkit::Control::GetHeightForWidth()
 124    */
 125   float GetHeightForWidth(float width) override;
 126
 127   /**
 128    * @copydoc Toolkit::Control::GetWidthForHeight()
 129    */
 130   float GetWidthForHeight(float height) override;
 131
 132   /**
 133    * @copydoc Toolkit::Control::OnRelayout()
 134    */
 135   void OnRelayout(const Vector2& size, RelayoutContainer& container) override;
 136
 137   /**
 138    * @copydoc Toolkit::Control::IsResourceReady()
 139    */
 140   bool IsResourceReady() const override;
 141
 142   /**
 143    * @brief Loads a model from file
 144    */
 145   void LoadModel();
 146
 147   /**
 148    * @brief Scales the model to fit the control or to return to original size.
 149    */
 150   void ScaleModel();
 151
 152   /**
 153    * @brief Changes model anchor point to set the model at center or returns to the original model pivot.
 154    */
 155   void FitModelPosition();
 156
 157   /**
 158    * @brief Changes IBL information of the input node.
 159    */
 160   void CollectRenderableActor(Actor actor);
 161
 162   /**
 163    * @brief Changes IBL textures of the input node.
 164    */
 165   void UpdateImageBasedLightTexture();
 166
 167   /**
 168    * @brief Changes IBL scale factor of the input node.
 169    */
 170   void UpdateImageBasedLightScaleFactor();
 171
 172 private:
 173   std::string                    mModelUrl;
 174   std::string                    mResourceDirectoryUrl;
 175   Dali::Actor                    mModelRoot;
 176   std::vector<AnimationData>     mAnimations;
 177   std::vector<WeakHandle<Actor>> mRenderableActors;
 178   WeakHandle<Scene3D::SceneView> mParentSceneView;
 179
 180   Dali::Texture mSpecularTexture;
 181   Dali::Texture mDiffuseTexture;
 182   Vector3       mNaturalSize;
 183   Vector3       mModelPivot;
 184   float         mIblScaleFactor;
 185   bool          mModelResourceReady;
 186   bool          mIBLResourceReady;
 187 };
 188
 189 } // namespace Internal
 190
 191 // Helpers for public-api forwarding methods
 192 inline Dali::Scene3D::Internal::Model& GetImpl(Dali::Scene3D::Model& obj)
 193 {
 194   DALI_ASSERT_ALWAYS(obj);
 195   Dali::RefObject& handle = obj.GetImplementation();
 196   return static_cast<Dali::Scene3D::Internal::Model&>(handle);
 197 }
 198
 199 inline const Dali::Scene3D::Internal::Model& GetImpl(const Dali::Scene3D::Model& obj)
 200 {
 201   DALI_ASSERT_ALWAYS(obj);
 202   const Dali::RefObject& handle = obj.GetImplementation();
 203   return static_cast<const Dali::Scene3D::Internal::Model&>(handle);
 204 }
 205
 206 } // namespace Scene3D
 207
 208 } // namespace Dali
 209
 210 #endif // DALI_SCENE3D_INTERNAL_MODEL_H