void Update()
        {
            // Exit Sample
//            if (Input.GetKey(KeyCode.Escape))
//            {
//                Application.Quit();
//#if UNITY_EDITOR
//                UnityEditor.EditorApplication.isPlaying = false;
//#endif
//            }

            // Hide and lock cursor when right mouse button pressed
            if (Input.GetMouseButtonDown(1))
            {
                //Cursor.lockState = CursorLockMode.Locked;
            }

            // Unlock and show cursor when right mouse button released
            if (Input.GetMouseButtonUp(1))
            {
                //Cursor.visible = true;
                //Cursor.lockState = CursorLockMode.None;
            }

            // Rotation
            if (Input.GetMouseButton(1))
            {
                var mouseMovement = new Vector2(Input.GetAxis("Mouse X"), Input.GetAxis("Mouse Y") * (invertY ? 1 : -1));

                var mouseSensitivityFactor = mouseSensitivityCurve.Evaluate(mouseMovement.magnitude);

                m_TargetCameraState.yaw   += mouseMovement.x * mouseSensitivityFactor;
                m_TargetCameraState.pitch += mouseMovement.y * mouseSensitivityFactor;
            }

            // Translation
            var translation = GetInputTranslationDirection() * Time.deltaTime;

            // Speed up movement when shift key held
            if (Input.GetKey(KeyCode.LeftShift))
            {
                translation *= 10.0f;
            }

            // Modify movement by a boost factor (defined in Inspector and modified in play mode through the mouse scroll wheel)
            boost       += Input.mouseScrollDelta.y * 0.2f;
            translation *= Mathf.Pow(2.0f, boost);

            m_TargetCameraState.Translate(translation);

            // Framerate-independent interpolation
            // Calculate the lerp amount, such that we get 99% of the way to our target in the specified time
            var positionLerpPct = 1f - Mathf.Exp((Mathf.Log(1f - 0.99f) / positionLerpTime) * Time.deltaTime);
            var rotationLerpPct = 1f - Mathf.Exp((Mathf.Log(1f - 0.99f) / rotationLerpTime) * Time.deltaTime);

            m_InterpolatingCameraState.LerpTowards(m_TargetCameraState, positionLerpPct, rotationLerpPct);

            m_InterpolatingCameraState.UpdateTransform(transform);
        }
        void Update()
        {
            //Put cursor back into lock mode
            if (Cursor.lockState == CursorLockMode.None)
            {
                if (Input.GetMouseButton(0) || Input.GetMouseButton(1))
                {
                    Cursor.lockState = CursorLockMode.Locked;
                    Time.timeScale   = 1;
                }
                if (Input.GetKey(KeyCode.Escape))
                {
                    Application.Quit();
                    #if UNITY_EDITOR
                    UnityEditor.EditorApplication.isPlaying = false;
                    #endif
                }
            }
            else
            {
                getMouseRotation();

                if (Input.GetKey(KeyCode.Escape))
                {
                    Cursor.lockState = CursorLockMode.None;
                    Time.timeScale   = 0;
                }
            }

            // Translation
            var translation = GetInputTranslationDirection() * Time.deltaTime;
            var keyRotation = GetMouseTranslationKeybing() * Time.deltaTime;


            m_TargetCameraState.yaw   += keyRotation.x;
            m_TargetCameraState.pitch += keyRotation.y;

            // Speed up movement when shift key held
            if (Input.GetKey(KeyCode.LeftShift))
            {
                translation *= 5.0f;
            }

            // Modify movement by a boost factor (defined in Inspector and modified in play mode through the mouse scroll wheel)
            boost       += Input.mouseScrollDelta.y * 0.2f;
            translation *= Mathf.Pow(2.0f, boost);

            m_TargetCameraState.Translate(translation);

            // Framerate-independent interpolation
            // Calculate the lerp amount, such that we get 99% of the way to our target in the specified time
            var positionLerpPct = 1f - Mathf.Exp((Mathf.Log(1f - 0.99f) / positionLerpTime) * Time.deltaTime);
            var rotationLerpPct = 1f - Mathf.Exp((Mathf.Log(1f - 0.99f) / rotationLerpTime) * Time.deltaTime);
            m_InterpolatingCameraState.LerpTowards(m_TargetCameraState, positionLerpPct, rotationLerpPct);

            m_InterpolatingCameraState.UpdateTransform(transform);
        }
        void Update()
        {
            Vector3 translation = Vector3.zero;

            // Exit Sample
            if (Keyboard.current[Key.Escape].isPressed)
            {
                Application.Quit();
                                #if UNITY_EDITOR
                UnityEditor.EditorApplication.isPlaying = false;
                                #endif
            }
            // Hide and lock cursor when right mouse button pressed
            if (Mouse.current.rightButton.wasPressedThisFrame)
            {
                Cursor.visible   = false;
                Cursor.lockState = CursorLockMode.Confined;
            }

            // Unlock and show cursor when right mouse button released
            if (Mouse.current.rightButton.wasReleasedThisFrame)
            {
                Cursor.visible   = true;
                Cursor.lockState = CursorLockMode.None;
            }

            // Rotation
            if (Mouse.current.rightButton.isPressed)
            {
                Move = controls.Player.Move.ReadValue <Vector2>();
                var mouseMovement = new Vector2(Move.x, Move.y * -1) * 0.05f; // Vector 2!

                var mouseSensitivityFactor = mouseSensitivityCurve.Evaluate(mouseMovement.magnitude);

                m_TargetCameraState.yaw   += mouseMovement.x * mouseSensitivityFactor;
                m_TargetCameraState.pitch += mouseMovement.y * mouseSensitivityFactor;
            }

            // Translation
            translation = GetInputTranslationDirection() * Time.deltaTime * 2;

            // Speed up movement when shift key held
            if (Keyboard.current[Key.LeftShift].isPressed)
            {
                translation *= 2.5f;
            }

            m_TargetCameraState.Translate(translation);

            // Framerate-independent interpolation
            // Calculate the lerp amount, such that we get 99% of the way to our target in the specified time
            var positionLerpPct = 1f - Mathf.Exp((Mathf.Log(1f - 0.99f) / positionLerpTime) * Time.deltaTime);
            var rotationLerpPct = 1f - Mathf.Exp((Mathf.Log(1f - 0.99f) / rotationLerpTime) * Time.deltaTime);
            m_InterpolatingCameraState.LerpTowards(m_TargetCameraState, positionLerpPct, rotationLerpPct);

            m_InterpolatingCameraState.UpdateTransform(transform);
        }
