Source/System/State/OpenGL/OSGStencilChunkBase.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 StencilChunk!
  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"                        // StencilFunc default header
  65 #include "OSGGL.h"                        // StencilOpFail default header
  66 #include "OSGGL.h"                        // StencilOpZFail default header
  67 #include "OSGGL.h"                        // StencilOpZPass default header
  68
  69
  70 #include "OSGStencilChunkBase.h"
  71 #include "OSGStencilChunk.h"
  72
  73 #include <boost/bind.hpp>
  74
  75 OSG_BEGIN_NAMESPACE
  76
  77 /***************************************************************************\
  78  *                            Description                                  *
  79 \***************************************************************************/
  80
  81 /*! \class OSG::StencilChunk
  82     The stencil chunk handles OpenGL stencil tests by wrapping glStencilFunc()
  83     and glStencilOp().
  84  */
  85
  86 /***************************************************************************\
  87  *                        Field Documentation                              *
  88 \***************************************************************************/
  89
  90 /*! \var GLenum          StencilChunkBase::_sfStencilFunc
  91     The stencilFunc defines how fragments which do not fulfill a certain
  92     condition are handled.
  93     See glStencilFunc() for details. GL_NONE is used to disable stencil.
  94 */
  95
  96 /*! \var Int32           StencilChunkBase::_sfStencilValue
  97     The stencilFunc defines how fragments which do not fulfill a certain
  98     condition are handled.
  99     See glStencilFunc() for details. GL_NONE is used to disable stencil.
 100 */
 101
 102 /*! \var UInt32          StencilChunkBase::_sfStencilMask
 103     The stencilFunc defines how fragments which do not fulfill a certain
 104     condition are handled.
 105     See glStencilFunc() for details. GL_NONE is used to disable stencil.
 106 */
 107
 108 /*! \var GLenum          StencilChunkBase::_sfStencilOpFail
 109     The stencilFunc defines how fragments which do not fulfill a certain
 110     condition are handled.
 111     See glStencilFunc() for details. GL_NONE is used to disable stencil.
 112 */
 113
 114 /*! \var GLenum          StencilChunkBase::_sfStencilOpZFail
 115     The stencilFunc defines how fragments which do not fulfill a certain
 116     condition are handled.
 117     See glStencilFunc() for details. GL_NONE is used to disable stencil.
 118 */
 119
 120 /*! \var GLenum          StencilChunkBase::_sfStencilOpZPass
 121     The stencilFunc defines how fragments which do not fulfill a certain
 122     condition are handled.
 123     See glStencilFunc() for details. GL_NONE is used to disable stencil.
 124 */
 125
 126 /*! \var Int32           StencilChunkBase::_sfClearBuffer
 127     Clear buffer on activate(1) or deactivate(2).
 128 */
 129
 130 /*! \var UInt32          StencilChunkBase::_sfBitMask
 131     Controls writing of individual bits in stencil planes, with 0 means write
 132     protected and 1 write enabled.
 133 */
 134
 135
 136 /***************************************************************************\
 137  *                      FieldType/FieldTrait Instantiation                 *
 138 \***************************************************************************/
 139
 140 #if !defined(OSG_DO_DOC) || defined(OSG_DOC_DEV)
 141 PointerType FieldTraits<StencilChunk *, nsOSG>::_type(
 142     "StencilChunkPtr",
 143     "StateChunkPtr",
 144     StencilChunk::getClassType(),
 145     nsOSG);
 146 #endif
 147
 148 OSG_FIELDTRAITS_GETTYPE_NS(StencilChunk *, nsOSG)
 149
 150 OSG_EXPORT_PTR_SFIELD_FULL(PointerSField,
 151                            StencilChunk *,
 152                            nsOSG)
 153
 154 OSG_EXPORT_PTR_MFIELD_FULL(PointerMField,
 155                            StencilChunk *,
 156                            nsOSG)
 157
 158 /***************************************************************************\
 159  *                         Field Description                               *
 160 \***************************************************************************/
 161
 162 void StencilChunkBase::classDescInserter(TypeObject &oType)
 163 {
 164     FieldDescriptionBase *pDesc = NULL;
 165
 166
 167     pDesc = new SFGLenum::Description(
 168         SFGLenum::getClassType(),
 169         "stencilFunc",
 170         "The stencilFunc defines how fragments which do not fulfill a certain\n"
 171         "condition are handled. \n"
 172         "See glStencilFunc() for details. GL_NONE is used to disable stencil.\n",
 173         StencilFuncFieldId, StencilFuncFieldMask,
 174         false,
 175         (Field::SFDefaultFlags | Field::FStdAccess),
 176         static_cast<FieldEditMethodSig>(&StencilChunk::editHandleStencilFunc),
 177         static_cast<FieldGetMethodSig >(&StencilChunk::getHandleStencilFunc));
 178
 179     oType.addInitialDesc(pDesc);
 180
 181     pDesc = new SFInt32::Description(
 182         SFInt32::getClassType(),
 183         "stencilValue",
 184         "The stencilFunc defines how fragments which do not fulfill a certain\n"
 185         "condition are handled. \n"
 186         "See glStencilFunc() for details. GL_NONE is used to disable stencil.\n",
 187         StencilValueFieldId, StencilValueFieldMask,
 188         false,
 189         (Field::SFDefaultFlags | Field::FStdAccess),
 190         static_cast<FieldEditMethodSig>(&StencilChunk::editHandleStencilValue),
 191         static_cast<FieldGetMethodSig >(&StencilChunk::getHandleStencilValue));
 192
 193     oType.addInitialDesc(pDesc);
 194
 195     pDesc = new SFUInt32::Description(
 196         SFUInt32::getClassType(),
 197         "stencilMask",
 198         "The stencilFunc defines how fragments which do not fulfill a certain\n"
 199         "condition are handled. \n"
 200         "See glStencilFunc() for details. GL_NONE is used to disable stencil.\n",
 201         StencilMaskFieldId, StencilMaskFieldMask,
 202         false,
 203         (Field::SFDefaultFlags | Field::FStdAccess),
 204         static_cast<FieldEditMethodSig>(&StencilChunk::editHandleStencilMask),
 205         static_cast<FieldGetMethodSig >(&StencilChunk::getHandleStencilMask));
 206
 207     oType.addInitialDesc(pDesc);
 208
 209     pDesc = new SFGLenum::Description(
 210         SFGLenum::getClassType(),
 211         "stencilOpFail",
 212         "The stencilFunc defines how fragments which do not fulfill a certain\n"
 213         "condition are handled. \n"
 214         "See glStencilFunc() for details. GL_NONE is used to disable stencil.\n",
 215         StencilOpFailFieldId, StencilOpFailFieldMask,
 216         false,
 217         (Field::SFDefaultFlags | Field::FStdAccess),
 218         static_cast<FieldEditMethodSig>(&StencilChunk::editHandleStencilOpFail),
 219         static_cast<FieldGetMethodSig >(&StencilChunk::getHandleStencilOpFail));
 220
 221     oType.addInitialDesc(pDesc);
 222
 223     pDesc = new SFGLenum::Description(
 224         SFGLenum::getClassType(),
 225         "stencilOpZFail",
 226         "The stencilFunc defines how fragments which do not fulfill a certain\n"
 227         "condition are handled. \n"
 228         "See glStencilFunc() for details. GL_NONE is used to disable stencil.\n",
 229         StencilOpZFailFieldId, StencilOpZFailFieldMask,
 230         false,
 231         (Field::SFDefaultFlags | Field::FStdAccess),
 232         static_cast<FieldEditMethodSig>(&StencilChunk::editHandleStencilOpZFail),
 233         static_cast<FieldGetMethodSig >(&StencilChunk::getHandleStencilOpZFail));
 234
 235     oType.addInitialDesc(pDesc);
 236
 237     pDesc = new SFGLenum::Description(
 238         SFGLenum::getClassType(),
 239         "stencilOpZPass",
 240         "The stencilFunc defines how fragments which do not fulfill a certain\n"
 241         "condition are handled. \n"
 242         "See glStencilFunc() for details. GL_NONE is used to disable stencil.\n",
 243         StencilOpZPassFieldId, StencilOpZPassFieldMask,
 244         false,
 245         (Field::SFDefaultFlags | Field::FStdAccess),
 246         static_cast<FieldEditMethodSig>(&StencilChunk::editHandleStencilOpZPass),
 247         static_cast<FieldGetMethodSig >(&StencilChunk::getHandleStencilOpZPass));
 248
 249     oType.addInitialDesc(pDesc);
 250
 251     pDesc = new SFInt32::Description(
 252         SFInt32::getClassType(),
 253         "clearBuffer",
 254         "Clear buffer on activate(1) or deactivate(2).\n",
 255         ClearBufferFieldId, ClearBufferFieldMask,
 256         false,
 257         (Field::SFDefaultFlags | Field::FStdAccess),
 258         static_cast<FieldEditMethodSig>(&StencilChunk::editHandleClearBuffer),
 259         static_cast<FieldGetMethodSig >(&StencilChunk::getHandleClearBuffer));
 260
 261     oType.addInitialDesc(pDesc);
 262
 263     pDesc = new SFUInt32::Description(
 264         SFUInt32::getClassType(),
 265         "bitMask",
 266         "Controls writing of individual bits in stencil planes, with 0 means write\n"
 267         "protected and 1 write enabled.\n",
 268         BitMaskFieldId, BitMaskFieldMask,
 269         false,
 270         (Field::SFDefaultFlags | Field::FStdAccess),
 271         static_cast<FieldEditMethodSig>(&StencilChunk::editHandleBitMask),
 272         static_cast<FieldGetMethodSig >(&StencilChunk::getHandleBitMask));
 273
 274     oType.addInitialDesc(pDesc);
 275 }
 276
 277
 278 StencilChunkBase::TypeObject StencilChunkBase::_type(
 279     StencilChunkBase::getClassname(),
 280     Inherited::getClassname(),
 281     "NULL",
 282     nsOSG, //Namespace
 283     reinterpret_cast<PrototypeCreateF>(&StencilChunkBase::createEmptyLocal),
 284     reinterpret_cast<InitContainerF>(&StencilChunk::initMethod),
 285     reinterpret_cast<ExitContainerF>(&StencilChunk::exitMethod),
 286     reinterpret_cast<InitalInsertDescFunc>(
 287         reinterpret_cast<void *>(&StencilChunk::classDescInserter)),
 288     false,
 289     0,
 290     "<?xml version=\"1.0\"?>\n"
 291     "\n"
 292     "<FieldContainer\n"
 293     "   name=\"StencilChunk\"\n"
 294     "   parent=\"StateChunk\"\n"
 295     "   library=\"State\"\n"
 296     "   pointerfieldtypes=\"both\"\n"
 297     "   structure=\"concrete\"\n"
 298     "   systemcomponent=\"true\"\n"
 299     "   parentsystemcomponent=\"true\"\n"
 300     "   decoratable=\"false\"\n"
 301     "   useLocalIncludes=\"false\"\n"
 302     "   docGroupBase=\"GrpStateOpenGL\"\n"
 303     "   >\n"
 304     "  The stencil chunk handles OpenGL stencil tests by wrapping glStencilFunc()\n"
 305     "  and glStencilOp(). \n"
 306     "  <Field\n"
 307     "\t name=\"stencilFunc\"\n"
 308     "\t type=\"GLenum\"\n"
 309     "\t cardinality=\"single\"\n"
 310     "\t visibility=\"external\"\n"
 311     "\t defaultValue=\"GL_NONE\"\n"
 312     "\t defaultHeader=\"OSGGL.h\"\n"
 313     "\t access=\"public\"\n"
 314     "\t >\n"
 315     "\tThe stencilFunc defines how fragments which do not fulfill a certain\n"
 316     "\tcondition are handled. \n"
 317     "    See glStencilFunc() for details. GL_NONE is used to disable stencil.\n"
 318     "  </Field>\n"
 319     "  <Field\n"
 320     "\t name=\"stencilValue\"\n"
 321     "\t type=\"Int32\"\n"
 322     "\t cardinality=\"single\"\n"
 323     "\t visibility=\"external\"\n"
 324     "\t defaultValue=\"0\"\n"
 325     "\t access=\"public\"\n"
 326     "\t >\n"
 327     "\tThe stencilFunc defines how fragments which do not fulfill a certain\n"
 328     "\tcondition are handled. \n"
 329     "    See glStencilFunc() for details. GL_NONE is used to disable stencil.\n"
 330     "  </Field>\n"
 331     "  <Field\n"
 332     "\t name=\"stencilMask\"\n"
 333     "\t type=\"UInt32\"\n"
 334     "\t cardinality=\"single\"\n"
 335     "\t visibility=\"external\"\n"
 336     "\t defaultValue=\"0x1\"\n"
 337     "\t access=\"public\"\n"
 338     "\t >\n"
 339     "\tThe stencilFunc defines how fragments which do not fulfill a certain\n"
 340     "\tcondition are handled. \n"
 341     "    See glStencilFunc() for details. GL_NONE is used to disable stencil.\n"
 342     "  </Field>\n"
 343     "  <Field\n"
 344     "\t name=\"stencilOpFail\"\n"
 345     "\t type=\"GLenum\"\n"
 346     "\t cardinality=\"single\"\n"
 347     "\t visibility=\"external\"\n"
 348     "\t defaultValue=\"GL_KEEP\"\n"
 349     "\t defaultHeader=\"OSGGL.h\"\n"
 350     "\t access=\"public\"\n"
 351     "\t >\n"
 352     "\tThe stencilFunc defines how fragments which do not fulfill a certain\n"
 353     "\tcondition are handled. \n"
 354     "    See glStencilFunc() for details. GL_NONE is used to disable stencil.\n"
 355     "  </Field>\n"
 356     "  <Field\n"
 357     "\t name=\"stencilOpZFail\"\n"
 358     "\t type=\"GLenum\"\n"
 359     "\t cardinality=\"single\"\n"
 360     "\t visibility=\"external\"\n"
 361     "\t defaultValue=\"GL_KEEP\"\n"
 362     "\t defaultHeader=\"OSGGL.h\"\n"
 363     "\t access=\"public\"\n"
 364     "\t >\n"
 365     "\tThe stencilFunc defines how fragments which do not fulfill a certain\n"
 366     "\tcondition are handled. \n"
 367     "    See glStencilFunc() for details. GL_NONE is used to disable stencil.\n"
 368     "  </Field>\n"
 369     "  <Field\n"
 370     "\t name=\"stencilOpZPass\"\n"
 371     "\t type=\"GLenum\"\n"
 372     "\t cardinality=\"single\"\n"
 373     "\t visibility=\"external\"\n"
 374     "\t defaultValue=\"GL_KEEP\"\n"
 375     "\t defaultHeader=\"OSGGL.h\"\n"
 376     "\t access=\"public\"\n"
 377     "\t >\n"
 378     "\tThe stencilFunc defines how fragments which do not fulfill a certain\n"
 379     "\tcondition are handled. \n"
 380     "    See glStencilFunc() for details. GL_NONE is used to disable stencil.\n"
 381     "  </Field>\n"
 382     "  <Field\n"
 383     "\t name=\"clearBuffer\"\n"
 384     "\t type=\"Int32\"\n"
 385     "\t cardinality=\"single\"\n"
 386     "\t visibility=\"external\"\n"
 387     "\t defaultValue=\"0\"\n"
 388     "\t access=\"public\"\n"
 389     "\t >\n"
 390     "\tClear buffer on activate(1) or deactivate(2).\n"
 391     "  </Field>\n"
 392     "  <Field\n"
 393     "\t name=\"bitMask\"\n"
 394     "\t type=\"UInt32\"\n"
 395     "\t cardinality=\"single\"\n"
 396     "\t visibility=\"external\"\n"
 397     "\t defaultValue=\"0xFFFFFFFF\"\n"
 398     "\t access=\"public\"\n"
 399     "\t >\n"
 400     "\tControls writing of individual bits in stencil planes, with 0 means write\n"
 401     "\tprotected and 1 write enabled.\n"
 402     "  </Field>\n"
 403     "</FieldContainer>\n",
 404     "The stencil chunk handles OpenGL stencil tests by wrapping glStencilFunc()\n"
 405     "and glStencilOp(). \n"
 406     );
 407
 408 /*------------------------------ get -----------------------------------*/
 409
 410 FieldContainerType &StencilChunkBase::getType(void)
 411 {
 412     return _type;
 413 }
 414
 415 const FieldContainerType &StencilChunkBase::getType(void) const
 416 {
 417     return _type;
 418 }
 419
 420 UInt32 StencilChunkBase::getContainerSize(void) const
 421 {
 422     return sizeof(StencilChunk);
 423 }
 424
 425 /*------------------------- decorator get ------------------------------*/
 426
 427
 428 SFGLenum *StencilChunkBase::editSFStencilFunc(void)
 429 {
 430     editSField(StencilFuncFieldMask);
 431
 432     return &_sfStencilFunc;
 433 }
 434
 435 const SFGLenum *StencilChunkBase::getSFStencilFunc(void) const
 436 {
 437     return &_sfStencilFunc;
 438 }
 439
 440
 441 SFInt32 *StencilChunkBase::editSFStencilValue(void)
 442 {
 443     editSField(StencilValueFieldMask);
 444
 445     return &_sfStencilValue;
 446 }
 447
 448 const SFInt32 *StencilChunkBase::getSFStencilValue(void) const
 449 {
 450     return &_sfStencilValue;
 451 }
 452
 453
 454 SFUInt32 *StencilChunkBase::editSFStencilMask(void)
 455 {
 456     editSField(StencilMaskFieldMask);
 457
 458     return &_sfStencilMask;
 459 }
 460
 461 const SFUInt32 *StencilChunkBase::getSFStencilMask(void) const
 462 {
 463     return &_sfStencilMask;
 464 }
 465
 466
 467 SFGLenum *StencilChunkBase::editSFStencilOpFail(void)
 468 {
 469     editSField(StencilOpFailFieldMask);
 470
 471     return &_sfStencilOpFail;
 472 }
 473
 474 const SFGLenum *StencilChunkBase::getSFStencilOpFail(void) const
 475 {
 476     return &_sfStencilOpFail;
 477 }
 478
 479
 480 SFGLenum *StencilChunkBase::editSFStencilOpZFail(void)
 481 {
 482     editSField(StencilOpZFailFieldMask);
 483
 484     return &_sfStencilOpZFail;
 485 }
 486
 487 const SFGLenum *StencilChunkBase::getSFStencilOpZFail(void) const
 488 {
 489     return &_sfStencilOpZFail;
 490 }
 491
 492
 493 SFGLenum *StencilChunkBase::editSFStencilOpZPass(void)
 494 {
 495     editSField(StencilOpZPassFieldMask);
 496
 497     return &_sfStencilOpZPass;
 498 }
 499
 500 const SFGLenum *StencilChunkBase::getSFStencilOpZPass(void) const
 501 {
 502     return &_sfStencilOpZPass;
 503 }
 504
 505
 506 SFInt32 *StencilChunkBase::editSFClearBuffer(void)
 507 {
 508     editSField(ClearBufferFieldMask);
 509
 510     return &_sfClearBuffer;
 511 }
 512
 513 const SFInt32 *StencilChunkBase::getSFClearBuffer(void) const
 514 {
 515     return &_sfClearBuffer;
 516 }
 517
 518
 519 SFUInt32 *StencilChunkBase::editSFBitMask(void)
 520 {
 521     editSField(BitMaskFieldMask);
 522
 523     return &_sfBitMask;
 524 }
 525
 526 const SFUInt32 *StencilChunkBase::getSFBitMask(void) const
 527 {
 528     return &_sfBitMask;
 529 }
 530
 531
 532
 533
 534
 535
 536 /*------------------------------ access -----------------------------------*/
 537
 538 SizeT StencilChunkBase::getBinSize(ConstFieldMaskArg whichField)
 539 {
 540     SizeT returnValue = Inherited::getBinSize(whichField);
 541
 542     if(FieldBits::NoField != (StencilFuncFieldMask & whichField))
 543     {
 544         returnValue += _sfStencilFunc.getBinSize();
 545     }
 546     if(FieldBits::NoField != (StencilValueFieldMask & whichField))
 547     {
 548         returnValue += _sfStencilValue.getBinSize();
 549     }
 550     if(FieldBits::NoField != (StencilMaskFieldMask & whichField))
 551     {
 552         returnValue += _sfStencilMask.getBinSize();
 553     }
 554     if(FieldBits::NoField != (StencilOpFailFieldMask & whichField))
 555     {
 556         returnValue += _sfStencilOpFail.getBinSize();
 557     }
 558     if(FieldBits::NoField != (StencilOpZFailFieldMask & whichField))
 559     {
 560         returnValue += _sfStencilOpZFail.getBinSize();
 561     }
 562     if(FieldBits::NoField != (StencilOpZPassFieldMask & whichField))
 563     {
 564         returnValue += _sfStencilOpZPass.getBinSize();
 565     }
 566     if(FieldBits::NoField != (ClearBufferFieldMask & whichField))
 567     {
 568         returnValue += _sfClearBuffer.getBinSize();
 569     }
 570     if(FieldBits::NoField != (BitMaskFieldMask & whichField))
 571     {
 572         returnValue += _sfBitMask.getBinSize();
 573     }
 574
 575     return returnValue;
 576 }
 577
 578 void StencilChunkBase::copyToBin(BinaryDataHandler &pMem,
 579                                   ConstFieldMaskArg  whichField)
 580 {
 581     Inherited::copyToBin(pMem, whichField);
 582
 583     if(FieldBits::NoField != (StencilFuncFieldMask & whichField))
 584     {
 585         _sfStencilFunc.copyToBin(pMem);
 586     }
 587     if(FieldBits::NoField != (StencilValueFieldMask & whichField))
 588     {
 589         _sfStencilValue.copyToBin(pMem);
 590     }
 591     if(FieldBits::NoField != (StencilMaskFieldMask & whichField))
 592     {
 593         _sfStencilMask.copyToBin(pMem);
 594     }
 595     if(FieldBits::NoField != (StencilOpFailFieldMask & whichField))
 596     {
 597         _sfStencilOpFail.copyToBin(pMem);
 598     }
 599     if(FieldBits::NoField != (StencilOpZFailFieldMask & whichField))
 600     {
 601         _sfStencilOpZFail.copyToBin(pMem);
 602     }
 603     if(FieldBits::NoField != (StencilOpZPassFieldMask & whichField))
 604     {
 605         _sfStencilOpZPass.copyToBin(pMem);
 606     }
 607     if(FieldBits::NoField != (ClearBufferFieldMask & whichField))
 608     {
 609         _sfClearBuffer.copyToBin(pMem);
 610     }
 611     if(FieldBits::NoField != (BitMaskFieldMask & whichField))
 612     {
 613         _sfBitMask.copyToBin(pMem);
 614     }
 615 }
 616
 617 void StencilChunkBase::copyFromBin(BinaryDataHandler &pMem,
 618                                     ConstFieldMaskArg  whichField)
 619 {
 620     Inherited::copyFromBin(pMem, whichField);
 621
 622     if(FieldBits::NoField != (StencilFuncFieldMask & whichField))
 623     {
 624         editSField(StencilFuncFieldMask);
 625         _sfStencilFunc.copyFromBin(pMem);
 626     }
 627     if(FieldBits::NoField != (StencilValueFieldMask & whichField))
 628     {
 629         editSField(StencilValueFieldMask);
 630         _sfStencilValue.copyFromBin(pMem);
 631     }
 632     if(FieldBits::NoField != (StencilMaskFieldMask & whichField))
 633     {
 634         editSField(StencilMaskFieldMask);
 635         _sfStencilMask.copyFromBin(pMem);
 636     }
 637     if(FieldBits::NoField != (StencilOpFailFieldMask & whichField))
 638     {
 639         editSField(StencilOpFailFieldMask);
 640         _sfStencilOpFail.copyFromBin(pMem);
 641     }
 642     if(FieldBits::NoField != (StencilOpZFailFieldMask & whichField))
 643     {
 644         editSField(StencilOpZFailFieldMask);
 645         _sfStencilOpZFail.copyFromBin(pMem);
 646     }
 647     if(FieldBits::NoField != (StencilOpZPassFieldMask & whichField))
 648     {
 649         editSField(StencilOpZPassFieldMask);
 650         _sfStencilOpZPass.copyFromBin(pMem);
 651     }
 652     if(FieldBits::NoField != (ClearBufferFieldMask & whichField))
 653     {
 654         editSField(ClearBufferFieldMask);
 655         _sfClearBuffer.copyFromBin(pMem);
 656     }
 657     if(FieldBits::NoField != (BitMaskFieldMask & whichField))
 658     {
 659         editSField(BitMaskFieldMask);
 660         _sfBitMask.copyFromBin(pMem);
 661     }
 662 }
 663
 664 //! create a new instance of the class
 665 StencilChunkTransitPtr StencilChunkBase::createLocal(BitVector bFlags)
 666 {
 667     StencilChunkTransitPtr fc;
 668
 669     if(getClassType().getPrototype() != NULL)
 670     {
 671         FieldContainerTransitPtr tmpPtr =
 672             getClassType().getPrototype()-> shallowCopyLocal(bFlags);
 673
 674         fc = dynamic_pointer_cast<StencilChunk>(tmpPtr);
 675     }
 676
 677     return fc;
 678 }
 679
 680 //! create a new instance of the class, copy the container flags
 681 StencilChunkTransitPtr StencilChunkBase::createDependent(BitVector bFlags)
 682 {
 683     StencilChunkTransitPtr fc;
 684
 685     if(getClassType().getPrototype() != NULL)
 686     {
 687         FieldContainerTransitPtr tmpPtr =
 688             getClassType().getPrototype()-> shallowCopyDependent(bFlags);
 689
 690         fc = dynamic_pointer_cast<StencilChunk>(tmpPtr);
 691     }
 692
 693     return fc;
 694 }
 695
 696 //! create a new instance of the class
 697 StencilChunkTransitPtr StencilChunkBase::create(void)
 698 {
 699     StencilChunkTransitPtr fc;
 700
 701     if(getClassType().getPrototype() != NULL)
 702     {
 703         FieldContainerTransitPtr tmpPtr =
 704             getClassType().getPrototype()-> shallowCopy();
 705
 706         fc = dynamic_pointer_cast<StencilChunk>(tmpPtr);
 707     }
 708
 709     return fc;
 710 }
 711
 712 StencilChunk *StencilChunkBase::createEmptyLocal(BitVector bFlags)
 713 {
 714     StencilChunk *returnValue;
 715
 716     newPtr<StencilChunk>(returnValue, bFlags);
 717
 718     returnValue->_pFieldFlags->_bNamespaceMask &= ~bFlags;
 719
 720     return returnValue;
 721 }
 722
 723 //! create an empty new instance of the class, do not copy the prototype
 724 StencilChunk *StencilChunkBase::createEmpty(void)
 725 {
 726     StencilChunk *returnValue;
 727
 728     newPtr<StencilChunk>(returnValue, Thread::getCurrentLocalFlags());
 729
 730     returnValue->_pFieldFlags->_bNamespaceMask &=
 731         ~Thread::getCurrentLocalFlags();
 732
 733     return returnValue;
 734 }
 735
 736
 737 FieldContainerTransitPtr StencilChunkBase::shallowCopyLocal(
 738     BitVector bFlags) const
 739 {
 740     StencilChunk *tmpPtr;
 741
 742     newPtr(tmpPtr, dynamic_cast<const StencilChunk *>(this), bFlags);
 743
 744     FieldContainerTransitPtr returnValue(tmpPtr);
 745
 746     tmpPtr->_pFieldFlags->_bNamespaceMask &= ~bFlags;
 747
 748     return returnValue;
 749 }
 750
 751 FieldContainerTransitPtr StencilChunkBase::shallowCopyDependent(
 752     BitVector bFlags) const
 753 {
 754     StencilChunk *tmpPtr;
 755
 756     newPtr(tmpPtr, dynamic_cast<const StencilChunk *>(this), ~bFlags);
 757
 758     FieldContainerTransitPtr returnValue(tmpPtr);
 759
 760     tmpPtr->_pFieldFlags->_bNamespaceMask = bFlags;
 761
 762     return returnValue;
 763 }
 764
 765 FieldContainerTransitPtr StencilChunkBase::shallowCopy(void) const
 766 {
 767     StencilChunk *tmpPtr;
 768
 769     newPtr(tmpPtr,
 770            dynamic_cast<const StencilChunk *>(this),
 771            Thread::getCurrentLocalFlags());
 772
 773     tmpPtr->_pFieldFlags->_bNamespaceMask &= ~Thread::getCurrentLocalFlags();
 774
 775     FieldContainerTransitPtr returnValue(tmpPtr);
 776
 777     return returnValue;
 778 }
 779
 780
 781
 782
 783 /*------------------------- constructors ----------------------------------*/
 784
 785 StencilChunkBase::StencilChunkBase(void) :
 786     Inherited(),
 787     _sfStencilFunc            (GLenum(GL_NONE)),
 788     _sfStencilValue           (Int32(0)),
 789     _sfStencilMask            (UInt32(0x1)),
 790     _sfStencilOpFail          (GLenum(GL_KEEP)),
 791     _sfStencilOpZFail         (GLenum(GL_KEEP)),
 792     _sfStencilOpZPass         (GLenum(GL_KEEP)),
 793     _sfClearBuffer            (Int32(0)),
 794     _sfBitMask                (UInt32(0xFFFFFFFF))
 795 {
 796 }
 797
 798 StencilChunkBase::StencilChunkBase(const StencilChunkBase &source) :
 799     Inherited(source),
 800     _sfStencilFunc            (source._sfStencilFunc            ),
 801     _sfStencilValue           (source._sfStencilValue           ),
 802     _sfStencilMask            (source._sfStencilMask            ),
 803     _sfStencilOpFail          (source._sfStencilOpFail          ),
 804     _sfStencilOpZFail         (source._sfStencilOpZFail         ),
 805     _sfStencilOpZPass         (source._sfStencilOpZPass         ),
 806     _sfClearBuffer            (source._sfClearBuffer            ),
 807     _sfBitMask                (source._sfBitMask                )
 808 {
 809 }
 810
 811
 812 /*-------------------------- destructors ----------------------------------*/
 813
 814 StencilChunkBase::~StencilChunkBase(void)
 815 {
 816 }
 817
 818
 819 GetFieldHandlePtr StencilChunkBase::getHandleStencilFunc     (void) const
 820 {
 821     SFGLenum::GetHandlePtr returnValue(
 822         new  SFGLenum::GetHandle(
 823              &_sfStencilFunc,
 824              this->getType().getFieldDesc(StencilFuncFieldId),
 825              const_cast<StencilChunkBase *>(this)));
 826
 827     return returnValue;
 828 }
 829
 830 EditFieldHandlePtr StencilChunkBase::editHandleStencilFunc    (void)
 831 {
 832     SFGLenum::EditHandlePtr returnValue(
 833         new  SFGLenum::EditHandle(
 834              &_sfStencilFunc,
 835              this->getType().getFieldDesc(StencilFuncFieldId),
 836              this));
 837
 838
 839     editSField(StencilFuncFieldMask);
 840
 841     return returnValue;
 842 }
 843
 844 GetFieldHandlePtr StencilChunkBase::getHandleStencilValue    (void) const
 845 {
 846     SFInt32::GetHandlePtr returnValue(
 847         new  SFInt32::GetHandle(
 848              &_sfStencilValue,
 849              this->getType().getFieldDesc(StencilValueFieldId),
 850              const_cast<StencilChunkBase *>(this)));
 851
 852     return returnValue;
 853 }
 854
 855 EditFieldHandlePtr StencilChunkBase::editHandleStencilValue   (void)
 856 {
 857     SFInt32::EditHandlePtr returnValue(
 858         new  SFInt32::EditHandle(
 859              &_sfStencilValue,
 860              this->getType().getFieldDesc(StencilValueFieldId),
 861              this));
 862
 863
 864     editSField(StencilValueFieldMask);
 865
 866     return returnValue;
 867 }
 868
 869 GetFieldHandlePtr StencilChunkBase::getHandleStencilMask     (void) const
 870 {
 871     SFUInt32::GetHandlePtr returnValue(
 872         new  SFUInt32::GetHandle(
 873              &_sfStencilMask,
 874              this->getType().getFieldDesc(StencilMaskFieldId),
 875              const_cast<StencilChunkBase *>(this)));
 876
 877     return returnValue;
 878 }
 879
 880 EditFieldHandlePtr StencilChunkBase::editHandleStencilMask    (void)
 881 {
 882     SFUInt32::EditHandlePtr returnValue(
 883         new  SFUInt32::EditHandle(
 884              &_sfStencilMask,
 885              this->getType().getFieldDesc(StencilMaskFieldId),
 886              this));
 887
 888
 889     editSField(StencilMaskFieldMask);
 890
 891     return returnValue;
 892 }
 893
 894 GetFieldHandlePtr StencilChunkBase::getHandleStencilOpFail   (void) const
 895 {
 896     SFGLenum::GetHandlePtr returnValue(
 897         new  SFGLenum::GetHandle(
 898              &_sfStencilOpFail,
 899              this->getType().getFieldDesc(StencilOpFailFieldId),
 900              const_cast<StencilChunkBase *>(this)));
 901
 902     return returnValue;
 903 }
 904
 905 EditFieldHandlePtr StencilChunkBase::editHandleStencilOpFail  (void)
 906 {
 907     SFGLenum::EditHandlePtr returnValue(
 908         new  SFGLenum::EditHandle(
 909              &_sfStencilOpFail,
 910              this->getType().getFieldDesc(StencilOpFailFieldId),
 911              this));
 912
 913
 914     editSField(StencilOpFailFieldMask);
 915
 916     return returnValue;
 917 }
 918
 919 GetFieldHandlePtr StencilChunkBase::getHandleStencilOpZFail  (void) const
 920 {
 921     SFGLenum::GetHandlePtr returnValue(
 922         new  SFGLenum::GetHandle(
 923              &_sfStencilOpZFail,
 924              this->getType().getFieldDesc(StencilOpZFailFieldId),
 925              const_cast<StencilChunkBase *>(this)));
 926
 927     return returnValue;
 928 }
 929
 930 EditFieldHandlePtr StencilChunkBase::editHandleStencilOpZFail (void)
 931 {
 932     SFGLenum::EditHandlePtr returnValue(
 933         new  SFGLenum::EditHandle(
 934              &_sfStencilOpZFail,
 935              this->getType().getFieldDesc(StencilOpZFailFieldId),
 936              this));
 937
 938
 939     editSField(StencilOpZFailFieldMask);
 940
 941     return returnValue;
 942 }
 943
 944 GetFieldHandlePtr StencilChunkBase::getHandleStencilOpZPass  (void) const
 945 {
 946     SFGLenum::GetHandlePtr returnValue(
 947         new  SFGLenum::GetHandle(
 948              &_sfStencilOpZPass,
 949              this->getType().getFieldDesc(StencilOpZPassFieldId),
 950              const_cast<StencilChunkBase *>(this)));
 951
 952     return returnValue;
 953 }
 954
 955 EditFieldHandlePtr StencilChunkBase::editHandleStencilOpZPass (void)
 956 {
 957     SFGLenum::EditHandlePtr returnValue(
 958         new  SFGLenum::EditHandle(
 959              &_sfStencilOpZPass,
 960              this->getType().getFieldDesc(StencilOpZPassFieldId),
 961              this));
 962
 963
 964     editSField(StencilOpZPassFieldMask);
 965
 966     return returnValue;
 967 }
 968
 969 GetFieldHandlePtr StencilChunkBase::getHandleClearBuffer     (void) const
 970 {
 971     SFInt32::GetHandlePtr returnValue(
 972         new  SFInt32::GetHandle(
 973              &_sfClearBuffer,
 974              this->getType().getFieldDesc(ClearBufferFieldId),
 975              const_cast<StencilChunkBase *>(this)));
 976
 977     return returnValue;
 978 }
 979
 980 EditFieldHandlePtr StencilChunkBase::editHandleClearBuffer    (void)
 981 {
 982     SFInt32::EditHandlePtr returnValue(
 983         new  SFInt32::EditHandle(
 984              &_sfClearBuffer,
 985              this->getType().getFieldDesc(ClearBufferFieldId),
 986              this));
 987
 988
 989     editSField(ClearBufferFieldMask);
 990
 991     return returnValue;
 992 }
 993
 994 GetFieldHandlePtr StencilChunkBase::getHandleBitMask         (void) const
 995 {
 996     SFUInt32::GetHandlePtr returnValue(
 997         new  SFUInt32::GetHandle(
 998              &_sfBitMask,
 999              this->getType().getFieldDesc(BitMaskFieldId),
1000              const_cast<StencilChunkBase *>(this)));
1001
1002     return returnValue;
1003 }
1004
1005 EditFieldHandlePtr StencilChunkBase::editHandleBitMask        (void)
1006 {
1007     SFUInt32::EditHandlePtr returnValue(
1008         new  SFUInt32::EditHandle(
1009              &_sfBitMask,
1010              this->getType().getFieldDesc(BitMaskFieldId),
1011              this));
1012
1013
1014     editSField(BitMaskFieldMask);
1015
1016     return returnValue;
1017 }
1018
1019
1020 #ifdef OSG_MT_CPTR_ASPECT
1021 void StencilChunkBase::execSyncV(      FieldContainer    &oFrom,
1022                                         ConstFieldMaskArg  whichField,
1023                                         AspectOffsetStore &oOffsets,
1024                                         ConstFieldMaskArg  syncMode,
1025                                   const UInt32             uiSyncInfo)
1026 {
1027     StencilChunk *pThis = static_cast<StencilChunk *>(this);
1028
1029     pThis->execSync(static_cast<StencilChunk *>(&oFrom),
1030                     whichField,
1031                     oOffsets,
1032                     syncMode,
1033                     uiSyncInfo);
1034 }
1035 #endif
1036
1037
1038 #ifdef OSG_MT_CPTR_ASPECT
1039 FieldContainer *StencilChunkBase::createAspectCopy(
1040     const FieldContainer *pRefAspect) const
1041 {
1042     StencilChunk *returnValue;
1043
1044     newAspectCopy(returnValue,
1045                   dynamic_cast<const StencilChunk *>(pRefAspect),
1046                   dynamic_cast<const StencilChunk *>(this));
1047
1048     return returnValue;
1049 }
1050 #endif
1051
1052 void StencilChunkBase::resolveLinks(void)
1053 {
1054     Inherited::resolveLinks();
1055
1056
1057 }
1058
1059
1060 OSG_END_NAMESPACE