igl::opengl::ViewerData Class Reference

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

Collaboration diagram for igl::opengl::ViewerData:

Public Member Functions
	ViewerData ()
IGL_INLINE void	clear ()
IGL_INLINE void	set_face_based (bool newvalue)
IGL_INLINE void	set_mesh (const Eigen::MatrixXd &V, const Eigen::MatrixXi &F)
IGL_INLINE void	set_vertices (const Eigen::MatrixXd &V)
IGL_INLINE void	set_normals (const Eigen::MatrixXd &N)
IGL_INLINE void	set_colors (const Eigen::MatrixXd &C)
IGL_INLINE void	set_uv (const Eigen::MatrixXd &UV)
IGL_INLINE void	set_uv (const Eigen::MatrixXd &UV_V, const Eigen::MatrixXi &UV_F)
IGL_INLINE void	set_texture (const Eigen::Matrix< unsigned char, Eigen::Dynamic, Eigen::Dynamic > &R, const Eigen::Matrix< unsigned char, Eigen::Dynamic, Eigen::Dynamic > &G, const Eigen::Matrix< unsigned char, Eigen::Dynamic, Eigen::Dynamic > &B)
IGL_INLINE void	set_texture (const Eigen::Matrix< unsigned char, Eigen::Dynamic, Eigen::Dynamic > &R, const Eigen::Matrix< unsigned char, Eigen::Dynamic, Eigen::Dynamic > &G, const Eigen::Matrix< unsigned char, Eigen::Dynamic, Eigen::Dynamic > &B, const Eigen::Matrix< unsigned char, Eigen::Dynamic, Eigen::Dynamic > &A)
IGL_INLINE void	set_points (const Eigen::MatrixXd &P, const Eigen::MatrixXd &C)
IGL_INLINE void	add_points (const Eigen::MatrixXd &P, const Eigen::MatrixXd &C)
IGL_INLINE void	set_edges (const Eigen::MatrixXd &P, const Eigen::MatrixXi &E, const Eigen::MatrixXd &C)
IGL_INLINE void	add_edges (const Eigen::MatrixXd &P1, const Eigen::MatrixXd &P2, const Eigen::MatrixXd &C)
IGL_INLINE void	add_label (const Eigen::VectorXd &P, const std::string &str)
IGL_INLINE void	compute_normals ()
IGL_INLINE void	uniform_colors (const Eigen::Vector3d &diffuse, const Eigen::Vector3d &ambient, const Eigen::Vector3d &specular)
IGL_INLINE void	uniform_colors (const Eigen::Vector4d &ambient, const Eigen::Vector4d &diffuse, const Eigen::Vector4d &specular)
IGL_INLINE void	grid_texture ()
IGL_INLINE void	updateGL (const igl::opengl::ViewerData &data, const bool invert_normals, igl::opengl::MeshGL &meshgl)

Public Attributes
Eigen::MatrixXd	V
Eigen::MatrixXi	F
Eigen::MatrixXd	F_normals
Eigen::MatrixXd	F_material_ambient
Eigen::MatrixXd	F_material_diffuse
Eigen::MatrixXd	F_material_specular
Eigen::MatrixXd	V_normals
Eigen::MatrixXd	V_material_ambient
Eigen::MatrixXd	V_material_diffuse
Eigen::MatrixXd	V_material_specular
Eigen::MatrixXd	V_uv
Eigen::MatrixXi	F_uv
Eigen::Matrix< unsigned char, Eigen::Dynamic, Eigen::Dynamic >	texture_R
Eigen::Matrix< unsigned char, Eigen::Dynamic, Eigen::Dynamic >	texture_G
Eigen::Matrix< unsigned char, Eigen::Dynamic, Eigen::Dynamic >	texture_B
Eigen::Matrix< unsigned char, Eigen::Dynamic, Eigen::Dynamic >	texture_A
Eigen::MatrixXd	lines
Eigen::MatrixXd	points
Eigen::MatrixXd	labels_positions
std::vector< std::string >	labels_strings
uint32_t	dirty
bool	face_based
bool	show_overlay
bool	show_overlay_depth
bool	show_texture
bool	show_faces
bool	show_lines
bool	show_vertid
bool	show_faceid
bool	invert_normals
float	point_size
float	line_width
Eigen::Vector4f	line_color
float	shininess
int	id
igl::opengl::MeshGL	meshgl

Detailed Description

Constructor & Destructor Documentation

ViewerData()

IGL_INLINE igl::opengl::ViewerData::ViewerData

(

)

: dirty(MeshGL::DIRTY_ALL),
  show_faces(true),
  show_lines(true),
  invert_normals(false),
  show_overlay(true),
  show_overlay_depth(true),
  show_vertid(false),
  show_faceid(false),
  show_texture(false),
  point_size(30),
  line_width(0.5f),
  line_color(0,0,0,1),
  shininess(35.0f),
  id(-1)
{
  clear();
};

References clear().

Here is the call graph for this function:

Member Function Documentation

add_edges()

