Bullet Vehicle Problem, using btVehicle class

[MrPuff]

Here's a video of the problem.
http://www.youtube.com/watch?v=GHsGa7Ei538

The code's worked from the vehicle example.

The game is rendered using DirectX 9.

const int rightIndex = 0;
const int upIndex = 1;
const int forwardIndex = 2;
const btVector3 wheelDirectionCS0(0,-1,0);
const btVector3 wheelAxleCS(-1,0,0);

const float connectionHeight = 1.2f;

car.m_BreakingForce = 0.f;
car.m_EngineForce = 0.f;
car.m_VehicleSteering = 0.2f;

car.m_chassisModel = chassis_model;
car.m_chassisMass = 800.f;
car.m_maxBreakingForce = 100.f;
car.m_maxEngineForce = 4000.f;
car.m_wheelRadius = 0.5f;
car.m_wheelWidth = 0.1f;
car.m_wheelFriction = 2.0f;
car.m_rollInfluence = 0.1f;

car.m_suspensionStiffness = 60.f;
car.m_suspensionDamping = 4.f * 2.f * sqrt(car.m_suspensionStiffness);
car.m_suspensionRestLength = 2.8f;
car.m_suspensionCompression = 3.f * 2.f * sqrt(car.m_suspensionStiffness);
car.m_maxSuspensionForce = 6000.0f;
car.m_maxSuspensionTravelCm = 10.0f;


Anyone got any idea what the hell is going on?!

[MrPuff]

Just thought, maybe im not converting the matrix properly? This is what im doing:

Code: Select all

MP_INLINE MATRIX4 PhysicsShape::GetWorldTransform()
{
	btTransform t;
	m_rigidbody->getMotionState()->getWorldTransform(t);
	return MATRIX4( t.getBasis().getRow(0).m_floats[0], t.getBasis().getRow(0).m_floats[1], t.getBasis().getRow(0).m_floats[2], t.getBasis().getRow(0).m_floats[3],
					t.getBasis().getRow(1).m_floats[0], t.getBasis().getRow(1).m_floats[1], t.getBasis().getRow(1).m_floats[2], t.getBasis().getRow(1).m_floats[3],
					t.getBasis().getRow(2).m_floats[0], t.getBasis().getRow(2).m_floats[1], t.getBasis().getRow(2).m_floats[2], t.getBasis().getRow(2).m_floats[3],
					t.getBasis().getRow(3).m_floats[0], t.getBasis().getRow(3).m_floats[1], t.getBasis().getRow(3).m_floats[2], t.getBasis().getRow(3).m_floats[3]);
}

This is the matrix 4:

Code: Select all

//Matrix 4 Class
class MATRIX4
{
public:
	
	//Constructors
	MATRIX4()
	{
		_11 = 0.f, _12 = 0.f, _13 = 0.f, _14 = 0.f;
		_21 = 0.f, _22 = 0.f, _23 = 0.f, _24 = 0.f;
		_31 = 0.f, _32 = 0.f, _33 = 0.f, _34 = 0.f;
		_41 = 0.f, _42 = 0.f, _43 = 0.f, _44 = 0.f;
	}

	MATRIX4(float i11, float i12, float i13, float i14,
            float i21, float i22, float i23, float i24,
            float i31, float i32, float i33, float i34,
            float i41, float i42, float i43, float i44)
	{
		_11 = i11, _12 = i12, _13 = i13, _14 = i14;
		_21 = i21, _22 = i22, _23 = i23, _24 = i24;
		_31 = i31, _32 = i32, _33 = i33, _34 = i34;
		_41 = i41, _42 = i42, _43 = i43, _44 = i44;
	}

	MATRIX4(const MATRIX4& m)
	{
		_11 = m._11, _12 = m._12, _13 = m._13, _14 = m._14;
		_21 = m._21, _22 = m._22, _23 = m._23, _24 = m._24;
		_31 = m._31, _32 = m._32, _33 = m._33, _34 = m._34;
		_41 = m._41, _42 = m._42, _43 = m._43, _44 = m._44;
	}

	MATRIX4(const D3DXMATRIX& m)
	{
		_11 = m._11, _12 = m._12, _13 = m._13, _14 = m._14;
		_21 = m._21, _22 = m._22, _23 = m._23, _24 = m._24;
		_31 = m._31, _32 = m._32, _33 = m._33, _34 = m._34;
		_41 = m._41, _42 = m._42, _43 = m._43, _44 = m._44;
	}

