in Networked Physics/Assets/Scripts/Common.cs [507:708]
protected void DeterminePrediction( Context context, Context.ConnectionData connectionData, ushort currentSequence, int numCubes, ref int[] cubeIds, ref bool[] notChanged, ref bool[] hasDelta, ref bool[] perfectPrediction, ref bool[] hasPredictionDelta, ref ushort[] baselineSequence, ref CubeState[] cubeState, ref CubeDelta[] predictionDeltas )
{
Profiler.BeginSample( "DeterminePrediction" );
CubeState baselineCubeState = CubeState.defaults;
for ( int i = 0; i < numCubes; ++i )
{
perfectPrediction[i] = false;
hasPredictionDelta[i] = false;
#if !DISABLE_DELTA_ENCODING
if ( notChanged[i] )
continue;
if ( !hasDelta[i] )
continue;
if ( !cubeState[i].active )
continue;
if ( context.GetMostRecentAckedState( connectionData, cubeIds[i], ref baselineSequence[i], context.GetResetSequence(), ref baselineCubeState ) )
{
if ( Network.Util.BaselineDifference( currentSequence, baselineSequence[i] ) <= Constants.MaxBaselineDifference )
{
// baseline is too far behind. send the cube state absolute
continue;
}
if ( !baselineCubeState.active )
{
// no point predicting if the cube is at rest.
continue;
}
int baseline_sequence = baselineSequence[i];
int current_sequence = currentSequence;
if ( current_sequence < baseline_sequence )
current_sequence += 65536;
int baseline_position_x = baselineCubeState.position_x;
int baseline_position_y = baselineCubeState.position_y;
int baseline_position_z = baselineCubeState.position_z;
int baseline_linear_velocity_x = baselineCubeState.linear_velocity_x;
int baseline_linear_velocity_y = baselineCubeState.linear_velocity_y;
int baseline_linear_velocity_z = baselineCubeState.linear_velocity_z;
int baseline_angular_velocity_x = baselineCubeState.angular_velocity_x;
int baseline_angular_velocity_y = baselineCubeState.angular_velocity_y;
int baseline_angular_velocity_z = baselineCubeState.angular_velocity_z;
if ( current_sequence < baseline_sequence )
current_sequence += 65536;
int numFrames = current_sequence - baseline_sequence;
int predicted_position_x;
int predicted_position_y;
int predicted_position_z;
int predicted_linear_velocity_x;
int predicted_linear_velocity_y;
int predicted_linear_velocity_z;
int predicted_angular_velocity_x;
int predicted_angular_velocity_y;
int predicted_angular_velocity_z;
Prediction.PredictBallistic( numFrames,
baseline_position_x, baseline_position_y, baseline_position_z,
baseline_linear_velocity_x, baseline_linear_velocity_y, baseline_linear_velocity_z,
baseline_angular_velocity_x, baseline_angular_velocity_y, baseline_angular_velocity_z,
out predicted_position_x, out predicted_position_y, out predicted_position_z,
out predicted_linear_velocity_x, out predicted_linear_velocity_y, out predicted_linear_velocity_z,
out predicted_angular_velocity_x, out predicted_angular_velocity_y, out predicted_angular_velocity_z );
int current_position_x = cubeState[i].position_x;
int current_position_y = cubeState[i].position_y;
int current_position_z = cubeState[i].position_z;
int current_linear_velocity_x = cubeState[i].linear_velocity_x;
int current_linear_velocity_y = cubeState[i].linear_velocity_y;
int current_linear_velocity_z = cubeState[i].linear_velocity_z;
int current_angular_velocity_x = cubeState[i].angular_velocity_x;
int current_angular_velocity_y = cubeState[i].angular_velocity_y;
int current_angular_velocity_z = cubeState[i].angular_velocity_z;
int position_error_x = current_position_x - predicted_position_x;
int position_error_y = current_position_y - predicted_position_y;
int position_error_z = current_position_z - predicted_position_z;
int linear_velocity_error_x = current_linear_velocity_x - predicted_linear_velocity_x;
int linear_velocity_error_y = current_linear_velocity_y - predicted_linear_velocity_y;
int linear_velocity_error_z = current_linear_velocity_z - predicted_linear_velocity_z;
int angular_velocity_error_x = current_angular_velocity_x - predicted_angular_velocity_x;
int angular_velocity_error_y = current_angular_velocity_y - predicted_angular_velocity_y;
int angular_velocity_error_z = current_angular_velocity_z - predicted_angular_velocity_z;
if ( position_error_x == 0 &&
position_error_y == 0 &&
position_error_z == 0 &&
linear_velocity_error_x == 0 &&
linear_velocity_error_y == 0 &&
linear_velocity_error_z == 0 &&
angular_velocity_error_x == 0 &&
angular_velocity_error_y == 0 &&
angular_velocity_error_z == 0 )
{
perfectPrediction[i] = true;
}
else
{
int abs_position_error_x = Math.Abs( position_error_x );
int abs_position_error_y = Math.Abs( position_error_y );
int abs_position_error_z = Math.Abs( position_error_z );
int abs_linear_velocity_error_x = Math.Abs( linear_velocity_error_x );
int abs_linear_velocity_error_y = Math.Abs( linear_velocity_error_y );
int abs_linear_velocity_error_z = Math.Abs( linear_velocity_error_z );
int abs_angular_velocity_error_x = Math.Abs( angular_velocity_error_x );
int abs_angular_velocity_error_y = Math.Abs( angular_velocity_error_y );
int abs_angular_velocity_error_z = Math.Abs( angular_velocity_error_z );
int total_prediction_error = abs_position_error_x +
abs_position_error_y +
abs_position_error_z +
linear_velocity_error_x +
linear_velocity_error_y +
linear_velocity_error_z +
angular_velocity_error_x +
angular_velocity_error_y +
angular_velocity_error_z;
int total_absolute_error = Math.Abs( cubeState[i].position_x - baselineCubeState.position_x ) +
Math.Abs( cubeState[i].position_y - baselineCubeState.position_y ) +
Math.Abs( cubeState[i].position_z - baselineCubeState.position_z ) +
Math.Abs( cubeState[i].linear_velocity_x - baselineCubeState.linear_velocity_x ) +
Math.Abs( cubeState[i].linear_velocity_y - baselineCubeState.linear_velocity_y ) +
Math.Abs( cubeState[i].linear_velocity_z - baselineCubeState.linear_velocity_z ) +
Math.Abs( cubeState[i].angular_velocity_x - baselineCubeState.angular_velocity_x ) +
Math.Abs( cubeState[i].angular_velocity_y - baselineCubeState.angular_velocity_y ) +
Math.Abs( cubeState[i].angular_velocity_z - baselineCubeState.angular_velocity_z );
if ( total_prediction_error < total_absolute_error )
{
int max_position_error = abs_position_error_x;
if ( abs_position_error_y > max_position_error )
max_position_error = abs_position_error_y;
if ( abs_position_error_z > max_position_error )
max_position_error = abs_position_error_z;
int max_linear_velocity_error = abs_linear_velocity_error_x;
if ( abs_linear_velocity_error_y > max_linear_velocity_error )
max_linear_velocity_error = abs_linear_velocity_error_y;
if ( abs_linear_velocity_error_z > max_linear_velocity_error )
max_linear_velocity_error = abs_linear_velocity_error_z;
int max_angular_velocity_error = abs_angular_velocity_error_x;
if ( abs_angular_velocity_error_y > max_angular_velocity_error )
max_angular_velocity_error = abs_angular_velocity_error_y;
if ( abs_angular_velocity_error_z > max_angular_velocity_error )
max_angular_velocity_error = abs_angular_velocity_error_z;
if ( max_position_error <= Constants.PositionDeltaMax &&
max_linear_velocity_error <= Constants.LinearVelocityDeltaMax &&
max_angular_velocity_error <= Constants.AngularVelocityDeltaMax )
{
hasPredictionDelta[i] = true;
predictionDelta[i].position_delta_x = position_error_x;
predictionDelta[i].position_delta_y = position_error_y;
predictionDelta[i].position_delta_z = position_error_z;
predictionDelta[i].linear_velocity_delta_x = linear_velocity_error_x;
predictionDelta[i].linear_velocity_delta_y = linear_velocity_error_y;
predictionDelta[i].linear_velocity_delta_z = linear_velocity_error_z;
predictionDelta[i].angular_velocity_delta_x = angular_velocity_error_x;
predictionDelta[i].angular_velocity_delta_y = angular_velocity_error_y;
predictionDelta[i].angular_velocity_delta_z = angular_velocity_error_z;
}
}
}
}
}
#endif // #if !DISABLE_DELTA_ENCODING
Profiler.EndSample();
}