dali/internal/event/rendering/visual-renderer-impl.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 // CLASS HEADER
  19 #include <dali/internal/event/rendering/visual-renderer-impl.h>
  20
  21 // INTERNAL INCLUDES
  22 #include <dali/devel-api/rendering/renderer-devel.h>
  23 #include <dali/devel-api/scripting/scripting.h>
  24 #include <dali/internal/event/common/property-helper.h> // DALI_PROPERTY_TABLE_BEGIN, DALI_PROPERTY, DALI_PROPERTY_TABLE_END
  25 #include <dali/internal/event/common/property-input-impl.h>
  26 #include <dali/internal/update/manager/update-manager.h>
  27 #include <dali/internal/update/rendering/scene-graph-renderer.h>
  28 #include <dali/public-api/object/type-registry.h>
  29
  30 namespace Dali
  31 {
  32 namespace Internal
  33 {
  34 namespace
  35 {
  36 /**
  37  * Properties: |name                              |type     |writable|animatable|constraint-input|enum for index-checking|
  38  */
  39 DALI_PROPERTY_TABLE_BEGIN
  40 DALI_PROPERTY("transformOffset", VECTOR2, true, true, true, Dali::VisualRenderer::Property::TRANSFORM_OFFSET)
  41 DALI_PROPERTY("transformSize", VECTOR2, true, true, true, Dali::VisualRenderer::Property::TRANSFORM_SIZE)
  42 DALI_PROPERTY("transformOrigin", VECTOR2, true, false, false, Dali::VisualRenderer::Property::TRANSFORM_ORIGIN)
  43 DALI_PROPERTY("transformAnchorPoint", VECTOR2, true, false, false, Dali::VisualRenderer::Property::TRANSFORM_ANCHOR_POINT)
  44 DALI_PROPERTY("transformOffsetSizeMode", VECTOR4, true, false, false, Dali::VisualRenderer::Property::TRANSFORM_OFFSET_SIZE_MODE)
  45 DALI_PROPERTY("extraSize", VECTOR2, true, true, true, Dali::VisualRenderer::Property::EXTRA_SIZE)
  46 DALI_PROPERTY("visualMixColor", VECTOR3, true, true, true, Dali::VisualRenderer::Property::VISUAL_MIX_COLOR)
  47 DALI_PROPERTY("preMultipliedAlpha", FLOAT, true, false, false, Dali::VisualRenderer::Property::VISUAL_PRE_MULTIPLIED_ALPHA)
  48 DALI_PROPERTY_TABLE_END(Dali::VisualRenderer::Property::DEFAULT_VISUAL_RENDERER_PROPERTY_START_INDEX, VisualRendererDefaultProperties)
  49
  50 // Property string to enumeration tables:
  51
  52 DALI_ENUM_TO_STRING_TABLE_BEGIN(TRANSFORM_POLICY)
  53   DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::VisualRenderer::TransformPolicy::Type, RELATIVE)
  54   DALI_ENUM_TO_STRING_WITH_SCOPE(Dali::VisualRenderer::TransformPolicy::Type, ABSOLUTE)
  55 DALI_ENUM_TO_STRING_TABLE_END(TRANSFORM_POLICY)
  56
  57 BaseHandle Create()
  58 {
  59   return Dali::BaseHandle();
  60 }
  61
  62 TypeRegistration mType(typeid(Dali::VisualRenderer), typeid(Dali::Renderer), Create, VisualRendererDefaultProperties);
  63
  64 } // unnamed namespace
  65
  66 VisualRendererPtr VisualRenderer::New()
  67 {
  68   // create scene object first so it's guaranteed to exist for the event side
  69   auto sceneObject = SceneGraph::Renderer::New();
  70
  71   sceneObject->SetVisualProperties(new SceneGraph::VisualRenderer::AnimatableVisualProperties());
  72
  73   OwnerPointer<SceneGraph::Renderer> transferOwnership(sceneObject);
  74   // pass the pointer to base for message passing
  75   VisualRendererPtr rendererPtr(new VisualRenderer(sceneObject));
  76
  77   rendererPtr->AddUniformMappings(); // Ensure properties are mapped to uniforms
  78
  79   // transfer scene object ownership to update manager
  80   EventThreadServices&       eventThreadServices = rendererPtr->GetEventThreadServices();
  81   SceneGraph::UpdateManager& updateManager       = eventThreadServices.GetUpdateManager();
  82   AddRendererMessage(updateManager, transferOwnership);
  83
  84   eventThreadServices.RegisterObject(rendererPtr.Get());
  85   return rendererPtr;
  86 }
  87
  88 VisualRenderer::VisualRenderer(const SceneGraph::Renderer* sceneObject)
  89 : Renderer(sceneObject)
  90 {
  91 }
  92
  93 VisualRenderer::~VisualRenderer()
  94 {
  95   // The scene object will be deleted by ~Renderer
  96 }
  97
  98 const SceneGraph::Renderer& VisualRenderer::GetVisualRendererSceneObject() const
  99 {
 100   return static_cast<const SceneGraph::Renderer&>(GetSceneObject());
 101 }
 102
 103 void VisualRenderer::SetDefaultProperty(Property::Index        index,
 104                                         const Property::Value& propertyValue)
 105 {
 106   if(index < Dali::VisualRenderer::Property::DEFAULT_VISUAL_RENDERER_PROPERTY_START_INDEX)
 107   {
 108     Renderer::SetDefaultProperty(index, propertyValue);
 109   }
 110   else
 111   {
 112     switch(index)
 113     {
 114       case Dali::VisualRenderer::Property::TRANSFORM_OFFSET:
 115       {
 116         if(propertyValue.Get(mPropertyCache.mTransformOffset))
 117         {
 118           const SceneGraph::Renderer& sceneObject      = GetVisualRendererSceneObject();
 119           auto                        visualProperties = sceneObject.GetVisualProperties();
 120
 121           if(visualProperties)
 122           {
 123             BakeMessage<Vector2>(GetEventThreadServices(), visualProperties->mTransformOffset, mPropertyCache.mTransformOffset);
 124           }
 125         }
 126         break;
 127       }
 128
 129       case Dali::VisualRenderer::Property::TRANSFORM_SIZE:
 130       {
 131         if(propertyValue.Get(mPropertyCache.mTransformSize))
 132         {
 133           const SceneGraph::Renderer& sceneObject      = GetVisualRendererSceneObject();
 134           auto                        visualProperties = sceneObject.GetVisualProperties();
 135           if(visualProperties)
 136           {
 137             BakeMessage<Vector2>(GetEventThreadServices(), visualProperties->mTransformSize, mPropertyCache.mTransformSize);
 138           }
 139         }
 140         break;
 141       }
 142       case Dali::VisualRenderer::Property::TRANSFORM_ORIGIN:
 143       {
 144         if(propertyValue.Get(mPropertyCache.mTransformOrigin))
 145         {
 146           const SceneGraph::Renderer& sceneObject      = GetVisualRendererSceneObject();
 147           auto                        visualProperties = sceneObject.GetVisualProperties();
 148           if(visualProperties)
 149           {
 150             BakeMessage<Vector2>(GetEventThreadServices(), visualProperties->mTransformOrigin, mPropertyCache.mTransformOrigin);
 151           }
 152         }
 153         break;
 154       }
 155       case Dali::VisualRenderer::Property::TRANSFORM_ANCHOR_POINT:
 156       {
 157         if(propertyValue.Get(mPropertyCache.mTransformAnchorPoint))
 158         {
 159           const SceneGraph::Renderer& sceneObject      = GetVisualRendererSceneObject();
 160           auto                        visualProperties = sceneObject.GetVisualProperties();
 161           if(visualProperties)
 162           {
 163             BakeMessage<Vector2>(GetEventThreadServices(), visualProperties->mTransformAnchorPoint, mPropertyCache.mTransformAnchorPoint);
 164           }
 165         }
 166         break;
 167       }
 168       case Dali::VisualRenderer::Property::TRANSFORM_OFFSET_SIZE_MODE:
 169       {
 170         if(propertyValue.Get(mPropertyCache.mTransformOffsetSizeMode))
 171         {
 172           const SceneGraph::Renderer& sceneObject      = GetVisualRendererSceneObject();
 173           auto                        visualProperties = sceneObject.GetVisualProperties();
 174           if(visualProperties)
 175           {
 176             BakeMessage<Vector4>(GetEventThreadServices(), visualProperties->mTransformOffsetSizeMode, mPropertyCache.mTransformOffsetSizeMode);
 177           }
 178         }
 179         break;
 180       }
 181       case Dali::VisualRenderer::Property::EXTRA_SIZE:
 182       {
 183         if(propertyValue.Get(mPropertyCache.mExtraSize))
 184         {
 185           const SceneGraph::Renderer& sceneObject      = GetVisualRendererSceneObject();
 186           auto                        visualProperties = sceneObject.GetVisualProperties();
 187           if(visualProperties)
 188           {
 189             BakeMessage<Vector2>(GetEventThreadServices(), visualProperties->mExtraSize, mPropertyCache.mExtraSize);
 190           }
 191         }
 192         break;
 193       }
 194       case Dali::VisualRenderer::Property::VISUAL_MIX_COLOR:
 195       {
 196         if(propertyValue.Get(mPropertyCache.mMixColor))
 197         {
 198           const SceneGraph::Renderer& sceneObject      = GetVisualRendererSceneObject();
 199           auto                        visualProperties = sceneObject.GetVisualProperties();
 200           if(visualProperties)
 201           {
 202             BakeMessage<Vector3>(GetEventThreadServices(), visualProperties->mMixColor, mPropertyCache.mMixColor);
 203           }
 204         }
 205         break;
 206       }
 207       case Dali::VisualRenderer::Property::VISUAL_PRE_MULTIPLIED_ALPHA:
 208       {
 209         float preMultipliedAlpha;
 210         if(propertyValue.Get(preMultipliedAlpha))
 211         {
 212           if(!Equals(mPropertyCache.mPreMultipliedAlpha, preMultipliedAlpha))
 213           {
 214             const SceneGraph::Renderer& sceneObject      = GetVisualRendererSceneObject();
 215             auto                        visualProperties = sceneObject.GetVisualProperties();
 216             if(visualProperties)
 217             {
 218               mPropertyCache.mPreMultipliedAlpha = preMultipliedAlpha;
 219               BakeMessage<float>(GetEventThreadServices(), visualProperties->mPreMultipliedAlpha, preMultipliedAlpha);
 220             }
 221           }
 222         }
 223         break;
 224       }
 225     }
 226   }
 227 }
 228
 229 Property::Value VisualRenderer::GetDefaultProperty(Property::Index index) const
 230 {
 231   Property::Value value;
 232
 233   if(index < Dali::VisualRenderer::Property::DEFAULT_VISUAL_RENDERER_PROPERTY_START_INDEX)
 234   {
 235     value = Renderer::GetDefaultProperty(index);
 236   }
 237   else
 238   {
 239     switch(index)
 240     {
 241       case Dali::VisualRenderer::Property::TRANSFORM_OFFSET:
 242       {
 243         value = mPropertyCache.mTransformOffset;
 244         break;
 245       }
 246       case Dali::VisualRenderer::Property::TRANSFORM_SIZE:
 247       {
 248         value = mPropertyCache.mTransformSize;
 249         break;
 250       }
 251       case Dali::VisualRenderer::Property::TRANSFORM_ORIGIN:
 252       {
 253         value = mPropertyCache.mTransformOrigin;
 254         break;
 255       }
 256       case Dali::VisualRenderer::Property::TRANSFORM_ANCHOR_POINT:
 257       {
 258         value = mPropertyCache.mTransformAnchorPoint;
 259         break;
 260       }
 261       case Dali::VisualRenderer::Property::TRANSFORM_OFFSET_SIZE_MODE:
 262       {
 263         value = mPropertyCache.mTransformOffsetSizeMode;
 264         break;
 265       }
 266       case Dali::VisualRenderer::Property::EXTRA_SIZE:
 267       {
 268         value = mPropertyCache.mExtraSize;
 269         break;
 270       }
 271       case Dali::VisualRenderer::Property::VISUAL_MIX_COLOR:
 272       {
 273         value = mPropertyCache.mMixColor;
 274         break;
 275       }
 276       case Dali::VisualRenderer::Property::VISUAL_PRE_MULTIPLIED_ALPHA:
 277       {
 278         value = mPropertyCache.mPreMultipliedAlpha;
 279         break;
 280       }
 281       default:
 282       {
 283         break;
 284       }
 285     }
 286   }
 287
 288   return value;
 289 }
 290
 291 Property::Value VisualRenderer::GetDefaultPropertyCurrentValue(Property::Index index) const
 292 {
 293   Property::Value value;
 294
 295   if(index < Dali::VisualRenderer::Property::DEFAULT_VISUAL_RENDERER_PROPERTY_START_INDEX)
 296   {
 297     value = Renderer::GetDefaultPropertyCurrentValue(index);
 298   }
 299   else
 300   {
 301     const SceneGraph::Renderer& sceneObject = GetVisualRendererSceneObject();
 302
 303     switch(index)
 304     {
 305       case Dali::VisualRenderer::Property::TRANSFORM_OFFSET:
 306       {
 307         auto visualProperties = sceneObject.GetVisualProperties();
 308         if(visualProperties)
 309         {
 310           value = visualProperties->mTransformOffset[GetEventThreadServices().GetEventBufferIndex()];
 311         }
 312         break;
 313       }
 314       case Dali::VisualRenderer::Property::TRANSFORM_SIZE:
 315       {
 316         auto visualProperties = sceneObject.GetVisualProperties();
 317         if(visualProperties)
 318         {
 319           value = visualProperties->mTransformSize[GetEventThreadServices().GetEventBufferIndex()];
 320         }
 321         break;
 322       }
 323       case Dali::VisualRenderer::Property::TRANSFORM_ORIGIN:
 324       {
 325         auto visualProperties = sceneObject.GetVisualProperties();
 326         if(visualProperties)
 327         {
 328           value = visualProperties->mTransformOrigin[GetEventThreadServices().GetEventBufferIndex()];
 329         }
 330         break;
 331       }
 332       case Dali::VisualRenderer::Property::TRANSFORM_ANCHOR_POINT:
 333       {
 334         auto visualProperties = sceneObject.GetVisualProperties();
 335         if(visualProperties)
 336         {
 337           value = visualProperties->mTransformAnchorPoint[GetEventThreadServices().GetEventBufferIndex()];
 338         }
 339         break;
 340       }
 341       case Dali::VisualRenderer::Property::TRANSFORM_OFFSET_SIZE_MODE:
 342       {
 343         auto visualProperties = sceneObject.GetVisualProperties();
 344         if(visualProperties)
 345         {
 346           value = visualProperties->mTransformOffsetSizeMode[GetEventThreadServices().GetEventBufferIndex()];
 347         }
 348         break;
 349       }
 350       case Dali::VisualRenderer::Property::EXTRA_SIZE:
 351       {
 352         auto visualProperties = sceneObject.GetVisualProperties();
 353         if(visualProperties)
 354         {
 355           value = visualProperties->mExtraSize[GetEventThreadServices().GetEventBufferIndex()];
 356         }
 357         break;
 358       }
 359       case Dali::VisualRenderer::Property::VISUAL_MIX_COLOR:
 360       {
 361         auto visualProperties = sceneObject.GetVisualProperties();
 362         if(visualProperties)
 363         {
 364           value = visualProperties->mMixColor[GetEventThreadServices().GetEventBufferIndex()];
 365         }
 366         break;
 367       }
 368       case Dali::VisualRenderer::Property::VISUAL_PRE_MULTIPLIED_ALPHA:
 369       {
 370         auto visualProperties = sceneObject.GetVisualProperties();
 371         if(visualProperties)
 372         {
 373           value = visualProperties->mPreMultipliedAlpha[GetEventThreadServices().GetEventBufferIndex()];
 374         }
 375         break;
 376       }
 377     }
 378   }
 379   return value;
 380 }
 381
 382 void VisualRenderer::OnNotifyDefaultPropertyAnimation(Animation& animation, Property::Index index, const Property::Value& value, Animation::Type animationType)
 383 {
 384   if(index < Dali::VisualRenderer::Property::DEFAULT_VISUAL_RENDERER_PROPERTY_START_INDEX)
 385   {
 386     Renderer::OnNotifyDefaultPropertyAnimation(animation, index, value, animationType);
 387   }
 388   else
 389   {
 390     switch(animationType)
 391     {
 392       case Animation::TO:
 393       case Animation::BETWEEN:
 394       {
 395         switch(index)
 396         {
 397           case Dali::VisualRenderer::Property::TRANSFORM_OFFSET:
 398           {
 399             value.Get(mPropertyCache.mTransformOffset);
 400             break;
 401           }
 402           case Dali::VisualRenderer::Property::TRANSFORM_SIZE:
 403           {
 404             value.Get(mPropertyCache.mTransformSize);
 405             break;
 406           }
 407           case Dali::VisualRenderer::Property::EXTRA_SIZE:
 408           {
 409             value.Get(mPropertyCache.mExtraSize);
 410             break;
 411           }
 412           case Dali::VisualRenderer::Property::VISUAL_MIX_COLOR:
 413           {
 414             value.Get(mPropertyCache.mMixColor);
 415             break;
 416           }
 417         }
 418         break;
 419       }
 420
 421       case Animation::BY:
 422       {
 423         switch(index)
 424         {
 425           case Dali::VisualRenderer::Property::TRANSFORM_OFFSET:
 426           {
 427             AdjustValue<Vector2>(mPropertyCache.mTransformOffset, value);
 428             break;
 429           }
 430           case Dali::VisualRenderer::Property::TRANSFORM_SIZE:
 431           {
 432             AdjustValue<Vector2>(mPropertyCache.mTransformSize, value);
 433             break;
 434           }
 435           case Dali::VisualRenderer::Property::EXTRA_SIZE:
 436           {
 437             AdjustValue<Vector2>(mPropertyCache.mExtraSize, value);
 438             break;
 439           }
 440           case Dali::VisualRenderer::Property::VISUAL_MIX_COLOR:
 441           {
 442             AdjustValue<Vector3>(mPropertyCache.mMixColor, value);
 443             break;
 444           }
 445         }
 446         break;
 447       }
 448     }
 449   }
 450 }
 451
 452 const SceneGraph::PropertyBase* VisualRenderer::GetSceneObjectAnimatableProperty(Property::Index index) const
 453 {
 454   const SceneGraph::PropertyBase* property = nullptr;
 455
 456   switch(index)
 457   {
 458     case Dali::VisualRenderer::Property::TRANSFORM_OFFSET:
 459     {
 460       auto visualProperties = GetVisualRendererSceneObject().GetVisualProperties();
 461       if(visualProperties)
 462       {
 463         property = &visualProperties->mTransformOffset;
 464       }
 465       break;
 466     }
 467     case Dali::VisualRenderer::Property::TRANSFORM_SIZE:
 468     {
 469       auto visualProperties = GetVisualRendererSceneObject().GetVisualProperties();
 470       if(visualProperties)
 471       {
 472         property = &visualProperties->mTransformSize;
 473       }
 474       break;
 475     }
 476     case Dali::VisualRenderer::Property::EXTRA_SIZE:
 477     {
 478       auto visualProperties = GetVisualRendererSceneObject().GetVisualProperties();
 479       if(visualProperties)
 480       {
 481         property = &visualProperties->mExtraSize;
 482       }
 483       break;
 484     }
 485     case Dali::VisualRenderer::Property::VISUAL_MIX_COLOR:
 486     {
 487       auto visualProperties = GetVisualRendererSceneObject().GetVisualProperties();
 488       if(visualProperties)
 489       {
 490         property = &visualProperties->mMixColor;
 491       }
 492       break;
 493     }
 494   }
 495
 496   if(!property)
 497   {
 498     // not our property, ask base
 499     property = Renderer::GetSceneObjectAnimatableProperty(index);
 500   }
 501
 502   return property;
 503 }
 504
 505 const PropertyInputImpl* VisualRenderer::GetSceneObjectInputProperty(Property::Index index) const
 506 {
 507   switch(index)
 508   {
 509     case Dali::VisualRenderer::Property::TRANSFORM_ORIGIN:
 510     {
 511       auto visualProperties = GetVisualRendererSceneObject().GetVisualProperties();
 512       if(visualProperties)
 513       {
 514         return &visualProperties->mTransformOrigin;
 515       }
 516       break;
 517     }
 518     case Dali::VisualRenderer::Property::TRANSFORM_ANCHOR_POINT:
 519     {
 520       auto visualProperties = GetVisualRendererSceneObject().GetVisualProperties();
 521       if(visualProperties)
 522       {
 523         return &visualProperties->mTransformAnchorPoint;
 524       }
 525       break;
 526     }
 527     case Dali::VisualRenderer::Property::TRANSFORM_OFFSET_SIZE_MODE:
 528     {
 529       auto visualProperties = GetVisualRendererSceneObject().GetVisualProperties();
 530       if(visualProperties)
 531       {
 532         return &visualProperties->mTransformOffsetSizeMode;
 533       }
 534       break;
 535     }
 536     case Dali::VisualRenderer::Property::VISUAL_PRE_MULTIPLIED_ALPHA:
 537     {
 538       auto visualProperties = GetVisualRendererSceneObject().GetVisualProperties();
 539       if(visualProperties)
 540       {
 541         return &visualProperties->mPreMultipliedAlpha;
 542       }
 543       break;
 544     }
 545     default:
 546     {
 547       return GetSceneObjectAnimatableProperty(index);
 548     }
 549   }
 550   return nullptr;
 551 }
 552
 553 void VisualRenderer::AddUniformMappings()
 554 {
 555   AddUniformMapping(Dali::VisualRenderer::Property::TRANSFORM_OFFSET, ConstString("offset"));
 556   AddUniformMapping(Dali::VisualRenderer::Property::TRANSFORM_SIZE, ConstString("size"));
 557   AddUniformMapping(Dali::VisualRenderer::Property::TRANSFORM_OFFSET_SIZE_MODE, ConstString("offsetSizeMode"));
 558   AddUniformMapping(Dali::VisualRenderer::Property::TRANSFORM_ORIGIN, ConstString("origin"));
 559   AddUniformMapping(Dali::VisualRenderer::Property::TRANSFORM_ANCHOR_POINT, ConstString("anchorPoint"));
 560   AddUniformMapping(Dali::VisualRenderer::Property::EXTRA_SIZE, ConstString("extraSize"));
 561   AddUniformMapping(Dali::VisualRenderer::Property::VISUAL_MIX_COLOR, ConstString("mixColor"));
 562   AddUniformMapping(Dali::VisualRenderer::Property::VISUAL_PRE_MULTIPLIED_ALPHA, ConstString("preMultipliedAlpha"));
 563 }
 564
 565 } // namespace Internal
 566
 567 } // namespace Dali