微软hololens学院教程-hologram230-空间映射（spatialmapping）

using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Windows.Speech;
using HoloToolkit.Unity;

/// <summary>
/// The SurfaceManager class allows applications to scan the environment for a specified amount of time 
/// and then process the Spatial Mapping Mesh (find planes, remove vertices) after that time has expired.
/// </summary>
public class PlaySpaceManager : Singleton<PlaySpaceManager>
{
    [Tooltip("When checked, the SurfaceObserver will stop running after a specified amount of time.")]
    public bool limitScanningByTime = true;

    [Tooltip("How much time (in seconds) that the SurfaceObserver will run after being started; used when 'Limit Scanning By Time' is checked.")]
    public float scanTime = 30.0f;

    [Tooltip("Material to use when rendering Spatial Mapping meshes while the observer is running.")]
    public Material defaultMaterial;

    [Tooltip("Optional Material to use when rendering Spatial Mapping meshes after the observer has been stopped.")]
    public Material secondaryMaterial;

    [Tooltip("Minimum number of floor planes required in order to exit scanning/processing mode.")]
    public uint minimumFloors = 1;

    [Tooltip("Minimum number of wall planes required in order to exit scanning/processing mode.")]
    public uint minimumWalls = 1;

    /// <summary>
    /// Indicates if processing of the surface meshes is complete.
    /// </summary>
    private bool meshesProcessed = false;

    /// <summary>
    /// GameObject initialization.
    /// </summary>
    private void Start()
    {
        // Update surfaceObserver and storedMeshes to use the same material during scanning.
        SpatialMappingManager.Instance.SetSurfaceMaterial(defaultMaterial);

        // Register for the MakePlanesComplete event.
        SurfaceMeshesToPlanes.Instance.MakePlanesComplete += SurfaceMeshesToPlanes_MakePlanesComplete;
    }

    /// <summary>
    /// Called once per frame.
    /// </summary>
    private void Update()
    {
        // Check to see if the spatial mapping data has been processed
        // and if we are limiting how much time the user can spend scanning.
        if (!meshesProcessed && limitScanningByTime)
        {
            // If we have not processed the spatial mapping data
            // and scanning time is limited...

            // Check to see if enough scanning time has passed
            // since starting the observer.
            if (limitScanningByTime && ((Time.time - SpatialMappingManager.Instance.StartTime) < scanTime))
            {
                // If we have a limited scanning time, then we should wait until
                // enough time has passed before processing the mesh.
            }
            else
            {
                // The user should be done scanning their environment,
                // so start processing the spatial mapping data...

                /* TODO: 3.a DEVELOPER CODING EXERCISE 3.a */

                // 3.a: Check if IsObserverRunning() is true on the
                // SpatialMappingManager.Instance.
                if(SpatialMappingManager.Instance.IsObserverRunning())
                {
                    // 3.a: If running, Stop the observer by calling
                    // StopObserver() on the SpatialMappingManager.Instance.
                    SpatialMappingManager.Instance.StopObserver();
                }

                // 3.a: Call CreatePlanes() to generate planes.
                CreatePlanes();

                // 3.a: Set meshesProcessed to true.
                meshesProcessed = true;
            }
        }
    }