Exemplo n.º 4
0
        void Update()
        {
            Vector3 translation = Vector3.zero;

#if ENABLE_LEGACY_INPUT_MANAGER
            // Exit Sample
            if (Input.GetKey(KeyCode.Escape))
            {
                Application.Quit();
                                #if UNITY_EDITOR
                UnityEditor.EditorApplication.isPlaying = false;
                                #endif
            }
            // Hide and lock cursor when right mouse button pressed
            if (Input.GetMouseButtonDown(0))
            {
                lastPos = new Vector2(Input.GetAxis("Mouse X"), Input.GetAxis("Mouse Y") * (invertY ? 1 : -1));
            }

            // Rotation
            if (Input.GetMouseButton(0) || Input.GetMouseButton(1))
            {
                var mouseMovement = new Vector2(Input.GetAxis("Mouse X"), Input.GetAxis("Mouse Y") * (invertY ? 1 : -1));

                var mouseSensitivityFactor = mouseSensitivityCurve.Evaluate(mouseMovement.magnitude);

                m_TargetCameraState.yaw   += mouseMovement.x * mouseSensitivityFactor;
                m_TargetCameraState.pitch += mouseMovement.y * mouseSensitivityFactor;
            }

            // Translation
            translation = GetInputTranslationDirection() * Time.deltaTime;

            // Speed up movement when shift key held
            if (Input.GetKey(KeyCode.LeftShift))
            {
                translation *= 10.0f;
            }

            // Modify movement by a boost factor (defined in Inspector and modified in play mode through the mouse scroll wheel)
            boost       += Input.mouseScrollDelta.y * 0.2f;
            translation *= Mathf.Pow(2.0f, boost);
#elif USE_INPUT_SYSTEM
            // TODO: make the new input system work
#endif

            m_TargetCameraState.Translate(translation);

            // Framerate-independent interpolation
            // Calculate the lerp amount, such that we get 99% of the way to our target in the specified time
            var positionLerpPct = 1f - Mathf.Exp((Mathf.Log(1f - 0.99f) / positionLerpTime) * Time.deltaTime);
            var rotationLerpPct = 1f - Mathf.Exp((Mathf.Log(1f - 0.99f) / rotationLerpTime) * Time.deltaTime);
            m_InterpolatingCameraState.LerpTowards(m_TargetCameraState, positionLerpPct, rotationLerpPct);

            m_InterpolatingCameraState.UpdateTransform(transform);
        }
Exemplo n.º 5
0
    void LateUpdate()
    {
        // Framerate-independent interpolation
        // Calculate the lerp amount, such that we get 99% of the way to our target in the specified time
        var positionLerpPct = 1f - Mathf.Exp((Mathf.Log(1f - 0.99f) / positionLerpTime) * Time.deltaTime);
        var rotationLerpPct = 1f - Mathf.Exp((Mathf.Log(1f - 0.99f) / rotationLerpTime) * Time.deltaTime);

        m_InterpolatingCameraState.LerpTowards(m_TargetCameraState, positionLerpPct, rotationLerpPct);
        m_InterpolatingCameraState.UpdateTransform(transform);
    }
    private void LateUpdate()
    {
        transform.rotation = Quaternion.Euler(_cameraAngle, 0f, 0f);

        Vector3 desieredCameraPosition = GetCameraPosition();

        _interpolatingCameraState.LerpTowards(desieredCameraPosition, _positionLerpTime * Time.deltaTime);

        _interpolatingCameraState.UpdateTransform(transform);
    }
