Example #1
0
        public void SetHolographicSpace(HolographicSpace holographicSpace)
        {
            this.holographicSpace = holographicSpace;

            //
            // TODO: Add code here to initialize your content.
            //

#if DRAW_SAMPLE_CONTENT
            // Initialize the sample hologram.
            spinningCubeRenderer = new SpinningCubeRenderer(deviceResources);

            spatialInputHandler = new SpatialInputHandler();
#endif

            // Use the default SpatialLocator to track the motion of the device.
            locator = SpatialLocator.GetDefault();

            // Be able to respond to changes in the positional tracking state.
            locator.LocatabilityChanged += this.OnLocatabilityChanged;

            // Respond to camera added events by creating any resources that are specific
            // to that camera, such as the back buffer render target view.
            // When we add an event handler for CameraAdded, the API layer will avoid putting
            // the new camera in new HolographicFrames until we complete the deferral we created
            // for that handler, or return from the handler without creating a deferral. This
            // allows the app to take more than one frame to finish creating resources and
            // loading assets for the new holographic camera.
            // This function should be registered before the app creates any HolographicFrames.
            holographicSpace.CameraAdded += this.OnCameraAdded;

            // Respond to camera removed events by releasing resources that were created for that
            // camera.
            // When the app receives a CameraRemoved event, it releases all references to the back
            // buffer right away. This includes render target views, Direct2D target bitmaps, and so on.
            // The app must also ensure that the back buffer is not attached as a render target, as
            // shown in DeviceResources.ReleaseResourcesForBackBuffer.
            holographicSpace.CameraRemoved += this.OnCameraRemoved;

            // The simplest way to render world-locked holograms is to create a stationary reference frame
            // when the app is launched. This is roughly analogous to creating a "world" coordinate system
            // with the origin placed at the device's position as the app is launched.
            referenceFrame = locator.CreateStationaryFrameOfReferenceAtCurrentLocation();

            // Notes on spatial tracking APIs:
            // * Stationary reference frames are designed to provide a best-fit position relative to the
            //   overall space. Individual positions within that reference frame are allowed to drift slightly
            //   as the device learns more about the environment.
            // * When precise placement of individual holograms is required, a SpatialAnchor should be used to
            //   anchor the individual hologram to a position in the real world - for example, a point the user
            //   indicates to be of special interest. Anchor positions do not drift, but can be corrected; the
            //   anchor will use the corrected position starting in the next frame after the correction has
            //   occurred.
        }
    private void SetHolographicSpace()
    {
        // from Holographic Face Tracking Example
        // Use the default SpatialLocator to track the motion of the device.
        m_locator = SpatialLocator.GetDefault();

        // The simplest way to render world-locked holograms is to create a stationary reference frame
        // when the app is launched. This is roughly analogous to creating a "world" coordinate system
        // with the origin placed at the device's position as the app is launched.
        m_referenceFrame = m_locator.CreateStationaryFrameOfReferenceAtCurrentLocation();
    }
Example #3
0
        async void LoadAssets(string[] pakFiles)
        {
            ReferenceFrame = SpatialLocator.GetDefault().CreateStationaryFrameOfReferenceAtCurrentLocation();
            foreach (var assetName in pakFiles)
            {
                if (!string.IsNullOrEmpty(assetName) && await ApplicationData.Current.LocalFolder.TryGetItemAsync(assetName) == null)
                {
                    var file = await StorageFile.GetFileFromApplicationUriAsync(new Uri("ms-appx:///" + assetName));

                    var folder = ApplicationData.Current.LocalFolder;
                    await file.CopyAsync(folder);
                }
            }
            await CopyEmbeddedResourceToLocalFolder("Urho.CoreData.pak", "CoreData.pak");

            assetsLoaded = true;
        }
        public GestureController()
        {
            spatialLocator = SpatialLocator.GetDefault();

            gestureRecognizer = new SpatialGestureRecognizer(
                SpatialGestureSettings.Tap |
                SpatialGestureSettings.ManipulationTranslate);

            gestureRecognizer.ManipulationCanceled  += OnManipulationCanceled;
            gestureRecognizer.ManipulationCompleted += OnManipulationCompleted;
            gestureRecognizer.ManipulationStarted   += OnManipulationStarted;
            gestureRecognizer.ManipulationUpdated   += OnManipulationUpdated;
            gestureRecognizer.Tapped += OnTapped;

            interactionManager = SpatialInteractionManager.GetForCurrentView();
            interactionManager.InteractionDetected += OnInteractionDetected;
        }
