DirectX の座標系Coordinate systems in DirectX

座標系空間については、Windows Mixed Reality Api によって提供されるは、基礎を形成します。Coordinate systems form the basis for spatial understanding offered by Windows Mixed Reality APIs.

今日の取り付け VR または、単一ルーム VR デバイスは、追跡対象のスペースを表す 1 つのプライマリ座標システムを確立します。Today's seated VR or single-room VR devices establish one primary coordinate system to represent their tracked space. Windows Mixed Reality デバイスなど、HoloLens が定義されていない大規模な環境で使用するために設計されたデバイスを検出して、ユーザーとしてその周囲のものについて学習について説明しますの周り。Windows Mixed Reality devices such as HoloLens are designed to be used throughout large undefined environments, with the device discovering and learning about its surroundings as the user walks around. これにより、継続的に向上に合わせて、デバイス、ユーザーのルームが互いに、アプリの有効期間の関係を変更する座標システムでの結果に関する知識。This allows the device to adapt to continually-improving knowledge about the user's rooms, but results in coordinate systems that will change their relationship to one another through the lifetime of the app. Windows Mixed Reality は、幅広いデバイス、イマーシブ ヘッドセットが取り付けられていないから世界に接続された参照フレームまでをサポートします。Windows Mixed Reality supports a wide spectrum of devices, ranging from seated immersive headsets through world-attached reference frames.

注意

この記事のコード スニペットは現在の使用を示すC++/CX ではなく c++ 17 に準拠していませんC++/WinRT で使用するため、 C++ holographic プロジェクト テンプレートします。The code snippets in this article currently demonstrate use of C++/CX rather than C++17-compliant C++/WinRT as used in the C++ holographic project template. 概念は、同等のC++/WinRT のプロジェクトがコードに変換する必要があります。The concepts are equivalent for a C++/WinRT project, though you will need to translate the code.

Windows では、空間座標系Spatial coordinate systems in Windows

Windows では、実際の座標系を判断するために使用する主要なタイプは、 SpatialCoordinateSystemします。The core type used to reason about real-world coordinate systems in Windows is the SpatialCoordinateSystem. この型のインスタンスは、任意の座標系を表し、それぞれの詳細を理解することがなく 2 つの座標システム間で変換に使用できる変換行列を取得するメソッドを提供します。An instance of this type represents an arbitrary coordinate system and provides a method to get a transformation matrix that you can use to transform between two coordinate systems without understanding the details of each.

ポイント、線などで、またはユーザーの環境でボリュームとして表される空間の情報を返すメソッドが返されるこれらの座標に最も役立つ座標系を決定できるように SpatialCoordinateSystem パラメーターを受け入れます。Methods that return spatial information, represented as points, rays, or volumes in the user's surroundings, will accept a SpatialCoordinateSystem parameter to let you decide the coordinate system in which it's most useful for those coordinates to be returned. これらの座標の単位がメートル単位で常になります。The units for these coordinates will always be in meters.

SpatialCoordinateSystem には、デバイスの位置を表すものも含め、他の座標システムと動的な関係があります。A SpatialCoordinateSystem has a dynamic relationship with other coordinate systems, including those that represent the device's position. 任意の時点で、デバイスは一部の座標システムなどを検索することにあります。At any point in time, the device may be able to locate some coordinate systems and not others. ほとんどの座標システムでは、アプリを配置できません期間を処理できる必要があります。For most coordinate systems, your app must be ready to handle periods of time during which they cannot be located.

アプリケーションを作成しないでください SpatialCoordinateSystems 直接 - ではなく認識 Api を使用して使用する必要があります。Your application should not create SpatialCoordinateSystems directly - rather they should be consumed via the Perception APIs. 認識 Api で座標システムの 3 つのプライマリ ソースがあるで説明されている概念へのマップの各、座標系ページ。There are three primary sources of coordinate systems in the Perception APIs, each of which map to a concept described on the Coordinate systems page:

これらのオブジェクトによって返される座標システムのすべてが右利きで、+ 右に、+ x、y と + z 内を後方に向かってします。All of the coordinate systems returned by these objects are right-handed, with +y up, +x to the right and +z backwards. 方向正の x 方向の左側または右側のいずれかの本の指をポイントし、それらを正の y 方向に curling の正の z 軸点に注意することができます。You can remember which direction the positive z-axis points by pointing the fingers of either your left or right hand in the positive x direction and curling them into the positive y direction. 親指が指している方向は、自身に向かうかまたは離れる方向のいずれかとなり、その座標系の z 軸の正の向きが指す方向となります。The direction your thumb points, either toward or away from you, is the direction that the positive z-axis points for that coordinate system. 次の図は、これらの 2 つの座標系を示しています。The following illustration shows these two coordinate systems.

左辺と右辺座標系Left-hand and right-hand coordinate systems
左辺と右辺座標系Left-hand and right-hand coordinate systems

HoloLens の位置に基づいて SpatialCoordinateSystem にブートス トラップを使用して、 SpatialLocator以下のセクションで説明されているか、添付または静止フレームの参照を作成するクラス。To bootstrap into a SpatialCoordinateSystem based on the position of a HoloLens, use the SpatialLocator class to create either an attached or stationary frame of reference, as described in the sections below.

空間のステージを使用して、世界中の配置ホログラムPlace holograms in the world using a spatial stage

Windows Mixed Reality イマーシブ ヘッドセットを非透過の座標系は、静的なを使用してアクセスSpatialStageFrameOfReference::Currentプロパティ。The coordinate system for opaque Windows Mixed Reality immersive headsets is accessed using the static SpatialStageFrameOfReference::Current property. この API には、座標系、については、プレーヤーが取り付けられているかどうかについてや、モバイル、安全な領域の境界の場合は、プレーヤーは、モバイル、歩き回るとかどうかを示す値、ヘッドセットは方向。This API provides a coordinate system, information about whether the player is seated or mobile, the boundary of a safe area for walking around if the player is mobile, and an indication of whether or not the headset is directional. 空間のステージに更新プログラムのイベント ハンドラーもあります。There is also an event handler for updates to the spatial stage.

最初に、空間のステージを取得し、更新プログラムの定期受信します。First, we get the spatial stage and subscribe for updates to it:

コードを空間ステージの初期化Code for Spatial stage initialization

