Equalizer  1.10.1
Parallel Rendering Framework
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
channel.h
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_CHANNEL_H
21 #define EQ_CHANNEL_H
22 
23 #include <eq/api.h>
24 #include <eq/types.h>
25 
26 #include <eq/fabric/channel.h> // base class
27 
28 namespace eq
29 {
30 namespace detail { class Channel; struct RBStat; }
31 
43 class Channel : public fabric::Channel< Window, Channel >
44 {
45 public:
47  EQ_API explicit Channel( Window* parent );
48 
50  EQ_API virtual ~Channel();
51 
54  EQ_API co::CommandQueue* getPipeThreadQueue();
55  EQ_API co::CommandQueue* getCommandThreadQueue();
56  EQ_API uint32_t getCurrentFrame() const;
57 
59  bool waitFrameFinished( uint32_t frame, uint32_t timeout ) const;
60 
65  EQ_API bool isStopped() const;
66 
68  EQ_API Pipe* getPipe();
69 
71  EQ_API const Pipe* getPipe() const;
72 
74  EQ_API Node* getNode();
75 
77  EQ_API const Node* getNode() const;
78 
80  EQ_API Config* getConfig();
81 
83  EQ_API const Config* getConfig() const;
84 
86  EQ_API ServerPtr getServer();
87 
101  EQ_API const GLEWContext* glewGetContext() const;
102 
105 
107  EQ_API const DrawableConfig& getDrawableConfig() const;
108 
119  EQ_API View* getNativeView();
120 
122  EQ_API const View* getNativeView() const;
123 
125  EQ_API const Vector3ub& getUniqueColor() const;
126 
128  EQ_API void addStatistic( Event& event );
130 
145  EQ_API virtual Vector2f getJitter() const;
146 
159  EQ_API View* getView();
160 
162  EQ_API const View* getView() const;
163 
173  EQ_API Frustumf getScreenFrustum() const;
175 
189  EQ_API virtual void applyBuffer();
190 
196  EQ_API virtual void applyColorMask() const;
197 
203  EQ_API virtual void applyViewport() const;
204 
217  EQ_API virtual void applyFrustum() const;
218 
223  EQ_API virtual void applyPerspective() const;
224 
229  EQ_API virtual void applyOrtho() const;
230 
238  EQ_API void applyScreenFrustum() const;
239 
245  EQ_API virtual void applyHeadTransform() const;
246 
251  EQ_API virtual void applyPerspectiveTransform() const;
252 
257  EQ_API virtual void applyOrthoTransform() const;
258 
263  EQ_API void bindFrameBuffer();
264 
269  EQ_API void bindDrawFrameBuffer();
271 
281  EQ_API virtual void resetRegions();
282 
297  EQ_API virtual void declareRegion( const eq::PixelViewport& region );
298 
305  EQ_API void declareRegion( const eq::Viewport& vp );
306 
308  EQ_API PixelViewport getRegion() const;
309 
321  EQ_API const PixelViewports& getRegions() const;
323 
332  EQ_API EventOCommand sendError( const uint32_t error );
333 
345  EQ_API virtual bool processEvent( const Event& event );
347 
349  EQ_API virtual void drawStatistics();
350 
352  EQ_API virtual void outlineViewport();
353 
360  void changeLatency( const uint32_t latency );
361 
372  EQ_API void addResultImageListener( ResultImageListener* listener );
373 
381  EQ_API void removeResultImageListener( ResultImageListener* listener );
382 
388  EQ_API virtual std::string getDumpImageFileName() const;
389 
390 protected:
392  EQ_API void attach( const uint128_t& id, const uint32_t instanceID );
393 
402  EQ_API void startFrame( const uint32_t frameNumber );
403 
410  EQ_API void releaseFrame( const uint32_t frameNumber );
411 
418  EQ_API void releaseFrameLocal( const uint32_t frameNumber );
419 
430  EQ_API virtual void setupAssemblyState();
431 
433  EQ_API virtual void resetAssemblyState();
435 
451  EQ_API virtual bool configInit( const uint128_t& initID );
452 
454  EQ_API virtual bool configExit();
455 
467  EQ_API virtual void frameStart( const uint128_t& frameID,
468  const uint32_t frameNumber );
469 
480  EQ_API virtual void frameFinish( const uint128_t& frameID,
481  const uint32_t frameNumber );
482 
493  EQ_API virtual void frameDrawFinish( const uint128_t& frameID,
494  const uint32_t frameNumber );
495 
504  EQ_API virtual void frameClear( const uint128_t& frameID );
505 
514  EQ_API virtual void frameDraw( const uint128_t& frameID );
515 
525  EQ_API virtual void frameAssemble( const uint128_t& frameID,
526  const Frames& frames );
527 
538  EQ_API virtual void frameReadback( const uint128_t& frameID,
539  const Frames& frames );
540 
552  EQ_API virtual void frameViewStart( const uint128_t& frameID );
553 
569  EQ_API virtual void frameViewFinish( const uint128_t& frameID );
571 
573  virtual void frameTilesStart( const uint128_t& /*frameID*/ ) {}
574 
576  virtual void frameTilesFinish( const uint128_t& /*frameID*/ ) {}
577 
579  EQ_API virtual void notifyViewportChanged();
580 
593  EQ_API virtual void notifyStopFrame( const uint32_t lastFrameNumber );
594 
595 private:
596  detail::Channel* const _impl;
597  friend class fabric::Window< Pipe, Window, Channel, WindowSettings >;
598 
599  //-------------------- Methods --------------------
601  void _overrideContext( RenderContext& context );
602 
604  void _initDrawableConfig();
605 
607  void _frameTiles( RenderContext& context, const bool isLocal,
608  const uint128_t& queueID, const uint32_t tasks,
609  const co::ObjectVersions& frames );
610 
612  void _refFrame( const uint32_t frameNumber );
613 
615  void _unrefFrame( const uint32_t frameNumber );
616 
618  void _transmitImage( const co::ObjectVersion& frameDataVersion,
619  const uint128_t& nodeID,
620  const co::NodeID& netNodeID,
621  const uint64_t imageIndex,
622  const uint32_t frameNumber,
623  const uint32_t taskID );
624 
625  void _frameReadback( const uint128_t& frameID,
626  const co::ObjectVersions& frames );
627  void _finishReadback( const co::ObjectVersion& frameDataVersion,
628  const uint64_t imageIndex,
629  const uint32_t frameNumber,
630  const uint32_t taskID,
631  const std::vector< uint128_t >& nodes,
632  const co::NodeIDs& netNodes );
633 
634  bool _asyncFinishReadback( const std::vector< size_t >& imagePos,
635  const Frames& frames );
636 
637  void _asyncTransmit( FrameDataPtr frame, const uint32_t frameNumber,
638  const uint64_t image,
639  const std::vector< uint128_t >& nodes,
640  const co::NodeIDs& netNodes,
641  const uint32_t taskID );
642 
643  void _setReady( const bool async, detail::RBStat* stat,
644  const Frames& frames );
645  void _asyncSetReady( const FrameDataPtr frame, detail::RBStat* stat,
646  const std::vector< uint128_t >& nodes,
647  const co::NodeIDs& netNodes );
648 
649  void _setReady( FrameDataPtr frame, detail::RBStat* stat,
650  const std::vector< uint128_t >& nodes,
651  const co::NodeIDs& netNodes );
652 
654  co::QueueSlave* _getQueue( const uint128_t& queueID );
655 
656  Frames _getFrames( const co::ObjectVersions& frameIDs,
657  const bool isOutput );
658 
659  void _createTransferWindow();
660  void _deleteTransferWindow();
661 
662  /* The command handler functions. */
663  bool _cmdConfigInit( co::ICommand& command );
664  bool _cmdConfigExit( co::ICommand& command );
665  bool _cmdFrameStart( co::ICommand& command );
666  bool _cmdFrameFinish( co::ICommand& command );
667  bool _cmdFrameClear( co::ICommand& command );
668  bool _cmdFrameDraw( co::ICommand& command );
669  bool _cmdFrameDrawFinish( co::ICommand& command );
670  bool _cmdFrameAssemble( co::ICommand& command );
671  bool _cmdFrameReadback( co::ICommand& command );
672  bool _cmdFinishReadback( co::ICommand& command );
673  bool _cmdFrameSetReady( co::ICommand& command );
674  bool _cmdFrameTransmitImage( co::ICommand& command );
675  bool _cmdFrameSetReadyNode( co::ICommand& command );
676  bool _cmdFrameViewStart( co::ICommand& command );
677  bool _cmdFrameViewFinish( co::ICommand& command );
678  bool _cmdStopFrame( co::ICommand& command );
679  bool _cmdFrameTiles( co::ICommand& command );
680  bool _cmdCreateTransferWindow( co::ICommand& command );
681  bool _cmdDeleteTransferWindow( co::ICommand& command );
682 
683  LB_TS_VAR( _pipeThread );
684 };
685 }
686 
687 #endif // EQ_CHANNEL_H
virtual EQ_API void frameFinish(const uint128_t &frameID, const uint32_t frameNumber)
Finish rendering a frame.
virtual EQ_API Vector2f getJitter() const
virtual EQ_API void applyColorMask() const
Apply the current color mask.
EQ_API EventOCommand sendError(const uint32_t error)
Send a channel error event to the application node.
virtual EQ_API void frameReadback(const uint128_t &frameID, const Frames &frames)
Read back the rendered frame buffer into the output frames.
virtual EQ_API void outlineViewport()
Outline the current pixel viewport.
A channel represents a two-dimensional viewport within a Window.
Definition: channel.h:43
A configuration is a visualization session driven by an application.
Definition: config.h:55
virtual EQ_API void frameStart(const uint128_t &frameID, const uint32_t frameNumber)
Start rendering a frame.
virtual EQ_API void applyOrthoTransform() const
Apply the transformation to position the orthographic view frustum.
EQ_API void applyScreenFrustum() const
Apply an orthographic frustum for pixel-based 2D operations.
virtual EQ_API bool configInit(const uint128_t &initID)
Initialize this channel.
virtual EQ_API void frameDrawFinish(const uint128_t &frameID, const uint32_t frameNumber)
Finish drawing.
virtual EQ_API void frameDraw(const uint128_t &frameID)
Draw the scene.
virtual void frameTilesStart(const uint128_t &)
Start a batch of tile rendering operations.
Definition: channel.h:573
A Pipe represents a graphics card (GPU) on a Node.
Definition: pipe.h:50
EQ_API ServerPtr getServer()
A Node represents a single computer in the cluster.
Definition: node.h:48
virtual EQ_API std::string getDumpImageFileName() const
EQ_API void bindFrameBuffer()
Rebind the window frame buffer.
A set of settings to setup an eq::SystemWindow.
virtual EQ_API void applyOrtho() const
Apply the orthographic frustum matrix for the current rendering task.
std::vector< PixelViewport > PixelViewports
A vector of eq::PixelViewport.
Definition: eq/types.h:172
virtual EQ_API void applyViewport() const
Apply the OpenGL viewport for the current rendering task.
virtual EQ_API void applyFrustum() const
Apply the frustum matrix for the current rendering task.
EQ_API void releaseFrameLocal(const uint32_t frameNumber)
Release the local synchronization of the parent for a frame.
EQ_API Frustumf getScreenFrustum() const
Returns an orthographic frustum for 2D operations on the view.
EQ_API void startFrame(const uint32_t frameNumber)
Start a frame by unlocking all child resources.
lunchbox::RefPtr< Server > ServerPtr
A reference-counted pointer to an eq::Server.
Definition: eq/types.h:210
EQ_API void bindDrawFrameBuffer()
Rebind the window draw buffer.
EQ_API util::ObjectManager & getObjectManager()
A Window represents an on-screen or off-screen drawable.
Definition: window.h:64
EQ_API Config * getConfig()
EQ_API const GLEWContext * glewGetContext() const
Get the GLEW context for this channel.
virtual EQ_API void frameViewStart(const uint128_t &frameID)
Start updating a destination channel.
EQ_API Channel(Window *parent)
Construct a new channel.
virtual EQ_API void notifyStopFrame(const uint32_t lastFrameNumber)
Notify interruption of the rendering.
virtual EQ_API void applyPerspectiveTransform() const
Apply the transformation to position the perspective view frustum.
The result image listener gets notified on new images produced by destination channels.
EQ_API Node * getNode()
EQ_API const Vector3ub & getUniqueColor() const
virtual EQ_API void applyHeadTransform() const
Apply the transformation to position the view frustum.
EQ_API View * getNativeView()
Get the channel's native view.
virtual EQ_API void frameClear(const uint128_t &frameID)
Clear the frame buffer.
virtual EQ_API void drawStatistics()
Draw a statistics overlay.
EQ_API Pipe * getPipe()
EQ_API const DrawableConfig & getDrawableConfig() const
virtual EQ_API bool configExit()
Exit this channel.
std::vector< Frame * > Frames
A vector of pointers to eq::Frame.
Definition: eq/types.h:158
EQ_API void addResultImageListener(ResultImageListener *listener)
Add a listener that gets notified everytime a new frame was rendered for a destination channel...
A View is a 2D area of a Layout.
Definition: view.h:42
virtual EQ_API void notifyViewportChanged()
Notification that parameters influencing the vp/pvp have changed.
virtual EQ_API void resetRegions()
Reset the declared regions of interest.
Base data transport class for windows.
EQ_API View * getView()
Get the channel's current View.
virtual EQ_API bool processEvent(const Event &event)
Process a received event.
virtual void frameTilesFinish(const uint128_t &)
Finish a batch of tile rendering operations.
Definition: channel.h:576
EQ_API bool isStopped() const
virtual EQ_API void frameViewFinish(const uint128_t &frameID)
Finish updating a destination channel.
EQ_API void removeResultImageListener(ResultImageListener *listener)
Remove a result image listener to stop receival of notifications on new images.
A facility class to manage OpenGL objects across shared contexts.
Definition: objectManager.h:52
Base data transport class for channels.
virtual EQ_API void setupAssemblyState()
Setup the OpenGL state for a readback or assemble operation.
virtual EQ_API void applyPerspective() const
Apply the perspective frustum matrix for the current rendering task.
virtual EQ_API void applyBuffer()
Apply the current rendering buffer, including the color mask.
EQ_API PixelViewport getRegion() const
lunchbox::RefPtr< FrameData > FrameDataPtr
A reference-counted pointer to an eq::FrameData.
Definition: eq/types.h:212
virtual EQ_API void frameAssemble(const uint128_t &frameID, const Frames &frames)
Assemble all input frames.
virtual EQ_API void resetAssemblyState()
Reset the OpenGL state after an assembly operation.
EQ_API const PixelViewports & getRegions() const
Get the current regions of interest.
virtual EQ_API ~Channel()
Destruct the channel.
EQ_API void releaseFrame(const uint32_t frameNumber)
Signal the completion of a frame to the parent.
virtual EQ_API void declareRegion(const eq::PixelViewport &region)
Declare a region covered by the current draw or assemble operation.