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

Renamed ShaderTerrain to DisplacementMappingTechnique and moved it from the osgterrain example testbed into the osgTerrain NodeKit

Browse Source 
git-svn-id: http://svn.openscenegraph.org/osg/OpenSceneGraph/trunk@14534 16af8721-9629-0410-8352-f15c8da7e697
This commit is contained in:
Robert Osfield 2014-11-26 14:04:20 +00:00
parent d9f93f9d1a
commit dfb0b2ab8e
9 changed files with 183 additions and 204 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
examples/osgterrain/CMakeLists.txt
View File

@ -1,9 +1,4 @@
SET(TARGET_H
ShaderTerrain.h
)
SET(TARGET_SRC
ShaderTerrain.cpp
osgterrain.cpp
)

145
examples/osgterrain/ShaderTerrain.cpp
View File

@ -1,145 +0,0 @@
#include <osgTerrain/Layer>
#include <osgTerrain/TerrainTile>
#include <osg/Texture1D>
#include <osg/Texture2D>
#include <osg/Program>
#include <osg/Uniform>
#include <osg/io_utils>
#include <osgDB/ReadFile>
#include <osgDB/WriteFile>
#include <osgDB/FileUtils>
#include "ShaderTerrain.h"
using namespace osgTerrain;
#if 0
#define LOCK(mutex) OpenThreads::ScopedLock<OpenThreads::Mutex> lock(mutex);
#else
#define LOCK(mutex) /* OpenThreads::Thread::microSleep(1);*/
#endif
/////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// ShaderTerrain
//
ShaderTerrain::ShaderTerrain()
{
// OSG_NOTICE<<"ShaderTerrain::ShaderTerrain()"<<std::endl;
_geometryPool = new GeometryPool;
}
ShaderTerrain::ShaderTerrain(const ShaderTerrain& st,const osg::CopyOp& copyop):
osgTerrain::TerrainTechnique(st, copyop),
_geometryPool(st._geometryPool)
{
// OSG_NOTICE<<"ShaderTerrain::ShaderTerrain(ShaderTerrain&, CopyOp&) "<<_geometryPool.get()<<std::endl;
}
ShaderTerrain::~ShaderTerrain()
{
}
void ShaderTerrain::init(int dirtyMask, bool assumeMultiThreaded)
{
if (!_terrainTile) return;
LOCK(_transformMutex);
++_currentTraversalCount;
#if 0
if (_currentTraversalCount>1)
{
unsigned int val = _currentTraversalCount;
printf("Has a concurrent traversal %i\n",val);
//throw "have concurrent traversal happening";
OpenThreads::Thread::YieldCurrentThread();
}
else
{
printf("Single threaded traversal\n");
}
#endif
//OSG_NOTICE<<"ShaderTerrain::init("<<dirtyMask<<", "<<assumeMultiThreaded<<")"<<std::endl;
_transform = _geometryPool->getTileSubgraph(_terrainTile);
// set tile as no longer dirty.
_terrainTile->setDirtyMask(0);
--_currentTraversalCount;
}
void ShaderTerrain::update(osgUtil::UpdateVisitor* uv)
{
LOCK(_transformMutex);
if (_terrainTile) _terrainTile->osg::Group::traverse(*uv);
if (_transform.valid()) _transform->accept(*uv);
}
void ShaderTerrain::cull(osgUtil::CullVisitor* cv)
{
LOCK(_transformMutex);
if (_transform.valid()) _transform->accept(*cv);
}
void ShaderTerrain::traverse(osg::NodeVisitor& nv)
{
if (!_terrainTile) return;
// if app traversal update the frame count.
if (nv.getVisitorType()==osg::NodeVisitor::UPDATE_VISITOR)
{
// if (_terrainTile->getDirty()) _terrainTile->init(_terrainTile->getDirtyMask(), false);
osgUtil::UpdateVisitor* uv = dynamic_cast<osgUtil::UpdateVisitor*>(&nv);
if (uv)
{
update(uv);
return;
}
}
else if (nv.getVisitorType()==osg::NodeVisitor::CULL_VISITOR)
{
osgUtil::CullVisitor* cv = dynamic_cast<osgUtil::CullVisitor*>(&nv);
if (cv)
{
cull(cv);
return;
}
}
{
LOCK(_transformMutex);
if (_transform.valid())
{
_transform->accept(nv);
}
}
}
void ShaderTerrain::cleanSceneGraph()
{
}
void ShaderTerrain::releaseGLObjects(osg::State* state) const
{
// LOCK(_transformMutex);
if (_transform.valid())
{
// OSG_NOTICE<<"ShaderTerrain::releaseGLObjects()"<<std::endl;
_transform->releaseGLObjects(state);
}
}

