SpatialMappingSource.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;
using UnityEngine.Rendering;

namespace HoloToolkit.Unity.SpatialMapping
{
    public class SpatialMappingSource : MonoBehaviour
    {
        public struct SurfaceObject
        {
            public int ID;
            public GameObject Object;
            public MeshRenderer Renderer;
            public MeshFilter Filter;
            public MeshCollider Collider;
        }

        public struct SurfaceUpdate
        {
            public SurfaceObject Old;
            public SurfaceObject New;
        }

        public ReadOnlyCollection<SurfaceObject> SurfaceObjects
        {
            get { return surfaceObjects; }
        }

        public event EventHandler<DataEventArgs<SurfaceObject>> SurfaceAdded;
        public event EventHandler<DataEventArgs<SurfaceUpdate>> SurfaceUpdated;
        public event EventHandler<DataEventArgs<SurfaceObject>> SurfaceRemoved;
        public event EventHandler<EventArgs> RemovingAllSurfaces;

        protected readonly Type[] componentsRequiredForSurfaceMesh =
        {
            typeof(MeshFilter),
            typeof(MeshRenderer),
            typeof(MeshCollider)
        };

        protected virtual Material RenderMaterial { get { return SpatialMappingManager.Instance.SurfaceMaterial; } }

        private readonly List<SurfaceObject> surfaceObjectsWriteable;
        private readonly ReadOnlyCollection<SurfaceObject> surfaceObjects;

        public SpatialMappingSource()
        {
            surfaceObjectsWriteable = new List<SurfaceObject>();
            surfaceObjects = new ReadOnlyCollection<SurfaceObject>(surfaceObjectsWriteable);
        }

        protected virtual void Awake()
        {
            // Nothing.
        }

        protected SurfaceObject CreateSurfaceObject(
            Mesh mesh,
            string objectName,
            Transform parentObject,
            int meshID = 0,
            bool? drawVisualMeshesOverride = null,
            bool? castShadowsOverride = null
            )
        {
            SurfaceObject surfaceObject = new SurfaceObject();
            surfaceObject.ID = meshID;

            surfaceObject.Object = new GameObject(objectName, componentsRequiredForSurfaceMesh);
            surfaceObject.Object.transform.SetParent(parentObject);
            surfaceObject.Object.layer = SpatialMappingManager.Instance.PhysicsLayer;

            surfaceObject.Filter = surfaceObject.Object.GetComponent<MeshFilter>();
            surfaceObject.Filter.sharedMesh = mesh;

            surfaceObject.Renderer = surfaceObject.Object.GetComponent<MeshRenderer>();
            surfaceObject.Renderer.sharedMaterial = RenderMaterial;
            surfaceObject.Renderer.enabled = (drawVisualMeshesOverride ?? SpatialMappingManager.Instance.DrawVisualMeshes);
            surfaceObject.Renderer.shadowCastingMode = ((castShadowsOverride ?? SpatialMappingManager.Instance.CastShadows) ? ShadowCastingMode.On : ShadowCastingMode.Off);

            surfaceObject.Collider = surfaceObject.Object.GetComponent<MeshCollider>();

            // Reset the surface mesh collider to fit the updated mesh. 
            // Unity tribal knowledge indicates that to change the mesh assigned to a
            // mesh collider, the mesh must first be set to null.  Presumably there
            // is a side effect in the setter when setting the shared mesh to null.
            surfaceObject.Collider.sharedMesh = null;
            surfaceObject.Collider.sharedMesh = surfaceObject.Filter.sharedMesh;

            return surfaceObject;
        }

        protected void AddSurfaceObject(SurfaceObject toAdd)
        {
            surfaceObjectsWriteable.Add(toAdd);

            var handlers = SurfaceAdded;
            if (handlers != null)
            {
                handlers(this, DataEventArgs.Create(toAdd));
            }
        }