Example #5
0
        void OnHolographicDisplayIsAvailableChanged(Object o, Object args)
        {
            // Get the spatial locator for the default HolographicDisplay, if one is available.
            SpatialLocator spatialLocator = null;

            if (canGetDefaultHolographicDisplay)
            {
                HolographicDisplay defaultHolographicDisplay = HolographicDisplay.GetDefault();
                if (defaultHolographicDisplay != null)
                {
                    spatialLocator = defaultHolographicDisplay.SpatialLocator;
                }
            }
            else
            {
                spatialLocator = SpatialLocator.GetDefault();
            }

            if (this.spatialLocator != spatialLocator)
            {
                // If the spatial locator is disconnected or replaced, we should discard any state that was
                // based on it.
                if (this.spatialLocator != null)
                {
                    this.spatialLocator.LocatabilityChanged -= this.OnLocatabilityChanged;
                    this.spatialLocator = null;
                }

                this.stationaryReferenceFrame = null;

                if (spatialLocator != null)
                {
                    // Use the SpatialLocator from the default HolographicDisplay to track the motion of the device.
                    this.spatialLocator = spatialLocator;

                    // Respond to changes in the positional tracking state.
                    this.spatialLocator.LocatabilityChanged += this.OnLocatabilityChanged;

                    // The simplest way to render world-locked holograms is to create a stationary reference frame
                    // based on a SpatialLocator. This is roughly analogous to creating a "world" coordinate system
                    // with the origin placed at the device's position as the app is launched.
                    this.stationaryReferenceFrame = this.spatialLocator.CreateStationaryFrameOfReferenceAtCurrentLocation();
                }
            }
        }
Example #6
0
    //   int reconstructionID = 0;

    // initialization
    void Start()
    {
        locator = SpatialLocator.GetDefault();
        originFrameOfReference = locator.CreateStationaryFrameOfReferenceAtCurrentLocation();
        audioData         = GetComponent <AudioSource>();
        startHeadPosition = Camera.main.transform.position;
        newHeadPosition   = startHeadPosition;
        textMesh.text     = photoCount.ToString();

        Debug.Log("Airtap to start/stop capture");

        //CreateScene("Test");

        CreateFolder();

        gr              = new GestureRecognizer();
        gr.TappedEvent += Tap;
        gr.StartCapturingGestures();
    }
Example #7
0
        /// <summary>
        /// Set holographic space
        /// </summary>
        /// <param name="holographicSpace">The holographic space</param>
        public void SetHolographicSpace(HolographicSpace holographicSpace)
        {
            // The DeviceResources class uses the preferred DXGI adapter ID from the holographic
            // space (when available) to create a Direct3D device. The HolographicSpace
            // uses this ID3D11Device to create and manage device-based resources such as
            // swap chains.
            this.deviceResources.SetHolographicSpace(holographicSpace);

            this.holographicSpace = holographicSpace;

            // Use the default SpatialLocator to track the motion of the device.
            this.locator = SpatialLocator.GetDefault();

            // Be able to respond to changes in the positional tracking state.
            this.locator.LocatabilityChanged += this.OnLocatabilityChanged;

            // Respond to camera added events by creating any resources that are specific
            // to that camera, such as the back buffer render target view.
            // When we add an event handler for CameraAdded, the API layer will avoid putting
            // the new camera in new HolographicFrames until we complete the deferral we created
            // for that handler, or return from the handler without creating a deferral. This
            // allows the app to take more than one frame to finish creating resources and
            // loading assets for the new holographic camera.
            // This function should be registered before the app creates any HolographicFrames.
            holographicSpace.CameraAdded += this.OnCameraAdded;

            // Respond to camera removed events by releasing resources that were created for that
            // camera.
            // When the app receives a CameraRemoved event, it releases all references to the back
            // buffer right away. This includes render target views, Direct2D target bitmaps, and so on.
            // The app must also ensure that the back buffer is not attached as a render target, as
            // shown in DeviceResources.ReleaseResourcesForBackBuffer.
            holographicSpace.CameraRemoved += this.OnCameraRemoved;

            // The simplest way to render world-locked holograms is to create a stationary reference frame
            // when the app is launched. This is roughly analogous to creating a "world" coordinate system
            // with the origin placed at the device's position as the app is launched.
            this.ReferenceFrame = this.locator.CreateStationaryFrameOfReferenceAtCurrentLocation();
        }
