public void TransformEntries(Matrix4x4 matrix)
{
Quaternion rotation = ((Matrix4x4) ref matrix).get_rotation();
for (int index = 0; index < this.interpolator.list.Count; ++index)
{
TransformInterpolator.Entry entry = this.interpolator.list[index];
entry.pos = ((Matrix4x4) ref matrix).MultiplyPoint3x4(entry.pos);
entry.rot = Quaternion.op_Multiply(rotation, entry.rot);
this.interpolator.list[index] = entry;
}
this.interpolator.last.pos = ((Matrix4x4) ref matrix).MultiplyPoint3x4(this.interpolator.last.pos);
this.interpolator.last.rot = Quaternion.op_Multiply(rotation, this.interpolator.last.rot);
}
public void TransformEntries(Matrix4x4 matrix)
{
Quaternion quaternion = matrix.rotation;
for (int i = 0; i < this.interpolator.list.Count; i++)
{
TransformInterpolator.Entry item = this.interpolator.list[i];
item.pos = matrix.MultiplyPoint3x4(item.pos);
item.rot = quaternion * item.rot;
this.interpolator.list[i] = item;
}
this.interpolator.last.pos = matrix.MultiplyPoint3x4(this.interpolator.last.pos);
this.interpolator.last.rot = quaternion * this.interpolator.last.rot;
}
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.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 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));
}
public void Snapshot(Vector3 position, Quaternion rotation, float serverTime)
{
float interpolationDelay = this.target.GetInterpolationDelay() + this.target.GetInterpolationSmoothing() + 1f;
float single = Time.time;
this.timeOffsetNew = Mathf.Min(this.timeOffsetNew, single - serverTime);
this.timeOffsetCount++;
if (this.timeOffsetCount >= PositionLerp.TimeOffsetInterval)
{
this.timeOffset = this.timeOffsetNew;
this.timeOffsetNew = Single.MaxValue;
this.timeOffsetCount = 0;
}
single = (this.timeOffset == Single.MaxValue ? serverTime + this.timeOffsetNew : serverTime + this.timeOffset);
if (PositionLerp.DebugLog && this.interpolator.list.Count > 0 && serverTime < this.lastServerTime)
{
Debug.LogWarning(string.Concat(new object[] { this.target.ToString(), " adding tick from the past: server time ", serverTime, " < ", this.lastServerTime }));
}
else if (!PositionLerp.DebugLog || this.interpolator.list.Count <= 0 || single >= this.lastClientTime)
{
this.lastClientTime = single;
this.lastServerTime = serverTime;
TransformInterpolator transformInterpolator = this.interpolator;
TransformInterpolator.Entry entry = new TransformInterpolator.Entry()
{
time = single,
pos = position,
rot = rotation
};
transformInterpolator.Add(entry);
}
else
{
Debug.LogWarning(string.Concat(new object[] { this.target.ToString(), " adding tick from the past: client time ", single, " < ", this.lastClientTime }));
}
this.interpolator.Cull(single - interpolationDelay);
}
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 void Add(TransformInterpolator.Entry tick)
{
this.last = tick;
this.list.Add(tick);
}
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);
}
