FGFS-4.1/OpenSceneGraph
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Pulled in latest changes from 3.6 branch

Browse Source
This commit is contained in:
Robert Osfield 2018-04-07 18:14:57 +01:00
parent 159f0fd584
commit e884df59c7
9 changed files with 113 additions and 104 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
AUTHORS.txt
View File

@ -5,6 +5,7 @@ OpenSceneGraph Library 3.7.0
Firstname Surname
-----------------
Robert Osfield
Don Burns
Stephan Huber
Paul Martz
Laurens Voerman
@ -176,7 +177,6 @@ John Ivar
Gustav Haapalahti
Erik den Dekker
Emmanuel Roche
Don Burns
Domenico Mangieri
Daniel Larimer
Colin Dunlop

61
NEWS.txt
View File

@ -2,55 +2,60 @@ OSG News
========
OpenSceneGraph 3.6 release
PERTHSHIRE, Scotland - 24th March 2018 - OpenSceneGraph Professional Services announces the release of OpenSceneGraph 3.6, the industry's leading open-source scene graph technology, designed to accelerate application development and improve 3D graphics performance. OpenSceneGraph 3.6 written entirely in Standard C++ and built upon OpenGL, offers developers working in the visual simulation, game development, virtual reality, scientific visualization and modeling markets - a real-time visualization tool which eclipses commercial scene graph toolkits in functionality, stability and performance. OpenSceneGraph 3.6 runs on all Microsoft Windows platforms, Apple OS/X, IOS, GNU/Linux, Android, IRIX, Solaris, HP-UX, AIX and FreeBSD operating systems.
PERTHSHIRE, Scotland - 7th April 2018 - OpenSceneGraph Professional Services announces the release of OpenSceneGraph 3.6.0, the industry's leading open-source scene graph technology, designed to accelerate application development and improve 3D graphics performance. The OpenSceneGraph is written entirely in Standard C++ and built upon OpenGL (1.2 to 4.6) and OpenGL ES (1.0 to 3.0), and offers developers working in the visual simulation, game development, virtual reality, scientific visualization and modeling markets. OpenSceneGraph 3.6 runs on all Microsoft Windows platforms, Apple OS/X, iOS, GNU/Linux, Android, Solaris, HP-UX, AIX and FreeBSD operating systems.
Updates include:
* CoverityScan testing introduced, fixes bring defect density to 0.0.
* OpenThreads::Affinity introduced to enable setting of processor affinity on viewer and database threads
* osgText rewritten to improve visual quality, add signed distance field support and full GLES2/3 and GL3/4 support
* Added VertexArrayObject support, enable full OpenGL Core Profile support under OSX.
* Added OpenCASCADE plugin
* Added STEP (.stp) plugin
* Improvements to FBX and COLLADA loaders
* Improvements to gles plugin to provide better Sketchfab support
* Added osgemscripten example
* Improvements to osgAnimation
* NodeVisitor ValueMap for storing values that can be stored and accessed across frames, such as update, event and cull traversals
* ShapeDrawable rewritten as an osg::Geometry to improve performance and flexibility
* Added osg::MultiDrawArrays support
* Added osgdeferred example that illustrates how to implement deferred rendering
* Added MultiDrawIndirect support
* Moved glDispatchCompute control out of osg::Program into a dedicated osg::DispatchCompute class to improve control of compute shaders
* KdTree support added for PolytopeIntersector, and ability to work with points, lines and polygons
* osgQt has been moved out to it's own dedicated osgQt github repository
* CMake build support for iOS bitcode builds
* CoverityScan testing introduced, fixes bring defect density to 0.0 per 1,0000 lines of code!
* Support for Codedoc automated documentation
* Support for Travis automated build system
* OpenThreads::Affinity & DatabasePager::setProcessorAffinity
* Improvements to osgAnimation
* Improvements to gles plugin to provide better Sketchfab support
* NodeVisit ValueMap for storing values that can be stored and accessed across frames
* Improvements to FBX and COLLADA loaders
* osg::MultiDrawArrays
* osgText rewritten to improve visual quality, add signed distance field support and full GLES2/3 and GL3/4 supprt
* osgderred example that illustrates how to implement deferred rendering
* Vertex Array Object support
* ShadpeDrawable implemented as an osg::Geometry to improve performance and flexibility
* New OpenCASCADE plugin
* New STEP (.stp) plugin
* KdTree support added for PolytopeIntersector, and ability to work with points, lines and polygons
* osgQt has been moved out to it's own dedicated
* Added osgemscripten example
* Moved ComputeDispatch control out of osg::Program into a dedicated osg::ComputeDispatch class to improve flexibility of compute shaders
* CMake build support for iOS bitcode builds
* Added MultiDrawIndirect support
Downloads and Licensing:
OpenSceneGraph is open-source, so full source code is provided, and can be copied, modified and used free of charge for commercial and non-commercial use. Access to the source allows end users greater flexibility in how they develop, debug and deploy their applications. They gain productivity and freedom by being able to leverage the tool chain in accordance with their own release cycles. Downloads of binaries and source can be found in the Downloads section of the openscenegraph.org website.
OpenSceneGraph is open-source, so full source code is provided, and can be copied, modified and used free of charge for commercial and non-commercial use. Access to the source allows end users greater flexibility in how they develop, debug and deploy their applications. They gain productivity and freedom by being able to leverage the tool chain in accordance with their own release cycles. Downloads of binaries and source can be found at http://www.openscenegraph.org/index.php/download-section/stable-releases and at our github repository https://github.com/openscenegraph/OpenSceneGraph/.
OpenSceneGraph is released under the OpenSceneGraph Public License, which is based on the Lesser GNU Public License (LGPL), permitting the software to be used free of charge across the full spectrum of commercial and open-source applications. Furthermore, it allows both static and dynamic linking of the OpenSceneGraph libraries without restricting the licensing of the user's software.
Professional support and services
OpenSceneGraph is released under the OpenSceneGraph Public License, which is based on the Lesser GNU Public License (LGPL), permitting the software to be used free of charge across the full spectrum of commercial and open-source applications. Furthermore, it allows both static and dynamic linking of the OpenSceneGraph libraries without restricting the licensing of the user's software. Further details http://www.openscenegraph.org/index.php/about/licensing
OpenSceneGraph project is backed up with professional services by OpenSceneGraph Professional Services, based in Scotland, and a range of Contractors from around the world. Services available include:
Professional support and services:
OpenSceneGraph project is backed up with professional services by OpenSceneGraph Professional Services, based in Scotland, and a range of Contractors from around the world http://www.openscenegraph.org/index.php/support/professional-support. For enquires email robert@openscenegraph.com. Services available include:
Confidential Professional Support
Bespoke development
Consultancy
Training
Community support and contributions:
The diverse and growing community of over 5000 developers is centred around the public osg-users mailing list/forum, where members discuss how best to use OpenSceneGraph, provide mutual support, and coordinate development of new features and bug fixes. Members of this community come from many different countries with backgrounds ranging from some of the world's largest aerospace companies, game companies, and visual simulation specialists to university researchers, students and hobbyists.
The OpenSceneGraph project owes a great deal to the community for its development and support, in particular we wish to thank the 569 individuals from around the world that have directly contributed to the development and refinement of the OpenSceneGraph code base.
The OpenSceneGraph project owes a great deal to the community for its development and support, in particular we wish to thank the 568 individuals from around the world that have directly contributed to the development and refinement of the OpenSceneGraph code base.
OpenSceneGraph 3.4 release introduces shader composition, new osgUI library, displacement mapping, volume rendering, lua scripting support and much more
PERTHSHIRE, Scotland - 12th August 2015 - OpenSceneGraph Professional Services announces the release of OpenSceneGraph 3.4, the industry's leading open-source scene graph technology, designed to accelerate application development and improve 3D graphics performance. OpenSceneGraph 3.4 written entirely in Standard C++ and built upon OpenGL, offers developers working in the visual simulation, game development, virtual reality, scientific visualization and modeling markets - a real-time visualization tool which eclipses commercial scene graph toolkits in functionality, stability and performance. OpenSceneGraph 3.4 runs on all Microsoft Windows platforms, Apple OS/X, IOS, GNU/Linux, Android, IRIX, Solaris, HP-UX, AIX and FreeBSD operating systems.
PERTHSHIRE, Scotland - 12th August 2015 - OpenSceneGraph Professional Services announces the release of OpenSceneGraph 3.4, the industry's leading open-source scene graph technology, designed to accelerate application development and improve 3D graphics performance. OpenSceneGraph 3.4 written entirely in Standard C++ and built upon OpenGL, offers developers working in the visual simulation, game development, virtual reality, scientific visualization and modeling markets - a real-time visualization tool which eclipses commercial scene graph toolkits in functionality, stability and performance. OpenSceneGraph 3.4 runs on all Microsoft Windows platforms, Apple OS/X, iOS, GNU/Linux, Android, IRIX, Solaris, HP-UX, AIX and FreeBSD operating systems.
Updates include:
* New #pragma(tic) composition shader functionality built into the core OSG that provides a easy to use yet flexible scheme for controlling and composing shaders at runtime levering GLSL support for #define and #pragma.
@ -87,7 +92,7 @@ The OpenSceneGraph project owes a great deal to the community for its developmen
= !OpenSceneGraph 3.2 release improves support iOS and Android, supports a range of new OpenGL features much more.
PERTHSHIRE, Scotland - 24th July 2013 - !OpenSceneGraph Professional Services announces the release of !OpenSceneGraph 3.2, the industry's leading open-source scene graph technology, designed to accelerate application development and improve 3D graphics performance. !OpenSceneGraph 3.2 written entirely in Standard C++ and built upon OpenGL, offers developers working in the visual simulation, game development, virtual reality, scientific visualization and modeling markets - a real-time visualization tool which eclipses commercial scene graph toolkits in functionality, stability and performance. !OpenSceneGraph 3.2 runs on all Microsoft Windows platforms, Apple OS/X, IOS, GNU/Linux, Android, IRIX, Solaris, HP-UX, AIX and FreeBSD operating systems.
PERTHSHIRE, Scotland - 24th July 2013 - !OpenSceneGraph Professional Services announces the release of !OpenSceneGraph 3.2, the industry's leading open-source scene graph technology, designed to accelerate application development and improve 3D graphics performance. !OpenSceneGraph 3.2 written entirely in Standard C++ and built upon OpenGL, offers developers working in the visual simulation, game development, virtual reality, scientific visualization and modeling markets - a real-time visualization tool which eclipses commercial scene graph toolkits in functionality, stability and performance. !OpenSceneGraph 3.2 runs on all Microsoft Windows platforms, Apple OS/X, iOS, GNU/Linux, Android, IRIX, Solaris, HP-UX, AIX and FreeBSD operating systems.
=== Open-source development delivers industry-leading features and performance ===
The !OpenSceneGraph 3.2 release is the culmination of 14 years of work by the open-source community that has grown up around the project. The real-time graphics industry and academia embraced it from the very beginning, deploying it in real-world applications, and actively participating in its development, testing and refinement. The end result is a high-quality library with a feature set relevant to application developers' needs in both the desktop and mobile space.
@ -138,7 +143,7 @@ The !OpenSceneGraph project owes a great deal to the community for its developme
= !OpenSceneGraph 3.0 release adds support OpenGL ES 1.1, OpenGL ES 2.0, OpenGL 3.x to 4.0, support for Andoid and IOS platforms and much more.
PERTHSHIRE, Scotland - 28th June 2011 - !OpenSceneGraph Professional Services announces the release of !OpenSceneGraph 3.0, the industry's leading open-source scene graph technology, designed to accelerate application development and improve 3D graphics performance. !OpenSceneGraph 3.0 written entirely in Standard C++ and built upon OpenGL, offers developers working in the visual simulation, game development, virtual reality, scientific visualization and modeling markets - a real-time visualization tool which eclipses commercial scene graph toolkits in functionality, stability and performance. !OpenSceneGraph 3.0 runs on all Microsoft Windows platforms, Apple OS/X, IOS, GNU/Linux, Android, IRIX, Solaris, HP-UX, AIX and FreeBSD operating systems.
PERTHSHIRE, Scotland - 28th June 2011 - !OpenSceneGraph Professional Services announces the release of !OpenSceneGraph 3.0, the industry's leading open-source scene graph technology, designed to accelerate application development and improve 3D graphics performance. !OpenSceneGraph 3.0 written entirely in Standard C++ and built upon OpenGL, offers developers working in the visual simulation, game development, virtual reality, scientific visualization and modeling markets - a real-time visualization tool which eclipses commercial scene graph toolkits in functionality, stability and performance. !OpenSceneGraph 3.0 runs on all Microsoft Windows platforms, Apple OS/X, iOS, GNU/Linux, Android, IRIX, Solaris, HP-UX, AIX and FreeBSD operating systems.
=== Open-source development delivers industry-leading features and performance ===
The !OpenSceneGraph 3.0 release is the culmination of 12 years of work by the lead developers and the open-source community that has grown up around the project. The real-time graphics industry and academia embraced it from the very beginning, deploying it in real-world applications, and actively participating in its development, testing and refinement. The end result is a high-quality library with a feature set relevant to application developers' needs.