Example #8
0
        private bool InitializeUWP()
        {
            // Ask or check for Spatial permissions
            SpatialSurfaceObserver.RequestAccessAsync().Completed = (i, s) => {
                if (s == AsyncStatus.Completed && i.GetResults() == SpatialPerceptionAccessStatus.Allowed)
                {
                    observer = new SpatialSurfaceObserver();
                    observer.ObservedSurfacesChanged += OnSurfaceUpdate;
                    UpdateBounds(center, radius);
                }
            };

            // Establish the coordinate frame of reference
            var locator = SpatialLocator.GetDefault();

            if (locator != null)
            {
                locator.LocatabilityChanged += OnLocated;
                OnLocated(locator, null);
            }
            return(true);
        }
Example #9
0
        /// <summary>
        /// Initializes a new instance of the <see cref="SeeingSharpHolographicsSpacePainter"/> class.
        /// </summary>
        /// <param name="targetWindow">The target window into which to render.</param>
        public SeeingSharpHolographicsSpacePainter(CoreWindow targetWindow)
        {
            m_targetWindow = targetWindow;

            // Call generic initialization
            //  (choose device, create holographic space)
            InitializeHolographicSpace(targetWindow);

            // Use the default SpatialLocator to track the motion of the device.
            m_spatialLocator = SpatialLocator.GetDefault();

            // Be able to respond to changes in the positional tracking state.
            m_spatialLocator.LocatabilityChanged += this.OnSpatialLocator_LocatabilityChanged;

            // Respond to camera added events by creating any resources that are specific
            // to that camera, such as the back buffer render target view.
            // When we add an event handler for CameraAdded, the API layer will avoid putting
            // the new camera in new HolographicFrames until we complete the deferral we created
            // for that handler, or return from the handler without creating a deferral. This
            // allows the app to take more than one frame to finish creating resources and
            // loading assets for the new holographic camera.
            // This function should be registered before the app creates any HolographicFrames.
            m_holoSpace.CameraAdded += this.OnHoloSpace_CameraAdded;

            // Respond to camera removed events by releasing resources that were created for that
            // camera.
            // When the app receives a CameraRemoved event, it releases all references to the back
            // buffer right away. This includes render target views, Direct2D target bitmaps, and so on.
            // The app must also ensure that the back buffer is not attached as a render target, as
            // shown in DeviceResources.ReleaseResourcesForBackBuffer.
            m_holoSpace.CameraRemoved += this.OnHoloSpace_CameraRemoved;

            // The simplest way to render world-locked holograms is to create a stationary reference frame
            // when the app is launched. This is roughly analogous to creating a "world" coordinate system
            // with the origin placed at the device's position as the app is launched.
            m_referenceFrame = m_spatialLocator.CreateStationaryFrameOfReferenceAtCurrentLocation();
        }
