public Tile(HeatPointList heatPoints, HeatmapSettings settings, Bounds bounds) { Bounds = bounds; Bounds heatMapBounds = new Bounds(bounds); heatMapBounds.TopLeftLat += settings.Size / 2 * this.DegreesPerPixelLat; heatMapBounds.TopLeftLng -= settings.Size / 2 * this.DegreesPerPixelLng; heatMapBounds.BottomRightLat -= settings.Size / 2 * this.DegreesPerPixelLat; heatMapBounds.BottomRightLng += settings.Size / 2 * this.DegreesPerPixelLng; HeatPointList pointsWithinBounds = new HeatPointList(); foreach (HeatPoint hp in heatPoints) { if (heatMapBounds.Contains(hp)) pointsWithinBounds.Add(hp); } HeatMap = new HeatMap(pointsWithinBounds, settings, heatMapBounds); }
// Checks to see whether Bounds lilB are within Bounds bigB public static Vector3 BoundsInBoundsCheck(Bounds bigB, Bounds lilB, BoundsTest test = BoundsTest.onScreen) { // The behavior of this function is different based on the BoundsTest // that has been selected. // Get the center of lilB Vector3 pos = lilB.center; // Initialize the offset at [0,0,0] Vector3 off = Vector3.zero; switch (test) { // The center test determines what off (offset) would have to be applied // to lilB to move its center back inside bigB case BoundsTest.center: if (bigB.Contains(pos)) { return(Vector3.zero); } if (pos.x > bigB.max.x) { off.x = pos.x - bigB.max.x; } else if (pos.x < bigB.min.x) { off.x = pos.x - bigB.min.x; } if (pos.y > bigB.max.y) { off.y = pos.y - bigB.max.y; } else if (pos.y < bigB.min.y) { off.y = pos.y - bigB.min.y; } if (pos.z > bigB.max.z) { off.z = pos.z - bigB.max.z; } else if (pos.z < bigB.min.z) { off.z = pos.z - bigB.min.z; } return(off); // The onScreen test determines what off would have to be applied to // keep all of lilB inside bigB case BoundsTest.onScreen: if (bigB.Contains(lilB.min) && bigB.Contains(lilB.max)) { return(Vector3.zero); } if (lilB.max.x > bigB.max.x) { off.x = lilB.max.x - bigB.max.x; } else if (lilB.min.x < bigB.min.x) { off.x = lilB.min.x - bigB.min.x; } if (lilB.max.y > bigB.max.y) { off.y = lilB.max.y - bigB.max.y; } else if (lilB.min.y < bigB.min.y) { off.y = lilB.min.y - bigB.min.y; } if (lilB.max.z > bigB.max.z) { off.z = lilB.max.z - bigB.max.z; } else if (lilB.min.z < bigB.min.z) { off.z = lilB.min.z - bigB.min.z; } return(off); // The offScreen test determines what off would need to be applied to // move any tiny part of lilB inside of bigB case BoundsTest.offScreen: bool cMin = bigB.Contains(lilB.min); bool cMax = bigB.Contains(lilB.max); if (cMin || cMax) { return(Vector3.zero); } if (lilB.min.x > bigB.max.x) { off.x = lilB.min.x - bigB.max.x; } else if (lilB.max.x < bigB.min.x) { off.x = lilB.max.x - bigB.min.x; } if (lilB.min.y > bigB.max.y) { off.y = lilB.min.y - bigB.max.y; } else if (lilB.max.y < bigB.min.y) { off.y = lilB.max.y - bigB.min.y; } if (lilB.min.z > bigB.max.z) { off.z = lilB.min.z - bigB.max.z; } else if (lilB.max.z < bigB.min.z) { off.z = lilB.max.z - bigB.min.z; } return(off); } return(Vector3.zero); }
private void FindShieldedParts() { /*if (HighLogic.LoadedSceneIsEditor/* && FARAeroUtil.EditorAboutToAttach(false) && * !FARAeroUtil.CurEditorParts.Contains(part)) * return;*/ ClearShieldedParts(); UpdateShipPartsList(); CalculateFairingBounds(); Collider[] colliders = this.PartColliders; for (int i = 0; i < VesselPartList.Count; i++) { Part p = VesselPartList[i]; if (FARShieldedParts.Contains(p) || p == null || p == part || part.symmetryCounterparts.Contains(p)) { continue; } FARBaseAerodynamics b = null; FARBasicDragModel d = null; FARWingAerodynamicModel w = null; Vector3 relPos = -part.transform.position; w = p.GetComponent <FARWingAerodynamicModel>(); if ((object)w == null) { d = p.GetComponent <FARBasicDragModel>(); } if ((object)w == null && (object)d == null) { continue; } //if (p.GetComponent<FARPayloadFairingModule>() != null) // continue; if (w) { b = w as FARBaseAerodynamics; relPos += w.WingCentroid(); } else { b = d as FARBaseAerodynamics; relPos += p.transform.TransformDirection(d.CenterOfDrag) + p.transform.position; //No attach node shifting with this } relPos = this.part.transform.worldToLocalMatrix.MultiplyVector(relPos); Vector3 fairingCenter = fairingBounds.center; fairingCenter *= 0.5f; fairingCenter = this.part.transform.localToWorldMatrix.MultiplyVector(fairingCenter); fairingCenter += this.part.transform.position; if (fairingBounds.Contains(relPos)) { Vector3 vecFromPToPFCenter; Vector3 origin; if (w) { origin = w.WingCentroid(); } else { origin = p.transform.position; } vecFromPToPFCenter = fairingCenter - origin; RaycastHit[] hits = Physics.RaycastAll(origin, vecFromPToPFCenter, vecFromPToPFCenter.magnitude, FARAeroUtil.RaycastMask); bool outsideMesh = false; for (int k = 0; k < hits.Length; k++) { if (colliders.Contains(hits[k].collider)) { outsideMesh = true; break; } } if (outsideMesh) { continue; } FARShieldedParts.Add(p); if (b) { b.ActivateShielding(); //print("Shielded: " + p.partInfo.title); } for (int k = 0; k < p.symmetryCounterparts.Count; k++) { Part q = p.symmetryCounterparts[k]; if (q == null) { continue; } FARShieldedParts.Add(q); b = q.GetComponent <FARBaseAerodynamics>(); if (b) { b.ActivateShielding(); //print("Shielded: " + p.partInfo.title); } } } } partsShielded = FARShieldedParts.Count; }
private void Update() { //if (!roadBounds.Contains(transform.position)) // 离开赛道GameOver //{// 无法形成多边形区域,因此即使离开赛道也会判定为没有离开 // Debug.Log("Game Over!"); // GetComponent<KartController>().enabled = false; //} // 每次更新判断一次赛车是否在赛道内 insideRoad = false; roadBoard = GameObject.FindGameObjectsWithTag("Road"); foreach (GameObject road in roadBoard) { Bounds roadBounds = road.GetComponent <Collider2D>().bounds; if (roadBounds.Contains(transform.position)) { insideRoad = true; } } if (!insideRoad) { Debug.Log("离开赛道!"); GetComponent <KartController>().enabled = false; Time.timeScale = 0; fire.gameObject.SetActive(false); } if (insideRoad) { if (Input.GetKeyDown(KeyCode.W)) { if (left || right) { straight = true; left = false; right = false; transform.rotation = Quaternion.Euler(0, 0, 0); } } if (Input.GetKeyDown(KeyCode.A)) { if (straight) { left = true; straight = false; right = false; transform.rotation = Quaternion.Euler(0, 0, 90); } } if (Input.GetKeyDown(KeyCode.D)) { if (straight) { right = true; straight = false; left = false; transform.rotation = Quaternion.Euler(0, 0, -90); } } if (Input.GetKey(KeyCode.W) || Input.GetKey(KeyCode.A) || Input.GetKey(KeyCode.D)) { // 直行 if (Input.GetKey(KeyCode.LeftShift)) { // 加速 AccelUp(); } else if (Input.GetKey(KeyCode.LeftControl)) {// 减速 SlowUp(); Debug.Log("Slow"); } else {// 起步 StartUp(); } fire.gameObject.SetActive(true); } else {// 停车 EndUp(); fire.gameObject.SetActive(false); } if (straight) { rgb.velocity = new Vector2(0, velocity / velocityRejust); } if (left) { rgb.velocity = new Vector2(-velocity / velocityRejust, 0); } if (right) { rgb.velocity = new Vector2(velocity / velocityRejust, 0); } Debug.Log("当前速度为 " + velocity); Debug.Log("当前加速度为 " + acceleration); if (velocity > 0) { scorePoint++; score.text = "Score: " + scorePoint.ToString(); } } }
// Checks to see if bounds lilb are within Bounds bigB public static Vector3 BoundsInBoundsCheck(Bounds bigB, Bounds lilB, BoundsTest test = BoundsTest.onScreen) { // behavior needs to be different depending on the test selected Vector3 pos = lilB.center; // use center for measurement Vector3 off = Vector3.zero; // offset is 0,0,0 to start switch (test) { // what is offset to move center of lilB back inside bigB case BoundsTest.center: // trivial case - we are already inside if (bigB.Contains(pos)) { return(Vector3.zero); //no need to move } //otherwise adjust x,y,z components as needed if (pos.x > bigB.max.x) { off.x = pos.x - bigB.max.x; } else if (pos.x < bigB.min.x) { off.x = pos.x - bigB.min.x; } if (pos.y > bigB.max.y) { off.y = pos.y - bigB.max.y; } else if (pos.y < bigB.min.y) { off.y = pos.y - bigB.min.y; } if (pos.z > bigB.max.z) { off.z = pos.z - bigB.max.z; } else if (pos.z < bigB.min.z) { off.z = pos.z - bigB.min.z; } return(off); //------------------------- // what is the offset to keep ALL of lilB inside bigB case BoundsTest.onScreen: // trivial case - we are already inside if (bigB.Contains(lilB.max) && bigB.Contains(lilB.min)) { return(Vector3.zero); //no need to move } if (lilB.max.x > bigB.max.x) { off.x = lilB.max.x - bigB.max.x; } else if (lilB.min.x < bigB.min.x) { off.x = lilB.min.x - bigB.min.x; } if (lilB.max.y > bigB.max.y) { off.y = lilB.max.y - bigB.max.y; } else if (lilB.min.y < bigB.min.y) { off.y = lilB.min.y - bigB.min.y; } if (lilB.max.z > bigB.max.z) { off.z = lilB.max.z - bigB.max.z; } else if (lilB.min.z < bigB.min.z) { off.z = lilB.min.z - bigB.min.z; } return(off); //------------------------- // what is the offset to keep ALL of lilB outside of bigB case BoundsTest.offScreen: bool cMin = bigB.Contains(lilB.min); bool cMax = bigB.Contains(lilB.max); if (cMin || cMax) { return(Vector3.zero); } if (lilB.min.x > bigB.max.x) { off.x = lilB.min.x - bigB.max.x; } else if (lilB.max.x < bigB.min.x) { off.x = lilB.max.x - bigB.min.x; } if (lilB.min.y > bigB.max.y) { off.y = lilB.min.y - bigB.max.y; } else if (lilB.max.y < bigB.min.y) { off.y = lilB.max.y - bigB.min.y; } if (lilB.min.z > bigB.max.z) { off.z = lilB.min.z - bigB.max.z; } else if (lilB.max.z < bigB.min.z) { off.z = lilB.max.z - bigB.min.z; } return(off); } // end switch BoundsTest return(Vector3.zero); // if we get here something went wrong } // end BoundsInBoundsCheck
MouseState ProcessMouse(MouseState mouse) { // Handle mouse buttons for (MouseButton i = 0; i < MouseButton.LastButton; i++) { if (mouse[i] && !previous_mouse[i]) { OnMouseDown(i); } if (!mouse[i] && previous_mouse[i]) { OnMouseUp(i); } } // Handle mouse movement { int x = mouse.X; int y = mouse.Y; // Make sure the mouse cannot leave the GameWindow when captured if (!CursorVisible) { x = MathHelper.Clamp(mouse.X, Bounds.Left, Bounds.Right - 1); y = MathHelper.Clamp(mouse.Y, Bounds.Top, Bounds.Bottom - 1); if (x != mouse.X || y != mouse.Y) { Mouse.SetPosition(x, y); } } if (x != previous_mouse.X || y != previous_mouse.Y) { OnMouseMove(x, y); } } // Handle mouse scroll if (mouse.Scroll != previous_mouse.Scroll) { float dx = mouse.Scroll.X - previous_mouse.Scroll.X; float dy = mouse.Scroll.Y - previous_mouse.Scroll.Y; OnMouseWheel(dx, dy); } // Handle mouse focus // Note: focus follows mouse. Literally. bool cursor_in = Bounds.Contains(new Point(mouse.X, mouse.Y)); if (!cursor_in && Focused) { OnMouseLeave(EventArgs.Empty); SetFocus(false); } else if (cursor_in && !Focused) { OnMouseEnter(EventArgs.Empty); SetFocus(true); } return(mouse); }
protected virtual bool TestBounds(Vector2 pos) { return(Bounds.Contains(pos)); }
public void BoundsCanNotContainAPoint() { b = new Bounds(Vector3.zero, Vector3.one); Assert.That(!b.Contains(new Vector3(2, 0, 0))); }
bool IsWithinBounds(Camera camera, Bounds viewportBounds, Vector3 position) { Vector3 viewportPoint = camera.WorldToViewportPoint(position); return(viewportBounds.Contains(viewportPoint)); }
private IEnumerator DoMove(Vector3 direction) { if (isMoving) { yield break; } Vector3 startPos = transform.position; Vector3 goalPos = startPos + direction * distancePerUnit; float moveTime = (goalPos - startPos).magnitude / moveSpeed; Bounds selfBounds = new Bounds(); bool initialized = false; foreach (Collider c in GetComponentsInChildren <Collider>()) { if (initialized) { selfBounds.Encapsulate(c.bounds); } else { selfBounds = c.bounds; initialized = true; } } selfBounds.center += direction * distancePerUnit; Bounds areaBounds = area.bounds; Vector3 minPoint = new Vector3(selfBounds.min.x, areaBounds.center.y, selfBounds.min.z); Vector3 maxPoint = new Vector3(selfBounds.max.x, areaBounds.center.y, selfBounds.max.z); bool fullyContained = areaBounds.Contains(minPoint) && areaBounds.Contains(maxPoint); Debug.Log(areaBounds); if (!fullyContained) { yield break; } isMoving = true; audioSource.PlayOneShot(startMove); OnMove.Invoke(); PushBody.FreezeAll(); float progress = 0.0f; while (progress < 1.0f) { float x = Mathf.SmoothStep(startPos.x, goalPos.x, progress); float y = Mathf.SmoothStep(startPos.y, goalPos.y, progress); float z = Mathf.SmoothStep(startPos.z, goalPos.z, progress); _rb.MovePosition(new Vector3(x, y, z)); progress += Time.deltaTime / moveTime; yield return(null); } isMoving = false; audioSource.PlayOneShot(endMove); PushBody.ThawAll(); historianManager.Record(); }
//検証メソッド public override Result Validate() { //初期化 base.Validate(); Bounds outBounds = new Bounds(new Vector3(0, 2.5f, -2.0f), new Vector3(4.0f, 5.0f, 4.0f)); //検証ロジック Scene scene = SceneManager.GetSceneByPath(AssetDatabase.GUIDToAssetPath(options.sceneGuid)); if (!scene.IsValid()) { AddResultLog("無効なシーンです"); return(SetResult(Result.FAIL)); } bool dirtFlag = false; Bounds torelanceBounds = new Bounds(new Vector3(0, 0, 0), new Vector3(0.0001f, 0.0001f, 0.0001f)); Bounds torelanceScale = new Bounds(new Vector3(1.0f, 1.0f, 1.0f), new Vector3(0.0001f, 0.0001f, 0.0001f)); // ルートオブジェクトの取得 GameObject[] rootObjects = scene.GetRootGameObjects(); foreach (var obj in rootObjects) { if (obj.name == options.baseFolder.name) { if (!torelanceBounds.Contains(obj.transform.position)) { AddResultLog(string.Format("ルートオブジェクトの位置は(0, 0, 0)にしてください。現在は(x, y, z) = ({0}, {1}, {2})となっています。", obj.transform.position.x, obj.transform.position.y, obj.transform.position.z)); dirtFlag = true; } if (!torelanceBounds.Contains(obj.transform.rotation.eulerAngles)) { AddResultLog(string.Format("ルートオブジェクトの回転は(0, 0, 0)にしてください。現在は(x, y, z) = ({0}, {1}, {2})となっています。", obj.transform.rotation.eulerAngles.x, obj.transform.rotation.eulerAngles.y, obj.transform.rotation.eulerAngles.z)); dirtFlag = true; } if (!torelanceScale.Contains(obj.transform.localScale)) { AddResultLog(string.Format("ルートオブジェクトのスケールは(0, 0, 0)にしてください。現在は(x, y, z) = ({0}, {1}, {2})となっています。", obj.transform.localScale.x, obj.transform.localScale.y, obj.transform.localScale.z)); dirtFlag = true; } foreach (Transform child_tr in obj.transform) { var child = child_tr.gameObject; if (child.name.ToLower() == "dynamic" || child.name.ToLower() == "static") { if (!torelanceBounds.Contains(child.transform.position)) { AddResultLog(string.Format("ルート直下のオブジェクト{0}の位置は(0, 0, 0)にしてください。現在は(x, y, z) = ({1}, {2}, {3})となっています。", child.name, child.transform.position.x, child.transform.position.y, child.transform.position.z)); dirtFlag = true; } if (!torelanceBounds.Contains(child.transform.rotation.eulerAngles)) { AddResultLog(string.Format("ルート直下のオブジェクト{0}の回転は(0, 0, 0)にしてください。現在は(x, y, z) = ({1}, {2}, {3})となっています。", child.name, child.transform.rotation.eulerAngles.x, child.transform.rotation.eulerAngles.y, child.transform.rotation.eulerAngles.z)); dirtFlag = true; } if (!torelanceScale.Contains(child.transform.localScale)) { AddResultLog(string.Format("ルート直下のオブジェクト{0}のスケールは(0, 0, 0)にしてください。現在は(x, y, z) = ({1}, {2}, {3})となっています。", child.name, child.transform.localScale.x, child.transform.localScale.y, child.transform.localScale.z)); dirtFlag = true; } } } } } //検証結果を設定して返す(正常:Result.SUCESS 異常:Result.FAIL) return(SetResult(dirtFlag ? Result.FAIL : Result.SUCCESS)); }
public void Update() { var ml = Game.InputControls.MouseLocation; if (!ml.HasValue) return; var size = Measure(); var pos = new Vector2(Game.ViewportWidth - size.X, Game.ViewportHeight - size.Y) * new Vector2(0.5f, 0.5f); for (int i = 0; i < Items.Count; i++) { var item = Items[i]; var itemSize = item.Measure(Game); var itemBounds = new Bounds( pos, pos + itemSize ); if (itemBounds.Contains(ml.Value)) SelectedIndex = i; pos.Y += itemSize.Y; } }
public void IfAPointIntersectsTheBoundsItWillBeContained() { b = new Bounds(Vector3.zero, Vector3.one); Assert.That(b.Contains(new Vector3(0.5f, 0.5f, 0.5f))); }
public unsafe void Execute(int i) { float3 currentPos = Positions[i].Value; float3 currentDir = VehicleData[i].Forward; int laneCount, nextLane; //spawn new pos if (!BoundingBox.Contains(currentPos)) { int nextSeg = rdGen.NextInt(0, RoadSegments.Length); float3 nextForward = RoadSegments[nextSeg].Direction; quaternion newRot = quaternion.LookRotation(nextForward, new float3() { x = 0, y = 1, z = 0 }); laneCount = RoadSegments[nextSeg].LaneNumber; nextLane = 0; float laneOffset = (nextLane + 0.5f) * RoadSegments[nextSeg].LaneWidth; if (RoadSegments[nextSeg].IsOneWay == 1) { laneOffset -= (laneCount / 2.0f) * RoadSegments[nextSeg].LaneWidth; } float nextPerct = 0; float3 nextPos = (1.0f - nextPerct) * RoadNodes[RoadSegments[nextSeg].StartNodeId].Position + (nextPerct) * RoadNodes[RoadSegments[nextSeg].EndNodeId].Position; nextPos += laneOffset * RoadSegments[nextSeg].RightDirection; VehicleData[i] = new VehicleData( VehicleData[i].Id, nextSeg, VehicleData[i].Speed, nextForward, nextPerct, 1.0f, nextPos, nextLane, 50.0f ); BVHAABB newAABB = AABB[i]; newAABB.Max += (nextPos - currentPos); newAABB.Min += (nextPos - currentPos); AABB[i] = newAABB; Positions[i] = new Position() { Value = nextPos }; Rotations[i] = new Rotation() { Value = newRot }; return; } #region Redlight infront int currentSeg = VehicleData[i].SegId; int nextCrossing = VehicleData[i].Direction > 0.0f ? RoadSegments[currentSeg].EndNodeId : RoadSegments[currentSeg].StartNodeId; float3 nextCrossingPos = RoadNodes[nextCrossing].Position; float distanceToCrossing = math.distance(currentPos, nextCrossingPos); int2 nextCrossingGreenlightConnect = RoadNodes[nextCrossing].ConnectionSegIds[RoadNodes[nextCrossing].ActiveConnection]; if (currentSeg != nextCrossingGreenlightConnect.x && currentSeg != nextCrossingGreenlightConnect.y && distanceToCrossing < 20.0f) { return; } #endregion #region SpeedVariation float prevDistanceAhead = VehicleData[i].HitDistAhead; float newDistanceAhead = HitResult[i].FrontHitDistance; float distAheadDiff = prevDistanceAhead - newDistanceAhead; int hitResult = HitResult[i].HitResultPacked; float maxSpeed = RoadSegments[VehicleData[i].SegId].MaxSpeed; float newSpeed = VehicleData[i].Speed; if (hitResult == 0 && newSpeed < maxSpeed) { newSpeed += 0.5f; } else if ((hitResult & 0x1) == 1 && (distAheadDiff > 0)) { newSpeed -= ((distAheadDiff) / 20.0f); } if (newDistanceAhead < 5.0f) { newSpeed = 0.0f; } newSpeed = newSpeed > maxSpeed ? maxSpeed : newSpeed; newSpeed = newSpeed < 0 ? 0 : newSpeed; #endregion float stepLength = newSpeed * DeltaTime; float segLength = RoadSegments[VehicleData[i].SegId].Length; float stepPerc = stepLength / segLength; float nextPosPerc = VehicleData[i].CurrentSegPos + stepPerc * VehicleData[i].Direction; #region switchLane laneCount = RoadSegments[VehicleData[i].SegId].LaneNumber; int currentLane = VehicleData[i].Lane; int laneSwitch = rdGen.NextInt(-10, 10); laneSwitch = laneSwitch / 10; if (currentLane == 0 && laneSwitch == -1) { laneSwitch = 0; } if (currentLane == (laneCount - 1) && laneSwitch == 1) { laneSwitch = 0; } nextLane = VehicleData[i].Lane + laneSwitch; #endregion //great, still in this seg if (nextPosPerc < 1.0f && nextPosPerc > 0.0f) { //step forward float3 nextPos = currentPos + currentDir * stepLength; //offset lane nextPos += laneSwitch * VehicleData[i].Direction * RoadSegments[VehicleData[i].SegId].LaneWidth * RoadSegments[VehicleData[i].SegId].RightDirection; VehicleData[i] = new VehicleData( VehicleData[i].Id, VehicleData[i].SegId, newSpeed, VehicleData[i].Forward, nextPosPerc, VehicleData[i].Direction, nextPos, nextLane, newDistanceAhead ); BVHAABB newAABB = AABB[i]; newAABB.Max += currentDir * stepLength; newAABB.Min += currentDir * stepLength; AABB[i] = newAABB; Positions[i] = new Position() { Value = nextPos }; } //reach end node, find next seg else { //find next available segment int *_availableSeg = (int *)UnsafeUtility.Malloc( 5 * sizeof(int), sizeof(int), Allocator.Temp); int availableSegCount = 0; for (int k = 0; k < 3; k++) { int seg1 = RoadNodes[nextCrossing].ConnectionSegIds[k].x; int seg2 = RoadNodes[nextCrossing].ConnectionSegIds[k].y; if (seg1 != -1 && seg1 != currentSeg && //not current seg, and next seg not one-way !(RoadSegments[seg1].EndNodeId == nextCrossing && RoadSegments[seg1].IsOneWay == 1)) { _availableSeg[availableSegCount++] = seg1; } if (seg2 != -1 && seg2 != currentSeg && //not current seg, and next seg not one-way !(RoadSegments[seg2].EndNodeId == nextCrossing && RoadSegments[seg2].IsOneWay == 1)) { _availableSeg[availableSegCount++] = seg2; } } int nextSeg = currentSeg; float dir = 1.0f; if (availableSegCount > 0)//luckily we can proceed { int selectSegId = rdGen.NextInt(0, availableSegCount); nextSeg = _availableSeg[selectSegId]; dir = RoadSegments[nextSeg].StartNodeId == nextCrossing ? 1.0f : -1.0f; } else//to the end, spawn a new pos { nextSeg = rdGen.NextInt(0, RoadSegments.Length); } float3 nextForward = RoadSegments[nextSeg].Direction * dir; quaternion newRot = quaternion.LookRotation(nextForward, new float3() { x = 0, y = 1, z = 0 }); laneCount = RoadSegments[nextSeg].LaneNumber; nextLane = nextLane < laneCount ? nextLane : laneCount - 1; float laneOffset = (nextLane + 0.5f) * RoadSegments[nextSeg].LaneWidth; if (RoadSegments[nextSeg].IsOneWay == 1) { laneOffset -= (laneCount / 2.0f) * RoadSegments[nextSeg].LaneWidth; } float nextPerct = dir > 0.0f ? (nextPosPerc > 0.0f ? nextPosPerc - 1.0f : -nextPosPerc) : (nextPosPerc > 0.0f ? 2.0f - nextPosPerc : nextPosPerc + 1.0f); float3 nextPos = (1.0f - nextPerct) * RoadNodes[RoadSegments[nextSeg].StartNodeId].Position + (nextPerct) * RoadNodes[RoadSegments[nextSeg].EndNodeId].Position; nextPos += laneOffset * dir * RoadSegments[nextSeg].RightDirection; VehicleData[i] = new VehicleData( VehicleData[i].Id, nextSeg, newSpeed, nextForward, nextPerct, dir, nextPos, nextLane, newDistanceAhead ); BVHAABB newAABB = AABB[i]; newAABB.Max += (nextPos - currentPos); newAABB.Min += (nextPos - currentPos); AABB[i] = newAABB; Positions[i] = new Position() { Value = nextPos }; Rotations[i] = new Rotation() { Value = newRot }; UnsafeUtility.Free(_availableSeg, Allocator.Temp); _availableSeg = null; } }
private void ConnectRegions() { // Find all of the tiles that can connect two (or more) regions. var connectorRegions = new Dictionary <Vector, HashSet <int> >(); foreach (var pos in Bounds.Deflate()) { // Can't already be part of a region. if (GetTile(pos) != TileType.Wall) { continue; } var regions = new HashSet <int>(); var neighbours = Direction.Cardinal .Select(dir => pos + dir) .Where(p => Bounds.Contains(p)); foreach (var neighbour in neighbours) { regions.Add(regionMap[neighbour.X, neighbour.Y]); } if (regions.Count < 2) { continue; } connectorRegions[pos] = regions; } var connectors = connectorRegions.Keys.ToList(); // Keep track of which regions have been merged. This maps an original // region index to the one it has been merged to. var merged = new Dictionary <int, int>(); var openRegions = new HashSet <int>(); for (var i = 0; i <= currentRegion; i++) { merged[i] = i; openRegions.Add(i); } // Keep connecting regions until we're down to one. while (openRegions.Count > 1) { var connector = connectors.PickRandom(); if (connector == null) { break; } // Carve the connection. AddJunction(connector); // Merge the connected regions. We'll pick one region (arbitrarily) and // map all of the other regions to its index. var mRegions = connectorRegions[connector] .Select(region => merged[region]).ToList(); var dest = mRegions.First(); var sources = mRegions.Skip(1).ToList(); // Merge all of the affected regions. We have to look at *all* of the // regions because other regions may have previously been merged with // some of the ones we're merging now. for (var i = 0; i <= currentRegion; i++) { if (sources.Contains(merged[i])) { merged[i] = dest; } } // The sources are no longer in use. openRegions.RemoveWhere(i => sources.Contains(i)); // Remove any connectors that aren't needed anymore. connectors.RemoveAll(pos => { // Don't allow connectors right next to each other. if ((connector - pos).Distance < 2) { return(true); } // If the connector no long spans different regions, we don't need it. var regions = new HashSet <int>(connectorRegions[pos].Select(region => merged[region])); if (regions.Count > 1) { return(false); } // This connecter isn't needed, but connect it occasionally so that the // dungeon isn't singly-connected. if (Randomizer.ChanceIn(extraConnectorChance)) { AddJunction(pos); } return(true); }); } }
public bool Contains(int offsetX, int offsetY) { return(bounds.Contains(offsetX, offsetY)); }
/// <inheritdoc /> protected override void OnLeftMouseButtonUp() { // Skip if was controlling mouse or mouse is not over the area if (_prevInput.IsControllingMouse || !Bounds.Contains(ref _viewMousePos)) { return; } if (TransformGizmo.IsActive) { // Ensure player is not moving objects if (TransformGizmo.ActiveAxis != TransformGizmo.Axis.None) { return; } } else { // For now just pick objects in transform gizmo mode return; } // Get mouse ray and try to hit any object var ray = MouseRay; float closest = float.MaxValue; bool selectColliders = (Task.Flags & ViewFlags.PhysicsDebug) == ViewFlags.PhysicsDebug; SceneGraphNode.RayCastData.FlagTypes rayCastFlags = SceneGraphNode.RayCastData.FlagTypes.None; if (!selectColliders) { rayCastFlags |= SceneGraphNode.RayCastData.FlagTypes.SkipColliders; } var hit = Editor.Instance.Scene.Root.RayCast(ref ray, ref closest, rayCastFlags); // Update selection var sceneEditing = Editor.Instance.SceneEditing; if (hit != null) { // For child actor nodes (mesh, link or sth) we need to select it's owning actor node first or any other child node (but not a child actor) if (hit is ActorChildNode actorChildNode) { var parentNode = actorChildNode.ParentNode; bool canChildBeSelected = sceneEditing.Selection.Contains(parentNode); if (!canChildBeSelected) { for (int i = 0; i < parentNode.ChildNodes.Count; i++) { if (sceneEditing.Selection.Contains(parentNode.ChildNodes[i])) { canChildBeSelected = true; break; } } } if (!canChildBeSelected) { // Select parent hit = parentNode; } } bool addRemove = Root.GetKey(Keys.Control); bool isSelected = sceneEditing.Selection.Contains(hit); if (addRemove) { if (isSelected) { sceneEditing.Deselect(hit); } else { sceneEditing.Select(hit, true); } } else { sceneEditing.Select(hit); } } else { sceneEditing.Deselect(); } // Keep focus Focus(); base.OnLeftMouseButtonUp(); }
public virtual bool FillContains(Point point) => Bounds.Contains(point);
public bool CheckPositionIsInsidePaddle(Vector2 position) { return(_bounds.Contains(position)); }
public static Vector3 BoundsInBoundsCheck(Bounds bigB, Bounds lilB, BoundsTest test = BoundsTest.onScreen) { // Центр lilB Vector3 pos = lilB.center; // Создаём смещение Vector3 off = Vector3.zero; switch (test) { case BoundsTest.center: if (bigB.Contains(pos)) { return(Vector3.zero); } if (pos.x > bigB.max.x) { off.x = pos.x - bigB.max.x; } else if (pos.x < bigB.min.x) { off.x = pos.x - bigB.min.x; } if (pos.y > bigB.max.y) { off.y = pos.y - bigB.max.y; } else if (pos.y < bigB.min.y) { off.y = pos.y - bigB.min.y; } if (pos.z > bigB.max.z) { off.z = pos.z - bigB.max.z; } else if (pos.z < bigB.min.z) { off.z = pos.z - bigB.min.z; } return(off); // Что нужно сделать, чтобы держать lilB внутри bigB case BoundsTest.onScreen: if (bigB.Contains(lilB.min) && bigB.Contains(lilB.max)) { return(Vector3.zero); } if (lilB.max.x > bigB.max.x) { off.x = lilB.max.x - bigB.max.x; } else if (lilB.min.x < bigB.min.x) { off.x = lilB.min.x - bigB.min.x; } if (lilB.max.y > bigB.max.y) { off.y = lilB.max.y - bigB.max.y; } else if (lilB.min.y < bigB.min.y) { off.y = lilB.min.y - bigB.min.y; } if (lilB.max.z > bigB.max.z) { off.z = lilB.max.z - bigB.max.z; } else if (lilB.min.z < bigB.min.z) { off.z = lilB.min.z - bigB.min.z; } return(off); case BoundsTest.offScreen: bool cMin = bigB.Contains(lilB.min); bool cMax = bigB.Contains(lilB.max); if (cMin || cMax) { return(Vector3.zero); } if (lilB.min.x > bigB.max.x) { off.x = lilB.min.x - bigB.max.x; } else if (lilB.max.x < bigB.min.x) { off.x = lilB.max.x - bigB.min.x; } if (lilB.min.y > bigB.max.y) { off.y = lilB.min.y - bigB.max.y; } else if (lilB.max.y < bigB.min.y) { off.y = lilB.max.y - bigB.min.y; } if (lilB.min.z > bigB.max.z) { off.z = lilB.min.z - bigB.max.z; } else if (lilB.max.z < bigB.min.z) { off.z = lilB.max.z - bigB.min.z; } return(off); default: return(Vector3.zero); } }
public virtual bool Contains(PointF p) { return(Bounds.Contains(p)); }
// Update is called once per frame void Update() { hasPrimary = primaryObject; //If there is a primary object, hasPrimary is true if (primaryObject != null) //Is there a primary object? { ObjectPanel.alpha = 1; //Sets the unit panel to be visible ObjectPanel.blocksRaycasts = true; //Sets the unit panel to block raycasts ObjectPanel.interactable = true; //Sets the unit panel to be interactable } else { ObjectPanel.alpha = 0; //Sets the unit panel to be invisible ObjectPanel.blocksRaycasts = false; //Sets the unit panel to not block raycasts ObjectPanel.interactable = false; //Sets the unit panel to be not interactable } //Did the player left click while being able to click the ground and while the move button is not active? if (Input.GetMouseButtonDown(0) && canClickGround && !AL.moveButtonActive) { Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition); RaycastHit hit; //Did the raycast hit something? if (Physics.Raycast(ray, out hit)) { ObjectInfo OI = hit.collider.GetComponent <ObjectInfo>(); //Is there anything currently selected? if (OI != null) { //Is the player holding left shift? if (Input.GetKey(KeyCode.LeftShift)) { UpdateSelection(OI, !OI.isSelected); //Add the clicked object to selected units } else { //Replace selected units with the clicked object ClearSelected(); UpdateSelection(OI, true); } } } startPos = Input.mousePosition; //Set the start position isSelecting = true; //The player is now selecting } //Did the player release the left mouse button? if (Input.GetMouseButtonUp(0)) { isSelecting = false; } //Toggle the selection box based on if the player is selecting selectionBox.gameObject.SetActive(isSelecting); //Is the player selecting? if (isSelecting) { //Define new bounds based on current selection box Bounds bounds = new Bounds(); bounds.center = Vector3.Lerp(startPos, Input.mousePosition, 0.5f); bounds.size = new Vector3(Mathf.Abs(startPos.x - Input.mousePosition.x), Mathf.Abs(startPos.y - Input.mousePosition.y), 0); //Adjust the selection bos image to match the bounds RT.position = bounds.center; RT.sizeDelta = canvas.transform.InverseTransformVector(bounds.size); //For each selectable object foreach (ObjectInfo selectable in selectedObjects) { //If it's a unit owned by the player if (selectable.isUnit && selectable.isPlayerObject) { Vector3 screenPos = Camera.main.WorldToScreenPoint(selectable.transform.position); //Get the unit's position on the screen screenPos.z = 0; //Set the screen position z to 0 UpdateSelection(selectable, (bounds.Contains(screenPos))); //Update selection based on if the selected object is inside selection box bounds } } } }
public static Bounds BoundsHandle(Bounds bounds, Quaternion rotation, CapFunction sideCapFunction, CapFunction pointCapFunction, Vector3?snappingSteps = null) { var hotControl = GUIUtility.hotControl; bool isControlHot = false; for (int i = 0; i < s_BoundsControlIds.Length; i++) { s_BoundsControlIds[i] = GUIUtility.GetControlID(s_BoundsHash, FocusType.Keyboard); s_BoundsAxisHot[i] = s_BoundsControlIds[i] == hotControl; isControlHot = isControlHot || s_BoundsAxisHot[i]; } s_BoundsSlideDirs[0] = rotation * Vector3.right; s_BoundsSlideDirs[1] = rotation * Vector3.up; s_BoundsSlideDirs[2] = rotation * Vector3.forward; var min = bounds.min; var max = bounds.max; var center = bounds.center; s_BoundsValues[0] = min.x; s_BoundsValues[1] = min.y; s_BoundsValues[2] = min.z; s_BoundsValues[3] = max.x; s_BoundsValues[4] = max.y; s_BoundsValues[5] = max.z; s_BoundsVertices[0] = rotation * new Vector3(s_BoundsValues[0], s_BoundsValues[1], s_BoundsValues[2]); s_BoundsVertices[1] = rotation * new Vector3(s_BoundsValues[3], s_BoundsValues[1], s_BoundsValues[2]); s_BoundsVertices[2] = rotation * new Vector3(s_BoundsValues[3], s_BoundsValues[4], s_BoundsValues[2]); s_BoundsVertices[3] = rotation * new Vector3(s_BoundsValues[0], s_BoundsValues[4], s_BoundsValues[2]); s_BoundsVertices[4] = rotation * new Vector3(s_BoundsValues[0], s_BoundsValues[1], s_BoundsValues[5]); s_BoundsVertices[5] = rotation * new Vector3(s_BoundsValues[3], s_BoundsValues[1], s_BoundsValues[5]); s_BoundsVertices[6] = rotation * new Vector3(s_BoundsValues[3], s_BoundsValues[4], s_BoundsValues[5]); s_BoundsVertices[7] = rotation * new Vector3(s_BoundsValues[0], s_BoundsValues[4], s_BoundsValues[5]); s_BoundsSidePoint[0] = rotation * new Vector3(s_BoundsValues[0], center.y, center.z); s_BoundsSidePoint[1] = rotation * new Vector3(center.x, s_BoundsValues[1], center.z); s_BoundsSidePoint[2] = rotation * new Vector3(center.x, center.y, s_BoundsValues[2]); s_BoundsSidePoint[3] = rotation * new Vector3(s_BoundsValues[3], center.y, center.z); s_BoundsSidePoint[4] = rotation * new Vector3(center.x, s_BoundsValues[4], center.z); s_BoundsSidePoint[5] = rotation * new Vector3(center.x, center.y, s_BoundsValues[5]); // TODO: add handles in the corners of each quad on the bounds, with an offset from the vertex, to drag from there using (new SceneHandles.DrawingScope()) { var prevDisabled = SceneHandles.disabled; var isStatic = (!Tools.hidden && EditorApplication.isPlaying && GameObjectUtility.ContainsStatic(Selection.gameObjects)); for (int i = 0; i < s_BoundsAxisDisabled.Length; i++) { s_BoundsAxisDisabled[i] = isStatic || prevDisabled || Snapping.AxisLocking[i % 3] || (isControlHot && !s_BoundsAxisHot[i]); } var camera = Camera.current; var cameraLocalPos = SceneHandles.inverseMatrix.MultiplyPoint(camera.transform.position); var cameraLocalForward = SceneHandles.inverseMatrix.MultiplyVector(camera.transform.forward); var isCameraInsideBox = bounds.Contains(cameraLocalPos); var isCameraOrthographic = camera.orthographic; var boundsColor = SceneHandles.yAxisColor; var backfacedColor = new Color(boundsColor.r, boundsColor.g, boundsColor.b, boundsColor.a * SceneHandles.backfaceAlphaMultiplier); var prevGUIchanged = GUI.changed; bool haveChanged = false; var selectedAxes = Axes.None; // all sides of bounds int currentFocusControl = SceneHandleUtility.focusControl; for (int i = 0; i < s_BoundsValues.Length; i++) { var id = s_BoundsControlIds[i]; GUI.changed = false; var localPoint = s_BoundsSidePoint[i]; var handleSize = UnityEditor.HandleUtility.GetHandleSize(localPoint); var pointSize = handleSize * kPointScale; var direction = s_BoundsSlideDirs[i % 3]; var normal = (i < 3) ? -direction : direction; normal.x *= (bounds.size.x < 0) ? -1 : 1; normal.y *= (bounds.size.y < 0) ? -1 : 1; normal.z *= (bounds.size.z < 0) ? -1 : 1; if (Event.current.type == EventType.Repaint) { s_BoundsBackfaced[i] = false; if (!isCameraInsideBox) { var cosV = isCameraOrthographic ? Vector3.Dot(normal, -cameraLocalForward) : Vector3.Dot(normal, (cameraLocalPos - localPoint)); if (cosV < -0.0001f) { // TODO: do not set backfaced to true when side is infinitely thin s_BoundsBackfaced[i] = !(isControlHot && !s_BoundsAxisHot[i % 3]); } } var sideColor = (s_BoundsBackfaced[i] ? backfacedColor: boundsColor); SceneHandles.color = SceneHandles.StateColor(sideColor, s_BoundsAxisDisabled[i], (currentFocusControl == id)); if (currentFocusControl == id) { var sceneView = SceneView.currentDrawingSceneView; if (sceneView) { var rect = sceneView.position; rect.min = Vector2.zero; EditorGUIUtility.AddCursorRect(rect, SceneHandleUtility.GetCursorForDirection(localPoint, normal)); } selectedAxes = s_BoundsAxes[i]; } if (s_BoundsBackfaced[i]) { pointSize *= backfaceSizeMultiplier; } } var steps = snappingSteps ?? Snapping.MoveSnappingSteps; var newPoint = Slider1DHandle(id, (Axis)(i % 3), localPoint, normal, steps[i % 3], pointSize, sideCapFunction); if (GUI.changed) { s_BoundsValues[i] += Vector3.Dot(direction, newPoint - localPoint); haveChanged = true; } } // all edges of bounds for (int i = 0; i < s_BoundsEdgeIndices.GetLength(0); i++) { var id = GUIUtility.GetControlID(s_BoundsHash, FocusType.Keyboard); GUI.changed = false; var index1 = s_BoundsEdgeIndices[i, 0]; var index2 = s_BoundsEdgeIndices[i, 1]; var point1 = s_BoundsVertices[index1]; var point2 = s_BoundsVertices[index2]; var midPoint = (point1 + point2) * 0.5f; var offset1 = s_EdgeDirectionOffsets[i, 0]; var offset2 = s_EdgeDirectionOffsets[i, 1]; var offset3 = s_EdgeDirectionOffsets[i, 2]; var offset1_dir = offset1 % 3; var offset2_dir = offset2 % 3; if (Event.current.type == EventType.Repaint) { var highlight = (currentFocusControl == id) || (currentFocusControl == s_BoundsControlIds[offset1]) || (currentFocusControl == s_BoundsControlIds[offset2]); var edgeColor = (s_BoundsBackfaced[offset1] && s_BoundsBackfaced[offset2]) ? backfacedColor : boundsColor; var edgeDisabled = (s_BoundsAxisDisabled[offset1] && s_BoundsAxisDisabled[offset2]); SceneHandles.color = SceneHandles.StateColor(edgeColor, edgeDisabled, highlight); if (currentFocusControl == id) { selectedAxes = s_EdgeAxes[i]; } } // only use capFunction (render point) when in ortho mode & aligned with box or when side size is 0 bool isSideAlignedWithCamera = false; // TODO: determine if aligned with camera direction & in ortho mode bool showSidePoint = !isSideAlignedWithCamera && ((point2 - point1).sqrMagnitude < kShowPointThreshold); float pointSize; Vector3 offset; if (showSidePoint) { pointSize = UnityEditor.HandleUtility.GetHandleSize(midPoint) * kPointScale; offset = Edge2DHandleOffset(id, point1, point2, midPoint, s_BoundsSlideDirs[offset3], s_BoundsSlideDirs[offset1_dir], s_BoundsSlideDirs[offset2_dir], pointSize, pointCapFunction, s_EdgeAxes[i], snappingSteps: snappingSteps); } else { offset = Edge2DHandleOffset(id, point1, point2, midPoint, s_BoundsSlideDirs[offset3], s_BoundsSlideDirs[offset1_dir], s_BoundsSlideDirs[offset2_dir], 0, null, s_EdgeAxes[i], snappingSteps: snappingSteps); } if (GUI.changed) { offset = Quaternion.Inverse(rotation) * offset; if (Mathf.Abs(offset[offset1_dir]) > 0.000001f || Mathf.Abs(offset[offset2_dir]) > 0.000001f) { s_BoundsValues[offset1] += offset[offset1_dir]; s_BoundsValues[offset2] += offset[offset2_dir]; haveChanged = true; } else { GUI.changed = false; } } } GUI.changed = prevGUIchanged || haveChanged; if (haveChanged) { var size = bounds.size; center.x = (s_BoundsValues[3] + s_BoundsValues[0]) * 0.5f; size.x = (s_BoundsValues[3] - s_BoundsValues[0]); center.y = (s_BoundsValues[4] + s_BoundsValues[1]) * 0.5f; size.y = (s_BoundsValues[4] - s_BoundsValues[1]); center.z = (s_BoundsValues[5] + s_BoundsValues[2]) * 0.5f; size.z = (s_BoundsValues[5] - s_BoundsValues[2]); bounds.center = center; bounds.size = size; } // TODO: paint XZ intersection with grid plane + 'shadow' SceneHandles.disabled = prevDisabled; } return(bounds); }
public static bool Contains(this Bounds b1, Bounds b2) { return(b1.Contains(b2.min) && b1.Contains(b2.max)); }
public static void findShieldedPartsCylinder(Part basePart, Bounds fairingRenderBounds, List <Part> shieldedParts, float topY, float bottomY, float topRadius, float bottomRadius) { float height = topY - bottomY; float largestRadius = topRadius > bottomRadius ? topRadius : bottomRadius; Vector3 lookupCenterLocal = new Vector3(0, bottomY + (height * 0.5f), 0); Vector3 lookupTopLocal = new Vector3(0, topY, 0); Vector3 lookupBottomLocal = new Vector3(0, bottomY, 0); Vector3 lookupCenterGlobal = basePart.transform.TransformPoint(lookupCenterLocal); Ray lookupRay = new Ray(lookupBottomLocal, new Vector3(0, 1, 0)); List <Part> partsFound = new List <Part>(); Collider[] foundColliders = Physics.OverlapSphere(lookupCenterGlobal, height * 1.5f, 1); foreach (Collider col in foundColliders) { Part pt = col.gameObject.GetComponentUpwards <Part>(); if (pt != null && pt != basePart && pt.vessel == basePart.vessel && !partsFound.Contains(pt)) { partsFound.Add(pt); } } Bounds[] otherPartBounds; Vector3 otherPartCenterLocal; float partYPos; float partYPercent; float partYRadius; float radiusOffset = topRadius - bottomRadius; foreach (Part pt in partsFound) { //check basic render bounds for containment //TODO this check misses the case where the fairing is long/tall, containing a wide part; it will report that the wide part can fit inside //of the fairing, due to the relative size of their colliders otherPartBounds = pt.GetRendererBounds(); if (PartGeometryUtil.MergeBounds(otherPartBounds, pt.transform).size.sqrMagnitude > fairingRenderBounds.size.sqrMagnitude) { continue; } Vector3 otherPartCenter = pt.partTransform.TransformPoint(PartGeometryUtil.FindBoundsCentroid(otherPartBounds, pt.transform)); if (!fairingRenderBounds.Contains(otherPartCenter)) { continue; } //check part bounds center point against conic projection of the fairing otherPartCenterLocal = basePart.transform.InverseTransformPoint(otherPartCenter); //check vs top and bottom of the shielded area if (otherPartCenterLocal.y > lookupTopLocal.y || otherPartCenterLocal.y < lookupBottomLocal.y) { continue; } //quick check vs cylinder radius float distFromLine = SSTUUtils.distanceFromLine(lookupRay, otherPartCenterLocal); if (distFromLine > largestRadius) { continue; } //more precise check vs radius of the cone at that Y position partYPos = otherPartCenterLocal.y - lookupBottomLocal.y; partYPercent = partYPos / height; partYRadius = partYPercent * radiusOffset; if (distFromLine > (partYRadius + bottomRadius)) { continue; } shieldedParts.Add(pt); } }
// Tests to see whether lilB is inside bigB public static Vector3 BoundsInBoundsCheck(Bounds bigB, Bounds lilB, BoundsTest test = BoundsTest.onScreen) { // Get the center of lilB Vector3 pos = lilB.center; // Initialize the offset at [0,0,0] Vector3 off = Vector3.zero; switch (test) { // The center test determines what off (offset) would have to be applied to lilB to move its center back inside bigB case BoundsTest.center: // if the center is contained, return Vector3.zero if (bigB.Contains(pos)) { return(Vector3.zero); } // if not contained, find the offset if (pos.x > bigB.max.x) { off.x = pos.x - bigB.max.x; } else if (pos.x < bigB.min.x) { off.x = pos.x - bigB.min.x; } if (pos.y > bigB.max.y) { off.y = pos.y - bigB.max.y; } else if (pos.y < bigB.min.y) { off.y = pos.y - bigB.min.y; } if (pos.z > bigB.max.z) { off.z = pos.z - bigB.max.z; } else if (pos.z < bigB.min.z) { off.z = pos.z - bigB.min.z; } return(off); // The onScreen test determines what off would have to be applied to keep all of lilB inside bigB case BoundsTest.onScreen: // find whether bigB contains all of lilB if (bigB.Contains(lilB.min) && bigB.Contains(lilB.max)) { return(Vector3.zero); } // if not, find the offset if (lilB.max.x > bigB.max.x) { off.x = lilB.max.x - bigB.max.x; } else if (lilB.min.x < bigB.min.x) { off.x = lilB.min.x - bigB.min.x; } if (lilB.max.y > bigB.max.y) { off.y = lilB.max.y - bigB.max.y; } else if (lilB.min.y < bigB.min.y) { off.y = lilB.min.y - bigB.min.y; } if (lilB.max.z > bigB.max.z) { off.z = lilB.max.z - bigB.max.z; } else if (lilB.min.z < bigB.min.z) { off.z = lilB.min.z - bigB.min.z; } return(off); // The offScreen test determines what off would need to be applied to move any tiny part of lilB inside of bigB case BoundsTest.offScreen: // find whether bigB contains any of lilB bool cMin = bigB.Contains(lilB.min); bool cMax = bigB.Contains(lilB.max); if (cMin || cMax) { return(Vector3.zero); } // if not, find the offset if (lilB.min.x > bigB.max.x) { off.x = lilB.min.x - bigB.max.x; } else if (lilB.max.x < bigB.min.x) { off.x = lilB.max.x - bigB.min.x; } if (lilB.min.y > bigB.max.y) { off.y = lilB.min.y - bigB.max.y; } else if (lilB.max.y < bigB.min.y) { off.y = lilB.max.y - bigB.min.y; } if (lilB.min.z > bigB.max.z) { off.z = lilB.min.z - bigB.max.z; } else if (lilB.max.z < bigB.min.z) { off.z = lilB.max.z - bigB.min.z; } return(off); } return(Vector3.zero); }
public void Update(MouseState mouse, KeyboardState keyboard, KeyboardState previousKeyboard) { if (mouse.LeftButton == ButtonState.Pressed) { if (Bounds.Contains(mouse.Position)) { isClicked = true; } else { isClicked = false; } } if (isClicked) { if (keyboard.IsKeyDown(Keys.D0) && previousKeyboard.IsKeyUp(Keys.D0)) { currentWord = currentWord.Insert(cursorIndex, "0"); cursorIndex++; } else if (keyboard.IsKeyDown(Keys.D1) && previousKeyboard.IsKeyUp(Keys.D1)) { currentWord = currentWord.Insert(cursorIndex, "1"); cursorIndex++; } else if (keyboard.IsKeyDown(Keys.D2) && previousKeyboard.IsKeyUp(Keys.D2)) { currentWord = currentWord.Insert(cursorIndex, "2"); cursorIndex++; } else if (keyboard.IsKeyDown(Keys.D3) && previousKeyboard.IsKeyUp(Keys.D3)) { currentWord = currentWord.Insert(cursorIndex, "3"); cursorIndex++; } else if (keyboard.IsKeyDown(Keys.D4) && previousKeyboard.IsKeyUp(Keys.D4)) { currentWord = currentWord.Insert(cursorIndex, "4"); cursorIndex++; } else if (keyboard.IsKeyDown(Keys.D5) && previousKeyboard.IsKeyUp(Keys.D5)) { currentWord = currentWord.Insert(cursorIndex, "5"); cursorIndex++; } else if (keyboard.IsKeyDown(Keys.D6) && previousKeyboard.IsKeyUp(Keys.D6)) { currentWord = currentWord.Insert(cursorIndex, "6"); cursorIndex++; } else if (keyboard.IsKeyDown(Keys.D7) && previousKeyboard.IsKeyUp(Keys.D7)) { currentWord = currentWord.Insert(cursorIndex, "7"); cursorIndex++; } else if (keyboard.IsKeyDown(Keys.D8) && previousKeyboard.IsKeyUp(Keys.D8)) { currentWord = currentWord.Insert(cursorIndex, "8"); cursorIndex++; } else if (keyboard.IsKeyDown(Keys.D9) && previousKeyboard.IsKeyUp(Keys.D9)) { currentWord = currentWord.Insert(cursorIndex, "9"); cursorIndex++; } else if (keyboard.IsKeyDown(Keys.Back) && previousKeyboard.IsKeyUp(Keys.Back) && cursorIndex > 0) { currentWord = currentWord.Remove(cursorIndex - 1, 1); if (cursorIndex != 0) { cursorIndex--; } } else if (keyboard.IsKeyDown(Keys.Left) && previousKeyboard.IsKeyUp(Keys.Left) && cursorIndex > 0) { cursorIndex--; } else if (keyboard.IsKeyDown(Keys.Right) && previousKeyboard.IsKeyUp(Keys.Right) && cursorIndex < currentWord.Length) { cursorIndex++; } if (currentWord == "") { reset(); } else { Scale = font.MeasureString(currentWord); } } }
public virtual bool Contains(int x, int y) { return(Bounds.Contains(x, y)); }
public static bool ContainBounds(this Bounds bounds, Bounds target) { return(bounds.Contains(target.min) && bounds.Contains(target.max)); }
void PopulateCellCandidates() { Profiler.BeginSample("Populate Candidates"); ms_random = new System.Random(1235798); var detailPrototypes = terrainTemplate.detailPrototypes; var spriteSamplesInCell = Mathf.RoundToInt(cellSize * cellMaxSpriteDensity); spriteSamplesInCell *= spriteSamplesInCell; var meshSamplesInCell = Mathf.RoundToInt(cellSize * cellMaxMeshDensity); meshSamplesInCell *= meshSamplesInCell; var meshBuilder = new MeshBuilder(); var meshBuilder2 = new MeshBuilder(); var maxInstancesInPatch = Mathf.CeilToInt(spriteSamplesInCell * m_patchesInCellSide); var patches = new int[m_patchesInCellSide, m_patchesInCellSide, 1 + maxInstancesInPatch]; var boundsCorner = m_bounds.center - m_bounds.extents; for (int cellIdx = 0; cellIdx < m_phatCells.Count;) { Profiler.BeginSample("Cell"); var phatCell = m_phatCells[cellIdx]; var cellOffset = new Vector3(phatCell.x * cellSize, 0f, phatCell.z * cellSize); var cellCorner = boundsCorner + cellOffset; float minY = float.MaxValue, maxY = float.MinValue; foreach (var pj in phatCell.pjobs) { Profiler.BeginSample("Paintjob"); var pjCorner = pj.transform.position - pj.alignedSize * 0.5f; var pjSizeRcp = new Vector3(1f / pj.alignedSize.x, 1f, 1f / pj.alignedSize.z); for (int s = 0, sidx = 0; s < spriteSamplesInCell; ++s) { for (int l = 0, ln = pj.detailLayerCount; l < ln; ++l) { var detailLayer = detailPrototypes[l]; if (detailLayer.usePrototypeMesh) { continue; } var subCellSampleRand = RandX0Z_ZO; var subCellSampleOffset = subCellSampleRand * cellSize; var subCellSamplePos = cellCorner + subCellSampleOffset; var patchRelativePos = Vector3.Scale(subCellSamplePos - pjCorner, pjSizeRcp); if (patchRelativePos.x < 0f || patchRelativePos.x > 1f || patchRelativePos.z < 0f || patchRelativePos.z > 1f) { continue; } var patchDimension = Mathf.RoundToInt(Mathf.Sqrt(pj.detailLayerElements)); var patchOffset = Mathf.Clamp(Mathf.RoundToInt(patchDimension * patchRelativePos.x), 0, patchDimension); patchOffset += Mathf.RoundToInt(patchDimension * Mathf.Round(patchDimension * patchRelativePos.z)); patchOffset = Mathf.Clamp(patchOffset, 0, pj.detailLayerElements - 1); if (pj.maskData[patchOffset] <= 0f) { continue; } int totalLayersValue = 0; for (int lc = 0, lcn = pj.detailLayerCount; lc < lcn; ++lc) { var layerValue2 = pj.detailData[lc * pj.detailLayerElements + patchOffset]; totalLayersValue += layerValue2; } float totalLayersScale = Mathf.Clamp01(totalLayersValue / 4f); var heightY = (pj.heightData[patchOffset] - 0.5f) * pj.alignedSize.y + pj.transform.position.y; var placePos = new Vector3(subCellSamplePos.x, heightY, subCellSamplePos.z); // for(int l = 0, ln = pj.detailLayerCount; l < ln; ++l) { // var detailLayer = detailPrototypes[l]; // if(detailLayer.usePrototypeMesh) // continue; var layerValue = pj.detailData[l * pj.detailLayerElements + patchOffset]; if (layerValue > 0) { // TODO: check density vs probability var subPlacePos = placePos; var spriteColB = SampleColormap(subPlacePos); var healthCol = Color.Lerp(detailLayer.dryColor, detailLayer.healthyColor, healthyToDryRatio); // Mathf.Clamp01(0.5f + ssn / (float)maxInstances)); var spriteColT = Color.Lerp(spriteColB, healthCol, groundToTopColorRatio); var darkenBase = Mathf.Lerp(darkenBaseMaxMin.x, darkenBaseMaxMin.y, totalLayersScale); //spriteColB.r *= darkenBase; //spriteColB.g *= darkenBase; //spriteColB.b *= darkenBase; spriteColB.a = darkenBase; //if(darkenBase < darkenBaseMaxMin.y) if (totalLayersScale < 0f || totalLayersScale > 1f) { Debug.LogWarningFormat("SuperDark: {0} {1} {2}", darkenBase, totalLayersValue, totalLayersScale); } var spriteWidth = Mathf.Lerp(detailLayer.minWidth, detailLayer.maxWidth, RandVal_ZO); var spriteHeight = Mathf.Lerp(detailLayer.minHeight, detailLayer.maxHeight, RandVal_ZO); var spriteBB = detailLayer.renderMode == DetailRenderMode.GrassBillboard; var spriteRot = /*spriteBB ? Quaternion.identity :*/ RandYaw_PM; var vtxStart = meshBuilder.PushSprite(growthAtlasMappings[l], spriteWidth, spriteHeight, subPlacePos, spriteRot, spriteColB, spriteColT, spriteBB, sidx++); var patchIdxX = Mathf.FloorToInt(subCellSampleRand.x * m_patchesInCellSide); var patchIdxZ = Mathf.FloorToInt(subCellSampleRand.z * m_patchesInCellSide); var patchIdxNext = 1 + patches[patchIdxX, patchIdxZ, 0]; patches[patchIdxX, patchIdxZ, patchIdxNext] = vtxStart; patches[patchIdxX, patchIdxZ, 0] = patchIdxNext; minY = Mathf.Min(minY, subPlacePos.y); maxY = Mathf.Max(maxY, subPlacePos.y + spriteHeight); } } } for (int s = 0, sidx = 0; s < meshSamplesInCell; ++s) { for (int l = 0, ln = pj.detailLayerCount; l < ln; ++l) { var detailLayer = detailPrototypes[l]; if (!detailLayer.usePrototypeMesh) { continue; } var subCellSampleRand = RandX0Z_ZO; var subCellSampleOffset = subCellSampleRand * cellSize; var subCellSamplePos = cellCorner + subCellSampleOffset; var patchRelativePos = Vector3.Scale(subCellSamplePos - pjCorner, pjSizeRcp); if (patchRelativePos.x < 0f || patchRelativePos.x > 1f || patchRelativePos.z < 0f || patchRelativePos.z > 1f) { continue; } var patchDimension = Mathf.RoundToInt(Mathf.Sqrt(pj.detailLayerElements)); var patchOffset = Mathf.Clamp(Mathf.RoundToInt(patchDimension * patchRelativePos.x), 0, patchDimension); patchOffset += Mathf.RoundToInt(patchDimension * Mathf.Round(patchDimension * patchRelativePos.z)); patchOffset = Mathf.Clamp(patchOffset, 0, pj.detailLayerElements - 1); if (pj.maskData[patchOffset] <= 0f) { continue; } int totalLayersValue = 0; for (int lc = 0, lcn = pj.detailLayerCount; lc < lcn; ++lc) { var layerValue2 = pj.detailData[lc * pj.detailLayerElements + patchOffset]; totalLayersValue += layerValue2; } float totalLayersScale = Mathf.Clamp01(totalLayersValue / 4f); var heightY = (pj.heightData[patchOffset] - 0.5f) * pj.alignedSize.y + pj.transform.position.y; var placePos = new Vector3(subCellSamplePos.x, heightY, subCellSamplePos.z); // for(int l = 0, ln = pj.detailLayerCount; l < ln; ++l) { // var detailLayer = detailPrototypes[l]; // if(!detailLayer.usePrototypeMesh) // continue; var layerValue = pj.detailData[l * pj.detailLayerElements + patchOffset]; if (layerValue > 0) { // TODO: check density vs probability var meshScale = new Vector3( Mathf.Lerp(detailLayer.minWidth, detailLayer.minWidth, RandVal_ZO), Mathf.Lerp(detailLayer.minHeight, detailLayer.maxHeight, RandVal_ZO), Mathf.Lerp(detailLayer.minWidth, detailLayer.minWidth, RandVal_ZO) ); var subPlacePos = placePos; var spriteColB = SampleColormap(subPlacePos); var healthCol = Color.Lerp(detailLayer.dryColor, detailLayer.healthyColor, healthyToDryRatio); // Mathf.Clamp01(0.5f + ssn / (float)maxInstances)); var spriteColT = Color.Lerp(spriteColB, healthCol, groundToTopColorRatio); var darkenBase = Mathf.Lerp(darkenBaseMaxMin.x, darkenBaseMaxMin.y, totalLayersScale); //spriteColB.r *= darkenBase; //spriteColB.g *= darkenBase; //spriteColB.b *= darkenBase; spriteColB.a = darkenBase; //if((layerValue / 16f) < (Random.value - 0.35f)) meshBuilder2.PushMesh( detailLayer.prototype.GetComponent <MeshFilter>().sharedMesh, growthAtlasMappings[l], subPlacePos, RandYaw_PM, meshScale, RandVal_ZO * 0.42f, spriteColB, spriteColT, sidx++ ); } } } var embedBounds = new Bounds( cellCorner + new Vector3(cellSize * 0.5f, 0f, cellSize * 0.5f), new Vector3(cellSize, 100f, cellSize) ); var embedInstanceIdx = 0; foreach (var ei in capturedInstances) { var embedPos = ei.transform.position; if (/*!ei.enabled ||*/ !embedBounds.Contains(embedPos)) { continue; } //public float darkenBaseMesh = 0.3f; //public float meshBaseToGroundRatio = 0.3f; var spriteColB = SampleColormap(embedPos); var spriteColT = Color.Lerp(spriteColB, Color.white, 0.3f); var darkenBase = 0.3f; //Mathf.Lerp(0.6f, 0.15f, totalLayersScale); spriteColB.a = darkenBase; var atlasName = ei.sharedMaterial.mainTexture.name; var atlasIndex = 0; for (; atlasIndex < growthAtlasMappingNames.Length; ++atlasIndex) { if (growthAtlasMappingNames[atlasIndex] == atlasName) { break; } } meshBuilder2.PushMesh(ei.GetComponent <MeshFilter>().sharedMesh, growthAtlasMappings[atlasIndex], embedPos, ei.transform.rotation, ei.transform.localScale, 0f, spriteColB, spriteColT, embedInstanceIdx++ ); //ei.enabled = false; } Profiler.EndSample(); } if (!meshBuilder.IsEmpty || !meshBuilder2.IsEmpty) { //Debug.Log(string.Format("x: {0} z: {1} camD: {2} scaledSpriteDensity: {3}, scaledMeshDensity: {4}, scaledMaxSprites: {5}, scaledMaxMeshes: {6}", cell.x, cell.z, cellDistance, cellScaledSpriteDensity, cellScaledMeshDensity, subCellMaxSpriteInstances, subCellMaxMeshInstances)); //Debug.LogFormat("x: {0} z: {1}", phatCell.x, phatCell.z); var dbgName = string.Format("Cell {0}x{1}: ", phatCell.x, phatCell.z); phatCell.bounds.SetMinMax(new Vector3(cellCorner.x, minY, cellCorner.z), new Vector3(cellCorner.x + cellSize, maxY, cellCorner.z + cellSize)); phatCell.patches = meshBuilder.SortPatches(patches); if (!meshBuilder.IsEmpty) { phatCell.mesh = meshBuilder.Realize(dbgName + "Sprites"); phatCell.indices = phatCell.mesh.triangles; } if (!meshBuilder2.IsEmpty) { phatCell.mesh2 = meshBuilder2.Realize(dbgName + "Meshes"); } meshBuilder.Reset(); meshBuilder2.Reset(); for (int pz = 0, pzn = patches.GetLength(1); pz < pzn; ++pz) { for (int px = 0, pxn = patches.GetLength(0); px < pxn; ++px) { patches[px, pz, 0] = 0; } } ++cellIdx; } else { //Debug.LogFormat("Culling empty cell at {0}, {1}", phatCell.x, phatCell.z); m_phatCells[cellIdx] = m_phatCells[m_phatCells.Count - 1]; m_phatCells.RemoveAt(m_phatCells.Count - 1); } Profiler.EndSample(); } Profiler.EndSample(); }
public virtual void onHover(Point mousePosition) { BackgroundColor = Bounds.Contains(mousePosition) ? Color.Gray : Color.White; }
public bool IsPointInsideWorld(Vector3Int point) { return(worldBounds.Contains(point)); }
// Checks to see whether Bounds lilB are within Bound bigB public static Vector3 BoundsInBoundsCheck(Bounds bigB, Bounds lilB, BoundsTest test = BoundsTest.onScreen) { // The behaviour of the function will change based on the BoundsTest // Get the centre of the lilB Vector3 posLilBCenter = lilB.center; // Initialize the offset Vector3 off = Vector3.zero; // Switch between three cases, is centre within the bigB? is all of lilB within? is any of lilB within? switch (test) { case BoundsTest.centre: // The centre test determine what off would have to be applied to lilB to move the its center back into BigB if (bigB.Contains(posLilBCenter)) { return(Vector3.zero); } if (posLilBCenter.x > bigB.max.x) { off.x = posLilBCenter.x - bigB.max.x; } else if (posLilBCenter.x < bigB.min.x) { off.x = posLilBCenter.x - bigB.min.x; } if (posLilBCenter.y > bigB.max.y) { off.y = posLilBCenter.y - bigB.max.y; } else if (posLilBCenter.y < bigB.min.y) { off.y = posLilBCenter.y - bigB.min.y; } if (posLilBCenter.z > bigB.max.z) { off.z = posLilBCenter.z - bigB.max.z; } else if (posLilBCenter.z < bigB.min.z) { off.z = posLilBCenter.z - bigB.min.z; } return(off); case BoundsTest.onScreen: // The on screen test determine what off would have to be applied to lilB to keep all of lilB inside bigB if (bigB.Contains(lilB.max) && bigB.Contains(lilB.min)) { return(Vector3.zero); } if (lilB.max.x > bigB.max.x) { off.x = lilB.max.x - bigB.max.x; } else if (lilB.min.x < bigB.min.x) { off.x = lilB.min.x - bigB.min.x; } if (lilB.max.y > bigB.max.y) { off.y = lilB.max.y - bigB.max.y; } else if (lilB.min.y < bigB.min.y) { off.y = lilB.min.y - bigB.min.y; } if (lilB.max.z > bigB.max.z) { off.z = lilB.max.z - bigB.max.z; } else if (lilB.min.z < bigB.min.z) { off.z = lilB.min.z - bigB.min.z; } return(off); case BoundsTest.offScreen: // the off screen test deternmine what off would need to be applied to move any tiny part of lilB inside of bigB if (bigB.Contains(lilB.max) || bigB.Contains(lilB.min)) { return(Vector3.zero); } if (lilB.min.x > bigB.max.x) { off.x = lilB.min.x - bigB.max.x; } else if (lilB.max.x < bigB.min.x) { off.x = lilB.max.x - bigB.min.x; } if (lilB.min.y > bigB.max.y) { off.y = lilB.min.y - bigB.max.y; } else if (lilB.max.y < bigB.min.y) { off.y = lilB.max.y - bigB.min.y; } if (lilB.min.z > bigB.max.z) { off.z = lilB.min.z - bigB.max.z; } else if (lilB.max.z < bigB.min.z) { off.z = lilB.max.z - bigB.min.z; } return(off); } return(Vector3.zero); }
// Update is called once per frame void Update() { for (int i = 0; i < activeSwarm.Count; i++) { Vector3 tarPos = tarPositions[i]; //Debug.Log(Time.time + " activeSwarm[i].transform.position " + activeSwarm[i].transform.position + " " + tarPositions[i]); if (Mathf.Abs(Vector3.Distance(activeSwarm[i].transform.position, tarPositions[i])) < reachedTarPosThreshold || Mathf.Abs(Vector3.Distance(center.transform.position, lastCenter)) > changeTarPosThreshold) { float angle = Random.Range(0, 360f) * Mathf.Deg2Rad; float radius = Random.Range(minRadius, maxRadius); float x = Mathf.Cos(angle) * radius; float y = Mathf.Sin(angle) * radius; tarPos = new Vector3(center.transform.position.x + x, center.transform.position.y + y, center.transform.position.z); tarPositions[i] = tarPos; radii[i] = radius; //Debug.Log(Time.time + " new tarPos " + tarPositions[i]); } Vector3 moveDir = tarPos - activeSwarm[i].transform.position; moveDir.Normalize(); activeSwarm[i].transform.position += moveDir * Time.deltaTime * 2; if (moveDir.x > 0) { if (activeSwarm[i].transform.localScale.x < 0) { activeSwarm[i].transform.localScale = new Vector3(-activeSwarm[i].transform.localScale.x, activeSwarm[i].transform.localScale.y, activeSwarm[i].transform.localScale.z); } } else { if (activeSwarm[i].transform.localScale.x > 0) { activeSwarm[i].transform.localScale = new Vector3(-activeSwarm[i].transform.localScale.x, activeSwarm[i].transform.localScale.y, activeSwarm[i].transform.localScale.z); } } //Validate position and target position for (int j = 0; j < activeSwarm.Count; j++) { if (i != j && activeSwarm[i].GetComponent <BoxCollider2D>().bounds.Intersects(activeSwarm[j].GetComponent <BoxCollider2D>().bounds)) { Bounds testBounds = new Bounds(activeSwarm[i].GetComponent <BoxCollider2D>().bounds.center, new Vector3(activeSwarm[i].GetComponent <BoxCollider2D>().bounds.size.x + activeSwarm[j].GetComponent <BoxCollider2D>().bounds.size.x, activeSwarm[i].GetComponent <BoxCollider2D>().bounds.size.y + activeSwarm[j].GetComponent <BoxCollider2D>().bounds.size.y, activeSwarm[i].GetComponent <BoxCollider2D>().bounds.size.z + activeSwarm[j].GetComponent <BoxCollider2D>().bounds.size.z)); if (testBounds.Contains(tarPositions[i])) { float radius = radii[i]; bool validPoint = false; while (!validPoint) { bool invalidPoint = false; float angle = Random.Range(0, 360f) * Mathf.Deg2Rad; float x = Mathf.Cos(angle) * radius; float y = Mathf.Sin(angle) * radius; Vector3 tarPos2 = new Vector3(center.transform.position.x + x, center.transform.position.y + y, center.transform.position.z); for (int k = 0; k < activeSwarm.Count && !validPoint; k++) { testBounds = new Bounds(activeSwarm[i].GetComponent <BoxCollider2D>().bounds.center, new Vector3(activeSwarm[i].GetComponent <BoxCollider2D>().bounds.size.x + activeSwarm[k].GetComponent <BoxCollider2D>().bounds.size.x, activeSwarm[i].GetComponent <BoxCollider2D>().bounds.size.y + activeSwarm[k].GetComponent <BoxCollider2D>().bounds.size.y, activeSwarm[i].GetComponent <BoxCollider2D>().bounds.size.z + activeSwarm[k].GetComponent <BoxCollider2D>().bounds.size.z)); if (testBounds.Contains(tarPos2)) { invalidPoint = true; } } if (!invalidPoint) { validPoint = true; radii[i] = radius; tarPositions[i] = tarPos2; } else { radius += .1f; } } } break; } } } lastCenter = center.transform.position; }
public void BoundsCanContainAPoint() { b = new Bounds(Vector3.zero, Vector3.one); Assert.That(b.Contains(Vector3.zero)); }