compositor.h

/* Copyright (c) 2007-2009, 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/client/frame.h>          // nested type Frame::Buffer 
#include <eq/client/pixel.h>          // member
#include <eq/client/types.h>          // type definitions
#include <eq/base/base.h>             // EQ_EXPORT definition

#include <vector>

namespace eq
{
namespace util
{
    class Accum;
}
    class Channel;
    class Image;

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

            Channel* channel; 
            uint32_t buffers; 
            Vector2i offset;  
            Pixel pixel;      
            Zoom zoom;        
        };

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

        static uint32_t assembleFramesSorted( const FrameVector& frames,
                                              Channel* channel, 
                                              util::Accum* accum,
                                              const bool blendAlpha = false );

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

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

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

        static bool mergeFramesCPU( const FrameVector& frames,
                                    const bool blendAlpha,
                                    void* colorBuffer,
                                    const uint32_t colorBufferSize,
                                    void* depthBuffer, 
                                    const uint32_t depthBufferSize,
                                    PixelViewport& outPVP );

        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 clearStencilBuffer( const ImageOp& operation );

        static void setupAssemblyState( const PixelViewport& pvp );
        
        static void resetAssemblyState();

        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 bool _isSubPixelDecomposition( const FrameVector& frames );
        static const FrameVector _extractOneSubPixel( FrameVector& frames );

        static bool _collectOutputData( const FrameVector& frames,
                                        PixelViewport& destPVP, 
                                        uint32_t& colorFormat, 
                                        uint32_t& colorType,
                                        uint32_t& depthFormat,
                                        uint32_t& depthType );
                                        
        static void _mergeFrames( const FrameVector& frames,
                                  const bool blendAlpha, 
                                  void* colorBuffer, void* depthBuffer,
                                  const PixelViewport& destPVP );
                                  
        static void   _mergeDBImage( void* destColor, void* destDepth,
                                     const PixelViewport& destPVP, 
                                     const Image* image, 
                                     const Vector2i& offset );
                                     
        static void   _merge2DImage( void* destColor, void* destDepth,
                                     const PixelViewport& destPVP,
                                     const Image* input,
                                     const Vector2i& offset );
                                     
        static void   _mergeBlendImage( void* dest, 
                                        const PixelViewport& destPVP, 
                                        const Image* input,
                                        const Vector2i& offset );
        static bool     _mergeImage_PC( int operation, void* destColor, 
                                        void* destDepth, const Image* source );
        static void _drawPixels( const Image* image, const ImageOp& op,
                                 const Frame::Buffer which );

        static util::Accum* _obtainAccum( Channel* channel );
    };
}

#endif // EQ_COMPOSITOR_H