Esempio n. 1
0
 public override void Update(float time)
 {
     if (m_target != null && !IsDone())
     {
         float slice = 1.0f / m_times;
         float m     = MtMath.Fmod(time, slice);
         m_target.gameObject.SetActive(m > slice / 2 ? true : false);
     }
 }
Esempio n. 2
0
 public override void Step(float dt)
 {
     m_innerAction.Step(dt);
     if (m_innerAction.IsDone())
     {
         float diff = m_innerAction.Elapsed - m_innerAction.Duration;
         if (diff > m_innerAction.Duration)
         {
             diff = MtMath.Fmod(diff, m_innerAction.Duration);
         }
         m_innerAction.StartWithTarget(m_target);
         // to prevent jerk. issue #390, 1247
         m_innerAction.Step(0.0f);
         m_innerAction.Step(diff);
     }
 }
Esempio n. 3
0
 protected void CalculateAngles(ref float startAngle, ref float diffAngle, float dstAngle)
 {
     if (startAngle > 0)
     {
         startAngle = MtMath.Fmod(startAngle, 360.0f);
     }
     else
     {
         startAngle = MtMath.Fmod(startAngle, -360.0f);
     }
     diffAngle = dstAngle - startAngle;
     if (diffAngle > 180)
     {
         diffAngle -= 360;
     }
     if (diffAngle < -180)
     {
         diffAngle += 360;
     }
 }
Esempio n. 4
0
    public override void Update(float time)
    {
        if (m_target != null)
        {
            float xa = 0;
            float xb = m_controlPoint_1.x;
            float xc = m_controlPoint_2.x;
            float xd = m_endPosition.x;

            float ya = 0;
            float yb = m_controlPoint_1.y;
            float yc = m_controlPoint_2.y;
            float yd = m_endPosition.y;

            float za = 0;
            float zb = m_controlPoint_1.z;
            float zc = m_controlPoint_2.z;
            float zd = m_endPosition.z;

            float x = MtMath.BezierAt(xa, xb, xc, xd, time);
            float y = MtMath.BezierAt(ya, yb, yc, yd, time);
            float z = MtMath.BezierAt(za, zb, zc, zd, time);

#if MT_ENABLE_STACKABLE_ACTIONS
            Vector3 currentPos = m_target.position;
            Vector3 diff       = currentPos - m_previousPosition;
            m_startPosition = m_startPosition + diff;

            Vector3 newPos = m_startPosition + new Vector3(x, y, z);
            m_target.position  = newPos;
            m_previousPosition = newPos;
#else
            m_target.position = m_startPosition + new Vector2(x, y);
#endif // !MT_ENABLE_STACKABLE_ACTIONS
        }
    }
Esempio n. 5
0
 public override void Update(float time)
 {
     m_inner.Update(MtMath.ExpoEaseInOut(time));
 }