Afficher une heightmap avec OpenGL

#ifndef MAP_HH
#define MAP_HH

#include <string>

#include "SFML/Window.hpp"
#include "SFML/Graphics.hpp"

#include "camera/camera.hh"

template <class MapLoader>
class Map : public MapLoader
{
public:
  // Constructeurs / Desctructeurs
   Map( void );
  ~Map( void );

  // Méthodes publiques
  bool loadTexture( const std::string& filename );
  bool loadDetails( const std::string& filename );
  void compile    ( void                        );
  void render     ( sf::RenderWindow& w         );

  // Accesseurs
  const std::string& getName        ( void ) const;
  const std::string& getDescription ( void ) const;
  unsigned int       getPrecision   ( void ) const;

  // Mutateurs
  void setName        ( const std::string& name        );
  void setDescription ( const std::string& description );
  void setPrecision   ( unsigned int precision         );
  void setPosition    ( unsigned int x, unsigned int y );

private:
  // Méthodes privées
  void renderTerrain ( sf::RenderWindow& w );
  void renderInfos   ( sf::RenderWindow& w );

private:
  // Attributs privés
  sf::String   name_;
  sf::String   description_;
  sf::Image    texture_main;
  sf::Image    texture_details;
  Camera       camera_;
  sf::Sprite   minimap_;
  GLuint       list_;
  unsigned int precision_;
};

#include "map.inl"

#endif // MAP_HH

glFrontFace( GL_CW  ); //         ClockWise: Aiguilles d'une montre
glFrontFace( GL_CCW ); // Counter ClockWise: Trigonométrique

glEnable(GL_CULL_FACE);

glCullFace(GL_BACK);

template <class MapLoader>
void Map<MapLoader>::compile( void )
{
  // Génération d'un identifiant pour notre display lsit
  list_ = glGenLists( 1 );
  
  // On demande à OpenGL de compiler ce qui va suivre dans
  // une display list identifiée par list_, que l'on vient de
  // générer.
  glNewList( list_, GL_COMPILE );
  {
    // Nous informons OpenGL que ce qui va suivre est une
    // énumération de triangles.
    glBegin( GL_TRIANGLES );
    {
      //  Pour chaque ligne, avec un pas dépendant de la précision souhaitée
      for ( unsigned int x=0; x<(getHeight()-getPrecision()); x+=getPrecision())
      {
        // Pour chaque colonne, avec un pas dépendant de la précision souhaitée
        for ( unsigned int z=0; z<(getWidth()-getPrecision()); z+=getPrecision())
        {
          // Définition des coordonnées des points
          Point3D<GLfloat> vertex1( x,
                                    getPixel( x, z ),
                                    z,
                                    x/getWidth (),
                                    1.f-(z/getHeight()) );
                                    
          Point3D<GLfloat> vertex2( getPrecision()+x,
                                    getPixel( getPrecision()+x, z ),
                                    z,
                                    (x+getPrecision())/getWidth(),
                                    1.f-(z/getHeight()) );
                                    
          Point3D<GLfloat> vertex3( getPrecision()+x,
                                    getPixel( getPrecision()+x, getPrecision()+z ),
                                    getPrecision()+z,
                                    (x+getPrecision())/getWidth(),
                                    1.f-((z+getPrecision())/getHeight()) );
                                    
          Point3D<GLfloat> vertex4( x,
                                    getPixel( x, getPrecision()+z ),
                                    getPrecision()+z,
                                    (x)/(float)getWidth (),
                                    1.f-((z+getPrecision())/getHeight()) );
          
          // Premier triangle
          vertex3.sendWithText();
          vertex2.sendWithText();
          vertex1.sendWithText();
          
          // Deuxi&#232;me triangle
          vertex4.sendWithText();
          vertex3.sendWithText();
          vertex1.sendWithText();
        }
      }
    }
    glEnd();
  }
  glEndList();
}

#ifndef POINT3D_HH
#define POINT3D_HH

template <class T>
class Point3D
{
public:
   Point3D ( T mx=0, T my=0, T mz=0, float mtx=0, float mty=0 ):
   x ( mx  ),
   y ( my  ),
   z ( mz  ),
   tx( mtx ),
   ty( mty )
   {
   }

  ~Point3D ( void )
  {
  }

  void send( void ) const
  {
    glVertex3f( static_cast<float>(x),
                static_cast<float>(y),
                static_cast<float>(z) );
  }

  void sendWithText( void ) const
  {
    glTexCoord2f( tx, ty );
    glVertex3f( static_cast<float>(x),
                static_cast<float>(y),
                static_cast<float>(z) );
  }

public:
  T x;
  T y;
  T z;

  float tx;
  float ty;
};

#endif // POINT3D_HH

template <class MapLoader>
void Map<MapLoader>::render( sf::RenderWindow& w )
{
  renderTerrain( w );           // Affichage du terrain
  renderInfos  ( w );           // Affichage des informations
  camera_.renderPosition( w );  // Affichage de la position sur la minimap
}

template <class MapLoader>
void Map<MapLoader>::renderInfos( sf::RenderWindow& w )
{
  w.Draw        ( name_            );  // Affichage de l'ombre du nom
  name_.Move    ( -2.f, -2.f       );  // Décalage pour le texte en blanc
  name_.SetColor( sf::Color::White );  // Le prochain affichage sera blanc
  w.Draw        ( name_            );  // Rendu en blanc
  name_.SetColor( sf::Color::Black );  // Retour à la couleur de l'ombre
  name_.Move    (  2.f,  2.f       );  // Retour à la place initiale
  
  w.Draw               ( description_     ); // Idem qu'au-dessus
  description_.Move    ( -1.f, -1.f       );
  description_.SetColor( sf::Color::White );
  w.Draw               ( description_     );
  description_.SetColor( sf::Color::Black );
  description_.Move    (  1.f,  1.f       );

  w.Draw( minimap_ ); // Affichage de la minimap
}

template <class MapLoader>
void Map<MapLoader>::renderTerrain( sf::RenderWindow& )
{
  glClear          ( GL_DEPTH_BUFFER_BIT ); // Réinitialisation z-buffer
  camera_.focus    (                     ); // gluLookAt
  glScalef         ( 1.f, 0.15f, 1.f     ); // Diminution du rapport de hauteur
  glEnable         ( GL_TEXTURE_2D       ); // Activation du texturing
  texture_main.Bind(                     ); // Sélection de la texture principale
  glCallList       ( list_               ); // Appel de la display list
}