Merge branch 'master' of https://github.com/danielepanozzo/libigl

Former-commit-id: f94cd7e5c7eb52a409a26775a67535184958e7cb

include/igl/viewer/OpenGL_state.cpp

@@ -176,7 +176,7 @@ IGL_INLINE void igl::viewer::OpenGL_state::set_data(const igl::viewer::ViewerDat
 
     if (dirty & ViewerData::DIRTY_AMBIENT)
     {
-      V_ambient_vbo.resize(3,data.F.rows()*3);
+      V_ambient_vbo.resize(4,data.F.rows()*3);
       for (unsigned i=0; i<data.F.rows();++i)
         for (unsigned j=0;j<3;++j)
           V_ambient_vbo.col (i*3+j) = data.F_material_ambient.row(i).transpose().cast<float>();
@@ -184,7 +184,7 @@ IGL_INLINE void igl::viewer::OpenGL_state::set_data(const igl::viewer::ViewerDat
 
     if (dirty & ViewerData::DIRTY_DIFFUSE)
     {
-      V_diffuse_vbo.resize(3,data.F.rows()*3);
+      V_diffuse_vbo.resize(4,data.F.rows()*3);
       for (unsigned i=0; i<data.F.rows();++i)
         for (unsigned j=0;j<3;++j)
           V_diffuse_vbo.col (i*3+j) = data.F_material_diffuse.row(i).transpose().cast<float>();
@@ -192,7 +192,7 @@ IGL_INLINE void igl::viewer::OpenGL_state::set_data(const igl::viewer::ViewerDat
 
     if (dirty & ViewerData::DIRTY_SPECULAR)
     {
-      V_specular_vbo.resize(3,data.F.rows()*3);
+      V_specular_vbo.resize(4,data.F.rows()*3);
       for (unsigned i=0; i<data.F.rows();++i)
         for (unsigned j=0;j<3;++j)
           V_specular_vbo.col(i*3+j) = data.F_material_specular.row(i).transpose().cast<float>();
@@ -232,12 +232,13 @@ IGL_INLINE void igl::viewer::OpenGL_state::set_data(const igl::viewer::ViewerDat
   {
     tex_u = data.texture_R.rows();
     tex_v = data.texture_R.cols();
-    tex.resize(data.texture_R.size()*3);
+    tex.resize(data.texture_R.size()*4);
     for (unsigned i=0;i<data.texture_R.size();++i)
     {
-      tex(i*3+0) = data.texture_R(i);
-      tex(i*3+1) = data.texture_G(i);
-      tex(i*3+2) = data.texture_B(i);
+      tex(i*4+0) = data.texture_R(i);
+      tex(i*4+1) = data.texture_G(i);
+      tex(i*4+2) = data.texture_B(i);
+      tex(i*4+3) = data.texture_A(i);
     }
   }
 
@@ -295,7 +296,7 @@ IGL_INLINE void igl::viewer::OpenGL_state::bind_mesh()
     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_RGB, tex_u, tex_v, 0, GL_RGB, GL_UNSIGNED_BYTE, tex.data());
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, tex_u, tex_v, 0, GL_RGBA, GL_UNSIGNED_BYTE, tex.data());
   }
   glUniform1i(shader_mesh.uniform("tex"), 0);
   dirty &= ~ViewerData::DIRTY_MESH;
@@ -370,14 +371,14 @@ IGL_INLINE void igl::viewer::OpenGL_state::init()
   "in vec3 normal;"
   "out vec3 position_eye;"
   "out vec3 normal_eye;"
-  "in vec3 Ka;"
-  "in vec3 Kd;"
-  "in vec3 Ks;"
+  "in vec4 Ka;"
+  "in vec4 Kd;"
+  "in vec4 Ks;"
   "in vec2 texcoord;"
   "out vec2 texcoordi;"
-  "out vec3 Kai;"
-  "out vec3 Kdi;"
-  "out vec3 Ksi;"
+  "out vec4 Kai;"
+  "out vec4 Kdi;"
+  "out vec4 Ksi;"
 
   "void main()"
   "{"
@@ -403,9 +404,9 @@ IGL_INLINE void igl::viewer::OpenGL_state::init()
   "vec3 Ls = vec3 (1, 1, 1);"
   "vec3 Ld = vec3 (1, 1, 1);"
   "vec3 La = vec3 (1, 1, 1);"
-  "in vec3 Ksi;"
-  "in vec3 Kdi;"
-  "in vec3 Kai;"
+  "in vec4 Ksi;"
+  "in vec4 Kdi;"
+  "in vec4 Kai;"
   "in vec2 texcoordi;"
   "uniform sampler2D tex;"
   "uniform float specular_exponent;"
@@ -414,22 +415,22 @@ IGL_INLINE void igl::viewer::OpenGL_state::init()
   "out vec4 outColor;"
   "void main()"
   "{"
-  "vec3 Ia = La * Kai;"    // ambient intensity
+  "vec3 Ia = La * vec3(Kai);"    // ambient intensity
 
   "vec3 light_position_eye = vec3 (view * vec4 (light_position_world, 1.0));"
   "vec3 vector_to_light_eye = light_position_eye - position_eye;"
   "vec3 direction_to_light_eye = normalize (vector_to_light_eye);"
   "float dot_prod = dot (direction_to_light_eye, normal_eye);"
   "float clamped_dot_prod = max (dot_prod, 0.0);"
-  "vec3 Id = Ld * Kdi * clamped_dot_prod;"    // Diffuse intensity
+  "vec3 Id = Ld * vec3(Kdi) * clamped_dot_prod;"    // Diffuse intensity
 
   "vec3 reflection_eye = reflect (-direction_to_light_eye, normal_eye);"
   "vec3 surface_to_viewer_eye = normalize (-position_eye);"
   "float dot_prod_specular = dot (reflection_eye, surface_to_viewer_eye);"
   "dot_prod_specular = float(abs(dot_prod)==dot_prod) * max (dot_prod_specular, 0.0);"
   "float specular_factor = pow (dot_prod_specular, specular_exponent);"
-  "vec3 Is = Ls * Ksi * specular_factor;"    // specular intensity
-  "vec4 color = vec4(lighting_factor * (Is + Id) + Ia, 1.0) + vec4((1.0-lighting_factor) * Kdi,1.0);"
+  "vec3 Is = Ls * vec3(Ksi) * specular_factor;"    // specular intensity
+  "vec4 color = vec4(lighting_factor * (Is + Id) + Ia + (1.0-lighting_factor) * vec3(Kdi),(Kai.a+Ksi.a+Kdi.a)/3);"
   "outColor = mix(vec4(1,1,1,1), texture(tex, texcoordi), texture_factor) * color;"
   "if (fixed_color != vec4(0.0)) outColor = fixed_color;"
   "}";

include/igl/viewer/ViewerCore.cpp

@@ -17,77 +17,6 @@
 #include <Eigen/Geometry>
 #include <iostream>
 
-#ifdef ENABLE_SERIALIZATION
-#include <igl/serialize.h>
-namespace igl {
-  namespace serialization {
-
-    IGL_INLINE void serialization(bool s,igl::viewer::ViewerCore& obj,std::vector<char>& buffer)
-    {
-      SERIALIZE_MEMBER(shininess);
-
-      SERIALIZE_MEMBER(background_color);
-      SERIALIZE_MEMBER(line_color);
-
-      SERIALIZE_MEMBER(light_position);
-      SERIALIZE_MEMBER(lighting_factor);
-
-      SERIALIZE_MEMBER(trackball_angle);
-      SERIALIZE_MEMBER(rotation_type);
-
-      SERIALIZE_MEMBER(model_zoom);
-      SERIALIZE_MEMBER(model_translation);
-
-      SERIALIZE_MEMBER(model_zoom_uv);
-      SERIALIZE_MEMBER(model_translation_uv);
-
-      SERIALIZE_MEMBER(camera_zoom);
-      SERIALIZE_MEMBER(orthographic);
-      SERIALIZE_MEMBER(camera_view_angle);
-      SERIALIZE_MEMBER(camera_dnear);
-      SERIALIZE_MEMBER(camera_dfar);
-      SERIALIZE_MEMBER(camera_eye);
-      SERIALIZE_MEMBER(camera_center);
-      SERIALIZE_MEMBER(camera_up);
-
-      SERIALIZE_MEMBER(show_faces);
-      SERIALIZE_MEMBER(show_lines);
-      SERIALIZE_MEMBER(invert_normals);
-      SERIALIZE_MEMBER(show_overlay);
-      SERIALIZE_MEMBER(show_overlay_depth);
-      SERIALIZE_MEMBER(show_vertid);
-      SERIALIZE_MEMBER(show_faceid);
-      SERIALIZE_MEMBER(show_texture);
-      SERIALIZE_MEMBER(depth_test);
-
-      SERIALIZE_MEMBER(point_size);
-      SERIALIZE_MEMBER(line_width);
-      SERIALIZE_MEMBER(is_animating);
-      SERIALIZE_MEMBER(animation_max_fps);
-
-      SERIALIZE_MEMBER(object_scale);
-
-      SERIALIZE_MEMBER(viewport);
-      SERIALIZE_MEMBER(view);
-      SERIALIZE_MEMBER(model);
-      SERIALIZE_MEMBER(proj);
-    }
-
-    template<>
-    IGL_INLINE void serialize(const igl::viewer::ViewerCore& obj,std::vector<char>& buffer)
-    {
-      serialization(true,const_cast<igl::viewer::ViewerCore&>(obj),buffer);
-    }
-
-    template<>
-    IGL_INLINE void deserialize(igl::viewer::ViewerCore& obj,const std::vector<char>& buffer)
-    {
-      serialization(false,obj,const_cast<std::vector<char>&>(buffer));
-    }
-  }
-}
-#endif
-
 IGL_INLINE void igl::viewer::ViewerCore::align_camera_center(
   const Eigen::MatrixXd& V,
   const Eigen::MatrixXi& F)
@@ -164,8 +93,8 @@ IGL_INLINE void igl::viewer::ViewerCore::clear_framebuffers()
 }
 
 IGL_INLINE void igl::viewer::ViewerCore::draw(
-  ViewerData& data, 
-  OpenGL_state& opengl, 
+  ViewerData& data,
+  OpenGL_state& opengl,
   bool update_matrices)
 {
   using namespace std;
@@ -176,6 +105,9 @@ IGL_INLINE void igl::viewer::ViewerCore::draw(
   else
     glDisable(GL_DEPTH_TEST);
 
+  glEnable(GL_BLEND);
+  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
   /* Bind and potentially refresh mesh/line/point data */
   if (data.dirty)
   {

include/igl/viewer/ViewerCore.h

@@ -168,6 +168,77 @@ public:
 }
 }
 
+#ifdef ENABLE_SERIALIZATION
+#include <igl/serialize.h>
+namespace igl {
+	namespace serialization {
+
+		inline void serialization(bool s, igl::viewer::ViewerCore& obj, std::vector<char>& buffer)
+		{
+			SERIALIZE_MEMBER(shininess);
+
+			SERIALIZE_MEMBER(background_color);
+			SERIALIZE_MEMBER(line_color);
+
+			SERIALIZE_MEMBER(light_position);
+			SERIALIZE_MEMBER(lighting_factor);
+
+			SERIALIZE_MEMBER(trackball_angle);
+			SERIALIZE_MEMBER(rotation_type);
+
+			SERIALIZE_MEMBER(model_zoom);
+			SERIALIZE_MEMBER(model_translation);
+
+			SERIALIZE_MEMBER(model_zoom_uv);
+			SERIALIZE_MEMBER(model_translation_uv);
+
+			SERIALIZE_MEMBER(camera_zoom);
+			SERIALIZE_MEMBER(orthographic);
+			SERIALIZE_MEMBER(camera_view_angle);
+			SERIALIZE_MEMBER(camera_dnear);
+			SERIALIZE_MEMBER(camera_dfar);
+			SERIALIZE_MEMBER(camera_eye);
+			SERIALIZE_MEMBER(camera_center);
+			SERIALIZE_MEMBER(camera_up);
+
+			SERIALIZE_MEMBER(show_faces);
+			SERIALIZE_MEMBER(show_lines);
+			SERIALIZE_MEMBER(invert_normals);
+			SERIALIZE_MEMBER(show_overlay);
+			SERIALIZE_MEMBER(show_overlay_depth);
+			SERIALIZE_MEMBER(show_vertid);
+			SERIALIZE_MEMBER(show_faceid);
+			SERIALIZE_MEMBER(show_texture);
+			SERIALIZE_MEMBER(depth_test);
+
+			SERIALIZE_MEMBER(point_size);
+			SERIALIZE_MEMBER(line_width);
+			SERIALIZE_MEMBER(is_animating);
+			SERIALIZE_MEMBER(animation_max_fps);
+
+			SERIALIZE_MEMBER(object_scale);
+
+			SERIALIZE_MEMBER(viewport);
+			SERIALIZE_MEMBER(view);
+			SERIALIZE_MEMBER(model);
+			SERIALIZE_MEMBER(proj);
+		}
+
+		template<>
+		inline void serialize(const igl::viewer::ViewerCore& obj, std::vector<char>& buffer)
+		{
+			serialization(true, const_cast<igl::viewer::ViewerCore&>(obj), buffer);
+		}
+
+		template<>
+		inline void deserialize(igl::viewer::ViewerCore& obj, const std::vector<char>& buffer)
+		{
+			serialization(false, obj, const_cast<std::vector<char>&>(buffer));
+		}
+  }
+}
+#endif
+
 #ifndef IGL_STATIC_LIBRARY
 #  include "ViewerCore.cpp"
 #endif

include/igl/viewer/ViewerData.cpp

@@ -15,60 +15,6 @@
 #include <igl/parula.h>
 #include <igl/per_vertex_normals.h>
 
-#ifdef ENABLE_SERIALIZATION
-#include <igl/serialize.h>
-namespace igl {
-  namespace serialization {
-
-    IGL_INLINE void serialization(bool s,igl::viewer::ViewerData& obj,std::vector<char>& buffer)
-    {
-      SERIALIZE_MEMBER(V);
-      SERIALIZE_MEMBER(F);
-
-      SERIALIZE_MEMBER(F_normals);
-      SERIALIZE_MEMBER(F_material_ambient);
-      SERIALIZE_MEMBER(F_material_diffuse);
-      SERIALIZE_MEMBER(F_material_specular);
-
-      SERIALIZE_MEMBER(V_normals);
-      SERIALIZE_MEMBER(V_material_ambient);
-      SERIALIZE_MEMBER(V_material_diffuse);
-      SERIALIZE_MEMBER(V_material_specular);
-
-      SERIALIZE_MEMBER(V_uv);
-      SERIALIZE_MEMBER(F_uv);
-
-      SERIALIZE_MEMBER(texture_R);
-      SERIALIZE_MEMBER(texture_G);
-      SERIALIZE_MEMBER(texture_B);
-
-      SERIALIZE_MEMBER(lines);
-      SERIALIZE_MEMBER(points);
-
-      SERIALIZE_MEMBER(labels_positions);
-      SERIALIZE_MEMBER(labels_strings);
-
-      SERIALIZE_MEMBER(dirty);
-
-      SERIALIZE_MEMBER(face_based);
-    }
-
-    template<>
-    IGL_INLINE void serialize(const igl::viewer::ViewerData& obj,std::vector<char>& buffer)
-    {
-      serialization(true,const_cast<igl::viewer::ViewerData&>(obj),buffer);
-    }
-
-    template<>
-    IGL_INLINE void deserialize(igl::viewer::ViewerData& obj,const std::vector<char>& buffer)
-    {
-      serialization(false,obj,const_cast<std::vector<char>&>(buffer));
-      obj.dirty = igl::viewer::ViewerData::DIRTY_ALL;
-    }
-  }
-}
-#endif
-
 IGL_INLINE igl::viewer::ViewerData::ViewerData()
 : dirty(DIRTY_ALL)
 {
@@ -164,27 +110,31 @@ IGL_INLINE void igl::viewer::ViewerData::set_colors(const Eigen::MatrixXd &C)
   // Ambient color should be darker color
   const auto ambient = [](const MatrixXd & C)->MatrixXd
   {
-    return 0.1*C;
+    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;
-    return grey+0.1*(C.array()-grey);
+    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)
     {
-      V_material_diffuse.row(i) = C.row(0);
+      V_material_diffuse.row(i) << C.row(0),1;
     }
     V_material_ambient = ambient(V_material_diffuse);
     V_material_specular = specular(V_material_diffuse);
 
     for (unsigned i=0;i<F_material_diffuse.rows();++i)
     {
-      F_material_diffuse.row(i) = C.row(0);
+      F_material_diffuse.row(i) << C.row(0),1;
     }
     F_material_ambient = ambient(F_material_diffuse);
     F_material_specular = specular(F_material_diffuse);
@@ -192,14 +142,20 @@ IGL_INLINE void igl::viewer::ViewerData::set_colors(const Eigen::MatrixXd &C)
   else if (C.rows() == V.rows())
   {
     set_face_based(false);
-    V_material_diffuse = C;
+    for (unsigned i=0;i<V_material_diffuse.rows();++i)
+    {
+      V_material_diffuse.row(i) << C.row(i),1;
+    }
     V_material_ambient = ambient(V_material_diffuse);
     V_material_specular = specular(V_material_diffuse);
   }
   else if (C.rows() == F.rows())
   {
     set_face_based(true);
-    F_material_diffuse = C;
+    for (unsigned i=0;i<F_material_diffuse.rows();++i)
+    {
+      F_material_diffuse.row(i) << C.row(i),1;
+    }
     F_material_ambient = ambient(F_material_diffuse);
     F_material_specular = specular(F_material_diffuse);
   }
@@ -239,6 +195,20 @@ IGL_INLINE void igl::viewer::ViewerData::set_texture(
   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 |= DIRTY_TEXTURE;
+}
+
+IGL_INLINE void igl::viewer::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 |= DIRTY_TEXTURE;
 }
 
@@ -345,13 +315,13 @@ IGL_INLINE void igl::viewer::ViewerData::clear()
   V                       = Eigen::MatrixXd (0,3);
   F                       = Eigen::MatrixXi (0,3);
 
-  F_material_ambient      = Eigen::MatrixXd (0,3);
-  F_material_diffuse      = Eigen::MatrixXd (0,3);
-  F_material_specular     = Eigen::MatrixXd (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,3);
-  V_material_diffuse      = Eigen::MatrixXd (0,3);
-  V_material_specular     = Eigen::MatrixXd (0,3);
+  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);
@@ -376,9 +346,22 @@ IGL_INLINE void igl::viewer::ViewerData::compute_normals()
 
 IGL_INLINE void igl::viewer::ViewerData::uniform_colors(Eigen::Vector3d ambient, Eigen::Vector3d diffuse, Eigen::Vector3d specular)
 {
-  V_material_ambient.resize(V.rows(),3);
-  V_material_diffuse.resize(V.rows(),3);
-  V_material_specular.resize(V.rows(),3);
+  Eigen::Vector4d ambient4;
+  Eigen::Vector4d diffuse4;
+  Eigen::Vector4d specular4;
+
+  ambient4 << ambient, 1;
+  diffuse4 << diffuse, 1;
+  specular4 << specular, 1;
+
+  uniform_colors(ambient4,diffuse4,specular4);
+}
+
+IGL_INLINE void igl::viewer::ViewerData::uniform_colors(Eigen::Vector4d ambient, Eigen::Vector4d diffuse, 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)
   {
@@ -387,9 +370,9 @@ IGL_INLINE void igl::viewer::ViewerData::uniform_colors(Eigen::Vector3d ambient,
     V_material_specular.row(i) = specular;
   }
 
-  F_material_ambient.resize(F.rows(),3);
-  F_material_diffuse.resize(F.rows(),3);
-  F_material_specular.resize(F.rows(),3);
+  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)
   {
@@ -434,5 +417,6 @@ IGL_INLINE void igl::viewer::ViewerData::grid_texture()
 
   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 |= DIRTY_TEXTURE;
 }

include/igl/viewer/ViewerData.h

@@ -83,6 +83,20 @@ public:
     const Eigen::Matrix<unsigned char,Eigen::Dynamic,Eigen::Dynamic>& G,
     const Eigen::Matrix<unsigned char,Eigen::Dynamic,Eigen::Dynamic>& B);
 
+  // Set the texture associated with the mesh.
+  //
+  // Inputs:
+  //   R  width by height image matrix of red channel
+  //   G  width by height image matrix of green channel
+  //   B  width by height image matrix of blue channel
+  //   A  width by height image matrix of alpha channel
+  //
+  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);
+
   // Sets points given a list of point vertices. In constrast to `set_points`
   // this will (purposefully) clober existing points.
   //
@@ -90,7 +104,7 @@ public:
   //   P  #P by 3 list of vertex positions
   //   C  #P|1 by 3 color(s)
   IGL_INLINE void set_points(
-    const Eigen::MatrixXd& P,  
+    const Eigen::MatrixXd& P,
     const Eigen::MatrixXd& C);
   IGL_INLINE void add_points(const Eigen::MatrixXd& P,  const Eigen::MatrixXd& C);
   // Sets edges given a list of edge vertices and edge indices. In constrast
@@ -109,10 +123,16 @@ public:
 
   // Assigns uniform colors to all faces/vertices
   IGL_INLINE void uniform_colors(
-    Eigen::Vector3d ambient, 
-    Eigen::Vector3d diffuse, 
+    Eigen::Vector3d ambient,
+    Eigen::Vector3d diffuse,
     Eigen::Vector3d specular);
 
+  // Assigns uniform colors to all faces/vertices
+  IGL_INLINE void uniform_colors(
+    Eigen::Vector4d ambient,
+    Eigen::Vector4d diffuse,
+    Eigen::Vector4d specular);
+
   // Generates a default grid texture
   IGL_INLINE void grid_texture();
 
@@ -141,6 +161,7 @@ public:
   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;
 
   // Overlays
 
@@ -171,6 +192,61 @@ public:
 }
 }
 
