Merge branch 'develop' of icube-forge.unistra.fr:cgogn/cgogn into develop

Conflicts:
	SCHNApps/Plugins/surface_renderVector/src/surface_renderVector_dockTab.cpp

CGoGN/include/Geometry/bounding_box.h

@@ -37,95 +37,95 @@ namespace Geom
 template <typename VEC>
 class BoundingBox
 {
-	public:
-		/**********************************************/
-		/*                CONSTRUCTORS                */
-		/**********************************************/
+public:
+	/**********************************************/
+	/*                CONSTRUCTORS                */
+	/**********************************************/
 
-		BoundingBox() ;
+	BoundingBox() ;
 
-		// initialize the bounding box with one first point
-		BoundingBox(const VEC& p) ;
+	// initialize the bounding box with one first point
+	BoundingBox(const VEC& p) ;
 
-		/**********************************************/
-		/*                 ACCESSORS                  */
-		/**********************************************/
+	/**********************************************/
+	/*                 ACCESSORS                  */
+	/**********************************************/
 
-		VEC& min() ;
+	VEC& min() ;
 
-		const VEC& min() const ;
+	const VEC& min() const ;
 
-		VEC& max() ;
+	VEC& max() ;
 
-		const VEC& max() const ;
+	const VEC& max() const ;
 
-		typename VEC::DATA_TYPE size(unsigned int coord) const ;
+	typename VEC::DATA_TYPE size(unsigned int coord) const ;
 
-		typename VEC::DATA_TYPE maxSize() const ;
+	typename VEC::DATA_TYPE maxSize() const ;
 
-		typename VEC::DATA_TYPE minSize() const ;
+	typename VEC::DATA_TYPE minSize() const ;
 
-		VEC diag() const ;
+	VEC diag() const ;
 
-		typename VEC::DATA_TYPE diagSize() const ;
+	typename VEC::DATA_TYPE diagSize() const ;
 
-		VEC center() const ;
+	VEC center() const ;
 
-		bool isInitialized() const ;
+	bool isInitialized() const ;
 
-		/**********************************************/
-		/*                 FUNCTIONS                  */
-		/**********************************************/
+	/**********************************************/
+	/*                 FUNCTIONS                  */
+	/**********************************************/
 
-		// reinitialize the bounding box
-		void reset() ;
+	// reinitialize the bounding box
+	void reset() ;
 
-		// add a point to the bounding box
-		void addPoint(const VEC& p) ;
+	// add a point to the bounding box
+	void addPoint(const VEC& p) ;
 
-		// return true if bb intersects the bounding box
-		bool intersects(const BoundingBox<VEC>& bb) ;
+	// return true if bb intersects the bounding box
+	bool intersects(const BoundingBox<VEC>& bb) ;
 
-		// fusion with the given bounding box
-		void fusion(const BoundingBox<VEC>& bb) ;
+	// fusion with the given bounding box
+	void fusion(const BoundingBox<VEC>& bb) ;
 
-		// return true if the point belongs strictly to a bounding box
-		bool contains(const VEC& p);
+	// return true if the point belongs strictly to a bounding box
+	bool contains(const VEC& p);
 
-		// return true if the segment belongs strictly to a bounding box
-		bool contains(const VEC& a, const VEC& b);
+	// return true if the segment belongs strictly to a bounding box
+	bool contains(const VEC& a, const VEC& b);
 
-		// return true if the bounding box belongs strictly to a bounding box
-		bool contains(const BoundingBox<VEC> & bb);
+	// return true if the bounding box belongs strictly to a bounding box
+	bool contains(const BoundingBox<VEC> & bb);
 
-		// scale the bounding box
-		void scale(typename VEC::DATA_TYPE size);
+	// scale the bounding box
+	void scale(typename VEC::DATA_TYPE size);
 
-		// 0-centered scale of the bounding box
-		void centeredScale(typename VEC::DATA_TYPE size);
+	// 0-centered scale of the bounding box
+	void centeredScale(typename VEC::DATA_TYPE size);
 
-		/// test if bb is intersected by a ray
-		bool rayIntersect(const VEC& P, const VEC& V) const;
+	/// test if bb is intersected by a ray
+	bool rayIntersect(const VEC& P, const VEC& V) const;
 
-		/**********************************************/
-		/*             STREAM OPERATORS               */
-		/**********************************************/
+	/**********************************************/
+	/*             STREAM OPERATORS               */
+	/**********************************************/
 
-		friend std::ostream& operator<<(std::ostream& out, const BoundingBox<VEC>& bb)
-		{
-			out << bb.min() << " " << bb.max() ;
-			return out ;
-		}
+	friend std::ostream& operator<<(std::ostream& out, const BoundingBox<VEC>& bb)
+	{
+		out << bb.min() << " " << bb.max() ;
+		return out ;
+	}
 
-		friend std::istream& operator>>(std::istream& in, BoundingBox<VEC>& bb)
-		{
-			in >> bb.min() >> bb.max() ;
-			return in ;
-		}
+	friend std::istream& operator>>(std::istream& in, BoundingBox<VEC>& bb)
+	{
+		in >> bb.min() >> bb.max() ;
+		return in ;
+	}
 
-	private:
-		bool m_initialized ;
-		VEC m_pMin, m_pMax ;
+private:
+	bool m_initialized ;
+	VEC m_pMin, m_pMax ;
 } ;
 
 } // namespace Geom

