//-------------------------------------------------
        private void TeleportPlayer()
        {
            teleporting = false;

            VRTRIXGloveTeleport.PlayerPre.Send(pointedAtTeleportMarker);

            SteamVR_Fade.Start(Color.clear, currentFadeTime);

            VRTRIXGloveTelportPoint teleportPoint = teleportingToMarker as VRTRIXGloveTelportPoint;
            Vector3 teleportPosition = pointedAtPosition;

            Debug.Log("teleportPosition: " + teleportPosition);
            Debug.Log("teleportPoint: " + teleportPoint);
            if (teleportPoint != null)
            {
                teleportPosition = teleportPoint.transform.position;
                Debug.Log(teleportPosition);
                //Teleport to a new scene
                if (teleportPoint.teleportType == VRTRIXGloveTelportPoint.TeleportPointType.SwitchToNewScene)
                {
                    Debug.Log("SwitchToNewScene");
                    teleportPoint.TeleportToScene();
                    return;
                }
            }

            // Find the actual floor position below the navigation mesh
            VRTRIXGloveTelportArea teleportArea = teleportingToMarker as VRTRIXGloveTelportArea;

            if (teleportArea != null)
            {
                if (floorFixupMaximumTraceDistance > 0.0f)
                {
                    RaycastHit raycastHit;
                    if (Physics.Raycast(teleportPosition + 0.05f * Vector3.down, Vector3.down, out raycastHit, floorFixupMaximumTraceDistance, floorFixupTraceLayerMask))
                    {
                        teleportPosition = raycastHit.point;
                    }
                }
            }

            if (teleportingToMarker.ShouldMovePlayer())
            {
                Debug.Log("Moving Player");
                Vector3 playerFeetOffset = player.trackingOriginTransform.position - player.feetPositionGuess;
                Debug.Log("playerFeetOffset: " + playerFeetOffset);
                player.trackingOriginTransform.position = teleportPosition + playerFeetOffset;
                Debug.Log("trackingOriginTransform: " + player.trackingOriginTransform.position);
            }
            else
            {
                teleportingToMarker.TeleportPlayer(pointedAtPosition);
            }

            VRTRIXGloveTeleport.Player.Send(pointedAtTeleportMarker);
        }
예제 #2
0
 //-------------------------------------------------
 void OnEnable()
 {
     if (Selection.activeTransform != null)
     {
         VRTRIXGloveTelportArea teleportArea = Selection.activeTransform.GetComponent <VRTRIXGloveTelportArea>();
         if (teleportArea != null)
         {
             teleportArea.UpdateVisualsInEditor();
         }
     }
 }
        //-------------------------------------------------
        void FixedUpdate()
        {
            if (!visible)
            {
                return;
            }

            if (debugFloor)
            {
                //Debug floor
                VRTRIXGloveTelportArea teleportArea = pointedAtTeleportMarker as VRTRIXGloveTelportArea;
                if (teleportArea != null)
                {
                    if (floorFixupMaximumTraceDistance > 0.0f)
                    {
                        floorDebugSphere.gameObject.SetActive(true);
                        floorDebugLine.gameObject.SetActive(true);

                        RaycastHit raycastHit;
                        Vector3    traceDir = Vector3.down;
                        traceDir.x = 0.01f;
                        if (Physics.Raycast(pointedAtPosition + 0.05f * traceDir, traceDir, out raycastHit, floorFixupMaximumTraceDistance, floorFixupTraceLayerMask))
                        {
                            floorDebugSphere.transform.position = raycastHit.point;
                            floorDebugSphere.material.color     = Color.green;
#if (UNITY_5_4)
                            floorDebugLine.SetColors(Color.green, Color.green);
#else
                            floorDebugLine.startColor = Color.green;
                            floorDebugLine.endColor   = Color.green;
#endif
                            floorDebugLine.SetPosition(0, pointedAtPosition);
                            floorDebugLine.SetPosition(1, raycastHit.point);
                        }
                        else
                        {
                            Vector3 rayEnd = pointedAtPosition + (traceDir * floorFixupMaximumTraceDistance);
                            floorDebugSphere.transform.position = rayEnd;
                            floorDebugSphere.material.color     = Color.red;
#if (UNITY_5_4)
                            floorDebugLine.SetColors(Color.red, Color.red);
#else
                            floorDebugLine.startColor = Color.red;
                            floorDebugLine.endColor   = Color.red;
#endif
                            floorDebugLine.SetPosition(0, pointedAtPosition);
                            floorDebugLine.SetPosition(1, rayEnd);
                        }
                    }
                }
            }
        }
