private ChunkedLodTreeNode[] GetLeafs(Bounds2D bounds, ChunkedLodTreeNode parent, int depth) { if (depth == 0) { return new ChunkedLodTreeNode[0]; } var min = bounds.Min; var max = bounds.Max; var center = bounds.Center; var first = new Bounds2D(min, new Vector2d(center.X, center.Y)); var second = new Bounds2D(new Vector2d(center.X, min.Y), new Vector2d(max.X, center.Y)); var third = new Bounds2D(new Vector2d(min.X, center.Y), new Vector2d(center.X, max.Y)); var fourth = new Bounds2D(new Vector2d(center.X, center.Y), max); var nextDepth = depth - 1; var geometricError = CalculateGeometricError(depth - 1); return new[] { CreateChunkedLodTreeNode(first, parent, nextDepth, geometricError), CreateChunkedLodTreeNode(second, parent, nextDepth, geometricError), CreateChunkedLodTreeNode(third, parent, nextDepth, geometricError), CreateChunkedLodTreeNode(fourth, parent, nextDepth, geometricError) }; }
private Collision2D(SpriteCollider a, SpriteCollider b) { this.a = a; this.b = b; boundsA = a.getBounds(); boundsB = b.getBounds(); checkCollsion(); }
public Bounds2D toLocal(Bounds2D global) { Bounds2D ret = new Bounds2D(); ret.x = global.x - x; ret.y = global.y - y; ret.width = global.width; ret.height = global.height; return ret; }
public Bounds2D intersection(Bounds2D other) { Bounds2D ret = new Bounds2D(); ret.x = Mathf.Max(x, other.x); ret.y = Mathf.Max(y, other.y); ret.width = Mathf.Abs(ret.x - Mathf.Min(x+width,other.x+other.width)); ret.height = Mathf.Abs(ret.y - Mathf.Min(y+height,other.y+other.height)); return ret; }
public static ChunkedLodTreeFactory.ChunkedLodTreeNode CreateTree() { var chunkedLodTreeFactory = new ChunkedLodTreeFactory(); double width = 8192 * 2 * 2; var bounds = new Bounds2D( new Vector2d(-width/2, -width/2), new Vector2d(width/2, width/2)); var chunkResolution = 32; var depth = (int)Math.Log((width / chunkResolution), 2); return chunkedLodTreeFactory.Create(bounds, depth); }
public ChunkedLodTreeNode(Bounds2D bounds, ChunkedLodTreeNode parent, double geometricError) { Bounds = bounds; Parent = parent; Nodes = new ChunkedLodTreeNode[0]; GeometricError = geometricError; if (Parent == null) { Level = 0; } else { Level = parent.Level + 1; } }
protected override void DoCheck(IMovable user, ref Vector2 vel, ref CollisionStatus collStatus, LayerMask mask, Bounds2D bounds, Bounds2D shrinkedBounds) { //Direction var direction = Math.Sign(vel.y); var verticalRays = user.VerticalRaycasts; var directionVector = new Vector2(0, vel.y * Time.deltaTime); // Bounds2D var bMin = bounds.Min; var bMax = bounds.Max; var positiveDir = direction == 1; var originX = shrinkedBounds.Min.x; var originY = positiveDir ? bMax.y : bMin.y; var origin = new Vector2(originX, originY); var width = shrinkedBounds.Size.x; var spacing = width / (verticalRays - 1); var rayLength = directionVector.magnitude; LastHit = null; var hitDown = false; for (byte x = 0; x < verticalRays; x++) { var raycast = Physics2D.Raycast(origin, directionVector, rayLength, mask); Debug.DrawRay(origin, directionVector, raycast ? Color.green : Color.red); if (raycast && !raycast.collider.isTrigger && raycast.distance < rayLength) { LastHit = raycast; vel.y = raycast.distance / Time.deltaTime * direction; rayLength = raycast.distance; collStatus.Down = direction == -1; collStatus.Up = direction == 1; if (!hitDown) { hitDown = direction == -1; } } origin.x += spacing; } if (!hitDown) { collStatus.Down = false; } }
public Film( Point2I resolution, Bounds2D cropWindow, Filter filter, double diagonal, string filename, double scale, double maxSampleLuminance = double.MaxValue) { FullResolution = resolution; Diagonal = diagonal * 0.001; Filter = filter; Filename = filename; _scale = scale; _maxSampleLuminance = maxSampleLuminance; CroppedPixelBounds = new Bounds2I( new Point2I( Convert.ToInt32(Math.Ceiling(Convert.ToDouble(FullResolution.X) * cropWindow.MinPoint.X)), Convert.ToInt32(Math.Ceiling(Convert.ToDouble(FullResolution.Y) * cropWindow.MinPoint.Y))), new Point2I( Convert.ToInt32(Math.Ceiling(Convert.ToDouble(FullResolution.X) * cropWindow.MaxPoint.X)), Convert.ToInt32(Math.Ceiling(Convert.ToDouble(FullResolution.Y) * cropWindow.MaxPoint.Y)))); //LOG(INFO) << "Created film with full resolution " << resolution << // ". Crop window of " << cropWindow << " -> croppedPixelBounds " << // croppedPixelBounds; // Allocate film image storage _pixels = new Pixel[CroppedPixelBounds.Area]; // todo: this is a stat... _filmPixelMemory += croppedPixelBounds.Area() * sizeof(Pixel); // Precompute filter weight table int offset = 0; for (int y = 0; y < FilterTableWidth; ++y) { for (int x = 0; x < FilterTableWidth; ++x, ++offset) { Point2D p = new Point2D( (x + 0.5f) * filter.Radius.X / Convert.ToDouble(FilterTableWidth), (y + 0.5f) * filter.Radius.Y / Convert.ToDouble(FilterTableWidth)); FilterTable[offset] = filter.Evaluate(p); } } }
/// <inheritdoc /> public PerspectiveCamera(AnimatedTransform cameraToWorld, Bounds2D screenWindow, double shutterOpen, double shutterClose, double lensr, double focald, double fov, Film film, Medium medium) : base(cameraToWorld, Transform.Perspective(fov, 1e-2f, 1000.0), screenWindow, shutterOpen, shutterClose, lensr, focald, film, medium) { // Compute differential changes in origin for perspective camera rays _dxCamera = (RasterToCamera.AtPoint(new Point3D(1.0, 0.0, 0.0)) - RasterToCamera.AtPoint(new Point3D(0.0, 0.0, 0.0))).ToVector3D(); _dyCamera = (RasterToCamera.AtPoint(new Point3D(0.0, 1.0, 0.0)) - RasterToCamera.AtPoint(new Point3D(0.0, 0.0, 0.0))).ToVector3D(); // Compute image plane bounds at $z=1$ for _PerspectiveCamera_ Point2I res = film.FullResolution; Point3D MinPoint = RasterToCamera.AtPoint(new Point3D(0.0, 0.0, 0.0)); Point3D MaxPoint = RasterToCamera.AtPoint(new Point3D(res.X, res.Y, 0.0)); MinPoint /= MinPoint.Z; MaxPoint /= MaxPoint.Z; _a = Math.Abs((MaxPoint.X - MinPoint.X) * (MaxPoint.Y - MinPoint.Y)); }
/// <summary> Constructor </summary> public Polygon2D(params Vector2[] verts) { if (verts.Length < 4) { Debug.LogWarning("You cannot create a polygon with less than 4 verts. Input count: " + verts.Length); verts = new Vector2[] { new Vector2(-1, 1), new Vector2(1, 1), new Vector2(1, -1), new Vector2(-1, -1) }; } _verts = verts; _triIndices = Triangulate(verts); float area = Geometry2D.ShoelaceFormula(_verts); _area = Mathf.Abs(area); _triCount = _triIndices.Length / 3; _bounds = new Bounds2D(verts); _edges = GetEdges(_verts); _tris = GetTriangles(_verts, _triIndices); _isClockwise = area < 0; }
private IList <Polyline4D> method_17( IClippingTransformer transformer, Bounds2D textBounds) { Matrix4D transform = this.Transform; IClippingTransformer transformer1 = (IClippingTransformer)transformer.Clone(); transformer1.SetPreTransform(transform); double num = this.double_1 * (this.backgroundFillInfo_0.BorderOffsetFactor - 1.0); double x1 = textBounds.Corner1.X - num; double x2 = this.double_2 + num; double y1 = textBounds.Corner1.Y - num; double y2 = textBounds.Corner2.Y + num; return(DxfUtil.smethod_38(new WW.Math.Geometry.Polyline3D(true, new WW.Math.Point3D[4] { new WW.Math.Point3D(x1, y1, 0.0), new WW.Math.Point3D(x2, y1, 0.0), new WW.Math.Point3D(x2, y2, 0.0), new WW.Math.Point3D(x1, y2, 0.0) }), true, transformer1)); }
private static bool Contains(Class455.Class461 polyInfo, Point2D point) { Bounds2D bounds2D0 = polyInfo.bounds2D_0; Point2D min = bounds2D0.Min; Point2D max = bounds2D0.Max; if (min.X > point.X || max.X < point.X || (min.Y > point.Y || max.Y < point.Y)) { return(polyInfo.bool_0); } Polygon2D polygon2D0 = polyInfo.polygon2D_0; if (polyInfo.bool_0) { return(!polygon2D0.IsInside(point)); } return(polygon2D0.IsInside(point)); }
private static void SearchRecursive(PathFinderAgent agent, Bounds2D targetBounds, Vector3 targetPos, float targetSqrDist, int targetBranch) { kDTreeBranch branch = branches[targetBranch]; if (branch.bounds.Overlap(targetBounds)) { if (branch.branchA != -1) { SearchRecursive(agent, targetBounds, targetPos, targetSqrDist, branch.branchA); SearchRecursive(agent, targetBounds, targetPos, targetSqrDist, branch.branchB); } else { for (int i = branch.start; i < branch.end; i++) { var realAgent = PathFinder.agents[agents[i].index]; if (agent != realAgent) { float curSqrDist = SomeMath.SqrDistance(targetPos, realAgent.positionVector3); if (curSqrDist < targetSqrDist) { if (agent.neighbourAgents.Count < agent.maxNeighbors) { agent.neighbourAgents.Add(realAgent); agent.neighbourSqrDistances.Add(curSqrDist); } else { for (int n = 0; n < agent.maxNeighbors; n++) { if (agent.neighbourSqrDistances[n] > curSqrDist) { agent.neighbourAgents[n] = realAgent; agent.neighbourSqrDistances[n] = curSqrDist; break; } } } } } } } } }
private void SearchRecursive(T target, Bounds2D targetBounds, Vector2 targetPos, float targetSqrDist, int targetBranch) { kDTreeBranch branch = branches[targetBranch]; if (branch.bounds.Overlap(targetBounds)) { if (branch.branchA != -1) { SearchRecursive(target, targetBounds, targetPos, targetSqrDist, branch.branchA); SearchRecursive(target, targetBounds, targetPos, targetSqrDist, branch.branchB); } else { for (int i = branch.start; i < branch.end; i++) { T realAgent = data[members[i].index]; if (target.Equals(realAgent) == false) { float curSqrDist = SomeMath.SqrDistance(targetPos, realAgent.position); if (curSqrDist < targetSqrDist) { if (target.neighbourAgents.Count < target.maxNeighbours) { target.neighbourAgents.Add(realAgent); target.neighbourSqrDistances.Add(curSqrDist); } else { for (int n = 0; n < target.maxNeighbours; n++) { if (target.neighbourSqrDistances[n] > curSqrDist) { target.neighbourAgents[n] = realAgent; target.neighbourSqrDistances[n] = curSqrDist; break; } } } } } } } } }
public void Transform(ITransformer4D transformer) { WW.Math.Point3D position = this.Position; Vector4D vector4D1 = new Vector4D(position.X, position.Y, position.Z, 1.0); WW.Math.Point3D point3D1 = transformer.TransformToPoint3D(this.matrix4D_0 * vector4D1); Bounds2D bounds = this.interface34_0.Font.Metrics.GetBounds(this.interface34_0.Text, Enum24.flag_0); Vector4D vector4D2 = vector4D1 + new Vector4D(bounds.Delta.X, 0.0, 0.0, 0.0); WW.Math.Point3D point3D2 = transformer.TransformToPoint3D(this.matrix4D_0 * vector4D2); Vector4D vector4D3 = vector4D1 + new Vector4D(0.0, bounds.Delta.Y, 0.0, 0.0); WW.Math.Point3D point3D3 = transformer.TransformToPoint3D(this.matrix4D_0 * vector4D3); Vector3D vector3D1 = (point3D2 - point3D1) / bounds.Delta.X; Vector3D vector3D2 = (point3D3 - point3D1) / bounds.Delta.Y; Vector3D zaxis = Vector3D.CrossProduct(vector3D1, vector3D2); this.matrix4D_0 = Transformation4D.GetCoordSystem(vector3D1, vector3D2, zaxis, point3D1); }
/// <summary> /// Determines whether every item matches the conditions defined by the specified /// predicate. If the current instance contains no items the return value is /// <see langword="true"/>. /// </summary> /// <typeparam name="T"></typeparam> /// <typeparam name="TRefReadOnlyRectCollection"> /// <typeparamref name="TRefReadOnlyRectCollection"/> is /// <see cref="IRefReadOnlyRectangularCollection{T}"/> /// </typeparam> /// <typeparam name="TPredicate"> /// <typeparamref name = "TPredicate"/> is <see cref="IPredicate{T}"/> and /// <see langword="struct"/> /// </typeparam> /// <param name="source">The collection in which the operation takes place.</param> /// <param name="match"> /// A <see langword="struct"/> implementing <see cref="IPredicate{T}"/> that defines /// the conditions to check against the items. /// </param> /// <returns></returns> public static bool TrueForAll <T, TRefReadOnlyRectCollection, TPredicate>( this TRefReadOnlyRectCollection source, TPredicate match) where TRefReadOnlyRectCollection : IRefReadOnlyRectangularCollection <T> where TPredicate : struct, IPredicate <T> { Bounds2D bounds = source.Boundaries; for (int i = 0; i < bounds.Length1; i++) { for (int j = 0; j < bounds.Length2; j++) { if (!match.Invoke(source[new Index2D(i, j)])) { return(false); } } } return(true); }
public PerspectiveCamera(Transform cameraToWorld, Bounds2D screenWindow, float lensRadius, float focalDistance, float fov, Film film) : base(cameraToWorld, Perspective(fov, 1e-2f, 1000f), screenWindow, lensRadius, focalDistance, film) { _dxCamera = RasterToCamera * new Point(1, 0, 0) - RasterToCamera * new Point(0, 0, 0); _dyCamera = RasterToCamera * new Point(0, 1, 0) - RasterToCamera * new Point(0, 0, 0); var res = film.FullResolution; var pMin = RasterToCamera * new Point(0, 0, 0); var pMax = RasterToCamera * new Point(res.X, res.Y, 0); pMin /= pMin.Z; pMax /= pMax.Z; A = Abs((pMax.X - pMin.X) * (pMax.Y - pMin.Y)); }
private Vector2 GetRandomVectorOutTheRoad(Bounds2D bounds) { var rnd = new System.Random(); var vec = new Vector2( rnd.Next((int)bounds.Min.x, (int)bounds.Max.x), rnd.Next((int)bounds.Min.y, (int)bounds.Max.y)); while (game.Map.RoadNodes.Contains(vec)) { vec = new Vector2( rnd.Next((int)bounds.Min.x, (int)bounds.Max.x), rnd.Next((int)bounds.Min.y, (int)bounds.Max.y)); } return(vec); }
public BasicLayoutRenderInfo(IViewDescription viewDescription) { double val1 = viewDescription.ViewportWidth / viewDescription.ViewWidth; double val2 = viewDescription.ViewportHeight / viewDescription.ViewHeight; if (DxfUtil.IsSaneNotZero(val1) && DxfUtil.IsSaneNotZero(val2)) { this.ModelToLayoutScaling = System.Math.Min(val1, val2); Vector2D vector2D = val1 > val2 ? new Vector2D(0.5 * val2 / val1 * viewDescription.ViewportWidth, 0.5 * viewDescription.ViewportHeight) : new Vector2D(0.5 * viewDescription.ViewportWidth, 0.5 * val1 / val2 * viewDescription.ViewportHeight); WW.Math.Point2D viewportCenter = (WW.Math.Point2D)viewDescription.ViewportCenter; this.LayoutViewport = new Bounds2D(viewportCenter - vector2D, viewportCenter + vector2D); this.ModelToLayoutTransform = Transformation4D.Translation((WW.Math.Vector3D)viewDescription.ViewportCenter) * Transformation4D.Scaling(this.ModelToLayoutScaling) * ViewUtil.GetBasicModelToViewportTransform(viewDescription) * Transformation4D.Translation(-(WW.Math.Vector3D)viewDescription.ViewportCenter); } else { this.LayoutViewport = new Bounds2D(); this.ModelToLayoutTransform = Matrix4D.Identity; this.ModelToLayoutScaling = 0.0; } }
public void SetWipeoutPolygon(IList <WW.Math.Point2D> polygon) { Bounds2D bounds2D = new Bounds2D(); bounds2D.Update(polygon); this.InsertionPoint = (WW.Math.Point3D)bounds2D.Min; this.XAxis = new Vector3D(bounds2D.Delta.X, 0.0, 0.0); this.YAxis = new Vector3D(0.0, bounds2D.Delta.Y, 0.0); Matrix3D matrix3D = Transformation3D.Scaling(1.0 / this.XAxis.X, -1.0 / this.YAxis.Y, 1.0) * Transformation3D.Translation(WW.Math.Point2D.Zero - bounds2D.Center); this.BoundaryVertices.Clear(); foreach (WW.Math.Point2D point in (IEnumerable <WW.Math.Point2D>)polygon) { this.BoundaryVertices.Add(matrix3D.Transform(point)); } if (this.BoundaryVertices.Count <= 2 || !(this.BoundaryVertices[0] != this.BoundaryVertices[this.BoundaryVertices.Count - 1])) { return; } this.BoundaryVertices.Add(this.BoundaryVertices[0]); }
/** * Attempts to translate, rotate, and scale @points to match @target as closely as possible. * Only points[0, target.Length] coordinates are used in the matching process - points[target.Length, points.Length] * are just along for the ride. */ public static Transform2D MatchCoordinates(Vector2[] points, Vector2[] target) { int length = points.Length < target.Length ? points.Length : target.Length; Bounds2D t_bounds = new Bounds2D(target, length); // only match the bounds of known matching points // move points to the center of target Vector2 translation = t_bounds.center - Bounds2D.Center(points, length); Vector2[] transformed = new Vector2[points.Length]; for (int i = 0; i < points.Length; i++) { transformed[i] = points[i] + translation; } // rotate to match target points Vector2 target_angle = target[1] - target[0], transform_angle = transformed[1] - transformed[0]; float angle = Vector2.Angle(target_angle, transform_angle); float dot = Vector2.Dot(Vector2.Perpendicular(target_angle), transform_angle); if (dot < 0) { angle = 360f - angle; } for (int i = 0; i < points.Length; i++) { transformed[i] = transformed[i].RotateAroundPoint(t_bounds.center, angle); } // and lastly scale Bounds2D p_bounds = new Bounds2D(transformed, length); Vector2 scale = t_bounds.size.DivideBy(p_bounds.size); // for(int i = 0; i < points.Length; i++) // transformed[i] = transformed[i].ScaleAroundPoint(t_bounds.center, scale); return(new Transform2D(translation, angle, scale)); }
public Terminal(Primitive <bool> isPauseToggled) { this.isPauseToggled = isPauseToggled; commands = new SortedDictionary <string, Command>(); autocomplete = new Autocomplete(); font = ContentCache.GetFont("Debug"); currentLine = new SpriteText(font); suggestionText = new SpriteText(font); lines = new List <SpriteText>(); history = new List <string>(); charWidth = font.Measure("A").x; storedIndex = -1; insertBounds = new Bounds2D(charWidth, font.Size); var accessor = Properties.Access(); padding = accessor.GetInt("terminal.padding"); historyLimit = accessor.GetInt("terminal.history.limit"); Height = accessor.GetInt("terminal.default.height"); Anchor = Anchors.Left | Anchors.Top; IsDrawEnabled = false; colors = new Color[5]; textProcessor = new TextProcessor(); textProcessor.RepeatDelay = accessor.GetFloat("terminal.repeat.delay"); textProcessor.RepeatRate = accessor.GetFloat("terminal.repeat.rate"); textProcessor.Submit = Submit; AddDefaultCommands(); MessageSystem.Subscribe(this, (int)CoreMessageTypes.ResizeWindow, data => { // The terminal is always resized to fit the window width. Width = ((ivec2)data).x; }); InputProcessor.Add(this, 10); }
protected ProjectiveCamera( Transform cameraToWorld, Transform cameraToScreen, Bounds2D screenWindow, float lensRadius, float focalDistance, Film film) { CameraToWorld = cameraToWorld; CameraToScreen = cameraToScreen; LensRadius = lensRadius; FocalDistance = focalDistance; Film = film; ScreenToRaster = Scale(film.FullResolution.X, film.FullResolution.Y, 1f) * Scale(1f / (screenWindow.Max.X - screenWindow.Min.X), 1f / (screenWindow.Min.Y - screenWindow.Max.Y), 1f) * Translate(-screenWindow.Min.X, -screenWindow.Max.Y, 0f); RasterToScreen = Invert(ScreenToRaster); RasterToCamera = Invert(CameraToScreen) * RasterToScreen; }
private void SearchRecursive(QuadTreeBranch curBranch, Bounds2D bounds, List <T> result) { if (curBranch == null) { return; } Bounds2D branchBounds = curBranch.bounds; if (bounds.Overlap(branchBounds) == false) { return; } for (int i = 0; i < curBranch.list.Count; i++) { if (bounds.Overlap(curBranch.list[i].bounds)) { result.Add(curBranch.list[i]); } } if (curBranch.branches[0] != null) { SearchRecursive(curBranch.branches[0], bounds, result); } if (curBranch.branches[1] != null) { SearchRecursive(curBranch.branches[1], bounds, result); } if (curBranch.branches[2] != null) { SearchRecursive(curBranch.branches[2], bounds, result); } if (curBranch.branches[3] != null) { SearchRecursive(curBranch.branches[3], bounds, result); } }
public static ItemRequestResult <Index2D> FindIndex < T, TRectCollection>( this TRectCollection source, Index2D startIndex, Bounds2D sectorSize, Predicate <T> match) where TRectCollection : IRectangularCollection <T> { if (match == null) { throw new ArgumentNullException(nameof(match), "match cannot be null."); } try { return(source.FindIndex <T, TRectCollection, BoxedPredicate <T> >( startIndex, sectorSize, new BoxedPredicate <T>(match))); } catch (ArgumentOutOfRangeException) { throw; } }
/// <summary> /// Get the distance between a point and a quad /// </summary> /// <param name="point">The point from which the distance is calculated`</param> /// <param name="a">One of the quad's point. Is connected to b and d.</param> /// <param name="b">One of the quad's point. Is connected to a and c.</param> /// <param name="c">One of the quad's point. Is connected to b and d.</param> /// <param name="d">One of the quad's point. Is connected to c and a.</param> /// <returns></returns> public static float DistanceToQuad(Vector2 point, Vector2 a, Vector2 b, Vector2 c, Vector2 d) { s_QuadBuffer[0] = a; s_QuadBuffer[1] = b; s_QuadBuffer[2] = c; s_QuadBuffer[3] = d; var bounds = new Bounds2D(s_QuadBuffer); //Check if the point is inside the quad if (bounds.Contains(point)) { var firstEdgeDir = bounds.center - (Vector2)GetEdgeCenter(a, b); var rayStart = bounds.center + firstEdgeDir * (bounds.size.y + bounds.size.x + 2f); var collisions = 0; for (int i = 0, count = s_QuadBuffer.Length - 1; i < count; ++i) { var p1 = s_QuadBuffer[i]; var p2 = s_QuadBuffer[i + 1]; if (AreSegmentIntersecting(rayStart, point, p1, p2)) { ++collisions; } } if (collisions % 2 != 0) { return(0f); } } s_QuadDistanceBuffer[0] = DistanceToLine(point, a, b); s_QuadDistanceBuffer[1] = DistanceToLine(point, b, c); s_QuadDistanceBuffer[2] = DistanceToLine(point, c, d); s_QuadDistanceBuffer[3] = DistanceToLine(point, d, a); return(Mathf.Min(s_QuadDistanceBuffer)); }
public FlatShape4D(FillableShape2D shape, Matrix4D transform) { this.fillableShape2D_0 = shape; this.matrix4D_0 = transform; Bounds2D bounds = ShapeTool.GetBounds((IShape2D)shape); if (bounds.Initialized) { this.point2D_0 = new Point2D[4] { bounds.Corner1, new Point2D(bounds.Corner2.X, bounds.Corner1.Y), bounds.Corner2, new Point2D(bounds.Corner1.X, bounds.Corner2.Y) } } ; else { this.point2D_0 = (Point2D[])null; } }
public static void AddToBounds( Bounds2D bounds, ISegment2DIterator iterator, Matrix4D transformation) { if (!iterator.MoveNext()) { return; } Point2D[] points = new Point2D[3]; Point2D point2D = new Point2D(); do { switch (iterator.Current(points, 0)) { case SegmentType.MoveTo: case SegmentType.LineTo: point2D = transformation.Transform(points[0]); bounds.Update(point2D); break; case SegmentType.QuadTo: Point2D p1 = transformation.Transform(points[1]); ShapeTool.smethod_4(bounds, point2D, transformation.Transform(points[0]), p1); point2D = p1; bounds.Update(point2D); break; case SegmentType.CubicTo: Point2D p3 = transformation.Transform(points[2]); ShapeTool.smethod_5(bounds, point2D, transformation.Transform(points[0]), transformation.Transform(points[1]), p3); point2D = p3; bounds.Update(point2D); break; } }while (iterator.MoveNext()); }
public void BuildTree(int membersPerBranch = 2) { this.membersPerBranch = Mathf.Max(1, membersPerBranch); foreach (var item in inUse) { ReturnBranch(item); } inUse.Clear(); //find current bonds if (data.Count == 0) { return; } Bounds2D curBounds = data[0].bounds; float minX = curBounds.minX; float minY = curBounds.minY; float maxX = curBounds.maxX; float maxY = curBounds.maxY; for (int i = 1; i < data.Count; i++) { curBounds = data[i].bounds; minX = Mathf.Min(curBounds.minX, minX); minY = Mathf.Min(curBounds.minY, minY); maxX = Mathf.Max(curBounds.maxX, maxX); maxY = Mathf.Max(curBounds.maxY, maxY); } root = GetFreeBranch(); root.list.AddRange(data); root.bounds = new Bounds2D(minX, minY, maxX, maxY); root.depth = 0; BuildRecursive(root); }
public RenderableMesh GetRenderable(Bounds2D bounds) { RenderableMesh mesh; var result = _cache.TryGetValue(bounds, out mesh); if (result) { return mesh; } if (!_jobs.Contains(bounds)) { _jobs.Add(bounds); JobDispatcher.Instance.Enqueue(() => { var terrainChunk = _terrainChunkFactory.Create(bounds); var renderableMesh = _resourceAllocator.AllocateResourceFor(terrainChunk); _cache[bounds] = renderableMesh; _jobs.Remove(bounds); }); } return null; }
internal static ItemRequestResult <Index2D> FindIndexInternal < T, TRectCollection, TPredicate>( this TRectCollection source, Index2D startIndex, Bounds2D sectorSize, TPredicate match) where TRectCollection : IRectangularCollection <T> where TPredicate : struct, IPredicate <T> { for (int i = startIndex.Dimension1Index; i < sectorSize.Length1; i++) { for (int j = startIndex.Dimension2Index; j < sectorSize.Length2; j++) { var index = new Index2D(i, j); if (match.Invoke(source[index])) { return(new ItemRequestResult <Index2D>(index)); } } } return(ItemRequestResult <Index2D> .Fail); }
/// <summary> /// Makes sure that the <paramref name="objCenter"/> specified will allow the <paramref name="obj"/> to remain in the <paramref name="field"/>. /// Returns the original <paramref name="objCenter"/> if it is valid or a new location otherwise. /// </summary> /// <param name="objCenter">The location of the object's center</param> /// <param name="obj">The object's bounds</param> /// <param name="field">The bounding box to fit the object in</param> /// <returns>The location to move the object to</returns> public static Vector2 VerifyBounds(Vector2 objCenter, Bounds2D obj, Bounds2D field) { Vector2 maxOffset = field.Max - (objCenter + obj.Extents); Vector2 minOffset = field.Min - (objCenter - obj.Extents); if (minOffset.x > 0) { objCenter.x = field.XMin + obj.Extents.x; } else if (maxOffset.x < 0) { objCenter.x = field.XMax - obj.Extents.x; } if (minOffset.y > 0) { objCenter.y = field.YMin + obj.Extents.y; } else if (maxOffset.y < 0) { objCenter.y = field.YMax - obj.Extents.y; } return(objCenter); }
public override InsideTestResult TryIsInside(Bounds3D bounds) { if (!bounds.Initialized) { return(InsideTestResult.None); } Bounds2D bounds2D = new Bounds2D(); Point3D min = bounds.Min; Point3D max = bounds.Max; bounds2D.Update(this.matrix4D_1.TransformTo2D(min)); bounds2D.Update(this.matrix4D_1.TransformTo2D(new Point3D(min.X, min.Y, max.Z))); bounds2D.Update(this.matrix4D_1.TransformTo2D(new Point3D(min.X, max.X, min.Z))); bounds2D.Update(this.matrix4D_1.TransformTo2D(new Point3D(min.X, max.X, max.Z))); bounds2D.Update(this.matrix4D_1.TransformTo2D(new Point3D(max.X, min.X, min.Z))); bounds2D.Update(this.matrix4D_1.TransformTo2D(new Point3D(max.X, min.X, max.Z))); bounds2D.Update(this.matrix4D_1.TransformTo2D(new Point3D(max.X, max.X, min.Z))); bounds2D.Update(this.matrix4D_1.TransformTo2D(max)); if (bounds2D.Overlaps(this.class461_0.bounds2D_0)) { return(InsideTestResult.BothSides); } return(!this.class461_0.bool_0 ? InsideTestResult.Outside : InsideTestResult.Inside); }
public static Polygon2D[] smethod_9( Interface28 xInterval, Interface28 yInterval, Polygon2D[] outer, Polygon2D[] holes, bool right, double epsilon) { if (xInterval.IsUnbound || yInterval.IsUnbound) { Bounds2D bounds2D = new Bounds2D(); foreach (Polygon2D polygon2D in outer) { bounds2D.Update((IList <Point2D>)polygon2D); } if (!bounds2D.Initialized) { return((Polygon2D[])null); } if (xInterval.IsUnbound) { xInterval = (Interface28) new Class438(xInterval.HasUnboundStart ? bounds2D.Min.X : xInterval.Start, xInterval.HasUnboundEnd ? bounds2D.Max.X : xInterval.End, xInterval.PeriodicLength); } if (yInterval.IsUnbound) { yInterval = (Interface28) new Class438(yInterval.HasUnboundStart ? bounds2D.Min.Y : yInterval.Start, yInterval.HasUnboundEnd ? bounds2D.Max.Y : yInterval.End, yInterval.PeriodicLength); } } List <Polygon2D> polygon2DList = new List <Polygon2D>(); Polygon2D[] polygon2DArray1 = Class794.smethod_10(outer, right, true, xInterval, yInterval, epsilon); polygon2DList.AddRange((IEnumerable <Polygon2D>)polygon2DArray1); Polygon2D[] polygon2DArray2 = Class794.smethod_10(holes, right, false, xInterval, yInterval, epsilon); polygon2DList.AddRange((IEnumerable <Polygon2D>)polygon2DArray2); return(polygon2DList.ToArray()); }
private DxfLayout.BasicLayoutRenderInfo method_8() { Bounds2D bounds2D = new Bounds2D(); switch (this.PlotArea) { case PlotArea.LastScreenDisplay: if (this.LastActiveViewport is DxfVPort) { return(new DxfLayout.BasicLayoutRenderInfo(((DxfVPort)this.LastActiveViewport).ViewDescription)); } if (this.LastActiveViewport is DxfViewport) { return(new DxfLayout.BasicLayoutRenderInfo(((DxfViewport)this.LastActiveViewport).ViewDescription)); } return(new DxfLayout.BasicLayoutRenderInfo()); case PlotArea.SpecifiedByViewName: return(new DxfLayout.BasicLayoutRenderInfo(this.Model.Views[this.PlotViewName].ViewDescription)); default: return(new DxfLayout.BasicLayoutRenderInfo(this.GetPlotAreaBounds())); } }
public RenderableMesh GetRenderable(Bounds2D bounds) { RenderableMesh mesh; var result = _cache.TryGetValue(bounds, out mesh); if (result) { return(mesh); } if (!_jobs.Contains(bounds)) { _jobs.Add(bounds); JobDispatcher.Instance.Enqueue(() => { var terrainChunk = _terrainChunkFactory.Create(bounds); var renderableMesh = _resourceAllocator.AllocateResourceFor(terrainChunk); _cache[bounds] = renderableMesh; _jobs.Remove(bounds); }); } return(null); }
public bool isVerticalOverlap(Bounds2D other) { return !(y > other.y + other.height || other.y > y + height); }
public bool overlaps(Bounds2D other) { return isHorizontalOverlap(other) && isVerticalOverlap(other); }
private ChunkedLodTreeNode CreateChunkedLodTreeNode(Bounds2D first, ChunkedLodTreeNode parent, int nextDepth, double geometricError) { var chunkedLodTreeNode = new ChunkedLodTreeNode(first, parent, geometricError); chunkedLodTreeNode.SetNodes(GetLeafs(first, chunkedLodTreeNode, nextDepth)); return chunkedLodTreeNode; }
public ChunkedLodTreeNode Create(Bounds2D bounds, int depth) { return CreateChunkedLodTreeNode(bounds, null, depth, CalculateGeometricError(depth)); }
public ImplicitChunkHeightMap(Bounds2D bounds, int columns, int rows, INoiseGenerator noiseGenerator) { _noiseGenerator = noiseGenerator; _rows = rows; _columns = columns; _bounds = bounds; var origin = CalculatePosition(0, 0); var position = CalculatePosition(1, 1); _dx = 1 / (position.X - origin.X); _dy = 1 / (position.Y - origin.Y); }
protected void MakeBounds() { Bounds2D actualBounds = new Bounds2D(collider2D); Vector3 max = actualBounds.GetMax(); Vector3 min = actualBounds.GetMin(); Vector3 maxY = new Vector3(min.x, max.y, min.z); Vector3 maxX = new Vector3(max.x, min.y, min.z); if (bounds == null) { bounds = new LineRenderer[4]; } bounds[0] = MakeOutline(min, maxY, bounds[0]); bounds[1] = MakeOutline(maxY, max, bounds[1]); bounds[2] = MakeOutline(min, maxX, bounds[2]); bounds[3] = MakeOutline(maxX, max, bounds[3]); }
private static Color[] getBitArray(Bounds2D section, Texture2D texture) { return texture.GetPixels(section.x, section.y, section.width,section.height); }
public bool isHorizontalOverlap(Bounds2D other) { return !(x > other.x + other.width || other.x > x + width); }
public void imethod_0(ref Vector2D baselinePos, double height, Enum24 whiteSpaceHandlingFlags) { LinkedList <Class427> linkedList = new LinkedList <Class427>(); this.vector2D_0 = baselinePos; baselinePos += new Vector2D(0.0, -this.class1024_0.BeforeSpace); double paragraphWidth = this.class1024_0.ParagraphWidth; bool flag1; double width = (flag1 = paragraphWidth > 0.0) ? paragraphWidth - this.class1024_0.RightIndent + this.vector2D_0.X : 0.0; bool flag2 = true; using (LinkedList <Class427> .Enumerator enumerator = this.linkedList_0.GetEnumerator()) { label_13: if (enumerator.MoveNext()) { Class427 class427_1 = enumerator.Current; do { double x = this.vector2D_0.X + this.class1024_0.LeftIndent; if (flag2) { goto label_11; } label_3: Vector2D baselinePos1 = new Vector2D(x, baselinePos.Y); Vector2D vector2D = baselinePos1; class427_1.imethod_0(ref baselinePos1, height, whiteSpaceHandlingFlags); Bounds2D bounds = class427_1.GetBounds(whiteSpaceHandlingFlags, (Class985)null); if (flag1 && bounds.Delta.X > width - x) { Interface24[] nterface24Array = class427_1.imethod_1(width, this.TextBreaker); switch (nterface24Array.Length) { case 0: linkedList.AddLast(class427_1); class427_1 = (Class427)null; break; case 1: linkedList.AddLast(class427_1); class427_1 = (Class427)null; break; case 2: baselinePos1 = vector2D; Class427 class427_2 = (Class427)nterface24Array[0]; class427_2.imethod_0(ref baselinePos1, height, whiteSpaceHandlingFlags); linkedList.AddLast(class427_2); class427_1 = (Class427)nterface24Array[1]; break; default: linkedList.AddLast(class427_1); class427_1 = (Class427)null; break; } } else { linkedList.AddLast(class427_1); class427_1 = (Class427)null; } baselinePos += baselinePos1 - vector2D; continue; label_11: flag2 = false; x += this.class1024_0.LeftIndentFirst; goto label_3; }while (class427_1 != null); goto label_13; } } if (linkedList.Count > this.linkedList_0.Count) { this.linkedList_0 = linkedList; } bool flag3 = true; foreach (Class427 class427 in this.linkedList_0) { double num = this.vector2D_0.X + this.class1024_0.LeftIndent; if (flag3) { flag3 = false; num += this.class1024_0.LeftIndentFirst; } Bounds2D bounds = class427.GetBounds(Enum24.flag_1, (Class985)null); switch (this.class1024_0.Alignment) { case Class1023.Enum45.const_0: class427.method_1(0.5 * (width + num) - bounds.Center.X); continue; case Class1023.Enum45.const_1: class427.method_1(num - bounds.Corner1.X); continue; case Class1023.Enum45.const_2: class427.method_1(width - bounds.Corner2.X); continue; default: continue; } } baselinePos += new Vector2D(0.0, -this.class1024_0.AfterSpace); }
public Mesh3V3N Create(Bounds2D bounds) { var meshDimensions = 128; var implicintHeightMap = new ImplicitChunkHeightMap(bounds, meshDimensions, meshDimensions, new ScaledNoiseGenerator()); return MeshCreator.CreateFromHeightMap(meshDimensions, meshDimensions, implicintHeightMap); }