Fix game:addSpawnShapesByZone

[ryzomcore.git] / nel / tools / pacs / build_rbank / build_surf.h

// 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) 2010  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/>.

#ifndef NL_BUILD_SURF_H
#define NL_BUILD_SURF_H

#include <vector>

#include "nel/misc/debug.h"
#include "nel/misc/file.h"

#include "nel/3d/zone.h"
#include "nel/3d/patch.h"
#include "nel/3d/mesh.h"
#include "nel/3d/landscape.h"

#include "nel/3d/quad_tree.h"
#include "nel/3d/quad_grid.h"

#include "nel/misc/vector.h"
#include "nel/misc/aabbox.h"
#include "nel/misc/geom_ext.h"
#include "nel/misc/polygon.h"

#include "nel/pacs/surface_quad.h"
#include "nel/pacs/retrievable_surface.h"

#include "prim_checker.h"



extern std::string                              OutputRootPath;
extern std::string                              OutputDirectory;
extern std::string                              OutputPath;
extern std::string                              TessellationPath;
extern std::string                              IGBoxes;
extern uint                                             TessellateLevel;
extern bool                                             ReduceSurfaces;
extern bool                                             SmoothBorders;
extern bool                                             ComputeElevation;
extern bool                                             ComputeLevels;
extern std::vector<std::string> ZoneNames;
extern std::string                              ZoneExt;
extern std::string                              ZoneNHExt;
extern std::string                              ZoneLookUpPath;

extern bool                                             ProcessAllPasses;
extern bool                                             CheckPrims;
extern bool                                             TessellateZones;
extern bool                                             MoulineZones;
extern bool                                             TessellateAndMoulineZones;
extern bool                                             ProcessRetrievers;
extern std::string                              PreprocessDirectory;

extern float                                    WaterThreshold;

extern bool                                             UseZoneSquare;
extern std::string                              ZoneUL;
extern std::string                              ZoneDR;

extern std::string                              GlobalRetriever;
extern std::string                              RetrieverBank;
extern std::string                              GlobalUL;
extern std::string                              GlobalDR;
extern bool                                             ProcessGlobal;
extern bool                                             Verbose;
extern bool                                             CheckConsistency;

extern CPrimChecker                             PrimChecker;

std::string                     getZoneNameById(uint16 id);
uint16                          getZoneIdByName(std::string &name);
NLMISC::CAABBox         getZoneBBoxById(uint16 id);
uint16                          getZoneIdByPos(NLMISC::CVector &pos);
NL3D::CMesh                     *generateMeshFromBBox(const NLMISC::CAABBox &bbox, NLMISC::CRGBA color = NLMISC::CRGBA(255, 128, 0));

namespace NLPACS
{

class CSurfElement;
class CComputableSurfaceBorder;
class CComputableSurface;
class CPatchTessellation;
class CZoneTessellation;



/**/

const sint32    UnaffectedSurfaceId = -1;











/**
 * CSurfElement is an element of an iso-criteria surface. It is basically a CTriangle, and
 * contains the various criteria values such as incline class, landscape material ...
 * \author Benjamin Legros
 * \author Nevrax France
 * \date 2001
 */
class CSurfElement
{
public:
        /**
         *
         */
        uint32                                                  ElemId;

        /**
         * The support of the surface element.
         * The index to the 3 vertices of the triangle.
         */
        uint32                                                  Tri[3];

        /**
         * The element normal vector
         */
        NLMISC::CVector                                 Normal;

        /**
         * The area of the element
         */
        float                                                   Area;

        /**
         * The zone id
         */
        uint16                                                  ZoneId;

        /**
         * The tessellation vertices
         */
        std::vector<NLMISC::CVector>    *Vertices;


        /* Here the surface criteria.
           Probably some normal quantization, material, flags ... */
        uint8                                                   WaterShape;
        uint8                                                   QuantHeight;

        uint32                                                  ForceMerge;
        
        bool                                                    ForceInvalid;
        bool                                                    IsBorder;
        bool                                                    IsValid;
        bool                                                    IsMergable;
        bool                                                    ClusterHint;
        bool                                                    IsUnderWater;

