public GearBase(GObject owner)
 {
     _owner = owner;
     pageSet = new PageOptionSet();
     easeType = Ease.OutQuad;
     tweenTime = 0.3f;
 }

 public QuaternionMemberCurve(string propName, Ease ease, float dur, Quaternion start, Quaternion end, bool slerp)
     : base(propName, ease, dur)
 {
     _start = start;
     _end = end;
     _useSlerp = slerp;
 }

	public void CreateReelSymbols(JSlotGame slot, int reelIndex, int reelHeight)
	{
		this.slot = slot;
		//this.reelIndex = reelIndex;
		this.reelLength = reelHeight + 2;
		this.cellHeight = slot.maker.cellHeight;
		
		this.cellMoveCount = slot.maker.cellsSpinCount[reelIndex];
		this.cellTweenTime = slot.maker.cellTweenTime;
		//this.firstMoveEase = slot.maker.firstMoveEase;
		this.lastMoveEase = slot.maker.lastMoveEase;

		this.speed = slot.maker.reel2Speed;

		symbols = new List<GameObject>(8);
		for (int i = 0; i < reelLength; ++i)
			//CreateSymbolInQueue(i);
		{
			int symbolIndex = GetSymbolIndex();
			GameObject newOne = CreateSymbol(i, symbolIndex);
			symbols.Add(newOne);
		}

		this.myTransform = this.transform;

		ResetReelPosition();
	}

		public static Func<float, float, float, float> Get(Ease ease)
		{
			switch(ease)
			{
			case Ease.Linear:
				return Linear;
			case Ease.BackIn:
				return InBack;
			case Ease.BackOut:
				return OutBack;
			case Ease.BackInOut:
				return InOutBack;
			case Ease.CircIn:
				return InCirc;
			case Ease.CircOut:
				return OutCirc;
			case Ease.CircInOut:
				return InOutCirc;
			case Ease.CubicIn:
				return InCubic;
			case Ease.CubicOut:
				return OutCubic;
			case Ease.CubicInOut:
				return InOutCubic;
			default:
				throw new Exception("Not supported ease type: " + ease);
			}
		}

 public MemberCurve(string propName, Ease ease, float dur)
 {
     _memberName = propName;
     _ease = ease;
     _dur = dur;
     _delay = 0f;
 }

 public GearBase(GObject owner)
 {
     _owner = owner;
     easeType = Ease.OutQuad;
     tweenTime = 0.3f;
     delay = 0;
 }

 public StringCurve(string propName, Ease ease, float dur, string start, string end, StringTweenStyle style)
     : base(propName, ease, dur)
 {
     _start = start;
     _end = end;
     _style = style;
 }

 public Vector2MemberCurve(string propName, Ease ease, float dur, Vector2 start, Vector2 end, bool slerp)
     : base(propName, ease, dur)
 {
     _start = start;
     _end = end;
     _useSlerp = slerp;
 }

        public MeshCurve(Mesh[] meshes, Ease ease, float dur)
        {
            _meshes = meshes;
            _ease = ease;
            _dur = dur;

            //  At least two meshes
            if (_meshes.Length < 2)
            {
                throw new System.ArgumentException("MeshCurve requires at least 2 source meshes.", "meshes");
            }

            // Make sure all meshes are assigned and shaped correctly!
            int vertexCount = (_meshes[0] != null) ? _meshes[0].vertexCount : 0;
            for (int i = 0; i < _meshes.Length; i++)
            {
                if (_meshes[i] == null)
                {
                    throw new System.ArgumentNullException("Mesh  " + i + " is null.", "meshes");
                }
                if (_meshes[i].vertexCount != vertexCount)
                {
                    throw new System.ArgumentException("Mesh " + i + " doesn't have the same number of vertices as the first mesh", "meshes");
                }
            }
        }

 public Vector3MemberCurve(string propName, Ease ease, float dur, Vector3 start, Vector3 end)
     : base(propName, ease, dur)
 {
     _start = start;
     _end = end;
     _useSlerp = false;
 }

 public TransMemberCurve(string propName, Ease ease, float dur, Trans start, Trans end, bool slerp)
     : base(propName, ease, dur)
 {
     _start = start;
     _end = end;
     _useSlerp = slerp;
 }

    void SetTextureEase(Ease easeType, Texture2D tx, float elapsed, int y)
    {
        int x = (int)((txW - 1) * (elapsed / tweenDuration));
        if (y > txH - 1 || y < 0) return; // elastic/back eases

        tx.SetPixel(x, y, Color.white);
        tx.Apply();
    }

        // ===================================================================================
        // PUBLIC METHODS --------------------------------------------------------------------

        // Ease popup with filtered eases
        public static Ease FilteredEasePopup(Ease currEase)
        {
            int stringEaseId = currEase == Ease.INTERNAL_Custom
                ? FilteredEaseTypes.Length - 1
                : Array.IndexOf(FilteredEaseTypes, currEase.ToString());
            if (stringEaseId == -1) stringEaseId = 0;
            stringEaseId = EditorGUILayout.Popup("Ease", stringEaseId, FilteredEaseTypes);
            return stringEaseId == FilteredEaseTypes.Length - 1 ? Ease.INTERNAL_Custom : (Ease)Enum.Parse(typeof(Ease), FilteredEaseTypes[stringEaseId]);
        }

        public static double Interpolate(float x, float x1, float x2, float y1, float y2, Ease ease)
        {
            if (ease == null)
                ease = Linear.EaseNone;

            var c = y2 - y1;
            var d = x2 - x1;

            return ease (x - x1, y1, c, d);
        }

 public Tween(Setter<float> setter, float start, float target, float duration, Ease ease = null, bool yoyo = false, Action onComplete = null)
 {
     Setter = setter;
     _start = start;
     _target = target;
     _duration = duration;
     _ease = ease ?? Linear.EaseNone;
     _change = target - start;
     _elapsedTime = 0;
     OnComplete = onComplete;
     _yoyo = yoyo;
 }

        /// <summary>Clears and resets this TweenParams instance using default values,
        /// so it can be reused without instantiating another one</summary>
        public TweenParams Clear()
        {
            id = target = null;
            updateType = DOTween.defaultUpdateType;
            isIndependentUpdate = DOTween.defaultTimeScaleIndependent;
            onStart = onPlay = onRewind = onUpdate = onStepComplete = onComplete = onKill = null;
            onWaypointChange = null;
            isRecyclable = DOTween.defaultRecyclable;
            isSpeedBased = false;
            autoKill = DOTween.defaultAutoKill;
            loops = 1;
            loopType = DOTween.defaultLoopType;
            delay = 0;
            isRelative = false;
            easeType = Ease.Unset;
            customEase = null;
            easeOvershootOrAmplitude = DOTween.defaultEaseOvershootOrAmplitude;
            easePeriod = DOTween.defaultEasePeriod;

            return this;
        }

 public TweenHash By(string memberName, Ease ease, object amt, float dur, object option = null)
 {
     _props.Add(new PropInfo(AnimMode.By, memberName, ease, amt, dur, option));
     return this;
 }

 public PropInfo(AnimMode mode, string nm, Ease e, object v, float d, object option, object altV)
 {
     this.mode = mode;
     this.name = nm;
     this.ease = e;
     this.value = v;
     this.dur = d;
     this.altValue = altV;
     this.option = option;
 }

 public TweenHash To(string memberName, Ease ease, object end, float dur, object option = null)
 {
     _props.Add(new PropInfo(AnimMode.To, memberName, ease, end, dur, option));
     return this;
 }

 /// <summary>
 /// Creates a curve that will animate from the current value to the end value, but will rescale the duration from how long it should have 
 /// taken from start to end, but already animated up to current.
 /// </summary>
 /// <param name="memberName"></param>
 /// <param name="ease"></param>
 /// <param name="start"></param>
 /// <param name="end"></param>
 /// <param name="dur"></param>
 /// <param name="option"></param>
 /// <returns></returns>
 public TweenHash RedirectTo(string memberName, Ease ease, object start, object end, float dur, object option = null)
 {
     _props.Add(new PropInfo(AnimMode.RedirectTo, memberName, ease, start, dur, option, end));
     return this;
 }