ConcaveShape

[Zabarovka]

Hi all. I just wrote some class for concave shapes, but because of being pretty new to SFML and even C++ (this is only my second project with SFML),so I decided to ask you if it is ok and ask you for some advices, and thank you for your time 

ConcaveShape.hpp

(click to show/hide)

#ifndef CONCAVESHAPE_HPP
#define CONCAVESHAPE_HPP
//---------------------------------------------------------------------------//
#include <vector>
//-----------------------------------//
#include <SFML/System.hpp>
#include <SFML/Graphics.hpp>

class ConcaveShape: public sf::Drawable, public sf::Transformable {
  private:
    std::vector<sf::VertexArray> triangles;
    std::vector<sf::Vector2f> points;
    sf::Color color;
    const sf::Texture* texture;
    float Area() const;
    bool PointOnLine(sf::Vector2f pt,sf::Vector2f v1,sf::Vector2f v2) const;
    bool PointInTriangle(sf::Vector2f p,sf::Vector2f p1,sf::Vector2f p2,sf::Vector2f p3) const;
    void CreateTriangle(unsigned int a,unsigned int b,unsigned int c);
    void TriangulateInner(unsigned int n,std::vector<unsigned int>& p);
  public:
    explicit ConcaveShape(sf::Color c=sf::Color::Black);
    explicit ConcaveShape(const sf::Texture& t,sf::Color c=sf::Color::Black);
    ~ConcaveShape();
    void addPoint(sf::Vector2f point);
    void Triangulate();
    void setColor(sf::Color c);
    void setTexture(sf::Texture& t);
    virtual void draw(sf::RenderTarget& target, sf::RenderStates states) const
    {
      if (texture!=nullptr) {states.texture=texture;}
      for (unsigned int i=0;i<triangles.size();++i) {
        target.draw(triangles.at(i),states);
      }
    }
};
//---------------------------------------------------------------------------//
#endif // CONCAVESHAPE_HPP

ConcaveShape.cpp

(click to show/hide)

#include "ConcaveShape.hpp"
float epsilon=0.000000001f;
//---------------------------------------------------------------------------//
ConcaveShape::ConcaveShape(sf::Color c):texture(nullptr),color(c) {}
//---------------------------------------------------------------------------//
ConcaveShape::ConcaveShape(const sf::Texture& t,sf::Color c):texture(&t),color(c) {}
//---------------------------------------------------------------------------//
ConcaveShape::~ConcaveShape()
{
  std::vector<sf::VertexArray>().swap(triangles);
  triangles.shrink_to_fit();
  texture=nullptr;
}
//---------------------------------------------------------------------------//
void ConcaveShape::addPoint(sf::Vector2f point)
{
  points.push_back(point);
}
//---------------------------------------------------------------------------//
float ConcaveShape::Area() const
{
  float A=0.f;
  unsigned int n=points.size(),p=n-1;
  for (unsigned int q=0;q!=n;++q) {
    A+=points[p].x*points[q].y-points[q].x*points[p].y;
    p=q;
  }
  return A*0.5f;
}
//---------------------------------------------------------------------------//
bool ConcaveShape::PointOnLine(sf::Vector2f pt,sf::Vector2f v1,sf::Vector2f v2) const
{
  if (fabs(v2.x-v1.x)>0) {
    if (fabs(pt.y-v1.y-(v2.y-v1.y)*(pt.x-v1.x)/(v2.x-v1.x))<epsilon) {return true;}
    else {return false;}
  }
  return false;
}
//---------------------------------------------------------------------------//
bool ConcaveShape::PointInTriangle(sf::Vector2f pt,sf::Vector2f v1,sf::Vector2f v2,sf::Vector2f v3) const
{
  float denominator=(v2.x-v3.x)*(v1.y-v3.y)-(v2.y-v3.y)*(v1.x-v3.x);
  if (fabs(denominator)<epsilon) {return false;}
  float a=((pt.y-v3.y)*(v2.x-v3.x)-(pt.x-v3.x)*(v2.y-v3.y))/denominator;
  float b=((pt.x-v3.x)*(v1.y-v3.y)-(pt.y-v3.y)*(v1.x-v3.x))/denominator;
  if ((!std::isfinite(a))||(!std::isfinite(b))) {return true;}
  if ((!std::signbit(a))&&(!std::signbit(b))&&(std::signbit(a+b-1.0f))) {return true;}
  else {
    if ((!std::signbit(a+epsilon))&&(!std::signbit(b+epsilon))&&(std::signbit(a+b-1.0f))){
      if (PointOnLine(pt,v3,v1)) {return true;}
    }
    return false;
  }
}
//---------------------------------------------------------------------------//
void ConcaveShape::CreateTriangle(unsigned int a,unsigned int b,unsigned int c)
{
  if ((a<points.size())&&(b<points.size())&&(c<points.size())) {
    triangles.push_back(sf::VertexArray(sf::Triangles,3));
    triangles.back()[0].position=points[a];
    triangles.back()[1].position=points[b];
    triangles.back()[2].position=points[c];
//-----------------------------------//
    triangles.back()[0].color=color;
    triangles.back()[1].color=color;
    triangles.back()[2].color=color;
//-----------------------------------//
    triangles.back()[0].texCoords=points[a];
    triangles.back()[1].texCoords=points[b];
    triangles.back()[2].texCoords=points[c];
  }
}
//---------------------------------------------------------------------------//
void ConcaveShape::TriangulateInner(unsigned int n,std::vector<unsigned int>& p)
{
  register unsigned int next=0,next2=0,start=0,check=0;
  while ((p.size()>3)&&(check<(2*p.size()))) {
    Label:
    start++;
    check++;
//-----------------------------------//
    if (start>=p.size()) {start=0;}
    next=start+1;
    if (next>=p.size()) {next=0;}
    next2=next+1;
    if (next2>=p.size()) {next2=0;}
    sf::Vector2f a=points[p[start]];
    sf::Vector2f b=points[p[next]];
    sf::Vector2f c=points[p[next2]];
//-----------------------------------//
    if (-epsilon>((b.x-a.x)*(c.y-a.y)-(b.y-a.y)*(c.x-a.x))) {goto Label;}
    else {
      for (unsigned int i=0;i!=n;++i) {
        if ((i!=p[start])&&(i!=p[next])&&(i!=p[next2])) {
          if (PointInTriangle(points[i],a,b,c)) {goto Label;}
        }
      }
    }
    check=0;
    CreateTriangle(p[start],p[next],p[next2]);
    p.erase(p.begin()+next);
  }
}
//---------------------------------------------------------------------------//
void ConcaveShape::Triangulate()
{
  register unsigned int n=points.size();
  std::vector<unsigned int> p;
  if (0.f<Area()) {for (unsigned int i=0;i!=n;++i) {p.push_back(i);}}
  else {for(unsigned int i=0;i!=n;++i) {p.push_back((n-1)-i);}}
  if (p.size()>3) {TriangulateInner(n,p);}
  if (p.size()==3) {CreateTriangle(p[0],p[1],p[2]);}
  std::vector<unsigned int>().swap(p);
  p.shrink_to_fit();
  std::vector<sf::Vector2f>().swap(points);
  points.shrink_to_fit();
}
//---------------------------------------------------------------------------//
void ConcaveShape::setColor(sf::Color c)
{
  color=c;
  for (auto& i:triangles) {
    i[0].color=color;
    i[1].color=color;
    i[2].color=color;
  }
}
//---------------------------------------------------------------------------//
void ConcaveShape::setTexture(const sf::Texture& t)
{
  texture=&t;
}
 

