/****************************************************************************

 Copyright (C) 2002-2014 Gilles Debunne. All rights reserved.

 This file is part of the QGLViewer library version 2.8.0.

 http://www.libqglviewer.com - contact@libqglviewer.com

 This file may be used under the terms of the GNU General Public License 
 versions 2.0 or 3.0 as published by the Free Software Foundation and
 appearing in the LICENSE file included in the packaging of this file.
 In addition, as a special exception, Gilles Debunne gives you certain 
 additional rights, described in the file GPL_EXCEPTION in this package.

 libQGLViewer uses dual licensing. Commercial/proprietary software must
 purchase a libQGLViewer Commercial License.

 This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.

*****************************************************************************/

// TP OpenGL: Joerg Liebelt, Serigne Sow
#include "quadtree.h"

#define SQR(number) (number * number)
#define CUBE(number) (number * number * number)
#define MIN(a, b) (((a) < (b)) ? (a) : (b))
#define MAX(a, b) (((a) < (b)) ? (b) : (a))

// codes determinant le type de suite partielle de triangles a creer, selon la
// position dans le quadtree
static char suiteCode[] = {10, 8,  8, 12, 8,  0,  12, 14,
                           8,  12, 0, 14, 12, 14, 14, 0};
static char suiteStart[] = {3, 3, 0, 3, 1, 0, 0, 3, 2, 2, 0, 2, 1, 1, 0, 0};

static bool debugger = false;

bool QUADTREE::Init(void) {
  int x, z;

  quadMatrix = new unsigned char[SQR(sizeHeightMap)];

  for (z = 0; z < sizeHeightMap; z++) {
    for (x = 0; x < sizeHeightMap; x++) {
      quadMatrix[GetMatrixIndex(x, z)] = 1;
    }
  }

  // repartir les triangles pour que les regions detailles/moins lisses
  // obtiennent plus de triangles
  PropagateRoughness();
  return true;
}

void QUADTREE::Shutdown(void) {
  if (quadMatrix)
    delete[] quadMatrix;
}

void QUADTREE::Update(float x, float y, float z) {
  float center;
  setCameraPosition(x, y, z);
  // centre de la carte
  center = (sizeHeightMap) / 2.0f;

  // reconstruire le "grid" par traversee top-down du quadtree
  RefineNode(center, center, sizeHeightMap);
}

// rendering d'un seul vertex
// params u,v deja normalises par rapport a sizeHeightMap
void QUADTREE::RenderVertex(float x, float z, float u, float v,
                            bool multiTextures) {
  unsigned char color = GetBrightnessAtPoint((int)x, (int)z);
  if (debugger)
    printf("RenderVertex %f,%f - %f,%f\n", x, z, u, v);
  if (paintLighting) {
    glColor3ub((unsigned char)(color * rLight), (unsigned char)(color * gLight),
               (unsigned char)(color * bLight));
  } else
    glColor3ub(255, 255, 255);
  glMultiTexCoord2f(GL_TEXTURE0, u, v);
  if (multiTextures)
    glMultiTexCoord2f(GL_TEXTURE1, u * repeatDetailMap, v * repeatDetailMap);
  glVertex3f(x / sizeHeightMap * scaleSize,
             GetScaledHeightAtPoint((int)x, (int)z) / sizeHeightMap,
             z / sizeHeightMap * scaleSize);
}

// debut du rendering recursif
void QUADTREE::Render(void) {
  float center;
  if (debugger)
    printf("Render\n");
  // centre de la carte
  center = (sizeHeightMap) / 2.0f;

  // on fait le culling a travers le quadtree, pas avec le hardware
  glDisable(GL_CULL_FACE);

  // on a multitextures et on souhaite les afficher
  if (haveMultitexture && paintTextures) {
    glDisable(GL_BLEND); // pas de combinaison de couleurs avec MULTITEXTURES,
    //.. la combi des deux textures se fait automatiquement en hardware

    // selectionner comme premiere unite de texture la texture de base (couleur
    // selon hauteur)
    glActiveTexture(GL_TEXTURE0);
    glEnable(GL_TEXTURE_2D);
    glBindTexture(GL_TEXTURE_2D, textureColorID);

    // selectionner commer deuxieme unite de texture la texture de detail
    // (structure)
    glActiveTexture(GL_TEXTURE1);
    glEnable(GL_TEXTURE_2D);
    glBindTexture(GL_TEXTURE_2D, textureDetailID);

    // definir la maniere dont les couleurs des triangles sont crees en fct. des
    // couleurs des textures
    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE,
              GL_COMBINE); // mode de combination des deux
    glTexEnvi(GL_TEXTURE_ENV, GL_RGB_SCALE,
              2); // augmenter la luminosite des couleurs

    // render a partir du noeud principal au milieu de la carte (recursif a
    // partir d'ici)
    RenderNode(center, center, sizeHeightMap, true, true);
  }

  // on a pas de multitextures mais on souhaite des textures
  else if (paintTextures) {
    // PREMIER PARCOURS: couleurs
    // selectionner comme unite de texture la texture de base (couleur selon
    // hauteur)
    glActiveTexture(GL_TEXTURE0);
    glEnable(GL_TEXTURE_2D);
    glBindTexture(GL_TEXTURE_2D, textureColorID);

    RenderNode(center, center, sizeHeightMap, false, false);

    // DEUXIEME PARCOURS: DETAIL
    // preparer la texture de detail
    glActiveTexture(GL_TEXTURE0);
    glEnable(GL_TEXTURE_2D);
    glBindTexture(GL_TEXTURE_2D, textureDetailID);

    // activer la combinaison entre couleur existant (premier parcours) et
    // couleur ajoutee (detail)
    glEnable(GL_BLEND);
    glBlendFunc(GL_ZERO, GL_SRC_COLOR);

    RenderNode(center, center, sizeHeightMap, false, true);

    glDisable(GL_BLEND);
  }

  else // pas de textures du tout
  {
    RenderNode(center, center, sizeHeightMap, false, false);
    // sinon rendering brute force?
  }

  // liberer la deuxieme texture
  glActiveTexture(GL_TEXTURE1);
  glDisable(GL_TEXTURE_2D);
  glBindTexture(GL_TEXTURE_2D, 0);

  // liberer la premiere texture
  glActiveTexture(GL_TEXTURE0);
  glDisable(GL_TEXTURE_2D);
  glBindTexture(GL_TEXTURE_2D, 0);
}

