251 lines
7.2 KiB
C++
251 lines
7.2 KiB
C++
////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Paella
|
|
// Copyright (C) 2015 - Thomas FORGIONE, Emilie JALRAS, Marion LENFANT, Thierry MALON, Amandine PAILLOUX
|
|
// Authors :
|
|
// Thomas FORGIONE
|
|
// Emilie JALRAS
|
|
// Marion LENFANT
|
|
// Thierry MALON
|
|
// Amandine PAILLOUX
|
|
//
|
|
// This file is part of the project Paella
|
|
// This software is provided 'as-is', without any express or implied warranty.
|
|
// In no event will the authors be held liable for any damages arising from the use of this software.
|
|
//
|
|
// Permission is granted to anyone to use this software for any purpose,
|
|
// including commercial applications, and to alter it and redistribute it freely,
|
|
// subject to the following restrictions:
|
|
//
|
|
// 1. The origin of this software must not be misrepresented;
|
|
// you must not claim that you wrote the original software.
|
|
// If you use this software in a product, an acknowledgment
|
|
// in the product documentation would be appreciated but is not required.
|
|
//
|
|
// 2. Altered source versions must be plainly marked as such,
|
|
// and must not be misrepresented as being the original software.
|
|
//
|
|
// 3. This notice may not be removed or altered from any source distribution.
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
#include <iostream>
|
|
#include <vector>
|
|
#include <memory>
|
|
#include <cmath>
|
|
#include <SFML/Window.hpp>
|
|
#include <SFML/Graphics.hpp>
|
|
#include <SFML/OpenGL.hpp>
|
|
#include <GL/gl.h>
|
|
#include <GL/glu.h>
|
|
|
|
#include "SFMLTools/FreeFlyCamera.hpp"
|
|
#include "Geometry/Mesh.hpp"
|
|
#include "Meshing/Skeleton3D.hpp"
|
|
|
|
// Full hd : 1920x1080
|
|
constexpr auto WIDTH = 1920;
|
|
constexpr auto HEIGHT = 1080;
|
|
|
|
void drawScene(sft::FreeFlyCamera const& camera, geo::Mesh const& mesh, std::vector<geo::Circle<float>> const& circles, geo::Vector4f const& plane);
|
|
|
|
void drawCircle(geo::Circle<float> const& circle);
|
|
|
|
int main(int argc, char *argv[])
|
|
{
|
|
// Init mesh
|
|
// pae::Skeleton3D<pae::Vector3<float>, float> skeleton;
|
|
// skeleton.loadFromFile("skel.skl");
|
|
unsigned int screenNumber = 0;
|
|
geo::Mesh mesh;
|
|
|
|
#include "Circles3.cxx"
|
|
|
|
std::vector<std::vector<geo::Circle<float>>> splines_circles;
|
|
std::vector<geo::Circle<float>> circles;
|
|
circles.push_back(c1);
|
|
circles.push_back(c2);
|
|
circles.push_back(c3);
|
|
circles.push_back(c4);
|
|
|
|
for (auto const& c : circles)
|
|
{
|
|
for (auto const& pt : c.points)
|
|
{
|
|
mesh.vertices.push_back(pt.second);
|
|
}
|
|
}
|
|
|
|
// skeleton.meshExtremities(mesh, splines_circles, profondeur);
|
|
auto plane = pae::meshJunction(mesh,geo::Vector3<float>{0.0f,0.0f,0.0f}, 2, circles);
|
|
|
|
std::cout << plane << std::endl;
|
|
|
|
// Création de la fenêtre
|
|
sf::RenderWindow window(sf::VideoMode(WIDTH, HEIGHT),
|
|
"pae",
|
|
sf::Style::Fullscreen,
|
|
sf::ContextSettings(32));
|
|
|
|
window.setVerticalSyncEnabled(true);
|
|
window.setMouseCursorVisible(false);
|
|
|
|
//Initialisation du mode 3D
|
|
glMatrixMode(GL_PROJECTION);
|
|
glLoadIdentity();
|
|
gluPerspective(70,(double)WIDTH/HEIGHT,0.2,1000);
|
|
|
|
// Initialisation de Z-Buffer
|
|
glEnable(GL_DEPTH_TEST);
|
|
|
|
// Activer les textures
|
|
glEnable(GL_TEXTURE_2D);
|
|
|
|
// Autoriser la transparence
|
|
glEnable(GL_BLEND);
|
|
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
|
|
|
// Ces 2 lignes améliorent le rendu
|
|
glHint(GL_PERSPECTIVE_CORRECTION_HINT,GL_NICEST);
|
|
glHint(GL_POINT_SMOOTH_HINT,GL_NICEST);
|
|
|
|
// On efface le tampon d'affichage
|
|
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
|
glFlush();
|
|
|
|
|
|
|
|
mesh.prepare();
|
|
|
|
// Camera
|
|
auto camera = sft::FreeFlyCamera{};
|
|
|
|
// la boucle principale
|
|
auto running = true;
|
|
auto captureRequired = false;
|
|
while (running)
|
|
{
|
|
// gestion des évènements
|
|
sf::Event event;
|
|
while (window.pollEvent(event))
|
|
{
|
|
if (event.type == sf::Event::Closed)
|
|
{
|
|
// on stoppe le programme
|
|
running = false;
|
|
}
|
|
else if (event.type == sf::Event::KeyPressed)
|
|
{
|
|
if (event.key.code == sf::Keyboard::Escape)
|
|
{
|
|
running = false;
|
|
}
|
|
else if (event.key.code == sf::Keyboard::P)
|
|
{
|
|
captureRequired = true;
|
|
}
|
|
}
|
|
else if (event.type == sf::Event::MouseMoved)
|
|
{
|
|
// Hum...
|
|
}
|
|
else if (event.type == sf::Event::Resized)
|
|
{
|
|
// on ajuste le viewport lorsque la fenêtre est redimensionnée
|
|
glViewport(0, 0, event.size.width, event.size.height);
|
|
}
|
|
|
|
}
|
|
|
|
// Les trucs qui sont pas des évènements
|
|
camera.nextStep(WIDTH, HEIGHT);
|
|
sf::Mouse::setPosition(sf::Vector2i{WIDTH/2, HEIGHT/2});
|
|
|
|
// Dessin de la scene
|
|
drawScene(camera, mesh, circles, plane);
|
|
|
|
if (captureRequired)
|
|
{
|
|
sf::Vector2u windowSize = window.getSize();
|
|
sf::Texture texture;
|
|
texture.create(windowSize.x, windowSize.y);
|
|
texture.update(window);
|
|
sf::Image screenshot = texture.copyToImage();
|
|
screenshot.saveToFile("data/img/capture" + std::to_string(screenNumber) + ".png");
|
|
screenNumber++;
|
|
}
|
|
|
|
// termine la trame courante (en interne, échange les deux tampons de rendu)
|
|
window.display();
|
|
}
|
|
|
|
// libération des ressources...
|
|
|
|
return 0;
|
|
}
|
|
|
|
void drawScene(sft::FreeFlyCamera const& camera, geo::Mesh const& mesh, std::vector<geo::Circle<float>> const& circles, geo::Vector4f const& plane)
|
|
{
|
|
// Initialisation
|
|
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
|
glMatrixMode(GL_MODELVIEW);
|
|
glLoadIdentity();
|
|
|
|
// Position Camera gluLookAt(positionCamera, positionCible, vecteurVertical)
|
|
camera.look();
|
|
|
|
glBegin(GL_LINES);
|
|
glColor3f(1,0,0);
|
|
glVertex3f(0,0,0);
|
|
glVertex3f(1,0,0);
|
|
glColor3f(0,1,0);
|
|
glVertex3f(0,0,0);
|
|
glVertex3f(0,1,0);
|
|
glColor3f(0,0,1);
|
|
glVertex3f(0,0,0);
|
|
glVertex3f(0,0,1);
|
|
glEnd();
|
|
|
|
// Dessin de carrés
|
|
mesh.draw();
|
|
|
|
// Dessin des cercles
|
|
glColor3f(1,0,0);
|
|
drawCircle(circles[0]);
|
|
glColor3f(0,1,0);
|
|
drawCircle(circles[1]);
|
|
glColor3f(0,0,1);
|
|
drawCircle(circles[2]);
|
|
|
|
// // Dessin du plan
|
|
// auto p1 = geo::Vector3f{-plane.y(), plane.x(), -plane.t() / plane.z()};
|
|
// auto v1 = geo::Vector3f{-plane.z(), 0.0f, plane.x()};
|
|
// auto v2 = geo::crossProduct(geo::Vector3<float>{plane.x(), plane.y(), plane.z()}, v1);
|
|
|
|
// v1 /= v1.norm();
|
|
// v2 /= v2.norm();
|
|
|
|
// auto pt1 = p1 - 5*v1;
|
|
// auto pt2 = p1 + 5*v2;
|
|
// auto pt3 = p1 + 5*v1;
|
|
// auto pt4 = p1 - 5*v2;
|
|
|
|
// glColor4f(1.0,1.0,1.0,0.5);
|
|
// glBegin(GL_QUADS);
|
|
// glVertex3fv(&pt1.data[0]);
|
|
// glVertex3fv(&pt2.data[0]);
|
|
// glVertex3fv(&pt3.data[0]);
|
|
// glVertex3fv(&pt4.data[0]);
|
|
// glEnd();
|
|
|
|
// MAJ de l'écran
|
|
glFlush();
|
|
}
|
|
|
|
void drawCircle(geo::Circle<float> const& circle)
|
|
{
|
|
glBegin(GL_LINE_LOOP);
|
|
for (auto const& pt : circle.points)
|
|
glVertex3fv(&pt.second.data[0]);
|
|
glEnd();
|
|
}
|
|
|