Example #10
0
        public unsafe void Run()
        {
            AppStarting?.Invoke();
            ReferenceFrame = SpatialLocator.GetDefault().CreateStationaryFrameOfReferenceAtCurrentLocation();

            var coreWindow = CoreWindow.GetForCurrentThread();

            coreWindow.CustomProperties.Add(nameof(HolographicSpace), HolographicSpace);

            InitializeSpace();
            InteractionManager = SpatialInteractionManager.GetForCurrentView();
            InteractionManager.InteractionDetected += (s, e) => GesturesManager?.HandleInteraction(e.Interaction);

            while (!windowClosed)
            {
                if (!appInited)
                {
                    SpatialMappingManager = new SpatialMappingManager();
                    VoiceManager          = new VoiceManager();
                    appInited             = true;

                    if (options == null)
                    {
                        options = new ApplicationOptions();
                    }

                    //override some options:
                    options.LimitFps = false;
                    options.Width    = 1268;                  //TODO: find system
                    options.Height   = 720;

                    Game = (HoloApplication)Activator.CreateInstance(holoAppType, options);
                    Game.Run();
                    GesturesManager = new GesturesManager(Game, ReferenceFrame);
                    AppStarted?.Invoke(Game);
                }

                if (windowVisible && (null != HolographicSpace))
                {
                    if (Game != null)
                    {
                        CurrentFrame = HolographicSpace.CreateNextFrame();
                        CurrentFrame.UpdateCurrentPrediction();
                        var prediction = CurrentFrame.CurrentPrediction;
                        if (prediction.CameraPoses.Count < 1)
                        {
                            continue;
                        }
                        var cameraPose = prediction.CameraPoses[0];

                        var viewBox = cameraPose.TryGetViewTransform(ReferenceFrame.CoordinateSystem);
                        if (viewBox != null)
                        {
                            Matrix4x4 leftViewMatrixDx  = viewBox.Value.Left;
                            Matrix4x4 rightViewMatrixDx = viewBox.Value.Right;
                            Matrix4x4 leftProjMatrixDx  = cameraPose.ProjectionTransform.Left;
                            Matrix4x4 rightProjMatrixDx = cameraPose.ProjectionTransform.Right;

                            Matrix4 leftViewMatrixUrho  = *(Matrix4 *)(void *)&leftViewMatrixDx;
                            Matrix4 rightViewMatrixUrho = *(Matrix4 *)(void *)&rightViewMatrixDx;
                            Matrix4 leftProjMatrixUrho  = *(Matrix4 *)(void *)&leftProjMatrixDx;
                            Matrix4 rightProjMatrixUrho = *(Matrix4 *)(void *)&rightProjMatrixDx;
                            Game.UpdateStereoView(leftViewMatrixUrho, rightViewMatrixUrho, leftProjMatrixUrho, rightProjMatrixUrho);
                        }

                        var parameters = CurrentFrame.GetRenderingParameters(cameraPose);
                        if (Game.FocusWorldPoint != Vector3.Zero)
                        {
                            parameters.SetFocusPoint(ReferenceFrame.CoordinateSystem,
                                                     new System.Numerics.Vector3(
                                                         Game.FocusWorldPoint.X,
                                                         Game.FocusWorldPoint.Y,
                                                         -Game.FocusWorldPoint.Z));                //LH->RH
                        }
                        Game.Engine.RunFrame();
                        CurrentFrame.PresentUsingCurrentPrediction(HolographicFramePresentWaitBehavior.WaitForFrameToFinish);
                    }
                    CoreWindow.GetForCurrentThread().Dispatcher.ProcessEvents(CoreProcessEventsOption.ProcessAllIfPresent);
                }
                else
                {
                    CoreWindow.GetForCurrentThread().Dispatcher.ProcessEvents(CoreProcessEventsOption.ProcessOneAndAllPending);
                }
            }
        }
Example #11
0
 public HoloLensCamera()
 {
     locator = SpatialLocator.GetDefault();
     originalFrameOfReference = locator.CreateStationaryFrameOfReferenceAtCurrentLocation();
 }
