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