Exemple #1
0
        public override void UpdateComponent()
        {
            status = Status.Tracking;
            if (OculusDevice.status == Status.Unavailable)
            {
                status = Status.Unavailable;
            }

            Sensor.ID sensorID = isLeft ? Sensor.ID.LeftHand : Sensor.ID.RightHand;

            if (OculusDevice.GetRotationalConfidence(sensorID) == 0)
            {
                status = Status.Present;
            }

            if (status == Status.Present || status == Status.Unavailable)
            {
                positionConfidence = 0;
                rotationConfidence = 0;
                gameObject.SetActive(false);
                return;
            }

            Vector3    localSensorPosition = Target.ToVector3(OculusDevice.GetPosition(sensorID));
            Quaternion localSensorRotation = Target.ToQuaternion(OculusDevice.GetRotation(sensorID));

            transform.position = trackerTransform.TransformPoint(localSensorPosition);
            transform.rotation = trackerTransform.rotation * localSensorRotation;

            positionConfidence = OculusDevice.GetPositionalConfidence(sensorID);
            rotationConfidence = OculusDevice.GetRotationalConfidence(sensorID);
            gameObject.SetActive(true);

            UpdateInput(sensorID);
        }
        public static float GetPositionalConfidence(Sensor.ID sensorID)
        {
            if (sensorStates == null)
            {
                return(0);
            }

            return((ovrp_GetNodePositionTracked(sensorStates[(int)sensorID].sensorID) == Bool.True) ? 0.99F : 0);
        }
        public static Rotation GetRotation(Sensor.ID sensorID)
        {
            if (sensorStates == null)
            {
                return(Rotation.identity);
            }

            return(sensorStates[(int)sensorID].rotation);
        }
        public static Vector GetPosition(Sensor.ID sensorID)
        {
            if (sensorStates == null)
            {
                return(Vector.zero);
            }

            return(sensorStates[(int)sensorID].position);
        }
        public static bool IsPresent(Sensor.ID sensorID)
        {
            if (sensorStates == null)
            {
                return(false);
            }

            return(sensorStates[(int)sensorID].present);
        }
        public static float GetRotationalConfidence(Sensor.ID sensorID)
        {
            if (sensorStates == null)
            {
                return(0);
            }

            if (ovrp_GetNodePositionTracked(sensorStates[(int)sensorID].sensorID) == Bool.True)
            {
                return(sensorStates[(int)sensorID].confidence);
            }
            else
            {
                return(sensorStates[(int)sensorID].confidence * 0.9F); // without positional tracking, there is no drift correction
            }
        }