SpatialStageManager::SpatialStageManager(
    const std::shared_ptr<DX::DeviceResources>& deviceResources, 
    const std::shared_ptr<SceneController>& sceneController)
    : m_deviceResources(deviceResources), m_sceneController(sceneController)
{
    // Get notified when the stage is updated.
    m_spatialStageChangedEventToken = SpatialStageFrameOfReference::CurrentChanged +=
        ref new EventHandler<Object^>(std::bind(&SpatialStageManager::OnCurrentChanged, this, _1));

    // Make sure to get the current spatial stage.
    OnCurrentChanged(nullptr);
}

OnCurrentChanged メソッドでは、アプリは空間段階の検査し、プレーヤーのエクスペリエンスを適宜更新する必要があります。In the OnCurrentChanged method, your app should inspect the spatial stage and update the player experience accordingly. この例では、ユーザーとビューのステージの範囲と移動プロパティの範囲で指定された開始位置と同様に、ステージの境界の視覚エフェクトを提供します。In this example, we provide a visualization of the stage boundary, as well as the start position specified by the user and the stage's range of view and range of movement properties. 私たちも場合にフォールバック独自静止座標系ステージを指定することはできません。We also fall back to our own stationary coordinate system, when a stage cannot be provided.

コードを空間段階の更新Code for Spatial stage update

void SpatialStageManager::OnCurrentChanged(Object^ /*o*/)
{
    // The event notifies us that a new stage is available.
    // Get the current stage.
    m_currentStage = SpatialStageFrameOfReference::Current;

    // Clear previous content.
    m_sceneController->ClearSceneObjects();

    if (m_currentStage != nullptr)
    {
        // Obtain stage geometry.
        auto stageCoordinateSystem = m_currentStage->CoordinateSystem;
        auto boundsVertexArray = m_currentStage->TryGetMovementBounds(stageCoordinateSystem);

        // Visualize the area where the user can move around.
        std::vector<float3> boundsVertices;
        boundsVertices.resize(boundsVertexArray->Length);
        memcpy(boundsVertices.data(), boundsVertexArray->Data, boundsVertexArray->Length * sizeof(float3));
        std::vector<unsigned short> indices = TriangulatePoints(boundsVertices);
        m_stageBoundsShape =
            std::make_shared<SceneObject>(
                    m_deviceResources,
                    reinterpret_cast<std::vector<XMFLOAT3>&>(boundsVertices),
                    indices,
                    XMFLOAT3(DirectX::Colors::SeaGreen),
                    stageCoordinateSystem);
        m_sceneController->AddSceneObject(m_stageBoundsShape);

        // In this sample, we draw a visual indicator for some spatial stage properties.
        // If the view is forward-only, the indicator is a half circle pointing forward - otherwise, it
        // is a full circle.
        // If the user can walk around, the indicator is blue. If the user is seated, it is red.

        // The indicator is rendered at the origin - which is where the user declared the center of the
        // stage to be during setup - above the plane of the stage bounds object.
        float3 visibleAreaCenter = float3(0.f, 0.001f, 0.f);

        // Its shape depends on the look direction range.
        std::vector<float3> visibleAreaIndicatorVertices;
        if (m_currentStage->LookDirectionRange == SpatialLookDirectionRange::ForwardOnly)
        {
            // Half circle for forward-only look direction range.
            visibleAreaIndicatorVertices = CreateCircle(visibleAreaCenter, 0.25f, 9, XM_PI);
        }
        else
        {
            // Full circle for omnidirectional look direction range.
            visibleAreaIndicatorVertices = CreateCircle(visibleAreaCenter, 0.25f, 16, XM_2PI);
        }

        // Its color depends on the movement range.
        XMFLOAT3 visibleAreaColor;
        if (m_currentStage->MovementRange == SpatialMovementRange::NoMovement)
        {
            visibleAreaColor = XMFLOAT3(DirectX::Colors::OrangeRed);
        }
        else
        {
            visibleAreaColor = XMFLOAT3(DirectX::Colors::Aqua);
        }

        std::vector<unsigned short> visibleAreaIndicatorIndices = TriangulatePoints(visibleAreaIndicatorVertices);

        // Visualize the look direction range.
        m_stageVisibleAreaIndicatorShape =
            std::make_shared<SceneObject>(
                    m_deviceResources,
                    reinterpret_cast<std::vector<XMFLOAT3>&>(visibleAreaIndicatorVertices),
                    visibleAreaIndicatorIndices,
                    visibleAreaColor,
                    stageCoordinateSystem);
        m_sceneController->AddSceneObject(m_stageVisibleAreaIndicatorShape);
    }
    else
    {
        // No spatial stage was found.
        // Fall back to a stationary coordinate system.
        auto locator = SpatialLocator::GetDefault();
        if (locator)
        {
            m_stationaryFrameOfReference = locator->CreateStationaryFrameOfReferenceAtCurrentLocation();

            // Render an indicator, so that we know we fell back to a mode without a stage.
            std::vector<float3> visibleAreaIndicatorVertices;
            float3 visibleAreaCenter = float3(0.f, -2.0f, 0.f);
            visibleAreaIndicatorVertices = CreateCircle(visibleAreaCenter, 0.125f, 16, XM_2PI);
            std::vector<unsigned short> visibleAreaIndicatorIndices = TriangulatePoints(visibleAreaIndicatorVertices);
            m_stageVisibleAreaIndicatorShape =
                std::make_shared<SceneObject>(
                    m_deviceResources,
                    reinterpret_cast<std::vector<XMFLOAT3>&>(visibleAreaIndicatorVertices),
                    visibleAreaIndicatorIndices,
                    XMFLOAT3(DirectX::Colors::LightSlateGray),
                    m_stationaryFrameOfReference->CoordinateSystem);
            m_sceneController->AddSceneObject(m_stageVisibleAreaIndicatorShape);
        }
    }
}

時計回りの頂点のステージの境界を定義するセットが提供されます。The set of vertices that define the stage boundary are provided in clockwise order. Windows Mixed Reality シェルでは、ユーザーがそれに近づくと、境界にフェンスを描画します。ウォークの領域を目的に合わせて triangularize たい場合があります。The Windows Mixed Reality shell draws a fence at the boundary when the user approaches it; you may wish to triangularize the walkable area for your own purposes. Triangularize ステージには、次のアルゴリズムを使用できます。The following algorithm can be used to triangularize the stage.

コードを空間ステージ triangularizationCode for Spatial stage triangularization

