patch.h

Go to the documentation of this file.

/* Copyright, 2000 Nevrax Ltd.
 *
 * This file is part of NEVRAX NEL.
 * NEVRAX NEL is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2, or (at your option)
 * any later version.

 * NEVRAX NEL 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
 * General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with NEVRAX NEL; see the file COPYING. If not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
 * MA 02111-1307, USA.
 */

#ifndef NL_PATCH_H
#define NL_PATCH_H

#include "nel/misc/types_nl.h"
#include "nel/misc/vector.h"
#include "nel/misc/vector_2f.h"
#include "nel/misc/rgba.h"
#include "nel/3d/tessellation.h"
#include "nel/misc/aabbox.h"
#include "nel/misc/bsphere.h"
#include "nel/misc/triangle.h"
#include "nel/misc/geom_ext.h"
#include "nel/misc/object_vector.h"
#include "nel/3d/tile_element.h"
#include "nel/3d/tile_color.h"
#include "nel/3d/tess_block.h"
#include "nel/3d/tile_light_influence.h"
#include "nel/3d/point_light_influence.h"


namespace NL3D {

#define NL_MAX_TILES_BY_PATCH_EDGE_SHIFT 4                                      // max 16x16 tiles by patch (shift version)
#define NL_MAX_TILES_BY_PATCH_EDGE (1<<NL_MAX_TILES_BY_PATCH_EDGE_SHIFT)        // max 16x16 tiles by patch
#define NL_PATCH_FAR0_ROTATED 0x1                                               // Flags far0 rotated
#define NL_PATCH_FAR1_ROTATED 0x2                                               // Flags far1 rotated
#define NL_PATCH_SMOOTH_FLAG_SHIFT 0x2                                          // Smooth flags shift
#define NL_PATCH_SMOOTH_FLAG_MASK 0x3c                                          // Smooth flags mask

#define NL_LUMEL_BY_TILE_SHIFT 2                                                // 4 lumels by tile
#define NL_LUMEL_BY_TILE (1<<NL_LUMEL_BY_TILE_SHIFT)                            // 4 lumels by tile
#define NL_BLOCK_LUMEL_COMPRESSED_SIZE 8                                        // Compressed block size 8 bytes


#define NL_PATCH_BLOCK_MAX_QUAD 4                                               // Max quad per CPatchQuadBlock.
#define NL_PATCH_BLOCK_MAX_VERTEX (NL_PATCH_BLOCK_MAX_QUAD+1)                   // Max vertex per CPatchQuadBlock.


using NLMISC::CVector;
using NLMISC::CPlane;
using NLMISC::CAABBox;
using NLMISC::CBSphere;
using NLMISC::CRGBA;


class   CLandscape;
class   CZone;
class   CBezierPatch;
class   ITexture;
class   CVegetableClipBlock;
class   CVegetableManager;
class   CVegetableInstanceGroup;
class   CLandscapeVegetableBlock;
class   CLandscapeVegetableBlockCreateContext;
class   CPatchDLMContext;
class   CPatchDLMPointLight;


// ***************************************************************************
#define NL3D_NOISE_MAX  1


// ***************************************************************************
/*
    NL3D_PATCH_VEGETABLE_NUM_TESSBLOCK_PER_CLIPBLOCK == 2 means that
    clipBlocks enclose 2*2 tessBlocks (hence 4*4 tiles).
*/
#define NL3D_PATCH_VEGETABLE_NUM_TESSBLOCK_PER_CLIPBLOCK_SHIFT  1
#define NL3D_PATCH_VEGETABLE_NUM_TESSBLOCK_PER_CLIPBLOCK        (1<<NL3D_PATCH_VEGETABLE_NUM_TESSBLOCK_PER_CLIPBLOCK_SHIFT)


// ***************************************************************************
class   CVector3s
{
public:
    sint16  x,y,z;

public:
    void    pack(const CVector &v, const CVector &bias, float scale)
    {
        float   xr,yr,zr;
        xr= (v.x - bias.x)/scale;
        yr= (v.y - bias.y)/scale;
        zr= (v.z - bias.z)/scale;
        NLMISC::clamp(xr, -32768, 32767);
        NLMISC::clamp(yr, -32768, 32767);
        NLMISC::clamp(zr, -32768, 32767);
        x= (sint16)xr;
        y= (sint16)yr;
        z= (sint16)zr;
    }
    void    unpack(CVector &v, const CVector &bias, float scale) const
    {
        v.x= x*scale + bias.x;
        v.y= y*scale + bias.y;
        v.z= z*scale + bias.z;
    }
    void    serial(NLMISC::IStream &f)
    {
        f.serial(x,y,z);
    }
};


// ***************************************************************************
struct  CPatchIdent
{
    sint32      ZoneId;     // From which zone this patch come from...
    uint16      PatchId;    // Id of this patch.

