Source/System/Window/FrameBufferObjects/OSGRenderBuffer.cpp

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *             Copyright (C) 2000-2002 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 #include <boost/bind.hpp>
  46
  47 #include "OSGConfig.h"
  48 #include "OSGGL.h"
  49 #include "OSGGLEXT.h"
  50 #include "OSGGLFuncProtos.h"
  51
  52 #include "OSGRenderBuffer.h"
  53 #include "OSGDrawEnv.h"
  54 #include "OSGGLU.h"
  55 #include "OSGImage.h"
  56
  57 OSG_BEGIN_NAMESPACE
  58
  59 UInt32 RenderBuffer::_uiFramebufferObjectArb             =
  60     Window::invalidExtensionID;
  61
  62 UInt32 RenderBuffer::_uiFramebufferMultiSampleExt        =
  63     Window::invalidExtensionID;
  64
  65 UInt32 RenderBuffer::_uiFramebufferMultiSampleCoverageNV =
  66     Window::invalidExtensionID;
  67
  68
  69 UInt32 RenderBuffer::_uiFuncFramebufferRenderbuffer                =
  70     Window::invalidFunctionID;
  71
  72 UInt32  RenderBuffer::_uiFuncGenRenderbuffers                      =
  73     Window::invalidFunctionID;
  74
  75 UInt32 RenderBuffer::_uiFuncDeleteRenderbuffers                    =
  76     Window::invalidFunctionID;
  77
  78 UInt32 RenderBuffer::_uiFuncBindRenderbuffer                       =
  79     Window::invalidFunctionID;
  80
  81 UInt32 RenderBuffer::_uiFuncRenderbufferStorage                    =
  82     Window::invalidFunctionID;
  83
  84 UInt32 RenderBuffer::_uiFuncRenderbufferStorageMultiSample         =
  85     Window::invalidFunctionID;
  86
  87 UInt32 RenderBuffer::_uiFuncRenderbufferStorageMultiSampleCoverage =
  88     Window::invalidFunctionID;
  89
  90 // Documentation for this class is emited in the
  91 // OSGRenderBufferBase.cpp file.
  92 // To modify it, please change the .fcd file (OSGRenderBuffer.fcd) and
  93 // regenerate the base file.
  94
  95 void RenderBuffer::bind(DrawEnv *pEnv, UInt32 index)
  96 {
  97     Window *pWindow = pEnv->getWindow();
  98
  99     pWindow->validateGLObject(getGLId(), pEnv);
 100
 101     OSGGETGLFUNCBYID_GL3_ES( glFramebufferRenderbuffer,
 102                              osgGlFramebufferRenderbuffer,
 103                             _uiFuncFramebufferRenderbuffer,
 104                              pWindow);
 105
 106     osgGlFramebufferRenderbuffer(GL_FRAMEBUFFER,
 107                                  index,
 108                                  GL_RENDERBUFFER,
 109                                  pWindow->getGLObjectId(getGLId()));
 110 }
 111
 112 void RenderBuffer::validate(DrawEnv *pEnv)
 113 {
 114     Window *pWindow = pEnv->getWindow();
 115
 116     pWindow->validateGLObject(getGLId(), pEnv);
 117 }
 118
 119
 120 /*----------------------- constructors & destructors ----------------------*/
 121
 122 RenderBuffer::RenderBuffer(void) :
 123     Inherited()
 124 {
 125 }
 126
 127 RenderBuffer::RenderBuffer(const RenderBuffer &source) :
 128     Inherited(source)
 129 {
 130 }
 131
 132 RenderBuffer::~RenderBuffer(void)
 133 {
 134     if(getGLId() > 0)
 135         Window::destroyGLObject(getGLId(), 1);
 136 }
 137
 138 /*----------------------------- class specific ----------------------------*/
 139
 140 void RenderBuffer::initMethod(InitPhase ePhase)
 141 {
 142     Inherited::initMethod(ePhase);
 143
 144    if(ePhase == TypeObject::SystemPost)
 145     {
 146         _uiFramebufferObjectArb         =
 147             Window::registerExtension("GL_ARB_framebuffer_object");
 148
 149         _uiFramebufferMultiSampleExt    =
 150             Window::registerExtension("GL_EXT_framebuffer_multisample");
 151
 152         _uiFramebufferMultiSampleCoverageNV =
 153             Window::registerExtension("GL_NV_framebuffer_multisample_coverage");
 154
 155         _uiFuncFramebufferRenderbuffer  =
 156             Window::registerFunction (
 157                  OSG_DLSYM_UNDERSCORE"glFramebufferRenderbuffer",
 158                 _uiFramebufferObjectArb);
 159
 160         _uiFuncGenRenderbuffers         =
 161             Window::registerFunction (
 162                  OSG_DLSYM_UNDERSCORE"glGenRenderbuffers",
 163                 _uiFramebufferObjectArb);
 164
 165         _uiFuncDeleteRenderbuffers      =
 166             Window::registerFunction (
 167                  OSG_DLSYM_UNDERSCORE"glDeleteRenderbuffers",
 168                 _uiFramebufferObjectArb);
 169
 170         _uiFuncRenderbufferStorage      =
 171             Window::registerFunction (
 172                  OSG_DLSYM_UNDERSCORE"glRenderbufferStorage",
 173                 _uiFramebufferObjectArb);
 174
 175
 176         _uiFuncBindRenderbuffer         =
 177             Window::registerFunction (
 178                  OSG_DLSYM_UNDERSCORE"glBindRenderbuffer",
 179                 _uiFramebufferObjectArb);
 180
 181
 182         _uiFuncRenderbufferStorageMultiSample          =
 183             Window::registerFunction (
 184                  OSG_DLSYM_UNDERSCORE"glRenderbufferStorageMultisampleEXT",
 185                 _uiFramebufferMultiSampleExt);
 186
 187         _uiFuncRenderbufferStorageMultiSampleCoverage  =
 188             Window::registerFunction (
 189               OSG_DLSYM_UNDERSCORE"glRenderbufferStorageMultisampleCoverageNV",
 190              _uiFramebufferMultiSampleCoverageNV);
 191     }
 192 }
 193
 194 void RenderBuffer::onCreate(const RenderBuffer *source)
 195 {
 196     if(GlobalSystemState == Startup)
 197         return;
 198
 199     setGLId(
 200         Window::registerGLObject(
 201             boost::bind(&RenderBuffer::handleGL,
 202                         RenderBufferMTUncountedPtr(this),
 203                         _1, _2, _3, _4),
 204             &RenderBuffer::handleDestroyGL));
 205 }
 206
 207 void RenderBuffer::changed(ConstFieldMaskArg whichField,
 208                            UInt32            origin,
 209                            BitVector         details)
 210 {
 211     Inherited::changed(whichField, origin, details);
 212
 213     if(0x0000 != (whichField & (WidthFieldMask | HeightFieldMask)))
 214     {
 215         Window::reinitializeGLObject(getGLId());
 216     }
 217 }
 218
 219 void RenderBuffer::dump(      UInt32    ,
 220                         const BitVector ) const
 221 {
 222     SLOG << "Dump RenderBuffer NI" << std::endl;
 223 }
 224
 225 void RenderBuffer::resizeBuffers(UInt32 uiWidth, UInt32 uiHeight)
 226 {
 227     Inherited::resize(uiWidth, uiHeight);
 228
 229     Window::reinitializeGLObject(getGLId());
 230 }
 231
 232 GLenum RenderBuffer::getBufferFormat(void) const
 233 {
 234     return _sfInternalFormat.getValue();
 235 }
 236
 237 UInt32 RenderBuffer::handleGL(DrawEnv                 *pEnv,
 238                               UInt32                   osgid,
 239                               Window::GLObjectStatusE  mode,
 240                               UInt64                        )
 241 {
 242     Window *pWindow = pEnv->getWindow();
 243
 244     if(mode == Window::initialize || mode == Window::reinitialize ||
 245        mode == Window::needrefresh )
 246     {
 247         GLuint uiBufferId = 0;
 248
 249         if(mode == Window::initialize)
 250         {
 251             OSGGETGLFUNCBYID_GL3_ES( glGenRenderbuffers,
 252                                      osgGlGenRenderbuffers,
 253                                     _uiFuncGenRenderbuffers,
 254                                      pWindow);
 255
 256             osgGlGenRenderbuffers(1, &uiBufferId);
 257
 258             pWindow->setGLObjectId(osgid, uiBufferId);
 259         }
 260         else
 261         {
 262             uiBufferId = pWindow->getGLObjectId(osgid);
 263         }
 264
 265         OSGGETGLFUNCBYID_GL3_ES( glBindRenderbuffer,
 266                                  osgGlBindRenderbuffer,
 267                                 _uiFuncBindRenderbuffer,
 268                                  pWindow);
 269
 270         OSGGETGLFUNCBYID_GL3_ES( glRenderbufferStorage,
 271                                  osgGlRenderbufferStorage,
 272                                 _uiFuncRenderbufferStorage,
 273                                  pWindow);
 274
 275         osgGlBindRenderbuffer(GL_RENDERBUFFER, uiBufferId);
 276
 277         GLenum internalFormat = getInternalFormat();
 278
 279         if(internalFormat == GL_NONE && getImage() != NULL)
 280         {
 281             internalFormat = getImage()->getPixelFormat();
 282         }
 283
 284
 285         if(pWindow->hasExtension(_uiFramebufferMultiSampleCoverageNV) == true &&
 286
 287            (_sfColorSamples   .getValue() != 0 ||
 288             _sfCoverageSamples.getValue() != 0  )                         )
 289         {
 290             OSGGETGLFUNCBYID_EXT(
 291                  glRenderbufferStorageMultisampleCoverage,
 292                  osgGlRenderbufferStorageMultisampleCoverage,
 293                 _uiFuncRenderbufferStorageMultiSampleCoverage,
 294                  pWindow);
 295
 296             osgGlRenderbufferStorageMultisampleCoverage(
 297                 GL_RENDERBUFFER,
 298                 _sfCoverageSamples.getValue(),
 299                 _sfColorSamples   .getValue(),
 300                 internalFormat,
 301                 getWidth(),
 302                 getHeight());
 303         }
 304         else if(pWindow->hasExtOrVersion(
 305                     _uiFramebufferMultiSampleExt,
 306                      0x0300                     ) == true &&
 307
 308            (_sfColorSamples   .getValue() != 0)            )
 309         {
 310             OSGGETGLFUNCBYID_GL3( glRenderbufferStorageMultisample,
 311                                   osgGlRenderbufferStorageMultisample,
 312                                  _uiFuncRenderbufferStorageMultiSample,
 313                                   pWindow                             );
 314
 315             osgGlRenderbufferStorageMultisample(
 316                  GL_RENDERBUFFER,
 317                 _sfColorSamples.getValue(),
 318                  internalFormat,
 319                  getWidth(),
 320                  getHeight()              );
 321         }
 322         else
 323         {
 324             osgGlRenderbufferStorage(GL_RENDERBUFFER,
 325                                      internalFormat,
 326                                      getWidth(),
 327                                      getHeight());
 328         }
 329     }
 330
 331     return 0;
 332 }
 333
 334
 335 void RenderBuffer::handleDestroyGL(DrawEnv                 *pEnv,
 336                                    UInt32                   osgid,
 337                                    Window::GLObjectStatusE  mode)
 338 {
 339     Window *pWindow = pEnv->getWindow();
 340
 341     if(mode == Window::destroy)
 342     {
 343         GLuint uiBufferId =  pWindow->getGLObjectId(osgid);
 344
 345         OSGGETGLFUNCBYID_GL3_ES( glDeleteRenderbuffers,
 346                                  osgGlDeleteRenderbuffers,
 347                                 _uiFuncDeleteRenderbuffers,
 348                                  pWindow);
 349
 350         osgGlDeleteRenderbuffers(1, &uiBufferId);
 351
 352         pWindow->setGLObjectId(osgid, 0);
 353     }
 354     else if(mode == Window::finaldestroy)
 355     {
 356         //SWARNING << "Last texture user destroyed" << std::endl;
 357     }
 358 }
 359
 360 void RenderBuffer::processPreDeactivate (DrawEnv *pEnv, UInt32 index)
 361 {
 362     if(_sfReadBack.getValue() == true)
 363     {
 364         Image *pImg = this->getImage();
 365
 366         if(pImg == NULL)
 367             return;
 368
 369         if(pImg->getData() == NULL)
 370         {
 371             SINFO << "TextureBuffer::render: (Re)Allocating image "
 372                   << "for read-back."
 373                   << endLog;
 374
 375             pImg->set(pImg->getPixelFormat(),
 376                       pImg->getWidth      (),
 377                       pImg->getHeight     (),
 378                       pImg->getDepth      (),
 379                       pImg->getMipMapCount(),
 380                       pImg->getFrameCount (),
 381                       pImg->getFrameDelay (),
 382                       NULL,
 383                       pImg->getDataType   (),
 384                       true,
 385                       pImg->getSideCount  () );
 386         }
 387
 388         // select GL_COLORATTACHMENTn and read data into image
 389 #ifndef OSG_OGL_ES2
 390         glReadBuffer(index);
 391 #endif
 392         glReadPixels(0, 0,
 393                      pImg->getWidth      (),
 394                      pImg->getHeight     (),
 395                      pImg->getPixelFormat(),
 396                      pImg->getDataType   (),
 397                      pImg->editData      ());
 398
 399 #ifndef OSG_OGL_ES2
 400         glReadBuffer(GL_NONE);
 401 #endif
 402
 403         glErr("renderbuffer:predeactivate");
 404     }
 405 }
 406
 407 void RenderBuffer::processPostDeactivate(DrawEnv *pEnv)
 408 {
 409 }
 410
 411 OSG_END_NAMESPACE