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