ryzom/server/src/server_share/light_ig_loader.cpp

   1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
   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
  18
  19 // pch
  20 #include "stdpch.h"
  21
  22 //
  23 #include "light_ig_loader.h"
  24
  25
  26 // misc
  27 #include <nel/misc/vector_2f.h>
  28 #include <nel/misc/object_vector.h>
  29 #include <nel/misc/rgba.h>
  30 #include <nel/misc/plane.h>
  31 #include <nel/misc/aabbox.h>
  32
  33
  34 using namespace std;
  35 using namespace NLMISC;
  36
  37
  38
  39
  40 //
  41 #define SERIAL_DUMMY(type)      { type  dummy; _File.serial(dummy); }
  42
  43 struct  CCellCorner
  44 {
  45         enum { NumLightPerCorner = 2 };
  46
  47         uint8   SunContribution;
  48         uint8   Light[NumLightPerCorner];
  49         uint8   LocalAmbientId;
  50
  51         void            serial(NLMISC::IStream &f)
  52         {
  53                 uint    ver= f.serialVersion(1);
  54                 nlassert(NumLightPerCorner==2);
  55
  56                 if(ver>=1)
  57                         f.serial(LocalAmbientId);
  58                 f.serial(SunContribution);
  59                 f.serial(Light[0]);
  60                 f.serial(Light[1]);
  61         }
  62 };
  63
  64 class CSurfaceLightGrid
  65 {
  66 public:
  67         NLMISC::CVector2f                                       Origin;
  68         uint32                                                          Width;
  69         uint32                                                          Height;
  70         NLMISC::CObjectVector<CCellCorner>      Cells;
  71
  72 public:
  73
  74         void            serial(NLMISC::IStream &f)
  75         {
  76                 (void)f.serialVersion(0);
  77                 f.serial(Origin);
  78                 f.serial(Width);
  79                 f.serial(Height);
  80                 f.serial(Cells);
  81         }
  82 };
  83
  84 class CRetrieverLightGrid
  85 {
  86 public:
  87         //NLMISC::CObjectVector<CSurfaceLightGrid>      Grids;
  88
  89 public:
  90
  91         void            serial(NLMISC::IStream &_File)
  92         {
  93                 (void)_File.serialVersion(0);
  94                 SERIAL_DUMMY(NLMISC::CObjectVector<CSurfaceLightGrid>);
  95         }
  96 };
  97
  98
  99
 100
 101
 102 /*
 103  * Constructor
 104  */
 105 CLightIGLoader::CLightIGLoader()
 106 {
 107 }
 108
 109
 110 // Load IG
 111 void    CLightIGLoader::loadIG(const string &filename)
 112 {
 113         _File.open(CPath::lookup(filename));
 114
 115
 116         // Serial a header
 117         _File.serialCheck (NELID("TPRG"));
 118
 119         // Serial a version number
 120         sint version = _File.serialVersion (5);
 121
 122
 123         // _RealTimeSunContribution
 124         if (version >= 5)
 125         {
 126                 SERIAL_DUMMY(bool);             // _RealTimeSunContribution
 127         }
 128
 129
 130         // Serial the IGSurfaceLight
 131         if (version >= 4)
 132         {
 133                 sint    ver = _File.serialVersion(1);
 134
 135                 SERIAL_DUMMY(float);    // _CellSize
 136                 SERIAL_DUMMY(float);    // _OOCellSize
 137
 138                 if(ver<1)
 139                 {
 140                         std::map<std::string, CRetrieverLightGrid>              _RetrieverGridMap;
 141                         _File.serialCont(_RetrieverGridMap);
 142                 }
 143                 else
 144                 {
 145                         std::map<uint32, CRetrieverLightGrid>                   _RetrieverGridMap;
 146                         _File.serialCont(_RetrieverGridMap);
 147                 }
 148         }
 149
 150
 151         // Serial the PointLights info
 152         if (version >= 3)
 153         {
 154                 sint ver = _File.serialVersion(1);
 155
 156                 // _PointLights
 157                 uint32  num;
 158                 _File.serial(num);
 159                 for (; num>0; --num)
 160                 {
 161                         sint    ver = _File.serialVersion(1);
 162
 163                         // Serialize parent.
 164                         sint    verp= _File.serialVersion(2);
 165
 166                         if (verp>=2)
 167                         {
 168                                 SERIAL_DUMMY(bool);
 169                         }
 170
 171                         if (verp>=1)
 172                         {
 173                                 SERIAL_DUMMY(sint32);   // enum _Type
 174                                 SERIAL_DUMMY(CVector);  // _SpotDirection
 175                                 SERIAL_DUMMY(float);    // _SpotAngleBegin
 176                                 SERIAL_DUMMY(float);    // _SpotAngleEnd
 177                         }
 178
 179                         SERIAL_DUMMY(CVector);          // _Position
 180                         SERIAL_DUMMY(CRGBA);            // _Ambient
 181                         SERIAL_DUMMY(CRGBA);            // _Diffuse
 182                         SERIAL_DUMMY(CRGBA);            // _Specular
 183                         SERIAL_DUMMY(float);            // _AttenuationBegin
 184                         SERIAL_DUMMY(float);            // _AttenuationEnd
 185
 186                         // Serialize my data
 187                         SERIAL_DUMMY(string);           // AnimatedLight
 188                         SERIAL_DUMMY(CRGBA);            // _DefaultAmbient
 189                         SERIAL_DUMMY(CRGBA);            // _DefaultDiffuse
 190                         SERIAL_DUMMY(CRGBA);            // _DefaultSpecular
 191
 192                         if (ver>=1)
 193                                 SERIAL_DUMMY(uint32);   // LightGroup
 194                 }
 195
 196                 if (ver == 0)
 197                 {
 198                         uint32  num;
 199                         _File.serial(num);
 200                         for (; num>0; --num)
 201                         {
 202                                 SERIAL_DUMMY(uint32);   // StartId
 203                                 SERIAL_DUMMY(uint32);   // EndId
 204                         }
 205                 }
 206                 else
 207                 {
 208                         // _PointLightGroupMap
 209                         uint32  num;
 210                         _File.serial(num);
 211                         for (; num>0; --num)
 212                         {
 213                                 _File.serialVersion (0);
 214                                 SERIAL_DUMMY(string);           // AnimationLight
 215                                 SERIAL_DUMMY(uint32);           // LightGroup
 216                                 SERIAL_DUMMY(uint32);           // StartId
 217                                 SERIAL_DUMMY(uint32);           // EndId
 218                         }
 219                 }
 220         }
 221
 222
 223         if (version >= 2)
 224                 SERIAL_DUMMY(CVector);                  // _GlobalPos
 225
 226
 227
 228
 229
 230
 231
 232         if (version >= 1)
 233         {
 234                 uint32  numClusters;
 235                 uint32  num;
 236
 237                 // f.serialCont (_ClusterInfos);
 238                 _File.serial(numClusters);
 239                 for (num=numClusters; num>0; --num)
 240                 {
 241                         sint version = _File.serialVersion (3);
 242
 243                         if (version >= 1)
 244                                 SERIAL_DUMMY(string);   // Name
 245
 246                         uint32  n;
 247
 248                         // f.serialCont (_LocalVolume);
 249                         _File.serial(n);
 250                         for (; n>0; --n)
 251                                 SERIAL_DUMMY(CPlane);   // _LocalVolume
 252
 253                         SERIAL_DUMMY(CAABBox);          // _LocalBBox
 254                         SERIAL_DUMMY(bool)      ;               // FatherVisible
 255                         SERIAL_DUMMY(bool);                     // VisibleFromFather
 256
 257                         if (version >= 2)
 258                         {
 259                                 SERIAL_DUMMY(string);   // soundGroup
 260                                 SERIAL_DUMMY(string);   // envFxName
 261                         }
 262
 263                         if (version >= 3)
 264                         {
 265                                 SERIAL_DUMMY(bool);             // AudibleFromFather
 266                                 SERIAL_DUMMY(bool);             // FatherAudible
 267                         }
 268                 }
 269
 270                 // f.serialCont (_Portals);
 271                 _File.serial(num);
 272                 for (; num>0; --num)
 273                 {
 274                         int version = _File.serialVersion (1);
 275
 276                         uint32  n;
 277
 278                         //f.serialCont (_LocalPoly);
 279                         _File.serial(n);
 280                         for (; n>0; --n)
 281                                 SERIAL_DUMMY(CVector);
 282
 283                         SERIAL_DUMMY(string);           // _Name
 284
 285                         if (version >= 1)
 286                         {
 287                                 SERIAL_DUMMY(string);           // occName;
 288                                 SERIAL_DUMMY(string);           // occName;
 289                         }
 290                 }
 291
 292                 // Links
 293                 uint32 i, j;
 294                 for (i = 0; i < numClusters; ++i)
 295                 {
 296                         uint32 nNbPortals;
 297                         _File.serial (nNbPortals);
 298
 299                         for (j = 0; j < nNbPortals; ++j)
 300                                 SERIAL_DUMMY(sint32);   // nPortalNb
 301                 }
 302         }
 303
 304         // Serial the array
 305         // f.serialCont (_InstancesInfos);
 306         uint32  num;
 307         _File.serial(num);
 308         for (; num>0; --num)
 309         {
 310                 /*
 311                 Version 7:
 312                         - Visible
 313                 Version 6:
 314                         - DontCastShadowForExterior
 315                 Version 5:
 316                         - DontCastShadowForInterior
 317                 Version 4:
 318                         - LocalAmbientId.
 319                 Version 3:
 320                         - StaticLight.
 321                 Version 2:
 322                         - gameDev data.
 323                 Version 1:
 324                         - Clusters
 325                 */
 326                 // Serial a version number
 327                 sint version = _File.serialVersion (7);
 328
 329                 // Visible
 330                 if (version >= 7)
 331                         SERIAL_DUMMY(bool);
 332
 333                 // DontCastShadowForExterior
 334                 if (version >= 6)
 335                         SERIAL_DUMMY(bool);
 336
 337                 // DontCastShadowForInterior
 338                 if (version >= 5)
 339                         SERIAL_DUMMY(bool);
 340
 341
 342                 // Serial the LocalAmbientId.
 343                 if (version >= 4)
 344                         SERIAL_DUMMY(uint8);    // LocalAmbientId)
 345
 346                 // Serial the StaticLight
 347                 if (version >= 3)
 348                 {
 349
 350                         SERIAL_DUMMY(bool);             // AvoidStaticLightPreCompute
 351                         SERIAL_DUMMY(bool);             // DontCastShadow
 352                         SERIAL_DUMMY(bool);             // StaticLightEnabled
 353                         SERIAL_DUMMY(uint8);    // SunContribution
 354
 355                         SERIAL_DUMMY(uint8);    // Light[0]
 356                         SERIAL_DUMMY(uint8);    // Light[1]
 357                 }
 358
 359                 // Serial the gamedev data
 360                 _InstanceNames.resize(_InstanceNames.size()+1);
 361                 if (version >= 2)
 362                 {
 363                         _File.serial(_InstanceNames.back());
 364                         SERIAL_DUMMY(bool);             // DontAddToScene
 365                 }
 366
 367                 // Serial the clusters
 368                 if (version >= 1)
 369                 {
 370                         // f.serialCont (Clusters);
 371                         uint32  num;
 372                         _File.serial(num);
 373                         for (; num>0; --num)
 374                                 SERIAL_DUMMY(uint32);
 375                 }
 376
 377                 // Serial the name
 378                 _ShapeNames.resize(_ShapeNames.size()+1);
 379                 _File.serial(_ShapeNames.back());
 380                 //serialDummy<string>();                // Name
 381
 382                 // Serial the position vector
 383                 _ShapePos.resize(_ShapePos.size()+1);
 384                 _File.serial(_ShapePos.back());
 385                 //serialDummy<CVector>();               // Pos
 386
 387                 // Serial the rotation vector
 388                 _ShapeRots.resize(_ShapeRots.size()+1);
 389                 _File.serial(_ShapeRots.back());
 390                 //serialDummy<CQuat>();         // Rot
 391
 392                 // Serial the scale vector
 393                 _ShapeScales.resize(_ShapeScales.size()+1);
 394                 _File.serial(_ShapeScales.back());
 395                 //serialDummy<CVector>();               // Scale
 396
 397                 // Serial the parent location in the vector (-1 if no parent)
 398                 SERIAL_DUMMY(sint32);           // nParent
 399         }
 400 }