nel/tools/3d/pipeline_max/config.cpp

   1 /**
   2  * \file config.cpp
   3  * \brief CConfig
   4  * \date 2012-08-18 19:25GMT
   5  * \author Jan Boon (Kaetemi)
   6  * CConfig
   7  */
   8
   9 /*
  10  * Copyright (C) 2012  by authors
  11  *
  12  * This file is part of RYZOM CORE PIPELINE.
  13  * RYZOM CORE PIPELINE is free software: you can redistribute it
  14  * and/or modify it under the terms of the GNU Affero General Public
  15  * License as published by the Free Software Foundation, either
  16  * version 3 of the License, or (at your option) any later version.
  17  *
  18  * RYZOM CORE PIPELINE is distributed in the hope that it will be
  19  * useful, but WITHOUT ANY WARRANTY; without even the implied warranty
  20  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Affero General Public License for more details.
  22  *
  23  * You should have received a copy of the GNU Affero General Public
  24  * License along with RYZOM CORE PIPELINE.  If not, see
  25  * <http://www.gnu.org/licenses/>.
  26  */
  27
  28 #include <nel/misc/types_nl.h>
  29 #include "config.h"
  30
  31 // STL includes
  32
  33 // NeL includes
  34 // #include <nel/misc/debug.h>
  35 #include <nel/misc/vector.h>
  36
  37 // Project includes
  38
  39 using namespace std;
  40 // using namespace NLMISC;
  41
  42 namespace PIPELINE {
  43 namespace MAX {
  44
  45 ////////////////////////////////////////////////////////////////////////
  46 ////////////////////////////////////////////////////////////////////////
  47 ////////////////////////////////////////////////////////////////////////
  48
  49 CConfig::CConfig()
  50 {
  51
  52 }
  53
  54 CConfig::~CConfig()
  55 {
  56
  57 }
  58
  59 std::string CConfig::className() const
  60 {
  61         return "Config";
  62 }
  63
  64 void CConfig::toString(std::ostream &ostream, const std::string &pad) const
  65 {
  66         CStorageContainer::toString(ostream, pad);
  67 }
  68
  69 void CConfig::parse(uint16 version, uint filter)
  70 {
  71         CStorageContainer::parse(version);
  72 }
  73
  74 void CConfig::clean()
  75 {
  76         CStorageContainer::clean();
  77 }
  78
  79 void CConfig::build(uint16 version, uint filter)
  80 {
  81         CStorageContainer::build(version);
  82 }
  83
  84 void CConfig::disown()
  85 {
  86         CStorageContainer::disown();
  87 }
  88
  89 IStorageObject *CConfig::createChunkById(uint16 id, bool container)
  90 {
  91         if (container)
  92         {
  93                 switch (id)
  94                 {
  95                 case 0x20a0: // unknown
  96                         return new CConfig20a0();
  97                 case 0x2180: // CConfigScript
  98                         return new CConfigScript();
  99                 }
 100         }
 101         else
 102         {
 103                 switch (id)
 104                 {
 105                 case 0x2090: // unknown; known values: 1 (m3), 0 (m9, m2008, m2010)
 106                         return new CStorageValue<sint32>();
 107                 }
 108         }
 109         return CStorageContainer::createChunkById(id, container);
 110 }
 111
 112 ////////////////////////////////////////////////////////////////////////
 113 ////////////////////////////////////////////////////////////////////////
 114 ////////////////////////////////////////////////////////////////////////
 115
 116 CConfig20a0::CConfig20a0()
 117 {
 118
 119 }
 120
 121 CConfig20a0::~CConfig20a0()
 122 {
 123
 124 }
 125
 126 std::string CConfig20a0::className() const
 127 {
 128         return "Config20a0";
 129 }
 130
 131 void CConfig20a0::toString(std::ostream &ostream, const std::string &pad) const
 132 {
 133         CStorageContainer::toString(ostream, pad);
 134 }
 135
 136 void CConfig20a0::parse(uint16 version, uint filter)
 137 {
 138         CStorageContainer::parse(version);
 139 }
 140
 141 void CConfig20a0::clean()
 142 {
 143         CStorageContainer::clean();
 144 }
 145
 146 void CConfig20a0::build(uint16 version, uint filter)
 147 {
 148         CStorageContainer::build(version);
 149 }
 150
 151 void CConfig20a0::disown()
 152 {
 153         CStorageContainer::disown();
 154 }
 155
 156 IStorageObject *CConfig20a0::createChunkById(uint16 id, bool container)
 157 {
 158         if (container)
 159         {
 160                 switch (id)
 161                 {
 162                 case 0x0110: // CConfig20a0Entry
 163                         return new CConfig20a0Entry();
 164                 }
 165         }
 166         else
 167         {
 168                 switch (id)
 169                 {
 170                 case 0x0100: // CConfig20a0Header: Number of entries
 171                         return new CStorageValue<sint32>();
 172                 }
 173         }
 174         return CStorageContainer::createChunkById(id, container);
 175 }
 176
 177 ////////////////////////////////////////////////////////////////////////
 178 ////////////////////////////////////////////////////////////////////////
 179 ////////////////////////////////////////////////////////////////////////
 180
 181 CConfig20a0Entry::CConfig20a0Entry()
 182 {
 183
 184 }
 185
 186 CConfig20a0Entry::~CConfig20a0Entry()
 187 {
 188
 189 }
 190
 191 std::string CConfig20a0Entry::className() const
 192 {
 193         return "Config20a0Entry";
 194 }
 195
 196 void CConfig20a0Entry::toString(std::ostream &ostream, const std::string &pad) const
 197 {
 198         CStorageContainer::toString(ostream, pad);
 199 }
 200
 201 void CConfig20a0Entry::parse(uint16 version, uint filter)
 202 {
 203         CStorageContainer::parse(version);
 204 }
 205
 206 void CConfig20a0Entry::clean()
 207 {
 208         CStorageContainer::clean();
 209 }
 210
 211 void CConfig20a0Entry::build(uint16 version, uint filter)
 212 {
 213         CStorageContainer::build(version);
 214 }
 215
 216 void CConfig20a0Entry::disown()
 217 {
 218         CStorageContainer::disown();
 219 }
 220
 221 IStorageObject *CConfig20a0Entry::createChunkById(uint16 id, bool container)
 222 {
 223         if (container)
 224         {
 225                 switch (id)
 226                 {
 227                 case 0x0300: // unknown, contains 0x0100 with 4 bytes int value
 228                         return CStorageContainer::createChunkById(id, container);
 229                 }
 230         }
 231         else
 232         {
 233                 switch (id)
 234                 {
 235                 case 0x0100: // unknown
 236                 case 0x0110: // unknown
 237                 case 0x0120: // unknown
 238                 case 0x0130: // unknown
 239                 case 0x0140: // unknown
 240                 case 0x0150: // unknown
 241                 case 0x0160: // unknown
 242                 case 0x0161: // unknown
 243                 case 0x0170: // unknown
 244                 case 0x0180: // unknown
 245                 case 0x0190: // unknown
 246                 case 0x0200: // unknown
 247                 case 0x0210: // unknown
 248                 case 0x0220: // unknown
 249                 case 0x0230: // unknown
 250                 case 0x0240: // unknown
 251                 case 0x0250: // unknown
 252                 case 0x0270: // unknown
 253                 case 0x0280: // unknown
 254                 case 0x0310: // unknown
 255                 case 0x0320: // unknown
 256                         return new CStorageValue<sint32>();
 257                 case 0x0260: // unknown
 258                         return new CStorageValue<sint64>();
 259                 case 0x0330: // unknown, 16 bytes
 260                         return CStorageContainer::createChunkById(id, container);
 261                 case 0x0290: // unknown
 262                 case 0x0390: // unknown
 263                         return new CStorageValue<ucstring>();
 264                 }
 265         }
 266         return CStorageContainer::createChunkById(id, container);
 267 }
 268
 269 ////////////////////////////////////////////////////////////////////////
 270 ////////////////////////////////////////////////////////////////////////
 271 ////////////////////////////////////////////////////////////////////////
 272
 273 CConfigScript::CConfigScript()
 274 {
 275
 276 }
 277
 278 CConfigScript::~CConfigScript()
 279 {
 280
 281 }
 282
 283 std::string CConfigScript::className() const
 284 {
 285         return "ConfigScript";
 286 }
 287
 288 void CConfigScript::toString(std::ostream &ostream, const std::string &pad) const
 289 {
 290         CStorageContainer::toString(ostream, pad);
 291 }
 292
 293 void CConfigScript::parse(uint16 version, uint filter)
 294 {
 295         CStorageContainer::parse(version);
 296 }
 297
 298 void CConfigScript::clean()
 299 {
 300         CStorageContainer::clean();
 301 }
 302
 303 void CConfigScript::build(uint16 version, uint filter)
 304 {
 305         CStorageContainer::build(version);
 306 }
 307
 308 void CConfigScript::disown()
 309 {
 310         CStorageContainer::disown();
 311 }
 312
 313 IStorageObject *CConfigScript::createChunkById(uint16 id, bool container)
 314 {
 315         if (container)
 316         {
 317                 switch (id)
 318                 {
 319                 case 0x0040: // ConfigScriptEntry
 320                         return new CConfigScriptEntry();
 321                 }
 322         }
 323         return CStorageContainer::createChunkById(id, container);
 324 }
 325
 326 ////////////////////////////////////////////////////////////////////////
 327 ////////////////////////////////////////////////////////////////////////
 328 ////////////////////////////////////////////////////////////////////////
 329
 330 CConfigScriptEntry::CConfigScriptEntry()
 331 {
 332
 333 }
 334
 335 CConfigScriptEntry::~CConfigScriptEntry()
 336 {
 337
 338 }
 339
 340 std::string CConfigScriptEntry::className() const
 341 {
 342         return "ConfigScriptEntry";
 343 }
 344
 345 void CConfigScriptEntry::toString(std::ostream &ostream, const std::string &pad) const
 346 {
 347         CStorageContainer::toString(ostream, pad);
 348 }
 349
 350 void CConfigScriptEntry::parse(uint16 version, uint filter)
 351 {
 352         CStorageContainer::parse(version);
 353 }
 354
 355 void CConfigScriptEntry::clean()
 356 {
 357         CStorageContainer::clean();
 358 }
 359
 360 void CConfigScriptEntry::build(uint16 version, uint filter)
 361 {
 362         CStorageContainer::build(version);
 363 }
 364
 365 void CConfigScriptEntry::disown()
 366 {
 367         CStorageContainer::disown();
 368 }
 369
 370 IStorageObject *CConfigScriptEntry::createChunkById(uint16 id, bool container)
 371 {
 372         if (container)
 373         {
 374                 switch (id)
 375                 {
 376                 case 0x0007: // ConfigScriptMetaContainer
 377                         return new CConfigScriptMetaContainer();
 378                 }
 379         }
 380         else
 381         {
 382                 switch (id)
 383                 {
 384                 case 0x0050: // ConfigScriptHeader
 385                         return new CConfigScriptHeader();
 386                 }
 387         }
 388         return CStorageContainer::createChunkById(id, container);
 389 }
 390
 391 ////////////////////////////////////////////////////////////////////////
 392 ////////////////////////////////////////////////////////////////////////
 393 ////////////////////////////////////////////////////////////////////////
 394
 395 CConfigScriptHeader::CConfigScriptHeader()
 396 {
 397
 398 }
 399
 400 CConfigScriptHeader::~CConfigScriptHeader()
 401 {
 402
 403 }
 404
 405 std::string CConfigScriptHeader::className() const
 406 {
 407         return "ConfigScriptHeader";
 408 }
 409
 410 void CConfigScriptHeader::serial(NLMISC::IStream &stream)
 411 {
 412         stream.serial(SuperClassID);
 413         stream.serial(ClassID);
 414 }
 415
 416 void CConfigScriptHeader::toString(std::ostream &ostream, const std::string &pad) const
 417 {
 418         ostream << "(" << className() << ") { ";
 419         ostream << "\n" << pad << "SuperClassID: " << SuperClassID;
 420         ostream << "\n" << pad << "ClassID: " << NLMISC::toString(ClassID);
 421         ostream << " } ";
 422 }
 423
 424 ////////////////////////////////////////////////////////////////////////
 425 ////////////////////////////////////////////////////////////////////////
 426 ////////////////////////////////////////////////////////////////////////
 427
 428 CConfigScriptMetaContainer::CConfigScriptMetaContainer()
 429 {
 430
 431 }
 432
 433 CConfigScriptMetaContainer::~CConfigScriptMetaContainer()
 434 {
 435
 436 }
 437
 438 std::string CConfigScriptMetaContainer::className() const
 439 {
 440         return "ConfigScriptMetaContainer";
 441 }
 442
 443 void CConfigScriptMetaContainer::toString(std::ostream &ostream, const std::string &pad) const
 444 {
 445         CStorageContainer::toString(ostream, pad);
 446 }
 447
 448 void CConfigScriptMetaContainer::parse(uint16 version, uint filter)
 449 {
 450         CStorageContainer::parse(version);
 451 }
 452
 453 void CConfigScriptMetaContainer::clean()
 454 {
 455         CStorageContainer::clean();
 456 }
 457
 458 void CConfigScriptMetaContainer::build(uint16 version, uint filter)
 459 {
 460         CStorageContainer::build(version);
 461 }
 462
 463 void CConfigScriptMetaContainer::disown()
 464 {
 465         CStorageContainer::disown();
 466 }
 467
 468 IStorageObject *CConfigScriptMetaContainer::createChunkById(uint16 id, bool container)
 469 {
 470         if (container)
 471         {
 472                 switch (id)
 473                 {
 474                 case 0x0007: // ConfigScriptMetaContainer
 475                         return new CConfigScriptMetaContainer();
 476                 }
 477         }
 478         else
 479         {
 480                 switch (id)
 481                 {
 482                 case 0x0001: // type: boolean (stored in four bytes, yes)
 483                         return new CStorageValue<uint32>();
 484                 case 0x0002: // ???
 485                         nlerror("0x0002 found, please implement");
 486                         break;
 487                 case 0x0003: // type: integer (not sure if signed)
 488                         return new CStorageValue<sint32>();
 489                 case 0x0004: // type: float
 490                         return new CStorageValue<float>();
 491                 case 0x0005: // type: string (same format as the meta string)
 492                 case 0x0006: // ConfigScriptMetaString
 493                         return new CConfigScriptMetaString();
 494                 case 0x0008: // type: color (stored as 3 float vector)
 495                         return new CStorageValue<NLMISC::CVector>;
 496                 case 0x0060: // ConfigScriptMetaContainerHeader (contains the number of entries, amusingly)
 497                         return new CStorageValue<uint32>();
 498                 }
 499         }
 500         return CStorageContainer::createChunkById(id, container);
 501 }
 502
 503 ////////////////////////////////////////////////////////////////////////
 504 ////////////////////////////////////////////////////////////////////////
 505 ////////////////////////////////////////////////////////////////////////
 506
 507 CConfigScriptMetaString::CConfigScriptMetaString()
 508 {
 509
 510 }
 511
 512 CConfigScriptMetaString::~CConfigScriptMetaString()
 513 {
 514
 515 }
 516
 517 std::string CConfigScriptMetaString::className() const
 518 {
 519         return "ConfigScriptMetaString";
 520 }
 521
 522 void CConfigScriptMetaString::serial(NLMISC::IStream &stream)
 523 {
 524         if (stream.isReading())
 525         {
 526                 uint32 size;
 527                 stream.serial(size);
 528                 Value.resize(size - 1);
 529         }
 530         else
 531         {
 532                 uint32 size = Value.size() + 1;
 533                 stream.serial(size);
 534         }
 535         stream.serialBuffer(static_cast<uint8 *>(static_cast<void *>(&Value[0])), Value.size());
 536         uint8 endByte = 0;
 537         stream.serial(endByte);
 538         nlassert(endByte == 0);
 539 }
 540
 541 void CConfigScriptMetaString::toString(std::ostream &ostream, const std::string &pad) const
 542 {
 543         ostream << "(" << className() << ") { " << Value << " } ";
 544 }
 545
 546 ////////////////////////////////////////////////////////////////////////
 547 ////////////////////////////////////////////////////////////////////////
 548 ////////////////////////////////////////////////////////////////////////
 549
 550 } /* namespace MAX */
 551 } /* namespace PIPELINE */
 552
 553 /* end of file */