Exemplo n.º 7
0
        void Update()
        {
            Vector3 translation = Vector3.zero;

#if ENABLE_LEGACY_INPUT_MANAGER
            // Hide and lock cursor when right mouse button pressed
            if (Input.GetMouseButtonDown(1))
            {
                Cursor.lockState = CursorLockMode.Locked;
            }

            // Unlock and show cursor when right mouse button released
            if (Input.GetMouseButtonUp(1))
            {
                Cursor.visible   = true;
                Cursor.lockState = CursorLockMode.None;
            }

            // Rotation
            if (Input.GetMouseButton(1))
            {
                var mouseMovement = new Vector2(Input.GetAxis("Mouse X"), Input.GetAxis("Mouse Y") * (invertY ? 1 : -1));

                var mouseSensitivityFactor = mouseSensitivityCurve.Evaluate(mouseMovement.magnitude);

                m_TargetCameraState.yaw   += mouseMovement.x * mouseSensitivityFactor;
                m_TargetCameraState.pitch += mouseMovement.y * mouseSensitivityFactor;
            }

            // Translation
            translation = GetInputTranslationDirection() * Time.deltaTime;

            // Speed up movement when shift key held
            //if (Input.GetKey(KeyCode.LeftShift))
            //{
            //    //translation *= 10.0f;
            //}

            // Modify movement by a boost factor (defined in Inspector and modified in play mode through the mouse scroll wheel)
            //boost += Input.mouseScrollDelta.y * 0.2f;
            translation *= Mathf.Pow(2.0f, boost);
#elif USE_INPUT_SYSTEM
            // TODO: make the new input system work
#endif

            m_TargetCameraState.Translate(translation);

            // Framerate-independent interpolation
            // Calculate the lerp amount, such that we get 99% of the way to our target in the specified time
            var positionLerpPct = 1f - Mathf.Exp((Mathf.Log(1f - 0.99f) / positionLerpTime) * Time.deltaTime);
            var rotationLerpPct = 1f - Mathf.Exp((Mathf.Log(1f - 0.99f) / rotationLerpTime) * Time.deltaTime);
            m_InterpolatingCameraState.LerpTowards(m_TargetCameraState, positionLerpPct, rotationLerpPct);

            m_InterpolatingCameraState.UpdateTransform(transform);
        }
        void Update()
        {
            // Hide and lock cursor when right mouse button pressed
            if (IsRightMouseButtonDown())
            {
                Cursor.lockState = CursorLockMode.Locked;
            }

            // Unlock and show cursor when right mouse button released
            if (IsRightMouseButtonUp())
            {
                Cursor.visible   = true;
                Cursor.lockState = CursorLockMode.None;
            }

            // Rotation
            if (IsCameraRotationAllowed())
            {
                var mouseMovement = GetInputLookRotation() * Time.deltaTime * 5;
                if (invertY)
                {
                    mouseMovement.y = -mouseMovement.y;
                }

                var mouseSensitivityFactor = mouseSensitivityCurve.Evaluate(mouseMovement.magnitude);

                m_TargetCameraState.yaw   += mouseMovement.x * mouseSensitivityFactor;
                m_TargetCameraState.pitch += mouseMovement.y * mouseSensitivityFactor;
            }

            // Translation
            var translation = GetInputTranslationDirection() * Time.deltaTime;

            // Speed up movement when shift key held
            if (IsBoostPressed())
            {
                translation *= 10.0f;
            }

            // Modify movement by a boost factor (defined in Inspector and modified in play mode through the mouse scroll wheel)
            boost       += GetBoostFactor();
            translation *= Mathf.Pow(2.0f, boost);

            m_TargetCameraState.Translate(translation);

            // Framerate-independent interpolation
            // Calculate the lerp amount, such that we get 99% of the way to our target in the specified time
            var positionLerpPct = 1f - Mathf.Exp((Mathf.Log(1f - 0.99f) / positionLerpTime) * Time.deltaTime);
            var rotationLerpPct = 1f - Mathf.Exp((Mathf.Log(1f - 0.99f) / rotationLerpTime) * Time.deltaTime);

            m_InterpolatingCameraState.LerpTowards(m_TargetCameraState, positionLerpPct, rotationLerpPct);

            m_InterpolatingCameraState.UpdateTransform(transform);
        }
    void Update()
    {
        //-- exit play mode
        if (Input.GetKey(KeyCode.Escape))
        {
            Application.Quit();
#if UNITY_EDITOR
            UnityEditor.EditorApplication.isPlaying = false;
#endif
        }

        //-- Hide+lock cursor while RMB pressed
        if (Input.GetMouseButtonDown(1))
        {
            Cursor.lockState = CursorLockMode.Locked; // locked to center of view, invisible
        }
        if (Input.GetMouseButtonUp(1))
        {
            Cursor.visible   = true;
            Cursor.lockState = CursorLockMode.None;
        }

        //-- Camera rotation
        if (Input.GetMouseButton(1))
        {
            var mouseMovement = new Vector2(Input.GetAxis("Mouse X"), Input.GetAxis("Mouse Y"));

            var mouseSensitivityFactor = MouseSensitivityCurve.Evaluate(mouseMovement.magnitude);

            _targetCameraState.yaw   += mouseMovement.x * mouseSensitivityFactor;
            _targetCameraState.pitch -= mouseMovement.y * mouseSensitivityFactor;
        }

        //-- Camera translation (Shift - increase speed)
        var shift = GetInputTranslationDirection() * Time.deltaTime;
        if (Input.GetKey(KeyCode.LeftShift))
        {
            shift *= 10.0f;
        }

        //-- Movement boost factor (controlled by mouse wheel)
        Boost += Input.mouseScrollDelta.y * 0.2f;
        shift *= Mathf.Pow(2.0f, Boost);

        _targetCameraState.Translate(shift);


        //-- interpolation
        var positionLerpFactor = 1f - Mathf.Exp((Mathf.Log(1f - 0.99f) / PositionLerpTime) * Time.deltaTime);
        var rotationLerpFactor = 1f - Mathf.Exp((Mathf.Log(1f - 0.99f) / PositionLerpTime) * Time.deltaTime);

        _interpolatingCameraState.LerpTowards(_targetCameraState, positionLerpFactor, rotationLerpFactor);
        _interpolatingCameraState.UpdateTransform(transform);
    }
Exemplo n.º 10
0
        void FixedUpdate()
        {
            if (m_keyboard == null)
            {
                return;
            }
            if (m_keyboard.uKey.isPressed)
            {
                ResetCamera();
                return;
            }

            var touches = m_screen.GetTouches();

            // Rotation
            if (IsMouseDragged(m_mouse, false))
            {
                UpdateTargetCameraStateFromInput(m_mouse.delta.ReadValue());
            }
            else if (touches.Count() == 1)
            {
                var activeTouches = touches.ToArray();
                UpdateTargetCameraStateFromInput(activeTouches[0].delta);
            }

            // Rotation from joystick
            if (m_gamepad?.leftStick != null)
            {
                UpdateTargetCameraStateFromInput(m_gamepad.leftStick.ReadValue());
            }
            // Translation
            var translation = GetInputTranslationDirection() * Time.deltaTime;

            // Speed up movement when shift key held
            if (m_keyboard.leftShiftKey.isPressed)
            {
                translation *= 10.0f;
            }

            translation *= Mathf.Pow(2.0f, boost);

            m_TargetCameraState.Translate(translation);

            // Framerate-independent interpolation
            // Calculate the lerp amount, such that we get 99% of the way to our target in the specified time
            var positionLerpPct = 1f - Mathf.Exp((Mathf.Log(1f - 0.99f) / positionLerpTime) * Time.deltaTime);
            var rotationLerpPct = 1f - Mathf.Exp((Mathf.Log(1f - 0.99f) / rotationLerpTime) * Time.deltaTime);

            m_InterpolatingCameraState.LerpTowards(m_TargetCameraState, positionLerpPct, rotationLerpPct);

            m_InterpolatingCameraState.UpdateTransform(transform);
        }
