1369987cdd
and associated member variables. I have not linked them up to the cull traversal yet, but this will be the next task.
300 lines
13 KiB
Plaintext
300 lines
13 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 <osg/DisplaySettings>
|
|
|
|
|
|
//#include <osgUtil/CullVisitor>
|
|
#include <osgUtil/NewCullVisitor>
|
|
|
|
namespace osgUtil {
|
|
|
|
typedef NewCullVisitor CullVisitor;
|
|
|
|
/**
|
|
* 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(osg::DisplaySettings* ds=NULL);
|
|
|
|
/** 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 DisplaySettings. */
|
|
inline void setDisplaySettings(osg::DisplaySettings* vs) { _displaySettings = vs; }
|
|
|
|
/** Get the const DisplaySettings */
|
|
inline const osg::DisplaySettings* getDisplaySettings() const { return _displaySettings.get(); }
|
|
|
|
/** Get the DisplaySettings */
|
|
inline osg::DisplaySettings* getDisplaySettings() { return _displaySettings.get(); }
|
|
|
|
|
|
/** 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 setGlobalStateSet(osg::StateSet* state) { _globalState = state; }
|
|
osg::StateSet* getGlobalStateSet() { return _globalState.get(); }
|
|
const osg::StateSet* getGlobalStateSet() 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 setState(osg::State* state) { _state = state; }
|
|
osg::State* getState() { return _state.get(); }
|
|
const osg::State* getState() const { return _state.get(); }
|
|
|
|
void setCamera(osg::Camera* camera) { _camera = camera; }
|
|
osg::Camera* getCamera() { return _camera.get(); }
|
|
const osg::Camera* getCamera() const { return _camera.get(); }
|
|
|
|
void setProjectionMatrix(osg::Matrix* matrix) { _projectionMatrix = matrix; }
|
|
osg::Matrix* getProjectionMatrix() { return _projectionMatrix.get(); }
|
|
const osg::Matrix* getProjectionMatrix() const { return _projectionMatrix.get(); }
|
|
|
|
void setModelViewMatrix(osg::Matrix* matrix) { _modelviewMatrix = matrix; }
|
|
osg::Matrix* getModelViewMatrix() { return _modelviewMatrix.get(); }
|
|
const osg::Matrix* getModelViewMatrix() const { return _modelviewMatrix.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; }
|
|
|
|
|
|
void setCullMask(const osg::Node::NodeMask nm) { _cullMask = nm; }
|
|
const osg::Node::NodeMask getCullMask() const { return _cullMask; }
|
|
|
|
void setCullMaskLeft(const osg::Node::NodeMask nm) { _cullMaskLeft = nm; }
|
|
const osg::Node::NodeMask getCullMaskLeft() const { return _cullMaskLeft; }
|
|
|
|
void setCullMaskRight(const osg::Node::NodeMask nm) { _cullMaskRight = nm; }
|
|
const osg::Node::NodeMask getCullMaskRight() const { return _cullMaskRight; }
|
|
|
|
|
|
/** 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();
|
|
|
|
/** Do cull traversal of attached scene graph using Cull NodeVisitor.*/
|
|
virtual void cullStage(osg::Camera* camera,osgUtil::CullVisitor* cullVisitor, osgUtil::RenderGraph* rendergraph, osgUtil::RenderStage* renderStage);
|
|
virtual void drawStage(osgUtil::RenderStage* renderStage);
|
|
|
|
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::Matrix> _projectionMatrix;
|
|
osg::ref_ptr<osg::Matrix> _modelviewMatrix;
|
|
osg::ref_ptr<osg::DisplaySettings> _displaySettings;
|
|
osg::ref_ptr<osg::State> _state;
|
|
|
|
bool _initCalled;
|
|
osg::ref_ptr<osg::NodeVisitor> _initVisitor;
|
|
osg::ref_ptr<osg::NodeVisitor> _appVisitor;
|
|
osg::Node::NodeMask _cullMask;
|
|
osg::ref_ptr<osgUtil::CullVisitor> _cullVisitor;
|
|
osg::ref_ptr<osgUtil::RenderGraph> _rendergraph;
|
|
osg::ref_ptr<osgUtil::RenderStage> _renderStage;
|
|
|
|
osg::Node::NodeMask _cullMaskLeft;
|
|
osg::ref_ptr<osg::Camera> _cameraLeft;
|
|
osg::ref_ptr<osgUtil::CullVisitor> _cullVisitorLeft;
|
|
osg::ref_ptr<osgUtil::RenderGraph> _rendergraphLeft;
|
|
osg::ref_ptr<osgUtil::RenderStage> _renderStageLeft;
|
|
|
|
osg::Node::NodeMask _cullMaskRight;
|
|
osg::ref_ptr<osg::Camera> _cameraRight;
|
|
osg::ref_ptr<osgUtil::CullVisitor> _cullVisitorRight;
|
|
osg::ref_ptr<osgUtil::RenderGraph> _rendergraphRight;
|
|
osg::ref_ptr<osgUtil::RenderStage> _renderStageRight;
|
|
|
|
|
|
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
|
|
|