D:/Zythum/DinoKod/Landscape/SubTileDraw.cpp

//---------------------------------------------------------------------------------------------
//      This file is a part of "DinoKod".
//      Copyright © 2003 Dino Productions. All Rights Reserved.
//      
//      File                    : SubTileDraw.cpp
//      Author                  : Sebastien LEIX        sebastien.leix@wanadoo.fr
//      Date                    : 12/02/2003
//      Modification    :
//
//---------------------------------------------------------------------------------------------
#include "Common/Math3D.h"
#include "Common/Directory.h"
#include "Common/Game.h"
#include "Common/Ini.h"
#include "Render/Render.h"
#include "Landscape/TileDraw.h"
#include "Landscape/LandscapeDraw.h"
#include "Landscape/SubTileDraw.h"

//---------------------------------------------------------------------------------------------
void KSubTileDrawMipMesh::ComputeNormal()
{
        u32                     vtx;
        KVector         v0, v1, v2, Normal;
        float*          pnTri;

        pnTri = new float[m_nVertex];

        // Met a 0 toutes les normales
        for( vtx = 0; vtx < m_nVertex; vtx ++ )
        {
                m_pVertex[vtx].Normal.x = 0.0f;
                m_pVertex[vtx].Normal.y = 0.0f;
                m_pVertex[vtx].Normal.z = 0.0f;
                pnTri[vtx] = 0.0f;
        }

        // Calcul les normales en faisant la moyenne de des normales des faces qui partagent le vertex
        for( u32 mi = 0; mi < KSTMI_COUNT; mi ++ )
        {
                for( u32 idx = 0; idx < m_nIndex[mi]; idx += 3 )
                {
                        v0 = m_pVertex[ m_pIndex[mi][idx + 0] ].Position;
                        v1 = m_pVertex[ m_pIndex[mi][idx + 1] ].Position;
                        v2 = m_pVertex[ m_pIndex[mi][idx + 2] ].Position;

                        Normal = KVector::CrossProduct( v2 - v0, v1 - v0 );
                        
                        m_pVertex[ m_pIndex[mi][idx + 0] ].Normal += Normal;
                        m_pVertex[ m_pIndex[mi][idx + 1] ].Normal += Normal;
                        m_pVertex[ m_pIndex[mi][idx + 2] ].Normal += Normal;
                        
                        pnTri[m_pIndex[mi][idx + 0] ] += 1.0f;
                        pnTri[m_pIndex[mi][idx + 1] ] += 1.0f;
                        pnTri[m_pIndex[mi][idx + 2] ] += 1.0f;
                }
        }

        // Fait la moyenne et normalise
        for( vtx = 0; vtx < m_nVertex; vtx ++ )
        {
                m_pVertex[vtx].Normal /= pnTri[vtx];
                m_pVertex[vtx].Normal.Normalize();
        }

        Deletev( pnTri );
}

