Line data Source code
1 :
2 : /* Copyright (c) 2008-2013, Stefan Eilemann <eile@equalizergraphics.com>
3 : * 2011-2012, Daniel Nachbaur <danielnachbaur@gmail.com>
4 : * 2010, Cedric Stalder <cedric.stalder@gmail.com>
5 : *
6 : * This library is free software; you can redistribute it and/or modify it under
7 : * the terms of the GNU Lesser General Public License version 2.1 as published
8 : * by the Free Software Foundation.
9 : *
10 : * This library is distributed in the hope that it will be useful, but WITHOUT
11 : * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
12 : * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
13 : * details.
14 : *
15 : * You should have received a copy of the GNU Lesser General Public License
16 : * along with this library; if not, write to the Free Software Foundation, Inc.,
17 : * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 : */
19 :
20 : #include "view.h"
21 :
22 : #include "equalizerTypes.h"
23 : #include "leafVisitor.h"
24 : #include "log.h"
25 : #include "paths.h"
26 :
27 : #include <co/dataIStream.h>
28 : #include <co/dataOStream.h>
29 :
30 : namespace eq
31 : {
32 : namespace fabric
33 : {
34 : template< class L, class V, class O >
35 478 : View< L, V, O >::View( L* layout )
36 : : _layout( layout )
37 : , _observer( 0 )
38 : , _overdraw( Vector2i::ZERO )
39 : , _minimumCapabilities( LB_BIT_NONE )
40 : , _maximumCapabilities( LB_BIT_ALL_64 )
41 : , _capabilities( LB_BIT_ALL_64 )
42 : , _equalizers( EQUALIZER_ALL )
43 478 : , _modelUnit( EQ_M )
44 : {
45 : // Note: Views are an exception to the strong structuring, since render
46 : // client views are multi-buffered (once per pipe) and do not have a parent
47 478 : if( layout )
48 477 : layout->_addChild( static_cast< V* >( this ));
49 478 : LBLOG( LOG_INIT ) << "New " << lunchbox::className( this ) << std::endl;
50 478 : }
51 :
52 : template< class L, class V, class O >
53 477 : View< L, V, O >::~View()
54 : {
55 477 : LBLOG( LOG_INIT ) << "Delete " << lunchbox::className( this ) << std::endl;
56 477 : if( _layout )
57 476 : _layout->_removeChild( static_cast< V* >( this ));
58 954 : }
59 :
60 : template< class L, class V, class O >
61 956 : View< L, V, O >::BackupData::BackupData()
62 956 : : mode( MODE_MONO )
63 956 : {}
64 :
65 : template< class L, class V, class O >
66 227 : void View< L, V, O >::serialize( co::DataOStream& os, const uint64_t dirtyBits )
67 : {
68 227 : Object::serialize( os, dirtyBits );
69 227 : if( dirtyBits & DIRTY_OBSERVER )
70 197 : os << co::ObjectVersion( _observer );
71 227 : if( dirtyBits & DIRTY_FRUSTUM )
72 142 : Frustum::serialize( os );
73 227 : if( dirtyBits & DIRTY_VIEWPORT )
74 142 : os << _data.viewport;
75 227 : if( dirtyBits & DIRTY_OVERDRAW )
76 142 : os << _overdraw;
77 227 : if( dirtyBits & DIRTY_EQUALIZER )
78 163 : os << _equalizer;
79 227 : if( dirtyBits & DIRTY_MINCAPS )
80 142 : os << _minimumCapabilities;
81 227 : if( dirtyBits & DIRTY_MAXCAPS )
82 142 : os << _maximumCapabilities;
83 227 : if( dirtyBits & DIRTY_CAPABILITIES )
84 142 : os << _capabilities;
85 227 : if( dirtyBits & DIRTY_MODE )
86 142 : os << _data.mode;
87 227 : if( dirtyBits & DIRTY_EQUALIZERS )
88 142 : os << _equalizers;
89 227 : if( dirtyBits & DIRTY_MODELUNIT )
90 142 : os << _modelUnit;
91 227 : if( dirtyBits & DIRTY_DISPLAYCLUSTER )
92 142 : os << _displayCluster;
93 227 : }
94 :
95 : template< class L, class V, class O >
96 149 : void View< L, V, O >::deserialize( co::DataIStream& is,
97 : const uint64_t dirtyBits )
98 : {
99 149 : Object::deserialize( is, dirtyBits );
100 149 : if( dirtyBits & DIRTY_OBSERVER )
101 : {
102 119 : co::ObjectVersion observer;
103 119 : is >> observer;
104 :
105 119 : if( observer.identifier == 0 )
106 : {
107 0 : if( _observer )
108 0 : _observer->removeView( static_cast< V* >( this ));
109 0 : _observer = 0;
110 : }
111 : else
112 : {
113 119 : if( !_observer && _layout ) // don't map render client observers yet
114 : {
115 63 : L* layout = getLayout();
116 63 : LBASSERT( layout && layout->getConfig( ));
117 63 : layout->getConfig()->find( observer.identifier, &_observer );
118 63 : if( _observer )
119 63 : _observer->addView( static_cast< V* >( this ));
120 63 : LBASSERT( _observer );
121 63 : LBASSERT( _observer->getID() == observer.identifier );
122 : }
123 119 : if( _observer )
124 : {
125 118 : LBASSERT( _observer->getID() == observer.identifier );
126 118 : if( _observer->isMaster( ))
127 0 : _observer->sync();
128 : else
129 118 : _observer->sync( observer.version );
130 : }
131 : }
132 : }
133 149 : if( dirtyBits & DIRTY_FRUSTUM )
134 64 : Frustum::deserialize( is );
135 149 : if( dirtyBits & DIRTY_VIEWPORT )
136 64 : is >> _data.viewport;
137 149 : if( dirtyBits & DIRTY_OVERDRAW )
138 64 : is >> _overdraw;
139 149 : if( dirtyBits & DIRTY_EQUALIZER )
140 85 : is >> _equalizer;
141 149 : if( dirtyBits & ( DIRTY_MINCAPS | DIRTY_MAXCAPS ) )
142 : {
143 64 : if( dirtyBits & DIRTY_MINCAPS )
144 64 : is >> _minimumCapabilities;
145 64 : if( dirtyBits & DIRTY_MAXCAPS )
146 64 : is >> _maximumCapabilities;
147 64 : updateCapabilities();
148 : }
149 149 : if( dirtyBits & DIRTY_CAPABILITIES )
150 64 : is >> _capabilities;
151 149 : if( dirtyBits & DIRTY_MODE )
152 : {
153 : uint32_t mode;
154 64 : is >> mode;
155 64 : activateMode( Mode( mode ));
156 : }
157 149 : if( dirtyBits & DIRTY_EQUALIZERS )
158 64 : is >> _equalizers;
159 149 : if( dirtyBits & DIRTY_MODELUNIT )
160 64 : is >> _modelUnit;
161 149 : if( dirtyBits & DIRTY_DISPLAYCLUSTER )
162 64 : is >> _displayCluster;
163 149 : }
164 :
165 : template< class L, class V, class O >
166 135 : void View< L, V, O >::setDirty( const uint64_t dirtyBits )
167 : {
168 135 : Object::setDirty( dirtyBits );
169 135 : if( _layout )
170 135 : _layout->setDirty( L::DIRTY_VIEWS );
171 135 : }
172 :
173 : template< class L, class V, class O >
174 88 : void View< L, V, O >::changeMode( const Mode mode )
175 : {
176 88 : if ( _data.mode == mode )
177 132 : return;
178 :
179 44 : _data.mode = mode;
180 44 : setDirty( DIRTY_MODE );
181 : }
182 :
183 : template< class L, class V, class O >
184 7 : bool View< L, V, O >::isActive() const
185 : {
186 7 : const L* layout = getLayout();
187 7 : if( !layout )
188 0 : return true; // render client view, active by definition.
189 7 : return layout->isActive();
190 : }
191 :
192 : template< class L, class V, class O >
193 55 : bool View< L, V, O >::setModelUnit( const float modelUnit )
194 : {
195 55 : if( modelUnit < std::numeric_limits< float >::epsilon() ||
196 : _modelUnit == modelUnit )
197 : {
198 55 : return false;
199 : }
200 0 : _modelUnit = modelUnit;
201 0 : setDirty( DIRTY_MODELUNIT );
202 0 : return true;
203 : }
204 :
205 : template< class L, class V, class O >
206 394 : float View< L, V, O >::getModelUnit() const
207 : {
208 394 : LBASSERT( _modelUnit > 0.f );
209 394 : return _modelUnit;
210 : }
211 :
212 : template< class L, class V, class O >
213 0 : void View< L, V, O >::setDisplayCluster( const std::string& hostname )
214 : {
215 0 : _displayCluster = hostname;
216 0 : setDirty( DIRTY_DISPLAYCLUSTER );
217 0 : }
218 :
219 : template< class L, class V, class O >
220 0 : const std::string& View< L, V, O >::getDisplayCluster() const
221 : {
222 0 : return _displayCluster;
223 : }
224 :
225 : template< class L, class V, class O >
226 116 : void View< L, V, O >::setViewport( const Viewport& viewport )
227 : {
228 116 : _data.viewport = viewport;
229 116 : setDirty( DIRTY_VIEWPORT );
230 116 : }
231 :
232 63 : template< class L, class V, class O > void View< L, V, O >::backup()
233 : {
234 63 : _backup = _data;
235 63 : Frustum::backup();
236 63 : Object::backup();
237 63 : }
238 :
239 2 : template< class L, class V, class O > void View< L, V, O >::restore()
240 : {
241 2 : Object::restore();
242 2 : Frustum::restore();
243 2 : _data = _backup;
244 2 : _overdraw = Vector2i::ZERO;
245 2 : _minimumCapabilities = LB_BIT_NONE;
246 2 : _maximumCapabilities = LB_BIT_ALL_64;
247 2 : _capabilities = LB_BIT_ALL_64;
248 2 : _equalizers = EQUALIZER_ALL;
249 2 : _modelUnit = EQ_M;
250 :
251 2 : setDirty( DIRTY_VIEW_BITS );
252 2 : }
253 :
254 : template< class L, class V, class O >
255 402 : void View< L, V, O >::setObserver( O* observer )
256 : {
257 402 : if( _observer == observer )
258 402 : return;
259 :
260 402 : if( _observer )
261 0 : _observer->removeView( static_cast< V* >( this ));
262 402 : _observer = observer;
263 402 : if( _observer )
264 402 : _observer->addView( static_cast< V* >( this ));
265 402 : setDirty( DIRTY_OBSERVER );
266 : }
267 :
268 : template< class L, class V, class O >
269 1896 : const Viewport& View< L, V, O >::getViewport() const
270 : {
271 1896 : return _data.viewport;
272 : }
273 :
274 : template< class L, class V, class O >
275 0 : void View< L, V, O >::setOverdraw( const Vector2i& pixels )
276 : {
277 0 : if( _overdraw == pixels )
278 0 : return;
279 :
280 0 : _overdraw = pixels;
281 0 : setDirty( DIRTY_OVERDRAW );
282 : }
283 :
284 : template< class L, class V, class O >
285 0 : void View< L, V, O >::useEqualizer( uint32_t bitmask )
286 : {
287 0 : if( _equalizers == bitmask )
288 0 : return;
289 0 : _equalizers = bitmask;
290 0 : setDirty( DIRTY_EQUALIZERS );
291 : }
292 :
293 : template< class L, class V, class O >
294 0 : const Equalizer& View< L, V, O >::getEqualizer() const
295 : {
296 0 : return _equalizer;
297 : }
298 :
299 : template< class L, class V, class O >
300 42 : Equalizer& View< L, V, O >::getEqualizer()
301 : {
302 42 : setDirty( DIRTY_EQUALIZER );
303 42 : return _equalizer;
304 : }
305 :
306 : template< class L, class V, class O >
307 14840 : VisitorResult View< L, V, O >::accept( LeafVisitor< V >& visitor )
308 : {
309 14840 : return visitor.visit( static_cast< V* >( this ));
310 : }
311 :
312 : template< class L, class V, class O >
313 0 : VisitorResult View< L, V, O >::accept( LeafVisitor< V >& visitor ) const
314 : {
315 0 : return visitor.visit( static_cast< const V* >( this ));
316 : }
317 :
318 : template< class L, class V, class O >
319 7 : uint32_t View< L, V, O >::getUserDataLatency() const
320 : {
321 7 : return static_cast< const V* >( this )->getConfig()->getLatency();
322 : }
323 :
324 : template< class L, class V, class O >
325 0 : void View< L, V, O >::setMinimumCapabilities( uint64_t bitmask )
326 : {
327 0 : if( bitmask == _minimumCapabilities )
328 0 : return;
329 :
330 0 : _minimumCapabilities = bitmask;
331 0 : setDirty( DIRTY_MINCAPS );
332 : }
333 :
334 : template< class L, class V, class O >
335 1248 : uint64_t View< L, V, O >::getMinimumCapabilities() const
336 : {
337 1248 : return _minimumCapabilities;
338 : }
339 :
340 : template< class L, class V, class O >
341 0 : void View< L, V, O >::setMaximumCapabilities( uint64_t bitmask )
342 : {
343 0 : if( bitmask == _maximumCapabilities )
344 0 : return;
345 :
346 0 : _maximumCapabilities = bitmask;
347 0 : setDirty( DIRTY_MAXCAPS );
348 : }
349 :
350 : template< class L, class V, class O >
351 0 : uint64_t View< L, V, O >::getMaximumCapabilities() const
352 : {
353 0 : return _maximumCapabilities;
354 : }
355 :
356 : template< class L, class V, class O >
357 0 : void View< L, V, O >::setCapabilities( uint64_t bitmask )
358 : {
359 0 : if( bitmask == _capabilities )
360 0 : return;
361 :
362 0 : _capabilities = bitmask;
363 0 : setDirty( DIRTY_CAPABILITIES );
364 : }
365 :
366 : template< class L, class V, class O >
367 0 : uint64_t View< L, V, O >::getCapabilities() const
368 : {
369 0 : return _capabilities;
370 : }
371 :
372 : template< class L, class V, class O >
373 299 : std::ostream& operator << ( std::ostream& os, const View< L, V, O >& view )
374 : {
375 598 : os << lunchbox::disableFlush << lunchbox::disableHeader
376 299 : << "view" << std::endl;
377 299 : os << "{" << std::endl << lunchbox::indent;
378 :
379 299 : const std::string& name = view.getName();
380 299 : if( !name.empty( ))
381 0 : os << "name \"" << name << "\"" << std::endl;
382 :
383 299 : const Viewport& vp = view.getViewport();
384 299 : if( vp.isValid( ) && vp != Viewport::FULL )
385 58 : os << "viewport " << vp << std::endl;
386 :
387 299 : if( view.getMode() == View< L, V, O >::MODE_STEREO )
388 22 : os << "mode STEREO" << std::endl; // MONO is default
389 :
390 299 : const O* observer = static_cast< const O* >( view.getObserver( ));
391 299 : if( observer )
392 : {
393 293 : const std::string& observerName = observer->getName();
394 293 : const L* layout = view.getLayout();
395 293 : const O* foundObserver = 0;
396 293 : layout->getConfig()->find( observerName, &foundObserver );
397 :
398 293 : if( layout && foundObserver == observer )
399 : {
400 293 : os << "observer \"" << observerName << "\"" << std::endl;
401 : }
402 : else
403 0 : os << observer->getPath() << std::endl;
404 : }
405 :
406 299 : return os << static_cast< const Frustum& >( view )
407 299 : << lunchbox::exdent << "}" << std::endl << lunchbox::enableHeader
408 299 : << lunchbox::enableFlush;
409 : }
410 :
411 : }
412 : }
|