IGL_INLINE void igl::opengl::ViewerData::add_edges	(	const Eigen::MatrixXd &	P1,
		const Eigen::MatrixXd &	P2,
		const Eigen::MatrixXd &	C
	)

{
  Eigen::MatrixXd P1_temp,P2_temp;
 
  // If P1 only has two columns, pad with a column of zeros
  if (P1.cols() == 2)
  {
    P1_temp = Eigen::MatrixXd::Zero(P1.rows(),3);
    P1_temp.block(0,0,P1.rows(),2) = P1;
    P2_temp = Eigen::MatrixXd::Zero(P2.rows(),3);
    P2_temp.block(0,0,P2.rows(),2) = P2;
  }
  else
  {
    P1_temp = P1;
    P2_temp = P2;
  }
 
  int lastid = lines.rows();
  lines.conservativeResize(lines.rows() + P1_temp.rows(),9);
  for (unsigned i=0; i<P1_temp.rows(); ++i)
    lines.row(lastid+i) << P1_temp.row(i), P2_temp.row(i), i<C.rows() ? C.row(i) : C.row(C.rows()-1);
 
  dirty |= MeshGL::DIRTY_OVERLAY_LINES;
}

References igl::opengl::MeshGL::DIRTY_OVERLAY_LINES.

add_label()

IGL_INLINE void igl::opengl::ViewerData::add_label	(	const Eigen::VectorXd &	P,
		const std::string &	str
	)

{
  Eigen::RowVectorXd P_temp;
 
  // If P only has two columns, pad with a column of zeros
  if (P.size() == 2)
  {
    P_temp = Eigen::RowVectorXd::Zero(3);
    P_temp << P.transpose(), 0;
  }
  else
    P_temp = P;
 
  int lastid = labels_positions.rows();
  labels_positions.conservativeResize(lastid+1, 3);
  labels_positions.row(lastid) = P_temp;
  labels_strings.push_back(str);
}

add_points()

IGL_INLINE void igl::opengl::ViewerData::add_points	(	const Eigen::MatrixXd &	P,
		const Eigen::MatrixXd &	C
	)

{
  Eigen::MatrixXd P_temp;
 
  // If P only has two columns, pad with a column of zeros
  if (P.cols() == 2)
  {
    P_temp = Eigen::MatrixXd::Zero(P.rows(),3);
    P_temp.block(0,0,P.rows(),2) = P;
  }
  else
    P_temp = P;
 
  int lastid = points.rows();
  points.conservativeResize(points.rows() + P_temp.rows(),6);
  for (unsigned i=0; i<P_temp.rows(); ++i)
    points.row(lastid+i) << P_temp.row(i), i<C.rows() ? C.row(i) : C.row(C.rows()-1);
 
  dirty |= MeshGL::DIRTY_OVERLAY_POINTS;
}

References igl::opengl::MeshGL::DIRTY_OVERLAY_POINTS.

clear()

IGL_INLINE void igl::opengl::ViewerData::clear

(

)

{
  V                       = Eigen::MatrixXd (0,3);
  F                       = Eigen::MatrixXi (0,3);
 
  F_material_ambient      = Eigen::MatrixXd (0,4);
  F_material_diffuse      = Eigen::MatrixXd (0,4);
  F_material_specular     = Eigen::MatrixXd (0,4);
 
  V_material_ambient      = Eigen::MatrixXd (0,4);
  V_material_diffuse      = Eigen::MatrixXd (0,4);
  V_material_specular     = Eigen::MatrixXd (0,4);
 
  F_normals               = Eigen::MatrixXd (0,3);
  V_normals               = Eigen::MatrixXd (0,3);
 
  V_uv                    = Eigen::MatrixXd (0,2);
  F_uv                    = Eigen::MatrixXi (0,3);
 
  lines                   = Eigen::MatrixXd (0,9);
  points                  = Eigen::MatrixXd (0,6);
  labels_positions        = Eigen::MatrixXd (0,3);
  labels_strings.clear();
 
  face_based = false;
}

Referenced by ViewerData(), and igl::opengl::glfw::Viewer::load_mesh_from_file().

Here is the caller graph for this function:

compute_normals()

IGL_INLINE void igl::opengl::ViewerData::compute_normals

(

)

{
  igl::per_face_normals(V, F, F_normals);
  igl::per_vertex_normals(V, F, F_normals, V_normals);
  dirty |= MeshGL::DIRTY_NORMAL;
}

References igl::opengl::MeshGL::DIRTY_NORMAL, igl::per_face_normals(), and igl::per_vertex_normals().

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

Here is the call graph for this function:

Here is the caller graph for this function:

grid_texture()

IGL_INLINE void igl::opengl::ViewerData::grid_texture

(

)

