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

   1 /*
   2  * Copyright (c) 2023 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/internal/model-components/model-primitive-impl.h>
  20
  21 // EXTERNAL INCLUDES
  22 #include <dali/devel-api/adaptor-framework/image-loading.h>
  23 #include <dali/public-api/animation/constraint.h>
  24 #include <dali/public-api/object/type-registry-helper.h>
  25 #include <dali/public-api/object/type-registry.h>
  26
  27 // INTERNAL INCLUDES
  28 #include <dali-scene3d/internal/common/image-resource-loader.h>
  29 #include <dali-scene3d/internal/light/light-impl.h>
  30 #include <dali-scene3d/internal/model-components/material-impl.h>
  31 #include <dali-scene3d/public-api/loader/environment-definition.h>
  32
  33 #include <dali/integration-api/debug.h>
  34
  35 namespace Dali
  36 {
  37 namespace Scene3D
  38 {
  39 namespace Internal
  40 {
  41 namespace
  42 {
  43 /**
  44  * Creates control through type registry
  45  */
  46 BaseHandle Create()
  47 {
  48   return Scene3D::ModelPrimitive::New();
  49 }
  50
  51 // Setup properties, signals and actions using the type-registry.
  52 DALI_TYPE_REGISTRATION_BEGIN(Scene3D::ModelPrimitive, Dali::BaseHandle, Create);
  53 DALI_TYPE_REGISTRATION_END()
  54
  55 static constexpr uint32_t INDEX_FOR_LIGHT_CONSTRAINT_TAG = 10;
  56
  57 } // unnamed namespace
  58
  59 ModelPrimitivePtr ModelPrimitive::New()
  60 {
  61   ModelPrimitivePtr primitive = new ModelPrimitive();
  62
  63   primitive->Initialize();
  64
  65   return primitive;
  66 }
  67
  68 ModelPrimitive::ModelPrimitive()
  69 : mShaderManager(new Scene3D::Loader::ShaderManager())
  70 {
  71 }
  72
  73 ModelPrimitive::~ModelPrimitive()
  74 {
  75   if(mMaterial)
  76   {
  77     GetImplementation(mMaterial).RemoveObserver(this);
  78   }
  79   mMaterial.Reset();
  80 }
  81
  82 void ModelPrimitive::Initialize()
  83 {
  84 }
  85
  86 void ModelPrimitive::SetRenderer(Dali::Renderer renderer)
  87 {
  88   mRenderer   = renderer;
  89   mGeometry   = renderer.GetGeometry();
  90   mTextureSet = renderer.GetTextures();
  91   mShader     = renderer.GetShader();
  92 }
  93
  94 Dali::Renderer ModelPrimitive::GetRenderer() const
  95 {
  96   return mRenderer;
  97 }
  98
  99 void ModelPrimitive::SetGeometry(Dali::Geometry geometry)
 100 {
 101   mGeometry = geometry;
 102   CreateRenderer();
 103 }
 104
 105 Dali::Geometry ModelPrimitive::GetGeometry() const
 106 {
 107   return mGeometry;
 108 }
 109
 110 void ModelPrimitive::SetMaterial(Dali::Scene3D::Material material, bool updateRenderer)
 111 {
 112   if(!material)
 113   {
 114     return;
 115   }
 116
 117   if(mMaterial != material)
 118   {
 119     // Stop observe from previous material.
 120     if(mMaterial)
 121     {
 122       GetImplementation(mMaterial).RemoveObserver(this);
 123     }
 124
 125     mMaterial = material;
 126
 127     // Start observe from new material.
 128
 129     if(mMaterial)
 130     {
 131       GetImplementation(mMaterial).AddObserver(this);
 132     }
 133
 134     if(updateRenderer)
 135     {
 136       mIsMaterialChanged = true;
 137       if(GetImplementation(mMaterial).IsResourceReady())
 138       {
 139         GetImplementation(mMaterial).UpdateMaterialData();
 140         ApplyMaterialToRenderer();
 141       }
 142     }
 143     UpdateShadowMapTexture();
 144     UpdateImageBasedLightTexture();
 145   }
 146 }
 147
 148 Dali::Scene3D::Material ModelPrimitive::GetMaterial() const
 149 {
 150   return mMaterial;
 151 }
 152
 153 void ModelPrimitive::AddPrimitiveObserver(ModelPrimitiveModifyObserver* observer)
 154 {
 155   mObservers.insert(observer);
 156 }
 157
 158 void ModelPrimitive::RemovePrimitiveObserver(ModelPrimitiveModifyObserver* observer)
 159 {
 160   mObservers.erase(observer);
 161 }
 162
 163 void ModelPrimitive::SetShadowMapTexture(Dali::Texture shadowMapTexture)
 164 {
 165   mShadowMapTexture = shadowMapTexture;
 166   UpdateShadowMapTexture();
 167 }
 168
 169 void ModelPrimitive::SetImageBasedLightTexture(Dali::Texture diffuseTexture, Dali::Texture specularTexture, float iblScaleFactor, uint32_t specularMipmapLevels)
 170 {
 171   mDiffuseTexture       = diffuseTexture;
 172   mSpecularTexture      = specularTexture;
 173   mIblScaleFactor       = iblScaleFactor;
 174   mSpecularMipmapLevels = specularMipmapLevels;
 175
 176   UpdateImageBasedLightTexture();
 177 }
 178
 179 void ModelPrimitive::SetImageBasedLightScaleFactor(float iblScaleFactor)
 180 {
 181   mIblScaleFactor = iblScaleFactor;
 182   if(mRenderer && mMaterial)
 183   {
 184     mRenderer.RegisterProperty(GetImplementation(mMaterial).GetImageBasedLightScaleFactorName().data(), iblScaleFactor);
 185   }
 186 }
 187
 188 void ModelPrimitive::UpdateShader(Scene3D::Loader::ShaderManagerPtr shaderManager)
 189 {
 190   if(mShaderManager != shaderManager)
 191   {
 192     mShaderManager = (shaderManager) ? shaderManager : new Scene3D::Loader::ShaderManager();
 193     if(mMaterial && GetImplementation(mMaterial).IsResourceReady())
 194     {
 195       ApplyMaterialToRenderer(MaterialModifyObserver::ModifyFlag::SHADER);
 196     }
 197   }
 198 }
 199
 200 void ModelPrimitive::SetBlendShapeData(Scene3D::Loader::BlendShapes::BlendShapeData& data)
 201 {
 202   mBlendShapeData = std::move(data);
 203   Scene3D::Loader::BlendShapes::ConfigureProperties(mBlendShapeData, mRenderer);
 204 }
 205
 206 void ModelPrimitive::SetBlendShapeGeometry(Dali::Texture blendShapeGeometry)
 207 {
 208   mBlendShapeGeometry = blendShapeGeometry;
 209 }
 210
 211 void ModelPrimitive::SetBlendShapeOptions(bool hasPositions, bool hasNormals, bool hasTangents, Scene3D::Loader::BlendShapes::Version version)
 212 {
 213   mHasPositions      = hasPositions;
 214   mHasNormals        = hasNormals;
 215   mHasTangents       = hasTangents;
 216   mBlendShapeVersion = version;
 217 }
 218
 219 void ModelPrimitive::SetSkinned(bool isSkinned)
 220 {
 221   mHasSkinning = isSkinned;
 222 }
 223
 224 // From MaterialModifyObserver
 225
 226 void ModelPrimitive::OnMaterialModified(Dali::Scene3D::Material material, MaterialModifyObserver::ModifyFlag flag)
 227 {
 228   ApplyMaterialToRenderer(flag);
 229 }
 230
 231 void ModelPrimitive::ApplyMaterialToRenderer(MaterialModifyObserver::ModifyFlag flag)
 232 {
 233   if(!mMaterial)
 234   {
 235     return;
 236   }
 237
 238   uint32_t shaderFlag = (flag & static_cast<uint32_t>(MaterialModifyObserver::ModifyFlag::SHADER));
 239   if(mIsMaterialChanged || shaderFlag == static_cast<uint32_t>(MaterialModifyObserver::ModifyFlag::SHADER))
 240   {
 241     Scene3D::Loader::ShaderOption shaderOption = GetImplementation(mMaterial).GetShaderOption();
 242
 243     shaderOption.AddOption(Scene3D::Loader::ShaderOption::Type::VEC4_TANGENT);
 244     if(mHasSkinning)
 245     {
 246       shaderOption.AddOption(Scene3D::Loader::ShaderOption::Type::SKINNING);
 247     }
 248     if(mHasPositions || mHasNormals || mHasTangents)
 249     {
 250       if(mHasPositions)
 251       {
 252         shaderOption.AddOption(Scene3D::Loader::ShaderOption::Type::MORPH_POSITION);
 253       }
 254       if(mHasNormals)
 255       {
 256         shaderOption.AddOption(Scene3D::Loader::ShaderOption::Type::MORPH_NORMAL);
 257       }
 258       if(mHasTangents)
 259       {
 260         shaderOption.AddOption(Scene3D::Loader::ShaderOption::Type::MORPH_TANGENT);
 261       }
 262       if(mBlendShapeVersion == Scene3D::Loader::BlendShapes::Version::VERSION_2_0)
 263       {
 264         shaderOption.AddOption(Scene3D::Loader::ShaderOption::Type::MORPH_VERSION_2_0);
 265       }
 266     }
 267
 268     mShader.Reset();
 269     mShader = mShaderManager->ProduceShader(shaderOption);
 270
 271     if(!mRenderer)
 272     {
 273       CreateRenderer();
 274     }
 275     else
 276     {
 277       mRenderer.SetShader(mShader);
 278     }
 279   }
 280
 281   uint32_t textureFlag = (flag & static_cast<uint32_t>(MaterialModifyObserver::ModifyFlag::TEXTURE));
 282   if(mIsMaterialChanged || textureFlag == static_cast<uint32_t>(MaterialModifyObserver::ModifyFlag::TEXTURE))
 283   {
 284     mTextureSet = GetImplementation(mMaterial).GetTextureSet();
 285
 286     if(mBlendShapeGeometry)
 287     {
 288       TextureSet newTextureSet = TextureSet::New();
 289       newTextureSet.SetTexture(0u, mBlendShapeGeometry);
 290
 291       const unsigned int numberOfTextures = mTextureSet.GetTextureCount();
 292       for(unsigned int index = 0u; index < numberOfTextures; ++index)
 293       {
 294         const unsigned int newIndex = index + 1u;
 295         newTextureSet.SetTexture(newIndex, mTextureSet.GetTexture(index));
 296         newTextureSet.SetSampler(newIndex, mTextureSet.GetSampler(index));
 297       }
 298
 299       mTextureSet = newTextureSet;
 300     }
 301
 302     uint32_t textureCount = mTextureSet.GetTextureCount();
 303
 304     if(!mShadowMapTexture)
 305     {
 306       mShadowMapTexture = Dali::Scene3D::Internal::ImageResourceLoader::GetEmptyTextureWhiteRGB();
 307     }
 308     mTextureSet.SetTexture(textureCount++, mShadowMapTexture);
 309
 310     Texture brdfTexture = Scene3D::Loader::EnvironmentDefinition::GetBrdfTexture();
 311     if(!mSpecularTexture || !mDiffuseTexture)
 312     {
 313       Scene3D::Loader::EnvironmentMapData environmentMapData;
 314       environmentMapData.mPixelData.resize(6);
 315       for(auto& face : environmentMapData.mPixelData)
 316       {
 317         face.push_back(PixelData::New(new uint8_t[3]{0xff, 0xff, 0xff}, 3, 1, 1, Pixel::RGB888, PixelData::DELETE_ARRAY));
 318       }
 319       environmentMapData.SetEnvironmentMapType(Dali::Scene3D::EnvironmentMapType::CUBEMAP);
 320       Texture iblTexture = environmentMapData.GetTexture();
 321       mDiffuseTexture    = iblTexture;
 322       mSpecularTexture   = iblTexture;
 323     }
 324
 325     mTextureSet.SetTexture(textureCount++, brdfTexture);
 326     mTextureSet.SetTexture(textureCount++, mDiffuseTexture);
 327     mTextureSet.SetTexture(textureCount, mSpecularTexture);
 328
 329     auto specularSampler = Sampler::New();
 330     specularSampler.SetWrapMode(WrapMode::CLAMP_TO_EDGE, WrapMode::CLAMP_TO_EDGE, WrapMode::CLAMP_TO_EDGE);
 331     specularSampler.SetFilterMode(FilterMode::LINEAR_MIPMAP_LINEAR, FilterMode::LINEAR);
 332     mTextureSet.SetSampler(textureCount, specularSampler);
 333
 334     if(!mRenderer)
 335     {
 336       CreateRenderer();
 337     }
 338     else
 339     {
 340       mRenderer.SetTextures(mTextureSet);
 341     }
 342   }
 343
 344   uint32_t uniformFlag = (flag & static_cast<uint32_t>(MaterialModifyObserver::ModifyFlag::UNIFORM));
 345   if(mIsMaterialChanged || uniformFlag == static_cast<uint32_t>(MaterialModifyObserver::ModifyFlag::UNIFORM))
 346   {
 347     if(!mRenderer)
 348     {
 349       mNeedToSetRendererUniform = true;
 350     }
 351     else
 352     {
 353       UpdateRendererUniform();
 354     }
 355   }
 356   mIsMaterialChanged = false;
 357 }
 358
 359 void ModelPrimitive::CreateRenderer()
 360 {
 361   if(!mShader || !mGeometry || !mTextureSet || mRenderer)
 362   {
 363     return;
 364   }
 365
 366   mRenderer = Renderer::New(mGeometry, mShader);
 367   mRenderer.SetTextures(mTextureSet);
 368   UpdateRendererUniform();
 369
 370   for(auto* observer : mObservers)
 371   {
 372     observer->OnRendererCreated(mRenderer);
 373   }
 374 }
 375
 376 void ModelPrimitive::UpdateShadowMapTexture()
 377 {
 378   if(mRenderer && mMaterial)
 379   {
 380     Dali::TextureSet textures = mRenderer.GetTextures();
 381     if(!textures)
 382     {
 383       return;
 384     }
 385
 386     uint32_t textureCount = textures.GetTextureCount();
 387     if(mShadowMapTexture &&
 388        textureCount >= GetImplementation(mMaterial).GetShadowMapTextureOffset() &&
 389        textures.GetTexture(textureCount - GetImplementation(mMaterial).GetShadowMapTextureOffset()) != mShadowMapTexture)
 390     {
 391       Dali::TextureSet newTextures = Dali::TextureSet::New();
 392
 393       for(uint32_t index = 0u; index < textureCount; ++index)
 394       {
 395         Dali::Texture texture = textures.GetTexture(index);
 396         if(index == textureCount - GetImplementation(mMaterial).GetShadowMapTextureOffset())
 397         {
 398           texture = (!!mShadowMapTexture) ? mShadowMapTexture : Dali::Scene3D::Internal::ImageResourceLoader::GetEmptyTextureWhiteRGB();
 399         }
 400
 401         newTextures.SetTexture(index, texture);
 402         newTextures.SetSampler(index, textures.GetSampler(index));
 403       }
 404
 405       mRenderer.SetTextures(newTextures);
 406     }
 407   }
 408 }
 409
 410 void ModelPrimitive::UpdateImageBasedLightTexture()
 411 {
 412   if(mRenderer && mMaterial)
 413   {
 414     Dali::TextureSet textures = mRenderer.GetTextures();
 415     if(!textures)
 416     {
 417       return;
 418     }
 419
 420     uint32_t textureCount = textures.GetTextureCount();
 421     if(textureCount > 2u &&
 422        (textures.GetTexture(textureCount - GetImplementation(mMaterial).GetDiffuseImageBasedLightTextureOffset()) != mDiffuseTexture ||
 423         textures.GetTexture(textureCount - GetImplementation(mMaterial).GetSpecularImageBasedLightTextureOffset()) != mSpecularTexture))
 424     {
 425       Dali::TextureSet newTextures = Dali::TextureSet::New();
 426
 427       for(uint32_t index = 0u; index < textureCount; ++index)
 428       {
 429         Dali::Texture texture = textures.GetTexture(index);
 430         if(index == textureCount - GetImplementation(mMaterial).GetDiffuseImageBasedLightTextureOffset())
 431         {
 432           texture = mDiffuseTexture;
 433         }
 434         else if(index == textureCount - GetImplementation(mMaterial).GetSpecularImageBasedLightTextureOffset())
 435         {
 436           texture = mSpecularTexture;
 437         }
 438
 439         newTextures.SetTexture(index, texture);
 440         newTextures.SetSampler(index, textures.GetSampler(index));
 441       }
 442
 443       mRenderer.SetTextures(newTextures);
 444     }
 445     mRenderer.RegisterProperty(GetImplementation(mMaterial).GetImageBasedLightScaleFactorName().data(), mIblScaleFactor);
 446     mRenderer.RegisterProperty(GetImplementation(mMaterial).GetImageBasedLightMaxLodUniformName().data(), static_cast<float>(mSpecularMipmapLevels));
 447   }
 448 }
 449
 450 void ModelPrimitive::UpdateRendererUniform()
 451 {
 452   if(mMaterial)
 453   {
 454     mRenderer.RegisterProperty(GetImplementation(mMaterial).GetImageBasedLightScaleFactorName().data(), mIblScaleFactor);
 455     mRenderer.RegisterProperty(GetImplementation(mMaterial).GetImageBasedLightMaxLodUniformName().data(), static_cast<float>(mSpecularMipmapLevels));
 456     GetImplementation(mMaterial).SetRendererUniform(mRenderer);
 457   }
 458 }
 459
 460 } // namespace Internal
 461
 462 } // namespace Scene3D
 463
 464 } // namespace Dali