	MATRIX4(const D3DXMATRIXA16& m)
	{
		_11 = m._11, _12 = m._12, _13 = m._13, _14 = m._14;
		_21 = m._21, _22 = m._22, _23 = m._23, _24 = m._24;
		_31 = m._31, _32 = m._32, _33 = m._33, _34 = m._34;
		_41 = m._41, _42 = m._42, _43 = m._43, _44 = m._44;
	}

	MATRIX4(const float* m)
	{
		_11 = m[0], _12 = m[1], _13 = m[2], _14 = m[3];
		_21 = m[4], _22 = m[5], _23 = m[6], _24 = m[7];
		_31 = m[8], _32 = m[9], _33 = m[10], _34 = m[11];
		_41 = m[12], _42 = m[13], _43 = m[14], _44 = m[15];
	}


	//Operator Overloads
	MATRIX4 operator*(const MATRIX4& rhs)
	{
		return MATRIX4(
						(_11 * rhs._11) + (_12 * rhs._21) + (_13 * rhs._31) + (_14 * rhs._41),
						(_11 * rhs._12) + (_12 * rhs._22) + (_13 * rhs._32) + (_14 * rhs._42),
						(_11 * rhs._13) + (_12 * rhs._23) + (_13 * rhs._33) + (_14 * rhs._43),
						(_11 * rhs._14) + (_12 * rhs._24) + (_13 * rhs._34) + (_14 * rhs._44),

						(_21 * rhs._11) + (_22 * rhs._21) + (_23 * rhs._31) + (_24 * rhs._41),
						(_21 * rhs._12) + (_22 * rhs._22) + (_23 * rhs._32) + (_24 * rhs._42),
						(_21 * rhs._13) + (_22 * rhs._23) + (_23 * rhs._33) + (_24 * rhs._43),
						(_21 * rhs._14) + (_22 * rhs._24) + (_23 * rhs._34) + (_24 * rhs._44),

						(_31 * rhs._11) + (_32 * rhs._21) + (_33 * rhs._31) + (_34 * rhs._41),
						(_31 * rhs._12) + (_32 * rhs._22) + (_33 * rhs._32) + (_34 * rhs._42),
						(_31 * rhs._13) + (_32 * rhs._23) + (_33 * rhs._33) + (_34 * rhs._43),
						(_31 * rhs._14) + (_32 * rhs._24) + (_33 * rhs._34) + (_34 * rhs._44),

						(_41 * rhs._11) + (_42 * rhs._21) + (_43 * rhs._31) + (_44 * rhs._41),
						(_41 * rhs._12) + (_42 * rhs._22) + (_43 * rhs._32) + (_44 * rhs._42),
						(_41 * rhs._13) + (_42 * rhs._23) + (_43 * rhs._33) + (_44 * rhs._43),
						(_41 * rhs._14) + (_42 * rhs._24) + (_43 * rhs._34) + (_44 * rhs._44)
					   );
	}

	MATRIX4& operator*=(MATRIX4& rhs)
	{
		(*this) = (*this) * rhs;
		return *this;
	}

	MP_INLINE bool operator==(const MATRIX4& rhs)
	{
		if( _11 == rhs._11 && _12 == rhs._12 && _13 == rhs._13 && _14 == rhs._14 &&
			_21 == rhs._21 && _22 == rhs._22 && _23 == rhs._23 && _24 == rhs._24 &&
			_31 == rhs._31 && _32 == rhs._32 && _33 == rhs._33 && _34 == rhs._34 &&
			_41 == rhs._41 && _42 == rhs._42 && _43 == rhs._43 && _44 == rhs._44 )
		{
			return true;
		}

		return false;
	}

	MP_INLINE bool operator!=(const MATRIX4& rhs)
	{
		if( _11 != rhs._11 && _12 != rhs._12 && _13 != rhs._13 && _14 != rhs._14 &&
			_21 != rhs._21 && _22 != rhs._22 && _23 != rhs._23 && _24 != rhs._24 &&
			_31 != rhs._31 && _32 != rhs._32 && _33 != rhs._33 && _34 != rhs._34 &&
			_41 != rhs._41 && _42 != rhs._42 && _43 != rhs._43 && _44 != rhs._44 )
		{
			return true;
		}

		return false;
	}

	//Casting Overloads
	operator float*() const
	{
		return (float*)&_11;
	}

	//Data Members
	float _11, _12, _13, _14;
	float _21, _22, _23, _24;
	float _31, _32, _33, _34;
	float _41, _42, _43, _44;
};

[MrPuff]

Fixed it, boy do I feel a bit like a retard now. seesh.