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) 2014 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 // INTERNAL INCLUDES
  22
  23 #include <dali/internal/event/common/event-thread-services.h>
  24 #include <dali/internal/event/common/property-input-impl.h>
  25 #include <dali/internal/update/common/property-owner.h>
  26 #include <dali/internal/update/common/double-buffered-property.h>
  27 #include <dali/internal/update/animation/scene-graph-constraint-base.h>
  28 #include <string>
  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   virtual ~PropertyOwnerMessageBase();
  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
  74   typedef void(AnimatableProperty<P>::*MemberFunction)( BufferIndex, typename ParameterType< P >::PassingType );
  75
  76   /**
  77    * Create a message.
  78    * @note The scene object is expected to be const in the thread which sends this message.
  79    * However it can be modified when Process() is called in a different thread.
  80    * @param[in] eventThreadServices The object used to send messages to the scene graph
  81    * @param[in] sceneObject The property owner scene object
  82    * @param[in] property The property to bake.
  83    * @param[in] member The member function of the object.
  84    * @param[in] value The new value of the property.
  85    */
  86   static void Send( EventThreadServices& eventThreadServices,
  87                     const PropertyOwner* sceneObject,
  88                     const AnimatableProperty<P>* property,
  89                     MemberFunction member,
  90                     typename ParameterType< P >::PassingType value )
  91   {
  92     // Reserve some memory inside the message queue
  93     unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( AnimatablePropertyMessage ) );
  94
  95     // Construct message in the message queue memory; note that delete should not be called on the return value
  96     new (slot) AnimatablePropertyMessage( sceneObject, property, member, value );
  97   }
  98
  99   /**
 100    * Virtual destructor
 101    */
 102   virtual ~AnimatablePropertyMessage()
 103   {
 104   }
 105
 106   /**
 107    * @copydoc MessageBase::Process
 108    */
 109   virtual void Process( BufferIndex updateBufferIndex )
 110   {
 111     (mProperty->*mMemberFunction)( updateBufferIndex, mParam );
 112   }
 113
 114 private:
 115
 116   /**
 117    * Create a message.
 118    * @note The property owner is expected to be const in the thread which sends this message.
 119    * However it can be modified when Process() is called in a different thread.
 120    * @param[in] sceneObject the property owner scene object
 121    * @param[in] property The property to bake.
 122    * @param[in] member The member function of the object.
 123    * @param[in] value The new value of the property.
 124    */
 125   AnimatablePropertyMessage( const PropertyOwner* sceneObject,
 126                              const AnimatableProperty<P>* property,
 127                              MemberFunction member,
 128                              typename ParameterType< P >::PassingType value )
 129   : PropertyOwnerMessageBase(),
 130     mSceneObject( const_cast< PropertyOwner* >( sceneObject ) ),
 131     mProperty( const_cast< AnimatableProperty<P>* >( property ) ),
 132     mMemberFunction( member ),
 133     mParam( value )
 134   {
 135   }
 136
 137 private:
 138
 139   PropertyOwner* mSceneObject;
 140   AnimatableProperty<P>* mProperty;
 141   MemberFunction mMemberFunction;
 142   typename ParameterType< P >::HolderType mParam;
 143 };
 144
 145 /**
 146  * Templated message which bakes a property.
 147  */
 148 template< typename P >
 149 class AnimatablePropertyComponentMessage : public PropertyOwnerMessageBase
 150 {
 151 public:
 152
 153   typedef void(AnimatableProperty<P>::*MemberFunction)( BufferIndex, float );
 154
 155   /**
 156    * Send a message.
 157    * @note The scene object is expected to be const in the thread which sends this message.
 158    * However it can be modified when Process() is called in a different thread.
 159    * @param[in] eventThreadServices The service object used for sending messages to the scene graph
 160    * @param[in] sceneObject The property owner scene object
 161    * @param[in] property The property to bake.
 162    * @param[in] member The member function of the object.
 163    * @param[in] value The new value of the X,Y,Z or W component.
 164    */
 165   static void Send( EventThreadServices& eventThreadServices,
 166                     const PropertyOwner* sceneObject,
 167                     const AnimatableProperty<P>* property,
 168                     MemberFunction member,
 169                     float value )
 170   {
 171     // Reserve some memory inside the message queue
 172     unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( AnimatablePropertyComponentMessage ) );
 173
 174     // Construct message in the message queue memory; note that delete should not be called on the return value
 175     new (slot) AnimatablePropertyComponentMessage( sceneObject, property, member, value );
 176   }
 177
 178   /**
 179    * Virtual destructor
 180    */
 181   virtual ~AnimatablePropertyComponentMessage()
 182   {
 183   }
 184
 185   /**
 186    * @copydoc MessageBase::Process
 187    */
 188   virtual void Process( BufferIndex updateBufferIndex )
 189   {
 190     (mProperty->*mMemberFunction)( updateBufferIndex, mParam );
 191   }
 192
 193 private:
 194
 195   /**
 196    * Create a message.
 197    * @note The scene object is expected to be const in the thread which sends this message.
 198    * However it can be modified when Process() is called in a different thread.
 199    * @param[in] sceneObject The property owner scene object
 200    * @param[in] property The property to bake.
 201    * @param[in] member The member function of the object.
 202    * @param[in] value The new value of the X,Y,Z or W component.
 203   */
 204   AnimatablePropertyComponentMessage( const PropertyOwner* sceneObject,
 205                                       const AnimatableProperty<P>* property,
 206                                       MemberFunction member,
 207                                       float value )
 208   : PropertyOwnerMessageBase(),
 209     mSceneObject( const_cast< PropertyOwner* >( sceneObject ) ),
 210     mProperty( const_cast< AnimatableProperty<P>* >( property ) ),
 211     mMemberFunction( member ),
 212     mParam( value )
 213   {
 214   }
 215
 216 private:
 217   PropertyOwner* mSceneObject;
 218   AnimatableProperty<P>* mProperty;
 219   MemberFunction mMemberFunction;
 220   float mParam;
 221 };
 222
 223
 224 /**
 225  * Template class for sending messages to double buffered properties in a PropertyOwner
 226  */
 227 template< typename P >
 228 class DoubleBufferedPropertyMessage : public PropertyOwnerMessageBase
 229 {
 230 public:
 231
 232   typedef void(DoubleBufferedProperty<P>::*MemberFunction)( BufferIndex, typename ParameterType< P >::PassingType );
 233
 234   /**
 235    * Create a message.
 236    * @note The scene object is expected to be const in the thread which sends this message.
 237    * However it can be modified when Process() is called in a different thread.
 238    * @param[in] eventThreadServices The object used to send messages to the scene graph
 239    * @param[in] sceneObject The property owner scene object
 240    * @param[in] property The property to set.
 241    * @param[in] member The member function of the object.
 242    * @param[in] value The new value of the property.
 243    */
 244   static void Send( EventThreadServices& eventThreadServices,
 245                     const PropertyOwner* sceneObject,
 246                     const DoubleBufferedProperty<P>* property,
 247                     MemberFunction member,
 248                     typename ParameterType< P >::PassingType value )
 249   {
 250     // Reserve some memory inside the message queue
 251     unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( DoubleBufferedPropertyMessage ) );
 252
 253     // Construct message in the message queue memory; note that delete should not be called on the return value
 254     new (slot) DoubleBufferedPropertyMessage( sceneObject, property, member, value );
 255   }
 256
 257   /**
 258    * Virtual destructor
 259    */
 260   virtual ~DoubleBufferedPropertyMessage()
 261   {
 262   }
 263
 264   /**
 265    * @copydoc MessageBase::Process
 266    */
 267   virtual void Process( BufferIndex updateBufferIndex )
 268   {
 269     (mProperty->*mMemberFunction)( updateBufferIndex, mParam );
 270   }
 271
 272 private:
 273
 274   /**
 275    * Create a message.
 276    * @note The property owner is expected to be const in the thread which sends this message.
 277    * However it can be modified when Process() is called in a different thread.
 278    * @param[in] sceneObject the property owner scene object
 279    * @param[in] property The property to set.
 280    * @param[in] member The member function of the object.
 281    * @param[in] value The new value of the property.
 282    */
 283   DoubleBufferedPropertyMessage( const PropertyOwner* sceneObject,
 284                                  const DoubleBufferedProperty<P>* property,
 285                                  MemberFunction member,
 286                                  typename ParameterType< P >::PassingType value )
 287   : PropertyOwnerMessageBase(),
 288     mSceneObject( const_cast< PropertyOwner* >( sceneObject ) ),
 289     mProperty( const_cast< DoubleBufferedProperty<P>* >( property ) ),
 290     mMemberFunction( member ),
 291     mParam( value )
 292   {
 293   }
 294
 295 private:
 296   PropertyOwner* mSceneObject;
 297   DoubleBufferedProperty<P>* mProperty;
 298   MemberFunction mMemberFunction;
 299   typename ParameterType< P >::HolderType mParam;
 300 };
 301
 302
 303 // Messages for PropertyOwner
 304
 305 inline void InstallCustomPropertyMessage( EventThreadServices& eventThreadServices, const PropertyOwner& owner, PropertyBase* property )
 306 {
 307   typedef MessageValue1< PropertyOwner, OwnerPointer<PropertyBase> > LocalType;
 308
 309   // Reserve some memory inside the message queue
 310   unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
 311
 312   // Construct message in the message queue memory; note that delete should not be called on the return value
 313   new (slot) LocalType( &owner, &PropertyOwner::InstallCustomProperty, property );
 314 }
 315
 316 inline void ApplyConstraintMessage( EventThreadServices& eventThreadServices, const PropertyOwner& owner, ConstraintBase& constraint )
 317 {
 318   typedef MessageValue1< PropertyOwner, OwnerPointer<ConstraintBase> > LocalType;
 319
 320   // Reserve some memory inside the message queue
 321   unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
 322
 323   // Construct message in the message queue memory; note that delete should not be called on the return value
 324   new (slot) LocalType( &owner, &PropertyOwner::ApplyConstraint, &constraint );
 325 }
 326
 327 inline void RemoveConstraintMessage( EventThreadServices& eventThreadServices, const PropertyOwner& owner, const ConstraintBase& constConstraint )
 328 {
 329   // The update-thread can modify this object.
 330   ConstraintBase& constraint = const_cast< ConstraintBase& >( constConstraint );
 331
 332   typedef MessageValue1< PropertyOwner, ConstraintBase* > LocalType;
 333
 334   // Reserve some memory inside the message queue
 335   unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
 336
 337   // Construct message in the message queue memory; note that delete should not be called on the return value
 338   new (slot) LocalType( &owner, &PropertyOwner::RemoveConstraint, &constraint );
 339 }
 340
 341 inline void AddUniformMapMessage( EventThreadServices& eventThreadServices, const PropertyOwner& owner, UniformPropertyMapping* map )
 342 {
 343   typedef MessageValue1< PropertyOwner, OwnerPointer< UniformPropertyMapping > > LocalType;
 344   unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
 345   new (slot) LocalType( &owner, &PropertyOwner::AddUniformMapping, map );
 346 }
 347
 348 inline void RemoveUniformMapMessage( EventThreadServices& eventThreadServices, const PropertyOwner& owner, const std::string& uniformName )
 349 {
 350   typedef MessageValue1< PropertyOwner, std::string > LocalType;
 351   unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
 352   new (slot) LocalType( &owner, &PropertyOwner::RemoveUniformMapping, uniformName );
 353 }
 354
 355
 356 } // namespace SceneGraph
 357
 358 } // namespace Internal
 359
 360 } // namespace Dali
 361
 362 #endif // __DALI_INTERNAL_SCENE_GRAPH_PROPERTY_OWNER_MESSAGES_H__