philipp.kramer/zed-ar-headfree-passthrough
0
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
zed-ar-headfree-passthrough/Assets/ZED/SDK/Helpers/Scripts/SpatialMapping/ZEDSpatialMapping.cs

1644 lines
62 KiB
C#
Raw Permalink Normal View History

import zed package
2019-11-26 14:03:54 +00:00
//======= Copyright (c) Stereolabs Corporation, All rights reserved. ===============
using System.Collections.Generic;
using UnityEngine;
using System.Threading;
using System.Text;
using System;
/// <summary>
/// Processes the mesh taken from the ZED's Spatial Mapping feature so it can be used within Unity.
/// Handles the real-time updates as well as the final processing.
/// Note that ZEDSpatialMappingManager is more user-friendly/high-level, designed to hide the complexities of this class.
/// </summary>
public class ZEDSpatialMapping
{
/// <summary>
/// Submesh created by ZEDSpatialMapping. The scan is made of multiple chunks.
/// </summary>
public struct Chunk
{
/// <summary>
/// Reference to the GameObject that holds the MeshFilter.
/// </summary>
public GameObject o;
/// <summary>
/// Dynamic mesh data that will change throughout the spatial mapping.
/// </summary>
public ProceduralMesh proceduralMesh;
/// <summary>
/// Final mesh, assigned to once the spatial mapping is over and done processing.
/// </summary>
public Mesh mesh;
}
/// <summary>
/// Structure to contain a temporary buffer that holds triangles and vertices.
/// </summary>
public struct ProceduralMesh
{
/// <summary>
/// List of vertex indexes that make up triangles.
/// </summary>
public int[] triangles;
/// <summary>
/// List of vertices in the mesh.
/// </summary>
public Vector3[] vertices;
/// <summary>
/// MeshFilter of a GameObject that holds the chunk this ProceduralMesh represents.
/// </summary>
public MeshFilter mesh;
};
/// <summary>
/// Spatial mapping depth resolution presets.
/// </summary>
public enum RESOLUTION
{
/// <summary>
/// Create detailed geometry. Requires lots of memory.
/// </summary>
HIGH,
/// <summary>
/// Small variations in the geometry will disappear. Useful for large objects.
/// </summary>
///
MEDIUM,
/// <summary>
/// Keeps only large variations of the geometry. Useful for outdoors.
/// </summary>
LOW
}
/// <summary>
/// Spatial mapping depth range presets.
/// </summary>
public enum RANGE
{
/// <summary>
/// Geometry within 3.5 meters of the camera will be mapped.
/// </summary>
NEAR,
/// <summary>
/// Geometry within 5 meters of the camera will be mapped.
/// </summary>
MEDIUM,
/// <summary>
/// Objects as far as 10 meters away are mapped. Useful for outdoors.
/// </summary>
FAR
}
/// <summary>
/// Current instance of the ZED Camera.
/// </summary>
private sl.ZEDCamera zedCamera;
/// <summary>
/// Instance of an internal helper class for low-level mesh processing.
/// </summary>
private ZEDSpatialMappingHelper spatialMappingHelper;
/// <summary>
/// Amount of filtering to apply to the mesh. Higher values result in lower face counts/memory usage, but also lower precision.
/// </summary>
public sl.FILTER filterParameters = sl.FILTER.MEDIUM;
/// <summary>
/// True when RequestSaveMesh has been called, so that ongoing threads know to stop and save the mesh
/// when everything is finished processing.
/// </summary>
private bool saveRequested = false;
/// <summary>
/// Where the new mesh will be saved. Should end in .obj.
/// If textured, a .mtl (material) file and .png file will appear in the same folder with the same base filename.
/// </summary>
private string savePath = "Assets/ZEDMesh.obj";
#if UNITY_EDITOR
/// <summary>
/// Color of the wireframe mesh to be drawn in Unity's Scene window.
/// </summary>
private Color colorMesh = new Color(0.35f, 0.65f, 0.95f);
#endif
/// <summary>
/// Offset for the triangles buffer, so that new triangles are copied into the dynamic mesh starting at the correct index.
/// </summary>
private int trianglesOffsetLastFrame;
/// <summary>
/// Offset for the vertices buffer, so that new vertices are copied into the dynamic mesh starting at the correct index.
/// </summary>
private int verticesOffsetLastFrame;
/// <summary>
/// Offset for the UVs buffer, so that new UV coordinates are copied into the dynamic mesh starting at the correct index.
/// </summary>
private int uvsOffsetLastFrame;
/// <summary>
/// Index of the mesh that was updated last frame.
/// </summary>
private int indexLastFrame;
/// <summary>
/// Flag set to true if there were meshes what weren't completely updated last frame due to lack of time.
/// </summary>
private bool remainMeshes = false;
/// <summary>
/// The user has requested to stop spatial mapping.
/// </summary>
private bool stopWanted = false;
/// <summary>
/// Whether the mesh is in the filtering stage of processing.
/// </summary>
private bool isFiltering = false;
/// <summary>
/// Whether the filtering stage of the mesh's processing has started and finished.
/// </summary>
private bool isFilteringOver = false;
/// <summary>
/// Whether the update thread will stop running.
/// </summary>
private bool stopRunning = false;
/// <summary>
/// Whether any part of spatial mapping is running. Set to true when scanning has started
/// and set to false after the scanned mesh has finished bring filtered, textured, etc.
/// </summary>
private bool running = false;
/// <summary>
/// Flag that causes spatial mapping to pause when true. Use SwitchPauseState() to change.
/// </summary>
private bool pause = false;
/// <summary>
/// Returns true if spatial mapping has been paused. This can be set to true even if spatial mapping isn't running.
/// </summary>
public bool IsPaused
{
get { return pause; }
}
/// <summary>
/// Whether scanned meshes are visible or not.
/// </summary>
public bool display = false;
/// <summary>
/// State of the scanning during its initialization. Used to know if it has started successfully.
/// </summary>
private sl.ERROR_CODE scanningInitState;
/// <summary>
/// Delegate for the OnMeshUpdate event, which is called every time a new chunk/submesh is processed.
/// </summary>
public delegate void OnNewMesh();
/// <summary>
/// Events called every time a new chunk/submesh has been processed. It's called many times during the scan.
/// </summary>
public event OnNewMesh OnMeshUpdate;
/// <summary>
/// Delegate for OnMeshReady, which is called when spatial mapping has finished.
/// </summary>
public delegate void OnSpatialMappingEnded();
/// <summary>
/// Event called when spatial mapping has finished.
/// </summary>
public event OnSpatialMappingEnded OnMeshReady;
/// <summary>
/// Delegate for OnMeshStarted, which is called when spatial mapping has started.
/// </summary>
public delegate void OnSpatialMappingStarted();
/// <summary>
/// Event called when spatial mapping has started.
/// </summary>
public event OnSpatialMappingStarted OnMeshStarted;
/// <summary>
/// GameObject to which every chunk of the mesh is parented. Represents the scanned mesh in Unity's Hierarchy.
/// </summary>
private GameObject holder = null;
/**** Threading Variables ****/
/// <summary>
/// True if the mesh has been updated, and needs to be processed.
/// </summary>
private bool meshUpdated = false;
/// <summary>
/// True if the mesh update thread is running.
/// </summary>
private bool updateThreadRunning = false;
/// <summary>
/// Public accessor for whether the mesh update thread is running.
/// </summary>
public bool IsUpdateThreadRunning
{
get { return updateThreadRunning; }
}
/// <summary>
/// True if the user has requested that spatial mapping start.
/// </summary>
private bool spatialMappingRequested = false;
/// <summary>
/// True if the real-world texture needs to be updated.
/// This only happens after scanning is finished and if Texturing (isTextured) is enabled.
/// </summary>
private bool updateTexture = false;
/// <summary>
/// True if the real-world texture has been updated.
/// </summary>
private bool updatedTexture = false;
/// <summary>
/// Thread that retrieves the size of the submeshes.
/// </summary>
private Thread scanningThread;
/// <summary>
/// Thread that filters the mesh once scanning has finished.
/// </summary>
private Thread filterThread;
/// <summary>
/// Mutex for threaded spatial mapping.
/// </summary>
private object lockScanning = new object();
/// <summary>
/// Maximum time in milliseconds that can be spent processing retrieved meshes each frame. If time is exceeded, remaining meshes will be processed next frame.
/// </summary>
private const int MAX_TIME = 5;
/// <summary>
/// True if the thread that updates the real-world texture is running.
/// </summary>
private bool texturingRunning = false;
/// <summary>
/// Gravity direction vector relative to ZEDManager's orientation. Estimated after spatial mapping is finished.
/// Note that this will always be empty if using the ZED Mini as gravity is determined from its IMU at start.
/// </summary>
public Vector3 gravityEstimation;
/// <summary>
/// Public accessor for texturingRunning, which is whether the thread that updates the real-world texture is running.
/// </summary>
public bool IsTexturingRunning
{
get
{
return texturingRunning;
}
}
/// <summary>
/// If true, the script will add MeshColliders to all scanned chunks to allow physics collisions.
/// </summary>
private bool hasColliders = true;
/// <summary>
/// True if texture from the real world should be applied to the mesh. If true, texture will be applied after scanning is finished.
/// </summary>
private bool isTextured = false;
/// <summary>
/// Flag to check if we have attached ZEDMeshRenderer components to the ZED rig camera objects.
/// This is done in Update() if it hasn't been done yet.
/// </summary>
private bool setMeshRenderer = false;
/// <summary>
/// References to the ZEDMeshRenderer components attached to the ZED rig camera objects.
/// [0] is the one attached to the left camera. [1] is the right camera, if it exists.
/// </summary>
private ZEDMeshRenderer[] meshRenderer = new ZEDMeshRenderer[2];
/// <summary>
/// The scene's ZEDManager component, usually attached to the ZED rig GameObject (ZED_Rig_Mono or ZED_Rig_Stereo).
/// </summary>
private ZEDManager zedManager;
/// <summary>
/// All chunks/submeshes with their indices. Only used while spatial mapping is running, as meshes are consolidated from
/// many small meshes into fewer, larger meshes when finished. See ChunkList for final submeshes.
/// </summary>
public Dictionary<int, ZEDSpatialMapping.Chunk> Chunks
{
get { return spatialMappingHelper.chunks; }
}
/// <summary>
/// List of the final mesh chunks created after scanning is finished. This is not filled beforehand because we use
/// many small chunks during scanning, and consolidate them afterward. See Chunks for runtime submeshes.
/// </summary>
public List<ZEDSpatialMapping.Chunk> ChunkList = new List<ZEDSpatialMapping.Chunk>();
/// <summary>
/// Constructor. Spawns the holder GameObject to hold scanned chunks and the ZEDSpatialMappingHelper to handle low-level mesh processing.
/// </summary>
/// <param name="transform">Transform of the scene's ZEDSpatialMappingManager.</param>
/// <param name="zedCamera">Reference to the ZEDCamera instance.</param>
/// <param name="zedManager">The scene's ZEDManager component.</param>
public ZEDSpatialMapping(Transform transform, ZEDManager zedManager)
{
//Instantiate the low-level mesh processing helper.
spatialMappingHelper = new ZEDSpatialMappingHelper(zedManager.zedCamera, Resources.Load("Materials/SpatialMapping/Mat_ZED_Texture") as Material, Resources.Load("Materials/SpatialMapping/Mat_ZED_Geometry_Wireframe") as Material);
//Assign basic values.
this.zedCamera = zedManager.zedCamera;
this.zedManager = zedManager;
scanningInitState = sl.ERROR_CODE.FAILURE;
}
/// <summary>
/// Begins the spatial mapping process. This is called when you press the "Start Spatial Mapping" button in the Inspector.
/// </summary>
/// <param name="resolutionPreset">Resolution setting - how detailed the mesh should be at scan time.</param>
/// <param name="rangePreset">Range setting - how close geometry must be to be scanned.</param>
/// <param name="isTextured">Whether to scan texture, or only the geometry.</param>
public void StartStatialMapping(RESOLUTION resolutionPreset, RANGE rangePreset, bool isTextured)
{
//Create the Holder object, to which all scanned chunks will be parented.
holder = new GameObject();
holder.name = "[ZED Mesh Holder (" + zedManager.name + ")]";
holder.transform.position = Vector3.zero;
holder.transform.rotation = Quaternion.identity;
StaticBatchingUtility.Combine(holder);
holder.transform.position = Vector3.zero;
holder.transform.rotation = Quaternion.identity;
spatialMappingRequested = true;
if (spatialMappingRequested && scanningInitState != sl.ERROR_CODE.SUCCESS)
{
scanningInitState = EnableSpatialMapping(resolutionPreset, rangePreset, isTextured);
}
zedManager.gravityRotation = Quaternion.identity;
pause = false; //Make sure the scanning doesn't start paused because it was left paused at the last scan.
}
/// <summary>
/// Initializes flags used during scan, tells ZEDSpatialMappingHelper to activate the ZED SDK's scanning, and
/// starts the thread that updates the in-game chunks with data from the ZED SDK.
/// </summary>
/// <param name="resolutionPreset">Resolution setting - how detailed the mesh should be at scan time.</param>
/// <param name="rangePreset">Range setting - how close geometry must be to be scanned.</param>
/// <param name="isTextured">Whether to scan texture, or only the geometry.</param>
/// <returns></returns>
private sl.ERROR_CODE EnableSpatialMapping(RESOLUTION resolutionPreset, RANGE rangePreset, bool isTextured)
{
sl.ERROR_CODE error;
this.isTextured = isTextured;
//Tell the helper to start scanning. This call gets passed directly to the wrapper call in ZEDCamera.
error = spatialMappingHelper.EnableSpatialMapping(ZEDSpatialMappingHelper.ConvertResolutionPreset(resolutionPreset), ZEDSpatialMappingHelper.ConvertRangePreset(rangePreset), isTextured);
if (meshRenderer[0]) meshRenderer[0].isTextured = isTextured;
if (meshRenderer[1]) meshRenderer[1].isTextured = isTextured;
stopWanted = false;
running = true;
if (error == sl.ERROR_CODE.SUCCESS) //If the scan was started successfully.
{
//Set default flag settings.
display = true;
meshUpdated = false;
spatialMappingRequested = false;
updateTexture = false;
updatedTexture = false;
//Clear all previous meshes.
ClearMeshes();
//Request the first mesh update. Later, this will get called continuously after each update is applied.
zedCamera.RequestMesh();
//Launch the thread to retrieve the chunks and their sizes from the ZED SDK.
scanningThread = new Thread(UpdateMesh);
updateThreadRunning = true;
if (OnMeshStarted != null)
{
OnMeshStarted(); //Invoke the event for other scripts, like ZEDMeshRenderer.
}
scanningThread.Start();
}
return error;
}
/// <summary>
/// Attach a new ZEDMeshRenderer to the ZED rig cameras. This is necessary to see the mesh.
/// </summary>
public void SetMeshRenderer()
{
if (!setMeshRenderer) //Make sure we haven't do this yet.
{
if (zedManager != null)
{
Transform left = zedManager.GetLeftCameraTransform(); //Find the left camera. This exists in both ZED_Rig_Mono and ZED_Rig_Stereo.
if (left != null)
{
meshRenderer[0] = left.gameObject.GetComponent<ZEDMeshRenderer>();
if (!meshRenderer[0])
{
meshRenderer[0] = left.gameObject.AddComponent<ZEDMeshRenderer>();
}
meshRenderer[0].Create();
}
Transform right = zedManager.GetRightCameraTransform(); //Find the right camera. This only exists in ZED_Rig_Stereo or a similar stereo rig.
if (right != null)
{
meshRenderer[1] = right.gameObject.GetComponent<ZEDMeshRenderer>();
if (!meshRenderer[1])
{
meshRenderer[1] = right.gameObject.AddComponent<ZEDMeshRenderer>();
}
meshRenderer[1].Create();
}
setMeshRenderer = true;
}
}
}
/// <summary>
/// Updates the current mesh, if scanning, and manages the start and stop states.
/// </summary>
public void Update()
{
SetMeshRenderer(); //Make sure we have ZEDMeshRenderers on the cameras, so we can see the mesh.
if (meshUpdated || remainMeshes)
{
UpdateMeshMainthread();
meshUpdated = false;
}
if (stopWanted && !remainMeshes)
{
stopRunning = true;
stopWanted = false;
Stop();
}
//If it's time to stop the scan, disable the spatial mapping and store the gravity estimation in ZEDManager.
if (stopRunning && !isFiltering && isFilteringOver)
{
isFilteringOver = false;
UpdateMeshMainthread(false);
Thread disabling = new Thread(DisableSpatialMapping);
disabling.Start();
if (hasColliders)
{
if (!zedManager.IsStereoRig && gravityEstimation != Vector3.zero && zedManager.transform.parent != null)
{
Quaternion rotationToApplyForGravity = Quaternion.Inverse(Quaternion.FromToRotation(Vector3.up, -gravityEstimation.normalized));
holder.transform.localRotation = rotationToApplyForGravity;
zedManager.gravityRotation = rotationToApplyForGravity;
}
UpdateMeshCollider();
}
else
{
running = false;
}
stopRunning = false;
}
}
/// <summary>
/// Gets the mesh data from the ZED SDK and stores it for later update in the Unity mesh.
/// </summary>
private void UpdateMesh()
{
while (updateThreadRunning)
{
if (!remainMeshes) //If we don't have leftover meshes to apply from the last update.
{
lock (lockScanning)
{
if (meshUpdated == false && updateTexture) //If we need to update the texture, prioritize that.
{
//Get the last size of the mesh and get the texture size.
spatialMappingHelper.ApplyTexture();
meshUpdated = true;
updateTexture = false;
updatedTexture = true;
updateThreadRunning = false;
}
else if (zedCamera.GetMeshRequestStatus() == sl.ERROR_CODE.SUCCESS && !pause && meshUpdated == false)
{
spatialMappingHelper.UpdateMesh(); //Tells the ZED SDK to update its internal mesh.
spatialMappingHelper.RetrieveMesh(); //Applies the ZED SDK's internal mesh to values inside spatialMappingHelper.
meshUpdated = true;
}
}
//Time to process all the meshes spread on multiple frames.
Thread.Sleep(5);
}
else //If there are meshes that were collected but not processed yet. Happens if the last update took too long to process.
{
//Check every 5ms if the meshes are done being processed.
Thread.Sleep(5);
}
}
}
/// <summary>
/// Destroys all submeshes.
/// </summary>
private void ClearMeshes()
{
if (holder != null)
{
foreach (Transform child in holder.transform)
{
GameObject.Destroy(child.gameObject);
}
spatialMappingHelper.Clear();
}
}
/// <summary>
/// Measures time since the provided start time. Used in UpdateMeshMainthread() to check if computational time for mesh updates
/// has exceeded the MAX_TIME time limit (usually 5ms), so that it can hold off processing remaining meshes until the next frame.
/// </summary>
/// <param name="startTimeMS">Time.realtimeSinceStartup value when the process began.</param>
/// <returns><c>True</c> if more than MAX_TIME has elapsed since startTimeMS.</returns>
private bool GoneOverTimeBudget(int startTimeMS)
{
return (Time.realtimeSinceStartup * 1000) - startTimeMS > MAX_TIME;
}
/// <summary>
/// Update the Unity mesh with the last data retrieved from the ZED, creating a new submesh if needed.
/// Also launches the OnMeshUpdate event when the update is finished.
/// <param name="spreadUpdateOverTime">If <c>true</c>, caps time spent on updating meshes each frame, leaving 'leftover' meshes for the next frame.</param>
/// </summary>
private void UpdateMeshMainthread(bool spreadUpdateOverTime = true)
{
//Cache the start time so we can measure how long this function is taking.
//We'll check when updating the submeshes so that if it takes too long, we'll stop updating until the next frame.
int startTimeMS = (int)(Time.realtimeSinceStartup * 1000);
int indexUpdate = 0;
lock (lockScanning) //Don't update if another thread is accessing.
{
if (updatedTexture)
{
spreadUpdateOverTime = false;
}
//Set the offset of the buffers to the offset of the last frame.
int verticesOffset = 0, trianglesOffset = 0, uvsOffset = 0;
if (remainMeshes && spreadUpdateOverTime)
{
verticesOffset = verticesOffsetLastFrame;
trianglesOffset = trianglesOffsetLastFrame;
uvsOffset = uvsOffsetLastFrame;
indexUpdate = indexLastFrame;
}
//Clear all existing meshes and process the last ones.
if (updatedTexture)
{
ClearMeshes();
spatialMappingHelper.SetMeshAndTexture();
if (meshRenderer[0]) meshRenderer[0].isTextured = isTextured;
if (meshRenderer[1]) meshRenderer[1].isTextured = isTextured;
}
//Process the last meshes.
for (; indexUpdate < spatialMappingHelper.NumberUpdatedSubMesh; indexUpdate++)
{
spatialMappingHelper.SetMesh(indexUpdate, ref verticesOffset, ref trianglesOffset, ref uvsOffset, holder.transform, updatedTexture);
if (spreadUpdateOverTime && GoneOverTimeBudget(startTimeMS)) //Check if it's taken too long this frame.
{
remainMeshes = true; //It has. Set this flag so we know to pick up where we left off next frame.
break;
}
}
if (spreadUpdateOverTime)
{
indexLastFrame = indexUpdate;
}
else
{
indexLastFrame = 0;
}
//If all the meshes have been updated, reset values used to process 'leftover' meshes and get more data from the ZED.
if ((indexUpdate == spatialMappingHelper.NumberUpdatedSubMesh) || spatialMappingHelper.NumberUpdatedSubMesh == 0)
{
verticesOffsetLastFrame = 0;
trianglesOffsetLastFrame = 0;
uvsOffsetLastFrame = 0;
indexLastFrame = 0;
remainMeshes = false;
meshUpdated = false;
zedCamera.RequestMesh();
}
//If some meshes still need updating, we'll save the offsets so we know where to start next frame.
else if (indexUpdate != spatialMappingHelper.NumberUpdatedSubMesh)
{
remainMeshes = true;
indexLastFrame = indexUpdate + 1;
verticesOffsetLastFrame = verticesOffset;
trianglesOffsetLastFrame = trianglesOffset;
uvsOffsetLastFrame = uvsOffset;
}
//Save the mesh here if we requested it to be saved, as we just updated the meshes, including textures, if applicable.
if (saveRequested && remainMeshes == false)
{
if (!isTextured || updatedTexture)
{
SaveMeshNow(savePath);
saveRequested = false;
}
}
}
if (OnMeshUpdate != null)
{
OnMeshUpdate(); //Call the event if it has at least one listener.
}
//The texture update is done in one pass, so this is only called once after the mesh has stopped scanning.
if (updatedTexture)
{
DisableSpatialMapping();
updatedTexture = false;
running = false;
texturingRunning = false;
if (hasColliders)
{
UpdateMeshCollider();
}
else
{
running = false;
}
}
}
public void ClearAllMeshes()
{
GameObject[] gos = GameObject.FindObjectsOfType<GameObject>() as GameObject[];
spatialMappingHelper.Clear();
for (int i = 0; i < gos.Length; i++)
{
string targetName = "[ZED Mesh Holder (" + zedManager.name + ")]";
if (gos[i] != null && gos[i].name.Contains(targetName))
{
GameObject.Destroy(gos[i]);
}
}
}
/// <summary>
/// Changes the visibility state of the meshes.
/// This is what's called when the Hide/Display Mesh button is clicked in the Inspector.
/// </summary>
/// <param name="newDisplayState"> If true, the mesh will be displayed, else it will be hide. </param>
public void SwitchDisplayMeshState(bool newDisplayState)
{
display = newDisplayState;
}
/// <summary>
/// Pauses or resumes spatial mapping. If the spatial mapping is not enabled, nothing will happen.
/// </summary>
/// <param name="newPauseState"> If true, the spatial mapping will be paused, else it will be resumed. </param>
public void SwitchPauseState(bool newPauseState)
{
pause = newPauseState;
zedCamera.PauseSpatialMapping(newPauseState);
}
/// <summary>
/// Update the mesh collider with the current mesh so it can handle physics.
/// Calling it is slow, so it's only called after a scan is finished (or loaded).
/// </summary>
public void UpdateMeshCollider(bool timeSlicing = false)
{
ChunkList.Clear();
foreach (var submesh in Chunks)
{
ChunkList.Add(submesh.Value);
}
lock (lockScanning)
{
spatialMappingHelper.UpdateMeshCollider(ChunkList);
}
if (OnMeshReady != null)
{
OnMeshReady();
}
running = false;
}
/// <summary>
/// Properly clears existing scan data when the application is closed.
/// Called by OnApplicationQuit() when the application closes.
/// </summary>
public void Dispose()
{
if (scanningThread != null)
{
updateThreadRunning = false;
scanningThread.Join();
}
ClearMeshes();
GameObject.Destroy(holder);
DisableSpatialMapping();
}
/// <summary>
/// Disable the ZED's spatial mapping. The mesh will no longer be updated, but it is not deleted.
/// This gets called in Update() if the user requested a stop, and will execute once the scanning thread is free.
/// </summary>
private void DisableSpatialMapping()
{
lock (lockScanning)
{
updateThreadRunning = false;
spatialMappingHelper.DisableSpatialMapping();
scanningInitState = sl.ERROR_CODE.FAILURE;
spatialMappingRequested = false;
}
}
/// <summary>
/// Save the mesh as an .obj file, and the area database as an .area file.
/// This can be quite time-comsuming if you mapped a large area.
/// </summary>
public void RequestSaveMesh(string meshFilePath = "Assets/ZEDMesh.obj")
{
saveRequested = true;
savePath = meshFilePath;
if (updateThreadRunning)
{
StopStatialMapping(); //Stop the mapping if it hasn't stopped already.
}
}
/// <summary>
/// Loads the mesh and the corresponding area file if it exists. It can be quite time-comsuming if you mapped a large area.
/// Note that if there are no .area files found in the same folder, the mesh will not be loaded either.
/// Loading a mesh this way also loads relevant data into buffers, so it's as if a scan was just finished
/// rather than a mesh asset being dropped into Unity.
/// <returns><c>True</c> if loaded successfully, otherwise <c>flase</c>.</returns>
/// </summary>
public bool LoadMesh(string meshFilePath = "ZEDMesh.obj")
{
if (holder == null)
{
holder = new GameObject();
holder.name = "[ZED Mesh Holder (" + zedManager.name + ")]";
holder.transform.position = Vector3.zero;
holder.transform.rotation = Quaternion.identity;
StaticBatchingUtility.Combine(holder);
}
if (OnMeshStarted != null)
{
OnMeshStarted();
}
//If spatial mapping has started, disable it.
DisableSpatialMapping();
//Find and load the area
string basePath = meshFilePath.Substring(0, meshFilePath.LastIndexOf("."));
if (!System.IO.File.Exists(basePath + ".area"))
{
Debug.LogWarning(ZEDLogMessage.Error2Str(ZEDLogMessage.ERROR.TRACKING_BASE_AREA_NOT_FOUND));
}
zedCamera.DisableTracking();
Quaternion quat = Quaternion.identity; Vector3 tr = Vector3.zero;
if (zedCamera.EnableTracking(ref quat, ref tr, true, false, false, System.IO.File.Exists(basePath + ".area") ? basePath + ".area" : "") != sl.ERROR_CODE.SUCCESS)
{
Debug.LogWarning(ZEDLogMessage.Error2Str(ZEDLogMessage.ERROR.TRACKING_NOT_INITIALIZED));
}
updateTexture = false;
updatedTexture = false;
bool meshUpdatedLoad = false;
lock (lockScanning)
{
ClearMeshes();
meshUpdatedLoad = spatialMappingHelper.LoadMesh(meshFilePath);
if (meshUpdatedLoad)
{
//Checks if a texture exists.
if (spatialMappingHelper.GetWidthTexture() != -1)
{
updateTexture = true;
updatedTexture = true;
}
//Retrieves the mesh sizes to be updated in the Unity's buffer later.
if (!updateTexture)
{
spatialMappingHelper.RetrieveMesh();
}
}
}
if (meshUpdatedLoad)
{
//Update the buffer on Unity's side.
UpdateMeshMainthread(false);
//Add colliders and scan for gravity.
if (hasColliders)
{
if (!zedManager.IsStereoRig && gravityEstimation != Vector3.zero)
{
Quaternion rotationToApplyForGravity = Quaternion.Inverse(Quaternion.FromToRotation(Vector3.up, -gravityEstimation.normalized));
holder.transform.rotation = rotationToApplyForGravity;
zedManager.gravityRotation = rotationToApplyForGravity;
}
UpdateMeshCollider();
foreach (Chunk c in ChunkList)
{
c.o.transform.localRotation = Quaternion.identity;
}
}
if (OnMeshReady != null)
{
OnMeshReady(); //Call the event if it has at least one listener.
}
return true;
}
return false;
}
/// <summary>
/// Filters the mesh with the current filtering parameters.
/// This reduces the total number of faces. More filtering means fewer faces.
/// </summary>
public void FilterMesh()
{
lock (lockScanning) //Wait for the thread to be available.
{
spatialMappingHelper.FilterMesh(filterParameters);
spatialMappingHelper.ResizeMesh();
spatialMappingHelper.RetrieveMesh();
meshUpdated = true;
}
}
/// <summary>
/// Begin mesh filtering, and consolidate chunks into a reasonably low number when finished.
/// </summary>
/// <param name="filter"></param>
void PostProcessMesh(bool filter = true)
{
isFiltering = true;
if (filter)
{
FilterMesh();
}
MergeChunks();
}
/// <summary>
/// Consolidates meshes to get fewer chunks - one for every MAX_SUBMESH vertices. Then applies to
/// actual meshes in Unity.
/// </summary>
public void MergeChunks()
{
lock (lockScanning)
{
spatialMappingHelper.MergeChunks();
spatialMappingHelper.ResizeMesh();
spatialMappingHelper.RetrieveMesh();
meshUpdated = true;
}
isFiltering = false;
isFilteringOver = true;
}
/// <summary>
/// Multi-threaded component of ApplyTexture(). Filters, then updates the mesh once, but as
/// updateTexture is set to true when this is called, UpdateMesh() will also handle applying the texture.
/// </summary>
void ApplyTextureThreaded()
{
FilterMesh();
UpdateMesh();
}
/// <summary>
/// Stops the spatial mapping and begins the final processing, including adding texture.
/// </summary>
public bool ApplyTexture()
{
updateTexture = true;
if (updateThreadRunning)
{
updateThreadRunning = false;
scanningThread.Join();
}
scanningThread = new Thread(ApplyTextureThreaded);
updateThreadRunning = true;
scanningThread.Start();
texturingRunning = true;
return true;
}
/// <summary>
/// Stop the spatial mapping and calls appropriate functions to process the final mesh.
/// </summary>
private void Stop()
{
gravityEstimation = zedCamera.GetGravityEstimate();
if (isTextured)
{
ApplyTexture();
}
else
{
stopRunning = false;
if (updateThreadRunning)
{
updateThreadRunning = false;
scanningThread.Join();
}
ClearMeshes();
PostProcessMesh(true);
//filterThread = new Thread(() => PostProcessMesh(true));
//filterThread.Start();
stopRunning = true;
}
SwitchDisplayMeshState(true); //Make it default to visible.
}
/// <summary>
/// Returns true from the moment a scan has started until the post-process is finished.
/// </summary>
/// <returns></returns>
public bool IsRunning()
{
return running;
}
/// <summary>
/// Sets a flag that will cause spatial mapping to stop at the next Update() call after all meshes already retrieved from the ZED are applied.
/// </summary>
public void StopStatialMapping()
{
stopWanted = true;
}
/// <summary>
/// Combines the meshes from all the current chunks and saves them into a single mesh. If textured,
/// will also save a .mtl file and .png file.
/// This must only be called once all the chunks are completely finalized, or else they won't be filtered
/// or have their UVs set.
/// Called after RequestSaveMesh has been called after the main thread has the chance to stop the scan
/// and finalize everything.
/// </summary>
/// <param name="meshFilePath">Where the mesh, material, and texture files will be saved.</param>
private void SaveMeshNow(string meshFilePath = "Assets/ZEDMesh.obj")
{
//Make sure the destination file ends in .obj - only .obj file format is supported.
string extension = meshFilePath.Substring(meshFilePath.Length - 4);
if (extension.ToLower() != ".obj")
{
Debug.LogError("Couldn't save to " + meshFilePath + ": Must save as .obj.");
}
lock (lockScanning)
{
Debug.Log("Saving mesh to " + meshFilePath);
//Count how many vertices and triangles are in all the chunk meshes so we know how large of an array to allocate.
int vertcount = 0;
int tricount = 0;
foreach (Chunk chunk in Chunks.Values)
{
vertcount += chunk.mesh.vertices.Length;
tricount += chunk.mesh.triangles.Length;
}
if (vertcount == 0) return;
Vector3[] vertices = new Vector3[vertcount];
Vector2[] uvs = new Vector2[vertcount];
Vector3[] normals = new Vector3[vertcount];
int[] triangles = new int[tricount];
int vertssofar = 0; //We keep an ongoing tally of how many verts/tris we've put so far so as to increment
int trissofar = 0; //where we copy to in the arrays, and also to increment the vertex indices in the triangle array.
for (int i = 0; i < Chunks.Keys.Count; i++)
{
Mesh chunkmesh = Chunks[i].mesh; //Shorthand.
Array.Copy(chunkmesh.vertices, 0, vertices, vertssofar, chunkmesh.vertices.Length);
Array.Copy(chunkmesh.uv, 0, uvs, vertssofar, chunkmesh.uv.Length);
chunkmesh.RecalculateNormals();
Array.Copy(chunkmesh.normals, 0, normals, vertssofar, chunkmesh.normals.Length);
Array.Copy(chunkmesh.triangles, 0, triangles, trissofar, chunkmesh.triangles.Length);
for (int t = trissofar; t < trissofar + chunkmesh.triangles.Length; t++)
{
triangles[t] += vertssofar;
}
vertssofar += chunkmesh.vertices.Length;
trissofar += chunkmesh.triangles.Length;
}
Material savemat = Chunks[0].o.GetComponent<MeshRenderer>().material; //All chunks share the same material.
//We'll need to know the base file name for this and the .mtl file. We'll extract it.
//Since both forward and backslashes are valid for the file pack, determine which they used last.
int forwardindex = meshFilePath.LastIndexOf('/');
int backindex = meshFilePath.LastIndexOf('\\');
int slashindex = forwardindex > backindex ? forwardindex : backindex;
string basefilename = meshFilePath.Substring(slashindex + 1, meshFilePath.LastIndexOf(".") - slashindex - 1);
//Create the string file.
//Importantly, we flip the X value (and reverse the triangles) since the scanning module uses a different handedness than Unity.
StringBuilder objstring = new StringBuilder();
objstring.Append("mtllib " + basefilename + "\n");
objstring.Append("g ").Append("ZEDScan").Append("\n");
foreach (Vector3 vec in vertices)
{
//X is flipped because of Unity's handedness.
objstring.Append(string.Format("v {0} {1} {2}\n", -vec.x, vec.y, vec.z));
}
objstring.Append("\n");
foreach (Vector2 uv in uvs)
{
objstring.Append(string.Format("vt {0} {1}\n", uv.x, uv.y));
}
objstring.Append("\n");
foreach (Vector3 norm in normals)
{
objstring.Append(string.Format("vn {0} {1} {2}\n", -norm.x, norm.y, norm.z));
}
objstring.Append("\n");
if (isTextured)
{
objstring.Append("usemtl ").Append(basefilename).Append("\n");
objstring.Append("usemap ").Append(basefilename).Append("\n");
}
for (int i = 0; i < triangles.Length; i += 3)
{
//Triangles are reversed so that surface normals face the right way after the X vertex flip.
objstring.Append(string.Format("f {0}/{0}/{0} {1}/{1}/{1} {2}/{2}/{2}\n",
triangles[i + 2] + 1, triangles[i + 1] + 1, triangles[i + 0] + 1));
}
System.IO.StreamWriter swriter = new System.IO.StreamWriter(meshFilePath);
swriter.Write(objstring.ToString());
swriter.Close();
//Create a texture and .mtl file for your scan, if textured.
if (isTextured)
{
//First, the texture.
//You can't save a Texture2D directly to a file since it's stored on the GPU.
//So we use a RenderTexture as a buffer, which we can read into a new Texture2D on the CPU-side.
Texture textosave = savemat.mainTexture;
RenderTexture buffertex = new RenderTexture(textosave.width, textosave.height, 0);
Graphics.Blit(textosave, buffertex);
RenderTexture oldactivert = RenderTexture.active;
RenderTexture.active = buffertex;
Texture2D texcopy = new Texture2D(textosave.width, textosave.height);
texcopy.ReadPixels(new Rect(0, 0, buffertex.width, buffertex.height), 0, 0);
texcopy.Apply(); //It's now on the CPU!
byte[] imagebytes = texcopy.EncodeToPNG();
string imagepath = meshFilePath.Substring(0, meshFilePath.LastIndexOf(".")) + ".png";
System.IO.File.WriteAllBytes(imagepath, imagebytes);
RenderTexture.active = oldactivert;
//Now the material file.
StringBuilder mtlstring = new StringBuilder();
mtlstring.Append("newmtl " + basefilename + "\n");
mtlstring.Append("Ka 1.000000 1.000000 1.000000\n");
mtlstring.Append("Kd 1.000000 1.000000 1.000000\n");
mtlstring.Append("Ks 0.000000 0.000000 0.000000\n");
mtlstring.Append("Tr 1.000000\n");
mtlstring.Append("illum 1\n");
mtlstring.Append("Ns 1.000000\n");
mtlstring.Append("map_Kd " + basefilename + ".png");
string mtlpath = meshFilePath.Substring(0, meshFilePath.LastIndexOf(".")) + ".mtl";
swriter = new System.IO.StreamWriter(mtlpath);
swriter.Write(mtlstring.ToString());
swriter.Close();
}
}
//Save the .area file for spatial memory.
string areaName = meshFilePath.Substring(0, meshFilePath.LastIndexOf(".")) + ".area";
zedCamera.SaveCurrentArea(areaName);
}
/// <summary>
/// Used by Unity to draw the meshes in the editor with a double pass shader.
/// </summary>
#if UNITY_EDITOR
private void OnDrawGizmos()
{
Gizmos.color = colorMesh;
if (!IsRunning() && spatialMappingHelper != null && spatialMappingHelper.chunks.Count != 0 && display)
{
foreach (var submesh in spatialMappingHelper.chunks)
{
if (submesh.Value.proceduralMesh.mesh != null)
{
Gizmos.DrawWireMesh(submesh.Value.proceduralMesh.mesh.sharedMesh, submesh.Value.o.transform.position, submesh.Value.o.transform.rotation);
}
}
}
}
#endif
/// <summary>
/// Low-level spatial mapping class. Calls SDK wrapper functions to get mesh data and applies it to Unity meshes.
/// Functions are usually called from ZEDSpatialMapping, but buffer data is held within.
/// Note that some values are updated directly from the ZED wrapper dll, so such assignments aren't visible in the plugin.
/// </summary>
private class ZEDSpatialMappingHelper
{
/// <summary>
/// Reference to the ZEDCamera instance. Used to call SDK functions.
/// </summary>
private sl.ZEDCamera zedCamera;
/// <summary>
/// Maximum number of chunks. It's best to get relatively few chunks and to update them quickly.
/// </summary>
private const int MAX_SUBMESH = 1000;
/*** Number of vertices/triangles/indices per chunk***/
/// <summary>
/// Total vertices in each chunk/submesh.
/// </summary>
private int[] numVerticesInSubmesh = new int[MAX_SUBMESH];
/// <summary>
/// Total triangles in each chunk/submesh.
/// </summary>
private int[] numTrianglesInSubmesh = new int[MAX_SUBMESH];
/// <summary>
/// Total indices per chunk/submesh.
/// </summary>
private int[] UpdatedIndices = new int[MAX_SUBMESH];
/*** Number of vertices/uvs/indices at the moment**/
/// <summary>
/// Vertex count in current submesh.
/// </summary>
private int numVertices = 0;
/// <summary>
/// Triangle point counds in current submesh. (Every three values are the indexes of the three vertexes that make up one triangle)
/// </summary>
private int numTriangles = 0;
/// <summary>
/// How many submeshes were updated.
/// </summary>
private int numUpdatedSubmesh = 0;
/*** The current data in the current submesh***/
/// <summary>
/// Vertices of the current submesh.
/// </summary>
private Vector3[] vertices;
/// <summary>
/// UVs of the current submesh.
/// </summary>
private Vector2[] uvs;
/// <summary>
/// Triangles of the current submesh. (Each int refers to the index of a vertex)
/// </summary>
private int[] triangles;
/// <summary>
/// Width and height of the mesh texture, if any.
/// </summary>
private int[] texturesSize = new int[2];
/// <summary>
/// Dictionary of all existing chunks.
/// </summary>
public Dictionary<int, ZEDSpatialMapping.Chunk> chunks = new Dictionary<int, ZEDSpatialMapping.Chunk>(MAX_SUBMESH);
/// <summary>
/// Material with real-world texture, applied to the mesh when Texturing (isTextured) is enabled.
/// </summary>
private Material materialTexture;
/// <summary>
/// Material used to draw the mesh. Applied to chunks during the scan, and replaced with materialTexture
/// only if Texturing (isTextured) is enabled.
/// </summary>
private Material materialMesh;
/// <summary>
/// Public accessor for the number of chunks that have been updated.
/// </summary>
public int NumberUpdatedSubMesh
{
get { return numUpdatedSubmesh; }
}
/// <summary>
/// Gets the material used to draw spatial mapping meshes without real-world textures.
/// </summary>
/// <returns></returns>
public Material GetMaterialSpatialMapping()
{
return materialMesh;
}
/// <summary>
/// Constructor. Gets the ZEDCamera instance and sets materials used on the meshes.
/// </summary>
/// <param name="materialTexture"></param>
/// <param name="materialMesh"></param>
public ZEDSpatialMappingHelper(sl.ZEDCamera camera, Material materialTexture, Material materialMesh)
{
zedCamera = camera;
this.materialTexture = materialTexture;
this.materialMesh = materialMesh;
}
/// <summary>
/// Updates the range to match the specified preset.
/// </summary>
static public float ConvertRangePreset(RANGE rangePreset)
{
if (rangePreset == RANGE.NEAR)
{
return 3.5f;
}
else if (rangePreset == RANGE.MEDIUM)
{
return 5.0f;
}
if (rangePreset == RANGE.FAR)
{
return 10.0f;
}
return 5.0f;
}
/// <summary>
/// Updates the resolution to match the specified preset.
/// </summary>
static public float ConvertResolutionPreset(RESOLUTION resolutionPreset)
{
if (resolutionPreset == RESOLUTION.HIGH)
{
return 0.05f;
}
else if (resolutionPreset == RESOLUTION.MEDIUM)
{
return 0.10f;
}
if (resolutionPreset == RESOLUTION.LOW)
{
return 0.15f;
}
return 0.10f;
}
/// <summary>
/// Tells the ZED SDK to begin spatial mapping.
/// </summary>
/// <returns></returns>
public sl.ERROR_CODE EnableSpatialMapping(float resolutionMeter, float maxRangeMeter, bool saveTexture)
{
return zedCamera.EnableSpatialMapping(resolutionMeter, maxRangeMeter, saveTexture);
}
/// <summary>
/// Tells the ZED SDK to stop spatial mapping.
/// </summary>
public void DisableSpatialMapping()
{
zedCamera.DisableSpatialMapping();
}
/// <summary>
/// Create a new submesh to contain the data retrieved from the ZED.
/// </summary>
public ZEDSpatialMapping.Chunk CreateNewMesh(int i, Material meshMat, Transform holder)
{
//Initialize the chunk and create a GameObject for it.
ZEDSpatialMapping.Chunk chunk = new ZEDSpatialMapping.Chunk();
chunk.o = GameObject.CreatePrimitive(PrimitiveType.Quad);
chunk.o.layer = zedCamera.TagOneObject;
chunk.o.GetComponent<MeshCollider>().sharedMesh = null;
chunk.o.name = "Chunk" + chunks.Count;
chunk.o.transform.localPosition = Vector3.zero;
chunk.o.transform.localRotation = Quaternion.identity;
Mesh m = new Mesh();
m.MarkDynamic(); //Allows it to be updated regularly without performance issues.
chunk.mesh = m;
//Set graphics settings to not treat the chunk like a physical object (no shadows, no reflections, no lights, etc.).
MeshRenderer meshRenderer = chunk.o.GetComponent<MeshRenderer>();
meshRenderer.material = meshMat;
meshRenderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
meshRenderer.receiveShadows = false;
meshRenderer.enabled = true;
meshRenderer.lightProbeUsage = UnityEngine.Rendering.LightProbeUsage.Off;
meshRenderer.reflectionProbeUsage = UnityEngine.Rendering.ReflectionProbeUsage.Off;
//Sets the position and parent of the chunk.
chunk.o.transform.parent = holder;
chunk.o.layer = zedCamera.TagOneObject;
//Add the chunk to the dictionary.
chunk.proceduralMesh.mesh = chunk.o.GetComponent<MeshFilter>();
chunks.Add(i, chunk);
return chunk;
}
/// <summary>
/// Adds a MeshCollider to each chunk for physics. This is time-consuming, so it's only called
/// once scanning is finished and the final mesh is being processed.
/// </summary>
public void UpdateMeshCollider(List<ZEDSpatialMapping.Chunk> listMeshes, int startIndex = 0)
{
List<int> idsToDestroy = new List<int>(); //List of meshes that are too small for colliders and will be destroyed.
//Update each mesh with a collider.
for (int i = startIndex; i < listMeshes.Count; ++i)
{
var submesh = listMeshes[i];
MeshCollider m = submesh.o.GetComponent<MeshCollider>();
if (m == null)
{
m = submesh.o.AddComponent<MeshCollider>();
}
//If a mesh has 2 or fewer vertices, it's useless, so queue it up to be destroyed.
Mesh tempMesh = submesh.o.GetComponent<MeshFilter>().sharedMesh;
if (tempMesh.vertexCount < 3)
{
idsToDestroy.Add(i);
continue;
}
m.sharedMesh = tempMesh;
m.sharedMesh.RecalculateNormals();
m.sharedMesh.RecalculateBounds();
}
//Destroy all useless meshes now that we've iterated through all the meshes.
for (int i = 0; i < idsToDestroy.Count; ++i)
{
GameObject.Destroy(chunks[idsToDestroy[i]].o);
chunks.Remove(idsToDestroy[i]);
}
Clear(); //Clear the buffer data now that we have Unity meshes.
}
/// <summary>
/// Tells the ZED SDK to calculate the size of the texture and the UVs.
/// </summary>
public void ApplyTexture()
{
zedCamera.ApplyTexture(numVerticesInSubmesh, numTrianglesInSubmesh, ref numUpdatedSubmesh, UpdatedIndices, ref numVertices, ref numTriangles, texturesSize, MAX_SUBMESH);
}
/// <summary>
/// Tells the ZED SDK to update its internal mesh from spatial mapping. The resulting mesh will later be retrieved with RetrieveMesh().
/// </summary>
public void UpdateMesh()
{
zedCamera.UpdateMesh(numVerticesInSubmesh, numTrianglesInSubmesh, ref numUpdatedSubmesh, UpdatedIndices, ref numVertices, ref numTriangles, MAX_SUBMESH);
ResizeMesh();
}
/// <summary>
/// Retrieves the mesh vertices and triangles from the ZED SDK. This must be called after UpdateMesh() has been called.
/// Note that the actual assignment to vertices and triangles happens from within the wrapper .dll via pointers, not a C# script.
/// </summary>
public void RetrieveMesh()
{
zedCamera.RetrieveMesh(vertices, triangles, MAX_SUBMESH, null, System.IntPtr.Zero);
}
/// <summary>
/// Clear the current buffer data.
/// </summary>
public void Clear()
{
chunks.Clear();
vertices = new Vector3[0];
triangles = new int[0];
uvs = new Vector2[0];
System.Array.Clear(vertices, 0, vertices.Length);
System.Array.Clear(triangles, 0, triangles.Length);
}
/// <summary>
/// Process data from a submesh retrieved from the ZED SDK into a chunk, which includes a GameObject and visible mesh.
/// </summary>
/// <param name="indexUpdate">Index of the submesh/chunk to be updated.</param>
/// <param name="verticesOffset">Starting index in the vertices stack.</param>
/// <param name="trianglesOffset">Starting index in the triangles stack.</param>
/// <param name="uvsOffset">Starting index in the UVs stack.</param>
/// <param name="transform">Transform of the holder object to which all chunks are parented.</param>
/// <param name="updatedTex"><c>True</c> if the world texture has been updated so we know to update UVs.</param>
public void SetMesh(int indexUpdate, ref int verticesOffset, ref int trianglesOffset, ref int uvsOffset, Transform holder, bool updatedTex)
{
ZEDSpatialMapping.Chunk subMesh;
int updatedIndex = UpdatedIndices[indexUpdate];
if (!chunks.TryGetValue(updatedIndex, out subMesh)) //Use the existing chunk/submesh if already in the dictionary. Otherwise, make a new one.
{
subMesh = CreateNewMesh(updatedIndex, materialMesh, holder);
}
Mesh currentMesh = subMesh.mesh;
ZEDSpatialMapping.ProceduralMesh dynamicMesh = subMesh.proceduralMesh;
//If the dynamicMesh's triangle and vertex arrays are unassigned or are the wrong size, redo the array.
if (dynamicMesh.triangles == null || dynamicMesh.triangles.Length != 3 * numTrianglesInSubmesh[indexUpdate])
{
dynamicMesh.triangles = new int[3 * numTrianglesInSubmesh[indexUpdate]];
}
if (dynamicMesh.vertices == null || dynamicMesh.vertices.Length != numVerticesInSubmesh[indexUpdate])
{
dynamicMesh.vertices = new Vector3[numVerticesInSubmesh[indexUpdate]];
}
//Clear the old mesh data.
currentMesh.Clear();
//Copy data retrieved from the ZED SDK into the ProceduralMesh buffer in the current chunk.
System.Array.Copy(vertices, verticesOffset, dynamicMesh.vertices, 0, numVerticesInSubmesh[indexUpdate]);
verticesOffset += numVerticesInSubmesh[indexUpdate];
System.Buffer.BlockCopy(triangles, trianglesOffset * sizeof(int), dynamicMesh.triangles, 0, 3 * numTrianglesInSubmesh[indexUpdate] * sizeof(int)); //Block copy has better performance than Array.
trianglesOffset += 3 * numTrianglesInSubmesh[indexUpdate];
currentMesh.vertices = dynamicMesh.vertices;
currentMesh.SetTriangles(dynamicMesh.triangles, 0, false);
dynamicMesh.mesh.sharedMesh = currentMesh;
//If textured, add UVs.
if (updatedTex)
{
Vector2[] localUvs = new Vector2[numVerticesInSubmesh[indexUpdate]];
subMesh.o.GetComponent<MeshRenderer>().sharedMaterial = materialTexture;
System.Array.Copy(uvs, uvsOffset, localUvs, 0, numVerticesInSubmesh[indexUpdate]);
uvsOffset += numVerticesInSubmesh[indexUpdate];
currentMesh.uv = localUvs;
}
}
/// <summary>
/// Retrieves the entire mesh and texture (vertices, triangles, and uvs) from the ZED SDK.
/// Differs for normal retrieval as the UVs and texture are retrieved.
/// This is only called after scanning has been stopped, and only if Texturing is enabled.
/// </summary>
public void SetMeshAndTexture()
{
//If the texture is too large, it's impossible to add the texture to the mesh.
if (texturesSize[0] > 8192) return;
Texture2D textureMesh = new Texture2D(texturesSize[0], texturesSize[1], TextureFormat.RGB24, false);
if (textureMesh != null)
{
System.IntPtr texture = textureMesh.GetNativeTexturePtr();
materialTexture.SetTexture("_MainTex", textureMesh);
vertices = new Vector3[numVertices];
uvs = new Vector2[numVertices];
triangles = new int[3 * numTriangles];
zedCamera.RetrieveMesh(vertices, triangles, MAX_SUBMESH, uvs, texture);
}
}
/// <summary>
/// Loads a mesh from a file path and allocates the buffers accordingly.
/// </summary>
/// <param name="meshFilePath">Path to the mesh file.</param>
/// <returns></returns>
public bool LoadMesh(string meshFilePath)
{
bool r = zedCamera.LoadMesh(meshFilePath, numVerticesInSubmesh, numTrianglesInSubmesh, ref numUpdatedSubmesh, UpdatedIndices, ref numVertices, ref numTriangles, MAX_SUBMESH, texturesSize);
vertices = new Vector3[numVertices];
uvs = new Vector2[numVertices];
triangles = new int[3 * numTriangles];
return r;
}
/// <summary>
/// Gets the width of the scanned texture file. Note that if this is over 8k, the texture will not be taken.
/// </summary>
/// <returns>Texture width in pixels.</returns>
public int GetWidthTexture()
{
return texturesSize[0];
}
public int GetHeightTexture()
{
return texturesSize[1];
}
/// <summary>
/// Resize the mesh buffer according to how many vertices are needed by the current submesh/chunk.
/// </summary>
public void ResizeMesh()
{
if (vertices.Length < numVertices)
{
vertices = new Vector3[numVertices * 2]; //Allocation is faster than resizing.
}
if (triangles.Length < 3 * numTriangles)
{
triangles = new int[3 * numTriangles * 2];
}
}
/// <summary>
/// Filters the mesh with predefined parameters.
/// </summary>
/// <param name="filterParameters">Filter setting. A higher setting results in fewer faces.</param>
public void FilterMesh(sl.FILTER filterParameters)
{
zedCamera.FilterMesh(filterParameters, numVerticesInSubmesh, numTrianglesInSubmesh, ref numUpdatedSubmesh, UpdatedIndices, ref numVertices, ref numTriangles, MAX_SUBMESH);
}
/// <summary>
/// Tells the ZED SDK to consolidate the chunks into a smaller number of large chunks.
/// Useful because having many small chunks is more performant for scanning, but fewer large chunks are otherwise easier to work with.
/// </summary>
public void MergeChunks()
{
zedCamera.MergeChunks(MAX_SUBMESH, numVerticesInSubmesh, numTrianglesInSubmesh, ref numUpdatedSubmesh, UpdatedIndices, ref numVertices, ref numTriangles, MAX_SUBMESH);
}
}
}
Reference in a new issue Copy permalink