    // default ctor
    CPatchIdent() {}
    //
    CPatchIdent(sint32 zoneId, uint16 patchId) : ZoneId(zoneId), PatchId(patchId) {}
public:
    bool            operator<(const CPatchIdent &p) const
    {
        if(ZoneId!=p.ZoneId) return ZoneId<p.ZoneId;
        return PatchId<p.PatchId;
    }

    bool            operator==(const CPatchIdent &p) const
    {
        return ZoneId==p.ZoneId && PatchId==p.PatchId;
    }
    bool            operator!=(const CPatchIdent &p) const
    {
        return !(*this==p);
    }

};


// ***************************************************************************
struct  CTrianglePatch : public NLMISC::CTriangleUV
{
    CPatchIdent     PatchId;
};


// ***************************************************************************
class   CPatchBlockIdent
{
public:
    CPatchIdent     PatchId;
    uint8           OrderS,OrderT;
    uint8           S0,S1,T0,T1;

public:
    // @{
    bool            operator==(const CPatchBlockIdent &pb) const
    {
        return PatchId==pb.PatchId &&
            S0==pb.S0 && S1==pb.S1 &&
            T0==pb.T0 && T1==pb.T1;
    }
    bool            operator!=(const CPatchBlockIdent &pb) const
    {
        return !(*this==pb);
    }

    bool            operator<(const CPatchBlockIdent &pb) const
    {
        if(PatchId!=pb.PatchId)
            return PatchId<pb.PatchId;
        if(S0!=pb.S0)   return S0<pb.S0;
        if(S1!=pb.S1)   return S1<pb.S1;
        if(T0!=pb.T0)   return T0<pb.T0;
        return T1<pb.T1;
    }
    bool            operator<=(const CPatchBlockIdent &pb) const
    {
        return (*this<pb) || (*this==pb);
    }
    bool            operator>(const CPatchBlockIdent &pb) const
    {
        return !(*this<=pb);
    }
    bool            operator>=(const CPatchBlockIdent &pb) const
    {
        return !(*this<pb);
    }

    // @}
};


// ***************************************************************************
class   CPatchQuadBlock
{
public:
    CPatchBlockIdent    PatchBlockId;

    CVector             Vertices[NL_PATCH_BLOCK_MAX_VERTEX*NL_PATCH_BLOCK_MAX_VERTEX];

public:

    void        buildTileTriangles(uint8 quadId, CTrianglePatch  triangles[2]) const;
};



// ***************************************************************************
class CPatch
{
public:

    struct  CBindInfo
    {
        // The zone on this edge. NULL if not loaded (or if none).
        CZone           *Zone;

        // The number of patchs on this edge. 0,1, 2 or 4. if MultipleBindNum>1, NPatchs==1.
        sint            NPatchs;

        // Special case: on this edge, we are a small patch connected to a bigger: this is the X of 1/X (1,2 or 4).
        // 0 if this is not the case.
        uint8           MultipleBindNum;
        // valid only if MultipleBindNum>1. this tells our place in this MultipleBind: 0<=MultipleBindId<MultipleBindNum.
        uint8           MultipleBindId;


        CPatch          *Next[4];   // The neighbor patch i.
        sint            Edge[4];    // On which edge of Nexti we are binded.
    };

public:
    CVector3s       Vertices[4];
    CVector3s       Tangents[8];
    CVector3s       Interiors[4];

    // Lumel array compressed.
    std::vector<uint8>          CompressedLumels;

    // There is OrderS*OrderT tiles. CZone build it at build() time.
    std::vector<CTileElement>   Tiles;

    // There is OrderS*OrderT tiles color. CZone build it at build() time.
    std::vector<CTileColor>     TileColors;

    // There is OrderS/2+1 * OrderT/2+1 tiles light influence. CZone build it at build() time.
    std::vector<CTileLightInfluence>        TileLightInfluences;


    // @{
    uint8           NoiseRotation;

    void            setCornerSmoothFlag(uint corner, bool smooth);
    bool            getCornerSmoothFlag(uint corner) const;

private:
    uint8           _CornerSmoothFlag;

public:
    // @}


public:

