Overview     Modules     Class Hierarchy     Classes     Members  

#include <GlComplexPolygon.h>

Inheritance diagram for tlp::GlComplexPolygon:
Collaboration diagram for tlp::GlComplexPolygon:

Public Member Functions

 GlComplexPolygon ()
 GlComplexPolygon (const std::vector< Coord > &coords, Color fcolor, int polygonEdgesType=0, const std::string &textureName="")
 GlComplexPolygon (const std::vector< Coord > &coords, Color fcolor, Color ocolor, int polygonEdgesType=0, const std::string &textureName="")
 GlComplexPolygon (const std::vector< std::vector< Coord > > &coords, Color fcolor, int polygonEdgesType=0, const std::string &textureName="")
 GlComplexPolygon (const std::vector< std::vector< Coord > > &coords, Color fcolor, Color ocolor, int polygonEdgesType=0, const std::string &textureName="")
virtual ~GlComplexPolygon ()
void setPolygonContour (const std::vector< Coord > &contour, int polygonEdgesType=0)
void setPolygonContours (const std::vector< std::vector< Coord > > &contours, int polygonEdgesType=0)
const std::vector< std::vector
< Coord > > & 
getPolygonContours () const
virtual void draw (float lod, Camera *camera)
void setOutlineMode (const bool)
void setOutlineSize (double size)
Color getFillColor ()
void setFillColor (const Color &color)
Color getOutlineColor ()
void setOutlineColor (const Color &color)
float getTextureZoom ()
std::string getTextureName ()
void setTextureName (const std::string &name)
void setTextureZoom (float zoom)
virtual void translate (const Coord &mouvement)
virtual void getXML (xmlNodePtr rootNode)
virtual void getXMLOnlyData (xmlNodePtr rootNode)
virtual void setWithXML (xmlNodePtr rootNode)
- Public Member Functions inherited from tlp::GlSimpleEntity
 GlSimpleEntity ()
virtual ~GlSimpleEntity ()
virtual void acceptVisitor (GlSceneVisitor *visitor)
virtual void setVisible (bool visible)
bool isVisible ()
virtual void setStencil (int stencil)
int getStencil ()
void setCheckByBoundingBoxVisitor (bool check)
bool isCheckByBoundingBoxVisitor ()
virtual BoundingBox getBoundingBox ()
virtual void addLayerParent (GlLayer *)
virtual void removeLayerParent (GlLayer *)
void addParent (GlComposite *composite)
void removeParent (GlComposite *composite)
- Public Member Functions inherited from tlp::GlEntity
virtual ~GlEntity ()

Protected Member Functions

virtual void addPoint (const Coord &point)
virtual void beginNewHole ()
void runTesselation ()
void createPolygon (const std::vector< Coord > &coords, int polygonEdgesType)
void startPrimitive (GLenum primitive)
void endPrimitive ()
void addVertex (const Coord &vertexCoord, const Vec2f &vertexTexCoord)
VERTEXallocateNewVertex ()

Protected Attributes

std::vector< std::vector< Coord > > polygonContours
std::vector< std::vector< Coord > > points
std::set< GLenum > primitivesSet
std::map< GLenum, std::vector
< Coord > > 
verticesMap
std::map< GLenum, std::vector
< Vec2f > > 
texCoordsMap
std::map< GLenum, std::vector
< int > > 
startIndicesMap
std::map< GLenum, std::vector
< int > > 
verticesCountMap
std::vector< VERTEX * > allocatedVertices
GLenum currentPrimitive
int nbPrimitiveVertices
int currentVector
bool outlined
Color fillColor
Color outlineColor
double outlineSize
std::string textureName
float textureZoom
- Protected Attributes inherited from tlp::GlSimpleEntity
bool visible
int stencil
bool checkByBoundingBoxVisitor
BoundingBox boundingBox
std::vector< GlComposite * > parents

Friends

void CALLBACK beginCallback (GLenum which, GLvoid *polygonData)
void CALLBACK errorCallback (GLenum errorCode)
void CALLBACK endCallback (GLvoid *polygonData)
void CALLBACK vertexCallback (GLvoid *vertex, GLvoid *polygonData)
void CALLBACK combineCallback (GLdouble coords[3], VERTEX *d[4], GLfloat w[4], VERTEX **dataOut, GLvoid *polygonData)

Detailed Description

Class to create a complex polygon (concave polygon or polygon with hole) If you want to create a complex polygon you have 4 constructors : Constructors with vector of coords : to create a complex polygon without hole

  • In this case you have two constructor : with and without outline color
  • You can create a polygon like this :
    vector <Coord> coords;
    coords.push_back(Coord(0,0,0));
    coords.push_back(Coord(10,0,0));
    coords.push_back(Coord(10,10,0));
    coords.push_back(Coord(0,10,0));
    GlComplexPolygon *complexPolygon=new GlComplexPolygon(coords,Color(255,0,0,255));
    layer->addGlEntity(complexPolygon,"complexPolygon");

