From e884df59c7d024b318f76e9b304840bb8e2e7ab1 Mon Sep 17 00:00:00 2001 From: Robert Osfield Date: Sat, 7 Apr 2018 18:14:57 +0100 Subject: [PATCH] Pulled in latest changes from 3.6 branch --- AUTHORS.txt | 2 +- NEWS.txt | 61 ++++++++++--------- examples/osgSSBO/osgSSBO.cpp | 10 +-- .../osgcomputeshaders/osgcomputeshaders.cpp | 4 +- include/osg/ComputeDispatch | 55 ----------------- include/osg/DispatchCompute | 59 ++++++++++++++++++ src/osg/CMakeLists.txt | 4 +- ...omputeDispatch.cpp => DispatchCompute.cpp} | 6 +- ...omputeDispatch.cpp => DispatchCompute.cpp} | 16 ++--- 9 files changed, 113 insertions(+), 104 deletions(-) delete mode 100644 include/osg/ComputeDispatch create mode 100644 include/osg/DispatchCompute rename src/osg/{ComputeDispatch.cpp => DispatchCompute.cpp} (59%) rename src/osgWrappers/serializers/osg/{ComputeDispatch.cpp => DispatchCompute.cpp} (66%) diff --git a/AUTHORS.txt b/AUTHORS.txt index 75de9d694..b34d733cf 100644 --- a/AUTHORS.txt +++ b/AUTHORS.txt @@ -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 diff --git a/NEWS.txt b/NEWS.txt index 292b79622..769e61516 100644 --- a/NEWS.txt +++ b/NEWS.txt @@ -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. diff --git a/examples/osgSSBO/osgSSBO.cpp b/examples/osgSSBO/osgSSBO.cpp index 5ce2ec07c..ca8f80d55 100644 --- a/examples/osgSSBO/osgSSBO.cpp +++ b/examples/osgSSBO/osgSSBO.cpp @@ -10,7 +10,7 @@ #include #include #include -#include +#include #include #include #include @@ -167,7 +167,7 @@ class ComputeNode : public osg::PositionAttitudeTransform public: - osg::ref_ptr _computeDispatch; + osg::ref_ptr _DispatchCompute; osg::ref_ptr _computeProgram; osg::ref_ptr _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()); diff --git a/examples/osgcomputeshaders/osgcomputeshaders.cpp b/examples/osgcomputeshaders/osgcomputeshaders.cpp index fa75987bf..c0b48445d 100644 --- a/examples/osgcomputeshaders/osgcomputeshaders.cpp +++ b/examples/osgcomputeshaders/osgcomputeshaders.cpp @@ -21,7 +21,7 @@ #include #include -#include +#include #include #include #include @@ -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 sourceNode = new osg::ComputeDispatch(512/16, 512/16, 1 ); + osg::ref_ptr 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) ); diff --git a/include/osg/ComputeDispatch b/include/osg/ComputeDispatch deleted file mode 100644 index 5e0ac6ffe..000000000 --- a/include/osg/ComputeDispatch +++ /dev/null @@ -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 - -#include - -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 - diff --git a/include/osg/DispatchCompute b/include/osg/DispatchCompute new file mode 100644 index 000000000..adacb2001 --- /dev/null +++ b/include/osg/DispatchCompute @@ -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 + +#include + +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 + diff --git a/src/osg/CMakeLists.txt b/src/osg/CMakeLists.txt index 37a3fbf8d..425949b6a 100644 --- a/src/osg/CMakeLists.txt +++ b/src/osg/CMakeLists.txt @@ -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 diff --git a/src/osg/ComputeDispatch.cpp b/src/osg/DispatchCompute.cpp similarity index 59% rename from src/osg/ComputeDispatch.cpp rename to src/osg/DispatchCompute.cpp index c689bd95b..a68c1696d 100644 --- a/src/osg/ComputeDispatch.cpp +++ b/src/osg/DispatchCompute.cpp @@ -1,8 +1,8 @@ -#include +#include 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()->glDispatchCompute(_numGroupsX, _numGroupsY, _numGroupsZ); } diff --git a/src/osgWrappers/serializers/osg/ComputeDispatch.cpp b/src/osgWrappers/serializers/osg/DispatchCompute.cpp similarity index 66% rename from src/osgWrappers/serializers/osg/ComputeDispatch.cpp rename to src/osgWrappers/serializers/osg/DispatchCompute.cpp index d77533a5d..a7779fb2c 100644 --- a/src/osgWrappers/serializers/osg/ComputeDispatch.cpp +++ b/src/osgWrappers/serializers/osg/DispatchCompute.cpp @@ -1,17 +1,17 @@ -#include +#include #include #include #include // _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 }