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

   1 #ifndef DALI_INTERNAL_SCENE_GRAPH_PROPERTY_OWNER_H
   2 #define DALI_INTERNAL_SCENE_GRAPH_PROPERTY_OWNER_H
   3
   4 /*
   5  * Copyright (c) 2020 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 #include <dali/public-api/common/dali-vector.h>
  23 #include <dali/devel-api/common/owner-container.h>
  24 #include <dali/internal/common/message.h>
  25 #include <dali/internal/update/common/property-base.h>
  26 #include <dali/internal/update/common/scene-graph-buffers.h>
  27 #include <dali/internal/update/common/uniform-map.h>
  28 #include <dali/internal/update/animation/scene-graph-constraint-declarations.h>
  29
  30
  31 namespace Dali
  32 {
  33
  34 namespace Internal
  35 {
  36
  37 namespace SceneGraph
  38 {
  39
  40 class PropertyOwner;
  41
  42 using OwnedPropertyContainer = OwnerContainer<PropertyBase*>;
  43 using OwnedPropertyIter      = OwnedPropertyContainer::Iterator;
  44
  45 /**
  46  * An update-thread object which own properties.
  47  * This allows observers to track the lifetime of the object & its properties.
  48  */
  49 class PropertyOwner
  50 {
  51 public:
  52
  53   class Observer
  54   {
  55   public:
  56
  57     /**
  58      * Called when the observable object is connected to the scene graph.
  59      * @param[in] owner A reference to the connected PropertyOwner
  60      */
  61     virtual void PropertyOwnerConnected( PropertyOwner& owner ) = 0;
  62
  63     /**
  64      * Called when the observable object is disconnected from the scene graph.
  65      * @param[in] currentBufferIndex The buffer to reset.
  66      * @param[in] owner A reference to the disconnected PropertyOwner
  67      */
  68     virtual void PropertyOwnerDisconnected( BufferIndex updateBufferIndex, PropertyOwner& owner ) = 0;
  69
  70     /**
  71      * Called shortly before the observable object is destroyed.
  72      *
  73      * @note Cleanup should be done in both this and PropertyOwnerDisconnected as PropertyOwnerDisconnected
  74      * may not be called (i.e. when shutting down).
  75      */
  76     virtual void PropertyOwnerDestroyed( PropertyOwner& owner ) = 0;
  77
  78   protected:
  79
  80     /**
  81      * Virtual destructor, no deletion through this interface
  82      */
  83     virtual ~Observer() = default;
  84   };
  85
  86   /**
  87    * Create a property owner.
  88    * @return A newly allocated object.
  89    */
  90   static PropertyOwner* New();
  91
  92   /**
  93    * Virtual destructor; this is intended as a base class.
  94    */
  95   virtual ~PropertyOwner();
  96
  97   /**
  98    * Add an observer.
  99    * The observer is responsible for calling RemoveObserver(*this) during its own destruction.
 100    * Connecting an actor-side object as an observer is not allowed, due to thread-safety issues.
 101    * @param[in] observer The observer.
 102    */
 103   void AddObserver(Observer& observer);
 104
 105   /**
 106    * Remove an observer.
 107    * @param[in] observer The observer.
 108    */
 109   void RemoveObserver(Observer& observer);
 110
 111   /**
 112    * This method can be used to determine if there is an animation or
 113    * constraint that is using this property owner.
 114    * @return true if there are observers.
 115    */
 116   bool IsObserved();
 117
 118   /**
 119    * Called just before destruction to disconnect all observers and remove constraints.
 120    * This occurs when the object is in the process of being destroyed.
 121    */
 122   void Destroy();
 123
 124   /**
 125    * Notify all observers that the object has been connected
 126    * This occurs when the object is connected to the scene-graph during UpdateManager::Update().
 127    */
 128   void ConnectToSceneGraph();
 129
 130   /**
 131    * Notify all observers that the object has been disconnected and remove constraints.
 132    * This occurs when the object is disconnected from the scene-graph during UpdateManager::Update().
 133    * @param[in] currentBufferIndex The current update buffer.
 134    */
 135   void DisconnectFromSceneGraph( BufferIndex updateBufferIndex );
 136
 137   /**
 138    * Install a custom property.
 139    * @post The PropertyOwner takes ownership of the property.
 140    * @param[in] property A pointer to a newly allocated property.
 141    */
 142   void InstallCustomProperty( OwnerPointer<PropertyBase>& property );
 143
 144   /**
 145    * Retrieve the custom properties owned by the object.
 146    * @return A container of properties.
 147    */
 148   OwnedPropertyContainer& GetCustomProperties()
 149   {
 150     return mCustomProperties;
 151   }
 152
 153   /**
 154    * Retrieve the custom properties owned by the object.
 155    * @return A container of properties.
 156    */
 157   const OwnedPropertyContainer& GetCustomProperties() const
 158   {
 159     return mCustomProperties;
 160   }
 161
 162   /**
 163    * Mark an property owner with the updated flag.
 164    * @param[in] updated The updated flag
 165    */
 166   virtual void SetUpdated(bool updated)
 167   {
 168     mUpdated = updated;
 169   }
 170
 171   /**
 172    * Retrieve if the property owner is updated due to the property is being animating.
 173    * @return An updated flag
 174    */
 175   bool Updated() const
 176   {
 177     return mUpdated;
 178   }
 179
 180   // Constraints
 181
 182   /**
 183    * Apply a constraint.
 184    * @param[in] constraint The constraint to apply.
 185    */
 186   void ApplyConstraint( OwnerPointer<ConstraintBase>& constraint );
 187
 188   /**
 189    * Begin removal of constraints.
 190    * @param[in] constraint The constraint to remove.
 191    */
 192   void RemoveConstraint( ConstraintBase* constraint );
 193
 194   /**
 195    * Retrieve the constraints that are currently applied.
 196    * @return A container of constraints.
 197    */
 198   ConstraintOwnerContainer& GetConstraints();
 199
 200   /**
 201    * @copydoc UniformMap::Add
 202    */
 203   virtual void AddUniformMapping( OwnerPointer< UniformPropertyMapping >& map );
 204
 205   /**
 206    * @copydoc UniformMap::Remove
 207    */
 208   virtual void RemoveUniformMapping( const std::string& uniformName );
 209
 210   /**
 211    * Get the mappings table
 212    */
 213   const UniformMap& GetUniformMap() const;
 214
 215   /**
 216    * @copydoc UniformMap::AddUniformMapObserver
 217    */
 218   void AddUniformMapObserver( UniformMap::Observer& observer );
 219
 220   /**
 221    * @copydoc UniformMap::RemoveUniformMapObserver
 222    */
 223   void RemoveUniformMapObserver( UniformMap::Observer& observer );
 224
 225   /**
 226    * Query whether playing an animation is possible or not.
 227    * @return true if playing an animation is possible.
 228    */
 229   virtual bool IsAnimationPossible() const
 230   {
 231     return true;
 232   }
 233
 234 protected:
 235
 236   /**
 237    * Protected constructor.
 238    */
 239   PropertyOwner();
 240
 241 private:
 242
 243   // Undefined
 244   PropertyOwner(const PropertyOwner&);
 245
 246   // Undefined
 247   PropertyOwner& operator=(const PropertyOwner& rhs);
 248
 249 protected:
 250
 251   OwnedPropertyContainer mCustomProperties; ///< Properties provided with InstallCustomProperty()
 252   UniformMap mUniformMaps; ///< Container of owned uniform maps
 253   bool mUpdated;
 254   bool                   mIsConnectedToSceneGraph;
 255
 256 private:
 257   using ObserverContainer = Dali::Vector<PropertyOwner::Observer*>;
 258   using ObserverIter      = ObserverContainer::Iterator;
 259   using ConstObserverIter = ObserverContainer::ConstIterator;
 260
 261   ObserverContainer mObservers; ///< Container of observer raw-pointers (not owned)
 262
 263   ConstraintOwnerContainer mConstraints; ///< Container of owned constraints
 264 };
 265
 266 } // namespace SceneGraph
 267
 268 } // namespace Internal
 269
 270 } // namespace Dali
 271
 272 #endif // DALI_INTERNAL_SCENE_GRAPH_PROPERTY_OWNER_H