CGoGN/include/Utils/Shaders/shaderRadiancePerVertex.vert

 // ShaderRadiancePerVertex::vertexShaderText
 
-#extension GL_EXT_gpu_shader4 : enable // need GLSL v1.30 -> if not available, use a uniform for passing textureSize instead of calling textureSize2D
+//#extension GL_EXT_gpu_shader4 : enable // need GLSL v1.30 -> if not available, use a uniform for passing textureSize instead of calling textureSize2D
 
 ATTRIBUTE vec3 VertexPosition;
 ATTRIBUTE vec3 VertexNormal;
@@ -69,7 +69,7 @@ void set_eval_direction (vec3 v)
 
 void main ()
 {
-    int size = (textureSize2D(texture,0)).x; // supposed square matrix
+    int size = (textureSize(texture,0)).x; // supposed square matrix
 
     //init_K_tab();
     vec3 eyeV = normalize(camera - VertexPosition); // normalized outgoing line-of-sight vector

CGoGN/include/Utils/Shaders/shaderRadiancePerVertexInterp.frag

 // ShaderRadiancePerVertex::fragmentShaderInterpText
 
-#extension GL_EXT_gpu_shader4 : enable // need GLSL v1.30 -> if not available, use a uniform for passing textureSize instead of calling textureSize2D
+//#extension GL_EXT_gpu_shader4 : enable // need GLSL v1.30 -> if not available, use a uniform for passing textureSize instead of calling textureSize2D
 
 PRECISION;
 
@@ -75,7 +75,7 @@ void set_eval_direction (vec3 v)
 
 void main (void)
 {
-	int size = (textureSize2D(texture,0)).x; // supposed square matrix
+	int size = (textureSize(texture,0)).x; // supposed square matrix
 
 	vec3 eyeV = normalize(camera - vxPos); // normalized outgoing line-of-sight vector
 	eyeV = 2*dot(vxNorm,eyeV)*vxNorm-eyeV ; // symmetrize

CGoGN/src/Utils/Shaders/shaderColorPerVertex.cpp

@@ -21,10 +21,10 @@
 * Contact information: cgogn@unistra.fr                                        *
 *                                                                              *
 *******************************************************************************/
+
 #define CGoGN_UTILS_DLL_EXPORT 1
 #include "Utils/Shaders/shaderColorPerVertex.h"
 
-
 namespace CGoGN
 {
 
@@ -36,7 +36,6 @@ namespace Utils
 #include "shaderColorPerVertexClip.vert"
 #include "shaderColorPerVertexClip.frag"
 
-
 ShaderColorPerVertex::ShaderColorPerVertex(bool withClipping, bool black_is_transparent)
 {
 	if (withClipping)
@@ -102,7 +101,6 @@ unsigned int ShaderColorPerVertex::setAttributeColor(VBO* vbo)
 	return id;
 }
 
-
 void ShaderColorPerVertex::restoreUniformsAttribs()
 {
 	bind();
@@ -129,8 +127,6 @@ void ShaderColorPerVertex::setClippingPlane(const Geom::Vec4f& plane)
 	unbind();
 }
 
-
-
 } // namespace Utils
 
 } // namespace CGoGN

CGoGN/src/Utils/Shaders/shaderSimpleColor.cpp

@@ -92,7 +92,6 @@ void ShaderSimpleColor::setColor(const Geom::Vec4f& color)
 	unbind();
 }
 
