Class Hierarchy
This inheritance list is sorted roughly, but not completely, alphabetically:

SurgSim::Framework::Accessible | Mixin class for enabling a property system on OSS classes, the instance still needs to initialize properties in the constructor by using either addSetter, addGetter, addAccessors or the macro for each member variable that should be made accessible
SurgSim::Framework::Asset | This class is used to facilitate file loading
SurgSim::Physics::Fem< FemElementStructs::RotationVectorData, FemElementStructs::FemElement1DParameter > |
SurgSim::Physics::Fem1D | Fem class data structure implementation for 1-Dimensional FEMs
SurgSim::Physics::Fem< FemElementStructs::RotationVectorData, FemElementStructs::FemElement2DParameter > |
SurgSim::Physics::Fem2D | Fem class data structure implementation for 2-Dimensional FEMs
SurgSim::Physics::Fem< SurgSim::DataStructures::EmptyData, FemElementStructs::FemElement3DParameter > |
SurgSim::Physics::Fem3D | Fem class data structure implementation for 3-Dimensional FEMs
SurgSim::DataStructures::OctreeNode< Data > | Octree data structure
SurgSim::DataStructures::TriangleMesh< VertexData, EdgeData, TriangleData > | Basic class for storing Triangle Meshes, handling basic vertex, edge, and triangle functionality
SurgSim::Graphics::Font | Abstract base class for the Font Asset, fonts are typefaces that can be used to render text on screen they would usually be loaded from disk
SurgSim::Graphics::OsgFont | Osg specialization of the Font class, supports osgText::Font
SurgSim::Graphics::Model |
SurgSim::Graphics::OsgModel | Osg implementation of the Model class, inheriting from Asset, this class knows how to load models that can be handled by osg
SurgSim::Physics::Fem< VertexData, Element > | Base class for a data structure for holding FEM mesh data of different dimensions
SurgSim::DataStructures::TriangleMesh< SurgSim::DataStructures::EmptyData, SurgSim::DataStructures::EmptyData, SurgSim::DataStructures::NormalData > |
SurgSim::Math::MeshShape | Mesh shape: shape made of a triangle mesh The triangle mesh needs to be watertight to produce valid volume, center and second moment of volume
SurgSim::Math::SurfaceMeshShape | SurfaceMeshShape defines a shape based on a mesh, like MeshShape
SurgSim::DataStructures::TriangleMesh< VertexData, EdgeData, SegmentEmptyData > |
SurgSim::DataStructures::SegmentMesh< VertexData, EdgeData > | Class to hold the type of a SegmentMesh
SurgSim::Math::SegmentMeshShape | SegmentMeshShape defines a shape based on a mesh, like MeshShape
SurgSim::DataStructures::TriangleMesh< VertexData, SurgSim::DataStructures::EmptyData, SurgSim::DataStructures::EmptyData > |
SurgSim::Graphics::Mesh |
SurgSim::Framework::Component | Component is the main interface class to pass information to the system managers each will decide whether to handle a component of a given type or not
SerializationMockComponent | This class is for testing the linker and checking if the definition stays in the executable even if there is not direct reference to it, DO NOT define a member of this class explicitly anywhere
SurgSim::Collision::ContactFilter | Base class to implement a contact filter, the job of this class is to be executed by the ContactFiltering stage in the PhysicsManager
SurgSim::Collision::ElementContactFilter | Given a DeformableCollisionRepresentation this filter can remove contacts on specific elements of that representation
SurgSim::Framework::Behavior | Behaviors perform actions
SurgSim::Blocks::CompoundShapeToGraphics | Keep a set of Graphics representations in sync with a CompoundShape, the shape can either be set directly or pulled from a Physics or Collision Representation
SurgSim::Blocks::DebugDumpBehavior | Provides keyboard access to debugging functionality F1 - call the graphics manager dumpDebugInfo, this will write the current scenegraph to a file in the working directory
SurgSim::Blocks::DriveElementFromInputBehavior | Behavior to copy a pose from an input component to a SceneElement By adding this behavior to a SceneElement, that SceneElement will be moved in correspondance to the input
SurgSim::Blocks::FunctionBehavior | A Behavior that can run any callable target in its update function
SurgSim::Blocks::KeyBehavior | Behavior to abstract the functionality of keyboard driven behaviors, can be programmed to react to a single keystroke
SurgSim::Blocks::SingleKeyBehavior | Behavior to abstract the functionality of keyboard driven behaviors, can be programmed to react to a single keystroke
SurgSim::Blocks::KeyboardCallbackBehavior | This behavior will call the registered callback function when the registered key is pressed
SurgSim::Blocks::KeyboardTogglesComponentBehavior | This behavior is used to control the activity of registered components
SurgSim::Blocks::PoseInterpolator | Perform linear interpolation on two poses
SurgSim::Blocks::TransferParticlesToPointCloudBehavior | Behavior to copy positions of a Particles::Representation to a PointCloud
SurgSim::Blocks::TransferPhysicsToGraphicsMeshBehavior | Behavior to copy positions of a PhysicsRepresentation to a GraphicsMesh
SurgSim::Blocks::TransferPhysicsToPointCloudBehavior | Behavior to copy positions of a PhysicsRepresentation to a PointCloud
SurgSim::Blocks::TransferPhysicsToVerticesBehavior | Transfer Physics State to any representation that has a Vertices property, the "Vertices" property on the targets side needs to accept DataStructures::VerticesPlain for the type
SurgSim::Blocks::VisualizeConstraintsBehavior | Behavior to visualize information about the constraints as they are in the physics manager this will show the constraint location and the force from the last iteration of the physics manager
SurgSim::Blocks::VisualizeContactsBehavior | This behavior is used to visualize the contacts on collision representation through vector field
SurgSim::Framework::SamplingMetricBase | SamplingMetricBase provides a base class to support metric development
SurgSim::Framework::TransferPropertiesBehavior | Behavior to copy properties between instances of Accessible
SurgSim::Graphics::PaintBehavior | Behavior class to allow a specified scene element to receive painting effects
SurgSim::Particles::Emitter | Emitter emits particles into a ParticleSystem
SurgSim::Particles::Sink | Sink removes particles from a ParticleSystem
SurgSim::Physics::VirtualToolCoupler | The VirtualToolCoupler couples a rigid object to an input/output device through a spring and damper
SurgSim::Framework::PoseComponent | The PoseComponent holds a pose
SurgSim::Framework::Representation | Representations are manifestations of a SceneElement
SurgSim::Collision::Representation | The type of collision detection
SurgSim::Collision::ShapeCollisionRepresentation | Use a Shape as a Collision Representation, any SurgSim::Physics::Representation can be used as a backing representation
SurgSim::Particles::ParticlesCollisionRepresentation | A Collision Representation that can be attached to a Particle Representation
SurgSim::Physics::DeformableCollisionRepresentation | A collision representation that can be attached to a deformable, when this contains a mesh with the same number of vertices as the deformable has nodes, the mesh vertices will move to match the positions of the nodes in the deformable
SurgSim::Physics::RigidCollisionRepresentation | Collision Representation class that wraps a RigidRepresentation, this can be used to strictly tie the Collision Representation to the Rigid, so even if the shape of the rigid changes, the collision representation will use the appropriate shape
SurgSim::Graphics::Representation | Base graphics representation class, which defines the interface that all graphics representations must implement
SurgSim::Graphics::AxesRepresentation | Displays the coordinate axes, as three lines from the origin default size is 1.0, the X/Y/Z axis are indicated by R/G/B respectively
SurgSim::Graphics::OsgAxesRepresentation | Osg axes representation implementation for the AxesRepresentation interface in graphics
SurgSim::Graphics::BoxRepresentation | Base graphics box representation class, which defines the basic interface for a box that can be visualized
SurgSim::Graphics::OsgBoxRepresentation | OSG implementation of a graphics box representation
SurgSim::Graphics::Camera | Base graphics camera class, which defines the basic interface for all graphics cameras
SurgSim::Graphics::OsgCamera | OSG implementation of a graphics camera
SurgSim::Graphics::CapsuleRepresentation | Base graphics capsule representation class, which defines the basic interface for a capsule that can be visualized
SurgSim::Graphics::OsgCapsuleRepresentation | OSG implementation of a graphics capsule representation
SurgSim::Graphics::CurveRepresentation | This implements a graphical object to draw an interpolated curve, it accepts a series of control points, the number of segments in the curve will depend on the number of control points and the value returned from getSubdivisions()
SurgSim::Graphics::OsgCurveRepresentation | Implements the CurveRepresentation for OpenSceneGraph, it uses Catmull Rom interpolation, to draw the line as a GL_LINESTRIP
SurgSim::Graphics::CylinderRepresentation | Base graphics cylinder representation class, which defines the basic interface for a cylinder that can be visualized
SurgSim::Graphics::OsgCylinderRepresentation | OSG implementation of a graphics Cylinder representation
SurgSim::Graphics::Light | Abstract interface for a light, a light needs to be assigned to a group to be active, only the members of this group will be considered to be lit by this light
SurgSim::Graphics::OsgLight | OpenScenegraph implementation for the Light interface
SurgSim::Graphics::MeshRepresentation | Graphics representation of a mesh, can be initialized from a Mesh structure
SurgSim::Graphics::OsgMeshRepresentation | Implementation of a MeshRepresentation for rendering under osg
SurgSim::Graphics::OctreeRepresentation | Graphic representation of an Octree
SurgSim::Graphics::OsgOctreeRepresentation | OSG octree representation, implements an OctreeRepresenation using OSG
SurgSim::Graphics::OsgRepresentation | Base OSG implementation of a graphics representation
SurgSim::Graphics::OsgAxesRepresentation | Osg axes representation implementation for the AxesRepresentation interface in graphics
SurgSim::Graphics::OsgBoxRepresentation | OSG implementation of a graphics box representation
SurgSim::Graphics::OsgCamera | OSG implementation of a graphics camera
SurgSim::Graphics::OsgCapsuleRepresentation | OSG implementation of a graphics capsule representation
SurgSim::Graphics::OsgCurveRepresentation | Implements the CurveRepresentation for OpenSceneGraph, it uses Catmull Rom interpolation, to draw the line as a GL_LINESTRIP
SurgSim::Graphics::OsgCylinderRepresentation | OSG implementation of a graphics Cylinder representation
SurgSim::Graphics::OsgLight | OpenScenegraph implementation for the Light interface
SurgSim::Graphics::OsgMeshRepresentation | Implementation of a MeshRepresentation for rendering under osg
SurgSim::Graphics::OsgOctreeRepresentation | OSG octree representation, implements an OctreeRepresenation using OSG
SurgSim::Graphics::OsgPlaneRepresentation | OSG implementation of a graphics plane representation
SurgSim::Graphics::OsgPointCloudRepresentation | Osg point cloud representation, implementation of a PointCloudRepresenation using OSG
SurgSim::Graphics::OsgSceneryRepresentation | A OsgSceneryRepresentation is used to load osg object/node from file
SurgSim::Graphics::OsgScreenSpaceQuadRepresentation | Implements the ScreenSpaceQuadRepresentation, provides the uniform 'texture' for the texture that it carries
SurgSim::Graphics::OsgSkeletonRepresentation | Skeleton representation is used to move a mesh based on the movements of pre-selected control points (bones)
SurgSim::Graphics::OsgSphereRepresentation | OSG implementation of a graphics sphere representation
SurgSim::Graphics::OsgTextRepresentation | Osg implementation of the TextRepresentation, to be used with OsgFont assets
SurgSim::Graphics::OsgVectorFieldRepresentation | OSG vector field representation, implements a VectorFieldRepresenation using OSG
SurgSim::Graphics::PlaneRepresentation | Base graphics plane representation class, which defines the basic interface for a plane that can be visualized
SurgSim::Graphics::OsgPlaneRepresentation | OSG implementation of a graphics plane representation
SurgSim::Graphics::PointCloudRepresentation | Graphic representation of a point cloud, hase a very basic interface and is intentionally kept generic
SurgSim::Graphics::OsgPointCloudRepresentation | Osg point cloud representation, implementation of a PointCloudRepresenation using OSG
SurgSim::Graphics::SceneryRepresentation | Base class defining the interface for a Graphics Scenery Object
SurgSim::Graphics::OsgSceneryRepresentation | A OsgSceneryRepresentation is used to load osg object/node from file
SurgSim::Graphics::ScreenSpaceQuadRepresentation | A quad to display on the screen in screen space coordinates, use setPose() to set the position but x,y are presumed to be in screen space with 0|0 being in the lower left corner
SurgSim::Graphics::OsgScreenSpaceQuadRepresentation | Implements the ScreenSpaceQuadRepresentation, provides the uniform 'texture' for the texture that it carries
SurgSim::Graphics::SkeletonRepresentation | Skeleton representation is used to move a mesh based on the movements of pre-selected control points (bones)
SurgSim::Graphics::OsgSkeletonRepresentation | Skeleton representation is used to move a mesh based on the movements of pre-selected control points (bones)
SurgSim::Graphics::SphereRepresentation | Base graphics sphere representation class, which defines the basic interface for a sphere that can be visualized
SurgSim::Graphics::OsgSphereRepresentation | OSG implementation of a graphics sphere representation
SurgSim::Graphics::TextRepresentation | A text to be displayed on the screen in screen space coordinates, use setPose() to set the position but x,y are presumed to be in screen space with 0|0 being in the lower left corner, has a default font but can also received a separate font
SurgSim::Graphics::OsgTextRepresentation | Osg implementation of the TextRepresentation, to be used with OsgFont assets
SurgSim::Graphics::VectorFieldRepresentation | Graphic representation of a vector field Each point/location, i.e
SurgSim::Graphics::OsgVectorFieldRepresentation | OSG vector field representation, implements a VectorFieldRepresenation using OSG
SurgSim::Input::InputComponent | InputComponents connect devices to SceneElements, facilitating data transfer from a device to SceneElements and other Components
SurgSim::Testing::MockInputComponent | A MockInputComponent allows Components to test connections with devices without using an instance of DeviceInterface (and then an InputManager to connect the device with the InputComponent, etc)
SurgSim::Input::OutputComponent | OutputComponents connect SceneElements to devices, facilitating data transfer from a SceneElement to a device
SurgSim::Input::CombiningOutputComponent | CombiningOutputComponents is-a OutputComponent that takes one or more OutputComponents and combines their datagroups into a single output datagroup
SurgSim::Particles::Representation | Defines the base class for all Particle System
SurgSim::Particles::SphRepresentation | SphRepresentation is a Representation dedicated to Smoothed-Particles Hydrodynamics (SPH)
SurgSim::Physics::Representation | Defines the base class for all physics objects
SurgSim::Physics::DeformableRepresentation | Base class for all deformable representations MassSprings, Finite Element Models,..
SurgSim::Physics::FemRepresentation | Finite Element Model (a.k.a FEM) is a deformable model (a set of nodes connected by FemElement)
SurgSim::Physics::Fem1DRepresentation | Finite Element Model 1D is a fem built with 1D FemElement
SurgSim::Physics::Fem2DRepresentation | Finite Element Model 2D is a fem built with 2D FemElement
SurgSim::Physics::Fem3DRepresentation | Finite Element Model 3D is a fem built with 3D FemElement
SurgSim::Physics::MassSpringRepresentation | MassSpring model is a deformable model (a set of masses connected by springs)
SurgSim::Blocks::MassSpring1DRepresentation |
SurgSim::Blocks::MassSpring2DRepresentation |
SurgSim::Blocks::MassSpring3DRepresentation |
SurgSim::Physics::RigidRepresentationBase | Defines the base class for all rigid motion based representations (fixed, rigid body, rigid body + vtc,...)
SurgSim::Physics::FixedRepresentation | Physics entity without any motion nor compliance against which others physics entities can interact
SurgSim::Physics::RigidRepresentation | Defines the dynamic rigid body representation Note that the rigid representation is velocity-based, therefore its degrees of freedom are the linear and angular velocities: 6 Dof
SurgSim::Graphics::Material | Base class that defines the interface for graphics materials
SurgSim::Graphics::OsgMaterial | OSG-based implementation of a graphics material
SurgSim::Graphics::View | Base graphics view class, which defines the basic interface for all graphics views
SurgSim::Graphics::OsgView | OSG-based implementation of graphics view class
SurgSim::Devices::OculusView | OculusView is a customization of SurgSim::Graphics::OsgView with projection matrices pulled from the Oculus device
SurgSim::Physics::ConstraintComponent | Component class for inserting constraints between physics representations into the scene
SurgSim::Graphics::UniformBase | Common base class for all graphics uniforms
SurgSim::Graphics::OsgUniformBase | Base OSG implementation of graphics uniforms
SurgSim::Graphics::OsgTextureUniform< OsgTexture1d > |
SurgSim::Graphics::OsgUniform< std::shared_ptr< OsgTexture1d > > | Specialization of OsgUniform for OsgTexture1d
SurgSim::Graphics::OsgTextureUniform< OsgTexture2d > |
SurgSim::Graphics::OsgUniform< std::shared_ptr< OsgTexture2d > > | Specialization of OsgUniform for OsgTexture2d
SurgSim::Graphics::OsgTextureUniform< OsgTexture3d > |
SurgSim::Graphics::OsgUniform< std::shared_ptr< OsgTexture3d > > | Specialization of OsgUniform for OsgTexture3d
SurgSim::Graphics::OsgTextureUniform< OsgTextureCubeMap > |
SurgSim::Graphics::OsgUniform< std::shared_ptr< OsgTextureCubeMap > > | Specialization of OsgUniform for OsgTextureCubeMap
SurgSim::Graphics::OsgTextureUniform< OsgTextureRectangle > |
SurgSim::Graphics::OsgUniform< std::shared_ptr< OsgTextureRectangle > > | Specialization of OsgUniform for OsgTextureRectangle
SurgSim::Graphics::OsgTextureUniform< T > | OSG implementation of graphics uniform with a texture value
SurgSim::Graphics::OsgUniform< T > | OSG implementation of graphics uniform with a value of type T
SurgSim::Graphics::OsgUniform< std::vector< T > > | Specialization of OsgUniform for vectors of values
SurgSim::Graphics::Uniform< T > | Base class for a graphics uniform with a value of type T
SurgSim::Graphics::OsgUniform< T > | OSG implementation of graphics uniform with a value of type T
SurgSim::Graphics::Uniform< std::vector< T > > | Specialization of Uniform for vectors of values
SurgSim::Graphics::OsgUniform< std::vector< T > > | Specialization of OsgUniform for vectors of values
SurgSim::Graphics::Uniform< std::shared_ptr< OsgTexture1d > > |
SurgSim::Graphics::OsgTextureUniform< OsgTexture1d > |
SurgSim::Graphics::Uniform< std::shared_ptr< OsgTexture2d > > |
SurgSim::Graphics::OsgTextureUniform< OsgTexture2d > |
SurgSim::Graphics::Uniform< std::shared_ptr< OsgTexture3d > > |
SurgSim::Graphics::OsgTextureUniform< OsgTexture3d > |
SurgSim::Graphics::Uniform< std::shared_ptr< OsgTextureCubeMap > > |
SurgSim::Graphics::OsgTextureUniform< OsgTextureCubeMap > |
SurgSim::Graphics::Uniform< std::shared_ptr< OsgTextureRectangle > > |
SurgSim::Graphics::OsgTextureUniform< OsgTextureRectangle > |
SurgSim::Graphics::Uniform< std::shared_ptr< T > > |
SurgSim::Graphics::OsgTextureUniform< T > | OSG implementation of graphics uniform with a texture value
SurgSim::Input::DeviceInterface | Interface used to communicate with user-interface hardware devices
SurgSim::Devices::FilteredDevice | A DeviceInterface connected in series with one or more DeviceFilters. Useful for serialization
SurgSim::Devices::MultiAxisDevice | A class implementing the communication with a multi-axis controller input device, for example a 3DConnexion SpaceNavigator
SurgSim::Input::CommonDevice | A class that implements some common management code on top of the DeviceInterface
SurgSim::Devices::DeviceFilter | A device filter can be connected between a device and the InputConsumerInterface (e.g., InputComponent) and/or the OutputProducerInterface (e.g., OutputComponent), and can alter the data being passed from/to the device
LabJackToPoseFilter |
SurgSim::Devices::BoolToScalar | Maps the on and off state of two boolean values to the increase and decrease of a scalar field, this for example enables the driving on a scalar value through two buttons on a device, no change occurs when both booleans are true at the same time
SurgSim::Devices::ForceScale | An output device filter that scales forces and/or torques
SurgSim::Devices::PoseIntegrator | A device filter that integrates the pose, turning a relative device into an absolute one
SurgSim::Devices::PoseTransform | A device filter that transforms the input pose
SurgSim::Devices::RecordPose | An input device filter that record the input pose along with the relative time
SurgSim::Devices::IdentityPoseDevice | A class implementing the identity pose device, which is a pretend device that doesn't move
SurgSim::Devices::KeyboardDevice | A class implementing the communication with a keyboard
SurgSim::Devices::LabJackDevice | A class implementing the communication with a LabJack data acquisition (DAQ) device
SurgSim::Devices::LeapDevice | A class implementing the communication with one hand tracked by Leap Motion camera
SurgSim::Devices::MouseDevice | A class implementing the communication with a mouse
SurgSim::Devices::NimbleDevice | A class implementing the communication with the Nimble server
SurgSim::Devices::NovintDevice | A class implementing the communication with a Novint Falcon device
SurgSim::Devices::OculusDevice | A class implementing the communication with Oculus Rift DK2
SurgSim::Devices::OpenNIDevice | A class implementing the communication with one OpenNI compatible depth camera
SurgSim::Devices::PhantomDevice | A class implementing the communication with a SensAble/Geomagic PHANTOM device
SurgSim::Devices::RawMultiAxisDevice | A class implementing the communication with a multi-axis controller input device, for example a 3DConnexion SpaceNavigator
SurgSim::Devices::ReplayPoseDevice | A class implementing the replay pose device, which is a pretend device that replays a recorded motion from a file
SurgSim::Devices::SixenseDevice | A class implementing the communication with one Sixense controller, for example one of the two on the Razer Hydra
SurgSim::Devices::TrackIRDevice | A class implementing the communication with Natural Point TrackIR camera
SurgSim::Math::Shape | Generic rigid shape class defining a shape
SurgSim::Math::BoxShape | Box shape: box centered on (0 0 0), aligned with the axis with different sizes along X, Y and Z
SurgSim::Math::CapsuleShape | Capsule shape: centered on (0, 0, 0), aligned along Y, with length and radius
SurgSim::Math::CompoundShape |
SurgSim::Math::CylinderShape | Cylinder shape: centered on (0 0 0), aligned along Y, defined with length and radius
SurgSim::Math::DoubleSidedPlaneShape | DoubleSidedPlaneShape: The XZ plane (d = 0) with normal pointing along positive Y axis
SurgSim::Math::MeshShape | Mesh shape: shape made of a triangle mesh The triangle mesh needs to be watertight to produce valid volume, center and second moment of volume
SurgSim::Math::OctreeShape | Octree Shape A defined by an octree data structure
SurgSim::Math::ParticlesShape | Particles Shape: A shape consisting of a group of particles of equal radius
SurgSim::Math::PlaneShape | The XZ plane (d = 0) with normal pointing along positive Y axis
SurgSim::Math::SegmentMeshShape | SegmentMeshShape defines a shape based on a mesh, like MeshShape
SurgSim::Math::SphereShape | Sphere shape: sphere centered on (0 0 0), defined with radius
SurgSim::Physics::RigidState | Describes a state (position and velocity information)
SurgSim::Devices::LabJack::AnalogInputSettings | A struct holding the data to be associated with the positive channel for an analog input
SurgSim::Framework::ApplicationData | Enable searching for files in a given list of paths, give access to the current directory and wrap boost::filesystem functionality
SurgSim::Framework::Barrier | Barrier class, synchronize a set of threads to wait at a common point, all threads will wait at Barrier::wait(val) until the number of threads calling wait is equal to the number given in the constructor
SurgSim::Framework::BasicThread | Basic thread implementation, tries to maintain a constant rate, supplies startup an initialization, can be synchronized with other threads at startup after calling doRun() a thread be be set off and doInit() and doStartup() will be called in succession
SurgSim::Devices::LabJackThread | A class implementing the thread context for communicating with LabJack devices
SurgSim::Devices::NimbleScaffold | A class that manages Nimble devices
SurgSim::Devices::OculusScaffold | A class that manages Oculus Rift DK2 devices
SurgSim::Devices::OpenNIScaffold | A class that manages OpenNI devices
SurgSim::Devices::RawMultiAxisThread | A class implementing the thread context for sampling RawMultiAxis devices
SurgSim::Devices::ReplayPoseScaffold |
SurgSim::Devices::SixenseThread | A class implementing the thread context for sampling Sixense devices
SurgSim::Devices::TrackIRThread | A class implementing the thread context for sampling TrackIR devices
SurgSim::Framework::ComponentManager | Base Component Manager class
SurgSim::Framework::BehaviorManager | Manager to handle Behaviors
SurgSim::Graphics::Manager | Basic graphics manager class which manages graphics components to provide a visualization of the scene to the user
SurgSim::Graphics::OsgManager | OSG-based implementation of graphics manager class
SurgSim::Input::InputManager | Manager to handle InputComponent and OutputComponent, SceneElement can add these to get input from devices, or even write output to devices
SurgSim::Physics::PhysicsManager | PhyicsManager handles the physics and motion calculation, it uses Computations to separate the algorithmic steps into smaller pieces
SurgSim::Testing::MockPhysicsManager | Testing class used to publicly expose PhysicsManager's protected member functions
SurgSim::Devices::BitSetBuffer< N > | A bit set corresponding to a contiguous memory buffer
SurgSim::Graphics::BoneData | Local data structure to store the bones and their references to the transforms
SurgSim::DataStructures::OctreeNodePlyReaderDelegateBase::BoundsData | Data Structure to receive the bounds information
SurgSim::DataStructures::BufferedValue< T > | BufferedValue is a class to enable a representation of two values for one variable, where both values need to be accessible at the same time, one in a thread safe, single threaded context, the other in a thread unsafe context
SurgSim::DataStructures::BufferedValue< ContactMapType > |
SurgSim::DataStructures::BufferedValue< SurgSim::DataStructures::Vertices > |
SurgSim::DataStructures::BufferedValue< SurgSim::Math::Vector6d > |
SurgSim::Devices::NovintScaffold::Callback |
SurgSim::Devices::PhantomScaffold::Callback |
SurgSim::DataStructures::Grid< T, N >::CellContent | Data structure for a cell's content (the list of elements and the list of all the neighbors)
SurgSim::Math::clampOperator< T > | Define a custom template unary functor to execute the clamp operation over an Eigen matrix structure
SurgSim::Collision::CollisionPair | Collision Pair class, it signifies a pair of items that should be checked with the collision algorithm, this structure will be used for input as well as output, as contacts get appended to the contacts list when found
SurgSim::Physics::Computation | Encapsulates a calculation over a selection of objects, needs to be subclassed to be used
SurgSim::Physics::BuildMlcp | Build an mlcp from a list of constraints stored in a PhysicsManagerState
SurgSim::Physics::CcdCollision | Computation to determine the contacts between a list of CollisionPairs
SurgSim::Physics::CcdCollisionLoop |
SurgSim::Physics::ComputationGroup | Implements a mechanism to group and loop computations, the computations will be called in sequence repeatedly until one of the exit criteria is met
SurgSim::Physics::ContactConstraintGeneration | Generate a constraint for every contact that was calculated
SurgSim::Physics::ContactFiltering | Computation to determine filter the contacts on collisions pairs
SurgSim::Physics::DcdCollision | Computation to determine the contacts between a list of CollisionPairs
SurgSim::Physics::FreeMotion | Apply the FreeMotion calculation to all physics representations
SurgSim::Physics::ParticleCollisionResponse | Allows the Particle Representations to respond to collisions
SurgSim::Physics::PostUpdate | Post Update is called prior to anything else at the beginning of each time step
SurgSim::Physics::PrepareCollisionPairs | Computation to determine the contacts between a list of CollisionPairs
SurgSim::Physics::PreUpdate | Pre Update is called after everything else is done in the physics time step
SurgSim::Physics::PushResults | Propagates the Mlcp result to the representations
SurgSim::Physics::SolveMlcp | Solve the system Mixed Linear Complementarity Problem (Mlcp)
SurgSim::Physics::UpdateCcdData |
SurgSim::Physics::UpdateCollisionData |
SurgSim::Physics::UpdateCollisionRepresentations | Computation that calls the CollisionRepresentations update() function
SurgSim::Physics::UpdateDcdData |
SurgSim::Physics::Constraint | Base class for all physics constraints. Contains data specific to the constraint and a pair of implementations
SurgSim::Physics::RotationVectorConstraint | Specific class for rotation vector constraints
SurgSim::Physics::SlidingConstraint | Sliding constraint between two physics representations
SurgSim::Physics::ConstraintData | Base class for all CosntraintData Derived classes should be specific to a given constraint
SurgSim::Physics::ContactConstraintData | Class for Frictionless contact (only needs a plane equation)
SurgSim::Physics::RotationVectorRigidFem1DConstraintData | Class for rotation vector constraint data between a rigid/fixed representation and Fem1d beam being controlled
SurgSim::Physics::SlidingConstraintData | Class for Frictionless sliding constraint (stores two planes, the intersection of which, is the sliding direction)
SurgSim::Physics::ConstraintImplementation | Base class for all constraint implementations. A ConstraintImplementation defines 1 side of a constraint
SurgSim::Physics::FemConstraintFixedPoint | Base class for all FemRepresentation fixed point constraint implementation
SurgSim::Physics::FemConstraintFixedRotationVector | Base class for all FemRepresentation fixed rotation vector constraint implementation
SurgSim::Physics::FemConstraintFrictionalSliding | Base class for all FemRepresentation frictional sliding constraint implementation
SurgSim::Physics::FemConstraintFrictionlessContact | Base class for all FemRepresentation frictionless contact constraint implementation
SurgSim::Physics::FemConstraintFrictionlessSliding | Base class for all FemRepresentation frictionless sliding constraint implementation
SurgSim::Physics::FixedConstraintFixedPoint | FixedRepresentation bilateral 3d constraint implementation
SurgSim::Physics::FixedConstraintFixedRotationVector | FixedRepresentation fixed rotation vector constraint
SurgSim::Physics::FixedConstraintFrictionlessContact | FixedRepresentation frictionless contact implementation
SurgSim::Physics::MassSpringConstraintFixedPoint | MassSpringRepresentation bilateral 3d constraint implementation
SurgSim::Physics::MassSpringConstraintFrictionlessContact | MassSpring frictionless contact implementation
SurgSim::Physics::RigidConstraintFixedPoint | RigidRepresentation bilateral 3d constraint implementation
SurgSim::Physics::RigidConstraintFixedRotationVector | RigidRepresentationBase fixed rotation vector constraint
SurgSim::Physics::RigidConstraintFrictionlessContact | RigidRepresentation frictionless contact implementation
SurgSim::Physics::ConstraintImplementationFactory | This class manages ConstraintImplementations, and can be used to look up the correct implementation by representation and constraint type
SurgSim::Collision::Contact | Contact data structure used when two representations touch each other The convention is that if body 1 is moved along the normal vector by a distance depth (or equivalently if body 2 is moved the same distance in the opposite direction) then the penetration depth will be reduced to zero
SurgSim::Collision::ContactCalculation | Base class responsible for calculating contact data between two objects
SurgSim::Collision::ShapeShapeContactCalculation< Math::BoxShape, Math::CapsuleShape > |
SurgSim::Collision::BoxCapsuleContact | Class to calculate intersections between Boxes and Capsules
SurgSim::Collision::ShapeShapeContactCalculation< Math::BoxShape, Math::DoubleSidedPlaneShape > |
SurgSim::Collision::BoxDoubleSidedPlaneContact | Class to calculate intersections between Boxes and Planes
SurgSim::Collision::ShapeShapeContactCalculation< Math::BoxShape, Math::PlaneShape > |
SurgSim::Collision::BoxPlaneContact | Class to calculate intersections between Boxes and Planes
SurgSim::Collision::ShapeShapeContactCalculation< Math::BoxShape, Math::SphereShape > |
SurgSim::Collision::BoxSphereContact | Class to calculate intersections between a box and a sphere
SurgSim::Collision::ShapeShapeContactCalculation< Math::CapsuleShape, Math::SphereShape > |
SurgSim::Collision::CapsuleSphereContact | Class to calculate intersections between a capsule and a sphere
SurgSim::Collision::ShapeShapeContactCalculation< Math::MeshShape, Math::MeshShape > |
SurgSim::Collision::TriangleMeshTriangleMeshContact | Class to calculate intersections between a triangle mesh and a triangle mesh
SurgSim::Collision::ShapeShapeContactCalculation< Math::MeshShape, Math::ParticlesShape > |
SurgSim::Collision::TriangleMeshParticlesContact | Class to calculate intersections between a triangle mesh and particles
SurgSim::Collision::ShapeShapeContactCalculation< Math::MeshShape, Math::PlaneShape > |
SurgSim::Collision::TriangleMeshPlaneContact | Class to calculate intersections between a triangle mesh and a plane
SurgSim::Collision::ShapeShapeContactCalculation< Math::MeshShape, Math::SurfaceMeshShape > |
SurgSim::Collision::TriangleMeshSurfaceMeshContact | Class to calculate intersections between a surface mesh and a triangle/surface mesh
SurgSim::Collision::ShapeShapeContactCalculation< Math::SegmentMeshShape, Math::MeshShape > |
SurgSim::Collision::SegmentMeshTriangleMeshContact | Class to calculate intersections between a segment mesh and a triangle mesh
SurgSim::Collision::ShapeShapeContactCalculation< Math::SegmentMeshShape, Math::SegmentMeshShape > |
SurgSim::Collision::SegmentSelfContact | SegmentSelfContact computes the self collisions among a SegmentMesh under motion at two time points parametrized over the time interval [0,1]
SurgSim::Collision::ShapeShapeContactCalculation< Math::SphereShape, Math::DoubleSidedPlaneShape > |
SurgSim::Collision::SphereDoubleSidedPlaneContact | Class to calculate intersections between Spheres and DoubleSidedPlanes
SurgSim::Collision::ShapeShapeContactCalculation< Math::SphereShape, Math::PlaneShape > |
SurgSim::Collision::SpherePlaneContact | Class to calculate intersections between Spheres and Planes
SurgSim::Collision::ShapeShapeContactCalculation< Math::SphereShape, Math::SphereShape > |
SurgSim::Collision::SphereSphereContact | Class to calculate intersections between spheres
SurgSim::Collision::CompoundShapeContact |
SurgSim::Collision::DefaultContactCalculation | A default calculation, it does nothing and can be used as a placeholder
SurgSim::Collision::OctreeContact | Abstract base class to calculate intersections between an Octree and other shapes
SurgSim::Collision::OctreeCapsuleContact |
SurgSim::Collision::OctreeDoubleSidedPlaneContact |
SurgSim::Collision::OctreePlaneContact |
SurgSim::Collision::OctreeSphereContact |
SurgSim::Collision::ShapeShapeContactCalculation< Shape1, Shape2 > | Class that can automate the type conversion and provides a consistent interface to the typed call Takes the shapes to convert as template parameters
YAML::convert< std::shared_ptr< SurgSim::Framework::Asset > > |
YAML::convert< std::shared_ptr< SurgSim::Framework::Component > > | Specialization of YAML::convert for std::shared_ptr<Component>, use this for to read in a component written by the convert<SurgSim::Framework::Component> converter, or a reference to a component written by this converter
YAML::convert< std::shared_ptr< SurgSim::Framework::Scene > > |
YAML::convert< std::shared_ptr< SurgSim::Framework::SceneElement > > |
YAML::convert< std::shared_ptr< SurgSim::Math::Shape > > |