Constructors with vector of vector of Coords : to create a complex polygon with hole

  • In this case you have two constructor : with and without outline color
  • The first vector of coords is the polygon and others vector are holes
  • You can create a polygon with hole like this :
    vector <vector <Coord> > coords;
    vector <Coord> polygon;
    vector <Coord> hole;
    polygon.push_back(Coord(0,0,0));
    polygon.push_back(Coord(10,0,0));
    polygon.push_back(Coord(10,10,0));
    polygon.push_back(Coord(0,10,0));
    hole.push_back(Coord(4,4,0));
    hole.push_back(Coord(6,4,0));
    hole.push_back(Coord(6,6,0));
    hole.push_back(Coord(4,6,0));
    coords.push_back(polygon);
    coords.push_back(hole);
    GlComplexPolygon *complexPolygon=new GlComplexPolygon(coords,Color(255,0,0,255));
    layer->addGlEntity(complexPolygon,"complexPolygon");

In constructors you can specify the polygon border style : polygonEdgesType parameter (0 -> straight lines, 1 -> catmull rom curves, 2 -> bezier curves) You can also specify the texture name if you want to create a textured complex polygon

In complex polygon you can add a smooth border : see activateQuadBorder(..) function And you can specify the texture zoom : see setTextureZoom(...) function

Constructor & Destructor Documentation

tlp::GlComplexPolygon::GlComplexPolygon ( )
inline

Default constructor

tlp::GlComplexPolygon::GlComplexPolygon ( const std::vector< Coord > &  coords,
Color  fcolor,
int  polygonEdgesType = 0,
const std::string &  textureName = "" 
)

Constructor with a vector of coords, a fill color, a polygon edges type(0 -> straight lines, 1 -> catmull rom curves, 2 -> bezier curves) and a textureName if you want

tlp::GlComplexPolygon::GlComplexPolygon ( const std::vector< Coord > &  coords,
Color  fcolor,
Color  ocolor,
int  polygonEdgesType = 0,
const std::string &  textureName = "" 
)

Constructor with a vector of coords, a fill color, an outline color, a polygon edges type(0 -> straight lines, 1 -> catmull rom curves, 2 -> bezier curves) and a textureName if you want

tlp::GlComplexPolygon::GlComplexPolygon ( const std::vector< std::vector< Coord > > &  coords,
Color  fcolor,
int  polygonEdgesType = 0,
const std::string &  textureName = "" 
)

Constructor with a vector of vector of coords (the first vector of coord is the polygon and others vectors are holes in polygon), a fill color, a polygon edges type(0 -> straight lines, 1 -> catmull rom curves, 2 -> bezier curves) and a textureName if you want

tlp::GlComplexPolygon::GlComplexPolygon ( const std::vector< std::vector< Coord > > &  coords,
Color  fcolor,
Color  ocolor,
int  polygonEdgesType = 0,
const std::string &  textureName = "" 
)

Constructor with a vector of vector of coords (the first vector of coord is the polygon and others vectors are holes in polygon), a fill color, an outline color a polygon edges type(0 -> straight lines, 1 -> catmull rom curves, 2 -> bezier curves) and a textureName if you want

virtual tlp::GlComplexPolygon::~GlComplexPolygon ( )
inlinevirtual

Member Function Documentation

virtual void tlp::GlComplexPolygon::addPoint ( const Coord &  point)
protectedvirtual

Add a new point in polygon

void tlp::GlComplexPolygon::addVertex ( const Coord &  vertexCoord,
const Vec2f &  vertexTexCoord 
)
protected
VERTEX* tlp::GlComplexPolygon::allocateNewVertex ( )
protected
virtual void tlp::GlComplexPolygon::beginNewHole ( )
protectedvirtual

Begin a new hole in the polygon

void tlp::GlComplexPolygon::createPolygon ( const std::vector< Coord > &  coords,
int  polygonEdgesType 
)
protected
virtual void tlp::GlComplexPolygon::draw ( float  lod,
Camera camera 
)
virtual

Draw the complex polygon

Implements tlp::GlSimpleEntity.

void tlp::GlComplexPolygon::endPrimitive ( )
protected
Color tlp::GlComplexPolygon::getFillColor ( )
inline

Get fill color of GlComplexPolygon

Color tlp::GlComplexPolygon::getOutlineColor ( )
inline

Get outline color of GlComplexPolygon

const std::vector<std::vector<Coord> >& tlp::GlComplexPolygon::getPolygonContours ( ) const

Returns the contours defining the polygon.

std::string tlp::GlComplexPolygon::getTextureName ( )

Get the textureName

float tlp::GlComplexPolygon::getTextureZoom ( )
inline

Get the texture zoom factor

