Danbias/Code/GamePhysics/Implementation/PhysicsAPI_Impl.cpp

399 lines
12 KiB
C++
Raw Normal View History

#include "PhysicsAPI_Impl.h"
#include "OysterPhysics3D.h"
#include "SimpleRigidBody.h"
#include "SphericalRigidBody.h"
2014-01-15 10:44:31 +01:00
using namespace ::Oyster;
using namespace ::Oyster::Physics;
using namespace ::Oyster::Math;
using namespace ::Oyster::Collision3D;
using namespace ::Utility::DynamicMemory;
2013-12-19 10:15:32 +01:00
using namespace ::Utility::Value;
API_Impl API_instance;
namespace
{
void OnPossibleCollision( Octree& worldScene, unsigned int protoTempRef, unsigned int deuterTempRef )
{ /** @todo TODO: OnPossibleCollision is a temporary solution .*/
auto proto = worldScene.GetCustomBody( protoTempRef );
auto deuter = worldScene.GetCustomBody( deuterTempRef );
Float4 worldPointOfContact;
if( proto->Intersects(*deuter, worldPointOfContact) )
{
switch( proto->CallSubscription_Collision(deuter) )
{
case ICustomBody::SubscriptMessage_ignore_collision_response:
break;
default:
{ // Apply CollisionResponse in pure gather pattern
ICustomBody::State protoState; proto->GetState( protoState );
ICustomBody::State deuterState; deuter->GetState( deuterState );
Float4 protoG = protoState.GetLinearMomentum( worldPointOfContact ),
deuterG = deuterState.GetLinearMomentum( worldPointOfContact );
// calc from perspective of deuter
Float4 normal; deuter->GetNormalAt( worldPointOfContact, normal );
2014-01-21 14:28:27 +01:00
Float protoG_Magnitude = protoG.Dot( normal ),
deuterG_Magnitude = deuterG.Dot( normal );
// if they are not relatively moving towards eachother, there is no collision
Float deltaPos = normal.Dot( deuterState.GetCenterPosition() - protoState.GetCenterPosition() );
if( deltaPos < 0.0f )
{
if( protoG_Magnitude >= deuterG_Magnitude )
{
break;
}
}
else if( deltaPos > 0.0f )
{
if( protoG_Magnitude <= deuterG_Magnitude )
{
break;
}
}
else
{
break;
}
// bounce
2013-12-19 17:27:09 +01:00
Float4 bounceD = normal * -Formula::CollisionResponse::Bounce( deuterState.GetRestitutionCoeff(),
deuterState.GetMass(), deuterG_Magnitude,
protoState.GetMass(), protoG_Magnitude );
2013-12-19 17:27:09 +01:00
//sumJ -= Formula::CollisionResponse::Friction( impulse, normal,
// protoState.GetLinearMomentum(), protoState.GetFrictionCoeff_Static(), protoState.GetFrictionCoeff_Kinetic(), protoState.GetMass(),
// deuterState.GetLinearMomentum(), deuterState.GetFrictionCoeff_Static(), deuterState.GetFrictionCoeff_Kinetic(), deuterState.GetMass());
// calc from perspective of proto
proto->GetNormalAt( worldPointOfContact, normal );
protoG_Magnitude = protoG.Dot( normal ),
deuterG_Magnitude = deuterG.Dot( normal );
// bounce
2013-12-19 17:27:09 +01:00
Float4 bounceP = normal * Formula::CollisionResponse::Bounce( protoState.GetRestitutionCoeff(),
protoState.GetMass(), protoG_Magnitude,
deuterState.GetMass(), deuterG_Magnitude );
Float4 bounce = Average( bounceD, bounceP );
//Float4 bounce = bounceD + bounceP;
// FRICTION
// Apply
//sumJ += ( 1 / deuterState.GetMass() )*frictionImpulse;
// FRICTION END
// Float4 forwardedDeltaPos, forwardedDeltaAxis;
// { // @todo TODO: is this right?
// Float4 bounceAngularImpulse = ::Oyster::Math::Float4( (worldPointOfContact - protoState.GetCenterPosition()).xyz.Cross(bounce.xyz), 0.0f ),
// bounceLinearImpulse = bounce - bounceAngularImpulse;
// proto->Predict( forwardedDeltaPos, forwardedDeltaAxis, bounceLinearImpulse, bounceAngularImpulse, API_instance.GetFrameTimeLength() );
// }
2013-12-20 11:44:27 +01:00
2014-01-22 13:50:54 +01:00
// protoState.ApplyForwarding( forwardedDeltaPos, forwardedDeltaAxis );
2013-12-19 17:27:09 +01:00
protoState.ApplyImpulse( bounce, worldPointOfContact, normal );
proto->SetState( protoState );
2014-01-22 13:50:54 +01:00
proto->CallSubscription_CollisionResponse( deuter, protoState.GetLinearMomentum().GetMagnitude()/(protoState.GetMass() + protoState.GetLinearMomentum().GetMagnitude()));
}
2013-12-19 17:27:09 +01:00
break;
}
}
}
}
2013-11-25 12:21:44 +01:00
API & API::Instance()
{
return API_instance;
}
API_Impl::API_Impl()
2013-11-28 17:59:12 +01:00
{
this->gravityConstant = Constant::gravity_constant;
this->updateFrameLength = 1.0f / 120.0f;
this->destructionAction = Default::EventAction_Destruction;
2014-01-15 10:44:31 +01:00
this->gravity = ::std::vector<Gravity>();
2013-11-28 17:59:12 +01:00
this->worldScene = Octree();
}
API_Impl::~API_Impl() {}
void API_Impl::Init( unsigned int numObjects, unsigned int numGravityWells , const Float3 &worldSize )
{
2013-11-28 17:59:12 +01:00
unsigned char numLayers = 4; //!< @todo TODO: calc numLayers from worldSize
2014-01-15 10:44:31 +01:00
this->gravity.resize( 0 );
this->gravity.reserve( numGravityWells );
2013-11-28 17:59:12 +01:00
this->worldScene = Octree( numObjects, numLayers, worldSize );
}
2013-11-28 17:59:12 +01:00
void API_Impl::SetFrameTimeLength( float deltaTime )
{
2013-11-28 17:59:12 +01:00
this->updateFrameLength = deltaTime;
}
void API_Impl::SetGravityConstant( float g )
{
this->gravityConstant = g;
}
void API_Impl::SetSubscription( API::EventAction_Destruction functionPointer )
{
if( functionPointer )
{
this->destructionAction = functionPointer;
}
else
{
this->destructionAction = Default::EventAction_Destruction;
}
}
float API_Impl::GetFrameTimeLength() const
{
return this->updateFrameLength;
}
void API_Impl::Update()
{ /** @todo TODO: Update is a temporary solution .*/
::std::vector<ICustomBody*> updateList;
auto proto = this->worldScene.Sample( Universe(), updateList ).begin();
2014-01-21 09:58:33 +01:00
ICustomBody::State state;
for( ; proto != updateList.end(); ++proto )
{
2014-01-15 10:44:31 +01:00
// Step 1: Apply Gravity
Float4 gravityImpulse = Float4::null;
2014-01-21 09:58:33 +01:00
(*proto)->GetState( state );
2014-01-15 10:44:31 +01:00
for( ::std::vector<Gravity>::size_type i = 0; i < this->gravity.size(); ++i )
{
switch( this->gravity[i].gravityType )
{
case Gravity::GravityType_Well:
{
2014-01-21 10:34:22 +01:00
Float4 d = Float4( this->gravity[i].well.position, 1.0f ) - state.GetCenterPosition();
2014-01-15 10:44:31 +01:00
Float rSquared = d.Dot( d );
if( rSquared != 0.0 )
{
Float force = Physics3D::Formula::ForceField( this->gravityConstant, state.GetMass(), this->gravity[i].well.mass, rSquared );
gravityImpulse += (this->updateFrameLength * force / ::std::sqrt(rSquared)) * d;
2014-01-15 10:44:31 +01:00
}
break;
}
case Gravity::GravityType_Directed:
gravityImpulse += Float4( this->gravity[i].directed.impulse, 0.0f );
2014-01-15 10:44:31 +01:00
break;
// case Gravity::GravityType_DirectedField:
// //this->gravity[i].directedField.
// //! TODO: @todo rethink
// break;
default: break;
}
}
if( gravityImpulse != Float4::null )
{
state.ApplyLinearImpulse( gravityImpulse );
2014-01-23 08:24:35 +01:00
//state.SetGravityNormal( gravityImpulse.GetNormalized());
//(*proto)->SetGravityNormal( gravityImpulse.GetNormalized().xyz );
(*proto)->SetState( state );
2014-01-23 08:24:35 +01:00
(*proto)->SetGravityNormal( gravityImpulse.GetNormalized().xyz );
}
// Step 2: Apply Collision Response
this->worldScene.Visit( *proto, OnPossibleCollision );
}
proto = updateList.begin();
for( ; proto != updateList.end(); ++proto )
{
switch( (*proto)->Update(this->updateFrameLength) )
{
case UpdateState_altered:
this->worldScene.SetAsAltered( this->worldScene.GetTemporaryReferenceOf(*proto) );
(*proto)->CallSubscription_Move();
case UpdateState_resting: default:
break;
}
}
}
bool API_Impl::IsInLimbo( const ICustomBody* objRef )
{
//! @todo TODO: implement stub
return true;
}
void API_Impl::MoveToLimbo( const ICustomBody* objRef )
{
/** @todo TODO: Fix this function.*/
}
void API_Impl::ReleaseFromLimbo( const ICustomBody* objRef )
{
/** @todo TODO: Fix this function.*/
}
void API_Impl::AddObject( ::Utility::DynamicMemory::UniquePointer<ICustomBody> handle )
{
2013-11-28 17:59:12 +01:00
this->worldScene.AddObject( handle );
}
2013-11-28 17:59:12 +01:00
UniquePointer<ICustomBody> API_Impl::ExtractObject( const ICustomBody* objRef )
{
2013-11-28 17:59:12 +01:00
return this->worldScene.Extract( objRef );
}
void API_Impl::DestroyObject( const ICustomBody* objRef )
{
2013-11-28 17:59:12 +01:00
UniquePointer<ICustomBody> object = this->worldScene.Extract( objRef );
if( object )
2013-11-28 17:59:12 +01:00
{
this->destructionAction( object );
}
}
2014-01-15 10:44:31 +01:00
void API_Impl::AddGravity( const API::Gravity &g )
{
this->gravity.push_back( g );
}
void API_Impl::RemoveGravity( const API::Gravity &g )
{
for( ::std::vector<Gravity>::size_type i = this->gravity.size() - 1; i >= 0; --i )
{
if( g == this->gravity[i] )
{
int end = this->gravity.size() - 1;
this->gravity[i] = this->gravity[end];
this->gravity.resize( end );
}
}
}
void API_Impl::ApplyEffect( const Oyster::Collision3D::ICollideable& collideable, void(hitAction)(ICustomBody*) )
{
this->worldScene.Visit(collideable, hitAction);
}
2013-12-18 14:16:13 +01:00
//void API_Impl::ApplyForceAt( const ICustomBody* objRef, const Float3 &worldPos, const Float3 &worldF )
//{
// unsigned int tempRef = this->worldScene.GetTemporaryReferenceOf( objRef );
// if( tempRef != this->worldScene.invalid_ref )
// {
// //this->worldScene.GetCustomBody( tempRef )->Apply //!< @todo TODO: need function
// this->worldScene.SetAsAltered( tempRef );
// }
//}
//
//void API_Impl::SetMomentOfInertiaTensor_KeepVelocity( const ICustomBody* objRef, const Float4x4 &localI )
//{ // deprecated
// unsigned int tempRef = this->worldScene.GetTemporaryReferenceOf( objRef );
// if( tempRef != this->worldScene.invalid_ref )
// {
// this->worldScene.GetCustomBody( tempRef )->SetMomentOfInertiaTensor_KeepVelocity( localI );
// }
//}
//
//void API_Impl::SetMomentOfInertiaTensor_KeepMomentum( const ICustomBody* objRef, const Float4x4 &localI )
//{ // deprecated
// unsigned int tempRef = this->worldScene.GetTemporaryReferenceOf( objRef );
// if( tempRef != this->worldScene.invalid_ref )
// {
// this->worldScene.GetCustomBody( tempRef )->SetMomentOfInertiaTensor_KeepMomentum( localI );
// }
//}
//
//void API_Impl::SetMass_KeepVelocity( const ICustomBody* objRef, Float m )
//{ // deprecated
// unsigned int tempRef = this->worldScene.GetTemporaryReferenceOf( objRef );
// if( tempRef != this->worldScene.invalid_ref )
// {
// this->worldScene.GetCustomBody( tempRef )->SetMass_KeepVelocity( m );
// }
//}
//
//void API_Impl::SetMass_KeepMomentum( const ICustomBody* objRef, Float m )
//{ // deprecated
// unsigned int tempRef = this->worldScene.GetTemporaryReferenceOf( objRef );
// if( tempRef != this->worldScene.invalid_ref )
// {
// this->worldScene.GetCustomBody( tempRef )->SetMass_KeepMomentum( m );
// }
//}
//
//void API_Impl::SetCenter( const ICustomBody* objRef, const Float3 &worldPos )
//{
// unsigned int tempRef = this->worldScene.GetTemporaryReferenceOf( objRef );
// if( tempRef != this->worldScene.invalid_ref )
// {
// //this->worldScene.GetCustomBody( tempRef )->Set //!< @todo TODO: need function
// this->worldScene.EvaluatePosition( tempRef );
// }
//}
//
//void API_Impl::SetRotation( const ICustomBody* objRef, const Float4x4 &rotation )
//{
// unsigned int tempRef = this->worldScene.GetTemporaryReferenceOf( objRef );
// if( tempRef != this->worldScene.invalid_ref )
// {
// this->worldScene.GetCustomBody( tempRef )->SetRotation( rotation );
// this->worldScene.EvaluatePosition( tempRef );
// }
//}
//
//void API_Impl::SetOrientation( const ICustomBody* objRef, const Float4x4 &orientation )
//{
// unsigned int tempRef = this->worldScene.GetTemporaryReferenceOf( objRef );
// if( tempRef != this->worldScene.invalid_ref )
// {
// this->worldScene.GetCustomBody( tempRef )->SetOrientation( orientation );
// this->worldScene.EvaluatePosition( tempRef );
// }
//}
//
//void API_Impl::SetSize( const ICustomBody* objRef, const Float3 &size )
//{
// unsigned int tempRef = this->worldScene.GetTemporaryReferenceOf( objRef );
// if( tempRef != this->worldScene.invalid_ref )
// {
// this->worldScene.GetCustomBody( tempRef )->SetSize( size );
// this->worldScene.EvaluatePosition( tempRef );
// }
//}
UniquePointer<ICustomBody> API_Impl::CreateRigidBody( const API::SimpleBodyDescription &desc ) const
{
return new SimpleRigidBody( desc );
}
UniquePointer<ICustomBody> API_Impl::CreateRigidBody( const API::SphericalBodyDescription &desc ) const
{
return new SphericalRigidBody( desc );
}
2013-11-28 17:59:12 +01:00
namespace Oyster { namespace Physics
{
2013-11-28 17:59:12 +01:00
namespace Default
{
void EventAction_Destruction( ::Utility::DynamicMemory::UniquePointer<::Oyster::Physics::ICustomBody> proto )
{ /* Do nothing except allowing the proto uniquePointer destroy itself. */ }
2013-11-28 17:59:12 +01:00
::Oyster::Physics::ICustomBody::SubscriptMessage EventAction_Collision( const ::Oyster::Physics::ICustomBody *proto, const ::Oyster::Physics::ICustomBody *deuter )
{ /* Do nothing except returning business as usual. */
return ::Oyster::Physics::ICustomBody::SubscriptMessage_none;
}
2014-01-22 13:50:54 +01:00
void EventAction_CollisionResponse( const ::Oyster::Physics::ICustomBody *proto, const ::Oyster::Physics::ICustomBody *deuter, ::Oyster::Math::Float kineticEnergyLoss )
{ /* Do nothing except returning business as usual. */
}
void EventAction_Move( const ::Oyster::Physics::ICustomBody *object )
{ /* Do nothing. */ }
}
2013-11-28 17:59:12 +01:00
} }