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