channel.h

/* Copyright (c) 2005-2016, Stefan Eilemann <eile@equalizergraphics.com>
 *                          Cedric Stalder <cedric.stalder@gmail.com>
 *                          Daniel Nachbaur <danielnachbaur@gmail.com>
 *
 * This library is free software; you can redistribute it and/or modify it under
 * the terms of the GNU Lesser General Public License version 2.1 as published
 * by the Free Software Foundation.
 *
 * This library is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
 * details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#ifndef EQ_CHANNEL_H
#define EQ_CHANNEL_H

#include <eq/api.h>
#include <eq/fabric/channel.h> // base class
#include <eq/types.h>

namespace eq
{
namespace detail
{
class Channel;
struct RBStat;
}

class Channel : public fabric::Channel<Window, Channel>
{
public:
    EQ_API explicit Channel(Window* parent);

    EQ_API virtual ~Channel();

    EQ_API co::CommandQueue* getPipeThreadQueue();    
    EQ_API co::CommandQueue* getCommandThreadQueue(); 
    EQ_API uint32_t getCurrentFrame() const; 

    bool waitFrameFinished(uint32_t frame, uint32_t timeout) const;

    EQ_API bool isStopped() const;

    EQ_API Pipe* getPipe();

    EQ_API const Pipe* getPipe() const;

    EQ_API Node* getNode();

    EQ_API const Node* getNode() const;

    EQ_API Config* getConfig();

    EQ_API const Config* getConfig() const;

    EQ_API ServerPtr getServer();

    EQ_API const GLEWContext* glewGetContext() const;

    EQ_API util::ObjectManager& getObjectManager();

    EQ_API const DrawableConfig& getDrawableConfig() const;

    EQ_API View* getNativeView();

    EQ_API const View* getNativeView() const;

    EQ_API const Vector3ub& getUniqueColor() const;

    EQ_API void addStatistic(Statistic& event);

    EQ_API virtual Vector2f getJitter() const;

    EQ_API View* getView();

    EQ_API const View* getView() const;

    EQ_API Frustumf getScreenFrustum() const;

    EQ_API virtual void applyBuffer();

    EQ_API virtual void applyColorMask() const;

    EQ_API virtual void applyViewport() const;

    EQ_API virtual void applyFrustum() const;

    EQ_API virtual void applyPerspective() const;

    EQ_API virtual void applyOrtho() const;

    EQ_API void applyScreenFrustum() const;

    EQ_API virtual void applyHeadTransform() const;

    EQ_API virtual void applyPerspectiveTransform() const;

    EQ_API virtual void applyOrthoTransform() const;

    EQ_API void applyOverlayState();

    EQ_API void resetOverlayState();

    EQ_API void bindFrameBuffer();

    EQ_API void bindDrawFrameBuffer();

    EQ_API virtual void resetRegions();

    EQ_API virtual void declareRegion(const eq::PixelViewport& region);

    EQ_API void declareRegion(const eq::Viewport& vp);

    EQ_API PixelViewport getRegion() const;

    EQ_API const PixelViewports& getRegions() const;

    EQ_API EventOCommand sendError(const uint32_t error);

    EQ_API virtual bool processEvent(EventType type, SizeEvent& event);
    EQ_API virtual bool processEvent(EventType type, PointerEvent& event);
    EQ_API virtual bool processEvent(EventType type, KeyEvent& event);
    EQ_API virtual bool processEvent(Statistic& event);

    EQ_API virtual void drawStatistics();

    EQ_API virtual void outlineViewport();

    void changeLatency(const uint32_t latency);

    EQ_API void addResultImageListener(ResultImageListener* listener);

    EQ_API void removeResultImageListener(ResultImageListener* listener);

    EQ_API virtual std::string getDumpImageFileName() const;

protected:
    EQ_API void attach(const uint128_t& id, const uint32_t instanceID);

    EQ_API void startFrame(const uint32_t frameNumber);

    EQ_API void releaseFrame(const uint32_t frameNumber);

    EQ_API void releaseFrameLocal(const uint32_t frameNumber);

    EQ_API virtual void setupAssemblyState();

    EQ_API virtual void resetAssemblyState();

    EQ_API virtual bool configInit(const uint128_t& initID);

    EQ_API virtual bool configExit();

    EQ_API virtual void frameStart(const uint128_t& frameID,
                                   const uint32_t frameNumber);

    EQ_API virtual void frameFinish(const uint128_t& frameID,
                                    const uint32_t frameNumber);

    EQ_API virtual void frameDrawFinish(const uint128_t& frameID,
                                        const uint32_t frameNumber);

    EQ_API virtual void frameClear(const uint128_t& frameID);

    EQ_API virtual void frameDraw(const uint128_t& frameID);

    EQ_API virtual void frameAssemble(const uint128_t& frameID,
                                      const Frames& frames);

    EQ_API virtual void frameReadback(const uint128_t& frameID,
                                      const Frames& frames);

    EQ_API virtual void frameViewStart(const uint128_t& frameID);

    EQ_API virtual void frameViewFinish(const uint128_t& frameID);

    EQ_API virtual void frameDrawOverlay(const uint128_t& frameID);

    virtual void frameTilesStart(const uint128_t& /*frameID*/) {}
    virtual void frameTilesFinish(const uint128_t& /*frameID*/) {}
    EQ_API virtual void notifyViewportChanged();

    EQ_API virtual void notifyStopFrame(const uint32_t lastFrameNumber);

