Esempio n. 1
0
        /// <summary>
        /// Handler when Mesh Request is complete.
        /// Builds the mesh if available. Invokes the callbacks.
        /// </summary>
        /// <param name="result">Status of the request.</param>
        /// <param name="meshData">Mesh Data, only valid when result is Ok.</param>
        private void HandMeshRequestCallback(MLResult result, MLHandMeshing.Mesh meshData)
        {
            if (!result.IsOk)
            {
                Debug.LogErrorFormat("MLHandMeshingBehavior failed to request data. Reason : {0}", result);
                MLHandMeshing.RequestHandMesh(HandMeshRequestCallback);
                return;
            }
            _hasPendingRequest = false;

            int numMeshes = (meshData.MeshBlock == null) ? 0 : meshData.MeshBlock.Length;

            for (var i = 0; i < numMeshes; ++i)
            {
                MeshFilter meshFilter = null;
                if (_meshFilters.Count < i + 1)
                {
                    GameObject go = Instantiate(_meshBlockPrefab, transform, true);
                    meshFilter      = go.GetComponent <MeshFilter>();
                    meshFilter.mesh = new Mesh();
                    _meshFilters.Add(meshFilter);
                }
                else
                {
                    meshFilter = _meshFilters[i];
                    meshFilter.gameObject.SetActive(true);
                    meshFilter.mesh.Clear();
                }
                MeshRenderer renderer = meshFilter.GetComponent <MeshRenderer>();
                renderer.material = _meshMaterial;

                Mesh mesh = meshFilter.mesh;
                mesh.vertices  = meshData.MeshBlock[i].Vertex;
                mesh.triangles = meshData.MeshBlock[i].Index;
                if (_recalculateNormals)
                {
                    mesh.RecalculateNormals();
                }
                meshFilter.mesh = mesh;
            }

            for (var j = numMeshes; j < _meshFilters.Count; ++j)
            {
                _meshFilters[j].gameObject.SetActive(false);
            }

            HandleCallbacks(result, meshData);

            if (enabled)
            {
                MLHandMeshing.RequestHandMesh(HandMeshRequestCallback);
                _hasPendingRequest = true;
            }
        }
Esempio n. 2
0
        /// <summary>
        /// Invoke callbacks.
        /// </summary>
        /// <param name="result">Result</param>
        /// <param name="meshData">Mesh Data</param>
        private void HandleCallbacks(MLResult result, MLHandMeshing.Mesh meshData)
        {
            bool hasMeshData = false;

            foreach (MLHandMeshing.Mesh.Block meshBlock in meshData.MeshBlock)
            {
                if (meshBlock.Vertex.Length > 0)
                {
                    hasMeshData = true;
                    break;
                }
            }

            if (!hasMeshData)
            {
                if (HandMeshFound)
                {
                    if (OnHandMeshLost != null)
                    {
                        OnHandMeshLost(result, meshData);
                    }
                    HandMeshFound = false;
                }
            }
            else
            {
                if (HandMeshFound)
                {
                    if (OnHandMeshUpdated != null)
                    {
                        OnHandMeshUpdated(result, meshData);
                    }
                }
                else
                {
                    if (OnHandMeshFound != null)
                    {
                        OnHandMeshFound(result, meshData);
                    }
                    HandMeshFound = true;
                }
            }
        }