{
  // Don't do anything for an empty mesh
  if(V.rows() == 0)
  {
    V_uv.resize(V.rows(),2);
    return;
  }
  if (V_uv.rows() == 0)
  {
    V_uv = V.block(0, 0, V.rows(), 2);
    V_uv.col(0) = V_uv.col(0).array() - V_uv.col(0).minCoeff();
    V_uv.col(0) = V_uv.col(0).array() / V_uv.col(0).maxCoeff();
    V_uv.col(1) = V_uv.col(1).array() - V_uv.col(1).minCoeff();
    V_uv.col(1) = V_uv.col(1).array() / V_uv.col(1).maxCoeff();
    V_uv = V_uv.array() * 10;
    dirty |= MeshGL::DIRTY_TEXTURE;
  }
 
  unsigned size = 128;
  unsigned size2 = size/2;
  texture_R.resize(size, size);
  for (unsigned i=0; i<size; ++i)
  {
    for (unsigned j=0; j<size; ++j)
    {
      texture_R(i,j) = 0;
      if ((i<size2 && j<size2) || (i>=size2 && j>=size2))
        texture_R(i,j) = 255;
    }
  }
 
  texture_G = texture_R;
  texture_B = texture_R;
  texture_A = Eigen::Matrix<unsigned char,Eigen::Dynamic,Eigen::Dynamic>::Constant(texture_R.rows(),texture_R.cols(),255);
  dirty |= MeshGL::DIRTY_TEXTURE;
}

References igl::opengl::MeshGL::DIRTY_TEXTURE.

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

Here is the caller graph for this function:

set_colors()

IGL_INLINE void igl::opengl::ViewerData::set_colors

(

const Eigen::MatrixXd &

C

)

{
  using namespace std;
  using namespace Eigen;
  if(C.rows()>0 && C.cols() == 1)
  {
    Eigen::MatrixXd C3;
    igl::parula(C,true,C3);
    return set_colors(C3);
  }
  // Ambient color should be darker color
  const auto ambient = [](const MatrixXd & C)->MatrixXd
  {
    MatrixXd T = 0.1*C;
    T.col(3) = C.col(3);
    return T;
  };
  // Specular color should be a less saturated and darker color: dampened
  // highlights
  const auto specular = [](const MatrixXd & C)->MatrixXd
  {
    const double grey = 0.3;
    MatrixXd T = grey+0.1*(C.array()-grey);
    T.col(3) = C.col(3);
    return T;
  };
  if (C.rows() == 1)
  {
    for (unsigned i=0;i<V_material_diffuse.rows();++i)
    {
      if (C.cols() == 3)
        V_material_diffuse.row(i) << C.row(0),1;
      else if (C.cols() == 4)
        V_material_diffuse.row(i) << C.row(0);
    }
    V_material_ambient = ambient(V_material_diffuse);
    V_material_specular = specular(V_material_diffuse);
 
    for (unsigned i=0;i<F_material_diffuse.rows();++i)
    {
      if (C.cols() == 3)
        F_material_diffuse.row(i) << C.row(0),1;
      else if (C.cols() == 4)
        F_material_diffuse.row(i) << C.row(0);
    }
    F_material_ambient = ambient(F_material_diffuse);
    F_material_specular = specular(F_material_diffuse);
  }
  else if (C.rows() == V.rows())
  {
    set_face_based(false);
    for (unsigned i=0;i<V_material_diffuse.rows();++i)
    {
      if (C.cols() == 3)
        V_material_diffuse.row(i) << C.row(i), 1;
      else if (C.cols() == 4)
        V_material_diffuse.row(i) << C.row(i);
    }
    V_material_ambient = ambient(V_material_diffuse);
    V_material_specular = specular(V_material_diffuse);
  }
  else if (C.rows() == F.rows())
  {
    set_face_based(true);
    for (unsigned i=0;i<F_material_diffuse.rows();++i)
    {
      if (C.cols() == 3)
        F_material_diffuse.row(i) << C.row(i), 1;
      else if (C.cols() == 4)
        F_material_diffuse.row(i) << C.row(i);
    }
    F_material_ambient = ambient(F_material_diffuse);
    F_material_specular = specular(F_material_diffuse);
  }
  else
    cerr << "ERROR (set_colors): Please provide a single color, or a color per face or per vertex."<<endl;
  dirty |= MeshGL::DIRTY_DIFFUSE;
 
}

References igl::opengl::MeshGL::DIRTY_DIFFUSE, and igl::parula().

Here is the call graph for this function:

set_edges()

IGL_INLINE void igl::opengl::ViewerData::set_edges	(	const Eigen::MatrixXd &	P,
		const Eigen::MatrixXi &	E,
		const Eigen::MatrixXd &	C
	)

{
  using namespace Eigen;
  lines.resize(E.rows(),9);
  assert(C.cols() == 3);
  for(int e = 0;e<E.rows();e++)
  {
    RowVector3d color;
    if(C.size() == 3)
    {
      color<<C;
    }else if(C.rows() == E.rows())
    {
      color<<C.row(e);
    }
    lines.row(e)<< P.row(E(e,0)), P.row(E(e,1)), color;
  }
  dirty |= MeshGL::DIRTY_OVERLAY_LINES;
}

References igl::opengl::MeshGL::DIRTY_OVERLAY_LINES.

set_face_based()

IGL_INLINE void igl::opengl::ViewerData::set_face_based

(

bool

newvalue

)

