<?xml version="1.0" encoding="iso-8859-1"?>
<configuration>
  <videomode>
    <width>1024</width&>
    <height>768</height>
    <bpp>32</bpp>
  </videomode>
  <map>
    <name>Example map</name>
    <description>OpenGL heightmap article by NewbiZ.</description>
    <heightmap path="map_height.png" precision="1" />
    <texture   path="map_texture.png" />
    <details   path="map_details.png" />
  </map>
</configuration>

#ifndef SFMLLOADER_HH
#define SFMLLOADER_HH

#include <string>

#include "loader.hh"

class SFMLLoader : public Loader
{
public:
  virtual bool loadHeightmap( const std::string& filename );
};

#endif // SFMLLOADER_HH

bool SFMLLoader::loadHeightmap( const std::string& filename )
{
  // L'image servant à récupérer les pixels
  sf::Image image;
  
  // Si le fichier n'existe pas ou est invalide, on retourne sans rien faire,
  // sinon on peut continuer avec l'image chargée
  if ( !image.LoadFromFile(filename) )
    return false;
  
  // Assignations
  setWidth ( image.GetWidth () );
  setHeight( image.GetHeight() );
  
  // Le tableau renvoyé par GetPixelsPtr() contient les 4 composantes RGBA
  // sous forme de char
  static const int elemSize = 4;
  
  // La taille totale du tableau renvoyé par GetPixelsPtr()
  const int size = image.GetWidth() * image.GetHeight() * 4;
  
  // Création de notre propre tableau qui ne contiendra qu'une composante (noir et blanc)
  pixels_  = new unsigned char[size/elemSize];
                    
  // On stocke un pointeur vers le tableau renvoyé par GetPixelsPtr() pour y accéder plus
  // simplement
  const unsigned char* const px = image.GetPixelsPtr();
  
  // On copie les pixels
  for ( int i=0; i<size/elemSize; ++i )
    pixels_[i] = px[i*elemSize];
  
  return true;
}

#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è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 couleure 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
}