zone.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_ZONE_H
#define NL_ZONE_H

#include "nel/misc/types_nl.h"
#include "nel/misc/smart_ptr.h"
#include "nel/misc/stream.h"
#include "nel/misc/debug.h"
#include "nel/misc/bit_set.h"
#include "3d/tessellation.h"
#include "3d/patch.h"
#include "3d/bezier_patch.h"
#include "3d/point_light_named.h"
#include "3d/point_light_named_array.h"
#include <stdio.h>
#include <vector>
#include <map>


namespace NL3D 
{


class CZone;
class CLandscape;
class CZoneSymmetrisation;
class CTileBank;

using NLMISC::CAABBoxExt;


// ***************************************************************************
typedef std::map<uint16, CZone*>                        TZoneMap;
typedef std::map<uint16, CZone*>::iterator      ItZoneMap;


// ***************************************************************************
struct  CBorderVertex
{
        // The index of vertex in the current zone to bind.
        uint16                  CurrentVertex;
        // The neighbor zone Id.
        uint16                  NeighborZoneId;
        // The index of vertex in the neighbor zone to bind to CurrentVertex.
        uint16                  NeighborVertex;

        void                    serial(NLMISC::IStream &f);
};


// ***************************************************************************
struct  CPatchInfo
{
public:

        struct  CBindInfo
        {
                uint8                   NPatchs;

                uint16                  ZoneId;
                uint16                  Next[4];
                uint8                   Edge[4];

        public:
                void                    serial(NLMISC::IStream &f);
                CBindInfo() {NPatchs=0;}
        };

        
public:
        // @{
        CBezierPatch    Patch;
        uint8                   OrderS, OrderT;
        float                   ErrorSize;
        uint16                  BaseVertices[4];

        uint8                   Flags;


        uint8                   NoiseRotation;

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

        // @}


        // @{

        std::vector<CTileElement>       Tiles;

        std::vector<CTileColor>         TileColors;

        std::vector<uint8>                      Lumels;

        std::vector<CTileLightInfluence>                TileLightInfluences;

        // @}


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

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

        bool getNeighborTile (uint patchId, uint edge, sint position, uint &patchOut, sint &sOut, sint &tOut, const std::vector<CPatchInfo> &patchInfos) const;

        static bool transform (std::vector<CPatchInfo> &patchInfo, NL3D::CZoneSymmetrisation &zoneSymmetry, const NL3D::CTileBank &bank, bool symmetry, uint rotate, float snapCell, float weldThreshold, const NLMISC::CMatrix &toOriginalSpace);

        // Transform tile and 256 case with rotation and symmetry parameters
        static bool getTileSymmetryRotate (const NL3D::CTileBank &bank, uint tile, bool &symmetry, uint &rotate);
        static bool transformTile (const NL3D::CTileBank &bank, uint &tile, uint &tileRotation, bool symmetry, uint rotate, bool goofy);
        static void transform256Case (const NL3D::CTileBank &bank, uint8 &case256, uint tileRotation, bool symmetry, uint rotate, bool goofy);

        // @{
        CBindInfo               BindEdges[4];
        // @}


public:
        CPatchInfo()
        {
                ErrorSize= 0;
                // No Rotation / not smooth by default.
                NoiseRotation= 0;
                _CornerSmoothFlag= 0;
        }

private:
        // Noise Smooth flags.
        uint8                   _CornerSmoothFlag;

};


// ***************************************************************************
struct  CZoneInfo
{
        uint16                                          ZoneId;
        std::vector<CPatchInfo>         Patchs;
        std::vector<CBorderVertex>      BorderVertices;

        std::vector<CPointLightNamed>   PointLights;
};


// ***************************************************************************
class CZone
{
public:
        // The stored patch structure for compile() - ation.
        struct  CPatchConnect
        {
                // NB: same meanings than in CPatchInfo.
                uint8                   OldOrderS, OldOrderT;
                float                   ErrorSize;
                uint16                  BaseVertices[4];
                CPatchInfo::CBindInfo           BindEdges[4];

        public:
                void                    serial(NLMISC::IStream &f);
        };

public:

        CZone();
        ~CZone();


        void                    build(const CZoneInfo &zoneInfo, uint32 numVertices=0);


        void                    build(uint16 zoneId, const std::vector<CPatchInfo> &patchs, const std::vector<CBorderVertex> &borderVertices, uint32 numVertices=0);


        void                    build(const CZone &zone);


        void                    retrieve(CZoneInfo &zoneInfo);


        void                    retrieve(std::vector<CPatchInfo> &patchs, std::vector<CBorderVertex> &borderVertices);



        void                    debugBinds(FILE *f= stdout);


        void                    compile(CLandscape *landscape, TZoneMap &loadedZones);

        void                    release(TZoneMap &loadedZones);


        void                    serial(NLMISC::IStream &f);


        void                    changePatchTextureAndColor (sint numPatch, const std::vector<CTileElement> *tiles, const std::vector<CTileColor> *colors);