    CPatch();
    ~CPatch();

    void            compile(CZone *z, uint patchId, uint8 orderS, uint8 orderT, CTessVertex *baseVertices[4], float errorSize=0);
    void            release();


    CLandscape      *getLandscape () const;
    CZone           *getZone() const {return Zone;}
    uint8           getOrderS() const {return OrderS;}
    uint8           getOrderT() const {return OrderT;}
    uint8           getOrderForEdge(sint8 edge) const;
    float           getErrorSize() const {return ErrorSize;}
    sint            getFar0() const {return Far0;}
    sint            getFar1() const {return Far1;}
    uint16          getPatchId () const {return PatchId;}
    void            getBindNeighbor(uint edge, CBindInfo &neighborEdge) const;

    CAABBox         buildBBox() const;

    CVector         computeVertex(float s, float t) const;


    CVector         computeContinousVertex(float s, float t) const;


    void            unbind();

    void            bind(CBindInfo  Edges[4], bool rebind);

    void            forceMergeAtTileLevel();

    void            averageTesselationVertices();

    void            refineAll();




    void            preRender(const NLMISC::CBSphere &patchSphere);
    // like preRender(), but update TextureFar only. (you should call preRender() in this case).
    void            updateTextureFarOnly(const NLMISC::CBSphere &patchSphere);
    // Global Setup setup it in CLandscape::render().
    void            renderFar0();
    void            renderFar1();
    // NB: renderTile() is now in CTileMaterial.
    // For All Far0/Far1/Tile etc..., compute Geomorph and Alpha in software (no VertexShader).
    void            computeSoftwareGeomorphAndAlpha();

    // update VB according to new clip state.
    void            updateClipPatchVB(bool renderClipped);

    // get the next patch to render in the same RenderPass for Far0.
    CPatch          *getNextFar0ToRdr() const {return _NextRdrFar0;}
    // get the next patch to render in the same RenderPass for Far1.
    CPatch          *getNextFar1ToRdr() const {return _NextRdrFar1;}



    // release Far render pass/reset Tile/Far render.
    void            resetRenderFar();



    // For CZone changePatchTexture only.
    void            deleteTileUvs();
    void            recreateTileUvs();
    // For CZone::refreshTesselationGeometry() only.
    void            refreshTesselationGeometry();


    // Serial just the un-compiled part.
    void            serial(NLMISC::IStream &f);

    // unpack the patch into a floating point one.
    void            unpack(CBezierPatch &p) const;


    void            unpackShadowMap (uint8 *pShadow);

    void            packShadowMap (const uint8 *pLumel);

    void            resetCompressedLumels ();

    void setupColorsFromTileFlags(const NLMISC::CRGBA colors[4]);

    void copyTileFlagsFromPatch(const CPatch *src);

    // Count the number of tri needed to draw the patch
    uint32 countNumTriFar0() const;
    uint32 countNumTriFar1() const;

private:

    // Methods used internaly to compute shadowmaps

    void            packLumelBlock (uint8 *dest, const uint8 *source, uint8 alpha0, uint8 alpha1);

    uint            evalLumelBlock (const uint8 *original, const uint8 *unCompressed, uint width, uint height);

    void            unpackLumelBlock (uint8 *dest, const uint8 *src);

public:


    void setSmoothFlag (uint edge, bool flag)
    {
        // Erase it
        Flags&=~(1<<(edge+NL_PATCH_SMOOTH_FLAG_SHIFT));

        // Set it
        Flags|=(((uint)flag)<<(edge+NL_PATCH_SMOOTH_FLAG_SHIFT));
    }

    bool getSmoothFlag (uint edge) const
    {
        // Test it
        return ((Flags&(1<<(edge+NL_PATCH_SMOOTH_FLAG_SHIFT)))!=0);
    }


    // @{
    void        addTrianglesInBBox(CPatchIdent paId, const CAABBox &bbox, std::vector<CTrianglePatch> &triangles, uint8 tileTessLevel) const;

    void        fillPatchQuadBlock(CPatchQuadBlock &quadBlock) const;

    void        addPatchBlocksInBBox(CPatchIdent paId, const CAABBox &bbox, std::vector<CPatchBlockIdent> &paBlockIds) const;


    CVector     getTesselatedPos(CUV uv) const;


    void        appendTessellationLeaves(std::vector<const CTessFace*>  &leaves) const;


    // @}


    // @{

    uint8       getLumel(const CUV &uv) const;

    void        appendTileLightInfluences(const CUV &uv,
        std::vector<CPointLightInfluence> &pointLightList) const;

