Home

nevrax.com

Nevrax.org News Mailing-list Documentation CVS Bugs License

Documentation                       Search   landscape.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_LANDSCAPE_H #define NL_LANDSCAPE_H #include "nel/misc/types_nl.h" #include "nel/misc/class_id.h" #include "nel/misc/smart_ptr.h" #include "nel/misc/triangle.h" #include "3d/zone.h" #include "3d/tile_bank.h" #include "3d/patch_rdr_pass.h" #include "3d/vertex_buffer.h" #include "3d/primitive_block.h" #include "3d/material.h" #include "3d/tile_far_bank.h" #include "3d/texture_near.h" #include "3d/quad_grid.h" #include "nel/misc/block_memory.h" #include "3d/landscapevb_allocator.h" #include "3d/landscape_face_vector_manager.h" #include "3d/tess_face_priority_list.h" #include "nel/3d/point_light_influence.h" #include <map> #define NL_MAX_SIZE_OF_TEXTURE_EDGE_SHIFT (NL_MAX_TILES_BY_PATCH_EDGE_SHIFT+NL_NUM_PIXELS_ON_FAR_TILE_EDGE_SHIFT) #define NL_MAX_SIZE_OF_TEXTURE_EDGE (1<<NL_MAX_SIZE_OF_TEXTURE_EDGE_SHIFT) // Size max of a far texture edge in pixel namespace NL3D { class CHeightMap; class CTileNoiseMap; class CVegetableManager; class CVegetable; class CTileVegetableDesc; class CScene; class CTextureFar; class CTextureDLM; class CPatchDLMContextList; using NLMISC::Exception; using NLMISC::CTriangle; using NLMISC::CBlockMemory; // *************************************************************************** // The maximum amount of different tiles in world. const sint NbTilesMax= 65536; // Size of a CTextureNear. 256 by default (works everywhere). // Texures must be square, because of uvscalebias... const sint TextureNearSize= 512; const sint NbTileLightMapByLine= TextureNearSize/NL_TILE_LIGHTMAP_SIZE; const sint NbTileLightMapByTexture= NbTileLightMapByLine*NbTileLightMapByLine; // *************************************************************************** struct EBadBind : public Exception { private: mutable std::string _Output; public: struct CBindError { CBindError(sint z, sint p) {ZoneId= z; PatchId= p;} sint ZoneId; sint PatchId; }; // The result list of bind errors. std::list<CBindError> BindErrors; public: EBadBind() {} ~EBadBind() throw () {} virtual const char *what() const throw(); }; // *************************************************************************** class CLandscape : public NLMISC::CRefCount { public: // The bank of tiles information. CTileBank TileBank; CTileFarBank TileFarBank; public: CLandscape(); ~CLandscape(); // @{ void init(); bool addZone(const CZone &newZone); bool removeZone(uint16 zoneId); void clear(); void checkBinds() throw(EBadBind); void checkBinds(uint16 zoneId) throw(EBadBind); bool initTileBanks (); // @} // @{ void setTileNear (float tileNear); float getTileNear () const {return _TileDistNear;} void setThreshold (float thre); float getThreshold () const {return _Threshold;} void setRefineMode(bool enabled) {_RefineMode= enabled;} bool getRefineMode() const {return _RefineMode;} void setTileMaxSubdivision (uint tileDiv); uint getTileMaxSubdivision (); void setNoiseMode(bool enabled); bool getNoiseMode() const; // \todo yoyo: other landscape param setup (Transition etc...). // Store it by landscape, and not only globally in CLandscapeGlobals statics. // @} // @{ void setDriver(IDriver *drv); void clip(const CVector &refineCenter, const std::vector<CPlane> &pyramid); void refine(const CVector &refineCenter); void render(const CVector &refineCenter, const CVector &frontVector, const CPlane pyramid[NL3D_TESSBLOCK_NUM_CLIP_PLANE], bool doTileAddPass=false); void refineAll(const CVector &refineCenter); void excludePatchFromRefineAll(sint zoneId, uint patch, bool exclude); void averageTesselationVertices(); // @} // @{ void buildCollideFaces(const CAABBoxExt &bbox, std::vector<CTriangle> &faces, bool faceSplit); void buildCollideFaces(sint zoneId, sint patch, std::vector<CTriangle> &faces); void buildTrianglesInBBox(const CAABBox &bbox, std::vector<CTrianglePatch> &triangles, uint8 tileTessLevel); void buildPatchBlocksInBBox(const CAABBox &bbox, std::vector<CPatchBlockIdent> &paBlockIds); void fillPatchQuadBlock(CPatchQuadBlock &quadBlock) const; CVector getTesselatedPos(const CPatchIdent &patchId, const CUV &uv) const; void getTessellationLeaves(std::vector<const CTessFace*> &leaves) const; // @} // @{ CZone* getZone (sint zoneId); const CZone* getZone (sint zoneId) const; void getZoneList(std::vector<uint16> &zoneIds) const; static void buildZoneName(sint zoneId, std::string &zoneName); // @} // @{ void flushTiles(IDriver *drv, uint16 tileStart, uint16 nbTiles); void releaseTiles(uint16 tileStart, uint16 nbTiles); NLMISC::CSmartPtr<ITexture> getTileTexture(uint16 tileId, CTile::TBitmap bitmapType, CVector &uvScaleBias); CTileElement *getTileElement(const CPatchIdent &patchId, const CUV &uv); // @} // @{ void setupStaticLight (const CRGBA &diffuse, const CRGBA &ambiant, float multiply); const CRGBA* getStaticLight () const { return _LightValue; } void setPointLightDiffuseMaterial(CRGBA diffuse); CRGBA getPointLightDiffuseMaterial () const { return _PointLightDiffuseMaterial; } void enableAutomaticLighting(bool enable); void setupAutomaticLightDir(const CVector &lightDir); bool getAutomaticLighting() const {return _AutomaticLighting;} const CVector &getAutomaticLightDir() const {return _AutomaticLightDir;} void removeAllPointLights(); void setPointLightFactor(const std::string &lightGroupName, NLMISC::CRGBA nFactor); // @} // @{ CVector getHeightFieldDeltaZ(float x, float y) const; void setHeightField(const CHeightMap &hf); // @} // @{ void createVegetableBlendLayersModels(CScene *scene); void setVegetableTime(double time); void setVegetableUpdateLightingTime(double time); void enableVegetable(bool enable); bool isVegetableActive() const; void loadVegetableTexture(const std::string &textureFileName); void setupVegetableLighting(const CRGBA &ambient, const CRGBA &diffuse, const CVector &directionalLight); void setVegetableWind(const CVector &windDir, float windFreq, float windPower, float windBendMin); uint getNumVegetableFaceRendered() const; void setVegetableUpdateLightingFrequency(float freq); void setupColorsFromTileFlags(const NLMISC::CRGBA colors[4]); // @} // @{ uint8 getLumel(const CPatchIdent &patchId, const CUV &uv) const; void appendTileLightInfluences(const CPatchIdent &patchId, const CUV &uv, std::vector<CPointLightInfluence> &pointLightList) const; // @} // @{ void setPZBModelPosition(const CVector &pos); const CVector &getPZBModelPosition() const {return _PZBModelPosition;} // @} // @{ void updateLighting(double time); void setUpdateLightingFrequency(float freq); void updateLightingAll(); // @} // @{ void computeDynamicLighting(const std::vector<CPointLight*> &pls); uint getDynamicLightingMemoryLoad() const; void setDynamicLightingMaxAttEnd(float maxAttEnd); float getDynamicLightingMaxAttEnd() const {return _DLMMaxAttEnd;} void setDLMGlobalVegetableColor(CRGBA gvc); CRGBA getDLMGlobalVegetableColor() const {return _DLMGlobalVegetableColor;} // @} // ******************************** private: // Private part used by CTessFace / CPatch / CZone. friend class CTessFace; friend class CPatch; friend class CZone; // @{ CBlockMemory<CTessFace> TessFaceAllocator; CBlockMemory<CTessVertex> TessVertexAllocator; CBlockMemory<CTessNearVertex> TessNearVertexAllocator; CBlockMemory<CTessFarVertex> TessFarVertexAllocator; CBlockMemory<CTileMaterial> TileMaterialAllocator; CBlockMemory<CTileFace> TileFaceAllocator; CTessFace *newTessFace(); CTessVertex *newTessVertex(); CTessNearVertex *newTessNearVertex(); CTessFarVertex *newTessFarVertex(); CTileMaterial *newTileMaterial(); CTileFace *newTileFace(); void deleteTessFace(CTessFace *f); void deleteTessVertex(CTessVertex *v); void deleteTessNearVertex(CTessNearVertex *v); void deleteTessFarVertex(CTessFarVertex *v); void deleteTileMaterial(CTileMaterial *tm); void deleteTileFace(CTileFace *tf); // Allocator of FaceVector for allocation of packed triangles indices. CLandscapeFaceVectorManager _FaceVectorManager; // This is not a valid TessBlock. But it is used as a Root for modification list. // Can't use a ptr, because of ~CTessBlock(). CTessBlock _TessBlockModificationRoot; // @} // Return the render pass for a far texture here. CPatchRdrPass *getFarRenderPass(CPatch* pPatch, uint farIndex, float& far1UScale, float& far1VScale, float& far1UBias, float& far1VBias, bool& bRot); // Free the render pass for a far texture here. void freeFarRenderPass (CPatch* pPatch, CPatchRdrPass* pass, uint farIndex); // Return the render pass for a tile Id, and a patch Lightmap. CPatchRdrPass *getTileRenderPass(uint16 tileId, bool additiveRdrPass); // Return the UvScaleBias for a tile Id. uv.z has the scale info. uv.x has the BiasU, and uv.y has the BiasV. // if bitmap type is CTile::alpha, Return also the additionla rot for alpha (else 0). void getTileUvScaleBiasRot(uint16 tileId, CTile::TBitmap bitmapType, CVector &uvScaleBias, uint8 &rotAlpha); // release Far render pass/reset Tile/Far render. Delete also VB, and FaceVectors void resetRenderFarAndDeleteVBFV(); void forceMergeAtTileLevel(); // Update globals value to CTessFace, and lock Buffers if possible. void updateGlobalsAndLockBuffers (const CVector &refineCenter); // lockBuffers(), called by updateGlobalsAndLockBuffers(). void lockBuffers (); // unlockBuffers. This is the END call for updateGlobalsAndLockBuffers(). void unlockBuffers (); // special for ATI. called in render() void synchronizeATIVBHards(); // update TheFaceVector for which the faces may have been modified during refine(), refineAll() etc.... void updateTessBlocksFaceVector(); // System: update UL links, and call _FarRdrPassSet.erase() void eraseFarRenderPassFromSet (CPatchRdrPass* pass); private: TZoneMap Zones; // Parameters. float _TileDistNear; float _Threshold; bool _RefineMode; float _FarTransition; uint _TileMaxSubdivision; // For VertexProgram. true if change has occured in threshold since the last render(). float _VPThresholdChange; // @{ CRefPtr<IDriver> _Driver; CLandscapeVBAllocator _Far0VB; CLandscapeVBAllocator _Far1VB; CLandscapeVBAllocator _TileVB; // True if we can compute Geomorph and Alpha with VertexShader. bool _VertexShaderOk; // For CZone::refreshTesselationGeometry(). bool _RenderMustRefillVB; // @} // Tiles Types. //============= // Texture Map. Use a RefPtr because TileTextureMap must not reference the object, but the ptr. typedef NLMISC::CRefPtr<ITexture> RPTexture; typedef std::map<std::string, RPTexture> TTileTextureMap; typedef TTileTextureMap::iterator ItTileTextureMap; // RdrPass Set. typedef std::set<CPatchRdrPass> TTileRdrPassSet; typedef TTileRdrPassSet::iterator ItTileRdrPassSet; typedef NLMISC::CSmartPtr<CPatchRdrPass> TSPRenderPass; // The additional realtime structure for a tile. struct CTileInfo { // NB: CSmartPtr are not used for simplicity, and because of TTileRdrPassSet... // CPatchRdrPass::RefCount are excplictly incremented/decremented... // The rdrpass for diffuse+Alpha material. CPatchRdrPass *DiffuseRdrPass; // The rdrpass for additive material (may be NULL if no additive part). CPatchRdrPass *AdditiveRdrPass; // The scale/Bias to access those tiles in the big texture. // uv.z has the scale info. uv.x has the BiasU, and uv.y has the BiasV. // Manages the demi-texel on tile border too. CVector DiffuseUvScaleBias; CVector AlphaUvScaleBias; CVector AdditiveUvScaleBias; // The additional rotation for this tile, in alpha. uint8 RotAlpha; }; // Tiles Data. //============= // The map of tile texture loaded. TTileTextureMap TileTextureMap; // The set of tile Rdr Pass. TTileRdrPassSet TileRdrPassSet; // The parrallel array of tile of those existing in TileBank. size of NbTilesMax. std::vector<CTileInfo*> TileInfos; // The Lightmap rdrpass for tiles. // must have a vector of pointer, because of vector reallocation. std::vector<TSPRenderPass> _TextureNears; uint _NFreeLightMaps; // The Tile material. CMaterial TileMaterial; // The Far material. CMaterial FarMaterial; // *** Far texture // ** Some types // The vector of set of far render pass typedef std::set<TSPRenderPass> TSPRenderPassSet; typedef TSPRenderPassSet::iterator ItSPRenderPassSet; typedef std::vector<TSPRenderPassSet> TSPRdrPassSetVector; TSPRenderPassSet _FarRdrPassSet; // Contain all the render pass not empty for pass0 and pass1 TSPRdrPassSetVector _FarRdrPassSetVectorFree; // Contain the render pass not filled yet sorted by size for pass0 and pass1 bool _FarInitialized; // Used internaly by initTileBanks bool eraseTileFarIfNotGood (uint tileNumber, uint sizeOrder0, uint sizeOrder1, uint sizeOrder2); // ** Some private methods static uint getRdrPassIndexWithSize (uint width, uint height); void addPatch (); void removePatch (); // *** Lighting CRGBA _LightValue[256]; bool _AutomaticLighting; CVector _AutomaticLightDir; // The map LightGroupName -> Color. typedef std::map<std::string, NLMISC::CRGBA> TLightGroupColorMap; typedef TLightGroupColorMap::iterator ItLightGroupColorMap; TLightGroupColorMap _LightGroupColorMap; private: // Internal only. Force load of the tile (with TileBank). void loadTile(uint16 tileId); void releaseTile(uint16 tileId); ITexture *findTileTexture(const std::string &textName); CPatchRdrPass *findTileRdrPass(const CPatchRdrPass &pass); // Tile LightMap mgt. NB: a lightmap is now a 2x2 tiles lightmap (10x10 pixels). // @{ // Compute and get a lightmapId/lightmap renderpass. // lightmap returned is to be uses with getTileRenderPass(). The id returned must be stored. uint getTileLightMap(CRGBA map[NL_TILE_LIGHTMAP_SIZE*NL_TILE_LIGHTMAP_SIZE], CPatchRdrPass *&lightmapRdrPass); // tileLightMapId must be the id returned by getTileLightMap(). void getTileLightMapUvInfo(uint tileLightMapId, CVector &uvScaleBias); // tileLightMapId must be the id returned by getTileLightMap(). void releaseTileLightMap(uint tileLightMapId); // refill a lightmap already computed. tileLightMapId must be the id returned by getTileLightMap(). void refillTileLightMap(uint tileLightMapId, CRGBA map[NL_TILE_LIGHTMAP_SIZE*NL_TILE_LIGHTMAP_SIZE]); // @} // check a zone, adding error to exception. void checkZoneBinds(CZone &curZone, EBadBind &bindError); struct CBezierPatchZ { float Vertices[4]; float Tangents[8]; float Interiors[4]; void makeInteriors(); float eval(float s, float t) const; // s,t coordinates for quad. }; // HeightFields. struct CHeightField { std::vector<CBezierPatchZ> ZPatchs; float OriginX, OriginY; float SizeX, SizeY; float OOSizeX, OOSizeY; uint Width, Height; }; CHeightField _HeightField; // @{ // A CPatchIdent, with a ptr to the compiled CPatch struct CPatchIdentEx : public CPatchIdent { const CPatch *Patch; }; CQuadGrid<CPatchIdentEx> _PatchQuadGrid; static const uint _PatchQuadGridSize; static const float _PatchQuadGridEltSize; void addTrianglesInBBox(const CPatchIdentEx &paIdEx, const CAABBox &bbox, std::vector<CTrianglePatch> &triangles, uint8 tileTessLevel) const; void addPatchBlocksInBBox(const CPatchIdentEx &paIdEx, const CAABBox &bbox, std::vector<CPatchBlockIdent> &paBlockIds); // @} // @{ // guess. bool _NoiseEnabled; // @} // @{ CTessFacePriorityList _SplitPriorityList; CTessFacePriorityList _MergePriorityList; CVector _OldRefineCenter; bool _OldRefineCenterSetuped; CTessFacePListNode _RootNewLeaves; // @} // @{ CVegetableManager *_VegetableManager; bool _VegetableManagerEnabled; bool _DriverOkForVegetable; CTessList<CLandscapeVegetableBlock> _VegetableBlockList; const CTileVegetableDesc &getTileVegetableDesc(uint16 tileId); // @} // @{ CVector _PZBModelPosition; // @} // @{ // Last update time. double _ULPrecTime; bool _ULPrecTimeInit; double _ULTime; float _ULFrequency; sint _ULTotalFarPixels; float _ULFarPixelsToUpdate; CTextureFar *_ULRootTextureFar; uint _ULFarCurrentPatchId; sint _ULTotalNearPixels; float _ULNearPixelsToUpdate; CPatch *_ULRootNearPatch; uint _ULNearCurrentTessBlockId; void linkPatchToNearUL(CPatch *patch); void unlinkPatchFromNearUL(CPatch *patch); void updateLightingTextureFar(float ratio); void updateLightingTextureNear(float ratio); // @} // @{ NLMISC::CSmartPtr<ITexture> _TextureDLM; CTextureDLM *getTextureDLM() const {return (CTextureDLM*)(ITexture*)_TextureDLM;} CPatchDLMContextList *_PatchDLMContextList; CPatchDLMContextList *getPatchDLMContextList() const {return _PatchDLMContextList;} float _DLMMaxAttEnd; CRGBA _DLMGlobalVegetableColor; CRGBA _PointLightDiffuseMaterial; // @} }; } // NL3D #endif // NL_LANDSCAPE_H /* End of landscape.h */