{
  if (face_based != newvalue)
  {
    face_based = newvalue;
    dirty = MeshGL::DIRTY_ALL;
  }
}

References igl::opengl::MeshGL::DIRTY_ALL.

Referenced by igl::opengl::glfw::Viewer::Viewer(), igl::opengl::glfw::imgui::ImGuiMenu::draw_viewer_menu(), and igl::opengl::glfw::Viewer::key_pressed().

Here is the caller graph for this function:

set_mesh()

IGL_INLINE void igl::opengl::ViewerData::set_mesh	(	const Eigen::MatrixXd &	V,
		const Eigen::MatrixXi &	F
	)

{
  using namespace std;
 
  Eigen::MatrixXd V_temp;
 
  // If V only has two columns, pad with a column of zeros
  if (_V.cols() == 2)
  {
    V_temp = Eigen::MatrixXd::Zero(_V.rows(),3);
    V_temp.block(0,0,_V.rows(),2) = _V;
  }
  else
    V_temp = _V;
 
  if (V.rows() == 0 && F.rows() == 0)
  {
    V = V_temp;
    F = _F;
 
    compute_normals();
    uniform_colors(
      Eigen::Vector3d(GOLD_AMBIENT[0], GOLD_AMBIENT[1], GOLD_AMBIENT[2]),
      Eigen::Vector3d(GOLD_DIFFUSE[0], GOLD_DIFFUSE[1], GOLD_DIFFUSE[2]),
      Eigen::Vector3d(GOLD_SPECULAR[0], GOLD_SPECULAR[1], GOLD_SPECULAR[2]));
 
    grid_texture();
  }
  else
  {
    if (_V.rows() == V.rows() && _F.rows() == F.rows())
    {
      V = V_temp;
      F = _F;
    }
    else
      cerr << "ERROR (set_mesh): The new mesh has a different number of vertices/faces. Please clear the mesh before plotting."<<endl;
  }
  dirty |= MeshGL::DIRTY_FACE | MeshGL::DIRTY_POSITION;
}

References igl::opengl::MeshGL::DIRTY_FACE, igl::opengl::MeshGL::DIRTY_POSITION, igl::GOLD_AMBIENT, igl::GOLD_DIFFUSE, and igl::GOLD_SPECULAR.

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

Here is the caller graph for this function:

set_normals()

IGL_INLINE void igl::opengl::ViewerData::set_normals

(

const Eigen::MatrixXd &

N

)

{
  using namespace std;
  if (N.rows() == V.rows())
  {
    set_face_based(false);
    V_normals = N;
  }
  else if (N.rows() == F.rows() || N.rows() == F.rows()*3)
  {
    set_face_based(true);
    F_normals = N;
  }
  else
    cerr << "ERROR (set_normals): Please provide a normal per face, per corner or per vertex."<<endl;
  dirty |= MeshGL::DIRTY_NORMAL;
}

References igl::opengl::MeshGL::DIRTY_NORMAL.

set_points()

IGL_INLINE void igl::opengl::ViewerData::set_points	(	const Eigen::MatrixXd &	P,
		const Eigen::MatrixXd &	C
	)

{
  // clear existing points
  points.resize(0,0);
  add_points(P,C);
}

set_texture() [1/2]

IGL_INLINE void igl::opengl::ViewerData::set_texture	(	const Eigen::Matrix< unsigned char, Eigen::Dynamic, Eigen::Dynamic > &	R,
		const Eigen::Matrix< unsigned char, Eigen::Dynamic, Eigen::Dynamic > &	G,
		const Eigen::Matrix< unsigned char, Eigen::Dynamic, Eigen::Dynamic > &	B
	)

{
  texture_R = R;
  texture_G = G;
  texture_B = B;
  texture_A = Eigen::Matrix<unsigned char,Eigen::Dynamic,Eigen::Dynamic>::Constant(R.rows(),R.cols(),255);
  dirty |= MeshGL::DIRTY_TEXTURE;
}

References Eigen::PlainObjectBase< Derived >::cols(), igl::opengl::MeshGL::DIRTY_TEXTURE, and Eigen::PlainObjectBase< Derived >::rows().

Here is the call graph for this function:

set_texture() [2/2]

IGL_INLINE void igl::opengl::ViewerData::set_texture	(	const Eigen::Matrix< unsigned char, Eigen::Dynamic, Eigen::Dynamic > &	R,
		const Eigen::Matrix< unsigned char, Eigen::Dynamic, Eigen::Dynamic > &	G,
		const Eigen::Matrix< unsigned char, Eigen::Dynamic, Eigen::Dynamic > &	B,
		const Eigen::Matrix< unsigned char, Eigen::Dynamic, Eigen::Dynamic > &	A
	)

{
  texture_R = R;
  texture_G = G;
  texture_B = B;
  texture_A = A;
  dirty |= MeshGL::DIRTY_TEXTURE;
}

References igl::opengl::MeshGL::DIRTY_TEXTURE.

set_uv() [1/2]

IGL_INLINE void igl::opengl::ViewerData::set_uv

(

const Eigen::MatrixXd &

UV

)

