Back to index

supertuxkart  0.5+dfsg1
Class List
Here are the classes, structs, unions and interfaces with brief descriptions:
ActionMapThis thing is named after what is put in as values
Attachment
AttachmentManager
AutoBlockSa
AutoKart
BaseGUI
BMF_BitmapFont***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
BMF_CharData***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
BMF_FontData
bt32BitAxisSweep3Bt32BitAxisSweep3 allows higher precision quantization and more objects compared to the btAxisSweep3 sweep and prune. This comes at the cost of more memory per handle, and a bit slower performance. It uses arrays rather then lists for storage of the 3 axis
btAlignedAllocator< T, Alignment >
btAlignedObjectArray< T >BtAlignedObjectArray uses a subset of the stl::vector interface for its methods It is developed to replace stl::vector to avoid STL alignment issues to add SIMD/SSE data
btAxisSweep3BtAxisSweep3 is an efficient implementation of the 3d axis sweep and prune broadphase. It uses arrays rather then lists for storage of the 3 axis. Also it operates using 16 bit integer coordinates instead of floats. For large worlds and many objects, use bt32BitAxisSweep3 instead. bt32BitAxisSweep3 has higher precision and allows more then 16384 objects at the cost of more memory and bit of performance
btAxisSweep3Internal< BP_FP_INT_TYPE >BtAxisSweep3Internal is an internal template class that implements sweep and prune. Dont use this class directly, use btAxisSweep3 or bt32BitAxisSweep3 instead
btBlock
btBoxBoxCollisionAlgorithmBox-box collision detection
btBoxBoxDetectorBtBoxBoxDetector wraps the ODE box-box collision detector re-distributed under the Zlib license with permission from Russell L. Smith
btBoxShapeBtBoxShape implements both a feature based (vertex/edge/plane) and implicit (getSupportingVertex) Box
btMultiSapBroadphase::btBridgeProxy
btBroadphaseInterfaceBroadphaseInterface for aabb-overlapping object pairs
btBroadphasePairSortPredicate
btBU_Simplex1to4BU_Simplex1to4 implements feature based and implicit simplex of up to 4 vertices (tetrahedron, triangle, line, vertex)
btCapsuleShapeBtCapsuleShape represents a capsule around the Y axis A more general solution that can represent capsules is the btMultiSphereShape the total height is height+2*radius, so the height is just the height between the center of each 'sphere' of the capsule caps
btCapsuleShapeXBtCapsuleShapeX represents a capsule around the Z axis the total height is height+2*radius, so the height is just the height between the center of each 'sphere' of the capsule caps
btCapsuleShapeZBtCapsuleShapeZ represents a capsule around the Z axis the total height is height+2*radius, so the height is just the height between the center of each 'sphere' of the capsule caps
btClockBasic clock
btCollisionAlgorithmBtCollisionAlgorithm is an collision interface that is compatible with the Broadphase and btDispatcher. It is persistent over frames
btCollisionAlgorithmConstructionInfo
btCollisionAlgorithmCreateFuncUsed by the btCollisionDispatcher to register and create instances for btCollisionAlgorithm
btCollisionConfigurationBtCollisionConfiguration allows to configure Bullet collision detection stack allocator size, default collision algorithms and persistent manifold pool size todo: describe the meaning
btCollisionDispatcherBtCollisionDispatcher supports algorithms that handle ConvexConvex and ConvexConcave collision pairs. Time of Impact, Closest Points and Penetration Depth
btCollisionPairCallbackInterface for iterating all overlapping collision pairs, no matter how those pairs are stored (array, set, map etc) this is useful for the collision dispatcher
btCollisionShapeBtCollisionShape provides interface for collision shapes that can be shared among btCollisionObjects
btCollisionWorldCollisionWorld is interface and container for the collision detection
btCompoundCollisionAlgorithmBtCompoundCollisionAlgorithm supports collision between CompoundCollisionShapes and other collision shapes Place holder, not fully implemented yet
btConcaveShapeConcave shape proves an interface concave shapes that can produce triangles that overlapping a given AABB. Static triangle mesh, infinite plane, height field/landscapes are example that implement this interface
btConeShapeBtConeShape implements a Cone shape, around the Y axis
btConeShapeXBtConeShape implements a Cone shape, around the X axis
btConeShapeZBtConeShapeZ implements a Cone shape, around the Z axis
btConeTwistConstraintBtConeTwistConstraint can be used to simulate ragdoll joints (upper arm, leg etc)
btConstraintPersistentDataStores some extra information to each contact point. It is not in the contact point, because that want to keep the collision detection independent from the constraint solver
btConstraintSetting
btConstraintSolverBtConstraintSolver provides solver interface
btContactSolverInfo
btContactSolverInfoData
btContinuousConvexCollisionBtContinuousConvexCollision implements angular and linear time of impact for convex objects. Based on Brian Mirtich's Conservative Advancement idea (PhD thesis). Algorithm operates in worldspace, in order to keep inbetween motion globally consistent. It uses GJK at the moment. Future improvement would use minkowski sum / supporting vertex, merging innerloops
btContinuousDynamicsWorldBtContinuousDynamicsWorld adds optional (per object) continuous collision detection for fast moving objects to the btDiscreteDynamicsWorld. This copes with fast moving objects that otherwise would tunnel/miss collisions. Under construction, don't use yet! Please use btDiscreteDynamicsWorld instead
btConvexCastBtConvexCast is an interface for Casting
btConvexConcaveCollisionAlgorithmBtConvexConcaveCollisionAlgorithm supports collision between convex shapes and (concave) trianges meshes
btConvexConvexAlgorithmConvexConvexAlgorithm collision algorithm implements time of impact, convex closest points and penetration depth calculations
btConvexInternalShapeBtConvexInternalShape carries some additional data, shared by most implementations
btConvexPenetrationDepthSolverConvexPenetrationDepthSolver provides an interface for penetration depth calculation
btConvexPlaneCollisionAlgorithmBtSphereBoxCollisionAlgorithm provides sphere-box collision detection. Other features are frame-coherency (persistent data) and collision response
btConvexTriangleCallbackFor each triangle in the concave mesh that overlaps with the AABB of a convex (m_convexProxy), processTriangle is called
btConvexTriangleMeshShapeBtConvexTriangleMeshShape is a convex hull of a triangle mesh. If you just have a point cloud, you can use btConvexHullShape instead. It uses the btStridingMeshInterface instead of a point cloud. This can avoid the duplication of the triangle mesh data
btCylinderShapeImplements cylinder shape interface
btCylinderShapeX
btCylinderShapeZ
btDebugCastResult
btDefaultCollisionConfigurationBtCollisionConfiguration allows to configure Bullet collision detection stack allocator, pool memory allocators todo: describe the meaning
btDefaultMotionStateBtDefaultMotionState provides a common implementation to synchronize world transforms with offsets
btDefaultVehicleRaycaster
btDiscreteCollisionDetectorInterfaceThis interface is made to be used by an iterative approach to do TimeOfImpact calculations This interface allows to query for closest points and penetration depth between two (convex) objects the closest point is on the second object (B), and the normal points from the surface on B towards A. distance is between closest points on B and closest point on A. So you can calculate closest point on A by taking closestPointInA = closestPointInB + m_distance * m_normalOnSurfaceB
btDiscreteDynamicsWorldBtDiscreteDynamicsWorld provides discrete rigid body simulation those classes replace the obsolete CcdPhysicsEnvironment/CcdPhysicsController
btDispatcherBtDispatcher can be used in combination with broadphase to dispatch overlapping pairs. For example for pairwise collision detection or user callbacks (game logic)
btDispatcherInfo
btDynamicsWorldBtDynamicsWorld is the baseclass for several dynamics implementation, basic, discrete, parallel, and continuous
btElement
btEmptyAlgorithmEmptyAlgorithm is a stub for unsupported collision pairs. The dispatcher can dispatch a persistent btEmptyAlgorithm to avoid a search every frame
btEmptyShapeBtEmptyShape is a collision shape without actual collision detection. It can be replaced by another shape during runtime
btGEN_Link
btGEN_List
btGeneric6DofConstraintBtGeneric6DofConstraint between two rigidbodies each with a pivotpoint that descibes the axis location in local space
btGeometryUtil
btGjkConvexCastGjkConvexCast performs a raycast on a convex object using support mapping
btGjkEpaPenetrationDepthSolverEpaPenetrationDepthSolver uses the Expanding Polytope Algorithm to calculate the penetration depth between two convex shapes
btGjkEpaSolverBtGjkEpaSolver contributed under zlib by Nathanael Presson
btGjkEpaSolver2BtGjkEpaSolver contributed under zlib by Nathanael Presson
btGjkPairDetectorBtGjkPairDetector uses GJK to implement the btDiscreteCollisionDetectorInterface
btHashedOverlappingPairCacheHash-space based Pair Cache, thanks to Erin Catto, Box2D, http://www.box2d.org, and Pierre Terdiman, Codercorner, http://codercorner.com
btHashKey< Value >
btHashKeyPtr< Value >
btHashMap< Key, Value >
btHeightfieldTerrainShapeBtHeightfieldTerrainShape simulates a 2D heightfield terrain
btHingeConstraintHinge constraint between two rigidbodies each with a pivotpoint that descibes the axis location in local space axis defines the orientation of the hinge axis
btIDebugDraw
btInternalTriangleIndexCallback
btJacobianEntryJacobian entry is an abstraction that allows to describe constraints it can be used in combination with a constraint solver Can be used to relate the effect of an impulse to the constraint error
btManifoldPointManifoldContactPoint collects and maintains persistent contactpoints. used to improve stability and performance of rigidbody dynamics response
btManifoldResultBtManifoldResult is a helper class to manage contact results
btMatrix3x3
btMinkowskiPenetrationDepthSolverMinkowskiPenetrationDepthSolver implements bruteforce penetration depth estimation. Implementation is based on sampling the depth using support mapping, and using GJK step to get the witness points
btMinkowskiSumShapeBtMinkowskiSumShape represents implicit (getSupportingVertex) based minkowski sum of two convex implicit shapes
btMotionStateBtMotionState allows the dynamics world to synchronize the updated world transforms with graphics For optimizations, potentially only moving objects get synchronized (using setWorldPosition/setWorldOrientation)
btMultiSapBroadphaseMulti SAP broadphase See http://www.continuousphysics.com/Bullet/phpBB2/viewtopic.php?t=328 and http://www.continuousphysics.com/Bullet/phpBB2/viewtopic.php?t=1329
btMultiSapBroadphasePairSortPredicate
btMultiSapBroadphase::btMultiSapProxy
btMultiSphereShapeBtMultiSphereShape represents implicit convex hull of a collection of spheres (using getSupportingVertex)
btNodeOverlapCallback
btNullPairCacheBtNullPairCache skips add/removal of overlapping pairs. Userful for benchmarking and testing
btOdeContactJoint
btOdeJoint
btOdeQuickstepConstraintSolverBtOdeQuickstepConstraintSolver is one of the available solvers for Bullet dynamics framework It uses an adapted version quickstep solver from the Open Dynamics Engine project
btOdeSolverBodyODE's quickstep needs just a subset of the rigidbody data in its own layout, so make a temp copy
btOdeTypedJoint
btOrderIndex
btOverlapCallback
btOverlapFilterCallback
btOverlappingPairCacheBtOverlappingPairCache is an interface that allows different ways of pair management. btHashedOverlappingPairCache or btSortedOverlappingPairCache are two implementations
btOverlappingPairCallbackBtOverlappingPairCallback provides user callback to keep track of overlap between objects, like a collision sensor
btPersistentManifoldSortPredicateFunction object that routes calls to operator<
btPhysicsSdk
btPlane
btPoint2PointConstraintPoint to point constraint between two rigidbodies each with a pivotpoint that descibes the 'ballsocket' location in local space
btPointCollector
btPolyhedralConvexShapePolyhedralConvexShape is an interface class for feature based (vertex/edge/face) convex shapes
btPoolAllocator
btQuadWordBtQuadWord is base-class for vectors, points
btQuadWordStorage
btQuaternion
btRaycastVehicleRayCast vehicle, very special constraint that turn a rigidbody into a vehicle
btRigidBodyBtRigidBody is the main class for rigid body objects. It is derived from btCollisionObject, so it keeps a pointer to a btCollisionShape. It is recommended for performance and memory use to share btCollisionShape objects whenever possible. There are 3 types of rigid bodies:
btRigidBody::btRigidBodyConstructionInfoBtRigidBodyConstructionInfo provides information to create a rigid body. Setting mass to zero creates a fixed (non-dynamic) rigid body. For dynamic objects, you can use the collision shape to approximate the local inertia tensor, otherwise use the zero vector (default argument) You can use the motion state to synchronize the world transform between physics and graphics objects. And if the motion state is provided, the rigid body will initialize its initial world transform from the motion state, m_startWorldTransform is only used when you don't provide a motion state
btRotationalLimitMotorRotation Limit structure for generic joints
btSequentialImpulseConstraintSolverBtSequentialImpulseConstraintSolver uses a Propagation Method and Sequentially applies impulses The approach is the 3D version of Erin Catto's GDC 2006 tutorial. See http://www.gphysics.com Although Sequential Impulse is more intuitive, it is mathematically equivalent to Projected Successive Overrelaxation (iterative LCP) Applies impulses for combined restitution and penetration recovery and to simulate friction
btShapeHullBtShapeHull takes a btConvexShape, builds the convex hull using btConvexHull and provides triangle indices and vertices
btSimpleBroadphaseSimpleBroadphase is a brute force aabb culling broadphase based on O(n^2) aabb checks btSimpleBroadphase is just a unit-test implementation to verify and test other broadphases. So please don't use this class, but use bt32BitAxisSweep3 or btAxisSweep3 instead!
btSimpleBroadphaseProxy
btSimpleDynamicsWorldBtSimpleDynamicsWorld serves as unit-test and to verify more complicated and optimized dynamics worlds. Please use btDiscreteDynamicsWorld instead (or btContinuousDynamicsWorld once it is finished)
btSimulationIslandManagerSimulationIslandManager creates and handles simulation islands, using btUnionFind
btSliderConstraint
btSolve2LinearConstraintConstraint class used for lateral tyre friction
btSorLcpSolver
btSortConstraintOnIslandPredicate
btSortedOverlappingPairCacheBtSortedOverlappingPairCache maintains the objects with overlapping AABB Typically managed by the Broadphase, Axis3Sweep or btSimpleBroadphase
btSphereBoxCollisionAlgorithmBtSphereBoxCollisionAlgorithm provides sphere-box collision detection. Other features are frame-coherency (persistent data) and collision response
btSphereSphereCollisionAlgorithmBtSphereSphereCollisionAlgorithm provides sphere-sphere collision detection. Other features are frame-coherency (persistent data) and collision response. Also provides the most basic sample for custom/user btCollisionAlgorithm
btSphereTriangleCollisionAlgorithmBtSphereSphereCollisionAlgorithm provides sphere-sphere collision detection. Other features are frame-coherency (persistent data) and collision response. Also provides the most basic sample for custom/user btCollisionAlgorithm
btStackAllocStackAlloc provides some fast stack-based memory allocator (LIFO last-in first-out)
btStaticPlaneShapeStaticPlaneShape simulates an 'infinite' plane by dynamically reporting triangles approximated by intersection of the plane with the AABB. Assumed is that the other objects is not also infinite, so a reasonable sized AABB
btStorageResult
btStridingMeshInterface
  btStridingMeshInterface is the interface class for high performance access to triangle meshes

