Equalizer  1.8.0
Parallel Rendering Framework
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Pages
include/eq/client/window.h
Go to the documentation of this file.
1 
2 /* Copyright (c) 2005-2013, Stefan Eilemann <eile@equalizergraphics.com>
3  * 2010, Cedric Stalder <cedric.stalder@gmail.com>
4  * 2010-2014, 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/client/types.h>
24 #include <eq/client/notifierInterface.h> // base class
25 #include <eq/client/windowSettings.h> // template param
26 #include <eq/client/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 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 
239  void makeCurrentTransfer( const bool cache = true ) const;
240 
242  EQ_API virtual void bindFrameBuffer() const;
243 
245  EQ_API virtual void notifyViewportChanged();
247 
259  EQ_API void setSystemWindow( SystemWindow* window );
260 
262  const SystemWindow* getSystemWindow() const { return _systemWindow; }
263 
265  SystemWindow* getSystemWindow() { return _systemWindow; }
266 
268  const SystemPipe* getSystemPipe() const;
269 
272 
274  bool createTransferWindow();
275 
277  void deleteTransferSystemWindow();
279 
288  EQ_API EventOCommand sendError( const uint32_t error ) final;
289 
301  EQ_API virtual bool processEvent( const Event& event );
303 
304 protected:
305  friend class Pipe;
306 
308  EQ_API virtual void attach( const uint128_t& id, const uint32_t instanceID );
309 
318  EQ_API void startFrame( const uint32_t frameNumber );
319 
326  EQ_API void releaseFrame( const uint32_t frameNumber );
327 
334  EQ_API void releaseFrameLocal( const uint32_t frameNumber );
336 
350  EQ_API virtual bool configInit( const uint128_t& initID );
351 
358  EQ_API virtual bool configInitSystemWindow( const uint128_t& initID );
359 
368  EQ_API virtual bool configInitGL( const uint128_t& initID );
369 
371  EQ_API virtual bool configExit();
372 
374  EQ_API virtual bool configExitSystemWindow();
375 
377  virtual bool configExitGL() { return true; }
378 
389  EQ_API virtual void frameStart( const uint128_t& frameID,
390  const uint32_t frameNumber );
391 
405  EQ_API virtual void frameFinish( const uint128_t& frameID,
406  const uint32_t frameNumber );
407 
418  EQ_API virtual void frameDrawFinish( const uint128_t& frameID,
419  const uint32_t frameNumber );
421 
422 private:
423  enum State
424  {
425  STATE_STOPPED,
426  STATE_INITIALIZING,
427  STATE_RUNNING,
428  STATE_FAILED
429  };
430 
432  const Window* _sharedContextWindow;
433 
435  SystemWindow* _transferWindow;
436 
438  SystemWindow* _systemWindow;
439 
441  State _state;
442 
444  util::ObjectManager _objectManager;
445 
447  float _lastTime;
448 
450  float _avgFPS;
451 
453  std::vector< RenderContext > _renderContexts[2];
454  enum
455  {
456  FRONT = 0,
457  BACK = 1
458  };
459 
461  int64_t _lastSwapTime;
462 
464  Channels _grabbedChannels;
465 
466  struct Private;
467  Private* _private; // placeholder for binary-compatible changes
468 
470  void _addRenderContext( const RenderContext& context );
471  friend class Channel;
472 
474  Channels _getEventChannels( const PointerEvent& event );
475 
477  void _setupObjectManager();
479  void _releaseObjectManager();
480 
482  void _updateFPS();
483 
485  void _enterBarrier( co::ObjectVersion barrier );
486 
487  void _updateEvent( Event& event );
488 
489  /* The command functions. */
490  bool _cmdCreateChannel( co::ICommand& command );
491  bool _cmdDestroyChannel(co::ICommand& command );
492  bool _cmdConfigInit( co::ICommand& command );
493  bool _cmdConfigExit( co::ICommand& command );
494  bool _cmdFrameStart( co::ICommand& command );
495  bool _cmdFrameFinish( co::ICommand& command );
496  bool _cmdThrottleFramerate( co::ICommand& command );
497  bool _cmdFlush( co::ICommand& command );
498  bool _cmdFinish( co::ICommand& command );
499  bool _cmdBarrier( co::ICommand& command );
500  bool _cmdNVBarrier( co::ICommand& command );
501  bool _cmdSwap( co::ICommand& command );
502  bool _cmdFrameDrawFinish( co::ICommand& command );
503 
504  LB_TS_VAR( _pipeThread )
505 };
506 }
507 
508 #endif // EQ_WINDOW_H
virtual EQ_API bool configInitSystemWindow(const uint128_t &initID)
Initialize the OS-specific window.
const util::ObjectManager & getObjectManager() const
EQ_API const Config * getConfig() const
A configuration is a visualization session driven by an application.
virtual EQ_API ~Window()
Destruct the window.
std::vector< C * > Channels
A vector of pointers to channels.
A Pipe represents a graphics card (GPU) on a Node.
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.
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.
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.
The interface definition for system-specific GPU handling.
Definition: systemPipe.h:37
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.
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
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()
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.
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:51
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.
bool isRunning() const
float getFPS() const
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()
const SystemWindow * getSystemWindow() const