//---------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------
KSubTileDraw::KSubTileDraw( KTile* pTile, float PosX, float PosY )
: KSubTile( pTile, PosX, PosY )
{
        m_pMipMesh                      = NULL;
        m_CurrentMipLevel       = 0;
        m_bDraw                         = false;
        m_pIndexList            = NULL;
        m_nIndexList            = 0;
        m_nIndexListPos         = 0;
        m_hShader                       = KSHADER_NO;   
        m_pShader                       = NULL;

//      char    pTex[1024];
//      sprintf( pTex, "Maps\\%s\\Tile%ix%i\\SubTile%ix%i", pTileDraw->GetpDirectory(), (int)(pTileDraw->GetPosX() / TILE_SIZE_X), (int)(pTileDraw->GetPosY() / TILE_SIZE_Y), (int)(PosX / TILE_SUBTILE_SIZE_X), (int)(PosY / TILE_SUBTILE_SIZE_Y) );
//      m_hTestShader           = GetpTileDraw()->GetpRender()->GetpShaderBank()->LoadShader( "textures/grass" );
//      m_hTestShader           = GetpTileDraw()->GetpRender()->GetpShaderBank()->LoadShader( pTex );

        u32             SizeX = TILE_NCELLS_X/TILE_NSUBTILES_X;
        u32             SizeY = TILE_NCELLS_Y/TILE_NSUBTILES_Y;

        // Calcul le nombre de niveau de mipmesh
        KASSERT( TILE_NSUBTILES_X == TILE_NSUBTILES_Y );

//      u32 n = 1;
        m_nMipMesh = GetnMipMeshLevels();
/*      while( n < (TILE_SUBTILE_SIZE_X / TILE_CELL_SIZE_X) )
        {
                n *= 2;
                m_nMipMesh ++;
        }*/
//      m_nMipMesh -= 2;

        u32     MipValue;

        // Creation des niveaux de mipmesh
        m_pMipMesh = new KSubTileDrawMipMesh[ m_nMipMesh ];
        for( u32 m = 0; m < m_nMipMesh; m ++ )
        {
                MipValue = (u32)powf( 2, (float)m );
                //
                //      Vertex
                //
//              u32     v = 0;
//              s32     hvx, hvy;

                m_pMipMesh[m].m_nVertex = ((SizeX + 1) * (SizeY + 1)) / MipValue;
                m_pMipMesh[m].m_pVertex = new KVertex2[ m_pMipMesh[m].m_nVertex ];

                // La construction des vertex est faite d'un seul coup plus tard.

/*              for( u32 vy = 0; vy < SizeY + 1; vy += MipValue )
                {
                        for( u32 vx = 0; vx < SizeX + 1; vx += MipValue )
                        {
                                hvx = (s32)(m_PosX / TILE_CELL_SIZE_X) + (s32)vx;
                                hvy = (s32)(m_PosY / TILE_CELL_SIZE_Y) + (s32)vy;

                                // TODO : liaison entre tiles
                                if( hvx >= TILE_NCELLS_X ) hvx = TILE_NCELLS_X - 1;
                                if( hvy >= TILE_NCELLS_Y ) hvy = TILE_NCELLS_Y - 1;

                                m_pMipMesh[m].m_pVertex[v].Position     = KVector( (float)m_PosX + vx * TILE_CELL_SIZE_X, (float)m_PosY + vy * TILE_CELL_SIZE_Y, GetpTileDraw()->GetHeight( hvx, hvy ) );
                                
                                float r = ((float)rand() / (float)RAND_MAX);
                                float g = ((float)rand() / (float)RAND_MAX);
                                float b = ((float)rand() / (float)RAND_MAX);
                                
                                u8 rr = 200 + (u8)(50.0f * r);
                                u8 gg = 200 + (u8)(50.0f * g);
                                u8 bb = 200 + (u8)(50.0f * b);

                                m_pMipMesh[m].m_pVertex[v].Color        = KRGB( rr, gg ,bb );//KRGB( 255, 255, 255 );
                                m_pMipMesh[m].m_pVertex[v].Specular     = KRGB( 0, 0, 0 );
                                m_pMipMesh[m].m_pVertex[v].tu           = (float)vx;//(((vx / MipValue) % 2) * MipValue);
                                m_pMipMesh[m].m_pVertex[v].tv           = (float)vy;//(((vy / MipValue) % 2) * MipValue);
                                v ++;
                        }
                }
*/
                //
                //      Index
                //
                u32     idx;
                u32 ix, iy;
                u32     i;

                u32 IndexSizeX = SizeX / MipValue;
                u32 IndexSizeY = SizeY / MipValue;

                //
                //      Center
                //
                if( ( IndexSizeX > 2 ) && ( IndexSizeY > 2 ) )
                {
                        m_pMipMesh[m].m_nIndex[KSTMI_CENTER] = (IndexSizeX - 2) * (IndexSizeY - 2) * 6;
                        m_pMipMesh[m].m_pIndex[KSTMI_CENTER] = new KINDEX[ m_pMipMesh[m].m_nIndex[KSTMI_CENTER] ];

                        i = 0;
                        for( iy = 1; iy < IndexSizeY - 1; iy ++  )
                        {
                                for( ix = 1; ix < IndexSizeX - 1; ix ++ )
                                {
                                        idx = (iy * (IndexSizeX + 1) + ix);

                                        // Triangle 1
                                        m_pMipMesh[m].m_pIndex[KSTMI_CENTER][i + 0] = (KINDEX)(idx);
                                        m_pMipMesh[m].m_pIndex[KSTMI_CENTER][i + 1] = (KINDEX)(idx + IndexSizeX + 1);
                                        m_pMipMesh[m].m_pIndex[KSTMI_CENTER][i + 2] = (KINDEX)(idx + 1);

                                        // Triangle 2
                                        m_pMipMesh[m].m_pIndex[KSTMI_CENTER][i + 3] = (KINDEX)(idx + 1);
                                        m_pMipMesh[m].m_pIndex[KSTMI_CENTER][i + 4] = (KINDEX)(idx + IndexSizeX + 1);
                                        m_pMipMesh[m].m_pIndex[KSTMI_CENTER][i + 5] = (KINDEX)(idx + IndexSizeX + 2);
                                        i += 6;
                                }
                        }
                        KASSERT( i == m_pMipMesh[m].m_nIndex[KSTMI_CENTER] );
                }
        
                //
                //      Center niveau mipmesh le plus eleve 1x1
                //
                if( ( IndexSizeX == 1 ) && ( IndexSizeY == 1 ) )
                {
                        m_pMipMesh[m].m_nIndex[KSTMI_CENTER] = 6;
                        m_pMipMesh[m].m_pIndex[KSTMI_CENTER] = new KINDEX[ m_pMipMesh[m].m_nIndex[KSTMI_CENTER] ];

                        i = 0;

                        // Triangle 1
                        m_pMipMesh[m].m_pIndex[KSTMI_CENTER][i + 0] = (KINDEX)0;
                        m_pMipMesh[m].m_pIndex[KSTMI_CENTER][i + 1] = (KINDEX)2;
                        m_pMipMesh[m].m_pIndex[KSTMI_CENTER][i + 2] = (KINDEX)3;

                        // Triangle 2
                        m_pMipMesh[m].m_pIndex[KSTMI_CENTER][i + 3] = (KINDEX)0;
                        m_pMipMesh[m].m_pIndex[KSTMI_CENTER][i + 4] = (KINDEX)3;
                        m_pMipMesh[m].m_pIndex[KSTMI_CENTER][i + 5] = (KINDEX)1;

                        i += 6;

                        KASSERT( i == m_pMipMesh[m].m_nIndex[KSTMI_CENTER] );
                }

                //
                // Up
                //
                if( IndexSizeX > 1 )
                {
                        // nombre de triangle dans la bande : (IndexSizeX - 2) * 2
                        // nombre de triangle sur les coté      : 2
                        m_pMipMesh[m].m_nIndex[KSTMI_UP] = ((IndexSizeX - 2) * 2 + 2) * 3;
                        m_pMipMesh[m].m_pIndex[KSTMI_UP] = new KINDEX[ m_pMipMesh[m].m_nIndex[KSTMI_UP] ];

                        i = 0;

                        // Triangle coté gauche
                        m_pMipMesh[m].m_pIndex[KSTMI_UP][i + 0] = (KINDEX)(IndexSizeX * (IndexSizeX + 1));
                        m_pMipMesh[m].m_pIndex[KSTMI_UP][i + 1] = (KINDEX)(IndexSizeX * (IndexSizeX + 1) + 1);
                        m_pMipMesh[m].m_pIndex[KSTMI_UP][i + 2] = (KINDEX)(IndexSizeX * IndexSizeX);
                                                                                                                                
                        // Triangle coté droit                                                          
                        m_pMipMesh[m].m_pIndex[KSTMI_UP][i + 3] = (KINDEX)((IndexSizeX + 1) * (IndexSizeX + 1) - 2);
                        m_pMipMesh[m].m_pIndex[KSTMI_UP][i + 4] = (KINDEX)((IndexSizeX + 1) * (IndexSizeX + 1) - 1);
                        m_pMipMesh[m].m_pIndex[KSTMI_UP][i + 5] = (KINDEX)((IndexSizeX) * (IndexSizeX + 1) - 2);

                        i += 6;

                        // Bande
                        for( ix = 1; ix < IndexSizeX - 1; ix += 1 )
                        {
                                idx = (IndexSizeY - 1) * (IndexSizeX + 1) + ix;

                                // Triangle 1
                                m_pMipMesh[m].m_pIndex[KSTMI_UP][i + 0] = (KINDEX)(idx);
                                m_pMipMesh[m].m_pIndex[KSTMI_UP][i + 1] = (KINDEX)(idx + IndexSizeX + 1);
                                m_pMipMesh[m].m_pIndex[KSTMI_UP][i + 2] = (KINDEX)(idx + 1);
                                                                                                                                        
                                // Triangle 2                                                                           
                                m_pMipMesh[m].m_pIndex[KSTMI_UP][i + 3] = (KINDEX)(idx + 1);
                                m_pMipMesh[m].m_pIndex[KSTMI_UP][i + 4] = (KINDEX)(idx + IndexSizeX + 1);
                                m_pMipMesh[m].m_pIndex[KSTMI_UP][i + 5] = (KINDEX)(idx + IndexSizeX + 2);
        
                                i += 6;
                        }

                        KASSERT( i == m_pMipMesh[m].m_nIndex[KSTMI_UP] );
                }

                //
                //      Mip Up
                //
                if( IndexSizeX > 1 )
                {
                        // nombre de triangle dans la bande haute       : (IndexSizeX / 2)
                        // nombre de triangle dans la bande basse       : (IndexSizeX - 2)
                        m_pMipMesh[m].m_nIndex[KSTMI_MIP_UP] = (IndexSizeX / 2) * 3 + (IndexSizeX - 2) * 3;
                        m_pMipMesh[m].m_pIndex[KSTMI_MIP_UP] = new KINDEX[ m_pMipMesh[m].m_nIndex[KSTMI_MIP_UP] ];
                        
                        i = 0;

                        // Bande Haute
                        for( ix = 0; ix < IndexSizeX; ix += 2 )
                        {
                                idx = ix + (IndexSizeX + 1) * IndexSizeY;

                                // Triangle 1
                                m_pMipMesh[m].m_pIndex[KSTMI_MIP_UP][i + 0] = (KINDEX)(idx);
                                m_pMipMesh[m].m_pIndex[KSTMI_MIP_UP][i + 1] = (KINDEX)(idx + 2);
                                m_pMipMesh[m].m_pIndex[KSTMI_MIP_UP][i + 2] = (KINDEX)(idx - IndexSizeX);
        
                                i += 3;
                        }
                        // Bande Basse
                        for( ix = 1; ix < IndexSizeX - 1; ix += 2 )
                        {
                                idx = ix + (IndexSizeX + 1) * IndexSizeY;

                                // Triangle 1
                                m_pMipMesh[m].m_pIndex[KSTMI_MIP_UP][i + 0] = (KINDEX)(idx - IndexSizeX - 1);
                                m_pMipMesh[m].m_pIndex[KSTMI_MIP_UP][i + 1] = (KINDEX)(idx + 1);
                                m_pMipMesh[m].m_pIndex[KSTMI_MIP_UP][i + 2] = (KINDEX)(idx - IndexSizeX);
        
                                // Triangle 2
                                m_pMipMesh[m].m_pIndex[KSTMI_MIP_UP][i + 3] = (KINDEX)(idx - IndexSizeX);
                                m_pMipMesh[m].m_pIndex[KSTMI_MIP_UP][i + 4] = (KINDEX)(idx + 1);
                                m_pMipMesh[m].m_pIndex[KSTMI_MIP_UP][i + 5] = (KINDEX)(idx - IndexSizeX + 1);
        
                                i += 6;
                        }

                        KASSERT( i == m_pMipMesh[m].m_nIndex[KSTMI_MIP_UP] );
                }

                //
                //      Down
                //
                if( IndexSizeX > 1 )
                {
                        // nombre de triangle dans la bande : (IndexSizeX - 2) * 2
                        // nombre de triangle sur les coté      : 2
                        m_pMipMesh[m].m_nIndex[KSTMI_DOWN] = ((IndexSizeX - 2) * 2 + 2) * 3;
                        m_pMipMesh[m].m_pIndex[KSTMI_DOWN] = new KINDEX[ m_pMipMesh[m].m_nIndex[KSTMI_DOWN] ];

                        i = 0;

                        // Triangle coté gauche
                        m_pMipMesh[m].m_pIndex[KSTMI_DOWN][i + 0] = (KINDEX)(0);
                        m_pMipMesh[m].m_pIndex[KSTMI_DOWN][i + 1] = (KINDEX)(IndexSizeX + 2);
                        m_pMipMesh[m].m_pIndex[KSTMI_DOWN][i + 2] = (KINDEX)(1);
                                                                                                                                
                        // Triangle coté droit                                                          
                        m_pMipMesh[m].m_pIndex[KSTMI_DOWN][i + 3] = (KINDEX)(IndexSizeX - 1);
                        m_pMipMesh[m].m_pIndex[KSTMI_DOWN][i + 4] = (KINDEX)(IndexSizeX + IndexSizeX);
                        m_pMipMesh[m].m_pIndex[KSTMI_DOWN][i + 5] = (KINDEX)(IndexSizeX);

                        i += 6;

                        // Bande
                        for( ix = 1; ix < IndexSizeX - 1; ix += 1 )
                        {
                                idx = ix;

                                // Triangle 1
                                m_pMipMesh[m].m_pIndex[KSTMI_DOWN][i + 0] = (KINDEX)(idx);
                                m_pMipMesh[m].m_pIndex[KSTMI_DOWN][i + 1] = (KINDEX)(idx + IndexSizeX + 1);
                                m_pMipMesh[m].m_pIndex[KSTMI_DOWN][i + 2] = (KINDEX)(idx + 1);
                                                                                                                                        
                                // Triangle 2                                                                           
                                m_pMipMesh[m].m_pIndex[KSTMI_DOWN][i + 3] = (KINDEX)(idx + 1);
                                m_pMipMesh[m].m_pIndex[KSTMI_DOWN][i + 4] = (KINDEX)(idx + IndexSizeX + 1);
                                m_pMipMesh[m].m_pIndex[KSTMI_DOWN][i + 5] = (KINDEX)(idx + IndexSizeX + 2);
        
                                i += 6;
                        }

                        KASSERT( i == m_pMipMesh[m].m_nIndex[KSTMI_DOWN] );
                }

                //
                //      Mip Down
                //
                if( IndexSizeX > 1 )
                {
                        // nombre de triangle dans la bande haute       : (IndexSizeX - 2)
                        // nombre de triangle dans la bande basse       : (IndexSizeX / 2)
                        m_pMipMesh[m].m_nIndex[KSTMI_MIP_DOWN] = (IndexSizeX / 2) * 3 + (IndexSizeX - 2) * 3;
                        m_pMipMesh[m].m_pIndex[KSTMI_MIP_DOWN] = new KINDEX[ m_pMipMesh[m].m_nIndex[KSTMI_MIP_DOWN] ];
                        
                        i = 0;

                        // Bande Basse
                        for( ix = 0; ix < IndexSizeX; ix += 2 )
                        {
                                idx = ix;

                                // Triangle 1
                                m_pMipMesh[m].m_pIndex[KSTMI_MIP_DOWN][i + 0] = (KINDEX)(idx);
                                m_pMipMesh[m].m_pIndex[KSTMI_MIP_DOWN][i + 1] = (KINDEX)(idx + IndexSizeX + 2);
                                m_pMipMesh[m].m_pIndex[KSTMI_MIP_DOWN][i + 2] = (KINDEX)(idx + 2);
        
                                i += 3;
                        }
                        // Bande Haute
                        for( ix = 1; ix < IndexSizeX - 1; ix += 2 )
                        {
                                idx = ix;

                                // Triangle 1
                                m_pMipMesh[m].m_pIndex[KSTMI_MIP_DOWN][i + 0] = (KINDEX)(idx + 1);
                                m_pMipMesh[m].m_pIndex[KSTMI_MIP_DOWN][i + 1] = (KINDEX)(idx + IndexSizeX + 1);
                                m_pMipMesh[m].m_pIndex[KSTMI_MIP_DOWN][i + 2] = (KINDEX)(idx + IndexSizeX + 2);
        
                                // Triangle 2
                                m_pMipMesh[m].m_pIndex[KSTMI_MIP_DOWN][i + 3] = (KINDEX)(idx + 1);
                                m_pMipMesh[m].m_pIndex[KSTMI_MIP_DOWN][i + 4] = (KINDEX)(idx + IndexSizeX + 2);
                                m_pMipMesh[m].m_pIndex[KSTMI_MIP_DOWN][i + 5] = (KINDEX)(idx + IndexSizeX + 3);
        
                                i += 6;
                        }

                        KASSERT( i == m_pMipMesh[m].m_nIndex[KSTMI_MIP_DOWN] );
                }

                //
                // Left
                //
                if( IndexSizeY > 1 )
                {
                        // nombre de triangle dans la bande : (IndexSizeY - 2) * 2
                        // nombre de triangle sur les coté      : 2
                        m_pMipMesh[m].m_nIndex[KSTMI_LEFT] = ((IndexSizeY - 2) * 2 + 2) * 3;
                        m_pMipMesh[m].m_pIndex[KSTMI_LEFT] = new KINDEX[ m_pMipMesh[m].m_nIndex[KSTMI_LEFT] ];

                        i = 0;

                        // Triangle coté gauche
                        m_pMipMesh[m].m_pIndex[KSTMI_LEFT][i + 0] = (KINDEX)(0);
                        m_pMipMesh[m].m_pIndex[KSTMI_LEFT][i + 1] = (KINDEX)(IndexSizeX + 1);
                        m_pMipMesh[m].m_pIndex[KSTMI_LEFT][i + 2] = (KINDEX)(IndexSizeX + 2);
                                                                                                                                
                        // Triangle coté droit                                                          
                        m_pMipMesh[m].m_pIndex[KSTMI_LEFT][i + 3] = (KINDEX)(IndexSizeX * IndexSizeY - 1);
                        m_pMipMesh[m].m_pIndex[KSTMI_LEFT][i + 4] = (KINDEX)(IndexSizeX * (IndexSizeY + 1));
                        m_pMipMesh[m].m_pIndex[KSTMI_LEFT][i + 5] = (KINDEX)(IndexSizeX * IndexSizeY);

                        i += 6;

                        // Bande
                        for( iy = 1; iy < IndexSizeY - 1; iy += 1 )
                        {
                                idx = iy * (IndexSizeX + 1);

                                // Triangle 1
                                m_pMipMesh[m].m_pIndex[KSTMI_LEFT][i + 0] = (KINDEX)(idx);
                                m_pMipMesh[m].m_pIndex[KSTMI_LEFT][i + 1] = (KINDEX)(idx + IndexSizeY + 1);
                                m_pMipMesh[m].m_pIndex[KSTMI_LEFT][i + 2] = (KINDEX)(idx + 1);
                                                                                                                                        
                                // Triangle 2                                                                           
                                m_pMipMesh[m].m_pIndex[KSTMI_LEFT][i + 3] = (KINDEX)(idx + 1);
                                m_pMipMesh[m].m_pIndex[KSTMI_LEFT][i + 4] = (KINDEX)(idx + IndexSizeY + 1);
                                m_pMipMesh[m].m_pIndex[KSTMI_LEFT][i + 5] = (KINDEX)(idx + IndexSizeY + 2);
        
                                i += 6;
                        }

                        KASSERT( i == m_pMipMesh[m].m_nIndex[KSTMI_LEFT] );
                }

                //
                //      Mip Left
                //
                if( IndexSizeY > 1 )
                {
                        // nombre de triangle dans la bande haute       : (IndexSizeY / 2)
                        // nombre de triangle dans la bande basse       : (IndexSizeY - 2)
                        m_pMipMesh[m].m_nIndex[KSTMI_MIP_LEFT] = (IndexSizeY / 2) * 3 + (IndexSizeY - 2) * 3;
                        m_pMipMesh[m].m_pIndex[KSTMI_MIP_LEFT] = new KINDEX[ m_pMipMesh[m].m_nIndex[KSTMI_MIP_LEFT] ];
                        
                        i = 0;

                        // Bande Haute
                        for( iy = 0; iy < IndexSizeY; iy += 2 )
                        {
                                idx = iy * (IndexSizeX + 1);

                                // Triangle 1
                                m_pMipMesh[m].m_pIndex[KSTMI_MIP_LEFT][i + 0] = (KINDEX)(idx);
                                m_pMipMesh[m].m_pIndex[KSTMI_MIP_LEFT][i + 1] = (KINDEX)(idx + (IndexSizeX + 1) * 2);
                                m_pMipMesh[m].m_pIndex[KSTMI_MIP_LEFT][i + 2] = (KINDEX)(idx + IndexSizeX + 2);
        
                                i += 3;
                        }
                        // Bande Basse
                        for( iy = 1; iy < IndexSizeY - 1; iy += 2 )
                        {
                                idx = iy * (IndexSizeX + 1);

                                // Triangle 1
                                m_pMipMesh[m].m_pIndex[KSTMI_MIP_LEFT][i + 0] = (KINDEX)(idx + 1);
                                m_pMipMesh[m].m_pIndex[KSTMI_MIP_LEFT][i + 1] = (KINDEX)(idx + IndexSizeX + 1);
                                m_pMipMesh[m].m_pIndex[KSTMI_MIP_LEFT][i + 2] = (KINDEX)(idx + IndexSizeX + 2);
        
                                // Triangle 2
                                m_pMipMesh[m].m_pIndex[KSTMI_MIP_LEFT][i + 3] = (KINDEX)(idx + IndexSizeX + 1);
                                m_pMipMesh[m].m_pIndex[KSTMI_MIP_LEFT][i + 4] = (KINDEX)(idx + (IndexSizeX + 1 ) * 2 + 1);
                                m_pMipMesh[m].m_pIndex[KSTMI_MIP_LEFT][i + 5] = (KINDEX)(idx + IndexSizeX + 2);
        
                                i += 6;
                        }

                        KASSERT( i == m_pMipMesh[m].m_nIndex[KSTMI_MIP_LEFT] );
                }

                //
                //      Right
                //
                if( IndexSizeY > 1 )
                {
                        // nombre de triangle dans la bande : (IndexSizeY - 2) * 2
                        // nombre de triangle sur les coté      : 2
                        m_pMipMesh[m].m_nIndex[KSTMI_RIGHT] = ((IndexSizeY - 2) * 2 + 2) * 3;
                        m_pMipMesh[m].m_pIndex[KSTMI_RIGHT] = new KINDEX[ m_pMipMesh[m].m_nIndex[KSTMI_RIGHT] ];

                        i = 0;

                        // Triangle coté gauche
                        m_pMipMesh[m].m_pIndex[KSTMI_RIGHT][i + 0] = (KINDEX)(IndexSizeX);
                        m_pMipMesh[m].m_pIndex[KSTMI_RIGHT][i + 1] = (KINDEX)(IndexSizeX * 2);
                        m_pMipMesh[m].m_pIndex[KSTMI_RIGHT][i + 2] = (KINDEX)(IndexSizeX * 2 + 1);
                                                                                                                                 
                        // Triangle coté droit                                                           
                        m_pMipMesh[m].m_pIndex[KSTMI_RIGHT][i + 3] = (KINDEX)((IndexSizeX + 1) * IndexSizeY - 2);
                        m_pMipMesh[m].m_pIndex[KSTMI_RIGHT][i + 4] = (KINDEX)((IndexSizeX + 1) * (IndexSizeY + 1) - 1);
                        m_pMipMesh[m].m_pIndex[KSTMI_RIGHT][i + 5] = (KINDEX)((IndexSizeX + 1) * IndexSizeY - 1);

                        i += 6;

                        // Bande
                        for( iy = 1; iy < IndexSizeY - 1; iy += 1 )
                        {
                                idx = iy * (IndexSizeX + 1) + IndexSizeX - 1;

                                // Triangle 1
                                m_pMipMesh[m].m_pIndex[KSTMI_RIGHT][i + 0] = (KINDEX)(idx);
                                m_pMipMesh[m].m_pIndex[KSTMI_RIGHT][i + 1] = (KINDEX)(idx + IndexSizeY + 1);
                                m_pMipMesh[m].m_pIndex[KSTMI_RIGHT][i + 2] = (KINDEX)(idx + 1);
                                                                                                                                          
                                // Triangle 2                                                                             
                                m_pMipMesh[m].m_pIndex[KSTMI_RIGHT][i + 3] = (KINDEX)(idx + 1);
                                m_pMipMesh[m].m_pIndex[KSTMI_RIGHT][i + 4] = (KINDEX)(idx + IndexSizeY + 1);
                                m_pMipMesh[m].m_pIndex[KSTMI_RIGHT][i + 5] = (KINDEX)(idx + IndexSizeY + 2);
        
                                i += 6;
                        }

                        KASSERT( i == m_pMipMesh[m].m_nIndex[KSTMI_RIGHT] );
                }

                //
                //      Mip Right
                //
                if( IndexSizeY > 1 )
                {
                        // nombre de triangle dans la bande haute       : (IndexSizeY - 2)
                        // nombre de triangle dans la bande basse       : (IndexSizeY / 2)
                        m_pMipMesh[m].m_nIndex[KSTMI_MIP_RIGHT] = (IndexSizeY / 2) * 3 + (IndexSizeY - 2) * 3;
                        m_pMipMesh[m].m_pIndex[KSTMI_MIP_RIGHT] = new KINDEX[ m_pMipMesh[m].m_nIndex[KSTMI_MIP_RIGHT] ];
                        
                        i = 0;

                        // Bande Basse
                        for( iy = 0; iy < IndexSizeY; iy += 2 )
                        {
                                idx = iy * (IndexSizeX + 1) + IndexSizeX;

                                // Triangle 1
                                m_pMipMesh[m].m_pIndex[KSTMI_MIP_RIGHT][i + 0] = (KINDEX)(idx);
                                m_pMipMesh[m].m_pIndex[KSTMI_MIP_RIGHT][i + 1] = (KINDEX)(idx + IndexSizeX);
                                m_pMipMesh[m].m_pIndex[KSTMI_MIP_RIGHT][i + 2] = (KINDEX)(idx + IndexSizeX * 2 + 2);
        
                                i += 3;
                        }
                        // Bande Haute
                        for( iy = 1; iy < IndexSizeY - 1; iy += 2 )
                        {
                                idx = iy * (IndexSizeX + 1) + IndexSizeX;

                                // Triangle 1
                                m_pMipMesh[m].m_pIndex[KSTMI_MIP_RIGHT][i + 0] = (KINDEX)(idx - 1);
                                m_pMipMesh[m].m_pIndex[KSTMI_MIP_RIGHT][i + 1] = (KINDEX)(idx + IndexSizeX);
                                m_pMipMesh[m].m_pIndex[KSTMI_MIP_RIGHT][i + 2] = (KINDEX)(idx + IndexSizeX + 1);
        
                                // Triangle 2
                                m_pMipMesh[m].m_pIndex[KSTMI_MIP_RIGHT][i + 3] = (KINDEX)(idx + IndexSizeX);
                                m_pMipMesh[m].m_pIndex[KSTMI_MIP_RIGHT][i + 4] = (KINDEX)(idx + (IndexSizeX * 2) + 1);
                                m_pMipMesh[m].m_pIndex[KSTMI_MIP_RIGHT][i + 5] = (KINDEX)(idx + IndexSizeX + 1);
        
                                i += 6;
                        }

                        KASSERT( i == m_pMipMesh[m].m_nIndex[KSTMI_MIP_RIGHT] );
                }
        }

        //
        //      Contruit les vertex a partir de la hauteur
        //
        BuildVertex();

        // Buffer qui recevra les indices pour la subtile entière
        m_nIndexList = 0;
        for( u32 mi = 0; mi < KSTMI_COUNT; mi ++ )
                m_nIndexList += m_pMipMesh[0].m_nIndex[mi];
        m_pIndexList = new KINDEX[ m_nIndexList ];

        // Calcule la bounding box
        ComputeBBox();
}

