public static LVector3 Slerp(LVector3 from, LVector3 to, LFloat t) { t = LMath.Clamp(t, 0, 1); LFloat diff = Angle(from, to) * LMath.DegToRad; LFloat sind = LMath.Sin(diff); LFloat sintd = LMath.Sin(t * diff); LFloat sin1td = LMath.Sin((1 - t) * diff); return((sin1td / sind) * from + (sintd / sind) * to); }
/// <summary> /// Constructor for the bounds octree. /// </summary> /// <param name="initialWorldSize">Size of the sides of the initial node, in metres. The octree will never shrink smaller than this.</param> /// <param name="initialWorldPos">Position of the centre of the initial node.</param> /// <param name="minNodeSize">Nodes will stop splitting if the new nodes would be smaller than this (metres).</param> /// <param name="loosenessVal">Clamped between 1 and 2. Values > 1 let nodes overlap.</param> public BoundsQuadTree(LFloat initialWorldSize, LVector2 initialWorldPos, LFloat minNodeSize, LFloat loosenessVal) { if (minNodeSize > initialWorldSize) { Debug.LogWarning("Minimum node size must be at least as big as the initial world size. Was: " + minNodeSize + " Adjusted to: " + initialWorldSize); minNodeSize = initialWorldSize; } Count = 0; initialSize = initialWorldSize; minSize = minNodeSize; looseness = LMath.Clamp(loosenessVal, 1.ToLFloat(), 2.ToLFloat()); rootNode = new BoundsQuadTreeNode(null, initialSize, minSize, looseness, initialWorldPos); }
public void DoUpdate(float deltaTime) { _timer += deltaTime; if (_timer > _checkInterval) { _timer = 0; if (!hasMissTick) { var preSend = _cmdBuffer._maxPing * 1.0f / NetworkDefine.UPDATE_DELTATIME; _targetPreSendTick = _targetPreSendTick * _oldPercent + preSend * (1 - _oldPercent); var targetPreSendTick = LMath.Clamp((int)System.Math.Ceiling(_targetPreSendTick), 1, 60); #if UNITY_EDITOR //if (targetPreSendTick != _simulatorService.PreSendInputCount) { Debug.LogWarning( $"Shrink preSend buffer old:{_simulatorService.PreSendInputCount} new:{_targetPreSendTick} " + $"PING: min:{_cmdBuffer._minPing} max:{_cmdBuffer._maxPing} avg:{_cmdBuffer.PingVal}"); } #endif _simulatorService.PreSendInputCount = targetPreSendTick; } hasMissTick = false; } if (missTick != -1) { var delayTick = _simulatorService.TargetTick - missTick; var targetPreSendTick = _simulatorService.PreSendInputCount + (int)System.Math.Ceiling(delayTick * _incPercent); targetPreSendTick = LMath.Clamp(targetPreSendTick, 1, 60); #if UNITY_EDITOR Debug.LogWarning( $"Expend preSend buffer old:{_simulatorService.PreSendInputCount} new:{targetPreSendTick}"); #endif _simulatorService.PreSendInputCount = targetPreSendTick; nextCheckMissTick = _simulatorService.TargetTick; missTick = -1; hasMissTick = true; } }
public void DoUpdate(float deltaTime) { this._timer += deltaTime; bool flag = this._timer > this._checkInterval; if (flag) { this._timer = 0f; bool flag2 = !this.hasMissTick; if (flag2) { float num = (float)this._cmdBuffer._maxPing * 1f / 30f; this._targetPreSendTick = this._targetPreSendTick * this._oldPercent + num * (1f - this._oldPercent); int num2 = LMath.Clamp((int)System.Math.Ceiling((double)this._targetPreSendTick), 1, 60); bool flag3 = num2 != this._simulatorService.PreSendInputCount; if (flag3) { Debug.LogWarning(string.Format("Shrink preSend buffer old:{0} new:{1} ", this._simulatorService.PreSendInputCount, this._targetPreSendTick) + string.Format("PING: min:{0} max:{1} avg:{2}", this._cmdBuffer._minPing, this._cmdBuffer._maxPing, this._cmdBuffer.PingVal), Array.Empty <object>()); } this._simulatorService.PreSendInputCount = num2; } this.hasMissTick = false; } bool flag4 = this.missTick != -1; if (flag4) { int num3 = this._simulatorService.TargetTick - this.missTick; int num4 = this._simulatorService.PreSendInputCount + (int)System.Math.Ceiling((double)((float)num3 * this._incPercent)); num4 = LMath.Clamp(num4, 1, 60); Debug.LogWarning(string.Format("Expend preSend buffer old:{0} new:{1}", this._simulatorService.PreSendInputCount, num4), Array.Empty <object>()); this._simulatorService.PreSendInputCount = num4; this.nextCheckMissTick = this._simulatorService.TargetTick; this.missTick = -1; this.hasMissTick = true; } }
private LFloat(long val) { value = LMath.Clamp(val, RateNegativeInfinity, RatePositiveInfinity); }
public static LQuaternion Lerp(LQuaternion from, LQuaternion to, LFloat t) { t = LMath.Clamp(t, 0, 1); return((1 - t) * from + t * to); }