        enum
        {
                NumNormalQuantas = 4,
                NumOrientationQuantas = 4
        };


        /** 
         * The links to the neighboring elements.
         * Each edge is related to the opposite vertex in the triangle */
        CSurfElement            *EdgeLinks[3];

        /**
         * A flag for each edge, set if the edge has already been evaluated (in
         * the surface border computation.
         */
        bool                            EdgeFlag[3];

        /**
         * The Id of the surface container.
         */
        sint32                          SurfaceId;

public:
        /**
         * Constructor.
         * Creates a simple CSurfElement.
         */
        CSurfElement()
        {
                ElemId = 0;
                EdgeLinks[0] = NULL;
                EdgeLinks[1] = NULL;
                EdgeLinks[2] = NULL;
                EdgeFlag[0] = false;
                EdgeFlag[1] = false;
                EdgeFlag[2] = false;
                SurfaceId = UnaffectedSurfaceId;
                IsBorder = false;
                IsValid = false;
                IsMergable = true;
                ClusterHint = false;
                ForceInvalid = false;
                IsUnderWater = false;
                WaterShape = 255;
                QuantHeight = 0;
                ForceMerge = 0;
                ZoneId = 0;
        }

        /// Computes the bbox of the surface element.
        NLMISC::CAABBox getBBox() const;


        /**
         * Computes the various criteria values (associated to quantas)
         */
        void    computeQuantas(CZoneTessellation *zoneTessel);

        /**
         * Removes properly all links to the CSurfElement.
         */
        void    removeLinks()
        {
                uint    i, j;
                for (i=0; i<3; ++i)
                {
                        if (EdgeLinks[i] != NULL)
                                for (j=0; j<3; ++j)
                                        if (EdgeLinks[i]->EdgeLinks[j] == this)
                                                EdgeLinks[i]->EdgeLinks[j] = NULL;
                        EdgeLinks[i] = NULL;
                }

        }

        /**
         * Get zone Id on edge
         */
        sint32  getZoneIdOnEdge(uint edge) const
        {
                return (EdgeLinks[edge] != NULL ? EdgeLinks[edge]->ZoneId : -1);
        }

        void    serial(NLMISC::IStream &f, std::vector<CSurfElement> &tessellation)
        {
                f.serial(ElemId);
                f.serial(Tri[0], Tri[1], Tri[2]);
                f.serial(Normal);
                f.serial(ZoneId);

                if (f.isReading())
                {
                        sint32  s;
                        uint    i;
                        for (i=0; i<3; ++i)
                        {
                                f.serial(s);
                                EdgeLinks[i] = (s >= 0 ? &tessellation[s] : NULL);
                        }
                }
                else
                {
                        sint32  s;
                        uint    i;
                        for (i=0; i<3; ++i)
                        {
                                s = (EdgeLinks[i] != NULL ? EdgeLinks[i]->ElemId : -1);
                                f.serial(s);
                        }
                }
        }
};







/**
 * CComputableSurfaceBorder separates geometrically 2 distinct CComputableSurface objects
 * \author Benjamin Legros
 * \author Nevrax France
 * \date 2001
 */
class CComputableSurfaceBorder
{
public:
        std::vector<NLMISC::CVector>    Vertices;

        sint32                                                  Left;
        sint32                                                  Right;

        float                                                   Length;

        sint8                                                   Edge;

        bool                                                    DontSmooth;

public:
        /// Constructor.
        CComputableSurfaceBorder(sint32 left = 0, sint32 right = 0, sint edge=-1) : Left(left), Right(right), Edge(edge), DontSmooth(false) {}

        /// Dump the vertices that constitue the border.
        void    dump();

        /// Smoothes the border (and so reduces the number of vertices).
        void    smooth(float val);

        /// Computes the length of the border
        void    computeLength()
        {
                sint    n;
                Length = 0.0;
                for (n=0; n<(sint)Vertices.size()-1; ++n)
                {
                        Length += (Vertices[n+1]-Vertices[n]).norm();
                }
        }
};










/**
 * CComputableSurface is a compact connex set of CSurfElement.
 * \author Benjamin Legros
 * \author Nevrax France
 * \date 2001
 */
class CComputableSurface
{
public:

public:
        /// The Id of the surface
        sint32                                                                  SurfaceId;

