public bool GetState(InputDevice inputDevice) { return(!Mathf.Approximately(GetValue(inputDevice), 0.0f)); }
public static float Remainder(float _numerator, float _denominator) { return(Mathf.Approximately(_denominator, 0) ? 0 : (_numerator % _denominator)); }
void Update() { if (!gameManager.roundStarted) { return; } if (this.isOnSurface > 1) { this.isWalking = false; this.movement = Vector3.zero; float horiInput = Input.GetAxisRaw("Horizontal"); float vertInput = Input.GetAxisRaw("Vertical"); if (!Mathf.Approximately(horiInput, 0) || !Mathf.Approximately(vertInput, 0)) { this.gameObject.transform.up = new Vector3(horiInput * speed * Time.deltaTime, vertInput * speed * Time.deltaTime, 0.0f); } // I had the bright idea of raycasting three times instead of making a collider // If you stumble on this code, learn from my stupidity and this better // - Miguel RaycastHit2D hit1 = Physics2D.Raycast(this.transform.position + this.transform.up * 0.5f + this.transform.transform.right * 0.1f, this.transform.up, 0.5f, this.layerMask); RaycastHit2D hit2 = Physics2D.Raycast(this.transform.position + this.transform.up * 0.5f - this.transform.transform.right * 0.1f, this.transform.up, 0.5f, this.layerMask); RaycastHit2D hit3 = Physics2D.Raycast(this.transform.position + this.transform.up * 0.5f, this.transform.up, 0.5f, this.layerMask); if (!Mathf.Approximately(horiInput, 0)) { this.movement += new Vector3(horiInput * speed * Time.deltaTime, 0.0f, 0.0f); this.isWalking = true; } if (!Mathf.Approximately(vertInput, 0)) { if ((hit1.collider != null || hit2.collider != null) && vertInput > 0.0f) { this.movement += new Vector3(0.0f, vertInput * speed * Time.deltaTime, 0.0f); } else if (vertInput < 0.0f) { this.movement += new Vector3(0.0f, vertInput * speed * Time.deltaTime, 0.0f); } this.isWalking = true; } if (Input.GetButton("Jump") && canJump) { canJump = false; this.isWalking = false; this.animator.ResetTrigger("Idle"); this.animator.ResetTrigger("Walk"); this.animator.SetTrigger("Jump"); this.movement += new Vector3(0.0f, vertInput * speed * Time.deltaTime, 0.0f); this.GetComponent <Rigidbody2D>().velocity = this.movement * jump; this.audioSource.PlayOneShot(this.jumpSound); if (!makingWeb) { this.startingWeb = true; this.web = Instantiate(this.webOriginal); } StartCoroutine("CooldownJump"); } if (this.isWalking) { this.animator.ResetTrigger("Idle"); this.animator.SetTrigger("Walk"); } else { this.animator.ResetTrigger("Walk"); this.animator.SetTrigger("Idle"); } if (this.isWalking) { this.gameObject.transform.position += this.movement; } /* this.gameObject.transform.up = this.movement; */ } else { this.GetComponent <Rigidbody2D>().gravityScale = 1; } if (this.makingWeb) { this.EndWeb(this.gameObject.transform.GetChild(0).transform.position); } }
private bool LineContainsPoint(Point point, Pair <Point, Point> line) { return(Mathf.Approximately(Point.Distance(line.First, point) + Point.Distance(line.Second, point), Point.Distance(line.First, line.Second))); }
private void PaintControls() { float areaWidth = PreferencesWindow.WIN_MIN_WIDTH - PreferencesWindow.SIDEBAR_WIDTH; float areaHeight = PreferencesWindow.WIN_MIN_HEIGHT - EditorGUIUtility.singleLineHeight; Rect btnPrevRect = new Rect( areaWidth / 2.0f - (CONTROL_DOT_WIDTH * this.pages.Length / 2.0f) - CONTROL_BTN_WIDTH, areaHeight - EditorGUIUtility.singleLineHeight - CONTROL_MARGIN_BOTTOM, CONTROL_BTN_WIDTH, EditorGUIUtility.singleLineHeight ); Rect btnNextRect = new Rect( areaWidth / 2.0f + (CONTROL_DOT_WIDTH * this.pages.Length / 2.0f), areaHeight - EditorGUIUtility.singleLineHeight - CONTROL_MARGIN_BOTTOM, CONTROL_BTN_WIDTH, EditorGUIUtility.singleLineHeight ); EditorGUI.BeginDisabledGroup(Mathf.Approximately(this.animPagesIndex.target, 0.0f)); if (GUI.Button(btnPrevRect, "Previous", EditorStyles.miniButtonLeft)) { float target = this.animPagesIndex.target - 1.0f; if (target < 0.0f) { target = 0.0f; } this.animPagesIndex.target = target; } EditorGUI.EndDisabledGroup(); for (int i = 0; i < this.pages.Length; ++i) { Rect btnDot = new Rect( areaWidth / 2.0f - (CONTROL_DOT_WIDTH * this.pages.Length / 2.0f) + (CONTROL_DOT_WIDTH * i), areaHeight - EditorGUIUtility.singleLineHeight - CONTROL_MARGIN_BOTTOM, CONTROL_DOT_WIDTH, EditorGUIUtility.singleLineHeight ); GUIStyle dotStyle = (Mathf.Approximately(this.animPagesIndex.target, (float)i) ? this.controlDotActive : this.controlDotNormal ); if (GUI.Button(btnDot, (i + 1).ToString(), dotStyle)) { this.animPagesIndex.target = (float)i; } } EditorGUI.BeginDisabledGroup(Mathf.Approximately(this.animPagesIndex.target, this.pages.Length - 1.0f)); if (GUI.Button(btnNextRect, "Next", EditorStyles.miniButtonRight)) { float target = this.animPagesIndex.target + 1.0f; if (target > this.pages.Length - 1.0f) { target = this.pages.Length - 1.0f; } this.animPagesIndex.target = target; } EditorGUI.EndDisabledGroup(); }
void UpdateBarValue() { if (effectBurn) { if (effectSmoothChange) { // in burn mode smooth primary bar only when it's increasing bool canGoUp = effectSmoothChangeDirection == SmoothDirection.Both || effectSmoothChangeDirection == SmoothDirection.OnlyWhenIncreasing; if (ValueF > ValueF2 && canGoUp) { EnergyBarCommons.SmoothDisplayValue(ref ValueF2, ValueF, effectSmoothChangeSpeed); } else { ValueF2 = energyBar.ValueF; } if (!Mathf.Approximately(ValueF, ValueF2)) { effectSmoothChangeWorking = true; } else if (effectSmoothChangeWorking) { effectSmoothChangeFinishedNotify.Execute(this); effectSmoothChangeWorking = false; } } else { ValueF2 = energyBar.ValueF; } } else { if (effectSmoothChange) { bool canGoUp = effectSmoothChangeDirection == SmoothDirection.Both || effectSmoothChangeDirection == SmoothDirection.OnlyWhenIncreasing; bool canGoDown = effectSmoothChangeDirection == SmoothDirection.Both || effectSmoothChangeDirection == SmoothDirection.OnlyWhenDecreasing; if ((ValueF > ValueF2 && canGoUp) || (ValueF < ValueF2 && canGoDown)) { EnergyBarCommons.SmoothDisplayValue(ref ValueF2, ValueF, effectSmoothChangeSpeed); } else { ValueF2 = energyBar.ValueF; } if (!Mathf.Approximately(ValueF, ValueF2)) { effectSmoothChangeWorking = true; } else if (effectSmoothChangeWorking) { effectSmoothChangeFinishedNotify.Execute(this); effectSmoothChangeWorking = false; } } else { ValueF2 = energyBar.ValueF; } } }
void DrawSelectionToolUI() { GUILayout.Label(selectedCount + " particle(s) selected"); GUILayout.BeginHorizontal(); if (GUILayout.Button("Invert", GUILayout.Width(88))) { for (int i = 0; i < selectionStatus.Length; i++) { if (actor.active[i]) { selectionStatus[i] = !selectionStatus[i]; } } SelectionChanged(); } GUI.enabled = selectedCount > 0; if (GUILayout.Button("Clear", GUILayout.Width(88))) { for (int i = 0; i < selectionStatus.Length; i++) { selectionStatus[i] = false; } SelectionChanged(); } GUI.enabled = true; GUILayout.EndHorizontal(); GUILayout.BeginHorizontal(); if (GUILayout.Button("Select fixed", GUILayout.Width(88))) { for (int i = 0; i < actor.invMasses.Length; i++) { if (actor.active[i] && actor.invMasses[i] == 0) { selectionStatus[i] = true; } } SelectionChanged(); } GUI.enabled = selectedCount > 0; if (GUILayout.Button("Unselect fixed", GUILayout.Width(88))) { for (int i = 0; i < actor.invMasses.Length; i++) { if (actor.active[i] && actor.invMasses[i] == 0) { selectionStatus[i] = false; } } SelectionChanged(); } GUI.enabled = true; GUILayout.EndHorizontal(); GUI.enabled = selectedCount > 0; GUILayout.BeginHorizontal(); if (GUILayout.Button(new GUIContent("Fix", EditorGUIUtility.Load("PinIcon.psd") as Texture2D), GUILayout.MaxHeight(18), GUILayout.Width(88))) { Undo.RecordObject(actor, "Fix particles"); for (int i = 0; i < selectionStatus.Length; i++) { if (selectionStatus[i]) { if (actor.invMasses[i] != 0) { SetPropertyValue(ParticleProperty.MASS, i, Mathf.Infinity); newProperty = GetPropertyValue(ParticleProperty.MASS, i); actor.velocities[i] = Vector3.zero; } } } actor.PushDataToSolver(new ObiSolverData(ObiSolverData.ParticleData.INV_MASSES | ObiSolverData.ParticleData.VELOCITIES)); EditorUtility.SetDirty(actor); } if (GUILayout.Button(new GUIContent("Unfix", EditorGUIUtility.Load("UnpinIcon.psd") as Texture2D), GUILayout.MaxHeight(18), GUILayout.Width(88))) { Undo.RecordObject(actor, "Unfix particles"); for (int i = 0; i < selectionStatus.Length; i++) { if (selectionStatus[i]) { if (actor.invMasses[i] == 0) { SetPropertyValue(ParticleProperty.MASS, i, 1); } } } actor.PushDataToSolver(new ObiSolverData(ObiSolverData.ParticleData.INV_MASSES)); EditorUtility.SetDirty(actor); } /*if (GUILayout.Button("CUT")){ * ObiCloth mesh = ((ObiCloth)actor); * mesh.DistanceConstraints.RemoveFromSolver(null); * mesh.AerodynamicConstraints.RemoveFromSolver(null); * MeshBuffer buf = new MeshBuffer(mesh.clothMesh); * * int[] sel = new int[2]; * int k = 0; * for(int i = 0; i < selectionStatus.Length; i++){ * if (selectionStatus[i]){ * sel[k] = i; * k++; * if (k == 2) break; * } * } * * int cindex = -1; * for (int j = 0; j < mesh.DistanceConstraints.restLengths.Count; j++){ * if ((mesh.DistanceConstraints.springIndices[j*2] == sel[0] && mesh.DistanceConstraints.springIndices[j*2+1] == sel[1]) || * (mesh.DistanceConstraints.springIndices[j*2] == sel[1] && mesh.DistanceConstraints.springIndices[j*2+1] == sel[0])){ * cindex = j; * break; * } * } * if (cindex >= 0) * mesh.Tear(cindex,buf); * * * mesh.DistanceConstraints.AddToSolver(mesh); * mesh.AerodynamicConstraints.AddToSolver(mesh); * buf.Apply(); * * mesh.GetMeshDataArrays(mesh.clothMesh); * }*/ GUILayout.EndHorizontal(); GUILayout.BeginHorizontal(); GUI.enabled = selectedCount > 0; if (GUILayout.Button("Create Handle", GUILayout.Width(180))) { // Create the handle: GameObject c = new GameObject("Obi Handle"); Undo.RegisterCreatedObjectUndo(c, "Create Obi Particle Handle"); ObiParticleHandle handle = c.AddComponent <ObiParticleHandle>(); handle.Actor = actor; // Calculate position of handle from average of particle positions: Vector3 average = Vector3.zero; for (int i = 0; i < selectionStatus.Length; i++) { if (selectionStatus[i]) { average += wsPositions[i]; } } c.transform.position = average / selectedCount; // Add the selected particles to the handle: for (int i = 0; i < selectionStatus.Length; i++) { if (selectionStatus[i]) { handle.AddParticle(i, wsPositions[i], actor.invMasses[i]); } } } GUI.enabled = true; GUILayout.EndHorizontal(); GUILayout.BeginHorizontal(); EditorGUI.showMixedValue = false; for (int i = 0; i < selectionStatus.Length; i++) { if (selectionStatus[i] && !Mathf.Approximately(GetPropertyValue(currentProperty, i), selectionProperty)) { EditorGUI.showMixedValue = true; } } newProperty = EditorGUILayout.FloatField(newProperty, GUILayout.Width(88)); EditorGUI.showMixedValue = false; if (GUILayout.Button("Set " + GetPropertyName(), GUILayout.Width(88))) { Undo.RecordObject(actor, "Set particle property"); selectionProperty = newProperty; for (int i = 0; i < selectionStatus.Length; i++) { if (selectionStatus[i]) { SetPropertyValue(currentProperty, i, selectionProperty); } } ParticlePropertyChanged(); EditorUtility.SetDirty(actor); } GUILayout.EndHorizontal(); GUI.enabled = true; }
public static bool IsUniformScale(Vector3 toCheck) { return(Mathf.Approximately(toCheck.x, toCheck.y) && Mathf.Approximately(toCheck.y, toCheck.z)); }
private void OrderBySide() { var increase = Vector3.zero; int axisX = _orderAxis & (int)(OrderAxis.X); int axisY = _orderAxis & (int)(OrderAxis.X); int axisZ = _orderAxis & (int)(OrderAxis.X); if (axisX != 0) { Array.Sort(_gameObjects, (object x, object y) => { GameObject a = (GameObject)x; GameObject b = (GameObject)y; return(a.transform.position.x.CompareTo(b.transform.position.x)); }); if (_alignment == TextAlignment.Left) { increase.x = _distance; } else if (_alignment == TextAlignment.Right) { Array.Reverse(_gameObjects); increase.x = -_distance; } } if (axisY != 0) { Array.Sort(_gameObjects, (object x, object y) => { GameObject a = (GameObject)x; GameObject b = (GameObject)y; return(a.transform.position.y.CompareTo(b.transform.position.y)); }); if (_alignment == TextAlignment.Left) { increase.y = _distance; } else if (_alignment == TextAlignment.Right) { Array.Reverse(_gameObjects); increase.y = -_distance; } } if (axisZ != 0) { Array.Sort(_gameObjects, (object x, object y) => { GameObject a = (GameObject)x; GameObject b = (GameObject)y; return(a.transform.position.z.CompareTo(b.transform.position.z)); }); if (_alignment == TextAlignment.Left) { increase.z = _distance; } else if (_alignment == TextAlignment.Right) { Array.Reverse(_gameObjects); increase.z = -_distance; } } var firstPos = _gameObjects[0].transform.position; var increasePos = increase; for (var i = 1; i < _gameObjects.Length; i++) { var pos = _gameObjects[i].transform.position; if (!Mathf.Approximately(increase.x, 0)) { pos.x = firstPos.x + increasePos.x; } else if (!Mathf.Approximately(increase.y, 0)) { pos.y = firstPos.y + increasePos.y; } else if (!Mathf.Approximately(increase.z, 0)) { pos.z = firstPos.z + increasePos.z; } _gameObjects[i].transform.position = pos; increasePos += increase; } }
public void AddDanger(Vector3 position, float amount) { for (int index = 0; index < this.All.Count; ++index) { if (Mathf.Approximately((float)this.All[index].Position.x, (float)position.x) && Mathf.Approximately((float)this.All[index].Position.y, (float)position.y) && Mathf.Approximately((float)this.All[index].Position.z, (float)position.z)) { Memory.SeenInfo seenInfo = this.All[index]; seenInfo.Danger = amount; this.All[index] = seenInfo; return; } } this.All.Add(new Memory.SeenInfo() { Position = position, Timestamp = Time.get_realtimeSinceStartup(), Danger = amount }); }
private bool Approximately(Color a, Color b) { return(Mathf.Approximately(a.r, b.r) && Mathf.Approximately(a.g, b.g) && Mathf.Approximately(a.b, b.b)); }
/// <summary> /// Coroutine to handle the transition delay. /// </summary> /// <returns></returns> protected override IEnumerator TransitionLoop() { // early exit if skipping when in cross transition if (SkipOnCrossTransition && TransitionController.Instance.IsInCrossTransition) { yield break; } // if delay and duration are both zero then just set to end state, otherwise set to start and transition if (Mathf.Approximately(Delay + Duration, 0)) { SetProgressToEnd(); TransitionStarted(); } else { TransitionStarted(); // delay if (!Mathf.Approximately(Delay, 0)) { yield return(new WaitForSeconds(Delay)); } if (SceneChangeMode == SceneChangeModeType.CrossTransition) { TransitionController.Instance.IsInCrossTransition = true; yield return (TransitionController.Instance.StartCoroutine( TransitionController.Instance.TakeScreenshotCoroutine())); SetTransitionDisplayedState(true); StartValue = 1; EndValue = 0; SetProgressToStart(); yield return (TransitionController.Instance.StartCoroutine( TransitionController.Instance.LoadSceneAndWaitForLoad(SceneToLoad))); } else { SetTransitionDisplayedState(true); SetProgressToStart(); } // calculate normalised multiplication factor and avoid / by 0 error. var normalisedFactor = Mathf.Approximately(Duration, 0) ? float.MaxValue : (1 / Duration); // repeat while progress is less than one. while (Progress < 1 && !IsStopped) { // update progress if not paused if (!IsPaused) { SetProgress(Progress + normalisedFactor * Time.deltaTime); } yield return(0); } } // if we completed and weren't stopped if (Mathf.Approximately(Progress, 1) && !IsStopped) { TransitionCompleted(); } }
public override void OnInspectorGUI() { // Update the serializedProperty - always do this in the beginning of OnInspectorGUI. serializedObject.Update(); if (Application.isPlaying) { GUI.enabled = false; } LightingSystem lightingSystem = (LightingSystem)target; Camera cam = lightingSystem.GetComponent <Camera>(); bool isMobileTarget = EditorUserBuildSettings.activeBuildTarget == BuildTarget.iOS || EditorUserBuildSettings.activeBuildTarget == BuildTarget.Android; if (cam == null) { EditorGUILayout.LabelField("WARNING: No attached camera found."); } EditorGUILayout.PropertyField(_lightPixelSize, new GUIContent("Light Pixel Size")); bool sizeChanged = false; #if LIGHT2D_2DTK var tk2dCamera = lightingSystem.GetComponent <tk2dCamera>(); var tk2dCamSize = tk2dCamera == null ? (cam == null ? 0 : cam.orthographicSize) : tk2dCamera.ScreenExtents.yMax; var currSizeChanged = !Mathf.Approximately(tk2dCamSize, _old2dtkCamSize); _old2dtkCamSize = tk2dCamSize; if (currSizeChanged) { _sizeChangeTime = DateTime.Now; } sizeChanged = (DateTime.Now - _sizeChangeTime).TotalSeconds < 0.2f; #endif if (cam != null) { float size; if (cam.orthographic) { #if LIGHT2D_2DTK float zoom = (tk2dCamera == null ? 1 : tk2dCamera.ZoomFactor); size = (cam.orthographicSize * zoom + _lightCameraSizeAdd.floatValue) * 2f; #else size = (cam.orthographicSize + _lightCameraSizeAdd.floatValue) * 2f; #endif } else { float halfFov = (cam.fieldOfView + _lightCameraFovAdd.floatValue) * Mathf.Deg2Rad / 2f; size = Mathf.Tan(halfFov) * _lightObstaclesDistance.floatValue * 2; } if (!Application.isPlaying) { int lightTextureHeight = Mathf.RoundToInt(size / _lightPixelSize.floatValue); int oldSize = lightTextureHeight; lightTextureHeight = EditorGUILayout.IntField("Light Texture Height", lightTextureHeight); if (lightTextureHeight % 2 != 0) { lightTextureHeight++; } if (lightTextureHeight < 16) { if (lightTextureHeight < 8) { lightTextureHeight = 8; } EditorGUILayout.LabelField("WARNING: Light Texture Height is too small."); EditorGUILayout.LabelField(" 50-200 (mobile) and 200-1000 (pc) is recommended."); } if (lightTextureHeight > (isMobileTarget ? 200 : 1000)) { if (lightTextureHeight > 2048) { lightTextureHeight = 2048; } EditorGUILayout.LabelField("WARNING: Light Texture Height is too big."); EditorGUILayout.LabelField(" 50-200 (mobile) and 200-1000 (pc) is recommended."); } if (oldSize != lightTextureHeight && !sizeChanged) { _lightPixelSize.floatValue = size / lightTextureHeight; } } } if (cam == null || cam.orthographic) { EditorGUILayout.PropertyField(_lightCameraSizeAdd, new GUIContent("Light Camera Size Add")); } else { EditorGUILayout.PropertyField(_lightCameraFovAdd, new GUIContent("Light Camera Fov Add")); EditorGUILayout.PropertyField(_lightObstaclesDistance, new GUIContent("Camera To Light Obstacles Distance")); } EditorGUILayout.PropertyField(_hdr, new GUIContent("64 Bit Color")); EditorGUILayout.PropertyField(_lightObstaclesAntialiasing, new GUIContent("Light Obstacles Antialiasing")); EditorGUILayout.PropertyField(_enableNormalMapping, new GUIContent("Normal Mapping")); if (_enableNormalMapping.boolValue && isMobileTarget) { EditorGUILayout.LabelField("WARNING: Normal mapping is not supported on mobiles."); } EditorGUILayout.PropertyField(_affectOnlyThisCamera, new GUIContent("Affect Only This Camera")); _lightTexturesFilterMode.enumValueIndex = (int)(FilterMode)EditorGUILayout.EnumPopup("Texture Filtering", (FilterMode)_lightTexturesFilterMode.enumValueIndex); EditorGUILayout.PropertyField(_blurLightSources, new GUIContent("Blur Light Sources")); if (_blurLightSources.boolValue && _enableNormalMapping.boolValue) { EditorGUILayout.LabelField(" Blurring light sources with normal mapping enabled\n"); EditorGUILayout.LabelField(" could significantly reduce lighting quality."); } bool normalGuiEnableState = GUI.enabled; if (!_blurLightSources.boolValue) { GUI.enabled = false; } EditorGUILayout.PropertyField(_lightSourcesBlurMaterial, new GUIContent(" Light Sources Blur Material")); GUI.enabled = normalGuiEnableState; EditorGUILayout.PropertyField(_enableAmbientLight, new GUIContent("Enable Ambient Light")); if (!_enableAmbientLight.boolValue) { GUI.enabled = false; } EditorGUILayout.PropertyField(_blurAmbientLight, new GUIContent(" Blur Ambient Light")); bool oldEnabled = GUI.enabled; if (!_blurAmbientLight.boolValue) { GUI.enabled = false; } EditorGUILayout.PropertyField(_ambientLightBlurMaterial, new GUIContent(" Ambient Light Blur Material")); GUI.enabled = oldEnabled; EditorGUILayout.PropertyField(_ambientLightComputeMaterial, new GUIContent(" Ambient Light Compute Material")); GUI.enabled = normalGuiEnableState; EditorGUILayout.PropertyField(_lightOverlayMaterial, new GUIContent("Light Overlay Material")); EditorGUILayout.PropertyField(_lightCamera, new GUIContent("Lighting Camera")); EditorGUILayout.PropertyField(_BgCamera, new GUIContent("BG Camera")); _lightSourcesLayer.intValue = EditorGUILayout.LayerField(new GUIContent("Light Sources Layer"), _lightSourcesLayer.intValue); _lightObstaclesLayer.intValue = EditorGUILayout.LayerField(new GUIContent("Light Obstacles Layer"), _lightObstaclesLayer.intValue); _ambientLightLayer.intValue = EditorGUILayout.LayerField(new GUIContent("Ambient Light Layer"), _ambientLightLayer.intValue); // Apply changes to the serializedProperty - always do this in the end of OnInspectorGUI. serializedObject.ApplyModifiedProperties(); }
public static Vector2 Slider2D(int id, Vector2 position, CapFunction drawCapFunction, Vector3 planeNormal, Vector3 planePosition) { EventType eventType = Event.current.GetTypeForControl(id); switch (eventType) { case EventType.MouseDown: if (Event.current.button == 0 && HandleUtility.nearestControl == id && !Event.current.alt) { GUIUtility.keyboardControl = id; GUIUtility.hotControl = id; s_CurrentMousePosition = Event.current.mousePosition; s_DragStartScreenPosition = Event.current.mousePosition; Vector2 b = HandleUtility.WorldToGUIPoint(position); s_DragScreenOffset = s_CurrentMousePosition - b; EditorGUIUtility.SetWantsMouseJumping(1); Event.current.Use(); } break; case EventType.MouseUp: if (GUIUtility.hotControl == id && (Event.current.button == 0 || Event.current.button == 2)) { GUIUtility.hotControl = 0; Event.current.Use(); EditorGUIUtility.SetWantsMouseJumping(0); } break; case EventType.MouseDrag: if (GUIUtility.hotControl == id) { s_CurrentMousePosition = Event.current.mousePosition; Vector2 center = position; position = GUIToWorld(s_CurrentMousePosition - s_DragScreenOffset, planeNormal, planePosition); if (!Mathf.Approximately((center - position).magnitude, 0f)) { GUI.changed = true; } Event.current.Use(); } break; case EventType.KeyDown: if (GUIUtility.hotControl == id && Event.current.keyCode == KeyCode.Escape) { position = GUIToWorld(s_DragStartScreenPosition - s_DragScreenOffset); GUIUtility.hotControl = 0; GUI.changed = true; Event.current.Use(); } break; } if (drawCapFunction != null) { drawCapFunction(id, position, Quaternion.identity, 1f, eventType); } return(position); }
public static bool Zero(float v) { return(Mathf.Approximately(v, 0.0f)); }
private void guidanceProcess() { if (weaponRef.launched) { myFlightControl.enabled = true; // Target bearing line // ============================ ESTIMATIONS float deltaVBoost = Mathf.Min(Mathf.Abs(estimatedTimeToImpact), rocketMotor.burnTime) * rocketMotor.thrustForce; float deltaVCruise = Mathf.Min(Mathf.Abs(estimatedTimeToImpact - rocketMotor.burnTime), rocketMotor.cruiseTime) * rocketMotor.cruiseThrust; if (estimatedTimeToImpact < rocketMotor.burnTime) { deltaVCruise = 0; } //Debug.LogWarning("DeltaVBoost" + deltaVBoost + "DeltaVCruise: " + deltaVCruise); // estimate average missile speed based on distance, thrust, remaining burn time, altitude difference estimatedMissileVelocityAverage = myRB.velocity + transform.forward.normalized * deltaVBoost + transform.forward.normalized * deltaVCruise - Vector3.up * (targetPos_now.y - transform.position.y) * assumedGravityAccel; //estimatedMissileVelocityAverage = myRB.velocity; // estimate closing speed -- positive for closing, negative for separating Vector3 closingVector = Vector3.Project(estimatedTargetVelocityAverage - estimatedMissileVelocityAverage, targetBearingLine); float closingSpeed = closingVector.magnitude; // if closing vect not in same direction as bearing line, we are separating. Change sign to negative if (!Mathf.Approximately(Vector3.Angle(-closingVector, targetBearingLine), 0.0f)) { closingSpeed *= -1; } // estimate time to intercept estimatedTimeToImpact = Vector3.Distance(targetPos_now, transform.position) / closingSpeed; float burnTime = rocketMotor.burnTime + rocketMotor.cruiseTime; float glideTime = Mathf.Max(0.0f, estimatedTimeToImpact - burnTime); estimatedMissileVelocityAverage *= timeRemainDragEstFactor / (glideTime + timeRemainDragEstFactor); // estimate target average velocity //estimatedTargetVelocityAverage = targetRB.velocity + (targetAccel * estimatedTimeToImpact / 2); estimatedTargetVelocityAverage = targetVel_now; // Debug.Log("Estimations ------------ estimated missile average velocity: " + estimatedMissileVelocityAverage.magnitude + // " estimated TARGET average velocity: " + estimatedTargetVelocityAverage.magnitude + " estimated time to impact: " + // estimatedTimeToImpact + " seconds, closing speed: " + closingSpeed); // Debug.DrawRay(transform.position, estimatedMissileVelocityAverage, Color.magenta); // show estimated missilve velocity average // Debug.DrawRay(targetPos_now, estimatedTargetVelocityAverage, Color.magenta); // estimated target average velocity // Debug.DrawRay(transform.position, closingVector, Color.white); //================================== LEAD ANGLE CALCULATION // Lead axis (cross of bearing line and target velocity) Vector3 leadRotationAxis = Vector3.Cross(targetBearingLine, estimatedTargetVelocityAverage); // Target tangential velocity --> missile will try to match its tangential velocity to this Vector3 targetTangentialVelocity = Vector3.Project(estimatedTargetVelocityAverage, Vector3.Cross(leadRotationAxis, targetBearingLine)); //Debug.DrawRay(targetPos_now, targetTangentialVelocity, Color.blue); //Debug.DrawRay(targetPos_now, estimatedTargetVelocityAverage, Color.cyan); //Debug.Log("Estimated target average velocity: " + estimatedTargetVelocityAverage.magnitude); // Lead angle -- direction vector // - trig from velocity magnitude to get angle where tangential velocity matches target tangential velocity float leadAngleDegrees = Mathf.Rad2Deg * Mathf.Asin(targetTangentialVelocity.magnitude / estimatedMissileVelocityAverage.magnitude); leadAngleDegrees = Mathf.Min(leadAngleDegrees, myRadar.scanConeAngle * scanConeFactor); //Debug.Log("leadAngleDegrees: " + leadAngleDegrees); //Debug.DrawRay(transform.position, leadRotationAxis.normalized * 10f); // Lead direction Vector3 leadDirection = Quaternion.AngleAxis(leadAngleDegrees, leadRotationAxis) * targetBearingLine.normalized; // Show lead direction //Debug.DrawRay(transform.position, leadDirection * Vector3.Distance(targetRB.position, transform.position), Color.green); // Target bearing line -- uses drawRay to confirm line vector //Debug.DrawRay(transform.position, targetBearingLine.normalized * // Vector3.Distance(targetPos_now, transform.position), Color.red); // Corrected velocity -- CYAN // Debug.DrawRay(transform.position, leadDirection.normalized * myRB.velocity.magnitude, Color.cyan); // // Target's current velocity -- YELLOW // Debug.DrawRay(targetPos_now, targetRB.velocity, Color.yellow); // Target average velocity // Debug.DrawRay(targetPos_now, estimatedTargetVelocityAverage, Color.white); // Parallel target bearing line, placed at end of corrected velocity //Debug.DrawRay(transform.position + leadDirection.normalized * myRB.velocity.magnitude, // targetBearingLine.normalized * 1000f, Color.magenta); // ========================== CORRECTIVE TORQUE CALCULATION // correctiveTorqueVector -- axis to torque around to move velocity towards lead direction // - cross of velocity and lead direction vector // - magnitude -- angleBetween velocity and lead direction, ratio of angle vs maxAngle (max 1.0) // - projected onto xy plane to nullify any roll requirement float currentVelocityErrorAngle = Vector3.Angle(estimatedMissileVelocityAverage, leadDirection); // degrees Vector3 correctiveTorqueVect = Vector3.ProjectOnPlane(Vector3.Cross(myRB.velocity, leadDirection), transform.forward).normalized * // torque direction (Mathf.Min(currentVelocityErrorAngle / maxCorrectionErrorAngle, 1.0f)); // torque magnitude // Debug.DrawRay(transform.position, correctiveTorqueVect * 30f, Color.blue); // Debug.DrawRay(transform.position, correctiveTorqueVect.normalized * 30f, Color.green); // Debug.DrawRay(transform.position, myRB.velocity, Color.yellow); //Debug.DrawRay(transform.position, transform.forward * 100f, Color.white); // Convert to yaw/pitch inputs, -1.0 to 1.0 myFlightControl.input_pitch = transform.InverseTransformDirection(correctiveTorqueVect).x; myFlightControl.input_yaw = transform.InverseTransformDirection(correctiveTorqueVect).y; // Debug.Log("Missile pitch input: " + myFlightControl.input_pitch); } targetPos_prev = targetPos_now; targetVel_prev = targetVel_now; }
void UpdateBurnValue() { EnergyBarCommons.SmoothDisplayValue( ref ValueFBurn, ValueF2, effectSmoothChangeSpeed); ValueFBurn = Mathf.Max(ValueFBurn, ValueF2); switch (effectBurnDirection) { case BurnDirection.Both: if (ValueF > ValueF2) { ValueFBurn = ValueF; } else if (ValueF < ValueF2) { EnergyBarCommons.SmoothDisplayValue( ref ValueFBurn, ValueF, effectSmoothChangeSpeed); } else { ValueFBurn = Mathf.Max(ValueFBurn, ValueF2); } break; case BurnDirection.OnlyWhenDecreasing: if (ValueF < ValueF2) { EnergyBarCommons.SmoothDisplayValue( ref ValueFBurn, ValueF, effectSmoothChangeSpeed); } else { ValueFBurn = Mathf.Max(ValueFBurn, ValueF2); } break; case BurnDirection.OnlyWhenIncreasing: if (ValueF > ValueF2) { ValueFBurn = ValueF; } else { ValueFBurn = ValueF2; } break; default: throw new ArgumentOutOfRangeException(); } if (!Mathf.Approximately(ValueFBurn, ValueF2)) { effectBurnWorking = true; } else if (effectBurnWorking) { effectBurnFinishedNotify.Execute(this); effectBurnWorking = false; } }
public void InsertOffset(float yOffset, float deltaOffset, int id = -1) { if (id != -1) { for (int i = 0; i < this.list.Count; i++) { if (this.list[i].id == id) { this.list[i].postOffset += deltaOffset; if (Mathf.Approximately(this.list[i].offset + this.list[i].postOffset, 0F) == true) { this.list.RemoveAt(i); } lastOffset += deltaOffset; return; } } } float interestOffset = 0F; lastOffset += deltaOffset; if (this.list.Count > 0) { if (this.list[0].offset + this.list[0].postOffset > yOffset) { if (Mathf.Approximately(this.list[0].postOffset, -deltaOffset) == true) { this.list.RemoveAt(0); } else { this.list.Insert(0, new PointOfInterest() { postOffset = deltaOffset, id = id }); } return; } else { for (int j = 0; j < this.list.Count; j++) { interestOffset += this.list[j].offset + this.list[j].postOffset; if (interestOffset > yOffset) { if (this.list[j].id == -1) { if (Mathf.Approximately(this.list[j].postOffset, -deltaOffset) == true) { this.list.RemoveAt(j); } else if (j + 1 < this.list.Count && Mathf.Approximately(this.list[j + 1].postOffset, -deltaOffset) == true) { this.list.RemoveAt(j + 1); } } else { this.list.Insert(j, new PointOfInterest() { postOffset = deltaOffset, id = id }); } return; } } } } this.list.Add(new PointOfInterest() { postOffset = deltaOffset, id = id }); }
public override void TickRare() { if (this.compFlickable.SwitchIsOn) { float ambientTemperature = base.AmbientTemperature; float num; if (ambientTemperature > this.compTempControl.targetTemperature - 1f && ambientTemperature < this.compTempControl.targetTemperature + 1f) { num = 0f; } else if (ambientTemperature < this.compTempControl.targetTemperature - 1f) { if (ambientTemperature < 20f) { num = 1f; } else if (ambientTemperature > 1000f) { num = 0f; } else { num = Mathf.InverseLerp(1000f, 100f, ambientTemperature); } } else if (ambientTemperature > this.compTempControl.targetTemperature + 1f) { if (ambientTemperature < -50f) { num = -Mathf.InverseLerp(-273f, -50f, ambientTemperature); } else { num = -1f; } } else { num = 0f; } float energyLimit = this.compTempControl.prop.energyPerSecond * num * 4.16666651f; float num2 = GenTemperature.ControlTemperatureTempChange(base.Position, base.Map, energyLimit, this.compTempControl.targetTemperature); bool flag = !Mathf.Approximately(num2, 0f); if (flag) { this.energyCostPerSec = compTempControl.prop.energyCostPerSec; if (netPort.TryGetEnergy(energyCostPerSec)) { this.GetRoomGroup().Temperature += num2; powerOn = true; } else { powerOn = false; } } else { this.energyCostPerSec = compTempControl.prop.energyCostPerSec * this.compTempControl.prop.lowPowerConsumptionFactor; if (netPort.TryGetEnergy(energyCostPerSec)) { powerOn = true; } else { powerOn = false; } } this.compTempControl.operatingAtHighPower = flag; } }
void EatInvalidChars() { if (isRenamingFilename) { Event evt = Event.current; if (GUIUtility.keyboardControl == m_TextFieldControlID && evt.GetTypeForControl(m_TextFieldControlID) == EventType.KeyDown) { string errorMsg = ""; string invalidChars = EditorUtility.GetInvalidFilenameChars(); if (invalidChars.IndexOf(evt.character) > -1) { errorMsg = "A file name can't contain any of the following characters:\t" + invalidChars; } if (errorMsg != "") { evt.Use(); // Eat character: prevents the textfield from inputting this evt.character ShowMessage(errorMsg); } else { RemoveMessage(); } } // Remove tooltip if screenpos of overlay has changed (handles the case where the main window is being moved or docked window // is resized) if (evt.type == EventType.Repaint) { Rect screenPos = GetScreenRect(); if (!Mathf.Approximately(m_LastScreenPosition.x, screenPos.x) || !Mathf.Approximately(m_LastScreenPosition.y, screenPos.y)) { RemoveMessage(); } m_LastScreenPosition = screenPos; } } }
// Handles slider clicks and page scrolls void SetSliderValueFromClick() { if (clampedDragger.dragDirection == ClampedDragger <TValueType> .DragDirection.Free) { return; } if (clampedDragger.dragDirection == ClampedDragger <TValueType> .DragDirection.None) { if (Mathf.Approximately(pageSize, 0.0f)) { // Jump drag element to current mouse position when user clicks on slider and pageSize == 0 float x, y, sliderLength, dragElementLength, dragElementStartPos; if (direction == SliderDirection.Horizontal) { sliderLength = dragContainer.resolvedStyle.width; dragElementLength = dragElement.resolvedStyle.width; var totalRange = sliderLength - dragElementLength; var targetXPos = clampedDragger.startMousePosition.x - (dragElementLength / 2f); x = Mathf.Max(0f, Mathf.Min(targetXPos, totalRange)); y = dragElement.transform.position.y; dragElementStartPos = x; } else { sliderLength = dragContainer.resolvedStyle.height; dragElementLength = dragElement.resolvedStyle.height; var totalRange = sliderLength - dragElementLength; var targetYPos = clampedDragger.startMousePosition.y - (dragElementLength / 2f); x = dragElement.transform.position.x; y = Mathf.Max(0f, Mathf.Min(targetYPos, totalRange)); dragElementStartPos = y; } var pos = new Vector3(x, y, 0); dragElement.transform.position = pos; dragBorderElement.transform.position = pos; m_DragElementStartPos = new Rect(x, y, dragElement.resolvedStyle.width, dragElement.resolvedStyle.height); // Manipulation becomes a free form drag clampedDragger.dragDirection = ClampedDragger <TValueType> .DragDirection.Free; ComputeValueAndDirectionFromDrag(sliderLength, dragElementLength, dragElementStartPos); return; } m_DragElementStartPos = new Rect(dragElement.transform.position.x, dragElement.transform.position.y, dragElement.resolvedStyle.width, dragElement.resolvedStyle.height); } if (direction == SliderDirection.Horizontal) { ComputeValueAndDirectionFromClick(dragContainer.resolvedStyle.width, dragElement.resolvedStyle.width, dragElement.transform.position.x, clampedDragger.lastMousePosition.x); } else { ComputeValueAndDirectionFromClick(dragContainer.resolvedStyle.height, dragElement.resolvedStyle.height, dragElement.transform.position.y, clampedDragger.lastMousePosition.y); } }
void LateUpdate() { UpdateKeywords(); // Shader properties float motion = CalculateMotion(Time.deltaTime); _matTunnel.SetFloat(_propFxInner, motion); _matTunnel.SetFloat(_propFxOuter, motion - effectFeather); switch (backgroundMode) { case BackgroundMode.COLOR: _matTunnel.SetColor(_propColor, effectColor); break; case BackgroundMode.CAGE_COLOR: case BackgroundMode.BLUR: case BackgroundMode.CAGE_SKYBOX: case BackgroundMode.SKYBOX: Color bkg = applyColorToBackground ? effectColor : Color.white; bkg.a = effectColor.a; _matTunnel.SetColor(_propColor, bkg); break; } switch (backgroundMode) { case BackgroundMode.SKYBOX: _matTunnel.SetTexture(_propSkybox, effectSkybox); break; case BackgroundMode.CAGE_SKYBOX: _matSkysphere.SetTexture(_propSkybox, effectSkybox); break; } // Update cage objects if necessary if (useCage && cageUpdateEveryFrame) { UpdateCage(); } if (_lastMaskMode != maskMode) { ResetMaskCommandBuffer(); } if (_lastBlurKernel != blurSamples || !Mathf.Approximately(_lastBlurRadius, blurDistance)) { UpdateBlurKernel(); } bool di = _drawIris; if (_wasDrawingIrisEarly != di) { if (_camHasIrisBuffer && !di) { ToggleIrisCommandBuffer(false); } else if (!_camHasIrisBuffer && di) { ToggleIrisCommandBuffer(true); } _wasDrawingIrisEarly = di; } if (di) { float inner = motion * 0.98f; // Ensure iris is always a little bigger than image effect aperture _matIris.SetFloat(_propFxInner, inner); _matIris.SetFloat(_propFxOuter, inner - effectFeather); } // Fog Shader.SetGlobalFloat(_globPropFogDensity, cageFogDensity); Shader.SetGlobalFloat(_globPropFogPower, cageFogPower); Shader.SetGlobalFloat(_globPropFogBlend, cageFogBlend); Shader.SetGlobalColor(_globPropFogColor, effectColor); _hasDrawnThisFrame = false; // Flag for once-per-frame things in Draw }
// Update is called once per frame void Update() { horizontal = Input.GetAxis("Horizontal"); vertical = Input.GetAxis("Vertical"); Vector2 move = new Vector2(horizontal, vertical); if (!Mathf.Approximately(move.x, 0.0f) || !Mathf.Approximately(move.y, 0.0f)) { lookDirection.Set(move.x, move.y); lookDirection.Normalize(); } animator.SetFloat("Look X", lookDirection.x); animator.SetFloat("Look Y", lookDirection.y); animator.SetFloat("Speed", move.magnitude); if (isInvincible) { invincibleTimer -= Time.deltaTime; if (invincibleTimer < 0) { isInvincible = false; } } if (Input.GetKeyDown(KeyCode.C)) { Launch(); } if (Input.GetKey("escape")) { Application.Quit(); } if (Input.GetKeyDown(KeyCode.X)) { RaycastHit2D hit = Physics2D.Raycast(rigidbody2d.position + Vector2.up * 0.2f, lookDirection, 1.5f, LayerMask.GetMask("NPC")); if (hit.collider != null) { NonPlayerCharacter character = hit.collider.GetComponent <NonPlayerCharacter>(); if (character != null) { character.DisplayDialog(); } } } //work if (currentHealth == 0) { gameOver = true; youLose.SetActive(true); } if (Input.GetKey(KeyCode.R)) { if (gameOver == true) { Application.LoadLevel(Application.loadedLevel); } if (gameWin == true) { Application.LoadLevel(Application.loadedLevel); } } //work end }
private bool IsReachedTargetPoint() { float distance = Vector2.Distance(thisTransform.position, targetPos); return(Mathf.Approximately(distance, 0f)); }
public override bool ApplyPreset(GameObject avatar) { if (!avatar) { return(false); } Undo.RegisterFullObjectHierarchyUndo(avatar, "Apply Pose"); PumkinsAvatarTools.ResetPose(avatar); if (presetMode == PosePresetMode.HumanPose) { Animator anim = avatar.GetComponent <Animator>(); if (anim && anim.avatar && anim.avatar.isHuman) { Vector3 pos = avatar.transform.position; Quaternion rot = avatar.transform.rotation; avatar.transform.SetPositionAndRotation(Vector3.zero, Quaternion.identity); var humanPoseHandler = new HumanPoseHandler(anim.avatar, avatar.transform); var humanPose = new HumanPose(); humanPoseHandler.GetHumanPose(ref humanPose); humanPose.muscles = muscles; if (PumkinsAvatarTools.Instance.posePresetTryFixSinking) { if (humanPose.bodyPosition.y < 1 && !Mathf.Approximately(humanPose.bodyPosition.y, 0)) { PumkinsAvatarTools.Log(Strings.PoseEditor.bodyPositionYTooSmall, LogType.Warning, humanPose.bodyPosition.y.ToString()); humanPose.bodyPosition.y = 1; } } if (PumkinsAvatarTools.Instance.posePresetApplyBodyPosition) { humanPose.bodyPosition = bodyPosition; } if (PumkinsAvatarTools.Instance.posePresetApplyBodyRotation) { humanPose.bodyRotation = bodyRotation; } humanPoseHandler.SetHumanPose(ref humanPose); avatar.transform.SetPositionAndRotation(pos, rot); PumkinsPoseEditor.OnPoseWasChanged(PumkinsPoseEditor.PoseChangeType.Reset); return(true); } else { PumkinsAvatarTools.Log(Strings.Log.cantSetPoseNonHumanoid, LogType.Error, name); return(false); } } else { if (!avatar) { return(false); } for (int i = 0; i < transformPaths.Count; i++) { var t = avatar.transform.Find(transformPaths[i]); if (t != null) { t.localEulerAngles = transformRotations[i]; } } return(true); } }
public void checkCache() { // Point Values if (cachedPointValues.Count != pointValues.Count) { cachedPointValues = new List <Vector2>(pointValues); setAllChanged(); } else { // Vast majority of update loops will need to loop through all the point values and check cache, should be possible to improve performance here for (int i = 0; i < pointValues.Count; i++) { if (!Mathf.Approximately(pointValues[i].x, cachedPointValues[i].x) || !Mathf.Approximately(pointValues[i].y, cachedPointValues[i].y)) { cachedPointValues = new List <Vector2>(pointValues); setAllChanged(); break; } } } // x dist between variables theGraph.updateCacheAndFlagFloat(ref cachedXDistBetweenPoints, xDistBetweenPoints, ref pointValuesChanged); theGraph.updateCacheAndFlagBool(ref cachedUseXDistBetweenToSpace, UseXDistBetweenToSpace, ref pointValuesChanged); theGraph.updateCacheAndFlagBool(ref cachedAutoUpdateXDistBetween, AutoUpdateXDistBetween, ref pointValuesChanged); // connect first to last if (cachedConnectFirstToLast != connectFirstToLast) { cachedConnectFirstToLast = connectFirstToLast; setAllChanged(); } // Others theGraph.updateCacheAndFlagBool(ref cachedHidePoints, hidePoints, ref hidePointsChanged); theGraph.updateCacheAndFlagBool(ref cachedHideLines, hideLines, ref hideLinesChanged); theGraph.updateCacheAndFlagColor(ref cachedLineColor, lineColor, ref lineColorChanged); theGraph.updateCacheAndFlagColor(ref cachedPointColor, pointColor, ref pointColorChanged); theGraph.updateCacheAndFlagFloat(ref cachedLineScale, lineScale, ref lineScaleChanged); theGraph.updateCacheAndFlagFloat(ref cachedPointWidthHeight, pointWidthHeight, ref pointWidthHeightChanged); theGraph.updateCacheAndFlagInt(ref cachedPointPrefab, pointPrefab, ref prefabChanged); theGraph.updateCacheAndFlagInt(ref cachedLinkPrefab, linkPrefab, ref prefabChanged); if (cachedSeriesType != theGraph.graphType) { cachedSeriesType = theGraph.graphType; prefabChanged = true; } if (prefabChanged) { setAllChanged(); } theGraph.updateCacheAndFlagString(ref cachedSeriesName, seriesName, ref seriesNameChanged); theGraph.updateCacheAndFlagFloat(ref cachedLegendEntryFontSize, legendEntryFontSize, ref seriesNameChanged); theGraph.updateCacheAndFlagFloat(ref cachedLegendEntryLinkSpacing, legendEntryLinkSpacing, ref legendEntryLinkSpacingChanged); theGraph.updateCacheAndFlagFloat(ref cachedLinePadding, linePadding, ref linePaddingChanged); }
public static float Divide(float _numerator, float _denominator) { return(Mathf.Approximately(_denominator, 0) ? 0 : (_numerator / _denominator)); }
private void DoRealTimeUpdate() { /* This "Real Time" update is FPS dependent, so the time axis actually represents a number of frames. * The waitForSeconds for coroutines does not actually wait for the specified number of seconds, and is also FPS dependent. * An FPS independent solution only seems possible with fixedUpdate, which may be added later. */ float waitTime = 0.0166f; // Each x-axis unit is 60 frames. This is 1 second at 60 fps. realTimeLoopVar += waitTime; float yval = getRealTimeRefVal(); // Add new point or move the last existing point if (pointValues.Count > 1) { // For the third and additional points, calculate slopes and move previous point instead of creating a new point if slopes not significantly different float slope1 = (pointValues[pointValues.Count - 1].y - pointValues[pointValues.Count - 2].y) / (pointValues[pointValues.Count - 1].x - pointValues[pointValues.Count - 2].x); float slope2 = (yval - pointValues[pointValues.Count - 2].y) / (realTimeLoopVar - pointValues[pointValues.Count - 2].x); if (Mathf.Abs(slope1 - slope2) <= Mathf.Abs(slope1) / 1000f) // Mathf.Approximately not always working, so defining significantly as 10^3 different // Slopes about the same, move the last point { pointValues[pointValues.Count - 1] = new Vector2(realTimeLoopVar, yval); } else { // Slopes significantly different, add a new point pointValues.Add(new Vector2(realTimeLoopVar, yval)); } } else { // Just add the second point pointValues.Add(new Vector2(realTimeLoopVar, yval)); } // If needed, change graph axis boundary and remove or move the first point to keep the series within the graph boundaries if (pointValues.Count > 1 && pointValues[pointValues.Count - 1].x > realTimeOrigMax) { // For the last real time update series update the axis boundaries by the difference if (theGraph.orientationType == WMG_Axis_Graph.orientationTypes.vertical) { theGraph.xAxisMinValue = realTimeLoopVar - realTimeOrigMax; theGraph.xAxisMaxValue = realTimeLoopVar; } else { theGraph.yAxisMinValue = realTimeLoopVar - realTimeOrigMax; theGraph.yAxisMaxValue = realTimeLoopVar; } // First and second points used to see if the first point should be moved or deleted after incrementing the minimum axis value float x1 = pointValues[0].x; float x2 = pointValues[1].x; float y1 = pointValues[0].y; float y2 = pointValues[1].y; // Delete or move the very first point to keep the series in the graph boundary when the maximum is increased if (Mathf.Approximately(x1 + waitTime, x2)) { pointValues.RemoveAt(0); } else { pointValues[0] = new Vector2(x1 + waitTime, y1 + (y2 - y1) / (x2 - x1) * waitTime); } } }
private void HandleScroll() { bool touchDown = false; bool touching = false; Vector2 currentScroll = Vector2.zero; int cidx = -1; int cidxa = -1; touchDown |= VRControllers.Instance.GetButtonDown(VRControllerButtons.Touch, out cidx); touching |= VRControllers.Instance.GetButton(VRControllerButtons.Touch, out cidxa); if (cidx > -1) { currentScroll = VRControllers.Instance.GetTouchPos(cidx); } else if (cidxa > -1) { currentScroll = VRControllers.Instance.GetTouchPos(cidxa); } /* #if UNITY_HAS_GOOGLEVR && (UNITY_ANDROID || UNITY_EDITOR) * touchDown |= GvrController.TouchDown; * touching |= GvrController.IsTouching; * currentScroll = GvrController.TouchPos; #endif // UNITY_HAS_GOOGLEVR && (UNITY_ANDROID || UNITY_EDITOR) */ if (touchDown && !eligibleForScroll) { lastScroll = currentScroll; eligibleForScroll = true; } else if (touching && eligibleForScroll) { //Debug.Log("currentScroll is " + currentScroll + " , lastScroll is " + lastScroll); pointerData.scrollDelta = (currentScroll - lastScroll) * SCROLL_DELTA_MULTIPLIER; GameObject currentGameObject = GetCurrentGameObject(); if (currentGameObject != null && !Mathf.Approximately(pointerData.scrollDelta.sqrMagnitude, 0.0f)) { GameObject scrollHandler = ExecuteEvents.GetEventHandler <IScrollHandler>(currentGameObject); ExecuteEvents.ExecuteHierarchy(scrollHandler, pointerData, ExecuteEvents.scrollHandler); } if (scrollEventData == null) { scrollEventData = new ScrollEventData(eventSystem); } if (currentGameObject != null && Mathf.Abs((currentScroll - lastScroll).x) >= 1 && Mathf.Abs(currentScroll.x) > float.Epsilon) { scrollEventData.Direction = (currentScroll - lastScroll).x >= 1 ? ScrollEventData.ScrollDirection.Right : ScrollEventData.ScrollDirection.Left; GameObject scrollHandler = ExecuteEvents.GetEventHandler <IScrollToDirectHandler>(currentGameObject); scrollEventData.selectedObject = scrollHandler; ExecuteEvents.Execute(scrollHandler, scrollEventData, VRExecuteEvents.scrollToDirectHandler); } lastScroll = currentScroll; } else if (eligibleForScroll) { eligibleForScroll = false; pointerData.scrollDelta = Vector2.zero; } }
protected override void Update() { base.Update(); if (IsPlayer) { if (InputManager.Instance.AnyDown("JUMP") && IsGrounded) { if (InputManager.Instance.AnyDown("MOVE_RIGHT")) { _velocity = _jumpForce; } else if (InputManager.Instance.AnyDown("MOVE_LEFT")) { _velocity = new Vector2(-_jumpForce.x, _jumpForce.y); } } if (_wormCollectPoint.childCount == 0) { WormAgent closestWorm = null; var minDist = float.MaxValue; for (var i = 0; i < WormAgent.All.Count; i++) { var worm = WormAgent.All[i]; var dst = Vector2.Distance(_wormCollectPoint.position, worm.transform.position); if (dst < minDist && dst < _wormCollectDst) { minDist = dst; closestWorm = worm; } } if (closestWorm != null) { closestWorm.enabled = false; closestWorm.transform.SetParent(_wormCollectPoint); closestWorm.transform.localPosition = Vector2.zero; } } } else if (Time.time >= _nextUpdate) { _nextUpdate = Time.time + Random.Range(0.5f, 5f); _velocity = new Vector2(Random.value > 0.5f ? _jumpForce.x : -_jumpForce.x, _jumpForce.y); } if (!Mathf.Approximately(_velocity.x, 0f)) { _facingRight = Mathf.Sign(_velocity.x) > 0f; } var scale = transform.localScale; var facingSign = _facingRight ? 1 : -1; if ((int)Mathf.Sign(scale.x) != facingSign) { scale.x *= -1f; } transform.localScale = scale; var position = transform.position; position += (Vector3)_velocity * Time.deltaTime; position.y = Mathf.Max(0f, position.y); transform.position = position; _velocity.y -= 9.87f * Time.deltaTime; if (IsGrounded) { _velocity = Vector2.zero; } }