Usage example

(click to show/hide)

#include <SFML/Window.hpp>
#include "ConcaveShape.hpp"

int main()
{
  sf::Window window(sf::VideoMode(100,100),"My window");

  ConcaveShape shape(sf::Color::Red);
  shape.addPoint(sf::Vector2f(10,10));
  shape.addPoint(sf::Vector2f(20,20));
  shape.addPoint(sf::Vector2f(10,30));
  shape.addPoint(sf::Vector2f(10,60));
  shape.addPoint(sf::Vector2f(50,60));
  shape.addPoint(sf::Vector2f(20,40));
  shape.addPoint(sf::Vector2f(50,20));
  shape.Triangulate();

  while (window.isOpen()) {
    sf::Event event;
    while (window.pollEvent(event)) {
      if (event.type == sf::Event::Closed) {window.close();}
    }
    window.clear(sf::Color(255,255,255));
    window->draw(shape);
    window->display();
  }

  return 0;
}

I created it for displaying some charts, so there are few examples:

(click to show/hide)

(click to show/hide)

(click to show/hide)

[Hapax]

Just a couple of points that I could see with a quick look:

1) Instead of:

if (texture!=nullptr) {states.texture=texture;}

you can just use:

states.texture = texture;

as nullptr is a valid value for states.texture

2) This is just a question. Why do you attempt to delete the external texture that is used when the object is destroyed? This texture may be used elsewhere.

[Zabarovka]

Just a couple of points that I could see with a quick look:

1) Instead of:

if (texture!=nullptr) {states.texture=texture;}

you can just use:

states.texture = texture;

as nullptr is a valid value for states.texture

2) This is just a question. Why do you attempt to delete the external texture that is used when the object is destroyed? This texture may be used elsewhere.

1) Done 
2) ...nevermind- just forgot to remove "delete"...

Thanks ^^

[Laurent]

1) Instead of:

if (texture!=nullptr) {states.texture=texture;}

you can just use:

states.texture = texture;

as nullptr is a valid value for states.texture

This is not equivalent. The first version uses the states' texture by default unless there's one in the shape. The second one always uses the shape's texture and ignores the states one.

[Hapax]

This is not equivalent.

This is true. It's not exactly equivalent.
It's equivalent for most standard cases but doesn't allow passing another texture in the states call to draw, if that's what you need.
I would argue, though, that being stricter about which texture is being used (by only allowing it to be specified in the actual class) is more predictable.

[Laurent]

I just wanted to point out that changing this code would slightly change the behaviour of the class. I didn't mean that one was better than the other

[Zabarovka]

Minor updates.