예제 #1
0
void SimpleGMap2::cb_initGL()
{
	Utils::GLSLShader::setCurrentOGLVersion(1) ;

	Geom::BoundingBox<VEC3> bb = Algo::Geometry::computeBoundingBox<PFP>(myMap, position) ;
	VEC3 gPosObj = bb.center() ;
	float tailleX = bb.size(0) ;
	float tailleY = bb.size(1) ;
	float tailleZ = bb.size(2) ;
	float gWidthObj = std::max<float>(std::max<float>(tailleX, tailleY), tailleZ) ;
	setParamObject(gWidthObj, gPosObj.data());
}
예제 #2
0
void SimpleGMap3::cb_initGL()
{
    Geom::BoundingBox<PFP::VEC3> bb = Algo::Geometry::computeBoundingBox<PFP>(myMap, position) ;
    VEC3 gPosObj = bb.center() ;
    float tailleX = bb.size(0) ;
    float tailleY = bb.size(1) ;
    float tailleZ = bb.size(2) ;
    float gWidthObj = std::max<float>(std::max<float>(tailleX, tailleY), tailleZ) ;
    setParamObject(gWidthObj, gPosObj.data());

	m_render_topo = new Algo::Render::GL2::Topo3RenderGMap<PFP>();
    m_render_topo->setDartWidth(2.0f);
    m_render_topo->setInitialDartsColor(1.0f,1.0f,1.0f);
	m_render_topo->updateData(myMap, position, 0.9f,0.9f,0.8f);
}
예제 #3
0
void SimpleVisu::cb_redraw(Scene* scene){
	while(!l_waitingAssoc.isEmpty()){
		QPair<Scene*,MapHandler*> p= l_waitingAssoc.takeFirst();
		Scene* s= p.first;
		if(h_info.find(s)==h_info.end()){
			MapHandler* vh= p.second;

			VBOHandler* vboPosition, *vboNormal;
			if(!(vboPosition=vh->findVBO("positionVBO"))){
				vboPosition= vh->addNewVBO("positionVBO");
			}
			if(!(vboNormal=vh->findVBO("normalVBO"))){
				vboNormal= vh->addNewVBO("normalVBO");
			}

			PFP::MAP* map= (PFP::MAP*)vh->map();

			VertexAttribute<VEC3> position= map->getAttribute<PFP::VEC3, VERTEX>("position");
			VertexAttribute<VEC3> normal= map->getAttribute<PFP::VEC3, VERTEX>("normal") ;
			if(!normal.isValid()){
				normal= map->addAttribute<PFP::VEC3, VERTEX>("normal");

				if(position.isValid()){
					Algo::Geometry::computeNormalVertices<PFP>(*map, position, normal) ;
				}
			}

			Algo::Render::GL2::MapRender* render= NULL;
			bool valid= position.isValid() && normal.isValid();
			if(valid){
				vboPosition->updateData(position);
				vboNormal->updateData(normal) ;

				render= new Algo::Render::GL2::MapRender();

				render->initPrimitives<PFP>(*map, allDarts, Algo::Render::GL2::POINTS) ;
				render->initPrimitives<PFP>(*map, allDarts, Algo::Render::GL2::LINES) ;
				render->initPrimitives<PFP>(*map, allDarts, Algo::Render::GL2::TRIANGLES) ;

				Geom::BoundingBox<PFP::VEC3> bb = Algo::Geometry::computeBoundingBox<PFP>(*map, position) ;
				s->firstViewFitSphere(bb.center()[0], bb.center()[1], bb.center()[2], bb.maxSize());
			}

			MyContainer mc(map,vboPosition,vboNormal,position,normal,render);
			mc.valid=valid;

			h_info.insert(s,mc);
		}
	}

	QHash<Scene*, MyContainer>::iterator it;
	if(scene && (it=h_info.find(scene))!=h_info.end() && it->valid){
		VBOHandler* vboPosition= it->vbos.first;
		VBOHandler* vboNormal= it->vbos.second;
		Algo::Render::GL2::MapRender* render= it->render;

		m_phongShader->setAttributePosition(vboPosition) ;
		m_phongShader->setAttributeNormal(vboNormal) ;
		m_flatShader->setAttributePosition(vboPosition) ;
		m_vectorShader->setAttributePosition(vboPosition) ;
		m_vectorShader->setAttributeVector(vboNormal) ;
		m_simpleColorShader->setAttributePosition(vboPosition) ;
		m_pointSprite->setAttributePosition(vboPosition) ;


		if(m_drawVertices)
		{
			float size = vertexScaleFactor ;
			m_pointSprite->setSize(size) ;
			m_pointSprite->predraw(Geom::Vec3f(0.0f, 0.0f, 1.0f)) ;
			render->draw(m_pointSprite, Algo::Render::GL2::POINTS) ;
			m_pointSprite->postdraw() ;
		}

		if(m_drawEdges)
		{
			glLineWidth(1.0f) ;
			render->draw(m_simpleColorShader, Algo::Render::GL2::LINES) ;
		}

		if(m_drawFaces)
		{
			glPolygonMode(GL_FRONT_AND_BACK, GL_FILL) ;
			glEnable(GL_LIGHTING) ;
			glEnable(GL_POLYGON_OFFSET_FILL) ;
			glPolygonOffset(1.0f, 1.0f) ;
			switch(m_renderStyle)
			{
				case FLAT :
					m_flatShader->setExplode(faceShrinkage) ;
					render->draw(m_flatShader, Algo::Render::GL2::TRIANGLES) ;
					break ;
				case PHONG :
						render->draw(m_phongShader, Algo::Render::GL2::TRIANGLES) ;
					break ;
			}
			glDisable(GL_POLYGON_OFFSET_FILL) ;
		}


		if(m_drawNormals)
		{
			float size = normalBaseSize * normalScaleFactor ;
			m_vectorShader->setScale(size) ;
			glLineWidth(1.0f) ;
			render->draw(m_vectorShader, Algo::Render::GL2::POINTS) ;
		}

	}

//	if(scene){
//		for(int i=0; i<l_map.size(); ++i){
//			if(!initOK){
//				initVBOs(scene);
//			}
//
//			PFP::MAP* myMap= (PFP::MAP*)l_map[i];
//			if(!fited){
//
//				Geom::BoundingBox<PFP::VEC3> bb = Algo::Geometry::computeBoundingBox<PFP>((*myMap), m_position) ;
//				scene->firstViewFitSphere(bb.center()[0], bb.center()[1], bb.center()[2], bb.maxSize());
//
//				fited= true;
//			}
//
//			if(m_drawVertices /*&& position_ok*/)
//			{
//				float size = vertexScaleFactor ;
//				m_pointSprite->setSize(size) ;
//				m_pointSprite->predraw(Geom::Vec3f(0.0f, 0.0f, 1.0f)) ;
//				m_render->draw(m_pointSprite, Algo::Render::GL2::POINTS) ;
//				m_pointSprite->postdraw() ;
//			}
//
//			if(m_drawEdges /*&& position_ok*/)
//			{
//				glLineWidth(1.0f) ;
//				m_render->draw(m_simpleColorShader, Algo::Render::GL2::LINES) ;
//			}
//
//			if(m_drawFaces /*&& position_ok*/)
//			{
//				glPolygonMode(GL_FRONT_AND_BACK, GL_FILL) ;
//				glEnable(GL_LIGHTING) ;
//				glEnable(GL_POLYGON_OFFSET_FILL) ;
//				glPolygonOffset(1.0f, 1.0f) ;
//				switch(m_renderStyle)
//				{
//					case FLAT :
//						m_flatShader->setExplode(faceShrinkage) ;
//						m_render->draw(m_flatShader, Algo::Render::GL2::TRIANGLES) ;
//						break ;
//					case PHONG :
////						if(normal_ok){
//							m_render->draw(m_phongShader, Algo::Render::GL2::TRIANGLES) ;
////						}
//						break ;
//				}
//				glDisable(GL_POLYGON_OFFSET_FILL) ;
//			}
//
//
//			if(m_drawNormals /*&& normal_ok && position_ok*/)
//			{
//				float size = normalBaseSize * normalScaleFactor ;
//				m_vectorShader->setScale(size) ;
//				glLineWidth(1.0f) ;
//				m_render->draw(m_vectorShader, Algo::Render::GL2::POINTS) ;
//			}
//		}
//	}
}
예제 #4
0
void SimpleVisu::cb_initGL(Scene* scene){
	if(scene && h_info.find(scene)==h_info.end()){
		int t;
		if(((t=l_recievedScene.size())>0) && t<=l_map.size()){
			MapHandler* vh= l_map[l_recievedScene.size()-1];

			VBOHandler* vboPosition, *vboNormal;
			if(!(vboPosition=vh->findVBO("positionVBO"))){
				vboPosition= vh->addNewVBO("positionVBO");
			}
			if(!(vboNormal=vh->findVBO("normalVBO"))){
				vboNormal= vh->addNewVBO("normalVBO");
			}

			PFP::MAP* map= (PFP::MAP*)vh->map();

			VertexAttribute<VEC3> position= map->getAttribute<PFP::VEC3, VERTEX>("position");
			VertexAttribute<VEC3> normal= map->getAttribute<PFP::VEC3, VERTEX>("normal") ;
			if(!normal.isValid()){
				normal= map->addAttribute<PFP::VEC3, VERTEX>("normal");

				if(position.isValid()){
					Algo::Geometry::computeNormalVertices<PFP>(*map, position, normal) ;
				}
			}

			Algo::Render::GL2::MapRender* render= NULL;
			bool valid= position.isValid() && normal.isValid();
			if(valid){
				vboPosition->updateData(position);
				vboNormal->updateData(normal) ;

				render= new Algo::Render::GL2::MapRender();

				render->initPrimitives<PFP>(*map, allDarts, Algo::Render::GL2::POINTS) ;
				render->initPrimitives<PFP>(*map, allDarts, Algo::Render::GL2::LINES) ;
				render->initPrimitives<PFP>(*map, allDarts, Algo::Render::GL2::TRIANGLES) ;

				Geom::BoundingBox<PFP::VEC3> bb = Algo::Geometry::computeBoundingBox<PFP>(*map, position) ;
				scene->firstViewFitSphere(bb.center()[0], bb.center()[1], bb.center()[2], bb.maxSize());
			}

			MyContainer mc(map,vboPosition,vboNormal,position,normal,render);
			mc.valid=valid;

			h_info.insert(scene,mc);
		}
	}
	if(!init && scene){
//		m_render = new Algo::Render::GL2::MapRender() ;


		m_phongShader = new Utils::ShaderPhong() ;
//		m_phongShader->setAttributePosition(m_positionVBO) ;
//		m_phongShader->setAttributeNormal(m_normalVBO) ;
		m_phongShader->setAmbiant(colClear) ;
		m_phongShader->setDiffuse(colDif) ;
		m_phongShader->setSpecular(colSpec) ;
		m_phongShader->setShininess(shininess) ;

		m_flatShader = new Utils::ShaderFlat() ;
//		m_flatShader->setAttributePosition(m_positionVBO) ;
		m_flatShader->setAmbiant(colClear) ;
		m_flatShader->setDiffuse(colDif) ;
		m_flatShader->setExplode(faceShrinkage) ;

		m_vectorShader = new Utils::ShaderVectorPerVertex() ;
//		m_vectorShader->setAttributePosition(m_positionVBO) ;
//		m_vectorShader->setAttributeVector(m_normalVBO) ;
		m_vectorShader->setColor(colNormal) ;

		m_simpleColorShader = new Utils::ShaderSimpleColor() ;
//		m_simpleColorShader->setAttributePosition(m_positionVBO) ;
		Geom::Vec4f c(0.1f, 0.1f, 0.1f, 1.0f) ;
		m_simpleColorShader->setColor(c) ;

		m_pointSprite = new Utils::PointSprite() ;
//		m_pointSprite->setAttributePosition(m_positionVBO) ;

		GLSLShader::registerShader(NULL,m_phongShader) ;
		GLSLShader::registerShader(NULL,m_flatShader) ;
		GLSLShader::registerShader(NULL,m_vectorShader) ;
		GLSLShader::registerShader(NULL,m_simpleColorShader) ;
		GLSLShader::registerShader(NULL,m_pointSprite) ;

		init=true;
	}
}