[dali_2.3.24] Merge branch 'devel/master'

[platform/core/uifw/dali-toolkit.git] / dali-scene3d / public-api / loader / node-definition.cpp

diff --git a/dali-scene3d/public-api/loader/node-definition.cpp b/dali-scene3d/public-api/loader/node-definition.cpp
index f0a0eba..013b4f3 100644 (file)
--- a/dali-scene3d/public-api/loader/node-definition.cpp
+++ b/dali-scene3d/public-api/loader/node-definition.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2024 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -253,12 +253,18 @@ void ModelRenderable::ReflectResources(IResourceReflector& reflector)
   reflector.Reflect(ResourceType::Material, mMaterialIdx);
 }
 
+// How many shader managers are there?!
 void ModelRenderable::OnCreate(const NodeDefinition& nodeDefinition, NodeDefinition::CreateParams& params, ModelNode& node) const
 {
   DALI_ASSERT_DEBUG(mMeshIdx != INVALID_INDEX);
+  ShaderOption::HashType shaderOptionHash{0u};
   if(mShaderIdx == INVALID_INDEX)
   {
-    Shader          shader          = params.mShaderManager->ProduceShader(params.mResources.mMaterials[mMaterialIdx].first, params.mResources.mMeshes[mMeshIdx].first);
+    ShaderOption option = params.mShaderManager->ProduceShaderOption(params.mResources.mMaterials[mMaterialIdx].first,
+                                                                     params.mResources.mMeshes[mMeshIdx].first);
+    shaderOptionHash    = option.GetOptionHash();
+    Shader shader       = params.mShaderManager->ProduceShader(option);
+
     static Geometry defaultGeometry = Geometry::New();
     Renderer        renderer        = Renderer::New(defaultGeometry, shader);
 
@@ -299,23 +305,24 @@ void ModelRenderable::OnCreate(const NodeDefinition& nodeDefinition, NodeDefinit
 
   {
     mesh.first.mModelPrimitive = ModelPrimitive::New();
-    auto primitive             = mesh.first.mModelPrimitive;
-    GetImplementation(primitive).SetRenderer(renderer);
+    auto& primitive            = GetImplementation(mesh.first.mModelPrimitive);
+    primitive.SetRenderer(renderer);
 
     Index    envIndex       = resources.mMaterials[mMaterialIdx].first.mEnvironmentIdx;
     uint32_t specularMipmap = resources.mEnvironmentMaps[envIndex].second.mSpecularMipmapLevels;
-    GetImplementation(primitive).SetImageBasedLightTexture(resources.mEnvironmentMaps[envIndex].second.mDiffuse,
-                                                           resources.mEnvironmentMaps[envIndex].second.mSpecular,
-                                                           resources.mEnvironmentMaps[envIndex].first.mIblIntensity,
-                                                           specularMipmap);
+    primitive.SetImageBasedLightTexture(resources.mEnvironmentMaps[envIndex].second.mDiffuse,
+                                        resources.mEnvironmentMaps[envIndex].second.mSpecular,
+                                        resources.mEnvironmentMaps[envIndex].first.mIblIntensity,
+                                        specularMipmap);
 
     bool hasPositions = false;
     bool hasNormals   = false;
     bool hasTangents  = false;
     mesh.first.RetrieveBlendShapeComponents(hasPositions, hasNormals, hasTangents);
-    GetImplementation(primitive).SetBlendShapeOptions(hasPositions, hasNormals, hasTangents, mesh.first.mBlendShapeVersion);
-    GetImplementation(primitive).SetBlendShapeGeometry(mesh.second.blendShapeGeometry);
-    GetImplementation(primitive).SetSkinned(mesh.first.IsSkinned());
+    primitive.SetBlendShapeOptions(hasPositions, hasNormals, hasTangents, mesh.first.mBlendShapeVersion);
+    primitive.SetBlendShapeGeometry(mesh.second.blendShapeGeometry);
+    primitive.SetSkinned(mesh.first.IsSkinned(), mesh.first.GetNumberOfJointSets());
+    primitive.SetVertexColor(mesh.first.HasVertexColor());
   }
 
   auto shader = renderer.GetShader();
@@ -343,6 +350,73 @@ void ModelRenderable::OnCreate(const NodeDefinition& nodeDefinition, NodeDefinit
     renderer.RegisterProperty("uOcclusionStrength", matDef.mOcclusionStrength);
   }
 
+  renderer.RegisterProperty("uBaseColorTextureTransformAvailable", 0.0f);
+  renderer.RegisterProperty("uNormalTextureTransformAvailable", 0.0f);
+  renderer.RegisterProperty("uNormalRoughnessTextureTransformAvailable", 0.0f);
+  renderer.RegisterProperty("uMetalRoughnessTextureTransformAvailable", 0.0f);
+  renderer.RegisterProperty("uOcclusionTextureTransformAvailable", 0.0f);
+  renderer.RegisterProperty("uEmissiveTextureTransformAvailable", 0.0f);
+
+  renderer.RegisterProperty("uBaseColorTextureTransform", Matrix3::IDENTITY);
+  renderer.RegisterProperty("uNormalRoughnessTextureTransform", Matrix3::IDENTITY);
+  renderer.RegisterProperty("uNormalTextureTransform", Matrix3::IDENTITY);
+  renderer.RegisterProperty("uMetalRoughnessTextureTransform", Matrix3::IDENTITY);
+  renderer.RegisterProperty("uOcclusionTextureTransform", Matrix3::IDENTITY);
+  renderer.RegisterProperty("uEmissiveTextureTransform", Matrix3::IDENTITY);
+
+  auto iTexture   = matDef.mTextureStages.begin();
+  auto checkStage = [&](uint32_t flags) {
+    return iTexture != matDef.mTextureStages.end() && MaskMatch(iTexture->mSemantic, flags);
+  };
+
+  if(checkStage(MaterialDefinition::ALBEDO | MaterialDefinition::METALLIC))
+  {
+    renderer.RegisterProperty("uBaseColorTextureTransformAvailable", iTexture->mTexture.mTransform != Matrix3::IDENTITY);
+    renderer.RegisterProperty("uBaseColorTextureTransform", iTexture->mTexture.mTransform);
+    ++iTexture;
+
+    if(checkStage(MaterialDefinition::NORMAL | MaterialDefinition::ROUGHNESS))
+    {
+      renderer.RegisterProperty("uNormalRoughnessTextureTransformAvailable", iTexture->mTexture.mTransform != Matrix3::IDENTITY);
+      renderer.RegisterProperty("uNormalRoughnessTextureTransform", iTexture->mTexture.mTransform);
+      ++iTexture;
+    }
+  }
+  else if(checkStage(MaterialDefinition::ALBEDO))
+  {
+    renderer.RegisterProperty("uBaseColorTextureTransformAvailable", iTexture->mTexture.mTransform != Matrix3::IDENTITY);
+    renderer.RegisterProperty("uBaseColorTextureTransform", iTexture->mTexture.mTransform);
+    ++iTexture;
+  }
+
+  if(checkStage(MaterialDefinition::METALLIC | MaterialDefinition::ROUGHNESS))
+  {
+    renderer.RegisterProperty("uMetalRoughnessTextureTransformAvailable", iTexture->mTexture.mTransform != Matrix3::IDENTITY);
+    renderer.RegisterProperty("uMetalRoughnessTextureTransform", iTexture->mTexture.mTransform);
+    ++iTexture;
+  }
+
+  if(checkStage(MaterialDefinition::NORMAL))
+  {
+    renderer.RegisterProperty("uNormalTextureTransformAvailable", iTexture->mTexture.mTransform != Matrix3::IDENTITY);
+    renderer.RegisterProperty("uNormalTextureTransform", iTexture->mTexture.mTransform);
+    ++iTexture;
+  }
+
+  if(checkStage(MaterialDefinition::OCCLUSION))
+  {
+    renderer.RegisterProperty("uOcclusionTextureTransformAvailable", iTexture->mTexture.mTransform != Matrix3::IDENTITY);
+    renderer.RegisterProperty("uOcclusionTextureTransform", iTexture->mTexture.mTransform);
+    ++iTexture;
+  }
+
+  if(checkStage(MaterialDefinition::EMISSIVE))
+  {
+    renderer.RegisterProperty("uEmissiveTextureTransformAvailable", iTexture->mTexture.mTransform != Matrix3::IDENTITY);
+    renderer.RegisterProperty("uEmissiveTextureTransform", iTexture->mTexture.mTransform);
+    ++iTexture;
+  }
+
   float opaque      = matDef.mIsOpaque ? 1.0f : 0.0f;
   float mask        = matDef.mIsMask ? 1.0f : 0.0f;
   float alphaCutoff = matDef.GetAlphaCutoff();
@@ -371,9 +445,10 @@ void ModelRenderable::OnCreate(const NodeDefinition& nodeDefinition, NodeDefinit
       Internal::Material::TextureInformation textureInformation;
       if(matDef.CheckTextures(SEMANTICS[i]))
       {
-        textureInformation.mTexture = textures.GetTexture(textureIndex + textureIndexOffset);
-        textureInformation.mSampler = textures.GetSampler(textureIndex + textureIndexOffset);
-        textureInformation.mUrl     = matDef.mTextureStages[textureIndex].mTexture.mDirectoryPath + matDef.mTextureStages[textureIndex].mTexture.mImageUri;
+        textureInformation.mTexture   = textures.GetTexture(textureIndex + textureIndexOffset);
+        textureInformation.mSampler   = textures.GetSampler(textureIndex + textureIndexOffset);
+        textureInformation.mUrl       = matDef.mTextureStages[textureIndex].mTexture.mDirectoryPath + matDef.mTextureStages[textureIndex].mTexture.mImageUri;
+        textureInformation.mTransform = matDef.mTextureStages[textureIndex].mTexture.mTransform;
         textureIndex++;
       }
       textureInformation.mFactor = GetTextureFactor(matDef, SEMANTICS[i]);
@@ -383,11 +458,13 @@ void ModelRenderable::OnCreate(const NodeDefinition& nodeDefinition, NodeDefinit
     material.SetProperty(Scene3D::Material::Property::ALPHA_CUTOFF, matDef.GetAlphaCutoff());
     material.SetProperty(Scene3D::Material::Property::DOUBLE_SIDED, matDef.mDoubleSided);
     material.SetProperty(Scene3D::Material::Property::IOR, matDef.mIor);
+
+    // This _should_ keep the same shader as generated at the top of the method.
     GetImplementation(mesh.first.mModelPrimitive).SetMaterial(material, false);
     GetImplementation(material).ResetFlag();
   }
 
-  node.AddModelPrimitive(mesh.first.mModelPrimitive);
+  Internal::GetImplementation(node).AddModelPrimitive(mesh.first.mModelPrimitive, shaderOptionHash);
 }
 
 void ArcRenderable::OnCreate(const NodeDefinition& nodeDefinition, NodeDefinition::CreateParams& params, ModelNode& node) const