compositor.h

/* Copyright (c) 2007-2008, Stefan Eilemann <eile@equalizergraphics.com> 
   All rights reserved. */

#ifndef EQ_COMPOSITOR_H
#define EQ_COMPOSITOR_H

#include <eq/client/pixel.h>          // member
#include <eq/client/types.h>          // type definitions
#include <eq/base/base.h>             // EQ_EXPORT definition

#include <vmmlib/vector2.h>
#include <vector>

namespace eq
{
    class Channel;
    class Frame;
    class Image;

    class EQ_EXPORT Compositor
    {
    public:
        struct ImageOp
        {
            ImageOp() : channel( 0 ), buffers( 0 )
                      , offset( vmml::Vector2i::ZERO ) {}

            Channel*       channel; 
            uint32_t       buffers; 
            vmml::Vector2i offset;  
            Pixel          pixel;   
        };

        //*{
        static void assembleFrames( const FrameVector& frames,
                                    Channel* channel );

        static void assembleFramesSorted( const FrameVector& frames,
                                          Channel* channel,
                                          const bool blendAlpha = false );

        static void assembleFramesUnsorted( const FrameVector& frames,
                                              Channel* channel );

        static void assembleFramesCPU( const FrameVector& frames,
                                       Channel* channel,
                                       const bool blendAlpha = false );

        static const Image* assembleFramesCPU(const FrameVector& frames,
                                              const bool blendAlpha = false );

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

        
        //*{
        static void assembleImage( const Image* image,
                                   const ImageOp& operation );

        static void setupStencilBuffer( const Image* image, 
                                        const ImageOp& operation );

        static void assembleImage2D( const Image* image, const ImageOp& op );
        static void assembleImageDB( const Image* image, const ImageOp& op );

        static void assembleImageDB_FF( const Image* image, const ImageOp& op );

        static void assembleImageDB_GLSL( const Image* image, 
                                          const ImageOp& op );
        //*}
                                
      private:
        typedef std::pair< const Frame*, const Image* > FrameImage;

        static void _assembleDBImages( Image* result,
                                       const std::vector< FrameImage >& images);
        static void _assemble2DImages( Image* result,
                                       const std::vector< FrameImage >& images);
        static void _assembleBlendImages( Image* result,
                                       const std::vector< FrameImage >& images);
        static bool   _assembleImage_PC( int operation, Image* result,
                                         const Image* source );

    };
}

#endif // EQ_COMPOSITOR_H