igl::opengl::MeshGL Class Reference

#include <src/libigl/igl/opengl/MeshGL.h>

Collaboration diagram for igl::opengl::MeshGL:

Public Types
enum	DirtyFlags {   DIRTY_NONE = 0x0000 , DIRTY_POSITION = 0x0001 , DIRTY_UV = 0x0002 , DIRTY_NORMAL = 0x0004 ,   DIRTY_AMBIENT = 0x0008 , DIRTY_DIFFUSE = 0x0010 , DIRTY_SPECULAR = 0x0020 , DIRTY_TEXTURE = 0x0040 ,   DIRTY_FACE = 0x0080 , DIRTY_MESH = 0x00FF , DIRTY_OVERLAY_LINES = 0x0100 , DIRTY_OVERLAY_POINTS = 0x0200 ,   DIRTY_ALL = 0x03FF }
typedef unsigned int	GLuint
typedef Eigen::Matrix< float, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor >	RowMatrixXf

Public Member Functions
IGL_INLINE void	init ()
IGL_INLINE void	free ()
IGL_INLINE void	init_buffers ()
IGL_INLINE void	bind_mesh ()
IGL_INLINE void	draw_mesh (bool solid)
	Draw the currently buffered mesh (either solid or wireframe)
IGL_INLINE void	bind_overlay_lines ()
IGL_INLINE void	draw_overlay_lines ()
	Draw the currently buffered line overlay.
IGL_INLINE void	bind_overlay_points ()
IGL_INLINE void	draw_overlay_points ()
	Draw the currently buffered point overlay.
IGL_INLINE void	free_buffers ()

Public Attributes
bool	is_initialized = false
GLuint	vao_mesh
GLuint	vao_overlay_lines
GLuint	vao_overlay_points
GLuint	shader_mesh
GLuint	shader_overlay_lines
GLuint	shader_overlay_points
GLuint	vbo_V
GLuint	vbo_V_uv
GLuint	vbo_V_normals
GLuint	vbo_V_ambient
GLuint	vbo_V_diffuse
GLuint	vbo_V_specular
GLuint	vbo_F
GLuint	vbo_tex
GLuint	vbo_lines_F
GLuint	vbo_lines_V
GLuint	vbo_lines_V_colors
GLuint	vbo_points_F
GLuint	vbo_points_V
GLuint	vbo_points_V_colors
RowMatrixXf	V_vbo
RowMatrixXf	V_normals_vbo
RowMatrixXf	V_ambient_vbo
RowMatrixXf	V_diffuse_vbo
RowMatrixXf	V_specular_vbo
RowMatrixXf	V_uv_vbo
RowMatrixXf	lines_V_vbo
RowMatrixXf	lines_V_colors_vbo
RowMatrixXf	points_V_vbo
RowMatrixXf	points_V_colors_vbo
int	tex_u
int	tex_v
Eigen::Matrix< char, Eigen::Dynamic, 1 >	tex
Eigen::Matrix< unsigned, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor >	F_vbo
Eigen::Matrix< unsigned, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor >	lines_F_vbo
Eigen::Matrix< unsigned, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor >	points_F_vbo
uint32_t	dirty

Detailed Description

Member Typedef Documentation

GLuint

typedef unsigned int igl::opengl::MeshGL::GLuint

RowMatrixXf

typedef Eigen::Matrix<float,Eigen::Dynamic,Eigen::Dynamic,Eigen::RowMajor> igl::opengl::MeshGL::RowMatrixXf

Member Enumeration Documentation

DirtyFlags

enum igl::opengl::MeshGL::DirtyFlags

