element.hpp

Go to the documentation of this file.

#ifndef __GUIELEMENT__
#define __GUIELEMENT__

#include <tucano/gui/guishaders.hpp>
#include <tucano/utils/imageIO.hpp>
#include <tucano/texture.hpp>

namespace Tucano
{

namespace GUI
{

enum ElementType : signed int
{
    NONE,
    BUTTON,
        SELECTBUTTON,
    SLIDER,
    LABEL,
    GROUPBOX,
        SELECTGROUP
};

class Element {

protected:

    int element_type = Tucano::GUI::NONE;

    int num_params = 0;

    Eigen::Affine3f model_matrix;

    Eigen::Vector2i dimensions;

    Eigen::Vector2i position;

    Shapes::Quad quad;

    Tucano::Texture texture;

    Tucano::Texture texture_alt;

    Tucano::Texture texture_alt2;

    bool has_alt_texture = 0;

    bool has_alt_texture2 = 0;

    Eigen::Vector4f color = Eigen::Vector4f (1.0, 1.0, 1.0, 1.0);


    function< void() > callback_noparam;
    function< void(int) > callback_1i;
    function< void(float) > callback_1f;

        bool visible = true;

    bool hover = false;

public:

    Element (void) 
    {
        model_matrix = Eigen::Affine3f::Identity();
        callback_noparam = NULL;
        callback_1i = NULL;
        callback_1f = NULL;
    }


        Eigen::Vector2i getDimensions (void)
        {
                return dimensions;
        }

        Eigen::Vector2i getPosition (void)
        {
                return position;
        }

    void setDimensions (const Eigen::Vector2i& dim)
    {
        dimensions = dim;
        setModelMatrix();
    }

    void setDimensions (int w, int h)
    {
        setDimensions(Eigen::Vector2i(w,h));
    }

    virtual void setDimensionsFromHeight (int h)
    {
        if (texture.getWidth() != 0)
        {
            dimensions << texture.getWidth() * h/(float)texture.getHeight(), h;
            setModelMatrix();
        }
    }

    virtual void setTexture (string file)
    {
        Tucano::ImageImporter::loadImage(file, &texture);
        texture.setTexParameters( GL_REPEAT, GL_REPEAT, GL_LINEAR, GL_LINEAR );
    }

    virtual void setAltTexture (string file)
    {
        Tucano::ImageImporter::loadImage(file, &texture_alt);
        texture_alt.setTexParameters( GL_REPEAT, GL_REPEAT, GL_LINEAR, GL_LINEAR );
        has_alt_texture = true;
            color = Eigen::Vector4f (1.0, 1.0, 1.0, 1.0); // wont modulate color, set it to white
    }


    virtual void setModelMatrix (void)
    {
        model_matrix = Eigen::Affine3f::Identity();
        
        // translates to position
        model_matrix.translate (Eigen::Vector3f ((float)position[0], (float)position[1], 0.0) );
        // scales to fit required dimensions, invert y axis to get appropriate texcoords
        model_matrix.scale (Eigen::Vector3f ((float)dimensions[0], (float)dimensions[1], 1.0));
        // sets the quad to range (0, 1) instead of (-0.5, 0.5)
        model_matrix.translate (Eigen::Vector3f (0.5, 0.5, 0.0) );
    }



    void setPosition (const Eigen::Vector2i& pos)
    {
        position = pos;
        setModelMatrix();
    }

    void setPosition (int x, int y)
    {
        setPosition (Eigen::Vector2i(x,y));
    }
    bool isInside (int x, int y)
    {
        return isInside (Eigen::Vector2i(x,y));
    }

    virtual bool isInside (const Eigen::Vector2i& pos)
    {
        if (pos[0] >= position[0] && pos[0] <= position[0] + dimensions[0] &&
            pos[1] >= position[1] && pos[1] <= position[1] + dimensions[1])
            return true;
        return false;
    }

    virtual void release (void) {}

    virtual void cursorMove (int x, int y) {}

    virtual int getType (void)
    {
        return element_type;
    }

    virtual void render (Camera &camera_2d, Shader &shader) 
        {
                if (!visible)
                        return;

        shader.bind();

        shader.setUniform("modelMatrix", model_matrix);
        shader.setUniform("viewMatrix", camera_2d.getViewMatrix());
        shader.setUniform("projectionMatrix", camera_2d.getProjectionMatrix());
        shader.setUniform("in_Color", color);
        shader.setUniform("shapetex", texture.bind());

        quad.setAttributeLocation(shader);

        quad.bindBuffers();
        quad.renderElements();
        quad.unbindBuffers();

        shader.unbind(); 
        texture.unbind();
        }



    virtual void setCallback (function<void()> f)
    {
        callback_noparam = f;  
    }

    virtual void setCallback1i (function< void(int) > f)
    {
        callback_1i = f;
    }

    virtual void setCallback1f (function< void(float) > f)
    {
        callback_1f = f;
    }

    virtual void callback (void)
    {
        callback();
    }

    virtual void callback (int p)
    {
        callback_1i(p);
    }

    virtual void callback (float p)
    {
        callback_1f(p);
    }

        void show(void) { visible = true; }

        void hide(void) { visible = false; }

        void toggleDisplay(void) { visible = !visible;}

        bool isVisible (void) { return visible; }

};
}
}
#endif