// gerer la repartition des triangles sur les parties moins lisses / plus
// detaillees
void QUADTREE::PropagateRoughness(void) {
  float upperBound;
  int dH, d2, localD2, localH;
  int edgeLength, edgeOffset;
  int childOffset;
  int x, z;
  if (debugger)
    printf("PropagateRoughness\n");
  // commencer au niveau de detail le plus elevee (taille de bloc la plus
  // petite)
  edgeLength = 2;
  // jusqu'au niveau de detail le moins elevee (taille de bloc la plus petite)
  // un bloc est defini par edgeLength*edgeLength
  //.. ==> bottom-up!
  while (edgeLength <= sizeHeightMap) {
    edgeOffset = (edgeLength) >> 1;

    childOffset = (edgeLength) >> 2;
    // D2: valeur qui indique la difference maximale entre l'hauteur reelle et
    //.. l'hauteur moyenne autour du point (calculee comme moyenne de deux
    //points)  pour chaque noeud, calculer D2 a 9 endroits (milieu + 8 autour,
    // sur un rectangle) pour 5 valeurs
    for (z = edgeOffset; z < sizeHeightMap - edgeOffset; z += (edgeLength)) {
      for (x = edgeOffset; x < sizeHeightMap - edgeOffset; x += (edgeLength)) {
        // haut, milieu
        localD2 = (int)ceil(
            (int)(abs(((GetTrueHeightAtPoint(x - edgeOffset, z + edgeOffset) +
                        GetTrueHeightAtPoint(x + edgeOffset, z + edgeOffset)) >>
                       1) -
                      GetTrueHeightAtPoint(x, z + edgeOffset))));
        // a droite, milieu
        dH = (int)ceil(
            abs(((GetTrueHeightAtPoint(x + edgeOffset, z + edgeOffset) +
                  GetTrueHeightAtPoint(x + edgeOffset, z - edgeOffset)) >>
                 1) -
                GetTrueHeightAtPoint(x + edgeOffset, z)));
        localD2 = MAX(localD2, dH);

        // en bas, milieu
        dH = (int)ceil(
            abs(((GetTrueHeightAtPoint(x - edgeOffset, z - edgeOffset) +
                  GetTrueHeightAtPoint(x + edgeOffset, z - edgeOffset)) >>
                 1) -
                GetTrueHeightAtPoint(x, z - edgeOffset)));
        localD2 = MAX(localD2, dH);

        // a gauche, milieu
        dH = (int)ceil(
            abs(((GetTrueHeightAtPoint(x - edgeOffset, z + edgeOffset) +
                  GetTrueHeightAtPoint(x - edgeOffset, z - edgeOffset)) >>
                 1) -
                GetTrueHeightAtPoint(x - edgeOffset, z)));
        localD2 = MAX(localD2, dH);

        // deux points sur la diagonale de bas gauche a haut droite
        dH = (int)ceil(
            abs(((GetTrueHeightAtPoint(x - edgeOffset, z - edgeOffset) +
                  GetTrueHeightAtPoint(x + edgeOffset, z + edgeOffset)) >>
                 1) -
                GetTrueHeightAtPoint(x, z)));
        localD2 = MAX(localD2, dH);

        // deux points sur la diagonale de bas droite a haut gauche
        dH = (int)ceil(
            abs(((GetTrueHeightAtPoint(x + edgeOffset, z - edgeOffset) +
                  GetTrueHeightAtPoint(x - edgeOffset, z + edgeOffset)) >>
                 1) -
                GetTrueHeightAtPoint(x, z)));
        localD2 = MAX(localD2, dH);
        // localD2 de 0 a 255, normaliser par la taille du bloc actuelle (de 3 a
        // sizeHeightMap)
        // ... donc multiplier par 3 pour obtenir une precision maximale de 0 a
        // 255 pour d2
        localD2 = (int)ceil((localD2 * 3.0f) / edgeLength);
        // sur le niveau le plus bas, on calcule l'hauteur reelle maximale a la
        // main
        if (edgeLength == 2) {
          d2 = localD2;
          // haut, droite
          localH = GetTrueHeightAtPoint(x + edgeOffset, z + edgeOffset);
          // milieu, droite
          localH = MAX(localH, GetTrueHeightAtPoint(x + edgeOffset, z));
          // bas, droite
          localH =
              MAX(localH, GetTrueHeightAtPoint(x + edgeOffset, z - edgeOffset));
          // bas milieu
          localH = MAX(localH, GetTrueHeightAtPoint(x, z - edgeOffset));
          // bas gauche
          localH =
              MAX(localH, GetTrueHeightAtPoint(x - edgeOffset, z - edgeOffset));
          // gauche milieu
          localH = MAX(localH, GetTrueHeightAtPoint(x - edgeOffset, z));
          // gauche haut
          localH =
              MAX(localH, GetTrueHeightAtPoint(x - edgeOffset, z + edgeOffset));
          // haut milieu
          localH = MAX(localH, GetTrueHeightAtPoint(x, z + edgeOffset));
          // centre
          localH = MAX(localH, GetTrueHeightAtPoint(x, z));
          // sauvegarder ce valeur dans la matrice (pour les pas recursifs
          // suivants)
          quadMatrix[GetMatrixIndex(x + 1, z)] = localH;
        }
        // sur les autres niveaux, on utilise la valeur sauvegarde dans la
        // matrice
        else {
          upperBound = 1.0f * minResolution / (2.0f * (minResolution - 1.0f));

          d2 = (int)ceil(
              MAX(upperBound * (float)GetQuadMatrixData(x, z), (float)localD2));
          d2 = (int)ceil(
              MAX(upperBound * (float)GetQuadMatrixData(x - edgeOffset, z),
                  (float)d2));
          d2 = (int)ceil(
              MAX(upperBound * (float)GetQuadMatrixData(x + edgeOffset, z),
                  (float)d2));
          d2 = (int)ceil(
              MAX(upperBound * (float)GetQuadMatrixData(x, z + edgeOffset),
                  (float)d2));
          d2 = (int)ceil(
              MAX(upperBound * (float)GetQuadMatrixData(x, z - edgeOffset),
                  (float)d2));

          localH = GetTrueHeightAtPoint(x + childOffset, z + childOffset);
          localH = MAX(localH,
                       GetTrueHeightAtPoint(x + childOffset, z - childOffset));
          localH = MAX(localH,
                       GetTrueHeightAtPoint(x - childOffset, z - childOffset));
          localH = MAX(localH,
                       GetTrueHeightAtPoint(x - childOffset, z + childOffset));

          quadMatrix[GetMatrixIndex(x + 1, z)] = localH;
        }

        // sauvegarder les valeurs d2 dans la matrice
        quadMatrix[GetMatrixIndex(x, z)] = d2;
        quadMatrix[GetMatrixIndex(x - 1, z)] = d2;

        // la valeur se propage vers les noeuds voisins
        quadMatrix[GetMatrixIndex(x - edgeOffset, z - edgeOffset)] =
            MAX(GetQuadMatrixData(x - edgeOffset, z - edgeOffset), d2);
        quadMatrix[GetMatrixIndex(x - edgeOffset, z + edgeOffset)] =
            MAX(GetQuadMatrixData(x - edgeOffset, z + edgeOffset), d2);
        quadMatrix[GetMatrixIndex(x + edgeOffset, z + edgeOffset)] =
            MAX(GetQuadMatrixData(x + edgeOffset, z + edgeOffset), d2);
        quadMatrix[GetMatrixIndex(x + edgeOffset, z - edgeOffset)] =
            MAX(GetQuadMatrixData(x + edgeOffset, z - edgeOffset), d2);
      }
    }
    // monter un niveau (elargir la taille d'un bloc, reduire le niveau de
    // detail)
    edgeLength = (edgeLength << 1);
  }
}

