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

#include <mesh.h>

Public Member Functions
construction.
	Mesh ()
	constructeur par defaut.
	Mesh (const GLenum primitives)
	constructeur.
int	create (const GLenum primitives)
	construit les objets openGL.
	Mesh (const GLenum primitives, const std::vector< vec3 > &positions)
	constructeur. a partir d'un ensemble de positions.
	Mesh (const GLenum primitives, const std::vector< vec3 > &positions, const std::vector< unsigned > &indices)
	constructeur. a partir d'un ensemble de positions indexees.
	Mesh (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)
	constructeur. a partir d'un ensemble de positions + attributs indexes.
void	release ()
	detruit les objets openGL.
description des attributs des sommets.
Mesh &	color (const vec4 &c)
	definit la couleur du prochain sommet.
Mesh &	color (const Color &c)
	definit la couleur du prochain sommet.
Mesh &	color (const float r, const float g, const float b, const float a=1)
	definit la couleur du prochain sommet.
Mesh &	normal (const vec3 &n)
	definit la normale du prochain sommet.
Mesh &	normal (const Vector &n)
	definit la normale du prochain sommet.
Mesh &	normal (const float x, const float y, const float z)
	definit la normale du prochain sommet.
Mesh &	texcoord (const vec2 &uv)
	definit les coordonnees de texture du prochain sommet.
Mesh &	texcoord (const float x, const float y)
	definit les coordonnees de texture du prochain sommet.
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.
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.
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.
void	clear ()
	vide la description.
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.
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.
Mesh &	color (const unsigned int id, const Color &c)
	modifie la couleur du sommet d'indice id.
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.
Mesh &	normal (const unsigned int id, const vec3 &n)
	modifie la normale du sommet d'indice id.
Mesh &	normal (const unsigned int id, const Vector &n)
	modifie la normale du sommet d'indice id.
Mesh &	normal (const unsigned int id, const float x, const float y, const float z)
	modifie la normale du sommet d'indice id.
Mesh &	texcoord (const unsigned int id, const vec2 &uv)
	modifie les coordonnees du sommet d'indice id.
Mesh &	texcoord (const unsigned int id, const float x, const float y)
	modifie les coordonnees du sommet d'indice id.
void	vertex (const unsigned int id, const vec3 &p)
	modifie la position du sommet d'indice id.
void	vertex (const unsigned int id, const Point &p)
	modifie la position du sommet d'indice id.
void	vertex (const unsigned int id, const float x, const float y, const float z)
	modifie la position du sommet d'indice id.
description des matieres.
const Materials &	materials () const
	renvoie la description des matieres.
Materials &	materials ()
	renvoie la description des matieres.
void	materials (const Materials &materials)
	remplace la description des matieres.
const std::vector< unsigned int > &	material_indices () const
	renvoie les indices des matieres des triangles.
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.
description des triangles d'un maillage.
int	triangle_count () const
	renvoie le nombre de triangles.
TriangleData	triangle (const unsigned int id) const
	renvoie un triangle.
int	triangle_material_index (const unsigned int id) const
	renvoie l'indice de la matiere d'un triangle.
const Material &	triangle_material (const unsigned int id) const
	renvoie la matiere d'un triangle.
std::vector< TriangleGroup >	groups ()
	renvoie les groupes de triangles de meme matiere. re-organise les triangles. permet d'afficher l'objet matiere par matiere.
std::vector< TriangleGroup >	groups (const std::vector< unsigned int > &triangle_properties)
	renvoie les groupes de triangles de meme 'propriete'. re-organise les triangles.
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).
Color	default_color () const
	renvoie la couleur par defaut du mesh, utilisee si les sommets n'ont pas de couleur associee.
Mesh &	default_color (const Color &color)
	modifie la couleur par defaut, utilisee si les sommets n'ont pas de couleur associee.

manipulation des buffers d'attributs.
int	vertex_count () const
	renvoie le nombre de sommets.
int	index_count () const
	renvoie le nombre d'indices de sommets.
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.
std::size_t	vertex_buffer_size () const
	renvoie la longueur (en octets) du vertex buffer.
const float *	normal_buffer () const
	renvoie l'adresse de la normale du premier sommet. par convention, la normale est un vec3, 3 GL_FLOAT.