Example #12
0
        public unsafe void Run()
        {
            AppStarting?.Invoke();
            ReferenceFrame = SpatialLocator.GetDefault().CreateStationaryFrameOfReferenceAtCurrentLocation();

            var coreWindow = CoreWindow.GetForCurrentThread();

            coreWindow.CustomProperties.Add(nameof(HolographicSpace), HolographicSpace);

            InitializeSpace();
            HolographicSpace.CameraAdded += HolographicSpace_CameraAdded;
            InteractionManager            = SpatialInteractionManager.GetForCurrentView();
            if (InteractionManager != null)
            {
                InteractionManager.InteractionDetected += (s, e) => GesturesManager?.HandleInteraction(e.Interaction);
            }

            while (!windowClosed)
            {
                if (appInited && windowVisible && (null != HolographicSpace))
                {
                    if (Game != null)
                    {
                        CurrentFrame = HolographicSpace.CreateNextFrame();
                        CurrentFrame.UpdateCurrentPrediction();
                        var prediction = CurrentFrame.CurrentPrediction;
                        if (prediction.CameraPoses.Count < 1)
                        {
                            continue;
                        }
                        var cameraPose = prediction.CameraPoses[0];

                        var viewBox = cameraPose.TryGetViewTransform(ReferenceFrame.CoordinateSystem);
                        if (viewBox != null)
                        {
                            Matrix4x4 leftViewMatrixDx  = viewBox.Value.Left;
                            Matrix4x4 rightViewMatrixDx = viewBox.Value.Right;
                            Matrix4x4 leftProjMatrixDx  = cameraPose.ProjectionTransform.Left;
                            Matrix4x4 rightProjMatrixDx = cameraPose.ProjectionTransform.Right;

                            Matrix4 leftViewMatrixUrho  = *(Matrix4 *)(void *)&leftViewMatrixDx;
                            Matrix4 rightViewMatrixUrho = *(Matrix4 *)(void *)&rightViewMatrixDx;
                            Matrix4 leftProjMatrixUrho  = *(Matrix4 *)(void *)&leftProjMatrixDx;
                            Matrix4 rightProjMatrixUrho = *(Matrix4 *)(void *)&rightProjMatrixDx;
                            Game.UpdateStereoView(leftViewMatrixUrho, rightViewMatrixUrho, leftProjMatrixUrho, rightProjMatrixUrho);
                        }

                        var parameters = CurrentFrame.GetRenderingParameters(cameraPose);
                        if (Game.FocusWorldPoint != Vector3.Zero)
                        {
                            parameters.SetFocusPoint(ReferenceFrame.CoordinateSystem,
                                                     new System.Numerics.Vector3(
                                                         Game.FocusWorldPoint.X,
                                                         Game.FocusWorldPoint.Y,
                                                         -Game.FocusWorldPoint.Z));                //LH->RH
                        }
                        Game.Engine.RunFrame();
                        CurrentFrame.PresentUsingCurrentPrediction(HolographicFramePresentWaitBehavior.WaitForFrameToFinish);
                    }
                    CoreWindow.GetForCurrentThread().Dispatcher.ProcessEvents(CoreProcessEventsOption.ProcessAllIfPresent);
                }
                else
                {
                    CoreWindow.GetForCurrentThread().Dispatcher.ProcessEvents(CoreProcessEventsOption.ProcessOneAndAllPending);
                }
            }
        }
