dali/internal/update/common/property-owner-messages.h

   1 #ifndef DALI_INTERNAL_SCENE_GRAPH_PROPERTY_OWNER_MESSAGES_H
   2 #define DALI_INTERNAL_SCENE_GRAPH_PROPERTY_OWNER_MESSAGES_H
   3
   4 /*
   5  * Copyright (c) 2019 Samsung Electronics Co., Ltd.
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  * http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  */
  20
  21 // EXTERNAL INCLUDES
  22 #include <string>
  23
  24 // INTERNAL INCLUDES
  25 #include <dali/internal/event/common/event-thread-services.h>
  26 #include <dali/internal/event/common/property-input-impl.h>
  27 #include <dali/internal/update/common/property-owner.h>
  28 #include <dali/internal/update/animation/scene-graph-constraint-base.h>
  29
  30 namespace Dali
  31 {
  32 namespace Internal
  33 {
  34 namespace SceneGraph
  35 {
  36 class UniformMap;
  37 class PropertyOwner;
  38
  39 // Property Messages for PropertyOwner
  40
  41 /**
  42  * A base class for property owner property messages.
  43  * (For future optimization - see NodeMessageBase & Node.SetActive())
  44  */
  45 class PropertyOwnerMessageBase : public MessageBase
  46 {
  47 public:
  48
  49   /**
  50    * Create a message.
  51    */
  52   PropertyOwnerMessageBase();
  53
  54   /**
  55    * Virtual destructor
  56    */
  57   ~PropertyOwnerMessageBase() override;
  58
  59 private:
  60
  61   // Undefined
  62   PropertyOwnerMessageBase(const PropertyOwnerMessageBase&);
  63   PropertyOwnerMessageBase& operator=(const PropertyOwnerMessageBase& rhs);
  64 };
  65
  66 /**
  67  * Templated message which bakes a property.
  68  */
  69 template< typename P >
  70 class AnimatablePropertyMessage : public PropertyOwnerMessageBase
  71 {
  72 public:
  73   using MemberFunction = void ( AnimatableProperty<P>::* )( BufferIndex, typename ParameterType<P>::PassingType );
  74
  75   /**
  76    * Create a message.
  77    * @note The scene object is expected to be const in the thread which sends this message.
  78    * However it can be modified when Process() is called in a different thread.
  79    * @param[in] eventThreadServices The object used to send messages to the scene graph
  80    * @param[in] sceneObject The property owner scene object
  81    * @param[in] property The property to bake.
  82    * @param[in] member The member function of the object.
  83    * @param[in] value The new value of the property.
  84    */
  85   static void Send( EventThreadServices& eventThreadServices,
  86                     const PropertyOwner* sceneObject,
  87                     const AnimatableProperty<P>* property,
  88                     MemberFunction member,
  89                     typename ParameterType< P >::PassingType value )
  90   {
  91     // Reserve some memory inside the message queue
  92     uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( AnimatablePropertyMessage ) );
  93
  94     // Construct message in the message queue memory; note that delete should not be called on the return value
  95     new (slot) AnimatablePropertyMessage( sceneObject, property, member, value );
  96   }
  97
  98   /**
  99    * Virtual destructor
 100    */
 101   ~AnimatablePropertyMessage() override = default;
 102
 103   /**
 104    * @copydoc MessageBase::Process
 105    */
 106   void Process( BufferIndex updateBufferIndex ) override
 107   {
 108     (mProperty->*mMemberFunction)( updateBufferIndex, mParam );
 109   }
 110
 111 private:
 112
 113   /**
 114    * Create a message.
 115    * @note The property owner is expected to be const in the thread which sends this message.
 116    * However it can be modified when Process() is called in a different thread.
 117    * @param[in] sceneObject the property owner scene object
 118    * @param[in] property The property to bake.
 119    * @param[in] member The member function of the object.
 120    * @param[in] value The new value of the property.
 121    */
 122   AnimatablePropertyMessage( const PropertyOwner* sceneObject,
 123                              const AnimatableProperty<P>* property,
 124                              MemberFunction member,
 125                              typename ParameterType< P >::PassingType value )
 126   : PropertyOwnerMessageBase(),
 127     mSceneObject( const_cast< PropertyOwner* >( sceneObject ) ),
 128     mProperty( const_cast< AnimatableProperty<P>* >( property ) ),
 129     mMemberFunction( member ),
 130     mParam( value )
 131   {
 132   }
 133
 134 private:
 135
 136   PropertyOwner* mSceneObject;
 137   AnimatableProperty<P>* mProperty;
 138   MemberFunction mMemberFunction;
 139   typename ParameterType< P >::HolderType mParam;
 140 };
 141
 142 /**
 143  * Templated message which bakes a property.
 144  */
 145 template< typename P >
 146 class AnimatablePropertyComponentMessage : public PropertyOwnerMessageBase
 147 {
 148 public:
 149   using MemberFunction = void ( AnimatableProperty<P>::* )( BufferIndex, float );
 150
 151   /**
 152    * Send a message.
 153    * @note The scene object is expected to be const in the thread which sends this message.
 154    * However it can be modified when Process() is called in a different thread.
 155    * @param[in] eventThreadServices The service object used for sending messages to the scene graph
 156    * @param[in] sceneObject The property owner scene object
 157    * @param[in] property The property to bake.
 158    * @param[in] member The member function of the object.
 159    * @param[in] value The new value of the X,Y,Z or W component.
 160    */
 161   static void Send( EventThreadServices& eventThreadServices,
 162                     const PropertyOwner* sceneObject,
 163                     const AnimatableProperty<P>* property,
 164                     MemberFunction member,
 165                     float value )
 166   {
 167     // Reserve some memory inside the message queue
 168     uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( AnimatablePropertyComponentMessage ) );
 169
 170     // Construct message in the message queue memory; note that delete should not be called on the return value
 171     new (slot) AnimatablePropertyComponentMessage( sceneObject, property, member, value );
 172   }
 173
 174   /**
 175    * Virtual destructor
 176    */
 177   ~AnimatablePropertyComponentMessage() override = default;
 178
 179   /**
 180    * @copydoc MessageBase::Process
 181    */
 182   void Process( BufferIndex updateBufferIndex ) override
 183   {
 184     (mProperty->*mMemberFunction)( updateBufferIndex, mParam );
 185   }
 186
 187 private:
 188
 189   /**
 190    * Create a message.
 191    * @note The scene object is expected to be const in the thread which sends this message.
 192    * However it can be modified when Process() is called in a different thread.
 193    * @param[in] sceneObject The property owner scene object
 194    * @param[in] property The property to bake.
 195    * @param[in] member The member function of the object.
 196    * @param[in] value The new value of the X,Y,Z or W component.
 197   */
 198   AnimatablePropertyComponentMessage( const PropertyOwner* sceneObject,
 199                                       const AnimatableProperty<P>* property,
 200                                       MemberFunction member,
 201                                       float value )
 202   : PropertyOwnerMessageBase(),
 203     mSceneObject( const_cast< PropertyOwner* >( sceneObject ) ),
 204     mProperty( const_cast< AnimatableProperty<P>* >( property ) ),
 205     mMemberFunction( member ),
 206     mParam( value )
 207   {
 208   }
 209
 210 private:
 211   PropertyOwner* mSceneObject;
 212   AnimatableProperty<P>* mProperty;
 213   MemberFunction mMemberFunction;
 214   float mParam;
 215 };
 216
 217
 218 // Messages for PropertyOwner
 219
 220 inline void InstallCustomPropertyMessage( EventThreadServices& eventThreadServices, const PropertyOwner& owner, OwnerPointer<PropertyBase>& property )
 221 {
 222   using LocalType = MessageValue1<PropertyOwner, OwnerPointer<PropertyBase> >;
 223
 224   // Reserve some memory inside the message queue
 225   uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
 226
 227   // Construct message in the message queue memory; note that delete should not be called on the return value
 228   new (slot) LocalType( &owner, &PropertyOwner::InstallCustomProperty, property );
 229 }
 230
 231 inline void ApplyConstraintMessage( EventThreadServices& eventThreadServices, const PropertyOwner& owner, OwnerPointer<ConstraintBase>& constraint )
 232 {
 233   using LocalType = MessageValue1<PropertyOwner, OwnerPointer<ConstraintBase> >;
 234
 235   // Reserve some memory inside the message queue
 236   uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
 237
 238   // Construct message in the message queue memory; note that delete should not be called on the return value
 239   new (slot) LocalType( &owner, &PropertyOwner::ApplyConstraint, constraint );
 240 }
 241
 242 inline void RemoveConstraintMessage( EventThreadServices& eventThreadServices, const PropertyOwner& owner, const ConstraintBase& constConstraint )
 243 {
 244   // The update-thread can modify this object.
 245   ConstraintBase& constraint = const_cast< ConstraintBase& >( constConstraint );
 246
 247   using LocalType = MessageValue1<PropertyOwner, ConstraintBase*>;
 248
 249   // Reserve some memory inside the message queue
 250   uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
 251
 252   // Construct message in the message queue memory; note that delete should not be called on the return value
 253   new (slot) LocalType( &owner, &PropertyOwner::RemoveConstraint, &constraint );
 254 }
 255
 256 inline void AddUniformMapMessage( EventThreadServices& eventThreadServices, const PropertyOwner& owner, OwnerPointer< UniformPropertyMapping >& map )
 257 {
 258   using LocalType = MessageValue1<PropertyOwner, OwnerPointer<UniformPropertyMapping> >;
 259
 260   // Reserve some memory inside the message queue
 261   uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
 262
 263   new (slot) LocalType( &owner, &PropertyOwner::AddUniformMapping, map );
 264 }
 265
 266 inline void RemoveUniformMapMessage( EventThreadServices& eventThreadServices, const PropertyOwner& owner, const std::string& uniformName )
 267 {
 268   using LocalType = MessageValue1<PropertyOwner, std::string>;
 269
 270   // Reserve some memory inside the message queue
 271   uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
 272
 273   new (slot) LocalType( &owner, &PropertyOwner::RemoveUniformMapping, uniformName );
 274 }
 275
 276
 277 } // namespace SceneGraph
 278
 279 } // namespace Internal
 280
 281 } // namespace Dali
 282
 283 #endif // DALI_INTERNAL_SCENE_GRAPH_PROPERTY_OWNER_MESSAGES_H