NoEdge/Danbias
NoEdge
/
Danbias
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Major StateStruct and API update

This commit is contained in:
Dander7BD 2013-12-18 14:16:13 +01:00
parent 96bf20e5ae
commit 5051a9e767
18 changed files with 724 additions and 490 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
Bin/DLL/GamePhysics_x86D.pdb
View File

Binary file not shown.

170
Code/GamePhysics/Implementation/PhysicsAPI_Impl.cpp
View File

@ -171,91 +171,91 @@ void API_Impl::DestroyObject( const ICustomBody* objRef )
} }
} }
void API_Impl::ApplyForceAt( const ICustomBody* objRef, const Float3 &worldPos, const Float3 &worldF ) //void API_Impl::ApplyForceAt( const ICustomBody* objRef, const Float3 &worldPos, const Float3 &worldF )
{ //{
unsigned int tempRef = this->worldScene.GetTemporaryReferenceOf( objRef ); // unsigned int tempRef = this->worldScene.GetTemporaryReferenceOf( objRef );
if( tempRef != this->worldScene.invalid_ref ) // if( tempRef != this->worldScene.invalid_ref )
{ // {
//this->worldScene.GetCustomBody( tempRef )->Apply //!< @todo TODO: need function // //this->worldScene.GetCustomBody( tempRef )->Apply //!< @todo TODO: need function
this->worldScene.SetAsAltered( tempRef ); // this->worldScene.SetAsAltered( tempRef );
} // }
} //}
//
void API_Impl::SetMomentOfInertiaTensor_KeepVelocity( const ICustomBody* objRef, const Float4x4 &localI ) //void API_Impl::SetMomentOfInertiaTensor_KeepVelocity( const ICustomBody* objRef, const Float4x4 &localI )
{ // deprecated //{ // deprecated
unsigned int tempRef = this->worldScene.GetTemporaryReferenceOf( objRef ); // unsigned int tempRef = this->worldScene.GetTemporaryReferenceOf( objRef );
if( tempRef != this->worldScene.invalid_ref ) // if( tempRef != this->worldScene.invalid_ref )
{ // {
this->worldScene.GetCustomBody( tempRef )->SetMomentOfInertiaTensor_KeepVelocity( localI ); // this->worldScene.GetCustomBody( tempRef )->SetMomentOfInertiaTensor_KeepVelocity( localI );
} // }
} //}
//
void API_Impl::SetMomentOfInertiaTensor_KeepMomentum( const ICustomBody* objRef, const Float4x4 &localI ) //void API_Impl::SetMomentOfInertiaTensor_KeepMomentum( const ICustomBody* objRef, const Float4x4 &localI )
{ // deprecated //{ // deprecated
unsigned int tempRef = this->worldScene.GetTemporaryReferenceOf( objRef ); // unsigned int tempRef = this->worldScene.GetTemporaryReferenceOf( objRef );
if( tempRef != this->worldScene.invalid_ref ) // if( tempRef != this->worldScene.invalid_ref )
{ // {
this->worldScene.GetCustomBody( tempRef )->SetMomentOfInertiaTensor_KeepMomentum( localI ); // this->worldScene.GetCustomBody( tempRef )->SetMomentOfInertiaTensor_KeepMomentum( localI );
} // }
} //}
//
void API_Impl::SetMass_KeepVelocity( const ICustomBody* objRef, Float m ) //void API_Impl::SetMass_KeepVelocity( const ICustomBody* objRef, Float m )
{ // deprecated //{ // deprecated
unsigned int tempRef = this->worldScene.GetTemporaryReferenceOf( objRef ); // unsigned int tempRef = this->worldScene.GetTemporaryReferenceOf( objRef );
if( tempRef != this->worldScene.invalid_ref ) // if( tempRef != this->worldScene.invalid_ref )
{ // {
this->worldScene.GetCustomBody( tempRef )->SetMass_KeepVelocity( m ); // this->worldScene.GetCustomBody( tempRef )->SetMass_KeepVelocity( m );
} // }
} //}
//
void API_Impl::SetMass_KeepMomentum( const ICustomBody* objRef, Float m ) //void API_Impl::SetMass_KeepMomentum( const ICustomBody* objRef, Float m )
{ // deprecated //{ // deprecated
unsigned int tempRef = this->worldScene.GetTemporaryReferenceOf( objRef ); // unsigned int tempRef = this->worldScene.GetTemporaryReferenceOf( objRef );
if( tempRef != this->worldScene.invalid_ref ) // if( tempRef != this->worldScene.invalid_ref )
{ // {
this->worldScene.GetCustomBody( tempRef )->SetMass_KeepMomentum( m ); // this->worldScene.GetCustomBody( tempRef )->SetMass_KeepMomentum( m );
} // }
} //}
//
void API_Impl::SetCenter( const ICustomBody* objRef, const Float3 &worldPos ) //void API_Impl::SetCenter( const ICustomBody* objRef, const Float3 &worldPos )
{ //{
unsigned int tempRef = this->worldScene.GetTemporaryReferenceOf( objRef ); // unsigned int tempRef = this->worldScene.GetTemporaryReferenceOf( objRef );
if( tempRef != this->worldScene.invalid_ref ) // if( tempRef != this->worldScene.invalid_ref )
{ // {
//this->worldScene.GetCustomBody( tempRef )->Set //!< @todo TODO: need function // //this->worldScene.GetCustomBody( tempRef )->Set //!< @todo TODO: need function
this->worldScene.EvaluatePosition( tempRef ); // this->worldScene.EvaluatePosition( tempRef );
} // }
} //}
//
void API_Impl::SetRotation( const ICustomBody* objRef, const Float4x4 &rotation ) //void API_Impl::SetRotation( const ICustomBody* objRef, const Float4x4 &rotation )
{ //{
unsigned int tempRef = this->worldScene.GetTemporaryReferenceOf( objRef ); // unsigned int tempRef = this->worldScene.GetTemporaryReferenceOf( objRef );
if( tempRef != this->worldScene.invalid_ref ) // if( tempRef != this->worldScene.invalid_ref )
{ // {
this->worldScene.GetCustomBody( tempRef )->SetRotation( rotation ); // this->worldScene.GetCustomBody( tempRef )->SetRotation( rotation );
this->worldScene.EvaluatePosition( tempRef ); // this->worldScene.EvaluatePosition( tempRef );
} // }
} //}
//
void API_Impl::SetOrientation( const ICustomBody* objRef, const Float4x4 &orientation ) //void API_Impl::SetOrientation( const ICustomBody* objRef, const Float4x4 &orientation )
{ //{
unsigned int tempRef = this->worldScene.GetTemporaryReferenceOf( objRef ); // unsigned int tempRef = this->worldScene.GetTemporaryReferenceOf( objRef );
if( tempRef != this->worldScene.invalid_ref ) // if( tempRef != this->worldScene.invalid_ref )
{ // {
this->worldScene.GetCustomBody( tempRef )->SetOrientation( orientation ); // this->worldScene.GetCustomBody( tempRef )->SetOrientation( orientation );
this->worldScene.EvaluatePosition( tempRef ); // this->worldScene.EvaluatePosition( tempRef );
} // }
} //}
//
void API_Impl::SetSize( const ICustomBody* objRef, const Float3 &size ) //void API_Impl::SetSize( const ICustomBody* objRef, const Float3 &size )
{ //{
unsigned int tempRef = this->worldScene.GetTemporaryReferenceOf( objRef ); // unsigned int tempRef = this->worldScene.GetTemporaryReferenceOf( objRef );
if( tempRef != this->worldScene.invalid_ref ) // if( tempRef != this->worldScene.invalid_ref )
{ // {
this->worldScene.GetCustomBody( tempRef )->SetSize( size ); // this->worldScene.GetCustomBody( tempRef )->SetSize( size );
this->worldScene.EvaluatePosition( tempRef ); // this->worldScene.EvaluatePosition( tempRef );
} // }
} //}
UniquePointer<ICustomBody> API_Impl::CreateRigidBody( const API::SimpleBodyDescription &desc ) const UniquePointer<ICustomBody> API_Impl::CreateRigidBody( const API::SimpleBodyDescription &desc ) const
{ {

18
Code/GamePhysics/Implementation/PhysicsAPI_Impl.h
View File

@ -30,16 +30,16 @@ namespace Oyster
::Utility::DynamicMemory::UniquePointer<ICustomBody> ExtractObject( const ICustomBody* objRef ); ::Utility::DynamicMemory::UniquePointer<ICustomBody> ExtractObject( const ICustomBody* objRef );
void DestroyObject( const ICustomBody* objRef ); void DestroyObject( const ICustomBody* objRef );
void ApplyForceAt( const ICustomBody* objRef, const ::Oyster::Math::Float3 &worldPos, const ::Oyster::Math::Float3 &worldF ); //void ApplyForceAt( const ICustomBody* objRef, const ::Oyster::Math::Float3 &worldPos, const ::Oyster::Math::Float3 &worldF );
void SetMomentOfInertiaTensor_KeepVelocity( const ICustomBody* objRef, const ::Oyster::Math::Float4x4 &localI ); //void SetMomentOfInertiaTensor_KeepVelocity( const ICustomBody* objRef, const ::Oyster::Math::Float4x4 &localI );
void SetMomentOfInertiaTensor_KeepMomentum( const ICustomBody* objRef, const ::Oyster::Math::Float4x4 &localI ); //void SetMomentOfInertiaTensor_KeepMomentum( const ICustomBody* objRef, const ::Oyster::Math::Float4x4 &localI );
void SetMass_KeepVelocity( const ICustomBody* objRef, ::Oyster::Math::Float m ); //void SetMass_KeepVelocity( const ICustomBody* objRef, ::Oyster::Math::Float m );
void SetMass_KeepMomentum( const ICustomBody* objRef, ::Oyster::Math::Float m ); //void SetMass_KeepMomentum( const ICustomBody* objRef, ::Oyster::Math::Float m );
void SetCenter( const ICustomBody* objRef, const ::Oyster::Math::Float3 &worldPos ); //void SetCenter( const ICustomBody* objRef, const ::Oyster::Math::Float3 &worldPos );
void SetRotation( const ICustomBody* objRef, const ::Oyster::Math::Float4x4 &rotation ); //void SetRotation( const ICustomBody* objRef, const ::Oyster::Math::Float4x4 &rotation );
void SetOrientation( const ICustomBody* objRef, const ::Oyster::Math::Float4x4 &orientation ); //void SetOrientation( const ICustomBody* objRef, const ::Oyster::Math::Float4x4 &orientation );
void SetSize( const ICustomBody* objRef, const ::Oyster::Math::Float3 &size ); //void SetSize( const ICustomBody* objRef, const ::Oyster::Math::Float3 &size );
::Utility::DynamicMemory::UniquePointer<ICustomBody> CreateRigidBody( const SimpleBodyDescription &desc ) const; ::Utility::DynamicMemory::UniquePointer<ICustomBody> CreateRigidBody( const SimpleBodyDescription &desc ) const;
::Utility::DynamicMemory::UniquePointer<ICustomBody> CreateRigidBody( const SphericalBodyDescription &desc ) const; ::Utility::DynamicMemory::UniquePointer<ICustomBody> CreateRigidBody( const SphericalBodyDescription &desc ) const;

138
Code/GamePhysics/Implementation/SimpleRigidBody.cpp
View File

@ -18,7 +18,7 @@ SimpleRigidBody::SimpleRigidBody()
SimpleRigidBody::SimpleRigidBody( const API::SimpleBodyDescription &desc ) SimpleRigidBody::SimpleRigidBody( const API::SimpleBodyDescription &desc )
{ {
this->rigid = RigidBody( Box( desc.rotation, desc.centerPosition, desc.size ), this->rigid = RigidBody( Box( desc.rotation, desc.centerPosition.xyz, desc.size.xyz ),
desc.mass, desc.mass,
desc.inertiaTensor ); desc.inertiaTensor );
this->gravityNormal = Float3::null; this->gravityNormal = Float3::null;
@ -44,12 +44,18 @@ UniquePointer<ICustomBody> SimpleRigidBody::Clone() const
SimpleRigidBody::State SimpleRigidBody::GetState() const SimpleRigidBody::State SimpleRigidBody::GetState() const
{ {
return State( this->rigid.box.boundingOffset.xyz, this->rigid.box.center.xyz, AngularAxis(this->rigid.box.rotation).xyz, this->rigid.linearMomentum, this->rigid.angularMomentum ); return State( this->rigid.GetMass(), this->rigid.restitutionCoeff, this->rigid.frictionCoeff,
this->rigid.GetMomentOfInertia(), this->rigid.box.boundingOffset,
this->rigid.box.center, AngularAxis(this->rigid.box.rotation),
Float4(this->rigid.linearMomentum, 0.0f), Float4(this->rigid.angularMomentum, 0.0f) );
} }
SimpleRigidBody::State & SimpleRigidBody::GetState( SimpleRigidBody::State &targetMem ) const SimpleRigidBody::State & SimpleRigidBody::GetState( SimpleRigidBody::State &targetMem ) const
{ {
return targetMem = State( this->rigid.box.boundingOffset.xyz, this->rigid.box.center.xyz, AngularAxis(this->rigid.box.rotation).xyz, this->rigid.linearMomentum, this->rigid.angularMomentum ); return targetMem = State( this->rigid.GetMass(), this->rigid.restitutionCoeff, this->rigid.frictionCoeff,
this->rigid.GetMomentOfInertia(), this->rigid.box.boundingOffset,
this->rigid.box.center, AngularAxis(this->rigid.box.rotation),
Float4(this->rigid.linearMomentum, 0.0f), Float4(this->rigid.angularMomentum, 0.0f) );
} }
void SimpleRigidBody::SetState( const SimpleRigidBody::State &state ) void SimpleRigidBody::SetState( const SimpleRigidBody::State &state )
@ -100,25 +106,25 @@ Float3 & SimpleRigidBody::GetGravityNormal( Float3 &targetMem ) const
return targetMem = this->gravityNormal; return targetMem = this->gravityNormal;
} }
Float3 & SimpleRigidBody::GetCenter( Float3 &targetMem ) const //Float3 & SimpleRigidBody::GetCenter( Float3 &targetMem ) const
{ //{
return targetMem = this->rigid.box.center; // return targetMem = this->rigid.box.center;
} //}
//
Float4x4 & SimpleRigidBody::GetRotation( Float4x4 &targetMem ) const //Float4x4 & SimpleRigidBody::GetRotation( Float4x4 &targetMem ) const
{ //{
return targetMem = this->rigid.box.rotation; // return targetMem = this->rigid.box.rotation;
} //}
//
Float4x4 & SimpleRigidBody::GetOrientation( Float4x4 &targetMem ) const //Float4x4 & SimpleRigidBody::GetOrientation( Float4x4 &targetMem ) const
{ //{
return targetMem = this->rigid.GetOrientation(); // return targetMem = this->rigid.GetOrientation();
} //}
//
Float4x4 & SimpleRigidBody::GetView( Float4x4 &targetMem ) const //Float4x4 & SimpleRigidBody::GetView( Float4x4 &targetMem ) const
{ //{
return targetMem = this->rigid.GetView(); // return targetMem = this->rigid.GetView();
} //}
Float3 SimpleRigidBody::GetRigidLinearVelocity() const Float3 SimpleRigidBody::GetRigidLinearVelocity() const
{ {
@ -158,47 +164,47 @@ void SimpleRigidBody::SetGravityNormal( const Float3 &normalizedVector )
this->gravityNormal = normalizedVector; this->gravityNormal = normalizedVector;
} }
void SimpleRigidBody::SetMomentOfInertiaTensor_KeepVelocity( const Float4x4 &localI ) //void SimpleRigidBody::SetMomentOfInertiaTensor_KeepVelocity( const Float4x4 &localI )
{ //{
this->rigid.SetMomentOfInertia_KeepVelocity( localI ); // this->rigid.SetMomentOfInertia_KeepVelocity( localI );
} //}
//
void SimpleRigidBody::SetMomentOfInertiaTensor_KeepMomentum( const Float4x4 &localI ) //void SimpleRigidBody::SetMomentOfInertiaTensor_KeepMomentum( const Float4x4 &localI )
{ //{
this->rigid.SetMomentOfInertia_KeepMomentum( localI ); // this->rigid.SetMomentOfInertia_KeepMomentum( localI );
} //}
//
void SimpleRigidBody::SetMass_KeepVelocity( Float m ) //void SimpleRigidBody::SetMass_KeepVelocity( Float m )
{ //{
this->rigid.SetMass_KeepVelocity( m ); // this->rigid.SetMass_KeepVelocity( m );
} //}
//
void SimpleRigidBody::SetMass_KeepMomentum( Float m ) //void SimpleRigidBody::SetMass_KeepMomentum( Float m )
{ //{
this->rigid.SetMass_KeepMomentum( m ); // this->rigid.SetMass_KeepMomentum( m );
} //}
//
void SimpleRigidBody::SetCenter( const Float3 &worldPos ) //void SimpleRigidBody::SetCenter( const Float3 &worldPos )
{ //{
this->rigid.SetCenter( worldPos ); // this->rigid.SetCenter( worldPos );
} //}
//
void SimpleRigidBody::SetRotation( const Float4x4 &rotation ) //void SimpleRigidBody::SetRotation( const Float4x4 &rotation )
{ //{
this->rigid.SetRotation( rotation ); // this->rigid.SetRotation( rotation );
} //}
//
void SimpleRigidBody::SetOrientation( const Float4x4 &orientation ) //void SimpleRigidBody::SetOrientation( const Float4x4 &orientation )
{ //{
this->rigid.SetOrientation( orientation ); // this->rigid.SetOrientation( orientation );
} //}
//
void SimpleRigidBody::SetSize( const Float3 &size ) //void SimpleRigidBody::SetSize( const Float3 &size )
{ //{
this->rigid.SetSize( size ); // this->rigid.SetSize( size );
} //}
//
void SimpleRigidBody::SetMomentum( const Float3 &worldG ) //void SimpleRigidBody::SetMomentum( const Float3 &worldG )
{ //{
this->rigid.SetLinearMomentum( worldG ); // this->rigid.SetLinearMomentum( worldG );
} //}

26
Code/GamePhysics/Implementation/SimpleRigidBody.h
View File

@ -29,25 +29,25 @@ namespace Oyster { namespace Physics
::Oyster::Collision3D::Sphere & GetBoundingSphere( ::Oyster::Collision3D::Sphere &targetMem = ::Oyster::Collision3D::Sphere() ) const; ::Oyster::Collision3D::Sphere & GetBoundingSphere( ::Oyster::Collision3D::Sphere &targetMem = ::Oyster::Collision3D::Sphere() ) const;
::Oyster::Math::Float4 & GetNormalAt( const ::Oyster::Math::Float4 &worldPos, ::Oyster::Math::Float4 &targetMem = ::Oyster::Math::Float4() ) const; ::Oyster::Math::Float4 & GetNormalAt( const ::Oyster::Math::Float4 &worldPos, ::Oyster::Math::Float4 &targetMem = ::Oyster::Math::Float4() ) const;
::Oyster::Math::Float3 & GetGravityNormal( ::Oyster::Math::Float3 &targetMem = ::Oyster::Math::Float3() ) const; ::Oyster::Math::Float3 & GetGravityNormal( ::Oyster::Math::Float3 &targetMem = ::Oyster::Math::Float3() ) const;
::Oyster::Math::Float3 & GetCenter( ::Oyster::Math::Float3 &targetMem = ::Oyster::Math::Float3() ) const; //::Oyster::Math::Float3 & GetCenter( ::Oyster::Math::Float3 &targetMem = ::Oyster::Math::Float3() ) const;
::Oyster::Math::Float4x4 & GetRotation( ::Oyster::Math::Float4x4 &targetMem = ::Oyster::Math::Float4x4() ) const; //::Oyster::Math::Float4x4 & GetRotation( ::Oyster::Math::Float4x4 &targetMem = ::Oyster::Math::Float4x4() ) const;
::Oyster::Math::Float4x4 & GetOrientation( ::Oyster::Math::Float4x4 &targetMem = ::Oyster::Math::Float4x4() ) const; //::Oyster::Math::Float4x4 & GetOrientation( ::Oyster::Math::Float4x4 &targetMem = ::Oyster::Math::Float4x4() ) const;
::Oyster::Math::Float4x4 & GetView( ::Oyster::Math::Float4x4 &targetMem = ::Oyster::Math::Float4x4() ) const; //::Oyster::Math::Float4x4 & GetView( ::Oyster::Math::Float4x4 &targetMem = ::Oyster::Math::Float4x4() ) const;
UpdateState Update( ::Oyster::Math::Float timeStepLength ); UpdateState Update( ::Oyster::Math::Float timeStepLength );
void SetSubscription( EventAction_Collision functionPointer ); void SetSubscription( EventAction_Collision functionPointer );
void SetGravity( bool ignore); void SetGravity( bool ignore);
void SetGravityNormal( const ::Oyster::Math::Float3 &normalizedVector ); void SetGravityNormal( const ::Oyster::Math::Float3 &normalizedVector );
void SetMomentOfInertiaTensor_KeepVelocity( const ::Oyster::Math::Float4x4 &localI ); //void SetMomentOfInertiaTensor_KeepVelocity( const ::Oyster::Math::Float4x4 &localI );
void SetMomentOfInertiaTensor_KeepMomentum( const ::Oyster::Math::Float4x4 &localI ); //void SetMomentOfInertiaTensor_KeepMomentum( const ::Oyster::Math::Float4x4 &localI );
void SetMass_KeepVelocity( ::Oyster::Math::Float m ); //void SetMass_KeepVelocity( ::Oyster::Math::Float m );
void SetMass_KeepMomentum( ::Oyster::Math::Float m ); //void SetMass_KeepMomentum( ::Oyster::Math::Float m );
void SetCenter( const ::Oyster::Math::Float3 &worldPos ); //void SetCenter( const ::Oyster::Math::Float3 &worldPos );
void SetRotation( const ::Oyster::Math::Float4x4 &rotation ); //void SetRotation( const ::Oyster::Math::Float4x4 &rotation );
void SetOrientation( const ::Oyster::Math::Float4x4 &orientation ); //void SetOrientation( const ::Oyster::Math::Float4x4 &orientation );
void SetSize( const ::Oyster::Math::Float3 &size ); //void SetSize( const ::Oyster::Math::Float3 &size );
void SetMomentum( const ::Oyster::Math::Float3 &worldG ); //void SetMomentum( const ::Oyster::Math::Float3 &worldG );
private: private:
::Oyster::Physics3D::RigidBody rigid; ::Oyster::Physics3D::RigidBody rigid;

145
Code/GamePhysics/Implementation/SphericalRigidBody.cpp
View File

@ -19,7 +19,7 @@ SphericalRigidBody::SphericalRigidBody()
SphericalRigidBody::SphericalRigidBody( const API::SphericalBodyDescription &desc ) SphericalRigidBody::SphericalRigidBody( const API::SphericalBodyDescription &desc )
{ {
this->rigid = RigidBody( Box( desc.rotation, desc.centerPosition, Float3(2.0f * desc.radius) ), this->rigid = RigidBody( Box( desc.rotation, desc.centerPosition.xyz, Float3(2.0f * desc.radius) ),
desc.mass, desc.mass,
Formula::MomentOfInertia::CreateSphereMatrix( desc.mass, desc.radius ) ); Formula::MomentOfInertia::CreateSphereMatrix( desc.mass, desc.radius ) );
this->gravityNormal = Float3::null; this->gravityNormal = Float3::null;
@ -46,12 +46,18 @@ UniquePointer<ICustomBody> SphericalRigidBody::Clone() const
SphericalRigidBody::State SphericalRigidBody::GetState() const SphericalRigidBody::State SphericalRigidBody::GetState() const
{ {
return State( this->rigid.box.boundingOffset.xyz, this->rigid.box.center.xyz, AngularAxis(this->rigid.box.rotation).xyz, this->rigid.linearMomentum, this->rigid.angularMomentum ); return State( this->rigid.GetMass(), this->rigid.restitutionCoeff, this->rigid.frictionCoeff,
this->rigid.GetMomentOfInertia(), this->rigid.box.boundingOffset,
this->rigid.box.center, AngularAxis(this->rigid.box.rotation),
Float4(this->rigid.linearMomentum, 0.0f), Float4(this->rigid.angularMomentum, 0.0f) );
} }
SphericalRigidBody::State & SphericalRigidBody::GetState( SphericalRigidBody::State &targetMem ) const SphericalRigidBody::State & SphericalRigidBody::GetState( SphericalRigidBody::State &targetMem ) const
{ {
return targetMem = State( this->rigid.box.boundingOffset.xyz, this->rigid.box.center.xyz, AngularAxis(this->rigid.box.rotation).xyz, this->rigid.linearMomentum, this->rigid.angularMomentum ); return targetMem = State( this->rigid.GetMass(), this->rigid.restitutionCoeff, this->rigid.frictionCoeff,
this->rigid.GetMomentOfInertia(), this->rigid.box.boundingOffset,
this->rigid.box.center, AngularAxis(this->rigid.box.rotation),
Float4(this->rigid.linearMomentum, 0.0f), Float4(this->rigid.angularMomentum, 0.0f) );
} }
void SphericalRigidBody::SetState( const SphericalRigidBody::State &state ) void SphericalRigidBody::SetState( const SphericalRigidBody::State &state )
@ -93,7 +99,6 @@ Sphere & SphericalRigidBody::GetBoundingSphere( Sphere &targetMem ) const
Float4 & SphericalRigidBody::GetNormalAt( const Float4 &worldPos, Float4 &targetMem ) const Float4 & SphericalRigidBody::GetNormalAt( const Float4 &worldPos, Float4 &targetMem ) const
{ {
//! @todo TODO: better implementation needed
return targetMem = (worldPos - this->rigid.box.center).GetNormalized(); return targetMem = (worldPos - this->rigid.box.center).GetNormalized();
} }
@ -102,25 +107,25 @@ Float3 & SphericalRigidBody::GetGravityNormal( Float3 &targetMem ) const
return targetMem = this->gravityNormal; return targetMem = this->gravityNormal;
} }
Float3 & SphericalRigidBody::GetCenter( Float3 &targetMem ) const //Float3 & SphericalRigidBody::GetCenter( Float3 &targetMem ) const
{ //{
return targetMem = this->rigid.box.center; // return targetMem = this->rigid.box.center;
} //}
//
Float4x4 & SphericalRigidBody::GetRotation( Float4x4 &targetMem ) const //Float4x4 & SphericalRigidBody::GetRotation( Float4x4 &targetMem ) const
{ //{
return targetMem = this->rigid.box.rotation; // return targetMem = this->rigid.box.rotation;
} //}
//
Float4x4 & SphericalRigidBody::GetOrientation( Float4x4 &targetMem ) const //Float4x4 & SphericalRigidBody::GetOrientation( Float4x4 &targetMem ) const
{ //{
return targetMem = this->rigid.GetOrientation(); // return targetMem = this->rigid.GetOrientation();
} //}
//
Float4x4 & SphericalRigidBody::GetView( Float4x4 &targetMem ) const //Float4x4 & SphericalRigidBody::GetView( Float4x4 &targetMem ) const
{ //{
return targetMem = this->rigid.GetView(); // return targetMem = this->rigid.GetView();
} //}
Float3 SphericalRigidBody::GetRigidLinearVelocity() const Float3 SphericalRigidBody::GetRigidLinearVelocity() const
{ {
@ -160,50 +165,50 @@ void SphericalRigidBody::SetGravityNormal( const Float3 &normalizedVector )
this->gravityNormal = normalizedVector; this->gravityNormal = normalizedVector;
} }
void SphericalRigidBody::SetMomentOfInertiaTensor_KeepVelocity( const Float4x4 &localI ) //void SphericalRigidBody::SetMomentOfInertiaTensor_KeepVelocity( const Float4x4 &localI )
{ //{
this->rigid.SetMomentOfInertia_KeepVelocity( localI ); // this->rigid.SetMomentOfInertia_KeepVelocity( localI );
} //}
//
void SphericalRigidBody::SetMomentOfInertiaTensor_KeepMomentum( const Float4x4 &localI ) //void SphericalRigidBody::SetMomentOfInertiaTensor_KeepMomentum( const Float4x4 &localI )
{ //{
this->rigid.SetMomentOfInertia_KeepMomentum( localI ); // this->rigid.SetMomentOfInertia_KeepMomentum( localI );
} //}
//
void SphericalRigidBody::SetMass_KeepVelocity( Float m ) //void SphericalRigidBody::SetMass_KeepVelocity( Float m )
{ //{
this->rigid.SetMass_KeepVelocity( m ); // this->rigid.SetMass_KeepVelocity( m );
} //}
//
void SphericalRigidBody::SetMass_KeepMomentum( Float m ) //void SphericalRigidBody::SetMass_KeepMomentum( Float m )
{ //{
this->rigid.SetMass_KeepMomentum( m ); // this->rigid.SetMass_KeepMomentum( m );
} //}
//
void SphericalRigidBody::SetCenter( const Float3 &worldPos ) //void SphericalRigidBody::SetCenter( const Float3 &worldPos )
{ //{
this->rigid.SetCenter( worldPos ); // this->rigid.SetCenter( worldPos );
this->body.center = worldPos; // this->body.center = worldPos;
} //}
//
void SphericalRigidBody::SetRotation( const Float4x4 &rotation ) //void SphericalRigidBody::SetRotation( const Float4x4 &rotation )
{ //{
this->rigid.SetRotation( rotation ); // this->rigid.SetRotation( rotation );
} //}
//
void SphericalRigidBody::SetOrientation( const Float4x4 &orientation ) //void SphericalRigidBody::SetOrientation( const Float4x4 &orientation )
{ //{
this->rigid.SetOrientation( orientation ); // this->rigid.SetOrientation( orientation );
this->body.center = orientation.v[3].xyz; // this->body.center = orientation.v[3].xyz;
} //}
//
void SphericalRigidBody::SetSize( const Float3 &size ) //void SphericalRigidBody::SetSize( const Float3 &size )
{ //{
this->rigid.SetSize( size ); // this->rigid.SetSize( size );
this->body.radius = 0.5f * Min( Min( size.x, size.y ), size.z ); // inline Min( FloatN )? // this->body.radius = 0.5f * Min( Min( size.x, size.y ), size.z ); // inline Min( FloatN )?
} //}
//
void SphericalRigidBody::SetMomentum( const Float3 &worldG ) //void SphericalRigidBody::SetMomentum( const Float3 &worldG )
{ //{
this->rigid.SetLinearMomentum( worldG ); // this->rigid.SetLinearMomentum( worldG );
} //}

26
Code/GamePhysics/Implementation/SphericalRigidBody.h
View File

@ -30,25 +30,25 @@ namespace Oyster { namespace Physics
::Oyster::Collision3D::Sphere & GetBoundingSphere( ::Oyster::Collision3D::Sphere &targetMem = ::Oyster::Collision3D::Sphere() ) const; ::Oyster::Collision3D::Sphere & GetBoundingSphere( ::Oyster::Collision3D::Sphere &targetMem = ::Oyster::Collision3D::Sphere() ) const;
::Oyster::Math::Float4 & GetNormalAt( const ::Oyster::Math::Float4 &worldPos, ::Oyster::Math::Float4 &targetMem = ::Oyster::Math::Float4() ) const; ::Oyster::Math::Float4 & GetNormalAt( const ::Oyster::Math::Float4 &worldPos, ::Oyster::Math::Float4 &targetMem = ::Oyster::Math::Float4() ) const;
::Oyster::Math::Float3 & GetGravityNormal( ::Oyster::Math::Float3 &targetMem = ::Oyster::Math::Float3() ) const; ::Oyster::Math::Float3 & GetGravityNormal( ::Oyster::Math::Float3 &targetMem = ::Oyster::Math::Float3() ) const;
::Oyster::Math::Float3 & GetCenter( ::Oyster::Math::Float3 &targetMem = ::Oyster::Math::Float3() ) const; //::Oyster::Math::Float3 & GetCenter( ::Oyster::Math::Float3 &targetMem = ::Oyster::Math::Float3() ) const;
::Oyster::Math::Float4x4 & GetRotation( ::Oyster::Math::Float4x4 &targetMem = ::Oyster::Math::Float4x4() ) const; //::Oyster::Math::Float4x4 & GetRotation( ::Oyster::Math::Float4x4 &targetMem = ::Oyster::Math::Float4x4() ) const;
::Oyster::Math::Float4x4 & GetOrientation( ::Oyster::Math::Float4x4 &targetMem = ::Oyster::Math::Float4x4() ) const; //::Oyster::Math::Float4x4 & GetOrientation( ::Oyster::Math::Float4x4 &targetMem = ::Oyster::Math::Float4x4() ) const;
::Oyster::Math::Float4x4 & GetView( ::Oyster::Math::Float4x4 &targetMem = ::Oyster::Math::Float4x4() ) const; //::Oyster::Math::Float4x4 & GetView( ::Oyster::Math::Float4x4 &targetMem = ::Oyster::Math::Float4x4() ) const;
UpdateState Update( ::Oyster::Math::Float timeStepLength ); UpdateState Update( ::Oyster::Math::Float timeStepLength );
void SetSubscription( EventAction_Collision functionPointer ); void SetSubscription( EventAction_Collision functionPointer );
void SetGravity( bool ignore); void SetGravity( bool ignore);
void SetGravityNormal( const ::Oyster::Math::Float3 &normalizedVector ); void SetGravityNormal( const ::Oyster::Math::Float3 &normalizedVector );
void SetMomentOfInertiaTensor_KeepVelocity( const ::Oyster::Math::Float4x4 &localI ); //void SetMomentOfInertiaTensor_KeepVelocity( const ::Oyster::Math::Float4x4 &localI );
void SetMomentOfInertiaTensor_KeepMomentum( const ::Oyster::Math::Float4x4 &localI ); //void SetMomentOfInertiaTensor_KeepMomentum( const ::Oyster::Math::Float4x4 &localI );
void SetMass_KeepVelocity( ::Oyster::Math::Float m ); //void SetMass_KeepVelocity( ::Oyster::Math::Float m );
void SetMass_KeepMomentum( ::Oyster::Math::Float m ); //void SetMass_KeepMomentum( ::Oyster::Math::Float m );
void SetCenter( const ::Oyster::Math::Float3 &worldPos ); //void SetCenter( const ::Oyster::Math::Float3 &worldPos );
void SetRotation( const ::Oyster::Math::Float4x4 &rotation ); //void SetRotation( const ::Oyster::Math::Float4x4 &rotation );
void SetOrientation( const ::Oyster::Math::Float4x4 &orientation ); //void SetOrientation( const ::Oyster::Math::Float4x4 &orientation );
void SetSize( const ::Oyster::Math::Float3 &size ); //void SetSize( const ::Oyster::Math::Float3 &size );
void SetMomentum( const ::Oyster::Math::Float3 &worldG ); //void SetMomentum( const ::Oyster::Math::Float3 &worldG );
private: private:
::Oyster::Physics3D::RigidBody rigid; ::Oyster::Physics3D::RigidBody rigid;

282
Code/GamePhysics/PhysicsAPI.h
View File

@ -124,73 +124,73 @@ namespace Oyster
********************************************************/ ********************************************************/
virtual void DestroyObject( const ICustomBody* objRef ) = 0; virtual void DestroyObject( const ICustomBody* objRef ) = 0;
/******************************************************** ///********************************************************
* Apply force on an object. // * Apply force on an object.
* @param objRef: A pointer to the ICustomBody representing a physical object. // * @param objRef: A pointer to the ICustomBody representing a physical object.
* @param worldPos: Relative to the world origo. (Not relative to object) [m] // * @param worldPos: Relative to the world origo. (Not relative to object) [m]
* @param worldF: Vector with the direction and magnitude of the force. [N] // * @param worldF: Vector with the direction and magnitude of the force. [N]
********************************************************/ // ********************************************************/
virtual void ApplyForceAt( const ICustomBody* objRef, const ::Oyster::Math::Float3 &worldPos, const ::Oyster::Math::Float3 &worldF ) = 0; //virtual void ApplyForceAt( const ICustomBody* objRef, const ::Oyster::Math::Float3 &worldPos, const ::Oyster::Math::Float3 &worldF ) = 0;
/******************************************************** ///********************************************************
* Sets the MomentOfInertia tensor matrix of an object without changing it's angular velocity. // * Sets the MomentOfInertia tensor matrix of an object without changing it's angular velocity.
* Noticeable effect: The angular momentum will change. Changing the amount of kinetic energy. // * Noticeable effect: The angular momentum will change. Changing the amount of kinetic energy.
* @param objRef: A pointer to the ICustomBody representing a physical object. // * @param objRef: A pointer to the ICustomBody representing a physical object.
* @param localI: The tensor matrix relative to the axises of the object. @see MomentOfInertia namespace. // * @param localI: The tensor matrix relative to the axises of the object. @see MomentOfInertia namespace.
********************************************************/ // ********************************************************/
virtual void SetMomentOfInertiaTensor_KeepVelocity( const ICustomBody* objRef, const ::Oyster::Math::Float4x4 &localI ) = 0; //virtual void SetMomentOfInertiaTensor_KeepVelocity( const ICustomBody* objRef, const ::Oyster::Math::Float4x4 &localI ) = 0;
//
/******************************************************** ///********************************************************
* Sets the MomentOfInertia tensor matrix of an object without changing it's angular momentum. // * Sets the MomentOfInertia tensor matrix of an object without changing it's angular momentum.
* Noticeable effect: The angular velocity will change. Can be used to create slow effects. // * Noticeable effect: The angular velocity will change. Can be used to create slow effects.
* @param objRef: A pointer to the ICustomBody representing a physical object. // * @param objRef: A pointer to the ICustomBody representing a physical object.
* @param localI: The tensor matrix relative to the axises of the object. @see MomentOfInertia namespace. // * @param localI: The tensor matrix relative to the axises of the object. @see MomentOfInertia namespace.
********************************************************/ // ********************************************************/
virtual void SetMomentOfInertiaTensor_KeepMomentum( const ICustomBody* objRef, const ::Oyster::Math::Float4x4 &localI ) = 0; //virtual void SetMomentOfInertiaTensor_KeepMomentum( const ICustomBody* objRef, const ::Oyster::Math::Float4x4 &localI ) = 0;
//
/******************************************************** ///********************************************************
* Sets the mass of an object without changing it's linear velocity. // * Sets the mass of an object without changing it's linear velocity.
* Noticeable effect: The linear momentum will change. Changing the amount of kinetic energy. // * Noticeable effect: The linear momentum will change. Changing the amount of kinetic energy.
* @param objRef: A pointer to the ICustomBody representing a physical object. // * @param objRef: A pointer to the ICustomBody representing a physical object.
* @param m: [kg] // * @param m: [kg]
********************************************************/ // ********************************************************/
virtual void SetMass_KeepVelocity( const ICustomBody* objRef, ::Oyster::Math::Float m ) = 0; //virtual void SetMass_KeepVelocity( const ICustomBody* objRef, ::Oyster::Math::Float m ) = 0;
//
/******************************************************** ///********************************************************
* Sets the mass of an object without changing it's linear velocity. // * Sets the mass of an object without changing it's linear velocity.
* Noticeable effect: The linear velocity will change. Can be used to create slow effects. // * Noticeable effect: The linear velocity will change. Can be used to create slow effects.
* @param objRef: A pointer to the ICustomBody representing a physical object. // * @param objRef: A pointer to the ICustomBody representing a physical object.
* @param m: [kg] // * @param m: [kg]
********************************************************/ // ********************************************************/
virtual void SetMass_KeepMomentum( const ICustomBody* objRef, ::Oyster::Math::Float m ) = 0; //virtual void SetMass_KeepMomentum( const ICustomBody* objRef, ::Oyster::Math::Float m ) = 0;
//
/******************************************************** ///********************************************************
* Instantly moves an object. // * Instantly moves an object.
* @param objRef: A pointer to the ICustomBody representing a physical object. // * @param objRef: A pointer to the ICustomBody representing a physical object.
* @param worldPos: Relative to the world origo. (Not relative to object) [m] // * @param worldPos: Relative to the world origo. (Not relative to object) [m]
********************************************************/ // ********************************************************/
virtual void SetCenter( const ICustomBody* objRef, const ::Oyster::Math::Float3 &worldPos ) = 0; //virtual void SetCenter( const ICustomBody* objRef, const ::Oyster::Math::Float3 &worldPos ) = 0;
//
/******************************************************** ///********************************************************
* Instantly redirects object. // * Instantly redirects object.
* @param objRef: A pointer to the ICustomBody representing a physical object. // * @param objRef: A pointer to the ICustomBody representing a physical object.
* @param rotation: New rotation. // * @param rotation: New rotation.
********************************************************/ // ********************************************************/
virtual void SetRotation( const ICustomBody* objRef, const ::Oyster::Math::Float4x4 &rotation ) = 0; //virtual void SetRotation( const ICustomBody* objRef, const ::Oyster::Math::Float4x4 &rotation ) = 0;
//
/******************************************************** ///********************************************************
* Instantly moves and redirects object. // * Instantly moves and redirects object.
* @param objRef: A pointer to the ICustomBody representing a physical object. // * @param objRef: A pointer to the ICustomBody representing a physical object.
* @param orientation: New orientation. // * @param orientation: New orientation.
********************************************************/ // ********************************************************/
virtual void SetOrientation( const ICustomBody* objRef, const ::Oyster::Math::Float4x4 &orientation ) = 0; //virtual void SetOrientation( const ICustomBody* objRef, const ::Oyster::Math::Float4x4 &orientation ) = 0;
//
/******************************************************** ///********************************************************
* Resizes the boundingBox. // * Resizes the boundingBox.
* @param objRef: A pointer to the ICustomBody representing a physical object. // * @param objRef: A pointer to the ICustomBody representing a physical object.
* @param size: New size of this [m] // * @param size: New size of this [m]
********************************************************/ // ********************************************************/
virtual void SetSize( const ICustomBody* objRef, const ::Oyster::Math::Float3 &size ) = 0; //virtual void SetSize( const ICustomBody* objRef, const ::Oyster::Math::Float3 &size ) = 0;
/******************************************************** /********************************************************
* Creates a new dynamically allocated object that can be used as a component for more complex ICustomBodies. * Creates a new dynamically allocated object that can be used as a component for more complex ICustomBodies.
@ -307,30 +307,30 @@ namespace Oyster
********************************************************/ ********************************************************/
virtual ::Oyster::Math::Float3 & GetGravityNormal( ::Oyster::Math::Float3 &targetMem = ::Oyster::Math::Float3() ) const = 0; virtual ::Oyster::Math::Float3 & GetGravityNormal( ::Oyster::Math::Float3 &targetMem = ::Oyster::Math::Float3() ) const = 0;
/******************************************************** ///********************************************************
* The world position of this center of gravity. // * The world position of this center of gravity.
* @param targetMem: Provided memory that written into and then returned. // * @param targetMem: Provided memory that written into and then returned.
* @return a position in worldSpace. // * @return a position in worldSpace.
********************************************************/ // ********************************************************/
virtual ::Oyster::Math::Float3 & GetCenter( ::Oyster::Math::Float3 &targetMem = ::Oyster::Math::Float3() ) const = 0; //virtual ::Oyster::Math::Float3 & GetCenter( ::Oyster::Math::Float3 &targetMem = ::Oyster::Math::Float3() ) const = 0;
//
/******************************************************** ///********************************************************
* @param targetMem: Provided memory that written into and then returned. // * @param targetMem: Provided memory that written into and then returned.
* @return a copy of this's rotation matrix. // * @return a copy of this's rotation matrix.
********************************************************/ // ********************************************************/
virtual ::Oyster::Math::Float4x4 & GetRotation( ::Oyster::Math::Float4x4 &targetMem = ::Oyster::Math::Float4x4() ) const = 0; //virtual ::Oyster::Math::Float4x4 & GetRotation( ::Oyster::Math::Float4x4 &targetMem = ::Oyster::Math::Float4x4() ) const = 0;
//
/******************************************************** ///********************************************************
* @param targetMem: Provided memory that written into and then returned. // * @param targetMem: Provided memory that written into and then returned.
* @return a copy of this's orientation matrix. // * @return a copy of this's orientation matrix.
********************************************************/ // ********************************************************/
virtual ::Oyster::Math::Float4x4 & GetOrientation( ::Oyster::Math::Float4x4 &targetMem = ::Oyster::Math::Float4x4() ) const = 0; //virtual ::Oyster::Math::Float4x4 & GetOrientation( ::Oyster::Math::Float4x4 &targetMem = ::Oyster::Math::Float4x4() ) const = 0;
//
/******************************************************** ///********************************************************
* @param targetMem: Provided memory that written into and then returned. // * @param targetMem: Provided memory that written into and then returned.
* @return a copy of this's view matrix. // * @return a copy of this's view matrix.
********************************************************/ // ********************************************************/
virtual ::Oyster::Math::Float4x4 & GetView( ::Oyster::Math::Float4x4 &targetMem = ::Oyster::Math::Float4x4() ) const = 0; //virtual ::Oyster::Math::Float4x4 & GetView( ::Oyster::Math::Float4x4 &targetMem = ::Oyster::Math::Float4x4() ) const = 0;
/******************************************************** /********************************************************
* To not be called if is in Engine * To not be called if is in Engine
@ -356,59 +356,59 @@ namespace Oyster
********************************************************/ ********************************************************/
virtual void SetGravityNormal( const ::Oyster::Math::Float3 &normalizedVector ) = 0; virtual void SetGravityNormal( const ::Oyster::Math::Float3 &normalizedVector ) = 0;
/******************************************************** ///********************************************************
* To not be called if is in Engine // * To not be called if is in Engine
* Use API::SetMomentOfInertiaTensor_KeepVelocity(...) instead // * Use API::SetMomentOfInertiaTensor_KeepVelocity(...) instead
********************************************************/ // ********************************************************/
virtual void SetMomentOfInertiaTensor_KeepVelocity( const ::Oyster::Math::Float4x4 &localI ) = 0; //virtual void SetMomentOfInertiaTensor_KeepVelocity( const ::Oyster::Math::Float4x4 &localI ) = 0;
//
///********************************************************
// * To not be called if is in Engine
// * Use API::SetMomentOfInertiaTensor_KeepMomentum(...)
// ********************************************************/
//virtual void SetMomentOfInertiaTensor_KeepMomentum( const ::Oyster::Math::Float4x4 &localI ) = 0;
//
///********************************************************
// * To not be called if is in Engine
// * Use API::SetMass_KeepVelocity(...)
// ********************************************************/
//virtual void SetMass_KeepVelocity( ::Oyster::Math::Float m ) = 0;
//
///********************************************************
// * To not be called if is in Engine
// * Use API::SetMass_KeepMomentum(...)
// ********************************************************/
//virtual void SetMass_KeepMomentum( ::Oyster::Math::Float m ) = 0;
//
///********************************************************
// * To not be called if is in Engine
// * Use API::SetCenter(...)
// ********************************************************/
//virtual void SetCenter( const ::Oyster::Math::Float3 &worldPos ) = 0;
//
///********************************************************
// * To not be called if is in Engine
// * Use API::SetRotation(...)
// ********************************************************/
//virtual void SetRotation( const ::Oyster::Math::Float4x4 &rotation ) = 0;
//
///********************************************************
// * To not be called if is in Engine
// * Use API::SetOrientation(...)
// ********************************************************/
//virtual void SetOrientation( const ::Oyster::Math::Float4x4 &orientation ) = 0;
/******************************************************** ///********************************************************
* To not be called if is in Engine // * To not be called if is in Engine
* Use API::SetMomentOfInertiaTensor_KeepMomentum(...) // * Use API::SetSize(...)
********************************************************/ // ********************************************************/
virtual void SetMomentOfInertiaTensor_KeepMomentum( const ::Oyster::Math::Float4x4 &localI ) = 0; //virtual void SetSize( const ::Oyster::Math::Float3 &size ) = 0;
/******************************************************** ///********************************************************
* To not be called if is in Engine // * To not be called if is in Engine
* Use API::SetMass_KeepVelocity(...) // * Use API::?? @todo TODO:
********************************************************/ // ********************************************************/
virtual void SetMass_KeepVelocity( ::Oyster::Math::Float m ) = 0; //virtual void SetMomentum( const ::Oyster::Math::Float3 &worldG ) = 0;
/********************************************************
* To not be called if is in Engine
* Use API::SetMass_KeepMomentum(...)
********************************************************/
virtual void SetMass_KeepMomentum( ::Oyster::Math::Float m ) = 0;
/********************************************************
* To not be called if is in Engine
* Use API::SetCenter(...)
********************************************************/
virtual void SetCenter( const ::Oyster::Math::Float3 &worldPos ) = 0;
/********************************************************
* To not be called if is in Engine
* Use API::SetRotation(...)
********************************************************/
virtual void SetRotation( const ::Oyster::Math::Float4x4 &rotation ) = 0;
/********************************************************
* To not be called if is in Engine
* Use API::SetOrientation(...)
********************************************************/
virtual void SetOrientation( const ::Oyster::Math::Float4x4 &orientation ) = 0;
/********************************************************
* To not be called if is in Engine
* Use API::SetSize(...)
********************************************************/
virtual void SetSize( const ::Oyster::Math::Float3 &size ) = 0;
/********************************************************
* To not be called if is in Engine
* Use API::?? @todo TODO:
********************************************************/
virtual void SetMomentum( const ::Oyster::Math::Float3 &worldG ) = 0;
}; };
} }
} }

