ajout tuto opengl3

Apps/Tuto/tuto_ogl3.cpp

+/*******************************************************************************
+* CGoGN: Combinatorial and Geometric modeling with Generic N-dimensional Maps  *
+* version 0.1                                                                  *
+* Copyright (C) 2009, IGG Team, LSIIT, University of Strasbourg                *
+*                                                                              *
+* This library is free software; you can redistribute it and/or modify it      *
+* under the terms of the GNU Lesser General Public License as published by the *
+* Free Software Foundation; either version 2.1 of the License, or (at your     *
+* option) any later version.                                                   *
+*                                                                              *
+* This library is distributed in the hope that it will be useful, but WITHOUT  *
+* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or        *
+* FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License  *
+* for more details.                                                            *
+*                                                                              *
+* You should have received a copy of the GNU Lesser General Public License     *
+* along with this library; if not, write to the Free Software Foundation,      *
+* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA.           *
+*                                                                              *
+* Web site: https://iggservis.u-strasbg.fr/CGoGN/                              *
+* Contact information: cgogn@unistra.fr                                        *
+*                                                                              *
+*******************************************************************************/
+
+#include <iostream>
+
+#include "Utils/glutwingl3.h"
+
+#include "Topology/generic/parameters.h"
+#include "Topology/map/map2.h"
+#include "Topology/generic/embeddedMap2.h"
+
+
+#include "Algo/Geometry/boundingbox.h"
+#include "Algo/Render/gl3mapRender.h"
+
+#include "Algo/Modelisation/polyhedron.h"
+#include "Geometry/vector_gen.h"
+#include "Algo/Geometry/normal.h"
+
+using namespace CGoGN ;
+
+
+/**
+ * Struct that contains some informations about the types of the manipulated objects
+ * Mainly here to be used by the algorithms that are parameterized by it
+ */
+struct PFP: public PFP_STANDARD
+{
+	// definition of the type of the map
+	typedef EmbeddedMap2<Map2> MAP;
+};
+
+
+
+const unsigned int GL_ATTRIB_POSITION=0;
+const unsigned int GL_ATTRIB_NORMAL=1;
+
+
+/**
+ * A class for a little interface and rendering
+ */
+class MyGlutWin: public Utils::SimpleGlutWinGL3
+{
+public:
+     void myRedraw();
+     void initGLAttribs();
+     void renderColor();
+     void renderPhong();
+
+     PFP::REAL gWidthObj;
+     PFP::VEC3 gPosObj;
+
+     Algo::Render::GL3::MapRender* m_render;
+
+     Utils::GLSLShader* current_shader;
+     Utils::GLSLShader shaders[4];
+
+
+
+ 	MyGlutWin(int* argc, char **argv, int winX, int winY) : SimpleGlutWinGL3(argc, argv, winX, winY)
+    {
+ 		shaders[0].loadShaders("color_gl3.vert","color_gl3.frag");
+ 		shaders[1].loadShaders("phong_gl3.vert","phong_gl3.frag");
+ 		current_shader = &shaders[1];
+ 		setCurrentShader(current_shader);
+    }
+ 	~MyGlutWin()
+ 	{
+ 		delete m_render ;
+ 	}
+};
+
+void MyGlutWin::initGLAttribs()
+{
+	shaders[0].bindAttrib(GL_ATTRIB_POSITION, "VertexPosition");
+
+	shaders[1].bindAttrib(GL_ATTRIB_POSITION, "VertexPosition");
+	shaders[1].bindAttrib(GL_ATTRIB_NORMAL, "VertexNormal");
+}
+
+void MyGlutWin::renderColor()
+{
+	current_shader = &shaders[0];
+
+//	setModelViewProjectionMatrix(current_shader);
+	setCurrentShader(current_shader);
+	glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+	glDisable(GL_LIGHTING);
+
+	current_shader->bind();
+
+	float colorLine[] = {1.0f,1.0f,0.0f,0.0f};
+	float colorFace[] = {0.0f,1.0f,0.0f,0.0f};
+
+	// draw the lines
+	glLineWidth(2.0f);
+	current_shader->setuniformf<4>("Color",colorLine);
+	m_render->draw(Algo::Render::GL3::LINES);
+
+	// draw the faces
+	glEnable(GL_POLYGON_OFFSET_FILL);
+	glPolygonOffset(1.0f, 1.0f);
+
+	current_shader->setuniformf<4>("Color",colorFace);
+	m_render->draw(Algo::Render::GL3::TRIANGLES);
+
+	glDisable(GL_POLYGON_OFFSET_FILL);
+
+}
+
+void MyGlutWin::renderPhong()
+{
+	current_shader = &shaders[1];
+	setCurrentShader(current_shader);
+//	setModelViewProjectionMatrix(current_shader);
+
+	float diffuse[] = {0.0f,1.0f,0.0f,0.0f};
+	float specular[] = {0.3f,0.3f,1.0f,0.0f};
+	float ambient[] = {0.1f,0.03f,0.03f,0.0f};
+	float shininess = 100.0f;
+	float lightPos[] = {100.0,300.0,1000.0f};
+
+	glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+	glEnable(GL_LIGHTING);
+
+	current_shader->bind();
+
+	current_shader->setuniformf<4>("materialDiffuse",diffuse);
+	current_shader->setuniformf<4>("materialSpecular",specular);
+	current_shader->setuniformf<4>("materialAmbient",ambient);
+	current_shader->setuniformf<1>("shininess",&shininess);
+
+	current_shader->setuniformf<3>("LightPosition",lightPos);
+
+	m_render->draw(Algo::Render::GL3::TRIANGLES);
+}
+
+
+void MyGlutWin::myRedraw()
+{
+	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+//	oglPushModelViewMatrix();
+
+	renderPhong();
+
+//	oglPopModelViewMatrix();
+}
+
+int main(int argc, char **argv)
+{
+
+    // instanciation of the interface
+	MyGlutWin mgw(&argc, argv, 800, 800);
+
+	// declaration of the map
+	PFP::MAP myMap;
+
+	AttributeHandler<PFP::VEC3> position = myMap.addAttribute<PFP::VEC3>(VERTEX_ORBIT, "position");
+	AttributeHandler<PFP::VEC3> normal = myMap.addAttribute<PFP::VEC3>(VERTEX_ORBIT, "normal");
+
+	Algo::Modelisation::Polyhedron<PFP> prim3(myMap, position);
+	prim3.tore_topo(16, 32);
+	prim3.embedTore(30.0f,10.0f);
+
+	Algo::Geometry::computeNormalVertices<PFP>(myMap,position,normal);
+
+	mgw.init();
+
+    // computation of the bounding box
+    Geom::BoundingBox<PFP::VEC3> bb = Algo::Geometry::computeBoundingBox<PFP>(myMap, position);
+    mgw.gWidthObj = std::max<PFP::REAL>(std::max<PFP::REAL>(bb.size(0), bb.size(1)), bb.size(2));
+    mgw.gPosObj = (bb.min() +  bb.max()) / PFP::REAL(2);
+
+    mgw.setParamObject(mgw.gWidthObj,mgw.gPosObj.data());
+
+    // instanciation of the renderer (here using VBOs)
+    mgw.m_render = new Algo::Render::GL3::MapRender();
+
+    // update the renderer (primitives and geometry)
+	SelectorTrue allDarts;
+    mgw.m_render->initPrimitives<PFP>(myMap, allDarts,Algo::Render::GL3::TRIANGLES);
+    mgw.m_render->initPrimitives<PFP>(myMap, allDarts,Algo::Render::GL3::LINES);
+    mgw.m_render->initPrimitives<PFP>(myMap, allDarts,Algo::Render::GL3::POINTS);
+
+    mgw.m_render->updateData(GL_ATTRIB_POSITION, position);
+    mgw.m_render->updateData(GL_ATTRIB_NORMAL, normal);
+
+    mgw.initGLAttribs();
+
+    mgw.mainLoop();
+
+    return 0;
+}