        /// The references on the elements that belong to the surface
        std::vector<CSurfElement *>                             Elements;

        /// The object that stores all the borders used in the computed area
        std::vector<CComputableSurfaceBorder>   *BorderKeeper;

        /// The border in the surface, by id
        std::vector<uint16>                                             BorderIds;

        bool                                                                    IsUnderWater;
        bool                                                                    ClusterHint;

        float                                                                   Area;
        float                                                                   WaterHeight;
        uint8                                                                   QuantHeight;

        /// The BBox of the whole zone (in which the surface should be contained.)
        NLMISC::CAABBox                                                 BBox;

        /// The height storage quad tree
        CSurfaceQuadTree                                                HeightQuad;

        /// The center of the surface
        NLMISC::CVector                                                 Center;

public:
        /**
         * Constructor.
         * Builds an empty surface.
         */
        CComputableSurface() : SurfaceId(UnaffectedSurfaceId), BorderKeeper(NULL), ClusterHint(false)   {}

        /**
         * Flood fills the surface elements to find iso-criteria surfaces.
         * Every linked surface element which has the same quantas values and a surfaceid == -1
         * are marked and recursively called.
         */
        template<class A>
        void    floodFill(CSurfElement *first, sint32 surfId, const A &cmp, CZoneTessellation *zoneTessel)
        {
                if (Verbose)
                {
                        nldebug("flood fill surface %d", surfId);
                }

                std::vector<CSurfElement *>     stack;
                sint                                    i;

                stack.push_back(first);
                first->SurfaceId = surfId;

                SurfaceId = surfId;
                ClusterHint = first->ClusterHint;
                QuantHeight = first->QuantHeight;
                uint    waterShape = first->WaterShape;

                IsUnderWater = first->IsUnderWater;

                //WaterHeight = IsUnderWater ? zoneTessel->WaterShapes[first->WaterShape].Vertices[0].z : 123456.0f;
                bool    tamere;
                WaterHeight = IsUnderWater ? PrimChecker.waterHeight(first->WaterShape, tamere)+WaterThreshold : 123456.0f;


                uint32  currentZoneId = first->ZoneId;

                Area = 0.0;

                while (!stack.empty())
                {
                        CSurfElement    *pop = stack.back();
                        stack.pop_back();
                        Elements.push_back(pop);
                        Area += pop->Area;

                        for (i=0; i<3; ++i)
                        {
                                if (pop->EdgeLinks[i] != NULL && pop->EdgeLinks[i]->SurfaceId == UnaffectedSurfaceId && cmp.equal(first, pop->EdgeLinks[i]))
                                {
                                        pop->EdgeLinks[i]->SurfaceId = SurfaceId;
                                        stack.push_back(pop->EdgeLinks[i]);
                                }
                        }
                }

                if (Verbose)
                {
                        nldebug("%d elements added", Elements.size());
                }

                Center = NLMISC::CVector::Null;
                for (i=0; i<(sint)Elements.size(); ++i)
                {
                        std::vector<NLMISC::CVector>    &vertices = *Elements[i]->Vertices;
                        Center += (vertices[Elements[i]->Tri[0]]+vertices[Elements[i]->Tri[1]]+vertices[Elements[i]->Tri[2]]);
                }
                Center /= (float)(Elements.size()*3);
        }


        /// Builds the border of the CComputableSurface.
        void    buildBorders(CZoneTessellation *zoneTessel);

        /// Check Surface Consistency
        bool    checkConsistency();

private:
        void    followBorder(CZoneTessellation *zoneTessel, CSurfElement *first, uint edge, uint sens, std::vector<NLMISC::CVector> &vstore, bool &loop);
};














/**
 * CZoneTessellation is the whole tessellation of a given CZone.
 * \author Benjamin Legros
 * \author Nevrax France
 * \date 2001
 */
class CZoneTessellation
{
private:
        std::vector<CSurfElement>                               _Tessellation;
        std::vector<NLMISC::CVector>                    _Vertices;

protected:

