lhark
/
ripple
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
OpenGL port of https://github.com/jeschke/water-wave-packets, presented at SIGGRAPH 2017.
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
8 Commits
1 Branch
0 Tags
192 KiB
 
 
 
 
Tree: 51abb756a5
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '51abb756a5'
${ noResults }
ripple/inf2705.h

3081 lines
101 KiB
Raw Blame History

// Version: mar nov 21 12:54:32 EST 2017
#ifndef INF2705_MATRICE_H
#define INF2705_MATRICE_H
////////////////////////////////////////////////////////////////////////////
//
// Classe pour les matrices du pipeline
// (INF2705, Benoît Ozell)
////////////////////////////////////////////////////////////////////////////
#include <GL/glew.h>
#include <iostream>
#define GLM_SWIZZLE
// (à compter de GLM 9.8, c'est plutôt la variable ci-dessous qu'il faut définir)
#define GLM_FORCE_SWIZZLE
#define GLM_FORCE_RADIANS 1
#include <glm/glm.hpp>
#include <glm/gtc/type_ptr.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtx/rotate_vector.hpp>
#include <glm/gtx/string_cast.hpp>
#include <stack>
class MatricePipeline
{
public:
MatricePipeline()
{ matr_.push( glm::mat4(1.0) ); }
operator glm::mat4() const { return matr_.top(); }
operator const GLfloat*() const { return glm::value_ptr(matr_.top()); }
void LoadIdentity()
{ matr_.top() = glm::mat4(1.0); }
// Note: la librairie glm s’occupe de convertir les glm::vec3 en glm::vec4 pour la multiplication par glm::mat4 matr_.
void Scale( GLfloat sx, GLfloat sy, GLfloat sz )
{ matr_.top() = glm::scale( matr_.top(), glm::vec3(sx,sy,sz) ); }
void Translate( GLfloat tx, GLfloat ty, GLfloat tz )
{ matr_.top() = glm::translate( matr_.top(), glm::vec3(tx,ty,tz) ); }
void Rotate( GLfloat angle, GLfloat x, GLfloat y, GLfloat z )
{ matr_.top() = glm::rotate( matr_.top(), (GLfloat)glm::radians(angle), glm::vec3(x,y,z) ); }
void LookAt( GLdouble obsX, GLdouble obsY, GLdouble obsZ, GLdouble versX, GLdouble versY, GLdouble versZ, GLdouble upX, GLdouble upY, GLdouble upZ )
{ matr_.top() = glm::lookAt( glm::vec3( obsX, obsY, obsZ ), glm::vec3( versX, versY, versZ ), glm::vec3( upX, upY, upZ ) ); }
void LookAt( glm::vec3 obs, glm::vec3 vers, glm::vec3 up )
{ matr_.top() = glm::lookAt(obs, vers, up); }
void Frustum( GLdouble gauche, GLdouble droite, GLdouble bas, GLdouble haut, GLdouble planAvant, GLdouble planArriere )
{ matr_.top() = glm::frustum( gauche, droite, bas, haut, planAvant, planArriere ); }
void Perspective( GLdouble fovy, GLdouble aspect, GLdouble planAvant, GLdouble planArriere )
{ matr_.top() = glm::perspective( glm::radians(fovy), aspect, planAvant, planArriere );}
void Ortho( GLdouble gauche, GLdouble droite, GLdouble bas, GLdouble haut, GLdouble planAvant, GLdouble planArriere )
{ matr_.top() = glm::ortho( gauche, droite, bas, haut, planAvant, planArriere ); }
void Ortho2D( GLdouble gauche, GLdouble droite, GLdouble bas, GLdouble haut )
{ matr_.top() = glm::ortho( gauche, droite, bas, haut ); }
void PushMatrix()
{ matr_.push( matr_.top() ); }
void PopMatrix()
{ matr_.pop(); }
glm::mat4 getMatr()
{ return matr_.top(); }
glm::mat4 setMatr( glm::mat4 m )
{ return( matr_.top() = m ); }
friend std::ostream& operator<<( std::ostream& o, const MatricePipeline& mp )
{
//return o << glm::to_string(mp.matr_.top());
glm::mat4 m = mp.matr_.top(); //o.precision(3); o.width(6);
return o << std::endl
<< " " << m[0][0] << " " << m[1][0] << " " << m[2][0] << " " << m[3][0] << std::endl
<< " " << m[0][1] << " " << m[1][1] << " " << m[2][1] << " " << m[3][1] << std::endl
<< " " << m[0][2] << " " << m[1][2] << " " << m[2][2] << " " << m[3][2] << std::endl
<< " " << m[0][3] << " " << m[1][3] << " " << m[2][3] << " " << m[3][3] << std::endl;
}
private:
std::stack<glm::mat4> matr_;
};
#endif
#ifndef INF2705_NUANCEUR_H
#define INF2705_NUANCEUR_H
////////////////////////////////////////////////////////////////////////////
//
// Classe pour charger les nuanceurs
// (INF2705, Benoît Ozell)
////////////////////////////////////////////////////////////////////////////
#include <GL/glew.h>
#include <iostream>
#include <string.h>
#include <errno.h>
#include <fstream>
#include <sstream>
class ProgNuanceur
{
public:
ProgNuanceur( ) : prog_(0), etiquette_("vide") { }
~ProgNuanceur( ) { /* glDeleteShader(); */ glDeleteProgram( prog_ ); }
operator GLuint() const { return prog_; }
ProgNuanceur& operator=( GLuint prog ) { prog_ = prog; return *this; }
// Demander à OpenGL de créer un programme de nuanceur
void creer( const std::string etiquette = "" )
{
if ( prog_ ) glDeleteProgram( prog_ );
prog_ = glCreateProgram();
etiquette_ = etiquette;
if ( etiquette_ == "" ) { std::ostringstream oss; oss << prog_; etiquette_ += oss.str(); }
}
// Charger en mémoire le contenu du fichier
static const GLchar *lireNuanceur( const GLchar *fich )
{
// Ouvrir le fichier
std::ifstream fichier( fich );
if ( fichier.fail() )
{
std::cerr << "!!! " << fich << ": " << strerror(errno) << std::endl;
return NULL;
}
// Lire le fichier
std::stringstream contenuFichier;
contenuFichier << fichier.rdbuf();
fichier.close();
// Obtenir le contenu du fichier
std::string contenu = contenuFichier.str();
const int taille = contenu.size();
// Retourner une chaîne pour le nuanceur
char *source = new char[taille+1];
strcpy( source, contenu.c_str() );
return source;
}
// Afficher le log de la compilation
static bool afficherLogCompile( GLuint nuanceurObj )
{
// afficher le message d'erreur, le cas échéant
int infologLength = 0;
glGetShaderiv( nuanceurObj, GL_INFO_LOG_LENGTH, &infologLength );
if ( infologLength > 1 )
{
char* infoLog = new char[infologLength+1];
int charsWritten = 0;
glGetShaderInfoLog( nuanceurObj, infologLength, &charsWritten, infoLog );
std::cout << std::endl << infoLog << std::endl;
delete[] infoLog;
return( false );
}
return( true );
}
// Compiler et attacher le nuanceur
bool attacher( GLuint type, GLsizei nbChaine, const GLchar **chaines, const GLint *longueur = NULL )
{
GLuint nuanceurObj = glCreateShader( type );
glShaderSource( nuanceurObj, nbChaine, chaines, longueur );
glCompileShader( nuanceurObj );
glAttachShader( prog_, nuanceurObj );
return ( afficherLogCompile(nuanceurObj) );
}
bool attacher( GLuint type, const GLchar *fich )
{
bool rc = false;
const GLchar *fichChaine = lireNuanceur( fich );
if ( fichChaine != NULL )
{
rc = attacher( type, 1, &fichChaine, NULL );
delete [] fichChaine;
}
return( rc );
}
bool attacher( GLuint type, const GLchar *preambule, const GLchar *fich )
{
bool rc = false;
if ( fich == NULL ) // le nuanceur complet est dans le préambule
rc = attacher( type, 1, &preambule, NULL );
else
{
const GLchar *chaines[2] = { preambule, lireNuanceur( fich ) };
if ( chaines[1] != NULL )
{
rc = attacher( type, 2, chaines, NULL );
delete [] chaines[1];
}
}
return( rc );
}
bool attacher( GLuint type, const std::string preambule, const GLchar *fich )
{ return attacher( type, preambule.c_str(), fich ); }
// Afficher le log de l'édition des liens
static bool afficherLogLink( GLuint progObj )
{
// afficher le message d'erreur, le cas échéant
int infologLength = 0;
glGetProgramiv( progObj, GL_INFO_LOG_LENGTH, &infologLength );
if ( infologLength > 1 )
{
char* infoLog = new char[infologLength+1];
int charsWritten = 0;
glGetProgramInfoLog( progObj, infologLength, &charsWritten, infoLog );
std::cout << "progObj" << std::endl << infoLog << std::endl;
delete[] infoLog;
return( false );
}
return( true );
}
// Faire l'édition des liens du programme
bool lier( )
{
glLinkProgram( prog_ );
return( afficherLogLink(prog_) );
}
// le nuanceur de sommets minimal
static const GLchar *chainesSommetsMinimal;
// le nuanceur de fragments minimal
static const GLchar *chainesFragmentsMinimal;
private:
GLuint prog_; // LE programme
std::string etiquette_; // une étiquette pour identifier le programme
};
// le nuanceur de sommets minimal
const GLchar *ProgNuanceur::chainesSommetsMinimal =
{
"#version 410\n"
"uniform mat4 matrModel;\n"
"uniform mat4 matrVisu;\n"
"uniform mat4 matrProj;\n"
"layout(location=0) in vec4 Vertex;\n"
"layout(location=3) in vec4 Color;\n"
"out vec4 couleur;\n"
"void main( void )\n"
"{\n"
" // transformation standard du sommet\n"
" gl_Position = matrProj * matrVisu * matrModel * Vertex;\n"
" // couleur du sommet\n"
" couleur = Color;\n"
"}\n"
};
// le nuanceur de fragments minimal
const GLchar *ProgNuanceur::chainesFragmentsMinimal =
{
"#version 410\n"
"in vec4 couleur;\n"
"out vec4 FragColor;\n"
"void main( void )\n"
"{\n"
" // la couleur du fragment est la couleur interpolée\n"
" FragColor = couleur;\n"
"}\n"
};
#endif
#ifndef INF2705_FENETRE_H
#define INF2705_FENETRE_H
////////////////////////////////////////////////////////////////////////////
//
// Classe pour créer une fenêtre
// (INF2705, Benoît Ozell)
////////////////////////////////////////////////////////////////////////////
#include <GL/glew.h>
#include <iostream>
#include <fstream>
#include <sstream>
#if defined( __APPLE__ )
#define FENETRE_LIB_GLFW 1
#else
#define FENETRE_LIB_SDL 1
#endif
#if defined(FENETRE_LIB_GLFW)
# include <GLFW/glfw3.h>
#else
# include <SDL.h>
#endif
#include <string.h>
#include <stdlib.h>
typedef enum {
#if defined(FENETRE_LIB_GLFW)
TP_ECHAP = GLFW_KEY_ESCAPE,
TP_BAS = GLFW_KEY_UP,
TP_HAUT = GLFW_KEY_DOWN,
TP_PAGEPREC = GLFW_KEY_PAGE_UP,
TP_PAGESUIV = GLFW_KEY_PAGE_DOWN,
TP_DEBUT = GLFW_KEY_HOME,
TP_FIN = GLFW_KEY_END,
TP_EGAL = '=', // GLFW_KEY_EQUALS,
TP_SUPERIEUR = '>', // GLFW_KEY_GREATER,
TP_INFERIEUR = '<', // GLFW_KEY_LESS,
TP_DROITE = GLFW_KEY_RIGHT,
TP_GAUCHE = GLFW_KEY_LEFT,
TP_PLUS = '+', // GLFW_KEY_PLUS,
TP_MOINS = GLFW_KEY_MINUS,
TP_CROCHETDROIT = GLFW_KEY_RIGHT_BRACKET,
TP_CROCHETGAUCHE = GLFW_KEY_LEFT_BRACKET,
TP_POINT = GLFW_KEY_PERIOD,
TP_VIRGULE = GLFW_KEY_COMMA,
TP_POINTVIRGULE = GLFW_KEY_SEMICOLON,
TP_BARREOBLIQUE = GLFW_KEY_SLASH,
TP_ESPACE = GLFW_KEY_SPACE,
TP_SOULIGNE = '_', // GLFW_KEY_UNDERSCORE,
TP_CONTROLEGAUCHE= GLFW_KEY_LEFT_CONTROL,
TP_0 = GLFW_KEY_0,
TP_1 = GLFW_KEY_1,
TP_2 = GLFW_KEY_2,
TP_3 = GLFW_KEY_3,
TP_4 = GLFW_KEY_4,
TP_5 = GLFW_KEY_5,
TP_6 = GLFW_KEY_6,
TP_7 = GLFW_KEY_7,
TP_8 = GLFW_KEY_8,
TP_9 = GLFW_KEY_9,
TP_a = GLFW_KEY_A,
TP_b = GLFW_KEY_B,
TP_c = GLFW_KEY_C,
TP_d = GLFW_KEY_D,
TP_e = GLFW_KEY_E,
TP_f = GLFW_KEY_F,
TP_g = GLFW_KEY_G,
TP_h = GLFW_KEY_H,
TP_i = GLFW_KEY_I,
TP_j = GLFW_KEY_J,
TP_k = GLFW_KEY_K,
TP_l = GLFW_KEY_L,
TP_m = GLFW_KEY_M,
TP_n = GLFW_KEY_N,
TP_o = GLFW_KEY_O,
TP_p = GLFW_KEY_P,
TP_q = GLFW_KEY_Q,
TP_r = GLFW_KEY_R,
TP_s = GLFW_KEY_S,
TP_t = GLFW_KEY_T,
TP_u = GLFW_KEY_U,
TP_v = GLFW_KEY_V,
TP_w = GLFW_KEY_W,
TP_x = GLFW_KEY_X,
TP_y = GLFW_KEY_Y,
TP_z = GLFW_KEY_Z,
#else
TP_ECHAP = SDLK_ESCAPE,
TP_BAS = SDLK_UP,
TP_HAUT = SDLK_DOWN,
TP_PAGEPREC = SDLK_PAGEUP,
TP_PAGESUIV = SDLK_PAGEDOWN,
TP_DEBUT = SDLK_HOME,
TP_FIN = SDLK_END,
TP_EGAL = SDLK_EQUALS,
TP_SUPERIEUR = SDLK_GREATER,
TP_INFERIEUR = SDLK_LESS,
TP_DROITE = SDLK_RIGHT,
TP_GAUCHE = SDLK_LEFT,
TP_PLUS = SDLK_PLUS,
TP_MOINS = SDLK_MINUS,
TP_CROCHETDROIT = SDLK_RIGHTBRACKET,
TP_CROCHETGAUCHE = SDLK_LEFTBRACKET,
TP_POINT = SDLK_PERIOD,
TP_VIRGULE = SDLK_COMMA,
TP_POINTVIRGULE = SDLK_SEMICOLON,
TP_BARREOBLIQUE = SDLK_SLASH,
TP_ESPACE = SDLK_SPACE,
TP_SOULIGNE = SDLK_UNDERSCORE,
TP_CONTROLEGAUCHE= SDLK_LCTRL,
TP_0 = SDLK_0,
TP_1 = SDLK_1,
TP_2 = SDLK_2,
TP_3 = SDLK_3,
TP_4 = SDLK_4,
TP_5 = SDLK_5,
TP_6 = SDLK_6,
TP_7 = SDLK_7,
TP_8 = SDLK_8,
TP_9 = SDLK_9,
TP_a = SDLK_a,
TP_b = SDLK_b,
TP_c = SDLK_c,
TP_d = SDLK_d,
TP_e = SDLK_e,
TP_f = SDLK_f,
TP_g = SDLK_g,
TP_h = SDLK_h,
TP_i = SDLK_i,
TP_j = SDLK_j,
TP_k = SDLK_k,
TP_l = SDLK_l,
TP_m = SDLK_m,
TP_n = SDLK_n,
TP_o = SDLK_o,
TP_p = SDLK_p,
TP_q = SDLK_q,
TP_r = SDLK_r,
TP_s = SDLK_s,
TP_t = SDLK_t,
TP_u = SDLK_u,
TP_v = SDLK_v,
TP_w = SDLK_w,
TP_x = SDLK_x,
TP_y = SDLK_y,
TP_z = SDLK_z,
#endif
} TP_touche;
typedef enum {
#if defined(FENETRE_LIB_GLFW)
TP_BOUTON_GAUCHE = GLFW_MOUSE_BUTTON_1,
TP_BOUTON_MILIEU = GLFW_MOUSE_BUTTON_3,
TP_BOUTON_DROIT = GLFW_MOUSE_BUTTON_2,
TP_RELACHE = GLFW_RELEASE,
TP_PRESSE = GLFW_PRESS,
#else
TP_BOUTON_GAUCHE = SDL_BUTTON_LEFT,
TP_BOUTON_MILIEU = SDL_BUTTON_MIDDLE,
TP_BOUTON_DROIT = SDL_BUTTON_RIGHT,
TP_RELACHE = SDL_RELEASED,
TP_PRESSE = SDL_PRESSED,
#endif
} TP_bouton;
// la fenêtre graphique
class FenetreTP
{
#if defined(FENETRE_LIB_GLFW)
static void key_callback( GLFWwindow* window, int key, int scancode, int action, int mods )
{
FenetreTP *fen = (FenetreTP*) glfwGetWindowUserPointer( window );
if ( action == GLFW_PRESS )
fen->clavier( (TP_touche) key );
}
static void mouse_button_callback( GLFWwindow* window, int button, int action, int mods )
{
FenetreTP *fen = (FenetreTP*) glfwGetWindowUserPointer( window );
double xpos, ypos; glfwGetCursorPos( window, &xpos, &ypos );
fen->sourisClic( button, action, xpos, ypos );
}
static void cursor_position_callback( GLFWwindow* window, double xpos, double ypos )
{
FenetreTP *fen = (FenetreTP*) glfwGetWindowUserPointer( window );
fen->sourisMouvement( xpos, ypos );
}
static void scroll_callback( GLFWwindow* window, double xoffset, double yoffset )
{
FenetreTP *fen = (FenetreTP*) glfwGetWindowUserPointer( window );
fen->sourisWheel( xoffset, yoffset );
}
static void window_refresh_callback( GLFWwindow* window )
{
FenetreTP *fen = (FenetreTP*) glfwGetWindowUserPointer( window );
// int left, top, right, bottom;
// glfwGetWindowFrameSize( window, &left, &top, &right, &bottom );
// fen->redimensionner( right-left, top-bottom );
int width, height;
glfwGetWindowSize( window, &width, &height );
fen->redimensionner( width, height );
fen->afficherScene();
fen->swap();
}
#else
#endif
public:
FenetreTP( std::string nom = "INF2705 TP",
int largeur = 900, int hauteur = 600,
int xpos = 100, int ypos = 100 )
: fenetre_(NULL),
#if defined(FENETRE_LIB_GLFW)
#else
contexte_(NULL),
#endif
largeur_(largeur), hauteur_(hauteur)
{
#if defined(FENETRE_LIB_GLFW)
// initialiser GLFW
if ( !glfwInit() )
{
glfwdie( "ERREUR: Incapable d'initialiser GLFW3\n");
}
// demander certaines caractéristiques:
glfwWindowHint( GLFW_RED_BITS, 8 );
glfwWindowHint( GLFW_GREEN_BITS, 8 );
glfwWindowHint( GLFW_BLUE_BITS, 8 );
glfwWindowHint( GLFW_ALPHA_BITS, 8 );
//glfwWindowHint( GLFW_DOUBLEBUFFER, GL_TRUE );
glfwWindowHint( GLFW_DEPTH_BITS, 24 );
glfwWindowHint( GLFW_STENCIL_BITS, 8 );
#if defined( __APPLE__ )
glfwWindowHint( GLFW_CONTEXT_VERSION_MAJOR, 4 );
glfwWindowHint( GLFW_CONTEXT_VERSION_MINOR, 1 );
glfwWindowHint( GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE );
glfwWindowHint( GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE );
#endif
// créer la fenêtre
fenetre_ = glfwCreateWindow( largeur, hauteur, nom.c_str(), NULL, NULL );
if ( !fenetre_ )
{
glfwdie( "ERROR: Incapable de créer la fenêtre GLFW3\n");
}
glfwMakeContextCurrent( fenetre_ );
glfwSwapInterval(1);
glfwSetWindowUserPointer( fenetre_, this );
glfwSetKeyCallback( fenetre_, key_callback );
glfwSetMouseButtonCallback( fenetre_, mouse_button_callback );
glfwSetCursorPosCallback( fenetre_, cursor_position_callback );
glfwSetScrollCallback( fenetre_, scroll_callback );
glfwSetWindowRefreshCallback( fenetre_, window_refresh_callback );
#else
// initialiser SDL
const Uint32 flags = SDL_INIT_VIDEO | SDL_INIT_EVENTS;
if ( SDL_WasInit( flags ) == 0 )
{
if ( SDL_Init( flags ) < 0 ) sdldie( "ERREUR: Incapable d'initialiser SDL" );
atexit( SDL_Quit );
}
// demander certaines caractéristiques: https://wiki.libsdl.org/SDL_GL_SetAttribute
SDL_GL_SetAttribute( SDL_GL_RED_SIZE, 8 );
SDL_GL_SetAttribute( SDL_GL_GREEN_SIZE, 8 );
SDL_GL_SetAttribute( SDL_GL_BLUE_SIZE, 8 );
SDL_GL_SetAttribute( SDL_GL_ALPHA_SIZE, 8 );
//SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
SDL_GL_SetAttribute( SDL_GL_DEPTH_SIZE, 24 );
SDL_GL_SetAttribute( SDL_GL_STENCIL_SIZE, 8 );
//SDL_GL_SetAttribute( SDL_GL_MULTISAMPLESAMPLES, 4 );
SDL_GL_SetAttribute( SDL_GL_ACCELERATED_VISUAL, 1 );
#if 0
SDL_GL_SetAttribute( SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE );
//SDL_GL_SetAttribute( SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_COMPATIBILITY );
SDL_GL_SetAttribute( SDL_GL_CONTEXT_MAJOR_VERSION, 4 );
SDL_GL_SetAttribute( SDL_GL_CONTEXT_MINOR_VERSION, 1 );
#endif
// créer la fenêtre
fenetre_ = SDL_CreateWindow( nom.c_str(), xpos, ypos, largeur, hauteur,
SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE );
if ( !fenetre_ ) sdldie( "ERREUR: Incapable de créer la fenêtre SDL" );
verifierErreurSDL(__LINE__);
// créer le contexte OpenGL
contexte_ = SDL_GL_CreateContext( fenetre_ );
verifierErreurSDL(__LINE__);
// s'assurer que les réaffichage seront synchronisés avec le rafraîchissement de l'écran
SDL_GL_SetSwapInterval( 1 );
verifierErreurSDL(__LINE__);
#endif
// initiliaser GLEW
initialiserGLEW( );
// imprimer un peu d'information OpenGL
imprimerInfosGL( );
}
#if defined(FENETRE_LIB_GLFW)
void quit( )
{
glfwDestroyWindow( fenetre_ );
glfwTerminate();
exit(0);
}
~FenetreTP( )
{
quit();
}
#else
void quit( )
{
SDL_Event sdlevent; sdlevent.type = SDL_QUIT;
SDL_PushEvent( &sdlevent );
}
~FenetreTP( )
{
SDL_GL_DeleteContext( contexte_ ); contexte_ = NULL;
SDL_DestroyWindow( fenetre_ ); fenetre_ = NULL;
}
#endif
// mettre à jour la fenêtre OpenGL: le tampon arrière devient le tampon avant et vice-versa
#if defined(FENETRE_LIB_GLFW)
void swap( ) { glfwSwapBuffers( fenetre_ ); }
#else
void swap( ) { SDL_GL_SwapWindow( fenetre_ ); }
#endif
// fonction appelée pour tracer la scène
void afficherScene( );
// fonction appelée lors d'un événement de redimensionnement
void redimensionner( GLsizei w, GLsizei h );
// fonction appelée lors d'un événement de clavier
void clavier( TP_touche touche );
// fonction appelée lors d'un événement de clavier relaché
void clavierRelache( TP_touche touche );
// fonctions appelées lors d'un événement de souris
void sourisClic( int button, int state, int x, int y );
void sourisWheel( int x, int y );
void sourisMouvement( int x, int y );
// fonction de gestion de la boucle des événements
bool gererEvenement( )
{
#if defined(FENETRE_LIB_GLFW)
glfwPollEvents();
return( !glfwWindowShouldClose( fenetre_ ) );
#else
SDL_Event e;
while ( SDL_PollEvent( &e ) )
{
switch ( e.type )
{
case SDL_QUIT: // c'est la fin
return( false );
break;
case SDL_WINDOWEVENT:
if ( e.window.event == SDL_WINDOWEVENT_SIZE_CHANGED ) // redimensionnement
{
largeur_ = e.window.data1;
hauteur_ = e.window.data2;
redimensionner( largeur_, hauteur_ );
}
else if ( e.window.event == SDL_WINDOWEVENT_SHOWN ) // affichage
{
SDL_GetWindowSize( fenetre_, &largeur_, &hauteur_ );
redimensionner( largeur_, hauteur_ );
}
//else
// std::cout << "//@FenetreTP,WINDOWEVENT;" << " e.window.event=" << e.window.event << std::endl;
break;
case SDL_KEYDOWN: // une touche est pressée
clavier( (TP_touche) e.key.keysym.sym );
break;
case SDL_KEYUP: // une touche est relâchée
clavierRelache( (TP_touche) e.key.keysym.sym );
break;
case SDL_MOUSEBUTTONDOWN: // un bouton de la souris est pressé
case SDL_MOUSEBUTTONUP: // un bouton de la souris est relâché
sourisClic( e.button.button, e.button.state, e.button.x, e.button.y );
break;
case SDL_MOUSEMOTION: // la souris est déplacée
sourisMouvement( e.motion.x, e.motion.y );
break;
case SDL_MOUSEWHEEL: // la molette de la souris est tournée
sourisWheel( e.wheel.x, e.wheel.y );
break;
default:
//std::cerr << "//@FenetreTP," << __LINE__ << ";" << " e.type=" << e.type << std::endl;
break;
}
}
return( true );
#endif
}
//
// Quelques fonctions utilitaires
//
// Charger en mémoire le contenu du fichier
static void imprimerTouches( )
{
// Ouvrir le fichier
std::ifstream fichier( "touches.txt" );
if ( fichier.fail() ) return;
// Lire le fichier
std::stringstream contenuFichier;
contenuFichier << fichier.rdbuf();
fichier.close();
// Ecrire le contenu du fichier
std::cout << " touches possibles :" << std::endl
<< contenuFichier.str() << std::endl;
}
// afficher les versions des éléments du pipeline OpenGL
static void imprimerInfosGL( const int verbose = 1 )
{
#define PBYTE(CHAINE) ( (CHAINE) != NULL ? (CHAINE) : (const GLubyte *) "????" )
#define PCHAR(CHAINE) ( (CHAINE) != NULL ? (CHAINE) : (const char *) "????" )
if ( verbose >= 1 )
{
#if defined(FENETRE_LIB_GLFW)
int major, minor, rev; glfwGetVersion( &major, &minor, &rev );
std::cout << "// GLFW " << major << "." << minor << "." << rev << std::endl;
#else
SDL_version linked; SDL_GetVersion( &linked );
std::cout << "// SDL " << (int) linked.major << "." << (int) linked.minor << "." << (int) linked.patch << std::endl;
#endif
const GLubyte *glVersion = glGetString( GL_VERSION );
const GLubyte *glVendor = glGetString( GL_VENDOR );
const GLubyte *glRenderer = glGetString( GL_RENDERER );
const GLubyte *glslVersion = glGetString( GL_SHADING_LANGUAGE_VERSION );
std::cout << "// OpenGL " << PBYTE(glVersion) << PBYTE(glVendor) << std::endl;
std::cout << "// GPU " << PBYTE(glRenderer) << std::endl;
std::cout << "// GLSL " << PBYTE(glslVersion) << std::endl;
if ( verbose >= 2 )
{
const GLubyte *glExtensions = glGetString( GL_EXTENSIONS );
std::cout << "// extensions = " << PBYTE(glExtensions) << std::endl;
}
}
#undef PBYTE
#undef PCHAR
return;
}
#if defined(FENETRE_LIB_GLFW)
// donner une message et mourir...
static void glfwdie( const char *msg )
{
//const char *sdlerror = SDL_GetError();
//std::cout << "glfwdie " << msg << " " << sdlerror << std::endl;
std::cout << "glfwdie " << msg << " " << std::endl;
//glfwTerminate();
exit(1);
}
#else
// donner une message et mourir...
static void sdldie( const char *msg )
{
const char *sdlerror = SDL_GetError();
std::cout << "sdldie " << msg << " " << sdlerror << std::endl;
SDL_Quit();
exit(1);
}
// vérifier les erreurs
static void verifierErreurSDL( int line = -1 )
{
const char *sdlerror = SDL_GetError();
if ( *sdlerror != '\0' )
{
std::cout << "SDL Error: " << sdlerror << std::endl;
if ( line != -1 )
std::cout << "line: " << line;
std::cout << std::endl;
SDL_ClearError();
}
}
#endif
// La fonction glGetError() permet de savoir si une erreur est survenue depuis le dernier appel à cette fonction.
static int VerifierErreurGL( const std::string message )
{
int rc = 0;
GLenum err;
while ( ( err = glGetError() ) != GL_NO_ERROR )
{
std::cerr << "Erreur OpenGL, " << message << " " << std::endl;
switch ( err )
{
case GL_INVALID_ENUM:
std::cerr << "GL_INVALID_ENUM: Valeur d'une énumération hors limite.";
break;
case GL_INVALID_VALUE:
std::cerr << "GL_INVALID_VALUE: Valeur numérique hors limite.";
break;
case GL_INVALID_OPERATION:
std::cerr << "GL_INVALID_OPERATION: Opération non permise dans l'état courant.";
break;
case GL_INVALID_FRAMEBUFFER_OPERATION:
std::cerr << "GL_INVALID_FRAMEBUFFER_OPERATION: L'objet est incomplet.";
break;
case GL_OUT_OF_MEMORY:
std::cerr << "GL_OUT_OF_MEMORY: Pas assez de mémoire pour exécuter la commande.";
break;
case GL_STACK_UNDERFLOW:
std::cerr << "GL_STACK_UNDERFLOW: Une opération entraînerait un débordement de pile interne.";
break;
case GL_STACK_OVERFLOW:
std::cerr << "GL_STACK_OVERFLOW: Une opération entraînerait un débordement de pile interne.";
break;
default:
std::cerr << "err = " << err << ": Erreur inconnue!";
break;
}
std::cerr << std::endl;
++rc;
}
return( rc );
}
// La fonction afficherAxes affiche des axes qui représentent l'orientation courante du repère
// Les axes sont colorés ainsi: X = Rouge, Y = Vert, Z = Bleu
static void afficherAxes( const GLfloat longueurAxe = 1.0, const GLfloat largeurLigne = 2.0 )
{
#if !defined( __APPLE__ )
glPushAttrib( GL_ENABLE_BIT | GL_LINE_BIT );
glLineWidth( largeurLigne );
const GLfloat coo[] = { 0., 0., 0.,
longueurAxe, 0., 0.,
0., longueurAxe, 0.,
0., 0., longueurAxe };
const GLfloat couleur[] = { 1., 1., 1.,
1., 0., 0.,
0., 1., 0.,
0., 0., 1. };
#if 0
const GLuint connec[] = { 0, 1, 0, 2, 0, 3 };
GLint locVertex = 0;
glVertexAttribPointer( locVertex, 3, GL_FLOAT, GL_FALSE, 0, coo );
glEnableVertexAttribArray(locVertex);
GLint locColor = 3;
glVertexAttribPointer( locColor, 3, GL_FLOAT, GL_FALSE, 0, couleur );
glEnableVertexAttribArray(locColor);
glDrawElements( GL_LINES, sizeof(connec)/sizeof(GLuint), GL_UNSIGNED_INT, connec );
#else
glBegin( GL_LINES );{
glColor3fv( &(couleur[3]) ); glVertex3fv( &(coo[0]) ); glVertex3fv( &(coo[3]) );
glColor3fv( &(couleur[6]) ); glVertex3fv( &(coo[0]) ); glVertex3fv( &(coo[6]) );
glColor3fv( &(couleur[9]) ); glVertex3fv( &(coo[0]) ); glVertex3fv( &(coo[9]) );
}glEnd( );
#endif
glPopAttrib( );
#endif
return;
}
private:
void initialiserGLEW( )
{
//#if defined(_GLEW_H__)
glewExperimental = GL_TRUE;
GLenum rev = glewInit();
if ( rev != GLEW_OK )
{
std::cout << "Error: " << glewGetErrorString(rev) << std::endl;
exit( 1 );
}
glGetError(); // Afin d'ignorer l'erreur générée par GLEW. Voir https://www.opengl.org/wiki/OpenGL_Loading_Library#GLEW_.28OpenGL_Extension_Wrangler.29
//#endif
}
#if defined(FENETRE_LIB_GLFW)
GLFWwindow *fenetre_;
#else
SDL_Window *fenetre_;
SDL_GLContext contexte_;
#endif
GLsizei largeur_; // la largeur de la fenêtre
GLsizei hauteur_; // la hauteur de la fenêtre
};
#endif
#ifndef INF2705_TEXTURE_H
#define INF2705_TEXTURE_H
////////////////////////////////////////////////////////////////////////////
//
// Fonctions pour charger une texture
// (INF2705, Benoît Ozell)
////////////////////////////////////////////////////////////////////////////
#include <GL/glew.h>
#include <iostream>
#include <string.h>
/*
* Windows Bitmap File Loader
* Version 1.2.5 (20120929)
*
* Supported Formats: 1, 4, 8, 16, 24, 32 Bit Images
* Alpha Bitmaps are also supported.
* Supported compression types: RLE 8, BITFIELDS
*
* Created by: Benjamin Kalytta, 2006 - 2012
* Thanks for bug fixes goes to: Chris Campbell
*
* Licence: Free to use, URL to my source and my name is required in your source code.
*
* Source can be found at http://www.kalytta.com/bitmap.h
*
* Warning: This code should not be used in unmodified form in a production environment.
* It should only serve as a basis for your own development.
* There is only a minimal error handling in this code. (Notice added 20111211)
*/
#include <fstream>
#include <string>
#ifndef __LITTLE_ENDIAN__
# ifndef __BIG_ENDIAN__
# define __LITTLE_ENDIAN__
# endif
#endif
#ifdef __LITTLE_ENDIAN__
# define BITMAP_SIGNATURE 0x4d42
#else
# define BITMAP_SIGNATURE 0x424d
#endif
#if defined(_MSC_VER) || defined(__INTEL_COMPILER)
typedef unsigned __int32 uint32_t;
typedef unsigned __int16 uint16_t;
typedef unsigned __int8 uint8_t;
typedef __int32 int32_t;
#elif defined(__GNUC__) || defined(__CYGWIN__) || defined(__MWERKS__) || defined(__WATCOMC__) || defined(__PGI) || defined(__LCC__)
# include <stdint.h>
#else
typedef unsigned int uint32_t;
typedef unsigned short int uint16_t;
typedef unsigned char uint8_t;
typedef int int32_t;
#endif
#pragma pack(push, 1)
typedef struct _BITMAP_FILEHEADER {
uint16_t Signature;
uint32_t Size;
uint32_t Reserved;
uint32_t BitsOffset;
} BITMAP_FILEHEADER;
#define BITMAP_FILEHEADER_SIZE 14
typedef struct _BITMAP_HEADER {
uint32_t HeaderSize;
int32_t Width;
int32_t Height;
uint16_t Planes;
uint16_t BitCount;
uint32_t Compression;
uint32_t SizeImage;
int32_t PelsPerMeterX;
int32_t PelsPerMeterY;
uint32_t ClrUsed;
uint32_t ClrImportant;
uint32_t RedMask;
uint32_t GreenMask;
uint32_t BlueMask;
uint32_t AlphaMask;
uint32_t CsType;
uint32_t Endpoints[9]; // see http://msdn2.microsoft.com/en-us/library/ms536569.aspx
uint32_t GammaRed;
uint32_t GammaGreen;
uint32_t GammaBlue;
} BITMAP_HEADER;
typedef struct _RGBA {
uint8_t Red;
uint8_t Green;
uint8_t Blue;
uint8_t Alpha;
} RGBA;
typedef struct _BGRA {
uint8_t Blue;
uint8_t Green;
uint8_t Red;
uint8_t Alpha;
} BGRA;
#pragma pack(pop)
class CBitmap {
private:
BITMAP_FILEHEADER m_BitmapFileHeader;
BITMAP_HEADER m_BitmapHeader;
RGBA *m_BitmapData;
unsigned int m_BitmapSize;
// Masks and bit counts shouldn't exceed 32 Bits
public:
class CColor {
public:
static inline unsigned int BitCountByMask(unsigned int Mask) {
unsigned int BitCount = 0;
while (Mask) {
Mask &= Mask - 1;
BitCount++;
}
return BitCount;
}
static inline unsigned int BitPositionByMask(unsigned int Mask) {
return BitCountByMask((Mask & (~Mask + 1)) - 1);
}
static inline unsigned int ComponentByMask(unsigned int Color, unsigned int Mask) {
unsigned int Component = Color & Mask;
return Component >> BitPositionByMask(Mask);
}
static inline unsigned int BitCountToMask(unsigned int BitCount) {
return (BitCount == 32) ? 0xFFFFFFFF : (1 << BitCount) - 1;
}
static unsigned int Convert(unsigned int Color, unsigned int FromBitCount, unsigned int ToBitCount) {
if (ToBitCount < FromBitCount) {
Color >>= (FromBitCount - ToBitCount);
} else {
Color <<= (ToBitCount - FromBitCount);
if (Color > 0) {
Color |= BitCountToMask(ToBitCount - FromBitCount);
}
}
return Color;
}
};
public:
CBitmap() : m_BitmapData(0), m_BitmapSize(0) {
Dispose();
}
CBitmap(const char* Filename) : m_BitmapData(0), m_BitmapSize(0) {
Load(Filename);
}
~CBitmap() {
Dispose();
}
void Dispose() {
if (m_BitmapData) {
delete[] m_BitmapData;
m_BitmapData = 0;
}
memset(&m_BitmapFileHeader, 0, sizeof(m_BitmapFileHeader));
memset(&m_BitmapHeader, 0, sizeof(m_BitmapHeader));
}
/* Load specified Bitmap and stores it as RGBA in an internal buffer */
bool Load(const char *Filename) {
std::ifstream file(Filename, std::ios::binary | std::ios::in);
if (file.bad()) {
return false;
}
if (file.is_open() == false) {
return false;
}
Dispose();
file.read((char*) &m_BitmapFileHeader, BITMAP_FILEHEADER_SIZE);
if (m_BitmapFileHeader.Signature != BITMAP_SIGNATURE) {
return false;
}
file.read((char*) &m_BitmapHeader, sizeof(BITMAP_HEADER));
/* Load Color Table */
file.seekg(BITMAP_FILEHEADER_SIZE + m_BitmapHeader.HeaderSize, std::ios::beg);
unsigned int ColorTableSize = 0;
if (m_BitmapHeader.BitCount == 1) {
ColorTableSize = 2;
} else if (m_BitmapHeader.BitCount == 4) {
ColorTableSize = 16;
} else if (m_BitmapHeader.BitCount == 8) {
ColorTableSize = 256;
}
// Always allocate full sized color table
BGRA* ColorTable = new BGRA[ColorTableSize]; // std::bad_alloc exception should be thrown if memory is not available
file.read((char*) ColorTable, sizeof(BGRA) * m_BitmapHeader.ClrUsed);
/* ... Color Table for 16 bits images are not supported yet */
m_BitmapSize = GetWidth() * GetHeight();
m_BitmapData = new RGBA[m_BitmapSize];
unsigned int LineWidth = ((GetWidth() * GetBitCount() / 8) + 3) & ~3;
uint8_t *Line = new uint8_t[LineWidth];
file.seekg(m_BitmapFileHeader.BitsOffset, std::ios::beg);
int Index = 0;
bool Result = true;
if (m_BitmapHeader.Compression == 0) {
for (unsigned int i = 0; i < GetHeight(); i++) {
file.read((char*) Line, LineWidth);
uint8_t *LinePtr = Line;
for (unsigned int j = 0; j < GetWidth(); j++) {
if (m_BitmapHeader.BitCount == 1) {
uint32_t Color = *((uint8_t*) LinePtr);
for (int k = 0; k < 8; k++) {
m_BitmapData[Index].Red = ColorTable[Color & 0x80 ? 1 : 0].Red;
m_BitmapData[Index].Green = ColorTable[Color & 0x80 ? 1 : 0].Green;
m_BitmapData[Index].Blue = ColorTable[Color & 0x80 ? 1 : 0].Blue;
m_BitmapData[Index].Alpha = ColorTable[Color & 0x80 ? 1 : 0].Alpha;
Index++;
Color <<= 1;
}
LinePtr++;
j += 7;
} else if (m_BitmapHeader.BitCount == 4) {
uint32_t Color = *((uint8_t*) LinePtr);
m_BitmapData[Index].Red = ColorTable[(Color >> 4) & 0x0f].Red;
m_BitmapData[Index].Green = ColorTable[(Color >> 4) & 0x0f].Green;
m_BitmapData[Index].Blue = ColorTable[(Color >> 4) & 0x0f].Blue;
m_BitmapData[Index].Alpha = ColorTable[(Color >> 4) & 0x0f].Alpha;
Index++;
m_BitmapData[Index].Red = ColorTable[Color & 0x0f].Red;
m_BitmapData[Index].Green = ColorTable[Color & 0x0f].Green;
m_BitmapData[Index].Blue = ColorTable[Color & 0x0f].Blue;
m_BitmapData[Index].Alpha = ColorTable[Color & 0x0f].Alpha;
Index++;
LinePtr++;
j++;
} else if (m_BitmapHeader.BitCount == 8) {
uint32_t Color = *((uint8_t*) LinePtr);
m_BitmapData[Index].Red = ColorTable[Color].Red;
m_BitmapData[Index].Green = ColorTable[Color].Green;
m_BitmapData[Index].Blue = ColorTable[Color].Blue;
m_BitmapData[Index].Alpha = ColorTable[Color].Alpha;
Index++;
LinePtr++;
} else if (m_BitmapHeader.BitCount == 16) {
uint32_t Color = *((uint16_t*) LinePtr);
m_BitmapData[Index].Red = ((Color >> 10) & 0x1f) << 3;
m_BitmapData[Index].Green = ((Color >> 5) & 0x1f) << 3;
m_BitmapData[Index].Blue = (Color & 0x1f) << 3;
m_BitmapData[Index].Alpha = 255;
Index++;
LinePtr += 2;
} else if (m_BitmapHeader.BitCount == 24) {
uint32_t Color = *((uint32_t*) LinePtr);
m_BitmapData[Index].Blue = Color & 0xff;
m_BitmapData[Index].Green = (Color >> 8) & 0xff;
m_BitmapData[Index].Red = (Color >> 16) & 0xff;
m_BitmapData[Index].Alpha = 255;
Index++;
LinePtr += 3;
} else if (m_BitmapHeader.BitCount == 32) {
uint32_t Color = *((uint32_t*) LinePtr);
m_BitmapData[Index].Blue = Color & 0xff;
m_BitmapData[Index].Green = (Color >> 8) & 0xff;
m_BitmapData[Index].Red = (Color >> 16) & 0xff;
m_BitmapData[Index].Alpha = Color >> 24;
Index++;
LinePtr += 4;
}
}
}
} else if (m_BitmapHeader.Compression == 1) { // RLE 8
uint8_t Count = 0;
uint8_t ColorIndex = 0;
int x = 0, y = 0;
while (file.eof() == false) {
file.read((char*) &Count, sizeof(uint8_t));
file.read((char*) &ColorIndex, sizeof(uint8_t));
if (Count > 0) {
Index = x + y * GetWidth();
for (int k = 0; k < Count; k++) {
m_BitmapData[Index + k].Red = ColorTable[ColorIndex].Red;
m_BitmapData[Index + k].Green = ColorTable[ColorIndex].Green;
m_BitmapData[Index + k].Blue = ColorTable[ColorIndex].Blue;
m_BitmapData[Index + k].Alpha = ColorTable[ColorIndex].Alpha;
}
x += Count;
} else if (Count == 0) {
int Flag = ColorIndex;
if (Flag == 0) {
x = 0;
y++;
} else if (Flag == 1) {
break;
} else if (Flag == 2) {
char rx = 0;
char ry = 0;
file.read((char*) &rx, sizeof(char));
file.read((char*) &ry, sizeof(char));
x += rx;
y += ry;
} else {
Count = Flag;
Index = x + y * GetWidth();
for (int k = 0; k < Count; k++) {
file.read((char*) &ColorIndex, sizeof(uint8_t));
m_BitmapData[Index + k].Red = ColorTable[ColorIndex].Red;
m_BitmapData[Index + k].Green = ColorTable[ColorIndex].Green;
m_BitmapData[Index + k].Blue = ColorTable[ColorIndex].Blue;
m_BitmapData[Index + k].Alpha = ColorTable[ColorIndex].Alpha;
}
x += Count;
// Attention: Current Microsoft STL implementation seems to be buggy, tellg() always returns 0.
if (file.tellg() & 1) {
file.seekg(1, std::ios::cur);
}
}
}
}
} else if (m_BitmapHeader.Compression == 2) { // RLE 4
/* RLE 4 is not supported */
Result = false;
} else if (m_BitmapHeader.Compression == 3) { // BITFIELDS
/* We assumes that mask of each color component can be in any order */
uint32_t BitCountRed = CColor::BitCountByMask(m_BitmapHeader.RedMask);
uint32_t BitCountGreen = CColor::BitCountByMask(m_BitmapHeader.GreenMask);
uint32_t BitCountBlue = CColor::BitCountByMask(m_BitmapHeader.BlueMask);
uint32_t BitCountAlpha = CColor::BitCountByMask(m_BitmapHeader.AlphaMask);
for (unsigned int i = 0; i < GetHeight(); i++) {
file.read((char*) Line, LineWidth);
uint8_t *LinePtr = Line;
for (unsigned int j = 0; j < GetWidth(); j++) {
uint32_t Color = 0;
if (m_BitmapHeader.BitCount == 16) {
Color = *((uint16_t*) LinePtr);
LinePtr += 2;
} else if (m_BitmapHeader.BitCount == 32) {
Color = *((uint32_t*) LinePtr);
LinePtr += 4;
} else {
// Other formats are not valid
}
m_BitmapData[Index].Red = CColor::Convert(CColor::ComponentByMask(Color, m_BitmapHeader.RedMask), BitCountRed, 8);
m_BitmapData[Index].Green = CColor::Convert(CColor::ComponentByMask(Color, m_BitmapHeader.GreenMask), BitCountGreen, 8);
m_BitmapData[Index].Blue = CColor::Convert(CColor::ComponentByMask(Color, m_BitmapHeader.BlueMask), BitCountBlue, 8);
m_BitmapData[Index].Alpha = CColor::Convert(CColor::ComponentByMask(Color, m_BitmapHeader.AlphaMask), BitCountAlpha, 8);
Index++;
}
}
}
delete [] ColorTable;
delete [] Line;
file.close();
return Result;
}
bool Save(const char* Filename, unsigned int BitCount = 32) {
bool Result = true;
std::ofstream file(Filename, std::ios::out | std::ios::binary);
if (file.is_open() == false) {
return false;
}
BITMAP_FILEHEADER bfh;
BITMAP_HEADER bh;
memset(&bfh, 0, sizeof(bfh));
memset(&bh, 0, sizeof(bh));
bfh.Signature = BITMAP_SIGNATURE;
bfh.BitsOffset = BITMAP_FILEHEADER_SIZE + sizeof(BITMAP_HEADER);
bfh.Size = (GetWidth() * GetHeight() * BitCount) / 8 + bfh.BitsOffset;
bh.HeaderSize = sizeof(BITMAP_HEADER);
bh.BitCount = BitCount;
if (BitCount == 32) {
bh.Compression = 3; // BITFIELD
bh.AlphaMask = 0xff000000;
bh.BlueMask = 0x00ff0000;
bh.GreenMask = 0x0000ff00;
bh.RedMask = 0x000000ff;
} else if (BitCount == 16) {
bh.Compression = 3; // BITFIELD
bh.AlphaMask = 0x00000000;
bh.BlueMask = 0x0000001f;
bh.GreenMask = 0x000007E0;
bh.RedMask = 0x0000F800;
} else {
bh.Compression = 0; // RGB
}
unsigned int LineWidth = (GetWidth() + 3) & ~3;
bh.Planes = 1;
bh.Height = GetHeight();
bh.Width = GetWidth();
bh.SizeImage = (LineWidth * BitCount * GetHeight()) / 8;
bh.PelsPerMeterX = 3780;
bh.PelsPerMeterY = 3780;
if (BitCount == 32) {
file.write((char*) &bfh, sizeof(BITMAP_FILEHEADER));
file.write((char*) &bh, sizeof(BITMAP_HEADER));
file.write((char*) m_BitmapData, bh.SizeImage);
} else if (BitCount < 16) {
uint8_t* Bitmap = new uint8_t[bh.SizeImage];
BGRA *Palette = 0;
unsigned int PaletteSize = 0;
if (GetBitsWithPalette(Bitmap, bh.SizeImage, BitCount, Palette, PaletteSize)) {
bfh.BitsOffset += PaletteSize * sizeof(BGRA);
file.write((char*) &bfh, BITMAP_FILEHEADER_SIZE);
file.write((char*) &bh, sizeof(BITMAP_HEADER));
file.write((char*) Palette, PaletteSize * sizeof(BGRA));
file.write((char*) Bitmap, bh.SizeImage);
}
delete [] Bitmap;
delete [] Palette;
} else {
uint32_t RedMask = 0;
uint32_t GreenMask = 0;
uint32_t BlueMask = 0;
uint32_t AlphaMask = 0;
if (BitCount == 16) {
RedMask = 0x0000F800;
GreenMask = 0x000007E0;
BlueMask = 0x0000001F;
AlphaMask = 0x00000000;
} else if (BitCount == 24) {
RedMask = 0x00FF0000;
GreenMask = 0x0000FF00;
BlueMask = 0x000000FF;
} else {
// Other color formats are not valid
Result = false;
}
if (Result) {
if (GetBits(NULL, bh.SizeImage, RedMask, GreenMask, BlueMask, AlphaMask)) {
uint8_t* Bitmap = new uint8_t[bh.SizeImage];
if (GetBits(Bitmap, bh.SizeImage, RedMask, GreenMask, BlueMask, AlphaMask)) {
file.write((char*) &bfh, sizeof(BITMAP_FILEHEADER));
file.write((char*) &bh, sizeof(BITMAP_HEADER));
file.write((char*) Bitmap, bh.SizeImage);
}
delete [] Bitmap;
}
}
}
file.close();
return Result;
}
unsigned int GetWidth() {
/* Add plausibility test */
// if (abs(m_BitmapHeader.Width) > 8192) {
// m_BitmapHeader.Width = 8192;
// }
return m_BitmapHeader.Width < 0 ? -m_BitmapHeader.Width : m_BitmapHeader.Width;
}
unsigned int GetHeight() {
/* Add plausibility test */
// if (abs(m_BitmapHeader.Height) > 8192) {
// m_BitmapHeader.Height = 8192;
// }
return m_BitmapHeader.Height < 0 ? -m_BitmapHeader.Height : m_BitmapHeader.Height;
}
unsigned int GetBitCount() {
/* Add plausibility test */
// if (m_BitmapHeader.BitCount > 32) {
// m_BitmapHeader.BitCount = 32;
// }
return m_BitmapHeader.BitCount;
}
/* Copies internal RGBA buffer to user specified buffer */
bool GetBits(void* Buffer, unsigned int &Size) {
bool Result = false;
if (Size == 0 || Buffer == 0) {
Size = m_BitmapSize * sizeof(RGBA);
Result = m_BitmapSize != 0;
} else {
memcpy(Buffer, m_BitmapData, Size);
Result = true;
}
return Result;
}
/* Returns internal RGBA buffer */
void* GetBits() {
return m_BitmapData;
}
/* Copies internal RGBA buffer to user specified buffer and converts it into destination
* bit format specified by component masks.
*
* Typical Bitmap color formats (BGR/BGRA):
*
* Masks for 16 bit (5-5-5): ALPHA = 0x00000000, RED = 0x00007C00, GREEN = 0x000003E0, BLUE = 0x0000001F
* Masks for 16 bit (5-6-5): ALPHA = 0x00000000, RED = 0x0000F800, GREEN = 0x000007E0, BLUE = 0x0000001F
* Masks for 24 bit: ALPHA = 0x00000000, RED = 0x00FF0000, GREEN = 0x0000FF00, BLUE = 0x000000FF
* Masks for 32 bit: ALPHA = 0xFF000000, RED = 0x00FF0000, GREEN = 0x0000FF00, BLUE = 0x000000FF
*
* Other color formats (RGB/RGBA):
*
* Masks for 32 bit (RGBA): ALPHA = 0xFF000000, RED = 0x000000FF, GREEN = 0x0000FF00, BLUE = 0x00FF0000
*
* Bit count will be rounded to next 8 bit boundary. If IncludePadding is true, it will be ensured
* that line width is a multiple of 4. padding bytes are included if necessary.
*
* NOTE: systems with big endian byte order may require masks in inversion order.
*/
bool GetBits(void* Buffer, unsigned int &Size, unsigned int RedMask, unsigned int GreenMask, unsigned int BlueMask, unsigned int AlphaMask, bool IncludePadding = true) {
bool Result = false;
uint32_t BitCountRed = CColor::BitCountByMask(RedMask);
uint32_t BitCountGreen = CColor::BitCountByMask(GreenMask);
uint32_t BitCountBlue = CColor::BitCountByMask(BlueMask);
uint32_t BitCountAlpha = CColor::BitCountByMask(AlphaMask);
unsigned int BitCount = (BitCountRed + BitCountGreen + BitCountBlue + BitCountAlpha + 7) & ~7;
if (BitCount > 32) {
return false;
}
unsigned int w = GetWidth();
//unsigned int LineWidth = (w + 3) & ~3;
unsigned int dataBytesPerLine = (w * BitCount + 7) / 8;
unsigned int LineWidth = (dataBytesPerLine + 3) & ~3;
if (Size == 0 || Buffer == 0) {
//Size = (LineWidth * GetHeight() * BitCount) / 8 + sizeof(unsigned int);
Size = (GetWidth() * GetHeight() * BitCount) / 8 + sizeof(unsigned int);
return true;
}
uint8_t* BufferPtr = (uint8_t*) Buffer;
Result = true;
uint32_t BitPosRed = CColor::BitPositionByMask(RedMask);
uint32_t BitPosGreen = CColor::BitPositionByMask(GreenMask);
uint32_t BitPosBlue = CColor::BitPositionByMask(BlueMask);
uint32_t BitPosAlpha = CColor::BitPositionByMask(AlphaMask);
unsigned int j = 0;
for (unsigned int i = 0; i < m_BitmapSize; i++) {
*(uint32_t*) BufferPtr =
(CColor::Convert(m_BitmapData[i].Blue, 8, BitCountBlue) << BitPosBlue) |
(CColor::Convert(m_BitmapData[i].Green, 8, BitCountGreen) << BitPosGreen) |
(CColor::Convert(m_BitmapData[i].Red, 8, BitCountRed) << BitPosRed) |
(CColor::Convert(m_BitmapData[i].Alpha, 8, BitCountAlpha) << BitPosAlpha);
if (IncludePadding) {
j++;
if (j >= w) {
for (unsigned int k = 0; k < LineWidth - dataBytesPerLine; k++) {
BufferPtr += (BitCount >> 3);
}
j = 0;
}
}
BufferPtr += (BitCount >> 3);
}
Size -= sizeof(unsigned int);
return Result;
}
/* See GetBits().
* It creates a corresponding color table (palette) which have to be destroyed by the user after usage.
*
* Supported Bit depths are: 4, 8
*
* Todo: Optimize, use optimized palette, do ditehring (see my dithering class), support padding for 4 bit bitmaps
*/
bool GetBitsWithPalette(void* Buffer, unsigned int &Size, unsigned int BitCount, BGRA* &Palette, unsigned int &PaletteSize, bool OptimalPalette = false, bool IncludePadding = true) {
bool Result = false;
if (BitCount > 16) {
return false;
}
unsigned int w = GetWidth();
unsigned int dataBytesPerLine = (w * BitCount + 7) / 8;
unsigned int LineWidth = (dataBytesPerLine + 3) & ~3;
if (Size == 0 || Buffer == 0) {
Size = (LineWidth * GetHeight() * BitCount) / 8;
return true;
}
if (OptimalPalette) {
PaletteSize = 0;
// Not implemented
} else {
if (BitCount == 1) {
PaletteSize = 2;
// Not implemented: Who need that?
} else if (BitCount == 4) { // 2:2:1
PaletteSize = 16;
Palette = new BGRA[PaletteSize];
for (int r = 0; r < 4; r++) {
for (int g = 0; g < 2; g++) {
for (int b = 0; b < 2; b++) {
Palette[r | g << 2 | b << 3].Red = r ? (r << 6) | 0x3f : 0;
Palette[r | g << 2 | b << 3].Green = g ? (g << 7) | 0x7f : 0;
Palette[r | g << 2 | b << 3].Blue = b ? (b << 7) | 0x7f : 0;
Palette[r | g << 2 | b << 3].Alpha = 0xff;
}
}
}
} else if (BitCount == 8) { // 3:3:2
PaletteSize = 256;
Palette = new BGRA[PaletteSize];
for (int r = 0; r < 8; r++) {
for (int g = 0; g < 8; g++) {
for (int b = 0; b < 4; b++) {
Palette[r | g << 3 | b << 6].Red = r ? (r << 5) | 0x1f : 0;
Palette[r | g << 3 | b << 6].Green = g ? (g << 5) | 0x1f : 0;
Palette[r | g << 3 | b << 6].Blue = b ? (b << 6) | 0x3f : 0;
Palette[r | g << 3 | b << 6].Alpha = 0xff;
}
}
}
} else if (BitCount == 16) { // 5:5:5
// Not implemented
}
}
unsigned int j = 0;
uint8_t* BufferPtr = (uint8_t*) Buffer;
for (unsigned int i = 0; i < m_BitmapSize; i++) {
if (BitCount == 1) {
// Not implemented: Who needs that?
} else if (BitCount == 4) {
*BufferPtr = ((m_BitmapData[i].Red >> 6) | (m_BitmapData[i].Green >> 7) << 2 | (m_BitmapData[i].Blue >> 7) << 3) << 4;
i++;
*BufferPtr |= (m_BitmapData[i].Red >> 6) | (m_BitmapData[i].Green >> 7) << 2 | (m_BitmapData[i].Blue >> 7) << 3;
} else if (BitCount == 8) {
*BufferPtr = (m_BitmapData[i].Red >> 5) | (m_BitmapData[i].Green >> 5) << 3 | (m_BitmapData[i].Blue >> 5) << 6;
} else if (BitCount == 16) {
// Not implemented
}
if (IncludePadding) {
j++;
if (j >= w) {
for (unsigned int k = 0; k < (LineWidth - dataBytesPerLine); k++) {
BufferPtr += BitCount / 8;
}
j = 0;
}
}
BufferPtr++;
}
Result = true;
return Result;
}
/* Set Bitmap Bits. Will be converted to RGBA internally */
bool SetBits(void* Buffer, unsigned int Width, unsigned int Height, unsigned int RedMask, unsigned int GreenMask, unsigned int BlueMask, unsigned int AlphaMask = 0) {
if (Buffer == 0) {
return false;
}
uint8_t *BufferPtr = (uint8_t*) Buffer;
Dispose();
m_BitmapHeader.Width = Width;
m_BitmapHeader.Height = Height;
m_BitmapHeader.BitCount = 32;
m_BitmapHeader.Compression = 3;
m_BitmapSize = GetWidth() * GetHeight();
m_BitmapData = new RGBA[m_BitmapSize];
/* Find bit count by masks (rounded to next 8 bit boundary) */
unsigned int BitCount = (CColor::BitCountByMask(RedMask | GreenMask | BlueMask | AlphaMask) + 7) & ~7;
uint32_t BitCountRed = CColor::BitCountByMask(RedMask);
uint32_t BitCountGreen = CColor::BitCountByMask(GreenMask);
uint32_t BitCountBlue = CColor::BitCountByMask(BlueMask);
uint32_t BitCountAlpha = CColor::BitCountByMask(AlphaMask);
for (unsigned int i = 0; i < m_BitmapSize; i++) {
unsigned int Color = 0;
if (BitCount <= 8) {
Color = *((uint8_t*) BufferPtr);
BufferPtr += 1;
} else if (BitCount <= 16) {
Color = *((uint16_t*) BufferPtr);
BufferPtr += 2;
} else if (BitCount <= 24) {
Color = *((uint32_t*) BufferPtr);
BufferPtr += 3;
} else if (BitCount <= 32) {
Color = *((uint32_t*) BufferPtr);
BufferPtr += 4;
} else {
/* unsupported */
BufferPtr += 1;
}
m_BitmapData[i].Alpha = CColor::Convert(CColor::ComponentByMask(Color, AlphaMask), BitCountAlpha, 8);
m_BitmapData[i].Red = CColor::Convert(CColor::ComponentByMask(Color, RedMask), BitCountRed, 8);
m_BitmapData[i].Green = CColor::Convert(CColor::ComponentByMask(Color, GreenMask), BitCountGreen, 8);
m_BitmapData[i].Blue = CColor::Convert(CColor::ComponentByMask(Color, BlueMask), BitCountBlue, 8);
}
return true;
}
};
////////////////////////////////////////////////////////////////////////////
//
// Fonction pour charger une texture
//
////////////////////////////////////////////////////////////////////////////
#include <string.h>
#include <stdio.h>
//#include <SDL_surface.h>
unsigned char *ChargerImage( std::string fichier, GLsizei &largeur, GLsizei &hauteur )
{
// vérifier la présence du fichier BMP en essayant de l'ouvrir
FILE *img = fopen( fichier.c_str(), "r" );
if ( !img )
{
std::cerr << "Fichier de texture manquant: " << fichier << std::endl;
return NULL;
}
fclose( img );
// lire le fichier dans un objet CBitmap
CBitmap image( fichier.c_str() );
// obtenir la taille de l'image et les composantes RGBA
largeur = image.GetWidth();
hauteur = image.GetHeight();
unsigned int taille = largeur * hauteur * 4; // l * h * 4 composantes
unsigned char *pixels = new unsigned char[taille];
image.GetBits( (void*) pixels, taille, 0x000000FF, 0x0000FF00, 0x00FF0000, 0xFF000000 );
//SDL_Surface* surface = SDL_LoadBMP( fichier.c_str() );
// https://wiki.libsdl.org/SDL_LoadBMP
// largeur = surface->w;
// hauteur = surface->h;
// pixels = surface->pixels;
return pixels;
}
#endif
#ifndef INF2705_FORME_H
#define INF2705_FORME_H
////////////////////////////////////////////////////////////////////////////
//
// Fonctions variées pour afficher des formes connues
// (INF2705, Benoît Ozell)
////////////////////////////////////////////////////////////////////////////
#include <GL/glew.h>
#include <iostream>
#if !defined( __APPLE__ )
/* Copyright (c) Mark J. Kilgard, 1994, 1997. */
/**
(c) Copyright 1993, Silicon Graphics, Inc.
ALL RIGHTS RESERVED
Permission to use, copy, modify, and distribute this software
for any purpose and without fee is hereby granted, provided
that the above copyright notice appear in all copies and that
both the copyright notice and this permission notice appear in
supporting documentation, and that the name of Silicon
Graphics, Inc. not be used in advertising or publicity
pertaining to distribution of the software without specific,
written prior permission.
THE MATERIAL EMBODIED ON THIS SOFTWARE IS PROVIDED TO YOU
"AS-IS" AND WITHOUT WARRANTY OF ANY KIND, EXPRESS, IMPLIED OR
OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF
MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. IN NO
EVENT SHALL SILICON GRAPHICS, INC. BE LIABLE TO YOU OR ANYONE
ELSE FOR ANY DIRECT, SPECIAL, INCIDENTAL, INDIRECT OR
CONSEQUENTIAL DAMAGES OF ANY KIND, OR ANY DAMAGES WHATSOEVER,
INCLUDING WITHOUT LIMITATION, LOSS OF PROFIT, LOSS OF USE,
SAVINGS OR REVENUE, OR THE CLAIMS OF THIRD PARTIES, WHETHER OR
NOT SILICON GRAPHICS, INC. HAS BEEN ADVISED OF THE POSSIBILITY
OF SUCH LOSS, HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
ARISING OUT OF OR IN CONNECTION WITH THE POSSESSION, USE OR
PERFORMANCE OF THIS SOFTWARE.
US Government Users Restricted Rights
Use, duplication, or disclosure by the Government is subject to
restrictions set forth in FAR 52.227.19(c)(2) or subparagraph
(c)(1)(ii) of the Rights in Technical Data and Computer
Software clause at DFARS 252.227-7013 and/or in similar or
successor clauses in the FAR or the DOD or NASA FAR
Supplement. Unpublished-- rights reserved under the copyright
laws of the United States. Contractor/manufacturer is Silicon
Graphics, Inc., 2011 N. Shoreline Blvd., Mountain View, CA
94039-7311.
OpenGL(TM) is a trademark of Silicon Graphics, Inc.
*/
#include <math.h>
#include <stdio.h>
static GLfloat dodec[20][3];
static void initDodecahedron(void)
{
GLfloat alpha, beta;
alpha = sqrt(2.0 / (3.0 + sqrt(5.0)));
beta = 1.0 + sqrt(6.0 / (3.0 + sqrt(5.0)) - 2.0 + 2.0 * sqrt(2.0 / (3.0 + sqrt(5.0))));
dodec[0][0] = -alpha; dodec[0][1] = 0; dodec[0][2] = beta;
dodec[1][0] = alpha; dodec[1][1] = 0; dodec[1][2] = beta;
dodec[2][0] = -1; dodec[2][1] = -1; dodec[2][2] = -1;
dodec[3][0] = -1; dodec[3][1] = -1; dodec[3][2] = 1;
dodec[4][0] = -1; dodec[4][1] = 1; dodec[4][2] = -1;
dodec[5][0] = -1; dodec[5][1] = 1; dodec[5][2] = 1;
dodec[6][0] = 1; dodec[6][1] = -1; dodec[6][2] = -1;
dodec[7][0] = 1; dodec[7][1] = -1; dodec[7][2] = 1;
dodec[8][0] = 1; dodec[8][1] = 1; dodec[8][2] = -1;
dodec[9][0] = 1; dodec[9][1] = 1; dodec[9][2] = 1;
dodec[10][0] = beta; dodec[10][1] = alpha; dodec[10][2] = 0;
dodec[11][0] = beta; dodec[11][1] = -alpha; dodec[11][2] = 0;
dodec[12][0] = -beta; dodec[12][1] = alpha; dodec[12][2] = 0;
dodec[13][0] = -beta; dodec[13][1] = -alpha; dodec[13][2] = 0;
dodec[14][0] = -alpha; dodec[14][1] = 0; dodec[14][2] = -beta;
dodec[15][0] = alpha; dodec[15][1] = 0; dodec[15][2] = -beta;
dodec[16][0] = 0; dodec[16][1] = beta; dodec[16][2] = alpha;
dodec[17][0] = 0; dodec[17][1] = beta; dodec[17][2] = -alpha;
dodec[18][0] = 0; dodec[18][1] = -beta; dodec[18][2] = alpha;
dodec[19][0] = 0; dodec[19][1] = -beta; dodec[19][2] = -alpha;
}
#define DIFF3(_a,_b,_c) { \
(_c)[0] = (_a)[0] - (_b)[0]; \
(_c)[1] = (_a)[1] - (_b)[1]; \
(_c)[2] = (_a)[2] - (_b)[2]; \
}
static void crossprod(GLfloat v1[3], GLfloat v2[3], GLfloat prod[3])
{
GLfloat p[3]; /* in case prod == v1 or v2 */
p[0] = v1[1] * v2[2] - v2[1] * v1[2];
p[1] = v1[2] * v2[0] - v2[2] * v1[0];
p[2] = v1[0] * v2[1] - v2[0] * v1[1];
prod[0] = p[0];
prod[1] = p[1];
prod[2] = p[2];
}
static void normalize(GLfloat v[3])
{
GLfloat d;
d = sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
if (d == 0.0)
{
printf("normalize: zero length vector");
v[0] = d = 1.0;
}
d = 1 / d;
v[0] *= d;
v[1] *= d;
v[2] *= d;
}
static void pentagon(int a, int b, int c, int d, int e, GLenum shadeType)
{
GLfloat n0[3], d1[3], d2[3];
DIFF3(dodec[a], dodec[b], d1);
DIFF3(dodec[b], dodec[c], d2);
crossprod(d1, d2, n0);
normalize(n0);
glBegin(shadeType);
glNormal3fv(n0);
glVertex3fv(&dodec[a][0]);
glVertex3fv(&dodec[b][0]);
glVertex3fv(&dodec[c][0]);
glVertex3fv(&dodec[d][0]);
glVertex3fv(&dodec[e][0]);
glEnd();
}
static void dodecahedron(GLenum type)
{
static int inited = 0;
if (inited == 0)
{
inited = 1;
initDodecahedron();
}
pentagon(0, 1, 9, 16, 5, type);
pentagon(1, 0, 3, 18, 7, type);
pentagon(1, 7, 11, 10, 9, type);
pentagon(11, 7, 18, 19, 6, type);
pentagon(8, 17, 16, 9, 10, type);
pentagon(2, 14, 15, 6, 19, type);
pentagon(2, 13, 12, 4, 14, type);
pentagon(2, 19, 18, 3, 13, type);
pentagon(3, 0, 5, 12, 13, type);
pentagon(6, 15, 8, 10, 11, type);
pentagon(4, 17, 8, 15, 14, type);
pentagon(4, 12, 5, 16, 17, type);
}
void shapesWireDodecahedron(void)
{
dodecahedron(GL_LINE_LOOP);
}
void shapesSolidDodecahedron(void)
{
dodecahedron(GL_TRIANGLE_FAN);
}
static void recorditem(GLfloat * n1, GLfloat * n2, GLfloat * n3,
GLenum shadeType)
{
GLfloat q0[3], q1[3];
DIFF3(n1, n2, q0);
DIFF3(n2, n3, q1);
crossprod(q0, q1, q1);
normalize(q1);
glBegin(shadeType);
glNormal3fv(q1);
glVertex3fv(n1);
glVertex3fv(n2);
glVertex3fv(n3);
glEnd();
}
static void subdivide(GLfloat * v0, GLfloat * v1, GLfloat * v2,
GLenum shadeType)
{
int depth = 1;
for (int i = 0; i < depth; i++)
{
for (int j = 0; i + j < depth; j++)
{
GLfloat w0[3], w1[3], w2[3];
int k = depth - i - j;
for (int n = 0; n < 3; n++)
{
w0[n] = (i * v0[n] + j * v1[n] + k * v2[n]) / depth;
w1[n] = ((i + 1) * v0[n] + j * v1[n] + (k - 1) * v2[n]) / depth;
w2[n] = (i * v0[n] + (j + 1) * v1[n] + (k - 1) * v2[n]) / depth;
}
GLfloat l;
l = sqrt(w0[0] * w0[0] + w0[1] * w0[1] + w0[2] * w0[2]);
w0[0] /= l;
w0[1] /= l;
w0[2] /= l;
l = sqrt(w1[0] * w1[0] + w1[1] * w1[1] + w1[2] * w1[2]);
w1[0] /= l;
w1[1] /= l;
w1[2] /= l;
l = sqrt(w2[0] * w2[0] + w2[1] * w2[1] + w2[2] * w2[2]);
w2[0] /= l;
w2[1] /= l;
w2[2] /= l;
recorditem(w1, w0, w2, shadeType);
}
}
}
static void drawtriangle(int i, GLfloat data[][3], int ndx[][3],
GLenum shadeType)
{
GLfloat *x0 = data[ndx[i][0]];
GLfloat *x1 = data[ndx[i][1]];
GLfloat *x2 = data[ndx[i][2]];
subdivide(x0, x1, x2, shadeType);
}
/* octahedron data: The octahedron produced is centered at the
origin and has radius 1.0 */
static GLfloat odata[6][3] =
{
{1.0, 0.0, 0.0},
{-1.0, 0.0, 0.0},
{0.0, 1.0, 0.0},
{0.0, -1.0, 0.0},
{0.0, 0.0, 1.0},
{0.0, 0.0, -1.0}
};
static int ondex[8][3] =
{
{0, 4, 2},
{1, 2, 4},
{0, 3, 4},
{1, 4, 3},
{0, 2, 5},
{1, 5, 2},
{0, 5, 3},
{1, 3, 5}
};
static void octahedron(GLenum shadeType)
{
for (int i = 7; i >= 0; i--)
{
drawtriangle(i, odata, ondex, shadeType);
}
}
void shapesWireOctahedron(void)
{
octahedron(GL_LINE_LOOP);
}
void shapesSolidOctahedron(void)
{
octahedron(GL_TRIANGLES);
}
/* icosahedron data: These numbers are rigged to make an
icosahedron of radius 1.0 */
#define X .525731112119133606
#define Z .850650808352039932
static GLfloat idata[12][3] =
{
{-X, 0, Z},
{X, 0, Z},
{-X, 0, -Z},
{X, 0, -Z},
{0, Z, X},
{0, Z, -X},
{0, -Z, X},
{0, -Z, -X},
{Z, X, 0},
{-Z, X, 0},
{Z, -X, 0},
{-Z, -X, 0}
};
#undef X
#undef Z
static int connectivity[20][3] =
{
{0, 4, 1},
{0, 9, 4},
{9, 5, 4},
{4, 5, 8},
{4, 8, 1},
{8, 10, 1},
{8, 3, 10},
{5, 3, 8},
{5, 2, 3},
{2, 7, 3},
{7, 10, 3},
{7, 6, 10},
{7, 11, 6},
{11, 0, 6},
{0, 1, 6},
{6, 1, 10},
{9, 0, 11},
{9, 11, 2},
{9, 2, 5},
{7, 2, 11},
};
static void icosahedron(GLenum shadeType)
{
for (int i = 19; i >= 0; i--)
{
drawtriangle(i, idata, connectivity, shadeType);
}
}
void shapesWireIcosahedron(void)
{
icosahedron(GL_LINE_LOOP);
}
void shapesSolidIcosahedron(void)
{
icosahedron(GL_TRIANGLES);
}
/* tetrahedron data: */
#define T 1.73205080756887729
static GLfloat tdata[4][3] =
{
{T, T, T},
{T, -T, -T},
{-T, T, -T},
{-T, -T, T}
};
#undef T
static int tndex[4][3] =
{
{0, 1, 3},
{2, 1, 0},
{3, 2, 0},
{1, 2, 3}
};
static void tetrahedron(GLenum shadeType)
{
for (int i = 3; i >= 0; i--)
drawtriangle(i, tdata, tndex, shadeType);
}
void shapesWireTetrahedron(void)
{
tetrahedron(GL_LINE_LOOP);
}
void shapesSolidTetrahedron(void)
{
tetrahedron(GL_TRIANGLES);
}
/* Rim, body, lid, and bottom data must be reflected in x and
y; handle and spout data across the y axis only. */
static int patchdata[][16] =
{
/* rim */
{102, 103, 104, 105, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
/* body */
{12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27},
{24, 25, 26, 27, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40},
/* lid */
{96, 96, 96, 96, 97, 98, 99, 100, 101, 101, 101, 101, 0, 1, 2, 3,},
{0, 1, 2, 3, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117},
/* bottom */
{118, 118, 118, 118, 124, 122, 119, 121, 123, 126, 125, 120, 40, 39, 38, 37},
/* handle */
{41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56},
{53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 28, 65, 66, 67},
/* spout */
{68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83},
{80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95}
};
static float cpdata[][3] =
{
{0.2,0,2.7}, {0.2,-0.112,2.7}, {0.112,-0.2,2.7}, {0,-0.2,2.7},
{1.3375,0,2.53125}, {1.3375,-0.749,2.53125}, {0.749,-1.3375,2.53125},
{0,-1.3375,2.53125}, {1.4375,0,2.53125}, {1.4375,-0.805, 2.53125},
{0.805,-1.4375,2.53125}, {0,-1.4375,2.53125}, {1.5,0,2.4}, {1.5,-0.84,2.4},
{0.84,-1.5,2.4}, {0,-1.5,2.4}, {1.75,0, 1.875}, {1.75,-0.98,1.875},
{0.98,-1.75,1.875}, {0,-1.75,1.875}, {2,0,1.35}, {2,-1.12,1.35},
{1.12,-2,1.35}, {0,-2,1.35}, {2,0,0.9}, {2,-1.12,0.9}, {1.12,-2,0.9},
{0,-2,0.9}, {-2,0,0.9}, {2, 0,0.45}, {2,-1.12,0.45}, {1.12,-2,0.45},
{0,-2,0.45}, {1.5,0,0.225}, {1.5,-0.84,0.225}, {0.84,-1.5,0.225},
{0,-1.5,0.225}, {1.5, 0,0.15}, {1.5,-0.84,0.15}, {0.84,-1.5,0.15},
{0,-1.5,0.15}, {-1.6,0,2.025}, {-1.6,-0.3,2.025}, {-1.5,-0.3,2.25},
{-1.5,0,2.25}, {-2.3,0,2.025}, {-2.3,-0.3,2.025}, {-2.5,-0.3,2.25},
{-2.5,0,2.25}, {-2.7,0,2.025}, {-2.7,-0.3,2.025}, {-3,-0.3,2.25},
{-3,0,2.25}, {-2.7,0,1.8}, {-2.7,-0.3,1.8}, {-3,-0.3,1.8}, {-3,0,1.8},
{-2.7,0,1.575}, {-2.7,-0.3,1.575}, {-3,-0.3,1.35}, {-3,0,1.35},
{-2.5,0,1.125}, {-2.5,-0.3,1.125}, {-2.65,-0.3,0.9375}, {-2.65,0, 0.9375},
{-2,-0.3,0.9}, {-1.9,-0.3,0.6}, {-1.9,0,0.6}, {1.7,0, 1.425},
{1.7,-0.66,1.425}, {1.7,-0.66,0.6}, {1.7,0,0.6}, {2.6,0, 1.425},
{2.6,-0.66,1.425}, {3.1,-0.66,0.825}, {3.1,0,0.825}, {2.3, 0,2.1},
{2.3,-0.25,2.1}, {2.4,-0.25,2.025}, {2.4,0,2.025}, {2.7, 0,2.4},
{2.7,-0.25,2.4}, {3.3,-0.25,2.4}, {3.3,0,2.4}, {2.8,0, 2.475},
{2.8,-0.25,2.475}, {3.525,-0.25,2.49375}, {3.525,0, 2.49375}, {2.9,0,2.475},
{2.9,-0.15,2.475}, {3.45,-0.15,2.5125}, {3.45,0,2.5125}, {2.8,0,2.4},
{2.8,-0.15,2.4}, {3.2,-0.15,2.4}, {3.2,0,2.4}, {0,0,3.15}, {0.8,0,3.15},
{0.8,-0.45,3.15}, {0.45, -0.8,3.15}, {0,-0.8,3.15}, {0,0,2.85}, {1.4,0,2.4},
{1.4,-0.784, 2.4}, {0.784,-1.4,2.4}, {0,-1.4,2.4}, {0.4,0,2.55},
{0.4,-0.224, 2.55}, {0.224,-0.4,2.55}, {0,-0.4,2.55}, {1.3,0,2.55},
{1.3,-0.728,2.55}, {0.728,-1.3,2.55}, {0,-1.3,2.55}, {1.3,0,2.4},
{1.3,-0.728,2.4}, {0.728,-1.3,2.4}, {0,-1.3,2.4}, {0,0,0}, {1.425,-0.798,0},
{1.5,0,0.075}, {1.425,0,0}, {0.798,-1.425,0}, {0,-1.5, 0.075}, {0,-1.425,0},
{1.5,-0.84,0.075}, {0.84,-1.5,0.075}
};
static float tex[2][2][2] =
{
{ {0, 0},
{1, 0}},
{ {0, 1},
{1, 1}}
};
static void teapot(GLint grid, GLenum type)
{
float p[4][4][3], q[4][4][3], r[4][4][3], s[4][4][3];
glPushAttrib(GL_ENABLE_BIT | GL_EVAL_BIT);
glEnable(GL_AUTO_NORMAL);
glEnable(GL_MAP2_VERTEX_3);
glEnable(GL_MAP2_TEXTURE_COORD_2);
for (int i = 0; i < 10; i++)
{
for (int j = 0; j < 4; j++)
{
for (int k = 0; k < 4; k++)
{
for (int l = 0; l < 3; l++)
{
p[j][k][l] = cpdata[patchdata[i][j * 4 + k]][l];
q[j][k][l] = cpdata[patchdata[i][j * 4 + (3 - k)]][l];
if (l == 1) q[j][k][l] *= -1.0;
if (i < 6)
{
r[j][k][l] = cpdata[patchdata[i][j * 4 + (3 - k)]][l];
if (l == 0) r[j][k][l] *= -1.0;
s[j][k][l] = cpdata[patchdata[i][j * 4 + k]][l];
if (l == 0) s[j][k][l] *= -1.0;
if (l == 1) s[j][k][l] *= -1.0;
}
}
}
}
glMap2f(GL_MAP2_TEXTURE_COORD_2, 0, 1, 2, 2, 0, 1, 4, 2, &tex[0][0][0]);
glMap2f(GL_MAP2_VERTEX_3, 0, 1, 3, 4, 0, 1, 12, 4, &p[0][0][0]);
glMapGrid2f(grid, 0.0, 1.0, grid, 0.0, 1.0);
glEvalMesh2(type, 0, grid, 0, grid);
glMap2f(GL_MAP2_VERTEX_3, 0, 1, 3, 4, 0, 1, 12, 4, &q[0][0][0]);
glEvalMesh2(type, 0, grid, 0, grid);
if (i < 6)
{
glMap2f(GL_MAP2_VERTEX_3, 0, 1, 3, 4, 0, 1, 12, 4, &r[0][0][0]);
glEvalMesh2(type, 0, grid, 0, grid);
glMap2f(GL_MAP2_VERTEX_3, 0, 1, 3, 4, 0, 1, 12, 4, &s[0][0][0]);
glEvalMesh2(type, 0, grid, 0, grid);
}
}
glPopAttrib();
}
void shapesSolidTeapot()
{
teapot(14, GL_FILL);
}
void shapesWireTeapot()
{
teapot(10, GL_LINE);
}
#endif
//////////////////////////////////////////////////////////
class FormeBase2705
{
public:
FormeBase2705( bool plein = true )
: plein_(plein),
vao(0), locVertex(-1), locNormal(-1), locTexCoord(-1)
{
glGenVertexArrays( 1, &vao );
}
~FormeBase2705()
{
glDeleteVertexArrays( 1, &vao );
}
protected:
bool obtenirAttributs( )
{
GLint prog = 0; glGetIntegerv( GL_CURRENT_PROGRAM, &prog );
if ( prog <= 0 )
{
std::cerr << "Pas de programme actif!" << std::endl;
return(false);
}
locVertex = glGetAttribLocation( prog, "Vertex" );
if ( locVertex == -1 )
{
std::cerr << "Pas de nuanceur de sommets!" << std::endl;
return(false);
}
locNormal = glGetAttribLocation( prog, "Normal" );
locTexCoord = glGetAttribLocation( prog, "TexCoord" );
if ( locTexCoord < 0 ) locTexCoord = glGetAttribLocation( prog, "TexCoord0" );
if ( locTexCoord < 0 ) locTexCoord = glGetAttribLocation( prog, "MultiTexCoord0" );
return(true);
}
bool plein_;
GLuint vao;
GLint locVertex, locNormal, locTexCoord;
};
//////////
#define AJOUTE(X,Y,Z,NX,NY,NZ,S,T) \
{ \
if ( locTexCoord >= 0 ) \
{ texcoord[2*nsommets+0] = (S); texcoord[2*nsommets+1] = (T); } \
if ( locNormal >= 0 ) \
{ normales[3*nsommets+0] = (NX); normales[3*nsommets+1] = (NY); normales[3*nsommets+2] = (NZ); } \
{ sommets[3*nsommets+0] = (X); sommets[3*nsommets+1] = (Y); sommets[3*nsommets+2] = (Z); ++nsommets; } \
}
class FormeCube : public FormeBase2705
{
public:
FormeCube( GLfloat taille = 1.0,
bool plein = true )
: FormeBase2705( plein )
{
/* +Y */
/* 3+-----------+2 */
/* |\ |\ */
/* | \ | \ */
/* | \ | \ */
/* | 7+-----------+6 */
/* | | | | */
/* | | | | */
/* 0+---|-------+1 | */
/* \ | \ | +X */
/* \ | \ | */
/* \| \| */
/* 4+-----------+5 */
/* +Z */
static GLint faces[6][4] =
{
{ 3, 2, 1, 0 },
{ 5, 4, 0, 1 },
{ 6, 5, 1, 2 },
{ 7, 6, 2, 3 },
{ 4, 7, 3, 0 },
{ 4, 5, 6, 7 }
};
static GLfloat n[6][3] =
{
{ 0.0, 0.0, -1.0 },
{ 0.0, -1.0, 0.0 },
{ 1.0, 0.0, 0.0 },
{ 0.0, 1.0, 0.0 },
{ -1.0, 0.0, 0.0 },
{ 0.0, 0.0, 1.0 }
};
GLfloat v[8][3];
v[4][0] = v[7][0] = v[3][0] = v[0][0] = -taille / 2.;
v[6][0] = v[5][0] = v[1][0] = v[2][0] = +taille / 2.;
v[5][1] = v[4][1] = v[0][1] = v[1][1] = -taille / 2.;
v[7][1] = v[6][1] = v[2][1] = v[3][1] = +taille / 2.;
v[3][2] = v[2][2] = v[1][2] = v[0][2] = -taille / 2.;
v[4][2] = v[5][2] = v[6][2] = v[7][2] = +taille / 2.;
GLfloat t[8][2];
t[4][0] = t[7][0] = t[3][0] = t[0][0] = 0.;
t[6][0] = t[5][0] = t[1][0] = t[2][0] = 1.;
t[5][1] = t[4][1] = t[0][1] = t[1][1] = 0.;
t[7][1] = t[6][1] = t[2][1] = t[3][1] = 1.;
if ( obtenirAttributs( ) )
{
// initialisation
const int TAILLEMAX = 6*6;
GLfloat sommets[3*TAILLEMAX], normales[3*TAILLEMAX], texcoord[2*TAILLEMAX];
int nsommets = 0;
if ( plein_ )
{
for ( int i = 0 ; i < 6 ; ++i )
{
AJOUTE( v[faces[i][0]][0], v[faces[i][0]][1], v[faces[i][0]][2], n[i][0], n[i][1], n[i][2], t[faces[i][0]][0], t[faces[i][0]][1] );
AJOUTE( v[faces[i][1]][0], v[faces[i][1]][1], v[faces[i][1]][2], n[i][0], n[i][1], n[i][2], t[faces[i][1]][0], t[faces[i][1]][1] );
AJOUTE( v[faces[i][2]][0], v[faces[i][2]][1], v[faces[i][2]][2], n[i][0], n[i][1], n[i][2], t[faces[i][2]][0], t[faces[i][2]][1] );
AJOUTE( v[faces[i][2]][0], v[faces[i][2]][1], v[faces[i][2]][2], n[i][0], n[i][1], n[i][2], t[faces[i][2]][0], t[faces[i][2]][1] );
AJOUTE( v[faces[i][3]][0], v[faces[i][3]][1], v[faces[i][3]][2], n[i][0], n[i][1], n[i][2], t[faces[i][3]][0], t[faces[i][3]][1] );
AJOUTE( v[faces[i][0]][0], v[faces[i][0]][1], v[faces[i][0]][2], n[i][0], n[i][1], n[i][2], t[faces[i][0]][0], t[faces[i][0]][1] );
}
}
else
{
for ( int i = 0 ; i < 6 ; ++i )
{
AJOUTE( v[faces[i][0]][0], v[faces[i][0]][1], v[faces[i][0]][2], n[i][0], n[i][1], n[i][2], t[faces[i][0]][0], t[faces[i][0]][1] );
AJOUTE( v[faces[i][1]][0], v[faces[i][1]][1], v[faces[i][1]][2], n[i][0], n[i][1], n[i][2], t[faces[i][1]][0], t[faces[i][1]][1] );
AJOUTE( v[faces[i][2]][0], v[faces[i][2]][1], v[faces[i][2]][2], n[i][0], n[i][1], n[i][2], t[faces[i][2]][0], t[faces[i][2]][1] );
AJOUTE( v[faces[i][3]][0], v[faces[i][3]][1], v[faces[i][3]][2], n[i][0], n[i][1], n[i][2], t[faces[i][3]][0], t[faces[i][3]][1] );
}
}
nsommets_ = nsommets;
// remplir VBOs
glBindVertexArray( vao );
glGenBuffers( 3, vbo );
glBindBuffer( GL_ARRAY_BUFFER, vbo[0] );
glBufferData( GL_ARRAY_BUFFER, 3*nsommets*sizeof(GLfloat), NULL, GL_STATIC_DRAW );
glBufferSubData( GL_ARRAY_BUFFER, 0, 3*nsommets*sizeof(GLfloat), sommets );
glVertexAttribPointer( locVertex, 3, GL_FLOAT, GL_FALSE, 0, 0 );
glEnableVertexAttribArray(locVertex);
if ( locNormal >= 0 )
{
glBindBuffer( GL_ARRAY_BUFFER, vbo[1] );
glBufferData( GL_ARRAY_BUFFER, 3*nsommets*sizeof(GLfloat), NULL, GL_STATIC_DRAW );
glBufferSubData( GL_ARRAY_BUFFER, 0, 3*nsommets*sizeof(GLfloat), normales );
glVertexAttribPointer( locNormal, 3, GL_FLOAT, GL_FALSE, 0, 0 );
glEnableVertexAttribArray(locNormal);
}
if ( locTexCoord >= 0 )
{
glBindBuffer( GL_ARRAY_BUFFER, vbo[2] );
glBufferData( GL_ARRAY_BUFFER, 2*nsommets*sizeof(GLfloat), NULL, GL_STATIC_DRAW );
glBufferSubData( GL_ARRAY_BUFFER, 0, 2*nsommets*sizeof(GLfloat), texcoord );
glVertexAttribPointer( locTexCoord, 2, GL_FLOAT, GL_FALSE, 0, 0 );
glEnableVertexAttribArray(locTexCoord);
}
glBindVertexArray( 0 );
}
}
~FormeCube()
{
glDeleteBuffers( 3, vbo );
}
void afficher()
{
glBindVertexArray( vao );
if ( plein_ )
glDrawArrays( GL_TRIANGLES, 0, nsommets_ );
else
for ( int i = 0 ; i < 6 ; ++i ) glDrawArrays( GL_LINE_LOOP, 4*i, 4 );
glBindVertexArray( 0 );
}
private:
GLint nsommets_;
GLuint vbo[3];
};
//////////
class FormeSphere : public FormeBase2705
{
public:
FormeSphere( GLdouble radius, GLint slices, GLint stacks,
bool plein = true, bool entiere = true )
: FormeBase2705( plein )
{
if ( obtenirAttributs( ) )
{
// initialisation
const int TAILLEMAX = 2*(slices+1)*(stacks+2);
GLfloat sommets[3*TAILLEMAX], normales[3*TAILLEMAX], texcoord[2*TAILLEMAX];
int nsommets = 0;
// variables locales
const GLfloat drho = M_PI / (GLfloat) stacks;
const GLfloat dtheta = 2.0 * M_PI / (GLfloat) slices;
GLint imin, imax;
if ( locTexCoord >= 0 ) { imin = 0; imax = stacks; } else { imin = 1; imax = stacks - 1; }
if ( !entiere ) imax = imax/2 + 1; // pour se rendre seulement à la moitié supérieure
/* texturing: s goes from 0.0/0.25/0.5/0.75/1.0 at +y/+x/-y/-x/+y axis */
/* t goes from -1.0/+1.0 at z = -radius/+radius (linear along longitudes) */
/* cannot use triangle fan on texturing (s coord. at top/bottom tip varies) */
nsommets = 0;
{
GLfloat t = 1.0;
GLfloat ds = 1.0 / slices;
GLfloat dt = 1.0 / stacks;
for ( GLint i = imin; i < imax; i++ )
{
GLfloat rho = i * drho;
GLfloat s = 0.0;
for ( GLint j = 0; j <= slices; j++ )
{
GLfloat x, y, z;
GLfloat theta = (j == slices) ? 0.0 : j * dtheta;
x = -sin(theta) * sin(rho);
y = cos(theta) * sin(rho);
z = cos(rho);
AJOUTE( x * radius, y * radius, z * radius, x, y, z, s, t );
x = -sin(theta) * sin(rho + drho);
y = cos(theta) * sin(rho + drho);
z = cos(rho + drho);
AJOUTE( x * radius, y * radius, z * radius, x, y, z, s, t-dt );
s += ds;
}
t -= dt;
}
}
nsommetsStrip_ = nsommets;
if ( !(locTexCoord >= 0) )
{
AJOUTE( 0.0, 0.0, radius, 0.0, 0.0, 1.0, 0, 0 );
for ( GLint j = 0; j <= slices; j++ )
{
GLfloat x, y, z;
GLfloat theta = (j == slices) ? 0.0 : j * dtheta;
x = -sin(theta) * sin(drho);
y = cos(theta) * sin(drho);
z = cos(drho);
AJOUTE( x * radius, y * radius, z * radius, x, y, z, 0, 0 );
}
}
nsommetsFan_ = nsommets - nsommetsStrip_;
if ( !(locTexCoord >= 0) && entiere )
{
AJOUTE( 0.0, 0.0, -radius, 0.0, 0.0, -1.0, 0, 0 );
GLfloat rho = M_PI - drho;
for ( GLint j = slices; j >= 0; j-- )
{
GLfloat x, y, z;
GLfloat theta = (j == slices) ? 0.0 : j * dtheta;
x = -sin(theta) * sin(rho);
y = cos(theta) * sin(rho);
z = cos(rho);
AJOUTE( x * radius, y * radius, z * radius, x, y, z, 0, 0 );
}
}
// remplir VBOs
glBindVertexArray( vao );
glGenBuffers( 3, vbo );
glBindBuffer( GL_ARRAY_BUFFER, vbo[0] );
glBufferData( GL_ARRAY_BUFFER, 3*nsommets*sizeof(GLfloat), NULL, GL_STATIC_DRAW );
glBufferSubData( GL_ARRAY_BUFFER, 0, 3*nsommets*sizeof(GLfloat), sommets );
glVertexAttribPointer( locVertex, 3, GL_FLOAT, GL_FALSE, 0, 0 );
glEnableVertexAttribArray(locVertex);
if ( locNormal >= 0 )
{
glBindBuffer( GL_ARRAY_BUFFER, vbo[1] );
glBufferData( GL_ARRAY_BUFFER, 3*nsommets*sizeof(GLfloat), NULL, GL_STATIC_DRAW );
glBufferSubData( GL_ARRAY_BUFFER, 0, 3*nsommets*sizeof(GLfloat), normales );
glVertexAttribPointer( locNormal, 3, GL_FLOAT, GL_FALSE, 0, 0 );
glEnableVertexAttribArray(locNormal);
}
if ( locTexCoord >= 0 )
{
glBindBuffer( GL_ARRAY_BUFFER, vbo[2] );
glBufferData( GL_ARRAY_BUFFER, 2*nsommets*sizeof(GLfloat), NULL, GL_STATIC_DRAW );
glBufferSubData( GL_ARRAY_BUFFER, 0, 2*nsommets*sizeof(GLfloat), texcoord );
glVertexAttribPointer( locTexCoord, 2, GL_FLOAT, GL_FALSE, 0, 0 );
glEnableVertexAttribArray(locTexCoord);
}
glBindVertexArray( 0 );
}
}
~FormeSphere()
{
glDeleteBuffers( 3, vbo );
}
void afficher()
{
glBindVertexArray( vao );
glDrawArrays( GL_TRIANGLE_STRIP, 0, nsommetsStrip_ );
if ( !(locTexCoord >= 0) )
{
glDrawArrays( GL_TRIANGLE_FAN, nsommetsStrip_, nsommetsFan_ );
glDrawArrays( GL_TRIANGLE_FAN, nsommetsStrip_+nsommetsFan_, nsommetsFan_ );
}
glBindVertexArray( 0 );
}
private:
GLint nsommetsStrip_, nsommetsFan_;
GLuint vbo[3];
};
//////////
class FormeTore : public FormeBase2705
{
public:
FormeTore( GLdouble innerRadius, GLdouble outerRadius, GLint nsides, GLint rings,
bool plein = true )
: FormeBase2705( plein )
{
if ( obtenirAttributs( ) )
{
// initialisation
const int TAILLEMAX = 2*(nsides+1)*(rings);
GLfloat sommets[3*TAILLEMAX], normales[3*TAILLEMAX], texcoord[2*TAILLEMAX];
int nsommets = 0;
// variables locales
const GLfloat ringDelta = 2.0 * M_PI / rings;
const GLfloat sideDelta = 2.0 * M_PI / nsides;
GLfloat theta = 0.0;
GLfloat cosTheta = 1.0;
GLfloat sinTheta = 0.0;
for ( int i = rings - 1; i >= 0; i-- )
{
GLfloat theta1 = theta + ringDelta;
GLfloat cosTheta1 = cos(theta1);
GLfloat sinTheta1 = sin(theta1);
GLfloat phi = 0.0;
for ( int j = nsides; j >= 0; j-- )
{
phi += sideDelta;
GLfloat cosPhi = cos(phi);
GLfloat sinPhi = sin(phi);
GLfloat dist = outerRadius + innerRadius * cosPhi;
AJOUTE( cosTheta1 * dist, -sinTheta1 * dist, innerRadius * sinPhi,
cosTheta1 * cosPhi, -sinTheta1 * cosPhi, sinPhi,
(4.0*(i+1))/rings, (4.0*j)/nsides );
AJOUTE( cosTheta * dist, -sinTheta * dist, innerRadius * sinPhi,
cosTheta * cosPhi, -sinTheta * cosPhi, sinPhi,
(4.0*i)/rings, (4.0*j)/nsides );
}
theta = theta1;
cosTheta = cosTheta1;
sinTheta = sinTheta1;
}
nsommets_ = nsommets;
// remplir VBOs
glBindVertexArray( vao );
glGenBuffers( 3, vbo );
glBindBuffer( GL_ARRAY_BUFFER, vbo[0] );
glBufferData( GL_ARRAY_BUFFER, 3*nsommets*sizeof(GLfloat), NULL, GL_STATIC_DRAW );
glBufferSubData( GL_ARRAY_BUFFER, 0, 3*nsommets*sizeof(GLfloat), sommets );
glVertexAttribPointer( locVertex, 3, GL_FLOAT, GL_FALSE, 0, 0 );
glEnableVertexAttribArray(locVertex);
if ( locNormal >= 0 )
{
glBindBuffer( GL_ARRAY_BUFFER, vbo[1] );
glBufferData( GL_ARRAY_BUFFER, 3*nsommets*sizeof(GLfloat), NULL, GL_STATIC_DRAW );
glBufferSubData( GL_ARRAY_BUFFER, 0, 3*nsommets*sizeof(GLfloat), normales );
glVertexAttribPointer( locNormal, 3, GL_FLOAT, GL_FALSE, 0, 0 );
glEnableVertexAttribArray(locNormal);
}
if ( locTexCoord >= 0 )
{
glBindBuffer( GL_ARRAY_BUFFER, vbo[2] );
glBufferData( GL_ARRAY_BUFFER, 2*nsommets*sizeof(GLfloat), NULL, GL_STATIC_DRAW );
glBufferSubData( GL_ARRAY_BUFFER, 0, 2*nsommets*sizeof(GLfloat), texcoord );
glVertexAttribPointer( locTexCoord, 2, GL_FLOAT, GL_FALSE, 0, 0 );
glEnableVertexAttribArray(locTexCoord);
}
glBindVertexArray( 0 );
}
}
~FormeTore()
{
glDeleteBuffers( 3, vbo );
}
void afficher()
{
glBindVertexArray( vao );
glDrawArrays( GL_TRIANGLE_STRIP, 0, nsommets_ );
glBindVertexArray( 0 );
}
private:
GLint nsommets_;
GLuint vbo[3];
};
//////////
class FormeCylindre : public FormeBase2705
{
public:
FormeCylindre( GLdouble base, GLdouble top, GLdouble height, GLint slices, GLint stacks,
bool plein = true )
: FormeBase2705( plein )
{
if ( obtenirAttributs( ) )
{
// initialisation
const int TAILLEMAX = 2*(slices+1)*(stacks) + 2*(slices+1) + 2;
GLfloat sommets[3*TAILLEMAX], normales[3*TAILLEMAX], texcoord[2*TAILLEMAX];
int nsommets = 0;
// variables locales
const GLdouble da = 2.0 * M_PI / slices;
{
// le cylindre
const GLdouble dr = (top - base) / stacks;
const GLdouble nz = (base - top) / height;
const GLdouble dz = height / stacks;
const GLfloat ds = 1.0 / slices;
const GLfloat dt = 1.0 / stacks;
GLfloat t = 0.0;
GLfloat z = 0.0;
GLfloat r = base;
for ( int j = 0; j < stacks; j++ )
{
GLfloat s = 0.0;
for ( int i = 0; i <= slices; i++ )
{
GLfloat a = ( i == slices ) ? 0.0 : i * da;
GLfloat x = sin( a );
GLfloat y = cos( a );
AJOUTE( x * r, y * r, z, x, y, nz, s, t );
AJOUTE( x * (r + dr), y * (r + dr), z + dz, x, y, nz, s, t + dt );
s += ds;
}
r += dr;
t += dt;
z += dz;
}
nsommetsCyl_ = nsommets;
}
{
// les deux bouts avec des disques
/* texture of a shapesDisk is a cut out of the texture unit square
* x, y in [-outerRadius, +outerRadius]; s, t in [0, 1] (linear mapping) */
AJOUTE( 0.0, 0.0, 0.0, 0.0, 0.0, -1.0, 0.5, 0.5 );
for ( int i = slices; i >= 0; i-- )
{
GLfloat a = ( i == slices ) ? 0.0 : i * -da;
GLfloat x = sin( a );
GLfloat y = cos( a );
AJOUTE( base*x, base*y, 0.0, 0.0, 0.0, -1.0, 0.5*(1.0-x), 0.5*(1.0+y) );
}
nsommetsBout_ = nsommets - nsommetsCyl_;
AJOUTE( 0.0, 0.0, height, 0.0, 0.0, +1.0, 0.5, 0.5 );
for ( int i = slices; i >= 0; i-- )
{
GLfloat a = ( i == slices ) ? 0.0 : i * da;
GLfloat x = sin( a );
GLfloat y = cos( a );
AJOUTE( top*x, top*y, height, 0.0, 0.0, +1.0, 0.5*(1.0-x), 0.5*(1.0+y) );
}
}
// remplir VBOs
glBindVertexArray( vao );
glGenBuffers( 3, vbo );
glBindBuffer( GL_ARRAY_BUFFER, vbo[0] );
glBufferData( GL_ARRAY_BUFFER, 3*nsommets*sizeof(GLfloat), NULL, GL_STATIC_DRAW );
glBufferSubData( GL_ARRAY_BUFFER, 0, 3*nsommets*sizeof(GLfloat), sommets );
glVertexAttribPointer( locVertex, 3, GL_FLOAT, GL_FALSE, 0, 0 );
glEnableVertexAttribArray(locVertex);
if ( locNormal >= 0 )
{
glBindBuffer( GL_ARRAY_BUFFER, vbo[1] );
glBufferData( GL_ARRAY_BUFFER, 3*nsommets*sizeof(GLfloat), NULL, GL_STATIC_DRAW );
glBufferSubData( GL_ARRAY_BUFFER, 0, 3*nsommets*sizeof(GLfloat), normales );
glVertexAttribPointer( locNormal, 3, GL_FLOAT, GL_FALSE, 0, 0 );
glEnableVertexAttribArray(locNormal);
}
if ( locTexCoord >= 0 )
{
glBindBuffer( GL_ARRAY_BUFFER, vbo[2] );
glBufferData( GL_ARRAY_BUFFER, 2*nsommets*sizeof(GLfloat), NULL, GL_STATIC_DRAW );
glBufferSubData( GL_ARRAY_BUFFER, 0, 2*nsommets*sizeof(GLfloat), texcoord );
glVertexAttribPointer( locTexCoord, 2, GL_FLOAT, GL_FALSE, 0, 0 );
glEnableVertexAttribArray(locTexCoord);
}
glBindVertexArray( 0 );
}
}
~FormeCylindre()
{
glDeleteBuffers( 3, vbo );
}
void afficher()
{
glBindVertexArray( vao );
glDrawArrays( GL_TRIANGLE_STRIP, 0, nsommetsCyl_ );
glDrawArrays( GL_TRIANGLE_FAN, nsommetsCyl_, nsommetsBout_ );
glDrawArrays( GL_TRIANGLE_FAN, nsommetsCyl_+nsommetsBout_, nsommetsBout_ );
glBindVertexArray( 0 );
}
private:
GLint nsommetsCyl_, nsommetsBout_;
GLuint vbo[3];
};
//////////
class FormeDisque : public FormeBase2705
{
public:
FormeDisque( GLdouble inner, GLdouble outer, GLint slices, GLint loops,
bool plein = true )
: FormeBase2705( plein )
{
if ( obtenirAttributs( ) )
{
// initialisation
const int TAILLEMAX = 2*(slices+1)*(loops);
GLfloat sommets[3*TAILLEMAX], normales[3*TAILLEMAX], texcoord[2*TAILLEMAX];
int nsommets = 0;
// variables locales
const GLfloat da = 2.0 * M_PI / slices;
const GLfloat dr = (outer - inner) / (GLfloat) loops;
/* texture of a shapesDisk is a cut out of the texture unit square
* x, y in [-outer, +outer]; s, t in [0, 1] * (linear mapping) */
GLfloat r1 = inner;
for ( int l = 0; l < loops; l++ )
{
GLfloat r2 = r1 + dr;
for ( int i = slices; i >= 0; i-- )
{
GLfloat a = ( i == slices ) ? 0.0 : i * da;
GLfloat x = sin( a );
GLfloat y = cos( a );
AJOUTE( r2*x, r2*y, 0.0, 0.0, 0.0, +1.0, 0.5*( 1.0 - x*r2/outer ), 0.5*( 1.0 + y*r2/outer ) );
AJOUTE( r1*x, r1*y, 0.0, 0.0, 0.0, +1.0, 0.5*( 1.0 - x*r1/outer ), 0.5*( 1.0 + y*r1/outer ) );
}
r1 = r2;
}
nsommets_ = nsommets;
// remplir VBOs
glBindVertexArray( vao );
glGenBuffers( 3, vbo );
glBindBuffer( GL_ARRAY_BUFFER, vbo[0] );
glBufferData( GL_ARRAY_BUFFER, 3*nsommets*sizeof(GLfloat), NULL, GL_STATIC_DRAW );
glBufferSubData( GL_ARRAY_BUFFER, 0, 3*nsommets*sizeof(GLfloat), sommets );
glVertexAttribPointer( locVertex, 3, GL_FLOAT, GL_FALSE, 0, 0 );
glEnableVertexAttribArray(locVertex);
if ( locNormal >= 0 )
{
glBindBuffer( GL_ARRAY_BUFFER, vbo[1] );
glBufferData( GL_ARRAY_BUFFER, 3*nsommets*sizeof(GLfloat), NULL, GL_STATIC_DRAW );
glBufferSubData( GL_ARRAY_BUFFER, 0, 3*nsommets*sizeof(GLfloat), normales );
glVertexAttribPointer( locNormal, 3, GL_FLOAT, GL_FALSE, 0, 0 );
glEnableVertexAttribArray(locNormal);
}
if ( locTexCoord >= 0 )
{
glBindBuffer( GL_ARRAY_BUFFER, vbo[2] );
glBufferData( GL_ARRAY_BUFFER, 2*nsommets*sizeof(GLfloat), NULL, GL_STATIC_DRAW );
glBufferSubData( GL_ARRAY_BUFFER, 0, 2*nsommets*sizeof(GLfloat), texcoord );
glVertexAttribPointer( locTexCoord, 2, GL_FLOAT, GL_FALSE, 0, 0 );
glEnableVertexAttribArray(locTexCoord);
}
glBindVertexArray( 0 );
}
}
~FormeDisque()
{
glDeleteBuffers( 3, vbo );
}
void afficher()
{
glBindVertexArray( vao );
glDrawArrays( GL_TRIANGLE_STRIP, 0, nsommets_ );
glBindVertexArray( 0 );
}
private:
GLint nsommets_;
GLuint vbo[3];
};
//////////
class FormeIcosaedre : public FormeBase2705
{
public:
FormeIcosaedre( bool plein = true )
: FormeBase2705( plein )
{
}
~FormeIcosaedre()
{
}
void afficher()
{
#if !defined( __APPLE__ )
shapesSolidIcosahedron( );
#endif
}
private:
};
//////////
class FormeDodecaedre : public FormeBase2705
{
public:
FormeDodecaedre( bool plein = true )
: FormeBase2705( plein )
{
}
~FormeDodecaedre()
{
}
void afficher()
{
#if !defined( __APPLE__ )
shapesSolidDodecahedron( );
#endif
}
private:
};
//////////
// teapot(14, true);
// teapot(10, false);
class FormeTheiere : public FormeBase2705
{
public:
FormeTheiere( GLint npts = 14,
bool plein = true )
: FormeBase2705( plein ) //, npts_(npts)
{
#if 0
if ( obtenirAttributs( ) )
{
// initialisation
const int TAILLEMAX = 10*(npts_+1)*(npts_);
GLfloat sommets[3*TAILLEMAX], normales[3*TAILLEMAX], texcoord[2*TAILLEMAX];
int nsommets = 0;
}
#endif
}
~FormeTheiere()
{
#if 0
glDeleteBuffers( 3, vbo );
#endif
}
void afficher()
{
#if 1
#if !defined( __APPLE__ )
shapesSolidTeapot();
#endif
#else
glBindVertexArray( vao );
//glDrawArrays( GL_TRIANGLE_STRIP, 0, nsommets_ );
/* Rim, body, lid, and bottom data must be reflected in x and
y; handle and spout data across the y axis only. */
int patchdata[][16] =
{
/* rim */
{102, 103, 104, 105, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
/* body */
{12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27},
{24, 25, 26, 27, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40},
/* lid */
{96, 96, 96, 96, 97, 98, 99, 100, 101, 101, 101, 101, 0, 1, 2, 3,},
{0, 1, 2, 3, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117},
/* bottom */
{118, 118, 118, 118, 124, 122, 119, 121, 123, 126, 125, 120, 40, 39, 38, 37},
/* handle */
{41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56},
{53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 28, 65, 66, 67},
/* spout */
{68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83},
{80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95}
};
float cpdata[][3] =
{
{0.2,0,2.7}, {0.2,-0.112,2.7}, {0.112,-0.2,2.7}, {0,-0.2,2.7},
{1.3375,0,2.53125}, {1.3375,-0.749,2.53125}, {0.749,-1.3375,2.53125},
{0,-1.3375,2.53125}, {1.4375,0,2.53125}, {1.4375,-0.805, 2.53125},
{0.805,-1.4375,2.53125}, {0,-1.4375,2.53125}, {1.5,0,2.4}, {1.5,-0.84,2.4},
{0.84,-1.5,2.4}, {0,-1.5,2.4}, {1.75,0, 1.875}, {1.75,-0.98,1.875},
{0.98,-1.75,1.875}, {0,-1.75,1.875}, {2,0,1.35}, {2,-1.12,1.35},
{1.12,-2,1.35}, {0,-2,1.35}, {2,0,0.9}, {2,-1.12,0.9}, {1.12,-2,0.9},
{0,-2,0.9}, {-2,0,0.9}, {2, 0,0.45}, {2,-1.12,0.45}, {1.12,-2,0.45},
{0,-2,0.45}, {1.5,0,0.225}, {1.5,-0.84,0.225}, {0.84,-1.5,0.225},
{0,-1.5,0.225}, {1.5, 0,0.15}, {1.5,-0.84,0.15}, {0.84,-1.5,0.15},
{0,-1.5,0.15}, {-1.6,0,2.025}, {-1.6,-0.3,2.025}, {-1.5,-0.3,2.25},
{-1.5,0,2.25}, {-2.3,0,2.025}, {-2.3,-0.3,2.025}, {-2.5,-0.3,2.25},
{-2.5,0,2.25}, {-2.7,0,2.025}, {-2.7,-0.3,2.025}, {-3,-0.3,2.25},
{-3,0,2.25}, {-2.7,0,1.8}, {-2.7,-0.3,1.8}, {-3,-0.3,1.8}, {-3,0,1.8},
{-2.7,0,1.575}, {-2.7,-0.3,1.575}, {-3,-0.3,1.35}, {-3,0,1.35},
{-2.5,0,1.125}, {-2.5,-0.3,1.125}, {-2.65,-0.3,0.9375}, {-2.65,0, 0.9375},
{-2,-0.3,0.9}, {-1.9,-0.3,0.6}, {-1.9,0,0.6}, {1.7,0, 1.425},
{1.7,-0.66,1.425}, {1.7,-0.66,0.6}, {1.7,0,0.6}, {2.6,0, 1.425},
{2.6,-0.66,1.425}, {3.1,-0.66,0.825}, {3.1,0,0.825}, {2.3, 0,2.1},
{2.3,-0.25,2.1}, {2.4,-0.25,2.025}, {2.4,0,2.025}, {2.7, 0,2.4},
{2.7,-0.25,2.4}, {3.3,-0.25,2.4}, {3.3,0,2.4}, {2.8,0, 2.475},
{2.8,-0.25,2.475}, {3.525,-0.25,2.49375}, {3.525,0, 2.49375}, {2.9,0,2.475},
{2.9,-0.15,2.475}, {3.45,-0.15,2.5125}, {3.45,0,2.5125}, {2.8,0,2.4},
{2.8,-0.15,2.4}, {3.2,-0.15,2.4}, {3.2,0,2.4}, {0,0,3.15}, {0.8,0,3.15},
{0.8,-0.45,3.15}, {0.45, -0.8,3.15}, {0,-0.8,3.15}, {0,0,2.85}, {1.4,0,2.4},
{1.4,-0.784, 2.4}, {0.784,-1.4,2.4}, {0,-1.4,2.4}, {0.4,0,2.55},
{0.4,-0.224, 2.55}, {0.224,-0.4,2.55}, {0,-0.4,2.55}, {1.3,0,2.55},
{1.3,-0.728,2.55}, {0.728,-1.3,2.55}, {0,-1.3,2.55}, {1.3,0,2.4},
{1.3,-0.728,2.4}, {0.728,-1.3,2.4}, {0,-1.3,2.4}, {0,0,0}, {1.425,-0.798,0},
{1.5,0,0.075}, {1.425,0,0}, {0.798,-1.425,0}, {0,-1.5, 0.075}, {0,-1.425,0},
{1.5,-0.84,0.075}, {0.84,-1.5,0.075}
};
float tex[2][2][2] =
{
{ {0, 0},
{1, 0}},
{ {0, 1},
{1, 1}}
};
float p[4][4][3], q[4][4][3], r[4][4][3], s[4][4][3];
for ( int i = 0; i < 10; i++ )
{
for ( int j = 0; j < 4; j++ )
{
for ( int k = 0; k < 4; k++ )
{
for ( int l = 0; l < 3; l++ )
{
p[j][k][l] = cpdata[patchdata[i][j * 4 + k]][l];
q[j][k][l] = cpdata[patchdata[i][j * 4 + (3 - k)]][l];
if (l == 1) q[j][k][l] *= -1.0;
if (i < 6)
{
r[j][k][l] = cpdata[patchdata[i][j * 4 + (3 - k)]][l];
if (l == 0) r[j][k][l] *= -1.0;
s[j][k][l] = cpdata[patchdata[i][j * 4 + k]][l];
if (l == 0) s[j][k][l] *= -1.0;
if (l == 1) s[j][k][l] *= -1.0;
}
}
}
}
glEnable( GL_AUTO_NORMAL );
glEnable( GL_MAP2_TEXTURE_COORD_2 );
glEnable( GL_MAP2_VERTEX_3 );
glMap2f( GL_MAP2_TEXTURE_COORD_2, 0, 1, 2, 2, 0, 1, 4, 2, &tex[0][0][0] );
glMap2f( GL_MAP2_VERTEX_3, 0, 1, 3, 4, 0, 1, 12, 4, &p[0][0][0] );
glMapGrid2f( npts_, 0.0, 1.0, npts_, 0.0, 1.0 );
glEvalMesh2( GL_FILL, 0, npts_, 0, npts_ );
glMap2f( GL_MAP2_VERTEX_3, 0, 1, 3, 4, 0, 1, 12, 4, &q[0][0][0] );
glEvalMesh2( GL_FILL, 0, npts_, 0, npts_ );
if ( i < 6 )
{
glMap2f( GL_MAP2_VERTEX_3, 0, 1, 3, 4, 0, 1, 12, 4, &r[0][0][0] );
glEvalMesh2( GL_FILL, 0, npts_, 0, npts_ );
glMap2f( GL_MAP2_VERTEX_3, 0, 1, 3, 4, 0, 1, 12, 4, &s[0][0][0] );
glEvalMesh2( GL_FILL, 0, npts_, 0, npts_ );
}
}
glBindVertexArray( 0 );
#endif
}
private:
#if 0
void Map2f( GLenum target,
GLfloat u1, GLfloat u2, GLint ustride, GLint uorder,
GLfloat v1, GLfloat v2, GLint vstride, GLint vorder,
const GLfloat *points )
{
}
GLint un; GLfloat u1, u2, du;
GLint vn; GLfloat v1, v2, dv;
void MapGrid2f( GLint unArg, GLfloat u1Arg, GLfloat u2Arg,
GLint vnArg, GLfloat v1Arg, GLfloat v2Arg )
{
un = unArg; u1 = u1Arg; u2 = u2Arg; du = u2 - u1;
vn = vnArg; v1 = v1Arg; v2 = v2Arg; dv = v2 - v1;
}
void EvalMesh2( GLint i1, GLint i2, GLint j1, GLint j2 )
{
if ( plein_ )
{
for ( int j = j1; j < j2; j += 1 )
{
glBegin( GL_QUAD_STRIP );
for ( int i = i1; i <= i2; i += 1 )
{
glEvalCoord2f( i * du + u1, j * dv + v1 );
glEvalCoord2f( i * du + u1, j + 1 * dv + v1 );
} glEnd();
}
}
else
{
for ( int j = j1; j <= j2; j += 1 )
{
glBegin( GL_LINE_STRIP );
for ( int i = i1; i <= i2; i += 1 )
glEvalCoord2f( i * du + u1, j * dv + v1 );
glEnd();
}
for ( int i = i1; i <= i2; i += 1 )
{
glBegin( GL_LINE_STRIP );
for ( int j = j1; j <= j1; j += 1 )
glEvalCoord2f( i * du + u1, j * dv + v1 );
glEnd();
}
}
}
#endif
#if 0
GLint npts_;
GLint nsommets_;
GLuint vbo[3];
#endif
};
//////////
#endif