+#ifdef ENABLE_SERIALIZATION
+#include <igl/serialize.h>
+namespace igl {
+	namespace serialization {
+
+		inline void serialization(bool s, igl::viewer::ViewerData& obj, std::vector<char>& buffer)
+		{
+			SERIALIZE_MEMBER(V);
+			SERIALIZE_MEMBER(F);
+
+			SERIALIZE_MEMBER(F_normals);
+			SERIALIZE_MEMBER(F_material_ambient);
+			SERIALIZE_MEMBER(F_material_diffuse);
+			SERIALIZE_MEMBER(F_material_specular);
+
+			SERIALIZE_MEMBER(V_normals);
+			SERIALIZE_MEMBER(V_material_ambient);
+			SERIALIZE_MEMBER(V_material_diffuse);
+			SERIALIZE_MEMBER(V_material_specular);
+
+			SERIALIZE_MEMBER(V_uv);
+			SERIALIZE_MEMBER(F_uv);
+
+			SERIALIZE_MEMBER(texture_R);
+			SERIALIZE_MEMBER(texture_G);
+			SERIALIZE_MEMBER(texture_B);
+      SERIALIZE_MEMBER(texture_A);
+
+			SERIALIZE_MEMBER(lines);
+			SERIALIZE_MEMBER(points);
+
+			SERIALIZE_MEMBER(labels_positions);
+			SERIALIZE_MEMBER(labels_strings);
+
+			SERIALIZE_MEMBER(dirty);
+
+			SERIALIZE_MEMBER(face_based);
+		}
+
+		template<>
+		inline void serialize(const igl::viewer::ViewerData& obj, std::vector<char>& buffer)
+		{
+			serialization(true, const_cast<igl::viewer::ViewerData&>(obj), buffer);
+		}
+
+		template<>
+		inline void deserialize(igl::viewer::ViewerData& obj, const std::vector<char>& buffer)
+		{
+			serialization(false, obj, const_cast<std::vector<char>&>(buffer));
+			obj.dirty = igl::viewer::ViewerData::DIRTY_ALL;
+		}
+	}
+}
+#endif
+
 #ifndef IGL_STATIC_LIBRARY
 #  include "ViewerData.cpp"
 #endif

