示例#1
0
    // Update is called once per frame
    void Update()
    {
        if (RayFromCamera.ObjectLookAt() != null && teleport.CanTeleport)
        {
            //Debug.Log(Pose.GetLocalPosition(HandType).y + "  " + Pose.GetVelocity(HandType).y);
            GameObject obj = RayFromCamera.ObjectLookAt();
            //if (Pose.GetLocalPosition(HandType).y <= teleport.heightRequired &&
            //    (Pose.GetLastLocalPosition(HandType).y - Pose.GetLocalPosition(HandType).y) > 0 &&

            //    (Pose.GetLastVelocity(HandType).y - Pose.GetVelocity(HandType).y) > 0 &&
            //    Pose.GetVelocity(HandType).y <= teleport.speedRequired)

            //if((Pose.GetVelocity(HandType).y > 1 && Pose.GetLocalPosition(HandType).y > 0.1f) || Trigger.GetStateDown(SteamVR_Input_Sources.Any))



            if (Pose.GetLocalPosition(HandType).y <= teleport.heightRequired &&
                (Pose.GetLastLocalPosition(HandType).y - Pose.GetLocalPosition(HandType).y) > 0 &&
                (Pose.GetLastVelocity(HandType).y - Pose.GetVelocity(HandType).y) > 0 &&
                Pose.GetVelocity(HandType).y <= teleport.speedRequired)
            {
                teleport.Begin(obj);
                teleport.CanTeleport = false;
            }
        }

        //ShowTargetObject();
    }
    /// <summary>
    /// Checks the Tracker-Status and Updates the Position, Rotation and Velocity.
    /// </summary>
    protected override void UpdateTracker()
    {
        // Setting 'trackingOK' to false (In case we have an Error and return before the end of the method).
        trackingOK = false;
        // Check if OpenVR-System is found correctly.
        if (OpenVR.System == null)
        {
            Debug.LogError("<b>DHUI</b> | DroneTracking_Vive | OpenVR-System was not found.");
            return;
        }
        // If we didn't set the Action Pose.
        if (_VRTrackerActionPose == null)
        {
            // Check if there is an Active Action called "VRTracker".
            SteamVR_Action_Pose ap = SteamVR_Input.GetAction <SteamVR_Action_Pose>("VRTracker");
            if (ap.GetActive(SteamVR_Input_Sources.Any))
            {
                _VRTrackerActionPose = ap;
                droneTrackerIndex    = _VRTrackerActionPose.GetDeviceIndex(SteamVR_Input_Sources.Any);
            }
            else
            {
                Debug.LogError("<b>DHUI</b> | DroneTracking_Vive | No Active VR-Tracker was found.");
                return;
            }
        }

        // Copy Position and Rotation to the 'trackedTransform' and save the Velocity.
        // If 'trackTransformAsLocal' is true: Copy the real tracked pose to 'trackedTransform' as localPosition & localRotation
        if (trackTransformAsLocal)
        {
            trackedTransform.localPosition = _VRTrackerActionPose.GetLocalPosition(SteamVR_Input_Sources.Any) - trackerToDroneOffset_Position;
            trackedTransform.localRotation = _VRTrackerActionPose.GetLocalRotation(SteamVR_Input_Sources.Any) * Quaternion.Euler(trackerToDroneOffset_Rotation);
        }
        // If 'trackTransformAsLocal' is false (= default): Copy the real tracked pose to 'trackedTransform' as (global) position & rotation
        else
        {
            trackedTransform.position = _VRTrackerActionPose.GetLocalPosition(SteamVR_Input_Sources.Any) - trackerToDroneOffset_Position;
            trackedTransform.rotation = _VRTrackerActionPose.GetLocalRotation(SteamVR_Input_Sources.Any) * Quaternion.Euler(trackerToDroneOffset_Rotation);
        }

        velocity = _VRTrackerActionPose.GetVelocity(SteamVR_Input_Sources.Any);

        // Calculate the current pose for our device. [See https://github.com/ValveSoftware/openvr/wiki/IVRSystem::GetDeviceToAbsoluteTrackingPose]
        TrackedDevicePose_t[] trackedDevicePoses = new TrackedDevicePose_t[OpenVR.k_unMaxTrackedDeviceCount];
        OpenVR.System.GetDeviceToAbsoluteTrackingPose(ETrackingUniverseOrigin.TrackingUniverseStanding, 0.0f, trackedDevicePoses);
        TrackedDevicePose_t droneTrackedDevicePose = trackedDevicePoses[droneTrackerIndex];

        // If the 'TrackedDevicePose' of the drone is valid, connected and running ok, we can set the 'trackingOK' to true.
        if (droneTrackedDevicePose.bPoseIsValid && droneTrackedDevicePose.bDeviceIsConnected && droneTrackedDevicePose.eTrackingResult == ETrackingResult.Running_OK)
        {
            trackingOK = true;
        }
    }