-
 void ShaderSimpleColor::setClippingPlane(const Geom::Vec4f& plane)
 {
 	m_planeClip = plane;
@@ -101,7 +100,6 @@ void ShaderSimpleColor::setClippingPlane(const Geom::Vec4f& plane)
 	unbind();
 }
 
-
 unsigned int ShaderSimpleColor::setAttributePosition(VBO* vbo)
 {
 	m_vboPos = vbo;

CMakeLists.txt

@@ -35,6 +35,12 @@ IF (WIN32)
 	SET ( CGoGN_WITH_QTCREATOR OFF CACHE BOOL "use QtCreator to compile (Experimental" )
 ENDIF()
 
+IF (LINUX)
+	SET ( CGoGN_GCC_4_9 OFF CACHE BOOL "using gcc version > 4.9 (std::regex ok !)" )
+ENDIF()
+
+SET ( BUILD_SHARED_LIBS ON CACHE BOOL "if used all library are build as shared type (.so/.dylib/.dll)" )
+
 
 checkCpp11Support()
 checkCpp11Feature("regex" HAS_CPP11_REGEX "False")
@@ -166,12 +172,8 @@ IF(WIN32)
 ENDIF ()
 
 
-IF (APPLE)
-	LIST(APPEND CGoGN_DEFS -DCGOGN_APPLE)
-ENDIF ()
-
-IF (HAS_CPP11_REGEX)
-	LIST(APPEND CGoGN_DEFS -DHAS_CPP11_REGEX)
+IF (CGoGN_GCC_4_9)
+	LIST(APPEND CGoGN_DEFS -DCGOGN_GCC_4_9)
 ENDIF ()
 
 

SCHNApps/Plugins/CMakeLists.txt

@@ -28,6 +28,8 @@ ADD_SUBDIRECTORY(surface_modelisation)
 ADD_SUBDIRECTORY(surface_distance)
 ADD_SUBDIRECTORY(surface_radiance)
 
+ADD_SUBDIRECTORY(cage2D_deformation)
+
 ADD_SUBDIRECTORY(volume_import)
 #ADD_SUBDIRECTORY(volume_render)
 

SCHNApps/Plugins/surface_deformation/src/surface_deformation.cpp

@@ -113,7 +113,7 @@ void MapParameters::stop(MapHandlerGen* mh)
 bool Surface_Deformation_Plugin::enable()
 {
 	//	magic line that init static variables of GenericMap in the plugins
-		GenericMap::copyAllStatics(m_schnapps->getStaticPointers());
+	GenericMap::copyAllStatics(m_schnapps->getStaticPointers());
 
 	m_dockTab = new Surface_Deformation_DockTab(m_schnapps, this);
 	m_schnapps->addPluginDockTab(this, m_dockTab, "Surface_Deformation");
@@ -380,16 +380,16 @@ void Surface_Deformation_Plugin::toggleMapDeformation(MapHandlerGen* map)
 	if(map)
 	{
 		MapParameters& p = h_parameterSet[map];
-		if(!p.initialized)
+		if (!p.initialized)
 		{
 			p.start(map);
-			if(p.initialized && map->isSelectedMap())
+			if (p.initialized && map->isSelectedMap())
 				m_dockTab->mapParametersInitialized(true);
 		}
 		else
 		{
 			p.stop(map);
-			if(!p.initialized && map->isSelectedMap())
+			if (!p.initialized && map->isSelectedMap())
 				m_dockTab->mapParametersInitialized(false);
 		}
 	}
@@ -401,9 +401,9 @@ void Surface_Deformation_Plugin::matchDiffCoord(MapHandlerGen* mh)
 	MapParameters& p = h_parameterSet[mh];
 
 	nlMakeCurrent(p.nlContext);
-	if(nlGetCurrentState() == NL_STATE_INITIAL)
+	if (nlGetCurrentState() == NL_STATE_INITIAL)
 		nlBegin(NL_SYSTEM) ;
-	for(int coord = 0; coord < 3; ++coord)
+	for (int coord = 0; coord < 3; ++coord)
 	{
 		LinearSolving::setupVariables<PFP2>(*map, p.vIndex, p.freeSelector->getMarker(), p.positionAttribute, coord);
 		nlBegin(NL_MATRIX);
@@ -421,13 +421,13 @@ void Surface_Deformation_Plugin::asRigidAsPossible(MapHandlerGen* mh)
 	PFP2::MAP* map = static_cast<MapHandler<PFP2>*>(mh)->getMap();
 	MapParameters& p = h_parameterSet[mh];
 
-	if(p.initialized)
+	if (p.initialized)
 	{
 		CellMarkerNoUnmark<PFP2::MAP, VERTEX> m(*map) ;
 
-		for(Dart d = map->begin(); d != map->end(); map->next(d))
+		for (Dart d = map->begin(); d != map->end(); map->next(d))
 		{
-			if(!m.isMarked(d))
+			if (!m.isMarked(d))
 			{
 				m.mark(d) ;
 
@@ -441,11 +441,11 @@ void Surface_Deformation_Plugin::asRigidAsPossible(MapHandlerGen* mh)
 					Dart neigh = map->phi1(it) ;
 					PFP2::VEC3 v = p.positionAttribute[neigh] - pp ;
 					PFP2::VEC3 vv = p.positionInit[neigh] - ppInit ;
-					for(unsigned int i = 0; i < 3; ++i)
-						for(unsigned int j = 0; j < 3; ++j)
+					for (unsigned int i = 0; i < 3; ++i)
+						for (unsigned int j = 0; j < 3; ++j)
 							cov(i,j) += v[i] * vv[j];// * perMap->edgeWeight[it] / area ;
 					Dart dboundary = map->phi_1(it) ;
-					if(map->phi2(dboundary) == dboundary)
+					if (map->phi2(dboundary) == dboundary)
 					{
 						v = p.positionAttribute[dboundary] - pp ;
 						vv = p.positionInit[dboundary] - pp ;
@@ -454,15 +454,15 @@ void Surface_Deformation_Plugin::asRigidAsPossible(MapHandlerGen* mh)
 								cov(i,j) += v[i] * vv[j];// * perMap->edgeWeight[dboundary] / area ;
 					}
 					it = map->alpha1(it) ;
-				} while(it != d) ;
+				} while (it != d) ;
 
 				Eigen::JacobiSVD<Eigen::Matrix3f> svd(cov, Eigen::ComputeFullU | Eigen::ComputeFullV) ;
 				Eigen::Matrix3f R = svd.matrixU() * svd.matrixV().transpose() ;
 
-				if(R.determinant() < 0)
+				if (R.determinant() < 0)
 				{
 					Eigen::Matrix3f U = svd.matrixU() ;
-					for(unsigned int i = 0; i < 3; ++i)
+					for (unsigned int i = 0; i < 3; ++i)
 						U(i,2) *= -1 ;
 					R = U * svd.matrixV().transpose() ;
 				}
@@ -471,9 +471,9 @@ void Surface_Deformation_Plugin::asRigidAsPossible(MapHandlerGen* mh)
 			}
 		}
 
-		for(Dart d = map->begin(); d != map->end(); map->next(d))
+		for (Dart d = map->begin(); d != map->end(); map->next(d))
 		{
-			if(m.isMarked(d))
+			if (m.isMarked(d))
 			{
 				m.unmark(d) ;
 
@@ -491,7 +491,7 @@ void Surface_Deformation_Plugin::asRigidAsPossible(MapHandlerGen* mh)
 						++degree ;
 					}
 					it = map->alpha1(it) ;
-				} while(it != d) ;
+				} while (it != d) ;
 				r += p.vertexRotationMatrix[d] ;
 				r /= degree + 1 ;
 				PFP2::VEC3& dc = p.diffCoord[d] ;
@@ -531,9 +531,9 @@ void Surface_Deformation_Plugin::asRigidAsPossible(MapHandlerGen* mh)
 		}
 
 		nlMakeCurrent(p.nlContext);
