anchor.diff:  
   	NewTorque = vector:multiply(1.0 / 6.0, vector:add(Torque1, vector:multiply(2.0, vector:add(Torque2, Torque3)), Torque4)),
   
  -	NewState = dict:from_list([
  -		{ position, vector:add(Position, vector:multiply(TimeDelta, NewVelocity)) },
  -		{ linear_velocity, vector:add(Velocity, vector:multiply(TimeDelta, NewAcceleration)) },
  -		{
  -			orientation, quaternion:unit({
  -				OrientW + TimeDelta * NewSpinW,
  -				OrientX + TimeDelta * NewSpinX,
  -				OrientY + TimeDelta * NewSpinY,
  -				OrientZ + TimeDelta * NewSpinZ
  -			})
  -		},
  -		{ angular_momentum, vector:add(AngularMomentum, vector:multiply(TimeDelta, NewTorque)) }
  -	]),
  -
  -	% Merge in State 4 and the calculated state. Note: This might not be required, but it protects us from ever loosing state unexpectedly.
  -	dict:merge(fun(_Key, _InitialVal, NewVal) ->
  -		NewVal
  -	end, State4, NewState).
  +	State4#physical{
  +		position = vector:add(Position, vector:multiply(TimeDelta, NewVelocity)),
  +		linear_velocity = vector:add(Velocity, vector:multiply(TimeDelta, NewAcceleration)),
  +		orientation = quaternion:unit({
  +			OrientW + TimeDelta * NewSpinW,
  +			OrientX + TimeDelta * NewSpinX,
  +			OrientY + TimeDelta * NewSpinY,
  +			OrientZ + TimeDelta * NewSpinZ
  +		}),
  +		angular_momentum = vector:add(AngularMomentum, vector:multiply(TimeDelta, NewTorque))
  +	}.
  
positive.code: 	Force :: vector:vec(),
  	Spin :: quaternion:quat(),
  	Torque :: vector:vec(),
  	State :: dict().
  
  evaluate(TimeDelta, Velocity, Force, Spin, Torque, State) ->
  
  	Position = dict:fetch(position, State),
  	InitialVelocity = dict:fetch(linear_velocity, State),
  	Orientation = dict:fetch(orientation, State),
  	AngularMomentum = dict:fetch(angular_momentum ,State),
  
  	{SpinW, SpinX, SpinY, SpinZ} = Spin,
  	{OrientW, OrientX, OrientY, OrientZ} = Orientation,
  
negative.code: 			Orientation
  		)
  	),
  	NewState = State#physical{
  		linear_velocity = LinearVelocity,
  		angular_velocity = AngularVelocity,
  		spin = Spin
  	},
  	{Spin, NewState}.
  
  %% ------------------------------------------------------------------------
  
  %% @doc Simulate physical movement of the 'physical' object represented by `State`, over the given `TimeDelta`.
  simulate(TimeDelta, InitialPhysical) ->
  
  	Physical = #physical{
  			position = dict:fetch(position, InitialPhysical),
  			linear_momentum = dict:fetch(linear_momentum, InitialPhysical),
  			orientation = dict:fetch(orientation, InitialPhysical),
  			angular_momentum = dict:fetch(angular_momentum, InitialPhysical),
  
  			force_absolute = dict:fetch(force_absolute, InitialPhysical),
  			force_relative = dict:fetch(force_relative, InitialPhysical),
  			torque_absolute = dict:fetch(torque_absolute, InitialPhysical),
  			torque_relative = dict:fetch(torque_relative, InitialPhysical),
  
  			last_update = dict:fetch(last_update, InitialPhysical),
  			linear_velocity = dict:fetch(linear_velocity, InitialPhysical),
  			angular_velocity = dict:fetch(angular_velocity, InitialPhysical),
  			spin = dict:fetch(spin, InitialPhysical),
  
  			mass = dict:fetch(mass, InitialPhysical),
  			inverse_mass = dict:fetch(inverse_mass, InitialPhysical),
  			inertia_tensor = dict:fetch(inertia_tensor, InitialPhysical),
  			inverse_inertia_tensor = dict:fetch(inverse_inertia_tensor, InitialPhysical)
  	},
  
  	NewPhysical = simulate_internal(TimeDelta, Physical),
  
  	dict:from_list([
  			{ position, NewPhysical#physical.position },
  			{ linear_momentum, NewPhysical#physical.linear_momentum },
  			{ orientation, NewPhysical#physical.orientation },
  			{ angular_momentum, NewPhysical#physical.angular_momentum },
  
  			{ force_absolute, NewPhysical#physical.force_absolute },
  			{ force_relative, NewPhysical#physical.force_relative },
  			{ torque_absolute, NewPhysical#physical.torque_absolute },
  			{ torque_relative, NewPhysical#physical.torque_relative },
  
  			{ last_update, NewPhysical#physical.last_update },
  			{ linear_velocity, NewPhysical#physical.linear_velocity },
  			{ angular_velocity, NewPhysical#physical.angular_velocity },
  			{ spin, NewPhysical#physical.spin },
  
  			{ mass, NewPhysical#physical.mass },
  			{ inverse_mass, NewPhysical#physical.inverse_mass },
  			{ inertia_tensor, NewPhysical#physical.inertia_tensor },
  			{ inverse_inertia_tensor, NewPhysical#physical.inverse_inertia_tensor }
  	]).
  
  %% ------------------------------------------------------------------------
  
  simulate_internal(TimeDelta, State) ->
  	#physical{
  		position = Position,
  		linear_velocity = Velocity,
  		orientation = {OrientW, OrientX, OrientY, OrientZ},
  		angular_momentum = AngularMomentum
  	} = State,
  
  	{Velocity1, Force1, Spin1, Torque1, State1} = evaluate(0, {0, 0, 0}, {0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0}, State),
  	{Velocity2, Force2, Spin2, Torque2, State2} = evaluate(TimeDelta * 0.5, Velocity1, Force1, Spin1, Torque1, State1),
  