std::vector<unsigned short> SpatialStageManager::TriangulatePoints(std::vector<float3> const& vertices)
{
    size_t const& vertexCount = vertices.size();

    // Segments of the shape are removed as they are triangularized.
    std::vector<bool> vertexRemoved;
    vertexRemoved.resize(vertexCount, false);
    unsigned int vertexRemovedCount = 0;

    // Indices are used to define triangles.
    std::vector<unsigned short> indices;

    // Decompose into convex segments.
    unsigned short currentVertex = 0;
    while (vertexRemovedCount < (vertexCount - 2))
    {
        // Get next triangle:
        // Start with the current vertex.
        unsigned short index1 = currentVertex;

        // Get the next available vertex.
        unsigned short index2 = index1 + 1;

        // This cycles to the next available index.
        auto CycleIndex = [=](unsigned short indexToCycle, unsigned short stopIndex)
        {
            // Make sure the index does not exceed bounds.
            if (indexToCycle >= unsigned short(vertexCount))
            {
                indexToCycle -= unsigned short(vertexCount);
            }

            while (vertexRemoved[indexToCycle])
            {
                // If the vertex is removed, go to the next available one.
                ++indexToCycle;

                // Make sure the index does not exceed bounds.
                if (indexToCycle >= unsigned short(vertexCount))
                {
                    indexToCycle -= unsigned short(vertexCount);
                }

                // Prevent cycling all the way around.
                // Should not be needed, as we limit with the vertex count.
                if (indexToCycle == stopIndex)
                {
                    break;
                }
            }

            return indexToCycle;
        };
        index2 = CycleIndex(index2, index1);

        // Get the next available vertex after that.
        unsigned short index3 = index2 + 1;
        index3 = CycleIndex(index3, index1);

        // Vertices that may define a triangle inside the 2D shape.
        auto& v1 = vertices[index1];
        auto& v2 = vertices[index2];
        auto& v3 = vertices[index3];

        // If the projection of the first segment (in clockwise order) onto the second segment is 
        // positive, we know that the clockwise angle is less than 180 degrees, which tells us 
        // that the triangle formed by the two segments is contained within the bounding shape.
        auto v2ToV1 = v1 - v2;
        auto v2ToV3 = v3 - v2;
        float3 normalToV2ToV3 = { -v2ToV3.z, 0.f, v2ToV3.x };
        float projectionOntoNormal = dot(v2ToV1, normalToV2ToV3);
        if (projectionOntoNormal >= 0)
        {
            // Triangle is contained within the 2D shape.

            // Remove peak vertex from the list.
            vertexRemoved[index2] = true;
            ++vertexRemovedCount;

            // Create the triangle.
            indices.push_back(index1);
            indices.push_back(index2);
            indices.push_back(index3);

            // Continue on to the next outer triangle.
            currentVertex = index3;
        }
        else
        {
            // Triangle is a cavity in the 2D shape.
            // The next triangle starts at the inside corner.
            currentVertex = index2;
        }
    }

    indices.shrink_to_fit();
    return indices;
}

静止した基準枠を使用して、世界中の配置ホログラムPlace holograms in the world using a stationary frame of reference

SpatialStationaryFrameOfReferenceクラスのフレームを表しますが参照する静止周りを基準として、ユーザー、ユーザーの環境と移動します。The SpatialStationaryFrameOfReference class represents a frame of reference that remains stationary relative to the user's surroundings as the user moves around. このフレームの参照では、デバイスの近くに安定したままの状態の座標で優先されます。This frame of reference prioritizes keeping coordinates stable near the device. ホログラムを表示するときに、レンダリング エンジン内で基になるワールド座標系として機能すること、SpatialStationaryFrameOfReference の 1 つのキーの使用です。One key use of a SpatialStationaryFrameOfReference is to act as the underlying world coordinate system within a rendering engine when rendering holograms.

SpatialStationaryFrameOfReference を取得する、 SpatialLocatorクラスと呼び出しCreateStationaryFrameOfReferenceAtCurrentLocationします。To get a SpatialStationaryFrameOfReference, use the SpatialLocator class and call CreateStationaryFrameOfReferenceAtCurrentLocation.

Windows Holographic のアプリのテンプレート コード: からFrom the Windows Holographic app template code:

           // 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();
  • 静止した基準枠は、領域全体の基準とした最適位置を提供する設計されています。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. これは、普通は、デバイスは環境についての詳細を学習します。This is normal as the device learns more about the environment.
  • ホログラムの個々 の正確な配置が必要な場合、SpatialAnchor を使用して、個々 のホログラム現実の世界での位置に固定する必要がある-たとえば、ポイントをユーザーことを示します特別な関心のあります。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.

空間のアンカーを使用して、世界中の配置ホログラムPlace holograms in the world using spatial anchors

空間アンカーホログラムを現実の世界での特定の場所に配置する優れた方法は、システム アンカーのことを確認する時間の経過と共にのままにします。Spatial anchors are a great way to place holograms at a specific place in the real world, with the system ensuring the anchor stays in place over time. このトピックでは、アンカーのデータを操作する方法と作成して、アンカーを使用する方法について説明します。This topic explains how to create and use an anchor, and how to work with anchor data.

任意の位置と、選択、SpatialCoordinateSystem 内向き、SpatialAnchor を作成できます。You can create a SpatialAnchor at any position and orientation within the SpatialCoordinateSystem of your choosing. デバイスは、現時点では、その座標系を検索できる必要があり、システムが空間アンカーの制限に達しましたのないでする必要がありますがします。The device must be able to locate that coordinate system at the moment, and the system must not have reached its limit of spatial anchors.

定義した後、SpatialAnchor の座標系は、正確な位置と向きの初期位置を保持する継続的に調整します。Once defined, the coordinate system of a SpatialAnchor adjusts continually to retain the precise position and orientation of its initial location. この SpatialAnchor は、その正確な場所で、ユーザーの環境に固定表示されるホログラムを表示するために使用できます。You can then use this SpatialAnchor to render holograms that will appear fixed in the user's surroundings at that exact location.

アンカーを維持する調整の効果を拡大するには、アンカーが増加からの距離として。The effects of the adjustments that keep the anchor in place are magnified as distance from the anchor increases. そのため、そのアンカーの配信元から複数の約 3 メートル アンカーの基準とした内容の表示を避ける必要があります。Therefore, you should avoid rendering content relative to an anchor that is more than about 3 meters from that anchor's origin.

CoordinateSystemプロパティが、デバイス、アンカーの正確な場所を調整するときに適用されるイージングを使用する、アンカー ポイントからコンテンツを配置することができます、座標系を取得します。The CoordinateSystem property gets a coordinate system that lets you place content relative to the anchor, with easing applied when the device adjusts the anchor's precise location.