示例#3
0
    // Update is called once per frame
    void Update()
    {
        if (trigger.GetStateDown(rightHand))
        {
            CreateLine();
        }

        if (trigger.GetState(rightHand))
        {
            Vector3 pos = pose.GetLocalPosition(rightHand);
            ++line.positionCount;
            line.SetPosition(line.positionCount - 1, pos);
        }
    }
示例#4
0
    // Update is called once per frame
    void Update()
    {
        if (trigger.GetStateDown(rightHand))
        {
            CreateLineObject();
        }

        if (trigger.GetState(rightHand))
        {
            Vector3 pos = /*transform.parent.position +*/ pose.GetLocalPosition(rightHand);
            // 라인의 노드 갯수 증가
            line.positionCount++;
            line.SetPosition(line.positionCount - 1, pos);
        }
    }
示例#5
0
 void Update()
 {
     //
     if (trigger.GetStateDown(rightHand))
     {
         CreateLineObject();
     }
     //
     if (trigger.GetState(rightHand))
     {
         Vector3 pos = pose.GetLocalPosition(rightHand);
         //라인의 노드 갯수 증가
         line.positionCount++;
         line.SetPosition(line.positionCount - 1, pos);
     }
 }
示例#6
0
 void Update()
 {
     Position                = pose.GetLocalPosition(inputSource);
     Stick.Value             = stick.GetAxis(inputSource);
     MainButtonPressed.Value = mainButton.GetState(inputSource);
     ModifierPressed.Value   = modifier.GetState(inputSource);
     CancellerPressed.Value  = canceller.GetState(inputSource);
 }
示例#7
0
    public bool IsControllerWorking()
    {
        Vector3 pos = position.GetLocalPosition(handType);

        if (pos == null || pos.Equals(Vector3.zero))
        {
            return(false);
        }
        return(true);
    }
示例#8
0
    private void SetMoveDirection()
    {
        Vector3 right = PoseRightFoot.GetLocalPosition(RightFoot);
        Vector3 left  = PoseLeftFoot.GetLocalPosition(LeftFoot);

        rightFoot = new Vector2(right.x, right.z);
        leftFoot  = new Vector2(left.x, left.z);

        footDirection = (rightFoot - leftFoot).normalized;
        moveDirection = footDirection;
    }