-		if(nlGetCurrentState() == NL_STATE_INITIAL)
+		if (nlGetCurrentState() == NL_STATE_INITIAL)
 			nlBegin(NL_SYSTEM);
-		for(int coord = 0; coord < 3; ++coord)
+		for (int coord = 0; coord < 3; ++coord)
 		{
 			LinearSolving::setupVariables<PFP2>(*map, p.vIndex, p.freeSelector->getMarker(), p.positionAttribute, coord);
 			nlBegin(NL_MATRIX);

SCHNApps/Plugins/surface_import/include/surface_import.h

@@ -29,11 +29,15 @@ private:
 	virtual void disable() {}
 
 public slots:
-	MapHandlerGen* importFromFile(const QString& fileName);
-	void importFromFileDialog();
+	MapHandlerGen* importMeshFromFile(const QString& fileName);
+	void importMeshFromFileDialog();
+
+	MapHandlerGen* importImageFromFile(const QString& fileName);
+	void importImageFromFileDialog();
 
 private:
-	QAction* importAction;
+	QAction* importMeshAction;
+	QAction* importImageAction;
 };
 
 } // namespace SCHNApps
@@ -41,4 +45,3 @@ private:
 } // namespace CGoGN
 
 #endif
-

SCHNApps/Plugins/surface_import/src/surface_import.cpp

