Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/branches/environment2/src/external/bullet/BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h @ 8420

Last change on this file since 8420 was 8351, checked in by rgrieder, 14 years ago

Merged kicklib2 branch back to trunk (includes former branches ois_update, mac_osx and kicklib).

Notes for updating

Linux:
You don't need an extra package for CEGUILua and Tolua, it's already shipped with CEGUI.
However you do need to make sure that the OgreRenderer is installed too with CEGUI 0.7 (may be a separate package).
Also, Orxonox now recognises if you install the CgProgramManager (a separate package available on newer Ubuntu on Debian systems).

Windows:
Download the new dependency packages versioned 6.0 and use these. If you have problems with that or if you don't like the in game console problem mentioned below, you can download the new 4.3 version of the packages (only available for Visual Studio 2005/2008).

Key new features:

  • *Support for Mac OS X*
  • Visual Studio 2010 support
  • Bullet library update to 2.77
  • OIS library update to 1.3
  • Support for CEGUI 0.7 —> Support for Arch Linux and even SuSE
  • Improved install target
  • Compiles now with GCC 4.6
  • Ogre Cg Shader plugin activated for Linux if available
  • And of course lots of bug fixes

There are also some regressions:

  • No support for CEGUI 0.5, Ogre 1.4 and boost 1.35 - 1.39 any more
  • In game console is not working in main menu for CEGUI 0.7
  • Tolua (just the C lib, not the application) and CEGUILua libraries are no longer in our repository. —> You will need to get these as well when compiling Orxonox
  • And of course lots of new bugs we don't yet know about
  • Property svn:eol-style set to native