使用して、 RawCoordinateSystemプロパティと、対応するRawCoordinateSystemAdjusted自分でこれらの調整を管理するイベントです。Use the RawCoordinateSystem property and the corresponding RawCoordinateSystemAdjusted event to manage these adjustments yourself.

保存や共有空間アンカーPersist and share spatial anchors

使用してローカル SpatialAnchor を永続化できる、 SpatialAnchorStoreクラスし、同じ HoloLens デバイスに将来のアプリのセッションに戻りを取得します。You can persist a SpatialAnchor locally using the SpatialAnchorStore class and then get it back in a future app session on the same HoloLens device.

使用してAzure 空間アンカーから、ローカルな SpatialAnchor は、アプリが複数の HoloLens、iOS や Android デバイスで見つけることができますし、持続性のあるクラウド アンカーを作成できます。By using Azure Spatial Anchors, you can create a durable cloud anchor from a local SpatialAnchor, which your app can then locate across multiple HoloLens, iOS and Android devices. 各ユーザーは複数のデバイスで共通の空間アンカーを共有することで、同じ物理的な場所でそのアンカーの基準としたコンテンツを表示できます。By sharing a common spatial anchor across multiple devices, each user can see content rendered relative to that anchor in the same physical location. これにより、リアルタイムのエクスペリエンスを共有します。This allows for real-time shared experiences.

使用することもAzure 空間アンカー HoloLens、iOS および Android デバイスの間で非同期ホログラム永続化します。You can also use Azure Spatial Anchors for asynchronous hologram persistence across HoloLens, iOS and Android devices. 持続性のあるクラウド空間アンカーを共有することで複数のデバイスはこれらのデバイスがまとめてと同時に存在しない場合でも、時間の経過と共に同じ永続化されたホログラムを確認できます。By sharing a durable cloud spatial anchor, multiple devices can observe the same persisted hologram over time, even if those devices are not present together at the same time.

5 分間試して、HoloLens のアプリで共有のエクスペリエンスの構築を開始する、空間アンカー HoloLens の Azure クイック スタートします。To get started building shared experiences in your HoloLens app, try out the 5-minute Azure Spatial Anchors HoloLens quickstart.

空間のアンカーを Azure で稼働しているを開発したとして、を作成し、HoloLens でアンカーを見つけるします。Once you're up and running with Azure Spatial Anchors, you can then create and locate anchors on HoloLens. チュートリアルに利用Android および iOS同様に、すべてのデバイスで同じアンカーを共有できるようにすることです。Walkthroughs are available for Android and iOS as well, enabling you to share the same anchors on all devices.

SpatialAnchors を holographic のコンテンツを作成します。Create SpatialAnchors for holographic content

このコード サンプルでは、変更後の Windows Holographic アプリ テンプレートの作成に固定する場合に、 Pressedジェスチャが検出されました。For this code sample, we modified the Windows Holographic app template to create anchors when the Pressed gesture is detected. キューブは、レンダリング パス中に、アンカーに格納されます。The cube is then placed at the anchor during the render pass.

ヘルパー クラスでは、複数のアンカーがサポートされている、このコード サンプルを使用すると同数のキューブを配置できます。Since multiple anchors are supported by the helper class, we can place as many cubes as we want using this code sample!

アンカーの Id は、何か、アプリを制御することに注意してください。Note that the IDs for anchors are something you control in your app. この例では順次アンカーのアプリのコレクションに格納されているアンカーの数に基づく名前付けスキームを作成しました。In this example, we have created a naming scheme that is sequential based on the number of anchors currently stored in the app's collection of anchors.

   // Check for new input state since the last frame.
   SpatialInteractionSourceState^ pointerState = m_spatialInputHandler->CheckForInput();
   if (pointerState != nullptr)
   {
       // Try to get the pointer pose relative to the SpatialStationaryReferenceFrame.
       SpatialPointerPose^ pointerPose = pointerState->TryGetPointerPose(currentCoordinateSystem);
       if (pointerPose != nullptr)
       {
           // When a Pressed gesture is detected, the anchor will be created two meters in front of the user.

           // Get the gaze direction relative to the given coordinate system.
           const float3 headPosition = pointerPose->Head->Position;
           const float3 headDirection = pointerPose->Head->ForwardDirection;

           // The anchor position in the StationaryReferenceFrame.
           static const float distanceFromUser = 2.0f; // meters
           const float3 gazeAtTwoMeters = headPosition + (distanceFromUser * headDirection);

           // Create the anchor at position.
           SpatialAnchor^ anchor = SpatialAnchor::TryCreateRelativeTo(currentCoordinateSystem, gazeAtTwoMeters);

           if ((anchor != nullptr) && (m_spatialAnchorHelper != nullptr))
           {
               // In this example, we store the anchor in an IMap.
               auto anchorMap = m_spatialAnchorHelper->GetAnchorMap();

               // Create an identifier for the anchor.
               String^ id = ref new String(L"HolographicSpatialAnchorStoreSample_Anchor") + anchorMap->Size;

               anchorMap->Insert(id->ToString(), anchor);
           }
       }
   }

非同期的に読み込まれ、SpatialAnchorStore をキャッシュします。Asynchronously load, and cache, the SpatialAnchorStore

この永続化、処理に役立つ SampleSpatialAnchorHelper クラスを作成する方法について説明を含みます。Let's see how to write a SampleSpatialAnchorHelper class that helps handle this persistence, including:

  • Platform::string キーによってインデックスが作成、メモリ内表現のアンカーのコレクションを格納します。Storing a collection of in-memory anchors, indexed by a Platform::String key.
  • アンカーは、システムの SpatialAnchorStore から読み込み、これは分離されますローカル メモリ内コレクションから。Loading anchors from the system's SpatialAnchorStore, which is kept separate from the local in-memory collection.
  • そのためには、アプリが選択したときに、SpatialAnchorStore にアンカーのローカル メモリ内コレクションを保存しています。Saving the local in-memory collection of anchors to the SpatialAnchorStore when the app chooses to do so.

保存する方法を次に示しますSpatialAnchor内のオブジェクト、 SpatialAnchorStoreします。Here's how to save SpatialAnchor objects in the SpatialAnchorStore.

