Vector CPhysicsObject::GetMassCenterLocalSpace() const {
btTransform bullTransform = ((btMassCenterMotionState *)m_pObject->getMotionState())->m_centerOfMassOffset;
Vector HLMassCenter;
ConvertPosToHL(bullTransform.getOrigin(), HLMassCenter);
return HLMassCenter;
}
void CPhysicsObject::GetPosition(Vector *worldPosition, QAngle *angles) const {
if (!worldPosition && !angles) return;
btTransform transform = m_pObject->getWorldTransform() * ((btMassCenterMotionState *)m_pObject->getMotionState())->m_centerOfMassOffset.inverse();
if (worldPosition) ConvertPosToHL(transform.getOrigin(), *worldPosition);
if (angles) ConvertRotationToHL(transform.getBasis(), *angles);
}
void CPlayerController::GetShadowVelocity(Vector *velocity) {
if (!velocity) return;
//btRigidBody *body = m_pObject->GetObject();
//ConvertPosToHL(body->getLinearVelocity(), *velocity);
ConvertPosToHL(m_linVelocity, *velocity);
}
// Basically get the last inputs to IPhysicsShadowController::Update(), returns last input to timeOffset in Update()
float CShadowController::GetTargetPosition(Vector *pPositionOut, QAngle *pAnglesOut) {
if (pPositionOut)
ConvertPosToHL(m_shadow.targetPosition, *pPositionOut);
if (pAnglesOut)
ConvertRotationToHL(m_shadow.targetRotation, *pAnglesOut);
return m_timeOffset;
}
// This function is a silly hack, games should be using the friction snapshot instead.
bool CPhysicsObject::GetContactPoint(Vector *contactPoint, IPhysicsObject **contactObject) const {
if (!contactPoint && !contactObject) return false;
int numManifolds = m_pEnv->GetBulletEnvironment()->getDispatcher()->getNumManifolds();
for (int i = 0; i < numManifolds; i++) {
btPersistentManifold *contactManifold = m_pEnv->GetBulletEnvironment()->getDispatcher()->getManifoldByIndexInternal(i);
const btCollisionObject *obA = contactManifold->getBody0();
const btCollisionObject *obB = contactManifold->getBody1();
if (contactManifold->getNumContacts() <= 0)
continue;
// Interface specifies this function as a hack - return any point of contact.
btManifoldPoint bullContactPoint = contactManifold->getContactPoint(0);
if (obA == m_pObject) {
btVector3 bullContactVec = bullContactPoint.getPositionWorldOnA();
if (contactPoint) {
ConvertPosToHL(bullContactVec, *contactPoint);
}
if (contactObject) {
*contactObject = (IPhysicsObject *)obB->getUserPointer();
}
return true;
} else if (obB == m_pObject) {
btVector3 bullContactVec = bullContactPoint.getPositionWorldOnB();
if (contactPoint) {
ConvertPosToHL(bullContactVec, *contactPoint);
}
if (contactObject) {
*contactObject = (IPhysicsObject *)obA->getUserPointer();
}
return true;
}
}
return false; // Bool in contact
}
void CPhysicsObject::OutputDebugInfo() const {
Msg("-----------------\n");
if (m_pName)
Msg("Object: %s\n", m_pName);
Msg("Mass: %f (inv %f)\n", GetMass(), GetInvMass());
Vector pos;
QAngle ang;
GetPosition(&pos, &ang);
Msg("Position: %f %f %f\nAngle: %f %f %f\n", pos.x, pos.y, pos.z, ang.x, ang.y, ang.z);
Vector inertia = GetInertia();
Vector invinertia = GetInvInertia();
Msg("Inertia: %f %f %f (inv %f %f %f)\n", inertia.x, inertia.y, inertia.z, invinertia.x, invinertia.y, invinertia.z);
Vector vel;
AngularImpulse angvel;
GetVelocity(&vel, &angvel);
Msg("Velocity: %f, %f, %f\nAng Velocity: %f, %f, %f\n", vel.x, vel.y, vel.z, angvel.x, angvel.y, angvel.z);
float dampspeed, damprot;
GetDamping(&dampspeed, &damprot);
Msg("Damping %f linear, %f angular\n", dampspeed, damprot);
Vector dragBasis;
Vector angDragBasis;
ConvertPosToHL(m_dragBasis, dragBasis);
ConvertDirectionToHL(m_angDragBasis, angDragBasis);
Msg("Linear Drag: %f, %f, %f (factor %f)\n", dragBasis.x, dragBasis.y, dragBasis.z, m_dragCoefficient);
Msg("Angular Drag: %f, %f, %f (factor %f)\n", angDragBasis.x, angDragBasis.y, angDragBasis.z, m_angDragCoefficient);
// TODO: Attached to x controllers
Msg("State: %s, Collision %s, Motion %s, Drag %s, Flags %04X (game %04x, index %d)\n",
IsAsleep() ? "Asleep" : "Awake",
IsCollisionEnabled() ? "Enabled" : "Disabled",
IsStatic() ? "Static" : IsMotionEnabled() ? "Enabled" : "Disabled",
IsDragEnabled() ? "Enabled" : "Disabled",
m_pObject->getFlags(),
GetGameFlags(),
GetGameIndex()
);
const char *pMaterialStr = g_SurfaceDatabase.GetPropName(m_materialIndex);
surfacedata_t *surfaceData = g_SurfaceDatabase.GetSurfaceData(m_materialIndex);
if (surfaceData) {
Msg("Material: %s : density(%f), thickness(%f), friction(%f), elasticity(%f)\n",
pMaterialStr, surfaceData->physics.density, surfaceData->physics.thickness, surfaceData->physics.friction, surfaceData->physics.elasticity);
}
Msg("-- COLLISION SHAPE INFO --\n");
g_PhysicsCollision.OutputDebugInfo((CPhysCollide *)m_pObject->getCollisionShape()->getUserPointer());
}
int CPlayerController::GetShadowPosition(Vector *position, QAngle *angles) {
btRigidBody *pObject = m_pObject->GetObject();
btTransform transform;
((btMassCenterMotionState *)pObject->getMotionState())->getGraphicTransform(transform);
if (position) ConvertPosToHL(transform.getOrigin(), *position);
if (angles) ConvertRotationToHL(transform.getBasis(), *angles);
// Yep. We're returning a variable totally unrelated to the shadow's position.
return m_ticksSinceUpdate;
}
void CPhysicsObject::GetVelocityAtPoint(const Vector &worldPosition, Vector *pVelocity) const {
if (!pVelocity) return;
Vector localPos;
WorldToLocal(&localPos, worldPosition);
btVector3 vec;
ConvertPosToBull(localPos, vec);
ConvertPosToHL(m_pObject->getVelocityInLocalPoint(vec), *pVelocity);
}
void ConvertMatrixToHL(const btTransform& transform, matrix3x4_t& hl) {
Vector forward, left, up, pos;
ConvertDirectionToHL(transform.getBasis().getColumn(0), forward);
ConvertDirectionToHL(-transform.getBasis().getColumn(2), left);
ConvertDirectionToHL(transform.getBasis().getColumn(1), up);
ConvertPosToHL(transform.getOrigin(), pos);
hl.Init(forward, left, up, pos);
}
int CPhysicsObject::GetShadowPosition(Vector* position, QAngle* angles) const {
btTransform transform;
((btMassCenterMotionState*)m_pObject->getMotionState())->getGraphicTransform(transform);
if (position) {
ConvertPosToHL(transform.getOrigin(), *position);
}
if (angles) {
ConvertRotationToHL(transform.getBasis(), *angles);
}
return 0;
}
void CPhysicsObject::GetImplicitVelocity(Vector *velocity, AngularImpulse *angularVelocity) const {
if (!velocity && !angularVelocity) return;
// gets the velocity actually moved by the object in the last simulation update
btTransform frameMotion = m_pObject->getWorldTransform().inverse() * m_pObject->getInterpolationWorldTransform();
if (velocity)
ConvertPosToHL(frameMotion.getOrigin(), *velocity);
if (angularVelocity)
ConvertAngularImpulseToHL(frameMotion.getRotation().getAxis() * frameMotion.getRotation().getAngle(), *angularVelocity);
}
void CPhysicsObject::GetVelocity(Vector *velocity, AngularImpulse *angularVelocity) const {
if (!velocity && !angularVelocity) return;
if (velocity)
ConvertPosToHL(m_pObject->getLinearVelocity(), *velocity);
// Angular velocity is supplied in local space.
if (angularVelocity) {
btVector3 angVel = m_pObject->getAngularVelocity();
angVel = m_pObject->getWorldTransform().getBasis().transpose() * angVel;
ConvertAngularImpulseToHL(angVel, *angularVelocity);
}
}
bool CPlayerController::TryTeleportObject() {
if (m_handler) {
Vector hlPosition;
ConvertPosToHL(m_targetPosition, hlPosition);
if (!m_handler->ShouldMoveTo(m_pObject, hlPosition)) return false;
}
btRigidBody *body = m_pObject->GetObject();
btTransform trans = body->getWorldTransform();
trans.setOrigin(m_targetPosition);
body->setWorldTransform(trans * ((btMassCenterMotionState *)body->getMotionState())->m_centerOfMassOffset);
((btMassCenterMotionState *)body->getMotionState())->setGraphicTransform(trans);
return true;
}
int CPhysicsObject::GetShadowPosition(Vector *position, QAngle *angles) const {
// Valve vphysics just interpolates current position to next PSI
if (!position && !angles) return m_pEnv->GetNumSubSteps();
btTransform transform;
((btMassCenterMotionState *)m_pObject->getMotionState())->getGraphicTransform(transform);
float deltaTime = m_pEnv->GetSubStepTime();
btTransformUtil::integrateTransform(transform, m_pObject->getLinearVelocity(), m_pObject->getAngularVelocity(), deltaTime, transform);
if (position)
ConvertPosToHL(transform.getOrigin(), *position);
if (angles)
ConvertRotationToHL(transform.getBasis(), *angles);
// Simulated PSIs
return m_pEnv->GetNumSubSteps();
}
void CPhysicsObject::GetPosition(Vector* worldPosition, QAngle* angles) const {
btTransform transform;
((btMassCenterMotionState*)m_pObject->getMotionState())->getGraphicTransform(transform);
if (worldPosition) ConvertPosToHL(transform.getOrigin(), *worldPosition);
if (angles) ConvertRotationToHL(transform.getBasis(), *angles);
}
void CPhysicsObject::GetVelocity(Vector* velocity, AngularImpulse* angularVelocity) const {
if (velocity) ConvertPosToHL(m_pObject->getLinearVelocity(), *velocity);
if (angularVelocity) ConvertAngularImpulseToHL(m_pObject->getAngularVelocity(), *angularVelocity);
}
void CPhysicsEnvironment::GetGravity(Vector *pGravityVector) const {
if (!pGravityVector) return;
btVector3 temp = m_pBulletEnvironment->getGravity();
ConvertPosToHL(temp, *pGravityVector);
}
CPhysicsCollisionData(btManifoldPoint *manPoint) {
ConvertDirectionToHL(manPoint->m_normalWorldOnB, m_surfaceNormal);
ConvertPosToHL(manPoint->getPositionWorldOnA(), m_contactPoint);
ConvertPosToHL(manPoint->m_lateralFrictionDir1, m_contactSpeed); // FIXME: Need the correct variable from the manifold point
}
void CPhysicsFrictionSnapshot::GetSurfaceNormal(Vector &out) {
btManifoldPoint bullManifoldPoint = m_manifolds[m_iCurManifold]->getContactPoint(m_iCurContactPoint);
ConvertPosToHL(bullManifoldPoint.m_normalWorldOnB, out);
}
void CPhysicsFrictionSnapshot::GetContactPoint(Vector &out) {
btManifoldPoint bullManifoldPoint = m_manifolds[m_iCurManifold]->getContactPoint(m_iCurContactPoint);
btVector3 bullPos = bullManifoldPoint.getPositionWorldOnA(); // TODO: A or B?
ConvertPosToHL(bullPos, out);
}
void CPhysicsObject::GetVelocityAtPoint(const Vector& worldPosition, Vector* pVelocity) const {
btVector3 vec;
ConvertPosToBull(worldPosition, vec);
ConvertPosToHL(m_pObject->getVelocityInLocalPoint(vec), *pVelocity);
}
Vector CPhysicsObject::GetLocalGravity() const {
Vector tmp;
ConvertPosToHL(m_pObject->getGravity(), tmp);
return tmp;
}
