Source/System/Window/FrameBufferObjects/OSGTextureBuffer.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
  46 #include "OSGConfig.h"
  47 #include "OSGGL.h"
  48 #include "OSGGLEXT.h"
  49 #include "OSGGLFuncProtos.h"
  50
  51 #include "OSGTextureBuffer.h"
  52 #include "OSGWindow.h"
  53 #include "OSGDrawEnv.h"
  54 #include "OSGTextureObjChunk.h"
  55 #include "OSGImage.h"
  56
  57 OSG_BEGIN_NAMESPACE
  58
  59 UInt32 TextureBuffer::_uiFramebuffer_object_extension =
  60     Window::invalidExtensionID;
  61
  62 UInt32 TextureBuffer::_uiFuncFramebufferTexture1D    =  Window::invalidFunctionID;
  63 UInt32 TextureBuffer::_uiFuncFramebufferTexture2D    =  Window::invalidFunctionID;
  64 UInt32 TextureBuffer::_uiFuncFramebufferTexture3D    =  Window::invalidFunctionID;
  65 UInt32 TextureBuffer::_uiFuncFramebufferTextureLayer =  Window::invalidFunctionID;
  66 UInt32 TextureBuffer::_uiFuncGenerateMipmap          =  Window::invalidFunctionID;
  67
  68 // Documentation for this class is emited in the
  69 // OSGTextureBufferBase.cpp file.
  70 // To modify it, please change the .fcd file (OSGTextureBuffer.fcd) and
  71 // regenerate the base file.
  72
  73 void TextureBuffer::bind(DrawEnv *pEnv, UInt32 index)
  74 {
  75     Window *pWindow = pEnv->getWindow();
  76
  77     if(_sfTexture.getValue() != NULL)
  78     {
  79         pWindow->validateGLObject(_sfTexture.getValue()->getGLId(), pEnv);
  80
  81         GLenum target;
  82
  83         if(getTexTarget() != GL_NONE)
  84         {
  85             target = getTexTarget();
  86         }
  87         else
  88         {
  89             target = _sfTexture.getValue()->determineTextureTarget(pWindow);
  90         }
  91
  92         switch(target)
  93         {
  94 #ifndef OSG_OGL_ES2
  95             case GL_TEXTURE_1D:
  96             {
  97                 OSGGETGLFUNCBYID_GL3( glFramebufferTexture1D,
  98                                       osgGlFramebufferTexture1D,
  99                                      _uiFuncFramebufferTexture1D,
 100                                       pWindow);
 101
 102                 osgGlFramebufferTexture1D(
 103                     GL_FRAMEBUFFER,
 104                     index,
 105                     target,
 106                     pWindow->getGLObjectId(_sfTexture.getValue()->getGLId()),
 107                     getLevel());
 108              }
 109             break;
 110 #endif
 111
 112             case GL_TEXTURE_2D:
 113             case GL_TEXTURE_RECTANGLE_ARB:
 114             case GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB:
 115             case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB:
 116             case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB:
 117             case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB:
 118             case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB:
 119             case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB:
 120             {
 121                 OSGGETGLFUNCBYID_GL3_ES( glFramebufferTexture2D,
 122                                          osgGlFramebufferTexture2D,
 123                                         _uiFuncFramebufferTexture2D,
 124                                          pWindow);
 125
 126                 osgGlFramebufferTexture2D(
 127                     GL_FRAMEBUFFER,
 128                     index,
 129                     target,
 130                     pWindow->getGLObjectId(_sfTexture.getValue()->getGLId()),
 131                     getLevel());
 132             }
 133             break;
 134
 135             case GL_TEXTURE_3D:
 136             {
 137                 OSGGETGLFUNCBYID_GL3( glFramebufferTexture3D,
 138                                       osgGlFramebufferTexture3D,
 139                                      _uiFuncFramebufferTexture3D,
 140                                       pWindow);
 141
 142                 osgGlFramebufferTexture3D(
 143                     GL_FRAMEBUFFER,
 144                     index,
 145                     target,
 146                     pWindow->getGLObjectId(_sfTexture.getValue()->getGLId()),
 147                     getLevel(),
 148                     getLayer());
 149             }
 150             break;
 151
 152             case GL_TEXTURE_2D_ARRAY:
 153             case GL_TEXTURE_CUBE_MAP_ARRAY:
 154             {
 155                 OSGGETGLFUNCBYID_GL3( glFramebufferTextureLayer,
 156                                       osgGlFramebufferTextureLayer,
 157                                      _uiFuncFramebufferTextureLayer,
 158                                       pWindow);
 159
 160                 osgGlFramebufferTextureLayer(
 161                     GL_FRAMEBUFFER,
 162                     index,
 163                     pWindow->getGLObjectId(_sfTexture.getValue()->getGLId()),
 164                     getLevel(),
 165                     getLayer());
 166             }
 167             break;
 168
 169         }
 170     }
 171 }
 172
 173 void TextureBuffer::validate(DrawEnv *pEnv)
 174 {
 175     Window *pWindow = pEnv->getWindow();
 176
 177     if(_sfTexture.getValue() != NULL)
 178     {
 179         pWindow->validateGLObject(_sfTexture.getValue()->getGLId(), pEnv);
 180     }
 181 }
 182
 183 void TextureBuffer::resizeBuffers(UInt32 uiWidth, UInt32 uiHeight)
 184 {
 185     TextureObjChunk *pTex = this->getTexture();
 186
 187     if(pTex == NULL)
 188         return;
 189
 190     Image *pImg = pTex->getImage();
 191
 192     if(pImg == NULL)
 193         return;
 194
 195     pImg->set(pImg->getPixelFormat(), //Image::OSG_RGB_PF,
 196               uiWidth,
 197               uiHeight,
 198               pImg->getDepth      (),
 199               pImg->getMipMapCount(),
 200               pImg->getFrameCount (),
 201               pImg->getFrameDelay (),
 202               NULL,
 203               pImg->getDataType   (), //Image::OSG_UINT8_IMAGEDATA,
 204               false,
 205               pImg->getSideCount  ());
 206 }
 207
 208 GLenum TextureBuffer::getBufferFormat(void) const
 209 {
 210     TextureObjChunk *pTex = this->getTexture();
 211
 212     if(pTex == NULL)
 213         return GL_NONE;
 214
 215     if(pTex->getInternalFormat() != GL_NONE)
 216         return pTex->getInternalFormat();
 217
 218     Image *pImg = pTex->getImage();
 219
 220     if(pImg == NULL)
 221         return GL_NONE;
 222
 223     return pImg->getPixelFormat();
 224 }
 225
 226
 227 void TextureBuffer::processPreDeactivate(DrawEnv *pEnv, UInt32 index)
 228 {
 229     if(_sfReadBack.getValue() == true)
 230     {
 231         TextureObjChunk *pTexObj = this->getTexture();
 232
 233         if(pTexObj == NULL)
 234             return;
 235
 236         Image *pTexImg = pTexObj->getImage();
 237
 238         if(pTexImg == NULL)
 239             return;
 240
 241         if(pTexImg->getData() == NULL)
 242         {
 243             SINFO << "TextureBuffer::render: (Re)Allocating image "
 244                   << "for read-back."
 245                   << endLog;
 246
 247             pTexImg->set(pTexImg->getPixelFormat(),
 248                          pTexImg->getWidth      (),
 249                          pTexImg->getHeight     (),
 250                          pTexImg->getDepth      (),
 251                          pTexImg->getMipMapCount(),
 252                          pTexImg->getFrameCount (),
 253                          pTexImg->getFrameDelay (),
 254                          NULL,
 255                          pTexImg->getDataType   (),
 256                          true,
 257                          pTexImg->getSideCount  () );
 258         }
 259
 260         UInt32  mipMapLevel = _sfLevel.getValue();
 261         UInt32  frame       = 0;
 262         UInt32  side        = 0;
 263         GLenum  target;
 264         Window *pWindow = pEnv->getWindow();
 265
 266         if(_sfTexTarget.getValue() != GL_NONE)
 267         {
 268             target = _sfTexTarget.getValue();
 269         }
 270         else
 271         {
 272             target = _sfTexture.getValue()->determineTextureTarget(pWindow);
 273         }
 274
 275         switch(target)
 276         {
 277             case GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB:
 278                 side = 0;
 279                 break;
 280             case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB:
 281                 side = 1;
 282                 break;
 283             case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB:
 284                 side = 2;
 285                 break;
 286             case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB:
 287                 side = 3;
 288                 break;
 289             case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB:
 290                 side = 4;
 291                 break;
 292             case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB:
 293                 side = 5;
 294                 break;
 295         }
 296
 297         // select GL_COLORATTACHMENTn and read data into image
 298 #ifndef OSG_OGL_ES2
 299         glReadBuffer(index);
 300 #endif
 301         glReadPixels(0, 0,
 302                      pTexImg->getWidth      (),
 303                      pTexImg->getHeight     (),
 304                      pTexImg->getPixelFormat(),
 305                      pTexImg->getDataType   (),
 306                      pTexImg->editData      (mipMapLevel, frame, side));
 307
 308 #ifndef OSG_OGL_ES2
 309         glReadBuffer(GL_NONE);
 310 #endif
 311     }
 312 }
 313
 314 void TextureBuffer::processPostDeactivate(DrawEnv *pEnv)
 315 {
 316     Window *win = pEnv->getWindow();
 317
 318     // If there are TextureBuffers with mipmap filters attached,
 319     // the mipmaps need to be regenerated
 320     TextureObjChunk *pTexObj = this->getTexture();
 321
 322     if(pTexObj == NULL)
 323         return;
 324
 325     GLenum target = pTexObj->determineTextureTarget(win);
 326
 327     if(target                   == GL_TEXTURE_2D                 &&
 328        (pTexObj->getMinFilter() == GL_NEAREST_MIPMAP_NEAREST ||
 329         pTexObj->getMinFilter() == GL_LINEAR_MIPMAP_NEAREST  ||
 330         pTexObj->getMinFilter() == GL_NEAREST_MIPMAP_LINEAR  ||
 331         pTexObj->getMinFilter() == GL_LINEAR_MIPMAP_LINEAR     )   )
 332     {
 333         OSGGETGLFUNCBYID_GL3_ES( glGenerateMipmap,
 334                                  osgGlGenerateMipmap,
 335                                 _uiFuncGenerateMipmap,
 336                                  win);
 337
 338         glBindTexture(target, win->getGLObjectId(pTexObj->getGLId()));
 339
 340         osgGlGenerateMipmap(target);
 341     }
 342 }
 343
 344 /*----------------------- constructors & destructors ----------------------*/
 345
 346 TextureBuffer::TextureBuffer(void) :
 347     Inherited()
 348 {
 349 }
 350
 351 TextureBuffer::TextureBuffer(const TextureBuffer &source) :
 352     Inherited(source)
 353 {
 354 }
 355
 356 TextureBuffer::~TextureBuffer(void)
 357 {
 358 }
 359
 360 /*----------------------------- class specific ----------------------------*/
 361
 362 void TextureBuffer::initMethod(InitPhase ePhase)
 363 {
 364     Inherited::initMethod(ePhase);
 365
 366     if(ePhase == TypeObject::SystemPost)
 367     {
 368         _uiFramebuffer_object_extension =
 369             Window::registerExtension("GL_ARB_framebuffer_object");
 370
 371         _uiFuncFramebufferTexture1D =
 372             Window::registerFunction (
 373                  OSG_DLSYM_UNDERSCORE"glFramebufferTexture1D",
 374                 _uiFramebuffer_object_extension);
 375
 376         _uiFuncFramebufferTexture2D =
 377             Window::registerFunction (
 378                  OSG_DLSYM_UNDERSCORE"glFramebufferTexture2D",
 379                 _uiFramebuffer_object_extension);
 380
 381         _uiFuncFramebufferTexture3D =
 382             Window::registerFunction (
 383                  OSG_DLSYM_UNDERSCORE"glFramebufferTexture3D",
 384                 _uiFramebuffer_object_extension);
 385
 386         _uiFuncFramebufferTextureLayer =
 387             Window::registerFunction (
 388                  OSG_DLSYM_UNDERSCORE"glFramebufferTextureLayer",
 389                 _uiFramebuffer_object_extension);
 390
 391         _uiFuncGenerateMipmap =
 392             Window::registerFunction (
 393                  OSG_DLSYM_UNDERSCORE"glGenerateMipmap",
 394                 _uiFramebuffer_object_extension);
 395     }
 396
 397 }
 398
 399 void TextureBuffer::changed(ConstFieldMaskArg whichField,
 400                             UInt32            origin,
 401                             BitVector         details)
 402 {
 403     Inherited::changed(whichField, origin, details);
 404 }
 405
 406 void TextureBuffer::dump(      UInt32    ,
 407                          const BitVector ) const
 408 {
 409     SLOG << "Dump TextureBuffer NI" << std::endl;
 410 }
 411
 412 OSG_END_NAMESPACE