예제 #1
0
    public void CycleInteractionGestures()
    {
        int cur = (int)inty;

        cur++;
        if (cur == Enum.GetNames(typeof(interType)).Length)
        {
            cur = 0;
        }
        inty = (interType)cur;

        switch ((int)inty)
        {
        case (int)interType.Hold:
            SwitchTo(inter_Hold);
            break;

        case (int)interType.Nav:
            SwitchTo(inter_Nav);
            break;

        case (int)interType.Man:
            SwitchTo(inter_Man);
            break;

        default:
            break;
        }
    }
예제 #2
0
    public void GesturesFor(StateMachine.State state)
    {
        switch (state.ToString())
        {
        case "Calibration":
            SwitchTo(caliAdj);
            break;

        case "Adjusting":
            SwitchTo(caliAdj);
            break;

        case "Interaction":
            SwitchTo(inter_Hold);
            inty = interType.Hold;
            break;

        default:
            break;
        }
    }
예제 #3
0
    // Interpolate by Type
    public Vector3 InterpolateByType(interType type, Vector3 v1, Vector3 v2, float t)
    {
        Vector3 result; // result of operation

        // goes based on type
        switch (type)
        {
        case interType.lerp:
            result = Lerp(v1, v2, t);
            break;

        case interType.easeIn1:
            result = EaseIn1(v1, v2, t);
            break;

        case interType.easeIn2:
            result = EaseIn2(v1, v2, t);
            break;

        case interType.easeIn3:
            result = EaseIn3(v1, v2, t);
            break;

        case interType.easeOut1:
            result = EaseOut1(v1, v2, t);
            break;

        case interType.easeOut2:
            result = EaseOut2(v1, v2, t);
            break;

        case interType.easeOut3:
            result = EaseOut3(v1, v2, t);
            break;

        case interType.easeInOut1:
            result = EaseInOut1(v1, v2, t);
            break;

        case interType.easeInOut2:
            result = EaseInOut2(v1, v2, t);
            break;

        case interType.easeInOut3:
            result = EaseInOut3(v1, v2, t);
            break;

        case interType.easeInCircular:
            result = EaseInCircular(v1, v2, t);
            break;

        case interType.easeOutCircular:
            result = EaseOutCircular(v1, v2, t);
            break;

        case interType.easeInOutCircular:
            result = EaseInOutCircular(v1, v2, t);
            break;

        case interType.easeInBounce1:
            result = EaseInBounce1(v1, v2, t);
            break;

        case interType.easeInBounce2:
            result = EaseInBounce2(v1, v2, t);
            break;

        case interType.easeInBounce3:
            result = EaseInBounce3(v1, v2, t);
            break;

        case interType.easeOutBounce1:
            result = EaseOutBounce1(v1, v2, t);
            break;

        case interType.easeOutBounce2:
            result = EaseOutBounce2(v1, v2, t);
            break;

        case interType.easeOutBounce3:
            result = EaseOutBounce3(v1, v2, t);
            break;

        case interType.easeInOutBounce1:
            result = EaseInOutBounce1(v1, v2, t);
            break;

        case interType.easeInOutBounce2:
            result = EaseInOutBounce2(v1, v2, t);
            break;

        case interType.easeInOutBounce3:
            result = EaseInOutBounce3(v1, v2, t);
            break;

        default:     // unity lerp
            result = Vector3.Lerp(v1, v2, t);
            break;
        }

        return(result);
    }