// on determine la region capturee par la camera (en fct. de modelview et
// projection) idee pour le code: Chris Cookson, gamersdev.net
void QUADTREE::ComputeView(void) {
  float projMatrix[16]; // projection matrice
  float modMatrix[16];  // modelview matrice
  float clip[16];
  float norm;
  if (debugger)
    printf("ComputeView\n");
  /* opengl: matrice de proj.*/
  glGetFloatv(GL_PROJECTION_MATRIX, projMatrix);

  /* opengl: matrice de vue*/
  glGetFloatv(GL_MODELVIEW_MATRIX, modMatrix);

  /* multiplication vue*proj*/
  clip[0] = modMatrix[0] * projMatrix[0] + modMatrix[1] * projMatrix[4] +
            modMatrix[2] * projMatrix[8] + modMatrix[3] * projMatrix[12];
  clip[1] = modMatrix[0] * projMatrix[1] + modMatrix[1] * projMatrix[5] +
            modMatrix[2] * projMatrix[9] + modMatrix[3] * projMatrix[13];
  clip[2] = modMatrix[0] * projMatrix[2] + modMatrix[1] * projMatrix[6] +
            modMatrix[2] * projMatrix[10] + modMatrix[3] * projMatrix[14];
  clip[3] = modMatrix[0] * projMatrix[3] + modMatrix[1] * projMatrix[7] +
            modMatrix[2] * projMatrix[11] + modMatrix[3] * projMatrix[15];

  clip[4] = modMatrix[4] * projMatrix[0] + modMatrix[5] * projMatrix[4] +
            modMatrix[6] * projMatrix[8] + modMatrix[7] * projMatrix[12];
  clip[5] = modMatrix[4] * projMatrix[1] + modMatrix[5] * projMatrix[5] +
            modMatrix[6] * projMatrix[9] + modMatrix[7] * projMatrix[13];
  clip[6] = modMatrix[4] * projMatrix[2] + modMatrix[5] * projMatrix[6] +
            modMatrix[6] * projMatrix[10] + modMatrix[7] * projMatrix[14];
  clip[7] = modMatrix[4] * projMatrix[3] + modMatrix[5] * projMatrix[7] +
            modMatrix[6] * projMatrix[11] + modMatrix[7] * projMatrix[15];

  clip[8] = modMatrix[8] * projMatrix[0] + modMatrix[9] * projMatrix[4] +
            modMatrix[10] * projMatrix[8] + modMatrix[11] * projMatrix[12];
  clip[9] = modMatrix[8] * projMatrix[1] + modMatrix[9] * projMatrix[5] +
            modMatrix[10] * projMatrix[9] + modMatrix[11] * projMatrix[13];
  clip[10] = modMatrix[8] * projMatrix[2] + modMatrix[9] * projMatrix[6] +
             modMatrix[10] * projMatrix[10] + modMatrix[11] * projMatrix[14];
  clip[11] = modMatrix[8] * projMatrix[3] + modMatrix[9] * projMatrix[7] +
             modMatrix[10] * projMatrix[11] + modMatrix[11] * projMatrix[15];

  clip[12] = modMatrix[12] * projMatrix[0] + modMatrix[13] * projMatrix[4] +
             modMatrix[14] * projMatrix[8] + modMatrix[15] * projMatrix[12];
  clip[13] = modMatrix[12] * projMatrix[1] + modMatrix[13] * projMatrix[5] +
             modMatrix[14] * projMatrix[9] + modMatrix[15] * projMatrix[13];
  clip[14] = modMatrix[12] * projMatrix[2] + modMatrix[13] * projMatrix[6] +
             modMatrix[14] * projMatrix[10] + modMatrix[15] * projMatrix[14];
  clip[15] = modMatrix[12] * projMatrix[3] + modMatrix[13] * projMatrix[7] +
             modMatrix[14] * projMatrix[11] + modMatrix[15] * projMatrix[15];

  /* plan droite*/
  viewMatrix[VIEW_RIGHT][0] = clip[3] - clip[0];
  viewMatrix[VIEW_RIGHT][1] = clip[7] - clip[4];
  viewMatrix[VIEW_RIGHT][2] = clip[11] - clip[8];
  viewMatrix[VIEW_RIGHT][3] = clip[15] - clip[12];

  // normaliser
  norm = sqrtf(SQR(viewMatrix[VIEW_RIGHT][0]) + SQR(viewMatrix[VIEW_RIGHT][1]) +
               SQR(viewMatrix[VIEW_RIGHT][2]));
  viewMatrix[VIEW_RIGHT][0] /= norm;
  viewMatrix[VIEW_RIGHT][1] /= norm;
  viewMatrix[VIEW_RIGHT][2] /= norm;
  viewMatrix[VIEW_RIGHT][3] /= norm;

  /* plan gauche*/
  viewMatrix[VIEW_LEFT][0] = clip[3] + clip[0];
  viewMatrix[VIEW_LEFT][1] = clip[7] + clip[4];
  viewMatrix[VIEW_LEFT][2] = clip[11] + clip[8];
  viewMatrix[VIEW_LEFT][3] = clip[15] + clip[12];

  // normaliser
  norm = sqrtf(SQR(viewMatrix[VIEW_LEFT][0]) + SQR(viewMatrix[VIEW_LEFT][1]) +
               SQR(viewMatrix[VIEW_LEFT][2]));
  viewMatrix[VIEW_LEFT][0] /= norm;
  viewMatrix[VIEW_LEFT][1] /= norm;
  viewMatrix[VIEW_LEFT][2] /= norm;
  viewMatrix[VIEW_LEFT][3] /= norm;

  /* plan bas*/
  viewMatrix[VIEW_BOTTOM][0] = clip[3] + clip[1];
  viewMatrix[VIEW_BOTTOM][1] = clip[7] + clip[5];
  viewMatrix[VIEW_BOTTOM][2] = clip[11] + clip[9];
  viewMatrix[VIEW_BOTTOM][3] = clip[15] + clip[13];

  // normaliser
  norm =
      sqrtf(SQR(viewMatrix[VIEW_BOTTOM][0]) + SQR(viewMatrix[VIEW_BOTTOM][1]) +
            SQR(viewMatrix[VIEW_BOTTOM][2]));
  viewMatrix[VIEW_BOTTOM][0] /= norm;
  viewMatrix[VIEW_BOTTOM][1] /= norm;
  viewMatrix[VIEW_BOTTOM][2] /= norm;
  viewMatrix[VIEW_BOTTOM][3] /= norm;

  /* plan haut*/
  viewMatrix[VIEW_TOP][0] = clip[3] - clip[1];
  viewMatrix[VIEW_TOP][1] = clip[7] - clip[5];
  viewMatrix[VIEW_TOP][2] = clip[11] - clip[9];
  viewMatrix[VIEW_TOP][3] = clip[15] - clip[13];

  // normaliser
  norm = sqrtf(SQR(viewMatrix[VIEW_TOP][0]) + SQR(viewMatrix[VIEW_TOP][1]) +
               SQR(viewMatrix[VIEW_TOP][2]));
  viewMatrix[VIEW_TOP][0] /= norm;
  viewMatrix[VIEW_TOP][1] /= norm;
  viewMatrix[VIEW_TOP][2] /= norm;
  viewMatrix[VIEW_TOP][3] /= norm;

  /* plan loin*/
  viewMatrix[VIEW_FAR][0] = clip[3] - clip[2];
  viewMatrix[VIEW_FAR][1] = clip[7] - clip[6];
  viewMatrix[VIEW_FAR][2] = clip[11] - clip[10];
  viewMatrix[VIEW_FAR][3] = clip[15] - clip[14];

  // normaliser
  norm = sqrtf(SQR(viewMatrix[VIEW_FAR][0]) + SQR(viewMatrix[VIEW_FAR][1]) +
               SQR(viewMatrix[VIEW_FAR][2]));
  viewMatrix[VIEW_FAR][0] /= norm;
  viewMatrix[VIEW_FAR][1] /= norm;
  viewMatrix[VIEW_FAR][2] /= norm;
  viewMatrix[VIEW_FAR][3] /= norm;

  /* plan proche*/
  viewMatrix[VIEW_NEAR][0] = clip[3] + clip[2];
  viewMatrix[VIEW_NEAR][1] = clip[7] + clip[6];
  viewMatrix[VIEW_NEAR][2] = clip[11] + clip[10];
  viewMatrix[VIEW_NEAR][3] = clip[15] + clip[14];

  // normaliser
  norm = sqrtf(SQR(viewMatrix[VIEW_NEAR][0]) + SQR(viewMatrix[VIEW_NEAR][1]) +
               SQR(viewMatrix[VIEW_NEAR][2]));
  viewMatrix[VIEW_NEAR][0] /= norm;
  viewMatrix[VIEW_NEAR][1] /= norm;
  viewMatrix[VIEW_NEAR][2] /= norm;
  viewMatrix[VIEW_NEAR][3] /= norm;
}

