SpatialMappingManager.cs

Go to the documentation of this file.

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See LICENSE in the project root for license information.

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using UnityEngine;

namespace HoloToolkit.Unity.SpatialMapping
{
    [RequireComponent(typeof(SpatialMappingObserver))]
    public partial class SpatialMappingManager : Singleton<SpatialMappingManager>
    {
        [Tooltip("The physics layer for spatial mapping objects to be set to.")]
        public int PhysicsLayer = 31;

        [Tooltip("The material to use for rendering spatial mapping data.")]
        [SerializeField]
        private Material surfaceMaterial;

        [Tooltip("Determines if the surface observer should be automatically started.")]
        [SerializeField]
        private bool autoStartObserver = true;

        [Tooltip("Determines if spatial mapping data will be rendered.")]
        [SerializeField]
        private bool drawVisualMeshes = false;

        [Tooltip("Determines if spatial mapping data will cast shadows.")]
        [SerializeField]
        private bool castShadows = false;

        private SpatialMappingObserver surfaceObserver;

        public float StartTime { get; private set; }

        public SpatialMappingObserver SurfaceObserver { get { return surfaceObserver; } }

        public SpatialMappingSource Source
        {
            get { return source; }

            private set
            {
                if (source != value)
                {
                    UpdateRendering(false);

                    var oldSource = source;
                    source = value;

                    UpdateRendering(DrawVisualMeshes);

                    var handlers = SourceChanged;
                    if (handlers != null)
                    {
                        handlers(this, PropertyChangedEventArgsEx.Create(() => Source, oldSource, source));
                    }
                }
            }
        }
        private SpatialMappingSource source;

        public event EventHandler<PropertyChangedEventArgsEx<SpatialMappingSource>> SourceChanged;

        // Called when the GameObject is first created.
        protected override void Awake()
        {
            base.Awake();

            surfaceObserver = gameObject.GetComponent<SpatialMappingObserver>();
            Source = surfaceObserver;
        }

        // Use for initialization.
        private void Start()
        {
            if (autoStartObserver)
            {
                StartObserver();
            }
        }

        public int LayerMask
        {
            get { return (1 << PhysicsLayer); }
        }

        public Material SurfaceMaterial
        {
            get
            {
                return surfaceMaterial;
            }
            set
            {
                if (value != surfaceMaterial)
                {
                    surfaceMaterial = value;
                    SetSurfaceMaterial(surfaceMaterial);
                }
            }
        }

        public bool DrawVisualMeshes
        {
            get
            {
                return drawVisualMeshes;
            }
            set
            {
                if (value != drawVisualMeshes)
                {
                    drawVisualMeshes = value;
                    UpdateRendering(drawVisualMeshes);
                }
            }
        }

        public bool CastShadows
        {
            get
            {
                return castShadows;
            }
            set
            {
                if (value != castShadows)
                {
                    castShadows = value;
                    SetShadowCasting(castShadows);
                }
            }
        }

        public void SetSpatialMappingSource(SpatialMappingSource mappingSource)
        {
            Source = (mappingSource ?? surfaceObserver);
        }

        public void SetSurfaceMaterial(Material setSurfaceMaterial)
        {
            SurfaceMaterial = setSurfaceMaterial;
            if (DrawVisualMeshes)
            {
                foreach (MeshRenderer sourceRenderer in Source.GetMeshRenderers())
                {
                    if (sourceRenderer != null)
                    {
                        sourceRenderer.sharedMaterial = setSurfaceMaterial;
                    }
                }
            }
        }

        public bool IsObserverRunning()
        {
            return surfaceObserver.ObserverState == ObserverStates.Running;
        }

        public void StartObserver()
        {
#if UNITY_WSA
            // Allow observing if a device is present (Holographic Remoting)
#if UNITY_2017_2_OR_NEWER
            if (!UnityEngine.XR.XRDevice.isPresent) { return; }
#else
            if (!UnityEngine.VR.VRDevice.isPresent) { return; }
#endif
#endif
            if (!IsObserverRunning())
            {
                surfaceObserver.StartObserving();
                StartTime = Time.unscaledTime;
            }
        }

        public void StopObserver()
        {
#if UNITY_WSA
            // Allow observing if a device is present (Holographic Remoting)
#if UNITY_2017_2_OR_NEWER
            if (!UnityEngine.XR.XRDevice.isPresent) { return; }
#else
            if (!UnityEngine.VR.VRDevice.isPresent) { return; }
#endif
#endif
            if (IsObserverRunning())
            {
                surfaceObserver.StopObserving();
            }
        }

        public void CleanupObserver()
        {
            surfaceObserver.CleanupObserver();
        }

        public List<Mesh> GetMeshes()
        {
            List<Mesh> meshes = new List<Mesh>();
            List<MeshFilter> meshFilters = GetMeshFilters();

            // Get all valid mesh filters for observed surfaces.
            for (int i = 0; i < meshFilters.Count; i++)
            {
                // GetMeshFilters ensures that both filter and filter.sharedMesh are not null.
                meshes.Add(meshFilters[i].sharedMesh);
            }

            return meshes;
        }

        public ReadOnlyCollection<SpatialMappingSource.SurfaceObject> GetSurfaceObjects()
        {
            return Source.SurfaceObjects;
        }

        public List<MeshFilter> GetMeshFilters()
        {
            return Source.GetMeshFilters();
        }

        private void SetShadowCasting(bool canCastShadows)
        {
            CastShadows = canCastShadows;
            foreach (MeshRenderer sourceRenderer in Source.GetMeshRenderers())
            {
                if (sourceRenderer != null)
                {
                    if (canCastShadows)
                    {
                        sourceRenderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.On;
                    }
                    else
                    {
                        sourceRenderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
                    }
                }
            }
        }

        private void UpdateRendering(bool enable)
        {
            if (Source != null)
            {
                List<MeshRenderer> renderers = Source.GetMeshRenderers();
                for (int index = 0; index < renderers.Count; index++)
                {
                    if (renderers[index] != null)
                    {
                        renderers[index].enabled = enable;
                        if (enable)
                        {
                            renderers[index].sharedMaterial = SurfaceMaterial;
                        }
                    }
                }
            }
        }
    }
}