/// <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); }