Exemplo n.º 11
0
    void FixedUpdate()
    {
        if (Input.GetKey(KeyCode.Escape))
        {
            Application.Quit();
                                #if UNITY_EDITOR
            UnityEditor.EditorApplication.isPlaying = false;
                                #endif
        }

        if (Input.GetMouseButtonDown(1))
        {
            Cursor.lockState = CursorLockMode.Locked;
            Cursor.visible   = false;
        }

        if (Input.GetMouseButtonUp(1))
        {
            Cursor.visible   = true;
            Cursor.lockState = CursorLockMode.None;
        }

        if (Input.GetMouseButton(1))
        {
            var mouseMovement = new Vector2(Input.GetAxis("Mouse X"), Input.GetAxis("Mouse Y") * (invertY ? 1 : -1));

            var mouseSensitivityFactor = mouseSensitivityCurve.Evaluate(mouseMovement.magnitude);

            m_TargetCameraState.yaw   += mouseMovement.x * mouseSensitivityFactor;
            m_TargetCameraState.pitch += mouseMovement.y * mouseSensitivityFactor;
        }

        var translation = GetInputTranslationDirection() * Time.deltaTime;

        if (Input.GetKey(KeyCode.LeftShift))
        {
            translation *= 10.0f;
        }

        boost       += Input.mouseScrollDelta.y * 0.2f;
        translation *= Mathf.Pow(2.0f, boost);

        m_TargetCameraState.Translate(translation);
        //characterController.  //Move(translation);

        var positionLerpPct = 1f - Mathf.Exp((Mathf.Log(1f - 0.99f) / positionLerpTime) * Time.deltaTime);
        var rotationLerpPct = 1f - Mathf.Exp((Mathf.Log(1f - 0.99f) / rotationLerpTime) * Time.deltaTime);
        m_InterpolatingCameraState.LerpTowards(m_TargetCameraState, positionLerpPct, rotationLerpPct);

        m_InterpolatingCameraState.UpdateTransform(transform);
    }
        private void Update()
        {
            float dt = Time.deltaTime;

            if (Keyboard.current.escapeKey.wasPressedThisFrame)
            {
#if UNITY_EDITOR
                EditorApplication.isPlaying = false;
#endif
                Application.Quit();
            }

            if (Mouse.current.rightButton.wasPressedThisFrame)
            {
                Cursor.visible   = false;
                Cursor.lockState = CursorLockMode.Locked;
            }

            if (Mouse.current.rightButton.wasReleasedThisFrame)
            {
                Cursor.visible   = true;
                Cursor.lockState = CursorLockMode.None;
            }

            // rotation
            if (Mouse.current.rightButton.isPressed)
            {
                Vector2 mouseMovement = Mouse.current.delta.ReadValue() * 0.02f;
                mouseMovement.y = mouseMovement.y * (invertY ? 1 : -1);
                float mouseSensitivityFactor = mouseSensitivityCurve.Evaluate(mouseMovement.magnitude);

                targetCameraState.yaw   += mouseMovement.x * mouseSensitivityFactor;
                targetCameraState.pitch += mouseMovement.y * mouseSensitivityFactor;
            }

            // translation
            Vector3 translation = GetInputTranslationDirection() * dt;
            if (Keyboard.current.leftShiftKey.isPressed)
            {
                translation *= 10.0f;
            }

            // modify movement by a boost factor
            boost       += Mouse.current.scroll.y.ReadValue() * 0.002f;
            translation *= Mathf.Pow(2.0f, boost);

            targetCameraState.Translate(translation);

            interpolatingCameraState.LerpTowards(targetCameraState, positionLerpTime, rotationLerpTime, dt);
            interpolatingCameraState.UpdateTransform(transform);
        }
    public void NotifyCameraMovement(Vector3 direction)
    {
        direction *= Time.deltaTime;
        direction *= Mathf.Pow(2.0f, boost);
        m_TargetCameraState.Translate(direction);
        // Framerate-independent interpolation
        // Calculate the lerp amount, such that we get 99% of the way to our target in the specified time
        var positionLerpPct = 1f - Mathf.Exp((Mathf.Log(1f - 0.99f) / positionLerpTime) * Time.deltaTime);
        var rotationLerpPct = 1f - Mathf.Exp((Mathf.Log(1f - 0.99f) / rotationLerpTime) * Time.deltaTime);

        m_InterpolatingCameraState.LerpTowards(m_TargetCameraState, positionLerpPct, rotationLerpPct);

        m_InterpolatingCameraState.UpdateTransform(transform);
    }
Exemplo n.º 14
0
        void Update()
        {
            // Exit Sample
            if (dontMove)
            {
                return;
            }

            if (Input.GetKey(KeyCode.Escape))
            {
                Application.Quit();
                                #if UNITY_EDITOR
                UnityEditor.EditorApplication.isPlaying = false;
                                #endif
            }
            // Hide and lock cursor when right mouse button pressed
            if (Input.GetMouseButtonDown(1))
            {
                Cursor.lockState = CursorLockMode.Locked;
            }

            // Unlock and show cursor when right mouse button released
            if (Input.GetMouseButtonUp(1))
            {
                Cursor.visible   = true;
                Cursor.lockState = CursorLockMode.None;
            }

            // Rotation
            if (Input.GetMouseButton(1))
            {
                var mouseMovement = new Vector2(Input.GetAxis("Mouse X"), Input.GetAxis("Mouse Y") * (invertY ? 1 : -1));

                var mouseSensitivityFactor = mouseSensitivityCurve.Evaluate(mouseMovement.magnitude);

                m_TargetCameraState.yaw   += mouseMovement.x * mouseSensitivityFactor;
                m_TargetCameraState.pitch += mouseMovement.y * mouseSensitivityFactor;
            }

            m_TargetCameraState.distance      -= Input.mouseScrollDelta.y * distanceSteps;
            m_TargetCameraState.targetPosition = targetPosition;

            // Framerate-independent interpolation
            // Calculate the lerp amount, such that we get 99% of the way to our target in the specified time
            var positionLerpPct = 1f - Mathf.Exp((Mathf.Log(1f - 0.99f) / positionLerpTime) * Time.deltaTime);
            var rotationLerpPct = 1f - Mathf.Exp((Mathf.Log(1f - 0.99f) / rotationLerpTime) * Time.deltaTime);
            m_InterpolatingCameraState.LerpTowards(m_TargetCameraState, positionLerpPct, rotationLerpPct);

            m_InterpolatingCameraState.UpdateTransform(transform);
        }
Exemplo n.º 15
0
    void FPSMovement()
    {
        // Use LSHIFT to toggle control
        if (Input.GetKeyDown(KeyCode.LeftShift))
        {
            Cursor.lockState = CursorLockMode.Locked;
        }

        // Unlock and show cursor when right mouse button released
        if (Input.GetKeyUp(KeyCode.LeftShift))
        {
            Cursor.visible   = true;
            Cursor.lockState = CursorLockMode.None;
        }

        if (Input.GetKey(KeyCode.LeftShift))
        {
            // Rotation
            var mouseMovement = new Vector2(Input.GetAxis("Mouse X"), Input.GetAxis("Mouse Y") * (invertY ? 1 : -1));

            var mouseSensitivityFactor = mouseSensitivityCurve.Evaluate(mouseMovement.magnitude);

            m_TargetCameraState.yaw   += mouseMovement.x * mouseSensitivityFactor;
            m_TargetCameraState.pitch += mouseMovement.y * mouseSensitivityFactor;

            // Translation
            var translation = GetInputTranslationDirection() * Time.deltaTime;

            //// Speed up movement when shift key held
            //if (Input.GetKey(KeyCode.LeftShift)) {
            //  translation *= 10.0f;
            //}

            // Modify movement by a boost factor (defined in Inspector and modified in play mode through the mouse scroll wheel)
            boost       += Input.mouseScrollDelta.y * 0.2f;
            translation *= Mathf.Pow(2.0f, boost);

            m_TargetCameraState.Translate(translation);

            // Framerate-independent interpolation
            // Calculate the lerp amount, such that we get 99% of the way to our target in the specified time
            var positionLerpPct = 1f - Mathf.Exp((Mathf.Log(1f - 0.99f) / positionLerpTime) * Time.deltaTime);
            var rotationLerpPct = 1f - Mathf.Exp((Mathf.Log(1f - 0.99f) / rotationLerpTime) * Time.deltaTime);
            m_InterpolatingCameraState.LerpTowards(m_TargetCameraState, positionLerpPct, rotationLerpPct);

            m_InterpolatingCameraState.UpdateTransform(transform);
        }
        /////
    }
