/// <summary>
    /// Extract and update (or create, if it doesn't exist) the mesh at the given grid index.
    /// </summary>
    /// <param name="gridIndex">Grid index.</param>
    /// <param name="needsResize">List to which indicies needing a future resize will be added.</param>
    private void _UpdateMeshAtGridIndex(Tango3DReconstruction.GridIndex gridIndex, List <Tango3DReconstruction.GridIndex> needsResize)
    {
        TangoSingleDynamicMesh dynamicMesh;

        if (!m_meshes.TryGetValue(gridIndex, out dynamicMesh))
        {
            // build a dynamic mesh as a child of this game object.
            GameObject newObj = new GameObject();
            newObj.transform.parent = transform;
            newObj.name             = string.Format("{0},{1},{2}", gridIndex.x, gridIndex.y, gridIndex.z);
            newObj.layer            = gameObject.layer;
            dynamicMesh             = newObj.AddComponent <TangoSingleDynamicMesh>();
            dynamicMesh.m_vertices  = new Vector3[INITIAL_VERTEX_COUNT];
            if (m_tangoApplication.m_3drGenerateTexCoord)
            {
                dynamicMesh.m_uv = new Vector2[INITIAL_VERTEX_COUNT];
            }

            if (m_tangoApplication.m_3drGenerateColor)
            {
                dynamicMesh.m_colors = new Color32[INITIAL_VERTEX_COUNT];
            }

            dynamicMesh.m_triangles = new int[INITIAL_INDEX_COUNT];

            // Update debug info too.
            m_debugTotalVertices  = dynamicMesh.m_vertices.Length;
            m_debugTotalTriangles = dynamicMesh.m_triangles.Length;

            // Add the other necessary objects
            MeshFilter meshFilter = newObj.AddComponent <MeshFilter>();
            dynamicMesh.m_mesh = meshFilter.mesh;

            if (m_meshRenderer != null)
            {
                MeshRenderer meshRenderer = newObj.AddComponent <MeshRenderer>();
                #if UNITY_5
                meshRenderer.shadowCastingMode    = m_meshRenderer.shadowCastingMode;
                meshRenderer.receiveShadows       = m_meshRenderer.receiveShadows;
                meshRenderer.sharedMaterials      = m_meshRenderer.sharedMaterials;
                meshRenderer.useLightProbes       = m_meshRenderer.useLightProbes;
                meshRenderer.reflectionProbeUsage = m_meshRenderer.reflectionProbeUsage;
                meshRenderer.probeAnchor          = m_meshRenderer.probeAnchor;
                #elif UNITY_4_6
                meshRenderer.castShadows      = m_meshRenderer.castShadows;
                meshRenderer.receiveShadows   = m_meshRenderer.receiveShadows;
                meshRenderer.sharedMaterials  = m_meshRenderer.sharedMaterials;
                meshRenderer.useLightProbes   = m_meshRenderer.useLightProbes;
                meshRenderer.lightProbeAnchor = m_meshRenderer.lightProbeAnchor;
                #endif

                //meshRenderer.enabled = false;
            }

            if (m_meshCollider != null)
            {
                MeshCollider meshCollider = newObj.AddComponent <MeshCollider>();
                meshCollider.convex         = m_meshCollider.convex;
                meshCollider.isTrigger      = m_meshCollider.isTrigger;
                meshCollider.sharedMaterial = m_meshCollider.sharedMaterial;
                meshCollider.sharedMesh     = dynamicMesh.m_mesh;
                dynamicMesh.m_meshCollider  = meshCollider;
            }

            m_meshes.Add(gridIndex, dynamicMesh);
        }

        // Last frame the mesh needed more space.  Give it more room now.
        if (dynamicMesh.m_needsToGrow)
        {
            int newVertexSize   = (int)(dynamicMesh.m_vertices.Length * GROWTH_FACTOR);
            int newTriangleSize = (int)(dynamicMesh.m_triangles.Length * GROWTH_FACTOR);
            newTriangleSize -= newTriangleSize % 3;

            // Remove the old size, add the new size.
            m_debugTotalVertices  += newVertexSize - dynamicMesh.m_vertices.Length;
            m_debugTotalTriangles += newTriangleSize - dynamicMesh.m_triangles.Length;

            dynamicMesh.m_vertices = new Vector3[newVertexSize];
            if (m_tangoApplication.m_3drGenerateTexCoord)
            {
                dynamicMesh.m_uv = new Vector2[newVertexSize];
            }

            if (m_tangoApplication.m_3drGenerateColor)
            {
                dynamicMesh.m_colors = new Color32[newVertexSize];
            }

            dynamicMesh.m_triangles   = new int[newTriangleSize];
            dynamicMesh.m_needsToGrow = false;
        }

        int numVertices;
        int numTriangles;
        Tango3DReconstruction.Status status = m_tangoApplication.Tango3DRExtractMeshSegment(
            gridIndex, dynamicMesh.m_vertices, null, dynamicMesh.m_colors, dynamicMesh.m_triangles,
            out numVertices, out numTriangles);
        if (status != Tango3DReconstruction.Status.INSUFFICIENT_SPACE &&
            status != Tango3DReconstruction.Status.SUCCESS)
        {
            Debug.Log("Tango3DR extraction failed, status code = " + status + Environment.StackTrace);
            return;
        }
        else if (status == Tango3DReconstruction.Status.INSUFFICIENT_SPACE)
        {
            // We already spent the time extracting this mesh, let's not spend any more time this frame
            // to extract the mesh.
            Debug.Log(string.Format(
                          "TangoDynamicMesh.Update() extraction ran out of space with room for {0} vertexes, {1} indexes.",
                          dynamicMesh.m_vertices.Length, dynamicMesh.m_triangles.Length));
            dynamicMesh.m_needsToGrow = true;
            needsResize.Add(gridIndex);
        }

        // Make any leftover triangles degenerate.
        for (int triangleIt = numTriangles * 3; triangleIt < dynamicMesh.m_triangles.Length; ++triangleIt)
        {
            dynamicMesh.m_triangles[triangleIt] = 0;
        }

        if (dynamicMesh.m_uv != null)
        {
            // Add texture coordinates.
            for (int vertexIt = 0; vertexIt < numVertices; ++vertexIt)
            {
                Vector3 vertex = dynamicMesh.m_vertices[vertexIt];
                dynamicMesh.m_uv[vertexIt].x = vertex.x * UV_PER_METERS;
                dynamicMesh.m_uv[vertexIt].y = (vertex.z + vertex.y) * UV_PER_METERS;
            }
        }

        dynamicMesh.m_mesh.Clear();
        dynamicMesh.m_mesh.vertices  = dynamicMesh.m_vertices;
        dynamicMesh.m_mesh.uv        = dynamicMesh.m_uv;
        dynamicMesh.m_mesh.colors32  = dynamicMesh.m_colors;
        dynamicMesh.m_mesh.triangles = dynamicMesh.m_triangles;
        if (m_tangoApplication.m_3drGenerateNormal)
        {
            dynamicMesh.m_mesh.RecalculateNormals();
        }

        if (dynamicMesh.m_meshCollider != null)
        {
            // Force the mesh collider to update too.
            dynamicMesh.m_meshCollider.sharedMesh = null;
            dynamicMesh.m_meshCollider.sharedMesh = dynamicMesh.m_mesh;
        }
    }