クラスは、起動時に、SpatialAnchorStore を非同期的に要求します。When the class starts up, we request the SpatialAnchorStore asynchronously. システム I/O API は、アンカー ストアを読み込むし、I/O は非ブロッキングようにこの API は非同期されるようになります。This involves system I/O as the API loads the anchor store, and this API is made asynchronous so that the I/O is non-blocking.

   // Request the spatial anchor store, which is the WinRT object that will accept the imported anchor data.
   return create_task(SpatialAnchorManager::RequestStoreAsync())
       .then([](task<SpatialAnchorStore^> previousTask)
   {
       std::shared_ptr<SampleSpatialAnchorHelper> newHelper = nullptr;

       try
       {
           SpatialAnchorStore^ anchorStore = previousTask.get();

           // Once the SpatialAnchorStore has been loaded by the system, we can create our helper class.

           // Using "new" to access private constructor
           newHelper = std::shared_ptr<SampleSpatialAnchorHelper>(new SampleSpatialAnchorHelper(anchorStore));

           // Now we can load anchors from the store.
           newHelper->LoadFromAnchorStore();
       }
       catch (Exception^ exception)
       {
           PrintWstringToDebugConsole(
               std::wstring(L"Exception while loading the anchor store: ") +
               exception->Message->Data() +
               L"\n"
               );
       }

       // Return the initialized class instance.
       return newHelper;
   });

アンカーの保存に使用できる SpatialAnchorStore が与えられます。You will be given a SpatialAnchorStore that you can use to save the anchors. これは、IMapView を関連付ける SpatialAnchors いるデータ値では文字列であるキーの値です。This is an IMapView that associates key values that are Strings, with data values that are SpatialAnchors. サンプル コードで保存すれば、ヘルパー クラスのパブリック関数を通じてアクセスできるプライベート クラス メンバー変数にします。In our sample code, we store this in a private class member variable that is accessible through a public function of our helper class.

   SampleSpatialAnchorHelper::SampleSpatialAnchorHelper(SpatialAnchorStore^ anchorStore)
   {
       m_anchorStore = anchorStore;
       m_anchorMap = ref new Platform::Collections::Map<String^, SpatialAnchor^>();
   }

注意

忘れずに保存および読み込みアンカー ストア保留/再開イベントをフックします。Don't forget to hook up the suspend/resume events to save and load the anchor store.

   void HolographicSpatialAnchorStoreSampleMain::SaveAppState()
   {
       // For example, store information in the SpatialAnchorStore.
       if (m_spatialAnchorHelper != nullptr)
       {
           m_spatialAnchorHelper->TrySaveToAnchorStore();
       }
   }
   void HolographicSpatialAnchorStoreSampleMain::LoadAppState()
   {
       // For example, load information from the SpatialAnchorStore.
       LoadAnchorStore();
   }

コンテンツをアンカー ストアに保存します。Save content to the anchor store

システムでは、アプリが中断、ときに、空間、アンカーをアンカー ストアに保存する必要があります。When the system suspends your app, you need to save your spatial anchors to the anchor store. アプリの実装に必要であることを検索するには、アンカーのストアにその他の時間は、アンカーを保存することもできます。You may also choose to save anchors to the anchor store at other times, as you find to be necessary for your app's implementation.

SpatialAnchorStore をメモリ内のアンカーを保存してください準備ができたらは、コレクションをループ処理し、それぞれを保存しようとしています。When you're ready to try saving the in-memory anchors to the SpatialAnchorStore, you can loop through your collection and try to save each one.

   // TrySaveToAnchorStore: Stores all anchors from memory into the app's anchor store.
   //
   // For each anchor in memory, this function tries to store it in the app's AnchorStore. The operation will fail if
   // the anchor store already has an anchor by that name.
   //
   bool SampleSpatialAnchorHelper::TrySaveToAnchorStore()
   {
       // This function returns true if all the anchors in the in-memory collection are saved to the anchor
       // store. If zero anchors are in the in-memory collection, we will still return true because the
       // condition has been met.
       bool success = true;

       // If access is denied, 'anchorStore' will not be obtained.
       if (m_anchorStore != nullptr)
       {
           for each (auto& pair in m_anchorMap)
           {
               auto const& id = pair->Key;
               auto const& anchor = pair->Value;

               // Try to save the anchors.
               if (!m_anchorStore->TrySave(id, anchor))
               {
                   // This may indicate the anchor ID is taken, or the anchor limit is reached for the app.
                   success=false;
               }
           }
       }

       return success;
   }

アンカー ストアからアプリを再開したときにコンテンツを読み込むLoad content from the anchor store when the app resumes

アプリの再開時、または implementaiton のアプリのために必要な他の任意の時点で、アンカー ストアの IMapView から SpatialAnchors の独自のメモリ内データベースに転送することによって、AnchorStore に以前に保存されたアンカーを戻すことができます。When your app resumes, or at any other time necessary for your app's implementaiton, you can restore anchors that were previously saved to the AnchorStore by transferring them from the anchor store's IMapView to your own in-memory database of SpatialAnchors.

SpatialAnchorStore から表現のアンカーを復元するには、互いをメモリ内コレクションに興味があるを復元します。To restore anchors from the SpatialAnchorStore, restore each one that you are interested in to your own in-memory collection.

SpatialAnchors; の独自のメモリ内データベースを作成する必要があります。何らかの方法に文字列を作成する SpatialAnchors に関連付けます。You need your own in-memory database of SpatialAnchors; some way to associate Strings with the SpatialAnchors that you create. サンプル コードで選択、Windows::Foundation::Collections::IMap を使用して、アンカーを格納するしやすく、SpatialAnchorStore に同じキーとデータの値を使用します。In our sample code, we choose to use a Windows::Foundation::Collections::IMap to store the anchors, which makes it easy to use the same key and data value for the SpatialAnchorStore.

   // This is an in-memory anchor list that is separate from the anchor store.
   // These anchors may be used, reasoned about, and so on before committing the collection to the store.
   Windows::Foundation::Collections::IMap<Platform::String^, Windows::Perception::Spatial::SpatialAnchor^>^ m_anchorMap;

注意

復元されるアンカーできない可能性があります場所を特定できるでしょうか。An anchor that is restored might not be locatable right away. たとえば、別の部屋にまたは、別の構築に完全にアンカーがあります。For example, it might be an anchor in a separate room or in a different building altogether. 使用する前に locatability、AnchorStore から取得したアンカーをテストする必要があります。Anchors retrieved from the AnchorStore should be tested for locatability before using them.


注意

