public GraphicSnapshot(GraphicSnapshot toCopy)
{
SyncSize = toCopy.SyncSize;
SyncScale = toCopy.SyncScale;
SizeDelta = toCopy.SizeDelta;
ScaleDelta = toCopy.ScaleDelta;
Position = toCopy.Position;
Rotation = toCopy.Rotation;
Color = toCopy.Color;
}
public static void ApplySnapshotLerp(MaskableGraphic graphic, GraphicState state, TransitionParameters transition, GraphicSnapshot origin, GraphicSnapshot target, float t)
{
RectTransform rect = graphic.GetComponent <RectTransform>();
float progress = 0;
if (state.ChangeSize == true)
{
UpdateProgress(ref progress, t, state.Size_SeparateTransition,
transition.SizeUseCurve, transition.SizeCurve, transition.SizePower,
transition.UseCurve, transition.Curve, transition.Power);
if (state.SyncSizeAxises == true)
{
rect.sizeDelta = Vector2.one * Mathf.LerpUnclamped(origin.SyncSize, target.SyncSize, progress);
}
else
{
rect.sizeDelta = Vector2.LerpUnclamped(origin.SizeDelta, target.SizeDelta, progress);
}
}
if (state.ChangeScale == true)
{
UpdateProgress(ref progress, t, state.Scale_SeparateTransition,
transition.ScaleUseCurve, transition.ScaleCurve, transition.ScalePower,
transition.UseCurve, transition.Curve, transition.Power);
if (state.SyncScaleAxises == true)
{
rect.localScale = Vector3.one * Mathf.LerpUnclamped(origin.SyncScale, target.SyncScale, progress);
}
else
{
rect.localScale = Vector3.LerpUnclamped(origin.ScaleDelta, target.ScaleDelta, progress);
}
}
if (state.ChangePosition == true)
{
UpdateProgress(ref progress, t, state.Position_SeparateTransition,
transition.PositionUseCurve, transition.PositionCurve, transition.PositionPower,
transition.UseCurve, transition.Curve, transition.Power);
rect.anchoredPosition3D = Vector3.LerpUnclamped(origin.Position, target.Position, progress);
}
if (state.ChangeRotation == true)
{
UpdateProgress(ref progress, t, state.Rotation_SeparateTransition,
transition.RotationUseCurve, transition.RotationCurve, transition.RotationPower,
transition.UseCurve, transition.Curve, transition.Power);
rect.localEulerAngles = rect.localEulerAngles.SetZ(Mathf.LerpUnclamped(origin.Rotation, target.Rotation, progress));
}
if (state.ChangeColor == true)
{
UpdateProgress(ref progress, t, state.Color_SeparateTransition,
transition.ColorUseCurve, transition.ColorCurve, transition.ColorPower,
transition.UseCurve, transition.Curve, transition.Power);
graphic.color = Color.LerpUnclamped(origin.Color, target.Color, progress);
}
}
public void CopyFrom(GraphicState state, GraphicSnapshot snap)
{
if (snap == this)
{
snap = new GraphicSnapshot(this);
}
if (state.RandomSize == true)
{
SyncSize = Random.Range(state.MinSyncSize, state.MaxSyncSize);
SizeDelta.x = Random.Range(state.MinSizeDelta.x, state.MaxSizeDelta.x);
SizeDelta.y = Random.Range(state.MinSizeDelta.y, state.MaxSizeDelta.y);
}
else
{
SyncSize = state.SyncSize;
SizeDelta = state.SizeDelta;
}
if (state.AbsoluteSize == false)
{
SizeDelta += snap.SizeDelta;
SyncSize += snap.SyncSize;
}
if (state.RandomScale == true)
{
SyncScale = Random.Range(state.MinSyncScale, state.MaxSyncScale);
ScaleDelta.x = Random.Range(state.MinScaleDelta.x, state.MaxScaleDelta.x);
ScaleDelta.y = Random.Range(state.MinScaleDelta.y, state.MaxScaleDelta.y);
}
else
{
SyncScale = state.SyncScale;
ScaleDelta = state.ScaleDelta;
}
if (state.AbsoluteScale == false)
{
ScaleDelta += snap.ScaleDelta;
SyncScale += snap.SyncScale;
}
if (state.RandomPosition == true)
{
if (state.PositionSeparateAxisRandom == true)
{
Position.x = Random.Range(state.MinPosition.x, state.MaxPosition.x);
Position.y = Random.Range(state.MinPosition.y, state.MaxPosition.y);
Position.z = Random.Range(state.MinPosition.z, state.MaxPosition.z);
}
else
{
Position = Vector3.Lerp(state.MinPosition, state.MaxPosition, Random.value);
}
}
else
{
Position = state.Position;
}
if (state.AbsolutePosition == false)
{
Position += snap.Position;
}
if (state.RandomRotation == true)
{
Rotation = Random.Range(state.MinRotation, state.MaxRotation);
}
else
{
Rotation = state.Rotation;
}
if (state.AbsoluteRotation == false)
{
Rotation += snap.Rotation;
}
if (state.RandomColor == true)
{
Color = Color.Lerp(state.MinColor, state.MaxColor, Random.value);
}
else
{
Color = state.Color;
}
}
public GraphicSnapshot(GraphicState state, GraphicSnapshot snap)
{
CopyFrom(state, snap);
}
