| osgIntrospection::AbstractObjectReflector< T > | This reflector is to be used to describe abstract types that can't be instantiated |
| osgParticle::AccelOperator | An operator class that applies a constant acceleration to the particles |
| osg::AlphaFunc | Encapsulates OpenGL glAlphaFunc |
| osgParticle::AngularAccelOperator | An operator class that applies a constant angular acceleration to the particles |
| osg::AnimationPath | AnimationPath encapsulates a time varying transformation pathway |
| osg::AnimationPath::ControlPoint | |
| osg::AnimationPathCallback | |
| osgGA::AnimationPathManipulator | |
| osgFX::AnisotropicLighting | This single-pass effect implements a sort of anisotropic lighting that replaces the standard OpenGL lighting model |
| osgManipulator::AntiSquish | Class that performs the Anti Squish by making the scaling uniform along all axes |
| osg::ApplicationUsage | |
| osg::ApplicationUsageProxy | |
| osgDB::Archive | Base class for implementing database Archives |
| osg::ArgumentParser | |
| osg::ArgumentParser::Parameter | |
| osg::ArgumentParser::Parameter::ValueUnion | |
| osg::Array | |
| osg::ArrayVisitor | |
| osgIntrospection::AtomicValueReflector< T > | This reflector is a ValueReflector that should be used to define types that can be read and written from/to streams using the << and >> operators |
| osg::AutoTransform | AutoTransform is a derived form of Transform that automatically scales or rotates to keep its children aligned with screen coordinates |
| osgSim::AzimElevationSector | |
| osgSim::AzimRange | |
| osgSim::AzimSector | |
| osg::BarrierOperation | BarrierOperation allows one to syncronize multiple GraphicsThreads with each other |
| osgUtil::BaseOptimizerVisitor | Helper base class for implementing Optimizer techniques |
| BaseTypeConverters< x, reflected_type, polymorphic > | |
| BaseTypeConverters< x, reflected_type, true > | |
| osgDB::basic_type_wrapper | Basic structure for custom runtime inheritance checking |
| osg::Billboard | Billboard is a derived form of Geode that orients its osg::Drawable children to face the eye point |
| osg::BlendColor | Encapsulates OpenGL blend/transparency state |
| osg::BlendColor::Extensions | Encapsulates queries of extension availability, obtains extension function pointers, and provides convinience wrappers for calling extension functions |
| osg::BlendEquation | Encapsulates OpenGL BlendEquation state |
| osg::BlendEquation::Extensions | Encapsulates queries of extension availability, obtains extension function pointers, and provides convinience wrappers for calling extension functions |
| osg::BlendFunc | Encapsulates OpenGL blend/transparency state |
| osg::BlendFunc::Extensions | Encapsulates queries of extension availability, obtains extension function pointers, and provides convenience wrappers for calling extension functions |
| osgSim::BlinkSequence | |
| osg::BlockAndFlushOperation | |
| osg::BoundingBox | General purpose axis-aligned bounding box class for enclosing objects/vertices |
| osg::BoundingSphere | General purpose bounding sphere class for enclosing nodes/objects/vertices |
| osg::Box | |
| osgParticle::BoxPlacer | A sector-shaped particle placer |
| osg::buffered_object< T > | |
| osg::buffered_value< T > | Implements a simple buffered value for values that need to be buffered on a per graphics context basis |
| osg::BufferObject | |
| osg::BufferObject::BufferEntry | |
| osg::BufferObject::Extensions | Extensions class which encapsulates the querying of extensions and associated function pointers, and provide convenience wrappers to check for the extensions or use the associated functions |
| osgFX::BumpMapping | This effect makes surfaces appear bumpy |
| osg::Camera | Camera - is a subclass of Transform which represents encapsulates the settings of a Camera |
| osg::Camera::Attachment | |
| osg::Camera::DrawCallback | Draw callback for custom operations |
| osg::CameraView | CameraView - is a Transform that is used to specify camera views from within the scene graph |
| osg::Capsule | |
| osgFX::Cartoon | This effect implements a technique called 'Cel-Shading' to produce a cartoon-style (non photorealistic) rendering |
| osgParticle::CenteredPlacer | An abstract placer base class for placers which need a center point |
| osg::ClampColor | Encapsulates OpenGL ClampColor state |
| osg::ClampColor::Extensions | Encapsulates queries of extension availability, obtains extension function pointers, and provides convinience wrappers for calling extension functions |
| osg::ClearNode | A Group node for clearing the color and depth buffers |
| osg::ClipNode | Node for defining the position of ClipPlanes in the scene |
| osg::ClipPlane | Encapsulates OpenGL glClipPlane() |
| osg::ClusterCullingCallback | Implements cluster culling to cull back facing drawables |
| osg::CollectOccludersVisitor | |
| osg::ColorMask | Encapsulates OpenGL glColorMaskFunc/Op/Mask functions |
| osg::ColorMatrix | Encapsulates OpenGL color matrix functionality |
| osgSim::ColorRange | ColorRange is a ScalarsToColors object to define a color spectrum for a scalar range |
| osgManipulator::CommandManager | Command manager receives commands from draggers and dispatches them to selections |
| osgIntrospection::Comparator | |
| osgIntrospection::ComparisonNotPermittedException | |
| osgIntrospection::ComparisonOperatorNotSupportedException | |
| osgIntrospection::CompositeConverter | |
| osgManipulator::CompositeDragger | CompositeDragger allows to create complex draggers that are composed of a hierarchy of Draggers |
| osgTerrain::CompositeLayer | |
| osg::CompositeShape | |
| osgViewer::CompositeViewer | CompsiteViewer holds a or more views to a one more scenes |
| osg::ComputeBoundsVisitor | |
| osg::Cone | |
| osgSim::ConeSector | |
| osgParticle::ConnectedParticleSystem | ConnectConnectedParticleSystem is a specialise ConnectedParticleSystem for effects like missle trails, where the individual particles are rendered as single ribbon |
| osgParticle::ConstantRateCounter | |
| osg::ConstArrayVisitor | |
| osgIntrospection::ConstIsConstException | |
| osgManipulator::Constraint | |
| osgIntrospection::ConstructorInfo | |
| osgIntrospection::ConstructorNotFoundException | |
| osg::ConstShapeVisitor | |
| osg::ConstValueVisitor | |
| osgIntrospection::Converter | |
| osgIntrospection::ConverterProxy | |
| osg::ConvexHull | |
| osg::ConvexPlanarOccluder | A class for representing convex clipping volumes made up of several ConvexPlanarPolygon |
| osg::ConvexPlanarPolygon | A class for representing components of convex clipping volumes |
| osg::CoordinateSystemNode | CoordinateSystem encapsulate the coordinate system that is associated with objects in a scene |
| osg::CopyOp | Copy Op(erator) used to control whether shallow or deep copy is used during copy construction and clone operation |
| osgParticle::Counter | |
| osgUtil::CubeMapGenerator | This is the base class for cube map generators |
| osg::CullFace | Class to globally enable/disable OpenGL's polygon culling mode |
| osg::CullingSet | A CullingSet class which contains a frustum and a list of occluders |
| osg::CullSettings | |
| osg::CullSettings::ClampProjectionMatrixCallback | Callback for overriding the CullVisitor's default clamping of the projection matrix to computed near and far values |
| osg::CullStack | A CullStack class which accumulates the current project, modelview matrices and the CullingSet |
| osgUtil::CullVisitor | Basic NodeVisitor implementation for rendering a scene |
| osgUtil::CullVisitor::MatrixPlanesDrawables | |
| osgIntrospection::CustomAttribute | The base class for custom attributes |
| osgIntrospection::CustomAttributeProvider | This is the base class for custom attribute providers, that is objects that can be assigned a list of custom attributes |
| osgIntrospection::CustomIndexAttribute | By default each index in an indexed property is assumed to be an enumeration |
| osgIntrospection::CustomPropertyAddAttribute | By setting an attribute of this class you can specify a custom object that will be used to add a new item to an array property |
| osgIntrospection::CustomPropertyCountAttribute | By setting an attribute of this class you can specify a custom object that will be used to count the number of items in an array property |
| osgIntrospection::CustomPropertyGetAttribute | By setting an attribute of this class you can specify a custom object that will be used to retrieve the value of a property instead of the default getter method |
| osgIntrospection::CustomPropertyInsertAttribute | By setting an attribute of this class you can specify a custom object that will be used to insert a new item to an array property |
| osgIntrospection::CustomPropertyRemoveAttribute | By setting an attribute of this class you can specify a custom object that will be used to remove an item from an array property |
| osgIntrospection::CustomPropertySetAttribute | By setting an attribute of this class you can specify a custom object that will be used to set the value of a property instead of the default setter method |
| osg::Cylinder | |
| osgManipulator::CylinderPlaneProjector | CylinderPlaneProjector projects points onto the given cylinder |
| osgManipulator::CylinderProjector | CylinderProjector projects points onto the given cylinder |
| osgSim::DatabaseCacheReadCallback | |
| osgDB::DatabasePager | Database paging class which manages the loading of files in a background thread, and syncronizing of loaded models with the main scene graph |
| osgDB::DatabasePager::CompileOperation | |
| osgDB::DatabasePager::DatabaseRequest | |
| osgIntrospection::DefaultValueAttribute | By adding this attribute to a PropertyInfo you specify a custom default value for that property |
| osgUtil::DelaunayConstraint | DelaunayTriangulator: Utility class that triangulates an irregular network of sample points |
| osgUtil::DelaunayTriangulator | |
| osg::DeleteHandler | Class for override the default delete behavior so that users can implement their own object deletion schemes |
| osg::Depth | Encapsulate OpenGL glDepthFunc/Mask/Range functions |
| osgSim::DirectionalSector | |
| osgUtil::DisplayRequirementsVisitor | A visitor for traversing a scene graph establishing which OpenGL visuals are required to support rendering of that scene graph |
| osg::DisplaySettings | DisplaySettings class for encapsulating what visuals are required and have been set up, and the status of stereo viewing |
| osgSim::DOFTransform | DOFTransform - encapsulates Multigen DOF behavior |
| osgDB::DotOsgWrapper | Wrapper class for specifying read and write functions for extending the .osg file format |
| osgManipulator::Dragger | Base class for draggers |
| osg::Drawable | Pure virtual base class for drawable geometry |
| osg::Drawable::AttributeFunctor | |
| osg::Drawable::ComputeBoundingBoxCallback | Callback to allow users to override the default computation of bounding volume |
| osg::Drawable::ConstAttributeFunctor | |
| osg::Drawable::CullCallback | |
| osg::Drawable::DrawCallback | Callback attached to an Drawable which allows the users to customize the drawing of an exist Drawable object |
| osg::Drawable::EventCallback | |
| osg::Drawable::Extensions | Extensions class which encapsulates the querying of extensions and associated function pointers, and provide convenience wrappers to check for the extensions or use the associated functions |
| osg::Drawable::UpdateCallback | |
| osg::DrawArrayLengths | |
| osg::DrawArrays | |
| osg::DrawElements | |
| osg::DrawElementsUByte | |
| osg::DrawElementsUInt | |
| osg::DrawElementsUShort | |
| osg::DrawPixels | DrawPixels is an osg::Drawable subclass which encapsulates the drawing of images using glDrawPixels |
| osgGA::DriveManipulator | DriveManipulator is a camera manipulator which provides drive-like functionality |
| osgIntrospection::DummyInstanceCreator< T > | |
| osgIntrospection::DynamicConverter< S, D > | |
| osgDB::DynamicLibrary | DynamicLibrary - encapsulates the loading and unloading of dynamic libraries, typically used for loading ReaderWriter plug-ins |
| osgFX::Effect | The base class for special effects |
| osg::ElementBufferObject | |
| osgSim::ElevationRange | |
| osgSim::ElevationSector | |
| osgSim::ElevationSlice | Helper class for setting up and aquiring height above terrain intersections with terrain |
| osg::EllipsoidModel | EllipsoidModel encapsulates the ellipsoid used to model astronomical bodies, such as sun, planets, moon etc |
| osgParticle::Emitter | An abstract base class for particle emitters |
| osgIntrospection::EmptyValueException | |
| osg::EndOfDynamicDrawBlock | |
| osgIntrospection::EnumReaderWriter< T > | This ReaderWriter can be used to read and write enumeration values |
| osgIntrospection::EnumReflector< T > | This reflector is a ValueReflector that should be used to define enumerations |
| osgGA::EventQueue | EventQueue implementation for collecting and adapting windowing events |
| osgGA::EventVisitor | Basic EventVisitor implementation for animating a scene |
| osgIntrospection::Exception | |
| osgParticle::ExplosionDebrisEffect | |
| osgParticle::ExplosionEffect | |
| osgIntrospection::ExtendedTypeInfo | This class is a wrapper for std::type_info that also records whether a type is a reference or const reference |
| osgText::FadeText | |
| osg::fast_back_stack< T > | Simple stack implementation that keeps the back() cached locally for fast access rather than at the back of the vector which is the traditional stack implementation |
| osg::FBOExtensions | |
| osgDB::Field | |
| osgDB::FieldReader | |
| osgDB::FieldReaderIterator | |
| osgParticle::FireEffect | |
| osgGA::FlightManipulator | FlightManipulator is a MatrixManipulator which provides flight simulator-like updating of the camera position & orientation |
| osgParticle::FluidFrictionOperator | An operator that simulates the friction of a fluid |
| osgParticle::FluidProgram | A program class for performing operations on particles using a sequence of operators |
| osg::FlushDeletedGLObjectsOperation | |
| osg::Fog | Fog - encapsulates OpenGL fog state |
| osgText::Font | Pure virtual base class for fonts |
| osgText::Font::FontImplementation | |
| osgText::Font::Glyph | |
| osgText::Font::GlyphTexture | |
| osgParticle::ForceOperator | An operator that applies a constant force to the particles |
| osg::FragmentProgram | FragmentProgram - encapsulates the OpenGL ARB fragment program state |
| osg::FragmentProgram::Extensions | Extensions class which encapsulates the querying of extensions and associated function pointers, and provide convenience wrappers to check for the extensions or use the associated functions |
| osg::FrameBufferAttachment | |
| osg::FrameBufferObject | |
| osg::FrameStamp | Class which encapsulates the frame number, reference time and calendar time of specific frame, used to synchonize operations on the scene graph and other machines when using a graphics cluster |
| osg::FrontFace | Class to specify the orientation of front-facing polygons |
| osg::Geode | A Geode is a "geometry node", that is, a leaf node on the scene graph that can have "renderable things" attached to it |
| osgSim::GeographicLocation | Stores a double precision geographic location, latitude and longitude |
| osg::Geometry | |
| osg::Geometry::ArrayData | |
| osg::Geometry::Vec3ArrayData | |
| osgTerrain::GeometryTechnique | |
| osg::GL2Extensions | |
| osgUtil::GLObjectsOperation | |
| osgUtil::GLObjectsVisitor | Visitor for traversing scene graph and setting each osg::Drawable's _useDisplayList flag, with option to immediately compile osg::Drawable OpenGL Display lists and osg::StateAttribute's |
| osg::GraphicsContext | Base class for providing Windowing API agnostic access to creating and managing graphics context |
| osg::GraphicsContext::ResizedCallback | |
| osg::GraphicsContext::ScreenIdentifier | |
| osg::GraphicsContext::Traits | GraphicsContext Traits object provides the specification of what type of graphics context is required |
| osg::GraphicsContext::WindowingSystemInterface | Callback to be implemented to provide access to Windowing API's ability to create Windows/pbuffers |
| osg::GraphicsOperation | |
| osg::GraphicsThread | GraphicsThread is a helper class for running OpenGL GraphicsOperation within a single thread assigned to a specific GraphicsContext |
| osgViewer::GraphicsWindow | Base class for providing Windowing API agnostic access to creating and managing graphisc window and events |
| osgViewer::GraphicsWindowEmbedded | |
| osgViewer::GraphicsWindowFunctionProxy | |
| osgViewer::GraphicsWindowWin32 | |
| osgViewer::GraphicsWindowWin32::WindowData | WindowData is used to pass in the Win32 window handle attached the GraphicsContext::Traits structure |
| osgViewer::GraphicsWindowX11 | |
| osgViewer::GraphicsWindowX11::WindowData | WindowData is used to pass in the X11 window handle attached the GraphicsContext::Traits structure |
| osgManipulator::GridConstraint | Constraint to snap motion commands to a sugar cube grid |
| osg::Group | General group node which maintains a list of children |
| osgGA::GUIActionAdapter | Abstract base class defining the interface by which GUIEventHandlers may request actions of the GUI system in use |
| osgGA::GUIEventAdapter | Event class for storing Keyboard, mouse and window events |
| osgGA::GUIEventHandler | GUIEventHandler provides a basic interface for any class which wants to handle a GUI Events |
| osgUtil::HalfWayMapGenerator | This cube map generator produces an Half-way vector map, useful for hardware-based specular lighting effects |
| osgSim::HeightAboveTerrain | Helper class for setting up and aquiring height above terrain intersections with terrain |
| osgSim::HeightAboveTerrain::HAT | |
| osg::HeightField | |
| osgTerrain::HeightFieldLayer | |
| osgViewer::HelpHandler | Event handler for adding on screen help to Viewers |
| osgUtil::HighlightMapGenerator | This cube map generator produces a specular highlight map |
| osg::Hint | |
| osgUtil::Hit | |
| osg::Image | Image class for encapsulating the storage texture image data |
| osgTerrain::ImageLayer | |
| osgDB::ImageOptions | |
| osgDB::ImageOptions::PixelWindow | PixelWindow stores the window (in exact pixels) from the overall imagery from which to extract the osg::Image |
| osgDB::ImageOptions::RatioWindow | RatioWindow stores the window (as ratios of 0.0 to 1.0) from the overall imagery from which to extract the osg::Image |
| osgDB::ImageOptions::TexCoordRange | Used as UserData attached to generated osg::Image's |
| osg::ImageStream | Image Stream class |
| osgSim::Impostor | Impostor - is a form of Level Of Detail group node which allows both switching between children depending on distance from eye point and image caching |
| osgSim::ImpostorSprite | An ImposterSprite is a textured quad which is rendered in place of 3D geometry |
| osgSim::ImpostorSpriteManager | Helper class for managing the reuse of ImpostorSprite resources |
| osg::IndexArray | |
| osgIntrospection::IndexInfo | This struct allows customization of an indexed property's index set |
| osgIntrospection::IndexTypeAttribute | Attribute for overriding the type of an index (of an indexed property) with a custom type |
| osgIntrospection::IndexValuesNotDefinedException | |
| osg::InfinitePlane | |
| osgDB::Input | Class for managing the reading of ASCII .osg files |
| osgSim::InsertImpostorsVisitor | Insert impostor nodes into scene graph |
| osgParticle::Interpolator | An abstract base class for implementing interpolators |
| osgUtil::IntersectionVisitor | InteresectionVisitor is used to testing for intersections with the scene, traversing the scene using generic osgUtil::Intersector's to test against the scene |
| osgUtil::IntersectionVisitor::ReadCallback | Callback used to implement the reading of external files, allowing support for paged databases to be intergrated with IntersectionVisitor |
| osgUtil::Intersector | Pure virtual base class for implementating custom intersection technique |
| osgUtil::IntersectorGroup | Concrent class for passing multiple intersectors through the scene graph |
| osgUtil::IntersectVisitor | Basic visitor for ray based collisions of a scene |
| osgUtil::IntersectVisitor::IntersectState | |
| osgIntrospection::InvalidFunctionPointerException | |
| osgIntrospection::InvokeNotImplementedException | |
| is_const_reference< T > | Is_const_reference is a compile-time template predicate to determine if a type is a const reference type |
| is_const_reference< const T & > | |
| osgIntrospection::is_polymorphic< T > | Compile-time polymorphism detector |
| osgIntrospection::is_polymorphic< T >::dummy1 | |
| osgIntrospection::is_polymorphic< T >::dummy2 | |
| is_reference< T > | Is_reference is a compile-time template predicate to determine if a type is a reference type |
| is_reference< T & > | |
| osgGA::KeySwitchMatrixManipulator | KeySwitchMatrixManipulator is a decorator which allows the type of camera manipulator being used to be switched by pressing a key |
| osgTerrain::Layer | |
| osgUtil::LessDepthSortFunctor | |
| osg::Light | Light state class which encapsulates OpenGL glLight() functionality |
| osg::LightModel | |
| osgSim::LightPoint | |
| osgSim::LightPointNode | |
| osgSim::LightPointSystem | |
| osg::LightSource | Leaf Node for defining a light in the scene |
| osgParticle::LinearInterpolator | A linear interpolator |
| osgSim::LineOfSight | Helper class for setting up and aquiring line of sight intersections with terrain |
| osgSim::LineOfSight::LOS | |
| osgManipulator::LineProjector | LineProjector projects points onto the closest point on the given line |
| osg::LineSegment | LineSegment class for representing a line segment |
| osgUtil::LineSegmentIntersector | Concrent class for implementing line intersections with the scene graph |
| osgUtil::LineSegmentIntersector::Intersection | |
| osg::LineStipple | |
| osg::LineWidth | LineWidth - encapsulates the OpenGL glLineWidth for setting the width of lines in pixels |
| osgTerrain::Locator | |
| osg::LOD | LOD - Level Of Detail group node which allows switching between children depending on distance from eye point |
| osg::LogicOp | Encapsulates OpenGL LogicOp state |
| osg::Material | Material - encapsulates OpenGL glMaterial state |
| osg::Matrix2 | |
| osg::Matrix3 | |
| osg::Matrixd | |
| osg::Matrixf | |
| osgGA::MatrixManipulator | MatrixManipulator is an abstract base class defining the interface, and a certain amount of default functionality, for classes which wish to control OSG cameras in response to GUI events |
| osgGA::MatrixManipulator::CoordinateFrameCallback | Callback class to use to allow matrix manipulators to querry the application for the local coordinate frame |
| osg::MatrixTransform | MatrixTransform - is a subclass of Transform which has an osg::Matrix which represents a 4x4 transformation of its children from local coordinates into the Transform's parent coordinates |
| osgIntrospection::MethodInfo | Class MethodInfo stores information about a class method |
| osgIntrospection::MethodNotFoundException | |
| osgParticle::ModularEmitter | An emitter class that holds three objects to control the creation of particles |
| osgParticle::ModularProgram | A program class for performing operations on particles using a sequence of operators |
| osgManipulator::MotionCommand | Base class for motion commands that are generated by draggers |
| osg::Multisample | Multisample - encapsulates the OpenGL Multisample state |
| osg::Multisample::Extensions | Extensions class which encapsulates the querying of extensions and associated function pointers, and provide convenience wrappers to check for the extensions or use the associated functions |
| osgParticle::MultiSegmentPlacer | A polyline-shaped particle placer |
| osgSim::MultiSwitch | MultiSwitch is a Group node which allows switching between sets of selected children |
| osgFX::MultiTextureControl | This node provides control over the which texture units are active and the blending weighting between them |
| osgTerrain::NoDataValue | |
| osg::Node | Base class for all internal nodes in the scene graph |
| osg::Node::ComputeBoundingSphereCallback | Callback to allow users to override the default computation of bounding volume |
| osg::NodeAcceptOp | Convenience functor for assisting visiting of arrays of osg::Node's |
| osg::NodeCallback | |
| osgIntrospection::NoDefaultValueAttribute | By adding this attribute to a PropertyInfo you specify that there is no default value for that property |
| osg::NodeTrackerCallback | |
| osgGA::NodeTrackerManipulator | |
| osg::NodeVisitor | Visitor for type safe operations on osg::Nodes |
| osg::NodeVisitor::DatabaseRequestHandler | Callback for managing database paging, such as generated by PagedLOD nodes |
| osg::Object | Base class/standard interface for objects which require IO support, cloning and reference counting |
| osgIntrospection::ObjectInstanceCreator< T > | The ObjectInstanceCreator struct template is a collection of static methods that provide the means for creating instances of object types dynamically |
| osgIntrospection::ObjectReflector< T > | This reflector is to be used to describe types that ought to be created on the heap |
| osg::Observer | |
| osg::observer_ptr< T > | Smart pointer for observed objects, that automatically set pointers to them to null when they deleted |
| osgShadow::OccluderGeometry | OccluderGeometry provides a sepecialised geometry representation of objects in scene that occlude light and therefore cast shadows |
| osgShadow::OccluderGeometry::Edge | |
| osg::OccluderNode | OccluderNode is a Group node which allows OccluderNodeing between children |
| osgViewer::OpenGLQuerySupport | |
| osg::Operation | Base class for implementing graphics operations |
| osg::OperationQueue | |
| osg::OperationThread | OperationThread is a helper class for running Operation within a single thread |
| osgParticle::Operator | An abstract base class used by ModularProgram to perform operations on particles before they are updated |
| osgSim::Optimizer | Flight optimizer |
| osgUtil::Optimizer | Traverses scene graph to improve efficiency |
| osgUtil::Optimizer::CheckGeometryVisitor | |
| osgUtil::Optimizer::CombineLODsVisitor | Optimize the LOD groups, by combining adjacent LOD's which have complementary ranges |
| osgUtil::Optimizer::CombineStaticTransformsVisitor | Combine Static Transform nodes that sit above one another |
| osgUtil::Optimizer::CopySharedSubgraphsVisitor | Copy any shared subgraphs, enabling flattening of static transforms |
| osgUtil::Optimizer::FlattenBillboardVisitor | Flatten MatrixTransform/Billboard pairs |
| osgUtil::Optimizer::FlattenStaticTransformsVisitor | Flatten Static Transform nodes by applying their transform to the geometry on the leaves of the scene graph, then removing the now redundant transforms |
| osgUtil::Optimizer::IsOperationPermissibleForObjectCallback | Callback for customizing what operations are permitted on objects in the scene graph |
| osgSim::Optimizer::MakeLitVisitor | |
| osgSim::Optimizer::MergeGeodesVisitor | Combine geodes |
| osgUtil::Optimizer::MergeGeodesVisitor | Combine geodes |
| osgUtil::Optimizer::MergeGeometryVisitor | |
| osgUtil::Optimizer::RemoveEmptyNodesVisitor | Remove rendundant nodes, such as groups with one single child |
| osgUtil::Optimizer::RemoveLoadedProxyNodesVisitor | Remove loaded proxy nodes |
| osgUtil::Optimizer::RemoveRedundantNodesVisitor | Remove redundant nodes, such as groups with one single child |
| osgUtil::Optimizer::SpatializeGroupsVisitor | Spatialize scene into a balanced quad/oct tree |
| osgUtil::Optimizer::StateVisitor | Optimize State in the scene graph by removing duplicate state, replacing it with shared instances, both for StateAttributes, and whole StateSets |
| osgUtil::Optimizer::StaticObjectDetectionVisitor | Optimize the setting of StateSet and Geometry objects in scene so that they have a STATIC DataVariance when they don't have any callbacks associated with them |
| osgSim::Optimizer::TessellateVisitor | |
| osgUtil::Optimizer::TessellateVisitor | Tessellate all geodes, to remove POLYGONS |
| osgUtil::Optimizer::TextureAtlasBuilder | Texture Atlas Builder creates a set of textures/images which each contain multiple images |
| osgUtil::Optimizer::TextureAtlasBuilder::Atlas | |
| osgUtil::Optimizer::TextureAtlasBuilder::Source | |
| osgUtil::Optimizer::TextureAtlasVisitor | Optimize texture usage in the scene graph by combining textures into texture atlas Use of texture atlas cuts down on the number of seperate states in the scene, reducing state changes and improving the chances of use larger batches of geomertry |
| osgUtil::Optimizer::TextureVisitor | For all textures apply settings |
| osgDB::Output | Ofstream wrapper class for adding support for indenting |
| osgSim::OverlayNode | OverlayNode is for creating texture overlays on scenes, with the overlay texture being generated by pre rendering an Overlay Subgraph to a texture, then projecting this resulting texture on the scene |
| osg::PagedLOD | PagedLOD |
| osg::PagedLOD::PerRangeData | |
| osgShadow::ParallelSplitShadowMap | |
| osgShadow::ParallelSplitShadowMap::PSSMShadowSplitTexture | |
| osgIntrospection::ParameterInfo | This class stores information about a function parameter |
| osgDB::ParameterOutput | |
| osgIntrospection::PartialOrderComparator< T > | |
| osgParticle::Particle | Implementation of a particle |
| osgParticle::ParticleEffect | |
| osgParticle::ParticleProcessor | A common base interface for those classes which need to do something on particles |
| osgParticle::ParticleSystem | The heart of this class library; its purpose is to hold a set of particles and manage particle creation, update, rendering and destruction |
| osgParticle::ParticleSystemUpdater | A useful node class for updating particle systems automatically |
| osgUtil::PickVisitor | Picking intersection visitor specialises the IntersectVistor to allow more convinient handling of mouse picking |
| osg::PixelBufferObject | |
| osgViewer::PixelBufferWin32 | |
| osgViewer::PixelBufferX11 | |
| osgParticle::Placer | An abstract base class for implementing particle placers |
| osg::Plane | A plane class |
| osgUtil::PlaneIntersector | Concrent class for implementing polytope intersections with the scene graph |
| osgUtil::PlaneIntersector::Intersection | |
| osgManipulator::PlaneProjector | PlaneProjector projects points onto the given line |
| osgDB::PluginFunctionProxy | |
| osg::Point | Point - encapsulates the OpenGL point smoothing and size state |
| osg::Point::Extensions | Encapsulates queries of extension availability, obtains extension function pointers, and provides convinience wrappers for calling extension functions |
| osgManipulator::PointerInfo | |
| osgParticle::PointPlacer | A point-shaped particle placer |
| osg::PointSprite | PointSprite base class which encapsulates enabling of point sprites |
| osg::PolygonMode | State Class for setting OpenGL's polygon culling mode |
| osg::PolygonOffset | PolygonOffset - encapsulates the OpenGL glPolygonOffset state |
| osg::PolygonStipple | |
| osg::Polytope | A Polytope class for representing convex clipping volumes made up of a set of planes |
| osgUtil::PolytopeIntersector | Concrent class for implementing polytope intersections with the scene graph |
| osgUtil::PolytopeIntersector::Intersection | |
| osgUtil::PositionalStateContainer | PositionalStateContainer base class |
| osg::PositionAttitudeTransform | PositionAttitudeTransform - is a Transform |
| osgParticle::PrecipitationEffect | |
| osgParticle::PrecipitationEffect::PrecipitationDrawable | Internal drawable used to render batches of cells |
| osgParticle::PrecipitationEffect::PrecipitationDrawable::Cell | |
| osgParticle::PrecipitationEffect::PrecipitationDrawable::DepthMatrixStartTime | |
| osgParticle::PrecipitationEffect::PrecipitationDrawable::LessFunctor | |
| osgParticle::PrecipitationEffect::PrecipitationDrawableSet | |
| osg::PrimitiveFunctor | A PrimitiveFunctor is used (in conjunction with osg::Drawable::accept (PrimitiveFunctor&)) to get access to the primitives that compose the things drawn by OSG |
| osg::PrimitiveIndexFunctor | |
| osg::PrimitiveSet | |
| osg::PrimitiveSet::ObjectIDModifiedCountPair | |
| osgParticle::Program | An abstract ParticleProcessor descendant for modifying particles "on the fly" during the cull traversal |
| osg::Program | Osg::Program is an application-level abstraction of an OpenGL glProgram |
| osg::Program::ActiveVarInfo | |
| osg::Program::PerContextProgram | PerContextProgram (PCP) is an OSG-internal encapsulation of glPrograms per-GL context |
| osg::Projection | Projection nodes set up the frustum/orthographic projection used when rendering the scene |
| osgManipulator::Projector | Base class for Projectors |
| osgIntrospection::PropertyAccessException | |
| osgIntrospection::PropertyAdder | Base struct for custom array property adders |
| osgIntrospection::PropertyCounter | Base struct for custom array property counters |
| osgIntrospection::PropertyGetter | Base struct for custom property getters |
| osgIntrospection::PropertyInfo | This class keeps information about a class' property |
| osgIntrospection::PropertyInserter | Base struct for custom array property inserters |
| osgIntrospection::PropertyRemover | Base struct for custom array property removers |
| osgIntrospection::PropertySetter | Base struct for custom property setters |
| osgIntrospection::PropertyTypeAttribute | Attribute for overriding the type of a property with a custom type |
| osgIntrospection::ProtectedConstructorInstanceCreator< T > | |
| osgIntrospection::ProtectedConstructorInvocationException | |
| osgIntrospection::ProtectedMethodInvocationException | |
| osgTerrain::ProxyLayer | |
| osg::ProxyNode | ProxyNode |
| osgIntrospection::PtrReaderWriter< T > | This is a ReaderWriter class that can be used to read and write pointer values |
| osgIntrospection::PublicMemberAccessor< C, P > | |
| osg::Quat | A quaternion class |
| osgParticle::RadialShooter | A shooter class that shoots particles radially |
| osgParticle::RandomRateCounter | |
| osgParticle::range< ValueType > | A simple struct template useful to store ranges of values as min/max pairs |
| osgDB::ReaderWriter | Pure virtual base class for reading and writing of non native formats |
| osgIntrospection::ReaderWriter | This is the base class for reader/writer objects |
| osgDB::ReaderWriter::Options | Options base class used for passing options into plugins to control their operation |
| osgIntrospection::ReaderWriter::Options | |
| osgDB::ReaderWriter::ReadResult | |
| osgDB::ReaderWriter::WriteResult | |
| osgViewer::RecordCameraPathHandler | Event handler allowing the user to record the animation "path" of a camera |
| osg::ref_ptr< T > | Smart pointer for handling referenced counted objects |
| osg::RefBlock | |
| osg::RefBlockCount | |
| osg::Referenced | Base class from providing referencing counted objects |
| osgIntrospection::Reflection | This class provides basic reflection services such as registration of new types and queries on the global type map |
| osgIntrospection::ReflectionException | |
| osgUtil::ReflectionMapGenerator | This is the most simple cube map generator |
| osgIntrospection::Reflector< T > | A Reflector is a proxy class that is used to create a new description of a given type |
| osg::RefMatrixd | |
| osg::RefMatrixf | |
| osgDB::RegisterDotOsgWrapperProxy | Proxy class for automatic registration of DotOsgWrappers with the Registry |
| osgDB::RegisterReaderWriterProxy< T > | Proxy class for automatic registration of reader/writers with the Registry |
| osgUtil::RegisterRenderBinProxy | Proxy class for automatic registration of renderbins with the RenderBin prototypelist |
| osgDB::Registry | Registry is a singleton factory which stores the reader/writers which are linked in at runtime for reading non-native file formats |
| osgFX::Registry | |
| osgFX::Registry::Proxy | |
| osgDB::Registry::ReadFileCallback | |
| osgDB::Registry::ReadFunctor | Functor used in internal implementations |
| osgDB::Registry::WriteFileCallback | |
| osgIntrospection::ReinterpretConverter< S, D > | |
| osg::ReleaseContext_Block_MakeCurrentOperation | ReleaseContext_Block_MakeCurrentOperation releases the context for another thread to aquire, then blocks waiting for context to be released, once the block is release the context is re-aqquired |
| remove_pointer< T > | Remove_pointer is a compile-time template type mapper that produces the input type, but with any pointer modifier removed |
| remove_pointer< T * > | |
| osgUtil::RenderBin | RenderBin base class |
| osgUtil::RenderBin::DrawCallback | |
| osgUtil::RenderBin::SortCallback | |
| osg::RenderBuffer | |
| osgViewer::Renderer | |
| osgViewer::Renderer::TheadSafeQueue | |
| osg::RenderInfo | |
| osgUtil::RenderLeaf | Container class for all data required for rendering of drawables |
| osgUtil::RenderStage | RenderStage base class |
| osgUtil::RenderStage::Attachment | |
| osgManipulator::Rotate3DCommand | Command for rotation in 3D |
| osgManipulator::RotateCylinderDragger | Dragger for performing 3D rotation on a cylinder |
| osgManipulator::RotateSphereDragger | Dragger for performing 3D rotation on a sphere |
| osg::RunOperations | |
| osgSim::ScalarBar | A ScalarBar is an osg::Geode to render a colored bar representing a range of scalars |
| osgSim::ScalarBar::ScalarPrinter | Users may provide their own ScalarPrinter by deriving from this base class and overriding the printScalar() method |
| osgSim::ScalarBar::TextProperties | TextProperties allows users to specify a number of properties for the text used to display the labels & title on the ScalarBar |
| osgSim::ScalarsToColors | ScalarsToColors defines the interface to map a scalar value to a color, and provides a default implementation of the mapping functionaltity, with colors ranging from black to white across the min - max scalar range |
| osgManipulator::Scale1DCommand | Command for 1D scaling |
| osgManipulator::Scale1DDragger | Dragger for performing 1D scaling |
| osgManipulator::Scale2DCommand | Command for 2D scaling |
| osgManipulator::Scale2DDragger | Dragger for performing 2D scaling |
| osgManipulator::ScaleAxisDragger | Dragger for performing scaling on all 3 axes |
| osgManipulator::ScaleUniformCommand | Command for uniform 3D scaling |
| osgViewer::Scene | Scene holds the highe level reference to a single scene graph |
| osgUtil::SceneView | SceneView is literaly a view of a scene, encapsulating the rendering of the scene |
| osgUtil::SceneView::ComputeStereoMatricesCallback | Callback for overidding the default method for compute the offset projection and view matrices |
| osg::Scissor | Encapsulate OpenGL glScissor |
| osgFX::Scribe | This is a two-passes effect; the first pass renders the subgraph as usual while the second pass switches to wireframe mode, sets up lighting and material to obtain a fixed (user-defined) color and then renders the subgraph |
| osgSim::Sector | |
| osgParticle::SectorPlacer | A sector-shaped particle placer |
| osgParticle::SegmentPlacer | A segment-shaped particle placer |
| osgManipulator::Selection | Selection listens to motion commands generated by draggers |
| osg::Sequence | Sequence is a Group node which allows automatic, time based switching between children |
| osgSim::SequenceGroup | Sequence group which can be used to synchronize related blink sequences |
| osg::ShadeModel | Class which encapsulates glShadeModel( |
| osg::Shader | Osg::Shader is an application-level abstraction of an OpenGL glShader |
| osg::Shader::PerContextShader | PerContextShader (PCS) is an OSG-internal encapsulation of glShader per-GL context |
| osgShadow::ShadowedScene | ShadowedScene provides a mechansim for decorating a scene that the needs to have shadows cast upon it |
| osgShadow::ShadowMap | ShadowedTexture provides an implementation of shadow textures |
| osgShadow::ShadowTechnique | ShadowedScene provides a mechansim for decorating a scene that the needs to have shadows cast upon it |
| osgShadow::ShadowTechnique::CameraCullCallback | |
| osgShadow::ShadowTexture | ShadowedTexture provides an implementation of shadow textures |
| osgShadow::ShadowVolume | ShadowedTexture provides an implementation of shadow textures |
| osgShadow::ShadowVolumeGeometry | |
| osg::ShadowVolumeOccluder | ShadowVolumeOccluder is a helper class for implementating shadow occlusion culling |
| osg::Shape | Base class for all shape types |
| osg::ShapeDrawable | Allow the use of Shapes as Drawables, so that they can be rendered with reduced effort |
| osg::ShapeVisitor | |
| osgDB::SharedStateManager | |
| osgParticle::Shooter | An abstract base class used by ModularEmitter to "shoot" the particles after they have been placed |
| osgUtil::Simplifier | A simplifier for reducing the number of traingles in osg::Geometry |
| osgUtil::Simplifier::ContinueSimplificationCallback | |
| osgParticle::SmokeEffect | |
| osgParticle::SmokeTrailEffect | |
| osgUtil::SmoothingVisitor | A smoothing visitor for calculating smoothed normals for osg::GeoSet's which contains surface primitives |
| osgShadow::SoftShadowMap | SoftShadowMap provides an implementation of soft shadows with shadow maps |
| osgFX::SpecularHighlights | This effect applies additive specular highlights at fragment level (instead of OpenGL's vertex-level lighting) by using a cube map and reflective texgen |
| osg::Sphere | |
| osgManipulator::SpherePlaneProjector | SpherePlaneProjector projects points onto a sphere, failing which it project onto a plane oriented to the viewing direction |
| osgManipulator::SphereProjector | SphereProjector projects points onto the given sphere |
| osgSim::SphereSegment | A SphereSegment is a Geode to represent an portion of a sphere (potentially the whole sphere) |
| osg::State | Encapsulates the current applied OpenGL modes, attributes and vertex arrays settings, implements lazy state updating and provides accessors for querrying the current state |
| osg::State::AttributeStack | |
| osg::State::DynamicObjectRenderingCompletedCallback | |
| osg::State::EnabledArrayPair | |
| osg::State::ModeStack | |
| osg::State::UniformStack | |
| osg::StateAttribute | Base class for state attributes |
| osg::StateAttribute::Callback | |
| osg::StateAttribute::ModeUsage | |
| osgUtil::StateGraph | StateGraph - contained in a renderBin, defines the scene to be drawn |
| osg::StateSet | Stores a set of modes and attributes which respresent a set of OpenGL state |
| osg::StateSet::Callback | |
| osgGA::StateSetManipulator | Experimental class, not been looked at for a while, but which will be returned to at some point :-\ |
| osgIntrospection::StaticConverter< S, D > | |
| osgIntrospection::StaticMethodInfo0< C, R > | Class templates StaticMethodInfoN (where 0 <= N <= 16) are concrete implementations of MethodInfo |
| osgIntrospection::StaticMethodInfo0< C, void > | |
| osgIntrospection::StaticMethodInfo1< C, R, P0 > | |
| osgIntrospection::StaticMethodInfo10< C, R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9 > | |
| osgIntrospection::StaticMethodInfo10< C, void, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9 > | |
| osgIntrospection::StaticMethodInfo11< C, R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > | |
| osgIntrospection::StaticMethodInfo11< C, void, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > | |
| osgIntrospection::StaticMethodInfo12< C, R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > | |
| osgIntrospection::StaticMethodInfo12< C, void, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > | |
| osgIntrospection::StaticMethodInfo13< C, R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > | |
| osgIntrospection::StaticMethodInfo13< C, void, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > | |
| osgIntrospection::StaticMethodInfo14< C, R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > | |
| osgIntrospection::StaticMethodInfo14< C, void, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > | |
| osgIntrospection::StaticMethodInfo15< C, R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > | |
| osgIntrospection::StaticMethodInfo15< C, void, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > | |
| osgIntrospection::StaticMethodInfo16< C, R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > | |
| osgIntrospection::StaticMethodInfo16< C, void, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > | |
| osgIntrospection::StaticMethodInfo1< C, void, P0 > | |
| osgIntrospection::StaticMethodInfo2< C, R, P0, P1 > | |
| osgIntrospection::StaticMethodInfo2< C, void, P0, P1 > | |
| osgIntrospection::StaticMethodInfo3< C, R, P0, P1, P2 > | |
| osgIntrospection::StaticMethodInfo3< C, void, P0, P1, P2 > | |
| osgIntrospection::StaticMethodInfo4< C, R, P0, P1, P2, P3 > | |
| osgIntrospection::StaticMethodInfo4< C, void, P0, P1, P2, P3 > | |
| osgIntrospection::StaticMethodInfo5< C, R, P0, P1, P2, P3, P4 > | |
| osgIntrospection::StaticMethodInfo5< C, void, P0, P1, P2, P3, P4 > | |
| osgIntrospection::StaticMethodInfo6< C, R, P0, P1, P2, P3, P4, P5 > | |
| osgIntrospection::StaticMethodInfo6< C, void, P0, P1, P2, P3, P4, P5 > | |
| osgIntrospection::StaticMethodInfo7< C, R, P0, P1, P2, P3, P4, P5, P6 > | |
| osgIntrospection::StaticMethodInfo7< C, void, P0, P1, P2, P3, P4, P5, P6 > | |
| osgIntrospection::StaticMethodInfo8< C, R, P0, P1, P2, P3, P4, P5, P6, P7 > | |
| osgIntrospection::StaticMethodInfo8< C, void, P0, P1, P2, P3, P4, P5, P6, P7 > | |
| osgIntrospection::StaticMethodInfo9< C, R, P0, P1, P2, P3, P4, P5, P6, P7, P8 > | |
| osgIntrospection::StaticMethodInfo9< C, void, P0, P1, P2, P3, P4, P5, P6, P7, P8 > | |
| osgIntrospection::StaticProtectedMethodInfo0< C, R > | |
| osgIntrospection::StaticProtectedMethodInfo0< C, void > | |
| osgIntrospection::StaticProtectedMethodInfo1< C, R, P0 > | |
| osgIntrospection::StaticProtectedMethodInfo10< C, R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9 > | |
| osgIntrospection::StaticProtectedMethodInfo10< C, void, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9 > | |
| osgIntrospection::StaticProtectedMethodInfo11< C, R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > | |
| osgIntrospection::StaticProtectedMethodInfo11< C, void, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > | |
| osgIntrospection::StaticProtectedMethodInfo12< C, R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > | |
| osgIntrospection::StaticProtectedMethodInfo12< C, void, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > | |
| osgIntrospection::StaticProtectedMethodInfo13< C, R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > | |
| osgIntrospection::StaticProtectedMethodInfo13< C, void, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > | |
| osgIntrospection::StaticProtectedMethodInfo14< C, R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > | |
| osgIntrospection::StaticProtectedMethodInfo14< C, void, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > | |
| osgIntrospection::StaticProtectedMethodInfo15< C, R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > | |
| osgIntrospection::StaticProtectedMethodInfo15< C, void, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > | |
| osgIntrospection::StaticProtectedMethodInfo16< C, R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > | |
| osgIntrospection::StaticProtectedMethodInfo16< C, void, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > | |
| osgIntrospection::StaticProtectedMethodInfo1< C, void, P0 > | |
| osgIntrospection::StaticProtectedMethodInfo2< C, R, P0, P1 > | |
| osgIntrospection::StaticProtectedMethodInfo2< C, void, P0, P1 > | |
| osgIntrospection::StaticProtectedMethodInfo3< C, R, P0, P1, P2 > | |
| osgIntrospection::StaticProtectedMethodInfo3< C, void, P0, P1, P2 > | |
| osgIntrospection::StaticProtectedMethodInfo4< C, R, P0, P1, P2, P3 > | |
| osgIntrospection::StaticProtectedMethodInfo4< C, void, P0, P1, P2, P3 > | |
| osgIntrospection::StaticProtectedMethodInfo5< C, R, P0, P1, P2, P3, P4 > | |
| osgIntrospection::StaticProtectedMethodInfo5< C, void, P0, P1, P2, P3, P4 > | |
| osgIntrospection::StaticProtectedMethodInfo6< C, R, P0, P1, P2, P3, P4, P5 > | |
| osgIntrospection::StaticProtectedMethodInfo6< C, void, P0, P1, P2, P3, P4, P5 > | |
| osgIntrospection::StaticProtectedMethodInfo7< C, R, P0, P1, P2, P3, P4, P5, P6 > | |
| osgIntrospection::StaticProtectedMethodInfo7< C, void, P0, P1, P2, P3, P4, P5, P6 > | |
| osgIntrospection::StaticProtectedMethodInfo8< C, R, P0, P1, P2, P3, P4, P5, P6, P7 > | |
| osgIntrospection::StaticProtectedMethodInfo8< C, void, P0, P1, P2, P3, P4, P5, P6, P7 > | |
| osgIntrospection::StaticProtectedMethodInfo9< C, R, P0, P1, P2, P3, P4, P5, P6, P7, P8 > | |
| osgIntrospection::StaticProtectedMethodInfo9< C, void, P0, P1, P2, P3, P4, P5, P6, P7, P8 > | |
| osgUtil::Statistics | Statistics base class |
| osg::Stats | |
| osgViewer::StatsHandler | Event handler for adding on screen stats reporting to Viewers |
| osgUtil::StatsVisitor | StatsVisitor for collecting statistics about scene graph |
| osgIntrospection::StdListReflector< T, VT > | This class allows to define the means for reflecting STL containers that cannot be indexed directly, such as std::list |
| osgIntrospection::StdListReflector< T, VT >::Adder | |
| osgIntrospection::StdListReflector< T, VT >::Counter | |
| osgIntrospection::StdListReflector< T, VT >::Getter | |
| osgIntrospection::StdListReflector< T, VT >::Inserter | |
| osgIntrospection::StdListReflector< T, VT >::Remover | |
| osgIntrospection::StdListReflector< T, VT >::Setter | |
| osgIntrospection::StdMapReflector< T, IT, VT > | This class allows to define the means for reflecting STL associative containers which hold pairs of key+value, such as std::map |
| osgIntrospection::StdMapReflector< T, IT, VT >::Getter | |
| osgIntrospection::StdMapReflector< T, IT, VT >::Indexer | |
| osgIntrospection::StdMapReflector< T, IT, VT >::Remover | |
| osgIntrospection::StdMapReflector< T, IT, VT >::Setter | |
| osgIntrospection::StdPairReflector< T, PT1, PT2 > | |
| osgIntrospection::StdPairReflector< T, PT1, PT2 >::Accessor | |
| osgIntrospection::StdReaderWriter< T > | This class template provides basic default streaming capabilities for all types that define streaming operators (<< and >>) |
| osgIntrospection::StdSetReflector< T, VT > | This class allows to define the means for reflecting STL containers such as std::set and std::multiset |
| osgIntrospection::StdSetReflector< T, VT >::Adder | |
| osgIntrospection::StdSetReflector< T, VT >::Counter | |
| osgIntrospection::StdSetReflector< T, VT >::Getter | |
| osgIntrospection::StdSetReflector< T, VT >::Remover | |
| osgIntrospection::StdVectorReflector< T, VT > | This class allows to define the means for reflecting STL containers such as std::deque and std::vector |
| osgIntrospection::StdVectorReflector< T, VT >::Adder | |
| osgIntrospection::StdVectorReflector< T, VT >::Counter | |
| osgIntrospection::StdVectorReflector< T, VT >::Getter | |
| osgIntrospection::StdVectorReflector< T, VT >::Inserter | |
| osgIntrospection::StdVectorReflector< T, VT >::Remover | |
| osgIntrospection::StdVectorReflector< T, VT >::Setter | |
| osgIntrospection::StdWReaderWriter< T > | |
| osg::Stencil | Encapsulate OpenGL glStencilFunc/Op/Mask functions |
| osg::StencilTwoSided | Encapsulate OpenGL two sided glStencilFunc/Op/Mask functions |
| osg::StencilTwoSided::Extensions | Extensions class which encapsulates the querying of extensions and associated function pointers, and provide convenience wrappers to check for the extensions or use the associated functions |
| osgIntrospection::StreamingNotSupportedException | |
| osgIntrospection::StreamReadErrorException | |
| osgIntrospection::StreamWriteErrorException | |
| osgText::String | |
| osg::SwapBuffersOperation | SwapBufferOperation calls swap buffers on the GraphicsContext |
| osg::Switch | Switch is a Group node that allows switching between children |
| osgManipulator::TabBoxDragger | TabBoxDragger consists of 6 TabPlaneDraggers to form a box dragger that performs translation and scaling |
| osgManipulator::TabPlaneDragger | Tab plane dragger consists of a plane with tabs on it's corners and edges for scaling |
| osgManipulator::TabPlaneTrackballDragger | Dragger for performing rotation in all axes |
| osgUtil::TangentSpaceGenerator | The TangentSpaceGenerator class generates three arrays containing tangent-space basis vectors |
| osgFX::Technique | This is the base class for effect techniques |
| osg::TemplateArray< T, ARRAYTYPE, DataSize, DataType > | |
| osg::TemplateIndexArray< T, ARRAYTYPE, DataSize, DataType > | |
| osg::TemplatePrimitiveFunctor< T > | Provides access to the primitives that compose an osg::Drawable |
| osgDB::TemplateRegisterDotOsgWrapperProxy< T > | |
| osgTerrain::Terrain | Terrain provides a framework for loosly coupling height field data with height rendering algorithms |
| osgTerrain::Terrain::LayerData | |
| osgGA::TerrainManipulator | |
| osgTerrain::TerrainTechnique | |
| osg::TessellationHints | Describe several hints that can be passed to a Tessellator (like the one used by ShapeDrawable) as a mean to try to influence the way it works |
| osgUtil::Tessellator | Originally a simple class for tessellating a single polygon boundary |
| osgUtil::Tessellator::NewVertex | |
| osgUtil::Tessellator::Prim | |
| osgUtil::Tessellator::Vec3d | |
| osg::TexEnv | TexEnv encapsulates the OpenGL glTexEnv (texture environment) state |
| osg::TexEnvCombine | TexEnvCombine encapsulates the OpenGL glTexEnvCombine (texture environment) state |
| osg::TexEnvFilter | TexEnvFilter - encapsulates the OpenGL glTexEnv (GL_TEXTURE_FILTER_CONTROL) state |
| osg::TexGen | TexGen encapsulates the OpenGL glTexGen (texture coordinate generation) state |
| osg::TexGenNode | Node for defining the position of TexGen in the scene |
| osg::TexMat | A texture matrix state class that encapsulates OpenGL texture matrix functionality |
| osgText::Text | |
| osgText::Text::AutoTransformCache | |
| osgText::Text::GlyphQuads | |
| osg::Texture | Texture pure virtual base class that encapsulates OpenGl texture functionality common to the various types of OSG textures |
| osg::Texture1D | Encapsulates OpenGl 1D texture functionality |
| osg::Texture1D::SubloadCallback | |
| osg::Texture2D | Encapsulates OpenGl 2D texture functionality |
| osg::Texture2D::SubloadCallback | |
| osg::Texture2DArray | Texture2DArray state class which encapsulates OpenGL 2D array texture functionality |
| osg::Texture2DArray::Extensions | Extensions class which encapsulates the querying of extensions and associated function pointers, and provides convinience wrappers to check for the extensions or use the associated functions |
| osg::Texture2DArray::SubloadCallback | |
| osg::Texture3D | Encapsulates OpenGl 2D texture functionality |
| osg::Texture3D::Extensions | Encapsulates queries of extension availability, obtains extension function pointers, and provides convinience wrappers for calling extension functions |
| osg::Texture3D::SubloadCallback | |
| osg::Texture::Extensions | Encapsulates queries of extension availability, obtains extension function pointers, and provides convinience wrappers for calling extension functions |
| osg::Texture::TextureObject | |
| osg::TextureCubeMap | TextureCubeMap state class which encapsulates OpenGL texture cubemap functionality |
| osg::TextureCubeMap::Extensions | Extensions class which encapsulates the querying of extensions and associated function pointers, and provides convinience wrappers to check for the extensions or use the associated functions |
| osg::TextureCubeMap::SubloadCallback | |
| osg::TextureRectangle | Texture state class which encapsulates OpenGL texture functionality |
| osg::TextureRectangle::SubloadCallback | |
| osgViewer::ThreadingHandler | Event handler allowing to change the viewer threading model |
| osgTerrain::TileID | |
| osgTerrain::TileSystem | TileSystem provides the mechanism for computing the position in space of tiles |
| osg::Timer | Timer class is used for measuring elapsed time or time between two points |
| osgIntrospection::TotalOrderComparator< T > | |
| osgManipulator::TrackballDragger | Dragger for performing rotation in all axes |
| osgGA::TrackballManipulator | |
| osg::TransferFunction | TransferFunction is a class that provide a 1D,2D or 3D colour look up table that can be used on the GPU as a 1D, 2D or 3D texture |
| osg::TransferFunction1D | 1D variant of TransferFunction |
| osg::Transform | A Transform is a group node for which all children are transformed by a 4x4 matrix |
| osgUtil::TransformAttributeFunctor | Functor for transforming a drawable's vertex and normal attributes by specified matrix |
| osgUtil::TransformCallback | TransformCallback is now deprecated, use osg::AnimationPathCallback instead |
| osgManipulator::Translate1DDragger | Dragger for performing 1D translation |
| osgManipulator::Translate2DDragger | Dragger for performing 2D translation |
| osgManipulator::TranslateAxisDragger | Dragger for performing translation in all three axes |
| osgManipulator::TranslateInLineCommand | Command for translating in a line |
| osgManipulator::TranslateInPlaneCommand | Command for translating in a plane |
| osgManipulator::TranslatePlaneDragger | Tab plane dragger consists of a plane with tabs on it's corners and edges for scaling |
| osg::TriangleFunctor< T > | Provides access to the triangles that compose an osg::Drawable |
| osg::TriangleIndexFunctor< T > | |
| osg::TriangleMesh | |
| osgUtil::TriStripVisitor | A tri stripping visitor for converting Geometry surface primitives into tri strips |
| osgIntrospection::Type | Objects of class Type are used to maintain information about reflected types |
| osgDB::type_wrapper< T > | Class template that checks inheritance between a given Object's class and a class defined at compile time through the template parameter T |
| osgIntrospection::TypeConversionException | |
| osgIntrospection::TypedConstructorInfo0< C, IC > | |
| osgIntrospection::TypedConstructorInfo1< C, IC, P0 > | |
| osgIntrospection::TypedConstructorInfo10< C, IC, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9 > | |
| osgIntrospection::TypedConstructorInfo11< C, IC, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > | |
| osgIntrospection::TypedConstructorInfo12< C, IC, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > | |
| osgIntrospection::TypedConstructorInfo13< C, IC, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > | |
| osgIntrospection::TypedConstructorInfo14< C, IC, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > | |
| osgIntrospection::TypedConstructorInfo15< C, IC, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > | |
| osgIntrospection::TypedConstructorInfo16< C, IC, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > | |
| osgIntrospection::TypedConstructorInfo2< C, IC, P0, P1 > | |
| osgIntrospection::TypedConstructorInfo3< C, IC, P0, P1, P2 > | |
| osgIntrospection::TypedConstructorInfo4< C, IC, P0, P1, P2, P3 > | |
| osgIntrospection::TypedConstructorInfo5< C, IC, P0, P1, P2, P3, P4 > | |
| osgIntrospection::TypedConstructorInfo6< C, IC, P0, P1, P2, P3, P4, P5 > | |
| osgIntrospection::TypedConstructorInfo7< C, IC, P0, P1, P2, P3, P4, P5, P6 > | |
| osgIntrospection::TypedConstructorInfo8< C, IC, P0, P1, P2, P3, P4, P5, P6, P7 > | |
| osgIntrospection::TypedConstructorInfo9< C, IC, P0, P1, P2, P3, P4, P5, P6, P7, P8 > | |
| osgIntrospection::TypedMethodInfo0< C, R > | Class templates TypedMethodInfoN (where 0 <= N <= 16) are concrete implementations of MethodInfo |
| osgIntrospection::TypedMethodInfo0< C, void > | |
| osgIntrospection::TypedMethodInfo1< C, R, P0 > | |
| osgIntrospection::TypedMethodInfo10< C, R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9 > | |
| osgIntrospection::TypedMethodInfo10< C, void, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9 > | |
| osgIntrospection::TypedMethodInfo11< C, R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > | |
| osgIntrospection::TypedMethodInfo11< C, void, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > | |
| osgIntrospection::TypedMethodInfo12< C, R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > | |
| osgIntrospection::TypedMethodInfo12< C, void, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > | |
| osgIntrospection::TypedMethodInfo13< C, R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > | |
| osgIntrospection::TypedMethodInfo13< C, void, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > | |
| osgIntrospection::TypedMethodInfo14< C, R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > | |
| osgIntrospection::TypedMethodInfo14< C, void, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > | |
| osgIntrospection::TypedMethodInfo15< C, R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > | |
| osgIntrospection::TypedMethodInfo15< C, void, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > | |
| osgIntrospection::TypedMethodInfo16< C, R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > | |
| osgIntrospection::TypedMethodInfo16< C, void, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > | |
| osgIntrospection::TypedMethodInfo1< C, void, P0 > | |
| osgIntrospection::TypedMethodInfo2< C, R, P0, P1 > | |
| osgIntrospection::TypedMethodInfo2< C, void, P0, P1 > | |
| osgIntrospection::TypedMethodInfo3< C, R, P0, P1, P2 > | |
| osgIntrospection::TypedMethodInfo3< C, void, P0, P1, P2 > | |
| osgIntrospection::TypedMethodInfo4< C, R, P0, P1, P2, P3 > | |
| osgIntrospection::TypedMethodInfo4< C, void, P0, P1, P2, P3 > | |
| osgIntrospection::TypedMethodInfo5< C, R, P0, P1, P2, P3, P4 > | |
| osgIntrospection::TypedMethodInfo5< C, void, P0, P1, P2, P3, P4 > | |
| osgIntrospection::TypedMethodInfo6< C, R, P0, P1, P2, P3, P4, P5 > | |
| osgIntrospection::TypedMethodInfo6< C, void, P0, P1, P2, P3, P4, P5 > | |
| osgIntrospection::TypedMethodInfo7< C, R, P0, P1, P2, P3, P4, P5, P6 > | |
| osgIntrospection::TypedMethodInfo7< C, void, P0, P1, P2, P3, P4, P5, P6 > | |
| osgIntrospection::TypedMethodInfo8< C, R, P0, P1, P2, P3, P4, P5, P6, P7 > | |
| osgIntrospection::TypedMethodInfo8< C, void, P0, P1, P2, P3, P4, P5, P6, P7 > | |
| osgIntrospection::TypedMethodInfo9< C, R, P0, P1, P2, P3, P4, P5, P6, P7, P8 > | |
| osgIntrospection::TypedMethodInfo9< C, void, P0, P1, P2, P3, P4, P5, P6, P7, P8 > | |
| osgIntrospection::TypedProtectedMethodInfo0< C, R > | |
| osgIntrospection::TypedProtectedMethodInfo0< C, void > | |
| osgIntrospection::TypedProtectedMethodInfo1< C, R, P0 > | |
| osgIntrospection::TypedProtectedMethodInfo10< C, R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9 > | |
| osgIntrospection::TypedProtectedMethodInfo10< C, void, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9 > | |
| osgIntrospection::TypedProtectedMethodInfo11< C, R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > | |
| osgIntrospection::TypedProtectedMethodInfo11< C, void, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10 > | |
| osgIntrospection::TypedProtectedMethodInfo12< C, R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > | |
| osgIntrospection::TypedProtectedMethodInfo12< C, void, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11 > | |
| osgIntrospection::TypedProtectedMethodInfo13< C, R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > | |
| osgIntrospection::TypedProtectedMethodInfo13< C, void, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12 > | |
| osgIntrospection::TypedProtectedMethodInfo14< C, R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > | |
| osgIntrospection::TypedProtectedMethodInfo14< C, void, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13 > | |
| osgIntrospection::TypedProtectedMethodInfo15< C, R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > | |
| osgIntrospection::TypedProtectedMethodInfo15< C, void, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14 > | |
| osgIntrospection::TypedProtectedMethodInfo16< C, R, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > | |
| osgIntrospection::TypedProtectedMethodInfo16< C, void, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15 > | |
| osgIntrospection::TypedProtectedMethodInfo1< C, void, P0 > | |
| osgIntrospection::TypedProtectedMethodInfo2< C, R, P0, P1 > | |
| osgIntrospection::TypedProtectedMethodInfo2< C, void, P0, P1 > | |
| osgIntrospection::TypedProtectedMethodInfo3< C, R, P0, P1, P2 > | |
| osgIntrospection::TypedProtectedMethodInfo3< C, void, P0, P1, P2 > | |
| osgIntrospection::TypedProtectedMethodInfo4< C, R, P0, P1, P2, P3 > | |
| osgIntrospection::TypedProtectedMethodInfo4< C, void, P0, P1, P2, P3 > | |
| osgIntrospection::TypedProtectedMethodInfo5< C, R, P0, P1, P2, P3, P4 > | |
| osgIntrospection::TypedProtectedMethodInfo5< C, void, P0, P1, P2, P3, P4 > | |
| osgIntrospection::TypedProtectedMethodInfo6< C, R, P0, P1, P2, P3, P4, P5 > | |
| osgIntrospection::TypedProtectedMethodInfo6< C, void, P0, P1, P2, P3, P4, P5 > | |
| osgIntrospection::TypedProtectedMethodInfo7< C, R, P0, P1, P2, P3, P4, P5, P6 > | |
| osgIntrospection::TypedProtectedMethodInfo7< C, void, P0, P1, P2, P3, P4, P5, P6 > | |
| osgIntrospection::TypedProtectedMethodInfo8< C, R, P0, P1, P2, P3, P4, P5, P6, P7 > | |
| osgIntrospection::TypedProtectedMethodInfo8< C, void, P0, P1, P2, P3, P4, P5, P6, P7 > | |
| osgIntrospection::TypedProtectedMethodInfo9< C, R, P0, P1, P2, P3, P4, P5, P6, P7, P8 > | |
| osgIntrospection::TypedProtectedMethodInfo9< C, void, P0, P1, P2, P3, P4, P5, P6, P7, P8 > | |
| osgIntrospection::TypeIsAbstractException | |
| osgIntrospection::TypeNameAliasProxy< C > | |
| osgIntrospection::TypeNotDefinedException | |
| osgIntrospection::TypeNotFoundException | |
| osgGA::UFOManipulator | |
| osg::Uniform | Uniform encapsulates glUniform values |
| osg::Uniform::Callback | |
| osgUtil::UpdateVisitor | Basic UpdateVisitor implementation for animating a scene |
| osgFX::Validator | This class is used internally by osgFX::Effect to choose between different techniques dynamically |
| osgTerrain::ValidDataOperator | |
| osgTerrain::ValidRange | |
| osgIntrospection::Value | |
| osgIntrospection::ValueInstanceCreator< T > | |
| osgIntrospection::ValueReflector< T > | This reflector ought to be used to describe types that can be created on the stack |
| osg::ValueVisitor | |
| osgParticle::VariableRateCounter | |
| osg::Vec2b | General purpose float triple |
| osg::Vec2d | General purpose double pair, uses include representation of texture coordinates |
| osg::Vec2f | General purpose float pair |
| osg::Vec2s | |
| osg::Vec3b | General purpose float triple |
| osg::Vec3d | General purpose double triple for use as vertices, vectors and normals |
| osg::Vec3f | General purpose float triple for use as vertices, vectors and normals |
| osg::Vec3s | |
| osg::Vec4b | General purpose float triple |
| osg::Vec4d | General purpose double quad |
| osg::Vec4f | General purpose float quad |
| osg::Vec4s | |
| osg::Vec4ub | General purpose float quad |
| osg::VectorGLsizei | |
| osg::VectorGLubyte | |
| osg::VectorGLuint | |
| osg::VectorGLushort | |
| osgText::VectorUInt | |
| osg::VertexBufferObject | |
| osg::VertexProgram | VertexProgram - encapsulates the OpenGL ARB vertex program state |
| osg::VertexProgram::Extensions | Extensions class which encapsulates the querying of extensions and associated function pointers, and provide convenience wrappers to check for the extensions or use the associated functions |
| osgViewer::View | View holds a single view on a scene, this view may be composed of one or more slave cameras |
| osg::View | View - maintains a master camera view and a list of slave cameras that are relative to this master camera |
| osg::View::Slave | Slave allows one to up a camera that follows the master with a local offset to the project and view matrices |
| osgViewer::Viewer | Viewer holds a single view on to a single scene |
| osgViewer::ViewerBase | ViewerBase is the view base class that is inhertied by both Viewer and CompositeViewer |
| osg::Viewport | Encapsulate OpenGL glViewport |
| osgSim::VisibilityGroup | VisibilityGroup renders (traverses) it's children only when the camera is inside a specified visibility volume |
| osgIntrospection::WAtomicValueReflector< T > | |
| osgViewer::WindowSizeHandler | Event handler allowing to change the screen resolution (in windowed mode) and toggle between fullscreen and windowed mode |