Index: /OpenSceneGraph/tags/osg_8_34/dist/RedHatRPM/osg.spec =================================================================== --- /OpenSceneGraph/tags/osg_8_34/dist/RedHatRPM/osg.spec (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/dist/RedHatRPM/osg.spec (revision 2) @@ -0,0 +1,32 @@ + +Summary: Open Scene Graph +Name: OpenSceneGraph +Version: 0.8 +Release: 2 +Copyright: GLPL +Group: Graphics +Source: osg-0.8-2.tar.gz +URL: http://www.openscenegraph.org +Packager: Robert Osfield + +%description + +Open Scene Graph is an open-source scene graph API. + +%prep +%setup +%build +%install + + + + + +# --------------------- +# FILES Sections +%files + +%attr(755, root, root) /usr/bin/* +%attr(755, root, root) /usr/lib/* +%attr(444, root, root) /usr/include/osg/* + Index: /OpenSceneGraph/tags/osg_8_34/dist/RedHatRPM/makespec =================================================================== --- /OpenSceneGraph/tags/osg_8_34/dist/RedHatRPM/makespec (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/dist/RedHatRPM/makespec (revision 2) @@ -0,0 +1,84 @@ +#!/bin/sh + +list_install_files() +{ + for d in \ + ${OSGHOME}/bin\ + ${OSGHOME}/lib\ + ${OSGHOME}/include + do + dd=`basename $d` + for f in `ls -1 $d` + do + echo cp -rf \ + /usr/src/redhat/BUILD/OpenSceneGraph-"$OSGVERSION"/$dd/$f /usr/$dd/$f + done + done +} + +list_attr_files() +{ + for d in \ + ${OSGHOME}/bin\ + ${OSGHOME}/lib + do + dd=`basename $d` + for f in $d/* + do + ff=`basename $f` + echo "%attr(755, root, root) /usr/$dd/$ff" + done + done + + for f in ${OSGHOME}/include/osg/* + do + ff=`basename $f` + echo "%attr(444, root, root) /usr/include/osg/$ff" + done +} + +[ -z "$OSGHOME" ] && (echo Please define OSGHOME; exit 1) +[ -z "$OSGVERSION" ] && (echo Please define OSGVERSION; exit 1) +[ -z "$OSGRELEASE" ] && (echo Please define OSGRELEASE; exit 1) + + + + +cat <<-LEOF > osg.spec + +Summary: Open Scene Graph +Name: OpenSceneGraph +Version: $OSGVERSION +Release: $OSGRELEASE +Copyright: GLPL +Group: Graphics +Source: osg-$OSGVERSION-$OSGRELEASE.tar.gz +URL: http://www.openscenegraph.org +Packager: `awk -f - /etc/passwd <<-EOF +BEGIN { FS=":"} +{ + if( \\$1 == "$LOGNAME" ) + print \\$5 +} +EOF` + +%description + +Open Scene Graph is an open-source scene graph API. + +%prep +%setup +%build +%install + +`list_install_files` + + + +# --------------------- +# FILES Sections +%files + +`list_attr_files` + +LEOF Index: /OpenSceneGraph/tags/osg_8_34/dist/RedHatRPM/Makefile =================================================================== --- /OpenSceneGraph/tags/osg_8_34/dist/RedHatRPM/Makefile (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/dist/RedHatRPM/Makefile (revision 2) @@ -0,0 +1,29 @@ +SHELL = /bin/sh + +BINDIRS = \ + OpenSceneGraph-${OSGVERSION}/bin/\ + OpenSceneGraph-${OSGVERSION}/include/\ + OpenSceneGraph-${OSGVERSION}/lib/\ + +all :: rpm + + +rpm : osg.spec tardist + rpm -bb --clean osg.spec + + +osg.spec : makespec + makespec + +tardist : + @[ -n "${OSGHOME}" ] || (echo Please define OSGHOME; exit 3) + @[ -n "${OSGVERSION}" ] || (echo Please define OSGVERSION; exit 4) + @[ -n "${OSGRELEASE}" ] || (echo Please define OSGRELEASE; exit 5) + @[ "`whoami`" = "root" ] || (echo Must be ROOT; exit 6) + (cd ${OSGHOME}/..; \ + tar cf - ${BINDIRS} | gzip > \ + /usr/src/redhat/SOURCES/osg-${OSGVERSION}-${OSGRELEASE}.tar.gz) + + +clean : + rm -f osg.spec Index: /OpenSceneGraph/tags/osg_8_34/dist/Irix/osg.spec =================================================================== --- /OpenSceneGraph/tags/osg_8_34/dist/Irix/osg.spec (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/dist/Irix/osg.spec (revision 2) @@ -0,0 +1,13 @@ +product osg + id "OpenSceneGraph" + image sw + id "Software" + version 1 + order 9999 + subsys base default + id "Base Software" + replaces self + exp osg.sw.base + endsubsys + endimage +endproduct Index: /OpenSceneGraph/tags/osg_8_34/dist/Irix/osg.idb =================================================================== --- /OpenSceneGraph/tags/osg_8_34/dist/Irix/osg.idb (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/dist/Irix/osg.idb (revision 2) @@ -0,0 +1,80 @@ +f 0755 root sys usr/bin/sgv bin/sgv osg.sw.base +d 0755 root sys usr/include/osg include/osg osg.sw.base +f 0666 root sys usr/include/osg/AlphaFunc include/osg/AlphaFunc osg.sw.base +f 0666 root sys usr/include/osg/Billboard include/osg/Billboard osg.sw.base +f 0666 root sys usr/include/osg/BoundingBox include/osg/BoundingBox osg.sw.base +f 0666 root sys usr/include/osg/BoundingSphere include/osg/BoundingSphere osg.sw.base +f 0666 root sys usr/include/osg/Camera include/osg/Camera osg.sw.base +f 0666 root sys usr/include/osg/CullFace include/osg/CullFace osg.sw.base +f 0666 root sys usr/include/osg/DCS include/osg/DCS osg.sw.base +f 0666 root sys usr/include/osg/DynamicLibrary include/osg/DynamicLibrary osg.sw.base +f 0666 root sys usr/include/osg/Export include/osg/Export osg.sw.base +f 0666 root sys usr/include/osg/ExtensionSupported include/osg/ExtensionSupported osg.sw.base +f 0666 root sys usr/include/osg/Field include/osg/Field osg.sw.base +f 0666 root sys usr/include/osg/FieldReader include/osg/FieldReader osg.sw.base +f 0666 root sys usr/include/osg/FieldReaderIterator include/osg/FieldReaderIterator osg.sw.base +f 0666 root sys usr/include/osg/FileNameUtils include/osg/FileNameUtils osg.sw.base +f 0666 root sys usr/include/osg/Fog include/osg/Fog osg.sw.base +f 0666 root sys usr/include/osg/GL include/osg/GL osg.sw.base +f 0666 root sys usr/include/osg/GeoSet include/osg/GeoSet osg.sw.base +f 0666 root sys usr/include/osg/GeoState include/osg/GeoState osg.sw.base +f 0666 root sys usr/include/osg/Geode include/osg/Geode osg.sw.base +f 0666 root sys usr/include/osg/Group include/osg/Group osg.sw.base +f 0666 root sys usr/include/osg/Image include/osg/Image osg.sw.base +f 0666 root sys usr/include/osg/Input include/osg/Input osg.sw.base +f 0666 root sys usr/include/osg/LOD include/osg/LOD osg.sw.base +f 0666 root sys usr/include/osg/Light include/osg/Light osg.sw.base +f 0666 root sys usr/include/osg/LightSource include/osg/LightSource osg.sw.base +f 0666 root sys usr/include/osg/Lighting include/osg/Lighting osg.sw.base +f 0666 root sys usr/include/osg/Material include/osg/Material osg.sw.base +f 0666 root sys usr/include/osg/Matrix include/osg/Matrix osg.sw.base +f 0666 root sys usr/include/osg/Node include/osg/Node osg.sw.base +f 0666 root sys usr/include/osg/NodeVisitor include/osg/NodeVisitor osg.sw.base +f 0666 root sys usr/include/osg/Notify include/osg/Notify osg.sw.base +f 0666 root sys usr/include/osg/OSG include/osg/OSG osg.sw.base +f 0666 root sys usr/include/osg/Object include/osg/Object osg.sw.base +f 0666 root sys usr/include/osg/Output include/osg/Output osg.sw.base +f 0666 root sys usr/include/osg/Point include/osg/Point osg.sw.base +f 0666 root sys usr/include/osg/PolygonOffset include/osg/PolygonOffset osg.sw.base +f 0666 root sys usr/include/osg/Quat include/osg/Quat osg.sw.base +f 0666 root sys usr/include/osg/Referenced include/osg/Referenced osg.sw.base +f 0666 root sys usr/include/osg/Registry include/osg/Registry osg.sw.base +f 0666 root sys usr/include/osg/Scene include/osg/Scene osg.sw.base +f 0666 root sys usr/include/osg/Seg include/osg/Seg osg.sw.base +f 0666 root sys usr/include/osg/Sequence include/osg/Sequence osg.sw.base +f 0666 root sys usr/include/osg/State include/osg/State osg.sw.base +f 0666 root sys usr/include/osg/Switch include/osg/Switch osg.sw.base +f 0666 root sys usr/include/osg/TexEnv include/osg/TexEnv osg.sw.base +f 0666 root sys usr/include/osg/TexGen include/osg/TexGen osg.sw.base +f 0666 root sys usr/include/osg/TexMat include/osg/TexMat osg.sw.base +f 0666 root sys usr/include/osg/Texture include/osg/Texture osg.sw.base +f 0666 root sys usr/include/osg/Timer include/osg/Timer osg.sw.base +f 0666 root sys usr/include/osg/Transparency include/osg/Transparency osg.sw.base +f 0666 root sys usr/include/osg/Types include/osg/Types osg.sw.base +f 0666 root sys usr/include/osg/Vec2 include/osg/Vec2 osg.sw.base +f 0666 root sys usr/include/osg/Vec3 include/osg/Vec3 osg.sw.base +f 0666 root sys usr/include/osg/Vec4 include/osg/Vec4 osg.sw.base +f 0666 root sys usr/include/osg/Version include/osg/Version osg.sw.base +d 0750 root sys usr/include/osgUtil include/osgUtil osg.sw.base +f 0666 root sys usr/include/osgUtil/CameraManipulator include/osgUtil/CameraManipulator osg.sw.base +f 0666 root sys usr/include/osgUtil/DisplayListVisitor include/osgUtil/DisplayListVisitor osg.sw.base +f 0666 root sys usr/include/osgUtil/DriveManipulator include/osgUtil/DriveManipulator osg.sw.base +f 0666 root sys usr/include/osgUtil/Export include/osgUtil/Export osg.sw.base +f 0666 root sys usr/include/osgUtil/FlightManipulator include/osgUtil/FlightManipulator osg.sw.base +f 0666 root sys usr/include/osgUtil/GUIActionAdapter include/osgUtil/GUIActionAdapter osg.sw.base +f 0666 root sys usr/include/osgUtil/GUIEventAdapter include/osgUtil/GUIEventAdapter osg.sw.base +f 0666 root sys usr/include/osgUtil/IntersectVisitor include/osgUtil/IntersectVisitor osg.sw.base +f 0666 root sys usr/include/osgUtil/RenderVisitor include/osgUtil/RenderVisitor osg.sw.base +f 0666 root sys usr/include/osgUtil/SceneView include/osgUtil/SceneView osg.sw.base +f 0666 root sys usr/include/osgUtil/TrackballManipulator include/osgUtil/TrackballManipulator osg.sw.base +f 0666 root sys usr/include/osgUtil/Version include/osgUtil/Version osg.sw.base +f 0755 root sys usr/lib32/libosg.so lib/libosg.so osg.sw.base +f 0755 root sys usr/lib32/libosgUtil.so lib/libosgUtil.so osg.sw.base +d 0755 root sys usr/lib32/osgPlugins lib/osgPlugins osg.sw.base +f 0755 root sys usr/lib32/osgPlugins/osgdb_flt.so lib/osgPlugins/osgdb_flt.so osg.sw.base +f 0755 root sys usr/lib32/osgPlugins/osgdb_fly.so lib/osgPlugins/osgdb_fly.so osg.sw.base +f 0755 root sys usr/lib32/osgPlugins/osgdb_jpg.so lib/osgPlugins/osgdb_jpg.so osg.sw.base +f 0755 root sys usr/lib32/osgPlugins/osgdb_osgtgz.so lib/osgPlugins/osgdb_osgtgz.so osg.sw.base +f 0755 root sys usr/lib32/osgPlugins/osgdb_pic.so lib/osgPlugins/osgdb_pic.so osg.sw.base +f 0755 root sys usr/lib32/osgPlugins/osgdb_tga.so lib/osgPlugins/osgdb_tga.so osg.sw.base +f 0755 root sys usr/lib32/osgPlugins/osgdb_tif.so lib/osgPlugins/osgdb_tif.so osg.sw.base Index: /OpenSceneGraph/tags/osg_8_34/dist/Irix/Makefile =================================================================== --- /OpenSceneGraph/tags/osg_8_34/dist/Irix/Makefile (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/dist/Irix/Makefile (revision 2) @@ -0,0 +1,16 @@ +SHELL = /bin/sh + + +all : irixdist tardist + + +irixdist : + cd ${OSGHOME}; [ -d irixdist ] || mkdir irixdist + cd ${OSGHOME}; \ + /usr/sbin/gendist -sbase ${OSGHOME} -idb dist/Irix/osg.idb -spec dist/Irix/osg.spec -dist irixdist -all + + +tardist : irixdist + cd ${OSGHOME}/irixdist;\ + tar cvf osg.tardist osg osg.idb osg.sw + Index: /OpenSceneGraph/tags/osg_8_34/include/osgGLUT/Export =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osgGLUT/Export (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osgGLUT/Export (revision 2) @@ -0,0 +1,22 @@ +// The following symbole has a underscore suffix for compatibility. +#ifndef OSGGLUT_EXPORT_ +#define OSGGLUT_EXPORT_ 1 + +#ifdef WIN32 + #pragma warning( disable : 4251 ) + #pragma warning( disable : 4275 ) + #pragma warning( disable : 4786 ) +#endif + +#if defined(_MSC_VER) + # ifdef OSGGLUT_LIBRARY + # define OSGGLUT_EXPORT __declspec(dllexport) + # else + # define OSGGLUT_EXPORT __declspec(dllimport) + #endif /* OSGGLUT_LIBRARY */ +#else + #define OSGGLUT_EXPORT +#endif + +#endif + Index: /OpenSceneGraph/tags/osg_8_34/include/osgGLUT/Viewer =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osgGLUT/Viewer (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osgGLUT/Viewer (revision 2) @@ -0,0 +1,147 @@ +#ifndef OSGGLUT_VIEWER +#define OSGGLUT_VIEWER 1 + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include + +#ifdef SGV_USE_RTFS +#include +#endif + +#include + +#ifdef OSG_USE_IO_DOT_H +#include +#else +#include +using namespace std; +#endif + +namespace osgGLUT{ + +/** A basic viewer base class which provides a window, simple keyboard and mouse interaction. + * Please note, this viewer class has been developed via a rather haphazzard + * path and *needs* a total rewrite. It currently surfices for osg demo's + * but shouldn't be viewed as the be all or end of osg viewer classes. + * Someone please rewrite it :-) + */ +class OSGGLUT_EXPORT Viewer : public osgUtil::GUIActionAdapter +{ + public: + + Viewer(); + virtual ~Viewer(); + + virtual bool init( osg::Node* ); + + virtual bool run(); + + // called on each frame redraw.. + virtual bool update(); + virtual bool traverse(); + virtual bool draw(); + + // initialize the clock. + long initClock(); + // time since initClock() in seconds. + float clockSeconds() { return _timer.delta_s(_initialTick,clockTick()); } + + // update the number of ticks since the last frame update. + osg::Timer_t updateFrameTick(); + + // time from the current frame update and the previous one in seconds. + float frameSeconds() { return _timer.delta_s(_lastFrameTick,_frameTick); } + float frameRate() { return 1.0f/frameSeconds(); } + + void help(ostream& fout); + + // hande multiple camera. + void registerCameraManipulator(osgUtil::CameraManipulator* cm); + void selectCameraManipulator(unsigned int pos); + + // derived from osgUtil::GUIActionAdapter + virtual void needRedraw(bool /*needed*/) {} // redraw always done. + virtual void needContinuousUpdate(bool /*needed*/) {} // continous update always + virtual void needWarpPointer(int x,int y); + + protected: + + static void displayCB(); + static void reshapeCB(GLint w, GLint h); + static void visibilityCB(int state); + static void mouseMotionCB(int x, int y); + static void mousePassiveMotionCB(int x, int y); + static void mouseCB(int button, int state, int x, int y); + static void keyboardCB(unsigned char key, int x, int y ); + + virtual void display(); + virtual void reshape(GLint w, GLint h); + virtual void visibility(int state); + virtual void mouseMotion(int x, int y); + virtual void mousePassiveMotion(int x, int y); + virtual void mouse(int button, int state, int x, int y); + virtual void keyboard(unsigned char key, int x, int y); + + + static Viewer* s_theViewer; + + osg::ref_ptr _sceneView; + + typedef std::vector > CameraManipList; + + osg::ref_ptr _cameraManipulator; + CameraManipList _cameraManipList; + + std::string _saveFileName; + + int ww, wh; + + #ifdef SGV_USE_RTFS + unsigned int frame_rate; + RTfs *fs; + #endif + + bool _viewFrustumCullingActive; + bool _smallFeatureCullingActive; + + int mx, my, mbutton; + int polymode; + int texture; + int backface; + int lighting; + int flat_shade; + int _two_sided_lighting; + bool fullscreen; + int _saved_ww,_saved_wh; + bool _printStats; + bool _useDisplayLists; + + osg::Timer _timer; + osg::Timer_t _tickRatePerSecond; + osg::Timer_t _initialTick; + osg::Timer_t _lastFrameTick; + osg::Timer_t _frameTick; + + // system tick. + osg::Timer_t clockTick(); + osg::Timer_t frameTick(); + + +}; + +} + +#endif // SG_VIEWIER_H Index: /OpenSceneGraph/tags/osg_8_34/include/osgGLUT/Version =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osgGLUT/Version (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osgGLUT/Version (revision 2) @@ -0,0 +1,35 @@ +#ifndef OSGGLUT_VERSION +#define OSGGLUT_VERSION 1 + +#include + + +extern "C" { + +/** + * getVersion_osgGLUT() returns the library version number. + * Numbering conventon : osg_src-0.8-31 will return 0.8.31 from getVersion_osgGLUT. + * + * This C function can be also used to check for the existance of the OpenSceneGraph + * library using autoconf and its m4 macro AC_CHECK_LIB. + * + * Here is the code to add to your configure.in: + \verbatim + # + # Check for the OpenSceneGraph (OSG) GLUT library + # + AC_CHECK_LIB(osg, osgGLUTGetVersion, , + [AC_MSG_ERROR(OpenSceneGraph GLUT library not found. See http://www.openscenegraph.org)],) + \endverbatim +*/ +extern OSGGLUT_EXPORT const char* osgGLUTGetVersion(); + +/** + * getLibraryName_osgGLUT() returns the library name in human friendly form. +*/ +extern OSGGLUT_EXPORT const char* osgGLUTGetLibraryName(); + +}; + +#endif + Index: /OpenSceneGraph/tags/osg_8_34/include/osgGLUT/GLUTEventAdapter =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osgGLUT/GLUTEventAdapter (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osgGLUT/GLUTEventAdapter (revision 2) @@ -0,0 +1,108 @@ +#ifndef OSGGLUT_GLUTEVENTADAPTER +#define OSGGLUT_GLUTEVENTADAPTER 1 + +#include + +#include + +namespace osgGLUT{ + +/** Class for adapting GLUT events so that they can be used as input to osgUtil::CameraManipulators.*/ +class OSGGLUT_EXPORT GLUTEventAdapter : public osgUtil::GUIEventAdapter +{ + + public: + GLUTEventAdapter(); + virtual ~GLUTEventAdapter() {} + + /** Get the EventType of the GUI event.*/ + virtual EventType getEventType() const { return _eventType; } + + /** key pressed, return -1 if inapropriate for this event. */ + virtual int getKey() const { return _key; } + + /** button pressed/released, return -1 if inappropriate for this event.*/ + virtual int getButton() const { return _button; } + + /** window minimum x. */ + virtual int getXmin() const { return _Xmin; } + + /** window maximum x. */ + virtual int getXmax() const { return _Xmax; } + + /** window minimum y. */ + virtual int getYmin() const { return _Ymin; } + + /** window maximum y. */ + virtual int getYmax() const { return _Ymax; } + + /** current mouse x position.*/ + virtual int getX() const { return _mx; } + + /** current mouse y position.*/ + virtual int getY() const { return _my; } + + /** current mouse button state */ + virtual unsigned int getButtonMask() const { return _buttonMask; } + + /** time in seconds of event. */ + virtual float time() const { return _time; } + + + /** static method for setting window dimensions.*/ + static void setWindowSize(int Xmin, int Ymin, int Xmax, int Ymax); + + /** static method for setting button state.*/ + static void setButtonMask(unsigned int buttonMask); + + /** method for adapting resize events. */ + void adaptResize(float t, int Xmin, int Ymin, int Xmax, int Ymax); + + /** method for adapting mouse motion events whilst mouse buttons are pressed.*/ + void adaptMouseMotion(float t, int x, int y); + + /** method for adapting mouse motion events whilst no mouse button are pressed.*/ + void adaptMousePassiveMotion(float t,int x, int y); + + /** method for adapting mouse button pressed/released events.*/ + void adaptMouse(float t,int button, int state, int x, int y); + + /** method for adapting keyboard events.*/ + void adaptKeyboard(float t,unsigned char key, int x, int y ); + + /** method for adapting frame events, i.e. iddle/display callback.*/ + void adaptFrame(float t); + + void copyStaticVariables(); + + protected: + + EventType _eventType; + int _key; + int _button; + int _Xmin,_Xmax; + int _Ymin,_Ymax; + int _mx; + int _my; + unsigned int _buttonMask; + float _time; + + // used to accumulate the button mask state, it represents + // the current button mask state, which is modified by the + // adaptMouse() method which then copies it to value _buttonMask + // which required the mouse buttons state at the time of the event. + static unsigned int _s_accumulatedButtonMask; + + // used to store window min and max values. + static int _s_Xmin; + static int _s_Xmax; + static int _s_Ymin; + static int _s_Ymax; + static int _s_mx; + static int _s_my; + +}; + +} + +#endif Index: /OpenSceneGraph/tags/osg_8_34/include/osgUtil/RenderVisitor =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osgUtil/RenderVisitor (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osgUtil/RenderVisitor (revision 2) @@ -0,0 +1,196 @@ +#ifndef OSGUTIL_RENDERVISITOR +#define OSGUTIL_RENDERVISITOR 1 + +#include +#include +#include +#include +#include +#include +#include + +#include + +#include +#include + +namespace osgUtil { + +/** Container class for encapsulating the viewing state in local + coordinates, during the cull traversal. +*/ +class OSGUTIL_EXPORT ViewState : public osg::Referenced +{ + public: + + ViewState(); + + osg::Matrix* _matrix; + osg::Matrix* _inverse; + osg::Vec3 _eyePoint; + osg::Vec3 _centerPoint; + osg::Vec3 _lookVector; + osg::Vec3 _upVector; + osg::Vec3 _frustumTopNormal; + osg::Vec3 _frustumBottomNormal; + osg::Vec3 _frustumLeftNormal; + osg::Vec3 _frustumRightNormal; + float _ratio; + + bool _viewFrustumCullingActive; + bool _smallFeatureCullingActive; + + bool isCulled(const osg::BoundingSphere& sp); + bool isCulled(const osg::BoundingBox& bb); + + protected: + + ~ViewState(); + +}; + + +/** + * Basic NodeVisitor implementation for rendering a scene. + * This visitor traverses the scene graph, collecting transparent and + * opaque osg::GeoSets into a depth sorted transparent bin and a state + * sorted opaque bin. The opaque bin is rendered first, and then the + * transparent bin in rendered in order from the furthest osg::GeoSet + * from the eye to the one nearest the eye. + */ +class OSGUTIL_EXPORT RenderVisitor : public osg::NodeVisitor +{ + public: + + RenderVisitor(); + virtual ~RenderVisitor(); + + void reset(); + + virtual void apply(osg::Node&); + virtual void apply(osg::Geode& node); + virtual void apply(osg::Billboard& node); + virtual void apply(osg::LightSource& node); + + virtual void apply(osg::Group& node); + virtual void apply(osg::DCS& node); + virtual void apply(osg::Switch& node); + virtual void apply(osg::LOD& node); + virtual void apply(osg::Scene& node); + + void setGlobalState(osg::GeoState* global); + + void setPerspective(const osg::Camera& camera); + void setPerspective(float fovy,float aspect,float znear,float zfar); + + void setLookAt(const osg::Camera& camera); + void setLookAt(const osg::Vec3& eye,const osg::Vec3& center,const osg::Vec3& upVector); + void setLookAt(double eyeX,double eyeY,double eyeZ, + double centerX,double centerY,double centerZ, + double upX,double upY,double upZ); + + + void setLODBias(float bias) { _LODBias = bias; } + float getLODBias() { return _LODBias; } + + enum TransparencySortMode { + LOOK_VECTOR_DISTANCE, + OBJECT_EYE_POINT_DISTANCE + }; + + void setTransparencySortMode(TransparencySortMode tsm) { _tsm = tsm; } + + enum CullingType { + VIEW_FRUSTUM_CULLING, + SMALL_FEATURE_CULLING + }; + + /** + * Enables/disables the specified culling type. + * @param ct The culling type to enable/disable. + * @param active true enables the culling type, false disables. + */ + void setCullingActive(CullingType ct, bool active); + + /** + * Returns the state of the specified culling type. + * @result true, if culling type is enabled, false otherwise. + */ + bool getCullingActive(CullingType ct); + + /** + * Calculates the near_plane and the far_plane for the current + * camera view depending on the objects currently stored in the + * opaque and transparent bins. + * @param near_plane reference to a variable that can store the + * near plane result. + * @param far_plane reference to a variable that can store the + * far plane result. + * @result true, if near_plane and far_plane contain valid values, + * false otherwise. + */ + bool calcNearFar(double& near_plane, double& far_plane); + + /** + * Renders the osg::GeoSets that were collected in the opaque and + * transparent bins before. + */ + void render(); + + protected: + + void pushMatrix(const osg::Matrix& matrix); + void popMatrix(); + + osg::Matrix* getCurrentMatrix(); + osg::Matrix* getInverseCurrentMatrix(); + const osg::Vec3& getEyeLocal(); + const osg::Vec3& getCenterLocal(); + const osg::Vec3& getLookVectorLocal(); + + + bool _viewFrustumCullingActive; + bool _smallFeatureCullingActive; + + bool isCulled(const osg::BoundingSphere& sp); + bool isCulled(const osg::BoundingBox& bb); + + typedef std::pair MatrixGeoSet; + + typedef std::vector ViewStateStack; + ViewStateStack _viewStateStack; + ViewState* _tvs; + ViewState* _cvs; + + + typedef std::multimap OpaqueList; + typedef std::multimap TransparentList; + typedef std::map LightList; + + OpaqueList _opaqueGeoSets; + TransparentList _transparentGeoSets; + LightList _lights; + + osg::GeoState* _globalState; + float _LODBias; + + float _fovy; + float _aspect; + float _znear; + float _zfar; + + void calculateClippingPlanes(); + + // frustum clipping normals. + osg::Vec3 _frustumTop; + osg::Vec3 _frustumBottom; + osg::Vec3 _frustumLeft; + osg::Vec3 _frustumRight; + + TransparencySortMode _tsm; +}; + +}; + +#endif + Index: /OpenSceneGraph/tags/osg_8_34/include/osgUtil/IntersectVisitor =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osgUtil/IntersectVisitor (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osgUtil/IntersectVisitor (revision 2) @@ -0,0 +1,142 @@ +#ifndef OSGUTIL_INTERSECTVISITOR +#define OSGUTIL_INTERSECTVISITOR 1 + +#include +#include +#include +#include + +#include + +#include +#include +#include + +namespace osgUtil { + +class OSGUTIL_EXPORT IntersectState : public osg::Referenced +{ + public: + + IntersectState(); + + osg::Matrix* _matrix; + osg::Matrix* _inverse; + + typedef std::vector< std::pair > SegList; + SegList _segList; + + typedef unsigned int SegmentMask; + typedef std::vector SegmentMaskStack; + SegmentMaskStack _segmentMaskStack; + + bool isCulled(const osg::BoundingSphere& bs,SegmentMask& segMaskOut); + bool isCulled(const osg::BoundingBox& bb,SegmentMask& segMaskOut); + + protected: + + ~IntersectState(); + +}; + +class OSGUTIL_EXPORT Hit : public osg::Referenced +{ + public: + Hit(); + Hit(const Hit& hit); + ~Hit(); + + Hit& operator = (const Hit& hit); + + typedef std::vector VecIndexList; + + bool operator < (const Hit& hit) const + { + if (_originalSeghit._originalSeg) return false; + return _ratio HitList; + typedef std::vector HitList; + typedef std::map SegHitListMap; + HitList& getHitList(osg::Seg* seg) { return _segHitList[seg]; } + int getNumHits(osg::Seg* seg) { return _segHitList[seg].size(); } + + bool hits(); + + virtual void apply(osg::Node&); + virtual void apply(osg::Geode& node); + virtual void apply(osg::Billboard& node); + + virtual void apply(osg::Group& node); + virtual void apply(osg::DCS& node); + virtual void apply(osg::Switch& node); + virtual void apply(osg::LOD& node); + virtual void apply(osg::Scene& node); + + protected: + + + bool intersect(osg::GeoSet& gset); + + void pushMatrix(const osg::Matrix& matrix); + void popMatrix(); + + bool enterNode(osg::Node& node); + void leaveNode(); + + typedef std::vector IntersectStateStack; + IntersectStateStack _intersectStateStack; + + osg::NodePath _nodePath; + + HitReportingMode _hitReportingMode; + SegHitListMap _segHitList; +}; + +}; + +#endif + Index: /OpenSceneGraph/tags/osg_8_34/include/osgUtil/DisplayListVisitor =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osgUtil/DisplayListVisitor (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osgUtil/DisplayListVisitor (revision 2) @@ -0,0 +1,72 @@ +#ifndef OSGUTIL_COMPILEGEOSETVISITOR +#define OSGUTIL_COMPILEGEOSETVISITOR 1 + +#include +#include + +#include + +namespace osgUtil { + +/** Visitor for traversing scene set each osg::GeoSet's _useDisplayList flag, or + * immediately compiling osg::GeoSet's OpenGL Display lists. The mode of operation + * of the vistor is controlled by setting the DisplayListMode either on visitor + * constructor or via the setDisplayListMode() method. DisplayListMode options are: + * _displayListMode == SWITCH_ON_AND_COMPILE_DISPLAY_LISTS cals gset->compile() on + * all Geode childern. Note, the visitor must only be used within a valid + * OpenGL context as compile uses OpenGL calls. + * _displayListMode == SWITCH_ON_DISPLAY_LISTS sets the Geode's children with + * gset->setUseDisplayList(true), this method does not directly create display list, + * or uses OpenGL calls so if safe to use before a valid OpenGL context has been set up. + * On the next redraw of the scene, the gset's draw methods will be called + * which then will respond to their _useDisplayList being set by creating display lists + * automatically. + * _displayListMode == SWITCH_OFF_DISPLAY_LISTS sets the Geode's children with + * gset->setUseDisplayList(false), this method does not directly create display list, + * or uses OpenGL calls so if safe to use before a valid OpenGL context has been set up. + */ +class OSGUTIL_EXPORT DisplayListVisitor : public osg::NodeVisitor +{ + public: + + /** Operation modes of the DisplayListVisitor.*/ + enum DisplayListMode + { + SWITCH_ON_AND_COMPILE_DISPLAY_LISTS, + SWITCH_ON_DISPLAY_LISTS, + SWITCH_OFF_DISPLAY_LISTS + }; + + /** Construct a CompileGeoSetsVisior to traverse all child, + * with set specfied display list mode. Default mode is to + * gset->setUseDisplayList(true). + */ + DisplayListVisitor(DisplayListMode mode=SWITCH_ON_DISPLAY_LISTS); + + /** Set the operational mode of how the visitor should set up osg::GeoSet's.*/ + void setDisplayListMode(DisplayListMode mode) { _displayListMode = mode; } + + /** Get the operational mode.*/ + DisplayListMode getDisplayListMode() const { return _displayListMode; } + + /** Simply traverse using standard NodeVisitor traverse method.*/ + virtual void apply(osg::Node& node) + { + traverse(node); + } + + /** For each Geode visited set the display list usage according to the + * _displayListMode. + */ + virtual void apply(osg::Geode& node); + + protected: + + DisplayListMode _displayListMode; + +}; + +}; + +#endif + Index: /OpenSceneGraph/tags/osg_8_34/include/osgUtil/Export =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osgUtil/Export (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osgUtil/Export (revision 2) @@ -0,0 +1,22 @@ +// The following symbole has a underscore suffix for compatibility. +#ifndef OSGUTIL_EXPORT_ +#define OSGUTIL_EXPORT_ 1 + +#ifdef WIN32 + #pragma warning( disable : 4251 ) + #pragma warning( disable : 4275 ) + #pragma warning( disable : 4786 ) +#endif + +#if defined(_MSC_VER) + # ifdef OSGUTIL_LIBRARY + # define OSGUTIL_EXPORT __declspec(dllexport) + # else + # define OSGUTIL_EXPORT __declspec(dllimport) + #endif /* OSGUTIL_LIBRARY */ +#else + #define OSGUTIL_EXPORT +#endif + +#endif + Index: /OpenSceneGraph/tags/osg_8_34/include/osgUtil/GUIActionAdapter =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osgUtil/GUIActionAdapter (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osgUtil/GUIActionAdapter (revision 2) @@ -0,0 +1,23 @@ +#ifndef OSGUTIL_GUIACTIONADAPTER +#define OSGUTIL_GUIACTIONADAPTER 1 + +#include + +namespace osgUtil{ + + +/** Pure virtual base class for adapting the GUI actions for use in CameraManipulators.*/ +class GUIActionAdapter +{ + public: + + virtual void needRedraw(bool needed=true) = 0; + virtual void needContinuousUpdate(bool needed=true) = 0; + virtual void needWarpPointer(int x,int y) = 0; + +}; + +} + +#endif + Index: /OpenSceneGraph/tags/osg_8_34/include/osgUtil/CameraManipulator =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osgUtil/CameraManipulator (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osgUtil/CameraManipulator (revision 2) @@ -0,0 +1,55 @@ +#ifndef OSGUTIL_CAMERAMANIPULATOR +#define OSGUTIL_CAMERAMANIPULATOR 1 + +#include +#include +#include +#include +#include + +namespace osgUtil{ + +class OSGUTIL_EXPORT CameraManipulator : public osg::Referenced +{ + public: + + CameraManipulator(); + virtual ~CameraManipulator(); + + /** attach a camera to the manipulator to be used for specifying view.*/ + virtual void setCamera(osg::Camera*); + + /** get the attached a camera.*/ + virtual osg::Camera * getCamera() const; + + /** Attach a node to the manipulator. + Automatically detaches previously attached node. + setNode(NULL) detaches previously nodes. + Is ignored by manipulators which do not require a reference model.*/ + virtual void setNode(osg::Node*) {} + + /** Return node if attached.*/ + virtual osg::Node* getNode() const { return NULL; } + + /** Move the camera to the default position. + May be ignored by manipulators if home functionality is not appropriate.*/ + virtual void home(GUIEventAdapter& ,GUIActionAdapter&) {} + + /** Start/restart the manipulator.*/ + virtual void init(GUIEventAdapter& ,GUIActionAdapter&) {} + + /** Handle events, return true if handled, false otherwise.*/ + virtual bool update(GUIEventAdapter& ea,GUIActionAdapter& us); + + + protected: + + // Reference pointer to a camera + osg::ref_ptr _camera; + +}; + +} + +#endif + Index: /OpenSceneGraph/tags/osg_8_34/include/osgUtil/DriveManipulator =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osgUtil/DriveManipulator (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osgUtil/DriveManipulator (revision 2) @@ -0,0 +1,68 @@ +#ifndef OSGUTIL_DRIVEMANIPULATOR +#define OSGUTIL_DRIVEMANIPULATOR 1 + +#include + +namespace osgUtil{ + +class OSGUTIL_EXPORT DriveManipulator : public CameraManipulator +{ + public: + + DriveManipulator(); + virtual ~DriveManipulator(); + + /** Attach a node to the manipulator. + Automatically detaches previously attached node. + setNode(NULL) detaches previously nodes. + Is ignored by manipulators which do not require a reference model.*/ + virtual void setNode(osg::Node*); + + /** Return node if attached.*/ + virtual osg::Node* getNode() const; + + /** Move the camera to the default position. + May be ignored by manipulators if home functionality is not appropriate.*/ + virtual void home(GUIEventAdapter& ea,GUIActionAdapter& us); + + /** Start/restart the manipulator.*/ + virtual void init(GUIEventAdapter& ea,GUIActionAdapter& us); + + /** handle events, return true if handled, false otherwise.*/ + virtual bool update(GUIEventAdapter& ea,GUIActionAdapter& us); + + private: + + /** Reset the internal GUIEvent stack.*/ + void flushMouseEventStack(); + /** Add the current mouse GUIEvent to internal stack.*/ + void addMouseEvent(GUIEventAdapter& ea); + + /** For the give mouse movement calculate the movement of the camera. + Return true is camera has moved and a redraw is required.*/ + bool calcMovement(); + + // Internal event stack comprising last three mouse events. + osg::ref_ptr _ga_t1; + osg::ref_ptr _ga_t0; + + osg::ref_ptr _node; + + float _modelScale; + float _velocity; + float _height; + float _buffer; + + enum SpeedControlMode { + USE_MOUSE_Y_FOR_SPEED, + USE_MOUSE_BUTTONS_FOR_SPEED + }; + + SpeedControlMode _speedMode; + +}; + +} + +#endif + Index: /OpenSceneGraph/tags/osg_8_34/include/osgUtil/Version =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osgUtil/Version (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osgUtil/Version (revision 2) @@ -0,0 +1,35 @@ +#ifndef OSGUTIL_VERSION +#define OSGUTIL_VERSION 1 + +#include + + +extern "C" { + +/** + * getVersion_osgUtil() returns the library version number. + * Numbering conventon : osg_src-0.8-31 will return 0.8.31 from getVersion_osgUtil. + * + * This C function can be also used to check for the existance of the OpenSceneGraph + * library using autoconf and its m4 macro AC_CHECK_LIB. + * + * Here is the code to add to your configure.in: + \verbatim + # + # Check for the OpenSceneGraph (OSG) utility library + # + AC_CHECK_LIB(osg, osgUtilGetVersion, , + [AC_MSG_ERROR(OpenSceneGraph utility library not found. See http://www.openscenegraph.org)],) + \endverbatim +*/ +extern OSGUTIL_EXPORT const char* osgUtilGetVersion(); + +/** + * getLibraryName_osgUtil() returns the library name in human friendly form. +*/ +extern OSGUTIL_EXPORT const char* osgUtilGetLibraryName(); + +}; + +#endif + Index: /OpenSceneGraph/tags/osg_8_34/include/osgUtil/GUIEventAdapter =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osgUtil/GUIEventAdapter (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osgUtil/GUIEventAdapter (revision 2) @@ -0,0 +1,80 @@ +#ifndef OSGUTIL_GUIEVENTADAPTER +#define OSGUTIL_GUIEVENTADAPTER 1 + +#include +#include + +namespace osgUtil{ + + +/** Pure virtual base class for adapting platform specfic events into + generic keyboard and mouse events. */ +class GUIEventAdapter : public osg::Referenced +{ + public: + + GUIEventAdapter() {} + + + enum MouseButtonMask { + LEFT_BUTTON=1, + MIDDLE_BUTTON=2, + RIGHT_BUTTON=4 + }; + + enum EventType { + PUSH, + RELEASE, + DRAG, + MOVE, + KEYBOARD, + FRAME, + RESIZE, + NONE + }; + + /** Get the EventType of the GUI event.*/ + virtual EventType getEventType() const = 0; + + /** key pressed, return -1 if inapropriate for this event. */ + virtual int getKey() const = 0; + + /** button pressed/released, return -1 if inappropriate for this event.*/ + virtual int getButton() const = 0; + + /** window minimum x. */ + virtual int getXmin() const = 0; + + /** window maximum x. */ + virtual int getXmax() const = 0; + + /** window minimum y. */ + virtual int getYmin() const = 0; + + /** window maximum y. */ + virtual int getYmax() const = 0; + + /** current mouse x position.*/ + virtual int getX() const = 0; + + /** current mouse y position.*/ + virtual int getY() const = 0; + + /** current mouse button state */ + virtual unsigned int getButtonMask() const = 0; + + /** time in seconds of event. */ + virtual float time() const = 0; + + + protected: + + /** Force users to create on heap, so that mulitple referencing is safe.*/ + virtual ~GUIEventAdapter() {} + +}; + +} + +#endif + Index: /OpenSceneGraph/tags/osg_8_34/include/osgUtil/SceneView =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osgUtil/SceneView (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osgUtil/SceneView (revision 2) @@ -0,0 +1,165 @@ +#ifndef OSGUTIL_SCENEVIEW +#define OSGUTIL_SCENEVIEW 1 + +#include +#include +#include +#include + +#include + +#include + +namespace osgUtil { + +/** + * SceneView is literaly 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: + + /** Constrcut a default scene view.*/ + SceneView(); + + /** 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(); } + + /** Set the viewport of the scene view. */ + void setViewport(int x,int y,int width,int height) + { + _view[0] = x; + _view[1] = y; + _view[2] = width; + _view[3] = height; + } + + /** Get the viewport of the scene view. */ + void getViewport(int& x,int& y,int& width,int& height) + { + x = _view[0]; + y = _view[1]; + width = _view[2]; + height = _view[3]; + } + + /** Set scene view to use default global state, light, camera + * and render visitor. + */ + void setDefaults(); + + /** 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::GeoState* state) { _globalState = state; } + osg::GeoState* 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() const { return _light.get(); } + + void setCamera(osg::Camera* camera) { _camera = camera; } + osg::Camera* getCamera() const { return _camera.get(); } + + void setRenderVisitor(osgUtil::RenderVisitor* rv) { _renderVisitor = rv; } + osgUtil::RenderVisitor* getRenderVisitor() const { return _renderVisitor.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 caclculates near and + far clipping planes for each frame. + */ + bool getCalcNearFar() { return _calc_nearfar; } + + /** 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; + + + virtual void cull(); + virtual void draw(); + + protected: + + virtual ~SceneView(); + + osg::ref_ptr _sceneData; + osg::ref_ptr _globalState; + osg::ref_ptr _light; + osg::ref_ptr _camera; + osg::ref_ptr _renderVisitor; + + bool _need_compile; + bool _calc_nearfar; + + osg::Vec4 _backgroundColor; + + double _near_plane; + double _far_plane; + + float _lodBias; + + // viewport x,y,width,height respectiveyly. + GLint _view[4]; + + // model and project matices, used by glUnproject to get + // to generate rays form the eyepoint through the mouse x,y. + GLdouble _model[16]; + GLdouble _proj[16]; + + LightingMode _lightingMode; + +}; + +}; + +#endif + Index: /OpenSceneGraph/tags/osg_8_34/include/osgUtil/FlightManipulator =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osgUtil/FlightManipulator (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osgUtil/FlightManipulator (revision 2) @@ -0,0 +1,69 @@ +#ifndef OSGUTIL_FLIGHTMANIPULATOR +#define OSGUTIL_FLIGHTMANIPULATOR 1 + +#include + +namespace osgUtil{ + +class OSGUTIL_EXPORT FlightManipulator : public CameraManipulator +{ + public: + + FlightManipulator(); + virtual ~FlightManipulator(); + + /** Attach a node to the manipulator. + Automatically detaches previously attached node. + setNode(NULL) detaches previously nodes. + Is ignored by manipulators which do not require a reference model.*/ + virtual void setNode(osg::Node*); + + /** Return node if attached.*/ + virtual osg::Node* getNode() const; + + /** Move the camera to the default position. + May be ignored by manipulators if home functionality is not appropriate.*/ + virtual void home(GUIEventAdapter& ea,GUIActionAdapter& us); + + /** Start/restart the manipulator.*/ + virtual void init(GUIEventAdapter& ea,GUIActionAdapter& us); + + /** handle events, return true if handled, false otherwise.*/ + virtual bool update(GUIEventAdapter& ea,GUIActionAdapter& us); + + enum YawControlMode { + YAW_AUTOMATICALLY_WHEN_BANKED, + NO_AUTOMATIC_YAW + }; + + /** Set the yaw control between no yaw and yawing when banked.*/ + void setYawControlMode(YawControlMode ycm) { _yawMode = ycm; } + + private: + + /** Reset the internal GUIEvent stack.*/ + void flushMouseEventStack(); + /** Add the current mouse GUIEvent to internal stack.*/ + void addMouseEvent(GUIEventAdapter& ea); + + /** For the give mouse movement calculate the movement of the camera. + Return true is camera has moved and a redraw is required.*/ + bool calcMovement(); + + // Internal event stack comprising last three mouse events. + osg::ref_ptr _ga_t1; + osg::ref_ptr _ga_t0; + + osg::ref_ptr _node; + + float _modelScale; + float _velocity; + + YawControlMode _yawMode; + +}; + +} + +#endif + Index: /OpenSceneGraph/tags/osg_8_34/include/osgUtil/TrackballManipulator =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osgUtil/TrackballManipulator (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osgUtil/TrackballManipulator (revision 2) @@ -0,0 +1,70 @@ +#ifndef OSGUTIL_TRACKBALLMANIPULATOR +#define OSGUTIL_TRACKBALLMANIPULATOR 1 + +#include + +namespace osgUtil{ + +class OSGUTIL_EXPORT TrackballManipulator : public CameraManipulator +{ + public: + + TrackballManipulator(); + virtual ~TrackballManipulator(); + + /** Attach a node to the manipulator. + Automatically detaches previously attached node. + setNode(NULL) detaches previously nodes. + Is ignored by manipulators which do not require a reference model.*/ + virtual void setNode(osg::Node*); + + /** Return node if attached.*/ + virtual osg::Node* getNode() const; + + /** Move the camera to the default position. + May be ignored by manipulators if home functionality is not appropriate.*/ + virtual void home(GUIEventAdapter& ea,GUIActionAdapter& us); + + /** Start/restart the manipulator.*/ + virtual void init(GUIEventAdapter& ea,GUIActionAdapter& us); + + + /** handle events, return true if handled, false otherwise.*/ + virtual bool update(GUIEventAdapter& ea,GUIActionAdapter& us); + + private: + + /** Reset the internal GUIEvent stack.*/ + void flushMouseEventStack(); + /** Add the current mouse GUIEvent to internal stack.*/ + void addMouseEvent(GUIEventAdapter& ea); + + /** For the give mouse movement calculate the movement of the camera. + Return true is camera has moved and a redraw is required.*/ + bool calcMovement(); + + void trackball(osg::Vec3& axis,float& angle, float p1x, float p1y, float p2x, float p2y); + float tb_project_to_sphere(float r, float x, float y); + + + /** Check the speed at which the mouse is moving. + If speed is below a threshold then return false, otherwise return true.*/ + bool isMouseMoving(); + + // Internal event stack comprising last three mouse events. + osg::ref_ptr _ga_t1; + osg::ref_ptr _ga_t0; + + osg::ref_ptr _node; + + float _modelScale; + float _minimumZoomScale; + + bool _thrown; + +}; + +} + +#endif + Index: /OpenSceneGraph/tags/osg_8_34/include/osg/State =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osg/State (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osg/State (revision 2) @@ -0,0 +1,22 @@ +#ifndef OSG_STATE +#define OSG_STATE 1 + +#include + +namespace osg { + +class SG_EXPORT State +{ + public : + State( void ); + ~State( void ); + + private : + GeoState *initial; + GeoState *req; + GeoState *current; +}; + +}; + +#endif Index: /OpenSceneGraph/tags/osg_8_34/include/osg/Timer =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osg/Timer (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osg/Timer (revision 2) @@ -0,0 +1,77 @@ +#ifndef OSG_TIMER +#define OSG_TIMER 1 + +#include + +namespace osg { + +#ifdef WIN32 + typedef __int64 Timer_t; +#else + typedef unsigned long long Timer_t; +#endif + +class SG_EXPORT Timer { + + public: + + Timer( void ); + ~Timer( void ); + + +#ifdef WIN32 + #pragma optimize("",off) + inline Timer_t tick( void ) + { + volatile Timer_t ts; + volatile unsigned int HighPart; + volatile unsigned int LowPart; + _asm + { + xor eax, eax // Used when QueryPerformanceCounter() + xor edx, edx // not supported or minimal overhead + _emit 0x0f // desired + _emit 0x31 // + mov HighPart,edx + mov LowPart,eax + } + //ts = LowPart | HighPart >> 32; + *((unsigned int*)&ts) = LowPart; + *((unsigned int*)&ts+1) = HighPart; + return ts; + } + #pragma optimize("",on) +#endif +#ifdef __linux + #define CLK(x) __asm__ volatile (".byte 0x0f, 0x31" : "=A" (x)) + inline Timer_t tick( void ) {Timer_t x;CLK(x);return x;} +#endif +#ifdef __sgi + inline Timer_t tick( void ) { return *clk; } +#endif + double delta_s( Timer_t t1, Timer_t t2 ); + double delta_m( Timer_t t1, Timer_t t2 ); + + Timer_t delta_u( Timer_t t1, Timer_t t2 ); + Timer_t delta_n( Timer_t t1, Timer_t t2 ); + + + private : + + double microseconds_per_click; + double nanoseconds_per_click; + unsigned long *clk; + int cycleCntrSize; + static unsigned long dummy; + + static int inited; + static double cpu_mhz; + void init( void ); + + + +}; + + +}; +#endif Index: /OpenSceneGraph/tags/osg_8_34/include/osg/ExtensionSupported =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osg/ExtensionSupported (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osg/ExtensionSupported (revision 2) @@ -0,0 +1,15 @@ +#ifndef OSG_EXTENSIONSUPPORTED +#define OSG_EXTENSIONSUPPORTED 1 + +#include + +namespace osg { + +/** return true if OpenGL "extension" is supported. + note: Must only called within a valid OpenGL context, + undefined behaviour may occur otherwise.*/ +SG_EXPORT extern bool ExtensionSupported(const char *extension); + +}; + +#endif Index: /OpenSceneGraph/tags/osg_8_34/include/osg/Geode =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osg/Geode (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osg/Geode (revision 2) @@ -0,0 +1,108 @@ +#ifndef OSG_GEODE +#define OSG_GEODE 1 + +#include + +#include +#include +#include + +#include + +namespace osg { + +/** Leaf Node for grouping GeoSets.*/ +class SG_EXPORT Geode : public Node +{ + public: + + typedef std::vector< ref_ptr > GeoSetList; + + Geode(); + + virtual Object* clone() const { return new Geode(); } + virtual bool isSameKindAs(Object* obj) { return dynamic_cast(obj)!=NULL; } + virtual const char* className() const { return "Geode"; } + virtual void accept(NodeVisitor& nv) { nv.apply(*this); } + + /** Add GeoSet to Geode. + * If gset is not NULL and is not contained in Geode then increment its + * reference count, add it to the geosets list and dirty the bounding + * sphere to force it to recompute on next getBound() and return true for success. + * Otherwise return false. + */ + virtual bool addGeoSet( GeoSet *gset ); + + /** Remove GeoSet from Geode. + * If gset is contained in Geode then remove it from the geoset + * list and decrement its reference count, and dirty the + * bounding sphere to force it to recompute on next getBound() and + * return true for success. If gset is not found then return false + * and do not change the reference count of gset. + */ + virtual bool removeGeoSet( GeoSet *gset ); + + /** Replace specified GeoSet with another GeoSet. + * Decrement the reference count origGSet and increments the + * reference count of newGset, and dirty the bounding sphere + * to force it to recompute on next getBound() and returns true. + * If origGeoSet is not found then return false and do not + * add newGset. If newGset is NULL then return false and do + * not remove origGset. + */ + virtual bool replaceGeoSet( GeoSet *origGset, GeoSet *newGset ); + + + /** return the number of geoset's.*/ + int getNumGeosets( void ) const { return _geosets.size(); } + + /** return geoset at position i.*/ + GeoSet* getGeoSet( int i ) { return _geosets[i].get(); } + + /** return true is geoset is contained within Geode.*/ + bool containsGeoSet( GeoSet* gset) + { + + for (GeoSetList::iterator itr=_geosets.begin(); + itr!=_geosets.end(); + ++itr) + { + if (itr->get()==gset) return true; + } + return false; + } + + /** return the iterator postion for specified GeoSet. + * return _geoset.end() if gset not is contained in Geode. + */ + GeoSetList::iterator findGeoSet( GeoSet* gset) + { + + for (GeoSetList::iterator itr=_geosets.begin(); + itr!=_geosets.end(); + ++itr) + { + if (itr->get()==gset) return itr; + } + return _geosets.end(); + } + + /** complile OpenGL Display List for each geoset.*/ + void compileGeoSets( void ); + + protected: + + virtual ~Geode(); + + virtual bool readLocalData(Input& fr); + virtual bool writeLocalData(Output& fw); + + virtual bool computeBound( void ); + + GeoSetList _geosets; + +}; + +}; + +#endif Index: /OpenSceneGraph/tags/osg_8_34/include/osg/Field =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osg/Field (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osg/Field (revision 2) @@ -0,0 +1,100 @@ +#ifndef OSG_FIELD +#define OSG_FIELD 1 + +#include +#include +#include + +namespace osg { + + +class SG_EXPORT Field +{ + public: + + enum { + MIN_CACHE_SIZE = 256 + }; + + Field(); + Field(const Field& field); + virtual ~Field(); + + virtual Field& operator = (const Field& ic); + + void reset(); + void addChar(char c); + int getNoCharacters() const { return _fieldCacheSize; } + + void setWithinQuotes(bool withinQuotes=true); + bool getWithinQuotes(); + + void setNoNestedBrackets(int no); + int getNoNestedBrackets(); + + enum FieldType + { + OPEN_BRACKET, + CLOSE_BRACKET, + STRING, + WORD, + REAL, + INTEGER, + BLANK, + UNINTIALISED + }; + + FieldType getFieldType() const; + + bool isValid() const; + + bool isOpenBracket() const; + bool isCloseBracket() const; + + bool isWord() const; + bool matchWord(const char* str) const; + bool matchWord(const char* str,int noCharacters) const; + + bool isString() const; + bool matchString(const char* str) const; + bool matchString(const char* str,int noCharacters) const; + bool isQuotedString() const; + + const char* getStr() const; + char* takeStr(); + + bool isInt() const; + bool matchInt(int i) const; + bool getInt(int& i) const; + + bool isFloat() const; + bool matchFloat(float f) const; + bool getFloat(float& f) const; + + bool isDouble() const; + bool matchDouble(double f) const; + bool getDouble(double& d) const; + + static FieldType calculateFieldType(const char* str,bool withinQuotes=false); + + protected: + + void _init(); + void _free(); + void _copy(const Field& ic); + + int _fieldCacheCapacity; + int _fieldCacheSize; + char* _fieldCache; + + mutable FieldType _fieldType; + + bool _withinQuotes; + + int _noNestedBrackets; + +}; + +}; + +#endif // __SG_FIELD_H Index: /OpenSceneGraph/tags/osg_8_34/include/osg/Node =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osg/Node (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osg/Node (revision 2) @@ -0,0 +1,211 @@ +#ifndef OSG_NODE +#define OSG_NODE 1 + +#include +#include +#include + +#include +#include + +namespace osg { + +class NodeVisitor; +class Group; + +/** Class for adapting the memory management of external data. + * Typically used to specify the memory management of user data + * which can be attached to osg::Node. + */ +class SG_EXPORT MemoryAdapter : public Referenced +{ + public: + MemoryAdapter() {} + + /** Increment the reference count of the userData.*/ + virtual void incrementReference(void* /*userData*/) = 0; + + /** Decrement the reference count of the userData. + Is usually implemented such that if reference count + is decremented to zero the userData should be + deleted. However, this is entirely up to the + discression of the user who is extending this base class.*/ + virtual void decrementReference(void* /*userData*/) = 0; + + /** not current used, but will be used in future.*/ + virtual void* clone(void* /*userData*/) { return 0L; } + + /** not current used, but will be used in future.*/ + virtual bool write(Output& /*fw*/,void* /*userData*/) { return false; } + + /** not current used, but will be used in future.*/ + virtual bool read(Input& /*fr*/,void* /*userData*/) { return false; } + + protected: + + virtual ~MemoryAdapter() {} +}; + +/** Base class for all internal nodes in the scene graph. + Provides interface for most common node operations (Composite Pattern). +*/ +class SG_EXPORT Node : public Object +{ + public: + + /** Construct a node. + Initialize the parent list to empty, node name to "" and + bounding sphere dirty flag to true.*/ + Node(); + + /** return a shallow copy of a node, with Object* return type.*/ + virtual Object* clone() const { return new Node(); } + /** return a shallow copy of a node, with Node* return type.*/ + Node* cloneNode() const { return (Node*)clone(); } + + /** return true if this and obj are of the same kind of object.*/ + virtual bool isSameKindAs(Object* obj) { return dynamic_cast(obj)!=NULL; } + + /** return the name of the node's class type.*/ + virtual const char* className() const { return "Node"; } + + /** Visitor Pattern : calls the apply method of a NodeVisitor with this node's type.*/ + virtual void accept(NodeVisitor& nv); + /** Traverse upwards : calls parents' accept method with NodeVisitor.*/ + virtual void ascend(NodeVisitor& nv); + /** Traverse downwards : calls children's accept method with NodeVisitor.*/ + virtual void traverse(NodeVisitor& /*nv*/) {} + + + /** Set the name of node using C++ style string.*/ + void setName( const std::string& name ) { _name = name; } + /** Set the name of node using a C style string.*/ + void setName( const char* name ) { _name = name; } + /** Get the name of node.*/ + const std::string& getName( void ) { return _name; } + + + /** A vector of osg::Group pointers which is used to store the parent(s) of node.*/ + typedef std::vector ParentList; + + /** Get the parent list of node. */ + const ParentList& getParents() const { return _parents; } + /** + * Get a single parent of node. + * @param i index of the parent to get. + * @return the parent i. + */ + Group* getParent(int i) const { return _parents[i]; } + /** + * Get the number of parents of node. + * @return the number of parents of this node. + */ + int getNumParents() const { return _parents.size(); } + + + /** + * Set user data. See MemoryAdapter documention for details + * of how to specify memory managament of _userData. + */ + void setUserData(void* data,MemoryAdapter* ma=0L) + { + if (_userData && _memoryAdapter.valid()) _memoryAdapter->decrementReference(_userData); + _userData = data; + _memoryAdapter = ma; + if (_userData && _memoryAdapter.valid()) _memoryAdapter->incrementReference(_userData); + } + /** Get user data.*/ + void* getUserData() const { return _userData; } + + /** Get the memory adapter associated with _userData.*/ + MemoryAdapter* getMemoryAdapter() const { return _memoryAdapter.get(); } + + + typedef unsigned int NodeMask; + /** Set the node mask. Note, node mask is will be replaced by TraversalMask.*/ + void setNodeMask(NodeMask nm) { _nodeMask = nm; } + /** Get the node Mask. Note, node mask is will be replaced by TraversalMask.*/ + NodeMask getNodeMask() { return _nodeMask; } + + + + /** A vector of std::string's which are used to describe the object.*/ + typedef std::vector DescriptionList; + + /** Get the description list of the const node.*/ + const DescriptionList& getDescriptions() const { return _descriptions; } + /** Get the description list of the const node.*/ + DescriptionList& getDescriptions() { return _descriptions; } + /** Get a single const description of the const node.*/ + const std::string& getDescription(int i) const { return _descriptions[i]; } + /** Get a single description of the node.*/ + std::string& getDescription(int i) { return _descriptions[i]; } + /** Get the number of descriptions of the node.*/ + int getNumDescriptions() const { return _descriptions.size(); } + /** Add a description string to the node.*/ + void addDescription(const std::string& desc) { _descriptions.push_back(desc); } + + /** get the bounding sphere of node. + Using lazy evaluation computes the bounding sphere if it is 'dirty'.*/ + const BoundingSphere& getBound(); + + /** Mark this node's bounding sphere dirty. + Forcing it to be computed on the next call to getBound().*/ + void dirtyBound(); + + + protected: + + /** Node destructor. Note, is protected so that Nodes cannot + be deleted other than by being dereferenced and the reference + count being zero (see osg::Referenced), preventing the deletion + of nodes which are still in use. This also means that + Node's cannot be created on stack i.e Node node will not compile, + forcing all nodes to be created on the heap i.e Node* node + = new Node().*/ + virtual ~Node(); + + /** + * Template Method Pattern : read local data from .osg file. + * Note should be implemented in derived classes, which + * call their parent class's readLocalData. + * @return true if the input iterator has been advanced, otherwise false. + */ + virtual bool readLocalData(Input& fr); + + /** + * Template Method Pattern : read local data from .osg file. + * Note should be implemented in derivied classes, which + * call their parent class's writeLocalData. + * @return true if data has been written out, otherwise false. + */ + virtual bool writeLocalData(Output& fw); + + /** Compute the bounding sphere around Node's geometry or children. + This method is automatically called by getBound() when the bounding + sphere has been marked dirty via dirtyBound().*/ + virtual bool computeBound( void ) ; + + BoundingSphere _bsphere; + bool _bsphere_computed; + + std::string _name; + + ParentList _parents; + friend Group; + + void* _userData; + ref_ptr _memoryAdapter; + + NodeMask _nodeMask; + + DescriptionList _descriptions; + +}; + +/** A vector of Nodes pointers which is used to describe the path from a root node to a descendant.*/ +typedef std::vector NodePath; + +}; + +#endif Index: /OpenSceneGraph/tags/osg_8_34/include/osg/Version =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osg/Version (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osg/Version (revision 2) @@ -0,0 +1,33 @@ +#ifndef OSG_VERSION +#define OSG_VERSION 1 + +#include + +extern "C" { + +/** + * getVersion_osg() returns the library version number. + * Numbering conventon : osg_src-0.8-31 will return 0.8.31 from getVersion_osg. + * + * This C function can be also used to check for the existance of the OpenSceneGraph + * library using autoconf and its m4 macro AC_CHECK_LIB. + * + * Here is the code to add to your configure.in: + \verbatim + # + # Check for the OpenSceneGraph (OSG) library + # + AC_CHECK_LIB(osg, osgGetVersion, , + [AC_MSG_ERROR(OpenSceneGraph library not found. See http://www.openscenegraph.org)],) + \endverbatim +*/ +extern SG_EXPORT const char* osgGetVersion(); + +/** + * getLibraryName_osg() returns the library name in human friendly form. +*/ +extern SG_EXPORT const char* osgGetLibraryName(); + +}; + +#endif Index: /OpenSceneGraph/tags/osg_8_34/include/osg/OSG =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osg/OSG (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osg/OSG (revision 2) @@ -0,0 +1,15 @@ +#ifndef OSG_OSG +#define OSG_OSG 1 + +#include + +namespace osg { + +SG_EXPORT extern void Init( void ); +SG_EXPORT extern void SetFilePath( const char *_path ); +SG_EXPORT extern char *FindFile( const char *file ); +SG_EXPORT extern char *findDSO( const char *name ); + +}; + +#endif Index: /OpenSceneGraph/tags/osg_8_34/include/osg/Camera =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osg/Camera (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osg/Camera (revision 2) @@ -0,0 +1,140 @@ +#ifndef OSG_CAMERA +#define OSG_CAMERA 1 + +#include +#include + +namespace osg { + +/** Camera class for encapsulating the view position and orientation. + * This is the first implementation of osg::Camera class and + * currently is a perspective camera, but in future will be + * a base class from which PerpsectivCamera,FrustumCamera and OrthoCamera + * will be derived. + */ +class SG_EXPORT Camera: public osg::Referenced +{ + + public: + + Camera(); + virtual ~Camera(); + + + /** + * Set field of view and window aspect ratio. + * The parameters have the same meaning as their counterparts + * in gluPerspective(fovy,aspectRatio + */ + void setFieldOfView(double fovy,double aspectRatio); + + void setFieldOfViewY(double fovy) { _fovy = fovy; } + double getFieldOfViewY() const { return _fovy; } + + void setAspectRatio(double aspectRatio) { _aspectRatio = aspectRatio; } + double getAspectRatio() const { return _aspectRatio; } + + /** + * hardwired home view for now, looking straight down the + * Z axis at the origin, with 'up' being the y axis. + */ + void home(); + + /** + * Set the View, the up vector should be orthogonal to the + * look vector. + */ + void setView(Vec3 eyePoint, + Vec3 lookPoint, + Vec3 upVector); + + /** get the eyepoint. */ + const Vec3& getEyePoint() const {return _eyePoint;} + + /** get the lookpoint. */ + const Vec3& getLookPoint() const {return _lookPoint;} + + /** which way is up? */ + const Vec3& getUpVector() const {return _upVector;} + + /** calculate side vector.*/ + Vec3 getSideVector() const + { + Vec3 sv = (_lookPoint-_eyePoint)^_upVector; + sv.normalize(); + return sv; + } + + /** calculate look vector.*/ + Vec3 getLookVector() const + { + Vec3 lv = (_lookPoint-_eyePoint); + lv.normalize(); + return lv; + } + + /** calculate focal distance.*/ + float getFocalDistance() const + { + return (_lookPoint-_eyePoint).length(); + } + + /** set the near plane. */ + void setNearPlane(double nearPlane) {_nearPlane=nearPlane;} + + /**get the near plane. */ + double getNearPlane() const {return _nearPlane;} + + /** set the far plane. */ + void setFarPlane(double farPlane) {_farPlane=farPlane;} + + /** get the far plane. */ + double getFarPlane() const {return _farPlane;} + + + + /** Set up the OpenGL GL_PROJECTION matrix. + Enters the GL_PROJECTION mode, sets up matrix, then + resets model GL_MODELVIEW, which is by OpenGL convention the default.*/ + void draw_PROJECTION() const; + + /** Set up the OpenGL GL_MODELVIEW matrix. + * Enters the GL_MODELVIEW mode, sets matrix to identity + * and then sets matrix up according to camera, eye point, center + * point and upvector. + */ + void draw_MODELVIEW() const; + + + + /** post multiply a camera by matrix.*/ + void mult(const Camera& camera,const Matrix& m); + + /** pre multiply a camera by matrix.*/ + void mult(const Matrix& m,const Camera& camera); + + void ensureOrthogonalUpVector(); + + + private: + + // Disallow copy construction & assignment (for now) + Camera(const Camera&); + Camera& operator=(const Camera&); + + Vec3 _eyePoint; + Vec3 _lookPoint; + Vec3 _upVector; + + double _fovy; + double _aspectRatio; + + double _nearPlane; // No Dougal, these are small... but those... + double _farPlane; // are far away + + +}; + +} + +# endif Index: /OpenSceneGraph/tags/osg_8_34/include/osg/Billboard =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osg/Billboard (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osg/Billboard (revision 2) @@ -0,0 +1,84 @@ +#ifndef OSG_BILLBOARD +#define OSG_BILLBOARD 1 + +#include + +namespace osg { + +/** Billboard - a Geode which orientates its child osg::GeoSet's to face + the eye point. + Typical uses are for trees, or particle explosions. +*/ +class SG_EXPORT Billboard : public Geode +{ + public: + + enum Mode { + AXIAL_ROT, + POINT_ROT_EYE, + POINT_ROT_WORLD + }; + + Billboard(); + + virtual Object* clone() const { return new Billboard(); } + virtual bool isSameKindAs(Object* obj) { return dynamic_cast(obj)!=NULL; } + virtual const char* className() const { return "Billboard"; } + virtual void accept(NodeVisitor& nv) { nv.apply(*this); } + + + void setAxis(const Vec3& axis) { _axis = axis; } + void getAxis(Vec3& axis) const { axis = _axis; } + + void setMode(Mode mode) { _mode = mode; } + int getMode() const { return _mode; } + + void setPos(int i,const Vec3& pos) { _positionList[i] = pos; } + void getPos(int i,Vec3& pos) const { pos = _positionList[i]; } + + /** Add GeoSet to Billboard with default position(0,0,0); + * If gset not NULL and is not contained in Billboard then increment its + * reference count, and dirty the bounding box to cause it to recompute on + * next getBound() and return true for success. Otherwise return false. + */ + virtual bool addGeoSet( GeoSet *gset ); + + /** Add GeoSet to Geode at position pos. + * If gset not NULL and is not contained in Billboard then increment its + * reference count, and dirty the bounding box to cause it to recompute on + * next getBound() and return true for success. Otherwise return false. + */ + virtual bool addGeoSet(GeoSet *gset,const Vec3& pos); + + /** Remove GeoSet and associated position from Billboard. + * If gset is contained in Billboard then remove it from the geoset + * list and decrement its reference count, and dirty the + * bounding box to cause it to recompute on next getBound() and + * return true for success. If gset is not found then return false + * and do not the reference count of gset is left unchanged. + */ + virtual bool removeGeoSet( GeoSet *gset ); + + void calcRotation(const Vec3& eye_local, const Vec3& pos_local,Matrix& mat); + void calcTransform(const Vec3& eye_local, const Vec3& pos_local,Matrix& mat); + + protected: + + virtual ~Billboard(); + + virtual bool readLocalData(Input& fr); + virtual bool writeLocalData(Output& fw); + + virtual bool computeBound( void ); + + typedef std::vector PositionList; + + Mode _mode; + Vec3 _axis; + PositionList _positionList; + +}; + +}; + +#endif Index: /OpenSceneGraph/tags/osg_8_34/include/osg/Scene =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osg/Scene (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osg/Scene (revision 2) @@ -0,0 +1,39 @@ +#ifndef OSG_SCENE +#define OSG_SCENE 1 + +#include +#include + +namespace osg { + +/** The top level group node in a scene graph. */ +class SG_EXPORT Scene : public Group +{ + public : + Scene(); + + virtual Object* clone() const { return new Scene(); } + virtual bool isSameKindAs(Object* obj) { return dynamic_cast(obj)!=NULL; } + virtual const char* className() const { return "Scene"; } + virtual void accept(NodeVisitor& nv) { nv.apply(*this); } + + /** set the scene's GeoState.*/ + void setGState(osg::GeoState* gstate); + + /** return the scene's GeoState.*/ + osg::GeoState* getGState() { return _gstate; } + + protected : + + virtual ~Scene(); + + virtual bool readLocalData(Input& fr); + virtual bool writeLocalData(Output& fw); + + osg::GeoState* _gstate; + +}; + +}; + +#endif Index: /OpenSceneGraph/tags/osg_8_34/include/osg/Output =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osg/Output (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osg/Output (revision 2) @@ -0,0 +1,98 @@ +#ifndef OSG_OUTPUT +#define OSG_OUTPUT 1 + +#include + +#include +#include + +#ifdef OSG_USE_IO_DOT_H +#include +#else +#include +using namespace std; +#endif + +namespace osg { + +class Object; + +/** ofstream wrapper class for adding support for indenting. + Used in output of .osg ASCII files to improve their readability.*/ +class SG_EXPORT Output : public ofstream +{ + public: + + Output(); + virtual ~Output(); + + Output& indent(); + + int getIndentStep() const { return _indentStep; } + void setIndentStep(int step) { _indentStep = step; } + + int getIndent() const { return _indent; } + void setIndent(int indent) { _indent = indent; } + + int getNumIndicesPerLine() const { return _numIndicesPerLine; } + void setNumIndicesPerLine(int num) { _numIndicesPerLine = num; } + + void moveIn(); + void moveOut(); + + bool getUniqueIDForObject(Object* obj,std::string& uniqueID); + bool createUniqueIDForObject(Object* obj,std::string& uniqueID); + bool registerUniqueIDForObject(Object* obj,std::string& uniqueID); + + + protected: + + // prevent copy construction and assignment. + Output(const Output&) : ofstream() {} + Output& operator = (const Output&) { return *this; } + + virtual void _init(); + virtual void _free(); + + int _indent; + int _indentStep; + + int _numIndicesPerLine; + + typedef std::map UniqueIDToLabelMapping; + UniqueIDToLabelMapping _objectToUniqueIDMap; + +}; + +template +bool writeArrayBlock(Output& fw,T* start,T* finish) +{ + fw.indent() << "{" << endl; + fw.moveIn(); + int numIndicesThisLine = 0; + for(T* itr=start;itr!=finish;++itr) + { + if (numIndicesThisLine>=fw.getNumIndicesPerLine()) + { + fw << endl; + numIndicesThisLine = 0; + } + + if (numIndicesThisLine==0) fw.indent(); + else fw << " "; + + fw << *itr; + + ++numIndicesThisLine; + + } + fw << endl; + fw.moveOut(); + fw.indent() << "}" << endl; + return true; +} + + +}; + +#endif // __SG_OUTPUT_H Index: /OpenSceneGraph/tags/osg_8_34/include/osg/Texture =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osg/Texture (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osg/Texture (revision 2) @@ -0,0 +1,104 @@ +#ifndef OSG_TEXTURE +#define OSG_TEXTURE 1 + +#include +#include +#include +#include + +namespace osg { + + +class Input; +class Output; + +/** Texture state class which encapsulates OpenGl texture functionality.*/ +class SG_EXPORT Texture : public Object +{ + + public : + + Texture(); + static Texture* instance(); + virtual Object* clone() const { return new Texture(); } + virtual bool isSameKindAs(Object* obj) { return dynamic_cast(obj)!=NULL; } + virtual const char* className() const { return "Texture"; } + + /** Set the texture image. */ + void setImage(Image* image); + /** Get the texture image. */ + Image* getImage() const { return _image.get(); } + + enum WrapParameter { + WRAP_S, + WRAP_T, + WRAP_R + }; + + enum WrapMode { + CLAMP = GL_CLAMP, + REPEAT = GL_REPEAT + }; + + /** Set the texture wrap mode.*/ + void setWrap(WrapParameter which, WrapMode wrap); + /** Get the texture wrap mode.*/ + WrapMode getWrap(WrapParameter which) const; + + + enum FilterParameter { + MIN_FILTER, + MAG_FILTER + }; + + enum FilterMode { + LINEAR = GL_LINEAR, + LINEAR_MIPMAP_LINEAR = GL_LINEAR_MIPMAP_LINEAR, + LINEAR_MIPMAP_NEAREST = GL_LINEAR_MIPMAP_NEAREST, + NEAREST = GL_NEAREST, + NEAREST_MIPMAP_LINEAR = GL_NEAREST_MIPMAP_LINEAR, + NEAREST_MIPMAP_NEAREST = GL_NEAREST_MIPMAP_NEAREST + }; + + /** Set the texture filter mode.*/ + void setFilter(FilterParameter which, FilterMode filter); + /** Get the texture filter mode.*/ + FilterMode getFilter(FilterParameter which) const; + + + /** Enable OpenGL texturing.*/ + static void enable( void ); + /** Disable OpenGL texturing.*/ + static void disable( void ); + + /** On first apply, create the minmapped texture and bind it, + subsequent apply will simple bind to texture.*/ + void apply( void ); + + protected : + + virtual ~Texture(); + + virtual bool readLocalData(Input& fr); + virtual bool writeLocalData(Output& fw); + + uint _handle; + + ref_ptr _image; + + bool matchWrapStr(const char* str,WrapMode& wrap); + const char* getWrapStr(WrapMode wrap); + + bool matchFilterStr(const char* str,FilterMode& filter); + const char* getFilterStr(FilterMode filter); + + WrapMode _wrap_s; + WrapMode _wrap_t; + WrapMode _wrap_r; + FilterMode _min_filter; + FilterMode _mag_filter; +}; + +}; + +#endif Index: /OpenSceneGraph/tags/osg_8_34/include/osg/FileNameUtils =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osg/FileNameUtils (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osg/FileNameUtils (revision 2) @@ -0,0 +1,18 @@ +#ifndef OSG_FILENAMEUTILS +#define OSG_FILENAMEUTILS 1 + +#include + +#include + +namespace osg { + +SG_EXPORT extern std::string getFilePath(const std::string& filename); +SG_EXPORT extern std::string getFileExtension(const std::string& filename); +SG_EXPORT extern std::string getLowerCaseFileExtension(const std::string& filename); +SG_EXPORT extern std::string getSimpleFileName(const std::string& fileName); +SG_EXPORT extern std::string getStrippedName(const std::string& fileName); + +}; + +#endif Index: /OpenSceneGraph/tags/osg_8_34/include/osg/Switch =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osg/Switch (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osg/Switch (revision 2) @@ -0,0 +1,45 @@ +#ifndef OSG_SWITCH +#define OSG_SWITCH 1 + +#include + +namespace osg { + +/** Switch - Group node which allows switching between children. + Typical uses would be for objects which might need to be rendered + differently at different times, for instance a switch could be used + to represent the different states of a traffic light. +*/ +class SG_EXPORT Switch : public Group +{ + public : + + enum SwitchType { + ALL_CHILDREN_ON=-1, + ALL_CHILDREN_OFF=-2 + }; + + Switch(); + + virtual Object* clone() const { return new Switch(); } + virtual bool isSameKindAs(Object* obj) { return dynamic_cast(obj)!=NULL; } + virtual const char* className() const { return "Switch"; } + virtual void accept(NodeVisitor& nv) { nv.apply(*this); } + virtual void traverse(NodeVisitor& nv); + + void setVal(int val) { _value = val; } + int getVal() const { return _value; } + + protected : + + virtual ~Switch() {} + + virtual bool readLocalData(Input& fr); + virtual bool writeLocalData(Output& fw); + + int _value; +}; + +}; + +#endif Index: /OpenSceneGraph/tags/osg_8_34/include/osg/Referenced =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osg/Referenced (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osg/Referenced (revision 2) @@ -0,0 +1,103 @@ +#ifndef OSG_REFERENCED +#define OSG_REFERENCED 1 + +#include + +namespace osg { + +/** Convience functor for unreferencing objects.*/ +template +struct UnrefOp +{ + void operator () (T* node) { node->unref(); } +}; + +/** Smart pointer for handling referenced counted objects.*/ +template +class ref_ptr +{ + + public: + ref_ptr() :_ptr(0L) {} + ref_ptr(T* t):_ptr(t) { if (_ptr) _ptr->ref(); } + ref_ptr(const ref_ptr& rp):_ptr(rp._ptr) { if (_ptr) _ptr->ref(); } + ~ref_ptr() { if (_ptr) _ptr->unref(); } + + ref_ptr& operator = (const ref_ptr& rp) + { + if (_ptr==rp._ptr) return *this; + if (_ptr) _ptr->unref(); + _ptr = rp._ptr; + if (_ptr) _ptr->ref(); + return *this; + } + + ref_ptr& operator = (T* ptr) + { + if (_ptr==ptr) return *this; + if (_ptr) _ptr->unref(); + _ptr = ptr; + if (_ptr) _ptr->ref(); + return *this; + } + + bool operator == (const ref_ptr& rp) const + { + return (_ptr==rp._ptr); + } + + bool operator == (const T* ptr) const + { + return (_ptr==ptr); + } + + bool operator != (const ref_ptr& rp) const + { + return (_ptr!=rp._ptr); + } + + bool operator != (const T* ptr) const + { + return (_ptr!=ptr); + } + + T& operator*() const { return *_ptr; } + T* operator->() const { return _ptr; } + bool operator!() const { return _ptr==0L; } + bool valid() const { return _ptr!=0L; } + + T* get() const { return _ptr; } + + private: + T* _ptr; +}; + +/** Base class from providing referencing counted objects.*/ +class Referenced +{ + + public: + Referenced() { _refCount=0; } + Referenced(Referenced&) { _refCount=0; } + + Referenced& operator = (Referenced&) { return *this; } + + /** increment the reference count by one, indicating that + this object has another pointer which is referencing it.*/ + void ref() { ++_refCount; } + /** decrement the reference count by one, indicating that + a pointer to this object is referencing it. If the + refence count goes to zero, it is assumed that this object + is nolonger referenced and is automatically deleted.*/ + void unref() { --_refCount; if (_refCount<=0) delete this; } + /** return the number pointers currently referencing this object. */ + int referenceCount() { return _refCount; } + + protected: + virtual ~Referenced() {}; + int _refCount; +}; + +}; + +#endif Index: /OpenSceneGraph/tags/osg_8_34/include/osg/Types =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osg/Types (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osg/Types (revision 2) @@ -0,0 +1,32 @@ +#ifndef OSG_TYPES +#define OSG_TYPES 1 + +#include +#include + +namespace osg { + +typedef unsigned int uint; +typedef unsigned short ushort; +typedef unsigned char uchar; +typedef uchar ubyte; + +#ifdef WIN32 +#define M_E 2.7182818284590452354 +#define M_LOG2E 1.4426950408889634074 +#define M_LOG10E 0.43429448190325182765 +#define M_LN2 0.69314718055994530942 +#define M_LN10 2.30258509299404568402 +#define M_PI 3.14159265358979323846 +#define M_PI_2 1.57079632679489661923 +#define M_PI_4 0.78539816339744830962 +#define M_1_PI 0.31830988618379067154 +#define M_2_PI 0.63661977236758134308 +#define M_2_SQRTPI 1.12837916709551257390 +#define M_SQRT2 1.41421356237309504880 +#define M_SQRT1_2 0.70710678118654752440 +#endif + +}; + +#endif Index: /OpenSceneGraph/tags/osg_8_34/include/osg/Lighting =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osg/Lighting (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osg/Lighting (revision 2) @@ -0,0 +1,21 @@ +#ifndef OSG_LIGHTING +#define OSG_LIGHTING 1 + +#include + +namespace osg { + +/** Class to globally control OpenGL's lighting.*/ + +class SG_EXPORT Lighting +{ + public : + /** Enable lighting.*/ + static void enable(); + /** Disable lighting.*/ + static void disable(); +}; + +}; + +#endif Index: /OpenSceneGraph/tags/osg_8_34/include/osg/NodeVisitor =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osg/NodeVisitor (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osg/NodeVisitor (revision 2) @@ -0,0 +1,94 @@ +#ifndef OSG_NODEVISITOR +#define OSG_NODEVISITOR 1 + +#include + +namespace osg { + +class Geode; +class Billboard; +class LightSource; +class Group; +class DCS; +class LOD; +class Sequence; +class Scene; +class Switch; + +/** Visitor for type safe operations on osg::Node's. + Based on GOF's Visitor pattern.*/ +class SG_EXPORT NodeVisitor : public Referenced +{ + public: + + enum TraversalMode { + TRAVERSE_NONE, + TRAVERSE_PARENTS, + TRAVERSE_ALL_CHILDREN, + TRAVERSE_ACTIVE_CHILDREN, + TRAVERSE_VISITOR + }; + + NodeVisitor(TraversalMode tm=TRAVERSE_NONE); + virtual ~NodeVisitor(); + + + /** Set the traversal mode for Node::traverse() to use when + deciding which children of a node to traverse. If a + NodeVisitor has been attached via setTraverseVisitor() + and the new mode is not TRAVERSE_VISITOR then the attached + visitor is detached. Default mode is TRAVERSE_NONE.*/ + void setTraverseMode(TraversalMode mode); + /** Get the traversal mode.*/ + TraversalMode getTraverseMode() { return _traverseMode; } + /** Set a visitor to handle traversal. + Overides the traverse mode setting it to TRAVERSE_VISITOR.*/ + + void setTraverseVisitor(NodeVisitor* nv); + /** Get the traverse visitor, returns NULL if none is attached.*/ + NodeVisitor* getTraverseVisitor() { return _traverseVisitor; } + + /** Inline method for passing handling traversal of a nodes. + If you intend to use the visitor for actively traversing + the scene graph then make sure the accept() methods call + this method unless they handle traversal directly.*/ + void traverse(Node& node) + { + if (_traverseVisitor) node.accept(*_traverseVisitor); + else if (_traverseMode==TRAVERSE_PARENTS) node.ascend(*this); + else if (_traverseMode!=TRAVERSE_NONE) node.traverse(*this); + } + + virtual void apply(Node& node) { traverse(node);} + + virtual void apply(Geode& node) { apply((Node&)node); } + virtual void apply(Billboard& node){ apply((Geode&)node); } + virtual void apply(LightSource& node){ apply((Node&)node); } + + virtual void apply(Group& node) { apply((Node&)node); } + virtual void apply(DCS& node) { apply((Group&)node); } + virtual void apply(Switch& node) { apply((Group&)node); } + virtual void apply(Sequence& node) { apply((Group&)node); } + virtual void apply(LOD& node) { apply((Group&)node); } + virtual void apply(Scene& node) { apply((Group&)node); } + + protected: + + NodeVisitor* _traverseVisitor; + TraversalMode _traverseMode; + +}; + + +/** Convinience functor for assisting visiting of arrays of osg::Node's.*/ +struct NodeAcceptOp +{ + NodeVisitor& _nv; + NodeAcceptOp(NodeVisitor& nv):_nv(nv) {} + void operator () (Node* node) { node->accept(_nv); } + void operator () (ref_ptr node) { node->accept(_nv); } +}; + +}; + +#endif Index: /OpenSceneGraph/tags/osg_8_34/include/osg/Object =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osg/Object (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osg/Object (revision 2) @@ -0,0 +1,76 @@ +#ifndef OSG_OBJECT +#define OSG_OBJECT 1 + +#include + +namespace osg { + +class Input; +class Output; + +/** Base class/standard interface for objects which require IO support, + cloning and reference counting. + Based on GOF Composite, Prototype and Template Method patterns. +*/ +class SG_EXPORT Object : public Referenced +{ + public: + /** Construct an object. Note Object is a pure virtual base class + and therefore cannot be constructed on its own, only derived + classes which overide the clone and className methods are + concrete classes and can be constructed.*/ + Object() {} + + /** return a shallow copy of a node, with Object* return type. + Must be defined by derived classes.*/ + virtual Object* clone() const = 0; + + virtual bool isSameKindAs(Object*) { return true; } + + /** return the name of the object's class type. Must be defined + by derived classes.*/ + virtual const char* className() const = 0; + + /** Template Method/Prototype Pattern : create a clone and read + Object data from Input. Reads Input and if it matches this + objects className() then create a clone and match '{' brackets + and repeating calling Object::readLocalData() until the + matching ']' is read.*/ + virtual Object* readClone(Input& fr); + /** Template Method Pattern : write out Object data to Output. + Sequence of output is className() followed by Open '{' + and then call Object::writeLocalData() and complete with '}'.*/ + virtual bool write(Output& fw); + + protected: + + /** Object destructor. Note, is protected so that Objects cannot + be deleted other than by being derefernced and the reference + count being zero (see osg::Referenced), preventing the deletion + of nodes which are still in use. This also means that + Node's cannot be created on stack i.e Node node will not compile, + forcing all nodes to be created on the heap i.e Node* node + = new Node().*/ + virtual ~Object() {} + + /** Template Method Pattern : read local data from .osg file. + Note should be implemented in derivied classes, which + call their parent class's readLocalData. Returns + true if the input iterator has been advanced, otherwise false.*/ + virtual bool readLocalData(Input&) { return false; } + /** Template Method Pattern : write local data to .osg file. + Note should be implemented in derivied classes, which + call their parent class's writeLocalData. Returns + true if data has been written out, otherwise false.*/ + virtual bool writeLocalData(Output&) { return false; } + + private: + + /** disallow any form of deep copy.*/ + Object(Object&): Referenced() {} + Object& operator = (const Object&) { return *this; } +}; + +}; + +#endif Index: /OpenSceneGraph/tags/osg_8_34/include/osg/FieldReader =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osg/FieldReader (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osg/FieldReader (revision 2) @@ -0,0 +1,62 @@ +#ifndef OSG_FIELDREADER +#define OSG_FIELDREADER 1 + +#include +#include +#include + +#ifdef OSG_USE_IO_DOT_H +#include +#else +#include +using namespace std; +#endif + +namespace osg { + +class Field; + +class SG_EXPORT FieldReader +{ + public: + + FieldReader(); + FieldReader(const FieldReader& ic); + virtual ~FieldReader(); + + virtual FieldReader& operator = (const FieldReader& ic); + + void attach(istream* input); + void detach(); + + virtual bool eof() const; + + bool readField(Field& fieldPtr); + void ignoreField(); + + /** no of unmatched `{' encounterd so far in file*/ + int getNoNestedBrackets() const; + + private: + + bool _readField(Field* fieldPtr); + + void _init(); + void _free(); + void _copy(const FieldReader& ic); + + istream* _fin; + bool _eof; + + bool findStartOfNextField(); + + int _noNestedBrackets; + + bool _delimatorEatLookUp[256]; + bool _delimatorKeepLookUp[256]; + +}; + +}; + +#endif // __SG_FIELD_READER_H Index: /OpenSceneGraph/tags/osg_8_34/include/osg/Light =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osg/Light (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osg/Light (revision 2) @@ -0,0 +1,143 @@ +#ifndef OSG_LIGHT +#define OSG_LIGHT 1 + +#include +#include +#include + +namespace osg { + +/** Light state class which encapsulates OpenGL glLight() functionality.*/ +class SG_EXPORT Light : public Object +{ + public : + + Light(); + + /** return a static instance of an osg::Light, to be used as prototype + for loading lights.*/ + static Light* instance(); + + /** return a shallow copy of a node, with Object* return type.*/ + virtual Object* clone() const { return new Light(); } + + virtual bool isSameKindAs(Object* obj) { return dynamic_cast(obj)!=NULL; } + + /** return the name of the node's class type.*/ + virtual const char* className() const { return "Light"; } + + + + /** + * Turn the light on. + * Calling this method doesn't directly affect OpenGL's lighting mode. + */ + void on( void ) { _on = true; } + + /** + * Turn the light off. + * Calling this method doesn't directly affect OpenGL's lighting mode. + */ + void off( void ) { _on = false; } + + /** Enable OpenGL's Lighting mode. */ + static void enable( void ); + + /** Disable OpenGL's Lighting mode. */ + static void disable( void ); + + /** Apply the light's state to the OpenGL state machine. */ + void apply( void ); + + /** Set the ambient component of the light. */ + void setAmbient( const Vec4& ambient ) { _ambient = ambient; } + + /** Get the ambient component of the light. */ + const Vec4& getAmbient() const { return _ambient; } + + /** Set the diffuse component of the light. */ + void setDiffuse( const Vec4& diffuse ) { _diffuse = diffuse; } + + /** Get the diffuse component of the light. */ + const Vec4& getDiffuse() const { return _diffuse; } + + /** Set the specular component of the light. */ + void setSpecular( const Vec4& specular ) { _specular = specular; } + + /** Get the specular component of the light. */ + const Vec4& getSpecular() const { return _specular; } + + /** Set the position of the light. */ + void setPosition( const Vec4& position ) { _position = position; } + + /** Get the position of the light. */ + const Vec4& getPosition() const { return _position; } + + /** Set the direction of the light. */ + void setDirection( const Vec3& direction ) { _direction = direction; } + + /** Get the direction of the light. */ + const Vec3& getDirection() const { return _direction; } + + /** Set the constant attenuation of the light. */ + void setConstantAttenuation( float constant_attenuation ) { _constant_attenuation = constant_attenuation; } + + /** Get the constant attenuation of the light. */ + float setConstantAttenuation() const { return _constant_attenuation; } + + /** Set the linear attenuation of the light. */ + void setLinearAttenuation ( float linear_attenuation ) { _linear_attenuation = linear_attenuation; } + + /** Get the linear attenuation of the light. */ + float getLinearAttenuation () const { return _linear_attenuation; } + + /** Set the quadratic attenuation of the light. */ + void setQuadraticAttenuation ( float quadratic_attenuation ) { _quadratic_attenuation = quadratic_attenuation; } + + /** Get the quadratic attenuation of the light. */ + float getQuadraticAttenuation() const { return _quadratic_attenuation; } + + /** Set the spot exponent of the light. */ + void setSpotExponent( float spot_exponent ) { _spot_exponent = spot_exponent; } + + /** Get the spot exponent of the light. */ + float getSpotExponent() const { return _spot_exponent; } + + /** Set the spot cutoff of the light. */ + void setSpotCutoff( float spot_cutoff ) { _spot_cutoff = spot_cutoff; } + + /** Get the spot cutoff of the light. */ + float getSpotCutoff() { return _spot_cutoff; } + + /** + * Capture the lighting settings of the current OpenGL state + * and store them in this object. + */ + void captureLightState(); + + protected : + + virtual ~Light( void ); + + /** Initialize the light's settings with some decent defaults. */ + void init( void ); + + int _lightnum; // OpenGL light number + bool _on; // on/off state + Vec4 _ambient; // r, g, b, w + Vec4 _diffuse; // r, g, b, w + Vec4 _specular; // r, g, b, w + Vec4 _position; // x, y, z, w + Vec3 _direction; // x, y, z + float _constant_attenuation; // constant + float _linear_attenuation; // linear + float _quadratic_attenuation; // quadratic + float _spot_exponent; // exponent + float _spot_cutoff; // spread + + static int _currentLightNum; // current max. OpenGL light number +}; + +}; + +#endif Index: /OpenSceneGraph/tags/osg_8_34/include/osg/Registry =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osg/Registry (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osg/Registry (revision 2) @@ -0,0 +1,168 @@ +#ifndef OSG_REGISTRY +#define OSG_REGISTRY 1 + +#include +#include + +#include +#include + +namespace osg { + +// forward declare referenced classes to help avoid mutiple includes +class Object; +class Image; +class Node; +class Input; + +SG_EXPORT extern Object* loadObjectFile(const char *name); +SG_EXPORT extern Image* loadImageFile(const char *name); +SG_EXPORT extern Node* loadNodeFile(const char *name); + +SG_EXPORT extern bool saveObjectFile(Object& object, const char *name); +SG_EXPORT extern bool saveImageFile(Image& image, const char *name); +SG_EXPORT extern bool saveNodeFile(Node& node, const char *name); + +/** pure virtual base class for reading and writing of non native formats. */ +class SG_EXPORT ReaderWriter : public Referenced +{ + public: + virtual ~ReaderWriter() {} + virtual const char* className() = 0; + virtual bool acceptsExtension(const std::string& /*extension*/) { return false; } + + virtual Object* readObject(const std::string& /*fileName*/) { return NULL; } + virtual Image* readImage(const std::string& /*fileName*/) { return NULL; } + virtual Node* readNode(const std::string& /*fileName*/) { return NULL; } + + virtual bool writeObject(Object& /*obj*/,const std::string& /*fileName*/) {return false; } + virtual bool writeImage(Image& /*image*/,const std::string& /*fileName*/) {return false; } + virtual bool writeNode(Node& /*node*/,const std::string& /*fileName*/) { return false; } +}; + +/** + Registry is a singleton factory which stores + the Objects types available at runtime for loading, + and any Object reader or writers which are linked in + at runtime for reading non-native file formats. + + The RegisterObjectProxy defined in Object.h can be + used to automatically register at runtime a Object + with the Registry. + + The RegisterReaderWriterProxy defined in ReaderWriter.h can + be used to automatically register at runtime a reader/writer + with the Registry. +*/ +class SG_EXPORT Registry +{ + public: + + ~Registry(); + + static Registry* instance(); + + void addPrototype(Object* obj); + void removePrototype(Object* obj); + + void addReaderWriter(ReaderWriter* rw); + void removeReaderWriter(ReaderWriter* rw); + + /** create the platform specific library name associated with file.*/ + std::string createLibraryNameForFile(const std::string& fileName); + + /** create the platform specific library name associated with file extension.*/ + std::string createLibraryNameForExt(const std::string& ext); + + /** find the library in the SG_LIBRARY_PATH and load it.*/ + bool loadLibrary(const std::string& fileName); + /** close the attached library with specified name.*/ + bool closeLibrary(const std::string& fileName); + + Object* readObject(Input& fr); + Object* readObject(const std::string& fileName); + bool writeObject(Object& obj, const std::string& fileName); + + Image* readImage(Input& fr); + Image* readImage(const std::string& fileName); + bool writeImage(Image& obj, const std::string& fileName); + + Node* readNode(Input& fr); + Node* readNode(const std::string& fileName); + bool writeNode(Node& node, const std::string& fileName); + + + private: + + typedef std::vector > PrototypeList; + typedef std::vector > ReaderWriterList; + typedef std::vector > DynamicLibraryList; + + /** constructor is private, as its a singleton, preventing + construction other than via the instance() method and + therefore ensuring only one copy is ever constructed*/ + Registry(); + + /** get the attached library with specified name.*/ + DynamicLibraryList::iterator getLibraryItr(const std::string& fileName); + DynamicLibrary* getLibrary(const std::string& fileName); + + PrototypeList _protoList; + ReaderWriterList _rwList; + DynamicLibraryList _dlList; + + std::vector _nodeProtoList; + std::vector _imageProtoList; + + bool _openingLibrary; + +}; + +/** Proxy class for automatic registration of reader/writers with the + Registry.*/ +template +class RegisterObjectProxy +{ + public: + RegisterObjectProxy() + { + _obj = new T; + _obj->ref(); + Registry::instance()->addPrototype(_obj); + } + ~RegisterObjectProxy() + { + Registry::instance()->removePrototype(_obj); + _obj->unref(); + } + + protected: + T* _obj; +}; + +/** Proxy class for automatic registration of reader/writers with the + Registry.*/ +template +class RegisterReaderWriterProxy +{ + public: + RegisterReaderWriterProxy() + { + _rw = new T; + _rw->ref(); + Registry::instance()->addReaderWriter(_rw); + } + + ~RegisterReaderWriterProxy() + { + Registry::instance()->removeReaderWriter(_rw); + _rw->unref(); + } + + protected: + T* _rw; +}; + +}; + +#endif // __SG_OBJECT_FACTORY_H Index: /OpenSceneGraph/tags/osg_8_34/include/osg/Transparency =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osg/Transparency (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osg/Transparency (revision 2) @@ -0,0 +1,50 @@ +#ifndef OSG_TRANSPARENCY +#define OSG_TRANSPARENCY 1 + +#include +#include +#include + +namespace osg { + + +class SG_EXPORT Transparency : public Object +{ + public : + + enum TransparencyMode { + DST_ALPHA = GL_DST_ALPHA, + DST_COLOR = GL_DST_COLOR, + ONE = GL_ONE, + ONE_MINUS_DST_ALPHA = GL_ONE_MINUS_DST_ALPHA, + ONE_MINUS_DST_COLOR = GL_ONE_MINUS_DST_COLOR, + ONE_MINUS_SRC_ALPHA = GL_ONE_MINUS_SRC_ALPHA, + ONE_MINUS_SRC_COLOR = GL_ONE_MINUS_SRC_COLOR, + SRC_ALPHA = GL_SRC_ALPHA, + SRC_ALPHA_SATURATE = GL_SRC_ALPHA_SATURATE, + SRC_COLOR = GL_SRC_COLOR, + ZERO = GL_ZERO + }; + + Transparency(); + static Transparency * instance(); + virtual Object* clone() const { return new Transparency(); } + virtual bool isSameKindAs(Object* obj) { return dynamic_cast(obj)!=NULL; } + virtual const char* className() const { return "Transparency"; } + + void setFunction( int source, int destination ); + static void enable( void ); + static void disable( void ); + void apply( void ); + + protected : + + virtual ~Transparency(); + + int _source_factor; + int _destination_factor; +}; + +}; + +#endif Index: /OpenSceneGraph/tags/osg_8_34/include/osg/TexEnv =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osg/TexEnv (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osg/TexEnv (revision 2) @@ -0,0 +1,45 @@ +#ifndef OSG_TEXENV +#define OSG_TEXENV 1 + +#include +#include +#include + +namespace osg { + + +class SG_EXPORT TexEnv : public Object +{ + public : + + enum TexEnvMode { + DECAL = GL_DECAL, + MODULATE = GL_MODULATE, + BLEND = GL_BLEND + }; + + TexEnv( void ); + static TexEnv* instance(); + virtual Object* clone() const { return new TexEnv(); } + virtual bool isSameKindAs(Object* obj) { return dynamic_cast(obj)!=NULL; } + virtual const char* className() const { return "TexEnv"; } + + + void setMode( TexEnvMode mode ); + void apply( void ); + + protected : + + virtual ~TexEnv( void ); + virtual bool readLocalData(Input& fr); + virtual bool writeLocalData(Output& fw); + + bool matchModeStr(const char* str,TexEnvMode& mode); + const char* getModeStr(TexEnvMode mode); + + TexEnvMode _mode; +}; + +}; + +#endif Index: /OpenSceneGraph/tags/osg_8_34/include/osg/Quat =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osg/Quat (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osg/Quat (revision 2) @@ -0,0 +1,231 @@ +#ifndef OSG_QUAT +#define OSG_QUAT 1 + +#include +#include + +#include +#include +#include + +namespace osg { + +/** A quaternion class. It can be used to represent an orientation in 3D space.*/ +class SG_EXPORT Quat +{ + + public: + + /* ---------------------------------------------------------- + DATA MEMBERS + The only data member is a + Vec4 which holds the elements + + In other words, osg:Quat is composed of an osg::Vec4 + The osg::Quat aggregates an osg::Vec4 + + These seem to be different jargons for the same thing :-) + ---------------------------------------------------------- */ + Vec4 _fv; // a four-vector + + /* ---------------------------------- + CONSTRUCTORS + Default constructor + One to accept four floats + One to accept a Vec4 + These are implemented in Quat.cpp + ---------------------------------- */ + Quat( void ); + Quat( float x, float y, float z, float w ); + Quat( const Vec4& vec ); + + /* ---------------------------------- + Methods to access data members + ---------------------------------- */ + inline Vec4 asVec4( void ) const + { + return _fv; + } + + inline Vec3 asVec3( void ) const + { + return Vec3(_fv[0], _fv[1], _fv[2]); + } + + /* ------------------------------------------------------------- + BASIC ARITHMETIC METHODS + Implemented in terms of Vec4s. Some Vec4 operators, e.g. + operator* are not appropriate for quaternions (as + mathematical objects) so they are implemented differently. + Also define methods for conjugate and the multiplicative inverse. + ------------------------------------------------------------- */ + /// Multiply by scalar + inline Quat operator * (const float& rhs) const + { + return Quat(_fv*rhs); + } + + /// Unary multiply by scalar + inline Quat& operator *= (const float& rhs) + { + _fv*=rhs; + return *this; // enable nesting + } + + /// Binary multiply + inline Quat operator*(const Quat& rhs) const + { + return Quat( _fv[3]*rhs._fv[0] + _fv[0]*rhs._fv[3] + _fv[1]*rhs._fv[2] - _fv[2]*rhs._fv[1], + _fv[3]*rhs._fv[1] - _fv[0]*rhs._fv[2] + _fv[1]*rhs._fv[3] + _fv[2]*rhs._fv[0], + _fv[3]*rhs._fv[2] + _fv[0]*rhs._fv[1] - _fv[1]*rhs._fv[0] + _fv[2]*rhs._fv[3], + _fv[3]*rhs._fv[3] - _fv[0]*rhs._fv[0] - _fv[1]*rhs._fv[1] - _fv[2]*rhs._fv[2] ); + } + + /// Unary multiply + inline Quat& operator*=(const Quat& rhs) + { + float x = _fv[3]*rhs._fv[0] + _fv[0]*rhs._fv[3] + _fv[1]*rhs._fv[2] - _fv[2]*rhs._fv[1]; + float y = _fv[3]*rhs._fv[1] - _fv[0]*rhs._fv[2] + _fv[1]*rhs._fv[3] + _fv[2]*rhs._fv[0]; + float z = _fv[3]*rhs._fv[2] + _fv[0]*rhs._fv[1] - _fv[1]*rhs._fv[0] + _fv[2]*rhs._fv[3]; + _fv[3] = _fv[3]*rhs._fv[3] - _fv[0]*rhs._fv[0] - _fv[1]*rhs._fv[1] - _fv[2]*rhs._fv[2]; + + _fv[2] = z; + _fv[1] = y; + _fv[0] = x; + + return (*this); // enable nesting + } + + /// Divide by scalar + inline Quat operator / (const float& rhs) const + { + return Quat(_fv/rhs); + } + + /// Unary divide by scalar + inline Quat& operator /= (const float& rhs) + { + _fv/=rhs; + return *this; + } + + /// Binary divide + inline Quat operator/(const Quat& denom) const + { + return ( (*this) * denom.inverse() ); + } + + /// Unary divide + inline Quat& operator/=(const Quat& denom) + { + (*this) = (*this) * denom.inverse(); + return (*this); // enable nesting + } + + /// Binary addition + inline Quat operator + (const Quat& rhs) const + { + return Quat( _fv + rhs._fv ); + } + + /// Unary addition + inline Quat& operator += (const Quat& rhs) + { + _fv += rhs._fv; + return *this; // enable nesting + } + + /// Binary subtraction + inline Quat operator - (const Quat& rhs) const + { + return Quat( _fv - rhs._fv ); + } + + /// Unary subtraction + inline Quat& operator -= (const Quat& rhs) + { + _fv-=rhs._fv; + return *this; // enable nesting + } + + /** Negation operator - returns the negative of the quaternion. + Basically just calls operator - () on the Vec4 */ + inline Quat operator - () const + { + return Quat ( -_fv ); + } + + /// Length of the quaternion = sqrt( vec . vec ) + float length( void ) const + { + return _fv.length(); + } + + /// Length of the quaternion = vec . vec + float length2( void ) const + { + return _fv.length2(); + } + + /// Conjugate + inline Quat conj ( void ) const + { + return Quat( -_fv[0], -_fv[1], -_fv[2], _fv[3] ); + } + + /// Multiplicative inverse method: q^(-1) = q^*/(q.q^*) + inline Quat inverse ( void ) const + { + return conj() / length2(); + } + + /* -------------------------------------------------------- + METHODS RELATED TO ROTATIONS + Set a quaternion which will perform a rotation of an + angle around the axis given by the vector (x,y,z). + Should be written to also accept an angle and a Vec3? + + Define Spherical Linear intERPolation method also + + Not inlined - see the Quat.cpp file for implementation + -------------------------------------------------------- */ + void makeRot ( const float angle, + const float x, const float y, const float z ); + void makeRot ( const float angle, const Vec3& vec ); + + /** Make a rotation Quat which will rotate vec1 to vec2. + Generally take adot product to get the angle between these + and then use a cross product to get the rotation axis + Watch out for the two special cases of when the vectors + are co-incident or opposite in direction.*/ + void makeRot( const Vec3& vec1, const Vec3& vec2 ); + + /** Return the angle and vector components represented by the quaternion.*/ + void getRot ( float& angle, float& x, float& y, float& z ) const; + /** Return the angle and vector represented by the quaternion.*/ + void getRot ( float& angle, Vec3& vec ) const; + + /** Spherical Linear Interpolation. + As t goes from 0 to 1, the Quat object goes from "from" to "to". */ + void slerp ( const float t, const Quat& from, const Quat& to); + + /** Set quaternion to be equivalent to specified matrix.*/ + void set( const osg::Matrix& m ); + + /** Get the equivalent matrix for this quaternion.*/ + void get( osg::Matrix& m ) const; + + friend inline ostream& operator << (ostream& output, const Quat& vec) + { + output << vec._fv[0] << " " + << vec._fv[1] << " " + << vec._fv[2] << " " + << vec._fv[3]; + return output; // to enable cascading + } + + +}; // end of class prototype + +}; // end of namespace +#endif Index: /OpenSceneGraph/tags/osg_8_34/include/osg/GeoState =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osg/GeoState (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osg/GeoState (revision 2) @@ -0,0 +1,150 @@ +#ifndef OSG_GEOSTATE +#define OSG_GEOSTATE 1 + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace osg { + +class Input; +class Output; + +/** +Encapsulates OpenGL state modes and attributes. +Used to specificy textures etc of osg::GeoSet's which hold references +to a single osg::GeoState. GeoState can be shared between GeoSet's +and is recommend if possible as it minimize expensive state changes +in the graphics pipeline. +*/ +class SG_EXPORT GeoState : public Object +{ + public : + + enum AttributeType + { + ANTIALIAS, + FACE_CULL, + FOG, + LIGHTING, + MATERIAL, + POINT, + POLYGON_OFFSET, + TEXENV, + TEXGEN, + TEXMAT, + TEXTURE, + TRANSPARENCY, + WIREFRAME, + ALPHAFUNC + }; + + enum AttributeMode + { + INHERIT, + OFF, + ON, + OVERRIDE_OFF, + OVERRIDE_ON, + }; + + GeoState(); + static GeoState* instance(); + virtual Object* clone() const { return new GeoState(); } + virtual bool isSameKindAs(Object* obj) { return dynamic_cast(obj)!=NULL; } + const char* className() const { return "GeoState"; } + + /** set all the modes to on or off so that it defines a + complete state, typically used for a default global state.*/ + void setGlobalDefaults(); + + /** set all the modes to inherit, typically used to signifiy + nodes which inherit all of their modes for the global state.*/ + void setAllToInherit(); + + void setMode(AttributeType type, AttributeMode mode); + AttributeMode getMode(AttributeType type) const; + + void setAttribute(AttributeType type, Object *attribute); + Object* getAttribute(AttributeType type) const; + + bool isTransparent() { return _transparencing==ON; } + + void apply(); + void apply(GeoState* global,GeoState* prev); + + bool check(); + + static AttributeMode combineMode(const AttributeMode g,const AttributeMode p,const AttributeMode c) + { + AttributeMode gp = mergeMode(g,p); + AttributeMode gc = mergeMode(g,c); + if (gc==gp) return INHERIT; + else return gc; + } + + static AttributeMode mergeMode(const AttributeMode lhs,const AttributeMode rhs) + { + AttributeMode mode; + if (rhs==INHERIT || lhs==OVERRIDE_OFF || lhs==OVERRIDE_ON) mode = lhs; + else mode = rhs; + if (mode==OVERRIDE_OFF) return OFF; + else if (mode==OVERRIDE_OFF) return ON; + return mode; + } + + protected : + + + virtual ~GeoState(); + + GeoState(const GeoState&):Object() {} + GeoState& operator = (const GeoState&) { return *this; } + + virtual bool readLocalData(Input& fr); + virtual bool writeLocalData(Output& fw); + + bool matchModeStr(const char* str, AttributeMode& mode); + const char* getModeStr(AttributeMode flag); + + // Modes + AttributeMode _transparencing; + AttributeMode _face_culling; + AttributeMode _lighting; + AttributeMode _texturing; + AttributeMode _fogging; + AttributeMode _texgening; + AttributeMode _antialiasing; + AttributeMode _colortable; + AttributeMode _pointSmoothing; + AttributeMode _polygonOffsetting; + AttributeMode _alphaTesting; + + // Attributes + ref_ptr _texture; + ref_ptr _texgen; + ref_ptr _material; + ref_ptr _texenv; + ref_ptr _transparency; + ref_ptr _texmat; + ref_ptr _fog; + ref_ptr _point; + ref_ptr _polygonOffset; + ref_ptr _cullFace; + ref_ptr _alphaFunc; +}; + +}; + +#endif Index: /OpenSceneGraph/tags/osg_8_34/include/osg/BoundingSphere =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osg/BoundingSphere (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osg/BoundingSphere (revision 2) @@ -0,0 +1,85 @@ +#ifndef OSG_BOUNDINGSPHERE +#define OSG_BOUNDINGSPHERE 1 + +#include +#include + +namespace osg { + +/** General purpose bounding sphere class for enclosing nodes/objects/vertices. + Used to bound internal osg::Node's in the scene, + to assist in view frustrum culling etc. Similar in function to BoundingBox + but is quicker for evaluating culling, but generally encloses a greater volume + than a BoundingBox so will not cull so aggressively. +*/ +class SG_EXPORT BoundingSphere +{ + public: + + Vec3 _center; + float _radius; + + /** construct to invalid values to represent an unset bounding sphere.*/ + BoundingSphere() : _center(0.0f,0.0f,0.0f),_radius(-1.0f) {} + + /** initialize to invalid values to represent an unset bounding sphere.*/ + void init() + { + _center.set(0.0f,0.0f,0.0f); + _radius = -1.0f; + } + + /** return true if the bounding sphere contains valid values, + false if the bounding sphere is effectively unset.*/ + bool isValid() const { return _radius>=0.0f; } + + + /** return the const center of the bounding sphere.*/ + const Vec3& center() const { return _center; } + /** return the center of the bounding sphere.*/ + Vec3& center() { return _center; } + + /** return the const radius of the bounding sphere.*/ + float radius() const { return _radius; } + /** return the radius of the bounding sphere.*/ + float& radius() { return _radius; } + + /** return the radius squared. + Note, for performance reasons, assumes the calling method has ensured + that the sphere is valid before calling radius2(), i.e. has _radius>=0.0, + as it does not check th validity of sphere and will eroneously return a positive value.*/ + float radius2() const { return _radius*_radius; } + + /** If the vertex is outwith the sphere expand to ecompass vertex. + Calculates the combination of movement of center and radius which + minimizes the radius increase. If this sphere is empty then + move the centrer to v and set radius to 0.*/ + void expandBy(const Vec3& v); + + /** If the vertex is outwith the sphere expand radius to ecompass vertex. + Unlike update, does not move the center, just increasing the radius. + If this sphere is empty then move the centrer to v and set radius to 0 */ + void expandRadiusBy(const Vec3& v); + + /** If incomming sphere is outwith the sphere expand to ecompass incomming sphere. + calculates the combination of movement of center and radius which + minimizes the radius increase. If this sphere is empty then + move the centrer to v and set radius to 0.*/ + void expandBy(const BoundingSphere& sh); + + /** If incomming sphere is outwith the sphere expand radius to ecompass incomming sphere. + Unlike update, does not move the center, just increasing the radius. + If this sphere is empty then move the centrer to v and set radius to 0. */ + void expandRadiusBy(const BoundingSphere& sh); + + /** return true is vertex v is within the sphere.*/ + bool contains(const Vec3& v) + { + return isValid() && ((v-_center).length2()<=radius2()); + } + +}; + +}; + +#endif Index: /OpenSceneGraph/tags/osg_8_34/include/osg/BoundingBox =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osg/BoundingBox (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osg/BoundingBox (revision 2) @@ -0,0 +1,116 @@ +#ifndef OSG_BOUNDINGBOX +#define OSG_BOUNDINGBOX 1 + +#include +#include +#include + +namespace osg { + +class BoundingSphere; + +/** General purpose axis-aligned bounding box class for enclosing objects/vertices. + Used to bounding the leaf objects in the scene, + i.e. osg::GeoSet's to assist in view frustum culling etc. +*/ +class SG_EXPORT BoundingBox +{ + public: + + /** The corner with the smallest values for each coordinate of the + bounding box.*/ + Vec3 _min; + /** The corner with the largest values for each coordinate of the + bounding box.*/ + Vec3 _max; + + /** construct to invalid values to represent an unset bounding box.*/ + BoundingBox() : _min(FLT_MAX,FLT_MAX,FLT_MAX), + _max(-FLT_MAX,-FLT_MAX,-FLT_MAX) {} + + /** initialize to invalid values to represent an unset bounding box.*/ + void init() + { + _min.set(FLT_MAX,FLT_MAX,FLT_MAX); + _max.set(-FLT_MAX,-FLT_MAX,-FLT_MAX); + } + + /** return true if the bounding box contains valid values, + false if the bounding box is effectively unset/empty.*/ + bool isValid() const + { + return _max.x()>=_min.x(); + } + + float& xMin() { return _min.x(); } + float xMin() const { return _min.x(); } + + float& yMin() { return _min.y(); } + float yMin() const { return _min.y(); } + + float& zMin() { return _min.z(); } + float zMin() const { return _min.z(); } + + float& xMax() { return _max.x(); } + float xMax() const { return _max.x(); } + + float& yMax() { return _max.y(); } + float yMax() const { return _max.y(); } + + float& zMax() { return _max.z(); } + float zMax() const { return _max.z(); } + + /** Calculate and return the center of the bounding box.*/ + Vec3 center() const + { + return (_min+_max)*0.5f; + } + + /** Calculate and return the radius of the bounding box.*/ + float radius() const + { + return sqrtf(radius2()); + } + + /** Calculate and return the radius squared of the bounding box. + Note, radius2() is faster to calculate than radius().*/ + float radius2() const + { + return 0.25f*((_max-_min).length2()); + } + + /** return the corner of the bounding box. + Position (pos) is specfied by a number between 0 and 7, + the first bit toggles between x min and x max, second + bit toggles between y min and y max, third bit toggles + between z min and z max.*/ + Vec3 corner(unsigned int pos) const + { + return Vec3(pos&1?_max.x():_min.x(),pos&2?_max.y():_min.y(),pos&4?_max.z():_min.z()); + } + + /** If the vertex is outwith the box expand to ecompass vertex. + If this box is empty then move set this box's min max to vertex. */ + void expandBy(const Vec3& v); + + /** If incomming box is outwith the box expand to ecompass incomming box. + If this box is empty then move set this box to incomming box. */ + void expandBy(const BoundingBox& bb); + + /** If incomming sphere is outwith the box expand to ecompass incomming sphere. + If this box is empty then move set this box to encompass the sphere. */ + void expandBy(const BoundingSphere& sh); + + /** return true is vertex v is within the box.*/ + bool contains(const Vec3& v) + { + return isValid() && + (v.x()>=_min.x() && v.x()<=_max.x()) && + (v.y()>=_min.y() && v.y()<=_max.y()) && + (v.z()>=_min.z() && v.z()<=_max.z()); + } +}; + +}; + +#endif Index: /OpenSceneGraph/tags/osg_8_34/include/osg/FieldReaderIterator =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osg/FieldReaderIterator (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osg/FieldReaderIterator (revision 2) @@ -0,0 +1,68 @@ +#ifndef OSG_FIELDREADERITERATOR +#define OSG_FIELDREADERITERATOR 1 + +#include +#include + +namespace osg { + + +class SG_EXPORT FieldReaderIterator +{ + public: + + enum { + MINIMUM_FIELD_READER_QUEUE_SIZE = 10 + }; + + FieldReaderIterator(); + FieldReaderIterator(const FieldReaderIterator& ic); + virtual ~FieldReaderIterator(); + + virtual FieldReaderIterator& operator = (const FieldReaderIterator& ic); + + void attach(istream* input); + void detach(); + + virtual bool eof() const; + + FieldReader& getFieldReader() { return _reader; } + + void insert(int pos,Field* field); + void insert(int pos,const char* str); + + Field& operator [] (int pos); + Field& field (int pos); + + FieldReaderIterator& operator ++ (); + FieldReaderIterator& operator += (int no); + +/** increments the itetor of the next simple field or + whole block if the current field[0] is an open bracket */ + void advanceOverCurrentFieldOrBlock(); + void advanceToEndOfCurrentBlock(); + void advanceToEndOfBlock(int noNestBrackets); + + bool matchSequence(const char* str); + + private: + + void _init(); + void _free(); + void _copy(const FieldReaderIterator& ic); + + FieldReader _reader; + + Field _blank; + + Field* _previousField; + + Field** _fieldQueue; + int _fieldQueueSize; + int _fieldQueueCapacity; + +}; + +}; + +#endif // __OSG_FIELD_READER_QUEUE_H Index: /OpenSceneGraph/tags/osg_8_34/include/osg/Export =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osg/Export (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osg/Export (revision 2) @@ -0,0 +1,32 @@ +#ifndef OSG_EXPORT +#define OSG_EXPORT 1 + +#ifdef WIN32 + #pragma warning( disable : 4251 ) + #pragma warning( disable : 4275 ) + #pragma warning( disable : 4786 ) + +/* Define NULL pointer value */ + +#ifndef NULL +#ifdef __cplusplus +#define NULL 0 +#else +#define NULL ((void *)0) +#endif +#endif + + +#endif + +#if defined(_MSC_VER) + # ifdef SG_LIBRARY + # define SG_EXPORT __declspec(dllexport) + # else + # define SG_EXPORT __declspec(dllimport) + # endif /* SG_LIBRARY */ +#else + # define SG_EXPORT +#endif + +#endif Index: /OpenSceneGraph/tags/osg_8_34/include/osg/Image =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osg/Image (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osg/Image (revision 2) @@ -0,0 +1,98 @@ +#ifndef OSG_IMAGE +#define OSG_IMAGE 1 + +#include +#include + +namespace osg { + +class Output; +class Input; + +/** Image class for encapsulating the storage texture image data.*/ +class SG_EXPORT Image : public Object +{ + + public : + + Image(); + + virtual Object* clone() const { return new Image(); } + virtual bool isSameKindAs(Object* obj) { return dynamic_cast(obj)!=NULL; } + virtual const char* className() const { return "Image"; } + + + const char* getFileName() { return _fileName; } + void setFileName(const char* fileName); + + /** set the image data and format. + * note, when no packing value is negative (the default is -1) this method assumes + * a _packing width of 1 if the width is not a multiple of 4, + * otherwise automatically sets to _packing to 4. If a postive + * value of packing is supplied than _packing is simply set to that value. + */ + void setImage(int s,int t,int r, + int internalFormat, + unsigned int pixelFormat, + unsigned int dataType, + unsigned char *data, + int packing=-1); + + /** Width of image.*/ + int s() { return _s; } + /** Height of image.*/ + int t() { return _t; } + /** Depth of image.*/ + int r() { return _r; } + + int internalFormat() { return _internalFormat; } + unsigned int pixelFormat() { return _pixelFormat; } + unsigned int dataType() { return _dataType; } + unsigned int packing() { return _packing; } + + /** raw image data.*/ + unsigned char *data() { return _data; } + + /** Scale image to specified size. */ + void scaleImage(int s,int t,int r); + + /** Ensure image dimensions are a power of two. + * Mip Mapped texture require the image dimensions to be + * power of two. + */ + void ensureDimensionsArePowerOfTwo(); + + protected : + + virtual ~Image(); + +// Image(const Image&) {} +// Image& operator = (const Image& image) {} + + virtual bool readLocalData(Input& fr); + virtual bool writeLocalData(Output& fw); + + char* _fileName; + int _s, _t, _r; + int _internalFormat; + unsigned int _pixelFormat; + unsigned int _dataType; + unsigned int _packing; + unsigned char *_data; + +}; + +class Geode; + +/** Convinience function to be used by images loaders to generate a valid geode to return for readNode(). + * Use the images s and t values scale the dimensions of the image. + */ +SG_EXPORT extern Geode* createGeodeForImage(Image* image); +/** Convinience function to be used by images loaders to generate a valid geode to return for readNode(). + * Use the specified s and t values scale the dimensions of the image. + */ +SG_EXPORT extern Geode* createGeodeForImage(Image* image,float s,float t); + +}; + +#endif // __SG_IMAGE_H Index: /OpenSceneGraph/tags/osg_8_34/include/osg/GeoSet =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osg/GeoSet (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osg/GeoSet (revision 2) @@ -0,0 +1,468 @@ +#ifndef OSG_GEOSET +#define OSG_GEOSET 1 + +#include +#include +#include +#include +#include + +namespace osg { + + +class Input; +class Output; + +/** Encapsulates OpenGL drawing primitives, geometry and + optional binding of normal, color and texture coordinates. Used + for representing the visible objects in the scene. State attributes + for a GeoSet are maintained in GeoState which the GeoSet maintains + a referenced counted pointer to. Both GeoSet's and GeoState's can + be shared for optimal memory usage and graphics performance. +*/ +class SG_EXPORT GeoSet : public Object +{ + public: + + enum PrimitiveType { + NO_TYPE, + POINTS, + LINES, + LINE_STRIP, + FLAT_LINE_STRIP, + LINE_LOOP, + TRIANGLES, + TRIANGLE_STRIP, + FLAT_TRIANGLE_STRIP, + TRIANGLE_FAN, + FLAT_TRIANGLE_FAN, + QUADS, + QUAD_STRIP, + POLYGON + }; + + enum BindingType { + BIND_OFF, + BIND_OVERALL, + BIND_PERPRIM, + BIND_PERVERTEX, + BIND_DEFAULT + }; + + enum InterleaveArrayType { + IA_OFF, + IA_V2F, + IA_V3F, + IA_C4UB_V2F, + IA_C4UB_V3F, + IA_C3F_V3F, + IA_N3F_V3F, + IA_C4F_N3F_V3F, + IA_T2F_V3F, + IA_T4F_V4F, + IA_T2F_C4UB_V3F, + IA_T2F_C3F_V3F, + IA_T2F_N3F_V3F, + IA_T2F_C4F_N3F_V3F, + IA_T4F_C4F_N3F_V4F + }; + + GeoSet(); + static GeoSet* instance(); + virtual Object* clone() const { return new GeoSet(); } + virtual bool isSameKindAs(Object* obj) { return dynamic_cast(obj)!=NULL; } + virtual const char* className() const { return "Geoset"; } + + + // data access methods. + void setNumPrims( int n ) { _numprims = n; } + int getNumPrims( void ) { return _numprims; } + + void setPrimType( PrimitiveType type ); + PrimitiveType getPrimType( void ) { return _primtype; } + + void setPrimLengths( int *lens ) { _primLengths = lens; } + int *getPrimLengths( void ) { return _primLengths; } + + void computeNumVerts(); + + /** get the number of coords required by the defined primitives. */ + int getNumCoords() { return _numcoords; } + /** get a pointer to Vec3 coord array. */ + Vec3* getCoords() { return _coords; } + /** get the number of indices required by the defined primitives. */ + int getNumIndices() { return _numindices; } + /** get the coord index array. */ + ushort* getCIndex() { return _cindex; } + /** set the coords (i.e the geometry) of the geoset.*/ + void setCoords( Vec3 *cp ); + /** set the coords (i.e the geometry) and indices of the geoset.*/ + void setCoords( Vec3 *cp, ushort *ci ); + + /** get the number of normals required by the defined primitives and normals binding.*/ + int getNumNormals() { return _numnormals; } + /** get a pointer to Vec3 normal array. */ + Vec3* getNormals() { return _normals; } + /** get the number of normal indices required by the defined primitives and normals binding.*/ + int getNumNIndices() { return _numnindices; } + /** get the normal index array. */ + ushort* getNIndex() { return _nindex; } + /** set the normals of the geoset.*/ + void setNormals( Vec3 *np ); + /** set the normals and normal indices of the geoset.*/ + void setNormals( Vec3 *np, ushort *ni ); + /** set the normals binding to the vertices/primitives/overall.*/ + void setNormalBinding( BindingType binding ); + BindingType getNormalBinding() { return _normal_binding; } + + /** get the number of colors required by the defined primitives and color binding.*/ + int getNumColors() { return _numcolors; } + /** get a pointer to Vec4 color array. */ + Vec4* getColors() { return _colors; } + /** get the number of colors indices required by the defined primitives and color binding.*/ + int getNumCIndices() { return _numcindices; } + /** get the color index array. */ + ushort* getColIndex() { return _colindex; } + /** set the colors of the geoset.*/ + void setColors( Vec4 *lp ); + /** set the colors and color indices of the geoset.*/ + void setColors( Vec4 *lp, ushort *li ); + /** set the color binding to the vertices/primitives/overall.*/ + void setColorBinding( BindingType binding ); + BindingType getColorBinding() { return _color_binding; } + + /** get the number of texture coords required by the defined primitives and textures binding.*/ + int getNumTCoords() { return _numtcoords; } + /** get a pointer to Vec4 color array. */ + Vec2* getTCoords() { return _tcoords; } + /** get the number of texture coord indices required by the defined primitives and texture binding.*/ + int getNumTIndices() { return _numtindices; } + /** get the texture index array. */ + ushort* getTIndex() { return _tindex; } + /** set the texture coords of the geoset.*/ + void setTextureCoords( Vec2 *tc ); + /** set the texture coords and texture coord indices of the geoset.*/ + void setTextureCoords( Vec2 *tc, ushort *ti ); + /** set the texture coord binding to the vertices/primitives/overall.*/ + void setTextureBinding( BindingType binding ); + BindingType getTextureBinding() { return _texture_binding; } + + void setInterleavedArray( InterleaveArrayType format, float *ia ); + void setInterleavedArray( InterleaveArrayType format, float *ia, ushort *iai ); + + void setGeoState(GeoState *state) { _state = state; } + GeoState* getGeoState() const { return _state.get();} + + + /** When set to true, force the draw method to use OpenGL Display List for rendering. + If false rendering directly. If the display list has not been already + compile the next call to draw will automatically create the display list.*/ + void setUseDisplayList(bool flag); + + /** Return whether OpenGL display lists are being used for rendering.*/ + bool getUseDisplayList() { return _useDisplayList; } + + /** Force a recompile on next draw() of any OpenGL display list associated with this geoset.*/ + void dirtyDisplayList(); + + /** get bounding box of geoset. + * Note, now made virtual to make it possible to implement user-drawn + * objects albiet so what crudely, to be improved later. + */ + virtual const BoundingBox& getBound() ; + + /** draw geoset. + * If the geoset has _useDisplayList set to true then use an OpenGL display + * list, automatically compiling one if required. + * Otherwise call drawImmediateMode(). + * Note, draw method should not be overiden in subclasses as it + * manages the optional display list. + */ + void draw( void ); + + + /** draw geoset directly ignoring an OpenGL display list which could be attached. + * This is the internal draw method which does the drawing itself, + * and is the method to override when deriving from GeoSet for user-drawn objects. + */ + virtual void drawImmediateMode(); + + /** Immediately compile this geoset into an OpenGL Display List, set _useDisplayList to true.*/ + void compile( void ); + + bool check(); + + protected: + + GeoSet(const GeoSet&):Object() {} + GeoSet& operator = (const GeoSet&) { return *this;} + + virtual ~GeoSet(); + + bool matchBindingTypeStr(const char* str,BindingType& mode); + const char* getBindingTypeStr(BindingType mode); + + virtual bool readLocalData(Input& fr); + virtual bool writeLocalData(Output& fw); + + private : + + int _numprims; + PrimitiveType _primtype; + int _needprimlen; + unsigned int _oglprimtype; + int *_primLengths; + int _numverts; + unsigned char _primlength; + unsigned char _flat_shaded_skip; + + int _numcoords; + int _numindices; + Vec3 *_coords; + ushort *_cindex; + + int _numnormals; + int _numnindices; + Vec3 *_normals; + ushort *_nindex; + BindingType _normal_binding; + + int _numcolors; + int _numcindices; + Vec4 *_colors; + ushort *_colindex; + BindingType _color_binding; + + int _numtcoords; + int _numtindices; + Vec2 *_tcoords; + ushort *_tindex; + BindingType _texture_binding; + + void *_iarray; + ushort *_iaindex; + InterleaveArrayType _iaformat; + unsigned int _ogliaformat; + + + /** return the bbbbffff composition required for an interleaved array row.*/ + const char* getInterleavedRowComposition(InterleaveArrayType at) const; + /** return the number of bytes required for an interleaved array row.*/ + int getInterleavedRowLength(InterleaveArrayType at) const; + + + int _fast_path; + + ref_ptr _state; + + bool _useDisplayList; + uint _globj; + + BoundingBox _bbox; + int _bbox_computed; + + void computeBound( void ); + void set_fast_path( void ); + void draw_fast_path( void ); + void draw_alternate_path( void ); + +}; + +/** Template function for iterating through a GeoSet operating on triangles + with templated functor. Function automatically decomposes quads and polygons + into sub triangles which are passed onto functor.*/ +template +void for_each_triangle(GeoSet& gset,T& op) +{ + switch(gset.getPrimType()) + { + case(GeoSet::TRIANGLE_STRIP): + case(GeoSet::FLAT_TRIANGLE_STRIP): + { + if (gset.getCIndex()) + { + ushort* iptr = gset.getCIndex(); + Vec3* vptr = gset.getCoords(); + const int numPrim = gset.getNumPrims(); + for(int i=0; i0) + { + const Vec3& start = vptr[*(iptr)]; + ushort* iend = iptr+primLength; + ++iptr; + for(int j = 2; j < primLength; ++j ) + { + op(start,vptr[*(iptr)],vptr[*(iptr+1)]); + ++iptr; + } + iptr=iend; + } + } + } + else + { + Vec3* vptr = gset.getCoords(); + const int numPrim = gset.getNumPrims(); + for(int i=0; i0) + { + const Vec3& start = *vptr; + Vec3* vend = vptr+primLength; + ++vptr; + for(int j = 2; j < primLength; ++j) + { + op(start,*(vptr),*(vptr+1)); + ++vptr; + } + vptr = vend; + } + } + } + } + break; + default: + break; + } + +}; + + +}; + +#endif Index: /OpenSceneGraph/tags/osg_8_34/include/osg/LightSource =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osg/LightSource (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osg/LightSource (revision 2) @@ -0,0 +1,42 @@ +#ifndef OSG_LIGHTSOURCE +#define OSG_LIGHTSOURCE 1 + +#include +#include +#include + +namespace osg { + +/** Leaf Node for defining a light in the scene.*/ +class SG_EXPORT LightSource : public Node +{ + public: + + LightSource(); + + virtual Object* clone() const { return new LightSource(); } + virtual bool isSameKindAs(Object* obj) { return dynamic_cast(obj)!=NULL; } + virtual const char* className() const { return "LightSource"; } + virtual void accept(NodeVisitor& nv) { nv.apply(*this); } + + /** Set the attached light.*/ + void setLight(Light* light) { _light = light; } + + /** Get the attached light.*/ + Light* getLight() { return _light.get(); } + + protected: + + virtual ~LightSource(); + + virtual bool readLocalData(Input& fr); + virtual bool writeLocalData(Output& fw); + + virtual bool computeBound( void ); + + ref_ptr _light; +}; + +}; + +#endif Index: /OpenSceneGraph/tags/osg_8_34/include/osg/Point =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osg/Point (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osg/Point (revision 2) @@ -0,0 +1,49 @@ +#ifndef OSG_POINT +#define OSG_POINT 1 + +#include +#include +#include + +namespace osg { + +class Input; +class Output; + +class SG_EXPORT Point : public Object +{ + public : + + Point(); + static Point* instance(); + virtual Object* clone() const { return new Point(); } + virtual bool isSameKindAs(Object* obj) { return dynamic_cast(obj)!=NULL; } + virtual const char* className() const { return "Point"; } + + void setSize(float size); + void setFadeThresholdSize(float fadeThresholdSize); + void setDistanceAttenuation(const Vec3& distanceAttenuation); + + static void enableSmooth( void ); + static void disableSmooth( void ); + + void apply( void ); + + static void init_GL_EXT(); + + protected : + + virtual ~Point(); + + virtual bool readLocalData(Input& fr); + virtual bool writeLocalData(Output& fw); + + float _size; + float _fadeThresholdSize; + Vec3 _distanceAttenuation; + +}; + +}; + +#endif Index: /OpenSceneGraph/tags/osg_8_34/include/osg/TexGen =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osg/TexGen (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osg/TexGen (revision 2) @@ -0,0 +1,54 @@ +#ifndef OSG_TEXGEN +#define OSG_TEXGEN 1 + +#include +#include +#include +#include + +namespace osg { + + +class Input; +class Output; + +class SG_EXPORT TexGen : public Object +{ + public : + + enum TexGenMode { + OBJECT_LINEAR = GL_OBJECT_LINEAR, + EYE_LINEAR = GL_EYE_LINEAR, + SPHERE_MAP = GL_SPHERE_MAP + }; + + TexGen( void ); + static TexGen* instance(); + virtual Object* clone() const { return new TexGen(); } + virtual bool isSameKindAs(Object* obj) { return dynamic_cast(obj)!=NULL; } + virtual const char* className() const { return "TexGen"; } + + static void enable( void ); + static void disable( void ); + + void apply( void ); + + void setMode( TexGenMode mode ) { _mode = mode; } + + protected : + + virtual ~TexGen( void ); + + virtual bool readLocalData(Input& fr); + virtual bool writeLocalData(Output& fw); + + bool matchModeStr(const char* str,TexGenMode& mode); + const char* getModeStr(TexGenMode mode); + + TexGenMode _mode; + +}; + +}; + +#endif Index: /OpenSceneGraph/tags/osg_8_34/include/osg/Group =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osg/Group (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osg/Group (revision 2) @@ -0,0 +1,106 @@ +#ifndef OSG_GROUP +#define OSG_GROUP 1 + +#include +#include + +#include + +namespace osg { + +/** General group node which maintains a list of children. + Children are reference counted to allow children to be shared + with memory management handled automatically via osg::Referenced. +*/ +class SG_EXPORT Group : public Node +{ + public : + + typedef std::vector > ChildList; + + Group(); + + virtual Object* clone() const { return new Group(); } + virtual bool isSameKindAs(Object* obj) { return dynamic_cast(obj)!=NULL; } + virtual const char* className() const { return "Group"; } + virtual void accept(NodeVisitor& nv) { nv.apply(*this); } + + virtual void traverse(NodeVisitor& nv); + + /** Add Node to Group. + * If node is not NULL and is not contained in Group then increment its + * reference count, add it to the child list and dirty the bounding + * sphere to force it to recompute on next getBound() and return true for success. + * Otherwise return false. + */ + virtual bool addChild( Node *child ); + + /** Remove Node from Group. + * If Node is contained in Group then remove it from the child + * list, decrement its reference count, and dirty the + * bounding sphere to force it to recompute on next getBound() and + * return true for success. If Node is not found then return false + * and do not change the reference count of the Node. + */ + virtual bool removeChild( Node *child ); + + /** Replace specified Node with another Node. + * Decrement the reference count origNode and increments the + * reference count of newNode, and dirty the bounding sphere + * to force it to recompute on next getBound() and returns true. + * If origNode is not found then return false and do not + * add newNode. If newNode is NULL then return false and do + * not remove origNode. + */ + virtual bool replaceChild( Node *origChild, Node* newChild ); + + /** return the number of chilren nodes.*/ + int getNumChildren( void ) { return _children.size(); } + + /** return child node at position i.*/ + Node *getChild( int i ) { return _children[i].get(); } + + /** return true is node is contained within Group.*/ + bool containsNode( Node* node ) + { + + for (ChildList::iterator itr=_children.begin(); + itr!=_children.end(); + ++itr) + { + if (itr->get()==node) return true; + } + return false; + } + + /** return the iterator postion for specified Node. + * return _chilren.end() if node is not contained in Group. + */ + ChildList::iterator findNode( Node* node ) + { + + for (ChildList::iterator itr=_children.begin(); + itr!=_children.end(); + ++itr) + { + if (itr->get()==node) return itr; + } + return _children.end(); + } + + protected: + + virtual ~Group(); + + virtual bool readLocalData(Input& fr); + virtual bool writeLocalData(Output& fw); + + ChildList _children; + + bool computeBound( void ); + +}; + +}; + +#endif Index: /OpenSceneGraph/tags/osg_8_34/include/osg/Material =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osg/Material (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osg/Material (revision 2) @@ -0,0 +1,100 @@ +#ifndef OSG_MATERIAL +#define OSG_MATERIAL 1 + +#include +#include +#include +#include + +namespace osg { + + +class Input; +class Output; + +class SG_EXPORT Material : public Object +{ + + public : + + enum MaterialFace { + FACE_FRONT = GL_FRONT, + FACE_BACK = GL_BACK, + FACE_FRONT_AND_BACK = GL_FRONT_AND_BACK + }; + + enum ColorMode { + AMBIENT = GL_AMBIENT, + DIFFUSE = GL_DIFFUSE, + SPECULAR = GL_SPECULAR, + EMISSION = GL_EMISSION, + AMBIENT_AND_DIFFUSE = GL_AMBIENT_AND_DIFFUSE, + OFF + }; + + Material( void ); + static Material* instance(); + virtual Object* clone() const { return new Material(); } + virtual bool isSameKindAs(Object* obj) { return dynamic_cast(obj)!=NULL; } + const char* className() const { return "Material"; } + + void apply( void ); + + void setColorMode(ColorMode mode) { _colorMode = mode; } + + void setAmbient( MaterialFace face, const Vec4& ambient ); + const Vec4& getAmbient(MaterialFace face) const; + bool getAmbientFrontAndBack() { return _ambientFrontAndBack; } + + void setDiffuse( MaterialFace face, const Vec4& diffuse ); + const Vec4& getDiffuse(MaterialFace face) const; + bool getDiffuseFrontAndBack() { return _diffuseFrontAndBack; } + + void setSpecular( MaterialFace face, const Vec4& specular ); + const Vec4& getSpecular(MaterialFace face) const; + bool getSpecularFrontAndBack() { return _specularFrontAndBack; } + + void setEmission( MaterialFace face, const Vec4& emission ); + const Vec4& getEmission(MaterialFace face) const; + bool getEmissionFrontAndBack() { return _emissionFrontAndBack; } + + void setShininess( MaterialFace face, float shininess ); + float getShininess(MaterialFace face) const; + bool getShininessFrontAndBack() { return _shininessFrontAndBack; } + + protected : + + virtual ~Material( void ); + + virtual bool readLocalData(Input& fr); + virtual bool writeLocalData(Output& fw); + + bool matchFaceAndColor(Input& fr,const char* name,MaterialFace& mf,Vec4& color); + + ColorMode _colorMode; + + bool _ambientFrontAndBack; + Vec4 _ambientFront; // r, g, b, w + Vec4 _ambientBack; // r, g, b, w + + bool _diffuseFrontAndBack; + Vec4 _diffuseFront; // r, g, b, w + Vec4 _diffuseBack; // r, g, b, w + + bool _specularFrontAndBack; + Vec4 _specularFront; // r, g, b, w + Vec4 _specularBack; // r, g, b, w + + bool _emissionFrontAndBack; + Vec4 _emissionFront; // r, g, b, w + Vec4 _emissionBack; // r, g, b, w + + bool _shininessFrontAndBack; + float _shininessFront; // values 0 - 1.0 + float _shininessBack; // values 0 - 1.0 + +}; + +}; + +#endif Index: /OpenSceneGraph/tags/osg_8_34/include/osg/PolygonOffset =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osg/PolygonOffset (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osg/PolygonOffset (revision 2) @@ -0,0 +1,44 @@ +#ifndef OSG_POLYGONOFFSET +#define OSG_POLYGONOFFSET 1 + +#include +#include +#include + +namespace osg { + +class Input; +class Output; + +class SG_EXPORT PolygonOffset : public Object +{ + public : + + PolygonOffset(); + static PolygonOffset* instance(); + virtual Object* clone() const { return new PolygonOffset(); } + virtual bool isSameKindAs(Object* obj) { return dynamic_cast(obj)!=NULL; } + virtual const char* className() const { return "PolygonOffset"; } + + void setOffset(float factor,float units); + + static void enable( void ); + static void disable( void ); + + void apply( void ); + + protected : + + virtual ~PolygonOffset(); + + virtual bool readLocalData(Input& fr); + virtual bool writeLocalData(Output& fw); + + float _factor; + float _units; + +}; + +}; + +#endif Index: /OpenSceneGraph/tags/osg_8_34/include/osg/Input =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osg/Input (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osg/Input (revision 2) @@ -0,0 +1,49 @@ +#ifndef OSG_INPUT +#define OSG_INPUT 1 + +#include + +#include +#include + +namespace osg { + +class Object; +class Image; +class Node; + +/** Class for managing the reading of ASCII .osg files.*/ +class SG_EXPORT Input : public FieldReaderIterator +{ + public: + +// Will extend to handle #DEF and use +// functionality similar to Inventor, +// and add the ability to handle #include +// from within the OSG file format. + + Input(); + virtual ~Input(); + + virtual Object* readObject(); + virtual Object* readObject(const std::string& fileName); + + virtual Image* readImage(); + virtual Image* readImage(const std::string& fileName); + + virtual Node* readNode(); + virtual Node* readNode(const std::string& fileName); + + virtual Object* getObjectForUniqueID(const std::string& uniqueID); + virtual void regisiterUniqueIDForObject(const std::string& uniqueID,Object* obj); + + private: + + typedef std::map UniqueIDToObjectMapping; + UniqueIDToObjectMapping _uniqueIDToObjectMap; + +}; + +}; + +#endif // __SG_INPUT_H Index: /OpenSceneGraph/tags/osg_8_34/include/osg/Vec2 =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osg/Vec2 (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osg/Vec2 (revision 2) @@ -0,0 +1,149 @@ +#ifndef OSG_VEC2 +#define OSG_VEC2 1 + +#include +#include + +#ifdef OSG_USE_IO_DOT_H +#include +#else +#include +using namespace std; +#endif + +namespace osg { + +/** General purpose float pair, uses include representation of + texture coordinates. + No support yet added for float * Vec2 - is it necessary? + Need to define a non-member non-friend operator* etc. + BTW: Vec2 * float is okay +*/ + +class Vec2 +{ + public: + + Vec2() {} // no operations done to maintain speed + Vec2(float x,float y) { _v[0]=x; _v[1]=y; } + + float _v[2]; + + bool operator == (const Vec2& v) const { return _v[0]==v._v[0] && _v[1]==v._v[1]; } + + inline float* ptr() { return _v; } + inline const float* ptr() const { return _v; } + + inline void set( float x, float y ) { _v[0]=x; _v[1]=y; } + + inline float& operator [] (int i) { return _v[i]; } + inline float operator [] (int i) const { return _v[i]; } + + inline float& x() { return _v[0]; } + inline float& y() { return _v[1]; } + + inline float x() const { return _v[0]; } + inline float y() const { return _v[1]; } + + /// dot product + inline float operator * (const Vec2& rhs) const + { + return _v[0]*rhs._v[0]+_v[1]*rhs._v[1]; + } + + /// multiply by scalar + inline Vec2 operator * (const float& rhs) const + { + return Vec2(_v[0]*rhs, _v[1]*rhs); + } + + /// unary multiply by scalar + inline Vec2& operator *= (const float& rhs) + { + _v[0]*=rhs; + _v[1]*=rhs; + return *this; + } + + /// divide by scalar + inline Vec2 operator / (const float& rhs) const + { + return Vec2(_v[0]/rhs, _v[1]/rhs); + } + + /// unary divide by scalar + inline Vec2& operator /= (const float& rhs) + { + _v[0]/=rhs; + _v[1]/=rhs; + return *this; + } + + /// binary vector add + inline Vec2 operator + (const Vec2& rhs) const + { + return Vec2(_v[0]+rhs._v[0], _v[1]+rhs._v[1]); + } + + /** unary vector add. Slightly more efficient because no temporary + intermediate object.*/ + inline Vec2& operator += (const Vec2& rhs) + { + _v[0] += rhs._v[0]; + _v[1] += rhs._v[1]; + return *this; + } + + /// binary vector subract + inline Vec2 operator - (const Vec2& rhs) const + { + return Vec2(_v[0]-rhs._v[0], _v[1]-rhs._v[1]); + } + + /// unary vector subract + inline Vec2& operator -= (const Vec2& rhs) + { + _v[0]-=rhs._v[0]; + _v[1]-=rhs._v[1]; + return *this; + } + + /// negation operator. Returns the negative of the Vec2 + inline Vec2 operator - () const + { + return Vec2 (-_v[0], -_v[1]); + } + + /// Length of the vector = sqrt( vec . vec ) + inline float length() const + { + return sqrtf( _v[0]*_v[0] + _v[1]*_v[1] ); + } + + /// Length squared of the vector = vec . vec + inline float length2( void ) const + { + return _v[0]*_v[0] + _v[1]*_v[1]; + } + + /** normalize the vector so that it has length unity + returns the previous length of the vector*/ + inline float normalize() + { + float norm = Vec2::length(); + _v[0] /= norm; + _v[1] /= norm; + return( norm ); + } + + friend inline ostream& operator << (ostream& output, const Vec2& vec) + { + output << vec._v[0] << " " + << vec._v[1]; + return output; // to enable cascading + } + +}; // end of class Vec2 + +} // end of namespace osg +#endif Index: /OpenSceneGraph/tags/osg_8_34/include/osg/Vec3 =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osg/Vec3 (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osg/Vec3 (revision 2) @@ -0,0 +1,168 @@ +#ifndef OSG_VEC3 +#define OSG_VEC3 1 + +#include +#include + +#ifdef OSG_USE_IO_DOT_H +#include +#else +#include +using namespace std; +#endif + +namespace osg { + +/** General purpose float triple for use as vertices, vectors and normals. + Provides general maths operations from addition through to cross products. + No support yet added for float * Vec3 - is it necessary? + Need to define a non-member non-friend operator* etc. + Vec3 * float is okay +*/ +class Vec3 +{ + public: + + Vec3() {} // no operations done to maintain speed + Vec3(float x,float y,float z) { _v[0]=x; _v[1]=y; _v[2]=z; } + + float _v[3]; + + bool operator == (const Vec3& v) const { return _v[0]==v._v[0] && _v[1]==v._v[1] && _v[2]==v._v[2]; } + + inline float* ptr() { return _v; } + inline const float* ptr() const { return _v; } + + inline void set( float x, float y, float z) + { + _v[0]=x; _v[1]=y; _v[2]=z; + } + + inline float& operator [] (int i) { return _v[i]; } + inline float operator [] (int i) const { return _v[i]; } + + inline float& x() { return _v[0]; } + inline float& y() { return _v[1]; } + inline float& z() { return _v[2]; } + + inline float x() const { return _v[0]; } + inline float y() const { return _v[1]; } + inline float z() const { return _v[2]; } + + /// dot product + inline float operator * (const Vec3& rhs) const + { + return _v[0]*rhs._v[0]+_v[1]*rhs._v[1]+_v[2]*rhs._v[2]; + } + + /// cross product + inline Vec3 operator ^ (const Vec3& rhs) const + { + return Vec3(_v[1]*rhs._v[2]-_v[2]*rhs._v[1], + _v[2]*rhs._v[0]-_v[0]*rhs._v[2] , + _v[0]*rhs._v[1]-_v[1]*rhs._v[0]); + } + + /// multiply by scalar + inline Vec3 operator * (const float& rhs) const + { + return Vec3(_v[0]*rhs, _v[1]*rhs, _v[2]*rhs); + } + + /// unary multiply by scalar + inline Vec3& operator *= (const float& rhs) + { + _v[0]*=rhs; + _v[1]*=rhs; + _v[2]*=rhs; + return *this; + } + + /// divide by scalar + inline Vec3 operator / (const float& rhs) const + { + return Vec3(_v[0]/rhs, _v[1]/rhs, _v[2]/rhs); + } + + /// unary divide by scalar + inline Vec3& operator /= (const float& rhs) + { + _v[0]/=rhs; + _v[1]/=rhs; + _v[2]/=rhs; + return *this; + } + + /// binary vector add + inline Vec3 operator + (const Vec3& rhs) const + { + return Vec3(_v[0]+rhs._v[0], _v[1]+rhs._v[1], _v[2]+rhs._v[2]); + } + + /** unary vector add. Slightly more efficient because no temporary + intermediate object*/ + inline Vec3& operator += (const Vec3& rhs) + { + _v[0] += rhs._v[0]; + _v[1] += rhs._v[1]; + _v[2] += rhs._v[2]; + return *this; + } + + /// binary vector subract + inline Vec3 operator - (const Vec3& rhs) const + { + return Vec3(_v[0]-rhs._v[0], _v[1]-rhs._v[1], _v[2]-rhs._v[2]); + } + + /// unary vector subract + inline Vec3& operator -= (const Vec3& rhs) + { + _v[0]-=rhs._v[0]; + _v[1]-=rhs._v[1]; + _v[2]-=rhs._v[2]; + return *this; + } + + /// negation operator. Returns the negative of the Vec3 + inline Vec3 operator - () const + { + return Vec3 (-_v[0], -_v[1], -_v[2]); + } + + /// Length of the vector = sqrt( vec . vec ) + inline float length( void ) const + { + return sqrtf( _v[0]*_v[0] + _v[1]*_v[1] + _v[2]*_v[2] ); + } + + /// Length squared of the vector = vec . vec + inline float length2( void ) const + { + return _v[0]*_v[0] + _v[1]*_v[1] + _v[2]*_v[2]; + } + + /** normalize the vector so that it has length unity + returns the previous length of the vector*/ + inline float normalize() + { + float norm = Vec3::length(); + _v[0] /= norm; + _v[1] /= norm; + _v[2] /= norm; + return( norm ); + } + + friend inline ostream& operator << (ostream& output, const Vec3& vec) + { + output << vec._v[0] << " " + << vec._v[1] << " " + << vec._v[2]; + return output; // to enable cascading + } + +}; // end of class Vec3 + +} // end of namespace osg + +#endif Index: /OpenSceneGraph/tags/osg_8_34/include/osg/AlphaFunc =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osg/AlphaFunc (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osg/AlphaFunc (revision 2) @@ -0,0 +1,65 @@ +#ifndef OSG_ALPHAFUNC +#define OSG_ALPHAFUNC 1 + +#include +#include +#include + +namespace osg { + +/** Encapsulte OpenGL glAlphaFunc. +*/ +class SG_EXPORT AlphaFunc : public Object +{ + public : + + enum ComparisonFunction { + NEVER = GL_NEVER, + LESS = GL_LESS, + EQUAL = GL_EQUAL, + LEQUAL = GL_LEQUAL, + GREATER = GL_GREATER, + NOTEQUAL = GL_NOTEQUAL, + GEQUAL = GL_GEQUAL, + ALWAYS = GL_ALWAYS + }; + + AlphaFunc(); + static AlphaFunc* instance(); + virtual bool isSameKindAs(Object* obj) { return dynamic_cast(obj)!=NULL; } + virtual Object* clone() const { return new AlphaFunc(); } + virtual const char* className() const { return "AlphaFunc"; } + + void setFunction(ComparisonFunction func,float ref) + { + _comparisonFunc = func; + _referenceValue = ref; + } + + ComparisonFunction getFunction() const { return _comparisonFunc; } + + float getRefrenceValue() const { return _referenceValue; } + + static void enable(); + static void disable(); + + void apply(); + + protected: + + virtual ~AlphaFunc(); + + virtual bool readLocalData(Input& fr); + virtual bool writeLocalData(Output& fw); + + bool matchFuncStr(const char* str,ComparisonFunction& func); + const char* getFuncStr(ComparisonFunction func); + + ComparisonFunction _comparisonFunc; + float _referenceValue; + +}; + +}; + +#endif Index: /OpenSceneGraph/tags/osg_8_34/include/osg/Vec4 =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osg/Vec4 (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osg/Vec4 (revision 2) @@ -0,0 +1,178 @@ +#ifndef OSG_VEC4 +#define OSG_VEC4 1 + +#include +#include + +#ifdef OSG_USE_IO_DOT_H +#include +#else +#include +using namespace std; +#endif + +namespace osg { + +/** General purpose float quad, uses include representation + of colour coordinates. + No support yet added for float * Vec4 - is it necessary? + Need to define a non-member non-friend operator* etc. + Vec4 * float is okay +*/ +class Vec4 +{ + public: + + // Methods are defined here so that they are implicitly inlined + + Vec4() {} // no operations done to maintain speed + Vec4(float x, float y, float z, float w) + { + _v[0]=x; _v[1]=y; _v[2]=z; _v[3]=w; + } + + float _v[4]; + + bool operator == (const Vec4& v) const { return _v[0]==v._v[0] && _v[1]==v._v[1] && _v[2]==v._v[2] && _v[3]==v._v[3]; } + + inline float* ptr() { return _v; } + inline const float* ptr() const { return _v; } + + inline void set( float x, float y, float z, float w) + { + _v[0]=x; _v[1]=y; _v[2]=z; _v[3]=w; + } + + inline float& operator [] (int i) { return _v[i]; } + inline float operator [] (int i) const { return _v[i]; } + + inline float& x() { return _v[0]; } + inline float& y() { return _v[1]; } + inline float& z() { return _v[2]; } + inline float& w() { return _v[3]; } + + inline float x() const { return _v[0]; } + inline float y() const { return _v[1]; } + inline float z() const { return _v[2]; } + inline float w() const { return _v[3]; } + + /// dot product + inline float operator * (const Vec4& rhs) const + { + return _v[0]*rhs._v[0]+ + _v[1]*rhs._v[1]+ + _v[2]*rhs._v[2]+ + _v[3]*rhs._v[3] ; + } + + /// multiply by scalar + inline Vec4 operator * (const float& rhs) const + { + return Vec4(_v[0]*rhs, _v[1]*rhs, _v[2]*rhs, _v[3]*rhs); + } + + /// unary multiply by scalar + inline Vec4& operator *= (const float& rhs) + { + _v[0]*=rhs; + _v[1]*=rhs; + _v[2]*=rhs; + _v[3]*=rhs; + return *this; + } + + /// divide by scalar + inline Vec4 operator / (const float& rhs) const + { + return Vec4(_v[0]/rhs, _v[1]/rhs, _v[2]/rhs, _v[3]/rhs); + } + + /// unary divide by scalar + inline Vec4& operator /= (const float& rhs) + { + _v[0]/=rhs; + _v[1]/=rhs; + _v[2]/=rhs; + _v[3]/=rhs; + return *this; + } + + /// binary vector add + inline Vec4 operator + (const Vec4& rhs) const + { + return Vec4(_v[0]+rhs._v[0], _v[1]+rhs._v[1], + _v[2]+rhs._v[2], _v[3]+rhs._v[3]); + } + + /** unary vector add. Slightly more efficient because no temporary + intermediate object*/ + inline Vec4& operator += (const Vec4& rhs) + { + _v[0] += rhs._v[0]; + _v[1] += rhs._v[1]; + _v[2] += rhs._v[2]; + _v[3] += rhs._v[3]; + return *this; + } + + /// binary vector subract + inline Vec4 operator - (const Vec4& rhs) const + { + return Vec4(_v[0]-rhs._v[0], _v[1]-rhs._v[1], + _v[2]-rhs._v[2], _v[3]-rhs._v[3] ); + } + + /// unary vector subract + inline Vec4& operator -= (const Vec4& rhs) + { + _v[0]-=rhs._v[0]; + _v[1]-=rhs._v[1]; + _v[2]-=rhs._v[2]; + _v[3]-=rhs._v[3]; + return *this; + } + + /// negation operator. Returns the negative of the Vec4 + inline Vec4 operator - () const + { + return Vec4 (-_v[0], -_v[1], -_v[2], -_v[3]); + } + + /// Length of the vector = sqrt( vec . vec ) + inline float length( void ) const + { + return sqrtf( _v[0]*_v[0] + _v[1]*_v[1] + _v[2]*_v[2] + _v[3]*_v[3]); + } + + /// Length squared of the vector = vec . vec + inline float length2( void ) const + { + return _v[0]*_v[0] + _v[1]*_v[1] + _v[2]*_v[2] + _v[3]*_v[3]; + } + + /** normalize the vector so that it has length unity + returns the previous length of the vector*/ + inline float normalize() + { + float norm = Vec4::length(); + _v[0] /= norm; + _v[1] /= norm; + _v[2] /= norm; + _v[3] /= norm; + return( norm ); + } + + friend inline ostream& operator << (ostream& output, const Vec4& vec) + { + output << vec._v[0] << " " + << vec._v[1] << " " + << vec._v[2] << " " + << vec._v[3]; + return output; // to enable cascading + } + +}; // end of class Vec4 + +} // end of namespace osg + +#endif Index: /OpenSceneGraph/tags/osg_8_34/include/osg/GL =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osg/GL (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osg/GL (revision 2) @@ -0,0 +1,71 @@ +#ifndef OSG_GL +#define OSG_GL 1 + +#ifdef WIN32 + + // this works with no problems +// #ifndef _WINDOWS_ +// #define WIN32_LEAN_AND_MEAN +// #include +// #endif + +// follows lifted from glut.h, to avoid including + +//#if defined(_WIN32) + +// GLUT 3.7 now tries to avoid including +// to avoid name space pollution, but Win32's +// needs APIENTRY and WINGDIAPI defined properly. +# if 0 +# define WIN32_LEAN_AND_MEAN +# include +# else + // XXX This is from Win32's +# ifndef APIENTRY +# define GLUT_APIENTRY_DEFINED +# if (_MSC_VER >= 800) || defined(_STDCALL_SUPPORTED) +# define APIENTRY __stdcall +# else +# define APIENTRY +# endif +# endif + // XXX This is from Win32's +# ifndef CALLBACK +# if (defined(_M_MRX000) || defined(_M_IX86) || defined(_M_ALPHA) || defined(_M_PPC)) && !defined(MIDL_PASS) +# define CALLBACK __stdcall +# else +# define CALLBACK +# endif +# endif + // XXX This is from Win32's and +# ifndef WINGDIAPI +# define GLUT_WINGDIAPI_DEFINED +# define WINGDIAPI __declspec(dllimport) +# endif + // XXX This is from Win32's +# ifndef _WCHAR_T_DEFINED +typedef unsigned short wchar_t; +# define _WCHAR_T_DEFINED +# endif +# endif + + + + #ifndef __gl_h_ + #include + #endif + #ifndef __glu_h__ + #include + #endif + +#else + + // GL_GLEXT_LEGACY required by some Linux OpenGL implementations + // to allow compilation of glPointParameterfEXT. + #define GL_GLEXT_LEGACY 1 + #include + #include + #include +#endif + +#endif // __osgGL_h Index: /OpenSceneGraph/tags/osg_8_34/include/osg/TexMat =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osg/TexMat (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osg/TexMat (revision 2) @@ -0,0 +1,29 @@ +#ifndef OSG_TEXMAT +#define OSG_TEXMAT 1 + +#include +#include + +namespace osg { + +class SG_EXPORT TexMat : public Matrix +{ + public : + TexMat( void ); + static TexMat* instance(); + virtual Object* clone() const { return new TexMat(); } + virtual bool isSameKindAs(Object* obj) { return dynamic_cast(obj)!=NULL; } + virtual const char* className() const { return "TexMat"; } + + void apply( void ); + + protected: + + virtual ~TexMat( void ); + +}; + +}; + + +#endif Index: /OpenSceneGraph/tags/osg_8_34/include/osg/Matrix =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osg/Matrix (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osg/Matrix (revision 2) @@ -0,0 +1,107 @@ +#ifndef OSG_MATRIX +#define OSG_MATRIX 1 + +#include +#include + +namespace osg { + +class Input; +class Output; + +/** 4x4 Matrix for storage & manipulation of transformations in scene graph. + Provides basic maths operations, IO and via osg::Object reference counting. +*/ +class SG_EXPORT Matrix : public Object +{ + public: + Matrix(); + Matrix(const Matrix& matrix); + Matrix( float a00, float a01, float a02, float a03, + float a10, float a11, float a12, float a13, + float a20, float a21, float a22, float a23, + float a30, float a31, float a32, float a33); + + Matrix& operator = (const Matrix& matrix); + + virtual ~Matrix(); + + static Matrix* instance(); + virtual Object* clone() const { return new Matrix(); } + virtual bool isSameKindAs(Object* obj) { return dynamic_cast(obj)!=NULL; } + virtual const char* className() const { return "Matrix"; } + + void makeIdent(); + + void set(const float* m); + void copy(const Matrix& matrix); + + void makeScale(float sx, float sy, float sz); + void preScale( float sx, float sy, float sz, const Matrix& m ); + void postScale( const Matrix& m, float sx, float sy, float sz ); + + void preScale( float sx, float sy, float sz ); + void postScale( float sx, float sy, float sz ); + + + void makeTrans( float tx, float ty, float tz ); + void preTrans( float tx, float ty, float tz, const Matrix& m ); + void postTrans( const Matrix& m, float tx, float ty, float tz ); + + void preTrans( float tx, float ty, float tz ); + void postTrans( float tx, float ty, float tz ); + + + void makeRot( float deg, float x, float y, float z ); + void preRot( float deg, float x, float y, float z, const Matrix& m ); + void postRot( const Matrix& m, float deg, float x, float y, float z ); + + void preRot( float deg, float x, float y, float z ); + void postRot( float deg, float x, float y, float z ); + + void setTrans( float tx, float ty, float tz ); + void setTrans( const Vec3& v ); + Vec3 getTrans() const { return Vec3(_mat[3][0],_mat[3][1],_mat[3][2]); } + + void preMult(const Matrix& m); + void postMult(const Matrix& m); + void mult(const Matrix& lhs,const Matrix& rhs); + + Matrix operator * (const Matrix& m) const; + + inline Vec3 operator * (const Vec3& v) const; + inline friend Vec3 operator * (const Vec3& v,const Matrix& m); + + bool invert(const Matrix& m); + + public : + float _mat[4][4]; + + protected: + + virtual bool readLocalData(Input& fr); + virtual bool writeLocalData(Output& fw); +}; + +// post multiple v. ie. (m*v) +inline Vec3 Matrix::operator * (const Vec3& v) const +{ + float d = 1.0f/(_mat[3][0]*v.x()+_mat[3][1]*v.y()+_mat[3][2]*v.z()+_mat[3][3]) ; + return Vec3( (_mat[0][0]*v.x() + _mat[0][1]*v.y() + _mat[0][2]*v.z() + _mat[0][3])*d, + (_mat[1][0]*v.x() + _mat[1][1]*v.y() + _mat[1][2]*v.z() + _mat[1][3])*d, + (_mat[2][0]*v.x() + _mat[2][1]*v.y() + _mat[2][2]*v.z() + _mat[2][3])*d) ; +} + + +// pre multiple v. ie. (v*m) +inline Vec3 operator * (const Vec3& v,const Matrix& m) +{ + float d = 1.0f/(m._mat[0][3]*v.x()+m._mat[1][3]*v.y()+m._mat[2][3]*v.z()+m._mat[3][3]) ; + return Vec3( (m._mat[0][0]*v.x() + m._mat[1][0]*v.y() + m._mat[2][0]*v.z() + m._mat[3][0])*d, + (m._mat[0][1]*v.x() + m._mat[1][1]*v.y() + m._mat[2][1]*v.z() + m._mat[3][1])*d, + (m._mat[0][2]*v.x() + m._mat[1][2]*v.y() + m._mat[2][2]*v.z() + m._mat[3][2])*d); +} + +}; + +#endif Index: /OpenSceneGraph/tags/osg_8_34/include/osg/Notify =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osg/Notify (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osg/Notify (revision 2) @@ -0,0 +1,64 @@ +#ifndef OSG_NOTIFY +#define OSG_NOTIFY 1 + +#include + +#ifdef OSG_USE_IO_DOT_H +#include +#include +//#include +#else +#include +#include +//#include +using namespace std; +#endif + + +namespace osg { + +enum NotifySeverity { + ALWAYS=0, + FATAL=1, + WARN=2, + NOTICE=3, + INFO=4, + DEBUG=5, + FP_DEBUG=6 +}; + +extern NotifySeverity g_NotifyLevel; +extern ofstream *g_absorbStreamPtr; + +SG_EXPORT extern void setNotifyLevel(NotifySeverity severity); +SG_EXPORT extern int getNotifyLevel(); + +#ifdef WIN32 +inline ostream& notify(NotifySeverity severity=INFO) +{ + if (severity<=osg::WARN) return cerr; + else return cout; +} + +#else +SG_EXPORT extern ostream& notify(NotifySeverity severity=INFO); +#endif + +// A nifty_counter to ensure that the notify things are initialised before +// they're used. Initialises g_NotifyLevel and g_absorbStreamPointer +class SG_EXPORT NotifyInit +{ + public: + + NotifyInit(); + ~NotifyInit(); + + private: + static int count_; +}; + +static NotifyInit niftyNotifyInit; + +}; + +#endif Index: /OpenSceneGraph/tags/osg_8_34/include/osg/Sequence =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osg/Sequence (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osg/Sequence (revision 2) @@ -0,0 +1,28 @@ +#ifndef OSG_SEQUENCE +#define OSG_SEQUENCE 1 + +#include + +namespace osg { + +/** Sequence - Switch node which allows iterators between children. + + Note: has not been implemented yet! +*/ +class SG_EXPORT Sequence : public Group +{ + public : + Sequence() {} + + virtual Object* clone() const { return new Sequence(); } + virtual bool isSameKindAs(Object* obj) { return dynamic_cast(obj)!=NULL; } + virtual const char* className() const { return "Sequence"; } + virtual void accept(NodeVisitor& nv) { nv.apply(*this); } + + protected : + virtual ~Sequence() {} +}; + +}; + +#endif Index: /OpenSceneGraph/tags/osg_8_34/include/osg/DCS =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osg/DCS (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osg/DCS (revision 2) @@ -0,0 +1,45 @@ +#ifndef OSG_DCS +#define OSG_DCS 1 + +#include +#include + +namespace osg { + +/** DCS - Dynamic Coordinate System a is group which all children + are transformed by the the DCS's osg::Matrix. Typical uses + of the DCS is for positioning objects within a scene or + producing trakerball functionality. +*/ +class SG_EXPORT DCS : public Group +{ + public : + DCS(); + DCS(const Matrix& matix); + + virtual Object* clone() const { return new DCS(); } + virtual bool isSameKindAs(Object* obj) { return dynamic_cast(obj)!=NULL; } + virtual const char* className() const { return "DCS"; } + virtual void accept(NodeVisitor& nv) { nv.apply(*this); } + + void setMatrix(const Matrix& mat ); + Matrix* getMatrix() { return _mat; } + + void preTranslate( float tx, float ty, float tz ); + void preRotate( float deg, float x, float y, float z ); + + bool computeBound(); + + protected : + + virtual ~DCS(); + + virtual bool readLocalData(Input& fr); + virtual bool writeLocalData(Output& fw); + + Matrix *_mat; +}; + +}; + +#endif Index: /OpenSceneGraph/tags/osg_8_34/include/osg/DynamicLibrary =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osg/DynamicLibrary (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osg/DynamicLibrary (revision 2) @@ -0,0 +1,51 @@ +#ifndef OSG_DYNAMICLIBRARY +#define OSG_DYNAMICLIBRARY 1 + +#include +#include + +#ifdef WIN32 +//#include +#endif + +namespace osg { + +/** DynamicLibrary - encapsulates the loading and unloading of dynamic libraries, + typically used for loading ReaderWriter plug-ins. +*/ +class SG_EXPORT DynamicLibrary : public Referenced +{ + public: + + #ifdef WIN32 + // from Snados.h + typedef void* HANDLE; + // from Delayimp.h + typedef void* PROC_ADDRESS; + #else + typedef void* HANDLE; + typedef void* PROC_ADDRESS; + #endif + + static DynamicLibrary* loadLibrary(const std::string& libraryName); + + const std::string& getName() const { return _name; } + const std::string& getFullName() const { return _fullName; } + HANDLE getHandle() const { return _handle; } + + PROC_ADDRESS getProcAddress(const std::string& procName); + + protected: + + DynamicLibrary(const std::string& name,HANDLE handle); + ~DynamicLibrary(); + + HANDLE _handle; + std::string _name; + std::string _fullName; + +}; + +}; + +#endif // __DYNAMIC_LIBRARY_H Index: /OpenSceneGraph/tags/osg_8_34/include/osg/Fog =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osg/Fog (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osg/Fog (revision 2) @@ -0,0 +1,66 @@ +#ifndef OSG_FOG +#define OSG_FOG 1 + +#include +#include +#include +#include + +namespace osg { + + +/** Fog - encapsulates OpenGL fog state. */ +class SG_EXPORT Fog : public Object +{ + public : + + enum FogMode { + LINEAR = GL_LINEAR, + EXP = GL_EXP, + EXP2 = GL_EXP2 + }; + + Fog( void ); + static Fog* instance(); + virtual Object* clone() const { return new Fog(); } + virtual bool isSameKindAs(Object* obj) { return dynamic_cast(obj)!=NULL; } + virtual const char* className() const { return "Fog"; } + + static void enable( void ); + static void disable( void ); + void apply( void ); + + void setMode( uint mode ) { _mode = mode; } + uint getMode( void ) { return _mode; } + + void setDensity( float density ) { _density = density; } + float getDensity( void ) { return _density; } + + void setStart( float start ) { _start = start; } + float getStart( void ) { return _start; } + + void setEnd( float end ) { _end = end; } + float getEnd( void ) { return _end; } + + void setColor( Vec4 &color ) + { + _color[0] = color[0]; + _color[1] = color[1]; + _color[2] = color[2]; + _color[3] = color[3]; + } + + protected : + + virtual ~Fog( void ); + + uint _mode; + float _density; + float _start; + float _end; + Vec4 _color; +}; + +}; + +#endif Index: /OpenSceneGraph/tags/osg_8_34/include/osg/LOD =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osg/LOD (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osg/LOD (revision 2) @@ -0,0 +1,67 @@ +#ifndef OSG_LOD +#define OSG_LOD 1 + +#include + +#include + +namespace osg { + +/** LOD - Level Of Detail group node which allows switching between children + depending on distance from eye point. + Typical uses are for load balancing - objects further away from + the eye point are rendered at a lower level of detail, and at times + of high stress on the graphics pipeline lower levels of detail can + also be chosen. +*/ +class SG_EXPORT LOD : public Group +{ + public : + LOD() {} + + virtual Object* clone() const { return new LOD(); } + virtual bool isSameKindAs(Object* obj) { return dynamic_cast(obj)!=NULL; } + virtual const char* className() const { return "LOD"; } + virtual void accept(NodeVisitor& nv) { nv.apply(*this); } + virtual void traverse(NodeVisitor& nv); + + /** Sets the value of range list element index to range which + is a floating point distance specified in world coordinates. + Range list automatically expands to accomodate values beyond + the current getNumRanges().*/ + void setRange(unsigned int index, float range); + /** pfLOD::getRange returns the range element index.*/ + float getRange(unsigned int index) { return _rangeList[index]; } + /** returns the number of ranges currently set.*/ + int getNumRanges() { return _rangeList.size(); } + + /** Sets the object-space point which defines the center of the osg::LOD. + center is affected by any transforms in the hierarchy above the osg::LOD.*/ + void setCenter(const Vec3 ¢er) { _center = center; } + /** return the LOD center point. */ + const Vec3& getCenter() { return _center; } + + + /** return the child to traverse. + Selected by the distance between the eye point in local + coordinates and the LOD center, mutliplied by the bias.*/ + int evaluate(const Vec3& eye_local,float bias=1.0f); + + + protected : + virtual ~LOD() {} + + virtual bool readLocalData(Input& fr); + virtual bool writeLocalData(Output& fw); + + typedef std::vector RangeList; + RangeList _rangeList; + RangeList _rangeList2; + + Vec3 _center; + +}; + +}; + +#endif Index: /OpenSceneGraph/tags/osg_8_34/include/osg/CullFace =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osg/CullFace (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osg/CullFace (revision 2) @@ -0,0 +1,51 @@ +#ifndef OSG_CULLFACE +#define OSG_CULLFACE 1 + +#include +#include +#include + +namespace osg { + +/** Class to globally enable/disable OpenGL's polygon culling mode + (GL_CULL_FACE). +*/ +class SG_EXPORT CullFace : public Object +{ + public : + + enum Mode { + FRONT = GL_FRONT, + BACK = GL_BACK, + FRONT_AND_BACK = GL_FRONT_AND_BACK + }; + + CullFace(); + static CullFace* instance(); + virtual bool isSameKindAs(Object* obj) { return dynamic_cast(obj)!=NULL; } + virtual Object* clone() const { return new CullFace(); } + virtual const char* className() const { return "CullFace"; } + + void setMode(Mode mode) { _mode = mode; } + + /** Enable the polygon culling mode.*/ + static void enable(); + /** Disable the polygon culling mode.*/ + static void disable(); + + void apply(); + + protected: + + virtual ~CullFace(); + + virtual bool readLocalData(Input& fr); + virtual bool writeLocalData(Output& fw); + + Mode _mode; + +}; + +}; + +#endif Index: /OpenSceneGraph/tags/osg_8_34/include/osg/Seg =================================================================== --- /OpenSceneGraph/tags/osg_8_34/include/osg/Seg (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/include/osg/Seg (revision 2) @@ -0,0 +1,63 @@ +#ifndef OSG_SEG +#define OSG_SEG 1 + +#include +#include +#include +#include +#include +#include + +namespace osg { + +/** Segment class for representing a line segment.*/ +class SG_EXPORT Seg : public Referenced +{ + public: + + Seg() {}; + Seg(const Seg& seg) : Referenced(),_s(seg._s),_e(seg._e) {} + Seg(const Vec3& s,const Vec3& e) : _s(s),_e(e) {} + virtual ~Seg() {} + + Seg& operator = (const Seg& seg) { _s = seg._s; _e = seg._e; return *this; } + + void set(const Vec3& s,const Vec3& e) { _s=s; _e=e; } + + const Vec3& start() const { return _s; } + Vec3& start() { return _s; } + + const Vec3& end() const { return _e; } + Vec3& end() { return _e; } + + /** return true if segment intersects BoundingBox.*/ + bool intersect(const BoundingBox& bb) const; + + /** return true if segment intersects BoundingSphere and return the intersection ratio's.*/ + bool intersect(const BoundingBox& bb,float& r1,float& r2) const; + + /** return true if segment intersects BoundingSphere.*/ + bool intersect(const BoundingSphere& bs) const; + + /** return true if segment intersects BoundingSphere and return the intersection ratio's.*/ + bool intersect(const BoundingSphere& bs,float& r1,float& r2) const; + + /** return true if segment intersects triangle and set ratio long segment. */ + bool intersect(const Vec3& v1,const Vec3& v2,const Vec3& v3,float& r); + + /** post multiply a segment by matrix.*/ + void mult(const Seg& seg,const Matrix& m) { _s = seg._s*m; _e = seg._e*m; } + /** pre multiply a segment by matrix.*/ + void mult(const Matrix& m,const Seg& seg) { _s = m*seg._s; _e = m*seg._e; } + + protected: + + static bool intersectAndClip(Vec3& s,Vec3& e,const BoundingBox& bb); + + Vec3 _s; + Vec3 _e; +}; + +}; + +#endif Index: /OpenSceneGraph/tags/osg_8_34/AUTHORS =================================================================== --- /OpenSceneGraph/tags/osg_8_34/AUTHORS (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/AUTHORS (revision 2) @@ -0,0 +1,44 @@ +# $Id$ +# +# The is a list of authors and contributors to the project. +# Feel free to add your name and change list. + +Robert Osfield + - osg and osgUtil. + - pfb, gif, jpeg, tiff, tga, pic plugins. + - sgv, various revisions, now most of code in osgGLUT. + - documentation?! + - visual studio workspace files/unix makefiles. + - project adim & lead. + +Don Burns + - libosg (particularily OpenGL) + - first version of sgv. + - fly database plugin. + - netscape plugin. + - unix makefiles. + +Graeme Harkness + - osg::Vec2,Vec3,Vec4 & osg::Quat classes. + - reworking of old sgv into osgGLUT and a slim line Demos/sgv. + - Demos/cube. + +Neil Salter + - first incarnation of osgUtil, Camera and Manipulators. + - web site. + +Brede Johansen + - flt loader. + - osg::Point. + - bug fixes. + - assistance on visual studio workspace files. + +Ben Discoe + - png plugin. + - a couple of bug fixes and code submissions. + +Karsten Weiss + - autoconfiscation of the project. + - rpm spec file. + - documentation. + - bug fixes. Index: /OpenSceneGraph/tags/osg_8_34/TODO =================================================================== --- /OpenSceneGraph/tags/osg_8_34/TODO (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/TODO (revision 2) @@ -0,0 +1,141 @@ +OSG TODO List +============= + +Main categories +=============== + +o Core OSG Library + - the core OSG library itself (include/OSG and src/) +o Reader/writer plug-ins + - the reader/writers plug-ins for third party file formats. +o Viewers & Application plug-ins + - osg viewers and plug-ins to third party applications such as Netscape. +o Under development + - listing of TODO items which are currently under developement. +o Work completed + - listing of TODO items which have been done and hence removed + from the above TODO catagories. +-- + +o Core OSG Library + ================ + - General + . Header & code documentation/reference guide. + . Programming guide. + . Naming conventions. + . mutli-threading/shared memory support. + + - Maths + . full maths support in osg::Matrix class. + . double matrix class. + . osg::Plane class. + + - Nodes + . create a base class to provide interface to objects which can render, + derive osg::GeoSet from this. + . add osg::Sequence for basic animation. + . add osg::Morph for interpolating between geometries. + . add support for Multi-texturing into osg::GeoSet/osg::GeoState. + . add support for multi-pass rendering. + . utilise stl vectors for osg::GeoSets? + . improve osg::GeoState. + . add osg::State for mainting image of the OpenGL state. + . add osg::Terrain node. + . add osg::EarthSky class for rendering earth and sky backgrounds. + . add proxy node for lazy loading of nodes, when needed. + . implement visual proximity to assist loading of proxied data + when the view frustum nears an unloaded proxy node, and deleting + of unused proxied data. + . implement support for modified status/lazy evaluation of node data + and observer style pattern. + . manipulator decoration nodes? + . spacial subdivision decoration nodes? + + - Visitors + . improve state sorting of opaque bins in osg::RenderVistor. + . add statistics visitor for logging the stats of the scene graph. + . add OpenGL picking visitor. + + - IO/Plug-in support + . improve the ascii parsing class osg::Field, osg::FieldReader etc. + . change the osg::Registry to timestamp registrations of objects/RW's. + . add support for file path logging into osg::Input. + . add binary data reading and writing into osg::Input/osg::Output to + support part binary .osg files. + . return error messages of on failed loading/saving. + + +o Reader/writer plug-ins + ======================= + - .iv/.wrl Inventor/VRML ascii. + - .obj Alias wavefront's format. + - .dxf Autocads ascii format. + - .3ds 3D Studio format. + - .dem digital elevation map. + - .d3d? MS's Direct 3D file formats if they have one.. + - .bmp Windows Bitmap files. + - .gz Automatic unzipping of GNU zipped files. + - .zip Automatic unzipping of windows zipped files. + - .Z Automatic unzipping of Unix Compress files. + - .tar Automatic unpacking of directories and loading of contents. + + +o Viewers & Application plug-ins + =============================== + - OSG scene graph viewer - sgv. + . add command line reading for specifying data search paths and data, + -D for data search path, -d for data. + . add command line reading for specifying library search paths and + libraries/plug-ins, -D for library search path, -l for libraries. + - Internet Explorer plug-in. + - .osg to Inventor file plug-in. + - Tutorials example programs. + + +o Under development + ================= + Sign up here if would like to take on a task :-) + - add osg::Billboard for trees etc. + - .pfb loader for Performer binary files. + - full maths support in osg::Matrix class. + - Netscape plug-in. + - add osg::Channel/sgCamera class. + - .flt Open Flight format. + - autoconf/configure support to aid portabilty to other unix's. + - CVS support for when source is made fully public. + + +o Work completed + ============== + - osg namespace implemented. + - reduce the STL platform specific #ifdef's. + - remove using namespace from all header files, so not to pollute user space. + - remove the sg prefix from sgNode etc, now that the osg namespaces exits. + - FAQ for distribution and web site. + - full maths support in osg::Vec2, osg::Vec3 and osg::Vec4. + - change the osg::Registry to use plug-in RW's on loading a plug-in + instead of the plug-in functions found in sg.cxx. + - add support for removal of plug-ins from osg::Registry, + - add .osg support into DCS node. + - clean up inheritance relationship between osg::Node, osg::Object etc. + - add osg::Switch for handling optional rendering of children. + - add osg::LOD (level of detail) group node for load management. + - add view frustrum culling into osg::RenderVisitor. + - add support for mutliply referenced nodes into osg::Input. + - add a quaternion class. + - improve osg::BoundingBox and osg::BoundingSphere. + - add hit and intersect classes for collision detection. + - add intersect visitor. + - add camera manipualotors for trackball, drive and flight mouse control. + - add compile OpenGL display lists visitor (currently in sgv). + - library version and description functions. + - add support for OpenGL Vertex Array into osg::GeoSet. + - .gif GIF Images! + - .jpg JPEG Images. + - .tiff TIFF Images. + - .png PNG Images. + - .tga TGA Images. + - .pic PIC Images. + - add timing/timestamp class. + - document how to get the OSG compiled and running under all + platforms, Win32 being priority as it's the least obvious. Index: /OpenSceneGraph/tags/osg_8_34/doc/Doxyfile =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/Doxyfile (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/Doxyfile (revision 2) @@ -0,0 +1,708 @@ +# Doxyfile 1.2.2 + +# This file describes the settings to be used by doxygen for a project +# +# All text after a hash (#) is considered a comment and will be ignored +# The format is: +# TAG = value [value, ...] +# For lists items can also be appended using: +# TAG += value [value, ...] +# Values that contain spaces should be placed between quotes (" ") + +#--------------------------------------------------------------------------- +# General configuration options +#--------------------------------------------------------------------------- + +# The PROJECT_NAME tag is a single word (or a sequence of words surrounded +# by quotes) that should identify the project. + +PROJECT_NAME = "OpenSceneGraph & Utility Toolkit" + +# The PROJECT_NUMBER tag can be used to enter a project or revision number. +# This could be handy for archiving the generated documentation or +# if some version control system is used. + +PROJECT_NUMBER = 0.8-26 + +# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) +# base path where the generated documentation will be put. +# If a relative path is entered, it will be relative to the location +# where doxygen was started. If left blank the current directory will be used. + +OUTPUT_DIRECTORY = $(OSGHOME)/docs/doxygen + +# The OUTPUT_LANGUAGE tag is used to specify the language in which all +# documentation generated by doxygen is written. Doxygen will use this +# information to generate all constant output in the proper language. +# The default language is English, other supported languages are: +# Dutch, French, Italian, Czech, Swedish, German, Finnish, Japanese, +# Korean, Hungarian, Spanish, Romanian, Russian, Croatian, Polish, and +# Portuguese. + +OUTPUT_LANGUAGE = English + +# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in +# documentation are documented, even if no documentation was available. +# Private class members and static file members will be hidden unless +# the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES + +EXTRACT_ALL = YES + +# If the EXTRACT_PRIVATE tag is set to YES all private members of a class +# will be included in the documentation. + +EXTRACT_PRIVATE = NO + +# If the EXTRACT_STATIC tag is set to YES all static members of a file +# will be included in the documentation. + +EXTRACT_STATIC = NO + +# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all +# undocumented members of documented classes, files or namespaces. +# If set to NO (the default) these members will be included in the +# various overviews, but no documentation section is generated. +# This option has no effect if EXTRACT_ALL is enabled. + +HIDE_UNDOC_MEMBERS = NO + +# If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all +# undocumented classes that are normally visible in the class hierarchy. +# If set to NO (the default) these class will be included in the various +# overviews. This option has no effect if EXTRACT_ALL is enabled. + +HIDE_UNDOC_CLASSES = NO + +# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will +# include brief member descriptions after the members that are listed in +# the file and class documentation (similar to JavaDoc). +# Set to NO to disable this. + +BRIEF_MEMBER_DESC = YES + +# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend +# the brief description of a member or function before the detailed description. +# Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the +# brief descriptions will be completely suppressed. + +REPEAT_BRIEF = YES + +# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then +# Doxygen will generate a detailed section even if there is only a brief +# description. + +ALWAYS_DETAILED_SEC = NO + +# If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full +# path before files name in the file list and in the header files. If set +# to NO the shortest path that makes the file name unique will be used. + +FULL_PATH_NAMES = NO + +# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag +# can be used to strip a user defined part of the path. Stripping is +# only done if one of the specified strings matches the left-hand part of +# the path. It is allowed to use relative paths in the argument list. + +STRIP_FROM_PATH = + +# The INTERNAL_DOCS tag determines if documentation +# that is typed after a \internal command is included. If the tag is set +# to NO (the default) then the documentation will be excluded. +# Set it to YES to include the internal documentation. + +INTERNAL_DOCS = NO + +# If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will +# generate a class diagram (in Html and LaTeX) for classes with base or +# super classes. Setting the tag to NO turns the diagrams off. + +CLASS_DIAGRAMS = YES + +# If the SOURCE_BROWSER tag is set to YES then a list of source files will +# be generated. Documented entities will be cross-referenced with these sources. + +SOURCE_BROWSER = NO + +# Setting the INLINE_SOURCES tag to YES will include the body +# of functions and classes directly in the documentation. + +INLINE_SOURCES = NO + +# Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct +# doxygen to hide any special comment blocks from generated source code +# fragments. Normal C and C++ comments will always remain visible. + +STRIP_CODE_COMMENTS = YES + +# If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate +# file names in lower case letters. If set to YES upper case letters are also +# allowed. This is useful if you have classes or files whose names only differ +# in case and if your file system supports case sensitive file names. Windows +# users are adviced to set this option to NO. + +CASE_SENSE_NAMES = YES + +# If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen +# will show members with their full class and namespace scopes in the +# documentation. If set to YES the scope will be hidden. + +HIDE_SCOPE_NAMES = NO + +# If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen +# will generate a verbatim copy of the header file for each class for +# which an include is specified. Set to NO to disable this. + +VERBATIM_HEADERS = YES + +# If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen +# will put list of the files that are included by a file in the documentation +# of that file. + +SHOW_INCLUDE_FILES = YES + +# If the JAVADOC_AUTOBRIEF tag is set to YES (the default) then Doxygen +# will interpret the first line (until the first dot) of a JavaDoc-style +# comment as the brief description. If set to NO, the Javadoc-style will +# behave just like the Qt-style comments. + +JAVADOC_AUTOBRIEF = YES + +# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented +# member inherits the documentation from any documented member that it +# reimplements. + +INHERIT_DOCS = YES + +# If the INLINE_INFO tag is set to YES (the default) then a tag [inline] +# is inserted in the documentation for inline members. + +INLINE_INFO = YES + +# If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen +# will sort the (detailed) documentation of file and class members +# alphabetically by member name. If set to NO the members will appear in +# declaration order. + +SORT_MEMBER_DOCS = YES + +# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC +# tag is set to YES, then doxygen will reuse the documentation of the first +# member in the group (if any) for the other members of the group. By default +# all members of a group must be documented explicitly. + +DISTRIBUTE_GROUP_DOC = NO + +# The TAB_SIZE tag can be used to set the number of spaces in a tab. +# Doxygen uses this value to replace tabs by spaces in code fragments. + +TAB_SIZE = 8 + +# The ENABLE_SECTIONS tag can be used to enable conditional +# documentation sections, marked by \if sectionname ... \endif. + +ENABLED_SECTIONS = + +# The GENERATE_TODOLIST tag can be used to enable (YES) or +# disable (NO) the todo list. This list is created by putting \todo +# commands in the documentation. + +GENERATE_TODOLIST = YES + +# The GENERATE_TESTLIST tag can be used to enable (YES) or +# disable (NO) the test list. This list is created by putting \test +# commands in the documentation. + +GENERATE_TESTLIST = YES + +# This tag can be used to specify a number of aliases that acts +# as commands in the documentation. An alias has the form "name=value". +# For example adding "sideeffect=\par Side Effects:\n" will allow you to +# put the command \sideeffect (or @sideeffect) in the documentation, which +# will result in a user defined paragraph with heading "Side Effects:". +# You can put \n's in the value part of an alias to insert newlines. + +ALIASES = + +#--------------------------------------------------------------------------- +# configuration options related to warning and progress messages +#--------------------------------------------------------------------------- + +# The QUIET tag can be used to turn on/off the messages that are generated +# by doxygen. Possible values are YES and NO. If left blank NO is used. + +QUIET = NO + +# The WARNINGS tag can be used to turn on/off the warning messages that are +# generated by doxygen. Possible values are YES and NO. If left blank +# NO is used. + +WARNINGS = YES + +# If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings +# for undocumented members. If EXTRACT_ALL is set to YES then this flag will +# automatically be disabled. + +WARN_IF_UNDOCUMENTED = YES + +# The WARN_FORMAT tag determines the format of the warning messages that +# doxygen can produce. The string should contain the $file, $line, and $text +# tags, which will be replaced by the file and line number from which the +# warning originated and the warning text. + +WARN_FORMAT = "$file:$line: $text" + +#--------------------------------------------------------------------------- +# configuration options related to the input files +#--------------------------------------------------------------------------- + +# The INPUT tag can be used to specify the files and/or directories that contain +# documented source files. You may enter file names like "myfile.cpp" or +# directories like "/usr/src/myproject". Separate the files or directories +# with spaces. + +INPUT = $(OSGHOME) + +# If the value of the INPUT tag contains directories, you can use the +# FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp +# and *.h) to filter out the source-files in the directories. If left +# blank all files are included. + +FILE_PATTERNS = */include/* */src/*/*.cpp + +# The RECURSIVE tag can be used to turn specify whether or not subdirectories +# should be searched for input files as well. Possible values are YES and NO. +# If left blank NO is used. + +RECURSIVE = YES + +# The EXCLUDE tag can be used to specify files and/or directories that should +# excluded from the INPUT source files. This way you can easily exclude a +# subdirectory from a directory tree whose root is specified with the INPUT tag. + +EXCLUDE = + +# If the value of the INPUT tag contains directories, you can use the +# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude +# certain files from those directories. + +EXCLUDE_PATTERNS = + +# The EXAMPLE_PATH tag can be used to specify one or more files or +# directories that contain example code fragments that are included (see +# the \include command). + +EXAMPLE_PATH = + +# If the value of the EXAMPLE_PATH tag contains directories, you can use the +# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp +# and *.h) to filter out the source-files in the directories. If left +# blank all files are included. + +EXAMPLE_PATTERNS = + +# The IMAGE_PATH tag can be used to specify one or more files or +# directories that contain image that are included in the documentation (see +# the \image command). + +IMAGE_PATH = + +# The INPUT_FILTER tag can be used to specify a program that doxygen should +# invoke to filter for each input file. Doxygen will invoke the filter program +# by executing (via popen()) the command , where +# is the value of the INPUT_FILTER tag, and is the name of an +# input file. Doxygen will then use the output that the filter program writes +# to standard output. + +INPUT_FILTER = + +#--------------------------------------------------------------------------- +# configuration options related to the alphabetical class index +#--------------------------------------------------------------------------- + +# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index +# of all compounds will be generated. Enable this if the project +# contains a lot of classes, structs, unions or interfaces. + +ALPHABETICAL_INDEX = YES + +# If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then +# the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns +# in which this list will be split (can be a number in the range [1..20]) + +COLS_IN_ALPHA_INDEX = 5 + +# In case all classes in a project start with a common prefix, all +# classes will be put under the same header in the alphabetical index. +# The IGNORE_PREFIX tag can be used to specify one or more prefixes that +# should be ignored while generating the index headers. + +IGNORE_PREFIX = + +#--------------------------------------------------------------------------- +# configuration options related to the HTML output +#--------------------------------------------------------------------------- + +# If the GENERATE_HTML tag is set to YES (the default) Doxygen will +# generate HTML output. + +GENERATE_HTML = YES + +# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `html' will be used as the default path. + +HTML_OUTPUT = html + +# The HTML_HEADER tag can be used to specify a personal HTML header for +# each generated HTML page. If it is left blank doxygen will generate a +# standard header. + +HTML_HEADER = + +# The HTML_FOOTER tag can be used to specify a personal HTML footer for +# each generated HTML page. If it is left blank doxygen will generate a +# standard footer. + +HTML_FOOTER = + +# The HTML_STYLESHEET tag can be used to specify a user defined cascading +# style sheet that is used by each HTML page. It can be used to +# fine-tune the look of the HTML output. If the tag is left blank doxygen +# will generate a default style sheet + +HTML_STYLESHEET = + +# If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes, +# files or namespaces will be aligned in HTML using tables. If set to +# NO a bullet list will be used. + +HTML_ALIGN_MEMBERS = YES + +# If the GENERATE_HTMLHELP tag is set to YES, additional index files +# will be generated that can be used as input for tools like the +# Microsoft HTML help workshop to generate a compressed HTML help file (.chm) +# of the generated HTML documentation. + +GENERATE_HTMLHELP = NO + +# The DISABLE_INDEX tag can be used to turn on/off the condensed index at +# top of each HTML page. The value NO (the default) enables the index and +# the value YES disables it. + +DISABLE_INDEX = NO + +#--------------------------------------------------------------------------- +# configuration options related to the LaTeX output +#--------------------------------------------------------------------------- + +# If the GENERATE_LATEX tag is set to YES (the default) Doxygen will +# generate Latex output. + +GENERATE_LATEX = NO + +# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `latex' will be used as the default path. + +LATEX_OUTPUT = latex + +# If the COMPACT_LATEX tag is set to YES Doxygen generates more compact +# LaTeX documents. This may be useful for small projects and may help to +# save some trees in general. + +COMPACT_LATEX = NO + +# The PAPER_TYPE tag can be used to set the paper type that is used +# by the printer. Possible values are: a4, a4wide, letter, legal and +# executive. If left blank a4wide will be used. + +PAPER_TYPE = a4wide + +# The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX +# packages that should be included in the LaTeX output. + +EXTRA_PACKAGES = + +# The LATEX_HEADER tag can be used to specify a personal LaTeX header for +# the generated latex document. The header should contain everything until +# the first chapter. If it is left blank doxygen will generate a +# standard header. Notice: only use this tag if you know what you are doing! + +LATEX_HEADER = + +# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated +# is prepared for conversion to pdf (using ps2pdf). The pdf file will +# contain links (just like the HTML output) instead of page references +# This makes the output suitable for online browsing using a pdf viewer. + +PDF_HYPERLINKS = NO + +# If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of +# plain latex in the generated Makefile. Set this option to YES to get a +# higher quality PDF documentation. + +USE_PDFLATEX = NO + +# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode. +# command to the generated LaTeX files. This will instruct LaTeX to keep +# running if errors occur, instead of asking the user for help. +# This option is also used when generating formulas in HTML. + +LATEX_BATCHMODE = NO + +#--------------------------------------------------------------------------- +# configuration options related to the RTF output +#--------------------------------------------------------------------------- + +# If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output +# The RTF output is optimised for Word 97 and may not look very pretty with +# other RTF readers or editors. + +GENERATE_RTF = NO + +# The RTF_OUTPUT tag is used to specify where the RTF docs will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `rtf' will be used as the default path. + +RTF_OUTPUT = rtf + +# If the COMPACT_RTF tag is set to YES Doxygen generates more compact +# RTF documents. This may be useful for small projects and may help to +# save some trees in general. + +COMPACT_RTF = NO + +# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated +# will contain hyperlink fields. The RTF file will +# contain links (just like the HTML output) instead of page references. +# This makes the output suitable for online browsing using a WORD or other. +# programs which support those fields. +# Note: wordpad (write) and others do not support links. + +RTF_HYPERLINKS = NO + +# Load stylesheet definitions from file. Syntax is similar to doxygen's +# config file, i.e. a series of assigments. You only have to provide +# replacements, missing definitions are set to their default value. + +RTF_STYLESHEET_FILE = + +#--------------------------------------------------------------------------- +# configuration options related to the man page output +#--------------------------------------------------------------------------- + +# If the GENERATE_MAN tag is set to YES (the default) Doxygen will +# generate man pages + +GENERATE_MAN = YES + +# The MAN_OUTPUT tag is used to specify where the man pages will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be +# put in front of it. If left blank `man' will be used as the default path. + +MAN_OUTPUT = man + +# The MAN_EXTENSION tag determines the extension that is added to +# the generated man pages (default is the subroutine's section .3) + +MAN_EXTENSION = .3 + +#--------------------------------------------------------------------------- +# configuration options related to the XML output +#--------------------------------------------------------------------------- + +# If the GENERATE_XML tag is set to YES Doxygen will +# generate an XML file that captures the structure of +# the code including all documentation. Warning: This feature +# is still experimental and very incomplete. + +GENERATE_XML = NO + +#--------------------------------------------------------------------------- +# Configuration options related to the preprocessor +#--------------------------------------------------------------------------- + +# If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will +# evaluate all C-preprocessor directives found in the sources and include +# files. + +ENABLE_PREPROCESSING = YES + +# If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro +# names in the source code. If set to NO (the default) only conditional +# compilation will be performed. Macro expansion can be done in a controlled +# way by setting EXPAND_ONLY_PREDEF to YES. + +MACRO_EXPANSION = NO + +# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES +# then the macro expansion is limited to the macros specified with the +# PREDEFINED and EXPAND_AS_PREDEFINED tags. + +EXPAND_ONLY_PREDEF = NO + +# If the SEARCH_INCLUDES tag is set to YES (the default) the includes files +# in the INCLUDE_PATH (see below) will be search if a #include is found. + +SEARCH_INCLUDES = YES + +# The INCLUDE_PATH tag can be used to specify one or more directories that +# contain include files that are not input files but should be processed by +# the preprocessor. + +INCLUDE_PATH = + +# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard +# patterns (like *.h and *.hpp) to filter out the header-files in the +# directories. If left blank, the patterns specified with FILE_PATTERNS will +# be used. + +INCLUDE_FILE_PATTERNS = + +# The PREDEFINED tag can be used to specify one or more macro names that +# are defined before the preprocessor is started (similar to the -D option of +# gcc). The argument of the tag is a list of macros of the form: name +# or name=definition (no spaces). If the definition and the = are +# omitted =1 is assumed. + +PREDEFINED = + +# If the MACRO_EXPANSION and EXPAND_PREDEF_ONLY tags are set to YES then +# this tag can be used to specify a list of macro names that should be expanded. +# The macro definition that is found in the sources will be used. +# Use the PREDEFINED tag if you want to use a different macro definition. + +EXPAND_AS_DEFINED = + +#--------------------------------------------------------------------------- +# Configuration::addtions related to external references +#--------------------------------------------------------------------------- + +# The TAGFILES tag can be used to specify one or more tagfiles. + +TAGFILES = + +# When a file name is specified after GENERATE_TAGFILE, doxygen will create +# a tag file that is based on the input files it reads. + +GENERATE_TAGFILE = + +# If the ALLEXTERNALS tag is set to YES all external classes will be listed +# in the class index. If set to NO only the inherited external classes +# will be listed. + +ALLEXTERNALS = NO + +# The PERL_PATH should be the absolute path and name of the perl script +# interpreter (i.e. the result of `which perl'). + +PERL_PATH = /usr/bin/perl + +#--------------------------------------------------------------------------- +# Configuration options related to the dot tool +#--------------------------------------------------------------------------- + +# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is +# available from the path. This tool is part of Graphviz, a graph visualization +# toolkit from AT&T and Lucent Bell Labs. The other options in this section +# have no effect if this option is set to NO (the default) + +HAVE_DOT = YES + +# If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen +# will generate a graph for each documented class showing the direct and +# indirect inheritance relations. Setting this tag to YES will force the +# the CLASS_DIAGRAMS tag to NO. + +CLASS_GRAPH = YES + +# If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen +# will generate a graph for each documented class showing the direct and +# indirect implementation dependencies (inheritance, containment, and +# class references variables) of the class with other documented classes. + +COLLABORATION_GRAPH = YES + +# If the ENABLE_PREPROCESSING, INCLUDE_GRAPH, and HAVE_DOT tags are set to +# YES then doxygen will generate a graph for each documented file showing +# the direct and indirect include dependencies of the file with other +# documented files. + +INCLUDE_GRAPH = YES + +# If the ENABLE_PREPROCESSING, INCLUDED_BY_GRAPH, and HAVE_DOT tags are set to +# YES then doxygen will generate a graph for each documented header file showing +# the documented files that directly or indirectly include this file + +INCLUDED_BY_GRAPH = YES + +# If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen +# will graphical hierarchy of all classes instead of a textual one. + +GRAPHICAL_HIERARCHY = YES + +# The tag DOT_PATH can be used to specify the path where the dot tool can be +# found. If left blank, it is assumed the dot tool can be found on the path. + +DOT_PATH = + +# The MAX_DOT_GRAPH_WIDTH tag can be used to set the maximum allowed width +# (in pixels) of the graphs generated by dot. If a graph becomes larger than +# this value, doxygen will try to truncate the graph, so that it fits within +# the specified constraint. Beware that most browsers cannot cope with very +# large images. + +MAX_DOT_GRAPH_WIDTH = 1024 + +# The MAX_DOT_GRAPH_HEIGHT tag can be used to set the maximum allows height +# (in pixels) of the graphs generated by dot. If a graph becomes larger than +# this value, doxygen will try to truncate the graph, so that it fits within +# the specified constraint. Beware that most browsers cannot cope with very +# large images. + +MAX_DOT_GRAPH_HEIGHT = 1024 + +#--------------------------------------------------------------------------- +# Configuration::addtions related to the search engine +#--------------------------------------------------------------------------- + +# The SEARCHENGINE tag specifies whether or not a search engine should be +# used. If set to NO the values of all tags below this one will be ignored. + +SEARCHENGINE = NO + +# The CGI_NAME tag should be the name of the CGI script that +# starts the search engine (doxysearch) with the correct parameters. +# A script with this name will be generated by doxygen. + +CGI_NAME = search.cgi + +# The CGI_URL tag should be the absolute URL to the directory where the +# cgi binaries are located. See the documentation of your http daemon for +# details. + +CGI_URL = + +# The DOC_URL tag should be the absolute URL to the directory where the +# documentation is located. If left blank the absolute path to the +# documentation, with file:// prepended to it, will be used. + +DOC_URL = + +# The DOC_ABSPATH tag should be the absolute path to the directory where the +# documentation is located. If left blank the directory on the local machine +# will be used. + +DOC_ABSPATH = + +# The BIN_ABSPATH tag must point to the directory where the doxysearch binary +# is installed. + +BIN_ABSPATH = /usr/local/bin/ + +# The EXT_DOC_PATHS tag can be used to specify one or more paths to +# documentation generated for other projects. This allows doxysearch to search +# the documentation for these projects as well. + +EXT_DOC_PATHS = Index: /OpenSceneGraph/tags/osg_8_34/doc/osgGLUT/General.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osgGLUT/General.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osgGLUT/General.html (revision 2) @@ -0,0 +1,33 @@ + + + General Bits + + + + +
+
+ +o#define +OSGGLUT_EXPORT_
+
+ +o#define +OSGGLUT_EXPORT(dllexport)
+
+ +o#define +OSGGLUT_EXPORT(dllimport)
+
+ +o#define +OSGGLUT_GLUTEVENTADAPTER
+
+ +o#define +OSGGLUT_VIEWER
+
+Alphabetic index Hierarchy of classes

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osgGLUT/GLUTEventAdapter.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osgGLUT/GLUTEventAdapter.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osgGLUT/GLUTEventAdapter.html (revision 2) @@ -0,0 +1,342 @@ + + + class OSGGLUT_EXPORT osgGLUT::GLUTEventAdapter + + + + +

class OSGGLUT_EXPORT osgGLUT::GLUTEventAdapter: public osgUtil::GUIEventAdapter

+
Class for adapting GLUT events so that they can be used as input to osgUtil::CameraManipulators
+
+ +

Inheritance:

+ + + + + + + +
+ +
+

+

Public Methods

+[more] GLUTEventAdapter() +
+
+[more]virtual ~GLUTEventAdapter() +
+
+[more]virtual EventType getEventType() const +
Get the EventType of the GUI event +
+[more]virtual int getKey() const +
key pressed, return -1 if inapropriate for this event. +
+[more]virtual int getButton() const +
button pressed/released, return -1 if inappropriate for this event +
+[more]virtual int getXmin() const +
window minimum x. +
+[more]virtual int getXmax() const +
window maximum x. +
+[more]virtual int getYmin() const +
window minimum y. +
+[more]virtual int getYmax() const +
window maximum y. +
+[more]virtual int getX() const +
current mouse x position +
+[more]virtual int getY() const +
current mouse y position +
+[more]virtual unsigned int getButtonMask() const +
current mouse button state +
+[more]virtual float time() const +
time in seconds of event. +
+[more]static void setWindowSize(int Xmin, int Ymin, int Xmax, int Ymax) +
static method for setting window dimensions +
+[more]static void setButtonMask(unsigned int buttonMask) +
static method for setting button state +
+[more]void adaptResize(float t, int Xmin, int Ymin, int Xmax, int Ymax) +
method for adapting resize events. +
+[more]void adaptMouseMotion(float t, int x, int y) +
method for adapting mouse motion events whilst mouse buttons are pressed +
+[more]void adaptMousePassiveMotion(float t, int x, int y) +
method for adapting mouse motion events whilst no mouse button are pressed +
+[more]void adaptMouse(float t, int button, int state, int x, int y) +
method for adapting mouse button pressed/released events +
+[more]void adaptKeyboard(float t, unsigned char key, int x, int y ) +
method for adapting keyboard events +
+[more]void adaptFrame(float t) +
method for adapting frame events, ie. +
+[more]void copyStaticVariables() +
+

+ +

+

Protected Fields

+[more]EventType _eventType +
+
+[more]int _key +
+
+[more]int _button +
+
+[more]int _Xmin +
+
+[more]int _Xmax +
+
+[more]int _Ymin +
+
+[more]int _Ymax +
+
+[more]int _mx +
+
+[more]int _my +
+
+[more]unsigned int _buttonMask +
+
+[more]float _time +
+
+[more]static unsigned int _s_accumulatedButtonMask +
+
+[more]static int _s_Xmin +
+
+[more]static int _s_Xmax +
+
+[more]static int _s_Ymin +
+
+[more]static int _s_Ymax +
+
+[more]static int _s_mx +
+
+[more]static int _s_my +
+

+ +
+ + +
+

Documentation

+
Class for adapting GLUT events so that they can be used as input to osgUtil::CameraManipulators
+
+ + + +
o GLUTEventAdapter() +

+ + +

ovirtual ~GLUTEventAdapter() +

+ + +

ovirtual EventType getEventType() const +
Get the EventType of the GUI event +

+ + +

ovirtual int getKey() const +
key pressed, return -1 if inapropriate for this event. +

+ + +

ovirtual int getButton() const +
button pressed/released, return -1 if inappropriate for this event +

+ + +

ovirtual int getXmin() const +
window minimum x. +

+ + +

ovirtual int getXmax() const +
window maximum x. +

+ + +

ovirtual int getYmin() const +
window minimum y. +

+ + +

ovirtual int getYmax() const +
window maximum y. +

+ + +

ovirtual int getX() const +
current mouse x position +

+ + +

ovirtual int getY() const +
current mouse y position +

+ + +

ovirtual unsigned int getButtonMask() const +
current mouse button state +

+ + +

ovirtual float time() const +
time in seconds of event. +

+ + +

ostatic void setWindowSize(int Xmin, int Ymin, int Xmax, int Ymax) +
static method for setting window dimensions +

+ + +

ostatic void setButtonMask(unsigned int buttonMask) +
static method for setting button state +

+ + +

ovoid adaptResize(float t, int Xmin, int Ymin, int Xmax, int Ymax) +
method for adapting resize events. +

+ + +

ovoid adaptMouseMotion(float t, int x, int y) +
method for adapting mouse motion events whilst mouse buttons are pressed +

+ + +

ovoid adaptMousePassiveMotion(float t, int x, int y) +
method for adapting mouse motion events whilst no mouse button are pressed +

+ + +

ovoid adaptMouse(float t, int button, int state, int x, int y) +
method for adapting mouse button pressed/released events +

+ + +

ovoid adaptKeyboard(float t, unsigned char key, int x, int y ) +
method for adapting keyboard events +

+ + +

ovoid adaptFrame(float t) +
method for adapting frame events, ie. iddle/display callback. +

+ + +

ovoid copyStaticVariables() +

+ + +

oEventType _eventType +

+ + +

oint _key +

+ + +

oint _button +

+ + +

oint _Xmin +

+ + +

oint _Xmax +

+ + +

oint _Ymin +

+ + +

oint _Ymax +

+ + +

oint _mx +

+ + +

oint _my +

+ + +

ounsigned int _buttonMask +

+ + +

ofloat _time +

+ + +

ostatic unsigned int _s_accumulatedButtonMask +

+ + +

ostatic int _s_Xmin +

+ + +

ostatic int _s_Xmax +

+ + +

ostatic int _s_Ymin +

+ + +

ostatic int _s_Ymax +

+ + +

ostatic int _s_mx +

+ + +

ostatic int _s_my +

+ +
This class has no child classes.
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osgGLUT/Viewer.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osgGLUT/Viewer.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osgGLUT/Viewer.html (revision 2) @@ -0,0 +1,508 @@ + + + class OSGGLUT_EXPORT osgGLUT::Viewer + + + + +

class OSGGLUT_EXPORT osgGLUT::Viewer: public osgUtil::GUIActionAdapter

+
A basic viewer base class which provides a window, simple keyboard and mouse interaction.
+
+ +

Inheritance:

+ + + + + + + +
+ +
+

+

Public Methods

+[more] Viewer() +
+
+[more]virtual ~Viewer() +
+
+[more]virtual bool init( osg::Node* ) +
+
+[more]virtual bool run() +
+
+[more]virtual bool update() +
+
+[more]virtual bool traverse() +
+
+[more]virtual bool draw() +
+
+[more]long initClock() +
+
+[more]float clockSeconds() +
+
+[more]osg::Timer_t updateFrameTick() +
+
+[more]float frameSeconds() +
+
+[more]float frameRate() +
+
+[more]void help(ostream& fout) +
+
+[more]void registerCameraManipulator(osgUtil::CameraManipulator* cm) +
+
+[more]void selectCameraManipulator(unsigned int pos) +
+
+[more]virtual void needRedraw(bool ) +
+
+[more]virtual void needContinuousUpdate(bool ) +
+
+[more]virtual void needWarpPointer(int x, int y) +
+

+ +

+

Protected Fields

+[more]static Viewer* s_theViewer +
+
+[more]osg::ref_ptr<osgUtil::SceneView> _sceneView +
+
+[more]osg::ref_ptr<osgUtil::CameraManipulator> _cameraManipulator +
+
+[more]CameraManipList _cameraManipList +
+
+[more]std::string _saveFileName +
+
+[more]int ww +
+
+[more]int wh +
+
+[more]ifdef SGV_USE_RTFS unsigned int frame_rate +
+
+[more]RTfs* fs +
+
+[more]bool _viewFrustumCullingActive +
+
+[more]bool _smallFeatureCullingActive +
+
+[more]int mx +
+
+[more]int my +
+
+[more]int mbutton +
+
+[more]int polymode +
+
+[more]int texture +
+
+[more]int backface +
+
+[more]int lighting +
+
+[more]int flat_shade +
+
+[more]int _two_sided_lighting +
+
+[more]bool fullscreen +
+
+[more]int _saved_ww +
+
+[more]int _saved_wh +
+
+[more]bool _printStats +
+
+[more]bool _useDisplayLists +
+
+[more]osg::Timer _timer +
+
+[more]osg::Timer_t _tickRatePerSecond +
+
+[more]osg::Timer_t _initialTick +
+
+[more]osg::Timer_t _lastFrameTick +
+
+[more]osg::Timer_t _frameTick +
+

+ +

+

Protected Methods

+[more]static void displayCB() +
+
+[more]static void reshapeCB(GLint w, GLint h) +
+
+[more]static void visibilityCB(int state) +
+
+[more]static void mouseMotionCB(int x, int y) +
+
+[more]static void mousePassiveMotionCB(int x, int y) +
+
+[more]static void mouseCB(int button, int state, int x, int y) +
+
+[more]static void keyboardCB(unsigned char key, int x, int y ) +
+
+[more]virtual void display() +
+
+[more]virtual void reshape(GLint w, GLint h) +
+
+[more]virtual void visibility(int state) +
+
+[more]virtual void mouseMotion(int x, int y) +
+
+[more]virtual void mousePassiveMotion(int x, int y) +
+
+[more]virtual void mouse(int button, int state, int x, int y) +
+
+[more]virtual void keyboard(unsigned char key, int x, int y) +
+
+[more]osg::Timer_t clockTick() +
+
+[more]osg::Timer_t frameTick() +
+

+ +

+

Protected

+[more]typedef std::vector<osg::ref_ptr<osgUtil::CameraManipulator> > CameraManipList +
+

+ +
+ + +
+

Documentation

+
A basic viewer base class which provides a window, simple keyboard and mouse interaction. +Please note, this viewer class has been developed via a rather haphazzard +path and *needs* a total rewrite. It currently surfices for osg demo's +but shouldn't be viewed as the be all or end of osg viewer classes. +Someone please rewrite it :-)
+
+ + + +
o Viewer() +

+ + +

ovirtual ~Viewer() +

+ + +

ovirtual bool init( osg::Node* ) +

+ + +

ovirtual bool run() +

+ + +

ovirtual bool update() +

+ + +

ovirtual bool traverse() +

+ + +

ovirtual bool draw() +

+ + +

olong initClock() +

+ + +

ofloat clockSeconds() +

+ + +

oosg::Timer_t updateFrameTick() +

+ + +

ofloat frameSeconds() +

+ + +

ofloat frameRate() +

+ + +

ovoid help(ostream& fout) +

+ + +

ovoid registerCameraManipulator(osgUtil::CameraManipulator* cm) +

+ + +

ovoid selectCameraManipulator(unsigned int pos) +

+ + +

ovirtual void needRedraw(bool ) +

+ + +

ovirtual void needContinuousUpdate(bool ) +

+ + +

ovirtual void needWarpPointer(int x, int y) +

+ + +

ostatic void displayCB() +

+ + +

ostatic void reshapeCB(GLint w, GLint h) +

+ + +

ostatic void visibilityCB(int state) +

+ + +

ostatic void mouseMotionCB(int x, int y) +

+ + +

ostatic void mousePassiveMotionCB(int x, int y) +

+ + +

ostatic void mouseCB(int button, int state, int x, int y) +

+ + +

ostatic void keyboardCB(unsigned char key, int x, int y ) +

+ + +

ovirtual void display() +

+ + +

ovirtual void reshape(GLint w, GLint h) +

+ + +

ovirtual void visibility(int state) +

+ + +

ovirtual void mouseMotion(int x, int y) +

+ + +

ovirtual void mousePassiveMotion(int x, int y) +

+ + +

ovirtual void mouse(int button, int state, int x, int y) +

+ + +

ovirtual void keyboard(unsigned char key, int x, int y) +

+ + +

ostatic Viewer* s_theViewer +

+ + +

oosg::ref_ptr<osgUtil::SceneView> _sceneView +

+ + +

otypedef std::vector<osg::ref_ptr<osgUtil::CameraManipulator> > CameraManipList +

+ + +

oosg::ref_ptr<osgUtil::CameraManipulator> _cameraManipulator +

+ + +

oCameraManipList _cameraManipList +

+ + +

ostd::string _saveFileName +

+ + +

oint ww +

+ + +

oint wh +

+ + +

oifdef SGV_USE_RTFS unsigned int frame_rate +

+ + +

oRTfs* fs +

+ + +

obool _viewFrustumCullingActive +

+ + +

obool _smallFeatureCullingActive +

+ + +

oint mx +

+ + +

oint my +

+ + +

oint mbutton +

+ + +

oint polymode +

+ + +

oint texture +

+ + +

oint backface +

+ + +

oint lighting +

+ + +

oint flat_shade +

+ + +

oint _two_sided_lighting +

+ + +

obool fullscreen +

+ + +

oint _saved_ww +

+ + +

oint _saved_wh +

+ + +

obool _printStats +

+ + +

obool _useDisplayLists +

+ + +

oosg::Timer _timer +

+ + +

oosg::Timer_t _tickRatePerSecond +

+ + +

oosg::Timer_t _initialTick +

+ + +

oosg::Timer_t _lastFrameTick +

+ + +

oosg::Timer_t _frameTick +

+ + +

oosg::Timer_t clockTick() +

+ + +

oosg::Timer_t frameTick() +

+ +
This class has no child classes.
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osgGLUT/osgGLUT.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osgGLUT/osgGLUT.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osgGLUT/osgGLUT.html (revision 2) @@ -0,0 +1,27 @@ + + + namespace osgGLUT + + + + +

namespace osgGLUT

+ +
+

+
class OSGGLUT_EXPORT GLUTEventAdapter +
Class for adapting GLUT events so that they can be used as input to osgUtil::CameraManipulators +
class OSGGLUT_EXPORT Viewer +
A basic viewer base class which provides a window, simple keyboard and mouse interaction. +

+ + + +
+

Documentation

+
+
+

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osgGLUT/HIER.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osgGLUT/HIER.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osgGLUT/HIER.html (revision 2) @@ -0,0 +1,15 @@ + + + Hierarchy of Classes + + + +

Hierarchy of Classes

+ +Alphabetic index

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osgGLUT/index.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osgGLUT/index.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osgGLUT/index.html (revision 2) @@ -0,0 +1,27 @@ + + + Table of Contents + + + + +

Table of Contents

+

Namespaces

+ +

Macros

+ +Hierarchy of classes

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osgGLUT/HIERjava.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osgGLUT/HIERjava.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osgGLUT/HIERjava.html (revision 2) @@ -0,0 +1,27 @@ + + + Hierarchy of Classes + + + +

Hierarchy of classes

+
    + + + + + + + + + + + + + + +
+ alphabetic index

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/osgUtilGetLibraryName.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/osgUtilGetLibraryName.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/osgUtilGetLibraryName.html (revision 2) @@ -0,0 +1,21 @@ + + + extern OSGUTIL_EXPORT const char* osgUtilGetLibraryName + + + + +

extern OSGUTIL_EXPORT const char* osgUtilGetLibraryName()

+
getLibraryName_osgUtil() returns the library name in human friendly form
+ + +
+

Documentation

+
+getLibraryName_osgUtil() returns the library name in human friendly form
+
+
+

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/CameraTrackballManipulator.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/CameraTrackballManipulator.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/CameraTrackballManipulator.html (revision 2) @@ -0,0 +1,125 @@ + + + class OSGUTIL_EXPORT osgUtil::CameraTrackballManipulator + + + + +

class OSGUTIL_EXPORT osgUtil::CameraTrackballManipulator

+
+ +
+

+

Public Classes

+[more]enum MovementType +
+

+ +

+

Public Methods

+[more] CameraTrackballManipulator() +
+
+[more] ~CameraTrackballManipulator() +
+
+[more]void setCamera(osg::Camera *) +
+
+[more]osg::Camera* getCamera() const +
+
+[more]void initialise(int x, int y) +
initialise(int x,int y) will typically be called on a mouse down prior to a number of drag events. +
+[more]bool update(MovementType movementType, int x, int y) +
update(MovementType,int,int) will typically be called on receipt of drag events, with a view to letting the view change the view. +
+[more]void update() +
This will replicate any previous update, and is useful for animation +
+[more]MovementType getLastMovementType() const +
Returns last movementType, and is useful for updating on mouse up +

+ +
+ + +
+

Documentation

+
+ + + +
o CameraTrackballManipulator() +

+ + +

o ~CameraTrackballManipulator() +

+ + +

ovoid setCamera(osg::Camera *) +

+ + +

oosg::Camera* getCamera() const +

+ + +

ovoid initialise(int x, int y) +
+initialise(int x,int y) will typically be called on a +mouse down prior to a number of drag events. The parameters +tell the viewer where the mouse is at the start of the drag. +

+ + +

oenum MovementType +

+ + + +
o NONE +

+ + +

o ORBIT +

+ + +

o ZOOM +

+ + +

o PAN +

+ + + +
obool update(MovementType movementType, int x, int y) +
+update(MovementType,int,int) will typically be called on receipt of drag events, +with a view to letting the view change the view. The return value specifies whether +any change to the view was necessary as a result from the mouse event. Returns true +if any change in viewpoint is made. +

+ + +

ovoid update() +
+This will replicate any previous update, and is useful for animation +

+ + +

oMovementType getLastMovementType() const +
+Returns last movementType, and is useful for updating on mouse up +

+ +
This class has no child classes.
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/HIER.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/HIER.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/HIER.html (revision 2) @@ -0,0 +1,28 @@ + + + Hierarchy of Classes + + + +

Hierarchy of Classes

+ +Alphabetic index

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/RenderVisitor.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/RenderVisitor.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/RenderVisitor.html (revision 2) @@ -0,0 +1,525 @@ + + + class OSGUTIL_EXPORT osgUtil::RenderVisitor + + + + +

class OSGUTIL_EXPORT osgUtil::RenderVisitor: public osg::NodeVisitor

+
Basic NodeVisitor implementation for rendering a scene.
+
+ +

Inheritance:

+ + + + + + + +
+ +
+

+

Public Classes

+[more]enum TransparencySortMode +
+
+[more]enum CullingType +
+

+ +

+

Public Methods

+[more] RenderVisitor() +
+
+[more]virtual ~RenderVisitor() +
+
+[more]void reset() +
+
+[more]virtual void apply(osg::Node&) +
+
+[more]virtual void apply(osg::Geode& node) +
+
+[more]virtual void apply(osg::Billboard& node) +
+
+[more]virtual void apply(osg::LightSource& node) +
+
+[more]virtual void apply(osg::Group& node) +
+
+[more]virtual void apply(osg::DCS& node) +
+
+[more]virtual void apply(osg::Switch& node) +
+
+[more]virtual void apply(osg::LOD& node) +
+
+[more]virtual void apply(osg::Scene& node) +
+
+[more]void setGlobalState(osg::GeoState* global) +
+
+[more]void setPerspective(const osg::Camera& camera) +
+
+[more]void setPerspective(float fovy, float aspect, float znear, float zfar) +
+
+[more]void setLookAt(const osg::Camera& camera) +
+
+[more]void setLookAt(const osg::Vec3& eye, const osg::Vec3& center, const osg::Vec3& upVector) +
+
+[more]void setLookAt(double eyeX, double eyeY, double eyeZ, double centerX, double centerY, double centerZ, double upX, double upY, double upZ) +
+
+[more]void setLODBias(float bias) +
+
+[more]float getLODBias() +
+
+[more]void setTransparencySortMode(TransparencySortMode tsm) +
+
+[more]void setCullingActive(CullingType ct, bool active) +
Enables/disables the specified culling type. +
+[more]bool getCullingActive(CullingType ct) +
Returns the state of the specified culling type. +
+[more]bool calcNearFar(double& near_plane, double& far_plane) +
Calculates the near_plane and the far_plane for the current camera view depending on the objects currently stored in the opaque and transparent bins. +
+[more]void render() +
Renders the osg::GeoSets that were collected in the opaque and transparent bins before +

+ +

+

Protected Fields

+[more]bool _viewFrustumCullingActive +
+
+[more]bool _smallFeatureCullingActive +
+
+[more]ViewStateStack _viewStateStack +
+
+[more]ViewState* _tvs +
+
+[more]ViewState* _cvs +
+
+[more]OpaqueList _opaqueGeoSets +
+
+[more]TransparentList _transparentGeoSets +
+
+[more]LightList _lights +
+
+[more]osg::GeoState* _globalState +
+
+[more]float _LODBias +
+
+[more]float _fovy +
+
+[more]float _aspect +
+
+[more]float _znear +
+
+[more]float _zfar +
+
+[more]osg::Vec3 _frustumTop +
+
+[more]osg::Vec3 _frustumBottom +
+
+[more]osg::Vec3 _frustumLeft +
+
+[more]osg::Vec3 _frustumRight +
+
+[more]TransparencySortMode _tsm +
+

+ +

+

Protected Methods

+[more]void pushMatrix(const osg::Matrix& matrix) +
+
+[more]void popMatrix() +
+
+[more]osg::Matrix* getCurrentMatrix() +
+
+[more]osg::Matrix* getInverseCurrentMatrix() +
+
+[more]const osg::Vec3& getEyeLocal() +
+
+[more]const osg::Vec3& getCenterLocal() +
+
+[more]const osg::Vec3& getLookVectorLocal() +
+
+[more]bool isCulled(const osg::BoundingSphere& sp) +
+
+[more]bool isCulled(const osg::BoundingBox& bb) +
+
+[more]void calculateClippingPlanes() +
+

+ +

+

Protected

+[more]typedef std::pair<osg::Matrix*,osg::GeoSet*> MatrixGeoSet +
+
+[more]typedef std::vector<ViewState*> ViewStateStack +
+
+[more]typedef std::multimap<osg::GeoState*,MatrixGeoSet> OpaqueList +
+
+[more]typedef std::multimap<float,MatrixGeoSet> TransparentList +
+
+[more]typedef std::map<osg::Matrix*,osg::Light*> LightList +
+

+ +
+ + +
+

Documentation

+
+Basic NodeVisitor implementation for rendering a scene. +This visitor traverses the scene graph, collecting transparent and +opaque osg::GeoSets into a depth sorted transparent bin and a state +sorted opaque bin. The opaque bin is rendered first, and then the +transparent bin in rendered in order from the furthest osg::GeoSet +from the eye to the one nearest the eye.
+
+ + + +
o RenderVisitor() +

+ + +

ovirtual ~RenderVisitor() +

+ + +

ovoid reset() +

+ + +

ovirtual void apply(osg::Node&) +

+ + +

ovirtual void apply(osg::Geode& node) +

+ + +

ovirtual void apply(osg::Billboard& node) +

+ + +

ovirtual void apply(osg::LightSource& node) +

+ + +

ovirtual void apply(osg::Group& node) +

+ + +

ovirtual void apply(osg::DCS& node) +

+ + +

ovirtual void apply(osg::Switch& node) +

+ + +

ovirtual void apply(osg::LOD& node) +

+ + +

ovirtual void apply(osg::Scene& node) +

+ + +

ovoid setGlobalState(osg::GeoState* global) +

+ + +

ovoid setPerspective(const osg::Camera& camera) +

+ + +

ovoid setPerspective(float fovy, float aspect, float znear, float zfar) +

+ + +

ovoid setLookAt(const osg::Camera& camera) +

+ + +

ovoid setLookAt(const osg::Vec3& eye, const osg::Vec3& center, const osg::Vec3& upVector) +

+ + +

ovoid setLookAt(double eyeX, double eyeY, double eyeZ, double centerX, double centerY, double centerZ, double upX, double upY, double upZ) +

+ + +

ovoid setLODBias(float bias) +

+ + +

ofloat getLODBias() +

+ + +

oenum TransparencySortMode +

+ + + +
o LOOK_VECTOR_DISTANCE +

+ + +

o OBJECT_EYE_POINT_DISTANCE +

+ + + +
ovoid setTransparencySortMode(TransparencySortMode tsm) +

+ + +

oenum CullingType +

+ + + +
o VIEW_FRUSTUM_CULLING +

+ + +

o SMALL_FEATURE_CULLING +

+ + + +
ovoid setCullingActive(CullingType ct, bool active) +
+Enables/disables the specified culling type. + +
Parameters:
ct - The culling type to enable/disable. +
active - true enables the culling type, false disables.

+ + +

obool getCullingActive(CullingType ct) +
+Returns the state of the specified culling type. +@result true, if culling type is enabled, false otherwise. +

+ + +

obool calcNearFar(double& near_plane, double& far_plane) +
+Calculates the near_plane and the far_plane for the current +camera view depending on the objects currently stored in the +opaque and transparent bins. + +
Parameters:
near_plane - reference to a variable that can store the +near plane result. +
far_plane - reference to a variable that can store the +far plane result. +@result true, if near_plane and far_plane contain valid values, +false otherwise.

+ + +

ovoid render() +
+Renders the osg::GeoSets that were collected in the opaque and +transparent bins before +

+ + +

ovoid pushMatrix(const osg::Matrix& matrix) +

+ + +

ovoid popMatrix() +

+ + +

oosg::Matrix* getCurrentMatrix() +

+ + +

oosg::Matrix* getInverseCurrentMatrix() +

+ + +

oconst osg::Vec3& getEyeLocal() +

+ + +

oconst osg::Vec3& getCenterLocal() +

+ + +

oconst osg::Vec3& getLookVectorLocal() +

+ + +

obool _viewFrustumCullingActive +

+ + +

obool _smallFeatureCullingActive +

+ + +

obool isCulled(const osg::BoundingSphere& sp) +

+ + +

obool isCulled(const osg::BoundingBox& bb) +

+ + +

otypedef std::pair<osg::Matrix*,osg::GeoSet*> MatrixGeoSet +

+ + +

otypedef std::vector<ViewState*> ViewStateStack +

+ + +

oViewStateStack _viewStateStack +

+ + +

oViewState* _tvs +

+ + +

oViewState* _cvs +

+ + +

otypedef std::multimap<osg::GeoState*,MatrixGeoSet> OpaqueList +

+ + +

otypedef std::multimap<float,MatrixGeoSet> TransparentList +

+ + +

otypedef std::map<osg::Matrix*,osg::Light*> LightList +

+ + +

oOpaqueList _opaqueGeoSets +

+ + +

oTransparentList _transparentGeoSets +

+ + +

oLightList _lights +

+ + +

oosg::GeoState* _globalState +

+ + +

ofloat _LODBias +

+ + +

ofloat _fovy +

+ + +

ofloat _aspect +

+ + +

ofloat _znear +

+ + +

ofloat _zfar +

+ + +

ovoid calculateClippingPlanes() +

+ + +

oosg::Vec3 _frustumTop +

+ + +

oosg::Vec3 _frustumBottom +

+ + +

oosg::Vec3 _frustumLeft +

+ + +

oosg::Vec3 _frustumRight +

+ + +

oTransparencySortMode _tsm +

+ +
This class has no child classes.
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/CompileGeoSetsVisitor.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/CompileGeoSetsVisitor.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/CompileGeoSetsVisitor.html (revision 2) @@ -0,0 +1,61 @@ + + + class OSGUTIL_EXPORT osgUtil::CompileGeoSetsVisitor + + + + +

class OSGUTIL_EXPORT osgUtil::CompileGeoSetsVisitor: public osg::NodeVisitor

+
Visitor for traversing scene compiling OpenGL Display list from osg::GeoSets
+
+ +

Inheritance:

+ + + + + + + +
+ +
+

+

Public Methods

+[more] CompileGeoSetsVisitor() +
+
+[more]virtual void apply(osg::Node& node) +
+
+[more]virtual void apply(osg::Geode& node) +
+

+ +
+ + +
+

Documentation

+
Visitor for traversing scene compiling OpenGL Display list from osg::GeoSets
+
+ + + +
o CompileGeoSetsVisitor() +

+ + +

ovirtual void apply(osg::Node& node) +

+ + +

ovirtual void apply(osg::Geode& node) +

+ +
This class has no child classes.
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/ViewState.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/ViewState.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/ViewState.html (revision 2) @@ -0,0 +1,166 @@ + + + class OSGUTIL_EXPORT osgUtil::ViewState + + + + +

class OSGUTIL_EXPORT osgUtil::ViewState: public osg::Referenced

+
Container class for encapsulating the viewing state in local coordinates, during the cull traversal
+
+ +

Inheritance:

+ + + + + + + +
+ +
+

+

Public Fields

+[more]osg::Matrix* _matrix +
+
+[more]osg::Matrix* _inverse +
+
+[more]osg::Vec3 _eyePoint +
+
+[more]osg::Vec3 _centerPoint +
+
+[more]osg::Vec3 _lookVector +
+
+[more]osg::Vec3 _upVector +
+
+[more]osg::Vec3 _frustumTopNormal +
+
+[more]osg::Vec3 _frustumBottomNormal +
+
+[more]osg::Vec3 _frustumLeftNormal +
+
+[more]osg::Vec3 _frustumRightNormal +
+
+[more]float _ratio +
+
+[more]bool _viewFrustumCullingActive +
+
+[more]bool _smallFeatureCullingActive +
+

+ +

+

Public Methods

+[more] ViewState() +
+
+[more]bool isCulled(const osg::BoundingSphere& sp) +
+
+[more]bool isCulled(const osg::BoundingBox& bb) +
+

+ +

+

Protected Methods

+[more] ~ViewState() +
+

+ +
+ + +
+

Documentation

+
Container class for encapsulating the viewing state in local +coordinates, during the cull traversal
+
+ + + +
o ViewState() +

+ + +

oosg::Matrix* _matrix +

+ + +

oosg::Matrix* _inverse +

+ + +

oosg::Vec3 _eyePoint +

+ + +

oosg::Vec3 _centerPoint +

+ + +

oosg::Vec3 _lookVector +

+ + +

oosg::Vec3 _upVector +

+ + +

oosg::Vec3 _frustumTopNormal +

+ + +

oosg::Vec3 _frustumBottomNormal +

+ + +

oosg::Vec3 _frustumLeftNormal +

+ + +

oosg::Vec3 _frustumRightNormal +

+ + +

ofloat _ratio +

+ + +

obool _viewFrustumCullingActive +

+ + +

obool _smallFeatureCullingActive +

+ + +

obool isCulled(const osg::BoundingSphere& sp) +

+ + +

obool isCulled(const osg::BoundingBox& bb) +

+ + +

o ~ViewState() +

+ +
This class has no child classes.
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/TrackballManipulator.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/TrackballManipulator.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/TrackballManipulator.html (revision 2) @@ -0,0 +1,111 @@ + + + class OSGUTIL_EXPORT osgUtil::TrackballManipulator + + + + +

class OSGUTIL_EXPORT osgUtil::TrackballManipulator: public CameraManipulator

+
+ +

Inheritance:

+ + + + + + + +
+ +
+

+

Public Methods

+[more] TrackballManipulator() +
+
+[more]virtual ~TrackballManipulator() +
+
+[more]virtual void setNode(osg::Node*) +
Attach a node to the manipulator. +
+[more]virtual osg::Node* getNode() const +
Return node if attached +
+[more]virtual void home(GUIEventAdapter& ea, GUIActionAdapter& us) +
Move the camera to the default position. +
+[more]virtual void init(GUIEventAdapter& ea, GUIActionAdapter& us) +
Start/restart the manipulator +
+[more]virtual bool update(GUIEventAdapter& ea, GUIActionAdapter& us) +
handle events, return true if handled, false otherwise +

+ +
+

Inherited from CameraManipulator:

+
+

+

Public Methods

+ovirtual void setCamera(osg::Camera*) +
+ovirtual osg::Camera* getCamera() const +

+ +

+

Protected Fields

+oosg::ref_ptr<osg::Camera> _camera +

+ +
+ + +
+

Documentation

+
+ + + +
o TrackballManipulator() +

+ + +

ovirtual ~TrackballManipulator() +

+ + +

ovirtual void setNode(osg::Node*) +
Attach a node to the manipulator. +Automatically detaches previously attached node. +setNode(NULL) detaches previously nodes. +Is ignored by manipulators which do not require a reference model. +

+ + +

ovirtual osg::Node* getNode() const +
Return node if attached +

+ + +

ovirtual void home(GUIEventAdapter& ea, GUIActionAdapter& us) +
Move the camera to the default position. +May be ignored by manipulators if home functionality is not appropriate. +

+ + +

ovirtual void init(GUIEventAdapter& ea, GUIActionAdapter& us) +
Start/restart the manipulator +

+ + +

ovirtual bool update(GUIEventAdapter& ea, GUIActionAdapter& us) +
handle events, return true if handled, false otherwise +

+ +
This class has no child classes.
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/CameraZSpindleManipulator.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/CameraZSpindleManipulator.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/CameraZSpindleManipulator.html (revision 2) @@ -0,0 +1,125 @@ + + + class OSGUTIL_EXPORT osgUtil::CameraZSpindleManipulator + + + + +

class OSGUTIL_EXPORT osgUtil::CameraZSpindleManipulator

+
+ +
+

+

Public Classes

+[more]enum MovementType +
+

+ +

+

Public Methods

+[more] CameraZSpindleManipulator() +
+
+[more] ~CameraZSpindleManipulator() +
+
+[more]void setCamera(osg::Camera *) +
+
+[more]osg::Camera* getCamera() const +
+
+[more]void initialise(int x, int y) +
initialise(int x,int y) will typically be called on a mouse down prior to a number of drag events. +
+[more]bool update(MovementType movementType, int x, int y) +
update(MovementType,int,int) will typically be called on receipt of drag events, with a view to letting the view change the view. +
+[more]void update() +
This will replicate any previous update, and is useful for animation +
+[more]MovementType getLastMovementType() const +
Returns last movementType, and is useful for updating on mouse up +

+ +
+ + +
+

Documentation

+
+ + + +
o CameraZSpindleManipulator() +

+ + +

o ~CameraZSpindleManipulator() +

+ + +

ovoid setCamera(osg::Camera *) +

+ + +

oosg::Camera* getCamera() const +

+ + +

ovoid initialise(int x, int y) +
+initialise(int x,int y) will typically be called on a +mouse down prior to a number of drag events. The parameters +tell the viewer where the mouse is at the start of the drag. +

+ + +

oenum MovementType +

+ + + +
o NONE +

+ + +

o ORBIT +

+ + +

o ZOOM +

+ + +

o PAN +

+ + + +
obool update(MovementType movementType, int x, int y) +
+update(MovementType,int,int) will typically be called on receipt of drag events, +with a view to letting the view change the view. The return value specifies whether +any change to the view was necessary as a result from the mouse event. Returns true +if any change in viewpoint is made. +

+ + +

ovoid update() +
+This will replicate any previous update, and is useful for animation +

+ + +

oMovementType getLastMovementType() const +
+Returns last movementType, and is useful for updating on mouse up +

+ +
This class has no child classes.
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/General.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/General.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/General.html (revision 2) @@ -0,0 +1,89 @@ + + + General Bits + + + + +
+
+ +o#define +OSGUTIL_CAMERAMANIPULATOR
+
+ +o#define +OSGUTIL_COMPILEGEOSETVISITOR
+
+ +o +
+
+ +o#define +OSGUTIL_DRIVEMANIPULATOR
+
+ +o#define +OSGUTIL_EXPORT_
+
+ +o#define +OSGUTIL_EXPORT(dllexport)
+
+ +o#define +OSGUTIL_EXPORT(dllimport)
+
+ +o#define +OSGUTIL_FLIGHTMANIPULATOR
+
+ +o#define +OSGUTIL_GUIACTIONADAPTER
+
+ +o#define +OSGUTIL_GUIEVENTADAPTER
+
+ +o#define +OSGUTIL_INTERSECTVISITOR
+
+ +o +
+
+ +o#define +OSGUTIL_RENDERVISITOR
+
+ +o +
+
+ +o#define +OSGUTIL_SCENEVIEW
+
+ +o +
+
+ +o#define +OSGUTIL_TRACKBALLMANIPULATOR
+
+ +o#define +OSGUTIL_VERSION
+
+ +o +
+
+Alphabetic index Hierarchy of classes

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/IntersectVisitor.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/IntersectVisitor.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/IntersectVisitor.html (revision 2) @@ -0,0 +1,281 @@ + + + class OSGUTIL_EXPORT osgUtil::IntersectVisitor + + + + +

class OSGUTIL_EXPORT osgUtil::IntersectVisitor: public osg::NodeVisitor

+
Basic visitor for ray based collisions of a scene.
+
+ +

Inheritance:

+ + + + + + + +
+ +
+

+

Public Classes

+[more]enum HitReportingMode +
Modes to control how IntersectVisitor reports hits. +

+ +

+

Public Methods

+[more] IntersectVisitor() +
+
+[more]virtual ~IntersectVisitor() +
+
+[more]void reset() +
+
+[more]void addSeg(osg::Seg* seg) +
Add a line segment to use for intersection testing during scene traversal +
+[more]void setHitReportingMode(HitReportingMode hrm) +
Set the mode of how hits should reported back from a traversal +
+[more]HitReportingMode getHitReportingMode() +
Get the mode of how hits should reported back from a traversal +
+[more]HitList& getHitList(osg::Seg* seg) +
+
+[more]int getNumHits(osg::Seg* seg) +
+
+[more]bool hits() +
+
+[more]virtual void apply(osg::Node&) +
+
+[more]virtual void apply(osg::Geode& node) +
+
+[more]virtual void apply(osg::Billboard& node) +
+
+[more]virtual void apply(osg::Group& node) +
+
+[more]virtual void apply(osg::DCS& node) +
+
+[more]virtual void apply(osg::Switch& node) +
+
+[more]virtual void apply(osg::LOD& node) +
+
+[more]virtual void apply(osg::Scene& node) +
+

+ +

+

Public

+[more]typedef std::vector<Hit> HitList +
+
+[more]typedef std::map<osg::Seg*,HitList > SegHitListMap +
+

+ +

+

Protected Fields

+[more]IntersectStateStack _intersectStateStack +
+
+[more]osg::NodePath _nodePath +
+
+[more]HitReportingMode _hitReportingMode +
+
+[more]SegHitListMap _segHitList +
+

+ +

+

Protected Methods

+[more]bool intersect(osg::GeoSet& gset) +
+
+[more]void pushMatrix(const osg::Matrix& matrix) +
+
+[more]void popMatrix() +
+
+[more]bool enterNode(osg::Node& node) +
+
+[more]void leaveNode() +
+

+ +

+

Protected

+[more]typedef std::vector<IntersectState*> IntersectStateStack +
+

+ +
+ + +
+

Documentation

+
Basic visitor for ray based collisions of a scene. +Note, still in development, current version has not +pratical functionality!
+
+ + + +
o IntersectVisitor() +

+ + +

ovirtual ~IntersectVisitor() +

+ + +

ovoid reset() +

+ + +

ovoid addSeg(osg::Seg* seg) +
Add a line segment to use for intersection testing during scene traversal +

+ + +

oenum HitReportingMode +
Modes to control how IntersectVisitor reports hits. +

+ + + +
o ONLY_NEAREST_HIT +

+ + +

o ALL_HITS +

+ + + +
ovoid setHitReportingMode(HitReportingMode hrm) +
Set the mode of how hits should reported back from a traversal +

+ + +

oHitReportingMode getHitReportingMode() +
Get the mode of how hits should reported back from a traversal +

+ + +

otypedef std::vector<Hit> HitList +

+ + +

otypedef std::map<osg::Seg*,HitList > SegHitListMap +

+ + +

oHitList& getHitList(osg::Seg* seg) +

+ + +

oint getNumHits(osg::Seg* seg) +

+ + +

obool hits() +

+ + +

ovirtual void apply(osg::Node&) +

+ + +

ovirtual void apply(osg::Geode& node) +

+ + +

ovirtual void apply(osg::Billboard& node) +

+ + +

ovirtual void apply(osg::Group& node) +

+ + +

ovirtual void apply(osg::DCS& node) +

+ + +

ovirtual void apply(osg::Switch& node) +

+ + +

ovirtual void apply(osg::LOD& node) +

+ + +

ovirtual void apply(osg::Scene& node) +

+ + +

obool intersect(osg::GeoSet& gset) +

+ + +

ovoid pushMatrix(const osg::Matrix& matrix) +

+ + +

ovoid popMatrix() +

+ + +

obool enterNode(osg::Node& node) +

+ + +

ovoid leaveNode() +

+ + +

otypedef std::vector<IntersectState*> IntersectStateStack +

+ + +

oIntersectStateStack _intersectStateStack +

+ + +

oosg::NodePath _nodePath +

+ + +

oHitReportingMode _hitReportingMode +

+ + +

oSegHitListMap _segHitList +

+ +
This class has no child classes.
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/DisplayListVisitor.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/DisplayListVisitor.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/DisplayListVisitor.html (revision 2) @@ -0,0 +1,133 @@ + + + class OSGUTIL_EXPORT osgUtil::DisplayListVisitor + + + + +

class OSGUTIL_EXPORT osgUtil::DisplayListVisitor: public osg::NodeVisitor

+
Visitor for traversing scene set each osg::GeoSet's _useDisplayList flag, or immediately compiling osg::GeoSet's OpenGL Display lists.
+
+ +

Inheritance:

+ + + + + + + +
+ +
+

+

Public Classes

+[more]enum DisplayListMode +
Operation modes of the DisplayListVisitor +

+ +

+

Public Methods

+[more] DisplayListVisitor(DisplayListMode mode=SWITCH_ON_DISPLAY_LISTS) +
Construct a CompileGeoSetsVisior to traverse all child, with set specfied display list mode. +
+[more]void setDisplayListMode(DisplayListMode mode) +
Set the operational mode of how the visitor should set up osg::GeoSet's +
+[more]DisplayListMode getDisplayListMode() const +
Get the operational mode +
+[more]virtual void apply(osg::Node& node) +
Simply traverse using standard NodeVisitor traverse method +
+[more]virtual void apply(osg::Geode& node) +
For each Geode visited set the display list usage according to the _displayListMode +

+ +

+

Protected Fields

+[more]DisplayListMode _displayListMode +
+

+ +
+ + +
+

Documentation

+
Visitor for traversing scene set each osg::GeoSet's _useDisplayList flag, or +immediately compiling osg::GeoSet's OpenGL Display lists. The mode of operation +of the vistor is controlled by setting the DisplayListMode either on visitor +constructor or via the setDisplayListMode() method. DisplayListMode options are: +_displayListMode == SWITCH_ON_AND_COMPILE_DISPLAY_LISTS cals gset->compile() on +all Geode childern. Note, the visitor must only be used within a valid +OpenGL context as compile uses OpenGL calls. +_displayListMode == SWITCH_ON_DISPLAY_LISTS sets the Geode's children with +gset->setUseDisplayList(true), this method does not directly create display list, +or uses OpenGL calls so if safe to use before a valid OpenGL context has been set up. +On the next redraw of the scene, the gset's draw methods will be called +which then will respond to their _useDisplayList being set by creating display lists +automatically. +_displayListMode == SWITCH_OFF_DISPLAY_LISTS sets the Geode's children with +gset->setUseDisplayList(false), this method does not directly create display list, +or uses OpenGL calls so if safe to use before a valid OpenGL context has been set up.
+
+ + + +
oenum DisplayListMode +
Operation modes of the DisplayListVisitor +

+ + + +
o SWITCH_ON_AND_COMPILE_DISPLAY_LISTS +

+ + +

o SWITCH_ON_DISPLAY_LISTS +

+ + +

o SWITCH_OFF_DISPLAY_LISTS +

+ + + +
o DisplayListVisitor(DisplayListMode mode=SWITCH_ON_DISPLAY_LISTS) +
Construct a CompileGeoSetsVisior to traverse all child, +with set specfied display list mode. Default mode is to +gset->setUseDisplayList(true). +

+ + +

ovoid setDisplayListMode(DisplayListMode mode) +
Set the operational mode of how the visitor should set up osg::GeoSet's +

+ + +

oDisplayListMode getDisplayListMode() const +
Get the operational mode +

+ + +

ovirtual void apply(osg::Node& node) +
Simply traverse using standard NodeVisitor traverse method +

+ + +

ovirtual void apply(osg::Geode& node) +
For each Geode visited set the display list usage according to the +_displayListMode +

+ + +

oDisplayListMode _displayListMode +

+ +
This class has no child classes.
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/GUIActionAdapter.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/GUIActionAdapter.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/GUIActionAdapter.html (revision 2) @@ -0,0 +1,51 @@ + + + class osgUtil::GUIActionAdapter + + + + +

class osgUtil::GUIActionAdapter

+
Pure virtual base class for adapting the GUI actions for use in CameraManipulators
+
+ +
+

+

Public Methods

+[more]virtual void needRedraw(bool needed=true) +
+
+[more]virtual void needContinuousUpdate(bool needed=true) +
+
+[more]virtual void needWarpPointer(int x, int y) +
+

+ +
+ + +
+

Documentation

+
Pure virtual base class for adapting the GUI actions for use in CameraManipulators
+
+ + + +
ovirtual void needRedraw(bool needed=true) +

+ + +

ovirtual void needContinuousUpdate(bool needed=true) +

+ + +

ovirtual void needWarpPointer(int x, int y) +

+ +
This class has no child classes.
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/Hit.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/Hit.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/Hit.html (revision 2) @@ -0,0 +1,163 @@ + + + class OSGUTIL_EXPORT osgUtil::Hit + + + + +

class OSGUTIL_EXPORT osgUtil::Hit: public osg::Referenced

+
+ +

Inheritance:

+ + + + + + + +
+ +
+

+

Public Fields

+[more]float _ratio +
+
+[more]osg::Seg* _originalSeg +
+
+[more]osg::Seg* _localSeg +
+
+[more]osg::NodePath _nodePath +
+
+[more]osg::Geode* _geode +
+
+[more]osg::GeoSet* _geoset +
+
+[more]osg::Matrix* _matrix +
+
+[more]VecIndexList _vecIndexList +
+
+[more]int _primitiveIndex +
+
+[more]osg::Vec3 _intersectPoint +
+
+[more]osg::Vec3 _intersectNormal +
+

+ +

+

Public Methods

+[more] Hit() +
+
+[more] Hit(const Hit& hit) +
+
+[more] ~Hit() +
+
+[more]Hit& operator = (const Hit& hit) +
+
+[more]bool operator < (const Hit& hit) const +
+

+ +

+

Public

+[more]typedef std::vector<int> VecIndexList +
+

+ +
+ + +
+

Documentation

+
+ + + +
o Hit() +

+ + +

o Hit(const Hit& hit) +

+ + +

o ~Hit() +

+ + +

oHit& operator = (const Hit& hit) +

+ + +

otypedef std::vector<int> VecIndexList +

+ + +

obool operator < (const Hit& hit) const +

+ + +

ofloat _ratio +

+ + +

oosg::Seg* _originalSeg +

+ + +

oosg::Seg* _localSeg +

+ + +

oosg::NodePath _nodePath +

+ + +

oosg::Geode* _geode +

+ + +

oosg::GeoSet* _geoset +

+ + +

oosg::Matrix* _matrix +

+ + +

oVecIndexList _vecIndexList +

+ + +

oint _primitiveIndex +

+ + +

oosg::Vec3 _intersectPoint +

+ + +

oosg::Vec3 _intersectNormal +

+ +
This class has no child classes.
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/DriveManipulator.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/DriveManipulator.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/DriveManipulator.html (revision 2) @@ -0,0 +1,121 @@ + + + class OSGUTIL_EXPORT osgUtil::DriveManipulator + + + + +

class OSGUTIL_EXPORT osgUtil::DriveManipulator: public CameraManipulator

+
+ +

Inheritance:

+ + + + + + + +
+ +
+

+

Public Methods

+[more] DriveManipulator() +
+
+[more]virtual ~DriveManipulator() +
+
+[more]virtual void setNode(osg::Node*) +
Attach a node to the manipulator. +
+[more]virtual osg::Node* getNode() const +
Return node if attached +
+[more]virtual void home(GUIEventAdapter& ea, GUIActionAdapter& us) +
Move the camera to the default position. +
+[more]virtual void init(GUIEventAdapter& ea, GUIActionAdapter& us) +
Start/restart the manipulator +
+[more]virtual bool update(GUIEventAdapter& ea, GUIActionAdapter& us) +
handle events, return true if handled, false otherwise +

+ +
+

Inherited from CameraManipulator:

+
+

+

Public Methods

+ovirtual void setCamera(osg::Camera*) +
+ovirtual osg::Camera* getCamera() const +

+ +

+

Protected Fields

+oosg::ref_ptr<osg::Camera> _camera +

+ +
+ + +
+

Documentation

+
+ + + +
o DriveManipulator() +

+ + +

ovirtual ~DriveManipulator() +

+ + +

ovirtual void setNode(osg::Node*) +
Attach a node to the manipulator. +Automatically detaches previously attached node. +setNode(NULL) detaches previously nodes. +Is ignored by manipulators which do not require a reference model. +

+ + +

ovirtual osg::Node* getNode() const +
Return node if attached +

+ + +

ovirtual void home(GUIEventAdapter& ea, GUIActionAdapter& us) +
Move the camera to the default position. +May be ignored by manipulators if home functionality is not appropriate. +

+ + +

ovirtual void init(GUIEventAdapter& ea, GUIActionAdapter& us) +
Start/restart the manipulator +

+ + +

ovirtual bool update(GUIEventAdapter& ea, GUIActionAdapter& us) +
handle events, return true if handled, false otherwise +

+ + + +
o USE_MOUSE_Y_FOR_SPEED +

+ + +

o USE_MOUSE_BUTTONS_FOR_SPEED +

+
+ +
This class has no child classes.
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/osgUtil.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/osgUtil.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/osgUtil.html (revision 2) @@ -0,0 +1,49 @@ + + + namespace osgUtil + + + + +

namespace osgUtil

+ +
+

+
class OSGUTIL_EXPORT CameraManipulator +
+
class OSGUTIL_EXPORT DisplayListVisitor +
Visitor for traversing scene set each osg::GeoSet's _useDisplayList flag, or immediately compiling osg::GeoSet's OpenGL Display lists. +
class OSGUTIL_EXPORT DriveManipulator +
+
class OSGUTIL_EXPORT FlightManipulator +
+
class GUIActionAdapter +
Pure virtual base class for adapting the GUI actions for use in CameraManipulators +
class GUIEventAdapter +
Pure virtual base class for adapting platform specfic events into generic keyboard and mouse events. +
class OSGUTIL_EXPORT IntersectState +
+
class OSGUTIL_EXPORT Hit +
+
class OSGUTIL_EXPORT IntersectVisitor +
Basic visitor for ray based collisions of a scene. +
class OSGUTIL_EXPORT ViewState +
Container class for encapsulating the viewing state in local coordinates, during the cull traversal +
class OSGUTIL_EXPORT RenderVisitor +
Basic NodeVisitor implementation for rendering a scene. +
class OSGUTIL_EXPORT SceneView +
SceneView is literaly a view of a scene, encapsulating the camera, global state, lights and the scene itself. +
class OSGUTIL_EXPORT TrackballManipulator +
+

+ + + +
+

Documentation

+
+
+

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/GUIEventAdapter.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/GUIEventAdapter.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/GUIEventAdapter.html (revision 2) @@ -0,0 +1,212 @@ + + + class osgUtil::GUIEventAdapter + + + + +

class osgUtil::GUIEventAdapter: public osg::Referenced

+
Pure virtual base class for adapting platform specfic events into generic keyboard and mouse events.
+
+ +

Inheritance:

+ + + + + + + +
+ +
+

+

Public Classes

+[more]enum MouseButtonMask +
+
+[more]enum EventType +
+

+ +

+

Public Methods

+[more] GUIEventAdapter() +
+
+[more]virtual EventType getEventType() const +
Get the EventType of the GUI event +
+[more]virtual int getKey() const +
key pressed, return -1 if inapropriate for this event. +
+[more]virtual int getButton() const +
button pressed/released, return -1 if inappropriate for this event +
+[more]virtual int getXmin() const +
window minimum x. +
+[more]virtual int getXmax() const +
window maximum x. +
+[more]virtual int getYmin() const +
window minimum y. +
+[more]virtual int getYmax() const +
window maximum y. +
+[more]virtual int getX() const +
current mouse x position +
+[more]virtual int getY() const +
current mouse y position +
+[more]virtual unsigned int getButtonMask() const +
current mouse button state +
+[more]virtual float time() const +
time in seconds of event. +

+ +

+

Protected Methods

+[more]virtual ~GUIEventAdapter() +
Force users to create on heap, so that mulitple referencing is safe +

+ +
+ + +
+

Documentation

+
Pure virtual base class for adapting platform specfic events into +generic keyboard and mouse events.
+
+ + + +
o GUIEventAdapter() +

+ + +

oenum MouseButtonMask +

+ + + +
o LEFT_BUTTON +

+ + +

o MIDDLE_BUTTON +

+ + +

o RIGHT_BUTTON +

+ + + +
oenum EventType +

+ + + +
o PUSH +

+ + +

o RELEASE +

+ + +

o DRAG +

+ + +

o MOVE +

+ + +

o KEYBOARD +

+ + +

o FRAME +

+ + +

o RESIZE +

+ + +

o NONE +

+ + + +
ovirtual EventType getEventType() const +
Get the EventType of the GUI event +

+ + +

ovirtual int getKey() const +
key pressed, return -1 if inapropriate for this event. +

+ + +

ovirtual int getButton() const +
button pressed/released, return -1 if inappropriate for this event +

+ + +

ovirtual int getXmin() const +
window minimum x. +

+ + +

ovirtual int getXmax() const +
window maximum x. +

+ + +

ovirtual int getYmin() const +
window minimum y. +

+ + +

ovirtual int getYmax() const +
window maximum y. +

+ + +

ovirtual int getX() const +
current mouse x position +

+ + +

ovirtual int getY() const +
current mouse y position +

+ + +

ovirtual unsigned int getButtonMask() const +
current mouse button state +

+ + +

ovirtual float time() const +
time in seconds of event. +

+ + +

ovirtual ~GUIEventAdapter() +
Force users to create on heap, so that mulitple referencing is safe +

+ +
This class has no child classes.
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/GUIUpdateState.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/GUIUpdateState.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/GUIUpdateState.html (revision 2) @@ -0,0 +1,45 @@ + + + class osgUtil::GUIUpdateState + + + + +

class osgUtil::GUIUpdateState

+
Class for passing back the update state from a camera maniupulator back to the caller, on the handling of an event.
+
+ +
+

+

Public Methods

+[more]virtual void needRedraw(bool needed=true) +
+
+[more]virtual void needContinuousUpdate(bool needed=true) +
+

+ +
+ + +
+

Documentation

+
Class for passing back the update state from a camera maniupulator +back to the caller, on the handling of an event.
+
+ + + +
ovirtual void needRedraw(bool needed=true) +

+ + +

ovirtual void needContinuousUpdate(bool needed=true) +

+ +
This class has no child classes.
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/Camera.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/Camera.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/Camera.html (revision 2) @@ -0,0 +1,144 @@ + + + class osgUtil::Camera + + + + +

class osgUtil::Camera: public osg::Referenced

+
+ +

Inheritance:

+ + + + + + + +
+ +
+

+

Public Methods

+[more] Camera() +
+
+[more] ~Camera() +
+
+[more]void draw() const +
Renders the OpenGL to set the view +
+[more]void setView(osg::Vec3 eyePoint, osg::Vec3 lookPoint, osg::Vec3 upVector) +
Set the View, the up vector should be orthogonal to the look vector +
+[more]const osg::Vec3& getEyePoint() const +
get the eyepoint +
+[more]const osg::Vec3& getLookPoint() const +
get the lookpoint +
+[more]const osg::Vec3& getUpVector() const +
which way is up? +
+[more]void setNearPlane(double nearPlane) +
set the near plane +
+[more]double getNearPlane() const +
get the near plane +
+[more]void setFarPlane(double farPlane) +
set the far plane +
+[more]double getFarPlane() const +
get the far plane +
+[more]void home() +
hardwired home view for now, looking straight down the Z axis at the origin, with 'up' being the y axis +

+ +
+ + +
+

Documentation

+
+ + + +
o Camera() +

+ + +

o ~Camera() +

+ + +

ovoid draw() const +
+Renders the OpenGL to set the view +

+ + +

ovoid setView(osg::Vec3 eyePoint, osg::Vec3 lookPoint, osg::Vec3 upVector) +
+Set the View, the up vector should be orthogonal to the +look vector +

+ + +

oconst osg::Vec3& getEyePoint() const +
+get the eyepoint +

+ + +

oconst osg::Vec3& getLookPoint() const +
+get the lookpoint +

+ + +

oconst osg::Vec3& getUpVector() const +
+which way is up? +

+ + +

ovoid setNearPlane(double nearPlane) +
+set the near plane +

+ + +

odouble getNearPlane() const +
+get the near plane +

+ + +

ovoid setFarPlane(double farPlane) +
+set the far plane +

+ + +

odouble getFarPlane() const +
+get the far plane +

+ + +

ovoid home() +
+hardwired home view for now, looking straight down the +Z axis at the origin, with 'up' being the y axis +

+ +
This class has no child classes.
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/SceneView.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/SceneView.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/SceneView.html (revision 2) @@ -0,0 +1,409 @@ + + + class OSGUTIL_EXPORT osgUtil::SceneView + + + + +

class OSGUTIL_EXPORT osgUtil::SceneView: public osg::Referenced

+
SceneView is literaly a view of a scene, encapsulating the camera, global state, lights and the scene itself.
+
+ +

Inheritance:

+ + + + + + + +
+ +
+

+

Public Classes

+[more]enum LightingMode +
+

+ +

+

Public Methods

+[more] SceneView() +
Constrcut a default scene view +
+[more]void setSceneData(osg::Node* node) +
Set the data which to view. +
+[more]osg::Node* getSceneData() +
Get the scene data which to view. +
+[more]void setViewport(int x, int y, int width, int height) +
Set the viewport of the scene view. +
+[more]void getViewport(int& x, int& y, int& width, int& height) +
Get the viewport of the scene view. +
+[more]void setDefaults() +
Set scene view to use default global state, light, camera and render visitor +
+[more]void setBackgroundColor(const osg::Vec4& color) +
Set the background color used in glClearColor(). +
+[more]const osg::Vec4& getBackgroundColor() const +
Get the background color +
+[more]void setGlobalState(osg::GeoState* state) +
+
+[more]osg::GeoState* getGlobalState() const +
+
+[more]void setLightingMode(LightingMode mode) +
+
+[more]LightingMode getLightingMode() const +
+
+[more]void setLight(osg::Light* light) +
+
+[more]osg::Light* getLight() const +
+
+[more]void setCamera(osg::Camera* camera) +
+
+[more]osg::Camera* getCamera() const +
+
+[more]void setRenderVisitor(osgUtil::RenderVisitor* rv) +
+
+[more]osgUtil::RenderVisitor* getRenderVisitor() const +
+
+[more]void setLODBias(float bias) +
+
+[more]float getLODBias() const +
+
+[more]void setCalcNearFar(bool calc) +
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. +
+[more]bool getCalcNearFar() +
return true if SceneView automatically caclculates near and far clipping planes for each frame +
+[more]bool projectWindowIntoObject(const osg::Vec3& window, osg::Vec3& object) const +
Calculate, via glUnProject, the object coordinates of a window point. +
+[more]bool projectWindowXYIntoObject(int x, int y, osg::Vec3& near_point, osg::Vec3& far_point) const +
Calculate, via glUnProject, the object coordinates of a window x,y when projected onto the near and far planes. +
+[more]bool projectObjectIntoWindow(const osg::Vec3& object, osg::Vec3& window) const +
Calculate, via glProject, the object coordinates of a window. +
+[more]virtual void cull() +
+
+[more]virtual void draw() +
+

+ +

+

Protected Fields

+[more]osg::ref_ptr<osg::Node> _sceneData +
+
+[more]osg::ref_ptr<osg::GeoState> _globalState +
+
+[more]osg::ref_ptr<osg::Light> _light +
+
+[more]osg::ref_ptr<osg::Camera> _camera +
+
+[more]osg::ref_ptr<osgUtil::RenderVisitor> _renderVisitor +
+
+[more]bool _need_compile +
+
+[more]bool _calc_nearfar +
+
+[more]osg::Vec4 _backgroundColor +
+
+[more]double _near_plane +
+
+[more]double _far_plane +
+
+[more]float _lodBias +
+
+[more]GLint _view[4] +
+
+[more]GLdouble _model[16] +
+
+[more]GLdouble _proj[16] +
+
+[more]LightingMode _lightingMode +
+

+ +

+

Protected Methods

+[more]virtual ~SceneView() +
+

+ +
+ + +
+

Documentation

+
+SceneView is literaly 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.
+
+ + + +
o SceneView() +
Constrcut a default scene view +

+ + +

ovoid setSceneData(osg::Node* node) +
Set the data which to view. The data will typically be +an osg::Scene but can be any osg::Node type. +

+ + +

oosg::Node* getSceneData() +
Get the scene data which to view. The data will typically be +an osg::Scene but can be any osg::Node type. +

+ + +

ovoid setViewport(int x, int y, int width, int height) +
Set the viewport of the scene view. +

+ + +

ovoid getViewport(int& x, int& y, int& width, int& height) +
Get the viewport of the scene view. +

+ + +

ovoid setDefaults() +
Set scene view to use default global state, light, camera +and render visitor +

+ + +

ovoid setBackgroundColor(const osg::Vec4& color) +
Set the background color used in glClearColor(). +Defaults to an off blue color. +

+ + +

oconst osg::Vec4& getBackgroundColor() const +
Get the background color +

+ + +

ovoid setGlobalState(osg::GeoState* state) +

+ + +

oosg::GeoState* getGlobalState() const +

+ + +

oenum LightingMode +

+ + + +
o HEADLIGHT +

+ + +

o SKY_LIGHT +

+ + +

o NO_SCENEVIEW_LIGHT +

+ + + +
ovoid setLightingMode(LightingMode mode) +

+ + +

oLightingMode getLightingMode() const +

+ + +

ovoid setLight(osg::Light* light) +

+ + +

oosg::Light* getLight() const +

+ + +

ovoid setCamera(osg::Camera* camera) +

+ + +

oosg::Camera* getCamera() const +

+ + +

ovoid setRenderVisitor(osgUtil::RenderVisitor* rv) +

+ + +

oosgUtil::RenderVisitor* getRenderVisitor() const +

+ + +

ovoid setLODBias(float bias) +

+ + +

ofloat getLODBias() const +

+ + +

ovoid setCalcNearFar(bool calc) +
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. +

+ + +

obool getCalcNearFar() +
return true if SceneView automatically caclculates near and +far clipping planes for each frame +

+ + +

obool projectWindowIntoObject(const osg::Vec3& window, osg::Vec3& object) const +
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. +

+ + +

obool projectWindowXYIntoObject(int x, int y, osg::Vec3& near_point, osg::Vec3& far_point) 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. +

+ + +

obool projectObjectIntoWindow(const osg::Vec3& object, osg::Vec3& window) 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. +

+ + +

ovirtual void cull() +

+ + +

ovirtual void draw() +

+ + +

ovirtual ~SceneView() +

+ + +

oosg::ref_ptr<osg::Node> _sceneData +

+ + +

oosg::ref_ptr<osg::GeoState> _globalState +

+ + +

oosg::ref_ptr<osg::Light> _light +

+ + +

oosg::ref_ptr<osg::Camera> _camera +

+ + +

oosg::ref_ptr<osgUtil::RenderVisitor> _renderVisitor +

+ + +

obool _need_compile +

+ + +

obool _calc_nearfar +

+ + +

oosg::Vec4 _backgroundColor +

+ + +

odouble _near_plane +

+ + +

odouble _far_plane +

+ + +

ofloat _lodBias +

+ + +

oGLint _view[4] +

+ + +

oGLdouble _model[16] +

+ + +

oGLdouble _proj[16] +

+ + +

oLightingMode _lightingMode +

+ +
This class has no child classes.
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/FlightManipulator.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/FlightManipulator.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/FlightManipulator.html (revision 2) @@ -0,0 +1,139 @@ + + + class OSGUTIL_EXPORT osgUtil::FlightManipulator + + + + +

class OSGUTIL_EXPORT osgUtil::FlightManipulator: public CameraManipulator

+
+ +

Inheritance:

+ + + + + + + +
+ +
+

+

Public Classes

+[more]enum YawControlMode +
+

+ +

+

Public Methods

+[more] FlightManipulator() +
+
+[more]virtual ~FlightManipulator() +
+
+[more]virtual void setNode(osg::Node*) +
Attach a node to the manipulator. +
+[more]virtual osg::Node* getNode() const +
Return node if attached +
+[more]virtual void home(GUIEventAdapter& ea, GUIActionAdapter& us) +
Move the camera to the default position. +
+[more]virtual void init(GUIEventAdapter& ea, GUIActionAdapter& us) +
Start/restart the manipulator +
+[more]virtual bool update(GUIEventAdapter& ea, GUIActionAdapter& us) +
handle events, return true if handled, false otherwise +
+[more]void setYawControlMode(YawControlMode ycm) +
Set the yaw control between no yaw and yawing when banked +

+ +
+

Inherited from CameraManipulator:

+
+

+

Public Methods

+ovirtual void setCamera(osg::Camera*) +
+ovirtual osg::Camera* getCamera() const +

+ +

+

Protected Fields

+oosg::ref_ptr<osg::Camera> _camera +

+ +
+ + +
+

Documentation

+
+ + + +
o FlightManipulator() +

+ + +

ovirtual ~FlightManipulator() +

+ + +

ovirtual void setNode(osg::Node*) +
Attach a node to the manipulator. +Automatically detaches previously attached node. +setNode(NULL) detaches previously nodes. +Is ignored by manipulators which do not require a reference model. +

+ + +

ovirtual osg::Node* getNode() const +
Return node if attached +

+ + +

ovirtual void home(GUIEventAdapter& ea, GUIActionAdapter& us) +
Move the camera to the default position. +May be ignored by manipulators if home functionality is not appropriate. +

+ + +

ovirtual void init(GUIEventAdapter& ea, GUIActionAdapter& us) +
Start/restart the manipulator +

+ + +

ovirtual bool update(GUIEventAdapter& ea, GUIActionAdapter& us) +
handle events, return true if handled, false otherwise +

+ + +

oenum YawControlMode +

+ + + +
o YAW_AUTOMATICALLY_WHEN_BANKED +

+ + +

o NO_AUTOMATIC_YAW +

+ + + +
ovoid setYawControlMode(YawControlMode ycm) +
Set the yaw control between no yaw and yawing when banked +

+ +
This class has no child classes.
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/HIERjava.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/HIERjava.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/HIERjava.html (revision 2) @@ -0,0 +1,83 @@ + + + Hierarchy of Classes + + + +

Hierarchy of classes

+
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ alphabetic index

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/osgUtilGetVersion.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/osgUtilGetVersion.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/osgUtilGetVersion.html (revision 2) @@ -0,0 +1,30 @@ + + + extern OSGUTIL_EXPORT const char* osgUtilGetVersion + + + + +

extern OSGUTIL_EXPORT const char* osgUtilGetVersion()

+
getVersion_osgUtil() returns the library version number.
+ + +
+

Documentation

+
+getVersion_osgUtil() returns the library version number. +Numbering conventon : osg_src-0.8-31 will return 0.8.31 from getVersion_osgUtil.

This C function can be also used to check for the existance of the OpenSceneGraph +library using autoconf and its m4 macro AC_CHECK_LIB.

Here is the code to add to your configure.in: +\verbatim +# +# Check for the OpenSceneGraph (OSG) utility library +# +AC_CHECK_LIB(osg, osgUtilGetVersion, , +[AC_MSG_ERROR(OpenSceneGraph utility library not found. See http://www.openscenegraph.org)],) +\endverbatim

+
+
+

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/GUIEventAdaptor.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/GUIEventAdaptor.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/GUIEventAdaptor.html (revision 2) @@ -0,0 +1,134 @@ + + + class osgUtil::GUIEventAdaptor + + + + +

class osgUtil::GUIEventAdaptor

+
+ +
+

+

Public Classes

+[more]enum MouseButtonMask +
+
+[more]enum EventType +
+

+ +

+

Public Fields

+[more]EventType _eventType +
event type +
+[more]int _key_or_button_pressed +
the key or button pressed in this event. +
+[more]int _x +
current mouse position. +
+[more]int _y +
+
+[more]unsigned int _buttonMask +
current mouse button state. +

+ +

+

Public Methods

+[more] GUIEventAdaptor() +
+

+ +
+ + +
+

Documentation

+
+ + + +
o GUIEventAdaptor() +

+ + +

oenum MouseButtonMask +

+ + + +
o LEFT_BUTTON +

+ + +

o MIDDLE_BUTTON +

+ + +

o RIGHT_BUTTON +

+ + + +
oenum EventType +

+ + + +
o PUSH +

+ + +

o RELEASE +

+ + +

o DRAG +

+ + +

o MOVE +

+ + +

o KEYBOARD +

+ + +

o NONE +

+ + + +
oEventType _eventType +
event type +

+ + +

oint _key_or_button_pressed +
the key or button pressed in this event. +

+ + +

oint _x +
current mouse position. +

+ + +

oint _y +

+ + +

ounsigned int _buttonMask +
current mouse button state. +

+ +
This class has no child classes.
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/IntersectState.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/IntersectState.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/IntersectState.html (revision 2) @@ -0,0 +1,124 @@ + + + class OSGUTIL_EXPORT osgUtil::IntersectState + + + + +

class OSGUTIL_EXPORT osgUtil::IntersectState: public osg::Referenced

+
+ +

Inheritance:

+ + + + + + + +
+ +
+

+

Public Fields

+[more]osg::Matrix* _matrix +
+
+[more]osg::Matrix* _inverse +
+
+[more]SegList _segList +
+
+[more]SegmentMaskStack _segmentMaskStack +
+

+ +

+

Public Methods

+[more] IntersectState() +
+
+[more]bool isCulled(const osg::BoundingSphere& bs, SegmentMask& segMaskOut) +
+
+[more]bool isCulled(const osg::BoundingBox& bb, SegmentMask& segMaskOut) +
+

+ +

+

Public

+[more]typedef std::vector< std::pair<osg::Seg*,osg::Seg*> > SegList +
+
+[more]typedef unsigned int SegmentMask +
+
+[more]typedef std::vector<SegmentMask> SegmentMaskStack +
+

+ +

+

Protected Methods

+[more] ~IntersectState() +
+

+ +
+ + +
+

Documentation

+
+ + + +
o IntersectState() +

+ + +

oosg::Matrix* _matrix +

+ + +

oosg::Matrix* _inverse +

+ + +

otypedef std::vector< std::pair<osg::Seg*,osg::Seg*> > SegList +

+ + +

oSegList _segList +

+ + +

otypedef unsigned int SegmentMask +

+ + +

otypedef std::vector<SegmentMask> SegmentMaskStack +

+ + +

oSegmentMaskStack _segmentMaskStack +

+ + +

obool isCulled(const osg::BoundingSphere& bs, SegmentMask& segMaskOut) +

+ + +

obool isCulled(const osg::BoundingBox& bb, SegmentMask& segMaskOut) +

+ + +

o ~IntersectState() +

+ +
This class has no child classes.
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/CameraManipulator.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/CameraManipulator.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/CameraManipulator.html (revision 2) @@ -0,0 +1,126 @@ + + + class OSGUTIL_EXPORT osgUtil::CameraManipulator + + + + +

class OSGUTIL_EXPORT osgUtil::CameraManipulator: public osg::Referenced

+
+ +

Inheritance:

+ + + + + + + +
+ +
+

+

Public Methods

+[more] CameraManipulator() +
+
+[more]virtual ~CameraManipulator() +
+
+[more]virtual void setCamera(osg::Camera*) +
attach a camera to the manipulator to be used for specifying view +
+[more]virtual osg::Camera* getCamera() const +
get the attached a camera +
+[more]virtual void setNode(osg::Node*) +
Attach a node to the manipulator. +
+[more]virtual osg::Node* getNode() const +
Return node if attached +
+[more]virtual void home(GUIEventAdapter&, GUIActionAdapter&) +
Move the camera to the default position. +
+[more]virtual void init(GUIEventAdapter&, GUIActionAdapter&) +
Start/restart the manipulator +
+[more]virtual bool update(GUIEventAdapter& ea, GUIActionAdapter& us) +
Handle events, return true if handled, false otherwise +

+ +

+

Protected Fields

+[more]osg::ref_ptr<osg::Camera> _camera +
+

+ +
+ + +
+

Documentation

+
+ + + +
o CameraManipulator() +

+ + +

ovirtual ~CameraManipulator() +

+ + +

ovirtual void setCamera(osg::Camera*) +
attach a camera to the manipulator to be used for specifying view +

+ + +

ovirtual osg::Camera* getCamera() const +
get the attached a camera +

+ + +

ovirtual void setNode(osg::Node*) +
Attach a node to the manipulator. +Automatically detaches previously attached node. +setNode(NULL) detaches previously nodes. +Is ignored by manipulators which do not require a reference model. +

+ + +

ovirtual osg::Node* getNode() const +
Return node if attached +

+ + +

ovirtual void home(GUIEventAdapter&, GUIActionAdapter&) +
Move the camera to the default position. +May be ignored by manipulators if home functionality is not appropriate. +

+ + +

ovirtual void init(GUIEventAdapter&, GUIActionAdapter&) +
Start/restart the manipulator +

+ + +

ovirtual bool update(GUIEventAdapter& ea, GUIActionAdapter& us) +
Handle events, return true if handled, false otherwise +

+ + +

oosg::ref_ptr<osg::Camera> _camera +

+
+
Direct child classes: +
TrackballManipulator
+FlightManipulator
+DriveManipulator
+
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/index.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/index.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osgUtil/index.html (revision 2) @@ -0,0 +1,41 @@ + + + Table of Contents + + + + +

Table of Contents

+

Namespaces

+ +

Functions

+ +

Macros

+ +Hierarchy of classes

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/MindMaps/Mission/Mission.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/MindMaps/Mission/Mission.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/MindMaps/Mission/Mission.html (revision 2) @@ -0,0 +1,16 @@ + + + + + +Mission + + + + +
+ + + + + Index: /OpenSceneGraph/tags/osg_8_34/doc/MindMaps/DesignPatterns/DesignPatterns.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/MindMaps/DesignPatterns/DesignPatterns.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/MindMaps/DesignPatterns/DesignPatterns.html (revision 2) @@ -0,0 +1,16 @@ + + + + + +Design Patterns + + + + +
+ + + + + Index: /OpenSceneGraph/tags/osg_8_34/doc/osg/BoundingBox.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osg/BoundingBox.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osg/BoundingBox.html (revision 2) @@ -0,0 +1,234 @@ + + + class SG_EXPORT osg::BoundingBox + + + + +

class SG_EXPORT osg::BoundingBox

+
General purpose axis-aligned bounding box class for enclosing objects/vertices.
+
+ +
+

+

Public Fields

+[more]Vec3 _min +
The corner with the smallest values for each coordinate of the bounding box +
+[more]Vec3 _max +
The corner with the largest values for each coordinate of the bounding box +

+ +

+

Public Methods

+[more] BoundingBox() +
construct to invalid values to represent an unset bounding box +
+[more]void init() +
initialize to invalid values to represent an unset bounding box +
+[more]bool isValid() const +
return true if the bounding box contains valid values, false if the bounding box is effectively unset/empty +
+[more]float& xMin() +
+
+[more]float xMin() const +
+
+[more]float& yMin() +
+
+[more]float yMin() const +
+
+[more]float& zMin() +
+
+[more]float zMin() const +
+
+[more]float& xMax() +
+
+[more]float xMax() const +
+
+[more]float& yMax() +
+
+[more]float yMax() const +
+
+[more]float& zMax() +
+
+[more]float zMax() const +
+
+[more]Vec3 center() const +
Calculate and return the center of the bounding box +
+[more]float radius() const +
Calculate and return the radius of the bounding box +
+[more]float radius2() const +
Calculate and return the radius squared of the bounding box. +
+[more]Vec3 corner(unsigned int pos) const +
return the corner of the bounding box. +
+[more]void expandBy(const Vec3& v) +
If the vertex is outwith the box expand to ecompass vertex. +
+[more]void expandBy(const BoundingBox& bb) +
If incomming box is outwith the box expand to ecompass incomming box. +
+[more]void expandBy(const BoundingSphere& sh) +
If incomming sphere is outwith the box expand to ecompass incomming sphere. +
+[more]bool contains(const Vec3& v) +
return true is vertex v is within the box +

+ +
+ + +
+

Documentation

+
General purpose axis-aligned bounding box class for enclosing objects/vertices. +Used to bounding the leaf objects in the scene, +i.e. osg::GeoSet's to assist in view frustum culling etc.
+
+ + + +
oVec3 _min +
The corner with the smallest values for each coordinate of the +bounding box +

+ + +

oVec3 _max +
The corner with the largest values for each coordinate of the +bounding box +

+ + +

o BoundingBox() +
construct to invalid values to represent an unset bounding box +

+ + +

ovoid init() +
initialize to invalid values to represent an unset bounding box +

+ + +

obool isValid() const +
return true if the bounding box contains valid values, +false if the bounding box is effectively unset/empty +

+ + +

ofloat& xMin() +

+ + +

ofloat xMin() const +

+ + +

ofloat& yMin() +

+ + +

ofloat yMin() const +

+ + +

ofloat& zMin() +

+ + +

ofloat zMin() const +

+ + +

ofloat& xMax() +

+ + +

ofloat xMax() const +

+ + +

ofloat& yMax() +

+ + +

ofloat yMax() const +

+ + +

ofloat& zMax() +

+ + +

ofloat zMax() const +

+ + +

oVec3 center() const +
Calculate and return the center of the bounding box +

+ + +

ofloat radius() const +
Calculate and return the radius of the bounding box +

+ + +

ofloat radius2() const +
Calculate and return the radius squared of the bounding box. +Note, radius2() is faster to calculate than radius(). +

+ + +

oVec3 corner(unsigned int pos) const +
return the corner of the bounding box. +Position (pos) is specfied by a number between 0 and 7, +the first bit toggles between x min and x max, second +bit toggles between y min and y max, third bit toggles +between z min and z max. +

+ + +

ovoid expandBy(const Vec3& v) +
If the vertex is outwith the box expand to ecompass vertex. +If this box is empty then move set this box's min max to vertex. +

+ + +

ovoid expandBy(const BoundingBox& bb) +
If incomming box is outwith the box expand to ecompass incomming box. +If this box is empty then move set this box to incomming box. +

+ + +

ovoid expandBy(const BoundingSphere& sh) +
If incomming sphere is outwith the box expand to ecompass incomming sphere. +If this box is empty then move set this box to encompass the sphere. +

+ + +

obool contains(const Vec3& v) +
return true is vertex v is within the box +

+ +
This class has no child classes.
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osg/createGeodeForImage.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osg/createGeodeForImage.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osg/createGeodeForImage.html (revision 2) @@ -0,0 +1,21 @@ + + + SG_EXPORT extern Geode* osg::createGeodeForImage + + + + +

SG_EXPORT extern Geode* osg::createGeodeForImage(Image* image)

+
Convinience function to be used by images loaders to generate a valid geode to return for readNode().
+ + +
+

Documentation

+
Convinience function to be used by images loaders to generate a valid geode to return for readNode(). +Use the images s and t values scale the dimensions of the image.
+
+
+

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osg/Geode.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osg/Geode.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osg/Geode.html (revision 2) @@ -0,0 +1,317 @@ + + + class SG_EXPORT osg::Geode + + + + +

class SG_EXPORT osg::Geode: public Node

+
Leaf Node for grouping GeoSets
+
+ +

Inheritance:

+ + + + + + + +
+ +
+

+

Public Methods

+[more] Geode() +
+
+[more]virtual Object* clone() const +
+
+[more]virtual bool isSameKindAs(Object* obj) +
+
+[more]virtual const char* className() const +
+
+[more]virtual void accept(NodeVisitor& nv) +
+
+[more]virtual bool addGeoSet( GeoSet *gset ) +
Add GeoSet to Geode. +
+[more]virtual bool removeGeoSet( GeoSet *gset ) +
Remove GeoSet from Geode. +
+[more]virtual bool replaceGeoSet( GeoSet *origGset, GeoSet *newGset ) +
Replace specified GeoSet with another GeoSet. +
+[more]int getNumGeosets( void ) const +
return the number of geoset's +
+[more]GeoSet* getGeoSet( int i ) +
return geoset at position i +
+[more]bool containsGeoSet( GeoSet* gset) +
return true is geoset is contained within Geode +
+[more]GeoSetList::iterator findGeoSet( GeoSet* gset) +
return the iterator postion for specified GeoSet. +
+[more]void compileGeoSets( void ) +
complile OpenGL Display List for each geoset +

+ +

+

Public

+[more]typedef std::vector< ref_ptr<GeoSet> > GeoSetList +
+

+ +

+

Protected Fields

+[more]GeoSetList _geosets +
+

+ +

+

Protected Methods

+[more]virtual ~Geode() +
+
+[more]virtual bool readLocalData(Input& fr) +
+
+[more]virtual bool writeLocalData(Output& fw) +
+
+[more]virtual bool computeBound( void ) +
+

+ +
+

Inherited from Node:

+
+

+

Public Methods

+oNode* cloneNode() const +
+ovirtual void ascend(NodeVisitor& nv) +
+ovirtual void traverse(NodeVisitor& ) +
+ovoid setName( const std::string& name ) +
+ovoid setName( const char* name ) +
+oconst std::string& getName( void ) +
+oconst ParentList& getParents() const +
+oGroup* getParent(int i) const +
+oint getNumParents() const +
+ovoid setUserData(void* data, MemoryAdapter* ma=0L) +
+ovoid* getUserData() const +
+oMemoryAdapter* getMemoryAdapter() const +
+ovoid setNodeMask(NodeMask nm) +
+oNodeMask getNodeMask() +
+oconst DescriptionList& getDescriptions() const +
+oDescriptionList& getDescriptions() +
+oconst std::string& getDescription(int i) const +
+ostd::string& getDescription(int i) +
+oint getNumDescriptions() const +
+ovoid addDescription(const std::string& desc) +
+oconst BoundingSphere& getBound() +
+ovoid dirtyBound() +

+ +

+

Public

+otypedef std::vector<Group*> ParentList +
+otypedef unsigned int NodeMask +
+otypedef std::vector<std::string> DescriptionList +

+ +

+

Protected Fields

+oBoundingSphere _bsphere +
+obool _bsphere_computed +
+ostd::string _name +
+oParentList _parents +
+ofriend Group +
+ovoid* _userData +
+oref_ptr<MemoryAdapter> _memoryAdapter +
+oNodeMask _nodeMask +
+oDescriptionList _descriptions +

+ +
+

Inherited from Object:

+
+

+

Public Methods

+ovirtual Object* readClone(Input& fr) +
+ovirtual bool write(Output& fw) +

+ +
+

Inherited from Referenced:

+
+

+

Public Methods

+oReferenced& operator = (Referenced&) +
+ovoid ref() +
+ovoid unref() +
+oint referenceCount() +

+ +

+

Protected Fields

+oint _refCount +

+ +
+ + +
+

Documentation

+
Leaf Node for grouping GeoSets
+
+ + + +
otypedef std::vector< ref_ptr<GeoSet> > GeoSetList +

+ + +

o Geode() +

+ + +

ovirtual Object* clone() const +

+ + +

ovirtual bool isSameKindAs(Object* obj) +

+ + +

ovirtual const char* className() const +

+ + +

ovirtual void accept(NodeVisitor& nv) +

+ + +

ovirtual bool addGeoSet( GeoSet *gset ) +
Add GeoSet to Geode. +If gset is not NULL and is not contained in Geode then increment its +reference count, add it to the geosets list and dirty the bounding +sphere to force it to recompute on next getBound() and return true for success. +Otherwise return false. +

+ + +

ovirtual bool removeGeoSet( GeoSet *gset ) +
Remove GeoSet from Geode. +If gset is contained in Geode then remove it from the geoset +list and decrement its reference count, and dirty the +bounding sphere to force it to recompute on next getBound() and +return true for success. If gset is not found then return false +and do not change the reference count of gset. +

+ + +

ovirtual bool replaceGeoSet( GeoSet *origGset, GeoSet *newGset ) +
Replace specified GeoSet with another GeoSet. +Decrement the reference count origGSet and increments the +reference count of newGset, and dirty the bounding sphere +to force it to recompute on next getBound() and returns true. +If origGeoSet is not found then return false and do not +add newGset. If newGset is NULL then return false and do +not remove origGset. +

+ + +

oint getNumGeosets( void ) const +
return the number of geoset's +

+ + +

oGeoSet* getGeoSet( int i ) +
return geoset at position i +

+ + +

obool containsGeoSet( GeoSet* gset) +
return true is geoset is contained within Geode +

+ + +

oGeoSetList::iterator findGeoSet( GeoSet* gset) +
return the iterator postion for specified GeoSet. +return _geoset.end() if gset not is contained in Geode. +

+ + +

ovoid compileGeoSets( void ) +
complile OpenGL Display List for each geoset +

+ + +

ovirtual ~Geode() +

+ + +

ovirtual bool readLocalData(Input& fr) +

+ + +

ovirtual bool writeLocalData(Output& fw) +

+ + +

ovirtual bool computeBound( void ) +

+ + +

oGeoSetList _geosets +

+
+
Direct child classes: +
Billboard
+
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osg/Field.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osg/Field.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osg/Field.html (revision 2) @@ -0,0 +1,392 @@ + + + class SG_EXPORT osg::Field + + + + +

class SG_EXPORT osg::Field

+
+ +
+

+

Public Classes

+[more]enum +
+
+[more]enum FieldType +
+

+ +

+

Public Methods

+[more] Field() +
+
+[more] Field(const Field& field) +
+
+[more]virtual ~Field() +
+
+[more]virtual Field& operator = (const Field& ic) +
+
+[more]void reset() +
+
+[more]void addChar(char c) +
+
+[more]int getNoCharacters() const +
+
+[more]void setWithinQuotes(bool withinQuotes=true) +
+
+[more]bool getWithinQuotes() +
+
+[more]void setNoNestedBrackets(int no) +
+
+[more]int getNoNestedBrackets() +
+
+[more]FieldType getFieldType() const +
+
+[more]bool isValid() const +
+
+[more]bool isOpenBracket() const +
+
+[more]bool isCloseBracket() const +
+
+[more]bool isWord() const +
+
+[more]bool matchWord(const char* str) const +
+
+[more]bool matchWord(const char* str, int noCharacters) const +
+
+[more]bool isString() const +
+
+[more]bool matchString(const char* str) const +
+
+[more]bool matchString(const char* str, int noCharacters) const +
+
+[more]bool isQuotedString() const +
+
+[more]const char* getStr() const +
+
+[more]char* takeStr() +
+
+[more]bool isInt() const +
+
+[more]bool matchInt(int i) const +
+
+[more]bool getInt(int& i) const +
+
+[more]bool isFloat() const +
+
+[more]bool matchFloat(float f) const +
+
+[more]bool getFloat(float& f) const +
+
+[more]bool isDouble() const +
+
+[more]bool matchDouble(double f) const +
+
+[more]bool getDouble(double& d) const +
+
+[more]static FieldType calculateFieldType(const char* str, bool withinQuotes=false) +
+

+ +

+

Protected Fields

+[more]int _fieldCacheCapacity +
+
+[more]int _fieldCacheSize +
+
+[more]char* _fieldCache +
+
+[more]mutable FieldType _fieldType +
+
+[more]bool _withinQuotes +
+
+[more]int _noNestedBrackets +
+

+ +

+

Protected Methods

+[more]void _init() +
+
+[more]void _free() +
+
+[more]void _copy(const Field& ic) +
+

+ +
+ + +
+

Documentation

+
+ + + +
oenum +

+ + + +
o MIN_CACHE_SIZE +

+ + + +
o Field() +

+ + +

o Field(const Field& field) +

+ + +

ovirtual ~Field() +

+ + +

ovirtual Field& operator = (const Field& ic) +

+ + +

ovoid reset() +

+ + +

ovoid addChar(char c) +

+ + +

oint getNoCharacters() const +

+ + +

ovoid setWithinQuotes(bool withinQuotes=true) +

+ + +

obool getWithinQuotes() +

+ + +

ovoid setNoNestedBrackets(int no) +

+ + +

oint getNoNestedBrackets() +

+ + +

oenum FieldType +

+ + + +
o OPEN_BRACKET +

+ + +

o CLOSE_BRACKET +

+ + +

o STRING +

+ + +

o WORD +

+ + +

o REAL +

+ + +

o INTEGER +

+ + +

o BLANK +

+ + +

o UNINTIALISED +

+ + + +
oFieldType getFieldType() const +

+ + +

obool isValid() const +

+ + +

obool isOpenBracket() const +

+ + +

obool isCloseBracket() const +

+ + +

obool isWord() const +

+ + +

obool matchWord(const char* str) const +

+ + +

obool matchWord(const char* str, int noCharacters) const +

+ + +

obool isString() const +

+ + +

obool matchString(const char* str) const +

+ + +

obool matchString(const char* str, int noCharacters) const +

+ + +

obool isQuotedString() const +

+ + +

oconst char* getStr() const +

+ + +

ochar* takeStr() +

+ + +

obool isInt() const +

+ + +

obool matchInt(int i) const +

+ + +

obool getInt(int& i) const +

+ + +

obool isFloat() const +

+ + +

obool matchFloat(float f) const +

+ + +

obool getFloat(float& f) const +

+ + +

obool isDouble() const +

+ + +

obool matchDouble(double f) const +

+ + +

obool getDouble(double& d) const +

+ + +

ostatic FieldType calculateFieldType(const char* str, bool withinQuotes=false) +

+ + +

ovoid _init() +

+ + +

ovoid _free() +

+ + +

ovoid _copy(const Field& ic) +

+ + +

oint _fieldCacheCapacity +

+ + +

oint _fieldCacheSize +

+ + +

ochar* _fieldCache +

+ + +

omutable FieldType _fieldType +

+ + +

obool _withinQuotes +

+ + +

oint _noNestedBrackets +

+ +
This class has no child classes.
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osg/GeoSet.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osg/GeoSet.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osg/GeoSet.html (revision 2) @@ -0,0 +1,713 @@ + + + class SG_EXPORT osg::GeoSet + + + + +

class SG_EXPORT osg::GeoSet: public Object

+
Encapsulates OpenGL drawing primitives, geometry and optional binding of normal, color and texture coordinates.
+
+ +

Inheritance:

+ + + + + + + +
+ +
+

+

Public Classes

+[more]enum PrimitiveType +
+
+[more]enum BindingType +
+
+[more]enum InterleaveArrayType +
+

+ +

+

Public Methods

+[more] GeoSet() +
+
+[more]static GeoSet* instance() +
+
+[more]virtual Object* clone() const +
+
+[more]virtual bool isSameKindAs(Object* obj) +
+
+[more]virtual const char* className() const +
+
+[more]void setNumPrims( int n ) +
+
+[more]int getNumPrims( void ) +
+
+[more]void setPrimType( PrimitiveType type ) +
+
+[more]PrimitiveType getPrimType( void ) +
+
+[more]void setPrimLengths( int *lens ) +
+
+[more]int* getPrimLengths( void ) +
+
+[more]void computeNumVerts() +
+
+[more]int getNumCoords() +
get the number of coords required by the defined primitives. +
+[more]Vec3* getCoords() +
get a pointer to Vec3 coord array. +
+[more]int getNumIndices() +
get the number of indices required by the defined primitives. +
+[more]ushort* getCIndex() +
get the coord index array. +
+[more]void setCoords( Vec3 *cp ) +
set the coords (ie the geometry) of the geoset +
+[more]void setCoords( Vec3 *cp, ushort *ci ) +
set the coords (ie the geometry) and indices of the geoset +
+[more]int getNumNormals() +
get the number of normals required by the defined primitives and normals binding +
+[more]Vec3* getNormals() +
get a pointer to Vec3 normal array. +
+[more]int getNumNIndices() +
get the number of normal indices required by the defined primitives and normals binding +
+[more]ushort* getNIndex() +
get the normal index array. +
+[more]void setNormals( Vec3 *np ) +
set the normals of the geoset +
+[more]void setNormals( Vec3 *np, ushort *ni ) +
set the normals and normal indices of the geoset +
+[more]void setNormalBinding( BindingType binding ) +
set the normals binding to the vertices/primitives/overall +
+[more]BindingType getNormalBinding() +
+
+[more]int getNumColors() +
get the number of colors required by the defined primitives and color binding +
+[more]Vec4* getColors() +
get a pointer to Vec4 color array. +
+[more]int getNumCIndices() +
get the number of colors indices required by the defined primitives and color binding +
+[more]ushort* getColIndex() +
get the color index array. +
+[more]void setColors( Vec4 *lp ) +
set the colors of the geoset +
+[more]void setColors( Vec4 *lp, ushort *li ) +
set the colors and color indices of the geoset +
+[more]void setColorBinding( BindingType binding ) +
set the color binding to the vertices/primitives/overall +
+[more]BindingType getColorBinding() +
+
+[more]int getNumTCoords() +
get the number of texture coords required by the defined primitives and textures binding +
+[more]Vec2* getTCoords() +
get a pointer to Vec4 color array. +
+[more]int getNumTIndices() +
get the number of texture coord indices required by the defined primitives and texture binding +
+[more]ushort* getTIndex() +
get the texture index array. +
+[more]void setTextureCoords( Vec2 *tc ) +
set the texture coords of the geoset +
+[more]void setTextureCoords( Vec2 *tc, ushort *ti ) +
set the texture coords and texture coord indices of the geoset +
+[more]void setTextureBinding( BindingType binding ) +
set the texture coord binding to the vertices/primitives/overall +
+[more]BindingType getTextureBinding() +
+
+[more]void setInterleavedArray( InterleaveArrayType format, float *ia ) +
+
+[more]void setInterleavedArray( InterleaveArrayType format, float *ia, ushort *iai ) +
+
+[more]void setGeoState(GeoState *state) +
+
+[more]GeoState* getGeoState() const +
+
+[more]void setUseDisplayList(bool flag) +
When set to true, force the draw method to use OpenGL Display List for rendering. +
+[more]bool getUseDisplayList() +
Return whether OpenGL display lists are being used for rendering +
+[more]void dirtyDisplayList() +
Force a recompile on next draw() of any OpenGL display list associated with this geoset +
+[more]virtual const BoundingBox& getBound() +
get bounding box of geoset. +
+[more]void draw( void ) +
draw geoset. +
+[more]virtual void drawImmediateMode() +
draw geoset directly ignoring an OpenGL display list which could be attached. +
+[more]void compile( void ) +
Immediately compile this geoset into an OpenGL Display List, set _useDisplayList to true +
+[more]bool check() +
+

+ +

+

Protected Methods

+[more] GeoSet(const GeoSet&) +
+
+[more]GeoSet& operator = (const GeoSet&) +
+
+[more]virtual ~GeoSet() +
+
+[more]bool matchBindingTypeStr(const char* str, BindingType& mode) +
+
+[more]const char* getBindingTypeStr(BindingType mode) +
+
+[more]virtual bool readLocalData(Input& fr) +
+
+[more]virtual bool writeLocalData(Output& fw) +
+

+ +
+

Inherited from Object:

+
+

+

Public Methods

+ovirtual Object* readClone(Input& fr) +
+ovirtual bool write(Output& fw) +

+ +
+

Inherited from Referenced:

+
+

+

Public Methods

+ovoid ref() +
+ovoid unref() +
+oint referenceCount() +

+ +

+

Protected Fields

+oint _refCount +

+ +
+ + +
+

Documentation

+
Encapsulates OpenGL drawing primitives, geometry and +optional binding of normal, color and texture coordinates. Used +for representing the visible objects in the scene. State attributes +for a GeoSet are maintained in GeoState which the GeoSet maintains +a referenced counted pointer to. Both GeoSet's and GeoState's can +be shared for optimal memory usage and graphics performance.
+
+ + + +
oenum PrimitiveType +

+ + + +
o NO_TYPE +

+ + +

o POINTS +

+ + +

o LINES +

+ + +

o LINE_STRIP +

+ + +

o FLAT_LINE_STRIP +

+ + +

o LINE_LOOP +

+ + +

o TRIANGLES +

+ + +

o TRIANGLE_STRIP +

+ + +

o FLAT_TRIANGLE_STRIP +

+ + +

o TRIANGLE_FAN +

+ + +

o FLAT_TRIANGLE_FAN +

+ + +

o QUADS +

+ + +

o QUAD_STRIP +

+ + +

o POLYGON +

+ + + +
oenum BindingType +

+ + + +
o BIND_OFF +

+ + +

o BIND_OVERALL +

+ + +

o BIND_PERPRIM +

+ + +

o BIND_PERVERTEX +

+ + +

o BIND_DEFAULT +

+ + + +
oenum InterleaveArrayType +

+ + + +
o IA_OFF +

+ + +

o IA_V2F +

+ + +

o IA_V3F +

+ + +

o IA_C4UB_V2F +

+ + +

o IA_C4UB_V3F +

+ + +

o IA_C3F_V3F +

+ + +

o IA_N3F_V3F +

+ + +

o IA_C4F_N3F_V3F +

+ + +

o IA_T2F_V3F +

+ + +

o IA_T4F_V4F +

+ + +

o IA_T2F_C4UB_V3F +

+ + +

o IA_T2F_C3F_V3F +

+ + +

o IA_T2F_N3F_V3F +

+ + +

o IA_T2F_C4F_N3F_V3F +

+ + +

o IA_T4F_C4F_N3F_V4F +

+ + + +
o GeoSet() +

+ + +

ostatic GeoSet* instance() +

+ + +

ovirtual Object* clone() const +

+ + +

ovirtual bool isSameKindAs(Object* obj) +

+ + +

ovirtual const char* className() const +

+ + +

ovoid setNumPrims( int n ) +

+ + +

oint getNumPrims( void ) +

+ + +

ovoid setPrimType( PrimitiveType type ) +

+ + +

oPrimitiveType getPrimType( void ) +

+ + +

ovoid setPrimLengths( int *lens ) +

+ + +

oint* getPrimLengths( void ) +

+ + +

ovoid computeNumVerts() +

+ + +

oint getNumCoords() +
get the number of coords required by the defined primitives. +

+ + +

oVec3* getCoords() +
get a pointer to Vec3 coord array. +

+ + +

oint getNumIndices() +
get the number of indices required by the defined primitives. +

+ + +

oushort* getCIndex() +
get the coord index array. +

+ + +

ovoid setCoords( Vec3 *cp ) +
set the coords (ie the geometry) of the geoset +

+ + +

ovoid setCoords( Vec3 *cp, ushort *ci ) +
set the coords (ie the geometry) and indices of the geoset +

+ + +

oint getNumNormals() +
get the number of normals required by the defined primitives and normals binding +

+ + +

oVec3* getNormals() +
get a pointer to Vec3 normal array. +

+ + +

oint getNumNIndices() +
get the number of normal indices required by the defined primitives and normals binding +

+ + +

oushort* getNIndex() +
get the normal index array. +

+ + +

ovoid setNormals( Vec3 *np ) +
set the normals of the geoset +

+ + +

ovoid setNormals( Vec3 *np, ushort *ni ) +
set the normals and normal indices of the geoset +

+ + +

ovoid setNormalBinding( BindingType binding ) +
set the normals binding to the vertices/primitives/overall +

+ + +

oBindingType getNormalBinding() +

+ + +

oint getNumColors() +
get the number of colors required by the defined primitives and color binding +

+ + +

oVec4* getColors() +
get a pointer to Vec4 color array. +

+ + +

oint getNumCIndices() +
get the number of colors indices required by the defined primitives and color binding +

+ + +

oushort* getColIndex() +
get the color index array. +

+ + +

ovoid setColors( Vec4 *lp ) +
set the colors of the geoset +

+ + +

ovoid setColors( Vec4 *lp, ushort *li ) +
set the colors and color indices of the geoset +

+ + +

ovoid setColorBinding( BindingType binding ) +
set the color binding to the vertices/primitives/overall +

+ + +

oBindingType getColorBinding() +

+ + +

oint getNumTCoords() +
get the number of texture coords required by the defined primitives and textures binding +

+ + +

oVec2* getTCoords() +
get a pointer to Vec4 color array. +

+ + +

oint getNumTIndices() +
get the number of texture coord indices required by the defined primitives and texture binding +

+ + +

oushort* getTIndex() +
get the texture index array. +

+ + +

ovoid setTextureCoords( Vec2 *tc ) +
set the texture coords of the geoset +

+ + +

ovoid setTextureCoords( Vec2 *tc, ushort *ti ) +
set the texture coords and texture coord indices of the geoset +

+ + +

ovoid setTextureBinding( BindingType binding ) +
set the texture coord binding to the vertices/primitives/overall +

+ + +

oBindingType getTextureBinding() +

+ + +

ovoid setInterleavedArray( InterleaveArrayType format, float *ia ) +

+ + +

ovoid setInterleavedArray( InterleaveArrayType format, float *ia, ushort *iai ) +

+ + +

ovoid setGeoState(GeoState *state) +

+ + +

oGeoState* getGeoState() const +

+ + +

ovoid setUseDisplayList(bool flag) +
When set to true, force the draw method to use OpenGL Display List for rendering. +If false rendering directly. If the display list has not been already +compile the next call to draw will automatically create the display list. +

+ + +

obool getUseDisplayList() +
Return whether OpenGL display lists are being used for rendering +

+ + +

ovoid dirtyDisplayList() +
Force a recompile on next draw() of any OpenGL display list associated with this geoset +

+ + +

ovirtual const BoundingBox& getBound() +
get bounding box of geoset. +Note, now made virtual to make it possible to implement user-drawn +objects albiet so what crudely, to be improved later. +

+ + +

ovoid draw( void ) +
draw geoset. +If the geoset has _useDisplayList set to true then use an OpenGL display +list, automatically compiling one if required. +Otherwise call drawImmediateMode(). +Note, draw method should not be overiden in subclasses as it +manages the optional display list. +

+ + +

ovirtual void drawImmediateMode() +
draw geoset directly ignoring an OpenGL display list which could be attached. +This is the internal draw method which does the drawing itself, +and is the method to override when deriving from GeoSet for user-drawn objects. +

+ + +

ovoid compile( void ) +
Immediately compile this geoset into an OpenGL Display List, set _useDisplayList to true +

+ + +

obool check() +

+ + +

o GeoSet(const GeoSet&) +

+ + +

oGeoSet& operator = (const GeoSet&) +

+ + +

ovirtual ~GeoSet() +

+ + +

obool matchBindingTypeStr(const char* str, BindingType& mode) +

+ + +

oconst char* getBindingTypeStr(BindingType mode) +

+ + +

ovirtual bool readLocalData(Input& fr) +

+ + +

ovirtual bool writeLocalData(Output& fw) +

+ +
This class has no child classes.
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osg/HIER.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osg/HIER.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osg/HIER.html (revision 2) @@ -0,0 +1,80 @@ + + + Hierarchy of Classes + + + +

Hierarchy of Classes

+ +Alphabetic index

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osg/osg.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osg/osg.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osg/osg.html (revision 2) @@ -0,0 +1,453 @@ + + + namespace osg + + + + +

namespace osg

+ +
+

+
class SG_EXPORT AlphaFunc +
Encapsulte OpenGL glAlphaFunc +
class SG_EXPORT Billboard +
Billboard - a Geode which orientates its child osg::GeoSet's to face the eye point. +
class SG_EXPORT BoundingBox +
General purpose axis-aligned bounding box class for enclosing objects/vertices. +
class SG_EXPORT BoundingSphere +
General purpose bounding sphere class for enclosing nodes/objects/vertices. +
class SG_EXPORT Camera +
Camera class for encapsulating the view position and orientation. +
class SG_EXPORT CullFace +
Class to globally enable/disable OpenGL's polygon culling mode (GL_CULL_FACE) +
class SG_EXPORT DCS +
DCS - Dynamic Coordinate System a is group which all children are transformed by the the DCS's osg::Matrix. +
class SG_EXPORT DynamicLibrary +
DynamicLibrary - encapsulates the loading and unloading of dynamic libraries, typically used for loading ReaderWriter plug-ins +
SG_EXPORT extern bool ExtensionSupported +
return true if OpenGL "extension" is supported. +
class SG_EXPORT Field +
+
class SG_EXPORT FieldReader +
+
class SG_EXPORT FieldReaderIterator +
+
+[more]SG_EXPORT extern std::string getFilePath(const std::string& filename) +
+
+[more]SG_EXPORT extern std::string getFileExtension(const std::string& filename) +
+
+[more]SG_EXPORT extern std::string getLowerCaseFileExtension(const std::string& filename) +
+
+[more]SG_EXPORT extern std::string getSimpleFileName(const std::string& fileName) +
+
+[more]SG_EXPORT extern std::string getStrippedName(const std::string& fileName) +
+
class SG_EXPORT Fog +
Fog - encapsulates OpenGL fog state. +
class SG_EXPORT GeoSet +
Encapsulates OpenGL drawing primitives, geometry and optional binding of normal, color and texture coordinates. +
template<class T> void for_each_triangle +
Template function for iterating through a GeoSet operating on triangles with templated functor. +
class SG_EXPORT GeoState +
Encapsulates OpenGL state modes and attributes. +
class SG_EXPORT Geode +
Leaf Node for grouping GeoSets +
class SG_EXPORT Group +
General group node which maintains a list of children. +
class SG_EXPORT Image +
Image class for encapsulating the storage texture image data +
SG_EXPORT extern Geode* createGeodeForImage +
Convinience function to be used by images loaders to generate a valid geode to return for readNode(). +
SG_EXPORT extern Geode* createGeodeForImage +
Convinience function to be used by images loaders to generate a valid geode to return for readNode(). +
class SG_EXPORT Input +
Class for managing the reading of ASCII osg files +
class SG_EXPORT LOD +
LOD - Level Of Detail group node which allows switching between children depending on distance from eye point. +
class SG_EXPORT Light +
Light state class which encapsulates OpenGL glLight() functionality +
class SG_EXPORT LightSource +
Leaf Node for defining a light in the scene +
class SG_EXPORT Lighting +
Class to globally control OpenGL's lighting +
class SG_EXPORT Material +
+
class SG_EXPORT Matrix +
4x4 Matrix for storage & manipulation of transformations in scene graph. +
+[more]inline Vec3 Matrix::operator * (const Vec3& v) const +
+
+[more]inline Vec3 operator * (const Vec3& v, const Matrix& m) +
+
class SG_EXPORT MemoryAdapter +
Class for adapting the memory management of external data. +
class SG_EXPORT Node +
Base class for all internal nodes in the scene graph. +
typedef std::vector<Node*> NodePath +
A vector of Nodes pointers which is used to describe the path from a root node to a descendant +
class SG_EXPORT NodeVisitor +
Visitor for type safe operations on osg::Node's. +
struct NodeAcceptOp +
Convinience functor for assisting visiting of arrays of osg::Node's +
enum NotifySeverity +
+
+[more]extern NotifySeverity g_NotifyLevel +
+
+[more]extern ofstream* g_absorbStreamPtr +
+
+[more]SG_EXPORT extern void setNotifyLevel(NotifySeverity severity) +
+
+[more]SG_EXPORT extern int getNotifyLevel() +
+
+[more]inline ostream& notify(NotifySeverity severity=INFO) +
+
+[more]SG_EXPORT extern ostream& notify(NotifySeverity severity=INFO) +
+
class SG_EXPORT NotifyInit +
+
+[more]static NotifyInit niftyNotifyInit +
+
+[more]SG_EXPORT extern void Init( void ) +
+
+[more]SG_EXPORT extern void SetFilePath( const char *_path ) +
+
+[more]SG_EXPORT extern char* FindFile( const char *file ) +
+
+[more]SG_EXPORT extern char* findDSO( const char *name ) +
+
class SG_EXPORT Object +
Base class/standard interface for objects which require IO support, cloning and reference counting. +
class SG_EXPORT Output +
ofstream wrapper class for adding support for indenting. +
+[more]template<class T> bool writeArrayBlock(Output& fw, T* start, T* finish) +
+
class SG_EXPORT Point +
+
class SG_EXPORT PolygonOffset +
+
class SG_EXPORT Quat +
A quaternion class. +
template<class T> struct UnrefOp +
Convience functor for unreferencing objects +
template<class T> class ref_ptr +
Smart pointer for handling referenced counted objects +
class Referenced +
Base class from providing referencing counted objects +
+[more]SG_EXPORT extern Object* loadObjectFile(const char *name) +
+
+[more]SG_EXPORT extern Image* loadImageFile(const char *name) +
+
+[more]SG_EXPORT extern Node* loadNodeFile(const char *name) +
+
+[more]SG_EXPORT extern bool saveObjectFile(Object& object, const char *name) +
+
+[more]SG_EXPORT extern bool saveImageFile(Image& image, const char *name) +
+
+[more]SG_EXPORT extern bool saveNodeFile(Node& node, const char *name) +
+
class SG_EXPORT ReaderWriter +
pure virtual base class for reading and writing of non native formats. +
class SG_EXPORT Registry +
Registry is a singleton factory which stores the Objects types available at runtime for loading, and any Object reader or writers which are linked in at runtime for reading non-native file formats. +
template<class T> class RegisterObjectProxy +
Proxy class for automatic registration of reader/writers with the Registry +
template<class T> class RegisterReaderWriterProxy +
Proxy class for automatic registration of reader/writers with the Registry +
class SG_EXPORT Scene +
The top level group node in a scene graph. +
class SG_EXPORT Seg +
Segment class for representing a line segment +
class SG_EXPORT Sequence +
Sequence - Switch node which allows iterators between children. +
class SG_EXPORT State +
+
class SG_EXPORT Switch +
Switch - Group node which allows switching between children. +
class SG_EXPORT TexEnv +
+
class SG_EXPORT TexGen +
+
class SG_EXPORT TexMat +
+
class SG_EXPORT Texture +
Texture state class which encapsulates OpenGl texture functionality +
+[more]typedef __int64 Timer_t +
+
+[more]typedef unsigned long long Timer_t +
+
class SG_EXPORT Timer +
+
class SG_EXPORT Transparency +
+
+[more]typedef unsigned int uint +
+
+[more]typedef unsigned short ushort +
+
+[more]typedef unsigned char uchar +
+
+[more]typedef uchar ubyte +
+
+[more]#define M_E +
+
+[more]#define M_LOG2E +
+
+[more]#define M_LOG10E +
+
+[more]#define M_LN2 +
+
+[more]#define M_LN10 +
+
+[more]#define M_PI +
+
+[more]#define M_PI_2 +
+
+[more]#define M_PI_4 +
+
+[more]#define M_1_PI +
+
+[more]#define M_2_PI +
+
+[more]#define M_2_SQRTPI +
+
+[more]#define M_SQRT2 +
+
+[more]#define M_SQRT1_2 +
+
class Vec2 +
General purpose float pair, uses include representation of texture coordinates. +
class Vec3 +
General purpose float triple for use as vertices, vectors and normals. +
class Vec4 +
General purpose float quad, uses include representation of colour coordinates. +

+ + + +
+

Documentation

+
+ + + +
oSG_EXPORT extern std::string getFilePath(const std::string& filename) +

+ + +

oSG_EXPORT extern std::string getFileExtension(const std::string& filename) +

+ + +

oSG_EXPORT extern std::string getLowerCaseFileExtension(const std::string& filename) +

+ + +

oSG_EXPORT extern std::string getSimpleFileName(const std::string& fileName) +

+ + +

oSG_EXPORT extern std::string getStrippedName(const std::string& fileName) +

+ + +

oinline Vec3 Matrix::operator * (const Vec3& v) const +

+ + +

oinline Vec3 operator * (const Vec3& v, const Matrix& m) +

+ + +

oextern NotifySeverity g_NotifyLevel +

+ + +

oextern ofstream* g_absorbStreamPtr +

+ + +

oSG_EXPORT extern void setNotifyLevel(NotifySeverity severity) +

+ + +

oSG_EXPORT extern int getNotifyLevel() +

+ + +

oinline ostream& notify(NotifySeverity severity=INFO) +

+ + +

oSG_EXPORT extern ostream& notify(NotifySeverity severity=INFO) +

+ + +

ostatic NotifyInit niftyNotifyInit +

+ + +

oSG_EXPORT extern void Init( void ) +

+ + +

oSG_EXPORT extern void SetFilePath( const char *_path ) +

+ + +

oSG_EXPORT extern char* FindFile( const char *file ) +

+ + +

oSG_EXPORT extern char* findDSO( const char *name ) +

+ + +

otemplate<class T> bool writeArrayBlock(Output& fw, T* start, T* finish) +

+ + +

oSG_EXPORT extern Object* loadObjectFile(const char *name) +

+ + +

oSG_EXPORT extern Image* loadImageFile(const char *name) +

+ + +

oSG_EXPORT extern Node* loadNodeFile(const char *name) +

+ + +

oSG_EXPORT extern bool saveObjectFile(Object& object, const char *name) +

+ + +

oSG_EXPORT extern bool saveImageFile(Image& image, const char *name) +

+ + +

oSG_EXPORT extern bool saveNodeFile(Node& node, const char *name) +

+ + +

otypedef __int64 Timer_t +

+ + +

otypedef unsigned long long Timer_t +

+ + +

otypedef unsigned int uint +

+ + +

otypedef unsigned short ushort +

+ + +

otypedef unsigned char uchar +

+ + +

otypedef uchar ubyte +

+ + +

o#define M_E +

+ + +

o#define M_LOG2E +

+ + +

o#define M_LOG10E +

+ + +

o#define M_LN2 +

+ + +

o#define M_LN10 +

+ + +

o#define M_PI +

+ + +

o#define M_PI_2 +

+ + +

o#define M_PI_4 +

+ + +

o#define M_1_PI +

+ + +

o#define M_2_PI +

+ + +

o#define M_2_SQRTPI +

+ + +

o#define M_SQRT2 +

+ + +

o#define M_SQRT1_2 +

+

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osg/TexGen.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osg/TexGen.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osg/TexGen.html (revision 2) @@ -0,0 +1,202 @@ + + + class SG_EXPORT osg::TexGen + + + + +

class SG_EXPORT osg::TexGen: public Object

+
+ +

Inheritance:

+ + + + + + + +
+ +
+

+

Public Classes

+[more]enum TexGenMode +
+

+ +

+

Public Methods

+[more] TexGen( void ) +
+
+[more]static TexGen* instance() +
+
+[more]virtual Object* clone() const +
+
+[more]virtual bool isSameKindAs(Object* obj) +
+
+[more]virtual const char* className() const +
+
+[more]static void enable( void ) +
+
+[more]static void disable( void ) +
+
+[more]void apply( void ) +
+
+[more]void setMode( TexGenMode mode ) +
+

+ +

+

Protected Fields

+[more]TexGenMode _mode +
+

+ +

+

Protected Methods

+[more]virtual ~TexGen( void ) +
+
+[more]virtual bool readLocalData(Input& fr) +
+
+[more]virtual bool writeLocalData(Output& fw) +
+
+[more]bool matchModeStr(const char* str, TexGenMode& mode) +
+
+[more]const char* getModeStr(TexGenMode mode) +
+

+ +
+

Inherited from Object:

+
+

+

Public Methods

+ovirtual Object* readClone(Input& fr) +
+ovirtual bool write(Output& fw) +

+ +
+

Inherited from Referenced:

+
+

+

Public Methods

+oReferenced& operator = (Referenced&) +
+ovoid ref() +
+ovoid unref() +
+oint referenceCount() +

+ +

+

Protected Fields

+oint _refCount +

+ +
+ + +
+

Documentation

+
+ + + +
oenum TexGenMode +

+ + + +
o OBJECT_LINEAR +

+ + +

o EYE_LINEAR +

+ + +

o SPHERE_MAP +

+ + + +
o TexGen( void ) +

+ + +

ostatic TexGen* instance() +

+ + +

ovirtual Object* clone() const +

+ + +

ovirtual bool isSameKindAs(Object* obj) +

+ + +

ovirtual const char* className() const +

+ + +

ostatic void enable( void ) +

+ + +

ostatic void disable( void ) +

+ + +

ovoid apply( void ) +

+ + +

ovoid setMode( TexGenMode mode ) +

+ + +

ovirtual ~TexGen( void ) +

+ + +

ovirtual bool readLocalData(Input& fr) +

+ + +

ovirtual bool writeLocalData(Output& fw) +

+ + +

obool matchModeStr(const char* str, TexGenMode& mode) +

+ + +

oconst char* getModeStr(TexGenMode mode) +

+ + +

oTexGenMode _mode +

+ +
This class has no child classes.
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osg/PolygonOffset.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osg/PolygonOffset.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osg/PolygonOffset.html (revision 2) @@ -0,0 +1,171 @@ + + + class SG_EXPORT osg::PolygonOffset + + + + +

class SG_EXPORT osg::PolygonOffset: public Object

+
+ +

Inheritance:

+ + + + + + + +
+ +
+

+

Public Methods

+[more] PolygonOffset() +
+
+[more]static PolygonOffset* instance() +
+
+[more]virtual Object* clone() const +
+
+[more]virtual bool isSameKindAs(Object* obj) +
+
+[more]virtual const char* className() const +
+
+[more]void setOffset(float factor, float units) +
+
+[more]static void enable( void ) +
+
+[more]static void disable( void ) +
+
+[more]void apply( void ) +
+

+ +

+

Protected Fields

+[more]float _factor +
+
+[more]float _units +
+

+ +

+

Protected Methods

+[more]virtual ~PolygonOffset() +
+
+[more]virtual bool readLocalData(Input& fr) +
+
+[more]virtual bool writeLocalData(Output& fw) +
+

+ +
+

Inherited from Object:

+
+

+

Public Methods

+ovirtual Object* readClone(Input& fr) +
+ovirtual bool write(Output& fw) +

+ +
+

Inherited from Referenced:

+
+

+

Public Methods

+oReferenced& operator = (Referenced&) +
+ovoid ref() +
+ovoid unref() +
+oint referenceCount() +

+ +

+

Protected Fields

+oint _refCount +

+ +
+ + +
+

Documentation

+
+ + + +
o PolygonOffset() +

+ + +

ostatic PolygonOffset* instance() +

+ + +

ovirtual Object* clone() const +

+ + +

ovirtual bool isSameKindAs(Object* obj) +

+ + +

ovirtual const char* className() const +

+ + +

ovoid setOffset(float factor, float units) +

+ + +

ostatic void enable( void ) +

+ + +

ostatic void disable( void ) +

+ + +

ovoid apply( void ) +

+ + +

ovirtual ~PolygonOffset() +

+ + +

ovirtual bool readLocalData(Input& fr) +

+ + +

ovirtual bool writeLocalData(Output& fw) +

+ + +

ofloat _factor +

+ + +

ofloat _units +

+ +
This class has no child classes.
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osg/TexMat.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osg/TexMat.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osg/TexMat.html (revision 2) @@ -0,0 +1,193 @@ + + + class SG_EXPORT osg::TexMat + + + + +

class SG_EXPORT osg::TexMat: public Matrix

+
+ +

Inheritance:

+ + + + + + + +
+ +
+

+

Public Methods

+[more] TexMat( void ) +
+
+[more]static TexMat* instance() +
+
+[more]virtual Object* clone() const +
+
+[more]virtual bool isSameKindAs(Object* obj) +
+
+[more]virtual const char* className() const +
+
+[more]void apply( void ) +
+

+ +

+

Protected Methods

+[more]virtual ~TexMat( void ) +
+

+ +
+

Inherited from Matrix:

+
+

+

Public Fields

+ofloat _mat[4][4] +

+ +

+

Public Methods

+oMatrix& operator = (const Matrix& matrix) +
+ovoid makeIdent() +
+ovoid set(const float* m) +
+ovoid copy(const Matrix& matrix) +
+ovoid makeScale(float sx, float sy, float sz) +
+ovoid preScale( float sx, float sy, float sz, const Matrix& m ) +
+ovoid postScale( const Matrix& m, float sx, float sy, float sz ) +
+ovoid preScale( float sx, float sy, float sz ) +
+ovoid postScale( float sx, float sy, float sz ) +
+ovoid makeTrans( float tx, float ty, float tz ) +
+ovoid preTrans( float tx, float ty, float tz, const Matrix& m ) +
+ovoid postTrans( const Matrix& m, float tx, float ty, float tz ) +
+ovoid preTrans( float tx, float ty, float tz ) +
+ovoid postTrans( float tx, float ty, float tz ) +
+ovoid makeRot( float deg, float x, float y, float z ) +
+ovoid preRot( float deg, float x, float y, float z, const Matrix& m ) +
+ovoid postRot( const Matrix& m, float deg, float x, float y, float z ) +
+ovoid preRot( float deg, float x, float y, float z ) +
+ovoid postRot( float deg, float x, float y, float z ) +
+ovoid setTrans( float tx, float ty, float tz ) +
+ovoid setTrans( const Vec3& v ) +
+oVec3 getTrans() const +
+ovoid preMult(const Matrix& m) +
+ovoid postMult(const Matrix& m) +
+ovoid mult(const Matrix& lhs, const Matrix& rhs) +
+oMatrix operator * (const Matrix& m) const +
+oinline Vec3 operator * (const Vec3& v) const +
+oinline friend Vec3 operator * (const Vec3& v, const Matrix& m) +
+obool invert(const Matrix& m) +

+ +

+

Protected Methods

+ovirtual bool readLocalData(Input& fr) +
+ovirtual bool writeLocalData(Output& fw) +

+ +
+

Inherited from Object:

+
+

+

Public Methods

+ovirtual Object* readClone(Input& fr) +
+ovirtual bool write(Output& fw) +

+ +
+

Inherited from Referenced:

+
+

+

Public Methods

+ovoid ref() +
+ovoid unref() +
+oint referenceCount() +

+ +

+

Protected Fields

+oint _refCount +

+ +
+ + +
+

Documentation

+
+ + + +
o TexMat( void ) +

+ + +

ostatic TexMat* instance() +

+ + +

ovirtual Object* clone() const +

+ + +

ovirtual bool isSameKindAs(Object* obj) +

+ + +

ovirtual const char* className() const +

+ + +

ovoid apply( void ) +

+ + +

ovirtual ~TexMat( void ) +

+ +
This class has no child classes.
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osg/NodeAcceptOp.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osg/NodeAcceptOp.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osg/NodeAcceptOp.html (revision 2) @@ -0,0 +1,53 @@ + + + struct osg::NodeAcceptOp + + + + +

struct osg::NodeAcceptOp

+
Convinience functor for assisting visiting of arrays of osg::Node's
+ +
+

+
+[more]NodeVisitor& _nv +
+
+[more] NodeAcceptOp(NodeVisitor& nv) +
+
+[more]void operator () (Node* node) +
+
+[more]void operator () (ref_ptr<Node> node) +
+

+ + + +
+

Documentation

+
Convinience functor for assisting visiting of arrays of osg::Node's
+
+ + + +
oNodeVisitor& _nv +

+ + +

o NodeAcceptOp(NodeVisitor& nv) +

+ + +

ovoid operator () (Node* node) +

+ + +

ovoid operator () (ref_ptr<Node> node) +

+

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osg/Lighting.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osg/Lighting.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osg/Lighting.html (revision 2) @@ -0,0 +1,46 @@ + + + class SG_EXPORT osg::Lighting + + + + +

class SG_EXPORT osg::Lighting

+
Class to globally control OpenGL's lighting
+
+ +
+

+

Public Methods

+[more]static void enable() +
Enable lighting +
+[more]static void disable() +
Disable lighting +

+ +
+ + +
+

Documentation

+
Class to globally control OpenGL's lighting
+
+ + + +
ostatic void enable() +
Enable lighting +

+ + +

ostatic void disable() +
Disable lighting +

+ +
This class has no child classes.
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osg/Light.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osg/Light.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osg/Light.html (revision 2) @@ -0,0 +1,441 @@ + + + class SG_EXPORT osg::Light + + + + +

class SG_EXPORT osg::Light: public Object

+
Light state class which encapsulates OpenGL glLight() functionality
+
+ +

Inheritance:

+ + + + + + + +
+ +
+

+

Public Methods

+[more] Light() +
+
+[more]static Light* instance() +
return a static instance of an osg::Light, to be used as prototype for loading lights +
+[more]virtual Object* clone() const +
return a shallow copy of a node, with Object* return type +
+[more]virtual bool isSameKindAs(Object* obj) +
+
+[more]virtual const char* className() const +
return the name of the node's class type +
+[more]void on( void ) +
Turn the light on. +
+[more]void off( void ) +
Turn the light off. +
+[more]static void enable( void ) +
Enable OpenGL's Lighting mode. +
+[more]static void disable( void ) +
Disable OpenGL's Lighting mode. +
+[more]void apply( void ) +
Apply the light's state to the OpenGL state machine. +
+[more]void setAmbient( const Vec4& ambient ) +
Set the ambient component of the light. +
+[more]const Vec4& getAmbient() const +
Get the ambient component of the light. +
+[more]void setDiffuse( const Vec4& diffuse ) +
Set the diffuse component of the light. +
+[more]const Vec4& getDiffuse() const +
Get the diffuse component of the light. +
+[more]void setSpecular( const Vec4& specular ) +
Set the specular component of the light. +
+[more]const Vec4& getSpecular() const +
Get the specular component of the light. +
+[more]void setPosition( const Vec4& position ) +
Set the position of the light. +
+[more]const Vec4& getPosition() const +
Get the position of the light. +
+[more]void setDirection( const Vec3& direction ) +
Set the direction of the light. +
+[more]const Vec3& getDirection() const +
Get the direction of the light. +
+[more]void setConstantAttenuation( float constant_attenuation ) +
Set the constant attenuation of the light. +
+[more]float setConstantAttenuation() const +
Get the constant attenuation of the light. +
+[more]void setLinearAttenuation( float linear_attenuation ) +
Set the linear attenuation of the light. +
+[more]float getLinearAttenuation() const +
Get the linear attenuation of the light. +
+[more]void setQuadraticAttenuation( float quadratic_attenuation ) +
Set the quadratic attenuation of the light. +
+[more]float getQuadraticAttenuation() const +
Get the quadratic attenuation of the light. +
+[more]void setSpotExponent( float spot_exponent ) +
Set the spot exponent of the light. +
+[more]float getSpotExponent() const +
Get the spot exponent of the light. +
+[more]void setSpotCutoff( float spot_cutoff ) +
Set the spot cutoff of the light. +
+[more]float getSpotCutoff() +
Get the spot cutoff of the light. +
+[more]void captureLightState() +
Capture the lighting settings of the current OpenGL state and store them in this object +

+ +

+

Protected Fields

+[more]int _lightnum +
+
+[more]bool _on +
+
+[more]Vec4 _ambient +
+
+[more]Vec4 _diffuse +
+
+[more]Vec4 _specular +
+
+[more]Vec4 _position +
+
+[more]Vec3 _direction +
+
+[more]float _constant_attenuation +
+
+[more]float _linear_attenuation +
+
+[more]float _quadratic_attenuation +
+
+[more]float _spot_exponent +
+
+[more]float _spot_cutoff +
+
+[more]static int _currentLightNum +
+

+ +

+

Protected Methods

+[more]virtual ~Light( void ) +
+
+[more]void init( void ) +
Initialize the light's settings with some decent defaults. +

+ +
+

Inherited from Object:

+
+

+

Public Methods

+ovirtual Object* readClone(Input& fr) +
+ovirtual bool write(Output& fw) +

+ +

+

Protected Methods

+ovirtual bool readLocalData(Input&) +
+ovirtual bool writeLocalData(Output&) +

+ +
+

Inherited from Referenced:

+
+

+

Public Methods

+oReferenced& operator = (Referenced&) +
+ovoid ref() +
+ovoid unref() +
+oint referenceCount() +

+ +

+

Protected Fields

+oint _refCount +

+ +
+ + +
+

Documentation

+
Light state class which encapsulates OpenGL glLight() functionality
+
+ + + +
o Light() +

+ + +

ostatic Light* instance() +
return a static instance of an osg::Light, to be used as prototype +for loading lights +

+ + +

ovirtual Object* clone() const +
return a shallow copy of a node, with Object* return type +

+ + +

ovirtual bool isSameKindAs(Object* obj) +

+ + +

ovirtual const char* className() const +
return the name of the node's class type +

+ + +

ovoid on( void ) +
+Turn the light on. +Calling this method doesn't directly affect OpenGL's lighting mode. +

+ + +

ovoid off( void ) +
+Turn the light off. +Calling this method doesn't directly affect OpenGL's lighting mode. +

+ + +

ostatic void enable( void ) +
Enable OpenGL's Lighting mode. +

+ + +

ostatic void disable( void ) +
Disable OpenGL's Lighting mode. +

+ + +

ovoid apply( void ) +
Apply the light's state to the OpenGL state machine. +

+ + +

ovoid setAmbient( const Vec4& ambient ) +
Set the ambient component of the light. +

+ + +

oconst Vec4& getAmbient() const +
Get the ambient component of the light. +

+ + +

ovoid setDiffuse( const Vec4& diffuse ) +
Set the diffuse component of the light. +

+ + +

oconst Vec4& getDiffuse() const +
Get the diffuse component of the light. +

+ + +

ovoid setSpecular( const Vec4& specular ) +
Set the specular component of the light. +

+ + +

oconst Vec4& getSpecular() const +
Get the specular component of the light. +

+ + +

ovoid setPosition( const Vec4& position ) +
Set the position of the light. +

+ + +

oconst Vec4& getPosition() const +
Get the position of the light. +

+ + +

ovoid setDirection( const Vec3& direction ) +
Set the direction of the light. +

+ + +

oconst Vec3& getDirection() const +
Get the direction of the light. +

+ + +

ovoid setConstantAttenuation( float constant_attenuation ) +
Set the constant attenuation of the light. +

+ + +

ofloat setConstantAttenuation() const +
Get the constant attenuation of the light. +

+ + +

ovoid setLinearAttenuation( float linear_attenuation ) +
Set the linear attenuation of the light. +

+ + +

ofloat getLinearAttenuation() const +
Get the linear attenuation of the light. +

+ + +

ovoid setQuadraticAttenuation( float quadratic_attenuation ) +
Set the quadratic attenuation of the light. +

+ + +

ofloat getQuadraticAttenuation() const +
Get the quadratic attenuation of the light. +

+ + +

ovoid setSpotExponent( float spot_exponent ) +
Set the spot exponent of the light. +

+ + +

ofloat getSpotExponent() const +
Get the spot exponent of the light. +

+ + +

ovoid setSpotCutoff( float spot_cutoff ) +
Set the spot cutoff of the light. +

+ + +

ofloat getSpotCutoff() +
Get the spot cutoff of the light. +

+ + +

ovoid captureLightState() +
+Capture the lighting settings of the current OpenGL state +and store them in this object +

+ + +

ovirtual ~Light( void ) +

+ + +

ovoid init( void ) +
Initialize the light's settings with some decent defaults. +

+ + +

oint _lightnum +

+ + +

obool _on +

+ + +

oVec4 _ambient +

+ + +

oVec4 _diffuse +

+ + +

oVec4 _specular +

+ + +

oVec4 _position +

+ + +

oVec3 _direction +

+ + +

ofloat _constant_attenuation +

+ + +

ofloat _linear_attenuation +

+ + +

ofloat _quadratic_attenuation +

+ + +

ofloat _spot_exponent +

+ + +

ofloat _spot_cutoff +

+ + +

ostatic int _currentLightNum +

+ +
This class has no child classes.
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osg/Sequence.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osg/Sequence.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osg/Sequence.html (revision 2) @@ -0,0 +1,233 @@ + + + class SG_EXPORT osg::Sequence + + + + +

class SG_EXPORT osg::Sequence: public Group

+
Sequence - Switch node which allows iterators between children.
+
+ +

Inheritance:

+ + + + + + + +
+ +
+

+

Public Methods

+[more] Sequence() +
+
+[more]virtual Object* clone() const +
+
+[more]virtual bool isSameKindAs(Object* obj) +
+
+[more]virtual const char* className() const +
+
+[more]virtual void accept(NodeVisitor& nv) +
+

+ +

+

Protected Methods

+[more]virtual ~Sequence() +
+

+ +
+

Inherited from Group:

+
+

+

Public Methods

+ovirtual void traverse(NodeVisitor& nv) +
+ovirtual bool addChild( Node *child ) +
+ovirtual bool removeChild( Node *child ) +
+ovirtual bool replaceChild( Node *origChild, Node* newChild ) +
+oint getNumChildren( void ) +
+oNode* getChild( int i ) +
+obool containsNode( Node* node ) +
+oChildList::iterator findNode( Node* node ) +

+ +

+

Public

+otypedef std::vector<ref_ptr<Node> > ChildList +

+ +

+

Protected Fields

+oChildList _children +

+ +

+

Protected Methods

+ovirtual bool readLocalData(Input& fr) +
+ovirtual bool writeLocalData(Output& fw) +
+obool computeBound( void ) +

+ +
+

Inherited from Node:

+
+

+

Public Methods

+oNode* cloneNode() const +
+ovirtual void ascend(NodeVisitor& nv) +
+ovoid setName( const std::string& name ) +
+ovoid setName( const char* name ) +
+oconst std::string& getName( void ) +
+oconst ParentList& getParents() const +
+oGroup* getParent(int i) const +
+oint getNumParents() const +
+ovoid setUserData(void* data, MemoryAdapter* ma=0L) +
+ovoid* getUserData() const +
+oMemoryAdapter* getMemoryAdapter() const +
+ovoid setNodeMask(NodeMask nm) +
+oNodeMask getNodeMask() +
+oconst DescriptionList& getDescriptions() const +
+oDescriptionList& getDescriptions() +
+oconst std::string& getDescription(int i) const +
+ostd::string& getDescription(int i) +
+oint getNumDescriptions() const +
+ovoid addDescription(const std::string& desc) +
+oconst BoundingSphere& getBound() +
+ovoid dirtyBound() +

+ +

+

Public

+otypedef std::vector<Group*> ParentList +
+otypedef unsigned int NodeMask +
+otypedef std::vector<std::string> DescriptionList +

+ +

+

Protected Fields

+oBoundingSphere _bsphere +
+obool _bsphere_computed +
+ostd::string _name +
+oParentList _parents +
+ofriend Group +
+ovoid* _userData +
+oref_ptr<MemoryAdapter> _memoryAdapter +
+oNodeMask _nodeMask +
+oDescriptionList _descriptions +

+ +
+

Inherited from Object:

+
+

+

Public Methods

+ovirtual Object* readClone(Input& fr) +
+ovirtual bool write(Output& fw) +

+ +
+

Inherited from Referenced:

+
+

+

Public Methods

+oReferenced& operator = (Referenced&) +
+ovoid ref() +
+ovoid unref() +
+oint referenceCount() +

+ +

+

Protected Fields

+oint _refCount +

+ +
+ + +
+

Documentation

+
Sequence - Switch node which allows iterators between children.

Note: has not been implemented yet!

+
+ + + +
o Sequence() +

+ + +

ovirtual Object* clone() const +

+ + +

ovirtual bool isSameKindAs(Object* obj) +

+ + +

ovirtual const char* className() const +

+ + +

ovirtual void accept(NodeVisitor& nv) +

+ + +

ovirtual ~Sequence() +

+ +
This class has no child classes.
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osg/TexEnv.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osg/TexEnv.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osg/TexEnv.html (revision 2) @@ -0,0 +1,188 @@ + + + class SG_EXPORT osg::TexEnv + + + + +

class SG_EXPORT osg::TexEnv: public Object

+
+ +

Inheritance:

+ + + + + + + +
+ +
+

+

Public Classes

+[more]enum TexEnvMode +
+

+ +

+

Public Methods

+[more] TexEnv( void ) +
+
+[more]static TexEnv* instance() +
+
+[more]virtual Object* clone() const +
+
+[more]virtual bool isSameKindAs(Object* obj) +
+
+[more]virtual const char* className() const +
+
+[more]void setMode( TexEnvMode mode ) +
+
+[more]void apply( void ) +
+

+ +

+

Protected Fields

+[more]TexEnvMode _mode +
+

+ +

+

Protected Methods

+[more]virtual ~TexEnv( void ) +
+
+[more]virtual bool readLocalData(Input& fr) +
+
+[more]virtual bool writeLocalData(Output& fw) +
+
+[more]bool matchModeStr(const char* str, TexEnvMode& mode) +
+
+[more]const char* getModeStr(TexEnvMode mode) +
+

+ +
+

Inherited from Object:

+
+

+

Public Methods

+ovirtual Object* readClone(Input& fr) +
+ovirtual bool write(Output& fw) +

+ +
+

Inherited from Referenced:

+
+

+

Public Methods

+oReferenced& operator = (Referenced&) +
+ovoid ref() +
+ovoid unref() +
+oint referenceCount() +

+ +

+

Protected Fields

+oint _refCount +

+ +
+ + +
+

Documentation

+
+ + + +
oenum TexEnvMode +

+ + + +
o DECAL +

+ + +

o MODULATE +

+ + +

o BLEND +

+ + + +
o TexEnv( void ) +

+ + +

ostatic TexEnv* instance() +

+ + +

ovirtual Object* clone() const +

+ + +

ovirtual bool isSameKindAs(Object* obj) +

+ + +

ovirtual const char* className() const +

+ + +

ovoid setMode( TexEnvMode mode ) +

+ + +

ovoid apply( void ) +

+ + +

ovirtual ~TexEnv( void ) +

+ + +

ovirtual bool readLocalData(Input& fr) +

+ + +

ovirtual bool writeLocalData(Output& fw) +

+ + +

obool matchModeStr(const char* str, TexEnvMode& mode) +

+ + +

oconst char* getModeStr(TexEnvMode mode) +

+ + +

oTexEnvMode _mode +

+ +
This class has no child classes.
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osg/GeoState.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osg/GeoState.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osg/GeoState.html (revision 2) @@ -0,0 +1,501 @@ + + + class SG_EXPORT osg::GeoState + + + + +

class SG_EXPORT osg::GeoState: public Object

+
Encapsulates OpenGL state modes and attributes.
+
+ +

Inheritance:

+ + + + + + + +
+ +
+

+

Public Classes

+[more]enum AttributeType +
+
+[more]enum AttributeMode +
+

+ +

+

Public Methods

+[more] GeoState() +
+
+[more]static GeoState* instance() +
+
+[more]virtual Object* clone() const +
+
+[more]virtual bool isSameKindAs(Object* obj) +
+
+[more]const char* className() const +
+
+[more]void setGlobalDefaults() +
set all the modes to on or off so that it defines a complete state, typically used for a default global state +
+[more]void setAllToInherit() +
set all the modes to inherit, typically used to signifiy nodes which inherit all of their modes for the global state +
+[more]void setMode(AttributeType type, AttributeMode mode) +
+
+[more]AttributeMode getMode(AttributeType type) const +
+
+[more]void setAttribute(AttributeType type, Object *attribute) +
+
+[more]Object* getAttribute(AttributeType type) const +
+
+[more]bool isTransparent() +
+
+[more]void apply() +
+
+[more]void apply(GeoState* global, GeoState* prev) +
+
+[more]bool check() +
+
+[more]static AttributeMode combineMode(const AttributeMode g, const AttributeMode p, const AttributeMode c) +
+
+[more]static AttributeMode mergeMode(const AttributeMode lhs, const AttributeMode rhs) +
+

+ +

+

Protected Fields

+[more]AttributeMode _transparencing +
+
+[more]AttributeMode _face_culling +
+
+[more]AttributeMode _lighting +
+
+[more]AttributeMode _texturing +
+
+[more]AttributeMode _fogging +
+
+[more]AttributeMode _texgening +
+
+[more]AttributeMode _antialiasing +
+
+[more]AttributeMode _colortable +
+
+[more]AttributeMode _pointSmoothing +
+
+[more]AttributeMode _polygonOffsetting +
+
+[more]AttributeMode _alphaTesting +
+
+[more]ref_ptr<Texture> _texture +
+
+[more]ref_ptr<TexGen> _texgen +
+
+[more]ref_ptr<Material> _material +
+
+[more]ref_ptr<TexEnv> _texenv +
+
+[more]ref_ptr<Transparency> _transparency +
+
+[more]ref_ptr<TexMat> _texmat +
+
+[more]ref_ptr<Fog> _fog +
+
+[more]ref_ptr<Point> _point +
+
+[more]ref_ptr<PolygonOffset> _polygonOffset +
+
+[more]ref_ptr<CullFace> _cullFace +
+
+[more]ref_ptr<AlphaFunc> _alphaFunc +
+

+ +

+

Protected Methods

+[more]virtual ~GeoState() +
+
+[more] GeoState(const GeoState&) +
+
+[more]GeoState& operator = (const GeoState&) +
+
+[more]virtual bool readLocalData(Input& fr) +
+
+[more]virtual bool writeLocalData(Output& fw) +
+
+[more]bool matchModeStr(const char* str, AttributeMode& mode) +
+
+[more]const char* getModeStr(AttributeMode flag) +
+

+ +
+

Inherited from Object:

+
+

+

Public Methods

+ovirtual Object* readClone(Input& fr) +
+ovirtual bool write(Output& fw) +

+ +
+

Inherited from Referenced:

+
+

+

Public Methods

+ovoid ref() +
+ovoid unref() +
+oint referenceCount() +

+ +

+

Protected Fields

+oint _refCount +

+ +
+ + +
+

Documentation

+
+Encapsulates OpenGL state modes and attributes. +Used to specificy textures etc of osg::GeoSet's which hold references +to a single osg::GeoState. GeoState can be shared between GeoSet's +and is recommend if possible as it minimize expensive state changes +in the graphics pipeline.
+
+ + + +
oenum AttributeType +

+ + + +
o ANTIALIAS +

+ + +

o FACE_CULL +

+ + +

o FOG +

+ + +

o LIGHTING +

+ + +

o MATERIAL +

+ + +

o POINT +

+ + +

o POLYGON_OFFSET +

+ + +

o TEXENV +

+ + +

o TEXGEN +

+ + +

o TEXMAT +

+ + +

o TEXTURE +

+ + +

o TRANSPARENCY +

+ + +

o WIREFRAME +

+ + +

o ALPHAFUNC +

+ + + +
oenum AttributeMode +

+ + + +
o INHERIT +

+ + +

o OFF +

+ + +

o ON +

+ + +

o OVERRIDE_OFF +

+ + +

o OVERRIDE_ON +

+ + + +
o GeoState() +

+ + +

ostatic GeoState* instance() +

+ + +

ovirtual Object* clone() const +

+ + +

ovirtual bool isSameKindAs(Object* obj) +

+ + +

oconst char* className() const +

+ + +

ovoid setGlobalDefaults() +
set all the modes to on or off so that it defines a +complete state, typically used for a default global state +

+ + +

ovoid setAllToInherit() +
set all the modes to inherit, typically used to signifiy +nodes which inherit all of their modes for the global state +

+ + +

ovoid setMode(AttributeType type, AttributeMode mode) +

+ + +

oAttributeMode getMode(AttributeType type) const +

+ + +

ovoid setAttribute(AttributeType type, Object *attribute) +

+ + +

oObject* getAttribute(AttributeType type) const +

+ + +

obool isTransparent() +

+ + +

ovoid apply() +

+ + +

ovoid apply(GeoState* global, GeoState* prev) +

+ + +

obool check() +

+ + +

ostatic AttributeMode combineMode(const AttributeMode g, const AttributeMode p, const AttributeMode c) +

+ + +

ostatic AttributeMode mergeMode(const AttributeMode lhs, const AttributeMode rhs) +

+ + +

ovirtual ~GeoState() +

+ + +

o GeoState(const GeoState&) +

+ + +

oGeoState& operator = (const GeoState&) +

+ + +

ovirtual bool readLocalData(Input& fr) +

+ + +

ovirtual bool writeLocalData(Output& fw) +

+ + +

obool matchModeStr(const char* str, AttributeMode& mode) +

+ + +

oconst char* getModeStr(AttributeMode flag) +

+ + +

oAttributeMode _transparencing +

+ + +

oAttributeMode _face_culling +

+ + +

oAttributeMode _lighting +

+ + +

oAttributeMode _texturing +

+ + +

oAttributeMode _fogging +

+ + +

oAttributeMode _texgening +

+ + +

oAttributeMode _antialiasing +

+ + +

oAttributeMode _colortable +

+ + +

oAttributeMode _pointSmoothing +

+ + +

oAttributeMode _polygonOffsetting +

+ + +

oAttributeMode _alphaTesting +

+ + +

oref_ptr<Texture> _texture +

+ + +

oref_ptr<TexGen> _texgen +

+ + +

oref_ptr<Material> _material +

+ + +

oref_ptr<TexEnv> _texenv +

+ + +

oref_ptr<Transparency> _transparency +

+ + +

oref_ptr<TexMat> _texmat +

+ + +

oref_ptr<Fog> _fog +

+ + +

oref_ptr<Point> _point +

+ + +

oref_ptr<PolygonOffset> _polygonOffset +

+ + +

oref_ptr<CullFace> _cullFace +

+ + +

oref_ptr<AlphaFunc> _alphaFunc +

+ +
This class has no child classes.
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osg/RegisterObjectProxy.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osg/RegisterObjectProxy.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osg/RegisterObjectProxy.html (revision 2) @@ -0,0 +1,55 @@ + + + template<class T> class osg::RegisterObjectProxy + + + + +

template<class T> class osg::RegisterObjectProxy

+
Proxy class for automatic registration of reader/writers with the Registry
+
+ +
+

+

Public Methods

+[more] RegisterObjectProxy() +
+
+[more] ~RegisterObjectProxy() +
+

+ +

+

Protected Fields

+[more]T* _obj +
+

+ +
+ + +
+

Documentation

+
Proxy class for automatic registration of reader/writers with the +Registry
+
+ + + +
o RegisterObjectProxy() +

+ + +

o ~RegisterObjectProxy() +

+ + +

oT* _obj +

+ +
This class has no child classes.
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osg/CullFace.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osg/CullFace.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osg/CullFace.html (revision 2) @@ -0,0 +1,193 @@ + + + class SG_EXPORT osg::CullFace + + + + +

class SG_EXPORT osg::CullFace: public Object

+
Class to globally enable/disable OpenGL's polygon culling mode (GL_CULL_FACE)
+
+ +

Inheritance:

+ + + + + + + +
+ +
+

+

Public Classes

+[more]enum Mode +
+

+ +

+

Public Methods

+[more] CullFace() +
+
+[more]static CullFace* instance() +
+
+[more]virtual bool isSameKindAs(Object* obj) +
+
+[more]virtual Object* clone() const +
+
+[more]virtual const char* className() const +
+
+[more]void setMode(Mode mode) +
+
+[more]static void enable() +
Enable the polygon culling mode +
+[more]static void disable() +
Disable the polygon culling mode +
+[more]void apply() +
+

+ +

+

Protected Fields

+[more]Mode _mode +
+

+ +

+

Protected Methods

+[more]virtual ~CullFace() +
+
+[more]virtual bool readLocalData(Input& fr) +
+
+[more]virtual bool writeLocalData(Output& fw) +
+

+ +
+

Inherited from Object:

+
+

+

Public Methods

+ovirtual Object* readClone(Input& fr) +
+ovirtual bool write(Output& fw) +

+ +
+

Inherited from Referenced:

+
+

+

Public Methods

+oReferenced& operator = (Referenced&) +
+ovoid ref() +
+ovoid unref() +
+oint referenceCount() +

+ +

+

Protected Fields

+oint _refCount +

+ +
+ + +
+

Documentation

+
Class to globally enable/disable OpenGL's polygon culling mode +(GL_CULL_FACE)
+
+ + + +
oenum Mode +

+ + + +
o FRONT +

+ + +

o BACK +

+ + +

o FRONT_AND_BACK +

+ + + +
o CullFace() +

+ + +

ostatic CullFace* instance() +

+ + +

ovirtual bool isSameKindAs(Object* obj) +

+ + +

ovirtual Object* clone() const +

+ + +

ovirtual const char* className() const +

+ + +

ovoid setMode(Mode mode) +

+ + +

ostatic void enable() +
Enable the polygon culling mode +

+ + +

ostatic void disable() +
Disable the polygon culling mode +

+ + +

ovoid apply() +

+ + +

ovirtual ~CullFace() +

+ + +

ovirtual bool readLocalData(Input& fr) +

+ + +

ovirtual bool writeLocalData(Output& fw) +

+ + +

oMode _mode +

+ +
This class has no child classes.
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osg/LOD.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osg/LOD.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osg/LOD.html (revision 2) @@ -0,0 +1,341 @@ + + + class SG_EXPORT osg::LOD + + + + +

class SG_EXPORT osg::LOD: public Group

+
LOD - Level Of Detail group node which allows switching between children depending on distance from eye point.
+
+ +

Inheritance:

+ + + + + + + +
+ +
+

+

Public Methods

+[more] LOD() +
+
+[more]virtual Object* clone() const +
+
+[more]virtual bool isSameKindAs(Object* obj) +
+
+[more]virtual const char* className() const +
+
+[more]virtual void accept(NodeVisitor& nv) +
+
+[more]virtual void traverse(NodeVisitor& nv) +
+
+[more]void setRange(unsigned int index, float range) +
Sets the value of range list element index to range which is a floating point distance specified in world coordinates. +
+[more]float getRange(unsigned int index) +
pfLOD::getRange returns the range element index +
+[more]int getNumRanges() +
returns the number of ranges currently set +
+[more]void setCenter(const Vec3 &center) +
Sets the object-space point which defines the center of the osg::LOD. +
+[more]const Vec3& getCenter() +
return the LOD center point. +
+[more]int evaluate(const Vec3& eye_local, float bias=1.0f) +
return the child to traverse. +

+ +

+

Protected Fields

+[more]RangeList _rangeList +
+
+[more]RangeList _rangeList2 +
+
+[more]Vec3 _center +
+

+ +

+

Protected Methods

+[more]virtual ~LOD() +
+
+[more]virtual bool readLocalData(Input& fr) +
+
+[more]virtual bool writeLocalData(Output& fw) +
+

+ +

+

Protected

+[more]typedef std::vector<float> RangeList +
+

+ +
+

Inherited from Group:

+
+

+

Public Methods

+ovirtual bool addChild( Node *child ) +
+ovirtual bool removeChild( Node *child ) +
+ovirtual bool replaceChild( Node *origChild, Node* newChild ) +
+oint getNumChildren( void ) +
+oNode* getChild( int i ) +
+obool containsNode( Node* node ) +
+oChildList::iterator findNode( Node* node ) +

+ +

+

Public

+otypedef std::vector<ref_ptr<Node> > ChildList +

+ +

+

Protected Fields

+oChildList _children +

+ +

+

Protected Methods

+obool computeBound( void ) +

+ +
+

Inherited from Node:

+
+

+

Public Methods

+oNode* cloneNode() const +
+ovirtual void ascend(NodeVisitor& nv) +
+ovoid setName( const std::string& name ) +
+ovoid setName( const char* name ) +
+oconst std::string& getName( void ) +
+oconst ParentList& getParents() const +
+oGroup* getParent(int i) const +
+oint getNumParents() const +
+ovoid setUserData(void* data, MemoryAdapter* ma=0L) +
+ovoid* getUserData() const +
+oMemoryAdapter* getMemoryAdapter() const +
+ovoid setNodeMask(NodeMask nm) +
+oNodeMask getNodeMask() +
+oconst DescriptionList& getDescriptions() const +
+oDescriptionList& getDescriptions() +
+oconst std::string& getDescription(int i) const +
+ostd::string& getDescription(int i) +
+oint getNumDescriptions() const +
+ovoid addDescription(const std::string& desc) +
+oconst BoundingSphere& getBound() +
+ovoid dirtyBound() +

+ +

+

Public

+otypedef std::vector<Group*> ParentList +
+otypedef unsigned int NodeMask +
+otypedef std::vector<std::string> DescriptionList +

+ +

+

Protected Fields

+oBoundingSphere _bsphere +
+obool _bsphere_computed +
+ostd::string _name +
+oParentList _parents +
+ofriend Group +
+ovoid* _userData +
+oref_ptr<MemoryAdapter> _memoryAdapter +
+oNodeMask _nodeMask +
+oDescriptionList _descriptions +

+ +
+

Inherited from Object:

+
+

+

Public Methods

+ovirtual Object* readClone(Input& fr) +
+ovirtual bool write(Output& fw) +

+ +
+

Inherited from Referenced:

+
+

+

Public Methods

+oReferenced& operator = (Referenced&) +
+ovoid ref() +
+ovoid unref() +
+oint referenceCount() +

+ +

+

Protected Fields

+oint _refCount +

+ +
+ + +
+

Documentation

+
LOD - Level Of Detail group node which allows switching between children +depending on distance from eye point. +Typical uses are for load balancing - objects further away from +the eye point are rendered at a lower level of detail, and at times +of high stress on the graphics pipeline lower levels of detail can +also be chosen.
+
+ + + +
o LOD() +

+ + +

ovirtual Object* clone() const +

+ + +

ovirtual bool isSameKindAs(Object* obj) +

+ + +

ovirtual const char* className() const +

+ + +

ovirtual void accept(NodeVisitor& nv) +

+ + +

ovirtual void traverse(NodeVisitor& nv) +

+ + +

ovoid setRange(unsigned int index, float range) +
Sets the value of range list element index to range which +is a floating point distance specified in world coordinates. +Range list automatically expands to accomodate values beyond +the current getNumRanges(). +

+ + +

ofloat getRange(unsigned int index) +
pfLOD::getRange returns the range element index +

+ + +

oint getNumRanges() +
returns the number of ranges currently set +

+ + +

ovoid setCenter(const Vec3 &center) +
Sets the object-space point which defines the center of the osg::LOD. +center is affected by any transforms in the hierarchy above the osg::LOD. +

+ + +

oconst Vec3& getCenter() +
return the LOD center point. +

+ + +

oint evaluate(const Vec3& eye_local, float bias=1.0f) +
return the child to traverse. +Selected by the distance between the eye point in local +coordinates and the LOD center, mutliplied by the bias. +

+ + +

ovirtual ~LOD() +

+ + +

ovirtual bool readLocalData(Input& fr) +

+ + +

ovirtual bool writeLocalData(Output& fw) +

+ + +

otypedef std::vector<float> RangeList +

+ + +

oRangeList _rangeList +

+ + +

oRangeList _rangeList2 +

+ + +

oVec3 _center +

+ +
This class has no child classes.
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osg/IntersectVisitor.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osg/IntersectVisitor.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osg/IntersectVisitor.html (revision 2) @@ -0,0 +1,309 @@ + + + class SG_EXPORT osg::IntersectVisitor + + + + +

class SG_EXPORT osg::IntersectVisitor: public NodeVisitor

+
Basic visitor for ray based collisions of a scene.
+
+ +

Inheritance:

+ + + + + + + +
+ +
+

+

Public Classes

+[more]enum HitReportingMode +
Modes to control how IntersectVisitor reports hits. +

+ +

+

Public Methods

+[more] IntersectVisitor() +
+
+[more]virtual ~IntersectVisitor() +
+
+[more]void reset() +
+
+[more]void addSeg(Seg* seg) +
Add a line segment to use for intersection testing during scene traversal +
+[more]void setHitReportingMode(HitReportingMode hrm) +
Set the mode of how hits should reported back from a traversal +
+[more]HitReportingMode getHitReportingMode() +
Get the mode of how hits should reported back from a traversal +
+[more]HitList& getHitList(Seg* seg) +
+
+[more]int getNumHits(Seg* seg) +
+
+[more]bool hits() +
+
+[more]virtual void apply(Node&) +
+
+[more]virtual void apply(Geode& node) +
+
+[more]virtual void apply(Billboard& node) +
+
+[more]virtual void apply(Group& node) +
+
+[more]virtual void apply(DCS& node) +
+
+[more]virtual void apply(Switch& node) +
+
+[more]virtual void apply(LOD& node) +
+
+[more]virtual void apply(Scene& node) +
+

+ +

+

Public

+[more]typedef std::multiset<Hit> HitList +
+
+[more]typedef std::map<Seg*,HitList > SegHitListMap +
+

+ +

+

Protected Fields

+[more]IntersectStateStack _intersectStateStack +
+
+[more]NodePath _nodePath +
+
+[more]HitReportingMode _hitReportingMode +
+
+[more]SegHitListMap _segHitList +
+

+ +

+

Protected Methods

+[more]bool intersect(GeoSet& gset) +
+
+[more]void pushMatrix(const Matrix& matrix) +
+
+[more]void popMatrix() +
+
+[more]bool enterNode(Node& node) +
+
+[more]void leaveNode() +
+

+ +

+

Protected

+[more]typedef std::vector<IntersectState*> IntersectStateStack +
+

+ +
+

Inherited from NodeVisitor:

+
+

+

Public Classes

+oenum TraversalMode +

+ +

+

Public Methods

+ovoid setTraverseMode(TraversalMode mode) +
+oTraversalMode getTraverseMode() +
+ovoid setTraverseVisitor(NodeVisitor* nv) +
+oNodeVisitor* getTraverseVisitor() +
+ovoid traverse(Node& node) +

+ +

+

Protected Fields

+oNodeVisitor* _traverseVisitor +
+oTraversalMode _traverseMode +

+ +
+ + +
+

Documentation

+
Basic visitor for ray based collisions of a scene. +Note, still in development, current version has not +pratical functionality!
+
+ + + +
o IntersectVisitor() +

+ + +

ovirtual ~IntersectVisitor() +

+ + +

ovoid reset() +

+ + +

ovoid addSeg(Seg* seg) +
Add a line segment to use for intersection testing during scene traversal +

+ + +

oenum HitReportingMode +
Modes to control how IntersectVisitor reports hits. +

+ + + +
o ONLY_NEAREST_HIT +

+ + +

o ALL_HITS +

+ + + +
ovoid setHitReportingMode(HitReportingMode hrm) +
Set the mode of how hits should reported back from a traversal +

+ + +

oHitReportingMode getHitReportingMode() +
Get the mode of how hits should reported back from a traversal +

+ + +

otypedef std::multiset<Hit> HitList +

+ + +

otypedef std::map<Seg*,HitList > SegHitListMap +

+ + +

oHitList& getHitList(Seg* seg) +

+ + +

oint getNumHits(Seg* seg) +

+ + +

obool hits() +

+ + +

ovirtual void apply(Node&) +

+ + +

ovirtual void apply(Geode& node) +

+ + +

ovirtual void apply(Billboard& node) +

+ + +

ovirtual void apply(Group& node) +

+ + +

ovirtual void apply(DCS& node) +

+ + +

ovirtual void apply(Switch& node) +

+ + +

ovirtual void apply(LOD& node) +

+ + +

ovirtual void apply(Scene& node) +

+ + +

obool intersect(GeoSet& gset) +

+ + +

ovoid pushMatrix(const Matrix& matrix) +

+ + +

ovoid popMatrix() +

+ + +

obool enterNode(Node& node) +

+ + +

ovoid leaveNode() +

+ + +

otypedef std::vector<IntersectState*> IntersectStateStack +

+ + +

oIntersectStateStack _intersectStateStack +

+ + +

oNodePath _nodePath +

+ + +

oHitReportingMode _hitReportingMode +

+ + +

oSegHitListMap _segHitList +

+ +
This class has no child classes.
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osg/RP.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osg/RP.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osg/RP.html (revision 2) @@ -0,0 +1,86 @@ + + + template<class T> class osg::RP + + + + +

template<class T> class osg::RP

+
Smart pointer for handling referenced counted objects
+
+ +
+

+

Public Methods

+[more] RP(T* t=0) +
+
+[more] RP(const RP& rp) +
+
+[more] ~RP() +
+
+[more]RP& operator = (const RP& rp) +
+
+[more]T& operator*() const +
+
+[more]T* operator->() const +
+
+[more]bool operator!() const +
+
+[more]T* get() const +
+

+ +
+ + +
+

Documentation

+
Smart pointer for handling referenced counted objects
+
+ + + +
o RP(T* t=0) +

+ + +

o RP(const RP& rp) +

+ + +

o ~RP() +

+ + +

oRP& operator = (const RP& rp) +

+ + +

oT& operator*() const +

+ + +

oT* operator->() const +

+ + +

obool operator!() const +

+ + +

oT* get() const +

+ +
This class has no child classes.
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osg/createGeodeForImage.2.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osg/createGeodeForImage.2.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osg/createGeodeForImage.2.html (revision 2) @@ -0,0 +1,21 @@ + + + SG_EXPORT extern Geode* osg::createGeodeForImage + + + + +

SG_EXPORT extern Geode* osg::createGeodeForImage(Image* image, float s, float t)

+
Convinience function to be used by images loaders to generate a valid geode to return for readNode().
+ + +
+

Documentation

+
Convinience function to be used by images loaders to generate a valid geode to return for readNode(). +Use the specified s and t values scale the dimensions of the image.
+
+
+

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osg/ExtensionSupported.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osg/ExtensionSupported.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osg/ExtensionSupported.html (revision 2) @@ -0,0 +1,22 @@ + + + SG_EXPORT extern bool osg::ExtensionSupported + + + + +

SG_EXPORT extern bool osg::ExtensionSupported(const char *extension)

+
return true if OpenGL "extension" is supported.
+ + +
+

Documentation

+
return true if OpenGL "extension" is supported. +note: Must only called within a valid OpenGL context, +undefined behaviour may occur otherwise.
+
+
+

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osg/Camera.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osg/Camera.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osg/Camera.html (revision 2) @@ -0,0 +1,260 @@ + + + class SG_EXPORT osg::Camera + + + + +

class SG_EXPORT osg::Camera: public osg::Referenced

+
Camera class for encapsulating the view position and orientation.
+
+ +

Inheritance:

+ + + + + + + +
+ +
+

+

Public Methods

+[more] Camera() +
+
+[more]virtual ~Camera() +
+
+[more]void setFieldOfView(double fovy, double aspectRatio) +
Set field of view and window aspect ratio. +
+[more]void setFieldOfViewY(double fovy) +
+
+[more]double getFieldOfViewY() const +
+
+[more]void setAspectRatio(double aspectRatio) +
+
+[more]double getAspectRatio() const +
+
+[more]void home() +
hardwired home view for now, looking straight down the Z axis at the origin, with 'up' being the y axis +
+[more]void setView(Vec3 eyePoint, Vec3 lookPoint, Vec3 upVector) +
Set the View, the up vector should be orthogonal to the look vector +
+[more]const Vec3& getEyePoint() const +
get the eyepoint. +
+[more]const Vec3& getLookPoint() const +
get the lookpoint. +
+[more]const Vec3& getUpVector() const +
which way is up? +
+[more]Vec3 getSideVector() const +
calculate side vector +
+[more]Vec3 getLookVector() const +
calculate look vector +
+[more]float getFocalDistance() const +
calculate focal distance +
+[more]void setNearPlane(double nearPlane) +
set the near plane. +
+[more]double getNearPlane() const +
get the near plane. +
+[more]void setFarPlane(double farPlane) +
set the far plane. +
+[more]double getFarPlane() const +
get the far plane. +
+[more]void draw_PROJECTION() const +
Set up the OpenGL GL_PROJECTION matrix. +
+[more]void draw_MODELVIEW() const +
Set up the OpenGL GL_MODELVIEW matrix. +
+[more]void mult(const Camera& camera, const Matrix& m) +
post multiply a camera by matrix +
+[more]void mult(const Matrix& m, const Camera& camera) +
pre multiply a camera by matrix +
+[more]void ensureOrthogonalUpVector() +
+

+ +
+

Inherited from Referenced:

+
+

+

Public Methods

+oReferenced& operator = (Referenced&) +
+ovoid ref() +
+ovoid unref() +
+oint referenceCount() +

+ +

+

Protected Fields

+oint _refCount +

+ +
+ + +
+

Documentation

+
Camera class for encapsulating the view position and orientation. +This is the first implementation of osg::Camera class and +currently is a perspective camera, but in future will be +a base class from which PerpsectivCamera,FrustumCamera and OrthoCamera +will be derived.
+
+ + + +
o Camera() +

+ + +

ovirtual ~Camera() +

+ + +

ovoid setFieldOfView(double fovy, double aspectRatio) +
+Set field of view and window aspect ratio. +The parameters have the same meaning as their counterparts +in gluPerspective(fovy,aspectRatio +

+ + +

ovoid setFieldOfViewY(double fovy) +

+ + +

odouble getFieldOfViewY() const +

+ + +

ovoid setAspectRatio(double aspectRatio) +

+ + +

odouble getAspectRatio() const +

+ + +

ovoid home() +
+hardwired home view for now, looking straight down the +Z axis at the origin, with 'up' being the y axis +

+ + +

ovoid setView(Vec3 eyePoint, Vec3 lookPoint, Vec3 upVector) +
+Set the View, the up vector should be orthogonal to the +look vector +

+ + +

oconst Vec3& getEyePoint() const +
get the eyepoint. +

+ + +

oconst Vec3& getLookPoint() const +
get the lookpoint. +

+ + +

oconst Vec3& getUpVector() const +
which way is up? +

+ + +

oVec3 getSideVector() const +
calculate side vector +

+ + +

oVec3 getLookVector() const +
calculate look vector +

+ + +

ofloat getFocalDistance() const +
calculate focal distance +

+ + +

ovoid setNearPlane(double nearPlane) +
set the near plane. +

+ + +

odouble getNearPlane() const +
get the near plane. +

+ + +

ovoid setFarPlane(double farPlane) +
set the far plane. +

+ + +

odouble getFarPlane() const +
get the far plane. +

+ + +

ovoid draw_PROJECTION() const +
Set up the OpenGL GL_PROJECTION matrix. +Enters the GL_PROJECTION mode, sets up matrix, then +resets model GL_MODELVIEW, which is by OpenGL convention the default. +

+ + +

ovoid draw_MODELVIEW() const +
Set up the OpenGL GL_MODELVIEW matrix. +Enters the GL_MODELVIEW mode, sets matrix to identity +and then sets matrix up according to camera, eye point, center +point and upvector. +

+ + +

ovoid mult(const Camera& camera, const Matrix& m) +
post multiply a camera by matrix +

+ + +

ovoid mult(const Matrix& m, const Camera& camera) +
pre multiply a camera by matrix +

+ + +

ovoid ensureOrthogonalUpVector() +

+ +
This class has no child classes.
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osg/HIERjava.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osg/HIERjava.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osg/HIERjava.html (revision 2) @@ -0,0 +1,146 @@ + + + Hierarchy of Classes + + + +

Hierarchy of classes

+
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ alphabetic index

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osg/for_each_triangle.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osg/for_each_triangle.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osg/for_each_triangle.html (revision 2) @@ -0,0 +1,22 @@ + + + template<class T> void osg::for_each_triangle + + + + +

template<class T> void osg::for_each_triangle(GeoSet& gset, T& op)

+
Template function for iterating through a GeoSet operating on triangles with templated functor.
+ + +
+

Documentation

+
Template function for iterating through a GeoSet operating on triangles +with templated functor. Function automatically decomposes quads and polygons +into sub triangles which are passed onto functor.
+
+
+

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osg/ReaderWriter.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osg/ReaderWriter.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osg/ReaderWriter.html (revision 2) @@ -0,0 +1,122 @@ + + + class SG_EXPORT osg::ReaderWriter + + + + +

class SG_EXPORT osg::ReaderWriter: public Referenced

+
pure virtual base class for reading and writing of non native formats.
+
+ +

Inheritance:

+ + + + + + + +
+ +
+

+

Public Methods

+[more]virtual ~ReaderWriter() +
+
+[more]virtual const char* className() +
+
+[more]virtual bool acceptsExtension(const std::string& ) +
+
+[more]virtual Object* readObject(const std::string& ) +
+
+[more]virtual Image* readImage(const std::string& ) +
+
+[more]virtual Node* readNode(const std::string& ) +
+
+[more]virtual bool writeObject(Object& , const std::string& ) +
+
+[more]virtual bool writeImage(Image& , const std::string& ) +
+
+[more]virtual bool writeNode(Node& , const std::string& ) +
+

+ +
+

Inherited from Referenced:

+
+

+

Public Methods

+oReferenced& operator = (Referenced&) +
+ovoid ref() +
+ovoid unref() +
+oint referenceCount() +

+ +

+

Protected Fields

+oint _refCount +

+ +
+ + +
+

Documentation

+
pure virtual base class for reading and writing of non native formats.
+
+ + + +
ovirtual ~ReaderWriter() +

+ + +

ovirtual const char* className() +

+ + +

ovirtual bool acceptsExtension(const std::string& ) +

+ + +

ovirtual Object* readObject(const std::string& ) +

+ + +

ovirtual Image* readImage(const std::string& ) +

+ + +

ovirtual Node* readNode(const std::string& ) +

+ + +

ovirtual bool writeObject(Object& , const std::string& ) +

+ + +

ovirtual bool writeImage(Image& , const std::string& ) +

+ + +

ovirtual bool writeNode(Node& , const std::string& ) +

+ +
This class has no child classes.
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osg/Vec2.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osg/Vec2.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osg/Vec2.html (revision 2) @@ -0,0 +1,241 @@ + + + class osg::Vec2 + + + + +

class osg::Vec2

+
General purpose float pair, uses include representation of texture coordinates.
+
+ +
+

+

Public Fields

+[more]float _v[2] +
+

+ +

+

Public Methods

+[more] Vec2() +
+
+[more] Vec2(float x, float y) +
+
+[more]bool operator == (const Vec2& v) const +
+
+[more]inline float* ptr() +
+
+[more]inline const float* ptr() const +
+
+[more]inline void set( float x, float y ) +
+
+[more]inline float& operator [] (int i) +
+
+[more]inline float operator [] (int i) const +
+
+[more]inline float& x() +
+
+[more]inline float& y() +
+
+[more]inline float x() const +
+
+[more]inline float y() const +
+
+[more]inline float operator * (const Vec2& rhs) const +
dot product +
+[more]inline Vec2 operator * (const float& rhs) const +
multiply by scalar +
+[more]inline Vec2& operator *= (const float& rhs) +
unary multiply by scalar +
+[more]inline Vec2 operator / (const float& rhs) const +
divide by scalar +
+[more]inline Vec2& operator /= (const float& rhs) +
unary divide by scalar +
+[more]inline Vec2 operator + (const Vec2& rhs) const +
binary vector add +
+[more]inline Vec2& operator += (const Vec2& rhs) +
unary vector add. +
+[more]inline Vec2 operator - (const Vec2& rhs) const +
binary vector subract +
+[more]inline Vec2& operator -= (const Vec2& rhs) +
unary vector subract +
+[more]inline Vec2 operator - () const +
negation operator. Returns the negative of the Vec2 +
+[more]inline float length() const +
Length of the vector = sqrt( vec . vec ) +
+[more]inline float length2( void ) const +
Length squared of the vector = vec . vec +
+[more]inline float normalize() +
normalize the vector so that it has length unity returns the previous length of the vector +
+[more]inline friend ostream& operator << (ostream& output, const Vec2& vec) +
+

+ +
+ + +
+

Documentation

+
General purpose float pair, uses include representation of +texture coordinates. +No support yet added for float * Vec2 - is it necessary? +Need to define a non-member non-friend operator* etc. +BTW: Vec2 * float is okay
+
+ + + +
o Vec2() +

+ + +

o Vec2(float x, float y) +

+ + +

ofloat _v[2] +

+ + +

obool operator == (const Vec2& v) const +

+ + +

oinline float* ptr() +

+ + +

oinline const float* ptr() const +

+ + +

oinline void set( float x, float y ) +

+ + +

oinline float& operator [] (int i) +

+ + +

oinline float operator [] (int i) const +

+ + +

oinline float& x() +

+ + +

oinline float& y() +

+ + +

oinline float x() const +

+ + +

oinline float y() const +

+ + +

oinline float operator * (const Vec2& rhs) const +
dot product +

+ + +

oinline Vec2 operator * (const float& rhs) const +
multiply by scalar +

+ + +

oinline Vec2& operator *= (const float& rhs) +
unary multiply by scalar +

+ + +

oinline Vec2 operator / (const float& rhs) const +
divide by scalar +

+ + +

oinline Vec2& operator /= (const float& rhs) +
unary divide by scalar +

+ + +

oinline Vec2 operator + (const Vec2& rhs) const +
binary vector add +

+ + +

oinline Vec2& operator += (const Vec2& rhs) +
unary vector add. Slightly more efficient because no temporary +intermediate object. +

+ + +

oinline Vec2 operator - (const Vec2& rhs) const +
binary vector subract +

+ + +

oinline Vec2& operator -= (const Vec2& rhs) +
unary vector subract +

+ + +

oinline Vec2 operator - () const +
negation operator. Returns the negative of the Vec2 +

+ + +

oinline float length() const +
Length of the vector = sqrt( vec . vec ) +

+ + +

oinline float length2( void ) const +
Length squared of the vector = vec . vec +

+ + +

oinline float normalize() +
normalize the vector so that it has length unity +returns the previous length of the vector +

+ + +

oinline friend ostream& operator << (ostream& output, const Vec2& vec) +

+ +
This class has no child classes.
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osg/Texture.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osg/Texture.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osg/Texture.html (revision 2) @@ -0,0 +1,372 @@ + + + class SG_EXPORT osg::Texture + + + + +

class SG_EXPORT osg::Texture: public Object

+
Texture state class which encapsulates OpenGl texture functionality
+
+ +

Inheritance:

+ + + + + + + +
+ +
+

+

Public Classes

+[more]enum WrapParameter +
+
+[more]enum WrapMode +
+
+[more]enum FilterParameter +
+
+[more]enum FilterMode +
+

+ +

+

Public Methods

+[more] Texture() +
+
+[more]static Texture* instance() +
+
+[more]virtual Object* clone() const +
+
+[more]virtual bool isSameKindAs(Object* obj) +
+
+[more]virtual const char* className() const +
+
+[more]void setImage(Image* image) +
Set the texture image. +
+[more]Image* getImage() const +
Get the texture image. +
+[more]void setWrap(WrapParameter which, WrapMode wrap) +
Set the texture wrap mode +
+[more]WrapMode getWrap(WrapParameter which) const +
Get the texture wrap mode +
+[more]void setFilter(FilterParameter which, FilterMode filter) +
Set the texture filter mode +
+[more]FilterMode getFilter(FilterParameter which) const +
Get the texture filter mode +
+[more]static void enable( void ) +
Enable OpenGL texturing +
+[more]static void disable( void ) +
Disable OpenGL texturing +
+[more]void apply( void ) +
On first apply, create the minmapped texture and bind it, subsequent apply will simple bind to texture +

+ +

+

Protected Fields

+[more]uint _handle +
+
+[more]ref_ptr<Image> _image +
+
+[more]WrapMode _wrap_s +
+
+[more]WrapMode _wrap_t +
+
+[more]WrapMode _wrap_r +
+
+[more]FilterMode _min_filter +
+
+[more]FilterMode _mag_filter +
+

+ +

+

Protected Methods

+[more]virtual ~Texture() +
+
+[more]virtual bool readLocalData(Input& fr) +
+
+[more]virtual bool writeLocalData(Output& fw) +
+
+[more]bool matchWrapStr(const char* str, WrapMode& wrap) +
+
+[more]const char* getWrapStr(WrapMode wrap) +
+
+[more]bool matchFilterStr(const char* str, FilterMode& filter) +
+
+[more]const char* getFilterStr(FilterMode filter) +
+

+ +
+

Inherited from Object:

+
+

+

Public Methods

+ovirtual Object* readClone(Input& fr) +
+ovirtual bool write(Output& fw) +

+ +
+

Inherited from Referenced:

+
+

+

Public Methods

+oReferenced& operator = (Referenced&) +
+ovoid ref() +
+ovoid unref() +
+oint referenceCount() +

+ +

+

Protected Fields

+oint _refCount +

+ +
+ + +
+

Documentation

+
Texture state class which encapsulates OpenGl texture functionality
+
+ + + +
o Texture() +

+ + +

ostatic Texture* instance() +

+ + +

ovirtual Object* clone() const +

+ + +

ovirtual bool isSameKindAs(Object* obj) +

+ + +

ovirtual const char* className() const +

+ + +

ovoid setImage(Image* image) +
Set the texture image. +

+ + +

oImage* getImage() const +
Get the texture image. +

+ + +

oenum WrapParameter +

+ + + +
o WRAP_S +

+ + +

o WRAP_T +

+ + +

o WRAP_R +

+ + + +
oenum WrapMode +

+ + + +
o CLAMP +

+ + +

o REPEAT +

+ + + +
ovoid setWrap(WrapParameter which, WrapMode wrap) +
Set the texture wrap mode +

+ + +

oWrapMode getWrap(WrapParameter which) const +
Get the texture wrap mode +

+ + +

oenum FilterParameter +

+ + + +
o MIN_FILTER +

+ + +

o MAG_FILTER +

+ + + +
oenum FilterMode +

+ + + +
o LINEAR +

+ + +

o LINEAR_MIPMAP_LINEAR +

+ + +

o LINEAR_MIPMAP_NEAREST +

+ + +

o NEAREST +

+ + +

o NEAREST_MIPMAP_LINEAR +

+ + +

o NEAREST_MIPMAP_NEAREST +

+ + + +
ovoid setFilter(FilterParameter which, FilterMode filter) +
Set the texture filter mode +

+ + +

oFilterMode getFilter(FilterParameter which) const +
Get the texture filter mode +

+ + +

ostatic void enable( void ) +
Enable OpenGL texturing +

+ + +

ostatic void disable( void ) +
Disable OpenGL texturing +

+ + +

ovoid apply( void ) +
On first apply, create the minmapped texture and bind it, +subsequent apply will simple bind to texture +

+ + +

ovirtual ~Texture() +

+ + +

ovirtual bool readLocalData(Input& fr) +

+ + +

ovirtual bool writeLocalData(Output& fw) +

+ + +

ouint _handle +

+ + +

oref_ptr<Image> _image +

+ + +

obool matchWrapStr(const char* str, WrapMode& wrap) +

+ + +

oconst char* getWrapStr(WrapMode wrap) +

+ + +

obool matchFilterStr(const char* str, FilterMode& filter) +

+ + +

oconst char* getFilterStr(FilterMode filter) +

+ + +

oWrapMode _wrap_s +

+ + +

oWrapMode _wrap_t +

+ + +

oWrapMode _wrap_r +

+ + +

oFilterMode _min_filter +

+ + +

oFilterMode _mag_filter +

+ +
This class has no child classes.
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osg/Output.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osg/Output.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osg/Output.html (revision 2) @@ -0,0 +1,211 @@ + + + class SG_EXPORT osg::Output + + + + +

class SG_EXPORT osg::Output: public ofstream

+
ofstream wrapper class for adding support for indenting.
+
+ +

Inheritance:

+ + + + + + + +
+ +
+

+

Public Methods

+[more] Output() +
+
+[more]virtual ~Output() +
+
+[more]Output& indent() +
+
+[more]int getIndentStep() const +
+
+[more]void setIndentStep(int step) +
+
+[more]int getIndent() const +
+
+[more]void setIndent(int indent) +
+
+[more]int getNumIndicesPerLine() const +
+
+[more]void setNumIndicesPerLine(int num) +
+
+[more]void moveIn() +
+
+[more]void moveOut() +
+
+[more]bool getUniqueIDForObject(Object* obj, std::string& uniqueID) +
+
+[more]bool createUniqueIDForObject(Object* obj, std::string& uniqueID) +
+
+[more]bool registerUniqueIDForObject(Object* obj, std::string& uniqueID) +
+

+ +

+

Protected Fields

+[more]int _indent +
+
+[more]int _indentStep +
+
+[more]int _numIndicesPerLine +
+
+[more]UniqueIDToLabelMapping _objectToUniqueIDMap +
+

+ +

+

Protected Methods

+[more] Output(const Output&) +
+
+[more]Output& operator = (const Output&) +
+
+[more]virtual void _init() +
+
+[more]virtual void _free() +
+

+ +

+

Protected

+[more]typedef std::map<Object*,std::string> UniqueIDToLabelMapping +
+

+ +
+ + +
+

Documentation

+
ofstream wrapper class for adding support for indenting. +Used in output of .osg ASCII files to improve their readability.
+
+ + + +
o Output() +

+ + +

ovirtual ~Output() +

+ + +

oOutput& indent() +

+ + +

oint getIndentStep() const +

+ + +

ovoid setIndentStep(int step) +

+ + +

oint getIndent() const +

+ + +

ovoid setIndent(int indent) +

+ + +

oint getNumIndicesPerLine() const +

+ + +

ovoid setNumIndicesPerLine(int num) +

+ + +

ovoid moveIn() +

+ + +

ovoid moveOut() +

+ + +

obool getUniqueIDForObject(Object* obj, std::string& uniqueID) +

+ + +

obool createUniqueIDForObject(Object* obj, std::string& uniqueID) +

+ + +

obool registerUniqueIDForObject(Object* obj, std::string& uniqueID) +

+ + +

o Output(const Output&) +

+ + +

oOutput& operator = (const Output&) +

+ + +

ovirtual void _init() +

+ + +

ovirtual void _free() +

+ + +

oint _indent +

+ + +

oint _indentStep +

+ + +

oint _numIndicesPerLine +

+ + +

otypedef std::map<Object*,std::string> UniqueIDToLabelMapping +

+ + +

oUniqueIDToLabelMapping _objectToUniqueIDMap +

+ +
This class has no child classes.
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osg/NodePath.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osg/NodePath.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osg/NodePath.html (revision 2) @@ -0,0 +1,20 @@ + + + typedef std::vector<Node*> osg::NodePath + + + + +

typedef std::vector<Node*> osg::NodePath

+
A vector of Nodes pointers which is used to describe the path from a root node to a descendant
+ + +
+

Documentation

+
A vector of Nodes pointers which is used to describe the path from a root node to a descendant
+
+
+

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osg/NotifySeverity.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osg/NotifySeverity.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osg/NotifySeverity.html (revision 2) @@ -0,0 +1,72 @@ + + + enum osg::NotifySeverity + + + + +

enum osg::NotifySeverity

+ +
+

+
+[more] ALWAYS +
+
+[more] FATAL +
+
+[more] WARN +
+
+[more] NOTICE +
+
+[more] INFO +
+
+[more] DEBUG +
+
+[more] FP_DEBUG +
+

+ + + +
+

Documentation

+
+ + + +
o ALWAYS +

+ + +

o FATAL +

+ + +

o WARN +

+ + +

o NOTICE +

+ + +

o INFO +

+ + +

o DEBUG +

+ + +

o FP_DEBUG +

+

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osg/RegisterReaderWriterProxy.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osg/RegisterReaderWriterProxy.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osg/RegisterReaderWriterProxy.html (revision 2) @@ -0,0 +1,55 @@ + + + template<class T> class osg::RegisterReaderWriterProxy + + + + +

template<class T> class osg::RegisterReaderWriterProxy

+
Proxy class for automatic registration of reader/writers with the Registry
+
+ +
+

+

Public Methods

+[more] RegisterReaderWriterProxy() +
+
+[more] ~RegisterReaderWriterProxy() +
+

+ +

+

Protected Fields

+[more]T* _rw +
+

+ +
+ + +
+

Documentation

+
Proxy class for automatic registration of reader/writers with the +Registry
+
+ + + +
o RegisterReaderWriterProxy() +

+ + +

o ~RegisterReaderWriterProxy() +

+ + +

oT* _rw +

+ +
This class has no child classes.
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osg/Registry.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osg/Registry.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osg/Registry.html (revision 2) @@ -0,0 +1,175 @@ + + + class SG_EXPORT osg::Registry + + + + +

class SG_EXPORT osg::Registry

+
Registry is a singleton factory which stores the Objects types available at runtime for loading, and any Object reader or writers which are linked in at runtime for reading non-native file formats.
+
+ +
+

+

Public Methods

+[more] ~Registry() +
+
+[more]static Registry* instance() +
+
+[more]void addPrototype(Object* obj) +
+
+[more]void removePrototype(Object* obj) +
+
+[more]void addReaderWriter(ReaderWriter* rw) +
+
+[more]void removeReaderWriter(ReaderWriter* rw) +
+
+[more]std::string createLibraryNameForFile(const std::string& fileName) +
create the platform specific library name associated with file +
+[more]std::string createLibraryNameForExt(const std::string& ext) +
create the platform specific library name associated with file extension +
+[more]bool loadLibrary(const std::string& fileName) +
find the library in the SG_LIBRARY_PATH and load it +
+[more]bool closeLibrary(const std::string& fileName) +
close the attached library with specified name +
+[more]Object* readObject(Input& fr) +
+
+[more]Object* readObject(const std::string& fileName) +
+
+[more]bool writeObject(Object& obj, const std::string& fileName) +
+
+[more]Image* readImage(Input& fr) +
+
+[more]Image* readImage(const std::string& fileName) +
+
+[more]bool writeImage(Image& obj, const std::string& fileName) +
+
+[more]Node* readNode(Input& fr) +
+
+[more]Node* readNode(const std::string& fileName) +
+
+[more]bool writeNode(Node& node, const std::string& fileName) +
+

+ +
+ + +
+

Documentation

+
+Registry is a singleton factory which stores +the Objects types available at runtime for loading, +and any Object reader or writers which are linked in +at runtime for reading non-native file formats.

The RegisterObjectProxy defined in Object.h can be +used to automatically register at runtime a Object +with the Registry.

The RegisterReaderWriterProxy defined in ReaderWriter.h can +be used to automatically register at runtime a reader/writer +with the Registry.

+
+ + + +
o ~Registry() +

+ + +

ostatic Registry* instance() +

+ + +

ovoid addPrototype(Object* obj) +

+ + +

ovoid removePrototype(Object* obj) +

+ + +

ovoid addReaderWriter(ReaderWriter* rw) +

+ + +

ovoid removeReaderWriter(ReaderWriter* rw) +

+ + +

ostd::string createLibraryNameForFile(const std::string& fileName) +
create the platform specific library name associated with file +

+ + +

ostd::string createLibraryNameForExt(const std::string& ext) +
create the platform specific library name associated with file extension +

+ + +

obool loadLibrary(const std::string& fileName) +
find the library in the SG_LIBRARY_PATH and load it +

+ + +

obool closeLibrary(const std::string& fileName) +
close the attached library with specified name +

+ + +

oObject* readObject(Input& fr) +

+ + +

oObject* readObject(const std::string& fileName) +

+ + +

obool writeObject(Object& obj, const std::string& fileName) +

+ + +

oImage* readImage(Input& fr) +

+ + +

oImage* readImage(const std::string& fileName) +

+ + +

obool writeImage(Image& obj, const std::string& fileName) +

+ + +

oNode* readNode(Input& fr) +

+ + +

oNode* readNode(const std::string& fileName) +

+ + +

obool writeNode(Node& node, const std::string& fileName) +

+ +
This class has no child classes.
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osg/MemoryAdapter.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osg/MemoryAdapter.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osg/MemoryAdapter.html (revision 2) @@ -0,0 +1,122 @@ + + + class SG_EXPORT osg::MemoryAdapter + + + + +

class SG_EXPORT osg::MemoryAdapter: public Referenced

+
Class for adapting the memory management of external data.
+
+ +

Inheritance:

+ + + + + + + +
+ +
+

+

Public Methods

+[more] MemoryAdapter() +
+
+[more]virtual void incrementReference(void* ) +
Increment the reference count of the userData +
+[more]virtual void decrementReference(void* ) +
Decrement the reference count of the userData. +
+[more]virtual void* clone(void* ) +
not current used, but will be used in future +
+[more]virtual bool write(Output& , void* ) +
not current used, but will be used in future +
+[more]virtual bool read(Input& , void* ) +
not current used, but will be used in future +

+ +

+

Protected Methods

+[more]virtual ~MemoryAdapter() +
+

+ +
+

Inherited from Referenced:

+
+

+

Public Methods

+oReferenced& operator = (Referenced&) +
+ovoid ref() +
+ovoid unref() +
+oint referenceCount() +

+ +

+

Protected Fields

+oint _refCount +

+ +
+ + +
+

Documentation

+
Class for adapting the memory management of external data. +Typically used to specify the memory management of user data +which can be attached to osg::Node.
+
+ + + +
o MemoryAdapter() +

+ + +

ovirtual void incrementReference(void* ) +
Increment the reference count of the userData +

+ + +

ovirtual void decrementReference(void* ) +
Decrement the reference count of the userData. +Is usually implemented such that if reference count +is decremented to zero the userData should be +deleted. However, this is entirely up to the +discression of the user who is extending this base class. +

+ + +

ovirtual void* clone(void* ) +
not current used, but will be used in future +

+ + +

ovirtual bool write(Output& , void* ) +
not current used, but will be used in future +

+ + +

ovirtual bool read(Input& , void* ) +
not current used, but will be used in future +

+ + +

ovirtual ~MemoryAdapter() +

+ +
This class has no child classes.
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osg/Quat.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osg/Quat.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osg/Quat.html (revision 2) @@ -0,0 +1,286 @@ + + + class SG_EXPORT osg::Quat + + + + +

class SG_EXPORT osg::Quat

+
A quaternion class.
+
+ +
+

+

Public Fields

+[more]Vec4 _fv +
+

+ +

+

Public Methods

+[more] Quat( void ) +
+
+[more] Quat( float x, float y, float z, float w ) +
+
+[more] Quat( const Vec4& vec ) +
+
+[more]inline Vec4 asVec4( void ) const +
+
+[more]inline Vec3 asVec3( void ) const +
+
+[more]inline Quat operator * (const float& rhs) const +
Multiply by scalar +
+[more]inline Quat& operator *= (const float& rhs) +
Unary multiply by scalar +
+[more]inline Quat operator*(const Quat& rhs) const +
Binary multiply +
+[more]inline Quat& operator*=(const Quat& rhs) +
Unary multiply +
+[more]inline Quat operator / (const float& rhs) const +
Divide by scalar +
+[more]inline Quat& operator /= (const float& rhs) +
Unary divide by scalar +
+[more]inline Quat operator/(const Quat& denom) const +
Binary divide +
+[more]inline Quat& operator/=(const Quat& denom) +
Unary divide +
+[more]inline Quat operator + (const Quat& rhs) const +
Binary addition +
+[more]inline Quat& operator += (const Quat& rhs) +
Unary addition +
+[more]inline Quat operator - (const Quat& rhs) const +
Binary subtraction +
+[more]inline Quat& operator -= (const Quat& rhs) +
Unary subtraction +
+[more]inline Quat operator - () const +
Negation operator - returns the negative of the quaternion. +
+[more]float length( void ) const +
Length of the quaternion = sqrt( vec . vec ) +
+[more]float length2( void ) const +
Length of the quaternion = vec . vec +
+[more]inline Quat conj( void ) const +
Conjugate +
+[more]inline Quat inverse( void ) const +
Multiplicative inverse method: q^(-1) = q^*/(q.q^*) +
+[more]void makeRot( const float angle, const float x, const float y, const float z ) +
+
+[more]void makeRot( const float angle, const Vec3& vec ) +
+
+[more]void makeRot( const Vec3& vec1, const Vec3& vec2 ) +
Make a rotation Quat which will rotate vec1 to vec2. +
+[more]void getRot( float& angle, float& x, float& y, float& z ) const +
Return the angle and vector components represented by the quaternion +
+[more]void getRot( float& angle, Vec3& vec ) const +
Return the angle and vector represented by the quaternion +
+[more]void slerp( const float t, const Quat& from, const Quat& to) +
Spherical Linear Interpolation. +
+[more]void set( const osg::Matrix& m ) +
Set quaternion to be equivalent to specified matrix +
+[more]void get( osg::Matrix& m ) const +
Get the equivalent matrix for this quaternion +
+[more]inline friend ostream& operator << (ostream& output, const Quat& vec) +
+

+ +
+ + +
+

Documentation

+
A quaternion class. It can be used to represent an orientation in 3D space.
+
+ + + +
oVec4 _fv +

+ + +

o Quat( void ) +

+ + +

o Quat( float x, float y, float z, float w ) +

+ + +

o Quat( const Vec4& vec ) +

+ + +

oinline Vec4 asVec4( void ) const +

+ + +

oinline Vec3 asVec3( void ) const +

+ + +

oinline Quat operator * (const float& rhs) const +
Multiply by scalar +

+ + +

oinline Quat& operator *= (const float& rhs) +
Unary multiply by scalar +

+ + +

oinline Quat operator*(const Quat& rhs) const +
Binary multiply +

+ + +

oinline Quat& operator*=(const Quat& rhs) +
Unary multiply +

+ + +

oinline Quat operator / (const float& rhs) const +
Divide by scalar +

+ + +

oinline Quat& operator /= (const float& rhs) +
Unary divide by scalar +

+ + +

oinline Quat operator/(const Quat& denom) const +
Binary divide +

+ + +

oinline Quat& operator/=(const Quat& denom) +
Unary divide +

+ + +

oinline Quat operator + (const Quat& rhs) const +
Binary addition +

+ + +

oinline Quat& operator += (const Quat& rhs) +
Unary addition +

+ + +

oinline Quat operator - (const Quat& rhs) const +
Binary subtraction +

+ + +

oinline Quat& operator -= (const Quat& rhs) +
Unary subtraction +

+ + +

oinline Quat operator - () const +
Negation operator - returns the negative of the quaternion. +Basically just calls operator - () on the Vec4 +

+ + +

ofloat length( void ) const +
Length of the quaternion = sqrt( vec . vec ) +

+ + +

ofloat length2( void ) const +
Length of the quaternion = vec . vec +

+ + +

oinline Quat conj( void ) const +
Conjugate +

+ + +

oinline Quat inverse( void ) const +
Multiplicative inverse method: q^(-1) = q^*/(q.q^*) +

+ + +

ovoid makeRot( const float angle, const float x, const float y, const float z ) +

+ + +

ovoid makeRot( const float angle, const Vec3& vec ) +

+ + +

ovoid makeRot( const Vec3& vec1, const Vec3& vec2 ) +
Make a rotation Quat which will rotate vec1 to vec2. +Generally take adot product to get the angle between these +and then use a cross product to get the rotation axis +Watch out for the two special cases of when the vectors +are co-incident or opposite in direction. +

+ + +

ovoid getRot( float& angle, float& x, float& y, float& z ) const +
Return the angle and vector components represented by the quaternion +

+ + +

ovoid getRot( float& angle, Vec3& vec ) const +
Return the angle and vector represented by the quaternion +

+ + +

ovoid slerp( const float t, const Quat& from, const Quat& to) +
Spherical Linear Interpolation. +As t goes from 0 to 1, the Quat object goes from "from" to "to". +

+ + +

ovoid set( const osg::Matrix& m ) +
Set quaternion to be equivalent to specified matrix +

+ + +

ovoid get( osg::Matrix& m ) const +
Get the equivalent matrix for this quaternion +

+ + +

oinline friend ostream& operator << (ostream& output, const Quat& vec) +

+ +
This class has no child classes.
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osg/BoundingSphere.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osg/BoundingSphere.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osg/BoundingSphere.html (revision 2) @@ -0,0 +1,169 @@ + + + class SG_EXPORT osg::BoundingSphere + + + + +

class SG_EXPORT osg::BoundingSphere

+
General purpose bounding sphere class for enclosing nodes/objects/vertices.
+
+ +
+

+

Public Fields

+[more]Vec3 _center +
+
+[more]float _radius +
+

+ +

+

Public Methods

+[more] BoundingSphere() +
construct to invalid values to represent an unset bounding sphere +
+[more]void init() +
initialize to invalid values to represent an unset bounding sphere +
+[more]bool isValid() const +
return true if the bounding sphere contains valid values, false if the bounding sphere is effectively unset +
+[more]const Vec3& center() const +
return the const center of the bounding sphere +
+[more]Vec3& center() +
return the center of the bounding sphere +
+[more]float radius() const +
return the const radius of the bounding sphere +
+[more]float& radius() +
return the radius of the bounding sphere +
+[more]float radius2() const +
return the radius squared. +
+[more]void expandBy(const Vec3& v) +
If the vertex is outwith the sphere expand to ecompass vertex. +
+[more]void expandRadiusBy(const Vec3& v) +
If the vertex is outwith the sphere expand radius to ecompass vertex. +
+[more]void expandBy(const BoundingSphere& sh) +
If incomming sphere is outwith the sphere expand to ecompass incomming sphere. +
+[more]void expandRadiusBy(const BoundingSphere& sh) +
If incomming sphere is outwith the sphere expand radius to ecompass incomming sphere. +
+[more]bool contains(const Vec3& v) +
return true is vertex v is within the sphere +

+ +
+ + +
+

Documentation

+
General purpose bounding sphere class for enclosing nodes/objects/vertices. +Used to bound internal osg::Node's in the scene, +to assist in view frustrum culling etc. Similar in function to BoundingBox +but is quicker for evaluating culling, but generally encloses a greater volume +than a BoundingBox so will not cull so aggressively.
+
+ + + +
oVec3 _center +

+ + +

ofloat _radius +

+ + +

o BoundingSphere() +
construct to invalid values to represent an unset bounding sphere +

+ + +

ovoid init() +
initialize to invalid values to represent an unset bounding sphere +

+ + +

obool isValid() const +
return true if the bounding sphere contains valid values, +false if the bounding sphere is effectively unset +

+ + +

oconst Vec3& center() const +
return the const center of the bounding sphere +

+ + +

oVec3& center() +
return the center of the bounding sphere +

+ + +

ofloat radius() const +
return the const radius of the bounding sphere +

+ + +

ofloat& radius() +
return the radius of the bounding sphere +

+ + +

ofloat radius2() const +
return the radius squared. +Note, for performance reasons, assumes the calling method has ensured +that the sphere is valid before calling radius2(), i.e. has _radius>=0.0, +as it does not check th validity of sphere and will eroneously return a positive value. +

+ + +

ovoid expandBy(const Vec3& v) +
If the vertex is outwith the sphere expand to ecompass vertex. +Calculates the combination of movement of center and radius which +minimizes the radius increase. If this sphere is empty then +move the centrer to v and set radius to 0. +

+ + +

ovoid expandRadiusBy(const Vec3& v) +
If the vertex is outwith the sphere expand radius to ecompass vertex. +Unlike update, does not move the center, just increasing the radius. +If this sphere is empty then move the centrer to v and set radius to 0 +

+ + +

ovoid expandBy(const BoundingSphere& sh) +
If incomming sphere is outwith the sphere expand to ecompass incomming sphere. +calculates the combination of movement of center and radius which +minimizes the radius increase. If this sphere is empty then +move the centrer to v and set radius to 0. +

+ + +

ovoid expandRadiusBy(const BoundingSphere& sh) +
If incomming sphere is outwith the sphere expand radius to ecompass incomming sphere. +Unlike update, does not move the center, just increasing the radius. +If this sphere is empty then move the centrer to v and set radius to 0. +

+ + +

obool contains(const Vec3& v) +
return true is vertex v is within the sphere +

+ +
This class has no child classes.
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osg/FieldReaderIterator.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osg/FieldReaderIterator.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osg/FieldReaderIterator.html (revision 2) @@ -0,0 +1,184 @@ + + + class SG_EXPORT osg::FieldReaderIterator + + + + +

class SG_EXPORT osg::FieldReaderIterator

+
+ +

Inheritance:

+ + + + + + + +
+ +
+

+

Public Classes

+[more]enum +
+

+ +

+

Public Methods

+[more] FieldReaderIterator() +
+
+[more] FieldReaderIterator(const FieldReaderIterator& ic) +
+
+[more]virtual ~FieldReaderIterator() +
+
+[more]virtual FieldReaderIterator& operator = (const FieldReaderIterator& ic) +
+
+[more]void attach(istream* input) +
+
+[more]void detach() +
+
+[more]virtual bool eof() const +
+
+[more]FieldReader& getFieldReader() +
+
+[more]void insert(int pos, Field* field) +
+
+[more]void insert(int pos, const char* str) +
+
+[more]Field& operator [] (int pos) +
+
+[more]Field& field(int pos) +
+
+[more]FieldReaderIterator& operator ++ () +
+
+[more]FieldReaderIterator& operator += (int no) +
+
+[more]void advanceOverCurrentFieldOrBlock() +
increments the itetor of the next simple field or whole block if the current field[0] is an open bracket +
+[more]void advanceToEndOfCurrentBlock() +
+
+[more]void advanceToEndOfBlock(int noNestBrackets) +
+
+[more]bool matchSequence(const char* str) +
+

+ +
+ + +
+

Documentation

+
+ + + +
oenum +

+ + + +
o MINIMUM_FIELD_READER_QUEUE_SIZE +

+ + + +
o FieldReaderIterator() +

+ + +

o FieldReaderIterator(const FieldReaderIterator& ic) +

+ + +

ovirtual ~FieldReaderIterator() +

+ + +

ovirtual FieldReaderIterator& operator = (const FieldReaderIterator& ic) +

+ + +

ovoid attach(istream* input) +

+ + +

ovoid detach() +

+ + +

ovirtual bool eof() const +

+ + +

oFieldReader& getFieldReader() +

+ + +

ovoid insert(int pos, Field* field) +

+ + +

ovoid insert(int pos, const char* str) +

+ + +

oField& operator [] (int pos) +

+ + +

oField& field(int pos) +

+ + +

oFieldReaderIterator& operator ++ () +

+ + +

oFieldReaderIterator& operator += (int no) +

+ + +

ovoid advanceOverCurrentFieldOrBlock() +
increments the itetor of the next simple field or +whole block if the current field[0] is an open bracket +

+ + +

ovoid advanceToEndOfCurrentBlock() +

+ + +

ovoid advanceToEndOfBlock(int noNestBrackets) +

+ + +

obool matchSequence(const char* str) +

+
+
Direct child classes: +
Input
+
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osg/Image.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osg/Image.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osg/Image.html (revision 2) @@ -0,0 +1,272 @@ + + + class SG_EXPORT osg::Image + + + + +

class SG_EXPORT osg::Image: public Object

+
Image class for encapsulating the storage texture image data
+
+ +

Inheritance:

+ + + + + + + +
+ +
+

+

Public Methods

+[more] Image() +
+
+[more]virtual Object* clone() const +
+
+[more]virtual bool isSameKindAs(Object* obj) +
+
+[more]virtual const char* className() const +
+
+[more]const char* getFileName() +
+
+[more]void setFileName(const char* fileName) +
+
+[more]void setImage(int s, int t, int r, int internalFormat, unsigned int pixelFormat, unsigned int dataType, unsigned char *data) +
+
+[more]int s() +
Width of image +
+[more]int t() +
Height of image +
+[more]int r() +
Depth of image +
+[more]int internalFormat() +
+
+[more]unsigned int pixelFormat() +
+
+[more]unsigned int dataType() +
+
+[more]unsigned char* data() +
raw image data +
+[more]void scaleImage(int s, int t, int r) +
Scale image to specified size. +
+[more]void ensureDimensionsArePowerOfTwo() +
Ensure image dimensions are a power of two. +

+ +

+

Protected Fields

+[more]char* _fileName +
+
+[more]int _s +
+
+[more]int _t +
+
+[more]int _r +
+
+[more]int _internalFormat +
+
+[more]unsigned int _pixelFormat +
+
+[more]unsigned int _dataType +
+
+[more]unsigned char* _data +
+

+ +

+

Protected Methods

+[more]virtual ~Image() +
+
+[more]virtual bool readLocalData(Input& fr) +
+
+[more]virtual bool writeLocalData(Output& fw) +
+

+ +
+

Inherited from Object:

+
+

+

Public Methods

+ovirtual Object* readClone(Input& fr) +
+ovirtual bool write(Output& fw) +

+ +
+

Inherited from Referenced:

+
+

+

Public Methods

+oReferenced& operator = (Referenced&) +
+ovoid ref() +
+ovoid unref() +
+oint referenceCount() +

+ +

+

Protected Fields

+oint _refCount +

+ +
+ + +
+

Documentation

+
Image class for encapsulating the storage texture image data
+
+ + + +
o Image() +

+ + +

ovirtual Object* clone() const +

+ + +

ovirtual bool isSameKindAs(Object* obj) +

+ + +

ovirtual const char* className() const +

+ + +

oconst char* getFileName() +

+ + +

ovoid setFileName(const char* fileName) +

+ + +

ovoid setImage(int s, int t, int r, int internalFormat, unsigned int pixelFormat, unsigned int dataType, unsigned char *data) +

+ + +

oint s() +
Width of image +

+ + +

oint t() +
Height of image +

+ + +

oint r() +
Depth of image +

+ + +

oint internalFormat() +

+ + +

ounsigned int pixelFormat() +

+ + +

ounsigned int dataType() +

+ + +

ounsigned char* data() +
raw image data +

+ + +

ovoid scaleImage(int s, int t, int r) +
Scale image to specified size. +

+ + +

ovoid ensureDimensionsArePowerOfTwo() +
Ensure image dimensions are a power of two. +Mip Mapped texture require the image dimensions to be +power of two. +

+ + +

ovirtual ~Image() +

+ + +

ovirtual bool readLocalData(Input& fr) +

+ + +

ovirtual bool writeLocalData(Output& fw) +

+ + +

ochar* _fileName +

+ + +

oint _s +

+ + +

oint _t +

+ + +

oint _r +

+ + +

oint _internalFormat +

+ + +

ounsigned int _pixelFormat +

+ + +

ounsigned int _dataType +

+ + +

ounsigned char* _data +

+ +
This class has no child classes.
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osg/Node.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osg/Node.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osg/Node.html (revision 2) @@ -0,0 +1,444 @@ + + + class SG_EXPORT osg::Node + + + + +

class SG_EXPORT osg::Node: public Object

+
Base class for all internal nodes in the scene graph.
+
+ +

Inheritance:

+ + + + + + + +
+ +
+

+

Public Methods

+[more] Node() +
Construct a node. +
+[more]virtual Object* clone() const +
return a shallow copy of a node, with Object* return type +
+[more]Node* cloneNode() const +
return a shallow copy of a node, with Node* return type +
+[more]virtual bool isSameKindAs(Object* obj) +
return true if this and obj are of the same kind of object +
+[more]virtual const char* className() const +
return the name of the node's class type +
+[more]virtual void accept(NodeVisitor& nv) +
Visitor Pattern : calls the apply method of a NodeVisitor with this node's type +
+[more]virtual void ascend(NodeVisitor& nv) +
Traverse upwards : calls parents' accept method with NodeVisitor +
+[more]virtual void traverse(NodeVisitor& ) +
Traverse downwards : calls children's accept method with NodeVisitor +
+[more]void setName( const std::string& name ) +
Set the name of node using C++ style string +
+[more]void setName( const char* name ) +
Set the name of node using a C style string +
+[more]const std::string& getName( void ) +
Get the name of node +
+[more]const ParentList& getParents() const +
Get the parent list of node. +
+[more]Group* getParent(int i) const +
Get a single parent of node. +
+[more]int getNumParents() const +
Get the number of parents of node. +
+[more]void setUserData(void* data, MemoryAdapter* ma=0L) +
Set user data. +
+[more]void* getUserData() const +
Get user data +
+[more]MemoryAdapter* getMemoryAdapter() const +
Get the memory adapter associated with _userData +
+[more]void setNodeMask(NodeMask nm) +
Set the node mask. +
+[more]NodeMask getNodeMask() +
Get the node Mask. +
+[more]const DescriptionList& getDescriptions() const +
Get the description list of the const node +
+[more]DescriptionList& getDescriptions() +
Get the description list of the const node +
+[more]const std::string& getDescription(int i) const +
Get a single const description of the const node +
+[more]std::string& getDescription(int i) +
Get a single description of the node +
+[more]int getNumDescriptions() const +
Get the number of descriptions of the node +
+[more]void addDescription(const std::string& desc) +
Add a description string to the node +
+[more]const BoundingSphere& getBound() +
get the bounding sphere of node. +
+[more]void dirtyBound() +
Mark this node's bounding sphere dirty. +

+ +

+

Public

+[more]typedef std::vector<Group*> ParentList +
A vector of osg::Group pointers which is used to store the parent(s) of node +
+[more]typedef unsigned int NodeMask +
+
+[more]typedef std::vector<std::string> DescriptionList +
A vector of std::string's which are used to describe the object +

+ +

+

Protected Fields

+[more]BoundingSphere _bsphere +
+
+[more]bool _bsphere_computed +
+
+[more]std::string _name +
+
+[more]ParentList _parents +
+
+[more]friend Group +
+
+[more]void* _userData +
+
+[more]ref_ptr<MemoryAdapter> _memoryAdapter +
+
+[more]NodeMask _nodeMask +
+
+[more]DescriptionList _descriptions +
+

+ +

+

Protected Methods

+[more]virtual ~Node() +
Node destructor. +
+[more]virtual bool readLocalData(Input& fr) +
Template Method Pattern : read local data from osg file. +
+[more]virtual bool writeLocalData(Output& fw) +
Template Method Pattern : read local data from osg file. +
+[more]virtual bool computeBound( void ) +
Compute the bounding sphere around Node's geometry or children. +

+ +
+

Inherited from Object:

+
+

+

Public Methods

+ovirtual Object* readClone(Input& fr) +
+ovirtual bool write(Output& fw) +

+ +
+

Inherited from Referenced:

+
+

+

Public Methods

+oReferenced& operator = (Referenced&) +
+ovoid ref() +
+ovoid unref() +
+oint referenceCount() +

+ +

+

Protected Fields

+oint _refCount +

+ +
+ + +
+

Documentation

+
Base class for all internal nodes in the scene graph. +Provides interface for most common node operations (Composite Pattern).
+
+ + + +
o Node() +
Construct a node. +Initialize the parent list to empty, node name to "" and +bounding sphere dirty flag to true. +

+ + +

ovirtual Object* clone() const +
return a shallow copy of a node, with Object* return type +

+ + +

oNode* cloneNode() const +
return a shallow copy of a node, with Node* return type +

+ + +

ovirtual bool isSameKindAs(Object* obj) +
return true if this and obj are of the same kind of object +

+ + +

ovirtual const char* className() const +
return the name of the node's class type +

+ + +

ovirtual void accept(NodeVisitor& nv) +
Visitor Pattern : calls the apply method of a NodeVisitor with this node's type +

+ + +

ovirtual void ascend(NodeVisitor& nv) +
Traverse upwards : calls parents' accept method with NodeVisitor +

+ + +

ovirtual void traverse(NodeVisitor& ) +
Traverse downwards : calls children's accept method with NodeVisitor +

+ + +

ovoid setName( const std::string& name ) +
Set the name of node using C++ style string +

+ + +

ovoid setName( const char* name ) +
Set the name of node using a C style string +

+ + +

oconst std::string& getName( void ) +
Get the name of node +

+ + +

otypedef std::vector<Group*> ParentList +
A vector of osg::Group pointers which is used to store the parent(s) of node +

+ + +

oconst ParentList& getParents() const +
Get the parent list of node. +

+ + +

oGroup* getParent(int i) const +
+Get a single parent of node. + +
Parameters:
i - index of the parent to get. +
Returns:
the parent i.

+ + +

oint getNumParents() const +
+Get the number of parents of node. + +
Returns:
the number of parents of this node.

+ + +

ovoid setUserData(void* data, MemoryAdapter* ma=0L) +
+Set user data. See MemoryAdapter documention for details +of how to specify memory managament of _userData. +

+ + +

ovoid* getUserData() const +
Get user data +

+ + +

oMemoryAdapter* getMemoryAdapter() const +
Get the memory adapter associated with _userData +

+ + +

otypedef unsigned int NodeMask +

+ + +

ovoid setNodeMask(NodeMask nm) +
Set the node mask. Note, node mask is will be replaced by TraversalMask. +

+ + +

oNodeMask getNodeMask() +
Get the node Mask. Note, node mask is will be replaced by TraversalMask. +

+ + +

otypedef std::vector<std::string> DescriptionList +
A vector of std::string's which are used to describe the object +

+ + +

oconst DescriptionList& getDescriptions() const +
Get the description list of the const node +

+ + +

oDescriptionList& getDescriptions() +
Get the description list of the const node +

+ + +

oconst std::string& getDescription(int i) const +
Get a single const description of the const node +

+ + +

ostd::string& getDescription(int i) +
Get a single description of the node +

+ + +

oint getNumDescriptions() const +
Get the number of descriptions of the node +

+ + +

ovoid addDescription(const std::string& desc) +
Add a description string to the node +

+ + +

oconst BoundingSphere& getBound() +
get the bounding sphere of node. +Using lazy evaluation computes the bounding sphere if it is 'dirty'. +

+ + +

ovoid dirtyBound() +
Mark this node's bounding sphere dirty. +Forcing it to be computed on the next call to getBound(). +

+ + +

ovirtual ~Node() +
Node destructor. Note, is protected so that Nodes cannot +be deleted other than by being dereferenced and the reference +count being zero (see osg::Referenced), preventing the deletion +of nodes which are still in use. This also means that +Node's cannot be created on stack i.e Node node will not compile, +forcing all nodes to be created on the heap i.e Node* node += new Node(). +

+ + +

ovirtual bool readLocalData(Input& fr) +
+Template Method Pattern : read local data from osg file. +Note should be implemented in derived classes, which +call their parent class's readLocalData. + +
Returns:
true if the input iterator has been advanced, otherwise false.

+ + +

ovirtual bool writeLocalData(Output& fw) +
+Template Method Pattern : read local data from osg file. +Note should be implemented in derivied classes, which +call their parent class's writeLocalData. + +
Returns:
true if data has been written out, otherwise false.

+ + +

ovirtual bool computeBound( void ) +
Compute the bounding sphere around Node's geometry or children. +This method is automatically called by getBound() when the bounding +sphere has been marked dirty via dirtyBound(). +

+ + +

oBoundingSphere _bsphere +

+ + +

obool _bsphere_computed +

+ + +

ostd::string _name +

+ + +

oParentList _parents +

+ + +

ofriend Group +

+ + +

ovoid* _userData +

+ + +

oref_ptr<MemoryAdapter> _memoryAdapter +

+ + +

oNodeMask _nodeMask +

+ + +

oDescriptionList _descriptions +

+
+
Direct child classes: +
LightSource
+Group
+Geode
+
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osg/LightSource.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osg/LightSource.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osg/LightSource.html (revision 2) @@ -0,0 +1,241 @@ + + + class SG_EXPORT osg::LightSource + + + + +

class SG_EXPORT osg::LightSource: public Node

+
Leaf Node for defining a light in the scene
+
+ +

Inheritance:

+ + + + + + + +
+ +
+

+

Public Methods

+[more] LightSource() +
+
+[more]virtual Object* clone() const +
+
+[more]virtual bool isSameKindAs(Object* obj) +
+
+[more]virtual const char* className() const +
+
+[more]virtual void accept(NodeVisitor& nv) +
+
+[more]void setLight(Light* light) +
Set the attached light +
+[more]Light* getLight() +
Get the attached light +

+ +

+

Protected Fields

+[more]ref_ptr<Light> _light +
+

+ +

+

Protected Methods

+[more]virtual ~LightSource() +
+
+[more]virtual bool readLocalData(Input& fr) +
+
+[more]virtual bool writeLocalData(Output& fw) +
+
+[more]virtual bool computeBound( void ) +
+

+ +
+

Inherited from Node:

+
+

+

Public Methods

+oNode* cloneNode() const +
+ovirtual void ascend(NodeVisitor& nv) +
+ovirtual void traverse(NodeVisitor& ) +
+ovoid setName( const std::string& name ) +
+ovoid setName( const char* name ) +
+oconst std::string& getName( void ) +
+oconst ParentList& getParents() const +
+oGroup* getParent(int i) const +
+oint getNumParents() const +
+ovoid setUserData(void* data, MemoryAdapter* ma=0L) +
+ovoid* getUserData() const +
+oMemoryAdapter* getMemoryAdapter() const +
+ovoid setNodeMask(NodeMask nm) +
+oNodeMask getNodeMask() +
+oconst DescriptionList& getDescriptions() const +
+oDescriptionList& getDescriptions() +
+oconst std::string& getDescription(int i) const +
+ostd::string& getDescription(int i) +
+oint getNumDescriptions() const +
+ovoid addDescription(const std::string& desc) +
+oconst BoundingSphere& getBound() +
+ovoid dirtyBound() +

+ +

+

Public

+otypedef std::vector<Group*> ParentList +
+otypedef unsigned int NodeMask +
+otypedef std::vector<std::string> DescriptionList +

+ +

+

Protected Fields

+oBoundingSphere _bsphere +
+obool _bsphere_computed +
+ostd::string _name +
+oParentList _parents +
+ofriend Group +
+ovoid* _userData +
+oref_ptr<MemoryAdapter> _memoryAdapter +
+oNodeMask _nodeMask +
+oDescriptionList _descriptions +

+ +
+

Inherited from Object:

+
+

+

Public Methods

+ovirtual Object* readClone(Input& fr) +
+ovirtual bool write(Output& fw) +

+ +
+

Inherited from Referenced:

+
+

+

Public Methods

+oReferenced& operator = (Referenced&) +
+ovoid ref() +
+ovoid unref() +
+oint referenceCount() +

+ +

+

Protected Fields

+oint _refCount +

+ +
+ + +
+

Documentation

+
Leaf Node for defining a light in the scene
+
+ + + +
o LightSource() +

+ + +

ovirtual Object* clone() const +

+ + +

ovirtual bool isSameKindAs(Object* obj) +

+ + +

ovirtual const char* className() const +

+ + +

ovirtual void accept(NodeVisitor& nv) +

+ + +

ovoid setLight(Light* light) +
Set the attached light +

+ + +

oLight* getLight() +
Get the attached light +

+ + +

ovirtual ~LightSource() +

+ + +

ovirtual bool readLocalData(Input& fr) +

+ + +

ovirtual bool writeLocalData(Output& fw) +

+ + +

ovirtual bool computeBound( void ) +

+ + +

oref_ptr<Light> _light +

+ +
This class has no child classes.
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osg/Group.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osg/Group.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osg/Group.html (revision 2) @@ -0,0 +1,318 @@ + + + class SG_EXPORT osg::Group + + + + +

class SG_EXPORT osg::Group: public Node

+
General group node which maintains a list of children.
+
+ +

Inheritance:

+ + + + + + + +
+ +
+

+

Public Methods

+[more] Group() +
+
+[more]virtual Object* clone() const +
+
+[more]virtual bool isSameKindAs(Object* obj) +
+
+[more]virtual const char* className() const +
+
+[more]virtual void accept(NodeVisitor& nv) +
+
+[more]virtual void traverse(NodeVisitor& nv) +
+
+[more]virtual bool addChild( Node *child ) +
Add Node to Group. +
+[more]virtual bool removeChild( Node *child ) +
Remove Node from Group. +
+[more]virtual bool replaceChild( Node *origChild, Node* newChild ) +
Replace specified Node with another Node. +
+[more]int getNumChildren( void ) +
return the number of chilren nodes +
+[more]Node* getChild( int i ) +
return child node at position i +
+[more]bool containsNode( Node* node ) +
return true is node is contained within Group +
+[more]ChildList::iterator findNode( Node* node ) +
return the iterator postion for specified Node. +

+ +

+

Public

+[more]typedef std::vector<ref_ptr<Node> > ChildList +
+

+ +

+

Protected Fields

+[more]ChildList _children +
+

+ +

+

Protected Methods

+[more]virtual ~Group() +
+
+[more]virtual bool readLocalData(Input& fr) +
+
+[more]virtual bool writeLocalData(Output& fw) +
+
+[more]bool computeBound( void ) +
+

+ +
+

Inherited from Node:

+
+

+

Public Methods

+oNode* cloneNode() const +
+ovirtual void ascend(NodeVisitor& nv) +
+ovoid setName( const std::string& name ) +
+ovoid setName( const char* name ) +
+oconst std::string& getName( void ) +
+oconst ParentList& getParents() const +
+oGroup* getParent(int i) const +
+oint getNumParents() const +
+ovoid setUserData(void* data, MemoryAdapter* ma=0L) +
+ovoid* getUserData() const +
+oMemoryAdapter* getMemoryAdapter() const +
+ovoid setNodeMask(NodeMask nm) +
+oNodeMask getNodeMask() +
+oconst DescriptionList& getDescriptions() const +
+oDescriptionList& getDescriptions() +
+oconst std::string& getDescription(int i) const +
+ostd::string& getDescription(int i) +
+oint getNumDescriptions() const +
+ovoid addDescription(const std::string& desc) +
+oconst BoundingSphere& getBound() +
+ovoid dirtyBound() +

+ +

+

Public

+otypedef std::vector<Group*> ParentList +
+otypedef unsigned int NodeMask +
+otypedef std::vector<std::string> DescriptionList +

+ +

+

Protected Fields

+oBoundingSphere _bsphere +
+obool _bsphere_computed +
+ostd::string _name +
+oParentList _parents +
+ovoid* _userData +
+oref_ptr<MemoryAdapter> _memoryAdapter +
+oNodeMask _nodeMask +
+oDescriptionList _descriptions +

+ +
+

Inherited from Object:

+
+

+

Public Methods

+ovirtual Object* readClone(Input& fr) +
+ovirtual bool write(Output& fw) +

+ +
+

Inherited from Referenced:

+
+

+

Public Methods

+oReferenced& operator = (Referenced&) +
+ovoid ref() +
+ovoid unref() +
+oint referenceCount() +

+ +

+

Protected Fields

+oint _refCount +

+ +
+ + +
+

Documentation

+
General group node which maintains a list of children. +Children are reference counted to allow children to be shared +with memory management handled automatically via osg::Referenced.
+
+ + + +
otypedef std::vector<ref_ptr<Node> > ChildList +

+ + +

o Group() +

+ + +

ovirtual Object* clone() const +

+ + +

ovirtual bool isSameKindAs(Object* obj) +

+ + +

ovirtual const char* className() const +

+ + +

ovirtual void accept(NodeVisitor& nv) +

+ + +

ovirtual void traverse(NodeVisitor& nv) +

+ + +

ovirtual bool addChild( Node *child ) +
Add Node to Group. +If node is not NULL and is not contained in Group then increment its +reference count, add it to the child list and dirty the bounding +sphere to force it to recompute on next getBound() and return true for success. +Otherwise return false. +

+ + +

ovirtual bool removeChild( Node *child ) +
Remove Node from Group. +If Node is contained in Group then remove it from the child +list, decrement its reference count, and dirty the +bounding sphere to force it to recompute on next getBound() and +return true for success. If Node is not found then return false +and do not change the reference count of the Node. +

+ + +

ovirtual bool replaceChild( Node *origChild, Node* newChild ) +
Replace specified Node with another Node. +Decrement the reference count origNode and increments the +reference count of newNode, and dirty the bounding sphere +to force it to recompute on next getBound() and returns true. +If origNode is not found then return false and do not +add newNode. If newNode is NULL then return false and do +not remove origNode. +

+ + +

oint getNumChildren( void ) +
return the number of chilren nodes +

+ + +

oNode* getChild( int i ) +
return child node at position i +

+ + +

obool containsNode( Node* node ) +
return true is node is contained within Group +

+ + +

oChildList::iterator findNode( Node* node ) +
return the iterator postion for specified Node. +return _chilren.end() if node is not contained in Group. +

+ + +

ovirtual ~Group() +

+ + +

ovirtual bool readLocalData(Input& fr) +

+ + +

ovirtual bool writeLocalData(Output& fw) +

+ + +

oChildList _children +

+ + +

obool computeBound( void ) +

+
+
Direct child classes: +
Switch
+Sequence
+Scene
+LOD
+DCS
+
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osg/Scene.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osg/Scene.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osg/Scene.html (revision 2) @@ -0,0 +1,269 @@ + + + class SG_EXPORT osg::Scene + + + + +

class SG_EXPORT osg::Scene: public Group

+
The top level group node in a scene graph.
+
+ +

Inheritance:

+ + + + + + + +
+ +
+

+

Public Methods

+[more] Scene() +
+
+[more]virtual Object* clone() const +
+
+[more]virtual bool isSameKindAs(Object* obj) +
+
+[more]virtual const char* className() const +
+
+[more]virtual void accept(NodeVisitor& nv) +
+
+[more]void setGState(osg::GeoState* gstate) +
set the scene's GeoState +
+[more]osg::GeoState* getGState() +
return the scene's GeoState +

+ +

+

Protected Fields

+[more]osg::GeoState* _gstate +
+

+ +

+

Protected Methods

+[more]virtual ~Scene() +
+
+[more]virtual bool readLocalData(Input& fr) +
+
+[more]virtual bool writeLocalData(Output& fw) +
+

+ +
+

Inherited from Group:

+
+

+

Public Methods

+ovirtual void traverse(NodeVisitor& nv) +
+ovirtual bool addChild( Node *child ) +
+ovirtual bool removeChild( Node *child ) +
+ovirtual bool replaceChild( Node *origChild, Node* newChild ) +
+oint getNumChildren( void ) +
+oNode* getChild( int i ) +
+obool containsNode( Node* node ) +
+oChildList::iterator findNode( Node* node ) +

+ +

+

Public

+otypedef std::vector<ref_ptr<Node> > ChildList +

+ +

+

Protected Fields

+oChildList _children +

+ +

+

Protected Methods

+obool computeBound( void ) +

+ +
+

Inherited from Node:

+
+

+

Public Methods

+oNode* cloneNode() const +
+ovirtual void ascend(NodeVisitor& nv) +
+ovoid setName( const std::string& name ) +
+ovoid setName( const char* name ) +
+oconst std::string& getName( void ) +
+oconst ParentList& getParents() const +
+oGroup* getParent(int i) const +
+oint getNumParents() const +
+ovoid setUserData(void* data, MemoryAdapter* ma=0L) +
+ovoid* getUserData() const +
+oMemoryAdapter* getMemoryAdapter() const +
+ovoid setNodeMask(NodeMask nm) +
+oNodeMask getNodeMask() +
+oconst DescriptionList& getDescriptions() const +
+oDescriptionList& getDescriptions() +
+oconst std::string& getDescription(int i) const +
+ostd::string& getDescription(int i) +
+oint getNumDescriptions() const +
+ovoid addDescription(const std::string& desc) +
+oconst BoundingSphere& getBound() +
+ovoid dirtyBound() +

+ +

+

Public

+otypedef std::vector<Group*> ParentList +
+otypedef unsigned int NodeMask +
+otypedef std::vector<std::string> DescriptionList +

+ +

+

Protected Fields

+oBoundingSphere _bsphere +
+obool _bsphere_computed +
+ostd::string _name +
+oParentList _parents +
+ofriend Group +
+ovoid* _userData +
+oref_ptr<MemoryAdapter> _memoryAdapter +
+oNodeMask _nodeMask +
+oDescriptionList _descriptions +

+ +
+

Inherited from Object:

+
+

+

Public Methods

+ovirtual Object* readClone(Input& fr) +
+ovirtual bool write(Output& fw) +

+ +
+

Inherited from Referenced:

+
+

+

Public Methods

+oReferenced& operator = (Referenced&) +
+ovoid ref() +
+ovoid unref() +
+oint referenceCount() +

+ +

+

Protected Fields

+oint _refCount +

+ +
+ + +
+

Documentation

+
The top level group node in a scene graph.
+
+ + + +
o Scene() +

+ + +

ovirtual Object* clone() const +

+ + +

ovirtual bool isSameKindAs(Object* obj) +

+ + +

ovirtual const char* className() const +

+ + +

ovirtual void accept(NodeVisitor& nv) +

+ + +

ovoid setGState(osg::GeoState* gstate) +
set the scene's GeoState +

+ + +

oosg::GeoState* getGState() +
return the scene's GeoState +

+ + +

ovirtual ~Scene() +

+ + +

ovirtual bool readLocalData(Input& fr) +

+ + +

ovirtual bool writeLocalData(Output& fw) +

+ + +

oosg::GeoState* _gstate +

+ +
This class has no child classes.
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osg/osgGetVersion.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osg/osgGetVersion.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osg/osgGetVersion.html (revision 2) @@ -0,0 +1,30 @@ + + + extern SG_EXPORT const char* osgGetVersion + + + + +

extern SG_EXPORT const char* osgGetVersion()

+
getVersion_osg() returns the library version number.
+ + +
+

Documentation

+
+getVersion_osg() returns the library version number. +Numbering conventon : osg_src-0.8-31 will return 0.8.31 from getVersion_osg.

This C function can be also used to check for the existance of the OpenSceneGraph +library using autoconf and its m4 macro AC_CHECK_LIB.

Here is the code to add to your configure.in: +\verbatim +# +# Check for the OpenSceneGraph (OSG) library +# +AC_CHECK_LIB(osg, osgGetVersion, , +[AC_MSG_ERROR(OpenSceneGraph library not found. See http://www.openscenegraph.org)],) +\endverbatim

+
+
+

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osg/Material.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osg/Material.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osg/Material.html (revision 2) @@ -0,0 +1,424 @@ + + + class SG_EXPORT osg::Material + + + + +

class SG_EXPORT osg::Material: public Object

+
+ +

Inheritance:

+ + + + + + + +
+ +
+

+

Public Classes

+[more]enum MaterialFace +
+
+[more]enum ColorMode +
+

+ +

+

Public Methods

+[more] Material( void ) +
+
+[more]static Material* instance() +
+
+[more]virtual Object* clone() const +
+
+[more]virtual bool isSameKindAs(Object* obj) +
+
+[more]const char* className() const +
+
+[more]void apply( void ) +
+
+[more]void setColorMode(ColorMode mode) +
+
+[more]void setAmbient( MaterialFace face, const Vec4& ambient ) +
+
+[more]const Vec4& getAmbient(MaterialFace face) const +
+
+[more]bool getAmbientFrontAndBack() +
+
+[more]void setDiffuse( MaterialFace face, const Vec4& diffuse ) +
+
+[more]const Vec4& getDiffuse(MaterialFace face) const +
+
+[more]bool getDiffuseFrontAndBack() +
+
+[more]void setSpecular( MaterialFace face, const Vec4& specular ) +
+
+[more]const Vec4& getSpecular(MaterialFace face) const +
+
+[more]bool getSpecularFrontAndBack() +
+
+[more]void setEmission( MaterialFace face, const Vec4& emission ) +
+
+[more]const Vec4& getEmission(MaterialFace face) const +
+
+[more]bool getEmissionFrontAndBack() +
+
+[more]void setShininess( MaterialFace face, float shininess ) +
+
+[more]float getShininess(MaterialFace face) const +
+
+[more]bool getShininessFrontAndBack() +
+

+ +

+

Protected Fields

+[more]ColorMode _colorMode +
+
+[more]bool _ambientFrontAndBack +
+
+[more]Vec4 _ambientFront +
+
+[more]Vec4 _ambientBack +
+
+[more]bool _diffuseFrontAndBack +
+
+[more]Vec4 _diffuseFront +
+
+[more]Vec4 _diffuseBack +
+
+[more]bool _specularFrontAndBack +
+
+[more]Vec4 _specularFront +
+
+[more]Vec4 _specularBack +
+
+[more]bool _emissionFrontAndBack +
+
+[more]Vec4 _emissionFront +
+
+[more]Vec4 _emissionBack +
+
+[more]bool _shininessFrontAndBack +
+
+[more]float _shininessFront +
+
+[more]float _shininessBack +
+

+ +

+

Protected Methods

+[more]virtual ~Material( void ) +
+
+[more]virtual bool readLocalData(Input& fr) +
+
+[more]virtual bool writeLocalData(Output& fw) +
+
+[more]bool matchFaceAndColor(Input& fr, const char* name, MaterialFace& mf, Vec4& color) +
+

+ +
+

Inherited from Object:

+
+

+

Public Methods

+ovirtual Object* readClone(Input& fr) +
+ovirtual bool write(Output& fw) +

+ +
+

Inherited from Referenced:

+
+

+

Public Methods

+oReferenced& operator = (Referenced&) +
+ovoid ref() +
+ovoid unref() +
+oint referenceCount() +

+ +

+

Protected Fields

+oint _refCount +

+ +
+ + +
+

Documentation

+
+ + + +
oenum MaterialFace +

+ + + +
o FACE_FRONT +

+ + +

o FACE_BACK +

+ + +

o FACE_FRONT_AND_BACK +

+ + + +
oenum ColorMode +

+ + + +
o AMBIENT +

+ + +

o DIFFUSE +

+ + +

o SPECULAR +

+ + +

o EMISSION +

+ + +

o AMBIENT_AND_DIFFUSE +

+ + +

o OFF +

+ + + +
o Material( void ) +

+ + +

ostatic Material* instance() +

+ + +

ovirtual Object* clone() const +

+ + +

ovirtual bool isSameKindAs(Object* obj) +

+ + +

oconst char* className() const +

+ + +

ovoid apply( void ) +

+ + +

ovoid setColorMode(ColorMode mode) +

+ + +

ovoid setAmbient( MaterialFace face, const Vec4& ambient ) +

+ + +

oconst Vec4& getAmbient(MaterialFace face) const +

+ + +

obool getAmbientFrontAndBack() +

+ + +

ovoid setDiffuse( MaterialFace face, const Vec4& diffuse ) +

+ + +

oconst Vec4& getDiffuse(MaterialFace face) const +

+ + +

obool getDiffuseFrontAndBack() +

+ + +

ovoid setSpecular( MaterialFace face, const Vec4& specular ) +

+ + +

oconst Vec4& getSpecular(MaterialFace face) const +

+ + +

obool getSpecularFrontAndBack() +

+ + +

ovoid setEmission( MaterialFace face, const Vec4& emission ) +

+ + +

oconst Vec4& getEmission(MaterialFace face) const +

+ + +

obool getEmissionFrontAndBack() +

+ + +

ovoid setShininess( MaterialFace face, float shininess ) +

+ + +

ofloat getShininess(MaterialFace face) const +

+ + +

obool getShininessFrontAndBack() +

+ + +

ovirtual ~Material( void ) +

+ + +

ovirtual bool readLocalData(Input& fr) +

+ + +

ovirtual bool writeLocalData(Output& fw) +

+ + +

obool matchFaceAndColor(Input& fr, const char* name, MaterialFace& mf, Vec4& color) +

+ + +

oColorMode _colorMode +

+ + +

obool _ambientFrontAndBack +

+ + +

oVec4 _ambientFront +

+ + +

oVec4 _ambientBack +

+ + +

obool _diffuseFrontAndBack +

+ + +

oVec4 _diffuseFront +

+ + +

oVec4 _diffuseBack +

+ + +

obool _specularFrontAndBack +

+ + +

oVec4 _specularFront +

+ + +

oVec4 _specularBack +

+ + +

obool _emissionFrontAndBack +

+ + +

oVec4 _emissionFront +

+ + +

oVec4 _emissionBack +

+ + +

obool _shininessFrontAndBack +

+ + +

ofloat _shininessFront +

+ + +

ofloat _shininessBack +

+ +
This class has no child classes.
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osg/RenderVisitor.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osg/RenderVisitor.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osg/RenderVisitor.html (revision 2) @@ -0,0 +1,497 @@ + + + class SG_EXPORT osg::RenderVisitor + + + + +

class SG_EXPORT osg::RenderVisitor: public NodeVisitor

+
Basic visitor for rendering a scene.
+
+ +

Inheritance:

+ + + + + + + +
+ +
+

+

Public Classes

+[more]enum TransparencySortMode +
+
+[more]enum CullingType +
+

+ +

+

Public Methods

+[more] RenderVisitor() +
+
+[more]virtual ~RenderVisitor() +
+
+[more]void reset() +
+
+[more]virtual void apply(Node&) +
+
+[more]virtual void apply(Geode& node) +
+
+[more]virtual void apply(Billboard& node) +
+
+[more]virtual void apply(Group& node) +
+
+[more]virtual void apply(DCS& node) +
+
+[more]virtual void apply(Switch& node) +
+
+[more]virtual void apply(LOD& node) +
+
+[more]virtual void apply(Scene& node) +
+
+[more]void setGlobalState(GeoState* global) +
+
+[more]void setPerspective(float fovy, float aspect, float znear, float zfar) +
+
+[more]void setLookAt(const Vec3& eye, const Vec3& center, const Vec3& upVector) +
+
+[more]void setLookAt(double eyeX, double eyeY, double eyeZ, double centerX, double centerY, double centerZ, double upX, double upY, double upZ) +
+
+[more]void setLODBias(float bias) +
+
+[more]float getLODBias() +
+
+[more]void setTransparencySortMode(TransparencySortMode tsm) +
+
+[more]void setCullingActive(CullingType ct, bool active) +
+
+[more]bool getCullingActive(CullingType ct) +
+
+[more]bool calcNearFar(double& near_plane, double& far_plane) +
+
+[more]void render() +
+

+ +

+

Protected Fields

+[more]bool _viewFrustumCullingActive +
+
+[more]bool _smallFeatureCullingActive +
+
+[more]ViewStateStack _viewStateStack +
+
+[more]ViewState* _tvs +
+
+[more]ViewState* _cvs +
+
+[more]OpaqueList _opaqueGeoSets +
+
+[more]TransparentList _transparentGeoSets +
+
+[more]GeoState* _globalState +
+
+[more]float _LODBias +
+
+[more]float _fovy +
+
+[more]float _aspect +
+
+[more]float _znear +
+
+[more]float _zfar +
+
+[more]Vec3 _frustumTop +
+
+[more]Vec3 _frustumBottom +
+
+[more]Vec3 _frustumLeft +
+
+[more]Vec3 _frustumRight +
+
+[more]TransparencySortMode _tsm +
+

+ +

+

Protected Methods

+[more]void pushMatrix(const Matrix& matrix) +
+
+[more]void popMatrix() +
+
+[more]Matrix* getCurrentMatrix() +
+
+[more]Matrix* getInverseCurrentMatrix() +
+
+[more]const Vec3& getEyeLocal() +
+
+[more]const Vec3& getCenterLocal() +
+
+[more]const Vec3& getLookVectorLocal() +
+
+[more]bool isCulled(const BoundingSphere& sp) +
+
+[more]bool isCulled(const BoundingBox& bb) +
+
+[more]void calculateClippingPlanes() +
+

+ +

+

Protected

+[more]typedef std::pair<Matrix*,GeoSet*> MatrixGeoSet +
+
+[more]typedef std::vector<ViewState*> ViewStateStack +
+
+[more]typedef std::multimap<GeoState*,MatrixGeoSet> OpaqueList +
+
+[more]typedef std::multimap<float,MatrixGeoSet> TransparentList +
+

+ +
+

Inherited from NodeVisitor:

+
+

+

Public Classes

+oenum TraversalMode +

+ +

+

Public Methods

+ovoid setTraverseMode(TraversalMode mode) +
+oTraversalMode getTraverseMode() +
+ovoid setTraverseVisitor(NodeVisitor* nv) +
+oNodeVisitor* getTraverseVisitor() +
+ovoid traverse(Node& node) +

+ +

+

Protected Fields

+oNodeVisitor* _traverseVisitor +
+oTraversalMode _traverseMode +

+ +
+ + +
+

Documentation

+
Basic visitor for rendering a scene. +The visitor traverses the scene graph, collecting transparent +and opaque osg::GeoSet's into a depth sorted transparent bin +and a state sorted opaque bin. The opaque bin is rendered first, +and then the transparent bin in rendered in order from the furthest +osg::GeoSet from the eye to the one nearest the eye.
+
+ + + +
o RenderVisitor() +

+ + +

ovirtual ~RenderVisitor() +

+ + +

ovoid reset() +

+ + +

ovirtual void apply(Node&) +

+ + +

ovirtual void apply(Geode& node) +

+ + +

ovirtual void apply(Billboard& node) +

+ + +

ovirtual void apply(Group& node) +

+ + +

ovirtual void apply(DCS& node) +

+ + +

ovirtual void apply(Switch& node) +

+ + +

ovirtual void apply(LOD& node) +

+ + +

ovirtual void apply(Scene& node) +

+ + +

ovoid setGlobalState(GeoState* global) +

+ + +

ovoid setPerspective(float fovy, float aspect, float znear, float zfar) +

+ + +

ovoid setLookAt(const Vec3& eye, const Vec3& center, const Vec3& upVector) +

+ + +

ovoid setLookAt(double eyeX, double eyeY, double eyeZ, double centerX, double centerY, double centerZ, double upX, double upY, double upZ) +

+ + +

ovoid setLODBias(float bias) +

+ + +

ofloat getLODBias() +

+ + +

oenum TransparencySortMode +

+ + + +
o LOOK_VECTOR_DISTANCE +

+ + +

o OBJECT_EYE_POINT_DISTANCE +

+ + + +
ovoid setTransparencySortMode(TransparencySortMode tsm) +

+ + +

oenum CullingType +

+ + + +
o VIEW_FRUSTUM_CULLING +

+ + +

o SMALL_FEATURE_CULLING +

+ + + +
ovoid setCullingActive(CullingType ct, bool active) +

+ + +

obool getCullingActive(CullingType ct) +

+ + +

obool calcNearFar(double& near_plane, double& far_plane) +

+ + +

ovoid render() +

+ + +

ovoid pushMatrix(const Matrix& matrix) +

+ + +

ovoid popMatrix() +

+ + +

oMatrix* getCurrentMatrix() +

+ + +

oMatrix* getInverseCurrentMatrix() +

+ + +

oconst Vec3& getEyeLocal() +

+ + +

oconst Vec3& getCenterLocal() +

+ + +

oconst Vec3& getLookVectorLocal() +

+ + +

obool _viewFrustumCullingActive +

+ + +

obool _smallFeatureCullingActive +

+ + +

obool isCulled(const BoundingSphere& sp) +

+ + +

obool isCulled(const BoundingBox& bb) +

+ + +

otypedef std::pair<Matrix*,GeoSet*> MatrixGeoSet +

+ + +

otypedef std::vector<ViewState*> ViewStateStack +

+ + +

oViewStateStack _viewStateStack +

+ + +

oViewState* _tvs +

+ + +

oViewState* _cvs +

+ + +

otypedef std::multimap<GeoState*,MatrixGeoSet> OpaqueList +

+ + +

otypedef std::multimap<float,MatrixGeoSet> TransparentList +

+ + +

oOpaqueList _opaqueGeoSets +

+ + +

oTransparentList _transparentGeoSets +

+ + +

oGeoState* _globalState +

+ + +

ofloat _LODBias +

+ + +

ofloat _fovy +

+ + +

ofloat _aspect +

+ + +

ofloat _znear +

+ + +

ofloat _zfar +

+ + +

ovoid calculateClippingPlanes() +

+ + +

oVec3 _frustumTop +

+ + +

oVec3 _frustumBottom +

+ + +

oVec3 _frustumLeft +

+ + +

oVec3 _frustumRight +

+ + +

oTransparencySortMode _tsm +

+ +
This class has no child classes.
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osg/Vec3.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osg/Vec3.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osg/Vec3.html (revision 2) @@ -0,0 +1,263 @@ + + + class osg::Vec3 + + + + +

class osg::Vec3

+
General purpose float triple for use as vertices, vectors and normals.
+
+ +
+

+

Public Fields

+[more]float _v[3] +
+

+ +

+

Public Methods

+[more] Vec3() +
+
+[more] Vec3(float x, float y, float z) +
+
+[more]bool operator == (const Vec3& v) const +
+
+[more]inline float* ptr() +
+
+[more]inline const float* ptr() const +
+
+[more]inline void set( float x, float y, float z) +
+
+[more]inline float& operator [] (int i) +
+
+[more]inline float operator [] (int i) const +
+
+[more]inline float& x() +
+
+[more]inline float& y() +
+
+[more]inline float& z() +
+
+[more]inline float x() const +
+
+[more]inline float y() const +
+
+[more]inline float z() const +
+
+[more]inline float operator * (const Vec3& rhs) const +
dot product +
+[more]inline Vec3 operator ^ (const Vec3& rhs) const +
cross product +
+[more]inline Vec3 operator * (const float& rhs) const +
multiply by scalar +
+[more]inline Vec3& operator *= (const float& rhs) +
unary multiply by scalar +
+[more]inline Vec3 operator / (const float& rhs) const +
divide by scalar +
+[more]inline Vec3& operator /= (const float& rhs) +
unary divide by scalar +
+[more]inline Vec3 operator + (const Vec3& rhs) const +
binary vector add +
+[more]inline Vec3& operator += (const Vec3& rhs) +
unary vector add. +
+[more]inline Vec3 operator - (const Vec3& rhs) const +
binary vector subract +
+[more]inline Vec3& operator -= (const Vec3& rhs) +
unary vector subract +
+[more]inline Vec3 operator - () const +
negation operator. Returns the negative of the Vec3 +
+[more]inline float length( void ) const +
Length of the vector = sqrt( vec . vec ) +
+[more]inline float length2( void ) const +
Length squared of the vector = vec . vec +
+[more]inline float normalize() +
normalize the vector so that it has length unity returns the previous length of the vector +
+[more]inline friend ostream& operator << (ostream& output, const Vec3& vec) +
+

+ +
+ + +
+

Documentation

+
General purpose float triple for use as vertices, vectors and normals. +Provides general maths operations from addition through to cross products. +No support yet added for float * Vec3 - is it necessary? +Need to define a non-member non-friend operator* etc. +Vec3 * float is okay
+
+ + + +
o Vec3() +

+ + +

o Vec3(float x, float y, float z) +

+ + +

ofloat _v[3] +

+ + +

obool operator == (const Vec3& v) const +

+ + +

oinline float* ptr() +

+ + +

oinline const float* ptr() const +

+ + +

oinline void set( float x, float y, float z) +

+ + +

oinline float& operator [] (int i) +

+ + +

oinline float operator [] (int i) const +

+ + +

oinline float& x() +

+ + +

oinline float& y() +

+ + +

oinline float& z() +

+ + +

oinline float x() const +

+ + +

oinline float y() const +

+ + +

oinline float z() const +

+ + +

oinline float operator * (const Vec3& rhs) const +
dot product +

+ + +

oinline Vec3 operator ^ (const Vec3& rhs) const +
cross product +

+ + +

oinline Vec3 operator * (const float& rhs) const +
multiply by scalar +

+ + +

oinline Vec3& operator *= (const float& rhs) +
unary multiply by scalar +

+ + +

oinline Vec3 operator / (const float& rhs) const +
divide by scalar +

+ + +

oinline Vec3& operator /= (const float& rhs) +
unary divide by scalar +

+ + +

oinline Vec3 operator + (const Vec3& rhs) const +
binary vector add +

+ + +

oinline Vec3& operator += (const Vec3& rhs) +
unary vector add. Slightly more efficient because no temporary +intermediate object +

+ + +

oinline Vec3 operator - (const Vec3& rhs) const +
binary vector subract +

+ + +

oinline Vec3& operator -= (const Vec3& rhs) +
unary vector subract +

+ + +

oinline Vec3 operator - () const +
negation operator. Returns the negative of the Vec3 +

+ + +

oinline float length( void ) const +
Length of the vector = sqrt( vec . vec ) +

+ + +

oinline float length2( void ) const +
Length squared of the vector = vec . vec +

+ + +

oinline float normalize() +
normalize the vector so that it has length unity +returns the previous length of the vector +

+ + +

oinline friend ostream& operator << (ostream& output, const Vec3& vec) +

+ +
This class has no child classes.
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osg/Switch.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osg/Switch.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osg/Switch.html (revision 2) @@ -0,0 +1,295 @@ + + + class SG_EXPORT osg::Switch + + + + +

class SG_EXPORT osg::Switch: public Group

+
Switch - Group node which allows switching between children.
+
+ +

Inheritance:

+ + + + + + + +
+ +
+

+

Public Classes

+[more]enum SwitchType +
+

+ +

+

Public Methods

+[more] Switch() +
+
+[more]virtual Object* clone() const +
+
+[more]virtual bool isSameKindAs(Object* obj) +
+
+[more]virtual const char* className() const +
+
+[more]virtual void accept(NodeVisitor& nv) +
+
+[more]virtual void traverse(NodeVisitor& nv) +
+
+[more]void setVal(int val) +
+
+[more]int getVal() const +
+

+ +

+

Protected Fields

+[more]int _value +
+

+ +

+

Protected Methods

+[more]virtual ~Switch() +
+
+[more]virtual bool readLocalData(Input& fr) +
+
+[more]virtual bool writeLocalData(Output& fw) +
+

+ +
+

Inherited from Group:

+
+

+

Public Methods

+ovirtual bool addChild( Node *child ) +
+ovirtual bool removeChild( Node *child ) +
+ovirtual bool replaceChild( Node *origChild, Node* newChild ) +
+oint getNumChildren( void ) +
+oNode* getChild( int i ) +
+obool containsNode( Node* node ) +
+oChildList::iterator findNode( Node* node ) +

+ +

+

Public

+otypedef std::vector<ref_ptr<Node> > ChildList +

+ +

+

Protected Fields

+oChildList _children +

+ +

+

Protected Methods

+obool computeBound( void ) +

+ +
+

Inherited from Node:

+
+

+

Public Methods

+oNode* cloneNode() const +
+ovirtual void ascend(NodeVisitor& nv) +
+ovoid setName( const std::string& name ) +
+ovoid setName( const char* name ) +
+oconst std::string& getName( void ) +
+oconst ParentList& getParents() const +
+oGroup* getParent(int i) const +
+oint getNumParents() const +
+ovoid setUserData(void* data, MemoryAdapter* ma=0L) +
+ovoid* getUserData() const +
+oMemoryAdapter* getMemoryAdapter() const +
+ovoid setNodeMask(NodeMask nm) +
+oNodeMask getNodeMask() +
+oconst DescriptionList& getDescriptions() const +
+oDescriptionList& getDescriptions() +
+oconst std::string& getDescription(int i) const +
+ostd::string& getDescription(int i) +
+oint getNumDescriptions() const +
+ovoid addDescription(const std::string& desc) +
+oconst BoundingSphere& getBound() +
+ovoid dirtyBound() +

+ +

+

Public

+otypedef std::vector<Group*> ParentList +
+otypedef unsigned int NodeMask +
+otypedef std::vector<std::string> DescriptionList +

+ +

+

Protected Fields

+oBoundingSphere _bsphere +
+obool _bsphere_computed +
+ostd::string _name +
+oParentList _parents +
+ofriend Group +
+ovoid* _userData +
+oref_ptr<MemoryAdapter> _memoryAdapter +
+oNodeMask _nodeMask +
+oDescriptionList _descriptions +

+ +
+

Inherited from Object:

+
+

+

Public Methods

+ovirtual Object* readClone(Input& fr) +
+ovirtual bool write(Output& fw) +

+ +
+

Inherited from Referenced:

+
+

+

Public Methods

+oReferenced& operator = (Referenced&) +
+ovoid ref() +
+ovoid unref() +
+oint referenceCount() +

+ +

+

Protected Fields

+oint _refCount +

+ +
+ + +
+

Documentation

+
Switch - Group node which allows switching between children. +Typical uses would be for objects which might need to be rendered +differently at different times, for instance a switch could be used +to represent the different states of a traffic light.
+
+ + + +
oenum SwitchType +

+ + + +
o ALL_CHILDREN_ON +

+ + +

o ALL_CHILDREN_OFF +

+ + + +
o Switch() +

+ + +

ovirtual Object* clone() const +

+ + +

ovirtual bool isSameKindAs(Object* obj) +

+ + +

ovirtual const char* className() const +

+ + +

ovirtual void accept(NodeVisitor& nv) +

+ + +

ovirtual void traverse(NodeVisitor& nv) +

+ + +

ovoid setVal(int val) +

+ + +

oint getVal() const +

+ + +

ovirtual ~Switch() +

+ + +

ovirtual bool readLocalData(Input& fr) +

+ + +

ovirtual bool writeLocalData(Output& fw) +

+ + +

oint _value +

+ +
This class has no child classes.
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osg/Matrix.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osg/Matrix.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osg/Matrix.html (revision 2) @@ -0,0 +1,356 @@ + + + class SG_EXPORT osg::Matrix + + + + +

class SG_EXPORT osg::Matrix: public Object

+
4x4 Matrix for storage & manipulation of transformations in scene graph.
+
+ +

Inheritance:

+ + + + + + + +
+ +
+

+

Public Fields

+[more]float _mat[4][4] +
+

+ +

+

Public Methods

+[more] Matrix() +
+
+[more] Matrix(const Matrix& matrix) +
+
+[more] Matrix( float a00, float a01, float a02, float a03, float a10, float a11, float a12, float a13, float a20, float a21, float a22, float a23, float a30, float a31, float a32, float a33) +
+
+[more]Matrix& operator = (const Matrix& matrix) +
+
+[more]virtual ~Matrix() +
+
+[more]static Matrix* instance() +
+
+[more]virtual Object* clone() const +
+
+[more]virtual bool isSameKindAs(Object* obj) +
+
+[more]virtual const char* className() const +
+
+[more]void makeIdent() +
+
+[more]void set(const float* m) +
+
+[more]void copy(const Matrix& matrix) +
+
+[more]void makeScale(float sx, float sy, float sz) +
+
+[more]void preScale( float sx, float sy, float sz, const Matrix& m ) +
+
+[more]void postScale( const Matrix& m, float sx, float sy, float sz ) +
+
+[more]void preScale( float sx, float sy, float sz ) +
+
+[more]void postScale( float sx, float sy, float sz ) +
+
+[more]void makeTrans( float tx, float ty, float tz ) +
+
+[more]void preTrans( float tx, float ty, float tz, const Matrix& m ) +
+
+[more]void postTrans( const Matrix& m, float tx, float ty, float tz ) +
+
+[more]void preTrans( float tx, float ty, float tz ) +
+
+[more]void postTrans( float tx, float ty, float tz ) +
+
+[more]void makeRot( float deg, float x, float y, float z ) +
+
+[more]void preRot( float deg, float x, float y, float z, const Matrix& m ) +
+
+[more]void postRot( const Matrix& m, float deg, float x, float y, float z ) +
+
+[more]void preRot( float deg, float x, float y, float z ) +
+
+[more]void postRot( float deg, float x, float y, float z ) +
+
+[more]void setTrans( float tx, float ty, float tz ) +
+
+[more]void setTrans( const Vec3& v ) +
+
+[more]Vec3 getTrans() const +
+
+[more]void preMult(const Matrix& m) +
+
+[more]void postMult(const Matrix& m) +
+
+[more]void mult(const Matrix& lhs, const Matrix& rhs) +
+
+[more]Matrix operator * (const Matrix& m) const +
+
+[more]inline Vec3 operator * (const Vec3& v) const +
+
+[more]inline friend Vec3 operator * (const Vec3& v, const Matrix& m) +
+
+[more]bool invert(const Matrix& m) +
+

+ +

+

Protected Methods

+[more]virtual bool readLocalData(Input& fr) +
+
+[more]virtual bool writeLocalData(Output& fw) +
+

+ +
+

Inherited from Object:

+
+

+

Public Methods

+ovirtual Object* readClone(Input& fr) +
+ovirtual bool write(Output& fw) +

+ +
+

Inherited from Referenced:

+
+

+

Public Methods

+ovoid ref() +
+ovoid unref() +
+oint referenceCount() +

+ +

+

Protected Fields

+oint _refCount +

+ +
+ + +
+

Documentation

+
4x4 Matrix for storage & manipulation of transformations in scene graph. +Provides basic maths operations, IO and via osg::Object reference counting.
+
+ + + +
o Matrix() +

+ + +

o Matrix(const Matrix& matrix) +

+ + +

o Matrix( float a00, float a01, float a02, float a03, float a10, float a11, float a12, float a13, float a20, float a21, float a22, float a23, float a30, float a31, float a32, float a33) +

+ + +

oMatrix& operator = (const Matrix& matrix) +

+ + +

ovirtual ~Matrix() +

+ + +

ostatic Matrix* instance() +

+ + +

ovirtual Object* clone() const +

+ + +

ovirtual bool isSameKindAs(Object* obj) +

+ + +

ovirtual const char* className() const +

+ + +

ovoid makeIdent() +

+ + +

ovoid set(const float* m) +

+ + +

ovoid copy(const Matrix& matrix) +

+ + +

ovoid makeScale(float sx, float sy, float sz) +

+ + +

ovoid preScale( float sx, float sy, float sz, const Matrix& m ) +

+ + +

ovoid postScale( const Matrix& m, float sx, float sy, float sz ) +

+ + +

ovoid preScale( float sx, float sy, float sz ) +

+ + +

ovoid postScale( float sx, float sy, float sz ) +

+ + +

ovoid makeTrans( float tx, float ty, float tz ) +

+ + +

ovoid preTrans( float tx, float ty, float tz, const Matrix& m ) +

+ + +

ovoid postTrans( const Matrix& m, float tx, float ty, float tz ) +

+ + +

ovoid preTrans( float tx, float ty, float tz ) +

+ + +

ovoid postTrans( float tx, float ty, float tz ) +

+ + +

ovoid makeRot( float deg, float x, float y, float z ) +

+ + +

ovoid preRot( float deg, float x, float y, float z, const Matrix& m ) +

+ + +

ovoid postRot( const Matrix& m, float deg, float x, float y, float z ) +

+ + +

ovoid preRot( float deg, float x, float y, float z ) +

+ + +

ovoid postRot( float deg, float x, float y, float z ) +

+ + +

ovoid setTrans( float tx, float ty, float tz ) +

+ + +

ovoid setTrans( const Vec3& v ) +

+ + +

oVec3 getTrans() const +

+ + +

ovoid preMult(const Matrix& m) +

+ + +

ovoid postMult(const Matrix& m) +

+ + +

ovoid mult(const Matrix& lhs, const Matrix& rhs) +

+ + +

oMatrix operator * (const Matrix& m) const +

+ + +

oinline Vec3 operator * (const Vec3& v) const +

+ + +

oinline friend Vec3 operator * (const Vec3& v, const Matrix& m) +

+ + +

obool invert(const Matrix& m) +

+ + +

ofloat _mat[4][4] +

+ + +

ovirtual bool readLocalData(Input& fr) +

+ + +

ovirtual bool writeLocalData(Output& fw) +

+
+
Direct child classes: +
TexMat
+
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osg/NodeVisitor.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osg/NodeVisitor.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osg/NodeVisitor.html (revision 2) @@ -0,0 +1,241 @@ + + + class SG_EXPORT osg::NodeVisitor + + + + +

class SG_EXPORT osg::NodeVisitor: public Referenced

+
Visitor for type safe operations on osg::Node's.
+
+ +

Inheritance:

+ + + + + + + +
+ +
+

+

Public Classes

+[more]enum TraversalMode +
+

+ +

+

Public Methods

+[more] NodeVisitor(TraversalMode tm=TRAVERSE_NONE) +
+
+[more]virtual ~NodeVisitor() +
+
+[more]void setTraverseMode(TraversalMode mode) +
Set the traversal mode for Node::traverse() to use when deciding which children of a node to traverse. +
+[more]TraversalMode getTraverseMode() +
Get the traversal mode +
+[more]void setTraverseVisitor(NodeVisitor* nv) +
Set a visitor to handle traversal. +
+[more]NodeVisitor* getTraverseVisitor() +
Get the traverse visitor, returns NULL if none is attached +
+[more]void traverse(Node& node) +
Inline method for passing handling traversal of a nodes. +
+[more]virtual void apply(Node& node) +
+
+[more]virtual void apply(Geode& node) +
+
+[more]virtual void apply(Billboard& node) +
+
+[more]virtual void apply(LightSource& node) +
+
+[more]virtual void apply(Group& node) +
+
+[more]virtual void apply(DCS& node) +
+
+[more]virtual void apply(Switch& node) +
+
+[more]virtual void apply(Sequence& node) +
+
+[more]virtual void apply(LOD& node) +
+
+[more]virtual void apply(Scene& node) +
+

+ +

+

Protected Fields

+[more]NodeVisitor* _traverseVisitor +
+
+[more]TraversalMode _traverseMode +
+

+ +
+

Inherited from Referenced:

+
+

+

Public Methods

+oReferenced& operator = (Referenced&) +
+ovoid ref() +
+ovoid unref() +
+oint referenceCount() +

+ +

+

Protected Fields

+oint _refCount +

+ +
+ + +
+

Documentation

+
Visitor for type safe operations on osg::Node's. +Based on GOF's Visitor pattern.
+
+ + + +
oenum TraversalMode +

+ + + +
o TRAVERSE_NONE +

+ + +

o TRAVERSE_PARENTS +

+ + +

o TRAVERSE_ALL_CHILDREN +

+ + +

o TRAVERSE_ACTIVE_CHILDREN +

+ + +

o TRAVERSE_VISITOR +

+ + + +
o NodeVisitor(TraversalMode tm=TRAVERSE_NONE) +

+ + +

ovirtual ~NodeVisitor() +

+ + +

ovoid setTraverseMode(TraversalMode mode) +
Set the traversal mode for Node::traverse() to use when +deciding which children of a node to traverse. If a +NodeVisitor has been attached via setTraverseVisitor() +and the new mode is not TRAVERSE_VISITOR then the attached +visitor is detached. Default mode is TRAVERSE_NONE. +

+ + +

oTraversalMode getTraverseMode() +
Get the traversal mode +

+ + +

ovoid setTraverseVisitor(NodeVisitor* nv) +
Set a visitor to handle traversal. +Overides the traverse mode setting it to TRAVERSE_VISITOR. +

+ + +

oNodeVisitor* getTraverseVisitor() +
Get the traverse visitor, returns NULL if none is attached +

+ + +

ovoid traverse(Node& node) +
Inline method for passing handling traversal of a nodes. +If you intend to use the visitor for actively traversing +the scene graph then make sure the accept() methods call +this method unless they handle traversal directly. +

+ + +

ovirtual void apply(Node& node) +

+ + +

ovirtual void apply(Geode& node) +

+ + +

ovirtual void apply(Billboard& node) +

+ + +

ovirtual void apply(LightSource& node) +

+ + +

ovirtual void apply(Group& node) +

+ + +

ovirtual void apply(DCS& node) +

+ + +

ovirtual void apply(Switch& node) +

+ + +

ovirtual void apply(Sequence& node) +

+ + +

ovirtual void apply(LOD& node) +

+ + +

ovirtual void apply(Scene& node) +

+ + +

oNodeVisitor* _traverseVisitor +

+ + +

oTraversalMode _traverseMode +

+ +
This class has no child classes.
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osg/Transparency.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osg/Transparency.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osg/Transparency.html (revision 2) @@ -0,0 +1,220 @@ + + + class SG_EXPORT osg::Transparency + + + + +

class SG_EXPORT osg::Transparency: public Object

+
+ +

Inheritance:

+ + + + + + + +
+ +
+

+

Public Classes

+[more]enum TransparencyMode +
+

+ +

+

Public Methods

+[more] Transparency() +
+
+[more]static Transparency* instance() +
+
+[more]virtual Object* clone() const +
+
+[more]virtual bool isSameKindAs(Object* obj) +
+
+[more]virtual const char* className() const +
+
+[more]void setFunction( int source, int destination ) +
+
+[more]static void enable( void ) +
+
+[more]static void disable( void ) +
+
+[more]void apply( void ) +
+

+ +

+

Protected Fields

+[more]int _source_factor +
+
+[more]int _destination_factor +
+

+ +

+

Protected Methods

+[more]virtual ~Transparency() +
+

+ +
+

Inherited from Object:

+
+

+

Public Methods

+ovirtual Object* readClone(Input& fr) +
+ovirtual bool write(Output& fw) +

+ +

+

Protected Methods

+ovirtual bool readLocalData(Input&) +
+ovirtual bool writeLocalData(Output&) +

+ +
+

Inherited from Referenced:

+
+

+

Public Methods

+oReferenced& operator = (Referenced&) +
+ovoid ref() +
+ovoid unref() +
+oint referenceCount() +

+ +

+

Protected Fields

+oint _refCount +

+ +
+ + +
+

Documentation

+
+ + + +
oenum TransparencyMode +

+ + + +
o DST_ALPHA +

+ + +

o DST_COLOR +

+ + +

o ONE +

+ + +

o ONE_MINUS_DST_ALPHA +

+ + +

o ONE_MINUS_DST_COLOR +

+ + +

o ONE_MINUS_SRC_ALPHA +

+ + +

o ONE_MINUS_SRC_COLOR +

+ + +

o SRC_ALPHA +

+ + +

o SRC_ALPHA_SATURATE +

+ + +

o SRC_COLOR +

+ + +

o ZERO +

+ + + +
o Transparency() +

+ + +

ostatic Transparency* instance() +

+ + +

ovirtual Object* clone() const +

+ + +

ovirtual bool isSameKindAs(Object* obj) +

+ + +

ovirtual const char* className() const +

+ + +

ovoid setFunction( int source, int destination ) +

+ + +

ostatic void enable( void ) +

+ + +

ostatic void disable( void ) +

+ + +

ovoid apply( void ) +

+ + +

ovirtual ~Transparency() +

+ + +

oint _source_factor +

+ + +

oint _destination_factor +

+ +
This class has no child classes.
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osg/ViewState.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osg/ViewState.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osg/ViewState.html (revision 2) @@ -0,0 +1,185 @@ + + + class SG_EXPORT osg::ViewState + + + + +

class SG_EXPORT osg::ViewState: public Referenced

+
Container class for encapsulating the viewing state in local coordinates, during the cull traversal
+
+ +

Inheritance:

+ + + + + + + +
+ +
+

+

Public Fields

+[more]Matrix* _matrix +
+
+[more]Matrix* _inverse +
+
+[more]Vec3 _eyePoint +
+
+[more]Vec3 _centerPoint +
+
+[more]Vec3 _lookVector +
+
+[more]Vec3 _upVector +
+
+[more]Vec3 _frustumTopNormal +
+
+[more]Vec3 _frustumBottomNormal +
+
+[more]Vec3 _frustumLeftNormal +
+
+[more]Vec3 _frustumRightNormal +
+
+[more]float _ratio +
+
+[more]bool _viewFrustumCullingActive +
+
+[more]bool _smallFeatureCullingActive +
+

+ +

+

Public Methods

+[more] ViewState() +
+
+[more]bool isCulled(const BoundingSphere& sp) +
+
+[more]bool isCulled(const BoundingBox& bb) +
+

+ +

+

Protected Methods

+[more] ~ViewState() +
+

+ +
+

Inherited from Referenced:

+
+

+

Public Methods

+oReferenced& operator = (Referenced&) +
+ovoid ref() +
+ovoid unref() +
+oint referenceCount() +

+ +

+

Protected Fields

+oint _reference +

+ +
+ + +
+

Documentation

+
Container class for encapsulating the viewing state in local +coordinates, during the cull traversal
+
+ + + +
o ViewState() +

+ + +

oMatrix* _matrix +

+ + +

oMatrix* _inverse +

+ + +

oVec3 _eyePoint +

+ + +

oVec3 _centerPoint +

+ + +

oVec3 _lookVector +

+ + +

oVec3 _upVector +

+ + +

oVec3 _frustumTopNormal +

+ + +

oVec3 _frustumBottomNormal +

+ + +

oVec3 _frustumLeftNormal +

+ + +

oVec3 _frustumRightNormal +

+ + +

ofloat _ratio +

+ + +

obool _viewFrustumCullingActive +

+ + +

obool _smallFeatureCullingActive +

+ + +

obool isCulled(const BoundingSphere& sp) +

+ + +

obool isCulled(const BoundingBox& bb) +

+ + +

o ~ViewState() +

+ +
This class has no child classes.
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osg/General.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osg/General.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osg/General.html (revision 2) @@ -0,0 +1,489 @@ + + + General Bits + + + + +
+
+ +o#define +OSG_ALPHAFUNC
+
+ +o +
+
+ +o#define +OSG_BILLBOARD
+
+ +o +
+
+ +o#define +OSG_BOUNDINGBOX
+
+ +o +
+
+ +o#define +OSG_BOUNDINGSPHERE
+
+ +o +
+
+ +o#define +OSG_CAMERA
+
+ +o#define +OSG_CULLFACE
+
+ +o +
+
+ +o#define +OSG_DCS
+
+ +o +
+
+ +o#define +OSG_DYNAMICLIBRARY
+
+ +o +
+
+ +o#define +OSG_EXPORT
+
+ +o#define +NULL
+
+ +o#define +NULL((void *)
+
+ +o#define +SG_EXPORT(dllexport)
+
+ +o#define +SG_EXPORT(dllimport)
+
+ +o#define +OSG_EXTENSIONSUPPORTED
+
+ +o +
+
+ +o#define +OSG_FIELD
+
+ +o +
+
+ +o#define +OSG_FIELDREADER
+
+ +o +
+
+ +o#define +OSG_FIELDREADERITERATOR
+
+ +o +
+
+ +o#define +OSG_FILENAMEUTILS
+
+ +o +
+
+ +o#define +OSG_FOG
+
+ +o +
+
+ +o#define +OSG_GL
+
+ +o#define +WIN32_LEAN_AND_MEAN
+
+ +o#define +GLUT_APIENTRY_DEFINED
+
+ +o#define +APIENTRY
+
+ +o#define +APIENTRY
+
+ +o#define +CALLBACK
+
+ +o#define +CALLBACK
+
+ +o#define +GLUT_WINGDIAPI_DEFINED
+
+ +o#define +WINGDIAPI(dllimport)
+
+ +otypedef unsigned short +wchar_t
+
+ +o#define +_WCHAR_T_DEFINED
+
+ +o#define +GL_GLEXT_LEGACY
+
+ +o#define +OSG_GEOSET
+
+ +o +
+
+ +o#define +OSG_GEOSTATE
+
+ +o +
+
+ +o#define +OSG_GEODE
+
+ +o +
+
+ +o#define +OSG_GROUP
+
+ +o +
+
+ +o#define +OSG_IMAGE
+
+ +o +
+
+ +o#define +OSG_INPUT
+
+ +o +
+
+ +o#define +OSG_LOD
+
+ +o +
+
+ +o#define +OSG_LIGHT
+
+ +o +
+
+ +o#define +OSG_LIGHTSOURCE
+
+ +o +
+
+ +o#define +OSG_LIGHTING
+
+ +o +
+
+ +o#define +OSG_MATERIAL
+
+ +o +
+
+ +o#define +OSG_MATRIX
+
+ +o +
+
+ +o#define +OSG_NODE
+
+ +o +
+
+ +o#define +OSG_NODEVISITOR
+
+ +o +
+
+ +o#define +OSG_NOTIFY
+
+ +o +
+
+ +o#define +OSG_OSG
+
+ +o +
+
+ +o#define +OSG_OBJECT
+
+ +o +
+
+ +o#define +OSG_OUTPUT
+
+ +o +
+
+ +o#define +OSG_POINT
+
+ +o +
+
+ +o#define +OSG_POLYGONOFFSET
+
+ +o +
+
+ +o#define +OSG_QUAT
+
+ +o +
+
+ +o#define +OSG_REFERENCED
+
+ +o +
+
+ +o#define +OSG_REGISTRY
+
+ +o +
+
+ +o#define +OSG_SCENE
+
+ +o +
+
+ +o#define +OSG_SEG
+
+ +o +
+
+ +o#define +OSG_SEQUENCE
+
+ +o +
+
+ +o#define +OSG_STATE
+
+ +o +
+
+ +o#define +OSG_SWITCH
+
+ +o +
+
+ +o#define +OSG_TEXENV
+
+ +o +
+
+ +o#define +OSG_TEXGEN
+
+ +o +
+
+ +o#define +OSG_TEXMAT
+
+ +o +
+
+ +o#define +OSG_TEXTURE
+
+ +o +
+
+ +o#define +OSG_TIMER
+
+ +o +
+
+ +o#define +OSG_TRANSPARENCY
+
+ +o +
+
+ +o#define +OSG_TYPES
+
+ +o +
+
+ +o#define +OSG_VEC2
+
+ +o#define +OSG_VEC3
+
+ +o#define +OSG_VEC4
+
+ +o#define +OSG_VERSION
+
+ +o +
+
+Alphabetic index Hierarchy of classes

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osg/osgGetLibraryName.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osg/osgGetLibraryName.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osg/osgGetLibraryName.html (revision 2) @@ -0,0 +1,21 @@ + + + extern SG_EXPORT const char* osgGetLibraryName + + + + +

extern SG_EXPORT const char* osgGetLibraryName()

+
getLibraryName_osg() returns the library name in human friendly form
+ + +
+

Documentation

+
+getLibraryName_osg() returns the library name in human friendly form
+
+
+

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osg/UnrefOp.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osg/UnrefOp.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osg/UnrefOp.html (revision 2) @@ -0,0 +1,32 @@ + + + template<class T> struct osg::UnrefOp + + + + +

template<class T> struct osg::UnrefOp

+
Convience functor for unreferencing objects
+ +
+

+
+[more]void operator () (T* node) +
+

+ + + +
+

Documentation

+
Convience functor for unreferencing objects
+
+ + + +
ovoid operator () (T* node) +

+

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osg/Seg.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osg/Seg.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osg/Seg.html (revision 2) @@ -0,0 +1,210 @@ + + + class SG_EXPORT osg::Seg + + + + +

class SG_EXPORT osg::Seg: public Referenced

+
Segment class for representing a line segment
+
+ +

Inheritance:

+ + + + + + + +
+ +
+

+

Public Methods

+[more] Seg() +
+
+[more] Seg(const Seg& seg) +
+
+[more] Seg(const Vec3& s, const Vec3& e) +
+
+[more]virtual ~Seg() +
+
+[more]Seg& operator = (const Seg& seg) +
+
+[more]void set(const Vec3& s, const Vec3& e) +
+
+[more]const Vec3& start() const +
+
+[more]Vec3& start() +
+
+[more]const Vec3& end() const +
+
+[more]Vec3& end() +
+
+[more]bool intersect(const BoundingBox& bb) const +
return true if segment intersects BoundingBox +
+[more]bool intersect(const BoundingBox& bb, float& r1, float& r2) const +
return true if segment intersects BoundingSphere and return the intersection ratio's +
+[more]bool intersect(const BoundingSphere& bs) const +
return true if segment intersects BoundingSphere +
+[more]bool intersect(const BoundingSphere& bs, float& r1, float& r2) const +
return true if segment intersects BoundingSphere and return the intersection ratio's +
+[more]bool intersect(const Vec3& v1, const Vec3& v2, const Vec3& v3, float& r) +
return true if segment intersects triangle and set ratio long segment. +
+[more]void mult(const Seg& seg, const Matrix& m) +
post multiply a segment by matrix +
+[more]void mult(const Matrix& m, const Seg& seg) +
pre multiply a segment by matrix +

+ +

+

Protected Fields

+[more]Vec3 _s +
+
+[more]Vec3 _e +
+

+ +

+

Protected Methods

+[more]static bool intersectAndClip(Vec3& s, Vec3& e, const BoundingBox& bb) +
+

+ +
+

Inherited from Referenced:

+
+

+

Public Methods

+ovoid ref() +
+ovoid unref() +
+oint referenceCount() +

+ +

+

Protected Fields

+oint _refCount +

+ +
+ + +
+

Documentation

+
Segment class for representing a line segment
+
+ + + +
o Seg() +

+ + +

o Seg(const Seg& seg) +

+ + +

o Seg(const Vec3& s, const Vec3& e) +

+ + +

ovirtual ~Seg() +

+ + +

oSeg& operator = (const Seg& seg) +

+ + +

ovoid set(const Vec3& s, const Vec3& e) +

+ + +

oconst Vec3& start() const +

+ + +

oVec3& start() +

+ + +

oconst Vec3& end() const +

+ + +

oVec3& end() +

+ + +

obool intersect(const BoundingBox& bb) const +
return true if segment intersects BoundingBox +

+ + +

obool intersect(const BoundingBox& bb, float& r1, float& r2) const +
return true if segment intersects BoundingSphere and return the intersection ratio's +

+ + +

obool intersect(const BoundingSphere& bs) const +
return true if segment intersects BoundingSphere +

+ + +

obool intersect(const BoundingSphere& bs, float& r1, float& r2) const +
return true if segment intersects BoundingSphere and return the intersection ratio's +

+ + +

obool intersect(const Vec3& v1, const Vec3& v2, const Vec3& v3, float& r) +
return true if segment intersects triangle and set ratio long segment. +

+ + +

ovoid mult(const Seg& seg, const Matrix& m) +
post multiply a segment by matrix +

+ + +

ovoid mult(const Matrix& m, const Seg& seg) +
pre multiply a segment by matrix +

+ + +

ostatic bool intersectAndClip(Vec3& s, Vec3& e, const BoundingBox& bb) +

+ + +

oVec3 _s +

+ + +

oVec3 _e +

+ +
This class has no child classes.
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osg/State.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osg/State.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osg/State.html (revision 2) @@ -0,0 +1,42 @@ + + + class SG_EXPORT osg::State + + + + +

class SG_EXPORT osg::State

+
+ +
+

+

Public Methods

+[more] State( void ) +
+
+[more] ~State( void ) +
+

+ +
+ + +
+

Documentation

+
+ + + +
o State( void ) +

+ + +

o ~State( void ) +

+ +
This class has no child classes.
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osg/Timer.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osg/Timer.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osg/Timer.html (revision 2) @@ -0,0 +1,91 @@ + + + class SG_EXPORT osg::Timer + + + + +

class SG_EXPORT osg::Timer

+
+ +
+

+

Public Methods

+[more] Timer( void ) +
+
+[more] ~Timer( void ) +
+
+[more]inline Timer_t tick( void ) +
+
+[more]pragmaoptimize("", on)(x) (".byte 0x0f, 0x31" : "=A" (x))( void ) +
+
+[more]ifdefinline __sgi Timer_t tick( void ) +
+
+[more]double delta_s( Timer_t t1, Timer_t t2 ) +
+
+[more]double delta_m( Timer_t t1, Timer_t t2 ) +
+
+[more]Timer_t delta_u( Timer_t t1, Timer_t t2 ) +
+
+[more]Timer_t delta_n( Timer_t t1, Timer_t t2 ) +
+

+ +
+ + +
+

Documentation

+
+ + + +
o Timer( void ) +

+ + +

o ~Timer( void ) +

+ + +

oinline Timer_t tick( void ) +

+ + +

opragmaoptimize("", on)(x) (".byte 0x0f, 0x31" : "=A" (x))( void ) +

+ + +

oifdefinline __sgi Timer_t tick( void ) +

+ + +

odouble delta_s( Timer_t t1, Timer_t t2 ) +

+ + +

odouble delta_m( Timer_t t1, Timer_t t2 ) +

+ + +

oTimer_t delta_u( Timer_t t1, Timer_t t2 ) +

+ + +

oTimer_t delta_n( Timer_t t1, Timer_t t2 ) +

+ +
This class has no child classes.
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osg/Hit.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osg/Hit.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osg/Hit.html (revision 2) @@ -0,0 +1,173 @@ + + + class SG_EXPORT osg::Hit + + + + +

class SG_EXPORT osg::Hit: public Referenced

+
+ +

Inheritance:

+ + + + + + + +
+ +
+

+

Public Fields

+[more]float _ratio +
+
+[more]Seg* _originalSeg +
+
+[more]Seg* _localSeg +
+
+[more]NodePath _nodePath +
+
+[more]Geode* _geode +
+
+[more]GeoSet* _geoset +
+
+[more]Matrix* _matrix +
+
+[more]VecIndexList _vecIndexList +
+
+[more]int _primitiveIndex +
+
+[more]Vec3 _intersectPoint +
+

+ +

+

Public Methods

+[more] Hit() +
+
+[more] Hit(const Hit& hit) +
+
+[more] ~Hit() +
+
+[more]Hit& operator = (const Hit& hit) +
+
+[more]bool operator < (const Hit& hit) const +
+

+ +

+

Public

+[more]typedef std::vector<int> VecIndexList +
+

+ +
+

Inherited from Referenced:

+
+

+

Public Methods

+ovoid ref() +
+ovoid unref() +
+oint referenceCount() +

+ +

+

Protected Fields

+oint _reference +

+ +
+ + +
+

Documentation

+
+ + + +
o Hit() +

+ + +

o Hit(const Hit& hit) +

+ + +

o ~Hit() +

+ + +

oHit& operator = (const Hit& hit) +

+ + +

otypedef std::vector<int> VecIndexList +

+ + +

obool operator < (const Hit& hit) const +

+ + +

ofloat _ratio +

+ + +

oSeg* _originalSeg +

+ + +

oSeg* _localSeg +

+ + +

oNodePath _nodePath +

+ + +

oGeode* _geode +

+ + +

oGeoSet* _geoset +

+ + +

oMatrix* _matrix +

+ + +

oVecIndexList _vecIndexList +

+ + +

oint _primitiveIndex +

+ + +

oVec3 _intersectPoint +

+ +
This class has no child classes.
+ +

Alphabetic index HTML hierarchy of classes or Java

+
+This page was generated with the help of DOC++. + Index: /OpenSceneGraph/tags/osg_8_34/doc/osg/Point.html =================================================================== --- /OpenSceneGraph/tags/osg_8_34/doc/osg/Point.html (revision 2) +++ /OpenSceneGraph/tags/osg_8_34/doc/osg/Point.html (revision 2) @@ -0,0 +1,199 @@ + + + class SG_EXPORT osg::Point + + + + +

class SG_EXPORT osg::Point: public Object

+
+ +

Inheritance:

+ + + + + +