Exemple #7
0
        private void UpdateInput(Sensor.ID sensorID)
        {
            switch (sensorID)
            {
            case Sensor.ID.LeftHand:
                UpdateLeftInput();
                return;

            case Sensor.ID.RightHand:
                UpdateRightInput();
                return;

            default:
                return;
            }
        }
        public static void GetControllerInput(Sensor.ID sensorID, ref ControllerButtons input)
        {
            Controller controllerMask;

            switch (sensorID)
            {
            case Sensor.ID.LeftHand:
#if UNITY_ANDROID
                controllerMask = Controller.LTrackedRemote;
#else
                controllerMask = Controller.LTouch;
#endif
                break;

            case Sensor.ID.RightHand:
#if UNITY_ANDROID
                controllerMask = Controller.RTrackedRemote;
#else
                controllerMask = Controller.RTouch;
#endif
                break;

            default:
                return;
            }
            bool isLeft = (sensorID == Sensor.ID.LeftHand);

            ControllerState4 controllerState = GetControllerState(controllerMask);

            input.stickHorizontal = GetHorizontalStick(controllerState, isLeft);
            input.stickVertical   = GetVerticalStick(controllerState, isLeft);
            input.stickPress      = GetStickPress(controllerState);
            input.stickTouch      = GetStickTouch(controllerState);

            input.buttons[0] = GetButton1Press(controllerState);
            input.buttons[1] = GetButton2Press(controllerState);

            input.trigger1 = GetTrigger1(controllerState, isLeft);
            input.trigger2 = GetTrigger2(controllerState, isLeft);

            input.up    = (input.stickVertical > 0.3F);
            input.down  = (input.stickVertical < -0.3F);
            input.left  = (input.stickHorizontal < -0.3F);
            input.right = (input.stickHorizontal > 0.3F);
        }
        public static void Vibrate(Sensor.ID sensorID, float length, float strength)
        {
            Controller controllerMask;

            switch (sensorID)
            {
            case Sensor.ID.LeftHand:
                controllerMask = Controller.LTouch;
                break;

            case Sensor.ID.RightHand:
                controllerMask = Controller.RTouch;
                break;

            default:
                return;
            }
            ovrp_SetControllerVibration((uint)controllerMask, 0.5F, strength);
        }
        public static float GetConfidence(Sensor.ID sensorID)
        {
            Controller controller;

            if (sensorID == Sensor.ID.LeftHand)
            {
                controller = leftController;
            }
            else if (sensorID == Sensor.ID.RightHand)
            {
                controller = rightController;
            }
            else
            {
                return(0);
            }

            if (controller == null || controller.m_Docked)
            {
                return(0);
            }

            return(0.8F);
        }
        public Vector3 DetectCollision(Frame frame, bool mirrored, Sensor.ID mode, Vector3 pivot, float radius, out Collider collider)
        {
            if (mode == ID.Closest)
            {
                return(Utility.GetClosestPointOverlapSphere(pivot, radius, Mask, out collider));
            }

            if (mode == ID.RayTopDown)
            {
                RaycastHit info;
                bool       hit = Physics.Raycast(pivot + new Vector3(0f, radius, 0f), Vector3.down, out info, 2f * radius, Mask);
                if (hit)
                {
                    collider = info.collider;
                    return(info.point);
                }
            }

            if (mode == ID.RayCenterDown)
            {
                RaycastHit info;
                bool       hit = Physics.Raycast(pivot, Vector3.down, out info, radius, Mask);
                if (hit)
                {
                    collider = info.collider;
                    return(info.point);
                }
            }

            if (mode == ID.RayBottomUp)
            {
                RaycastHit info;
                bool       hit = Physics.Raycast(pivot - new Vector3(0f, radius, 0f), Vector3.up, out info, 2f * radius, Mask);
                if (hit)
                {
                    collider = info.collider;
                    return(info.point);
                }
            }

            if (mode == ID.RayCenterUp)
            {
                RaycastHit info;
                bool       hit = Physics.Raycast(pivot, Vector3.up, out info, radius, Mask);
                if (hit)
                {
                    collider = info.collider;
                    return(info.point);
                }
            }

            if (mode == ID.SphereTopDown)
            {
                RaycastHit info;
                bool       hit = Physics.SphereCast(pivot + new Vector3(0f, radius + Threshold, 0f), Threshold, Vector3.down, out info, 2f * radius, Mask);
                if (hit)
                {
                    collider = info.collider;
                    return(info.point);
                }
            }

            if (mode == ID.SphereCenterDown)
            {
                RaycastHit info;
                bool       hit = Physics.SphereCast(pivot + new Vector3(0f, radius, 0f), Threshold, Vector3.down, out info, radius, Mask);
                if (hit)
                {
                    collider = info.collider;
                    return(info.point);
                }
            }

            if (mode == ID.SphereBottomUp)
            {
                RaycastHit info;
                bool       hit = Physics.SphereCast(pivot - new Vector3(0f, radius + Threshold, 0f), Threshold, Vector3.up, out info, 2f * radius, Mask);
                if (hit)
                {
                    collider = info.collider;
                    return(info.point);
                }
            }

            if (mode == ID.SphereCenterUp)
            {
                RaycastHit info;
                bool       hit = Physics.SphereCast(pivot - new Vector3(0f, radius, 0f), Threshold, Vector3.up, out info, radius, Mask);
                if (hit)
                {
                    collider = info.collider;
                    return(info.point);
                }
            }

            if (mode == ID.RayXPositive)
            {
                Vector3    dir = frame.GetBoneTransformation(Bone, mirrored).GetRight();
                RaycastHit info;
                bool       hit = Physics.Raycast(pivot - radius * dir, dir, out info, 2f * radius, Mask);
                if (hit)
                {
                    collider = info.collider;
                    return(info.point);
                }
            }

            if (mode == ID.RayXNegative)
            {
                Vector3    dir = -frame.GetBoneTransformation(Bone, mirrored).GetRight();
                RaycastHit info;
                bool       hit = Physics.Raycast(pivot - radius * dir, dir, out info, 2f * radius, Mask);
                if (hit)
                {
                    collider = info.collider;
                    return(info.point);
                }
            }

            if (mode == ID.RayYPositive)
            {
                Vector3    dir = frame.GetBoneTransformation(Bone, mirrored).GetUp();
                RaycastHit info;
                bool       hit = Physics.Raycast(pivot - radius * dir, dir, out info, 2f * radius, Mask);
                if (hit)
                {
                    collider = info.collider;
                    return(info.point);
                }
            }

            if (mode == ID.RayYNegative)
            {
                Vector3    dir = -frame.GetBoneTransformation(Bone, mirrored).GetUp();
                RaycastHit info;
                bool       hit = Physics.Raycast(pivot - radius * dir, dir, out info, 2f * radius, Mask);
                if (hit)
                {
                    collider = info.collider;
                    return(info.point);
                }
            }

            if (mode == ID.RayZPositive)
            {
                Vector3    dir = frame.GetBoneTransformation(Bone, mirrored).GetForward();
                RaycastHit info;
                bool       hit = Physics.Raycast(pivot - radius * dir, dir, out info, 2f * radius, Mask);
                if (hit)
                {
                    collider = info.collider;
                    return(info.point);
                }
            }

            if (mode == ID.RayZNegative)
            {
                Vector3    dir = -frame.GetBoneTransformation(Bone, mirrored).GetForward();
                RaycastHit info;
                bool       hit = Physics.Raycast(pivot - radius * dir, dir, out info, 2f * radius, Mask);
                if (hit)
                {
                    collider = info.collider;
                    return(info.point);
                }
            }

            collider = null;
            return(pivot);
        }
    public Sensor AddSensor(string bone, Vector3 offset, float threshold, float tolerance, float velocity, Sensor.ID capture, Sensor.ID edit)
    {
        Sensor sensor = new Sensor(this, Data.Source.FindBone(bone).Index, offset, threshold, tolerance, velocity, capture, edit);

        ArrayExtensions.Add(ref Sensors, sensor);
        return(sensor);
    }
 public override void Start(HumanoidControl _humanoid, Transform targetTransform)
 {
     base.Start(_humanoid, targetTransform);
     sensorID        = handTarget.isLeft ? Sensor.ID.LeftHand : Sensor.ID.RightHand;
     controllerInput = Controllers.GetController(0);
 }