Source/System/State/Base/OSGMultiLightChunk.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 //  Includes
  41 //---------------------------------------------------------------------------
  42
  43 #include <cstdlib>
  44 #include <cstdio>
  45
  46 #include <boost/bind.hpp>
  47
  48 #include "OSGConfig.h"
  49
  50 #include "OSGGL.h"
  51 #include "OSGGLU.h"
  52 #include "OSGGLEXT.h"
  53 #include "OSGWindow.h"
  54
  55 #include "OSGMatrix.h"
  56 #include "OSGMatrixUtility.h"
  57 #include "OSGQuaternion.h"
  58
  59 #include "OSGGLFuncProtos.h"
  60 #include "OSGBaseFunctions.h"
  61
  62 #include "OSGDrawEnv.h"
  63 #include "OSGNode.h"
  64
  65 #include "OSGMultiLightChunk.h"
  66
  67 OSG_BEGIN_NAMESPACE
  68
  69 // Documentation for this class is emitted in the
  70 // OSGMultiLightChunkBase.cpp file.
  71 // To modify it, please change the .fcd file (OSGMultiLightChunk.fcd) and
  72 // regenerate the base file.
  73
  74 /***************************************************************************\
  75  *                           Class variables                               *
  76 \***************************************************************************/
  77
  78 typedef OSG::Window Win;
  79
  80 /***************************************************************************\
  81  *                           Class methods                                 *
  82 \***************************************************************************/
  83
  84 void MultiLightChunk::initMethod(InitPhase ePhase)
  85 {
  86     Inherited::initMethod(ePhase);
  87
  88     if(ePhase == TypeObject::SystemPost)
  89     {
  90     }
  91 }
  92
  93
  94 /***************************************************************************\
  95  *                           Instance methods                              *
  96 \***************************************************************************/
  97
  98 MultiLight::MultiLight(Type e)
  99     : position(0.f,0.f,0.f)
 100     , direction(0.f,0.f,1.f)
 101     , color(1.f,1.f,1.f)
 102     , intensity(1.f)
 103     , ambientIntensity(1.f,1.f,1.f)
 104     , diffuseIntensity(1.f,1.f,1.f)
 105     , specularIntensity(1.f,1.f,1.f)
 106     , attenuation(1.f, 0.0001f, 0.000001f)
 107     , spotlightAngle(20.f)
 108     , spotExponent(1.f)
 109     , innerSuperEllipsesWidth(1.f)
 110     , innerSuperEllipsesHeight(1.f)
 111     , outerSuperEllipsesWidth(1.3f)
 112     , outerSuperEllipsesHeight(1.3f)
 113     , superEllipsesRoundness(1.f)
 114     , superEllipsesTwist(0.f)
 115     , rangeCutOn(0.f)
 116     , rangeCutOff(1.f)
 117     , rangeNearZone(0.f)
 118     , rangeFarZone(0.f)
 119     , type(e)
 120     , enabled(true)
 121     , beacon(NULL)
 122 {
 123 }
 124
 125 /*-------------------------------------------------------------------------*\
 126  -  private                                                                 -
 127 \*-------------------------------------------------------------------------*/
 128
 129 /*----------------------- constructors & destructors ----------------------*/
 130
 131 MultiLightChunk::MultiLightChunk(void) :
 132     Inherited(),
 133     _bUpdateBuffer(false),
 134     _cameraCB()
 135 {
 136 }
 137
 138 MultiLightChunk::MultiLightChunk(const MultiLightChunk &source) :
 139     Inherited(source),
 140     _bUpdateBuffer(false),
 141     _cameraCB()
 142 {
 143 }
 144
 145 MultiLightChunk::~MultiLightChunk(void)
 146 {
 147     clearLights();
 148 }
 149
 150 /*----------------------------- class specific ----------------------------*/
 151
 152 void MultiLightChunk::changed(ConstFieldMaskArg whichField,
 153                               UInt32            origin,
 154                               BitVector         details)
 155 {
 156     //
 157     // The BeaconMatrixFieldMask is deliberately omitted
 158     //
 159     if((whichField & ( HasWorldToLightSpaceMatrixFieldMask |
 160                        HasLightToWorldSpaceMatrixFieldMask |
 161                        HasEyeToLightSpaceMatrixFieldMask |
 162                        HasLightToEyeSpaceMatrixFieldMask |
 163                        HasLightPerspectiveMatrixFieldMask |
 164                        HasInvLightPerspectiveMatrixFieldMask |
 165                        HasColorFieldMask |
 166                        HasIntensityFieldMask |
 167                        HasSeparateIntensitiesFieldMask |
 168                        HasAttenuationFieldMask |
 169                        HasRangeCutOnFieldMask |
 170                        HasRangeCutOffFieldMask |
 171                        HasRangeNearZoneFieldMask |
 172                        HasRangeFarZoneFieldMask |
 173                        HasCosSpotlightAngleFieldMask |
 174                        HasSpotlightAngleFieldMask |
 175                        HasSpotExponentFieldMask |
 176                        HasCinemaLightFieldMask |
 177                        AutoCalcRangesFieldMask |
 178                        PositionFieldMask |
 179                        DirectionFieldMask |
 180                        ColorFieldMask |
 181                        IntensityFieldMask |
 182                        AmbientIntensityFieldMask |
 183                        DiffuseIntensityFieldMask |
 184                        SpecularIntensityFieldMask |
 185                        AttenuationFieldMask |
 186                        RangeCutOnFieldMask |
 187                        RangeCutOffFieldMask |
 188                        RangeNearZoneFieldMask |
 189                        RangeFarZoneFieldMask |
 190                        SpotlightAngleFieldMask |
 191                        SpotExponentFieldMask |
 192                        InnerSuperEllipsesWidthFieldMask |
 193                        InnerSuperEllipsesHeightFieldMask |
 194                        OuterSuperEllipsesWidthFieldMask |
 195                        OuterSuperEllipsesHeightFieldMask |
 196                        SuperEllipsesRoundnessFieldMask |
 197                        SuperEllipsesTwistFieldMask |
 198                        TypeFieldMask |
 199                        EnabledFieldMask |
 200                        BeaconFieldMask |
 201                        EyeSpaceFieldMask )) != 0)
 202     {
 203         _bUpdateBuffer = true;
 204     }
 205
 206     Inherited::changed(whichField, origin, details);
 207 }
 208
 209 /*----------------------------- onCreate --------------------------------*/
 210
 211 void MultiLightChunk::onCreate(const MultiLightChunk *source)
 212 {
 213     Inherited::onCreate(source);
 214
 215     if(GlobalSystemState == Startup)
 216         return;
 217 }
 218
 219 void MultiLightChunk::onCreateAspect(
 220     const MultiLightChunk *createAspect,
 221     const MultiLightChunk *source      )
 222 {
 223     Inherited::onCreateAspect(createAspect, source);
 224 }
 225
 226 void MultiLightChunk::onDestroy(UInt32 uiContainerId)
 227 {
 228     Inherited::onDestroy(uiContainerId);
 229 }
 230
 231 /*------------------------------ Output -------------------------------------*/
 232
 233 void MultiLightChunk::dump(      UInt32    ,
 234                            const BitVector ) const
 235 {
 236     SLOG << "Dump MultiLightChunk NI" << std::endl;
 237 }
 238
 239 /*------------------------------ buffer -------------------------------------*/
 240
 241 void MultiLightChunk::transformToWorldSpace(
 242     DrawEnv* pEnv,
 243     Node* beacon,
 244     const Pnt3f& position_bs,
 245     const Vec3f& direction_bs,
 246     Pnt3f& position_ws,
 247     Vec3f& direction_ws) const
 248 {
 249     Matrix matWsFromBS;
 250     matWsFromBS.identity();
 251
 252     if(beacon != NULL)
 253     {
 254         beacon->getToWorld(matWsFromBS);
 255     }
 256     else
 257     {
 258         matWsFromBS.setIdentity();
 259     }
 260
 261     matWsFromBS.multFull( position_bs,  position_ws);
 262     matWsFromBS.multFull(direction_bs, direction_ws);
 263 }
 264
 265 void MultiLightChunk::transformToEyeSpace(
 266     DrawEnv* pEnv,
 267     Node* beacon,
 268     const Pnt3f& position_bs,
 269     const Vec3f& direction_bs,
 270     Pnt3f& position_es,
 271     Vec3f& direction_es) const
 272 {
 273     Matrix matWsFromBS;
 274
 275     if(beacon != NULL)
 276     {
 277         beacon->getToWorld(matWsFromBS);
 278     }
 279     else
 280     {
 281         matWsFromBS.setIdentity();
 282     }
 283
 284     Matrix mat = pEnv->getCameraViewing();  // matEsFromWs
 285     mat.mult(matWsFromBS);                  // matEsFromBs
 286
 287     mat.multFull( position_bs,  position_es);
 288     mat.multFull(direction_bs, direction_es);
 289 }
 290
 291 void MultiLightChunk::calcDirectionalLightMatrices(
 292     DrawEnv* pEnv,
 293     Node* beacon,
 294     const Vec3f& direction_bs,
 295     Matrix& matLSFromWS,
 296     Matrix& matLSFromES) const
 297 {
 298     if(beacon)
 299         beacon->getToWorld(matLSFromWS);    // matWsFromBS;
 300
 301     Matrix     matLightDir;
 302     Quaternion rotLightDir(Vec3f(0.f, 0.f, 1.f), direction_bs);
 303     matLightDir.setRotate(rotLightDir);
 304
 305     matLSFromWS.mult        (matLightDir);
 306     matLSFromWS.invert      (           );  // WS -> LS
 307
 308     Matrix matWsFromEs = pEnv->getCameraToWorld();
 309     matLSFromES = matLSFromWS;
 310     matLSFromES.mult(matWsFromEs);
 311 }
 312
 313 void MultiLightChunk::calcPointLightMatrices(
 314     DrawEnv* pEnv,
 315     Node* beacon,
 316     const Pnt3f& position_bs,
 317     Matrix& matLSFromWS,
 318     Matrix& matLSFromES) const
 319 {
 320     if(beacon)
 321         beacon->getToWorld(matLSFromWS);    // matWsFromBS;
 322
 323     Matrix matLightPos;
 324     matLightPos.setTranslate(position_bs);
 325
 326     matLSFromWS.mult        (matLightPos);
 327     matLSFromWS.invert      (           );  // WS -> LS
 328
 329     Matrix matWsFromEs = pEnv->getCameraToWorld();
 330     matLSFromES = matLSFromWS;
 331     matLSFromES.mult(matWsFromEs);
 332 }
 333
 334 void MultiLightChunk::calcSpotLightMatrices(
 335     DrawEnv* pEnv,
 336     Node* beacon,
 337     const Pnt3f& position_bs,
 338     const Vec3f& direction_bs,
 339     Matrix& matLSFromWS,
 340     Matrix& matLSFromES) const
 341 {
 342     if(beacon)
 343         beacon->getToWorld(matLSFromWS);    // matWsFromBS;
 344
 345     Matrix matLightPos;
 346     matLightPos.setTranslate(position_bs);
 347
 348     Matrix     matLightDir;
 349     Quaternion rotLightDir(Vec3f(0.f, 0.f, 1.f), -direction_bs);
 350     matLightDir.setRotate(rotLightDir);
 351
 352     matLSFromWS.mult        (matLightPos);
 353     matLSFromWS.mult        (matLightDir);
 354     matLSFromWS.invert      (           );  // WS -> LS
 355
 356     Matrix matWsFromEs = pEnv->getCameraToWorld();
 357     matLSFromES = matLSFromWS;
 358     matLSFromES.mult(matWsFromEs);
 359 }
 360
 361 void MultiLightChunk::calcPointLightRange(
 362     DrawEnv*    pEnv,
 363     const Vec3f attenuation,
 364     Real32      threshold,
 365     Real32&     outNear,
 366     Real32&     outFar) const
 367 {
 368     Real32 defaultNear = pEnv->getCameraNear();
 369     Real32 defaultFar  = pEnv->getCameraFar();
 370
 371     outNear = defaultNear;
 372     outFar  = defaultFar;
 373
 374     Real32 q = attenuation[2];
 375     Real32 l = attenuation[1];
 376     Real32 c = attenuation[0];
 377
 378     if (osgAbs(q) > TypeTraits<Real32>::getDefaultEps())
 379     {
 380         Real32 D = l*l - 4.f * q * (c - 1.f/threshold);
 381
 382         if (D >= 0)
 383         {
 384                     D = osgSqrt(D);
 385
 386             Real32 r1 = - l + D / (2.f * q);
 387             Real32 r2 = - l - D / (2.f * q);
 388
 389             if (r1 > 0.f && r2 > 0.f)
 390             {
 391                 outFar = osgMin(r1, r2);
 392             }
 393             else if (r1 > 0.f)
 394             {
 395                 outFar = r1;
 396             }
 397             else if (r2 > 0.f)
 398             {
 399                 outFar = r2;
 400             }
 401         }
 402     }
 403     else if(osgAbs(l) > TypeTraits<Real32>::getDefaultEps())
 404     {
 405         Real32 r = (1.f/threshold - c)/l;
 406
 407         if (r > 0.f)
 408         {
 409             outFar = r;
 410         }
 411     }
 412 }
 413
 414 std::size_t MultiLightChunk::calcLightBufferSize() const
 415 {
 416     std::size_t ao = 0; // aligned offset
 417     std::size_t bo = 0; // base offset
 418
 419     OSG_ASSERT(check_invariant());
 420
 421     //struct Light
 422     //{
 423     //    mat4  worldToLightSpaceMatrix;
 424     //    mat4  lightToWorldSpaceMatrix;
 425     //    mat4  eyeToLightSpaceMatrix;
 426     //    mat4  lightToEyeSpaceMatrix;
 427     //    mat4  lightPerspectiveMatrix
 428     //    mat4  InvLightPerspectiveMatrix;
 429     //    vec3  position;
 430     //    vec3  direction;
 431     //    vec3  color;
 432     //    vec3  ambientIntensity;
 433     //    vec3  diffuseIntensity;
 434     //    vec3  specularIntensity;
 435     //    float intensity;
 436     //    float constantAttenuation;
 437     //    float linearAttenuation;
 438     //    float quadraticAttenuation;
 439     //    float rangeCutOn;
 440     //    float rangeCutOff;
 441     //    float rangeNearZone;
 442     //    float rangeFarZone;
 443     //    float cosSpotlightAngle;
 444     //    float spotlightAngle;
 445     //    float spotExponent;
 446     //    float innerSuperEllipsesWidth;
 447     //    float innerSuperEllipsesHeight;
 448     //    float outerSuperEllipsesWidth;
 449     //    float outerSuperEllipsesHeight;
 450     //    float superEllipsesRoundness;
 451     //    float superEllipsesTwist;
 452     //    int   type;
 453     //    bool  enabled;
 454     //};
 455
 456     if (getHasWorldToLightSpaceMatrix())
 457     {
 458         ao = alignOffset(16, bo); bo = ao + sizeof(OSG::Vec4f); // Matrix  worldToLightSpaceMatrix
 459         ao = alignOffset(16, bo); bo = ao + sizeof(OSG::Vec4f);
 460         ao = alignOffset(16, bo); bo = ao + sizeof(OSG::Vec4f);
 461         ao = alignOffset(16, bo); bo = ao + sizeof(OSG::Vec4f);
 462         ao = alignOffset(16, bo); bo = ao;
 463     }
 464
 465     if (getHasLightToWorldSpaceMatrix())
 466     {
 467         ao = alignOffset(16, bo); bo = ao + sizeof(OSG::Vec4f); // Matrix  lightToWorldSpaceMatrix
 468         ao = alignOffset(16, bo); bo = ao + sizeof(OSG::Vec4f);
 469         ao = alignOffset(16, bo); bo = ao + sizeof(OSG::Vec4f);
 470         ao = alignOffset(16, bo); bo = ao + sizeof(OSG::Vec4f);
 471         ao = alignOffset(16, bo); bo = ao;
 472     }
 473
 474     if (getHasEyeToLightSpaceMatrix())
 475     {
 476         ao = alignOffset(16, bo); bo = ao + sizeof(OSG::Vec4f); // Matrix  eyeToLightSpaceMatrix
 477         ao = alignOffset(16, bo); bo = ao + sizeof(OSG::Vec4f);
 478         ao = alignOffset(16, bo); bo = ao + sizeof(OSG::Vec4f);
 479         ao = alignOffset(16, bo); bo = ao + sizeof(OSG::Vec4f);
 480         ao = alignOffset(16, bo); bo = ao;
 481     }
 482
 483     if (getHasLightToEyeSpaceMatrix())
 484     {
 485         ao = alignOffset(16, bo); bo = ao + sizeof(OSG::Vec4f); // Matrix  lightToEyeSpaceMatrix
 486         ao = alignOffset(16, bo); bo = ao + sizeof(OSG::Vec4f);
 487         ao = alignOffset(16, bo); bo = ao + sizeof(OSG::Vec4f);
 488         ao = alignOffset(16, bo); bo = ao + sizeof(OSG::Vec4f);
 489         ao = alignOffset(16, bo); bo = ao;
 490     }
 491
 492     if (getHasLightPerspectiveMatrix())
 493     {
 494         ao = alignOffset(16, bo); bo = ao + sizeof(OSG::Vec4f); // Matrix  lightPerspectiveMatrix
 495         ao = alignOffset(16, bo); bo = ao + sizeof(OSG::Vec4f);
 496         ao = alignOffset(16, bo); bo = ao + sizeof(OSG::Vec4f);
 497         ao = alignOffset(16, bo); bo = ao + sizeof(OSG::Vec4f);
 498         ao = alignOffset(16, bo); bo = ao;
 499     }
 500
 501     if (getHasInvLightPerspectiveMatrix())
 502     {
 503         ao = alignOffset(16, bo); bo = ao + sizeof(OSG::Vec4f); // Matrix  invLightPerspectiveMatrix
 504         ao = alignOffset(16, bo); bo = ao + sizeof(OSG::Vec4f);
 505         ao = alignOffset(16, bo); bo = ao + sizeof(OSG::Vec4f);
 506         ao = alignOffset(16, bo); bo = ao + sizeof(OSG::Vec4f);
 507         ao = alignOffset(16, bo); bo = ao;
 508     }
 509
 510     ao = alignOffset(16, bo); bo = ao + sizeof(Pnt3f);         // Pnt3f   position
 511     ao = alignOffset(16, bo); bo = ao + sizeof(Vec3f);         // Vec3f   direction
 512
 513     if (getHasColor())
 514     {
 515         ao = alignOffset(16, bo); bo = ao + sizeof(Color3f);   // Color3f color
 516     }
 517
 518     if (getHasSeparateIntensities())
 519     {
 520         ao = alignOffset(16, bo); bo = ao + sizeof(Vec3f);     // Vec3f   ambientIntensity
 521         ao = alignOffset(16, bo); bo = ao + sizeof(Vec3f);     // Vec3f   diffuseIntensity
 522         ao = alignOffset(16, bo); bo = ao + sizeof(Vec3f);     // Vec3f   specularIntensity
 523     }
 524
 525     if (getHasIntensity())
 526     {
 527         ao = alignOffset( 4, bo); bo = ao + sizeof(Real32);    // Real32  intensity
 528     }
 529
 530     if (getHasAttenuation())
 531     {
 532         ao = alignOffset( 4, bo); bo = ao + sizeof(Real32);    // Real32  constantAttenuation
 533         ao = alignOffset( 4, bo); bo = ao + sizeof(Real32);    // Real32  linearAttenuation
 534         ao = alignOffset( 4, bo); bo = ao + sizeof(Real32);    // Real32  quadraticAttenuation
 535     }
 536
 537     if (getHasRangeCutOn())
 538     {
 539         ao = alignOffset( 4, bo); bo = ao + sizeof(Real32);     // Real32  rangeCutOn
 540     }
 541
 542     if (getHasRangeCutOff())
 543     {
 544         ao = alignOffset( 4, bo); bo = ao + sizeof(Real32);     // Real32  rangeCutOff
 545     }
 546
 547     if (getHasRangeNearZone())
 548     {
 549         ao = alignOffset( 4, bo); bo = ao + sizeof(Real32);     // Real32  rangeNearZone
 550     }
 551
 552     if (getHasRangeFarZone())
 553     {
 554         ao = alignOffset( 4, bo); bo = ao + sizeof(Real32);     // Real32  rangeFarZone
 555     }
 556
 557     if (getHasCosSpotlightAngle() || (!getHasCosSpotlightAngle() && !getHasSpotlightAngle()))
 558     {
 559         ao = alignOffset( 4, bo); bo = ao + sizeof(Real32);     // Real32  cosSpotlightAngle
 560     }
 561
 562     if (getHasSpotlightAngle())
 563     {
 564         ao = alignOffset( 4, bo); bo = ao + sizeof(Real32);     // Real32  spotlightAngle
 565     }
 566
 567     if (getHasSpotExponent())
 568     {
 569         ao = alignOffset( 4, bo); bo = ao + sizeof(Real32);     // Real32  spotExponent
 570     }
 571
 572     if (getHasCinemaLight())
 573     {
 574         ao = alignOffset( 4, bo); bo = ao + sizeof(Real32);    // Real32  innerSuperEllipsesWidth
 575         ao = alignOffset( 4, bo); bo = ao + sizeof(Real32);    // Real32  innerSuperEllipsesHeight
 576         ao = alignOffset( 4, bo); bo = ao + sizeof(Real32);    // Real32  outerSuperEllipsesWidth
 577         ao = alignOffset( 4, bo); bo = ao + sizeof(Real32);    // Real32  outerSuperEllipsesHeight
 578         ao = alignOffset( 4, bo); bo = ao + sizeof(Real32);    // Real32  superEllipsesRoundness
 579         ao = alignOffset( 4, bo); bo = ao + sizeof(Real32);    // Real32  superEllipsesTwist
 580     }
 581
 582     ao = alignOffset( 4, bo); bo = ao + sizeof(Int32);         // UInt8   type
 583     ao = alignOffset( 4, bo); bo = ao + sizeof(Int32);         // bool    enabled
 584
 585     ao = alignOffset(16, bo); bo = ao;                         // padding
 586
 587     ao *= numLights();         bo = ao;                        // array
 588     ao = alignOffset(16, bo); bo = ao;                         // padding
 589
 590     return ao;
 591 }
 592
 593 std::vector<UInt8> MultiLightChunk::createLightBuffer(DrawEnv* pEnv) const
 594 {
 595     std::size_t size = calcLightBufferSize();
 596
 597     std::vector<UInt8> buffer(size);
 598
 599     UInt32 num_lights = numLights();
 600
 601     std::size_t ao = 0; // aligned offset
 602     std::size_t bo = 0; // base offset
 603
 604     for (UInt32 idx = 0; idx < num_lights; ++idx)
 605     {
 606         Pnt3f position;
 607         Vec3f direction;
 608
 609         Real32  cosSpotlightAngle = 1.f;
 610         Real32  spotlightAngle    = 0.f;
 611
 612         switch (getType(idx))
 613         {
 614             case MultiLight::POINT_LIGHT:
 615                 break;
 616             case MultiLight::DIRECTIONAL_LIGHT:
 617                 break;
 618             case MultiLight::SPOT_LIGHT:
 619                 cosSpotlightAngle = osgCos(osgDegree2Rad(getSpotlightAngle(idx)));
 620                 spotlightAngle    = osgDegree2Rad(getSpotlightAngle(idx));
 621                 break;
 622             case MultiLight::CINEMA_LIGHT:
 623                 break;
 624         }
 625
 626         Real32  cutOnRange = getHasRangeCutOn () ? getRangeCutOn (idx) : pEnv->getCameraNear();
 627         Real32 cutOffRange = getHasRangeCutOff() ? getRangeCutOff(idx) : pEnv->getCameraFar();
 628
 629         if (getAutoCalcRanges() && getHasAttenuation())
 630         {
 631             const Real32 threshold = 0.001f;
 632             calcPointLightRange(pEnv, getAttenuation(idx), threshold, cutOnRange, cutOffRange);
 633         }
 634
 635         if (getEyeSpace())
 636         {
 637             transformToEyeSpace(
 638                     pEnv, getBeacon(idx),
 639                     getPosition(idx), getDirection(idx),
 640                     position, direction);
 641         }
 642         else
 643         {
 644             transformToWorldSpace(
 645                     pEnv, getBeacon(idx),
 646                     getPosition(idx), getDirection(idx),
 647                     position, direction);
 648         }
 649
 650         Matrix matLSFromWS, matWSFromLS, matLSFromES, matESFromLS;
 651         if (getHasWorldToLightSpaceMatrix() || getHasLightToWorldSpaceMatrix() || getHasEyeToLightSpaceMatrix() || getHasLightToEyeSpaceMatrix())
 652         {
 653             switch (getType(idx))
 654             {
 655                 case MultiLight::POINT_LIGHT:
 656                     calcPointLightMatrices(pEnv, getBeacon(idx), getPosition(idx), matLSFromWS, matLSFromES);
 657                     break;
 658                 case MultiLight::DIRECTIONAL_LIGHT:
 659                     calcDirectionalLightMatrices(pEnv, getBeacon(idx), getDirection(idx), matLSFromWS, matLSFromES);
 660                     break;
 661                 case MultiLight::SPOT_LIGHT:
 662                 case MultiLight::CINEMA_LIGHT:
 663                     calcSpotLightMatrices(pEnv, getBeacon(idx), getPosition(idx), getDirection(idx), matLSFromWS, matLSFromES);
 664                     break;
 665             }
 666         }
 667
 668         if (getHasWorldToLightSpaceMatrix())
 669         {
 670             ao = alignOffset(16, bo); memcpy(&buffer[0] + ao, &matLSFromWS[0][0], sizeof(Vec4f)); bo = ao + sizeof(Vec4f);
 671             ao = alignOffset(16, bo); memcpy(&buffer[0] + ao, &matLSFromWS[1][0], sizeof(Vec4f)); bo = ao + sizeof(Vec4f);
 672             ao = alignOffset(16, bo); memcpy(&buffer[0] + ao, &matLSFromWS[2][0], sizeof(Vec4f)); bo = ao + sizeof(Vec4f);
 673             ao = alignOffset(16, bo); memcpy(&buffer[0] + ao, &matLSFromWS[3][0], sizeof(Vec4f)); bo = ao + sizeof(Vec4f);
 674             ao = alignOffset(16, bo); bo = ao;
 675         }
 676
 677         if (getHasLightToWorldSpaceMatrix())
 678         {
 679             matLSFromWS.inverse(matWSFromLS);
 680
 681             ao = alignOffset(16, bo); memcpy(&buffer[0] + ao, &matWSFromLS[0][0], sizeof(Vec4f)); bo = ao + sizeof(Vec4f);
 682             ao = alignOffset(16, bo); memcpy(&buffer[0] + ao, &matWSFromLS[1][0], sizeof(Vec4f)); bo = ao + sizeof(Vec4f);
 683             ao = alignOffset(16, bo); memcpy(&buffer[0] + ao, &matWSFromLS[2][0], sizeof(Vec4f)); bo = ao + sizeof(Vec4f);
 684             ao = alignOffset(16, bo); memcpy(&buffer[0] + ao, &matWSFromLS[3][0], sizeof(Vec4f)); bo = ao + sizeof(Vec4f);
 685             ao = alignOffset(16, bo); bo = ao;
 686         }
 687
 688         if (getHasEyeToLightSpaceMatrix())
 689         {
 690             ao = alignOffset(16, bo); memcpy(&buffer[0] + ao, &matLSFromES[0][0], sizeof(Vec4f)); bo = ao + sizeof(Vec4f);
 691             ao = alignOffset(16, bo); memcpy(&buffer[0] + ao, &matLSFromES[1][0], sizeof(Vec4f)); bo = ao + sizeof(Vec4f);
 692             ao = alignOffset(16, bo); memcpy(&buffer[0] + ao, &matLSFromES[2][0], sizeof(Vec4f)); bo = ao + sizeof(Vec4f);
 693             ao = alignOffset(16, bo); memcpy(&buffer[0] + ao, &matLSFromES[3][0], sizeof(Vec4f)); bo = ao + sizeof(Vec4f);
 694             ao = alignOffset(16, bo); bo = ao;
 695         }
 696
 697         if (getHasLightToEyeSpaceMatrix())
 698         {
 699             matLSFromES.inverse(matESFromLS);
 700             ao = alignOffset(16, bo); memcpy(&buffer[0] + ao, &matESFromLS[0][0], sizeof(Vec4f)); bo = ao + sizeof(Vec4f);
 701             ao = alignOffset(16, bo); memcpy(&buffer[0] + ao, &matESFromLS[1][0], sizeof(Vec4f)); bo = ao + sizeof(Vec4f);
 702             ao = alignOffset(16, bo); memcpy(&buffer[0] + ao, &matESFromLS[2][0], sizeof(Vec4f)); bo = ao + sizeof(Vec4f);
 703             ao = alignOffset(16, bo); memcpy(&buffer[0] + ao, &matESFromLS[3][0], sizeof(Vec4f)); bo = ao + sizeof(Vec4f);
 704             ao = alignOffset(16, bo); bo = ao;
 705         }
 706
 707         Matrix matLightPerspProj, matInvLightPerspProj;
 708         if (getHasLightPerspectiveMatrix() || getHasInvLightPerspectiveMatrix())
 709         {
 710             switch (getType(idx))
 711             {
 712                 case MultiLight::POINT_LIGHT:
 713                     MatrixPerspective(matLightPerspProj, Pi / 4.f, 1.f, cutOnRange, cutOffRange);
 714                     break;
 715                 case MultiLight::DIRECTIONAL_LIGHT:
 716                     break;
 717                 case MultiLight::SPOT_LIGHT:
 718                     MatrixPerspective(matLightPerspProj, cosSpotlightAngle, 1.f, cutOnRange, cutOffRange);
 719                     break;
 720                 case MultiLight::CINEMA_LIGHT:
 721                     {
 722                         Real32 s = osgMax(osgMax(getInnerSuperEllipsesWidth(idx), getInnerSuperEllipsesHeight(idx)),
 723                                           osgMax(getOuterSuperEllipsesWidth(idx), getOuterSuperEllipsesHeight(idx)));
 724
 725                         Real32 a = osgATan(s/1.f);
 726                         cosSpotlightAngle = cos(a);
 727                         spotlightAngle    = a;
 728
 729                         MatrixPerspective(matLightPerspProj, cosSpotlightAngle, 1.f, cutOnRange, cutOffRange);
 730                     }
 731                     break;
 732             }
 733         }
 734
 735         if (getHasLightPerspectiveMatrix())
 736         {
 737             ao = alignOffset(16, bo); memcpy(&buffer[0] + ao, &matLightPerspProj[0][0], sizeof(Vec4f)); bo = ao + sizeof(Vec4f);
 738             ao = alignOffset(16, bo); memcpy(&buffer[0] + ao, &matLightPerspProj[1][0], sizeof(Vec4f)); bo = ao + sizeof(Vec4f);
 739             ao = alignOffset(16, bo); memcpy(&buffer[0] + ao, &matLightPerspProj[2][0], sizeof(Vec4f)); bo = ao + sizeof(Vec4f);
 740             ao = alignOffset(16, bo); memcpy(&buffer[0] + ao, &matLightPerspProj[3][0], sizeof(Vec4f)); bo = ao + sizeof(Vec4f);
 741             ao = alignOffset(16, bo); bo = ao;
 742         }
 743
 744         if (getHasInvLightPerspectiveMatrix())
 745         {
 746             matLightPerspProj.inverse(matInvLightPerspProj);
 747
 748             ao = alignOffset(16, bo); memcpy(&buffer[0] + ao, &matInvLightPerspProj[0][0], sizeof(Vec4f)); bo = ao + sizeof(Vec4f);
 749             ao = alignOffset(16, bo); memcpy(&buffer[0] + ao, &matInvLightPerspProj[1][0], sizeof(Vec4f)); bo = ao + sizeof(Vec4f);
 750             ao = alignOffset(16, bo); memcpy(&buffer[0] + ao, &matInvLightPerspProj[2][0], sizeof(Vec4f)); bo = ao + sizeof(Vec4f);
 751             ao = alignOffset(16, bo); memcpy(&buffer[0] + ao, &matInvLightPerspProj[3][0], sizeof(Vec4f)); bo = ao + sizeof(Vec4f);
 752             ao = alignOffset(16, bo); bo = ao;
 753         }
 754
 755         ao = alignOffset(16, bo); memcpy(&buffer[0] + ao, &position [0], sizeof(Pnt3f)); bo = ao + sizeof(Pnt3f);
 756         ao = alignOffset(16, bo); memcpy(&buffer[0] + ao, &direction[0], sizeof(Vec3f)); bo = ao + sizeof(Vec3f);
 757
 758         if (getHasColor())
 759         {
 760             ao = alignOffset(16, bo); memcpy(&buffer[0] + ao, &getColor(idx)[0], sizeof(Color3f)); bo = ao + sizeof(Color3f);
 761         }
 762
 763         if (getHasSeparateIntensities())
 764         {
 765             ao = alignOffset(16, bo); memcpy(&buffer[0] + ao, &getAmbientIntensity (idx)[0], sizeof(Vec3f)); bo = ao + sizeof(Vec3f);
 766             ao = alignOffset(16, bo); memcpy(&buffer[0] + ao, &getDiffuseIntensity (idx)[0], sizeof(Vec3f)); bo = ao + sizeof(Vec3f);
 767             ao = alignOffset(16, bo); memcpy(&buffer[0] + ao, &getSpecularIntensity(idx)[0], sizeof(Vec3f)); bo = ao + sizeof(Vec3f);
 768         }
 769
 770         if (getHasIntensity())
 771         {
 772             ao = alignOffset( 4, bo); *(reinterpret_cast<Real32*>(&buffer[0] + ao)) = getIntensity(idx); bo = ao + sizeof(Real32);
 773         }
 774
 775         if (getHasAttenuation())
 776         {
 777             ao = alignOffset( 4, bo); *(reinterpret_cast<Real32*>(&buffer[0] + ao)) = getAttenuation(idx)[0]; bo = ao + sizeof(Real32);
 778             ao = alignOffset( 4, bo); *(reinterpret_cast<Real32*>(&buffer[0] + ao)) = getAttenuation(idx)[1]; bo = ao + sizeof(Real32);
 779             ao = alignOffset( 4, bo); *(reinterpret_cast<Real32*>(&buffer[0] + ao)) = getAttenuation(idx)[2]; bo = ao + sizeof(Real32);
 780         }
 781
 782         if (getHasRangeCutOn())
 783         {
 784             ao = alignOffset( 4, bo); *(reinterpret_cast<Real32*>(&buffer[0] + ao)) = cutOnRange; bo = ao + sizeof(Real32);
 785         }
 786
 787         if (getHasRangeCutOff())
 788         {
 789             ao = alignOffset( 4, bo); *(reinterpret_cast<Real32*>(&buffer[0] + ao)) = cutOffRange; bo = ao + sizeof(Real32);
 790         }
 791
 792         if (getHasRangeNearZone())
 793         {
 794             ao = alignOffset( 4, bo); *(reinterpret_cast<Real32*>(&buffer[0] + ao)) = getRangeNearZone(idx); bo = ao + sizeof(Real32);
 795         }
 796
 797         if (getHasRangeFarZone())
 798         {
 799             ao = alignOffset( 4, bo); *(reinterpret_cast<Real32*>(&buffer[0] + ao)) = getRangeFarZone (idx); bo = ao + sizeof(Real32);
 800         }
 801
 802         if (getHasCosSpotlightAngle() || (!getHasCosSpotlightAngle() && !getHasSpotlightAngle()))
 803         {
 804             ao = alignOffset( 4, bo); *(reinterpret_cast<Real32*>(&buffer[0] + ao)) = cosSpotlightAngle; bo = ao + sizeof(Real32);
 805         }
 806
 807         if (getHasSpotlightAngle())
 808         {
 809             ao = alignOffset( 4, bo); *(reinterpret_cast<Real32*>(&buffer[0] + ao)) = spotlightAngle; bo = ao + sizeof(Real32);
 810         }
 811
 812         if (getHasSpotExponent())
 813         {
 814             ao = alignOffset( 4, bo); *(reinterpret_cast<Real32*>(&buffer[0] + ao)) = getSpotExponent(idx); bo = ao + sizeof(Real32);
 815         }
 816
 817         if (getHasCinemaLight())
 818         {
 819             OSG::Real32 twistAngle = osgDegree2Rad(getSuperEllipsesTwist(idx));
 820
 821             ao = alignOffset( 4, bo); *(reinterpret_cast<Real32*>(&buffer[0] + ao)) = getInnerSuperEllipsesWidth (idx); bo = ao + sizeof(Real32);
 822             ao = alignOffset( 4, bo); *(reinterpret_cast<Real32*>(&buffer[0] + ao)) = getInnerSuperEllipsesHeight(idx); bo = ao + sizeof(Real32);
 823             ao = alignOffset( 4, bo); *(reinterpret_cast<Real32*>(&buffer[0] + ao)) = getOuterSuperEllipsesWidth (idx); bo = ao + sizeof(Real32);
 824             ao = alignOffset( 4, bo); *(reinterpret_cast<Real32*>(&buffer[0] + ao)) = getOuterSuperEllipsesHeight(idx); bo = ao + sizeof(Real32);
 825             ao = alignOffset( 4, bo); *(reinterpret_cast<Real32*>(&buffer[0] + ao)) = getSuperEllipsesRoundness  (idx); bo = ao + sizeof(Real32);
 826             ao = alignOffset( 4, bo); *(reinterpret_cast<Real32*>(&buffer[0] + ao)) = twistAngle;                       bo = ao + sizeof(Real32);
 827         }
 828
 829         ao = alignOffset( 4, bo); *(reinterpret_cast<Int32*>(&buffer[0] + ao)) = Int32(getType(idx)); bo = ao + sizeof(Int32);
 830         ao = alignOffset( 4, bo); *(reinterpret_cast<bool* >(&buffer[0] + ao)) = getEnabled(idx);     bo = ao + sizeof(Int32);
 831
 832         ao = alignOffset(16, bo); bo = ao;    // padding
 833     }
 834
 835     return buffer;
 836 }
 837
 838 void MultiLightChunk::createLightState(DrawEnv* pEnv)
 839 {
 840     std::vector<UInt8> buffer = createLightBuffer(pEnv);
 841     editMFBuffer()->setValues(buffer);
 842 }
 843
 844 void MultiLightChunk::updateLightState(DrawEnv* pEnv)
 845 {
 846     std::vector<UInt8> buffer = createLightBuffer(pEnv);
 847     editMFBuffer()->setValues(buffer);
 848
 849     setLastCamNear   (pEnv->getCameraNear());
 850     setLastCamFar    (pEnv->getCameraFar());
 851     setLastCamToWorld(pEnv->getCameraToWorld());
 852
 853     for (std::size_t idx = 0; idx < _mfBeacon.size(); ++idx)
 854     {
 855         Matrix matWsFromBS;
 856         Node* beacon = getBeacon(UInt32(idx));
 857         if (beacon)
 858         {
 859             beacon->getToWorld(matWsFromBS);
 860
 861             editMField(BeaconMatrixFieldMask, _mfBeaconMatrix);
 862             _mfBeaconMatrix[idx] = matWsFromBS;
 863         }
 864     }
 865
 866     _bUpdateBuffer = false;
 867 }
 868
 869 /*------------------------------ activate -----------------------------------*/
 870
 871 void MultiLightChunk::activate(DrawEnv *pEnv, UInt32 index)
 872 {
 873     if (getLastCamNear   () != pEnv->getCameraNear() ||
 874         getLastCamFar    () != pEnv->getCameraFar()  ||
 875         getLastCamToWorld() != pEnv->getCameraToWorld())
 876     {
 877         _bUpdateBuffer = true;
 878     }
 879     else
 880     {
 881         for (std::size_t idx = 0; idx < _mfBeacon.size(); ++idx)
 882         {
 883             Matrix matWsFromBS;
 884             Node* beacon = getBeacon(UInt32(idx));
 885             if (beacon)
 886             {
 887                 beacon->getToWorld(matWsFromBS);
 888
 889                 if (matWsFromBS != _mfBeaconMatrix[idx])
 890                 {
 891                     _bUpdateBuffer = true;
 892                     break;
 893                 }
 894             }
 895         }
 896     }
 897
 898     if (_bUpdateBuffer)
 899         updateLightState(pEnv);
 900
 901     Inherited::activate(pEnv, index);
 902 }
 903
 904 /*------------------------------ deactivate ---------------------------------*/
 905
 906 void MultiLightChunk::deactivate(DrawEnv *pEnv, UInt32 index)
 907 {
 908     Inherited::deactivate(pEnv, index);
 909 }
 910
 911 /*------------------------------ changeFrom ---------------------------------*/
 912
 913 void MultiLightChunk::changeFrom(DrawEnv    *pEnv,
 914                                  StateChunk *old,
 915                                  UInt32      index )
 916 {
 917     Inherited::changeFrom(pEnv, old, index);
 918 }
 919
 920 /*------------------------------ interface ----------------------------------*/
 921
 922 UInt32 MultiLightChunk::addLight(MultiLight::Type eType)
 923 {
 924     if (!check_invariant())
 925         clearLights();
 926
 927     editMField(PositionFieldMask,           _mfPosition);
 928     editMField(DirectionFieldMask,          _mfDirection);
 929     editMField(SpotlightAngleFieldMask,     _mfSpotlightAngle);
 930     editMField(TypeFieldMask,               _mfType);
 931     editMField(EnabledFieldMask,            _mfEnabled);
 932     editMField(BeaconFieldMask,             _mfBeacon);
 933     editMField(BeaconMatrixFieldMask,       _mfBeaconMatrix);
 934
 935     _mfPosition.        push_back(Pnt3f(0.f,0.f,0.f));
 936     _mfDirection.       push_back(Vec3f(0.f,0.f,1.f));
 937     _mfSpotlightAngle.  push_back(45.f);
 938     _mfType.            push_back(eType);
 939     _mfEnabled.         push_back(false);
 940                         pushToBeacon(NULL);
 941     _mfBeaconMatrix.    push_back(Matrix());
 942
 943     if (getHasSeparateIntensities())
 944     {
 945         editMField(AmbientIntensityFieldMask,   _mfAmbientIntensity);
 946         editMField(DiffuseIntensityFieldMask,   _mfDiffuseIntensity);
 947         editMField(SpecularIntensityFieldMask,  _mfSpecularIntensity);
 948
 949         _mfAmbientIntensity. push_back(Vec3f(1.f,1.f,1.f));
 950         _mfDiffuseIntensity. push_back(Vec3f(1.f,1.f,1.f));
 951         _mfSpecularIntensity.push_back(Vec3f(1.f,1.f,1.f));
 952     }
 953
 954     if (getHasColor())
 955     {
 956         editMField(ColorFieldMask,          _mfColor);
 957         _mfColor.push_back(Vec3f(1.f,1.f,1.f));
 958     }
 959
 960     if (getHasIntensity())
 961     {
 962         editMField(IntensityFieldMask,      _mfIntensity);
 963         _mfIntensity.push_back(1.f);
 964     }
 965
 966     if (getHasAttenuation())
 967     {
 968         editMField(AttenuationFieldMask,    _mfAttenuation);
 969         _mfAttenuation.push_back(Vec3f(1.f,0.f,0.f));
 970     }
 971
 972     if (getHasRangeCutOn())
 973     {
 974         editMField(RangeCutOnFieldMask,     _mfRangeCutOn);
 975         _mfRangeCutOn.push_back(0.f);
 976     }
 977
 978     if (getHasRangeCutOff())
 979     {
 980         editMField(RangeCutOffFieldMask,    _mfRangeCutOff);
 981         _mfRangeCutOff.push_back(0.f);
 982     }
 983
 984     if (getHasRangeNearZone())
 985     {
 986         editMField(RangeNearZoneFieldMask,  _mfRangeNearZone);
 987         _mfRangeNearZone.push_back(0.f);
 988     }
 989
 990     if (getHasRangeFarZone())
 991     {
 992         editMField(RangeFarZoneFieldMask,   _mfRangeFarZone);
 993         _mfRangeFarZone.push_back(0.f);
 994     }
 995
 996     if (getHasSpotExponent())
 997     {
 998         editMField(SpotExponentFieldMask,   _mfSpotExponent);
 999         _mfSpotExponent.push_back(1.f);
1000     }
1001
1002     if (getHasCinemaLight())
1003     {
1004         editMField(InnerSuperEllipsesWidthFieldMask,    _mfInnerSuperEllipsesWidth);
1005         editMField(InnerSuperEllipsesHeightFieldMask,   _mfInnerSuperEllipsesHeight);
1006         editMField(OuterSuperEllipsesWidthFieldMask,    _mfOuterSuperEllipsesWidth);
1007         editMField(OuterSuperEllipsesHeightFieldMask,   _mfOuterSuperEllipsesHeight);
1008         editMField(SuperEllipsesRoundnessFieldMask,     _mfSuperEllipsesRoundness);
1009         editMField(SuperEllipsesTwistFieldMask,         _mfSuperEllipsesTwist);
1010
1011         _mfInnerSuperEllipsesWidth. push_back(1.f);
1012         _mfInnerSuperEllipsesHeight.push_back(1.f);
1013         _mfOuterSuperEllipsesWidth. push_back(1.f);
1014         _mfOuterSuperEllipsesHeight.push_back(1.f);
1015         _mfSuperEllipsesRoundness.  push_back(0.f);
1016         _mfSuperEllipsesTwist.      push_back(0.f);
1017     }
1018
1019     OSG_ASSERT(check_invariant());
1020
1021     return UInt32(_mfPosition.size() - 1);
1022 }
1023
1024 UInt32 MultiLightChunk::addLight(const MultiLight& light)
1025 {
1026     if (!check_invariant())
1027         clearLights();
1028
1029     editMField(PositionFieldMask,           _mfPosition);
1030     editMField(DirectionFieldMask,          _mfDirection);
1031     editMField(SpotlightAngleFieldMask,     _mfSpotlightAngle);
1032     editMField(TypeFieldMask,               _mfType);
1033     editMField(EnabledFieldMask,            _mfEnabled);
1034     editMField(BeaconFieldMask,             _mfBeacon);
1035     editMField(BeaconMatrixFieldMask,       _mfBeaconMatrix);
1036
1037     _mfPosition.        push_back(light.position);
1038     _mfDirection.       push_back(light.direction);
1039     _mfSpotlightAngle.  push_back(light.spotlightAngle);
1040     _mfType.            push_back(light.type);
1041     _mfEnabled.         push_back(light.enabled);
1042                         pushToBeacon(light.beacon);
1043     _mfBeaconMatrix.    push_back(Matrix());
1044
1045     if (getHasSeparateIntensities())
1046     {
1047         editMField(AmbientIntensityFieldMask,   _mfAmbientIntensity);
1048         editMField(DiffuseIntensityFieldMask,   _mfDiffuseIntensity);
1049         editMField(SpecularIntensityFieldMask,  _mfSpecularIntensity);
1050
1051         _mfAmbientIntensity. push_back(light.ambientIntensity);
1052         _mfDiffuseIntensity. push_back(light.diffuseIntensity);
1053         _mfSpecularIntensity.push_back(light.specularIntensity);
1054     }
1055
1056     if (getHasColor())
1057     {
1058         editMField(ColorFieldMask,          _mfColor);
1059         _mfColor.push_back(light.color);
1060     }
1061
1062     if (getHasIntensity())
1063     {
1064         editMField(IntensityFieldMask,      _mfIntensity);
1065         _mfIntensity.push_back(light.intensity);
1066     }
1067
1068     if (getHasAttenuation())
1069     {
1070         editMField(AttenuationFieldMask,    _mfAttenuation);
1071         _mfAttenuation.push_back(light.attenuation);
1072     }
1073
1074     if (getHasRangeCutOn())
1075     {
1076         editMField(RangeCutOnFieldMask,     _mfRangeCutOn);
1077         _mfRangeCutOn.push_back(light.rangeCutOn);
1078     }
1079
1080     if (getHasRangeCutOff())
1081     {
1082         editMField(RangeCutOffFieldMask,    _mfRangeCutOff);
1083         _mfRangeCutOff.push_back(light.rangeCutOff);
1084     }
1085
1086     if (getHasRangeNearZone())
1087     {
1088         editMField(RangeNearZoneFieldMask,  _mfRangeNearZone);
1089         _mfRangeNearZone.push_back(light.rangeNearZone);
1090     }
1091
1092     if (getHasRangeFarZone())
1093     {
1094         editMField(RangeFarZoneFieldMask,   _mfRangeFarZone);
1095         _mfRangeFarZone.push_back(light.rangeFarZone);
1096     }
1097
1098     if (getHasSpotExponent())
1099     {
1100         editMField(SpotExponentFieldMask,   _mfSpotExponent);
1101         _mfSpotExponent.push_back(light.spotExponent);
1102     }
1103
1104     if (getHasCinemaLight())
1105     {
1106         editMField(InnerSuperEllipsesWidthFieldMask,    _mfInnerSuperEllipsesWidth);
1107         editMField(InnerSuperEllipsesHeightFieldMask,   _mfInnerSuperEllipsesHeight);
1108         editMField(OuterSuperEllipsesWidthFieldMask,    _mfOuterSuperEllipsesWidth);
1109         editMField(OuterSuperEllipsesHeightFieldMask,   _mfOuterSuperEllipsesHeight);
1110         editMField(SuperEllipsesRoundnessFieldMask,     _mfSuperEllipsesRoundness);
1111         editMField(SuperEllipsesTwistFieldMask,         _mfSuperEllipsesTwist);
1112
1113         _mfInnerSuperEllipsesWidth. push_back(light.innerSuperEllipsesWidth);
1114         _mfInnerSuperEllipsesHeight.push_back(light.innerSuperEllipsesHeight);
1115         _mfOuterSuperEllipsesWidth. push_back(light.outerSuperEllipsesWidth);
1116         _mfOuterSuperEllipsesHeight.push_back(light.outerSuperEllipsesHeight);
1117         _mfSuperEllipsesRoundness.  push_back(light.superEllipsesRoundness);
1118         _mfSuperEllipsesTwist.      push_back(light.superEllipsesTwist);
1119     }
1120
1121     OSG_ASSERT(check_invariant());
1122
1123     return UInt32(_mfPosition.size() - 1);
1124 }
1125
1126 void MultiLightChunk::updateLight(const UInt32 idx, const MultiLight& light)
1127 {
1128     setPosition         (idx, light.position);
1129     setDirection        (idx, light.direction);
1130     setSpotlightAngle   (idx, light.spotlightAngle);
1131     setType             (idx, light.type);
1132     setEnabled          (idx, light.enabled);
1133     setBeacon           (idx, light.beacon);
1134
1135     if (getHasSeparateIntensities())
1136     {
1137         setAmbientIntensity (idx, light.ambientIntensity);
1138         setDiffuseIntensity (idx, light.diffuseIntensity);
1139         setSpecularIntensity(idx, light.specularIntensity);
1140     }
1141
1142     if (getHasColor())
1143     {
1144         setColor(idx, light.color);
1145     }
1146
1147     if (getHasIntensity())
1148     {
1149         setIntensity(idx, light.intensity);
1150     }
1151
1152     if (getHasAttenuation())
1153     {
1154         setAttenuation(idx, light.attenuation);
1155     }
1156
1157     if (getHasRangeCutOn())
1158     {
1159         setRangeCutOn(idx, light.rangeCutOn);
1160     }
1161
1162     if (getHasRangeCutOff())
1163     {
1164         setRangeCutOff(idx, light.rangeCutOff);
1165     }
1166
1167     if (getHasRangeNearZone())
1168     {
1169         setRangeNearZone(idx, light.rangeNearZone);
1170     }
1171
1172     if (getHasRangeFarZone())
1173     {
1174         setRangeFarZone(idx, light.rangeFarZone);
1175     }
1176
1177     if (getHasSpotExponent())
1178     {
1179         setSpotExponent(idx, light.spotExponent);
1180     }
1181
1182     if (getHasCinemaLight())
1183     {
1184         setInnerSuperEllipsesWidth  (idx, light.innerSuperEllipsesWidth);
1185         setInnerSuperEllipsesHeight (idx, light.innerSuperEllipsesHeight);
1186         setOuterSuperEllipsesWidth  (idx, light.outerSuperEllipsesWidth);
1187         setOuterSuperEllipsesHeight (idx, light.outerSuperEllipsesHeight);
1188         setSuperEllipsesRoundness   (idx, light.superEllipsesRoundness);
1189         setSuperEllipsesTwist       (idx, light.superEllipsesTwist);
1190     }
1191 }
1192
1193 void MultiLightChunk::removeLight(const UInt32 idx)
1194 {
1195     OSG_ASSERT(check_invariant());
1196
1197     if (idx >= _mfPosition.size())
1198         return;
1199
1200     editMField(PositionFieldMask,           _mfPosition);
1201     editMField(DirectionFieldMask,          _mfDirection);
1202     editMField(SpotlightAngleFieldMask,     _mfSpotlightAngle);
1203     editMField(TypeFieldMask,               _mfType);
1204     editMField(EnabledFieldMask,            _mfEnabled);
1205     editMField(BeaconFieldMask,             _mfBeacon);
1206     editMField(BeaconMatrixFieldMask,       _mfBeaconMatrix);
1207
1208     _mfPosition.        erase(idx);
1209     _mfDirection.       erase(idx);
1210     _mfSpotlightAngle.  erase(idx);
1211     _mfType.            erase(idx);
1212     _mfEnabled.         erase(idx);
1213     _mfBeacon.          erase(idx);
1214     _mfBeaconMatrix.    erase(idx);
1215
1216     if (getHasSeparateIntensities())
1217     {
1218         editMField(AmbientIntensityFieldMask,   _mfAmbientIntensity);
1219         editMField(DiffuseIntensityFieldMask,   _mfDiffuseIntensity);
1220         editMField(SpecularIntensityFieldMask,  _mfSpecularIntensity);
1221
1222         _mfAmbientIntensity. erase(idx);
1223         _mfDiffuseIntensity. erase(idx);
1224         _mfSpecularIntensity.erase(idx);
1225     }
1226
1227     if (getHasColor())
1228     {
1229         editMField(ColorFieldMask,          _mfColor);
1230         _mfColor.erase(idx);
1231     }
1232
1233     if (getHasIntensity())
1234     {
1235         editMField(IntensityFieldMask,      _mfIntensity);
1236         _mfIntensity.erase(idx);
1237     }
1238
1239     if (getHasAttenuation())
1240     {
1241         editMField(AttenuationFieldMask,    _mfAttenuation);
1242         _mfAttenuation.erase(idx);
1243     }
1244
1245     if (getHasRangeCutOn())
1246     {
1247         editMField(RangeCutOnFieldMask,     _mfRangeCutOn);
1248         _mfRangeCutOn.erase(idx);
1249     }
1250
1251     if (getHasRangeCutOff())
1252     {
1253         editMField(RangeCutOffFieldMask,    _mfRangeCutOff);
1254         _mfRangeCutOff.erase(idx);
1255     }
1256
1257     if (getHasRangeNearZone())
1258     {
1259         editMField(RangeNearZoneFieldMask,  _mfRangeNearZone);
1260         _mfRangeNearZone.erase(idx);
1261     }
1262
1263     if (getHasRangeFarZone())
1264     {
1265         editMField(RangeFarZoneFieldMask,   _mfRangeFarZone);
1266         _mfRangeFarZone.erase(idx);
1267     }
1268
1269     if (getHasSpotExponent())
1270     {
1271         editMField(SpotExponentFieldMask,   _mfSpotExponent);
1272         _mfSpotExponent.erase(idx);
1273     }
1274
1275     if (getHasCinemaLight())
1276     {
1277         editMField(InnerSuperEllipsesWidthFieldMask,    _mfInnerSuperEllipsesWidth);
1278         editMField(InnerSuperEllipsesHeightFieldMask,   _mfInnerSuperEllipsesHeight);
1279         editMField(OuterSuperEllipsesWidthFieldMask,    _mfOuterSuperEllipsesWidth);
1280         editMField(OuterSuperEllipsesHeightFieldMask,   _mfOuterSuperEllipsesHeight);
1281         editMField(SuperEllipsesRoundnessFieldMask,     _mfSuperEllipsesRoundness);
1282         editMField(SuperEllipsesTwistFieldMask,         _mfSuperEllipsesTwist);
1283
1284         _mfInnerSuperEllipsesWidth. erase(idx);
1285         _mfInnerSuperEllipsesHeight.erase(idx);
1286         _mfOuterSuperEllipsesWidth. erase(idx);
1287         _mfOuterSuperEllipsesHeight.erase(idx);
1288         _mfSuperEllipsesRoundness.  erase(idx);
1289         _mfSuperEllipsesTwist.      erase(idx);
1290     }
1291
1292     OSG_ASSERT(check_invariant());
1293 }
1294
1295 void MultiLightChunk::clearLights()
1296 {
1297     editMField(PositionFieldMask,                   _mfPosition);
1298     editMField(DirectionFieldMask,                  _mfDirection);
1299     editMField(ColorFieldMask,                      _mfColor);
1300     editMField(IntensityFieldMask,                  _mfIntensity);
1301     editMField(AmbientIntensityFieldMask,           _mfAmbientIntensity);
1302     editMField(DiffuseIntensityFieldMask,           _mfDiffuseIntensity);
1303     editMField(SpecularIntensityFieldMask,          _mfSpecularIntensity);
1304     editMField(AttenuationFieldMask,                _mfAttenuation);
1305     editMField(RangeCutOnFieldMask,                 _mfRangeCutOn);
1306     editMField(RangeCutOffFieldMask,                _mfRangeCutOff);
1307     editMField(RangeNearZoneFieldMask,              _mfRangeNearZone);
1308     editMField(RangeFarZoneFieldMask,               _mfRangeFarZone);
1309     editMField(SpotlightAngleFieldMask,             _mfSpotlightAngle);
1310     editMField(SpotExponentFieldMask,               _mfSpotExponent);
1311     editMField(InnerSuperEllipsesWidthFieldMask,    _mfInnerSuperEllipsesWidth);
1312     editMField(InnerSuperEllipsesHeightFieldMask,   _mfInnerSuperEllipsesHeight);
1313     editMField(OuterSuperEllipsesWidthFieldMask,    _mfOuterSuperEllipsesWidth);
1314     editMField(OuterSuperEllipsesHeightFieldMask,   _mfOuterSuperEllipsesHeight);
1315     editMField(SuperEllipsesRoundnessFieldMask,     _mfSuperEllipsesRoundness);
1316     editMField(SuperEllipsesTwistFieldMask,         _mfSuperEllipsesTwist);
1317     editMField(TypeFieldMask,                       _mfType);
1318     editMField(EnabledFieldMask,                    _mfEnabled);
1319     editMField(BeaconFieldMask,                     _mfBeacon);
1320     editMField(BeaconMatrixFieldMask,               _mfBeaconMatrix);
1321
1322     _mfPosition.                clear();
1323     _mfDirection.               clear();
1324     _mfColor.                   clear();
1325     _mfIntensity.               clear();
1326     _mfAmbientIntensity.        clear();
1327     _mfDiffuseIntensity.        clear();
1328     _mfSpecularIntensity.       clear();
1329     _mfAttenuation.             clear();
1330     _mfRangeCutOn.              clear();
1331     _mfRangeCutOff.             clear();
1332     _mfRangeNearZone.           clear();
1333     _mfRangeFarZone.            clear();
1334     _mfSpotlightAngle.          clear();
1335     _mfSpotExponent.            clear();
1336     _mfInnerSuperEllipsesWidth. clear();
1337     _mfInnerSuperEllipsesHeight.clear();
1338     _mfOuterSuperEllipsesWidth. clear();
1339     _mfOuterSuperEllipsesHeight.clear();
1340     _mfSuperEllipsesRoundness.  clear();
1341     _mfSuperEllipsesTwist.      clear();
1342     _mfType.                    clear();
1343     _mfEnabled.                 clear();
1344     _mfBeacon.                  clear();
1345     _mfBeaconMatrix.            clear();
1346 }
1347
1348 void MultiLightChunk::setLayoutType(UInt32 layout)
1349 {
1350     setHasColor                     (false);
1351     setHasIntensity                 (false);
1352     setHasSeparateIntensities       (false);
1353     setHasAttenuation               (false);
1354     setHasRangeCutOn                (false);
1355     setHasRangeCutOff               (false);
1356     setHasRangeNearZone             (false);
1357     setHasRangeFarZone              (false);
1358     setHasCosSpotlightAngle         (true);
1359     setHasSpotlightAngle            (false);
1360     setHasSpotExponent              (false);
1361     setHasCinemaLight               (false);
1362
1363     if (layout & MultiLight::SIMPLE_LAYOUT)
1364     {
1365         setHasColor                 (true);
1366         setHasIntensity             (true);
1367         setHasRangeCutOff           (true);
1368     }
1369
1370     if (layout & MultiLight::RANGE_LAYOUT)
1371     {
1372         setHasRangeCutOn            (true);
1373         setHasRangeCutOff           (true);
1374     }
1375
1376     if (layout & MultiLight::ZONE_LAYOUT)
1377     {
1378         setHasRangeNearZone         (true);
1379         setHasRangeFarZone          (true);
1380     }
1381
1382     if (layout & MultiLight::OPENGL_LAYOUT)
1383     {
1384         setHasSeparateIntensities   (true);
1385         setHasAttenuation           (true);
1386         setHasSpotExponent          (true);
1387     }
1388
1389     if (layout & MultiLight::CINEMA_LAYOUT)
1390     {
1391         setHasCinemaLight           (true);
1392     }
1393
1394     clearLights();
1395 }
1396
1397 std::string MultiLightChunk::getLightProgSnippet() const
1398 {
1399     using namespace std;
1400
1401     stringstream ost;
1402
1403     ost
1404     << endl <<     "//"
1405     << endl <<     "// The supported light types"
1406     << endl <<     "//"
1407     << endl <<     "const int POINT_LIGHT       = " << MultiLight::POINT_LIGHT       << ";"
1408     << endl <<     "const int DIRECTIONAL_LIGHT = " << MultiLight::DIRECTIONAL_LIGHT << ";"
1409     << endl <<     "const int SPOT_LIGHT        = " << MultiLight::SPOT_LIGHT        << ";"
1410     << endl <<     "const int CINEMA_LIGHT      = " << MultiLight::CINEMA_LIGHT      << ";"
1411     << endl <<     ""
1412     << endl <<     "//"
1413     << endl <<     "// The multi light type declaration"
1414     << endl <<     "//"
1415     << endl <<     "struct Light"
1416     << endl <<     "{"
1417     ;
1418     if (getHasWorldToLightSpaceMatrix())
1419     {
1420         ost
1421         << endl << "    mat4  worldToLightSpaceMatrix;"
1422         ;
1423     }
1424
1425     if (getHasLightToWorldSpaceMatrix())
1426     {
1427         ost
1428         << endl << "    mat4  lightToWorldSpaceMatrix;"
1429         ;
1430     }
1431
1432     if (getHasEyeToLightSpaceMatrix())
1433     {
1434         ost
1435         << endl << "    mat4  eyeToLightSpaceMatrix;"
1436         ;
1437     }
1438
1439     if (getHasLightToEyeSpaceMatrix())
1440     {
1441         ost
1442         << endl << "    mat4  lightToEyeSpaceMatrix;"
1443         ;
1444     }
1445
1446     if (getHasLightPerspectiveMatrix())
1447     {
1448         ost
1449         << endl << "    mat4  lightPerspectiveMatrix;"
1450         ;
1451     }
1452
1453     if (getHasInvLightPerspectiveMatrix())
1454     {
1455         ost
1456         << endl << "    mat4  invLightPerspectiveMatrix;"
1457         ;
1458     }
1459     ost
1460     << endl <<     "    vec3  position;                 // in " << (getEyeSpace() ? "eye" : "world") << " space"
1461     << endl <<     "    vec3  direction;                // in " << (getEyeSpace() ? "eye" : "world") << " space"
1462     ;
1463     if (getHasColor())
1464     {
1465         ost
1466         << endl << "    vec3  color;"
1467         ;
1468     }
1469
1470     if (getHasSeparateIntensities())
1471     {
1472         ost
1473         << endl << "    vec3  ambientIntensity;"
1474         << endl << "    vec3  diffuseIntensity;"
1475         << endl << "    vec3  specularIntensity;"
1476         ;
1477     }
1478
1479     if (getHasIntensity())
1480     {
1481         ost
1482         << endl << "    float intensity;"
1483         ;
1484     }
1485
1486     if (getHasAttenuation())
1487     {
1488         ost
1489         << endl << "    float constantAttenuation;"
1490         << endl << "    float linearAttenuation;"
1491         << endl << "    float quadraticAttenuation;"
1492         ;
1493     }
1494
1495     if (getHasRangeCutOn())
1496     {
1497         ost
1498         << endl << "    float rangeCutOn;"
1499         ;
1500     }
1501
1502     if (getHasRangeCutOff())
1503     {
1504         ost
1505         << endl << "    float rangeCutOff;"
1506         ;
1507     }
1508
1509     if (getHasRangeNearZone())
1510     {
1511         ost
1512         << endl << "    float rangeNearZone;"
1513         ;
1514     }
1515
1516     if (getHasRangeFarZone())
1517     {
1518         ost
1519         << endl << "    float rangeFarZone;"
1520         ;
1521     }
1522
1523     if (getHasCosSpotlightAngle() || (!getHasCosSpotlightAngle() && !getHasSpotlightAngle()))
1524     {
1525         ost
1526         << endl << "    float cosSpotlightAngle;"
1527         ;
1528     }
1529
1530     if (getHasSpotlightAngle())
1531     {
1532         ost
1533         << endl << "    float spotlightAngle;           // in radians"
1534         ;
1535     }
1536
1537     if (getHasSpotExponent())
1538     {
1539         ost
1540         << endl << "    float spotExponent;"
1541         ;
1542     }
1543
1544     if (getHasCinemaLight())
1545     {
1546         ost
1547         << endl << "    float innerSuperEllipsesWidth;  // a"
1548         << endl << "    float innerSuperEllipsesHeight; // b"
1549         << endl << "    float outerSuperEllipsesWidth;  // A"
1550         << endl << "    float outerSuperEllipsesHeight; // B"
1551         << endl << "    float superEllipsesRoundness;   // r"
1552         << endl << "    float superEllipsesTwist;       // // twist angle theta in radians"
1553         ;
1554     }
1555     ost
1556     << endl <<     "    int   type;                     // specific type of light: POINT_LIGHT, DIRECTIONAL_LIGHT, SPOT_LIGHT or CINEMA_LIGHT"
1557     << endl <<     "    bool  enabled;                  // on/off state of light"
1558     << endl <<     "};"
1559     << endl <<     ""
1560     << endl <<     "layout (std430) buffer " << getLightBlockName()
1561     << endl <<     "{"
1562     << endl <<     "    Light light[];"
1563     << endl <<     "} " << getLightVariableName() << ";"
1564     << endl
1565     ;
1566
1567     return ost.str();
1568 }
1569
1570 OSG_END_NAMESPACE