Irrlicht Engine

Code: Select all

 
btDefaultCollisionConfiguration* collisionConfiguration = new btDefaultCollisionConfiguration();
  iCollisionDispatcher = new	btCollisionDispatcher(collisionConfiguration);

Code: Select all

 /*
  rigidBody = new btRigidBody(
    physicsParams.mass, 
    motionState, 
    collisionShape, 
    localInertia,
    physicsParams.linearDamping,
    physicsParams.angularDamping,
    physicsParams.friction,
    physicsParams.restitution
  );*/

  rigidBody = new btRigidBody(
    physicsParams.mass, 
    motionState, 
    collisionShape, 
    localInertia);
  rigidBody->setDamping(physicsParams.linearDamping,physicsParams.angularDamping);
  rigidBody->setFriction(physicsParams.friction);

Code: Select all

// A game application wrapper class
// 1.4.1 support!

#ifndef __C_BULLET_SCENE_NODE_ANIMATOR_FACTORY_H_INCLUDED__
#define __C_BULLET_SCENE_NODE_ANIMATOR_FACTORY_H_INCLUDED__

#include "irrlicht.h"

#include "CBulletWorldAnimator.h"
#include "CBulletObjectAnimator.h"

namespace irr
{
namespace scene
{
  class  ISceneNodeAnimator;
  class  ISceneManager;

  //! An enumeration for all types of built-in scene node animators
  enum ESCENE_NODE_BULLET_ANIMATOR_TYPE
  {
    ESNAT_BULLET_WORLD = 777,
    ESNAT_BULLET_OBJECT,
    ESNAT_BULLET_UNKNOWN
  };

  //!	Interface making it possible to dynamicly create scene nodes animators 
  class CBulletAnimatorManager : public ISceneNodeAnimatorFactory
  {
  public:

    CBulletAnimatorManager(ISceneManager* mgr);
    ~CBulletAnimatorManager();

    //! Create animator
    CBulletWorldAnimator* createBulletWorldAnimator(
      ISceneManager* scenemanager,
      ISceneNode* sceneNode, 
      CBulletWorldAnimatorParams* params
    );
    //! Create animator
    CBulletObjectAnimator* createBulletObjectAnimator(
      ISceneManager* scenemanager, 
      ISceneNode* sceneNode, 
      s32 bulletWorldID,
      CBulletObjectAnimatorGeometry* geometry,
      CBulletObjectAnimatorParams* physicsParams
    );

    //! Remove world from the list
    void removeWorld(CBulletWorldAnimator* world);

    //! Get world by id
    CBulletWorldAnimator* getBulletWorldByID(s32 id);

    //! Update
    void OnUpdate(u32 timeMs);


  private:


    //! creates a scene node animator based on its type id
    /** \param type: Type of the scene node animator to add.
    \param target: Target scene node of the new animator.
    \return Returns pointer to the new scene node animator or null if not successful. You need to
    drop this pointer after calling this, see IUnknown::drop() for details. */
    virtual ISceneNodeAnimator* createSceneNodeAnimator(ESCENE_NODE_ANIMATOR_TYPE type, ISceneNode* target);

    //! creates a scene node animator based on its type name
    /** \param typeName: Type of the scene node animator to add.
    \param target: Target scene node of the new animator.
    \return Returns pointer to the new scene node animator or null if not successful. You need to
    drop this pointer after calling this, see IUnknown::drop() for details. */
    virtual ISceneNodeAnimator* createSceneNodeAnimator(const char* typeName, ISceneNode* target);

    //! returns amount of scene node animator types this factory is able to create
#ifdef  IRR_OLD_13X
    virtual s32 getCreatableSceneNodeAnimatorTypeCount();
#else
	virtual u32 getCreatableSceneNodeAnimatorTypeCount() const;
#endif

    //! returns type of a createable scene node animator type
    /** \param idx: Index of scene node animator type in this factory. Must be a value between 0 and
    getCreatableSceneNodeTypeCount() */
#ifdef  IRR_OLD_13X
    virtual ESCENE_NODE_ANIMATOR_TYPE getCreateableSceneNodeAnimatorType(s32 idx);
#else
	virtual ESCENE_NODE_ANIMATOR_TYPE getCreateableSceneNodeAnimatorType(u32 idx) const;
#endif
	

    //! returns type name of a createable scene node animator type 
    /** \param idx: Index of scene node animator type in this factory. Must be a value between 0 and
    getCreatableSceneNodeAnimatorTypeCount() */
#ifdef  IRR_OLD_13X
    virtual const c8* getCreateableSceneNodeAnimatorTypeName(s32 idx);
#else
	virtual const c8* getCreateableSceneNodeAnimatorTypeName(u32 idx) const;
#endif
	