@@ -4,6 +4,7 @@
 #include "mapHandler.h"
 
 #include "Algo/Import/import.h"
+#include "Algo/Tiling/Surface/square.h"
 
 #include <QFileDialog>
 #include <QFileInfo>
@@ -19,13 +20,18 @@ bool Surface_Import_Plugin::enable()
 //	magic line that init static variables of GenericMap in the plugins
 	GenericMap::copyAllStatics(m_schnapps->getStaticPointers());
 
-	importAction = new QAction("import", this);
-	m_schnapps->addMenuAction(this, "Surface;Import", importAction);
-	connect(importAction, SIGNAL(triggered()), this, SLOT(importFromFileDialog()));
+	importMeshAction = new QAction("import mesh", this);
+	m_schnapps->addMenuAction(this, "Surface;Import Mesh", importMeshAction);
+	connect(importMeshAction, SIGNAL(triggered()), this, SLOT(importMeshFromFileDialog()));
+
+	importImageAction = new QAction("import image", this);
+	m_schnapps->addMenuAction(this, "Surface;Import Image", importImageAction);
+	connect(importImageAction, SIGNAL(triggered()), this, SLOT(importImageFromFileDialog()));
+
 	return true;
 }
 
-MapHandlerGen* Surface_Import_Plugin::importFromFile(const QString& fileName)
+MapHandlerGen* Surface_Import_Plugin::importMeshFromFile(const QString& fileName)
 {
 	QFileInfo fi(fileName);
 	if(fi.exists())
@@ -58,12 +64,72 @@ MapHandlerGen* Surface_Import_Plugin::importFromFile(const QString& fileName)
 		return NULL;
 }
 
