Equalizer  1.6.1
include/eq/fabric/view.h
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 #ifndef EQFABRIC_VIEW_H
21 #define EQFABRIC_VIEW_H
22 
23 #include <eq/fabric/api.h>
24 #include <eq/fabric/equalizer.h> // member
25 #include <eq/fabric/frustum.h> // base class
26 #include <eq/fabric/object.h> // base class
27 #include <eq/fabric/types.h>
28 #include <eq/fabric/viewport.h> // member
29 
30 #define EQ_MM 1000.f
31 #define EQ_CM 100.f
32 #define EQ_DM 10.f
33 #define EQ_M 1.f
34 #define EQ_KM 0.001f
35 #define EQ_UNDEFINED_UNIT -1.f
36 
37 namespace eq
38 {
39 namespace fabric
40 {
42  template< class L, class V, class O >
43  class View : public Object, public Frustum
44  {
45  public:
47  enum Mode
48  {
49  MODE_MONO = 1,
51  };
52 
56  EQFABRIC_INL const Viewport& getViewport() const;
57 
62  L* getLayout() { return _layout; }
63 
68  const L* getLayout() const { return _layout; }
69 
71  EQFABRIC_INL void setObserver( O* observer );
72 
77  O* getObserver() { return _observer; }
78 
80  const O* getObserver() const { return _observer; }
81 
83  EQFABRIC_INL void setOverdraw( const Vector2i& pixels );
84 
86  const Vector2i& getOverdraw() const { return _overdraw; }
87 
89  EQFABRIC_INL void useEqualizer( uint32_t equalizerMask );
90 
92  uint32_t getEqualizers() const { return _equalizers; }
93 
95  EQFABRIC_INL const Equalizer& getEqualizer() const;
96 
98  EQFABRIC_INL Equalizer& getEqualizer();
99 
101  EQFABRIC_INL void setViewport( const Viewport& viewport );
102 
104  Mode getMode() const { return _data.mode; }
105 
112  EQFABRIC_INL virtual void changeMode( const Mode mode );
113 
120  virtual void activateMode( const Mode mode ){ _data.mode = mode; }
121 
123  EQFABRIC_INL bool isActive() const;
124 
135  EQFABRIC_INL bool setModelUnit( const float modelUnit );
136 
145  EQFABRIC_INL float getModelUnit() const;
146 
157  void setSageConfig( const std::string& config );
158 
160  const std::string& getSageConfig() const;
161 
163  void setDisplayCluster( const std::string& hostname );
164 
166  const std::string& getDisplayCluster() const;
168 
178  EQFABRIC_INL VisitorResult accept( LeafVisitor< V >& visitor );
179 
181  EQFABRIC_INL VisitorResult accept( LeafVisitor< V >& visitor ) const;
182 
183  virtual EQFABRIC_INL void backup();
184  virtual EQFABRIC_INL void restore();
185 
195  EQFABRIC_INL void setMinimumCapabilities( const uint64_t bitmask );
196 
198  EQFABRIC_INL uint64_t getMinimumCapabilities() const;
199 
217  EQFABRIC_INL void setMaximumCapabilities(const uint64_t bitmask);
218 
223  EQFABRIC_INL uint64_t getMaximumCapabilities() const;
224 
230  EQFABRIC_INL uint64_t getCapabilities() const;
232 
233  void setCapabilities( const uint64_t bitmask );
234  virtual void updateCapabilities() {}
235 
237  enum DirtyBits
238  {
239  DIRTY_VIEWPORT = Object::DIRTY_CUSTOM << 0,
240  DIRTY_OBSERVER = Object::DIRTY_CUSTOM << 1,
241  DIRTY_OVERDRAW = Object::DIRTY_CUSTOM << 2,
242  DIRTY_FRUSTUM = Object::DIRTY_CUSTOM << 3,
243  DIRTY_MODE = Object::DIRTY_CUSTOM << 4,
244  DIRTY_MINCAPS = Object::DIRTY_CUSTOM << 5,
245  DIRTY_MAXCAPS = Object::DIRTY_CUSTOM << 6,
246  DIRTY_CAPABILITIES = Object::DIRTY_CUSTOM << 7,
247  DIRTY_EQUALIZER = Object::DIRTY_CUSTOM << 8,
248  DIRTY_EQUALIZERS = Object::DIRTY_CUSTOM << 9,
249  DIRTY_MODELUNIT = Object::DIRTY_CUSTOM << 10,
250  DIRTY_SAGECONFIG = Object::DIRTY_CUSTOM << 11,
251  DIRTY_DISPLAYCLUSTER = Object::DIRTY_CUSTOM << 12,
252  DIRTY_VIEW_BITS =
253  DIRTY_VIEWPORT | DIRTY_OBSERVER | DIRTY_OVERDRAW |
254  DIRTY_FRUSTUM | DIRTY_MODE | DIRTY_MINCAPS | DIRTY_MAXCAPS |
255  DIRTY_CAPABILITIES | DIRTY_OBJECT_BITS | DIRTY_EQUALIZER |
256  DIRTY_EQUALIZERS | DIRTY_MODELUNIT | DIRTY_SAGECONFIG |
257  DIRTY_DISPLAYCLUSTER
258  };
259 
260  protected:
262  EQFABRIC_INL View( L* layout );
263 
265  EQFABRIC_INL virtual ~View();
266 
272  virtual bool hasMasterUserData() { return getLayout() != 0; }
273 
279  EQFABRIC_INL virtual uint32_t getUserDataLatency() const;
280 
282  EQFABRIC_INL virtual void serialize( co::DataOStream& os,
283  const uint64_t dirtyBits );
284 
286  EQFABRIC_INL virtual void deserialize( co::DataIStream& is,
287  const uint64_t dirtyBits );
288 
290  EQFABRIC_INL virtual void setDirty( const uint64_t bits );
291 
293  virtual uint64_t getRedistributableBits() const
294  { return DIRTY_VIEW_BITS; }
295 
297  virtual void notifyFrustumChanged() { setDirty( DIRTY_FRUSTUM ); }
298 
299  private:
301  L* const _layout;
302 
304  O* _observer;
305 
306  Equalizer _equalizer;
307 
308  Vector2i _overdraw;
309 
310  uint64_t _minimumCapabilities;
311  uint64_t _maximumCapabilities;
312  uint64_t _capabilities;
313  uint32_t _equalizers;
314  float _modelUnit;
315  std::string _sageConfig;
316  std::string _displayCluster;
317 
318  struct BackupData
319  {
320  BackupData();
321 
323  Viewport viewport;
324 
325  Mode mode;
326  }
327  _data, _backup;
328 
329  struct Private;
330  Private* _private; // placeholder for binary-compatible changes
331  };
332 
333  template< class L, class V, class O >
334  EQFABRIC_INL std::ostream& operator << ( std::ostream& os,
335  const View< L, V, O >& view );
336 }
337 }
338 #endif // EQFABRIC_VIEW_H
EQFABRIC_INL void useEqualizer(uint32_t equalizerMask)
EQFABRIC_INL VisitorResult accept(LeafVisitor< V > &visitor)
Traverse this view using a view visitor.
const Vector2i & getOverdraw() const
Render in stereo (left &amp; right eye)
virtual EQFABRIC_INL void changeMode(const Mode mode)
Set the mode of this view.
EQFABRIC_INL uint64_t getMaximumCapabilities() const
void setSageConfig(const std::string &config)
Set the SAGE configuration file for this view.
EQFABRIC_INL void setMinimumCapabilities(const uint64_t bitmask)
Set the minimum required capabilities for this view.
EQFABRIC_INL void setMaximumCapabilities(const uint64_t bitmask)
Set the maximum desired capabilities for this view.
EQFABRIC_INL bool isActive() const
EQFABRIC_INL float getModelUnit() const
Get the model unit of this view.
uint32_t getEqualizers() const
virtual EQFABRIC_INL uint32_t getUserDataLatency() const
The view user data instance uses the config latency by default.
const std::string & getDisplayCluster() const
EQFABRIC_INL void setObserver(O *observer)
Set the entity tracking this view.
EQFABRIC_INL const Equalizer & getEqualizer() const
EQFABRIC_INL void setOverdraw(const Vector2i &pixels)
const L * getLayout() const
Render in mono (cyclop eye)
EQFABRIC_INL bool setModelUnit(const float modelUnit)
Set the model unit of this view.
Base data transport class for equalizers.
Definition: equalizer.h:38
const std::string & getSageConfig() const
virtual bool hasMasterUserData()
The application view instance holds the user data master by default.
EQFABRIC_INL uint64_t getMinimumCapabilities() const
A fractional viewport with methods for manipulation.
Definition: viewport.h:36
EQFABRIC_INL const Viewport & getViewport() const
EQFABRIC_INL uint64_t getCapabilities() const
const O * getObserver() const
const version of getObserver().
void setDisplayCluster(const std::string &hostname)
Set the DisplayCluster hostname for this view.
vmml::vector< 2, int > Vector2i
A two-component integer vector.
Definition: vmmlib.h:40