YAML::convert< std::shared_ptr< T > >

Specialization of YAML::convert for std::shared_ptr, this is used to redirect the serialization of a derived class to the specialization of the serialization for a base class, for example all subclasses of Component can use the Component serialization specialization, currently each redirection has to be implemented separately, the re is probably a way to do this automatically

YAML::convert< std::unordered_map< Key, T > > | YAML::convert specialization for std::unordered_map
YAML::convert< std::unordered_set< Value > > | YAML::convert specialization for std::unordered_set
YAML::convert< std::vector< std::shared_ptr< SurgSim::Framework::SceneElement > > > |
YAML::convert< SurgSim::DataStructures::OptionalValue< T > > | YAML::convert specialization for OptionalValue
YAML::convert< SurgSim::Framework::Component > | Override of the convert structure for an Component, use this form to write out a full version of the component information, to decode a component use the other converter
YAML::convert< SurgSim::Framework::SceneElement > |
YAML::convert< SurgSim::Graphics::Representation > | Specialize of YAML::convert<> template Represensation class
YAML::convert< SurgSim::Graphics::SphereRepresentation > | Specialize of YAML::convert<> template SphereRepresensation class
YAML::convert< SurgSim::Math::IntegrationScheme > |
YAML::convert< SurgSim::Math::LinearSolver > |
YAML::convert< SurgSim::Physics::RigidState > |
YAML::convert< typename Eigen::AngleAxis< Type > > | Specialization of convert for Eigen::AngleAxis
YAML::convert< typename Eigen::Matrix< Type, Rows, Cols, MOpt > > | Specialization of convert for fixed size Eigen::Matrix
YAML::convert< typename Eigen::Quaternion< Type, QOpt > > | Specialization of convert for Eigen::Quaternion
YAML::convert< typename Eigen::Transform< Type, Dim, TMode, TOptions > > | Specialization of convert for Eigen::RigidTransform
SurgSim::DataStructures::PlyReader::Data |
SurgSim::DataStructures::DataGroup | A collection of NamedData objects
SurgSim::DataStructures::DataGroupBuilder | A class that allows you to build a DataGroup structure
SurgSim::DataStructures::DataGroupCopier | A class that assists in copying from one DataGroup to another, when assignment is not possible
SurgSim::Framework::ReuseFactory< T >::Deleter | Custom deleter to keep unused objects for reuse, rather than actually deleting them
SurgSim::Devices::KeyboardScaffold::DeviceData | Struct to hold a KeyboardDevice object, a KeyboardHandler object, and a mutex for data passing
SurgSim::Devices::LabJackScaffold::DeviceData | The per-device data
SurgSim::Devices::LeapScaffold::DeviceData |
SurgSim::Devices::MouseScaffold::DeviceData | Struct to hold a MouseDevice object, a OsgMouseHandler, and a mutex for data passing
SurgSim::Devices::RawMultiAxisScaffold::DeviceData |
SurgSim::Devices::NovintScaffold::DeviceData |
SurgSim::Devices::OculusScaffold::DeviceData |
SurgSim::Devices::OpenNIScaffold::DeviceData |
SurgSim::Devices::PhantomScaffold::DeviceData |
SurgSim::Devices::ReplayPoseScaffold::DeviceData |
SurgSim::Devices::SixenseScaffold::DeviceData |
SurgSim::Devices::TrackIRScaffold::DeviceData |
SurgSim::DataStructures::OctreeNodePlyReaderDelegateBase::DimensionData | Data structure to receive the dimension information from the file
DisplaySettings |
SurgSim::Devices::OculusDisplaySettings | A customized osg::DisplaySettings, to be used with Oculus device
SurgSim::Physics::FemPlyReaderDelegate::ElementData | Internal data to receive the fem element
SurgSim::DataStructures::PlyReader::ElementInfo | Information about the element in the .ply file
SurgSim::DataStructures::EmptyData | EmptyData class
enable_shared_from_this |
SurgSim::Physics::Fem< FemElementStructs::RotationVectorData, FemElementStructs::FemElement1DParameter > |
SurgSim::Physics::Fem< FemElementStructs::RotationVectorData, FemElementStructs::FemElement2DParameter > |
SurgSim::Physics::Fem< SurgSim::DataStructures::EmptyData, FemElementStructs::FemElement3DParameter > |
SurgSim::DataStructures::OctreeNode< Data > | Octree data structure
SurgSim::DataStructures::TriangleMesh< VertexData, EdgeData, TriangleData > | Basic class for storing Triangle Meshes, handling basic vertex, edge, and triangle functionality
SurgSim::Framework::Component | Component is the main interface class to pass information to the system managers each will decide whether to handle a component of a given type or not
SurgSim::Framework::Runtime | This class contains all the information about the runtime environment of the simulation, all the running threads, the state, while it is de facto a singleton it should be passed around if needed
SurgSim::Framework::Scene | Scene. Basic Container for SceneElements
SurgSim::Framework::SceneElement | SceneElement is the basic part of a scene, it is a container of components
SurgSim::Blocks::SphereElement |
SurgSim::Framework::BasicSceneElement | Simple concrete implementation of a scene element that does not have any higher logic
SurgSim::Blocks::VisualizeConstraints | SceneElement that generates the VisualizeConstraintBehavior and the appropriate graphics Vectorfield
SurgSim::Graphics::ViewElement | Basic SceneElement that wraps a View so that it can be added to the Scene
SurgSim::Graphics::OsgViewElement | OSG-based implementation of graphics view element
SurgSim::Graphics::RenderPass | Encapsulation of all the components necessary needed to implement a full renderpass, this SceneElement contains a Camera and Group, it can also take a Material (for shaders and uniforms) and a RenderTarget for textures that are used as the output for the camera
SurgSim::Graphics::OsgScreenSpacePass | Special RenderPass to draw items using a orthogonal projection, this is specific to the Osg implementation of the SurgSim rendering
SurgSim::Physics::Fem< VertexData, Element > | Base class for a data structure for holding FEM mesh data of different dimensions
SurgSim::DataStructures::TriangleMesh< SurgSim::DataStructures::EmptyData, SurgSim::DataStructures::EmptyData, SurgSim::DataStructures::NormalData > |
SurgSim::DataStructures::TriangleMesh< VertexData, EdgeData, SegmentEmptyData > |
SurgSim::DataStructures::TriangleMesh< VertexData, SurgSim::DataStructures::EmptyData, SurgSim::DataStructures::EmptyData > |
std::exception | STL class
std::runtime_error | STL class
SurgSim::Framework::AssertionFailure | An exception class thrown by SURGSIM_ASSERT() failures and SURGSIM_FAILURE()
SurgSim::Framework::FactoryBase< T > | CRTP Base class to implement Object Factory functionality on a base class, use this rather than writing your own functions to return the factory
SurgSim::Framework::FactoryBase1< T, P > | CRTP Base class to implement Object Factory functionality on a base class, use this rather than writing your own functions to return the factory
SurgSim::Framework::FactoryBase1< Component, std::string > |
SurgSim::Framework::Component | Component is the main interface class to pass information to the system managers each will decide whether to handle a component of a given type or not
SurgSim::Framework::FactoryBase1< DeviceInterface, std::string > |
SurgSim::Input::DeviceInterface | Interface used to communicate with user-interface hardware devices
SurgSim::Framework::FactoryBase< Asset > |
SurgSim::Framework::Asset | This class is used to facilitate file loading
SurgSim::Framework::FactoryBase< Shape > |
SurgSim::Math::Shape | Generic rigid shape class defining a shape
SurgSim::Physics::FemElement | Base class for all Fem Element (1D, 2D, 3D) It handles the node ids to which it is connected and requires all derived classes to compute the element mass matrix and the force vector along with the derivatives (the stiffness and damping matrices)
SurgSim::Physics::Fem1DElementBeam | 1D FemElement based on a beam volume discretization with a fixed cross section
SurgSim::Physics::Fem2DElementTriangle | 2D FemElement based on a triangle with a constant thickness
SurgSim::Physics::Fem3DElementCube | Class for Fem Element 3D based on a cube volume discretization
SurgSim::Physics::Fem3DElementTetrahedron | Class for Fem Element 3D based on a tetrahedron volume discretization
SurgSim::Physics::Fem3DElementCorotationalTetrahedron | Fem Element 3D co-rotational based on a tetrahedron volume discretization
SurgSim::Physics::FemElementStructs::FemElementParameter | FemElementParameter is a structure containing the parameters of an fem element following the Hooke's law of deformation (linear deformation)
SurgSim::Physics::FemElementStructs::FemElement1DParameter | FemElement1DParameter is a FemElementParameter structure specialized for 1D element
SurgSim::Physics::FemElementStructs::FemElement2DParameter | FemElement2DParameter is a FemElementParameter structure specialized for 2D element
SurgSim::Physics::FemElementStructs::FemElement3DParameter | FemElement3DParameter is a FemElementParameter structure specialized for 3D element
SurgSim::Devices::FileDescriptor | A wrapper for an UNIX-style integer file descriptor
SurgSim::Devices::FileHandle | A wrapper for an Windows-style HANDLE file descriptor
SurgSim::Framework::Accessible::Functors | Private struct to keep the map under control
SurgSim::Math::gaussQuadraturePoint | 1D Gauss-Legendre quadrature
SurgSim::Math::gaussQuadratureTrianglePoint | 2D Gauss-Legendre quadrature on a triangle
SurgSim::Graphics::GenerateTangentSpaceTriangleIndexFunctor | Triangle index functor which calculates the tangent space basis vectors for the vertices of a geometry from texture coordinates
GlutCamera | Camera which controls the view of the scene
GlutRenderer | Simple static class renderer built on Glut
GlutRenderObject | Abstract definition of an object that can render itself with Glut
GlutAxes | Axes with center at local origin, red axis along the local X-axis, green axis along the local Y-axis, and blue axis along the local Z-axis
GlutGroup | Group of objects which provides a transform hierarchy
GlutImage | An Image drawn to the screen
GlutSphere | Sphere with center at local origin
GlutSquare | Square with center at local origin
SurgSim::DataStructures::Grid< T, N > | N-dimensional grid structure with uniform non-cubic cells This data structure is useful to search for neighbors in a given range (the size of each cell)
SurgSim::Graphics::Group | Base graphics group class, which defines the interface that all graphics groups must implement
SurgSim::Graphics::OsgGroup | OSG implementation of a graphics group
SurgSim::DataStructures::Groups< Key, T > | Class to wrap grouping operations, gives access to the members of a group and the groups of members
SurgSim::DataStructures::Groups< std::string, std::shared_ptr< SurgSim::Framework::SceneElement > > |
GUIEventHandler |
SurgSim::Devices::OsgKeyboardHandler |
SurgSim::Devices::OsgMouseHandler |
SurgSim::Devices::LabJackScaffold::Handle |
SurgSim::Devices::NovintScaffold::Handle |
SurgSim::Devices::PhantomScaffold::Handle |
SurgSim::DataStructures::ImageBase< T > | Base class for Image-like classes
SurgSim::DataStructures::Image< T > | A templated Image class
SurgSim::DataStructures::ImageMap< T > | A class that behaves like an Image but maps an existing array of data
SurgSim::DataStructures::IndexDirectory | A simple bidirectional mapping between names (strings) and distinct consecutive non-negative indices
SurgSim::DataStructures::IndexedLocalCoordinate | A generic (size_t index, Vector coordinate) pair
SurgSim::Input::InputConsumerInterface | Interface for a consumer that monitors device and signal state updates (pose, buttons, etc)
GlutWindow |
ImageGlutWindow |
MovingSquareForce | A simple listener to calculate collision force against a square area for the example application
MovingSquareGlutWindow | A simple listener to display the simple scene composed of a square and tool for the example application
SurgSim::Devices::DeviceFilter | A device filter can be connected between a device and the InputConsumerInterface (e.g., InputComponent) and/or the OutputProducerInterface (e.g., OutputComponent), and can alter the data being passed from/to the device
SurgSim::Input::InputComponent | InputComponents connect devices to SceneElements, facilitating data transfer from a device to SceneElements and other Components
SurgSim::Testing::MockInputOutput |
TestListener |
TestListener |
SurgSim::Math::Interval< T > | Interval defines the concept of a mathematical interval and provides operations on it including arithmetic operations, construction, and IO
SurgSim::Math::IntervalND< T, N > | IntervalND defines the concept of a group of mathematical intervals and provides operations on them including arithmetic operations, construction, and IO
SurgSim::Math::IntervalND< T, 3 > | IntervalND<T,3> defines the concept of a group of mathematical intervals specialized to 3 intervals and provides operations on them including arithmetic operations, construction, and IO
SurgSim::Math::KalmanFilter< M, N > | Implements a linear Kalman filter, a recursive estimator
SurgSim::Devices::KeyboardScaffold | A class that implements the behavior of KeyboardDevice objects
SurgSim::Devices::LabJackScaffold | A class that implements the behavior of LabJackDevice objects
SurgSim::Devices::LeapScaffold | A class that manages Leap devices
SurgSim::Math::LinearMotion< T > | LinearMotion is (intentionally) a lot like Interval, but it deals with linear motion where all operands start and end their motion simultaneously
SurgSim::Math::LinearMotion< double > |
SurgSim::Math::LinearMotionND< T, N > | LinearMotionND<T, N> defines the concept of a group of linear motions and provides operations on them including arithmetic operations, construction, and I/O
SurgSim::Math::LinearMotionND< double, 3 > |
SurgSim::Math::LinearMotionND< T, 3 > | LinearMotionND<T, 3> specializes the LinearMotionND<T, N> class for 3 dimensions
SurgSim::Math::LinearSolveAndInverse | LinearSolveAndInverse aims at performing an efficient linear system resolution and calculating its inverse matrix at the same time
SurgSim::Math::LinearSolveAndInverseDenseMatrix | Derivation for dense matrix type
SurgSim::Math::LinearSolveAndInverseDiagonalMatrix | Derivation for diagonal matrix type
SurgSim::Math::LinearSolveAndInverseTriDiagonalBlockMatrix< BlockSize > | Derivation for tri-diagonal block matrix type
SurgSim::Math::LinearSolveAndInverseSymmetricTriDiagonalBlockMatrix< BlockSize > | Derivation for symmetric tri-diagonal block matrix type
SurgSim::Math::LinearSparseSolveAndInverse | LinearSparseSolveAndInverse aims at performing an efficient linear system resolution and calculating its inverse matrix at the same time
SurgSim::Math::LinearSparseSolveAndInverseCG | Derivation for sparse CG solver
SurgSim::Math::LinearSparseSolveAndInverseLU | Derivation for sparse LU solver
SurgSim::DataStructures::TriangleMeshPlyReaderDelegate< M >::ListData | Internal structure, the received for data from the "face" element
Listener |
SurgSim::Devices::LeapScaffold::Listener |
SurgSim::Physics::Localization | This class localize a point on a representation (representation specific)
SurgSim::Physics::FemLocalization | Implementation of Localization for Fem3DRepresentation
SurgSim::Physics::Fem1DLocalization | Implementation of Localization for Fem1DRepresentation
SurgSim::Physics::Fem2DLocalization | Implementation of Localization for Fem2DRepresentation
SurgSim::Physics::Fem3DLocalization | Implementation of Localization for Fem3DRepresentation
SurgSim::Physics::MassSpringLocalization | Implementation of Localization for MassSpringRepresentation
SurgSim::Physics::RigidLocalization | This class implements the localization on a RigidRepresentationBase, as a local position
SurgSim::DataStructures::Location | A Location defines a local position w.r.t
SurgSim::Framework::LockedContainer< T > | A simple thread-safe data container that can support multiple writers and readers
SurgSim::Framework::LockedContainer< MovingSquareForce::SquarePoseVectors > |
SurgSim::Framework::LockedContainer< SurgSim::DataStructures::DataGroup > |
SurgSim::Framework::LockedContainer< SurgSim::DataStructures::Image > |
SurgSim::Framework::LockedContainer< SurgSim::DataStructures::Vertices > |
SurgSim::Framework::LockedContainer< SurgSim::Graphics::Mesh > |
SurgSim::Framework::LockedContainer< SurgSim::Physics::PhysicsManagerState > |
SurgSim::Framework::Logger | An object that can be used to control logging parameters, such as verbosity and log output destination
SurgSim::Framework::LoggerManager | Class to safely handle access to a group of loggers, manipulate the global logging threshold, and fetch logger(s) from a global pool
SurgSim::Framework::LogMessageBase | LogMessageBase is a base class to be used to customize messages for logging textual information can be put into a log message by using the << operator in general the message class will output all of its information when the destructor is being invoked, formats the incoming message to timestamp it and adds information about the logger
SurgSim::Framework::AssertMessage | An internal message class used for assertion failures
SurgSim::Framework::LogMessage | Specialization, handles flush on destruction
SurgSim::Framework::LogOutput | Virtual Base class to define an interface for outputting logging information
SurgSim::Framework::FileOutput | Class to output logging information to a give file
SurgSim::Framework::NullOutput |
SurgSim::Framework::StreamOutput | Class to output logging information to a stream that can be passed into the constructor of the class
SurgSim::Physics::Mass |
SurgSim::Physics::FemPlyReaderDelegate::MaterialData | Internal data to receive the "material" data
SurgSim::DataStructures::MeshElement< N, Data > | Element structure for meshes
SurgSim::Physics::MlcpMapping< T > |
SurgSim::Physics::MlcpMapping< SurgSim::Physics::Constraint > |
SurgSim::Physics::MlcpMapping< SurgSim::Physics::Representation > |
SurgSim::Math::MlcpProblem | A description of an MLCP (mixed linear complementarity problem, or mixed LCP) system to be solved
SurgSim::Physics::MlcpPhysicsProblem | A description of a physical mixed LCP system to be solved
SurgSim::Math::MlcpSolution | The description of a solution to a mixed linear complementarity problem
SurgSim::Physics::MlcpPhysicsSolution | The description of a solution to a physical MLCP problem
SurgSim::Math::MlcpSolver | This class provides a solver interface for mixed linear complementarity problems
SurgSim::Math::MlcpGaussSeidelSolver | A solver for mixed LCP problems using the Gauss-Seidel iterative method
MlcpTestData |
SurgSim::Devices::MouseScaffold | A class that implements the behavior of MouseDevice objects
SurgSim::DataStructures::NamedData< T > | A templated dictionary in which data can be accessed by name or index, with immutable names & indices
SurgSim::DataStructures::NamedData< BooleanType > |
SurgSim::DataStructures::NamedData< boost::any > |
SurgSim::DataStructures::NamedVariantData | A NamedData collection of variant data type
SurgSim::DataStructures::NamedData< DynamicMatrixType > |
SurgSim::DataStructures::NamedData< IntegerType > |
SurgSim::DataStructures::NamedData< PoseType > |
SurgSim::DataStructures::NamedData< ScalarType > |
SurgSim::DataStructures::NamedData< StringType > |
SurgSim::DataStructures::NamedData< SurgSim::DataStructures::Image > |
SurgSim::DataStructures::NamedData< VectorType > |
SurgSim::DataStructures::NamedDataBuilder< T > | A class that allows you to build a NamedData structure
SurgSim::DataStructures::NamedDataBuilder< BooleanType > |
SurgSim::DataStructures::NamedDataBuilder< boost::any > |
SurgSim::DataStructures::NamedDataBuilder< DynamicMatrixType > |
SurgSim::DataStructures::NamedDataBuilder< IntegerType > |
SurgSim::DataStructures::NamedDataBuilder< PoseType > |
SurgSim::DataStructures::NamedDataBuilder< ScalarType > |
SurgSim::DataStructures::NamedDataBuilder< StringType > |
SurgSim::DataStructures::NamedDataBuilder< SurgSim::DataStructures::Image > |
SurgSim::DataStructures::NamedDataBuilder< VectorType > |
SurgSim::DataStructures::Grid< T, N >::NDIdHash | Enable the NDId to be used as a key in an unordered map
NodeVisitor |
SurgSim::Graphics::TangentSpaceGenerator | Node visitor which calculates the tangent space basis vectors from the texture coordinates of any geometry it encounters
SurgSim::DataStructures::NormalData | Store normal for each triangle in a triangle mesh
NotifyHandler |
SurgSim::Graphics::OsgLog | Enable logging of OSG through SurgSim Logging System To use this, an object of OsgLog class must be created
SurgSim::Devices::NovintScaffold | A class that manages Novint Falcon devices
SurgSim::Framework::ObjectFactory< Base > | An object factory, once a class is registered with the factory it can be used to create instances of registered classes
SurgSim::Framework::ObjectFactory1< Base, Parameter1 > | An object factory, once a class is registered with the factory it can be used to create instances of registered classes
SurgSim::Framework::ObjectFactory1< UniformBase, std::string > |
SurgSim::Graphics::OsgUniformFactory | This class can create the appropriate OsgUniform from an OpenGl glsl type, use the appropriate name from glsl in the create() function to recieve the correctly typed uniform
SurgSim::DataStructures::OctreePathHash | Enable the OctreePath to be used as a key in an unordered map, if the int range is exceeded this will just push the least significant numbers (root addresses) out of scope, it loses a little bit of address space as octree ids only go from 0-7
SurgSim::Math::OdeEquation | Ode equation of 2nd order of the form \(M(x,v).a = F(x, v)\) with \((x0, v0)\) for initial conditions and a set of boundary conditions
SurgSim::Physics::DeformableRepresentation | Base class for all deformable representations MassSprings, Finite Element Models,..
SurgSim::Math::OdeSolver | Base class for all solvers of ode equation of order 2 of the form \(M(x(t), v(t)).a(t) = f(t, x(t), v(t))\)
SurgSim::Math::OdeSolverEulerExplicit | Euler Explicit ode solver solves the following \(2^{nd}\) order ode \(M(x(t), v(t)).a(t) = f(t, x(t), v(t))\)
SurgSim::Math::OdeSolverLinearEulerExplicit | Linear Version of the Euler Explicit ode solver This solver assumes that the system is linear, ie that Mass, Damping, and Stiffness matrices do not change
SurgSim::Math::OdeSolverEulerExplicitModified | Modified Euler Explicit ode solver solves the following \(2^{nd}\) order ode \(M(x(t), v(t)).a(t) = f(t, x(t), v(t))\)
SurgSim::Math::OdeSolverLinearEulerExplicitModified | Linear Version of the Modified Euler Explicit ode solver This solver assumes that the system is linear, ie that Mass, Damping, and Stiffness matrices do not change
SurgSim::Math::OdeSolverEulerImplicit | Euler implicit (a.k.a backward Euler) ode solver (see OdeSolverEulerImplicit.dox for more details)
SurgSim::Math::OdeSolverLinearEulerImplicit | Linear Version of the Euler Implicit ode solver This solver assumes that the system is linear, ie that Mass, Damping, and Stiffness matrices do not change
SurgSim::Math::OdeSolverRungeKutta4 | Runge Kutta 4 ode solver (See http://en.wikipedia.org/wiki/Runge%E2%80%93Kutta_methods) solves the following \(2^{nd}\) order ode \(M(x(t), v(t)).a(t) = f(t, x(t), v(t))\)
SurgSim::Math::OdeSolverLinearRungeKutta4 | Linear Version of the Runge Kutta 4 ode solver This solver assumes that the system is linear ie that Mass, Damping, and Stiffness matrices do not change
SurgSim::Math::OdeSolverStatic | Static ode solver solves the following \(2^{nd}\) order ode \(M(x(t), v(t)).a(t) = f(t, x(t), v(t))\)
SurgSim::Math::OdeSolverLinearStatic | Linear version of the static ode solver This solver assumes that the system is linear, ie that Stiffness matrix does not change
SurgSim::Math::OdeState | The state \(y\) of an ode of 2nd order of the form \(M(x,v).a = F(x, v)\) with boundary conditions
SurgSim::Math::Operation< DerivedSub, SparseType, StorageOrder > | Helper class to run operation a column/row of a matrix to a chunk of memory where the size is dynamically defined
SurgSim::Math::Operation< DerivedSub, SparseType, Eigen::ColMajor > | Specialization for column major storage
SurgSim::Math::Operation< DerivedSub, SparseType, Eigen::RowMajor > | Specialization for row major storage
SurgSim::DataStructures::OptionalValue< T > | Container class that can indicate whether the object has been assigned a value
SurgSim::DataStructures::OptionalValue< bool > |
SurgSim::DataStructures::OptionalValue< double > |
SurgSim::DataStructures::OptionalValue< int > |
SurgSim::DataStructures::OptionalValue< Math::Aabbd > |
SurgSim::DataStructures::OptionalValue< Math::Vector3d > |
SurgSim::DataStructures::OptionalValue< Matrix33d > |
SurgSim::DataStructures::OptionalValue< RigidTransform3 > |
SurgSim::DataStructures::OptionalValue< size_t > |
SurgSim::DataStructures::OptionalValue< std::string > |
SurgSim::DataStructures::OptionalValue< SurgSim::DataStructures::DataGroup > |
SurgSim::DataStructures::OptionalValue< SurgSim::DataStructures::IndexedLocalCoordinate > |
SurgSim::DataStructures::OptionalValue< SurgSim::DataStructures::OctreePath > |
SurgSim::DataStructures::OptionalValue< SurgSim::Math::RigidTransform3d > |
SurgSim::DataStructures::OptionalValue< SurgSim::Math::Vector2d > |
SurgSim::DataStructures::OptionalValue< SurgSim::Math::Vector3d > |
SurgSim::DataStructures::OptionalValue< SurgSim::Math::Vector4d > |
SurgSim::DataStructures::OptionalValue< Vector3d > |
SurgSim::Graphics::OsgPlane | OSG plane geode to be used as a primitive shape The plane is the XZ plane, with normal +Y
SurgSim::Graphics::OsgUnitAxes |
SurgSim::Graphics::OsgUnitBox | OSG unit box geode to be used as a primitive shape The box is located at (0, 0, 0) and has a size of 1 on all three axes
SurgSim::Graphics::OsgUnitCylinder | OSG unit cylinder geode to be used as a primitive shape The cylinder is located at (0, 0, 0) and has a radius of 1 and height of 1
SurgSim::Graphics::OsgUnitSphere | OSG unit sphere geode to be used as a primitive shape The sphere is located at (0, 0, 0) and has a radius of 1
OtherData |
OtherElem |
SurgSim::Input::OutputProducerInterface | Interface for a producer that generates device output updates (forces, status LED state, etc)
MovingSquareForce | A simple listener to calculate collision force against a square area for the example application
SurgSim::Devices::DeviceFilter | A device filter can be connected between a device and the InputConsumerInterface (e.g., InputComponent) and/or the OutputProducerInterface (e.g., OutputComponent), and can alter the data being passed from/to the device
SurgSim::Input::OutputComponent | OutputComponents connect SceneElements to devices, facilitating data transfer from a SceneElement to a device
SurgSim::Testing::MockInputOutput |
pair |
SurgSim::Math::PosedShapeMotion< std::shared_ptr< SurgSim::Math::Shape > > |
SurgSim::Math::PosedShapeMotion< T > | PosedShapeMotion is embedding the motion of a PosedShape, providing a posed shape at 2 different instant
SurgSim::Particles::ParticleData |
SurgSim::Devices::PhantomScaffold | A class that manages Sensable PHANTOM devices
SurgSim::Physics::PhysicsManagerState |
PlyElement |
PlyFile |
PlyOtherElems |
PlyOtherProp |
PlyProperty |
SurgSim::DataStructures::PlyReader | Wrapper for the C .ply file parser This class wraps the main functionality for the original C .ply file parser at http://paulbourke.net/dataformats/ply/ it enables customization of the parsing process either through a delegate class or through executing the requestElement and requestProperty functions
SurgSim::DataStructures::PlyReaderDelegate | PlyReaderDelegate abstract class
SurgSim::DataStructures::OctreeNodePlyReaderDelegateBase | Delegate to read Octrees from ply files, this is the abstract base class, to let us modify loading by datatype
SurgSim::DataStructures::OctreeNodePlyReaderDelegate< Data > | Subclass the OctreeNodePLyReaderDelegateBase class to enable processing of the templated data, this should be specialized to enable specific processing of various extended node types
SurgSim::DataStructures::TriangleMeshPlyReaderDelegate< M > | Implementation of PlyReaderDelegate for simple triangle meshes
SurgSim::Physics::FemPlyReaderDelegate | Common part of implementation of PlyReaderDelegate for FemRepresentations
SurgSim::Physics::Fem1DPlyReaderDelegate |
SurgSim::Physics::Fem2DPlyReaderDelegate |
SurgSim::Physics::Fem3DPlyReaderDelegate |
SurgSim::DataStructures::TriangleMeshPlyReaderDelegate< Mesh > |
SurgSim::Graphics::MeshPlyReaderDelegate | Implementation of PlyReaderDelegate for graphicsmeshes
SurgSim::DataStructures::TriangleMeshPlyReaderDelegate< SegmentMeshShape > |
SurgSim::Math::SegmentMeshShapePlyReaderDelegate | Implementation of ply reader for segment meshes, enable to read the radius from the ply file
SurgSim::Particles::PointGenerator | PointGenerator is used to generate points inside or on the surface of a given shape
SurgSim::Particles::DefaultPointGenerator | DefaultPointGenerator, methods of this class will always return (0.0, 0.0, 0.0) and output a severe logging message
SurgSim::Particles::RandomBoxPointGenerator | Class to generate points inside or on the surface of a box
SurgSim::Particles::RandomMeshPointGenerator | Class to generate points on the surface of a mesh
SurgSim::Particles::RandomPointGenerator | RandomPointGenerator will generate points based on the shape passed
SurgSim::Particles::RandomSpherePointGenerator | Class to generate points inside or on the surface of a sphere
SurgSim::Math::Polynomial< T, N > | Polynomial<T, N> defines the concept of an N degree polynomial with type T coefficients and provides operations on them including arithmetic operations, construction, and IO
SurgSim::Math::Polynomial< T, 0 > | Polynomial<T, 0> specializes the Polynomial class for degree 0 (constant polynomials)
SurgSim::Math::Polynomial< T, 1 > | Polynomial<T, 1> specializes the Polynomial class for degree 1 (linear polynomials)
SurgSim::Math::Polynomial< T, 2 > | Polynomial<T, 2> specializes the Polynomial class for degree 2 (quadratic polynomials)
SurgSim::Math::Polynomial< T, 3 > | Polynomial<T, 3> specializes the Polynomial class for degree 3 (cubic polynomials)
SurgSim::Math::PolynomialRoots< T, N > | The (algebraic) roots of a Polynomial<N,T>
SurgSim::Math::PolynomialRootsCommon< T, N > | The common base class for PolynomialRoots specializations for various N
SurgSim::Math::PolynomialRootsCommon< T, 1 > |
SurgSim::Math::PolynomialRoots< T, 1 > | PolynomialRoots<T, 1> specializes the PolynomialRoots class for degree 1 (linear polynomials)
SurgSim::Math::PolynomialRootsCommon< T, 2 > |
SurgSim::Math::PolynomialRoots< T, 2 > | PolynomialRoots<T, 2> specializes the PolynomialRoots class for degree 2 (quadratic polynomials)
SurgSim::Math::PolynomialValues< T, N > | Class to manage polynomial based calculations of interval boundaries
SurgSim::Math::PolynomialValues< double, 2 > |
SurgSim::Math::PolynomialValues< double, 3 > |
SurgSim::Math::PolynomialValues< T, 0 > | PolynomialValues<T, 0> specializes the PolynomialValues class for degree 0 (constant polynomials)
SurgSim::Math::PolynomialValues< T, 1 > | PolynomialValues<T, 1> specializes the PolynomialValues class for degree 1 (linear polynomials)
SurgSim::Math::PolynomialValues< T, 2 > | PolynomialValues<T, 2> specializes the PolynomialValues class for degree 2 (quadratic polynomials)
SurgSim::Math::PolynomialValues< T, 3 > | PolynomialValues<T, 3> specializes the PolynomialValues class for degree 3 (cubic polynomials)
SurgSim::Math::PosedShape< T > | PosedShape is a transformed shape with a record of the pose used to transform it
SurgSim::DataStructures::powerOf3< N > | Templated function to compute a power of 3 at compile time (useful for template parameter)
SurgSim::DataStructures::powerOf3< 0 > |
SurgSim::Graphics::Program | Base class that defines the interface for graphics programs
SurgSim::Graphics::OsgProgram | OSG-based implementation of a graphics shader
SurgSim::Framework::Property | Public struct to pair an accessible with its appropriate property
SurgSim::DataStructures::PlyReader::PropertyInfo | Information about the property on the .ply file
SurgSim::Devices::RawMultiAxisScaffold | A class that implements the behavior of RawMultiAxisDevice objects
SurgSim::Graphics::RenderTarget | RenderTarget is an abstraction of the target buffers that a Camera should use to render it's scene valid targets are a given number of color buffers, and an optional depth buffer
SurgSim::Graphics::OsgAbstractRenderTarget | Osg abstract render target, this hides the type of the actual osg texture and lets us use OsgRenderTarget without the template type
SurgSim::Graphics::OsgRenderTarget< T > | Specific implementation of the render target class
SurgSim::Framework::ReuseFactory< T > | Factory for acquiring new or unused existing instances of class T to reduce repeated deallocation and reallocation of objects with short lifespans
SurgSim::Physics::FemElementStructs::RotationVectorData | RotationVectorData is a structure containing the rotational dof per vertex The nature of the rotation depends on the underlying Representation, but right now all OSS's representations use rotation vector for rotational dof
SurgSim::Math::OdeSolverRungeKutta4::RungeKuttaDerivedState | Internal structure to hold the 4 temporary evaluations
SurgSim::DataStructures::SegmentEmptyData | SegmentEmptyData class This class is to ensure that the static TriangleMesh::m_className in SegmentMesh does not clash with static TriangleMesh<VertexData, EdgeData, EmptyData>
SurgSim::Collision::SegmentSegmentCcdIntervalCheck | SegmentSegmentCcdIntervalCheck uses the Interval classes including the LinearMotion and Polynomial families to quickly determine if there is a possible collision between two moving segments over a specified time interval
SurgSim::Collision::SegmentSegmentCcdMovingContact | SegmentSegmentCcdMovingContact computes the self collisions among a SegmentMesh under motion at two time points parametrized over the time interval [0,1]
SurgSim::Collision::SegmentSegmentCcdStaticContact | SegmentSegmentCcdStaticContact computes if there is contact between two segments at a specific point in time in support of the CCD calculations for moving intervals
SurgSim::Serialize::ShapesFactory | A factory implementation for shapes
SurgSim::Framework::SharedInstance< T > | A utility class to manage a shared instance of an object
SurgSim::Devices::SixenseScaffold | A class that manages Sixense devices, such as the Razer Hydra
SurgSim::DataStructures::OctreeNodePlyReaderDelegateBase::SpacingData | Data structure to receive the spacing information from the file
SurgSim::Physics::Spring | Base class for all springs It handles the node ids to which it is connected and requires all derived classes to compute the force and its derivatives (the stiffness and damping matrices) A extra method also exist to compute all of them at once for performance purposes
SurgSim::Physics::LinearSpring | Linear spring connecting 2 nodes with a viscous term
MovingSquareForce::SquarePoseVectors | State defined by the pose of the square
SurgSim::Devices::InputDeviceHandle::State |
SurgSim::Devices::WdkHidDeviceHandle::State |
SurgSim::Devices::LeapScaffold::StateData |
SurgSim::Devices::NimbleScaffold::StateData |
SurgSim::Devices::NovintScaffold::StateData |
SurgSim::Devices::OculusScaffold::StateData |
SurgSim::Devices::OpenNIScaffold::StateData |
SurgSim::Devices::RawMultiAxisScaffold::StateData |
SurgSim::Devices::LabJackScaffold::StateData | The per-scaffold data (in comparison to DeviceData the per-device data)
SurgSim::Devices::SixenseScaffold::StateData |
SurgSim::Devices::TrackIRScaffold::StateData |
SurgSim::Devices::PhantomScaffold::StateData |
SurgSim::Devices::SystemInputDeviceHandle | A wrapper for system-dependent access to an input/HID device
SurgSim::Devices::InputDeviceHandle | Access to an input/HID device using the Input API in Linux
SurgSim::Devices::WdkHidDeviceHandle | Access to an input/HID device using the HID API from the Windows Driver Kit
SurgSim::Framework::ThreadPool::TaskBase |
SurgSim::Framework::ThreadPool::Task< R > | Actual tasks, with typed return type
SurgSim::Graphics::Texture | Base class defining the interface for a Graphics Texture
SurgSim::Graphics::OsgTexture | Base class for OSG implementations of Graphics Textures
SurgSim::Graphics::OsgTexture1d | OSG implementation of a 1D Texture
SurgSim::Graphics::OsgTexture2d | OSG implementation of a 2D Texture
SurgSim::Graphics::OsgTexture3d | OSG implementation of a 3D Texture
SurgSim::Graphics::OsgTextureCubeMap | OSG implementation of a Cube Map Texture
SurgSim::Graphics::OsgTextureRectangle | OSG implementation of a Rectangle Texture
SurgSim::Graphics::Texture1d | Base class defining the interface for a 1D Graphics Texture
SurgSim::Graphics::OsgTexture1d | OSG implementation of a 1D Texture
SurgSim::Graphics::Texture2d | Base class defining the interface for a 2D Graphics Texture
SurgSim::Graphics::OsgTexture2d | OSG implementation of a 2D Texture
SurgSim::Graphics::Texture3d | Base class defining the interface for a 3D Graphics Texture
SurgSim::Graphics::OsgTexture3d | OSG implementation of a 3D Texture
SurgSim::Graphics::TextureCubeMap | Base class defining the interface for a Cube Map Graphics Texture
SurgSim::Graphics::OsgTextureCubeMap | OSG implementation of a Cube Map Texture
SurgSim::Graphics::TextureRectangle | Base class defining the interface for a Rectangle Graphics Texture
SurgSim::Graphics::OsgTextureRectangle | OSG implementation of a Rectangle Texture
SurgSim::Framework::ThreadPool | A thread pool for completing heterogenous tasks
SurgSim::Framework::Timer | Timer class, measures execution times
SurgSim::Devices::LabJack::TimerSettings | A struct holding the data to be associated with a Timer
TrackballManipulator |
SurgSim::Graphics::OsgTrackballZoomManipulator | Trackball manipulator that uses the mouse wheel to control zoom amount
SurgSim::Devices::TrackIRScaffold | A class that manages Natural Point TRACKIR devices
SurgSim::DataStructures::Tree | Basic tree structure
SurgSim::DataStructures::AabbTree | AabbTree is a tree that is organized by the bounding boxes of the referenced objects, the bounding box used is the Axis Aligned Bounding Box (AABB), with the extents of an AABB describing the min and max of each coordinate for the given object
SurgSim::DataStructures::TreeData | Abstract base class for data stored in a Tree
SurgSim::DataStructures::AabbTreeData | Internal class to hold a list of AABBs and their respective object ids, it can calculate the elements that intersect with a given aabb each node in the AABB tree holds one of these
SurgSim::DataStructures::TreeNode | Basic tree node structure
SurgSim::DataStructures::AabbTreeNode | Node class for the AabbTree, this handles groups of items and subdivision if the number of items gets too big
SurgSim::DataStructures::TreeVisitor | Abstract Class for visitors, this needs to be extended for other tree nodes when necessary return false from handle() to abort traversal
SurgSim::DataStructures::AabbTreeIntersectionVisitor | Visitor class to collect the items that intersect with a given bounding box
SurgSim::Math::TriangleCapsuleContactCalculation::TriangleCapsuleContactCalculation< T, MOpt > | Class used to find the intersection between a triangle and a capsule
SurgSim::Math::TriangleHelper< T, MOpt > | A helper class for a triangle, used for the following two purposes:
SurgSim::Graphics::TriangleNormalGenerator | Triangle index functor which calculates normals for the vertices of a geometry, use createNormalGenerator to instantiate this
SurgSim::Collision::OctreeContact::Vector3dHash | Enable a Vector3d to be used as a key in an unordered map
SurgSim::Graphics::VectorFieldData | A (mathematical) vector is represented as (X,Y,Z) associated with an optional color (R,G,B,alpha) information
SurgSim::DataStructures::Vertex< Data > | Vertex structure for meshes
SurgSim::Physics::FemPlyReaderDelegate::Vertex6DData | Vertex data containing 6 dofs (3 translational and 3 rotational)
SurgSim::DataStructures::Vertex< void > | Specialization of Vertex with no data
SurgSim::DataStructures::TriangleMeshPlyReaderDelegate< M >::VertexData | Internal structure, the receiver for data from the "vertex" element Provide space for standard ply vertex data, x/y/z and s/t
SurgSim::Graphics::VertexData |
SurgSim::DataStructures::Vertices< VertexData > | Base class for mesh structures, handling basic vertex functionality
SurgSim::DataStructures::TetrahedronMesh< VertexData, EdgeData, TriangleData, TetrahedronData > | Basic class for storing Tetrahedron Meshes, handling basic vertex, edge, triangle and tetrahedron functionality
SurgSim::DataStructures::TriangleMesh< VertexData, EdgeData, TriangleData > | Basic class for storing Triangle Meshes, handling basic vertex, edge, and triangle functionality
SurgSim::Physics::Fem< VertexData, Element > | Base class for a data structure for holding FEM mesh data of different dimensions
SurgSim::DataStructures::TriangleMesh< VertexData, EdgeData, SegmentEmptyData > |
SurgSim::DataStructures::TriangleMesh< VertexData, SurgSim::DataStructures::EmptyData, SurgSim::DataStructures::EmptyData > |
SurgSim::DataStructures::Vertices< DataStructures::EmptyData > |
SurgSim::Math::ParticlesShape | Particles Shape: A shape consisting of a group of particles of equal radius
SurgSim::DataStructures::Vertices< FemElementStructs::RotationVectorData > |
SurgSim::Physics::Fem< FemElementStructs::RotationVectorData, FemElementStructs::FemElement1DParameter > |
SurgSim::Physics::Fem< FemElementStructs::RotationVectorData, FemElementStructs::FemElement2DParameter > |
SurgSim::DataStructures::Vertices< SurgSim::DataStructures::EmptyData > |
SurgSim::Physics::Fem< SurgSim::DataStructures::EmptyData, FemElementStructs::FemElement3DParameter > |
SurgSim::DataStructures::TriangleMesh< SurgSim::DataStructures::EmptyData, SurgSim::DataStructures::EmptyData, SurgSim::DataStructures::NormalData > |
SurgSim::DataStructures::OctreeNodePlyReaderDelegateBase::VoxelData | Data structure to receive the specific voxel information from the file