    void        computeCurrentTLILightmapDiv2(NLMISC::CRGBA *array) const;

    // @}


    // @{

    CTileElement    *getTileElement(const CUV &uv);

    // @}

public:

    // Is the patch clipped? true if not yte compiled
    bool            isRenderClipped() const;


    // get the according vertex for a corner. use wisely
    const CTessVertex   *getCornerVertex(uint corner)
    {
        return BaseVertices[corner];
    }


public:

    // @{

    // delete all VB allocated in VertexBuffers, according to Far0 and Far1. Do not Test isRenderClipped() state.
    // With VB, allocate to he faces array.
    void        deleteVBAndFaceVector();

    // allocate all VB, according to Far0 and Far1. Do not Test isRenderClipped() state.
    // With VB, allocate to he faces array.
    void        allocateVBAndFaceVector();

    // fill all VB, according to Far0, Far1 and CTessFace VBInfos. Do not Test isRenderClipped() state.
    // Do not fill a VB if reallocationOccurs().
    void        fillVB();

    // if isRenderClipped()==false, fillVB().
    void        fillVBIfVisible();

    // delete Far1 VB allocated in VertexBuffers. do it only if Far1==true. Do not Test isRenderClipped() state.
    // With VB, allocate to he faces array.
    void        deleteVBAndFaceVectorFar1Only();

    // allocate Far1 VB, . do it only if Far1==true. Do not Test isRenderClipped() state.
    // With VB, allocate to he faces array.
    void        allocateVBAndFaceVectorFar1Only();

    // fill Far0 VB according CTessFace VBInfos and Far0 (do not fill if !Far0). Do not Test isRenderClipped() state.
    // Do not fill a VB if reallocationOccurs().
    void        fillVBFar0Only();
    // same for Far1
    void        fillVBFar1Only();


    // fill DLM Uv (ie UV1) for Far0 and Far1 VB only. NB: do not fill Far0 if !Far0 (idem fro Far1).
    // Do not Test isRenderClipped() state. Do not fill a VB if reallocationOccurs().
    void        fillVBFarsDLMUvOnly();
    void        fillFar0DLMUvOnlyVertexListVB(CTessList<CTessFarVertex>  &vertList);
    void        fillFar1DLMUvOnlyVertexListVB(CTessList<CTessFarVertex>  &vertList);


    // For Debug only.
    void        debugAllocationMarkIndices(uint marker);


    // Because of refine... tessBlock FaceVector may have been deleted, this method do nothing if isRenderClipped().
    // If not, recreate FaceVector for this tessBlock only, according to Far0 and Far1.
    void        recreateTessBlockFaceVector(CTessBlock &block);


    // @}


public:

    // @{

    void        deleteAllVegetableIgs();

    void        recreateAllVegetableIgs();

    // @}


    // @{
    void        resetTileLightInfluences();
    // @}


    // @{

    void        linkBeforeNearUL(CPatch *patchNext);
    void        unlinkNearUL();
    CPatch      *getNextNearUL() const {return _ULNearNext;}

    uint        getNumNearTessBlocks() const {return TessBlocks.size();}

    uint        updateTessBlockLighting(uint numTb);

    // @}


    // @{

    void        beginDLMLighting();
    void        processDLMLight(CPatchDLMPointLight &pl);
    void        endDLMLighting();

    // @}


    uint        getTileMaterialRefCount() const {return MasterBlock.TileMaterialRefCount;}

// Private part.
private:
/*********************************/

    friend  class CTessFace;
    friend  class CZone;
    friend  class CLandscapeVegetableBlock;
    friend  class CPatchRdrPass;

    CZone           *Zone;

    // Number of this patch in the zone. valid at compile Time.
    uint16          PatchId;
    // Tile Order for the patch.
    uint8           OrderS, OrderT;

    // This is especially for Pacs. false by default, and used by CZone::refineAll() and CZone::excludePatchFromRefineAll().
    bool            ExcludeFromRefineAll;

    // For this patch, which level is required for a face to be inserted in the secondary TessBlocks (and not the masterblock)??
    sint            TessBlockLimitLevel;
    // For this patch, which level is required for a face to be a valid Tile??
    sint            TileLimitLevel;
    // For this patch, which level is required for a face to be a "square" face (not rectangular)??
    sint            SquareLimitLevel;
    // The Base Size*bumpiness of the patch (/2 at each subdivide).
    float           ErrorSize;
    // The root for tesselation.
    CTessFace       *Son0, *Son1;
    // The base vertices.
    CTessVertex     *BaseVertices[4];
    // The base Far vertices (always here!!).
    CTessFarVertex  BaseFarVertices[4];