示例#9
0
    void CreateLineObject()
    {
        //"Line"이라는 게임오브젝트를 생성하여 LineRenderer컴포넌트를 추가한다.
        GameObject lineObject = new GameObject("Line");

        line    = lineObject.AddComponent <LineRenderer>();
        lineCol = lineObject.AddComponent <SphereCollider>();


        //번개효과 머티리얼 테스트중(박동건)///////////////////////////
        //Material newMat = GetComponent<LineRenderer>().material;
        //newMat.SetFloat("_StartSeed", Random.value * 1000);
        //GetComponent<LineRenderer>().material = newMat;
        ///////////////////////////////////////////////////////////////

        //라인렌더러에 연결할 머티리얼 생성
        Material mt = new Material(Shader.Find("Unlit/Color"));

        mt.color = lineColor;

        line.material      = mt;
        line.useWorldSpace = false;

        //라인의 끝부분을 부드럽게 하기위한 버텍스 갯수 설정
        line.numCapVertices = 20;

        //라인렌더러의 폭 설정
        line.widthMultiplier = 0.1f;
        line.startWidth      = lineWidth;
        line.endWidth        = lineWidth;

        //라인렌더러의 노드 갯수를 1로 설정
        line.positionCount = 1;

        //첫 번째 노드의 위치를 컨트롤러의 위치로 설정
        Vector3 position = pose.GetLocalPosition(rightHand);

        line.SetPosition(0, position);
    }
    // Update is called once per frame
    void Update()
    {
        Vector3    pos = Poser.GetLocalPosition(source);
        Quaternion rot = Poser.GetLocalRotation(source);

        // Move rocket when thrust is active
        float thrust = Engine_manager.g_ThrustLevel;

        if (thrust > 0.0f)
        {
            pos += (transform.localRotation * Vector3.forward) * 2.0f * thrust;
        }

        float rotSpeed = 0.6f;

        transform.localRotation = Quaternion.Slerp(transform.localRotation, rot, rotSpeed * Time.deltaTime);
        float movSpeed = 0.8f;

        transform.localPosition = Vector3.Slerp(transform.localPosition, pos, movSpeed * Time.deltaTime);
    }
    private void handlePose()
    {
        if (debugPoseMarkerStart != null && poseAction.GetActive(_controller))
        {
            Vector3 posePos = poseAction.GetLocalPosition(_controller);
            debugPoseMarkerStart.transform.localPosition = posePos;
            LineRenderer line = debugPoseMarkerStart.GetComponent <LineRenderer>();
            line.transform.position = debugPoseMarkerStart.transform.position;

            if (line != null)
            {
                line.SetPosition(0, debugPoseMarkerStart.transform.position);
                line.transform.localRotation = poseAction.GetLocalRotation(_controller);

                RaycastHit hit;
                // Shorten the default magnitude of the beam by 0.3
                Vector3 direction = poseAction.GetLocalRotation(_controller) * vectorFoward * 0.3f;
                Vector3 endPoint  = line.transform.position + direction * 10000;
                line.SetPosition(1, endPoint);
                debugPoseMarkerEnd.transform.position = endPoint;
                Ray ray = new Ray(line.transform.position, direction);
                if (Physics.Raycast(ray, out hit))
                {
                    //Debug.Log("Hit!");
                    debugPoseMarkerEnd.transform.position = hit.point;
                    line.SetPosition(1, hit.point);
                    handleHit(hit);
                }
                else
                {
                    //Debug.Log("Missed!");
                    //line.SetPosition(1, line.transform.position + direction * 10000);
                    //debugPoseMarkerEnd.transform.position = line.transform.position + direction * 10000;
                    handleMiss();
                }
            }
        }
    }
示例#12
0
 public Vector3 DifferenceLocalPosition()
 {
     return(pose.GetLocalPosition(handType) - pose.GetLastLocalPosition(handType));
 }
示例#13
0
    // Update is called once per frame
    void Update()
    {
        Vector3 tracker_position = trackerPose.GetLocalPosition(trackerSource);

        print(tracker_position);
    }
