Equalizer  1.9.0
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 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  void waitFrameFinished( const uint32_t frame ) const;
58 
63  EQ_API bool isStopped() const;
64 
66  EQ_API Pipe* getPipe();
67 
69  EQ_API const Pipe* getPipe() const;
70 
72  EQ_API Node* getNode();
73 
75  EQ_API const Node* getNode() const;
76 
78  EQ_API Config* getConfig();
79 
81  EQ_API const Config* getConfig() const;
82 
84  EQ_API ServerPtr getServer();
85 
99  EQ_API const GLEWContext* glewGetContext() const;
100 
103 
105  EQ_API const DrawableConfig& getDrawableConfig() const;
106 
117  EQ_API View* getNativeView();
118 
120  EQ_API const View* getNativeView() const;
121 
123  EQ_API const Vector3ub& getUniqueColor() const;
124 
126  EQ_API void addStatistic( Event& event );
128 
143  EQ_API virtual Vector2f getJitter() const;
144 
157  EQ_API View* getView();
158 
160  EQ_API const View* getView() const;
161 
171  EQ_API Frustumf getScreenFrustum() const;
173 
187  EQ_API virtual void applyBuffer();
188 
194  EQ_API virtual void applyColorMask() const;
195 
201  EQ_API virtual void applyViewport() const;
202 
215  EQ_API virtual void applyFrustum() const;
216 
221  EQ_API virtual void applyPerspective() const;
222 
227  EQ_API virtual void applyOrtho() const;
228 
236  EQ_API void applyScreenFrustum() const;
237 
243  EQ_API virtual void applyHeadTransform() const;
244 
249  EQ_API virtual void applyPerspectiveTransform() const;
250 
255  EQ_API virtual void applyOrthoTransform() const;
256 
261  EQ_API void bindFrameBuffer();
262 
267  EQ_API void bindDrawFrameBuffer();
269 
279  EQ_API virtual void resetRegions();
280 
295  EQ_API virtual void declareRegion( const eq::PixelViewport& region );
296 
303  EQ_API void declareRegion( const eq::Viewport& vp );
304 
306  EQ_API PixelViewport getRegion() const;
307 
319  EQ_API const PixelViewports& getRegions() const;
321 
330  EQ_API EventOCommand sendError( const uint32_t error );
331 
343  EQ_API virtual bool processEvent( const Event& event );
345 
347  EQ_API virtual void drawStatistics();
348 
350  EQ_API virtual void outlineViewport();
351 
358  void changeLatency( const uint32_t latency );
359 
370  EQ_API void addResultImageListener( ResultImageListener* listener );
371 
379  EQ_API void removeResultImageListener( ResultImageListener* listener );
380 
386  EQ_API virtual std::string getDumpImageFileName() const;
387 
388 protected:
390  EQ_API void attach( const uint128_t& id, const uint32_t instanceID );
391 
400  EQ_API void startFrame( const uint32_t frameNumber );
401 
408  EQ_API void releaseFrame( const uint32_t frameNumber );
409 
416  EQ_API void releaseFrameLocal( const uint32_t frameNumber );
417 
428  EQ_API virtual void setupAssemblyState();
429 
431  EQ_API virtual void resetAssemblyState();
433 
449  EQ_API virtual bool configInit( const uint128_t& initID );
450 
452  EQ_API virtual bool configExit();
453 
465  EQ_API virtual void frameStart( const uint128_t& frameID,
466  const uint32_t frameNumber );
467 
478  EQ_API virtual void frameFinish( const uint128_t& frameID,
479  const uint32_t frameNumber );
480 
491  EQ_API virtual void frameDrawFinish( const uint128_t& frameID,
492  const uint32_t frameNumber );
493 
502  EQ_API virtual void frameClear( const uint128_t& frameID );
503 
512  EQ_API virtual void frameDraw( const uint128_t& frameID );
513 
523  EQ_API virtual void frameAssemble( const uint128_t& frameID,
524  const Frames& frames );
525 
536  EQ_API virtual void frameReadback( const uint128_t& frameID,
537  const Frames& frames );
538 
550  EQ_API virtual void frameViewStart( const uint128_t& frameID );
551 
567  EQ_API virtual void frameViewFinish( const uint128_t& frameID );
569 
571  virtual void frameTilesStart( const uint128_t& /*frameID*/ ) {}
572 
574  virtual void frameTilesFinish( const uint128_t& /*frameID*/ ) {}
575 
577  EQ_API virtual void notifyViewportChanged();
578 
591  EQ_API virtual void notifyStopFrame( const uint32_t lastFrameNumber );
592 
593 private:
594  detail::Channel* const _impl;
595  friend class fabric::Window< Pipe, Window, Channel, WindowSettings >;
596 
597  //-------------------- Methods --------------------
599  void _overrideContext( RenderContext& context );
600 
602  void _initDrawableConfig();
603 
605  void _frameTiles( RenderContext& context, const bool isLocal,
606  const uint128_t& queueID, const uint32_t tasks,
607  const co::ObjectVersions& frames );
608 
610  void _refFrame( const uint32_t frameNumber );
611 
613  void _unrefFrame( const uint32_t frameNumber );
614 
616  void _transmitImage( const co::ObjectVersion& frameDataVersion,
617  const uint128_t& nodeID,
618  const co::NodeID& netNodeID,
619  const uint64_t imageIndex,
620  const uint32_t frameNumber,
621  const uint32_t taskID );
622 
623  void _frameReadback( const uint128_t& frameID,
624  const co::ObjectVersions& frames );
625  void _finishReadback( const co::ObjectVersion& frameDataVersion,
626  const uint64_t imageIndex,
627  const uint32_t frameNumber,
628  const uint32_t taskID,
629  const std::vector< uint128_t >& nodes,
630  const co::NodeIDs& netNodes );
631 
632  bool _asyncFinishReadback( const std::vector< size_t >& imagePos,
633  const Frames& frames );
634 
635  void _asyncTransmit( FrameDataPtr frame, const uint32_t frameNumber,
636  const uint64_t image,
637  const std::vector< uint128_t >& nodes,
638  const co::NodeIDs& netNodes,
639  const uint32_t taskID );
640 
641  void _setReady( const bool async, detail::RBStat* stat,
642  const Frames& frames );
643  void _asyncSetReady( const FrameDataPtr frame, detail::RBStat* stat,
644  const std::vector< uint128_t >& nodes,
645  const co::NodeIDs& netNodes );
646 
647  void _setReady( FrameDataPtr frame, detail::RBStat* stat,
648  const std::vector< uint128_t >& nodes,
649  const co::NodeIDs& netNodes );
650 
652  co::QueueSlave* _getQueue( const uint128_t& queueID );
653 
654  Frames _getFrames( const co::ObjectVersions& frameIDs,
655  const bool isOutput );
656 
657  void _deleteTransferContext();
658 
659  /* The command handler functions. */
660  bool _cmdConfigInit( co::ICommand& command );
661  bool _cmdConfigExit( co::ICommand& command );
662  bool _cmdFrameStart( co::ICommand& command );
663  bool _cmdFrameFinish( co::ICommand& command );
664  bool _cmdFrameClear( co::ICommand& command );
665  bool _cmdFrameDraw( co::ICommand& command );
666  bool _cmdFrameDrawFinish( co::ICommand& command );
667  bool _cmdFrameAssemble( co::ICommand& command );
668  bool _cmdFrameReadback( co::ICommand& command );
669  bool _cmdFinishReadback( co::ICommand& command );
670  bool _cmdFrameSetReady( co::ICommand& command );
671  bool _cmdFrameTransmitImage( co::ICommand& command );
672  bool _cmdFrameSetReadyNode( co::ICommand& command );
673  bool _cmdFrameViewStart( co::ICommand& command );
674  bool _cmdFrameViewFinish( co::ICommand& command );
675  bool _cmdStopFrame( co::ICommand& command );
676  bool _cmdFrameTiles( co::ICommand& command );
677  bool _cmdDeleteTransferContext( co::ICommand& command );
678 
679  LB_TS_VAR( _pipeThread );
680 };
681 }
682 
683 #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.
Defines export visibility macros for Equalizer.
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:571
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: 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: 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: 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:43
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.
Definition: fabric/types.h:86
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:574
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: 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.