Enumerator
DIRTY_NONE
DIRTY_POSITION
DIRTY_UV
DIRTY_NORMAL
DIRTY_AMBIENT
DIRTY_DIFFUSE
DIRTY_SPECULAR
DIRTY_TEXTURE
DIRTY_FACE
DIRTY_MESH
DIRTY_OVERLAY_LINES
DIRTY_OVERLAY_POINTS
DIRTY_ALL

  {
    DIRTY_NONE           = 0x0000,
    DIRTY_POSITION       = 0x0001,
    DIRTY_UV             = 0x0002,
    DIRTY_NORMAL         = 0x0004,
    DIRTY_AMBIENT        = 0x0008,
    DIRTY_DIFFUSE        = 0x0010,
    DIRTY_SPECULAR       = 0x0020,
    DIRTY_TEXTURE        = 0x0040,
    DIRTY_FACE           = 0x0080,
    DIRTY_MESH           = 0x00FF,
    DIRTY_OVERLAY_LINES  = 0x0100,
    DIRTY_OVERLAY_POINTS = 0x0200,
    DIRTY_ALL            = 0x03FF
  };

Member Function Documentation

bind_mesh()

IGL_INLINE void igl::opengl::MeshGL::bind_mesh

(

)

{
  glBindVertexArray(vao_mesh);
  glUseProgram(shader_mesh);
  bind_vertex_attrib_array(shader_mesh,"position", vbo_V, V_vbo, dirty & MeshGL::DIRTY_POSITION);
  bind_vertex_attrib_array(shader_mesh,"normal", vbo_V_normals, V_normals_vbo, dirty & MeshGL::DIRTY_NORMAL);
  bind_vertex_attrib_array(shader_mesh,"Ka", vbo_V_ambient, V_ambient_vbo, dirty & MeshGL::DIRTY_AMBIENT);
  bind_vertex_attrib_array(shader_mesh,"Kd", vbo_V_diffuse, V_diffuse_vbo, dirty & MeshGL::DIRTY_DIFFUSE);
  bind_vertex_attrib_array(shader_mesh,"Ks", vbo_V_specular, V_specular_vbo, dirty & MeshGL::DIRTY_SPECULAR);
  bind_vertex_attrib_array(shader_mesh,"texcoord", vbo_V_uv, V_uv_vbo, dirty & MeshGL::DIRTY_UV);
 
  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbo_F);
  if (dirty & MeshGL::DIRTY_FACE)
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(unsigned)*F_vbo.size(), F_vbo.data(), GL_DYNAMIC_DRAW);
 
  glActiveTexture(GL_TEXTURE0);
  glBindTexture(GL_TEXTURE_2D, vbo_tex);
  if (dirty & MeshGL::DIRTY_TEXTURE)
  {
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, tex_u, tex_v, 0, GL_RGBA, GL_UNSIGNED_BYTE, tex.data());
  }
  glUniform1i(glGetUniformLocation(shader_mesh,"tex"), 0);
  dirty &= ~MeshGL::DIRTY_MESH;
}

References igl::opengl::bind_vertex_attrib_array(), DIRTY_AMBIENT, DIRTY_DIFFUSE, DIRTY_FACE, DIRTY_NORMAL, DIRTY_POSITION, DIRTY_SPECULAR, DIRTY_TEXTURE, and DIRTY_UV.

Here is the call graph for this function:

bind_overlay_lines()

IGL_INLINE void igl::opengl::MeshGL::bind_overlay_lines

(

)

{
  bool is_dirty = dirty & MeshGL::DIRTY_OVERLAY_LINES;
 
  glBindVertexArray(vao_overlay_lines);
  glUseProgram(shader_overlay_lines);
 bind_vertex_attrib_array(shader_overlay_lines,"position", vbo_lines_V, lines_V_vbo, is_dirty);
 bind_vertex_attrib_array(shader_overlay_lines,"color", vbo_lines_V_colors, lines_V_colors_vbo, is_dirty);
 
  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbo_lines_F);
  if (is_dirty)
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(unsigned)*lines_F_vbo.size(), lines_F_vbo.data(), GL_DYNAMIC_DRAW);
 
  dirty &= ~MeshGL::DIRTY_OVERLAY_LINES;
}

References igl::opengl::bind_vertex_attrib_array(), and DIRTY_OVERLAY_LINES.

Here is the call graph for this function:

bind_overlay_points()

