Source/System/State/OpenGL/OSGLogicOpChunkBase.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 LogicOpChunk!
  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"                        // LogicOp default header
  65
  66
  67 #include "OSGLogicOpChunkBase.h"
  68 #include "OSGLogicOpChunk.h"
  69
  70 #include <boost/bind.hpp>
  71
  72 OSG_BEGIN_NAMESPACE
  73
  74 /***************************************************************************\
  75  *                            Description                                  *
  76 \***************************************************************************/
  77
  78 /*! \class OSG::LogicOpChunk
  79     The logic op chunk contains the parameters that specify the logic operation
  80     applied to fragments before writing them to the framebuffer. The following
  81     OpenGL functionality is wrapped here:
  82     glLogicOp(OSG::LogicOpChunk::_sfLogicOp).
  83  */
  84
  85 /***************************************************************************\
  86  *                        Field Documentation                              *
  87 \***************************************************************************/
  88
  89 /*! \var GLenum          LogicOpChunkBase::_sfLogicOp
  90     The logic operation applied to fragments.
  91 */
  92
  93
  94 /***************************************************************************\
  95  *                      FieldType/FieldTrait Instantiation                 *
  96 \***************************************************************************/
  97
  98 #if !defined(OSG_DO_DOC) || defined(OSG_DOC_DEV)
  99 PointerType FieldTraits<LogicOpChunk *, nsOSG>::_type(
 100     "LogicOpChunkPtr",
 101     "StateChunkPtr",
 102     LogicOpChunk::getClassType(),
 103     nsOSG);
 104 #endif
 105
 106 OSG_FIELDTRAITS_GETTYPE_NS(LogicOpChunk *, nsOSG)
 107
 108 OSG_EXPORT_PTR_SFIELD_FULL(PointerSField,
 109                            LogicOpChunk *,
 110                            nsOSG)
 111
 112 OSG_EXPORT_PTR_MFIELD_FULL(PointerMField,
 113                            LogicOpChunk *,
 114                            nsOSG)
 115
 116 /***************************************************************************\
 117  *                         Field Description                               *
 118 \***************************************************************************/
 119
 120 void LogicOpChunkBase::classDescInserter(TypeObject &oType)
 121 {
 122     FieldDescriptionBase *pDesc = NULL;
 123
 124
 125     pDesc = new SFGLenum::Description(
 126         SFGLenum::getClassType(),
 127         "LogicOp",
 128         "The logic operation applied to fragments.\n",
 129         LogicOpFieldId, LogicOpFieldMask,
 130         false,
 131         (Field::SFDefaultFlags | Field::FStdAccess),
 132         static_cast<FieldEditMethodSig>(&LogicOpChunk::editHandleLogicOp),
 133         static_cast<FieldGetMethodSig >(&LogicOpChunk::getHandleLogicOp));
 134
 135     oType.addInitialDesc(pDesc);
 136 }
 137
 138
 139 LogicOpChunkBase::TypeObject LogicOpChunkBase::_type(
 140     LogicOpChunkBase::getClassname(),
 141     Inherited::getClassname(),
 142     "NULL",
 143     nsOSG, //Namespace
 144     reinterpret_cast<PrototypeCreateF>(&LogicOpChunkBase::createEmptyLocal),
 145     reinterpret_cast<InitContainerF>(&LogicOpChunk::initMethod),
 146     reinterpret_cast<ExitContainerF>(&LogicOpChunk::exitMethod),
 147     reinterpret_cast<InitalInsertDescFunc>(
 148         reinterpret_cast<void *>(&LogicOpChunk::classDescInserter)),
 149     false,
 150     0,
 151     "<?xml version=\"1.0\"?>\n"
 152     "\n"
 153     "<FieldContainer\n"
 154     "   name=\"LogicOpChunk\"\n"
 155     "   parent=\"StateChunk\"\n"
 156     "   library=\"State\"\n"
 157     "   pointerfieldtypes=\"both\"\n"
 158     "   structure=\"concrete\"\n"
 159     "   systemcomponent=\"true\"\n"
 160     "   parentsystemcomponent=\"true\"\n"
 161     "   docGroupBase=\"GrpStateOpenGL\"\n"
 162     "   >\n"
 163     "  The logic op chunk contains the parameters that specify the logic operation\n"
 164     "  applied to fragments before writing them to the framebuffer. The following\n"
 165     "  OpenGL functionality is wrapped here: \n"
 166     "  glLogicOp(OSG::LogicOpChunk::_sfLogicOp). \n"
 167     "  <Field\n"
 168     "     name=\"LogicOp\"\n"
 169     "     category=\"data\"\n"
 170     "     type=\"GLenum\"\n"
 171     "     cardinality=\"single\"\n"
 172     "     visibility=\"external\"\n"
 173     "     defaultValue=\"GL_COPY\"\n"
 174     "     defaultHeader=\"OSGGL.h\"\n"
 175     "     access=\"public\"\n"
 176     "     >\n"
 177     "    The logic operation applied to fragments.\n"
 178     "  </Field>\n"
 179     "</FieldContainer>\n",
 180     "The logic op chunk contains the parameters that specify the logic operation\n"
 181     "applied to fragments before writing them to the framebuffer. The following\n"
 182     "OpenGL functionality is wrapped here: \n"
 183     "glLogicOp(OSG::LogicOpChunk::_sfLogicOp). \n"
 184     );
 185
 186 /*------------------------------ get -----------------------------------*/
 187
 188 FieldContainerType &LogicOpChunkBase::getType(void)
 189 {
 190     return _type;
 191 }
 192
 193 const FieldContainerType &LogicOpChunkBase::getType(void) const
 194 {
 195     return _type;
 196 }
 197
 198 UInt32 LogicOpChunkBase::getContainerSize(void) const
 199 {
 200     return sizeof(LogicOpChunk);
 201 }
 202
 203 /*------------------------- decorator get ------------------------------*/
 204
 205
 206 SFGLenum *LogicOpChunkBase::editSFLogicOp(void)
 207 {
 208     editSField(LogicOpFieldMask);
 209
 210     return &_sfLogicOp;
 211 }
 212
 213 const SFGLenum *LogicOpChunkBase::getSFLogicOp(void) const
 214 {
 215     return &_sfLogicOp;
 216 }
 217
 218
 219
 220
 221
 222
 223 /*------------------------------ access -----------------------------------*/
 224
 225 SizeT LogicOpChunkBase::getBinSize(ConstFieldMaskArg whichField)
 226 {
 227     SizeT returnValue = Inherited::getBinSize(whichField);
 228
 229     if(FieldBits::NoField != (LogicOpFieldMask & whichField))
 230     {
 231         returnValue += _sfLogicOp.getBinSize();
 232     }
 233
 234     return returnValue;
 235 }
 236
 237 void LogicOpChunkBase::copyToBin(BinaryDataHandler &pMem,
 238                                   ConstFieldMaskArg  whichField)
 239 {
 240     Inherited::copyToBin(pMem, whichField);
 241
 242     if(FieldBits::NoField != (LogicOpFieldMask & whichField))
 243     {
 244         _sfLogicOp.copyToBin(pMem);
 245     }
 246 }
 247
 248 void LogicOpChunkBase::copyFromBin(BinaryDataHandler &pMem,
 249                                     ConstFieldMaskArg  whichField)
 250 {
 251     Inherited::copyFromBin(pMem, whichField);
 252
 253     if(FieldBits::NoField != (LogicOpFieldMask & whichField))
 254     {
 255         editSField(LogicOpFieldMask);
 256         _sfLogicOp.copyFromBin(pMem);
 257     }
 258 }
 259
 260 //! create a new instance of the class
 261 LogicOpChunkTransitPtr LogicOpChunkBase::createLocal(BitVector bFlags)
 262 {
 263     LogicOpChunkTransitPtr fc;
 264
 265     if(getClassType().getPrototype() != NULL)
 266     {
 267         FieldContainerTransitPtr tmpPtr =
 268             getClassType().getPrototype()-> shallowCopyLocal(bFlags);
 269
 270         fc = dynamic_pointer_cast<LogicOpChunk>(tmpPtr);
 271     }
 272
 273     return fc;
 274 }
 275
 276 //! create a new instance of the class, copy the container flags
 277 LogicOpChunkTransitPtr LogicOpChunkBase::createDependent(BitVector bFlags)
 278 {
 279     LogicOpChunkTransitPtr fc;
 280
 281     if(getClassType().getPrototype() != NULL)
 282     {
 283         FieldContainerTransitPtr tmpPtr =
 284             getClassType().getPrototype()-> shallowCopyDependent(bFlags);
 285
 286         fc = dynamic_pointer_cast<LogicOpChunk>(tmpPtr);
 287     }
 288
 289     return fc;
 290 }
 291
 292 //! create a new instance of the class
 293 LogicOpChunkTransitPtr LogicOpChunkBase::create(void)
 294 {
 295     LogicOpChunkTransitPtr fc;
 296
 297     if(getClassType().getPrototype() != NULL)
 298     {
 299         FieldContainerTransitPtr tmpPtr =
 300             getClassType().getPrototype()-> shallowCopy();
 301
 302         fc = dynamic_pointer_cast<LogicOpChunk>(tmpPtr);
 303     }
 304
 305     return fc;
 306 }
 307
 308 LogicOpChunk *LogicOpChunkBase::createEmptyLocal(BitVector bFlags)
 309 {
 310     LogicOpChunk *returnValue;
 311
 312     newPtr<LogicOpChunk>(returnValue, bFlags);
 313
 314     returnValue->_pFieldFlags->_bNamespaceMask &= ~bFlags;
 315
 316     return returnValue;
 317 }
 318
 319 //! create an empty new instance of the class, do not copy the prototype
 320 LogicOpChunk *LogicOpChunkBase::createEmpty(void)
 321 {
 322     LogicOpChunk *returnValue;
 323
 324     newPtr<LogicOpChunk>(returnValue, Thread::getCurrentLocalFlags());
 325
 326     returnValue->_pFieldFlags->_bNamespaceMask &=
 327         ~Thread::getCurrentLocalFlags();
 328
 329     return returnValue;
 330 }
 331
 332
 333 FieldContainerTransitPtr LogicOpChunkBase::shallowCopyLocal(
 334     BitVector bFlags) const
 335 {
 336     LogicOpChunk *tmpPtr;
 337
 338     newPtr(tmpPtr, dynamic_cast<const LogicOpChunk *>(this), bFlags);
 339
 340     FieldContainerTransitPtr returnValue(tmpPtr);
 341
 342     tmpPtr->_pFieldFlags->_bNamespaceMask &= ~bFlags;
 343
 344     return returnValue;
 345 }
 346
 347 FieldContainerTransitPtr LogicOpChunkBase::shallowCopyDependent(
 348     BitVector bFlags) const
 349 {
 350     LogicOpChunk *tmpPtr;
 351
 352     newPtr(tmpPtr, dynamic_cast<const LogicOpChunk *>(this), ~bFlags);
 353
 354     FieldContainerTransitPtr returnValue(tmpPtr);
 355
 356     tmpPtr->_pFieldFlags->_bNamespaceMask = bFlags;
 357
 358     return returnValue;
 359 }
 360
 361 FieldContainerTransitPtr LogicOpChunkBase::shallowCopy(void) const
 362 {
 363     LogicOpChunk *tmpPtr;
 364
 365     newPtr(tmpPtr,
 366            dynamic_cast<const LogicOpChunk *>(this),
 367            Thread::getCurrentLocalFlags());
 368
 369     tmpPtr->_pFieldFlags->_bNamespaceMask &= ~Thread::getCurrentLocalFlags();
 370
 371     FieldContainerTransitPtr returnValue(tmpPtr);
 372
 373     return returnValue;
 374 }
 375
 376
 377
 378
 379 /*------------------------- constructors ----------------------------------*/
 380
 381 LogicOpChunkBase::LogicOpChunkBase(void) :
 382     Inherited(),
 383     _sfLogicOp                (GLenum(GL_COPY))
 384 {
 385 }
 386
 387 LogicOpChunkBase::LogicOpChunkBase(const LogicOpChunkBase &source) :
 388     Inherited(source),
 389     _sfLogicOp                (source._sfLogicOp                )
 390 {
 391 }
 392
 393
 394 /*-------------------------- destructors ----------------------------------*/
 395
 396 LogicOpChunkBase::~LogicOpChunkBase(void)
 397 {
 398 }
 399
 400
 401 GetFieldHandlePtr LogicOpChunkBase::getHandleLogicOp         (void) const
 402 {
 403     SFGLenum::GetHandlePtr returnValue(
 404         new  SFGLenum::GetHandle(
 405              &_sfLogicOp,
 406              this->getType().getFieldDesc(LogicOpFieldId),
 407              const_cast<LogicOpChunkBase *>(this)));
 408
 409     return returnValue;
 410 }
 411
 412 EditFieldHandlePtr LogicOpChunkBase::editHandleLogicOp        (void)
 413 {
 414     SFGLenum::EditHandlePtr returnValue(
 415         new  SFGLenum::EditHandle(
 416              &_sfLogicOp,
 417              this->getType().getFieldDesc(LogicOpFieldId),
 418              this));
 419
 420
 421     editSField(LogicOpFieldMask);
 422
 423     return returnValue;
 424 }
 425
 426
 427 #ifdef OSG_MT_CPTR_ASPECT
 428 void LogicOpChunkBase::execSyncV(      FieldContainer    &oFrom,
 429                                         ConstFieldMaskArg  whichField,
 430                                         AspectOffsetStore &oOffsets,
 431                                         ConstFieldMaskArg  syncMode,
 432                                   const UInt32             uiSyncInfo)
 433 {
 434     LogicOpChunk *pThis = static_cast<LogicOpChunk *>(this);
 435
 436     pThis->execSync(static_cast<LogicOpChunk *>(&oFrom),
 437                     whichField,
 438                     oOffsets,
 439                     syncMode,
 440                     uiSyncInfo);
 441 }
 442 #endif
 443
 444
 445 #ifdef OSG_MT_CPTR_ASPECT
 446 FieldContainer *LogicOpChunkBase::createAspectCopy(
 447     const FieldContainer *pRefAspect) const
 448 {
 449     LogicOpChunk *returnValue;
 450
 451     newAspectCopy(returnValue,
 452                   dynamic_cast<const LogicOpChunk *>(pRefAspect),
 453                   dynamic_cast<const LogicOpChunk *>(this));
 454
 455     return returnValue;
 456 }
 457 #endif
 458
 459 void LogicOpChunkBase::resolveLinks(void)
 460 {
 461     Inherited::resolveLinks();
 462
 463
 464 }
 465
 466
 467 OSG_END_NAMESPACE