//---------------------------------------------------------------------------------------------
KSubTileDraw::~KSubTileDraw()
{
        for( u32 m = 0; m < m_nMipMesh; m ++ )
        {
                if( m_pMipMesh[m].m_pVertex )
                        Deletev( m_pMipMesh[m].m_pVertex );

                if( m_pIndexList )
                        Deletev( m_pIndexList );

                for( u32 i = 0; i < KSTMI_COUNT; i ++ )
                {
                        if( m_pMipMesh[m].m_pIndex[i] )
                                Deletev( m_pMipMesh[m].m_pIndex[i] );
                }
        }
        Deletev( m_pMipMesh );
}

//---------------------------------------------------------------------------------------------
bool KSubTileDraw::Init( KRender* pRender )
{
//      char    pTex[1024];
//      sprintf( pTex, "Maps\\%s\\Tile%ix%i\\SubTile%ix%i", pTileDraw->GetpDirectory(), (int)(pTileDraw->GetPosX() / TILE_SIZE_X), (int)(pTileDraw->GetPosY() / TILE_SIZE_Y), (int)(PosX / TILE_SUBTILE_SIZE_X), (int)(PosY / TILE_SUBTILE_SIZE_Y) );
//      m_hShader = GetpTileDraw()->GetpRender()->GetpShaderBank()->LoadShader( "textures/grass" );
//      m_hTestShader           = GetpTileDraw()->GetpRender()->GetpShaderBank()->LoadShader( pTex );
        m_hShader = GetpTileDraw()->GetpRender()->GetpShaderBank()->CreateShader( "SubTile" );
        m_pShader = GetpTileDraw()->GetpRender()->GetpShaderBank()->GetpShader( m_hShader );
        
        ReloadShader();
//      KShaderStage*   pStage = new KShaderStage();
//      pStage->m_pMapName = strdup( "

        return true;
}

