Tulip  4.6.0
Better Visualization Through Research
tlp::GlComplexPolygon Class Reference

#include <GlComplexPolygon.h>

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

List of all members.

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="")
void activateQuadBorder (const float borderWidth, const Color &color, const std::string &texture="", const int position=1, const float texCoordFactor=1.f, const int polygonId=0)
void desactivateQuadBorder (const int polygonId=0)
virtual void draw (float lod, Camera *camera)
Color getFillColor () const
Color getOutlineColor () const
const std::vector< std::vector
< Coord > > & 
getPolygonSides () const
std::string getTextureName ()
float getTextureZoom ()
virtual void getXML (std::string &outString)
virtual void getXMLOnlyData (std::string &outString)
void setFillColor (const Color &color)
void setOutlineColor (const Color &color)
void setOutlineMode (const bool)
void setOutlineSize (double size)
void setTextureName (const std::string &name)
void setTextureZoom (float zoom)
virtual void setWithXML (const std::string &inString, unsigned int &currentPosition)
virtual void translate (const Coord &mouvement)

Protected Member Functions

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

Protected Attributes

std::vector< VERTEX * > allocatedVertices
GLenum currentPrimitive
int currentVector
Color fillColor
int nbPrimitiveVertices
Color outlineColor
bool outlined
double outlineSize
std::vector< std::vector< Coord > > points
std::vector< std::vector
< GLfloat > > 
pointsIdx
std::set< GLenum > primitivesSet
std::vector< bool > quadBorderActivated
std::vector< Color > quadBorderColor
std::vector< int > quadBorderPosition
std::vector< float > quadBorderTexFactor
std::vector< std::string > quadBorderTexture
std::vector< float > quadBorderWidth
std::map< GLenum, std::vector
< int > > 
startIndicesMap
std::map< GLenum, std::vector
< Vec2f > > 
texCoordsMap
std::string textureName
float textureZoom
std::map< GLenum, std::vector
< int > > 
verticesCountMap
std::map< GLenum, std::vector
< Coord > > 
verticesMap

Friends

void CALLBACK beginCallback (GLenum which, GLvoid *polygonData)
void CALLBACK combineCallback (GLdouble coords[3], VERTEX *d[4], GLfloat w[4], VERTEX **dataOut, GLvoid *polygonData)
void CALLBACK endCallback (GLvoid *polygonData)
void CALLBACK errorCallback (GLenum errorCode)
void CALLBACK vertexCallback (GLvoid *vertex, 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

Definition at line 104 of file GlComplexPolygon.h.


Constructor & Destructor Documentation

Default constructor.

Warning:
don't use this constructor if you want to create a complex polygon, see others constructors

Definition at line 117 of file GlComplexPolygon.h.

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.


Member Function Documentation

void tlp::GlComplexPolygon::activateQuadBorder ( const float  borderWidth,
const Color &  color,
const std::string &  texture = "",
const int  position = 1,
const float  texCoordFactor = 1.f,
const int  polygonId = 0 
)

Draw a thick (textured) border around the polygon.

The graphic card must support geometry shader to make this feature to work. The position parameter determines the way the border is drawn (depending on the polygon points ordering):

  • 0 : the border is drawn outside (or inside) the polygon
  • 1 : the border is centered on the polygon outline
  • 2 : the border is drawn inside (or outside) the polygon

The texCoordFactor parameter determines the way the texture is applied : if < 1, the texture will be expanded and > 1, the texture will be compressed The polygonId parameter determines on which contour of the polygon, the border will be applied

virtual void tlp::GlComplexPolygon::addPoint ( const Coord &  point) [protected, virtual]

Add a new point in polygon.

virtual void tlp::GlComplexPolygon::beginNewHole ( ) [protected, virtual]

Begin a new hole in the polygon.

void tlp::GlComplexPolygon::desactivateQuadBorder ( const int  polygonId = 0)

Desactivate the textured quad border.

virtual void tlp::GlComplexPolygon::draw ( float  lod,
Camera camera 
) [virtual]

Draw the complex polygon.

Implements tlp::GlSimpleEntity.

Color tlp::GlComplexPolygon::getFillColor ( ) const [inline]

Get fill color of GlComplexPolygon.

Definition at line 155 of file GlComplexPolygon.h.

Color tlp::GlComplexPolygon::getOutlineColor ( ) const [inline]

Get outline color of GlComplexPolygon.

Definition at line 169 of file GlComplexPolygon.h.

Get the textureName.

Get the texture zoom factor.

Definition at line 183 of file GlComplexPolygon.h.

virtual void tlp::GlComplexPolygon::getXML ( std::string &  outString) [virtual]

Function to export data and type outString (in XML format)

Implements tlp::GlSimpleEntity.

virtual void tlp::GlComplexPolygon::getXMLOnlyData ( std::string &  outString) [virtual]

Function to export data in outString (in XML format)

void tlp::GlComplexPolygon::setFillColor ( const Color &  color) [inline]

Set fill color of GlComplexPolygon.

Definition at line 162 of file GlComplexPolygon.h.

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

Set outline color of GlComplexPolygon.

Definition at line 176 of file GlComplexPolygon.h.

Set if the polygon is outlined or not.

Set size of outline.

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

Definition at line 194 of file GlComplexPolygon.h.

virtual void tlp::GlComplexPolygon::setWithXML ( const std::string &  inString,
unsigned int &  currentPosition 
) [virtual]

Function to set data with inString (in XML format)

Implements tlp::GlSimpleEntity.

virtual void tlp::GlComplexPolygon::translate ( const Coord &  mouvement) [virtual]

Translate entity.

 All Classes Files Functions Variables Enumerations Enumerator Properties