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; }