47
examples/osgterrain/ShaderTerrain.h
View File

@ -1,47 +0,0 @@
#ifndef OSGTERRAIN_SHADERTERRAIN
#define OSGTERRAIN_SHADERTERRAIN
#include <OpenThreads/Mutex>
#include <osg/MatrixTransform>
#include <osg/Program>
#include <osgTerrain/GeometryTechnique>
#include <osgTerrain/GeometryPool>
namespace osgTerrain
{
class ShaderTerrain : public osgTerrain::TerrainTechnique
{
public:
ShaderTerrain();
ShaderTerrain(const ShaderTerrain&,const osg::CopyOp& copyop=osg::CopyOp::SHALLOW_COPY);
META_Object(osgTerrain, ShaderTerrain);
virtual void init(int dirtyMask, bool assumeMultiThreaded);
virtual void update(osgUtil::UpdateVisitor* uv);
virtual void cull(osgUtil::CullVisitor* cv);
virtual void traverse(osg::NodeVisitor& nv);
virtual void cleanSceneGraph();
virtual void releaseGLObjects(osg::State* state) const;
protected:
virtual ~ShaderTerrain();
osg::ref_ptr<GeometryPool> _geometryPool;
mutable OpenThreads::Mutex _traversalMutex;
mutable OpenThreads::Mutex _transformMutex;
osg::ref_ptr<osg::MatrixTransform> _transform;
OpenThreads::Atomic _currentTraversalCount;
};
}
#endif

10
examples/osgterrain/osgterrain.cpp
View File

@ -33,9 +33,9 @@
#include <osgTerrain/Terrain>
#include <osgTerrain/TerrainTile>
#include <osgTerrain/GeometryTechnique>
#include <osgTerrain/DisplacementMappingTechnique>
#include <osgTerrain/Layer>
#include "ShaderTerrain.h"
#include <iostream>
@ -238,8 +238,8 @@ int main(int argc, char** argv)
else if (strBlendingPolicy == "ENABLE_BLENDING_WHEN_ALPHA_PRESENT") blendingPolicy = osgTerrain::TerrainTile::ENABLE_BLENDING_WHEN_ALPHA_PRESENT;
}
bool useShaderTerrain = arguments.read("--shader") || arguments.read("-s");
if (useShaderTerrain)
bool useDisplacementMappingTechnique = arguments.read("--dm");
if (useDisplacementMappingTechnique)
{
osgDB::Registry::instance()->setReadFileCallback(new CleanTechniqueReadFileCallback());
}
@ -285,9 +285,9 @@ int main(int argc, char** argv)
terrain->setVerticalScale(verticalScale);
terrain->setBlendingPolicy(blendingPolicy);
if (useShaderTerrain)
if (useDisplacementMappingTechnique)
{
terrain->setTerrainTechniquePrototype(new osgTerrain::ShaderTerrain());
terrain->setTerrainTechniquePrototype(new osgTerrain::DisplacementMappingTechnique());
}

60
include/osgTerrain/DisplacementMappingTechnique Normal file
View File

@ -0,0 +1,60 @@
/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2014 Robert Osfield
*
* 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 OSGTERRAIN_DISPLACEMENTMAPPINGTECHNIQUE
#define OSGTERRAIN_DISPLACEMENTMAPPINGTECHNIQUE
#include <OpenThreads/Mutex>
#include <osg/MatrixTransform>
#include <osg/Program>
#include <osgTerrain/GeometryTechnique>
#include <osgTerrain/GeometryPool>
namespace osgTerrain
{
class DisplacementMappingTechnique : public osgTerrain::TerrainTechnique
{
public:
DisplacementMappingTechnique();
DisplacementMappingTechnique(const DisplacementMappingTechnique&,const osg::CopyOp& copyop=osg::CopyOp::SHALLOW_COPY);
META_Object(osgTerrain, DisplacementMappingTechnique);
virtual void init(int dirtyMask, bool assumeMultiThreaded);
virtual void update(osgUtil::UpdateVisitor* uv);
virtual void cull(osgUtil::CullVisitor* cv);
virtual void traverse(osg::NodeVisitor& nv);
virtual void cleanSceneGraph();
virtual void releaseGLObjects(osg::State* state) const;
protected:
virtual ~DisplacementMappingTechnique();
osg::ref_ptr<GeometryPool> _geometryPool;
mutable OpenThreads::Mutex _traversalMutex;
mutable OpenThreads::Mutex _transformMutex;
osg::ref_ptr<osg::MatrixTransform> _transform;
OpenThreads::Atomic _currentTraversalCount;
};
}
#endif

