// 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/>. #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 */