Source/System/FileIO/Collada/OSGColladaLight.cpp

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *                Copyright (C) 2010 by the OpenSG Forum                     *
   6  *                                                                           *
   7  *                            www.opensg.org                                 *
   8  *                                                                           *
   9  *   contact: dirk@opensg.org, gerrit.voss@vossg.org, jbehr@zgdv.de          *
  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 #if __GNUC__ >= 4 || __GNUC_MINOR__ >=3
  40 #pragma GCC diagnostic ignored "-Wold-style-cast"
  41 #endif
  42
  43 #include "OSGColladaLight.h"
  44
  45 #ifdef OSG_WITH_COLLADA
  46
  47 #include "OSGColladaLog.h"
  48 #include "OSGColladaInstanceLight.h"
  49
  50 #include "OSGDirectionalLight.h"
  51 #include "OSGPointLight.h"
  52 #include "OSGSpotLight.h"
  53 #include "OSGChunkOverrideGroup.h"
  54 #include "OSGNameAttachment.h"
  55
  56 OSG_BEGIN_NAMESPACE
  57
  58 // ===========================================================================
  59
  60 ColladaInstInfoTransitPtr
  61 ColladaLight::ColladaLightInstInfo::create(
  62     ColladaElement *colInstParent, ColladaInstanceLight *colInst,
  63     Node           *beaconN                                      )
  64 {
  65     return ColladaInstInfoTransitPtr(
  66         new ColladaLightInstInfo(colInstParent, colInst, beaconN));
  67 }
  68
  69 void
  70 ColladaLight::ColladaLightInstInfo::process(void)
  71 {
  72     Node *lightInstN = dynamic_cast<Node *>(
  73         getColInst()->getTargetElem()->createInstance(this));
  74
  75     if(lightInstN == NULL)
  76         return;
  77
  78     Node *rootN = getColInst()->getGlobal()->getRoot();
  79
  80     while(rootN->getNChildren() > 0)
  81     {
  82         lightInstN->addChild(rootN->getChild(0));
  83     }
  84
  85     rootN->addChild(lightInstN);
  86 }
  87
  88 Node *
  89 ColladaLight::ColladaLightInstInfo::getBeacon(void) const
  90 {
  91     return _beacon;
  92 }
  93
  94 ColladaLight::ColladaLightInstInfo::ColladaLightInstInfo(
  95     ColladaElement *colInstParent, ColladaInstanceLight *colInst,
  96     Node           *beaconN                                      )
  97
  98     : Inherited(colInstParent, colInst)
  99     , _beacon  (beaconN               )
 100 {
 101 }
 102
 103 ColladaLight::ColladaLightInstInfo::~ColladaLightInstInfo(void)
 104 {
 105 }
 106
 107 // ===========================================================================
 108
 109 // Ambient light sources are a bit tricky to handle. First all ambient sources
 110 // in the scene have to be accumulated and then an appropriate LightModelChunk
 111 // must be inserted at the top of the scene (using a ChunkOverrideGroup).
 112 // The first part is done by ColladaLight::createInstance(), which will also
 113 // place an instance of ColladaLightAmbientInstInfo into the instance queue.
 114 // That instance will then cause the insertion of the LightModelChunk.
 115
 116 ColladaInstInfoTransitPtr
 117 ColladaLight::ColladaLightAmbientInstInfo::create(
 118     ColladaElement *colInstParent, ColladaInstanceLight *colInst)
 119 {
 120     return ColladaInstInfoTransitPtr(
 121         new ColladaLightAmbientInstInfo(colInstParent, colInst));
 122 }
 123
 124 void
 125 ColladaLight::ColladaLightAmbientInstInfo::process(void)
 126 {
 127     dynamic_cast<ColladaLight *>(
 128         getColInst()->getTargetElem())->createAmbientLight(this);
 129 }
 130
 131 ColladaLight::ColladaLightAmbientInstInfo::ColladaLightAmbientInstInfo(
 132     ColladaElement *colInstParent, ColladaInstanceLight *colInst)
 133
 134     : Inherited(colInstParent, colInst)
 135 {
 136 }
 137
 138 ColladaLight::ColladaLightAmbientInstInfo::~ColladaLightAmbientInstInfo(void)
 139 {
 140 }
 141
 142 // ===========================================================================
 143
 144 ColladaLight::LightLoaderStateTransitPtr
 145 ColladaLight::LightLoaderState::create(void)
 146 {
 147     return LightLoaderStateTransitPtr(new LightLoaderState());
 148 }
 149
 150 LightModelChunk *
 151 ColladaLight::LightLoaderState::getLightModelChunk(void) const
 152 {
 153     return _lightModel;
 154 }
 155
 156 void
 157 ColladaLight::LightLoaderState::setLightModelChunk(LightModelChunk *chunk)
 158 {
 159     _lightModel = chunk;
 160 }
 161
 162 ColladaLight::LightLoaderState::LightLoaderState(void)
 163     : Inherited  ()
 164     , _lightModel()
 165 {
 166 }
 167
 168 ColladaLight::LightLoaderState::~LightLoaderState(void)
 169 {
 170 }
 171
 172 // ===========================================================================
 173
 174 ColladaElementRegistrationHelper ColladaLight::_regHelper(
 175     &ColladaLight::create, "light");
 176 const std::string                ColladaLight::_loaderStateName("ColladaLight");
 177
 178
 179 ColladaElementTransitPtr
 180 ColladaLight::create(daeElement *elem, ColladaGlobal *global)
 181 {
 182     if(global->getLoaderState(_loaderStateName) == NULL)
 183     {
 184         LightLoaderStateRefPtr state = LightLoaderState::create();
 185
 186         global->addLoaderState(_loaderStateName, state);
 187     }
 188
 189     return ColladaElementTransitPtr(new ColladaLight(elem, global));
 190 }
 191
 192 void
 193 ColladaLight::read(ColladaElement *colElemParent)
 194 {
 195     domLightRef light = getDOMElementAs<domLight>();
 196
 197     OSG_COLLADA_LOG(("ColladaLight::read id [%s]\n", light->getId()));
 198 }
 199
 200 Node *
 201 ColladaLight::createInstance(ColladaInstInfo *colInstInfo)
 202 {
 203     domLightRef light = getDOMElementAs<domLight>();
 204
 205     OSG_COLLADA_LOG(("ColladaLight::createInstance id [%s]\n",
 206                      light->getId()));
 207
 208     NodeUnrecPtr                      retVal        = NULL;
 209     ColladaLightInstInfo             *lightInstInfo =
 210         dynamic_cast<ColladaLightInstInfo *>(colInstInfo);
 211     domLight::domTechnique_commonRef  techComm      =
 212         light->getTechnique_common();
 213
 214     const domTechnique_Array &techs = light->getTechnique_array();
 215
 216     for(UInt32 i = 0; i < techs.getCount(); ++i)
 217     {
 218         retVal = createInstanceTechnique(lightInstInfo, techs[i]);
 219
 220         // stop as soon as something is created
 221         if(retVal != NULL)
 222             return retVal;
 223     }
 224
 225     // if we get here no technique was choosen so we evaluate
 226     // <technique_common>
 227     retVal = createInstanceCommon(lightInstInfo, techComm);
 228
 229     return retVal;
 230 }
 231
 232 void
 233 ColladaLight::createAmbientLight(ColladaLightAmbientInstInfo *colInstInfo)
 234 {
 235     OSG_COLLADA_LOG(("ColladaLight::createAmbientLight\n"));
 236
 237     LightLoaderState *state =
 238         getGlobal()->getLoaderStateAs<LightLoaderState>(_loaderStateName);
 239     OSG_ASSERT(state != NULL);
 240
 241     ChunkOverrideGroupUnrecPtr coGroup  = ChunkOverrideGroup::create();
 242     NodeUnrecPtr               coGroupN = makeNodeFor(coGroup);
 243
 244     coGroup->addChunk(state->getLightModelChunk());
 245
 246     Node *rootN = getGlobal()->getRoot();
 247
 248     while(rootN->getNChildren() > 0)
 249     {
 250         coGroupN->addChild(rootN->getChild(0));
 251     }
 252
 253     if(getGlobal()->getOptions()->getCreateNameAttachments() == true)
 254     {
 255         setName(coGroupN, "OpenSG_AmbientLight");
 256     }
 257
 258     rootN->addChild(coGroupN);
 259 }
 260
 261 ColladaLight::ColladaLight(daeElement *elem, ColladaGlobal *global)
 262     : Inherited(elem, global)
 263 {
 264 }
 265
 266 ColladaLight::~ColladaLight(void)
 267 {
 268 }
 269
 270 Node *
 271 ColladaLight::createInstanceTechnique(
 272     ColladaLightInstInfo *colInstInfo, domTechnique *tech)
 273 {
 274     domLightRef light = getDOMElementAs<domLight>();
 275
 276     OSG_COLLADA_LOG(("ColladaLight::createInstanceTechnique id [%s] "
 277                      "profile [%s]\n", light->getId(), tech->getProfile()));
 278
 279     return NULL;
 280 }
 281
 282 Node *
 283 ColladaLight::createInstanceCommon(
 284     ColladaLightInstInfo *colInstInfo, domLight::domTechnique_common *tech)
 285 {
 286     domLightRef light = getDOMElementAs<domLight>();
 287
 288     OSG_COLLADA_LOG(("ColladaLight::createInstanceCommon id [%s]\n",
 289                      light->getId()));
 290
 291     NodeUnrecPtr                                     lightN      = NULL;
 292
 293     domLight::domTechnique_common::domAmbientRef     ambient     =
 294         tech->getAmbient();
 295     domLight::domTechnique_common::domDirectionalRef directional =
 296         tech->getDirectional();
 297     domLight::domTechnique_common::domPointRef       point       =
 298         tech->getPoint();
 299     domLight::domTechnique_common::domSpotRef        spot        =
 300         tech->getSpot();
 301
 302     if(ambient != NULL)
 303     {
 304         Color4f lightColor(ambient->getColor()->getValue()[0],
 305                            ambient->getColor()->getValue()[1],
 306                            ambient->getColor()->getValue()[2], 1.f);
 307
 308         LightLoaderState *state =
 309             getGlobal()->getLoaderStateAs<LightLoaderState>(_loaderStateName);
 310         OSG_ASSERT(state != NULL);
 311
 312         LightModelChunkUnrecPtr lmChunk = state->getLightModelChunk();
 313
 314         if(state->getLightModelChunk() == NULL)
 315         {
 316             lmChunk = LightModelChunk::create();
 317             lmChunk->setAmbient(Color4f(0.f, 0.f, 0.f, 1.f));
 318
 319             state->setLightModelChunk(lmChunk);
 320
 321             // only place one instance into the inst queue, it will
 322             // add the LightModelChunk with the accumulated ambient
 323             // for the scene
 324             ColladaInstInfoRefPtr ambientInstInfo =
 325                 ColladaLightAmbientInstInfo::create(
 326                     colInstInfo->getColInstParent(),
 327                     dynamic_cast<ColladaInstanceLight *>(
 328                         colInstInfo->getColInst())        );
 329
 330             getGlobal()->editInstQueue().push_back(ambientInstInfo);
 331         }
 332
 333         lightColor[0] =
 334             osgClamp(0.f, lmChunk->getAmbient()[0] + lightColor[0], 1.f);
 335         lightColor[1] =
 336             osgClamp(0.f, lmChunk->getAmbient()[1] + lightColor[1], 1.f);
 337         lightColor[2] =
 338             osgClamp(0.f, lmChunk->getAmbient()[2] + lightColor[0], 1.f);
 339
 340         lmChunk->setAmbient(lightColor);
 341     }
 342
 343     if(directional != NULL)
 344     {
 345         Color4f lightColor(directional->getColor()->getValue()[0],
 346                            directional->getColor()->getValue()[1],
 347                            directional->getColor()->getValue()[2], 1.f);
 348
 349         DirectionalLightUnrecPtr dl = DirectionalLight::create();
 350         lightN                      = makeNodeFor(dl);
 351
 352         dl->setBeacon  (colInstInfo->getBeacon());
 353         dl->setDiffuse (lightColor              );
 354         dl->setSpecular(lightColor              );
 355     }
 356
 357     if(point != NULL)
 358     {
 359         Color4f lightColor(point->getColor()->getValue()[0],
 360                            point->getColor()->getValue()[1],
 361                            point->getColor()->getValue()[2], 1.f);
 362
 363         PointLightUnrecPtr pl = PointLight::create();
 364         lightN                = makeNodeFor(pl);
 365
 366         Real32 constAtt = 1.f;
 367         Real32 linAtt   = 0.f;
 368         Real32 quadAtt  = 0.f;
 369
 370         if(point->getConstant_attenuation() != NULL)
 371             constAtt = point->getConstant_attenuation()->getValue();
 372
 373         if(point->getLinear_attenuation() != NULL)
 374             linAtt   = point->getLinear_attenuation()->getValue();
 375
 376         if(point->getQuadratic_attenuation() != NULL)
 377             quadAtt  = point->getQuadratic_attenuation()->getValue();
 378
 379         pl->setBeacon              (colInstInfo->getBeacon());
 380         pl->setDiffuse             (lightColor              );
 381         pl->setSpecular            (lightColor              );
 382         pl->setConstantAttenuation (constAtt                );
 383         pl->setLinearAttenuation   (linAtt                  );
 384         pl->setQuadraticAttenuation(quadAtt                 );
 385     }
 386
 387     if(spot != NULL)
 388     {
 389         Color4f lightColor(spot->getColor()->getValue()[0],
 390                            spot->getColor()->getValue()[1],
 391                            spot->getColor()->getValue()[2], 1.f);
 392
 393         SpotLightUnrecPtr sl = SpotLight::create();
 394         lightN               = makeNodeFor(sl);
 395
 396         Real32 constAtt =   1.f;
 397         Real32 linAtt   =   0.f;
 398         Real32 quadAtt  =   0.f;
 399         Real32 cutOff   = 180.f;
 400         Real32 exponent =   0.f;
 401
 402         if(spot->getConstant_attenuation() != NULL)
 403             constAtt = spot->getConstant_attenuation()->getValue();
 404
 405         if(spot->getLinear_attenuation() != NULL)
 406             linAtt   = spot->getLinear_attenuation()->getValue();
 407
 408         if(spot->getQuadratic_attenuation() != NULL)
 409             quadAtt  = spot->getQuadratic_attenuation()->getValue();
 410
 411         if(spot->getFalloff_angle() != NULL)
 412             cutOff   = spot->getFalloff_angle()->getValue();
 413
 414         if(spot->getFalloff_exponent() != NULL)
 415             exponent = spot->getFalloff_exponent()->getValue();
 416
 417         sl->setBeacon              (colInstInfo->getBeacon());
 418         sl->setDiffuse             (lightColor              );
 419         sl->setSpecular            (lightColor              );
 420         sl->setConstantAttenuation (constAtt                );
 421         sl->setLinearAttenuation   (linAtt                  );
 422         sl->setQuadraticAttenuation(quadAtt                 );
 423         sl->setSpotCutOff          (osgDegree2Rad(cutOff)   );
 424         sl->setSpotExponent        (exponent                );
 425     }
 426
 427     if(lightN != NULL)
 428     {
 429         editInstStore().push_back(lightN);
 430
 431         if(getGlobal()->getOptions()->getCreateNameAttachments() == true &&
 432            light->getName()                                      != NULL   )
 433         {
 434             setName(lightN, light->getName());
 435         }
 436
 437         getGlobal()->getStatCollector()->getElem(
 438             ColladaGlobal::statNLightCreated)->inc();
 439     }
 440
 441     return lightN;
 442 }
 443
 444 OSG_END_NAMESPACE
 445
 446 #endif // OSG_WITH_COLLADA