nevrax.org : docs

00001 
+00007 /* Copyright, 2000 Nevrax Ltd.
+00008  *
+00009  * This file is part of NEVRAX NEL.
+00010  * NEVRAX NEL is free software; you can redistribute it and/or modify
+00011  * it under the terms of the GNU General Public License as published by
+00012  * the Free Software Foundation; either version 2, or (at your option)
+00013  * any later version.
+00014 
+00015  * NEVRAX NEL is distributed in the hope that it will be useful, but
+00016  * WITHOUT ANY WARRANTY; without even the implied warranty of
+00017  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+00018  * General Public License for more details.
+00019 
+00020  * You should have received a copy of the GNU General Public License
+00021  * along with NEVRAX NEL; see the file COPYING. If not, write to the
+00022  * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+00023  * MA 02111-1307, USA.
+00024  */
+00025 
+00026 #ifndef NL_LANDSCAPE_H
+00027 #define NL_LANDSCAPE_H
+00028 
+00029 
+00030 #include "nel/misc/types_nl.h"
+00031 #include "nel/misc/class_id.h"
+00032 #include "nel/misc/smart_ptr.h"
+00033 #include "nel/misc/triangle.h"
+00034 #include "nel/3d/zone.h"
+00035 #include "nel/3d/tile_bank.h"
+00036 #include "nel/3d/patch_rdr_pass.h"
+00037 #include "nel/3d/vertex_buffer.h"
+00038 #include "nel/3d/primitive_block.h"
+00039 #include "nel/3d/material.h"
+00040 #include "nel/3d/tile_far_bank.h"
+00041 #include "nel/3d/texture_near.h"
+00042 #include <map>
+00043 
+00044 #define NL_MAX_SIZE_OF_TEXTURE_EDGE_SHIFT (NL_MAX_TILES_BY_PATCH_EDGE_SHIFT+NL_NUM_PIXELS_ON_FAR_TILE_EDGE_SHIFT)
+00045 #define NL_MAX_SIZE_OF_TEXTURE_EDGE (1<<NL_MAX_SIZE_OF_TEXTURE_EDGE_SHIFT)              // Size max of a far texture edge in pixel
+00046 
+00047 
+00048 namespace NL3D 
+00049 {
+00050 
+00051 
+00052 class   CHeightMap;
+00053 
+00054 
+00055 // ***************************************************************************
+00056 // The maximum amount of different tiles in world.
+00057 const   sint    NbTilesMax= 65536;
+00058 // Size of a CTextureNear. 256 by default (works everywhere).
+00059 // Texures must be square, because of uvscalebias...
+00060 const   sint    TextureNearSize= 256;
+00061 const   sint    NbTilesByLine= TextureNearSize/NL_TILE_LIGHTMAP_SIZE;
+00062 const   sint    NbTilesByTexture= NbTilesByLine*NbTilesByLine;
+00063 
+00064 
+00065 
+00066 // ***************************************************************************
+00073 struct EBadBind : public Exception
+00074 {
+00075 private:
+00076         mutable std::string             _Output;
+00077 
+00078 public:
+00079         struct  CBindError
+00080         {
+00081                 CBindError(sint z, sint p) {ZoneId= z; PatchId= p;}
+00082                 sint    ZoneId;
+00083                 sint    PatchId;
+00084         };
+00085 
+00086 
+00087         // The result list of bind errors.
+00088         std::list<CBindError>   BindErrors;
+00089 
+00090 public:
+00091         EBadBind() : Exception( "Landscape Bind Error in (3DSMax indices!! (+1) ): " ) {}
+00092         virtual const char      *what() const throw();
+00093 
+00094 };
+00095 
+00096 
+00097 
+00098 // ***************************************************************************
+00119 class CLandscape : public NLMISC::CRefCount
+00120 {
+00121 public:
+00122         // The bank of tiles information.
+00123         CTileBank               TileBank;
+00124         CTileFarBank    TileFarBank;
+00125 
+00126 public:
+00127 
+00129         CLandscape();
+00131         ~CLandscape();
+00132 
+00133 
+00135         // @{
+00137         void                    init();
+00138 
+00144         bool                    addZone(const CZone     &newZone);
+00145         
+00151         bool                    removeZone(uint16 zoneId);
+00152         
+00154         void                    clear();
+00155 
+00157         void                    checkBinds() throw(EBadBind);
+00159         void                    checkBinds(uint16 zoneId) throw(EBadBind);
+00160 
+00166         bool                    initTileBanks ();
+00167         // @}
+00168 
+00169         
+00171         // @{
+00173         void                    setTileNear (float tileNear);
+00175         float                   getTileNear () const    {return _TileDistNear;}
+00177         void                    setThreshold (float thre)       {_Threshold= thre;}
+00179         float                   getThreshold () const   {return _Threshold;}
+00180         void                    setRefineMode(bool enabled) {_RefineMode= enabled;}
+00181         bool                    getRefineMode() const {return _RefineMode;}
+00183         void                    setTileMaxSubdivision (uint tileDiv);
+00185         uint                    getTileMaxSubdivision ();
+00186 
+00187         // TODO: other landscape param setup (Transition etc...).
+00188         // Store it by landscape, and not only globally in CTessFace statics.
+00189         // @}
+00190 
+00191 
+00193         // @{
+00197         void                    clip(const CVector &refineCenter, const std::vector<CPlane>     &pyramid);
+00199         void                    refine(const CVector &refineCenter);
+00201         void                    render(IDriver *drv, const CVector &refineCenter, const std::vector<CPlane>     &pyramid, bool doTileAddPass=false);
+00203         void                    refineAll(const CVector &refineCenter);
+00204         // @}
+00205 
+00206 
+00208         // @{
+00216         void                    buildCollideFaces(const CAABBoxExt &bbox, std::vector<CTriangle> &faces, bool faceSplit);
+00220         void                    buildCollideFaces(sint zoneId, sint patch, std::vector<CTriangle> &faces);
+00221         // @}
+00222 
+00223 
+00224 
+00226         // @{
+00232         CZone*                  getZone (sint zoneId);
+00238         const CZone*    getZone (sint zoneId) const;
+00239         // @}
+00240 
+00241 
+00243         // @{
+00245         void                    flushTiles(IDriver *drv, uint16 tileStart, uint16 nbTiles);
+00247         void                    releaseTiles(uint16 tileStart, uint16 nbTiles);
+00248 
+00250         NLMISC::CSmartPtr<ITexture>             getTileTexture(uint16 tileId, CTile::TBitmap bitmapType, CVector &uvScaleBias);
+00251         // @}
+00252 
+00254         // @{
+00262         void setupStaticLight (const CRGBA &diffuse, const CRGBA &ambiant, float multiply);
+00268         const CRGBA* getStaticLight () const
+00269         {
+00270                 return _LightValue;
+00271         }
+00272         // @}
+00273 
+00274 
+00276         // @{
+00278         CVector         getHeightFieldDeltaZ(float x, float y) const;
+00284         void            setHeightField(const CHeightMap &hf);
+00285         // @}
+00286 
+00287 
+00288 
+00289 // ********************************
+00290 private:
+00291         // Private part used by CPatch.
+00292         friend class    CPatch;
+00293         friend class    CZone;
+00294 
+00295         // Return the render pass for a far texture here.
+00296         CPatchRdrPass   *getFarRenderPass(CPatch* pPatch, uint farIndex, float& far1UScale, float& far1VScale, float& far1UBias, float& far1VBias, bool& bRot);
+00297         // Free the render pass for a far texture here.
+00298         void freeFarRenderPass (CPatch* pPatch, CPatchRdrPass* pass, uint farIndex);
+00299         // Return the render pass for a tile Id, and a patch Lightmap.
+00300         CPatchRdrPass   *getTileRenderPass(uint16 tileId, bool additiveRdrPass);
+00301         // Return the UvScaleBias for a tile Id. uv.z has the scale info. uv.x has the BiasU, and uv.y has the BiasV.
+00302         // if bitmap type is CTile::alpha, Return also the additionla rot for alpha (else 0).
+00303         void                    getTileUvScaleBiasRot(uint16 tileId, CTile::TBitmap bitmapType, CVector &uvScaleBias, uint8 &rotAlpha);
+00304 
+00305         // release Far render pass/reset Tile/Far render.
+00306         void                    resetRenderFar();
+00308         void                    forceMergeAtTileLevel();
+00309 
+00310         // Update globals value to CTessFace
+00311         void updateGlobals (const CVector &refineCenter) const;
+00312 
+00313 private:
+00314         TZoneMap                Zones;
+00315 
+00316         // Parameters.
+00317         float                   _TileDistNear;
+00318         float                   _Threshold;
+00319         bool                    _RefineMode;
+00320         float                   _FarTransition;
+00321         uint                    _TileMaxSubdivision;
+00322 
+00323         // The temp VB for tiles and far passes.
+00324         CVertexBuffer   FarVB;
+00325         CVertexBuffer   TileVB;
+00326 
+00327 
+00328         // Tiles Types.
+00329         //=============
+00330         // Texture Map. Use a RefPtr because TileTextureMap must not reference the object, but the ptr.
+00331         typedef NLMISC::CRefPtr<ITexture>                       RPTexture;
+00332         typedef std::map<std::string, RPTexture>        TTileTextureMap;
+00333         typedef TTileTextureMap::iterator                       ItTileTextureMap;
+00334         // RdrPass Set.
+00335         typedef std::set<CPatchRdrPass>                         TTileRdrPassSet;
+00336         typedef TTileRdrPassSet::iterator                       ItTileRdrPassSet;
+00337         typedef NLMISC::CSmartPtr<CPatchRdrPass>        TSPRenderPass;
+00338 
+00339         // The additional realtime structure for a tile.
+00340         struct  CTileInfo
+00341         {
+00342                 // NB: CSmartPtr are not used for simplicity, and because of TTileRdrPassSet...
+00343                 // CPatchRdrPass::RefCount are excplictly incremented/decremented...
+00344                 // The rdrpass for diffuse+Alpha material.
+00345                 CPatchRdrPass   *DiffuseRdrPass;
+00346                 // The rdrpass for additive material (may be NULL if no additive part).
+00347                 CPatchRdrPass   *AdditiveRdrPass;
+00348                 // The scale/Bias to access those tiles in the big texture.
+00349                 // uv.z has the scale info. uv.x has the BiasU, and uv.y has the BiasV.
+00350                 // Manages the demi-texel on tile border too.
+00351                 CVector                 DiffuseUvScaleBias;
+00352                 CVector                 AlphaUvScaleBias;
+00353                 CVector                 AdditiveUvScaleBias;
+00354                 // The additional rotation for this tile, in alpha.
+00355                 uint8                   RotAlpha;
+00356         };
+00357 
+00358 
+00359         // Tiles Data.
+00360         //=============
+00361         // The map of tile texture loaded.
+00362         TTileTextureMap                         TileTextureMap;
+00363         // The set of tile Rdr Pass.
+00364         TTileRdrPassSet                         TileRdrPassSet;
+00365         // The parrallel array of tile of those existing in TileBank. size of NbTilesMax.
+00366         std::vector<CTileInfo*>         TileInfos;
+00367         // The Lightmap rdrpass for tiles.
+00368         // must have a vector of pointer, because of vector reallocation.
+00369         std::vector<TSPRenderPass>              _TextureNears;
+00370         uint                                                    _NFreeLightMaps;
+00371 
+00372 
+00373         // The Tile material.
+00374         CMaterial               TileMaterial;
+00375 
+00376         // The Far material.
+00377         CMaterial               FarMaterial;
+00378 
+00379 
+00380         // *** Far texture      
+00381 
+00382         // ** Some types
+00383 
+00384         // The vector of set of far render pass
+00385         typedef std::set<TSPRenderPass>                         TSPRenderPassSet;
+00386         typedef TSPRenderPassSet::iterator                      ItSPRenderPassSet;
+00387         typedef std::vector<TSPRenderPassSet>           TSPRdrPassSetVector;
+00388         TSPRenderPassSet                                                        _FarRdrPassSet;                                 // Contain all the render pass not empty for pass0 and pass1
+00389         TSPRdrPassSetVector                                                     _FarRdrPassSetVectorFree;               // Contain the render pass not filled yet sorted by size for pass0 and pass1
+00390         bool                                                                            _FarInitialized;
+00391 
+00392         // Used internaly by initTileBanks
+00393         bool                                                                            eraseTileFarIfNotGood (uint tileNumber, uint sizeOrder0, uint sizeOrder1, uint sizeOrder2);
+00394 
+00395         // ** Some private methods
+00396         static uint                                                                     getRdrPassIndexWithSize (uint width, uint height);
+00397         void                                                                            addPatch ();
+00398         void                                                                            removePatch ();
+00399 
+00400 
+00401         // *** Lighting
+00402         CRGBA                   _LightValue[256];
+00403 
+00404 private:
+00405         // Internal only. Force load of the tile (with TileBank).
+00406         void                    loadTile(uint16 tileId);
+00407         void                    releaseTile(uint16 tileId);
+00408         ITexture                *findTileTexture(const std::string &textName);
+00409         CPatchRdrPass   *findTileRdrPass(const CPatchRdrPass &pass);
+00410 
+00411         // Tile LightMap mgt.
+00412         // @{
+00413         // Compute and get a lightmapId/lightmap renderpass.
+00414         // lightmap returned is to be uses with getTileRenderPass(). The id returned must be stored.
+00415         uint            getTileLightMap(CRGBA  map[NL_TILE_LIGHTMAP_SIZE*NL_TILE_LIGHTMAP_SIZE], CPatchRdrPass *&lightmapRdrPass);
+00416         // tileLightMapId must be the id returned  by getTileLightMap().
+00417         void            getTileLightMapUvInfo(uint tileLightMapId, CVector &uvScaleBias);
+00418         // tileLightMapId must be the id returned  by getTileLightMap().
+00419         void            releaseTileLightMap(uint tileLightMapId);
+00420         // @}
+00421 
+00422 
+00423         // check a zone, adding error to exception.
+00424         void                    checkZoneBinds(CZone &curZone, EBadBind &bindError);
+00425 
+00426 
+00430         struct  CBezierPatchZ
+00431         {
+00433                 float           Vertices[4];            
+00435                 float           Tangents[8];            
+00437                 float           Interiors[4];           
+00438 
+00440                 void            makeInteriors();
+00442                 float           eval(float s, float t) const;                   // s,t coordinates for quad.
+00443         };
+00444 
+00445 
+00446         // HeightFields.
+00447         struct  CHeightField
+00448         {
+00449                 std::vector<CBezierPatchZ>              ZPatchs;
+00450 
+00452                 float                   OriginX, OriginY;
+00454                 float                   SizeX, SizeY;
+00455                 float                   OOSizeX, OOSizeY;
+00457                 uint                    Width, Height;
+00458         };
+00459         CHeightField    _HeightField;
+00460 
+00461 };
+00462 
+00463 
+00464 
+00465 } // NL3D
+00466 
+00467 
+00468 #endif // NL_LANDSCAPE_H
+00469 
+00470 /* End of landscape.h */
+