Exemplo n.º 1
0
        public void FocusTo(float targetScale, Vector2 targetWorldPosition, AnimCallback animMidCB, bool force2PointAnim)
        {
            DebugUtility.CheckFloat(targetScale);
            DebugUtility.CheckFloat(targetWorldPosition);
            mAnimMidCB = animMidCB;

            var effectiveTargetScale       = m_WorldToViewScale * targetScale;
            var effectiveTargetTranslation = m_WorldToViewTranslation + (-targetWorldPosition * effectiveTargetScale);

            if (force2PointAnim || ViewInWorldSpace.Contains(targetWorldPosition))
            {
                mAnimType                 = AnimType.Anim_2Point;
                mAnimDuration             = 2;
                m_Scale_Anim_Start        = m_Scale;
                m_Scale_Anim_Target       = effectiveTargetScale / m_WorldToViewScale;
                m_Scale_Anim_Delta        = m_Scale_Anim_Target - m_Scale_Anim_Start;
                m_Translation_Anim_Start  = m_Translation;
                m_Translation_Anim_Target = effectiveTargetTranslation - m_WorldToViewTranslation;
                m_Translation_Anim_Delta  = m_Translation_Anim_Target - m_Translation_Anim_Start;
            }
            else
            {
                var   currentWorldPos = -(m_WorldToViewTranslation_Effective - m_WorldToViewTranslation) / m_WorldToViewScale_Effective;
                var   midWorldPos     = 0.5f * (currentWorldPos + targetWorldPosition);
                float marginPercent   = 0.01f;
                var   w  = Mathf.Abs(targetWorldPosition.x - currentWorldPos.x) + marginPercent * m_WorldSpace.width;
                var   h  = Mathf.Abs(targetWorldPosition.y - currentWorldPos.y) + marginPercent * m_WorldSpace.height;
                var   zw = m_WorldSpace.width / w;
                var   zh = m_WorldSpace.height / h;
                var   z  = Mathf.Min(zw, zh);
                z = Mathf.Min(m_Scale.x, z);
                var midScale = new Vector2(z, z);//0.5f * (Vector2.one + m_Scale);

                var effectiveMidScale       = m_WorldToViewScale * midScale;
                var effectiveMidTranslation = m_WorldToViewTranslation + (-midWorldPos * effectiveMidScale);


                mAnimType           = AnimType.Anim_3Point;
                m_Scale_Anim_Start  = m_Scale;
                m_Scale_Anim_Mid    = midScale;
                m_Scale_Anim_Target = effectiveTargetScale / m_WorldToViewScale;

                m_Scale_Anim_Delta     = m_Scale_Anim_Mid - m_Scale_Anim_Start;
                m_Scale_Anim_Mid_Delta = m_Scale_Anim_Target - m_Scale_Anim_Mid;

                m_Translation_Anim_Start  = m_Translation;
                m_Translation_Anim_Mid    = effectiveMidTranslation - m_WorldToViewTranslation;
                m_Translation_Anim_Target = effectiveTargetTranslation - m_WorldToViewTranslation;

                m_Translation_Anim_Delta     = m_Translation_Anim_Mid - m_Translation_Anim_Start;
                m_Translation_Anim_Mid_Delta = m_Translation_Anim_Target - m_Translation_Anim_Mid;

                mAnimDuration = 4;
            }
            mbAnimated = true;
            mAnimTimer = new System.Diagnostics.Stopwatch();
            mAnimTimer.Start();
        }
Exemplo n.º 2
0
    public void EnableMainMenuUI(bool enable, AnimCallback cb)
    {
        menuUI.GetComponent <AnimationUtils>().cb = cb;

        if (enable)
        {
            menuUI.SetActive(enable);
        }
        else
        {
            menuUI.GetComponent <Animator>().SetTrigger("Exit");
        }
    }
        protected override void OnInit()
        {
            base.OnInit();

            PointOfTaken = Pawn.GetComponent <PointOfTakenProvider>().Provide();
            TakenOffset  = Pawn.GetComponent <PointOfTakenProvider>().Offset;

            Anim = Pawn.GetComponent <AnimCallback>();

            Anim.OnDoThrow.AddListener(DoThrow);
            Anim.OnEndThrow.AddListener(AfterThrow);
            Anim.OnEndPullUp.AddListener(EndPullUp);
        }
Exemplo n.º 4
0
        private void AnimStep()
        {
            if (mbAnimated)
            {
                if (mAnimTimer == null)
                {
                    mbAnimated = false;
                    return;
                }
                var animTime = mAnimTimer.Elapsed.TotalSeconds;

                if (animTime >= mAnimDuration * 0.5f)
                {
                    if (mAnimMidCB != null)
                    {
                        mAnimMidCB();
                        mAnimMidCB = null;
                    }
                }
                if (animTime >= mAnimDuration)
                {
                    m_Scale       = m_Scale_Anim_Target;
                    m_Translation = m_Translation_Anim_Target;
                    mAnimTimer    = null;
                }
                else
                {
                    //float t = EaseInOutCubic((float)animTime, 0, 1, duration);
                    Vector2 scaleMin;
                    Vector2 scaleDelta;
                    Vector2 translationMin;
                    Vector2 translationDelta;
                    float   t;
                    switch (mAnimType)
                    {
                    default:
                    case AnimType.Anim_2Point:

                        t                = EaseInOutCubic((float)animTime, 0, 1, mAnimDuration);
                        scaleMin         = m_Scale_Anim_Start;
                        scaleDelta       = m_Scale_Anim_Delta;
                        translationMin   = m_Translation_Anim_Start;
                        translationDelta = m_Translation_Anim_Delta;

                        break;

                    case AnimType.Anim_3Point:

                        if (animTime < mAnimDuration * 0.5f)
                        {
                            //scale out
                            t                = EaseInOutCubic((float)animTime, 0, 1, mAnimDuration * 0.5f);
                            scaleMin         = m_Scale_Anim_Start;
                            scaleDelta       = m_Scale_Anim_Delta;
                            translationMin   = m_Translation_Anim_Start;
                            translationDelta = m_Translation_Anim_Delta;
                        }
                        else
                        {
                            //scale in
                            t                = EaseInOutCubic((float)animTime - mAnimDuration * 0.5f, 0, 1, mAnimDuration * 0.5f);
                            scaleMin         = m_Scale_Anim_Mid;
                            scaleDelta       = m_Scale_Anim_Mid_Delta;
                            translationMin   = m_Translation_Anim_Mid;
                            translationDelta = m_Translation_Anim_Mid_Delta;
                        }
                        break;
                    }

                    m_Scale       = scaleMin + t * scaleDelta;
                    m_Translation = translationMin + t * translationDelta;
                }
                EnforceScaleAndRange();
            }
        }