1
Code/GamePhysics/PhysicsFormula-Impl.h
View File

@ -41,6 +41,7 @@ namespace Oyster { namespace Physics { namespace Formula
return (e + 1) * (mB*gA - mA*gB) / (mA + mB); return (e + 1) * (mB*gA - mA*gB) / (mA + mB);
} }
} }
} } } } } }
#endif #endif

1
Code/GamePhysics/PhysicsFormula.h
View File

@ -2,6 +2,7 @@
#define PHYSICS_FORMULA_H #define PHYSICS_FORMULA_H
#include "OysterMath.h" #include "OysterMath.h"
#include "OysterPhysics3D.h"
namespace Oyster { namespace Physics { namespace Formula namespace Oyster { namespace Physics { namespace Formula
{ {

193
Code/GamePhysics/PhysicsStructs-Impl.h
View File

@ -10,8 +10,8 @@ namespace Oyster { namespace Physics
inline SimpleBodyDescription::SimpleBodyDescription() inline SimpleBodyDescription::SimpleBodyDescription()
{ {
this->rotation = ::Oyster::Math::Float4x4::identity; this->rotation = ::Oyster::Math::Float4x4::identity;
this->centerPosition = ::Oyster::Math::Float3::null; this->centerPosition = ::Oyster::Math::Float4::null;
this->size = ::Oyster::Math::Float3( 1.0f ); this->size = ::Oyster::Math::Float4( 1.0f );
this->mass = 12.0f; this->mass = 12.0f;
this->inertiaTensor = ::Oyster::Math::Float4x4::identity; this->inertiaTensor = ::Oyster::Math::Float4x4::identity;
this->subscription = NULL; this->subscription = NULL;
@ -21,36 +21,66 @@ namespace Oyster { namespace Physics
inline SphericalBodyDescription::SphericalBodyDescription() inline SphericalBodyDescription::SphericalBodyDescription()
{ {
this->rotation = ::Oyster::Math::Float4x4::identity; this->rotation = ::Oyster::Math::Float4x4::identity;
this->centerPosition = ::Oyster::Math::Float3::null; this->centerPosition = ::Oyster::Math::Float4::null;
this->radius = 0.5f; this->radius = 0.5f;
this->mass = 10.0f; this->mass = 10.0f;
this->subscription = NULL; this->subscription = NULL;
this->ignoreGravity = false; this->ignoreGravity = false;
} }
inline CustomBodyState::CustomBodyState( const ::Oyster::Math::Float3 &reach, const ::Oyster::Math::Float3 &centerPos, const ::Oyster::Math::Float3 &rotation, const ::Oyster::Math::Float3 &linearMomentum, const ::Oyster::Math::Float3 &angularMomentum ) inline CustomBodyState::CustomBodyState( ::Oyster::Math::Float mass, ::Oyster::Math::Float restitutionCoeff, ::Oyster::Math::Float frictionCoeff, const ::Oyster::Math::Float4x4 &inertiaTensor, const ::Oyster::Math::Float4 &reach, const ::Oyster::Math::Float4 &centerPos, const ::Oyster::Math::Float4 &rotation, const ::Oyster::Math::Float4 &linearMomentum, const ::Oyster::Math::Float4 &angularMomentum )
{ {
this->reach = ::Oyster::Math::Float4( reach, 0.0f ); this->mass = mass;
this->centerPos = ::Oyster::Math::Float4( centerPos, 1.0f ); this->restitutionCoeff = restitutionCoeff;
this->angularAxis = ::Oyster::Math::Float4( rotation, 0.0f ); this->frictionCoeff = frictionCoeff;
this->linearMomentum = ::Oyster::Math::Float4( linearMomentum, 0.0f ); this->inertiaTensor = inertiaTensor;
this->angularMomentum = ::Oyster::Math::Float4( angularMomentum, 0.0f ); this->reach = ::Oyster::Math::Float4( reach.xyz, 0.0f );
this->centerPos = ::Oyster::Math::Float4( centerPos.xyz, 1.0f );
this->angularAxis = ::Oyster::Math::Float4( rotation.xyz, 0.0f );
this->linearMomentum = ::Oyster::Math::Float4( linearMomentum.xyz, 0.0f );
this->angularMomentum = ::Oyster::Math::Float4( angularMomentum.xyz, 0.0f );
this->linearImpulse = this->angularImpulse = ::Oyster::Math::Float4::null;
this->isSpatiallyAltered = this->isDisturbed = false; this->isSpatiallyAltered = this->isDisturbed = false;
} }
inline CustomBodyState & CustomBodyState::operator = ( const CustomBodyState &state ) inline CustomBodyState & CustomBodyState::operator = ( const CustomBodyState &state )
{ {
this->mass = state.mass;
this->restitutionCoeff = state.restitutionCoeff;
this->frictionCoeff = state.frictionCoeff;
this->inertiaTensor = state.inertiaTensor;
this->reach = state.reach; this->reach = state.reach;
this->centerPos = state.centerPos; this->centerPos = state.centerPos;
this->angularAxis = state.angularAxis; this->angularAxis = state.angularAxis;
this->linearMomentum = state.linearMomentum; this->linearMomentum = state.linearMomentum;
this->angularMomentum = state.angularMomentum; this->angularMomentum = state.angularMomentum;
this->linearImpulse = state.linearImpulse;
this->angularImpulse = state.angularImpulse;
this->isSpatiallyAltered = state.isSpatiallyAltered; this->isSpatiallyAltered = state.isSpatiallyAltered;
this->isDisturbed = state.isDisturbed; this->isDisturbed = state.isDisturbed;
return *this; return *this;
} }
inline const ::Oyster::Math::Float CustomBodyState::GetMass() const
{
return this->mass;
}
inline const ::Oyster::Math::Float CustomBodyState::GetRestitutionCoeff() const
{
return this->restitutionCoeff;
}
inline const ::Oyster::Math::Float CustomBodyState::GetFrictionCoeff() const
{
return this->frictionCoeff;
}
inline const ::Oyster::Math::Float4x4 & CustomBodyState::GetMomentOfInertia() const
{
return this->inertiaTensor;
}
inline const ::Oyster::Math::Float4 & CustomBodyState::GetReach() const inline const ::Oyster::Math::Float4 & CustomBodyState::GetReach() const
{ {
return this->reach; return this->reach;
@ -76,16 +106,14 @@ namespace Oyster { namespace Physics
return ::Oyster::Math3D::RotationMatrix( this->GetAngularAxis().xyz ); return ::Oyster::Math3D::RotationMatrix( this->GetAngularAxis().xyz );
} }
inline const ::Oyster::Math::Float CustomBodyState::GetMass() const inline ::Oyster::Math::Float4x4 CustomBodyState::GetOrientation() const
{ {
//! @todo TODO: stub to be implemented (CustomBodyState::GetMass) return ::Oyster::Math3D::OrientationMatrix( this->angularAxis.xyz, this->centerPos.xyz );
return 1.0f;
} }
inline const ::Oyster::Math::Float CustomBodyState::GetRestitutionCoeff() const inline ::Oyster::Math::Float4x4 CustomBodyState::GetView() const
{ {
//! @todo TODO: stub to be implemented (CustomBodyState::GetRestitutionCoeff) return ::Oyster::Math3D::ViewMatrix( this->angularAxis.xyz, this->centerPos.xyz );
return 1.0f;
} }
inline const ::Oyster::Math::Float4 & CustomBodyState::GetLinearMomentum() const inline const ::Oyster::Math::Float4 & CustomBodyState::GetLinearMomentum() const
@ -93,15 +121,10 @@ namespace Oyster { namespace Physics
return this->linearMomentum; return this->linearMomentum;
} }
inline ::Oyster::Math::Float4 CustomBodyState::GetLinearMomentum( const ::Oyster::Math::Float3 &at ) const
{
return this->GetLinearMomentum( ::Oyster::Math::Float4(at, 1.0f) );
}
inline ::Oyster::Math::Float4 CustomBodyState::GetLinearMomentum( const ::Oyster::Math::Float4 &at ) const inline ::Oyster::Math::Float4 CustomBodyState::GetLinearMomentum( const ::Oyster::Math::Float4 &at ) const
{ {
//! @todo TODO: stub to be implemented (CustomBodyState::GetLinearMomentum) //return this->linearMomentum + ::Oyster::Physics3D::Formula::TangentialLinearMomentum( this->angularMomentum, at - this->centerPos ); // C3083 error?
return ::Oyster::Math::Float4::null; return this->linearMomentum + ::Oyster::Math::Float4( this->angularMomentum.xyz.Cross((at - this->centerPos).xyz), 0.0f );
} }
inline const ::Oyster::Math::Float4 & CustomBodyState::GetAngularMomentum() const inline const ::Oyster::Math::Float4 & CustomBodyState::GetAngularMomentum() const
@ -109,25 +132,79 @@ namespace Oyster { namespace Physics
return this->angularMomentum; return this->angularMomentum;
} }
inline void CustomBodyState::SetSize( const ::Oyster::Math::Float3 &size ) inline const ::Oyster::Math::Float4 & CustomBodyState::GetLinearImpulse() const
{
return this->linearImpulse;
}
inline const ::Oyster::Math::Float4 & CustomBodyState::GetAngularImpulse() const
{
return this->angularImpulse;
}
inline void CustomBodyState::SetMass_KeepMomentum( ::Oyster::Math::Float m )
{
this->mass = m;
}
inline void CustomBodyState::SetMass_KeepVelocity( ::Oyster::Math::Float m )
{
if( m != 0.0f )
{ // sanity block!
// Formula::LinearMomentum( m, Formula::LinearVelocity(this->mass, this->linearMomentum) )
// is the same as (this->linearMomentum / this->mass) * m = (m / this->mass) * this->linearMomentum
this->linearMomentum *= (m / this->mass);
this->mass = m;
}
}
inline void CustomBodyState::SetRestitutionCoeff( ::Oyster::Math::Float e )
{
this->restitutionCoeff = e;
}
inline void CustomBodyState::SetFrictionCoeff( ::Oyster::Math::Float u )
{
this->frictionCoeff = u;
}
inline void CustomBodyState::SetMomentOfInertia_KeepMomentum( const ::Oyster::Math::Float4x4 &tensor )
{
this->inertiaTensor = tensor;
}
inline void CustomBodyState::SetMomentOfInertia_KeepVelocity( const ::Oyster::Math::Float4x4 &tensor )
{
if( tensor.GetDeterminant() != 0.0f )
{ // sanity block!
::Oyster::Math::Float4x4 rotation = ::Oyster::Math3D::RotationMatrix(this->angularAxis.xyz);
//::Oyster::Math::Float4 w = ::Oyster::Physics3D::Formula::AngularVelocity( (rotation * this->inertiaTensor).GetInverse(), this->angularMomentum ); // C3083 error?
::Oyster::Math::Float4 w = (rotation * this->inertiaTensor).GetInverse() * this->angularMomentum;
this->inertiaTensor = tensor;
//this->angularMomentum = ::Oyster::Physics3D::Formula::AngularMomentum( rotation * tensor, w ); // C3083 error?
this->angularMomentum = rotation * tensor * w;
}
}
inline void CustomBodyState::SetSize( const ::Oyster::Math::Float4 &size )
{ {
this->SetReach( 0.5f * size ); this->SetReach( 0.5f * size );
} }
inline void CustomBodyState::SetReach( const ::Oyster::Math::Float3 &halfSize ) inline void CustomBodyState::SetReach( const ::Oyster::Math::Float4 &halfSize )
{ {
this->reach.xyz = halfSize; this->reach.xyz = halfSize;
this->reach = ::Utility::Value::Max( this->reach, ::Oyster::Math::Float4::null ); this->reach = ::Utility::Value::Max( this->reach, ::Oyster::Math::Float4::null );
this->isSpatiallyAltered = this->isDisturbed = true; this->isSpatiallyAltered = this->isDisturbed = true;
} }
inline void CustomBodyState::SetCenterPosition( const ::Oyster::Math::Float3 &centerPos ) inline void CustomBodyState::SetCenterPosition( const ::Oyster::Math::Float4 &centerPos )
{ {
this->centerPos.xyz = centerPos; this->centerPos.xyz = centerPos;
this->isSpatiallyAltered = this->isDisturbed = true; this->isSpatiallyAltered = this->isDisturbed = true;
} }
inline void CustomBodyState::SetRotation( const ::Oyster::Math::Float3 &angularAxis ) inline void CustomBodyState::SetRotation( const ::Oyster::Math::Float4 &angularAxis )
{ {
this->angularAxis.xyz = angularAxis; this->angularAxis.xyz = angularAxis;
this->isSpatiallyAltered = this->isDisturbed = true; this->isSpatiallyAltered = this->isDisturbed = true;
@ -135,43 +212,69 @@ namespace Oyster { namespace Physics
inline void CustomBodyState::SetRotation( const ::Oyster::Math::Float4x4 &rotation ) inline void CustomBodyState::SetRotation( const ::Oyster::Math::Float4x4 &rotation )
{ {
this->SetRotation( ::Oyster::Math3D::AngularAxis(rotation).xyz ); this->SetRotation( ::Oyster::Math3D::AngularAxis(rotation) );
} }
inline void CustomBodyState::SetMass( ::Oyster::Math::Float m ) inline void CustomBodyState::SetOrientation( const ::Oyster::Math::Float4x4 &orientation )
{ {
//! @todo TODO: stub to be implemented (CustomBodyState::SetRestitutionCoeff) this->SetRotation( ::Oyster::Math3D::ExtractAngularAxis(orientation) );
this->SetCenterPosition( orientation.v[3] );
} }
inline void CustomBodyState::SetRestitutionCoeff( ::Oyster::Math::Float e ) inline void CustomBodyState::SetLinearMomentum( const ::Oyster::Math::Float4 &g )
{ {
//! @todo TODO: stub to be implemented (CustomBodyState::SetRestitutionCoeff) this->linearMomentum.xyz = g;
}
inline void CustomBodyState::SetLinearMomentum( const ::Oyster::Math::Float3 &g )
{
this->linearMomentum = ::Oyster::Math::Float4( g, 0.0f );
this->isDisturbed = true; this->isDisturbed = true;
} }
inline void CustomBodyState::SetAngularMomentum( const ::Oyster::Math::Float3 &h ) inline void CustomBodyState::SetAngularMomentum( const ::Oyster::Math::Float4 &h )
{ {
this->angularMomentum = ::Oyster::Math::Float4( h, 0.0f ); this->angularMomentum.xyz = h;
this->isDisturbed = true; this->isDisturbed = true;
} }
inline void CustomBodyState::ApplyImpulse( const ::Oyster::Math::Float4 &j ) inline void CustomBodyState::SetLinearImpulse( const ::Oyster::Math::Float4 &j )
{ {
this->linearMomentum += j; this->linearImpulse.xyz = j;
this->isDisturbed = true;
}
inline void CustomBodyState::SetAngularImpulse( const ::Oyster::Math::Float4 &j )
{
this->angularImpulse.xyz = j;
this->isDisturbed = true;
}
inline void CustomBodyState::AddRotation( const ::Oyster::Math::Float4 &angularAxis )
{
this->angularAxis += angularAxis;
this->isSpatiallyAltered = this->isDisturbed = true;
}
inline void CustomBodyState::AddTranslation( const ::Oyster::Math::Float4 &deltaPos )
{
this->centerPos += deltaPos;
this->isSpatiallyAltered = this->isDisturbed = true;
}
inline void CustomBodyState::ApplyLinearImpulse( const ::Oyster::Math::Float4 &j )
{
this->linearImpulse += j;
this->isDisturbed = true;
}
inline void CustomBodyState::ApplyAngularImpulse( const ::Oyster::Math::Float4 &j )
{
this->angularImpulse += j;
this->isDisturbed = true; this->isDisturbed = true;
} }
inline void CustomBodyState::ApplyImpulse( const ::Oyster::Math::Float4 &j, const ::Oyster::Math::Float4 &at, const ::Oyster::Math::Float4 &normal ) inline void CustomBodyState::ApplyImpulse( const ::Oyster::Math::Float4 &j, const ::Oyster::Math::Float4 &at, const ::Oyster::Math::Float4 &normal )
{ {
//! @todo TODO: stub to be implemented (CustomBodyState::ApplyImpulse) //::Oyster::Math::Float4 tangentialImpulse = ::Oyster::Physics3D::Formula::AngularMomentum( j, at - this->centerPos ); // C3083 error?
::Oyster::Math::Float4 tangentialImpulse = ::Oyster::Math::Float4( (at - this->centerPos).xyz.Cross(j.xyz), 0.0f );
this->linearMomentum += j.Dot( normal ) * normal; // perpendicular impulse component this->linearImpulse += j - tangentialImpulse;
//this->angularImpulse += Formula:: ... this->angularImpulse += tangentialImpulse;
this->isDisturbed = true; this->isDisturbed = true;
} }

64
Code/GamePhysics/PhysicsStructs.h
View File

@ -11,8 +11,8 @@ namespace Oyster { namespace Physics
struct SimpleBodyDescription struct SimpleBodyDescription
{ {
::Oyster::Math::Float4x4 rotation; ::Oyster::Math::Float4x4 rotation;
::Oyster::Math::Float3 centerPosition; ::Oyster::Math::Float4 centerPosition;
::Oyster::Math::Float3 size; ::Oyster::Math::Float4 size;
::Oyster::Math::Float mass; ::Oyster::Math::Float mass;
::Oyster::Math::Float4x4 inertiaTensor; ::Oyster::Math::Float4x4 inertiaTensor;
::Oyster::Physics::ICustomBody::EventAction_Collision subscription; ::Oyster::Physics::ICustomBody::EventAction_Collision subscription;
@ -24,7 +24,7 @@ namespace Oyster { namespace Physics
struct SphericalBodyDescription struct SphericalBodyDescription
{ {
::Oyster::Math::Float4x4 rotation; ::Oyster::Math::Float4x4 rotation;
::Oyster::Math::Float3 centerPosition; ::Oyster::Math::Float4 centerPosition;
::Oyster::Math::Float radius; ::Oyster::Math::Float radius;
::Oyster::Math::Float mass; ::Oyster::Math::Float mass;
::Oyster::Physics::ICustomBody::EventAction_Collision subscription; ::Oyster::Physics::ICustomBody::EventAction_Collision subscription;
@ -36,46 +36,68 @@ namespace Oyster { namespace Physics
struct CustomBodyState struct CustomBodyState
{ {
public: public:
CustomBodyState( const ::Oyster::Math::Float3 &reach = ::Oyster::Math::Float3::null, CustomBodyState( ::Oyster::Math::Float mass = 1.0f,
const ::Oyster::Math::Float3 &centerPos = ::Oyster::Math::Float3::null, ::Oyster::Math::Float restitutionCoeff = 1.0f,
const ::Oyster::Math::Float3 &rotation = ::Oyster::Math::Float3::null, ::Oyster::Math::Float frictionCoeff = 1.0f,
const ::Oyster::Math::Float3 &linearMomentum = ::Oyster::Math::Float3::null, const ::Oyster::Math::Float4x4 &inertiaTensor = ::Oyster::Math::Float4x4::identity,
const ::Oyster::Math::Float3 &angularMomentum = ::Oyster::Math::Float3::null ); const ::Oyster::Math::Float4 &reach = ::Oyster::Math::Float4::null,
const ::Oyster::Math::Float4 &centerPos = ::Oyster::Math::Float4::standard_unit_w,
const ::Oyster::Math::Float4 &rotation = ::Oyster::Math::Float4::null,
const ::Oyster::Math::Float4 &linearMomentum = ::Oyster::Math::Float4::null,
const ::Oyster::Math::Float4 &angularMomentum = ::Oyster::Math::Float4::null );
CustomBodyState & operator = ( const CustomBodyState &state ); CustomBodyState & operator = ( const CustomBodyState &state );
const ::Oyster::Math::Float GetMass() const;
const ::Oyster::Math::Float GetRestitutionCoeff() const;
const ::Oyster::Math::Float GetFrictionCoeff() const;
const ::Oyster::Math::Float4x4 & GetMomentOfInertia() const;
const ::Oyster::Math::Float4 & GetReach() const; const ::Oyster::Math::Float4 & GetReach() const;
::Oyster::Math::Float4 GetSize() const; ::Oyster::Math::Float4 GetSize() const;
const ::Oyster::Math::Float4 & GetCenterPosition() const; const ::Oyster::Math::Float4 & GetCenterPosition() const;
const ::Oyster::Math::Float4 & GetAngularAxis() const; const ::Oyster::Math::Float4 & GetAngularAxis() const;
::Oyster::Math::Float4x4 GetRotation() const; ::Oyster::Math::Float4x4 GetRotation() const;
const ::Oyster::Math::Float GetMass() const; ::Oyster::Math::Float4x4 GetOrientation() const;
const ::Oyster::Math::Float GetRestitutionCoeff() const; ::Oyster::Math::Float4x4 GetView() const;
const ::Oyster::Math::Float4 & GetLinearMomentum() const; const ::Oyster::Math::Float4 & GetLinearMomentum() const;
::Oyster::Math::Float4 GetLinearMomentum( const ::Oyster::Math::Float3 &at ) const;
::Oyster::Math::Float4 GetLinearMomentum( const ::Oyster::Math::Float4 &at ) const; ::Oyster::Math::Float4 GetLinearMomentum( const ::Oyster::Math::Float4 &at ) const;
const ::Oyster::Math::Float4 & GetAngularMomentum() const; const ::Oyster::Math::Float4 & GetAngularMomentum() const;
const ::Oyster::Math::Float4 & GetLinearImpulse() const;
const ::Oyster::Math::Float4 & GetAngularImpulse() const;
void SetMass_KeepMomentum( ::Oyster::Math::Float m );
void SetSize( const ::Oyster::Math::Float3 &size ); void SetMass_KeepVelocity( ::Oyster::Math::Float m );
void SetReach( const ::Oyster::Math::Float3 &halfSize );
void SetCenterPosition( const ::Oyster::Math::Float3 &centerPos );
void SetRotation( const ::Oyster::Math::Float3 &angularAxis );
void SetRotation( const ::Oyster::Math::Float4x4 &rotation );
void SetMass( ::Oyster::Math::Float m );
void SetRestitutionCoeff( ::Oyster::Math::Float e ); void SetRestitutionCoeff( ::Oyster::Math::Float e );
void SetLinearMomentum( const ::Oyster::Math::Float3 &g ); void SetFrictionCoeff( ::Oyster::Math::Float u );
void SetAngularMomentum( const ::Oyster::Math::Float3 &h ); void SetMomentOfInertia_KeepMomentum( const ::Oyster::Math::Float4x4 &tensor );
void SetMomentOfInertia_KeepVelocity( const ::Oyster::Math::Float4x4 &tensor );
void SetSize( const ::Oyster::Math::Float4 &size );
void SetReach( const ::Oyster::Math::Float4 &halfSize );
void SetCenterPosition( const ::Oyster::Math::Float4 &centerPos );
void SetRotation( const ::Oyster::Math::Float4 &angularAxis );
void SetRotation( const ::Oyster::Math::Float4x4 &rotation );
void SetOrientation( const ::Oyster::Math::Float4x4 &orientation );
void SetLinearMomentum( const ::Oyster::Math::Float4 &g );
void SetAngularMomentum( const ::Oyster::Math::Float4 &h );
void SetLinearImpulse( const ::Oyster::Math::Float4 &j );
void SetAngularImpulse( const ::Oyster::Math::Float4 &j );
void ApplyImpulse( const ::Oyster::Math::Float4 &j ); void AddRotation( const ::Oyster::Math::Float4 &angularAxis );
void AddTranslation( const ::Oyster::Math::Float4 &deltaPos );
void ApplyLinearImpulse( const ::Oyster::Math::Float4 &j );
void ApplyAngularImpulse( const ::Oyster::Math::Float4 &j );
void ApplyImpulse( const ::Oyster::Math::Float4 &j, const ::Oyster::Math::Float4 &at, const ::Oyster::Math::Float4 &normal ); void ApplyImpulse( const ::Oyster::Math::Float4 &j, const ::Oyster::Math::Float4 &at, const ::Oyster::Math::Float4 &normal );
bool IsSpatiallyAltered() const; bool IsSpatiallyAltered() const;
bool IsDisturbed() const; bool IsDisturbed() const;
private: private:
::Oyster::Math::Float mass, restitutionCoeff, frictionCoeff;
::Oyster::Math::Float4x4 inertiaTensor;
::Oyster::Math::Float4 reach, centerPos, angularAxis; ::Oyster::Math::Float4 reach, centerPos, angularAxis;
::Oyster::Math::Float4 linearMomentum, angularMomentum; ::Oyster::Math::Float4 linearMomentum, angularMomentum;
::Oyster::Math::Float4 linearImpulse, angularImpulse;
bool isSpatiallyAltered, isDisturbed; bool isSpatiallyAltered, isDisturbed;
}; };

33
Code/OysterMath/LinearMath.h
View File

@ -266,6 +266,12 @@ namespace LinearAlgebra3D
return ::std::asin( ::LinearAlgebra::Vector4<ScalarType>(rotationMatrix.v[1].z, rotationMatrix.v[2].x, rotationMatrix.v[0].y, 1) ); return ::std::asin( ::LinearAlgebra::Vector4<ScalarType>(rotationMatrix.v[1].z, rotationMatrix.v[2].x, rotationMatrix.v[0].y, 1) );
} }
template<typename ScalarType>
inline ::LinearAlgebra::Vector4<ScalarType> ExtractAngularAxis( const ::LinearAlgebra::Matrix4x4<ScalarType> &orientationMatrix )
{
return ::std::asin( ::LinearAlgebra::Vector4<ScalarType>(orientationMatrix.v[1].z, orientationMatrix.v[2].x, orientationMatrix.v[0].y, 1) );
}
template<typename ScalarType> template<typename ScalarType>
inline ::LinearAlgebra::Matrix4x4<ScalarType> & TranslationMatrix( const ::LinearAlgebra::Vector3<ScalarType> &position, ::LinearAlgebra::Matrix4x4<ScalarType> &targetMem = ::LinearAlgebra::Matrix4x4<ScalarType>() ) inline ::LinearAlgebra::Matrix4x4<ScalarType> & TranslationMatrix( const ::LinearAlgebra::Vector3<ScalarType> &position, ::LinearAlgebra::Matrix4x4<ScalarType> &targetMem = ::LinearAlgebra::Matrix4x4<ScalarType>() )
{ {
@ -400,18 +406,35 @@ namespace LinearAlgebra3D
} }
template<typename ScalarType> template<typename ScalarType>
::LinearAlgebra::Matrix4x4<ScalarType> & OrientationMatrix( const ::LinearAlgebra::Vector3<ScalarType> &sumDeltaAngularAxis, const ::LinearAlgebra::Vector3<ScalarType> &sumTranslation, ::LinearAlgebra::Matrix4x4<ScalarType> &targetMem = ::LinearAlgebra::Matrix4x4<ScalarType>() ) ::LinearAlgebra::Matrix4x4<ScalarType> & OrientationMatrix( const ::LinearAlgebra::Vector3<ScalarType> &angularAxis, const ::LinearAlgebra::Vector3<ScalarType> &translation, ::LinearAlgebra::Matrix4x4<ScalarType> &targetMem = ::LinearAlgebra::Matrix4x4<ScalarType>() )
{ /** @todo TODO: not tested */ {
ScalarType radian = sumDeltaAngularAxis.Dot( sumDeltaAngularAxis ); ScalarType radian = angularAxis.Dot( angularAxis );
if( radian > 0 ) if( radian > 0 )
{ {
radian = ::std::sqrt( radian ); radian = ::std::sqrt( radian );
return OrientationMatrix( sumDeltaAngularAxis / radian, radian, sumTranslation, targetMem ); return OrientationMatrix( angularAxis / radian, radian, translation, targetMem );
} }
else else
{ {
targetMem = ::LinearAlgebra::Matrix4x4<ScalarType>::identity; targetMem = ::LinearAlgebra::Matrix4x4<ScalarType>::identity;
targetMem.v[3].xyz = sumTranslation; targetMem.v[3].xyz = translation;
return targetMem;
}
}
template<typename ScalarType>
::LinearAlgebra::Matrix4x4<ScalarType> & ViewMatrix( const ::LinearAlgebra::Vector3<ScalarType> &angularAxis, const ::LinearAlgebra::Vector3<ScalarType> &translation, ::LinearAlgebra::Matrix4x4<ScalarType> &targetMem = ::LinearAlgebra::Matrix4x4<ScalarType>() )
{
ScalarType radian = angularAxis.Dot( angularAxis );
if( radian > 0 )
{
radian = ::std::sqrt( radian );
return InverseOrientationMatrix( OrientationMatrix(angularAxis / radian, radian, translation, targetMem) );
}
else
{
targetMem = ::LinearAlgebra::Matrix4x4<ScalarType>::identity;
targetMem.v[3].xyz = -translation;
return targetMem; return targetMem;
} }
} }

14
Code/OysterMath/OysterMath.cpp
View File

@ -91,6 +91,11 @@ namespace Oyster { namespace Math3D
return ::LinearAlgebra3D::AngularAxis( rotationMatrix ); return ::LinearAlgebra3D::AngularAxis( rotationMatrix );
} }
Float4 ExtractAngularAxis( const Float4x4 &orientationMatrix )
{
return ::LinearAlgebra3D::ExtractAngularAxis( orientationMatrix );
}
Float4x4 & TranslationMatrix( const Float3 &position, Float4x4 &targetMem ) Float4x4 & TranslationMatrix( const Float3 &position, Float4x4 &targetMem )
{ {
return ::LinearAlgebra3D::TranslationMatrix( position, targetMem ); return ::LinearAlgebra3D::TranslationMatrix( position, targetMem );
@ -147,9 +152,14 @@ namespace Oyster { namespace Math3D
return ::LinearAlgebra3D::OrientationMatrix( normalizedAxis, deltaRadian, sumTranslation, targetMem ); return ::LinearAlgebra3D::OrientationMatrix( normalizedAxis, deltaRadian, sumTranslation, targetMem );
} }
Float4x4 & OrientationMatrix( const Float3 &sumDeltaAngularAxis, const Float3 &sumTranslation, Float4x4 &targetMem ) Float4x4 & OrientationMatrix( const Float3 &angularAxis, const Float3 &translation, Float4x4 &targetMem )
{ {
return ::LinearAlgebra3D::OrientationMatrix( sumDeltaAngularAxis, sumTranslation, targetMem ); return ::LinearAlgebra3D::OrientationMatrix( angularAxis, translation, targetMem );
}
Float4x4 & ViewMatrix( const Float3 &angularAxis, const Float3 &translation, Float4x4 &targetMem )
{
return ::LinearAlgebra3D::ViewMatrix( angularAxis, translation, targetMem );
} }
Float4x4 & OrientationMatrix( const Float3 &sumDeltaAngularAxis, const Float3 &sumTranslation, const Float3 &centerOfMass, Float4x4 &targetMem ) Float4x4 & OrientationMatrix( const Float3 &sumDeltaAngularAxis, const Float3 &sumTranslation, const Float3 &centerOfMass, Float4x4 &targetMem )

20
Code/OysterMath/OysterMath.h
View File

@ -153,6 +153,9 @@ namespace Oyster { namespace Math3D /// Oyster's native math library specialized
//! Extracts the angularAxis from rotationMatrix //! Extracts the angularAxis from rotationMatrix
Float4 AngularAxis( const Float4x4 &rotationMatrix ); Float4 AngularAxis( const Float4x4 &rotationMatrix );
//! Extracts the angularAxis from orientationMatrix
Float4 ExtractAngularAxis( const Float4x4 &orientationMatrix );
/// Sets and returns targetMem to a translationMatrix with position as translation. /// Sets and returns targetMem to a translationMatrix with position as translation.
Float4x4 & TranslationMatrix( const Float3 &position, Float4x4 &targetMem = Float4x4() ); Float4x4 & TranslationMatrix( const Float3 &position, Float4x4 &targetMem = Float4x4() );
@ -191,19 +194,26 @@ namespace Oyster { namespace Math3D /// Oyster's native math library specialized
* @param sumTranslation: sum of all the translation vectors. * @param sumTranslation: sum of all the translation vectors.
* @param targetMem: is set to a rigibody matrix that rotate counterclockwise and then translates. * @param targetMem: is set to a rigibody matrix that rotate counterclockwise and then translates.
* @return targetMem * @return targetMem
* @todo TODO: not tested
*******************************************************************/ *******************************************************************/
Float4x4 & OrientationMatrix( const Float3 &normalizedAxis, const Float & deltaRadian, const Float3 &sumTranslation, Float4x4 &targetMem = Float4x4() ); Float4x4 & OrientationMatrix( const Float3 &normalizedAxis, const Float & deltaRadian, const Float3 &sumTranslation, Float4x4 &targetMem = Float4x4() );
/******************************************************************* /*******************************************************************
* Sets and returns targetMem as an orientation Matrix * Sets and returns targetMem as an orientation Matrix
* @param sumDeltaAngularAxis: sum of all ( (1/I) * ( L x D ) )-vectorproducts. There I is known as "moment of inertia", L as "angular momentum vector" and D the "lever vector". * @param angularAxis: sum of all ( (1/I) * ( L x D ) )-vectorproducts. There I is known as "moment of inertia", L as "angular momentum vector" and D the "lever vector".
* @param sumTranslation: sum of all the translation vectors. * @param translation: sum of all the translation vectors.
* @param targetMem: is set to a rigibody matrix that rotate counterclockwise and then translates. * @param targetMem: is set to a rigibody matrix that rotate counterclockwise and then translates.
* @return targetMem * @return targetMem
* @todo TODO: not tested
*******************************************************************/ *******************************************************************/
Float4x4 & OrientationMatrix( const Float3 &sumDeltaAngularAxis, const Float3 &sumTranslation, Float4x4 &targetMem = Float4x4() ); Float4x4 & OrientationMatrix( const Float3 &angularAxis, const Float3 &translation, Float4x4 &targetMem = Float4x4() );
/*******************************************************************
* Sets and returns targetMem as a view Matrix
* @param angularAxis: sum of all ( (1/I) * ( L x D ) )-vectorproducts. There I is known as "moment of inertia", L as "angular momentum vector" and D the "lever vector".
* @param translation: sum of all the translation vectors.
* @param targetMem: is set to a rigibody matrix that rotate counterclockwise and then translates.
* @return targetMem
*******************************************************************/
Float4x4 & ViewMatrix( const Float3 &angularAxis, const Float3 &translation, Float4x4 &targetMem = Float4x4() );
/******************************************************************* /*******************************************************************
* Sets and returns targetMem as an orientation Matrix * Sets and returns targetMem as an orientation Matrix

60
Code/OysterPhysics3D/OysterPhysics3D.h
View File

@ -12,6 +12,60 @@ namespace Oyster { namespace Physics3D
namespace Formula namespace Formula
{ /// Library of 3D physics related formulas { /// Library of 3D physics related formulas
/******************************************************************
* Returns the linear momentum of a mass in motion.
* @todo TODO: improve doc
******************************************************************/
inline ::Oyster::Math::Float4 LinearMomentum( const ::Oyster::Math::Float &mass, const ::Oyster::Math::Float4 &linearVelocity )
{
return linearVelocity * mass;
}
/******************************************************************
* Returns the linear momentum of a mass in motion.
* @todo TODO: improve doc
******************************************************************/
inline ::Oyster::Math::Float4 LinearVelocity( const ::Oyster::Math::Float &mass, const ::Oyster::Math::Float4 &linearMomentum )
{
return linearMomentum / mass;
}
/******************************************************************
* Returns the world angular momentum of a mass in rotation.
* @todo TODO: improve doc
******************************************************************/
inline ::Oyster::Math::Float4 AngularMomentum( const ::Oyster::Math::Float4 linearMomentum, const ::Oyster::Math::Float4 &worldOffset )
{
return ::Oyster::Math::Float4( worldOffset.xyz.Cross(linearMomentum.xyz), 0.0f );
}
/******************************************************************
* Returns the world angular momentum of a mass in rotation.
* @todo TODO: improve doc
******************************************************************/
inline ::Oyster::Math::Float4 AngularMomentum( const ::Oyster::Math::Float4x4 &worldMomentOfInertia, const ::Oyster::Math::Float4 &angularVelocity )
{
return worldMomentOfInertia * angularVelocity;
}
/******************************************************************
* Returns the world angular velocity of a mass in rotation.
* @todo TODO: improve doc
******************************************************************/
inline ::Oyster::Math::Float4 AngularVelocity( const ::Oyster::Math::Float4x4 &worldMomentOfInertiaInversed, const ::Oyster::Math::Float4 &angularMomentum )
{
return worldMomentOfInertiaInversed * angularMomentum;
}
/******************************************************************
* Returns the world tangential momentum at worldPos, of a mass in rotation.
* @todo TODO: improve doc
******************************************************************/
inline ::Oyster::Math::Float4 TangentialLinearMomentum( const ::Oyster::Math::Float4 &angularMomentum, const ::Oyster::Math::Float4 &worldOffset )
{
return ::Oyster::Math::Float4( angularMomentum.xyz.Cross(worldOffset.xyz), 0.0f );
}
/****************************************************************** /******************************************************************
* Returns the linear kinetic energy of a mass in motion. * Returns the linear kinetic energy of a mass in motion.
* @todo TODO: improve doc * @todo TODO: improve doc
@ -192,12 +246,6 @@ namespace Oyster { namespace Physics3D
return ( momentOfInertia * ::Oyster::Math::Float4(angularImpulseAcceleration, 0.0f) ).xyz; return ( momentOfInertia * ::Oyster::Math::Float4(angularImpulseAcceleration, 0.0f) ).xyz;
} }
inline ::Oyster::Math::Float3 Impulse( )
{
//! @todo TODO: implement calculation for impulse. Hijack Mattias Eriksson
return ::Oyster::Math::Float3::null;
}
namespace MomentOfInertia namespace MomentOfInertia
{ /// Library of Formulas to calculate moment of inerta for simple shapes { /// Library of Formulas to calculate moment of inerta for simple shapes
/** @todo TODO: add MomentOfInertia tensor formulas */ /** @todo TODO: add MomentOfInertia tensor formulas */

4
Code/OysterPhysics3D/RigidBody.cpp
View File

@ -16,6 +16,8 @@ RigidBody::RigidBody( const Box &b, Float m, const Float4x4 &inertiaTensor )
this->linearMomentum = Float3::null; this->linearMomentum = Float3::null;
this->impulseTorqueSum = Float3::null; this->impulseTorqueSum = Float3::null;
this->impulseForceSum = Float3::null; this->impulseForceSum = Float3::null;
this->restitutionCoeff = 1.0f;
this->frictionCoeff = 1.0f;
if( m != 0.0f ) if( m != 0.0f )
{ {
@ -43,6 +45,8 @@ RigidBody & RigidBody::operator = ( const RigidBody &body )
this->linearMomentum = body.linearMomentum; this->linearMomentum = body.linearMomentum;
this->impulseTorqueSum = body.impulseTorqueSum; this->impulseTorqueSum = body.impulseTorqueSum;
this->impulseForceSum = body.impulseForceSum; this->impulseForceSum = body.impulseForceSum;
this->restitutionCoeff = body.restitutionCoeff;
this->frictionCoeff = body.frictionCoeff;
this->mass = body.mass; this->mass = body.mass;
this->momentOfInertiaTensor = body.momentOfInertiaTensor; this->momentOfInertiaTensor = body.momentOfInertiaTensor;
return *this; return *this;

1
Code/OysterPhysics3D/RigidBody.h
View File

@ -19,6 +19,7 @@ namespace Oyster { namespace Physics3D
linearMomentum, /** The linear momentum G (kg*m/s). (worldValue) */ linearMomentum, /** The linear momentum G (kg*m/s). (worldValue) */
impulseTorqueSum, /** The impulse torque T (Nm) that will be consumed each update. (worldValue) */ impulseTorqueSum, /** The impulse torque T (Nm) that will be consumed each update. (worldValue) */
impulseForceSum; /** The impulse force F (N) that will be consumed each update. (worldValue) */ impulseForceSum; /** The impulse force F (N) that will be consumed each update. (worldValue) */
::Oyster::Math::Float restitutionCoeff, frictionCoeff;
RigidBody( const ::Oyster::Collision3D::Box &box = ::Oyster::Collision3D::Box(), RigidBody( const ::Oyster::Collision3D::Box &box = ::Oyster::Collision3D::Box(),
::Oyster::Math::Float mass = 12.0f, ::Oyster::Math::Float mass = 12.0f,