compositor.h

/* Copyright (c) 2007-2016, Stefan Eilemann <eile@equalizergraphics.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_COMPOSITOR_H
#define EQ_COMPOSITOR_H

#include <eq/frame.h> // nested type Frame::Buffer
#include <eq/types.h> // type definitions

#include <eq/fabric/pixel.h> // member
#include <eq/fabric/zoom.h>  // member

#include <vector>

namespace eq
{
class EQ_API Compositor
{
public:
    static uint32_t assembleFrames(const Frames& frames, Channel* channel,
                                   util::Accum* accum);

    static uint32_t blendFrames(const Frames& frames, Channel* channel,
                                util::Accum* accum);
    static uint32_t blendImages(const ImageOps& images, Channel* channel,
                                util::Accum* accum);

    static uint32_t assembleFramesUnsorted(const Frames& frames,
                                           Channel* channel,
                                           util::Accum* accum);

    static uint32_t assembleFramesCPU(const Frames& frames, Channel* channel,
                                      const bool blend = false);
    static uint32_t assembleImagesCPU(const ImageOps& ops, Channel* channel,
                                      const bool blend);

    static const Image* mergeFramesCPU(
        const Frames& frames, const bool blend = false,
        const uint32_t timeout = LB_TIMEOUT_INDEFINITE);
    static const Image* mergeImagesCPU(const ImageOps& ops, const bool blend);

    static void assembleFrame(const Frame* frame, Channel* channel);

    static void assembleImage(const ImageOp& operation, Channel* channel);

    static void setupStencilBuffer(const ImageOp& operation,
                                   const Channel* channel);

    static void clearStencilBuffer(const ImageOp& operation);

    static void setupAssemblyState(const PixelViewport& pvp,
                                   const GLEWContext* gl);

    static void resetAssemblyState();

    static void assembleImage2D(const ImageOp& op, Channel* channel);
    static void assembleImageDB(const ImageOp& op, Channel* channel);

    static void assembleImageDB_FF(const ImageOp& op, Channel* channel);

    static void assembleImageDB_GLSL(const ImageOp& op, Channel* channel);

    static void declareRegion(const ImageOp& op, Channel* channel);

    class WaitHandle;

    static WaitHandle* startWaitFrames(const Frames& frames, Channel* channel);

    static Frame* waitFrame(WaitHandle* handle);

    static bool isSubPixelDecomposition(const Frames& frames);
    static bool isSubPixelDecomposition(const ImageOps& ops);
    static Frames extractOneSubPixel(Frames& frames);
    static ImageOps extractOneSubPixel(ImageOps& ops);

private:
    typedef std::pair<const Frame*, const Image*> FrameImage;
};
}

#endif // EQ_COMPOSITOR_H