IGL_INLINE void igl::opengl::MeshGL::bind_overlay_points

(

)

{
  bool is_dirty = dirty & MeshGL::DIRTY_OVERLAY_POINTS;
 
  glBindVertexArray(vao_overlay_points);
  glUseProgram(shader_overlay_points);
 bind_vertex_attrib_array(shader_overlay_points,"position", vbo_points_V, points_V_vbo, is_dirty);
 bind_vertex_attrib_array(shader_overlay_points,"color", vbo_points_V_colors, points_V_colors_vbo, is_dirty);
 
  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbo_points_F);
  if (is_dirty)
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(unsigned)*points_F_vbo.size(), points_F_vbo.data(), GL_DYNAMIC_DRAW);
 
  dirty &= ~MeshGL::DIRTY_OVERLAY_POINTS;
}

References igl::opengl::bind_vertex_attrib_array(), and DIRTY_OVERLAY_POINTS.

Here is the call graph for this function:

draw_mesh()

IGL_INLINE void igl::opengl::MeshGL::draw_mesh

(

bool

solid

)

Draw the currently buffered mesh (either solid or wireframe)

{
  glPolygonMode(GL_FRONT_AND_BACK, solid ? GL_FILL : GL_LINE);
 
  /* Avoid Z-buffer fighting between filled triangles & wireframe lines */
  if (solid)
  {
    glEnable(GL_POLYGON_OFFSET_FILL);
    glPolygonOffset(1.0, 1.0);
  }
  glDrawElements(GL_TRIANGLES, 3*F_vbo.rows(), GL_UNSIGNED_INT, 0);
 
  glDisable(GL_POLYGON_OFFSET_FILL);
  glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
}

References GL_TRIANGLES.

draw_overlay_lines()

IGL_INLINE void igl::opengl::MeshGL::draw_overlay_lines

(

)

Draw the currently buffered line overlay.

{
  glDrawElements(GL_LINES, lines_F_vbo.rows(), GL_UNSIGNED_INT, 0);
}

draw_overlay_points()

IGL_INLINE void igl::opengl::MeshGL::draw_overlay_points

(

)

Draw the currently buffered point overlay.

{
  glDrawElements(GL_POINTS, points_F_vbo.rows(), GL_UNSIGNED_INT, 0);
}

free()

IGL_INLINE void igl::opengl::MeshGL::free

(

)

Referenced by igl::opengl::glfw::Viewer::launch_shut().

Here is the caller graph for this function:

free_buffers()

IGL_INLINE void igl::opengl::MeshGL::free_buffers

(

)

{
  if (is_initialized)
  {
    glDeleteVertexArrays(1, &vao_mesh);
    glDeleteVertexArrays(1, &vao_overlay_lines);
    glDeleteVertexArrays(1, &vao_overlay_points);
 
    glDeleteBuffers(1, &vbo_V);
    glDeleteBuffers(1, &vbo_V_normals);
    glDeleteBuffers(1, &vbo_V_ambient);
    glDeleteBuffers(1, &vbo_V_diffuse);
    glDeleteBuffers(1, &vbo_V_specular);
    glDeleteBuffers(1, &vbo_V_uv);
    glDeleteBuffers(1, &vbo_F);
    glDeleteBuffers(1, &vbo_lines_F);
    glDeleteBuffers(1, &vbo_lines_V);
    glDeleteBuffers(1, &vbo_lines_V_colors);
    glDeleteBuffers(1, &vbo_points_F);
    glDeleteBuffers(1, &vbo_points_V);
    glDeleteBuffers(1, &vbo_points_V_colors);
 
    glDeleteTextures(1, &vbo_tex);
  }
}

init()

IGL_INLINE void igl::opengl::MeshGL::init

(

)

