viewer.h

/*******************************************************************************
 * 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 <fstream>
#include <sstream>
#include <sys/time.h>

#include "Utils/Qt/qtQGLV.h"
#include "ui_socialAgents.h"
#include "Utils/Qt/qtui.h"

#include "simulator.h"
#include "env_render.h"
#include "exportObstacles.h"
#include "gl2ps.h"

#include "Algo/Geometry/boundingbox.h"

#include "Algo/Export/exportPov.h"
#include "Utils/GLSLShader.h"
#include "Utils/colorMaps.h"

#include "Algo/Render/GL2/mapRender.h"
#include "Algo/Render/GL2/topoRender.h"
#include "Utils/Shaders/shaderSimpleColor.h"
#include "Utils/Shaders/shaderFlat.h"
#include "Utils/Shaders/shaderPhong.h"
#include "Utils/colorMaps.h"
#include "Utils/vbo.h"
#include "Utils/fbo.h"
#include "Utils/drawer.h"
#include "Utils/pointSprite.h"

#include "shaderCustom.h"
#include "shaderPhongTexCust.h"

//#define DRAW_REGISTRATION //montre l'enregistrement détaillé des obstacles mobiles dansla topologie


#define AFFICHE_MESH
//#define EXPORTING // ne pas activer
//#define ONERING	     // affiche l'enregistrement global des obstacles mobiles en tant que cellules
//#define SHADOWSHELL // shadowshells ... old

using namespace CGoGN ;

typedef PFP::MAP MAP ;

class SocialAgents : public Utils::QT::SimpleQGLV
{
	Q_OBJECT

public:
	SocialAgents(unsigned int config, unsigned int minSize, unsigned int nbAgent , unsigned int nbObst ,bool resolution, unsigned int iterations) ;

	void initGUI() ;

	void updateVBOprimitives(int upType);

	void cb_initGL() ;
	void initRendering();
	void updateObstacleVBO();
	void updateAgentPredTriVBO();
	void updateObstaclePredTriVBO();
	void drawCell(Dart d, float width, float r, float g, float b);

	void moveCameraTo(VEC3 newPos);
	void cb_redraw() ;

#ifndef SPATIAL_HASHING
	void exportInfoFace(std::ofstream& out, Dart d) ;
	bool exportScenePov(PFP::MAP& map, PFP::TVEC3& position, const std::string& filename,
	                    PFP::VEC3 cameraPos, PFP::VEC3 cameraLook, PFP::VEC3 translate,
	                    float angle_X, float angle_Y, float angle_Z) ;
#endif

//	void cb_keyPress(int keycode) ;
	void keyPressEvent(QKeyEvent *e);

	//RENDERING
	Geom::Vec4f colDif ;
	Geom::Vec4f colSpec ;
	Geom::Vec4f colClear ;
	Geom::Vec4f colNormal ;

	//navigation map
	Algo::Render::GL2::MapRender* m_render;
	Algo::Render::GL2::MapRender* m_renderPedway;
	Algo::Render::GL2::TopoRender* m_renderTopo;
	Utils::VBO* m_positionVBO;
	Utils::VBO* m_normalVBO;
	Utils::VBO* m_colorVBO;
	Utils::ShaderSimpleColor* m_simpleColorShader;

	Algo::Render::GL2::MapRender* m_renderWithin;

	//building
	Algo::Render::GL2::MapRender* m_render_scenary;
	Utils::VBO* m_positionVBO_scenary;
	Utils::VBO* m_normalVBO_scenary;
	Utils::VBO* m_colorVBO_scenary;
#ifdef EXPORTING
	ShaderCustom* m_flatShader_scenary;
#else
	Utils::ShaderFlat* m_flatShader_scenary;
#endif


#ifdef EXPORTING_OBJ
	PFP2::MAP mapAgent;
	VertexAttribute<VEC3> positionAgent;
	VertexAttribute<VEC3> normalAgent;

	Algo::Render::GL2::MapRender* m_renderAgent;
	Utils::VBO* m_positionVBOAgent;
	Utils::VBO* m_normalVBOAgent;

	Utils::Texture<2,Geom::Vec3uc>* m_textureAgent;
	Utils::VBO* m_texcoordVBOAgent;
// 	ShaderCustomTex* m_shaderTexAgent;
	ShaderPhongTexCust* m_shaderTexAgent;
	Algo::Surface::Import::OBJModel<PFP2> m_objAgent;
	unsigned int m_nbIndicesAgent;
#endif
	//agents
	Utils::VBO* m_agentsVBO;
	Utils::PointSprite* m_sprite;

	//obstacles ground
	std::vector<Algo::Render::GL2::MapRender*> m_obst_render;
	std::vector<Utils::VBO*> m_obst_VBO;
	std::vector<Utils::ShaderFlat*> m_obstShader;

	//city ground
	Utils::ShaderFlat* m_Ground_Shader;
	Utils::VBO* m_Ground_VBO;

	//prediction triangles
	std::vector<Algo::Render::GL2::MapRender*> m_triObst_render;
	std::vector<Utils::VBO*> m_triObst_VBO;
	std::vector<Utils::ShaderSimpleColor*> m_triObst_Shader;
	std::vector<Algo::Render::GL2::MapRender*> m_triAgent_render;
	std::vector<Utils::VBO*> m_triAgent_VBO;
	std::vector<Utils::ShaderSimpleColor*> m_triAgent_Shader;

	static const unsigned int N_THETA = 64;
	static const unsigned int N_PHI   = 128;
	static const float        RADIUS  = 3950.0f;
	Utils::GLSLShader m_DeferedShader;
	Utils::GLSLShader m_DeferedShader2;
	std::stringstream filename;
	std::stringstream name;

	enum renderMode {SIMPLE} ;
	int m_renderStyle;
	//////

	// ARASH : camera input file
	std::ifstream cam_input_file;
	bool cif_exists;

	unsigned int cif_begin, cif_end;

	VEC3 *cif_lookfrom;
	VEC3 *cif_lookat;
	VEC3 *cif_upvector;
	void readCameraInputFile(char *filename);

	std::ofstream cam_output_file;


	Geom::BoundingBox<PFP::VEC3> bb ;

	Utils::QT::uiDockInterface dock ;

	QTimer* timer ;
	time_t elapsedTime;
	long int time_update;

	/* nbIterations counts the current number of iterations
	 * When maxIterations is reached the simulation is stopped
	 * If maxIterations is set to 0 the simulation is never stopped (interactive)
	 */
	unsigned int nbIterations ;
	unsigned int maxIterations ;

	unsigned int nbGeneratedPov;

	// to count fps
	unsigned int frames ;
	struct timespec startTime ;
	time_t nextUpdate ;

	Simulator simulator ;
	SelectorTrue allDarts ;

	bool render_anim ;
	int visu ;
	Utils::Drawer* m_ds;
	bool drawEnvLines ;
	bool drawEnvFaces ;
	bool drawEnvTopo ;
	bool drawObstacles ;
	bool drawMovingObstacles ;
	bool drawAgents ;
	bool drawAgentsNeighborDist ;
	bool drawAgentsObstacleDist ;
	bool drawAgentsPredictionTri ;
	bool drawAgentsPath ;
	bool drawObstPredictionTri ;
	bool drawObstPath ;
	bool draw_dart;
	bool target_Agent;
	bool draw_posX;
	bool draw_elipse;
	unsigned int dartSlider;
	unsigned int agentSlider;
	int posXSlider;
	int posYSlider;
	bool display_times;
	bool percent;