    // Local info for CTessFace tiles. CPatch must setup them at the begining at refine()/render().
    // For Far Texture coordinates.
    float           Far0UScale, Far0VScale, Far0UBias, Far0VBias;
    float           Far1UScale, Far1VScale, Far1UBias, Far1VBias;

    uint8           Flags;


    // Info for alpha transition with Far1.
    float           TransitionSqrMin;
    float           OOTransitionSqrDelta;

    /*
        Cache Optim Note:
        NB: for faster Cache Access during preRender(), you must leave those variables packed like this

        Far0
        Far1
        _PatchRdrPassFar0
        _NextRdrFar0
        _PatchRdrPassFar1
        _NextRdrFar1
        NumRenderableFaces
        TessBlocks (for size() )
        MasterBlock.Far0FaceVector
        MasterBlock.Far1FaceVector

        NB: Far0FaceVector and Far1FaceVector are accessed during renderFar*() (not preRender()) but they must be near
        to TessBlocks (for size() )
    */

    // Current Far Level computed in preRender()
    sint            Far0;           // The level of First Far: 0,1,2 or 3. 0 means Tile.
    sint            Far1;           // The level of second Far, for transition: 1,2 or 3. 0 means none.

    // The render Pass of Far0 and Far1.
    CPatchRdrPass   *_PatchRdrPassFar0;
    CPatch          *_NextRdrFar0;
    CPatchRdrPass   *_PatchRdrPassFar1;
    CPatch          *_NextRdrFar1;

    // @{
    // Tells how many Renderable Face this Patch has. updated in append/remove/FaceToRenderList()
    sint                        NumRenderableFaces;
    // The 2*2 block render. For memory optimisation, none is allocated when no faces need it.
    // There is (OrderT/2)*(OrderS/2) TessBlocks.
    NLMISC::CObjectVector<CTessBlock>   TessBlocks;
    // The block render of far only. Only Far faces bigger than a block are inserted here.
public: // tmp
    CTessBlock                  MasterBlock;
private:
    // The counter of faces which need TessBlocks (FarFaces, TileMaterial and FarVertices). When 0, the vector is contReset()-ed.
    sint                        TessBlockRefCount;
    // @}


    // @{
    std::vector<CVegetableClipBlock*>   VegetableClipBlocks;
    // @}


    static uint32   _Version;

private:
    // Guess.
    void            computeDefaultErrorSize();
    // based on BaseVertices, recompute positions, and Make Face roots Son0 and Son1.
    void            makeRoots();
    // Guess. For bind() reasons.
    CTessFace       *getRootFaceForEdge(sint edge) const;
    // Guess. For bind() reasons. return the vertex 0 of edge.
    CTessVertex     *getRootVertexForEdge(sint edge) const;
    void            changeEdgeNeighbor(sint edge, CTessFace *to);


    // @{

    // reset all list of MasterBlock.
    void            resetMasterBlock();
    // simply clear the tessnbloc array and reset cout to 0.
    void            clearTessBlocks();
    // add a ref to tess blocks, allocate them if necessary.
    void            addRefTessBlocks();
    // dec a ref to tess blocks, destroy them if necessary.
    void            decRefTessBlocks();
    // UGLY SIDE EFFECT: when refcount TessBlocks RefCount reach 0, tessblockas are deleted. think of it in tesselation.cpp.


    // Retrieve the tessblockId, depending on face info.
    uint            getNumTessBlock(CTessFace *face);
    // FarVertType.
    enum            TFarVertType {FVMasterBlock=0, FVTessBlock, FVTessBlockEdge};
    // Retrieve the tessblockId, depending on a ParamCoord.
    void            getNumTessBlock(CParamCoord pc, TFarVertType &type, uint &numtb);


    // If pathc is visible, force deletion of this TessBlock.
    void            dirtTessBlockFaceVector(CTessBlock &block);


    // For rdr. Insert in the GOOD TessBlock the face (depending on level, patchcoordinates etc...)
    // call appendFaceToTileRenderList() to insert his TileFaces into the good renderList.
    void            appendFaceToRenderList(CTessFace *face);
    // Remove a face and his tileface from the patch renderlist.
    // call removeFaceFromTileRenderList() to insert his TileFaces into the good renderList.
    void            removeFaceFromRenderList(CTessFace *face);
    // for changePatchTexture, insert just the TileFace into the good render List.
    void            appendFaceToTileRenderList(CTessFace *face);
    void            removeFaceFromTileRenderList(CTessFace *face);
    // For refreshTesselationGeometry() only. enlarge the TessBlock (if any) with face->V*->EndPos.
    void            extendTessBlockWithEndPos(CTessFace *face);