// on teste si un cube est visible (entieremen/partiellement) par la camera
bool QUADTREE::CubeViewTest(float x, float y, float z, float size) {
  int i;
  if (debugger)
    printf("CubeViewTest\n");
  // tester les six bords du cube contre l'intersections avec les plans de vue
  for (i = 0; i < 6; i++) {
    if (viewMatrix[i][0] * (x - size) + viewMatrix[i][1] * (y - size) +
            viewMatrix[i][2] * (z - size) + viewMatrix[i][3] >
        0)
      continue;
    if (viewMatrix[i][0] * (x + size) + viewMatrix[i][1] * (y - size) +
            viewMatrix[i][2] * (z - size) + viewMatrix[i][3] >
        0)
      continue;
    if (viewMatrix[i][0] * (x - size) + viewMatrix[i][1] * (y + size) +
            viewMatrix[i][2] * (z - size) + viewMatrix[i][3] >
        0)
      continue;
    if (viewMatrix[i][0] * (x + size) + viewMatrix[i][1] * (y + size) +
            viewMatrix[i][2] * (z - size) + viewMatrix[i][3] >
        0)
      continue;
    if (viewMatrix[i][0] * (x - size) + viewMatrix[i][1] * (y - size) +
            viewMatrix[i][2] * (z + size) + viewMatrix[i][3] >
        0)
      continue;
    if (viewMatrix[i][0] * (x + size) + viewMatrix[i][1] * (y - size) +
            viewMatrix[i][2] * (z + size) + viewMatrix[i][3] >
        0)
      continue;
    if (viewMatrix[i][0] * (x - size) + viewMatrix[i][1] * (y + size) +
            viewMatrix[i][2] * (z + size) + viewMatrix[i][3] >
        0)
      continue;
    if (viewMatrix[i][0] * (x + size) + viewMatrix[i][1] * (y + size) +
            viewMatrix[i][2] * (z + size) + viewMatrix[i][3] >
        0)
      continue;

    return false;
  }
  return true;
}

// decider si on sous-divise un noeud (ameliorer l'affichage si pret de la
// camera)
void QUADTREE::RefineNode(float x, float z, int edgeLength) {
  float viewDistance, f;
  float childOffset;
  int childEdgeLength;
  int blend;
  if (debugger)
    printf("RefineNode: %f,%f:%d\n", x, z, edgeLength);

  // tester les bords d'un cube contenant le vertex actuel contre l'intersection
  // avec la vue
  if (!CubeViewTest(x * scaleSize / sizeHeightMap,
                    GetScaledHeightAtPoint((int)x, (int)z) / sizeHeightMap,
                    z * scaleSize / sizeHeightMap,
                    edgeLength * scaleSize / sizeHeightMap)) //*2
  {
    // desactiver ce noeud et ne plus continuer la recursion
    quadMatrix[GetMatrixIndex((int)x, (int)z)] = 0;
    return;
  }

  // calculer la distance entre le vertex et la camera, norme L1

  viewDistance = (float)(fabs(pX - (x * scaleSize / sizeHeightMap)) +
                         fabs(pY - GetScaledHeightAtPoint((int)x + 1, (int)z) /
                                       sizeHeightMap) +
                         fabs(pZ - (z * scaleSize / sizeHeightMap)));

  // f: valeur qui decide si on subdivise un noeud ou non (selon l'article de
  // Stefan Röttger sur le quadtree algo)
  f = viewDistance /
      ((float)edgeLength * minResolution * /*/sizeHeightMap* */
       MAX((float)GetQuadMatrixData((int)x - 1, (int)z) / 3 * detailLevel,
           1.0f));
  if (debugger)
    printf("f: %f\n", f);
  if (f < 1.0f)
    blend = 255;
  else
    blend = 0;

  quadMatrix[GetMatrixIndex((int)x, (int)z)] = blend;

  if (blend != 0) {
    // si on a deja atteint le niveau de taille de noeud le plus petit: plus de
    // sousdivision possible
    if (edgeLength <= 2)
      return;

    // sinon, continuer la recursion du quadtree
    else {
      childOffset = (float)((edgeLength) >> 2);
      childEdgeLength = (edgeLength) >> 1;

      // effectuer du "refinement" recursivement
      // bas gauche
      RefineNode(x - childOffset, z - childOffset, childEdgeLength);
      // bas droite
      RefineNode(x + childOffset, z - childOffset, childEdgeLength);
      // haut gauche
      RefineNode(x - childOffset, z + childOffset, childEdgeLength);
      // haut droite
      RefineNode(x + childOffset, z + childOffset, childEdgeLength);
      return;
    }
  }
}