10
examples/osgSSBO/osgSSBO.cpp
View File

@ -10,7 +10,7 @@
#include <osg/StateAttributeCallback>
#include <osg/Texture2D>
#include <osg/Geometry>
#include <osg/ComputeDispatch>
#include <osg/DispatchCompute>
#include <osgDB/ReadFile>
#include <osgGA/StateSetManipulator>
#include <osgViewer/Viewer>
@ -167,7 +167,7 @@ class ComputeNode : public osg::PositionAttitudeTransform
public:
osg::ref_ptr<osg::ComputeDispatch> _computeDispatch;
osg::ref_ptr<osg::DispatchCompute> _DispatchCompute;
osg::ref_ptr<osg::Program> _computeProgram;
osg::ref_ptr<osg::Shader> _computeShader; //compute and write position data in SSBO
@ -205,8 +205,8 @@ public:
_vertexShaderSourcePath = "shaders/osgssboVertexShader.vs";
_geometryShaderSourcePath = "shaders/osgssboGeometryShader.gs";
_fragmentShaderSourcePath = "shaders/osgssboFragmentShader.fs";
_computeDispatch=new osg::ComputeDispatch();
addChild(_computeDispatch);
_DispatchCompute=new osg::DispatchCompute();
addChild(_DispatchCompute);
}
};
@ -625,7 +625,7 @@ void ComputeNode::initComputingSetup()
{
_computeProgram = new osg::Program;
_computeDispatch->setComputeGroups((NUM_ELEMENTS_X / WORK_GROUP_SIZE) <= 1 ? 1 : (NUM_ELEMENTS_X / WORK_GROUP_SIZE), (NUM_ELEMENTS_Y / WORK_GROUP_SIZE) <= 1 ? 1 : (NUM_ELEMENTS_Y / WORK_GROUP_SIZE), 1);
_DispatchCompute->setComputeGroups((NUM_ELEMENTS_X / WORK_GROUP_SIZE) <= 1 ? 1 : (NUM_ELEMENTS_X / WORK_GROUP_SIZE), (NUM_ELEMENTS_Y / WORK_GROUP_SIZE) <= 1 ? 1 : (NUM_ELEMENTS_Y / WORK_GROUP_SIZE), 1);
_computeShader = osgDB::readRefShaderFile(osg::Shader::COMPUTE, _computeShaderSourcePath);
_computeProgram->addShader(_computeShader.get());

4
examples/osgcomputeshaders/osgcomputeshaders.cpp
View File

@ -21,7 +21,7 @@
#include <osg/Texture2D>
#include <osg/BindImageTexture>
#include <osg/ComputeDispatch>
#include <osg/DispatchCompute>
#include <osg/Geode>
#include <osgDB/ReadFile>
#include <osgGA/StateSetManipulator>
@ -65,7 +65,7 @@ int main( int argc, char** argv )
// Create a node for outputting to the texture.
// It is OK to have just an empty node here, but seems inbuilt uniforms like osg_FrameTime won't work then.
// TODO: maybe we can have a custom drawable which also will implement glMemoryBarrier?
osg::ref_ptr<osg::Node> sourceNode = new osg::ComputeDispatch(512/16, 512/16, 1 );
osg::ref_ptr<osg::Node> sourceNode = new osg::DispatchCompute(512/16, 512/16, 1 );
sourceNode->setDataVariance( osg::Object::DYNAMIC );
sourceNode->getOrCreateStateSet()->setAttributeAndModes( computeProg.get() );
sourceNode->getOrCreateStateSet()->addUniform( new osg::Uniform("targetTex", (int)0) );

55
include/osg/ComputeDispatch
View File

@ -1,55 +0,0 @@
/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2014 Robert Osfield
* Copyright (C) 2017 Julien Valentin
*
* This library is open source and may be redistributed and/or modified under
* the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
* (at your option) any later version. The full license is in LICENSE file
* included with this distribution, and on the openscenegraph.org website.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* OpenSceneGraph Public License for more details.
*/
#ifndef OSG_COMPUTEDISPATCH
#define OSG_COMPUTEDISPATCH 1
#include <osg/Export>
#include <osg/Geometry>
namespace osg{
class OSG_EXPORT ComputeDispatch : public osg::Drawable
{
public:
ComputeDispatch(GLint numGroupsX=0, GLint numGroupsY=0, GLint numGroupsZ=0):
Drawable(),
_numGroupsX(numGroupsX),
_numGroupsY(numGroupsY),
_numGroupsZ(numGroupsZ)
{}
ComputeDispatch(const ComputeDispatch&,const osg::CopyOp& copyop=osg::CopyOp::SHALLOW_COPY);
META_Node(osg, ComputeDispatch);
virtual void compileGLObjects(RenderInfo&) const {}
virtual VertexArrayState* createVertexArrayStateImplememtation(RenderInfo&) const { return 0; }
virtual void drawImplementation(RenderInfo& renderInfo) const;
/** Set compute shader work groups */
void setComputeGroups( GLint numGroupsX, GLint numGroupsY, GLint numGroupsZ ) { _numGroupsX=numGroupsX; _numGroupsY=numGroupsY; _numGroupsZ=numGroupsZ; }
/** Get compute shader work groups */
void getComputeGroups( GLint& numGroupsX, GLint& numGroupsY, GLint& numGroupsZ ) const{ numGroupsX=_numGroupsX; numGroupsY=_numGroupsY; numGroupsZ=_numGroupsZ; }
protected:
GLint _numGroupsX, _numGroupsY, _numGroupsZ;
};
}
#endif

59
include/osg/DispatchCompute Normal file
View File

@ -0,0 +1,59 @@
/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2014 Robert Osfield
* Copyright (C) 2017 Julien Valentin
*
* This library is open source and may be redistributed and/or modified under
* the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
* (at your option) any later version. The full license is in LICENSE file
* included with this distribution, and on the openscenegraph.org website.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* OpenSceneGraph Public License for more details.
*/
#ifndef OSG_DispatchCompute
#define OSG_DispatchCompute 1
#include <osg/Export>
#include <osg/Geometry>
namespace osg
{
/** Wrapper around glDispatchCompute.*/
class OSG_EXPORT DispatchCompute : public osg::Drawable
{
public:
DispatchCompute(GLint numGroupsX=0, GLint numGroupsY=0, GLint numGroupsZ=0):
Drawable(),
_numGroupsX(numGroupsX),
_numGroupsY(numGroupsY),
_numGroupsZ(numGroupsZ)
{}
DispatchCompute(const DispatchCompute&,const osg::CopyOp& copyop=osg::CopyOp::SHALLOW_COPY);
META_Node(osg, DispatchCompute);
virtual void compileGLObjects(RenderInfo&) const {}
virtual VertexArrayState* createVertexArrayStateImplememtation(RenderInfo&) const { return 0; }
virtual void drawImplementation(RenderInfo& renderInfo) const;
/** Set compute shader work groups */
void setComputeGroups( GLint numGroupsX, GLint numGroupsY, GLint numGroupsZ ) { _numGroupsX=numGroupsX; _numGroupsY=numGroupsY; _numGroupsZ=numGroupsZ; }
/** Get compute shader work groups */
void getComputeGroups( GLint& numGroupsX, GLint& numGroupsY, GLint& numGroupsZ ) const{ numGroupsX=_numGroupsX; numGroupsY=_numGroupsY; numGroupsZ=_numGroupsZ; }
protected:
GLint _numGroupsX, _numGroupsY, _numGroupsZ;
};
}
#endif

4
src/osg/CMakeLists.txt
View File

@ -58,7 +58,7 @@ SET(TARGET_H
${HEADER_PATH}/ColorMaski
${HEADER_PATH}/ColorMatrix
${HEADER_PATH}/ComputeBoundsVisitor
${HEADER_PATH}/ComputeDispatch
${HEADER_PATH}/DispatchCompute
${HEADER_PATH}/ContextData
${HEADER_PATH}/ConvexPlanarOccluder
${HEADER_PATH}/ConvexPlanarPolygon
@ -276,7 +276,7 @@ SET(TARGET_SRC
ColorMaski.cpp
ColorMatrix.cpp
ComputeBoundsVisitor.cpp
ComputeDispatch.cpp
DispatchCompute.cpp
ContextData.cpp
ConvexPlanarOccluder.cpp
ConvexPlanarPolygon.cpp

6
src/osg/ComputeDispatch.cpp → src/osg/DispatchCompute.cpp
View File

@ -1,8 +1,8 @@
#include <osg/ComputeDispatch>
#include <osg/DispatchCompute>
using namespace osg;
ComputeDispatch::ComputeDispatch(const ComputeDispatch&o,const osg::CopyOp& copyop):
DispatchCompute::DispatchCompute(const DispatchCompute&o,const osg::CopyOp& copyop):
Drawable(o,copyop),
_numGroupsX(o._numGroupsX),
_numGroupsY(o._numGroupsY),
@ -10,7 +10,7 @@ ComputeDispatch::ComputeDispatch(const ComputeDispatch&o,const osg::CopyOp& copy
{
}
void ComputeDispatch::drawImplementation(RenderInfo& renderInfo) const
void DispatchCompute::drawImplementation(RenderInfo& renderInfo) const
{
renderInfo.getState()->get<GLExtensions>()->glDispatchCompute(_numGroupsX, _numGroupsY, _numGroupsZ);
}

16
src/osgWrappers/serializers/osg/ComputeDispatch.cpp → src/osgWrappers/serializers/osg/DispatchCompute.cpp
View File

@ -1,17 +1,17 @@
#include <osg/ComputeDispatch>
#include <osg/DispatchCompute>
#include <osgDB/ObjectWrapper>
#include <osgDB/InputStream>
#include <osgDB/OutputStream>
// _numGroupsX/Y/Z
static bool checkComputeGroups( const osg::ComputeDispatch& attr )
static bool checkComputeGroups( const osg::DispatchCompute& attr )
{
GLint numX = 0, numY = 0, numZ = 0;
attr.getComputeGroups( numX, numY, numZ );
return numX>0 && numY>0 && numZ>0;
}
static bool readComputeGroups( osgDB::InputStream& is, osg::ComputeDispatch& attr )
static bool readComputeGroups( osgDB::InputStream& is, osg::DispatchCompute& attr )
{
GLint numX = 0, numY = 0, numZ = 0;
is >> numX >> numY >> numZ;
@ -19,7 +19,7 @@ static bool readComputeGroups( osgDB::InputStream& is, osg::ComputeDispatch& att
return true;
}
static bool writeComputeGroups( osgDB::OutputStream& os, const osg::ComputeDispatch& attr )
static bool writeComputeGroups( osgDB::OutputStream& os, const osg::DispatchCompute& attr )
{
GLint numX = 0, numY = 0, numZ = 0;
attr.getComputeGroups( numX, numY, numZ );
@ -27,10 +27,10 @@ static bool writeComputeGroups( osgDB::OutputStream& os, const osg::ComputeDispa
return true;
}
REGISTER_OBJECT_WRAPPER( ComputeDispatch,
new osg::ComputeDispatch,
osg::ComputeDispatch,
"osg::Object osg::Node osg::Drawable osg::ComputeDispatch" )
REGISTER_OBJECT_WRAPPER( DispatchCompute,
new osg::DispatchCompute,
osg::DispatchCompute,
"osg::Object osg::Node osg::Drawable osg::DispatchCompute" )
{
ADD_USER_SERIALIZER( ComputeGroups ); // _numGroupsX/Y/Z
}