{
  using namespace std;
  if (UV.rows() == V.rows())
  {
    set_face_based(false);
    V_uv = UV;
  }
  else
    cerr << "ERROR (set_UV): Please provide uv per vertex."<<endl;;
  dirty |= MeshGL::DIRTY_UV;
}

References igl::opengl::MeshGL::DIRTY_UV.

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

Here is the caller graph for this function:

set_uv() [2/2]

IGL_INLINE void igl::opengl::ViewerData::set_uv	(	const Eigen::MatrixXd &	UV_V,
		const Eigen::MatrixXi &	UV_F
	)

{
  set_face_based(true);
  V_uv = UV_V.block(0,0,UV_V.rows(),2);
  F_uv = UV_F;
  dirty |= MeshGL::DIRTY_UV;
}

References igl::opengl::MeshGL::DIRTY_UV.

set_vertices()

IGL_INLINE void igl::opengl::ViewerData::set_vertices

(

const Eigen::MatrixXd &

V

)

{
  V = _V;
  assert(F.size() == 0 || F.maxCoeff() < V.rows());
  dirty |= MeshGL::DIRTY_POSITION;
}

References igl::opengl::MeshGL::DIRTY_POSITION.

uniform_colors() [1/2]

IGL_INLINE void igl::opengl::ViewerData::uniform_colors	(	const Eigen::Vector3d &	diffuse,
		const Eigen::Vector3d &	ambient,
		const Eigen::Vector3d &	specular
	)

{
  Eigen::Vector4d ambient4;
  Eigen::Vector4d diffuse4;
  Eigen::Vector4d specular4;
 
  ambient4 << ambient, 1;
  diffuse4 << diffuse, 1;
  specular4 << specular, 1;
 
  uniform_colors(ambient4,diffuse4,specular4);
}

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

Here is the caller graph for this function:

uniform_colors() [2/2]

IGL_INLINE void igl::opengl::ViewerData::uniform_colors	(	const Eigen::Vector4d &	ambient,
		const Eigen::Vector4d &	diffuse,
		const Eigen::Vector4d &	specular
	)

{
  V_material_ambient.resize(V.rows(),4);
  V_material_diffuse.resize(V.rows(),4);
  V_material_specular.resize(V.rows(),4);
 
  for (unsigned i=0; i<V.rows();++i)
  {
    V_material_ambient.row(i) = ambient;
    V_material_diffuse.row(i) = diffuse;
    V_material_specular.row(i) = specular;
  }
 
  F_material_ambient.resize(F.rows(),4);
  F_material_diffuse.resize(F.rows(),4);
  F_material_specular.resize(F.rows(),4);
 
  for (unsigned i=0; i<F.rows();++i)
  {
    F_material_ambient.row(i) = ambient;
    F_material_diffuse.row(i) = diffuse;
    F_material_specular.row(i) = specular;
  }
  dirty |= MeshGL::DIRTY_SPECULAR | MeshGL::DIRTY_DIFFUSE | MeshGL::DIRTY_AMBIENT;
}

References igl::opengl::MeshGL::DIRTY_AMBIENT, igl::opengl::MeshGL::DIRTY_DIFFUSE, and igl::opengl::MeshGL::DIRTY_SPECULAR.

updateGL()

IGL_INLINE void igl::opengl::ViewerData::updateGL	(	const igl::opengl::ViewerData &	data,
		const bool	invert_normals,
		igl::opengl::MeshGL &	meshgl
	)

