Source/System/State/Base/OSGMultiLightChunkBase.inl

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *               Copyright (C) 2000-2013 by the OpenSG Forum                 *
   6  *                                                                           *
   7  * contact: dirk@opensg.org, gerrit.voss@vossg.org, carsten_neumann@gmx.net  *
   8  *                                                                           *
   9 \*---------------------------------------------------------------------------*/
  10 /*---------------------------------------------------------------------------*\
  11  *                                License                                    *
  12  *                                                                           *
  13  * This library is free software; you can redistribute it and/or modify it   *
  14  * under the terms of the GNU Library General Public License as published    *
  15  * by the Free Software Foundation, version 2.                               *
  16  *                                                                           *
  17  * This library is distributed in the hope that it will be useful, but       *
  18  * WITHOUT ANY WARRANTY; without even the implied warranty of                *
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
  20  * Library General Public License for more details.                          *
  21  *                                                                           *
  22  * You should have received a copy of the GNU Library General Public         *
  23  * License along with this library; if not, write to the Free Software       *
  24  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                 *
  25  *                                                                           *
  26 \*---------------------------------------------------------------------------*/
  27 /*---------------------------------------------------------------------------*\
  28  *                                Changes                                    *
  29  *                                                                           *
  30  *                                                                           *
  31  *                                                                           *
  32  *                                                                           *
  33  *                                                                           *
  34  *                                                                           *
  35 \*---------------------------------------------------------------------------*/
  36
  37 /*****************************************************************************\
  38  *****************************************************************************
  39  **                                                                         **
  40  **                  This file is automatically generated.                  **
  41  **                                                                         **
  42  **          Any changes made to this file WILL be lost when it is          **
  43  **           regenerated, which can become necessary at any time.          **
  44  **                                                                         **
  45  **     Do not change this file, changes should be done in the derived      **
  46  **     class MultiLightChunk!
  47  **                                                                         **
  48  *****************************************************************************
  49 \*****************************************************************************/
  50
  51 OSG_BEGIN_NAMESPACE
  52
  53
  54
  55 //! access the type of the class
  56 inline
  57 OSG::FieldContainerType &MultiLightChunkBase::getClassType(void)
  58 {
  59     return _type;
  60 }
  61
  62 //! access the numerical type of the class
  63 inline
  64 OSG::UInt32 MultiLightChunkBase::getClassTypeId(void)
  65 {
  66     return _type.getId();
  67 }
  68
  69 inline
  70 OSG::UInt16 MultiLightChunkBase::getClassGroupId(void)
  71 {
  72     return _type.getGroupId();
  73 }
  74
  75 /*------------------------------ get -----------------------------------*/
  76
  77 //! Get the value of the MultiLightChunk::_sfHasWorldToLightSpaceMatrix field.
  78
  79 inline
  80 bool &MultiLightChunkBase::editHasWorldToLightSpaceMatrix(void)
  81 {
  82     editSField(HasWorldToLightSpaceMatrixFieldMask);
  83
  84     return _sfHasWorldToLightSpaceMatrix.getValue();
  85 }
  86
  87 //! Get the value of the MultiLightChunk::_sfHasWorldToLightSpaceMatrix field.
  88 inline
  89       bool  MultiLightChunkBase::getHasWorldToLightSpaceMatrix(void) const
  90 {
  91     return _sfHasWorldToLightSpaceMatrix.getValue();
  92 }
  93
  94 //! Set the value of the MultiLightChunk::_sfHasWorldToLightSpaceMatrix field.
  95 inline
  96 void MultiLightChunkBase::setHasWorldToLightSpaceMatrix(const bool value)
  97 {
  98     editSField(HasWorldToLightSpaceMatrixFieldMask);
  99
 100     _sfHasWorldToLightSpaceMatrix.setValue(value);
 101 }
 102 //! Get the value of the MultiLightChunk::_sfHasLightToWorldSpaceMatrix field.
 103
 104 inline
 105 bool &MultiLightChunkBase::editHasLightToWorldSpaceMatrix(void)
 106 {
 107     editSField(HasLightToWorldSpaceMatrixFieldMask);
 108
 109     return _sfHasLightToWorldSpaceMatrix.getValue();
 110 }
 111
 112 //! Get the value of the MultiLightChunk::_sfHasLightToWorldSpaceMatrix field.
 113 inline
 114       bool  MultiLightChunkBase::getHasLightToWorldSpaceMatrix(void) const
 115 {
 116     return _sfHasLightToWorldSpaceMatrix.getValue();
 117 }
 118
 119 //! Set the value of the MultiLightChunk::_sfHasLightToWorldSpaceMatrix field.
 120 inline
 121 void MultiLightChunkBase::setHasLightToWorldSpaceMatrix(const bool value)
 122 {
 123     editSField(HasLightToWorldSpaceMatrixFieldMask);
 124
 125     _sfHasLightToWorldSpaceMatrix.setValue(value);
 126 }
 127 //! Get the value of the MultiLightChunk::_sfHasEyeToLightSpaceMatrix field.
 128
 129 inline
 130 bool &MultiLightChunkBase::editHasEyeToLightSpaceMatrix(void)
 131 {
 132     editSField(HasEyeToLightSpaceMatrixFieldMask);
 133
 134     return _sfHasEyeToLightSpaceMatrix.getValue();
 135 }
 136
 137 //! Get the value of the MultiLightChunk::_sfHasEyeToLightSpaceMatrix field.
 138 inline
 139       bool  MultiLightChunkBase::getHasEyeToLightSpaceMatrix(void) const
 140 {
 141     return _sfHasEyeToLightSpaceMatrix.getValue();
 142 }
 143
 144 //! Set the value of the MultiLightChunk::_sfHasEyeToLightSpaceMatrix field.
 145 inline
 146 void MultiLightChunkBase::setHasEyeToLightSpaceMatrix(const bool value)
 147 {
 148     editSField(HasEyeToLightSpaceMatrixFieldMask);
 149
 150     _sfHasEyeToLightSpaceMatrix.setValue(value);
 151 }
 152 //! Get the value of the MultiLightChunk::_sfHasLightToEyeSpaceMatrix field.
 153
 154 inline
 155 bool &MultiLightChunkBase::editHasLightToEyeSpaceMatrix(void)
 156 {
 157     editSField(HasLightToEyeSpaceMatrixFieldMask);
 158
 159     return _sfHasLightToEyeSpaceMatrix.getValue();
 160 }
 161
 162 //! Get the value of the MultiLightChunk::_sfHasLightToEyeSpaceMatrix field.
 163 inline
 164       bool  MultiLightChunkBase::getHasLightToEyeSpaceMatrix(void) const
 165 {
 166     return _sfHasLightToEyeSpaceMatrix.getValue();
 167 }
 168
 169 //! Set the value of the MultiLightChunk::_sfHasLightToEyeSpaceMatrix field.
 170 inline
 171 void MultiLightChunkBase::setHasLightToEyeSpaceMatrix(const bool value)
 172 {
 173     editSField(HasLightToEyeSpaceMatrixFieldMask);
 174
 175     _sfHasLightToEyeSpaceMatrix.setValue(value);
 176 }
 177 //! Get the value of the MultiLightChunk::_sfHasLightPerspectiveMatrix field.
 178
 179 inline
 180 bool &MultiLightChunkBase::editHasLightPerspectiveMatrix(void)
 181 {
 182     editSField(HasLightPerspectiveMatrixFieldMask);
 183
 184     return _sfHasLightPerspectiveMatrix.getValue();
 185 }
 186
 187 //! Get the value of the MultiLightChunk::_sfHasLightPerspectiveMatrix field.
 188 inline
 189       bool  MultiLightChunkBase::getHasLightPerspectiveMatrix(void) const
 190 {
 191     return _sfHasLightPerspectiveMatrix.getValue();
 192 }
 193
 194 //! Set the value of the MultiLightChunk::_sfHasLightPerspectiveMatrix field.
 195 inline
 196 void MultiLightChunkBase::setHasLightPerspectiveMatrix(const bool value)
 197 {
 198     editSField(HasLightPerspectiveMatrixFieldMask);
 199
 200     _sfHasLightPerspectiveMatrix.setValue(value);
 201 }
 202 //! Get the value of the MultiLightChunk::_sfHasInvLightPerspectiveMatrix field.
 203
 204 inline
 205 bool &MultiLightChunkBase::editHasInvLightPerspectiveMatrix(void)
 206 {
 207     editSField(HasInvLightPerspectiveMatrixFieldMask);
 208
 209     return _sfHasInvLightPerspectiveMatrix.getValue();
 210 }
 211
 212 //! Get the value of the MultiLightChunk::_sfHasInvLightPerspectiveMatrix field.
 213 inline
 214       bool  MultiLightChunkBase::getHasInvLightPerspectiveMatrix(void) const
 215 {
 216     return _sfHasInvLightPerspectiveMatrix.getValue();
 217 }
 218
 219 //! Set the value of the MultiLightChunk::_sfHasInvLightPerspectiveMatrix field.
 220 inline
 221 void MultiLightChunkBase::setHasInvLightPerspectiveMatrix(const bool value)
 222 {
 223     editSField(HasInvLightPerspectiveMatrixFieldMask);
 224
 225     _sfHasInvLightPerspectiveMatrix.setValue(value);
 226 }
 227 //! Get the value of the MultiLightChunk::_sfHasColor field.
 228
 229 inline
 230 bool &MultiLightChunkBase::editHasColor(void)
 231 {
 232     editSField(HasColorFieldMask);
 233
 234     return _sfHasColor.getValue();
 235 }
 236
 237 //! Get the value of the MultiLightChunk::_sfHasColor field.
 238 inline
 239       bool  MultiLightChunkBase::getHasColor(void) const
 240 {
 241     return _sfHasColor.getValue();
 242 }
 243
 244 //! Set the value of the MultiLightChunk::_sfHasColor field.
 245 inline
 246 void MultiLightChunkBase::setHasColor(const bool value)
 247 {
 248     editSField(HasColorFieldMask);
 249
 250     _sfHasColor.setValue(value);
 251 }
 252 //! Get the value of the MultiLightChunk::_sfHasIntensity field.
 253
 254 inline
 255 bool &MultiLightChunkBase::editHasIntensity(void)
 256 {
 257     editSField(HasIntensityFieldMask);
 258
 259     return _sfHasIntensity.getValue();
 260 }
 261
 262 //! Get the value of the MultiLightChunk::_sfHasIntensity field.
 263 inline
 264       bool  MultiLightChunkBase::getHasIntensity(void) const
 265 {
 266     return _sfHasIntensity.getValue();
 267 }
 268
 269 //! Set the value of the MultiLightChunk::_sfHasIntensity field.
 270 inline
 271 void MultiLightChunkBase::setHasIntensity(const bool value)
 272 {
 273     editSField(HasIntensityFieldMask);
 274
 275     _sfHasIntensity.setValue(value);
 276 }
 277 //! Get the value of the MultiLightChunk::_sfHasSeparateIntensities field.
 278
 279 inline
 280 bool &MultiLightChunkBase::editHasSeparateIntensities(void)
 281 {
 282     editSField(HasSeparateIntensitiesFieldMask);
 283
 284     return _sfHasSeparateIntensities.getValue();
 285 }
 286
 287 //! Get the value of the MultiLightChunk::_sfHasSeparateIntensities field.
 288 inline
 289       bool  MultiLightChunkBase::getHasSeparateIntensities(void) const
 290 {
 291     return _sfHasSeparateIntensities.getValue();
 292 }
 293
 294 //! Set the value of the MultiLightChunk::_sfHasSeparateIntensities field.
 295 inline
 296 void MultiLightChunkBase::setHasSeparateIntensities(const bool value)
 297 {
 298     editSField(HasSeparateIntensitiesFieldMask);
 299
 300     _sfHasSeparateIntensities.setValue(value);
 301 }
 302 //! Get the value of the MultiLightChunk::_sfHasAttenuation field.
 303
 304 inline
 305 bool &MultiLightChunkBase::editHasAttenuation(void)
 306 {
 307     editSField(HasAttenuationFieldMask);
 308
 309     return _sfHasAttenuation.getValue();
 310 }
 311
 312 //! Get the value of the MultiLightChunk::_sfHasAttenuation field.
 313 inline
 314       bool  MultiLightChunkBase::getHasAttenuation(void) const
 315 {
 316     return _sfHasAttenuation.getValue();
 317 }
 318
 319 //! Set the value of the MultiLightChunk::_sfHasAttenuation field.
 320 inline
 321 void MultiLightChunkBase::setHasAttenuation(const bool value)
 322 {
 323     editSField(HasAttenuationFieldMask);
 324
 325     _sfHasAttenuation.setValue(value);
 326 }
 327 //! Get the value of the MultiLightChunk::_sfAutoCalcRanges field.
 328
 329 inline
 330 bool &MultiLightChunkBase::editAutoCalcRanges(void)
 331 {
 332     editSField(AutoCalcRangesFieldMask);
 333
 334     return _sfAutoCalcRanges.getValue();
 335 }
 336
 337 //! Get the value of the MultiLightChunk::_sfAutoCalcRanges field.
 338 inline
 339       bool  MultiLightChunkBase::getAutoCalcRanges(void) const
 340 {
 341     return _sfAutoCalcRanges.getValue();
 342 }
 343
 344 //! Set the value of the MultiLightChunk::_sfAutoCalcRanges field.
 345 inline
 346 void MultiLightChunkBase::setAutoCalcRanges(const bool value)
 347 {
 348     editSField(AutoCalcRangesFieldMask);
 349
 350     _sfAutoCalcRanges.setValue(value);
 351 }
 352 //! Get the value of the MultiLightChunk::_sfHasRangeCutOn field.
 353
 354 inline
 355 bool &MultiLightChunkBase::editHasRangeCutOn(void)
 356 {
 357     editSField(HasRangeCutOnFieldMask);
 358
 359     return _sfHasRangeCutOn.getValue();
 360 }
 361
 362 //! Get the value of the MultiLightChunk::_sfHasRangeCutOn field.
 363 inline
 364       bool  MultiLightChunkBase::getHasRangeCutOn(void) const
 365 {
 366     return _sfHasRangeCutOn.getValue();
 367 }
 368
 369 //! Set the value of the MultiLightChunk::_sfHasRangeCutOn field.
 370 inline
 371 void MultiLightChunkBase::setHasRangeCutOn(const bool value)
 372 {
 373     editSField(HasRangeCutOnFieldMask);
 374
 375     _sfHasRangeCutOn.setValue(value);
 376 }
 377 //! Get the value of the MultiLightChunk::_sfHasRangeCutOff field.
 378
 379 inline
 380 bool &MultiLightChunkBase::editHasRangeCutOff(void)
 381 {
 382     editSField(HasRangeCutOffFieldMask);
 383
 384     return _sfHasRangeCutOff.getValue();
 385 }
 386
 387 //! Get the value of the MultiLightChunk::_sfHasRangeCutOff field.
 388 inline
 389       bool  MultiLightChunkBase::getHasRangeCutOff(void) const
 390 {
 391     return _sfHasRangeCutOff.getValue();
 392 }
 393
 394 //! Set the value of the MultiLightChunk::_sfHasRangeCutOff field.
 395 inline
 396 void MultiLightChunkBase::setHasRangeCutOff(const bool value)
 397 {
 398     editSField(HasRangeCutOffFieldMask);
 399
 400     _sfHasRangeCutOff.setValue(value);
 401 }
 402 //! Get the value of the MultiLightChunk::_sfHasRangeNearZone field.
 403
 404 inline
 405 bool &MultiLightChunkBase::editHasRangeNearZone(void)
 406 {
 407     editSField(HasRangeNearZoneFieldMask);
 408
 409     return _sfHasRangeNearZone.getValue();
 410 }
 411
 412 //! Get the value of the MultiLightChunk::_sfHasRangeNearZone field.
 413 inline
 414       bool  MultiLightChunkBase::getHasRangeNearZone(void) const
 415 {
 416     return _sfHasRangeNearZone.getValue();
 417 }
 418
 419 //! Set the value of the MultiLightChunk::_sfHasRangeNearZone field.
 420 inline
 421 void MultiLightChunkBase::setHasRangeNearZone(const bool value)
 422 {
 423     editSField(HasRangeNearZoneFieldMask);
 424
 425     _sfHasRangeNearZone.setValue(value);
 426 }
 427 //! Get the value of the MultiLightChunk::_sfHasRangeFarZone field.
 428
 429 inline
 430 bool &MultiLightChunkBase::editHasRangeFarZone(void)
 431 {
 432     editSField(HasRangeFarZoneFieldMask);
 433
 434     return _sfHasRangeFarZone.getValue();
 435 }
 436
 437 //! Get the value of the MultiLightChunk::_sfHasRangeFarZone field.
 438 inline
 439       bool  MultiLightChunkBase::getHasRangeFarZone(void) const
 440 {
 441     return _sfHasRangeFarZone.getValue();
 442 }
 443
 444 //! Set the value of the MultiLightChunk::_sfHasRangeFarZone field.
 445 inline
 446 void MultiLightChunkBase::setHasRangeFarZone(const bool value)
 447 {
 448     editSField(HasRangeFarZoneFieldMask);
 449
 450     _sfHasRangeFarZone.setValue(value);
 451 }
 452 //! Get the value of the MultiLightChunk::_sfHasCosSpotlightAngle field.
 453
 454 inline
 455 bool &MultiLightChunkBase::editHasCosSpotlightAngle(void)
 456 {
 457     editSField(HasCosSpotlightAngleFieldMask);
 458
 459     return _sfHasCosSpotlightAngle.getValue();
 460 }
 461
 462 //! Get the value of the MultiLightChunk::_sfHasCosSpotlightAngle field.
 463 inline
 464       bool  MultiLightChunkBase::getHasCosSpotlightAngle(void) const
 465 {
 466     return _sfHasCosSpotlightAngle.getValue();
 467 }
 468
 469 //! Set the value of the MultiLightChunk::_sfHasCosSpotlightAngle field.
 470 inline
 471 void MultiLightChunkBase::setHasCosSpotlightAngle(const bool value)
 472 {
 473     editSField(HasCosSpotlightAngleFieldMask);
 474
 475     _sfHasCosSpotlightAngle.setValue(value);
 476 }
 477 //! Get the value of the MultiLightChunk::_sfHasSpotlightAngle field.
 478
 479 inline
 480 bool &MultiLightChunkBase::editHasSpotlightAngle(void)
 481 {
 482     editSField(HasSpotlightAngleFieldMask);
 483
 484     return _sfHasSpotlightAngle.getValue();
 485 }
 486
 487 //! Get the value of the MultiLightChunk::_sfHasSpotlightAngle field.
 488 inline
 489       bool  MultiLightChunkBase::getHasSpotlightAngle(void) const
 490 {
 491     return _sfHasSpotlightAngle.getValue();
 492 }
 493
 494 //! Set the value of the MultiLightChunk::_sfHasSpotlightAngle field.
 495 inline
 496 void MultiLightChunkBase::setHasSpotlightAngle(const bool value)
 497 {
 498     editSField(HasSpotlightAngleFieldMask);
 499
 500     _sfHasSpotlightAngle.setValue(value);
 501 }
 502 //! Get the value of the MultiLightChunk::_sfHasSpotExponent field.
 503
 504 inline
 505 bool &MultiLightChunkBase::editHasSpotExponent(void)
 506 {
 507     editSField(HasSpotExponentFieldMask);
 508
 509     return _sfHasSpotExponent.getValue();
 510 }
 511
 512 //! Get the value of the MultiLightChunk::_sfHasSpotExponent field.
 513 inline
 514       bool  MultiLightChunkBase::getHasSpotExponent(void) const
 515 {
 516     return _sfHasSpotExponent.getValue();
 517 }
 518
 519 //! Set the value of the MultiLightChunk::_sfHasSpotExponent field.
 520 inline
 521 void MultiLightChunkBase::setHasSpotExponent(const bool value)
 522 {
 523     editSField(HasSpotExponentFieldMask);
 524
 525     _sfHasSpotExponent.setValue(value);
 526 }
 527 //! Get the value of the MultiLightChunk::_sfHasCinemaLight field.
 528
 529 inline
 530 bool &MultiLightChunkBase::editHasCinemaLight(void)
 531 {
 532     editSField(HasCinemaLightFieldMask);
 533
 534     return _sfHasCinemaLight.getValue();
 535 }
 536
 537 //! Get the value of the MultiLightChunk::_sfHasCinemaLight field.
 538 inline
 539       bool  MultiLightChunkBase::getHasCinemaLight(void) const
 540 {
 541     return _sfHasCinemaLight.getValue();
 542 }
 543
 544 //! Set the value of the MultiLightChunk::_sfHasCinemaLight field.
 545 inline
 546 void MultiLightChunkBase::setHasCinemaLight(const bool value)
 547 {
 548     editSField(HasCinemaLightFieldMask);
 549
 550     _sfHasCinemaLight.setValue(value);
 551 }
 552 //! Get the value of the MultiLightChunk::_sfEyeSpace field.
 553
 554 inline
 555 bool &MultiLightChunkBase::editEyeSpace(void)
 556 {
 557     editSField(EyeSpaceFieldMask);
 558
 559     return _sfEyeSpace.getValue();
 560 }
 561
 562 //! Get the value of the MultiLightChunk::_sfEyeSpace field.
 563 inline
 564       bool  MultiLightChunkBase::getEyeSpace(void) const
 565 {
 566     return _sfEyeSpace.getValue();
 567 }
 568
 569 //! Set the value of the MultiLightChunk::_sfEyeSpace field.
 570 inline
 571 void MultiLightChunkBase::setEyeSpace(const bool value)
 572 {
 573     editSField(EyeSpaceFieldMask);
 574
 575     _sfEyeSpace.setValue(value);
 576 }
 577 //! Get the value of the MultiLightChunk::_sfLastCamNear field.
 578
 579 inline
 580 Real32 &MultiLightChunkBase::editLastCamNear(void)
 581 {
 582     editSField(LastCamNearFieldMask);
 583
 584     return _sfLastCamNear.getValue();
 585 }
 586
 587 //! Get the value of the MultiLightChunk::_sfLastCamNear field.
 588 inline
 589       Real32  MultiLightChunkBase::getLastCamNear(void) const
 590 {
 591     return _sfLastCamNear.getValue();
 592 }
 593
 594 //! Set the value of the MultiLightChunk::_sfLastCamNear field.
 595 inline
 596 void MultiLightChunkBase::setLastCamNear(const Real32 value)
 597 {
 598     editSField(LastCamNearFieldMask);
 599
 600     _sfLastCamNear.setValue(value);
 601 }
 602 //! Get the value of the MultiLightChunk::_sfLastCamFar field.
 603
 604 inline
 605 Real32 &MultiLightChunkBase::editLastCamFar(void)
 606 {
 607     editSField(LastCamFarFieldMask);
 608
 609     return _sfLastCamFar.getValue();
 610 }
 611
 612 //! Get the value of the MultiLightChunk::_sfLastCamFar field.
 613 inline
 614       Real32  MultiLightChunkBase::getLastCamFar(void) const
 615 {
 616     return _sfLastCamFar.getValue();
 617 }
 618
 619 //! Set the value of the MultiLightChunk::_sfLastCamFar field.
 620 inline
 621 void MultiLightChunkBase::setLastCamFar(const Real32 value)
 622 {
 623     editSField(LastCamFarFieldMask);
 624
 625     _sfLastCamFar.setValue(value);
 626 }
 627 //! Get the value of the MultiLightChunk::_sfLastCamToWorld field.
 628
 629 inline
 630 Matrix &MultiLightChunkBase::editLastCamToWorld(void)
 631 {
 632     editSField(LastCamToWorldFieldMask);
 633
 634     return _sfLastCamToWorld.getValue();
 635 }
 636
 637 //! Get the value of the MultiLightChunk::_sfLastCamToWorld field.
 638 inline
 639 const Matrix &MultiLightChunkBase::getLastCamToWorld(void) const
 640 {
 641     return _sfLastCamToWorld.getValue();
 642 }
 643
 644 //! Set the value of the MultiLightChunk::_sfLastCamToWorld field.
 645 inline
 646 void MultiLightChunkBase::setLastCamToWorld(const Matrix &value)
 647 {
 648     editSField(LastCamToWorldFieldMask);
 649
 650     _sfLastCamToWorld.setValue(value);
 651 }
 652 //! Get the value of the MultiLightChunk::_sfLightBlockName field.
 653
 654 inline
 655 std::string &MultiLightChunkBase::editLightBlockName(void)
 656 {
 657     editSField(LightBlockNameFieldMask);
 658
 659     return _sfLightBlockName.getValue();
 660 }
 661
 662 //! Get the value of the MultiLightChunk::_sfLightBlockName field.
 663 inline
 664 const std::string &MultiLightChunkBase::getLightBlockName(void) const
 665 {
 666     return _sfLightBlockName.getValue();
 667 }
 668
 669 //! Set the value of the MultiLightChunk::_sfLightBlockName field.
 670 inline
 671 void MultiLightChunkBase::setLightBlockName(const std::string &value)
 672 {
 673     editSField(LightBlockNameFieldMask);
 674
 675     _sfLightBlockName.setValue(value);
 676 }
 677 //! Get the value of the MultiLightChunk::_sfLightVariableName field.
 678
 679 inline
 680 std::string &MultiLightChunkBase::editLightVariableName(void)
 681 {
 682     editSField(LightVariableNameFieldMask);
 683
 684     return _sfLightVariableName.getValue();
 685 }
 686
 687 //! Get the value of the MultiLightChunk::_sfLightVariableName field.
 688 inline
 689 const std::string &MultiLightChunkBase::getLightVariableName(void) const
 690 {
 691     return _sfLightVariableName.getValue();
 692 }
 693
 694 //! Set the value of the MultiLightChunk::_sfLightVariableName field.
 695 inline
 696 void MultiLightChunkBase::setLightVariableName(const std::string &value)
 697 {
 698     editSField(LightVariableNameFieldMask);
 699
 700     _sfLightVariableName.setValue(value);
 701 }
 702
 703 //! Get the value of the \a index element the MultiLightChunk::_mfPosition field.
 704 inline
 705 const Pnt3f &MultiLightChunkBase::getPosition(const UInt32 index) const
 706 {
 707     return _mfPosition[index];
 708 }
 709
 710 inline
 711 MFPnt3f            ::reference MultiLightChunkBase::editPosition(const UInt32 index)
 712 {
 713     editMField(PositionFieldMask, _mfPosition);
 714
 715     return _mfPosition[index];
 716 }
 717
 718 //! Get the value of the \a index element the MultiLightChunk::_mfDirection field.
 719 inline
 720 const Vec3f &MultiLightChunkBase::getDirection(const UInt32 index) const
 721 {
 722     return _mfDirection[index];
 723 }
 724
 725 inline
 726 MFVec3f            ::reference MultiLightChunkBase::editDirection(const UInt32 index)
 727 {
 728     editMField(DirectionFieldMask, _mfDirection);
 729
 730     return _mfDirection[index];
 731 }
 732
 733 //! Get the value of the \a index element the MultiLightChunk::_mfColor field.
 734 inline
 735 const Color3f &MultiLightChunkBase::getColor(const UInt32 index) const
 736 {
 737     return _mfColor[index];
 738 }
 739
 740 inline
 741 MFColor3f          ::reference MultiLightChunkBase::editColor(const UInt32 index)
 742 {
 743     editMField(ColorFieldMask, _mfColor);
 744
 745     return _mfColor[index];
 746 }
 747
 748 //! Get the value of the \a index element the MultiLightChunk::_mfIntensity field.
 749 inline
 750       Real32  MultiLightChunkBase::getIntensity(const UInt32 index) const
 751 {
 752     return _mfIntensity[index];
 753 }
 754
 755 inline
 756 MFReal32           ::reference MultiLightChunkBase::editIntensity(const UInt32 index)
 757 {
 758     editMField(IntensityFieldMask, _mfIntensity);
 759
 760     return _mfIntensity[index];
 761 }
 762
 763 //! Get the value of the \a index element the MultiLightChunk::_mfAmbientIntensity field.
 764 inline
 765 const Vec3f &MultiLightChunkBase::getAmbientIntensity(const UInt32 index) const
 766 {
 767     return _mfAmbientIntensity[index];
 768 }
 769
 770 inline
 771 MFVec3f            ::reference MultiLightChunkBase::editAmbientIntensity(const UInt32 index)
 772 {
 773     editMField(AmbientIntensityFieldMask, _mfAmbientIntensity);
 774
 775     return _mfAmbientIntensity[index];
 776 }
 777
 778 //! Get the value of the \a index element the MultiLightChunk::_mfDiffuseIntensity field.
 779 inline
 780 const Vec3f &MultiLightChunkBase::getDiffuseIntensity(const UInt32 index) const
 781 {
 782     return _mfDiffuseIntensity[index];
 783 }
 784
 785 inline
 786 MFVec3f            ::reference MultiLightChunkBase::editDiffuseIntensity(const UInt32 index)
 787 {
 788     editMField(DiffuseIntensityFieldMask, _mfDiffuseIntensity);
 789
 790     return _mfDiffuseIntensity[index];
 791 }
 792
 793 //! Get the value of the \a index element the MultiLightChunk::_mfSpecularIntensity field.
 794 inline
 795 const Vec3f &MultiLightChunkBase::getSpecularIntensity(const UInt32 index) const
 796 {
 797     return _mfSpecularIntensity[index];
 798 }
 799
 800 inline
 801 MFVec3f            ::reference MultiLightChunkBase::editSpecularIntensity(const UInt32 index)
 802 {
 803     editMField(SpecularIntensityFieldMask, _mfSpecularIntensity);
 804
 805     return _mfSpecularIntensity[index];
 806 }
 807
 808 //! Get the value of the \a index element the MultiLightChunk::_mfAttenuation field.
 809 inline
 810 const Vec3f &MultiLightChunkBase::getAttenuation(const UInt32 index) const
 811 {
 812     return _mfAttenuation[index];
 813 }
 814
 815 inline
 816 MFVec3f            ::reference MultiLightChunkBase::editAttenuation(const UInt32 index)
 817 {
 818     editMField(AttenuationFieldMask, _mfAttenuation);
 819
 820     return _mfAttenuation[index];
 821 }
 822
 823 //! Get the value of the \a index element the MultiLightChunk::_mfSpotlightAngle field.
 824 inline
 825       Real32  MultiLightChunkBase::getSpotlightAngle(const UInt32 index) const
 826 {
 827     return _mfSpotlightAngle[index];
 828 }
 829
 830 inline
 831 MFReal32           ::reference MultiLightChunkBase::editSpotlightAngle(const UInt32 index)
 832 {
 833     editMField(SpotlightAngleFieldMask, _mfSpotlightAngle);
 834
 835     return _mfSpotlightAngle[index];
 836 }
 837
 838 //! Get the value of the \a index element the MultiLightChunk::_mfSpotExponent field.
 839 inline
 840       Real32  MultiLightChunkBase::getSpotExponent(const UInt32 index) const
 841 {
 842     return _mfSpotExponent[index];
 843 }
 844
 845 inline
 846 MFReal32           ::reference MultiLightChunkBase::editSpotExponent(const UInt32 index)
 847 {
 848     editMField(SpotExponentFieldMask, _mfSpotExponent);
 849
 850     return _mfSpotExponent[index];
 851 }
 852
 853 //! Get the value of the \a index element the MultiLightChunk::_mfInnerSuperEllipsesWidth field.
 854 inline
 855       Real32  MultiLightChunkBase::getInnerSuperEllipsesWidth(const UInt32 index) const
 856 {
 857     return _mfInnerSuperEllipsesWidth[index];
 858 }
 859
 860 inline
 861 MFReal32           ::reference MultiLightChunkBase::editInnerSuperEllipsesWidth(const UInt32 index)
 862 {
 863     editMField(InnerSuperEllipsesWidthFieldMask, _mfInnerSuperEllipsesWidth);
 864
 865     return _mfInnerSuperEllipsesWidth[index];
 866 }
 867
 868 //! Get the value of the \a index element the MultiLightChunk::_mfInnerSuperEllipsesHeight field.
 869 inline
 870       Real32  MultiLightChunkBase::getInnerSuperEllipsesHeight(const UInt32 index) const
 871 {
 872     return _mfInnerSuperEllipsesHeight[index];
 873 }
 874
 875 inline
 876 MFReal32           ::reference MultiLightChunkBase::editInnerSuperEllipsesHeight(const UInt32 index)
 877 {
 878     editMField(InnerSuperEllipsesHeightFieldMask, _mfInnerSuperEllipsesHeight);
 879
 880     return _mfInnerSuperEllipsesHeight[index];
 881 }
 882
 883 //! Get the value of the \a index element the MultiLightChunk::_mfOuterSuperEllipsesWidth field.
 884 inline
 885       Real32  MultiLightChunkBase::getOuterSuperEllipsesWidth(const UInt32 index) const
 886 {
 887     return _mfOuterSuperEllipsesWidth[index];
 888 }
 889
 890 inline
 891 MFReal32           ::reference MultiLightChunkBase::editOuterSuperEllipsesWidth(const UInt32 index)
 892 {
 893     editMField(OuterSuperEllipsesWidthFieldMask, _mfOuterSuperEllipsesWidth);
 894
 895     return _mfOuterSuperEllipsesWidth[index];
 896 }
 897
 898 //! Get the value of the \a index element the MultiLightChunk::_mfOuterSuperEllipsesHeight field.
 899 inline
 900       Real32  MultiLightChunkBase::getOuterSuperEllipsesHeight(const UInt32 index) const
 901 {
 902     return _mfOuterSuperEllipsesHeight[index];
 903 }
 904
 905 inline
 906 MFReal32           ::reference MultiLightChunkBase::editOuterSuperEllipsesHeight(const UInt32 index)
 907 {
 908     editMField(OuterSuperEllipsesHeightFieldMask, _mfOuterSuperEllipsesHeight);
 909
 910     return _mfOuterSuperEllipsesHeight[index];
 911 }
 912
 913 //! Get the value of the \a index element the MultiLightChunk::_mfSuperEllipsesRoundness field.
 914 inline
 915       Real32  MultiLightChunkBase::getSuperEllipsesRoundness(const UInt32 index) const
 916 {
 917     return _mfSuperEllipsesRoundness[index];
 918 }
 919
 920 inline
 921 MFReal32           ::reference MultiLightChunkBase::editSuperEllipsesRoundness(const UInt32 index)
 922 {
 923     editMField(SuperEllipsesRoundnessFieldMask, _mfSuperEllipsesRoundness);
 924
 925     return _mfSuperEllipsesRoundness[index];
 926 }
 927
 928 //! Get the value of the \a index element the MultiLightChunk::_mfSuperEllipsesTwist field.
 929 inline
 930       Real32  MultiLightChunkBase::getSuperEllipsesTwist(const UInt32 index) const
 931 {
 932     return _mfSuperEllipsesTwist[index];
 933 }
 934
 935 inline
 936 MFReal32           ::reference MultiLightChunkBase::editSuperEllipsesTwist(const UInt32 index)
 937 {
 938     editMField(SuperEllipsesTwistFieldMask, _mfSuperEllipsesTwist);
 939
 940     return _mfSuperEllipsesTwist[index];
 941 }
 942
 943 //! Get the value of the \a index element the MultiLightChunk::_mfRangeCutOn field.
 944 inline
 945       Real32  MultiLightChunkBase::getRangeCutOn(const UInt32 index) const
 946 {
 947     return _mfRangeCutOn[index];
 948 }
 949
 950 inline
 951 MFReal32           ::reference MultiLightChunkBase::editRangeCutOn(const UInt32 index)
 952 {
 953     editMField(RangeCutOnFieldMask, _mfRangeCutOn);
 954
 955     return _mfRangeCutOn[index];
 956 }
 957
 958 //! Get the value of the \a index element the MultiLightChunk::_mfRangeCutOff field.
 959 inline
 960       Real32  MultiLightChunkBase::getRangeCutOff(const UInt32 index) const
 961 {
 962     return _mfRangeCutOff[index];
 963 }
 964
 965 inline
 966 MFReal32           ::reference MultiLightChunkBase::editRangeCutOff(const UInt32 index)
 967 {
 968     editMField(RangeCutOffFieldMask, _mfRangeCutOff);
 969
 970     return _mfRangeCutOff[index];
 971 }
 972
 973 //! Get the value of the \a index element the MultiLightChunk::_mfRangeNearZone field.
 974 inline
 975       Real32  MultiLightChunkBase::getRangeNearZone(const UInt32 index) const
 976 {
 977     return _mfRangeNearZone[index];
 978 }
 979
 980 inline
 981 MFReal32           ::reference MultiLightChunkBase::editRangeNearZone(const UInt32 index)
 982 {
 983     editMField(RangeNearZoneFieldMask, _mfRangeNearZone);
 984
 985     return _mfRangeNearZone[index];
 986 }
 987
 988 //! Get the value of the \a index element the MultiLightChunk::_mfRangeFarZone field.
 989 inline
 990       Real32  MultiLightChunkBase::getRangeFarZone(const UInt32 index) const
 991 {
 992     return _mfRangeFarZone[index];
 993 }
 994
 995 inline
 996 MFReal32           ::reference MultiLightChunkBase::editRangeFarZone(const UInt32 index)
 997 {
 998     editMField(RangeFarZoneFieldMask, _mfRangeFarZone);
 999
1000     return _mfRangeFarZone[index];
1001 }
1002
1003 //! Get the value of the \a index element the MultiLightChunk::_mfType field.
1004 inline
1005       UInt8  MultiLightChunkBase::getType(const UInt32 index) const
1006 {
1007     return _mfType[index];
1008 }
1009
1010 inline
1011 MFUInt8            ::reference MultiLightChunkBase::editType(const UInt32 index)
1012 {
1013     editMField(TypeFieldMask, _mfType);
1014
1015     return _mfType[index];
1016 }
1017
1018 //! Get the value of the \a index element the MultiLightChunk::_mfEnabled field.
1019 inline
1020       bool  MultiLightChunkBase::getEnabled(const UInt32 index) const
1021 {
1022     return _mfEnabled[index];
1023 }
1024
1025 inline
1026 MFBool             ::reference MultiLightChunkBase::editEnabled(const UInt32 index)
1027 {
1028     editMField(EnabledFieldMask, _mfEnabled);
1029
1030     return _mfEnabled[index];
1031 }
1032
1033
1034 //! Get the value of the \a index element the MultiLightChunk::_mfBeaconMatrix field.
1035 inline
1036 const Matrix &MultiLightChunkBase::getBeaconMatrix(const UInt32 index) const
1037 {
1038     return _mfBeaconMatrix[index];
1039 }
1040
1041 inline
1042 MFMatrix           ::reference MultiLightChunkBase::editBeaconMatrix(const UInt32 index)
1043 {
1044     editMField(BeaconMatrixFieldMask, _mfBeaconMatrix);
1045
1046     return _mfBeaconMatrix[index];
1047 }
1048
1049
1050 #ifdef OSG_MT_CPTR_ASPECT
1051 inline
1052 void MultiLightChunkBase::execSync (      MultiLightChunkBase *pFrom,
1053                                         ConstFieldMaskArg  whichField,
1054                                         AspectOffsetStore &oOffsets,
1055                                         ConstFieldMaskArg  syncMode,
1056                                   const UInt32             uiSyncInfo)
1057 {
1058     Inherited::execSync(pFrom, whichField, oOffsets, syncMode, uiSyncInfo);
1059
1060     if(FieldBits::NoField != (HasWorldToLightSpaceMatrixFieldMask & whichField))
1061         _sfHasWorldToLightSpaceMatrix.syncWith(pFrom->_sfHasWorldToLightSpaceMatrix);
1062
1063     if(FieldBits::NoField != (HasLightToWorldSpaceMatrixFieldMask & whichField))
1064         _sfHasLightToWorldSpaceMatrix.syncWith(pFrom->_sfHasLightToWorldSpaceMatrix);
1065
1066     if(FieldBits::NoField != (HasEyeToLightSpaceMatrixFieldMask & whichField))
1067         _sfHasEyeToLightSpaceMatrix.syncWith(pFrom->_sfHasEyeToLightSpaceMatrix);
1068
1069     if(FieldBits::NoField != (HasLightToEyeSpaceMatrixFieldMask & whichField))
1070         _sfHasLightToEyeSpaceMatrix.syncWith(pFrom->_sfHasLightToEyeSpaceMatrix);
1071
1072     if(FieldBits::NoField != (HasLightPerspectiveMatrixFieldMask & whichField))
1073         _sfHasLightPerspectiveMatrix.syncWith(pFrom->_sfHasLightPerspectiveMatrix);
1074
1075     if(FieldBits::NoField != (HasInvLightPerspectiveMatrixFieldMask & whichField))
1076         _sfHasInvLightPerspectiveMatrix.syncWith(pFrom->_sfHasInvLightPerspectiveMatrix);
1077
1078     if(FieldBits::NoField != (HasColorFieldMask & whichField))
1079         _sfHasColor.syncWith(pFrom->_sfHasColor);
1080
1081     if(FieldBits::NoField != (HasIntensityFieldMask & whichField))
1082         _sfHasIntensity.syncWith(pFrom->_sfHasIntensity);
1083
1084     if(FieldBits::NoField != (HasSeparateIntensitiesFieldMask & whichField))
1085         _sfHasSeparateIntensities.syncWith(pFrom->_sfHasSeparateIntensities);
1086
1087     if(FieldBits::NoField != (HasAttenuationFieldMask & whichField))
1088         _sfHasAttenuation.syncWith(pFrom->_sfHasAttenuation);
1089
1090     if(FieldBits::NoField != (AutoCalcRangesFieldMask & whichField))
1091         _sfAutoCalcRanges.syncWith(pFrom->_sfAutoCalcRanges);
1092
1093     if(FieldBits::NoField != (HasRangeCutOnFieldMask & whichField))
1094         _sfHasRangeCutOn.syncWith(pFrom->_sfHasRangeCutOn);
1095
1096     if(FieldBits::NoField != (HasRangeCutOffFieldMask & whichField))
1097         _sfHasRangeCutOff.syncWith(pFrom->_sfHasRangeCutOff);
1098
1099     if(FieldBits::NoField != (HasRangeNearZoneFieldMask & whichField))
1100         _sfHasRangeNearZone.syncWith(pFrom->_sfHasRangeNearZone);
1101
1102     if(FieldBits::NoField != (HasRangeFarZoneFieldMask & whichField))
1103         _sfHasRangeFarZone.syncWith(pFrom->_sfHasRangeFarZone);
1104
1105     if(FieldBits::NoField != (HasCosSpotlightAngleFieldMask & whichField))
1106         _sfHasCosSpotlightAngle.syncWith(pFrom->_sfHasCosSpotlightAngle);
1107
1108     if(FieldBits::NoField != (HasSpotlightAngleFieldMask & whichField))
1109         _sfHasSpotlightAngle.syncWith(pFrom->_sfHasSpotlightAngle);
1110
1111     if(FieldBits::NoField != (HasSpotExponentFieldMask & whichField))
1112         _sfHasSpotExponent.syncWith(pFrom->_sfHasSpotExponent);
1113
1114     if(FieldBits::NoField != (HasCinemaLightFieldMask & whichField))
1115         _sfHasCinemaLight.syncWith(pFrom->_sfHasCinemaLight);
1116
1117     if(FieldBits::NoField != (PositionFieldMask & whichField))
1118         _mfPosition.syncWith(pFrom->_mfPosition,
1119                                 syncMode,
1120                                 uiSyncInfo,
1121                                 oOffsets);
1122
1123     if(FieldBits::NoField != (DirectionFieldMask & whichField))
1124         _mfDirection.syncWith(pFrom->_mfDirection,
1125                                 syncMode,
1126                                 uiSyncInfo,
1127                                 oOffsets);
1128
1129     if(FieldBits::NoField != (ColorFieldMask & whichField))
1130         _mfColor.syncWith(pFrom->_mfColor,
1131                                 syncMode,
1132                                 uiSyncInfo,
1133                                 oOffsets);
1134
1135     if(FieldBits::NoField != (IntensityFieldMask & whichField))
1136         _mfIntensity.syncWith(pFrom->_mfIntensity,
1137                                 syncMode,
1138                                 uiSyncInfo,
1139                                 oOffsets);
1140
1141     if(FieldBits::NoField != (AmbientIntensityFieldMask & whichField))
1142         _mfAmbientIntensity.syncWith(pFrom->_mfAmbientIntensity,
1143                                 syncMode,
1144                                 uiSyncInfo,
1145                                 oOffsets);
1146
1147     if(FieldBits::NoField != (DiffuseIntensityFieldMask & whichField))
1148         _mfDiffuseIntensity.syncWith(pFrom->_mfDiffuseIntensity,
1149                                 syncMode,
1150                                 uiSyncInfo,
1151                                 oOffsets);
1152
1153     if(FieldBits::NoField != (SpecularIntensityFieldMask & whichField))
1154         _mfSpecularIntensity.syncWith(pFrom->_mfSpecularIntensity,
1155                                 syncMode,
1156                                 uiSyncInfo,
1157                                 oOffsets);
1158
1159     if(FieldBits::NoField != (AttenuationFieldMask & whichField))
1160         _mfAttenuation.syncWith(pFrom->_mfAttenuation,
1161                                 syncMode,
1162                                 uiSyncInfo,
1163                                 oOffsets);
1164
1165     if(FieldBits::NoField != (SpotlightAngleFieldMask & whichField))
1166         _mfSpotlightAngle.syncWith(pFrom->_mfSpotlightAngle,
1167                                 syncMode,
1168                                 uiSyncInfo,
1169                                 oOffsets);
1170
1171     if(FieldBits::NoField != (SpotExponentFieldMask & whichField))
1172         _mfSpotExponent.syncWith(pFrom->_mfSpotExponent,
1173                                 syncMode,
1174                                 uiSyncInfo,
1175                                 oOffsets);
1176
1177     if(FieldBits::NoField != (InnerSuperEllipsesWidthFieldMask & whichField))
1178         _mfInnerSuperEllipsesWidth.syncWith(pFrom->_mfInnerSuperEllipsesWidth,
1179                                 syncMode,
1180                                 uiSyncInfo,
1181                                 oOffsets);
1182
1183     if(FieldBits::NoField != (InnerSuperEllipsesHeightFieldMask & whichField))
1184         _mfInnerSuperEllipsesHeight.syncWith(pFrom->_mfInnerSuperEllipsesHeight,
1185                                 syncMode,
1186                                 uiSyncInfo,
1187                                 oOffsets);
1188
1189     if(FieldBits::NoField != (OuterSuperEllipsesWidthFieldMask & whichField))
1190         _mfOuterSuperEllipsesWidth.syncWith(pFrom->_mfOuterSuperEllipsesWidth,
1191                                 syncMode,
1192                                 uiSyncInfo,
1193                                 oOffsets);
1194
1195     if(FieldBits::NoField != (OuterSuperEllipsesHeightFieldMask & whichField))
1196         _mfOuterSuperEllipsesHeight.syncWith(pFrom->_mfOuterSuperEllipsesHeight,
1197                                 syncMode,
1198                                 uiSyncInfo,
1199                                 oOffsets);
1200
1201     if(FieldBits::NoField != (SuperEllipsesRoundnessFieldMask & whichField))
1202         _mfSuperEllipsesRoundness.syncWith(pFrom->_mfSuperEllipsesRoundness,
1203                                 syncMode,
1204                                 uiSyncInfo,
1205                                 oOffsets);
1206
1207     if(FieldBits::NoField != (SuperEllipsesTwistFieldMask & whichField))
1208         _mfSuperEllipsesTwist.syncWith(pFrom->_mfSuperEllipsesTwist,
1209                                 syncMode,
1210                                 uiSyncInfo,
1211                                 oOffsets);
1212
1213     if(FieldBits::NoField != (RangeCutOnFieldMask & whichField))
1214         _mfRangeCutOn.syncWith(pFrom->_mfRangeCutOn,
1215                                 syncMode,
1216                                 uiSyncInfo,
1217                                 oOffsets);
1218
1219     if(FieldBits::NoField != (RangeCutOffFieldMask & whichField))
1220         _mfRangeCutOff.syncWith(pFrom->_mfRangeCutOff,
1221                                 syncMode,
1222                                 uiSyncInfo,
1223                                 oOffsets);
1224
1225     if(FieldBits::NoField != (RangeNearZoneFieldMask & whichField))
1226         _mfRangeNearZone.syncWith(pFrom->_mfRangeNearZone,
1227                                 syncMode,
1228                                 uiSyncInfo,
1229                                 oOffsets);
1230
1231     if(FieldBits::NoField != (RangeFarZoneFieldMask & whichField))
1232         _mfRangeFarZone.syncWith(pFrom->_mfRangeFarZone,
1233                                 syncMode,
1234                                 uiSyncInfo,
1235                                 oOffsets);
1236
1237     if(FieldBits::NoField != (TypeFieldMask & whichField))
1238         _mfType.syncWith(pFrom->_mfType,
1239                                 syncMode,
1240                                 uiSyncInfo,
1241                                 oOffsets);
1242
1243     if(FieldBits::NoField != (EnabledFieldMask & whichField))
1244         _mfEnabled.syncWith(pFrom->_mfEnabled,
1245                                 syncMode,
1246                                 uiSyncInfo,
1247                                 oOffsets);
1248
1249     if(FieldBits::NoField != (BeaconFieldMask & whichField))
1250         _mfBeacon.syncWith(pFrom->_mfBeacon,
1251                                 syncMode,
1252                                 uiSyncInfo,
1253                                 oOffsets);
1254
1255     if(FieldBits::NoField != (BeaconMatrixFieldMask & whichField))
1256         _mfBeaconMatrix.syncWith(pFrom->_mfBeaconMatrix,
1257                                 syncMode,
1258                                 uiSyncInfo,
1259                                 oOffsets);
1260
1261     if(FieldBits::NoField != (EyeSpaceFieldMask & whichField))
1262         _sfEyeSpace.syncWith(pFrom->_sfEyeSpace);
1263
1264     if(FieldBits::NoField != (LastCamNearFieldMask & whichField))
1265         _sfLastCamNear.syncWith(pFrom->_sfLastCamNear);
1266
1267     if(FieldBits::NoField != (LastCamFarFieldMask & whichField))
1268         _sfLastCamFar.syncWith(pFrom->_sfLastCamFar);
1269
1270     if(FieldBits::NoField != (LastCamToWorldFieldMask & whichField))
1271         _sfLastCamToWorld.syncWith(pFrom->_sfLastCamToWorld);
1272
1273     if(FieldBits::NoField != (LightBlockNameFieldMask & whichField))
1274         _sfLightBlockName.syncWith(pFrom->_sfLightBlockName);
1275
1276     if(FieldBits::NoField != (LightVariableNameFieldMask & whichField))
1277         _sfLightVariableName.syncWith(pFrom->_sfLightVariableName);
1278 }
1279 #endif
1280
1281
1282 inline
1283 const Char8 *MultiLightChunkBase::getClassname(void)
1284 {
1285     return "MultiLightChunk";
1286 }
1287 OSG_GEN_CONTAINERPTR(MultiLightChunk);
1288
1289 OSG_END_NAMESPACE
1290