public void SnapToEnd()
{
TransformInterpolator.Segment segment = this.interpolator.Query(Time.get_time(), this.target.GetInterpolationDelay(), 0.0f, 0.0f);
this.target.SetNetworkPosition(segment.tick.pos);
this.target.SetNetworkRotation(segment.tick.rot);
this.interpolator.Clear();
}
protected void DoCycle()
{
if (this.target == null)
{
return;
}
float extrapolationTime = this.target.GetExtrapolationTime();
float interpolationDelay = this.target.GetInterpolationDelay();
float interpolationSmoothing = this.target.GetInterpolationSmoothing();
TransformInterpolator.Segment segment = this.interpolator.Query(Time.get_time(), interpolationDelay, extrapolationTime, interpolationSmoothing);
this.extrapolatedTime = (double)segment.next.time < (double)this.interpolator.last.time ? Mathf.Max(this.extrapolatedTime - Time.get_deltaTime(), 0.0f) : Mathf.Min(this.extrapolatedTime + Time.get_deltaTime(), extrapolationTime);
if ((double)this.extrapolatedTime > 0.0 && (double)extrapolationTime > 0.0 && (double)interpolationSmoothing > 0.0)
{
float num = Time.get_deltaTime() / (this.extrapolatedTime / extrapolationTime * interpolationSmoothing);
segment.tick.pos = Vector3.Lerp(this.target.GetNetworkPosition(), segment.tick.pos, num);
segment.tick.rot = Quaternion.Slerp(this.target.GetNetworkRotation(), segment.tick.rot, num);
}
this.target.SetNetworkPosition(segment.tick.pos);
this.target.SetNetworkRotation(segment.tick.rot);
if (PositionLerp.DebugDraw)
{
this.target.DrawInterpolationState(segment, this.interpolator.list);
}
if ((double)Time.get_time() - (double)this.lastClientTime <= 10.0)
{
return;
}
if (this.idleDisable == null)
{
this.idleDisable = new Action(this.IdleDisable);
}
InvokeHandler.Invoke((Behaviour)this, this.idleDisable, 0.0f);
}
public Quaternion GetEstimatedAngularVelocity()
{
if (this.target == null)
{
return(Quaternion.get_identity());
}
float extrapolationTime = this.target.GetExtrapolationTime();
float interpolationDelay = this.target.GetInterpolationDelay();
float interpolationSmoothing = this.target.GetInterpolationSmoothing();
TransformInterpolator.Segment segment = this.interpolator.Query(Time.get_time(), interpolationDelay, extrapolationTime, interpolationSmoothing);
TransformInterpolator.Entry next = segment.next;
TransformInterpolator.Entry prev = segment.prev;
if ((double)next.time == (double)prev.time)
{
return(Quaternion.get_identity());
}
return(Quaternion.Euler(Vector3.op_Division(Vector3.op_Subtraction(((Quaternion) ref prev.rot).get_eulerAngles(), ((Quaternion) ref next.rot).get_eulerAngles()), prev.time - next.time)));
}
public Vector3 GetEstimatedVelocity()
{
if (this.target == null)
{
return(Vector3.get_zero());
}
float extrapolationTime = this.target.GetExtrapolationTime();
float interpolationDelay = this.target.GetInterpolationDelay();
float interpolationSmoothing = this.target.GetInterpolationSmoothing();
TransformInterpolator.Segment segment = this.interpolator.Query(Time.get_time(), interpolationDelay, extrapolationTime, interpolationSmoothing);
TransformInterpolator.Entry next = segment.next;
TransformInterpolator.Entry prev = segment.prev;
if ((double)next.time == (double)prev.time)
{
return(Vector3.get_zero());
}
return(Vector3.op_Division(Vector3.op_Subtraction(prev.pos, next.pos), prev.time - next.time));
}
public Quaternion GetEstimatedAngularVelocity()
{
if (this.target == null)
{
return(Quaternion.identity);
}
float extrapolationTime = this.target.GetExtrapolationTime();
float interpolationDelay = this.target.GetInterpolationDelay();
float interpolationSmoothing = this.target.GetInterpolationSmoothing();
TransformInterpolator.Segment segment = this.interpolator.Query(Time.time, interpolationDelay, extrapolationTime, interpolationSmoothing);
TransformInterpolator.Entry entry = segment.next;
TransformInterpolator.Entry entry1 = segment.prev;
if (entry.time == entry1.time)
{
return(Quaternion.identity);
}
return(Quaternion.Euler((entry1.rot.eulerAngles - entry.rot.eulerAngles) / (entry1.time - entry.time)));
}
public Vector3 GetEstimatedVelocity()
{
if (this.target == null)
{
return(Vector3.zero);
}
float extrapolationTime = this.target.GetExtrapolationTime();
float interpolationDelay = this.target.GetInterpolationDelay();
float interpolationSmoothing = this.target.GetInterpolationSmoothing();
TransformInterpolator.Segment segment = this.interpolator.Query(Time.time, interpolationDelay, extrapolationTime, interpolationSmoothing);
TransformInterpolator.Entry entry = segment.next;
TransformInterpolator.Entry entry1 = segment.prev;
if (entry.time == entry1.time)
{
return(Vector3.zero);
}
return((entry1.pos - entry.pos) / (entry1.time - entry.time));
}
protected void DoCycle()
{
if (this.target == null)
{
return;
}
float extrapolationTime = this.target.GetExtrapolationTime();
float interpolationDelay = this.target.GetInterpolationDelay();
float interpolationSmoothing = this.target.GetInterpolationSmoothing();
TransformInterpolator.Segment segment = this.interpolator.Query(Time.time, interpolationDelay, extrapolationTime, interpolationSmoothing);
if (segment.next.time < this.interpolator.last.time)
{
this.extrapolatedTime = Mathf.Max(this.extrapolatedTime - Time.deltaTime, 0f);
}
else
{
this.extrapolatedTime = Mathf.Min(this.extrapolatedTime + Time.deltaTime, extrapolationTime);
}
if (this.extrapolatedTime > 0f && extrapolationTime > 0f && interpolationSmoothing > 0f)
{
float single = Time.deltaTime / (this.extrapolatedTime / extrapolationTime * interpolationSmoothing);
segment.tick.pos = Vector3.Lerp(this.target.GetNetworkPosition(), segment.tick.pos, single);
segment.tick.rot = Quaternion.Slerp(this.target.GetNetworkRotation(), segment.tick.rot, single);
}
this.target.SetNetworkPosition(segment.tick.pos);
this.target.SetNetworkRotation(segment.tick.rot);
if (PositionLerp.DebugDraw)
{
this.target.DrawInterpolationState(segment, this.interpolator.list);
}
if (Time.time - this.lastClientTime > 10f)
{
if (this.idleDisable == null)
{
this.idleDisable = new Action(this.IdleDisable);
}
InvokeHandler.Invoke(this, this.idleDisable, 0f);
}
}
public TransformInterpolator.Segment Query(
float time,
float interpolation,
float extrapolation,
float smoothing)
{
TransformInterpolator.Segment segment = new TransformInterpolator.Segment();
if (this.list.Count == 0)
{
segment.prev = this.last;
segment.next = this.last;
segment.tick = this.last;
return(segment);
}
float num1 = (float)((double)time - (double)interpolation - (double)smoothing * 0.5);
float num2 = Mathf.Min(time - interpolation, this.last.time);
float num3 = num2 - smoothing;
TransformInterpolator.Entry entry1 = this.list[0];
TransformInterpolator.Entry entry2 = this.last;
TransformInterpolator.Entry entry3 = this.list[0];
TransformInterpolator.Entry entry4 = this.last;
foreach (TransformInterpolator.Entry entry5 in this.list)
{
if ((double)entry5.time < (double)num3)
{
entry1 = entry5;
}
else if ((double)entry2.time >= (double)entry5.time)
{
entry2 = entry5;
}
if ((double)entry5.time < (double)num2)
{
entry3 = entry5;
}
else if ((double)entry4.time >= (double)entry5.time)
{
entry4 = entry5;
}
}
TransformInterpolator.Entry entry6 = new TransformInterpolator.Entry();
if ((double)entry2.time - (double)entry1.time < Mathf.Epsilon)
{
entry6.time = num3;
entry6.pos = entry2.pos;
entry6.rot = entry2.rot;
}
else
{
float num4 = (float)(((double)num3 - (double)entry1.time) / ((double)entry2.time - (double)entry1.time));
entry6.time = num3;
entry6.pos = Vector3.LerpUnclamped(entry1.pos, entry2.pos, num4);
entry6.rot = Quaternion.SlerpUnclamped(entry1.rot, entry2.rot, num4);
}
segment.prev = entry6;
TransformInterpolator.Entry entry7 = new TransformInterpolator.Entry();
if ((double)entry4.time - (double)entry3.time < Mathf.Epsilon)
{
entry7.time = num2;
entry7.pos = entry4.pos;
entry7.rot = entry4.rot;
}
else
{
float num4 = (float)(((double)num2 - (double)entry3.time) / ((double)entry4.time - (double)entry3.time));
entry7.time = num2;
entry7.pos = Vector3.LerpUnclamped(entry3.pos, entry4.pos, num4);
entry7.rot = Quaternion.SlerpUnclamped(entry3.rot, entry4.rot, num4);
}
segment.next = entry7;
if ((double)entry7.time - (double)entry6.time < Mathf.Epsilon)
{
segment.prev = entry7;
segment.tick = entry7;
return(segment);
}
if ((double)num1 - (double)entry7.time > (double)extrapolation)
{
segment.prev = entry7;
segment.tick = entry7;
return(segment);
}
TransformInterpolator.Entry entry8 = new TransformInterpolator.Entry();
float num5 = Mathf.Min(num1 - entry6.time, entry7.time + extrapolation - entry6.time) / (entry7.time - entry6.time);
entry8.time = num1;
entry8.pos = Vector3.LerpUnclamped(entry6.pos, entry7.pos, num5);
entry8.rot = Quaternion.SlerpUnclamped(entry6.rot, entry7.rot, num5);
segment.tick = entry8;
return(segment);
}
public TransformInterpolator.Segment Query(float time, float interpolation, float extrapolation, float smoothing)
{
TransformInterpolator.Segment segment = new TransformInterpolator.Segment();
if (this.list.Count == 0)
{
segment.prev = this.last;
segment.next = this.last;
segment.tick = this.last;
return(segment);
}
float single = time - interpolation - smoothing * 0.5f;
float single1 = Mathf.Min(time - interpolation, this.last.time);
float single2 = single1 - smoothing;
TransformInterpolator.Entry item = this.list[0];
TransformInterpolator.Entry entry = this.last;
TransformInterpolator.Entry item1 = this.list[0];
TransformInterpolator.Entry entry1 = this.last;
foreach (TransformInterpolator.Entry entry2 in this.list)
{
if (entry2.time < single2)
{
item = entry2;
}
else if (entry.time >= entry2.time)
{
entry = entry2;
}
if (entry2.time >= single1)
{
if (entry1.time < entry2.time)
{
continue;
}
entry1 = entry2;
}
else
{
item1 = entry2;
}
}
TransformInterpolator.Entry entry3 = new TransformInterpolator.Entry();
if (entry.time - item.time >= Mathf.Epsilon)
{
float single3 = (single2 - item.time) / (entry.time - item.time);
entry3.time = single2;
entry3.pos = Vector3.LerpUnclamped(item.pos, entry.pos, single3);
entry3.rot = Quaternion.SlerpUnclamped(item.rot, entry.rot, single3);
}
else
{
entry3.time = single2;
entry3.pos = entry.pos;
entry3.rot = entry.rot;
}
segment.prev = entry3;
TransformInterpolator.Entry entry4 = new TransformInterpolator.Entry();
if (entry1.time - item1.time >= Mathf.Epsilon)
{
float single4 = (single1 - item1.time) / (entry1.time - item1.time);
entry4.time = single1;
entry4.pos = Vector3.LerpUnclamped(item1.pos, entry1.pos, single4);
entry4.rot = Quaternion.SlerpUnclamped(item1.rot, entry1.rot, single4);
}
else
{
entry4.time = single1;
entry4.pos = entry1.pos;
entry4.rot = entry1.rot;
}
segment.next = entry4;
if (entry4.time - entry3.time < Mathf.Epsilon)
{
segment.prev = entry4;
segment.tick = entry4;
return(segment);
}
if (single - entry4.time > extrapolation)
{
segment.prev = entry4;
segment.tick = entry4;
return(segment);
}
TransformInterpolator.Entry entry5 = new TransformInterpolator.Entry();
float single5 = Mathf.Min(single - entry3.time, entry4.time + extrapolation - entry3.time) / (entry4.time - entry3.time);
entry5.time = single;
entry5.pos = Vector3.LerpUnclamped(entry3.pos, entry4.pos, single5);
entry5.rot = Quaternion.SlerpUnclamped(entry3.rot, entry4.rot, single5);
segment.tick = entry5;
return(segment);
}
