Source/System/State/OpenGL/OSGFogChunkBase.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 FogChunk!
  49  **                                                                         **
  50  *****************************************************************************
  51 \*****************************************************************************/
  52
  53 #include <cstdlib>
  54 #include <cstdio>
  55
  56 #ifdef WIN32
  57 #pragma warning(disable: 4355) // turn off 'this' : used in base member initializer list warning
  58 #pragma warning(disable: 4290) // disable exception specification warning
  59 #endif
  60
  61 #include "OSGConfig.h"
  62
  63
  64 #include "OSGGL.h"                        // Mode default header
  65
  66
  67 #include "OSGFogChunkBase.h"
  68 #include "OSGFogChunk.h"
  69
  70 #include <boost/bind.hpp>
  71
  72 OSG_BEGIN_NAMESPACE
  73
  74 /***************************************************************************\
  75  *                            Description                                  *
  76 \***************************************************************************/
  77
  78 /*! \class OSG::FogChunk
  79     This chunk wraps glFog() (OSG::FogChunk::_sfMode, OSG::FogChunk::_sfFogColor,
  80     OSG::FogChunk::_sfStart, OSG::FogChunk::_sfEnd, OSG::FogChunk::_sfDensity).
  81  */
  82
  83 /***************************************************************************\
  84  *                        Field Documentation                              *
  85 \***************************************************************************/
  86
  87 /*! \var GLenum          FogChunkBase::_sfMode
  88     The fog type to use (GL_LINEAR, GL_EXP, GL_EXP2, default: GL_EXP).
  89 */
  90
  91 /*! \var Color4f         FogChunkBase::_sfColor
  92     The color of the fog (default: 0, 0, 0, 0).
  93 */
  94
  95 /*! \var Real32          FogChunkBase::_sfStart
  96     The near value for the fog, used in GL_LINEAR mode (default: 0.f)
  97 */
  98
  99 /*! \var Real32          FogChunkBase::_sfEnd
 100     The far value for the fog, used in GL_LINEAR mode (default: 1.f)
 101 */
 102
 103 /*! \var Real32          FogChunkBase::_sfDensity
 104     The denisty of the fog, used in GL_EXP, GL_EXP2 mode (default: 1.f)
 105 */
 106
 107
 108 /***************************************************************************\
 109  *                      FieldType/FieldTrait Instantiation                 *
 110 \***************************************************************************/
 111
 112 #if !defined(OSG_DO_DOC) || defined(OSG_DOC_DEV)
 113 PointerType FieldTraits<FogChunk *, nsOSG>::_type(
 114     "FogChunkPtr",
 115     "StateChunkPtr",
 116     FogChunk::getClassType(),
 117     nsOSG);
 118 #endif
 119
 120 OSG_FIELDTRAITS_GETTYPE_NS(FogChunk *, nsOSG)
 121
 122 OSG_EXPORT_PTR_SFIELD_FULL(PointerSField,
 123                            FogChunk *,
 124                            nsOSG)
 125
 126 OSG_EXPORT_PTR_MFIELD_FULL(PointerMField,
 127                            FogChunk *,
 128                            nsOSG)
 129
 130 /***************************************************************************\
 131  *                         Field Description                               *
 132 \***************************************************************************/
 133
 134 void FogChunkBase::classDescInserter(TypeObject &oType)
 135 {
 136     FieldDescriptionBase *pDesc = NULL;
 137
 138
 139     pDesc = new SFGLenum::Description(
 140         SFGLenum::getClassType(),
 141         "mode",
 142         "The fog type to use (GL_LINEAR, GL_EXP, GL_EXP2, default: GL_EXP).\n",
 143         ModeFieldId, ModeFieldMask,
 144         false,
 145         (Field::SFDefaultFlags | Field::FStdAccess),
 146         static_cast<FieldEditMethodSig>(&FogChunk::editHandleMode),
 147         static_cast<FieldGetMethodSig >(&FogChunk::getHandleMode));
 148
 149     oType.addInitialDesc(pDesc);
 150
 151     pDesc = new SFColor4f::Description(
 152         SFColor4f::getClassType(),
 153         "color",
 154         "The color of the fog (default: 0, 0, 0, 0).\n",
 155         ColorFieldId, ColorFieldMask,
 156         false,
 157         (Field::SFDefaultFlags | Field::FStdAccess),
 158         static_cast<FieldEditMethodSig>(&FogChunk::editHandleColor),
 159         static_cast<FieldGetMethodSig >(&FogChunk::getHandleColor));
 160
 161     oType.addInitialDesc(pDesc);
 162
 163     pDesc = new SFReal32::Description(
 164         SFReal32::getClassType(),
 165         "start",
 166         "The near value for the fog, used in GL_LINEAR mode (default: 0.f)\n",
 167         StartFieldId, StartFieldMask,
 168         false,
 169         (Field::SFDefaultFlags | Field::FStdAccess),
 170         static_cast<FieldEditMethodSig>(&FogChunk::editHandleStart),
 171         static_cast<FieldGetMethodSig >(&FogChunk::getHandleStart));
 172
 173     oType.addInitialDesc(pDesc);
 174
 175     pDesc = new SFReal32::Description(
 176         SFReal32::getClassType(),
 177         "end",
 178         "The far value for the fog, used in GL_LINEAR mode (default: 1.f)\n",
 179         EndFieldId, EndFieldMask,
 180         false,
 181         (Field::SFDefaultFlags | Field::FStdAccess),
 182         static_cast<FieldEditMethodSig>(&FogChunk::editHandleEnd),
 183         static_cast<FieldGetMethodSig >(&FogChunk::getHandleEnd));
 184
 185     oType.addInitialDesc(pDesc);
 186
 187     pDesc = new SFReal32::Description(
 188         SFReal32::getClassType(),
 189         "density",
 190         "The denisty of the fog, used in GL_EXP, GL_EXP2 mode (default: 1.f)\n",
 191         DensityFieldId, DensityFieldMask,
 192         false,
 193         (Field::SFDefaultFlags | Field::FStdAccess),
 194         static_cast<FieldEditMethodSig>(&FogChunk::editHandleDensity),
 195         static_cast<FieldGetMethodSig >(&FogChunk::getHandleDensity));
 196
 197     oType.addInitialDesc(pDesc);
 198 }
 199
 200
 201 FogChunkBase::TypeObject FogChunkBase::_type(
 202     FogChunkBase::getClassname(),
 203     Inherited::getClassname(),
 204     "NULL",
 205     nsOSG, //Namespace
 206     reinterpret_cast<PrototypeCreateF>(&FogChunkBase::createEmptyLocal),
 207     reinterpret_cast<InitContainerF>(&FogChunk::initMethod),
 208     reinterpret_cast<ExitContainerF>(&FogChunk::exitMethod),
 209     reinterpret_cast<InitalInsertDescFunc>(
 210         reinterpret_cast<void *>(&FogChunk::classDescInserter)),
 211     false,
 212     0,
 213     "<?xml version=\"1.0\"?>\n"
 214     "\n"
 215     "<FieldContainer\n"
 216     "   name=\"FogChunk\"\n"
 217     "   parent=\"StateChunk\"\n"
 218     "   library=\"State\"\n"
 219     "   pointerfieldtypes=\"both\"\n"
 220     "   structure=\"concrete\"\n"
 221     "   systemcomponent=\"true\"\n"
 222     "   parentsystemcomponent=\"true\"\n"
 223     "   decoratable=\"false\"\n"
 224     "   docGroupBase=\"GrpStateOpenGL\"\n"
 225     "   >\n"
 226     "  This chunk wraps glFog() (OSG::FogChunk::_sfMode, OSG::FogChunk::_sfFogColor,\n"
 227     "  OSG::FogChunk::_sfStart, OSG::FogChunk::_sfEnd, OSG::FogChunk::_sfDensity).\n"
 228     "\n"
 229     "  <Field\n"
 230     "     name=\"mode\"\n"
 231     "     type=\"GLenum\"\n"
 232     "     category=\"data\"\n"
 233     "     cardinality=\"single\"\n"
 234     "     defaultValue=\"GL_EXP\"\n"
 235     "     defaultHeader=\"&quot;OSGGL.h&quot;\"\n"
 236     "     visibility=\"external\"\n"
 237     "     access=\"public\"\n"
 238     "     >\n"
 239     "    The fog type to use (GL_LINEAR, GL_EXP, GL_EXP2, default: GL_EXP).\n"
 240     "  </Field>\n"
 241     "\n"
 242     "  <Field\n"
 243     "     name=\"color\"\n"
 244     "     type=\"Color4f\"\n"
 245     "     category=\"data\"\n"
 246     "     cardinality=\"single\"\n"
 247     "     defaultValue=\"0.f, 0.f, 0.f, 0.f\"\n"
 248     "     visibility=\"external\"\n"
 249     "     access=\"public\"\n"
 250     "     >\n"
 251     "    The color of the fog (default: 0, 0, 0, 0).\n"
 252     "  </Field>\n"
 253     "\n"
 254     "  <Field\n"
 255     "     name=\"start\"\n"
 256     "     type=\"Real32\"\n"
 257     "     category=\"data\"\n"
 258     "     cardinality=\"single\"\n"
 259     "     defaultValue=\"0.f\"\n"
 260     "     visibility=\"external\"\n"
 261     "     access=\"public\"\n"
 262     "     >\n"
 263     "    The near value for the fog, used in GL_LINEAR mode (default: 0.f)\n"
 264     "  </Field>\n"
 265     "\n"
 266     "  <Field\n"
 267     "     name=\"end\"\n"
 268     "     type=\"Real32\"\n"
 269     "     category=\"data\"\n"
 270     "     cardinality=\"single\"\n"
 271     "     defaultValue=\"1.f\"\n"
 272     "     visibility=\"external\"\n"
 273     "     access=\"public\"\n"
 274     "     >\n"
 275     "    The far value for the fog, used in GL_LINEAR mode (default: 1.f)\n"
 276     "  </Field>\n"
 277     "\n"
 278     "  <Field\n"
 279     "     name=\"density\"\n"
 280     "     type=\"Real32\"\n"
 281     "     category=\"data\"\n"
 282     "     cardinality=\"single\"\n"
 283     "     defaultValue=\"1.f\"\n"
 284     "     visibility=\"external\"\n"
 285     "     access=\"public\"\n"
 286     "     >\n"
 287     "    The denisty of the fog, used in GL_EXP, GL_EXP2 mode (default: 1.f)\n"
 288     "  </Field>\n"
 289     "</FieldContainer>\n",
 290     "This chunk wraps glFog() (OSG::FogChunk::_sfMode, OSG::FogChunk::_sfFogColor,\n"
 291     "OSG::FogChunk::_sfStart, OSG::FogChunk::_sfEnd, OSG::FogChunk::_sfDensity).\n"
 292     );
 293
 294 /*------------------------------ get -----------------------------------*/
 295
 296 FieldContainerType &FogChunkBase::getType(void)
 297 {
 298     return _type;
 299 }
 300
 301 const FieldContainerType &FogChunkBase::getType(void) const
 302 {
 303     return _type;
 304 }
 305
 306 UInt32 FogChunkBase::getContainerSize(void) const
 307 {
 308     return sizeof(FogChunk);
 309 }
 310
 311 /*------------------------- decorator get ------------------------------*/
 312
 313
 314 SFGLenum *FogChunkBase::editSFMode(void)
 315 {
 316     editSField(ModeFieldMask);
 317
 318     return &_sfMode;
 319 }
 320
 321 const SFGLenum *FogChunkBase::getSFMode(void) const
 322 {
 323     return &_sfMode;
 324 }
 325
 326
 327 SFColor4f *FogChunkBase::editSFColor(void)
 328 {
 329     editSField(ColorFieldMask);
 330
 331     return &_sfColor;
 332 }
 333
 334 const SFColor4f *FogChunkBase::getSFColor(void) const
 335 {
 336     return &_sfColor;
 337 }
 338
 339
 340 SFReal32 *FogChunkBase::editSFStart(void)
 341 {
 342     editSField(StartFieldMask);
 343
 344     return &_sfStart;
 345 }
 346
 347 const SFReal32 *FogChunkBase::getSFStart(void) const
 348 {
 349     return &_sfStart;
 350 }
 351
 352
 353 SFReal32 *FogChunkBase::editSFEnd(void)
 354 {
 355     editSField(EndFieldMask);
 356
 357     return &_sfEnd;
 358 }
 359
 360 const SFReal32 *FogChunkBase::getSFEnd(void) const
 361 {
 362     return &_sfEnd;
 363 }
 364
 365
 366 SFReal32 *FogChunkBase::editSFDensity(void)
 367 {
 368     editSField(DensityFieldMask);
 369
 370     return &_sfDensity;
 371 }
 372
 373 const SFReal32 *FogChunkBase::getSFDensity(void) const
 374 {
 375     return &_sfDensity;
 376 }
 377
 378
 379
 380
 381
 382
 383 /*------------------------------ access -----------------------------------*/
 384
 385 SizeT FogChunkBase::getBinSize(ConstFieldMaskArg whichField)
 386 {
 387     SizeT returnValue = Inherited::getBinSize(whichField);
 388
 389     if(FieldBits::NoField != (ModeFieldMask & whichField))
 390     {
 391         returnValue += _sfMode.getBinSize();
 392     }
 393     if(FieldBits::NoField != (ColorFieldMask & whichField))
 394     {
 395         returnValue += _sfColor.getBinSize();
 396     }
 397     if(FieldBits::NoField != (StartFieldMask & whichField))
 398     {
 399         returnValue += _sfStart.getBinSize();
 400     }
 401     if(FieldBits::NoField != (EndFieldMask & whichField))
 402     {
 403         returnValue += _sfEnd.getBinSize();
 404     }
 405     if(FieldBits::NoField != (DensityFieldMask & whichField))
 406     {
 407         returnValue += _sfDensity.getBinSize();
 408     }
 409
 410     return returnValue;
 411 }
 412
 413 void FogChunkBase::copyToBin(BinaryDataHandler &pMem,
 414                                   ConstFieldMaskArg  whichField)
 415 {
 416     Inherited::copyToBin(pMem, whichField);
 417
 418     if(FieldBits::NoField != (ModeFieldMask & whichField))
 419     {
 420         _sfMode.copyToBin(pMem);
 421     }
 422     if(FieldBits::NoField != (ColorFieldMask & whichField))
 423     {
 424         _sfColor.copyToBin(pMem);
 425     }
 426     if(FieldBits::NoField != (StartFieldMask & whichField))
 427     {
 428         _sfStart.copyToBin(pMem);
 429     }
 430     if(FieldBits::NoField != (EndFieldMask & whichField))
 431     {
 432         _sfEnd.copyToBin(pMem);
 433     }
 434     if(FieldBits::NoField != (DensityFieldMask & whichField))
 435     {
 436         _sfDensity.copyToBin(pMem);
 437     }
 438 }
 439
 440 void FogChunkBase::copyFromBin(BinaryDataHandler &pMem,
 441                                     ConstFieldMaskArg  whichField)
 442 {
 443     Inherited::copyFromBin(pMem, whichField);
 444
 445     if(FieldBits::NoField != (ModeFieldMask & whichField))
 446     {
 447         editSField(ModeFieldMask);
 448         _sfMode.copyFromBin(pMem);
 449     }
 450     if(FieldBits::NoField != (ColorFieldMask & whichField))
 451     {
 452         editSField(ColorFieldMask);
 453         _sfColor.copyFromBin(pMem);
 454     }
 455     if(FieldBits::NoField != (StartFieldMask & whichField))
 456     {
 457         editSField(StartFieldMask);
 458         _sfStart.copyFromBin(pMem);
 459     }
 460     if(FieldBits::NoField != (EndFieldMask & whichField))
 461     {
 462         editSField(EndFieldMask);
 463         _sfEnd.copyFromBin(pMem);
 464     }
 465     if(FieldBits::NoField != (DensityFieldMask & whichField))
 466     {
 467         editSField(DensityFieldMask);
 468         _sfDensity.copyFromBin(pMem);
 469     }
 470 }
 471
 472 //! create a new instance of the class
 473 FogChunkTransitPtr FogChunkBase::createLocal(BitVector bFlags)
 474 {
 475     FogChunkTransitPtr fc;
 476
 477     if(getClassType().getPrototype() != NULL)
 478     {
 479         FieldContainerTransitPtr tmpPtr =
 480             getClassType().getPrototype()-> shallowCopyLocal(bFlags);
 481
 482         fc = dynamic_pointer_cast<FogChunk>(tmpPtr);
 483     }
 484
 485     return fc;
 486 }
 487
 488 //! create a new instance of the class, copy the container flags
 489 FogChunkTransitPtr FogChunkBase::createDependent(BitVector bFlags)
 490 {
 491     FogChunkTransitPtr fc;
 492
 493     if(getClassType().getPrototype() != NULL)
 494     {
 495         FieldContainerTransitPtr tmpPtr =
 496             getClassType().getPrototype()-> shallowCopyDependent(bFlags);
 497
 498         fc = dynamic_pointer_cast<FogChunk>(tmpPtr);
 499     }
 500
 501     return fc;
 502 }
 503
 504 //! create a new instance of the class
 505 FogChunkTransitPtr FogChunkBase::create(void)
 506 {
 507     FogChunkTransitPtr fc;
 508
 509     if(getClassType().getPrototype() != NULL)
 510     {
 511         FieldContainerTransitPtr tmpPtr =
 512             getClassType().getPrototype()-> shallowCopy();
 513
 514         fc = dynamic_pointer_cast<FogChunk>(tmpPtr);
 515     }
 516
 517     return fc;
 518 }
 519
 520 FogChunk *FogChunkBase::createEmptyLocal(BitVector bFlags)
 521 {
 522     FogChunk *returnValue;
 523
 524     newPtr<FogChunk>(returnValue, bFlags);
 525
 526     returnValue->_pFieldFlags->_bNamespaceMask &= ~bFlags;
 527
 528     return returnValue;
 529 }
 530
 531 //! create an empty new instance of the class, do not copy the prototype
 532 FogChunk *FogChunkBase::createEmpty(void)
 533 {
 534     FogChunk *returnValue;
 535
 536     newPtr<FogChunk>(returnValue, Thread::getCurrentLocalFlags());
 537
 538     returnValue->_pFieldFlags->_bNamespaceMask &=
 539         ~Thread::getCurrentLocalFlags();
 540
 541     return returnValue;
 542 }
 543
 544
 545 FieldContainerTransitPtr FogChunkBase::shallowCopyLocal(
 546     BitVector bFlags) const
 547 {
 548     FogChunk *tmpPtr;
 549
 550     newPtr(tmpPtr, dynamic_cast<const FogChunk *>(this), bFlags);
 551
 552     FieldContainerTransitPtr returnValue(tmpPtr);
 553
 554     tmpPtr->_pFieldFlags->_bNamespaceMask &= ~bFlags;
 555
 556     return returnValue;
 557 }
 558
 559 FieldContainerTransitPtr FogChunkBase::shallowCopyDependent(
 560     BitVector bFlags) const
 561 {
 562     FogChunk *tmpPtr;
 563
 564     newPtr(tmpPtr, dynamic_cast<const FogChunk *>(this), ~bFlags);
 565
 566     FieldContainerTransitPtr returnValue(tmpPtr);
 567
 568     tmpPtr->_pFieldFlags->_bNamespaceMask = bFlags;
 569
 570     return returnValue;
 571 }
 572
 573 FieldContainerTransitPtr FogChunkBase::shallowCopy(void) const
 574 {
 575     FogChunk *tmpPtr;
 576
 577     newPtr(tmpPtr,
 578            dynamic_cast<const FogChunk *>(this),
 579            Thread::getCurrentLocalFlags());
 580
 581     tmpPtr->_pFieldFlags->_bNamespaceMask &= ~Thread::getCurrentLocalFlags();
 582
 583     FieldContainerTransitPtr returnValue(tmpPtr);
 584
 585     return returnValue;
 586 }
 587
 588
 589
 590
 591 /*------------------------- constructors ----------------------------------*/
 592
 593 FogChunkBase::FogChunkBase(void) :
 594     Inherited(),
 595     _sfMode                   (GLenum(GL_EXP)),
 596     _sfColor                  (Color4f(0.f, 0.f, 0.f, 0.f)),
 597     _sfStart                  (Real32(0.f)),
 598     _sfEnd                    (Real32(1.f)),
 599     _sfDensity                (Real32(1.f))
 600 {
 601 }
 602
 603 FogChunkBase::FogChunkBase(const FogChunkBase &source) :
 604     Inherited(source),
 605     _sfMode                   (source._sfMode                   ),
 606     _sfColor                  (source._sfColor                  ),
 607     _sfStart                  (source._sfStart                  ),
 608     _sfEnd                    (source._sfEnd                    ),
 609     _sfDensity                (source._sfDensity                )
 610 {
 611 }
 612
 613
 614 /*-------------------------- destructors ----------------------------------*/
 615
 616 FogChunkBase::~FogChunkBase(void)
 617 {
 618 }
 619
 620
 621 GetFieldHandlePtr FogChunkBase::getHandleMode            (void) const
 622 {
 623     SFGLenum::GetHandlePtr returnValue(
 624         new  SFGLenum::GetHandle(
 625              &_sfMode,
 626              this->getType().getFieldDesc(ModeFieldId),
 627              const_cast<FogChunkBase *>(this)));
 628
 629     return returnValue;
 630 }
 631
 632 EditFieldHandlePtr FogChunkBase::editHandleMode           (void)
 633 {
 634     SFGLenum::EditHandlePtr returnValue(
 635         new  SFGLenum::EditHandle(
 636              &_sfMode,
 637              this->getType().getFieldDesc(ModeFieldId),
 638              this));
 639
 640
 641     editSField(ModeFieldMask);
 642
 643     return returnValue;
 644 }
 645
 646 GetFieldHandlePtr FogChunkBase::getHandleColor           (void) const
 647 {
 648     SFColor4f::GetHandlePtr returnValue(
 649         new  SFColor4f::GetHandle(
 650              &_sfColor,
 651              this->getType().getFieldDesc(ColorFieldId),
 652              const_cast<FogChunkBase *>(this)));
 653
 654     return returnValue;
 655 }
 656
 657 EditFieldHandlePtr FogChunkBase::editHandleColor          (void)
 658 {
 659     SFColor4f::EditHandlePtr returnValue(
 660         new  SFColor4f::EditHandle(
 661              &_sfColor,
 662              this->getType().getFieldDesc(ColorFieldId),
 663              this));
 664
 665
 666     editSField(ColorFieldMask);
 667
 668     return returnValue;
 669 }
 670
 671 GetFieldHandlePtr FogChunkBase::getHandleStart           (void) const
 672 {
 673     SFReal32::GetHandlePtr returnValue(
 674         new  SFReal32::GetHandle(
 675              &_sfStart,
 676              this->getType().getFieldDesc(StartFieldId),
 677              const_cast<FogChunkBase *>(this)));
 678
 679     return returnValue;
 680 }
 681
 682 EditFieldHandlePtr FogChunkBase::editHandleStart          (void)
 683 {
 684     SFReal32::EditHandlePtr returnValue(
 685         new  SFReal32::EditHandle(
 686              &_sfStart,
 687              this->getType().getFieldDesc(StartFieldId),
 688              this));
 689
 690
 691     editSField(StartFieldMask);
 692
 693     return returnValue;
 694 }
 695
 696 GetFieldHandlePtr FogChunkBase::getHandleEnd             (void) const
 697 {
 698     SFReal32::GetHandlePtr returnValue(
 699         new  SFReal32::GetHandle(
 700              &_sfEnd,
 701              this->getType().getFieldDesc(EndFieldId),
 702              const_cast<FogChunkBase *>(this)));
 703
 704     return returnValue;
 705 }
 706
 707 EditFieldHandlePtr FogChunkBase::editHandleEnd            (void)
 708 {
 709     SFReal32::EditHandlePtr returnValue(
 710         new  SFReal32::EditHandle(
 711              &_sfEnd,
 712              this->getType().getFieldDesc(EndFieldId),
 713              this));
 714
 715
 716     editSField(EndFieldMask);
 717
 718     return returnValue;
 719 }
 720
 721 GetFieldHandlePtr FogChunkBase::getHandleDensity         (void) const
 722 {
 723     SFReal32::GetHandlePtr returnValue(
 724         new  SFReal32::GetHandle(
 725              &_sfDensity,
 726              this->getType().getFieldDesc(DensityFieldId),
 727              const_cast<FogChunkBase *>(this)));
 728
 729     return returnValue;
 730 }
 731
 732 EditFieldHandlePtr FogChunkBase::editHandleDensity        (void)
 733 {
 734     SFReal32::EditHandlePtr returnValue(
 735         new  SFReal32::EditHandle(
 736              &_sfDensity,
 737              this->getType().getFieldDesc(DensityFieldId),
 738              this));
 739
 740
 741     editSField(DensityFieldMask);
 742
 743     return returnValue;
 744 }
 745
 746
 747 #ifdef OSG_MT_CPTR_ASPECT
 748 void FogChunkBase::execSyncV(      FieldContainer    &oFrom,
 749                                         ConstFieldMaskArg  whichField,
 750                                         AspectOffsetStore &oOffsets,
 751                                         ConstFieldMaskArg  syncMode,
 752                                   const UInt32             uiSyncInfo)
 753 {
 754     FogChunk *pThis = static_cast<FogChunk *>(this);
 755
 756     pThis->execSync(static_cast<FogChunk *>(&oFrom),
 757                     whichField,
 758                     oOffsets,
 759                     syncMode,
 760                     uiSyncInfo);
 761 }
 762 #endif
 763
 764
 765 #ifdef OSG_MT_CPTR_ASPECT
 766 FieldContainer *FogChunkBase::createAspectCopy(
 767     const FieldContainer *pRefAspect) const
 768 {
 769     FogChunk *returnValue;
 770
 771     newAspectCopy(returnValue,
 772                   dynamic_cast<const FogChunk *>(pRefAspect),
 773                   dynamic_cast<const FogChunk *>(this));
 774
 775     return returnValue;
 776 }
 777 #endif
 778
 779 void FogChunkBase::resolveLinks(void)
 780 {
 781     Inherited::resolveLinks();
 782
 783
 784 }
 785
 786
 787 OSG_END_NAMESPACE