virtual void tlp::GlComplexPolygon::getXML ( xmlNodePtr  rootNode)
virtual

Function to export data and type in XML

Implements tlp::GlSimpleEntity.

virtual void tlp::GlComplexPolygon::getXMLOnlyData ( xmlNodePtr  rootNode)
virtual

Function to export data in XML

void tlp::GlComplexPolygon::runTesselation ( )
protected
void tlp::GlComplexPolygon::setFillColor ( const Color &  color)
inline

Set fill color of GlComplexPolygon

void tlp::GlComplexPolygon::setOutlineColor ( const Color &  color)
inline

Set outline color of GlComplexPolygon

void tlp::GlComplexPolygon::setOutlineMode ( const bool  )

Set if the polygon is outlined or not

void tlp::GlComplexPolygon::setOutlineSize ( double  size)

Set size of outline

void tlp::GlComplexPolygon::setPolygonContour ( const std::vector< Coord > &  contour,
int  polygonEdgesType = 0 
)

Define polygon according to one contour and compute tesselation.

Use this method if your polygon is defined by one contour. This method resets any previously defined contours and recompute tesselation.

Parameters
contoura vector of tlp::Coord defining the contour.
polygonEdgesTypean integer determining the shape of the polygon edges (0 -> straight lines, 1 -> catmull rom curves, 2 -> bezier curves)
void tlp::GlComplexPolygon::setPolygonContours ( const std::vector< std::vector< Coord > > &  contours,
int  polygonEdgesType = 0 
)

Define polygon according to several contours and compute tesselation.

Use this method if your polygon is defined by several contours (e.g. polygon with holes). This method resets any previously defined contours and recompute tesselation.

Parameters
contoursa vector of vector of tlp::Coord defining the different contours.
polygonEdgesTypean integer determining the shape of the polygon edges (0 -> straight lines, 1 -> catmull rom curves, 2 -> bezier curves)
void tlp::GlComplexPolygon::setTextureName ( const std::string &  name)

Set the textureName

void tlp::GlComplexPolygon::setTextureZoom ( float  zoom)
inline

Set the texture zoom factor By default if you have a polygon with a size bigger than (1,1,0) the texture will be repeated If you want to don't have this texture repeat you have to modify texture zoom For example if you have a polygon with coords ((0,0,0),(5,0,0),(5,5,0),(0,5,0)) you can set texture zoom to 5. to don't have texture repeat

virtual void tlp::GlComplexPolygon::setWithXML ( xmlNodePtr  rootNode)
virtual

Function to set data with XML

Implements tlp::GlSimpleEntity.

void tlp::GlComplexPolygon::startPrimitive ( GLenum  primitive)
protected
virtual void tlp::GlComplexPolygon::translate ( const Coord &  mouvement)
virtual

Translate entity

Reimplemented from tlp::GlSimpleEntity.

Friends And Related Function Documentation

void CALLBACK beginCallback ( GLenum  which,
GLvoid *  polygonData 
)
friend
void CALLBACK combineCallback ( GLdouble  coords[3],
VERTEX d[4],
GLfloat  w[4],
VERTEX **  dataOut,
GLvoid *  polygonData 
)
friend
void CALLBACK endCallback ( GLvoid *  polygonData)
friend
void CALLBACK errorCallback ( GLenum  errorCode)
friend
void CALLBACK vertexCallback ( GLvoid *  vertex,
GLvoid *  polygonData 
)
friend

Member Data Documentation

std::vector<VERTEX *> tlp::GlComplexPolygon::allocatedVertices
protected
GLenum tlp::GlComplexPolygon::currentPrimitive
protected
int tlp::GlComplexPolygon::currentVector
protected
Color tlp::GlComplexPolygon::fillColor
protected
int tlp::GlComplexPolygon::nbPrimitiveVertices
protected
Color tlp::GlComplexPolygon::outlineColor
protected
bool tlp::GlComplexPolygon::outlined
protected
double tlp::GlComplexPolygon::outlineSize
protected
std::vector<std::vector<Coord> > tlp::GlComplexPolygon::points
protected
std::vector<std::vector<Coord> > tlp::GlComplexPolygon::polygonContours
protected
std::set<GLenum> tlp::GlComplexPolygon::primitivesSet
protected
std::map<GLenum, std::vector<int> > tlp::GlComplexPolygon::startIndicesMap
protected
std::map<GLenum, std::vector<Vec2f> > tlp::GlComplexPolygon::texCoordsMap
protected
std::string tlp::GlComplexPolygon::textureName
protected
float tlp::GlComplexPolygon::textureZoom
protected
std::map<GLenum, std::vector<int> > tlp::GlComplexPolygon::verticesCountMap
protected
std::map<GLenum, std::vector<Coord> > tlp::GlComplexPolygon::verticesMap
protected


Tulip Software by LaBRI Visualization Team    2001 - 2012