示例#1
0
    // Updates overlay surface mesh. Returns true on success, false if the surface needs to be deleted
    private bool UpdateOverlaySurface(OverlaySurfaceUpdater overlaySurface, DetectedPlane trackedSurface)
    {
        // check for validity
        if (overlaySurface == null || trackedSurface == null)
        {
            return(false);
        }
        else if (trackedSurface.SubsumedBy != null)
        {
            return(false);
        }
        else if (trackedSurface.TrackingState != TrackingState.Tracking)
        {
            overlaySurface.SetEnabled(false);
            return(true);
        }

        // enable the surface
        overlaySurface.SetEnabled(true);

        // estimate mesh vertices
        List <Vector3> meshVertices = new List <Vector3>();

        // GetBoundaryPolygon returns points in clockwise order.
        trackedSurface.GetBoundaryPolygon(meshVertices);
        int verticeLength = meshVertices.Count;

        // surface position & rotation
        Vector3    surfacePos = trackedSurface.CenterPose.position;       // Vector3.zero; //
        Quaternion surfaceRot = trackedSurface.CenterPose.rotation;       // Quaternion.identity; //

        // estimate vertices relative to the center
        Quaternion invRot = Quaternion.Inverse(surfaceRot);

        for (int v = verticeLength - 1; v >= 0; v--)
        {
            meshVertices[v] -= surfacePos;
            meshVertices[v]  = invRot * meshVertices[v];

            if (Mathf.Abs(meshVertices[v].y) > 0.1f)
            {
                meshVertices.RemoveAt(v);
            }
        }

        // estimate mesh indices
        List <int> meshIndices = MultiARInterop.GetMeshIndices(meshVertices.Count);

        // update the surface mesh
        overlaySurface.UpdateSurfaceMesh(surfacePos, surfaceRot, meshVertices, meshIndices);

        return(true);
    }
示例#2
0
    /// <summary>
    /// Gets the currently tracked surfaces.
    /// </summary>
    /// <returns>The tracked surfaces.</returns>
    public MultiARInterop.TrackedSurface[] GetTrackedSurfaces(bool bGetPoints)
    {
        MultiARInterop.TrackedSurface[] trackedPlanes = new MultiARInterop.TrackedSurface[allTrackedPlanes.Count];

        for (int i = 0; i < allTrackedPlanes.Count; i++)
        {
            DetectedPlane surface = allTrackedPlanes[i];
            trackedPlanes[i] = new MultiARInterop.TrackedSurface();

            trackedPlanes[i].position = surface.CenterPose.position;
            trackedPlanes[i].rotation = surface.CenterPose.rotation;
            trackedPlanes[i].bounds   = new Vector3(surface.ExtentX, 0f, surface.ExtentZ);

            if (bGetPoints)
            {
                List <Vector3> alPoints = new List <Vector3>();
                surface.GetBoundaryPolygon(alPoints);

                int        vertexCount = alPoints.Count;
                Quaternion invRot      = Quaternion.Inverse(surface.CenterPose.rotation);
                Vector3    centerPos   = surface.CenterPose.position;

                for (int v = vertexCount - 1; v >= 0; v--)
                {
                    alPoints[v] -= centerPos;
                    alPoints[v]  = invRot * alPoints[v];

                    if (Mathf.Abs(alPoints[v].y) > 0.1f)
                    {
                        alPoints.RemoveAt(v);
                    }
                }

                // get mesh indices
                List <int> meshIndices = MultiARInterop.GetMeshIndices(vertexCount);

                trackedPlanes[i].points    = alPoints.ToArray();
                trackedPlanes[i].triangles = meshIndices.ToArray();
            }
        }

        return(trackedPlanes);
    }