D:/Programmation/Sources/lxgui/bak/lxgui/gui/include/gui_sprite.hpp

Go to the documentation of this file.

// # Note # :
// This class is inspired by HGE's hgeSprite class.
// HGE is a simple and fast 2D drawing library. I have
// been using it before switching to Ogre3D, and I
// really liked the synthax.
//
// More infos about HGE :
// http://hge.relishgames.com/

#ifndef GUI_SPRITE_HPP
#define GUI_SPRITE_HPP

#include <utils.hpp>
#include <utils_refptr.hpp>
#include <utils_wptr.hpp>
#include <array>
#include <vector>

#include "gui_vector2.hpp"
#include "gui_color.hpp"

namespace gui
{
    class manager;
    class render_target;
    class material;

    struct vertex
    {
        vertex();
        vertex(const vector2f& mPos, const vector2f& mUV, const color& mCol);

        vector2f pos;
        vector2f uvs;
        color    col;
    };

    enum blend_mode
    {
        BLEND_NORMAL,
        BLEND_ADD,
        BLEND_MUL
    };

    struct quad
    {
        std::array<vertex, 4>   v;
        utils::refptr<material> mat;
        blend_mode              blend;
    };


    class sprite
    {
    public :

        sprite(const manager* pManager, utils::refptr<material> pMat);

        sprite(const manager* pManager, utils::refptr<material> pMat, float fWidth, float fHeight);

        sprite(const manager* pManager, utils::refptr<material> pMat, float fU, float fV, float fWidth, float fHeight);

        virtual ~sprite();


        virtual void render(float fX, float fY) const;


        virtual void render_ex(float fX, float fY,
                      float fRot,
                      float fHScale = 1.0f, float fVScale = 1.0f) const;


        virtual void render_2v(float fX1, float fY1,
                      float fX3, float fY3);


        virtual void render_4v(float fX1, float fY1,
                      float fX2, float fY2,
                      float fX3, float fY3,
                      float fX4, float fY4);


        virtual void render_static() const;


        virtual void render_quads(const std::vector<std::array<vertex,4>>& lQuadsArray) const;


        virtual void set_quad(const std::array<vertex,4>& lVertexArray);


        virtual void set_color(const color& mColor, uint uiIndex = (uint)(-1));


        virtual void set_desaturated(bool bDesaturated);


        virtual void set_blend_mode(blend_mode mBlendMode);


        virtual void set_hot_spot(const vector2f& mHotSpot);


        virtual void set_hot_spot(float fX, float fY);


        virtual void set_texture_rect(const std::array<float,4>& lTextureRect, bool bNormalized = false);


        virtual void set_texture_rect(float fX1, float fY1, float fX3, float fY3, bool bNormalized = false);


        virtual void set_texture_coords(const std::array<float,8>& lTextureCoords, bool bNormalized = false);


        virtual void set_texture_coords(float fX1, float fY1,
                              float fX2, float fY2,
                              float fX3, float fY3,
                              float fX4, float fY4,
                              bool bNormalized = false);


        virtual void set_dimensions(float fWidth, float fHeight);


        virtual float get_width() const;


        virtual float get_height() const;


        virtual color get_color() const;


        virtual blend_mode get_blend_mode() const;


        virtual std::array<float,4> get_texture_rect() const;


        virtual std::array<float,8> get_texture_coords(bool bNormalized = false) const;

    private :

        const manager* pManager_;

        mutable quad mQuad_;
        vector2f     mHotSpot_;
        float        fWidth_, fHeight_;
    };
}

#endif

---