btFixedConstraint::btFixedConstraint(btRigidBody& rbA,btRigidBody& rbB, const btTransform& frameInA,const btTransform& frameInB)
:btTypedConstraint(FIXED_CONSTRAINT_TYPE,rbA,rbB)
{
m_pivotInA = frameInA.getOrigin();
m_pivotInB = frameInB.getOrigin();
m_relTargetAB = frameInA.getRotation()*frameInB.getRotation().inverse();
}
///getAabb's default implementation is brute force, expected derived classes to implement a fast dedicated version
void btEmptyShape::getAabb(const btTransform& t,btVector3& aabbMin,btVector3& aabbMax) const
{
btVector3 margin(getMargin(),getMargin(),getMargin());
aabbMin = t.getOrigin() - margin;
aabbMax = t.getOrigin() + margin;
}
void DebugDraw::drawSphere(btScalar radius, const btTransform& transform, const btVector3& color) {
sf::CircleShape circle(radius);
circle.setPosition(transform.getOrigin().x(), transform.getOrigin().y());
circle.setOrigin(radius, radius);
circle.setFillColor(sf::Color::Transparent);
circle.setOutlineColor(btToSfColor(color));
circle.setOutlineThickness(0.01f);
m_target->draw(circle);
}
Transform SWPhysics::toSWTransform(btTransform& o) {
Transform ret;
Vector3f trans(o.getOrigin().getX(), o.getOrigin().getY(), o.getOrigin().getZ());
Vector3f rot(o.getRotation().getX(), o.getRotation().getY(), o.getOrigin().getZ());
Vector3f scal(1);
ret.setTranslate(trans);
ret.setRotate(rot);
ret.setScale(scal);
return ret;
}
void btPersistentManifold::refreshContactPoints(const btTransform& trA,const btTransform& trB)
{
int i;
#ifdef DEBUG_PERSISTENCY
printf("refreshContactPoints posA = (%f,%f,%f) posB = (%f,%f,%f)\n",
trA.getOrigin().getX(),
trA.getOrigin().getY(),
trA.getOrigin().getZ(),
trB.getOrigin().getX(),
trB.getOrigin().getY(),
trB.getOrigin().getZ());
#endif //DEBUG_PERSISTENCY
/// first refresh worldspace positions and distance
for (i=getNumContacts()-1;i>=0;i--)
{
btManifoldPoint &manifoldPoint = m_pointCache[i];
manifoldPoint.m_positionWorldOnA = trA( manifoldPoint.m_localPointA );
manifoldPoint.m_positionWorldOnB = trB( manifoldPoint.m_localPointB );
manifoldPoint.m_distance1 = (manifoldPoint.m_positionWorldOnA - manifoldPoint.m_positionWorldOnB).dot(manifoldPoint.m_normalWorldOnB);
manifoldPoint.m_lifeTime++;
}
/// then
btScalar distance2d;
btVector3 projectedDifference,projectedPoint;
for (i=getNumContacts()-1;i>=0;i--)
{
btManifoldPoint &manifoldPoint = m_pointCache[i];
//contact becomes invalid when signed distance exceeds margin (projected on contactnormal direction)
if (!validContactDistance(manifoldPoint))
{
removeContactPoint(i);
} else
{
//contact also becomes invalid when relative movement orthogonal to normal exceeds margin
projectedPoint = manifoldPoint.m_positionWorldOnA - manifoldPoint.m_normalWorldOnB * manifoldPoint.m_distance1;
projectedDifference = manifoldPoint.m_positionWorldOnB - projectedPoint;
distance2d = projectedDifference.dot(projectedDifference);
if (distance2d > getContactBreakingThreshold()*getContactBreakingThreshold() )
{
removeContactPoint(i);
} else
{
//contact point processed callback
if (gContactProcessedCallback)
(*gContactProcessedCallback)(manifoldPoint,m_body0,m_body1);
}
}
}
#ifdef DEBUG_PERSISTENCY
DebugPersistency();
#endif //
}
static SIMD_FORCE_INLINE btScalar capsuleCapsuleDistance(
btVector3& normalOnB,
btVector3& pointOnB,
btScalar capsuleLengthA,
btScalar capsuleRadiusA,
btScalar capsuleLengthB,
btScalar capsuleRadiusB,
int capsuleAxisA,
int capsuleAxisB,
const btTransform& transformA,
const btTransform& transformB,
btScalar distanceThreshold)
{
btVector3 directionA = transformA.getBasis().getColumn(capsuleAxisA);
btVector3 translationA = transformA.getOrigin();
btVector3 directionB = transformB.getBasis().getColumn(capsuleAxisB);
btVector3 translationB = transformB.getOrigin();
// translation between centers
btVector3 translation = translationB - translationA;
// compute the closest points of the capsule line segments
btVector3 ptsVector; // the vector between the closest points
btVector3 offsetA, offsetB; // offsets from segment centers to their closest points
btScalar tA, tB; // parameters on line segment
segmentsClosestPoints(ptsVector, offsetA, offsetB, tA, tB, translation,
directionA, capsuleLengthA, directionB, capsuleLengthB);
btScalar distance = ptsVector.length() - capsuleRadiusA - capsuleRadiusB;
if (distance > distanceThreshold)
return distance;
btScalar lenSqr = ptsVector.length2();
if (lenSqr <= (SIMD_EPSILON * SIMD_EPSILON))
{
//degenerate case where 2 capsules are likely at the same location: take a vector tangential to 'directionA'
btVector3 q;
btPlaneSpace1(directionA, normalOnB, q);
}
else
{
// compute the contact normal
normalOnB = ptsVector * -btRecipSqrt(lenSqr);
}
pointOnB = transformB.getOrigin() + offsetB + normalOnB * capsuleRadiusB;
return distance;
}
void btSoftRigidDynamicsWorld::rayTestSingle(const btTransform& rayFromTrans, const btTransform& rayToTrans,
btCollisionObject* collisionObject,
const btCollisionShape* collisionShape,
const btTransform& colObjWorldTransform,
RayResultCallback& resultCallback)
{
if (collisionShape->isSoftBody())
{
btSoftBody* softBody = btSoftBody::upcast(collisionObject);
if (softBody)
{
btSoftBody::sRayCast softResult;
if (softBody->rayTest(rayFromTrans.getOrigin(), rayToTrans.getOrigin(), softResult))
{
if (softResult.fraction <= resultCallback.m_closestHitFraction)
{
btCollisionWorld::LocalShapeInfo shapeInfo;
shapeInfo.m_shapePart = 0;
shapeInfo.m_triangleIndex = softResult.index;
// get the normal
btVector3 rayDir = rayToTrans.getOrigin() - rayFromTrans.getOrigin();
btVector3 normal = -rayDir;
normal.normalize();
if (softResult.feature == btSoftBody::eFeature::Face)
{
normal = softBody->m_faces[softResult.index].m_normal;
if (normal.dot(rayDir) > 0)
{
// normal always point toward origin of the ray
normal = -normal;
}
}
btCollisionWorld::LocalRayResult rayResult(collisionObject,
&shapeInfo,
normal,
softResult.fraction);
bool normalInWorldSpace = true;
resultCallback.addSingleResult(rayResult, normalInWorldSpace);
}
}
}
}
else
{
btCollisionWorld::rayTestSingle(rayFromTrans, rayToTrans, collisionObject, collisionShape, colObjWorldTransform, resultCallback);
}
}
void convertBtTransform2Transform(btTransform bulletTransform, Transform *transform) {
btVector3 pos = bulletTransform.getOrigin();
btQuaternion rot = bulletTransform.getRotation();
transform->set_position(pos.getX(), pos.getY(), pos.getZ());
transform->set_rotation(rot.getW(), rot.getX(), rot.getY(), rot.getZ());
}
void btDiscreteDynamicsWorld::debugDrawSphere(btScalar radius, const btTransform& transform, const btVector3& color)
{
btVector3 start = transform.getOrigin();
const btVector3 xoffs = transform.getBasis() * btVector3(radius,0,0);
const btVector3 yoffs = transform.getBasis() * btVector3(0,radius,0);
const btVector3 zoffs = transform.getBasis() * btVector3(0,0,radius);
// XY
getDebugDrawer()->drawLine(start-xoffs, start+yoffs, color);
getDebugDrawer()->drawLine(start+yoffs, start+xoffs, color);
getDebugDrawer()->drawLine(start+xoffs, start-yoffs, color);
getDebugDrawer()->drawLine(start-yoffs, start-xoffs, color);
// XZ
getDebugDrawer()->drawLine(start-xoffs, start+zoffs, color);
getDebugDrawer()->drawLine(start+zoffs, start+xoffs, color);
getDebugDrawer()->drawLine(start+xoffs, start-zoffs, color);
getDebugDrawer()->drawLine(start-zoffs, start-xoffs, color);
// YZ
getDebugDrawer()->drawLine(start-yoffs, start+zoffs, color);
getDebugDrawer()->drawLine(start+zoffs, start+yoffs, color);
getDebugDrawer()->drawLine(start+yoffs, start-zoffs, color);
getDebugDrawer()->drawLine(start-zoffs, start-yoffs, color);
}
void RigidBody::setWorldTransform(const btTransform& worldTrans)
{
Quaternion newWorldRotation = ToQuaternion(worldTrans.getRotation());
Vector3 newWorldPosition = ToVector3(worldTrans.getOrigin()) - newWorldRotation * centerOfMass_;
RigidBody* parentRigidBody = 0;
// It is possible that the RigidBody component has been kept alive via a shared pointer,
// while its scene node has already been destroyed
if (node_)
{
// If the rigid body is parented to another rigid body, can not set the transform immediately.
// In that case store it to PhysicsWorld for delayed assignment
Node* parent = node_->GetParent();
if (parent != GetScene() && parent)
parentRigidBody = parent->GetComponent<RigidBody>();
if (!parentRigidBody)
ApplyWorldTransform(newWorldPosition, newWorldRotation);
else
{
DelayedWorldTransform delayed;
delayed.rigidBody_ = this;
delayed.parentRigidBody_ = parentRigidBody;
delayed.worldPosition_ = newWorldPosition;
delayed.worldRotation_ = newWorldRotation;
physicsWorld_->AddDelayedWorldTransform(delayed);
}
MarkNetworkUpdate();
}
}
CIwFMat Physics::GetMatrixFromWheelInfo( const btWheelInfo w, const btRigidBody* b )
{
CIwFMat modelMatrix( CIwMat::g_Identity );
const btTransform btTrans = w.m_worldTransform;
const btVector3 pos = btTrans.getOrigin();
const float posX = pos.getX();
const float posY = pos.getY();
const float posZ = pos.getZ();
const CIwFVec3 position( posX, posY, posZ );
const btQuaternion q = btTrans.getRotation();
CIwFVec3 rot;
QuaternionToEuler( q, rot );
const btQuaternion qBody = b->getOrientation();
CIwFVec3 rotBody;
QuaternionToEuler( qBody, rotBody );
CIwFMat mat = CIwFMat::g_Identity;
mat.PostRotateX( rot.x );
mat.PostRotateY( -rotBody.y ); // mat.PostRotateY( rot.y ); fix for rotating wheels by y axis, there are glitches after 360 degrees rotating
mat.PostRotateZ( -rotBody.z );
modelMatrix.CopyRot( mat );
modelMatrix.SetTrans( position );
return modelMatrix;
}
void LIPhyDynamicsWorld::sphereSweepTest (float radius, const btTransform& rayFromWorld, const btTransform& rayToWorld, ConvexResultCallback& resultCallback) const
{
LIPhyRaycastHook* hook;
/* Test against normal objects. */
btSphereShape shape (radius);
convexSweepTest (&shape, rayFromWorld, rayToWorld, resultCallback);
/* Test against raycast hooks. */
btVector3 src = rayFromWorld.getOrigin();
btVector3 dst = rayToWorld.getOrigin();
for (hook = raycast_hooks ; hook != NULL ; hook = hook->next)
{
hook->sphereSweepTest (radius, src, dst, resultCallback);
}
}
virtual void setWorldTransform(const btTransform &worldTrans) {
if(NULL == mVisibleobj) return; // silently return before we set a node
btQuaternion rot = worldTrans.getRotation();
mVisibleobj->setOrientation(rot.w(), rot.x(), rot.y(), rot.z());
btVector3 pos = worldTrans.getOrigin();
mVisibleobj->setPosition(pos.x(), pos.y()+5, pos.z()-5);
}
void EntityMotionState::setWorldTransform(const btTransform &worldTrans) {
btQuaternion rot = worldTrans.getRotation();
m_entity->setRotation(rot.getAngle() * rot.getAxis().z());
btVector3 pos = worldTrans.getOrigin();
m_entity->setPosition(glm::vec2(pos.x(), pos.y()));
m_transform = worldTrans;
}
void BulletRigidBodyObject::updateObjectFromBullet(const btTransform& worldTrans) {
assert(mFixed == false);
LocationInfo& locinfo = mParent->info(mID);
btVector3 pos = worldTrans.getOrigin();
btVector3 vel = mObjRigidBody->getLinearVelocity();
TimedMotionVector3f newLocation(mParent->context()->simTime(), MotionVector3f(Vector3f(pos.x(), pos.y(), pos.z()), Vector3f(vel.x(), vel.y(), vel.z())));
mParent->setLocation(mID, newLocation);
BULLETLOG(insane, "Updating " << mID << " to velocity " << vel.x() << " " << vel.y() << " " << vel.z());
btQuaternion rot = worldTrans.getRotation();
btVector3 angvel = mObjRigidBody->getAngularVelocity();
Vector3f angvel_siri(angvel.x(), angvel.y(), angvel.z());
float angvel_angle = angvel_siri.normalizeThis();
TimedMotionQuaternion newOrientation(
mParent->context()->simTime(),
MotionQuaternion(
Quaternion(rot.x(), rot.y(), rot.z(), rot.w()),
Quaternion(angvel_siri, angvel_angle)
)
);
mParent->setOrientation(mID, newOrientation);
mParent->addUpdate(mID);
}
void EntityMotionState::setWorldTransform(const btTransform &worldTrans) {
btQuaternion rot = worldTrans.getRotation();
m_Entity->rotation = rot.getAngle() * (180.f/M_PI) * rot.getAxis().z();
btVector3 pos = worldTrans.getOrigin();
m_Entity->position = pos;
m_Transform = worldTrans;
}
// This callback is invoked by the physics simulation at the end of each simulation step...
// iff the corresponding RigidBody is DYNAMIC and has moved.
void EntityMotionState::setWorldTransform(const btTransform& worldTrans) {
if (!_entity) {
return;
}
measureBodyAcceleration();
_entity->setPosition(bulletToGLM(worldTrans.getOrigin()) + ObjectMotionState::getWorldOffset());
_entity->setRotation(bulletToGLM(worldTrans.getRotation()));
_entity->setVelocity(getBodyLinearVelocity());
_entity->setAngularVelocity(getBodyAngularVelocity());
_entity->setLastSimulated(usecTimestampNow());
if (_entity->getSimulatorID().isNull()) {
_loopsWithoutOwner++;
const uint32_t OWNERSHIP_BID_DELAY = 50;
if (_loopsWithoutOwner > OWNERSHIP_BID_DELAY) {
//qDebug() << "Warning -- claiming something I saw moving." << getName();
_candidateForOwnership = true;
}
} else {
_loopsWithoutOwner = 0;
}
#ifdef WANT_DEBUG
quint64 now = usecTimestampNow();
qCDebug(physics) << "EntityMotionState::setWorldTransform()... changed entity:" << _entity->getEntityItemID();
qCDebug(physics) << " last edited:" << _entity->getLastEdited() << formatUsecTime(now - _entity->getLastEdited()) << "ago";
qCDebug(physics) << " last simulated:" << _entity->getLastSimulated() << formatUsecTime(now - _entity->getLastSimulated()) << "ago";
qCDebug(physics) << " last updated:" << _entity->getLastUpdated() << formatUsecTime(now - _entity->getLastUpdated()) << "ago";
#endif
}
//broken due to scaling
void btSphereShape::getAabb(const btTransform& t,btVector3& aabbMin,btVector3& aabbMax) const
{
const btVector3& center = t.getOrigin();
btVector3 extent(getMargin(),getMargin(),getMargin());
aabbMin = center - extent;
aabbMax = center + extent;
}
void position_and_orientation_from_transform(glm::vec3& out_position, glm::quat& out_orientation, const btTransform& world_transform)
{
const btVector3& origin = world_transform.getOrigin();
const btQuaternion& rot = world_transform.getRotation();
out_position = glm::vec3(origin.x(), origin.y(), origin.z());
out_orientation = glm::quat(rot.w(), rot.x(), rot.y(), rot.z());
}
/// btMotionState override. Called when Bullet wants to tell us the body's current transform
void setWorldTransform(const btTransform &worldTrans)
{
/// \todo For a large scene, applying the changed transforms of rigid bodies is slow (slower than the physics simulation itself,
/// or handling collisions) due to the large number of signals being fired.
// Cannot modify server-authoritative physics object, rather get the transform changes through placeable attributes
const bool hasAuthority = rigidBody->HasAuthority();
if (!hasAuthority && !clientExtrapolating)
return;
if (placeable.Expired())
return;
Placeable* p = placeable;
// Important: disconnect our own response to attribute changes to not create an endless loop!
disconnected = true;
AttributeChange::Type changeType = hasAuthority ? AttributeChange::Default : AttributeChange::LocalOnly;
// Set transform
float3 position = worldTrans.getOrigin();
Quat orientation = worldTrans.getRotation();
// Non-parented case
if (p->parentRef.Get().IsEmpty())
{
Transform newTrans = p->transform.Get();
newTrans.SetPos(position.x, position.y, position.z);
newTrans.SetOrientation(orientation);
p->transform.Set(newTrans, changeType);
}
else
// The placeable has a parent itself
{
Urho3D::Node* parent = p->UrhoSceneNode()->GetParent();
if (parent)
{
position = parent->WorldToLocal(position);
orientation = parent->GetWorldRotation().Inverse() * orientation;
Transform newTrans = p->transform.Get();
newTrans.SetPos(position);
newTrans.SetOrientation(orientation);
p->transform.Set(newTrans, changeType);
}
}
// Set linear & angular velocity
if (body)
{
// Performance optimization: because applying each attribute causes signals to be fired, which is slow in a large scene
// (and furthermore, on a server, causes each connection's sync state to be accessed), do not set the linear/angular
// velocities if they haven't changed
float3 linearVel = body->getLinearVelocity();
float3 angularVel = RadToDeg(body->getAngularVelocity());
if (!linearVel.Equals(rigidBody->linearVelocity.Get()))
rigidBody->linearVelocity.Set(linearVel, changeType);
if (!angularVel.Equals(rigidBody->angularVelocity.Get()))
rigidBody->angularVelocity.Set(angularVel, changeType);
}
disconnected = false;
}
void get_plane_equation_transformed(const btTransform & trans,btVector4 &equation)
{
equation[0] = trans.getBasis().getRow(0).dot(m_planeNormal);
equation[1] = trans.getBasis().getRow(1).dot(m_planeNormal);
equation[2] = trans.getBasis().getRow(2).dot(m_planeNormal);
equation[3] = trans.getOrigin().dot(m_planeNormal) + m_planeConstant;
}
// This callback is invoked by the physics simulation at the end of each simulation step...
// iff the corresponding RigidBody is DYNAMIC and has moved.
void EntityMotionState::setWorldTransform(const btTransform& worldTrans) {
if (!_entity) {
return;
}
assert(entityTreeIsLocked());
measureBodyAcceleration();
_entity->setPosition(bulletToGLM(worldTrans.getOrigin()) + ObjectMotionState::getWorldOffset());
_entity->setRotation(bulletToGLM(worldTrans.getRotation()));
_entity->setVelocity(getBodyLinearVelocity());
_entity->setAngularVelocity(getBodyAngularVelocity());
_entity->setLastSimulated(usecTimestampNow());
if (_entity->getSimulatorID().isNull()) {
_loopsWithoutOwner++;
if (_loopsWithoutOwner > LOOPS_FOR_SIMULATION_ORPHAN && usecTimestampNow() > _nextOwnershipBid) {
//qDebug() << "Warning -- claiming something I saw moving." << getName();
setOutgoingPriority(VOLUNTEER_SIMULATION_PRIORITY);
}
}
#ifdef WANT_DEBUG
quint64 now = usecTimestampNow();
qCDebug(physics) << "EntityMotionState::setWorldTransform()... changed entity:" << _entity->getEntityItemID();
qCDebug(physics) << " last edited:" << _entity->getLastEdited()
<< formatUsecTime(now - _entity->getLastEdited()) << "ago";
qCDebug(physics) << " last simulated:" << _entity->getLastSimulated()
<< formatUsecTime(now - _entity->getLastSimulated()) << "ago";
qCDebug(physics) << " last updated:" << _entity->getLastUpdated()
<< formatUsecTime(now - _entity->getLastUpdated()) << "ago";
#endif
}
// virtual
void AvatarMotionState::setWorldTransform(const btTransform& worldTrans) {
const float SPRING_TIMESCALE = 0.5f;
float tau = PHYSICS_ENGINE_FIXED_SUBSTEP / SPRING_TIMESCALE;
btVector3 currentPosition = worldTrans.getOrigin();
btVector3 offsetToTarget = glmToBullet(getObjectPosition()) - currentPosition;
float distance = offsetToTarget.length();
if ((1.0f - tau) * distance > _diameter) {
// the avatar body is far from its target --> slam position
btTransform newTransform;
newTransform.setOrigin(currentPosition + offsetToTarget);
newTransform.setRotation(glmToBullet(getObjectRotation()));
_body->setWorldTransform(newTransform);
_body->setLinearVelocity(glmToBullet(getObjectLinearVelocity()));
_body->setAngularVelocity(glmToBullet(getObjectAngularVelocity()));
} else {
// the avatar body is near its target --> slam velocity
btVector3 velocity = glmToBullet(getObjectLinearVelocity()) + (1.0f / SPRING_TIMESCALE) * offsetToTarget;
_body->setLinearVelocity(velocity);
_body->setAngularVelocity(glmToBullet(getObjectAngularVelocity()));
// slam its rotation
btTransform newTransform = worldTrans;
newTransform.setRotation(glmToBullet(getObjectRotation()));
_body->setWorldTransform(newTransform);
}
}
void Body::Update(float dt, btTransform& Parent)
{
btVector3 parentPos;
parentPos = Parent.getOrigin();
//Get Offset Rotation of a model(child)
btQuaternion LocalRot;
LocalRot = btQuaternion(m_yaw, m_pitch, m_roll);
btQuaternion parentRotation;
parentRotation = Parent.getRotation();
//Construct Directx Matricies out of give Quaternion rotations, sets up proper transformation of a model, Global + local
XMMATRIX matrixChildRotation = XMMatrixRotationQuaternion(XMLoadFloat4(&XMFLOAT4(LocalRot.getX(), LocalRot.getY(), LocalRot.getZ(), LocalRot.getW())));
XMMATRIX matrixParentRotation = XMMatrixRotationQuaternion(XMLoadFloat4(&XMFLOAT4(parentRotation.getX(), parentRotation.getY(), parentRotation.getZ(), parentRotation.getW())));
//calcualte the final rotation by multiplying quaternions using dxmatrix
XMMATRIX matrixFinalRotation = matrixChildRotation * matrixParentRotation;
XMFLOAT3 m_offset = XMFLOAT3(0, 0, 0);
XMMATRIX childOffset = XMMatrixTranslation(m_offset.x, m_offset.y, m_offset.z);
XMMATRIX zeroWorld = XMMatrixTranslation(0, 0, 0);
XMMATRIX translationMat = XMMatrixTranslation(parentPos.getX(), parentPos.getY(), parentPos.getZ());
XMMATRIX scaleMat = XMMatrixScaling(m_scale, m_scale, m_scale);
XMMATRIX worldMat = childOffset * matrixFinalRotation * zeroWorld * scaleMat * translationMat;
XMStoreFloat4x4(&m_worldMat, worldMat);
}
void bmodMotionState::setWorldTransform(const btTransform &worldTrans) {
//don't affect immovable objects
if(obj->getRigidBody()->isStaticOrKinematicObject())
return;
Vector origin = Vector((float*)(worldTrans.getOrigin().m_floats));
btVector3 btAngles;
MatrixEuler(worldTrans.getBasis(), btAngles);
Vector angles = Vector((float*)btAngles.m_floats);
btRigidBody * body = obj->getRigidBody();
Vector velocity;
Vector avelocity;
if(!body->getDeactivationTime()) {
velocity = Vector((float*)body->getLinearVelocity().m_floats);
btVector3 btAvelocity = body->getAngularVelocity();
avelocity = Vector(-btAvelocity[1], btAvelocity[2], btAvelocity[0]) * SIMD_DEGS_PER_RAD;
}
std::list<int> * entities = obj->getEntities();
for(std::list<int>::iterator it = entities->begin(); it != entities->end(); ++it) {
edict_t * entity = INDEXENT(*it);
SET_ORIGIN(entity, origin);
entity->v.angles = angles;
entity->v.velocity = velocity;
entity->v.avelocity = avelocity;
}
}
Matrix cast(const btTransform& t){
return Matrix(
Axes(
cast(t.getBasis().getColumn(0)),
cast(t.getBasis().getColumn(1)),
cast(t.getBasis().getColumn(2))),
cast(t.getOrigin()));
}
void CBaseGameEntity::setGraphicTrans(btTransform trans)
{
btVector3 v = trans.getOrigin();
m_node->setPosition(v.getX(), v.getY(), v.getZ());
btQuaternion q = trans.getRotation();
m_node->setOrientation(q.w(), q.x(), q.y(), q.z());
}
void MyMotionState::setWorldTransform(const btTransform &xWorldTrans)
{
if(NULL == mSceneNode) return; // silently return before we set a node
btQuaternion xRot = xWorldTrans.getRotation();
mSceneNode->setOrientation(xRot.w(), xRot.x(), xRot.y(), xRot.z());
btVector3 xPos = xWorldTrans.getOrigin();
mSceneNode->setPosition(xPos.x(), xPos.y(), xPos.z());
}
virtual void setWorldTransform(const btTransform &worldTrans) {
if(NULL == mVisibleobj) return; // silently return before we SET a node
btQuaternion rot = worldTrans.getRotation();
mVisibleobj->setOrientation(rot.w(), rot.x(), rot.y(), rot.z());
btVector3 pos = worldTrans.getOrigin();
// TODO **** XXX need to fix this up such that it renders properly since this doesnt know the scale of the node
// also the getCube function returns a cube that isnt centered on Z
mVisibleobj->setPosition(pos.x(), pos.y()+5, pos.z()-5);
}
/** set the world transform of the linked position
* @param worldTrans the transform to set the position to
* @warning this method is called by physics library and should
* not be called directly
*/
void MotionState::setWorldTransform (const btTransform &worldTrans)
{
// set the location/origin
const btVector3& location = worldTrans.getOrigin();
this->position->getLocation().set(location.getX(), location.getY(), location.getZ());
// set the basis/rotational matrix
this->position->setRowMajorRotationMatrix(worldTrans.getBasis());
}