    /// <summary>
    /// Handler for the SurfaceMeshesToPlanes MakePlanesComplete event.
    /// </summary>
    /// <param name="source">Source of the event.</param>
    /// <param name="args">Args for the event.</param>
    private void SurfaceMeshesToPlanes_MakePlanesComplete(object source, System.EventArgs args)
    {
        /* TODO: 3.a DEVELOPER CODING EXERCISE 3.a */

        // Collection of floor and table planes that we can use to set horizontal items on.
        List<GameObject> horizontal = new List<GameObject>();

        // Collection of wall planes that we can use to set vertical items on.
        List<GameObject> vertical = new List<GameObject>();

        // 3.a: Get all floor and table planes by calling
        // SurfaceMeshesToPlanes.Instance.GetActivePlanes().
        // Assign the result to the 'horizontal' list.
        horizontal = SurfaceMeshesToPlanes.Instance.GetActivePlanes(PlaneTypes.Table | PlaneTypes.Floor);

        // 3.a: Get all wall planes by calling
        // SurfaceMeshesToPlanes.Instance.GetActivePlanes().
        // Assign the result to the 'vertical' list.
        vertical = SurfaceMeshesToPlanes.Instance.GetActivePlanes(PlaneTypes.Wall);

        // Check to see if we have enough horizontal planes (minimumFloors)
        // and vertical planes (minimumWalls), to set holograms on in the world.
        if (horizontal.Count >= minimumFloors && vertical.Count >= minimumWalls)
        {
            // We have enough floors and walls to place our holograms on...

            // 3.a: Let's reduce our triangle count by removing triangles
            // from SpatialMapping meshes that intersect with our active planes.
            // Call RemoveVertices().
            // Pass in all activePlanes found by SurfaceMeshesToPlanes.Instance.
            RemoveVertices(SurfaceMeshesToPlanes.Instance.ActivePlanes);

            // 3.a: We can indicate to the user that scanning is over by
            // changing the material applied to the Spatial Mapping meshes.
            // Call SpatialMappingManager.Instance.SetSurfaceMaterial().
            // Pass in the secondaryMaterial.
            SpatialMappingManager.Instance.SetSurfaceMaterial(secondaryMaterial);

            // 3.a: We are all done processing the mesh, so we can now
            // initialize a collection of Placeable holograms in the world
            // and use horizontal/vertical planes to set their starting positions.
            // Call SpaceCollectionManager.Instance.GenerateItemsInWorld().
            // Pass in the lists of horizontal and vertical planes that we found earlier.
            SpaceCollectionManager.Instance.GenerateItemsInWorld(horizontal, vertical);
        }
        else
        {
            // We do not have enough floors/walls to place our holograms on...

            // 3.a: Re-enter scanning mode so the user can find more surfaces by 
            // calling StartObserver() on the SpatialMappingManager.Instance.
            SpatialMappingManager.Instance.StartObserver();

            // 3.a: Re-process spatial data after scanning completes by
            // re-setting meshesProcessed to false.
            meshesProcessed = false;
        }
    }

    /// <summary>
    /// Creates planes from the spatial mapping surfaces.
    /// </summary>
    private void CreatePlanes()
    {
        // Generate planes based on the spatial map.
        SurfaceMeshesToPlanes surfaceToPlanes = SurfaceMeshesToPlanes.Instance;
        if (surfaceToPlanes != null && surfaceToPlanes.enabled)
        {
            surfaceToPlanes.MakePlanes();
        }
    }

    /// <summary>
    /// Removes triangles from the spatial mapping surfaces.
    /// </summary>
    /// <param name="boundingObjects"></param>
    private void RemoveVertices(IEnumerable<GameObject> boundingObjects)
    {
        RemoveSurfaceVertices removeVerts = RemoveSurfaceVertices.Instance;
        if (removeVerts != null && removeVerts.enabled)
        {
            removeVerts.RemoveSurfaceVerticesWithinBounds(boundingObjects);
        }
    }

    /// <summary>
    /// Called when the GameObject is unloaded.
    /// </summary>
    private void OnDestroy()
    {
        if (SurfaceMeshesToPlanes.Instance != null)
        {
            SurfaceMeshesToPlanes.Instance.MakePlanesComplete -= SurfaceMeshesToPlanes_MakePlanesComplete;
        }
    }
}

using System.Collections.Generic;
using UnityEngine;
using HoloToolkit.Unity;

/// <summary>
/// Enumeration containing the surfaces on which a GameObject
/// can be placed.  For simplicity of this sample, only one
/// surface type is allowed to be selected.
/// </summary>
public enum PlacementSurfaces
{
    // Horizontal surface with an upward pointing normal.    
    Horizontal  = 1,

    // Vertical surface with a normal facing the user.
    Vertical    = 2,
}

