Equalizer  1.10.1
Parallel Rendering Framework
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
window.h
Go to the documentation of this file.
1 
2 /* Copyright (c) 2005-2015, Stefan Eilemann <eile@equalizergraphics.com>
3  * Cedric Stalder <cedric.stalder@gmail.com>
4  * Daniel Nachbaur <danielnachbaur@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 EQ_WINDOW_H
21 #define EQ_WINDOW_H
22 
23 #include <eq/types.h>
24 #include <eq/notifierInterface.h> // base class
25 #include <eq/windowSettings.h> // template param
26 #include <eq/visitorResult.h> // enum
27 
28 #include <eq/fabric/renderContext.h> // member
29 #include <eq/fabric/window.h> // base class
30 #include <eq/util/bitmapFont.h> // member
31 #include <eq/util/objectManager.h> // member
32 
33 
36 namespace eq
37 {
64 class Window : public fabric::Window< Pipe, Window, Channel, WindowSettings >,
65  public NotifierInterface
66 {
67 public:
69  EQ_API explicit Window( Pipe* parent );
70 
72  EQ_API virtual ~Window();
73 
76  EQ_API co::CommandQueue* getPipeThreadQueue();
77  EQ_API co::CommandQueue* getCommandThreadQueue();
78  EQ_API uint32_t getCurrentFrame() const;
79 
81  EQ_API const Node* getNode() const;
82 
84  EQ_API Node* getNode();
85 
87  EQ_API const Config* getConfig() const;
88 
90  EQ_API Config* getConfig();
91 
93  EQ_API ClientPtr getClient();
94 
96  EQ_API ServerPtr getServer();
97 
102  bool isRunning() const { return (_state == STATE_RUNNING); }
103 
108  bool isStopped() const { return (_state == STATE_STOPPED); }
109 
119  EQ_API bool getRenderContext( const int32_t x, const int32_t y,
120  RenderContext& context ) const;
122 
136  EQ_API void setSharedContextWindow( const Window* sharedContextWindow );
137 
142  EQ_API const Window* getSharedContextWindow() const;
143 
145  util::ObjectManager& getObjectManager() { return _objectManager; }
146 
149  { return _objectManager; }
150 
155  EQ_API const util::BitmapFont* getSmallFont();
156 
161  EQ_API const util::BitmapFont* getMediumFont();
162 
177  EQ_API const GLEWContext* glewGetContext() const;
178 
186  EQ_API const GLEWContext* getTransferGlewContext();
187 
193  EQ_API uint32_t getColorFormat() const;
195 
205  EQ_API virtual void flush() const;
206 
214  EQ_API virtual void finish() const;
215 
217  EQ_API virtual void swapBuffers();
218 
220  EQ_API virtual void drawFPS();
221 
223  float getFPS() const { return _avgFPS; }
224 
234  EQ_API virtual void makeCurrent( const bool cache = true ) const;
235 
240  EQ_API virtual void doneCurrent() const;
241 
243  EQ_API virtual void bindFrameBuffer() const;
244 
246  EQ_API virtual void bindDrawFrameBuffer() const;
247 
249  EQ_API virtual void updateFrameBuffer() const;
250 
252  EQ_API virtual void notifyViewportChanged();
254 
266  EQ_API void setSystemWindow( SystemWindow* window );
267 
269  const SystemWindow* getSystemWindow() const { return _systemWindow; }
270 
272  SystemWindow* getSystemWindow() { return _systemWindow; }
273 
275  const SystemPipe* getSystemPipe() const;
276 
279 
281  bool createTransferWindow();
282 
284  void deleteTransferWindow();
285 
287  SystemWindow* getTransferWindow();
289 
298  EQ_API EventOCommand sendError( const uint32_t error ) final;
299 
313  EQ_API virtual bool processEvent( const Event& event );
315 
316 protected:
317  friend class Pipe;
318 
320  EQ_API virtual void attach( const uint128_t& id, const uint32_t instanceID );
321 
330  EQ_API void startFrame( const uint32_t frameNumber );
331 
338  EQ_API void releaseFrame( const uint32_t frameNumber );
339 
346  EQ_API void releaseFrameLocal( const uint32_t frameNumber );
348 
362  EQ_API virtual bool configInit( const uint128_t& initID );
363 
370  EQ_API virtual bool configInitSystemWindow( const uint128_t& initID );
371 
380  EQ_API virtual bool configInitGL( const uint128_t& initID );
381 
383  EQ_API virtual bool configExit();
384 
386  EQ_API virtual bool configExitSystemWindow();
387 
389  virtual bool configExitGL() { return true; }
390 
401  EQ_API virtual void frameStart( const uint128_t& frameID,
402  const uint32_t frameNumber );
403 
417  EQ_API virtual void frameFinish( const uint128_t& frameID,
418  const uint32_t frameNumber );
419 
430  EQ_API virtual void frameDrawFinish( const uint128_t& frameID,
431  const uint32_t frameNumber );
433 
434 private:
435  enum State
436  {
437  STATE_STOPPED,
438  STATE_INITIALIZING,
439  STATE_RUNNING,
440  STATE_FAILED
441  };
442 
444  const Window* _sharedContextWindow;
445 
447  SystemWindow* _transferWindow;
448 
450  SystemWindow* _systemWindow;
451 
453  State _state;
454 
456  util::ObjectManager _objectManager;
457 
459  float _lastTime;
460 
462  float _avgFPS;
463 
465  std::vector< RenderContext > _renderContexts[2];
466  enum
467  {
468  FRONT = 0,
469  BACK = 1
470  };
471 
473  int64_t _lastSwapTime;
474 
476  Channels _grabbedChannels;
477 
478  struct Private;
479  Private* _private; // placeholder for binary-compatible changes
480 
482  void _addRenderContext( const RenderContext& context );
483  friend class Channel;
484 
486  Channels _getEventChannels( const PointerEvent& event );
487 
489  void _setupObjectManager();
491  void _releaseObjectManager();
492 
494  void _updateFPS();
495 
497  void _enterBarrier( co::ObjectVersion barrier );
498 
499  void _updateEvent( Event& event );
500 
501  /* The command functions. */
502  bool _cmdCreateChannel( co::ICommand& command );
503  bool _cmdDestroyChannel(co::ICommand& command );
504  bool _cmdConfigInit( co::ICommand& command );
505  bool _cmdConfigExit( co::ICommand& command );
506  bool _cmdFrameStart( co::ICommand& command );
507  bool _cmdFrameFinish( co::ICommand& command );
508  bool _cmdThrottleFramerate( co::ICommand& command );
509  bool _cmdFlush( co::ICommand& command );
510  bool _cmdFinish( co::ICommand& command );
511  bool _cmdBarrier( co::ICommand& command );
512  bool _cmdNVBarrier( co::ICommand& command );
513  bool _cmdSwap( co::ICommand& command );
514  bool _cmdFrameDrawFinish( co::ICommand& command );
515 
516  LB_TS_VAR( _pipeThread )
517 };
518 }
519 
520 #endif // EQ_WINDOW_H
virtual EQ_API bool configInitSystemWindow(const uint128_t &initID)
Initialize the OS-specific window.
const util::ObjectManager & getObjectManager() const
Definition: window.h:148
EQ_API const Config * getConfig() const
A configuration is a visualization session driven by an application.
Definition: config.h:55
virtual EQ_API ~Window()
Destruct the window.
std::vector< C * > Channels
A vector of pointers to channels.
Definition: fabric/window.h:41
A Pipe represents a graphics card (GPU) on a Node.
Definition: pipe.h:50
EQ_API ClientPtr getClient()
EQ_API EventOCommand sendError(const uint32_t error) final
Send a window error event to the application node.
A wrapper around AGL, WGL and GLX bitmap fonts.
Definition: bitmapFont.h:31
EQ_API void setSystemWindow(SystemWindow *window)
Set the OS-specific window.
A Node represents a single computer in the cluster.
Definition: node.h:48
EQ_API Window(Pipe *parent)
Construct a new window.
virtual EQ_API void frameDrawFinish(const uint128_t &frameID, const uint32_t frameNumber)
Finish drawing.
const SystemPipe * getSystemPipe() const
lunchbox::RefPtr< Server > ServerPtr
A reference-counted pointer to an eq::Server.
Definition: eq/types.h:210
virtual EQ_API void frameStart(const uint128_t &frameID, const uint32_t frameNumber)
Start rendering a frame.
virtual EQ_API void flush() const
Flush outstanding rendering requests.
EQ_API void setSharedContextWindow(const Window *sharedContextWindow)
Set the window with which this window shares the OpenGL context.
A Window represents an on-screen or off-screen drawable.
Definition: window.h:64
The interface definition for system-specific GPU handling.
Definition: systemPipe.h:38
virtual EQ_API bool processEvent(const Event &event)
Process a received event.
EQ_API const Node * getNode() const
A base class for notifying errors and events.
EQ_API void releaseFrame(const uint32_t frameNumber)
Signal the completion of a frame to the parent.
lunchbox::RefPtr< Client > ClientPtr
A reference-counted pointer to an eq::Client.
Definition: eq/types.h:206
EQ_API void startFrame(const uint32_t frameNumber)
Start a frame by unlocking all child resources.
virtual EQ_API void makeCurrent(const bool cache=true) const
Make the window's drawable and context current.
bool isStopped() const
Definition: window.h:108
virtual EQ_API bool configExit()
Exit this window.
EQ_API ServerPtr getServer()
virtual EQ_API bool configExitSystemWindow()
De-initialize the OS-specific window.
virtual EQ_API void drawFPS()
Render the current framerate as on overlay.
SystemWindow * getSystemWindow()
Definition: window.h:272
virtual EQ_API void finish() const
Finish outstanding rendering requests.
The interface definition for system-specific windowing code.
Definition: systemWindow.h:35
virtual bool configExitGL()
De-initialize the OpenGL state for this window.
Definition: window.h:389
Base data transport class for windows.
EQ_API bool getRenderContext(const int32_t x, const int32_t y, RenderContext &context) const
Get the last rendering context at the x, y position.
A facility class to manage OpenGL objects across shared contexts.
Definition: objectManager.h:52
virtual EQ_API void frameFinish(const uint128_t &frameID, const uint32_t frameNumber)
Finish rendering a frame.
virtual EQ_API void swapBuffers()
Swap the front and back buffer of the window.
EQ_API const GLEWContext * glewGetContext() const
Get the GLEW context for this window.
EQ_API const util::BitmapFont * getMediumFont()
EQ_API const util::BitmapFont * getSmallFont()
virtual EQ_API bool configInitGL(const uint128_t &initID)
Initialize the OpenGL state for this window.
virtual EQ_API bool configInit(const uint128_t &initID)
Initialize this window.
virtual EQ_API void doneCurrent() const
This results in no context being current in the current thread.
bool isRunning() const
Definition: window.h:102
float getFPS() const
Definition: window.h:223
EQ_API void releaseFrameLocal(const uint32_t frameNumber)
Signal the release of the local synchronization to the parent.
EQ_API const Window * getSharedContextWindow() const
util::ObjectManager & getObjectManager()
Definition: window.h:145
const SystemWindow * getSystemWindow() const
Definition: window.h:269