dali-scene3d/public-api/loader/node-definition.cpp

   1 /*
   2  * Copyright (c) 2022 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 // INTERNAL
  19 #include "dali-scene3d/public-api/loader/node-definition.h"
  20 #include "dali-scene3d/public-api/loader/renderer-state.h"
  21 #include "dali-scene3d/public-api/loader/utils.h"
  22
  23 namespace Dali
  24 {
  25 namespace
  26 {
  27 constexpr std::string_view IBL_INTENSITY_STRING("uIblIntensity");
  28 constexpr std::string_view IBL_Y_DIRECTION("uYDirection");
  29 } // namespace
  30
  31 namespace Scene3D
  32 {
  33 namespace Loader
  34 {
  35 bool NodeDefinition::Renderable::GetExtents(const ResourceBundle& resources, Vector3& min, Vector3& max) const
  36 {
  37   return false;
  38 }
  39
  40 void NodeDefinition::Renderable::RegisterResources(IResourceReceiver& receiver) const
  41 {
  42   receiver.Register(ResourceType::Shader, mShaderIdx);
  43 }
  44
  45 void NodeDefinition::Renderable::ReflectResources(IResourceReflector& reflector)
  46 {
  47   reflector.Reflect(ResourceType::Shader, mShaderIdx);
  48 }
  49
  50 void NodeDefinition::Renderable::OnCreate(const NodeDefinition& node, CreateParams& params, Actor& actor) const
  51 {
  52   DALI_ASSERT_DEBUG(mShaderIdx != INVALID_INDEX);
  53   auto&  resources = params.mResources;
  54   Shader shader    = resources.mShaders[mShaderIdx].second;
  55
  56   static Geometry defaultGeometry = Geometry::New();
  57   Renderer        renderer        = Renderer::New(defaultGeometry, shader);
  58
  59   RendererState::Apply(resources.mShaders[mShaderIdx].first.mRendererState, renderer);
  60
  61   actor.AddRenderer(renderer);
  62 }
  63
  64 const std::string NodeDefinition::ORIGINAL_MATRIX_PROPERTY_NAME = "originalMatrix";
  65
  66 Actor NodeDefinition::CreateActor(CreateParams& params)
  67 {
  68   Actor actor = Actor::New();
  69   mNodeId     = actor.GetProperty<int32_t>(Dali::Actor::Property::ID);
  70
  71   SetActorCentered(actor);
  72
  73   actor.SetProperty(Actor::Property::NAME, mName);
  74   actor.SetProperty(Actor::Property::POSITION, mPosition);
  75   actor.SetProperty(Actor::Property::ORIENTATION, mOrientation);
  76   actor.SetProperty(Actor::Property::SCALE, mScale);
  77   actor.SetProperty(Actor::Property::SIZE, mSize);
  78   actor.SetProperty(Actor::Property::VISIBLE, mIsVisible);
  79
  80   actor.RegisterProperty(ORIGINAL_MATRIX_PROPERTY_NAME, GetLocalSpace(), Property::AccessMode::READ_ONLY);
  81
  82   for(auto& renderable : mRenderables)
  83   {
  84     renderable->OnCreate(*this, params, actor);
  85   }
  86
  87   for(auto& e : mExtras)
  88   {
  89     actor.RegisterProperty(e.mKey, e.mValue);
  90   }
  91
  92   for(auto& c : mConstraints)
  93   {
  94     params.mConstrainables.push_back(ConstraintRequest{&c, actor});
  95   }
  96
  97   return actor;
  98 }
  99
 100 Matrix NodeDefinition::GetLocalSpace() const
 101 {
 102   Matrix localSpace{false};
 103   localSpace.SetTransformComponents(mScale, mOrientation, mPosition);
 104   return localSpace;
 105 }
 106
 107 std::string_view NodeDefinition::GetIblScaleFactorUniformName()
 108 {
 109   return IBL_INTENSITY_STRING;
 110 }
 111
 112 std::string_view NodeDefinition::GetIblYDirectionUniformName()
 113 {
 114   return IBL_Y_DIRECTION;
 115 }
 116
 117 bool NodeDefinition::GetExtents(const ResourceBundle& resources, Vector3& min, Vector3& max) const
 118 {
 119   if(mRenderables.empty())
 120   {
 121     return false;
 122   }
 123
 124   bool useModelExtents = false;
 125   for(auto& renderable : mRenderables)
 126   {
 127     Vector3 renderableMin(Vector3::ONE * MAXFLOAT), renderableMax(-Vector3::ONE * MAXFLOAT);
 128     if(!renderable->GetExtents(resources, renderableMin, renderableMax))
 129     {
 130       useModelExtents = false;
 131       break;
 132     }
 133     useModelExtents = true;
 134     min.x           = std::min(min.x, renderableMin.x);
 135     min.y           = std::min(min.y, renderableMin.y);
 136     min.z           = std::min(min.z, renderableMin.z);
 137     max.x           = std::max(max.x, renderableMax.x);
 138     max.y           = std::max(max.y, renderableMax.y);
 139     max.z           = std::max(max.z, renderableMax.z);
 140   }
 141   if(!useModelExtents)
 142   {
 143     // If the renderable node don't have mesh accessor, use size to compute extents.
 144     min = -mSize / 2.0f;
 145     max = mSize / 2.0f;
 146   }
 147   return true;
 148 }
 149
 150 bool ModelRenderable::GetExtents(const ResourceBundle& resources, Vector3& min, Vector3& max) const
 151 {
 152   auto&    mesh    = resources.mMeshes[mMeshIdx];
 153   uint32_t minSize = mesh.first.mPositions.mBlob.mMin.size();
 154   uint32_t maxSize = mesh.first.mPositions.mBlob.mMax.size();
 155   if(minSize == maxSize && minSize >= 2u && maxSize >= 2u)
 156   {
 157     min = Vector3(mesh.first.mPositions.mBlob.mMin[0], mesh.first.mPositions.mBlob.mMin[1], 0.0f);
 158     max = Vector3(mesh.first.mPositions.mBlob.mMax[0], mesh.first.mPositions.mBlob.mMax[1], 0.0f);
 159     if(minSize == 3u)
 160     {
 161       min.z = mesh.first.mPositions.mBlob.mMin[2];
 162       max.z = mesh.first.mPositions.mBlob.mMax[2];
 163     }
 164     return true;
 165   }
 166   return false;
 167 }
 168
 169 void ModelRenderable::RegisterResources(IResourceReceiver& receiver) const
 170 {
 171   Renderable::RegisterResources(receiver);
 172   receiver.Register(ResourceType::Mesh, mMeshIdx);
 173   receiver.Register(ResourceType::Material, mMaterialIdx);
 174 }
 175
 176 void ModelRenderable::ReflectResources(IResourceReflector& reflector)
 177 {
 178   Renderable::ReflectResources(reflector);
 179   reflector.Reflect(ResourceType::Mesh, mMeshIdx);
 180   reflector.Reflect(ResourceType::Material, mMaterialIdx);
 181 }
 182
 183 void ModelRenderable::OnCreate(const NodeDefinition& node, NodeDefinition::CreateParams& params, Actor& actor) const
 184 {
 185   DALI_ASSERT_DEBUG(mMeshIdx != INVALID_INDEX);
 186   Renderable::OnCreate(node, params, actor);
 187
 188   auto& resources = params.mResources;
 189   auto& mesh      = resources.mMeshes[mMeshIdx];
 190
 191   auto     renderer = actor.GetRendererAt(actor.GetRendererCount() - 1u);
 192   Geometry geometry = mesh.second.geometry;
 193   renderer.SetGeometry(geometry);
 194
 195   auto shader = renderer.GetShader();
 196
 197   if(mesh.first.IsSkinned())
 198   {
 199     params.mSkinnables.push_back(SkinningShaderConfigurationRequest{mesh.first.mSkeletonIdx, shader});
 200   }
 201
 202   if(mesh.first.HasBlendShapes())
 203   {
 204     params.mBlendshapeRequests.push_back(BlendshapeShaderConfigurationRequest{node.mName, mMeshIdx, shader});
 205   }
 206
 207   TextureSet textures = resources.mMaterials[mMaterialIdx].second;
 208
 209   // Set the blend shape texture.
 210   if(mesh.second.blendShapeGeometry)
 211   {
 212     TextureSet newTextureSet = TextureSet::New();
 213     newTextureSet.SetTexture(0u, mesh.second.blendShapeGeometry);
 214
 215     const unsigned int numberOfTextures = textures.GetTextureCount();
 216     for(unsigned int index = 0u; index < numberOfTextures; ++index)
 217     {
 218       const unsigned int newIndex = index + 1u;
 219       newTextureSet.SetTexture(newIndex, textures.GetTexture(index));
 220       newTextureSet.SetSampler(newIndex, textures.GetSampler(index));
 221     }
 222
 223     textures = newTextureSet;
 224   }
 225
 226   renderer.RegisterProperty("uHasVertexColor", static_cast<float>(mesh.first.mColors.IsDefined()));
 227
 228   auto& matDef = resources.mMaterials[mMaterialIdx].first;
 229   actor.RegisterProperty("uColorFactor", matDef.mBaseColorFactor);
 230   actor.RegisterProperty("uMetallicFactor", matDef.mMetallic);
 231   actor.RegisterProperty("uRoughnessFactor", matDef.mRoughness);
 232   actor.RegisterProperty("uDielectricSpecular", matDef.mDielectricSpecular);
 233   actor.RegisterProperty("uSpecularFactor", matDef.mSpecularFactor);
 234   actor.RegisterProperty("uSpecularColorFactor", matDef.mSpecularColorFactor);
 235   actor.RegisterProperty("uNormalScale", matDef.mNormalScale);
 236   if(matDef.mFlags & MaterialDefinition::OCCLUSION)
 237   {
 238     renderer.RegisterProperty("uOcclusionStrength", matDef.mOcclusionStrength);
 239   }
 240   if(matDef.mFlags & MaterialDefinition::EMISSIVE)
 241   {
 242     renderer.RegisterProperty("uEmissiveFactor", matDef.mEmissiveFactor);
 243   }
 244
 245   Index envIdx = matDef.mEnvironmentIdx;
 246   renderer.RegisterProperty(IBL_INTENSITY_STRING.data(), resources.mEnvironmentMaps[envIdx].first.mIblIntensity);
 247   renderer.RegisterProperty(IBL_Y_DIRECTION.data(), resources.mEnvironmentMaps[envIdx].first.mYDirection);
 248
 249   float opaque      = matDef.mIsOpaque ? 1.0f : 0.0f;
 250   float mask        = matDef.mIsMask ? 1.0f : 0.0f;
 251   float alphaCutoff = matDef.GetAlphaCutoff();
 252
 253   renderer.RegisterProperty("uOpaque", opaque);
 254   renderer.RegisterProperty("uMask", mask);
 255   renderer.RegisterProperty("uAlphaThreshold", alphaCutoff);
 256
 257   renderer.SetTextures(textures);
 258
 259   actor.SetProperty(Actor::Property::COLOR, mColor);
 260 }
 261
 262 void ArcRenderable::OnCreate(const NodeDefinition& node, NodeDefinition::CreateParams& params, Actor& actor) const
 263 {
 264   ModelRenderable::OnCreate(node, params, actor);
 265
 266   actor.RegisterProperty("antiAliasing", mAntiAliasing ? 1 : 0);
 267   actor.RegisterProperty("arcCaps", mArcCaps);
 268   actor.RegisterProperty("radius", mRadius);
 269
 270   const float startAngleRadians = mStartAngleDegrees * Math::PI_OVER_180;
 271   Vector2     startPolar{std::cos(startAngleRadians), std::sin(startAngleRadians)};
 272   actor.RegisterProperty("startAngle", startPolar);
 273
 274   const float endAngleRadians = mEndAngleDegrees * Math::PI_OVER_180;
 275   Vector2     endPolar{std::cos(endAngleRadians), std::sin(endAngleRadians)};
 276   actor.RegisterProperty("endAngle", endPolar);
 277 }
 278
 279 void ArcRenderable::GetEndVectorWithDiffAngle(float startAngle, float diffAngle, Vector2& endVector)
 280 {
 281   float endAngle = 0.f;
 282
 283   if(diffAngle <= 0.001f)
 284   {
 285     // 0.001 is used to ensure is empty arc when startAngle = endAngle + 360 * N
 286     endAngle = startAngle + 0.001f;
 287   }
 288   else if(diffAngle >= 360.f)
 289   {
 290     endAngle = diffAngle + 359.99f;
 291   }
 292   else
 293   {
 294     endAngle = startAngle + 360.0f + diffAngle;
 295   }
 296   endVector.x = cosf(endAngle * Math::PI_OVER_180);
 297   endVector.y = sinf(endAngle * Math::PI_OVER_180);
 298 }
 299
 300 } // namespace Loader
 301 } // namespace Scene3D
 302 } // namespace Dali