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_ZONE_H
+00027 #define NL_ZONE_H
+00028 
+00029 #include "nel/misc/types_nl.h"
+00030 #include "nel/misc/smart_ptr.h"
+00031 #include "nel/misc/stream.h"
+00032 #include "nel/misc/debug.h"
+00033 #include "3d/tessellation.h"
+00034 #include "3d/patch.h"
+00035 #include "3d/bezier_patch.h"
+00036 #include "3d/point_light_named.h"
+00037 #include "3d/point_light_named_array.h"
+00038 #include <stdio.h>
+00039 #include <vector>
+00040 #include <map>
+00041 
+00042 
+00043 namespace NL3D 
+00044 {
+00045 
+00046 
+00047 class CZone;
+00048 class CLandscape;
+00049 
+00050 using NLMISC::CAABBoxExt;
+00051 
+00052 
+00053 // ***************************************************************************
+00054 typedef std::map<uint16, CZone*>                        TZoneMap;
+00055 typedef std::map<uint16, CZone*>::iterator      ItZoneMap;
+00056 
+00057 
+00058 // ***************************************************************************
+00062 struct  CBorderVertex
+00063 {
+00064         // The index of vertex in the current zone to bind.
+00065         uint16                  CurrentVertex;
+00066         // The neighbor zone Id.
+00067         uint16                  NeighborZoneId;
+00068         // The index of vertex in the neighbor zone to bind to CurrentVertex.
+00069         uint16                  NeighborVertex;
+00070 
+00071         void                    serial(NLMISC::IStream &f);
+00072 };
+00073 
+00074 
+00075 // ***************************************************************************
+00083 struct  CPatchInfo
+00084 {
+00085 public:
+00086 
+00092         struct  CBindInfo
+00093         {
+00098                 uint8                   NPatchs;
+00099 
+00101                 uint16                  ZoneId;
+00103                 uint16                  Next[4];
+00105                 uint8                   Edge[4];
+00106 
+00107         public:
+00108                 void                    serial(NLMISC::IStream &f);
+00109                 CBindInfo() {NPatchs=0;}
+00110         };
+00111 
+00112         
+00113 public:
+00115         // @{
+00117         CBezierPatch    Patch;
+00119         uint8                   OrderS, OrderT;
+00121         float                   ErrorSize;
+00123         uint16                  BaseVertices[4];
+00124 
+00127         uint8                   Flags;
+00128 
+00129 
+00131         uint8                   NoiseRotation;
+00132 
+00134         void                    setCornerSmoothFlag(uint corner, bool smooth);
+00135         bool                    getCornerSmoothFlag(uint corner) const;
+00136 
+00137         // @}
+00138 
+00139 
+00141         // @{
+00142 
+00146         std::vector<CTileElement>       Tiles;
+00147 
+00152         std::vector<CTileColor>         TileColors;
+00153 
+00158         std::vector<uint8>                      Lumels;
+00159 
+00168         std::vector<CTileLightInfluence>                TileLightInfluences;
+00169 
+00170         // @}
+00171 
+00173 
+00177         void setSmoothFlag (uint edge, bool flag)
+00178         {
+00179                 // Erase it
+00180                 Flags&=~(1<<edge);
+00181                 
+00182                 // Set it
+00183                 Flags|=(((uint)flag)<<edge);
+00184         }
+00185 
+00189         bool getSmoothFlag (uint edge)
+00190         {
+00191                 // Test it
+00192                 return ((Flags&(1<<edge))!=0);
+00193         }
+00194 
+00196         // @{
+00197         CBindInfo               BindEdges[4];
+00198         // @}
+00199 
+00200 
+00201 public:
+00202         CPatchInfo()
+00203         {
+00204                 ErrorSize= 0;
+00205                 // No Rotation / not smooth by default.
+00206                 NoiseRotation= 0;
+00207                 _CornerSmoothFlag= 0;
+00208         }
+00209 
+00210 private:
+00211         // Noise Smooth flags.
+00212         uint8                   _CornerSmoothFlag;
+00213 
+00214 };
+00215 
+00216 
+00217 // ***************************************************************************
+00225 struct  CZoneInfo
+00226 {
+00228         uint16                                          ZoneId;
+00230         std::vector<CPatchInfo>         Patchs;
+00235         std::vector<CBorderVertex>      BorderVertices;
+00236 
+00240         std::vector<CPointLightNamed>   PointLights;
+00241 };
+00242 
+00243 
+00244 // ***************************************************************************
+00258 class CZone
+00259 {
+00260 public:
+00261         // The stored patch structure for compile() - ation.
+00262         struct  CPatchConnect
+00263         {
+00264                 // NB: same meanings than in CPatchInfo.
+00265                 uint8                   OldOrderS, OldOrderT;
+00266                 float                   ErrorSize;
+00267                 uint16                  BaseVertices[4];
+00268                 CPatchInfo::CBindInfo           BindEdges[4];
+00269 
+00270         public:
+00271                 void                    serial(NLMISC::IStream &f);
+00272         };
+00273 
+00274 public:
+00275 
+00277         CZone();
+00279         ~CZone();
+00280 
+00281 
+00293         void                    build(const CZoneInfo &zoneInfo, uint32 numVertices=0);
+00294 
+00295 
+00299         void                    build(uint16 zoneId, const std::vector<CPatchInfo> &patchs, const std::vector<CBorderVertex> &borderVertices, uint32 numVertices=0);
+00300 
+00301 
+00307         void                    build(const CZone &zone);
+00308 
+00309 
+00316         void                    retrieve(CZoneInfo &zoneInfo);
+00317 
+00318 
+00322         void                    retrieve(std::vector<CPatchInfo> &patchs, std::vector<CBorderVertex> &borderVertices);
+00323 
+00324 
+00325 
+00329         void                    debugBinds(FILE *f= stdout);
+00330 
+00331 
+00344         void                    compile(CLandscape *landscape, TZoneMap &loadedZones);
+00345 
+00356         void                    release(TZoneMap &loadedZones);
+00357 
+00358 
+00362         void                    serial(NLMISC::IStream &f);
+00363 
+00364 
+00372         void                    changePatchTextureAndColor (sint numPatch, const std::vector<CTileElement> *tiles, const std::vector<CTileColor> *colors);
+00373 
+00374 
+00386         void                    refreshTesselationGeometry(sint numPatch);
+00387 
+00388 
+00397         const std::vector<CTileElement> &getPatchTexture(sint numPatch) const;
+00398 
+00407         const std::vector<CTileColor> &getPatchColor(sint numPatch) const;
+00408 
+00414         CLandscape*             getLandscape () const
+00415         {
+00416                 return Landscape;
+00417         }
+00418 
+00419         // NB: for all those function, CTessFace static rendering context must be setup.
+00421         void                    clip(const std::vector<CPlane>  &pyramid);
+00423         void                    preRender();
+00424         // release Far render pass/reset Tile/Far render. Delete also VB, and FaceVectors
+00425         void                    resetRenderFarAndDeleteVBFV();
+00427         void                    forceMergeAtTileLevel();
+00428 
+00430         void                    refineAll();
+00432         void                    excludePatchFromRefineAll(uint patch, bool exclude);
+00435         void                    averageTesselationVertices();
+00436 
+00437         // Accessors.
+00438         const CVector   &getPatchBias() const {return PatchBias;}
+00439         float                   getPatchScale() const {return PatchScale;}
+00440         bool                    compiled() const {return Compiled;}
+00441         uint16                  getZoneId() const {return ZoneId;}
+00442         sint                    getNumPatchs() const {return Patchs.size();}
+00443         // Return the Bounding Box of the zone.
+00444         const CAABBoxExt        &getZoneBB() const {return ZoneBB;}
+00445 
+00452         const CPatch    *getPatch(sint patch) const {nlassert(patch>=0 && patch<(sint)Patchs.size()); return &(Patchs[patch]);}
+00453 
+00460         const CPatchConnect     *getPatchConnect(sint patch) const 
+00461                 {nlassert(patch>=0 && patch<(sint)Patchs.size()); return &(PatchConnects[patch]);}
+00462 
+00463 
+00468         void                    applyHeightField(const CLandscape &landScape);
+00469 
+00478         void setupColorsFromTileFlags(const NLMISC::CRGBA colors[4]);
+00479         
+00483         void copyTilesFlags(sint destPatchId, const CPatch *srcPatch);
+00484 
+00485 // Private part.
+00486 private:
+00487 /*********************************/
+00488         // A smartptrisable vertex.
+00489         struct  CTessBaseVertex : public NLMISC::CRefCount
+00490         {
+00491                 CTessVertex             Vert;
+00492         };
+00493 
+00494         // Zone vertices.
+00495         typedef NLMISC::CSmartPtr<CTessBaseVertex>      PBaseVertex;
+00496         typedef std::vector<PBaseVertex>                        TBaseVerticesVec;
+00497 
+00498 
+00499 private:
+00500         // The lanscape which own this zone. Usefull for texture management.
+00501         // Filled at compilation only.
+00502         CLandscape              *Landscape;
+00503 
+00504         // Misc.
+00505         uint16                  ZoneId;
+00506         bool                    Compiled;
+00507         CAABBoxExt              ZoneBB;
+00508         CVector                 PatchBias;
+00509         float                   PatchScale;
+00510 
+00511         // The number of vertices she access (maybe on border).
+00512         sint32                          NumVertices;
+00513         // The smartptr on zone vertices.
+00514         TBaseVerticesVec        BaseVertices;
+00515         // The list of border vertices.
+00516         std::vector<CBorderVertex>      BorderVertices;
+00517         // NB: No problem on corners, since zones are compile()-ed with knowledge of neighbors.
+00518 
+00519         // The patchs.
+00520         std::vector<CPatch>                     Patchs;
+00521         std::vector<CPatchConnect>      PatchConnects;
+00522 
+00525         CPointLightNamedArray                   _PointLightArray;
+00526 
+00527         
+00528 private:
+00529         friend  class CLandscape;
+00530         friend  class CTessFace;
+00531         // Should do this, for texture mgt.
+00532         friend  class CPatch;
+00533 
+00534         sint                    ClipResult;
+00535         enum    TClipResult {ClipIn= 0, ClipOut= 1, ClipSide= 2};
+00536 
+00537 
+00538 private:
+00543         void                    rebindBorder(TZoneMap &loadedZones);
+00544 
+00545         PBaseVertex             getBaseVertex(sint vert) const {return BaseVertices[vert];}
+00546         CPatch                  *getPatch(sint patch) {nlassert(patch>=0 && patch<(sint)Patchs.size()); return &(Patchs[patch]);}
+00547         static CPatch   *getZonePatch(TZoneMap &loadedZones, sint zoneId, sint patch);
+00548         // Bind the patch with ones which are loaded...
+00549         static void             unbindPatch(CPatch &pa);
+00550         static void             bindPatch(TZoneMap &loadedZones, CPatch &pa, CPatchConnect &pc, bool rebind);
+00551         // Is the patch on a border of this zone???
+00552         bool                    patchOnBorder(const CPatchConnect &pc) const;
+00553 
+00554         // compute AABBox, PatchBias and PatchScale, from a bbox.
+00555         void                    computeBBScaleBias(const CAABBox        &bb);
+00556 
+00557 
+00558         // For CPatch: build a bindInfo.
+00559         void                    buildBindInfo(uint patchId, uint edge, CZone *neighborZone, CPatch::CBindInfo   &paBind);
+00560 
+00561 };
+00562 
+00563 
+00564 } // NL3D
+00565 
+00566 
+00567 #endif // NL_ZONE_H
+00568 
+00569 /* End of zone.h */
+