//---------------------------------------------------------------------------------------------
void KSubTileDraw::ReloadShader()
{
        m_pShader->FlushAllStages();

        if( m_pTextureName )
        {
//              char    pTex[1024];
                
//              KStr sPath = g_Directory.GetPath( KStr( "Maps" ) );
//              sprintf( pTex, "%sSubTiles/%s", (char*)sPath, m_pTextureName );
                m_pShader->AddStage( m_pTextureName );
                
/*              sprintf( pTex, "%sSubTiles/Details", (char*)sPath );
                m_pShader->AddStage( pTex, KRBLEND_ZERO, KRBLEND_SRC );
                m_pShader->m_StageList[1]->m_TexCoordIndex = 1;*/
                
                u32             Size = g_pGame->GetpIniFile()->ReadInt( "LANDSCAPE", "TextureSize", 1 );
                m_pShader->LoadTextures( Size );
        }
}

//---------------------------------------------------------------------------------------------
void KSubTileDraw::BuildVertex()
{
        u32             MipValue;
//      s32             hvx, hvy;
        u32             vtx;

        u32             SizeX = TILE_NCELLS_X/TILE_NSUBTILES_X;
        u32             SizeY = TILE_NCELLS_Y/TILE_NSUBTILES_Y;

        s32             CellX = (s32)(GetpTileDraw()->GetPosX() + m_PosX) / TILE_CELL_SIZE_X;
        s32             CellY = (s32)(GetpTileDraw()->GetPosY() + m_PosY) / TILE_CELL_SIZE_Y;

        float   u, v;
        u32             Angle;

        KTILEHEIGHT             Height;

        for( u32 m = 0; m < m_nMipMesh; m ++ )
        {
                // Calcule l'increment de mipmap
                MipValue = (u32)powf( 2, (float)m );

                vtx = 0;
                for( u32 vy = 0; vy < SizeY + 1; vy += MipValue )
                {
                        for( u32 vx = 0; vx < SizeX + 1; vx += MipValue )
                        {
//                              hvx = (s32)(m_PosX / TILE_CELL_SIZE_X) + (s32)vx;
//                              hvy = (s32)(m_PosY / TILE_CELL_SIZE_Y) + (s32)vy;

                                // TODO : liaison entre tiles
//                              if( hvx >= TILE_NCELLS_X ) hvx = TILE_NCELLS_X - 1;
//                              if( hvy >= TILE_NCELLS_Y ) hvy = TILE_NCELLS_Y - 1;

                                // Recupere la hauteur
                                GetpTileDraw()->GetpLandscape()->GetCellHeight( CellX + vx, CellY + vy, &Height );

                                m_pMipMesh[m].m_pVertex[vtx].Position   = KVector( (float)m_PosX + vx * TILE_CELL_SIZE_X, (float)m_PosY + vy * TILE_CELL_SIZE_Y, (float)Height );
                                
                                float r = ((float)rand() / (float)RAND_MAX);
                                float g = ((float)rand() / (float)RAND_MAX);
                                float b = ((float)rand() / (float)RAND_MAX);
                                
                                u8 rr = 200 + (u8)(50.0f * r);
                                u8 gg = 200 + (u8)(50.0f * g);
                                u8 bb = 200 + (u8)(50.0f * b);

//                              m_pMipMesh[m].m_pVertex[vtx].Color      = KRGB( rr, gg ,bb );//KRGB( 255, 255, 255 );
//                              m_pMipMesh[m].m_pVertex[vtx].Specular   = KRGB( 0, 0, 0 );
                                m_pMipMesh[m].m_pVertex[vtx].Normal     = GetNormal( CellX + vx, CellY + vy );

//                              m_pMipMesh[m].m_pVertex[vtx].tu         = (float)vx;//(((vx / MipValue) % 2) * MipValue);
//                              m_pMipMesh[m].m_pVertex[vtx].tv         = (float)vy;//(((vy / MipValue) % 2) * MipValue);
                                Angle = (u32)m_MapAngle / 90;
                                Angle *= 90;
                                Angle %= 360;

                                switch( Angle )
                                {
                                case 0:
                                        u = (float)(vx / (float)SizeX);
                                        v = (float)(vy / (float)SizeY);
                                        break;
                                case 90:
                                        u = (float)(vy / (float)SizeY);
                                        v = (float)(vx / (float)SizeX);
                                        break;
                                case 180:
                                        u = 1.0f - (float)(vx / (float)SizeX);
                                        v = 1.0f - (float)(vy / (float)SizeY);
                                        break;
                                case 270:
                                        u = 1.0f - (float)(vy / (float)SizeY);
                                        v = 1.0f - (float)(vx / (float)SizeX);
                                        break;
                                }

                                m_pMipMesh[m].m_pVertex[vtx].tu1        = u;//(float)(vx / (float)SizeX);
                                m_pMipMesh[m].m_pVertex[vtx].tv1        = v;//(float)(vy / (float)SizeY);
                                m_pMipMesh[m].m_pVertex[vtx].tu2        = (float)(vx);// / (float)SizeX);
                                m_pMipMesh[m].m_pVertex[vtx].tv2        = (float)(vy);// / (float)SizeY);
                                vtx ++;
                        }
                }

                // Calcul les normales
//              m_pMipMesh[m].ComputeNormal();
        }
}

