Merge remote-tracking branch 'origin/Physics' into GameLogic

Conflicts:
	Bin/Content/Shaders/TextureDebug.cso

Code/Game/GameLogic/Player.cpp

@@ -62,6 +62,7 @@ void Player::Move(const PLAYER_MOVEMENT &movement)
 	switch(movement)
 	{
 		case PLAYER_MOVEMENT_FORWARD:
+			
 			break;
 
 		case PLAYER_MOVEMENT_BACKWARD:

Code/GamePhysics/GamePhysics.vcxproj

@@ -91,9 +91,12 @@
       <Optimization>Disabled</Optimization>
       <AdditionalIncludeDirectories>$(SolutionDir)Misc;$(SolutionDir)OysterMath;$(SolutionDir)OysterPhysics3D;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>_WINDLL;PHYSICS_DLL_EXPORT;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <GenerateXMLDocumentationFiles>false</GenerateXMLDocumentationFiles>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>
+      <ModuleDefinitionFile>
+      </ModuleDefinitionFile>
     </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
@@ -102,9 +105,12 @@
       <Optimization>Disabled</Optimization>
       <AdditionalIncludeDirectories>$(SolutionDir)Misc;$(SolutionDir)OysterMath;$(SolutionDir)OysterPhysics3D;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>_WINDLL;PHYSICS_DLL_EXPORT;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <GenerateXMLDocumentationFiles>false</GenerateXMLDocumentationFiles>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>
+      <ModuleDefinitionFile>
+      </ModuleDefinitionFile>
     </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
@@ -115,11 +121,14 @@
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <AdditionalIncludeDirectories>$(SolutionDir)Misc;$(SolutionDir)OysterMath;$(SolutionDir)OysterPhysics3D;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>_WINDLL;PHYSICS_DLL_EXPORT;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <GenerateXMLDocumentationFiles>false</GenerateXMLDocumentationFiles>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
       <OptimizeReferences>true</OptimizeReferences>
+      <ModuleDefinitionFile>
+      </ModuleDefinitionFile>
     </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
@@ -130,11 +139,14 @@
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <AdditionalIncludeDirectories>$(SolutionDir)Misc;$(SolutionDir)OysterMath;$(SolutionDir)OysterPhysics3D;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>_WINDLL;PHYSICS_DLL_EXPORT;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <GenerateXMLDocumentationFiles>false</GenerateXMLDocumentationFiles>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
       <OptimizeReferences>true</OptimizeReferences>
+      <ModuleDefinitionFile>
+      </ModuleDefinitionFile>
     </Link>
   </ItemDefinitionGroup>
   <ItemGroup>
@@ -154,6 +166,8 @@
     <ClInclude Include="Implementation\SimpleRigidBody.h" />
     <ClInclude Include="Implementation\SphericalRigidBody.h" />
     <ClInclude Include="PhysicsAPI.h" />
+    <ClInclude Include="PhysicsStructs-Impl.h" />
+    <ClInclude Include="PhysicsStructs.h" />
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Implementation\Octree.cpp" />

Code/GamePhysics/GamePhysics.vcxproj.filters

@@ -36,6 +36,12 @@
     <ClInclude Include="Implementation\Octree.h">
       <Filter>Header Files\Implementation</Filter>
     </ClInclude>
+    <ClInclude Include="PhysicsStructs.h">
+      <Filter>Header Files\Include</Filter>
+    </ClInclude>
+    <ClInclude Include="PhysicsStructs-Impl.h">
+      <Filter>Header Files\Include</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Implementation\PhysicsAPI_Impl.cpp">

Code/GamePhysics/Implementation/Octree.cpp

@@ -39,7 +39,7 @@ void Octree::AddObject(UniquePointer< ICustomBody > customBodyRef)
 	data.next = NULL;
 	data.prev = NULL;
 	data.customBodyRef = customBodyRef;
-	this->mapReferences.insert(std::pair <ICustomBody*, unsigned int> (customBodyRef, this->leafData.size()));
+	this->mapReferences.insert(std::pair <ICustomBody*, unsigned int> (data.customBodyRef, this->leafData.size()));
 	this->leafData.push_back(data);
 
 	/*if(tempPtr != NULL)
@@ -184,6 +184,7 @@ unsigned int Octree::GetTemporaryReferenceOf( const ICustomBody* objRef ) const
 
 void Octree::SetAsAltered( unsigned int tempRef )
 {
+	this->leafData[tempRef].container = this->leafData[tempRef].customBodyRef->GetBoundingSphere();
 	//! @todo TODO: implement stub
 }
 

Code/GamePhysics/Implementation/PhysicsAPI_Impl.cpp

@@ -20,36 +20,36 @@ namespace
 
 		float deltaWhen;
 		Float3 worldWhere;
-		if( deuter->Intersects(*deuter, 1.0f, deltaWhen, worldWhere) )
+		if( proto->Intersects(*deuter, 1.0f, deltaWhen, worldWhere) )
 		{
 			proto->CallSubscription( proto, deuter );
 		}
 	}
 }
 
-Float4x4 & MomentOfInertia::CreateSphereMatrix( const Float mass, const Float radius)
+Float4x4 & MomentOfInertia::CreateSphereMatrix( const Float mass, const Float radius, ::Oyster::Math::Float4x4 &targetMem )
 {
-	return Formula::MomentOfInertia::Sphere(mass, radius);
+	return targetMem = Formula::MomentOfInertia::Sphere(mass, radius);
 }
 
-Float4x4 & MomentOfInertia::CreateHollowSphereMatrix( const Float mass, const Float radius)
+Float4x4 & MomentOfInertia::CreateHollowSphereMatrix( const Float mass, const Float radius, ::Oyster::Math::Float4x4 &targetMem )
 {
-	return Formula::MomentOfInertia::HollowSphere(mass, radius);
+	return targetMem = Formula::MomentOfInertia::HollowSphere(mass, radius);
 }
 
-Float4x4 & MomentOfInertia::CreateCuboidMatrix( const Float mass, const Float height, const Float width, const Float depth )
+Float4x4 & MomentOfInertia::CreateCuboidMatrix( const Float mass, const Float height, const Float width, const Float depth, ::Oyster::Math::Float4x4 &targetMem )
 {
-	return Formula::MomentOfInertia::Cuboid(mass, height, width, depth);
+	return targetMem = Formula::MomentOfInertia::Cuboid(mass, height, width, depth);
 }
 
-Float4x4 & MomentOfInertia::CreateCylinderMatrix( const Float mass, const Float height, const Float radius )
+Float4x4 & MomentOfInertia::CreateCylinderMatrix( const Float mass, const Float height, const Float radius, ::Oyster::Math::Float4x4 &targetMem )
 {
-	return Formula::MomentOfInertia::Cylinder(mass, height, radius);
+	return targetMem = Formula::MomentOfInertia::Cylinder(mass, height, radius);
 }
 
-Float4x4 & MomentOfInertia::CreateRodMatrix( const Float mass, const Float length )
+Float4x4 & MomentOfInertia::CreateRodMatrix( const Float mass, const Float length, ::Oyster::Math::Float4x4 &targetMem )
 {
-	return Formula::MomentOfInertia::RodCenter(mass, length);
+	return targetMem = Formula::MomentOfInertia::RodCenter(mass, length);
 }
 
 API & API::Instance()

Code/GamePhysics/Implementation/SimpleRigidBody.cpp

@@ -42,6 +42,23 @@ UniquePointer<ICustomBody> SimpleRigidBody::Clone() const
 	return new SimpleRigidBody( *this );
 }
 
+SimpleRigidBody::State SimpleRigidBody::GetState() const
+{
+	return State( this->rigid.box.boundingOffset, this->rigid.box.center, AngularAxis(this->rigid.box.rotation).xyz );
+}
+
+SimpleRigidBody::State & SimpleRigidBody::GetState( SimpleRigidBody::State &targetMem ) const
+{
+	return targetMem = State( this->rigid.box.boundingOffset, this->rigid.box.center, AngularAxis(this->rigid.box.rotation).xyz );
+}
+
+void SimpleRigidBody::SetState( const SimpleRigidBody::State &state )
+{ /** @todo TODO: temporary solution! Need to know it's occtree */
+	this->rigid.box.boundingOffset = state.GetReach();
+	this->rigid.box.center = state.GetCenterPosition();
+	this->rigid.box.rotation = state.GetRotation();
+}
+
 void SimpleRigidBody::CallSubscription( const ICustomBody *proto, const ICustomBody *deuter )
 {
 	this->collisionAction( proto, deuter );
@@ -107,6 +124,12 @@ Float4x4 & SimpleRigidBody::GetView( Float4x4 &targetMem ) const
 	return targetMem = this->rigid.GetView();
 }
 
