Messages

1

Graphics / Re: ConcaveShape

« on: October 25, 2016, 09:47:44 am »

Minor updates.

2

Graphics / Re: ConcaveShape

« on: September 02, 2016, 02:46:45 pm »

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 ^^

3

Graphics / ConcaveShape

« on: September 02, 2016, 12:48:35 pm »

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)