private:
    detail::Channel* const _impl;
    friend class fabric::Window<Pipe, Window, Channel, WindowSettings>;

    //-------------------- Methods --------------------
    void _overrideContext(RenderContext& context);

    void _initDrawableConfig();

    void _frameTiles(RenderContext& context, const bool isLocal,
                     const uint128_t& queueID, const uint32_t tasks,
                     const co::ObjectVersions& frames);

    void _refFrame(const uint32_t frameNumber);

    void _unrefFrame(const uint32_t frameNumber);

    void _transmitImage(const co::ObjectVersion& frameDataVersion,
                        const uint128_t& nodeID, const co::NodeID& netNodeID,
                        const uint64_t imageIndex, const uint32_t frameNumber,
                        const uint32_t taskID);

    void _frameReadback(const uint128_t& frameID,
                        const co::ObjectVersions& frames);
    void _finishReadback(const co::ObjectVersion& frameDataVersion,
                         const uint64_t imageIndex, const uint32_t frameNumber,
                         const uint32_t taskID,
                         const std::vector<uint128_t>& nodes,
                         const co::NodeIDs& netNodes);

    bool _asyncFinishReadback(const std::vector<size_t>& imagePos,
                              const Frames& frames);

    void _asyncTransmit(FrameDataPtr frame, const uint32_t frameNumber,
                        const uint64_t image,
                        const std::vector<uint128_t>& nodes,
                        const co::NodeIDs& netNodes, const uint32_t taskID);

    void _setReady(const bool async, detail::RBStat* stat,
                   const Frames& frames);
    void _asyncSetReady(const FrameDataPtr frame, detail::RBStat* stat,
                        const std::vector<uint128_t>& nodes,
                        const co::NodeIDs& netNodes);

    void _setReady(FrameDataPtr frame, detail::RBStat* stat,
                   const std::vector<uint128_t>& nodes,
                   const co::NodeIDs& netNodes);

    co::QueueSlave* _getQueue(const uint128_t& queueID);

    Frames _getFrames(const co::ObjectVersions& frameIDs, const bool isOutput);

    void _createTransferWindow();
    void _deleteTransferWindow();

    /* The command handler functions. */
    bool _cmdConfigInit(co::ICommand& command);
    bool _cmdConfigExit(co::ICommand& command);
    bool _cmdFrameStart(co::ICommand& command);
    bool _cmdFrameFinish(co::ICommand& command);
    bool _cmdFrameClear(co::ICommand& command);
    bool _cmdFrameDraw(co::ICommand& command);
    bool _cmdFrameDrawFinish(co::ICommand& command);
    bool _cmdFrameAssemble(co::ICommand& command);
    bool _cmdFrameReadback(co::ICommand& command);
    bool _cmdFinishReadback(co::ICommand& command);
    bool _cmdFrameSetReady(co::ICommand& command);
    bool _cmdFrameTransmitImage(co::ICommand& command);
    bool _cmdFrameSetReadyNode(co::ICommand& command);
    bool _cmdFrameViewStart(co::ICommand& command);
    bool _cmdFrameViewFinish(co::ICommand& command);
    bool _cmdStopFrame(co::ICommand& command);
    bool _cmdFrameTiles(co::ICommand& command);
    bool _cmdDeleteTransferWindow(co::ICommand& command);

    LB_TS_VAR(_pipeThread);
};
}

#endif // EQ_CHANNEL_H