private CinemachineBlendDefinition LookupBlend( ICinemachineCamera fromKey, ICinemachineCamera toKey) { // Get the blend curve that's most appropriate for these cameras CinemachineBlendDefinition blend = m_DefaultBlend; if (m_CustomBlends != null) { string fromCameraName = (fromKey != null) ? fromKey.Name : string.Empty; string toCameraName = (toKey != null) ? toKey.Name : string.Empty; blend = m_CustomBlends.GetBlendForVirtualCameras( fromCameraName, toCameraName, blend); } if (CinemachineCore.GetBlendOverride != null) { blend = CinemachineCore.GetBlendOverride(fromKey, toKey, blend, this); } return(blend); }
/// <summary> /// Updates the state of this axis based on the axis defined /// by AxisState.m_AxisName /// </summary> /// <param name="deltaTime">Delta time in seconds</param> /// <returns>Returns <b>true</b> if this axis' input was non-zero this Update, /// <b>false</b> otherwise</returns> public bool Update(float deltaTime) { if (!string.IsNullOrEmpty(m_InputAxisName)) { try { m_InputAxisValue = CinemachineCore.GetInputAxis(m_InputAxisName); } catch (ArgumentException e) { Debug.LogError(e.ToString()); } } float input = m_InputAxisValue; if (m_InvertInput) input *= -1f; if (m_SpeedMode == SpeedMode.MaxSpeed) return MaxSpeedUpdate(input, deltaTime); // legacy mode // Direct mode update: maxSpeed interpreted as multiplier input *= m_MaxSpeed; if (deltaTime < Epsilon) mCurrentSpeed = 0; else { float speed = input / deltaTime; float dampTime = Mathf.Abs(speed) < Mathf.Abs(mCurrentSpeed) ? m_DecelTime : m_AccelTime; speed = mCurrentSpeed + Damper.Damp(speed - mCurrentSpeed, dampTime, deltaTime); mCurrentSpeed = speed; // Decelerate to the end points of the range if not wrapping float range = m_MaxValue - m_MinValue; if (!m_Wrap && m_DecelTime > Epsilon && range > Epsilon) { float v0 = ClampValue(Value); float v = ClampValue(v0 + speed * deltaTime); float d = (speed > 0) ? m_MaxValue - v : v - m_MinValue; if (d < (0.1f * range) && Mathf.Abs(speed) > Epsilon) speed = Damper.Damp(v - v0, m_DecelTime, deltaTime) / deltaTime; } input = speed * deltaTime; } Value = ClampValue(Value + input); return Mathf.Abs(input) > Epsilon; }
public bool Update(float deltaTime, ref AxisBase axis) { if (!string.IsNullOrEmpty(name)) { try { inputValue = CinemachineCore.GetInputAxis(name); } catch (ArgumentException) {} //catch (ArgumentException e) { Debug.LogError(e.ToString()); } } float input = inputValue * multiplier; if (deltaTime < Epsilon) { mCurrentSpeed = 0; } else { float speed = input / deltaTime; float dampTime = Mathf.Abs(speed) < Mathf.Abs(mCurrentSpeed) ? decelTime : accelTime; speed = mCurrentSpeed + Damper.Damp(speed - mCurrentSpeed, dampTime, deltaTime); mCurrentSpeed = speed; // Decelerate to the end points of the range if not wrapping float range = axis.m_MaxValue - axis.m_MinValue; if (!axis.m_Wrap && decelTime > Epsilon && range > Epsilon) { float v0 = ClampValue(ref axis, axis.m_Value); float v = ClampValue(ref axis, v0 + speed * deltaTime); float d = (speed > 0) ? axis.m_MaxValue - v : v - axis.m_MinValue; if (d < (0.1f * range) && Mathf.Abs(speed) > Epsilon) { speed = Damper.Damp(v - v0, decelTime, deltaTime) / deltaTime; } } input = speed * deltaTime; } axis.m_Value = ClampValue(ref axis, axis.m_Value + input); return(Mathf.Abs(inputValue) > Epsilon); }
public bool TriggerInvoke() { bool isInvoke = false; if (IsSelectTriggerType(TriggerMode.InputAxis)) { string[] strs = m_TriggerInputAxisName.Split(';'); float input = 0; for (int i = 0; i < strs.Length; i++) { input += Mathf.Abs(CinemachineCore.GetInputAxis(strs[i])); } if (input != 0) { isInvoke = true; } } if (!isInvoke && IsSelectTriggerType(TriggerMode.InputButton)) { string[] strs = m_TriggerInputButtonName.Split(';'); float input = 0; for (int i = 0; i < strs.Length; i++) { input += Mathf.Abs(CinemachineCore.GetInputAxis(strs[i])); } if (input != 0) { isInvoke = true; } } if (isInvoke) { Invoke(); } return(isInvoke); }
/// <summary> /// Updates the state of this axis based on the axis defined /// by AxisState.m_AxisName /// </summary> /// <param name="deltaTime">Delta time in seconds</param> /// <returns>Returns <b>true</b> if this axis' Input was non-zero this Update, /// <b>flase</b> otherwise</returns> public bool Update(float deltaTime) { if (!string.IsNullOrEmpty(m_InputAxisName)) { try { m_InputAxisValue = CinemachineCore.GetInputAxis(m_InputAxisName); } catch (ArgumentException e) { Debug.LogError(e.ToString()); } } float input = m_InputAxisValue; if (m_InvertAxis) { input *= -1f; } if (m_MaxSpeed > Epsilon) { float targetSpeed = input * m_MaxSpeed; if (Mathf.Abs(targetSpeed) < Epsilon || (Mathf.Sign(mCurrentSpeed) == Mathf.Sign(targetSpeed) && Mathf.Abs(targetSpeed) < Mathf.Abs(mCurrentSpeed))) { // Need to decelerate float a = Mathf.Abs(targetSpeed - mCurrentSpeed) / Mathf.Max(Epsilon, m_DecelTime); float delta = Mathf.Min(a * deltaTime, Mathf.Abs(mCurrentSpeed)); mCurrentSpeed -= Mathf.Sign(mCurrentSpeed) * delta; } else { // Accelerate to the target speed float a = Mathf.Abs(targetSpeed - mCurrentSpeed) / Mathf.Max(Epsilon, m_AccelTime); mCurrentSpeed += Mathf.Sign(targetSpeed) * a * deltaTime; if (Mathf.Sign(mCurrentSpeed) == Mathf.Sign(targetSpeed) && Mathf.Abs(mCurrentSpeed) > Mathf.Abs(targetSpeed)) { mCurrentSpeed = targetSpeed; } } } // Clamp our max speeds so we don't go crazy float maxSpeed = GetMaxSpeed(); mCurrentSpeed = Mathf.Clamp(mCurrentSpeed, -maxSpeed, maxSpeed); Value += mCurrentSpeed * deltaTime; bool isOutOfRange = (Value > mMaxValue) || (Value < mMinValue); if (isOutOfRange) { if (mWrapAround) { if (Value > mMaxValue) { Value = mMinValue + (Value - mMaxValue); } else { Value = mMaxValue + (Value - mMinValue); } } else { Value = Mathf.Clamp(Value, mMinValue, mMaxValue); mCurrentSpeed = 0f; } } return(Mathf.Abs(input) > Epsilon); }
public bool Update(float deltaTime) { if (!string.IsNullOrEmpty(this.m_InputAxisName)) { try { this.m_InputAxisValue = CinemachineCore.GetInputAxis(this.m_InputAxisName); } catch (ArgumentException ex) { Debug.LogError(ex.ToString()); } } float num = this.m_InputAxisValue; if (this.m_InvertAxis) { num *= -1f; } if (this.m_MaxSpeed > 0.0001f) { float num2 = num * this.m_MaxSpeed; if (Mathf.Abs(num2) < 0.0001f || (Mathf.Sign(this.mCurrentSpeed) == Mathf.Sign(num2) && Mathf.Abs(num2) < Mathf.Abs(this.mCurrentSpeed))) { float num3 = Mathf.Min(Mathf.Abs(num2 - this.mCurrentSpeed) / Mathf.Max(0.0001f, this.m_DecelTime) * deltaTime, Mathf.Abs(this.mCurrentSpeed)); this.mCurrentSpeed -= Mathf.Sign(this.mCurrentSpeed) * num3; } else { float num4 = Mathf.Abs(num2 - this.mCurrentSpeed) / Mathf.Max(0.0001f, this.m_AccelTime); this.mCurrentSpeed += Mathf.Sign(num2) * num4 * deltaTime; if (Mathf.Sign(this.mCurrentSpeed) == Mathf.Sign(num2) && Mathf.Abs(this.mCurrentSpeed) > Mathf.Abs(num2)) { this.mCurrentSpeed = num2; } } } float maxSpeed = this.GetMaxSpeed(); this.mCurrentSpeed = Mathf.Clamp(this.mCurrentSpeed, -maxSpeed, maxSpeed); this.Value += this.mCurrentSpeed * deltaTime; if (this.Value > this.mMaxValue || this.Value < this.mMinValue) { if (this.mWrapAround) { if (this.Value > this.mMaxValue) { this.Value = this.mMinValue + (this.Value - this.mMaxValue); } else { this.Value = this.mMaxValue + (this.Value - this.mMinValue); } } else { this.Value = Mathf.Clamp(this.Value, this.mMinValue, this.mMaxValue); this.mCurrentSpeed = 0f; } } return(Mathf.Abs(num) > 0.0001f); }
internal bool UpdateVirtualCamera(ICinemachineCamera vcam, Vector3 worldUp, float deltaTime) { int frameCount = Time.frameCount; CinemachineCore.UpdateFilter updateFilter = this.CurrentUpdateFilter; bool flag = updateFilter != CinemachineCore.UpdateFilter.ForcedFixed && updateFilter != CinemachineCore.UpdateFilter.ForcedLate; bool flag2 = updateFilter == CinemachineCore.UpdateFilter.Late; if (!flag) { if (updateFilter == CinemachineCore.UpdateFilter.ForcedFixed) { updateFilter = CinemachineCore.UpdateFilter.Fixed; } if (updateFilter == CinemachineCore.UpdateFilter.ForcedLate) { updateFilter = CinemachineCore.UpdateFilter.Late; } } if (this.mUpdateStatus == null) { this.mUpdateStatus = new Dictionary <ICinemachineCamera, CinemachineCore.UpdateStatus>(); } if (vcam.VirtualCameraGameObject == null) { if (this.mUpdateStatus.ContainsKey(vcam)) { this.mUpdateStatus.Remove(vcam); } return(false); } CinemachineCore.UpdateStatus updateStatus; if (!this.mUpdateStatus.TryGetValue(vcam, out updateStatus)) { updateStatus = new CinemachineCore.UpdateStatus(frameCount); this.mUpdateStatus.Add(vcam, updateStatus); } int num = flag2 ? 1 : CinemachineBrain.GetSubframeCount(); if (updateStatus.lastUpdateFrame != frameCount) { updateStatus.lastUpdateSubframe = 0; } bool flag3 = !flag; if (flag) { Matrix4x4 pos; if (!CinemachineCore.GetTargetPosition(vcam, out pos)) { flag3 = flag2; } else { flag3 = (updateStatus.ChoosePreferredUpdate(frameCount, pos, updateFilter) == updateFilter); } } if (flag3) { updateStatus.preferredUpdate = updateFilter; while (updateStatus.lastUpdateSubframe < num) { vcam.UpdateCameraState(worldUp, deltaTime); updateStatus.lastUpdateSubframe++; } updateStatus.lastUpdateFrame = frameCount; } this.mUpdateStatus[vcam] = updateStatus; return(true); }
/// <summary> /// Updates the state of this axis based on the axis defined /// by <see cref="AxisState.m_AxisName"/> /// </summary> /// <param name="dt">Delta time in seconds</param> /// <param name="invertAxisInput">If <b>TRUE</b>, inverts the value of the axis. /// Otherwise, the value is not modified</param> /// <return>Returns <b>TRUE</b> if this axis' input was non-zero this Update, /// <b>FALSE</b> otherwise</return> public bool Update(float dt, bool invertAxisInput) { if (!string.IsNullOrEmpty(m_InputAxisName)) { try { m_InputAxisValue = CinemachineCore.GetInputAxis(m_InputAxisName); } catch (ArgumentException e) { Debug.LogError(e.ToString()); } } float input = m_InputAxisValue; if (invertAxisInput) { input *= -1f; } float absInput = Mathf.Abs(input); bool axisNonZero = absInput > UnityVectorExtensions.Epsilon; // Test to see if we're commanding a speed faster than we are going float accelTime = Mathf.Max(0.001f, m_AccelTime); if (axisNonZero && (absInput >= Mathf.Abs(mCurrentSpeed / m_MaxSpeed))) { if (m_MaxSpeed > UnityVectorExtensions.Epsilon) { mCurrentSpeed += ((m_MaxSpeed / accelTime) * input) * dt; } } else { // Otherwise brake // TODO: Can the fluctuation between these two cause nasty behaviour? Must monitor.. float decelTime = Mathf.Max(0.001f, m_DecelTime); float reduction = Mathf.Sign(mCurrentSpeed) * (m_MaxSpeed / decelTime) * dt; mCurrentSpeed = (Mathf.Abs(reduction) >= Mathf.Abs(mCurrentSpeed)) ? 0f : (mCurrentSpeed - reduction); } // Clamp our max speeds so we don't go crazy float maxSpeed = GetMaxSpeed(); mCurrentSpeed = Mathf.Clamp(mCurrentSpeed, -maxSpeed, maxSpeed); Value += mCurrentSpeed * dt; bool isOutOfRange = (Value > mMaxValue) || (Value < mMinValue); if (isOutOfRange) { if (mWrapAround) { if (Value > mMaxValue) { Value = mMinValue + (Value - mMaxValue); } else { Value = mMaxValue + (Value - mMinValue); } } else { Value = Mathf.Clamp(Value, mMinValue, mMaxValue); mCurrentSpeed = 0f; } } return(axisNonZero); }
/// <summary>Bring the axis back to the centered state (only if enabled).</summary> public void DoRecentering(ref AxisState axis, float deltaTime, float recenterTarget) { if (!m_enabled && deltaTime >= 0) { return; } recenterTarget = axis.ClampValue(recenterTarget); if (deltaTime < 0) { CancelRecentering(); if (m_enabled) { axis.Value = recenterTarget; } return; } float v = axis.ClampValue(axis.Value); float delta = recenterTarget - v; if (delta == 0) { return; } float input = 0; if (m_NeedReTimingInputAxisName != "") { string[] names = m_NeedReTimingInputAxisName.Split(';'); for (int i = 0; i < names.Length; i++) { if (CinemachineCore.GetInputAxis(names[i]) != 0) { input = 1; break; } } } if (input != 0) { CancelRecentering(); } input = 0; if (m_NeedRecenterInputAxisName != "") { string[] names = m_NeedRecenterInputAxisName.Split(';'); for (int i = 0; i < names.Length; i++) { if (CinemachineCore.GetInputAxis(names[i]) != 0) { input = 1; break; } } } if (Time.time < (mLastAxisInputTime + m_WaitTime) && input == 0) { return; } // Determine the direction float r = axis.m_MaxValue - axis.m_MinValue; if (axis.m_Wrap && Mathf.Abs(delta) > r * 0.5f) { v += Mathf.Sign(recenterTarget - v) * r; } // Damp our way there float recenteringTime = input == 0? m_RecenteringTime : m_RecenterInputAxisTime; if (recenteringTime < 0.001f) { v = recenterTarget; } else { v = Mathf.SmoothDamp( v, recenterTarget, ref mRecenteringVelocity, recenteringTime, 9999, deltaTime); } axis.Value = axis.ClampValue(v); }