        void                    refreshTesselationGeometry(sint numPatch);


        const std::vector<CTileElement> &getPatchTexture(sint numPatch) const;

        const std::vector<CTileColor> &getPatchColor(sint numPatch) const;

        void setTileColor(bool monochrome, float factor);

        CLandscape*             getLandscape () const
        {
                return Landscape;
        }

        // NB: for all those function, CTessFace static rendering context must be setup.
        void                    clip(const std::vector<CPlane>  &pyramid);
        void                    preRender();
        // release Far render pass/reset Tile/Far render. Delete also VB, and FaceVectors
        void                    resetRenderFarAndDeleteVBFV();
        void                    forceMergeAtTileLevel();

        void                    refineAll();
        void                    excludePatchFromRefineAll(uint patch, bool exclude);
        void                    averageTesselationVertices();

        // Accessors.
        const CVector   &getPatchBias() const {return PatchBias;}
        float                   getPatchScale() const {return PatchScale;}
        bool                    compiled() const {return Compiled;}
        uint16                  getZoneId() const {return ZoneId;}
        sint                    getNumPatchs() const {return Patchs.size();}
        // Return the Bounding Box of the zone.
        const CAABBoxExt        &getZoneBB() const {return ZoneBB;}

        const CPatch    *getPatch(sint patch) const {nlassert(patch>=0 && patch<(sint)Patchs.size()); return &(Patchs[patch]);}

        const CPatchConnect     *getPatchConnect(sint patch) const 
                {nlassert(patch>=0 && patch<(sint)Patchs.size()); return &(PatchConnects[patch]);}


        void                    applyHeightField(const CLandscape &landScape);

        void setupColorsFromTileFlags(const NLMISC::CRGBA colors[4]);
        
        void copyTilesFlags(sint destPatchId, const CPatch *srcPatch);

        const CBSphere  &getPatchBSphere(uint patch) const;

        bool                    isPatchRenderClipped(uint patch) const {return _PatchRenderClipped.get(patch);}

// Private part.
private:
/*********************************/
        // A smartptrisable vertex.
        struct  CTessBaseVertex : public NLMISC::CRefCount
        {
                CTessVertex             Vert;
        };

        // Zone vertices.
        typedef NLMISC::CSmartPtr<CTessBaseVertex>      PBaseVertex;
        typedef std::vector<PBaseVertex>                        TBaseVerticesVec;


private:
        // The lanscape which own this zone. Usefull for texture management.
        // Filled at compilation only.
        CLandscape              *Landscape;

        // Misc.
        uint16                  ZoneId;
        bool                    Compiled;
        CAABBoxExt              ZoneBB;
        CVector                 PatchBias;
        float                   PatchScale;

        // The number of vertices she access (maybe on border).
        sint32                          NumVertices;
        // The smartptr on zone vertices.
        TBaseVerticesVec        BaseVertices;
        // The list of border vertices.
        std::vector<CBorderVertex>      BorderVertices;
        // NB: No problem on corners, since zones are compile()-ed with knowledge of neighbors.

        // The patchs.
        std::vector<CPatch>                     Patchs;
        std::vector<CPatchConnect>      PatchConnects;
        // Clipped States and BSphere stored here and not in CPatch for faster memory access during clip
        std::vector<CBSphere>           _PatchBSpheres;
        NLMISC::CBitSet                         _PatchRenderClipped;
        NLMISC::CBitSet                         _PatchOldRenderClipped;


        CPointLightNamedArray                   _PointLightArray;

        
private:
        friend  class CLandscape;
        friend  class CTessFace;
        // Should do this, for texture mgt.
        friend  class CPatch;

        sint                    ClipResult;
        enum    TClipResult {ClipIn= 0, ClipOut= 1, ClipSide= 2};


private:
        void                    rebindBorder(TZoneMap &loadedZones);

        PBaseVertex             getBaseVertex(sint vert) const {return BaseVertices[vert];}
        CPatch                  *getPatch(sint patch) {nlassert(patch>=0 && patch<(sint)Patchs.size()); return &(Patchs[patch]);}
        static CPatch   *getZonePatch(TZoneMap &loadedZones, sint zoneId, sint patch);
        // Bind the patch with ones which are loaded...
        static void             unbindPatch(CPatch &pa);
        static void             bindPatch(TZoneMap &loadedZones, CPatch &pa, CPatchConnect &pc, bool rebind);
        // Is the patch on a border of this zone???
        bool                    patchOnBorder(const CPatchConnect &pc) const;

        // compute AABBox, PatchBias and PatchScale, from a bbox.
        void                    computeBBScaleBias(const CAABBox        &bb);


        // For CPatch: build a bindInfo.
        void                    buildBindInfo(uint patchId, uint edge, CZone *neighborZone, CPatch::CBindInfo   &paBind);

        // Patch Array Clip
        void                    clipPatchs(const std::vector<CPlane>    &pyramid);
};


} // NL3D


#endif // NL_ZONE_H

/* End of zone.h */

---