Référence de la classe GLamWire

#include <glamwire.h>

Graphe d'héritage de GLamWire:

Fonctions membres publiques
	GLamWire ()
	GLamWire (double pts, double vectors, int numSectors=100)
	GLamWire (double *pts, int numPtsCtrl, int numSectors=100)
	GLamWire (const GLamWire &obj)
	~GLamWire ()
GLamWire &	operator= (const GLamWire &obj)
void	create ()
void	setNumSectors (int numSectors)
int	numSectors () const
void	changeStartPoint (double *point)
void	changeEndPoint (double *point)
void	changeStartVector (double *vector)
void	changeEndVector (double *vector)
void	changeStartPoint (double x, double y, double z)
void	changeEndPoint (double x, double y, double z)
void	changeStartVector (double x, double y, double z)
void	changeEndVector (double x, double y, double z)

Description détaillée

Elément filaire 3D.

La classe GLamWire permet de définir des éléments filaires (fil électrique, tuyau pneumatique,...) construits soit par une courbe lisse de Bézier définie par ses points (x,y,z) d'extrémité et les vecteurs 3D en ces mêmes points, soit sous forme d'une enveloppe définie par une liste de sommets servant au tracé d'une courbe BSpline de degré 2.

La gestion de la section du fil est prise en charge par la classe de base GLamCurve3D. La section par défaut est de type circulaire de diamètre 0.1 avec 20 facettes (polygone régulier à 20 faces). Les méthodes setSection() permettent de redéfinir la section aussi bien en tant que polygone régulier qu'en tant que polygone quelconque défini par une liste de points ou par copie des points d'un objet GLamPolygon ou dérivé.

Propriétés

numSectors : nombre de segments de l'élément. (100 par défaut).

int numSectors () const ;
void setNumSectors (int numSectors ) ;

Exemple

// attributs

GLamWire*     wire1 ;
GLamWire*     wire2 ;
GLamWire*     wire3 ;
GLamWire*     wire4 ;
GLamWire*     wire[4] ;

// construction

double pts1[][3] = { {0,0,0}, {3,1,2}, {3,4,1}, {-2,6,2}, {0,9,1} } ;
wire1 = new GLamWire((double*)pts1, 5, 50 ) ;     // BSpline
wire1->setSection( 0.5, 30 );
wire1->setRoughMode() ;

wire2 = new GLamWire( *wire1 ) ;
wire2->setRoughMode( false ) ;
wire2->setNumSectors( 100 ) ;

double pts3[][3] = { {-2,-2,1}, {-5,4,3} } ;
double vec3[][3] = { {0,0,3}, {4,-1,2} } ;
wire3 = new GLamWire( (double*)pts3, (double*)vec3 ) ;  // Bézier
wire3->setSection( 0.8, 60 );

wire4 = new GLamWire( *wire3 ) ;
wire4->setColor(188, 238, 104, true ) ;
wire4->setClosed() ;

wire3->setNumSectors( 25 ) ;
wire3->setRoughMode() ;

double pts[][3] = { {0,0,2}, {3,10,1} } ;
double vec[][3] = { {0,3,0}, {0,-3,0} } ;
wire[0] =  new GLamWire( (double*)pts, (double*)vec ) ;
wire[0]->setSection(0.3, 60 ) ;
wire[0]->setColor(1.0, 0, 0 ) ;     // rouge

wire[1] = new GLamWire( *wire[0] ) ;
wire[1]->changeStartPoint(0.5,0,2 ) ;
wire[1]->changeEndPoint(4,10,1 ) ;
wire[1]->setColor(0, 0, 1.0 ) ;     // bleu

wire[2] = new GLamWire( *wire[0] ) ;
wire[2]->changeStartPoint(1,0,2 ) ;
wire[2]->changeEndPoint(5,10,1 ) ;
wire[2]->setColor(1.0, 1.0, 0 ) ;   // jaune

wire[3] = new GLamWire( *wire[2] ) ;
wire[3]->setSection(0.33, 6 ) ;
wire[3]->setColor(0, 1.0, 0 ) ;     // vert

// projection sur la scène

