Carna  Version 3.3.2
GeometryStage.h
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2010 - 2015 Leonid Kostrykin
3  *
4  * Chair of Medical Engineering (mediTEC)
5  * RWTH Aachen University
6  * Pauwelsstr. 20
7  * 52074 Aachen
8  * Germany
9  *
10  */
11 
12 #ifndef GEOMETRYSTAGE_H_6014714286
13 #define GEOMETRYSTAGE_H_6014714286
14 
16 #include <Carna/base/RenderStage.h>
17 #include <Carna/base/RenderQueue.h>
19 #include <Carna/base/math.h>
20 #include <memory>
21 #include <map>
22 
27 namespace Carna
28 {
29 
30 namespace base
31 {
32 
33 
34 
35 // ----------------------------------------------------------------------------------
36 // GeometryStage
37 // ----------------------------------------------------------------------------------
38 
58 template< typename RenderableCompare >
59 class GeometryStage : public RenderStage
60 {
61 
63 
64  Node* root;
65  std::size_t passesRendered;
66  std::map< GeometryFeature*, VideoResource* > acquiredFeatures;
67 
68 protected:
69 
74 
75 public:
76 
84  ( unsigned int geometryType
86 
87  const unsigned int geometryType;
88  const unsigned int geometryTypeMask;
89 
93  virtual ~GeometryStage();
94 
97  virtual void prepareFrame( Node& root ) override;
98 
99  virtual void renderPass( const math::Matrix4f& viewTransform, RenderTask& rt, const Viewport& vp ) override;
100 
105  std::size_t renderedPassesCount() const;
106 
111  template< typename GeometryFeatureType >
112  typename GeometryFeatureType::ManagedInterface& videoResource( GeometryFeatureType& geometryFeature ) const;
113 
116  template< typename GeometryFeatureType >
117  const typename GeometryFeatureType::ManagedInterface& videoResource( const GeometryFeatureType& geometryFeature ) const;
118 
119 protected:
120 
125  void activateGLContext() const;
126 
130  virtual void buildRenderQueues( Node& root, const math::Matrix4f& viewTransform );
131 
135  virtual void rewindRenderQueues();
136 
141  virtual void updateRenderQueues( const math::Matrix4f& viewTransform );
142 
146  virtual void render( const Renderable& renderable ) = 0;
147 
148 }; // GeometryStage
149 
150 
151 template< typename RenderableCompare >
153  : root( nullptr )
154  , passesRendered( 0 )
155  , rq( geometryType, geometryTypeMask )
156  , geometryType( geometryType )
157  , geometryTypeMask( geometryTypeMask )
158 {
159 }
160 
161 
162 template< typename RenderableCompare >
164 {
165  activateGLContext();
166  std::for_each( acquiredFeatures.begin(), acquiredFeatures.end(),
167  [&]( const std::pair< GeometryFeature*, VideoResource* >& entry )
168  {
169  if( entry.second != nullptr )
170  {
171  delete entry.second;
172  }
173  }
174  );
175 }
176 
177 
178 template< typename RenderableCompare >
180 {
181  if( isInitialized() )
182  {
183  renderer().glContext().makeCurrent();
184  }
185 }
186 
187 
188 template< typename RenderableCompare >
190 {
191  RenderStage::prepareFrame( root );
192  this->root = &root;
193  this->passesRendered = 0;
194 }
195 
196 
197 template< typename RenderableCompare >
199 {
200  return passesRendered;
201 }
202 
203 
204 template< typename RenderableCompare >
206 {
207  rq.build( root, viewTransform );
208 }
209 
210 
211 template< typename RenderableCompare >
213 {
214  rq.rewind();
215 }
216 
217 
218 template< typename RenderableCompare >
220 {
221  rq.updateModelViewTransforms( viewTransform );
222 }
223 
224 
225 template< typename RenderableCompare >
227 {
228  const bool isFirstPass = passesRendered == 0;
229 
230  /* Maintain the render queues.
231  */
232  if( isFirstPass )
233  {
234  buildRenderQueues( *root, viewTransform );
235  }
236  else
237  {
238  rewindRenderQueues();
239  if( isViewTransformFixed() )
240  {
241  updateRenderQueues( viewTransform );
242  }
243  }
244 
245  std::set< GeometryFeature* > usedFeatures;
246  while( !rq.isEmpty() )
247  {
248  const Renderable& renderable = rq.poll();
249  if( isFirstPass )
250  {
251  renderable.geometry().visitFeatures( [&]( GeometryFeature& gf, unsigned int role )
252  {
253  /* Denote that the geometry feature was used.
254  */
255  usedFeatures.insert( &gf );
256 
257  /* Check whether video resources need to be acquired.
258  */
259  if( acquiredFeatures.find( &gf ) == acquiredFeatures.end() )
260  {
261  VideoResource* const vr = gf.acquireVideoResource();
262  acquiredFeatures[ &gf ] = vr;
263  }
264  }
265  );
266  }
267  render( renderable );
268  }
269  if( isFirstPass )
270  {
271  /* Release unused video resources.
272  */
273  for( auto itr = acquiredFeatures.begin(); itr != acquiredFeatures.end(); )
274  {
275  if( usedFeatures.find( itr->first ) == usedFeatures.end() )
276  {
277  if( itr->second != nullptr )
278  {
279  delete itr->second;
280  }
281  acquiredFeatures.erase( itr++ );
282  }
283  else
284  {
285  ++itr;
286  }
287  }
288  }
289 }
290 
291 
292 template< typename RenderableCompare >
293 template< typename GeometryFeatureType >
294 typename GeometryFeatureType::ManagedInterface& GeometryStage< RenderableCompare >
295  ::videoResource( GeometryFeatureType& gf ) const
296 {
297  const auto itr = acquiredFeatures.find( &gf );
298  CARNA_ASSERT( itr != acquiredFeatures.end() );
299  return static_cast< typename GeometryFeatureType::ManagedInterface& >( *itr->second );
300 }
301 
302 
303 template< typename RenderableCompare >
304 template< typename GeometryFeatureType >
305 const typename GeometryFeatureType::ManagedInterface& GeometryStage< RenderableCompare >
306  ::videoResource( const GeometryFeatureType& gf ) const
307 {
308  return videoResource( const_cast< GeometryFeatureType& >( gf ) );
309 }
310 
311 
312 
313 } // namespace Carna :: base
314 
315 } // namespace Carna
316 
317 #endif // GEOMETRYSTAGE_H_6014714286
Defines Carna::base::math namespace and CARNA_FOR_VECTOR3UI.
virtual void rewindRenderQueues()
Rewinds the rendering queues of this stage.
const unsigned int geometryTypeMask
Renders such geometries whose type AND-linked with this equals geometryType.
Definition: GeometryStage.h:88
void activateGLContext() const
Ensures that the OpenGL context of the hosting Carna::base::FrameRenderer is the current one...
virtual void buildRenderQueues(Node &root, const math::Matrix4f &viewTransform)
Builds the rendering queues of this stage.
RenderQueue< RenderableCompare > rq
Holds the predefined rendering queue of this rendering stage.
Definition: GeometryStage.h:73
std::size_t renderedPassesCount() const
Tells the number of passes rendered so far since the beginning of the current frame.
Partially implements a rendering stage that uses at least one render queue for rendering geometry fro...
Definition: GeometryStage.h:59
Defines Carna::base::GeometryFeature.
Defines Carna::base::FrameRenderer.
Gathers renderable geometry nodes from scene graph and provides those in a particular order...
Definition: RenderQueue.h:63
Represents "components" that are aggregated by Geometry objects. Closer description is given here...
virtual ManagedInterface * acquireVideoResource()=0
Acquires the video resources from this GeometryFeature by returning new instance of a class derived f...
Represents an acquisition of the video resources from a particular GeometryFeature. This acquisition realizes the RAII idiom.
virtual void renderPass(const math::Matrix4f &viewTransform, RenderTask &rt, const Viewport &vp) override
Called once per pass.
Defines the inner node of a scene graph. Implements a spatial scene element that is allowed to have c...
Definition: Node.h:44
Invokes the rendering stages of the frame renderer successively.
Definition: RenderTask.h:40
void visitFeatures(const std::function< void(GeometryFeature &gf, unsigned int role) > &visit) const
Invokes visit once on each attached geometry feature.
virtual ~GeometryStage()
Releases acquired video resources.
Defines Carna::base::RenderQueue.
virtual void prepareFrame(Node &root) override
Called once before each frame.
Eigen::Matrix< float, 4, 4, Eigen::ColMajor > Matrix4f
Defines matrix.
Definition: math.h:193
const Geometry & geometry() const
References the geometry node.
Base abstract class of each rendering stage. Refer to the documentation of the rendering process...
Definition: RenderStage.h:42
Defines a rendering viewport. The viewport is a property of the current OpenGL context.
Definition: Viewport.h:48
GeometryFeatureType::ManagedInterface & videoResource(GeometryFeatureType &geometryFeature) const
Interfaces the geometryFeature video resources that were acquired by this rendering stage...
const unsigned int geometryType
Renders such geometries whose type AND-linked with geometryTypeMask equals this.
Definition: GeometryStage.h:87
Represents a Geometry object that has been queued into a RenderQueue. The object&#39;s model-view transfo...
Definition: Renderable.h:45
GeometryStage(unsigned int geometryType, unsigned int geometryTypeMask=RenderQueue< RenderableCompare >::EXACT_MATCH_GEOMETRY_TYPE_MASK)
Instantiates s.t. the predefined rendering queue enqueues such Carna::base::Geometry scene graph node...
virtual void updateRenderQueues(const math::Matrix4f &viewTransform)
Recomputes the model-view transforms of the renderables enqueued by this stage.
#define CARNA_ASSERT(expression)
If the given expression is false, a break point is raised in debug mode and an AssertionFailure throw...
Defines Carna::base::RenderStage.
virtual void render(const Renderable &renderable)=0
Renders the renderable.