このコード例では、AnchorStore からすべてのアンカーを取得します。In this example code, we retrieve all anchors from the AnchorStore. これは要件ではありません。アプリと同様を選択アンカーの特定のサブセットを実装に意味のある文字列キー値を使用しています。This is not a requirement; your app could just as well pick and choose a certain subset of anchors by using String key values that are meaningful to your implementation.

   // LoadFromAnchorStore: Loads all anchors from the app's anchor store into memory.
   //
   // The anchors are stored in memory using an IMap, which stores anchors using a string identifier. Any string can be used as
   // the identifier; it can have meaning to the app, such as "Game_Leve1_CouchAnchor," or it can be a GUID that is generated
   // by the app.
   //
   void SampleSpatialAnchorHelper::LoadFromAnchorStore()
   {
       // If access is denied, 'anchorStore' will not be obtained.
       if (m_anchorStore != nullptr)
       {
           // Get all saved anchors.
           auto anchorMapView = m_anchorStore->GetAllSavedAnchors();
           for each (auto const& pair in anchorMapView)
           {
               auto const& id = pair->Key;
               auto const& anchor = pair->Value;
               m_anchorMap->Insert(id, anchor);
           }
       }
   }

必要なときに、アンカー ストアをクリアします。Clear the anchor store, when needed

場合によっては、アプリの状態をオフにして新しいデータを書き込む必要があります。Sometimes, you need to clear app state and write new data. その方法を次に示します、 SpatialAnchorStoreします。Here's how you do that with the SpatialAnchorStore.

ヘルパー クラスを使用する必要はありませんほぼをラップする関数をクリアします。Using our helper class, it's almost unnecessary to wrap the Clear function. このヘルパー クラスが SpatialAnchorStore インスタンスを所有しているの役割を与えられているため、サンプルの実装では、そのために選択します。We choose to do so in our sample implementation, because our helper class is given the responsibility of owning the SpatialAnchorStore instance.

   // ClearAnchorStore: Clears the AnchorStore for the app.
   //
   // This function clears the AnchorStore. It has no effect on the anchors stored in memory.
   //
   void SampleSpatialAnchorHelper::ClearAnchorStore()
   {
       // If access is denied, 'anchorStore' will not be obtained.
       if (m_anchorStore != nullptr)
       {
           // Clear all anchors from the store.
           m_anchorStore->Clear();
       }
   }

以下に例を示します。アンカーの座標系に関連する静止した基準枠座標系Example: Relating anchor coordinate systems to stationary reference frame coordinate systems

たとえば、アンカーがあり、その大部分の他のコンテンツを既に使用している SpatialStationaryReferenceFrame に関連するアンカーの座標システムで何かにするとします。Let's say that you have an anchor, and you want to relate something in your anchor's coordinate system to the SpatialStationaryReferenceFrame that you’re already using for most of your other content. 使用することができますTryGetTransformTo静止した基準枠のアンカーの座標系から変換を取得します。You can use TryGetTransformTo to obtain a transform from the anchor’s coordinate system to that of the stationary reference frame:

   // In this code snippet, someAnchor is a SpatialAnchor^ that has been initialized and is valid in the current environment.
   float4x4 anchorSpaceToCurrentCoordinateSystem;
   SpatialCoordinateSystem^ anchorSpace = someAnchor->CoordinateSystem;
   const auto tryTransform = anchorSpace->TryGetTransformTo(currentCoordinateSystem);
   if (tryTransform != nullptr)
   {
       anchorSpaceToCurrentCoordinateSystem = tryTransform->Value;
   }

このプロセスは、2 つの方法に便利です。This process is useful to you in two ways:

  1. 2 つのフレームを参照する場合、相互に関連した認識できるように指示し、;It tells you if the two reference frames can be understood relative to one another, and;
  2. そのためが提供されている場合にもう 1 つの座標システムから直接移動する変換。If so, it provides you a transform to go directly from one coordinate system to the other.

この情報は、2 つの参照フレーム間でオブジェクトの空間関係の理解しています。With this information, you have an understanding of the spatial relation between objects between the two reference frames.

レンダリングには、元の参照フレームまたはアンカーに従ってオブジェクトをグループ化して多くの場合より良い結果を取得できます。For rendering, you can often obtain better results by grouping objects according to their original reference frame or anchor. グループごとに別個の描画パスを実行します。Perform a separate drawing pass for each group. View 行列は、最初に同一の座標系を使用して作成されるモデルの変換でオブジェクトをより正確なです。The view matrices are more accurate for objects with model transforms that are created initially using the same coordinate system.

デバイス接続の参照を使用してホログラムを作成します。Create holograms using a device-attached frame of reference

ホログラムを表示するために必要な場合があるをがアタッチされたままデバイスの場所、デバイスがその向きを決定することのみのときに、情報メッセージまたは情報メッセージをデバッグなどのパネルに、いない領域の位置。There are times when you want to render a hologram that remains attached to the device's location, for example a panel with debugging information or an informational message when the device is only able to determine its orientation and not its position in space. これを行うには、接続されている基準を使用します。To accomplish this, we use an attached frame of reference.

SpatialLocatorAttachedFrameOfReference クラスは、現実世界ではなく、デバイスに対して相対的である座標系を定義します。The SpatialLocatorAttachedFrameOfReference class defines coordinate systems which are relative to the device rather than to the real-world. このフレームは、方向、ユーザーのポイントは、参照フレームが作成されたときに直面していましたが、ユーザーの環境の基準とした固定の見出しが。This frame has a fixed heading relative to the user's surroundings that points in the direction the user was facing when the reference frame was created. このフレームのリファレンス内のすべての向きは、ユーザー、デバイスを回転しても、その固定の見出しを基準とは。From then on, all orientations in this frame of reference are relative to that fixed heading, even as the user rotates the device.

HoloLens、このフレームの座標系の原点は配置されているユーザーの頭の回転の中心に回転、ヘッドの位置が受けないようにします。For HoloLens, the origin of this frame's coordinate system is located at the center of rotation of the user's head, so that its position is not affected by head rotation. アプリには、このポイント ホログラムも、ユーザーの位置を基準としたオフセットを指定できます。Your app can specify an offset relative to this point to position holograms in front of the user.

SpatialLocatorAttachedFrameOfReference を取得するには、SpatialLocator クラスを使用し、CreateAttachedFrameOfReferenceAtCurrentHeading を呼び出します。To get a SpatialLocatorAttachedFrameOfReference, use the SpatialLocator class and call CreateAttachedFrameOfReferenceAtCurrentHeading.

これが全体の範囲の Windows Mixed Reality デバイスに適用されることに注意してください。Note that this applies to the entire range of Windows Mixed Reality devices.

デバイスに接続されている参照フレームを使用して、Use a reference frame attached to the device