//---------------------------------------------------------------------------------------------
KVector KSubTileDraw::GetNormal( s32 CellX, s32 CellY )
{
        KTILEHEIGHT             h0, h1, h2, h3, h4, h5, h6;
        bool                    b0, b1, b2, b3, b4, b5, b6;
        KVector                 v0, v1, v2, v3, v4, v5, v6;
        KVector                 Normal( 0.0f, 0.0f, 0.0f );
        float                   n = 0;

        // Recupère les 5 hauteurs
        b0 = GetpTileDraw()->GetpLandscape()->GetCellHeight( CellX              , CellY         , &h0 );
        b1 = GetpTileDraw()->GetpLandscape()->GetCellHeight( CellX              , CellY + 1     , &h1 );
        b2 = GetpTileDraw()->GetpLandscape()->GetCellHeight( CellX + 1  , CellY         , &h2 );
        b3 = GetpTileDraw()->GetpLandscape()->GetCellHeight( CellX              , CellY - 1     , &h3 );
        b4 = GetpTileDraw()->GetpLandscape()->GetCellHeight( CellX - 1  , CellY         , &h4 );
        b5 = GetpTileDraw()->GetpLandscape()->GetCellHeight( CellX + 1  , CellY - 1     , &h5 );
        b6 = GetpTileDraw()->GetpLandscape()->GetCellHeight( CellX - 1  , CellY + 1     , &h6 );

        // Contruit les 5 points
        v0.x = 0.0f;
        v0.y = 0.0f;
        v0.z = (float)h0;

        v1.x = 0.0f;
        v1.y = TILE_CELL_SIZE_Y;
        v1.z = (float)h1;

        v2.x = TILE_CELL_SIZE_X;
        v2.y = 0.0f;
        v2.z = (float)h2;

        v3.x = 0.0f;
        v3.y = -TILE_CELL_SIZE_Y;
        v3.z = (float)h3;

        v4.x = -TILE_CELL_SIZE_X;
        v4.y = 0.0f;
        v4.z = (float)h4;

        v5.x = TILE_CELL_SIZE_X;
        v5.y = TILE_CELL_SIZE_Y;
        v5.z = (float)h5;

        v6.x = -TILE_CELL_SIZE_X;
        v6.y = -TILE_CELL_SIZE_Y;
        v6.z = (float)h6;

        // Calcule les 4 normales
        if( b1 && b2 )
        {
                Normal += KVector::CrossProduct( v2 - v0, v1 - v0 );
                n += 1.0f;
        }

        if( b2 && b3 )
        {
                Normal += KVector::CrossProduct( v3 - v0, v2 - v0 );
                n += 1.0f;
        }

        if( b3 && b4 )
        {
                Normal += KVector::CrossProduct( v4 - v0, v3 - v0 );
                n += 1.0f;
        }

        if( b4 && b1 )
        {
                Normal += KVector::CrossProduct( v1 - v0, v4 - v0 );
                n += 1.0f;
        }

/*      // Calcule les 6 normales
        if( b1 && b2 )
        {
                Normal += KVector::CrossProduct( v2 - v0, v1 - v0 );
                n += 1.0f;
        }

        if( b2 && b5 )
        {
                Normal += KVector::CrossProduct( v5 - v0, v2 - v0 );
                n += 1.0f;
        }

        if( b5 && b3 )
        {
                Normal += KVector::CrossProduct( v3 - v0, v5 - v0 );
                n += 1.0f;
        }

        if( b3 && b4 )
        {
                Normal += KVector::CrossProduct( v4 - v0, v3 - v0 );
                n += 1.0f;
        }

        if( b4 && b6 )
        {
                Normal += KVector::CrossProduct( v6 - v0, v4 - v0 );
                n += 1.0f;
        }

        if( b6 && b1 )
        {
                Normal += KVector::CrossProduct( v1 - v0, v6 - v0 );
                n += 1.0f;
        }
*/
        if( n == 0.0f )
                return KVector( 0.0f, 0.0f, 1.0f );

        // Fait la moyenne
        Normal /= n;
        Normal.Normalize();

        return Normal;
}

