[DEV] rename member of function ==> OK
This commit is contained in:
parent
64da8e8c51
commit
c58ef697ce
@ -20,13 +20,13 @@ using namespace reactphysics3d;
|
||||
* @param id The ID of the body
|
||||
*/
|
||||
RigidBody::RigidBody(const Transform& transform, CollisionWorld& world, bodyindex id)
|
||||
: CollisionBody(transform, world, id), mInitMass(float(1.0)),
|
||||
mCenterOfMassLocal(0, 0, 0), mCenterOfMassWorld(transform.getPosition()),
|
||||
m_isGravityEnabled(true), mLinearDamping(float(0.0)), mAngularDamping(float(0.0)),
|
||||
: CollisionBody(transform, world, id), m_initMass(float(1.0)),
|
||||
m_centerOfMassLocal(0, 0, 0), m_centerOfMassWorld(transform.getPosition()),
|
||||
m_isGravityEnabled(true), m_linearDamping(float(0.0)), m_angularDamping(float(0.0)),
|
||||
m_jointsList(NULL) {
|
||||
|
||||
// Compute the inverse mass
|
||||
m_massInverse = float(1.0) / mInitMass;
|
||||
m_massInverse = float(1.0) / m_initMass;
|
||||
}
|
||||
|
||||
// Destructor
|
||||
@ -60,8 +60,8 @@ void RigidBody::setType(BodyType type) {
|
||||
if (m_type == STATIC) {
|
||||
|
||||
// Reset the velocity to zero
|
||||
mLinearVelocity.setToZero();
|
||||
mAngularVelocity.setToZero();
|
||||
m_linearVelocity.setToZero();
|
||||
m_angularVelocity.setToZero();
|
||||
}
|
||||
|
||||
// If it is a static or a kinematic body
|
||||
@ -69,13 +69,13 @@ void RigidBody::setType(BodyType type) {
|
||||
|
||||
// Reset the inverse mass and inverse inertia tensor to zero
|
||||
m_massInverse = float(0.0);
|
||||
mInertiaTensorLocal.setToZero();
|
||||
mInertiaTensorLocalInverse.setToZero();
|
||||
m_inertiaTensorLocal.setToZero();
|
||||
m_inertiaTensorLocalInverse.setToZero();
|
||||
|
||||
}
|
||||
else { // If it is a dynamic body
|
||||
m_massInverse = float(1.0) / mInitMass;
|
||||
mInertiaTensorLocalInverse = mInertiaTensorLocal.getInverse();
|
||||
m_massInverse = float(1.0) / m_initMass;
|
||||
m_inertiaTensorLocalInverse = m_inertiaTensorLocal.getInverse();
|
||||
}
|
||||
|
||||
// Awake the body
|
||||
@ -89,8 +89,8 @@ void RigidBody::setType(BodyType type) {
|
||||
askForBroadPhaseCollisionCheck();
|
||||
|
||||
// Reset the force and torque on the body
|
||||
mExternalForce.setToZero();
|
||||
mExternalTorque.setToZero();
|
||||
m_externalForce.setToZero();
|
||||
m_externalTorque.setToZero();
|
||||
}
|
||||
|
||||
// Set the local inertia tensor of the body (in local-space coordinates)
|
||||
@ -102,10 +102,10 @@ void RigidBody::setInertiaTensorLocal(const Matrix3x3& inertiaTensorLocal) {
|
||||
|
||||
if (m_type != DYNAMIC) return;
|
||||
|
||||
mInertiaTensorLocal = inertiaTensorLocal;
|
||||
m_inertiaTensorLocal = inertiaTensorLocal;
|
||||
|
||||
// Compute the inverse local inertia tensor
|
||||
mInertiaTensorLocalInverse = mInertiaTensorLocal.getInverse();
|
||||
m_inertiaTensorLocalInverse = m_inertiaTensorLocal.getInverse();
|
||||
}
|
||||
|
||||
// Set the local center of mass of the body (in local-space coordinates)
|
||||
@ -117,14 +117,14 @@ void RigidBody::setCenterOfMassLocal(const Vector3& centerOfMassLocal) {
|
||||
|
||||
if (m_type != DYNAMIC) return;
|
||||
|
||||
const Vector3 oldCenterOfMass = mCenterOfMassWorld;
|
||||
mCenterOfMassLocal = centerOfMassLocal;
|
||||
const Vector3 oldCenterOfMass = m_centerOfMassWorld;
|
||||
m_centerOfMassLocal = centerOfMassLocal;
|
||||
|
||||
// Compute the center of mass in world-space coordinates
|
||||
mCenterOfMassWorld = m_transform * mCenterOfMassLocal;
|
||||
m_centerOfMassWorld = m_transform * m_centerOfMassLocal;
|
||||
|
||||
// Update the linear velocity of the center of mass
|
||||
mLinearVelocity += mAngularVelocity.cross(mCenterOfMassWorld - oldCenterOfMass);
|
||||
m_linearVelocity += m_angularVelocity.cross(m_centerOfMassWorld - oldCenterOfMass);
|
||||
}
|
||||
|
||||
// Set the mass of the rigid body
|
||||
@ -135,13 +135,13 @@ void RigidBody::setMass(float mass) {
|
||||
|
||||
if (m_type != DYNAMIC) return;
|
||||
|
||||
mInitMass = mass;
|
||||
m_initMass = mass;
|
||||
|
||||
if (mInitMass > float(0.0)) {
|
||||
m_massInverse = float(1.0) / mInitMass;
|
||||
if (m_initMass > float(0.0)) {
|
||||
m_massInverse = float(1.0) / m_initMass;
|
||||
}
|
||||
else {
|
||||
mInitMass = float(1.0);
|
||||
m_initMass = float(1.0);
|
||||
m_massInverse = float(1.0);
|
||||
}
|
||||
}
|
||||
@ -253,10 +253,10 @@ void RigidBody::setLinearVelocity(const Vector3& linearVelocity) {
|
||||
if (m_type == STATIC) return;
|
||||
|
||||
// Update the linear velocity of the current body state
|
||||
mLinearVelocity = linearVelocity;
|
||||
m_linearVelocity = linearVelocity;
|
||||
|
||||
// If the linear velocity is not zero, awake the body
|
||||
if (mLinearVelocity.lengthSquare() > float(0.0)) {
|
||||
if (m_linearVelocity.lengthSquare() > float(0.0)) {
|
||||
setIsSleeping(false);
|
||||
}
|
||||
}
|
||||
@ -271,10 +271,10 @@ void RigidBody::setAngularVelocity(const Vector3& angularVelocity) {
|
||||
if (m_type == STATIC) return;
|
||||
|
||||
// Set the angular velocity
|
||||
mAngularVelocity = angularVelocity;
|
||||
m_angularVelocity = angularVelocity;
|
||||
|
||||
// If the velocity is not zero, awake the body
|
||||
if (mAngularVelocity.lengthSquare() > float(0.0)) {
|
||||
if (m_angularVelocity.lengthSquare() > float(0.0)) {
|
||||
setIsSleeping(false);
|
||||
}
|
||||
}
|
||||
@ -289,13 +289,13 @@ void RigidBody::setTransform(const Transform& transform) {
|
||||
// Update the transform of the body
|
||||
m_transform = transform;
|
||||
|
||||
const Vector3 oldCenterOfMass = mCenterOfMassWorld;
|
||||
const Vector3 oldCenterOfMass = m_centerOfMassWorld;
|
||||
|
||||
// Compute the new center of mass in world-space coordinates
|
||||
mCenterOfMassWorld = m_transform * mCenterOfMassLocal;
|
||||
m_centerOfMassWorld = m_transform * m_centerOfMassLocal;
|
||||
|
||||
// Update the linear velocity of the center of mass
|
||||
mLinearVelocity += mAngularVelocity.cross(mCenterOfMassWorld - oldCenterOfMass);
|
||||
m_linearVelocity += m_angularVelocity.cross(m_centerOfMassWorld - oldCenterOfMass);
|
||||
|
||||
// Update the broad-phase state of the body
|
||||
updateBroadPhaseState();
|
||||
@ -305,15 +305,15 @@ void RigidBody::setTransform(const Transform& transform) {
|
||||
// the collision shapes attached to the body.
|
||||
void RigidBody::recomputeMassInformation() {
|
||||
|
||||
mInitMass = float(0.0);
|
||||
m_initMass = float(0.0);
|
||||
m_massInverse = float(0.0);
|
||||
mInertiaTensorLocal.setToZero();
|
||||
mInertiaTensorLocalInverse.setToZero();
|
||||
mCenterOfMassLocal.setToZero();
|
||||
m_inertiaTensorLocal.setToZero();
|
||||
m_inertiaTensorLocalInverse.setToZero();
|
||||
m_centerOfMassLocal.setToZero();
|
||||
|
||||
// If it is STATIC or KINEMATIC body
|
||||
if (m_type == STATIC || m_type == KINEMATIC) {
|
||||
mCenterOfMassWorld = m_transform.getPosition();
|
||||
m_centerOfMassWorld = m_transform.getPosition();
|
||||
return;
|
||||
}
|
||||
|
||||
@ -321,22 +321,22 @@ void RigidBody::recomputeMassInformation() {
|
||||
|
||||
// Compute the total mass of the body
|
||||
for (ProxyShape* shape = m_proxyCollisionShapes; shape != NULL; shape = shape->m_next) {
|
||||
mInitMass += shape->getMass();
|
||||
mCenterOfMassLocal += shape->getLocalToBodyTransform().getPosition() * shape->getMass();
|
||||
m_initMass += shape->getMass();
|
||||
m_centerOfMassLocal += shape->getLocalToBodyTransform().getPosition() * shape->getMass();
|
||||
}
|
||||
|
||||
if (mInitMass > float(0.0)) {
|
||||
m_massInverse = float(1.0) / mInitMass;
|
||||
if (m_initMass > float(0.0)) {
|
||||
m_massInverse = float(1.0) / m_initMass;
|
||||
}
|
||||
else {
|
||||
mInitMass = float(1.0);
|
||||
m_initMass = float(1.0);
|
||||
m_massInverse = float(1.0);
|
||||
}
|
||||
|
||||
// Compute the center of mass
|
||||
const Vector3 oldCenterOfMass = mCenterOfMassWorld;
|
||||
mCenterOfMassLocal *= m_massInverse;
|
||||
mCenterOfMassWorld = m_transform * mCenterOfMassLocal;
|
||||
const Vector3 oldCenterOfMass = m_centerOfMassWorld;
|
||||
m_centerOfMassLocal *= m_massInverse;
|
||||
m_centerOfMassWorld = m_transform * m_centerOfMassLocal;
|
||||
|
||||
// Compute the total mass and inertia tensor using all the collision shapes
|
||||
for (ProxyShape* shape = m_proxyCollisionShapes; shape != NULL; shape = shape->m_next) {
|
||||
@ -352,7 +352,7 @@ void RigidBody::recomputeMassInformation() {
|
||||
|
||||
// Use the parallel axis theorem to convert the inertia tensor w.r.t the collision shape
|
||||
// center int32_to a inertia tensor w.r.t to the body origin.
|
||||
Vector3 offset = shapeTransform.getPosition() - mCenterOfMassLocal;
|
||||
Vector3 offset = shapeTransform.getPosition() - m_centerOfMassLocal;
|
||||
float offsetSquare = offset.lengthSquare();
|
||||
Matrix3x3 offsetMatrix;
|
||||
offsetMatrix[0].setAllValues(offsetSquare, float(0.0), float(0.0));
|
||||
@ -363,14 +363,14 @@ void RigidBody::recomputeMassInformation() {
|
||||
offsetMatrix[2] += offset * (-offset.z);
|
||||
offsetMatrix *= shape->getMass();
|
||||
|
||||
mInertiaTensorLocal += inertiaTensor + offsetMatrix;
|
||||
m_inertiaTensorLocal += inertiaTensor + offsetMatrix;
|
||||
}
|
||||
|
||||
// Compute the local inverse inertia tensor
|
||||
mInertiaTensorLocalInverse = mInertiaTensorLocal.getInverse();
|
||||
m_inertiaTensorLocalInverse = m_inertiaTensorLocal.getInverse();
|
||||
|
||||
// Update the linear velocity of the center of mass
|
||||
mLinearVelocity += mAngularVelocity.cross(mCenterOfMassWorld - oldCenterOfMass);
|
||||
m_linearVelocity += m_angularVelocity.cross(m_centerOfMassWorld - oldCenterOfMass);
|
||||
}
|
||||
|
||||
// Update the broad-phase state for this body (because it has moved for instance)
|
||||
@ -379,7 +379,7 @@ void RigidBody::updateBroadPhaseState() const {
|
||||
PROFILE("RigidBody::updateBroadPhaseState()");
|
||||
|
||||
DynamicsWorld& world = static_cast<DynamicsWorld&>(m_world);
|
||||
const Vector3 displacement = world.m_timeStep * mLinearVelocity;
|
||||
const Vector3 displacement = world.m_timeStep * m_linearVelocity;
|
||||
|
||||
// For all the proxy collision shapes of the body
|
||||
for (ProxyShape* shape = m_proxyCollisionShapes; shape != NULL; shape = shape->m_next) {
|
||||
|
||||
@ -34,33 +34,33 @@ class RigidBody : public CollisionBody {
|
||||
// -------------------- Attributes -------------------- //
|
||||
|
||||
/// Intial mass of the body
|
||||
float mInitMass;
|
||||
float m_initMass;
|
||||
|
||||
/// Center of mass of the body in local-space coordinates.
|
||||
/// The center of mass can therefore be different from the body origin
|
||||
Vector3 mCenterOfMassLocal;
|
||||
Vector3 m_centerOfMassLocal;
|
||||
|
||||
/// Center of mass of the body in world-space coordinates
|
||||
Vector3 mCenterOfMassWorld;
|
||||
Vector3 m_centerOfMassWorld;
|
||||
|
||||
/// Linear velocity of the body
|
||||
Vector3 mLinearVelocity;
|
||||
Vector3 m_linearVelocity;
|
||||
|
||||
/// Angular velocity of the body
|
||||
Vector3 mAngularVelocity;
|
||||
Vector3 m_angularVelocity;
|
||||
|
||||
/// Current external force on the body
|
||||
Vector3 mExternalForce;
|
||||
Vector3 m_externalForce;
|
||||
|
||||
/// Current external torque on the body
|
||||
Vector3 mExternalTorque;
|
||||
Vector3 m_externalTorque;
|
||||
|
||||
/// Local inertia tensor of the body (in local-space) with respect to the
|
||||
/// center of mass of the body
|
||||
Matrix3x3 mInertiaTensorLocal;
|
||||
Matrix3x3 m_inertiaTensorLocal;
|
||||
|
||||
/// Inverse of the inertia tensor of the body
|
||||
Matrix3x3 mInertiaTensorLocalInverse;
|
||||
Matrix3x3 m_inertiaTensorLocalInverse;
|
||||
|
||||
/// Inverse of the mass of the body
|
||||
float m_massInverse;
|
||||
@ -69,13 +69,13 @@ class RigidBody : public CollisionBody {
|
||||
bool m_isGravityEnabled;
|
||||
|
||||
/// Material properties of the rigid body
|
||||
Material mMaterial;
|
||||
Material m_material;
|
||||
|
||||
/// Linear velocity damping factor
|
||||
float mLinearDamping;
|
||||
float m_linearDamping;
|
||||
|
||||
/// Angular velocity damping factor
|
||||
float mAngularDamping;
|
||||
float m_angularDamping;
|
||||
|
||||
/// First element of the linked list of joints involving this body
|
||||
JointListElement* m_jointsList;
|
||||
@ -215,7 +215,7 @@ class RigidBody : public CollisionBody {
|
||||
* @return The mass (in kilograms) of the body
|
||||
*/
|
||||
inline float RigidBody::getMass() const {
|
||||
return mInitMass;
|
||||
return m_initMass;
|
||||
}
|
||||
|
||||
// Return the linear velocity
|
||||
@ -223,7 +223,7 @@ inline float RigidBody::getMass() const {
|
||||
* @return The linear velocity vector of the body
|
||||
*/
|
||||
inline Vector3 RigidBody::getLinearVelocity() const {
|
||||
return mLinearVelocity;
|
||||
return m_linearVelocity;
|
||||
}
|
||||
|
||||
// Return the angular velocity of the body
|
||||
@ -231,7 +231,7 @@ inline Vector3 RigidBody::getLinearVelocity() const {
|
||||
* @return The angular velocity vector of the body
|
||||
*/
|
||||
inline Vector3 RigidBody::getAngularVelocity() const {
|
||||
return mAngularVelocity;
|
||||
return m_angularVelocity;
|
||||
}
|
||||
|
||||
// Return the local inertia tensor of the body (in local-space coordinates)
|
||||
@ -239,7 +239,7 @@ inline Vector3 RigidBody::getAngularVelocity() const {
|
||||
* @return The 3x3 inertia tensor matrix of the body (in local-space coordinates)
|
||||
*/
|
||||
inline const Matrix3x3& RigidBody::getInertiaTensorLocal() const {
|
||||
return mInertiaTensorLocal;
|
||||
return m_inertiaTensorLocal;
|
||||
}
|
||||
|
||||
// Return the inertia tensor in world coordinates.
|
||||
@ -254,7 +254,7 @@ inline const Matrix3x3& RigidBody::getInertiaTensorLocal() const {
|
||||
inline Matrix3x3 RigidBody::getInertiaTensorWorld() const {
|
||||
|
||||
// Compute and return the inertia tensor in world coordinates
|
||||
return m_transform.getOrientation().getMatrix() * mInertiaTensorLocal *
|
||||
return m_transform.getOrientation().getMatrix() * m_inertiaTensorLocal *
|
||||
m_transform.getOrientation().getMatrix().getTranspose();
|
||||
}
|
||||
|
||||
@ -274,7 +274,7 @@ inline Matrix3x3 RigidBody::getInertiaTensorInverseWorld() const {
|
||||
// INVERSE WORLD TENSOR IN THE CLASS AND UPLDATE IT WHEN THE ORIENTATION OF THE BODY CHANGES
|
||||
|
||||
// Compute and return the inertia tensor in world coordinates
|
||||
return m_transform.getOrientation().getMatrix() * mInertiaTensorLocalInverse *
|
||||
return m_transform.getOrientation().getMatrix() * m_inertiaTensorLocalInverse *
|
||||
m_transform.getOrientation().getMatrix().getTranspose();
|
||||
}
|
||||
|
||||
@ -299,7 +299,7 @@ inline void RigidBody::enableGravity(bool isEnabled) {
|
||||
* @return A reference to the material of the body
|
||||
*/
|
||||
inline Material& RigidBody::getMaterial() {
|
||||
return mMaterial;
|
||||
return m_material;
|
||||
}
|
||||
|
||||
// Set a new material for this rigid body
|
||||
@ -307,7 +307,7 @@ inline Material& RigidBody::getMaterial() {
|
||||
* @param material The material you want to set to the body
|
||||
*/
|
||||
inline void RigidBody::setMaterial(const Material& material) {
|
||||
mMaterial = material;
|
||||
m_material = material;
|
||||
}
|
||||
|
||||
// Return the linear velocity damping factor
|
||||
@ -315,7 +315,7 @@ inline void RigidBody::setMaterial(const Material& material) {
|
||||
* @return The linear damping factor of this body
|
||||
*/
|
||||
inline float RigidBody::getLinearDamping() const {
|
||||
return mLinearDamping;
|
||||
return m_linearDamping;
|
||||
}
|
||||
|
||||
// Set the linear damping factor. This is the ratio of the linear velocity
|
||||
@ -325,7 +325,7 @@ inline float RigidBody::getLinearDamping() const {
|
||||
*/
|
||||
inline void RigidBody::setLinearDamping(float linearDamping) {
|
||||
assert(linearDamping >= float(0.0));
|
||||
mLinearDamping = linearDamping;
|
||||
m_linearDamping = linearDamping;
|
||||
}
|
||||
|
||||
// Return the angular velocity damping factor
|
||||
@ -333,7 +333,7 @@ inline void RigidBody::setLinearDamping(float linearDamping) {
|
||||
* @return The angular damping factor of this body
|
||||
*/
|
||||
inline float RigidBody::getAngularDamping() const {
|
||||
return mAngularDamping;
|
||||
return m_angularDamping;
|
||||
}
|
||||
|
||||
// Set the angular damping factor. This is the ratio of the angular velocity
|
||||
@ -343,7 +343,7 @@ inline float RigidBody::getAngularDamping() const {
|
||||
*/
|
||||
inline void RigidBody::setAngularDamping(float angularDamping) {
|
||||
assert(angularDamping >= float(0.0));
|
||||
mAngularDamping = angularDamping;
|
||||
m_angularDamping = angularDamping;
|
||||
}
|
||||
|
||||
// Return the first element of the linked list of joints involving this body
|
||||
@ -366,10 +366,10 @@ inline JointListElement* RigidBody::getJointsList() {
|
||||
inline void RigidBody::setIsSleeping(bool isSleeping) {
|
||||
|
||||
if (isSleeping) {
|
||||
mLinearVelocity.setToZero();
|
||||
mAngularVelocity.setToZero();
|
||||
mExternalForce.setToZero();
|
||||
mExternalTorque.setToZero();
|
||||
m_linearVelocity.setToZero();
|
||||
m_angularVelocity.setToZero();
|
||||
m_externalForce.setToZero();
|
||||
m_externalTorque.setToZero();
|
||||
}
|
||||
|
||||
Body::setIsSleeping(isSleeping);
|
||||
@ -394,7 +394,7 @@ inline void RigidBody::applyForceToCenterOfMass(const Vector3& force) {
|
||||
}
|
||||
|
||||
// Add the force
|
||||
mExternalForce += force;
|
||||
m_externalForce += force;
|
||||
}
|
||||
|
||||
// Apply an external force to the body at a given point (in world-space coordinates).
|
||||
@ -419,8 +419,8 @@ inline void RigidBody::applyForce(const Vector3& force, const Vector3& point) {
|
||||
}
|
||||
|
||||
// Add the force and torque
|
||||
mExternalForce += force;
|
||||
mExternalTorque += (point - mCenterOfMassWorld).cross(force);
|
||||
m_externalForce += force;
|
||||
m_externalTorque += (point - m_centerOfMassWorld).cross(force);
|
||||
}
|
||||
|
||||
// Apply an external torque to the body.
|
||||
@ -442,14 +442,14 @@ inline void RigidBody::applyTorque(const Vector3& torque) {
|
||||
}
|
||||
|
||||
// Add the torque
|
||||
mExternalTorque += torque;
|
||||
m_externalTorque += torque;
|
||||
}
|
||||
|
||||
/// Update the transform of the body after a change of the center of mass
|
||||
inline void RigidBody::updateTransformWithCenterOfMass() {
|
||||
|
||||
// Translate the body according to the translation of the center of mass position
|
||||
m_transform.setPosition(mCenterOfMassWorld - m_transform.getOrientation() * mCenterOfMassLocal);
|
||||
m_transform.setPosition(m_centerOfMassWorld - m_transform.getOrientation() * m_centerOfMassLocal);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@ -25,7 +25,7 @@ class TriangleMesh {
|
||||
protected:
|
||||
|
||||
/// All the triangle arrays of the mesh (one triangle array per part)
|
||||
std::vector<TriangleVertexArray*> mTriangleArrays;
|
||||
std::vector<TriangleVertexArray*> m_triangleArrays;
|
||||
|
||||
public:
|
||||
|
||||
@ -47,18 +47,18 @@ class TriangleMesh {
|
||||
|
||||
// Add a subpart of the mesh
|
||||
inline void TriangleMesh::addSubpart(TriangleVertexArray* triangleVertexArray) {
|
||||
mTriangleArrays.push_back(triangleVertexArray );
|
||||
m_triangleArrays.push_back(triangleVertexArray );
|
||||
}
|
||||
|
||||
// Return a pointer to a given subpart (triangle vertex array) of the mesh
|
||||
inline TriangleVertexArray* TriangleMesh::getSubpart(uint32_t indexSubpart) const {
|
||||
assert(indexSubpart < mTriangleArrays.size());
|
||||
return mTriangleArrays[indexSubpart];
|
||||
assert(indexSubpart < m_triangleArrays.size());
|
||||
return m_triangleArrays[indexSubpart];
|
||||
}
|
||||
|
||||
// Return the number of subparts of the mesh
|
||||
inline uint32_t TriangleMesh::getNbSubparts() const {
|
||||
return mTriangleArrays.size();
|
||||
return m_triangleArrays.size();
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@ -29,11 +29,11 @@ TriangleVertexArray::TriangleVertexArray(uint32_t nbVertices, void* verticesStar
|
||||
m_numberVertices = nbVertices;
|
||||
m_verticesStart = reinterpret_cast<unsigned char*>(verticesStart);
|
||||
m_verticesStride = verticesStride;
|
||||
mNbTriangles = nbTriangles;
|
||||
mIndicesStart = reinterpret_cast<unsigned char*>(indexesStart);
|
||||
mIndicesStride = indexesStride;
|
||||
mVertexDataType = vertexDataType;
|
||||
mIndexDataType = indexDataType;
|
||||
m_numberTriangles = nbTriangles;
|
||||
m_indicesStart = reinterpret_cast<unsigned char*>(indexesStart);
|
||||
m_indicesStride = indexesStride;
|
||||
m_vertexDataType = vertexDataType;
|
||||
m_indexDataType = indexDataType;
|
||||
}
|
||||
|
||||
// Destructor
|
||||
|
||||
@ -43,20 +43,20 @@ class TriangleVertexArray {
|
||||
int32_t m_verticesStride;
|
||||
|
||||
/// Number of triangles in the array
|
||||
uint32_t mNbTriangles;
|
||||
uint32_t m_numberTriangles;
|
||||
|
||||
/// Pointer to the first vertex index of the array
|
||||
unsigned char* mIndicesStart;
|
||||
unsigned char* m_indicesStart;
|
||||
|
||||
/// Stride (number of bytes) between the beginning of two indices in
|
||||
/// the array
|
||||
int32_t mIndicesStride;
|
||||
int32_t m_indicesStride;
|
||||
|
||||
/// Data type of the vertices in the array
|
||||
VertexDataType mVertexDataType;
|
||||
VertexDataType m_vertexDataType;
|
||||
|
||||
/// Data type of the indices in the array
|
||||
IndexDataType mIndexDataType;
|
||||
IndexDataType m_indexDataType;
|
||||
|
||||
public:
|
||||
|
||||
@ -95,12 +95,12 @@ class TriangleVertexArray {
|
||||
|
||||
// Return the vertex data type
|
||||
inline TriangleVertexArray::VertexDataType TriangleVertexArray::getVertexDataType() const {
|
||||
return mVertexDataType;
|
||||
return m_vertexDataType;
|
||||
}
|
||||
|
||||
// Return the index data type
|
||||
inline TriangleVertexArray::IndexDataType TriangleVertexArray::getIndexDataType() const {
|
||||
return mIndexDataType;
|
||||
return m_indexDataType;
|
||||
}
|
||||
|
||||
// Return the number of vertices
|
||||
@ -110,7 +110,7 @@ inline uint32_t TriangleVertexArray::getNbVertices() const {
|
||||
|
||||
// Return the number of triangles
|
||||
inline uint32_t TriangleVertexArray::getNbTriangles() const {
|
||||
return mNbTriangles;
|
||||
return m_numberTriangles;
|
||||
}
|
||||
|
||||
// Return the vertices stride (number of bytes)
|
||||
@ -120,7 +120,7 @@ inline int32_t TriangleVertexArray::getVerticesStride() const {
|
||||
|
||||
// Return the indices stride (number of bytes)
|
||||
inline int32_t TriangleVertexArray::getIndicesStride() const {
|
||||
return mIndicesStride;
|
||||
return m_indicesStride;
|
||||
}
|
||||
|
||||
// Return the pointer to the start of the vertices array
|
||||
@ -130,7 +130,7 @@ inline unsigned char* TriangleVertexArray::getVerticesStart() const {
|
||||
|
||||
// Return the pointer to the start of the indices array
|
||||
inline unsigned char* TriangleVertexArray::getIndicesStart() const {
|
||||
return mIndicesStart;
|
||||
return m_indicesStart;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@ -11,7 +11,7 @@
|
||||
using namespace reactphysics3d;
|
||||
|
||||
// Constructor
|
||||
TrianglesStore::TrianglesStore() : mNbTriangles(0) {
|
||||
TrianglesStore::TrianglesStore() : m_numberTriangles(0) {
|
||||
|
||||
}
|
||||
|
||||
|
||||
@ -31,7 +31,7 @@ class TrianglesStore {
|
||||
TriangleEPA mTriangles[MAX_TRIANGLES];
|
||||
|
||||
/// Number of triangles
|
||||
int32_t mNbTriangles;
|
||||
int32_t m_numberTriangles;
|
||||
|
||||
// -------------------- Methods -------------------- //
|
||||
|
||||
@ -72,23 +72,23 @@ class TrianglesStore {
|
||||
|
||||
// Clear all the storage
|
||||
inline void TrianglesStore::clear() {
|
||||
mNbTriangles = 0;
|
||||
m_numberTriangles = 0;
|
||||
}
|
||||
|
||||
// Return the number of triangles
|
||||
inline int32_t TrianglesStore::getNbTriangles() const {
|
||||
return mNbTriangles;
|
||||
return m_numberTriangles;
|
||||
}
|
||||
|
||||
|
||||
inline void TrianglesStore::setNbTriangles(int32_t backup) {
|
||||
mNbTriangles = backup;
|
||||
m_numberTriangles = backup;
|
||||
}
|
||||
|
||||
// Return the last triangle
|
||||
inline TriangleEPA& TrianglesStore::last() {
|
||||
assert(mNbTriangles > 0);
|
||||
return mTriangles[mNbTriangles - 1];
|
||||
assert(m_numberTriangles > 0);
|
||||
return mTriangles[m_numberTriangles - 1];
|
||||
}
|
||||
|
||||
// Create a new triangle
|
||||
@ -97,11 +97,11 @@ inline TriangleEPA* TrianglesStore::newTriangle(const Vector3* vertices,
|
||||
TriangleEPA* newTriangle = NULL;
|
||||
|
||||
// If we have not reached the maximum number of triangles
|
||||
if (mNbTriangles != MAX_TRIANGLES) {
|
||||
newTriangle = &mTriangles[mNbTriangles++];
|
||||
if (m_numberTriangles != MAX_TRIANGLES) {
|
||||
newTriangle = &mTriangles[m_numberTriangles++];
|
||||
new (newTriangle) TriangleEPA(v0, v1, v2);
|
||||
if (!newTriangle->computeClosestPoint(vertices)) {
|
||||
mNbTriangles--;
|
||||
m_numberTriangles--;
|
||||
newTriangle = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
@ -35,8 +35,8 @@ void BallAndSocketJoint::initBeforeSolve(const ConstraintSolverData& constraintS
|
||||
m_indexBody2 = constraintSolverData.mapBodyToConstrainedVelocityIndex.find(m_body2)->second;
|
||||
|
||||
// Get the bodies center of mass and orientations
|
||||
const Vector3& x1 = m_body1->mCenterOfMassWorld;
|
||||
const Vector3& x2 = m_body2->mCenterOfMassWorld;
|
||||
const Vector3& x1 = m_body1->m_centerOfMassWorld;
|
||||
const Vector3& x2 = m_body2->m_centerOfMassWorld;
|
||||
const Quaternion& orientationBody1 = m_body1->getTransform().getOrientation();
|
||||
const Quaternion& orientationBody2 = m_body2->getTransform().getOrientation();
|
||||
|
||||
|
||||
@ -43,8 +43,8 @@ void FixedJoint::initBeforeSolve(const ConstraintSolverData& constraintSolverDat
|
||||
m_indexBody2 = constraintSolverData.mapBodyToConstrainedVelocityIndex.find(m_body2)->second;
|
||||
|
||||
// Get the bodies positions and orientations
|
||||
const Vector3& x1 = m_body1->mCenterOfMassWorld;
|
||||
const Vector3& x2 = m_body2->mCenterOfMassWorld;
|
||||
const Vector3& x1 = m_body1->m_centerOfMassWorld;
|
||||
const Vector3& x2 = m_body2->m_centerOfMassWorld;
|
||||
const Quaternion& orientationBody1 = m_body1->getTransform().getOrientation();
|
||||
const Quaternion& orientationBody2 = m_body2->getTransform().getOrientation();
|
||||
|
||||
|
||||
@ -58,8 +58,8 @@ void HingeJoint::initBeforeSolve(const ConstraintSolverData& constraintSolverDat
|
||||
m_indexBody2 = constraintSolverData.mapBodyToConstrainedVelocityIndex.find(m_body2)->second;
|
||||
|
||||
// Get the bodies positions and orientations
|
||||
const Vector3& x1 = m_body1->mCenterOfMassWorld;
|
||||
const Vector3& x2 = m_body2->mCenterOfMassWorld;
|
||||
const Vector3& x1 = m_body1->m_centerOfMassWorld;
|
||||
const Vector3& x2 = m_body2->m_centerOfMassWorld;
|
||||
const Quaternion& orientationBody1 = m_body1->getTransform().getOrientation();
|
||||
const Quaternion& orientationBody2 = m_body2->getTransform().getOrientation();
|
||||
|
||||
|
||||
@ -57,8 +57,8 @@ void SliderJoint::initBeforeSolve(const ConstraintSolverData& constraintSolverDa
|
||||
m_indexBody2 = constraintSolverData.mapBodyToConstrainedVelocityIndex.find(m_body2)->second;
|
||||
|
||||
// Get the bodies positions and orientations
|
||||
const Vector3& x1 = m_body1->mCenterOfMassWorld;
|
||||
const Vector3& x2 = m_body2->mCenterOfMassWorld;
|
||||
const Vector3& x1 = m_body1->m_centerOfMassWorld;
|
||||
const Vector3& x2 = m_body2->m_centerOfMassWorld;
|
||||
const Quaternion& orientationBody1 = m_body1->getTransform().getOrientation();
|
||||
const Quaternion& orientationBody2 = m_body2->getTransform().getOrientation();
|
||||
|
||||
|
||||
@ -70,8 +70,8 @@ void ContactSolver::initializeForIsland(float dt, Island* island) {
|
||||
assert(body2 != NULL);
|
||||
|
||||
// Get the position of the two bodies
|
||||
const Vector3& x1 = body1->mCenterOfMassWorld;
|
||||
const Vector3& x2 = body2->mCenterOfMassWorld;
|
||||
const Vector3& x1 = body1->m_centerOfMassWorld;
|
||||
const Vector3& x2 = body2->m_centerOfMassWorld;
|
||||
|
||||
// Initialize the int32_ternal contact manifold structure using the external
|
||||
// contact manifold
|
||||
|
||||
@ -180,7 +180,7 @@ void DynamicsWorld::int32_tegrateRigidBodiesPositions() {
|
||||
}
|
||||
|
||||
// Get current position and orientation of the body
|
||||
const Vector3& currentPosition = bodies[b]->mCenterOfMassWorld;
|
||||
const Vector3& currentPosition = bodies[b]->m_centerOfMassWorld;
|
||||
const Quaternion& currentOrientation = bodies[b]->getTransform().getOrientation();
|
||||
|
||||
// Update the new constrained position and orientation of the body
|
||||
@ -208,11 +208,11 @@ void DynamicsWorld::updateBodiesState() {
|
||||
uint32_t index = m_mapBodyToConstrainedVelocityIndex.find(bodies[b])->second;
|
||||
|
||||
// Update the linear and angular velocity of the body
|
||||
bodies[b]->mLinearVelocity = m_constrainedLinearVelocities[index];
|
||||
bodies[b]->mAngularVelocity = m_constrainedAngularVelocities[index];
|
||||
bodies[b]->m_linearVelocity = m_constrainedLinearVelocities[index];
|
||||
bodies[b]->m_angularVelocity = m_constrainedAngularVelocities[index];
|
||||
|
||||
// Update the position of the center of mass of the body
|
||||
bodies[b]->mCenterOfMassWorld = m_constrainedPositions[index];
|
||||
bodies[b]->m_centerOfMassWorld = m_constrainedPositions[index];
|
||||
|
||||
// Update the orientation of the body
|
||||
bodies[b]->m_transform.setOrientation(m_constrainedOrientations[index].getUnit());
|
||||
@ -298,10 +298,10 @@ void DynamicsWorld::int32_tegrateRigidBodiesVelocities() {
|
||||
|
||||
// Integrate the external force to get the new velocity of the body
|
||||
m_constrainedLinearVelocities[indexBody] = bodies[b]->getLinearVelocity() +
|
||||
m_timeStep * bodies[b]->m_massInverse * bodies[b]->mExternalForce;
|
||||
m_timeStep * bodies[b]->m_massInverse * bodies[b]->m_externalForce;
|
||||
m_constrainedAngularVelocities[indexBody] = bodies[b]->getAngularVelocity() +
|
||||
m_timeStep * bodies[b]->getInertiaTensorInverseWorld() *
|
||||
bodies[b]->mExternalTorque;
|
||||
bodies[b]->m_externalTorque;
|
||||
|
||||
// If the gravity has to be applied to this rigid body
|
||||
if (bodies[b]->isGravityEnabled() && m_isGravityEnabled) {
|
||||
|
||||
@ -290,8 +290,8 @@ inline void DynamicsWorld::resetBodiesForceAndTorque() {
|
||||
// For each body of the world
|
||||
std::set<RigidBody*>::iterator it;
|
||||
for (it = m_rigidBodies.begin(); it != m_rigidBodies.end(); ++it) {
|
||||
(*it)->mExternalForce.setToZero();
|
||||
(*it)->mExternalTorque.setToZero();
|
||||
(*it)->m_externalForce.setToZero();
|
||||
(*it)->m_externalTorque.setToZero();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -11,7 +11,7 @@
|
||||
using namespace reactphysics3d;
|
||||
|
||||
// Constructor
|
||||
Timer::Timer(double timeStep) : m_timeStep(timeStep), mIsRunning(false) {
|
||||
Timer::Timer(double timeStep) : m_timeStep(timeStep), m_isRunning(false) {
|
||||
assert(timeStep > 0.0);
|
||||
}
|
||||
|
||||
|
||||
@ -39,16 +39,16 @@ class Timer {
|
||||
double m_timeStep;
|
||||
|
||||
/// Last time the timer has been updated
|
||||
long double mLastUpdateTime;
|
||||
long double m_lastUpdateTime;
|
||||
|
||||
/// Time difference between the two last timer update() calls
|
||||
long double mDeltaTime;
|
||||
long double m_deltaTime;
|
||||
|
||||
/// Used to fix the time step and avoid strange time effects
|
||||
double mAccumulator;
|
||||
double m_accumulator;
|
||||
|
||||
/// True if the timer is running
|
||||
bool mIsRunning;
|
||||
bool m_isRunning;
|
||||
|
||||
// -------------------- Methods -------------------- //
|
||||
|
||||
@ -115,47 +115,47 @@ inline void Timer::setTimeStep(double timeStep) {
|
||||
|
||||
// Return the current time
|
||||
inline long double Timer::getPhysicsTime() const {
|
||||
return mLastUpdateTime;
|
||||
return m_lastUpdateTime;
|
||||
}
|
||||
|
||||
// Return if the timer is running
|
||||
inline bool Timer::getIsRunning() const {
|
||||
return mIsRunning;
|
||||
return m_isRunning;
|
||||
}
|
||||
|
||||
// Start the timer
|
||||
inline void Timer::start() {
|
||||
if (!mIsRunning) {
|
||||
if (!m_isRunning) {
|
||||
|
||||
// Get the current system time
|
||||
mLastUpdateTime = getCurrentSystemTime();
|
||||
m_lastUpdateTime = getCurrentSystemTime();
|
||||
|
||||
mAccumulator = 0.0;
|
||||
mIsRunning = true;
|
||||
m_accumulator = 0.0;
|
||||
m_isRunning = true;
|
||||
}
|
||||
}
|
||||
|
||||
// Stop the timer
|
||||
inline void Timer::stop() {
|
||||
mIsRunning = false;
|
||||
m_isRunning = false;
|
||||
}
|
||||
|
||||
// True if it's possible to take a new step
|
||||
inline bool Timer::isPossibleToTakeStep() const {
|
||||
return (mAccumulator >= m_timeStep);
|
||||
return (m_accumulator >= m_timeStep);
|
||||
}
|
||||
|
||||
// Take a new step => update the timer by adding the timeStep value to the current time
|
||||
inline void Timer::nextStep() {
|
||||
assert(mIsRunning);
|
||||
assert(m_isRunning);
|
||||
|
||||
// Update the accumulator value
|
||||
mAccumulator -= m_timeStep;
|
||||
m_accumulator -= m_timeStep;
|
||||
}
|
||||
|
||||
// Compute the int32_terpolation factor
|
||||
inline float Timer::computeInterpolationFactor() {
|
||||
return (float(mAccumulator / m_timeStep));
|
||||
return (float(m_accumulator / m_timeStep));
|
||||
}
|
||||
|
||||
// Compute the time since the last update() call and add it to the accumulator
|
||||
@ -165,13 +165,13 @@ inline void Timer::update() {
|
||||
long double currentTime = getCurrentSystemTime();
|
||||
|
||||
// Compute the delta display time between two display frames
|
||||
mDeltaTime = currentTime - mLastUpdateTime;
|
||||
m_deltaTime = currentTime - m_lastUpdateTime;
|
||||
|
||||
// Update the current display time
|
||||
mLastUpdateTime = currentTime;
|
||||
m_lastUpdateTime = currentTime;
|
||||
|
||||
// Update the accumulator value
|
||||
mAccumulator += mDeltaTime;
|
||||
m_accumulator += m_deltaTime;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@ -11,25 +11,25 @@
|
||||
using namespace reactphysics3d;
|
||||
|
||||
// Constructor
|
||||
Transform::Transform() : mPosition(Vector3(0.0, 0.0, 0.0)), mOrientation(Quaternion::identity()) {
|
||||
Transform::Transform() : m_position(Vector3(0.0, 0.0, 0.0)), m_orientation(Quaternion::identity()) {
|
||||
|
||||
}
|
||||
|
||||
// Constructor
|
||||
Transform::Transform(const Vector3& position, const Matrix3x3& orientation)
|
||||
: mPosition(position), mOrientation(Quaternion(orientation)) {
|
||||
: m_position(position), m_orientation(Quaternion(orientation)) {
|
||||
|
||||
}
|
||||
|
||||
// Constructor
|
||||
Transform::Transform(const Vector3& position, const Quaternion& orientation)
|
||||
: mPosition(position), mOrientation(orientation) {
|
||||
: m_position(position), m_orientation(orientation) {
|
||||
|
||||
}
|
||||
|
||||
// Copy-constructor
|
||||
Transform::Transform(const Transform& transform)
|
||||
: mPosition(transform.mPosition), mOrientation(transform.mOrientation) {
|
||||
: m_position(transform.m_position), m_orientation(transform.m_orientation) {
|
||||
|
||||
}
|
||||
|
||||
|
||||
@ -25,10 +25,10 @@ class Transform {
|
||||
// -------------------- Attributes -------------------- //
|
||||
|
||||
/// Position
|
||||
Vector3 mPosition;
|
||||
Vector3 m_position;
|
||||
|
||||
/// Orientation
|
||||
Quaternion mOrientation;
|
||||
Quaternion m_orientation;
|
||||
|
||||
public :
|
||||
|
||||
@ -99,28 +99,28 @@ class Transform {
|
||||
|
||||
// Return the position of the transform
|
||||
inline const Vector3& Transform::getPosition() const {
|
||||
return mPosition;
|
||||
return m_position;
|
||||
}
|
||||
|
||||
// Set the origin of the transform
|
||||
inline void Transform::setPosition(const Vector3& position) {
|
||||
mPosition = position;
|
||||
m_position = position;
|
||||
}
|
||||
|
||||
// Return the rotation matrix
|
||||
inline const Quaternion& Transform::getOrientation() const {
|
||||
return mOrientation;
|
||||
return m_orientation;
|
||||
}
|
||||
|
||||
// Set the rotation matrix of the transform
|
||||
inline void Transform::setOrientation(const Quaternion& orientation) {
|
||||
mOrientation = orientation;
|
||||
m_orientation = orientation;
|
||||
}
|
||||
|
||||
// Set the transform to the identity transform
|
||||
inline void Transform::setToIdentity() {
|
||||
mPosition = Vector3(0.0, 0.0, 0.0);
|
||||
mOrientation = Quaternion::identity();
|
||||
m_position = Vector3(0.0, 0.0, 0.0);
|
||||
m_orientation = Quaternion::identity();
|
||||
}
|
||||
|
||||
// Set the transform from an OpenGL transform matrix
|
||||
@ -128,28 +128,28 @@ inline void Transform::setFromOpenGL(float* openglMatrix) {
|
||||
Matrix3x3 matrix(openglMatrix[0], openglMatrix[4], openglMatrix[8],
|
||||
openglMatrix[1], openglMatrix[5], openglMatrix[9],
|
||||
openglMatrix[2], openglMatrix[6], openglMatrix[10]);
|
||||
mOrientation = Quaternion(matrix);
|
||||
mPosition.setAllValues(openglMatrix[12], openglMatrix[13], openglMatrix[14]);
|
||||
m_orientation = Quaternion(matrix);
|
||||
m_position.setAllValues(openglMatrix[12], openglMatrix[13], openglMatrix[14]);
|
||||
}
|
||||
|
||||
// Get the OpenGL matrix of the transform
|
||||
inline void Transform::getOpenGLMatrix(float* openglMatrix) const {
|
||||
const Matrix3x3& matrix = mOrientation.getMatrix();
|
||||
const Matrix3x3& matrix = m_orientation.getMatrix();
|
||||
openglMatrix[0] = matrix[0][0]; openglMatrix[1] = matrix[1][0];
|
||||
openglMatrix[2] = matrix[2][0]; openglMatrix[3] = 0.0;
|
||||
openglMatrix[4] = matrix[0][1]; openglMatrix[5] = matrix[1][1];
|
||||
openglMatrix[6] = matrix[2][1]; openglMatrix[7] = 0.0;
|
||||
openglMatrix[8] = matrix[0][2]; openglMatrix[9] = matrix[1][2];
|
||||
openglMatrix[10] = matrix[2][2]; openglMatrix[11] = 0.0;
|
||||
openglMatrix[12] = mPosition.x; openglMatrix[13] = mPosition.y;
|
||||
openglMatrix[14] = mPosition.z; openglMatrix[15] = 1.0;
|
||||
openglMatrix[12] = m_position.x; openglMatrix[13] = m_position.y;
|
||||
openglMatrix[14] = m_position.z; openglMatrix[15] = 1.0;
|
||||
}
|
||||
|
||||
// Return the inverse of the transform
|
||||
inline Transform Transform::getInverse() const {
|
||||
const Quaternion& invQuaternion = mOrientation.getInverse();
|
||||
const Quaternion& invQuaternion = m_orientation.getInverse();
|
||||
Matrix3x3 invMatrix = invQuaternion.getMatrix();
|
||||
return Transform(invMatrix * (-mPosition), invQuaternion);
|
||||
return Transform(invMatrix * (-m_position), invQuaternion);
|
||||
}
|
||||
|
||||
// Return an int32_terpolated transform
|
||||
@ -157,11 +157,11 @@ inline Transform Transform::int32_terpolateTransforms(const Transform& oldTransf
|
||||
const Transform& newTransform,
|
||||
float int32_terpolationFactor) {
|
||||
|
||||
Vector3 int32_terPosition = oldTransform.mPosition * (float(1.0) - int32_terpolationFactor) +
|
||||
newTransform.mPosition * int32_terpolationFactor;
|
||||
Vector3 int32_terPosition = oldTransform.m_position * (float(1.0) - int32_terpolationFactor) +
|
||||
newTransform.m_position * int32_terpolationFactor;
|
||||
|
||||
Quaternion int32_terOrientation = Quaternion::slerp(oldTransform.mOrientation,
|
||||
newTransform.mOrientation,
|
||||
Quaternion int32_terOrientation = Quaternion::slerp(oldTransform.m_orientation,
|
||||
newTransform.m_orientation,
|
||||
int32_terpolationFactor);
|
||||
|
||||
return Transform(int32_terPosition, int32_terOrientation);
|
||||
@ -174,18 +174,18 @@ inline Transform Transform::identity() {
|
||||
|
||||
// Return the transformed vector
|
||||
inline Vector3 Transform::operator*(const Vector3& vector) const {
|
||||
return (mOrientation.getMatrix() * vector) + mPosition;
|
||||
return (m_orientation.getMatrix() * vector) + m_position;
|
||||
}
|
||||
|
||||
// Operator of multiplication of a transform with another one
|
||||
inline Transform Transform::operator*(const Transform& transform2) const {
|
||||
return Transform(mPosition + mOrientation.getMatrix() * transform2.mPosition,
|
||||
mOrientation * transform2.mOrientation);
|
||||
return Transform(m_position + m_orientation.getMatrix() * transform2.m_position,
|
||||
m_orientation * transform2.m_orientation);
|
||||
}
|
||||
|
||||
// Return true if the two transforms are equal
|
||||
inline bool Transform::operator==(const Transform& transform2) const {
|
||||
return (mPosition == transform2.mPosition) && (mOrientation == transform2.mOrientation);
|
||||
return (m_position == transform2.m_position) && (m_orientation == transform2.m_orientation);
|
||||
}
|
||||
|
||||
// Return true if the two transforms are different
|
||||
@ -196,8 +196,8 @@ inline bool Transform::operator!=(const Transform& transform2) const {
|
||||
// Assignment operator
|
||||
inline Transform& Transform::operator=(const Transform& transform) {
|
||||
if (&transform != this) {
|
||||
mPosition = transform.mPosition;
|
||||
mOrientation = transform.mOrientation;
|
||||
m_position = transform.m_position;
|
||||
m_orientation = transform.m_orientation;
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
@ -28,7 +28,7 @@
|
||||
|
||||
|
||||
// Constructor
|
||||
Timer::Timer() : mIsRunning(false) {
|
||||
Timer::Timer() : m_isRunning(false) {
|
||||
|
||||
}
|
||||
|
||||
|
||||
@ -53,16 +53,16 @@ class Timer {
|
||||
// -------------------- Attributes -------------------- //
|
||||
|
||||
/// Last time the timer has been updated
|
||||
long double mLastUpdateTime;
|
||||
long double m_lastUpdateTime;
|
||||
|
||||
/// Time difference between the two last timer update() calls
|
||||
long double mDeltaTime;
|
||||
long double m_d*eltaTime;
|
||||
|
||||
/// Used to fix the time step and avoid strange time effects
|
||||
double mAccumulator;
|
||||
double m_accumulator;
|
||||
|
||||
/// True if the timer is running
|
||||
bool mIsRunning;
|
||||
bool m_isRunning;
|
||||
|
||||
// -------------------- Methods -------------------- //
|
||||
|
||||
@ -112,47 +112,47 @@ class Timer {
|
||||
|
||||
// Return the current time
|
||||
inline long double Timer::getPhysicsTime() const {
|
||||
return mLastUpdateTime;
|
||||
return m_lastUpdateTime;
|
||||
}
|
||||
|
||||
// Return if the timer is running
|
||||
inline bool Timer::isRunning() const {
|
||||
return mIsRunning;
|
||||
return m_isRunning;
|
||||
}
|
||||
|
||||
// Start the timer
|
||||
inline void Timer::start() {
|
||||
if (!mIsRunning) {
|
||||
if (!m_isRunning) {
|
||||
|
||||
// Get the current system time
|
||||
mLastUpdateTime = getCurrentSystemTime();
|
||||
m_lastUpdateTime = getCurrentSystemTime();
|
||||
|
||||
mAccumulator = 0.0;
|
||||
mIsRunning = true;
|
||||
m_accumulator = 0.0;
|
||||
m_isRunning = true;
|
||||
}
|
||||
}
|
||||
|
||||
// Stop the timer
|
||||
inline void Timer::stop() {
|
||||
mIsRunning = false;
|
||||
m_isRunning = false;
|
||||
}
|
||||
|
||||
// True if it's possible to take a new step
|
||||
inline bool Timer::isPossibleToTakeStep(float timeStep) const {
|
||||
return (mAccumulator >= timeStep);
|
||||
return (m_accumulator >= timeStep);
|
||||
}
|
||||
|
||||
// Take a new step => update the timer by adding the timeStep value to the current time
|
||||
inline void Timer::nextStep(float timeStep) {
|
||||
assert(mIsRunning);
|
||||
assert(m_isRunning);
|
||||
|
||||
// Update the accumulator value
|
||||
mAccumulator -= timeStep;
|
||||
m_accumulator -= timeStep;
|
||||
}
|
||||
|
||||
// Compute the int32_terpolation factor
|
||||
inline float Timer::computeInterpolationFactor(float timeStep) {
|
||||
return (float(mAccumulator) / timeStep);
|
||||
return (float(m_accumulator) / timeStep);
|
||||
}
|
||||
|
||||
// Compute the time since the last update() call and add it to the accumulator
|
||||
@ -162,13 +162,13 @@ inline void Timer::update() {
|
||||
long double currentTime = getCurrentSystemTime();
|
||||
|
||||
// Compute the delta display time between two display frames
|
||||
mDeltaTime = currentTime - mLastUpdateTime;
|
||||
m_d*eltaTime = currentTime - m_lastUpdateTime;
|
||||
|
||||
// Update the current display time
|
||||
mLastUpdateTime = currentTime;
|
||||
m_lastUpdateTime = currentTime;
|
||||
|
||||
// Update the accumulator value
|
||||
mAccumulator += mDeltaTime;
|
||||
m_accumulator += m_d*eltaTime;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
Loading…
Reference in New Issue
Block a user