Source/Contrib/ComputeBase/ComputeShader/OSGComputeShaderAlgorithm.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 #include <cstdlib>
  40 #include <cstdio>
  41
  42 #include <sstream>
  43 #include <fstream>
  44
  45 #include "OSGConfig.h"
  46
  47 #include "OSGGLEXT.h"
  48 #include "OSGGLFuncProtos.h"
  49
  50 #include "OSGAction.h"
  51 #include "OSGCamera.h"
  52 #include "OSGSceneFileHandler.h"
  53 #include "OSGVolumeDraw.h"
  54
  55 #include "OSGDrawEnv.h"
  56 #include "OSGComputeShaderAlgorithm.h"
  57
  58 #include "OSGTextureImageChunk.h"
  59 #include "OSGComputeShaderChunk.h"
  60 #include "OSGChunkMaterial.h"
  61
  62 #include "OSGShaderStorageBufferObjChunk.h"
  63 #include "OSGShaderStorageBufferObjRefChunk.h"
  64 #include "OSGShaderStorageBufferObjStdLayoutChunk.h"
  65 #include "OSGUniformBufferObjChunk.h"
  66 #include "OSGUniformBufferObjStd140Chunk.h"
  67
  68 OSG_BEGIN_NAMESPACE
  69
  70 // Documentation for this class is emited in the
  71 // OSGComputeShaderAlgorithmBase.cpp file.
  72 // To modify it, please change the .fcd file (OSGComputeShaderAlgorithm.fcd)
  73 // and regenerate the base file.
  74
  75 UInt32 ComputeShaderAlgorithm::_arbComputeShader =
  76     Window::invalidExtensionID;
  77
  78 UInt32 ComputeShaderAlgorithm::_arbComputeVariableGroupSize =
  79     Window::invalidExtensionID;
  80
  81 UInt32 ComputeShaderAlgorithm::_arbShaderImageLoadStore =
  82     Window::invalidExtensionID;
  83
  84 UInt32 ComputeShaderAlgorithm:: FuncIdDispatchCompute =
  85     Window::invalidFunctionID;
  86
  87 UInt32 ComputeShaderAlgorithm:: FuncIdDispatchComputeGroupSize =
  88     Window::invalidFunctionID;
  89
  90 UInt32 ComputeShaderAlgorithm:: FuncIdMemoryBarrier =
  91     Window::invalidFunctionID;
  92
  93 /*-------------------------------------------------------------------------*/
  94 /*                               Sync                                      */
  95
  96 void ComputeShaderAlgorithm::changed(ConstFieldMaskArg whichField,
  97                                      UInt32            origin,
  98                                      BitVector         details)
  99 {
 100     Inherited::changed(whichField, origin, details);
 101 }
 102
 103 /*-------------------------------------------------------------------------*/
 104 /*                               Dump                                      */
 105
 106 void ComputeShaderAlgorithm::dump(
 107           UInt32    OSG_CHECK_ARG(uiIndent),
 108     const BitVector OSG_CHECK_ARG(bvFlags )) const
 109 {
 110     SLOG << "Dump ComputeShaderAlgorithm NI" << std::endl;
 111 }
 112
 113 /*-------------------------------------------------------------------------*/
 114 /*                            Constructors                                 */
 115
 116 ComputeShaderAlgorithm::ComputeShaderAlgorithm(void) :
 117     Inherited()
 118 {
 119 }
 120
 121 ComputeShaderAlgorithm::ComputeShaderAlgorithm(
 122     const ComputeShaderAlgorithm &source) :
 123
 124     Inherited(source)
 125 {
 126 }
 127
 128 /*-------------------------------------------------------------------------*/
 129 /*                             Destructor                                  */
 130
 131 ComputeShaderAlgorithm::~ComputeShaderAlgorithm(void)
 132 {
 133 }
 134
 135 /*-------------------------------------------------------------------------*/
 136 /*                                Draw                                     */
 137
 138 Action::ResultE ComputeShaderAlgorithm::renderEnter(Action *pAction)
 139 {
 140     return Action::Continue;
 141 }
 142
 143 Action::ResultE ComputeShaderAlgorithm::renderLeave(Action *pAction)
 144 {
 145     return Action::Continue;
 146 }
 147
 148 void ComputeShaderAlgorithm::execute(HardwareContext *pContext,
 149                                      DrawEnv         *pEnv    )
 150 {
 151     Window *pWin = pEnv->getWindow();
 152
 153     if(!pWin->hasExtOrVersion(_arbComputeShader, 0x0403, 0xFFFF))
 154     {
 155         FWARNING(("OpenGL compute shader is not supported, couldn't find "
 156                   "extension 'GL_ARB_compute_shader'!\n"));
 157
 158         return;
 159     }
 160
 161     if(_sfUseVariableWorkGroupSize.getValue() == true &&
 162        !pWin->hasExtOrVersion(_arbComputeVariableGroupSize, 0x0403, 0xFFFF))
 163     {
 164         FWARNING(("OpenGL variable group size is not supported, couldn't find "
 165                     "extension 'GL_ARB_compute_variable_group_size'!\n"));
 166
 167         return;
 168     }
 169
 170     if(_sfUseMemoryBarrier.getValue() == true &&
 171        !pWin->hasExtOrVersion(_arbShaderImageLoadStore, 0x0402))
 172     {
 173         FWARNING(("OpenGL memory barrier is not supported, couldn't find "
 174                     "extension 'GL_ARB_shader_image_load_store'!\n"));
 175
 176         return;
 177     }
 178
 179     if(_sfComputeShader.getValue() == NULL)
 180     {
 181         return;
 182     }
 183
 184     MFTextureImagesType::const_iterator tIt  = _mfTextureImages.begin();
 185     MFTextureImagesType::const_iterator tEnd = _mfTextureImages.end  ();
 186
 187     UInt32 uiSlot = 0;
 188
 189     for(; tIt != tEnd; ++tIt, ++uiSlot)
 190     {
 191         if((*tIt) != NULL)
 192         {
 193             (*tIt)->activate(pEnv, uiSlot);
 194         }
 195     }
 196
 197     _sfComputeShader.getValue()->activate(pEnv, 0);
 198
 199     //
 200     // Buffer objects might introspect the shader code. Therefore their activation must
 201     // happen after the activation of the shader itself.
 202     //
 203     if (_sfChunkMaterial.getValue() != NULL)
 204     {
 205         const MFUnrecStateChunkPtr *chunks = _sfChunkMaterial.getValue()->getMFChunks();
 206         const MFInt32              *slots  = _sfChunkMaterial.getValue()->getMFSlots ();
 207
 208         for(SizeT i = 0; i < chunks->size(); ++i)
 209         {
 210             StateChunk* chunk = (*chunks)[i];
 211             if (chunk != NULL)
 212             {
 213                 UInt32 slot = (*slots)[i];
 214
 215                 if ( chunk->getType().isDerivedFrom(ShaderStorageBufferObjChunk::getClassType())
 216                   || chunk->getType().isDerivedFrom(ShaderStorageBufferObjRefChunk::getClassType())
 217                   || chunk->getType().isDerivedFrom(ShaderStorageBufferObjStdLayoutChunk::getClassType())
 218                   || chunk->getType().isDerivedFrom(UniformBufferObjChunk::getClassType())
 219                   || chunk->getType().isDerivedFrom(UniformBufferObjStd140Chunk::getClassType())
 220                   || chunk->getType().isDerivedFrom(TextureImageChunk::getClassType())
 221                     )
 222                 {
 223                     chunk->activate(pEnv, slot);
 224                 }
 225             }
 226         }
 227     }
 228
 229     if (_sfUseVariableWorkGroupSize.getValue() == true)
 230     {
 231         OSGGETGLFUNCBYID_GL4(glDispatchComputeGroupSizeARB,
 232                              osgGlDispatchComputeGroupSizeARB,
 233                              ComputeShaderAlgorithm::FuncIdDispatchComputeGroupSize,
 234                              pWin);
 235
 236         osgGlDispatchComputeGroupSizeARB(_sfDispatchConfig.getValue()[0],
 237                                          _sfDispatchConfig.getValue()[1],
 238                                          _sfDispatchConfig.getValue()[2],
 239                                          _sfWorkGroupSize.getValue()[0],
 240                                          _sfWorkGroupSize.getValue()[1],
 241                                          _sfWorkGroupSize.getValue()[2]);
 242     }
 243     else
 244     {
 245         OSGGETGLFUNCBYID_GL4(glDispatchCompute,
 246                              osgGlDispatchCompute,
 247                              ComputeShaderAlgorithm::FuncIdDispatchCompute,
 248                              pWin);
 249
 250         osgGlDispatchCompute(_sfDispatchConfig.getValue()[0],
 251                              _sfDispatchConfig.getValue()[1],
 252                              _sfDispatchConfig.getValue()[2]);
 253     }
 254
 255     if (_sfUseMemoryBarrier.getValue() == true)
 256     {
 257         OSGGETGLFUNCBYID_GL4(glMemoryBarrier,
 258                         osgGlMemoryBarrier,
 259                         ComputeShaderAlgorithm::FuncIdMemoryBarrier,
 260                         pWin);
 261
 262         osgGlMemoryBarrier(_sfMemoryBarrier.getValue());
 263     }
 264
 265     _sfComputeShader.getValue()->deactivate(pEnv, 0);
 266
 267     if (_sfChunkMaterial.getValue() != NULL)
 268     {
 269         const MFUnrecStateChunkPtr *chunks = _sfChunkMaterial.getValue()->getMFChunks();
 270         const MFInt32              *slots  = _sfChunkMaterial.getValue()->getMFSlots ();
 271
 272         for(SizeT i = 0; i < chunks->size(); ++i)
 273         {
 274             StateChunk* chunk = (*chunks)[i];
 275             if (chunk != NULL)
 276             {
 277                 UInt32 slot = (*slots)[i];
 278
 279                 if ( chunk->getType().isDerivedFrom(ShaderStorageBufferObjChunk::getClassType())
 280                   || chunk->getType().isDerivedFrom(ShaderStorageBufferObjRefChunk::getClassType())
 281                   || chunk->getType().isDerivedFrom(ShaderStorageBufferObjStdLayoutChunk::getClassType())
 282                   || chunk->getType().isDerivedFrom(UniformBufferObjChunk::getClassType())
 283                   || chunk->getType().isDerivedFrom(UniformBufferObjStd140Chunk::getClassType())
 284                   || chunk->getType().isDerivedFrom(TextureImageChunk::getClassType())
 285                     )
 286                 {
 287                     chunk->deactivate(pEnv, slot);
 288                 }
 289             }
 290         }
 291     }
 292
 293     tIt    = _mfTextureImages.begin();
 294     uiSlot = 0;
 295
 296     for(; tIt != tEnd; ++tIt, ++uiSlot)
 297     {
 298         if((*tIt) != NULL)
 299         {
 300             (*tIt)->deactivate(pEnv, uiSlot);
 301         }
 302     }
 303
 304
 305 }
 306
 307 /*-------------------------------------------------------------------------*/
 308 /*                               loading                                   */
 309
 310 /*-------------------------------------------------------------------------*/
 311 /*                               Init                                      */
 312
 313 void ComputeShaderAlgorithm::initMethod(InitPhase ePhase)
 314 {
 315     Inherited::initMethod(ePhase);
 316
 317     if(ePhase == TypeObject::SystemPost)
 318     {
 319         _arbComputeShader =
 320             Window::registerExtension("GL_ARB_compute_shader");
 321
 322         _arbComputeVariableGroupSize =
 323             Window::registerExtension("GL_ARB_compute_variable_group_size");
 324
 325         _arbShaderImageLoadStore =
 326             Window::registerExtension("GL_ARB_shader_image_load_store");
 327
 328         FuncIdDispatchCompute =
 329             Window::registerFunction
 330             (OSG_DLSYM_UNDERSCORE"glDispatchCompute",
 331              _arbComputeShader);
 332
 333         FuncIdDispatchComputeGroupSize =
 334             Window::registerFunction
 335             (OSG_DLSYM_UNDERSCORE"glDispatchComputeGroupSizeARB",
 336              _arbComputeVariableGroupSize);
 337
 338         FuncIdMemoryBarrier =
 339             Window::registerFunction
 340             (OSG_DLSYM_UNDERSCORE"glMemoryBarrier",
 341              _arbShaderImageLoadStore);
 342     }
 343 }
 344
 345 OSG_END_NAMESPACE