dali/internal/update/node-attachments/scene-graph-renderer-attachment.h

   1 #ifndef DALI_INTERNAL_SCENE_GRAPH_RENDERER_ATTACHMENT_H
   2 #define DALI_INTERNAL_SCENE_GRAPH_RENDERER_ATTACHMENT_H
   3
   4 /*
   5  * Copyright (c) 2015 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 #include <dali/internal/event/common/event-thread-services.h>
  21 #include <dali/internal/update/common/double-buffered.h>
  22 #include <dali/internal/update/common/property-owner.h>
  23 #include <dali/internal/update/common/animatable-property.h>
  24 #include <dali/internal/update/common/scene-graph-connection-change-propagator.h>
  25 #include <dali/internal/update/controllers/render-message-dispatcher.h>
  26 #include <dali/internal/update/controllers/scene-controller.h>
  27 #include <dali/internal/update/node-attachments/scene-graph-renderable-attachment.h>
  28 #include <dali/internal/render/data-providers/render-data-provider.h>
  29
  30 namespace Dali
  31 {
  32 namespace Internal
  33 {
  34 namespace SceneGraph
  35 {
  36 class Material;
  37 class Geometry;
  38 class NewRenderer;
  39
  40 /**
  41  * The renderer attachment is the SceneGraph equivalent of Dali::Renderer. It is used to create an instance of a geometry and material for rendering, and is attached to an actor.
  42  *
  43  * It observes it's children (Material and Geometry) for connection change and for uniform map change, and observer's it's actor parent for uniform map change - this allows it to re-generate the uniform maps used by its RenderThread equivalent class.
  44  *
  45  * Lifetime and ownership
  46  * It is created when a Dali::Renderer is created, and sent to UpdateManager. At this point
  47  * Initialize is called on the object, but ownership is NOT taken by UpdateManager.
  48
  49  * When a Dali::Renderer is added to an actor, then this object becomes the node attachment
  50  * for that actor, and the node takes ownership. It will create the Render::NewRenderer object
  51  * in the Update thread on reciept of the connection message.
  52
  53  * When it's not attached to an actor, it is still possible to send messages to this
  54  * object, to, e.g., set the material, or a property.
  55  *
  56  * @todo MESH_REWORK On merge with RenderableAttachment, change owner of all attachments to UpdateManager.
  57  */
  58 class RendererAttachment : public RenderableAttachment,
  59                            public PropertyOwner,
  60                            public UniformMapDataProvider,
  61                            public UniformMap::Observer,
  62                            public ConnectionChangePropagator::Observer
  63 {
  64 public:
  65   /**
  66    * Create a new renderer attachment.
  67    * @return The newly allocated RendererAttachment
  68    */
  69   static RendererAttachment* New();
  70
  71   /**
  72    * Constructor
  73    */
  74   RendererAttachment();
  75
  76   /**
  77    * Destructor
  78    */
  79   virtual ~RendererAttachment();
  80
  81   /**
  82    * @copydoc RenderableAttachment::Initialize2().
  83    */
  84   virtual void Initialize2( BufferIndex updateBufferIndex );
  85
  86   /**
  87    * @copydoc RenderableAttachment::OnDestroy2().
  88    */
  89   virtual void OnDestroy2();
  90
  91   /**
  92    * @copydoc NodeAttachment::ConnectedToSceneGraph()
  93    */
  94   virtual void ConnectedToSceneGraph();
  95
  96   /**
  97    * @copydoc NodeAttachment::DisconnectedFromSceneGraph()
  98    */
  99   virtual void DisconnectedFromSceneGraph();
 100
 101   /**
 102    * Set the material for the renderer
 103    * @param[in] bufferIndex The current frame's buffer index
 104    * @param[in] material The material this renderer will use
 105    */
 106   void SetMaterial( BufferIndex bufferIndex, Material* material);
 107
 108   /**
 109    * Get the material of this renderer
 110    * @return the material this renderer uses
 111    */
 112   Material& GetMaterial();
 113
 114   /**
 115    * Set the geometry for the renderer
 116    * @param[in] bufferIndex The current frame's buffer index
 117    * @param[in] geometry The geometry this renderer will use
 118    */
 119   void SetGeometry( BufferIndex bufferIndex, Geometry* geometry);
 120
 121   /**
 122    * Get the geometry of this renderer
 123    * @return the geometry this renderer uses
 124    */
 125   Geometry& GetGeometry();
 126
 127   /**
 128    * Set the depth index
 129    * @param[in] bufferIndex The buffer index
 130    * @param[in] depthIndex the new depth index to use
 131    */
 132   void SetDepthIndex( BufferIndex bufferIndex, int depthIndex );
 133
 134   /**
 135    * Get the depth index.
 136    * Inlined, as called from sort algorithm
 137    * @return The depth index of the renderer attachment in the current frame
 138    */
 139   int GetDepthIndex( BufferIndex bufferIndex ) const
 140   {
 141     return mDepthIndex[bufferIndex];
 142   }
 143
 144
 145 protected: // From NodeAttachment
 146   /**
 147    * @copydoc NodeAttachment::ResetToBaseValues
 148    */
 149   virtual void ResetToBaseValues( BufferIndex updateBufferIndex );
 150
 151 protected: // From RenderableAttachment
 152   /**
 153    * @copydoc RenderableAttachment::GetRenderer().
 154    */
 155   virtual Renderer& GetRenderer();
 156
 157   /**
 158    * @copydoc RenderableAttachment::GetRenderer().
 159    */
 160   virtual const Renderer& GetRenderer() const;
 161
 162   /**
 163    * @copydoc RenderableAttachment::DoPrepareResources()
 164    */
 165   virtual bool DoPrepareResources( BufferIndex updateBufferIndex,
 166                                    ResourceManager& resourceManager );
 167
 168   /**
 169    * @copydoc RenderableAttachment::DoPrepareRender()
 170    */
 171   virtual void DoPrepareRender( BufferIndex updateBufferIndex );
 172
 173   /**
 174    * @copydoc RenderableAttachment::IsFullyOpaque()
 175    */
 176   virtual bool IsFullyOpaque( BufferIndex updateBufferIndex );
 177
 178   /**
 179    * @copydoc RenderableAttachment::SizeChanged()
 180    */
 181   virtual void SizeChanged( BufferIndex updateBufferIndex );
 182
 183 protected: // From ConnectionObserver
 184   /**
 185    * @copydoc ConnectionObservers::Observer::ConnectionsChanged
 186    */
 187   virtual void ConnectionsChanged(PropertyOwner& object);
 188
 189   /**
 190    * @copydoc ConnectionObservers::Observer::ConnectedUniformMapChanged
 191    */
 192   virtual void ConnectedUniformMapChanged();
 193
 194 protected: // From UniformMap::Observer
 195   /**
 196    * @copydoc UniformMap::Observer::UniformMappingsChanged
 197    */
 198   virtual void UniformMappingsChanged( const UniformMap& mappings );
 199
 200 protected: // From UniformMapDataProvider
 201   /**
 202    * @copydoc UniformMapDataProvider::GetUniformMapChanged
 203    */
 204   virtual bool GetUniformMapChanged( BufferIndex bufferIndex ) const;
 205
 206   /**
 207    * @copydoc UniformMapDataProvider::GetUniformMap
 208    */
 209   virtual const CollectedUniformMap& GetUniformMap( BufferIndex bufferIndex ) const;
 210
 211 private:
 212   /**
 213    * Add any new mappings from map into the current map.
 214    * This doesn't override any existing mappings.
 215    * @param[in] localMap The map of collected uniforms.
 216    * @param[in] map The map to import into the local map
 217    */
 218   void AddMappings( CollectedUniformMap& localMap, const UniformMap& map );
 219
 220   /**
 221    * Create a new render data provider
 222    * @return the new (initialized) data provider
 223    */
 224   RenderDataProvider* NewRenderDataProvider();
 225
 226 private:
 227   NewRenderer* mRenderer; ///< Raw pointer to the new renderer (that's owned by RenderManager)
 228
 229   Material* mMaterial; ///< The material this renderer uses. (Not owned)
 230   Geometry* mGeometry; ///< The geometry this renderer uses. (Not owned)
 231
 232   CollectedUniformMap mCollectedUniformMap[2];
 233   int mRegenerateUniformMap;  ///< 2 if the map should be regenerated, 1 if it should be copied.
 234   bool mUniformMapChanged[2]; ///< Records if the uniform map has been altered this frame
 235   bool mResendDataProviders;  ///< True if the data providers should be resent to the renderer
 236
 237 public: // Properties
 238
 239   AnimatableProperty<int> mDepthIndex; ///< Used only in PrepareRenderInstructions
 240 };
 241
 242 // Messages for RendererAttachment
 243
 244 inline void SetMaterialMessage( EventThreadServices& eventThreadServices, const RendererAttachment& attachment, const Material& material )
 245 {
 246   typedef MessageDoubleBuffered1< RendererAttachment, Material* > LocalType;
 247
 248   // Reserve some memory inside the message queue
 249   unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
 250
 251   // Construct message in the message queue memory; note that delete should not be called on the return value
 252   new (slot) LocalType( &attachment, &RendererAttachment::SetMaterial, const_cast<Material*>(&material) );
 253 }
 254
 255 inline void SetGeometryMessage( EventThreadServices& eventThreadServices, const RendererAttachment& attachment, const Geometry& geometry )
 256 {
 257   typedef MessageDoubleBuffered1< RendererAttachment, Geometry* > LocalType;
 258
 259   // Reserve some memory inside the message queue
 260   unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
 261
 262   // Construct message in the message queue memory; note that delete should not be called on the return value
 263   new (slot) LocalType( &attachment, &RendererAttachment::SetGeometry, const_cast<Geometry*>(&geometry) );
 264 }
 265
 266 inline void SetDepthIndexMessage( EventThreadServices& eventThreadServices, const RendererAttachment& attachment, int depthIndex )
 267 {
 268   typedef MessageDoubleBuffered1< RendererAttachment, int > LocalType;
 269
 270   // Reserve some memory inside the message queue
 271   unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
 272
 273   // Construct message in the message queue memory; note that delete should not be called on the return value
 274   new (slot) LocalType( &attachment, &RendererAttachment::SetDepthIndex, depthIndex );
 275 }
 276
 277 } // namespace SceneGraph
 278 } // namespace Internal
 279 } // namespace Dali
 280
 281
 282 #endif //  DALI_INTERNAL_SCENE_GRAPH_RENDERER_ATTACHMENT_H