/// <summary> /// Creates a batch of movement tweens for the <see cref="Transform"/>[] <paramref name="targets"/>. /// </summary> /// <param name="targets">The <see cref="Transform"/>[] that are the targets of this tween batch.</param> /// <param name="fromArray">The <see cref="Vector3"/>[] where the move from position should be assigned from.</param> /// <param name="toArray">The <see cref="Vector3"/>[] where the move to position should be assigned from.</param> /// <param name="duration">The length of time in seconds that the tween batch should take to complete or one pass if looping.</param> /// <param name="tweenHandle">The <see cref="ITweenHandle"/> instance that will be initialized for this tween.</param> /// <param name="spaceType">The coordinate system the tween batch should operate in (default is World).</param> /// <param name="easeType">The type of easing the tween batch should use while playing (default is Linear).</param> /// <param name="loopType">The type of looping that should be used (default is None).</param> /// <param name="loopCount">If looping, the number of loops that should occur before completing. If set to -1, the tween will loop infinitely. (default is zero)</param> public void BatchMove( Transform[] targets, Vector3[] fromArray, Vector3[] toArray, float duration, out ITweenHandle tweenHandle, SpaceType spaceType = SpaceType.World, EaseType easeType = EaseType.Linear, LoopType loopType = LoopType.None, int loopCount = 0) { _batchTransformTweener.BatchMove( targets, fromArray, toArray, 0, targets.Length, duration, spaceType, easeType, loopType, loopCount, null, null, true, out tweenHandle); }
/// <summary> /// Creates a batch of rotation tweens for a slice from <see cref="Transform"/>[] <paramref name="targets"/> /// starting at <paramref name="startIndex"/> to <paramref name="length"/>. /// </summary> /// <param name="targets">The <see cref="Transform"/>[] that are the targets of this tween batch.</param> /// <param name="fromArray">The <see cref="Quaternion"/>[] where the from rotation should be assigned from.</param> /// <param name="toArray">The <see cref="Quaternion"/>[] where the to rotation should be assigned from.</param> /// <param name="startIndex">The index where the slice should start from in the parameter arrays.</param> /// <param name="length">The length from which values should copied in the parameter arrays starting from the <paramref name="startIndex"/>.</param> /// <param name="duration">The length of time in seconds that the tween batch should take to complete or one pass if looping.</param> /// <param name="tweenHandle">The <see cref="ITweenHandle"/> instance that will be initialized for this tween.</param> /// <param name="spaceType">The coordinate system the tween batch should operate in (default is World).</param> /// <param name="easeType">The type of easing the tween batch should use while playing (default is Linear).</param> /// <param name="loopType">The type of looping that should be used (default is None).</param> /// <param name="loopCount">If looping, the number of loops that should occur before completing. If set to -1, the tween will loop infinitely. (default is zero)</param> public void BatchRotateSlice( Transform[] targets, Quaternion[] fromArray, Quaternion[] toArray, int startIndex, int length, float duration, out ITweenHandle tweenHandle, SpaceType spaceType = SpaceType.World, EaseType easeType = EaseType.Linear, LoopType loopType = LoopType.None, int loopCount = 0) { _batchTransformTweener.BatchRotate( targets, fromArray, toArray, startIndex, length, duration, spaceType, easeType, loopType, loopCount, null, null, true, out tweenHandle); }
/// <summary> /// Creates a batch of tweens animating movement, rotation, and scaling for the <see cref="Transform"/>[] <paramref name="targets"/>. /// </summary> /// <param name="targets">The <see cref="Transform"/>[] that are the targets of this tween batch.</param> /// <param name="fromPosArray">The <see cref="Vector3"/>[] where the from position should be assigned from.</param> /// <param name="toPosArray">The <see cref="Vector3"/>[] where the from position should be assigned from.</param> /// <param name="fromRotArray">The <see cref="Quaternion"/>[] where the from rotation should be assigned from.</param> /// <param name="toRotArray">The <see cref="Quaternion"/>[] where the to rotation should be assigned from.</param> /// <param name="fromScaleArray">The <see cref="Vector3"/>[] where the from scale should be assigned from.</param> /// <param name="toScaleArray">The <see cref="Vector3"/>[] where the to scale should be assigned from.</param> /// <param name="duration">The length of time in seconds that the tween batch should take to complete or one pass if looping.</param> /// <param name="tweenHandle">The <see cref="ITweenHandle"/> instance that will be initialized for this tween.</param> /// <param name="spaceType">The coordinate system the tween batch should operate in (default is World).</param> /// <param name="easeType">The type of easing the tween batch should use while playing (default is Linear).</param> /// <param name="loopType">The type of looping that should be used (default is None).</param> /// <param name="loopCount">If looping, the number of loops that should occur before completing. If set to -1, the tween will loop infinitely. (default is zero)</param> public void BatchUpdateTransforms( Transform[] targets, Vector3[] fromPosArray, Vector3[] toPosArray, Quaternion[] fromRotArray, Quaternion[] toRotArray, Vector3[] fromScaleArray, Vector3[] toScaleArray, float duration, out ITweenHandle tweenHandle, SpaceType spaceType = SpaceType.World, EaseType easeType = EaseType.Linear, LoopType loopType = LoopType.None, int loopCount = 0) { _batchTransformTweener.BatchUpdateTransforms( targets, fromPosArray, toPosArray, fromRotArray, toRotArray, fromScaleArray, toScaleArray, 0, targets.Length, duration, spaceType, easeType, loopType, loopCount, null, null, true, out tweenHandle); }
/// <summary> /// Moves the <see cref="Transform"/> <paramref name="target"/>. /// </summary> /// <param name="target">The <see cref="Transform"/> that is the target of this tween.</param> /// <param name="from">The position the <see cref="Transform"/> will be moved from.</param> /// <param name="to">The position the <see cref="Transform"/> will be moved to.</param> /// <param name="duration">The length of time in seconds that the tween should take to complete or one pass if looping.</param> /// <param name="tweenHandle">The <see cref="ITweenHandle"/> instance that will be initialized for this tween.</param> /// <param name="spaceType">The coordinate system the tween should operate in (default is World).</param> /// <param name="easeType">The type of easing the tween should use while playing (default is Linear).</param> /// <param name="loopType">The type of looping that should be used (default is None).</param> /// <param name="loopCount">If looping, the number of loops that should occur before completing. If set to -1, the tween will loop infinitely. (default is zero)</param> public void Move( Transform target, Vector3 from, Vector3 to, float duration, out ITweenHandle tweenHandle, SpaceType spaceType = SpaceType.World, EaseType easeType = EaseType.Linear, LoopType loopType = LoopType.None, int loopCount = 0) { _singleTransformTweener.Move( target, from, to, duration, spaceType, easeType, loopType, loopCount, null, null, true, out tweenHandle); }
/// <summary> /// Rotates the <see cref="Transform"/> <paramref name="target"/> around the the specified axis /// (RotateMode.XYZ is an invalid value and will cause an assertion). /// </summary> /// <param name="target">The <see cref="Transform"/> that is the target of this tween.</param> /// <param name="angle"></param> /// <param name="duration">The length of time in seconds that the tween should take to complete or one pass if looping.</param> /// <param name="rotateMode"></param> /// <param name="tweenHandle">The <see cref="ITweenHandle"/> instance that will be initialized for this tween.</param> /// <param name="spaceType">The coordinate system the tween should operate in (default is World).</param> /// <param name="easeType">The type of easing the tween should use while playing (default is Linear).</param> /// <param name="loopType">The type of looping that should be used (default is None).</param> /// <param name="loopCount">If looping, the number of loops that should occur before completing. If set to -1, the tween will loop infinitely. (default is zero)</param> public void RotateOnAxis( Transform target, float angle, float duration, RotateMode rotateMode, out ITweenHandle tweenHandle, SpaceType spaceType = SpaceType.World, EaseType easeType = EaseType.Linear, LoopType loopType = LoopType.None, int loopCount = 0) { _singleTransformTweener.RotateOnAxis( target, angle, duration, rotateMode, spaceType, easeType, loopType, loopCount, null, null, true, out tweenHandle); }
public override void Add(ITweenHandle tweenHandle) { tweenHandle.AddOnStartedListener(OnTweenStarted); tweenHandle.AddOnCompletedListener(OnTweenCompleted); _tweenList.Add((TweenHandle)tweenHandle); }
private void OnRecycleButtonClicked() { if (_tweenHandle != null) { _tweenHandle.Recycle(); _tweenHandle = null; } else { Debug.Log("Tween needs to be created first via Play button before trying to recycle it."); } }
// Abstract methods for collections. public abstract void Add(ITweenHandle tweenHandle);
public void BatchUpdateTransforms( Transform[] targets, Vector3[] fromPosArray, Vector3[] toPosArray, Quaternion[] fromRotArray, Quaternion[] toRotArray, Vector3[] fromScaleArray, Vector3[] toScaleArray, int startIndex, int length, float duration, SpaceType spaceType, EaseType easeType, LoopType loopType, int loopCount, Action onStart, Action onComplete, bool useTweenHandle, out ITweenHandle tweenHandle) { // Ensure that our arrays are non-null and have sufficient capacity for the intended slice. Assert.IsNotNull(targets); Assert.IsNotNull(fromRotArray); Assert.IsNotNull(toRotArray); Assert.IsTrue(targets.Length >= startIndex + length && fromPosArray.Length >= startIndex + length && toPosArray.Length >= startIndex + length && fromRotArray.Length >= startIndex + length && toRotArray.Length >= startIndex + length && fromScaleArray.Length >= startIndex + length && toScaleArray.Length >= startIndex + length); tweenHandle = null; var batchIndex = _transforms.Length; var batchLength = length; _tweenBatches.Add(new TweenTransformBatchState { state = useTweenHandle ? HANDLE_START_PAUSED : NO_HANDLE_START, startIndex = (uint)batchIndex, length = (uint)batchLength }); _tweenBatchLifetimes.Add(new TweenLifetime { duration = Mathf.Max(0, duration), easeType = easeType, loopType = loopType, loopCount = (short)Mathf.Clamp(loopCount, -1, short.MaxValue), originalLoopCount = (short)Mathf.Clamp(loopCount, -1, short.MaxValue) }); var hasEvents = onStart != null || onComplete != null; if (useTweenHandle || hasEvents) { var availableTweenHandle = GetNextAvailableTweenHandle(); availableTweenHandle.state = useTweenHandle ? HANDLE_START_PAUSED : NO_HANDLE_START; if (onStart != null) { availableTweenHandle.AddOnStartedListener(onStart); } if (onComplete != null) { availableTweenHandle.AddOnCompletedListener(onComplete); } _tweenBatchHandles.Add(availableTweenHandle); // Only populate the out parameter if explicitly called out for. if (useTweenHandle) { tweenHandle = availableTweenHandle; } } else { _tweenBatchHandles.Add(null); } _transforms.AddRange(targets, startIndex, length); for (var i = 0; i < batchLength; i++) { var normalizedIndex = startIndex + i; var normalizedBatchIndex = batchIndex + i; _transformAccessArray.Add(_transforms.buffer[normalizedBatchIndex]); _tweenStates.Add(new TweenTransformState { state = useTweenHandle ? HANDLE_START_PAUSED : NO_HANDLE_START, transformType = TweenTransformType.Movement | TweenTransformType.Rotation | TweenTransformType.Scaling, spaceType = spaceType == SpaceType.World ? TweenSpaceType.WorldMovement | TweenSpaceType.WorldRotation : TweenSpaceType.LocalMovement | TweenSpaceType.LocalRotation }); _tweenPositions.Add(new TweenFloat3 { from = fromPosArray[normalizedIndex], to = toPosArray[normalizedIndex] }); _tweenRotations.Add(new TweenRotation { from = fromRotArray[normalizedIndex], to = toRotArray[normalizedIndex] }); _tweenScales.Add(new TweenFloat3 { from = fromScaleArray[normalizedIndex], to = toScaleArray[normalizedIndex] }); var lifetime = new TweenLifetime { duration = Mathf.Max(0, duration), easeType = easeType, loopType = loopType, loopCount = (short)Mathf.Clamp(loopCount, -1, short.MaxValue), originalLoopCount = (short)Mathf.Clamp(loopCount, -1, short.MaxValue) }; _tweenPositionLifetimes.Add(lifetime); _tweenRotationLifetimes.Add(lifetime); _tweenScaleLifetimes.Add(lifetime); } }
public void Scale( Transform target, Vector3 from, Vector3 to, float duration, EaseType easeType, LoopType loopType, int loopCount, Action onStart, Action onComplete, bool useTweenHandle, out ITweenHandle tweenHandle) { tweenHandle = null; _transforms.Add(target); _transformAccessArray.Add(target); _tweenStates.Add(new TweenTransformState { state = useTweenHandle ? HANDLE_START_PAUSED : NO_HANDLE_START, transformType = TweenTransformType.Scaling }); _tweenPositions.Add(new TweenFloat3()); _tweenRotations.Add(new TweenRotation()); _tweenScales.Add(new TweenFloat3 { from = from, to = to }); _tweenPositionLifetimes.Add(new TweenLifetime()); _tweenRotationLifetimes.Add(new TweenLifetime()); _tweenScaleLifetimes.Add(new TweenLifetime { duration = Mathf.Max(0, duration), easeType = easeType, loopType = loopType, loopCount = (short)Mathf.Clamp(loopCount, -1, short.MaxValue), originalLoopCount = (short)Mathf.Clamp(loopCount, -1, short.MaxValue) }); var hasEvents = onStart != null || onComplete != null; if (useTweenHandle || hasEvents) { var availableTweenHandle = GetNextAvailableTweenHandle(); availableTweenHandle.state = useTweenHandle ? HANDLE_START_PAUSED : NO_HANDLE_START; if (onStart != null) { availableTweenHandle.AddOnStartedListener(onStart); } if (onComplete != null) { availableTweenHandle.AddOnCompletedListener(onComplete); } _tweenHandles.Add(availableTweenHandle); // Only populate the out parameter if explicitly called out for. if (useTweenHandle) { tweenHandle = availableTweenHandle; } } else { _tweenHandles.Add(null); } }
internal void RotateOnAxis( Transform target, float angle, float duration, RotateMode rotateMode, SpaceType spaceType, EaseType easeType, LoopType loopType, int loopCount, Action onStart, Action onComplete, bool useTweenHandle, out ITweenHandle tweenHandle) { Assert.IsTrue(rotateMode != RotateMode.XYZ, RuntimeConstants.INVALID_ROTATE_MODE); tweenHandle = null; _transforms.Add(target); _transformAccessArray.Add(target); var rotateType = JTweenTools.GetTweenSpaceTypeFromRotateMode(rotateMode); _tweenStates.Add(new TweenTransformState { state = useTweenHandle ? HANDLE_START_PAUSED : NO_HANDLE_START, transformType = TweenTransformType.Rotation, spaceType = spaceType == SpaceType.World ? TweenSpaceType.WorldRotation | rotateType : TweenSpaceType.LocalRotation | rotateType }); _tweenPositions.Add(new TweenFloat3()); var eulerAngles = spaceType == SpaceType.World ? target.eulerAngles : target.localEulerAngles; _tweenRotations.Add(new TweenRotation { from = new quaternion(eulerAngles.x, eulerAngles.y, eulerAngles.z, 0), angle = angle }); _tweenScales.Add(new TweenFloat3()); _tweenPositionLifetimes.Add(new TweenLifetime()); _tweenRotationLifetimes.Add(new TweenLifetime { duration = Mathf.Max(0, duration), easeType = easeType, loopType = loopType, loopCount = (short)Mathf.Clamp(loopCount, -1, short.MaxValue), originalLoopCount = (short)Mathf.Clamp(loopCount, -1, short.MaxValue) }); _tweenScaleLifetimes.Add(new TweenLifetime()); var hasEvents = onStart != null || onComplete != null; if (useTweenHandle || hasEvents) { var availableTweenHandle = GetNextAvailableTweenHandle(); availableTweenHandle.state = useTweenHandle ? HANDLE_START_PAUSED : NO_HANDLE_START; if (onStart != null) { availableTweenHandle.AddOnStartedListener(onStart); } if (onComplete != null) { availableTweenHandle.AddOnCompletedListener(onComplete); } _tweenHandles.Add(availableTweenHandle); // Only populate the out parameter if explicitly called out for. if (useTweenHandle) { tweenHandle = availableTweenHandle; } } else { _tweenHandles.Add(null); } }