    // Set/Unset (to NULL) a TileMaterial from the TessBlocks. Material must exist for both functions.
    // And TileS/TileT must be OK.
    void            appendTileMaterialToRenderList(CTileMaterial *tm);
    void            removeTileMaterialFromRenderList(CTileMaterial *tm);

    // Add/Remove FarVertices. Use fv->PCoord to know where.
    void            appendFarVertexToRenderList(CTessFarVertex *fv);
    void            removeFarVertexFromRenderList(CTessFarVertex *fv);
    // Add/Remove NearVertices. Use tileMat to know where.
    void            appendNearVertexToRenderList(CTileMaterial *tileMat, CTessNearVertex *nv);
    void            removeNearVertexFromRenderList(CTileMaterial *tileMat, CTessNearVertex *nv);

    // @}



    // @{
    // For CTessFace::computeMaterial(). Return the render pass for this material, given the number of the tile, and the
    // desired pass. NULL may be returned if the pass is not present (eg: no additive for this tile...).
    CPatchRdrPass   *getTileRenderPass(sint tileId, sint pass);
    // For CTessFace::computeMaterial(). Return the orient/scalebias for the tile in the patchtexture, and the
    // desired pass (and the desired stage: RGB/Alpha).
    void            getTileUvInfo(sint tileId, sint pass, bool alpha, uint8 &orient, CVector &uvScaleBias, bool &is256x256, uint8 &uvOff);
    // @}

    // Tile LightMap mgt.
    // @{
    // for a given tile (accessed from the (ts,tt) coordinates), compute a lightmap if necessary, and get a RenderPass.
    void        getTileLightMap(uint ts, uint tt, CPatchRdrPass *&rdrpass);
    // get uvInfo for tile. NB: ts,tt form because simpler.
    void        getTileLightMapUvInfo(uint ts, uint tt, CVector &uvScaleBias);
    // release the tile lightmap. NB: ts,tt form because simpler.
    void        releaseTileLightMap(uint ts, uint tt);

    // Compute the Lightmap for 2x2 tiles. => 10x10 pixels. ts, tt is in [0,OrderS], [0, OrderT].
    void        computeNearBlockLightmap(uint ts, uint tt, NLMISC::CRGBA    *lightText);
    void        computeTileLightmapPixelAroundCorner(const NLMISC::CVector2f &stIn, NLMISC::CRGBA *dest, bool lookAround);

    // Compute a lightmap for a tile (ts,tt). 4x4 lumels are processed. NB: result= lumel*userColor.
    void        computeTileLightmap(uint ts, uint tt, NLMISC::CRGBA *dest, uint stride);
    // Compute a lightmap for an edge of a tile. 1x4 lumels. "edge" say what edge of the tile to compute.
    // pixels will be written in (dest+i*stride), where i vary from 0 to 3 or 3 to 0 (according to "inverse").
    void        computeTileLightmapEdge(uint ts, uint tt, uint edge, NLMISC::CRGBA *dest, uint stride, bool inverse);
    // Compute a lightmap just for a pixel (s,t) of a tile (ts,tt). (s,t) E [0;3], [0;3].
    void        computeTileLightmapPixel(uint ts, uint tt, uint s, uint t, NLMISC::CRGBA *dest);


    // Methods for automatic Lighting. NB: result= lumel only (no TileColors).
    void        computeTileLightmapAutomatic(uint ts, uint tt, NLMISC::CRGBA *dest, uint stride);
    void        computeTileLightmapEdgeAutomatic(uint ts, uint tt, uint edge, NLMISC::CRGBA *dest, uint stride, bool inverse);
    void        computeTileLightmapPixelAutomatic(uint ts, uint tt, uint s, uint t, NLMISC::CRGBA *dest);
    // Methods for Precomputed Lighting. NB: result= lumel only (no TileColors).
    void        computeTileLightmapPrecomputed(uint ts, uint tt, NLMISC::CRGBA *dest, uint stride);
    void        computeTileLightmapEdgePrecomputed(uint ts, uint tt, uint edge, NLMISC::CRGBA *dest, uint stride, bool inverse);
    void        computeTileLightmapPixelPrecomputed(uint ts, uint tt, uint s, uint t, NLMISC::CRGBA *dest);
    // Methods to modulate dest with TileColors. NB: A unmodified.
    void        modulateTileLightmapWithTileColors(uint ts, uint tt, NLMISC::CRGBA *dest, uint stride);
    void        modulateTileLightmapEdgeWithTileColors(uint ts, uint tt, uint edge, NLMISC::CRGBA *dest, uint stride, bool inverse);
    void        modulateTileLightmapPixelWithTileColors(uint ts, uint tt, uint s, uint t, NLMISC::CRGBA *dest);
    // get the tileColors at the corners of the tile. corner order: 0,0; 1,0; 0,1; 1,1. NB: A undefined.
    void        getTileTileColors(uint ts, uint tt, NLMISC::CRGBA corners[4]);