/// <summary>
/// The Placeable class implements the logic used to determine if a GameObject
/// can be placed on a target surface. Constraints for placement include:
/// * No part of the GameObject's box collider impacts with another object in the scene
/// * The object lays flat (within specified tolerances) against the surface
/// * The object would not fall off of the surface if gravity were enabled.
/// This class also provides the following visualizations.
/// * A transparent cube representing the object's box collider.
/// * Shadow on the target surface indicating whether or not placement is valid.
/// </summary>
public class Placeable : MonoBehaviour 
{
    [Tooltip("The base material used to render the bounds asset when placement is allowed.")]
    public Material PlaceableBoundsMaterial = null;

    [Tooltip("The base material used to render the bounds asset when placement is not allowed.")]
    public Material NotPlaceableBoundsMaterial = null;

    [Tooltip("The material used to render the placement shadow when placement it allowed.")]
    public Material PlaceableShadowMaterial = null;

    [Tooltip("The material used to render the placement shadow when placement it not allowed.")]
    public Material NotPlaceableShadowMaterial = null;

    [Tooltip("The type of surface on which the object can be placed.")]
    public PlacementSurfaces PlacementSurface = PlacementSurfaces.Horizontal;

    [Tooltip("The child object(s) to hide during placement.")]
    public List<GameObject> ChildrenToHide = new List<GameObject>();

    /// <summary>
    /// Indicates if the object is in the process of being placed.
    /// </summary>
    public bool IsPlacing { get; private set; }

    // The most recent distance to the surface.  This is used to 
    // locate the object when the user's gaze does not intersect
    // with the Spatial Mapping mesh.
    private float lastDistance = 2.0f;

    // The distance away from the target surface that the object should hover prior while being placed.
    private float hoverDistance = 0.15f;

    // Threshold (the closer to 0, the stricter the standard) used to determine if a surface is flat.
    private float distanceThreshold = 0.02f;

    // Threshold (the closer to 1, the stricter the standard) used to determine if a surface is vertical.
    private float upNormalThreshold = 0.9f;

    // Maximum distance, from the object, that placement is allowed.
    // This is used when raycasting to see if the object is near a placeable surface.
    private float maximumPlacementDistance = 5.0f;

    // Speed (1.0 being fastest) at which the object settles to the surface upon placement.
    private float placementVelocity = 0.06f;

    // Indicates whether or not this script manages the object's box collider.
    private bool managingBoxCollider = false;

    // The box collider used to determine of the object will fit in the desired location.
    // It is also used to size the bounding cube.
    private BoxCollider boxCollider = null;

    // Visible asset used to show the dimensions of the object. This asset is sized
    // using the box collider's bounds.
    private GameObject boundsAsset = null;

    // Visible asset used to show the where the object is attempting to be placed.
    // This asset is sized using the box collider's bounds.
    private GameObject shadowAsset = null;

    // The location at which the object will be placed.
    private Vector3 targetPosition;

    /// <summary>
    /// Called when the GameObject is created.
    /// </summary>
    private void Awake()
    {
        targetPosition = gameObject.transform.position;

        // Get the object's collider.
        boxCollider = gameObject.GetComponent<BoxCollider>();
        if (boxCollider == null)
        {
            // The object does not have a collider, create one and remember that
            // we are managing it.
            managingBoxCollider = true;
            boxCollider = gameObject.AddComponent<BoxCollider>();
            boxCollider.enabled = false;
        }

        // Create the object that will be used to indicate the bounds of the GameObject.
        boundsAsset = GameObject.CreatePrimitive(PrimitiveType.Cube);
        boundsAsset.transform.parent = gameObject.transform;
        boundsAsset.SetActive(false);

        // Create a object that will be used as a shadow.
        shadowAsset = GameObject.CreatePrimitive(PrimitiveType.Quad);
        shadowAsset.transform.parent = gameObject.transform;
        shadowAsset.SetActive(false);
    }