示例#14
0
    // Update is called once per frame
    void Update()
    {
        // Adapted from: http://3dcognition.com/unity-flight-simulator-phase-2/
        //   and http://wiki.unity3d.com/index.php/SmoothMouseLook

        if (ResetButton.GetState(SteamVR_Input_Sources.Any))
        {
            Reset();
        }

        float altitude = transform.position.magnitude;

        float rotateSpeed = 30.0f;                     // degrees/second
        float speed       = 0.5f * (altitude - 0.99f); // WASD movement, earth radius/second
        float mouseSpeed  = 140.0f;                    // degrees rotation per pixel of mouse movement / second

        float transAmount  = speed * Time.deltaTime;
        float rotateAmount = rotateSpeed * Time.deltaTime;

        // Update time zooming
        if (Input.GetKeyDown("."))
        {
            TimeControl.ui_timelapse *= 4.0f;
        }
        if (Input.GetKeyDown(","))
        {
            TimeControl.ui_timelapse /= 4.0f;
        }
        if (Input.GetKeyDown("/"))
        {
            TimeControl.ui_timelapse = 1.0f;
        }

        // Debug.Log("Orbital camera vive running");
        float zoom = TimeZoomAxis.GetAxis(TimeHand);

        if (zoom > 0.0f)
        {
            Debug.Log("  time axis active: " + zoom);
            TimeControl.ui_timelapse = 16.0f * Mathf.Pow(4.0f, 1.0f + 2.0f * zoom);
        }
        else
        {
            TimeControl.ui_timelapse = 1.0f;
        }
        TimeControl.Update();


        float rotX = 0.0f;
        float rotY = 0.0f;

        if (Input.GetMouseButton(0))
        {
            rotX += Input.GetAxis("Mouse X") * mouseSpeed * Time.deltaTime;
            rotY -= Input.GetAxis("Mouse Y") * mouseSpeed * Time.deltaTime;
        }
        if (Input.GetKey("up"))
        {
            rotY += rotateAmount;
        }
        if (Input.GetKey("down"))
        {
            rotY -= rotateAmount;
        }
        if (Input.GetKey("left"))
        {
            rotX -= rotateAmount;
        }
        if (Input.GetKey("right"))
        {
            rotX += rotateAmount;
        }

        Vector3 rocket      = new Vector3(0.0f, 0.0f, 0.0f);
        float   rocketAccel = 50.0f; // m/s^2 acceleration in vacuum

        if (Input.GetKey("a"))
        {
            rocket.x = -rocketAccel;
        }
        if (Input.GetKey("d"))
        {
            rocket.x = +rocketAccel;
        }

        if (Input.GetKey("z"))
        {
            rocket.y = -rocketAccel;
        }
        if (Input.GetKey("q"))
        {
            rocket.y = +rocketAccel;
        }

        if (Input.GetKey("s"))
        {
            rocket.z = -rocketAccel;
        }
        if (Input.GetKey("w"))
        {
            rocket.z = +rocketAccel;
        }

        // Rotate keyboard rocket thrust to match local motion frame
        rocket = rocket.x * transform.right + rocket.y * transform.up + rocket.z * transform.forward;


        float      thrust = RocketThrustAxis.GetAxis(RocketHand);
        Quaternion rot    = RocketPose.GetLocalRotation(RocketHand);

        rot = transform.rotation * rot; // local to world rotation
        Vector3 rocketForward = rot * Vector3.forward;

        if (thrust > 0.0f)
        {
            Debug.Log("  thrust axis active: " + thrust + "  direction " + rocketForward);
            rocket += thrust * rocketForward * rocketAccel; // FIXME: rotate to match controller orientation
            Engine_manager.g_ThrustLevel = thrust;
        }
        else
        {
            Engine_manager.g_ThrustLevel = 0.0f;
        }


        float   me    = 5.972e24f;                 // mass of Earth, in kilograms
        float   G     = 6.67408e-11f;              // gravitational constant, MKS units
        float   r     = P.magnitude;               // distance to spacecraft, in meters
        float   accel = -G * me / (r * r);         // scalar acceleration due to gravity (m/s^2)
        Vector3 A     = P * (accel / P.magnitude); // vector acceleration due to gravity

        A += rocket;                               // acceleration due to rocket
        float dt = Time.deltaTime * TimeControl.timelapse;

        V = V + dt * A;                            // Euler update for velocity
        P = P + dt * V;                            // Euler update for position

        float height  = (P.magnitude - Re) / (km); // kilometers altitude
        float airdrag = 0.0f;

        if (height < 60.0f)
        {
            float air_density = Mathf.Exp(-height / 8.0f);
            float dragfactor  = 0.01f + 0.2f * Vector3.Cross(rocketForward.normalized, V.normalized).magnitude;

            airdrag = dragfactor * air_density;
            float dragloss = (1.0f - airdrag * dt);
            if (dragloss < 0.5f)
            {
                dragloss = 0.5f;
            }
            V        = V * dragloss;
            airdrag *= V.magnitude;
        }

        float min_altitude = 1.00001f * Re; // stay outside of the planet

        if (P.magnitude < min_altitude)
        {
            P = P * (min_altitude / P.magnitude);
        }
        float max_altitude = 100.0f * Re; // stay fairly near the planet

        if (P.magnitude > max_altitude)
        {
            P = P * (max_altitude / P.magnitude);
            V = V * 0.001f;
        }

        // Bake output camera position
        Vector3 pos = P * (1.0f / km);// copy out simulated position to GUI position (in Earth radii)

        //pos.y-=1.8f; // make up for user height
        transform.position = pos;

        transform.Rotate(rotY, rotX, 0);

        // Update the text readout gizmo
        var TimeReadout = GameObject.FindWithTag("TimeReadout");

        if (TimeReadout)
        {
            TimeReadout.transform.localPosition = TimePose.GetLocalPosition(TimeHand);
            TimeReadout.transform.localRotation = TimePose.GetLocalRotation(TimeHand);
        }
        var TextReadout = GameObject.FindWithTag("TimeReadoutText");

        if (TextReadout)
        {
            float  alt = (P.magnitude - Re) / km;
            float  vel = V.magnitude / km;
            string pre = "";
            if (airdrag > 0.0)
            {
                pre = "Air drag: " + string.Format("{0:F1}", airdrag) + " m/s/s\n";
            }
            string text = pre +
                          "Time: x" + string.Format("{0:F1}", TimeControl.timelapse) + "\n" +
                          "Thrust: " + string.Format("{0:F0}", rocket.magnitude) + " m/s/s\n" +
                          "Speed: " + string.Format("{0:F2}", vel) + " km/s\n" +
                          "Vertical: " + string.Format("{0:F2}", Vector3.Dot(P.normalized, V) / km) + " km/s\n" +
                          "Altitude: " + (int)alt + " km";

            TextReadout.GetComponent <TextMesh>().text = text;
        }


        if (Input.GetKey("x") || Input.GetKey("escape"))
        {
            Application.Quit();
        }
    }
