dali/internal/update/nodes/node.h

   1 #ifndef DALI_INTERNAL_SCENE_GRAPH_NODE_H
   2 #define DALI_INTERNAL_SCENE_GRAPH_NODE_H
   3
   4 /*
   5  * Copyright (c) 2017 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/actors/actor-enumerations.h>
  23 #include <dali/public-api/actors/draw-mode.h>
  24 #include <dali/devel-api/common/set-wrapper.h>
  25 #include <dali/public-api/math/quaternion.h>
  26 #include <dali/public-api/math/math-utils.h>
  27 #include <dali/public-api/math/vector3.h>
  28 #include <dali/integration-api/debug.h>
  29 #include <dali/internal/common/message.h>
  30 #include <dali/internal/event/common/event-thread-services.h>
  31 #include <dali/internal/render/data-providers/node-data-provider.h>
  32 #include <dali/internal/update/common/animatable-property.h>
  33 #include <dali/internal/update/common/property-owner.h>
  34 #include <dali/internal/update/common/property-vector3.h>
  35 #include <dali/internal/update/common/scene-graph-buffers.h>
  36 #include <dali/internal/update/common/inherited-property.h>
  37 #include <dali/internal/update/manager/transform-manager.h>
  38 #include <dali/internal/update/manager/transform-manager-property.h>
  39 #include <dali/internal/update/nodes/node-declarations.h>
  40 #include <dali/internal/update/rendering/scene-graph-renderer.h>
  41
  42 namespace Dali
  43 {
  44
  45 namespace Internal
  46 {
  47
  48 // Value types used by messages.
  49 template <> struct ParameterType< ColorMode > : public BasicType< ColorMode > {};
  50 template <> struct ParameterType< PositionInheritanceMode > : public BasicType< PositionInheritanceMode > {};
  51 template <> struct ParameterType< ClippingMode::Type > : public BasicType< ClippingMode::Type > {};
  52
  53 namespace SceneGraph
  54 {
  55
  56 class DiscardQueue;
  57 class Layer;
  58 class RenderTask;
  59 class UpdateManager;
  60
  61 /**
  62  * Flag whether property has changed, during the Update phase.
  63  */
  64 enum NodePropertyFlags
  65 {
  66   NothingFlag          = 0x000,
  67   TransformFlag        = 0x001,
  68   VisibleFlag          = 0x002,
  69   ColorFlag            = 0x004,
  70   SizeFlag             = 0x008,
  71   OverlayFlag          = 0x010,
  72   SortModifierFlag     = 0x020,
  73   ChildDeletedFlag     = 0x040,
  74 };
  75
  76 static const int AllFlags = ( ChildDeletedFlag << 1 ) - 1; // all the flags
  77
  78 /**
  79  * Size is not inherited. VisibleFlag is inherited
  80  */
  81 static const int InheritedDirtyFlags = TransformFlag | VisibleFlag | ColorFlag | OverlayFlag;
  82
  83 // Flags which require the scene renderable lists to be updated
  84 static const int RenderableUpdateFlags = TransformFlag | SortModifierFlag | ChildDeletedFlag;
  85
  86 /**
  87  * Node is the base class for all nodes in the Scene Graph.
  88  *
  89  * Each node provides a transformation which applies to the node and
  90  * its children.  Node data is double-buffered. This allows an update
  91  * thread to modify node data, without interferring with another
  92  * thread reading the values from the previous update traversal.
  93  */
  94 class Node : public PropertyOwner, public NodeDataProvider
  95 {
  96 public:
  97
  98   // Defaults
  99   static const PositionInheritanceMode DEFAULT_POSITION_INHERITANCE_MODE;
 100   static const ColorMode DEFAULT_COLOR_MODE;
 101
 102   // Creation methods
 103
 104   /**
 105    * Construct a new Node.
 106    */
 107   static Node* New();
 108
 109   /**
 110    * Deletes a Node.
 111    */
 112   static void Delete( Node* node );
 113
 114   /**
 115    * Called during UpdateManager::DestroyNode shortly before Node is destroyed.
 116    */
 117   void OnDestroy();
 118
 119   // Layer interface
 120
 121   /**
 122    * Query whether the node is a layer.
 123    * @return True if the node is a layer.
 124    */
 125   bool IsLayer()
 126   {
 127     return mIsLayer;
 128   }
 129
 130   /**
 131    * Convert a node to a layer.
 132    * @return A pointer to the layer, or NULL.
 133    */
 134   virtual Layer* GetLayer()
 135   {
 136     return NULL;
 137   }
 138
 139   /**
 140    * This method sets clipping information on the node based on its hierarchy in the scene-graph.
 141    * A value is calculated that can be used during sorting to increase sort speed.
 142    * @param[in] clippingId The Clipping ID of the node to set
 143    * @param[in] clippingDepth The Clipping Depth of the node to set
 144    */
 145   void SetClippingInformation( const uint32_t clippingId, const uint32_t clippingDepth )
 146   {
 147     // We only set up the sort value if we have a clipping depth, IE. At least 1 clipping node has been hit.
 148     // If not, if we traverse down a clipping tree and back up, and there is another
 149     // node on the parent, this will have a non-zero clipping ID that must be ignored
 150     if( DALI_LIKELY( clippingDepth > 0u ) )
 151     {
 152       mClippingDepth = clippingDepth;
 153
 154       // Calculate the sort value here on write, as when read (during sort) it may be accessed several times.
 155       // The items must be sorted by Clipping ID first (so the ID is kept in the most-significant bits).
 156       // For the same ID, the clipping nodes must be first, so we negate the
 157       // clipping enabled flag and set it as the least significant bit.
 158       mClippingSortModifier = ( clippingId << 1u ) | ( mClippingMode == ClippingMode::DISABLED ? 1u : 0u );
 159     }
 160     else
 161     {
 162       // If we do not have a clipping depth, then set this to 0 so we do not have a Clipping ID either.
 163       mClippingSortModifier = 0u;
 164     }
 165   }
 166
 167   /**
 168    * Gets the Clipping ID for this node.
 169    * @return The Clipping ID for this node.
 170    */
 171   uint32_t GetClippingId() const
 172   {
 173     return mClippingSortModifier >> 1u;
 174   }
 175
 176   /**
 177    * Gets the Clipping Depth for this node.
 178    * @return The Clipping Depth for this node.
 179    */
 180   uint32_t GetClippingDepth() const
 181   {
 182     return mClippingDepth;
 183   }
 184
 185   /**
 186    * Sets the clipping mode for this node.
 187    * @param[in] clippingMode The ClippingMode to set
 188    */
 189   void SetClippingMode( const ClippingMode::Type clippingMode )
 190   {
 191     mClippingMode = clippingMode;
 192   }
 193
 194   /**
 195    * Gets the Clipping Mode for this node.
 196    * @return The ClippingMode of this node
 197    */
 198   ClippingMode::Type GetClippingMode() const
 199   {
 200     return mClippingMode;
 201   }
 202
 203   /**
 204    * Add a renderer to the node
 205    * @param[in] renderer The renderer added to the node
 206    */
 207   void AddRenderer( Renderer* renderer );
 208
 209   /**
 210    * Remove a renderer from the node
 211    * @param[in] renderer The renderer to be removed
 212    */
 213   void RemoveRenderer( Renderer* renderer );
 214
 215   /*
 216    * Get the renderer at the given index
 217    * @param[in] index
 218    */
 219   Renderer* GetRendererAt( unsigned int index ) const
 220   {
 221     return mRenderer[index];
 222   }
 223
 224   /**
 225    * Retrieve the number of renderers for the node
 226    */
 227   unsigned int GetRendererCount()
 228   {
 229     return mRenderer.Size();
 230   }
 231
 232   // Containment methods
 233
 234   /**
 235    * Query whether a node is the root node. Root nodes cannot have a parent node.
 236    * A node becomes a root node, when it is installed by UpdateManager.
 237    * @return True if the node is a root node.
 238    */
 239   bool IsRoot() const
 240   {
 241     return mIsRoot;
 242   }
 243
 244   /**
 245    * Set whether a node is the root node. Root nodes cannot have a parent node.
 246    * This method should only be called by UpdateManager.
 247    * @pre When isRoot is true, the node must not have a parent.
 248    * @param[in] isRoot Whether the node is now a root node.
 249    */
 250   void SetRoot(bool isRoot);
 251
 252   /**
 253    * Retrieve the parent of a Node.
 254    * @return The parent node, or NULL if the Node has not been added to the scene-graph.
 255    */
 256   Node* GetParent()
 257   {
 258     return mParent;
 259   }
 260
 261   /**
 262    * Retrieve the parent of a Node.
 263    * @return The parent node, or NULL if the Node has not been added to the scene-graph.
 264    */
 265   const Node* GetParent() const
 266   {
 267     return mParent;
 268   }
 269
 270   /**
 271    * Connect a node to the scene-graph.
 272    * @pre A node cannot be added to itself.
 273    * @pre The parent node is connected to the scene-graph.
 274    * @pre The childNode does not already have a parent.
 275    * @pre The childNode is not a root node.
 276    * @param[in] childNode The child to add.
 277    */
 278   void ConnectChild( Node* childNode );
 279
 280   /**
 281    * Disconnect a child (& its children) from the scene-graph.
 282    * @pre childNode is a child of this Node.
 283    * @param[in] updateBufferIndex The current update buffer index.
 284    * @param[in] childNode The node to disconnect.
 285    */
 286   void DisconnectChild( BufferIndex updateBufferIndex, Node& childNode );
 287
 288   /**
 289    * Retrieve the children a Node.
 290    * @return The container of children.
 291    */
 292   const NodeContainer& GetChildren() const
 293   {
 294     return mChildren;
 295   }
 296
 297   /**
 298    * Retrieve the children a Node.
 299    * @return The container of children.
 300    */
 301   NodeContainer& GetChildren()
 302   {
 303     return mChildren;
 304   }
 305
 306   // Update methods
 307
 308   /**
 309    * Flag that one of the node values has changed in the current frame.
 310    * @param[in] flag The flag to set.
 311    */
 312   void SetDirtyFlag(NodePropertyFlags flag)
 313   {
 314     mDirtyFlags |= flag;
 315   }
 316
 317   /**
 318    * Flag that all of the node values are dirty.
 319    */
 320   void SetAllDirtyFlags()
 321   {
 322     mDirtyFlags = AllFlags;
 323   }
 324
 325   /**
 326    * Query whether a node is dirty.
 327    * @return The dirty flags
 328    */
 329   int GetDirtyFlags() const;
 330
 331   /**
 332    * Retrieve the parent-origin of the node.
 333    * @return The parent-origin.
 334    */
 335   const Vector3& GetParentOrigin() const
 336   {
 337     return mParentOrigin.Get(0);
 338   }
 339
 340   /**
 341    * Sets both the local & base parent-origins of the node.
 342    * @param[in] origin The new local & base parent-origins.
 343    */
 344   void SetParentOrigin(const Vector3& origin)
 345   {
 346     mParentOrigin.Set(0,origin );
 347   }
 348
 349   /**
 350    * Retrieve the anchor-point of the node.
 351    * @return The anchor-point.
 352    */
 353   const Vector3& GetAnchorPoint() const
 354   {
 355     return mAnchorPoint.Get(0);
 356   }
 357
 358   /**
 359    * Sets both the local & base anchor-points of the node.
 360    * @param[in] anchor The new local & base anchor-points.
 361    */
 362   void SetAnchorPoint(const Vector3& anchor)
 363   {
 364     mAnchorPoint.Set(0, anchor );
 365   }
 366
 367   /**
 368    * Retrieve the local position of the node, relative to its parent.
 369    * @param[in] bufferIndex The buffer to read from.
 370    * @return The local position.
 371    */
 372   const Vector3& GetPosition(BufferIndex bufferIndex) const
 373   {
 374     if( mTransformId != INVALID_TRANSFORM_ID )
 375     {
 376       return mPosition.Get(bufferIndex);
 377     }
 378
 379     return Vector3::ZERO;
 380   }
 381
 382   /**
 383    * Retrieve the position of the node derived from the position of all its parents.
 384    * @return The world position.
 385    */
 386   const Vector3& GetWorldPosition( BufferIndex bufferIndex ) const
 387   {
 388     return mWorldPosition.Get(bufferIndex);
 389   }
 390
 391   /**
 392    * Set whether the Node inherits position.
 393    * @param[in] inherit True if the parent position is inherited.
 394    */
 395   void SetInheritPosition(bool inherit)
 396   {
 397     if( mTransformId != INVALID_TRANSFORM_ID )
 398     {
 399       mTransformManager->SetInheritPosition( mTransformId, inherit );
 400     }
 401   }
 402
 403   /**
 404    * Retrieve the local orientation of the node, relative to its parent.
 405    * @param[in] bufferIndex The buffer to read from.
 406    * @return The local orientation.
 407    */
 408   const Quaternion& GetOrientation(BufferIndex bufferIndex) const
 409   {
 410     if( mTransformId != INVALID_TRANSFORM_ID )
 411     {
 412       return mOrientation.Get(0);
 413     }
 414
 415     return Quaternion::IDENTITY;
 416   }
 417
 418   /**
 419    * Retrieve the orientation of the node derived from the rotation of all its parents.
 420    * @param[in] bufferIndex The buffer to read from.
 421    * @return The world rotation.
 422    */
 423   const Quaternion& GetWorldOrientation( BufferIndex bufferIndex ) const
 424   {
 425     return mWorldOrientation.Get(0);
 426   }
 427
 428   /**
 429    * Set whether the Node inherits orientation.
 430    * @param[in] inherit True if the parent orientation is inherited.
 431    */
 432   void SetInheritOrientation(bool inherit)
 433   {
 434     if( mTransformId != INVALID_TRANSFORM_ID )
 435     {
 436       mTransformManager->SetInheritOrientation(mTransformId, inherit );
 437     }
 438   }
 439
 440   /**
 441    * Retrieve the local scale of the node, relative to its parent.
 442    * @param[in] bufferIndex The buffer to read from.
 443    * @return The local scale.
 444    */
 445   const Vector3& GetScale(BufferIndex bufferIndex) const
 446   {
 447     if( mTransformId != INVALID_TRANSFORM_ID )
 448     {
 449       return mScale.Get(0);
 450     }
 451
 452     return Vector3::ONE;
 453   }
 454
 455
 456   /**
 457    * Retrieve the scale of the node derived from the scale of all its parents.
 458    * @param[in] bufferIndex The buffer to read from.
 459    * @return The world scale.
 460    */
 461   const Vector3& GetWorldScale( BufferIndex bufferIndex ) const
 462   {
 463     return mWorldScale.Get(0);
 464   }
 465
 466   /**
 467    * Set whether the Node inherits scale.
 468    * @param inherit True if the Node inherits scale.
 469    */
 470   void SetInheritScale( bool inherit )
 471   {
 472     if( mTransformId != INVALID_TRANSFORM_ID )
 473     {
 474       mTransformManager->SetInheritScale(mTransformId, inherit );
 475     }
 476   }
 477
 478   /**
 479    * Retrieve the visibility of the node.
 480    * @param[in] bufferIndex The buffer to read from.
 481    * @return True if the node is visible.
 482    */
 483   bool IsVisible(BufferIndex bufferIndex) const
 484   {
 485     return mVisible[bufferIndex];
 486   }
 487
 488   /**
 489    * Retrieve the opacity of the node.
 490    * @param[in] bufferIndex The buffer to read from.
 491    * @return The opacity.
 492    */
 493   float GetOpacity(BufferIndex bufferIndex) const
 494   {
 495     return mColor[bufferIndex].a;
 496   }
 497
 498   /**
 499    * Retrieve the color of the node.
 500    * @param[in] bufferIndex The buffer to read from.
 501    * @return The color.
 502    */
 503   const Vector4& GetColor(BufferIndex bufferIndex) const
 504   {
 505     return mColor[bufferIndex];
 506   }
 507
 508   /**
 509    * Sets the color of the node derived from the color of all its parents.
 510    * @param[in] color The world color.
 511    * @param[in] updateBufferIndex The current update buffer index.
 512    */
 513   void SetWorldColor(const Vector4& color, BufferIndex updateBufferIndex)
 514   {
 515     mWorldColor.Set( updateBufferIndex, color );
 516   }
 517
 518   /**
 519    * Sets the color of the node derived from the color of all its parents.
 520    * This method should only be called when the parents world color is up-to-date.
 521    * @pre The node has a parent.
 522    * @param[in] updateBufferIndex The current update buffer index.
 523    */
 524   void InheritWorldColor( BufferIndex updateBufferIndex )
 525   {
 526     DALI_ASSERT_DEBUG(mParent != NULL);
 527
 528     // default first
 529     if( mColorMode == USE_OWN_MULTIPLY_PARENT_ALPHA )
 530     {
 531       const Vector4& ownColor = mColor[updateBufferIndex];
 532       mWorldColor.Set( updateBufferIndex, ownColor.r, ownColor.g, ownColor.b, ownColor.a * mParent->GetWorldColor(updateBufferIndex).a );
 533     }
 534     else if( mColorMode == USE_OWN_MULTIPLY_PARENT_COLOR )
 535     {
 536       mWorldColor.Set( updateBufferIndex, mParent->GetWorldColor(updateBufferIndex) * mColor[updateBufferIndex] );
 537     }
 538     else if( mColorMode == USE_PARENT_COLOR )
 539     {
 540       mWorldColor.Set( updateBufferIndex, mParent->GetWorldColor(updateBufferIndex) );
 541     }
 542     else // USE_OWN_COLOR
 543     {
 544       mWorldColor.Set( updateBufferIndex, mColor[updateBufferIndex] );
 545     }
 546   }
 547
 548   /**
 549    * Copies the previous inherited scale, if this changed in the previous frame.
 550    * This method should be called instead of InheritWorldScale i.e. if the inherited scale
 551    * does not need to be recalculated in the current frame.
 552    * @param[in] updateBufferIndex The current update buffer index.
 553    */
 554   void CopyPreviousWorldColor( BufferIndex updateBufferIndex )
 555   {
 556     mWorldColor.CopyPrevious( updateBufferIndex );
 557   }
 558
 559   /**
 560    * Retrieve the color of the node, possibly derived from the color
 561    * of all its parents, depending on the value of mColorMode.
 562    * @param[in] bufferIndex The buffer to read from.
 563    * @return The world color.
 564    */
 565   const Vector4& GetWorldColor(BufferIndex bufferIndex) const
 566   {
 567     return mWorldColor[bufferIndex];
 568   }
 569
 570   /**
 571    * Set the color mode. This specifies whether the Node uses its own color,
 572    * or inherits its parent color.
 573    * @param[in] colorMode The new color mode.
 574    */
 575   void SetColorMode(ColorMode colorMode)
 576   {
 577     mColorMode = colorMode;
 578
 579     SetDirtyFlag(ColorFlag);
 580   }
 581
 582   /**
 583    * Retrieve the color mode.
 584    * @return The color mode.
 585    */
 586   ColorMode GetColorMode() const
 587   {
 588     return mColorMode;
 589   }
 590
 591   /**
 592    * Retrieve the size of the node.
 593    * @param[in] bufferIndex The buffer to read from.
 594    * @return The size.
 595    */
 596   const Vector3& GetSize(BufferIndex bufferIndex) const
 597   {
 598     if( mTransformId != INVALID_TRANSFORM_ID )
 599     {
 600       return mSize.Get(0);
 601     }
 602
 603     return Vector3::ZERO;
 604   }
 605
 606   /**
 607    * Retrieve the bounding sphere of the node
 608    * @return A vector4 describing the bounding sphere. XYZ is the center and W is the radius
 609    */
 610   const Vector4& GetBoundingSphere() const
 611   {
 612     if( mTransformId != INVALID_TRANSFORM_ID )
 613     {
 614       return mTransformManager->GetBoundingSphere( mTransformId );
 615     }
 616
 617     return Vector4::ZERO;
 618   }
 619
 620   /**
 621    * Retrieve world matrix and size of the node
 622    * @param[out] The local to world matrix of the node
 623    * @param[out] size The current size of the node
 624    */
 625   void GetWorldMatrixAndSize( Matrix& worldMatrix, Vector3& size ) const
 626   {
 627     if( mTransformId != INVALID_TRANSFORM_ID )
 628     {
 629       mTransformManager->GetWorldMatrixAndSize( mTransformId, worldMatrix, size );
 630     }
 631   }
 632
 633   /**
 634    * Checks if local matrix has changed since last update
 635    * @return true if local matrix has changed, false otherwise
 636    */
 637   bool IsLocalMatrixDirty() const
 638   {
 639     return (mTransformId != INVALID_TRANSFORM_ID) &&
 640            (mTransformManager->IsLocalMatrixDirty( mTransformId ));
 641   }
 642
 643   /**
 644    * Retrieve the cached world-matrix of a node.
 645    * @param[in] bufferIndex The buffer to read from.
 646    * @return The world-matrix.
 647    */
 648   const Matrix& GetWorldMatrix( BufferIndex bufferIndex ) const
 649   {
 650     return mWorldMatrix.Get(bufferIndex);
 651   }
 652
 653   /**
 654    * Mark the node as exclusive to a single RenderTask.
 655    * @param[in] renderTask The render-task, or NULL if the Node is not exclusive to a single RenderTask.
 656    */
 657   void SetExclusiveRenderTask( RenderTask* renderTask )
 658   {
 659     mExclusiveRenderTask = renderTask;
 660   }
 661
 662   /**
 663    * Query whether the node is exclusive to a single RenderTask.
 664    * @return The render-task, or NULL if the Node is not exclusive to a single RenderTask.
 665    */
 666   RenderTask* GetExclusiveRenderTask() const
 667   {
 668     return mExclusiveRenderTask;
 669   }
 670
 671   /**
 672    * Set how the Node and its children should be drawn; see Dali::Actor::SetDrawMode() for more details.
 673    * @param[in] drawMode The new draw-mode to use.
 674    */
 675   void SetDrawMode( const DrawMode::Type& drawMode )
 676   {
 677     mDrawMode = drawMode;
 678   }
 679
 680   /**
 681    * Returns whether node is an overlay or not.
 682    * @return True if node is an overlay, false otherwise.
 683    */
 684   DrawMode::Type GetDrawMode() const
 685   {
 686     return mDrawMode;
 687   }
 688
 689   /*
 690    * Returns the transform id of the node
 691    * @return The transform component id of the node
 692    */
 693   TransformId GetTransformId() const
 694   {
 695     return mTransformId;
 696   }
 697
 698   /**
 699    * Equality operator, checks for identity, not values.
 700    * @param[in]
 701    */
 702   bool operator==( const Node* rhs ) const
 703   {
 704     return ( this == rhs );
 705   }
 706
 707   /**
 708    * @brief Sets the sibling order of the node
 709    * @param[in] order The new order
 710    */
 711   void SetDepthIndex( unsigned int depthIndex ){ mDepthIndex = depthIndex; }
 712
 713   /**
 714    * @brief Get the depth index of the node
 715    * @return Current depth index
 716    */
 717   unsigned int GetDepthIndex(){ return mDepthIndex; }
 718
 719 public:
 720   /**
 721    * @copydoc UniformMap::Add
 722    */
 723   void AddUniformMapping( UniformPropertyMapping* map );
 724
 725   /**
 726    * @copydoc UniformMap::Remove
 727    */
 728   void RemoveUniformMapping( const std::string& uniformName );
 729
 730   /**
 731    * Prepare the node for rendering.
 732    * This is called by the UpdateManager when an object is due to be rendered in the current frame.
 733    * @param[in] updateBufferIndex The current update buffer index.
 734    */
 735   void PrepareRender( BufferIndex bufferIndex );
 736
 737   /**
 738    * Called by UpdateManager when the node is added.
 739    * Creates a new transform component in the transform manager and initialize all the properties
 740    * related to the transformation
 741    * @param[in] transformManager A pointer to the trnasform manager (Owned by UpdateManager)
 742    */
 743   void CreateTransform( SceneGraph::TransformManager* transformManager );
 744
 745 protected:
 746
 747   /**
 748    * Set the parent of a Node.
 749    * @param[in] parentNode the new parent.
 750    */
 751   void SetParent( Node& parentNode );
 752
 753 protected:
 754
 755   /**
 756    * Protected constructor; See also Node::New()
 757    */
 758   Node();
 759
 760   /**
 761    * Protected virtual destructor; See also Node::Delete( Node* )
 762    * Kept protected to allow destructor chaining from layer
 763    */
 764   virtual ~Node();
 765
 766 private: // from NodeDataProvider
 767
 768   /**
 769    * @copydoc NodeDataProvider::GetModelMatrix
 770    */
 771   virtual const Matrix& GetModelMatrix( unsigned int bufferId ) const
 772   {
 773     return GetWorldMatrix( bufferId );
 774   }
 775
 776   /**
 777    * @copydoc NodeDataProvider::GetRenderColor
 778    */
 779   virtual const Vector4& GetRenderColor( unsigned int bufferId ) const
 780   {
 781     return GetWorldColor( bufferId );
 782   }
 783
 784 public: // From UniformMapDataProvider
 785   /**
 786    * @copydoc UniformMapDataProvider::GetUniformMapChanged
 787    */
 788   virtual bool GetUniformMapChanged( BufferIndex bufferIndex ) const
 789   {
 790     return mUniformMapChanged[bufferIndex];
 791   }
 792
 793   /**
 794    * @copydoc UniformMapDataProvider::GetUniformMap
 795    */
 796   virtual const CollectedUniformMap& GetUniformMap( BufferIndex bufferIndex ) const
 797   {
 798     return mCollectedUniformMap[bufferIndex];
 799   }
 800
 801 private:
 802
 803   // Undefined
 804   Node(const Node&);
 805
 806   // Undefined
 807   Node& operator=(const Node& rhs);
 808
 809   /**
 810    * @copydoc Dali::Internal::SceneGraph::PropertyOwner::ResetDefaultProperties()
 811    */
 812   virtual void ResetDefaultProperties( BufferIndex updateBufferIndex );
 813
 814   /**
 815    * Recursive helper to disconnect a Node and its children.
 816    * Disconnected Nodes have no parent or children.
 817    * @param[in] updateBufferIndex The current update buffer index.
 818    */
 819   void RecursiveDisconnectFromSceneGraph( BufferIndex updateBufferIndex );
 820
 821 public: // Default properties
 822
 823   TransformManager*                  mTransformManager;
 824   TransformId                        mTransformId;
 825   TransformManagerPropertyVector3    mParentOrigin;           ///< Local transform; the position is relative to this. Sets the TransformFlag dirty when changed
 826   TransformManagerPropertyVector3    mAnchorPoint;            ///< Local transform; local center of rotation. Sets the TransformFlag dirty when changed
 827   TransformManagerPropertyVector3    mSize;                   ///< Size is provided for layouting
 828   TransformManagerPropertyVector3    mPosition;               ///< Local transform; distance between parent-origin & anchor-point
 829   TransformManagerPropertyQuaternion mOrientation;            ///< Local transform; rotation relative to parent node
 830   TransformManagerPropertyVector3    mScale;                  ///< Local transform; scale relative to parent node
 831
 832   AnimatableProperty<bool>           mVisible;                ///< Visibility can be inherited from the Node hierachy
 833   AnimatableProperty<Vector4>        mColor;                  ///< Color can be inherited from the Node hierarchy
 834
 835   // Inherited properties; read-only from public API
 836
 837   TransformManagerVector3Input       mWorldPosition;          ///< Full inherited position
 838   TransformManagerVector3Input       mWorldScale;
 839   TransformManagerQuaternionInput    mWorldOrientation;       ///< Full inherited orientation
 840   TransformManagerMatrixInput        mWorldMatrix;            ///< Full inherited world matrix
 841   InheritedColor                     mWorldColor;             ///< Full inherited color
 842
 843   uint32_t                           mClippingSortModifier;   ///< Contains bit-packed clipping information for quick access when sorting
 844
 845 protected:
 846
 847   Node*                              mParent;                 ///< Pointer to parent node (a child is owned by its parent)
 848   RenderTask*                        mExclusiveRenderTask;    ///< Nodes can be marked as exclusive to a single RenderTask
 849
 850   RendererContainer                  mRenderer;               ///< Container of renderers; not owned
 851
 852   NodeContainer                      mChildren;               ///< Container of children; not owned
 853
 854   CollectedUniformMap                mCollectedUniformMap[2]; ///< Uniform maps of the node
 855   unsigned int                       mUniformMapChanged[2];   ///< Records if the uniform map has been altered this frame
 856   uint32_t                           mClippingDepth;          ///< The number of clipping nodes deep this node is
 857
 858   uint32_t                           mDepthIndex;             ///< Depth index of the node
 859
 860   // flags, compressed to bitfield
 861   unsigned int                       mRegenerateUniformMap:2; ///< Indicate if the uniform map has to be regenerated this frame
 862   int                                mDirtyFlags:8;           ///< A composite set of flags for each of the Node properties
 863   DrawMode::Type                     mDrawMode:2;             ///< How the Node and its children should be drawn
 864   ColorMode                          mColorMode:2;            ///< Determines whether mWorldColor is inherited, 2 bits is enough
 865   ClippingMode::Type                 mClippingMode:2;         ///< The clipping mode of this node
 866   bool                               mIsRoot:1;               ///< True if the node cannot have a parent
 867   bool                               mIsLayer:1;              ///< True if the node is a layer
 868   // Changes scope, should be at end of class
 869   DALI_LOG_OBJECT_STRING_DECLARATION;
 870 };
 871
 872 // Messages for Node
 873
 874 inline void SetInheritOrientationMessage( EventThreadServices& eventThreadServices, const Node& node, bool inherit )
 875 {
 876   typedef MessageValue1< Node, bool > LocalType;
 877
 878   // Reserve some memory inside the message queue
 879   unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
 880
 881   // Construct message in the message queue memory; note that delete should not be called on the return value
 882   new (slot) LocalType( &node, &Node::SetInheritOrientation, inherit );
 883 }
 884
 885 inline void SetParentOriginMessage( EventThreadServices& eventThreadServices, const Node& node, const Vector3& origin )
 886 {
 887   typedef MessageValue1< Node, Vector3 > LocalType;
 888
 889   // Reserve some memory inside the message queue
 890   unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
 891
 892   // Construct message in the message queue memory; note that delete should not be called on the return value
 893   new (slot) LocalType( &node, &Node::SetParentOrigin, origin );
 894 }
 895
 896 inline void SetAnchorPointMessage( EventThreadServices& eventThreadServices, const Node& node, const Vector3& anchor )
 897 {
 898   typedef MessageValue1< Node, Vector3 > LocalType;
 899
 900   // Reserve some memory inside the message queue
 901   unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
 902
 903   // Construct message in the message queue memory; note that delete should not be called on the return value
 904   new (slot) LocalType( &node, &Node::SetAnchorPoint, anchor );
 905 }
 906
 907 inline void SetInheritPositionMessage( EventThreadServices& eventThreadServices, const Node& node, bool inherit )
 908 {
 909   typedef MessageValue1< Node, bool > LocalType;
 910
 911   // Reserve some memory inside the message queue
 912   unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
 913
 914   // Construct message in the message queue memory; note that delete should not be called on the return value
 915   new (slot) LocalType( &node, &Node::SetInheritPosition, inherit );
 916 }
 917
 918 inline void SetInheritScaleMessage( EventThreadServices& eventThreadServices, const Node& node, bool inherit )
 919 {
 920   typedef MessageValue1< Node, bool > LocalType;
 921
 922   // Reserve some memory inside the message queue
 923   unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
 924
 925   // Construct message in the message queue memory; note that delete should not be called on the return value
 926   new (slot) LocalType( &node, &Node::SetInheritScale, inherit );
 927 }
 928
 929 inline void SetColorModeMessage( EventThreadServices& eventThreadServices, const Node& node, ColorMode colorMode )
 930 {
 931   typedef MessageValue1< Node, ColorMode > LocalType;
 932
 933   // Reserve some memory inside the message queue
 934   unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
 935
 936   // Construct message in the message queue memory; note that delete should not be called on the return value
 937   new (slot) LocalType( &node, &Node::SetColorMode, colorMode );
 938 }
 939
 940 inline void SetDrawModeMessage( EventThreadServices& eventThreadServices, const Node& node, DrawMode::Type drawMode )
 941 {
 942   typedef MessageValue1< Node, DrawMode::Type > LocalType;
 943
 944   // Reserve some memory inside the message queue
 945   unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
 946
 947   // Construct message in the message queue memory; note that delete should not be called on the return value
 948   new (slot) LocalType( &node, &Node::SetDrawMode, drawMode );
 949 }
 950
 951 inline void AddRendererMessage( EventThreadServices& eventThreadServices, const Node& node, Renderer* renderer )
 952 {
 953   typedef MessageValue1< Node, Renderer* > LocalType;
 954
 955   // Reserve some memory inside the message queue
 956   unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
 957
 958   // Construct message in the message queue memory; note that delete should not be called on the return value
 959   new (slot) LocalType( &node, &Node::AddRenderer, renderer );
 960 }
 961
 962 inline void RemoveRendererMessage( EventThreadServices& eventThreadServices, const Node& node, Renderer* renderer )
 963 {
 964   typedef MessageValue1< Node, Renderer* > LocalType;
 965
 966   // Reserve some memory inside the message queue
 967   unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
 968
 969   // Construct message in the message queue memory; note that delete should not be called on the return value
 970   new (slot) LocalType( &node, &Node::RemoveRenderer, renderer );
 971 }
 972
 973 inline void SetDepthIndexMessage( EventThreadServices& eventThreadServices, const Node& node, unsigned int depthIndex )
 974 {
 975   typedef MessageValue1< Node, unsigned int > LocalType;
 976
 977   // Reserve some memory inside the message queue
 978   unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
 979
 980   // Construct message in the message queue memory; note that delete should not be called on the return value
 981   new (slot) LocalType( &node, &Node::SetDepthIndex, depthIndex );
 982 }
 983
 984 inline void SetClippingModeMessage( EventThreadServices& eventThreadServices, const Node& node, ClippingMode::Type clippingMode )
 985 {
 986   typedef MessageValue1< Node, ClippingMode::Type > LocalType;
 987
 988   // Reserve some memory inside the message queue
 989   unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
 990
 991   // Construct message in the message queue memory; note that delete should not be called on the return value
 992   new (slot) LocalType( &node, &Node::SetClippingMode, clippingMode );
 993 }
 994
 995
 996 } // namespace SceneGraph
 997
 998 // Template specialisation for OwnerPointer<Node>, because delete is protected
 999 template <>
1000 void OwnerPointer<Dali::Internal::SceneGraph::Node>::Reset();
1001
1002 } // namespace Internal
1003
1004 // Template specialisations for OwnerContainer<Node*>, because delete is protected
1005 template <>
1006 void OwnerContainer<Dali::Internal::SceneGraph::Node*>::Delete( Dali::Internal::SceneGraph::Node* pointer );
1007
1008 } // namespace Dali
1009
1010 #endif // DALI_INTERNAL_SCENE_GRAPH_NODE_H