        protected SurfaceObject? UpdateOrAddSurfaceObject(SurfaceObject toUpdateOrAdd, bool destroyGameObjectIfReplaced = true, bool destroyMeshesIfReplaced = true)
        {
            SurfaceObject? replaced = null;

            for (int iSurface = 0; iSurface < surfaceObjectsWriteable.Count; iSurface++)
            {
                SurfaceObject existing = surfaceObjectsWriteable[iSurface];

                if (existing.ID == toUpdateOrAdd.ID)
                {
                    surfaceObjectsWriteable[iSurface] = toUpdateOrAdd;

                    var handlers = SurfaceUpdated;
                    if (handlers != null)
                    {
                        handlers(this, DataEventArgs.Create(new SurfaceUpdate { Old = existing, New = toUpdateOrAdd }));
                    }

                    CleanUpSurface(
                        existing,
                        destroyGameObjectIfReplaced,
                        destroyMeshesIfReplaced,
                        objectToPreserve: toUpdateOrAdd.Object,
                        meshToPreserveA: toUpdateOrAdd.Filter.sharedMesh,
                        meshToPreserveB: toUpdateOrAdd.Collider.sharedMesh
                        );

                    replaced = existing;
                    break;
                }
            }

            if (replaced == null)
            {
                AddSurfaceObject(toUpdateOrAdd);
            }

            return replaced;
        }

        protected SurfaceObject? RemoveSurfaceIfFound(int surfaceID, bool destroyGameObject = true, bool destroyMeshes = true)
        {
            SurfaceObject? removed = null;

            for (int iSurface = 0; iSurface < surfaceObjectsWriteable.Count; iSurface++)
            {
                SurfaceObject surface = surfaceObjectsWriteable[iSurface];

                if (surface.ID == surfaceID)
                {
                    surfaceObjectsWriteable.RemoveAt(iSurface);

                    var handlers = SurfaceRemoved;
                    if (handlers != null)
                    {
                        handlers(this, DataEventArgs.Create(surface));
                    }

                    CleanUpSurface(surface, destroyGameObject, destroyMeshes);

                    removed = surface;
                    break;
                }
            }

            return removed;
        }

        protected void CleanUpSurface(
            SurfaceObject surface,
            bool destroyGameObject = true,
            bool destroyMeshes = true,
            GameObject objectToPreserve = null,
            Mesh meshToPreserveA = null,
            Mesh meshToPreserveB = null
            )
        {
            if (destroyGameObject
                && (surface.Object != null)
                && (surface.Object != objectToPreserve)
                )
            {
                Destroy(surface.Object);
                Debug.Assert(surface.GetType().IsValueType(), "If surface is no longer a value type, you should probably set surface.Object to null.");
            }

            Mesh filterMesh = surface.Filter.sharedMesh;
            Mesh colliderMesh = surface.Collider.sharedMesh;

            if (destroyMeshes
                && (filterMesh != null)
                && (filterMesh != meshToPreserveA)
                && (filterMesh != meshToPreserveB)
                )
            {
                Destroy(filterMesh);
                surface.Filter.sharedMesh = null;
            }

            if (destroyMeshes
                && (colliderMesh != null)
                && (colliderMesh != filterMesh)
                && (colliderMesh != meshToPreserveA)
                && (colliderMesh != meshToPreserveB)
                )
            {
                Destroy(colliderMesh);
                surface.Collider.sharedMesh = null;
            }
        }

        protected void Cleanup(bool destroyGameObjects = true, bool destroyMeshes = true)
        {
            var handlers = RemovingAllSurfaces;
            if (handlers != null)
            {
                handlers(this, EventArgs.Empty);
            }

            for (int index = 0; index < surfaceObjectsWriteable.Count; index++)
            {
                CleanUpSurface(surfaceObjectsWriteable[index], destroyGameObjects, destroyMeshes);
            }
            surfaceObjectsWriteable.Clear();
        }

        public virtual List<MeshFilter> GetMeshFilters()
        {
            List<MeshFilter> meshFilters = new List<MeshFilter>();

            for (int index = 0; index < surfaceObjectsWriteable.Count; index++)
            {
                if (surfaceObjectsWriteable[index].Filter != null &&
                    surfaceObjectsWriteable[index].Filter.sharedMesh != null &&
                    surfaceObjectsWriteable[index].Filter.sharedMesh.vertexCount > 2)
                {
                    meshFilters.Add(surfaceObjectsWriteable[index].Filter);
                }
            }

            return meshFilters;
        }

        public virtual List<MeshRenderer> GetMeshRenderers()
        {
            List<MeshRenderer> meshRenderers = new List<MeshRenderer>();

            for (int index = 0; index < surfaceObjectsWriteable.Count; index++)
            {
                if (surfaceObjectsWriteable[index].Renderer != null)
                {
                    meshRenderers.Add(surfaceObjectsWriteable[index].Renderer);
                }
            }

            return meshRenderers;
        }

        public void SaveSpatialMeshes(string fileName)
        {
            MeshSaver.Save(fileName, GetMeshFilters());
        }
    }
}