/// <summary>
/// Calls GetMeshAsync to update the SurfaceData and re-activate the surface object when ready.
/// </summary>
/// <param name="id">Identifier of the SurfaceData object to update.</param>
/// <param name="surface">The SurfaceData object to update.</param>
private void QueueSurfaceDataRequest(SurfaceId id, GameObject surface)
{
SurfaceData surfaceData = new SurfaceData(id,
surface.GetComponent <MeshFilter>(),
surface.GetComponent <WorldAnchor>(),
surface.GetComponent <MeshCollider>(),
TrianglesPerCubicMeter,
true);
surfaceWorkQueue.Enqueue(surfaceData);
}
private SurfaceData BuildSphereData(Vector2 ssPos)
{
SurfaceData data = new SurfaceData();
data.normal = new Vector3(ssPos.x, ssPos.y, Mathf.Clamp01(Mathf.Sqrt(1f - ssPos.x * ssPos.x - ssPos.y * ssPos.y))).normalized;
data.position = data.normal;
Vector3.OrthoNormalize(ref data.normal, ref data.tangent, ref data.binormal);
return(data);
}
public void SurfaceAnalysisDataBySurfacePointsAndResults_ValidArgs()
{
var sad = SurfaceData.BySurfacePointsAndValues(
TestSurface(),
TestUvs(),
TestResults());
Assert.NotNull(sad);
Assert.NotNull(sad.Surface);
Assert.AreEqual(sad.Values.Count, 3);
}
public void Exit(SurfaceData data)
{
DestinationLocation location = GetLocation(data);
if (location == null)
{
return;
}
location.Exit(data);
}
public void Reset(Transform snapToTransform = null)
{
if (snapToTransform)
{
rigidbody.position = snapToTransform.position;
rigidbody.rotation = snapToTransform.rotation;
}
previousPosition = rigidbody.position;
velocity = Vector3.zero;
surface = SurfaceData.Default;
}
/// <summary>
/// Creates the payload to emit on the hovering events of <see cref="Entered"/> and <see cref="Exited"/>.
/// </summary>
/// <param name="data">The data that is mutating the hover state.</param>
/// <returns>The data to emit.</returns>
protected virtual SurfaceData CreateHoverPayload(SurfaceData data)
{
if (Origin == null || !Origin.activeInHierarchy)
{
return(data);
}
hoverHit = data.CollisionData;
hoverHit.point = Origin.transform.position;
data.CollisionData = hoverHit;
return(data);
}
IEnumerator SurfaceExamples()
{
StartCoroutine(ChangeText(text1, "Surfaces"));
float ExampleSurface(float x, float z) => 4 - x / 10f - z;
SurfaceData es = graph.AddSurface(ExampleSurface, "ES");
es.AnimateX(ease: true, duration: 0.5f);
yield return(new WaitForSeconds(2));
es.WipeSurfaceX();
}
/// <summary>
/// Selects the containing button.
/// </summary>
/// <param name="data">The data to select with.</param>
public virtual void Select(SurfaceData data)
{
if (SpatialTargetDispatcher == null)
{
SpatialTargetFacade.Configuration.TargetController.DoSelect(data);
return;
}
SpatialTargetDispatcher.DoDispatchEnter(data);
SpatialTargetDispatcher.DoDispatchSelect(data);
SpatialTargetDispatcher.DoDispatchExit(data);
}
public void LoadSurfaceData(string path)
{
float[] data = Storage.StorageManager.GetDataAccess().Load <float[]>(path);
Block[] blocks = new Block[data.Length];
for (int i = 0; i < data.Length; i++)
{
blocks[i] = new Block((BlockType)Mathf.FloorToInt(data[i]), MathHelper.Fract(data[i]));
}
// hard-coded size, it will be fix soon
surface = new SurfaceData(1024, blocks);
}
public void Add(SurfaceData surface)
{
int vertexCount = vertices.Count;
vertices.AddRange(surface.vertices);
normals.AddRange(surface.normals);
UVs.AddRange(surface.UVs);
for (int i = 0; i < surface.indices.Count; i++)
{
indices.Add(vertexCount + surface.indices[i]);
}
}
/// <summary>
/// Creates the payload to emit on the hovering events of <see cref="FirstEntered"/>, <see cref="Entered"/>, <see cref="Exited"/> and <see cref="LastExited"/>.
/// </summary>
/// <param name="data">The data that is mutating the hover state.</param>
/// <returns>The mutated data to emit.</returns>
protected virtual SurfaceData CreateHoverPayload(SurfaceData data)
{
if (SourcePointOverride == null || !SourcePointOverride.activeInHierarchy)
{
return(data);
}
hoverHit = data.CollisionData;
hoverHit.point = SourcePointOverride.transform.position;
data.CollisionData = hoverHit;
return(data);
}
/// <summary>
/// Sets the <see cref="ActiveButtonIndex"/> when a button is activate.
/// </summary>
/// <param name="data">The data to retrieve the button being activated.</param>
protected virtual void SetActiveButtonIndexWhenButtonActivated(SurfaceData data)
{
SpatialTargetFacade spatialTarget = data.Transform.gameObject.TryGetComponent <SpatialTargetFacade>(false, true);
if (spatialTarget == null)
{
return;
}
ignoreActiveButtonIndexChanges = true;
ActiveButtonIndex = ButtonList.IndexOf(spatialTarget.gameObject);
ignoreActiveButtonIndexChanges = false;
}
public void ClearPayload()
{
UnityEventListenerMock emittedMock = new UnityEventListenerMock();
subject.Emitted.AddListener(emittedMock.Listen);
SurfaceData payload = new SurfaceData();
subject.Payload = payload;
Assert.AreEqual(payload, subject.Payload);
subject.ClearPayload();
Assert.IsNull(subject.Payload);
}
/// <summary>
/// Casts a <see cref="Ray"/> in the given direction from the given origin to search the nearest surface.
/// </summary>
/// <param name="givenOrigin">The origin to begin the <see cref="Ray"/> from.</param>
/// <param name="givenDirection">The direction in which to cast the <see cref="Ray"/>.</param>
/// <returns><see langword="true"/> if a valid surface is located.</returns>
protected virtual bool CastRay(Vector3 givenOrigin, Vector3 givenDirection)
{
givenOrigin = givenOrigin + (givenDirection.normalized * originOffset);
if (SurfaceData == null)
{
SurfaceData = new SurfaceData();
}
SurfaceData.origin = givenOrigin;
SurfaceData.direction = givenDirection;
Ray tracerRaycast = new Ray(givenOrigin, givenDirection);
return(targetValidity == null ? FindFirstCollision(tracerRaycast) : FindAllCollisions(tracerRaycast));
}
/// <summary>
/// Handler for RequestMeshAsync which will be used to set the layer, material, and collision options on the resulting mesh
/// </summary>
/// <param name="bakedData">The resulting data from the RequestMeshAsync call</param>
/// <param name="outputWritten">Whether or not the output was written</param>
/// <param name="elapsedBakeTimeSeconds">How long the baking took in seconds</param>
protected override void SurfaceObserver_OnDataReady(SurfaceData bakedData, bool outputWritten, float elapsedBakeTimeSeconds)
{
if (bakedData.outputMesh != null)
{
base.SurfaceObserver_OnDataReady(bakedData, outputWritten, elapsedBakeTimeSeconds);
bakedData.outputCollider.gameObject.layer = MeshLayer;
if (PhysicMaterial != null)
{
bakedData.outputCollider.material = PhysicMaterial;
}
bakedData.outputCollider.enabled = _enableCollisions;
}
}
/// <summary>
/// This methods handles the result of a request for mesh data for a surface.
/// These requests have their source in the update loop anytime a request
/// isn't in progress.
/// </summary>
/// <param name="data">The resulting data</param>
/// <param name="outputWritten">If any data has been written</param>
/// <param name="elapsedBakeTimeSeconds">Time it took from request to this function being evoked</param>
private void SurfaceDataReadyHandler(SurfaceData data, bool outputWritten, float elapsedBakeTimeSeconds)
{
_meshRequestInProgress = false;
ISpatialSurface surface;
if (_surfaceEntries.TryGetValue(data.id.handle, out surface))
{
surface.MeshStatus = SurfaceMeshStatuses.UP_TO_DATE;
}
else
{
Debug.LogError("SpatialMapper Error: Id of request surface could not be found!");
}
}
void AddMeshFilter(SurfaceData sd)
{
Debug.Log("Adding MeshFilter to SpatialMapping");
MeshFilter meshFilter = GetComponent <MeshFilter>();
if (meshFilter == null)
{
gameObject.AddComponent <MeshFilter>().mesh = sd.outputMesh.mesh;
}
else
{
meshFilter.mesh = sd.outputMesh.mesh;
}
}
Mesh GenerateMesh(SurfaceData surface)
{
Mesh new_surface_mesh = new Mesh();
surface.TransformToArrayFormat();
new_surface_mesh.vertices = surface.verticesArray;
new_surface_mesh.uv = surface.UVsArray;
new_surface_mesh.triangles = surface.trianglesArray;
//important
new_surface_mesh.RecalculateNormals();
new_surface_mesh.RecalculateBounds();
return(new_surface_mesh);
}
/// <summary>
/// Creates the payload to emit on the <see cref="Activated"/> event.
/// </summary>
/// <param name="data">The default data to potentially mutate.</param>
/// <returns>The data to emit.</returns>
protected virtual TransformData CreateSelectedPayload(SurfaceData data)
{
if (Destination == null || !Destination.activeInHierarchy)
{
return(data);
}
selectedPayload.Clear();
selectedPayload.Transform = Destination.transform;
if (!ApplyDestinationRotation)
{
selectedPayload.RotationOverride = data.Rotation;
}
return(selectedPayload);
}
public virtual void Receive(SurfaceData surfaceData)
{
if (!ValidSurfaceData(surfaceData))
{
return;
}
Vector3 generatedOrigin = GetCollisionPoint(surfaceData.PreviousCollisionData);
Vector3 generatedTarget = GeneratePoint(surfaceData.Position);
bool result = !generatedOrigin.ApproxEquals(generatedTarget, ChangeDistance);
Receive(result);
previousData = surfaceData;
}
public void Receive()
{
UnityEventListenerMock emittedMock = new UnityEventListenerMock();
subject.Emitted.AddListener(emittedMock.Listen);
SurfaceData payload = new SurfaceData();
Assert.IsNull(subject.Payload);
Assert.IsFalse(emittedMock.Received);
subject.Receive(payload);
Assert.AreEqual(payload, subject.Payload);
Assert.IsTrue(emittedMock.Received);
}
public virtual void Enter(SurfaceData data)
{
if (data.Transform == null || !SourceValidity.Accepts(data.Transform))
{
return;
}
IsHovered = true;
HoveringElements.Add(data);
if (HoveringElements.Count == 1)
{
HoverActivated?.Invoke();
}
Entered?.Invoke(CreateHoverPayload(data));
}
public virtual void Exit(SurfaceData data)
{
if (data.Transform == null || !SourceValidity.Accepts(data.Transform) || !HoveringElements.Contains(data))
{
return;
}
IsHovered = false;
HoveringElements.Remove(data);
Exited?.Invoke(CreateHoverPayload(data));
if (HoveringElements.Count == 0)
{
HoverDeactivated?.Invoke();
}
}
public virtual bool Select(SpatialTargetDispatcher dispatcher, SurfaceData data)
{
if (!IsSelectable)
{
return(false);
}
if (ActivatingDispatcher != null && ActivatingDispatcher != dispatcher)
{
ActivatingDispatcher.RemoveFromSelectedTargets(this);
}
ActivatingDispatcher = dispatcher;
return(Select(data));
}
private void Observer_OnSurfaceChanged(SurfaceId surfaceId, SurfaceChange changeType, Bounds bounds, System.DateTime updateTime)
{
GameObject surface;
switch (changeType)
{
case SurfaceChange.Updated:
case SurfaceChange.Added:
if (!surfaces.TryGetValue(surfaceId.handle, out surface))
{
// If we are adding a new surface, construct a GameObject
// to represent its state and attach some Mesh-related
// components to it.
surface = new GameObject(string.Format("Surface-{0}", surfaceId.handle));
surface.AddComponent <MeshFilter>();
surface.AddComponent <MeshRenderer>().sharedMaterial = DrawMaterial;
surface.AddComponent <MeshCollider>();
surface.AddComponent <WorldAnchor>();
// Set the layer that this SpatialMapping surface is a part of
surface.layer = PhysicsLayer;
// Add the surface to our dictionary of known surfaces so
// we can interact with it later.
surfaces[surfaceId.handle] = surface;
surface.transform.parent = transform;
surfaceObjectMeshFilters.Add(surface.GetComponent <MeshFilter>());
}
SurfaceData smsd = new SurfaceData(
surfaceId,
surface.GetComponent <MeshFilter>(),
surface.GetComponent <WorldAnchor>(),
surface.GetComponent <MeshCollider>(),
TrianglesPerCubicMeter,
true);
surfaceDataQueue.Enqueue(smsd);
break;
case SurfaceChange.Removed:
if (surfaces.TryGetValue(surfaceId.handle, out surface))
{
surfaces.Remove(surfaceId.handle);
Destroy(surface);
}
break;
}
}
public void CollisionData()
{
Physics.autoSimulation = false;
SurfaceData surfaceData = new SurfaceData();
//Create a couple of GameObjects for collision detection
GameObject front = GameObject.CreatePrimitive(PrimitiveType.Cube);
front.transform.position = Vector3.forward * 5f;
GameObject bottom = GameObject.CreatePrimitive(PrimitiveType.Cube);
bottom.transform.position = Vector3.down * 5f;
//Do an initial collision
Ray forwardRay = new Ray(Vector3.zero, Vector3.forward);
RaycastHit forwardHit;
Physics.Simulate(Time.fixedDeltaTime);
Physics.Raycast(forwardRay, out forwardHit);
//Set up the initial collision of a surface
surfaceData.Origin = Vector3.zero;
surfaceData.Direction = Vector3.forward;
surfaceData.CollisionData = forwardHit;
//Do an second different collision
Ray downwardRay = new Ray(Vector3.zero, Vector3.down);
RaycastHit downwardHit;
Physics.Simulate(Time.fixedDeltaTime);
Physics.Raycast(downwardRay, out downwardHit);
//Set up the initial collision of a surface
surfaceData.Origin = Vector3.zero;
surfaceData.Direction = Vector3.down;
surfaceData.CollisionData = downwardHit;
Assert.AreEqual(Vector3.zero, surfaceData.Origin);
Assert.AreEqual(Vector3.down, surfaceData.Direction);
Assert.AreEqual(bottom.transform, surfaceData.CollisionData.transform);
Assert.AreEqual(front.transform, surfaceData.PreviousCollisionData.transform);
Assert.AreEqual("{ Transform = [null] | UseLocalValues = False | PositionOverride = [null] | RotationOverride = [null] | ScaleOverride = [null] | Origin = (0.0, 0.0, 0.0) | Direction = (0.0, -1.0, 0.0) | CollisionData = { barycentricCoordinate = (1.0, 0.0, 0.0) | Collider = Cube (UnityEngine.BoxCollider) | Distance = 4.5 | Lightmap Coord = (0.0, 0.0) | Normal = (0.0, 1.0, 0.0) | Point = (0.0, -4.5, 0.0) | Rigidbody = [null] | Texture Coord = (0.0, 0.0) | Texture Coord2 = (0.0, 0.0) | Transform = Cube (UnityEngine.Transform) | Triangle Index = -1 } }", surfaceData.ToString());
Object.DestroyImmediate(front);
Object.DestroyImmediate(bottom);
Physics.autoSimulation = true;
}
public void ReceiveInactiveComponent()
{
UnityEventListenerMock emittedMock = new UnityEventListenerMock();
subject.Emitted.AddListener(emittedMock.Listen);
subject.enabled = false;
SurfaceData payload = new SurfaceData();
Assert.IsNull(subject.Payload);
Assert.IsFalse(emittedMock.Received);
subject.Receive(payload);
Assert.IsNull(subject.Payload);
Assert.IsFalse(emittedMock.Received);
}
public static T HourlySurfaceResult <T>(this SurfaceData surfaceData, tsdSurfaceArray tsdSurfaceArray, int index, T @default = default)
{
if (surfaceData == null || index == -1)
{
return(@default);
}
float value = surfaceData.GetHourlySurfaceResult(index, (int)tsdSurfaceArray);
if (!Core.Query.TryConvert(value, out T result))
{
return(@default);
}
return(result);
}
void Update()
{
if (mappingEnabled)
{
foreach (GameObject surface in surfaces.Values)
{
surface.GetComponent <MeshRenderer>().enabled = DrawVisualMeshes;
}
if (surfaceWorkOutstanding == false && surfaceDataQueue.Count > 0)
{
SurfaceData smsd = surfaceDataQueue.Dequeue();
surfaceWorkOutstanding = Observer.RequestMeshAsync(smsd, Observer_OnDataReady);
}
}
}
public void ReceiveInactiveGameObject()
{
UnityEventListenerMock emittedMock = new UnityEventListenerMock();
subject.Emitted.AddListener(emittedMock.Listen);
subject.gameObject.SetActive(false);
SurfaceData payload = new SurfaceData();
Assert.IsNull(subject.Payload);
Assert.IsFalse(emittedMock.Received);
subject.Receive(payload);
Assert.IsNull(subject.Payload);
Assert.IsFalse(emittedMock.Received);
}
public void Hide()
{
surface = null;
sample = null;
Visibility = Visibility.Collapsed;
}
public void Show(SurfaceData surface)
{
this.surface = surface;
lblMessage.Text = "Opravdu chccete smazat vybraný povrch z databáze";
Visibility = Visibility.Visible;
}
/// <summary>
/// Calls UploadSample method from WCF.
/// </summary>
/// <param name="surface">A WebMech.Web.SurfaceData that specifies
/// data object of surface.</param>
private void UploadSampleWcf(SurfaceData surface)
{
if (surface != null)
{
// show progres
OperationStarting("Ukládání vzorku ...");
byte[] imageArray, pointsArray;
try
{
// image file -> byte array
FileStream stream = uploadData.Image.OpenRead();
imageArray = new byte[stream.Length]; //1048575
stream.Read(imageArray, 0, imageArray.Length);
stream.Close();
// points file -> byte array
stream = uploadData.Points.OpenRead();
pointsArray = new byte[stream.Length]; //1048575
stream.Read(pointsArray, 0, pointsArray.Length);
stream.Close();
}
catch (Exception e)
{
OperationFailing("Exception" + Environment.NewLine + e.Message);
return;
}
// call WCF method asynchronously
client.UploadSampleAsync(surface, uploadData.Image.Name, imageArray, uploadData.Points.Name, pointsArray);
}
}
/// <summary>
/// Calls DeleteSurface method from WCF.
/// </summary>
/// <param name="deleteSurface">A WebMech.Web.SurfaceData that specifies
/// data object of surface.</param>
private void DeleteSurfaceWcf(SurfaceData deleteSurface)
{
if (deleteSurface != null)
{
// show progress
OperationStarting("Mazání povrchu ...");
// call WCF method asynchronously
client.DeleteSurfaceAsync(deleteSurface);
}
}
/// <summary>
/// Uploads new sample.
/// </summary>
/// <param name="surface">A WebMech.Web.SurfaceData that specifies
/// data object of surface.</param>
public void UploadSample(SurfaceData surface)
{
UploadSampleWcf(surface);
}
/// <summary>
/// Deletes the surface.
/// </summary>
/// <param name="surfaceData">A WebMech.Web.SurfaceData that specifies
/// data object of surface.</param>
public void DeleteSurface(SurfaceData surfaceData)
{
DeleteSurfaceWcf(surfaceData);
}