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

   1 /*
   2  * Copyright (c) 2020 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-scene-loader/public-api/node-definition.h"
  20 #include "dali-scene-loader/public-api/renderer-state.h"
  21 #include "dali-scene-loader/public-api/utils.h"
  22
  23 namespace Dali
  24 {
  25 namespace SceneLoader
  26 {
  27
  28 void NodeDefinition::Renderable::RegisterResources(IResourceReceiver& receiver) const
  29 {
  30   receiver.Register(ResourceType::Shader, mShaderIdx);
  31 }
  32
  33 void NodeDefinition::Renderable::ReflectResources(IResourceReflector& reflector)
  34 {
  35   reflector.Reflect(ResourceType::Shader, mShaderIdx);
  36 }
  37
  38 void NodeDefinition::Renderable::OnCreate(const NodeDefinition& node, CreateParams& params,
  39   Actor& actor) const
  40 {
  41   DALI_ASSERT_DEBUG(mShaderIdx != INVALID_INDEX);
  42   auto& resources = params.mResources;
  43   Shader shader = resources.mShaders[mShaderIdx].second;
  44
  45   static Geometry defaultGeometry = Geometry::New();
  46   Renderer renderer = Renderer::New(defaultGeometry, shader);
  47
  48   RendererState::Apply(resources.mShaders[mShaderIdx].first.mRendererState, renderer);
  49
  50   actor.AddRenderer(renderer);
  51 }
  52
  53 const std::string NodeDefinition::ORIGINAL_MATRIX_PROPERTY_NAME = "originalMatrix";
  54
  55 Actor NodeDefinition::CreateActor(CreateParams& params) const
  56 {
  57   Actor actor = Actor::New();
  58   SetActorCentered(actor);
  59
  60   actor.SetProperty(Actor::Property::NAME, mName);
  61   actor.SetProperty(Actor::Property::POSITION, mPosition);
  62   actor.SetProperty(Actor::Property::ORIENTATION, mOrientation);
  63   actor.SetProperty(Actor::Property::SCALE, mScale);
  64   actor.SetProperty(Actor::Property::SIZE, mSize);
  65   actor.SetProperty(Actor::Property::VISIBLE, mIsVisible);
  66
  67   actor.RegisterProperty(ORIGINAL_MATRIX_PROPERTY_NAME, GetLocalSpace(), Property::AccessMode::READ_ONLY);
  68
  69   if (mRenderable)
  70   {
  71     mRenderable->OnCreate(*this, params, actor);
  72   }
  73
  74   for (auto& e : mExtras)
  75   {
  76     actor.RegisterProperty(e.mKey, e.mValue);
  77   }
  78
  79   for (auto& c : mConstraints)
  80   {
  81     params.mConstrainables.push_back(ConstraintRequest{ &c, actor });
  82   }
  83
  84   return actor;
  85 }
  86
  87 Matrix NodeDefinition::GetLocalSpace() const
  88 {
  89   Matrix localSpace{ false };
  90   localSpace.SetTransformComponents(mScale, mOrientation, mPosition);
  91   return localSpace;
  92 }
  93
  94 void ModelNode::RegisterResources(IResourceReceiver& receiver) const
  95 {
  96   Renderable::RegisterResources(receiver);
  97   receiver.Register(ResourceType::Mesh, mMeshIdx);
  98   receiver.Register(ResourceType::Material, mMaterialIdx);
  99 }
 100
 101 void ModelNode::ReflectResources(IResourceReflector& reflector)
 102 {
 103   Renderable::ReflectResources(reflector);
 104   reflector.Reflect(ResourceType::Mesh, mMeshIdx);
 105   reflector.Reflect(ResourceType::Material, mMaterialIdx);
 106 }
 107
 108 void ModelNode::OnCreate(const NodeDefinition& node, NodeDefinition::CreateParams& params, Actor& actor) const
 109 {
 110   DALI_ASSERT_DEBUG(mMeshIdx != INVALID_INDEX);
 111   Renderable::OnCreate(node, params, actor);
 112
 113   auto& resources = params.mResources;
 114   auto& mesh = resources.mMeshes[mMeshIdx];
 115
 116   auto renderer = actor.GetRendererAt(0);
 117   Geometry geometry = mesh.second.geometry;
 118   renderer.SetGeometry(geometry);
 119
 120   auto shader = renderer.GetShader();
 121
 122   if (mesh.first.IsSkinned())
 123   {
 124     params.mSkinnables.push_back(SkinningShaderConfigurationRequest{ mesh.first.mSkeletonIdx, shader });
 125   }
 126
 127   if (mesh.first.HasBlendShapes())
 128   {
 129     params.mBlendshapeRequests.push_back(BlendshapeShaderConfigurationRequest{ node.mName, mMeshIdx, shader });
 130   }
 131
 132   TextureSet textures = resources.mMaterials[mMaterialIdx].second;
 133
 134   // Set the blend shape texture.
 135   if (mesh.second.blendShapeGeometry)
 136   {
 137     TextureSet newTextureSet = TextureSet::New();
 138     newTextureSet.SetTexture(0u, mesh.second.blendShapeGeometry);
 139
 140     const unsigned int numberOfTextures = textures.GetTextureCount();
 141     for (unsigned int index = 0u; index < numberOfTextures; ++index)
 142     {
 143       const unsigned int newIndex = index + 1u;
 144       newTextureSet.SetTexture(newIndex, textures.GetTexture(index));
 145       newTextureSet.SetSampler(newIndex, textures.GetSampler(index));
 146     }
 147
 148     textures = newTextureSet;
 149   }
 150
 151   renderer.SetTextures(textures);
 152
 153   actor.SetProperty(Actor::Property::COLOR, mColor);
 154
 155   auto& matDef = resources.mMaterials[mMaterialIdx].first;
 156   actor.RegisterProperty("uMetallicFactor", matDef.mMetallic);
 157   actor.RegisterProperty("uRoughnessFactor", matDef.mRoughness);
 158
 159   Index envIdx = matDef.mEnvironmentIdx;
 160   actor.RegisterProperty("uIblIntensity", resources.mEnvironmentMaps[envIdx].first.mIblIntensity);
 161
 162   const auto alphaCutoff = matDef.GetAlphaCutoff();
 163   if (alphaCutoff > 0.f)
 164   {
 165     actor.RegisterProperty("uAlphaThreshold", alphaCutoff);
 166   }
 167 }
 168
 169 void ArcNode::OnCreate(const NodeDefinition& node, NodeDefinition::CreateParams& params,
 170   Actor& actor) const
 171 {
 172   ModelNode::OnCreate(node, params, actor);
 173
 174   actor.RegisterProperty("antiAliasing", mAntiAliasing ? 1 : 0);
 175   actor.RegisterProperty("arcCaps", mArcCaps);
 176   actor.RegisterProperty("radius", mRadius);
 177
 178   const float startAngleRadians = mStartAngleDegrees * Math::PI_OVER_180;
 179   Vector2 startPolar{ std::cos(startAngleRadians), std::sin(startAngleRadians) };
 180   actor.RegisterProperty("startAngle", startPolar);
 181
 182   const float endAngleRadians = mEndAngleDegrees * Math::PI_OVER_180;
 183   Vector2 endPolar{ std::cos(endAngleRadians), std::sin(endAngleRadians) };
 184   actor.RegisterProperty("endAngle", endPolar);
 185 }
 186
 187 void ArcNode::GetEndVectorWithDiffAngle(float startAngle, float diffAngle, Vector2& endVector)
 188 {
 189   float endAngle = 0.f;
 190
 191   if (diffAngle <= 0.001f)
 192   {
 193     //0.001 is used to ensure is empty arc when startAngle = endAngle + 360 * N
 194     endAngle = startAngle + 0.001f;
 195   }
 196   else if (diffAngle >= 360.f)
 197   {
 198     endAngle = diffAngle + 359.99f;
 199   }
 200   else
 201   {
 202     endAngle = startAngle + 360.0f + diffAngle;
 203   }
 204   endVector.x = cosf(endAngle * Math::PI_OVER_180);
 205   endVector.y = sinf(endAngle * Math::PI_OVER_180);
 206 }
 207
 208 }
 209 }