Mesh Class Reference

representation d'un objet / maillage. More...

#include <mesh.h>

Public Member Functions
construction.
	Mesh ()
	constructeur par defaut. More...
	Mesh (const GLenum primitives)
	constructeur. More...
int	create (const GLenum primitives)
	construit les objets openGL. More...
int	create (const GLenum primitives, const std::vector< vec3 > &positions)
	construit les objets openGL. a partir d'un ensemble de positions. More...
int	create (const GLenum primitives, const std::vector< vec3 > &positions, const std::vector< unsigned > &indices)
	construit les objets openGL. a partir d'un ensemble de positions indexees. More...
int	create (const GLenum primitives, const std::vector< vec3 > &positions, const std::vector< vec2 > &texcoords, const std::vector< vec3 > &normals, const std::vector< vec4 > &colors, const std::vector< unsigned > &indices)
	construit les objets openGL. a partir d'un ensemble de positions + attributs indexes. More...
void	release ()
	detruit les objets openGL. More...
description des attributs des sommets.
Mesh &	color (const vec4 &c)
	definit la couleur du prochain sommet. More...
Mesh &	color (const Color &c)
	definit la couleur du prochain sommet. More...
Mesh &	color (const float r, const float g, const float b, const float a=1)
	definit la couleur du prochain sommet. More...
Mesh &	normal (const vec3 &n)
	definit la normale du prochain sommet. More...
Mesh &	normal (const Vector &n)
	definit la normale du prochain sommet. More...
Mesh &	normal (const float x, const float y, const float z)
	definit la normale du prochain sommet. More...
Mesh &	texcoord (const vec2 &uv)
	definit les coordonnees de texture du prochain sommet. More...
Mesh &	texcoord (const float x, const float y)
	definit les coordonnees de texture du prochain sommet. More...
