dali/internal/update/rendering/scene-graph-geometry.h

   1 #ifndef DALI_INTERNAL_SCENE_GRAPH_GEOMETRY_H
   2 #define DALI_INTERNAL_SCENE_GRAPH_GEOMETRY_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/devel-api/rendering/geometry.h>
  21 #include <dali/internal/event/common/event-thread-services.h>
  22 #include <dali/internal/update/common/animatable-property.h>
  23 #include <dali/internal/update/common/double-buffered.h>
  24 #include <dali/internal/update/common/property-owner.h>
  25 #include <dali/internal/update/common/uniform-map.h>
  26 #include <dali/internal/update/common/scene-graph-connection-change-propagator.h>
  27 #include <dali/internal/render/data-providers/render-data-provider.h>
  28
  29 namespace Dali
  30 {
  31 namespace Internal
  32 {
  33 namespace Render
  34 {
  35 class PropertyBuffer;
  36 }
  37 namespace SceneGraph
  38 {
  39 class SceneController;
  40 class RenderGeometry;
  41
  42 /**
  43  * This scene graph object is a property owner. It describes a geometry using a
  44  * number of PropertyBuffers acting as Vertex buffers.
  45  */
  46 class Geometry : public PropertyOwner, public UniformMap::Observer
  47 {
  48 public:
  49
  50   typedef Dali::Geometry::GeometryType GeometryType;
  51   /**
  52    * Constructor
  53    */
  54   Geometry();
  55
  56   /**
  57    * Destructor
  58    */
  59   virtual ~Geometry();
  60
  61   /**
  62    * Add a property buffer to be used as a vertex buffer
  63    */
  64   void AddVertexBuffer( Render::PropertyBuffer* vertexBuffer );
  65
  66   /**
  67    * Remove a property buffer to be used as a vertex buffer
  68    * @param[in] vertexBuffer the associated vertex buffer to remove
  69    */
  70   void RemoveVertexBuffer( Render::PropertyBuffer* vertexBuffer );
  71
  72   /**
  73    * Set the buffer to be used as a source of indices for the geometry
  74    * @param[in] indexBuffer the Property buffer describing the indexes for Line, Triangle tyes.
  75    */
  76   void SetIndexBuffer( Render::PropertyBuffer* indexBuffer );
  77
  78   /**
  79    * Clear the index buffer if it is no longer required, e.g. if changing geometry type
  80    * to POINTS.
  81    */
  82   void ClearIndexBuffer();
  83
  84   /**
  85    * Set the type of geometry to draw (Points, Lines, Triangles, etc)
  86    * @param[in] bufferIndex Index for double buffered values
  87    * @param[in] geometryType The geometry type
  88    */
  89   void SetGeometryType( GeometryType geometryType );
  90
  91   /**
  92    * Set if the geometry requires depth testing
  93    * @param[in] requiresDepthTest True if depth testing is required, false otherwise
  94    */
  95   void SetRequiresDepthTest( bool requiresDepthTest );
  96
  97   /**
  98    * Connect the object to the scene graph
  99    *
 100    * @param[in] sceneController The scene controller - used for sending messages to render thread
 101    * @param[in] bufferIndex The current buffer index - used for sending messages to render thread
 102    */
 103   void ConnectToSceneGraph( SceneController& sceneController, BufferIndex bufferIndex );
 104
 105   /**
 106    * Disconnect the object from the scene graph
 107    * @param[in] sceneController The scene controller - used for sending messages to render thread
 108    * @param[in] bufferIndex The current buffer index - used for sending messages to render thread
 109    */
 110   void DisconnectFromSceneGraph( SceneController& sceneController, BufferIndex bufferIndex );
 111
 112   /**
 113    * @copydoc ConnectionObservers::AddObserver
 114    */
 115   void AddConnectionObserver(ConnectionChangePropagator::Observer& observer);
 116
 117   /**
 118    * @copydoc ConnectionObservers::RemoveObserver
 119    */
 120   void RemoveConnectionObserver(ConnectionChangePropagator::Observer& observer);
 121
 122 public: // UniformMap::Observer
 123   /**
 124    * @copydoc UniformMap::Observer::UniformMappingsChanged
 125    */
 126   virtual void UniformMappingsChanged( const UniformMap& mappings );
 127
 128   /**
 129    * Get the vertex buffers of the geometry
 130    * @return A const reference to the vertex buffers
 131    */
 132   Vector<Render::PropertyBuffer*>& GetVertexBuffers();
 133
 134   /**
 135    * Get the index buffer of the geometry
 136    * @return A pointer to the index buffer if it exists, or NULL if it doesn't.
 137    */
 138    Render::PropertyBuffer* GetIndexBuffer();
 139
 140    /**
 141     * Gets the associated RenderGeometry
 142     * @param[in] sceneController The scene controller
 143     * @return The RenderGeometry associated to this Geometry
 144     */
 145    RenderGeometry* GetRenderGeometry(SceneController* sceneController);
 146
 147    /**
 148     * Called from renderers using this geometry when they get disconnected from the scenegraph
 149     */
 150    void OnRendererDisconnect();
 151
 152
 153 public: // GeometryDataProvider
 154   /**
 155    * Get the type of geometry to draw
 156    * @param[in] bufferIndex Index for double buffered values
 157    */
 158   virtual GeometryType GetGeometryType( BufferIndex bufferIndex ) const;
 159
 160   /**
 161    * Returns true if this geometry requires depth testing, e.g. if it is
 162    * a set of vertices with z != 0
 163    * @param[in] bufferIndex Index for double buffered values
 164    */
 165   virtual bool GetRequiresDepthTesting( BufferIndex bufferIndex ) const;
 166
 167 private:
 168
 169   RenderGeometry*  mRenderGeometry;
 170   SceneController* mSceneController;
 171
 172   Render::PropertyBuffer*         mIndexBuffer;   ///< The index buffer if required
 173   Vector<Render::PropertyBuffer*> mVertexBuffers; ///< The vertex buffers
 174
 175   ConnectionChangePropagator mConnectionObservers;
 176
 177   Geometry::GeometryType  mGeometryType;
 178   unsigned int            mRendererRefCount;
 179   bool                    mRequiresDepthTest;
 180 };
 181
 182 inline void AddVertexBufferMessage( EventThreadServices& eventThreadServices , const Geometry& geometry, const Render::PropertyBuffer& vertexBuffer )
 183 {
 184   typedef MessageValue1< Geometry, Render::PropertyBuffer* > LocalType;
 185
 186   // Reserve some memory inside the message queue
 187   unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
 188
 189   // Construct message in the message queue memory; note that delete should not be called on the return value
 190   new (slot) LocalType( &geometry, &Geometry::AddVertexBuffer, const_cast<Render::PropertyBuffer*>(&vertexBuffer) );
 191 }
 192
 193 inline void RemoveVertexBufferMessage( EventThreadServices& eventThreadServices, const Geometry& geometry, const Render::PropertyBuffer& vertexBuffer )
 194 {
 195   typedef MessageValue1< Geometry, Render::PropertyBuffer* > LocalType;
 196
 197   // Reserve some memory inside the message queue
 198   unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
 199
 200   // Construct message in the message queue memory; note that delete should not be called on the return value
 201   new (slot) LocalType( &geometry, &Geometry::RemoveVertexBuffer, const_cast<Render::PropertyBuffer*>(&vertexBuffer) );
 202 }
 203
 204 inline void SetIndexBufferMessage( EventThreadServices& eventThreadServices, const Geometry& geometry, const Render::PropertyBuffer& indexBuffer )
 205 {
 206   typedef MessageValue1< Geometry, Render::PropertyBuffer* > LocalType;
 207
 208   // Reserve some memory inside the message queue
 209   unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
 210
 211   // Construct message in the message queue memory; note that delete should not be called on the return value
 212   new (slot) LocalType( &geometry, &Geometry::SetIndexBuffer, const_cast<Render::PropertyBuffer*>(&indexBuffer) );
 213 }
 214
 215 inline void ClearIndexBufferMessage( EventThreadServices& eventThreadServices, const Geometry& geometry )
 216 {
 217   typedef Message< Geometry > LocalType;
 218
 219   // Reserve some memory inside the message queue
 220   unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
 221
 222   // Construct message in the message queue memory; note that delete should not be called on the return value
 223   new (slot) LocalType( &geometry, &Geometry::ClearIndexBuffer );
 224 }
 225
 226 } // namespace SceneGraph
 227
 228 // Declare enum as a message parameter type
 229 template <> struct ParameterType< SceneGraph::Geometry::GeometryType > : public BasicType< SceneGraph::Geometry::GeometryType > {};
 230
 231 namespace SceneGraph
 232 {
 233
 234 inline void SetGeometryTypeMessage( EventThreadServices& eventThreadServices, const Geometry& geometry, SceneGraph::Geometry::GeometryType geometryType )
 235 {
 236   typedef MessageValue1< Geometry, SceneGraph::Geometry::GeometryType > LocalType;
 237
 238   // Reserve some memory inside the message queue
 239   unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
 240
 241   // Construct message in the message queue memory; note that delete should not be called on the return value
 242   new (slot) LocalType( &geometry, &Geometry::SetGeometryType, geometryType );
 243 }
 244
 245 inline void SetGeometryRequiresDepthTestMessage( EventThreadServices& eventThreadServices, const Geometry& geometry, bool requiresDepthTest )
 246 {
 247   typedef MessageValue1< Geometry, bool > LocalType;
 248
 249   // Reserve some memory inside the message queue
 250   unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
 251
 252   // Construct message in the message queue memory; note that delete should not be called on the return value
 253   new (slot) LocalType( &geometry, &Geometry::SetRequiresDepthTest, requiresDepthTest );
 254 }
 255
 256 } // namespace SceneGraph
 257 } // namespace Internal
 258 } // namespace Dali
 259
 260 #endif // DALI_INTERNAL_SCENE_GRAPH_GEOMETRY_H