Exemplo n.º 16
0
    private void Update()
    {
        if (Input.GetKey(KeyCode.Escape))
        {
            Application.Quit();
                        #if UNITY_EDITOR
            UnityEditor.EditorApplication.isPlaying = false;
                        #endif
        }

        // Hide and lock cursor when right mouse button pressed
        if (Input.GetMouseButtonDown(1))
        {
            Cursor.lockState = CursorLockMode.Locked;
        }

        // Unlock and show cursor when right mouse button released
        if (Input.GetMouseButtonUp(1))
        {
            Cursor.visible   = true;
            Cursor.lockState = CursorLockMode.None;
        }

        // Rotation
        if (Input.GetMouseButton(2))
        {
            var mouseMovement          = new Vector2(Input.GetAxis("Mouse X"), Input.GetAxis("Mouse Y") * (invertY ? 1 : -1));
            var mouseSensitivityFactor = mouseSensitivityCurve.Evaluate(mouseMovement.magnitude);
            _targetCameraState.Yaw    += mouseMovement.x * mouseSensitivityFactor;
            _targetCameraState.Degree += mouseMovement.y * mouseSensitivityFactor;
        }

        // Translation
        var translation = GetInputTranslationDirection() * Time.deltaTime;

        // Speed up movement when shift key held
        if (Input.GetKey(KeyCode.LeftShift))
        {
            translation *= 10.0f;
        }

        boost       += Input.mouseScrollDelta.y * 0.2f;
        translation *= Mathf.Pow(2.0f, boost);
        _targetCameraState.Translate(translation);
        var positionLerpPct = 1f - Mathf.Exp((Mathf.Log(1f - 0.99f) / positionLerpTime) * Time.deltaTime);
        var rotationLerpPct = 1f - Mathf.Exp((Mathf.Log(1f - 0.99f) / rotationLerpTime) * Time.deltaTime);
        _interpolatingCameraState.LerpTowards(_targetCameraState, positionLerpPct, rotationLerpPct);
        _interpolatingCameraState.UpdateTransform(transform);
    }
Exemplo n.º 17
0
        void FixedUpdate()
        {
            if (Keyboard.current.uKey.isPressed)
            {
                ResetCamera();
                return;
            }

            // Rotation
            if (IsMouseDragged(Mouse.current, false))
            {
                UpdateTargetCameraStateFromInput(Mouse.current.delta.ReadValue());
            }
            else if (IsMouseDragged(RemoteInput.RemoteMouse, false))
            {
                UpdateTargetCameraStateFromInput(RemoteInput.RemoteMouse.delta.ReadValue());
            }
            else if (UnityEngine.InputSystem.EnhancedTouch.Touch.activeTouches.Count == 1)
            {
                UpdateTargetCameraStateFromInput(UnityEngine.InputSystem.EnhancedTouch.Touch.activeTouches[0].delta);
            }

            // Rotation from joystick
            if (Gamepad.all.Count > 0)
            {
                UpdateTargetCameraStateFromInput(Gamepad.all[Gamepad.all.Count - 1].leftStick.ReadValue());
            }
            // Translation
            var translation = GetInputTranslationDirection() * Time.deltaTime;

            // Speed up movement when shift key held
            if (Keyboard.current.leftShiftKey.isPressed)
            {
                translation *= 10.0f;
            }

            translation *= Mathf.Pow(2.0f, boost);

            m_TargetCameraState.Translate(translation);

            // Framerate-independent interpolation
            // Calculate the lerp amount, such that we get 99% of the way to our target in the specified time
            var positionLerpPct = 1f - Mathf.Exp((Mathf.Log(1f - 0.99f) / positionLerpTime) * Time.deltaTime);
            var rotationLerpPct = 1f - Mathf.Exp((Mathf.Log(1f - 0.99f) / rotationLerpTime) * Time.deltaTime);

            m_InterpolatingCameraState.LerpTowards(m_TargetCameraState, positionLerpPct, rotationLerpPct);

            m_InterpolatingCameraState.UpdateTransform(transform);
        }
    void LateUpdate()
    {
        if (Input.GetKeyDown(KeyCode.Escape))
        {
            if (settings.activeInHierarchy)
            {
                settings.SetActive(false); QuitButton.SetActive(false);
            }
            else
            {
                settings.SetActive(true); QuitButton.SetActive(true);
            }
            Back.SetActive(false);
        }

        if (Input.GetMouseButton(1))
        {
            Cursor.lockState = CursorLockMode.Locked;
            Cursor.visible   = false;

            RotX = Input.GetAxis("Mouse X");
            RotY = Input.GetAxis("Mouse Y");

            var mouseMovement = new Vector2(RotX, RotY * (invertY ? 1 : -1));
            //var mouseSenseFactor = mouseSensitivityCurve.Evaluate(mouseMovement.magnitude) * mouseSenseValue;
            var mouseSenseFactor = mouseSenseValue;

            targetState.yaw   += mouseMovement.x * mouseSenseFactor;
            targetState.pitch += mouseMovement.y * mouseSenseFactor;

            var positionLerpPct = 1f - Mathf.Exp((Mathf.Log(1f - 0.99f) / positionLerpTime) * Time.deltaTime);
            var rotationLerpPct = 1f - Mathf.Exp((Mathf.Log(1f - 0.99f) / rotationLerpTime) * Time.deltaTime);
            InterpolateCameraState.LerpTowards(targetState, positionLerpPct, rotationLerpPct);

            InterpolateCameraState.UpdateTransform(transform);

            var characterRotation = transform.rotation;
            characterRotation.x = 0;
            characterRotation.z = 0;

            playerObject.transform.rotation = characterRotation;
        }
        else
        {
            Cursor.lockState = CursorLockMode.None;
            Cursor.visible   = true;
        }
    }