std::size_t	normal_buffer_size () const
	renvoie la longueur (en octets) du normal buffer.
const float *	texcoord_buffer () const
	renvoie l'adresse des coordonnees de textures du premier sommet. par convention, c'est un vec2, 2 GL_FLOAT.
std::size_t	texcoord_buffer_size () const
	renvoie la taille (en octets) du texcoord buffer.
const float *	color_buffer () const
	renvoie l'adresse de la couleur du premier sommet. par convention, la couleur est un vec4, 4 GL_FLOAT.
std::size_t	color_buffer_size () const
	renvoie la taille (en octets) du color buffer.
const void *	index_buffer () const
	renvoie l'adresse du premier indice du premier triangle. par convention c'est un uint, 1, GL_UNSIGNED_INT.
std::size_t	index_buffer_size () const
	renvoie la taille (en octets) de l'index buffer.
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.
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.
GLuint	create_buffers ()
	construit les buffers et le vertex array object necessaires pour dessiner l'objet avec openGL. utilitaire. detruit par release( ). ou release_buffers( ).
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( ). ou release_buffers( ).
GLuint	create_buffers (const unsigned flags)
	idem mais utilise une combinaison des flags USE_TEXCOORD, USE_NORMAL...
void	draw (const GLuint program)
	dessine l'objet avec un shader program.
void	draw (const int first, const int n, const GLuint program)
	dessine une partie de l'objet avec un shader program.

Detailed Description

representation d'un objet / maillage.

Definition at line 120 of file mesh.h.

Constructor & Destructor Documentation

◆ Mesh() [1/5]

Mesh::Mesh ( )

inline

constructeur par defaut.

Definition at line 126 of file mesh.h.

126 : m_positions(), m_texcoords(), m_normals(), m_colors(), m_indices(),

127 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) {}

White

Color White()

utilitaire. renvoie une couleur blanche.

Definition color.cpp:23

◆ Mesh() [2/5]

Mesh::Mesh ( const GLenum primitives )

inline

constructeur.

Definition at line 130 of file mesh.h.

130 : m_positions(), m_texcoords(), m_normals(), m_colors(), m_indices(),

131 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) {}

Mesh::primitives

GLenum primitives() const

renvoie le type de primitives.

Definition mesh.h:345

◆ Mesh() [3/5]

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

constructeur. a partir d'un ensemble de positions.