{
  if (!meshgl.is_initialized)
  {
    meshgl.init();
  }
 
  bool per_corner_uv = (data.F_uv.rows() == data.F.rows());
  bool per_corner_normals = (data.F_normals.rows() == 3 * data.F.rows());
 
  meshgl.dirty |= data.dirty;
 
  // Input:
  //   X  #F by dim quantity
  // Output:
  //   X_vbo  #F*3 by dim scattering per corner
  const auto per_face = [&data](
      const Eigen::MatrixXd & X,
      MeshGL::RowMatrixXf & X_vbo)
  {
    assert(X.cols() == 4);
    X_vbo.resize(data.F.rows()*3,4);
    for (unsigned i=0; i<data.F.rows();++i)
      for (unsigned j=0;j<3;++j)
        X_vbo.row(i*3+j) = X.row(i).cast<float>();
  };
 
  // Input:
  //   X  #V by dim quantity
  // Output:
  //   X_vbo  #F*3 by dim scattering per corner
  const auto per_corner = [&data](
      const Eigen::MatrixXd & X,
      MeshGL::RowMatrixXf & X_vbo)
  {
    X_vbo.resize(data.F.rows()*3,X.cols());
    for (unsigned i=0; i<data.F.rows();++i)
      for (unsigned j=0;j<3;++j)
        X_vbo.row(i*3+j) = X.row(data.F(i,j)).cast<float>();
  };
 
  if (!data.face_based)
  {
    if (!(per_corner_uv || per_corner_normals))
    {
      // Vertex positions
      if (meshgl.dirty & MeshGL::DIRTY_POSITION)
        meshgl.V_vbo = data.V.cast<float>();
 
      // Vertex normals
      if (meshgl.dirty & MeshGL::DIRTY_NORMAL)
      {
        meshgl.V_normals_vbo = data.V_normals.cast<float>();
        if (invert_normals)
          meshgl.V_normals_vbo = -meshgl.V_normals_vbo;
      }
 
      // Per-vertex material settings
      if (meshgl.dirty & MeshGL::DIRTY_AMBIENT)
        meshgl.V_ambient_vbo = data.V_material_ambient.cast<float>();
      if (meshgl.dirty & MeshGL::DIRTY_DIFFUSE)
        meshgl.V_diffuse_vbo = data.V_material_diffuse.cast<float>();
      if (meshgl.dirty & MeshGL::DIRTY_SPECULAR)
        meshgl.V_specular_vbo = data.V_material_specular.cast<float>();
 
      // Face indices
      if (meshgl.dirty & MeshGL::DIRTY_FACE)
        meshgl.F_vbo = data.F.cast<unsigned>();
 
      // Texture coordinates
      if (meshgl.dirty & MeshGL::DIRTY_UV)
      {
        meshgl.V_uv_vbo = data.V_uv.cast<float>();
      }
    }
    else
    {
 
      // Per vertex properties with per corner UVs
      if (meshgl.dirty & MeshGL::DIRTY_POSITION)
      {
        per_corner(data.V,meshgl.V_vbo);
      }
 
      if (meshgl.dirty & MeshGL::DIRTY_AMBIENT)
      {
        meshgl.V_ambient_vbo.resize(data.F.rows()*3,4);
        for (unsigned i=0; i<data.F.rows();++i)
          for (unsigned j=0;j<3;++j)
            meshgl.V_ambient_vbo.row(i*3+j) = data.V_material_ambient.row(data.F(i,j)).cast<float>();
      }
      if (meshgl.dirty & MeshGL::DIRTY_DIFFUSE)
      {
        meshgl.V_diffuse_vbo.resize(data.F.rows()*3,4);
        for (unsigned i=0; i<data.F.rows();++i)
          for (unsigned j=0;j<3;++j)
            meshgl.V_diffuse_vbo.row(i*3+j) = data.V_material_diffuse.row(data.F(i,j)).cast<float>();
      }
      if (meshgl.dirty & MeshGL::DIRTY_SPECULAR)
      {
        meshgl.V_specular_vbo.resize(data.F.rows()*3,4);
        for (unsigned i=0; i<data.F.rows();++i)
          for (unsigned j=0;j<3;++j)
            meshgl.V_specular_vbo.row(i*3+j) = data.V_material_specular.row(data.F(i,j)).cast<float>();
      }
 
      if (meshgl.dirty & MeshGL::DIRTY_NORMAL)
      {
        meshgl.V_normals_vbo.resize(data.F.rows()*3,3);
        for (unsigned i=0; i<data.F.rows();++i)
          for (unsigned j=0;j<3;++j)
            meshgl.V_normals_vbo.row(i*3+j) =
                         per_corner_normals ?
               data.F_normals.row(i*3+j).cast<float>() :
               data.V_normals.row(data.F(i,j)).cast<float>();
 
 
        if (invert_normals)
          meshgl.V_normals_vbo = -meshgl.V_normals_vbo;
      }
 
      if (meshgl.dirty & MeshGL::DIRTY_FACE)
      {
        meshgl.F_vbo.resize(data.F.rows(),3);
        for (unsigned i=0; i<data.F.rows();++i)
          meshgl.F_vbo.row(i) << i*3+0, i*3+1, i*3+2;
      }
 
      if (meshgl.dirty & MeshGL::DIRTY_UV)
      {
        meshgl.V_uv_vbo.resize(data.F.rows()*3,2);
        for (unsigned i=0; i<data.F.rows();++i)
          for (unsigned j=0;j<3;++j)
            meshgl.V_uv_vbo.row(i*3+j) =
              data.V_uv.row(per_corner_uv ?
                data.F_uv(i,j) : data.F(i,j)).cast<float>();
      }
    }
  }
  else
  {
    if (meshgl.dirty & MeshGL::DIRTY_POSITION)
    {
      per_corner(data.V,meshgl.V_vbo);
    }
    if (meshgl.dirty & MeshGL::DIRTY_AMBIENT)
    {
      per_face(data.F_material_ambient,meshgl.V_ambient_vbo);
    }
    if (meshgl.dirty & MeshGL::DIRTY_DIFFUSE)
    {
      per_face(data.F_material_diffuse,meshgl.V_diffuse_vbo);
    }
    if (meshgl.dirty & MeshGL::DIRTY_SPECULAR)
    {
      per_face(data.F_material_specular,meshgl.V_specular_vbo);
    }
 
    if (meshgl.dirty & MeshGL::DIRTY_NORMAL)
    {
      meshgl.V_normals_vbo.resize(data.F.rows()*3,3);
      for (unsigned i=0; i<data.F.rows();++i)
        for (unsigned j=0;j<3;++j)
          meshgl.V_normals_vbo.row(i*3+j) =
             per_corner_normals ?
               data.F_normals.row(i*3+j).cast<float>() :
               data.F_normals.row(i).cast<float>();
 
      if (invert_normals)
        meshgl.V_normals_vbo = -meshgl.V_normals_vbo;
    }
 
    if (meshgl.dirty & MeshGL::DIRTY_FACE)
    {
      meshgl.F_vbo.resize(data.F.rows(),3);
      for (unsigned i=0; i<data.F.rows();++i)
        meshgl.F_vbo.row(i) << i*3+0, i*3+1, i*3+2;
    }
 
    if (meshgl.dirty & MeshGL::DIRTY_UV)
    {
        meshgl.V_uv_vbo.resize(data.F.rows()*3,2);
        for (unsigned i=0; i<data.F.rows();++i)
          for (unsigned j=0;j<3;++j)
            meshgl.V_uv_vbo.row(i*3+j) = data.V_uv.row(per_corner_uv ? data.F_uv(i,j) : data.F(i,j)).cast<float>();
    }
  }
 
  if (meshgl.dirty & MeshGL::DIRTY_TEXTURE)
  {
    meshgl.tex_u = data.texture_R.rows();
    meshgl.tex_v = data.texture_R.cols();
    meshgl.tex.resize(data.texture_R.size()*4);
    for (unsigned i=0;i<data.texture_R.size();++i)
    {
      meshgl.tex(i*4+0) = data.texture_R(i);
      meshgl.tex(i*4+1) = data.texture_G(i);
      meshgl.tex(i*4+2) = data.texture_B(i);
      meshgl.tex(i*4+3) = data.texture_A(i);
    }
  }
 
  if (meshgl.dirty & MeshGL::DIRTY_OVERLAY_LINES)
  {
    meshgl.lines_V_vbo.resize(data.lines.rows()*2,3);
    meshgl.lines_V_colors_vbo.resize(data.lines.rows()*2,3);
    meshgl.lines_F_vbo.resize(data.lines.rows()*2,1);
    for (unsigned i=0; i<data.lines.rows();++i)
    {
      meshgl.lines_V_vbo.row(2*i+0) = data.lines.block<1, 3>(i, 0).cast<float>();
      meshgl.lines_V_vbo.row(2*i+1) = data.lines.block<1, 3>(i, 3).cast<float>();
      meshgl.lines_V_colors_vbo.row(2*i+0) = data.lines.block<1, 3>(i, 6).cast<float>();
      meshgl.lines_V_colors_vbo.row(2*i+1) = data.lines.block<1, 3>(i, 6).cast<float>();
      meshgl.lines_F_vbo(2*i+0) = 2*i+0;
      meshgl.lines_F_vbo(2*i+1) = 2*i+1;
    }
  }
 
  if (meshgl.dirty & MeshGL::DIRTY_OVERLAY_POINTS)
  {
    meshgl.points_V_vbo.resize(data.points.rows(),3);
    meshgl.points_V_colors_vbo.resize(data.points.rows(),3);
    meshgl.points_F_vbo.resize(data.points.rows(),1);
    for (unsigned i=0; i<data.points.rows();++i)
    {
      meshgl.points_V_vbo.row(i) = data.points.block<1, 3>(i, 0).cast<float>();
      meshgl.points_V_colors_vbo.row(i) = data.points.block<1, 3>(i, 3).cast<float>();
      meshgl.points_F_vbo(i) = i;
    }
  }
}

