public override void tick(float totalElapsedTime)
    {
        var easedTime = _easeFunction(totalElapsedTime, 0, 1, _ownerTween.duration);
        var vec       = GoTweenUtils.unclampedVector3Lerp(_startValue, _diffValue, easedTime);

        _target.anchoredPosition3D = vec;
    }
    public override void tick(float totalElapsedTime)
    {
        var easedTime = _easeFunction(totalElapsedTime, 0, 1, _ownerTween.duration);
        var vec       = GoTweenUtils.unclampedVector3Lerp(_startValue, _diffValue, easedTime);

        _setter(vec);
    }
    public override void tick(float totalElapsedTime)
    {
        float   value = _easeFunction(totalElapsedTime, 0f, 1f, _ownerTween.duration);
        Vector3 obj   = GoTweenUtils.unclampedVector3Lerp(_startValue, _diffValue, value);

        _setter(obj);
    }
Example #4
0
    public override void tick(float totalElapsedTime)
    {
        float   value = _easeFunction(totalElapsedTime, 0f, 1f, _ownerTween.duration);
        Vector3 anchoredPosition3D = GoTweenUtils.unclampedVector3Lerp(_startValue, _diffValue, value);

        _target.anchoredPosition3D = anchoredPosition3D;
    }
Example #5
0
    public override void tick(float totalElapsedTime)
    {
        if (_target == null || target.Equals(null))
        {
            return;
        }

        var easedTime = _easeFunction(totalElapsedTime, 0, 1, _ownerTween.duration);

        _target.localScale = GoTweenUtils.unclampedVector3Lerp(_startValue, _diffValue, easedTime);
    }
Example #6
0
    public override void tick(float totalElapsedTime)
    {
        var easedTime = _easeFunction(totalElapsedTime, 0, 1, _ownerTween.duration);
        var vec       = GoTweenUtils.unclampedVector3Lerp(_startValue, _diffValue, easedTime);

        if (_useLocalRotation)
        {
            _target.localRotation = Quaternion.Euler(vec);
        }
        else
        {
            _target.rotation = Quaternion.Euler(vec);
        }
    }
    public override void tick(float totalElapsedTime)
    {
        float   value  = _easeFunction(totalElapsedTime, 0f, 1f, _ownerTween.duration);
        Vector3 vector = GoTweenUtils.unclampedVector3Lerp(_startValue, _diffValue, value);

        if (_useLocalPosition)
        {
            _target.localPosition = vector;
        }
        else
        {
            _target.position = vector;
        }
    }
    public override void tick(float totalElapsedTime)
    {
        float   value = _easeFunction(totalElapsedTime, 0f, 1f, _ownerTween.duration);
        Vector3 euler = GoTweenUtils.unclampedVector3Lerp(_startValue, _diffValue, value);

        if (_useLocalRotation)
        {
            _target.localRotation = Quaternion.Euler(euler);
        }
        else
        {
            _target.rotation = Quaternion.Euler(euler);
        }
    }
    public override void tick(float totalElapsedTime)
    {
        var easedTime = _easeFunction(totalElapsedTime, 0, 1, _ownerTween.duration);
        var vec       = GoTweenUtils.unclampedVector3Lerp(_startValue, _diffValue, easedTime);

        if (_targetTransform != null)
        {
            _targetTransform.FastSetter(propertyName, vec);
        }
        else
        {
            if (_setter != null)
            {
                _setter(vec);
            }
        }
    }
Example #10
0
 static public int unclampedVector3Lerp_s(IntPtr l)
 {
     try {
         UnityEngine.Vector3 a1;
         checkType(l, 1, out a1);
         UnityEngine.Vector3 a2;
         checkType(l, 2, out a2);
         System.Single a3;
         checkType(l, 3, out a3);
         var ret = GoTweenUtils.unclampedVector3Lerp(a1, a2, a3);
         pushValue(l, ret);
         return(1);
     }
     catch (Exception e) {
         return(error(l, e));
     }
 }
Example #11
0
    public override void tick(float totalElapsedTime)
    {
        var easedTime = _easeFunction(totalElapsedTime, 0, 1, _ownerTween.duration);
        var vec       = GoTweenUtils.unclampedVector3Lerp(_startValue, _diffValue, easedTime);

        if (float.IsNaN(vec.x))
        {
            Debug.LogError("Error ");
        }

        if (_useLocalPosition)
        {
            _target.localPosition = vec;
        }
        else
        {
            _target.position = vec;
        }
    }
        public override void tick(float totalElapsedTime)
        {
            var easedTime = _easeFunction(totalElapsedTime, 0, 1, _ownerTween.duration);
            var vec       = GoTweenUtils.unclampedVector3Lerp(_startValue, _diffValue, easedTime);

            // calc new anchor positions based on anchor center
            float   diffX = vec.x - (_target.anchorMin.x + _target.anchorMax.x) * 0.5f;
            float   diffY = vec.y - (_target.anchorMin.y + _target.anchorMax.y) * 0.5f;
            Vector2 min   = _target.anchorMin;

            min.x += diffX;
            min.y += diffY;
            Vector2 max = _target.anchorMax;

            max.x += diffX;
            max.y += diffY;

            // update anchors
            _target.anchorMin = min;
            _target.anchorMax = max;
        }