    // get the current TLIColor given a TLI coordinate (in (0..OrderS/2+1, 0..OrderT/2+1) )
    // NB: returned color is modulated by landscape material and precomputed diffuse factor
    CRGBA       getCurrentTLIColor(uint x, uint y) const;
    // get the current TLIColors at the corners of the tile (according to pointLights current colors)
    // corner order: 0,0; 1,0; 0,1; 1,1. NB: A undefined.
    void        getCurrentTileTLIColors(uint ts, uint tt, NLMISC::CRGBA corners[4]);
    // Methods to add dest with result of TLI lighting. NB: A unmodified.
    void        addTileLightmapWithTLI(uint ts, uint tt, NLMISC::CRGBA *dest, uint stride);
    void        addTileLightmapEdgeWithTLI(uint ts, uint tt, uint edge, NLMISC::CRGBA *dest, uint stride, bool inverse);
    void        addTileLightmapPixelWithTLI(uint ts, uint tt, uint s, uint t, NLMISC::CRGBA *dest);

    // @}


    // Recompute of new Far Values, according to globals. Don't erase Far0 and Far1.
    void        computeNewFar(const NLMISC::CBSphere &patchSphere, sint &newFar0, sint &newFar1);


    // For Render. Those methods compute the vertices for Driver (in CTessFace::Current*VB).
    void        fillFar0VertexVB(CTessFarVertex *pVert);
    void        fillFar1VertexVB(CTessFarVertex *pVert);
    void        fillTileVertexVB(CTessNearVertex *pVert);
    void        fillFar0VertexListVB(CTessList<CTessFarVertex>  &vertList);
    void        fillFar1VertexListVB(CTessList<CTessFarVertex>  &vertList);
    void        fillTileVertexListVB(CTessList<CTessNearVertex> &vertList);
    // For Render. Those methods allocate/delete vertices in VB.
    void        updateFar0VBAlloc(CTessList<CTessFarVertex>  &vertList, bool alloc);
    void        updateFar1VBAlloc(CTessList<CTessFarVertex>  &vertList, bool alloc);
    void        updateTileVBAlloc(CTessList<CTessNearVertex>  &vertList, bool alloc);
    void        updateVBAlloc(bool alloc);
    // For Debug Allcoation only.
    void        debugAllocationMarkIndicesFarList(CTessList<CTessFarVertex>  &vertList, uint marker);
    void        debugAllocationMarkIndicesNearList(CTessList<CTessNearVertex>  &vertList, uint marker);
    // For Render. Allocate / Fill FaceVector, according to Far0/Far1.
    void        createFaceVectorFar1();
    void        deleteFaceVectorFar1();
    void        createFaceVectorFar0OrTile();
    void        deleteFaceVectorFar0OrTile();



    // For Refine. Those methods do all the good job, and test if they can allocate the VB.
    void        checkCreateVertexVBFar(CTessFarVertex *pVert);
    void        checkCreateVertexVBNear(CTessNearVertex *pVert);
    // For Refine. Those methods do all the good job, and test if they can fill the VB.
    void        checkFillVertexVBFar(CTessFarVertex *pVert);
    void        checkFillVertexVBNear(CTessNearVertex   *pVert);
    // For Refine. Those methods do all the good job, and test if they have to delete the VB.
    void        checkDeleteVertexVBFar(CTessFarVertex *pVert);
    void        checkDeleteVertexVBNear(CTessNearVertex *pVert);