//---------------------------------------------------------------------------------------------
bool KSubTileDraw::GetHeight( s32 CellX, s32 CellY, KTILEHEIGHT* pHeight )
{
        // En dehors de la tile ?
        if( ( CellX < 0 ) || ( CellX >= TILE_NCELLS_X ) || ( CellY < 0 ) || ( CellY >= TILE_NCELLS_Y ) )
        {
                *pHeight = 0;
                return false;
        }

        *pHeight = GetpTileDraw()->GetHeight( CellX, CellY );

        return true;
}


//---------------------------------------------------------------------------------------------
void KSubTileDraw::ComputeBBox()
{
        KTILEHEIGHT             MinZ, MaxZ, h;
        u32                             SizeX, SizeY;
        u32                             CellPosX, CellPosY;
        float                   TilePosX, TilePosY;

        MinZ = MAX_TILEHEIGHT;
        MaxZ = MIN_TILEHEIGHT;
        
        SizeX           = TILE_NCELLS_X/TILE_NSUBTILES_X;
        SizeY           = TILE_NCELLS_Y/TILE_NSUBTILES_Y;
        CellPosX        = (u32)m_PosX / TILE_CELL_SIZE_X;
        CellPosY        = (u32)m_PosY / TILE_CELL_SIZE_Y;

        // Recherche le minimum et le maximum en Z
        for( u32 sty = 0; sty < SizeY; sty ++ )
        {
                for( u32 stx = 0; stx < SizeX; stx ++ )
                {
                        h = GetpTileDraw()->GetHeight( CellPosX + stx, CellPosY + sty );
                        
                        if( h < MinZ )
                                MinZ = h;

                        if( h > MaxZ )
                                MaxZ = h;
                }
        }

        TilePosX        = GetpTileDraw()->GetPosX();
        TilePosY        = GetpTileDraw()->GetPosY();

        m_pBBox[0].x    = TilePosX + m_PosX;
        m_pBBox[0].y    = TilePosY + m_PosY;
        m_pBBox[0].z    = MinZ;
        m_pBBox[1].x    = TilePosX + m_PosX + SizeX * TILE_CELL_SIZE_X;
        m_pBBox[1].y    = TilePosY + m_PosY;
        m_pBBox[1].z    = MinZ;
        m_pBBox[2].x    = TilePosX + m_PosX;
        m_pBBox[2].y    = TilePosY + m_PosY + SizeY * TILE_CELL_SIZE_Y;
        m_pBBox[2].z    = MinZ;
        m_pBBox[3].x    = TilePosX + m_PosX + SizeX * TILE_CELL_SIZE_X;
        m_pBBox[3].y    = TilePosY + m_PosY + SizeY * TILE_CELL_SIZE_Y;
        m_pBBox[3].z    = MinZ;

        m_pBBox[4].x    = TilePosX + m_PosX;
        m_pBBox[4].y    = TilePosY + m_PosY;
        m_pBBox[4].z    = MaxZ;
        m_pBBox[5].x    = TilePosX + m_PosX + SizeX * TILE_CELL_SIZE_X;
        m_pBBox[5].y    = TilePosY + m_PosY;
        m_pBBox[5].z    = MaxZ;
        m_pBBox[6].x    = TilePosX + m_PosX;
        m_pBBox[6].y    = TilePosY + m_PosY + SizeY * TILE_CELL_SIZE_Y;
        m_pBBox[6].z    = MaxZ;
        m_pBBox[7].x    = TilePosX + m_PosX + SizeX * TILE_CELL_SIZE_X;
        m_pBBox[7].y    = TilePosY + m_PosY + SizeY * TILE_CELL_SIZE_Y;
        m_pBBox[7].z    = MaxZ;
}