References igl::opengl::MeshGL::dirty, igl::opengl::MeshGL::DIRTY_AMBIENT, igl::opengl::MeshGL::DIRTY_DIFFUSE, igl::opengl::MeshGL::DIRTY_FACE, igl::opengl::MeshGL::DIRTY_NORMAL, igl::opengl::MeshGL::DIRTY_OVERLAY_LINES, igl::opengl::MeshGL::DIRTY_OVERLAY_POINTS, igl::opengl::MeshGL::DIRTY_POSITION, igl::opengl::MeshGL::DIRTY_SPECULAR, igl::opengl::MeshGL::DIRTY_TEXTURE, igl::opengl::MeshGL::DIRTY_UV, igl::opengl::MeshGL::F_vbo, igl::opengl::MeshGL::init(), igl::opengl::MeshGL::is_initialized, igl::opengl::MeshGL::lines_F_vbo, igl::opengl::MeshGL::lines_V_colors_vbo, igl::opengl::MeshGL::lines_V_vbo, igl::per_corner_normals(), igl::opengl::MeshGL::points_F_vbo, igl::opengl::MeshGL::points_V_colors_vbo, igl::opengl::MeshGL::points_V_vbo, Eigen::PlainObjectBase< Derived >::resize(), igl::opengl::MeshGL::tex, igl::opengl::MeshGL::tex_u, igl::opengl::MeshGL::tex_v, igl::opengl::MeshGL::V_ambient_vbo, igl::opengl::MeshGL::V_diffuse_vbo, igl::opengl::MeshGL::V_normals_vbo, igl::opengl::MeshGL::V_specular_vbo, igl::opengl::MeshGL::V_uv_vbo, and igl::opengl::MeshGL::V_vbo.

