Added Spatial Texture Mapping Example

C++/HolographicSpatialMapping/README.md

@@ -0,0 +1,119 @@
+<!---
+  category: Holographic
+  samplefwlink: http://go.microsoft.com/fwlink/p/?LinkId=798591
+--->
+
+# Holographic spatial mapping sample
+
+This sample demonstrates how to acquire spatial mapping data from Windows Perception in
+real-time, and provides a simple example for consuming the spatial mapping data.
+
+Specifically, this sample requests spatial mapping updates for a space with rectangular extents
+20x20x5 meters from the device, and renders the data as a mesh in holographic space. You can choose
+one of the following two scenarios:
+
+- Render mesh data in wireframe, visualizing the spatial map in direct comparison to the real world
+- Render mesh data as a surface, visualizing the spatial map as an overlay on top of surfaces
+
+This sample uses the spatialPerception app capability, which allows the app to use spatial mapping
+data. To do this, the app registers the capability in the app manifest (which uses a schema
+extension), and then performs an in-app permissions request, which is automatically granted as a
+core feature on the Microsoft HoloLens.
+
+### Render mesh data in wireframe
+
+This is the default operational mode for the sample. Build the sample and deploy it to the
+Microsoft HoloLens emulator, or to a Microsoft HoloLens with developer mode enabled. Look around the
+room to map your space using the Windows.Perception.Spatial namespace.
+
+### Render mesh data as a surface
+
+This is an optional operational mode for the sample. Starting from wireframe mode, perform an air tap
+gesture. The visualization mode will change to render the spatial map as a set of 3D surfaces, using a
+simplified lighting algorithm.
+
+### Additional remarks
+
+**Note** The Windows universal samples for Windows 10 Holographic require Visual Studio 2015 Update 2
+to build, and a Windows Holographic device to execute. Windows Holographic devices include the
+Microsoft HoloLens and the Microsoft HoloLens Emulator.
+
+To obtain information about Windows 10 development, go to the [Windows Dev Center](http://go.microsoft.com/fwlink/?LinkID=532421).
+
+To obtain information about the tools used for Windows Holographic development, including
+Microsoft Visual Studio 2015 Update 2 and the Microsoft HoloLens Emulator, go to
+[Install the tools](https://developer.microsoft.com/windows/holographic/install_the_tools).
+
+## Reference
+
+The following are used to demonstrate spatial mapping in this code sample:
+
+* [Windows.Perception namespace]                   (https://msdn.microsoft.com/library/windows/apps/windows.perception.aspx)
+* [Windows.Perception.Spatial namespace]           (https://msdn.microsoft.com/library/windows/apps/windows.perception.spatial.aspx)
+  * [SpatialPerceptionAccessStatus enumeration]    (https://msdn.microsoft.com/library/windows/apps/windows.perception.spatial.spatialperceptionaccessstatus.aspx)
+* [Windows.Perception.Spatial.Surfaces]            (https://msdn.microsoft.com/library/windows/apps/windows.perception.spatial.surfaces.aspx)
+  * [SpatialSurfaceObserver class]                 (https://msdn.microsoft.com/library/windows/apps/windows.perception.spatial.surfaces.spatialsurfaceobserver.aspx)
+  * [SpatialSurfaceInfo class]                     (https://msdn.microsoft.com/library/windows/apps/windows.perception.spatial.surfaces.spatialsurfaceinfo.aspx)
+  * [SpatialSurfaceMeshOptions class]              (https://msdn.microsoft.com/library/windows/apps/windows.perception.spatial.surfaces.spatialsurfacemeshoptions.aspx)
+  * [SpatialSurfaceInfo.TryComputeLatestMeshAsync] (https://msdn.microsoft.com/library/windows/apps/windows.perception.spatial.surfaces.spatialsurfaceinfo.trycomputelatestmeshasync.aspx)
+  * [SpatialSurfaceMesh class]                     (https://msdn.microsoft.com/library/windows/apps/windows.perception.spatial.surfaces.spatialsurfacemesh.aspx)
+  * [SpatialSurfaceMeshBuffer class]               (https://msdn.microsoft.com/library/windows/apps/windows.perception.spatial.surfaces.spatialsurfacemeshbuffer.aspx)
+
+
+## System requirements
+
+**Client:** Windows 10 Holographic
+
+**Phone:** Not supported
+
+## Build the sample
+
+1. If you download the samples ZIP, be sure to unzip the entire archive, not just the folder with
+   the sample you want to build.
+2. Start Microsoft Visual Studio 2015 and select **File** \> **Open** \> **Project/Solution**.
+3. Starting in the folder where you unzipped the samples, go to the Samples subfolder, then the
+   subfolder for this specific sample, then the subfolder for your preferred language (C++, C#, or
+   JavaScript). Double-click the Visual Studio 2015 Solution (.sln) file.
+4. Press Ctrl+Shift+B, or select **Build** \> **Build Solution**.
+
+## Run the sample
+
+The next steps depend on whether you just want to deploy the sample or you want to both deploy and
+run it.
+
+### Deploying the sample to the Microsoft HoloLens emulator
+
+- Click the debug target drop-down, and select **Microsoft HoloLens Emulator**.
+- Select **Build** \> **Deploy** Solution.
+
+### Deploying the sample to a Microsoft HoloLens
+
+- Developer unlock your Microsoft HoloLens. For instructions, go to [Enable your device for development]
+  (https://msdn.microsoft.com/windows/uwp/get-started/enable-your-device-for-development#enable-your-windows-10-devices).
+- Find the IP address of your Microsoft HoloLens. The IP address can be found in **Settings**
+  \> **Network & Internet** \> **Wi-Fi** \> **Advanced options**. Or, you can ask Cortana for this
+  information by saying: "Hey Cortana, what's my IP address?"
+- Right-click on your project in Visual Studio, and then select **Properties**.
+- In the Debugging pane, click the drop-down and select **Remote Machine**.
+- Enter the IP address of your Microsoft HoloLens into the field labelled **Machine Name**.
+- Click **OK**.
+- Select **Build** \> **Deploy** Solution.
+
+### Pairing your developer-unlocked Microsoft HoloLens with Visual Studio
+
+The first time you deploy from your development PC to your developer-unlocked Microsoft HoloLens,
+you will need to use a PIN to pair your PC with the Microsoft HoloLens.
+- When you select **Build** \> **Deploy Solution**, a dialog box will appear for Visual Studio to
+  accept the PIN.
+- On your Microsoft HoloLens, go to **Settings** \> **Update** \> **For developers**, and click on
+  **Pair**.
+- Type the PIN displayed by your Microsoft HoloLens into the Visual Studio dialog box and click
+  **OK**.
+- On your Microsoft HoloLens, select **Done** to accept the pairing.
+- The solution will then start to deploy.
+
+### Deploying and running the sample
+
+- To debug the sample and then run it, follow the steps listed above to connect your
+  developer-unlocked Microsoft HoloLens, then press F5 or select **Debug** \> **Start Debugging**.
+  To run  the sample without debugging, press Ctrl+F5 or select **Debug** \> **Start Without Debugging**.

C++/HolographicSpatialMapping/cpp/AppView.cpp

@@ -0,0 +1,203 @@
+//*********************************************************
+//
+// Copyright (c) Microsoft. All rights reserved.
+// This code is licensed under the MIT License (MIT).
+// THIS CODE IS PROVIDED *AS IS* WITHOUT WARRANTY OF
+// ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING ANY
+// IMPLIED WARRANTIES OF FITNESS FOR A PARTICULAR
+// PURPOSE, MERCHANTABILITY, OR NON-INFRINGEMENT.
+//
+//*********************************************************
+
+#include "pch.h"
+#include "AppView.h"
+
+#include <ppltasks.h>
+
+using namespace HolographicSpatialMapping;
+
+using namespace concurrency;
+using namespace Windows::ApplicationModel;
+using namespace Windows::ApplicationModel::Activation;
+using namespace Windows::ApplicationModel::Core;
+using namespace Windows::Foundation;
+using namespace Windows::Graphics::Holographic;
+using namespace Windows::UI::Core;
+
+// The main function is only used to initialize our IFrameworkView class.
+// Under most circumstances, you should not need to modify this function.
+[Platform::MTAThread]
+int main(Platform::Array<Platform::String^>^)
+{
+    AppViewSource^ appViewSource = ref new ::AppViewSource();
+    CoreApplication::Run(appViewSource);
+    return 0;
+}
+
+IFrameworkView^ AppViewSource::CreateView()
+{
+    return ref new AppView();
+}
+
+AppView::AppView()
+{
+}
+
+
+// IFrameworkView methods
+
+// The first method called when the IFrameworkView is being created.
+// Use this method to subscribe for Windows shell events and to initialize your app.
+void AppView::Initialize(CoreApplicationView^ applicationView)
+{
+    applicationView->Activated +=
+        ref new TypedEventHandler<CoreApplicationView^, IActivatedEventArgs^>(this, &AppView::OnViewActivated);
+
+    // Register event handlers for app lifecycle.
+    CoreApplication::Suspending +=
+        ref new EventHandler<SuspendingEventArgs^>(this, &AppView::OnSuspending);
+
+    CoreApplication::Resuming +=
+        ref new EventHandler<Platform::Object^>(this, &AppView::OnResuming);
+
+    // At this point we have access to the device and we can create device-dependent
+    // resources.
+    m_deviceResources = std::make_shared<DX::DeviceResources>();
+
+    m_main = std::make_unique<HolographicSpatialMappingMain>(m_deviceResources);
+}
+
+// Called when the CoreWindow object is created (or re-created).
+void AppView::SetWindow(CoreWindow^ window)
+{
+    // Register for keypress notifications.
+    window->KeyDown +=
+        ref new TypedEventHandler<CoreWindow^, KeyEventArgs^>(this, &AppView::OnKeyPressed);
+
+    // Register for notification that the app window is being closed.
+    window->Closed +=
+        ref new TypedEventHandler<CoreWindow^, CoreWindowEventArgs^>(this, &AppView::OnWindowClosed);
+
+    // Register for notifications that the app window is losing focus.
+    window->VisibilityChanged +=
+        ref new TypedEventHandler<CoreWindow^, VisibilityChangedEventArgs^>(this, &AppView::OnVisibilityChanged);
+
+    // Create a holographic space for the core window for the current view.
+    // Presenting holographic frames that are created by this holographic space will put
+    // the app into exclusive mode.
+    m_holographicSpace = HolographicSpace::CreateForCoreWindow(window);
+
+    // 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.
+    m_deviceResources->SetHolographicSpace(m_holographicSpace);
+
+    // The main class uses the holographic space for updates and rendering.
+    m_main->SetHolographicSpace(m_holographicSpace);
+}
+
+// The Load method can be used to initialize scene resources or to load a
+// previously saved app state.
+void AppView::Load(Platform::String^ entryPoint)
+{
+}
+
+// This method is called after the window becomes active. It oversees the
+// update, draw, and present loop, and it also oversees window message processing.
+void AppView::Run()
+{
+    while (!m_windowClosed)
+    {
+        if (m_windowVisible && (m_holographicSpace != nullptr))
+        {
+            CoreWindow::GetForCurrentThread()->Dispatcher->ProcessEvents(CoreProcessEventsOption::ProcessAllIfPresent);
+
+            HolographicFrame^ holographicFrame = m_main->Update();
+
+            if (m_main->Render(holographicFrame))
+            {
+                // The holographic frame has an API that presents the swap chain for each
+                // holographic camera.
+                m_deviceResources->Present(holographicFrame);
+            }
+        }
+        else
+        {
+            CoreWindow::GetForCurrentThread()->Dispatcher->ProcessEvents(CoreProcessEventsOption::ProcessOneAndAllPending);
+        }
+    }
+}
+
+// Terminate events do not cause Uninitialize to be called. It will be called if your IFrameworkView
+// class is torn down while the app is in the foreground.
+// This method is not often used, but IFrameworkView requires it and it will be called for
+// holographic apps.
+void AppView::Uninitialize()
+{
+
+}
+
+
+// Application lifecycle event handlers
+
+// Called when the app view is activated. Activates the app's CoreWindow.
+void AppView::OnViewActivated(CoreApplicationView^ sender, IActivatedEventArgs^ args)
+{
+    // Run() won't start until the CoreWindow is activated.
+    sender->CoreWindow->Activate();
+}
+
+void AppView::OnSuspending(Platform::Object^ sender, SuspendingEventArgs^ args)
+{
+    // Save app state asynchronously after requesting a deferral. Holding a deferral
+    // indicates that the application is busy performing suspending operations. Be
+    // aware that a deferral may not be held indefinitely; after about five seconds,
+    // the app will be forced to exit.
+    SuspendingDeferral^ deferral = args->SuspendingOperation->GetDeferral();
+
+    create_task([this, deferral] ()
+    {
+        m_deviceResources->Trim();
+
+        if (m_main != nullptr)
+        {
+            m_main->SaveAppState();
+        }
+
+        deferral->Complete();
+    });
+}
+
+void AppView::OnResuming(Platform::Object^ sender, Platform::Object^ args)
+{
+    // Restore any data or state that was unloaded on suspend. By default, data
+    // and state are persisted when resuming from suspend. Note that this event
+    // does not occur if the app was previously terminated.
+
+    if (m_main != nullptr)
+    {
+        m_main->LoadAppState();
+    }
+}
+
+
+// Window event handlers
+
+void AppView::OnVisibilityChanged(CoreWindow^ sender, VisibilityChangedEventArgs^ args)
+{
+    m_windowVisible = args->Visible;
+}
+
+void AppView::OnWindowClosed(CoreWindow^ sender, CoreWindowEventArgs^ args)
+{
+    m_windowClosed = true;
+}
+
+
+// Input event handlers
+
+void AppView::OnKeyPressed(CoreWindow^ sender, KeyEventArgs^ args)
+{
+    // This code sample does not use keyboard input.
+}

C++/HolographicSpatialMapping/cpp/AppView.h

@@ -0,0 +1,63 @@
+//*********************************************************
+//
+// Copyright (c) Microsoft. All rights reserved.
+// This code is licensed under the MIT License (MIT).
+// THIS CODE IS PROVIDED *AS IS* WITHOUT WARRANTY OF
+// ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING ANY
+// IMPLIED WARRANTIES OF FITNESS FOR A PARTICULAR
+// PURPOSE, MERCHANTABILITY, OR NON-INFRINGEMENT.
+//
+//*********************************************************
+
+#pragma once
+
+#include "Common\DeviceResources.h"
+#include "HolographicSpatialMappingMain.h"
+
+namespace HolographicSpatialMapping
+{
+    // IFrameworkView class. Connects the app with the Windows shell and handles application lifecycle events.
+    ref class AppView sealed : public Windows::ApplicationModel::Core::IFrameworkView
+    {
+    public:
+        AppView();
+
+        // IFrameworkView methods.
+        virtual void Initialize(Windows::ApplicationModel::Core::CoreApplicationView^ applicationView);
+        virtual void SetWindow(Windows::UI::Core::CoreWindow^ window);
+        virtual void Load(Platform::String^ entryPoint);
+        virtual void Run();
+        virtual void Uninitialize();
+
+    protected:
+        // Application lifecycle event handlers.
+        void OnViewActivated(Windows::ApplicationModel::Core::CoreApplicationView^ sender, Windows::ApplicationModel::Activation::IActivatedEventArgs^ args);
+        void OnSuspending(Platform::Object^ sender, Windows::ApplicationModel::SuspendingEventArgs^ args);
+        void OnResuming(Platform::Object^ sender, Platform::Object^ args);
+
+        // Window event handlers.
+        void OnVisibilityChanged(Windows::UI::Core::CoreWindow^ sender, Windows::UI::Core::VisibilityChangedEventArgs^ args);
+        void OnWindowClosed(Windows::UI::Core::CoreWindow^ sender, Windows::UI::Core::CoreWindowEventArgs^ args);
+
+        // CoreWindow input event handlers.
+        void OnKeyPressed(Windows::UI::Core::CoreWindow^ sender, Windows::UI::Core::KeyEventArgs^ args);
+
+    private:
+        std::unique_ptr<HolographicSpatialMappingMain> m_main;
+
+        std::shared_ptr<DX::DeviceResources>                m_deviceResources;
+        bool                                                m_windowClosed  = false;
+        bool                                                m_windowVisible = true;
+
+        // The holographic space the app will use for rendering.
+        Windows::Graphics::Holographic::HolographicSpace^   m_holographicSpace = nullptr;
+    };
+
+    // The entry point for the app.
+    ref class AppViewSource sealed : Windows::ApplicationModel::Core::IFrameworkViewSource
+    {
+    public:
+        virtual Windows::ApplicationModel::Core::IFrameworkView^ CreateView();
+    };
+}
+