Definition at line 22 of file mesh.cpp.

                                                                      : 
    m_positions(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(true)
{}

◆ Mesh() [4/5]

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

constructeur. a partir d'un ensemble de positions indexees.

Definition at line 27 of file mesh.cpp.

                                                                                                          : 
    m_positions(positions), m_texcoords(), m_normals(), m_colors(), m_indices(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(true)
{}

◆ Mesh() [5/5]

Mesh::Mesh	(	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 )

constructeur. a partir d'un ensemble de positions + attributs indexes.

Definition at line 32 of file mesh.cpp.

                                         : 
        m_positions(positions), m_texcoords(), m_normals(), m_colors(), m_indices(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(true)
{
    // n'initialise les autres attributs que s'ils sont definis
    if(texcoords.size() > 0 && texcoords.size() == positions.size()) 
        m_texcoords= texcoords;
    if(normals.size() > 0 && normals.size() == positions.size())
        m_normals= normals;
    if(colors.size() > 0 && colors.size() == positions.size())
        m_colors= colors;
}

Member Function Documentation

◆ create()

int Mesh::create ( const GLenum primitives )

construit les objets openGL.

Definition at line 16 of file mesh.cpp.

{
    m_primitives= primitives;
    return 0;
}

◆ release()

void Mesh::release ( )

detruit les objets openGL.

Definition at line 50 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 66 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 156 of file mesh.h.

156{ 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 158 of file mesh.h.

158{ 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 76 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 163 of file mesh.h.

163{ 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 165 of file mesh.h.

165{ 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 86 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 170 of file mesh.h.

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

Mesh::texcoord

Mesh & texcoord(const vec2 &uv)

definit les coordonnees de texture du prochain sommet.

Definition mesh.cpp:86

◆ 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 97 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 175 of file mesh.h.

175{ return vertex(vec3(p)); }

Mesh::vertex

unsigned int vertex(const vec3 &p)

insere un sommet de position p, et ses attributs (s'ils sont definis par color(), texcoord(),...

Definition mesh.cpp:97

◆ 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 177 of file mesh.h.

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

◆ clear()

void Mesh::clear ( )

vide la description.

Definition at line 164 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 178 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 196 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 214 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 227 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 133 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 231 of file mesh.h.

231{ 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 233 of file mesh.h.

233{ 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 141 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 238 of file mesh.h.

238{ 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 240 of file mesh.h.

240{ 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 149 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 245 of file mesh.h.

245{ 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 157 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 250 of file mesh.h.

250{ 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 252 of file mesh.h.

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

◆ materials() [1/3]

const Materials & Mesh::materials ( ) const

renvoie la description des matieres.

Definition at line 253 of file mesh.cpp.

{
    return m_materials;
}

◆ materials() [2/3]

Materials & Mesh::materials ( )

renvoie la description des matieres.

Definition at line 248 of file mesh.cpp.

{
    return m_materials;
}

◆ materials() [3/3]

void Mesh::materials ( const Materials & materials )

remplace la description des matieres.

Definition at line 258 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 273 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 263 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 421 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 432 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 278 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 284 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 291 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 296 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 489 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 293 of file mesh.h.

293{ 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 60 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 300 of file mesh.h.

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

◆ index_count()

int Mesh::index_count ( ) const

inline

renvoie le nombre d'indices de sommets.

Definition at line 302 of file mesh.h.

302{ 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 305 of file mesh.h.

305{ 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 307 of file mesh.h.

307{ 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 310 of file mesh.h.

310{ 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 312 of file mesh.h.

312{ 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 315 of file mesh.h.

315{ 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 317 of file mesh.h.

317{ 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 320 of file mesh.h.

320{ 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 322 of file mesh.h.

322{ 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 325 of file mesh.h.

325{ 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 327 of file mesh.h.

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

◆ positions()

const std::vector< vec3 > & Mesh::positions ( ) const

inline

Definition at line 330 of file mesh.h.

330{ return m_positions; }

◆ texcoords()

const std::vector< vec2 > & Mesh::texcoords ( ) const

inline

Definition at line 331 of file mesh.h.

331{ return m_texcoords; }

◆ normals()

const std::vector< vec3 > & Mesh::normals ( ) const

inline

Definition at line 332 of file mesh.h.

332{ return m_normals; }

◆ colors()

const std::vector< vec4 > & Mesh::colors ( ) const

inline

Definition at line 333 of file mesh.h.

333{ return m_colors; }

◆ indices()

const std::vector< unsigned int > & Mesh::indices ( ) const

inline

Definition at line 334 of file mesh.h.

334{ return m_indices; }

◆ has_position()

bool Mesh::has_position ( ) const

inline

verifie que les attributs sont decrits de maniere coherente.

Definition at line 337 of file mesh.h.

337{ return !m_positions.empty(); }

◆ has_texcoord()

bool Mesh::has_texcoord ( ) const

inline

Definition at line 338 of file mesh.h.

338{ return m_texcoords.size() == m_positions.size(); }

◆ has_normal()

bool Mesh::has_normal ( ) const

inline

Definition at line 339 of file mesh.h.

339{ return m_normals.size() == m_positions.size(); }

◆ has_color()

bool Mesh::has_color ( ) const

inline

Definition at line 340 of file mesh.h.

340{ return m_colors.size() == m_positions.size(); }

◆ has_material_index()

bool Mesh::has_material_index ( ) const

inline

Definition at line 341 of file mesh.h.

341{ return int(m_triangle_materials.size()) == triangle_count(); }

◆ primitives()

GLenum Mesh::primitives ( ) const

inline

renvoie le type de primitives.

Definition at line 345 of file mesh.h.

345{ return m_primitives; }

◆ create_buffers() [1/3]

GLuint Mesh::create_buffers ( )

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

Definition at line 606 of file mesh.cpp.

{
    return create_buffers( has_texcoord(),  has_normal(), has_color(), has_material_index() ); 
}

◆ create_buffers() [2/3]

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( ). ou release_buffers( ).

Definition at line 563 of file mesh.cpp.

{
    if(m_vao) 
        return m_vao;   // c'est deja fait...
    
    // 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);
 
    if(m_vertex_buffer_size == 0)
        return 0;
    
    // 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;
}

◆ create_buffers() [3/3]

GLuint Mesh::create_buffers ( const unsigned flags )

idem mais utilise une combinaison des flags USE_TEXCOORD, USE_NORMAL...

Definition at line 611 of file mesh.cpp.

{
#ifndef GK_RELEASE
    if((flags & USE_TEXCOORD) && !has_texcoord()) { printf("[oops] create_buffers: no texcoord array...\n"); return 0; }
    if((flags & USE_NORMAL) && !has_normal()) { printf("[oops] create_buffers: no normal array...\n"); return 0; }
    if((flags & USE_COLOR) && !has_color()) { printf("[oops] create_buffers: no color array...\n"); return 0; }
    if((flags & USE_MATERIAL_INDEX) && !has_material_index()) { printf("[oops] create_buffers: no material index array...\n"); return 0; }
#endif
    
    return create_buffers( flags & USE_TEXCOORD, flags & USE_NORMAL, flags & USE_COLOR, flags & USE_MATERIAL_INDEX ); 
}

◆ draw() [1/2]

void Mesh::draw ( const GLuint program )

dessine l'objet avec un shader program.

Definition at line 757 of file mesh.cpp.

{
    if(m_indices.size())
        draw(0, int(m_indices.size()), program);
    else
        draw(0, int(m_positions.size()), program);
}

◆ draw() [2/2]

void Mesh::draw	(	const int	first,
		const int	n,
		const GLuint	program )

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

Definition at line 765 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(!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(!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(!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(!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(!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, count, GL_UNSIGNED_INT, (void *) (first * sizeof(unsigned)));
    else
        glDrawArrays(m_primitives, first, count);
}

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

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

Public Member Functions

manipulation des buffers d'attributs.

Detailed Description

Constructor & Destructor Documentation

◆ Mesh() [1/5]

◆ Mesh() [2/5]

◆ Mesh() [3/5]

◆ Mesh() [4/5]

◆ Mesh() [5/5]

Member Function Documentation

◆ create()

◆ release()

◆ color() [1/6]

◆ color() [2/6]

◆ color() [3/6]

◆ normal() [1/6]

◆ normal() [2/6]

◆ normal() [3/6]

◆ texcoord() [1/4]

◆ texcoord() [2/4]

◆ vertex() [1/6]

◆ vertex() [2/6]

◆ vertex() [3/6]

◆ clear()

◆ triangle() [1/2]

◆ triangle_last()

◆ restart_strip()

◆ index()

◆ color() [4/6]

◆ color() [5/6]

◆ color() [6/6]

◆ normal() [4/6]

◆ normal() [5/6]

◆ normal() [6/6]

◆ texcoord() [3/4]

◆ texcoord() [4/4]

◆ vertex() [4/6]

◆ vertex() [5/6]

◆ vertex() [6/6]

◆ materials() [1/3]

◆ materials() [2/3]

◆ materials() [3/3]

◆ material_indices()

◆ material()

◆ triangle_count()

◆ triangle() [2/2]

◆ triangle_material_index()

◆ triangle_material()

◆ groups() [1/2]

◆ groups() [2/2]

◆ bounds()

◆ default_color() [1/2]

◆ default_color() [2/2]

◆ vertex_count()

◆ index_count()

◆ vertex_buffer()

◆ vertex_buffer_size()

◆ normal_buffer()

◆ normal_buffer_size()

◆ texcoord_buffer()

◆ texcoord_buffer_size()

◆ color_buffer()

◆ color_buffer_size()

◆ index_buffer()

◆ index_buffer_size()

◆ positions()

◆ texcoords()

◆ normals()

◆ colors()

◆ indices()

◆ has_position()

◆ has_texcoord()

◆ has_normal()

◆ has_color()

◆ has_material_index()

◆ primitives()

◆ create_buffers() [1/3]

◆ create_buffers() [2/3]

◆ create_buffers() [3/3]

◆ draw() [1/2]