dali-scene3d/internal/model-components/model-primitive-impl.h

   1 #ifndef DALI_SCENE3D_MODEL_COMPONENTS_MODEL_PRIMITIVE_IMPL_H
   2 #define DALI_SCENE3D_MODEL_COMPONENTS_MODEL_PRIMITIVE_IMPL_H
   3
   4 /*
   5  * Copyright (c) 2023 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/public-api/common/dali-common.h>
  23 #include <dali/public-api/common/intrusive-ptr.h>
  24 #include <dali/public-api/object/base-object.h>
  25 #include <dali/public-api/object/property-value.h>
  26 #include <dali/public-api/object/property.h>
  27 #include <set>
  28
  29 // INTERNAL INCLUDES
  30 #include <dali-scene3d/internal/model-components/material-modify-observer.h>
  31 #include <dali-scene3d/internal/model-components/model-primitive-modify-observer.h>
  32 #include <dali-scene3d/public-api/light/light.h>
  33 #include <dali-scene3d/public-api/loader/blend-shape-details.h>
  34 #include <dali-scene3d/public-api/loader/mesh-definition.h>
  35 #include <dali-scene3d/public-api/loader/shader-manager.h>
  36 #include <dali-scene3d/public-api/model-components/material.h>
  37 #include <dali-scene3d/public-api/model-components/model-primitive.h>
  38
  39 namespace Dali
  40 {
  41 namespace Scene3D
  42 {
  43 namespace Internal
  44 {
  45 using ModelPrimitivePtr = IntrusivePtr<ModelPrimitive>;
  46
  47 /**
  48  * @brief TODO : Explain me.
  49  * Use Vector4 Tangent data
  50  * Same ModelPrimitive all shares IBL
  51  */
  52 class ModelPrimitive : public BaseObject, public MaterialModifyObserver
  53 {
  54 private:
  55   using ModelPrimitiveModifyObserverContainer = std::set<ModelPrimitiveModifyObserver*>;
  56
  57 public:
  58   // Creation & Destruction
  59   /**
  60    * @brief Create a new ModelPrimitive object.
  61    * @return A smart-pointer to the newly allocated ModelPrimitive.
  62    */
  63   static ModelPrimitivePtr New();
  64
  65 protected:
  66   /**
  67    * @brief Construct a new ModelPrimitive.
  68    */
  69   ModelPrimitive();
  70
  71   /**
  72    * @brief Second-phase constructor.
  73    */
  74   void Initialize();
  75
  76   /**
  77    * @brief Virtual destructor.
  78    */
  79   virtual ~ModelPrimitive();
  80
  81 public:
  82   /**
  83    * @brief Set Renderer that is created by Scene3D::Loader internally.
  84    */
  85   void SetRenderer(Dali::Renderer renderer);
  86
  87   /**
  88    * @copydoc Dali::Scene3D::ModelPrimitive::GetRenderer()
  89    */
  90   Dali::Renderer GetRenderer() const;
  91
  92   /**
  93    * @copydoc Dali::Scene3D::ModelPrimitive::SetGeometry()
  94    */
  95   void SetGeometry(Dali::Geometry geometry);
  96
  97   /**
  98    * @copydoc Dali::Scene3D::ModelPrimitive::GetGeometry()
  99    */
 100   Dali::Geometry GetGeometry() const;
 101
 102   /**
 103    * @copydoc Dali::Scene3D::ModelPrimitive::SetMaterial()
 104    */
 105   void SetMaterial(Dali::Scene3D::Material material, bool updateRenderer = true);
 106
 107   /**
 108    * @copydoc Dali::Scene3D::ModelPrimitive::GetMaterial()
 109    */
 110   Dali::Scene3D::Material GetMaterial() const;
 111
 112   /**
 113    * @brief Adds a primitive observer to this model primitive.
 114    *
 115    * @param[in] observer The observer to add.
 116    */
 117   void AddPrimitiveObserver(ModelPrimitiveModifyObserver* observer);
 118
 119   /**
 120    * @brief Removes a primitive observer from this model primitive.
 121    *
 122    * @param[in] observer The observer to remove.
 123    */
 124   void RemovePrimitiveObserver(ModelPrimitiveModifyObserver* observer);
 125
 126   /**
 127    * @brief Sets the image-based lighting texture for this model primitive.
 128    *
 129    * @param[in] diffuseTexture The diffuse texture.
 130    * @param[in] specularTexture The specular texture.
 131    * @param[in] iblScaleFactor The scale factor to set for image-based lighting.
 132    * @param[in] specularMipmapLevels The number of mipmap levels of specular texture.
 133    */
 134   void SetImageBasedLightTexture(Dali::Texture diffuseTexture, Dali::Texture specularTexture, float iblScaleFactor, uint32_t specularMipmapLevels);
 135
 136   /**
 137    * @brief Sets the scale factor for image-based lighting for this model primitive.
 138    *
 139    * @param[in] iblScaleFactor The scale factor to set for image-based lighting.
 140    */
 141   void SetImageBasedLightScaleFactor(float iblScaleFactor);
 142
 143   /**
 144    * @brief Updates shaders by using current material
 145    *
 146    * @param[in] shaderManager Shader manager to create shader.
 147    */
 148   void UpdateShader(Scene3D::Loader::ShaderManagerPtr shaderManager);
 149
 150   /**
 151    * @brief Sets the blend shape data for this model primitive.
 152    *
 153    * @param[in] data The blend shape data to set.
 154    */
 155   void SetBlendShapeData(Scene3D::Loader::BlendShapes::BlendShapeData& data);
 156
 157   /**
 158    * @brief Sets the blend shape geometry for this model primitive.
 159    *
 160    * @param[in] blendShapeGeometry The blend shape geometry to set.
 161    */
 162   void SetBlendShapeGeometry(Dali::Texture blendShapeGeometry);
 163
 164   /**
 165    * @brief Sets the blend shape options for this model primitive.
 166    *
 167    * @param[in] hasPositions Whether or not this model primitive has positions for blend shapes.
 168    * @param[in] hasNormals Whether or not this model primitive has normals for blend shapes.
 169    * @param[in] hasTangents Whether or not this model primitive has tangents for blend shapes.
 170    * @param[in] version blendShape version.
 171    */
 172   void SetBlendShapeOptions(bool hasPositions, bool hasNormals, bool hasTangents, Scene3D::Loader::BlendShapes::Version version);
 173
 174   /**
 175    * @brief Sets whether or not this model primitive is skinned.
 176    *
 177    * @param[in] isSkinned Whether or not this model primitive is skinned.
 178    */
 179   void SetSkinned(bool isSkinned);
 180
 181 private: // From MaterialModifyObserver
 182   /**
 183    * @copydoc Dali::Scene3D::Internal::Material::MaterialModifyObserver::OnMaterialModified()
 184    */
 185   void OnMaterialModified(Dali::Scene3D::Material material, MaterialModifyObserver::ModifyFlag flag) override;
 186
 187 private:
 188   /**
 189    * @brief Apply materials data into renderer.
 190    */
 191   void ApplyMaterialToRenderer(MaterialModifyObserver::ModifyFlag flag = MaterialModifyObserver::ModifyFlag::NONE);
 192
 193   /**
 194    * @brief Updates the uniform of renderer.
 195    */
 196   void UpdateRendererUniform();
 197
 198   /**
 199    * @brief Creates a renderer.
 200    */
 201   void CreateRenderer();
 202
 203   /**
 204    * @brief Updates the image-based lighting texture.
 205    */
 206   void UpdateImageBasedLightTexture();
 207
 208 private:
 209   // Delete copy & move operator
 210   ModelPrimitive(const ModelPrimitive&)                    = delete;
 211   ModelPrimitive(ModelPrimitive&&)                         = delete;
 212   ModelPrimitive& operator=(const ModelPrimitive& rhs)     = delete;
 213   ModelPrimitive& operator=(ModelPrimitive&& rhs) noexcept = delete;
 214
 215 private:
 216   ModelPrimitiveModifyObserverContainer mObservers{};
 217
 218   // For Renderer
 219   Dali::Renderer          mRenderer;
 220   Dali::Geometry          mGeometry;
 221   Dali::Shader            mShader;
 222   Dali::TextureSet        mTextureSet;
 223   Dali::Scene3D::Material mMaterial;
 224
 225   Scene3D::Loader::ShaderManagerPtr mShaderManager;
 226
 227   // For IBL
 228   Dali::Texture mSpecularTexture;
 229   Dali::Texture mDiffuseTexture;
 230   float         mIblScaleFactor{1.0f};
 231   uint32_t      mSpecularMipmapLevels{1u};
 232
 233   // For blend shape
 234   Scene3D::Loader::BlendShapes::BlendShapeData mBlendShapeData;
 235   Dali::Texture                                mBlendShapeGeometry;
 236   bool                                         mHasSkinning       = false;
 237   bool                                         mHasPositions      = false;
 238   bool                                         mHasNormals        = false;
 239   bool                                         mHasTangents       = false;
 240   Scene3D::Loader::BlendShapes::Version        mBlendShapeVersion = Scene3D::Loader::BlendShapes::Version::INVALID;
 241
 242   bool mIsMaterialChanged        = false;
 243   bool mNeedToSetRendererUniform = false;
 244 };
 245
 246 } // namespace Internal
 247
 248 // Helpers for public-api forwarding methods
 249
 250 inline Internal::ModelPrimitive& GetImplementation(Dali::Scene3D::ModelPrimitive& modelPrimitive)
 251 {
 252   DALI_ASSERT_ALWAYS(modelPrimitive && "ModelPrimitive handle is empty");
 253
 254   BaseObject& handle = modelPrimitive.GetBaseObject();
 255
 256   return static_cast<Internal::ModelPrimitive&>(handle);
 257 }
 258
 259 inline const Internal::ModelPrimitive& GetImplementation(const Dali::Scene3D::ModelPrimitive& modelPrimitive)
 260 {
 261   DALI_ASSERT_ALWAYS(modelPrimitive && "ModelPrimitive handle is empty");
 262
 263   const BaseObject& handle = modelPrimitive.GetBaseObject();
 264
 265   return static_cast<const Internal::ModelPrimitive&>(handle);
 266 }
 267
 268 } // namespace Scene3D
 269
 270 } // namespace Dali
 271
 272 #endif // DALI_SCENE3D_MODEL_COMPONENTS_MODEL_PRIMITIVE_IMPL_H