    //! returns type name of a createable scene node animator type 
    /** \param type: Type of scene node animator. 
    \return: Returns name of scene node animator type if this factory can create the type, otherwise 0. */
#ifdef  IRR_OLD_13X
    virtual const c8* getCreateableSceneNodeAnimatorTypeName(ESCENE_NODE_ANIMATOR_TYPE type);
#else
	virtual const c8* getCreateableSceneNodeAnimatorTypeName(ESCENE_NODE_ANIMATOR_TYPE type) const;
#endif
	


    //! Create empty animators for deserialization
    CBulletWorldAnimator* createEmptyBulletWorldAnimator(
      ISceneManager* scenemanager,
      ISceneNode* sceneNode
    );
    CBulletObjectAnimator* createEmptyBulletObjectAnimator(
      ISceneManager* scenemanager, 
      ISceneNode* sceneNode
    );


    core::list<CBulletWorldAnimator*> bulletWorldAnimators;
    ISceneManager* sceneManager;
  };


} // end namespace scene
} // end namespace irr


#endif //__C_BULLET_SCENE_NODE_ANIMATOR_FACTORY_H_INCLUDED__

Code: Select all

CBulletWorldAnimator::CBulletWorldAnimator(CBulletAnimatorManager* bulletMgr)
: iBulletManager(bulletMgr), iID(-1)
{
#ifdef _DEBUG
  setDebugName("CBulletWorldAnimator");
#endif

#ifdef USE_PARALLEL_DISPATCHER
  iCollisionDispatcher = new	SpuGatheringCollisionDispatcher();
#else

  btDefaultCollisionConfiguration* collisionConfiguration = new btDefaultCollisionConfiguration();
  iCollisionDispatcher = new	btCollisionDispatcher(collisionConfiguration);

#endif//USE_PARALLEL_DISPATCHER

  //register algorithm
  btGImpactCollisionAlgorithm::registerAlgorithm(iCollisionDispatcher);


  btVector3 aWorldMin(-10000,-10000,-10000);
  btVector3 aWorldMax(10000,10000,10000);
  iPairCache = new btAxisSweep3(aWorldMin,aWorldMax);
  //btOverlappingPairCache* aPairCache = new btAxisSweep3(aWorldMin,aWorldMax);

  //iPairCache = new btSimpleBroadphase(); 

  iConstraintSolver = new btSequentialImpulseConstraintSolver();
  iDynamicsWorld = new btDiscreteDynamicsWorld(
	  iCollisionDispatcher, 
	  iPairCache,	  
	  iConstraintSolver,
	  collisionConfiguration
	  );

#ifdef USE_PARALLEL_DISPATCHER
  iDynamicsWorld->getDispatchInfo().m_enableSPU=true;
#endif //USE_PARALLEL_DISPATCHER
}

Code: Select all

case CBPAGT_CONCAVE_LOD_TERRAIN_MESH:
		{
			//mesh converting
			{
				btVector3 vertices[3];
				irr::u32 j,k,index,numVertices,numIndices;
				irr::u16* mb_indices;

				irr::scene::ITerrainSceneNode *pTerrain = 
					(irr::scene::ITerrainSceneNode *)pSceneManager->getSceneNodeFromName(pGeom->meshFile.c_str());

				irr::scene::SMeshBufferLightMap smb;
				pTerrain->getMeshBufferForLOD(smb,pGeom->terrain_mesh.meshLod);				

				numVertices = smb.getVertexCount ();//mb->getVertexCount();
				numIndices = smb.getIndexCount();//mb->getIndexCount();
				mb_indices = smb.getIndices();// mb->getIndices();
				irr::video::S3DVertex2TCoords* mb_vertices = 
					(irr::video::S3DVertex2TCoords*)smb.getVertices();// ->getVertices();

				{
					btTriangleMesh *pTriMesh = new btTriangleMesh();

					irr::core::vector3df scaling = pScaling;

					for(j=0;j<numIndices;j+=3)
					{ //index into irrlicht data
						for (k=0;k<3;k++) 
						{
							index = mb_indices[j+k];
							// we apply scaling factor directly to verticies
							vertices[k] = btVector3(mb_vertices[index].Pos.X*scaling.X,
								mb_vertices[index].Pos.Y*scaling.Y,
								mb_vertices[index].Pos.Z*scaling.Z);
						}
						pTriMesh->addTriangle(vertices[0], vertices[1], vertices[2]);
					}
					triangleMesh = pTriMesh;
				}
			}
			
			bool useQuantizedAabbCompression = true;
			collisionShape = new btBvhTriangleMeshShape(triangleMesh, useQuantizedAabbCompression);
		}
		break;