    // For Render, geomorph / Alpha in software.
    void        computeGeomorphVertexList(CTessList<CTessFarVertex>  &vertList);
    void        computeGeomorphFar0VertexListVB(CTessList<CTessFarVertex>  &vertList);
    void        computeGeomorphAlphaFar1VertexListVB(CTessList<CTessFarVertex>  &vertList);
    void        computeGeomorphTileVertexListVB(CTessList<CTessNearVertex>  &vertList);

    // @{
    void        buildBBoxFromBezierPatch(const CBezierPatch &p, CAABBox &ret) const;
    void        addTrianglesInBBoxRecurs(CPatchIdent paId, const CAABBox &bbox, std::vector<CTrianglePatch> &triangles, uint8 tessLevel,
        const CBezierPatch &pa, uint8 s0, uint8 s1, uint8 t0, uint8 t1) const;
    void        addTileTrianglesInBBox(CPatchIdent paId, const CAABBox &bbox, std::vector<CTrianglePatch> &triangles, uint8 tessLevel,
        uint8 s0, uint8 t0) const;

    void        addPatchBlocksInBBoxRecurs(CPatchIdent paId, const CAABBox &bbox, std::vector<CPatchBlockIdent> &paBlockIds,
        const CBezierPatch &pa, uint8 s0, uint8 s1, uint8 t0, uint8 t1) const;

    CVector     computeVertexButCorner(float s, float t, bool &onCorner) const;

    // @}


private:



    // @{

    CZone       *_BindZoneNeighbor[4];

    CTessFace   *linkTessFaceWithEdge(const NLMISC::CVector2f &uv0, const NLMISC::CVector2f &uv1, CTessFace *linkTo);

    // @}



    // @{


    float       computeDisplaceRawInteger(sint ts, sint tt, sint ms, sint mt) const;
    void        computeDisplaceRawCoordinates(float sTile, float tTile, float s, float t,
    sint &ts, sint &tt, sint &ms, sint &mt) const;
    float       computeDisplaceRaw(float sTile, float tTile, float s, float t) const;
    float       computeDisplaceRawOnNeighbor(float sTile, float tTile, float s, float t) const;


    float       computeDisplaceInteriorSmooth(float s, float t) const;
    float       computeDisplaceEdgeSmooth(float s, float t, sint8 smoothBorderX, sint8 smoothBorderY) const;
    float       computeDisplaceCornerSmooth(float s, float t, sint8 smoothBorderX, sint8 smoothBorderY) const;


    CVector     computeNormalEdgeSmooth(float s, float t, sint8 smoothBorderX, sint8 smoothBorderY) const;
    CVector     computeNormalCornerSmooth(float s, float t, sint8 smoothBorderX, sint8 smoothBorderY) const;
    CVector     computeNormalOnNeighbor(float s, float t, uint edgeExclude) const;


    void        computeNoise(float s, float t, CVector &displace) const;

    // @}


    // From tile coordinates, return the tessBlockId, and the id of the material in this tessBlock.
    void        computeTbTm(uint &numtb, uint &numtm, uint ts, uint tt);


    // @{

    void        createVegetableBlock(uint numTb, uint ts, uint tt);
    void        releaseVegetableBlock(uint numTb);

    /*
        generate the vegetables for a given tile in the vegetable manager.
        instances are added to vegetIg.
        Warning! Use OptFastFloor()! So call must be enclosed with a OptFastFloorBegin()/OptFastFloorEnd().
    */
    void        generateTileVegetable(CVegetableInstanceGroup *vegetIg, uint distType, uint ts, uint tt,
        CLandscapeVegetableBlockCreateContext &vbCreateCtx);

    // same as computeTileLightmapPrecomputed(), but brut result, not modified by colorTable.
    void        getTileLumelmapPrecomputed(uint ts, uint tt, uint8 *dest, uint stride);
    void        getTileLumelmapPixelPrecomputed(uint ts, uint tt, uint s, uint t, uint8 &dest) const;

    // @}


    // @{
    CPatch      *_ULNearPrec;
    CPatch      *_ULNearNext;
    // @}


    // @{

    CPatchDLMContext    *_DLMContext;

    sint                _DLMContextRefCount;

    void                addRefDLMContext();
    void                decRefDLMContext(uint count= 1);

    // @}


private:
    // NB: All global render info are stored in CTessFace class static members....

    // The Patch cache (may be a short list/vector later...).
    static  CBezierPatch    CachePatch;
    // For cahcing.
    static  const CPatch    *LastPatch;

public:
    // unpack the patch into the cache.
    CBezierPatch    *unpackIntoCache() const;

};



} // NL3D


#endif // NL_PATCH_H

/* End of patch.h */