示例#15
0
    void FixedUpdate()
    {
        /*// Swing Climbing
         * if (leftHand.canSwingGrip && GetGrap(leftHand.hand)) {
         *  attachPlayer(leftHand.swing);
         *  leftHand.swing.GetComponent<Rigidbody>().useGravity = true;
         * }
         * else if (leftHand.canGrip && GetGrapUp(leftHand.hand, lastLeftGrap)) {
         *  detachPlayer(leftHand.swing);
         *  leftHand.swing.GetComponent<Rigidbody>().useGravity = false;
         * }*/

        // Normal Climbing
        // tests if a hand is still grabbed onto an object
        if (isGrappedLeft || isGrappedRight)
        {
            isGrapped = true;
        }
        else
        {
            isGrapped = false;
        }

        if (!isGrapped)
        {
            body.useGravity = true;
        }

        // LeftHand
        if (leftHand.canGrip && GetGrap(leftHand.hand))
        {
            // change to grab physics
            body.velocity   = Vector3.zero;
            body.useGravity = false;
            isGrappedLeft   = true;
            // calc grab position
            body.transform.position += (leftHand.previousPosition - handPosition.GetLocalPosition(leftHand.hand.handType));
        }
        else if (leftHand.canGrip && GetGrapUp(leftHand.hand, lastLeftGrap))
        {
            // change to normal physics
            body.useGravity = true;
            isGrappedLeft   = false;
            // calc fling velocity
            body.velocity = (leftHand.previousPosition - handPosition.GetLocalPosition(leftHand.hand.handType)) / Time.deltaTime;
        }
        else // has to be here because Hand can lose grap without letting go
        {
            isGrappedLeft = false;
        }

        // RightHand
        if (rightHand.canGrip && GetGrap(rightHand.hand))
        {
            // change to grab physics
            body.velocity   = Vector3.zero;
            body.useGravity = false;
            isGrappedRight  = true;
            // calc grab position
            body.transform.position += (rightHand.previousPosition - handPosition.GetLocalPosition(rightHand.hand.handType));
        }
        else if (rightHand.canGrip && GetGrapUp(rightHand.hand, lastRightGrap))
        {
            // change to normal physics
            body.useGravity = true;
            isGrappedRight  = false;
            // calc fling velocity
            body.velocity = (rightHand.previousPosition - handPosition.GetLocalPosition(rightHand.hand.handType)) / Time.deltaTime;
        }
        else // has to be here because Hand can lose grap without letting go
        {
            isGrappedRight = false;
        }

        // set last grap power
        lastLeftGrap  = grapAction.GetAxis(leftHand.hand.handType);
        lastRightGrap = grapAction.GetAxis(rightHand.hand.handType);

        // set previous position
        leftHand.previousPosition  = handPosition.GetLocalPosition(leftHand.hand.handType);
        rightHand.previousPosition = handPosition.GetLocalPosition(rightHand.hand.handType);
    }
