public void sendUpdate(Clock clock)
{
if (animating)
{
currentTime += clock.DeltaSeconds;
if (currentTime < animationLength)
{
alpha = EasingFunctions.Ease(currentEasing, 0, 1.0f, currentTime, animationLength);
currentSize = new IntSize2((int)(oldSize.Width + sizeDelta.Width * alpha), WorkingSize.Height);
}
else
{
currentTime = animationLength;
alpha = 1.0f;
currentSize = new IntSize2(oldSize.Width + sizeDelta.Width, WorkingSize.Height);
finishAnimation();
oldChildContainer = null;
}
if (childContainer != null && oldChildContainer != null)
{
childContainer.setAlpha(alpha);
}
invalidate();
}
}
/// <summary>
/// Primary blend funciton, will always use the terminating state's mandible muscle force and target offset.
/// This is to retain compatability with animations that rely on this blend funciton to work.
/// </summary>
/// <param name="targetState"></param>
/// <param name="blendFactor"></param>
public void blend(MusclePosition targetState, float blendFactor)
{
float modifiedBlendFactor = blendFactor;
if (blendFactor < 1.0f)
{
EasingFunctions.Ease(targetState.Easing, 0, 1, blendFactor, 1);
}
if (MuscleController.MovingTarget != null) //If this is null then the whole mandible simulation is invalid and its better to do nothing
{
MuscleController.changeForce("MovingMuscleDynamic", targetState.muscleForce);
MuscleController.MovingTarget.Offset = targetState.movingTargetPosition;
ControlPointBehavior leftCP = ControlPointController.getControlPoint("LeftCP");
float delta = targetState.leftCPPosition - leftCPPosition;
leftCP.setLocation(leftCPPosition + delta * modifiedBlendFactor);
ControlPointBehavior rightCP = ControlPointController.getControlPoint("RightCP");
delta = targetState.rightCPPosition - rightCPPosition;
rightCP.setLocation(rightCPPosition + delta * modifiedBlendFactor);
}
FKRoot pelvis;
if (pelvisChainState != null && targetState.pelvisChainState != null && PoseableObjectsManager.tryGetFkChainRoot("Pelvis", out pelvis))
{
//This creates garbage, but it is unknown if this has negative effects
FKChainState blendedState = new FKChainState();
blendedState.setToBlendOf(pelvisChainState, targetState.pelvisChainState, modifiedBlendFactor);
pelvis.applyChainState(blendedState);
}
}
/// <summary>
/// Returns the Fast Fourier Transform of the song at a certain time, with the specified amount of magnitudes.
/// Useful to make spectrum effets.
/// </summary>
public float[] GetFft(double time, int magnitudes, string path = null, OsbEasing easing = OsbEasing.None)
{
var fft = GetFft(time, path);
if (magnitudes == fft.Length && easing == OsbEasing.None)
{
return(fft);
}
var resultFft = new float[magnitudes];
var baseIndex = 0;
for (var i = 0; i < magnitudes; i++)
{
var progress = EasingFunctions.Ease(easing, (double)i / magnitudes);
var index = Math.Min(Math.Max(baseIndex + 1, (int)(progress * fft.Length)), fft.Length - 1);
var value = 0f;
for (var v = baseIndex; v < index; v++)
{
value = Math.Max(value, fft[index]);
}
resultFft[i] = value;
baseIndex = index;
}
return(resultFft);
}
public override void sendUpdate(Clock clock)
{
if (camera != null)
{
if (automaticMovement)
{
totalTime += clock.DeltaSeconds;
if (totalTime > animationDuration)
{
totalTime = animationDuration;
automaticMovement = false;
orbitDistance = targetOrbitDistance;
yaw = targetYaw;
pitch = targetPitch;
normalDirection = targetNormal;
rotatedUp = targetRotatedUp;
rotatedLeft = targetRotatedLeft;
}
float slerpAmount = EasingFunctions.Ease(easingFunction, 0f, 1f, totalTime, animationDuration);
this.lookAt = startLookAt.lerp(ref targetLookAt, ref slerpAmount);
Quaternion rotation = startRotation.slerp(ref targetRotation, slerpAmount);
//If the rotation is not a valid number just use the target rotation
if (!rotation.isNumber())
{
rotation = targetRotation;
}
Vector3 currentNormalDirection = Quaternion.quatRotate(ref rotation, ref Vector3.Backward);
float currentOrbit = startOrbitDistance + (targetOrbitDistance - startOrbitDistance) * slerpAmount;
updateTranslation(currentNormalDirection * currentOrbit + lookAt);
camera.LookAt = lookAt;
}
}
}
// .. COROUTINES
IEnumerator UpdateAnimation(Camera camera_to_animate)
{
float elapsed = 0f;
float total_time = KeyFrames.Sum(e => e.TimeBetweenFrames);
Transform camera_transform = camera_to_animate.GetComponent <Transform>();
while (elapsed < total_time)
{
float elapsed_frame = 0;
CameraAnimationKeyframe from, to;
GetCameraKeyFramesAtTime(elapsed, out from, out to);
TransformValue from_transform = new TransformValue(from.CameraPreview == null ? camera_transform : from.CameraPreview.GetComponent <Transform>());
TransformValue to_transform = new TransformValue(to.CameraPreview.GetComponent <Transform>());
float from_fov = from.CameraPreview == null ? camera_to_animate.fieldOfView : from.CameraPreview.fieldOfView;
float to_fov = to.CameraPreview.fieldOfView;
while (elapsed_frame < to.TimeBetweenFrames)
{
float normalized_time = elapsed_frame / to.TimeBetweenFrames;
//Transform
EasingFunctions.Ease(to.TransformEaseType, normalized_time, from_transform, to_transform, ref camera_transform);
//Field of View
camera_to_animate.fieldOfView = EasingFunctions.Ease(to.FieldOfViewEaseType, normalized_time, from_fov, to_fov);
elapsed += Time.deltaTime;
elapsed_frame += Time.deltaTime;
yield return(null);
}
camera_transform.localPosition = to_transform.LocalPosition;
camera_transform.localRotation = to_transform.LocalRotation;
camera_transform.localScale = to_transform.LocalScale;
camera_to_animate.fieldOfView = to_fov;
}
if (OnAnimationCompleted != null)
{
OnAnimationCompleted.Invoke(this);
}
}
public override void update(Clock clock)
{
if (animating)
{
currentTime += clock.DeltaSeconds;
if (currentTime < animationLength)
{
alpha = EasingFunctions.Ease(currentEasing, 0, 1.0f, currentTime, animationLength);
currentSize = orientationStrategy.getOrientedResize(alpha);
}
else
{
currentTime = animationLength;
alpha = 1.0f;
currentSize = orientationStrategy.getOrientedFinalSize();
finishAfterLayout = true;
}
}
}
// -- PRIVATE
// .. OPERATIONS
IEnumerator UpdateScale(
object[] parameters
)
{
float
time,
timer;
Vector3
start_scale,
end_scale;
Transform
the_transform;
time = (float)parameters[0];
timer = 0.0f;
start_scale = (Vector3)parameters[2];
end_scale = (Vector3)parameters[3];
the_transform = GetComponent <Transform>();
the_transform.localScale = start_scale;
while (timer < time)
{
yield return(null);
timer += Time.deltaTime;
the_transform.localScale = EasingFunctions.Ease(
(EasingFunctions.TYPE)parameters[1],
Mathf.Clamp(timer / time, 0.0f, 1.0f),
start_scale,
end_scale
);
}
the_transform.localScale = end_scale;
}
// .. COROUTINES
IEnumerator UpdateFade(object[] args)
{
float target_alpha = Mathf.Clamp01((float)args[0]);
float animation_time = (float)args[1];
EasingFunctions.TYPE easing_type = (EasingFunctions.TYPE)args[2];
if (CanvasGroup == null)
{
CanvasGroup = GetComponent <CanvasGroup>();
}
float start_alpha = CanvasGroup.alpha;
float elapsed = 0f;
while (elapsed < animation_time)
{
CanvasGroup.alpha = EasingFunctions.Ease(easing_type, elapsed / animation_time, start_alpha, target_alpha);
elapsed += Time.deltaTime;
yield return(null);
}
CanvasGroup.alpha = target_alpha;
}
