Change Encyclo button name and macros icon

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

// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
// Copyright (C) 2010  Winch Gate Property Limited
//
// 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/patch.h"
#include "nel/3d/tessellation.h"
#include "nel/3d/bezier_patch.h"
#include "nel/3d/zone.h"
#include "nel/3d/landscape.h"
#include "nel/misc/vector.h"
#include "nel/misc/common.h"
#include "nel/3d/tile_noise_map.h"
#include "nel/3d/patchuv_locator.h"

using   namespace       std;
using   namespace       NLMISC;

#ifdef DEBUG_NEW
#define new DEBUG_NEW
#endif

namespace NL3D
{


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


#if defined(NL_OS_WINDOWS) && !defined(NL_NO_ASM) && defined(NL_USE_FASTFLOOR)

/* This floor works only for floor with noise, because floor/ceil are only made on decimal coordinates:
        sTile =1.25 ....  NB: because of difference of mapping (rare case), we may have sometimes values with
        precision < 1/4 (eg 1.125). Just use f*256 to compute the floor.

  NB: using a fastFloor() (fistp changing the controlfp() is not very a good idea here, because
  computeNoise() are not "packed", so change on controlFp() would bee too frequent...
  And also because we need either floor() or ceil() here.
*/
inline  sint noiseFloor(float f)
{
        // build a fixed 24:8.
        sint    a;
        f*=256;

        // fast ftol. work if no decimal.
        _asm
        {
                fld f
                fistp a
        }

        // floor.
        a>>=8;

        return a;
}


inline  sint noiseCeil(float f)
{
        // build a fixed 24:8.
        sint    a;
        f*=256;

        // fast ftol. work if no decimal.
        _asm
        {
                fld f
                fistp a
        }

        // ceil.
        a+=255;
        a>>=8;

        return a;
}


inline  float noiseFloorF(float f)
{
        return (float)noiseFloor(f);
}
inline  float noiseCeilF(float f)
{
        return (float)noiseCeil(f);
}


#else


inline  float noiseFloorF(float f)
{
        return (float)floor(f);
}
inline  float noiseCeilF(float f)
{
        return (float)ceil(f);
}

inline  sint noiseFloor(float f)
{
        return (sint)floor(f);
}
inline  sint noiseCeil(float f)
{
        return (sint)ceil(f);
}

#endif



// ***************************************************************************
float           CPatch::computeDisplaceRawInteger(sint ts, sint tt, sint ms, sint mt) const
{
        // Choose the noiseMap.
        // ===============================
        clamp(ts, 0, OrderS-1);
        clamp(tt, 0, OrderT-1);

        uint    tileId= tt*OrderS + ts;
        // Get the tile for pass0. This is the principal tile, and this one tells what noise to take.
        sint    tileNumber= Tiles[tileId].Tile[0];
        // Get the subNoise from tileElement.
        uint    tileSubNoise= Tiles[tileId].getTileSubNoise();

        // retrieve the wanted noiseMap.
        CTileNoiseMap   *noiseMap;
        noiseMap = getZone()->getLandscape()->TileBank.getTileNoiseMap (tileNumber, tileSubNoise);

        if (noiseMap == NULL)
                return 0.0f;

        // Sample the noiseMap with (s,t).
        // ===============================

        // sample from map.
        sint8   pix= noiseMap->Pixels[mt*NL3D_TILE_NOISE_MAP_SIZE + ms];

        // normalize.
        return  (float)pix * (NL3D_NOISE_MAX / 127.f);
}


// ***************************************************************************
void            CPatch::computeDisplaceRawCoordinates(float sTile, float tTile, float s, float t,
        sint &ts, sint &tt, sint &ms, sint &mt) const
{
        // Choose the noiseMap.
        // ===============================
        // Compute coordinate in the patch.
        ts= noiseFloor(sTile);
        tt= noiseFloor(tTile);


        // Sample the noiseMap with (s,t).
        // ===============================

        // scale the map.
        float   u= s * NL3D_TILE_NOISE_MAP_TILE_FACTOR;
        float   v= t * NL3D_TILE_NOISE_MAP_TILE_FACTOR;

        // Speed rotation.
        CUV             uv;
        switch(NoiseRotation & 3)
        {
                case 0:
                        uv.U= u;
                        uv.V= v;
                        break;
                case 1:
                        uv.U= NL3D_TILE_NOISE_MAP_SIZE-v;
                        uv.V= u;
                        break;
                case 2:
                        uv.U= NL3D_TILE_NOISE_MAP_SIZE-u;
                        uv.V= NL3D_TILE_NOISE_MAP_SIZE-v;
                        break;
                case 3:
                        uv.U= v;
                        uv.V= NL3D_TILE_NOISE_MAP_SIZE-u;
                        break;
        }

        // direct map (no bilinear, no round, the case where s,t < 1/4 of a tile is very rare).
        ms= noiseFloor(uv.U);
        mt= noiseFloor(uv.V);

        // Manage Tiling (add NL3D_TILE_NOISE_MAP_SIZE*1 should be sufficient, but take margin).
        ms= (ms + (NL3D_TILE_NOISE_MAP_SIZE*256)) & (NL3D_TILE_NOISE_MAP_SIZE-1);
        mt= (mt + (NL3D_TILE_NOISE_MAP_SIZE*256)) & (NL3D_TILE_NOISE_MAP_SIZE-1);
}



// ***************************************************************************
float           CPatch::computeDisplaceRaw(float sTile, float tTile, float s, float t) const
{
        sint    ts,tt,ms,mt;
        computeDisplaceRawCoordinates(sTile, tTile, s, t, ts, tt, ms, mt);
        return computeDisplaceRawInteger(ts, tt, ms, mt);

}

// ***************************************************************************
static inline   void    computeDisplaceBilinear(float sTile, float tTile,
        float &sInc, float &tInc, float &sa, float &ta, float &sa1, float &ta1)
{
        float   sDecimal= sTile-noiseFloor(sTile);
        float   tDecimal= tTile-noiseFloor(tTile);
        float   sDist, tDist;

        // Do a bilinear centered on 0.5, 0.5.

        // Compute increment, according to position against center.
        if(sDecimal>=0.5)
                sInc= 1;
        else
                sInc= -1;
        if(tDecimal>=0.5)
                tInc= 1;
        else
                tInc= -1;

        // Compute weight factor.
        sDist= (float)fabs(0.5 - sDecimal);     // s distance from center.
        tDist= (float)fabs(0.5 - tDecimal);     // t distance from center.
        sa= 1-sDist;
        ta= 1-tDist;
        sa1= 1-sa;
        ta1= 1-ta;
}


// ***************************************************************************
float           CPatch::computeDisplaceInteriorSmooth(float s, float t) const
{
        float sTile= s;
        float tTile= t;
        float   ret;

        // compute bi-linear weight factors.
        float   sInc, tInc, sa, ta, sa1, ta1;
        computeDisplaceBilinear(sTile, tTile, sInc, tInc, sa, ta, sa1, ta1);


        // NB: to have smooth transition, must keep the same (s,t), so we do a transition with the noise tile of
        // our neigbhor, but under us.

        // speed up, using just one computeDisplaceRawCoordinates(), and multiple computeDisplaceRawInteger().
        sint    ts,tt,ms,mt;
        computeDisplaceRawCoordinates(sTile, tTile, s, t, ts, tt, ms, mt);

        sint    sIncInt= (sint) sInc;
        sint    tIncInt= (sint) tInc;
        ret = computeDisplaceRawInteger(ts, tt, ms,mt) * sa * ta;
        ret+= computeDisplaceRawInteger(ts+sIncInt, tt, ms,mt) * sa1 * ta;
        ret+= computeDisplaceRawInteger(ts, tt+tIncInt, ms,mt) * sa * ta1;
        ret+= computeDisplaceRawInteger(ts+sIncInt, tt+tIncInt, ms,mt) * sa1 * ta1;

        return ret;
}


// ***************************************************************************
float           CPatch::computeDisplaceEdgeSmooth(float s, float t, sint8 smoothBorderX, sint8 smoothBorderY) const
{
        float sTile= s;
        float tTile= t;
        CBindInfo       bindInfo;
        uint            edge=0;

        // only one must be not null
        nlassert( (smoothBorderX==0) != (smoothBorderY==0) );


        // Get the edge against we must share displace.
        if(smoothBorderX==-1)   edge=0;
        else if(smoothBorderY==1)       edge=1;
        else if(smoothBorderX==1)       edge=2;
        else if(smoothBorderY==-1)      edge=3;
        else nlstop;

        // Build the bindInfo against this edge.
        getBindNeighbor(edge, bindInfo);

        // Fast reject: if no neighbor, just do a simple computeDisplaceInteriorSmooth.
        if(!bindInfo.Zone)
                return computeDisplaceInteriorSmooth(s, t);
        // else, look for result in neighborhood.
        else
        {
                float   ret;


                // compute bi-linear weight factors.
                float   sInc, tInc, sa, ta, sa1, ta1;
                computeDisplaceBilinear(sTile, tTile, sInc, tInc, sa, ta, sa1, ta1);
                // Manage limit case: if bilinear has not chosen the good direction (because of floor and orientation).
                // eg on Right edge: This case arise if sDecimal==0, so if sa==sa1==0.5f. result is that
                // smoothBorderX is != than sInc on right border. same reasoning with downBorder (smoothBorderY=1).

                // NO NEED TO DO HERE, because sInc or tInc is not used if it is bad (smoothBorder? used instead).
                // and no need to correct sa, sa1, because in this case they are both equal to 0.5.


                // compute Neighboring info.
                CPatchUVLocator         uvLocator;
                uvLocator.build(this, edge, bindInfo);

                /* NB: there is floor problems with neighbors:
                        - difference of orientation => uv.v=1. This point to the 1th tile. But this is not the same, if
                                v goes to up, or goes to down.
                        - if multiple bind, problem at limit (eg a bind 1/2 on edge 0 with OrdertT=8, when uv.v= 4).
                                because, selection of the patch is dependent of orientation too.
                        To avoid them, just take center of (sTile, tTile) to remove ambiguity.
                        This works because computeDisplaceRaw() use sTile, tTile to get the noiseMap, so the decimal part is not
                        used.

                        Notice that we do this AFTER computeDisplaceBilinear() of course.
                */
                sTile= noiseFloor(sTile) + 0.5f;
                tTile= noiseFloor(tTile) + 0.5f;
                // If we were exactly on the superior edge, prec compute is false... so correct this here.
                if(sTile>OrderS) sTile--;
                if(tTile>OrderT) tTile--;


                // Bilinear across an edge (enjoy!!).
                CVector2f       stTileIn, stIn;
                CVector2f       stTileOut, stOut;
                CPatch          *patchOut;
                uint            patchId;


                // if vertical edge.
                if(smoothBorderX!=0)
                {
                        // compute contribution of our patch.
                        ret = computeDisplaceRaw(sTile,tTile, s,t) * sa * ta;
                        ret+= computeDisplaceRaw(sTile,tTile+tInc, s,t) * sa * ta1;

                        // compute contribution of next(s) patchs.

                        // contribution of next at tTile.
                        // Keep the same coordinate.
                        stIn.set(s, t);
                        // But look for the neighbor noise tile.
                        stTileIn.set(sTile+smoothBorderX, tTile);
                        // change basis: find the s,t on the neighbor patch.
                        patchId= uvLocator.selectPatch(stTileIn);
                        uvLocator.locateUV(stTileIn, patchId, patchOut, stTileOut);
                        uvLocator.locateUV(stIn, patchId, patchOut, stOut);
                        // Compute displace, and bi-linear on the neighbor patch.
                        ret+= patchOut->computeDisplaceRaw(stTileOut.x, stTileOut.y, stOut.x, stOut.y) * sa1 * ta;

                        // contribution of next at tTile+tInc (same reasoning).
                        stIn.set(s, t);
                        stTileIn.set(sTile+smoothBorderX, tTile+tInc);
                        patchId= uvLocator.selectPatch(stTileIn);
                        uvLocator.locateUV(stTileIn, patchId, patchOut, stTileOut);
                        uvLocator.locateUV(stIn, patchId, patchOut, stOut);
                        ret+= patchOut->computeDisplaceRaw(stTileOut.x, stTileOut.y, stOut.x, stOut.y) * sa1 * ta1;

                }
                // else if horizontal edge.
                else
                {
                        // same reasoning as above.

                        // compute contribution of our patch.
                        ret = computeDisplaceRaw(sTile, tTile, s,t) * sa * ta;
                        ret+= computeDisplaceRaw(sTile+sInc,tTile, s,t) * sa1 * ta;

                        // compute contribution of next(s) patchs.
                        // contribution of next at tTile.
                        stIn.set(s, t);
                        stTileIn.set(sTile, tTile+smoothBorderY);
                        patchId= uvLocator.selectPatch(stTileIn);
                        uvLocator.locateUV(stTileIn, patchId, patchOut, stTileOut);
                        uvLocator.locateUV(stIn, patchId, patchOut, stOut);
                        ret+= patchOut->computeDisplaceRaw(stTileOut.x, stTileOut.y, stOut.x, stOut.y) * sa * ta1;

                        // contribution of next at tTile+tInc (same reasoning).
                        stIn.set(s, t);
                        stTileIn.set(sTile+sInc, tTile+smoothBorderY);
                        patchId= uvLocator.selectPatch(stTileIn);
                        uvLocator.locateUV(stTileIn, patchId, patchOut, stTileOut);
                        uvLocator.locateUV(stIn, patchId, patchOut, stOut);
                        ret+= patchOut->computeDisplaceRaw(stTileOut.x, stTileOut.y, stOut.x, stOut.y) * sa1 * ta1;
                }

                return ret;
        }

}


// ***************************************************************************
float           CPatch::computeDisplaceRawOnNeighbor(float sTile, float tTile, float s, float t) const
{
        sint    edge= -1;

        // look on what neighbor patch we must find the value (if any).
        if(sTile<0)     edge=0;
        else if(tTile>OrderT)   edge=1;
        else if(sTile>OrderS)   edge=2;
        else if(tTile<0)                edge=3;

        // If the location is In the patch, just return normal value.
        if(edge==-1)
                return computeDisplaceRaw(sTile, tTile, s, t);
        // else must find on neighbor.
        else
        {
                CBindInfo       bindInfo;
                getBindNeighbor(edge, bindInfo);

                // Fast reject: if no neighbor on the edge, just do a simple computeDisplaceRaw()
                if(!bindInfo.Zone)
                {
                        return computeDisplaceRaw(sTile, tTile, s, t);
                }
                // else must find on neighbor.
                else
                {
                        CPatchUVLocator         uvLocator;
                        uvLocator.build(this, edge, bindInfo);

                        CVector2f       stTileIn, stIn;
                        CVector2f       stTileOut, stOut;
                        CPatch          *patchOut;
                        uint            patchId;

                        // look on neighbor. same reasoning as in computeDisplaceEdgeSmooth();
                        stIn.set(s, t);
                        stTileIn.set(sTile, tTile);
                        patchId= uvLocator.selectPatch(stTileIn);
                        uvLocator.locateUV(stTileIn, patchId, patchOut, stTileOut);
                        uvLocator.locateUV(stIn, patchId, patchOut, stOut);
                        return patchOut->computeDisplaceRaw(stTileOut.x, stTileOut.y, stOut.x, stOut.y);
                }

        }
}


// ***************************************************************************
float           CPatch::computeDisplaceCornerSmooth(float s, float t, sint8 smoothBorderX, sint8 smoothBorderY) const
{
        // compute the value across the corner (enjoy!!)
        // NB: Only corners with Edges==4 and corners on a bind are correclty supported.
        // ignore problems with corner which nbEdges!=4, because Blend of normals blend to 0 on corner (see computenoise()).

        float sTile= s;
        float tTile= t;
        CBindInfo       bindInfoX;
        CBindInfo       bindInfoY;
        uint            edgeX=0;
        uint            edgeY=0;

        // both must be not null
        nlassert( (smoothBorderX!=0) && (smoothBorderY!=0) );


        // Get the edge against we must share displace.
        if(smoothBorderX==-1)   edgeX=0;
        else if(smoothBorderX==1)       edgeX=2;
        else nlstop;
        if(smoothBorderY==1)    edgeY=1;
        else if(smoothBorderY==-1)      edgeY=3;
        else nlstop;

        // Build the bindInfo against those 2 edge.
        getBindNeighbor(edgeX, bindInfoX);
        getBindNeighbor(edgeY, bindInfoY);

        // Fast reject: if no neighbor on one of the edge, just do a simple computeDisplaceInteriorSmooth.
        if(!bindInfoX.Zone || !bindInfoY.Zone)
                return computeDisplaceInteriorSmooth(s, t);
        else
        {
                float   ret;


                // compute bi-linear weight factors.
                float   sInc, tInc, sa, ta, sa1, ta1;
                computeDisplaceBilinear(sTile, tTile, sInc, tInc, sa, ta, sa1, ta1);
                // Manage limit case: if bilinear has not chosen the good direction (because of floor and orientation).
                // eg on Right edge: This case arise if sDecimal==0, so if sa==sa1==0.5f. result is that
                // smoothBorderX is != than sInc on right border. same reasoning with downBorder (smoothBorderY=1).

                // NO NEED TO DO HERE, because sInc or tInc are not used at all.



                // compute Neighboring info.
                CPatchUVLocator         uvLocatorX;
                CPatchUVLocator         uvLocatorY;
                uvLocatorX.build(this, edgeX, bindInfoX);
                uvLocatorY.build(this, edgeY, bindInfoY);


                /* NB: see floor problems note in computeDisplaceEdgeSmooth();
                */
                sTile= noiseFloor(sTile) + 0.5f;
                tTile= noiseFloor(tTile) + 0.5f;
                // If we were exactly on the superior edge, prec compute is false... so correct this here.
                if(sTile>OrderS) sTile--;
                if(tTile>OrderT) tTile--;


                // Bilinear across a corner.
                CVector2f       stTileIn, stIn;
                CVector2f       stTileOut, stOut;
                CPatch          *patchOut;
                uint            patchId;


                // compute contribution of our patch.
                ret = computeDisplaceRaw(sTile,tTile, s,t) * sa * ta;

                // compute contribution of the patch on the left/right side. same reasoning as in computeDisplaceEdgeSmooth();
                stIn.set(s, t);
                stTileIn.set(sTile+smoothBorderX, tTile);
                patchId= uvLocatorX.selectPatch(stTileIn);
                uvLocatorX.locateUV(stTileIn, patchId, patchOut, stTileOut);
                uvLocatorX.locateUV(stIn, patchId, patchOut, stOut);
                ret+= patchOut->computeDisplaceRaw(stTileOut.x, stTileOut.y, stOut.x, stOut.y) * sa1 * ta;


                // compute contribution of the patch on the up/down side. same reasoning as in computeDisplaceEdgeSmooth();
                stIn.set(s, t);
                stTileIn.set(sTile, tTile+smoothBorderY);
                patchId= uvLocatorY.selectPatch(stTileIn);
                uvLocatorY.locateUV(stTileIn, patchId, patchOut, stTileOut);
                uvLocatorY.locateUV(stIn, patchId, patchOut, stOut);
                ret+= patchOut->computeDisplaceRaw(stTileOut.x, stTileOut.y, stOut.x, stOut.y) * sa * ta1;


                /* compute contribution of the patch adjacent to me.
                        There is multiple case to consider here. Take example with corner=0 (ie smBdX=smBdY=-1):
                                - if we are a normal corner with 4 edges, take the result from the left patch of our top patch.
                                - if the corner is on a bind Edge, the top patch may be the bigger patch, so don't take the result
                                        from his neighbor (of course).
                                - if we are a normal corner with N!=4 edges, just do same thing than if N==4. this is false but don't bother.

                        To solve smoothly cases 1 and 2, use computeDisplaceRawOnNeighbor().
                        This method, if nessecary, look on his neighbor to compute the value.
                */
                stIn.set(s, t);
                stTileIn.set(sTile+smoothBorderX, tTile+smoothBorderY);
                // look on our "top" patch (this is arbitrary).
                patchId= uvLocatorY.selectPatch(stTileIn);
                uvLocatorY.locateUV(stTileIn, patchId, patchOut, stTileOut);
                uvLocatorY.locateUV(stIn, patchId, patchOut, stOut);
                ret+= patchOut->computeDisplaceRawOnNeighbor(stTileOut.x, stTileOut.y, stOut.x, stOut.y) * sa1 * ta1;


                return ret;
        }

}

// ***************************************************************************
CVector         CPatch::computeNormalEdgeSmooth(float s, float t, sint8 smoothBorderX, sint8 smoothBorderY) const
{
        CBindInfo       bindInfo;
        uint            edge=0;
        CBezierPatch    *bpatch;
        bpatch= unpackIntoCache();

        // only one must be not null
        nlassert( (smoothBorderX==0) != (smoothBorderY==0) );


        // Get the edge against we must share displace.
        if(smoothBorderX==-1)   edge=0;
        else if(smoothBorderY==1)       edge=1;
        else if(smoothBorderX==1)       edge=2;
        else if(smoothBorderY==-1)      edge=3;
        else nlstop;

        // If the edge is smoothed, blend with neighbor.
        if(getSmoothFlag(edge))
        {
                // Build the bindInfo against this edge.
                getBindNeighbor(edge, bindInfo);

                // Fast reject: if no neighbor, just do a simple computeDisplaceInteriorSmooth.
                if(!bindInfo.Zone)
                        return bpatch->evalNormal(s/getOrderS(), t/getOrderT());
                else
                {
                        CVector         r0, r1;

                        // Compute our contribution.
                        r0= bpatch->evalNormal(s/getOrderS(), t/getOrderT());

                        // Compute the coordinate on the border of the edge, and the coef of the blend.
                        float           se=s;
                        float           te=t;
                        float           coef=0.0;
                        if(smoothBorderX==-1)           se= noiseFloorF(se), coef=s-se;
                        else if(smoothBorderX==1)       se= noiseCeilF(se), coef=se-s;
                        else if(smoothBorderY==-1)      te= noiseFloorF(te), coef=t-te;
                        else if(smoothBorderY==1)       te= noiseCeilF(te), coef=te-t;
                        coef= 0.5f + coef*0.5f;

                        // Compute contribution of the normal on the neighbor, on the border of the edge.
                        CPatchUVLocator         uvLocator;
                        CVector2f       stIn, stOut;
                        CPatch          *patchOut;
                        uint            patchId;

                        uvLocator.build(this, edge, bindInfo);
                        stIn.set(se, te);
                        patchId= uvLocator.selectPatch(stIn);
                        uvLocator.locateUV(stIn, patchId, patchOut, stOut);

                        bpatch= patchOut->unpackIntoCache();
                        r1= bpatch->evalNormal(stOut.x/patchOut->getOrderS(), stOut.y/patchOut->getOrderT());

                        // NB: don't bother problems with bind 1/X and the choice of the patch, because bind are C1, so normal is C0.

                        // Blend 2 result. For speed optim, don't normalize.
                        return r0*coef + r1*(1-coef);
                }
        }
        // else blend with vector Null.
        else
        {
                // compute coef.
                float           se=s;
                float           te=t;
                float           coef=0.0;
                if(smoothBorderX==-1)           se= noiseFloorF(se), coef=s-se;
                else if(smoothBorderX==1)       se= noiseCeilF(se), coef=se-s;
                else if(smoothBorderY==-1)      te= noiseFloorF(te), coef=t-te;
                else if(smoothBorderY==1)       te= noiseCeilF(te), coef=te-t;

                // Compute our contribution.
                CVector         r0;
                r0= bpatch->evalNormal(s/getOrderS(), t/getOrderT());

                // Blend with 0.
                return r0*coef;
        }
}


// ***************************************************************************
CVector         CPatch::computeNormalOnNeighbor(float s, float t, uint edgeExclude) const
{
        sint    edge= -1;

        // look on what neighbor patch we must find the value (if any).
        if(s<1 && edgeExclude!=0)                               edge=0;
        else if(t>OrderT-1 && edgeExclude!=1)   edge=1;
        else if(s>OrderS-1 && edgeExclude!=2)   edge=2;
        else if(t<1 && edgeExclude!=3)                  edge=3;


        // If the location is In the patch, just return normal value. (case of a bind 1/X).
        if(edge==-1)
        {
                CBezierPatch    *bpatch= unpackIntoCache();
                return bpatch->evalNormal(s/getOrderS(), t/getOrderT());
        }
        // else must find on neighbor.
        else
        {
                CBindInfo       bindInfo;
                getBindNeighbor(edge, bindInfo);

                // Fast reject: if no neighbor on the edge, just do a simple computeDisplaceRaw()
                if(!bindInfo.Zone)
                {
                        CBezierPatch    *bpatch= unpackIntoCache();
                        return bpatch->evalNormal(s/getOrderS(), t/getOrderT());
                }
                // else must find on neighbor.
                else
                {
                        CPatchUVLocator         uvLocator;
                        uvLocator.build(this, edge, bindInfo);

                        CVector2f       stIn;
                        CVector2f       stOut;
                        CPatch          *patchOut;
                        uint            patchId;

                        // look on neighbor. same reasoning as in computeDisplaceEdgeSmooth();
                        stIn.set(s, t);
                        patchId= uvLocator.selectPatch(stIn);
                        uvLocator.locateUV(stIn, patchId, patchOut, stOut);
                        CBezierPatch    *bpatch= patchOut->unpackIntoCache();
                        return bpatch->evalNormal(stOut.x/patchOut->getOrderS(), stOut.y/patchOut->getOrderT());
                }

        }
}


// ***************************************************************************
CVector         CPatch::computeNormalCornerSmooth(float s, float t, sint8 smoothBorderX, sint8 smoothBorderY) const
{
        CBindInfo       bindInfoX;
        CBindInfo       bindInfoY;
        uint            edgeX=0;
        uint            edgeY=0;
        uint            corner;
        CBezierPatch    *bpatch;
        bpatch= unpackIntoCache();

        // both must be not null
        nlassert( (smoothBorderX!=0) && (smoothBorderY!=0) );


        // Get the edge against we must share displace.
        if(smoothBorderX==-1)   edgeX=0;
        else if(smoothBorderX==1)       edgeX=2;
        else nlstop;
        if(smoothBorderY==1)    edgeY=1;
        else if(smoothBorderY==-1)      edgeY=3;
        else nlstop;

        // Get the corner against we must share displace.
        if(smoothBorderX==-1)
        {
                if(smoothBorderY==-1)   corner=0;
                else                                    corner=1;
        }
        else
        {
                if(smoothBorderY==-1)   corner=3;
                else                                    corner=2;
        }

        // If this corner is smoothed, blend with 4 neighbors patchs.
        if(getCornerSmoothFlag(corner))
        {
                // Build the bindInfo against the 2 edge.
                getBindNeighbor(edgeX, bindInfoX);
                getBindNeighbor(edgeY, bindInfoY);

                // Fast reject: if no neighbor, just do a simple computeDisplaceInteriorSmooth.
                if(!bindInfoX.Zone || !bindInfoY.Zone)
                        return bpatch->evalNormal(s/getOrderS(), t/getOrderT());
                else
                {
                        CVector         ret;


                        // Compute the coordinate on the border of the edge, and the coef of the blend.
                        float           se=s;
                        float           te=t;
                        float           coefX;
                        float           coefY;
                        if(smoothBorderX==-1)   se= noiseFloorF(se), coefX=s-se;
                        else                                    se= noiseCeilF(se), coefX=se-s;
                        if(smoothBorderY==-1)   te= noiseFloorF(te), coefY=t-te;
                        else                                    te= noiseCeilF(te), coefY=te-t;
                        coefX= 0.5f + coefX*0.5f;
                        coefY= 0.5f + coefY*0.5f;


                        // Compute our contribution.
                        ret= bpatch->evalNormal(s/getOrderS(), t/getOrderT()) *coefX*coefY;


                        // compute Neighboring info.
                        CPatchUVLocator         uvLocatorX;
                        CPatchUVLocator         uvLocatorY;
                        CVector2f       stIn, stOut;
                        CPatch          *patchOut;
                        uint            patchId;

                        uvLocatorX.build(this, edgeX, bindInfoX);
                        uvLocatorY.build(this, edgeY, bindInfoY);

                        // Patch on our X side.
                        stIn.set(se, te);
                        patchId= uvLocatorX.selectPatch(stIn);
                        uvLocatorX.locateUV(stIn, patchId, patchOut, stOut);
                        bpatch= patchOut->unpackIntoCache();
                        ret+= bpatch->evalNormal(stOut.x/patchOut->getOrderS(), stOut.y/patchOut->getOrderT()) *(1-coefX)*coefY;

                        // Patch on our Y side.
                        stIn.set(se, te);
                        patchId= uvLocatorY.selectPatch(stIn);
                        uvLocatorY.locateUV(stIn, patchId, patchOut, stOut);
                        bpatch= patchOut->unpackIntoCache();
                        ret+= bpatch->evalNormal(stOut.x/patchOut->getOrderS(), stOut.y/patchOut->getOrderT()) *coefX*(1-coefY);

                        /* compute contribution of the patch adjacent to me.
                                Same reasoning as in computeDisplaceCornerSmooth().
                        */
                        stIn.set(se, te);
                        patchId= uvLocatorY.selectPatch(stIn);
                        uvLocatorY.locateUV(stIn, patchId, patchOut, stOut);
                        // Because we compute the normal exactly on the edge, we must inform this method not to take us as neighbor.
                        // ugly but simpler.
                        ret+= patchOut->computeNormalOnNeighbor(stOut.x, stOut.y, bindInfoY.Edge[patchId]) *(1-coefX)*(1-coefY);

                        return ret;
                }
        }
        // else must blend with 0.
        else
        {
                // compute coef.
                float           se=s;
                float           te=t;
                float           coefX;
                float           coefY;
                if(smoothBorderX==-1)   se= noiseFloorF(se), coefX=s-se;
                else                                    se= noiseCeilF(se), coefX=se-s;
                if(smoothBorderY==-1)   te= noiseFloorF(te), coefY=t-te;
                else                                    te= noiseCeilF(te), coefY=te-t;


                // To have smooth continuities with smooth on edge (if any), we must do this.
                CVector         rx, ry;
                // Compute a smooth with my X neighbor.
                rx= computeNormalEdgeSmooth(s, t, smoothBorderX, 0);
                // Compute a smooth with my Y neighbor.
                ry= computeNormalEdgeSmooth(s, t, 0, smoothBorderY);

                // Blend the 2 result.
                if(coefY + coefX>0)
                {
                        // This the weight used to blend to 0.
                        float   maxCoef= max(coefY, coefX);
                        // This the weight used to blend beetween rx and ry.
                        float   ooSum= 1.0f / (coefY + coefX);
                        float   blendCoefX= coefX * ooSum;
                        float   blendCoefY= coefY * ooSum;

                        return maxCoef* (rx*blendCoefY + ry*blendCoefX);
                }
                else
                {
                        return CVector::Null;
                }
        }
}



// ***************************************************************************
void            CPatch::computeNoise(float s, float t, CVector &displace) const
{
        float   so= s*OrderS;
        float   to= t*OrderT;


        // Pre-Compute Border Smothing.
        //=========================
        // If we are on a border, flag it.
        sint8   smoothNormalBorderX= 0;
        sint8   smoothNormalBorderY= 0;
        // NB: because OrderS and OrderT >=2, smoothNormalBorderX=-1 and smoothNormalBorderX=1 are exclusive (as smoothNormalBorderY).
        if(so < 1) smoothNormalBorderX= -1;
        else if(so > OrderS-1) smoothNormalBorderX= 1;
        if(to < 1) smoothNormalBorderY= -1;
        else if(to > OrderT-1) smoothNormalBorderY= 1;

        bool    smoothNormalEdge= (smoothNormalBorderX!=0) != (smoothNormalBorderY!=0);
        bool    smoothNormalCorner= (smoothNormalBorderX!=0) && (smoothNormalBorderY!=0);


        // Do same thing, but to know if we must compute a displace on an interior, on an edge or on a corner.
        sint8   smoothDisplaceBorderX= 0;
        sint8   smoothDisplaceBorderY= 0;
        // NB: because OrderS and OrderT >=2, smoothBorderX=-1 and smoothBorderX=1 are exclusive (as smoothBorderY).
        if(so < 0.5) smoothDisplaceBorderX= -1;
        else if(so > OrderS-0.5) smoothDisplaceBorderX= 1;
        if(to < 0.5) smoothDisplaceBorderY= -1;
        else if(to > OrderT-0.5) smoothDisplaceBorderY= 1;

        bool    smoothDisplaceEdge= (smoothDisplaceBorderX!=0) != (smoothDisplaceBorderY!=0);
        bool    smoothDisplaceCorner= (smoothDisplaceBorderX!=0) && (smoothDisplaceBorderY!=0);


        // Compute Displace value.
        //=========================
        float   displaceValue;

        if(smoothDisplaceCorner)
                displaceValue= computeDisplaceCornerSmooth(so, to, smoothDisplaceBorderX, smoothDisplaceBorderY);
        else if(smoothDisplaceEdge)
                displaceValue= computeDisplaceEdgeSmooth(so, to, smoothDisplaceBorderX, smoothDisplaceBorderY);
        else
                displaceValue= computeDisplaceInteriorSmooth(so, to);



        // Compute Displace normal.
        //=========================

        // Evaluate the normal.
        CVector         displaceNormal;


        // smooth on edges and on corners.
        if(smoothNormalCorner)
                displaceNormal= computeNormalCornerSmooth(so, to, smoothNormalBorderX, smoothNormalBorderY);
        else if(smoothNormalEdge)
                displaceNormal= computeNormalEdgeSmooth(so, to, smoothNormalBorderX, smoothNormalBorderY);
        else
        {
                // unpack...
                CBezierPatch    *bpatch= unpackIntoCache();
                // eval.
                displaceNormal= bpatch->evalNormal(s, t);
        }



        // Final result.
        //=========================
        displace= displaceNormal * displaceValue;
}



// ***************************************************************************
void                    CPatch::setCornerSmoothFlag(uint corner, bool smooth)
{
        nlassert(corner<=3);
        uint    mask= 1<<corner;
        if(smooth)
                _CornerSmoothFlag|= mask;
        else
                _CornerSmoothFlag&= ~mask;
}

// ***************************************************************************
bool                    CPatch::getCornerSmoothFlag(uint corner) const
{
        nlassert(corner<=3);
        uint    mask= 1<<corner;
        return  (_CornerSmoothFlag& mask)!=0;
}


} // NL3D