        std::vector<uint16>                                             _ZoneIds;
        std::vector<const NL3D::CZone*>                 _ZonePtrs;

public:
        class CMergeForceBox
        {
        public:
                NLMISC::CAABBox                                         MergeBox;
                uint32                                                          MergeId;
                void    serial(NLMISC::IStream &f)              { f.serial(MergeBox, MergeId); }
        };

public:
        /// The zone valid tessellation elements.
        std::vector<CSurfElement *>                             Elements;

        ///
        NLMISC::CAABBox                                                 BBox;
        NLMISC::CAABBox                                                 OriginalBBox;
        NLMISC::CAABBox                                                 BestFittingBBox;
        // Yoyo: if zone is empty, we must not apply the Translation delta to zone
        bool                                                                    BestFittingBBoxSetuped;

        ///
        NLMISC::CVector                                                 Translation;

        ///
        sint32                                                                  CentralZoneId;

        std::vector<NLMISC::CPolygon>                   WaterShapes;
        NL3D::CQuadGrid<uint32>                                 WaterGrid;

        /** 
         * The tessellation refinement. The size of the tessellation is equal to 2m/Refinement
         * (say, for instance, a refinement of 2 means a 1m large tessellation.)
         */
        sint16                                                                  Refinement;

        /**
         * The surfaces composing the tessellation.
         */
        std::vector<CComputableSurface>                 Surfaces;
        std::vector<CComputableSurface>                 ExtSurfaces;

        /**
         * The borders for the whole CZone.
         */
        std::vector<CComputableSurfaceBorder>   Borders;

        /**
         * The box that force merge into surface
         */
        std::vector<CMergeForceBox>                             ForceMerge;

        /**
         * Flags
         */
        std::vector<uint8>                                              VerticesFlags;

public:
        /**
         * Constructor
         * Creates an empty tessellation.
         */
        CZoneTessellation() {}

        /**
         * Clear
         */
        void    clear();

        /**
         * Sets a zone tessellation up for building later.
         */
        bool    setup(uint16 zoneId, sint16 refinement, const NLMISC::CVector &translation);

        /**
         * Adds a zone light tessellation to the quad tree container.
         */
        void    addToContainer(const NL3D::CZone &zone);
        NL3D::CMesh     *generateCollisionMesh();

        /**
         * Builds the whole zone tessellation (with linkage) from the given zone.
         */
        void    build();

        /**
         * Sets the water polygons up.
         */
        void    addWaterShape(const NLMISC::CPolygon &poly)
        {
                WaterShapes.push_back(poly);
        }

        /**
         * Compile the whole zone tessellation and creates surfaces
         */
        void    compile();

        /**
         * Generates a CMesh from the tessellation.
         */
        NL3D::CMesh     *generateMesh();

        /**
         * Generates borders for the whole zone tessellation.
         * \param smooth how much to smooth the borders
         */
        void    generateBorders(float smooth);

        /**
         *
         */
        NLMISC::CAABBox computeBBox() const;

        /**
         * Save tessellation
         */
        void    saveTessellation(NLMISC::COFile &output);

        /**
         * Load tessellation
         */
        void    loadTessellation(NLMISC::CIFile &input);

private:
        void    checkSameLandscapeHmBinds(const NL3D::CLandscape &landscape, const NL3D::CLandscape &landscapeNoHm);
};



class CSurfElemCompareSimple
{
public:

        bool    equal(const CSurfElement *a, const CSurfElement *b) const
        {
                return  a->IsValid == b->IsValid &&
                                a->ForceInvalid == b->ForceInvalid;
        }
};

class CSurfElemCompareNormal
{
public:

        bool    equal(const CSurfElement *a, const CSurfElement *b) const
        {
                return  b->IsValid &&
                                a->ClusterHint == b->ClusterHint &&
                                a->ZoneId == b->ZoneId &&
                                a->IsUnderWater == b->IsUnderWater &&
                                a->WaterShape == b->WaterShape &&
                                a->QuantHeight == b->QuantHeight;
        }
};


}; // NLPACS

#endif // NL_BUILD_SURF_H

/* End of build_surf.h */