Source/System/State/Base/OSGLightChunkBase.cpp

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *               Copyright (C) 2000-2013 by the OpenSG Forum                 *
   6  *                                                                           *
   7  *                            www.opensg.org                                 *
   8  *                                                                           *
   9  * contact: dirk@opensg.org, gerrit.voss@vossg.org, carsten_neumann@gmx.net  *
  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 /*****************************************************************************\
  40  *****************************************************************************
  41  **                                                                         **
  42  **                  This file is automatically generated.                  **
  43  **                                                                         **
  44  **          Any changes made to this file WILL be lost when it is          **
  45  **           regenerated, which can become necessary at any time.          **
  46  **                                                                         **
  47  **     Do not change this file, changes should be done in the derived      **
  48  **     class LightChunk!
  49  **                                                                         **
  50  *****************************************************************************
  51 \*****************************************************************************/
  52
  53 #include <cstdlib>
  54 #include <cstdio>
  55
  56 #include "OSGConfig.h"
  57
  58
  59
  60 #include "OSGNode.h"                    // Beacon Class
  61
  62 #include "OSGLightChunkBase.h"
  63 #include "OSGLightChunk.h"
  64
  65 #include <boost/bind.hpp>
  66
  67 #ifdef WIN32 // turn off 'this' : used in base member initializer list warning
  68 #pragma warning(disable:4355)
  69 #endif
  70
  71 OSG_BEGIN_NAMESPACE
  72
  73 /***************************************************************************\
  74  *                            Description                                  *
  75 \***************************************************************************/
  76
  77 /*! \class OSG::LightChunk
  78     See \ref PageSystemLightChunk for a description.
  79
  80     The light chunk contains the parameter set for a single light source. It's taken
  81     straight from the glLight() manpage.
  82
  83     This chunk wraps glLight() (OSG::LightChunk::_sfAmbient,
  84     OSG::LightChunk::_sfDiffuse, OSG::LightChunk::_sfSpecular,
  85     OSG::LightChunk::_sfEmission, OSG::LightChunk::_sfPosition,
  86     OSG::LightChunk::_sfDirection, OSG::LightChunk::_sfExponent,
  87     OSG::LightChunk::_sfCutoff, OSG::LightChunk::_sfConstantAttenuation,
  88     OSG::LightChunk::_sfLinearAttenuation,
  89     OSG::LightChunk::_sfQuadraticAttenuation).
  90  */
  91
  92 /***************************************************************************\
  93  *                        Field Documentation                              *
  94 \***************************************************************************/
  95
  96 /*! \var Color4f         LightChunkBase::_sfDiffuse
  97     The light's diffuse color.
  98 */
  99
 100 /*! \var Color4f         LightChunkBase::_sfAmbient
 101     The light's ambient color.
 102 */
 103
 104 /*! \var Color4f         LightChunkBase::_sfSpecular
 105     The light's specular color.
 106 */
 107
 108 /*! \var Vec4f           LightChunkBase::_sfPosition
 109     The light's position.
 110 */
 111
 112 /*! \var Vec3f           LightChunkBase::_sfDirection
 113     The light's direction (only for spotlights).
 114 */
 115
 116 /*! \var Real32          LightChunkBase::_sfExponent
 117     The light's spotlight exponent.
 118 */
 119
 120 /*! \var Real32          LightChunkBase::_sfCutoff
 121     The light's spotlight cutoff. As this chunk follows OpenGL conventions, this is the only angle in the system given in degrees.
 122 */
 123
 124 /*! \var Real32          LightChunkBase::_sfConstantAttenuation
 125     The light's constant attenuation.
 126 */
 127
 128 /*! \var Real32          LightChunkBase::_sfLinearAttenuation
 129     The light's linear attenuation.
 130 */
 131
 132 /*! \var Real32          LightChunkBase::_sfQuadraticAttenuation
 133     The light's quadratic attenuation.
 134 */
 135
 136 /*! \var Node *          LightChunkBase::_sfBeacon
 137
 138 */
 139
 140
 141 /***************************************************************************\
 142  *                      FieldType/FieldTrait Instantiation                 *
 143 \***************************************************************************/
 144
 145 #if !defined(OSG_DO_DOC) || defined(OSG_DOC_DEV)
 146 PointerType FieldTraits<LightChunk *, nsOSG>::_type(
 147     "LightChunkPtr",
 148     "StateChunkPtr",
 149     LightChunk::getClassType(),
 150     nsOSG);
 151 #endif
 152
 153 OSG_FIELDTRAITS_GETTYPE_NS(LightChunk *, nsOSG)
 154
 155 OSG_EXPORT_PTR_SFIELD_FULL(PointerSField,
 156                            LightChunk *,
 157                            nsOSG);
 158
 159 OSG_EXPORT_PTR_MFIELD_FULL(PointerMField,
 160                            LightChunk *,
 161                            nsOSG);
 162
 163 /***************************************************************************\
 164  *                         Field Description                               *
 165 \***************************************************************************/
 166
 167 void LightChunkBase::classDescInserter(TypeObject &oType)
 168 {
 169     FieldDescriptionBase *pDesc = NULL;
 170
 171
 172     pDesc = new SFColor4f::Description(
 173         SFColor4f::getClassType(),
 174         "diffuse",
 175         "The light's diffuse color.\n",
 176         DiffuseFieldId, DiffuseFieldMask,
 177         false,
 178         (Field::SFDefaultFlags | Field::FStdAccess),
 179         static_cast<FieldEditMethodSig>(&LightChunk::editHandleDiffuse),
 180         static_cast<FieldGetMethodSig >(&LightChunk::getHandleDiffuse));
 181
 182     oType.addInitialDesc(pDesc);
 183
 184     pDesc = new SFColor4f::Description(
 185         SFColor4f::getClassType(),
 186         "ambient",
 187         "The light's ambient color.\n",
 188         AmbientFieldId, AmbientFieldMask,
 189         false,
 190         (Field::SFDefaultFlags | Field::FStdAccess),
 191         static_cast<FieldEditMethodSig>(&LightChunk::editHandleAmbient),
 192         static_cast<FieldGetMethodSig >(&LightChunk::getHandleAmbient));
 193
 194     oType.addInitialDesc(pDesc);
 195
 196     pDesc = new SFColor4f::Description(
 197         SFColor4f::getClassType(),
 198         "specular",
 199         "The light's specular color.\n",
 200         SpecularFieldId, SpecularFieldMask,
 201         false,
 202         (Field::SFDefaultFlags | Field::FStdAccess),
 203         static_cast<FieldEditMethodSig>(&LightChunk::editHandleSpecular),
 204         static_cast<FieldGetMethodSig >(&LightChunk::getHandleSpecular));
 205
 206     oType.addInitialDesc(pDesc);
 207
 208     pDesc = new SFVec4f::Description(
 209         SFVec4f::getClassType(),
 210         "position",
 211         "The light's position.\n",
 212         PositionFieldId, PositionFieldMask,
 213         false,
 214         (Field::SFDefaultFlags | Field::FStdAccess),
 215         static_cast<FieldEditMethodSig>(&LightChunk::editHandlePosition),
 216         static_cast<FieldGetMethodSig >(&LightChunk::getHandlePosition));
 217
 218     oType.addInitialDesc(pDesc);
 219
 220     pDesc = new SFVec3f::Description(
 221         SFVec3f::getClassType(),
 222         "direction",
 223         "The light's direction (only for spotlights).\n",
 224         DirectionFieldId, DirectionFieldMask,
 225         false,
 226         (Field::SFDefaultFlags | Field::FStdAccess),
 227         static_cast<FieldEditMethodSig>(&LightChunk::editHandleDirection),
 228         static_cast<FieldGetMethodSig >(&LightChunk::getHandleDirection));
 229
 230     oType.addInitialDesc(pDesc);
 231
 232     pDesc = new SFReal32::Description(
 233         SFReal32::getClassType(),
 234         "exponent",
 235         "The light's spotlight exponent.\n",
 236         ExponentFieldId, ExponentFieldMask,
 237         false,
 238         (Field::SFDefaultFlags | Field::FStdAccess),
 239         static_cast<FieldEditMethodSig>(&LightChunk::editHandleExponent),
 240         static_cast<FieldGetMethodSig >(&LightChunk::getHandleExponent));
 241
 242     oType.addInitialDesc(pDesc);
 243
 244     pDesc = new SFReal32::Description(
 245         SFReal32::getClassType(),
 246         "cutoff",
 247         "The light's spotlight cutoff. As this chunk follows OpenGL conventions, this is the only angle in the system given in degrees.\n",
 248         CutoffFieldId, CutoffFieldMask,
 249         false,
 250         (Field::SFDefaultFlags | Field::FStdAccess),
 251         static_cast<FieldEditMethodSig>(&LightChunk::editHandleCutoff),
 252         static_cast<FieldGetMethodSig >(&LightChunk::getHandleCutoff));
 253
 254     oType.addInitialDesc(pDesc);
 255
 256     pDesc = new SFReal32::Description(
 257         SFReal32::getClassType(),
 258         "constantAttenuation",
 259         "The light's constant attenuation.\n",
 260         ConstantAttenuationFieldId, ConstantAttenuationFieldMask,
 261         false,
 262         (Field::SFDefaultFlags | Field::FStdAccess),
 263         static_cast<FieldEditMethodSig>(&LightChunk::editHandleConstantAttenuation),
 264         static_cast<FieldGetMethodSig >(&LightChunk::getHandleConstantAttenuation));
 265
 266     oType.addInitialDesc(pDesc);
 267
 268     pDesc = new SFReal32::Description(
 269         SFReal32::getClassType(),
 270         "linearAttenuation",
 271         "The light's linear attenuation.\n",
 272         LinearAttenuationFieldId, LinearAttenuationFieldMask,
 273         false,
 274         (Field::SFDefaultFlags | Field::FStdAccess),
 275         static_cast<FieldEditMethodSig>(&LightChunk::editHandleLinearAttenuation),
 276         static_cast<FieldGetMethodSig >(&LightChunk::getHandleLinearAttenuation));
 277
 278     oType.addInitialDesc(pDesc);
 279
 280     pDesc = new SFReal32::Description(
 281         SFReal32::getClassType(),
 282         "quadraticAttenuation",
 283         "The light's quadratic attenuation.\n",
 284         QuadraticAttenuationFieldId, QuadraticAttenuationFieldMask,
 285         false,
 286         (Field::SFDefaultFlags | Field::FStdAccess),
 287         static_cast<FieldEditMethodSig>(&LightChunk::editHandleQuadraticAttenuation),
 288         static_cast<FieldGetMethodSig >(&LightChunk::getHandleQuadraticAttenuation));
 289
 290     oType.addInitialDesc(pDesc);
 291
 292     pDesc = new SFWeakNodePtr::Description(
 293         SFWeakNodePtr::getClassType(),
 294         "beacon",
 295         "",
 296         BeaconFieldId, BeaconFieldMask,
 297         false,
 298         (Field::SFDefaultFlags | Field::FStdAccess),
 299         static_cast<FieldEditMethodSig>(&LightChunk::editHandleBeacon),
 300         static_cast<FieldGetMethodSig >(&LightChunk::getHandleBeacon));
 301
 302     oType.addInitialDesc(pDesc);
 303 }
 304
 305
 306 LightChunkBase::TypeObject LightChunkBase::_type(
 307     LightChunkBase::getClassname(),
 308     Inherited::getClassname(),
 309     "NULL",
 310     nsOSG, //Namespace
 311     reinterpret_cast<PrototypeCreateF>(&LightChunkBase::createEmptyLocal),
 312     LightChunk::initMethod,
 313     LightChunk::exitMethod,
 314     reinterpret_cast<InitalInsertDescFunc>(&LightChunk::classDescInserter),
 315     false,
 316     0,
 317     "<?xml version=\"1.0\" ?>\n"
 318     "\n"
 319     "<FieldContainer\n"
 320     "   name=\"LightChunk\"\n"
 321     "   parent=\"StateChunk\"\n"
 322     "   library=\"System\"\n"
 323     "   structure=\"concrete\"\n"
 324     "   pointerfieldtypes=\"both\"\n"
 325     "   systemcomponent=\"true\"\n"
 326     "   parentsystemcomponent=\"true\"\n"
 327     "   docGroupBase=\"GrpSystemState\"\n"
 328     ">\n"
 329     "See \\ref PageSystemLightChunk for a description.\n"
 330     "\n"
 331     "The light chunk contains the parameter set for a single light source. It's taken\n"
 332     "straight from the glLight() manpage.\n"
 333     "\n"
 334     "This chunk wraps glLight() (OSG::LightChunk::_sfAmbient,\n"
 335     "OSG::LightChunk::_sfDiffuse, OSG::LightChunk::_sfSpecular,\n"
 336     "OSG::LightChunk::_sfEmission, OSG::LightChunk::_sfPosition,\n"
 337     "OSG::LightChunk::_sfDirection, OSG::LightChunk::_sfExponent,\n"
 338     "OSG::LightChunk::_sfCutoff, OSG::LightChunk::_sfConstantAttenuation,\n"
 339     "OSG::LightChunk::_sfLinearAttenuation,\n"
 340     "OSG::LightChunk::_sfQuadraticAttenuation).\n"
 341     "\t<Field\n"
 342     "\t\tname=\"diffuse\"\n"
 343     "\t\ttype=\"Color4f\"\n"
 344     "\t\tcardinality=\"single\"\n"
 345     "\t\tvisibility=\"external\"\n"
 346     "\t\tdefaultValue=\"1.f,1.f,1.f,0.f\"\n"
 347     "\t>\n"
 348     "\tThe light's diffuse color.\n"
 349     "\t</Field>\n"
 350     "\t<Field\n"
 351     "\t\tname=\"ambient\"\n"
 352     "\t\ttype=\"Color4f\"\n"
 353     "\t\tcardinality=\"single\"\n"
 354     "\t\tvisibility=\"external\"\n"
 355     "\t\tdefaultValue=\".1f,.1f,.1f,0.f\"\n"
 356     "\t>\n"
 357     "\tThe light's ambient color.\n"
 358     "\t</Field>\n"
 359     "\t<Field\n"
 360     "\t\tname=\"specular\"\n"
 361     "\t\ttype=\"Color4f\"\n"
 362     "\t\tcardinality=\"single\"\n"
 363     "\t\tvisibility=\"external\"\n"
 364     "\t\tdefaultValue=\"1.f,1.f,1.f,0.f\"\n"
 365     "\t>\n"
 366     "\tThe light's specular color.\n"
 367     "\t</Field>\n"
 368     "\t<Field\n"
 369     "\t\tname=\"position\"\n"
 370     "\t\ttype=\"Vec4f\"\n"
 371     "\t\tcardinality=\"single\"\n"
 372     "\t\tvisibility=\"external\"\n"
 373     "\t\tdefaultValue=\"0.f,-1.f,0.f,0.f\"\n"
 374     "\t>\n"
 375     "\tThe light's position.\n"
 376     "\t</Field>\n"
 377     "\t<Field\n"
 378     "\t\tname=\"direction\"\n"
 379     "\t\ttype=\"Vec3f\"\n"
 380     "\t\tcardinality=\"single\"\n"
 381     "\t\tvisibility=\"external\"\n"
 382     "\t\tdefaultValue=\"0.f,0.f,1.f\"\n"
 383     "\t>\n"
 384     "\tThe light's direction (only for spotlights).\n"
 385     "\t</Field>\n"
 386     "\t<Field\n"
 387     "\t\tname=\"exponent\"\n"
 388     "\t\ttype=\"Real32\"\n"
 389     "\t\tcardinality=\"single\"\n"
 390     "\t\tvisibility=\"external\"\n"
 391     "\t\tdefaultValue=\"2.f\"\n"
 392     "\t>\n"
 393     "\tThe light's spotlight exponent.\n"
 394     "\t</Field>\n"
 395     "\t<Field\n"
 396     "\t\tname=\"cutoff\"\n"
 397     "\t\ttype=\"Real32\"\n"
 398     "\t\tcardinality=\"single\"\n"
 399     "\t\tvisibility=\"external\"\n"
 400     "\t\tdefaultValue=\"180.f\"\n"
 401     "\t>\n"
 402     "\tThe light's spotlight cutoff. As this chunk follows OpenGL conventions, this is the only angle in the system given in degrees.\n"
 403     "\t</Field>\n"
 404     "\t<Field\n"
 405     "\t\tname=\"constantAttenuation\"\n"
 406     "\t\ttype=\"Real32\"\n"
 407     "\t\tcardinality=\"single\"\n"
 408     "\t\tvisibility=\"external\"\n"
 409     "\t\tdefaultValue=\"1.f\"\n"
 410     "\t>\n"
 411     "\tThe light's constant attenuation.\n"
 412     "\t</Field>\n"
 413     "\t<Field\n"
 414     "\t\tname=\"linearAttenuation\"\n"
 415     "\t\ttype=\"Real32\"\n"
 416     "\t\tcardinality=\"single\"\n"
 417     "\t\tvisibility=\"external\"\n"
 418     "\t\tdefaultValue=\"0.f\"\n"
 419     "\t>\n"
 420     "\tThe light's linear attenuation.\n"
 421     "\t</Field>\n"
 422     "\t<Field\n"
 423     "\t\tname=\"quadraticAttenuation\"\n"
 424     "\t\ttype=\"Real32\"\n"
 425     "\t\tcardinality=\"single\"\n"
 426     "\t\tvisibility=\"external\"\n"
 427     "\t\tdefaultValue=\"0.f\"\n"
 428     "\t>\n"
 429     "\tThe light's quadratic attenuation.\n"
 430     "\t</Field>\n"
 431     "\t<Field\n"
 432     "\t\tname=\"beacon\"\n"
 433     "\t\ttype=\"Node\"\n"
 434     "        category=\"weakpointer\"\n"
 435     "\t\tcardinality=\"single\"\n"
 436     "\t\tvisibility=\"external\"\n"
 437     "\t\tdefaultValue=\"NULL\"\n"
 438     "\t\taccess=\"public\"\n"
 439     "\t>\n"
 440     "\t</Field>\n"
 441     "</FieldContainer>\n",
 442     "See \\ref PageSystemLightChunk for a description.\n"
 443     "\n"
 444     "The light chunk contains the parameter set for a single light source. It's taken\n"
 445     "straight from the glLight() manpage.\n"
 446     "\n"
 447     "This chunk wraps glLight() (OSG::LightChunk::_sfAmbient,\n"
 448     "OSG::LightChunk::_sfDiffuse, OSG::LightChunk::_sfSpecular,\n"
 449     "OSG::LightChunk::_sfEmission, OSG::LightChunk::_sfPosition,\n"
 450     "OSG::LightChunk::_sfDirection, OSG::LightChunk::_sfExponent,\n"
 451     "OSG::LightChunk::_sfCutoff, OSG::LightChunk::_sfConstantAttenuation,\n"
 452     "OSG::LightChunk::_sfLinearAttenuation,\n"
 453     "OSG::LightChunk::_sfQuadraticAttenuation).\n"
 454     );
 455
 456 /*------------------------------ get -----------------------------------*/
 457
 458 FieldContainerType &LightChunkBase::getType(void)
 459 {
 460     return _type;
 461 }
 462
 463 const FieldContainerType &LightChunkBase::getType(void) const
 464 {
 465     return _type;
 466 }
 467
 468 UInt32 LightChunkBase::getContainerSize(void) const
 469 {
 470     return sizeof(LightChunk);
 471 }
 472
 473 /*------------------------- decorator get ------------------------------*/
 474
 475
 476 SFColor4f *LightChunkBase::editSFDiffuse(void)
 477 {
 478     editSField(DiffuseFieldMask);
 479
 480     return &_sfDiffuse;
 481 }
 482
 483 const SFColor4f *LightChunkBase::getSFDiffuse(void) const
 484 {
 485     return &_sfDiffuse;
 486 }
 487
 488
 489 SFColor4f *LightChunkBase::editSFAmbient(void)
 490 {
 491     editSField(AmbientFieldMask);
 492
 493     return &_sfAmbient;
 494 }
 495
 496 const SFColor4f *LightChunkBase::getSFAmbient(void) const
 497 {
 498     return &_sfAmbient;
 499 }
 500
 501
 502 SFColor4f *LightChunkBase::editSFSpecular(void)
 503 {
 504     editSField(SpecularFieldMask);
 505
 506     return &_sfSpecular;
 507 }
 508
 509 const SFColor4f *LightChunkBase::getSFSpecular(void) const
 510 {
 511     return &_sfSpecular;
 512 }
 513
 514
 515 SFVec4f *LightChunkBase::editSFPosition(void)
 516 {
 517     editSField(PositionFieldMask);
 518
 519     return &_sfPosition;
 520 }
 521
 522 const SFVec4f *LightChunkBase::getSFPosition(void) const
 523 {
 524     return &_sfPosition;
 525 }
 526
 527
 528 SFVec3f *LightChunkBase::editSFDirection(void)
 529 {
 530     editSField(DirectionFieldMask);
 531
 532     return &_sfDirection;
 533 }
 534
 535 const SFVec3f *LightChunkBase::getSFDirection(void) const
 536 {
 537     return &_sfDirection;
 538 }
 539
 540
 541 SFReal32 *LightChunkBase::editSFExponent(void)
 542 {
 543     editSField(ExponentFieldMask);
 544
 545     return &_sfExponent;
 546 }
 547
 548 const SFReal32 *LightChunkBase::getSFExponent(void) const
 549 {
 550     return &_sfExponent;
 551 }
 552
 553
 554 SFReal32 *LightChunkBase::editSFCutoff(void)
 555 {
 556     editSField(CutoffFieldMask);
 557
 558     return &_sfCutoff;
 559 }
 560
 561 const SFReal32 *LightChunkBase::getSFCutoff(void) const
 562 {
 563     return &_sfCutoff;
 564 }
 565
 566
 567 SFReal32 *LightChunkBase::editSFConstantAttenuation(void)
 568 {
 569     editSField(ConstantAttenuationFieldMask);
 570
 571     return &_sfConstantAttenuation;
 572 }
 573
 574 const SFReal32 *LightChunkBase::getSFConstantAttenuation(void) const
 575 {
 576     return &_sfConstantAttenuation;
 577 }
 578
 579
 580 SFReal32 *LightChunkBase::editSFLinearAttenuation(void)
 581 {
 582     editSField(LinearAttenuationFieldMask);
 583
 584     return &_sfLinearAttenuation;
 585 }
 586
 587 const SFReal32 *LightChunkBase::getSFLinearAttenuation(void) const
 588 {
 589     return &_sfLinearAttenuation;
 590 }
 591
 592
 593 SFReal32 *LightChunkBase::editSFQuadraticAttenuation(void)
 594 {
 595     editSField(QuadraticAttenuationFieldMask);
 596
 597     return &_sfQuadraticAttenuation;
 598 }
 599
 600 const SFReal32 *LightChunkBase::getSFQuadraticAttenuation(void) const
 601 {
 602     return &_sfQuadraticAttenuation;
 603 }
 604
 605
 606 //! Get the LightChunk::_sfBeacon field.
 607 const SFWeakNodePtr *LightChunkBase::getSFBeacon(void) const
 608 {
 609     return &_sfBeacon;
 610 }
 611
 612 SFWeakNodePtr       *LightChunkBase::editSFBeacon         (void)
 613 {
 614     editSField(BeaconFieldMask);
 615
 616     return &_sfBeacon;
 617 }
 618
 619 //! Get the value of the LightChunk::_sfBeacon field.
 620 Node * LightChunkBase::getBeacon(void) const
 621 {
 622     return _sfBeacon.getValue();
 623 }
 624
 625 //! Set the value of the LightChunk::_sfBeacon field.
 626 void LightChunkBase::setBeacon(Node * const value)
 627 {
 628     editSField(BeaconFieldMask);
 629
 630     _sfBeacon.setValue(value);
 631 }
 632
 633
 634
 635
 636
 637
 638 /*------------------------------ access -----------------------------------*/
 639
 640 SizeT LightChunkBase::getBinSize(ConstFieldMaskArg whichField)
 641 {
 642     SizeT returnValue = Inherited::getBinSize(whichField);
 643
 644     if(FieldBits::NoField != (DiffuseFieldMask & whichField))
 645     {
 646         returnValue += _sfDiffuse.getBinSize();
 647     }
 648     if(FieldBits::NoField != (AmbientFieldMask & whichField))
 649     {
 650         returnValue += _sfAmbient.getBinSize();
 651     }
 652     if(FieldBits::NoField != (SpecularFieldMask & whichField))
 653     {
 654         returnValue += _sfSpecular.getBinSize();
 655     }
 656     if(FieldBits::NoField != (PositionFieldMask & whichField))
 657     {
 658         returnValue += _sfPosition.getBinSize();
 659     }
 660     if(FieldBits::NoField != (DirectionFieldMask & whichField))
 661     {
 662         returnValue += _sfDirection.getBinSize();
 663     }
 664     if(FieldBits::NoField != (ExponentFieldMask & whichField))
 665     {
 666         returnValue += _sfExponent.getBinSize();
 667     }
 668     if(FieldBits::NoField != (CutoffFieldMask & whichField))
 669     {
 670         returnValue += _sfCutoff.getBinSize();
 671     }
 672     if(FieldBits::NoField != (ConstantAttenuationFieldMask & whichField))
 673     {
 674         returnValue += _sfConstantAttenuation.getBinSize();
 675     }
 676     if(FieldBits::NoField != (LinearAttenuationFieldMask & whichField))
 677     {
 678         returnValue += _sfLinearAttenuation.getBinSize();
 679     }
 680     if(FieldBits::NoField != (QuadraticAttenuationFieldMask & whichField))
 681     {
 682         returnValue += _sfQuadraticAttenuation.getBinSize();
 683     }
 684     if(FieldBits::NoField != (BeaconFieldMask & whichField))
 685     {
 686         returnValue += _sfBeacon.getBinSize();
 687     }
 688
 689     return returnValue;
 690 }
 691
 692 void LightChunkBase::copyToBin(BinaryDataHandler &pMem,
 693                                   ConstFieldMaskArg  whichField)
 694 {
 695     Inherited::copyToBin(pMem, whichField);
 696
 697     if(FieldBits::NoField != (DiffuseFieldMask & whichField))
 698     {
 699         _sfDiffuse.copyToBin(pMem);
 700     }
 701     if(FieldBits::NoField != (AmbientFieldMask & whichField))
 702     {
 703         _sfAmbient.copyToBin(pMem);
 704     }
 705     if(FieldBits::NoField != (SpecularFieldMask & whichField))
 706     {
 707         _sfSpecular.copyToBin(pMem);
 708     }
 709     if(FieldBits::NoField != (PositionFieldMask & whichField))
 710     {
 711         _sfPosition.copyToBin(pMem);
 712     }
 713     if(FieldBits::NoField != (DirectionFieldMask & whichField))
 714     {
 715         _sfDirection.copyToBin(pMem);
 716     }
 717     if(FieldBits::NoField != (ExponentFieldMask & whichField))
 718     {
 719         _sfExponent.copyToBin(pMem);
 720     }
 721     if(FieldBits::NoField != (CutoffFieldMask & whichField))
 722     {
 723         _sfCutoff.copyToBin(pMem);
 724     }
 725     if(FieldBits::NoField != (ConstantAttenuationFieldMask & whichField))
 726     {
 727         _sfConstantAttenuation.copyToBin(pMem);
 728     }
 729     if(FieldBits::NoField != (LinearAttenuationFieldMask & whichField))
 730     {
 731         _sfLinearAttenuation.copyToBin(pMem);
 732     }
 733     if(FieldBits::NoField != (QuadraticAttenuationFieldMask & whichField))
 734     {
 735         _sfQuadraticAttenuation.copyToBin(pMem);
 736     }
 737     if(FieldBits::NoField != (BeaconFieldMask & whichField))
 738     {
 739         _sfBeacon.copyToBin(pMem);
 740     }
 741 }
 742
 743 void LightChunkBase::copyFromBin(BinaryDataHandler &pMem,
 744                                     ConstFieldMaskArg  whichField)
 745 {
 746     Inherited::copyFromBin(pMem, whichField);
 747
 748     if(FieldBits::NoField != (DiffuseFieldMask & whichField))
 749     {
 750         editSField(DiffuseFieldMask);
 751         _sfDiffuse.copyFromBin(pMem);
 752     }
 753     if(FieldBits::NoField != (AmbientFieldMask & whichField))
 754     {
 755         editSField(AmbientFieldMask);
 756         _sfAmbient.copyFromBin(pMem);
 757     }
 758     if(FieldBits::NoField != (SpecularFieldMask & whichField))
 759     {
 760         editSField(SpecularFieldMask);
 761         _sfSpecular.copyFromBin(pMem);
 762     }
 763     if(FieldBits::NoField != (PositionFieldMask & whichField))
 764     {
 765         editSField(PositionFieldMask);
 766         _sfPosition.copyFromBin(pMem);
 767     }
 768     if(FieldBits::NoField != (DirectionFieldMask & whichField))
 769     {
 770         editSField(DirectionFieldMask);
 771         _sfDirection.copyFromBin(pMem);
 772     }
 773     if(FieldBits::NoField != (ExponentFieldMask & whichField))
 774     {
 775         editSField(ExponentFieldMask);
 776         _sfExponent.copyFromBin(pMem);
 777     }
 778     if(FieldBits::NoField != (CutoffFieldMask & whichField))
 779     {
 780         editSField(CutoffFieldMask);
 781         _sfCutoff.copyFromBin(pMem);
 782     }
 783     if(FieldBits::NoField != (ConstantAttenuationFieldMask & whichField))
 784     {
 785         editSField(ConstantAttenuationFieldMask);
 786         _sfConstantAttenuation.copyFromBin(pMem);
 787     }
 788     if(FieldBits::NoField != (LinearAttenuationFieldMask & whichField))
 789     {
 790         editSField(LinearAttenuationFieldMask);
 791         _sfLinearAttenuation.copyFromBin(pMem);
 792     }
 793     if(FieldBits::NoField != (QuadraticAttenuationFieldMask & whichField))
 794     {
 795         editSField(QuadraticAttenuationFieldMask);
 796         _sfQuadraticAttenuation.copyFromBin(pMem);
 797     }
 798     if(FieldBits::NoField != (BeaconFieldMask & whichField))
 799     {
 800         editSField(BeaconFieldMask);
 801         _sfBeacon.copyFromBin(pMem);
 802     }
 803 }
 804
 805 //! create a new instance of the class
 806 LightChunkTransitPtr LightChunkBase::createLocal(BitVector bFlags)
 807 {
 808     LightChunkTransitPtr fc;
 809
 810     if(getClassType().getPrototype() != NULL)
 811     {
 812         FieldContainerTransitPtr tmpPtr =
 813             getClassType().getPrototype()-> shallowCopyLocal(bFlags);
 814
 815         fc = dynamic_pointer_cast<LightChunk>(tmpPtr);
 816     }
 817
 818     return fc;
 819 }
 820
 821 //! create a new instance of the class, copy the container flags
 822 LightChunkTransitPtr LightChunkBase::createDependent(BitVector bFlags)
 823 {
 824     LightChunkTransitPtr fc;
 825
 826     if(getClassType().getPrototype() != NULL)
 827     {
 828         FieldContainerTransitPtr tmpPtr =
 829             getClassType().getPrototype()-> shallowCopyDependent(bFlags);
 830
 831         fc = dynamic_pointer_cast<LightChunk>(tmpPtr);
 832     }
 833
 834     return fc;
 835 }
 836
 837 //! create a new instance of the class
 838 LightChunkTransitPtr LightChunkBase::create(void)
 839 {
 840     LightChunkTransitPtr fc;
 841
 842     if(getClassType().getPrototype() != NULL)
 843     {
 844         FieldContainerTransitPtr tmpPtr =
 845             getClassType().getPrototype()-> shallowCopy();
 846
 847         fc = dynamic_pointer_cast<LightChunk>(tmpPtr);
 848     }
 849
 850     return fc;
 851 }
 852
 853 LightChunk *LightChunkBase::createEmptyLocal(BitVector bFlags)
 854 {
 855     LightChunk *returnValue;
 856
 857     newPtr<LightChunk>(returnValue, bFlags);
 858
 859     returnValue->_pFieldFlags->_bNamespaceMask &= ~bFlags;
 860
 861     return returnValue;
 862 }
 863
 864 //! create an empty new instance of the class, do not copy the prototype
 865 LightChunk *LightChunkBase::createEmpty(void)
 866 {
 867     LightChunk *returnValue;
 868
 869     newPtr<LightChunk>(returnValue, Thread::getCurrentLocalFlags());
 870
 871     returnValue->_pFieldFlags->_bNamespaceMask &=
 872         ~Thread::getCurrentLocalFlags();
 873
 874     return returnValue;
 875 }
 876
 877
 878 FieldContainerTransitPtr LightChunkBase::shallowCopyLocal(
 879     BitVector bFlags) const
 880 {
 881     LightChunk *tmpPtr;
 882
 883     newPtr(tmpPtr, dynamic_cast<const LightChunk *>(this), bFlags);
 884
 885     FieldContainerTransitPtr returnValue(tmpPtr);
 886
 887     tmpPtr->_pFieldFlags->_bNamespaceMask &= ~bFlags;
 888
 889     return returnValue;
 890 }
 891
 892 FieldContainerTransitPtr LightChunkBase::shallowCopyDependent(
 893     BitVector bFlags) const
 894 {
 895     LightChunk *tmpPtr;
 896
 897     newPtr(tmpPtr, dynamic_cast<const LightChunk *>(this), ~bFlags);
 898
 899     FieldContainerTransitPtr returnValue(tmpPtr);
 900
 901     tmpPtr->_pFieldFlags->_bNamespaceMask = bFlags;
 902
 903     return returnValue;
 904 }
 905
 906 FieldContainerTransitPtr LightChunkBase::shallowCopy(void) const
 907 {
 908     LightChunk *tmpPtr;
 909
 910     newPtr(tmpPtr,
 911            dynamic_cast<const LightChunk *>(this),
 912            Thread::getCurrentLocalFlags());
 913
 914     tmpPtr->_pFieldFlags->_bNamespaceMask &= ~Thread::getCurrentLocalFlags();
 915
 916     FieldContainerTransitPtr returnValue(tmpPtr);
 917
 918     return returnValue;
 919 }
 920
 921
 922
 923
 924 /*------------------------- constructors ----------------------------------*/
 925
 926 LightChunkBase::LightChunkBase(void) :
 927     Inherited(),
 928     _sfDiffuse                (Color4f(1.f,1.f,1.f,0.f)),
 929     _sfAmbient                (Color4f(.1f,.1f,.1f,0.f)),
 930     _sfSpecular               (Color4f(1.f,1.f,1.f,0.f)),
 931     _sfPosition               (Vec4f(0.f,-1.f,0.f,0.f)),
 932     _sfDirection              (Vec3f(0.f,0.f,1.f)),
 933     _sfExponent               (Real32(2.f)),
 934     _sfCutoff                 (Real32(180.f)),
 935     _sfConstantAttenuation    (Real32(1.f)),
 936     _sfLinearAttenuation      (Real32(0.f)),
 937     _sfQuadraticAttenuation   (Real32(0.f)),
 938     _sfBeacon                 (NULL)
 939 {
 940 }
 941
 942 LightChunkBase::LightChunkBase(const LightChunkBase &source) :
 943     Inherited(source),
 944     _sfDiffuse                (source._sfDiffuse                ),
 945     _sfAmbient                (source._sfAmbient                ),
 946     _sfSpecular               (source._sfSpecular               ),
 947     _sfPosition               (source._sfPosition               ),
 948     _sfDirection              (source._sfDirection              ),
 949     _sfExponent               (source._sfExponent               ),
 950     _sfCutoff                 (source._sfCutoff                 ),
 951     _sfConstantAttenuation    (source._sfConstantAttenuation    ),
 952     _sfLinearAttenuation      (source._sfLinearAttenuation      ),
 953     _sfQuadraticAttenuation   (source._sfQuadraticAttenuation   ),
 954     _sfBeacon                 (NULL)
 955 {
 956 }
 957
 958
 959 /*-------------------------- destructors ----------------------------------*/
 960
 961 LightChunkBase::~LightChunkBase(void)
 962 {
 963 }
 964
 965 void LightChunkBase::onCreate(const LightChunk *source)
 966 {
 967     Inherited::onCreate(source);
 968
 969     if(source != NULL)
 970     {
 971         LightChunk *pThis = static_cast<LightChunk *>(this);
 972
 973         pThis->setBeacon(source->getBeacon());
 974     }
 975 }
 976
 977 GetFieldHandlePtr LightChunkBase::getHandleDiffuse         (void) const
 978 {
 979     SFColor4f::GetHandlePtr returnValue(
 980         new  SFColor4f::GetHandle(
 981              &_sfDiffuse,
 982              this->getType().getFieldDesc(DiffuseFieldId),
 983              const_cast<LightChunkBase *>(this)));
 984
 985     return returnValue;
 986 }
 987
 988 EditFieldHandlePtr LightChunkBase::editHandleDiffuse        (void)
 989 {
 990     SFColor4f::EditHandlePtr returnValue(
 991         new  SFColor4f::EditHandle(
 992              &_sfDiffuse,
 993              this->getType().getFieldDesc(DiffuseFieldId),
 994              this));
 995
 996
 997     editSField(DiffuseFieldMask);
 998
 999     return returnValue;
1000 }
1001
1002 GetFieldHandlePtr LightChunkBase::getHandleAmbient         (void) const
1003 {
1004     SFColor4f::GetHandlePtr returnValue(
1005         new  SFColor4f::GetHandle(
1006              &_sfAmbient,
1007              this->getType().getFieldDesc(AmbientFieldId),
1008              const_cast<LightChunkBase *>(this)));
1009
1010     return returnValue;
1011 }
1012
1013 EditFieldHandlePtr LightChunkBase::editHandleAmbient        (void)
1014 {
1015     SFColor4f::EditHandlePtr returnValue(
1016         new  SFColor4f::EditHandle(
1017              &_sfAmbient,
1018              this->getType().getFieldDesc(AmbientFieldId),
1019              this));
1020
1021
1022     editSField(AmbientFieldMask);
1023
1024     return returnValue;
1025 }
1026
1027 GetFieldHandlePtr LightChunkBase::getHandleSpecular        (void) const
1028 {
1029     SFColor4f::GetHandlePtr returnValue(
1030         new  SFColor4f::GetHandle(
1031              &_sfSpecular,
1032              this->getType().getFieldDesc(SpecularFieldId),
1033              const_cast<LightChunkBase *>(this)));
1034
1035     return returnValue;
1036 }
1037
1038 EditFieldHandlePtr LightChunkBase::editHandleSpecular       (void)
1039 {
1040     SFColor4f::EditHandlePtr returnValue(
1041         new  SFColor4f::EditHandle(
1042              &_sfSpecular,
1043              this->getType().getFieldDesc(SpecularFieldId),
1044              this));
1045
1046
1047     editSField(SpecularFieldMask);
1048
1049     return returnValue;
1050 }
1051
1052 GetFieldHandlePtr LightChunkBase::getHandlePosition        (void) const
1053 {
1054     SFVec4f::GetHandlePtr returnValue(
1055         new  SFVec4f::GetHandle(
1056              &_sfPosition,
1057              this->getType().getFieldDesc(PositionFieldId),
1058              const_cast<LightChunkBase *>(this)));
1059
1060     return returnValue;
1061 }
1062
1063 EditFieldHandlePtr LightChunkBase::editHandlePosition       (void)
1064 {
1065     SFVec4f::EditHandlePtr returnValue(
1066         new  SFVec4f::EditHandle(
1067              &_sfPosition,
1068              this->getType().getFieldDesc(PositionFieldId),
1069              this));
1070
1071
1072     editSField(PositionFieldMask);
1073
1074     return returnValue;
1075 }
1076
1077 GetFieldHandlePtr LightChunkBase::getHandleDirection       (void) const
1078 {
1079     SFVec3f::GetHandlePtr returnValue(
1080         new  SFVec3f::GetHandle(
1081              &_sfDirection,
1082              this->getType().getFieldDesc(DirectionFieldId),
1083              const_cast<LightChunkBase *>(this)));
1084
1085     return returnValue;
1086 }
1087
1088 EditFieldHandlePtr LightChunkBase::editHandleDirection      (void)
1089 {
1090     SFVec3f::EditHandlePtr returnValue(
1091         new  SFVec3f::EditHandle(
1092              &_sfDirection,
1093              this->getType().getFieldDesc(DirectionFieldId),
1094              this));
1095
1096
1097     editSField(DirectionFieldMask);
1098
1099     return returnValue;
1100 }
1101
1102 GetFieldHandlePtr LightChunkBase::getHandleExponent        (void) const
1103 {
1104     SFReal32::GetHandlePtr returnValue(
1105         new  SFReal32::GetHandle(
1106              &_sfExponent,
1107              this->getType().getFieldDesc(ExponentFieldId),
1108              const_cast<LightChunkBase *>(this)));
1109
1110     return returnValue;
1111 }
1112
1113 EditFieldHandlePtr LightChunkBase::editHandleExponent       (void)
1114 {
1115     SFReal32::EditHandlePtr returnValue(
1116         new  SFReal32::EditHandle(
1117              &_sfExponent,
1118              this->getType().getFieldDesc(ExponentFieldId),
1119              this));
1120
1121
1122     editSField(ExponentFieldMask);
1123
1124     return returnValue;
1125 }
1126
1127 GetFieldHandlePtr LightChunkBase::getHandleCutoff          (void) const
1128 {
1129     SFReal32::GetHandlePtr returnValue(
1130         new  SFReal32::GetHandle(
1131              &_sfCutoff,
1132              this->getType().getFieldDesc(CutoffFieldId),
1133              const_cast<LightChunkBase *>(this)));
1134
1135     return returnValue;
1136 }
1137
1138 EditFieldHandlePtr LightChunkBase::editHandleCutoff         (void)
1139 {
1140     SFReal32::EditHandlePtr returnValue(
1141         new  SFReal32::EditHandle(
1142              &_sfCutoff,
1143              this->getType().getFieldDesc(CutoffFieldId),
1144              this));
1145
1146
1147     editSField(CutoffFieldMask);
1148
1149     return returnValue;
1150 }
1151
1152 GetFieldHandlePtr LightChunkBase::getHandleConstantAttenuation (void) const
1153 {
1154     SFReal32::GetHandlePtr returnValue(
1155         new  SFReal32::GetHandle(
1156              &_sfConstantAttenuation,
1157              this->getType().getFieldDesc(ConstantAttenuationFieldId),
1158              const_cast<LightChunkBase *>(this)));
1159
1160     return returnValue;
1161 }
1162
1163 EditFieldHandlePtr LightChunkBase::editHandleConstantAttenuation(void)
1164 {
1165     SFReal32::EditHandlePtr returnValue(
1166         new  SFReal32::EditHandle(
1167              &_sfConstantAttenuation,
1168              this->getType().getFieldDesc(ConstantAttenuationFieldId),
1169              this));
1170
1171
1172     editSField(ConstantAttenuationFieldMask);
1173
1174     return returnValue;
1175 }
1176
1177 GetFieldHandlePtr LightChunkBase::getHandleLinearAttenuation (void) const
1178 {
1179     SFReal32::GetHandlePtr returnValue(
1180         new  SFReal32::GetHandle(
1181              &_sfLinearAttenuation,
1182              this->getType().getFieldDesc(LinearAttenuationFieldId),
1183              const_cast<LightChunkBase *>(this)));
1184
1185     return returnValue;
1186 }
1187
1188 EditFieldHandlePtr LightChunkBase::editHandleLinearAttenuation(void)
1189 {
1190     SFReal32::EditHandlePtr returnValue(
1191         new  SFReal32::EditHandle(
1192              &_sfLinearAttenuation,
1193              this->getType().getFieldDesc(LinearAttenuationFieldId),
1194              this));
1195
1196
1197     editSField(LinearAttenuationFieldMask);
1198
1199     return returnValue;
1200 }
1201
1202 GetFieldHandlePtr LightChunkBase::getHandleQuadraticAttenuation (void) const
1203 {
1204     SFReal32::GetHandlePtr returnValue(
1205         new  SFReal32::GetHandle(
1206              &_sfQuadraticAttenuation,
1207              this->getType().getFieldDesc(QuadraticAttenuationFieldId),
1208              const_cast<LightChunkBase *>(this)));
1209
1210     return returnValue;
1211 }
1212
1213 EditFieldHandlePtr LightChunkBase::editHandleQuadraticAttenuation(void)
1214 {
1215     SFReal32::EditHandlePtr returnValue(
1216         new  SFReal32::EditHandle(
1217              &_sfQuadraticAttenuation,
1218              this->getType().getFieldDesc(QuadraticAttenuationFieldId),
1219              this));
1220
1221
1222     editSField(QuadraticAttenuationFieldMask);
1223
1224     return returnValue;
1225 }
1226
1227 GetFieldHandlePtr LightChunkBase::getHandleBeacon          (void) const
1228 {
1229     SFWeakNodePtr::GetHandlePtr returnValue(
1230         new  SFWeakNodePtr::GetHandle(
1231              &_sfBeacon,
1232              this->getType().getFieldDesc(BeaconFieldId),
1233              const_cast<LightChunkBase *>(this)));
1234
1235     return returnValue;
1236 }
1237
1238 EditFieldHandlePtr LightChunkBase::editHandleBeacon         (void)
1239 {
1240     SFWeakNodePtr::EditHandlePtr returnValue(
1241         new  SFWeakNodePtr::EditHandle(
1242              &_sfBeacon,
1243              this->getType().getFieldDesc(BeaconFieldId),
1244              this));
1245
1246     returnValue->setSetMethod(
1247         boost::bind(&LightChunk::setBeacon,
1248                     static_cast<LightChunk *>(this), _1));
1249
1250     editSField(BeaconFieldMask);
1251
1252     return returnValue;
1253 }
1254
1255
1256 #ifdef OSG_MT_CPTR_ASPECT
1257 void LightChunkBase::execSyncV(      FieldContainer    &oFrom,
1258                                         ConstFieldMaskArg  whichField,
1259                                         AspectOffsetStore &oOffsets,
1260                                         ConstFieldMaskArg  syncMode,
1261                                   const UInt32             uiSyncInfo)
1262 {
1263     LightChunk *pThis = static_cast<LightChunk *>(this);
1264
1265     pThis->execSync(static_cast<LightChunk *>(&oFrom),
1266                     whichField,
1267                     oOffsets,
1268                     syncMode,
1269                     uiSyncInfo);
1270 }
1271 #endif
1272
1273
1274 #ifdef OSG_MT_CPTR_ASPECT
1275 FieldContainer *LightChunkBase::createAspectCopy(
1276     const FieldContainer *pRefAspect) const
1277 {
1278     LightChunk *returnValue;
1279
1280     newAspectCopy(returnValue,
1281                   dynamic_cast<const LightChunk *>(pRefAspect),
1282                   dynamic_cast<const LightChunk *>(this));
1283
1284     return returnValue;
1285 }
1286 #endif
1287
1288 void LightChunkBase::resolveLinks(void)
1289 {
1290     Inherited::resolveLinks();
1291
1292     static_cast<LightChunk *>(this)->setBeacon(NULL);
1293
1294
1295 }
1296
1297
1298 OSG_END_NAMESPACE