//---------------------------------------------------------------------------------------------
void KSubTileDraw::FlushIndexList()
{
        m_nIndexListPos = 0;
}

//---------------------------------------------------------------------------------------------
void KSubTileDraw::AddIndexList( u32 MipIndices )
{
        KASSERT( m_CurrentMipLevel < m_nMipMesh );

        KSubTileDrawMipMesh*    pMipMesh = &m_pMipMesh[m_CurrentMipLevel];

        if( !pMipMesh->m_nIndex[MipIndices] )
                return;

        KASSERT( pMipMesh->m_pIndex[MipIndices] );
        KASSERT( (m_nIndexListPos + pMipMesh->m_nIndex[MipIndices]) <= m_nIndexList );

        memcpy( &m_pIndexList[m_nIndexListPos], pMipMesh->m_pIndex[MipIndices], pMipMesh->m_nIndex[MipIndices] * sizeof( KINDEX ) );
        m_nIndexListPos += pMipMesh->m_nIndex[MipIndices];
}

//---------------------------------------------------------------------------------------------
void KSubTileDraw::Draw()
{
        KASSERT( m_CurrentMipLevel < m_nMipMesh );

        KSubTileDrawMipMesh*    pMipMesh = &m_pMipMesh[m_CurrentMipLevel];
        u32                                             nIndex = 0;
        s32                                             SubTileX = (s32)((GetpTileDraw()->GetPosX() + m_PosX) / TILE_SUBTILE_SIZE_X);
        s32                                             SubTileY = (s32)((GetpTileDraw()->GetPosY() + m_PosY) / TILE_SUBTILE_SIZE_Y);
        KSubTileDraw*                   pSubTile;

        // Flush le buffer d'index
        FlushIndexList();

        // Center
        AddIndexList( KSTMI_CENTER );

        // Up
        pSubTile = GetpTileDraw()->GetpLandscapeDraw()->GetpSubTileDraw( SubTileX, SubTileY + 1 );
        if( pSubTile && (pSubTile->GetCurrentMipLevel() > m_CurrentMipLevel ) )
                AddIndexList( KSTMI_MIP_UP );
        else
                AddIndexList( KSTMI_UP );

        // Down
        pSubTile = GetpTileDraw()->GetpLandscapeDraw()->GetpSubTileDraw( SubTileX, SubTileY - 1 );
        if( pSubTile && (pSubTile->GetCurrentMipLevel() > m_CurrentMipLevel ) )
                AddIndexList( KSTMI_MIP_DOWN );
        else
                AddIndexList( KSTMI_DOWN );

        // Left
        pSubTile = GetpTileDraw()->GetpLandscapeDraw()->GetpSubTileDraw( SubTileX - 1, SubTileY );
        if( pSubTile && (pSubTile->GetCurrentMipLevel() > m_CurrentMipLevel ) )
                AddIndexList( KSTMI_MIP_LEFT );
        else
                AddIndexList( KSTMI_LEFT );

        // Right
        pSubTile = GetpTileDraw()->GetpLandscapeDraw()->GetpSubTileDraw( SubTileX + 1, SubTileY );
        if( pSubTile && (pSubTile->GetCurrentMipLevel() > m_CurrentMipLevel ) )
                AddIndexList( KSTMI_MIP_RIGHT );
        else
                AddIndexList( KSTMI_RIGHT );

        if( !m_nIndexListPos )
                return;

        KRenderFace             RenderFace;

        GetpTileDraw()->GetpRender()->SetShader( m_hShader );
        GetpTileDraw()->GetpRender()->SetTextureStageState( 0, KRTSS_ADDRESSU, KRTD_MIRROR );
        GetpTileDraw()->GetpRender()->SetTextureStageState( 0, KRTSS_ADDRESSV, KRTD_MIRROR );
        RenderFace.m_VertexType = KRVERTEX2;
        RenderFace.m_nVertex    = (u16)pMipMesh->m_nVertex;
        RenderFace.m_pVertex    = pMipMesh->m_pVertex;
        RenderFace.m_nIndices   = (u16)m_nIndexListPos;//pMipMesh->m_nIndex;
        RenderFace.m_pIndices   = m_pIndexList;//pMipMesh->m_pIndex;
//      RenderFace.m_nIndices   = (u16)pMipMesh->m_nIndex[KSTMI_CENTER];
//      RenderFace.m_pIndices   = pMipMesh->m_pIndex[KSTMI_CENTER];
        GetpTileDraw()->GetpRender()->DrawTriangles( RenderFace );

        // Affiche la bounding box
//      GetpTileDraw()->GetpRender()->DrawBBox( m_pBBox );
}