Exemplo n.º 19
0
        void Update()
        {
            // Exit Sample
            if (controls.Game.Quit.ReadValue <float>() == 1)
            {
                Application.Quit();
                #if UNITY_EDITOR
                UnityEditor.EditorApplication.isPlaying = false;
                #endif
            }

            // Rotation
            if (controls.Camera.Aim.ReadValue <float>() == 1)
            {
                var mouseMovement = new Vector2(controls.Camera.Rotation.ReadValue <Vector2>().x, controls.Camera.Rotation.ReadValue <Vector2>().y *(invertY ? 1 : -1));

                var mouseSensitivityFactor = mouseSensitivityCurve.Evaluate(mouseMovement.magnitude / magnitudeForMaxSensitivity);

                m_TargetCameraState.yaw   += mouseMovement.x * mouseSensitivityFactor;
                m_TargetCameraState.pitch += mouseMovement.y * mouseSensitivityFactor;
            }

            // Translation
            var translation = GetInputTranslationDirection() * Time.deltaTime;

            // Speed up movement when shift key held
            if (controls.Camera.SpeedUp.ReadValue <float>() == 1)
            {
                translation *= speedUpMultiplier;
            }

            // Modify movement by a boost factor (defined in Inspector and modified in play mode through the mouse scroll wheel)
            boost       += controls.Camera.Boost.ReadValue <float>() * boostInputMultiplier;
            boost        = Mathf.Clamp(boost, minBoost, maxBoost);
            translation *= Mathf.Pow(2.0f, boost);

            m_TargetCameraState.Translate(translation);

            // Framerate-independent interpolation
            // Calculate the lerp amount, such that we get 99% of the way to our target in the specified time
            var positionLerpPct = 1f - Mathf.Exp((Mathf.Log(1f - 0.99f) / positionLerpTime) * Time.deltaTime);
            var rotationLerpPct = 1f - Mathf.Exp((Mathf.Log(1f - 0.99f) / rotationLerpTime) * Time.deltaTime);
            m_InterpolatingCameraState.LerpTowards(m_TargetCameraState, positionLerpPct, rotationLerpPct);

            m_InterpolatingCameraState.UpdateTransform(transform);
        }
Exemplo n.º 20
0
    private void GetInputRotation()
    {
        var mouseMovement = new Vector2(Input.GetAxis("Mouse X"), Input.GetAxis("Mouse Y") * (invertY ? 1 : -1));

        var mouseSensitivityFactor = mouseSensitivityCurve.Evaluate(mouseMovement.magnitude);

        m_TargetCameraState.yaw   += mouseMovement.x * mouseSensitivityFactor;
        m_TargetCameraState.pitch += mouseMovement.y * mouseSensitivityFactor;

        // Framerate-independent interpolation
        // Calculate the lerp amount, such that we get 99% of the way to our target in the specified time
        var rotationLerpPct = 1f - Mathf.Exp((Mathf.Log(1f - 0.99f) / rotationLerpTime) * Time.deltaTime);

        m_InterpolatingCameraState.LerpTowards(m_TargetCameraState, rotationLerpPct);

        m_InterpolatingCameraState.UpdateTransform(BoomArm.transform);
    }
Exemplo n.º 21
0
    private void Update()
    {
        // Hide and lock cursor when right mouse button pressed
        if (Input.GetMouseButtonDown(1))
        {
            Cursor.lockState = CursorLockMode.Locked;
        }
        else if (Input.GetMouseButtonUp(1)) // Unlock and show cursor when right mouse button released
        {
            Cursor.lockState = CursorLockMode.None;
        }

        // Rotation
        if (Input.GetMouseButton(1))
        {
            var mouseMovement = new Vector2(Input.GetAxis("Mouse X"), Input.GetAxis("Mouse Y") * (invertY ? 1 : -1));

            var mouseSensitivityFactor = mouseSensitivityCurve.Evaluate(mouseMovement.magnitude);

            targetCameraState.yaw   += mouseMovement.x * mouseSensitivityFactor;
            targetCameraState.pitch += mouseMovement.y * mouseSensitivityFactor;
        }

        // Translation
        var translation = GetInputTranslationDirection() * Time.deltaTime;

        // Speed up movement
        if (Input.GetKey(KeyCode.LeftControl))
        {
            translation *= 10.0f;
        }

        // Modify movement by a boost factor (defined in Inspector and modified in play mode through the mouse scroll wheel)
        boost       += Input.mouseScrollDelta.y * 0.2f;
        translation *= Mathf.Pow(2.0f, boost);

        targetCameraState.Translate(translation);

        // Framerate independent interp
        var positionLerpPct = 1f - Mathf.Exp((Mathf.Log(1f - 0.99f) / positionLerpTime) * Time.deltaTime);
        var rotationLerpPct = 1f - Mathf.Exp((Mathf.Log(1f - 0.99f) / rotationLerpTime) * Time.deltaTime);

        interpolatingCameraState.LerpTowards(targetCameraState, positionLerpPct, rotationLerpPct);

        interpolatingCameraState.UpdateTransform(transform);
    }
Exemplo n.º 22
0
    void Update()
    {
        // Hide and lock cursor when right mouse button pressed
        if (Input.GetMouseButtonDown(1))
        {
            Cursor.lockState = CursorLockMode.Locked;
        }

        // Unlock and show cursor when right mouse button released
        if (Input.GetMouseButtonUp(1))
        {
            Cursor.visible   = true;
            Cursor.lockState = CursorLockMode.None;
        }

        // Rotation
        if (Input.GetMouseButton(1))
        {
            Vector2 mouseMovement = new Vector2(Input.GetAxis("Mouse X"), Input.GetAxis("Mouse Y") * (m_InvertY ? 1 : -1));

            float mouseSensitivityFactor = m_MouseSensitivityCurve.Evaluate(mouseMovement.magnitude);

            m_TargetCameraState.yaw   += mouseMovement.x * mouseSensitivityFactor;
            m_TargetCameraState.pitch += mouseMovement.y * mouseSensitivityFactor;
        }

        // Translation
        Vector3 translation = GetInputTranslationDirection() * Time.deltaTime;

        // Modify movement by a boost factor (defined in Inspector and modified in play mode through the mouse scroll wheel)
        translation *= m_Boost;

        m_TargetCameraState.Translate(translation);

        // Framerate-independent interpolation
        // Calculate the lerp amount, such that we get 99% of the way to our target in the specified time
        float positionLerpPct = 1f - Mathf.Exp((Mathf.Log(1f - 0.99f) / m_PositionLerpTime) * Time.deltaTime);
        float rotationLerpPct = 1f - Mathf.Exp((Mathf.Log(1f - 0.99f) / m_RotationLerpTime) * Time.deltaTime);

        m_InterpolatingCameraState.LerpTowards(m_TargetCameraState, positionLerpPct, rotationLerpPct);

        m_InterpolatingCameraState.UpdateTransform(transform);

        m_Compass.position         = transform.position + m_CompassPositionOffset;
        m_Compass.localEulerAngles = -transform.eulerAngles;
    }