-void Surface_Import_Plugin::importFromFileDialog()
+void Surface_Import_Plugin::importMeshFromFileDialog()
 {
-	QStringList fileNames = QFileDialog::getOpenFileNames(m_schnapps, "Import surfaces", m_schnapps->getAppPath(), "Surface mesh Files (*.ply *.off *.trian)");
+	QStringList fileNames = QFileDialog::getOpenFileNames(m_schnapps, "Import surface meshes", m_schnapps->getAppPath(), "Surface mesh Files (*.ply *.off *.trian)");
 	QStringList::Iterator it = fileNames.begin();
-	while(it != fileNames.end()) {
-		importFromFile(*it);
+	while(it != fileNames.end())
+	{
+		importMeshFromFile(*it);
+		++it;
+	}
+}
+
+MapHandlerGen* Surface_Import_Plugin::importImageFromFile(const QString& fileName)
+{
+	QFileInfo fi(fileName);
+	if(fi.exists())
+	{
+		MapHandlerGen* mhg = m_schnapps->addMap(fi.baseName(), 2);
+		if(mhg)
+		{
+			MapHandler<PFP2>* mh = static_cast<MapHandler<PFP2>*>(mhg);
+			PFP2::MAP* map = mh->getMap();
+
+			VertexAttribute<PFP2::VEC3, PFP2::MAP> position = map->addAttribute<PFP2::VEC3, VERTEX, PFP2::MAP>("position");
+			VertexAttribute<PFP2::VEC3, PFP2::MAP> color = map->addAttribute<PFP2::VEC3, VERTEX, PFP2::MAP>("color");
+
+			QImage image;
+			QString extension = fi.suffix();
+			extension.toUpper();
+			if(!image.load(fileName, extension.toUtf8().constData()))
+			{
+				CGoGNout << "Image [" << fileName.toStdString() << "] has not been loaded correctly" << CGoGNendl;
+				return NULL;
+			}
+
+			int imageX = image.width();
+			int imageY = image.height();
+			Algo::Surface::Tilings::Square::Grid<PFP2> grid(*map, imageX - 1, imageY - 1);
+			grid.embedIntoGrid(position, imageX - 1, imageY - 1);
+			const std::vector<Dart>& vDarts = grid.getVertexDarts();
+			QRgb pixel;
+			for(int i = 0; i < imageX; ++i)
+			{
+				for(int j = 0; j < imageY; ++j)
+				{
+					pixel = image.pixel(i, (imageY-j) - 1);
+					color[vDarts[j*imageX + i]] = PFP2::VEC3(qRed(pixel)/255.f, qGreen(pixel)/255.f, qBlue(pixel)/255.f);
+				}
+			}
+
+			mh->registerAttribute(position);
+			mh->registerAttribute(color);
+
+		}
+		return mhg;
+	}
+	else
+		return NULL;
+}
+
+void Surface_Import_Plugin::importImageFromFileDialog()
+{
+	QStringList fileNames = QFileDialog::getOpenFileNames(m_schnapps, "Import images", m_schnapps->getAppPath(), "Surface mesh Files (*.png *.jpg *.jpeg)");
+	QStringList::Iterator it = fileNames.begin();
+	while(it != fileNames.end())
+	{
+		importImageFromFile(*it);
 		++it;
 	}
 }

SCHNApps/Plugins/surface_radiance/src/surface_radiance.cpp

@@ -259,7 +259,9 @@ MapHandlerGen* Surface_Radiance_Plugin::importFromFile(const QString& fileName)
 
 			mapParams.radianceTexture->update();
 
-			map->removeAttribute(mapParams.radiance);
+			// uncomment this line to be able to load multiple objects with different SH basis
+			// (decimation will be unavailable)
+//			map->removeAttribute(mapParams.radiance);
 
 			mapParams.paramVBO = new Utils::VBO();
 			mapParams.paramVBO->updateData(mapParams.param);
@@ -367,6 +369,13 @@ void Surface_Radiance_Plugin::decimate(const QString& mapName, const QString& po
 					*(Algo::Surface::Decimation::Approximator<PFP2, PFP2::VEC3, EDGE>*)(mapParams.normalApproximator),
 					*(Algo::Surface::Decimation::Approximator<PFP2, Utils::SphericalHarmonics<PFP2::REAL, PFP2::VEC3>, EDGE>*)(mapParams.radianceApproximator)
 				);
+
+			mapParams.selector =
+				new Algo::Surface::Decimation::EdgeSelector_QEM<PFP2>(
+					*map,
+					position,
+					*(Algo::Surface::Decimation::Approximator<PFP2, PFP2::VEC3, EDGE>*)(mapParams.positionApproximator)
+				);
 		}
 	}
 