示例#16
0
 private void OnPoseChanged(SteamVR_Action_Pose actionIn, SteamVR_Input_Sources hand)
 {
     transform.position = actionIn.GetLocalPosition(hand);
     transform.rotation = actionIn.GetLocalRotation(hand);
 }
    // Update is called once per frame
    void FixedUpdate()
    {
        if (vehicle)
        {
            // Apply keyboard motor and steering controls
            throttle = throttleAction.GetAxis(throttleSource);
            brake    = brakeAction.GetAxis(brakeSource);
            vehicle.complementary_filter(0.1f, ref vehicle.cur_motor_power, throttle - brake);

            Vector3 headPos = headPoser.GetLocalPosition(headSource);
            localHead = headPos;
            Quaternion headRot = headPoser.GetLocalRotation(headSource);

            // Slightly bank the user's head during turns,
            //   so the real gravity vector lines up with apparent acceleration.
            // Disadvantage: mismatch in user's roll gyros.
            vehicle.complementary_filter(0.1f, ref bank, vehicle.centripital);
            if (BankingTurns)   // Apply the turn
            // Reset full transform
            {
                BankingTurns.transform.localRotation = Quaternion.Euler(0.0f, 0.0f, 0.0f);
                BankingTurns.transform.localPosition = new Vector3(0.0f, 0.0f, 0.0f);
                // Rotate around the user's head position
                worldHead = BankingTurns.transform.TransformPoint(headPos);
                Vector3 axis = BankingTurns.transform.forward; // vehicle.last_velocity;
                axis.y = 0.0f;
                BankingTurns.transform.RotateAround(worldHead, axis, -30.0f * bank);
            }

            Vector3    framePos = framePoser.GetLocalPosition(frameSource);
            Quaternion frameRot = framePoser.GetLocalRotation(frameSource);

            if (VRAreaOffset && !setupVRArea && framePos.x != 0.0f)
            {
                // Locate VR camera relative to the physical frame:
                //   SteamVR does wacky things with the initial camera position,
                //   putting 0,0,0 as the center of the Steam VR room area.
                VRAreaOffset.transform.localPosition = new Vector3(-framePos.x, -framePos.y + 1.05f - 0.4f, -framePos.z + 0.7f);
                setupVRArea = true;
            }

            // Plant rollcage relative to the physical frame
            rollcage.transform.localPosition   = framePos + new Vector3(0.0f, -0.5f, -1.0f);
            rollcage.transform.localRotation   = frameRot * Quaternion.Euler(-60.0f, 180.0f, 0.0f);
            handlebars.transform.localPosition = framePos + new Vector3(0.0f, -0.2f, -0.10f);

            Vector3    steerPos = steerPoser.GetLocalPosition(steerSource);
            Quaternion steerRot = steerPoser.GetLocalRotation(steerSource);
            steerQuat = steerRot * Quaternion.Inverse(frameRot);

            float angle = 0.0f;
            steerQuat.ToAngleAxis(out angle, out steerAxis);
            if (Mathf.Abs(steerAxis.y) > 0.7f) // we're in a reasonable steering configuration
            {
                steer = angle;
                if (steerQuat.w > 0.0f)
                {
                    steer = -angle;
                }
                if (steer > 180.0f)
                {
                    steer -= 360.0f;             // rotation is around zero
                }
                steer  = -steer;
                steer -= 30.0f; // baked-in rotation offset (steering trim)
                vehicle.complementary_filter(0.1f, ref vehicle.cur_steer, steer / 45.0f);
                handlebars.transform.localRotation = frameRot * Quaternion.Euler(-90.0f, 180.0f, 0.0f) * Quaternion.Euler(0.0f, steer, 0.0f);
            }
        }
    }
示例#18
0
 // Update is called once per frame
 void Update()
 {
     transform.position = Pose.GetLocalPosition(SteamVR_Input_Sources.LeftHand);
 }