compositor.h

/* Copyright (c) 2007-2012, 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:
        struct ImageOp
        {
            ImageOp() : channel( 0 ), buffers( 0 )
                      , offset( Vector2i::ZERO )
                      , zoomFilter( FILTER_LINEAR ) {}

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

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

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

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

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

        static const Image* mergeFramesCPU( const Frames& frames,
                                            const bool blendAlpha = false,
                               const uint32_t timeout = LB_TIMEOUT_INDEFINITE );

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

        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,
                                        const GLEWContext* gl );

        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 );

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

        class WaitHandle;

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

        static Frame* waitFrame( WaitHandle* handle );

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

        static bool _isSubPixelDecomposition( const Frames& frames );
        static const Frames _extractOneSubPixel( Frames& frames );

        static bool _collectOutputData(
                             const Frames& frames,
                             PixelViewport& destPVP,
                             uint32_t& colorInternalFormat,
                             uint32_t& colorPixelSize,
                             uint32_t& colorExternalFormat,
                             uint32_t& depthInternalFormat,
                             uint32_t& depthPixelSize,
                             uint32_t& depthExternalFormat,
                             const uint32_t timeout );

        static void _collectOutputData( const PixelData& pixelData,
                                        uint32_t& internalFormat,
                                        uint32_t& pixelSize,
                                        uint32_t& externalFormat );

        static void _mergeFrames( const Frames& 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 _drawPixelsFF( const Image* image, const ImageOp& op,
                                   const Frame::Buffer which );

        static void _drawPixelsGLSL( const Image* image, const ImageOp& op,
                                     const Frame::Buffer which );

        static bool _setupDrawPixels( const Image* image, const ImageOp& op,
                                      const Frame::Buffer which );

        static Vector4f _getCoords( const ImageOp& op,
                                    const PixelViewport& pvp );

        template< typename T >
        static void _drawTexturedQuad( const T* key,const ImageOp& op,
                                       const PixelViewport& pvp,
                                       const bool withDepth );

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

#endif // EQ_COMPOSITOR_H