Exemplo n.º 23
0
    void Update()
    {
        // Exit Sample
        if (Input.GetKey(KeyCode.Escape))
        {
            Application.Quit();
#if UNITY_EDITOR
            UnityEditor.EditorApplication.isPlaying = false;
#endif
        }

        // Rotation
        if (Input.GetMouseButton(1))
        {
            var mouseMovement = new Vector2(Input.GetAxis("Mouse X"), Input.GetAxis("Mouse Y") * (invertY? 1: -1));

            var mouseSensitivityFactor = mouseSensitivityCurve.Evaluate(mouseMovement.magnitude);

            m_TargetCameraState.yaw   += mouseMovement.x * mouseSensitivityFactor;
            m_TargetCameraState.pitch += mouseMovement.y * mouseSensitivityFactor;
        }

        // Translation
        var translation = GetInputTranslationDirection() * Time.deltaTime;

        // Speed up movement when shift key held
        if (Input.GetKey(KeyCode.LeftShift))
        {
            translation *= 10.0f;
        }

        //boost += Input.mouseScrollDelta.y * 0.2f;
        translation *= Mathf.Pow(2.0f, boost);

        m_TargetCameraState.Translate(translation);

        // Framerate-independent interpolation
        // Calculate the lerp amount, such that we get 99% of the way to our target in the specified time
        var positionLerpPct = 1f - Mathf.Exp((Mathf.Log(1f - 0.99f) / positionLerpTime) * Time.deltaTime);
        var rotationLerpPct = 1f - Mathf.Exp((Mathf.Log(1f - 0.99f) / rotationLerpTime) * Time.deltaTime);
        m_InterpolatingCameraState.LerpTowards(m_TargetCameraState, positionLerpPct, rotationLerpPct);

        m_InterpolatingCameraState.UpdateTransform(transform);
    }
        void Update()
        {
            // Translation



            // Modify movement by a boost factor (defined in Inspector and modified in play mode through the mouse scroll wheel)



            // Framerate-independent interpolation
            // Calculate the lerp amount, such that we get 99% of the way to our target in the specified time
            var positionLerpPct = 1f - Mathf.Exp((Mathf.Log(1f - 0.99f) / positionLerpTime) * Time.deltaTime);
            var rotationLerpPct = 1f - Mathf.Exp((Mathf.Log(1f - 0.99f) / rotationLerpTime) * Time.deltaTime);

            m_InterpolatingCameraState.LerpTowards(m_TargetCameraState, positionLerpPct, rotationLerpPct);

            m_InterpolatingCameraState.UpdateTransform(transform);
        }
Exemplo n.º 25
0
        private void FixedUpdate()
        {
            // Tracked Device
            if (inputPosition.HasValue && inputRotation.HasValue)
            {
                transform.position = inputPosition.Value;
                transform.rotation = inputRotation.Value;
                return;
            }

            UpdateTargetCameraStateDirection(inputMovement);
            UpdateTargetCameraStateFromInput(inputLook);

            // Framerate-independent interpolation
            // Calculate the lerp amount, such that we get 99% of the way to our target in the specified time
            var positionLerpPct = 1f - Mathf.Exp((Mathf.Log(1f - 0.99f) / positionLerpTime) * Time.deltaTime);
            var rotationLerpPct = 1f - Mathf.Exp((Mathf.Log(1f - 0.99f) / rotationLerpTime) * Time.deltaTime);

            m_InterpolatingCameraState.LerpTowards(m_TargetCameraState, positionLerpPct, rotationLerpPct);
            m_InterpolatingCameraState.UpdateTransform(transform);
        }
Exemplo n.º 26
0
        public void GameUpdate()
        {
            if (ActiveControl)
            {
                // Rotation
                if (Input.GetMouseButton(1))
                {
                    var mouseMovement = new Vector2(Input.GetAxis("Mouse X"), Input.GetAxis("Mouse Y") * (invertY ? 1 : -1));

                    var mouseSensitivityFactor = mouseSensitivityCurve.Evaluate(mouseMovement.magnitude);

                    m_TargetCameraState.yaw   += mouseMovement.x * mouseSensitivityFactor;
                    m_TargetCameraState.pitch += mouseMovement.y * mouseSensitivityFactor;
                }

                // Translation
                var translation = GetInputTranslationDirection() * Time.deltaTime;

                // Speed up movement when shift key held
                if (Input.GetKey(KeyCode.LeftShift))
                {
                    translation *= 10.0f;
                }

                // Modify movement by a boost factor (defined in Inspector and modified in play mode through the mouse scroll wheel)
                boost       += Input.mouseScrollDelta.y * 0.2f;
                translation *= Mathf.Pow(2.0f, boost);

                m_TargetCameraState.Translate(translation);


                // Framerate-independent interpolation
                // Calculate the lerp amount, such that we get 99% of the way to our target in the specified time
                var positionLerpPct = 1f - Mathf.Exp((Mathf.Log(1f - 0.99f) / positionLerpTime) * Time.deltaTime);
                var rotationLerpPct = 1f - Mathf.Exp((Mathf.Log(1f - 0.99f) / rotationLerpTime) * Time.deltaTime);
                m_InterpolatingCameraState.LerpTowards(m_TargetCameraState, positionLerpPct, rotationLerpPct);

                m_InterpolatingCameraState.UpdateTransform(transform);
            }
        }
        void Update()
        {
            Vector3 translation = Vector3.zero;

#if ENABLE_LEGACY_INPUT_MANAGER
            // Exit Sample
            if (Input.GetKey(KeyCode.Escape))
            {
                Application.Quit();
                                #if UNITY_EDITOR
                UnityEditor.EditorApplication.isPlaying = false;
                                #endif
            }

            var mouseMovement = new Vector2(Input.GetAxis("Mouse X"), Input.GetAxis("Mouse Y") * (invertY ? 1 : -1));

            var mouseSensitivityFactor = mouseSensitivityCurve.Evaluate(mouseMovement.magnitude);

            m_TargetCameraState.yaw   += mouseMovement.x * mouseSensitivityFactor;
            m_TargetCameraState.pitch += mouseMovement.y * mouseSensitivityFactor;

            // Translation
            translation = GetInputTranslationDirection() * Time.deltaTime;

            translation *= Mathf.Pow(2.0f, speed);
#elif USE_INPUT_SYSTEM
            // TODO: make the new input system work
#endif

            m_TargetCameraState.Translate(translation);

            // Framerate-independent interpolation
            // Calculate the lerp amount, such that we get 99% of the way to our target in the specified time
            var positionLerpPct = 1f - Mathf.Exp((Mathf.Log(1f - 0.99f) / positionLerpTime) * Time.deltaTime);
            var rotationLerpPct = 1f - Mathf.Exp((Mathf.Log(1f - 0.99f) / rotationLerpTime) * Time.deltaTime);
            m_InterpolatingCameraState.LerpTowards(m_TargetCameraState, positionLerpPct, rotationLerpPct);

            m_InterpolatingCameraState.UpdateTransform(transform);
        }