    /// <summary>
    /// Called when our object is selected.  Generally called by
    /// a gesture management component.
    /// </summary>
    public void OnSelect()
    {
        /* TODO: 4.a CODE ALONG 4.a */

        if (!IsPlacing)
        {
            OnPlacementStart();
        }
        else
        {
            OnPlacementStop();
        }
    }

    /// <summary>
    /// Called once per frame.
    /// </summary>
    private void Update()
    {
        /* TODO: 4.a CODE ALONG 4.a */

        if (IsPlacing)
        {
            // Move the object.
            Move();

            // Set the visual elements.
            Vector3 targetPosition;
            Vector3 surfaceNormal;
            bool canBePlaced = ValidatePlacement(out targetPosition, out surfaceNormal);
            DisplayBounds(canBePlaced);
            DisplayShadow(targetPosition, surfaceNormal, canBePlaced);
        }
        else
        {
            // Disable the visual elements.
            boundsAsset.SetActive(false);
            shadowAsset.SetActive(false);

            // Gracefully place the object on the target surface.
            float dist = (gameObject.transform.position - targetPosition).magnitude;
            if (dist > 0)
            {
                gameObject.transform.position = Vector3.Lerp(gameObject.transform.position, targetPosition, placementVelocity / dist);
            }
            else
            {
                // Unhide the child object(s) to make placement easier.
                for (int i = 0; i < ChildrenToHide.Count; i++)
                {
                    ChildrenToHide[i].SetActive(true);
                }
            }
        }
    }

