Source/System/State/Auxiliary/OSGTextureImageChunk.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 #define GL_GLEXT_PROTOTYPES
  44
  45 #include <cstdlib>
  46 #include <cstdio>
  47
  48 #include <boost/bind.hpp>
  49
  50 #include "OSGConfig.h"
  51
  52 #include "OSGGL.h"
  53 #include "OSGGLU.h"
  54 #include "OSGGLEXT.h"
  55 #include "OSGImage.h"
  56
  57 #include "OSGDrawEnv.h"
  58
  59 #include "OSGTextureImageChunk.h"
  60 #include "OSGTextureBaseChunk.h"
  61
  62 #include "OSGGLFuncProtos.h"
  63
  64 //#define OSG_DUMP_TEX
  65
  66
  67 OSG_USING_NAMESPACE
  68
  69 // Documentation for this class is emited in the
  70 // OSGTextureImageChunkBase.cpp file.
  71 // To modify it, please change the .fcd file (OSGTextureImageChunk.fcd) and
  72 // regenerate the base file.
  73
  74 /***************************************************************************\
  75  *                           Class variables                               *
  76 \***************************************************************************/
  77
  78 StateChunkClass TextureImageChunk::_class("TextureImage", osgMaxTexImages, 30);
  79
  80 UInt32 TextureImageChunk::_arbShaderImageLS      = Window::invalidExtensionID;
  81 UInt32 TextureImageChunk::FuncIdBindImageTexture = Window::invalidFunctionID;
  82
  83 /***************************************************************************\
  84  *                           Class methods                                 *
  85 \***************************************************************************/
  86
  87 /*-------------------------------------------------------------------------*\
  88  -  private                                                                -
  89 \*-------------------------------------------------------------------------*/
  90
  91 void TextureImageChunk::initMethod(InitPhase ePhase)
  92 {
  93     Inherited::initMethod(ePhase);
  94
  95     if(ePhase == TypeObject::SystemPost)
  96     {
  97         _arbShaderImageLS =
  98             Window::registerExtension("GL_ARB_shader_image_load_store");
  99
 100         FuncIdBindImageTexture =
 101             Window::registerFunction
 102             (OSG_DLSYM_UNDERSCORE"glBindImageTexture",
 103              _arbShaderImageLS);
 104
 105     }
 106 }
 107
 108 /***************************************************************************\
 109  *                           Instance methods                              *
 110 \***************************************************************************/
 111
 112 /*-------------------------------------------------------------------------*\
 113  -  private                                                                 -
 114 \*-------------------------------------------------------------------------*/
 115
 116
 117 /*------------- constructors & destructors --------------------------------*/
 118
 119 TextureImageChunk::TextureImageChunk(void) :
 120     Inherited()
 121 {
 122 }
 123
 124 TextureImageChunk::TextureImageChunk(const TextureImageChunk &source) :
 125     Inherited(source)
 126 {
 127 }
 128
 129 TextureImageChunk::~TextureImageChunk(void)
 130 {
 131 }
 132
 133 /*------------------------- Chunk Class Access ---------------------------*/
 134
 135 const StateChunkClass *TextureImageChunk::getClass(void) const
 136 {
 137     return &_class;
 138 }
 139
 140 /*------------------------------- Sync -----------------------------------*/
 141
 142 /*! React to field changes.
 143     Note: this function also handles CubeTexture changes, make sure to keep
 144     it consistent with the cubeTexture specifics
 145 */
 146
 147 void TextureImageChunk::changed(ConstFieldMaskArg whichField,
 148                                 UInt32            origin,
 149                                 BitVector         details)
 150 {
 151     Inherited::changed(whichField, origin, details);
 152 }
 153
 154 bool TextureImageChunk::isTransparent(void) const
 155 {
 156     // Even if the texture has alpha, the Blending is makes the sorting
 157     // important, thus textures per se are not transparent
 158     return false;
 159 }
 160
 161
 162 /*----------------------------- onCreate --------------------------------*/
 163
 164 void TextureImageChunk::onCreate(const TextureImageChunk *source)
 165 {
 166     Inherited::onCreate(source);
 167 }
 168
 169 void TextureImageChunk::onCreateAspect(const TextureImageChunk *createAspect,
 170                                        const TextureImageChunk *source      )
 171 {
 172     Inherited::onCreateAspect(createAspect, source);
 173 }
 174
 175 /*------------------------------ Output ----------------------------------*/
 176
 177 void TextureImageChunk::dump(      UInt32    OSG_CHECK_ARG(uiIndent),
 178                              const BitVector OSG_CHECK_ARG(bvFlags )) const
 179 {
 180     SLOG << "Dump TextureImageChunk NI" << std::endl;
 181 }
 182
 183
 184 /*------------------------------ State ------------------------------------*/
 185
 186
 187 void TextureImageChunk::activate(DrawEnv *pEnv, UInt32 idx)
 188 {
 189     if(this->_sfTexture.getValue() == NULL)
 190         return;
 191
 192     Window *pWin = pEnv->getWindow();
 193
 194     if(!pWin->hasExtOrVersion(_arbShaderImageLS, 0x0402, 0xFFFF))
 195     {
 196         FWARNING(("OpenGL shader image load store is not supported, couldn't "
 197                   "find extension 'GL_ARB_shader_image_load_store'!\n"));
 198
 199         return;
 200     }
 201
 202     this->_sfTexture.getValue()->validate(pEnv);
 203
 204     GLint  iTexGLId = this->_sfTexture.getValue()->getOpenGLId(pEnv);
 205     GLenum eFormat  = this->getFormat();
 206
 207     if(eFormat == GL_NONE)
 208     {
 209         eFormat = this->_sfTexture.getValue()->determineInternalFormat();
 210     }
 211
 212     OSGGETGLFUNCBYID_GL4(glBindImageTexture,
 213                          osgGlBindImageTexture,
 214                          TextureImageChunk::FuncIdBindImageTexture,
 215                          pWin);
 216
 217     osgGlBindImageTexture(idx,
 218                           iTexGLId,
 219                           this->getLevel (),
 220                           this->getLayer () != -1 ? GL_FALSE         : GL_TRUE,
 221                           this->getLayer () != -1 ? this->getLayer() : 0,
 222                           this->getAccess(),
 223                           eFormat                                            );
 224 }
 225
 226
 227 void TextureImageChunk::changeFrom(DrawEnv    *pEnv,
 228                                    StateChunk *old   ,
 229                                    UInt32      idx )
 230 {
 231     if(this->_sfTexture.getValue() == NULL)
 232         return;
 233
 234     Window *pWin = pEnv->getWindow();
 235
 236     if(!pWin->hasExtOrVersion(_arbShaderImageLS, 0x0402, 0xFFFF))
 237     {
 238         FWARNING(("OpenGL shader image load store is not supported, couldn't "
 239                   "find extension 'GL_ARB_shader_image_load_store'!\n"));
 240
 241         return;
 242     }
 243
 244     // change from me to me?
 245     // this assumes I haven't changed in the meantime.
 246     // is that a valid assumption?
 247     if(old == this)
 248         return;
 249
 250     this->_sfTexture.getValue()->validate(pEnv);
 251
 252     GLint  iTexGLId = 0;
 253     GLenum eFormat  = this->getFormat();
 254
 255     if(eFormat == GL_NONE)
 256     {
 257         eFormat = this->_sfTexture.getValue()->determineInternalFormat();
 258     }
 259
 260     OSGGETGLFUNCBYID_GL4(glBindImageTexture,
 261                          osgGlBindImageTexture,
 262                          TextureImageChunk::FuncIdBindImageTexture,
 263                          pWin);
 264
 265     osgGlBindImageTexture(idx,
 266                           iTexGLId,
 267                           this->getLevel (),
 268                           this->getLayer () != -1 ? GL_FALSE         : GL_TRUE,
 269                           this->getLayer () != -1 ? this->getLayer() : 0,
 270                           this->getAccess(),
 271                           eFormat);
 272 }
 273
 274 void TextureImageChunk::deactivate(DrawEnv *pEnv, UInt32 idx)
 275 {
 276     if(this->_sfTexture.getValue() == NULL)
 277         return;
 278
 279     Window *pWin = pEnv->getWindow();
 280
 281     if(!pWin->hasExtOrVersion(_arbShaderImageLS, 0x0402, 0xFFFF))
 282     {
 283         FWARNING(("OpenGL shader image load store is not supported, couldn't "
 284                   "find extension 'GL_ARB_shader_image_load_store'!\n"));
 285
 286         return;
 287     }
 288
 289     GLenum eFormat = this->getFormat();
 290
 291     if(eFormat == GL_NONE)
 292     {
 293         eFormat = this->_sfTexture.getValue()->determineInternalFormat();
 294     }
 295
 296     OSGGETGLFUNCBYID_GL4(glBindImageTexture,
 297                          osgGlBindImageTexture,
 298                          TextureImageChunk::FuncIdBindImageTexture,
 299                          pWin);
 300
 301     osgGlBindImageTexture(idx,
 302                           0,
 303                           this->getLevel (),
 304                           this->getLayer () != -1 ? GL_FALSE         : GL_TRUE,
 305                           this->getLayer () != -1 ? this->getLayer() : 0,
 306                           this->getAccess(),
 307                           eFormat);
 308 }
 309
 310 /*-------------------------- Comparison -----------------------------------*/
 311
 312 Real32 TextureImageChunk::switchCost(StateChunk *OSG_CHECK_ARG(chunk))
 313 {
 314     return 0;
 315 }
 316
 317 bool TextureImageChunk::operator < (const StateChunk &other) const
 318 {
 319     return this < &other;
 320 }
 321
 322 bool TextureImageChunk::operator == (const StateChunk &other) const
 323 {
 324     bool returnValue = false;
 325
 326     return returnValue;
 327 }
 328
 329 bool TextureImageChunk::operator != (const StateChunk &other) const
 330 {
 331     return ! (*this == other);
 332 }
 333
 334 #if 0
 335 void TextureImageChunk::validate(DrawEnv *pEnv)
 336 {
 337     if(this->_sfTexture.getValue() == NULL)
 338         return;
 339
 340     this->_sfTexture.getValue()->validate(pEnv);
 341 }
 342 #endif