public override List<GameObject> getDependencies(AMITarget itarget)
 {
     Transform t = GetTarget(itarget) as Transform;
     List<GameObject> ls = new List<GameObject>();
     if(t) ls.Add(t.gameObject);
     return ls;
 }

        // preview a frame in the scene view
        public override void previewFrame(AMITarget target, float frame, int frameRate, bool play, float playSpeed)
        {
            GameObject go = GetTarget(target) as GameObject;

            if(keys == null || keys.Count <= 0) {
                return;
            }
            if(!go) return;

            // if before the first frame
            if(frame < (float)keys[0].frame) {
                //go.rotation = (cache[0] as AMPropertyAction).getStartQuaternion();
                go.SetActive(startActive);
                return;
            }
            // if beyond or equal to last frame
            if(frame >= (float)(keys[keys.Count - 1] as AMGOSetActiveKey).frame) {
                go.SetActive((keys[keys.Count - 1] as AMGOSetActiveKey).setActive);
                return;
            }
            // if lies on property action
            foreach(AMGOSetActiveKey key in keys) {
                if((frame < (float)key.frame) || (key.endFrame != -1 && frame >= (float)key.endFrame)) continue;

                go.SetActive(key.setActive);
                return;
            }
        }

 public override List<GameObject> getDependencies(AMITarget target)
 {
     AudioSource src = GetTarget(target) as AudioSource;
     List<GameObject> ls = new List<GameObject>();
     if(src) ls.Add(src.gameObject);
     return ls;
 }

 public override List<GameObject> getDependencies(AMITarget target)
 {
     GameObject go = GetTarget(target) as GameObject;
     List<GameObject> ls = new List<GameObject>();
     if(go) ls.Add(go);
     return ls;
 }

 // add a new key
 public void addKey(AMITarget itarget, OnAddKey addCall, int _frame, Camera camera = null,/*int? type = null, Camera camera = null, Color? color = null,*/ AMCameraSwitcherKey keyToClone = null)
 {
     foreach(AMCameraSwitcherKey key in keys) {
         // if key exists on frame, update key
         if(key.frame == _frame) {
             if(camera != null) {
                 key.setCamera(itarget, camera);
                 key.type = 0;
                 updateCache(itarget);
             }
             return;
         }
     }
     AMCameraSwitcherKey a = addCall(gameObject, typeof(AMCameraSwitcherKey)) as AMCameraSwitcherKey;
     if(keyToClone) {
         keyToClone.CopyTo(a);
     }
     else {
         a.type = 0;
         a.still = !AMTakeData.isProLicense;
         a.easeType = (int)EaseType.EaseOutSine;
     }
     a.frame = _frame;
     if(camera != null) {
         a.setCamera(itarget, camera);
         a.type = 0;
     }
     // add a new key
     keys.Add(a);
     // update cache
     updateCache(itarget);
 }

        public override List<GameObject> updateDependencies(AMITarget target, List<GameObject> newReferences, List<GameObject> oldReferences)
        {
            GameObject go = GetTarget(target) as GameObject;
            bool didUpdateObj = false;
            bool didUpdateParameter = false;
            if(go) {
                for(int i = 0; i < oldReferences.Count; i++) {
                    if(oldReferences[i] == go) {
                        // check if new GameObject has all the required components
                        foreach(AMEventKey key in keys) {
                            string componentName = key.getComponentName();
                            if(newReferences[i].GetComponent(componentName) == null) {
                                // missing component
                                Debug.LogWarning("Animator: Event Track component '" + componentName + "' not found on new reference for GameObject '" + obj.name + "'. Duplicate not replaced.");
                                List<GameObject> lsFlagToKeep = new List<GameObject>();
                                lsFlagToKeep.Add(oldReferences[i]);
                                return lsFlagToKeep;
                            }
                        }
                        SetTarget(target, newReferences[i].transform);
                        didUpdateObj = true;
                        break;
                    }

                }
            }
            foreach(AMEventKey key in keys) {
                if(key.updateDependencies(newReferences, oldReferences, didUpdateObj, go) && !didUpdateParameter) didUpdateParameter = true;
            }

            if(didUpdateObj || didUpdateParameter) updateCache(target);

            return new List<GameObject>();
        }

    public AMSequence(AMITarget itarget, int id, AMTakeData take)
    {
        mTarget = itarget;
        mId = id;
        mTake = take;

        if(mTake.loopBackToFrame > 0 && mTake.numLoop <= 0)
            mTake.numLoop = 1;
    }

 public override List<GameObject> getDependencies(AMITarget target)
 {
     GameObject go = GetTarget(target) as GameObject;
     List<GameObject> ls = new List<GameObject>();
     if(go) ls.Add(go);
     foreach(AMEventKey key in keys) {
         ls = ls.Union(key.getDependencies()).ToList();
     }
     return ls;
 }

 public override void Pause(AMITarget itarget)
 {
     AudioSource src = GetTarget(itarget) as AudioSource;
     if(src && src.isPlaying) {
         pausedLoop = src.loop && src.clip && src.clip.length - src.time < 1f; //only end loop if it's short enough to do so
         if(pausedLoop)
             src.loop = false;
         else
             src.Pause();
         paused = true;
     }
 }

 public Camera[] getAllCameras(AMITarget itarget)
 {
     List<Camera> lsCameras = new List<Camera>();
     foreach(AMCameraSwitcherKey key in keys) {
         Camera cam = key.getCamera(itarget);
         if(key.type == 0 && cam) {
             if(lsCameras.IndexOf(cam) == -1) {
                 lsCameras.Add(cam);
             }
         }
     }
     return lsCameras.ToArray();
 }

        // draw gizmos
        public override void drawGizmos(AMITarget itarget, float gizmo_size, bool inPlayMode, int frame)
        {
            if(!obj) return;

            // draw line to target
            bool isLineDrawn = false;
            if(!inPlayMode) {
                for(int i = 0; i < keys.Count; i++) {
                    AMOrientationKey key = keys[i] as AMOrientationKey;
                    if(key == null)
                        continue;

                    AMOrientationKey keyNext = i + 1 < keys.Count ? keys[i + 1] as AMOrientationKey : null;

                    Transform t = key.GetTarget(itarget);
                    if(t) {
                        //draw target
                        Gizmos.color = new Color(245f/255f, 107f/255f, 30f/255f, 1f);
                        Gizmos.DrawSphere(t.position, 0.2f * (AnimatorTimeline.e_gizmoSize/0.1f));

                        //draw line
                        if(!isLineDrawn) {
                            if(key.frame > frame) isLineDrawn = true;
                            if(frame >= key.frame && frame <= key.endFrame) {
                                if(!keyNext || t == keyNext.GetTarget(itarget)) {
                                    Gizmos.color = new Color(245f / 255f, 107f / 255f, 30f / 255f, 0.2f);
                                    Gizmos.DrawLine(obj.transform.position, t.position);
                                }
                                isLineDrawn = true;
                            }
                        }
                    }
                }
            }
            // draw arrow
            Gizmos.color = new Color(245f / 255f, 107f / 255f, 30f / 255f, 1f);
            Vector3 pos = obj.transform.position;
            float size = (1.2f * (gizmo_size / 0.1f));
            if(size < 0.1f) size = 0.1f;
            Vector3 direction = obj.forward * size;
            float arrowHeadAngle = 20f;
            float arrowHeadLength = 0.3f * size;

            Gizmos.DrawRay(pos, direction);

            Vector3 right = Quaternion.LookRotation(direction) * Quaternion.Euler(0, 180 + arrowHeadAngle, 0) * new Vector3(0, 0, 1);
            Vector3 left = Quaternion.LookRotation(direction) * Quaternion.Euler(0, 180 - arrowHeadAngle, 0) * new Vector3(0, 0, 1);
            Gizmos.DrawRay(pos + direction, right * arrowHeadLength);
            Gizmos.DrawRay(pos + direction, left * arrowHeadLength);
        }

 // add a new key
 public void addKey(AMITarget itarget, OnAddKey addCall, int _frame)
 {
     foreach(AMEventKey key in keys) {
         // if key exists on frame, do nothing
         if(key.frame == _frame) {
             return;
         }
     }
     AMEventKey a = addCall(gameObject, typeof(AMEventKey)) as AMEventKey;
     a.frame = _frame;
     // add a new key
     keys.Add(a);
     // update cache
     updateCache(itarget);
 }

 // add a new key
 public void addKey(AMITarget target, OnAddKey addCall, int _frame)
 {
     foreach(AMGOSetActiveKey key in keys) {
         // if key exists on frame, update
         if(key.frame == _frame) {
             key.setActive = true;
             updateCache(target);
             return;
         }
     }
     AMGOSetActiveKey a = addCall(gameObject, typeof(AMGOSetActiveKey)) as AMGOSetActiveKey;
     a.frame = _frame;
     a.setActive = true;
     // add a new key
     keys.Add(a);
     // update cache
     updateCache(target);
 }

    public Camera getCamera(AMITarget itarget)
    {
        if(itarget.isMeta) {
            if(!string.IsNullOrEmpty(_cameraPath)) {
                Transform t = itarget.GetCache(_cameraPath);
                if(t)
                    return t.GetComponent<Camera>();
                else {
                    t = AMUtil.GetTarget(itarget.root, _cameraPath);
                    itarget.SetCache(_cameraPath, t);
                    if(t)
                        return t.GetComponent<Camera>();
                }
            }

            return null;
        }
        else
            return _camera;
    }

 // add a new key
 public void addKey(AMITarget itarget, OnAddKey addCall, int _frame, AudioClip _clip, bool _loop)
 {
     foreach(AMAudioKey key in keys) {
         // if key exists on frame, update key
         if(key.frame == _frame) {
             key.audioClip = _clip;
             key.loop = _loop;
             // update cache
             updateCache(itarget);
         }
     }
     AMAudioKey a = addCall(gameObject, typeof(AMAudioKey)) as AMAudioKey;
     a.frame = _frame;
     a.audioClip = _clip;
     a.loop = _loop;
     // add a new key
     keys.Add(a);
     // update cache
     updateCache(itarget);
 }

        // add a new key, default interpolation and easeType
        public void addKey(AMITarget itarget, OnAddKey addCall, int _frame, Vector3 _position)
        {
            foreach(AMTranslationKey key in keys) {
                // if key exists on frame, update key
                if(key.frame == _frame) {
                    key.position = _position;
                    // update cache
                    updateCache(itarget);
                    return;
                }
            }
            AMTranslationKey a = addCall(gameObject, typeof(AMTranslationKey)) as AMTranslationKey;
            a.frame = _frame;
            a.position = _position;

            // add a new key
            keys.Add(a);
            // update cache
            updateCache(itarget);
        }

 // add a new key
 public void addKey(AMITarget itarget, OnAddKey addCall, int _frame, Transform target)
 {
     foreach(AMOrientationKey key in keys) {
         // if key exists on frame, update key
         if(key.frame == _frame) {
             key.SetTarget(itarget, target);
             // update cache
             updateCache(itarget);
             return;
         }
     }
     AMOrientationKey a = addCall(gameObject, typeof(AMOrientationKey)) as AMOrientationKey;
     a.frame = _frame;
     a.SetTarget(itarget, target);
     // set default ease type to linear
     a.easeType = (int)0;// AMTween.EaseType.linear;
     // add a new key
     keys.Add(a);
     // update cache
     updateCache(itarget);
 }

 // add a new key
 public void addKey(AMITarget itarget, OnAddKey addCall, int _frame, AnimationClip _clip, WrapMode _wrapMode)
 {
     foreach(AMAnimationKey key in keys) {
         // if key exists on frame, update key
         if(key.frame == _frame) {
             key.amClip = _clip;
             key.wrapMode = _wrapMode;
             // update cache
             updateCache(itarget);
             return;
         }
     }
     AMAnimationKey a = addCall(gameObject, typeof(AMAnimationKey)) as AMAnimationKey;
     a.frame = _frame;
     a.amClip = _clip;
     a.wrapMode = _wrapMode;
     // add a new key
     keys.Add(a);
     // update cache
     updateCache(itarget);
 }

    public cfTuple getCameraFadeTupleForFrame(AMITarget itarget, int frame)
    {
        if(keys == null || keys.Count <= 0) {
            return new cfTuple(0, 0, 0, null, null, false);
        }
        for(int i=0; i<keys.Count; i++) {
            AMCameraSwitcherKey key = keys[i] as AMCameraSwitcherKey;
            // compact
            if(frame < key.frame) {
                break;
            }
            else if(frame < key.endFrame) {
                if(!key.still || key.cameraFadeType == (int)AMCameraSwitcherKey.Fade.None || key.targetsAreEqual(itarget)) break;
                bool isReversed = key.isReversed();

                if(isReversed) return new cfTuple(key.endFrame, key.typeEnd, key.type, key.getCameraEnd(itarget), key.getCamera(itarget), isReversed);
                else return new cfTuple(key.frame, key.type, key.typeEnd, key.getCamera(itarget), key.getCameraEnd(itarget), isReversed);
                //return new cfTuple((isReversed ? (cache[i] as AMCameraSwitcherAction).endFrame : (cache[i] as AMCameraSwitcherAction).startFrame),(cache[i] as AMCameraSwitcherAction).startCamera,(cache[i] as AMCameraSwitcherAction).endCamera,isReversed);
            }
        }
        return new cfTuple(0, 0, 0, null, null, false);
    }

        // add a new key
        public void addKey(AMITarget target, OnAddKey addCall, int _frame, Quaternion _rotation)
        {
            foreach(AMRotationKey key in keys) {
                // if key exists on frame, update key
                if(key.frame == _frame) {
                    key.rotation = _rotation;
                    // update cache
                    updateCache(target);
                    return;
                }
            }
            AMRotationKey a = addCall(gameObject, typeof(AMRotationKey)) as AMRotationKey;
            a.frame = _frame;
            a.rotation = _rotation;
            // set default ease type to linear
            a.easeType = (int)EaseType.Linear;

            // add a new key
            keys.Add(a);
            // update cache
            updateCache(target);
        }