shadowmap.hpp

Go to the documentation of this file.

#ifndef __SHADOWMAP__
#define __SHADOWMAP__

#include <tucano/tucano.hpp>

namespace Tucano
{
namespace Effects
{

class ShadowMap: public Tucano::Effect {

protected:
    Tucano::Framebuffer fbo;

    Tucano::Framebuffer aa_fbo;

    Tucano::Shader shadowbuffer_shader;

    Tucano::Shader drawbuffer_shader;

    Tucano::Mesh quad;

    Eigen::Vector2i viewport = Eigen::Vector2i(1024, 1024);

    int depth_tex_id = 0;

    int num_samples = 4;

    bool recreate_fbo = true;

public:

    ShadowMap (void)
    {
        quad.createQuad();
        }

    virtual void initialize (void)
    {
                loadShader(shadowbuffer_shader, "shadowbuffer");
        loadShader(drawbuffer_shader, "rendershadowmap");
    }

        void clearShadowBuffer (void)
        {
                fbo.clearAttachments();
        }

    Tucano::Framebuffer* getShadowMap (void)
        {
        if (num_samples == 1)
            return &fbo;
                return &aa_fbo;
        }

    Tucano::Framebuffer* getShadowMapMultisample (void)
    {
        return &fbo;   
    }

    void setNumSamples (int n)
    {
        num_samples = n;
        recreate_fbo = true;
    }

    void setBufferSize (const Eigen::Vector2i & size)
    {
        viewport = size;
        recreate_fbo = true;
    }

    void createBuffers (void)
    {
        aa_fbo.create(viewport[0], viewport[1], 1, 1); // single sampling
        fbo.create(viewport[0], viewport[1], 1, num_samples); // multi sampling (actually used for generatin map)
        fbo.getTexture(0)->setTexParameters(GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE, GL_LINEAR, GL_LINEAR);

        // if using sampler2DShadow in shaders, but usually we do the check manually
        fbo.getTexture(0)->bind();
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE);   
        fbo.getTexture(0)->unbind();
    }

    void renderBuffer (const Tucano::Camera& camera)
    {
        Eigen::Vector4f viewport = camera.getViewport();
        glViewport(viewport[0], viewport[1], viewport[2], viewport[3]);
        drawbuffer_shader.bind();
        drawbuffer_shader.setUniform("shadowmap", fbo.bindAttachment(0));
        quad.setAttributeLocation(drawbuffer_shader);
        quad.render();
        drawbuffer_shader.unbind();
        fbo.unbindAttachments();
        
    }

    void render (Tucano::Mesh& mesh, const Tucano::Camera& camera, const Tucano::Camera & light)
        {
        if (recreate_fbo)
        {
            createBuffers();
            recreate_fbo = false;
        }

        glEnable(GL_DEPTH_TEST);
        
        glViewport(0, 0, viewport[0], viewport[1]);

        // Bind buffer to store coord
        fbo.bindRenderBuffer(depth_tex_id);

        shadowbuffer_shader.bind();
        shadowbuffer_shader.setUniform("projectionMatrix", light.getProjectionMatrix());
        shadowbuffer_shader.setUniform("modelMatrix",mesh.getModelMatrix());
        shadowbuffer_shader.setUniform("viewMatrix", light.getViewMatrix().inverse());

        mesh.setAttributeLocation(shadowbuffer_shader);
        mesh.render();

        shadowbuffer_shader.unbind();
        fbo.unbind();

        if (num_samples > 1) // if multisampling prepare Anti Aliased single sampled buffer
            fbo.blitTo(aa_fbo);
    }

};
}
}
#endif