2
include/osgTerrain/GeometryPool
View File

@ -1,4 +1,4 @@
/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield
/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2014 Robert Osfield
*
* 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

2
src/osgTerrain/CMakeLists.txt
View File

@ -7,6 +7,7 @@ ENDIF()
SET(LIB_NAME osgTerrain)
SET(HEADER_PATH ${OpenSceneGraph_SOURCE_DIR}/include/${LIB_NAME})
SET(TARGET_H
${HEADER_PATH}/DisplacementMappingTechnique
${HEADER_PATH}/Export
${HEADER_PATH}/Locator
${HEADER_PATH}/Layer
@ -21,6 +22,7 @@ SET(TARGET_H
# FIXME: For OS X, need flag for Framework or dylib
SET(TARGET_SRC
DisplacementMappingTechnique.cpp
Layer.cpp
Locator.cpp
TerrainTile.cpp

114
src/osgTerrain/DisplacementMappingTechnique.cpp Normal file
View File

@ -0,0 +1,114 @@
/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2014 Robert Osfield
*
* 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.
*/
#include <osgTerrain/Layer>
#include <osgTerrain/TerrainTile>
#include <osgTerrain/DisplacementMappingTechnique>
using namespace osgTerrain;
/////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// DisplacementMappingTechnique
//
DisplacementMappingTechnique::DisplacementMappingTechnique()
{
// OSG_NOTICE<<"DisplacementMappingTechnique::DisplacementMappingTechnique()"<<std::endl;
_geometryPool = new GeometryPool;
}
DisplacementMappingTechnique::DisplacementMappingTechnique(const DisplacementMappingTechnique& st,const osg::CopyOp& copyop):
osgTerrain::TerrainTechnique(st, copyop),
_geometryPool(st._geometryPool)
{
// OSG_NOTICE<<"DisplacementMappingTechnique::DisplacementMappingTechnique(DisplacementMappingTechnique&, CopyOp&) "<<_geometryPool.get()<<std::endl;
}
DisplacementMappingTechnique::~DisplacementMappingTechnique()
{
}
void DisplacementMappingTechnique::init(int dirtyMask, bool assumeMultiThreaded)
{
if (!_terrainTile) return;
//OSG_NOTICE<<"DisplacementMappingTechnique::init("<<dirtyMask<<", "<<assumeMultiThreaded<<")"<<std::endl;
_transform = _geometryPool->getTileSubgraph(_terrainTile);
// set tile as no longer dirty.
_terrainTile->setDirtyMask(0);
}
void DisplacementMappingTechnique::update(osgUtil::UpdateVisitor* uv)
{
if (_terrainTile) _terrainTile->osg::Group::traverse(*uv);
if (_transform.valid()) _transform->accept(*uv);
}
void DisplacementMappingTechnique::cull(osgUtil::CullVisitor* cv)
{
if (_transform.valid()) _transform->accept(*cv);
}
void DisplacementMappingTechnique::traverse(osg::NodeVisitor& nv)
{
if (!_terrainTile) return;
// if app traversal update the frame count.
if (nv.getVisitorType()==osg::NodeVisitor::UPDATE_VISITOR)
{
// if (_terrainTile->getDirty()) _terrainTile->init(_terrainTile->getDirtyMask(), false);
osgUtil::UpdateVisitor* uv = dynamic_cast<osgUtil::UpdateVisitor*>(&nv);
if (uv)
{
update(uv);
return;
}
}
else if (nv.getVisitorType()==osg::NodeVisitor::CULL_VISITOR)
{
osgUtil::CullVisitor* cv = dynamic_cast<osgUtil::CullVisitor*>(&nv);
if (cv)
{
cull(cv);
return;
}
}
{
if (_transform.valid())
{
_transform->accept(nv);
}
}
}
void DisplacementMappingTechnique::cleanSceneGraph()
{
}
void DisplacementMappingTechnique::releaseGLObjects(osg::State* state) const
{
if (_transform.valid())
{
// OSG_NOTICE<<"DisplacementMappingTechnique::releaseGLObjects()"<<std::endl;
_transform->releaseGLObjects(state);
}
}

2
src/osgTerrain/GeometryPool.cpp
View File

@ -1,4 +1,4 @@
/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield
/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2014 Robert Osfield
*
* 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