PerPixelProcessingBase.hh

/*
 This file is part of the BIAS library (Basic ImageAlgorithmS).

 Copyright (C) 2003-2009    (see file CONTACT for details)
 Multimediale Systeme der Informationsverarbeitung
 Institut fuer Informatik
 Christian-Albrechts-Universitaet Kiel


 BIAS is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
 the Free Software Foundation; either version 2.1 of the License, or
 (at your option) any later version.

 BIAS 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 BIAS; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#ifndef __PERPIXEL_PROCESSING_BASE_HH__
#define __PERPIXEL_PROCESSING_BASE_HH__

#include <OpenGLFramework/Base/glfTexture2D.hh>
#include <OpenGLFramework/Base/glfBatch.hh>
#include <OpenGLFramework/Base/glfScreen.hh>
#include <OpenGLFramework/Base/glfFramebufferObject.hh>
#include <OpenGLFramework/Utils/Primitives.hh>

#include <bias_config.h>

namespace BIAS {

/**
 * @brief
 * this class can be used as a simple base class for specialized batches
 *
 * usage : seed for example SeparabelBoxlFilter or DisparityInterpolator
 *
 * \author frick
 **/

class BIASOpenGLFramework_EXPORT PerPixelProcessingBase {
public:
    PerPixelProcessingBase();
    virtual ~PerPixelProcessingBase();

    void SetViewPort(unsigned int width, unsigned int height) {
        viewport_.SetSize(width, height);
        viewport_.SetOrigin(0, 0);
    }

    unsigned int GetViewportWidth() {
        return viewport_.GetWidth();
    }
    unsigned int GetViewportHeight() {
        return viewport_.GetHeight();
    }

    void SetRenderTarget(glfFramebufferObject* renderTarget) {
        if (renderTargetCreated_) {
            delete renderTargetP_;
            if (zBufferP_ != NULL)
                delete zBufferP_;
            if (textureP_ != NULL)
                delete textureP_;
            renderTargetP_ = NULL;
            zBufferP_ = NULL;
            textureP_ = NULL;
        }

        renderTargetP_ = renderTarget;
        batch_.SetRenderTarget(renderTarget);

        renderTargetCreated_ = false;
    }

    glfShaderProgram* CreateFragmentShaderProgram(
            const std::string& fragmentShaderCode);

    glfShaderProgram* CreateFragmentShaderProgramFromFile(
            const std::string& fragmentShaderPath);

    void ActivateFixedFunctionPipeline() {

        if (renderTargetCreated_) {
            delete renderTargetP_;
            if (zBufferP_ != NULL)
                delete zBufferP_;
            if (textureP_ != NULL)
                delete textureP_;
            renderTargetP_ = NULL;
            zBufferP_ = NULL;
            textureP_ = NULL;

                        renderTargetCreated_ = false;
        }


                batch_.SetRenderTarget(&glfScreen::GetInstance());
                batch_.SetShaderProgram(NULL);
    }

    void SetDefaultFloatRenderTarget(unsigned int width, unsigned height);
    void SetDefaultRGBRenderTarget(unsigned int width, unsigned height);
    void SetDefaultRenderTarget(unsigned int width, unsigned height, GLenum internalFormat=GL_LUMINANCE32F_ARB);

    glfTexture2D* GetZBufferFromDefaultRenderTarget() {
        return zBufferP_;
    }
    glfTexture2D* GetTextureFromDefaultRenderTarget() {
        return textureP_;
    }

    int GetTextureFromDefaultRenderTarget(ImageBase& texture) {
        if (textureP_ != NULL) {
            textureP_->CopyToImage(texture);
        } else {
            return -1;
        }

        return 0;
    }

    glfFramebufferObject* GetRenderTarget() {
        return renderTargetP_;
    }

protected:
    void InitBatch_() {
        batch_.SetElementBuffer(&elements_);
        batch_.SetVertexBuffer(&vertices_);
        batch_.SetViewport(&viewport_);
        batch_.SetModelViewMatrix(&modelViewMatrix_);
        batch_.SetProjectionMatrix(&projectionMatrix_);
        batch_.SetDepthBufferMode(&depthBufferMode_);

        depthBufferMode_.SetDepthTest(true);

        InitPrimitiveData_();
        InitVertexTransformation_();
    }

    void InitPrimitiveData_() {
        Primitives::PlainQuad2DWithTexture2D(vertices_, elements_, false);
    }

    void InitVertexTransformation_() {
        modelViewMatrix_.MakeIdentity();
        projectionMatrix_.MakeIdentity();
    }

    glfBatch* GetBatch_() {
        return &batch_;
    }

    glfVertexBuffer* GetVertexBuffer_();

    glfElementBuffer* GetElementBuffer_();

    glfMatrix* GetModelViewMatrix_();

    glfMatrix* GetProjectionMatrix_();

    glfViewport* GetViewport_() {
        return &viewport_;
    }
    glfDepthBufferMode* GetDepthBufferMode_() {
        return &depthBufferMode_;
    }

    glfShader* GetShader() {
        return fragmentShaderP_;
    }

    glfShaderProgram* GetShaderProgram_() {
        return shaderProgramP_;
    }
private:
    bool renderTargetCreated_;

    glfBatch batch_;
    glfVertexBuffer vertices_;
    glfElementBuffer elements_;
    glfMatrix modelViewMatrix_;
    glfMatrix projectionMatrix_;
    glfViewport viewport_;
    glfDepthBufferMode depthBufferMode_;
    glfFramebufferObject* renderTargetP_;
    glfTexture2D* zBufferP_;
    glfTexture2D* textureP_;
    glfShaderProgram* shaderProgramP_;
    glfShader* fragmentShaderP_;

};
}

#endif /* PERPIXELPROCESSINGBASE_HH_ */