{
  if(is_initialized)
  {
    return;
  }
  is_initialized = true;
  std::string mesh_vertex_shader_string =
R"(#version 150
  uniform mat4 view;
  uniform mat4 proj;
  uniform mat4 normal_matrix;
  in vec3 position;
  in vec3 normal;
  out vec3 position_eye;
  out vec3 normal_eye;
  in vec4 Ka;
  in vec4 Kd;
  in vec4 Ks;
  in vec2 texcoord;
  out vec2 texcoordi;
  out vec4 Kai;
  out vec4 Kdi;
  out vec4 Ksi;
 
  void main()
  {
    position_eye = vec3 (view * vec4 (position, 1.0));
    normal_eye = vec3 (normal_matrix * vec4 (normal, 0.0));
    normal_eye = normalize(normal_eye);
    gl_Position = proj * vec4 (position_eye, 1.0); //proj * view * vec4(position, 1.0);"
    Kai = Ka;
    Kdi = Kd;
    Ksi = Ks;
    texcoordi = texcoord;
  }
)";
 
  std::string mesh_fragment_shader_string =

Referenced by igl::opengl::ViewerData::updateGL().

Here is the caller graph for this function:

init_buffers()

IGL_INLINE void igl::opengl::MeshGL::init_buffers

(

)

{
  // Mesh: Vertex Array Object & Buffer objects
  glGenVertexArrays(1, &vao_mesh);
  glBindVertexArray(vao_mesh);
  glGenBuffers(1, &vbo_V);
  glGenBuffers(1, &vbo_V_normals);
  glGenBuffers(1, &vbo_V_ambient);
  glGenBuffers(1, &vbo_V_diffuse);
  glGenBuffers(1, &vbo_V_specular);
  glGenBuffers(1, &vbo_V_uv);
  glGenBuffers(1, &vbo_F);
  glGenTextures(1, &vbo_tex);
 
  // Line overlay
  glGenVertexArrays(1, &vao_overlay_lines);
  glBindVertexArray(vao_overlay_lines);
  glGenBuffers(1, &vbo_lines_F);
  glGenBuffers(1, &vbo_lines_V);
  glGenBuffers(1, &vbo_lines_V_colors);
 
  // Point overlay
  glGenVertexArrays(1, &vao_overlay_points);
  glBindVertexArray(vao_overlay_points);
  glGenBuffers(1, &vbo_points_F);
  glGenBuffers(1, &vbo_points_V);
  glGenBuffers(1, &vbo_points_V_colors);
 
  dirty = MeshGL::DIRTY_ALL;
}

References dirty, DIRTY_ALL, vao_mesh, vao_overlay_lines, vao_overlay_points, vbo_F, vbo_lines_F, vbo_lines_V, vbo_lines_V_colors, vbo_points_F, vbo_points_V, vbo_points_V_colors, vbo_tex, vbo_V, vbo_V_ambient, vbo_V_diffuse, vbo_V_normals, vbo_V_specular, and vbo_V_uv.

Member Data Documentation

dirty

uint32_t igl::opengl::MeshGL::dirty

Referenced by init_buffers(), and igl::opengl::ViewerData::updateGL().

F_vbo

Eigen::Matrix<unsigned, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor> igl::opengl::MeshGL::F_vbo

Referenced by igl::opengl::ViewerData::updateGL().

is_initialized

bool igl::opengl::MeshGL::is_initialized = false

Referenced by igl::opengl::ViewerData::updateGL().

lines_F_vbo

Eigen::Matrix<unsigned, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor> igl::opengl::MeshGL::lines_F_vbo

Referenced by igl::opengl::ViewerData::updateGL().

lines_V_colors_vbo

RowMatrixXf igl::opengl::MeshGL::lines_V_colors_vbo

Referenced by igl::opengl::ViewerData::updateGL().

lines_V_vbo

RowMatrixXf igl::opengl::MeshGL::lines_V_vbo

Referenced by igl::opengl::ViewerData::updateGL().

points_F_vbo

Eigen::Matrix<unsigned, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor> igl::opengl::MeshGL::points_F_vbo

Referenced by igl::opengl::ViewerData::updateGL().

points_V_colors_vbo

RowMatrixXf igl::opengl::MeshGL::points_V_colors_vbo