It allows for sharing graphics and collision meshes. Also it provides locking/unlocking of graphics meshes that are in gpu memory

btSubSimplexClosestResult
btSubsimplexConvexCastBtSubsimplexConvexCast implements Gino van den Bergens' paper "Ray Casting against bteral Convex Objects with Application to Continuous Collision Detection" GJK based Ray Cast, optimized version Objects should not start in overlap, otherwise results are not defined
btTransformBtTransform supports rigid transforms (only translation and rotation, no scaling/shear)
btTransformUtilUtils related to temporal transforms
btTranslationalLimitMotor
btTriangle
btTriangleBufferBtTriangleBuffer can be useful to collect and store overlapping triangles between AABB and concave objects that support 'processAllTriangles'
btTriangleCallback
btTriangleConvexcastCallback
btTriangleMeshBtTriangleMesh provides storage for a concave triangle mesh. It can be used as data for the btTriangleMeshShape. It allows either 32bit or 16bit indices, and 4 (x-y-z-w) or 3 (x-y-z) component vertices. btTriangleMesh will duplicate/keep all mesh data. If you prefer, you can avoid using btTriangleMesh and directly use btTriangleIndexVertexArray or derive your own class from btStridingMeshInterface. This allows to share render and collision meshes
btTriangleMeshShapeConcave triangle mesh interface. Don't use this class directly, use btBvhTriangleMeshShape instead
btTriangleRaycastCallback
btTriangleShape
btTypedConstraintTypedConstraint is the baseclass for Bullet constraints and vehicles
btTypedUserInfo
btUniformScalingShape
btUnionFindUnionFind calculates connected subsets
btUnionFindElementSortPredicate
btUprightConstraint
btUprightConstraintLimit
btUsageBitfield
btVector3BtVector3 can be used to represent 3D points and vectors. It has an un-used w component to suit 16-byte alignment when btVector3 is stored in containers. This extra component can be used by derived classes (Quaternion?) or by user Ideally, this class should be replaced by a platform optimized SIMD version that keeps the data in registers
btVector4
btVehicleRaycasterBtVehicleRaycaster is provides interface for between vehicle simulation and raycasting
btVehicleRaycaster::btVehicleRaycasterResult
btRaycastVehicle::btVehicleTuning
btVoronoiSimplexSolverBtVoronoiSimplexSolver is an implementation of the closest point distance algorithm from a 1-4 points simplex to the origin. Can be used with GJK, as an alternative to Johnson distance algorithm
btWheelContactPoint
btWheelInfoBtWheelInfo contains information per wheel about friction and suspension
btWheelInfoConstructionInfo
BU_ContactJointNode
Callback
CallbackManager
Camera
btConvexCast::CastResultRayResult stores the closest result alternatively, add a callback method to decide about closest/all results
Challenge
ChallengesMenu
CharSel
CheckOverlapCallback
CityTime
btCollisionWorld::ClosestConvexResultCallback
btDiscreteCollisionDetectorInterface::ClosestPointInput
btCollisionWorld::ClosestRayResultCallback
Collectable
CollectableManager
Physics::CollisionList
Physics::CollisionPair
ConfigControls
ConfigDisplay
ConfigSound
ConvexH
btCollisionWorld::ConvexResultCallbackRayResultCallback is used to report new raycast results
Coplanar
CProfileIterator
CProfileManager
CProfileNode
CProfileSample
DefaultRobot::CrashTypes
btBoxBoxCollisionAlgorithm::CreateFunc
btCompoundCollisionAlgorithm::CreateFunc
btConvexConcaveCollisionAlgorithm::CreateFunc
btConvexConvexAlgorithm::CreateFunc
btEmptyAlgorithm::CreateFunc
CreateFunc
btSphereBoxCollisionAlgorithm::CreateFunc
btSphereSphereCollisionAlgorithm::CreateFunc
btConvexPlaneCollisionAlgorithm::CreateFunc
btSphereTriangleCollisionAlgorithm::CreateFunc
CreditsMenu
CupDataSimple class that hold the data relevant to a 'cup', aka
DebugDrawcallback
DefaultRobot
DemoApplication
DisplayResConfirm
btAxisSweep3Internal< BP_FP_INT_TYPE >::Edge
EdgeFlag
EmptyRobot
EnergyMathClass
EnergyShiftingSands
lisp::EOFException
gjkepa_impl::EPA
gjkepa2_impl::EPA
gjkepa2_impl::GJK::eStatus
gjkepa2_impl::EPA::eStatus
Explosion
gjkepa_impl::EPA::Face
FeatureUnlocked
FileManager
Flyable
Font
GameManagerManagement class for the whole gameflow, this is where the main-loop is
GameMode
gjkepa_impl::GJK
gjkepa2_impl::GJK
GL_ShapeDrawerOpenGL shape drawing
GL_Simplex1to4GL_Simplex1to4 is a class to debug a Simplex Solver with 1 to 4 points. Can be used by GJK
GLDebugDrawer
GlDrawcallback
GrandPrixEnd
GrandPrixSelect
ConvexH::HalfEdge
gjkepa_impl::GJK::He
HelpPageOne
HelpPageThree
HelpPageTwo
Herring
HerringManager
HighscoreManager
Highscores
History
Homing
HullDesc
HullLibrary
HullResult
btOdeJoint::Info1
btOdeJoint::Info2
InfoTriangle
initAttachmentType
initCollectableType
Input
UserConfig::InputMapEntry
int3
int4
btSimulationIslandManager::IslandCallback
IslandFollow
JungleFollow
Kart
KartControl
KartProperties
KartPropertiesManager
RaceManager::KartStatus
LeaderResult
btAlignedObjectArray< T >::less
lisp::Lexer
lisp::Lisp
Loader
btCollisionWorld::LocalConvexResult
btCollisionWorld::LocalRayResult
btCollisionWorld::LocalShapeInfoLocalShapeInfo gives extra information for complex shapes Currently, only btTriangleMeshShape is available, so it just contains triangleIndex and subpart
LocalSupportVertexCallbackIt's not nice to have all this virtual function overhead, so perhaps we can also gather the points once but then we are duplicating
MainMenu
Material
MaterialManager
MenuManager
gjkepa2_impl::MinkowskiDiff
Missile
gjkepa_impl::GJK::Mkv
MoonAndBackGP
Moveable
MovingPhysics
MovingTexture
Music
MusicInformation
MusicOggStream
MusicPlib
NoCopyUtility class, you can inherit from this class to disallow the assignment operator and copy construction
NumPlayers
OdeD6Joint
OdeP2PJoint
Options
lisp::Parser
Particle
ParticleSystem
PenguinPlaygroundGP
PHullResult
Physics
PlaneFlag
Player
PlayerControls
PlayerKartPlayerKart manages control events from the player and moves them to the Kart
plRayCastResult
ProjectileManager
RaceGUI
RaceManagerThe race manager has two functions: 1) it stores information about the race the user selected (e.g
RaceMenu
RaceOptions
RaceResultsGUIGUI that shows the RaceResults, times and such
RaceTrackTime
btWheelInfo::RaycastInfo
btCollisionWorld::RayResultCallbackRayResultCallback is used to report new raycast results
btAlignedAllocator< T, Alignment >::rebind< O >
RemovePairContainingProxy
RemovingOverlapCallback
renderTextureRenderTexture provides a software-render context (setpixel/printf)
btDiscreteCollisionDetectorInterface::Result
Scene
SDLDriver
Track::SegmentTriangle
gjkepa2_impl::EPA::sFace
SFX
SFXImpl
Track::sgVec3WrapperSgVec3 is a float[3] array, so unfortunately we can't put it in a std::vector because it lacks a copy-constructor, this hack should help..
ShadowSimple shadow class, only used here for default herrings
gjkepa2_impl::EPA::sHorizon
SkidMark
SkidMark::SkidMarkPos
gjkepa2_impl::EPA::sList
Smoke
SoundManager
Spark
SphereTriangleDetectorSphere-triangle to match the btDiscreteCollisionDetectorInterface
btGjkEpaSolver2::sResults
btGjkEpaSolver::sResults
gjkepa2_impl::GJK::sSimplex
gjkepa2_impl::GJK::sSV
StartRaceFeedback
StaticSSG
UserConfig::StickConfig
SDLDriver::StickInfo
STKConfig
SupportVertexCallback
btConvexConcaveCollisionAlgorithm::SwappedCreateFunc
btCompoundCollisionAlgorithm::SwappedCreateFunc
TerrainInfoThis class stores information about the triangle that's under an object, i.e
RaceGUI::TimedMessage
TollwayHead2Head
TollwayTime
Track
TrackManagerSimple class to load and manage track data, track names and such
TrackSel
TrafficDriver
Translations
Tri
TriangleGlDrawcallback
TriangleMeshA special class to store a triangle mesh with a separate material per triangle
UnlockableFeature
UnlockManager
UserConfig
UserPointer
VertFlag
Widget
WidgetManager::WidgetElement
WidgetManager::WidgetID
WidgetManager
WorldThis class keeps all the state of a race, scenegraph, time, etc
WorldsEndGP
lisp::Writer