SCHNApps/Plugins/surface_render/include/surface_render.h

@@ -6,6 +6,7 @@
 
 #include "Utils/Shaders/shaderFlat.h"
 #include "Utils/Shaders/shaderPhong.h"
+#include "Utils/Shaders/shaderColorPerVertex.h"
 #include "Utils/Shaders/shaderSimpleColor.h"
 #include "Utils/pointSprite.h"
 
@@ -28,19 +29,21 @@ struct MapParameters
 	MapParameters() :
 		positionVBO(NULL),
 		normalVBO(NULL),
+		colorVBO(NULL),
 		verticesScaleFactor(1.0f),
 		renderVertices(false),
 		renderEdges(false),
 		renderFaces(true),
 		faceStyle(FLAT),
-		diffuseColor(0.8f,0.9f,0.7f,0.0f),
+		diffuseColor(0.85f,0.25f,0.19f,0.0f),
 		simpleColor(0.0f,0.0f,0.0f,0.0f),
 		vertexColor(0.0f,0.0f,1.0f,0.0f)
-
 	{}
 
 	Utils::VBO* positionVBO;
 	Utils::VBO* normalVBO;
+	Utils::VBO* colorVBO;
+
 	float verticesScaleFactor;
 	bool renderVertices;
 	bool renderEdges;
@@ -56,10 +59,12 @@ struct MapParameters
 class Surface_Render_Plugin : public PluginInteraction
 {
 	Q_OBJECT
+
 	Q_INTERFACES(CGoGN::SCHNApps::Plugin)
 #if CGOGN_QT_DESIRED_VERSION == 5
 	Q_PLUGIN_METADATA(IID "CGoGN.SCHNapps.Plugin")
 #endif
+
 	friend class Surface_Render_DockTab;
 
 public:
@@ -103,6 +108,7 @@ public slots:
 	// slots for Python calls
 	void changePositionVBO(const QString& view, const QString& map, const QString& vbo);
 	void changeNormalVBO(const QString& view, const QString& map, const QString& vbo);
+	void changeColorVBO(const QString& view, const QString& map, const QString& vbo);
 	void changeRenderVertices(const QString& view, const QString& map, bool b);
 	void changeVerticesScaleFactor(const QString&view, const QString& map, float f);
 	void changeRenderEdges(const QString& view, const QString& map, bool b);
@@ -119,6 +125,7 @@ protected:
 
 	CGoGN::Utils::ShaderFlat* m_flatShader;
 	CGoGN::Utils::ShaderPhong* m_phongShader;
+	CGoGN::Utils::ShaderColorPerVertex* m_colorPerVertexShader;
 	CGoGN::Utils::ShaderSimpleColor* m_simpleColorShader;