ssao.hpp

Go to the documentation of this file.

#ifndef __SSAO__
#define __SSAO__

#include <tucano/effect.hpp>
#include <tucano/camera.hpp>
#include <tucano/framebuffer.hpp>
#include <tucano/utils/ppmIO.hpp>

namespace Tucano
{
namespace Effects
{

class SSAO: public Tucano::Effect {

protected:

    Tucano::Texture noise_texture;

    float radius;

    Tucano::Framebuffer fbo;

    Tucano::Shader ssao_shader;

    Tucano::Shader deferred_shader;

    Tucano::Shader ssao_final_shader;

    Tucano::Mesh quad;

    bool apply_blur = true;

    bool displayAmbientPass = false;

    int blurRange = 3;

    int depthTextureID = 0;

    int normalTextureID = 1;

    int colorTextureID = 2;

    int ssaoTextureID = 3;

    int blurTextureID = 4;

    int intensity = 1;

    float global_scale = 1.0;


public:

    SSAO (float rad = 1.0)
    {
        radius = rad;
        }

    virtual void initialize (void)
    {
        initializeShaders();

        // @TODO put appropiate image path for random.ppm
        Tucano::ImageImporter::loadPPMImage("../samples/images/random.ppm", &noise_texture);
        noise_texture.setTexParameters( GL_REPEAT, GL_REPEAT, GL_NEAREST, GL_NEAREST );

        #ifdef TUCANODEBUG
        Tucano::Misc::errorCheckFunc(__FILE__, __LINE__);
        #endif

        quad.createQuad();
    }

    void createViewSpaceBuffer (Tucano::Mesh& mesh, const Tucano::Camera& camera_trackball, const Tucano::Camera& light_trackball)
    {

        // Bind buffer to store coord, normal and color information
        fbo.clearAttachments();
        fbo.bindRenderBuffers(depthTextureID, normalTextureID, colorTextureID);

        deferred_shader.bind();
        deferred_shader.setUniform("projectionMatrix", camera_trackball.getProjectionMatrix());
        deferred_shader.setUniform("modelMatrix",mesh.getModelMatrix());
        deferred_shader.setUniform("viewMatrix", camera_trackball.getViewMatrix());
        deferred_shader.setUniform("lightViewMatrix", light_trackball.getViewMatrix());
        deferred_shader.setUniform("has_color", mesh.hasAttribute("in_Color"));

        mesh.setAttributeLocation(deferred_shader);
        mesh.render();

        deferred_shader.unbind();
        fbo.unbind();
        fbo.clearDepth();

    }

    void computeSSAO (const Tucano::Camera& camera)
    {

        fbo.bindRenderBuffer(ssaoTextureID);

        ssao_shader.bind();

        ssao_shader.setUniform("coordsTexture", fbo.bindAttachment(depthTextureID));
        ssao_shader.setUniform("normalTexture", fbo.bindAttachment(normalTextureID));
        ssao_shader.setUniform("noise_texture", noise_texture.bind());
        ssao_shader.setUniform("viewport", (GLfloat)fbo.getWidth(), (GLfloat)fbo.getHeight());
        ssao_shader.setUniform("projectionMatrix", camera.getProjectionMatrix());
        ssao_shader.setUniform("radius", radius);
        ssao_shader.setUniform("global_scale", global_scale);
        ssao_shader.setUniform("intensity", (GLfloat)intensity);

        quad.setAttributeLocation(ssao_shader);
        quad.render();

        ssao_shader.unbind();
        noise_texture.unbind();
        fbo.unbind();
        fbo.clearDepth();
    }


    void applySSAO (const Tucano::Camera& light_trackball)
    {
        ssao_final_shader.bind();

        ssao_final_shader.setUniform("lightViewMatrix", light_trackball.getViewMatrix());

        ssao_final_shader.setUniform("coordsTexture", fbo.bindAttachment(depthTextureID));
        ssao_final_shader.setUniform("normalTexture", fbo.bindAttachment(normalTextureID));
        ssao_final_shader.setUniform("colorTexture", fbo.bindAttachment(colorTextureID));
        ssao_final_shader.setUniform("ssaoTexture", fbo.bindAttachment(ssaoTextureID));
        ssao_final_shader.setUniform("blurRange", blurRange);

        quad.setAttributeLocation(ssao_final_shader);
        quad.render();

        ssao_final_shader.unbind();
        fbo.unbind();
    }

    virtual void render(Tucano::Mesh& mesh, const Tucano::Camera& camera_trackball, const Tucano::Camera& light_trackball)
    {
        Eigen::Vector4f viewport = camera_trackball.getViewport();
        Eigen::Vector2i viewport_size = camera_trackball.getViewportSize();

        glViewport(viewport[0], viewport[1], viewport[2], viewport[3]);

        // check if viewport was modified, if so, regenerate fbo
        if (fbo.getWidth() != viewport_size[0] || fbo.getHeight() != viewport_size[1])
        {
            fbo.create(viewport_size[0], viewport_size[1], 5);
        }

        glEnable(GL_DEPTH_TEST);
        glClearColor(1.0, 1.0, 1.0, 0.0);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        // first pass
        createViewSpaceBuffer (mesh, camera_trackball, light_trackball);

        // second pass
        computeSSAO(camera_trackball);

        // final pass, blur SSAO and join with original render
        applySSAO(light_trackball);
    }

    int getIntensity (void)
    {
        return intensity;
    }

    void setIntensity (int value)
    {
        intensity = value;
    }

    int getRadius (void)
    {
        return radius;
    }


    void setRadius (int value)
    {
        radius = value;
    }

    void setScale (int value)
    {
        global_scale = value;
    }


    void setBlurRange (int value)
    {
        blurRange = value;
        }

    void toggleAmbientPass (void)
    {
        displayAmbientPass = !displayAmbientPass;
    }


private:

    void initializeShaders (void)
    {
                loadShader(ssao_shader, "ssao");
                loadShader(deferred_shader, "viewspacebuffer");
                loadShader(ssao_final_shader, "ssaofinal");
    }

};
}
}

#endif