Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Changeset 1923 for code/branches


Ignore:
Timestamp:
Oct 14, 2008, 10:07:50 PM (16 years ago)
Author:
rgrieder
Message:

Cleaned up the heavy mess with header file includes in OgreOde. It should now compile a lot faster.

Location:
code/branches/physics/src/ogreode
Files:
31 edited

Legend:

Unmodified
Added
Removed

  • code/branches/physics/src/ogreode/OgreOdeBody.cpp

    r1922 r1923  
    1 
    21#include "OgreOdePrecompiledHeaders.h"
     2#include "OgreOdeBody.h"
     3
     4#include <OgreStringConverter.h>
     5#include <OgreSceneManager.h>
    36
    47#include "OgreOdeWorld.h"
    5 #include "OgreOdeBody.h"
    68#include "OgreOdeMass.h"
    79#include "OgreOdeDebugObject.h"

  • code/branches/physics/src/ogreode/OgreOdeBody.h

    r1922 r1923  
    33
    44#include "OgreOdePreReqs.h"
     5#include <OgreUserDefinedObject.h>
     6#include <OgreMovableObject.h>
     7#include <OgreAxisAlignedBox.h>
     8#include <OgreSceneQuery.h>
     9#include <OgreSceneNode.h>
    510
    611namespace OgreOde

  • code/branches/physics/src/ogreode/OgreOdeCollision.cpp

    r1922 r1923  
    1 
    21#include "OgreOdePrecompiledHeaders.h"
    3 
    42#include "OgreOdeCollision.h"
     3
    54#include "OgreOdeSpace.h"
    65#include "OgreOdeGeometry.h"

  • code/branches/physics/src/ogreode/OgreOdeCollision.h

    r1919 r1923  
    33
    44#include "OgreOdePreReqs.h"
     5#include <OgreVector3.h>
    56
    67namespace OgreOde

  • code/branches/physics/src/ogreode/OgreOdeDebugContact.cpp

    r1922 r1923  
    99
    1010#include "OgreOdePrecompiledHeaders.h"
    11 
    12 #include "Ogre.h"
    13 #include "OgreFontManager.h"
    14 
    1511#include "OgreOdeDebugContact.h"
     12
     13#include <OgreFontManager.h>
     14#include <OgreEntity.h>
     15#include <OgreSceneNode.h>
     16#include <OgreMaterialManager.h>
     17#include <OgreCamera.h>
     18#include <OgreRoot.h>
     19
    1620#include "OgreOdeCollision.h"
    17 #include "OgreOdeGeometry.h"
    18 #include "OgreOdeBody.h"
    1921#include "OgreOdeWorld.h"
    2022

  • code/branches/physics/src/ogreode/OgreOdeDebugContact.h

    r1922 r1923  
    1212
    1313#include "OgreOdePreReqs.h"
     14
     15#include <OgreMovableObject.h>
     16#include <OgreRenderable.h>
     17#include <OgreAxisAlignedBox.h>
    1418#include "OgreOdeDebugObject.h"
    1519

  • code/branches/physics/src/ogreode/OgreOdeDebugObject.cpp

    r1922 r1923  
    1 
    21#include "OgreOdePrecompiledHeaders.h"
    3 
    42#include "OgreOdeDebugObject.h"
     3
     4#include <OgreMaterialManager.h>
     5#include <OgreTechnique.h>
     6#include <OgreCamera.h>
     7#include <OgreHardwareBufferManager.h>
    58
    69using namespace OgreOde;

  • code/branches/physics/src/ogreode/OgreOdeDebugObject.h

    r1919 r1923  
    33
    44#include "OgreOdePreReqs.h"
     5
     6#include <OgreSimpleRenderable.h>
    57
    68namespace OgreOde

  • code/branches/physics/src/ogreode/OgreOdeEigenSolver.cpp

    r1919 r1923  
    1 
    21#include "OgreOdePrecompiledHeaders.h"
    3 
    42#include "OgreOdeEigenSolver.h"
    53

  • code/branches/physics/src/ogreode/OgreOdeEigenSolver.h

    r1919 r1923  
    33
    44#include "OgreOdePreReqs.h"
     5
     6#include <OgreMatrix3.h>
    57
    68namespace OgreOde

  • code/branches/physics/src/ogreode/OgreOdeEntityInformer.cpp

    r1922 r1923  
    11#include "OgreOdePrecompiledHeaders.h"
    2 
    32#include "OgreOdeEntityInformer.h"
    4 #include "OgreOdeMaintainedList.h"
     3
     4#include <OgreEntity.h>
     5#include <OgreSubEntity.h>
     6#include <OgreSceneNode.h>
     7#include <OgreSubMesh.h>
     8#include <OgreLogManager.h>
     9#include <OgreSkeletonInstance.h>
     10#include <OgreBone.h>
     11
    512#include "OgreOdeBody.h"
    613#include "OgreOdeGeometry.h"
    714#include "OgreOdeMass.h"
    815#include "OgreOdeEigenSolver.h"
    9 
    1016#include "OgreOdeTriangleMeshDataManager.h"
    11 
    12 using namespace OgreOde;
    13 using namespace Ogre;
    14 
    15 
    16 #include "OgreOdePrecompiledHeaders.h"
    17 
    18 #include "OgreOdeEntityInformer.h"
    19 #include "OgreOdeMaintainedList.h"
    20 #include "OgreOdeBody.h"
    21 #include "OgreOdeGeometry.h"
    22 #include "OgreOdeMass.h"
    23 #include "OgreOdeEigenSolver.h"
    2417
    2518using namespace OgreOde;

  • code/branches/physics/src/ogreode/OgreOdeEntityInformer.h

    r1922 r1923  
    33
    44#include "OgreOdePreReqs.h"
     5
     6#include <OgreMesh.h>
    57#include "OgreOdeTriangleMeshData.h"
    68

  • code/branches/physics/src/ogreode/OgreOdeFrameListener.h

    r1919 r1923  
    88#define _PHYSICSFRAMELISTENER_H_
    99
     10#include "OgreOdePreReqs.h"
     11#include <OgreSceneQuery.h>
     12#include <OgreFrameListener.h>
     13
    1014// Uncomment this if you're planning to use the Plane2D joint
    1115// But you'll have to have modified ODE first!
    … …  
    1519A physical thing
    1620*/
    17 class PhysicalThing : public RaySceneQueryListener
     21class PhysicalThing : public Ogre::RaySceneQueryListener
    1822{
    1923public:
    … …  
    2327
    2428        // Just create geoms
    25     void makePlane(Real a,Real b,Real c,Real d);                                // Plane
    26     void makeBox(Real x,Real y,Real z,Real lx,Real ly,Real lz); // Box
    27     void makeSphere(Real x,Real y,Real z,Real r);                               // Sphere
     29    void makePlane(Ogre::Real a, Ogre::Real b, Ogre::Real c, Ogre::Real d);                             // Plane
     30    void makeBox(Ogre::Real x, Ogre::Real y, Ogre::Real z, Ogre::Real lx, Ogre::Real ly, Ogre::Real lz);        // Box
     31    void makeSphere(Ogre::Real x, Ogre::Real y, Ogre::Real z, Ogre::Real r);                            // Sphere
    2832
    2933        // Create bodies and geoms
    30     void makePlane(dWorld *world,SceneNode *node);
    31         void makeBox(dWorld *world,SceneNode *node,Real mass = 1,Vector3 const &offs = Vector3(0,0,0));
    32     void makeSphere(dWorld *world,SceneNode *node,Real mass = 1);
    33         void makeTerrainTriMesh(dWorld *world,SceneManager *mgr,Real grid_size,Real grid_spacing);
     34    void makePlane(dWorld *world, Ogre::SceneNode *node);
     35        void makeBox(dWorld *world, Ogre::SceneNode *node, Ogre::Real mass = 1, Ogre::Vector3 const &offs = Ogre::Vector3(0,0,0));
     36    void makeSphere(dWorld *world, Ogre::SceneNode *node, Ogre::Real mass = 1);
     37        void makeTerrainTriMesh(dWorld *world, Ogre::SceneManager *mgr, Ogre::Real grid_size, Ogre::Real grid_spacing);
    3438
    3539        // Callback functions for the ray scene query functionality
    36         virtual bool queryResult(SceneQuery::WorldFragment *fragment,Real distance);
    37         virtual bool queryResult(MovableObject *obj,Real distance);
     40        virtual bool queryResult(Ogre::SceneQuery::WorldFragment *fragment, Ogre::Real distance);
     41        virtual bool queryResult(Ogre::MovableObject *obj, Ogre::Real distance);
    3842
    3943        // Update the position and orientation of the scene node we're controlling
    … …  
    4145
    4246        // Utility functions to get at internal stuff
    43         SceneNode *getNode(void);
     47        Ogre::SceneNode *getNode(void);
    4448        dBodyID getBodyID(void);
    4549        dSpaceID getSpaceID(void);
    … …  
    4953        dBody           *_body;
    5054        dSpace          *_space;
    51         SceneNode       *_node;
     55        Ogre::SceneNode *_node;
    5256
    53         std::list<Vector3> _frag;
     57        std::list<Ogre::Vector3> _frag;
    5458
    5559        dVector3 *_vertices;
    … …  
    6064A Frame listener that implements the physics
    6165*/
    62 class PhysicsFrameListener : public FrameListener
     66class PhysicsFrameListener : public Ogre::FrameListener
    6367{
    6468protected:
    … …  
    7680   
    7781        // Adjustable variables
    78     Real total_time,step_size;
    79         Real k_spring,k_damper,k_tyre,k_mu,k_erp,k_cfm;
     82    Ogre::Real total_time,step_size;
     83        Ogre::Real k_spring,k_damper,k_tyre,k_mu,k_erp,k_cfm;
    8084
    8185        // Utility function to find the physical thing associated with an Ogre scene node
    82         dBodyID getBodyID(SceneNode *node);
     86        dBodyID getBodyID(Ogre::SceneNode *node);
    8387
    8488public:
    … …  
    8892
    8993        // Tell us when every frame's about to be started
    90     bool frameStarted(const FrameEvent& evt);
     94    bool frameStarted(const Ogre::FrameEvent& evt);
    9195        void pause(bool p = true);
    9296
    … …  
    98102        // Create things manually, no physical bodies
    99103        // so they won't move, but things will collide with them
    100     PhysicalThing *createPlane(Real a,Real b,Real c,Real d);
    101     PhysicalThing *createBox(Real x,Real y,Real z,Real lx,Real ly,Real lz);
    102     PhysicalThing *createSphere(Real x,Real y,Real z,Real r);
     104    PhysicalThing *createPlane(Ogre::Real a,Ogre::Real b,Ogre::Real c,Ogre::Real d);
     105    PhysicalThing *createBox(Ogre::Real x,Ogre::Real y,Ogre::Real z,Ogre::Real lx,Ogre::Real ly,Ogre::Real lz);
     106    PhysicalThing *createSphere(Ogre::Real x,Ogre::Real y,Ogre::Real z,Ogre::Real r);
    103107
    104108        // Create objects based on Ogre nodes, these nodes will then
    … …  
    107111        // Except for the plane, which can't actually be a physical body
    108112        // and the trimesh which we're not going to allow to be a physical body
    109     PhysicalThing *createPlane(SceneNode *node);
    110         PhysicalThing *createBox(SceneNode *node,Real mass = 1,Vector3 const &offs = Vector3(0,0,0));
    111     PhysicalThing *createSphere(SceneNode *node,Real mass = 1);
    112         PhysicalThing *createTerrainTriMesh(SceneManager *mgr,Real grid_size,Real grid_spacing);
     113    PhysicalThing *createPlane(Ogre::SceneNode *node);
     114        PhysicalThing *createBox(Ogre::SceneNode *node,Ogre::Real mass = 1,Ogre::Vector3 const &offs = Ogre::Vector3(0,0,0));
     115    PhysicalThing *createSphere(Ogre::SceneNode *node,Ogre::Real mass = 1);
     116        PhysicalThing *createTerrainTriMesh(Ogre::SceneManager *mgr,Ogre::Real grid_size,Ogre::Real grid_spacing);
    113117
    114118        // Create and activate a new space inside the standard hash space
    … …  
    120124        // The order of n1/n2 does matter; n1 is what you want attaching
    121125        // and n2 is what you want it attaching to
    122         dJoint *createHinge2(SceneNode *n1,SceneNode *n2,const Vector3 &suspension = Vector3(0,1,0),const Vector3 &axle = Vector3(1,0,0));
    123         dJoint *createHinge(SceneNode *n1,SceneNode *n2,const Vector3 &axis = Vector3(1,0,0));
    124         dJoint *createSlider(SceneNode *n1,SceneNode *n2,const Vector3 &axis = Vector3(0,1,0));
    125         dJoint *createBall(SceneNode *n1,SceneNode *n2);
     126        dJoint *createHinge2(Ogre::SceneNode *n1,Ogre::SceneNode *n2,const Ogre::Vector3 &suspension = Ogre::Vector3(0,1,0),const Ogre::Vector3 &axle = Ogre::Vector3(1,0,0));
     127        dJoint *createHinge(Ogre::SceneNode *n1,Ogre::SceneNode *n2,const Ogre::Vector3 &axis = Ogre::Vector3(1,0,0));
     128        dJoint *createSlider(Ogre::SceneNode *n1,Ogre::SceneNode *n2,const Ogre::Vector3 &axis = Ogre::Vector3(0,1,0));
     129        dJoint *createBall(Ogre::SceneNode *n1,Ogre::SceneNode *n2);
    126130#ifdef INCLUDE_PLANE2D_JOINT
    127         dJoint *createPlane2D(SceneNode *n);
     131        dJoint *createPlane2D(Ogre::SceneNode *n);
    128132#endif
    129133
    130134        // Apply forces to a body under our control
    131         void addTorque(SceneNode *n,const Vector3 &force);
     135        void addTorque(Ogre::SceneNode *n,const Ogre::Vector3 &force);
    132136
    133137        // Set the parameters used for the CFM/ERP joint parameters
    134         void setSuspension(Real spring,Real damper);
     138        void setSuspension(Ogre::Real spring,Ogre::Real damper);
    135139
    136140        // Set the acceleration due to gravity
    137         void setGravity(Real g);
     141        void setGravity(Ogre::Real g);
    138142
    139143        // Get our constants
    140         Real getTyre(void){return k_tyre;};
    141         Real getMu(void){return k_mu;};
    142         Real getCFM(void){return k_cfm;};
    143         Real getERP(void){return k_erp;};
     144        Ogre::Real getTyre(void){return k_tyre;};
     145        Ogre::Real getMu(void){return k_mu;};
     146        Ogre::Real getCFM(void){return k_cfm;};
     147        Ogre::Real getERP(void){return k_erp;};
    144148
    145149        // Static function for ODE to call when collisions (potentially) occur

  • code/branches/physics/src/ogreode/OgreOdeGeometry.cpp

    r1922 r1923  
    1 
    21#include "OgreOdePrecompiledHeaders.h"
    3 
    42#include "OgreOdeGeometry.h"
     3
     4#include <OgreSceneNode.h>
     5#include <OgreSceneManager.h>
     6#include <OgreStringConverter.h>
     7
    58#include "OgreOdeWorld.h"
    69#include "OgreOdeSpace.h"

  • code/branches/physics/src/ogreode/OgreOdeGeometry.h

    r1922 r1923  
    33
    44#include "OgreOdePreReqs.h"
    5 #include "OgreOdeMaintainedList.h"
    6 
     5
     6#include <OgreUserDefinedObject.h>
     7#include <OgreMovableObject.h>
     8#include <OgreSceneQuery.h>
    79#include "OgreOdeTriangleMeshData.h"
    810

  • code/branches/physics/src/ogreode/OgreOdeJoint.cpp

    r1919 r1923  
    1 
    21#include "OgreOdePrecompiledHeaders.h"
    3 
    4 #include "OgreOdeGeometry.h"
     2#include "OgreOdeJoint.h"
     3
    54#include "OgreOdeWorld.h"
    65#include "OgreOdeBody.h"
    76#include "OgreOdeGeometry.h"
    8 #include "OgreOdeJoint.h"
    97
    108using namespace OgreOde;

  • code/branches/physics/src/ogreode/OgreOdeJoint.h

    r1919 r1923  
    33
    44#include "OgreOdePreReqs.h"
    5 #include "OgreOdeMaintainedList.h"
     5#include <OgreVector3.h>
    66
    77namespace OgreOde

  • code/branches/physics/src/ogreode/OgreOdeMass.cpp

    r1919 r1923  
     1#include "OgreOdePrecompiledHeaders.h"
     2#include "OgreOdeMass.h"
    13
    2 #include "OgreOdePrecompiledHeaders.h"
    3 
    4 #include "OgreOdePreReqs.h"
    5 #include "OgreOdeMass.h"
     4#include <OgreMatrix3.h>
     5#include <OgreVector3.h>
     6#include <OgreQuaternion.h>
    67
    78using namespace OgreOde;

  • code/branches/physics/src/ogreode/OgreOdePreReqs.h

    r1919 r1923  
    22#define _OGREODEPREREQS_H_
    33
    4 #include "Ogre.h"
    5 #include "OgreNoMemoryMacros.h"
     4// we have to include the entire ode.h because the config file can either be
     5// config.h or odeconfig.h and it takes these files to determine the version
     6// in the first place.
    67#include "ode/ode.h"
    7 #include "OgreMemoryMacros.h"
     8#include <OgrePrerequisites.h>
    89
    9 
    10 namespace OgreOde
    11 {
    12     #if OGRE_PLATFORM == OGRE_PLATFORM_WIN32
    13     #   if defined( OGREODE_EXPORTS )
    14     #       define _OgreOdeExport __declspec( dllexport )
    15     #   else
    16     #       if defined( __MINGW32__ )
    17     #           define _OgreOdeExport
    18     #       else
    19     #           define _OgreOdeExport __declspec(dllimport)
    20     #       endif
    21     #   endif
    22     #elif defined ( OGRE_GCC_VISIBILITY )
    23     #   define _OgreOdeExport  __attribute__ ((visibility("default")))
    24     #else
    25     #   define _OgreOdeExport
    26     #endif
     10#if OGRE_PLATFORM == OGRE_PLATFORM_WIN32
     11#   if defined( OGREODE_EXPORTS )
     12#       define _OgreOdeExport __declspec( dllexport )
     13#   else
     14#       if defined( __MINGW32__ )
     15#           define _OgreOdeExport
     16#       else
     17#           define _OgreOdeExport __declspec(dllimport)
     18#       endif
     19#   endif
     20#elif defined ( OGRE_GCC_VISIBILITY )
     21#   define _OgreOdeExport  __attribute__ ((visibility("default")))
     22#else
     23#   define _OgreOdeExport
     24#endif
    2725
    2826// determine ODE version. In 0.10 and following, ODE uses odeconfig.h in the headers and
    … …  
    3634
    3735
     36namespace OgreOde
     37{
    3838#if ODE_VERSION_MINOR < 10
    3939#  ifndef dTriIndex
    4040#    if dTRIMESH_16BIT_INDICES
    4141#      if dTRIMESH_GIMPACT
    42              typedef uint32 dTriIndex;
     42
     43    typedef uint32 dTriIndex;
     44
    4345#      else // dTRIMESH_GIMPACT
    44              typedef uint16 dTriIndex;
     46
     47    typedef uint16 dTriIndex;
     48
    4549#      endif // dTRIMESH_GIMPACT
    4650#    else // dTRIMESH_16BIT_INDICES
    47            typedef int dTriIndex;
     51
     52    typedef int dTriIndex;
     53
    4854#    endif // dTRIMESH_16BIT_INDICES
    4955#  endif

  • code/branches/physics/src/ogreode/OgreOdePrecompiledHeaders.h

    r1919 r1923  
    44#ifdef _PRECOMP
    55
     6// external headers
     7#include <ode/ode.h>
     8
     9#include <OgreSceneNode.h>
     10#include <OgreEntity.h>
     11#include <OgreSceneNode.h>
     12#include <OgreRoot.h>
     13#include <OgreSceneManager.h>
     14#include <OgreEntity.h>
     15#include <OgreSceneManager.h>
     16#include <OgreSceneNode.h>
     17#include <OgreSceneManager.h>
     18#include <OgreSceneNode.h>
     19#include <OgreRoot.h>
     20#include <OgreSceneNode.h>
     21#include <OgreAxisAlignedBox.h>
     22#include <OgreCamera.h>
     23#include <OgreMovableObject.h>
     24#include <OgreSceneQuery.h>
     25#include <OgreStringConverter.h>
     26#include <OgreUserDefinedObject.h>
     27#include <OgreRenderable.h>
     28#include <OgreSimpleRenderable.h>
     29#include <OgreMesh.h>
     30#include <OgreFrameListener.h>
     31
     32// our own headers
    633#include "OgreOdePreReqs.h"
    7 #include "OgreOdeWorld.h"
     34
    835#include "OgreOdeBody.h"
     36#include "OgreOdeCollision.h"
     37#include "OgreOdeDebugContact.h"
     38#include "OgreOdeDebugObject.h"
     39#include "OgreOdeEigenSolver.h"
     40#include "OgreOdeEntityInformer.h"
     41#include "OgreOdeGeometry.h"
     42#include "OgreOdeJoint.h"
     43#include "OgreOdeMaintainedList.h"
    944#include "OgreOdeMass.h"
    10 #include "OgreOdeJoint.h"
    1145#include "OgreOdeSpace.h"
    12 #include "OgreOdeGeometry.h"
    13 #include "OgreOdeCollision.h"
    1446#include "OgreOdeStepper.h"
    15 
    16 #include "OgreOdeEntityInformer.h"
    17 
    18 
    19 #include "OgreOdeEigenSolver.h"
    2047#include "OgreOdeUtility.h"
    21 
    22 #include "OgreOdeDebugObject.h"
    23 #include "OgreOdeDebugContact.h"
    24 
    2548#include "OgreOdeTriangleMeshData.h"
    2649#include "OgreOdeTriangleMeshDataManager.h"
     50#include "OgreOdeUtility.h"
     51#include "OgreOdeWorld.h"
    2752
    2853#endif //_PRECOMP

  • code/branches/physics/src/ogreode/OgreOdeSpace.cpp

    r1922 r1923  
    1 
    21#include "OgreOdePrecompiledHeaders.h"
     2#include "OgreOdeSpace.h"
     3
     4#include <OgreSceneManager.h>
    35
    46#include "OgreOdeBody.h"
    5 #include "OgreOdeSpace.h"
    67#include "OgreOdeGeometry.h"
    78#include "OgreOdeWorld.h"
    8 
    99#include "OgreOdeCollision.h"
    1010

  • code/branches/physics/src/ogreode/OgreOdeSpace.h

    r1919 r1923  
    33
    44#include "OgreOdePreReqs.h"
    5 #include "OgreOdeMaintainedList.h"
     5#include <OgreAxisAlignedBox.h>
    66
    77namespace OgreOde

  • code/branches/physics/src/ogreode/OgreOdeStepper.cpp

    r1922 r1923  
    1 
    21#include "OgreOdePrecompiledHeaders.h"
     2#include "OgreOdeStepper.h"
     3
     4#include <OgreRoot.h>
    35
    46#include "OgreOdeGeometry.h"
    57#include "OgreOdeBody.h"
    6 #include "OgreOdeWorld.h"
    78#include "OgreOdeSpace.h"
    8 #include "OgreOdeStepper.h"
    99
    1010using namespace OgreOde;

  • code/branches/physics/src/ogreode/OgreOdeStepper.h

    r1919 r1923  
    33
    44#include "OgreOdePreReqs.h"
     5
     6#include <OgreFrameListener.h>
     7#include "OgreOdeWorld.h"
    58
    69namespace OgreOde

  • code/branches/physics/src/ogreode/OgreOdeTriangleMeshData.cpp

    r1919 r1923  
    1 
    21#include "OgreOdePrecompiledHeaders.h"
    3 
    4 #include "OgreOdeGeometry.h"
    5 #include "OgreOdeWorld.h"
    6 #include "OgreOdeSpace.h"
    7 #include "OgreOdeBody.h"
    8 #include "OgreOdeCollision.h"
    9 #include "OgreOdeDebugObject.h"
    10 #include "OgreOdeDebugContact.h"
    11 
    122#include "OgreOdeTriangleMeshData.h"
    133

  • code/branches/physics/src/ogreode/OgreOdeTriangleMeshData.h

    r1919 r1923  
    22#define __OgreOdeTriangleMeshData_H__
    33
    4 #include <Ogre.h>
     4#include "OgreOdePreReqs.h"
    55
    6 #include "OgreOdePreReqs.h"
    7 #include "OgreOdeMaintainedList.h"
    8 
    9 using namespace std;
     6#include <OgreSharedPtr.h>
     7#include <OgreVector3.h>
    108
    119namespace OgreOde

  • code/branches/physics/src/ogreode/OgreOdeTriangleMeshDataManager.cpp

    r1919 r1923  
    11#include "OgreOdePrecompiledHeaders.h"
     2#include "OgreOdeTriangleMeshDataManager.h"
    23
    3 #include "OgreOdeTriangleMeshDataManager.h"
     4#include "OgreOdeTriangleMeshData.h"
    45
    56using namespace Ogre;

  • code/branches/physics/src/ogreode/OgreOdeTriangleMeshDataManager.h

    r1919 r1923  
    22#define __OgreOdeTriangleMeshDataManager_H__
    33
    4 #include <Ogre.h>
     4#include "OgreOdePreReqs.h"
    55
    6 #include "OgreOdePreReqs.h"
    7 #include "OgreOdeTriangleMeshData.h"
    8 
    9 using namespace std;
     6#include <map>
     7#include <OgreSingleton.h>
     8#include <OgreVector3.h>
    109
    1110namespace OgreOde
    … …  
    3332        public:
    3433       
    35                 typedef map<Ogre::String, map<Ogre::Vector3, TriangleMeshDataPtr, vectorLess > > TriangleMeshDataPtrMap;
     34        typedef std::map<Ogre::String, std::map<Ogre::Vector3, TriangleMeshDataPtr, vectorLess > > TriangleMeshDataPtrMap;
    3635
    3736                /**

  • code/branches/physics/src/ogreode/OgreOdeUtility.cpp

    r1919 r1923  
    1 
    21#include "OgreOdePrecompiledHeaders.h"
    3 
    42#include "OgreOdeUtility.h"
    53

  • code/branches/physics/src/ogreode/OgreOdeWorld.cpp

    r1922 r1923  
    1 
    21#include "OgreOdePrecompiledHeaders.h"
    3 
    42#include "OgreOdeWorld.h"
     3
     4#include <OgreSceneNode.h>
     5#include <OgreMovableObject.h>
     6
    57#include "OgreOdeBody.h"
    6 #include "OgreOdeJoint.h"
    78#include "OgreOdeGeometry.h"
    89#include "OgreOdeSpace.h"
    9 #include "OgreOdeDebugObject.h"
    1010
    1111using namespace OgreOde;

  • code/branches/physics/src/ogreode/OgreOdeWorld.h

    r1919 r1923  
    33
    44#include "OgreOdePreReqs.h"
     5
     6#include <map>
     7#include <OgreVector3.h>
     8
    59#include "OgreOdeMaintainedList.h"
    6 #include "OgreSingleton.h"
    7 
    8 #include <map>
     10#include "OgreOdeBody.h"
     11#include "OgreOdeJoint.h"
     12#include "OgreOdeGeometry.h"
     13#include "OgreOdeSpace.h"
    914
    1015namespace OgreOde
Note: See TracChangeset for help on using the changeset viewer.