337 lines
14 KiB
C++
337 lines
14 KiB
C++
/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 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 OSGUTIL_INCREMENTALCOMPILEOPERATOR
|
|
#define OSGUTIL_INCREMENTALCOMPILEOPERATOR
|
|
|
|
#include <osgUtil/GLObjectsVisitor>
|
|
#include <osg/Geometry>
|
|
|
|
namespace osgUtil {
|
|
|
|
class CompileData : public osg::Referenced
|
|
{
|
|
public:
|
|
|
|
CompileData() {}
|
|
|
|
typedef std::set< osg::ref_ptr<osg::Drawable> > Drawables;
|
|
typedef std::set< osg::ref_ptr<osg::Texture> > Textures;
|
|
typedef std::set< osg::ref_ptr<osg::Program> > Programs;
|
|
|
|
bool empty() const { return _drawables.empty() && _textures.empty() && _programs.empty(); }
|
|
|
|
void reset()
|
|
{
|
|
_drawables.clear();
|
|
_textures.clear();
|
|
_programs.clear();
|
|
}
|
|
|
|
Drawables _drawables;
|
|
Textures _textures;
|
|
Programs _programs;
|
|
};
|
|
|
|
class OSGUTIL_EXPORT CompileStats : public osg::Referenced
|
|
{
|
|
public:
|
|
|
|
CompileStats();
|
|
|
|
void add(const std::string& name,double size, double time);
|
|
|
|
double estimateTime(const std::string& name, double size) const;
|
|
double estimateTime2(const std::string& name, double size) const;
|
|
double estimateTime3(const std::string& name, double size) const;
|
|
double estimateTime4(const std::string& name, double size) const;
|
|
double averageTime(const std::string& name) const;
|
|
|
|
void print(std::ostream& out) const;
|
|
|
|
protected:
|
|
|
|
struct OSGUTIL_EXPORT Values
|
|
{
|
|
Values():
|
|
totalSize(0.0), totalTime(0.0), totalNum(0.0),
|
|
minSize(0.0), minTime(0.0),
|
|
a(0.0), b(0.0),
|
|
m(0.0), n(0.0), o(0.0), p(0.0) {}
|
|
|
|
void add(double size, double time);
|
|
|
|
double estimateTime(double size) const
|
|
{
|
|
return a + b * size;
|
|
}
|
|
|
|
double estimateTime2(double size) const
|
|
{
|
|
return (totalTime/totalSize) * size;
|
|
}
|
|
|
|
double estimateTime3(double size) const
|
|
{
|
|
if (size<minSize) return minTime;
|
|
return minTime + (totalTime/totalSize) * (size-minSize);
|
|
}
|
|
|
|
double estimateTime4(double size) const
|
|
{
|
|
if (size<minSize) return minTime;
|
|
double denominator = totalSize-minSize*totalNum;
|
|
return denominator==0.0 ? minTime :
|
|
minTime + (totalTime-minTime*totalNum)/(totalSize-minSize*totalNum) * (size-minSize);
|
|
}
|
|
|
|
double averageTime() const
|
|
{
|
|
if (totalNum!=0.0) return totalTime/totalTime;
|
|
else return 0.0;
|
|
}
|
|
|
|
double totalSize, totalTime, totalNum;
|
|
double minSize, minTime;
|
|
double a,b;
|
|
double m,n,o,p;
|
|
};
|
|
|
|
typedef std::map<std::string, Values> StatsMap;
|
|
StatsMap _statsMap;
|
|
};
|
|
|
|
class OSGUTIL_EXPORT CompileOperator : public osg::Referenced
|
|
{
|
|
public:
|
|
|
|
CompileOperator();
|
|
|
|
/** Assign a geometry and associated StateSet than is applied after each texture compile to atttempt to force the OpenGL
|
|
* drive to download the texture object to OpenGL graphics card.*/
|
|
void assignForceTextureDownloadGeometry();
|
|
|
|
/** Set the osg::Geometry to apply after each texture compile to atttempt to force the OpenGL
|
|
* drive to download the texture object to OpenGL graphics card.*/
|
|
void setForceTextureDownloadGeometry(osg::Geometry* geom) { _forceTextureDownloadGeometry = geom; }
|
|
osg::Geometry* getForceTextureDownloadGeometry() { return _forceTextureDownloadGeometry.get(); }
|
|
const osg::Geometry* getForceTextureDownloadGeometry() const { return _forceTextureDownloadGeometry.get(); }
|
|
|
|
/** Compile as many elements in the CompileData container as possible within specified time.
|
|
* return true if all have been compiled. */
|
|
virtual bool compile(osg::RenderInfo& renderInfo, CompileData& compileData, unsigned int& maxNumObjectsToCompile, double& availableTime);
|
|
|
|
/** Compile all the elements in the CompileData container. */
|
|
void compileAll(osg::RenderInfo& renderInfo, CompileData& compileData)
|
|
{
|
|
unsigned int maxNumObjectsToCompile = 32768;
|
|
double availableTime = DBL_MAX;
|
|
compile(renderInfo, compileData, maxNumObjectsToCompile, availableTime);
|
|
}
|
|
|
|
CompileStats* getCompileStats() { return _compileStats.get(); }
|
|
const CompileStats* getCompileStats() const { return _compileStats.get(); }
|
|
|
|
protected:
|
|
|
|
void runTimingTests(osg::RenderInfo& renderInfo);
|
|
|
|
double timeCompile(osg::RenderInfo& renderInfo, osg::Geometry* geometry) const;
|
|
double timeCompile(osg::RenderInfo& renderInfo, osg::StateSet* stateset) const;
|
|
osg::Geometry* createTestGeometry(unsigned int numVertices, bool vbo) const;
|
|
osg::StateSet* createTestStateSet(unsigned int imageSize, bool mipmapped) const;
|
|
|
|
osg::ref_ptr<osg::Geometry> _forceTextureDownloadGeometry;
|
|
osg::ref_ptr<CompileStats> _compileStats;
|
|
bool _timingTestsCompleted;
|
|
};
|
|
|
|
|
|
class OSGUTIL_EXPORT IncrementalCompileOperation : public osg::GraphicsOperation
|
|
{
|
|
public:
|
|
|
|
IncrementalCompileOperation();
|
|
|
|
/** Set the target frame rate that the IncrementalCompileOperation should assume.
|
|
* Typically one would set this to the value refresh rate of your display system i.e. 60Hz.
|
|
* Default value is 100.
|
|
* Usage notes. The TargetFrameRate and the MinimumTimeAvailableForGLCompileAndDeletePerFrame
|
|
* parameters are not directly used by IncrementalCompileOperation, but are should be used as a guide for how
|
|
* long to set aside per frame for compiling and deleting OpenGL objects. The longer amount of
|
|
* time to set aside the faster databases will be paged in but with increased chance of frame drops,
|
|
* the lower the amount of time the set aside the slower databases will paged it but with better
|
|
* chance of avoid any frame drops. The default values are chosen to achieve the later when running
|
|
* on a modern mid to high end PC.
|
|
* The way to compute the amount of available time use a scheme such as :
|
|
* availableTime = maximum(1.0/targetFrameRate - timeTakenDuringUpdateCullAndDraw, minimumTimeAvailableForGLCompileAndDeletePerFrame).
|
|
*/
|
|
void setTargetFrameRate(double tfr) { _targetFrameRate = tfr; }
|
|
|
|
/** Get the target frame rate that the IncrementalCompileOperation should assume.*/
|
|
double getTargetFrameRate() const { return _targetFrameRate; }
|
|
|
|
/** Set the minimum amount of time (in seconds) that should be made available for compiling and delete OpenGL objects per frame.
|
|
* Default value is 0.001 (1 millisecond).
|
|
* For usage see notes in setTargetFrameRate.*/
|
|
void setMinimumTimeAvailableForGLCompileAndDeletePerFrame(double ta) { _minimumTimeAvailableForGLCompileAndDeletePerFrame = ta; }
|
|
|
|
/** Get the minimum amount of time that should be made available for compiling and delete OpenGL objects per frame.
|
|
* For usage see notes in setTargetFrameRate.*/
|
|
double getMinimumTimeAvailableForGLCompileAndDeletePerFrame() const { return _minimumTimeAvailableForGLCompileAndDeletePerFrame; }
|
|
|
|
/** Set the maximum number of OpenGL objects that the page should attempt to compile per frame.
|
|
* Note, Lower values reduces chances of a frame drop but lower the rate that database will be paged in at.
|
|
* Default value is 8. */
|
|
void setMaximumNumOfObjectsToCompilePerFrame(unsigned int num) { _maximumNumOfObjectsToCompilePerFrame = num; }
|
|
|
|
/** Get the maximum number of OpenGL objects that the page should attempt to compile per frame.*/
|
|
unsigned int getMaximumNumOfObjectsToCompilePerFrame() const { return _maximumNumOfObjectsToCompilePerFrame; }
|
|
|
|
|
|
/** FlushTimeRatio governs how much of the spare time in each frame is used for flushing deleted OpenGL objects.
|
|
* Default value is 0.5, valid range is 0.1 to 0.9.*/
|
|
void setFlushTimeRatio(double ratio) { _flushTimeRatio = ratio; }
|
|
double getFlushTimeRatio() const { return _flushTimeRatio; }
|
|
|
|
/** ConservativeTimeRatio governs how much of the measured spare time in each frame is used for flushing deleted and compile new OpenGL objects.
|
|
* Default value is 0.5, valid range is 0.1 to 1.0.
|
|
* A ratio near 1.0 will lead to paged databases being compiled and merged quicker but increase the chances of frame drop.
|
|
* A ratio near 0.1 will lead to paged databases being compiled and merged closer but reduse the chances of frame drop.*/
|
|
void setConservativeTimeRatio(double ratio) { _conservativeTimeRatio = ratio; }
|
|
double getConservativeTimeRatio() const { return _conservativeTimeRatio; }
|
|
|
|
|
|
|
|
typedef std::vector<osg::GraphicsContext*> Contexts;
|
|
void assignContexts(Contexts& contexts);
|
|
void removeContexts(Contexts& contexts);
|
|
|
|
void addGraphicsContext(osg::GraphicsContext* gc);
|
|
void removeGraphicsContext(osg::GraphicsContext* gc);
|
|
|
|
|
|
/** Merge subgraphs that have been compiled.*/
|
|
void mergeCompiledSubgraphs();
|
|
|
|
virtual void operator () (osg::GraphicsContext* context);
|
|
|
|
|
|
|
|
class CompileSet;
|
|
typedef std::set<osg::GraphicsContext*> ContextSet;
|
|
typedef std::map<osg::GraphicsContext*, CompileData > CompileMap;
|
|
|
|
struct CompileCompletedCallback : public virtual osg::Referenced
|
|
{
|
|
/// return true if the callback assumes responsibility for merging any associated subgraphs with the main scene graph
|
|
/// return false if callback doesn't handle the merge, and instead requires the IncrementalCompileOperation to handle this for us
|
|
virtual bool compileCompleted(CompileSet* compileSet) = 0;
|
|
};
|
|
|
|
class OSGUTIL_EXPORT CompileSet : public osg::Referenced
|
|
{
|
|
public:
|
|
|
|
|
|
CompileSet() {}
|
|
|
|
CompileSet(osg::Node*subgraphToCompile):
|
|
_subgraphToCompile(subgraphToCompile) {}
|
|
|
|
CompileSet(osg::Group* attachmentPoint, osg::Node*subgraphToCompile):
|
|
_attachmentPoint(attachmentPoint),
|
|
_subgraphToCompile(subgraphToCompile) {}
|
|
|
|
void buildCompileMap(ContextSet& context, GLObjectsVisitor::Mode mode=GLObjectsVisitor::COMPILE_DISPLAY_LISTS|GLObjectsVisitor::COMPILE_STATE_ATTRIBUTES);
|
|
|
|
bool compileCompleted() const
|
|
{
|
|
for(CompileMap::const_iterator itr = _compileMap.begin();
|
|
itr != _compileMap.end();
|
|
++itr)
|
|
{
|
|
if (!(itr->second.empty())) return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
osg::observer_ptr<osg::Group> _attachmentPoint;
|
|
osg::ref_ptr<osg::Node> _subgraphToCompile;
|
|
osg::ref_ptr<CompileCompletedCallback> _compileCompletedCallback;
|
|
CompileMap _compileMap;
|
|
|
|
// protected:
|
|
|
|
virtual ~CompileSet() {}
|
|
};
|
|
|
|
typedef std::list< osg::ref_ptr<CompileSet> > CompileSets;
|
|
|
|
/** Add a subgraph to be compiled.*/
|
|
void add(osg::Node* subgraphToCompile);
|
|
|
|
/** Add a subgraph to be compiled and add automatically to attachPoint on call to mergeCompiledSubgraphs.*/
|
|
void add(osg::Group* attachmentPoint, osg::Node* subgraphToCompile);
|
|
|
|
/** Add a CompileSet to be compiled.*/
|
|
void add(CompileSet* compileSet, bool callBuildCompileMap=true);
|
|
|
|
/** Remove CompileSet from list.*/
|
|
void remove(CompileSet* compileSet);
|
|
|
|
|
|
OpenThreads::Mutex* getToCompiledMutex() { return &_toCompileMutex; }
|
|
CompileSets& getToCompile() { return _toCompile; }
|
|
|
|
OpenThreads::Mutex* getCompiledMutex() { return &_compiledMutex; }
|
|
CompileSets& getCompiled() { return _compiled; }
|
|
|
|
void setCompileOperator(CompileOperator* compileOperator) { _compileOperator = compileOperator; }
|
|
CompileOperator* getCompileOperator() { return _compileOperator.get(); }
|
|
const CompileOperator* getCompileOperator() const { return _compileOperator.get(); }
|
|
|
|
/** Assign a geometry and associated StateSet than is applied after each texture compile to atttempt to force the OpenGL
|
|
* drive to download the texture object to OpenGL graphics card.*/
|
|
void assignForceTextureDownloadGeometry();
|
|
|
|
protected:
|
|
|
|
virtual ~IncrementalCompileOperation();
|
|
|
|
// forward declare to keep within class namespace
|
|
class CollectStateToCompile;
|
|
|
|
double _targetFrameRate;
|
|
double _minimumTimeAvailableForGLCompileAndDeletePerFrame;
|
|
unsigned int _maximumNumOfObjectsToCompilePerFrame;
|
|
double _flushTimeRatio;
|
|
double _conservativeTimeRatio;
|
|
|
|
osg::ref_ptr<CompileOperator> _compileOperator;
|
|
|
|
OpenThreads::Mutex _toCompileMutex;
|
|
CompileSets _toCompile;
|
|
|
|
OpenThreads::Mutex _compiledMutex;
|
|
CompileSets _compiled;
|
|
|
|
ContextSet _contexts;
|
|
|
|
};
|
|
|
|
}
|
|
|
|
#endif
|
|
|