Exemplo n.º 28
0
        void Update()
        {
            // Rotation
            var mouseMovement = GetInputLookRotation() * 0.1f;

            mouseMovement.y = -mouseMovement.y;

            m_TargetCameraState.yaw   += mouseMovement.x;
            m_TargetCameraState.pitch += mouseMovement.y;

            // Translation
            var translation = GetInputTranslationDirection() * Time.deltaTime;
            var deltaY      = verticalMovementAction.ReadValue <Vector2>().y *Time.deltaTime;

            // Modify movement by a boost factor (defined in Inspector and modified in play mode through the mouse scroll wheel)
            boost += GetBoostFactor();

            float currentBoostFactor = Mathf.Pow(2.0f, boost);

            // Speed up movement when shift key held
            if (IsBoostPressed())
            {
                currentBoostFactor *= 10.0f;
            }

            translation *= currentBoostFactor;
            deltaY      *= currentBoostFactor;

            m_TargetCameraState.Translate(translation, deltaY);

            // Framerate-independent interpolation
            // Calculate the lerp amount, such that we get 99% of the way to our target in the specified time
            var positionLerpPct = 1f - Mathf.Exp((Mathf.Log(1f - 0.99f) / positionLerpTime) * Time.deltaTime);
            var rotationLerpPct = 1f - Mathf.Exp((Mathf.Log(1f - 0.99f) / rotationLerpTime) * Time.deltaTime);

            m_InterpolatingCameraState.LerpTowards(m_TargetCameraState, positionLerpPct, rotationLerpPct);

            m_InterpolatingCameraState.UpdateTransform(transform);
        }
Exemplo n.º 29
0
        void Update()
        {
            Vector3 translation = Vector3.zero;

            // Exit Sample
            if (Input.GetKey(KeyCode.Escape))
            {
                Application.Quit();
                                #if UNITY_EDITOR
                UnityEditor.EditorApplication.isPlaying = false;
                                #endif
            }

            if (Input.GetMouseButton(1) || !rightClickToLook || (Input.GetKey(KeyCode.LeftAlt) && Input.GetMouseButton(0)))
            {
                var mouseMovement = new Vector2(Input.GetAxis("Mouse X"), Input.GetAxis("Mouse Y") * (invertY ? 1 : -1));

                var mouseSensitivityFactor = mouseSensitivityCurve.Evaluate(mouseMovement.magnitude);

                m_TargetCameraState.yaw   += mouseMovement.x * mouseSensitivityFactor;
                m_TargetCameraState.pitch += mouseMovement.y * mouseSensitivityFactor;
            }

            // Translation
            translation = GetInputTranslationDirection() * Time.unscaledDeltaTime;

            // Modify movement by a boost factor (defined in Inspector)
            translation *= Mathf.Pow(2.0f, boost);

            m_TargetCameraState.Translate(translation, bounds);

            // Framerate-independent interpolation
            // Calculate the lerp amount, such that we get 99% of the way to our target in the specified time
            var positionLerpPct = 1f - Mathf.Exp((Mathf.Log(1f - 0.99f) / positionLerpTime) * Time.unscaledDeltaTime);
            var rotationLerpPct = 1f - Mathf.Exp((Mathf.Log(1f - 0.99f) / rotationLerpTime) * Time.unscaledDeltaTime);
            m_InterpolatingCameraState.LerpTowards(m_TargetCameraState, positionLerpPct, rotationLerpPct);

            m_InterpolatingCameraState.UpdateTransform(transform);
        }
Exemplo n.º 30
0
        void Update()
        {
            // Exit Sample
            if (Input.GetKey(KeyCode.Escape))
            {
                Application.Quit();
                                #if UNITY_EDITOR
                //UnityEditor.EditorApplication.isPlaying = false;
                                #endif
            }

            // Rotation
            var mouseMovement = new Vector2(Input.GetAxis("Mouse X"), Input.GetAxis("Mouse Y") * (invertY ? 1 : -1));

            var mouseSensitivityFactor = mouseSensitivityCurve.Evaluate(mouseMovement.magnitude);

            m_TargetCameraState.yaw   += mouseMovement.x * mouseSensitivityFactor;
            m_TargetCameraState.pitch += mouseMovement.y * mouseSensitivityFactor;


            // Translation
            //var translation = GetInputTranslationDirection() * Time.deltaTime;

            // Modify movement by a boost factor (defined in Inspector and modified in play mode through the mouse scroll wheel)

            /*boost += Input.mouseScrollDelta.y * 0.2f;
             * translation *= Mathf.Pow(2.0f, boost);
             *
             * m_TargetCameraState.Translate(translation);*/

            // Framerate-independent interpolation
            // Calculate the lerp amount, such that we get 99% of the way to our target in the specified time
            var positionLerpPct = 1f - Mathf.Exp((Mathf.Log(1f - 0.99f) / positionLerpTime) * Time.deltaTime);
            var rotationLerpPct = 1f - Mathf.Exp((Mathf.Log(1f - 0.99f) / rotationLerpTime) * Time.deltaTime);
            m_InterpolatingCameraState.LerpTowards(m_TargetCameraState, positionLerpPct, rotationLerpPct);

            m_InterpolatingCameraState.UpdateTransform(transform);
        }