unsigned int	vertex (const vec3 &p)
	insere un sommet de position p, et ses attributs (s'ils sont definis par color(), texcoord(), normal()), dans l'objet. renvoie l'indice du sommet. More...
unsigned int	vertex (const Point &p)
	insere un sommet de position p, et ses attributs (s'ils sont definis par color(), texcoord(), normal()), dans l'objet. renvoie l'indice du sommet. More...
unsigned int	vertex (const float x, const float y, const float z)
	insere un sommet de position p, et ses attributs (s'ils sont definis par color(), texcoord(), normal()), dans l'objet. renvoie l'indice du sommet. More...
void	clear ()
	vide la description. More...
description de triangles indexes.
Mesh &	triangle (const unsigned int a, const unsigned int b, const unsigned int c)
Mesh &	triangle_last (const int a, const int b, const int c)
Mesh &	restart_strip ()
	demarre un nouveau strip. a utiliser avec un objet composes de GL_TRIANGLE_STRIP, doit aussi fonctionner avec GL_TRIANGLE_FAN, GL_LINE_STRIP, GL_LINE_LOOP, etc. More...
Mesh &	index (const int a)
modification des attributs des sommets.
Mesh &	color (const unsigned int id, const vec4 &c)
	modifie la couleur du sommet d'indice id. More...
Mesh &	color (const unsigned int id, const Color &c)
	modifie la couleur du sommet d'indice id. More...
Mesh &	color (const unsigned int id, const float r, const float g, const float b, const float a=1)
	modifie la couleur du sommet d'indice id. More...
Mesh &	normal (const unsigned int id, const vec3 &n)
	modifie la normale du sommet d'indice id. More...
Mesh &	normal (const unsigned int id, const Vector &n)
	modifie la normale du sommet d'indice id. More...
Mesh &	normal (const unsigned int id, const float x, const float y, const float z)
	modifie la normale du sommet d'indice id. More...
Mesh &	texcoord (const unsigned int id, const vec2 &uv)
	modifie les coordonnees du sommet d'indice id. More...
Mesh &	texcoord (const unsigned int id, const float x, const float y)
	modifie les coordonnees du sommet d'indice id. More...
void	vertex (const unsigned int id, const vec3 &p)
	modifie la position du sommet d'indice id. More...
void	vertex (const unsigned int id, const Point &p)
	modifie la position du sommet d'indice id. More...
void	vertex (const unsigned int id, const float x, const float y, const float z)
	modifie la position du sommet d'indice id. More...
description des matieres.
const Materials &	materials () const
	renvoie la description des matieres. More...
Materials &	materials ()
	renvoie la description des matieres. More...
void	materials (const Materials &materials)
	remplace la description des matieres. More...
const std::vector< unsigned int > &	material_indices () const
	renvoie les indices des matieres des triangles. More...
Mesh &	material (const unsigned int id)
	definit la matiere du prochain triangle. id est l'indice d'une matiere ajoutee dans materials(), cf la classe Materials. ne fonctionne que pour les primitives GL_TRIANGLES, indexees ou pas. More...
description des triangles d'un maillage.
int	triangle_count () const
	renvoie le nombre de triangles. More...
TriangleData	triangle (const unsigned int id) const
	renvoie un triangle. More...
int	triangle_material_index (const unsigned int id) const
	renvoie l'indice de la matiere d'un triangle. More...
const Material &	triangle_material (const unsigned int id) const
	renvoie la matiere d'un triangle. More...
std::vector< TriangleGroup >	groups ()
	renvoie les groupes de triangles de meme matiere. re-organise les triangles. permet d'afficher l'objet matiere par matiere. More...
std::vector< TriangleGroup >	groups (const std::vector< unsigned int > &triangle_properties)
	renvoie les groupes de triangles de meme 'propriete'. re-organise les triangles. More...
void	bounds (Point &pmin, Point &pmax) const
	renvoie min et max les coordonnees des extremites des positions des sommets de l'objet (boite englobante alignee sur les axes, aabb). More...
Color	default_color () const
	renvoie la couleur par defaut du mesh, utilisee si les sommets n'ont pas de couleur associee. More...
Mesh &	default_color (const Color &color)
	modifie la couleur par defaut, utilisee si les sommets n'ont pas de couleur associee. More...
manipulation des buffers d'attributs.
int	vertex_count () const
	renvoie le nombre de sommets. More...
int	index_count () const
	renvoie le nombre d'indices de sommets. More...
const float *	vertex_buffer () const
	renvoie l'adresse de la position du premier sommet. permet de construire les vertex buffers openGL. par convention, la position est un vec3, 3 GL_FLOAT. More...
std::size_t	vertex_buffer_size () const
	renvoie la longueur (en octets) du vertex buffer. More...
const float *	normal_buffer () const
	renvoie l'adresse de la normale du premier sommet. par convention, la normale est un vec3, 3 GL_FLOAT. More...
std::size_t	normal_buffer_size () const
	renvoie la longueur (en octets) du normal buffer. More...
const float *	texcoord_buffer () const
	renvoie l'adresse des coordonnees de textures du premier sommet. par convention, c'est un vec2, 2 GL_FLOAT. More...
std::size_t	texcoord_buffer_size () const
	renvoie la taille (en octets) du texcoord buffer. More...
const float *	color_buffer () const
	renvoie l'adresse de la couleur du premier sommet. par convention, la couleur est un vec4, 4 GL_FLOAT. More...
std::size_t	color_buffer_size () const
	renvoie la taille (en octets) du color buffer. More...
const void *	index_buffer () const
	renvoie l'adresse du premier indice du premier triangle. par convention c'est un uint, 1, GL_UNSIGNED_INT. More...
std::size_t	index_buffer_size () const
	renvoie la taille (en octets) de l'index buffer. More...
const std::vector< vec3 > &	positions () const
const std::vector< vec2 > &	texcoords () const
const std::vector< vec3 > &	normals () const
const std::vector< vec4 > &	colors () const
const std::vector< unsigned int > &	indices () const
bool	has_position () const
	verifie que les attributs sont decrits de maniere coherente. More...
bool	has_texcoord () const
bool	has_normal () const
bool	has_color () const
bool	has_material_index () const
GLenum	primitives () const
	renvoie le type de primitives. More...

gestion d'erreur.
bool	operator== (const Mesh &m) const
GLuint	create_buffers (const bool use_texcoord, const bool use_normal, const bool use_color, const bool use_material_index)
	construit les buffers et le vertex array object necessaires pour dessiner l'objet avec openGL. utilitaire. detruit par release( ). More...
void	draw (const GLuint program, const bool use_position, const bool use_texcoord, const bool use_normal, const bool use_color, const bool use_material_index)
	dessine l'objet avec un shader program. More...
void	draw (const int first, const int n, const GLuint program, const bool use_position, const bool use_texcoord, const bool use_normal, const bool use_color, const bool use_material_index)
	dessine une partie de l'objet avec un shader program. More...
static Mesh &	error ()

Detailed Description

representation d'un objet / maillage.

Definition at line 111 of file mesh.h.

Constructor & Destructor Documentation

Mesh() [1/2]

Mesh::Mesh ( )

inline

constructeur par defaut.

Definition at line 117 of file mesh.h.

            : m_positions(), m_texcoords(), m_normals(), m_colors(), m_indices(), 
        m_color(White()), m_primitives(GL_POINTS), m_vao(0), m_buffer(0), m_index_buffer(0), m_vertex_buffer_size(0), m_index_buffer_size(0), m_update_buffers(false) {}

Mesh() [2/2]

Mesh::Mesh ( const GLenum  primitives )

inline

constructeur.

Definition at line 121 of file mesh.h.

                                    : m_positions(), m_texcoords(), m_normals(), m_colors(), m_indices(), 
        m_color(White()), m_primitives(primitives), m_vao(0), m_buffer(0), m_index_buffer(0), m_vertex_buffer_size(0), m_index_buffer_size(0), m_update_buffers(false) {}

Member Function Documentation

create() [1/4]

int Mesh::create

(

const GLenum

primitives

)

construit les objets openGL.

Definition at line 16 of file mesh.cpp.

{
    m_primitives= primitives;
    return 0;
}

create() [2/4]

int Mesh::create	(	const GLenum	primitives,
		const std::vector< vec3 > &	positions
	)

construit les objets openGL. a partir d'un ensemble de positions.

Definition at line 22 of file mesh.cpp.

{
    clear();
    m_primitives= primitives;
    m_positions= positions;
    return 0;
}

create() [3/4]

int Mesh::create	(	const GLenum	primitives,
		const std::vector< vec3 > &	positions,
		const std::vector< unsigned > &	indices
	)

construit les objets openGL. a partir d'un ensemble de positions indexees.

Definition at line 30 of file mesh.cpp.

{
    clear();
    m_primitives= primitives;
    m_positions= positions;
    m_indices= indices;
    return 0;
}

create() [4/4]

int Mesh::create	(	const GLenum	primitives,
		const std::vector< vec3 > &	positions,
		const std::vector< vec2 > &	texcoords,
		const std::vector< vec3 > &	normals,
		const std::vector< vec4 > &	colors,
		const std::vector< unsigned > &	indices
	)

construit les objets openGL. a partir d'un ensemble de positions + attributs indexes.

Definition at line 39 of file mesh.cpp.

{
    clear();
    if(texcoords.size() > 0 && texcoords.size() != positions.size()) return -1;
    if(normals.size() > 0 && normals.size() != positions.size()) return -1;
    if(colors.size() > 0 && colors.size() != positions.size()) return -1;
    
    m_primitives= primitives;
    m_positions= positions;
    m_indices= indices;
    m_texcoords= texcoords;
    m_normals= normals;
    m_colors= colors;
    
    return 0;
}

release()

void Mesh::release

(

)

detruit les objets openGL.

Definition at line 62 of file mesh.cpp.

{
    printf("mesh release %d\n", m_vao);
    
    glDeleteVertexArrays(1, &m_vao);
    glDeleteBuffers(1, &m_buffer);
    glDeleteBuffers(1, &m_index_buffer);
}

color() [1/6]

Mesh & Mesh::color

(

const vec4 &

c

)

definit la couleur du prochain sommet.

Definition at line 78 of file mesh.cpp.

{
    if(m_colors.size() <= m_positions.size())
        m_colors.push_back(color);
    else
        m_colors.back()= color;
    m_update_buffers= true;
    return *this;
}

color() [2/6]

Mesh& Mesh::color ( const Color &  c )

inline

definit la couleur du prochain sommet.

Definition at line 147 of file mesh.h.

{ return color(vec4(c.r, c.g, c.b, c.a)); }

color() [3/6]

Mesh& Mesh::color ( const float  r, const float  g, const float  b, const float  a = 1  )

inline

definit la couleur du prochain sommet.

Definition at line 149 of file mesh.h.

{ return color(vec4(r, g, b, a)); }

normal() [1/6]

Mesh & Mesh::normal

(

const vec3 &

n

)

definit la normale du prochain sommet.

Definition at line 88 of file mesh.cpp.

{
    if(m_normals.size() <= m_positions.size())
        m_normals.push_back(normal);
    else
        m_normals.back()= normal;
    m_update_buffers= true;
    return *this;
}

normal() [2/6]

Mesh& Mesh::normal ( const Vector &  n )

inline

definit la normale du prochain sommet.

Definition at line 154 of file mesh.h.

{ return normal(vec3(n)); }

normal() [3/6]

Mesh& Mesh::normal ( const float  x, const float  y, const float  z  )

inline

definit la normale du prochain sommet.

Definition at line 156 of file mesh.h.

{ return normal(vec3(x, y, z)); }

texcoord() [1/4]

Mesh & Mesh::texcoord

(

const vec2 &

uv

)

definit les coordonnees de texture du prochain sommet.

Definition at line 98 of file mesh.cpp.

{
    if(m_texcoords.size() <= m_positions.size())
        m_texcoords.push_back(uv);
    else
        m_texcoords.back()= uv;
    m_update_buffers= true;
    return *this;
}

texcoord() [2/4]

Mesh& Mesh::texcoord ( const float  x, const float  y  )

inline

definit les coordonnees de texture du prochain sommet.

Definition at line 161 of file mesh.h.

{ return texcoord(vec2(x, y)); }

vertex() [1/6]

unsigned int Mesh::vertex

(

const vec3 &

p

)

insere un sommet de position p, et ses attributs (s'ils sont definis par color(), texcoord(), normal()), dans l'objet. renvoie l'indice du sommet.

Definition at line 109 of file mesh.cpp.

{
    m_update_buffers= true;
    m_positions.push_back(position);
 
    // copie les autres attributs du sommet, uniquement s'ils sont definis
    if(m_texcoords.size() > 0 && m_texcoords.size() != m_positions.size())
        m_texcoords.push_back(m_texcoords.back());
    if(m_normals.size() > 0 && m_normals.size() != m_positions.size())
        m_normals.push_back(m_normals.back());
    if(m_colors.size() > 0 && m_colors.size() != m_positions.size())
        m_colors.push_back(m_colors.back());
 
    // copie la matiere courante, uniquement si elle est definie
    if(m_triangle_materials.size() > 0 && int(m_triangle_materials.size()) < triangle_count())
        m_triangle_materials.push_back(m_triangle_materials.back());
    
    unsigned int index= m_positions.size() -1;
    // construction de l'index buffer pour les strip
    switch(m_primitives)
    {
        case GL_LINE_STRIP:
        case GL_LINE_LOOP:
        case GL_TRIANGLE_STRIP:
        case GL_TRIANGLE_FAN:
            m_indices.push_back(index);
            break;
        default:
            break;
    }
 
    // renvoie l'indice du sommet
    return index;
}

vertex() [2/6]

unsigned int Mesh::vertex ( const Point &  p )

inline

insere un sommet de position p, et ses attributs (s'ils sont definis par color(), texcoord(), normal()), dans l'objet. renvoie l'indice du sommet.

Definition at line 166 of file mesh.h.

{ return vertex(vec3(p)); }

vertex() [3/6]

unsigned int Mesh::vertex ( const float  x, const float  y, const float  z  )

inline

insere un sommet de position p, et ses attributs (s'ils sont definis par color(), texcoord(), normal()), dans l'objet. renvoie l'indice du sommet.

Definition at line 168 of file mesh.h.

{ return vertex(vec3(x, y, z)); }

clear()

void Mesh::clear

(

)

vide la description.

Definition at line 176 of file mesh.cpp.

{
    m_update_buffers= true;
    
    m_positions.clear();
    m_texcoords.clear();
    m_normals.clear();
    m_colors.clear();
    m_indices.clear();
    //~ m_materials.clear();
    m_triangle_materials.clear();
}

triangle() [1/2]

Mesh & Mesh::triangle	(	const unsigned int	a,
		const unsigned int	b,
		const unsigned int	c
	)

insere un triangle. a, b, c sont les indices des sommets deja inseres dans l'objet. ne fonctionne pas avec les strips et les fans.

Mesh m(GL_TRIANGLES);
unsigned int a= m.vertex( Point(ax, ay, az) );
unsigned int b= m.vertex( Point(bx, by, bz) );
unsigned int c= m.vertex( Point(cx, cy, cz) );
m.triangle(a, b, c);

Definition at line 190 of file mesh.cpp.

{
    assert(a < m_positions.size());
    assert(b < m_positions.size());
    assert(c < m_positions.size());
    m_update_buffers= true;
    m_indices.push_back(a);
    m_indices.push_back(b);
    m_indices.push_back(c);
    
    // copie la matiere courante, uniquement si elle est definie
    if(m_triangle_materials.size() > 0 && int(m_triangle_materials.size()) < triangle_count())
        m_triangle_materials.push_back(m_triangle_materials.back());
    
    m_update_buffers= true;
    return *this;
}

triangle_last()

Mesh & Mesh::triangle_last	(	const int	a,
		const int	b,
		const int	c
	)

insere un triangle, a, b, c sont les indices des sommets deja inseres dans l'objet, en comptant en partant du dernier. ne fonctionne pas avec les strips et les fans.

Mesh m(GL_TRIANGLES);
m.vertex( Point(ax, ay, az) );
m.vertex( Point(bx, by, bz) );
m.vertex( Point(cx, cy, cz) );
m.triangle_last(-3, -2, -1);

Definition at line 208 of file mesh.cpp.

{
    assert(a < 0);
    assert(b < 0);
    assert(c < 0);
    m_update_buffers= true;
    m_indices.push_back(int(m_positions.size()) + a);
    m_indices.push_back(int(m_positions.size()) + b);
    m_indices.push_back(int(m_positions.size()) + c);
    
    // copie la matiere courante, uniquement si elle est definie
    if(m_triangle_materials.size() > 0 && int(m_triangle_materials.size()) < triangle_count())
        m_triangle_materials.push_back(m_triangle_materials.back());
    
    m_update_buffers= true;
    return *this;
}

restart_strip()

Mesh & Mesh::restart_strip

(

)

demarre un nouveau strip. a utiliser avec un objet composes de GL_TRIANGLE_STRIP, doit aussi fonctionner avec GL_TRIANGLE_FAN, GL_LINE_STRIP, GL_LINE_LOOP, etc.

Definition at line 226 of file mesh.cpp.

{
    m_update_buffers= true;
    m_indices.push_back(~0u);   // ~0u plus grand entier non signe representable, ou UINT_MAX...
#if 1
    glPrimitiveRestartIndex(~0u);
    glEnable(GL_PRIMITIVE_RESTART);
#else
    glEnable(GL_PRIMITIVE_RESTART_FIXED_INDEX); // n'existe pas sur mac ?!
#endif
    return *this;
}

index()

Mesh & Mesh::index

(

const int

a

)

insere un indice de sommet.

Mesh m(GL_TRIANGLES);
unsigned int a= m.vertex( Point(ax, ay, az) );
unsigned int b= m.vertex( Point(bx, by, bz) );
unsigned int c= m.vertex( Point(cx, cy, cz) );
 
// insere le triangle abc
m.index(a);
m.index(b);
m.index(c);

Definition at line 239 of file mesh.cpp.

{
    if(a < 0)
        m_indices.push_back(int(m_positions.size()) + a);
    else if(a < int(m_positions.size()))
        m_indices.push_back(a);
    else
    {
        printf("[error] Mesh::index(): invalid index...\n");
        return *this;   // erreur
    }
    
    // copie la matiere courante, uniquement si elle est definie
    if(m_triangle_materials.size() > 0 && int(m_triangle_materials.size()) < triangle_count())
        m_triangle_materials.push_back(m_triangle_materials.back());
    
    m_update_buffers= true;
    return *this;
}

color() [4/6]

Mesh & Mesh::color	(	const unsigned int	id,
		const vec4 &	c
	)

modifie la couleur du sommet d'indice id.

Definition at line 145 of file mesh.cpp.

{
    assert(id < m_colors.size());
    m_update_buffers= true;
    m_colors[id]= c;
    return *this;
}

color() [5/6]

Mesh& Mesh::color ( const unsigned int  id, const Color &  c  )

inline

modifie la couleur du sommet d'indice id.

Definition at line 222 of file mesh.h.

{ return color(id, vec4(c.r, c.g, c.b, c.a)); }

color() [6/6]

Mesh& Mesh::color ( const unsigned int  id, const float  r, const float  g, const float  b, const float  a = 1  )

inline

modifie la couleur du sommet d'indice id.

Definition at line 224 of file mesh.h.

{ return color(id, vec4(r, g, b, a)); }

normal() [4/6]

Mesh & Mesh::normal	(	const unsigned int	id,
		const vec3 &	n
	)

modifie la normale du sommet d'indice id.

Definition at line 153 of file mesh.cpp.

{
    assert(id < m_normals.size());
    m_update_buffers= true;
    m_normals[id]= n;
    return *this;
}

normal() [5/6]

Mesh& Mesh::normal ( const unsigned int  id, const Vector &  n  )

inline

modifie la normale du sommet d'indice id.

Definition at line 229 of file mesh.h.

{ return normal(id, vec3(n)); }

normal() [6/6]

Mesh& Mesh::normal ( const unsigned int  id, const float  x, const float  y, const float  z  )

inline

modifie la normale du sommet d'indice id.

Definition at line 231 of file mesh.h.

{ return normal(id, vec3(x, y, z)); }

texcoord() [3/4]

Mesh & Mesh::texcoord	(	const unsigned int	id,
		const vec2 &	uv
	)

modifie les coordonnees du sommet d'indice id.

Definition at line 161 of file mesh.cpp.

{
    assert(id < m_texcoords.size());
    m_update_buffers= true;
    m_texcoords[id]= uv;
    return *this;
}

texcoord() [4/4]

Mesh& Mesh::texcoord ( const unsigned int  id, const float  x, const float  y  )

inline

modifie les coordonnees du sommet d'indice id.

Definition at line 236 of file mesh.h.

{ return texcoord(id, vec2(x, y)); }

vertex() [4/6]

void Mesh::vertex	(	const unsigned int	id,
		const vec3 &	p
	)

modifie la position du sommet d'indice id.

Definition at line 169 of file mesh.cpp.

{
    assert(id < m_positions.size());
    m_update_buffers= true;
    m_positions[id]= p;
}

vertex() [5/6]

void Mesh::vertex ( const unsigned int  id, const Point &  p  )

inline

modifie la position du sommet d'indice id.

Definition at line 241 of file mesh.h.

{ vertex(id, vec3(p)); }

vertex() [6/6]

void Mesh::vertex ( const unsigned int  id, const float  x, const float  y, const float  z  )

inline

modifie la position du sommet d'indice id.

Definition at line 243 of file mesh.h.

{ vertex(id, vec3(x, y, z)); }

materials() [1/3]

const Materials & Mesh::materials

(

)

const

renvoie la description des matieres.

Definition at line 265 of file mesh.cpp.

{
    return m_materials;
}

materials() [2/3]

Materials & Mesh::materials

(

)

renvoie la description des matieres.

Definition at line 260 of file mesh.cpp.

{
    return m_materials;
}

materials() [3/3]

void Mesh::materials

(

const Materials &

materials

)

remplace la description des matieres.

Definition at line 270 of file mesh.cpp.

{
    m_materials= materials;
}

material_indices()

const std::vector< unsigned int > & Mesh::material_indices

(

)

const

renvoie les indices des matieres des triangles.

Definition at line 285 of file mesh.cpp.

{
    return m_triangle_materials;
}

material()

Mesh & Mesh::material

(

const unsigned int

id

)

definit la matiere du prochain triangle. id est l'indice d'une matiere ajoutee dans materials(), cf la classe Materials. ne fonctionne que pour les primitives GL_TRIANGLES, indexees ou pas.

Definition at line 275 of file mesh.cpp.

{
    if(int(m_triangle_materials.size()) <= triangle_count())
        m_triangle_materials.push_back(id);
    else
        m_triangle_materials.back()= id;
    m_update_buffers= true;
    return *this;
}

triangle_count()

int Mesh::triangle_count

(

)

const

renvoie le nombre de triangles.

Definition at line 433 of file mesh.cpp.

{
    if(m_primitives != GL_TRIANGLES)
        return 0;
    
    if(m_indices.size() > 0)
        return int(m_indices.size() / 3);
    else
        return int(m_positions.size() / 3);
}

triangle() [2/2]

TriangleData Mesh::triangle

(

const unsigned int

id

)

const

renvoie un triangle.

Definition at line 444 of file mesh.cpp.

{
    unsigned int a, b, c;
    if(m_indices.size() > 0)
    {
        assert((size_t) id*3+2 < m_indices.size());
        a= m_indices[id*3];
        b= m_indices[id*3 +1];
        c= m_indices[id*3 +2];
    }
    else
    {
        assert((size_t) id*3+2 < m_positions.size());
        a= id*3;
        b= id*3 +1;
        c= id*3 +2;
    }
    
    TriangleData triangle;
    triangle.a= m_positions[a];
    triangle.b= m_positions[b];
    triangle.c= m_positions[c];
    
    if(m_normals.size() == m_positions.size())
    {
        triangle.na= m_normals[a];
        triangle.nb= m_normals[b];
        triangle.nc= m_normals[c];
    }
    else
    {
        // calculer la normale geometrique
        Vector ab= Point(m_positions[b]) - Point(m_positions[a]);
        Vector ac= Point(m_positions[c]) - Point(m_positions[a]);
        Vector n= normalize(cross(ab, ac));
        triangle.na= vec3(n);
        triangle.nb= vec3(n);
        triangle.nc= vec3(n);
    }
    
    if(m_texcoords.size() == m_positions.size())
    {
        triangle.ta= m_texcoords[a];
        triangle.tb= m_texcoords[b];
        triangle.tc= m_texcoords[c];
    }
    else
    {
        // coordonnees barycentriques des sommets, convention p(u, v)= w*a + u*b + v*c, avec w= 1 - u -v
        triangle.ta= vec2(0, 0);        // w= 1
        triangle.tb= vec2(1, 0);        // w= 0
        triangle.tc= vec2(0, 1);        // w= 0
    }
    
    return triangle;
}

triangle_material_index()

int Mesh::triangle_material_index

(

const unsigned int

id

)

const

renvoie l'indice de la matiere d'un triangle.

Definition at line 290 of file mesh.cpp.

{
    assert((size_t) id < m_triangle_materials.size());
    return m_triangle_materials[id];
}

triangle_material()

const Material & Mesh::triangle_material

(

const unsigned int

id

)

const

renvoie la matiere d'un triangle.

Definition at line 296 of file mesh.cpp.

{
    assert((size_t) id < m_triangle_materials.size());
    return m_materials.material(m_triangle_materials[id]);
}

groups() [1/2]

std::vector< TriangleGroup > Mesh::groups

(

)

renvoie les groupes de triangles de meme matiere. re-organise les triangles. permet d'afficher l'objet matiere par matiere.

Definition at line 303 of file mesh.cpp.

{
    return groups(m_triangle_materials);
}

groups() [2/2]

std::vector< TriangleGroup > Mesh::groups

(

const std::vector< unsigned int > &

triangle_properties

)

renvoie les groupes de triangles de meme 'propriete'. re-organise les triangles.

Definition at line 308 of file mesh.cpp.

{
    if(m_primitives != GL_TRIANGLES)
        return {};
    
    // pas le bon nombre d'infos, renvoyer un seul groupe
    if(int(triangle_properties.size()) != triangle_count())
    {
        if(m_indices.size())
            return { {0, 0, int(m_indices.size())} };
        else
            return { {0, 0, int(m_positions.size())} };
    }
    
    // trie les triangles
    std::vector<int> remap(triangle_count());
    for(unsigned i= 0; i < remap.size(); i++)
        remap[i]= i;
 
    struct triangle_sort
    {
        const std::vector<unsigned int>& properties;
        
        triangle_sort( const std::vector<unsigned int>& _properties ) : properties(_properties) {}
        
        bool operator() ( const int& a, const int& b ) const
        {
            return properties[a] < properties[b];
        }
    };
    
    std::stable_sort(remap.begin(), remap.end(), triangle_sort(triangle_properties));
    
    // re-organise les triangles, et construit les groupes
    std::vector<TriangleGroup> groups;
    if(m_indices.size())
    {
        int first= 0;
        int property_id= triangle_properties[remap[0]];
        
        // re-organise l'index buffer...
        std::vector<unsigned int> indices;
        std::vector<unsigned int> material_indices;
        for(unsigned i= 0; i < remap.size(); i++)
        {
            int id= triangle_properties[remap[i]];
            if(id != property_id)
            {
                groups.push_back( {property_id, first, int(3*i) - first} );
                first= 3*i;
                property_id= id;
            }
            
            indices.push_back(m_indices[3*remap[i]]);
            indices.push_back(m_indices[3*remap[i]+1]);
            indices.push_back(m_indices[3*remap[i]+2]);
            
            material_indices.push_back(m_triangle_materials[remap[i]]);
        }
        
        // dernier groupe
        groups.push_back( {property_id, first, int(3 * remap.size()) - first} );
        
        std::swap(m_indices, indices);
        std::swap(m_triangle_materials, material_indices);
    }
    else
    {
        int first= 0;
        int property_id= triangle_properties[remap[0]];
        
        // re-organise les attributs !!
        std::vector<vec3> positions;
        std::vector<vec2> texcoords;
        std::vector<vec3> normals;
        std::vector<vec4> colors;
        std::vector<unsigned int> material_indices;
        for(unsigned i= 0; i < remap.size(); i++)
        {
            int id= triangle_properties[remap[i]];
            if(id != property_id)
            {
                groups.push_back( {property_id, first, int(3*i) - first} );
                first= 3*i;
                property_id= id;
            }
            
            positions.push_back(m_positions[3*remap[i]]);
            positions.push_back(m_positions[3*remap[i]+1]);
            positions.push_back(m_positions[3*remap[i]+2]);
            if(has_texcoord())
            {
                texcoords.push_back(m_texcoords[3*remap[i]]);
                texcoords.push_back(m_texcoords[3*remap[i]+1]);
                texcoords.push_back(m_texcoords[3*remap[i]+2]);
            }
            if(has_normal())
            {
                normals.push_back(m_normals[3*remap[i]]);
                normals.push_back(m_normals[3*remap[i]+1]);
                normals.push_back(m_normals[3*remap[i]+2]);
            }
            if(has_color())
            {
                colors.push_back(m_colors[3*remap[i]]);
                colors.push_back(m_colors[3*remap[i]+1]);
                colors.push_back(m_colors[3*remap[i]+2]);
            }
            
            material_indices.push_back(m_triangle_materials[remap[i]]);
        }
        
        // dernier groupe
        groups.push_back( {property_id, first, int(3 * remap.size()) - first} );
        
        std::swap(m_positions, positions);
        std::swap(m_texcoords, texcoords);
        std::swap(m_normals, normals);
        std::swap(m_colors, colors);
        std::swap(m_triangle_materials, material_indices);
    }
    
    return groups;
}

bounds()

void Mesh::bounds	(	Point &	pmin,
		Point &	pmax
	)		const

renvoie min et max les coordonnees des extremites des positions des sommets de l'objet (boite englobante alignee sur les axes, aabb).

Definition at line 501 of file mesh.cpp.

{
    if(m_positions.size() < 1)
        return;
 
    pmin= Point(m_positions[0]);
    pmax= pmin;
 
    for(unsigned i= 1; i < m_positions.size(); i++)
    {
        vec3 p= m_positions[i];
        pmin= Point( std::min(pmin.x, p.x), std::min(pmin.y, p.y), std::min(pmin.z, p.z) );
        pmax= Point( std::max(pmax.x, p.x), std::max(pmax.y, p.y), std::max(pmax.z, p.z) );
    }
}

default_color() [1/2]

Color Mesh::default_color ( ) const

inline

renvoie la couleur par defaut du mesh, utilisee si les sommets n'ont pas de couleur associee.

Definition at line 284 of file mesh.h.

{ return m_color; }

default_color() [2/2]

Mesh & Mesh::default_color

(

const Color &

color

)

modifie la couleur par defaut, utilisee si les sommets n'ont pas de couleur associee.

Definition at line 72 of file mesh.cpp.

{
    m_color= color;
    return *this;
}

vertex_count()

int Mesh::vertex_count ( ) const

inline

renvoie le nombre de sommets.

Definition at line 291 of file mesh.h.

{ return (int) m_positions.size(); }

index_count()

int Mesh::index_count ( ) const

inline

renvoie le nombre d'indices de sommets.

Definition at line 293 of file mesh.h.

{ return (int) m_indices.size(); }

vertex_buffer()

const float* Mesh::vertex_buffer ( ) const

inline

renvoie l'adresse de la position du premier sommet. permet de construire les vertex buffers openGL. par convention, la position est un vec3, 3 GL_FLOAT.

Definition at line 296 of file mesh.h.

{ return &m_positions.front().x; }

vertex_buffer_size()

std::size_t Mesh::vertex_buffer_size ( ) const

inline

renvoie la longueur (en octets) du vertex buffer.

Definition at line 298 of file mesh.h.

{ return m_positions.size() * sizeof(vec3); }

normal_buffer()

const float* Mesh::normal_buffer ( ) const

inline

renvoie l'adresse de la normale du premier sommet. par convention, la normale est un vec3, 3 GL_FLOAT.

Definition at line 301 of file mesh.h.

{ return &m_normals.front().x; }

normal_buffer_size()

std::size_t Mesh::normal_buffer_size ( ) const

inline

renvoie la longueur (en octets) du normal buffer.

Definition at line 303 of file mesh.h.

{ return m_normals.size() * sizeof(vec3); }

texcoord_buffer()

const float* Mesh::texcoord_buffer ( ) const

inline

renvoie l'adresse des coordonnees de textures du premier sommet. par convention, c'est un vec2, 2 GL_FLOAT.

Definition at line 306 of file mesh.h.

{ return &m_texcoords.front().x; }

texcoord_buffer_size()

std::size_t Mesh::texcoord_buffer_size ( ) const

inline

renvoie la taille (en octets) du texcoord buffer.

Definition at line 308 of file mesh.h.

{ return m_texcoords.size() * sizeof(vec2); }

color_buffer()

const float* Mesh::color_buffer ( ) const

inline

renvoie l'adresse de la couleur du premier sommet. par convention, la couleur est un vec4, 4 GL_FLOAT.

Definition at line 311 of file mesh.h.

{ return &m_colors.front().x; }

color_buffer_size()

std::size_t Mesh::color_buffer_size ( ) const

inline

renvoie la taille (en octets) du color buffer.

Definition at line 313 of file mesh.h.

{ return m_colors.size() * sizeof(vec4); }

index_buffer()

const void* Mesh::index_buffer ( ) const

inline

renvoie l'adresse du premier indice du premier triangle. par convention c'est un uint, 1, GL_UNSIGNED_INT.

Definition at line 316 of file mesh.h.

{ return &m_indices.front(); }

index_buffer_size()

std::size_t Mesh::index_buffer_size ( ) const

inline

renvoie la taille (en octets) de l'index buffer.

Definition at line 318 of file mesh.h.

{ return m_indices.size() * sizeof(unsigned int); }

has_position()

bool Mesh::has_position ( ) const

inline

verifie que les attributs sont decrits de maniere coherente.

Definition at line 328 of file mesh.h.

{ return !m_positions.empty(); }

primitives()

GLenum Mesh::primitives ( ) const

inline

renvoie le type de primitives.

Definition at line 336 of file mesh.h.

{ return m_primitives; }

error()

static Mesh& Mesh::error ( )

inlinestatic

sentinelle pour la gestion d'erreur lors du chargement d'un fichier. exemple :

Mesh mesh= read_mesh("data/bigguy.obj");
if(mesh == Mesh::error())
    return "erreur de chargement";

Definition at line 348 of file mesh.h.

    {
        static Mesh mesh;
        return mesh;
    }

create_buffers()

GLuint Mesh::create_buffers	(	const bool	use_texcoord,
		const bool	use_normal,
		const bool	use_color,
		const bool	use_material_index
	)

construit les buffers et le vertex array object necessaires pour dessiner l'objet avec openGL. utilitaire. detruit par release( ).

Definition at line 579 of file mesh.cpp.

{
    if(m_positions.size() == 0)
        return 0;
 
#if 1
    if(use_texcoord && !has_texcoord())
        printf("[oops] mesh: no texcoord array...\n");
    if(use_normal && !has_normal())
        printf("[oops] mesh: no normal array...\n");
    if(use_color && !has_color())
        printf("[oops] mesh: no color array...\n");
    if(use_material_index && !has_material_index())
        printf("[oops] mesh: no material index array...\n");
#endif
    
    if(m_vao)
        // c'est deja fait...
        return m_vao;
   
    // configuration du format de sommet
    glGenVertexArrays(1, &m_vao);
    glBindVertexArray(m_vao);
    
    // determine la taille du buffer pour stocker tous les attributs et les indices
    m_vertex_buffer_size= vertex_buffer_size();
    if(use_texcoord && has_texcoord())
        m_vertex_buffer_size+= texcoord_buffer_size();
    if(use_normal && has_normal())
        m_vertex_buffer_size+= normal_buffer_size();
    if(use_color && has_color())
        m_vertex_buffer_size+= color_buffer_size();
    if(use_material_index && has_material_index())
        m_vertex_buffer_size+= m_positions.size() * sizeof(unsigned char);
    
    // alloue le buffer
    glGenBuffers(1, &m_buffer);
    glBindBuffer(GL_ARRAY_BUFFER, m_buffer);
    glBufferData(GL_ARRAY_BUFFER, m_vertex_buffer_size, nullptr, GL_STATIC_DRAW);
    
    // index buffer
    m_index_buffer_size= index_buffer_size();
    if(m_index_buffer_size)
    {
        glGenBuffers(1, &m_index_buffer);    
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_index_buffer);
        glBufferData(GL_ELEMENT_ARRAY_BUFFER, m_index_buffer_size, index_buffer(), GL_STATIC_DRAW);
    }
 
    // transfere les donnees dans les buffers
    update_buffers(use_texcoord,  use_normal, use_color, use_material_index);
    
    return m_vao;
}

draw() [1/2]

void Mesh::draw	(	const GLuint	program,
		const bool	use_position,
		const bool	use_texcoord,
		const bool	use_normal,
		const bool	use_color,
		const bool	use_material_index
	)

dessine l'objet avec un shader program.

Definition at line 768 of file mesh.cpp.

{
    if(m_indices.size())
        draw(0, int(m_indices.size()), program, use_position, use_texcoord, use_normal, use_color, use_material_index);
    else
        draw(0, int(m_positions.size()), program, use_position, use_texcoord, use_normal, use_color, use_material_index);
}

draw() [2/2]

void Mesh::draw	(	const int	first,
		const int	n,
		const GLuint	program,
		const bool	use_position,
		const bool	use_texcoord,
		const bool	use_normal,
		const bool	use_color,
		const bool	use_material_index
	)

dessine une partie de l'objet avec un shader program.

Definition at line 776 of file mesh.cpp.

{
    if(program == 0)
    {
        printf("[oops]  no program... can't draw !!\n");
        return;
    }
    
    // transfere toutes les donnees disponibles (et correctement definies)
    // le meme mesh peut etre dessine avec plusieurs shaders utilisant des attributs differents... 
    if(m_vao == 0)
        create_buffers(has_texcoord(), has_normal(), has_color(), has_material_index());
    assert(m_vao != 0);
    
    if(m_update_buffers)
        update_buffers(has_texcoord(), has_normal(), has_color(), has_material_index());
    
    glBindVertexArray(m_vao);
    
    #ifndef GK_RELEASE
    {
        char label[2048]= { 0 };
        #ifdef GL_VERSION_4_3
        {
            char tmp[1024];
            glGetObjectLabel(GL_PROGRAM, program, sizeof(tmp), nullptr, tmp);
            sprintf(label, "program( %u '%s' )", program, tmp);
        }
        #else
            sprintf(label, "program( %u )", program); 
        #endif
        
        // verifie que le program est selectionne
        GLuint current;
        glGetIntegerv(GL_CURRENT_PROGRAM, (GLint *) &current);
        if(current != program)
            printf("[oops] %s: not active... undefined draw !!\n", label); 
        
        // verifie que les attributs necessaires a l'execution du shader sont presents dans le mesh...
        // etape 1 : recuperer le nombre d'attributs
        GLint n= 0;
        glGetProgramiv(program, GL_ACTIVE_ATTRIBUTES, &n);
        
        // etape 2 : recuperer les infos de chaque attribut
        char name[1024];
        for(int index= 0; index < n; index++)
        {
            GLint glsl_size;
            GLenum glsl_type;
            glGetActiveAttrib(program, index, sizeof(name), nullptr, &glsl_size, &glsl_type, name);
            
            GLint location= glGetAttribLocation(program, name);
            if(location == 0)       // attribut position necessaire a l'execution du shader
            {
                if(!use_position || !has_position())
                    printf("[oops] position attribute '%s' in %s: no data... undefined draw !!\n", name, label);
                if(glsl_size != 1 || glsl_type != GL_FLOAT_VEC3)
                    printf("[oops] position attribute '%s' is not declared as a vec3 in %s... undefined draw !!\n", name, label);
            }
            else if(location == 1)  // attribut texcoord necessaire 
            {
                if(!use_texcoord || !has_texcoord())
                    printf("[oops] texcoord attribute '%s' in %s: no data... undefined draw !!\n", name, label);
                if(glsl_size != 1 || glsl_type != GL_FLOAT_VEC2)
                    printf("[oops] texcoord attribute '%s' is not declared as a vec2 in %s... undefined draw !!\n", name, label);
            }
            else if(location == 2)  // attribut normal necessaire
            {
                if(!use_normal || !has_normal())
                    printf("[oops] normal attribute '%s' in %s: no data... undefined draw !!\n", name, label);
                if(glsl_size != 1 || glsl_type != GL_FLOAT_VEC3)
                    printf("[oops] attribute '%s' is not declared as a vec3 in %s... undefined draw !!\n", name, label);
            }
            else if(location == 3)  // attribut color necessaire
            {
                if(!use_color || !has_color())
                    printf("[oops] color attribute '%s' in %s: no data... undefined draw !!\n", name, label);
                if(glsl_size != 1 || glsl_type != GL_FLOAT_VEC4)
                    printf("[oops] attribute '%s' is not declared as a vec4 in %s... undefined draw !!\n", name, label);
            }
            else if(location == 4)  // attribut material_index necessaire
            {
                if(!use_material_index || !has_material_index())
                    printf("[oops] material_index attribute '%s' in %s: no data... undefined draw !!\n", name, label);
                if(glsl_size != 1 || glsl_type != GL_UNSIGNED_INT)
                    printf("[oops] attribute '%s' is not declared as a uint in %s... undefined draw !!\n", name, label);
            }
        }
    }
    #endif
    
    if(m_indices.size() > 0)
        glDrawElements(m_primitives, n, GL_UNSIGNED_INT, (void *) (first * sizeof(unsigned)));
    else
        glDrawArrays(m_primitives, first, n);
}

---

The documentation for this class was generated from the following files:

• src/gKit/mesh.h
• src/gKit/mesh.cpp