これらのセクションでは、この API を使用してデバイスに接続されたフレームの参照を有効にする、Windows Holographic のアプリケーション テンプレートで変更点について説明します。These sections talk about what we changed in the Windows Holographic app template to enable a device-attached frame of reference using this API. この「添付」ホログラムが固定または固定のホログラムに連動し、デバイスは、世界中でその位置を検索する一時的にできない場合にも使用される可能性がありますに注意してください。Note that this "attached" hologram will work alongside stationary or anchored holograms, and may also be used when the device is temporarily unable to find its position in the world.

最初に、SpatialStationaryFrameOfReference ではなく、SpatialLocatorAttachedFrameOfReference を格納するテンプレートを変更します。First, we changed the template to store a SpatialLocatorAttachedFrameOfReference instead of a SpatialStationaryFrameOfReference:

HolographicTagAlongSampleMain.h:From HolographicTagAlongSampleMain.h:

   // A reference frame attached to the holographic camera.
   Windows::Perception::Spatial::SpatialLocatorAttachedFrameOfReference^   m_referenceFrame;

HolographicTagAlongSampleMain.cpp:From HolographicTagAlongSampleMain.cpp:

   // In this example, we create a reference frame attached to the device.
   m_referenceFrame = m_locator->CreateAttachedFrameOfReferenceAtCurrentHeading();

更新中に今すぐフレーム予測使用から取得されたタイムスタンプの座標系を取得します。During the update, we now obtain the coordinate system at the time stamp obtained from with the frame prediction.

   // Next, we get a coordinate system from the attached frame of reference that is
   // associated with the current frame. Later, this coordinate system is used for
   // for creating the stereo view matrices when rendering the sample content.
   SpatialCoordinateSystem^ currentCoordinateSystem =
       m_referenceFrame->GetStationaryCoordinateSystemAtTimestamp(prediction->Timestamp);

空間ポインター姿勢を取得し、次のユーザーの視線入力Get a spatial pointer pose, and follow the user's Gaze

ユーザーのフォローを例ホログラムする視線と同様に、holographic シェルが、ユーザーの視線の先に従います。We want our example hologram to follow the user's gaze, similar to how the holographic shell can follow the user's gaze. これは、同じタイムスタンプから、SpatialPointerPose を取得する必要があります。For this, we need to get the SpatialPointerPose from the same time stamp.

SpatialPointerPose^ pose = SpatialPointerPose::TryGetAtTimestamp(currentCoordinateSystem, prediction->Timestamp);

この SpatialPointerPose がに従ってホログラムを配置するための情報、ユーザーの現在の針路します。This SpatialPointerPose has the information needed to position the hologram according to the user's current heading.

快適性の理由から、時間の期間にわたって実行されるように、位置の変更を滑らかにするのに線形補間 ("lerp") を使用します。For reasons of user comfort, we use linear interpolation ("lerp") to smooth the change in position such that it occurs over a period of time. これは、視線の先にホログラムのロックよりも、ユーザーに快適です。This is more comfortable for the user than locking the hologram to their gaze. Lerping tag-along ホログラムの位置では移動; をダンプしてホログラムを安定化することもできます。このダンプ私たちは、ユーザーに通常とは、ユーザーの頭の見えない動きと見なされますためジッター ホログラムと表示されます。Lerping the tag-along hologram's position also allows us to stabilize the hologram by dampening the movement; if we did not do this dampening, the user would see the hologram jitter because of what are normally considered to be imperceptible movements of the user's head.

StationaryQuadRenderer::PositionHologram:From StationaryQuadRenderer::PositionHologram:

   const float& dtime = static_cast<float>(timer.GetElapsedSeconds());

   if (pointerPose != nullptr)
   {
       // Get the gaze direction relative to the given coordinate system.
       const float3 headPosition  = pointerPose->Head->Position;
       const float3 headDirection = pointerPose->Head->ForwardDirection;

       // The tag-along hologram follows a point 2.0m in front of the user's gaze direction.
       static const float distanceFromUser = 2.0f; // meters
       const float3 gazeAtTwoMeters = headPosition + (distanceFromUser * headDirection);

       // Lerp the position, to keep the hologram comfortably stable.
       auto lerpedPosition = lerp(m_position, gazeAtTwoMeters, dtime * c_lerpRate);

       // This will be used as the translation component of the hologram's
       // model transform.
       SetPosition(lerpedPosition);
   }

注意

デバッグのパネルの場合、ビューが隠されることができるように、少し側にオフ ホログラム位置を変更することもできます。In the case of a debugging panel, you might choose to reposition the hologram off to the side a little so that it does not obstruct your view. 次を行う方法の例に示します。Here's an example of how you might do that.

StationaryQuadRenderer::PositionHologram:For StationaryQuadRenderer::PositionHologram:

       // If you're making a debug view, you might not want the tag-along to be directly in the
       // center of your field of view. Use this code to position the hologram to the right of
       // the user's gaze direction.
       /*
       const float3 offset = float3(0.13f, 0.0f, 0.f);
       static const float distanceFromUser = 2.2f; // meters
       const float3 gazeAtTwoMeters = headPosition + (distanceFromUser * (headDirection + offset));
       */

カメラに直面するホログラムを回転させるRotate the hologram to face the camera

単にクワッド; をこの例では、ホログラムを配置するには不十分です。ユーザーが直面するオブジェクトを回転する必要がありますもできます。It is not enough to simply position the hologram, which in this case is a quad; we must also rotate the object to face the user. ビルボード処理のこの型では、ユーザーの環境の一部を維持するホログラムのため、ワールド空間で回転が発生することに注意してください。Note that this rotation occurs in world space, because this type of billboarding allows the hologram to remain a part of the user's environment. ビュー空間ビルボード処理やわらげるできないためはホログラムが画面の向きをロックその場合は、ステレオのレンダリングが妨害しないビュー空間ビルボードのトランス フォームを取得するには左右の view 行列間を補間も必要があります。View-space billboarding is not as comfortable because the hologram becomes locked to the display orientation; in that case, you would also have to interpolate between the left and right view matrices in order to acquire a view-space billboard transform that does not disrupt stereo rendering. ここでは、ユーザーが直面する X、Z 軸に回転させます。Here, we rotate on the X and Z axes to face the user.