Example #13
0
        /// <summary>
        /// Initializes the world coordinate system for the application using a pre-defined spatial anchor,
        /// or creates it at a stationary frame of reference if it does not exist. Once initialized, the
        /// world coordinate system will be consistent across application sessions, unless the associated
        /// spatial anchor is modified or deleted.
        /// <param name="worldSpatialAnchor">A spatial anchor to use for the world (may be null).</param>
        /// <param name="regenerateDefaultWorldSpatialAnchorIfNeeded">Flag indicating whether to regenerate and persist default world spatial anchor if currently persisted anchor fails to localize in the current environment (default: false).</param>
        /// </summary>
        private static void InitializeWorldCoordinateSystem(SpatialAnchor worldSpatialAnchor, bool regenerateDefaultWorldSpatialAnchorIfNeeded)
        {
            SpatialAnchor TryCreateDefaultWorldSpatialAnchor(SpatialStationaryFrameOfReference world)
            {
                // Save the world spatial coordinate system
                WorldSpatialCoordinateSystem = world.CoordinateSystem;

                // Create a spatial anchor to represent the world origin and persist it to the spatial
                // anchor store to ensure that the origin remains coherent between sessions.
                return(SpatialAnchorHelper.TryCreateSpatialAnchor(DefaultWorldSpatialAnchorId, WorldSpatialCoordinateSystem));
            }

            // If no world anchor was given, try to load the default world spatial anchor if it was previously persisted
            worldSpatialAnchor ??= SpatialAnchorHelper.TryGetSpatialAnchor(DefaultWorldSpatialAnchorId);

            if (worldSpatialAnchor != null)
            {
                // Set the world spatial coordinate system using the spatial anchor
                WorldSpatialCoordinateSystem = worldSpatialAnchor.CoordinateSystem;
                if (regenerateDefaultWorldSpatialAnchorIfNeeded)
                {
                    var locator = SpatialLocator.GetDefault();
                    if (locator == null)
                    {
                        throw new Exception($"Could not get spatial locator.");
                    }

                    // determine whether we can localize in the current environment
                    var world   = locator.CreateStationaryFrameOfReferenceAtCurrentLocation();
                    var success = world.CoordinateSystem.TryGetTransformTo(WorldSpatialCoordinateSystem) != null;
                    if (!success)
                    {
                        SpatialAnchorHelper.RemoveSpatialAnchor(DefaultWorldSpatialAnchorId);
                        worldSpatialAnchor = TryCreateDefaultWorldSpatialAnchor(world);
                        if (worldSpatialAnchor == null)
                        {
                            throw new Exception("Could not create the persistent world spatial anchor.");
                        }
                    }
                }
            }
            else
            {
                // Generate and persist the default world spatial anchor
                var locator = SpatialLocator.GetDefault();

                if (locator != null)
                {
                    // This creates a stationary frame of reference which we will use as our world origin
                    var world = locator.CreateStationaryFrameOfReferenceAtCurrentLocation();
                    worldSpatialAnchor = TryCreateDefaultWorldSpatialAnchor(world);

                    if (worldSpatialAnchor == null)
                    {
                        System.Diagnostics.Trace.WriteLine($"WARNING: Could not create the persistent world spatial anchor.");
                    }
                }
                else
                {
                    System.Diagnostics.Trace.WriteLine($"WARNING: Could not get spatial locator (expected in StereoKit on desktop).");
                }
            }

            if (worldSpatialAnchor != null)
            {
                // At startup, we need to capture the pose of StereoKit with respect to the world anchor, and vice versa.
                // These transforms will allow us to convert world coordinates to/from StereoKit coordinates where needed:
                // on input from StereoKit -> \psi, and on output (rendering) \psi -> StereoKit

                // Query the pose of the world anchor. We use this pose for rendering correctly in the world,
                // and for transforming from world coordinates to StereoKit coordinates.
                StereoKitTransforms.WorldHierarchy   = World.FromPerceptionAnchor(worldSpatialAnchor).ToMatrix();
                StereoKitTransforms.WorldToStereoKit = StereoKitTransforms.WorldHierarchy.ToCoordinateSystem();

                // Inverting gives us a coordinate system that can be used for transforming from StereoKit to world coordinates.
                StereoKitTransforms.StereoKitToWorld = StereoKitTransforms.WorldToStereoKit.Invert();

                System.Diagnostics.Trace.WriteLine($"StereoKit origin: {StereoKitTransforms.StereoKitToWorld.Origin.X},{StereoKitTransforms.StereoKitToWorld.Origin.Y},{StereoKitTransforms.StereoKitToWorld.Origin.Z}");

                // TODO: It would be nice if we could actually just shift the origin coordinate system in StereoKit
                // to the pose currently defined in StereoKitTransforms.WorldPose.
                // There's currently an open issue for this: https://github.com/maluoi/StereoKit/issues/189

                // Simply setting the renderer camera root does not work, as its transform appears to be applied in the wrong order.
                // E.g., if the starting StereoKit pose is at a yaw rotation of 180 degrees, we would want to apply that transform
                // first, then apply the transform of the headset pose (perhaps pitching up). Instead, it appears that the headset
                // pose is applied first (e.g., pitching up), and *then* the Renderer.CameraRoot transform is applied (yaw of 180 degrees)
                // which in this example manifests as the pitch going down, opposite of what we desired.
                ////Renderer.CameraRoot = stereoKitTransform.Inverse;
            }
        }