File size: 6.0 KB
Line 
1/*
2Bullet Continuous Collision Detection and Physics Library
3Copyright (c) 2003-2009 Erwin Coumans  http://bulletphysics.org
4
5This software is provided 'as-is', without any express or implied warranty.
6In no event will the authors be held liable for any damages arising from the use of this software.
7Permission is granted to anyone to use this software for any purpose,
8including commercial applications, and to alter it and redistribute it freely,
9subject to the following restrictions:
10
111. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
122. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
133. This notice may not be removed or altered from any source distribution.
14*/
15
16
17#ifndef BT_DISCRETE_DYNAMICS_WORLD_H
18#define BT_DISCRETE_DYNAMICS_WORLD_H
19
20#include "btDynamicsWorld.h"
21
22class btDispatcher;
23class btOverlappingPairCache;
24class btConstraintSolver;
25class btSimulationIslandManager;
26class btTypedConstraint;
27class btActionInterface;
28
29class btIDebugDraw;
30#include "LinearMath/btAlignedObjectArray.h"
31
32
33///btDiscreteDynamicsWorld provides discrete rigid body simulation
34///those classes replace the obsolete CcdPhysicsEnvironment/CcdPhysicsController
35class btDiscreteDynamicsWorld : public btDynamicsWorld
36{
37protected:
38
39        btConstraintSolver*     m_constraintSolver;
40
41        btSimulationIslandManager*      m_islandManager;
42
43        btAlignedObjectArray<btTypedConstraint*> m_constraints;
44
45        btAlignedObjectArray<btRigidBody*> m_nonStaticRigidBodies;
46
47        btVector3       m_gravity;
48
49        //for variable timesteps
50        btScalar        m_localTime;
51        //for variable timesteps
52
53        bool    m_ownsIslandManager;
54        bool    m_ownsConstraintSolver;
55        bool    m_synchronizeAllMotionStates;
56
57        btAlignedObjectArray<btActionInterface*>        m_actions;
58       
59        int     m_profileTimings;
60
61        virtual void    predictUnconstraintMotion(btScalar timeStep);
62       
63        virtual void    integrateTransforms(btScalar timeStep);
64               
65        virtual void    calculateSimulationIslands();
66
67        virtual void    solveConstraints(btContactSolverInfo& solverInfo);
68       
69        void    updateActivationState(btScalar timeStep);
70
71        void    updateActions(btScalar timeStep);
72
73        void    startProfiling(btScalar timeStep);
74
75        virtual void    internalSingleStepSimulation( btScalar timeStep);
76
77
78        virtual void    saveKinematicState(btScalar timeStep);
79
80        void    serializeRigidBodies(btSerializer* serializer);
81
82public:
83
84
85        ///this btDiscreteDynamicsWorld constructor gets created objects from the user, and will not delete those
86        btDiscreteDynamicsWorld(btDispatcher* dispatcher,btBroadphaseInterface* pairCache,btConstraintSolver* constraintSolver,btCollisionConfiguration* collisionConfiguration);
87
88        virtual ~btDiscreteDynamicsWorld();
89
90        ///if maxSubSteps > 0, it will interpolate motion between fixedTimeStep's
91        virtual int     stepSimulation( btScalar timeStep,int maxSubSteps=1, btScalar fixedTimeStep=btScalar(1.)/btScalar(60.));
92
93
94        virtual void    synchronizeMotionStates();
95
96        ///this can be useful to synchronize a single rigid body -> graphics object
97        void    synchronizeSingleMotionState(btRigidBody* body);
98
99        virtual void    addConstraint(btTypedConstraint* constraint, bool disableCollisionsBetweenLinkedBodies=false);
100
101        virtual void    removeConstraint(btTypedConstraint* constraint);
102
103        virtual void    addAction(btActionInterface*);
104
105        virtual void    removeAction(btActionInterface*);
106       
107        btSimulationIslandManager*      getSimulationIslandManager()
108        {
109                return m_islandManager;
110        }
111
112        const btSimulationIslandManager*        getSimulationIslandManager() const 
113        {
114                return m_islandManager;
115        }
116
117        btCollisionWorld*       getCollisionWorld()
118        {
119                return this;
120        }
121
122        virtual void    setGravity(const btVector3& gravity);
123
124        virtual btVector3 getGravity () const;
125
126        virtual void    addCollisionObject(btCollisionObject* collisionObject,short int collisionFilterGroup=btBroadphaseProxy::StaticFilter,short int collisionFilterMask=btBroadphaseProxy::AllFilter ^ btBroadphaseProxy::StaticFilter);
127
128        virtual void    addRigidBody(btRigidBody* body);
129
130        virtual void    addRigidBody(btRigidBody* body, short group, short mask);
131
132        virtual void    removeRigidBody(btRigidBody* body);
133
134        ///removeCollisionObject will first check if it is a rigid body, if so call removeRigidBody otherwise call btCollisionWorld::removeCollisionObject
135        virtual void    removeCollisionObject(btCollisionObject* collisionObject);
136
137
138        void    debugDrawConstraint(btTypedConstraint* constraint);
139
140        virtual void    debugDrawWorld();
141
142        virtual void    setConstraintSolver(btConstraintSolver* solver);
143
144        virtual btConstraintSolver* getConstraintSolver();
145       
146        virtual int             getNumConstraints() const;
147
148        virtual btTypedConstraint* getConstraint(int index)     ;
149
150        virtual const btTypedConstraint* getConstraint(int index) const;
151
152       
153        virtual btDynamicsWorldType     getWorldType() const
154        {
155                return BT_DISCRETE_DYNAMICS_WORLD;
156        }
157       
158        ///the forces on each rigidbody is accumulating together with gravity. clear this after each timestep.
159        virtual void    clearForces();
160
161        ///apply gravity, call this once per timestep
162        virtual void    applyGravity();
163
164        virtual void    setNumTasks(int numTasks)
165        {
166        (void) numTasks;
167        }
168
169        ///obsolete, use updateActions instead
170        virtual void updateVehicles(btScalar timeStep)
171        {
172                updateActions(timeStep);
173        }
174
175        ///obsolete, use addAction instead
176        virtual void    addVehicle(btActionInterface* vehicle);
177        ///obsolete, use removeAction instead
178        virtual void    removeVehicle(btActionInterface* vehicle);
179        ///obsolete, use addAction instead
180        virtual void    addCharacter(btActionInterface* character);
181        ///obsolete, use removeAction instead
182        virtual void    removeCharacter(btActionInterface* character);
183
184        void    setSynchronizeAllMotionStates(bool synchronizeAll)
185        {
186                m_synchronizeAllMotionStates = synchronizeAll;
187        }
188        bool getSynchronizeAllMotionStates() const
189        {
190                return m_synchronizeAllMotionStates;
191        }
192
193        ///Preliminary serialization test for Bullet 2.76. Loading those files requires a separate parser (see Bullet/Demos/SerializeDemo)
194        virtual void    serialize(btSerializer* serializer);
195
196};
197
198#endif //BT_DISCRETE_DYNAMICS_WORLD_H
Note: See TracBrowser for help on using the repository browser.