StationaryQuadRenderer::Update:From StationaryQuadRenderer::Update:

   // Seconds elapsed since previous frame.
   const float& dTime = static_cast<float>(timer.GetElapsedSeconds());

   // Create a direction normal from the hologram's position to the origin of person space.
   // This is the z-axis rotation.
   XMVECTOR facingNormal = XMVector3Normalize(-XMLoadFloat3(&m_position));

   // Rotate the x-axis around the y-axis.
   // This is a 90-degree angle from the normal, in the xz-plane.
   // This is the x-axis rotation.
   XMVECTOR xAxisRotation = XMVector3Normalize(XMVectorSet(XMVectorGetZ(facingNormal), 0.f, -XMVectorGetX(facingNormal), 0.f));

   // Create a third normal to satisfy the conditions of a rotation matrix.
   // The cross product  of the other two normals is at a 90-degree angle to
   // both normals. (Normalize the cross product to avoid floating-point math
   // errors.)
   // Note how the cross product will never be a zero-matrix because the two normals
   // are always at a 90-degree angle from one another.
   XMVECTOR yAxisRotation = XMVector3Normalize(XMVector3Cross(facingNormal, xAxisRotation));

   // Construct the 4x4 rotation matrix.

   // Rotate the quad to face the user.
   XMMATRIX rotationMatrix = XMMATRIX(
       xAxisRotation,
       yAxisRotation,
       facingNormal,
       XMVectorSet(0.f, 0.f, 0.f, 1.f)
       );

   // Position the quad.
   const XMMATRIX modelTranslation = XMMatrixTranslationFromVector(XMLoadFloat3(&m_position));

   // The view and projection matrices are provided by the system; they are associated
   // with holographic cameras, and updated on a per-camera basis.
   // Here, we provide the model transform for the sample hologram. The model transform
   // matrix is transposed to prepare it for the shader.
   XMStoreFloat4x4(&m_modelConstantBufferData.model, XMMatrixTranspose(rotationMatrix * modelTranslation));

アタッチされたホログラムをレンダリングします。Render the attached hologram

この例では、ホログラムを配置する場所は、SpatialLocatorAttachedReferenceFrame の座標システムでホログラムを表示するために選択もできます。For this example, we also choose to render the hologram in the coordinate system of the SpatialLocatorAttachedReferenceFrame, which is where we positioned the hologram. (別の座標系を使用して表示することにしましたが場合は、必要がありますをその座標系をデバイスに接続された参照フレームの座標システムからの変換を取得します。)(If we had decided to render using another coordinate system, we would need to acquire a transform from the device-attached reference frame's coordinate system to that coordinate system.)

HolographicTagAlongSampleMain::Render:From HolographicTagAlongSampleMain::Render:

   // The view and projection matrices for each holographic camera will change
   // every frame. This function refreshes the data in the constant buffer for
   // the holographic camera indicated by cameraPose.
   pCameraResources->UpdateViewProjectionBuffer(
       m_deviceResources,
       cameraPose,
       m_referenceFrame->GetStationaryCoordinateSystemAtTimestamp(prediction->Timestamp)
       );

以上で作業は終了です。That's it! ホログラムはようになりました「追跡」ユーザーの視線入力方向の前に 2 つのメーターの位置。The hologram will now "chase" a position that is 2 meters in front of the user's gaze direction.

注意

この例は、またその他のコンテンツを読み込みます - StationaryQuadRenderer.cpp を参照してください。This example also loads additional content - see StationaryQuadRenderer.cpp.

処理の追跡が失われるHandling tracking loss

デバイスは、世界で自体を見つけられない、アプリで"追跡損失"が発生します。When the device cannot locate itself in the world, the app experiences "tracking loss". Windows Mixed Reality アプリでは、位置指定の追跡システムには、このような中断を処理できる必要があります。Windows Mixed Reality apps should be able to handle such disruptions to the positional tracking system. これらの中断が見られることと既定 SpatialLocator LocatabilityChanged イベントを使用して、応答を作成します。These disruptions can be observed, and responses created, by using the LocatabilityChanged event on the default SpatialLocator.

AppMain::SetHolographicSpace:From AppMain::SetHolographicSpace:

   // Be able to respond to changes in the positional tracking state.
   m_locatabilityChangedToken =
       m_locator->LocatabilityChanged +=
           ref new Windows::Foundation::TypedEventHandler<SpatialLocator^, Object^>(
               std::bind(&HolographicApp1Main::OnLocatabilityChanged, this, _1, _2)
               );

アプリが LocatabilityChanged イベントを受け取るときに、必要に応じて、動作を変更できます。When your app receives a LocatabilityChanged event, it can change behavior as needed. など PositionalTrackingInhibited 状態でアプリは通常の操作を一時停止し、レンダリング、 tag-along ホログラム警告メッセージを表示します。For example, in the PositionalTrackingInhibited state, your app can pause normal operation and render a tag-along hologram that displays a warning message.

Windows Holographic のアプリ テンプレートが付属 LocatabilityChanged ハンドラーが既に自動的に作成します。The Windows Holographic app template comes with a LocatabilityChanged handler already created for you. 既定では、その警告が表示されます、デバッグ コンソールで位置指定の追跡が使用できない場合。By default, it displays a warning in the debug console when positional tracking is unavailable. 必要に応じて、アプリからの応答を提供するには、このハンドラーにコードを追加することができます。You can add code to this handler to provide a response as needed from your app.

AppMain.cpp:From AppMain.cpp:

   void HolographicApp1Main::OnLocatabilityChanged(SpatialLocator^ sender, Object^ args)
   {
       switch (sender->Locatability)
       {
       case SpatialLocatability::Unavailable:
           // Holograms cannot be rendered.
           {
               String^ message = L"Warning! Positional tracking is " +
                                           sender->Locatability.ToString() + L".\n";
               OutputDebugStringW(message->Data());
           }
           break;

       // In the following three cases, it is still possible to place holograms using a
       // SpatialLocatorAttachedFrameOfReference.
       case SpatialLocatability::PositionalTrackingActivating:
           // The system is preparing to use positional tracking.

       case SpatialLocatability::OrientationOnly:
           // Positional tracking has not been activated.

       case SpatialLocatability::PositionalTrackingInhibited:
           // Positional tracking is temporarily inhibited. User action may be required
           // in order to restore positional tracking.
           break;

       case SpatialLocatability::PositionalTrackingActive:
           // Positional tracking is active. World-locked content can be rendered.
           break;
       }
   }

空間マッピングSpatial mapping

空間マッピングApi を使用する画面のメッシュのモデルの変換を取得する座標系を使用します。The spatial mapping APIs make use of coordinate systems to get model transforms for surface meshes.

関連項目See also