// rendering (pas final!) du noeud (feuille) a la position x,z
void QUADTREE::RenderNode(float x, float z, int edgeLength, bool multiTextures,
                          bool detail) {
  float texLeft, texBottom, midX, midZ, texRight, texTop;
  float childOffset;
  float edgeOffset;
  int start, code;
  int childEdgeLength;
  int ichildOffset;
  int iedgeOffset;
  int adjOffset;
  int suiteLength;
  int suitePosition;
  int blend;
  int iX, iZ;

  iX = (int)x;
  iZ = (int)z;
  if (debugger)
    printf("RenderNode: %f,%f:%d\n", x, z, edgeLength);
  // noeud marque "desactive": ne pas render
  if (GetQuadMatrixData(iX, iZ) == 0)
    return;

  // offset: puissances de 2; la position dans le Quadtree
  iedgeOffset = (edgeLength) / 2;
  edgeOffset = (edgeLength) / 2.0f;

  // offset vers voisins
  adjOffset = edgeLength; //-1;

  if (detail && !multiTextures) {
    // coord. des textures
    texLeft = ((float)fabs(x - edgeOffset) / sizeHeightMap) * repeatDetailMap;
    texBottom = ((float)fabs(z - edgeOffset) / sizeHeightMap) * repeatDetailMap;
    texRight = ((float)fabs(x + edgeOffset) / sizeHeightMap) * repeatDetailMap;
    texTop = ((float)fabs(z + edgeOffset) / sizeHeightMap) * repeatDetailMap;

    midX = ((texLeft + texRight) / 2.0f);
    midZ = ((texBottom + texTop) / 2.0f);
  }

  else // multitextures disponibles (un seul parcours) ou pas de detail souhaite
  {
    texLeft = ((float)fabs(x - edgeOffset) / sizeHeightMap);
    texBottom = ((float)fabs(z - edgeOffset) / sizeHeightMap);
    texRight = ((float)fabs(x + edgeOffset) / sizeHeightMap);
    texTop = ((float)fabs(z + edgeOffset) / sizeHeightMap);

    midX = ((texLeft + texRight) / 2.0f);
    midZ = ((texBottom + texTop) / 2.0f);
  }

  blend = GetQuadMatrixData(iX, iZ);

  if (blend > 0) {
    // noeud sur le niveau le plus petit
    if (edgeLength <= 2) {
      glBegin(GL_TRIANGLE_FAN);
      // vertex au milieu
      RenderVertex(x, z, midX, midZ, multiTextures);

      //..bas gauche
      RenderVertex(x - edgeOffset, z - edgeOffset, texLeft, texBottom,
                   multiTextures);

      // bas milieu, on n'affiche pas si voisin moins detaille (eviter "CRACKS")
      if (((iZ - adjOffset) <= 0) ||
          GetQuadMatrixData(iX, iZ - adjOffset) != 0) {
        RenderVertex(x, z - edgeOffset, midX, texBottom, multiTextures);
      }

      // bas droite
      RenderVertex(x + edgeOffset, z - edgeOffset, texRight, texBottom,
                   multiTextures);

      // milieu droite, on n'affiche pas si voisin moins detaille (eviter
      // "CRACKS")
      if (((iX + adjOffset) >= sizeHeightMap) ||
          GetQuadMatrixData(iX + adjOffset, iZ) != 0) {
        RenderVertex(x + edgeOffset, z, texRight, midZ, multiTextures);
      }

      // haut droite
      RenderVertex(x + edgeOffset, z + edgeOffset, texRight, texTop,
                   multiTextures);

      // haut milieu,on n'affiche pas si voisin moins detaille (eviter "CRACKS")
      if (((iZ + adjOffset) >= sizeHeightMap) ||
          GetQuadMatrixData(iX, iZ + adjOffset) != 0) {
        RenderVertex(x, z + edgeOffset, midX, texTop, multiTextures);
      }

      // haut gauche
      RenderVertex(x - edgeOffset, z + edgeOffset, texLeft, texTop,
                   multiTextures);

      // gauche milieu, on n'affiche pas si voisin moins detaille (eviter
      // "CRACKS")
      if (((iX - adjOffset) <= 0) ||
          GetQuadMatrixData(iX - adjOffset, iZ) != 0) {
        RenderVertex(x - edgeOffset, z, texLeft, midZ, multiTextures);
      }

      // bas gauche
      RenderVertex(x - edgeOffset, z - edgeOffset, texLeft, texBottom,
                   multiTextures);
      glEnd();
      return;
    }

    else // sur les autres niveaux: recursion
    {
      // position dans le quadtree
      ichildOffset = (edgeLength) / 4;
      childOffset = (float)ichildOffset;

      childEdgeLength = (edgeLength) / 2;

      // on calcule un code indiquant le type de suite de triangles a creer
      //.. en fonction des valeurs dans notre quadtree-matrice
      // haut droite
      code = (GetQuadMatrixData(iX + ichildOffset, iZ + ichildOffset) != 0) * 8;

      // haut gauche
      code |=
          (GetQuadMatrixData(iX - ichildOffset, iZ + ichildOffset) != 0) * 4;

      // bas gauche
      code |=
          (GetQuadMatrixData(iX - ichildOffset, iZ - ichildOffset) != 0) * 2;

      // bas droite
      code |= (GetQuadMatrixData(iX + ichildOffset, iZ - ichildOffset) != 0);

      // pas d'affichage de ce noeud, car il est compose de 4 "enfants" qui
      // seront affiches recursivement
      if (code == QT_NO_FAN) {
        // bas gauche
        RenderNode(x - childOffset, z - childOffset, childEdgeLength);
        // bas droite
        RenderNode(x + childOffset, z - childOffset, childEdgeLength);
        // haut gauche
        RenderNode(x - childOffset, z + childOffset, childEdgeLength);
        // haut droite
        RenderNode(x + childOffset, z + childOffset, childEdgeLength);
        return;
      }

      // a afficher: bas gauche, haut droite; les autres sont des enfants
      if (code == QT_LL_UR) {
        // suite de triangles en haut droite
        glBegin(GL_TRIANGLE_FAN);
        // milieu
        RenderVertex(x, z, midX, midZ, multiTextures);

        // droite milieu
        RenderVertex(x + edgeOffset, z, texRight, midZ, multiTextures);

        // haut droite
        RenderVertex(x + edgeOffset, z + edgeOffset, texRight, texTop,
                     multiTextures);

        // haut milieu
        RenderVertex(x, z + edgeOffset, midX, texTop, multiTextures);
        glEnd();

        // suite en bas gauche
        glBegin(GL_TRIANGLE_FAN);
        // milieu
        RenderVertex(x, z, midX, midZ, multiTextures);

        // gauche milieu
        RenderVertex(x - edgeOffset, z, texLeft, midZ, multiTextures);

        // bas gauche
        RenderVertex(x - edgeOffset, z - edgeOffset, texLeft, texBottom,
                     multiTextures);

        // bas milieu
        RenderVertex(x, z - edgeOffset, midX, texBottom, multiTextures);
        glEnd();

        // recursion haut gauche, bas droite
        RenderNode(x - childOffset, z + childOffset, childEdgeLength);
        RenderNode(x + childOffset, z - childOffset, childEdgeLength);
        return;
      }

      // a afficher: triangles bas-droite, haut-gauche; les autres: enfants
      if (code == QT_LR_UL) {
        // haut gauche
        glBegin(GL_TRIANGLE_FAN);
        // milieu
        RenderVertex(x, z, midX, midZ, multiTextures);

        // haut milieu
        RenderVertex(x, z + edgeOffset, midX, texTop, multiTextures);

        // haut gauche
        RenderVertex(x - edgeOffset, z + edgeOffset, texLeft, texTop,
                     multiTextures);

        // milieu gauche
        RenderVertex(x - edgeOffset, z, texLeft, midZ, multiTextures);
        glEnd();

        // bas droite
        glBegin(GL_TRIANGLE_FAN);
        // milieu
        RenderVertex(x, z, midX, midZ, multiTextures);

        // bas milieu
        RenderVertex(x, z - edgeOffset, midX, texBottom, multiTextures);

        // bas droite
        RenderVertex(x + edgeOffset, z - edgeOffset, texRight, texBottom,
                     multiTextures);

        // droite milieu
        RenderVertex(x + edgeOffset, z, texRight, midZ, multiTextures);
        glEnd();

        // recursion haut droite, bas gauche: enfants
        RenderNode(x + childOffset, z + childOffset, childEdgeLength);
        RenderNode(x - childOffset, z - childOffset, childEdgeLength);
        return;
      }

      // feuille: pas d'enfants, rendering complet a faire
      if (code == QT_COMPLETE_FAN) {
        glBegin(GL_TRIANGLE_FAN);
        // vertex au milieu
        RenderVertex(x, z, midX, midZ, multiTextures);

        //..bas gauche
        RenderVertex(x - edgeOffset, z - edgeOffset, texLeft, texBottom,
                     multiTextures);

        // bas milieu, on n'affiche pas si voisin moins detaille (eviter
        // "CRACKS")
        if (((iZ - adjOffset) <= 0) ||
            GetQuadMatrixData(iX, iZ - adjOffset) != 0) {
          RenderVertex(x, z - edgeOffset, midX, texBottom, multiTextures);
        }

        // bas droite
        RenderVertex(x + edgeOffset, z - edgeOffset, texRight, texBottom,
                     multiTextures);

        // milieu droite, on n'affiche pas si voisin moins detaille (eviter
        // "CRACKS")
        if (((iX + adjOffset) >= sizeHeightMap) ||
            GetQuadMatrixData(iX + adjOffset, iZ) != 0) {
          RenderVertex(x + edgeOffset, z, texRight, midZ, multiTextures);
        }

        // haut droite
        RenderVertex(x + edgeOffset, z + edgeOffset, texRight, texTop,
                     multiTextures);

        // haut milieu,on n'affiche pas si voisin moins detaille (eviter
        // "CRACKS")
        if (((iZ + adjOffset) >= sizeHeightMap) ||
            GetQuadMatrixData(iX, iZ + adjOffset) != 0) {
          RenderVertex(x, z + edgeOffset, midX, texTop, multiTextures);
        }

        // haut gauche
        RenderVertex(x - edgeOffset, z + edgeOffset, texLeft, texTop,
                     multiTextures);

        // gauche milieu, on n'affiche pas si voisin moins detaille (eviter
        // "CRACKS")
        if (((iX - adjOffset) <= 0) ||
            GetQuadMatrixData(iX - adjOffset, iZ) != 0) {
          RenderVertex(x - edgeOffset, z, texLeft, midZ, multiTextures);
        }

        // bas gauche
        RenderVertex(x - edgeOffset, z - edgeOffset, texLeft, texBottom,
                     multiTextures);
        glEnd();
        return;
      }

      // il reste les suites partielles a afficher; on utilise les codes pour
      // faciliter le choix de triang.  cette partie est quasiment directement
      // copie de l'article de Stefan Röttger;
      //.. les codes des suites partielles sont pas evidents.. (code binaire
      //pour representer un quadtree)  suite partielle = repartition
      // non-symmetrique entre enfants recursifs et feuilles
      start = suiteStart[code];
      suiteLength = 0;

      // l'indice du permier bit non-null du code indique la taille de la suite
      // a creer
      while (!(((long)suiteCode[code]) & (1 << suiteLength)) && suiteLength < 8)
        suiteLength++;

      // rendering
      glBegin(GL_TRIANGLE_FAN);
      // milieu recursif
      RenderVertex(x, z, midX, midZ, multiTextures);

      for (suitePosition = suiteLength; suitePosition > 0; suitePosition--) {
        switch (start) {
        // bas droite
        case QT_LR_NODE:
          // bas milieu, ne pas afficher si voisin moins detaille
          if (((iZ - adjOffset) <= 0) ||
              GetQuadMatrixData(iX, iZ - adjOffset) != 0 ||
              suitePosition == suiteLength) {
            RenderVertex(x, z - edgeOffset, midX, texBottom, multiTextures);
          }

          // bas droite
          RenderVertex(x + edgeOffset, z - edgeOffset, texRight, texBottom,
                       multiTextures);

          // droit milieu
          if (suitePosition == 1) {
            RenderVertex(x + edgeOffset, z, texRight, midZ, multiTextures);
          }
          break;

        // bas gauche
        case QT_LL_NODE:
          // gauche milieu, ne pas afficher si voisin moins detaille
          if (((x - adjOffset) <= 0) ||
              GetQuadMatrixData(iX - adjOffset, iZ) != 0 ||
              suitePosition == suiteLength) {
            RenderVertex(x - edgeOffset, z, texLeft, midZ, multiTextures);
          }

          // bas gauche
          RenderVertex(x - edgeOffset, z - edgeOffset, texLeft, texBottom,
                       multiTextures);

          // bas milieu
          if (suitePosition == 1) {
            RenderVertex(x, z - edgeOffset, midX, texBottom, multiTextures);
          }
          break;

        // haut gauche
        case QT_UL_NODE:
          // haut milieu, ne pas afficher si voisin moins detaille
          if (((iZ + adjOffset) >= sizeHeightMap) ||
              GetQuadMatrixData(iX, iZ + adjOffset) != 0 ||
              suitePosition == suiteLength) {
            RenderVertex(x, z + edgeOffset, midX, texTop, multiTextures);
          }

          // haut gauche
          RenderVertex(x - edgeOffset, z + edgeOffset, texLeft, texTop,
                       multiTextures);

          // gauche milieu
          if (suitePosition == 1) {
            RenderVertex(x - edgeOffset, z, texLeft, midZ, multiTextures);
          }
          break;

        // haut droite
        case QT_UR_NODE:
          // droit milieu, ne pas afficher si voisin moins detaille
          if (((iX + adjOffset) >= sizeHeightMap) ||
              GetQuadMatrixData(iX + adjOffset, iZ) != 0 ||
              suitePosition == suiteLength) {
            RenderVertex(x + edgeOffset, z, texRight, midZ, multiTextures);
          }

          // haut droite
          RenderVertex(x + edgeOffset, z + edgeOffset, texRight, texTop,
                       multiTextures);

          // haut milieu
          if (suitePosition == 1) {
            RenderVertex(x, z + edgeOffset, midX, texTop, multiTextures);
          }
          break;
        }
        start--;
        start &= 3;
      }
      glEnd();

      // pour les cas toujours pas traites, on continue la recursion
      for (suitePosition = (4 - suiteLength); suitePosition > 0;
           suitePosition--) {
        switch (start) {
        // bas droite
        case QT_LR_NODE:
          RenderNode(x + childOffset, z - childOffset, childEdgeLength);
          break;

        // bas gauche
        case QT_LL_NODE:
          RenderNode(x - childOffset, z - childOffset, childEdgeLength);
          break;

        // haut gauche
        case QT_UL_NODE:
          RenderNode(x - childOffset, z + childOffset, childEdgeLength);
          break;

        // haut droite
        case QT_UR_NODE:
          RenderNode(x + childOffset, z + childOffset, childEdgeLength);
          break;
        }
        start--;
        start &= 3;
      }
      return;
    }
  }
}