+Float3 SimpleRigidBody::GetRigidLinearVelocity() const
+{
+	return this->rigid.GetLinearVelocity();
+}
+
+
 UpdateState SimpleRigidBody::Update( Float timeStepLength )
 {
 	this->rigid.Update_LeapFrog( timeStepLength );
@@ -177,4 +200,9 @@ void SimpleRigidBody::SetOrientation( const Float4x4 &orientation )
 void SimpleRigidBody::SetSize( const Float3 &size )
 {
 	this->rigid.SetSize( size );
+}
+
+void SimpleRigidBody::SetMomentum( const Float3 &worldG )
+{
+	this->rigid.SetLinearMomentum( worldG );
 }

Code/GamePhysics/Implementation/SimpleRigidBody.h

@@ -15,6 +15,11 @@ namespace Oyster { namespace Physics
 
 		::Utility::DynamicMemory::UniquePointer<ICustomBody> Clone() const;
 		
+		State GetState() const;
+		State & GetState( State &targetMem ) const;
+		void SetState( const State &state );
+		::Oyster::Math::Float3 GetRigidLinearVelocity() const;
+
 		void CallSubscription( const ICustomBody *proto, const ICustomBody *deuter );
 		bool IsAffectedByGravity() const;
 		bool Intersects( const ICustomBody &object, ::Oyster::Math::Float timeStepLength, ::Oyster::Math::Float &deltaWhen, ::Oyster::Math::Float3 &worldPointOfContact ) const;
@@ -41,6 +46,7 @@ namespace Oyster { namespace Physics
 		void SetRotation( const ::Oyster::Math::Float4x4 &rotation );
 		void SetOrientation( const ::Oyster::Math::Float4x4 &orientation );
 		void SetSize( const ::Oyster::Math::Float3 &size );
+		void SetMomentum( const ::Oyster::Math::Float3 &worldG );
 
 	private:
 		::Oyster::Physics3D::RigidBody rigid;

Code/GamePhysics/Implementation/SphericalRigidBody.cpp

@@ -44,6 +44,23 @@ UniquePointer<ICustomBody> SphericalRigidBody::Clone() const
 	return new SphericalRigidBody( *this );
 }
 
+SphericalRigidBody::State SphericalRigidBody::GetState() const
+{
+	return State( this->rigid.box.boundingOffset, this->rigid.box.center, AngularAxis(this->rigid.box.rotation).xyz );
+}
+
+SphericalRigidBody::State & SphericalRigidBody::GetState( SphericalRigidBody::State &targetMem ) const
+{
+	return targetMem = State( this->rigid.box.boundingOffset, this->rigid.box.center, AngularAxis(this->rigid.box.rotation).xyz );
+}
+
+void SphericalRigidBody::SetState( const SphericalRigidBody::State &state )
+{ /** @todo TODO: temporary solution! Need to know it's occtree */
+	this->rigid.box.boundingOffset = state.GetReach();
+	this->rigid.box.center = state.GetCenterPosition();
+	this->rigid.box.rotation = state.GetRotation();
+}
+
 void SphericalRigidBody::CallSubscription( const ICustomBody *proto, const ICustomBody *deuter )
 {
 	this->collisionAction( proto, deuter );
@@ -109,6 +126,11 @@ Float4x4 & SphericalRigidBody::GetView( Float4x4 &targetMem ) const
 	return targetMem = this->rigid.GetView();
 }
 
+Float3 SphericalRigidBody::GetRigidLinearVelocity() const
+{
+	return this->rigid.GetLinearVelocity();
+}
+
 UpdateState SphericalRigidBody::Update( Float timeStepLength )
 {
 	this->rigid.Update_LeapFrog( timeStepLength );
@@ -183,4 +205,9 @@ void SphericalRigidBody::SetSize( const Float3 &size )
 {
 	this->rigid.SetSize( size );
 	this->body.radius = 0.5f * Min( Min( size.x, size.y ), size.z ); // inline Min( FloatN )?
+}
+
+void SphericalRigidBody::SetMomentum( const Float3 &worldG )
+{
+	this->rigid.SetLinearMomentum( worldG );
 }

Code/GamePhysics/Implementation/SphericalRigidBody.h

@@ -16,6 +16,11 @@ namespace Oyster { namespace Physics
 
 		::Utility::DynamicMemory::UniquePointer<ICustomBody> Clone() const;
 		
+		State GetState() const;
+		State & GetState( State &targetMem = State() ) const;
+		void SetState( const State &state );
+		::Oyster::Math::Float3 GetRigidLinearVelocity() const;
+
 		void CallSubscription( const ICustomBody *proto, const ICustomBody *deuter );
 		bool IsAffectedByGravity() const;
 		bool Intersects( const ICustomBody &object, ::Oyster::Math::Float timeStepLength, ::Oyster::Math::Float &deltaWhen, ::Oyster::Math::Float3 &worldPointOfContact ) const;
@@ -42,6 +47,7 @@ namespace Oyster { namespace Physics
 		void SetRotation( const ::Oyster::Math::Float4x4 &rotation );
 		void SetOrientation( const ::Oyster::Math::Float4x4 &orientation );
 		void SetSize( const ::Oyster::Math::Float3 &size );
+		void SetMomentum( const ::Oyster::Math::Float3 &worldG );
 
 	private:
 		::Oyster::Physics3D::RigidBody rigid;

Code/GamePhysics/PhysicsAPI.h

@@ -17,6 +17,13 @@ namespace Oyster
 		class API;
 		class ICustomBody;
 
+		namespace Struct
+		{
+			struct SimpleBodyDescription;
+			struct SphericalBodyDescription;
+			struct CustomBodyState;
+		}
+
 		enum UpdateState
 		{
 			UpdateState_resting,
@@ -31,22 +38,22 @@ namespace Oyster
 		class PHYSICS_DLL_USAGE MomentOfInertia
 		{
 		public:
-			static ::Oyster::Math::Float4x4 & CreateSphereMatrix( const ::Oyster::Math::Float mass, const ::Oyster::Math::Float radius);
+			static ::Oyster::Math::Float4x4 & CreateSphereMatrix( const ::Oyster::Math::Float mass, const ::Oyster::Math::Float radius, ::Oyster::Math::Float4x4 &targetMem = ::Oyster::Math::Float4x4() );
-				
+			
-			static ::Oyster::Math::Float4x4 & CreateHollowSphereMatrix( const ::Oyster::Math::Float mass, const ::Oyster::Math::Float radius);
+			static ::Oyster::Math::Float4x4 & CreateHollowSphereMatrix( const ::Oyster::Math::Float mass, const ::Oyster::Math::Float radius, ::Oyster::Math::Float4x4 &targetMem = ::Oyster::Math::Float4x4() );
 
-			static ::Oyster::Math::Float4x4 & CreateCuboidMatrix( const ::Oyster::Math::Float mass, const ::Oyster::Math::Float height, const ::Oyster::Math::Float width, const ::Oyster::Math::Float depth );
+			static ::Oyster::Math::Float4x4 & CreateCuboidMatrix( const ::Oyster::Math::Float mass, const ::Oyster::Math::Float height, const ::Oyster::Math::Float width, const ::Oyster::Math::Float depth, ::Oyster::Math::Float4x4 &targetMem = ::Oyster::Math::Float4x4() );
 
-			static ::Oyster::Math::Float4x4 & CreateCylinderMatrix( const ::Oyster::Math::Float mass, const ::Oyster::Math::Float height, const ::Oyster::Math::Float radius );
+			static ::Oyster::Math::Float4x4 & CreateCylinderMatrix( const ::Oyster::Math::Float mass, const ::Oyster::Math::Float height, const ::Oyster::Math::Float radius, ::Oyster::Math::Float4x4 &targetMem = ::Oyster::Math::Float4x4() );
 	
-			static ::Oyster::Math::Float4x4 & CreateRodMatrix( const ::Oyster::Math::Float mass, const ::Oyster::Math::Float length );
+			static ::Oyster::Math::Float4x4 & CreateRodMatrix( const ::Oyster::Math::Float mass, const ::Oyster::Math::Float length, ::Oyster::Math::Float4x4 &targetMem = ::Oyster::Math::Float4x4() );
 		};
 
 		class PHYSICS_DLL_USAGE API
 		{
 		public:
-			struct SimpleBodyDescription;
+			typedef Struct::SimpleBodyDescription SimpleBodyDescription;
-			struct SphericalBodyDescription;
+			typedef Struct::SphericalBodyDescription SphericalBodyDescription;
 
 			typedef void (*EventAction_Destruction)( ::Utility::DynamicMemory::UniquePointer<ICustomBody> proto );
 
@@ -236,7 +243,15 @@ namespace Oyster
 				SubscriptMessage_ignore_collision_response
 			};
 
+			/********************************************************
+			 * @param gameObjectRef: a pointer to the object in the game owning the rigid body.
+			 ********************************************************/
+			void* gameObjectRef;
+
 			typedef SubscriptMessage (*EventAction_Collision)( const ICustomBody *proto, const ICustomBody *deuter );
+			typedef Struct::SimpleBodyDescription SimpleBodyDescription;
+			typedef Struct::SphericalBodyDescription SphericalBodyDescription;
+			typedef Struct::CustomBodyState State;
 
 			virtual ~ICustomBody() {};
 
@@ -251,6 +266,26 @@ namespace Oyster
 			 ********************************************************/
 			virtual void CallSubscription( const ICustomBody *proto, const ICustomBody *deuter ) = 0;
 
+			/********************************************************
+			 * @todo TODO: need doc
+			 ********************************************************/
+			virtual State GetState() const = 0;
+
+			/********************************************************
+			 * @todo TODO: need doc
+			 ********************************************************/
+			virtual State & GetState( State &targetMem ) const = 0;
+
+			/********************************************************
+			 * @return the linear velocity of the rigid body in a vector.
+			 ********************************************************/
+			virtual Math::Float3 GetRigidLinearVelocity() const = 0;
+
+			/********************************************************
+			 * @todo TODO: need doc
+			 ********************************************************/
+			virtual void SetState( const State &state ) = 0;
+
 			/********************************************************
 			 * @return true if Engine should apply gravity on this object.
 			 ********************************************************/
@@ -390,49 +425,16 @@ namespace Oyster
 			 * Use API::SetSize(...)
 			 ********************************************************/
 			virtual void SetSize( const ::Oyster::Math::Float3 &size ) = 0;
-		};
 
-		struct API::SimpleBodyDescription
+			/********************************************************
-		{
+			 * To not be called if is in Engine
-			::Oyster::Math::Float4x4 rotation;
+			 * Use API::?? @todo TODO: 
-			::Oyster::Math::Float3 centerPosition;
+			 ********************************************************/
-			::Oyster::Math::Float3 size;
+			virtual void SetMomentum( const ::Oyster::Math::Float3 &worldG ) = 0;
-			::Oyster::Math::Float mass;
-			::Oyster::Math::Float4x4 inertiaTensor;
-			ICustomBody::EventAction_Collision subscription;
-			bool ignoreGravity;
-
-			SimpleBodyDescription()
-			{
-				this->rotation = ::Oyster::Math::Float4x4::identity;
-				this->centerPosition = ::Oyster::Math::Float3::null;
-				this->size = ::Oyster::Math::Float3( 1.0f );
-				this->mass = 12.0f;
-				this->inertiaTensor = ::Oyster::Math::Float4x4::identity;
-				this->subscription = NULL;
-				this->ignoreGravity = false;
-			}
-		};
-
-		struct API::SphericalBodyDescription
-		{
-			::Oyster::Math::Float4x4 rotation;
-			::Oyster::Math::Float3 centerPosition;
-			::Oyster::Math::Float radius;
-			::Oyster::Math::Float mass;
-			ICustomBody::EventAction_Collision subscription;
-			bool ignoreGravity;
-
-			SphericalBodyDescription()
-			{
-				this->rotation = ::Oyster::Math::Float4x4::identity;
-				this->centerPosition = ::Oyster::Math::Float3::null;
-				this->radius = 0.5f;
-				this->mass = 10.0f;
-				this->subscription = NULL;
-				this->ignoreGravity = false;
-			}
 		};
 	}
 }
+
+#include "PhysicsStructs.h"
+
 #endif

Code/GamePhysics/PhysicsStructs-Impl.h

@@ -0,0 +1,117 @@
+#ifndef PHYSICS_STRUCTS_IMPL_H
+#define PHYSICS_STRUCTS_IMPL_H
+
+#include "PhysicsStructs.h"
+
+namespace Oyster { namespace Physics
+{
+	namespace Struct
+	{
+		inline SimpleBodyDescription::SimpleBodyDescription()
+		{
+			this->rotation = ::Oyster::Math::Float4x4::identity;
+			this->centerPosition = ::Oyster::Math::Float3::null;
+			this->size = ::Oyster::Math::Float3( 1.0f );
+			this->mass = 12.0f;
+			this->inertiaTensor = ::Oyster::Math::Float4x4::identity;
+			this->subscription = NULL;
+			this->ignoreGravity = false;
+		}
+
+		inline SphericalBodyDescription::SphericalBodyDescription()
+		{
+			this->rotation = ::Oyster::Math::Float4x4::identity;
+			this->centerPosition = ::Oyster::Math::Float3::null;
+			this->radius = 0.5f;
+			this->mass = 10.0f;
+			this->subscription = NULL;
+			this->ignoreGravity = false;
+		}
+
+
+		inline CustomBodyState::CustomBodyState( const ::Oyster::Math::Float3 &reach, const ::Oyster::Math::Float3 &centerPos, const ::Oyster::Math::Float3 &rotation )
+		{
+			this->reach = ::Oyster::Math::Float4( reach, 0.0f );
+			this->centerPos = ::Oyster::Math::Float4( centerPos, 1.0f );
+			this->angularAxis = ::Oyster::Math::Float4( rotation, 0.0f );
+			this->isSpatiallyAltered = this->isDisturbed = false;
+		}
+
+		inline CustomBodyState & CustomBodyState::operator = ( const CustomBodyState &state )
+		{
+			this->reach = state.reach;
+			this->centerPos = state.centerPos;
+			this->angularAxis = state.angularAxis;
+
+			this->isSpatiallyAltered = state.isSpatiallyAltered;
+			this->isDisturbed = state.isDisturbed;
+			return *this;
+		}
+
+		inline const ::Oyster::Math::Float4 & CustomBodyState::GetReach() const
+		{
+			return this->reach;
+		}
+
+		inline ::Oyster::Math::Float4 CustomBodyState::GetSize() const
+		{
+			return 2.0f * this->GetReach();
+		}
+
+		inline const ::Oyster::Math::Float4 & CustomBodyState::GetCenterPosition() const
+		{
+			return this->centerPos;
+		}
+
+		inline const ::Oyster::Math::Float4 & CustomBodyState::GetAngularAxis() const
+		{
+			return this->angularAxis;
+		}
+
+		inline ::Oyster::Math::Float4x4 CustomBodyState::GetRotation() const
+		{
+			return ::Oyster::Math3D::RotationMatrix( this->GetAngularAxis().xyz );
+		}
+
+		inline void CustomBodyState::SetSize( const ::Oyster::Math::Float3 &size )
+		{
+			this->SetReach( 0.5f * size );
+		}
+
+		inline void CustomBodyState::SetReach( const ::Oyster::Math::Float3 &halfSize )
+		{
+			this->reach.xyz = halfSize;
+			this->reach = ::Utility::Value::Max( this->reach, ::Oyster::Math::Float4::null );
+			this->isSpatiallyAltered = this->isDisturbed = true;
+		}
+
+		inline void CustomBodyState::SetCenterPosition( const ::Oyster::Math::Float3 &centerPos )
+		{
+			this->centerPos.xyz = centerPos;
+			this->isSpatiallyAltered = this->isDisturbed = true;
+		}
+
+		inline void CustomBodyState::SetRotation( const ::Oyster::Math::Float3 &angularAxis )
+		{
+			this->angularAxis.xyz = angularAxis;
+			this->isSpatiallyAltered = this->isDisturbed = true;
+		}
+
+		inline void CustomBodyState::SetRotation( const ::Oyster::Math::Float4x4 &rotation )
+		{
+			this->SetRotation( ::Oyster::Math3D::AngularAxis(rotation).xyz );
+		}
+
+		inline bool CustomBodyState::IsSpatiallyAltered() const
+		{
+			return this->isSpatiallyAltered;
+		}
+
+		inline bool CustomBodyState::IsDisturbed() const
+		{
+			return this->isDisturbed;
+		}
+	}
+} }
+
+#endif

Code/GamePhysics/PhysicsStructs.h

@@ -0,0 +1,70 @@
+#ifndef PHYSICS_STRUCTS_H
+#define PHYSICS_STRUCTS_H
+
+#include "OysterMath.h"
+#include "PhysicsAPI.h"
+
+namespace Oyster { namespace Physics
+{
+	namespace Struct
+	{
+		struct SimpleBodyDescription
+		{
+			::Oyster::Math::Float4x4 rotation;
+			::Oyster::Math::Float3 centerPosition;
+			::Oyster::Math::Float3 size;
+			::Oyster::Math::Float mass;
+			::Oyster::Math::Float4x4 inertiaTensor;
+			::Oyster::Physics::ICustomBody::EventAction_Collision subscription;
+			bool ignoreGravity;
+
+			SimpleBodyDescription();
+		};
+
+		struct SphericalBodyDescription
+		{
+			::Oyster::Math::Float4x4 rotation;
+			::Oyster::Math::Float3 centerPosition;
+			::Oyster::Math::Float radius;
+			::Oyster::Math::Float mass;
+			::Oyster::Physics::ICustomBody::EventAction_Collision subscription;
+			bool ignoreGravity;
+
+			SphericalBodyDescription();
+		};
+
+		struct CustomBodyState
+		{
+		public:
+			CustomBodyState( const ::Oyster::Math::Float3 &reach		= ::Oyster::Math::Float3::null,
+							 const ::Oyster::Math::Float3 &centerPos	= ::Oyster::Math::Float3::null,
+							 const ::Oyster::Math::Float3 &rotation		= ::Oyster::Math::Float3::null );
+
+			CustomBodyState & operator = ( const CustomBodyState &state );
+
+			const ::Oyster::Math::Float4 & GetReach() const;
+				  ::Oyster::Math::Float4   GetSize() const;
+			const ::Oyster::Math::Float4 & GetCenterPosition() const;
+			const ::Oyster::Math::Float4 & GetAngularAxis() const;
+				  ::Oyster::Math::Float4x4 GetRotation() const;
+
+			void SetSize( const ::Oyster::Math::Float3 &size );
+			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 );
+
+			bool IsSpatiallyAltered() const;
+			bool IsDisturbed() const;
+
+		private:
+			::Oyster::Math::Float4 reach, centerPos, angularAxis;
+
+			bool isSpatiallyAltered, isDisturbed;
+		};
+	}
+} }
+
+#include "PhysicsStructs-Impl.h"
+
+#endif

Code/OysterMath/LinearMath.h

@@ -11,6 +11,27 @@
 #include "Quaternion.h"
 #include <math.h>
 
+namespace std
+{
+	template<typename ScalarType>
+	inline ::LinearAlgebra::Vector2<ScalarType> asin( const ::LinearAlgebra::Vector2<ScalarType> &vec )
+	{
+		return ::LinearAlgebra::Vector2<ScalarType>( asin(vec.x), asin(vec.y) );
+	}
+
+	template<typename ScalarType>
+	inline ::LinearAlgebra::Vector3<ScalarType> asin( const ::LinearAlgebra::Vector3<ScalarType> &vec )
+	{
+		return ::LinearAlgebra::Vector3<ScalarType>( asin(vec.x), asin(vec.y), asin(vec.z) );
+	}
+
+	template<typename ScalarType>
+	inline ::LinearAlgebra::Vector4<ScalarType> asin( const ::LinearAlgebra::Vector4<ScalarType> &vec )
+	{
+		return ::LinearAlgebra::Vector4<ScalarType>( asin(vec.x), asin(vec.y), asin(vec.z), asin(vec.w) );
+	}
+}
+
 // x2
 
 template<typename ScalarType>
@@ -233,6 +254,18 @@ namespace LinearAlgebra2D
 
 namespace LinearAlgebra3D
 {
+	template<typename ScalarType>
+	inline ::LinearAlgebra::Vector4<ScalarType> AngularAxis( const ::LinearAlgebra::Matrix3x3<ScalarType> &rotationMatrix )
+	{
+		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> AngularAxis( const ::LinearAlgebra::Matrix4x4<ScalarType> &rotationMatrix )
+	{
+		return ::std::asin( ::LinearAlgebra::Vector4<ScalarType>(rotationMatrix.v[1].z, rotationMatrix.v[2].x, rotationMatrix.v[0].y, 1) );
+	}
+
 	template<typename ScalarType>
 	inline ::LinearAlgebra::Matrix4x4<ScalarType> & TranslationMatrix( const ::LinearAlgebra::Vector3<ScalarType> &position, ::LinearAlgebra::Matrix4x4<ScalarType> &targetMem = ::LinearAlgebra::Matrix4x4<ScalarType>() )
 	{
@@ -286,7 +319,9 @@ namespace LinearAlgebra3D
 
 	template<typename ScalarType>
 	inline ::LinearAlgebra::Matrix3x3<ScalarType> & RotationMatrix_AxisZ( const ScalarType &radian, ::LinearAlgebra::Matrix3x3<ScalarType> &targetMem = ::LinearAlgebra::Matrix3x3<ScalarType>() )
-	{ return ::LinearAlgebra2D::RotationMatrix( radian, targetMem ); }
+	{
+		return ::LinearAlgebra2D::RotationMatrix( radian, targetMem );
+	}
 
 	template<typename ScalarType>
 	inline ::LinearAlgebra::Matrix4x4<ScalarType> & RotationMatrix_AxisZ( const ScalarType &radian, ::LinearAlgebra::Matrix4x4<ScalarType> &targetMem = ::LinearAlgebra::Matrix4x4<ScalarType>() )
@@ -300,7 +335,21 @@ namespace LinearAlgebra3D
 	}
 
 	template<typename ScalarType>
-	::LinearAlgebra::Matrix4x4<ScalarType> & RotationMatrix( const ::LinearAlgebra::Vector3<ScalarType> &normalizedAxis, const ScalarType &radian, ::LinearAlgebra::Matrix4x4<ScalarType> &targetMem )
+	inline ::LinearAlgebra::Matrix4x4<ScalarType> RotationMatrix( const ::LinearAlgebra::Vector3<ScalarType> &angularAxis )
+	{
+		ScalarType radian = angularAxis.GetMagnitude();
+		if( radian != 0 )
+		{
+			return RotationMatrix( angularAxis / radian, radian );
+		}
+		else
+		{
+			return ::LinearAlgebra::Matrix4x4<ScalarType>::identity;
+		}
+	}
+
+	template<typename ScalarType>
+	::LinearAlgebra::Matrix4x4<ScalarType> & RotationMatrix( const ::LinearAlgebra::Vector3<ScalarType> &normalizedAxis, const ScalarType &radian, ::LinearAlgebra::Matrix4x4<ScalarType> &targetMem = ::LinearAlgebra::Matrix4x4<ScalarType>() )
 	{ /// TODO: not verified
 		ScalarType r = radian * 0.5f,
 				   s = std::sin( r ),
@@ -462,7 +511,7 @@ namespace LinearAlgebra3D
 	::LinearAlgebra::Matrix4x4<ScalarType> & ProjectionMatrix_Perspective( const ScalarType &vertFoV, const ScalarType &aspect, const ScalarType &nearClip, const ScalarType &farClip, ::LinearAlgebra::Matrix4x4<ScalarType> &targetMem = ::LinearAlgebra::Matrix4x4<ScalarType>() )
 	{ 
 		ScalarType fov = 1 / ::std::tan( vertFoV * 0.5f ),
-					dDepth = farClip / (farClip - nearClip);
+				   dDepth = farClip / (farClip - nearClip);
 		return targetMem = ::LinearAlgebra::Matrix4x4<ScalarType>( fov / aspect, 0, 0, 0, 
 																   0, fov, 0, 0,
 																   0, 0, dDepth, -(dDepth * nearClip),
@@ -473,7 +522,7 @@ namespace LinearAlgebra3D
 	::LinearAlgebra::Matrix4x4<ScalarType> & ProjectionMatrix_Perspective( const ScalarType &left, const ScalarType &right, const ScalarType &top, const ScalarType &bottom, const ScalarType &nearClip, const ScalarType &farClip, ::LinearAlgebra::Matrix4x4<ScalarType> &targetMem = ::LinearAlgebra::Matrix4x4<ScalarType>() )
 	{ /** @todo TODO: not tested */
 		ScalarType fov = 1 / ::std::tan( vertFoV * 0.5f ),
-					dDepth = farClip / (farClip - nearClip);
+				   dDepth = farClip / (farClip - nearClip);
 		return targetMem = ::LinearAlgebra::Matrix4x4<ScalarType>( 2*nearClip/(right - left), 0, -(right + left)/(right - left), 0,
 																   0, 2*nearClip/(top - bottom), -(top + bottom)/(top - bottom), 0,
 																   0, 0, dDepth, -(dDepth * nearClip),

Code/OysterMath/OysterMath.cpp

@@ -81,20 +81,45 @@ namespace Oyster { namespace Math2D
 
 namespace Oyster { namespace Math3D
 {
+	Float4 AngularAxis( const Float3x3 &rotationMatrix )
+	{
+		return ::LinearAlgebra3D::AngularAxis( rotationMatrix );
+	}
+
+	Float4 AngularAxis( const Float4x4 &rotationMatrix )
+	{
+		return ::LinearAlgebra3D::AngularAxis( rotationMatrix );
+	}
+
 	Float4x4 & TranslationMatrix( const Float3 &position, Float4x4 &targetMem )
-	{ return ::LinearAlgebra3D::TranslationMatrix( position, targetMem ); }
+	{
+		return ::LinearAlgebra3D::TranslationMatrix( position, targetMem );
+	}
 
 	Float4x4 & RotationMatrix_AxisX( const Float &radian, Float4x4 &targetMem )
-	{ return ::LinearAlgebra3D::RotationMatrix_AxisX( radian, targetMem ); }
+	{
+		return ::LinearAlgebra3D::RotationMatrix_AxisX( radian, targetMem );
+	}
 
 	Float4x4 & RotationMatrix_AxisY( const Float &radian, Float4x4 &targetMem )
-	{ return ::LinearAlgebra3D::RotationMatrix_AxisY( radian, targetMem ); }
+	{
+		return ::LinearAlgebra3D::RotationMatrix_AxisY( radian, targetMem );
+	}
 
 	Float4x4 & RotationMatrix_AxisZ( const Float &radian, Float4x4 &targetMem )
-	{ return ::LinearAlgebra3D::RotationMatrix_AxisZ( radian, targetMem ); }
+	{
+		return ::LinearAlgebra3D::RotationMatrix_AxisZ( radian, targetMem );
+	}
+
+	Float4x4 & RotationMatrix( const Float3 &angularAxis, Float4x4 &targetMem )
+	{
+		return targetMem = ::LinearAlgebra3D::RotationMatrix( angularAxis );
+	}
 
 	Float4x4 & RotationMatrix( const Float &radian, const Float3 &normalizedAxis, Float4x4 &targetMem )
-	{ return ::LinearAlgebra3D::RotationMatrix( normalizedAxis, radian, targetMem ); }
+	{
+		return ::LinearAlgebra3D::RotationMatrix( normalizedAxis, radian, targetMem );
+	}
 	
 	Float3x3 & InverseRotationMatrix( const Float3x3 &rotation, Float3x3 &targetMem )
 	{
@@ -103,7 +128,8 @@ namespace Oyster { namespace Math3D
 	
 	Float4x4 & InverseRotationMatrix( const Float4x4 &rotation, Float4x4 &targetMem )
 	{
-		return targetMem = ::LinearAlgebra3D::InverseRotationMatrix( rotation );
+//		return targetMem = ::LinearAlgebra3D::InverseRotationMatrix( rotation );
+		return targetMem = rotation.GetTranspose();
 	}
 
 	Float4x4 & OrientationMatrix( const Float3x3 &rotation, const Float3 &translation, Float4x4 &targetMem )

Code/OysterMath/OysterMath.h

@@ -147,6 +147,12 @@ namespace Oyster { namespace Math3D /// Oyster's native math library specialized
 {
 	using namespace ::Oyster::Math; // deliberate inheritance from ::Oyster::Math namespace
 
+	//! Extracts the angularAxis from rotationMatrix
+	Float4 AngularAxis( const Float3x3 &rotationMatrix );
+
+	//! Extracts the angularAxis from rotationMatrix
+	Float4 AngularAxis( const Float4x4 &rotationMatrix );
+
 	/// Sets and returns targetMem to a translationMatrix with position as translation. 
 	Float4x4 & TranslationMatrix( const Float3 &position, Float4x4 &targetMem = Float4x4() );
 
@@ -159,6 +165,9 @@ namespace Oyster { namespace Math3D /// Oyster's native math library specialized
 	/// Sets and returns targetMem as an counterclockwise rotation matrix around the global Z-axis
 	Float4x4 & RotationMatrix_AxisZ( const Float &radian, Float4x4 &targetMem = Float4x4() );
 
+	/// Sets and returns targetMem as an counterclockwise rotation matrix around the angularAxis.
+	Float4x4 & RotationMatrix( const Float3 &angularAxis, Float4x4 &targetMem = Float4x4() );
+
 	/// Sets and returns targetMem as an counterclockwise rotation matrix around the normalizedAxis.
 	/// Please make sure normalizedAxis is normalized.
 	Float4x4 & RotationMatrix( const Float &radian, const Float3 &normalizedAxis, Float4x4 &targetMem = Float4x4() );

Code/OysterPhysics3D/OysterCollision3D.cpp

@@ -393,8 +393,8 @@ namespace Oyster { namespace Collision3D { namespace Utility
 
 	bool Intersect( const BoxAxisAligned &box, const Sphere &sphere )
 	{ // by Dan Andersson
-		Float3 e = Max( box.minVertex - sphere.center, Float3::null );
+		Float4 e = Max( Float4(box.minVertex - sphere.center, 0.0f), Float4::null );
-		e += Max( sphere.center - box.maxVertex, Float3::null );
+		e += Max( Float4(sphere.center - box.maxVertex, 0.0f), Float4::null );
 
 		if( e.Dot(e) > (sphere.radius * sphere.radius) ) return false;
 		return true;
@@ -459,12 +459,12 @@ namespace Oyster { namespace Collision3D { namespace Utility
 
 	bool Intersect( const Box &box, const Sphere &sphere )
 	{ // by Dan Andersson
-		Float3 e = sphere.center - box.center,
+		// center: sphere's center in the box's view space
-			   centerL = Float3( e.Dot(box.xAxis), e.Dot(box.yAxis), e.Dot(box.zAxis) );
+		Float4 center = TransformVector( InverseRotationMatrix(box.rotation), Float4(sphere.center - box.center, 0.0f) );
-		
+
-		e  = Max( (box.boundingOffset + centerL)*=-1.0f, Float3::null );
+		Float4 e = Max( Float4(-box.boundingOffset, 0.0f) - center, Float4::null );
-		e += Max( centerL - box.boundingOffset, Float3::null );
+		e += Max( center - Float4(box.boundingOffset, 0.0f), Float4::null );
-		
+
 		if( e.Dot(e) > (sphere.radius * sphere.radius) ) return false;
 		return true;
 	}

Code/OysterPhysics3D/Point.cpp

@@ -38,7 +38,7 @@ bool Point::Intersects( const ICollideable &target ) const
 	case Type_universe: return true;
 	case Type_point: return Utility::Intersect( *this, *(Point*)&target );
 	case Type_ray: return Utility::Intersect( *(Ray*)&target, *this, ((Ray*)&target)->collisionDistance );
-	case Type_sphere: Utility::Intersect( *(Sphere*)&target, *this );
+	case Type_sphere: return Utility::Intersect( *(Sphere*)&target, *this );
 	case Type_plane: return Utility::Intersect( *(Plane*)&target, *this );
 	 //case Type_triangle: return false; // TODO: 
 	case Type_box_axis_aligned: return Utility::Intersect( *(BoxAxisAligned*)&target, *this );

Code/OysterPhysics3D/Ray.cpp

@@ -60,7 +60,7 @@ bool Ray::Contains( const ICollideable &target ) const
 	switch( target.type )
 	{
 	case Type_point: return Utility::Intersect( *this, *(Point*)&target, this->collisionDistance );
-	case Type_ray: Utility::Contains( *this, *(Ray*)&target );
+	case Type_ray: return Utility::Contains( *this, *(Ray*)&target );
 	default: return false;
 	}
 }

Code/OysterPhysics3D/Sphere.cpp

@@ -35,7 +35,7 @@ bool Sphere::Intersects( const ICollideable &target ) const
 	case Type_universe: return true;
 	case Type_point: return Utility::Intersect( *this, *(Point*)&target );
 	case Type_ray: return Utility::Intersect( *this, *(Ray*)&target, ((Ray*)&target)->collisionDistance );
-	case Type_sphere: Utility::Intersect( *this, *(Sphere*)&target );
+	case Type_sphere: return Utility::Intersect( *this, *(Sphere*)&target );
 	case Type_plane: return Utility::Intersect( *(Plane*)&target, *this );
 	// case Type_triangle: return false; // TODO: 
 	case Type_box_axis_aligned: return Utility::Intersect( *(BoxAxisAligned*)&target, *this );