glPushMatrix() ;
  glPushMatrix() ;
    glTranslated(-4, -1, 0 ) ;
    wire1->draw() ;
    glTranslated(3, 0, 0 ) ;
    wire2->draw() ;
    glTranslated(-3, -3, 0 ) ;
    wire3->draw() ;
    glTranslated(3, 0, 0 ) ;
    wire4->draw() ;
  glPopMatrix() ;
  glTranslated(1, -6, 0 ) ;
  for (int i = 0 ; i < 4 ; i++ )  wire[i]->draw() ;
glPopMatrix() ;

Documentation des constructeurs et destructeur

GLamWire::GLamWire ( )

Constructeur par défaut.

Le constructeur par défaut crée un élément triangulaire de 10 segments de type Bézier , apparaissant sous sa forme fil de fer (wireframe). Cet état est révocable lors d'une modification dimensionnelle de l'objet ou par copie d'un autre objet de même classe (cf. sélecteur isDefault() de la classe de base).

GLamWire::GLamWire	(	double *	pts,
		double *	vectors,
		int	numSectors = `100`
	)

Construction de type courbe de Bézier. Les points (x,y,z) de départ et d'arrivée sont transmis par le tableau pts, les vecteurs (x,y,z) relatifs aux points de départ et d'arrivée par le tableau vectors. Le nombre de segments répartis équitablement le long de la courbe est fixé par numSectors.
Le mode ébauche (propriété roughMode) montre les vecteurs aux points de départ et d'arrivée.

GLamWire::GLamWire	(	double *	pts,
		int	numPtsCtrl,
		int	numSectors = `100`
	)

Construction par BSpline de degré 2. La liste des numPtsCtrl points de contrôle (x,y,z) est transmise par le tableau pts. Le nombre de segments répartis équitablement le long de la courbe est fixé par numSectors.
Les points extrèmes sont automatiquement doublés afin que la courbe passe par le premier et le dernier point.
Le mode ébauche (propriété roughMode) montre les points de contrôle reliés par des droites.

GLamWire::GLamWire ( const GLamWire & obj )

Constructeur de copie.

GLamWire::~GLamWire ( )

Destructeur.

Documentation des fonctions membres

void GLamWire::changeEndPoint	(	double	x,
		double	y,
		double	z
	)

Modification du point d'arrivée.

void GLamWire::changeEndPoint ( double * point )

Modification du point d'arrivée. Les coordonnées (x,y,z) du nouveau point sont transmis par le tableau point.

void GLamWire::changeEndVector	(	double	x,
		double	y,
		double	z
	)

Modification du vecteur relatif au point final.
Dans le cas d'une construction de type BSpline, c'est la position relative de l'avant dernier point par rapport au dernier qui est affectée.

void GLamWire::changeEndVector ( double * vector )

Modification du vecteur relatif au point final. Les valeurs (x,y,z) du nouveau vecteur sont transmises par le tableau vector.
Dans le cas d'une construction de type BSpline, c'est la position relative de l'avant dernier point par rapport au dernier qui est affectée.

void GLamWire::changeStartPoint	(	double	x,
		double	y,
		double	z
	)

Modification du point de départ.

void GLamWire::changeStartPoint ( double * point )

Modification du point de départ. Les coordonnées (x,y,z) du nouveau point sont transmis par le tableau point.

void GLamWire::changeStartVector	(	double	x,
		double	y,
		double	z
	)

Modification du vecteur relatif au point de départ.
Dans le cas d'une construction de type BSpline, c'est la position relative du deuxième point par rapport au premier qui est affectée.

void GLamWire::changeStartVector ( double * vector )

Modification du vecteur relatif au point de départ. Les valeurs (x,y,z) du nouveau vecteur sont transmises par le tableau vector.
Dans le cas d'une construction de type BSpline, c'est la position relative du deuxième point par rapport au premier qui est affectée.

void GLamWire::create ( ) [virtual]

Méthode de dessin utilisée par la classe de base pour générer la display list de l'objet. Les programmes clients ne doivent normalement pas invoquer directement cette méthode, mais préférer la méthode draw() qui exploite la primitive OpenGL glCallList() .

Réimplémentée à partir de GLamCurve3D.

int GLamWire::numSectors ( ) const [inline]

Propriété numSectors.

GLamWire & GLamWire::operator= ( const GLamWire & obj )

Surcharge de l'opérateur d'affectation.

void GLamWire::setNumSectors ( int numSectors )