Source/Base/Field/OSGBaseFieldTraits.h

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *           Copyright (C) 2003 by the OpenSG Forum                          *
   6  *                                                                           *
   7  *                            www.opensg.org                                 *
   8  *                                                                           *
   9  *   contact: dirk@opensg.org, gerrit.voss@vossg.org, jbehr@zgdv.de          *
  10  *                                                                           *
  11 \*---------------------------------------------------------------------------*/
  12 /*---------------------------------------------------------------------------*\
  13  *                                License                                    *
  14  *                                                                           *
  15  * This library is free software; you can redistribute it and/or modify it   *
  16  * under the terms of the GNU Library General Public License as published    *
  17  * by the Free Software Foundation, version 2.                               *
  18  *                                                                           *
  19  * This library is distributed in the hope that it will be useful, but       *
  20  * WITHOUT ANY WARRANTY; without even the implied warranty of                *
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
  22  * Library General Public License for more details.                          *
  23  *                                                                           *
  24  * You should have received a copy of the GNU Library General Public         *
  25  * License along with this library; if not, write to the Free Software       *
  26  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                 *
  27  *                                                                           *
  28 \*---------------------------------------------------------------------------*/
  29 /*---------------------------------------------------------------------------*\
  30  *                                Changes                                    *
  31  *                                                                           *
  32  *                                                                           *
  33  *                                                                           *
  34  *                                                                           *
  35  *                                                                           *
  36  *                                                                           *
  37 \*---------------------------------------------------------------------------*/
  38
  39 #ifndef _OSGBASEFIELDTRAITS_H_
  40 #define _OSGBASEFIELDTRAITS_H_
  41 #ifdef __sgi
  42 #pragma once
  43 #endif
  44
  45 #include "OSGSysFieldTraits.h"
  46 #include "OSGDataType.h"
  47
  48 #include "OSGColor.h"
  49 #include "OSGTime.h"
  50 #include "OSGSphereVolume.h"
  51 #include "OSGBoxVolume.h"
  52 #include "OSGPlane.h"
  53 #include "OSGGL.h"
  54 #include "OSGGLDefineMapper.h"
  55
  56 #include <iomanip>
  57
  58 OSG_BEGIN_NAMESPACE
  59
  60 /*! \ingroup GrpBaseFieldTraits
  61     \ingroup GrpLibOSGBase
  62  */
  63
  64 template <>
  65 struct FieldTraits<Color3f> : public FieldTraitsVec3TemplateBase<Color3f>
  66 {
  67   private:
  68
  69     static  DataType             _type;
  70
  71   public:
  72
  73     typedef FieldTraits<Color3f>  Self;
  74
  75     enum             { Convertible = (Self::ToStreamConvertible  |
  76                                       Self::FromStringConvertible)     };
  77
  78     static OSG_BASE_DLLMAPPING
  79                  DataType &getType      (void);
  80
  81     static const Char8    *getSName     (void) { return "SFColor3f";   }
  82
  83     static const Char8    *getMName     (void) { return "MFColor3f";   }
  84
  85     static const Color3f   getDefault   (void) { return Color3f();     }
  86 };
  87
  88
  89 /*! \ingroup GrpBaseFieldTraits
  90     \ingroup GrpLibOSGBase
  91  */
  92
  93 template <>
  94 struct FieldTraits<Color3fx> : public FieldTraitsVec3TemplateBase<Color3fx>
  95 {
  96   private:
  97
  98     static  DataType              _type;
  99
 100   public:
 101
 102     typedef FieldTraits<Color3fx>  Self;
 103
 104     enum             { Convertible = (Self::ToStreamConvertible  |
 105                                       Self::FromStringConvertible)     };
 106
 107     static OSG_BASE_DLLMAPPING
 108                  DataType &getType      (void);
 109
 110     static const Char8    *getSName     (void) { return "SFColor3fx";   }
 111
 112     static const Char8    *getMName     (void) { return "MFColor3fx";   }
 113
 114     static const Color3fx  getDefault   (void) { return Color3fx();     }
 115 };
 116
 117
 118 /*! \ingroup GrpBaseFieldTraits
 119     \ingroup GrpLibOSGBase
 120  */
 121
 122 template <>
 123 struct FieldTraits<Color4f> : public FieldTraitsVec4TemplateBase<Color4f>
 124 {
 125   private:
 126
 127     static  DataType             _type;
 128
 129   public:
 130
 131     typedef FieldTraits<Color4f>  Self;
 132
 133     enum             { Convertible = (Self::ToStreamConvertible  |
 134                                       Self::FromStringConvertible)     };
 135
 136     static OSG_BASE_DLLMAPPING
 137                  DataType &getType      (void);
 138
 139     static const Char8    *getSName     (void) { return "SFColor4f";   }
 140
 141     static const Char8    *getMName     (void) { return "MFColor4f";   }
 142
 143     static       Color4f   getDefault   (void){ return Color4f();      }
 144 };
 145
 146
 147 /*! \ingroup GrpBaseFieldTraits
 148     \ingroup GrpLibOSGBase
 149  */
 150
 151 template <>
 152 struct FieldTraits<Color4fx> : public FieldTraitsVec4TemplateBase<Color4fx>
 153 {
 154   private:
 155
 156     static  DataType              _type;
 157
 158   public:
 159
 160     typedef FieldTraits<Color4fx>  Self;
 161
 162     enum             { Convertible = (Self::ToStreamConvertible  |
 163                                       Self::FromStringConvertible)     };
 164
 165     static OSG_BASE_DLLMAPPING
 166                  DataType &getType      (void);
 167
 168     static const Char8    *getSName     (void) { return "SFColor4fx";   }
 169
 170     static const Char8    *getMName     (void) { return "MFColor4fx";   }
 171
 172     static       Color4fx  getDefault   (void){ return Color4fx();      }
 173 };
 174
 175
 176 /*! \ingroup GrpBaseFieldTraits
 177     \ingroup GrpLibOSGBase
 178  */
 179
 180 template <>
 181 struct FieldTraits<Color3ub> : public FieldTraitsVec3TemplateBase<Color3ub>
 182 {
 183   private:
 184
 185     static  DataType              _type;
 186
 187   public:
 188
 189     typedef FieldTraits<Color3ub>  Self;
 190
 191     enum             { Convertible = (Self::ToStreamConvertible  |
 192                                       Self::FromStringConvertible)     };
 193
 194     static OSG_BASE_DLLMAPPING
 195                  DataType &getType      (void);
 196
 197     static const Char8    *getSName     (void) { return "SFColor3ub";  }
 198     static const Char8    *getMName     (void) { return "MFColor3ub";  }
 199
 200     static       Color3ub  getDefault   (void) { return Color3ub();    }
 201 };
 202
 203
 204 /*! \ingroup GrpBaseFieldTraits
 205     \ingroup GrpLibOSGBase
 206  */
 207
 208 template <>
 209 struct FieldTraits<Color4ub> : public FieldTraitsVec4TemplateBase<Color4ub>
 210 {
 211   private:
 212
 213     static  DataType              _type;
 214
 215   public:
 216
 217     typedef FieldTraits<Color4ub>  Self;
 218
 219     enum             { Convertible = (Self::ToStreamConvertible  |
 220                                       Self::FromStringConvertible)     };
 221
 222     static OSG_BASE_DLLMAPPING
 223                  DataType &getType      (void);
 224
 225     static const Char8    *getSName     (void) { return "SFColor4ub";  }
 226
 227     static const Char8    *getMName     (void) { return "MFColor4ub";  }
 228
 229     static       Color4ub  getDefault   (void) { return Color4ub();    }
 230 };
 231
 232
 233 /*! \ingroup GrpBaseFieldTraits
 234     \ingroup GrpLibOSGBase
 235  */
 236
 237 template <>
 238 struct FieldTraits<std::string> : public FieldTraitsTemplateBase<std::string>
 239 {
 240   private:
 241
 242     static  DataType                 _type;
 243
 244   public:
 245
 246     typedef FieldTraits<std::string>  Self;
 247
 248     enum             { Convertible = (Self::FromStringConvertible |
 249                                       Self::ToStreamConvertible   )  };
 250
 251     static OSG_BASE_DLLMAPPING
 252                  DataType   &getType      (void);
 253
 254     static const Char8      *getSName     (void) { return "SFString";    }
 255
 256     static const Char8      *getMName     (void) { return "MFString";    }
 257
 258     static       std::string getDefault   (void) { return std::string(); }
 259
 260     static void putToStream(const std::string &val,
 261                                   OutStream   &outStr)
 262     {
 263         outStr << "\"";
 264         outStr << val;
 265         outStr << "\"";
 266     }
 267
 268     static bool      getFromCString(      std::string  &outVal,
 269                                     const Char8       *&inVal)
 270     {
 271         outVal.assign(inVal);
 272
 273         return true;
 274     }
 275
 276     static       SizeT     getBinSize (const std::string &oObject)
 277     {
 278         return oObject.length() + 1 + sizeof(UInt32);
 279     }
 280
 281     static       SizeT     getBinSize (const std::string *pObjectStore,
 282                                                   SizeT   uiNumObjects)
 283     {
 284         SizeT size = 0;
 285
 286         for(SizeT i = 0; i < uiNumObjects; ++i)
 287         {
 288             size += getBinSize(pObjectStore[i]);
 289         }
 290
 291         return size;
 292     }
 293
 294
 295     static void copyToBin(           BinaryDataHandler   &pMem,
 296                           const std::string              &oObject)
 297     {
 298         pMem.putValue(oObject);
 299     }
 300
 301     static void copyToBin(           BinaryDataHandler &pMem,
 302                           const std::string            *pObjectStore,
 303                                      SizeT              uiNumObjects)
 304     {
 305         for(SizeT i = 0; i < uiNumObjects; ++i)
 306         {
 307             copyToBin(pMem, pObjectStore[i]);
 308         }
 309     }
 310
 311     static void copyFromBin(     BinaryDataHandler &pMem,
 312                             std::string            &oObject)
 313     {
 314         pMem.getValue(oObject);
 315     }
 316
 317     static void copyFromBin(     BinaryDataHandler &pMem,
 318                             std::string            *pObjectStore,
 319                                  SizeT              uiNumObjects)
 320     {
 321         for(SizeT i = 0; i < uiNumObjects; ++i)
 322         {
 323             copyFromBin(pMem, pObjectStore[i]);
 324         }
 325     }
 326 };
 327
 328
 329 /*! \ingroup GrpBaseFieldTraits
 330     \ingroup GrpLibOSGBase
 331  */
 332
 333 template <>
 334 struct FieldTraits<Time, 1> : public FieldTraitsPODTemplateBase<Time, 1>
 335 {
 336   private:
 337
 338     static  DataType             _type;
 339
 340   public:
 341
 342     typedef FieldTraits<Time, 1>  Self;
 343
 344     enum             { Convertible = (Self::ToStreamConvertible  |
 345                                       Self::FromStringConvertible)     };
 346
 347     static OSG_BASE_DLLMAPPING
 348                  DataType &getType      (void);
 349
 350     static const Char8    *getSName     (void) { return "SFTime";      }
 351
 352     static const Char8    *getMName     (void) { return "MFTime";      }
 353
 354     static       Time      getDefault   (void) { return Time();        }
 355 };
 356
 357
 358 /*! \ingroup GrpBaseFieldTraits
 359     \ingroup GrpLibOSGBase
 360  */
 361
 362 template <>
 363 struct FieldTraits<BoxVolume> :
 364     public FieldTraitsTemplateBase<BoxVolume>
 365 {
 366   private:
 367
 368     static  DataType                   _type;
 369
 370   public:
 371
 372     typedef FieldTraits<BoxVolume>  Self;
 373
 374     enum                  { Convertible = (Self::FromStringConvertible |
 375                                            Self::ToStreamConvertible   )     };
 376
 377     static OSG_BASE_DLLMAPPING
 378                  DataType  &getType     (void);
 379
 380     static const Char8     *getSName    (void) { return "SFBoxVolume"; }
 381
 382     static const Char8     *getMName    (void) { return "MFBoxVolume"; }
 383
 384     static const BoxVolume  getDefault  (void) { return BoxVolume();   }
 385
 386
 387     static bool getFromCString(      BoxVolume  &outVal,
 388                                const Char8     *&inVal)
 389     {
 390         Real32 valStore[  6];
 391         Char8  str     [256];
 392
 393         SizeT   length = strlen(inVal);
 394         Char8  *c      = str;
 395
 396         if(length > 256)
 397         {
 398             std::cerr << "FieldDataTraits<BoxVolume>::getFromString(): "
 399                       << "Input too long" << std::endl;
 400
 401             return false;
 402         }
 403
 404         strncpy(str, inVal, length);
 405
 406         while(*c != '\0')
 407         {
 408             if(*c == '[')
 409                 *c = ' ';
 410             if(*c == ']')
 411                 *c = ' ';
 412             if(*c == ',')
 413                 *c = ' ';
 414
 415             c++;
 416         }
 417
 418         Int32 iState;
 419
 420         Int16 count = sscanf(str, "%d %f %f %f %f %f %f",
 421                              &iState,
 422                              &valStore[0],
 423                              &valStore[1],
 424                              &valStore[2],
 425                              &valStore[3],
 426                              &valStore[4],
 427                              &valStore[5]);
 428
 429         if(count == 7)
 430         {
 431             outVal.setState(iState);
 432
 433             outVal.setBounds(valStore[0],
 434                              valStore[1],
 435                              valStore[2],
 436                              valStore[3],
 437                              valStore[4],
 438                              valStore[5]);
 439
 440             return true;
 441         }
 442         else
 443         {
 444             outVal.setBounds(0.f, 0.f, 0.f,
 445                              0.f, 0.f, 0.f);
 446
 447             return false;
 448         }
 449     }
 450
 451
 452     static void putToStream(const BoxVolume &val,
 453                                   OutStream &str)
 454     {
 455         Pnt3f min, max;
 456
 457         typedef TypeTraits<Pnt3f::ValueType> TypeTrait;
 458         typedef TypeTraits<UInt16>           StateTypeTrait;
 459
 460         StateTypeTrait::putToStream(val.getState(), str);
 461         str << " ";
 462
 463         val.getBounds(min, max);
 464
 465         TypeTrait::putToStream(min[0], str);
 466         str << " ";
 467
 468         TypeTrait::putToStream(min[1], str);
 469         str << " ";
 470
 471         TypeTrait::putToStream(min[2], str);
 472         str << " ";
 473
 474         TypeTrait::putToStream(max[0], str);
 475         str << " ";
 476
 477         TypeTrait::putToStream(max[1], str);
 478         str << " ";
 479
 480         TypeTrait::putToStream(max[2], str);
 481     }
 482
 483     static SizeT getBinSize(const BoxVolume &oObject)
 484     {
 485         SizeT  size = sizeof(UInt16);
 486
 487         size += sizeof(Pnt3f) + sizeof(Pnt3f);
 488
 489         return size;
 490     }
 491
 492
 493     static SizeT getBinSize(const BoxVolume *pObjectStore,
 494                                   SizeT      uiNumObjects)
 495     {
 496         SizeT size = 0;
 497
 498         for(SizeT i = 0; i < uiNumObjects; ++i)
 499         {
 500             size += getBinSize(pObjectStore[i]);
 501         }
 502
 503         return size;
 504     }
 505
 506     static void copyToBin(      BinaryDataHandler &pMem,
 507                           const BoxVolume         &oObject)
 508     {
 509
 510         UInt16 state = oObject.getState();
 511
 512         pMem.putValue(state);
 513
 514         pMem.putValues(&(oObject.getMin()[0]), 3);
 515         pMem.putValues(&(oObject.getMax()[0]), 3);
 516     }
 517
 518     static void copyToBin(      BinaryDataHandler &pMem,
 519                           const BoxVolume         *pObjectStore,
 520                                 SizeT              uiNumObjects)
 521     {
 522         for(SizeT i = 0; i < uiNumObjects; ++i)
 523         {
 524             copyToBin(pMem, pObjectStore[i]);
 525         }
 526     }
 527
 528     static void copyFromBin(BinaryDataHandler &pMem,
 529                             BoxVolume         &oObject)
 530     {
 531         Pnt3f min,max;
 532         UInt16 state;
 533
 534         pMem.getValue (state       );
 535         pMem.getValues(&(min[0]), 3);
 536         pMem.getValues(&(max[0]), 3);
 537
 538         oObject.setBounds(min, max);
 539         oObject.setState (state   );
 540     }
 541
 542     static void copyFromBin(BinaryDataHandler &pMem,
 543                             BoxVolume         *pObjectStore,
 544                             SizeT              uiNumObjects)
 545     {
 546         for(SizeT i = 0; i < uiNumObjects; ++i)
 547         {
 548             copyFromBin(pMem, pObjectStore[i]);
 549         }
 550     }
 551 };
 552
 553
 554 /*! \ingroup GrpBaseFieldTraits
 555     \ingroup GrpLibOSGBase
 556  */
 557
 558 template <>
 559 struct FieldTraits<BitVector, 1> :
 560     public FieldTraitsPODTemplateBase<BitVector, 1>
 561 {
 562   private:
 563
 564     static  DataType                  _type;
 565
 566   public:
 567
 568     typedef FieldTraits<BitVector, 1>  Self;
 569
 570     enum              { Convertible = Self::NotConvertible             };
 571
 572     static OSG_BASE_DLLMAPPING
 573                  DataType  &getType (void);
 574
 575     static const Char8     *getSName(void)   { return "SFBitVector";   }
 576
 577     static const Char8     *getMName(void)   { return "MFBitVector";   }
 578
 579     static       BitVector  getDefault(void) { return BitVector();     }
 580 };
 581
 582
 583 /*! \ingroup GrpBaseFieldTraits
 584     \ingroup GrpLibOSGBase
 585  */
 586
 587 template <>
 588 struct FieldTraits<GLenum, 1> : public FieldTraitsPODTemplateBase<GLenum, 1>
 589 {
 590   private:
 591
 592     static  DataType               _type;
 593
 594   public:
 595
 596     typedef FieldTraits<GLenum, 1>  Self;
 597
 598     enum             { Convertible = (Self::ToStreamConvertible  |
 599                                       Self::FromStringConvertible)     };
 600
 601     static OSG_BASE_DLLMAPPING
 602                  DataType &getType      (void);
 603
 604     static const Char8    *getSName     (void) { return "SFGLenum";          }
 605     static const Char8    *getMName     (void) { return "MFGLenum";          }
 606
 607     static       GLenum    getDefault   (void) { return 0;                   }
 608
 609     static void putToStream(const GLenum    &val,
 610                                   OutStream &str)
 611     {
 612 #ifdef OSG_GL_DEFMAPPER
 613         const std::string &oVal = GLDefineMapper::the()->toString(val);
 614
 615         str << "GL_" << oVal;
 616 #else
 617         str << std::setbase(16);
 618
 619         str << "0x";
 620         TypeTraits<GLenum>::putToStream(val, str);
 621
 622         str << std::setbase(10);
 623 #endif
 624     }
 625
 626 #ifdef OSG_GL_DEFMAPPER
 627     static bool getFromCString(      GLenum   &outVal,
 628                                const Char8   *&inVal )
 629     {
 630         outVal = GLDefineMapper::the()->fromString(inVal);
 631
 632         return true;
 633     }
 634 #endif
 635 };
 636
 637
 638 /*! \ingroup GrpBaseFieldTraits
 639     \ingroup GrpLibOSGBase
 640  */
 641
 642 template <>
 643 struct FieldTraits<Plane> : public FieldTraitsTemplateBase<Plane>
 644 {
 645   private:
 646
 647     static  DataType           _type;
 648
 649   public:
 650
 651     typedef FieldTraits<Plane>  Self;
 652
 653     enum             { Convertible = Self::NotConvertible               };
 654
 655     static OSG_BASE_DLLMAPPING
 656                  DataType &getType      (void);
 657
 658     static const Char8    *getSName     (void) { return "SFPlane";      }
 659
 660     static const Char8    *getMName     (void) { return "MFPlane";      }
 661
 662     static       Plane     getDefault   (void) { return Plane();        }
 663
 664     static       SizeT     getBinSize (const Plane &)
 665     {
 666         return sizeof(Real32) * 4;
 667     }
 668
 669     static       SizeT     getBinSize (const Plane     *,
 670                                              SizeT      uiNumObjects)
 671     {
 672         return sizeof(Real32) * 4 * uiNumObjects;
 673     }
 674
 675     static void   copyToBin  (      BinaryDataHandler &pMem,
 676                               const Plane            &oObject)
 677     {
 678         const Vec3f  &normal   = oObject.getNormal            ();
 679               Real32  distance = oObject.getDistanceFromOrigin();
 680
 681         pMem.putValues(&normal[0], 3);
 682         pMem.putValue ( distance    );
 683     }
 684
 685     static void copyToBin(      BinaryDataHandler &pMem,
 686                           const Plane             *pObjectStore,
 687                                 SizeT              uiNumObjects)
 688     {
 689         for(SizeT i = 0; i < uiNumObjects; ++i)
 690         {
 691             copyToBin(pMem, pObjectStore[i]);
 692         }
 693     }
 694
 695     static void   copyFromBin(      BinaryDataHandler &pMem,
 696                                     Plane             &oObject)
 697     {
 698         Vec3f  normal;
 699         Real32 distance;
 700
 701         pMem.getValues(&normal[0], 3);
 702         pMem.getValue ( distance    );
 703
 704         oObject.set(normal, distance);
 705     }
 706
 707     static void copyFromBin(BinaryDataHandler &pMem,
 708                             Plane             *pObjectStore,
 709                             SizeT              uiNumObjects)
 710     {
 711         for(SizeT i = 0; i < uiNumObjects; ++i)
 712         {
 713             copyFromBin(pMem, pObjectStore[i]);
 714         }
 715     }
 716 };
 717
 718
 719 /*! \ingroup GrpBaseFieldTraits
 720     \ingroup GrpLibOSGBase
 721  */
 722
 723 template <>
 724 struct FieldTraits<RenderPropBitVector, 3> :
 725     public FieldTraitsPODTemplateBase<RenderPropBitVector, 3>
 726 {
 727   private:
 728
 729     static  DataType               _type;
 730
 731   public:
 732
 733     typedef FieldTraits<RenderPropBitVector, 3>  Self;
 734
 735     enum             { Convertible = (Self::ToStreamConvertible  |
 736                                       Self::FromStringConvertible)     };
 737
 738     static OSG_BASE_DLLMAPPING
 739                  DataType &getType   (void);
 740
 741     static const Char8    *getSName  (void) { return "SFRenderPropBitVector"; }
 742     static const Char8    *getMName  (void) { return "MFRenderPropBitVector"; }
 743
 744     static       RenderPropBitVector getDefault(void) { return 0;             }
 745
 746     static void putToStream(const RenderPropBitVector &val,
 747                                   OutStream           &str)
 748     {
 749         FieldTraits<RenderPropBitVector, 0>::putToStream(val, str);
 750     }
 751
 752     static bool getFromCString(      RenderPropBitVector  &outVal,
 753                                const Char8               *&inVal )
 754     {
 755         return FieldTraits<RenderPropBitVector, 0>::getFromCString(outVal,
 756                                                                    inVal);
 757     }
 758 };
 759
 760 OSG_END_NAMESPACE
 761
 762 #endif /* _OSGBASEFIELDTRAITS_H_ */
 763