예제 #4
0
        //-------------------------------------------------
        public override void OnInspectorGUI()
        {
            DrawDefaultInspector();

            if (Selection.activeTransform != null)
            {
                VRTRIXGloveTelportArea teleportArea = Selection.activeTransform.GetComponent <VRTRIXGloveTelportArea>();
                if (GUI.changed && teleportArea != null)
                {
                    teleportArea.UpdateVisualsInEditor();
                }
            }
        }
        //-------------------------------------------------
        private void UpdatePointer()
        {
            Vector3 pointerStart = pointerStartTransform.position;
            Vector3 pointerEnd;
            Vector3 pointerDir          = -pointerStartTransform.right;
            bool    hitSomething        = false;
            bool    showPlayAreaPreview = false;
            Vector3 playerFeetOffset    = player.trackingOriginTransform.position - player.feetPositionGuess;

            Vector3 arcVelocity = pointerDir * arcDistance;

            VRTRIXTeleportMarkerBase hitTeleportMarker = null;

            //Check pointer angle
            float dotUp             = Vector3.Dot(pointerDir, Vector3.up);
            float dotForward        = Vector3.Dot(pointerDir, player.hmdTransform.forward);
            bool  pointerAtBadAngle = false;

            if ((dotForward > 0 && dotUp > 0.75f) || (dotForward < 0.0f && dotUp > 0.5f))
            {
                pointerAtBadAngle = true;
            }

            //Trace to see if the pointer hit anything
            RaycastHit hitInfo;

            teleportArc.SetArcData(pointerStart, arcVelocity, true, pointerAtBadAngle);
            if (teleportArc.DrawArc(out hitInfo))
            {
                hitSomething      = true;
                hitTeleportMarker = hitInfo.collider.GetComponentInParent <VRTRIXTeleportMarkerBase>();
            }

            if (pointerAtBadAngle)
            {
                hitTeleportMarker = null;
            }

            HighlightSelected(hitTeleportMarker);

            if (hitTeleportMarker != null) //Hit a teleport marker
            {
                if (hitTeleportMarker.locked)
                {
                    teleportArc.SetColor(pointerLockedColor);
#if (UNITY_5_4)
                    pointerLineRenderer.SetColors(pointerLockedColor, pointerLockedColor);
#else
                    pointerLineRenderer.startColor = pointerLockedColor;
                    pointerLineRenderer.endColor   = pointerLockedColor;
#endif
                    destinationReticleTransform.gameObject.SetActive(false);
                }
                else
                {
                    teleportArc.SetColor(pointerValidColor);
#if (UNITY_5_4)
                    pointerLineRenderer.SetColors(pointerValidColor, pointerValidColor);
#else
                    pointerLineRenderer.startColor = pointerValidColor;
                    pointerLineRenderer.endColor   = pointerValidColor;
#endif
                    destinationReticleTransform.gameObject.SetActive(hitTeleportMarker.showReticle);
                }

                offsetReticleTransform.gameObject.SetActive(true);

                invalidReticleTransform.gameObject.SetActive(false);
                Debug.Log("hitTeleportMarker: " + hitTeleportMarker);
                pointedAtTeleportMarker = hitTeleportMarker;
                pointedAtPosition       = hitInfo.point;

                if (showPlayAreaMarker)
                {
                    //Show the play area marker if this is a teleport area
                    VRTRIXGloveTelportArea teleportArea = pointedAtTeleportMarker as VRTRIXGloveTelportArea;
                    if (teleportArea != null && !teleportArea.locked && playAreaPreviewTransform != null)
                    {
                        Vector3 offsetToUse = playerFeetOffset;

                        //Adjust the actual offset to prevent the play area marker from moving too much
                        if (!movedFeetFarEnough)
                        {
                            float distanceFromStartingOffset = Vector3.Distance(playerFeetOffset, startingFeetOffset);
                            if (distanceFromStartingOffset < 0.1f)
                            {
                                offsetToUse = startingFeetOffset;
                            }
                            else if (distanceFromStartingOffset < 0.4f)
                            {
                                offsetToUse = Vector3.Lerp(startingFeetOffset, playerFeetOffset, (distanceFromStartingOffset - 0.1f) / 0.3f);
                            }
                            else
                            {
                                movedFeetFarEnough = true;
                            }
                        }

                        playAreaPreviewTransform.position = pointedAtPosition + offsetToUse;

                        showPlayAreaPreview = true;
                    }
                }

                pointerEnd = hitInfo.point;
            }
            else //Hit neither
            {
                destinationReticleTransform.gameObject.SetActive(false);
                offsetReticleTransform.gameObject.SetActive(false);

                teleportArc.SetColor(pointerInvalidColor);
#if (UNITY_5_4)
                pointerLineRenderer.SetColors(pointerInvalidColor, pointerInvalidColor);
#else
                pointerLineRenderer.startColor = pointerInvalidColor;
                pointerLineRenderer.endColor   = pointerInvalidColor;
#endif
                invalidReticleTransform.gameObject.SetActive(!pointerAtBadAngle);

                //Orient the invalid reticle to the normal of the trace hit point
                Vector3 normalToUse = hitInfo.normal;
                float   angle       = Vector3.Angle(hitInfo.normal, Vector3.up);
                if (angle < 15.0f)
                {
                    normalToUse = Vector3.up;
                }
                invalidReticleTargetRotation     = Quaternion.FromToRotation(Vector3.up, normalToUse);
                invalidReticleTransform.rotation = Quaternion.Slerp(invalidReticleTransform.rotation, invalidReticleTargetRotation, 0.1f);

                //Scale the invalid reticle based on the distance from the player
                float distanceFromPlayer         = Vector3.Distance(hitInfo.point, player.hmdTransform.position);
                float invalidReticleCurrentScale = Util.RemapNumberClamped(distanceFromPlayer, invalidReticleMinScaleDistance, invalidReticleMaxScaleDistance, invalidReticleMinScale, invalidReticleMaxScale);
                invalidReticleScale.x = invalidReticleCurrentScale;
                invalidReticleScale.y = invalidReticleCurrentScale;
                invalidReticleScale.z = invalidReticleCurrentScale;
                invalidReticleTransform.transform.localScale = invalidReticleScale;

                pointedAtTeleportMarker = null;

                if (hitSomething)
                {
                    pointerEnd = hitInfo.point;
                }
                else
                {
                    pointerEnd = teleportArc.GetArcPositionAtTime(teleportArc.arcDuration);
                }

                //Debug floor
                if (debugFloor)
                {
                    floorDebugSphere.gameObject.SetActive(false);
                    floorDebugLine.gameObject.SetActive(false);
                }
            }

            if (playAreaPreviewTransform != null)
            {
                playAreaPreviewTransform.gameObject.SetActive(showPlayAreaPreview);
            }

            if (!showOffsetReticle)
            {
                offsetReticleTransform.gameObject.SetActive(false);
            }

            destinationReticleTransform.position = pointedAtPosition;
            invalidReticleTransform.position     = pointerEnd;
            onActivateObjectTransform.position   = pointerEnd;
            onDeactivateObjectTransform.position = pointerEnd;
            offsetReticleTransform.position      = pointerEnd - playerFeetOffset;

            reticleAudioSource.transform.position = pointedAtPosition;

            pointerLineRenderer.SetPosition(0, pointerStart);
            pointerLineRenderer.SetPosition(1, pointerEnd);
        }