/*
  void bruteForce::Render(void)
  {
  float texLeft, texBottom, texTop;
  int	x, z;
  unsigned char color, shadeLow, shadeHigh;

  // optimiser en ne pas affichant terrain hors camera
  glEnable( GL_CULL_FACE );

  //la machine dispose de multitextures (dessiner plusieurs textures sur le meme
  triangle en meme temps)
  //.. et l'utilisateur veut les textures
  if( haveMultitexture && paintTextures )
  {
  glDisable( GL_BLEND );	//pas de combinaison de couleurs avec
  MULTITEXTURES,
  //.. la combi des deux textures se fait automatiquement en hardware

  //selectionner comme premiere unite de texture la texture de base (couleur
  selon hauteur) glActiveTexture( GL_TEXTURE0 ); glEnable( GL_TEXTURE_2D );
  glBindTexture( GL_TEXTURE_2D, textureColorID );

  //selectionner commer deuxieme unite de texture la texture de detail
  (structure) glActiveTexture( GL_TEXTURE1 ); glEnable( GL_TEXTURE_2D );
  glBindTexture( GL_TEXTURE_2D, textureDetailID );

  //definir la maniere dont les couleurs des triangles sont crees en fct. des
  couleurs des textures glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE,
  GL_COMBINE );		//mode de combination des deux glTexEnvi(
  GL_TEXTURE_ENV, GL_RGB_SCALE, 2 );		//augmenter la luminosite des
  couleurs

  //axe z
  for( z=0; z<sizeHeightMap-1; z++ )
  {
  //suite de triangles
  glBegin( GL_TRIANGLE_STRIP );
  //axe x
  for( x=0; x<sizeHeightMap-1; x++ )
  {
  //calculer les coordonnees sur la texture qui seront "mappees" sur le terrain
  //.. entre ces valeurs, opengl interpole
  texLeft  = ( float )x/sizeHeightMap;
  texBottom= ( float )z/sizeHeightMap;
  texTop	  = ( float )( z+1 )/sizeHeightMap;

  //creation d'ombrages en modifiant la couleur de base
  shadeLow = GetBrightnessAtPoint( x, z );
  shadeHigh= GetBrightnessAtPoint( x, z+1 );

  if (paintLighting)
  glColor3ub( ( unsigned char )( shadeLow*rLight ),
  ( unsigned char )( shadeLow*gLight ),
  ( unsigned char )( shadeLow*bLight ) );
  else
  glColor3ub( 255, 255, 255 );


  glMultiTexCoord2f( GL_TEXTURE0, texLeft, texBottom );
  glMultiTexCoord2f( GL_TEXTURE1, texLeft*repeatDetailMap,
  texBottom*repeatDetailMap ); glVertex3f( ( float )x/sizeHeightMap,
  GetScaledHeightAtPoint( x, z )/sizeHeightMap,
  ( float )z/sizeHeightMap );

  //meme chose pour deuxieme vertex
  if (paintLighting)
  glColor3ub( ( unsigned char )( shadeHigh*rLight ),
  ( unsigned char )( shadeHigh*gLight ),
  ( unsigned char )( shadeHigh*bLight ) );
  else
  glColor3ub( 255, 255, 255 );


  glMultiTexCoord2f( GL_TEXTURE0, texLeft, texTop );
  glMultiTexCoord2f( GL_TEXTURE1, texLeft*repeatDetailMap,
  texTop*repeatDetailMap ); glVertex3f( ( float )x/sizeHeightMap,
  GetScaledHeightAtPoint( x, z+1 )/sizeHeightMap,
  ( float )(z+1)/sizeHeightMap );
  }
  glEnd( );
  }

  //liberer la deuxieme texture
  glActiveTexture( GL_TEXTURE1 );
  glDisable( GL_TEXTURE_2D );
  glBindTexture( GL_TEXTURE_2D, 0 );

  //liberer la premiere texture
  glActiveTexture( GL_TEXTURE0 );
  glDisable( GL_TEXTURE_2D );
  glBindTexture( GL_TEXTURE_2D, 0 );
  }

  //la machine ne dispose pas de fonction multitextures, il faut alors faire
  deux parcours du terrain,
  //.. un premier parcours pour les textures de base (couleurs en fct.
  d'hauteur), le deuxieme pour le detail
  // .. mais seulement SI l'utilisateur souhaite des textures
  else if( paintTextures )
  {
  //PREMIER PARCOURS: couleurs
  //selectionner comme unite de texture la texture de base (couleur selon
  hauteur) glActiveTexture( GL_TEXTURE0 ); glEnable( GL_TEXTURE_2D );
  glBindTexture( GL_TEXTURE_2D, textureColorID );

  for( z=0; z<sizeHeightMap-1; z++ )
  {
  glBegin( GL_TRIANGLE_STRIP );
  for( x=0; x<sizeHeightMap-1; x++ )
  {
  //calculer la position sur la texture qui correspond a la pos. ds la carte
  // .. et afficher premier vertex
  texLeft  = ( float )x/sizeHeightMap;
  texBottom= ( float )z/sizeHeightMap;
  texTop	  = ( float )( z+1 )/sizeHeightMap;

  //creation d'ombrages en modifiant la couleur de base
  shadeLow = GetBrightnessAtPoint( x, z );
  shadeHigh= GetBrightnessAtPoint( x, z+1 );

  if (paintLighting)
  glColor3ub( ( unsigned char )( shadeLow*rLight ),
  ( unsigned char )( shadeLow*gLight ),
  ( unsigned char )( shadeLow*bLight ) );
  else
  glColor3ub( 255, 255, 255 );

  glMultiTexCoord2f( GL_TEXTURE0, texLeft, texBottom );
  glVertex3f( ( float )x/sizeHeightMap,
  GetScaledHeightAtPoint( x, z )/sizeHeightMap,
  ( float )z/sizeHeightMap );

  //..deuxieme vertex
  if (paintLighting)
  glColor3ub( ( unsigned char )( shadeHigh*rLight ),
  ( unsigned char )( shadeHigh*gLight ),
  ( unsigned char )( shadeHigh*bLight ) );
  else
  glColor3ub( 255, 255, 255 );

  glMultiTexCoord2f( GL_TEXTURE0, texLeft, texTop );
  glVertex3f( ( float )x/sizeHeightMap,
  GetScaledHeightAtPoint( x, z+1 )/sizeHeightMap,
  ( float )(z+1)/sizeHeightMap );
  }
  glEnd( );
  }

  //DEUXIEME PARCOURS: DETAIL
  //preparer la texture de detail
  glActiveTexture( GL_TEXTURE0 );
  glEnable( GL_TEXTURE_2D );
  glBindTexture( GL_TEXTURE_2D, textureDetailID );

  //activer la combinaison entre couleur existant (premier parcours) et couleur
  ajoutee (detail) glEnable( GL_BLEND ); glBlendFunc( GL_ZERO, GL_SRC_COLOR );

  for( z=0; z<sizeHeightMap-1; z++ )
  {
  glBegin( GL_TRIANGLE_STRIP );
  for( x=0; x<sizeHeightMap-1; x++ )
  {
  //calcul de coord. texture de detail
  texLeft  = ( float )x/sizeHeightMap;
  texBottom= ( float )z/sizeHeightMap;
  texTop	  = ( float )( z+1 )/sizeHeightMap;

  //premier vertex, la texture de detail est repetee (ca ne se voit quasiment
  pas)
  //creation d'ombrages en modifiant la couleur de base
  shadeLow = GetBrightnessAtPoint( x, z );
  shadeHigh= GetBrightnessAtPoint( x, z+1 );

  if (paintLighting)
  glColor3ub( ( unsigned char )( shadeLow*rLight ),
  ( unsigned char )( shadeLow*gLight ),
  ( unsigned char )( shadeLow*bLight ) );
  else
  glColor3ub( 255, 255, 255 );

  glMultiTexCoord2f( GL_TEXTURE0, texLeft*repeatDetailMap,
  texBottom*repeatDetailMap ); glVertex3f( ( float )x/sizeHeightMap,
  GetScaledHeightAtPoint( x, z )/sizeHeightMap,
  ( float )z/sizeHeightMap );

  //deuxieme vertex
  if (paintLighting)
  glColor3ub( ( unsigned char )( shadeHigh*rLight ),
  ( unsigned char )( shadeHigh*gLight ),
  ( unsigned char )( shadeHigh*bLight ) );
  else
  glColor3ub( 255, 255, 255 );

  glMultiTexCoord2f( GL_TEXTURE0, texLeft*repeatDetailMap,
  texTop*repeatDetailMap ); glVertex3f( ( float )x/sizeHeightMap,
  GetScaledHeightAtPoint( x, z+1 )/sizeHeightMap,
  ( float )(z+1)/sizeHeightMap );
  }
  glEnd( );
  }
  glDisable( GL_BLEND );
  //liberer l'unite de texture
  glActiveTexture( GL_TEXTURE0 );
  glDisable( GL_TEXTURE_2D );
  glBindTexture( GL_TEXTURE_2D, 0 );
  }
  //l'utilisateur ne souhaite pas de textures: on fait un parcours de rendering
  sans textures else
  {
  //axe z
  for( z=0; z<sizeHeightMap-1; z++ )
  {
  glBegin( GL_TRIANGLE_STRIP );
  //x-axe
  for( x=0; x<sizeHeightMap-1; x++ )
  {
  //premier coord vertex
  //choisir couleur en fct. de heightmap-valeur
  color= GetTrueHeightAtPoint( x, z );
  //ici, pas d'ombrages, mais colorisation en fct. de l'hauteur
  glColor3ub( color, color, color );

  glVertex3f( 	( float )x/sizeHeightMap,
  GetScaledHeightAtPoint( x, z )/sizeHeightMap,
  ( float )z/sizeHeightMap );

  //deuxieme coord vertex
  color= GetTrueHeightAtPoint( x, z+1 );
  glColor3ub( color, color, color );

  glVertex3f( 	( float )x/sizeHeightMap,
  GetScaledHeightAtPoint( x, z+1 )/sizeHeightMap,
  ( float )(z+1)/sizeHeightMap );
  }
  glEnd( );
  }
  }
  }

*/