Here is the call graph for this function:

Member Data Documentation

dirty

uint32_t igl::opengl::ViewerData::dirty

Referenced by igl::serialization::deserialize(), igl::opengl::glfw::imgui::ImGuiMenu::draw_viewer_menu(), and igl::opengl::glfw::Viewer::key_pressed().

F

Eigen::MatrixXi igl::opengl::ViewerData::F

Referenced by igl::opengl::glfw::imgui::ImGuiMenu::draw_viewer_menu().

F_material_ambient

Eigen::MatrixXd igl::opengl::ViewerData::F_material_ambient

F_material_diffuse

Eigen::MatrixXd igl::opengl::ViewerData::F_material_diffuse

F_material_specular

Eigen::MatrixXd igl::opengl::ViewerData::F_material_specular

F_normals

Eigen::MatrixXd igl::opengl::ViewerData::F_normals

F_uv

Eigen::MatrixXi igl::opengl::ViewerData::F_uv

face_based

bool igl::opengl::ViewerData::face_based

Referenced by igl::opengl::glfw::imgui::ImGuiMenu::draw_viewer_menu().

id

int igl::opengl::ViewerData::id

invert_normals

bool igl::opengl::ViewerData::invert_normals

Referenced by igl::opengl::glfw::imgui::ImGuiMenu::draw_viewer_menu(), and igl::opengl::glfw::Viewer::key_pressed().

labels_positions

Eigen::MatrixXd igl::opengl::ViewerData::labels_positions

labels_strings

std::vector<std::string> igl::opengl::ViewerData::labels_strings

line_color

Eigen::Vector4f igl::opengl::ViewerData::line_color

Referenced by igl::opengl::glfw::imgui::ImGuiMenu::draw_viewer_menu().

line_width

float igl::opengl::ViewerData::line_width

lines

Eigen::MatrixXd igl::opengl::ViewerData::lines

meshgl

igl::opengl::MeshGL igl::opengl::ViewerData::meshgl

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

point_size

float igl::opengl::ViewerData::point_size

points

Eigen::MatrixXd igl::opengl::ViewerData::points

shininess

float igl::opengl::ViewerData::shininess

Referenced by igl::opengl::glfw::imgui::ImGuiMenu::draw_viewer_menu().

show_faceid

bool igl::opengl::ViewerData::show_faceid

Referenced by igl::opengl::glfw::imgui::ImGuiMenu::draw_viewer_menu(), and igl::opengl::glfw::Viewer::key_pressed().

show_faces

bool igl::opengl::ViewerData::show_faces

Referenced by igl::opengl::glfw::imgui::ImGuiMenu::draw_viewer_menu(), and igl::opengl::glfw::Viewer::key_pressed().

show_lines

bool igl::opengl::ViewerData::show_lines

Referenced by igl::opengl::glfw::imgui::ImGuiMenu::draw_viewer_menu(), and igl::opengl::glfw::Viewer::key_pressed().

show_overlay

bool igl::opengl::ViewerData::show_overlay

Referenced by igl::opengl::glfw::imgui::ImGuiMenu::draw_viewer_menu().

show_overlay_depth

bool igl::opengl::ViewerData::show_overlay_depth

Referenced by igl::opengl::glfw::imgui::ImGuiMenu::draw_viewer_menu().

show_texture

bool igl::opengl::ViewerData::show_texture

Referenced by igl::opengl::glfw::imgui::ImGuiMenu::draw_viewer_menu().

show_vertid

bool igl::opengl::ViewerData::show_vertid

Referenced by igl::opengl::glfw::imgui::ImGuiMenu::draw_viewer_menu(), and igl::opengl::glfw::Viewer::key_pressed().

texture_A

Eigen::Matrix<unsigned char,Eigen::Dynamic,Eigen::Dynamic> igl::opengl::ViewerData::texture_A

texture_B

Eigen::Matrix<unsigned char,Eigen::Dynamic,Eigen::Dynamic> igl::opengl::ViewerData::texture_B

texture_G

Eigen::Matrix<unsigned char,Eigen::Dynamic,Eigen::Dynamic> igl::opengl::ViewerData::texture_G

texture_R

Eigen::Matrix<unsigned char,Eigen::Dynamic,Eigen::Dynamic> igl::opengl::ViewerData::texture_R

V

Eigen::MatrixXd igl::opengl::ViewerData::V

Referenced by igl::opengl::glfw::imgui::ImGuiMenu::draw_viewer_menu(), and igl::opengl::glfw::Viewer::mouse_down().

V_material_ambient

Eigen::MatrixXd igl::opengl::ViewerData::V_material_ambient

V_material_diffuse

Eigen::MatrixXd igl::opengl::ViewerData::V_material_diffuse

V_material_specular

Eigen::MatrixXd igl::opengl::ViewerData::V_material_specular

V_normals

Eigen::MatrixXd igl::opengl::ViewerData::V_normals

V_uv

Eigen::MatrixXd igl::opengl::ViewerData::V_uv

---

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

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