public slots:

	void setCameraDebug();
	void animate() ;

	void slot_timer(bool b)
	{
		b ? timer->start() : timer->stop() ;
		clock_gettime(CLOCK_MONOTONIC, &startTime) ;
//		display_times =b;
	}
	void slot_drawEnvLines(bool b)
	{
		drawEnvLines = b ;
		updateGL() ;
	}
	void slot_drawEnvFaces(bool b)
	{
		drawEnvFaces = b ;
		updateGL() ;
	}
	void slot_drawEnvTopo(bool b)
	{
		drawEnvTopo = b ;
		updateGL() ;
	}
	void slot_drawObstacles(bool b)
	{
		drawObstacles = b ;
		updateGL() ;
	}
	void slot_drawAgents(bool b)
	{
		drawAgents = b ;
		updateGL() ;
	}
	void slot_drawAgentsPredictionTri(bool b)
	{
		drawAgentsPredictionTri = b ;

		if(drawAgentsPredictionTri && m_triAgent_render.size()==0)
		{
			for(unsigned int i=0 ; i < simulator.agents_.size() ; ++i)
			{
					m_triAgent_render.push_back(new Algo::Render::GL2::MapRender());

					Utils::ShaderSimpleColor * shader = new Utils::ShaderSimpleColor();
					shader->setColor(Geom::Vec4f(1.,0.,1.,0.)) ;
//					shader->setAmbiant(Geom::Vec4f(1.,0.,1.,0.5)) ;
//					shader->setDiffuse(Geom::Vec4f(1.,0.,1.,0.5));

					Utils::VBO * vbo = new Utils::VBO();
					vbo->setDataSize(3);
					vbo->allocate(3);
					shader->setAttributePosition(vbo);

					m_triAgent_VBO.push_back(vbo);
					m_triAgent_Shader.push_back(shader);
					registerShader(shader);
			}
		}

		updateGL() ;
	}
	void slot_drawObstPredictionTri(bool b)
	{
		drawObstPredictionTri = b ;

		if(drawObstPredictionTri && m_triObst_render.size()==0)
		{
			for(unsigned int i=0 ; i < simulator.movingObstacles_.size() ; ++i)
			{
//				for(unsigned int j=0 ; j < simulator.movingObstacles_[i]->nbVertices ; ++j)
//				{
					m_triObst_render.push_back(new Algo::Render::GL2::MapRender());

					Utils::ShaderSimpleColor * shader = new Utils::ShaderSimpleColor();
					shader->setColor(Geom::Vec4f(1.,0.,1.,0.)) ;
//					shader->setAmbiant(Geom::Vec4f(1.,0.,1.,0.5)) ;
//					shader->setDiffuse(Geom::Vec4f(1.,0.,1.,0.5));

					Utils::VBO * vbo = new Utils::VBO();
					vbo->setDataSize(3);
					vbo->allocate(4*simulator.movingObstacles_[i]->nbVertices);
					shader->setAttributePosition(vbo);

					m_triObst_VBO.push_back(vbo);
					m_triObst_Shader.push_back(shader);
					registerShader(shader);
//				}
			}
		}

		updateGL() ;
	}
	void slot_drawAgentsNeighborDist(bool b)
	{
		drawAgentsNeighborDist = b ;
		updateGL() ;
	}
	void slot_drawAgentsObstacleDist(bool b)
	{
		drawAgentsObstacleDist = b ;
		updateGL() ;
	}
	void slot_drawAgentsPath(bool b)
	{
		drawAgentsPath= b ;
		updateGL() ;
	}
	void slot_drawMovingObstacles(bool b)
	{
		drawMovingObstacles = b ;
		updateGL() ;
	}
	void slot_drawObstPath(bool b)
	{
		drawObstPath= b ;
		updateGL() ;
	}
	void slot_dart(bool b)
	{
		draw_dart = b ;
		updateGL() ;
	}
	void slot_slide(int i)
	{
		dartSlider = i;
		updateGL();
	}
	void slot_posX(bool b)
	{
		draw_posX = b ;
		updateGL() ;
	}
	void slot_slide2(int i)
	{
		posXSlider = i;
		updateGL();
	}
	void slot_slide3(int i)
	{
		posYSlider = i;
		updateGL();
	}
	void slot_elipse(bool b)
	{
		draw_elipse = b;
		updateGL();
	}
	void slot_Agent(bool b)
	{
	target_Agent = b ;
		updateGL() ;
	}
	void slot_AgentSlider(int i)
	{
	agentSlider = i ;
		updateGL() ;
	}
} ;