shapeClass.h

Go to the documentation of this file.

/*
 * shapeClass.h
 *
 * Ce programme est distribué sous les termes de la Licence Publique
 * Générale GNU, version 3.0, telle que publiée par la Free Software
 * Foundation. Consultez la Licence Publique Générale GNU pour plus de
 * détails.
 *
 * Vous devez avoir reçu une copie de la Licence Publique Générale GNU
 * en même temps que ce programme. Si ce n'est pas le cas, consultez
 * <https://www.gnu.org/licenses/>.
 */
 
#ifndef SHAPE_CLASS_H
#define SHAPE_CLASS_H
 
#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include <initializer_list>
 
#include "bbopMathClass.h"
#include "bbopGlobal.h"
#include "collisionBoxClass.h"
#include "VAO.h"
#include "VBO.h"
#include "EBO.h"
 
class Shape : public BbopDrawable
{
      public:
    Shape(GLfloat *vertices, GLsizeiptr verticesSize, GLuint *indices,
        GLsizeiptr indicesSize);
 
    Shape();
 
    Shape(const Shape &other);
 
    ~Shape();
 
    void initShape(GLfloat *vertices, GLsizeiptr verticesSize,
        GLuint *indices, GLsizeiptr indicesSize);
 
    const Vector2f &getSize() const;
 
    void setSize(const Vector2f &nSize);
 
    void setSize(float x_, float y_);
 
    const Vector2f &getPosition() const;
 
    void setPosition(const Vector2f &nPos);
 
    void setPosition(float x_, float y_);
 
    const Vector2f &getOrigin() const;
 
    void setOrigin(const Vector2f &nOrigin);
 
    void setOrigin(float x_, float y_);
 
    const Vector3i &getColor() const;
 
    void setColor(const Vector3i &nRGB);
 
    void setColor(int x_, int y_, int z_);
 
    float getAlpha() const;
 
    void setAlpha(float nAlpha);
 
    float getRotation() const;
 
    void setRotation(float nRotation);
 
    CollisionBox &getCollisionBox();
 
    void setAutoUpdateCollision(bool etat);
 
    void move(const Vector2f &vecM);
 
    void move(float x_, float y_);
 
      protected:
    VAO shapeVAO;         //<! VAO de opengl de la Shape
    VBO shapeVBO;         //<! VBO opengl de la Shape
    EBO shapeEBO;         //<! EBO opengl de la Shape
    Vector2f pos;         //<! position de la shape
    Vector2f size;        //<! taille de la shape
    Vector2f origin;      //<! origin de la shape
    Vector3i RGB;         //<! couleur de la shape
    bool autoUpdateCollision; //<! activation automatique des collisions
    float rotation;       //<! rotation
    CollisionBox shapeCollisionBox; //<! boîte de collision
    float alpha;            //<! transparence de la shape
    virtual void buildVAO() = 0;
    virtual void updateVBO() = 0;
    virtual void updateVBORGB() = 0;
    virtual void updateVBOAlpha() = 0;
};
 
class RectangleShape : public Shape
{
      public:
    RectangleShape();
 
    RectangleShape(Vector2f nSize, Vector2f nPos);
    RectangleShape(
        Vector2f nSize, Vector2f nPos, Vector3i nRGB, Vector2f nOrigin);
    RectangleShape(Vector2f nSize, Vector2f nPos, Vector3i nRGB,
        Vector2f nOrigin, float nRotation, float nAlpha);
 
    void Draw(GLint *renderUniforms) const override;
 
      private:
    GLfloat vertices[24];
    GLuint indices[6];
    void buildVAO() override;
    void updateVBO() override;
    void updateVBORGB() override;
    void updateVBOAlpha() override;
};
 
class ConvexShape : public Shape
{
      public:
    ConvexShape();
 
    ConvexShape(int nnPoint, Vector2f *nlistPoint);
    ConvexShape(int nnPoint, Vector2f *nlistPoint, Vector2f nSize,
        Vector2f nPos);
    ConvexShape(int nnPoint, Vector2f *nlistPoint, Vector2f nSize,
        Vector2f nPos, Vector3i nRGB, Vector2f nOrigin);
    ConvexShape(int nnPoint, Vector2f *nlistPoint, Vector2f nSize,
        Vector2f nPos, Vector3i nRGB, Vector2f nOrigin, float nRotation,
        float nAlpha);
 
    ConvexShape(const ConvexShape &other);
    ~ConvexShape();
 
    ConvexShape &operator=(const ConvexShape &other);
 
    void initConvex(int nnPoint, Vector2f *nlistPoint);
 
    void Draw(GLint *renderUniforms) const override;
 
      private:
    GLfloat *vertices;
    GLuint *indices;
    int nPoint;
    Vector2f *listPoint;
    void buildVAO() override;
    void updateVBO() override;
    void updateVBORGB() override;
    void updateVBOAlpha() override;
};
 
class CircleShape : public ConvexShape
{
      public:
    CircleShape(int nnPoint, float nRadius);
    CircleShape(int nnPoint, float nRadius, Vector2f nSize, Vector2f nPos);
    CircleShape(int nnPoint, float nRadius, Vector2f nSize, Vector2f nPos,
        Vector3i nRGB, Vector2f nOrigin);
    CircleShape(int nnPoint, float nRadius, Vector2f nSize, Vector2f nPos,
        Vector3i nRGB, Vector2f nOrigin, float nRotation, float nAlpha);
 
    float getRadius() const;
 
    void setRadius(float nRadius);
 
    int getNPointCircle() const;
 
    void setNPointCircle(int nnPoint);
 
      private:
    float radius;
    int nPointCircle;
 
      protected:
    void buildConvex();
};
 
#endif // ! SHAPE_CLASS_H