bool TryCreateMRPlane(MRLayerPlaneData layerPlane, Pose layerOriginPose)
{
var mrPlaneVertices = new List <Vector3>();
Pose pose;
Vector3 center;
Vector2 extents;
if (!TryGetPlaneData(layerPlane, layerOriginPose, mrPlaneVertices, out pose, out center, out extents))
{
return(false);
}
var vertsCount = mrPlaneVertices.Count;
var normals = new List <Vector3>(vertsCount);
var textureCoordinates = new List <Vector2>(vertsCount);
var indices = new List <int>();
PlaneUtils.TriangulatePlaneFromVertices(pose, mrPlaneVertices, indices, normals, textureCoordinates);
var mrPlane = new MRPlane
{
id = MarsTrackableId.Create(),
alignment = m_PlaneAlignment,
vertices = mrPlaneVertices,
normals = normals,
indices = indices,
textureCoordinates = textureCoordinates,
pose = pose,
center = center,
extents = extents
};
layerPlane.MRPlane = mrPlane;
return(true);
}
void UpdatePlaneFromData()
{
if (m_UseMRPlaneMesh)
{
m_GeneratedPlane = m_RuntimePlane;
var localScale = transform.localScale;
// We duplicate the vertices here since the original list is serialized with the base plane
if (localScale != Vector3.one && m_GeneratedPlane.vertices != null)
{
m_GeneratedPlane.vertices = m_GeneratedPlane.vertices.ToList();
}
ScaleVertices(m_GeneratedPlane.vertices, localScale);
}
else
{
m_GeneratedPlane = new MRPlane {
id = m_RuntimePlane.id
};
if (m_OriginalMesh != null)
{
var vertices = m_OriginalMesh.vertices.ToList();
var verticesLength = vertices.Count;
ScaleVertices(vertices, transform.localScale);
var indices = new List <int>(verticesLength * 3);
var normals = new List <Vector3>(verticesLength);
var texCoords = new List <Vector2>(verticesLength);
PlaneUtils.TriangulatePlaneFromVertices(m_GeneratedPlane.pose, vertices, indices, normals, texCoords);
indices.TrimExcess();
// Mesh data is not initialized when MR Plane is created
m_GeneratedPlane.vertices = vertices;
m_GeneratedPlane.indices = indices;
m_GeneratedPlane.normals = normals;
m_GeneratedPlane.textureCoordinates = texCoords;
}
}
// Traits from other synthesized data
m_GeneratedPlane.pose = m_PoseSource.GetTraitData();
m_GeneratedPlane.alignment = (MarsPlaneAlignment)m_AlignmentSource.GetTraitData();
m_GeneratedPlane.extents = m_ExtentsSource.GetTraitData();
m_MRPlaneGenerated = true;
}
void UpdateMRPlane(MRLayerPlaneData layerPlane, Pose layerOriginPose)
{
var mrPlane = layerPlane.MRPlane;
var mrPlaneVertices = mrPlane.vertices;
mrPlaneVertices.Clear();
Pose pose;
Vector3 center;
Vector2 extents;
TryGetPlaneData(layerPlane, layerOriginPose, mrPlaneVertices, out pose, out center, out extents);
mrPlane.pose = pose;
mrPlane.center = center;
mrPlane.extents = extents;
// Grow capacity for normals and UVs if needed
const int capacityBuffer = 8;
var vertsCount = mrPlaneVertices.Count;
var normals = mrPlane.normals;
if (normals.Capacity <= vertsCount)
{
normals.Capacity = vertsCount + capacityBuffer;
}
var textureCoordinates = mrPlane.textureCoordinates;
if (textureCoordinates.Capacity <= vertsCount)
{
textureCoordinates.Capacity = vertsCount + capacityBuffer;
}
var indices = mrPlane.indices;
indices.Clear();
normals.Clear();
textureCoordinates.Clear();
PlaneUtils.TriangulatePlaneFromVertices(mrPlane.pose, mrPlaneVertices, indices, normals, textureCoordinates);
layerPlane.MRPlane = mrPlane;
}
public static MRPlane ToMRPlane(this ARPlane plane)
{
var alignment = plane.alignment;
var pose = plane.transform.GetWorldPose();
var mrPlane = new MRPlane
{
id = plane.trackableId.ToMarsId(),
alignment = alignment.ToMarsPlaneAlignment(),
pose = pose,
extents = plane.extents * 2.0f, // MR extents are diameter, AR extends are "(half dimensions) of the plane in meters."
center = new Vector3(plane.centerInPlaneSpace.x, 0.0f, plane.centerInPlaneSpace.y)
};
var nativeVertices = plane.boundary;
if (nativeVertices.Length <= 0)
{
return(mrPlane);
}
var count = nativeVertices.Length;
var vertices = new List <Vector3>(count);
var normals = new List <Vector3>(count);
var textureCoordinates = new List <Vector2>(count);
var indices = new List <int>();
for (var i = 0; i < count; i++)
{
var nativeVertex = nativeVertices[i];
vertices.Add(new Vector3(nativeVertex.x, 0.0f, nativeVertex.y));
}
mrPlane.vertices = vertices;
mrPlane.normals = normals;
mrPlane.textureCoordinates = textureCoordinates;
mrPlane.indices = indices;
PlaneUtils.TriangulatePlaneFromVertices(mrPlane.pose, vertices, indices, normals, textureCoordinates);
return(mrPlane);
}
/// <summary>
/// Set the data for the MRPlane backing this SynthesizedPlane
/// </summary>
/// <param name="vertices">The vertices for the boundary polygon</param>
/// <param name="center">The position of the center of the plane</param>
/// <param name="extents">The extents of the boundary polygon</param>
public void SetMRPlaneData(List <Vector3> vertices, Vector3 center, Vector2 extents)
{
if (m_ExtentsSource == null)
{
m_ExtentsSource = GetComponent <SynthesizedBounds2D>();
}
m_ExtentsSource.baseBounds = extents;
m_Plane.center = center;
m_Plane.vertices.Clear();
m_Plane.indices.Clear();
m_Plane.normals.Clear();
m_Plane.textureCoordinates.Clear();
m_Plane.vertices.AddRange(vertices);
PlaneUtils.TriangulatePlaneFromVertices(m_Plane.pose, m_Plane.vertices, m_Plane.indices, m_Plane.normals, m_Plane.textureCoordinates);
SetMeshData();
CopyToRuntimePlane();
m_MRPlaneGenerated = false;
}
void CreateOrUpdateGameObject(MRPlane plane)
{
if (MARSCore.instance.paused)
{
return;
}
GameObject go;
Mesh mesh = null;
MeshCollider meshCollider = null;
var id = plane.id;
var useGeometry = m_UsePlaneGeometry && plane.vertices != null;
var makeEdge = m_EdgeSettings.MakeEdge;
if (m_Planes.TryGetValue(id, out var planeVisual))
{
go = planeVisual.GameObject;
mesh = planeVisual.Mesh;
meshCollider = planeVisual.Collider;
if (useGeometry && mesh == null)
{
mesh = new Mesh();
planeVisual.Mesh = mesh;
}
}
else
{
go = Instantiate(m_PlanePrefab, transform);
#if UNITY_EDITOR
// This allows the instantiated objects to use layer locking for scene picking in the editor.
if (m_UseParentLayer)
{
go.SetLayerAndHideFlagsRecursively(gameObject.layer, HideFlags.DontSave);
}
else
{
go.SetHideFlagsRecursively(HideFlags.DontSave);
}
#else
go.SetHideFlagsRecursively(HideFlags.DontSave);
#endif
if (useGeometry)
{
mesh = new Mesh();
var meshFilter = go.GetComponentInChildren <MeshFilter>();
if (meshFilter)
{
meshFilter.sharedMesh = mesh;
}
meshCollider = go.GetComponentInChildren <MeshCollider>();
if (meshCollider)
{
meshCollider.sharedMesh = mesh;
}
planeVisual = PlaneVisual.GetOrCreate(go, mesh, meshCollider, makeEdge);
}
else
{
planeVisual = PlaneVisual.GetOrCreate(go, null, null, makeEdge);
}
m_Planes.Add(id, planeVisual);
}
var goTransform = go.transform;
var pose = this.ApplyOffsetToPose(plane.pose);
goTransform.SetWorldPose(pose);
var cameraScale = this.GetCameraScale();
if (useGeometry)
{
var vertices = plane.vertices;
var textureCoordinates = plane.textureCoordinates;
var textureCoordinates2 = planeVisual.TextureCoordinates2;
var indices = plane.indices;
if (makeEdge)
{
planeVisual.InitializeEdgeLists();
PlaneUtils.GeneratePlaneWithBorders(plane.pose, vertices, planeVisual.Vertices, planeVisual.TextureCoordinates,
planeVisual.TextureCoordinates2, planeVisual.Indices, m_EdgeSettings);
vertices = planeVisual.Vertices;
textureCoordinates = planeVisual.TextureCoordinates;
indices = planeVisual.Indices;
}
else
{
// Need to set uv2's with all 0's to clear out edge UVs if they exist (can happen if MakeEdge is toggled during play mode)
var vertexCount = vertices.Count;
textureCoordinates2.SetSize(vertexCount);
for (var i = 0; i < vertexCount; i++)
{
textureCoordinates2[i] = default;
}
}
goTransform.localScale = Vector3.one * cameraScale;
mesh.triangles = null;
mesh.SetVertices(vertices);
mesh.SetUVs(0, textureCoordinates);
mesh.SetUVs(1, textureCoordinates2);
mesh.SetTriangles(indices, 0, true);
mesh.RecalculateNormals();
if (meshCollider != null)
{
meshCollider.sharedMesh = mesh; // this needs to re-applied to take effect
}
}
else
{
var extents = plane.extents;
goTransform.position += pose.rotation * (plane.center * cameraScale);
goTransform.localScale = new Vector3(extents.x, 1f, extents.y) * cameraScale;
}
}