include/igl/viewer/ViewerPlugin.h

@@ -158,12 +158,12 @@ protected:
 #ifdef ENABLE_SERIALIZATION
 namespace serialization
 {
-  IGL_INLINE void serialize(const ViewerPlugin& obj,std::vector<char>& buffer)
+  inline void serialize(const ViewerPlugin& obj,std::vector<char>& buffer)
   {
     obj.serialize(buffer);
   }
 
-  IGL_INLINE void deserialize(ViewerPlugin& obj,const std::vector<char>& buffer)
+  inline void deserialize(ViewerPlugin& obj,const std::vector<char>& buffer)
   {
     obj.deserialize(buffer);
   }

tutorial/707_SweptVolume/main.cpp

@@ -69,11 +69,12 @@ int main(int argc, char * argv[])
           if(show_swept_volume)
           {
             viewer.data.set_mesh(SV,SF);
-            viewer.data.uniform_colors(
-              {SILVER_AMBIENT[0], SILVER_AMBIENT[1], SILVER_AMBIENT[2]},
-              {SILVER_DIFFUSE[0], SILVER_DIFFUSE[1], SILVER_DIFFUSE[2]},
-              {SILVER_SPECULAR[0], SILVER_SPECULAR[1], SILVER_SPECULAR[2]});
-          }else
+            Eigen::Vector3d ambient = Eigen::Vector3d(SILVER_AMBIENT[0], SILVER_AMBIENT[1], SILVER_AMBIENT[2]);
+            Eigen::Vector3d diffuse = Eigen::Vector3d(SILVER_DIFFUSE[0], SILVER_DIFFUSE[1], SILVER_DIFFUSE[2]);
+            Eigen::Vector3d specular = Eigen::Vector3d(SILVER_SPECULAR[0], SILVER_SPECULAR[1], SILVER_SPECULAR[2]);
+            viewer.data.uniform_colors(ambient,diffuse,specular);
+          }
+          else
           {
             viewer.data.set_mesh(V,F);
           }