    /// <summary>
    /// Verify whether or not the object can be placed.
    /// </summary>
    /// <param name="position">
    /// The target position on the surface.
    /// </param>
    /// <param name="surfaceNormal">
    /// The normal of the surface on which the object is to
微软hololens学院教程-hologram211-gestures（手势）
用户操作Hololens的全息对象时需要借助手势，手势的点击类似于我们电脑的鼠标，当我们凝视到某个全息对象时，手势点击即可以得到相应的反馈。这节教程主要讲述如何追踪用户的手势，并对手势操作做出反馈。这节对手势操...  查看详情  
                
微软hololens学院教程-hologram230-空间映射（spatialmapping）
空间映射地图是将真实环境的环境信息扫描到设备中，使得全息对象可以识别真实场景环境，从而达到可以将虚拟对象与真实世界相结合的效果。这节教程主要学习内容如下：使用Hololens扫描空间环境并将空间数据导入到开发计...  查看详情  
                
微软hololens学院教程-hologramgaze（凝视）
Hololens的使用如果类比到计算机的使用，在输入操作方面，Hololens了解用户的操作意图的第一个步骤是凝视，用户的凝视射线呈现在场景中的点为凝视点，就好像是电脑中的鼠标光标点，凝视是第一步，是人与hololens操作的开始。...  查看详情  
                
hololens官方教程精简版-04.gesture（手势）
...言注意：本文已更新到5.5.1f1版本个人建议，学习Holograms211之前，一定完成《Hololens官方教程精简版-02.IntroductionwithDevice》的学习。本篇集中学习手势功能，完成以下目标：-是否已检测到手势动作-使用导航手势...  查看详情  
                
hololens官方教程精简版-06.spatialsound（空间声音）
...言注意：本文已更新到5.5.1f1版本个人建议，学习Holograms220之前，一定完成《Hololens官方教程精简版-02.IntroductionwithDevice》的学习。本篇集中学习空间声音功能，完成以下目标：-感受空间声音-感受声音被遮挡的...  查看详情  
                
hololens官方教程精简版-03.gaze（凝视）(代码片段)
...言注意：本文已更新到5.5.1f1版本个人建议，学习Holograms210之前，一定完成《Hololens官方教程精简版-02.IntroductionwithDevice》的学习。本篇集中学习凝视功能，完成以下目标：让物体感知凝视凝视被感知后，给...  查看详情  
                
hololens官方教程精简版-05.voice（语音）(代码片段)
...言注意：本文已更新到5.5.1f1版本个人建议，学习Holograms212之前，一定完成《Hololens官方教程精简版-02.IntroductionwithDevice》的学习。本篇集中学习语音功能，完成以下目标：-语音命令（目前仅支持英文）-...  查看详情  
                
hololens官方教程精简版-02.introductionwithdevice(代码片段)
...注意：本文已更新到5.5.1f1版本个人认为，官方的Holograms101教程是该系列最重要的一篇。这里面包含了几乎所有Hololens的特征：凝视、手势、声音输入、空间声音、空间映射。准备工作按《Hololens官方教程精简版-01.Gettin...  查看详情  
                
hololens官方教程精简版-02.introductionwithdevice(代码片段)
...注意：本文已更新到5.5.1f1版本个人认为，官方的Holograms101教程是该系列最重要的一篇。这里面包含了几乎所有Hololens的特征：凝视、手势、声音输入、空间声音、空间映射。准备工作按《Hololens官方教程精简版-01.Gettin...  查看详情  
                
hololens官方教程精简版-04.gesture（手势）
...言注意：本文已更新到5.5.1f1版本个人建议，学习Holograms211之前，一定完成《Hololens官方教程精简版-02.IntroductionwithDevice》的学习。本篇集中学习手势功能，完成以下目标：-是否已检测到手势动作-使用导航手势...  查看详情  
                
HoloLens 空间映射不可用
...教程MRBasics101：https://docs.microsoft.com/en-us/windows/mixed-reality/holograms-101并按照本文中的建议设置所有内容：https://docs.microsoft.com/e  查看详情  
                
hololens官方教程精简版-06.spatialsound（空间声音）
...言注意：本文已更新到5.5.1f1版本个人建议，学习Holograms220之前，一定完成《Hololens官方教程精简版-02.IntroductionwithDevice》的学习。本篇集中学习空间声音功能，完成以下目标：-感受空间声音-感受声音被遮挡的...  查看详情  
                
hololens官方教程精简版-07.spatialmapping（空间映射）(代码片段)
...言注意：本文已更新到5.5.1f1版本个人建议，学习Holograms230之前，一定完成《Hololens官方教程精简版-02.IntroductionwithDevice》的学习。本篇集中学习空间映射功能，完成以下目标：Chapter1-空间扫描目标完成空间扫描...  查看详情  
                
hololens官方教程精简版-03.gaze（凝视）(代码片段)
...言注意：本文已更新到5.5.1f1版本个人建议，学习Holograms210之前，一定完成《Hololens官方教程精简版-02.IntroductionwithDevice》的学习。本篇集中学习凝视功能，完成以下目标：让物体感知凝视凝视被感知后，给...  查看详情  
                
hololens开发入门简介
 Holograms100本教程将引导您使用Unity构建基本全息应用程序。这个项目可作为您希望在Unity中构建的任何全息应用程序的起始模板。预备知识已经利用安装工具正确配置的Windows10PC。目录1第 1章 –创建新项目2第 2章&n...  查看详情  
                
如何在模拟器里体验微软hololens
众所周知，微软的HoloLens以及MR设备售价都比较高，这让不少感兴趣的朋友们望而却步，本篇教程将向大家介绍如何在模拟器里体验传说中的HoloLens。 1、需要准备的硬件：智能手机一台（WP、Android、iOS均可）；CPU支持二级地...  查看详情  
                
hololens微软hololens虚拟现实视频集
 混合虚拟现实（Hololens眼镜） 微软还是混合虚拟现实的行业领导者，Hololens眼镜在很多行业有了令人印象深刻的应用和演示。譬如：Hololens中文宣传片：https://pan.baidu.com/s/1jHRcD0MHololens展现无限可能（中文）https://pan.baidu.co...  查看详情  
                
微软hololens遭遇失败，前途何在？
...ogs.com/SpencerGong）   Intel最近宣布，用于微软的HoloLens设备中的“全息处理单元”(HPU)——Atomex5-Z8100P处理器，最后的下单时间为9月30日，出货截止时间为10月30日，之后就完全停产。微软Hololens遭遇失败，前途何在？图1Ho...  查看详情