Source/System/State/Base/OSGMultiLightChunkBase.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 MultiLightChunk!
  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
  65 #include "OSGNode.h"                    // Beacon Class
  66
  67 #include "OSGMultiLightChunkBase.h"
  68 #include "OSGMultiLightChunk.h"
  69
  70 #include <boost/bind.hpp>
  71
  72 OSG_BEGIN_NAMESPACE
  73
  74 /***************************************************************************\
  75  *                            Description                                  *
  76 \***************************************************************************/
  77
  78 /*! \class OSG::MultiLightChunk
  79     See \ref PageSystemMultiLightChunk for a description.
  80
  81     This chunk represents a number of lights that are exposed to shader code
  82     in form of a buffer in OpenGL std430 layout format.
  83     A shader, binding a shader storage block to the very same binding point,
  84     is expected to respect the corresponding block layout. The layout is regulated
  85     by the hasXXX fields of the chunk. If one is set to false the corresponding
  86     struct entry is omitted.
  87
  88     struct Light
  89     {
  90     mat4  worldToLightSpaceMatrix;
  91     mat4  lightToWorldSpaceMatrix;
  92     mat4  eyeToLightSpaceMatrix;
  93     mat4  lightToEyeSpaceMatrix;
  94     mat4  lightPerspectiveMatrix;
  95     mat4  invLightPerspectiveMatrix;
  96     vec3  position;
  97     vec3  direction;
  98     vec3  color;
  99     vec3  ambientIntensity;
 100     vec3  diffuseIntensity;
 101     vec3  specularIntensity;
 102     float intensity;
 103     float constantAttenuation;
 104     float linearAttenuation;
 105     float quadraticAttenuation;
 106     float rangeCutOn;
 107     float rangeCutOff;
 108     float rangeNearZone;
 109     float rangeFarZone;
 110     float cosSpotlightAngle;
 111     float spotlightAngle;
 112     float spotExponent;
 113     float innerSuperEllipsesWidth;
 114     float innerSuperEllipsesHeight;
 115     float outerSuperEllipsesWidth;
 116     float outerSuperEllipsesHeight;
 117     float superEllipsesRoundness;
 118     float superEllipsesTwist;
 119     int   type;
 120     bool  enabled;
 121     };
 122
 123     layout (std430) buffer Lights
 124     {
 125     Light light[];
 126     } lights;
 127
 128     The chunk provides a convenient function that allows to adjust the struct layout
 129     for standard OpenGL lights
 130
 131     struct Light
 132     {
 133     vec3  position;
 134     vec3  direction;
 135     vec3  ambientIntensity;
 136     vec3  diffuseIntensity;
 137     vec3  specularIntensity;
 138     float constantAttenuation;
 139     float linearAttenuation;
 140     float quadraticAttenuation;
 141     float cosSpotlightAngle;
 142     float spotExponent;
 143     int   type;
 144     bool  enabled;
 145     };
 146
 147     or for simple range lights:
 148
 149     struct Light
 150     {
 151     vec3  position;
 152     vec3  direction;
 153     vec3  color;
 154     float intensity;
 155     float rangeCutOff;
 156     float cosSpotlightAngle;
 157     int   type;
 158     bool  enabled;
 159     };
 160  */
 161
 162 /***************************************************************************\
 163  *                        Field Documentation                              *
 164 \***************************************************************************/
 165
 166 /*! \var bool            MultiLightChunkBase::_sfHasWorldToLightSpaceMatrix
 167     This flag determines if the worldToLightSpaceMatrix attribute is part of
 168     the shader storage block, i.e. if the "mat4  worldToLightSpaceMatrix;"
 169     entry is contained in the shader struct for the Light.
 170 */
 171
 172 /*! \var bool            MultiLightChunkBase::_sfHasLightToWorldSpaceMatrix
 173     This flag determines if the lightToWorldSpaceMatrix attribute is part of
 174     the shader storage block, i.e. if the "mat4  lightToWorldSpaceMatrix;"
 175     entry is contained in the shader struct for the Light.
 176 */
 177
 178 /*! \var bool            MultiLightChunkBase::_sfHasEyeToLightSpaceMatrix
 179     This flag determines if the eyeToLightSpaceMatrix attribute is part of
 180     the shader storage block, i.e. if the "mat4  eyeToLightSpaceMatrix;"
 181     entry is contained in the shader struct for the Light.
 182     Attention: If this flag is set the light shader storage block has to
 183     be updated with every redraw operation.
 184 */
 185
 186 /*! \var bool            MultiLightChunkBase::_sfHasLightToEyeSpaceMatrix
 187     This flag determines if the lightToEyeSpaceMatrix attribute is part of
 188     the shader storage block, i.e. if the "mat4  lightToEyeSpaceMatrix;"
 189     entry is contained in the shader struct for the Light.
 190     Attention: If this flag is set the light shader storage block has to
 191     be updated with every redraw operation.
 192 */
 193
 194 /*! \var bool            MultiLightChunkBase::_sfHasLightPerspectiveMatrix
 195     This flag determines if the lightPerspectiveMatrix attribute is part of
 196     the shader storage block, i.e. if the "mat4  lightPerspectiveMatrix;"
 197     entry is contained in the shader struct for the Light.
 198 */
 199
 200 /*! \var bool            MultiLightChunkBase::_sfHasInvLightPerspectiveMatrix
 201     This flag determines if the lightToEyeSpaceMatrix attribute is part of
 202     the shader storage block, i.e. if the "mat4  invLightToEyeSpaceMatrix;"
 203     entry is contained in the shader struct for the Light.
 204 */
 205
 206 /*! \var bool            MultiLightChunkBase::_sfHasColor
 207     This flag determines if the color attribute is part of the shader storage block, i.e.
 208     if the "vec3  color;" entry is contained in the shader struct for the Light.
 209 */
 210
 211 /*! \var bool            MultiLightChunkBase::_sfHasIntensity
 212     This flag determines if the intensity attribute is part of the shader storage block, i.e.
 213     if the "float intensity;" entry is contained in the shader struct for the Light.
 214 */
 215
 216 /*! \var bool            MultiLightChunkBase::_sfHasSeparateIntensities
 217     This flag determines if the color intensity attributes are part of the shader storage block, i.e.
 218     if the "vec3  Ia;", "vec3  Id;" and "vec3 Is;" entries are contained in the shader struct for the Light.
 219 */
 220
 221 /*! \var bool            MultiLightChunkBase::_sfHasAttenuation
 222     This flag determines if the attenuation attributes are part of the shader storage block, i.e.
 223     if the "float constantAttenuation;", "float linearAttenuation;" and "float quadraticAttenuation;"
 224     entries are contained in the shader struct for the Light.
 225 */
 226
 227 /*! \var bool            MultiLightChunkBase::_sfAutoCalcRanges
 228     If this flag is active and the lights have attenuations, then the cut on and cut off ranges
 229     are automatically calculated. They are, however, not provided automatically to the shader.
 230     For that, you have to set the hasRangeCutOn and hasRangeCutOff flags, respectively.
 231 */
 232
 233 /*! \var bool            MultiLightChunkBase::_sfHasRangeCutOn
 234     This flag determines if the rangeCutOn attribute is part of the shader storage block, i.e.
 235     if the "float rangeCutOn;" entry is contained in the shader struct for the Light.
 236 */
 237
 238 /*! \var bool            MultiLightChunkBase::_sfHasRangeCutOff
 239     This flag determines if the hasRangeCutOff attribute is part of the shader storage block, i.e.
 240     if the "float hasRangeCutOff;" entry is contained in the shader struct for the Light.
 241 */
 242
 243 /*! \var bool            MultiLightChunkBase::_sfHasRangeNearZone
 244     This flag determines if the hasRangeNearZone attribute is part of the shader storage block, i.e.
 245     if the "float hasRangeNearZone;" entry is contained in the shader struct for the Light.
 246 */
 247
 248 /*! \var bool            MultiLightChunkBase::_sfHasRangeFarZone
 249     This flag determines if the hasRangeFarZone attribute is part of the shader storage block, i.e.
 250     if the "float hasRangeFarZone;" entry is contained in the shader struct for the Light.
 251 */
 252
 253 /*! \var bool            MultiLightChunkBase::_sfHasCosSpotlightAngle
 254     This flag determines if the cosine of the spot light angle attribute is part of the shader storage block, i.e.
 255     if the "float  cosSpotlightAngle;" entry is contained in the shader struct for the Light. If neither this flag
 256     nor the hasSpotlightAngle flag is true, then this flag is treated as if it has value true.
 257 */
 258
 259 /*! \var bool            MultiLightChunkBase::_sfHasSpotlightAngle
 260     This flag determines if the spot light angle attribute is part of the shader storage block, i.e.
 261     if the "float  spotlightAngle;" entry is contained in the shader struct for the Light. If neither this flag
 262     nor the hasCosSpotlightAngle flag is true, then the hasCosSpotlightAngle flag is treated as if it has value true.
 263 */
 264
 265 /*! \var bool            MultiLightChunkBase::_sfHasSpotExponent
 266     This flag determines if the spot expenent attribute is part of the shader storage block, i.e.
 267     if the "float  spotExponent;" entry is contained in the shader struct for the Light.
 268 */
 269
 270 /*! \var bool            MultiLightChunkBase::_sfHasCinemaLight
 271     This flag determines if the cinema light attributes are part of the shader storage block, i.e.
 272     if the "float innerSuperEllipsesWidth;", ... entries are contained in the shader struct for the Light.
 273     If true this flag overrides the hasRangeCutOn, hasRangeCutOff, hasRangeNearZone and hasRangeFarZone
 274     flags, because cinema lights are described the corresponding attributes.
 275     See: http://http.developer.nvidia.com/GPUGems/gpugems_ch10.html
 276     http://www.yaldex.com/open-gl/ch12lev1sec4.html
 277     https://en.wikipedia.org/wiki/Superellipse
 278 */
 279
 280 /*! \var Pnt3f           MultiLightChunkBase::_mfPosition
 281     The light's position for point and spotlights in beacon space.
 282 */
 283
 284 /*! \var Vec3f           MultiLightChunkBase::_mfDirection
 285     The light's direction for directional and spotlights in beacon space.
 286 */
 287
 288 /*! \var Color3f         MultiLightChunkBase::_mfColor
 289     The light's color.
 290 */
 291
 292 /*! \var Real32          MultiLightChunkBase::_mfIntensity
 293     The light's intensity.
 294 */
 295
 296 /*! \var Vec3f           MultiLightChunkBase::_mfAmbientIntensity
 297     The light's ambient intensity.
 298 */
 299
 300 /*! \var Vec3f           MultiLightChunkBase::_mfDiffuseIntensity
 301     The light's diffuse intensity.
 302 */
 303
 304 /*! \var Vec3f           MultiLightChunkBase::_mfSpecularIntensity
 305     The light's specular intensity.
 306 */
 307
 308 /*! \var Vec3f           MultiLightChunkBase::_mfAttenuation
 309     The light's attenuation consiting of the constant, linear and quadratic attenuation parts.
 310 */
 311
 312 /*! \var Real32          MultiLightChunkBase::_mfSpotlightAngle
 313     The spot angle in degree.
 314 */
 315
 316 /*! \var Real32          MultiLightChunkBase::_mfSpotExponent
 317     The spot angle in degree.
 318 */
 319
 320 /*! \var Real32          MultiLightChunkBase::_mfInnerSuperEllipsesWidth
 321     The cinema light is described among others by an inner ellipses. This is
 322     the width of this ellipse.
 323     See: http://http.developer.nvidia.com/GPUGems/gpugems_ch10.html
 324     http://www.yaldex.com/open-gl/ch12lev1sec4.html
 325     https://en.wikipedia.org/wiki/Superellipse
 326 */
 327
 328 /*! \var Real32          MultiLightChunkBase::_mfInnerSuperEllipsesHeight
 329     The cinema light is described among others by an inner ellipses. This is
 330     the height of this ellipse.
 331     See: http://http.developer.nvidia.com/GPUGems/gpugems_ch10.html
 332     http://www.yaldex.com/open-gl/ch12lev1sec4.html
 333     https://en.wikipedia.org/wiki/Superellipse
 334 */
 335
 336 /*! \var Real32          MultiLightChunkBase::_mfOuterSuperEllipsesWidth
 337     The cinema light is described among others by an outer ellipses. This is
 338     the width of this ellipse.
 339     See: http://http.developer.nvidia.com/GPUGems/gpugems_ch10.html
 340     http://www.yaldex.com/open-gl/ch12lev1sec4.html
 341     https://en.wikipedia.org/wiki/Superellipse
 342 */
 343
 344 /*! \var Real32          MultiLightChunkBase::_mfOuterSuperEllipsesHeight
 345     The cinema light is described among others by an outer ellipses. This is
 346     the height of this ellipse.
 347     See: http://http.developer.nvidia.com/GPUGems/gpugems_ch10.html
 348     http://www.yaldex.com/open-gl/ch12lev1sec4.html
 349     https://en.wikipedia.org/wiki/Superellipse
 350 */
 351
 352 /*! \var Real32          MultiLightChunkBase::_mfSuperEllipsesRoundness
 353     The cinema light is described among others by a roundness parameter.
 354     See: http://http.developer.nvidia.com/GPUGems/gpugems_ch10.html
 355     http://www.yaldex.com/open-gl/ch12lev1sec4.html
 356     https://en.wikipedia.org/wiki/Superellipse
 357 */
 358
 359 /*! \var Real32          MultiLightChunkBase::_mfSuperEllipsesTwist
 360     The twist angle in degree by which the superellipses is rotatet in the xy-plane.
 361 */
 362
 363 /*! \var Real32          MultiLightChunkBase::_mfRangeCutOn
 364     The cinema light is described among others by a rangeCutOn parameter.
 365     In the interval rangeCutOn to rangeCutOff the lighted fragments are
 366     fully lit.
 367     See: http://http.developer.nvidia.com/GPUGems/gpugems_ch10.html
 368     http://www.yaldex.com/open-gl/ch12lev1sec4.html
 369     https://en.wikipedia.org/wiki/Superellipse
 370 */
 371
 372 /*! \var Real32          MultiLightChunkBase::_mfRangeCutOff
 373     The cinema light is described among others by a rangeCutOff parameter.
 374     In the interval rangeCutOn to rangeCutOff the lighted fragments are
 375     fully lit.
 376     See: http://http.developer.nvidia.com/GPUGems/gpugems_ch10.html
 377     http://www.yaldex.com/open-gl/ch12lev1sec4.html
 378     https://en.wikipedia.org/wiki/Superellipse
 379 */
 380
 381 /*! \var Real32          MultiLightChunkBase::_mfRangeNearZone
 382     The cinema light is described among others by a rangeNearZone parameter.
 383     In the interval rangeCutOn-rangeNearZone to rangeCutOn the lighted fragments are
 384     partly lit.
 385     See: http://http.developer.nvidia.com/GPUGems/gpugems_ch10.html
 386     http://www.yaldex.com/open-gl/ch12lev1sec4.html
 387     https://en.wikipedia.org/wiki/Superellipse
 388 */
 389
 390 /*! \var Real32          MultiLightChunkBase::_mfRangeFarZone
 391     In the interval rangeCutOff to rangeCutOff+rangeFarZone the lighted fragments are
 392     partly lit.
 393 */
 394
 395 /*! \var UInt8           MultiLightChunkBase::_mfType
 396     Stores the light's type. This can be any of the set {POINT_LIGHT, DIRECTIONAL_LIGHT, SPOT_LIGHT, CINEMA_LIGHT}.
 397 */
 398
 399 /*! \var bool            MultiLightChunkBase::_mfEnabled
 400     The on/off state of the light.
 401 */
 402
 403 /*! \var Node *          MultiLightChunkBase::_mfBeacon
 404     The light's beacon determining its position or direction.
 405 */
 406
 407 /*! \var Matrix          MultiLightChunkBase::_mfBeaconMatrix
 408     The beacon matrices used for the last render pass.
 409 */
 410
 411 /*! \var bool            MultiLightChunkBase::_sfEyeSpace
 412     The lights position and direction are transformed to eye space before loading into the shader.
 413     On default they are provided in world space.
 414 */
 415
 416 /*! \var Real32          MultiLightChunkBase::_sfLastCamNear
 417     The camera last near value.
 418 */
 419
 420 /*! \var Real32          MultiLightChunkBase::_sfLastCamFar
 421     The camera last far value.
 422 */
 423
 424 /*! \var Matrix          MultiLightChunkBase::_sfLastCamToWorld
 425     The camera last to world matrix.
 426 */
 427
 428 /*! \var std::string     MultiLightChunkBase::_sfLightBlockName
 429     The shader storage buffer block name for the light buffer.
 430 */
 431
 432 /*! \var std::string     MultiLightChunkBase::_sfLightVariableName
 433     The shader variable name for the light buffer.
 434 */
 435
 436
 437 /***************************************************************************\
 438  *                      FieldType/FieldTrait Instantiation                 *
 439 \***************************************************************************/
 440
 441 #if !defined(OSG_DO_DOC) || defined(OSG_DOC_DEV)
 442 PointerType FieldTraits<MultiLightChunk *, nsOSG>::_type(
 443     "MultiLightChunkPtr",
 444     "ShaderStorageBufferObjStdLayoutChunkPtr",
 445     MultiLightChunk::getClassType(),
 446     nsOSG);
 447 #endif
 448
 449 OSG_FIELDTRAITS_GETTYPE_NS(MultiLightChunk *, nsOSG)
 450
 451 OSG_EXPORT_PTR_SFIELD_FULL(PointerSField,
 452                            MultiLightChunk *,
 453                            nsOSG)
 454
 455 OSG_EXPORT_PTR_MFIELD_FULL(PointerMField,
 456                            MultiLightChunk *,
 457                            nsOSG)
 458
 459 /***************************************************************************\
 460  *                         Field Description                               *
 461 \***************************************************************************/
 462
 463 void MultiLightChunkBase::classDescInserter(TypeObject &oType)
 464 {
 465     FieldDescriptionBase *pDesc = NULL;
 466
 467
 468     pDesc = new SFBool::Description(
 469         SFBool::getClassType(),
 470         "hasWorldToLightSpaceMatrix",
 471         "This flag determines if the worldToLightSpaceMatrix attribute is part of \n"
 472         "the shader storage block, i.e. if the \"mat4  worldToLightSpaceMatrix;\" \n"
 473         "entry is contained in the shader struct for the Light.\n",
 474         HasWorldToLightSpaceMatrixFieldId, HasWorldToLightSpaceMatrixFieldMask,
 475         false,
 476         (Field::SFDefaultFlags | Field::FStdAccess),
 477         static_cast<FieldEditMethodSig>(&MultiLightChunk::editHandleHasWorldToLightSpaceMatrix),
 478         static_cast<FieldGetMethodSig >(&MultiLightChunk::getHandleHasWorldToLightSpaceMatrix));
 479
 480     oType.addInitialDesc(pDesc);
 481
 482     pDesc = new SFBool::Description(
 483         SFBool::getClassType(),
 484         "hasLightToWorldSpaceMatrix",
 485         "This flag determines if the lightToWorldSpaceMatrix attribute is part of \n"
 486         "the shader storage block, i.e. if the \"mat4  lightToWorldSpaceMatrix;\" \n"
 487         "entry is contained in the shader struct for the Light.\n",
 488         HasLightToWorldSpaceMatrixFieldId, HasLightToWorldSpaceMatrixFieldMask,
 489         false,
 490         (Field::SFDefaultFlags | Field::FStdAccess),
 491         static_cast<FieldEditMethodSig>(&MultiLightChunk::editHandleHasLightToWorldSpaceMatrix),
 492         static_cast<FieldGetMethodSig >(&MultiLightChunk::getHandleHasLightToWorldSpaceMatrix));
 493
 494     oType.addInitialDesc(pDesc);
 495
 496     pDesc = new SFBool::Description(
 497         SFBool::getClassType(),
 498         "hasEyeToLightSpaceMatrix",
 499         "This flag determines if the eyeToLightSpaceMatrix attribute is part of \n"
 500         "the shader storage block, i.e. if the \"mat4  eyeToLightSpaceMatrix;\" \n"
 501         "entry is contained in the shader struct for the Light.\n"
 502         "Attention: If this flag is set the light shader storage block has to\n"
 503         "be updated with every redraw operation.\n",
 504         HasEyeToLightSpaceMatrixFieldId, HasEyeToLightSpaceMatrixFieldMask,
 505         false,
 506         (Field::SFDefaultFlags | Field::FStdAccess),
 507         static_cast<FieldEditMethodSig>(&MultiLightChunk::editHandleHasEyeToLightSpaceMatrix),
 508         static_cast<FieldGetMethodSig >(&MultiLightChunk::getHandleHasEyeToLightSpaceMatrix));
 509
 510     oType.addInitialDesc(pDesc);
 511
 512     pDesc = new SFBool::Description(
 513         SFBool::getClassType(),
 514         "hasLightToEyeSpaceMatrix",
 515         "This flag determines if the lightToEyeSpaceMatrix attribute is part of \n"
 516         "the shader storage block, i.e. if the \"mat4  lightToEyeSpaceMatrix;\" \n"
 517         "entry is contained in the shader struct for the Light.\n"
 518         "Attention: If this flag is set the light shader storage block has to\n"
 519         "be updated with every redraw operation.\n",
 520         HasLightToEyeSpaceMatrixFieldId, HasLightToEyeSpaceMatrixFieldMask,
 521         false,
 522         (Field::SFDefaultFlags | Field::FStdAccess),
 523         static_cast<FieldEditMethodSig>(&MultiLightChunk::editHandleHasLightToEyeSpaceMatrix),
 524         static_cast<FieldGetMethodSig >(&MultiLightChunk::getHandleHasLightToEyeSpaceMatrix));
 525
 526     oType.addInitialDesc(pDesc);
 527
 528     pDesc = new SFBool::Description(
 529         SFBool::getClassType(),
 530         "hasLightPerspectiveMatrix",
 531         "This flag determines if the lightPerspectiveMatrix attribute is part of \n"
 532         "the shader storage block, i.e. if the \"mat4  lightPerspectiveMatrix;\" \n"
 533         "entry is contained in the shader struct for the Light.\n",
 534         HasLightPerspectiveMatrixFieldId, HasLightPerspectiveMatrixFieldMask,
 535         false,
 536         (Field::SFDefaultFlags | Field::FStdAccess),
 537         static_cast<FieldEditMethodSig>(&MultiLightChunk::editHandleHasLightPerspectiveMatrix),
 538         static_cast<FieldGetMethodSig >(&MultiLightChunk::getHandleHasLightPerspectiveMatrix));
 539
 540     oType.addInitialDesc(pDesc);
 541
 542     pDesc = new SFBool::Description(
 543         SFBool::getClassType(),
 544         "hasInvLightPerspectiveMatrix",
 545         "This flag determines if the lightToEyeSpaceMatrix attribute is part of \n"
 546         "the shader storage block, i.e. if the \"mat4  invLightToEyeSpaceMatrix;\" \n"
 547         "entry is contained in the shader struct for the Light.\n",
 548         HasInvLightPerspectiveMatrixFieldId, HasInvLightPerspectiveMatrixFieldMask,
 549         false,
 550         (Field::SFDefaultFlags | Field::FStdAccess),
 551         static_cast<FieldEditMethodSig>(&MultiLightChunk::editHandleHasInvLightPerspectiveMatrix),
 552         static_cast<FieldGetMethodSig >(&MultiLightChunk::getHandleHasInvLightPerspectiveMatrix));
 553
 554     oType.addInitialDesc(pDesc);
 555
 556     pDesc = new SFBool::Description(
 557         SFBool::getClassType(),
 558         "hasColor",
 559         "This flag determines if the color attribute is part of the shader storage block, i.e.\n"
 560         "if the \"vec3  color;\" entry is contained in the shader struct for the Light.\n",
 561         HasColorFieldId, HasColorFieldMask,
 562         false,
 563         (Field::SFDefaultFlags | Field::FStdAccess),
 564         static_cast<FieldEditMethodSig>(&MultiLightChunk::editHandleHasColor),
 565         static_cast<FieldGetMethodSig >(&MultiLightChunk::getHandleHasColor));
 566
 567     oType.addInitialDesc(pDesc);
 568
 569     pDesc = new SFBool::Description(
 570         SFBool::getClassType(),
 571         "hasIntensity",
 572         "This flag determines if the intensity attribute is part of the shader storage block, i.e.\n"
 573         "if the \"float intensity;\" entry is contained in the shader struct for the Light.\n",
 574         HasIntensityFieldId, HasIntensityFieldMask,
 575         false,
 576         (Field::SFDefaultFlags | Field::FStdAccess),
 577         static_cast<FieldEditMethodSig>(&MultiLightChunk::editHandleHasIntensity),
 578         static_cast<FieldGetMethodSig >(&MultiLightChunk::getHandleHasIntensity));
 579
 580     oType.addInitialDesc(pDesc);
 581
 582     pDesc = new SFBool::Description(
 583         SFBool::getClassType(),
 584         "hasSeparateIntensities",
 585         "This flag determines if the color intensity attributes are part of the shader storage block, i.e.\n"
 586         "if the \"vec3  Ia;\", \"vec3  Id;\" and \"vec3 Is;\" entries are contained in the shader struct for the Light.\n",
 587         HasSeparateIntensitiesFieldId, HasSeparateIntensitiesFieldMask,
 588         false,
 589         (Field::SFDefaultFlags | Field::FStdAccess),
 590         static_cast<FieldEditMethodSig>(&MultiLightChunk::editHandleHasSeparateIntensities),
 591         static_cast<FieldGetMethodSig >(&MultiLightChunk::getHandleHasSeparateIntensities));
 592
 593     oType.addInitialDesc(pDesc);
 594
 595     pDesc = new SFBool::Description(
 596         SFBool::getClassType(),
 597         "hasAttenuation",
 598         "This flag determines if the attenuation attributes are part of the shader storage block, i.e.\n"
 599         "if the \"float constantAttenuation;\", \"float linearAttenuation;\" and \"float quadraticAttenuation;\"\n"
 600         "entries are contained in the shader struct for the Light.\n",
 601         HasAttenuationFieldId, HasAttenuationFieldMask,
 602         false,
 603         (Field::SFDefaultFlags | Field::FStdAccess),
 604         static_cast<FieldEditMethodSig>(&MultiLightChunk::editHandleHasAttenuation),
 605         static_cast<FieldGetMethodSig >(&MultiLightChunk::getHandleHasAttenuation));
 606
 607     oType.addInitialDesc(pDesc);
 608
 609     pDesc = new SFBool::Description(
 610         SFBool::getClassType(),
 611         "autoCalcRanges",
 612         "If this flag is active and the lights have attenuations, then the cut on and cut off ranges\n"
 613         "are automatically calculated. They are, however, not provided automatically to the shader.\n"
 614         "For that, you have to set the hasRangeCutOn and hasRangeCutOff flags, respectively.\n",
 615         AutoCalcRangesFieldId, AutoCalcRangesFieldMask,
 616         false,
 617         (Field::SFDefaultFlags | Field::FStdAccess),
 618         static_cast<FieldEditMethodSig>(&MultiLightChunk::editHandleAutoCalcRanges),
 619         static_cast<FieldGetMethodSig >(&MultiLightChunk::getHandleAutoCalcRanges));
 620
 621     oType.addInitialDesc(pDesc);
 622
 623     pDesc = new SFBool::Description(
 624         SFBool::getClassType(),
 625         "hasRangeCutOn",
 626         "This flag determines if the rangeCutOn attribute is part of the shader storage block, i.e.\n"
 627         "if the \"float rangeCutOn;\" entry is contained in the shader struct for the Light.\n",
 628         HasRangeCutOnFieldId, HasRangeCutOnFieldMask,
 629         false,
 630         (Field::SFDefaultFlags | Field::FStdAccess),
 631         static_cast<FieldEditMethodSig>(&MultiLightChunk::editHandleHasRangeCutOn),
 632         static_cast<FieldGetMethodSig >(&MultiLightChunk::getHandleHasRangeCutOn));
 633
 634     oType.addInitialDesc(pDesc);
 635
 636     pDesc = new SFBool::Description(
 637         SFBool::getClassType(),
 638         "hasRangeCutOff",
 639         "This flag determines if the hasRangeCutOff attribute is part of the shader storage block, i.e.\n"
 640         "if the \"float hasRangeCutOff;\" entry is contained in the shader struct for the Light.\n",
 641         HasRangeCutOffFieldId, HasRangeCutOffFieldMask,
 642         false,
 643         (Field::SFDefaultFlags | Field::FStdAccess),
 644         static_cast<FieldEditMethodSig>(&MultiLightChunk::editHandleHasRangeCutOff),
 645         static_cast<FieldGetMethodSig >(&MultiLightChunk::getHandleHasRangeCutOff));
 646
 647     oType.addInitialDesc(pDesc);
 648
 649     pDesc = new SFBool::Description(
 650         SFBool::getClassType(),
 651         "hasRangeNearZone",
 652         "This flag determines if the hasRangeNearZone attribute is part of the shader storage block, i.e.\n"
 653         "if the \"float hasRangeNearZone;\" entry is contained in the shader struct for the Light.\n",
 654         HasRangeNearZoneFieldId, HasRangeNearZoneFieldMask,
 655         false,
 656         (Field::SFDefaultFlags | Field::FStdAccess),
 657         static_cast<FieldEditMethodSig>(&MultiLightChunk::editHandleHasRangeNearZone),
 658         static_cast<FieldGetMethodSig >(&MultiLightChunk::getHandleHasRangeNearZone));
 659
 660     oType.addInitialDesc(pDesc);
 661
 662     pDesc = new SFBool::Description(
 663         SFBool::getClassType(),
 664         "hasRangeFarZone",
 665         "This flag determines if the hasRangeFarZone attribute is part of the shader storage block, i.e.\n"
 666         "if the \"float hasRangeFarZone;\" entry is contained in the shader struct for the Light.\n",
 667         HasRangeFarZoneFieldId, HasRangeFarZoneFieldMask,
 668         false,
 669         (Field::SFDefaultFlags | Field::FStdAccess),
 670         static_cast<FieldEditMethodSig>(&MultiLightChunk::editHandleHasRangeFarZone),
 671         static_cast<FieldGetMethodSig >(&MultiLightChunk::getHandleHasRangeFarZone));
 672
 673     oType.addInitialDesc(pDesc);
 674
 675     pDesc = new SFBool::Description(
 676         SFBool::getClassType(),
 677         "hasCosSpotlightAngle",
 678         "This flag determines if the cosine of the spot light angle attribute is part of the shader storage block, i.e.\n"
 679         "if the \"float  cosSpotlightAngle;\" entry is contained in the shader struct for the Light. If neither this flag\n"
 680         "nor the hasSpotlightAngle flag is true, then this flag is treated as if it has value true.\n",
 681         HasCosSpotlightAngleFieldId, HasCosSpotlightAngleFieldMask,
 682         false,
 683         (Field::SFDefaultFlags | Field::FStdAccess),
 684         static_cast<FieldEditMethodSig>(&MultiLightChunk::editHandleHasCosSpotlightAngle),
 685         static_cast<FieldGetMethodSig >(&MultiLightChunk::getHandleHasCosSpotlightAngle));
 686
 687     oType.addInitialDesc(pDesc);
 688
 689     pDesc = new SFBool::Description(
 690         SFBool::getClassType(),
 691         "hasSpotlightAngle",
 692         "This flag determines if the spot light angle attribute is part of the shader storage block, i.e.\n"
 693         "if the \"float  spotlightAngle;\" entry is contained in the shader struct for the Light. If neither this flag\n"
 694         "nor the hasCosSpotlightAngle flag is true, then the hasCosSpotlightAngle flag is treated as if it has value true.\n",
 695         HasSpotlightAngleFieldId, HasSpotlightAngleFieldMask,
 696         false,
 697         (Field::SFDefaultFlags | Field::FStdAccess),
 698         static_cast<FieldEditMethodSig>(&MultiLightChunk::editHandleHasSpotlightAngle),
 699         static_cast<FieldGetMethodSig >(&MultiLightChunk::getHandleHasSpotlightAngle));
 700
 701     oType.addInitialDesc(pDesc);
 702
 703     pDesc = new SFBool::Description(
 704         SFBool::getClassType(),
 705         "hasSpotExponent",
 706         "This flag determines if the spot expenent attribute is part of the shader storage block, i.e.\n"
 707         "if the \"float  spotExponent;\" entry is contained in the shader struct for the Light.\n",
 708         HasSpotExponentFieldId, HasSpotExponentFieldMask,
 709         false,
 710         (Field::SFDefaultFlags | Field::FStdAccess),
 711         static_cast<FieldEditMethodSig>(&MultiLightChunk::editHandleHasSpotExponent),
 712         static_cast<FieldGetMethodSig >(&MultiLightChunk::getHandleHasSpotExponent));
 713
 714     oType.addInitialDesc(pDesc);
 715
 716     pDesc = new SFBool::Description(
 717         SFBool::getClassType(),
 718         "hasCinemaLight",
 719         "This flag determines if the cinema light attributes are part of the shader storage block, i.e.\n"
 720         "if the \"float innerSuperEllipsesWidth;\", ... entries are contained in the shader struct for the Light.\n"
 721         "If true this flag overrides the hasRangeCutOn, hasRangeCutOff, hasRangeNearZone and hasRangeFarZone\n"
 722         "flags, because cinema lights are described the corresponding attributes.\n"
 723         "See: http://http.developer.nvidia.com/GPUGems/gpugems_ch10.html\n"
 724         "http://www.yaldex.com/open-gl/ch12lev1sec4.html\n"
 725         "https://en.wikipedia.org/wiki/Superellipse\n",
 726         HasCinemaLightFieldId, HasCinemaLightFieldMask,
 727         false,
 728         (Field::SFDefaultFlags | Field::FStdAccess),
 729         static_cast<FieldEditMethodSig>(&MultiLightChunk::editHandleHasCinemaLight),
 730         static_cast<FieldGetMethodSig >(&MultiLightChunk::getHandleHasCinemaLight));
 731
 732     oType.addInitialDesc(pDesc);
 733
 734     pDesc = new MFPnt3f::Description(
 735         MFPnt3f::getClassType(),
 736         "position",
 737         "The light's position for point and spotlights in beacon space.\n",
 738         PositionFieldId, PositionFieldMask,
 739         false,
 740         (Field::MFDefaultFlags | Field::FStdAccess),
 741         static_cast<FieldEditMethodSig>(&MultiLightChunk::editHandlePosition),
 742         static_cast<FieldGetMethodSig >(&MultiLightChunk::getHandlePosition));
 743
 744     oType.addInitialDesc(pDesc);
 745
 746     pDesc = new MFVec3f::Description(
 747         MFVec3f::getClassType(),
 748         "direction",
 749         "The light's direction for directional and spotlights in beacon space.\n",
 750         DirectionFieldId, DirectionFieldMask,
 751         false,
 752         (Field::MFDefaultFlags | Field::FStdAccess),
 753         static_cast<FieldEditMethodSig>(&MultiLightChunk::editHandleDirection),
 754         static_cast<FieldGetMethodSig >(&MultiLightChunk::getHandleDirection));
 755
 756     oType.addInitialDesc(pDesc);
 757
 758     pDesc = new MFColor3f::Description(
 759         MFColor3f::getClassType(),
 760         "color",
 761         "The light's color.\n",
 762         ColorFieldId, ColorFieldMask,
 763         false,
 764         (Field::MFDefaultFlags | Field::FStdAccess),
 765         static_cast<FieldEditMethodSig>(&MultiLightChunk::editHandleColor),
 766         static_cast<FieldGetMethodSig >(&MultiLightChunk::getHandleColor));
 767
 768     oType.addInitialDesc(pDesc);
 769
 770     pDesc = new MFReal32::Description(
 771         MFReal32::getClassType(),
 772         "intensity",
 773         "The light's intensity.\n",
 774         IntensityFieldId, IntensityFieldMask,
 775         false,
 776         (Field::MFDefaultFlags | Field::FStdAccess),
 777         static_cast<FieldEditMethodSig>(&MultiLightChunk::editHandleIntensity),
 778         static_cast<FieldGetMethodSig >(&MultiLightChunk::getHandleIntensity));
 779
 780     oType.addInitialDesc(pDesc);
 781
 782     pDesc = new MFVec3f::Description(
 783         MFVec3f::getClassType(),
 784         "ambientIntensity",
 785         "The light's ambient intensity.\n",
 786         AmbientIntensityFieldId, AmbientIntensityFieldMask,
 787         false,
 788         (Field::MFDefaultFlags | Field::FStdAccess),
 789         static_cast<FieldEditMethodSig>(&MultiLightChunk::editHandleAmbientIntensity),
 790         static_cast<FieldGetMethodSig >(&MultiLightChunk::getHandleAmbientIntensity));
 791
 792     oType.addInitialDesc(pDesc);
 793
 794     pDesc = new MFVec3f::Description(
 795         MFVec3f::getClassType(),
 796         "diffuseIntensity",
 797         "The light's diffuse intensity.\n",
 798         DiffuseIntensityFieldId, DiffuseIntensityFieldMask,
 799         false,
 800         (Field::MFDefaultFlags | Field::FStdAccess),
 801         static_cast<FieldEditMethodSig>(&MultiLightChunk::editHandleDiffuseIntensity),
 802         static_cast<FieldGetMethodSig >(&MultiLightChunk::getHandleDiffuseIntensity));
 803
 804     oType.addInitialDesc(pDesc);
 805
 806     pDesc = new MFVec3f::Description(
 807         MFVec3f::getClassType(),
 808         "specularIntensity",
 809         "The light's specular intensity.\n",
 810         SpecularIntensityFieldId, SpecularIntensityFieldMask,
 811         false,
 812         (Field::MFDefaultFlags | Field::FStdAccess),
 813         static_cast<FieldEditMethodSig>(&MultiLightChunk::editHandleSpecularIntensity),
 814         static_cast<FieldGetMethodSig >(&MultiLightChunk::getHandleSpecularIntensity));
 815
 816     oType.addInitialDesc(pDesc);
 817
 818     pDesc = new MFVec3f::Description(
 819         MFVec3f::getClassType(),
 820         "attenuation",
 821         "The light's attenuation consiting of the constant, linear and quadratic attenuation parts.\n",
 822         AttenuationFieldId, AttenuationFieldMask,
 823         false,
 824         (Field::MFDefaultFlags | Field::FStdAccess),
 825         static_cast<FieldEditMethodSig>(&MultiLightChunk::editHandleAttenuation),
 826         static_cast<FieldGetMethodSig >(&MultiLightChunk::getHandleAttenuation));
 827
 828     oType.addInitialDesc(pDesc);
 829
 830     pDesc = new MFReal32::Description(
 831         MFReal32::getClassType(),
 832         "spotlightAngle",
 833         "The spot angle in degree.\n",
 834         SpotlightAngleFieldId, SpotlightAngleFieldMask,
 835         false,
 836         (Field::MFDefaultFlags | Field::FStdAccess),
 837         static_cast<FieldEditMethodSig>(&MultiLightChunk::editHandleSpotlightAngle),
 838         static_cast<FieldGetMethodSig >(&MultiLightChunk::getHandleSpotlightAngle));
 839
 840     oType.addInitialDesc(pDesc);
 841
 842     pDesc = new MFReal32::Description(
 843         MFReal32::getClassType(),
 844         "spotExponent",
 845         "The spot angle in degree.\n",
 846         SpotExponentFieldId, SpotExponentFieldMask,
 847         false,
 848         (Field::MFDefaultFlags | Field::FStdAccess),
 849         static_cast<FieldEditMethodSig>(&MultiLightChunk::editHandleSpotExponent),
 850         static_cast<FieldGetMethodSig >(&MultiLightChunk::getHandleSpotExponent));
 851
 852     oType.addInitialDesc(pDesc);
 853
 854     pDesc = new MFReal32::Description(
 855         MFReal32::getClassType(),
 856         "innerSuperEllipsesWidth",
 857         "The cinema light is described among others by an inner ellipses. This is\n"
 858         "the width of this ellipse.\n"
 859         "See: http://http.developer.nvidia.com/GPUGems/gpugems_ch10.html\n"
 860         "http://www.yaldex.com/open-gl/ch12lev1sec4.html\n"
 861         "https://en.wikipedia.org/wiki/Superellipse\n",
 862         InnerSuperEllipsesWidthFieldId, InnerSuperEllipsesWidthFieldMask,
 863         false,
 864         (Field::MFDefaultFlags | Field::FStdAccess),
 865         static_cast<FieldEditMethodSig>(&MultiLightChunk::editHandleInnerSuperEllipsesWidth),
 866         static_cast<FieldGetMethodSig >(&MultiLightChunk::getHandleInnerSuperEllipsesWidth));
 867
 868     oType.addInitialDesc(pDesc);
 869
 870     pDesc = new MFReal32::Description(
 871         MFReal32::getClassType(),
 872         "innerSuperEllipsesHeight",
 873         "The cinema light is described among others by an inner ellipses. This is\n"
 874         "the height of this ellipse.\n"
 875         "See: http://http.developer.nvidia.com/GPUGems/gpugems_ch10.html\n"
 876         "http://www.yaldex.com/open-gl/ch12lev1sec4.html\n"
 877         "https://en.wikipedia.org/wiki/Superellipse\n",
 878         InnerSuperEllipsesHeightFieldId, InnerSuperEllipsesHeightFieldMask,
 879         false,
 880         (Field::MFDefaultFlags | Field::FStdAccess),
 881         static_cast<FieldEditMethodSig>(&MultiLightChunk::editHandleInnerSuperEllipsesHeight),
 882         static_cast<FieldGetMethodSig >(&MultiLightChunk::getHandleInnerSuperEllipsesHeight));
 883
 884     oType.addInitialDesc(pDesc);
 885
 886     pDesc = new MFReal32::Description(
 887         MFReal32::getClassType(),
 888         "outerSuperEllipsesWidth",
 889         "The cinema light is described among others by an outer ellipses. This is\n"
 890         "the width of this ellipse.\n"
 891         "See: http://http.developer.nvidia.com/GPUGems/gpugems_ch10.html\n"
 892         "http://www.yaldex.com/open-gl/ch12lev1sec4.html\n"
 893         "https://en.wikipedia.org/wiki/Superellipse\n",
 894         OuterSuperEllipsesWidthFieldId, OuterSuperEllipsesWidthFieldMask,
 895         false,
 896         (Field::MFDefaultFlags | Field::FStdAccess),
 897         static_cast<FieldEditMethodSig>(&MultiLightChunk::editHandleOuterSuperEllipsesWidth),
 898         static_cast<FieldGetMethodSig >(&MultiLightChunk::getHandleOuterSuperEllipsesWidth));
 899
 900     oType.addInitialDesc(pDesc);
 901
 902     pDesc = new MFReal32::Description(
 903         MFReal32::getClassType(),
 904         "outerSuperEllipsesHeight",
 905         "The cinema light is described among others by an outer ellipses. This is\n"
 906         "the height of this ellipse.\n"
 907         "See: http://http.developer.nvidia.com/GPUGems/gpugems_ch10.html\n"
 908         "http://www.yaldex.com/open-gl/ch12lev1sec4.html\n"
 909         "https://en.wikipedia.org/wiki/Superellipse\n",
 910         OuterSuperEllipsesHeightFieldId, OuterSuperEllipsesHeightFieldMask,
 911         false,
 912         (Field::MFDefaultFlags | Field::FStdAccess),
 913         static_cast<FieldEditMethodSig>(&MultiLightChunk::editHandleOuterSuperEllipsesHeight),
 914         static_cast<FieldGetMethodSig >(&MultiLightChunk::getHandleOuterSuperEllipsesHeight));
 915
 916     oType.addInitialDesc(pDesc);
 917
 918     pDesc = new MFReal32::Description(
 919         MFReal32::getClassType(),
 920         "superEllipsesRoundness",
 921         "The cinema light is described among others by a roundness parameter. \n"
 922         "See: http://http.developer.nvidia.com/GPUGems/gpugems_ch10.html\n"
 923         "http://www.yaldex.com/open-gl/ch12lev1sec4.html\n"
 924         "https://en.wikipedia.org/wiki/Superellipse\n",
 925         SuperEllipsesRoundnessFieldId, SuperEllipsesRoundnessFieldMask,
 926         false,
 927         (Field::MFDefaultFlags | Field::FStdAccess),
 928         static_cast<FieldEditMethodSig>(&MultiLightChunk::editHandleSuperEllipsesRoundness),
 929         static_cast<FieldGetMethodSig >(&MultiLightChunk::getHandleSuperEllipsesRoundness));
 930
 931     oType.addInitialDesc(pDesc);
 932
 933     pDesc = new MFReal32::Description(
 934         MFReal32::getClassType(),
 935         "superEllipsesTwist",
 936         "The twist angle in degree by which the superellipses is rotatet in the xy-plane.\n",
 937         SuperEllipsesTwistFieldId, SuperEllipsesTwistFieldMask,
 938         false,
 939         (Field::MFDefaultFlags | Field::FStdAccess),
 940         static_cast<FieldEditMethodSig>(&MultiLightChunk::editHandleSuperEllipsesTwist),
 941         static_cast<FieldGetMethodSig >(&MultiLightChunk::getHandleSuperEllipsesTwist));
 942
 943     oType.addInitialDesc(pDesc);
 944
 945     pDesc = new MFReal32::Description(
 946         MFReal32::getClassType(),
 947         "rangeCutOn",
 948         "The cinema light is described among others by a rangeCutOn parameter.\n"
 949         "In the interval rangeCutOn to rangeCutOff the lighted fragments are\n"
 950         "fully lit.\n"
 951         "See: http://http.developer.nvidia.com/GPUGems/gpugems_ch10.html\n"
 952         "http://www.yaldex.com/open-gl/ch12lev1sec4.html\n"
 953         "https://en.wikipedia.org/wiki/Superellipse\n",
 954         RangeCutOnFieldId, RangeCutOnFieldMask,
 955         false,
 956         (Field::MFDefaultFlags | Field::FStdAccess),
 957         static_cast<FieldEditMethodSig>(&MultiLightChunk::editHandleRangeCutOn),
 958         static_cast<FieldGetMethodSig >(&MultiLightChunk::getHandleRangeCutOn));
 959
 960     oType.addInitialDesc(pDesc);
 961
 962     pDesc = new MFReal32::Description(
 963         MFReal32::getClassType(),
 964         "rangeCutOff",
 965         "The cinema light is described among others by a rangeCutOff parameter.\n"
 966         "In the interval rangeCutOn to rangeCutOff the lighted fragments are\n"
 967         "fully lit.\n"
 968         "See: http://http.developer.nvidia.com/GPUGems/gpugems_ch10.html\n"
 969         "http://www.yaldex.com/open-gl/ch12lev1sec4.html\n"
 970         "https://en.wikipedia.org/wiki/Superellipse\n",
 971         RangeCutOffFieldId, RangeCutOffFieldMask,
 972         false,
 973         (Field::MFDefaultFlags | Field::FStdAccess),
 974         static_cast<FieldEditMethodSig>(&MultiLightChunk::editHandleRangeCutOff),
 975         static_cast<FieldGetMethodSig >(&MultiLightChunk::getHandleRangeCutOff));
 976
 977     oType.addInitialDesc(pDesc);
 978
 979     pDesc = new MFReal32::Description(
 980         MFReal32::getClassType(),
 981         "rangeNearZone",
 982         "The cinema light is described among others by a rangeNearZone parameter.\n"
 983         "In the interval rangeCutOn-rangeNearZone to rangeCutOn the lighted fragments are\n"
 984         "partly lit.\n"
 985         "See: http://http.developer.nvidia.com/GPUGems/gpugems_ch10.html\n"
 986         "http://www.yaldex.com/open-gl/ch12lev1sec4.html\n"
 987         "https://en.wikipedia.org/wiki/Superellipse\n",
 988         RangeNearZoneFieldId, RangeNearZoneFieldMask,
 989         false,
 990         (Field::MFDefaultFlags | Field::FStdAccess),
 991         static_cast<FieldEditMethodSig>(&MultiLightChunk::editHandleRangeNearZone),
 992         static_cast<FieldGetMethodSig >(&MultiLightChunk::getHandleRangeNearZone));
 993
 994     oType.addInitialDesc(pDesc);
 995
 996     pDesc = new MFReal32::Description(
 997         MFReal32::getClassType(),
 998         "rangeFarZone",
 999         "In the interval rangeCutOff to rangeCutOff+rangeFarZone the lighted fragments are\n"
1000         "partly lit.\n",
1001         RangeFarZoneFieldId, RangeFarZoneFieldMask,
1002         false,
1003         (Field::MFDefaultFlags | Field::FStdAccess),
1004         static_cast<FieldEditMethodSig>(&MultiLightChunk::editHandleRangeFarZone),
1005         static_cast<FieldGetMethodSig >(&MultiLightChunk::getHandleRangeFarZone));
1006
1007     oType.addInitialDesc(pDesc);
1008
1009     pDesc = new MFUInt8::Description(
1010         MFUInt8::getClassType(),
1011         "type",
1012         "Stores the light's type. This can be any of the set {POINT_LIGHT, DIRECTIONAL_LIGHT, SPOT_LIGHT, CINEMA_LIGHT}.\n",
1013         TypeFieldId, TypeFieldMask,
1014         false,
1015         (Field::MFDefaultFlags | Field::FStdAccess),
1016         static_cast<FieldEditMethodSig>(&MultiLightChunk::editHandleType),
1017         static_cast<FieldGetMethodSig >(&MultiLightChunk::getHandleType));
1018
1019     oType.addInitialDesc(pDesc);
1020
1021     pDesc = new MFBool::Description(
1022         MFBool::getClassType(),
1023         "enabled",
1024         "The on/off state of the light.\n",
1025         EnabledFieldId, EnabledFieldMask,
1026         false,
1027         (Field::MFDefaultFlags | Field::FStdAccess),
1028         static_cast<FieldEditMethodSig>(&MultiLightChunk::editHandleEnabled),
1029         static_cast<FieldGetMethodSig >(&MultiLightChunk::getHandleEnabled));
1030
1031     oType.addInitialDesc(pDesc);
1032
1033     pDesc = new MFWeakNodePtr::Description(
1034         MFWeakNodePtr::getClassType(),
1035         "beacon",
1036         "The light's beacon determining its position or direction.\n",
1037         BeaconFieldId, BeaconFieldMask,
1038         false,
1039         (Field::MFDefaultFlags | Field::FStdAccess),
1040         static_cast<FieldEditMethodSig>(&MultiLightChunk::editHandleBeacon),
1041         static_cast<FieldGetMethodSig >(&MultiLightChunk::getHandleBeacon));
1042
1043     oType.addInitialDesc(pDesc);
1044
1045     pDesc = new MFMatrix::Description(
1046         MFMatrix::getClassType(),
1047         "beaconMatrix",
1048         "The beacon matrices used for the last render pass.\n",
1049         BeaconMatrixFieldId, BeaconMatrixFieldMask,
1050         true,
1051         (Field::MFDefaultFlags | Field::FStdAccess),
1052         static_cast<FieldEditMethodSig>(&MultiLightChunk::editHandleBeaconMatrix),
1053         static_cast<FieldGetMethodSig >(&MultiLightChunk::getHandleBeaconMatrix));
1054
1055     oType.addInitialDesc(pDesc);
1056
1057     pDesc = new SFBool::Description(
1058         SFBool::getClassType(),
1059         "eyeSpace",
1060         "The lights position and direction are transformed to eye space before loading into the shader. \n"
1061         "On default they are provided in world space.\n",
1062         EyeSpaceFieldId, EyeSpaceFieldMask,
1063         false,
1064         (Field::SFDefaultFlags | Field::FStdAccess),
1065         static_cast<FieldEditMethodSig>(&MultiLightChunk::editHandleEyeSpace),
1066         static_cast<FieldGetMethodSig >(&MultiLightChunk::getHandleEyeSpace));
1067
1068     oType.addInitialDesc(pDesc);
1069
1070     pDesc = new SFReal32::Description(
1071         SFReal32::getClassType(),
1072         "lastCamNear",
1073         "The camera last near value.\n",
1074         LastCamNearFieldId, LastCamNearFieldMask,
1075         true,
1076         (Field::SFDefaultFlags | Field::FStdAccess),
1077         static_cast<FieldEditMethodSig>(&MultiLightChunk::editHandleLastCamNear),
1078         static_cast<FieldGetMethodSig >(&MultiLightChunk::getHandleLastCamNear));
1079
1080     oType.addInitialDesc(pDesc);
1081
1082     pDesc = new SFReal32::Description(
1083         SFReal32::getClassType(),
1084         "lastCamFar",
1085         "The camera last far value.\n",
1086         LastCamFarFieldId, LastCamFarFieldMask,
1087         true,
1088         (Field::SFDefaultFlags | Field::FStdAccess),
1089         static_cast<FieldEditMethodSig>(&MultiLightChunk::editHandleLastCamFar),
1090         static_cast<FieldGetMethodSig >(&MultiLightChunk::getHandleLastCamFar));
1091
1092     oType.addInitialDesc(pDesc);
1093
1094     pDesc = new SFMatrix::Description(
1095         SFMatrix::getClassType(),
1096         "lastCamToWorld",
1097         "The camera last to world matrix.\n",
1098         LastCamToWorldFieldId, LastCamToWorldFieldMask,
1099         true,
1100         (Field::SFDefaultFlags | Field::FStdAccess),
1101         static_cast<FieldEditMethodSig>(&MultiLightChunk::editHandleLastCamToWorld),
1102         static_cast<FieldGetMethodSig >(&MultiLightChunk::getHandleLastCamToWorld));
1103
1104     oType.addInitialDesc(pDesc);
1105
1106     pDesc = new SFString::Description(
1107         SFString::getClassType(),
1108         "LightBlockName",
1109         "The shader storage buffer block name for the light buffer.\n",
1110         LightBlockNameFieldId, LightBlockNameFieldMask,
1111         false,
1112         (Field::SFDefaultFlags | Field::FStdAccess),
1113         static_cast<FieldEditMethodSig>(&MultiLightChunk::editHandleLightBlockName),
1114         static_cast<FieldGetMethodSig >(&MultiLightChunk::getHandleLightBlockName));
1115
1116     oType.addInitialDesc(pDesc);
1117
1118     pDesc = new SFString::Description(
1119         SFString::getClassType(),
1120         "LightVariableName",
1121         "The shader variable name for the light buffer.\n",
1122         LightVariableNameFieldId, LightVariableNameFieldMask,
1123         false,
1124         (Field::SFDefaultFlags | Field::FStdAccess),
1125         static_cast<FieldEditMethodSig>(&MultiLightChunk::editHandleLightVariableName),
1126         static_cast<FieldGetMethodSig >(&MultiLightChunk::getHandleLightVariableName));
1127
1128     oType.addInitialDesc(pDesc);
1129 }
1130
1131
1132 MultiLightChunkBase::TypeObject MultiLightChunkBase::_type(
1133     MultiLightChunkBase::getClassname(),
1134     Inherited::getClassname(),
1135     "NULL",
1136     nsOSG, //Namespace
1137     reinterpret_cast<PrototypeCreateF>(&MultiLightChunkBase::createEmptyLocal),
1138     reinterpret_cast<InitContainerF>(&MultiLightChunk::initMethod),
1139     reinterpret_cast<ExitContainerF>(&MultiLightChunk::exitMethod),
1140     reinterpret_cast<InitalInsertDescFunc>(
1141         reinterpret_cast<void *>(&MultiLightChunk::classDescInserter)),
1142     false,
1143     0,
1144     "<?xml version=\"1.0\"?>\n"
1145     "\n"
1146     "<FieldContainer\n"
1147     "    name=\"MultiLightChunk\"\n"
1148     "    parent=\"ShaderStorageBufferObjStdLayoutChunk\"\n"
1149     "    library=\"System\"\n"
1150     "    pointerfieldtypes=\"both\"\n"
1151     "    structure=\"concrete\"\n"
1152     "    systemcomponent=\"true\"\n"
1153     "    parentsystemcomponent=\"true\"\n"
1154     "    decoratable=\"false\"\n"
1155     "    useLocalIncludes=\"false\"\n"
1156     "    docGroupBase=\"GrpSystemState\"\n"
1157     ">\n"
1158     "See \\ref PageSystemMultiLightChunk for a description.\n"
1159     "\n"
1160     "This chunk represents a number of lights that are exposed to shader code\n"
1161     "in form of a buffer in OpenGL std430 layout format.\n"
1162     "A shader, binding a shader storage block to the very same binding point, \n"
1163     "is expected to respect the corresponding block layout. The layout is regulated\n"
1164     "by the hasXXX fields of the chunk. If one is set to false the corresponding\n"
1165     "struct entry is omitted.\n"
1166     "\n"
1167     "    struct Light\n"
1168     "    {\n"
1169     "        mat4  worldToLightSpaceMatrix;\n"
1170     "        mat4  lightToWorldSpaceMatrix;\n"
1171     "        mat4  eyeToLightSpaceMatrix;\n"
1172     "        mat4  lightToEyeSpaceMatrix;\n"
1173     "        mat4  lightPerspectiveMatrix;\n"
1174     "        mat4  invLightPerspectiveMatrix;\n"
1175     "        vec3  position;\n"
1176     "        vec3  direction;\n"
1177     "        vec3  color;\n"
1178     "        vec3  ambientIntensity;\n"
1179     "        vec3  diffuseIntensity;\n"
1180     "        vec3  specularIntensity;\n"
1181     "        float intensity;\n"
1182     "        float constantAttenuation;\n"
1183     "        float linearAttenuation;\n"
1184     "        float quadraticAttenuation;\n"
1185     "        float rangeCutOn;\n"
1186     "        float rangeCutOff;\n"
1187     "        float rangeNearZone;\n"
1188     "        float rangeFarZone;\n"
1189     "        float cosSpotlightAngle;\n"
1190     "        float spotlightAngle;\n"
1191     "        float spotExponent;\n"
1192     "        float innerSuperEllipsesWidth;\n"
1193     "        float innerSuperEllipsesHeight;\n"
1194     "        float outerSuperEllipsesWidth;\n"
1195     "        float outerSuperEllipsesHeight;\n"
1196     "        float superEllipsesRoundness;\n"
1197     "        float superEllipsesTwist;\n"
1198     "        int   type;\n"
1199     "        bool  enabled;\n"
1200     "    };\n"
1201     "\n"
1202     "    layout (std430) buffer Lights\n"
1203     "    {\n"
1204     "        Light light[];\n"
1205     "    } lights;\n"
1206     "\n"
1207     "The chunk provides a convenient function that allows to adjust the struct layout\n"
1208     "for standard OpenGL lights \n"
1209     "\n"
1210     "    struct Light\n"
1211     "    {\n"
1212     "        vec3  position;\n"
1213     "        vec3  direction;\n"
1214     "        vec3  ambientIntensity;\n"
1215     "        vec3  diffuseIntensity;\n"
1216     "        vec3  specularIntensity;\n"
1217     "        float constantAttenuation;\n"
1218     "        float linearAttenuation;\n"
1219     "        float quadraticAttenuation;\n"
1220     "        float cosSpotlightAngle;\n"
1221     "        float spotExponent;\n"
1222     "        int   type;\n"
1223     "        bool  enabled;\n"
1224     "    };\n"
1225     "\n"
1226     "or for simple range lights:\n"
1227     "\n"
1228     "    struct Light\n"
1229     "    {\n"
1230     "        vec3  position;\n"
1231     "        vec3  direction;\n"
1232     "        vec3  color;\n"
1233     "        float intensity;\n"
1234     "        float rangeCutOff;\n"
1235     "        float cosSpotlightAngle;\n"
1236     "        int   type;\n"
1237     "        bool  enabled;\n"
1238     "    };\n"
1239     "\n"
1240     "    <Field\n"
1241     "        name=\"hasWorldToLightSpaceMatrix\"\n"
1242     "        type=\"bool\"\n"
1243     "        cardinality=\"single\"\n"
1244     "        visibility=\"external\"\n"
1245     "        access=\"public\"\n"
1246     "        defaultValue=\"false\"\n"
1247     "    >\n"
1248     "        This flag determines if the worldToLightSpaceMatrix attribute is part of \n"
1249     "        the shader storage block, i.e. if the \"mat4  worldToLightSpaceMatrix;\" \n"
1250     "        entry is contained in the shader struct for the Light.\n"
1251     "    </Field>\n"
1252     "\n"
1253     "    <Field\n"
1254     "        name=\"hasLightToWorldSpaceMatrix\"\n"
1255     "        type=\"bool\"\n"
1256     "        cardinality=\"single\"\n"
1257     "        visibility=\"external\"\n"
1258     "        access=\"public\"\n"
1259     "        defaultValue=\"false\"\n"
1260     "    >\n"
1261     "        This flag determines if the lightToWorldSpaceMatrix attribute is part of \n"
1262     "        the shader storage block, i.e. if the \"mat4  lightToWorldSpaceMatrix;\" \n"
1263     "        entry is contained in the shader struct for the Light.\n"
1264     "    </Field>\n"
1265     "\n"
1266     "    <Field\n"
1267     "        name=\"hasEyeToLightSpaceMatrix\"\n"
1268     "        type=\"bool\"\n"
1269     "        cardinality=\"single\"\n"
1270     "        visibility=\"external\"\n"
1271     "        access=\"public\"\n"
1272     "        defaultValue=\"false\"\n"
1273     "    >\n"
1274     "        This flag determines if the eyeToLightSpaceMatrix attribute is part of \n"
1275     "        the shader storage block, i.e. if the \"mat4  eyeToLightSpaceMatrix;\" \n"
1276     "        entry is contained in the shader struct for the Light.\n"
1277     "        Attention: If this flag is set the light shader storage block has to\n"
1278     "        be updated with every redraw operation.\n"
1279     "    </Field>\n"
1280     "\n"
1281     "    <Field\n"
1282     "        name=\"hasLightToEyeSpaceMatrix\"\n"
1283     "        type=\"bool\"\n"
1284     "        cardinality=\"single\"\n"
1285     "        visibility=\"external\"\n"
1286     "        access=\"public\"\n"
1287     "        defaultValue=\"false\"\n"
1288     "    >\n"
1289     "        This flag determines if the lightToEyeSpaceMatrix attribute is part of \n"
1290     "        the shader storage block, i.e. if the \"mat4  lightToEyeSpaceMatrix;\" \n"
1291     "        entry is contained in the shader struct for the Light.\n"
1292     "        Attention: If this flag is set the light shader storage block has to\n"
1293     "        be updated with every redraw operation.\n"
1294     "    </Field>\n"
1295     "\n"
1296     "    <Field\n"
1297     "        name=\"hasLightPerspectiveMatrix\"\n"
1298     "        type=\"bool\"\n"
1299     "        cardinality=\"single\"\n"
1300     "        visibility=\"external\"\n"
1301     "        access=\"public\"\n"
1302     "        defaultValue=\"false\"\n"
1303     "    >\n"
1304     "        This flag determines if the lightPerspectiveMatrix attribute is part of \n"
1305     "        the shader storage block, i.e. if the \"mat4  lightPerspectiveMatrix;\" \n"
1306     "        entry is contained in the shader struct for the Light.\n"
1307     "    </Field>\n"
1308     "\n"
1309     "    <Field\n"
1310     "        name=\"hasInvLightPerspectiveMatrix\"\n"
1311     "        type=\"bool\"\n"
1312     "        cardinality=\"single\"\n"
1313     "        visibility=\"external\"\n"
1314     "        access=\"public\"\n"
1315     "        defaultValue=\"false\"\n"
1316     "    >\n"
1317     "        This flag determines if the lightToEyeSpaceMatrix attribute is part of \n"
1318     "        the shader storage block, i.e. if the \"mat4  invLightToEyeSpaceMatrix;\" \n"
1319     "        entry is contained in the shader struct for the Light.\n"
1320     "    </Field>\n"
1321     "\n"
1322     "    <Field\n"
1323     "        name=\"hasColor\"\n"
1324     "        type=\"bool\"\n"
1325     "        cardinality=\"single\"\n"
1326     "        visibility=\"external\"\n"
1327     "        access=\"public\"\n"
1328     "        defaultValue=\"false\"\n"
1329     "    >\n"
1330     "        This flag determines if the color attribute is part of the shader storage block, i.e.\n"
1331     "        if the \"vec3  color;\" entry is contained in the shader struct for the Light.\n"
1332     "    </Field>\n"
1333     "\n"
1334     "    <Field\n"
1335     "        name=\"hasIntensity\"\n"
1336     "        type=\"bool\"\n"
1337     "        cardinality=\"single\"\n"
1338     "        visibility=\"external\"\n"
1339     "        access=\"public\"\n"
1340     "        defaultValue=\"false\"\n"
1341     "    >\n"
1342     "        This flag determines if the intensity attribute is part of the shader storage block, i.e.\n"
1343     "        if the \"float intensity;\" entry is contained in the shader struct for the Light.\n"
1344     "    </Field>\n"
1345     "\n"
1346     "    <Field\n"
1347     "        name=\"hasSeparateIntensities\"\n"
1348     "        type=\"bool\"\n"
1349     "        cardinality=\"single\"\n"
1350     "        visibility=\"external\"\n"
1351     "        access=\"public\"\n"
1352     "        defaultValue=\"true\"\n"
1353     "    >\n"
1354     "        This flag determines if the color intensity attributes are part of the shader storage block, i.e.\n"
1355     "        if the \"vec3  Ia;\", \"vec3  Id;\" and \"vec3 Is;\" entries are contained in the shader struct for the Light.\n"
1356     "    </Field>\n"
1357     "\n"
1358     "    <Field\n"
1359     "        name=\"hasAttenuation\"\n"
1360     "        type=\"bool\"\n"
1361     "        cardinality=\"single\"\n"
1362     "        visibility=\"external\"\n"
1363     "        access=\"public\"\n"
1364     "        defaultValue=\"true\"\n"
1365     "    >\n"
1366     "        This flag determines if the attenuation attributes are part of the shader storage block, i.e.\n"
1367     "        if the \"float constantAttenuation;\", \"float linearAttenuation;\" and \"float quadraticAttenuation;\"\n"
1368     "        entries are contained in the shader struct for the Light.\n"
1369     "    </Field>\n"
1370     "\n"
1371     "    <Field\n"
1372     "        name=\"autoCalcRanges\"\n"
1373     "        type=\"bool\"\n"
1374     "        cardinality=\"single\"\n"
1375     "        visibility=\"external\"\n"
1376     "        access=\"public\"\n"
1377     "        defaultValue=\"true\"\n"
1378     "    >\n"
1379     "        If this flag is active and the lights have attenuations, then the cut on and cut off ranges\n"
1380     "        are automatically calculated. They are, however, not provided automatically to the shader.\n"
1381     "        For that, you have to set the hasRangeCutOn and hasRangeCutOff flags, respectively.\n"
1382     "    </Field>\n"
1383     "\n"
1384     "    <Field\n"
1385     "        name=\"hasRangeCutOn\"\n"
1386     "        type=\"bool\"\n"
1387     "        cardinality=\"single\"\n"
1388     "        visibility=\"external\"\n"
1389     "        access=\"public\"\n"
1390     "        defaultValue=\"false\"\n"
1391     "    >\n"
1392     "        This flag determines if the rangeCutOn attribute is part of the shader storage block, i.e.\n"
1393     "        if the \"float rangeCutOn;\" entry is contained in the shader struct for the Light.\n"
1394     "    </Field>\n"
1395     "\n"
1396     "    <Field\n"
1397     "        name=\"hasRangeCutOff\"\n"
1398     "        type=\"bool\"\n"
1399     "        cardinality=\"single\"\n"
1400     "        visibility=\"external\"\n"
1401     "        access=\"public\"\n"
1402     "        defaultValue=\"false\"\n"
1403     "    >\n"
1404     "        This flag determines if the hasRangeCutOff attribute is part of the shader storage block, i.e.\n"
1405     "        if the \"float hasRangeCutOff;\" entry is contained in the shader struct for the Light.\n"
1406     "    </Field>\n"
1407     "\n"
1408     "    <Field\n"
1409     "        name=\"hasRangeNearZone\"\n"
1410     "        type=\"bool\"\n"
1411     "        cardinality=\"single\"\n"
1412     "        visibility=\"external\"\n"
1413     "        access=\"public\"\n"
1414     "        defaultValue=\"false\"\n"
1415     "    >\n"
1416     "        This flag determines if the hasRangeNearZone attribute is part of the shader storage block, i.e.\n"
1417     "        if the \"float hasRangeNearZone;\" entry is contained in the shader struct for the Light.\n"
1418     "    </Field>\n"
1419     "\n"
1420     "    <Field\n"
1421     "        name=\"hasRangeFarZone\"\n"
1422     "        type=\"bool\"\n"
1423     "        cardinality=\"single\"\n"
1424     "        visibility=\"external\"\n"
1425     "        access=\"public\"\n"
1426     "        defaultValue=\"false\"\n"
1427     "    >\n"
1428     "        This flag determines if the hasRangeFarZone attribute is part of the shader storage block, i.e.\n"
1429     "        if the \"float hasRangeFarZone;\" entry is contained in the shader struct for the Light.\n"
1430     "    </Field>\n"
1431     "\n"
1432     "    <Field\n"
1433     "        name=\"hasCosSpotlightAngle\"\n"
1434     "        type=\"bool\"\n"
1435     "        cardinality=\"single\"\n"
1436     "        visibility=\"external\"\n"
1437     "        access=\"public\"\n"
1438     "        defaultValue=\"true\"\n"
1439     "    >\n"
1440     "        This flag determines if the cosine of the spot light angle attribute is part of the shader storage block, i.e.\n"
1441     "        if the \"float  cosSpotlightAngle;\" entry is contained in the shader struct for the Light. If neither this flag\n"
1442     "        nor the hasSpotlightAngle flag is true, then this flag is treated as if it has value true.\n"
1443     "    </Field>\n"
1444     "\n"
1445     "    <Field\n"
1446     "        name=\"hasSpotlightAngle\"\n"
1447     "        type=\"bool\"\n"
1448     "        cardinality=\"single\"\n"
1449     "        visibility=\"external\"\n"
1450     "        access=\"public\"\n"
1451     "        defaultValue=\"false\"\n"
1452     "    >\n"
1453     "        This flag determines if the spot light angle attribute is part of the shader storage block, i.e.\n"
1454     "        if the \"float  spotlightAngle;\" entry is contained in the shader struct for the Light. If neither this flag\n"
1455     "        nor the hasCosSpotlightAngle flag is true, then the hasCosSpotlightAngle flag is treated as if it has value true.\n"
1456     "    </Field>\n"
1457     "\n"
1458     "    <Field\n"
1459     "        name=\"hasSpotExponent\"\n"
1460     "        type=\"bool\"\n"
1461     "        cardinality=\"single\"\n"
1462     "        visibility=\"external\"\n"
1463     "        access=\"public\"\n"
1464     "        defaultValue=\"true\"\n"
1465     "    >\n"
1466     "        This flag determines if the spot expenent attribute is part of the shader storage block, i.e.\n"
1467     "        if the \"float  spotExponent;\" entry is contained in the shader struct for the Light.\n"
1468     "    </Field>\n"
1469     "\n"
1470     "    <Field\n"
1471     "        name=\"hasCinemaLight\"\n"
1472     "        type=\"bool\"\n"
1473     "        cardinality=\"single\"\n"
1474     "        visibility=\"external\"\n"
1475     "        access=\"public\"\n"
1476     "        defaultValue=\"false\"\n"
1477     "    >\n"
1478     "        This flag determines if the cinema light attributes are part of the shader storage block, i.e.\n"
1479     "        if the \"float innerSuperEllipsesWidth;\", ... entries are contained in the shader struct for the Light.\n"
1480     "        If true this flag overrides the hasRangeCutOn, hasRangeCutOff, hasRangeNearZone and hasRangeFarZone\n"
1481     "        flags, because cinema lights are described the corresponding attributes.\n"
1482     "        See: http://http.developer.nvidia.com/GPUGems/gpugems_ch10.html\n"
1483     "             http://www.yaldex.com/open-gl/ch12lev1sec4.html\n"
1484     "             https://en.wikipedia.org/wiki/Superellipse\n"
1485     "    </Field>\n"
1486     "\n"
1487     "    <Field\n"
1488     "        name=\"position\"\n"
1489     "        type=\"Pnt3f\"\n"
1490     "        cardinality=\"multi\"\n"
1491     "        visibility=\"external\"\n"
1492     "        access=\"protected\"\n"
1493     "        >\n"
1494     "        The light's position for point and spotlights in beacon space.\n"
1495     "    </Field>\n"
1496     "\n"
1497     "    <Field\n"
1498     "        name=\"direction\"\n"
1499     "        type=\"Vec3f\"\n"
1500     "        cardinality=\"multi\"\n"
1501     "        visibility=\"external\"\n"
1502     "        access=\"protected\"\n"
1503     "    >\n"
1504     "    The light's direction for directional and spotlights in beacon space.\n"
1505     "    </Field>\n"
1506     "\n"
1507     "    <Field\n"
1508     "        name=\"color\"\n"
1509     "        type=\"Color3f\"\n"
1510     "        cardinality=\"multi\"\n"
1511     "        visibility=\"external\"\n"
1512     "        access=\"protected\"\n"
1513     "    >\n"
1514     "    The light's color.\n"
1515     "    </Field>\n"
1516     "\n"
1517     "    <Field\n"
1518     "        name=\"intensity\"\n"
1519     "        type=\"Real32\"\n"
1520     "        cardinality=\"multi\"\n"
1521     "        visibility=\"external\"\n"
1522     "        access=\"protected\"\n"
1523     "    >\n"
1524     "    The light's intensity.\n"
1525     "    </Field>\n"
1526     "\n"
1527     "    <Field\n"
1528     "        name=\"ambientIntensity\"\n"
1529     "        type=\"Vec3f\"\n"
1530     "        cardinality=\"multi\"\n"
1531     "        visibility=\"external\"\n"
1532     "        access=\"protected\"\n"
1533     "    >\n"
1534     "    The light's ambient intensity.\n"
1535     "    </Field>\n"
1536     "\n"
1537     "    <Field\n"
1538     "        name=\"diffuseIntensity\"\n"
1539     "        type=\"Vec3f\"\n"
1540     "        cardinality=\"multi\"\n"
1541     "        visibility=\"external\"\n"
1542     "        access=\"protected\"\n"
1543     "    >\n"
1544     "    The light's diffuse intensity.\n"
1545     "    </Field>\n"
1546     "\n"
1547     "    <Field\n"
1548     "        name=\"specularIntensity\"\n"
1549     "        type=\"Vec3f\"\n"
1550     "        cardinality=\"multi\"\n"
1551     "        visibility=\"external\"\n"
1552     "        access=\"protected\"\n"
1553     "    >\n"
1554     "    The light's specular intensity.\n"
1555     "    </Field>\n"
1556     "\n"
1557     "    <Field\n"
1558     "        name=\"attenuation\"\n"
1559     "        type=\"Vec3f\"\n"
1560     "        cardinality=\"multi\"\n"
1561     "        visibility=\"external\"\n"
1562     "        access=\"protected\"\n"
1563     "    >\n"
1564     "    The light's attenuation consiting of the constant, linear and quadratic attenuation parts.\n"
1565     "    </Field>\n"
1566     "\n"
1567     "    <Field\n"
1568     "        name=\"spotlightAngle\"\n"
1569     "        type=\"Real32\"\n"
1570     "        cardinality=\"multi\"\n"
1571     "        visibility=\"external\"\n"
1572     "        access=\"protected\"\n"
1573     "    >\n"
1574     "    The spot angle in degree.\n"
1575     "    </Field>\n"
1576     "\n"
1577     "    <Field\n"
1578     "        name=\"spotExponent\"\n"
1579     "        type=\"Real32\"\n"
1580     "        cardinality=\"multi\"\n"
1581     "        visibility=\"external\"\n"
1582     "        access=\"protected\"\n"
1583     "    >\n"
1584     "    The spot angle in degree.\n"
1585     "    </Field>\n"
1586     "\n"
1587     "    <Field\n"
1588     "        name=\"innerSuperEllipsesWidth\"\n"
1589     "        type=\"Real32\"\n"
1590     "        cardinality=\"multi\"\n"
1591     "        visibility=\"external\"\n"
1592     "        access=\"protected\"\n"
1593     "    >\n"
1594     "    The cinema light is described among others by an inner ellipses. This is\n"
1595     "    the width of this ellipse.\n"
1596     "    See: http://http.developer.nvidia.com/GPUGems/gpugems_ch10.html\n"
1597     "         http://www.yaldex.com/open-gl/ch12lev1sec4.html\n"
1598     "         https://en.wikipedia.org/wiki/Superellipse\n"
1599     "    </Field>\n"
1600     "\n"
1601     "    <Field\n"
1602     "        name=\"innerSuperEllipsesHeight\"\n"
1603     "        type=\"Real32\"\n"
1604     "        cardinality=\"multi\"\n"
1605     "        visibility=\"external\"\n"
1606     "        access=\"protected\"\n"
1607     "    >\n"
1608     "    The cinema light is described among others by an inner ellipses. This is\n"
1609     "    the height of this ellipse.\n"
1610     "    See: http://http.developer.nvidia.com/GPUGems/gpugems_ch10.html\n"
1611     "         http://www.yaldex.com/open-gl/ch12lev1sec4.html\n"
1612     "         https://en.wikipedia.org/wiki/Superellipse\n"
1613     "    </Field>\n"
1614     "\n"
1615     "    <Field\n"
1616     "        name=\"outerSuperEllipsesWidth\"\n"
1617     "        type=\"Real32\"\n"
1618     "        cardinality=\"multi\"\n"
1619     "        visibility=\"external\"\n"
1620     "        access=\"protected\"\n"
1621     "    >\n"
1622     "    The cinema light is described among others by an outer ellipses. This is\n"
1623     "    the width of this ellipse.\n"
1624     "    See: http://http.developer.nvidia.com/GPUGems/gpugems_ch10.html\n"
1625     "         http://www.yaldex.com/open-gl/ch12lev1sec4.html\n"
1626     "         https://en.wikipedia.org/wiki/Superellipse\n"
1627     "    </Field>\n"
1628     "\n"
1629     "    <Field\n"
1630     "        name=\"outerSuperEllipsesHeight\"\n"
1631     "        type=\"Real32\"\n"
1632     "        cardinality=\"multi\"\n"
1633     "        visibility=\"external\"\n"
1634     "        access=\"protected\"\n"
1635     "    >\n"
1636     "    The cinema light is described among others by an outer ellipses. This is\n"
1637     "    the height of this ellipse.\n"
1638     "    See: http://http.developer.nvidia.com/GPUGems/gpugems_ch10.html\n"
1639     "         http://www.yaldex.com/open-gl/ch12lev1sec4.html\n"
1640     "         https://en.wikipedia.org/wiki/Superellipse\n"
1641     "    </Field>\n"
1642     "\n"
1643     "    <Field\n"
1644     "        name=\"superEllipsesRoundness\"\n"
1645     "        type=\"Real32\"\n"
1646     "        cardinality=\"multi\"\n"
1647     "        visibility=\"external\"\n"
1648     "        access=\"protected\"\n"
1649     "    >\n"
1650     "    The cinema light is described among others by a roundness parameter. \n"
1651     "    See: http://http.developer.nvidia.com/GPUGems/gpugems_ch10.html\n"
1652     "         http://www.yaldex.com/open-gl/ch12lev1sec4.html\n"
1653     "         https://en.wikipedia.org/wiki/Superellipse\n"
1654     "    </Field>\n"
1655     "\n"
1656     "    <Field\n"
1657     "        name=\"superEllipsesTwist\"\n"
1658     "        type=\"Real32\"\n"
1659     "        cardinality=\"multi\"\n"
1660     "        visibility=\"external\"\n"
1661     "        access=\"protected\"\n"
1662     "    >\n"
1663     "    The twist angle in degree by which the superellipses is rotatet in the xy-plane.\n"
1664     "    </Field>\n"
1665     "\n"
1666     "    <Field\n"
1667     "        name=\"rangeCutOn\"\n"
1668     "        type=\"Real32\"\n"
1669     "        cardinality=\"multi\"\n"
1670     "        visibility=\"external\"\n"
1671     "        access=\"protected\"\n"
1672     "    >\n"
1673     "    The cinema light is described among others by a rangeCutOn parameter.\n"
1674     "    In the interval rangeCutOn to rangeCutOff the lighted fragments are\n"
1675     "    fully lit.\n"
1676     "    See: http://http.developer.nvidia.com/GPUGems/gpugems_ch10.html\n"
1677     "         http://www.yaldex.com/open-gl/ch12lev1sec4.html\n"
1678     "         https://en.wikipedia.org/wiki/Superellipse\n"
1679     "    </Field>\n"
1680     "\n"
1681     "    <Field\n"
1682     "        name=\"rangeCutOff\"\n"
1683     "        type=\"Real32\"\n"
1684     "        cardinality=\"multi\"\n"
1685     "        visibility=\"external\"\n"
1686     "        access=\"protected\"\n"
1687     "    >\n"
1688     "    The cinema light is described among others by a rangeCutOff parameter.\n"
1689     "    In the interval rangeCutOn to rangeCutOff the lighted fragments are\n"
1690     "    fully lit.\n"
1691     "    See: http://http.developer.nvidia.com/GPUGems/gpugems_ch10.html\n"
1692     "         http://www.yaldex.com/open-gl/ch12lev1sec4.html\n"
1693     "         https://en.wikipedia.org/wiki/Superellipse\n"
1694     "    </Field>\n"
1695     "\n"
1696     "    <Field\n"
1697     "        name=\"rangeNearZone\"\n"
1698     "        type=\"Real32\"\n"
1699     "        cardinality=\"multi\"\n"
1700     "        visibility=\"external\"\n"
1701     "        access=\"protected\"\n"
1702     "    >\n"
1703     "    The cinema light is described among others by a rangeNearZone parameter.\n"
1704     "    In the interval rangeCutOn-rangeNearZone to rangeCutOn the lighted fragments are\n"
1705     "    partly lit.\n"
1706     "    See: http://http.developer.nvidia.com/GPUGems/gpugems_ch10.html\n"
1707     "         http://www.yaldex.com/open-gl/ch12lev1sec4.html\n"
1708     "         https://en.wikipedia.org/wiki/Superellipse\n"
1709     "    </Field>\n"
1710     "\n"
1711     "    <Field\n"
1712     "        name=\"rangeFarZone\"\n"
1713     "        type=\"Real32\"\n"
1714     "        cardinality=\"multi\"\n"
1715     "        visibility=\"external\"\n"
1716     "        access=\"protected\"\n"
1717     "    >\n"
1718     "    In the interval rangeCutOff to rangeCutOff+rangeFarZone the lighted fragments are\n"
1719     "    partly lit.\n"
1720     "    </Field>\n"
1721     "\n"
1722     "    <Field\n"
1723     "        name=\"type\"\n"
1724     "        type=\"UInt8\"\n"
1725     "        cardinality=\"multi\"\n"
1726     "        visibility=\"external\"\n"
1727     "        access=\"protected\"\n"
1728     "    >\n"
1729     "    Stores the light's type. This can be any of the set {POINT_LIGHT, DIRECTIONAL_LIGHT, SPOT_LIGHT, CINEMA_LIGHT}.\n"
1730     "    </Field>\n"
1731     "\n"
1732     "    <Field\n"
1733     "        name=\"enabled\"\n"
1734     "        type=\"bool\"\n"
1735     "        cardinality=\"multi\"\n"
1736     "        visibility=\"external\"\n"
1737     "        access=\"protected\"\n"
1738     "    >\n"
1739     "    The on/off state of the light.\n"
1740     "    </Field>\n"
1741     "\n"
1742     "    <Field\n"
1743     "        name=\"beacon\"\n"
1744     "        type=\"Node\"\n"
1745     "        category=\"weakpointer\"\n"
1746     "        cardinality=\"multi\"\n"
1747     "        visibility=\"external\"\n"
1748     "        access=\"protected\"\n"
1749     "    >\n"
1750     "    The light's beacon determining its position or direction.\n"
1751     "    </Field>\n"
1752     "\n"
1753     "    <Field\n"
1754     "        name=\"beaconMatrix\"\n"
1755     "        type=\"Matrix\"\n"
1756     "        cardinality=\"multi\"\n"
1757     "        visibility=\"internal\"\n"
1758     "        access=\"protected\"\n"
1759     "    >\n"
1760     "        The beacon matrices used for the last render pass.\n"
1761     "    </Field>\n"
1762     "\n"
1763     "    <Field\n"
1764     "        name=\"eyeSpace\"\n"
1765     "        type=\"bool\"\n"
1766     "        cardinality=\"single\"\n"
1767     "        visibility=\"external\"\n"
1768     "        access=\"public\"\n"
1769     "        defaultValue=\"false\"\n"
1770     "    >\n"
1771     "    The lights position and direction are transformed to eye space before loading into the shader. \n"
1772     "    On default they are provided in world space.\n"
1773     "    </Field>\n"
1774     "\n"
1775     "    <Field\n"
1776     "        name=\"lastCamNear\"\n"
1777     "        type=\"Real32\"\n"
1778     "        cardinality=\"single\"\n"
1779     "        visibility=\"internal\"\n"
1780     "        access=\"protected\"\n"
1781     "        defaultValue=\"0.f\"\n"
1782     "    >\n"
1783     "        The camera last near value.\n"
1784     "    </Field>\n"
1785     "\n"
1786     "    <Field\n"
1787     "        name=\"lastCamFar\"\n"
1788     "        type=\"Real32\"\n"
1789     "        cardinality=\"single\"\n"
1790     "        visibility=\"internal\"\n"
1791     "        access=\"protected\"\n"
1792     "        defaultValue=\"0.f\"\n"
1793     "    >\n"
1794     "        The camera last far value.\n"
1795     "    </Field>\n"
1796     "\n"
1797     "    <Field\n"
1798     "        name=\"lastCamToWorld\"\n"
1799     "        type=\"Matrix\"\n"
1800     "        cardinality=\"single\"\n"
1801     "        visibility=\"internal\"\n"
1802     "        access=\"protected\"\n"
1803     "    >\n"
1804     "        The camera last to world matrix.\n"
1805     "    </Field>\n"
1806     "\n"
1807     "    <Field\n"
1808     "     name=\"LightBlockName\"\n"
1809     "     type=\"std::string\"\n"
1810     "     cardinality=\"single\"\n"
1811     "     visibility=\"external\"\n"
1812     "     access=\"public\"\n"
1813     "     defaultValue='\"Lights\"'\n"
1814     "     >\n"
1815     "        The shader storage buffer block name for the light buffer.\n"
1816     "    </Field>\n"
1817     "\n"
1818     "    <Field\n"
1819     "     name=\"LightVariableName\"\n"
1820     "     type=\"std::string\"\n"
1821     "     cardinality=\"single\"\n"
1822     "     visibility=\"external\"\n"
1823     "     access=\"public\"\n"
1824     "     defaultValue='\"lights\"'\n"
1825     "     >\n"
1826     "        The shader variable name for the light buffer.\n"
1827     "    </Field>\n"
1828     "\n"
1829     "</FieldContainer>\n",
1830     "See \\ref PageSystemMultiLightChunk for a description.\n"
1831     "\n"
1832     "This chunk represents a number of lights that are exposed to shader code\n"
1833     "in form of a buffer in OpenGL std430 layout format.\n"
1834     "A shader, binding a shader storage block to the very same binding point, \n"
1835     "is expected to respect the corresponding block layout. The layout is regulated\n"
1836     "by the hasXXX fields of the chunk. If one is set to false the corresponding\n"
1837     "struct entry is omitted.\n"
1838     "\n"
1839     "struct Light\n"
1840     "{\n"
1841     "mat4  worldToLightSpaceMatrix;\n"
1842     "mat4  lightToWorldSpaceMatrix;\n"
1843     "mat4  eyeToLightSpaceMatrix;\n"
1844     "mat4  lightToEyeSpaceMatrix;\n"
1845     "mat4  lightPerspectiveMatrix;\n"
1846     "mat4  invLightPerspectiveMatrix;\n"
1847     "vec3  position;\n"
1848     "vec3  direction;\n"
1849     "vec3  color;\n"
1850     "vec3  ambientIntensity;\n"
1851     "vec3  diffuseIntensity;\n"
1852     "vec3  specularIntensity;\n"
1853     "float intensity;\n"
1854     "float constantAttenuation;\n"
1855     "float linearAttenuation;\n"
1856     "float quadraticAttenuation;\n"
1857     "float rangeCutOn;\n"
1858     "float rangeCutOff;\n"
1859     "float rangeNearZone;\n"
1860     "float rangeFarZone;\n"
1861     "float cosSpotlightAngle;\n"
1862     "float spotlightAngle;\n"
1863     "float spotExponent;\n"
1864     "float innerSuperEllipsesWidth;\n"
1865     "float innerSuperEllipsesHeight;\n"
1866     "float outerSuperEllipsesWidth;\n"
1867     "float outerSuperEllipsesHeight;\n"
1868     "float superEllipsesRoundness;\n"
1869     "float superEllipsesTwist;\n"
1870     "int   type;\n"
1871     "bool  enabled;\n"
1872     "};\n"
1873     "\n"
1874     "layout (std430) buffer Lights\n"
1875     "{\n"
1876     "Light light[];\n"
1877     "} lights;\n"
1878     "\n"
1879     "The chunk provides a convenient function that allows to adjust the struct layout\n"
1880     "for standard OpenGL lights \n"
1881     "\n"
1882     "struct Light\n"
1883     "{\n"
1884     "vec3  position;\n"
1885     "vec3  direction;\n"
1886     "vec3  ambientIntensity;\n"
1887     "vec3  diffuseIntensity;\n"
1888     "vec3  specularIntensity;\n"
1889     "float constantAttenuation;\n"
1890     "float linearAttenuation;\n"
1891     "float quadraticAttenuation;\n"
1892     "float cosSpotlightAngle;\n"
1893     "float spotExponent;\n"
1894     "int   type;\n"
1895     "bool  enabled;\n"
1896     "};\n"
1897     "\n"
1898     "or for simple range lights:\n"
1899     "\n"
1900     "struct Light\n"
1901     "{\n"
1902     "vec3  position;\n"
1903     "vec3  direction;\n"
1904     "vec3  color;\n"
1905     "float intensity;\n"
1906     "float rangeCutOff;\n"
1907     "float cosSpotlightAngle;\n"
1908     "int   type;\n"
1909     "bool  enabled;\n"
1910     "};\n"
1911     );
1912
1913 /*------------------------------ get -----------------------------------*/
1914
1915 FieldContainerType &MultiLightChunkBase::getType(void)
1916 {
1917     return _type;
1918 }
1919
1920 const FieldContainerType &MultiLightChunkBase::getType(void) const
1921 {
1922     return _type;
1923 }
1924
1925 UInt32 MultiLightChunkBase::getContainerSize(void) const
1926 {
1927     return sizeof(MultiLightChunk);
1928 }
1929
1930 /*------------------------- decorator get ------------------------------*/
1931
1932
1933 SFBool *MultiLightChunkBase::editSFHasWorldToLightSpaceMatrix(void)
1934 {
1935     editSField(HasWorldToLightSpaceMatrixFieldMask);
1936
1937     return &_sfHasWorldToLightSpaceMatrix;
1938 }
1939
1940 const SFBool *MultiLightChunkBase::getSFHasWorldToLightSpaceMatrix(void) const
1941 {
1942     return &_sfHasWorldToLightSpaceMatrix;
1943 }
1944
1945
1946 SFBool *MultiLightChunkBase::editSFHasLightToWorldSpaceMatrix(void)
1947 {
1948     editSField(HasLightToWorldSpaceMatrixFieldMask);
1949
1950     return &_sfHasLightToWorldSpaceMatrix;
1951 }
1952
1953 const SFBool *MultiLightChunkBase::getSFHasLightToWorldSpaceMatrix(void) const
1954 {
1955     return &_sfHasLightToWorldSpaceMatrix;
1956 }
1957
1958
1959 SFBool *MultiLightChunkBase::editSFHasEyeToLightSpaceMatrix(void)
1960 {
1961     editSField(HasEyeToLightSpaceMatrixFieldMask);
1962
1963     return &_sfHasEyeToLightSpaceMatrix;
1964 }
1965
1966 const SFBool *MultiLightChunkBase::getSFHasEyeToLightSpaceMatrix(void) const
1967 {
1968     return &_sfHasEyeToLightSpaceMatrix;
1969 }
1970
1971
1972 SFBool *MultiLightChunkBase::editSFHasLightToEyeSpaceMatrix(void)
1973 {
1974     editSField(HasLightToEyeSpaceMatrixFieldMask);
1975
1976     return &_sfHasLightToEyeSpaceMatrix;
1977 }
1978
1979 const SFBool *MultiLightChunkBase::getSFHasLightToEyeSpaceMatrix(void) const
1980 {
1981     return &_sfHasLightToEyeSpaceMatrix;
1982 }
1983
1984
1985 SFBool *MultiLightChunkBase::editSFHasLightPerspectiveMatrix(void)
1986 {
1987     editSField(HasLightPerspectiveMatrixFieldMask);
1988
1989     return &_sfHasLightPerspectiveMatrix;
1990 }
1991
1992 const SFBool *MultiLightChunkBase::getSFHasLightPerspectiveMatrix(void) const
1993 {
1994     return &_sfHasLightPerspectiveMatrix;
1995 }
1996
1997
1998 SFBool *MultiLightChunkBase::editSFHasInvLightPerspectiveMatrix(void)
1999 {
2000     editSField(HasInvLightPerspectiveMatrixFieldMask);
2001
2002     return &_sfHasInvLightPerspectiveMatrix;
2003 }
2004
2005 const SFBool *MultiLightChunkBase::getSFHasInvLightPerspectiveMatrix(void) const
2006 {
2007     return &_sfHasInvLightPerspectiveMatrix;
2008 }
2009
2010
2011 SFBool *MultiLightChunkBase::editSFHasColor(void)
2012 {
2013     editSField(HasColorFieldMask);
2014
2015     return &_sfHasColor;
2016 }
2017
2018 const SFBool *MultiLightChunkBase::getSFHasColor(void) const
2019 {
2020     return &_sfHasColor;
2021 }
2022
2023
2024 SFBool *MultiLightChunkBase::editSFHasIntensity(void)
2025 {
2026     editSField(HasIntensityFieldMask);
2027
2028     return &_sfHasIntensity;
2029 }
2030
2031 const SFBool *MultiLightChunkBase::getSFHasIntensity(void) const
2032 {
2033     return &_sfHasIntensity;
2034 }
2035
2036
2037 SFBool *MultiLightChunkBase::editSFHasSeparateIntensities(void)
2038 {
2039     editSField(HasSeparateIntensitiesFieldMask);
2040
2041     return &_sfHasSeparateIntensities;
2042 }
2043
2044 const SFBool *MultiLightChunkBase::getSFHasSeparateIntensities(void) const
2045 {
2046     return &_sfHasSeparateIntensities;
2047 }
2048
2049
2050 SFBool *MultiLightChunkBase::editSFHasAttenuation(void)
2051 {
2052     editSField(HasAttenuationFieldMask);
2053
2054     return &_sfHasAttenuation;
2055 }
2056
2057 const SFBool *MultiLightChunkBase::getSFHasAttenuation(void) const
2058 {
2059     return &_sfHasAttenuation;
2060 }
2061
2062
2063 SFBool *MultiLightChunkBase::editSFAutoCalcRanges(void)
2064 {
2065     editSField(AutoCalcRangesFieldMask);
2066
2067     return &_sfAutoCalcRanges;
2068 }
2069
2070 const SFBool *MultiLightChunkBase::getSFAutoCalcRanges(void) const
2071 {
2072     return &_sfAutoCalcRanges;
2073 }
2074
2075
2076 SFBool *MultiLightChunkBase::editSFHasRangeCutOn(void)
2077 {
2078     editSField(HasRangeCutOnFieldMask);
2079
2080     return &_sfHasRangeCutOn;
2081 }
2082
2083 const SFBool *MultiLightChunkBase::getSFHasRangeCutOn(void) const
2084 {
2085     return &_sfHasRangeCutOn;
2086 }
2087
2088
2089 SFBool *MultiLightChunkBase::editSFHasRangeCutOff(void)
2090 {
2091     editSField(HasRangeCutOffFieldMask);
2092
2093     return &_sfHasRangeCutOff;
2094 }
2095
2096 const SFBool *MultiLightChunkBase::getSFHasRangeCutOff(void) const
2097 {
2098     return &_sfHasRangeCutOff;
2099 }
2100
2101
2102 SFBool *MultiLightChunkBase::editSFHasRangeNearZone(void)
2103 {
2104     editSField(HasRangeNearZoneFieldMask);
2105
2106     return &_sfHasRangeNearZone;
2107 }
2108
2109 const SFBool *MultiLightChunkBase::getSFHasRangeNearZone(void) const
2110 {
2111     return &_sfHasRangeNearZone;
2112 }
2113
2114
2115 SFBool *MultiLightChunkBase::editSFHasRangeFarZone(void)
2116 {
2117     editSField(HasRangeFarZoneFieldMask);
2118
2119     return &_sfHasRangeFarZone;
2120 }
2121
2122 const SFBool *MultiLightChunkBase::getSFHasRangeFarZone(void) const
2123 {
2124     return &_sfHasRangeFarZone;
2125 }
2126
2127
2128 SFBool *MultiLightChunkBase::editSFHasCosSpotlightAngle(void)
2129 {
2130     editSField(HasCosSpotlightAngleFieldMask);
2131
2132     return &_sfHasCosSpotlightAngle;
2133 }
2134
2135 const SFBool *MultiLightChunkBase::getSFHasCosSpotlightAngle(void) const
2136 {
2137     return &_sfHasCosSpotlightAngle;
2138 }
2139
2140
2141 SFBool *MultiLightChunkBase::editSFHasSpotlightAngle(void)
2142 {
2143     editSField(HasSpotlightAngleFieldMask);
2144
2145     return &_sfHasSpotlightAngle;
2146 }
2147
2148 const SFBool *MultiLightChunkBase::getSFHasSpotlightAngle(void) const
2149 {
2150     return &_sfHasSpotlightAngle;
2151 }
2152
2153
2154 SFBool *MultiLightChunkBase::editSFHasSpotExponent(void)
2155 {
2156     editSField(HasSpotExponentFieldMask);
2157
2158     return &_sfHasSpotExponent;
2159 }
2160
2161 const SFBool *MultiLightChunkBase::getSFHasSpotExponent(void) const
2162 {
2163     return &_sfHasSpotExponent;
2164 }
2165
2166
2167 SFBool *MultiLightChunkBase::editSFHasCinemaLight(void)
2168 {
2169     editSField(HasCinemaLightFieldMask);
2170
2171     return &_sfHasCinemaLight;
2172 }
2173
2174 const SFBool *MultiLightChunkBase::getSFHasCinemaLight(void) const
2175 {
2176     return &_sfHasCinemaLight;
2177 }
2178
2179
2180 MFPnt3f *MultiLightChunkBase::editMFPosition(void)
2181 {
2182     editMField(PositionFieldMask, _mfPosition);
2183
2184     return &_mfPosition;
2185 }
2186
2187 const MFPnt3f *MultiLightChunkBase::getMFPosition(void) const
2188 {
2189     return &_mfPosition;
2190 }
2191
2192
2193 MFVec3f *MultiLightChunkBase::editMFDirection(void)
2194 {
2195     editMField(DirectionFieldMask, _mfDirection);
2196
2197     return &_mfDirection;
2198 }
2199
2200 const MFVec3f *MultiLightChunkBase::getMFDirection(void) const
2201 {
2202     return &_mfDirection;
2203 }
2204
2205
2206 MFColor3f *MultiLightChunkBase::editMFColor(void)
2207 {
2208     editMField(ColorFieldMask, _mfColor);
2209
2210     return &_mfColor;
2211 }
2212
2213 const MFColor3f *MultiLightChunkBase::getMFColor(void) const
2214 {
2215     return &_mfColor;
2216 }
2217
2218
2219 MFReal32 *MultiLightChunkBase::editMFIntensity(void)
2220 {
2221     editMField(IntensityFieldMask, _mfIntensity);
2222
2223     return &_mfIntensity;
2224 }
2225
2226 const MFReal32 *MultiLightChunkBase::getMFIntensity(void) const
2227 {
2228     return &_mfIntensity;
2229 }
2230
2231
2232 MFVec3f *MultiLightChunkBase::editMFAmbientIntensity(void)
2233 {
2234     editMField(AmbientIntensityFieldMask, _mfAmbientIntensity);
2235
2236     return &_mfAmbientIntensity;
2237 }
2238
2239 const MFVec3f *MultiLightChunkBase::getMFAmbientIntensity(void) const
2240 {
2241     return &_mfAmbientIntensity;
2242 }
2243
2244
2245 MFVec3f *MultiLightChunkBase::editMFDiffuseIntensity(void)
2246 {
2247     editMField(DiffuseIntensityFieldMask, _mfDiffuseIntensity);
2248
2249     return &_mfDiffuseIntensity;
2250 }
2251
2252 const MFVec3f *MultiLightChunkBase::getMFDiffuseIntensity(void) const
2253 {
2254     return &_mfDiffuseIntensity;
2255 }
2256
2257
2258 MFVec3f *MultiLightChunkBase::editMFSpecularIntensity(void)
2259 {
2260     editMField(SpecularIntensityFieldMask, _mfSpecularIntensity);
2261
2262     return &_mfSpecularIntensity;
2263 }
2264
2265 const MFVec3f *MultiLightChunkBase::getMFSpecularIntensity(void) const
2266 {
2267     return &_mfSpecularIntensity;
2268 }
2269
2270
2271 MFVec3f *MultiLightChunkBase::editMFAttenuation(void)
2272 {
2273     editMField(AttenuationFieldMask, _mfAttenuation);
2274
2275     return &_mfAttenuation;
2276 }
2277
2278 const MFVec3f *MultiLightChunkBase::getMFAttenuation(void) const
2279 {
2280     return &_mfAttenuation;
2281 }
2282
2283
2284 MFReal32 *MultiLightChunkBase::editMFSpotlightAngle(void)
2285 {
2286     editMField(SpotlightAngleFieldMask, _mfSpotlightAngle);
2287
2288     return &_mfSpotlightAngle;
2289 }
2290
2291 const MFReal32 *MultiLightChunkBase::getMFSpotlightAngle(void) const
2292 {
2293     return &_mfSpotlightAngle;
2294 }
2295
2296
2297 MFReal32 *MultiLightChunkBase::editMFSpotExponent(void)
2298 {
2299     editMField(SpotExponentFieldMask, _mfSpotExponent);
2300
2301     return &_mfSpotExponent;
2302 }
2303
2304 const MFReal32 *MultiLightChunkBase::getMFSpotExponent(void) const
2305 {
2306     return &_mfSpotExponent;
2307 }
2308
2309
2310 MFReal32 *MultiLightChunkBase::editMFInnerSuperEllipsesWidth(void)
2311 {
2312     editMField(InnerSuperEllipsesWidthFieldMask, _mfInnerSuperEllipsesWidth);
2313
2314     return &_mfInnerSuperEllipsesWidth;
2315 }
2316
2317 const MFReal32 *MultiLightChunkBase::getMFInnerSuperEllipsesWidth(void) const
2318 {
2319     return &_mfInnerSuperEllipsesWidth;
2320 }
2321
2322
2323 MFReal32 *MultiLightChunkBase::editMFInnerSuperEllipsesHeight(void)
2324 {
2325     editMField(InnerSuperEllipsesHeightFieldMask, _mfInnerSuperEllipsesHeight);
2326
2327     return &_mfInnerSuperEllipsesHeight;
2328 }
2329
2330 const MFReal32 *MultiLightChunkBase::getMFInnerSuperEllipsesHeight(void) const
2331 {
2332     return &_mfInnerSuperEllipsesHeight;
2333 }
2334
2335
2336 MFReal32 *MultiLightChunkBase::editMFOuterSuperEllipsesWidth(void)
2337 {
2338     editMField(OuterSuperEllipsesWidthFieldMask, _mfOuterSuperEllipsesWidth);
2339
2340     return &_mfOuterSuperEllipsesWidth;
2341 }
2342
2343 const MFReal32 *MultiLightChunkBase::getMFOuterSuperEllipsesWidth(void) const
2344 {
2345     return &_mfOuterSuperEllipsesWidth;
2346 }
2347
2348
2349 MFReal32 *MultiLightChunkBase::editMFOuterSuperEllipsesHeight(void)
2350 {
2351     editMField(OuterSuperEllipsesHeightFieldMask, _mfOuterSuperEllipsesHeight);
2352
2353     return &_mfOuterSuperEllipsesHeight;
2354 }
2355
2356 const MFReal32 *MultiLightChunkBase::getMFOuterSuperEllipsesHeight(void) const
2357 {
2358     return &_mfOuterSuperEllipsesHeight;
2359 }
2360
2361
2362 MFReal32 *MultiLightChunkBase::editMFSuperEllipsesRoundness(void)
2363 {
2364     editMField(SuperEllipsesRoundnessFieldMask, _mfSuperEllipsesRoundness);
2365
2366     return &_mfSuperEllipsesRoundness;
2367 }
2368
2369 const MFReal32 *MultiLightChunkBase::getMFSuperEllipsesRoundness(void) const
2370 {
2371     return &_mfSuperEllipsesRoundness;
2372 }
2373
2374
2375 MFReal32 *MultiLightChunkBase::editMFSuperEllipsesTwist(void)
2376 {
2377     editMField(SuperEllipsesTwistFieldMask, _mfSuperEllipsesTwist);
2378
2379     return &_mfSuperEllipsesTwist;
2380 }
2381
2382 const MFReal32 *MultiLightChunkBase::getMFSuperEllipsesTwist(void) const
2383 {
2384     return &_mfSuperEllipsesTwist;
2385 }
2386
2387
2388 MFReal32 *MultiLightChunkBase::editMFRangeCutOn(void)
2389 {
2390     editMField(RangeCutOnFieldMask, _mfRangeCutOn);
2391
2392     return &_mfRangeCutOn;
2393 }
2394
2395 const MFReal32 *MultiLightChunkBase::getMFRangeCutOn(void) const
2396 {
2397     return &_mfRangeCutOn;
2398 }
2399
2400
2401 MFReal32 *MultiLightChunkBase::editMFRangeCutOff(void)
2402 {
2403     editMField(RangeCutOffFieldMask, _mfRangeCutOff);
2404
2405     return &_mfRangeCutOff;
2406 }
2407
2408 const MFReal32 *MultiLightChunkBase::getMFRangeCutOff(void) const
2409 {
2410     return &_mfRangeCutOff;
2411 }
2412
2413
2414 MFReal32 *MultiLightChunkBase::editMFRangeNearZone(void)
2415 {
2416     editMField(RangeNearZoneFieldMask, _mfRangeNearZone);
2417
2418     return &_mfRangeNearZone;
2419 }
2420
2421 const MFReal32 *MultiLightChunkBase::getMFRangeNearZone(void) const
2422 {
2423     return &_mfRangeNearZone;
2424 }
2425
2426
2427 MFReal32 *MultiLightChunkBase::editMFRangeFarZone(void)
2428 {
2429     editMField(RangeFarZoneFieldMask, _mfRangeFarZone);
2430
2431     return &_mfRangeFarZone;
2432 }
2433
2434 const MFReal32 *MultiLightChunkBase::getMFRangeFarZone(void) const
2435 {
2436     return &_mfRangeFarZone;
2437 }
2438
2439
2440 MFUInt8 *MultiLightChunkBase::editMFType(void)
2441 {
2442     editMField(TypeFieldMask, _mfType);
2443
2444     return &_mfType;
2445 }
2446
2447 const MFUInt8 *MultiLightChunkBase::getMFType(void) const
2448 {
2449     return &_mfType;
2450 }
2451
2452
2453 MFBool *MultiLightChunkBase::editMFEnabled(void)
2454 {
2455     editMField(EnabledFieldMask, _mfEnabled);
2456
2457     return &_mfEnabled;
2458 }
2459
2460 const MFBool *MultiLightChunkBase::getMFEnabled(void) const
2461 {
2462     return &_mfEnabled;
2463 }
2464
2465
2466 //! Get the MultiLightChunk::_mfBeacon field.
2467 const MFWeakNodePtr *MultiLightChunkBase::getMFBeacon(void) const
2468 {
2469     return &_mfBeacon;
2470 }
2471
2472 MFWeakNodePtr       *MultiLightChunkBase::editMFBeacon         (void)
2473 {
2474     editMField(BeaconFieldMask, _mfBeacon);
2475
2476     return &_mfBeacon;
2477 }
2478 Node * MultiLightChunkBase::getBeacon(const UInt32 index) const
2479 {
2480     return _mfBeacon[index];
2481 }
2482
2483 MFMatrix *MultiLightChunkBase::editMFBeaconMatrix(void)
2484 {
2485     editMField(BeaconMatrixFieldMask, _mfBeaconMatrix);
2486
2487     return &_mfBeaconMatrix;
2488 }
2489
2490 const MFMatrix *MultiLightChunkBase::getMFBeaconMatrix(void) const
2491 {
2492     return &_mfBeaconMatrix;
2493 }
2494
2495
2496 SFBool *MultiLightChunkBase::editSFEyeSpace(void)
2497 {
2498     editSField(EyeSpaceFieldMask);
2499
2500     return &_sfEyeSpace;
2501 }
2502
2503 const SFBool *MultiLightChunkBase::getSFEyeSpace(void) const
2504 {
2505     return &_sfEyeSpace;
2506 }
2507
2508
2509 SFReal32 *MultiLightChunkBase::editSFLastCamNear(void)
2510 {
2511     editSField(LastCamNearFieldMask);
2512
2513     return &_sfLastCamNear;
2514 }
2515
2516 const SFReal32 *MultiLightChunkBase::getSFLastCamNear(void) const
2517 {
2518     return &_sfLastCamNear;
2519 }
2520
2521
2522 SFReal32 *MultiLightChunkBase::editSFLastCamFar(void)
2523 {
2524     editSField(LastCamFarFieldMask);
2525
2526     return &_sfLastCamFar;
2527 }
2528
2529 const SFReal32 *MultiLightChunkBase::getSFLastCamFar(void) const
2530 {
2531     return &_sfLastCamFar;
2532 }
2533
2534
2535 SFMatrix *MultiLightChunkBase::editSFLastCamToWorld(void)
2536 {
2537     editSField(LastCamToWorldFieldMask);
2538
2539     return &_sfLastCamToWorld;
2540 }
2541
2542 const SFMatrix *MultiLightChunkBase::getSFLastCamToWorld(void) const
2543 {
2544     return &_sfLastCamToWorld;
2545 }
2546
2547
2548 SFString *MultiLightChunkBase::editSFLightBlockName(void)
2549 {
2550     editSField(LightBlockNameFieldMask);
2551
2552     return &_sfLightBlockName;
2553 }
2554
2555 const SFString *MultiLightChunkBase::getSFLightBlockName(void) const
2556 {
2557     return &_sfLightBlockName;
2558 }
2559
2560
2561 SFString *MultiLightChunkBase::editSFLightVariableName(void)
2562 {
2563     editSField(LightVariableNameFieldMask);
2564
2565     return &_sfLightVariableName;
2566 }
2567
2568 const SFString *MultiLightChunkBase::getSFLightVariableName(void) const
2569 {
2570     return &_sfLightVariableName;
2571 }
2572
2573
2574
2575
2576 void MultiLightChunkBase::pushToBeacon(Node * const value)
2577 {
2578     editMField(BeaconFieldMask, _mfBeacon);
2579
2580     _mfBeacon.push_back(value);
2581 }
2582
2583 void MultiLightChunkBase::assignBeacon   (const MFWeakNodePtr     &value)
2584 {
2585     MFWeakNodePtr    ::const_iterator elemIt  =
2586         value.begin();
2587     MFWeakNodePtr    ::const_iterator elemEnd =
2588         value.end  ();
2589
2590     static_cast<MultiLightChunk *>(this)->clearBeacon();
2591
2592     while(elemIt != elemEnd)
2593     {
2594         this->pushToBeacon(*elemIt);
2595
2596         ++elemIt;
2597     }
2598 }
2599
2600 void MultiLightChunkBase::removeFromBeacon(UInt32 uiIndex)
2601 {
2602     if(uiIndex < _mfBeacon.size())
2603     {
2604         editMField(BeaconFieldMask, _mfBeacon);
2605
2606         _mfBeacon.erase(uiIndex);
2607     }
2608 }
2609
2610 void MultiLightChunkBase::removeObjFromBeacon(Node * const value)
2611 {
2612     Int32 iElemIdx = _mfBeacon.findIndex(value);
2613
2614     if(iElemIdx != -1)
2615     {
2616         editMField(BeaconFieldMask, _mfBeacon);
2617
2618         _mfBeacon.erase(iElemIdx);
2619     }
2620 }
2621 void MultiLightChunkBase::clearBeacon(void)
2622 {
2623     editMField(BeaconFieldMask, _mfBeacon);
2624
2625
2626     _mfBeacon.clear();
2627 }
2628
2629
2630
2631 /*------------------------------ access -----------------------------------*/
2632
2633 SizeT MultiLightChunkBase::getBinSize(ConstFieldMaskArg whichField)
2634 {
2635     SizeT returnValue = Inherited::getBinSize(whichField);
2636
2637     if(FieldBits::NoField != (HasWorldToLightSpaceMatrixFieldMask & whichField))
2638     {
2639         returnValue += _sfHasWorldToLightSpaceMatrix.getBinSize();
2640     }
2641     if(FieldBits::NoField != (HasLightToWorldSpaceMatrixFieldMask & whichField))
2642     {
2643         returnValue += _sfHasLightToWorldSpaceMatrix.getBinSize();
2644     }
2645     if(FieldBits::NoField != (HasEyeToLightSpaceMatrixFieldMask & whichField))
2646     {
2647         returnValue += _sfHasEyeToLightSpaceMatrix.getBinSize();
2648     }
2649     if(FieldBits::NoField != (HasLightToEyeSpaceMatrixFieldMask & whichField))
2650     {
2651         returnValue += _sfHasLightToEyeSpaceMatrix.getBinSize();
2652     }
2653     if(FieldBits::NoField != (HasLightPerspectiveMatrixFieldMask & whichField))
2654     {
2655         returnValue += _sfHasLightPerspectiveMatrix.getBinSize();
2656     }
2657     if(FieldBits::NoField != (HasInvLightPerspectiveMatrixFieldMask & whichField))
2658     {
2659         returnValue += _sfHasInvLightPerspectiveMatrix.getBinSize();
2660     }
2661     if(FieldBits::NoField != (HasColorFieldMask & whichField))
2662     {
2663         returnValue += _sfHasColor.getBinSize();
2664     }
2665     if(FieldBits::NoField != (HasIntensityFieldMask & whichField))
2666     {
2667         returnValue += _sfHasIntensity.getBinSize();
2668     }
2669     if(FieldBits::NoField != (HasSeparateIntensitiesFieldMask & whichField))
2670     {
2671         returnValue += _sfHasSeparateIntensities.getBinSize();
2672     }
2673     if(FieldBits::NoField != (HasAttenuationFieldMask & whichField))
2674     {
2675         returnValue += _sfHasAttenuation.getBinSize();
2676     }
2677     if(FieldBits::NoField != (AutoCalcRangesFieldMask & whichField))
2678     {
2679         returnValue += _sfAutoCalcRanges.getBinSize();
2680     }
2681     if(FieldBits::NoField != (HasRangeCutOnFieldMask & whichField))
2682     {
2683         returnValue += _sfHasRangeCutOn.getBinSize();
2684     }
2685     if(FieldBits::NoField != (HasRangeCutOffFieldMask & whichField))
2686     {
2687         returnValue += _sfHasRangeCutOff.getBinSize();
2688     }
2689     if(FieldBits::NoField != (HasRangeNearZoneFieldMask & whichField))
2690     {
2691         returnValue += _sfHasRangeNearZone.getBinSize();
2692     }
2693     if(FieldBits::NoField != (HasRangeFarZoneFieldMask & whichField))
2694     {
2695         returnValue += _sfHasRangeFarZone.getBinSize();
2696     }
2697     if(FieldBits::NoField != (HasCosSpotlightAngleFieldMask & whichField))
2698     {
2699         returnValue += _sfHasCosSpotlightAngle.getBinSize();
2700     }
2701     if(FieldBits::NoField != (HasSpotlightAngleFieldMask & whichField))
2702     {
2703         returnValue += _sfHasSpotlightAngle.getBinSize();
2704     }
2705     if(FieldBits::NoField != (HasSpotExponentFieldMask & whichField))
2706     {
2707         returnValue += _sfHasSpotExponent.getBinSize();
2708     }
2709     if(FieldBits::NoField != (HasCinemaLightFieldMask & whichField))
2710     {
2711         returnValue += _sfHasCinemaLight.getBinSize();
2712     }
2713     if(FieldBits::NoField != (PositionFieldMask & whichField))
2714     {
2715         returnValue += _mfPosition.getBinSize();
2716     }
2717     if(FieldBits::NoField != (DirectionFieldMask & whichField))
2718     {
2719         returnValue += _mfDirection.getBinSize();
2720     }
2721     if(FieldBits::NoField != (ColorFieldMask & whichField))
2722     {
2723         returnValue += _mfColor.getBinSize();
2724     }
2725     if(FieldBits::NoField != (IntensityFieldMask & whichField))
2726     {
2727         returnValue += _mfIntensity.getBinSize();
2728     }
2729     if(FieldBits::NoField != (AmbientIntensityFieldMask & whichField))
2730     {
2731         returnValue += _mfAmbientIntensity.getBinSize();
2732     }
2733     if(FieldBits::NoField != (DiffuseIntensityFieldMask & whichField))
2734     {
2735         returnValue += _mfDiffuseIntensity.getBinSize();
2736     }
2737     if(FieldBits::NoField != (SpecularIntensityFieldMask & whichField))
2738     {
2739         returnValue += _mfSpecularIntensity.getBinSize();
2740     }
2741     if(FieldBits::NoField != (AttenuationFieldMask & whichField))
2742     {
2743         returnValue += _mfAttenuation.getBinSize();
2744     }
2745     if(FieldBits::NoField != (SpotlightAngleFieldMask & whichField))
2746     {
2747         returnValue += _mfSpotlightAngle.getBinSize();
2748     }
2749     if(FieldBits::NoField != (SpotExponentFieldMask & whichField))
2750     {
2751         returnValue += _mfSpotExponent.getBinSize();
2752     }
2753     if(FieldBits::NoField != (InnerSuperEllipsesWidthFieldMask & whichField))
2754     {
2755         returnValue += _mfInnerSuperEllipsesWidth.getBinSize();
2756     }
2757     if(FieldBits::NoField != (InnerSuperEllipsesHeightFieldMask & whichField))
2758     {
2759         returnValue += _mfInnerSuperEllipsesHeight.getBinSize();
2760     }
2761     if(FieldBits::NoField != (OuterSuperEllipsesWidthFieldMask & whichField))
2762     {
2763         returnValue += _mfOuterSuperEllipsesWidth.getBinSize();
2764     }
2765     if(FieldBits::NoField != (OuterSuperEllipsesHeightFieldMask & whichField))
2766     {
2767         returnValue += _mfOuterSuperEllipsesHeight.getBinSize();
2768     }
2769     if(FieldBits::NoField != (SuperEllipsesRoundnessFieldMask & whichField))
2770     {
2771         returnValue += _mfSuperEllipsesRoundness.getBinSize();
2772     }
2773     if(FieldBits::NoField != (SuperEllipsesTwistFieldMask & whichField))
2774     {
2775         returnValue += _mfSuperEllipsesTwist.getBinSize();
2776     }
2777     if(FieldBits::NoField != (RangeCutOnFieldMask & whichField))
2778     {
2779         returnValue += _mfRangeCutOn.getBinSize();
2780     }
2781     if(FieldBits::NoField != (RangeCutOffFieldMask & whichField))
2782     {
2783         returnValue += _mfRangeCutOff.getBinSize();
2784     }
2785     if(FieldBits::NoField != (RangeNearZoneFieldMask & whichField))
2786     {
2787         returnValue += _mfRangeNearZone.getBinSize();
2788     }
2789     if(FieldBits::NoField != (RangeFarZoneFieldMask & whichField))
2790     {
2791         returnValue += _mfRangeFarZone.getBinSize();
2792     }
2793     if(FieldBits::NoField != (TypeFieldMask & whichField))
2794     {
2795         returnValue += _mfType.getBinSize();
2796     }
2797     if(FieldBits::NoField != (EnabledFieldMask & whichField))
2798     {
2799         returnValue += _mfEnabled.getBinSize();
2800     }
2801     if(FieldBits::NoField != (BeaconFieldMask & whichField))
2802     {
2803         returnValue += _mfBeacon.getBinSize();
2804     }
2805     if(FieldBits::NoField != (BeaconMatrixFieldMask & whichField))
2806     {
2807         returnValue += _mfBeaconMatrix.getBinSize();
2808     }
2809     if(FieldBits::NoField != (EyeSpaceFieldMask & whichField))
2810     {
2811         returnValue += _sfEyeSpace.getBinSize();
2812     }
2813     if(FieldBits::NoField != (LastCamNearFieldMask & whichField))
2814     {
2815         returnValue += _sfLastCamNear.getBinSize();
2816     }
2817     if(FieldBits::NoField != (LastCamFarFieldMask & whichField))
2818     {
2819         returnValue += _sfLastCamFar.getBinSize();
2820     }
2821     if(FieldBits::NoField != (LastCamToWorldFieldMask & whichField))
2822     {
2823         returnValue += _sfLastCamToWorld.getBinSize();
2824     }
2825     if(FieldBits::NoField != (LightBlockNameFieldMask & whichField))
2826     {
2827         returnValue += _sfLightBlockName.getBinSize();
2828     }
2829     if(FieldBits::NoField != (LightVariableNameFieldMask & whichField))
2830     {
2831         returnValue += _sfLightVariableName.getBinSize();
2832     }
2833
2834     return returnValue;
2835 }
2836
2837 void MultiLightChunkBase::copyToBin(BinaryDataHandler &pMem,
2838                                   ConstFieldMaskArg  whichField)
2839 {
2840     Inherited::copyToBin(pMem, whichField);
2841
2842     if(FieldBits::NoField != (HasWorldToLightSpaceMatrixFieldMask & whichField))
2843     {
2844         _sfHasWorldToLightSpaceMatrix.copyToBin(pMem);
2845     }
2846     if(FieldBits::NoField != (HasLightToWorldSpaceMatrixFieldMask & whichField))
2847     {
2848         _sfHasLightToWorldSpaceMatrix.copyToBin(pMem);
2849     }
2850     if(FieldBits::NoField != (HasEyeToLightSpaceMatrixFieldMask & whichField))
2851     {
2852         _sfHasEyeToLightSpaceMatrix.copyToBin(pMem);
2853     }
2854     if(FieldBits::NoField != (HasLightToEyeSpaceMatrixFieldMask & whichField))
2855     {
2856         _sfHasLightToEyeSpaceMatrix.copyToBin(pMem);
2857     }
2858     if(FieldBits::NoField != (HasLightPerspectiveMatrixFieldMask & whichField))
2859     {
2860         _sfHasLightPerspectiveMatrix.copyToBin(pMem);
2861     }
2862     if(FieldBits::NoField != (HasInvLightPerspectiveMatrixFieldMask & whichField))
2863     {
2864         _sfHasInvLightPerspectiveMatrix.copyToBin(pMem);
2865     }
2866     if(FieldBits::NoField != (HasColorFieldMask & whichField))
2867     {
2868         _sfHasColor.copyToBin(pMem);
2869     }
2870     if(FieldBits::NoField != (HasIntensityFieldMask & whichField))
2871     {
2872         _sfHasIntensity.copyToBin(pMem);
2873     }
2874     if(FieldBits::NoField != (HasSeparateIntensitiesFieldMask & whichField))
2875     {
2876         _sfHasSeparateIntensities.copyToBin(pMem);
2877     }
2878     if(FieldBits::NoField != (HasAttenuationFieldMask & whichField))
2879     {
2880         _sfHasAttenuation.copyToBin(pMem);
2881     }
2882     if(FieldBits::NoField != (AutoCalcRangesFieldMask & whichField))
2883     {
2884         _sfAutoCalcRanges.copyToBin(pMem);
2885     }
2886     if(FieldBits::NoField != (HasRangeCutOnFieldMask & whichField))
2887     {
2888         _sfHasRangeCutOn.copyToBin(pMem);
2889     }
2890     if(FieldBits::NoField != (HasRangeCutOffFieldMask & whichField))
2891     {
2892         _sfHasRangeCutOff.copyToBin(pMem);
2893     }
2894     if(FieldBits::NoField != (HasRangeNearZoneFieldMask & whichField))
2895     {
2896         _sfHasRangeNearZone.copyToBin(pMem);
2897     }
2898     if(FieldBits::NoField != (HasRangeFarZoneFieldMask & whichField))
2899     {
2900         _sfHasRangeFarZone.copyToBin(pMem);
2901     }
2902     if(FieldBits::NoField != (HasCosSpotlightAngleFieldMask & whichField))
2903     {
2904         _sfHasCosSpotlightAngle.copyToBin(pMem);
2905     }
2906     if(FieldBits::NoField != (HasSpotlightAngleFieldMask & whichField))
2907     {
2908         _sfHasSpotlightAngle.copyToBin(pMem);
2909     }
2910     if(FieldBits::NoField != (HasSpotExponentFieldMask & whichField))
2911     {
2912         _sfHasSpotExponent.copyToBin(pMem);
2913     }
2914     if(FieldBits::NoField != (HasCinemaLightFieldMask & whichField))
2915     {
2916         _sfHasCinemaLight.copyToBin(pMem);
2917     }
2918     if(FieldBits::NoField != (PositionFieldMask & whichField))
2919     {
2920         _mfPosition.copyToBin(pMem);
2921     }
2922     if(FieldBits::NoField != (DirectionFieldMask & whichField))
2923     {
2924         _mfDirection.copyToBin(pMem);
2925     }
2926     if(FieldBits::NoField != (ColorFieldMask & whichField))
2927     {
2928         _mfColor.copyToBin(pMem);
2929     }
2930     if(FieldBits::NoField != (IntensityFieldMask & whichField))
2931     {
2932         _mfIntensity.copyToBin(pMem);
2933     }
2934     if(FieldBits::NoField != (AmbientIntensityFieldMask & whichField))
2935     {
2936         _mfAmbientIntensity.copyToBin(pMem);
2937     }
2938     if(FieldBits::NoField != (DiffuseIntensityFieldMask & whichField))
2939     {
2940         _mfDiffuseIntensity.copyToBin(pMem);
2941     }
2942     if(FieldBits::NoField != (SpecularIntensityFieldMask & whichField))
2943     {
2944         _mfSpecularIntensity.copyToBin(pMem);
2945     }
2946     if(FieldBits::NoField != (AttenuationFieldMask & whichField))
2947     {
2948         _mfAttenuation.copyToBin(pMem);
2949     }
2950     if(FieldBits::NoField != (SpotlightAngleFieldMask & whichField))
2951     {
2952         _mfSpotlightAngle.copyToBin(pMem);
2953     }
2954     if(FieldBits::NoField != (SpotExponentFieldMask & whichField))
2955     {
2956         _mfSpotExponent.copyToBin(pMem);
2957     }
2958     if(FieldBits::NoField != (InnerSuperEllipsesWidthFieldMask & whichField))
2959     {
2960         _mfInnerSuperEllipsesWidth.copyToBin(pMem);
2961     }
2962     if(FieldBits::NoField != (InnerSuperEllipsesHeightFieldMask & whichField))
2963     {
2964         _mfInnerSuperEllipsesHeight.copyToBin(pMem);
2965     }
2966     if(FieldBits::NoField != (OuterSuperEllipsesWidthFieldMask & whichField))
2967     {
2968         _mfOuterSuperEllipsesWidth.copyToBin(pMem);
2969     }
2970     if(FieldBits::NoField != (OuterSuperEllipsesHeightFieldMask & whichField))
2971     {
2972         _mfOuterSuperEllipsesHeight.copyToBin(pMem);
2973     }
2974     if(FieldBits::NoField != (SuperEllipsesRoundnessFieldMask & whichField))
2975     {
2976         _mfSuperEllipsesRoundness.copyToBin(pMem);
2977     }
2978     if(FieldBits::NoField != (SuperEllipsesTwistFieldMask & whichField))
2979     {
2980         _mfSuperEllipsesTwist.copyToBin(pMem);
2981     }
2982     if(FieldBits::NoField != (RangeCutOnFieldMask & whichField))
2983     {
2984         _mfRangeCutOn.copyToBin(pMem);
2985     }
2986     if(FieldBits::NoField != (RangeCutOffFieldMask & whichField))
2987     {
2988         _mfRangeCutOff.copyToBin(pMem);
2989     }
2990     if(FieldBits::NoField != (RangeNearZoneFieldMask & whichField))
2991     {
2992         _mfRangeNearZone.copyToBin(pMem);
2993     }
2994     if(FieldBits::NoField != (RangeFarZoneFieldMask & whichField))
2995     {
2996         _mfRangeFarZone.copyToBin(pMem);
2997     }
2998     if(FieldBits::NoField != (TypeFieldMask & whichField))
2999     {
3000         _mfType.copyToBin(pMem);
3001     }
3002     if(FieldBits::NoField != (EnabledFieldMask & whichField))
3003     {
3004         _mfEnabled.copyToBin(pMem);
3005     }
3006     if(FieldBits::NoField != (BeaconFieldMask & whichField))
3007     {
3008         _mfBeacon.copyToBin(pMem);
3009     }
3010     if(FieldBits::NoField != (BeaconMatrixFieldMask & whichField))
3011     {
3012         _mfBeaconMatrix.copyToBin(pMem);
3013     }
3014     if(FieldBits::NoField != (EyeSpaceFieldMask & whichField))
3015     {
3016         _sfEyeSpace.copyToBin(pMem);
3017     }
3018     if(FieldBits::NoField != (LastCamNearFieldMask & whichField))
3019     {
3020         _sfLastCamNear.copyToBin(pMem);
3021     }
3022     if(FieldBits::NoField != (LastCamFarFieldMask & whichField))
3023     {
3024         _sfLastCamFar.copyToBin(pMem);
3025     }
3026     if(FieldBits::NoField != (LastCamToWorldFieldMask & whichField))
3027     {
3028         _sfLastCamToWorld.copyToBin(pMem);
3029     }
3030     if(FieldBits::NoField != (LightBlockNameFieldMask & whichField))
3031     {
3032         _sfLightBlockName.copyToBin(pMem);
3033     }
3034     if(FieldBits::NoField != (LightVariableNameFieldMask & whichField))
3035     {
3036         _sfLightVariableName.copyToBin(pMem);
3037     }
3038 }
3039
3040 void MultiLightChunkBase::copyFromBin(BinaryDataHandler &pMem,
3041                                     ConstFieldMaskArg  whichField)
3042 {
3043     Inherited::copyFromBin(pMem, whichField);
3044
3045     if(FieldBits::NoField != (HasWorldToLightSpaceMatrixFieldMask & whichField))
3046     {
3047         editSField(HasWorldToLightSpaceMatrixFieldMask);
3048         _sfHasWorldToLightSpaceMatrix.copyFromBin(pMem);
3049     }
3050     if(FieldBits::NoField != (HasLightToWorldSpaceMatrixFieldMask & whichField))
3051     {
3052         editSField(HasLightToWorldSpaceMatrixFieldMask);
3053         _sfHasLightToWorldSpaceMatrix.copyFromBin(pMem);
3054     }
3055     if(FieldBits::NoField != (HasEyeToLightSpaceMatrixFieldMask & whichField))
3056     {
3057         editSField(HasEyeToLightSpaceMatrixFieldMask);
3058         _sfHasEyeToLightSpaceMatrix.copyFromBin(pMem);
3059     }
3060     if(FieldBits::NoField != (HasLightToEyeSpaceMatrixFieldMask & whichField))
3061     {
3062         editSField(HasLightToEyeSpaceMatrixFieldMask);
3063         _sfHasLightToEyeSpaceMatrix.copyFromBin(pMem);
3064     }
3065     if(FieldBits::NoField != (HasLightPerspectiveMatrixFieldMask & whichField))
3066     {
3067         editSField(HasLightPerspectiveMatrixFieldMask);
3068         _sfHasLightPerspectiveMatrix.copyFromBin(pMem);
3069     }
3070     if(FieldBits::NoField != (HasInvLightPerspectiveMatrixFieldMask & whichField))
3071     {
3072         editSField(HasInvLightPerspectiveMatrixFieldMask);
3073         _sfHasInvLightPerspectiveMatrix.copyFromBin(pMem);
3074     }
3075     if(FieldBits::NoField != (HasColorFieldMask & whichField))
3076     {
3077         editSField(HasColorFieldMask);
3078         _sfHasColor.copyFromBin(pMem);
3079     }
3080     if(FieldBits::NoField != (HasIntensityFieldMask & whichField))
3081     {
3082         editSField(HasIntensityFieldMask);
3083         _sfHasIntensity.copyFromBin(pMem);
3084     }
3085     if(FieldBits::NoField != (HasSeparateIntensitiesFieldMask & whichField))
3086     {
3087         editSField(HasSeparateIntensitiesFieldMask);
3088         _sfHasSeparateIntensities.copyFromBin(pMem);
3089     }
3090     if(FieldBits::NoField != (HasAttenuationFieldMask & whichField))
3091     {
3092         editSField(HasAttenuationFieldMask);
3093         _sfHasAttenuation.copyFromBin(pMem);
3094     }
3095     if(FieldBits::NoField != (AutoCalcRangesFieldMask & whichField))
3096     {
3097         editSField(AutoCalcRangesFieldMask);
3098         _sfAutoCalcRanges.copyFromBin(pMem);
3099     }
3100     if(FieldBits::NoField != (HasRangeCutOnFieldMask & whichField))
3101     {
3102         editSField(HasRangeCutOnFieldMask);
3103         _sfHasRangeCutOn.copyFromBin(pMem);
3104     }
3105     if(FieldBits::NoField != (HasRangeCutOffFieldMask & whichField))
3106     {
3107         editSField(HasRangeCutOffFieldMask);
3108         _sfHasRangeCutOff.copyFromBin(pMem);
3109     }
3110     if(FieldBits::NoField != (HasRangeNearZoneFieldMask & whichField))
3111     {
3112         editSField(HasRangeNearZoneFieldMask);
3113         _sfHasRangeNearZone.copyFromBin(pMem);
3114     }
3115     if(FieldBits::NoField != (HasRangeFarZoneFieldMask & whichField))
3116     {
3117         editSField(HasRangeFarZoneFieldMask);
3118         _sfHasRangeFarZone.copyFromBin(pMem);
3119     }
3120     if(FieldBits::NoField != (HasCosSpotlightAngleFieldMask & whichField))
3121     {
3122         editSField(HasCosSpotlightAngleFieldMask);
3123         _sfHasCosSpotlightAngle.copyFromBin(pMem);
3124     }
3125     if(FieldBits::NoField != (HasSpotlightAngleFieldMask & whichField))
3126     {
3127         editSField(HasSpotlightAngleFieldMask);
3128         _sfHasSpotlightAngle.copyFromBin(pMem);
3129     }
3130     if(FieldBits::NoField != (HasSpotExponentFieldMask & whichField))
3131     {
3132         editSField(HasSpotExponentFieldMask);
3133         _sfHasSpotExponent.copyFromBin(pMem);
3134     }
3135     if(FieldBits::NoField != (HasCinemaLightFieldMask & whichField))
3136     {
3137         editSField(HasCinemaLightFieldMask);
3138         _sfHasCinemaLight.copyFromBin(pMem);
3139     }
3140     if(FieldBits::NoField != (PositionFieldMask & whichField))
3141     {
3142         editMField(PositionFieldMask, _mfPosition);
3143         _mfPosition.copyFromBin(pMem);
3144     }
3145     if(FieldBits::NoField != (DirectionFieldMask & whichField))
3146     {
3147         editMField(DirectionFieldMask, _mfDirection);
3148         _mfDirection.copyFromBin(pMem);
3149     }
3150     if(FieldBits::NoField != (ColorFieldMask & whichField))
3151     {
3152         editMField(ColorFieldMask, _mfColor);
3153         _mfColor.copyFromBin(pMem);
3154     }
3155     if(FieldBits::NoField != (IntensityFieldMask & whichField))
3156     {
3157         editMField(IntensityFieldMask, _mfIntensity);
3158         _mfIntensity.copyFromBin(pMem);
3159     }
3160     if(FieldBits::NoField != (AmbientIntensityFieldMask & whichField))
3161     {
3162         editMField(AmbientIntensityFieldMask, _mfAmbientIntensity);
3163         _mfAmbientIntensity.copyFromBin(pMem);
3164     }
3165     if(FieldBits::NoField != (DiffuseIntensityFieldMask & whichField))
3166     {
3167         editMField(DiffuseIntensityFieldMask, _mfDiffuseIntensity);
3168         _mfDiffuseIntensity.copyFromBin(pMem);
3169     }
3170     if(FieldBits::NoField != (SpecularIntensityFieldMask & whichField))
3171     {
3172         editMField(SpecularIntensityFieldMask, _mfSpecularIntensity);
3173         _mfSpecularIntensity.copyFromBin(pMem);
3174     }
3175     if(FieldBits::NoField != (AttenuationFieldMask & whichField))
3176     {
3177         editMField(AttenuationFieldMask, _mfAttenuation);
3178         _mfAttenuation.copyFromBin(pMem);
3179     }
3180     if(FieldBits::NoField != (SpotlightAngleFieldMask & whichField))
3181     {
3182         editMField(SpotlightAngleFieldMask, _mfSpotlightAngle);
3183         _mfSpotlightAngle.copyFromBin(pMem);
3184     }
3185     if(FieldBits::NoField != (SpotExponentFieldMask & whichField))
3186     {
3187         editMField(SpotExponentFieldMask, _mfSpotExponent);
3188         _mfSpotExponent.copyFromBin(pMem);
3189     }
3190     if(FieldBits::NoField != (InnerSuperEllipsesWidthFieldMask & whichField))
3191     {
3192         editMField(InnerSuperEllipsesWidthFieldMask, _mfInnerSuperEllipsesWidth);
3193         _mfInnerSuperEllipsesWidth.copyFromBin(pMem);
3194     }
3195     if(FieldBits::NoField != (InnerSuperEllipsesHeightFieldMask & whichField))
3196     {
3197         editMField(InnerSuperEllipsesHeightFieldMask, _mfInnerSuperEllipsesHeight);
3198         _mfInnerSuperEllipsesHeight.copyFromBin(pMem);
3199     }
3200     if(FieldBits::NoField != (OuterSuperEllipsesWidthFieldMask & whichField))
3201     {
3202         editMField(OuterSuperEllipsesWidthFieldMask, _mfOuterSuperEllipsesWidth);
3203         _mfOuterSuperEllipsesWidth.copyFromBin(pMem);
3204     }
3205     if(FieldBits::NoField != (OuterSuperEllipsesHeightFieldMask & whichField))
3206     {
3207         editMField(OuterSuperEllipsesHeightFieldMask, _mfOuterSuperEllipsesHeight);
3208         _mfOuterSuperEllipsesHeight.copyFromBin(pMem);
3209     }
3210     if(FieldBits::NoField != (SuperEllipsesRoundnessFieldMask & whichField))
3211     {
3212         editMField(SuperEllipsesRoundnessFieldMask, _mfSuperEllipsesRoundness);
3213         _mfSuperEllipsesRoundness.copyFromBin(pMem);
3214     }
3215     if(FieldBits::NoField != (SuperEllipsesTwistFieldMask & whichField))
3216     {
3217         editMField(SuperEllipsesTwistFieldMask, _mfSuperEllipsesTwist);
3218         _mfSuperEllipsesTwist.copyFromBin(pMem);
3219     }
3220     if(FieldBits::NoField != (RangeCutOnFieldMask & whichField))
3221     {
3222         editMField(RangeCutOnFieldMask, _mfRangeCutOn);
3223         _mfRangeCutOn.copyFromBin(pMem);
3224     }
3225     if(FieldBits::NoField != (RangeCutOffFieldMask & whichField))
3226     {
3227         editMField(RangeCutOffFieldMask, _mfRangeCutOff);
3228         _mfRangeCutOff.copyFromBin(pMem);
3229     }
3230     if(FieldBits::NoField != (RangeNearZoneFieldMask & whichField))
3231     {
3232         editMField(RangeNearZoneFieldMask, _mfRangeNearZone);
3233         _mfRangeNearZone.copyFromBin(pMem);
3234     }
3235     if(FieldBits::NoField != (RangeFarZoneFieldMask & whichField))
3236     {
3237         editMField(RangeFarZoneFieldMask, _mfRangeFarZone);
3238         _mfRangeFarZone.copyFromBin(pMem);
3239     }
3240     if(FieldBits::NoField != (TypeFieldMask & whichField))
3241     {
3242         editMField(TypeFieldMask, _mfType);
3243         _mfType.copyFromBin(pMem);
3244     }
3245     if(FieldBits::NoField != (EnabledFieldMask & whichField))
3246     {
3247         editMField(EnabledFieldMask, _mfEnabled);
3248         _mfEnabled.copyFromBin(pMem);
3249     }
3250     if(FieldBits::NoField != (BeaconFieldMask & whichField))
3251     {
3252         editMField(BeaconFieldMask, _mfBeacon);
3253         _mfBeacon.copyFromBin(pMem);
3254     }
3255     if(FieldBits::NoField != (BeaconMatrixFieldMask & whichField))
3256     {
3257         editMField(BeaconMatrixFieldMask, _mfBeaconMatrix);
3258         _mfBeaconMatrix.copyFromBin(pMem);
3259     }
3260     if(FieldBits::NoField != (EyeSpaceFieldMask & whichField))
3261     {
3262         editSField(EyeSpaceFieldMask);
3263         _sfEyeSpace.copyFromBin(pMem);
3264     }
3265     if(FieldBits::NoField != (LastCamNearFieldMask & whichField))
3266     {
3267         editSField(LastCamNearFieldMask);
3268         _sfLastCamNear.copyFromBin(pMem);
3269     }
3270     if(FieldBits::NoField != (LastCamFarFieldMask & whichField))
3271     {
3272         editSField(LastCamFarFieldMask);
3273         _sfLastCamFar.copyFromBin(pMem);
3274     }
3275     if(FieldBits::NoField != (LastCamToWorldFieldMask & whichField))
3276     {
3277         editSField(LastCamToWorldFieldMask);
3278         _sfLastCamToWorld.copyFromBin(pMem);
3279     }
3280     if(FieldBits::NoField != (LightBlockNameFieldMask & whichField))
3281     {
3282         editSField(LightBlockNameFieldMask);
3283         _sfLightBlockName.copyFromBin(pMem);
3284     }
3285     if(FieldBits::NoField != (LightVariableNameFieldMask & whichField))
3286     {
3287         editSField(LightVariableNameFieldMask);
3288         _sfLightVariableName.copyFromBin(pMem);
3289     }
3290 }
3291
3292 //! create a new instance of the class
3293 MultiLightChunkTransitPtr MultiLightChunkBase::createLocal(BitVector bFlags)
3294 {
3295     MultiLightChunkTransitPtr fc;
3296
3297     if(getClassType().getPrototype() != NULL)
3298     {
3299         FieldContainerTransitPtr tmpPtr =
3300             getClassType().getPrototype()-> shallowCopyLocal(bFlags);
3301
3302         fc = dynamic_pointer_cast<MultiLightChunk>(tmpPtr);
3303     }
3304
3305     return fc;
3306 }
3307
3308 //! create a new instance of the class, copy the container flags
3309 MultiLightChunkTransitPtr MultiLightChunkBase::createDependent(BitVector bFlags)
3310 {
3311     MultiLightChunkTransitPtr fc;
3312
3313     if(getClassType().getPrototype() != NULL)
3314     {
3315         FieldContainerTransitPtr tmpPtr =
3316             getClassType().getPrototype()-> shallowCopyDependent(bFlags);
3317
3318         fc = dynamic_pointer_cast<MultiLightChunk>(tmpPtr);
3319     }
3320
3321     return fc;
3322 }
3323
3324 //! create a new instance of the class
3325 MultiLightChunkTransitPtr MultiLightChunkBase::create(void)
3326 {
3327     MultiLightChunkTransitPtr fc;
3328
3329     if(getClassType().getPrototype() != NULL)
3330     {
3331         FieldContainerTransitPtr tmpPtr =
3332             getClassType().getPrototype()-> shallowCopy();
3333
3334         fc = dynamic_pointer_cast<MultiLightChunk>(tmpPtr);
3335     }
3336
3337     return fc;
3338 }
3339
3340 MultiLightChunk *MultiLightChunkBase::createEmptyLocal(BitVector bFlags)
3341 {
3342     MultiLightChunk *returnValue;
3343
3344     newPtr<MultiLightChunk>(returnValue, bFlags);
3345
3346     returnValue->_pFieldFlags->_bNamespaceMask &= ~bFlags;
3347
3348     return returnValue;
3349 }
3350
3351 //! create an empty new instance of the class, do not copy the prototype
3352 MultiLightChunk *MultiLightChunkBase::createEmpty(void)
3353 {
3354     MultiLightChunk *returnValue;
3355
3356     newPtr<MultiLightChunk>(returnValue, Thread::getCurrentLocalFlags());
3357
3358     returnValue->_pFieldFlags->_bNamespaceMask &=
3359         ~Thread::getCurrentLocalFlags();
3360
3361     return returnValue;
3362 }
3363
3364
3365 FieldContainerTransitPtr MultiLightChunkBase::shallowCopyLocal(
3366     BitVector bFlags) const
3367 {
3368     MultiLightChunk *tmpPtr;
3369
3370     newPtr(tmpPtr, dynamic_cast<const MultiLightChunk *>(this), bFlags);
3371
3372     FieldContainerTransitPtr returnValue(tmpPtr);
3373
3374     tmpPtr->_pFieldFlags->_bNamespaceMask &= ~bFlags;
3375
3376     return returnValue;
3377 }
3378
3379 FieldContainerTransitPtr MultiLightChunkBase::shallowCopyDependent(
3380     BitVector bFlags) const
3381 {
3382     MultiLightChunk *tmpPtr;
3383
3384     newPtr(tmpPtr, dynamic_cast<const MultiLightChunk *>(this), ~bFlags);
3385
3386     FieldContainerTransitPtr returnValue(tmpPtr);
3387
3388     tmpPtr->_pFieldFlags->_bNamespaceMask = bFlags;
3389
3390     return returnValue;
3391 }
3392
3393 FieldContainerTransitPtr MultiLightChunkBase::shallowCopy(void) const
3394 {
3395     MultiLightChunk *tmpPtr;
3396
3397     newPtr(tmpPtr,
3398            dynamic_cast<const MultiLightChunk *>(this),
3399            Thread::getCurrentLocalFlags());
3400
3401     tmpPtr->_pFieldFlags->_bNamespaceMask &= ~Thread::getCurrentLocalFlags();
3402
3403     FieldContainerTransitPtr returnValue(tmpPtr);
3404
3405     return returnValue;
3406 }
3407
3408
3409
3410
3411 /*------------------------- constructors ----------------------------------*/
3412
3413 MultiLightChunkBase::MultiLightChunkBase(void) :
3414     Inherited(),
3415     _sfHasWorldToLightSpaceMatrix(bool(false)),
3416     _sfHasLightToWorldSpaceMatrix(bool(false)),
3417     _sfHasEyeToLightSpaceMatrix(bool(false)),
3418     _sfHasLightToEyeSpaceMatrix(bool(false)),
3419     _sfHasLightPerspectiveMatrix(bool(false)),
3420     _sfHasInvLightPerspectiveMatrix(bool(false)),
3421     _sfHasColor               (bool(false)),
3422     _sfHasIntensity           (bool(false)),
3423     _sfHasSeparateIntensities (bool(true)),
3424     _sfHasAttenuation         (bool(true)),
3425     _sfAutoCalcRanges         (bool(true)),
3426     _sfHasRangeCutOn          (bool(false)),
3427     _sfHasRangeCutOff         (bool(false)),
3428     _sfHasRangeNearZone       (bool(false)),
3429     _sfHasRangeFarZone        (bool(false)),
3430     _sfHasCosSpotlightAngle   (bool(true)),
3431     _sfHasSpotlightAngle      (bool(false)),
3432     _sfHasSpotExponent        (bool(true)),
3433     _sfHasCinemaLight         (bool(false)),
3434     _mfPosition               (),
3435     _mfDirection              (),
3436     _mfColor                  (),
3437     _mfIntensity              (),
3438     _mfAmbientIntensity       (),
3439     _mfDiffuseIntensity       (),
3440     _mfSpecularIntensity      (),
3441     _mfAttenuation            (),
3442     _mfSpotlightAngle         (),
3443     _mfSpotExponent           (),
3444     _mfInnerSuperEllipsesWidth(),
3445     _mfInnerSuperEllipsesHeight(),
3446     _mfOuterSuperEllipsesWidth(),
3447     _mfOuterSuperEllipsesHeight(),
3448     _mfSuperEllipsesRoundness (),
3449     _mfSuperEllipsesTwist     (),
3450     _mfRangeCutOn             (),
3451     _mfRangeCutOff            (),
3452     _mfRangeNearZone          (),
3453     _mfRangeFarZone           (),
3454     _mfType                   (),
3455     _mfEnabled                (),
3456     _mfBeacon                 (),
3457     _mfBeaconMatrix           (),
3458     _sfEyeSpace               (bool(false)),
3459     _sfLastCamNear            (Real32(0.f)),
3460     _sfLastCamFar             (Real32(0.f)),
3461     _sfLastCamToWorld         (),
3462     _sfLightBlockName         (std::string("Lights")),
3463     _sfLightVariableName      (std::string("lights"))
3464 {
3465 }
3466
3467 MultiLightChunkBase::MultiLightChunkBase(const MultiLightChunkBase &source) :
3468     Inherited(source),
3469     _sfHasWorldToLightSpaceMatrix(source._sfHasWorldToLightSpaceMatrix),
3470     _sfHasLightToWorldSpaceMatrix(source._sfHasLightToWorldSpaceMatrix),
3471     _sfHasEyeToLightSpaceMatrix(source._sfHasEyeToLightSpaceMatrix),
3472     _sfHasLightToEyeSpaceMatrix(source._sfHasLightToEyeSpaceMatrix),
3473     _sfHasLightPerspectiveMatrix(source._sfHasLightPerspectiveMatrix),
3474     _sfHasInvLightPerspectiveMatrix(source._sfHasInvLightPerspectiveMatrix),
3475     _sfHasColor               (source._sfHasColor               ),
3476     _sfHasIntensity           (source._sfHasIntensity           ),
3477     _sfHasSeparateIntensities (source._sfHasSeparateIntensities ),
3478     _sfHasAttenuation         (source._sfHasAttenuation         ),
3479     _sfAutoCalcRanges         (source._sfAutoCalcRanges         ),
3480     _sfHasRangeCutOn          (source._sfHasRangeCutOn          ),
3481     _sfHasRangeCutOff         (source._sfHasRangeCutOff         ),
3482     _sfHasRangeNearZone       (source._sfHasRangeNearZone       ),
3483     _sfHasRangeFarZone        (source._sfHasRangeFarZone        ),
3484     _sfHasCosSpotlightAngle   (source._sfHasCosSpotlightAngle   ),
3485     _sfHasSpotlightAngle      (source._sfHasSpotlightAngle      ),
3486     _sfHasSpotExponent        (source._sfHasSpotExponent        ),
3487     _sfHasCinemaLight         (source._sfHasCinemaLight         ),
3488     _mfPosition               (source._mfPosition               ),
3489     _mfDirection              (source._mfDirection              ),
3490     _mfColor                  (source._mfColor                  ),
3491     _mfIntensity              (source._mfIntensity              ),
3492     _mfAmbientIntensity       (source._mfAmbientIntensity       ),
3493     _mfDiffuseIntensity       (source._mfDiffuseIntensity       ),
3494     _mfSpecularIntensity      (source._mfSpecularIntensity      ),
3495     _mfAttenuation            (source._mfAttenuation            ),
3496     _mfSpotlightAngle         (source._mfSpotlightAngle         ),
3497     _mfSpotExponent           (source._mfSpotExponent           ),
3498     _mfInnerSuperEllipsesWidth(source._mfInnerSuperEllipsesWidth),
3499     _mfInnerSuperEllipsesHeight(source._mfInnerSuperEllipsesHeight),
3500     _mfOuterSuperEllipsesWidth(source._mfOuterSuperEllipsesWidth),
3501     _mfOuterSuperEllipsesHeight(source._mfOuterSuperEllipsesHeight),
3502     _mfSuperEllipsesRoundness (source._mfSuperEllipsesRoundness ),
3503     _mfSuperEllipsesTwist     (source._mfSuperEllipsesTwist     ),
3504     _mfRangeCutOn             (source._mfRangeCutOn             ),
3505     _mfRangeCutOff            (source._mfRangeCutOff            ),
3506     _mfRangeNearZone          (source._mfRangeNearZone          ),
3507     _mfRangeFarZone           (source._mfRangeFarZone           ),
3508     _mfType                   (source._mfType                   ),
3509     _mfEnabled                (source._mfEnabled                ),
3510     _mfBeacon                 (),
3511     _mfBeaconMatrix           (source._mfBeaconMatrix           ),
3512     _sfEyeSpace               (source._sfEyeSpace               ),
3513     _sfLastCamNear            (source._sfLastCamNear            ),
3514     _sfLastCamFar             (source._sfLastCamFar             ),
3515     _sfLastCamToWorld         (source._sfLastCamToWorld         ),
3516     _sfLightBlockName         (source._sfLightBlockName         ),
3517     _sfLightVariableName      (source._sfLightVariableName      )
3518 {
3519 }
3520
3521
3522 /*-------------------------- destructors ----------------------------------*/
3523
3524 MultiLightChunkBase::~MultiLightChunkBase(void)
3525 {
3526 }
3527
3528 void MultiLightChunkBase::onCreate(const MultiLightChunk *source)
3529 {
3530     Inherited::onCreate(source);
3531
3532     if(source != NULL)
3533     {
3534         MultiLightChunk *pThis = static_cast<MultiLightChunk *>(this);
3535
3536         MFWeakNodePtr::const_iterator BeaconIt  =
3537             source->_mfBeacon.begin();
3538         MFWeakNodePtr::const_iterator BeaconEnd =
3539             source->_mfBeacon.end  ();
3540
3541         while(BeaconIt != BeaconEnd)
3542         {
3543             pThis->pushToBeacon(*BeaconIt);
3544
3545             ++BeaconIt;
3546         }
3547     }
3548 }
3549
3550 GetFieldHandlePtr MultiLightChunkBase::getHandleHasWorldToLightSpaceMatrix (void) const
3551 {
3552     SFBool::GetHandlePtr returnValue(
3553         new  SFBool::GetHandle(
3554              &_sfHasWorldToLightSpaceMatrix,
3555              this->getType().getFieldDesc(HasWorldToLightSpaceMatrixFieldId),
3556              const_cast<MultiLightChunkBase *>(this)));
3557
3558     return returnValue;
3559 }
3560
3561 EditFieldHandlePtr MultiLightChunkBase::editHandleHasWorldToLightSpaceMatrix(void)
3562 {
3563     SFBool::EditHandlePtr returnValue(
3564         new  SFBool::EditHandle(
3565              &_sfHasWorldToLightSpaceMatrix,
3566              this->getType().getFieldDesc(HasWorldToLightSpaceMatrixFieldId),
3567              this));
3568
3569
3570     editSField(HasWorldToLightSpaceMatrixFieldMask);
3571
3572     return returnValue;
3573 }
3574
3575 GetFieldHandlePtr MultiLightChunkBase::getHandleHasLightToWorldSpaceMatrix (void) const
3576 {
3577     SFBool::GetHandlePtr returnValue(
3578         new  SFBool::GetHandle(
3579              &_sfHasLightToWorldSpaceMatrix,
3580              this->getType().getFieldDesc(HasLightToWorldSpaceMatrixFieldId),
3581              const_cast<MultiLightChunkBase *>(this)));
3582
3583     return returnValue;
3584 }
3585
3586 EditFieldHandlePtr MultiLightChunkBase::editHandleHasLightToWorldSpaceMatrix(void)
3587 {
3588     SFBool::EditHandlePtr returnValue(
3589         new  SFBool::EditHandle(
3590              &_sfHasLightToWorldSpaceMatrix,
3591              this->getType().getFieldDesc(HasLightToWorldSpaceMatrixFieldId),
3592              this));
3593
3594
3595     editSField(HasLightToWorldSpaceMatrixFieldMask);
3596
3597     return returnValue;
3598 }
3599
3600 GetFieldHandlePtr MultiLightChunkBase::getHandleHasEyeToLightSpaceMatrix (void) const
3601 {
3602     SFBool::GetHandlePtr returnValue(
3603         new  SFBool::GetHandle(
3604              &_sfHasEyeToLightSpaceMatrix,
3605              this->getType().getFieldDesc(HasEyeToLightSpaceMatrixFieldId),
3606              const_cast<MultiLightChunkBase *>(this)));
3607
3608     return returnValue;
3609 }
3610
3611 EditFieldHandlePtr MultiLightChunkBase::editHandleHasEyeToLightSpaceMatrix(void)
3612 {
3613     SFBool::EditHandlePtr returnValue(
3614         new  SFBool::EditHandle(
3615              &_sfHasEyeToLightSpaceMatrix,
3616              this->getType().getFieldDesc(HasEyeToLightSpaceMatrixFieldId),
3617              this));
3618
3619
3620     editSField(HasEyeToLightSpaceMatrixFieldMask);
3621
3622     return returnValue;
3623 }
3624
3625 GetFieldHandlePtr MultiLightChunkBase::getHandleHasLightToEyeSpaceMatrix (void) const
3626 {
3627     SFBool::GetHandlePtr returnValue(
3628         new  SFBool::GetHandle(
3629              &_sfHasLightToEyeSpaceMatrix,
3630              this->getType().getFieldDesc(HasLightToEyeSpaceMatrixFieldId),
3631              const_cast<MultiLightChunkBase *>(this)));
3632
3633     return returnValue;
3634 }
3635
3636 EditFieldHandlePtr MultiLightChunkBase::editHandleHasLightToEyeSpaceMatrix(void)
3637 {
3638     SFBool::EditHandlePtr returnValue(
3639         new  SFBool::EditHandle(
3640              &_sfHasLightToEyeSpaceMatrix,
3641              this->getType().getFieldDesc(HasLightToEyeSpaceMatrixFieldId),
3642              this));
3643
3644
3645     editSField(HasLightToEyeSpaceMatrixFieldMask);
3646
3647     return returnValue;
3648 }
3649
3650 GetFieldHandlePtr MultiLightChunkBase::getHandleHasLightPerspectiveMatrix (void) const
3651 {
3652     SFBool::GetHandlePtr returnValue(
3653         new  SFBool::GetHandle(
3654              &_sfHasLightPerspectiveMatrix,
3655              this->getType().getFieldDesc(HasLightPerspectiveMatrixFieldId),
3656              const_cast<MultiLightChunkBase *>(this)));
3657
3658     return returnValue;
3659 }
3660
3661 EditFieldHandlePtr MultiLightChunkBase::editHandleHasLightPerspectiveMatrix(void)
3662 {
3663     SFBool::EditHandlePtr returnValue(
3664         new  SFBool::EditHandle(
3665              &_sfHasLightPerspectiveMatrix,
3666              this->getType().getFieldDesc(HasLightPerspectiveMatrixFieldId),
3667              this));
3668
3669
3670     editSField(HasLightPerspectiveMatrixFieldMask);
3671
3672     return returnValue;
3673 }
3674
3675 GetFieldHandlePtr MultiLightChunkBase::getHandleHasInvLightPerspectiveMatrix (void) const
3676 {
3677     SFBool::GetHandlePtr returnValue(
3678         new  SFBool::GetHandle(
3679              &_sfHasInvLightPerspectiveMatrix,
3680              this->getType().getFieldDesc(HasInvLightPerspectiveMatrixFieldId),
3681              const_cast<MultiLightChunkBase *>(this)));
3682
3683     return returnValue;
3684 }
3685
3686 EditFieldHandlePtr MultiLightChunkBase::editHandleHasInvLightPerspectiveMatrix(void)
3687 {
3688     SFBool::EditHandlePtr returnValue(
3689         new  SFBool::EditHandle(
3690              &_sfHasInvLightPerspectiveMatrix,
3691              this->getType().getFieldDesc(HasInvLightPerspectiveMatrixFieldId),
3692              this));
3693
3694
3695     editSField(HasInvLightPerspectiveMatrixFieldMask);
3696
3697     return returnValue;
3698 }
3699
3700 GetFieldHandlePtr MultiLightChunkBase::getHandleHasColor        (void) const
3701 {
3702     SFBool::GetHandlePtr returnValue(
3703         new  SFBool::GetHandle(
3704              &_sfHasColor,
3705              this->getType().getFieldDesc(HasColorFieldId),
3706              const_cast<MultiLightChunkBase *>(this)));
3707
3708     return returnValue;
3709 }
3710
3711 EditFieldHandlePtr MultiLightChunkBase::editHandleHasColor       (void)
3712 {
3713     SFBool::EditHandlePtr returnValue(
3714         new  SFBool::EditHandle(
3715              &_sfHasColor,
3716              this->getType().getFieldDesc(HasColorFieldId),
3717              this));
3718
3719
3720     editSField(HasColorFieldMask);
3721
3722     return returnValue;
3723 }
3724
3725 GetFieldHandlePtr MultiLightChunkBase::getHandleHasIntensity    (void) const
3726 {
3727     SFBool::GetHandlePtr returnValue(
3728         new  SFBool::GetHandle(
3729              &_sfHasIntensity,
3730              this->getType().getFieldDesc(HasIntensityFieldId),
3731              const_cast<MultiLightChunkBase *>(this)));
3732
3733     return returnValue;
3734 }
3735
3736 EditFieldHandlePtr MultiLightChunkBase::editHandleHasIntensity   (void)
3737 {
3738     SFBool::EditHandlePtr returnValue(
3739         new  SFBool::EditHandle(
3740              &_sfHasIntensity,
3741              this->getType().getFieldDesc(HasIntensityFieldId),
3742              this));
3743
3744
3745     editSField(HasIntensityFieldMask);
3746
3747     return returnValue;
3748 }
3749
3750 GetFieldHandlePtr MultiLightChunkBase::getHandleHasSeparateIntensities (void) const
3751 {
3752     SFBool::GetHandlePtr returnValue(
3753         new  SFBool::GetHandle(
3754              &_sfHasSeparateIntensities,
3755              this->getType().getFieldDesc(HasSeparateIntensitiesFieldId),
3756              const_cast<MultiLightChunkBase *>(this)));
3757
3758     return returnValue;
3759 }
3760
3761 EditFieldHandlePtr MultiLightChunkBase::editHandleHasSeparateIntensities(void)
3762 {
3763     SFBool::EditHandlePtr returnValue(
3764         new  SFBool::EditHandle(
3765              &_sfHasSeparateIntensities,
3766              this->getType().getFieldDesc(HasSeparateIntensitiesFieldId),
3767              this));
3768
3769
3770     editSField(HasSeparateIntensitiesFieldMask);
3771
3772     return returnValue;
3773 }
3774
3775 GetFieldHandlePtr MultiLightChunkBase::getHandleHasAttenuation  (void) const
3776 {
3777     SFBool::GetHandlePtr returnValue(
3778         new  SFBool::GetHandle(
3779              &_sfHasAttenuation,
3780              this->getType().getFieldDesc(HasAttenuationFieldId),
3781              const_cast<MultiLightChunkBase *>(this)));
3782
3783     return returnValue;
3784 }
3785
3786 EditFieldHandlePtr MultiLightChunkBase::editHandleHasAttenuation (void)
3787 {
3788     SFBool::EditHandlePtr returnValue(
3789         new  SFBool::EditHandle(
3790              &_sfHasAttenuation,
3791              this->getType().getFieldDesc(HasAttenuationFieldId),
3792              this));
3793
3794
3795     editSField(HasAttenuationFieldMask);
3796
3797     return returnValue;
3798 }
3799
3800 GetFieldHandlePtr MultiLightChunkBase::getHandleAutoCalcRanges  (void) const
3801 {
3802     SFBool::GetHandlePtr returnValue(
3803         new  SFBool::GetHandle(
3804              &_sfAutoCalcRanges,
3805              this->getType().getFieldDesc(AutoCalcRangesFieldId),
3806              const_cast<MultiLightChunkBase *>(this)));
3807
3808     return returnValue;
3809 }
3810
3811 EditFieldHandlePtr MultiLightChunkBase::editHandleAutoCalcRanges (void)
3812 {
3813     SFBool::EditHandlePtr returnValue(
3814         new  SFBool::EditHandle(
3815              &_sfAutoCalcRanges,
3816              this->getType().getFieldDesc(AutoCalcRangesFieldId),
3817              this));
3818
3819
3820     editSField(AutoCalcRangesFieldMask);
3821
3822     return returnValue;
3823 }
3824
3825 GetFieldHandlePtr MultiLightChunkBase::getHandleHasRangeCutOn   (void) const
3826 {
3827     SFBool::GetHandlePtr returnValue(
3828         new  SFBool::GetHandle(
3829              &_sfHasRangeCutOn,
3830              this->getType().getFieldDesc(HasRangeCutOnFieldId),
3831              const_cast<MultiLightChunkBase *>(this)));
3832
3833     return returnValue;
3834 }
3835
3836 EditFieldHandlePtr MultiLightChunkBase::editHandleHasRangeCutOn  (void)
3837 {
3838     SFBool::EditHandlePtr returnValue(
3839         new  SFBool::EditHandle(
3840              &_sfHasRangeCutOn,
3841              this->getType().getFieldDesc(HasRangeCutOnFieldId),
3842              this));
3843
3844
3845     editSField(HasRangeCutOnFieldMask);
3846
3847     return returnValue;
3848 }
3849
3850 GetFieldHandlePtr MultiLightChunkBase::getHandleHasRangeCutOff  (void) const
3851 {
3852     SFBool::GetHandlePtr returnValue(
3853         new  SFBool::GetHandle(
3854              &_sfHasRangeCutOff,
3855              this->getType().getFieldDesc(HasRangeCutOffFieldId),
3856              const_cast<MultiLightChunkBase *>(this)));
3857
3858     return returnValue;
3859 }
3860
3861 EditFieldHandlePtr MultiLightChunkBase::editHandleHasRangeCutOff (void)
3862 {
3863     SFBool::EditHandlePtr returnValue(
3864         new  SFBool::EditHandle(
3865              &_sfHasRangeCutOff,
3866              this->getType().getFieldDesc(HasRangeCutOffFieldId),
3867              this));
3868
3869
3870     editSField(HasRangeCutOffFieldMask);
3871
3872     return returnValue;
3873 }
3874
3875 GetFieldHandlePtr MultiLightChunkBase::getHandleHasRangeNearZone (void) const
3876 {
3877     SFBool::GetHandlePtr returnValue(
3878         new  SFBool::GetHandle(
3879              &_sfHasRangeNearZone,
3880              this->getType().getFieldDesc(HasRangeNearZoneFieldId),
3881              const_cast<MultiLightChunkBase *>(this)));
3882
3883     return returnValue;
3884 }
3885
3886 EditFieldHandlePtr MultiLightChunkBase::editHandleHasRangeNearZone(void)
3887 {
3888     SFBool::EditHandlePtr returnValue(
3889         new  SFBool::EditHandle(
3890              &_sfHasRangeNearZone,
3891              this->getType().getFieldDesc(HasRangeNearZoneFieldId),
3892              this));
3893
3894
3895     editSField(HasRangeNearZoneFieldMask);
3896
3897     return returnValue;
3898 }
3899
3900 GetFieldHandlePtr MultiLightChunkBase::getHandleHasRangeFarZone (void) const
3901 {
3902     SFBool::GetHandlePtr returnValue(
3903         new  SFBool::GetHandle(
3904              &_sfHasRangeFarZone,
3905              this->getType().getFieldDesc(HasRangeFarZoneFieldId),
3906              const_cast<MultiLightChunkBase *>(this)));
3907
3908     return returnValue;
3909 }
3910
3911 EditFieldHandlePtr MultiLightChunkBase::editHandleHasRangeFarZone(void)
3912 {
3913     SFBool::EditHandlePtr returnValue(
3914         new  SFBool::EditHandle(
3915              &_sfHasRangeFarZone,
3916              this->getType().getFieldDesc(HasRangeFarZoneFieldId),
3917              this));
3918
3919
3920     editSField(HasRangeFarZoneFieldMask);
3921
3922     return returnValue;
3923 }
3924
3925 GetFieldHandlePtr MultiLightChunkBase::getHandleHasCosSpotlightAngle (void) const
3926 {
3927     SFBool::GetHandlePtr returnValue(
3928         new  SFBool::GetHandle(
3929              &_sfHasCosSpotlightAngle,
3930              this->getType().getFieldDesc(HasCosSpotlightAngleFieldId),
3931              const_cast<MultiLightChunkBase *>(this)));
3932
3933     return returnValue;
3934 }
3935
3936 EditFieldHandlePtr MultiLightChunkBase::editHandleHasCosSpotlightAngle(void)
3937 {
3938     SFBool::EditHandlePtr returnValue(
3939         new  SFBool::EditHandle(
3940              &_sfHasCosSpotlightAngle,
3941              this->getType().getFieldDesc(HasCosSpotlightAngleFieldId),
3942              this));
3943
3944
3945     editSField(HasCosSpotlightAngleFieldMask);
3946
3947     return returnValue;
3948 }
3949
3950 GetFieldHandlePtr MultiLightChunkBase::getHandleHasSpotlightAngle (void) const
3951 {
3952     SFBool::GetHandlePtr returnValue(
3953         new  SFBool::GetHandle(
3954              &_sfHasSpotlightAngle,
3955              this->getType().getFieldDesc(HasSpotlightAngleFieldId),
3956              const_cast<MultiLightChunkBase *>(this)));
3957
3958     return returnValue;
3959 }
3960
3961 EditFieldHandlePtr MultiLightChunkBase::editHandleHasSpotlightAngle(void)
3962 {
3963     SFBool::EditHandlePtr returnValue(
3964         new  SFBool::EditHandle(
3965              &_sfHasSpotlightAngle,
3966              this->getType().getFieldDesc(HasSpotlightAngleFieldId),
3967              this));
3968
3969
3970     editSField(HasSpotlightAngleFieldMask);
3971
3972     return returnValue;
3973 }
3974
3975 GetFieldHandlePtr MultiLightChunkBase::getHandleHasSpotExponent (void) const
3976 {
3977     SFBool::GetHandlePtr returnValue(
3978         new  SFBool::GetHandle(
3979              &_sfHasSpotExponent,
3980              this->getType().getFieldDesc(HasSpotExponentFieldId),
3981              const_cast<MultiLightChunkBase *>(this)));
3982
3983     return returnValue;
3984 }
3985
3986 EditFieldHandlePtr MultiLightChunkBase::editHandleHasSpotExponent(void)
3987 {
3988     SFBool::EditHandlePtr returnValue(
3989         new  SFBool::EditHandle(
3990              &_sfHasSpotExponent,
3991              this->getType().getFieldDesc(HasSpotExponentFieldId),
3992              this));
3993
3994
3995     editSField(HasSpotExponentFieldMask);
3996
3997     return returnValue;
3998 }
3999
4000 GetFieldHandlePtr MultiLightChunkBase::getHandleHasCinemaLight  (void) const
4001 {
4002     SFBool::GetHandlePtr returnValue(
4003         new  SFBool::GetHandle(
4004              &_sfHasCinemaLight,
4005              this->getType().getFieldDesc(HasCinemaLightFieldId),
4006              const_cast<MultiLightChunkBase *>(this)));
4007
4008     return returnValue;
4009 }
4010
4011 EditFieldHandlePtr MultiLightChunkBase::editHandleHasCinemaLight (void)
4012 {
4013     SFBool::EditHandlePtr returnValue(
4014         new  SFBool::EditHandle(
4015              &_sfHasCinemaLight,
4016              this->getType().getFieldDesc(HasCinemaLightFieldId),
4017              this));
4018
4019
4020     editSField(HasCinemaLightFieldMask);
4021
4022     return returnValue;
4023 }
4024
4025 GetFieldHandlePtr MultiLightChunkBase::getHandlePosition        (void) const
4026 {
4027     MFPnt3f::GetHandlePtr returnValue(
4028         new  MFPnt3f::GetHandle(
4029              &_mfPosition,
4030              this->getType().getFieldDesc(PositionFieldId),
4031              const_cast<MultiLightChunkBase *>(this)));
4032
4033     return returnValue;
4034 }
4035
4036 EditFieldHandlePtr MultiLightChunkBase::editHandlePosition       (void)
4037 {
4038     MFPnt3f::EditHandlePtr returnValue(
4039         new  MFPnt3f::EditHandle(
4040              &_mfPosition,
4041              this->getType().getFieldDesc(PositionFieldId),
4042              this));
4043
4044
4045     editMField(PositionFieldMask, _mfPosition);
4046
4047     return returnValue;
4048 }
4049
4050 GetFieldHandlePtr MultiLightChunkBase::getHandleDirection       (void) const
4051 {
4052     MFVec3f::GetHandlePtr returnValue(
4053         new  MFVec3f::GetHandle(
4054              &_mfDirection,
4055              this->getType().getFieldDesc(DirectionFieldId),
4056              const_cast<MultiLightChunkBase *>(this)));
4057
4058     return returnValue;
4059 }
4060
4061 EditFieldHandlePtr MultiLightChunkBase::editHandleDirection      (void)
4062 {
4063     MFVec3f::EditHandlePtr returnValue(
4064         new  MFVec3f::EditHandle(
4065              &_mfDirection,
4066              this->getType().getFieldDesc(DirectionFieldId),
4067              this));
4068
4069
4070     editMField(DirectionFieldMask, _mfDirection);
4071
4072     return returnValue;
4073 }
4074
4075 GetFieldHandlePtr MultiLightChunkBase::getHandleColor           (void) const
4076 {
4077     MFColor3f::GetHandlePtr returnValue(
4078         new  MFColor3f::GetHandle(
4079              &_mfColor,
4080              this->getType().getFieldDesc(ColorFieldId),
4081              const_cast<MultiLightChunkBase *>(this)));
4082
4083     return returnValue;
4084 }
4085
4086 EditFieldHandlePtr MultiLightChunkBase::editHandleColor          (void)
4087 {
4088     MFColor3f::EditHandlePtr returnValue(
4089         new  MFColor3f::EditHandle(
4090              &_mfColor,
4091              this->getType().getFieldDesc(ColorFieldId),
4092              this));
4093
4094
4095     editMField(ColorFieldMask, _mfColor);
4096
4097     return returnValue;
4098 }
4099
4100 GetFieldHandlePtr MultiLightChunkBase::getHandleIntensity       (void) const
4101 {
4102     MFReal32::GetHandlePtr returnValue(
4103         new  MFReal32::GetHandle(
4104              &_mfIntensity,
4105              this->getType().getFieldDesc(IntensityFieldId),
4106              const_cast<MultiLightChunkBase *>(this)));
4107
4108     return returnValue;
4109 }
4110
4111 EditFieldHandlePtr MultiLightChunkBase::editHandleIntensity      (void)
4112 {
4113     MFReal32::EditHandlePtr returnValue(
4114         new  MFReal32::EditHandle(
4115              &_mfIntensity,
4116              this->getType().getFieldDesc(IntensityFieldId),
4117              this));
4118
4119
4120     editMField(IntensityFieldMask, _mfIntensity);
4121
4122     return returnValue;
4123 }
4124
4125 GetFieldHandlePtr MultiLightChunkBase::getHandleAmbientIntensity (void) const
4126 {
4127     MFVec3f::GetHandlePtr returnValue(
4128         new  MFVec3f::GetHandle(
4129              &_mfAmbientIntensity,
4130              this->getType().getFieldDesc(AmbientIntensityFieldId),
4131              const_cast<MultiLightChunkBase *>(this)));
4132
4133     return returnValue;
4134 }
4135
4136 EditFieldHandlePtr MultiLightChunkBase::editHandleAmbientIntensity(void)
4137 {
4138     MFVec3f::EditHandlePtr returnValue(
4139         new  MFVec3f::EditHandle(
4140              &_mfAmbientIntensity,
4141              this->getType().getFieldDesc(AmbientIntensityFieldId),
4142              this));
4143
4144
4145     editMField(AmbientIntensityFieldMask, _mfAmbientIntensity);
4146
4147     return returnValue;
4148 }
4149
4150 GetFieldHandlePtr MultiLightChunkBase::getHandleDiffuseIntensity (void) const
4151 {
4152     MFVec3f::GetHandlePtr returnValue(
4153         new  MFVec3f::GetHandle(
4154              &_mfDiffuseIntensity,
4155              this->getType().getFieldDesc(DiffuseIntensityFieldId),
4156              const_cast<MultiLightChunkBase *>(this)));
4157
4158     return returnValue;
4159 }
4160
4161 EditFieldHandlePtr MultiLightChunkBase::editHandleDiffuseIntensity(void)
4162 {
4163     MFVec3f::EditHandlePtr returnValue(
4164         new  MFVec3f::EditHandle(
4165              &_mfDiffuseIntensity,
4166              this->getType().getFieldDesc(DiffuseIntensityFieldId),
4167              this));
4168
4169
4170     editMField(DiffuseIntensityFieldMask, _mfDiffuseIntensity);
4171
4172     return returnValue;
4173 }
4174
4175 GetFieldHandlePtr MultiLightChunkBase::getHandleSpecularIntensity (void) const
4176 {
4177     MFVec3f::GetHandlePtr returnValue(
4178         new  MFVec3f::GetHandle(
4179              &_mfSpecularIntensity,
4180              this->getType().getFieldDesc(SpecularIntensityFieldId),
4181              const_cast<MultiLightChunkBase *>(this)));
4182
4183     return returnValue;
4184 }
4185
4186 EditFieldHandlePtr MultiLightChunkBase::editHandleSpecularIntensity(void)
4187 {
4188     MFVec3f::EditHandlePtr returnValue(
4189         new  MFVec3f::EditHandle(
4190              &_mfSpecularIntensity,
4191              this->getType().getFieldDesc(SpecularIntensityFieldId),
4192              this));
4193
4194
4195     editMField(SpecularIntensityFieldMask, _mfSpecularIntensity);
4196
4197     return returnValue;
4198 }
4199
4200 GetFieldHandlePtr MultiLightChunkBase::getHandleAttenuation     (void) const
4201 {
4202     MFVec3f::GetHandlePtr returnValue(
4203         new  MFVec3f::GetHandle(
4204              &_mfAttenuation,
4205              this->getType().getFieldDesc(AttenuationFieldId),
4206              const_cast<MultiLightChunkBase *>(this)));
4207
4208     return returnValue;
4209 }
4210
4211 EditFieldHandlePtr MultiLightChunkBase::editHandleAttenuation    (void)
4212 {
4213     MFVec3f::EditHandlePtr returnValue(
4214         new  MFVec3f::EditHandle(
4215              &_mfAttenuation,
4216              this->getType().getFieldDesc(AttenuationFieldId),
4217              this));
4218
4219
4220     editMField(AttenuationFieldMask, _mfAttenuation);
4221
4222     return returnValue;
4223 }
4224
4225 GetFieldHandlePtr MultiLightChunkBase::getHandleSpotlightAngle  (void) const
4226 {
4227     MFReal32::GetHandlePtr returnValue(
4228         new  MFReal32::GetHandle(
4229              &_mfSpotlightAngle,
4230              this->getType().getFieldDesc(SpotlightAngleFieldId),
4231              const_cast<MultiLightChunkBase *>(this)));
4232
4233     return returnValue;
4234 }
4235
4236 EditFieldHandlePtr MultiLightChunkBase::editHandleSpotlightAngle (void)
4237 {
4238     MFReal32::EditHandlePtr returnValue(
4239         new  MFReal32::EditHandle(
4240              &_mfSpotlightAngle,
4241              this->getType().getFieldDesc(SpotlightAngleFieldId),
4242              this));
4243
4244
4245     editMField(SpotlightAngleFieldMask, _mfSpotlightAngle);
4246
4247     return returnValue;
4248 }
4249
4250 GetFieldHandlePtr MultiLightChunkBase::getHandleSpotExponent    (void) const
4251 {
4252     MFReal32::GetHandlePtr returnValue(
4253         new  MFReal32::GetHandle(
4254              &_mfSpotExponent,
4255              this->getType().getFieldDesc(SpotExponentFieldId),
4256              const_cast<MultiLightChunkBase *>(this)));
4257
4258     return returnValue;
4259 }
4260
4261 EditFieldHandlePtr MultiLightChunkBase::editHandleSpotExponent   (void)
4262 {
4263     MFReal32::EditHandlePtr returnValue(
4264         new  MFReal32::EditHandle(
4265              &_mfSpotExponent,
4266              this->getType().getFieldDesc(SpotExponentFieldId),
4267              this));
4268
4269
4270     editMField(SpotExponentFieldMask, _mfSpotExponent);
4271
4272     return returnValue;
4273 }
4274
4275 GetFieldHandlePtr MultiLightChunkBase::getHandleInnerSuperEllipsesWidth (void) const
4276 {
4277     MFReal32::GetHandlePtr returnValue(
4278         new  MFReal32::GetHandle(
4279              &_mfInnerSuperEllipsesWidth,
4280              this->getType().getFieldDesc(InnerSuperEllipsesWidthFieldId),
4281              const_cast<MultiLightChunkBase *>(this)));
4282
4283     return returnValue;
4284 }
4285
4286 EditFieldHandlePtr MultiLightChunkBase::editHandleInnerSuperEllipsesWidth(void)
4287 {
4288     MFReal32::EditHandlePtr returnValue(
4289         new  MFReal32::EditHandle(
4290              &_mfInnerSuperEllipsesWidth,
4291              this->getType().getFieldDesc(InnerSuperEllipsesWidthFieldId),
4292              this));
4293
4294
4295     editMField(InnerSuperEllipsesWidthFieldMask, _mfInnerSuperEllipsesWidth);
4296
4297     return returnValue;
4298 }
4299
4300 GetFieldHandlePtr MultiLightChunkBase::getHandleInnerSuperEllipsesHeight (void) const
4301 {
4302     MFReal32::GetHandlePtr returnValue(
4303         new  MFReal32::GetHandle(
4304              &_mfInnerSuperEllipsesHeight,
4305              this->getType().getFieldDesc(InnerSuperEllipsesHeightFieldId),
4306              const_cast<MultiLightChunkBase *>(this)));
4307
4308     return returnValue;
4309 }
4310
4311 EditFieldHandlePtr MultiLightChunkBase::editHandleInnerSuperEllipsesHeight(void)
4312 {
4313     MFReal32::EditHandlePtr returnValue(
4314         new  MFReal32::EditHandle(
4315              &_mfInnerSuperEllipsesHeight,
4316              this->getType().getFieldDesc(InnerSuperEllipsesHeightFieldId),
4317              this));
4318
4319
4320     editMField(InnerSuperEllipsesHeightFieldMask, _mfInnerSuperEllipsesHeight);
4321
4322     return returnValue;
4323 }
4324
4325 GetFieldHandlePtr MultiLightChunkBase::getHandleOuterSuperEllipsesWidth (void) const
4326 {
4327     MFReal32::GetHandlePtr returnValue(
4328         new  MFReal32::GetHandle(
4329              &_mfOuterSuperEllipsesWidth,
4330              this->getType().getFieldDesc(OuterSuperEllipsesWidthFieldId),
4331              const_cast<MultiLightChunkBase *>(this)));
4332
4333     return returnValue;
4334 }
4335
4336 EditFieldHandlePtr MultiLightChunkBase::editHandleOuterSuperEllipsesWidth(void)
4337 {
4338     MFReal32::EditHandlePtr returnValue(
4339         new  MFReal32::EditHandle(
4340              &_mfOuterSuperEllipsesWidth,
4341              this->getType().getFieldDesc(OuterSuperEllipsesWidthFieldId),
4342              this));
4343
4344
4345     editMField(OuterSuperEllipsesWidthFieldMask, _mfOuterSuperEllipsesWidth);
4346
4347     return returnValue;
4348 }
4349
4350 GetFieldHandlePtr MultiLightChunkBase::getHandleOuterSuperEllipsesHeight (void) const
4351 {
4352     MFReal32::GetHandlePtr returnValue(
4353         new  MFReal32::GetHandle(
4354              &_mfOuterSuperEllipsesHeight,
4355              this->getType().getFieldDesc(OuterSuperEllipsesHeightFieldId),
4356              const_cast<MultiLightChunkBase *>(this)));
4357
4358     return returnValue;
4359 }
4360
4361 EditFieldHandlePtr MultiLightChunkBase::editHandleOuterSuperEllipsesHeight(void)
4362 {
4363     MFReal32::EditHandlePtr returnValue(
4364         new  MFReal32::EditHandle(
4365              &_mfOuterSuperEllipsesHeight,
4366              this->getType().getFieldDesc(OuterSuperEllipsesHeightFieldId),
4367              this));
4368
4369
4370     editMField(OuterSuperEllipsesHeightFieldMask, _mfOuterSuperEllipsesHeight);
4371
4372     return returnValue;
4373 }
4374
4375 GetFieldHandlePtr MultiLightChunkBase::getHandleSuperEllipsesRoundness (void) const
4376 {
4377     MFReal32::GetHandlePtr returnValue(
4378         new  MFReal32::GetHandle(
4379              &_mfSuperEllipsesRoundness,
4380              this->getType().getFieldDesc(SuperEllipsesRoundnessFieldId),
4381              const_cast<MultiLightChunkBase *>(this)));
4382
4383     return returnValue;
4384 }
4385
4386 EditFieldHandlePtr MultiLightChunkBase::editHandleSuperEllipsesRoundness(void)
4387 {
4388     MFReal32::EditHandlePtr returnValue(
4389         new  MFReal32::EditHandle(
4390              &_mfSuperEllipsesRoundness,
4391              this->getType().getFieldDesc(SuperEllipsesRoundnessFieldId),
4392              this));
4393
4394
4395     editMField(SuperEllipsesRoundnessFieldMask, _mfSuperEllipsesRoundness);
4396
4397     return returnValue;
4398 }
4399
4400 GetFieldHandlePtr MultiLightChunkBase::getHandleSuperEllipsesTwist (void) const
4401 {
4402     MFReal32::GetHandlePtr returnValue(
4403         new  MFReal32::GetHandle(
4404              &_mfSuperEllipsesTwist,
4405              this->getType().getFieldDesc(SuperEllipsesTwistFieldId),
4406              const_cast<MultiLightChunkBase *>(this)));
4407
4408     return returnValue;
4409 }
4410
4411 EditFieldHandlePtr MultiLightChunkBase::editHandleSuperEllipsesTwist(void)
4412 {
4413     MFReal32::EditHandlePtr returnValue(
4414         new  MFReal32::EditHandle(
4415              &_mfSuperEllipsesTwist,
4416              this->getType().getFieldDesc(SuperEllipsesTwistFieldId),
4417              this));
4418
4419
4420     editMField(SuperEllipsesTwistFieldMask, _mfSuperEllipsesTwist);
4421
4422     return returnValue;
4423 }
4424
4425 GetFieldHandlePtr MultiLightChunkBase::getHandleRangeCutOn      (void) const
4426 {
4427     MFReal32::GetHandlePtr returnValue(
4428         new  MFReal32::GetHandle(
4429              &_mfRangeCutOn,
4430              this->getType().getFieldDesc(RangeCutOnFieldId),
4431              const_cast<MultiLightChunkBase *>(this)));
4432
4433     return returnValue;
4434 }
4435
4436 EditFieldHandlePtr MultiLightChunkBase::editHandleRangeCutOn     (void)
4437 {
4438     MFReal32::EditHandlePtr returnValue(
4439         new  MFReal32::EditHandle(
4440              &_mfRangeCutOn,
4441              this->getType().getFieldDesc(RangeCutOnFieldId),
4442              this));
4443
4444
4445     editMField(RangeCutOnFieldMask, _mfRangeCutOn);
4446
4447     return returnValue;
4448 }
4449
4450 GetFieldHandlePtr MultiLightChunkBase::getHandleRangeCutOff     (void) const
4451 {
4452     MFReal32::GetHandlePtr returnValue(
4453         new  MFReal32::GetHandle(
4454              &_mfRangeCutOff,
4455              this->getType().getFieldDesc(RangeCutOffFieldId),
4456              const_cast<MultiLightChunkBase *>(this)));
4457
4458     return returnValue;
4459 }
4460
4461 EditFieldHandlePtr MultiLightChunkBase::editHandleRangeCutOff    (void)
4462 {
4463     MFReal32::EditHandlePtr returnValue(
4464         new  MFReal32::EditHandle(
4465              &_mfRangeCutOff,
4466              this->getType().getFieldDesc(RangeCutOffFieldId),
4467              this));
4468
4469
4470     editMField(RangeCutOffFieldMask, _mfRangeCutOff);
4471
4472     return returnValue;
4473 }
4474
4475 GetFieldHandlePtr MultiLightChunkBase::getHandleRangeNearZone   (void) const
4476 {
4477     MFReal32::GetHandlePtr returnValue(
4478         new  MFReal32::GetHandle(
4479              &_mfRangeNearZone,
4480              this->getType().getFieldDesc(RangeNearZoneFieldId),
4481              const_cast<MultiLightChunkBase *>(this)));
4482
4483     return returnValue;
4484 }
4485
4486 EditFieldHandlePtr MultiLightChunkBase::editHandleRangeNearZone  (void)
4487 {
4488     MFReal32::EditHandlePtr returnValue(
4489         new  MFReal32::EditHandle(
4490              &_mfRangeNearZone,
4491              this->getType().getFieldDesc(RangeNearZoneFieldId),
4492              this));
4493
4494
4495     editMField(RangeNearZoneFieldMask, _mfRangeNearZone);
4496
4497     return returnValue;
4498 }
4499
4500 GetFieldHandlePtr MultiLightChunkBase::getHandleRangeFarZone    (void) const
4501 {
4502     MFReal32::GetHandlePtr returnValue(
4503         new  MFReal32::GetHandle(
4504              &_mfRangeFarZone,
4505              this->getType().getFieldDesc(RangeFarZoneFieldId),
4506              const_cast<MultiLightChunkBase *>(this)));
4507
4508     return returnValue;
4509 }
4510
4511 EditFieldHandlePtr MultiLightChunkBase::editHandleRangeFarZone   (void)
4512 {
4513     MFReal32::EditHandlePtr returnValue(
4514         new  MFReal32::EditHandle(
4515              &_mfRangeFarZone,
4516              this->getType().getFieldDesc(RangeFarZoneFieldId),
4517              this));
4518
4519
4520     editMField(RangeFarZoneFieldMask, _mfRangeFarZone);
4521
4522     return returnValue;
4523 }
4524
4525 GetFieldHandlePtr MultiLightChunkBase::getHandleType            (void) const
4526 {
4527     MFUInt8::GetHandlePtr returnValue(
4528         new  MFUInt8::GetHandle(
4529              &_mfType,
4530              this->getType().getFieldDesc(TypeFieldId),
4531              const_cast<MultiLightChunkBase *>(this)));
4532
4533     return returnValue;
4534 }
4535
4536 EditFieldHandlePtr MultiLightChunkBase::editHandleType           (void)
4537 {
4538     MFUInt8::EditHandlePtr returnValue(
4539         new  MFUInt8::EditHandle(
4540              &_mfType,
4541              this->getType().getFieldDesc(TypeFieldId),
4542              this));
4543
4544
4545     editMField(TypeFieldMask, _mfType);
4546
4547     return returnValue;
4548 }
4549
4550 GetFieldHandlePtr MultiLightChunkBase::getHandleEnabled         (void) const
4551 {
4552     MFBool::GetHandlePtr returnValue(
4553         new  MFBool::GetHandle(
4554              &_mfEnabled,
4555              this->getType().getFieldDesc(EnabledFieldId),
4556              const_cast<MultiLightChunkBase *>(this)));
4557
4558     return returnValue;
4559 }
4560
4561 EditFieldHandlePtr MultiLightChunkBase::editHandleEnabled        (void)
4562 {
4563     MFBool::EditHandlePtr returnValue(
4564         new  MFBool::EditHandle(
4565              &_mfEnabled,
4566              this->getType().getFieldDesc(EnabledFieldId),
4567              this));
4568
4569
4570     editMField(EnabledFieldMask, _mfEnabled);
4571
4572     return returnValue;
4573 }
4574
4575 GetFieldHandlePtr MultiLightChunkBase::getHandleBeacon          (void) const
4576 {
4577     MFWeakNodePtr::GetHandlePtr returnValue(
4578         new  MFWeakNodePtr::GetHandle(
4579              &_mfBeacon,
4580              this->getType().getFieldDesc(BeaconFieldId),
4581              const_cast<MultiLightChunkBase *>(this)));
4582
4583     return returnValue;
4584 }
4585
4586 EditFieldHandlePtr MultiLightChunkBase::editHandleBeacon         (void)
4587 {
4588     MFWeakNodePtr::EditHandlePtr returnValue(
4589         new  MFWeakNodePtr::EditHandle(
4590              &_mfBeacon,
4591              this->getType().getFieldDesc(BeaconFieldId),
4592              this));
4593
4594     returnValue->setAddMethod(
4595         boost::bind(&MultiLightChunk::pushToBeacon,
4596                     static_cast<MultiLightChunk *>(this), _1));
4597     returnValue->setRemoveMethod(
4598         boost::bind(&MultiLightChunk::removeFromBeacon,
4599                     static_cast<MultiLightChunk *>(this), _1));
4600     returnValue->setRemoveObjMethod(
4601         boost::bind(&MultiLightChunk::removeObjFromBeacon,
4602                     static_cast<MultiLightChunk *>(this), _1));
4603     returnValue->setClearMethod(
4604         boost::bind(&MultiLightChunk::clearBeacon,
4605                     static_cast<MultiLightChunk *>(this)));
4606
4607     editMField(BeaconFieldMask, _mfBeacon);
4608
4609     return returnValue;
4610 }
4611
4612 GetFieldHandlePtr MultiLightChunkBase::getHandleBeaconMatrix    (void) const
4613 {
4614     MFMatrix::GetHandlePtr returnValue(
4615         new  MFMatrix::GetHandle(
4616              &_mfBeaconMatrix,
4617              this->getType().getFieldDesc(BeaconMatrixFieldId),
4618              const_cast<MultiLightChunkBase *>(this)));
4619
4620     return returnValue;
4621 }
4622
4623 EditFieldHandlePtr MultiLightChunkBase::editHandleBeaconMatrix   (void)
4624 {
4625     MFMatrix::EditHandlePtr returnValue(
4626         new  MFMatrix::EditHandle(
4627              &_mfBeaconMatrix,
4628              this->getType().getFieldDesc(BeaconMatrixFieldId),
4629              this));
4630
4631
4632     editMField(BeaconMatrixFieldMask, _mfBeaconMatrix);
4633
4634     return returnValue;
4635 }
4636
4637 GetFieldHandlePtr MultiLightChunkBase::getHandleEyeSpace        (void) const
4638 {
4639     SFBool::GetHandlePtr returnValue(
4640         new  SFBool::GetHandle(
4641              &_sfEyeSpace,
4642              this->getType().getFieldDesc(EyeSpaceFieldId),
4643              const_cast<MultiLightChunkBase *>(this)));
4644
4645     return returnValue;
4646 }
4647
4648 EditFieldHandlePtr MultiLightChunkBase::editHandleEyeSpace       (void)
4649 {
4650     SFBool::EditHandlePtr returnValue(
4651         new  SFBool::EditHandle(
4652              &_sfEyeSpace,
4653              this->getType().getFieldDesc(EyeSpaceFieldId),
4654              this));
4655
4656
4657     editSField(EyeSpaceFieldMask);
4658
4659     return returnValue;
4660 }
4661
4662 GetFieldHandlePtr MultiLightChunkBase::getHandleLastCamNear     (void) const
4663 {
4664     SFReal32::GetHandlePtr returnValue(
4665         new  SFReal32::GetHandle(
4666              &_sfLastCamNear,
4667              this->getType().getFieldDesc(LastCamNearFieldId),
4668              const_cast<MultiLightChunkBase *>(this)));
4669
4670     return returnValue;
4671 }
4672
4673 EditFieldHandlePtr MultiLightChunkBase::editHandleLastCamNear    (void)
4674 {
4675     SFReal32::EditHandlePtr returnValue(
4676         new  SFReal32::EditHandle(
4677              &_sfLastCamNear,
4678              this->getType().getFieldDesc(LastCamNearFieldId),
4679              this));
4680
4681
4682     editSField(LastCamNearFieldMask);
4683
4684     return returnValue;
4685 }
4686
4687 GetFieldHandlePtr MultiLightChunkBase::getHandleLastCamFar      (void) const
4688 {
4689     SFReal32::GetHandlePtr returnValue(
4690         new  SFReal32::GetHandle(
4691              &_sfLastCamFar,
4692              this->getType().getFieldDesc(LastCamFarFieldId),
4693              const_cast<MultiLightChunkBase *>(this)));
4694
4695     return returnValue;
4696 }
4697
4698 EditFieldHandlePtr MultiLightChunkBase::editHandleLastCamFar     (void)
4699 {
4700     SFReal32::EditHandlePtr returnValue(
4701         new  SFReal32::EditHandle(
4702              &_sfLastCamFar,
4703              this->getType().getFieldDesc(LastCamFarFieldId),
4704              this));
4705
4706
4707     editSField(LastCamFarFieldMask);
4708
4709     return returnValue;
4710 }
4711
4712 GetFieldHandlePtr MultiLightChunkBase::getHandleLastCamToWorld  (void) const
4713 {
4714     SFMatrix::GetHandlePtr returnValue(
4715         new  SFMatrix::GetHandle(
4716              &_sfLastCamToWorld,
4717              this->getType().getFieldDesc(LastCamToWorldFieldId),
4718              const_cast<MultiLightChunkBase *>(this)));
4719
4720     return returnValue;
4721 }
4722
4723 EditFieldHandlePtr MultiLightChunkBase::editHandleLastCamToWorld (void)
4724 {
4725     SFMatrix::EditHandlePtr returnValue(
4726         new  SFMatrix::EditHandle(
4727              &_sfLastCamToWorld,
4728              this->getType().getFieldDesc(LastCamToWorldFieldId),
4729              this));
4730
4731
4732     editSField(LastCamToWorldFieldMask);
4733
4734     return returnValue;
4735 }
4736
4737 GetFieldHandlePtr MultiLightChunkBase::getHandleLightBlockName  (void) const
4738 {
4739     SFString::GetHandlePtr returnValue(
4740         new  SFString::GetHandle(
4741              &_sfLightBlockName,
4742              this->getType().getFieldDesc(LightBlockNameFieldId),
4743              const_cast<MultiLightChunkBase *>(this)));
4744
4745     return returnValue;
4746 }
4747
4748 EditFieldHandlePtr MultiLightChunkBase::editHandleLightBlockName (void)
4749 {
4750     SFString::EditHandlePtr returnValue(
4751         new  SFString::EditHandle(
4752              &_sfLightBlockName,
4753              this->getType().getFieldDesc(LightBlockNameFieldId),
4754              this));
4755
4756
4757     editSField(LightBlockNameFieldMask);
4758
4759     return returnValue;
4760 }
4761
4762 GetFieldHandlePtr MultiLightChunkBase::getHandleLightVariableName (void) const
4763 {
4764     SFString::GetHandlePtr returnValue(
4765         new  SFString::GetHandle(
4766              &_sfLightVariableName,
4767              this->getType().getFieldDesc(LightVariableNameFieldId),
4768              const_cast<MultiLightChunkBase *>(this)));
4769
4770     return returnValue;
4771 }
4772
4773 EditFieldHandlePtr MultiLightChunkBase::editHandleLightVariableName(void)
4774 {
4775     SFString::EditHandlePtr returnValue(
4776         new  SFString::EditHandle(
4777              &_sfLightVariableName,
4778              this->getType().getFieldDesc(LightVariableNameFieldId),
4779              this));
4780
4781
4782     editSField(LightVariableNameFieldMask);
4783
4784     return returnValue;
4785 }
4786
4787
4788 #ifdef OSG_MT_CPTR_ASPECT
4789 void MultiLightChunkBase::execSyncV(      FieldContainer    &oFrom,
4790                                         ConstFieldMaskArg  whichField,
4791                                         AspectOffsetStore &oOffsets,
4792                                         ConstFieldMaskArg  syncMode,
4793                                   const UInt32             uiSyncInfo)
4794 {
4795     MultiLightChunk *pThis = static_cast<MultiLightChunk *>(this);
4796
4797     pThis->execSync(static_cast<MultiLightChunk *>(&oFrom),
4798                     whichField,
4799                     oOffsets,
4800                     syncMode,
4801                     uiSyncInfo);
4802 }
4803 #endif
4804
4805
4806 #ifdef OSG_MT_CPTR_ASPECT
4807 FieldContainer *MultiLightChunkBase::createAspectCopy(
4808     const FieldContainer *pRefAspect) const
4809 {
4810     MultiLightChunk *returnValue;
4811
4812     newAspectCopy(returnValue,
4813                   dynamic_cast<const MultiLightChunk *>(pRefAspect),
4814                   dynamic_cast<const MultiLightChunk *>(this));
4815
4816     return returnValue;
4817 }
4818 #endif
4819
4820 void MultiLightChunkBase::resolveLinks(void)
4821 {
4822     Inherited::resolveLinks();
4823
4824     static_cast<MultiLightChunk *>(this)->clearBeacon();
4825
4826 #ifdef OSG_MT_CPTR_ASPECT
4827     AspectOffsetStore oOffsets;
4828
4829     _pAspectStore->fillOffsetArray(oOffsets, this);
4830 #endif
4831
4832 #ifdef OSG_MT_CPTR_ASPECT
4833     _mfPosition.terminateShare(Thread::getCurrentAspect(),
4834                                       oOffsets);
4835 #endif
4836 #ifdef OSG_MT_CPTR_ASPECT
4837     _mfDirection.terminateShare(Thread::getCurrentAspect(),
4838                                       oOffsets);
4839 #endif
4840 #ifdef OSG_MT_CPTR_ASPECT
4841     _mfColor.terminateShare(Thread::getCurrentAspect(),
4842                                       oOffsets);
4843 #endif
4844 #ifdef OSG_MT_CPTR_ASPECT
4845     _mfIntensity.terminateShare(Thread::getCurrentAspect(),
4846                                       oOffsets);
4847 #endif
4848 #ifdef OSG_MT_CPTR_ASPECT
4849     _mfAmbientIntensity.terminateShare(Thread::getCurrentAspect(),
4850                                       oOffsets);
4851 #endif
4852 #ifdef OSG_MT_CPTR_ASPECT
4853     _mfDiffuseIntensity.terminateShare(Thread::getCurrentAspect(),
4854                                       oOffsets);
4855 #endif
4856 #ifdef OSG_MT_CPTR_ASPECT
4857     _mfSpecularIntensity.terminateShare(Thread::getCurrentAspect(),
4858                                       oOffsets);
4859 #endif
4860 #ifdef OSG_MT_CPTR_ASPECT
4861     _mfAttenuation.terminateShare(Thread::getCurrentAspect(),
4862                                       oOffsets);
4863 #endif
4864 #ifdef OSG_MT_CPTR_ASPECT
4865     _mfSpotlightAngle.terminateShare(Thread::getCurrentAspect(),
4866                                       oOffsets);
4867 #endif
4868 #ifdef OSG_MT_CPTR_ASPECT
4869     _mfSpotExponent.terminateShare(Thread::getCurrentAspect(),
4870                                       oOffsets);
4871 #endif
4872 #ifdef OSG_MT_CPTR_ASPECT
4873     _mfInnerSuperEllipsesWidth.terminateShare(Thread::getCurrentAspect(),
4874                                       oOffsets);
4875 #endif
4876 #ifdef OSG_MT_CPTR_ASPECT
4877     _mfInnerSuperEllipsesHeight.terminateShare(Thread::getCurrentAspect(),
4878                                       oOffsets);
4879 #endif
4880 #ifdef OSG_MT_CPTR_ASPECT
4881     _mfOuterSuperEllipsesWidth.terminateShare(Thread::getCurrentAspect(),
4882                                       oOffsets);
4883 #endif
4884 #ifdef OSG_MT_CPTR_ASPECT
4885     _mfOuterSuperEllipsesHeight.terminateShare(Thread::getCurrentAspect(),
4886                                       oOffsets);
4887 #endif
4888 #ifdef OSG_MT_CPTR_ASPECT
4889     _mfSuperEllipsesRoundness.terminateShare(Thread::getCurrentAspect(),
4890                                       oOffsets);
4891 #endif
4892 #ifdef OSG_MT_CPTR_ASPECT
4893     _mfSuperEllipsesTwist.terminateShare(Thread::getCurrentAspect(),
4894                                       oOffsets);
4895 #endif
4896 #ifdef OSG_MT_CPTR_ASPECT
4897     _mfRangeCutOn.terminateShare(Thread::getCurrentAspect(),
4898                                       oOffsets);
4899 #endif
4900 #ifdef OSG_MT_CPTR_ASPECT
4901     _mfRangeCutOff.terminateShare(Thread::getCurrentAspect(),
4902                                       oOffsets);
4903 #endif
4904 #ifdef OSG_MT_CPTR_ASPECT
4905     _mfRangeNearZone.terminateShare(Thread::getCurrentAspect(),
4906                                       oOffsets);
4907 #endif
4908 #ifdef OSG_MT_CPTR_ASPECT
4909     _mfRangeFarZone.terminateShare(Thread::getCurrentAspect(),
4910                                       oOffsets);
4911 #endif
4912 #ifdef OSG_MT_CPTR_ASPECT
4913     _mfType.terminateShare(Thread::getCurrentAspect(),
4914                                       oOffsets);
4915 #endif
4916 #ifdef OSG_MT_CPTR_ASPECT
4917     _mfEnabled.terminateShare(Thread::getCurrentAspect(),
4918                                       oOffsets);
4919 #endif
4920 #ifdef OSG_MT_CPTR_ASPECT
4921     _mfBeaconMatrix.terminateShare(Thread::getCurrentAspect(),
4922                                       oOffsets);
4923 #endif
4924 }
4925
4926
4927 OSG_END_NAMESPACE