mirror of
https://gitlab.com/OpenMW/openmw.git
synced 2025-05-06 19:01:21 +03:00
Merge branch 'master' into graphics
Conflicts: apps/openmw/CMakeLists.txt apps/openmw/mwrender/npcanimation.cpp apps/openmw/mwrender/sky.cpp
This commit is contained in:
scrawl
commit
cacdb33b42
75 changed files with 2856 additions and 4142 deletions
|
|
@ -207,7 +207,7 @@ public:
|
|||
|
||||
mLineDrawer->setMaterial("BtOgre/DebugLines");
|
||||
|
||||
mLineDrawer->setVisibilityFlags (1024);
|
||||
//mLineDrawer->setVisibilityFlags (1024);
|
||||
}
|
||||
|
||||
~DebugDrawer()
|
||||
|
|
|
|||
|
|
@ -2,7 +2,6 @@
|
|||
#include <btBulletDynamicsCommon.h>
|
||||
#include <btBulletCollisionCommon.h>
|
||||
#include <BulletCollision/CollisionShapes/btHeightfieldTerrainShape.h>
|
||||
#include "pmove.h"
|
||||
#include <components/nifbullet/bullet_nif_loader.hpp>
|
||||
#include "CMotionState.h"
|
||||
#include "OgreRoot.h"
|
||||
|
|
@ -27,91 +26,48 @@ namespace Physic
|
|||
COL_RAYCASTING = BIT(3)
|
||||
};
|
||||
|
||||
PhysicActor::PhysicActor(std::string name, std::string mesh, PhysicEngine* engine, Ogre::Vector3 position, Ogre::Quaternion rotation, float scale):
|
||||
mName(name), mEngine(engine), mMesh(mesh), mBoxScaledTranslation(0,0,0), mBoxRotationInverse(0,0,0,0), mBody(0), collisionMode(false), mBoxRotation(0,0,0,0)
|
||||
PhysicActor::PhysicActor(const std::string &name, const std::string &mesh, PhysicEngine *engine, const Ogre::Vector3 &position, const Ogre::Quaternion &rotation, float scale)
|
||||
: mName(name), mEngine(engine), mMesh(mesh), mBoxScaledTranslation(0,0,0), mBoxRotationInverse(0,0,0,0)
|
||||
, mBody(0), onGround(false), collisionMode(true), mBoxRotation(0,0,0,0), verticalForce(0.0f)
|
||||
{
|
||||
// FIXME: Force player to start in no-collision mode for now, until he spawns at a proper door marker.
|
||||
if(name == "player")
|
||||
collisionMode = false;
|
||||
mBody = mEngine->createAndAdjustRigidBody(mMesh, mName, scale, position, rotation, &mBoxScaledTranslation, &mBoxRotation);
|
||||
Ogre::Quaternion inverse = mBoxRotation.Inverse();
|
||||
mBoxRotationInverse = btQuaternion(inverse.x, inverse.y, inverse.z,inverse.w);
|
||||
mEngine->addRigidBody(mBody, false); //Add rigid body to dynamics world, but do not add to object map
|
||||
pmove = new playerMove;
|
||||
pmove->mEngine = mEngine;
|
||||
btBoxShape* box = static_cast<btBoxShape*> (mBody->getCollisionShape());
|
||||
if(box != NULL){
|
||||
btVector3 size = box->getHalfExtentsWithMargin();
|
||||
Ogre::Vector3 halfExtents = Ogre::Vector3(size.getX(), size.getY(), size.getZ());
|
||||
pmove->ps.halfExtents = halfExtents;
|
||||
}
|
||||
}
|
||||
|
||||
PhysicActor::~PhysicActor()
|
||||
{
|
||||
if(mBody){
|
||||
if(mBody)
|
||||
{
|
||||
mEngine->dynamicsWorld->removeRigidBody(mBody);
|
||||
delete mBody;
|
||||
}
|
||||
delete pmove;
|
||||
}
|
||||
|
||||
void PhysicActor::setCurrentWater(bool hasWater, int waterHeight){
|
||||
pmove->hasWater = hasWater;
|
||||
if(hasWater){
|
||||
pmove->waterHeight = waterHeight;
|
||||
}
|
||||
}
|
||||
|
||||
void PhysicActor::setGravity(float gravity)
|
||||
{
|
||||
pmove->ps.gravity = gravity;
|
||||
}
|
||||
|
||||
void PhysicActor::setSpeed(float speed)
|
||||
{
|
||||
pmove->ps.speed = speed;
|
||||
}
|
||||
|
||||
void PhysicActor::enableCollisions(bool collision)
|
||||
{
|
||||
collisionMode = collision;
|
||||
if(collisionMode)
|
||||
pmove->ps.move_type=PM_NORMAL;
|
||||
else
|
||||
pmove->ps.move_type=PM_NOCLIP;
|
||||
}
|
||||
|
||||
void PhysicActor::setJumpVelocity(float velocity)
|
||||
|
||||
void PhysicActor::setPosition(const Ogre::Vector3 &pos)
|
||||
{
|
||||
pmove->ps.jump_velocity = velocity;
|
||||
if(pos != getPosition())
|
||||
mEngine->adjustRigidBody(mBody, pos, getRotation(), mBoxScaledTranslation, mBoxRotation);
|
||||
}
|
||||
|
||||
bool PhysicActor::getCollisionMode()
|
||||
{
|
||||
return collisionMode;
|
||||
}
|
||||
|
||||
void PhysicActor::setMovement(signed char rightmove, signed char forwardmove, signed char upmove)
|
||||
{
|
||||
playerMove::playercmd& pm_ref = pmove->cmd;
|
||||
pm_ref.rightmove = rightmove;
|
||||
pm_ref.forwardmove = forwardmove;
|
||||
pm_ref.upmove = upmove;
|
||||
}
|
||||
|
||||
void PhysicActor::setPmoveViewAngles(float pitch, float yaw, float roll){
|
||||
pmove->ps.viewangles.x = pitch;
|
||||
pmove->ps.viewangles.y = yaw;
|
||||
pmove->ps.viewangles.z = roll;
|
||||
}
|
||||
|
||||
|
||||
|
||||
void PhysicActor::setRotation(const Ogre::Quaternion quat)
|
||||
void PhysicActor::setRotation(const Ogre::Quaternion &quat)
|
||||
{
|
||||
if(!quat.equals(getRotation(), Ogre::Radian(0))){
|
||||
mEngine->adjustRigidBody(mBody, getPosition(), quat, mBoxScaledTranslation, mBoxRotation);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
Ogre::Vector3 PhysicActor::getPosition()
|
||||
{
|
||||
btVector3 vec = mBody->getWorldTransform().getOrigin();
|
||||
|
|
@ -128,13 +84,6 @@ namespace Physic
|
|||
return Ogre::Quaternion(quat.getW(), quat.getX(), quat.getY(), quat.getZ());
|
||||
}
|
||||
|
||||
void PhysicActor::setPosition(const Ogre::Vector3 pos)
|
||||
{
|
||||
mEngine->adjustRigidBody(mBody, pos, getRotation(), mBoxScaledTranslation, mBoxRotation);
|
||||
btVector3 vec = mBody->getWorldTransform().getOrigin();
|
||||
pmove->ps.origin = Ogre::Vector3(vec.getX(), vec.getY(), vec.getZ());
|
||||
}
|
||||
|
||||
void PhysicActor::setScale(float scale){
|
||||
Ogre::Vector3 position = getPosition();
|
||||
Ogre::Quaternion rotation = getRotation();
|
||||
|
|
@ -148,18 +97,40 @@ namespace Physic
|
|||
//Create the newly scaled rigid body
|
||||
mBody = mEngine->createAndAdjustRigidBody(mMesh, mName, scale, position, rotation);
|
||||
mEngine->addRigidBody(mBody, false); //Add rigid body to dynamics world, but do not add to object map
|
||||
btBoxShape* box = static_cast<btBoxShape*> (mBody->getCollisionShape());
|
||||
if(box != NULL){
|
||||
btVector3 size = box->getHalfExtentsWithMargin();
|
||||
Ogre::Vector3 halfExtents = Ogre::Vector3(size.getX(), size.getY(), size.getZ());
|
||||
pmove->ps.halfExtents = halfExtents;
|
||||
}
|
||||
}
|
||||
|
||||
void PhysicActor::runPmove(){
|
||||
Pmove(pmove);
|
||||
Ogre::Vector3 newpos = pmove->ps.origin;
|
||||
mBody->getWorldTransform().setOrigin(btVector3(newpos.x, newpos.y, newpos.z));
|
||||
Ogre::Vector3 PhysicActor::getHalfExtents() const
|
||||
{
|
||||
if(mBody)
|
||||
{
|
||||
btBoxShape *box = static_cast<btBoxShape*>(mBody->getCollisionShape());
|
||||
if(box != NULL)
|
||||
{
|
||||
btVector3 size = box->getHalfExtentsWithMargin();
|
||||
return Ogre::Vector3(size.getX(), size.getY(), size.getZ());
|
||||
}
|
||||
}
|
||||
return Ogre::Vector3(0.0f);
|
||||
}
|
||||
|
||||
void PhysicActor::setVerticalForce(float force)
|
||||
{
|
||||
verticalForce = force;
|
||||
}
|
||||
|
||||
float PhysicActor::getVerticalForce() const
|
||||
{
|
||||
return verticalForce;
|
||||
}
|
||||
|
||||
void PhysicActor::setOnGround(bool grounded)
|
||||
{
|
||||
onGround = grounded;
|
||||
}
|
||||
|
||||
bool PhysicActor::getOnGround() const
|
||||
{
|
||||
return collisionMode && onGround;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
|
@ -221,10 +192,7 @@ namespace Physic
|
|||
{
|
||||
if(!isDebugCreated)
|
||||
{
|
||||
Ogre::SceneManagerEnumerator::SceneManagerIterator iter = Ogre::Root::getSingleton().getSceneManagerIterator();
|
||||
iter.begin();
|
||||
Ogre::SceneManager* scn = iter.getNext();
|
||||
Ogre::SceneNode* node = scn->getRootSceneNode()->createChildSceneNode();
|
||||
Ogre::SceneNode* node = mSceneMgr->getRootSceneNode()->createChildSceneNode();
|
||||
node->pitch(Ogre::Degree(-90));
|
||||
mDebugDrawer = new BtOgre::DebugDrawer(node, dynamicsWorld);
|
||||
dynamicsWorld->setDebugDrawer(mDebugDrawer);
|
||||
|
|
@ -249,6 +217,11 @@ namespace Physic
|
|||
return mDebugActive;
|
||||
}
|
||||
|
||||
void PhysicEngine::setSceneManager(Ogre::SceneManager* sceneMgr)
|
||||
{
|
||||
mSceneMgr = sceneMgr;
|
||||
}
|
||||
|
||||
PhysicEngine::~PhysicEngine()
|
||||
{
|
||||
HeightFieldContainer::iterator hf_it = mHeightFieldMap.begin();
|
||||
|
|
@ -356,18 +329,21 @@ namespace Physic
|
|||
mHeightFieldMap.erase(name);
|
||||
}
|
||||
|
||||
void PhysicEngine::adjustRigidBody(RigidBody* body, Ogre::Vector3 position, Ogre::Quaternion rotation,
|
||||
Ogre::Vector3 scaledBoxTranslation, Ogre::Quaternion boxRotation){
|
||||
void PhysicEngine::adjustRigidBody(RigidBody* body, const Ogre::Vector3 &position, const Ogre::Quaternion &rotation,
|
||||
const Ogre::Vector3 &scaledBoxTranslation, const Ogre::Quaternion &boxRotation)
|
||||
{
|
||||
btTransform tr;
|
||||
rotation = rotation * boxRotation;
|
||||
Ogre::Vector3 transrot = rotation * scaledBoxTranslation;
|
||||
Ogre::Quaternion boxrot = rotation * boxRotation;
|
||||
Ogre::Vector3 transrot = boxrot * scaledBoxTranslation;
|
||||
Ogre::Vector3 newPosition = transrot + position;
|
||||
|
||||
|
||||
tr.setOrigin(btVector3(newPosition.x, newPosition.y, newPosition.z));
|
||||
tr.setRotation(btQuaternion(rotation.x,rotation.y,rotation.z,rotation.w));
|
||||
tr.setRotation(btQuaternion(boxrot.x,boxrot.y,boxrot.z,boxrot.w));
|
||||
body->setWorldTransform(tr);
|
||||
}
|
||||
void PhysicEngine::boxAdjustExternal(std::string mesh, RigidBody* body, float scale, Ogre::Vector3 position, Ogre::Quaternion rotation){
|
||||
void PhysicEngine::boxAdjustExternal(const std::string &mesh, RigidBody* body,
|
||||
float scale, const Ogre::Vector3 &position, const Ogre::Quaternion &rotation)
|
||||
{
|
||||
std::string sid = (boost::format("%07.3f") % scale).str();
|
||||
std::string outputstring = mesh + sid;
|
||||
//std::cout << "The string" << outputstring << "\n";
|
||||
|
|
@ -380,7 +356,8 @@ namespace Physic
|
|||
adjustRigidBody(body, position, rotation, shape->boxTranslation * scale, shape->boxRotation);
|
||||
}
|
||||
|
||||
RigidBody* PhysicEngine::createAndAdjustRigidBody(std::string mesh,std::string name,float scale, Ogre::Vector3 position, Ogre::Quaternion rotation,
|
||||
RigidBody* PhysicEngine::createAndAdjustRigidBody(const std::string &mesh, const std::string &name,
|
||||
float scale, const Ogre::Vector3 &position, const Ogre::Quaternion &rotation,
|
||||
Ogre::Vector3* scaledBoxTranslation, Ogre::Quaternion* boxRotation)
|
||||
{
|
||||
std::string sid = (boost::format("%07.3f") % scale).str();
|
||||
|
|
@ -441,7 +418,7 @@ namespace Physic
|
|||
}
|
||||
}
|
||||
|
||||
void PhysicEngine::removeRigidBody(std::string name)
|
||||
void PhysicEngine::removeRigidBody(const std::string &name)
|
||||
{
|
||||
RigidBodyContainer::iterator it = ObjectMap.find(name);
|
||||
if (it != ObjectMap.end() )
|
||||
|
|
@ -461,7 +438,7 @@ namespace Physic
|
|||
}
|
||||
}
|
||||
|
||||
void PhysicEngine::deleteRigidBody(std::string name)
|
||||
void PhysicEngine::deleteRigidBody(const std::string &name)
|
||||
{
|
||||
RigidBodyContainer::iterator it = ObjectMap.find(name);
|
||||
if (it != ObjectMap.end() )
|
||||
|
|
@ -481,7 +458,7 @@ namespace Physic
|
|||
}
|
||||
}
|
||||
|
||||
RigidBody* PhysicEngine::getRigidBody(std::string name)
|
||||
RigidBody* PhysicEngine::getRigidBody(const std::string &name)
|
||||
{
|
||||
RigidBodyContainer::iterator it = ObjectMap.find(name);
|
||||
if (it != ObjectMap.end() )
|
||||
|
|
@ -497,15 +474,16 @@ namespace Physic
|
|||
|
||||
void PhysicEngine::stepSimulation(double deltaT)
|
||||
{
|
||||
dynamicsWorld->stepSimulation(deltaT,10, 1/60.0);
|
||||
// This isn't needed as there are no dynamic objects at this point
|
||||
//dynamicsWorld->stepSimulation(deltaT,10, 1/60.0);
|
||||
if(isDebugCreated)
|
||||
{
|
||||
mDebugDrawer->step();
|
||||
}
|
||||
}
|
||||
|
||||
void PhysicEngine::addCharacter(std::string name, std::string mesh,
|
||||
Ogre::Vector3 position, float scale, Ogre::Quaternion rotation)
|
||||
void PhysicEngine::addCharacter(const std::string &name, const std::string &mesh,
|
||||
const Ogre::Vector3 &position, float scale, const Ogre::Quaternion &rotation)
|
||||
{
|
||||
// Remove character with given name, so we don't make memory
|
||||
// leak when character would be added twice
|
||||
|
|
@ -518,9 +496,8 @@ namespace Physic
|
|||
PhysicActorMap[name] = newActor;
|
||||
}
|
||||
|
||||
void PhysicEngine::removeCharacter(std::string name)
|
||||
void PhysicEngine::removeCharacter(const std::string &name)
|
||||
{
|
||||
//std::cout << "remove";
|
||||
PhysicActorContainer::iterator it = PhysicActorMap.find(name);
|
||||
if (it != PhysicActorMap.end() )
|
||||
{
|
||||
|
|
@ -534,7 +511,7 @@ namespace Physic
|
|||
}
|
||||
}
|
||||
|
||||
PhysicActor* PhysicEngine::getCharacter(std::string name)
|
||||
PhysicActor* PhysicEngine::getCharacter(const std::string &name)
|
||||
{
|
||||
PhysicActorContainer::iterator it = PhysicActorMap.find(name);
|
||||
if (it != PhysicActorMap.end() )
|
||||
|
|
|
|||
|
|
@ -18,13 +18,17 @@ class btSequentialImpulseConstraintSolver;
|
|||
class btCollisionDispatcher;
|
||||
class btDiscreteDynamicsWorld;
|
||||
class btHeightfieldTerrainShape;
|
||||
struct playerMove;
|
||||
|
||||
namespace BtOgre
|
||||
{
|
||||
class DebugDrawer;
|
||||
}
|
||||
|
||||
namespace Ogre
|
||||
{
|
||||
class SceneManager;
|
||||
}
|
||||
|
||||
namespace MWWorld
|
||||
{
|
||||
class World;
|
||||
|
|
@ -61,33 +65,26 @@ namespace Physic
|
|||
class PhysicActor
|
||||
{
|
||||
public:
|
||||
PhysicActor(std::string name, std::string mesh, PhysicEngine *engine, Ogre::Vector3 position, Ogre::Quaternion rotation, float scale);
|
||||
PhysicActor(const std::string &name, const std::string &mesh, PhysicEngine *engine, const Ogre::Vector3 &position, const Ogre::Quaternion &rotation, float scale);
|
||||
|
||||
~PhysicActor();
|
||||
|
||||
void setCurrentWater(bool hasWater, int waterHeight);
|
||||
|
||||
/**
|
||||
* This function sets the movement keys for pmove
|
||||
*/
|
||||
void setMovement(signed char rightmove, signed char forwardmove, signed char upmove);
|
||||
void setPosition(const Ogre::Vector3 &pos);
|
||||
|
||||
/**
|
||||
* This adjusts the rotation of a PhysicActor
|
||||
* If we have any problems with this (getting stuck in pmove) we should change it
|
||||
* from setting the visual orientation to setting the orientation of the rigid body directly.
|
||||
*/
|
||||
void setRotation(const Ogre::Quaternion quat);
|
||||
|
||||
void setGravity(float gravity);
|
||||
|
||||
void setSpeed(float speed);
|
||||
|
||||
void setJumpVelocity(float velocity);
|
||||
void setRotation(const Ogre::Quaternion &quat);
|
||||
|
||||
void enableCollisions(bool collision);
|
||||
|
||||
bool getCollisionMode();
|
||||
bool getCollisionMode() const
|
||||
{
|
||||
return collisionMode;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* This returns the visual position of the PhysicActor (used to position a scenenode).
|
||||
|
|
@ -100,27 +97,29 @@ namespace Physic
|
|||
*/
|
||||
Ogre::Quaternion getRotation();
|
||||
|
||||
/**
|
||||
* Sets the position of mBody from a visual position input.
|
||||
* For most cases this should not be used. We should instead let pmove move the PhysicActor around for us
|
||||
*/
|
||||
void setPosition(const Ogre::Vector3 pos);
|
||||
|
||||
/**
|
||||
* Sets the view angles for pmove directly.
|
||||
* Remember, add 90 for yaw. Set roll to 0.
|
||||
*/
|
||||
void setPmoveViewAngles(float pitch, float yaw, float roll);
|
||||
|
||||
/**
|
||||
* Sets the scale of the PhysicActor
|
||||
*/
|
||||
void setScale(float scale);
|
||||
|
||||
/**
|
||||
* Runs pmove for this PhysicActor
|
||||
* Returns the half extents for this PhysiActor
|
||||
*/
|
||||
void runPmove();
|
||||
Ogre::Vector3 getHalfExtents() const;
|
||||
|
||||
/**
|
||||
* Sets the current amount of vertical force (gravity) affecting this physic actor
|
||||
*/
|
||||
void setVerticalForce(float force);
|
||||
|
||||
/**
|
||||
* Gets the current amount of vertical force (gravity) affecting this physic actor
|
||||
*/
|
||||
float getVerticalForce() const;
|
||||
|
||||
void setOnGround(bool grounded);
|
||||
|
||||
bool getOnGround() const;
|
||||
|
||||
//HACK: in Visual Studio 2010 and presumably above, this structures alignment
|
||||
// must be 16, but the built in operator new & delete don't properly
|
||||
|
|
@ -136,12 +135,12 @@ namespace Physic
|
|||
Ogre::Vector3 mBoxScaledTranslation;
|
||||
btQuaternion mBoxRotationInverse;
|
||||
Ogre::Quaternion mBoxRotation;
|
||||
float verticalForce;
|
||||
bool onGround;
|
||||
bool collisionMode;
|
||||
std::string mMesh;
|
||||
PhysicEngine* mEngine;
|
||||
std::string mName;
|
||||
playerMove* pmove;
|
||||
|
||||
};
|
||||
|
||||
/**
|
||||
|
|
@ -190,19 +189,21 @@ namespace Physic
|
|||
* Creates a RigidBody. It does not add it to the simulation.
|
||||
* After created, the body is set to the correct rotation, position, and scale
|
||||
*/
|
||||
RigidBody* createAndAdjustRigidBody(std::string mesh,std::string name,float scale, Ogre::Vector3 position, Ogre::Quaternion rotation,
|
||||
RigidBody* createAndAdjustRigidBody(const std::string &mesh, const std::string &name,
|
||||
float scale, const Ogre::Vector3 &position, const Ogre::Quaternion &rotation,
|
||||
Ogre::Vector3* scaledBoxTranslation = 0, Ogre::Quaternion* boxRotation = 0);
|
||||
|
||||
/**
|
||||
* Adjusts a rigid body to the right position and rotation
|
||||
*/
|
||||
|
||||
void adjustRigidBody(RigidBody* body, Ogre::Vector3 position, Ogre::Quaternion rotation,
|
||||
Ogre::Vector3 scaledBoxTranslation = Ogre::Vector3::ZERO, Ogre::Quaternion boxRotation = Ogre::Quaternion::IDENTITY);
|
||||
void adjustRigidBody(RigidBody* body, const Ogre::Vector3 &position, const Ogre::Quaternion &rotation,
|
||||
const Ogre::Vector3 &scaledBoxTranslation = Ogre::Vector3::ZERO,
|
||||
const Ogre::Quaternion &boxRotation = Ogre::Quaternion::IDENTITY);
|
||||
/**
|
||||
Mainly used to (but not limited to) adjust rigid bodies based on box shapes to the right position and rotation.
|
||||
*/
|
||||
void boxAdjustExternal(std::string mesh, RigidBody* body, float scale, Ogre::Vector3 position, Ogre::Quaternion rotation);
|
||||
void boxAdjustExternal(const std::string &mesh, RigidBody* body, float scale, const Ogre::Vector3 &position, const Ogre::Quaternion &rotation);
|
||||
/**
|
||||
* Add a HeightField to the simulation
|
||||
*/
|
||||
|
|
@ -223,35 +224,35 @@ namespace Physic
|
|||
/**
|
||||
* Remove a RigidBody from the simulation. It does not delete it, and does not remove it from the RigidBodyMap.
|
||||
*/
|
||||
void removeRigidBody(std::string name);
|
||||
void removeRigidBody(const std::string &name);
|
||||
|
||||
/**
|
||||
* Delete a RigidBody, and remove it from RigidBodyMap.
|
||||
*/
|
||||
void deleteRigidBody(std::string name);
|
||||
void deleteRigidBody(const std::string &name);
|
||||
|
||||
/**
|
||||
* Return a pointer to a given rigid body.
|
||||
* TODO:check if exist
|
||||
*/
|
||||
RigidBody* getRigidBody(std::string name);
|
||||
RigidBody* getRigidBody(const std::string &name);
|
||||
|
||||
/**
|
||||
* Create and add a character to the scene, and add it to the ActorMap.
|
||||
*/
|
||||
void addCharacter(std::string name, std::string mesh,
|
||||
Ogre::Vector3 position, float scale, Ogre::Quaternion rotation);
|
||||
void addCharacter(const std::string &name, const std::string &mesh,
|
||||
const Ogre::Vector3 &position, float scale, const Ogre::Quaternion &rotation);
|
||||
|
||||
/**
|
||||
* Remove a character from the scene. TODO:delete it! for now, a small memory leak^^ done?
|
||||
*/
|
||||
void removeCharacter(std::string name);
|
||||
void removeCharacter(const std::string &name);
|
||||
|
||||
/**
|
||||
* Return a pointer to a character
|
||||
* TODO:check if the actor exist...
|
||||
*/
|
||||
PhysicActor* getCharacter(std::string name);
|
||||
PhysicActor* getCharacter(const std::string &name);
|
||||
|
||||
/**
|
||||
* This step the simulation of a given time.
|
||||
|
|
@ -279,6 +280,8 @@ namespace Physic
|
|||
|
||||
void getObjectAABB(const std::string &mesh, float scale, btVector3 &min, btVector3 &max);
|
||||
|
||||
void setSceneManager(Ogre::SceneManager* sceneMgr);
|
||||
|
||||
/**
|
||||
* Return the closest object hit by a ray. If there are no objects, it will return ("",-1).
|
||||
*/
|
||||
|
|
@ -315,11 +318,12 @@ namespace Physic
|
|||
typedef std::map<std::string, PhysicActor*> PhysicActorContainer;
|
||||
PhysicActorContainer PhysicActorMap;
|
||||
|
||||
Ogre::SceneManager* mSceneMgr;
|
||||
|
||||
//debug rendering
|
||||
BtOgre::DebugDrawer* mDebugDrawer;
|
||||
bool isDebugCreated;
|
||||
bool mDebugActive;
|
||||
|
||||
};
|
||||
|
||||
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -1,200 +0,0 @@
|
|||
#ifndef OENGINE_BULLET_PMOVE_H
|
||||
#define OENGINE_BULLET_PMOVE_H
|
||||
/*
|
||||
This source file is a *modified* version of various header files from the Quake 3 Arena source code,
|
||||
which was released under the GNU GPL (v2) in 2005.
|
||||
Quake 3 Arena is copyright (C) 1999-2005 Id Software, Inc.
|
||||
*/
|
||||
|
||||
#include <OgreMath.h>
|
||||
#include <float.h>
|
||||
#include "trace.h"
|
||||
#include "physic.hpp"
|
||||
|
||||
#include <OgreVector3.h>
|
||||
|
||||
//#include "GameMath.h"
|
||||
//#include "GameTime.h"
|
||||
|
||||
// Forwards-declare it!
|
||||
|
||||
/*#ifndef COMPILING_PMOVE
|
||||
#include "Scene.h"
|
||||
extern SceneInstance* global_lastscene;
|
||||
#endif*/
|
||||
|
||||
static const Ogre::Vector3 halfExtentsDefault(14.64f * 2, 14.24f * 2, 33.25f * 2);
|
||||
|
||||
#define MAX_CLIP_PLANES 5
|
||||
#define OVERCLIP 1.001f
|
||||
//#define STEPSIZE 18 // 18 is way too much
|
||||
#define STEPSIZE (9)
|
||||
#ifndef M_PI
|
||||
#define M_PI 3.14159265358979323846f
|
||||
#endif
|
||||
#define YAW 0
|
||||
#define PITCH /*1*/2
|
||||
#define ROLL /*2*/1
|
||||
#define SHORT2ANGLE(x) ( (x) * (360.0f / 65536.0f) )
|
||||
#define ANGLE2SHORT(x) ( (const short)( (x) / (360.0f / 65536.0f) ) )
|
||||
#define GENTITYNUM_BITS 10 // don't need to send any more
|
||||
#define MAX_GENTITIES (1 << GENTITYNUM_BITS)
|
||||
#define ENTITYNUM_NONE (MAX_GENTITIES - 1)
|
||||
#define ENTITYNUM_WORLD (MAX_GENTITIES - 2)
|
||||
#define MIN_WALK_NORMAL .7f // can't walk on very steep slopes
|
||||
#define PS_PMOVEFRAMECOUNTBITS 6
|
||||
#define MINS_Z -24
|
||||
#define DEFAULT_VIEWHEIGHT 26
|
||||
#define CROUCH_VIEWHEIGHT 12
|
||||
#define DEAD_VIEWHEIGHT (-16)
|
||||
#define CONTENTS_SOLID 1 // an eye is never valid in a solid
|
||||
#define CONTENTS_LAVA 8
|
||||
#define CONTENTS_SLIME 16
|
||||
#define CONTENTS_WATER 32
|
||||
#define CONTENTS_FOG 64
|
||||
static const float pm_accelerate = 10.0f;
|
||||
static const float pm_stopspeed = 100.0f;
|
||||
static const float pm_friction = 12.0f;
|
||||
static const float pm_flightfriction = 3.0f;
|
||||
static const float pm_waterfriction = 1.0f;
|
||||
static const float pm_airaccelerate = 1.0f;
|
||||
static const float pm_swimScale = 0.50f;
|
||||
static const float pm_duckScale = 0.25f;
|
||||
static const float pm_flyaccelerate = 8.0f;
|
||||
static const float pm_wateraccelerate = 4.0f;
|
||||
|
||||
enum pmtype_t
|
||||
{
|
||||
PM_NORMAL, // can accelerate and turn
|
||||
PM_NOCLIP, // noclip movement
|
||||
PM_SPECTATOR, // still run into walls
|
||||
PM_DEAD, // no acceleration or turning, but free falling
|
||||
PM_FREEZE, // stuck in place with no control
|
||||
PM_INTERMISSION, // no movement or status bar
|
||||
PM_SPINTERMISSION // no movement or status bar
|
||||
};
|
||||
|
||||
enum waterlevel_t
|
||||
{
|
||||
WL_DRYLAND = 0,
|
||||
WL_ANKLE,
|
||||
WL_WAIST,
|
||||
WL_UNDERWATER
|
||||
};
|
||||
|
||||
|
||||
//#include "bprintf.h"
|
||||
|
||||
struct playerMove
|
||||
{
|
||||
struct playerStruct
|
||||
{
|
||||
playerStruct() : gravity(800.0f), speed(480.0f), jump_velocity(270), pmove_framecount(20), groundEntityNum(ENTITYNUM_NONE), commandTime(40), move_type(PM_NOCLIP), pm_time(0), snappingImplemented(true), bSnap(false), counter(-1), halfExtents(halfExtentsDefault)
|
||||
{
|
||||
origin = Ogre::Vector3(0.0f, 0.0f, 0.0f);
|
||||
velocity = Ogre::Vector3(0.0f, 0.0f, 0.0f);
|
||||
|
||||
viewangles = Ogre::Vector3(0.0f, 0.0f, 0.0f);
|
||||
|
||||
delta_angles[0] = delta_angles[1] = delta_angles[2] = 0;
|
||||
|
||||
lastframe_origin.x = lastframe_origin.y = lastframe_origin.z = 0;
|
||||
lerp_multiplier.x = lerp_multiplier.y = lerp_multiplier.z = 0;
|
||||
}
|
||||
|
||||
inline void SpeedUp(void)
|
||||
{
|
||||
//printf("speed up to: %f\n", speed);
|
||||
speed *= 1.25f;
|
||||
}
|
||||
|
||||
inline void SpeedDown(void)
|
||||
{
|
||||
//printf("speed down to %f\n", speed);
|
||||
speed /= 1.25f;
|
||||
}
|
||||
|
||||
Ogre::Vector3 velocity;
|
||||
Ogre::Vector3 origin;
|
||||
Ogre::Vector3 halfExtents;
|
||||
bool bSnap;
|
||||
bool snappingImplemented;
|
||||
int counter;
|
||||
float gravity; // default = 800
|
||||
float speed; // default = 320
|
||||
float jump_velocity; //default = 270
|
||||
|
||||
int commandTime; // the time at which this command was issued (in milliseconds)
|
||||
|
||||
int pm_time;
|
||||
|
||||
Ogre::Vector3 viewangles;
|
||||
|
||||
int groundEntityNum;
|
||||
|
||||
int pmove_framecount;
|
||||
|
||||
int watertype;
|
||||
waterlevel_t waterlevel;
|
||||
|
||||
signed short delta_angles[3];
|
||||
|
||||
pmtype_t move_type;
|
||||
|
||||
float last_compute_time;
|
||||
Ogre::Vector3 lastframe_origin;
|
||||
Ogre::Vector3 lerp_multiplier;
|
||||
} ps;
|
||||
|
||||
struct playercmd
|
||||
{
|
||||
enum CMDstateChange
|
||||
{
|
||||
NO_CHANGE,
|
||||
KEYDOWN,
|
||||
KEYUP
|
||||
};
|
||||
|
||||
playercmd() : forwardmove(0), rightmove(0), upmove(0), serverTime(50), ducking(false),
|
||||
activating(false), lastActivatingState(false), procActivating(NO_CHANGE),
|
||||
dropping(false), lastDroppingState(false), procDropping(NO_CHANGE)
|
||||
{
|
||||
angles[0] = angles[1] = angles[2] = 0;
|
||||
}
|
||||
|
||||
int serverTime;
|
||||
|
||||
short angles[3];
|
||||
|
||||
signed char forwardmove;
|
||||
signed char rightmove;
|
||||
signed char upmove;
|
||||
|
||||
bool ducking;
|
||||
bool activating; // if the user is holding down the activate button
|
||||
bool dropping; // if the user is dropping an item
|
||||
|
||||
bool lastActivatingState;
|
||||
bool lastDroppingState;
|
||||
|
||||
CMDstateChange procActivating;
|
||||
CMDstateChange procDropping;
|
||||
} cmd;
|
||||
|
||||
playerMove() : msec(50), pmove_fixed(false), pmove_msec(50), waterHeight(0), isInterior(true), hasWater(false)
|
||||
{
|
||||
}
|
||||
|
||||
int msec;
|
||||
int pmove_msec;
|
||||
bool pmove_fixed;
|
||||
int waterHeight;
|
||||
bool hasWater;
|
||||
bool isInterior;
|
||||
OEngine::Physic::PhysicEngine* mEngine;
|
||||
};
|
||||
|
||||
void Pmove (playerMove* const pmove);
|
||||
void Ext_UpdateViewAngles(playerMove* const pm);
|
||||
void AngleVectors( const Ogre::Vector3& angles, Ogre::Vector3* const forward, Ogre::Vector3* const right, Ogre::Vector3* const up) ;
|
||||
#endif
|
||||
|
|
@ -1,196 +1,57 @@
|
|||
|
||||
#include "trace.h"
|
||||
|
||||
|
||||
|
||||
#include <map>
|
||||
|
||||
#include <btBulletDynamicsCommon.h>
|
||||
#include <btBulletCollisionCommon.h>
|
||||
|
||||
#include "physic.hpp"
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
void newtrace(traceResults* const results, const Ogre::Vector3& start, const Ogre::Vector3& end, const Ogre::Vector3& BBHalfExtents, const float rotation, bool isInterior, OEngine::Physic::PhysicEngine* enginePass) //Traceobj was a Aedra Object
|
||||
enum traceWorldType
|
||||
{
|
||||
//static float lastyaw = 0.0f;
|
||||
//static float lastpitch = 0.0f;
|
||||
//if (!traceobj)
|
||||
// return;
|
||||
collisionWorldTrace = 1,
|
||||
pickWorldTrace = 2,
|
||||
bothWorldTrace = collisionWorldTrace | pickWorldTrace
|
||||
};
|
||||
|
||||
//if (!traceobj->incellptr)
|
||||
// return;
|
||||
|
||||
|
||||
const Ogre::Vector3 rayDir = end - start;
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
NewPhysTraceResults out;
|
||||
//std::cout << "Starting trace\n";
|
||||
//Ogre::Vector3 startReplace = Ogre::Vector3(650,950, 45);
|
||||
//Ogre::Vector3 endReplace = startReplace;
|
||||
//endReplace.z -= .25;
|
||||
|
||||
const bool hasHit = NewPhysicsTrace<collisionWorldTrace>(&out, start, end, BBHalfExtents, Ogre::Vector3(0.0f, 0.0f, 0.0f), isInterior, enginePass);
|
||||
|
||||
if (out.fraction < 0.001f)
|
||||
results->startsolid = true;
|
||||
else
|
||||
results->startsolid = false;
|
||||
|
||||
|
||||
//results->allsolid = out.startSolid;
|
||||
|
||||
// If outside and underground, we're solid
|
||||
/*if (isInterior)
|
||||
{
|
||||
const Ogre::Vector3 height = GetGroundPosition(start, CellCoords(traceCell->data->gridX, traceCell->data->gridY) );
|
||||
if (start.yPos - height.yPos < (-2.0f * BBHalfExtents.yPos) )
|
||||
{
|
||||
results->allsolid = true;
|
||||
}
|
||||
else
|
||||
results->allsolid = false;
|
||||
}*/
|
||||
|
||||
// If inside and out of the tree, we're solid
|
||||
//else
|
||||
//{
|
||||
results->allsolid = out.startSolid;
|
||||
//std::cout << "allsolid" << results->allsolid << "\n";
|
||||
//}
|
||||
|
||||
if (!hasHit)
|
||||
{
|
||||
results->endpos = end;
|
||||
results->planenormal = Ogre::Vector3(0.0f, 0.0f, 1.0f);
|
||||
results->entityNum = ENTITYNUM_NONE;
|
||||
results->fraction = 1.0f;
|
||||
}
|
||||
else
|
||||
{
|
||||
results->fraction = out.fraction;
|
||||
results->planenormal = out.hitNormal;
|
||||
results->endpos = rayDir * results->fraction + start;
|
||||
results->entityNum = ENTITYNUM_WORLD;
|
||||
/*bprintf("Start: (%f, %f, %f) End: (%f, %f, %f) TraceDir: (%f, %f, %f) HitNormal: (%f, %f, %f) Fraction: %f Hitpos: (%f, %f, %f) CompensatedHitpos: (%f, %f, %f)\n",
|
||||
start.xPos, start.yPos, start.zPos,
|
||||
end.xPos, end.yPos, end.zPos,
|
||||
rayDir.xPos, rayDir.yPos, rayDir.zPos,
|
||||
results->planenormal.xPos, results->planenormal.yPos, results->planenormal.zPos, results->fraction,
|
||||
out.endPos.xPos, out.endPos.yPos, out.endPos.zPos,
|
||||
results->endpos.xPos, results->endpos.yPos, results->endpos.zPos);*/
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
template <const traceWorldType traceType>
|
||||
const bool NewPhysicsTrace(NewPhysTraceResults* const out, const Ogre::Vector3& start, const Ogre::Vector3& end,
|
||||
const Ogre::Vector3& BBHalfExtents, const Ogre::Vector3& rotation, bool isInterior, OEngine::Physic::PhysicEngine* enginePass)
|
||||
enum collaborativePhysicsType
|
||||
{
|
||||
//if (!traceobj->incellptr)
|
||||
// return false;
|
||||
//if(enginePass->dynamicsWorld->getCollisionObjectArray().at(60)->getCollisionShape()->isConvex())
|
||||
// std::cout << "It's convex\n";
|
||||
|
||||
|
||||
No_Physics = 0, // Both are empty (example: statics you can walk through, like tall grass)
|
||||
Only_Collision = 1, // This object only has collision physics but no pickup physics (example: statics)
|
||||
Only_Pickup = 2, // This object only has pickup physics but no collision physics (example: items dropped on the ground)
|
||||
Both_Physics = 3 // This object has both kinds of physics (example: activators)
|
||||
};
|
||||
|
||||
const btVector3 btstart(start.x, start.y, start.z + BBHalfExtents.z);
|
||||
const btVector3 btend(end.x, end.y, end.z + BBHalfExtents.z);
|
||||
const btQuaternion btrot(rotation.y, rotation.x, rotation.z); //y, x, z
|
||||
void newtrace(traceResults *results, const Ogre::Vector3& start, const Ogre::Vector3& end, const Ogre::Vector3& BBHalfExtents, bool isInterior, OEngine::Physic::PhysicEngine *enginePass) //Traceobj was a Aedra Object
|
||||
{
|
||||
const btVector3 btstart(start.x, start.y, start.z + BBHalfExtents.z);
|
||||
const btVector3 btend(end.x, end.y, end.z + BBHalfExtents.z);
|
||||
const btQuaternion btrot(0.0f, 0.0f, 0.0f); //y, x, z
|
||||
|
||||
const btBoxShape newshape(btVector3(BBHalfExtents.x, BBHalfExtents.y, BBHalfExtents.z));
|
||||
//const btCapsuleShapeZ newshape(BBHalfExtents.x, BBHalfExtents.z * 2 - BBHalfExtents.x * 2);
|
||||
const btTransform from(btrot, btstart);
|
||||
const btTransform to(btrot, btend);
|
||||
//const btCapsuleShapeZ newshape(BBHalfExtents.x, BBHalfExtents.z * 2 - BBHalfExtents.x * 2);
|
||||
const btTransform from(btrot, btstart);
|
||||
const btTransform to(btrot, btend);
|
||||
|
||||
// warning: unused variable ...
|
||||
/*
|
||||
float x = from.getOrigin().getX();
|
||||
float y = from.getOrigin().getY();
|
||||
float z = from.getOrigin().getZ();
|
||||
float x2 = to.getOrigin().getX();
|
||||
float y2 = to.getOrigin().getY();
|
||||
float z2 = to.getOrigin().getZ();
|
||||
*/
|
||||
|
||||
//std::cout << "BtFrom: " << x << "," << y << "," << z << "\n";
|
||||
//std::cout << "BtTo: " << x2 << "," << y2 << "," << z2 << "\n";
|
||||
//std::cout << "BtTo: " << to.getOrigin().getX() << "," << to.getOrigin().getY() << "," << to.getOrigin().getZ() << "\n";
|
||||
btCollisionWorld::ClosestConvexResultCallback newTraceCallback(btstart, btend);
|
||||
newTraceCallback.m_collisionFilterMask = Only_Collision;
|
||||
|
||||
enginePass->dynamicsWorld->convexSweepTest(&newshape, from, to, newTraceCallback);
|
||||
|
||||
btCollisionWorld::ClosestConvexResultCallback
|
||||
newTraceCallback(btstart, btend);
|
||||
|
||||
newTraceCallback.m_collisionFilterMask = (traceType == collisionWorldTrace) ? Only_Collision : Only_Pickup;
|
||||
|
||||
|
||||
enginePass->dynamicsWorld->convexSweepTest(&newshape, from, to, newTraceCallback);
|
||||
//newTraceCallback.
|
||||
|
||||
|
||||
//std::cout << "NUM: " << enginePass->dynamicsWorld->getNumCollisionObjects() << "\n";
|
||||
|
||||
// Copy the hit data over to our trace results struct:
|
||||
out->fraction = newTraceCallback.m_closestHitFraction;
|
||||
|
||||
Ogre::Vector3& outhitnormal = out->hitNormal;
|
||||
const btVector3& tracehitnormal = newTraceCallback.m_hitNormalWorld;
|
||||
|
||||
outhitnormal.x = tracehitnormal.x();
|
||||
outhitnormal.y = tracehitnormal.y();
|
||||
outhitnormal.z = tracehitnormal.z();
|
||||
|
||||
Ogre::Vector3& outhitpos = out->endPos;
|
||||
const btVector3& tracehitpos = newTraceCallback.m_hitPointWorld;
|
||||
|
||||
outhitpos.x = tracehitpos.x();
|
||||
outhitpos.y = tracehitpos.y();
|
||||
outhitpos.z= tracehitpos.z();
|
||||
|
||||
// StartSolid test:
|
||||
{
|
||||
out->startSolid = false;
|
||||
//btCollisionObject collision;
|
||||
//collision.setCollisionShape(const_cast<btBoxShape* const>(&newshape) );
|
||||
|
||||
//CustomContactCallback crb;
|
||||
|
||||
//world.world->contactTest(&collision, crb);
|
||||
//out->startSolid = crb.hit;
|
||||
|
||||
// If outside and underground, we're solid
|
||||
if (!isInterior) //Check if we are interior
|
||||
{
|
||||
}
|
||||
|
||||
// If inside and out of the tree, we're solid
|
||||
else
|
||||
{
|
||||
btVector3 aabbMin, aabbMax;
|
||||
enginePass->broadphase->getBroadphaseAabb(aabbMin, aabbMax);
|
||||
//std::cout << "AABBMIN" << aabbMin.getX() <<"," <<aabbMin.getY() << "," << aabbMin.getZ() << "\n";
|
||||
//std::cout << "AABBMAX" << aabbMax.getX() <<"," <<aabbMax.getY() << "," << aabbMax.getZ() << "\n";
|
||||
//std::cout << "AABBMAX" << aabbMax << "\n";
|
||||
if (!TestPointAgainstAabb2(aabbMin, aabbMax, *(const btVector3* const)&(start) ) )
|
||||
{
|
||||
//We're solid
|
||||
//THIS NEEDS TO BE TURNED OFF IF WE WANT FALLING IN EXTERIORS TO WORK CORRECTLY!!!!!!!
|
||||
//out->startSolid = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const bool hasHit = newTraceCallback.hasHit();
|
||||
|
||||
|
||||
|
||||
|
||||
return hasHit;
|
||||
// Copy the hit data over to our trace results struct:
|
||||
if(newTraceCallback.hasHit())
|
||||
{
|
||||
const btVector3& tracehitnormal = newTraceCallback.m_hitNormalWorld;
|
||||
results->fraction = newTraceCallback.m_closestHitFraction;
|
||||
results->planenormal = Ogre::Vector3(tracehitnormal.x(), tracehitnormal.y(), tracehitnormal.z());
|
||||
results->endpos = (end-start)*results->fraction + start;
|
||||
}
|
||||
else
|
||||
{
|
||||
results->endpos = end;
|
||||
results->planenormal = Ogre::Vector3(0.0f, 0.0f, 1.0f);
|
||||
results->fraction = 1.0f;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,60 +1,26 @@
|
|||
#ifndef OENGINE_BULLET_TRACE_H
|
||||
#define OENGINE_BULLET_TRACE_H
|
||||
|
||||
|
||||
#include <btBulletDynamicsCommon.h>
|
||||
#include <btBulletCollisionCommon.h>
|
||||
#include <components/nifbullet/bullet_nif_loader.hpp>
|
||||
#include <openengine/bullet/physic.hpp>
|
||||
#include "pmove.h"
|
||||
#include <OgreVector3.h>
|
||||
|
||||
|
||||
enum traceWorldType
|
||||
namespace OEngine
|
||||
{
|
||||
collisionWorldTrace = 1,
|
||||
pickWorldTrace = 2,
|
||||
bothWorldTrace = collisionWorldTrace | pickWorldTrace
|
||||
};
|
||||
namespace Physic
|
||||
{
|
||||
class PhysicEngine;
|
||||
}
|
||||
}
|
||||
|
||||
enum collaborativePhysicsType
|
||||
{
|
||||
No_Physics = 0, // Both are empty (example: statics you can walk through, like tall grass)
|
||||
Only_Collision = 1, // This object only has collision physics but no pickup physics (example: statics)
|
||||
Only_Pickup = 2, // This object only has pickup physics but no collision physics (example: items dropped on the ground)
|
||||
Both_Physics = 3 // This object has both kinds of physics (example: activators)
|
||||
};
|
||||
|
||||
struct NewPhysTraceResults
|
||||
{
|
||||
Ogre::Vector3 endPos;
|
||||
Ogre::Vector3 hitNormal;
|
||||
float fraction;
|
||||
bool startSolid;
|
||||
//const Object* hitObj;
|
||||
};
|
||||
struct traceResults
|
||||
{
|
||||
Ogre::Vector3 endpos;
|
||||
Ogre::Vector3 planenormal;
|
||||
Ogre::Vector3 endpos;
|
||||
Ogre::Vector3 planenormal;
|
||||
|
||||
float fraction;
|
||||
|
||||
int surfaceFlags;
|
||||
int contents;
|
||||
int entityNum;
|
||||
|
||||
bool allsolid;
|
||||
bool startsolid;
|
||||
float fraction;
|
||||
};
|
||||
|
||||
|
||||
|
||||
template <const traceWorldType traceType>
|
||||
const bool NewPhysicsTrace(NewPhysTraceResults* const out, const Ogre::Vector3& start, const Ogre::Vector3& end, const Ogre::Vector3& BBExtents, const Ogre::Vector3& rotation, bool isInterior, OEngine::Physic::PhysicEngine* enginePass);
|
||||
//template const bool NewPhysicsTrace<collisionWorldTrace>(NewPhysTraceResults* const out, const Ogre::Vector3& start, const Ogre::Vector3& end, const Ogre::Vector3& BBExtents, const Ogre::Vector3& rotation, bool isInterior, OEngine::Physic::PhysicEngine* enginePass);
|
||||
//template const bool NewPhysicsTrace<pickWorldTrace>(NewPhysTraceResults* const out, const Ogre::Vector3& start, const Ogre::Vector3& end, const Ogre::Vector3& BBExtents, const Ogre::Vector3& rotation, bool isInterior, OEngine::Physic::PhysicEngine* enginePass);
|
||||
|
||||
void newtrace(traceResults* const results, const Ogre::Vector3& start, const Ogre::Vector3& end, const Ogre::Vector3& BBExtents, const float rotation, bool isInterior, OEngine::Physic::PhysicEngine* enginePass);
|
||||
|
||||
void newtrace(traceResults *results, const Ogre::Vector3& start, const Ogre::Vector3& end, const Ogre::Vector3& BBHalfExtents, bool isInterior, OEngine::Physic::PhysicEngine* enginePass);
|
||||
|
||||
#endif
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue