nel/tools/pacs/build_rbank/prim_checker.h

   1 // NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This program is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU Affero General Public License as
   6 // published by the Free Software Foundation, either version 3 of the
   7 // License, or (at your option) any later version.
   8 //
   9 // This program is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU Affero General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU Affero General Public License
  15 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 #ifndef NL_PRIM_CHECKER_H
  18 #define NL_PRIM_CHECKER_H
  19
  20 #include "nel/misc/types_nl.h"
  21 #include "nel/misc/stream.h"
  22
  23 #include <nel/misc/polygon.h>
  24
  25 namespace NLMISC
  26 {
  27         class CVectorD;
  28 };
  29
  30 namespace NLLIGO
  31 {
  32         class IPrimitive;
  33         class CPrimZone;
  34 };
  35
  36 /**
  37  * A class that reads .primitive files from ligo and that allows
  38  * to define flags over pacs surfaces with CPrimZone
  39  * \author Benjamin Legros
  40  * \author Nevrax France
  41  * \date 2003
  42  */
  43 class CPrimChecker
  44 {
  45 public:
  46
  47         /// Constructor
  48         CPrimChecker();
  49
  50
  51         /// Bits value for landscape
  52         enum
  53         {
  54                 Include = 1,
  55                 Exclude = 2,
  56                 ClusterHint = 4,
  57                 Water = 8,
  58                 Cliff = 16
  59         };
  60
  61
  62         /// Init CPrimChecker
  63         bool    build(const std::string &primitivesPath, const std::string &igLandPath, const std::string &igVillagePath, const std::string &outputDirectory = "./", bool forceRebuild = false);
  64
  65         /// load CPrimChecker state
  66         bool    load(const std::string &outputDirectory = "./");
  67
  68         /// Reads bits value at a given position
  69         uint8   get(uint x, uint y)     const   { return _Grid.get(x, y); }
  70
  71         /// Reads bits value at a given position
  72         uint16  index(uint x, uint y) const     { return _Grid.index(x, y); }
  73
  74         /// Gete water height
  75         float   waterHeight(uint index, bool &exists) const
  76         {
  77                 if (index >= _WaterHeight.size())
  78                 {
  79                         exists = false;
  80                         return 0.0;
  81                 }
  82                 exists = true;
  83                 return _WaterHeight[index];
  84         }
  85
  86         /// Render a CPolygon of bit value
  87         void    renderBits(const NLMISC::CPolygon &poly, uint8 bits);
  88
  89 private:
  90
  91         /// \name Grid management
  92         //@{
  93
  94         /**
  95          * A class that allows to store 65536x65536 elements with minimum allocation and dynamic allocation of elements
  96          */
  97         class CGrid
  98         {
  99         public:
 100
 101                 /// Constructor
 102                 CGrid()         { clear(); }
 103
 104                 /// Set bits in grid
 105                 void    set(uint x, uint y, uint8 bits)
 106                 {
 107                         CGridCell       *cell = _Grid[((x&0xff00)>>8) + (y&0xff00)];
 108                         if (cell == NULL)
 109                         {
 110                                 cell = new CGridCell();
 111                                 _Grid[((x&0xff00)>>8) + (y&0xff00)] = cell;
 112                         }
 113                         cell->set(x, y, bits);
 114                 }
 115
 116                 /// Get bits in grid
 117                 uint8   get(uint x, uint y) const
 118                 {
 119                         CGridCell       *cell = _Grid[((x&0xff00)>>8) + (y&0xff00)];
 120                         return cell != NULL ? cell->get(x, y) : (uint8)0;
 121                 }
 122
 123                 /// Set bits in grid
 124                 void    index(uint x, uint y, uint16 idx)
 125                 {
 126                         CGridCell       *cell = _Grid[((x&0xff00)>>8) + (y&0xff00)];
 127                         if (cell == NULL)
 128                         {
 129                                 cell = new CGridCell();
 130                                 _Grid[((x&0xff00)>>8) + (y&0xff00)] = cell;
 131                         }
 132                         cell->index(x, y, idx);
 133                 }
 134
 135                 /// Get bits in grid
 136                 uint16  index(uint x, uint y) const
 137                 {
 138                         CGridCell       *cell = _Grid[((x&0xff00)>>8) + (y&0xff00)];
 139                         return cell != NULL ? cell->index(x, y) : (uint16)0;
 140                 }
 141
 142
 143                 /// Clear grid
 144                 void    clear()
 145                 {
 146                         for (uint i=0; i<256*256; ++i)
 147                                 if (_Grid != NULL)
 148                                 {
 149                                         delete _Grid[i];
 150                                         _Grid[i] = NULL;
 151                                 }
 152                 }
 153
 154                 /// Serializes
 155                 void    serial(NLMISC::IStream &f)
 156                 {
 157                         f.serialCheck(NELID("PCHK"));
 158                         f.serialVersion(0);
 159
 160                         if (f.isReading())
 161                                 clear();
 162
 163                         for (uint i=0; i<256*256; ++i)
 164                         {
 165                                 bool    present = (_Grid[i] != NULL);
 166                                 f.serial(present);
 167
 168                                 if (present)
 169                                 {
 170                                         if (_Grid[i] == NULL)
 171                                                 _Grid[i] = new CGridCell();
 172                                         _Grid[i]->serial(f);
 173                                 }
 174                         }
 175                 }
 176
 177         private:
 178
 179                 /**
 180                  * A class that allows to store 256x256 elements
 181                  */
 182                 class CGridCell
 183                 {
 184                         class CGridElm
 185                         {
 186                                 uint16          _Value;
 187
 188                         public:
 189
 190                                 CGridElm() : _Value(0)  {}
 191
 192                                 uint8           flags() const                                           { return (uint8)((_Value >> 11) & 0x1f); }
 193                                 void            flags(uint8 bits)                                       { _Value |= (((uint16)bits) << 11); }
 194                                 uint16          index() const                                           { return _Value & 0x07ff; }
 195                                 void            index(uint16 idx)                                       { _Value = ((idx & 0x07ff) | (_Value & 0xf800)); }
 196
 197                                 void            serial(NLMISC::IStream &f)                      { f.serial(_Value); }
 198                         };
 199
 200                 public:
 201
 202                         /// Constructor
 203                         CGridCell()     {}
 204
 205                         /// Set bits in grid
 206                         void    set(uint x, uint y, uint8 bits)         { _Grid[(x&0xff) + ((y&0xff)<<8)].flags(bits); }
 207
 208                         /// Get bits in grid
 209                         uint8   get(uint x, uint y) const                       { return _Grid[(x&0xff) + ((y&0xff)<<8)].flags(); }
 210
 211
 212                         ///
 213                         uint16  index(uint x, uint y)                           { return _Grid[(x&0xff) + ((y&0xff)<<8)].index(); }
 214                         ///
 215                         void    index(uint x, uint y, uint idx)         { _Grid[(x&0xff) + ((y&0xff)<<8)].index(idx); }
 216
 217
 218                         /// Serializes
 219                         void    serial(NLMISC::IStream &f)                      { for (uint i=0; i<256*256; ++i) f.serial(_Grid[i]); }
 220
 221                 private:
 222                         CGridElm        _Grid[256*256];
 223                 };
 224
 225                 CGridCell               *_Grid[256*256];
 226         };
 227
 228         CGrid                           _Grid;
 229
 230         std::vector<float>      _WaterHeight;
 231
 232         //@}
 233
 234
 235
 236         /// Reads a primitive file and renders contained primitives into grid
 237         void    readFile(const std::string &filename);
 238
 239         /// Reads a primitive and its sub primitives
 240         void    readPrimitive(NLLIGO::IPrimitive *primitive);
 241
 242         /// Renders a primitive
 243         void    render(NLLIGO::CPrimZone *zone, uint8 bits);
 244
 245         /// Render a water shape, as a CPolygon
 246         void    render(const NLMISC::CPolygon &poly, uint16 value);
 247 };
 248
 249
 250 #endif // NL_PRIM_CHECKER_H
 251
 252 /* End of prim_checker.h */