//---------------------------------------------------------------------------------------------
bool KSubTileDraw::GetRayIntersection( KVector& Orig, KVector& Dir, KVector* pPoint )
{
        KVector                 p0, p1, p2;
        float                   t, u, v;
        KTILEHEIGHT             Height;

        s32                             SizeX = (s32)TILE_NCELLS_X / TILE_NSUBTILES_X;
        s32                             SizeY = (s32)TILE_NCELLS_Y / TILE_NSUBTILES_Y;
        s32                             CellPosX = (s32)(m_PosX + GetpTileDraw()->GetPosX()) / TILE_CELL_SIZE_X;
        s32                             CellPosY = (s32)(m_PosY + GetpTileDraw()->GetPosY()) / TILE_CELL_SIZE_Y;

        for( s32 cy = 0; cy < SizeY; cy ++ )
        {
                for( s32 cx = 0; cx < SizeX; cx ++ )
                {
                        // Triangle 1
                        p0.x    = (float)(CellPosX + cx) * TILE_CELL_SIZE_X;
                        p0.y    = (float)(CellPosY + cy) * TILE_CELL_SIZE_Y;
                        GetpTileDraw()->GetpLandscapeDraw()->GetCellHeight( CellPosX + cx, CellPosY + cy, &Height );
                        p0.z    = (float)Height;

                        p1.x    = (float)(CellPosX + cx) * TILE_CELL_SIZE_X;
                        p1.y    = (float)(CellPosY + cy + 1) * TILE_CELL_SIZE_Y;
                        GetpTileDraw()->GetpLandscapeDraw()->GetCellHeight( CellPosX + cx, CellPosY + cy + 1, &Height );
                        p1.z    = (float)Height;

                        p2.x    = (float)(CellPosX + cx + 1) * TILE_CELL_SIZE_X;
                        p2.y    = (float)(CellPosY + cy) * TILE_CELL_SIZE_Y;
                        GetpTileDraw()->GetpLandscapeDraw()->GetCellHeight( CellPosX + cx + 1, CellPosY + cy, &Height );
                        p2.z    = (float)Height;

                        if( IntersectTriangleCullNone( Orig, Dir, p0, p1, p2, &t, &u, &v ) )
                        {
                                KVector Edge1 = p1 - p0;
                                KVector Edge2 = p2 - p0;
                                KVector Point = p0 + Edge1 * u + Edge2 * v;

                                *pPoint = Point;
                                //pPoint->x = (float)(CellPosX + cx) * TILE_CELL_SIZE_X;
                                //pPoint->y = (float)(CellPosY + cy) * TILE_CELL_SIZE_Y;
                                //pPoint->z = Point.z;//0.0f;
                                return true;
                        }

                        // Triangle 2
                        p0.x    = (float)(CellPosX + cx + 1) * TILE_CELL_SIZE_X;
                        p0.y    = (float)(CellPosY + cy) * TILE_CELL_SIZE_Y;
                        GetpTileDraw()->GetpLandscapeDraw()->GetCellHeight( CellPosX + cx + 1, CellPosY + cy, &Height );
                        p0.z    = (float)Height;

                        p1.x    = (float)(CellPosX + cx) * TILE_CELL_SIZE_X;
                        p1.y    = (float)(CellPosY + cy + 1) * TILE_CELL_SIZE_Y;
                        GetpTileDraw()->GetpLandscapeDraw()->GetCellHeight( CellPosX + cx, CellPosY + cy + 1, &Height );
                        p1.z    = (float)Height;

                        p2.x    = (float)(CellPosX + cx + 1) * TILE_CELL_SIZE_X;
                        p2.y    = (float)(CellPosY + cy + 1) * TILE_CELL_SIZE_Y;
                        GetpTileDraw()->GetpLandscapeDraw()->GetCellHeight( CellPosX + cx + 1, CellPosY + cy + 1, &Height );
                        p2.z    = (float)Height;

                        if( IntersectTriangleCullNone( Orig, Dir, p0, p1, p2, &t, &u, &v ) )
                        {
                                KVector Edge1 = p1 - p0;
                                KVector Edge2 = p2 - p0;
                                KVector Point = p0 + Edge1 * u + Edge2 * v;

                                *pPoint = Point;
                                //pPoint->x = (float)(CellPosX + cx) * TILE_CELL_SIZE_X;
                                //pPoint->y = (float)(CellPosY + cy) * TILE_CELL_SIZE_Y;
                                //pPoint->z = Point.z;//0.0f;
                                return true;
                        }
                }
        }

        return false;
}

---