7082abb8ad
per scene view. The user can attach a NodeVisitor to do init for them, or leave it to the default which is to use the osgUtil::DisplayListVisitor which compiles all display lists and texture objects. The init traversal is called automatically by the first call to either app() or cull(), so should not be called by user code during initialization. This ensures that a valid graphics context has been established before OpenGL is initialized. osgUtil::DisplayListVisitor has also been updated to use a bit mask for options, and the addition of compilation of texture objects (via StateAttribute::compile) has also been added.
247 lines
9.9 KiB
Plaintext
247 lines
9.9 KiB
Plaintext
//C++ header - Open Scene Graph - Copyright (C) 1998-2001 Robert Osfield
|
|
//Distributed under the terms of the GNU Library General Public License (LGPL)
|
|
//as published by the Free Software Foundation.
|
|
|
|
#ifndef OSGUTIL_SCENEVIEW
|
|
#define OSGUTIL_SCENEVIEW 1
|
|
|
|
#include <osg/Node>
|
|
#include <osg/StateSet>
|
|
#include <osg/Light>
|
|
#include <osg/Camera>
|
|
#include <osg/FrameStamp>
|
|
|
|
#include <osgUtil/CullVisitor>
|
|
|
|
namespace osgUtil {
|
|
|
|
/**
|
|
* SceneView is literally a view of a scene, encapsulating the
|
|
* camera, global state, lights and the scene itself. Provides
|
|
* methods for setting up the view and rendering it.
|
|
*/
|
|
class OSGUTIL_EXPORT SceneView : public osg::Referenced
|
|
{
|
|
public:
|
|
|
|
/** Construct a default scene view.*/
|
|
SceneView();
|
|
|
|
/** Set scene view to use default global state, light, camera
|
|
* and render visitor.
|
|
*/
|
|
void setDefaults();
|
|
|
|
/** Set the data which to view. The data will typically be
|
|
* an osg::Scene but can be any osg::Node type.
|
|
*/
|
|
void setSceneData(osg::Node* node) { _sceneData = node; _need_compile = true;}
|
|
/** Get the scene data which to view. The data will typically be
|
|
* an osg::Scene but can be any osg::Node type.
|
|
*/
|
|
osg::Node* getSceneData() { return _sceneData.get(); }
|
|
|
|
/** Get the const scene data which to view. The data will typically be
|
|
* an osg::Scene but can be any osg::Node type.
|
|
*/
|
|
const osg::Node* getSceneData() const { return _sceneData.get(); }
|
|
|
|
/** Set the viewport of the scene view to use specfied osg::Viewport. */
|
|
void setViewport(osg::Viewport* viewport)
|
|
{
|
|
if (viewport) _viewport = viewport;
|
|
else
|
|
{
|
|
// ensure that _viewport is always valid.
|
|
_viewport = new osg::Viewport;
|
|
}
|
|
}
|
|
|
|
/** Set the viewport of the scene view to specified dimensions. */
|
|
void setViewport(int x,int y,int width,int height)
|
|
{
|
|
_viewport->setViewport(x,y,width,height);
|
|
}
|
|
|
|
|
|
/** Get the const viewport. */
|
|
const osg::Viewport* getViewport() const { return _viewport.get(); }
|
|
|
|
/** Get the viewport. */
|
|
osg::Viewport* getViewport() { return _viewport.get(); }
|
|
|
|
/** Get the viewport of the scene view. */
|
|
void getViewport(int& x,int& y,int& width,int& height)
|
|
{
|
|
_viewport->getViewport(x,y,width,height);
|
|
}
|
|
|
|
|
|
|
|
/** Set the background color used in glClearColor().
|
|
Defaults to an off blue color.*/
|
|
void setBackgroundColor(const osg::Vec4& color) { _backgroundColor=color; }
|
|
/** Get the background color.*/
|
|
const osg::Vec4& getBackgroundColor() const { return _backgroundColor; }
|
|
|
|
void setGlobalState(osg::StateSet* state) { _globalState = state; }
|
|
osg::StateSet* getGlobalState() { return _globalState.get(); }
|
|
const osg::StateSet* getGlobalState() const { return _globalState.get(); }
|
|
|
|
enum LightingMode {
|
|
HEADLIGHT, // default
|
|
SKY_LIGHT,
|
|
NO_SCENEVIEW_LIGHT
|
|
};
|
|
|
|
void setLightingMode(LightingMode mode) { _lightingMode=mode; }
|
|
LightingMode getLightingMode() const { return _lightingMode; }
|
|
|
|
void setLight(osg::Light* light) { _light = light; }
|
|
osg::Light* getLight() { return _light.get(); }
|
|
const osg::Light* getLight() const { return _light.get(); }
|
|
|
|
void setCamera(osg::Camera* camera) { _camera = camera; }
|
|
osg::Camera* getCamera() { return _camera.get(); }
|
|
const osg::Camera* getCamera() const { return _camera.get(); }
|
|
|
|
void setState(osg::State* state) { _state = state; }
|
|
osg::State* getState() { return _state.get(); }
|
|
const osg::State* getState() const { return _state.get(); }
|
|
|
|
|
|
void setInitVisitor(osg::NodeVisitor* av) { _initVisitor = av; }
|
|
osg::NodeVisitor* getInitVisitor() { return _initVisitor.get(); }
|
|
const osg::NodeVisitor* getInitVisitor() const { return _initVisitor.get(); }
|
|
|
|
void setAppVisitor(osg::NodeVisitor* av) { _appVisitor = av; }
|
|
osg::NodeVisitor* getAppVisitor() { return _appVisitor.get(); }
|
|
const osg::NodeVisitor* getAppVisitor() const { return _appVisitor.get(); }
|
|
|
|
void setCullVisitor(osgUtil::CullVisitor* cv) { _cullVisitor = cv; }
|
|
osgUtil::CullVisitor* getCullVisitor() { return _cullVisitor.get(); }
|
|
const osgUtil::CullVisitor* getCullVisitor() const { return _cullVisitor.get(); }
|
|
|
|
void setRenderGraph(osgUtil::RenderGraph* rg) { _rendergraph = rg; }
|
|
osgUtil::RenderGraph* getRenderGraph() { return _rendergraph.get(); }
|
|
const osgUtil::RenderGraph* getRenderGraph() const { return _rendergraph.get(); }
|
|
|
|
void setRenderStage(osgUtil::RenderStage* rs) { _renderStage = rs; }
|
|
osgUtil::RenderStage* getRenderStage() { return _renderStage.get(); }
|
|
const osgUtil::RenderStage* getRenderStage() const { return _renderStage.get(); }
|
|
|
|
void setLODBias(float bias) { _lodBias = bias; }
|
|
float getLODBias() const { return _lodBias; }
|
|
|
|
/** Set to true if you want SceneView to automatically calculate values
|
|
for the near/far clipping planes, each frame, set false to use camera's
|
|
internal near and far planes. Default value is true.
|
|
*/
|
|
void setCalcNearFar(bool calc) { _calc_nearfar = calc; }
|
|
/** return true if SceneView automatically calculates near and
|
|
far clipping planes for each frame.
|
|
*/
|
|
bool getCalcNearFar() const { return _calc_nearfar; }
|
|
|
|
/** set whether the draw method should call renderer->prioritizeTexture.*/
|
|
void setPrioritizeTextures(bool pt) { _prioritizeTextures = pt; }
|
|
|
|
/** get whether the draw method should call renderer->prioritizeTexture.*/
|
|
bool getPrioritizeTextures() const { return _prioritizeTextures; }
|
|
|
|
|
|
/** Calculate, via glUnProject, the object coordinates of a window point.
|
|
Note, current implementation requires that SceneView::draw() has been previously called
|
|
for projectWindowIntoObject to produce valid values. Consistent with OpenGL
|
|
windows coordinates are calculated relative to the bottom left of the window.
|
|
Returns true on successful projection.
|
|
*/
|
|
bool projectWindowIntoObject(const osg::Vec3& window,osg::Vec3& object) const;
|
|
|
|
/** Calculate, via glUnProject, the object coordinates of a window x,y
|
|
when projected onto the near and far planes.
|
|
Note, current implementation requires that SceneView::draw() has been previously called
|
|
for projectWindowIntoObject to produce valid values. Consistent with OpenGL
|
|
windows coordinates are calculated relative to the bottom left of the window.
|
|
Returns true on successful projection.
|
|
*/
|
|
bool projectWindowXYIntoObject(int x,int y,osg::Vec3& near_point,osg::Vec3& far_point) const;
|
|
|
|
/** Calculate, via glProject, the object coordinates of a window.
|
|
Note, current implementation requires that SceneView::draw() has been previously called
|
|
for projectWindowIntoObject to produce valid values. Consistent with OpenGL
|
|
windows coordinates are calculated relative to the bottom left of the window,
|
|
whereas as window API's normally have the top left as the origin,
|
|
so you may need to pass in (mouseX,window_height-mouseY,...).
|
|
Returns true on successful projection.
|
|
*/
|
|
bool projectObjectIntoWindow(const osg::Vec3& object,osg::Vec3& window) const;
|
|
|
|
|
|
/** Set the frame stamp for the current frame.*/
|
|
inline void setFrameStamp(osg::FrameStamp* fs) { _frameStamp = fs; }
|
|
|
|
/** Set the frame stamp for the current frame.*/
|
|
inline const osg::FrameStamp* getFrameStamp() const { return _frameStamp.get(); }
|
|
|
|
|
|
/** Do init traversal of attached scene graph using Init NodeVisitor.
|
|
* The init traversal is called once for each SceneView, and should
|
|
* be used to compile display list, texture objects intialize data
|
|
* not otherwise intializaed during scene graph loading. Note, is
|
|
* called automatically by app&cull if it hasn't already been called
|
|
* elsewhere. Also init() should only ever be called within a valid
|
|
* graphics context.*/
|
|
virtual void init();
|
|
|
|
/** Do app traversal of attached scene graph using App NodeVisitor.*/
|
|
virtual void app();
|
|
|
|
/** Do cull traversal of attached scene graph using Cull NodeVisitor.*/
|
|
virtual void cull();
|
|
|
|
/** Do draw traversal of draw bins generated by cull traversal.*/
|
|
virtual void draw();
|
|
|
|
protected:
|
|
|
|
virtual ~SceneView();
|
|
|
|
osg::ref_ptr<osg::Node> _sceneData;
|
|
osg::ref_ptr<osg::StateSet> _globalState;
|
|
osg::ref_ptr<osg::Light> _light;
|
|
osg::ref_ptr<osg::Camera> _camera;
|
|
osg::ref_ptr<osg::State> _state;
|
|
|
|
bool _initCalled;
|
|
osg::ref_ptr<osg::NodeVisitor> _initVisitor;
|
|
osg::ref_ptr<osg::NodeVisitor> _appVisitor;
|
|
osg::ref_ptr<osgUtil::CullVisitor> _cullVisitor;
|
|
osg::ref_ptr<osgUtil::RenderGraph> _rendergraph;
|
|
osg::ref_ptr<osgUtil::RenderStage> _renderStage;
|
|
|
|
osg::ref_ptr<osg::FrameStamp> _frameStamp;
|
|
|
|
bool _need_compile;
|
|
bool _calc_nearfar;
|
|
|
|
osg::Vec4 _backgroundColor;
|
|
|
|
double _near_plane;
|
|
double _far_plane;
|
|
|
|
float _lodBias;
|
|
|
|
osg::ref_ptr<osg::Viewport> _viewport;
|
|
|
|
LightingMode _lightingMode;
|
|
|
|
bool _prioritizeTextures;
|
|
|
|
};
|
|
|
|
};
|
|
|
|
#endif
|
|
|