Source/System/NodeCores/Groups/DynamicStateGenerators/OSGCubeMapGenerator.cpp

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *               Copyright (C) 2000-2006 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 //---------------------------------------------------------------------------
  40 //  Includes
  41 //---------------------------------------------------------------------------
  42
  43 #include <cstdlib>
  44 #include <cstdio>
  45
  46 #include "OSGConfig.h"
  47
  48 #include "OSGCubeMapGenerator.h"
  49 #include "OSGCubeMapGeneratorStageData.h"
  50
  51 #include "OSGFrameBufferObject.h"
  52 #include "OSGFrameBufferAttachment.h"
  53 #include "OSGRenderBuffer.h"
  54 #include "OSGTextureBuffer.h"
  55 #include "OSGTextureEnvChunk.h"
  56 #include "OSGTextureObjChunk.h"
  57 #include "OSGTexGenChunk.h"
  58 #include "OSGTextureTransformChunk.h"
  59 #include "OSGRenderAction.h"
  60 #include "OSGPerspectiveCamera.h"
  61
  62 OSG_BEGIN_NAMESPACE
  63
  64 // Documentation for this class is emitted in the
  65 // OSGCubeMapGeneratorBase.cpp file.
  66 // To modify it, please change the .fcd file (OSGCubeMapGenerator.fcd) and
  67 // regenerate the base file.
  68
  69 /***************************************************************************\
  70  *                           Class variables                               *
  71 \***************************************************************************/
  72
  73 /***************************************************************************\
  74  *                           Class methods                                 *
  75 \***************************************************************************/
  76
  77 void CubeMapGenerator::initMethod(InitPhase ePhase)
  78 {
  79     Inherited::initMethod(ePhase);
  80
  81     if(ePhase == TypeObject::SystemPost)
  82     {
  83         RenderAction::registerEnterDefault(
  84             CubeMapGenerator::getClassType(),
  85             reinterpret_cast<Action::Callback>(
  86                 &CubeMapGenerator::renderEnter));
  87
  88         RenderAction::registerLeaveDefault(
  89             CubeMapGenerator::getClassType(),
  90             reinterpret_cast<Action::Callback>(
  91                 &CubeMapGenerator::renderLeave));
  92     }
  93 }
  94
  95
  96 /***************************************************************************\
  97  *                           Instance methods                              *
  98 \***************************************************************************/
  99
 100 /*-------------------------------------------------------------------------*\
 101  -  private                                                                 -
 102 \*-------------------------------------------------------------------------*/
 103
 104 /*----------------------- constructors & destructors ----------------------*/
 105
 106 CubeMapGenerator::CubeMapGenerator(void) :
 107     Inherited()
 108 {
 109 }
 110
 111 CubeMapGenerator::CubeMapGenerator(const CubeMapGenerator &source) :
 112     Inherited(source)
 113 {
 114 }
 115
 116 CubeMapGenerator::~CubeMapGenerator(void)
 117 {
 118 }
 119
 120 /*----------------------------- class specific ----------------------------*/
 121
 122 void CubeMapGenerator::changed(ConstFieldMaskArg whichField,
 123                             UInt32            origin,
 124                             BitVector         details)
 125 {
 126     Inherited::changed(whichField, origin, details);
 127 }
 128
 129 void CubeMapGenerator::dump(      UInt32    ,
 130                          const BitVector ) const
 131 {
 132     SLOG << "Dump CubeMapGenerator NI" << std::endl;
 133 }
 134
 135 Action::ResultE CubeMapGenerator::renderEnter(Action *action)
 136 {
 137     static Matrix transforms[] =
 138     {
 139         Matrix( 1,  0,  0,  0,
 140                 0, -1,  0,  0,
 141                 0,  0, -1,  0,
 142                 0,  0,  0,  1),
 143
 144         Matrix(-1,  0,  0,  0,
 145                 0, -1,  0,  0,
 146                 0,  0,  1,  0,
 147                 0,  0,  0,  1),
 148
 149         Matrix( 1,  0,  0,  0,
 150                 0,  0, -1,  0,
 151                 0,  1,  0,  0,
 152                 0,  0,  0,  1),
 153
 154         Matrix( 1,  0,  0,  0,
 155                 0,  0,  1,  0,
 156                 0, -1,  0,  0,
 157                 0,  0,  0,  1),
 158
 159         Matrix( 0,  0, -1,  0,
 160                 0, -1,  0,  0,
 161                -1,  0,  0,  0,
 162                 0,  0,  0,  1),
 163
 164         Matrix( 0,  0,  1,  0,
 165                 0, -1,  0,  0,
 166                 1,  0,  0,  0,
 167                 0,  0,  0,  1)
 168     };
 169
 170     RenderAction *a = dynamic_cast<RenderAction *>(action);
 171
 172     Action::ResultE  returnValue = Action::Continue;
 173
 174     Background      *pBack    = a->getBackground();
 175
 176     Node            *pActNode = a->getActNode();
 177
 178     CubeMapGeneratorStageData *pData =
 179         a->getData<CubeMapGeneratorStageData *>(_iDataSlotId);
 180
 181     if(pData == NULL)
 182     {
 183         pData = this->initData(a);
 184     }
 185
 186     TraversalValidator::ValidationStatus eStatus = this->validateOnEnter(a);
 187
 188     if(eStatus == TraversalValidator::Run)
 189     {
 190         this->beginPartitionGroup(a);
 191         {
 192             FrameBufferObject *pTarget  = this->getRenderTarget();
 193
 194             if(pTarget == NULL)
 195             {
 196                 pTarget  = pData->getRenderTarget();
 197             }
 198
 199             Pnt3f oOrigin;
 200
 201             if(this->getOriginMode() == CubeMapGenerator::UseStoredValue)
 202             {
 203                 oOrigin = this->getOrigin();
 204             }
 205             else if(this->getOriginMode() == CubeMapGenerator::UseBeacon)
 206             {
 207                 fprintf(stderr, "CubemapGen::UseBeacon NYI\n");
 208             }
 209             else if(this->getOriginMode() ==
 210                                        CubeMapGenerator::UseCurrentVolumeCenter)
 211             {
 212                 BoxVolume oWorldVol;
 213
 214                 commitChanges();
 215
 216                 pActNode->updateVolume();
 217
 218                 pActNode->getWorldVolume(oWorldVol);
 219
 220                 oWorldVol.getCenter(oOrigin);
 221             }
 222             else if(this->getOriginMode() ==
 223                                        CubeMapGenerator::UseParentsVolumeCenter)
 224             {
 225                 fprintf(stderr, "CubemapGen::UseParentsCenter NYI\n");
 226             }
 227
 228             Camera *pCam = pData->getCamera();
 229
 230             pActNode->setTravMask(0);
 231
 232             for(UInt32 i = 0; i < 6; ++i)
 233             {
 234                 this->pushPartition(a);
 235                 {
 236                     RenderPartition   *pPart    = a->getActivePartition();
 237
 238                     pPart->setVolumeDrawing(false);
 239
 240                     pPart->setRenderTarget(pTarget       );
 241                     pPart->setWindow      (a->getWindow());
 242
 243                     pPart->calcViewportDimension(0,
 244                                                  0,
 245                                                  1,
 246                                                  1,
 247                                                  this->getWidth (),
 248                                                  this->getHeight());
 249
 250                     Matrix m, t;
 251
 252                     // set the projection
 253                     pCam->getProjection          (m,
 254                                                   pPart->getViewportWidth (),
 255                                                   pPart->getViewportHeight());
 256
 257                     pCam->getProjectionTranslation(t,
 258                                                    pPart->getViewportWidth (),
 259                                                    pPart->getViewportHeight());
 260
 261                     pPart->setupProjection(m, t);
 262
 263                     m = transforms[i];
 264
 265                     m[3][0] = oOrigin[0];
 266                     m[3][1] = oOrigin[1];
 267                     m[3][2] = oOrigin[2];
 268
 269                     m.invert();
 270
 271                     pPart->setupViewing(m);
 272
 273                     pPart->setNear     (pCam->getNear());
 274                     pPart->setFar      (pCam->getFar ());
 275
 276                     pPart->calcFrustum();
 277
 278                     if(this->getBackground() == NULL)
 279                     {
 280                         pPart->setBackground(pBack);
 281                     }
 282                     else
 283                     {
 284                         pPart->setBackground(this->getBackground());
 285                     }
 286
 287                     if(this->getRoot() != NULL)
 288                     {
 289                         this->recurse(a, this->getRoot());
 290                     }
 291                     else
 292                     {
 293                         this->recurse(a, a->getTraversalRoot());
 294                     }
 295
 296                     pPart->setDrawBuffer(GL_COLOR_ATTACHMENT0_EXT + i);
 297
 298 #ifdef OSG_DEBUGX
 299                     std::string szMessage("CubeX\n");
 300                     pPart->setDebugString(szMessage          );
 301 #endif
 302                 }
 303                 this->popPartition(a);
 304             }
 305
 306             pActNode->setTravMask(~0);
 307         }
 308         this->endPartitionGroup(a);
 309     }
 310
 311     OSG_ASSERT(pActNode == a->getActNode());
 312
 313     returnValue = Inherited::renderEnter(action);
 314
 315     action->useNodeList(false);
 316
 317     return returnValue;
 318 }
 319
 320 Action::ResultE CubeMapGenerator::renderLeave(Action *action)
 321 {
 322     Action::ResultE returnValue = Action::Continue;
 323
 324     returnValue = Inherited::renderLeave(action);
 325
 326     RenderAction *a = dynamic_cast<RenderAction *>(action);
 327
 328     this->validateOnLeave(a);
 329
 330     return returnValue;
 331 }
 332
 333
 334 CubeMapGeneratorStageDataTransitPtr CubeMapGenerator::setupStageData(
 335     RenderAction *pAction)
 336 {
 337     CubeMapGeneratorStageDataTransitPtr returnValue =
 338         CubeMapGeneratorStageData::createLocal();
 339
 340     if(returnValue == NULL)
 341         return returnValue;
 342
 343     FrameBufferObjectUnrecPtr pCubeTarget  = NULL;
 344     RenderBufferUnrecPtr      pDepthBuffer = NULL;
 345
 346     if(this->getRenderTarget() == NULL)
 347     {
 348         pCubeTarget  = FrameBufferObject::createLocal();
 349         pDepthBuffer = RenderBuffer     ::createLocal();
 350
 351         pDepthBuffer->setInternalFormat (GL_DEPTH_COMPONENT24);
 352
 353         pCubeTarget ->setDepthAttachment(pDepthBuffer        );
 354
 355         returnValue ->setRenderTarget   (pCubeTarget         );
 356     }
 357     else
 358     {
 359         pCubeTarget = this->getRenderTarget();
 360     }
 361
 362     TextureObjChunkUnrecPtr   pCubeTex     = NULL;
 363
 364     if(0x0000 != (_sfSetupMode.getValue() & SetupTexture))
 365     {
 366         pCubeTex = TextureObjChunk::createLocal();
 367
 368         ImageUnrecPtr pImg = Image::createLocal();
 369
 370         pImg->set(Image::OSG_RGB_PF,
 371                   getWidth (),
 372                   getHeight(),
 373                   1,
 374                   1,
 375                   1,
 376                   0.0,
 377                   0,
 378                   Image::OSG_UINT8_IMAGEDATA,
 379                   false,
 380                   6);
 381
 382         pCubeTex   ->setImage         (pImg              );
 383         pCubeTex   ->setMinFilter     (GL_LINEAR         );
 384         pCubeTex   ->setMagFilter     (GL_LINEAR         );
 385         pCubeTex   ->setWrapS         (GL_CLAMP_TO_EDGE  );
 386         pCubeTex   ->setWrapT         (GL_CLAMP_TO_EDGE  );
 387         pCubeTex   ->setWrapR         (GL_CLAMP_TO_EDGE  );
 388
 389         GLenum eTexTarget = this->getTextureFormat();
 390
 391         if(eTexTarget == GL_NONE)
 392         {
 393             eTexTarget = pAction->getActivePartition()->
 394                 getDrawEnv().getTargetBufferFormat();
 395         }
 396
 397         pCubeTex->setInternalFormat(eTexTarget);
 398     }
 399     else
 400     {
 401         pCubeTex = _sfTexture.getValue();
 402     }
 403
 404     TextureEnvChunkUnrecPtr pCubeTexEnv  = NULL;
 405
 406     if(0x0000 != (_sfSetupMode.getValue() & SetupTexEnv))
 407     {
 408         pCubeTexEnv = TextureEnvChunk::createLocal();
 409
 410         pCubeTexEnv->setEnvMode       (GL_REPLACE       );
 411     }
 412
 413     TexGenChunkUnrecPtr           pCubeTexGen   = NULL;
 414     TextureTransformChunkUnrecPtr pCubeTexTrans = NULL;
 415
 416     if(0x0000 != (_sfSetupMode.getValue() & SetupTexGen))
 417     {
 418         pCubeTexGen = TexGenChunk::createLocal();
 419
 420         pCubeTexGen->setGenFuncS(GL_REFLECTION_MAP);
 421         pCubeTexGen->setGenFuncT(GL_REFLECTION_MAP);
 422         pCubeTexGen->setGenFuncR(GL_REFLECTION_MAP);
 423
 424         pCubeTexTrans = TextureTransformChunk::createLocal();
 425
 426         pCubeTexTrans->setUseCameraBeacon(true);
 427     }
 428
 429
 430     static GLenum targets[6] =
 431     {
 432         GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB,
 433         GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB,
 434         GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB,
 435         GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB,
 436         GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB,
 437         GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB
 438     };
 439
 440     for(UInt32 i = 0; i < 6; ++i)
 441     {
 442         TextureBufferUnrecPtr pCubeTexBuffer = TextureBuffer::createLocal();
 443
 444         pCubeTexBuffer->setTexture  (pCubeTex  );
 445         pCubeTexBuffer->setTexTarget(targets[i]);
 446
 447         pCubeTarget->setColorAttachment(pCubeTexBuffer,    i);
 448     }
 449
 450     pCubeTarget->setSize(getWidth (),
 451                          getHeight());
 452
 453     if(0x0000 != (_sfSetupMode.getValue() & OverrideTex))
 454     {
 455         returnValue->addChunk(pCubeTex,
 456                               getTexUnit());
 457     }
 458
 459     if(0x0000 != (_sfSetupMode.getValue() & SetupTexEnv))
 460     {
 461         returnValue->addChunk(pCubeTexEnv,
 462                               getTexUnit());
 463     }
 464
 465     if(0x0000 != (_sfSetupMode.getValue() & SetupTexGen))
 466     {
 467         returnValue->addChunk(pCubeTexGen,
 468                               getTexUnit());
 469         returnValue->addChunk(pCubeTexTrans,
 470                               getTexUnit());
 471
 472         returnValue->setTexTransform(pCubeTexTrans);
 473     }
 474
 475     if(this->getCamera() == NULL)
 476     {
 477         PerspectiveCameraUnrecPtr pCam = PerspectiveCamera::createLocal();
 478
 479         pCam->setNear(pAction->getCamera()->getNear());
 480         pCam->setFar (pAction->getCamera()->getFar ());
 481
 482         pCam->setFov (osgDegree2Rad(90.f));
 483
 484         returnValue->setCamera(pCam);
 485     }
 486
 487     return returnValue;
 488 }
 489
 490 CubeMapGeneratorStageData *CubeMapGenerator::initData(RenderAction *pAction)
 491 {
 492     CubeMapGeneratorStageDataUnrecPtr pData =
 493         pAction->getData<CubeMapGeneratorStageData *>(_iDataSlotId);
 494
 495     if(pData == NULL)
 496     {
 497         pData = setupStageData(pAction);
 498
 499         this->setData(pData, _iDataSlotId, pAction);
 500     }
 501
 502     return pData;
 503 }
 504
 505
 506 OSG_END_NAMESPACE