Source/System/FileIO/Collada/OSGColladaEffect.cpp

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *                Copyright (C) 2009 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 "OSGColladaEffect.h"
  44
  45 #if defined(OSG_WITH_COLLADA) || defined(OSG_DO_DOC)
  46
  47 #include "OSGColladaLog.h"
  48 #include "OSGColladaGlobal.h"
  49 #include "OSGColladaImage.h"
  50 #include "OSGColladaInstanceEffect.h"
  51 #include "OSGColladaMaterial.h"
  52 #include "OSGColladaSampler2D.h"
  53
  54 #include "OSGGeometry.h"
  55 #include "OSGChunkMaterial.h"
  56 #include "OSGBlendChunk.h"
  57 #include "OSGDepthChunk.h"
  58 #include "OSGMaterialChunk.h"
  59 #include "OSGTextureEnvChunk.h"
  60
  61 #include "OSGColladaDomProfileHandler.h"
  62 #include "OSGColladaExtraHandler.h"
  63 #include "OSGColladaHandlerFactory.h"
  64
  65 #include <dom/domEffect.h>
  66 #include <dom/domInstance_effect.h>
  67 #include <dom/domProfile_COMMON.h>
  68 #include <dom/domProfile_GLSL.h>
  69 #include <dom/domProfile_CG.h>
  70
  71 // It is not clear what is the best way to handle <transparent>/<texture>, so
  72 // OSG_COLLADA_TRANSPARENT_MODE allows choosing between implementations
  73 // to experiment. See below for what the modes do.
  74
  75 #define OSG_COLLADA_TRANSPARENT_MODE 1
  76 // #define OSG_COLLADA_TRANSPARENT_MODE 2
  77
  78 OSG_BEGIN_NAMESPACE
  79
  80 ColladaInstInfoTransitPtr ColladaEffect::ColladaEffectInstInfo::create(
  81     ColladaMaterial       *colInstParent,
  82     ColladaInstanceEffect *colInst)
  83 {
  84     return ColladaInstInfoTransitPtr(
  85         new ColladaEffectInstInfo(colInstParent, colInst));
  86 }
  87
  88 void ColladaEffect::ColladaEffectInstInfo::process(void)
  89 {
  90     SFATAL << "ColladaEffectInstInfo::process called!" << std::endl;
  91 }
  92
  93 ColladaEffect::ColladaEffectInstInfo::ColladaEffectInstInfo(
  94     ColladaMaterial       *colInstParent,
  95     ColladaInstanceEffect *colInst      ) :
  96
  97     Inherited(colInstParent,
  98               colInst      )
  99 {
 100 }
 101
 102 ColladaEffect::ColladaEffectInstInfo::~ColladaEffectInstInfo(void)
 103 {
 104 }
 105
 106 // ===========================================================================
 107
 108 ColladaElementRegistrationHelper ColladaEffect::_regHelper(
 109     &ColladaEffect::create,
 110      "effect");
 111
 112
 113 ColladaElementTransitPtr ColladaEffect::create(daeElement    *elem,
 114                                                ColladaGlobal *global)
 115 {
 116     return ColladaElementTransitPtr(new ColladaEffect(elem, global));
 117 }
 118
 119 void ColladaEffect::read(ColladaElement *colElemParent)
 120 {
 121     OSG_COLLADA_LOG(("ColladaEffect::read\n"));
 122
 123           domEffectRef    effect = getDOMElementAs<domEffect>();
 124     const domImage_Array &images = effect->getImage_array();
 125
 126     readImageArray(images);
 127
 128     const domFx_newparam_common_Array &newParams = effect->getNewparam_array();
 129
 130     for(UInt32 i = 0; i < newParams.getCount(); ++i)
 131     {
 132         if(newParams[i]->getFx_basic_type_common() == NULL)
 133         {
 134             SWARNING << "ColladaEffect::read: <newparam> ["
 135                      << newParams[i]->getSid()
 136                      << "] without contents encountered, ignored."
 137                      << std::endl;
 138             continue;
 139         }
 140
 141         // must read surface params before sampler params, because
 142         // a samplers <source> can refer to a surface
 143         domFx_surface_commonRef paramSurface =
 144             newParams[i]->getFx_basic_type_common()->getSurface();
 145
 146         if(paramSurface != NULL)
 147         {
 148             ParamSurface param;
 149
 150             param.surface    = paramSurface;
 151             param.colSurface = dynamic_pointer_cast<ColladaSurface>(
 152                 ColladaElementFactory::the()->create(
 153                     paramSurface, getGlobal()));
 154
 155             param.colSurface->read(this);
 156
 157             _surfaceParams[newParams[i]->getSid()] = param;
 158             continue;
 159         }
 160
 161         domFx_sampler2D_commonRef paramSampler2D =
 162             newParams[i]->getFx_basic_type_common()->getSampler2D();
 163
 164         if(paramSampler2D != NULL)
 165         {
 166             ParamSampler2D param;
 167
 168             param.sampler2D    = paramSampler2D;
 169             param.colSampler2D = dynamic_pointer_cast<ColladaSampler2D>(
 170                 ColladaElementFactory::the()->create(
 171                     paramSampler2D, getGlobal()));
 172
 173             param.colSampler2D->setEffect(this);
 174             param.colSampler2D->read     (this);
 175
 176             _sampler2DParams[newParams[i]->getSid()] = param;
 177             continue;
 178         }
 179     }
 180
 181     const domFx_profile_abstract_Array &profiles =
 182         effect->getFx_profile_abstract_array();
 183
 184     ColladaDomProfileHandlerRefPtr pDomProfHandler;
 185
 186     for(UInt32 i = 0; i < profiles.getCount(); ++i)
 187     {
 188         const domExtra_Array *pProfileExtras = NULL;
 189
 190         if(domProfile_COMMON::ID() == profiles[i]->typeID())
 191         {
 192             domProfile_COMMON *pProfile =
 193                 daeSafeCast<domProfile_COMMON>(profiles[i]);
 194
 195             if(pProfile != NULL)
 196             {
 197                 readProfileCommon(pProfile);
 198
 199                 pProfileExtras = &(pProfile->getExtra_array());
 200             }
 201         }
 202         else if(domProfile_GLSL::ID() == profiles[i]->typeID())
 203         {
 204             pDomProfHandler =
 205                 ColladaHandlerFactory::the()->createDomProfileHandler(
 206                     domProfile_GLSL::ID());
 207
 208             domProfile_GLSL *pProfile =
 209                 daeSafeCast<domProfile_GLSL>(profiles[i]);
 210
 211             if(pProfile != NULL)
 212             {
 213                 if(pDomProfHandler != NULL)
 214                 {
 215                     pDomProfHandler->readProfile(pProfile);
 216                 }
 217                 else
 218                 {
 219                     readProfileGLSL(pProfile);
 220                 }
 221
 222                 pProfileExtras = &(pProfile->getExtra_array());
 223             }
 224         }
 225         else if(domProfile_CG::ID() == profiles[i]->typeID())
 226         {
 227             pDomProfHandler =
 228                 ColladaHandlerFactory::the()->createDomProfileHandler(
 229                     domProfile_CG::ID());
 230
 231             domProfile_CG *pProfile = daeSafeCast<domProfile_CG>(profiles[i]);
 232
 233             if(pProfile != NULL)
 234             {
 235                 if(pDomProfHandler != NULL)
 236                 {
 237                     pDomProfHandler->readProfile(pProfile);
 238                 }
 239                 else
 240                 {
 241                     readProfileCG(pProfile);
 242                 }
 243
 244                 pProfileExtras = &(pProfile->getExtra_array());
 245             }
 246         }
 247
 248         if(_extraHandlers.size() == 0)
 249             continue;
 250
 251         for(UInt32 j = 0; j < pProfileExtras->getCount(); ++j)
 252         {
 253             ExtraHandlerStoreIt      ehIt  = _extraHandlers.begin();
 254             ExtraHandlerStoreConstIt ehEnd = _extraHandlers.end  ();
 255
 256             for(; ehIt != ehEnd; ++ehIt)
 257             {
 258                 (*ehIt)->readProfileExtraElements(this, (*pProfileExtras)[j]);
 259             }
 260         }
 261     }
 262 }
 263
 264 Material *ColladaEffect::createInstance(ColladaInstInfo *colInstInfo)
 265 {
 266     OSG_COLLADA_LOG(("ColladaEffect::createInstance\n"));
 267
 268     MaterialUnrecPtr            retVal        = NULL;
 269     domEffectRef                effect        = getDOMElementAs<domEffect>();
 270
 271     ColladaInstanceEffectRefPtr colInstEffect =
 272         dynamic_cast<ColladaInstanceEffect *>(colInstInfo->getColInst());
 273
 274     domInstance_effectRef       instEffect    =
 275         colInstInfo->getColInst()->getDOMElementAs<domInstance_effect>();
 276
 277     const domFx_profile_abstract_Array &profiles =
 278         effect->getFx_profile_abstract_array();
 279
 280     ColladaDomProfileHandlerRefPtr pDomProfHandler;
 281
 282     for(UInt32 i = 0; i < profiles.getCount(); ++i)
 283     {
 284         const domExtra_Array *pProfileExtras = NULL;
 285
 286         if(domProfile_COMMON::ID() == profiles[i]->typeID())
 287         {
 288             domProfile_COMMON *pProfile =
 289                 daeSafeCast<domProfile_COMMON>(profiles[i]);
 290
 291             if(pProfile != NULL)
 292             {
 293                 retVal = createInstanceProfileCommon(pProfile,
 294                                                      effect,
 295                                                      instEffect);
 296
 297                 pProfileExtras = &(pProfile->getExtra_array());
 298             }
 299         }
 300         else if(domProfile_GLSL::ID() == profiles[i]->typeID())
 301         {
 302             pDomProfHandler =
 303                 ColladaHandlerFactory::the()->createDomProfileHandler(
 304                     domProfile_GLSL::ID());
 305
 306             domProfile_GLSL *pProfile =
 307                 daeSafeCast<domProfile_GLSL>(profiles[i]);
 308
 309             if(pProfile != NULL)
 310             {
 311                 if(pDomProfHandler != NULL)
 312                 {
 313                     pDomProfHandler->createInstProfile(pProfile,
 314                                                        effect,
 315                                                        instEffect );
 316                 }
 317                 else
 318                 {
 319                     retVal = createInstanceProfileGLSL(pProfile,
 320                                                        effect,
 321                                                        instEffect);
 322                 }
 323
 324                 pProfileExtras = &(pProfile->getExtra_array());
 325             }
 326         }
 327         else if(domProfile_CG::ID() == profiles[i]->typeID())
 328         {
 329             pDomProfHandler =
 330                 ColladaHandlerFactory::the()->createDomProfileHandler(
 331                     domProfile_CG::ID());
 332
 333             domProfile_CG *pProfile = daeSafeCast<domProfile_CG>(profiles[i]);
 334
 335             if(pProfile != NULL)
 336             {
 337                 if(pDomProfHandler != NULL)
 338                 {
 339                     pDomProfHandler->createInstProfile(pProfile,
 340                                                        effect,
 341                                                        instEffect );
 342                 }
 343                 else
 344                 {
 345                     retVal = createInstanceProfileCG(pProfile,
 346                                                      effect,
 347                                                      instEffect);
 348                 }
 349
 350                 pProfileExtras = &(pProfile->getExtra_array());
 351             }
 352         }
 353
 354         if(_extraHandlers.size() == 0 || pProfileExtras->getCount() == 0)
 355             continue;
 356
 357         ExtraHandlerStoreIt      ehIt  = _extraHandlers.begin();
 358         ExtraHandlerStoreConstIt ehEnd = _extraHandlers.end  ();
 359
 360         for(; ehIt != ehEnd; ++ehIt)
 361         {
 362             (*ehIt)->instProfileExtraElements(this,
 363                                               retVal);
 364         }
 365     }
 366
 367     editInstStore().push_back(retVal);
 368
 369     return retVal;
 370 }
 371
 372 /*! Return parameter of the effect (\c &lt;newparam&gt; tags) with the given
 373  *  \a name.
 374  */
 375
 376 daeElement *ColladaEffect::findDOMParam(const std::string &name) const
 377 {
 378     ParamSampler2DMapConstIt sampler2DIt = _sampler2DParams.find(name);
 379
 380     if(sampler2DIt != _sampler2DParams.end())
 381     {
 382         return sampler2DIt->second.sampler2D;
 383     }
 384
 385     ParamSurfaceMapConstIt surfaceIt = _surfaceParams.find(name);
 386
 387     if(surfaceIt != _surfaceParams.end())
 388     {
 389         return surfaceIt->second.surface;
 390     }
 391
 392     return NULL;
 393 }
 394
 395 /*! Return the loader element for the parameter of the effect (\c
 396     &lt;newparam&gt; tags) with the given \a name.
 397  */
 398
 399 ColladaElement *ColladaEffect::findParam(const std::string &name) const
 400 {
 401     ParamSampler2DMapConstIt sampler2DIt = _sampler2DParams.find(name);
 402
 403     if(sampler2DIt != _sampler2DParams.end())
 404     {
 405         return sampler2DIt->second.colSampler2D;
 406     }
 407
 408     ParamSurfaceMapConstIt surfaceIt = _surfaceParams.find(name);
 409
 410     if(surfaceIt != _surfaceParams.end())
 411     {
 412         return surfaceIt->second.colSurface;
 413     }
 414
 415     return NULL;
 416 }
 417
 418 void ColladaEffect::setTexture(
 419         TextureTarget                                eTarget,
 420         ColladaTexture                              *pColTexture,
 421         domCommon_color_or_texture_type::domTexture *pDomTexture)
 422 {
 423     ParamTexture oTexParam;
 424
 425     oTexParam.colTexture = pColTexture;
 426     oTexParam.texture    = pDomTexture;
 427
 428     _textures[eTarget]   = oTexParam;
 429 }
 430
 431 ColladaEffect::ColladaEffect(daeElement    *elem,
 432                              ColladaGlobal *global) :
 433
 434      Inherited      (elem,
 435                      global),
 436     _sampler2DParams(      ),
 437     _surfaceParams  (      ),
 438     _textures       (      ),
 439     _extraHandlers  (      )
 440 {
 441     _textures.resize(ColladaEffect::LastTexture);
 442
 443     ColladaHandlerFactory::the()->createExtraHandlers(_extraHandlers);
 444 }
 445
 446 ColladaEffect::~ColladaEffect(void)
 447 {
 448 }
 449
 450 void ColladaEffect::readImageArray(const domImage_Array &images)
 451 {
 452     for(UInt32 i = 0; i < images.getCount(); ++i)
 453     {
 454         ColladaImageRefPtr colImg = getUserDataAs<ColladaImage>(images[i]);
 455
 456         if(colImg == NULL)
 457         {
 458             colImg = dynamic_pointer_cast<ColladaImage>(
 459                 ColladaElementFactory::the()->create(
 460                     images[i],
 461                     getGlobal()));
 462
 463             colImg->read(this);
 464         }
 465     }
 466 }
 467
 468 void ColladaEffect::readNewParams(const CommonParamArray &newParams)
 469 {
 470     for(UInt32 i = 0; i < newParams.getCount(); ++i)
 471     {
 472         // must read surface params before sampler params, because their
 473         // <source> element can refer to a surface
 474
 475         domFx_surface_commonRef paramSurface =
 476             newParams[i]->getSurface();
 477
 478         if(paramSurface != NULL)
 479         {
 480             ParamSurface param;
 481
 482             param.surface    = paramSurface;
 483             param.colSurface = dynamic_pointer_cast<ColladaSurface>(
 484                 ColladaElementFactory::the()->create(
 485                     paramSurface, getGlobal()));
 486
 487             param.colSurface->read(this);
 488
 489             _surfaceParams[newParams[i]->getSid()] = param;
 490             continue;
 491         }
 492
 493         domFx_sampler2D_commonRef paramSampler2D =
 494             newParams[i]->getSampler2D();
 495
 496         if(paramSampler2D != NULL)
 497         {
 498             ParamSampler2D param;
 499
 500             param.sampler2D    = paramSampler2D;
 501             param.colSampler2D = dynamic_pointer_cast<ColladaSampler2D>(
 502                 ColladaElementFactory::the()->create(
 503                     paramSampler2D, getGlobal()));
 504
 505             param.colSampler2D->setEffect(this);
 506             param.colSampler2D->read     (this);
 507
 508             _sampler2DParams[newParams[i]->getSid()] = param;
 509             continue;
 510         }
 511
 512         // param is unhandled if we get to here
 513         SWARNING << "ColladaEffect::readProfileCommon: Unhandled <newparam> ["
 514                  << newParams[i]->getSid() << "]."
 515                  << std::endl;
 516     }
 517
 518 }
 519
 520 /*! Fills internal data structures for \c &lt;profile_COMMON&gt;.
 521     This mainly collects relevant parameters so they can be looked up
 522     efficiently when creating an instance of this effect.
 523  */
 524
 525 void ColladaEffect::readProfileCommon(domProfile_COMMON *prof)
 526 {
 527     if(prof == NULL)
 528     {
 529         SWARNING << "ColladaEffect::readProfileCommon: No DOM element or "
 530                  << "incorrect type." << std::endl;
 531         return;
 532     }
 533
 534     readImageArray(prof->getImage_array   ());
 535     readNewParams (prof->getNewparam_array());
 536
 537     domProfile_COMMON::domTechniqueRef tech = prof->getTechnique();
 538
 539     readNewParams (tech->getNewparam_array());
 540     readImageArray(tech->getImage_array   ());
 541
 542
 543     if(tech->getConstant() != NULL)
 544     {
 545         OSG_COLLADA_LOG(("ColladaEffect::readProfileCommon: "
 546                          "using <constant> shader\n"));
 547
 548         domProfile_COMMON::domTechnique::domConstantRef constant =
 549             tech->getConstant();
 550
 551
 552         readTextureParams((constant->getEmission() != NULL) ?
 553                               constant->getEmission()->getTexture() : NULL,
 554                           EmissionTexture);
 555
 556         readTextureParams((constant->getTransparent() != NULL) ?
 557                               constant->getTransparent()->getTexture() : NULL,
 558                           TransparentTexture);
 559     }
 560     else if(tech->getLambert() != NULL)
 561     {
 562         OSG_COLLADA_LOG(("ColladaEffect::readProfileCommon: "
 563                          "using <lambert> shader\n"));
 564
 565         domProfile_COMMON::domTechnique::domLambertRef lambert =
 566             tech->getLambert();
 567
 568         readTextureParams((lambert->getEmission() != NULL) ?
 569                               lambert->getEmission()->getTexture() : NULL,
 570                           EmissionTexture);
 571
 572         readTextureParams((lambert->getAmbient() != NULL) ?
 573                               lambert->getAmbient() ->getTexture() : NULL,
 574                           AmbientTexture);
 575
 576         readTextureParams((lambert->getDiffuse() != NULL) ?
 577                               lambert->getDiffuse() ->getTexture() : NULL,
 578                           DiffuseTexture);
 579
 580         readTextureParams((lambert->getTransparent() != NULL) ?
 581                               lambert->getTransparent()->getTexture() : NULL,
 582                           TransparentTexture);
 583     }
 584     else if(tech->getPhong() != NULL)
 585     {
 586         OSG_COLLADA_LOG(("ColladaEffect::readProfileCommon: "
 587                          "using <phong> shader\n"));
 588
 589         domProfile_COMMON::domTechnique::domPhongRef phong = tech->getPhong();
 590
 591         readTextureParams((phong->getEmission() != NULL) ?
 592                               phong->getEmission()->getTexture() : NULL,
 593                           EmissionTexture);
 594
 595         readTextureParams((phong->getAmbient() != NULL) ?
 596                               phong->getAmbient() ->getTexture() : NULL,
 597                           AmbientTexture);
 598
 599         readTextureParams((phong->getDiffuse() != NULL) ?
 600                               phong->getDiffuse() ->getTexture() : NULL,
 601                           DiffuseTexture);
 602
 603         readTextureParams((phong->getSpecular() != NULL) ?
 604                               phong->getSpecular() ->getTexture() : NULL,
 605                           SpecularTexture);
 606
 607         readTextureParams((phong->getTransparent() != NULL) ?
 608                               phong->getTransparent()->getTexture() : NULL,
 609                           TransparentTexture);
 610     }
 611     else if(tech->getBlinn() != NULL)
 612     {
 613         OSG_COLLADA_LOG(("ColladaEffect::readProfileCommon: "
 614                          "using <blinn> shader\n"));
 615
 616         domProfile_COMMON::domTechnique::domBlinnRef blinn = tech->getBlinn();
 617
 618         readTextureParams((blinn->getEmission() != NULL) ?
 619                               blinn->getEmission()->getTexture() : NULL,
 620                           EmissionTexture);
 621
 622         readTextureParams((blinn->getAmbient() != NULL) ?
 623                               blinn->getAmbient() ->getTexture() : NULL,
 624                           AmbientTexture);
 625
 626         readTextureParams((blinn->getDiffuse() != NULL) ?
 627                               blinn->getDiffuse() ->getTexture() : NULL,
 628                           DiffuseTexture);
 629
 630         readTextureParams((blinn->getSpecular() != NULL) ?
 631                               blinn->getSpecular() ->getTexture() : NULL,
 632                           SpecularTexture);
 633
 634         readTextureParams((blinn->getTransparent() != NULL) ?
 635                               blinn->getTransparent()->getTexture() : NULL,
 636                           TransparentTexture);
 637     }
 638
 639     const domExtra_Array &techniqueExtras = tech->getExtra_array();
 640
 641     if(_extraHandlers.size() == 0)
 642         return;
 643
 644     for(UInt32 i = 0; i < techniqueExtras.getCount(); ++i)
 645     {
 646         ExtraHandlerStoreIt      ehIt  = _extraHandlers.begin();
 647         ExtraHandlerStoreConstIt ehEnd = _extraHandlers.end  ();
 648
 649         for(; ehIt != ehEnd; ++ehIt)
 650         {
 651             (*ehIt)->readTechniqueExtraElements(this, techniqueExtras[i]);
 652         }
 653     }
 654 }
 655
 656 void ColladaEffect::readTextureParams(
 657     domCommon_color_or_texture_type::domTexture *texture,
 658     TextureTarget                                target )
 659 {
 660     if(texture == NULL)
 661         return;
 662
 663     ParamTexture oTexParam;
 664
 665     oTexParam.colTexture =
 666         dynamic_pointer_cast<ColladaTexture>(
 667             ColladaElementFactory::the()->create(texture,
 668                                                  getGlobal()));
 669
 670     oTexParam.texture    = texture;
 671
 672     oTexParam.colTexture->setEffect(this);
 673     oTexParam.colTexture->read     (this);
 674
 675     _textures[target] = oTexParam;
 676 }
 677
 678 void ColladaEffect::readProfileGLSL(domProfile_GLSL *prof)
 679 {
 680     SWARNING << "ColladaEffect::readProfileGLSL: NIY." << std::endl;
 681 }
 682
 683 void ColladaEffect::readProfileCG(domProfile_CG *prof)
 684 {
 685     SWARNING << "ColladaEffect::readProfileCG: Fallback NIY." << std::endl;
 686 }
 687
 688 /*! Create an OpenSG material that matches this \c &lt;profile_COMMON&gt;
 689     material (to the extent possible).
 690  */
 691
 692 MaterialTransitPtr ColladaEffect::createInstanceProfileCommon(
 693     domProfile_COMMON  *prof,
 694     domEffect          *effect,
 695     domInstance_effect *instEffect)
 696 {
 697     OSG_COLLADA_LOG(("ColladaEffect::createInstanceProfileCommon\n"));
 698
 699     ColladaInstanceEffectRefPtr colInstEffect =
 700         getUserDataAs<ColladaInstanceEffect>(instEffect);
 701
 702     domProfile_COMMON::domTechniqueRef tech = prof->getTechnique();
 703
 704     domCommon_color_or_texture_typeRef emission     = NULL;
 705     domCommon_color_or_texture_typeRef ambient      = NULL;
 706     domCommon_color_or_texture_typeRef diffuse      = NULL;
 707     domCommon_color_or_texture_typeRef specular     = NULL;
 708     domCommon_float_or_param_typeRef   shininess    = NULL;
 709     domCommon_transparent_typeRef      transparent  = NULL;
 710     domCommon_float_or_param_typeRef   transparency = NULL;
 711
 712     if(tech->getConstant() != NULL)
 713     {
 714         OSG_COLLADA_LOG(("ColladaEffect::createInstanceProfileCommon: "
 715                          "using <constant> shader\n"));
 716
 717         domProfile_COMMON::domTechnique::domConstantRef constant =
 718             tech->getConstant();
 719
 720         emission     = constant->getEmission    ();
 721         transparent  = constant->getTransparent ();
 722         transparency = constant->getTransparency();
 723     }
 724     else if(tech->getLambert() != NULL)
 725     {
 726         OSG_COLLADA_LOG(("ColladaEffect::createInstanceProfileCommon: "
 727                          "using <lambert> shader\n"));
 728
 729         domProfile_COMMON::domTechnique::domLambertRef lambert =
 730             tech->getLambert();
 731
 732         emission     = lambert->getEmission    ();
 733         ambient      = lambert->getAmbient     ();
 734         diffuse      = lambert->getDiffuse     ();
 735         transparent  = lambert->getTransparent ();
 736         transparency = lambert->getTransparency();
 737     }
 738     else if(tech->getPhong() != NULL)
 739     {
 740         OSG_COLLADA_LOG(("ColladaEffect::createInstanceProfileCommon: "
 741                          "using <phong> shader\n"));
 742
 743         domProfile_COMMON::domTechnique::domPhongRef phong =
 744             tech->getPhong();
 745
 746         emission     = phong->getEmission    ();
 747         ambient      = phong->getAmbient     ();
 748         diffuse      = phong->getDiffuse     ();
 749         specular     = phong->getSpecular    ();
 750         shininess    = phong->getShininess   ();
 751         transparent  = phong->getTransparent ();
 752         transparency = phong->getTransparency();
 753     }
 754     else if(tech->getBlinn() != NULL)
 755     {
 756         OSG_COLLADA_LOG(("ColladaEffect::createInstanceProfileCommon: "
 757                          "using <blinn> shader\n"));
 758
 759         domProfile_COMMON::domTechnique::domBlinnRef blinn =
 760             tech->getBlinn();
 761
 762         emission     = blinn->getEmission    ();
 763         ambient      = blinn->getAmbient     ();
 764         diffuse      = blinn->getDiffuse     ();
 765         specular     = blinn->getSpecular    ();
 766         shininess    = blinn->getShininess   ();
 767         transparent  = blinn->getTransparent ();
 768         transparency = blinn->getTransparency();
 769     }
 770
 771     UInt32                texCount   = 0;
 772     Real32                transVal   = 1.f;
 773     ChunkMaterialUnrecPtr mat        = ChunkMaterial::create();
 774     MaterialChunkUnrecPtr matChunk   = MaterialChunk::create();
 775     BlendChunkUnrecPtr    blendChunk = NULL;
 776     DepthChunkUnrecPtr    depthChunk = NULL;
 777
 778     getGlobal()->getStatCollector()->getElem(
 779         ColladaGlobal::statNMaterialCreated)->inc();
 780
 781     // handle the "conventional" material attributes
 782     handleProfileCommonEmission(emission,
 783                                 matChunk);
 784
 785     handleProfileCommonAmbient (ambient,
 786                                 colInstEffect,
 787                                 mat,
 788                                 matChunk,
 789                                 blendChunk,
 790                                 depthChunk,
 791                                 texCount     );
 792
 793     handleProfileCommonDiffuse (diffuse,
 794                                 colInstEffect,
 795                                 mat,
 796                                 matChunk,
 797                                 blendChunk,
 798                                 depthChunk,
 799                                 texCount     );
 800
 801     handleProfileCommonSpecular(specular,
 802                                 matChunk     );
 803
 804     if(shininess != NULL)
 805     {
 806         domCommon_float_or_param_type::domFloatRef value;
 807         domCommon_float_or_param_type::domParamRef param;
 808
 809         fillFloatParam(shininess, value, param);
 810
 811         if(value != NULL)
 812         {
 813             Real32 shininessVal = value->getValue();
 814             shininessVal = osgClamp(0.f, shininessVal, 128.f);
 815
 816             matChunk->setShininess(shininessVal);
 817         }
 818         else if(param != NULL)
 819         {
 820             SWARNING << "ColladaEffect::createInstanceProfileCommon: "
 821                      << "<shininess>/<param> not supported."
 822                      << std::endl;
 823         }
 824     }
 825
 826     if(transparency != NULL)
 827     {
 828         // this only sets transVal to the value stored in the
 829         // <transparency> tag.
 830
 831         domCommon_float_or_param_type::domFloatRef value;
 832         domCommon_float_or_param_type::domParamRef param;
 833
 834         fillFloatParam(transparency, value, param);
 835
 836         if(value != NULL)
 837         {
 838             transVal = value->getValue();
 839
 840             if(getGlobal()->getOptions()->getInvertTransparency() == true)
 841                 transVal = 1.f - transVal;
 842         }
 843         else if(param != NULL)
 844         {
 845             SWARNING << "ColladaEffect::createInstanceProfileCommon: "
 846                      << "<transparency>/<param> not supported."
 847                      << std::endl;
 848         }
 849     }
 850
 851     if(transparent != NULL)
 852     {
 853         // this handles <transparent> and <transparency> tags
 854         // (by considering the value of transVal) - since they are
 855         // so closely related that they need to be handled together
 856
 857         domCommon_color_or_texture_type::domColorRef   color;
 858         domCommon_color_or_texture_type::domParamRef   param;
 859         domCommon_color_or_texture_type::domTextureRef texture;
 860
 861         fillColorParamTex(transparent, color, param, texture);
 862
 863         if(color != NULL)
 864         {
 865             Color4f colVal(color->getValue()[0],
 866                            color->getValue()[1],
 867                            color->getValue()[2],
 868                            color->getValue()[3] );
 869
 870             domFx_opaque_enum opaque = transparent->getOpaque();
 871
 872             if(opaque == FX_OPAQUE_ENUM_A_ONE)
 873             {
 874                 Color4f constCol(colVal[3] * transVal,
 875                                  colVal[3] * transVal,
 876                                  colVal[3] * transVal,
 877                                  colVal[3] * transVal );
 878
 879                 if(constCol[0] < (1.f - TypeTraits<Real32>::getDefaultEps()))
 880                 {
 881                     if(blendChunk == NULL)
 882                         blendChunk = BlendChunk::create();
 883
 884                     blendChunk->setSrcFactor (GL_CONSTANT_ALPHA          );
 885                     blendChunk->setDestFactor(GL_ONE_MINUS_CONSTANT_ALPHA);
 886
 887                     blendChunk->setColor     (constCol                   );
 888
 889                     OSG_COLLADA_LOG(
 890                         ("ColladaEffect::createInstanceProfileCommon: "
 891                          "src: GL_CONSTANT_ALPHA "
 892                          "dst: GL_ONE_MINUS_CONSTANT_ALPHA "
 893                          "%f\n",
 894                          constCol[0]));
 895                 }
 896             }
 897             else if(opaque == FX_OPAQUE_ENUM_RGB_ZERO)
 898             {
 899                 Color4f constCol(colVal[0]         * transVal,
 900                                  colVal[1]         * transVal,
 901                                  colVal[2]         * transVal,
 902                                  luminance(colVal) * transVal );
 903
 904                 if(constCol[0] > TypeTraits<Real32>::getDefaultEps() ||
 905                    constCol[1] > TypeTraits<Real32>::getDefaultEps() ||
 906                    constCol[2] > TypeTraits<Real32>::getDefaultEps()   )
 907                 {
 908                     if(blendChunk == NULL)
 909                         blendChunk = BlendChunk::create();
 910
 911                     blendChunk->setSrcFactor (GL_ONE_MINUS_CONSTANT_COLOR);
 912                     blendChunk->setDestFactor(GL_CONSTANT_COLOR          );
 913
 914                     blendChunk->setColor     (constCol                   );
 915
 916                     OSG_COLLADA_LOG(
 917                         ("ColladaEffect::createInstanceProfileCommon: "
 918                          "src: GL_ONE_MINUS_CONSTANT_COLOR "
 919                          "dst: GL_CONSTANT_COLOR "
 920                          "%f %f %f %f\n",
 921                          constCol[0],
 922                          constCol[1],
 923                          constCol[2],
 924                          constCol[3]));
 925                 }
 926             }
 927         }
 928         else if(param != NULL)
 929         {
 930             SWARNING << "ColladaEffect::createInstanceProfileCommon: "
 931                      << "<transparent>/<param> not supported."
 932                      << std::endl;
 933         }
 934         else if(texture != NULL)
 935         {
 936             ColladaTexture *pTex = _textures[TransparentTexture].colTexture;
 937
 938             if(pTex != NULL)
 939             {
 940                 xsNCName tcSemantic =
 941                     _textures[TransparentTexture].texture->getTexcoord();
 942
 943                 addTexture(tcSemantic,
 944                            colInstEffect,
 945                            pTex,
 946                            mat,
 947                            GL_MODULATE,
 948                            texCount                     );
 949
 950                 // do we need a blend chunk?
 951                 if(pTex->hasAlpha())
 952                 {
 953                     if(blendChunk == NULL)
 954                         blendChunk = BlendChunk::create();
 955
 956 #if defined(OSG_COLLADA_TRANSPARENT_MODE) && OSG_COLLADA_TRANSPARENT_MODE == 1
 957                     // Always use alpha test with low alpha value, standard
 958                     // blending, but enable depth writes
 959
 960                     blendChunk->setAlphaFunc (GL_GREATER);
 961                     blendChunk->setAlphaValue(0.1f      );
 962
 963                     blendChunk->setSrcFactor (GL_SRC_ALPHA          );
 964                     blendChunk->setDestFactor(GL_ONE_MINUS_SRC_ALPHA);
 965
 966                     // force depth writing even for transparent object
 967                     if(depthChunk == NULL)
 968                         depthChunk = DepthChunk::create();
 969
 970 #elif defined(OSG_COLLADA_TRANSPARENT_MODE) && OSG_COLLADA_TRANSPARENT_MODE == 2
 971                     // enable depth writes for textures with a "mask" alpha
 972                     // channel (only values are 0 and 1)
 973                     // standard blending otherwise
 974
 975                     if(pTex->hasBinaryAlpha())
 976                     {
 977                         OSG_COLLADA_LOG((
 978                             "ColladaEffect::createInstanceProfileCommon: "
 979                             "<transparent>/<texture> using alpha test.\n"));
 980
 981                         blendChunk->setAlphaFunc (GL_GREATER  );
 982                         blendChunk->setAlphaValue(0.5f        );
 983
 984                         blendChunk->setDestFactor(GL_ZERO     );
 985                         blendChunk->setSrcFactor (GL_SRC_ALPHA);
 986                     }
 987                     else
 988                     {
 989                         OSG_COLLADA_LOG((
 990                             "ColladaEffect::createInstanceProfileCommon: "
 991                             "<transparent>/<texture> using blending.\n"));
 992
 993                         blendChunk->setSrcFactor (GL_SRC_ALPHA          );
 994                         blendChunk->setDestFactor(GL_ONE_MINUS_SRC_ALPHA);
 995                     }
 996 #endif // OSG_COLLADA_TRANSPARENT_MODE
 997                 }
 998             }
 999             else
1000             {
1001                 SWARNING << "ColladaEffect::createInstanceProfileCommon: "
1002                          << "<diffuse>/<texture> could not find sampler2D ["
1003                          << texture->getTexture() << "]."
1004                          << std::endl;
1005             }
1006         }
1007     }
1008     else if(transparency != NULL)
1009     {
1010         // handle only <transparency> tag case (no <transparent> tag)
1011
1012         Color4f constCol(transVal, transVal, transVal, transVal);
1013
1014         if(constCol[0] < (1.f - TypeTraits<Real32>::getDefaultEps()))
1015         {
1016             if(blendChunk == NULL)
1017                 blendChunk = BlendChunk::create();
1018
1019             blendChunk->setSrcFactor (GL_CONSTANT_ALPHA          );
1020             blendChunk->setDestFactor(GL_ONE_MINUS_CONSTANT_ALPHA);
1021
1022             blendChunk->setColor     (constCol                   );
1023
1024             OSG_COLLADA_LOG(("ColladaEffect::createInstanceProfileCommon: "
1025                              "src: GL_CONSTANT_ALPHA "
1026                              "dst: GL_ONE_MINUS_CONSTANT_ALPHA "
1027                              "%f\n", constCol[0]));
1028         }
1029     }
1030
1031     mat->addChunk(matChunk);
1032
1033     if(blendChunk != NULL)
1034         mat->addChunk(blendChunk);
1035
1036     if(depthChunk != NULL)
1037         mat->addChunk(depthChunk);
1038
1039     return MaterialTransitPtr(mat);
1040 }
1041
1042 MaterialTransitPtr ColladaEffect::createInstanceProfileGLSL(
1043     domProfile_GLSL    *prof,
1044     domEffect          *effect,
1045     domInstance_effect *instEffect)
1046 {
1047     SWARNING << "ColladaEffect::createInstanceProfileGLSL: NIY" << std::endl;
1048
1049     return MaterialTransitPtr();
1050 }
1051
1052 MaterialTransitPtr ColladaEffect::createInstanceProfileCG(
1053     domProfile_CG      *prof,
1054     domEffect          *effect,
1055     domInstance_effect *instEffect)
1056 {
1057     SWARNING << "ColladaEffect::createInstanceProfileCG: Fallback NIY"
1058              << std::endl;
1059
1060     return MaterialTransitPtr();
1061 }
1062
1063 void ColladaEffect::handleProfileCommonEmission(
1064     domCommon_color_or_texture_type *emission,
1065     MaterialChunk                   *matChunk )
1066 {
1067     if(emission == NULL)
1068         return;
1069
1070     domCommon_color_or_texture_type::domColorRef   color;
1071     domCommon_color_or_texture_type::domParamRef   param;
1072     domCommon_color_or_texture_type::domTextureRef texture;
1073
1074     fillColorParamTex(emission, color, param, texture);
1075
1076     if(color != NULL)
1077     {
1078         Color4f colVal(color->getValue()[0],
1079                        color->getValue()[1],
1080                        color->getValue()[2],
1081                        color->getValue()[3] );
1082
1083         matChunk->setEmission(colVal);
1084     }
1085     else if(param != NULL)
1086     {
1087         SWARNING << "ColladaEffect::handleProfileCommonEmission: "
1088                  << "<emission>/<param> not supported."
1089                  << std::endl;
1090     }
1091     else if(texture != NULL)
1092     {
1093 #if 0
1094         xsNCName texId      = texture->getTexture ();
1095         xsNCName tcSemantic = texture->getTexcoord();
1096 #endif
1097
1098         SWARNING << "ColladaEffect::handleProfileCommonEmission: "
1099                  << "<emission>/<texture> not supported."
1100                  << std::endl;
1101     }
1102 }
1103
1104 void ColladaEffect::handleProfileCommonAmbient(
1105     domCommon_color_or_texture_type *ambient,
1106     ColladaInstanceEffect           *colInstEffect,
1107     ChunkMaterial                   *mat,
1108     MaterialChunk                   *matChunk,
1109     BlendChunkUnrecPtr              &blendChunk,
1110     DepthChunkUnrecPtr              &depthChunk,
1111     UInt32                          &texCount     )
1112 {
1113     if(ambient == NULL)
1114         return;
1115
1116     domCommon_color_or_texture_type::domColorRef   color;
1117     domCommon_color_or_texture_type::domParamRef   param;
1118     domCommon_color_or_texture_type::domTextureRef texture;
1119
1120     fillColorParamTex(ambient, color, param, texture);
1121
1122     if(color != NULL)
1123     {
1124         Color4f colVal(color->getValue()[0],
1125                        color->getValue()[1],
1126                        color->getValue()[2],
1127                        color->getValue()[3] );
1128
1129         matChunk->setAmbient(colVal);
1130     }
1131     else if(param != NULL)
1132     {
1133
1134         SWARNING << "ColladaEffect::handleProfileCommonAmbient: "
1135                  << "<ambient>/<param> not supported."
1136                  << std::endl;
1137     }
1138     else if(texture != NULL)
1139     {
1140         ColladaTexture *pTex = _textures[AmbientTexture].colTexture;
1141
1142         if(pTex != NULL)
1143         {
1144             xsNCName tcSemantic =
1145                 _textures[AmbientTexture].texture->getTexcoord();
1146
1147             addTexture(tcSemantic,
1148                        colInstEffect,
1149                        pTex,
1150                        mat,
1151                        GL_REPLACE,
1152                        texCount                    );
1153
1154             // do we need a blend chunk?
1155             if(pTex->hasAlpha())
1156             {
1157                 if(blendChunk == NULL)
1158                     blendChunk = BlendChunk::create();
1159
1160 #if defined(OSG_COLLADA_TRANSPARENT_MODE) && OSG_COLLADA_TRANSPARENT_MODE == 1
1161                 // Always use alpha test with low alpha value, standard
1162                 // blending, but enable depth writes
1163
1164                 blendChunk->setAlphaFunc (GL_GREATER);
1165                 blendChunk->setAlphaValue(0.1f      );
1166
1167                 blendChunk->setSrcFactor (GL_SRC_ALPHA          );
1168                 blendChunk->setDestFactor(GL_ONE_MINUS_SRC_ALPHA);
1169
1170                 // force depth writing even for transparent object
1171                 if(depthChunk == NULL)
1172                     depthChunk = DepthChunk::create();
1173
1174 #elif defined(OSG_COLLADA_TRANSPARENT_MODE) && OSG_COLLADA_TRANSPARENT_MODE == 2
1175                 // enable depth writes for textures with a "mask" alpha
1176                 // channel (only values are 0 and 1)
1177                 // standard blending otherwise
1178
1179                 if(pTex->hasBinaryAlpha())
1180                 {
1181                     OSG_COLLADA_LOG(
1182                         ("ColladaEffect::handleProfileCommonAmbient: "
1183                          "<ambient>/<texture> using alpha test.\n"));
1184
1185                     blendChunk->setAlphaFunc (GL_GREATER  );
1186                     blendChunk->setAlphaValue(0.5f        );
1187
1188                     blendChunk->setDestFactor(GL_ZERO     );
1189                     blendChunk->setSrcFactor (GL_SRC_ALPHA);
1190                 }
1191                 else
1192                 {
1193                     OSG_COLLADA_LOG(
1194                         ("ColladaEffect::handleProfileCommonAmbient: "
1195                          "<ambient>/<texture> using blending.\n"));
1196
1197                     blendChunk->setSrcFactor (GL_SRC_ALPHA          );
1198                     blendChunk->setDestFactor(GL_ONE_MINUS_SRC_ALPHA);
1199                 }
1200 #endif // OSG_COLLADA_TRANSPARENT_MODE
1201             }
1202         }
1203         else
1204         {
1205             SWARNING << "ColladaEffect::handleProfileCommonAmbient: "
1206                      << "<ambient>/<texture> could not find sampler2D ["
1207                      << texture->getTexture() << "]."
1208                      << std::endl;
1209         }
1210     }
1211 }
1212
1213 void ColladaEffect::handleProfileCommonDiffuse(
1214     domCommon_color_or_texture_type *diffuse,
1215     ColladaInstanceEffect           *colInstEffect,
1216     ChunkMaterial                   *mat,
1217     MaterialChunk                   *matChunk,
1218     BlendChunkUnrecPtr              &blendChunk,
1219     DepthChunkUnrecPtr              &depthChunk,
1220     UInt32                          &texCount     )
1221 {
1222     domCommon_color_or_texture_type::domColorRef   color;
1223     domCommon_color_or_texture_type::domParamRef   param;
1224     domCommon_color_or_texture_type::domTextureRef texture;
1225
1226     fillColorParamTex(diffuse, color, param, texture);
1227
1228     if(color != NULL)
1229     {
1230         Color4f colVal(color->getValue()[0],
1231                        color->getValue()[1],
1232                        color->getValue()[2],
1233                        color->getValue()[3] );
1234
1235         matChunk->setDiffuse(colVal);
1236     }
1237     else if(param != NULL)
1238     {
1239         SWARNING << "ColladaEffect::handleProfileCommonDiffuse: "
1240                  << "<diffuse>/<param> not supported."
1241                  << std::endl;
1242     }
1243     else if(texture != NULL)
1244     {
1245         ColladaTexture *pTex = _textures[DiffuseTexture].colTexture;
1246
1247         if(pTex != NULL)
1248         {
1249             xsNCName tcSemantic =
1250                 _textures[DiffuseTexture].texture->getTexcoord();
1251
1252             addTexture(tcSemantic,
1253                        colInstEffect,
1254                        pTex,
1255                        mat,
1256                        GL_MODULATE,
1257                        texCount                    );
1258
1259             // do we need a blend chunk?
1260             if(pTex->hasAlpha())
1261             {
1262                 if(blendChunk == NULL)
1263                     blendChunk = BlendChunk::create();
1264
1265 #if defined(OSG_COLLADA_TRANSPARENT_MODE) && OSG_COLLADA_TRANSPARENT_MODE == 1
1266                 // Always use alpha test with low alpha value, standard
1267                 // blending, but enable depth writes
1268
1269                 blendChunk->setAlphaFunc (GL_GREATER);
1270                 blendChunk->setAlphaValue(0.1f      );
1271
1272                 blendChunk->setSrcFactor (GL_SRC_ALPHA          );
1273                 blendChunk->setDestFactor(GL_ONE_MINUS_SRC_ALPHA);
1274
1275                 // force depth writing even for transparent object
1276                 if(depthChunk == NULL)
1277                     depthChunk = DepthChunk::create();
1278
1279 #elif defined(OSG_COLLADA_TRANSPARENT_MODE) && OSG_COLLADA_TRANSPARENT_MODE == 2
1280                 // enable depth writes for textures with a "mask" alpha
1281                 // channel (only values are 0 and 1)
1282                 // standard blending otherwise
1283
1284                 if(pTex->hasBinaryAlpha())
1285                 {
1286                     OSG_COLLADA_LOG(
1287                         ("ColladaEffect::handleProfileCommonDiffuse: "
1288                          "<diffuse>/<texture> using alpha test.\n"));
1289
1290                     blendChunk->setAlphaFunc (GL_GREATER  );
1291                     blendChunk->setAlphaValue(0.5f        );
1292
1293
1294                     blendChunk->setDestFactor(GL_ZERO     );
1295                     blendChunk->setSrcFactor (GL_SRC_ALPHA);
1296                 }
1297                 else
1298                 {
1299                     OSG_COLLADA_LOG(
1300                         ("ColladaEffect::handleProfileCommonDiffuse: "
1301                          "<diffuse>/<texture> using blending.\n"));
1302
1303                     blendChunk->setSrcFactor (GL_SRC_ALPHA          );
1304                     blendChunk->setDestFactor(GL_ONE_MINUS_SRC_ALPHA);
1305                 }
1306 #endif // OSG_COLLADA_TRANSPARENT_MODE
1307             }
1308         }
1309         else
1310         {
1311             SWARNING << "ColladaEffect::handleProfileCommonDiffuse: "
1312                      << "<diffuse>/<texture> could not find sampler2D ["
1313                      << texture->getTexture() << "]."
1314                      << std::endl;
1315         }
1316
1317         matChunk->setDiffuse(Color4f(0.8f, 0.8f, 0.8f, 1.f));
1318     }
1319 }
1320
1321 void ColladaEffect::handleProfileCommonSpecular(
1322     domCommon_color_or_texture_type *specular,
1323     MaterialChunk                   *matChunk )
1324 {
1325     if(specular == NULL)
1326     {
1327         // set specular color to black if there is no specular value defined!
1328         matChunk->setSpecular(Color4f(0.0f,0.0f,0.0f,0.0f));
1329
1330         return;
1331     }
1332
1333     domCommon_color_or_texture_type::domColorRef   color;
1334     domCommon_color_or_texture_type::domParamRef   param;
1335     domCommon_color_or_texture_type::domTextureRef texture;
1336
1337     fillColorParamTex(specular, color, param, texture);
1338
1339     if(color != NULL)
1340     {
1341         Color4f colVal(color->getValue()[0],
1342                        color->getValue()[1],
1343                        color->getValue()[2],
1344                        color->getValue()[3] );
1345
1346         matChunk->setSpecular(colVal);
1347     }
1348     else if(param != NULL)
1349     {
1350         SWARNING << "ColladaEffect::createInstanceProfileCommon: "
1351                  << "<specular>/<param> not supported."
1352                  << std::endl;
1353     }
1354     else if(texture != NULL)
1355     {
1356 #if 0
1357         xsNCName texId      = texture->getTexture ();
1358         xsNCName tcSemantic = texture->getTexcoord();
1359 #endif
1360         SWARNING << "ColladaEffect::createInstanceProfileCommon: "
1361                  << "<specular>/<texture> not supported."
1362                  << std::endl;
1363     }
1364 }
1365
1366
1367 void ColladaEffect::fillColorParamTex(
1368     domCommon_color_or_texture_type                *colTex,
1369     domCommon_color_or_texture_type::domColorRef   &colOut,
1370     domCommon_color_or_texture_type::domParamRef   &paramOut,
1371     domCommon_color_or_texture_type::domTextureRef &texOut  )
1372 {
1373     if(colTex != NULL)
1374     {
1375         colOut   = colTex->getColor  ();
1376         paramOut = colTex->getParam  ();
1377         texOut   = colTex->getTexture();
1378     }
1379 }
1380
1381 void ColladaEffect::fillColorParamTex(
1382     domCommon_transparent_type                     *colTex,
1383     domCommon_color_or_texture_type::domColorRef   &colOut,
1384     domCommon_color_or_texture_type::domParamRef   &paramOut,
1385     domCommon_color_or_texture_type::domTextureRef &texOut  )
1386 {
1387     if(colTex != NULL)
1388     {
1389         colOut   = colTex->getColor  ();
1390         paramOut = colTex->getParam  ();
1391         texOut   = colTex->getTexture();
1392     }
1393 }
1394
1395 void ColladaEffect::fillFloatParam(
1396     domCommon_float_or_param_type              *floatParam,
1397     domCommon_float_or_param_type::domFloatRef &floatOut,
1398     domCommon_float_or_param_type::domParamRef &paramOut  )
1399 {
1400     if(floatParam != NULL)
1401     {
1402         floatOut = floatParam->getFloat();
1403         paramOut = floatParam->getParam();
1404     }
1405 }
1406
1407 void ColladaEffect::addTexture(const std::string           &tcSemantic,
1408                                      ColladaInstanceEffect *colInstEffect,
1409                                      ColladaTexture        *colTexture,
1410                                      ChunkMaterial         *mat,
1411                                      GLenum                 envMode,
1412                                      UInt32                &texCount     )
1413 {
1414     TextureEnvChunkUnrecPtr texEnv = TextureEnvChunk::create();
1415     texEnv->setEnvMode(envMode);
1416
1417     Image *texImg = colTexture->getTexture()->getImage();
1418
1419     if(texImg != NULL)
1420     {
1421         mat->addChunk(colTexture->getTexture(),      texCount);
1422         mat->addChunk(texEnv,                        texCount);
1423         mat->addChunk(colTexture->getTexTransform(), texCount);
1424
1425         getGlobal()->getStatCollector()->getElem(
1426             ColladaGlobal::statNTextureUsed)->inc();
1427
1428         OSG_COLLADA_LOG(("ColladaEffect::addTexture: "
1429                          "texCoord symbol [%s] in slot [%d]\n",
1430                          tcSemantic.c_str(),
1431                          Geometry::TexCoordsIndex + texCount));
1432
1433         colInstEffect->editTCMap()[tcSemantic] =
1434             Geometry::TexCoordsIndex + texCount;
1435
1436         ++texCount;
1437     }
1438 }
1439
1440 Real32 ColladaEffect::luminance(const Color4f &col)
1441 {
1442     return (col[0] * 0.212671f + col[1] * 0.71516f + col[2] * 0.072169f);
1443 }
1444
1445 OSG_END_NAMESPACE
1446
1447 #endif // OSG_WITH_COLLADA