public void SetupCalibrationSequence(CalibrationProfile profile, TrackerReference trackers, MonoBehaviour mono)
        {
            this.profile  = profile;
            this.trackers = trackers;
            this.mono     = mono;

            // TMP:
            isFinished   = false;
            currentIndex = 0;
        }
Beispiel #2
0
        private void Start()
        {
            // Find references
            trackers = FindObjectOfType <TrackerReference>();

            // Initializing
            trackerVisuals          = new List <GameObject>();
            trackerOffsetVisuals    = new List <GameObject>();
            trackerDirectionVisuals = new List <GameObject[]>();
        }
        public virtual void Setup(CalibrationProfile profile, TrackerReference trackers, Action finishCallback = null)
        {
            if (calibrationEvents != null)
            {
                calibrationEvents.RaisePrepareCalibration();
            }

            this.profile        = profile;
            this.trackers       = trackers;
            this.finishCallback = finishCallback;
        }
Beispiel #4
0
        private void Start()
        {
            trackers = FindObjectOfType <TrackerReference>();

            filters = new Dictionary <VRTrackerType, TransformFilter>();
            foreach (VRTrackerType type in trackers.RequiredTrackers)
            {
                filters.Add(type, new TransformFilter(Vector3.zero, Quaternion.identity, updateFramerate, measurementNoise, measurementReliability));
            }

            update = StartCoroutine(UpdateCoroutine());
        }
        public override void Setup(CalibrationProfile profile, TrackerReference trackers, Action finishCallback = null)
        {
            base.Setup(profile, trackers, finishCallback);

            arcArray = new Arc[settings.Length];

            for (var i = 0; i < settings.Length; i++)
            {
                arcArray[i] = settings[i].useParentTracker
                                                                  ? new Arc(trackers, settings[i].parentTracker)
                                                      : arcArray[i] = new Arc();
            }
        }
Beispiel #6
0
            public static Vector3 GetDirection(DirectionClosestTo settings, TrackerReference trackers, CalibrationProfile profile)
            {
                switch (settings.type)
                {
                case DirectionClosestType.SingleDirection:
                    return(Direction.GetDirection(settings.singleDirection, trackers, profile));

                case DirectionClosestType.Cross:
                    Vector3 crossDir1 = Direction.GetDirection(settings.crossDirection1, trackers, profile);
                    Vector3 crossDir2 = Direction.GetDirection(settings.crossDirection2, trackers, profile);
                    return(Vector3.Cross(crossDir1, crossDir2));

                default:
                    Debug.LogError("Implement your shit");
                    break;
                }

                return(Vector3.zero);
            }
Beispiel #7
0
            public static Vector3 GetDirection(Direction settings, TrackerReference trackers, CalibrationProfile profile)
            {
                switch (settings.type)
                {
                case DirectionType.WorldDirection:
                    return(settings.worldDirection);

                case DirectionType.TrackerDirection:
                    TransformValues?trackerFrom = trackers.GetTracker(settings.trackerFrom);
                    if (settings.trackerFromLocal)
                    {
                        if (profile.trackerOffsets.ContainsKey(settings.trackerFromLocalOffset) &&
                            profile.trackerOffsets[settings.trackerFromLocalOffset].position != null)
                        {
                            trackerFrom = trackers.GetTrackerWithOffset(settings.trackerFrom, profile.trackerOffsets[settings.trackerFromLocalOffset].Position, Quaternion.identity);
                        }
                    }

                    TransformValues?trackerTo = trackers.GetTracker(settings.trackerTo);
                    if (settings.trackerToLocal)
                    {
                        if (profile.trackerOffsets.ContainsKey(settings.trackerToLocalOffset) &&
                            profile.trackerOffsets[settings.trackerToLocalOffset].position != null)
                        {
                            trackerTo = trackers.GetTrackerWithOffset(settings.trackerTo, profile.trackerOffsets[settings.trackerToLocalOffset].Position, Quaternion.identity);
                        }
                    }

                    if (trackerFrom == null || trackerTo == null)
                    {
                        Debug.LogError("Not all trackers are connected");
                        break;
                    }

                    return(trackerTo.Value.position - trackerFrom.Value.position);
                }

                return(Vector3.zero);
            }
            public static Vector3 GetPoint(Point settings, TrackerReference trackers, CalibrationProfile profile)
            {
                switch (settings.type)
                {
                case PointType.Tracker:

                    TransformValues?trackerTransform = trackers.GetTracker(settings.tracker);

                    if (settings.useTrackerLocal)
                    {
                        if (!profile.trackerOffsets.ContainsKey(settings.trackerOffset) ||
                            profile.trackerOffsets[settings.trackerOffset].position == null)
                        {
                            break;
                        }

                        trackerTransform = trackers.GetTrackerWithOffset(settings.tracker, profile.trackerOffsets[settings.trackerOffset].Position, Quaternion.identity);
                    }

                    if (trackerTransform == null)
                    {
                        break;
                    }

                    return(trackerTransform.Value.position);

                    break;

                default:
                    Debug.LogError("Not Implemented");
                    break;
                }

                Debug.LogError("Something went wrong here");

                return(Vector3.zero);
            }
Beispiel #9
0
 public Arc(TrackerReference trackers, VRTrackerType parentTrackerType)         // TODO: add local offset
 {
     this.arcPoints     = new List <ArcPoint>();
     this.trackers      = trackers;
     this.parentTracker = parentTrackerType;
 }
Beispiel #10
0
 public Arc()
 {
     this.arcPoints = new List <ArcPoint>();
     this.trackers  = null;
 }
Beispiel #11
0
            public static bool CheckIfDirectionShouldBeInverted(DirectionClosestTo settings, TrackerReference trackers, CalibrationProfile profile, Vector3 worldDirection)
            {
                switch (settings.type)
                {
                case DirectionClosestType.SingleDirection:
                    Vector3 dir = Direction.GetDirection(settings.singleDirection, trackers, profile);

                    if (Vector3.Distance(dir, worldDirection) > Vector3.Distance(dir, worldDirection * -1))
                    {
                        return(true);
                    }

                    break;

                case DirectionClosestType.Cross:

                    Vector3 crossDir1 = Direction.GetDirection(settings.crossDirection1, trackers, profile);
                    Vector3 crossDir2 = Direction.GetDirection(settings.crossDirection2, trackers, profile);
                    Vector3 cross     = Vector3.Cross(crossDir1, crossDir2);

                    if (Vector3.Distance(cross, worldDirection) > Vector3.Distance(cross, worldDirection * -1))
                    {
                        return(true);
                    }

                    break;

                default:
                    Debug.LogError("Implement your shit");
                    break;
                }

                return(false);
            }
 private void Awake()
 {
     trackers         = FindObjectOfType <TrackerReference>();
     controllerEvents = GetComponent <CalibrationControllerEventListener>();
 }