Referenced by igl::opengl::ViewerData::updateGL().

points_V_vbo

RowMatrixXf igl::opengl::MeshGL::points_V_vbo

Referenced by igl::opengl::ViewerData::updateGL().

shader_mesh

GLuint igl::opengl::MeshGL::shader_mesh

shader_overlay_lines

GLuint igl::opengl::MeshGL::shader_overlay_lines

shader_overlay_points

GLuint igl::opengl::MeshGL::shader_overlay_points

tex

Eigen::Matrix<char,Eigen::Dynamic,1> igl::opengl::MeshGL::tex

Referenced by igl::opengl::ViewerData::updateGL().

tex_u

int igl::opengl::MeshGL::tex_u

Referenced by igl::opengl::ViewerData::updateGL().

tex_v

int igl::opengl::MeshGL::tex_v

Referenced by igl::opengl::ViewerData::updateGL().

V_ambient_vbo

RowMatrixXf igl::opengl::MeshGL::V_ambient_vbo

Referenced by igl::opengl::ViewerData::updateGL().

V_diffuse_vbo

RowMatrixXf igl::opengl::MeshGL::V_diffuse_vbo

Referenced by igl::opengl::ViewerData::updateGL().

V_normals_vbo

RowMatrixXf igl::opengl::MeshGL::V_normals_vbo

Referenced by igl::opengl::ViewerData::updateGL().

V_specular_vbo

RowMatrixXf igl::opengl::MeshGL::V_specular_vbo

Referenced by igl::opengl::ViewerData::updateGL().

V_uv_vbo

RowMatrixXf igl::opengl::MeshGL::V_uv_vbo

Referenced by igl::opengl::ViewerData::updateGL().

V_vbo

RowMatrixXf igl::opengl::MeshGL::V_vbo

Referenced by igl::opengl::ViewerData::updateGL().

vao_mesh

GLuint igl::opengl::MeshGL::vao_mesh

Referenced by init_buffers().

vao_overlay_lines

GLuint igl::opengl::MeshGL::vao_overlay_lines

Referenced by init_buffers().

vao_overlay_points

GLuint igl::opengl::MeshGL::vao_overlay_points

Referenced by init_buffers().

vbo_F

GLuint igl::opengl::MeshGL::vbo_F

Referenced by init_buffers().

vbo_lines_F

GLuint igl::opengl::MeshGL::vbo_lines_F

Referenced by init_buffers().

vbo_lines_V

GLuint igl::opengl::MeshGL::vbo_lines_V

Referenced by init_buffers().

vbo_lines_V_colors

GLuint igl::opengl::MeshGL::vbo_lines_V_colors

Referenced by init_buffers().

vbo_points_F

GLuint igl::opengl::MeshGL::vbo_points_F

Referenced by init_buffers().

vbo_points_V

GLuint igl::opengl::MeshGL::vbo_points_V

Referenced by init_buffers().

vbo_points_V_colors

GLuint igl::opengl::MeshGL::vbo_points_V_colors

Referenced by init_buffers().

vbo_tex

GLuint igl::opengl::MeshGL::vbo_tex

Referenced by init_buffers().

vbo_V

GLuint igl::opengl::MeshGL::vbo_V

Referenced by init_buffers().

vbo_V_ambient

GLuint igl::opengl::MeshGL::vbo_V_ambient

Referenced by init_buffers().

vbo_V_diffuse

GLuint igl::opengl::MeshGL::vbo_V_diffuse

Referenced by init_buffers().

vbo_V_normals

GLuint igl::opengl::MeshGL::vbo_V_normals

Referenced by init_buffers().

vbo_V_specular

GLuint igl::opengl::MeshGL::vbo_V_specular

Referenced by init_buffers().

vbo_V_uv

GLuint igl::opengl::MeshGL::vbo_V_uv

Referenced by init_buffers().

---

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

• src/libigl/igl/opengl/MeshGL.h
• src/libigl/igl/opengl/MeshGL.cpp