Change Encyclo button name and macros icon

[ryzomcore.git] / nel / src / 3d / tessellation.cpp

// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
// Copyright (C) 2010  Winch Gate Property Limited
//
// This source file has been modified by the following contributors:
// Copyright (C) 2020  Jan BOON (Kaetemi) <jan.boon@kaetemi.be>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

#include "std3d.h"

#include "nel/3d/tessellation.h"
#include "nel/3d/patch.h"
#include "nel/3d/zone.h"
#include "nel/misc/common.h"
#include "nel/3d/landscape_profile.h"
#include "nel/3d/landscape.h"
#include "nel/3d/patchdlm_context.h"

using namespace NLMISC;
using namespace std;

#ifdef DEBUG_NEW
#define new DEBUG_NEW
#endif

namespace NL3D
{


// ***************************************************************************
#define NL3D_TESS_USE_QUADRANT_THRESHOLD                0.1f


// ***************************************************************************
// The normal Uvs format.
const   uint8   TileUvFmtNormal1= 0;
const   uint8   TileUvFmtNormal2= 1;
const   uint8   TileUvFmtNormal3= 2;
const   uint8   TileUvFmtNormal4= 3;
const   uint8   TileUvFmtNormal5= 4;


// ***************************************************************************
const   float TileSize= 128;


// ***************************************************************************
// ***************************************************************************
// CTileMaterial
// ***************************************************************************
// ***************************************************************************


// ***************************************************************************
CTileMaterial::CTileMaterial()
{
        // By default, all pass are NULL.
        for(uint i=0; i<NL3D_MAX_TILE_FACE; i++)
        {
                TileFaceVectors[i]= NULL;
        }
}


// ***************************************************************************
void            CTileMaterial::appendTileToEachRenderPass(uint patchNumRenderableFaces)
{
        for(uint i=0;i<NL3D_MAX_TILE_PASS;i++)
        {
                // If RdrPass exist, add this Material Id
                CPatchRdrPass   *rdrPass= Pass[i].PatchRdrPass;
                if(rdrPass!=NULL)
                {
                        /* enlarge the capacity of the pass so it can renders the tile faces of this patch.
                         *      NumRenderableFaces is really too big since the tile-material surely doesn't use all
                         *      faces of the patch (except if same texture...)
                         *      But doesn't matter. Even if all the visible Tile Surface (80m*80m) is in the same pass,
                         *      it leads to only 76K final in CLandscapeGlobals::PassTriArray:
                         *      80*80(Visible surface at 80m max) /4 (2m*2m) *2(triangles) *2 (over-estimate) *3*4(triSize)=
                         *      76800
                         */
                        rdrPass->appendRdrPatchTile(i, &Pass[i], patchNumRenderableFaces);
                }
        }
}


// ***************************************************************************
// ***************************************************************************
//      CTessVertex
// ***************************************************************************
// ***************************************************************************


// ***************************************************************************
void            CTessVertex::computeGeomPos()
{
        // Compute Basic ErrorMetric.
        float   sqrDist= (StartPos - CLandscapeGlobals::RefineCenter).sqrnorm();
        float   pgeom= MaxFaceSize * CLandscapeGlobals::OORefineThreshold / sqrDist;

        // Compute ErrorMetric modified by TileNear transition, only if TileNear transition.
        if( sqrDist< CLandscapeGlobals::TileDistFarSqr )
        {
                // Soft optim: do it only if necessary, ie result of max(errorMetric, errorMetricModified) is foreseeable here.
                if(pgeom < MaxNearLimit)
                {
                        float   f= (CLandscapeGlobals::TileDistFarSqr - sqrDist) * CLandscapeGlobals::OOTileDistDeltaSqr;
                        clamp(f, 0, 1);
                        // ^4 gives better smooth result
                        f= sqr(f);
                        f= sqr(f);
                        // interpolate the errorMetric
                        pgeom= MaxNearLimit*f + pgeom*(1-f);
                }
        }

        // Interpolate StartPos to EndPos, between 1 and 2.
        if(pgeom<=1.0f)
                Pos= StartPos;
        else if(pgeom>=2.0f)
                Pos= EndPos;
        else
        {
                float           f= pgeom - 1.0f;
                Pos= f * (EndPos-StartPos) + StartPos;
        }
}


// ***************************************************************************
// ***************************************************************************
// CTessFace
// ***************************************************************************
// ***************************************************************************


// ***************************************************************************
CTessFace       CTessFace::CantMergeFace;
CTessFace       CTessFace::MultipleBindFace;


// ***************************************************************************
CTessFace::CTessFace()
{
        // Don't modify any of it!!
        // Patch, SonLeft and SonRight nullity are very useful for MultiplePatch faces, and CantMergeFace.

        Patch= NULL;
        VBase=VLeft=VRight= NULL;
        FBase=FLeft=FRight= NULL;
        Father=SonLeft=SonRight= NULL;
        Level=0;
        ErrorMetricDate= 0;
        // Size, Center, paramcoord undetermined.

        TileMaterial= NULL;
        // Very important (for split reasons). Init Tilefaces to NULL.
        for(sint i=0;i<NL3D_MAX_TILE_FACE;i++)
        {
                TileFaces[i]=NULL;
        }

        RecursMarkCanMerge=false;
        RecursMarkForceMerge=false;


        NL3D_PROFILE_LAND_ADD(ProfNTessFace, 1);

        ShadowMapTriId= -1;
}


// ***************************************************************************
CTessFace::~CTessFace()
{
        // Old Code. This is not sufficient to clear the CTessFace.
        // Vertices and Uvs must be correctly cleared too (but difficult because of sharing).
        /*
        Patch->getLandscape()->deleteTessFace(SonLeft);
        Patch->getLandscape()->deleteTessFace(SonRight);

        // update neighbors.
        if(FBase)       FBase->changeNeighbor(this, NULL);
        if(FLeft)       FLeft->changeNeighbor(this, NULL);
        if(FRight)      FRight->changeNeighbor(this, NULL);

        FBase=FLeft=FRight= NULL;
        */

        NL3D_PROFILE_LAND_ADD(ProfNTessFace, -1);

        // Ensure correclty removed from landscape ShadowMap.
        nlassert(ShadowMapTriId== -1);
}


// ***************************************************************************
float                   CTessFace::computeNearLimit()
{
        // General formula for Level, function of Size, threshold etc...:
        // WantedLevel= log2(BaseSize / sqrdist / RefineThreshold);
        // <=> WantedLevel= log2( CurSize*2^Level / sqrdist / RefineThreshold).
        // <=> WantedLevel= log2( ProjectedSize* 2^Level / RefineThreshold).
        // <=> 2^WantedLevel= ProjectedSize* 2^Level / RefineThreshold.
        // <=> ProjectedSize= (2^WantedLevel) * RefineThreshold / (2^Level);
        // <=> ProjectedSize= (1<<WantedLevel) * RefineThreshold / (1<<Level);
        // UnOptimised formula: limit= (1<<Patch->TileLimitLevel) / (1<<Level);
        nlassert(Level<=20);
        static const uint       BigValue= 1<<20;
        static const float      OOBigValue= 1.0f / BigValue;
        return (1<<Patch->TileLimitLevel) * (OOBigValue*(BigValue>>Level));
}


// ***************************************************************************
void                    CTessFace::computeTileErrorMetric()
{
        // We must take a more correct errometric here: We must have sons face which have
        // lower projectedsize than father. This is not the case if Center of face is taken (but when not in
        // tile mode this is nearly the case). So take the min dist from 3 points.
        float   s0= (VBase->EndPos - CLandscapeGlobals::RefineCenter).sqrnorm();
        float   s1= (VLeft->EndPos - CLandscapeGlobals::RefineCenter).sqrnorm();
        float   s2= (VRight->EndPos - CLandscapeGlobals::RefineCenter).sqrnorm();
        float   sqrdist= minof(s0, s1, s2);
        // It is also VERY important to take the min of 3, to ensure the split in TileMode when Far1 vertex begin
        // to blend (see Patch::renderFar1() render).

        // NB: VertexProgram geomorph take sqrdist= (SplitPoint - RefineCenter).sqrnorm();
        // It's OK because geomorph will start "far" after the split.

        if(sqrdist< CLandscapeGlobals::TileDistFarSqr)
        {
                float   nearLimit;
                nearLimit= CLandscapeGlobals::RefineThreshold * computeNearLimit();
                // If we are not so subdivided.
                if(ErrorMetric<nearLimit)
                {
                        if(sqrdist< CLandscapeGlobals::TileDistNearSqr)
                        {
                                ErrorMetric=nearLimit;
                        }
                        else
                        {
                                // Smooth transition to the nearLimit of tesselation.
                                float   f= ( CLandscapeGlobals::TileDistFarSqr - sqrdist ) * CLandscapeGlobals::OOTileDistDeltaSqr;
                                // sqr gives better result, by smoothing more the start of transition.
                                f= sqr(f);
                                f= sqr(f);
                                ErrorMetric= ErrorMetric + (nearLimit-ErrorMetric)*f;

                                // If threshold is big like 0.5, transition is still hard, and pops occurs. But The goal is
                                // 0.005 and less, so don't bother.
                        }
                }
        }
}


// ***************************************************************************
void            CTessFace::updateErrorMetric()
{
        // If already updated for this pass...
        if(ErrorMetricDate>= CLandscapeGlobals::CurrentDate)
                return;

        CVector viewdir= SplitPoint - CLandscapeGlobals::RefineCenter;
        float   sqrdist= viewdir.sqrnorm();

        // trivial formula.
        //-----------------
        ErrorMetric= Size/ sqrdist;


        // Hoppe97 formula:  k^2= a^2 * ("v-e"^2 - ((v-e).n)^2) / "v-e"^4.
        //-----------------
        // Can't do it because geomorph is made on Graphic card, so the simplier is the better.


        // TileMode Impact.
        //-----------------
        /* TileMode Impact. We must split at least at TileLimitLevel, but only if the triangle
                has a chance to enter in the TileDistFar sphere.
        */
        if( Level<Patch->TileLimitLevel && sqrdist < sqr(CLandscapeGlobals::TileDistFar+MaxDistToSplitPoint) )
        {
                computeTileErrorMetric();
        }

        ErrorMetricDate= CLandscapeGlobals::CurrentDate;
}


// ***************************************************************************
inline float    CTessFace::computeTileEMForUpdateRefine(float distSplitPoint, float distMinFace, float nearLimit)
{
        float   ema;
        // Normal ErrorMetric simulation.
        ema= Size / sqr(distSplitPoint);

        // TileErrorMetric simulation.
        if(distMinFace < CLandscapeGlobals::TileDistFar)
        {
                // If we are not so subdivided.
                if( ema<nearLimit )
                {
                        if( distMinFace< CLandscapeGlobals::TileDistNear)
                        {
                                ema= nearLimit;
                        }
                        else
                        {
                                // Smooth transition to the nearLimit of tesselation.
                                float   f= ( CLandscapeGlobals::TileDistFarSqr - sqr(distMinFace) ) * CLandscapeGlobals::OOTileDistDeltaSqr;
                                // sqr gives better result, by smoothing more the start of transition.
                                f= sqr(f);
                                f= sqr(f);
                                ema= ema + (nearLimit-ema)*f;
                        }
                }
        }

        return ema * CLandscapeGlobals::OORefineThreshold;
}


// ***************************************************************************
void    CTessFace::computeSplitPoint()
{
        if(isRectangular())
        {
                // If it is a rectangular triangle, it will be splitted on the middle of VBase/VLeft.
                // see splitRectangular() conventions.
                // So for good geomorph compute per vertex, we must have this SplitPoint on this middle.
                SplitPoint= (VLeft->EndPos + VBase->EndPos)/2;
        }
        else
        {
                // If it is a square triangle, it will be splitted on middle of VLeft/VRight.
                // So for good geomorph compute per vertex, we must have this SplitPoint on this middle.
                SplitPoint= (VLeft->EndPos + VRight->EndPos)/2;
        }

        // compute MaxDistToSplitPoint
        float   d0= (VBase->EndPos - SplitPoint).sqrnorm();
        float   d1= (VLeft->EndPos - SplitPoint).sqrnorm();
        float   d2= (VRight->EndPos - SplitPoint).sqrnorm();
        MaxDistToSplitPoint= max(d0, d1);
        MaxDistToSplitPoint= max(MaxDistToSplitPoint, d2);
        // Get the distance.
        MaxDistToSplitPoint= sqrtf(MaxDistToSplitPoint);
}

// ***************************************************************************
void    CTessFace::allocTileUv(TTileUvId id)
{
        // TileFaces must have been build.
        nlassert(TileFaces[NL3D_TILE_PASS_RGB0]);

        // what src??
        CTessVertex             *vertexSrc;
        switch(id)
        {
                case IdUvBase: vertexSrc= VBase; break;
                case IdUvLeft: vertexSrc= VLeft; break;
                case IdUvRight: vertexSrc= VRight; break;
                default: vertexSrc = 0; nlstop; break;
        };

        // Do it for all possible pass
        for(sint i=0;i<NL3D_MAX_TILE_FACE;i++)
        {
                if(TileFaces[i])
                {
                        CTessNearVertex         *newNear= Patch->getLandscape()->newTessNearVertex();
                        newNear->Src= vertexSrc;
                        TileFaces[i]->V[id]= newNear;
                        Patch->appendNearVertexToRenderList(TileMaterial, newNear);

                        // May Allocate/Fill VB. Do it after allocTileUv, because UVs are not comuted yet.
                }
        }
}

// ***************************************************************************
void    CTessFace::checkCreateFillTileVB(TTileUvId id)
{
        // TileFaces must have been build.
        nlassert(TileFaces[NL3D_TILE_PASS_RGB0]);

        for(sint i=0;i<NL3D_MAX_TILE_FACE;i++)
        {
                if(TileFaces[i])
                {
                        CTessNearVertex         *vertNear;
                        vertNear= TileFaces[i]->V[id];

                        // May Allocate/Fill VB.
                        Patch->checkCreateVertexVBNear(vertNear);
                        Patch->checkFillVertexVBNear(vertNear);
                }
        }
}


// ***************************************************************************
void    CTessFace::checkFillTileVB(TTileUvId id)
{
        // TileFaces must have been build.
        nlassert(TileFaces[NL3D_TILE_PASS_RGB0]);

        for(sint i=0;i<NL3D_MAX_TILE_FACE;i++)
        {
                if(TileFaces[i])
                {
                        CTessNearVertex         *vertNear;
                        vertNear= TileFaces[i]->V[id];

                        // May Fill VB.
                        Patch->checkFillVertexVBNear(vertNear);
                }
        }
}


// ***************************************************************************
void    CTessFace::deleteTileUv(TTileUvId id)
{
        // TileFaces must still exist.
        nlassert(TileFaces[NL3D_TILE_PASS_RGB0]);

        for(sint i=0;i<NL3D_MAX_TILE_FACE;i++)
        {
                if(TileFaces[i])
                {
                        CTessNearVertex         *oldNear;
                        oldNear= TileFaces[i]->V[id];
                        TileFaces[i]->V[id]=NULL;

                        // May delete this vertex from VB.
                        Patch->checkDeleteVertexVBNear(oldNear);

                        Patch->removeNearVertexFromRenderList(TileMaterial, oldNear);
                        Patch->getLandscape()->deleteTessNearVertex(oldNear);
                }
        }
}
// ***************************************************************************
void    CTessFace::copyTileUv(TTileUvId dstId, CTessFace *srcFace, TTileUvId srcId)
{
        // TileFaces must have been build.
        nlassert(TileFaces[NL3D_TILE_PASS_RGB0]);

        // Since this a ptr-copy, no need to add/remove the renderlist of near vertices.

        for(sint i=0;i<NL3D_MAX_TILE_FACE;i++)
        {
                if(TileFaces[i])
                {
                        // The srcface should have the same tileFaces enabled.
                        nlassert(srcFace->TileFaces[i]);

                        // copy from src.
                        CTessNearVertex         *copyNear;
                        copyNear= srcFace->TileFaces[i]->V[srcId];

                        // copy to dst.
                        TileFaces[i]->V[dstId]=  copyNear;
                }
        }
}
// ***************************************************************************
void    CTessFace::heritTileUv(CTessFace *baseFace)
{
        // TileFaces must have been build.
        nlassert(TileFaces[NL3D_TILE_PASS_RGB0]);

        for(sint i=0;i<NL3D_MAX_TILE_FACE;i++)
        {
                if(TileFaces[i])
                {
                        // The baseface should have the same tileFaces enabled.
                        nlassert(baseFace->TileFaces[i]);
                        // VBase should be allocated.
                        nlassert(TileFaces[i]->V[IdUvBase]);
                        TileFaces[i]->V[IdUvBase]->initMiddleUv(
                                *baseFace->TileFaces[i]->V[IdUvLeft], *baseFace->TileFaces[i]->V[IdUvRight]);
                }
        }
}


// ***************************************************************************
void            CTessFace::buildTileFaces()
{
        nlassert(TileMaterial);

        // Do nothgin for lightmap pass, of course.
        for(sint i=0;i<NL3D_MAX_TILE_FACE;i++)
        {
                if(TileMaterial->Pass[i].PatchRdrPass)
                {
                        TileFaces[i]= Patch->getLandscape()->newTileFace();
                        TileFaces[i]->V[IdUvBase]= NULL;
                        TileFaces[i]->V[IdUvLeft]= NULL;
                        TileFaces[i]->V[IdUvRight]= NULL;
                }
        }
}
// ***************************************************************************
void            CTessFace::deleteTileFaces()
{
        nlassert(TileMaterial);

        // Do nothgin for lightmap pass, of course.
        for(sint i=0;i<NL3D_MAX_TILE_FACE;i++)
        {
                if(TileMaterial->Pass[i].PatchRdrPass)
                {
                        nlassert(TileFaces[i]);
                        Patch->getLandscape()->deleteTileFace(TileFaces[i]);
                        TileFaces[i]= NULL;
                }
                else
                {
                        nlassert(TileFaces[i]==NULL);
                }
        }
}

// ***************************************************************************
bool            CTessFace::emptyTileFaces()
{
        // Do nothgin for lightmap pass, of course.
        for(sint i=0;i<NL3D_MAX_TILE_FACE;i++)
        {
                // Some TileFace exist??
                if(TileFaces[i])
                        return false;
        }

        return true;
}



// ***************************************************************************
void            CTessFace::initTileUvRGBA(sint pass, bool alpha, CParamCoord pointCoord, CParamCoord middle, CUV &uv)
{
        // Get good coordinate according to patch orientation.
        uv.U= pointCoord.S<=middle.S? 0.0f: 1.0f;
        uv.V= pointCoord.T<=middle.T? 0.0f: 1.0f;

        // Get Tile Uv info: orientation and scale.
        uint8           orient;
        CVector         uvScaleBias;
        bool            is256;
        uint8           uvOff;
        Patch->getTileUvInfo(TileId, pass, alpha, orient, uvScaleBias, is256, uvOff);

        // Orient the UV.
        float   u= uv.U;
        float   v= uv.V;
        // Speed rotation.
        switch(orient)
        {
                case 0:
                        uv.U= u;
                        uv.V= v;
                        break;
                case 1:
                        uv.U= 1-v;
                        uv.V= u;
                        break;
                case 2:
                        uv.U= 1-u;
                        uv.V= 1-v;
                        break;
                case 3:
                        uv.U= v;
                        uv.V= 1-u;
                        break;
        }

        // Do the 256x256.
        if(is256)
        {
                uv*= 0.5;
                if(uvOff==2 || uvOff==3)
                        uv.U+= 0.5;
                if(uvOff==1 || uvOff==2)
                        uv.V+= 0.5;
        }


        // Do the HalfPixel scale bias.
        float   hBiasXY, hBiasZ;
        if(is256)
        {
                hBiasXY= CLandscapeGlobals::TilePixelBias256;
                hBiasZ = CLandscapeGlobals::TilePixelScale256;
        }
        else
        {
                hBiasXY= CLandscapeGlobals::TilePixelBias128;
                hBiasZ = CLandscapeGlobals::TilePixelScale128;
        }


        // Scale the UV.
        uv.U*= uvScaleBias.z*hBiasZ;
        uv.V*= uvScaleBias.z*hBiasZ;
        uv.U+= uvScaleBias.x+hBiasXY;
        uv.V+= uvScaleBias.y+hBiasXY;
}


// ***************************************************************************
void            CTessFace::initTileUvLightmap(CParamCoord pointCoord, CParamCoord middle, CUV &uv)
{
        // Get good coordinate according to patch orientation.
        uv.U= pointCoord.S<=middle.S? 0.0f: 1.0f;
        uv.V= pointCoord.T<=middle.T? 0.0f: 1.0f;

        // Get Tile Lightmap Uv info: bias and scale.
        CVector         uvScaleBias;
        Patch->getTileLightMapUvInfo(TileMaterial->TileS, TileMaterial->TileT, uvScaleBias);

        // Scale the UV.
        uv.U*= uvScaleBias.z;
        uv.V*= uvScaleBias.z;
        uv.U+= uvScaleBias.x;
        uv.V+= uvScaleBias.y;
}


// ***************************************************************************
void            CTessFace::initTileUvDLM(CParamCoord pointCoord, CUV &uv)
{
        // get the dlm context from the patch.
        CPatchDLMContext        *dlmCtx= Patch->_DLMContext;
        // mmust exist at creation of the tile.
        nlassert(dlmCtx);

        // get coord in 0..1 range, along the patch.
        uv.U= pointCoord.getS();
        uv.V= pointCoord.getT();

        // ScaleBias according to the context.
        uv.U*= dlmCtx->DLMUScale;
        uv.V*= dlmCtx->DLMVScale;
        uv.U+= dlmCtx->DLMUBias;
        uv.V+= dlmCtx->DLMVBias;
}


// ***************************************************************************
void            CTessFace::computeTileMaterial()
{
        // 0. Compute TileId.
        //-------------------
        // Square Order Patch assumption: assume that when a CTessFace become a tile, his base can ONLY be diagonal...
        /* a Patch:
                A ________
                |\      /|
                | \    / |
           C|__\B_/  |
                |  /  \  |
                | /    \ |
                |/______\|

                Here, if OrderS*OrderT=2*2, ABC is a new CTessFace of a Tile, and AB is the diagonal of the tile.
                Hence the middle of the tile is the middle of AB.

                C must be created, but A and B may be created or copied from neighbor.
        */
        CParamCoord     middle(PVLeft,PVRight);
        uint16 ts= ((uint16)middle.S * (uint16)Patch->OrderS) / 0x8000;
        uint16 tt= ((uint16)middle.T * (uint16)Patch->OrderT) / 0x8000;
        TileId= (uint8)(tt*Patch->OrderS + ts);


        // 1. Compute Tile Material.
        //--------------------------
        // if base neighbor is already at TileLimitLevel just ptr-copy, else create the TileMaterial...
        nlassert(!FBase || FBase->Patch!=Patch || FBase->Level<=Patch->TileLimitLevel);
        bool    copyFromBase;
        copyFromBase= (FBase && FBase->Patch==Patch);
        copyFromBase= copyFromBase && (FBase->Level==Patch->TileLimitLevel && FBase->TileMaterial!=NULL);
        // NB: because of delete/recreateTileUvs(), FBase->TileMaterial may be NULL, even if face is at good TileLimitLevel.
        if(copyFromBase)
        {
                TileMaterial= FBase->TileMaterial;
                nlassert(FBase->TileId== TileId);
        }
        else
        {
                sint    i;
                TileMaterial= Patch->getLandscape()->newTileMaterial();
                TileMaterial->TileS= uint8(ts);
                TileMaterial->TileT= uint8(tt);

                // Add this new material to the render list.
                Patch->appendTileMaterialToRenderList(TileMaterial);

                // First, get a lightmap for this tile. NB: important to do this after appendTileMaterialToRenderList(),
                // because use TessBlocks.
                Patch->getTileLightMap(ts, tt, TileMaterial->Pass[NL3D_TILE_PASS_LIGHTMAP].PatchRdrPass);

                // Fill pass of multi pass material.
                for(i=0;i<NL3D_MAX_TILE_PASS;i++)
                {
                        // Get the correct render pass, according to the tile number, and the pass.
                        if(i!=NL3D_TILE_PASS_LIGHTMAP)
                                TileMaterial->Pass[i].PatchRdrPass= Patch->getTileRenderPass(TileId, i);
                }

                // Fill Pass Info.
                for(i=0;i<NL3D_MAX_TILE_PASS;i++)
                {
                        TileMaterial->Pass[i].TileMaterial= TileMaterial;
                }

                // Do not append this tile to each RenderPass, done in preRender().
        }


        // 2. Compute Uvs.
        //----------------
        // NB: TileMaterial is already setup. Useful for initTileUvLightmap() and initTileUvRGBA().

        // First, must create The TileFaces, according to the TileMaterial passes.
        buildTileFaces();

        // Must allocate the Base, and insert into list.
        allocTileUv(IdUvBase);


        // Init LightMap UV, in RGB0 pass, UV1..
        initTileUvLightmap(PVBase, middle, TileFaces[NL3D_TILE_PASS_RGB0]->V[IdUvBase]->PUv1);
        // Init DLM Uv, in RGB0 pass, UV2.
        initTileUvDLM(PVBase, TileFaces[NL3D_TILE_PASS_RGB0]->V[IdUvBase]->PUv2);

        // Init UV RGBA, for all pass (but lightmap).
        for(sint i=0;i<NL3D_MAX_TILE_FACE;i++)
        {
                nlassert(i!=NL3D_TILE_PASS_LIGHTMAP);
                // If pass is valid
                if( TileMaterial->Pass[i].PatchRdrPass)
                {
                        // Face must exist.
                        nlassert(TileFaces[i]);
                        // Compute RGB UV in UV0.
                        initTileUvRGBA(i, false, PVBase, middle, TileFaces[i]->V[IdUvBase]->PUv0);
                        // If transition tile, compute alpha UV in UV1.
                        // Do it also for Additive, because may have Transition
                        if(i== NL3D_TILE_PASS_RGB1 || i==NL3D_TILE_PASS_RGB2 || i==NL3D_TILE_PASS_ADD)
                                initTileUvRGBA(i, true, PVBase, middle, TileFaces[i]->V[IdUvBase]->PUv1);
                }
        }

        // UVs are computed, may create and fill VB.
        checkCreateFillTileVB(IdUvBase);


        // if base neighbor is already at TileLimitLevel just ptr-copy, else create the left/right TileUvs...
        if(copyFromBase)
        {
                // Just cross-copy the pointers.
                // Make Left near vertices be the Right vertices of FBase
                copyTileUv(IdUvLeft, FBase, IdUvRight);
                // Make Right near vertices be the Left vertices of FBase
                copyTileUv(IdUvRight, FBase, IdUvLeft);
        }
        else
        {
                // Must allocate the left/right uv (and insert into list).
                allocTileUv(IdUvLeft);
                allocTileUv(IdUvRight);


                // Init LightMap UV, in UvPass 0, UV1..
                initTileUvLightmap(PVLeft, middle, TileFaces[NL3D_TILE_PASS_RGB0]->V[IdUvLeft]->PUv1);
                initTileUvLightmap(PVRight, middle, TileFaces[NL3D_TILE_PASS_RGB0]->V[IdUvRight]->PUv1);
                // Init DLM Uv, in RGB0 pass, UV2.
                initTileUvDLM(PVLeft, TileFaces[NL3D_TILE_PASS_RGB0]->V[IdUvLeft]->PUv2);
                initTileUvDLM(PVRight, TileFaces[NL3D_TILE_PASS_RGB0]->V[IdUvRight]->PUv2);

                // Init UV RGBA!
                for(sint i=0;i<NL3D_MAX_TILE_FACE;i++)
                {
                        nlassert(i!=NL3D_TILE_PASS_LIGHTMAP);
                        // If pass is valid
                        if(TileMaterial->Pass[i].PatchRdrPass)
                        {
                                // Face must exist.
                                nlassert(TileFaces[i]);
                                // Compute RGB UV in UV0.
                                initTileUvRGBA(i, false, PVLeft, middle, TileFaces[i]->V[IdUvLeft]->PUv0);
                                initTileUvRGBA(i, false, PVRight, middle, TileFaces[i]->V[IdUvRight]->PUv0);
                                // If transition tile, compute alpha UV in UV1.
                                // Do it also for Additive, because may have Transition
                                if(i== NL3D_TILE_PASS_RGB1 || i==NL3D_TILE_PASS_RGB2 || i==NL3D_TILE_PASS_ADD)
                                {
                                        initTileUvRGBA(i, true, PVLeft, middle, TileFaces[i]->V[IdUvLeft]->PUv1);
                                        initTileUvRGBA(i, true, PVRight, middle, TileFaces[i]->V[IdUvRight]->PUv1);
                                }
                        }
                }

                // UVs are computed, may create and fill VB.
                checkCreateFillTileVB(IdUvLeft);
                checkCreateFillTileVB(IdUvRight);
        }

}
// ***************************************************************************
void    CTessFace::releaseTileMaterial()
{
        // Hence, must release the tile. TileUvBase is differnet for each of leaves.
        deleteTileUv(IdUvBase);

        nlassert(!FBase || FBase->Level<=Patch->TileLimitLevel);
        if(FBase && FBase->Level==Patch->TileLimitLevel && FBase->TileMaterial!=NULL)
        {
                // Do not release Uvs, since neighbor need it...
                // But release faces.
                deleteTileFaces();
                // Do not release TileMaterial, since neighbor need it...
                TileMaterial= NULL;
        }
        else
        {
                // release Uvs.
                deleteTileUv(IdUvLeft);
                deleteTileUv(IdUvRight);

                // After, release Tile faces.
                deleteTileFaces();

                // Release the tile lightmap part. Do it before removeTileMaterialFromRenderList().
                Patch->releaseTileLightMap(TileMaterial->TileS, TileMaterial->TileT);

                // Remove this material from the render list. DO it before deletion of course :).
                // NB: TileS/TileT still valid.
                Patch->removeTileMaterialFromRenderList(TileMaterial);

                Patch->getLandscape()->deleteTileMaterial(TileMaterial);
                TileMaterial= NULL;
        }
}



// ***************************************************************************
void            CTessFace::updateNearFarVertices()
{
        nlassert(VBase && FVBase);
        nlassert(VLeft && FVLeft);
        nlassert(VRight && FVRight);

        FVBase->Src= VBase;
        FVLeft->Src= VLeft;
        FVRight->Src= VRight;
        FVBase->PCoord= PVBase;
        FVLeft->PCoord= PVLeft;
        FVRight->PCoord= PVRight;

        // Update VB for far vertices (if needed)
        Patch->checkFillVertexVBFar(FVBase);
        Patch->checkFillVertexVBFar(FVLeft);
        Patch->checkFillVertexVBFar(FVRight);

        // Near Vertices update (Src only).
        for(sint i=0; i<NL3D_MAX_TILE_FACE; i++)
        {
                if(TileFaces[i])
                {
                        TileFaces[i]->V[IdUvBase]->Src= VBase;
                        TileFaces[i]->V[IdUvLeft]->Src= VLeft;
                        TileFaces[i]->V[IdUvRight]->Src= VRight;

                        // Update VB for near vertices (if needed)
                        Patch->checkFillVertexVBNear(TileFaces[i]->V[IdUvBase]);
                        Patch->checkFillVertexVBNear(TileFaces[i]->V[IdUvLeft]);
                        Patch->checkFillVertexVBNear(TileFaces[i]->V[IdUvRight]);
                }
        }

}


// ***************************************************************************
void            CTessFace::splitRectangular(bool propagateSplit)
{
        CTessFace       *f0= this;
        CTessFace       *f1= FBase;
        // Rectangular case: FBase must exist.
        nlassert(f1);

        // In rectangular case, we split at the same time this and FBase (f0 and f1).


        /*
                Tesselation is:

       lt                    rt        lt        top         rt
                ---------------------           ---------------------
                |----               |           |\        |\        |
                |    ----      f1   |           |  \  f1l |  \  f1r |
                |        ----       |    -->    |    \    |    \    |
                |   f0       ----   |           | f0r  \  | f0l  \  |
                |                ---|           |        \|        \|
                ---------------------           ---------------------
           lb                    rb        lb        bot         rb

                Why? For symetry and bind/split reasons: FBase->SonLeft->VBase is always the good vertex to take
                (see vertex binding).
        */
        CParamCoord             pclt= f1->PVLeft;
        CParamCoord             pclb= f0->PVBase;
        CParamCoord             pcrt= f1->PVBase;
        CParamCoord             pcrb= f1->PVRight;
        CTessVertex             *vlt= f1->VLeft;
        CTessVertex             *vlb= f0->VBase;
        CTessVertex             *vrt= f1->VBase;
        CTessVertex             *vrb= f1->VRight;

        CTessFarVertex  *farvlt= f1->FVLeft;
        CTessFarVertex  *farvlb= f0->FVBase;
        CTessFarVertex  *farvrt= f1->FVBase;
        CTessFarVertex  *farvrb= f1->FVRight;


        // 1. create new vertices.
        //------------------------

        // Create splitted vertices.
        CParamCoord             pctop(f1->PVBase, f1->PVLeft);
        CParamCoord             pcbot(f0->PVBase, f0->PVLeft);
        CTessVertex             *vtop= NULL;
        CTessVertex             *vbot= NULL;
        // Compute top.
        if(f1->FLeft==NULL || f1->FLeft->isLeaf())
        {
                // The base neighbor is a leaf or NULL. So must create the new vertex.
                vtop= Patch->getLandscape()->newTessVertex();

                // Compute pos.
                vtop->StartPos= (f1->VLeft->EndPos + f1->VBase->EndPos)/2;
                vtop->EndPos= f1->Patch->computeVertex(pctop.getS(), pctop.getT());
                // Init Pos= InitialPos. Important in the case of enforced split.
                vtop->Pos= vtop->StartPos;

                // For geomorph (VertexProgram or soft), compute MaxFaceSize and MaxNearLimit.
                vtop->MaxFaceSize= f1->Size;
                vtop->MaxNearLimit= f1->computeNearLimit();
        }
        else
        {
                // Else, get from neighbor.
                // NB: since *FLeft is not a leaf, FBase->SonLeft!=NULL...
                // NB: this work with both rectangular and square triangles.
                vtop= f1->FLeft->SonLeft->VBase;

                // For geomorph (VertexProgram or soft), compute MaxFaceSize and MaxNearLimit.
                vtop->MaxFaceSize= max( vtop->MaxFaceSize, f1->Size);
                vtop->MaxNearLimit= max( vtop->MaxNearLimit, f1->computeNearLimit());
        }
        // Compute bot.
        if(f0->FLeft==NULL || f0->FLeft->isLeaf())
        {
                // The base neighbor is a leaf or NULL. So must create the new vertex.
                vbot= Patch->getLandscape()->newTessVertex();

                // Compute pos.
                vbot->StartPos= (f0->VLeft->EndPos + f0->VBase->EndPos)/2;
                vbot->EndPos= Patch->computeVertex(pcbot.getS(), pcbot.getT());
                // Init Pos= InitialPos. Important in the case of enforced split.
                vbot->Pos= vbot->StartPos;

                // For geomorph (VertexProgram or soft), compute MaxFaceSize and MaxNearLimit.
                vbot->MaxFaceSize= f0->Size;
                vbot->MaxNearLimit= f0->computeNearLimit();
        }
        else
        {
                // Else, get from neighbor.
                // NB: since *FLeft is not a leaf, FBase->SonLeft!=NULL...
                // NB: this work with both rectangular and square triangles.
                vbot= f0->FLeft->SonLeft->VBase;

                // For geomorph (VertexProgram or soft), compute MaxFaceSize and MaxNearLimit.
                vbot->MaxFaceSize= max( vbot->MaxFaceSize, f0->Size);
                vbot->MaxNearLimit= max( vbot->MaxNearLimit, f0->computeNearLimit());
        }

        // In all case, must create new FarVertices, since rect split occurs on border!!
        CTessFarVertex  *farvtop= Patch->getLandscape()->newTessFarVertex();
        CTessFarVertex  *farvbot= Patch->getLandscape()->newTessFarVertex();
        farvtop->Src= vtop;
        farvbot->Src= vbot;
        farvtop->PCoord= pctop;
        farvbot->PCoord= pcbot;
        Patch->appendFarVertexToRenderList(farvtop);
        Patch->appendFarVertexToRenderList(farvbot);
        // May Allocate/Fill VB.
        // NB: vtop / vbot are well computed  and ready for the fill in VB.
        Patch->checkCreateVertexVBFar(farvtop);
        Patch->checkFillVertexVBFar(farvtop);
        Patch->checkCreateVertexVBFar(farvbot);
        Patch->checkFillVertexVBFar(farvbot);

        // For VertexProgram only, must refill the Far vertex of neighbor(s),
        // because MaxFaceSize, and MaxNearLimit may have change.
        if( CLandscapeGlobals::VertexProgramEnabled )
        {
                // f0
                if( ! (f0->FLeft==NULL || f0->FLeft->isLeaf()) )
                        f0->FLeft->Patch->checkFillVertexVBFar(f0->FLeft->SonLeft->FVBase);
                // f1
                if( ! (f1->FLeft==NULL || f1->FLeft->isLeaf()) )
                        f1->FLeft->Patch->checkFillVertexVBFar(f1->FLeft->SonLeft->FVBase);
        }


        // 2. Create sons, and update links.
        //----------------------------------

        CTessFace       *f0l, *f0r;
        CTessFace       *f1l, *f1r;

        // create and bind Sons.
        f0l= f0->SonLeft= Patch->getLandscape()->newTessFace();
        f0r= f0->SonRight= Patch->getLandscape()->newTessFace();
        f1l= f1->SonLeft= Patch->getLandscape()->newTessFace();
        f1r= f1->SonRight= Patch->getLandscape()->newTessFace();

        // subdivision left.
        f0l->Patch= f0->Patch;
        f0l->Father= f0;
        f0l->Level= f0->Level+1;
        f0l->Size= f0->Size*0.5f;
        // subdivision right.
        f0r->Patch= f0->Patch;
        f0r->Father= f0;
        f0r->Level= f0->Level+1;
        f0r->Size= f0->Size*0.5f;
        // subdivision left.
        f1l->Patch= f1->Patch;
        f1l->Father= f1;
        f1l->Level= f1->Level+1;
        f1l->Size= f1->Size*0.5f;
        // subdivision right.
        f1r->Patch= f1->Patch;
        f1r->Father= f1;
        f1r->Level= f1->Level+1;
        f1r->Size= f1->Size*0.5f;

        // Patch coordinates.
        f0r->PVRight= pclt;
        f0r->PVBase= pclb;
        f0r->PVLeft= pcbot;
        f1l->PVBase= pctop;
        f1l->PVLeft= f0r->PVRight;
        f1l->PVRight= f0r->PVLeft;

        f0l->PVRight= pctop;
        f0l->PVBase= pcbot;
        f0l->PVLeft= pcrb;
        f1r->PVBase= pcrt;
        f1r->PVLeft= f0l->PVRight;
        f1r->PVRight= f0l->PVLeft;

        // link existing vertex.
        f0r->VRight= vlt;
        f0r->VBase= vlb;
        f0r->VLeft= vbot;
        f1l->VBase= vtop;
        f1l->VLeft= f0r->VRight;
        f1l->VRight= f0r->VLeft;

        f0l->VRight= vtop;
        f0l->VBase= vbot;
        f0l->VLeft= vrb;
        f1r->VBase= vrt;
        f1r->VLeft= f0l->VRight;
        f1r->VRight= f0l->VLeft;

        // link Far vertices.
        f0r->FVRight= farvlt;
        f0r->FVBase= farvlb;
        f0r->FVLeft= farvbot;
        f1l->FVBase= farvtop;
        f1l->FVLeft= f0r->FVRight;
        f1l->FVRight= f0r->FVLeft;

        f0l->FVRight= farvtop;
        f0l->FVBase= farvbot;
        f0l->FVLeft= farvrb;
        f1r->FVBase= farvrt;
        f1r->FVLeft= f0l->FVRight;
        f1r->FVRight= f0l->FVLeft;

        // link neigbhor faces.
        f0r->FBase= f1l;
        f1l->FBase= f0r;
        f0l->FBase= f1r;
        f1r->FBase= f0l;
        f1l->FRight= f0l;
        f0l->FRight= f1l;
        f0r->FRight= f0->FRight;
        if(f0->FRight)
                f0->FRight->changeNeighbor(f0, f0r);
        f1r->FRight= f1->FRight;
        if(f1->FRight)
                f1->FRight->changeNeighbor(f1, f1r);
        // 4 links (all FLeft sons ) are stil invalid here.
        f0l->FLeft= NULL;
        f0r->FLeft= NULL;
        f1l->FLeft= NULL;
        f1r->FLeft= NULL;

        // Neigbors pointers of undetermined splitted face are not changed. Must Doesn't change this.
        // Used and Updated in section 5. ...


        // 3. Update Tile infos.
        //----------------------
        // There is no update tileinfo with rectangular patch, since tiles are always squares. (TileLimitLevel>SquareLimitLevel).

        // NB: but must test update of tile info for neighboring, ie 2 faces around the splits.
        // For Vertex program only
        if( CLandscapeGlobals::VertexProgramEnabled )
        {
                // if neighbor face splitted, and if 2 different patchs, we must update the Tile vertices
                // because MaxFaceSize and MaxNearLimit may have changed.
                if( f0->FLeft!=NULL && !f0->FLeft->isLeaf() && f0->FLeft->Patch!=Patch )
                {
                        // If neighbors sons at tile level, must update their Tile vertices.
                        if( f0->FLeft->SonLeft->Level >= f0->FLeft->Patch->TileLimitLevel )
                        {
                                f0->FLeft->SonLeft->checkFillTileVB(IdUvBase);
                                f0->FLeft->SonRight->checkFillTileVB(IdUvBase);
                        }
                }
                // idem for f1.
                if( f1->FLeft!=NULL && !f1->FLeft->isLeaf() && f1->FLeft->Patch!=Patch )
                {
                        // If neighbors sons at tile level, must update their Tile vertices.
                        if( f1->FLeft->SonLeft->Level >= f1->FLeft->Patch->TileLimitLevel )
                        {
                                f1->FLeft->SonLeft->checkFillTileVB(IdUvBase);
                                f1->FLeft->SonRight->checkFillTileVB(IdUvBase);
                        }
                }
        }


        // 4. Compute centers.
        //--------------------
        f0r->computeSplitPoint();
        f0l->computeSplitPoint();
        f1r->computeSplitPoint();
        f1l->computeSplitPoint();


        // 5. Propagate, or link sons of base.
        //------------------------------------
        for(sint i=0;i<2;i++)
        {
                CTessFace       *f, *fl, *fr;
                // TOP face.
                if(i==0)
                {
                        f= f1;
                        fl= f1l;
                        fr= f1r;
                }
                // then BOT face.
                else
                {
                        f= f0;
                        fl= f0l;
                        fr= f0r;
                }

                // If current face and FBase has sons, just links.
                if(f->FLeft==NULL)
                {
                        // Just update sons neighbors.
                        fl->FLeft= NULL;
                        fr->FLeft= NULL;
                }
                else if(!f->FLeft->isLeaf())
                {
                        CTessFace       *toLeft, *toRight;
                        toLeft= f->FLeft->SonLeft;
                        toRight= f->FLeft->SonRight;
                        // Cross connection of sons.
                        if( !f->FLeft->isRectangular() )
                        {
                                // Case neigbhor is square.
                                fl->FLeft= toLeft;
                                fr->FLeft= toRight;
                                toLeft->FRight= fl;
                                toRight->FLeft= fr;
                        }
                        else
                        {
                                // Case neigbhor is rectangle.
                                fl->FLeft= toRight;
                                fr->FLeft= toLeft;
                                toLeft->FLeft= fr;
                                toRight->FLeft= fl;
                        }
                }
                else if (propagateSplit)
                {
                        // Warning: at each iteration, the pointer of FLeft may change (because of split() which can change the neighbor
                        // and so f).
                        while(f->FLeft->isLeaf())
                                f->FLeft->split();

                        // There is a possible bug here (maybe easily patched). Sons may have be propagated splitted.
                        // And problems may arise because this face hasn't yet good connectivity (especially for rectangles!! :) ).
                        nlassert(fl->isLeaf() && fr->isLeaf());
                }
        }


        // 6. Must remove father from rdr list, and insert sons.
        //------------------------------------------------------
        // UGLY REFCOUNT SIDE EFFECT: do the append first.
        Patch->appendFaceToRenderList(f0l);
        Patch->appendFaceToRenderList(f0r);
        Patch->appendFaceToRenderList(f1l);
        Patch->appendFaceToRenderList(f1r);
        Patch->removeFaceFromRenderList(f0);
        Patch->removeFaceFromRenderList(f1);


        // 7. Update priority list.
        //------------------------------------------------------
        // Since we are freshly splitted, unlink from any list, and link to the MergePriorityList, because must look
        // now when should merge.
        Patch->getLandscape()->_MergePriorityList.insert(0, 0, f0);
        Patch->getLandscape()->_MergePriorityList.insert(0, 0, f1);

        // Since we are split, no need to test father for merge, because it cannot!
        if(f0->Father)
        {
                // remove father from any priority list.
                f0->Father->unlinkInPList();
        }
        if(f1->Father)
        {
                // remove father from any priority list.
                f1->Father->unlinkInPList();
        }

}


// ***************************************************************************
void            CTessFace::split(bool propagateSplit)
{

        // 0. Some easy ending.
        //---------------------
        // Already splitted??
        if(!isLeaf())
                return;
        // Don't do this!!!
        //if(Level>=LS_MAXLEVEL)
        //      return;
        // since split() may reach LS_MAXLEVEL, but enforce splits which outpass this stage!!

        NL3D_PROFILE_LAND_ADD(ProfNSplits, 1);


        // Special Rectangular case.
        if(isRectangular())
        {
                splitRectangular(propagateSplit);
                return;
        }

        // 1. Create sons, and update links.
        //----------------------------------

        // create and bind Sons.
        SonLeft= Patch->getLandscape()->newTessFace();
        SonRight= Patch->getLandscape()->newTessFace();

        // subdivision left.
        SonLeft->Patch= Patch;
        SonLeft->Father= this;
        SonLeft->Level= Level+1;
        SonLeft->Size= Size*0.5f;
        // subdivision right.
        SonRight->Patch= Patch;
        SonRight->Father= this;
        SonRight->Level= Level+1;
        SonRight->Size= Size*0.5f;


        // link Left Son.
        // link neighbor face.
        SonLeft->FBase= FLeft;
        if(FLeft)       FLeft->changeNeighbor(this, SonLeft);
        SonLeft->FLeft= SonRight;
        SonLeft->FRight= NULL;          // Temporary. updated later.
        // link neighbor vertex.
        SonLeft->VLeft= VBase;
        SonLeft->VRight= VLeft;
        // link neighbor Far vertex.
        SonLeft->FVLeft= FVBase;
        SonLeft->FVRight= FVLeft;
        // Patch coordinates.
        SonLeft->PVBase= CParamCoord(PVLeft, PVRight);
        SonLeft->PVLeft= PVBase;
        SonLeft->PVRight= PVLeft;

        // linkRight Son.
        // link neighbor face.
        SonRight->FBase= FRight;
        if(FRight)      FRight->changeNeighbor(this, SonRight);
        SonRight->FLeft= NULL;          // Temporary. updated later.
        SonRight->FRight= SonLeft;
        // link neighbor vertex.
        SonRight->VLeft= VRight;
        SonRight->VRight= VBase;
        // link neighbor Far vertex.
        SonRight->FVLeft= FVRight;
        SonRight->FVRight= FVBase;
        // Patch coordinates.
        SonRight->PVBase= CParamCoord(PVLeft, PVRight);
        SonRight->PVLeft= PVRight;
        SonRight->PVRight= PVBase;


        // FBase->FBase==this. Must Doesn't change this. Used and Updated in section 5. ...


        // 2. Update/Create Vertex infos.
        //-------------------------------

        // Must create/link *->VBase.
        if(FBase==NULL || FBase->isLeaf())
        {
                // The base neighbor is a leaf or NULL. So must create the new vertex.
                CTessVertex     *newVertex= Patch->getLandscape()->newTessVertex();
                SonRight->VBase= newVertex;
                SonLeft->VBase= newVertex;

                // Compute pos.
                newVertex->StartPos= (VLeft->EndPos + VRight->EndPos)/2;
                newVertex->EndPos= Patch->computeVertex(SonLeft->PVBase.getS(), SonLeft->PVBase.getT());

                // Init Pos= InitialPos. Important in the case of enforced split.
                newVertex->Pos= newVertex->StartPos;

                // For geomorph (VertexProgram or soft), compute MaxFaceSize and MaxNearLimit.
                newVertex->MaxFaceSize= Size;
                newVertex->MaxNearLimit= computeNearLimit();
        }
        else
        {
                // Else, get from neighbor.
                // NB: since *FBase is not a leaf, FBase->SonLeft!=NULL...
                // NB: this work with both rectangular and square triangles (see splitRectangular()).
                SonRight->VBase= FBase->SonLeft->VBase;
                SonLeft->VBase= FBase->SonLeft->VBase;

                // For geomorph (VertexProgram or soft), compute MaxFaceSize and MaxNearLimit.
                SonLeft->VBase->MaxFaceSize= max( SonLeft->VBase->MaxFaceSize, Size);
                SonLeft->VBase->MaxNearLimit= max( SonLeft->VBase->MaxNearLimit, computeNearLimit());
        }


        // Must create/link *->FVBase.
        // HERE, we must create a FarVertex too if the neighbor is not of the same patch as me.
        if(FBase==NULL || FBase->isLeaf() || FBase->Patch!=Patch)
        {
                // The base neighbor is a leaf or NULL. So must create the new far vertex.
                CTessFarVertex  *newFar= Patch->getLandscape()->newTessFarVertex();
                SonRight->FVBase= newFar;
                SonLeft->FVBase= newFar;

                // Compute.
                newFar->Src= SonLeft->VBase;
                newFar->PCoord= SonLeft->PVBase;

                // Append.
                Patch->appendFarVertexToRenderList(newFar);

                // May Allocate/Fill VB.
                // NB: SonLeft->VBase->Pos is well computed and ready for the fill in VB.
                Patch->checkCreateVertexVBFar(newFar);
                Patch->checkFillVertexVBFar(newFar);

                // For VertexProgram only, must refill the Far vertex of neighbor,
                // because MaxFaceSize, and MaxNearLimit may have change.
                if( CLandscapeGlobals::VertexProgramEnabled && ! (FBase==NULL || FBase->isLeaf()) )
                        FBase->Patch->checkFillVertexVBFar(FBase->SonLeft->FVBase);
        }
        else
        {
                // Else, get from neighbor.
                // NB: since *FBase is not a leaf, FBase->SonLeft!=NULL...
                // NB: this work with both rectangular and square triangles (see splitRectangular()).
                SonRight->FVBase= FBase->SonLeft->FVBase;
                SonLeft->FVBase= FBase->SonLeft->FVBase;

                // NB For VertexProgram only: no need to refill the Far vertex of neighbor, because neighbor is of same Patch
                // So MaxNearLimit and MaxFaceSize should be the same.
        }


        // 3. Update Tile infos.
        //----------------------
        // NB: must do it before appendFaceToRenderList().
        // NB: must do it after compute of SonLeft->VBase->Pos for good filling in VBuffer.
        // There is no problem with rectangular patch, since tiles are always squares.
        // If new tile ....
        if(SonLeft->Level==Patch->TileLimitLevel)
        {
                SonLeft->computeTileMaterial();
                SonRight->computeTileMaterial();
        }
        // else Tile herit.
        else if(SonLeft->Level > Patch->TileLimitLevel)
        {
                heritTileMaterial();
        }

        // For Vertex program only
        if( CLandscapeGlobals::VertexProgramEnabled )
        {
                // if neighbor face splitted, and if 2 different patchs, we must update the Tile vertices
                // because MaxFaceSize and MaxNearLimit may have changed.
                if( FBase!=NULL && !FBase->isLeaf() && FBase->Patch!=Patch )
                {
                        // If neighbors sons at tile level, must update their Tile vertices.
                        if( FBase->SonLeft->Level >= FBase->Patch->TileLimitLevel )
                        {
                                FBase->SonLeft->checkFillTileVB(IdUvBase);
                                FBase->SonRight->checkFillTileVB(IdUvBase);
                        }
                }
        }


        // 4. Compute centers.
        //--------------------
        SonRight->computeSplitPoint();
        SonLeft->computeSplitPoint();


        // 5. Propagate, or link sons of base.
        //------------------------------------
        // If current face and FBase has sons, just links.
        if(FBase==NULL)
        {
                // Just update sons neighbors.
                SonLeft->FRight= NULL;
                SonRight->FLeft= NULL;
        }
        else if(!FBase->isLeaf())
        {
                CTessFace       *toLeft, *toRight;
                CTessFace       *fl, *fr;
                fl= SonLeft;
                fr= SonRight;
                toLeft= FBase->SonLeft;
                toRight= FBase->SonRight;
                // Cross connection of sons.
                if(!FBase->isRectangular())
                {
                        // Case neigbhor is square.
                        fl->FRight= toRight;
                        fr->FLeft= toLeft;
                        toLeft->FRight= fr;
                        toRight->FLeft= fl;
                }
                else
                {
                        // Case neigbhor is rectangular.
                        fl->FRight= toLeft;
                        fr->FLeft= toRight;
                        toLeft->FLeft= fl;
                        toRight->FLeft= fr;
                }
        }
        else if (propagateSplit)
        {
                // Warning: at each iteration, the pointer of FBase may change (because of split() which can change the neighbor
                // and so "this").
                while(FBase->isLeaf())
                        FBase->split();

                // There is a possible bug here (maybe easily patched). Sons may have be propagated splitted.
                // And problems may arise because this face hasn't yet good connectivity.
                nlassert(SonLeft->isLeaf() && SonRight->isLeaf());
        }


        // 6. Must remove father from rdr list, and insert sons.
        //------------------------------------------------------
        // UGLY REFCOUNT SIDE EFFECT: do the append first.
        Patch->appendFaceToRenderList(SonLeft);
        Patch->appendFaceToRenderList(SonRight);
        Patch->removeFaceFromRenderList(this);


        // 7. Update priority list.
        //------------------------------------------------------
        // Since we are freshly splitted, unlink from any list, and link to the MergePriorityList, because must look
        // now when should merge.
        Patch->getLandscape()->_MergePriorityList.insert(0, 0, this);

        // Since we are split, no need to test father for merge, because it cannot!
        if(Father)
        {
                // remove father from any priority list.
                Father->unlinkInPList();
        }
}

// ***************************************************************************
bool            CTessFace::canMerge(bool testEm)
{
        if(this== &CantMergeFace)
                return false;

        nlassert(!isLeaf());

        // Test diamond config (sons must be leaves).
        if(!SonLeft->isLeaf())
                return false;
        if(!SonRight->isLeaf())
                return false;
        // If Errormetric must be considered for this test.
        if(testEm)
        {
                updateErrorMetric();
                float   ps2= ErrorMetric;
                ps2*= CLandscapeGlobals::OORefineThreshold;
                if(ps2>=1.0f)
                        return false;
        }

        // Then test neighbors.
        RecursMarkCanMerge= true;
        bool    ok= true;
        if(!isRectangular())
        {
                if(FBase && !FBase->RecursMarkCanMerge)
                {
                        if(!FBase->canMerge(testEm))
                                ok= false;
                }
        }
        else
        {
                // Rectangular case. May have a longer propagation...
                if(FBase && !FBase->RecursMarkCanMerge)
                {
                        if(!FBase->canMerge(testEm))
                                ok= false;
                }
                if(ok && FLeft && !FLeft->RecursMarkCanMerge)
                {
                        if(!FLeft->canMerge(testEm))
                                ok= false;
                }
        }
        // Must not return false in preceding tests, because must set RecursMarkCanMerge to false.
        RecursMarkCanMerge= false;

        return ok;
}


// ***************************************************************************
void            CTessFace::doMerge()
{
        // Assume that canMerge() return true.
        // And Assume that !isLeaf().
        nlassert(!isLeaf());

        if(!isRectangular())
        {
                // 1. Let's merge vertex.
                //-----------------------
                // Delete vertex, only if not already done by the neighbor (ie neighbor not already merged to a leaf).
                // NB: this work even if neigbor is rectnagular.
                if(!FBase || !FBase->isLeaf())
                        Patch->getLandscape()->deleteTessVertex(SonLeft->VBase);

                // Delete Far Vertex. Idem, but test too if != patch...
                if(!FBase || !FBase->isLeaf() || FBase->Patch!=Patch)
                {
                        // May delete this vertex from VB.
                        Patch->checkDeleteVertexVBFar(SonLeft->FVBase);

                        Patch->removeFarVertexFromRenderList(SonLeft->FVBase);
                        Patch->getLandscape()->deleteTessFarVertex(SonLeft->FVBase);
                }


                // 2. Must remove sons from rdr list, and insert father.
                //------------------------------------------------------
                // Must do it BEFORE the TileFaces are released.
                // UGLY REFCOUNT SIDE EFFECT: do the append first.
                Patch->appendFaceToRenderList(this);
                Patch->removeFaceFromRenderList(SonLeft);
                Patch->removeFaceFromRenderList(SonRight);


                // 3. Let's merge Uv.
                //-------------------
                // Delete Uv.
                // Must do it for this and FBase separately, since they may not have same tile level (if != patch).
                if(SonLeft->Level== Patch->TileLimitLevel)
                {
                        // Square patch assumption: the sons are not of the same TileId/Patch.
                        nlassert(!sameTile(SonLeft, SonRight));
                        // release tiles: NearVertices, TileFaces, and TileMaterial.
                        SonLeft->releaseTileMaterial();
                        SonRight->releaseTileMaterial();
                }
                else if(SonLeft->Level > Patch->TileLimitLevel)
                {
                        // Delete Uv, only if not already done by the neighbor (ie neighbor not already merged to a leaf).
                        // But Always delete if neighbor exist and has not same tile as me.
                        // NB: this work with rectangular neigbor patch, since sameTile() will return false if different patch.
                        if(!FBase || !FBase->isLeaf() || !sameTile(this, FBase))
                        {
                                SonLeft->deleteTileUv(IdUvBase);
                        }
                        // In all case, must delete the tilefaces of those face.
                        SonLeft->deleteTileFaces();
                        SonRight->deleteTileFaces();
                }


                // 4. Let's merge Face.
                //-------------------
                // Change father 's neighbor pointers.
                FLeft= SonLeft->FBase;
                if(FLeft)       FLeft->changeNeighbor(SonLeft, this);
                FRight= SonRight->FBase;
                if(FRight)      FRight->changeNeighbor(SonRight, this);
                // delete sons.
                Patch->getLandscape()->deleteTessFace(SonLeft);
                Patch->getLandscape()->deleteTessFace(SonRight);
                SonLeft=NULL;
                SonRight=NULL;

                // If not already done, merge the neighbor.
                if(FBase!=NULL && !FBase->isLeaf())
                {
                        FBase->doMerge();
                }

        }
        else
        {
                // Rectangular case.
                // Since minimum Order is 2, Sons of rectangular face are NEVER at TileLimitLevel. => no Uv merge to do.
                nlassert(SonLeft->Level< Patch->TileLimitLevel);
                nlassert(FBase);

                // 1. Let's merge vertex.
                //-----------------------
                // Delete vertex, only if not already done by the neighbor (ie neighbor not already merged to a leaf).
                // NB: this work even if neigbor is rectangular (see tesselation rules in splitRectangular()).
                if(!FLeft || !FLeft->isLeaf())
                        Patch->getLandscape()->deleteTessVertex(SonLeft->VBase);

                // Delete Far Vertex. Rect patch: neightb must be of a != pathc as me => must delete FarVertex.
                nlassert(!FLeft || FLeft->Patch!=Patch);
                // May delete this vertex from VB.
                Patch->checkDeleteVertexVBFar(SonLeft->FVBase);

                Patch->removeFarVertexFromRenderList(SonLeft->FVBase);
                Patch->getLandscape()->deleteTessFarVertex(SonLeft->FVBase);


                // 2. Must remove sons from rdr list, and insert father.
                //------------------------------------------------------
                // UGLY REFCOUNT SIDE EFFECT: do the append first.
                Patch->appendFaceToRenderList(this);
                Patch->removeFaceFromRenderList(SonLeft);
                Patch->removeFaceFromRenderList(SonRight);


                // 3. Let's merge Face.
                //-------------------
                // Change father 's neighbor pointers (see splitRectangular()).
                FRight= SonRight->FRight;
                if(FRight)      FRight->changeNeighbor(SonRight, this);
                // delete sons.
                Patch->getLandscape()->deleteTessFace(SonLeft);
                Patch->getLandscape()->deleteTessFace(SonRight);
                SonLeft=NULL;
                SonRight=NULL;

                // First, do it for my rectangular co-worker FBase (if not already done).
                if(!FBase->isLeaf())
                {
                        FBase->doMerge();
                }
                // If not already done, merge the neighbor.
                if(FLeft!=NULL && !FLeft->isLeaf())
                {
                        FLeft->doMerge();
                }
        }


        // Update priority list.
        //------------------------------------------------------
        // Since we are freshly merged, unlink from any list, and link to the SplitPriorityList, because must look
        // now when we should split again.
        Patch->getLandscape()->_SplitPriorityList.insert(0, 0, this);

        // since we are now merged maybe re-insert father in priority list.
        if(Father)
        {
                nlassert(!Father->isLeaf());
                // If sons of father are both leaves (ie this, and the other (complexe case if rectangle) )
                if( Father->SonLeft->isLeaf() && Father->SonRight->isLeaf() )
                {
                        Patch->getLandscape()->_MergePriorityList.insert(0, 0, Father);
                }
        }

}


// ***************************************************************************
bool            CTessFace::merge()
{
        // Must not be a leaf.
        nlassert(!isLeaf());

        // 0. Verify if merge is posible.
        //----------------------------
        if(!canMerge(false))
                return false;

        NL3D_PROFILE_LAND_ADD(ProfNMerges, 1);

        // 1. Let's merge the face.
        //-----------------------
        // Propagation is done in doMerge().
        doMerge();

        return true;
}

// ***************************************************************************
void            CTessFace::refineAll()
{
        NL3D_PROFILE_LAND_ADD(ProfNRefineFaces, 1);
        NL3D_PROFILE_LAND_ADD(ProfNRefineLeaves, isLeaf()?1:0);

        /*
                if(ps<RefineThreshold), the face must be merged (ie have no leaves).
                if(ps E [RefineThreshold, RefineThreshold*2]), the face must be splitted (ave leaves), and is geomorphed.
                if(ps>RefineThreshold*2), the face is fully splitted/geomoprhed (tests reported on sons...).
        */

        // Test for Split or merge.
        //-----------------------
        {
                NL3D_PROFILE_LAND_ADD(ProfNRefineComputeFaces, 1);

                updateErrorMetric();
                float   ps=ErrorMetric;
                ps*= CLandscapeGlobals::OORefineThreshold;
                // 1.0f is the point of split().
                // 2.0f is the end of geomorph.


                // Test split/merge.
                //---------------------
                // If wanted, not already done, and limit not reached, split().
                if(isLeaf())
                {
                        if(ps>1.0f && Level< (Patch->TileLimitLevel + CLandscapeGlobals::TileMaxSubdivision) )
                                split();
                }
                else
                {
                        // Else, if splitted, must merge (if not already the case).
                        if(ps<1.0f)
                        {
                                // Merge only if agree, and neighbors agree.
                                // canMerge() test all the good thing: FBase==CantMergeFace, or this is rectangular etc...
                                // The test is propagated to neighbors.
                                if(canMerge(true))
                                {
                                        merge();
                                }
                        }
                }
        }

        // Recurs.
        //-----------------------
        if(SonLeft)
        {
                SonLeft->refineAll();
                SonRight->refineAll();
        }

}


// ***************************************************************************
// Some updateRefine***() Doc:

// Split or merge, and meaning of errorMetric:
/*
        if(errorMetric<RefineThreshold), the face must be merged (ie have no leaves).
        if(errorMetric E [RefineThreshold, RefineThreshold*2]), the face must be splitted (ave leaves), and is geomorphed.
        if(errorMetric>RefineThreshold*2), the face is fully splitted/geomoprhed.
*/


// Compute distNormalSplitMerge: distance from refineCenter to normal split/merge (ie without tile transition):
/*
        normal ErrorMetric formula is:
                em = Size*OORefineThreshold/ dist^2;    with dist == (SplitPoint - CLandscapeGlobals::RefineCenter).norm()
        So inverse this function and we have:
                dist= sqrt(Size*OORefineThreshold/em).
        Split or merge is when em==1, so
                distSplitMerge= sqrt(Size*OORefineThreshold)
*/


// Compute distTileTransSplitMerge.
/* When we are sure that CLandscapeGlobals::TileDistNear < distMinFace < CLandscapeGlobals::TileDistFar,
        the clamp in the original formula is skipped

        So the TileErrorMetric formula is:

        {
                ema= Sife*OORefineThreshold / distSP^2.
                f= (TileDistFar^2 - distMinFace^2) * OOTileDeltaDist^2
                f= f ^ 4.               // no clamp. see above.
                emb= NL*f + ema*(1-f)
                emFinal= max(ema, emb).
        }

        The problem is that the formula is too complex (degree 8 equation).
        So search for the result recursively.
*/


// Quadrant Selection
/*
        Quadrant/Direction is interesting for updateRefineSplit() only.
        In the 2 most simples cases, the action we want is "Know when we enters in a bounding volume"
        This fit well for Quadrant notion.

        In the case "TileDistNear to TileDistFar", the rule is too complicated and there is also
        the notion of "Know when we LEAVE the TileDistFar sphere around the face" which is incompatible
        with Quadrant behavior (since can go in any direction to leave the sphere).

        updateRefineMerge() are at least all notion of "Know when we LEAVE the SplitSphere around the SplitPoint"
        which is incompatible with Quadrant behavior.
        This is why updateRefineMerge() don't bother at all quadrant, and so the _MergePriorityList is inited with 0
        quadrants.

*/

// ***************************************************************************
void            CTessFace::updateRefineSplit()
{
        NL3D_PROFILE_LAND_ADD(ProfNRefineFaces, 1);

        nlassert(Patch);
        // The face must be not splitted, because tested for split.
        nlassert(isLeaf());

        /*
                NB: see above for some updateRefine*** doc.
        */

        // Test for Split.
        //-----------------------
        bool    splitted= false;
        {
                updateErrorMetric();
                float   ps=ErrorMetric;
                ps*= CLandscapeGlobals::OORefineThreshold;
                // 1.0f is the point of split().
                // 2.0f is the end of geomorph.


                // Test split.
                //---------------------
                // If wanted and limit not reached, split().
                if(ps>1.0f && Level< (Patch->TileLimitLevel + CLandscapeGlobals::TileMaxSubdivision) )
                {
                        split();

                        // if split ok
                        if(!isLeaf())
                        {
                                splitted= true;
                        }
                }
        }


        // Insert the face in the priority list.
        //-----------------------
        // If splitted, then insertion in Landscape->MergePriorityList at 0 has been done. so nothing to update.
        // Else, must compute when whe should re-test.
        if(!splitted)
        {
                // the face is not splitted here.
                nlassert(isLeaf());

                float   minDeltaDistToUpdate;

                // by default insert in the quadrant-less rolling table.
                uint    quadrantId= 0;


                CVector         dirToSplitPoint= SplitPoint - CLandscapeGlobals::RefineCenter;
                // The distance of SplitPoint to center.
                float           distSplitPoint= dirToSplitPoint.norm();
                // The distance where we should split/merge. see updateRefin() doc.
                float           distNormalSplitMerge= (float)sqrt(Size*CLandscapeGlobals::OORefineThreshold);


                // If the face is at its max subdivision
                if(Level>=Patch->TileLimitLevel+CLandscapeGlobals::TileMaxSubdivision)
                {
                        // special case: the face do not need to be tested for splitting, because Max subdivision reached.
                        // Hence just unlink from any list, and return.
                        unlinkInPList();
                        return;
                }
                else if(Level>=Patch->TileLimitLevel)
                {
                        // Always normal ErrorMetric. Because Faces at Tile level decide to split or merge their sons independently
                        // of "Tile ErrorMetric".

                        // The test is "when do we enter in the Split area?", so we can use Quadrant PriorityList
                        quadrantId= Patch->getLandscape()->_SplitPriorityList.selectQuadrant(dirToSplitPoint);

                        // compute distance to split as default "No Quadrant"
                        minDeltaDistToUpdate= distSplitPoint - distNormalSplitMerge;

                        // If a quadrant is  selected, try to use it
                        if(quadrantId>0)
                        {
                                const CVector   &quadrantDir= Patch->getLandscape()->_SplitPriorityList.getQuadrantDirection(quadrantId);

                                // We must not approach the SplitPoint at distNormalSplitMerge
                                float   dMin= quadrantDir*dirToSplitPoint - distNormalSplitMerge;

                                // If the dist with quadrant is too small then use the std way (without quadrant).
                                if( dMin<NL3D_TESS_USE_QUADRANT_THRESHOLD )
                                        quadrantId= 0;
                                // else ok, use quadrant behavior
                                else
                                        minDeltaDistToUpdate= dMin;
                        }
                }
                else
                {
                        // Compute Distance of the face from RefineCenter. It is the min of the 3 points, as in computeTileErrorMetric().
                        CVector dirToV0= VBase->EndPos - CLandscapeGlobals::RefineCenter;
                        CVector dirToV1= VLeft->EndPos - CLandscapeGlobals::RefineCenter;
                        CVector dirToV2= VRight->EndPos - CLandscapeGlobals::RefineCenter;
                        float   s0= dirToV0.sqrnorm();
                        float   s1= dirToV1.sqrnorm();
                        float   s2= dirToV2.sqrnorm();
                        float   distMinFace= (float)sqrt( minof(s0, s1, s2) );

                        // compute the delta distance to the normal split point. See above for doc.
                        float   normalEMDeltaDist;
                        normalEMDeltaDist= distSplitPoint - distNormalSplitMerge;


                        /*
                        There is 3 possibles cases, according to level, and the distances minFaceDist:
                        */
                        ///     TileDistFar to +oo.
                        if( distMinFace > CLandscapeGlobals::TileDistFar )
                        {
                                // The test is "when do we enter in the Split area OR in TileDistFar area?", so we can use Quadrant PriorityList
                                quadrantId= Patch->getLandscape()->_SplitPriorityList.selectQuadrant(dirToSplitPoint);

                                // compute deltaDist as default "Direction less quadrant"
                                minDeltaDistToUpdate= normalEMDeltaDist;
                                // We must know when we enter in TileErrorMetric zone, because the computing is different.
                                minDeltaDistToUpdate= min(minDeltaDistToUpdate, distMinFace - CLandscapeGlobals::TileDistFar);

                                // try with quadrant if > 0.
                                if(quadrantId>0)
                                {
                                        const CVector   &quadrantDir= Patch->getLandscape()->_SplitPriorityList.getQuadrantDirection(quadrantId);

                                        // We must not approach the SplitPoint at distNormalSplitMerge
                                        float   dMin= quadrantDir*dirToSplitPoint - distNormalSplitMerge;
                                        // and we must not reach one of the 3 sphere (Vi, TileDistFar).
                                        float   d0 = quadrantDir*dirToV0 - CLandscapeGlobals::TileDistFar;
                                        float   d1 = quadrantDir*dirToV1 - CLandscapeGlobals::TileDistFar;
                                        float   d2 = quadrantDir*dirToV2 - CLandscapeGlobals::TileDistFar;
                                        // take min dist
                                        dMin= minof(dMin, d0, d1, d2);

                                        // If the dist with quadrant is too small then use the std way (without quadrant).
                                        if( dMin<NL3D_TESS_USE_QUADRANT_THRESHOLD )
                                                quadrantId= 0;
                                        // else ok, use quadrant behavior
                                        else
                                                minDeltaDistToUpdate= dMin;
                                }
                        }
                        /// TileDistNear to TileDistFar.
                        else if( distMinFace > CLandscapeGlobals::TileDistNear )
                        {
                                // NB: can't use quadrant behavior here. Leave quadrantId at 0.

                                // Profile
                                NL3D_PROFILE_LAND_ADD(ProfNRefineInTileTransition, 1);

                                // Compute distance to split/Merge in TileTransition
                                float   distTileTransSplitMerge;
                                float   maxDeltaDist= 8;
                                float   minDeltaDist= 0;
                                uint    nbRecurs= 6;
                                float   nearLimit;
                                nearLimit= CLandscapeGlobals::RefineThreshold * computeNearLimit();
                                // search the distance to split recursively.
                                for(uint i=0; i< nbRecurs; i++)
                                {
                                        float   pivotDeltaDist= (maxDeltaDist-minDeltaDist)/2;
                                        // If the em computed with this distance is still <1 (ie merged), then we can move further.
                                        if ( computeTileEMForUpdateRefine(distSplitPoint-pivotDeltaDist, distMinFace-pivotDeltaDist, nearLimit ) < 1)
                                                minDeltaDist= pivotDeltaDist;
                                        // else we must move not as far
                                        else
                                                maxDeltaDist= pivotDeltaDist;
                                }
                                // And so take the minimum resulting delta distance
                                distTileTransSplitMerge= minDeltaDist;

                                // take the min with distance of distMinFace to the TileDistNear and TileDistFar sphere, because formula change at
                                // those limits.
                                minDeltaDistToUpdate= min(distTileTransSplitMerge, CLandscapeGlobals::TileDistFar - distMinFace );
                                minDeltaDistToUpdate= min(minDeltaDistToUpdate, distMinFace - CLandscapeGlobals::TileDistNear);
                        }
                        /// 0 to TileDistNear.
                        else
                        {
                                // because the face is not a Tile Level (ie Level<Patch->TileLimitLevel), it should be splitted,
                                // and won't merge until reaching at least the TileDistNear sphere.
                                // if not splited (should not arise), force the split next time.
                                minDeltaDistToUpdate= 0;
                        }

                }

                // Profile.
                if(minDeltaDistToUpdate<0.0625)
                {
                        NL3D_PROFILE_LAND_ADD(ProfNRefineWithLowDistance, 1);
                }


                // insert in the Split priority list.
                // Until the RefineCenter move under minDeltaDistToUpdate, we don't need to test face.
                Patch->getLandscape()->_SplitPriorityList.insert(quadrantId, minDeltaDistToUpdate, this);
        }
}


// ***************************************************************************
void            CTessFace::updateRefineMerge()
{
        NL3D_PROFILE_LAND_ADD(ProfNRefineFaces, 1);

        nlassert(Patch);
        // The face must be splitted, because tested for merge.
        nlassert(!isLeaf());

        /*
                NB: see above for some updateRefine*** doc.
        */

        // Test for merge.
        //-----------------------
        bool    merged= false;
        {
                updateErrorMetric();
                float   ps=ErrorMetric;
                ps*= CLandscapeGlobals::OORefineThreshold;
                // 1.0f is the point of split().
                // 2.0f is the end of geomorph.


                // Test merge.
                //---------------------
                // Else, must merge ??
                if(ps<1.0f)
                {
                        // Merge only if agree, and neighbors agree.
                        // canMerge() test all the good thing: FBase==CantMergeFace, or this is rectangular etc...
                        // The test is propagated to neighbors.
                        if(canMerge(true))
                        {
                                merge();

                                // NB: here, merge() is not propagated to fathers (supposed to be not very useful).

                                if(isLeaf())
                                {
                                        merged= true;
                                }
                        }
                }
        }


        // Insert the face in the priority list.
        //-----------------------
        // If merged, then insertion in Landscape->SplitPriorityList at 0 has been done. so nothing to update.
        // Else, must compute when whe should re-test.
        if(!merged)
        {
                // the face is splitted here.
                nlassert(!isLeaf());

                float   minDeltaDistToUpdate;


                // The distance of SplitPoint to center.
                float   distSplitPoint= (SplitPoint - CLandscapeGlobals::RefineCenter).norm();
                // Compute distance from refineCenter to normal split/merge (ie without tile transition).
                float   distNormalSplitMerge= (float)sqrt(Size*CLandscapeGlobals::OORefineThreshold);


                // If the face is at its max subdivision
                if(Level>=Patch->TileLimitLevel+CLandscapeGlobals::TileMaxSubdivision)
                {
                        // since the face is splitted, then must test always this face, because we must merge it (as soon as it is possible).
                        minDeltaDistToUpdate= 0;
                }
                else if(Level>=Patch->TileLimitLevel)
                {
                        // Always normal ErrorMetric. Because Faces at Tile level decide to split or merge their sons independently
                        // of "Tile ErrorMetric".
                        // since splitted, compute distance to merge.
                        minDeltaDistToUpdate= distNormalSplitMerge - distSplitPoint;
                        // NB: it is possible that minDeltaDistToUpdate<0. A good example is when we are enforced split.
                        // Then, distSplitMerge may be < distSplitPoint, meaning we should have not split, but a neigbhor has enforced us.
                        // So now, must test every frame if we can merge....
                        minDeltaDistToUpdate= max( 0.f, minDeltaDistToUpdate );
                }
                else
                {
                        // Compute Distance of the face from RefineCenter. It is the min of the 3 points, as in computeTileErrorMetric().
                        float   s0= (VBase->EndPos - CLandscapeGlobals::RefineCenter).sqrnorm();
                        float   s1= (VLeft->EndPos - CLandscapeGlobals::RefineCenter).sqrnorm();
                        float   s2= (VRight->EndPos - CLandscapeGlobals::RefineCenter).sqrnorm();
                        float   distMinFace= (float)sqrt( minof(s0, s1, s2) );

                        // compute the delta distance to the normal split point. See above for doc.
                        float   normalEMDeltaDist;
                        normalEMDeltaDist= distNormalSplitMerge - distSplitPoint;
                        normalEMDeltaDist= max( 0.f, normalEMDeltaDist );


                        /*
                        There is 3 possibles cases, according to level, and the distances minFaceDist:
                        */
                        ///     TileDistFar to +oo.
                        if( distMinFace > CLandscapeGlobals::TileDistFar )
                        {
                                // normal geomorph. Any face compute the distance to the SplitPoint, and take min with distance to
                                // the TileDistFar sphere.
                                minDeltaDistToUpdate= normalEMDeltaDist;

                                // We must know when we enter in TileErrorMetric zone, because the computing is different.
                                minDeltaDistToUpdate= min(minDeltaDistToUpdate, distMinFace - CLandscapeGlobals::TileDistFar);
                        }
                        /// TileDistNear to TileDistFar.
                        else if( distMinFace > CLandscapeGlobals::TileDistNear )
                        {
                                // Profile
                                NL3D_PROFILE_LAND_ADD(ProfNRefineInTileTransition, 1);


                                // Compute distance to split/Merge in TileTransition
                                float   distTileTransSplitMerge;
                                float   maxDeltaDist= 8;
                                float   minDeltaDist= 0;
                                uint    nbRecurs= 6;
                                float   nearLimit;
                                nearLimit= CLandscapeGlobals::RefineThreshold * computeNearLimit();
                                // Since splitted, compute distance to merge.
                                // search the distance recursively.
                                for(uint i=0; i< nbRecurs; i++)
                                {
                                        float   pivotDeltaDist= (maxDeltaDist-minDeltaDist)/2;
                                        // If the em computed with this distance is still >1 (ie splitted), then we can move further.
                                        if ( computeTileEMForUpdateRefine(distSplitPoint+pivotDeltaDist, distMinFace+pivotDeltaDist, nearLimit ) > 1)
                                                minDeltaDist= pivotDeltaDist;
                                        // else we must move not as far
                                        else
                                                maxDeltaDist= pivotDeltaDist;
                                }
                                // And so take the minimum resulting delta distance
                                distTileTransSplitMerge= minDeltaDist;

                                // take the min with distance of distMinFace to the TileDistNear and TileDistFar sphere, because formula change at
                                // those limits.
                                minDeltaDistToUpdate= min(distTileTransSplitMerge, CLandscapeGlobals::TileDistFar - distMinFace );
                                minDeltaDistToUpdate= min(minDeltaDistToUpdate, distMinFace - CLandscapeGlobals::TileDistNear);
                        }
                        /// 0 to TileDistNear.
                        else
                        {
                                // because the face is not a Tile Level (ie Level<Patch->TileLimitLevel), it should be splitted,
                                // and won't merge until reaching at least the TileDistNear sphere.
                                // Since splitted, Must enter in TileErrorMetric area to know when to merge.
                                minDeltaDistToUpdate= CLandscapeGlobals::TileDistNear - distMinFace;
                        }

                }

                // Merge Refine Threshold: because of enforced splits, we have lot of faces whit minDeltaDistToUpdate<0, because
                // they alwayas want to merge. To avoid this, add a delta, which delay the test for merge.
                // The caveat is that faces which do not need this may merge later. But 2 meters won't add too many faces.
                minDeltaDistToUpdate+= NL3D_REFINE_MERGE_THRESHOLD;

                // insert in the Merge priority list.
                // Until the RefineCenter move under minDeltaDistToUpdate, we don't need to test face.
                Patch->getLandscape()->_MergePriorityList.insert(0, minDeltaDistToUpdate, this);
        }
}


// ***************************************************************************
void            CTessFace::unbind()
{
        // NB: since CantMergeFace has a NULL patch ptr, it is unbound too.

        // Square case.
        //=============
        if(!isRectangular())
        {
                // Change Left/Right neighbors.
                if(isLeaf())
                {
                        // FLeft and FRight pointers are only valid in Leaves nodes.
                        if(FLeft && FLeft->Patch!=Patch)
                        {
                                FLeft->changeNeighbor(this, NULL);
                                FLeft= NULL;
                        }
                        if(FRight && FRight->Patch!=Patch)
                        {
                                FRight->changeNeighbor(this, NULL);
                                FRight= NULL;
                        }
                }
                // Change Base neighbors.
                if(FBase && FBase->Patch!=Patch)
                {
                        CTessFace       *oldNeigbhorFace= FBase;

                        FBase->changeNeighbor(this, NULL);
                        FBase= NULL;
                        if(!isLeaf())
                        {
                                // Duplicate the VBase of sons, so the unbind is correct and no vertices are shared.
                                CTessVertex     *old= SonLeft->VBase;
                                SonLeft->VBase= Patch->getLandscape()->newTessVertex();
                                *(SonLeft->VBase)= *old;
                                SonRight->VBase= SonLeft->VBase;

                                // For geomorph (VertexProgram or soft), compute good MaxFaceSize and MaxNearLimit (change since unbinded)
                                // update us.
                                SonLeft->VBase->MaxFaceSize= Size;
                                SonLeft->VBase->MaxNearLimit= computeNearLimit();
                                // update our neigbhor, only if not a multiple patch face.
                                if(oldNeigbhorFace->Patch)
                                {
                                        old->MaxFaceSize= oldNeigbhorFace->Size;
                                        old->MaxNearLimit= oldNeigbhorFace->computeNearLimit();
                                }
                        }
                }
        }
        // Rectangular case.
        //==================
        else
        {
                // Doens't need to test FBase, since must be same patch.
                // In rectangular, FLeft has the behavior of FBase in square case.
                if(FLeft && FLeft->Patch!=Patch)
                {
                        CTessFace       *oldNeigbhorFace= FLeft;

                        FLeft->changeNeighbor(this, NULL);
                        FLeft= NULL;
                        if(!isLeaf())
                        {
                                // Duplicate the VBase of sons, so the unbind is correct and no vertices are shared.
                                // NB: this code is a bit different from square case.
                                CTessVertex     *old= SonLeft->VBase;
                                SonLeft->VBase= Patch->getLandscape()->newTessVertex();
                                *(SonLeft->VBase)= *old;
                                // This is the difference:  (see rectangle tesselation rules).
                                SonRight->VLeft= SonLeft->VBase;
                                // Yoyo_patch_himself (12/02/2001): I forgot this one!!
                                nlassert(FBase && FBase->SonLeft);
                                FBase->SonLeft->VRight= SonLeft->VBase;


                                // For geomorph (VertexProgram or soft), compute good MaxFaceSize and MaxNearLimit (change since unbinded)
                                // update us.
                                SonLeft->VBase->MaxFaceSize= Size;
                                SonLeft->VBase->MaxNearLimit= computeNearLimit();
                                // update our neigbhor, only if not a multiple patch face.
                                if(oldNeigbhorFace->Patch)
                                {
                                        old->MaxFaceSize= oldNeigbhorFace->Size;
                                        old->MaxNearLimit= oldNeigbhorFace->computeNearLimit();
                                }
                        }
                }
                // But FRight still valid in leaves nodes only.
                if(isLeaf())
                {
                        if(FRight && FRight->Patch!=Patch)
                        {
                                FRight->changeNeighbor(this, NULL);
                                FRight= NULL;
                        }
                }
        }

        // Propagate unbind.
        //==================
        if(!isLeaf())
        {
                // update sons vertex pointers (since they may have been updated by me or my grandfathers).
                if(!isRectangular())
                {
                        SonLeft->VLeft= VBase;
                        SonLeft->VRight= VLeft;
                        SonRight->VLeft= VRight;
                        SonRight->VRight= VBase;
                }
                else
                {
                        // Rectangular case. Update only ptrs which may have changed.
                        SonLeft->VLeft= VLeft;
                        SonRight->VBase= VBase;
                        SonRight->VRight= VRight;
                }

                // Must re-create good Vertex links for Far and Near Vertices!!!
                SonLeft->updateNearFarVertices();
                SonRight->updateNearFarVertices();
                if(isRectangular())
                {
                        //NB: must do this for Base neighbor (see unbind() rectangular case...).
                        nlassert(FBase && FBase->SonLeft && FBase->SonRight);
                        FBase->SonLeft->updateNearFarVertices();
                        FBase->SonRight->updateNearFarVertices();
                }

                // unbind the sons.
                SonLeft->unbind();
                SonRight->unbind();
        }

}
// ***************************************************************************
void            CTessFace::forceMerge()
{
        if(this== &CantMergeFace)
                return;

        if(!isLeaf())
        {
                // First, force merge of Sons and neighbor sons, to have a diamond configuration.
                SonLeft->forceMerge();
                SonRight->forceMerge();

                // forceMerge of necessary neighbors.
                RecursMarkForceMerge=true;
                if(!isRectangular())
                {
                        if(FBase && !FBase->RecursMarkForceMerge)
                                FBase->forceMerge();
                }
                else
                {
                        // Rectangular case. May have a longer propagation...
                        if(FBase && !FBase->RecursMarkForceMerge)
                                FBase->forceMerge();
                        if(FLeft && !FLeft->RecursMarkForceMerge)
                                FLeft->forceMerge();
                }
                RecursMarkForceMerge=false;

                // If still a parent, merge.
                if(!isLeaf())
                        merge();
        }
}


// ***************************************************************************
void            CTessFace::forceMergeAtTileLevel()
{
        if(this== &CantMergeFace)
                return;

        if(!isLeaf())
        {
                SonLeft->forceMergeAtTileLevel();
                SonRight->forceMergeAtTileLevel();
        }
        else
        {
                // If we are at tile subdivision, we must force our sons to merge.
                if(Level==Patch->TileLimitLevel)
                        forceMerge();
        }
}


// ***************************************************************************
void            CTessFace::averageTesselationVertices()
{
        // If we are not splitted, no-op.
        if(isLeaf())
                return;


        CTessFace       *neighbor;
        // Normal square case.
        if(!isRectangular())
        {
                neighbor= FBase;
        }
        // Special Rectangular case.
        else
        {
                // NB: here, just need to compute average of myself with FLeft, because my neighbor FBase
                // is on same patch (see splitRectangular()), and is average with its FLeft neighbor is done
                // on another branch of the recurs call.
                neighbor= FLeft;
        }


        /* Try to average with neighbor.
                - if no neighbor, no-op :).
                - if neighbor is bind 1/N (CantMergeFace), no-op too, because the vertex is a BaseVertex, so don't modify.
                - if my patch is same than my neighbor, then we are on a same patch :), and so no need to average.
        */
        if(neighbor!=NULL && neighbor!=&CantMergeFace && Patch!= neighbor->Patch)
        {
                nlassert(neighbor->Patch);
                nlassert(!neighbor->isLeaf());
                // must compute average beetween me and my neighbor.
                // NB: this work with both rectangular and square triangles (see split*()).
                nlassert(SonLeft->VBase == neighbor->SonLeft->VBase);

                CVector         v0= Patch->computeVertex(SonLeft->PVBase.getS(), SonLeft->PVBase.getT());
                CVector         v1= neighbor->Patch->computeVertex(neighbor->SonLeft->PVBase.getS(), neighbor->SonLeft->PVBase.getT());

                // And so set the average.
                SonLeft->VBase->EndPos= (v0+v1)/2;
        }


        // Do same thing for sons. NB: see above, we are not a leaf.
        SonLeft->averageTesselationVertices();
        SonRight->averageTesselationVertices();
}


// ***************************************************************************
void            CTessFace::refreshTesselationGeometry()
{
        // must enlarge the little tessBlock (if any), for clipping.
        Patch->extendTessBlockWithEndPos(this);

        // If we are not splitted, no-op.
        if(isLeaf())
                return;


        /* NB: rectangular case: just need to take SonLeft->VBase, because my neighbor on FBase will compute his son
                on another branch of the recurs call.
        */
        // re-compute this position (maybe with new noise geometry in Tile Edition).
        SonLeft->VBase->EndPos= Patch->computeVertex(SonLeft->PVBase.getS(), SonLeft->PVBase.getT());
        // overwrite cur Pos (NB: specialy hardcoded for Tile edition).
        SonLeft->VBase->Pos= SonLeft->VBase->EndPos;

        // Do same thing for sons. NB: see above, we are not a leaf.
        SonLeft->refreshTesselationGeometry();
        SonRight->refreshTesselationGeometry();
}


// ***************************************************************************
bool            CTessFace::updateBindEdge(CTessFace     *&edgeFace, bool &splitWanted)
{
        // Return true, when the bind should be Ok, or if a split has occurred.
        // Return false only if pointers are updated, without splits.

        if(edgeFace==NULL)
                return true;

        if(edgeFace->isLeaf())
                return true;

        /*
                Look at the callers, and you'll see that "this" is always a leaf.
                Therefore, edgeFace is a valid pointer (either if it is FLeft, FRight or FBase).
        */

        // MultiPatch face case.
        //======================
        // If neighbor is a multiple face.
        if(edgeFace->Patch==NULL && edgeFace->FBase==this)
        {
                splitWanted= true;
                return true;
        }


        // neighbor is a "Square face" case.
        //==================================
        if(!edgeFace->isRectangular())
        {
                // NB: this code works either if I AM a rectangular face or a square face.

                // If the neighbor is splitted  on ourself, split...
                if(edgeFace->FBase==this)
                {
                        splitWanted= true;
                        return true;
                }
                else
                {
                        // Just update pointers...
                        if(edgeFace->FLeft==this)
                        {
                                CTessFace       *sonLeft= edgeFace->SonLeft;
                                sonLeft->FBase= this;
                                edgeFace= sonLeft;
                        }
                        else if(edgeFace->FRight==this)
                        {
                                CTessFace       *sonRight= edgeFace->SonRight;
                                sonRight->FBase= this;
                                edgeFace= sonRight;
                        }
                        else
                        {
                                // Look at the callers, and you'll see that "this" is always a leaf.
                                // Therefore, we should never be here.
                                nlstop;
                        }
                }
        }
        // neighbor is a "Rectangle face" case.
        //=====================================
        else
        {
                // NB: this code works either if I AM a rectangular face or a square face.

                // If the neighbor is splitted  on ourself, split...
                // Test FLeft because of rectangular case... :)
                // FBase should be tested too. If edgeFace->FBase==this, I should be myself a rectangular face.
                if(edgeFace->FLeft==this || edgeFace->FBase==this)
                {
                        splitWanted= true;
                        return true;
                }
                else
                {
                        if(edgeFace->FRight==this)
                        {
                                // See rectangular tesselation rules, too know why we do this.
                                CTessFace       *sonRight= edgeFace->SonRight;
                                sonRight->FRight= this;
                                edgeFace= sonRight;
                        }
                        else
                        {
                                // Look at the callers, and you'll see that "this" is always a leaf.
                                // Therefore, we should never be here.
                                nlstop;
                        }
                }
        }

        return false;
}



// ***************************************************************************
void            CTessFace::updateBindAndSplit()
{
        bool    splitWanted= false;
        CTessFace       *f0= NULL;
        CTessFace       *f1= NULL;
        /*
                Look at the callers, and you'll see that "this" is always a leaf.
                Therefore, FBase, FLeft and FRight are good pointers, and *FLeft and *FRight should be Ok too.
        */
        nlassert(isLeaf());
        while(!updateBindEdge(FBase, splitWanted));
        // FLeft and FRight pointers are only valid in Leaves nodes.
        while(!updateBindEdge(FLeft, splitWanted));
        while(!updateBindEdge(FRight, splitWanted));
        // In rectangular case, we MUST also update edges of FBase.
        // Because splitRectangular() split those two faces at the same time.
        if(isRectangular())
        {
                f0= this;
                f1= FBase;
                nlassert(FBase);
                nlassert(FBase->isLeaf());
                // Doesn't need to update FBase->FBase, since it's me!
                // FLeft and FRight pointers are only valid in Leaves nodes.
                while(!FBase->updateBindEdge(FBase->FLeft, splitWanted));
                while(!FBase->updateBindEdge(FBase->FRight, splitWanted));
        }



        CTessFace       *fmult= NULL;
        CTessFace       *fmult0= NULL;
        CTessFace       *fmult1= NULL;
        // If multipatch face case.
        //=========================
        if(!isRectangular())
        {
                // multipatch face case are detected when face->Patch==NULL !!!
                if(FBase && FBase->Patch==NULL)
                {
                        fmult= FBase;
                        // First, trick: FBase is NULL, so during the split. => no ptr problem.
                        FBase= NULL;
                }
        }
        else
        {
                nlassert(f0);
                nlassert(f1);
                // multipatch face case are detected when face->Patch==NULL !!!
                if(f0->FLeft && f0->FLeft->Patch==NULL)
                {
                        fmult0= f0->FLeft;
                        // First, trick: neighbor is NULL, so during the split. => no ptr problem.
                        f0->FLeft= NULL;
                }
                // multipatch face case are detected when face->Patch==NULL !!!
                if(f1->FLeft && f1->FLeft->Patch==NULL)
                {
                        fmult1= f1->FLeft;
                        // First, trick: neighbor is NULL, so during the split. => no ptr problem.
                        f1->FLeft= NULL;
                }
        }

        // Then split, and propagate.
        //===========================
        split(false);
        if(!isRectangular())
        {
                if(FBase)
                {
                        while(FBase->isLeaf())
                                FBase->updateBindAndSplit();
                }
                // There is a possible bug here (maybe easily patched). Sons may have be propagated splitted.
                // And problems may arise because this face hasn't yet good connectivity.
                nlassert(SonLeft->isLeaf() && SonRight->isLeaf());
        }
        else
        {
                nlassert(f0);
                nlassert(f1);
                if(f0->FLeft)
                {
                        while(f0->FLeft->isLeaf())
                                f0->FLeft->updateBindAndSplit();
                }
                if(f1->FLeft)
                {
                        while(f1->FLeft->isLeaf())
                                f1->FLeft->updateBindAndSplit();
                }
                // There is a possible bug here (maybe easily patched). Sons may have be propagated splitted.
                // And problems may arise because this face hasn't yet good connectivity.
                nlassert(f0->SonLeft->isLeaf() && f0->SonRight->isLeaf());
                nlassert(f1->SonLeft->isLeaf() && f1->SonRight->isLeaf());
        }


        // If multipatch face case, update neighbors.
        //===========================================
        if(!isRectangular() && fmult)
        {
                // Update good Face neighbors.
                //============================
                SonLeft->FRight= fmult->SonRight;
                fmult->SonRight->changeNeighbor(&CTessFace::MultipleBindFace, SonLeft);

                SonRight->FLeft= fmult->SonLeft;
                fmult->SonLeft->changeNeighbor(&CTessFace::MultipleBindFace, SonRight);

                // NB: this work auto with 1/2 or 1/4. See CPatch::bind(), to understand.
                // In 1/4 case, fmult->SonLeft and fmult->SonRight are themselves MultiPatch face. So it will recurse.

                // Update good vertex pointer.
                //============================
                CTessVertex     *vert= fmult->VBase;

                // Copy the good coordinate: those splitted (because of noise).
                vert->Pos= vert->StartPos= vert->EndPos= SonLeft->VBase->EndPos;
                // But delete the pointer.
                Patch->getLandscape()->deleteTessVertex(SonLeft->VBase);
                // And update sons pointers, to good vertex.
                SonLeft->VBase= vert;
                SonRight->VBase= vert;
                // Compute correct centers.
                SonRight->computeSplitPoint();
                SonLeft->computeSplitPoint();


                // Update good Far vertex pointer.
                //================================
                // Because *->VBase may have been merged to the multiple bind face, Near/FarVertices which pointed on it must
                // be setup.
                // We do not have to propagate this vertex ptr change since sons are leaves!!
                nlassert(SonLeft->isLeaf() && SonRight->isLeaf());
                // update pointers on vertex.
                SonLeft->updateNearFarVertices();
                SonRight->updateNearFarVertices();


                // Bind FBase to a false face which indicate a bind 1/N.
                // This face prevent for "this" face to be merged...
                FBase= &CantMergeFace;

                // Therefore, the vertex will be never deleted (since face not merged).
                // The only way to do this, is to unbind the patch from all (then the vertex is cloned), then the merge will be Ok.
        }
        // Else if rectangular.
        else if(fmult0 || fmult1)
        {
                CTessFace       *f;
                sint            i;
                nlassert(f0);
                nlassert(f1);

                // Same reasoning for rectangular patchs, as above.
                for(i=0;i<2;i++)
                {
                        if(i==0)
                                f= f0, fmult= fmult0;
                        else
                                f= f1, fmult= fmult1;
                        if(fmult)
                        {
                                // Update good Face neighbors (when I am a rectangle).
                                //============================
                                // Consider the fmult face as a square face.
                                CTessFace       *toLeft, *toRight;
                                CTessFace       *fl=f->SonLeft, *fr=f->SonRight;
                                toLeft= fmult->SonLeft;
                                toRight= fmult->SonRight;
                                // Cross connection of sons.
                                fl->FLeft= toLeft;
                                fr->FLeft= toRight;
                                toLeft->changeNeighbor(&CTessFace::MultipleBindFace, fl);
                                toRight->changeNeighbor(&CTessFace::MultipleBindFace, fr);

                                // Update good vertex pointer.
                                //============================
                                CTessVertex     *vert= fmult->VBase;

                                // Copy the good coordinate: those splitted (because of noise).
                                // NB: this work too with rectangular patch (see tesselation rules).
                                vert->Pos= vert->StartPos= vert->EndPos= fl->VBase->EndPos;
                                // But delete the pointer.
                                Patch->getLandscape()->deleteTessVertex(fl->VBase);
                                // And update sons pointers, to good vertex (rectangular case, see tesselation rules).
                                fl->VBase= vert;
                                fr->VLeft= vert;
                                f->FBase->SonLeft->VRight= vert;

                                // Point to a bind 1/N indicator.
                                f->FLeft= &CantMergeFace;
                        }
                }
                // After all updates done. recompute centers of both sons 's faces, and update far vertices pointers.
                for(i=0;i<2;i++)
                {
                        if(i==0)
                                f= f0;
                        else
                                f= f1;
                        // Compute correct centers.
                        f->SonRight->computeSplitPoint();
                        f->SonLeft->computeSplitPoint();

                        // Update good Far vertex pointer.
                        //================================
                        // Because *->VBase may have been merged to the multiple bind face, Near/FarVertices which pointed on it must
                        // be setup.
                        // We do not have to propagate this vertex ptr change, since sons are leaves!!
                        nlassert(f->SonLeft->isLeaf() && f->SonRight->isLeaf());
                        // update pointers on vertex.
                        f->SonLeft->updateNearFarVertices();
                        f->SonRight->updateNearFarVertices();
                }
        }
}


// ***************************************************************************
void            CTessFace::updateBind()
{
        /*
                Remind that updateBind() is called ONLY on the patch which is binded (not the neighbors).
                Since updateBind() is called on the bintree, and that precedent propagated split may have occur, we may not
                be a leaf here. So we are not sure that FLeft and FRight are good, and we doesn't need to update them (since we have
                sons).
                Also, since we are splitted, and correctly linked (this may not be the case in updateBindAndSplit()), FBase IS
                correct. His FBase neighbor and him form a diamond. So we don't need to update him.

                Same remarks for rectangular patchs.
        */
        if(isLeaf())
        {
                bool    splitWanted= false;
                while(!updateBindEdge(FBase, splitWanted));
                // FLeft and FRight pointers are only valid in Leaves nodes.
                while(!updateBindEdge(FLeft, splitWanted));
                while(!updateBindEdge(FRight, splitWanted));
                if(splitWanted)
                        updateBindAndSplit();
        }


        // Recurse to sons.
        if(!isLeaf())
        {
                // Update bind of sons.
                SonLeft->updateBind();
                SonRight->updateBind();
        }
}

// ***************************************************************************
static  inline bool     matchEdge(const CVector2f &uv0, const CVector2f &uv1, const CVector2f &uva, const CVector2f &uvb)
{
        if(uv0==uva && uv1==uvb)
                return true;
        if(uv0==uvb && uv1==uva)
                return true;
        return false;
}

// ***************************************************************************
CTessFace               *CTessFace::linkTessFaceWithEdge(const CVector2f &uv0, const CVector2f &uv1, CTessFace *linkTo)
{
        // Compute 0,1 coords of 3 patch coords.
        CVector2f       vb( PVBase.getS(), PVBase.getT() );
        CVector2f       vl( PVLeft.getS(), PVLeft.getT() );
        CVector2f       vr( PVRight.getS(), PVRight.getT() );

        // Search if one of the 3 edges of this triangle match the wanted edge.
        // Base Edge
        if(matchEdge(uv0, uv1, vl, vr))
        {
                // If leaf, check if unbound (else ptr is invalid)
                nlassert(FBase==NULL || !isLeaf());
                FBase= linkTo;
                return this;
        }
        // Left Edge
        if(matchEdge(uv0, uv1, vb, vl))
        {
                // If leaf, check if unbound (else ptr is invalid)
                nlassert(FLeft==NULL || !isLeaf());
                FLeft= linkTo;
                return this;
        }
        // Right Edge
        if(matchEdge(uv0, uv1, vb, vr))
        {
                // If leaf, check if unbound (else ptr is invalid)
                nlassert(FRight==NULL || !isLeaf());
                FRight= linkTo;
                return this;
        }


        // If not found here, recurs to children
        CTessFace       *ret= NULL;
        if( !isLeaf() )
        {
                ret= SonLeft->linkTessFaceWithEdge(uv0, uv1, linkTo);
                // if no found in this branch, recusr right branch.
                if(!ret)
                        ret= SonRight->linkTessFaceWithEdge(uv0, uv1, linkTo);
        }

        // return the result from subBranchs
        return ret;
}


// ***************************************************************************
bool            CTessFace::isRectangular() const
{
        return Level<Patch->SquareLimitLevel;
}



// ***************************************************************************
// ***************************************************************************
// For changePatchTexture.
// ***************************************************************************
// ***************************************************************************


// ***************************************************************************
void            CTessFace::deleteTileUvs()
{
        // NB: NearVertices are removed from renderlist with deleteTileUv (called in releaseTileMaterial()).

        if(!isLeaf())
        {
                // Must delete the materials of leaves first.
                SonLeft->deleteTileUvs();
                SonRight->deleteTileUvs();
                if(SonLeft->Level== Patch->TileLimitLevel)
                {
                        // Square patch assumption: the sons are not of the same TileId/Patch.
                        nlassert(!sameTile(SonLeft, SonRight));
                        // release tiles.
                        SonLeft->releaseTileMaterial();
                        SonRight->releaseTileMaterial();
                }
                else if(SonLeft->Level > Patch->TileLimitLevel)
                {
                        nlassert(!FBase || !FBase->isLeaf());

                        // Delete Uv, only if not already done by the neighbor (ie neighbor has yet TileFaces!!).
                        // But Always delete if neighbor exist and has not same tile as me.
                        // NB: this work with rectangular neigbor patch, since sameTile() will return false if different patch.
                        if(!FBase || !FBase->SonLeft->emptyTileFaces() || !sameTile(this, FBase))
                        {
                                SonLeft->deleteTileUv(IdUvBase);
                        }
                        // In all case, must delete the tilefaces of those face.
                        SonLeft->deleteTileFaces();
                        SonRight->deleteTileFaces();
                        // For createTileUvs, it is important to mark those faces as NO TileMaterial.
                        SonLeft->TileMaterial= NULL;
                        SonRight->TileMaterial= NULL;
                }
        }
        else
        {
                // NB: this is done always BELOW tile creation (see above).
                // Do this only for tiles.
                if(TileMaterial)
                        Patch->removeFaceFromTileRenderList(this);
        }

}


// ***************************************************************************
void            CTessFace::recreateTileUvs()
{
        // NB: NearVertices are append to renderlist with allocTileUv (called in computeTileMaterial()/heritTileMaterial()).

        if(!isLeaf())
        {
                // Must recreate the materials of parent first.

                // There is no problem with rectangular patch, since tiles are always squares.
                // If new tile ....
                if(SonLeft->Level==Patch->TileLimitLevel)
                {
                        SonLeft->computeTileMaterial();
                        SonRight->computeTileMaterial();
                }
                // else Tile herit.
                else if(SonLeft->Level > Patch->TileLimitLevel)
                {
                        heritTileMaterial();
                }

                SonLeft->recreateTileUvs();
                SonRight->recreateTileUvs();
        }
        else
        {
                // NB: this is done always AFTER tile creation (see above).
                // Do this only for tiles.
                if(TileMaterial)
                        Patch->appendFaceToTileRenderList(this);
        }
}



// ***************************************************************************
void            CTessFace::heritTileMaterial()
{
        SonLeft->TileMaterial= TileMaterial;
        SonLeft->TileId= TileId;
        SonLeft->buildTileFaces();
        SonLeft->copyTileUv(IdUvLeft, this, IdUvBase);
        SonLeft->copyTileUv(IdUvRight, this, IdUvLeft);

        SonRight->TileMaterial= TileMaterial;
        SonRight->TileId= TileId;
        SonRight->buildTileFaces();
        SonRight->copyTileUv(IdUvLeft, this, IdUvRight);
        SonRight->copyTileUv(IdUvRight, this, IdUvBase);

        // Create, or link to the tileUv.
        // Try to link to a neighbor TileUv.
        // Can only work iff exist, and iff FBase is same patch, and same TileId.
        if(FBase!=NULL && !FBase->isLeaf() && FBase->SonLeft->TileMaterial!=NULL && sameTile(this, FBase) )
        {
                // Ok!! link to the (existing) TileUv.
                // FBase->SonLeft!=NULL since FBase->isLeaf()==false.
                SonLeft->copyTileUv(IdUvBase, FBase->SonLeft, IdUvBase);
                SonRight->copyTileUv(IdUvBase, FBase->SonLeft, IdUvBase);
        }
        else
        {
                // Allocate a new vertex, and copy it to SonLeft and SonRight.
                SonLeft->allocTileUv(IdUvBase);
                SonRight->copyTileUv(IdUvBase, SonLeft, IdUvBase);

                // Fill the new near vertex, with middle of Left/Right father.
                SonLeft->heritTileUv(this);

                // UVs are computed, may create and fill VB.
                SonLeft->checkCreateFillTileVB(IdUvBase);
        }

}


// ***************************************************************************
// ***************************************************************************
// For getTesselatedPos
// ***************************************************************************
// ***************************************************************************


// ***************************************************************************
void                    CTessFace::getTesselatedPos(const CUV &uv, bool verifInclusion, CVector &ret)
{
        CVector         uvPos(uv.U, uv.V, 0);

        // may verif if uv is In this triangle. supposed true if rectangular branch.
        if(verifInclusion && !(isRectangular() && !isLeaf()) )
        {
                CVector         uvs[3];
                uvs[0].set( PVBase.getS(), PVBase.getT(), 0);
                uvs[1].set( PVLeft.getS(), PVLeft.getT(), 0);
                uvs[2].set( PVRight.getS(), PVRight.getT(), 0);
                for(sint i=0; i<3; i++)
                {
                        CVector         dUv= uvs[(i+1)%3] - uvs[i];
                        CVector         normalUv(dUv.y, -dUv.x, 0);
                        // if out this 2D plane, uv is out this triangle
                        if(normalUv * (uvPos-uvs[i]) <0)
                                return;
                }
        }

        // compute tesselated pos in this face.
        if(isLeaf())
                // ok, no more sons, let's do it.
                computeTesselatedPos(uv, ret);
        else
        {
                // must subdivide.
                // if we are rectangular (strange tesselation), must test in both leaves, else, choose only one.
                if(isRectangular())
                {
                        SonLeft->getTesselatedPos(uv, true, ret);
                        SonRight->getTesselatedPos(uv, true, ret);
                }
                else
                {
                        // Compute the uv plane which separate the 2 leaves.
                        CVector         uvBase, uvMiddle;
                        uvBase.set  ( PVBase.getS(), PVBase.getT(), 0);
                        uvMiddle.set( SonLeft->PVBase.getS(), SonLeft->PVBase.getT(), 0);
                        CVector         dUv= uvMiddle - uvBase;
                        CVector         normalUv(dUv.y, -dUv.x, 0);
                        // choose what leaf to recurs.
                        if(normalUv * (uvPos - uvBase) <0)
                                SonLeft->getTesselatedPos(uv, false, ret);
                        else
                                SonRight->getTesselatedPos(uv, false, ret);

                }
        }

}


// ***************************************************************************
void                    CTessFace::computeTesselatedPos(const CUV &uv, CVector &ret)
{
        CVector         uvPos(uv.U, uv.V, 0);

        // compute the UV triangle of this face.
        CTriangle       uvTri;
        uvTri.V0.set( PVBase.getS(), PVBase.getT(), 0);
        uvTri.V1.set( PVLeft.getS(), PVLeft.getT(), 0);
        uvTri.V2.set( PVRight.getS(), PVRight.getT(), 0);

        // must interpolate the position with given UV, so compute XYZ gradients.
        CVector         Gx;
        CVector         Gy;
        CVector         Gz;
        // If VertexProgram activated
        if( CLandscapeGlobals::VertexProgramEnabled )
        {
                // then Must update geomorphed position because not done !!
                VBase->computeGeomPos();
                VLeft->computeGeomPos();
                VRight->computeGeomPos();
        }
        // NB: take geomorphed position.
        uvTri.computeGradient(VBase->Pos.x, VLeft->Pos.x, VRight->Pos.x, Gx);
        uvTri.computeGradient(VBase->Pos.y, VLeft->Pos.y, VRight->Pos.y, Gy);
        uvTri.computeGradient(VBase->Pos.z, VLeft->Pos.z, VRight->Pos.z, Gz);

        // Compute interpolated position.
        ret= VBase->Pos;
        uvPos-= uvTri.V0;
        ret.x+= Gx*uvPos;
        ret.y+= Gy*uvPos;
        ret.z+= Gz*uvPos;

}


// ***************************************************************************
void                    CTessFace::appendTessellationLeaves(std::vector<const CTessFace*>  &leaves) const
{
        if(isLeaf())
                leaves.push_back(this);
        else
        {
                SonLeft->appendTessellationLeaves(leaves);
                SonRight->appendTessellationLeaves(leaves);
        }
}


} // NL3D