/// <summary> /// Clips the bounds of an image tile to the specified display location and clipping region. /// </summary> /// <param name="dest"><para> /// On input, the location within the entire <see cref="MapView"/> where the upper-left /// corner of an image tile should appear. /// </para><para> /// On output, the location within and relative to the specified <paramref name="region"/> /// where the upper-left corner of the returned image tile portion should be drawn. /// </para></param> /// <param name="region"><para> /// On input, the display region within the entire <see cref="MapView"/> to which drawing is /// clipped. /// </para><para> /// On output, the portion of the image tile that should be drawn at the adjusted <paramref /// name="dest"/> location when returning <c>true</c>; otherwise, unchanged.</para></param> /// <returns> /// <c>true</c> if <paramref name="region"/> contains the portion of the image tile to draw; /// <c>false</c> if nothing should be drawn.</returns> /// <remarks> /// The specified <paramref name="region"/> should indicate the portion of the entire <see /// cref="MapView"/> that is covered by the current contents of the paint buffer.</remarks> private bool ClipTile(ref PointI dest, ref RectI region) { // shift destination to clipping region dest -= region.Location; /* * We draw at most the area of one image tile. If the destination * is negative, we actually draw only the lower and/or right part * of an image tile, and reduce the returned bounds accordingly. */ // negative offset to clipping region PointI neg = new PointI(Math.Max(0, -dest.X), Math.Max(0, -dest.Y)); // reduce destination to positive offset dest = new PointI(Math.Max(0, dest.X), Math.Max(0, dest.Y)); // clip image tile to destination and clipping region int width = Math.Min(MapView.TileWidth - neg.X, region.Width - dest.X); int height = Math.Min(MapView.TileHeight - neg.Y, region.Height - dest.Y); // check if there is anything to draw if (width <= 0 || height <= 0) { return(false); } region = new RectI(neg.X, neg.Y, width, height); return(true); }
/// <summary> /// Overlays pixel data from another <see cref="BitmapBuffer"/>, with alpha blending. /// </summary> /// <param name="x"> /// The x-coordinate where to begin writing in this <see cref="BitmapBuffer"/>.</param> /// <param name="y"> /// The y-coordinate where to begin writing in this <see cref="BitmapBuffer"/>.</param> /// <param name="source"> /// Another <see cref="BitmapBuffer"/> containing the rectangle to overlay.</param> /// <param name="bounds"> /// The pixel rectangle within the specified <paramref name="source"/> to overlay.</param> /// <param name="color"> /// The <see cref="Color"/> to substitute for all <paramref name="source"/> pixels.</param> /// <exception cref="ArgumentNullException"> /// <paramref name="source"/> is a null reference.</exception> /// <remarks><para> /// <b>Overlay</b> blends all <see cref="Pixels"/> elements within the specified <paramref /// name="bounds"/> of the specified <paramref name="source"/> buffer with the corresponding /// <see cref="Pixels"/> elements in this <see cref="BitmapBuffer"/>, starting with the /// specified <paramref name="x"/> and <paramref name="y"/> coordinates. /// </para><para> /// <b>Overlay</b> calls <see cref="BitmapUtility.BlendPbgra32"/> to perform alpha blending /// between the specified <paramref name="source"/> buffer (acting as the overlay) and this /// <see cref="BitmapBuffer"/> (acting as the blending target). No coordinate checking is /// performed. /// </para><para> /// <b>Overlay</b> substitutes the specified <paramref name="color"/> for the actual color /// channels of each <paramref name="source"/> pixel, while using its alpha channel to /// govern alpha blending with the corresponding <see cref="Pixels"/> element. The alpha /// channel of the specified <paramref name="color"/> is ignored.</para></remarks> public void Overlay(int x, int y, BitmapBuffer source, RectI bounds, Color color) { if (source == null) { ThrowHelper.ThrowArgumentNullException("source"); } int sourceOffset = bounds.X + source._size.Width * bounds.Y; int targetOffset = x + _size.Width * y; for (int dy = 0; dy < bounds.Height; dy++) { for (int dx = 0; dx < bounds.Width; dx++) { uint p0 = source._pixels[sourceOffset + dx]; uint p1 = _pixels[targetOffset + dx]; // multiply color channels with source alpha color.A = (byte)(p0 >> 24); p0 = BitmapUtility.ColorToPbgra32(color); _pixels[targetOffset + dx] = BitmapUtility.BlendPbgra32(p0, p1); } sourceOffset += source._size.Width; targetOffset += _size.Width; } }
public void Del(RectI rect) { foreach (Vector2Int position in rect) { this.positions.Remove(position); } }
/// <summary> /// Presents the contents of the next buffer in the sequence of back buffers to the screen. /// </summary> /// <param name="presentFlags">The present flags.</param> /// <param name="sourceRectangle">The area of the back buffer that should be presented.</param> /// <param name="destinationRectangle">The area of the front buffer that should receive the result of the presentation.</param> /// <param name="windowOverride">The destination window whose client area is taken as the target for this presentation.</param> /// <unmanaged>HRESULT IDirect3DSwapChain9::Present([In, Optional] const void* pSourceRect,[InOut, Optional] const void* pDestRect,[In] HWND hDestWindowOverride,[In] const RGNDATA* pDirtyRegion,[In] unsigned int dwFlags)</unmanaged> public void Present(RectI sourceRectangle, RectI destinationRectangle, IntPtr windowOverride, Present presentFlags) { RawRect sourceRect = sourceRectangle; RawRect destRect = destinationRectangle; Present(&sourceRect, &destRect, windowOverride, null, (int)presentFlags); }
public RectI(RectI clone) { _x = clone.X; _y = clone.Y; _width = clone.Width; _height = clone.Height; }
protected Map(int rows, int columns) { _cells = new Cell[rows, columns]; Bounds = new RectI(0, 0, columns, rows); Rows = rows; Columns = columns; }
public RectI(RectI rect) : this(IronSightEnginePINVOKE.new_RectI__SWIG_2(RectI.getCPtr(rect)), true) { if (IronSightEnginePINVOKE.SWIGPendingException.Pending) { throw IronSightEnginePINVOKE.SWIGPendingException.Retrieve(); } }
public Room Generate(Random random, Area area) { if (_roomCount >= MaxRooms) { return(null); } // Don't place the room on the area's edge. // This will keep rooms from being adjacent to each other. var placeableBounds = area.Bounds.Inflate(-1); var width = random.Next(MinWidth, placeableBounds.Width + 1); var height = random.Next(MinHeight, placeableBounds.Height + 1); // Find a place in the area to put the room. while (true) { var x = random.Next(placeableBounds.Left, placeableBounds.Right - width + 1 + 1); var y = random.Next(placeableBounds.Top, placeableBounds.Bottom - height + 1 + 1); var roomBounds = new RectI(x, y, width, height); if (placeableBounds.Contains(roomBounds)) { _roomCount++; return(new Room(random, roomBounds)); } } }
/// <summary> /// Handles the face frame data arriving from the sensor /// </summary> /// <param name="sender">object sending the event</param> /// <param name="e">event arguments</param> private void Reader_FaceFrameArrived(object sender, FaceFrameArrivedEventArgs e) { using (FaceFrame faceFrame = e.FrameReference.AcquireFrame()) { if (faceFrame != null) { // get the index of the face source from the face source array int index = this.GetFaceSourceIndex(faceFrame.FaceFrameSource); // check if this face frame has valid face frame results if (this.ValidateFaceBoxAndPoints(faceFrame.FaceFrameResult)) { // store this face frame result to draw later this.faceFrameResults[index] = faceFrame.FaceFrameResult; RectI oldFace = faceFrame.FaceFrameResult.FaceBoundingBoxInColorSpace; FaceRectangle newface = new FaceRectangle(); newface.Left = oldFace.Left; newface.Top = oldFace.Top; newface.Height = (oldFace.Top - oldFace.Bottom); newface.Width = (oldFace.Left - oldFace.Right); DrawRect(newface); } else { // indicates that the latest face frame result from this reader is invalid this.faceFrameResults[index] = null; } } } }
void DrawFaceFrameResult(int faceIndex, FaceFrameResult faceResult, DrawingContext drawingContext) { //Brush/Pen Brush drawingBrush = faceBrush[0]; if (faceIndex < bodyCount) { drawingBrush = faceBrush[faceIndex]; } Pen drawingPen = new Pen(drawingBrush, 5); //Face Points var facePoints = faceResult.FacePointsInColorSpace; foreach (PointF pointF in facePoints.Values) { Point points = new Point(pointF.X, pointF.Y); RectI box = faceResult.FaceBoundingBoxInColorSpace; Target.Width = box.Right - box.Left; Target.Height = box.Bottom - box.Top; Canvas.SetLeft(Target, (points.X / 4) - Target.Width / 2); Canvas.SetTop(Target, points.Y / 4 - Target.Height / 2); } }
protected override void OnPaint(PaintEventArgs e) { Graphics graphics = e.Graphics; // Draw AdditionLogos before foreground render if (!Canvas.ShouldDrawBackground) { DrawAdditionLogos(graphics); } // m_FPSCounter.Tick(); if (m_IntervalTimer.IsTimeOver) { m_ExamplesHolder.FPS = FPS; } base.OnPaint(e); // Need to process system redraw needs (like window overlapping etc.) if (Size != SizeI.Empty) { // Draw Main Logo Bitmap logo = GUI.Config.Logo; RectI logoRect = m_ExamplesHolder.LogoArea; PointI logoPos = new PointI(logoRect.Right - logo.PixelWidth - 10, logoRect.Top + 15); graphics.DrawImage(logo, logoPos); } }
public void DrawRectangle(RectI area, ref TilePicker tile) { // Use refs for faster access (really important!) speeds up a lot! int w = _world.Header.WorldBounds.W; int h = _world.Header.WorldBounds.H; // Check boundaries area.Rebound(_world.Header.WorldBounds); // (needed for refs) int x1 = area.Left; int x2 = area.Right; int y1 = area.Top; int y2 = area.Bottom; // top and bottom horizontal scanlines for (int x = area.Left; x <= area.Right; x++) { UpdateTile(ref tile, ref x, ref y1, ref w); UpdateTile(ref tile, ref x, ref y2, ref w); } for (int y = area.Top; y <= area.Bottom; y++) { UpdateTile(ref tile, ref x1, ref y, ref w); UpdateTile(ref tile, ref x2, ref y, ref w); } }
//---------------------------------------------------------------------------- //template<class T> public static bool ClipMovePoint(int x1, int y1, int x2, int y2, RectI clip_box, ref int x, ref int y, uint flags) { int bound; if ((flags & (uint)ClippingFlags.xClipped) != 0) { if (x1 == x2) { return(false); } bound = ((flags & (uint)ClippingFlags.x1Clipped) != 0) ? clip_box.x1 : clip_box.x2; y = (int)((double)(bound - x1) * (y2 - y1) / (x2 - x1) + y1); x = bound; } flags = ClippingFlagsY(y, clip_box); if ((flags & (uint)ClippingFlags.yClipped) != 0) { if (y1 == y2) { return(false); } bound = ((flags & (uint)ClippingFlags.x1Clipped) != 0) ? clip_box.y1 : clip_box.y2; x = (int)((double)(bound - y1) * (x2 - x1) / (y2 - y1) + x1); y = bound; } return(true); }
/// <summary> /// Overlays pixel data from another <see cref="BitmapBuffer"/>, with the specified alpha /// channel threshold.</summary> /// <param name="x"> /// The x-coordinate where to begin writing in this <see cref="BitmapBuffer"/>.</param> /// <param name="y"> /// The y-coordinate where to begin writing in this <see cref="BitmapBuffer"/>.</param> /// <param name="source"> /// Another <see cref="BitmapBuffer"/> containing the rectangle to overlay.</param> /// <param name="bounds"> /// The pixel rectangle within the specified <paramref name="source"/> to overlay.</param> /// <param name="alpha"> /// The alpha channel threshold below which <paramref name="source"/> pixels will be /// ignored.</param> /// <exception cref="ArgumentNullException"> /// <paramref name="source"/> is a null reference.</exception> /// <remarks><para> /// <b>Overlay</b> copies only those <see cref="Pixels"/> elements within the specified /// <paramref name="bounds"/> of the specified <paramref name="source"/> buffer whose alpha /// channel meets or exceeds the specified <paramref name="alpha"/> threshold. /// </para><para> /// The copies are written to the <see cref="Pixels"/> array of this <see /// cref="BitmapBuffer"/>, starting with the specified <paramref name="x"/> and <paramref /// name="y"/> coordinates. No alpha blending or coordinate checking is performed. /// </para></remarks> public void Overlay(int x, int y, BitmapBuffer source, RectI bounds, byte alpha) { if (source == null) { ThrowHelper.ThrowArgumentNullException("source"); } int sourceOffset = bounds.X + source._size.Width * bounds.Y; int targetOffset = x + _size.Width * y; for (int dy = 0; dy < bounds.Height; dy++) { for (int dx = 0; dx < bounds.Width; dx++) { uint value = source._pixels[sourceOffset + dx]; if ((value >> 24) >= alpha) { _pixels[targetOffset + dx] = value; } } sourceOffset += source._size.Width; targetOffset += _size.Width; } }
public void Add(RectI rect) { foreach (Vector2Int position in rect) { this.AddTilable(position); } }
/// <summary> /// Indicates whether the two specified <see cref="ImageFrame"/> objects define identical /// bitmap tiles.</summary> /// <param name="firstFrame"> /// The first <see cref="ImageFrame"/> to compare.</param> /// <param name="secondFrame"> /// The second <see cref="ImageFrame"/> to compare.</param> /// <returns> /// <c>true</c> if all pixels in the specified <paramref name="firstFrame"/> contain the /// same <see cref="Color"/> values as the corresponding pixels in the specified <paramref /// name="secondFrame"/>; otherwise, <c>false</c>.</returns> private static bool AreTilesEqual(ImageFrame firstFrame, ImageFrame secondFrame) { WriteableBitmap bitmap1 = firstFrame.Source.Value.Bitmap; WriteableBitmap bitmap2 = secondFrame.Source.Value.Bitmap; RectI bounds1 = firstFrame.Bounds, bounds2 = secondFrame.Bounds; if (bounds1.Size != bounds2.Size) { return(false); } for (int x = 0; x < bounds1.Width; x++) { for (int y = 0; y < bounds1.Height; y++) { if (bitmap1.GetPixel(x + bounds1.X, y + bounds1.Y) != bitmap2.GetPixel(x + bounds2.X, y + bounds2.Y)) { return(false); } } } return(true); }
public void CopyPixels(RectI rectangle, int stride, byte[] data) { fixed(byte *dataPtr = &data[0]) { CopyPixels(&rectangle, stride, data.Length, dataPtr); } }
public void CopyPixels <T>(RectI rectangle, int stride, Span <T> data) where T : unmanaged { fixed(T *dataPtr = data) { CopyPixels(&rectangle, stride, data.Length * sizeof(T), dataPtr); } }
/// <summary> /// The show zoom rectangle. /// </summary> /// <param name="r"> /// The r. /// </param> public void ShowZoomRectangle(OxyRect r) { this.zoomRectangle = new RectI((int)r.Left, (int)r.Top, (int)r.Width, (int)r.Height); //this.Invalidate(); Refresh(); }
/// <summary> /// The hide zoom rectangle. /// </summary> public void HideZoomRectangle() { this.zoomRectangle = RectI.Empty; //this.Invalidate(); Refresh(); }
//----------------------------------------------------------GetClippingFlags // Determine the clipping code of the Vertex according to the // Cyrus-Beck Line clipping algorithm // // | | // 0110 | 0010 | 0011 // | | // -------+--------+-------- ClipBox.y2 // | | // 0100 | 0000 | 0001 // | | // -------+--------+-------- ClipBox.y1 // | | // 1100 | 1000 | 1001 // | | // ClipBox.x1 ClipBox.x2 // // //template<class T> public static uint GetClippingFlags(int x, int y, RectI clip_box) { return((uint)(((x > clip_box.x2) ? 1 : 0) | ((y > clip_box.y2) ? 1 << 1 : 0) | ((x < clip_box.x1) ? 1 << 2 : 0) | ((y < clip_box.y1) ? 1 << 3 : 0))); }
private void M_FaceReader_FrameArrived(object sender, Microsoft.Kinect.Face.FaceFrameArrivedEventArgs e) { var frameRef = e.FrameReference; using (var faceFrame = frameRef.AcquireFrame()) { if (faceFrame != null) { //get the Color Region if (faceFrame.FaceFrameResult != null) { m_drawingRegion = faceFrame.FaceFrameResult.FaceBoundingBoxInColorSpace; var faceRegion = new RectI(); faceRegion.Top = Math.Abs(m_drawingRegion.Top - 36); faceRegion.Bottom = Math.Abs(m_drawingRegion.Bottom - 12); faceRegion.Left = Math.Abs(m_drawingRegion.Left + 26); faceRegion.Right = Math.Abs(m_drawingRegion.Right - 20); DrawBox(faceRegion); //Take the new region and record ColorFrame Data if (m_timerStarted) { RecordData(faceRegion, faceFrame); lblColorFeeds.Text = "Please be still taking measurements..."; } else { lblColorFeeds.Text = "Face Found, Click the Calculate button to start taking measurements..."; btnCalculateRate.IsEnabled = true; } } } } }
public bool Contains(RectI rect) { return (Contains(rect.TopLeft) && Contains(rect.TopRight) && Contains(rect.BottomLeft) && Contains(rect.BottomRight)); }
private bool Contains(RectI bounds, Vector2I roomLocation, Room room) { return (bounds.Contains(roomLocation.X, roomLocation.Y) && bounds.Contains(roomLocation.X + room.Columns - 1, roomLocation.Y) && bounds.Contains(roomLocation.X + room.Columns - 1, roomLocation.Y + room.Rows - 1) && bounds.Contains(roomLocation.X, roomLocation.Y + room.Rows - 1)); }
/// <summary> /// Draws the specified <see cref="CatalogManager.Catalog"/> tile to the <see /// cref="PaintBuffer"/>, with alpha blending and color substitution.</summary> /// <param name="dest"> /// The location within the <see cref="PaintBuffer"/> where to draw.</param> /// <param name="region"> /// The bitmap region within the <see cref="CatalogManager.Catalog"/> to copy, relative to /// the tile with the specified <paramref name="index"/>.</param> /// <param name="index"> /// The <see cref="CatalogManager.Catalog"/> index of the tile to draw.</param> /// <param name="color"> /// The <see cref="Color"/> whose color channels are substituted for those of all <see /// cref="CatalogManager.Catalog"/> pixels, retaining only their alpha channel.</param> private void DrawTile(PointI dest, RectI region, int index, Color color) { // add upper-left corner of catalog tile region = region.Offset(MapView.GetTileLocation(index)); // copy visible part of catalog tile to buffer PaintBuffer.Overlay(dest.X, dest.Y, MapView.Catalog, region, color); }
//-------------------------------------------------------ClipLineSegment // Returns: ret >= 4 - Fully clipped // (ret & 1) != 0 - First point has been moved // (ret & 2) != 0 - Second point has been moved // //template<class T> public static uint ClipLineSegment(ref int x1, ref int y1, ref int x2, ref int y2, RectI clip_box) { uint f1 = GetClippingFlags(x1, y1, clip_box); uint f2 = GetClippingFlags(x2, y2, clip_box); uint ret = 0; if ((f2 | f1) == 0) { // Fully visible return(0); } if ((f1 & (uint)ClippingFlags.xClipped) != 0 && (f1 & (uint)ClippingFlags.xClipped) == (f2 & (uint)ClippingFlags.xClipped)) { // Fully clipped return(4); } if ((f1 & (uint)ClippingFlags.yClipped) != 0 && (f1 & (uint)ClippingFlags.yClipped) == (f2 & (uint)ClippingFlags.yClipped)) { // Fully clipped return(4); } int tx1 = x1; int ty1 = y1; int tx2 = x2; int ty2 = y2; if (f1 != 0) { if (!ClipMovePoint(tx1, ty1, tx2, ty2, clip_box, ref x1, ref y1, f1)) { return(4); } if (x1 == x2 && y1 == y2) { return(4); } ret |= 1; } if (f2 != 0) { if (!ClipMovePoint(tx1, ty1, tx2, ty2, clip_box, ref x2, ref y2, f2)) { return(4); } if (x1 == x2 && y1 == y2) { return(4); } ret |= 2; } return(ret); }
/// <summary> /// Draws all decoration except arrows on all map sites in the specified region.</summary> /// <param name="context"> /// The <see cref="DrawingContext"/> for the drawing.</param> /// <param name="siteRegion"> /// The map region containing the coordinates of every <see cref="Site"/> to decorate. /// </param> /// <remarks> /// <b>DrawDecoration</b> draws grid outlines, selection highlights, owner shading, unit /// flags, resource gauges, and variable values on every <see cref="Site"/> within the /// specified <paramref name="siteRegion"/>, as appropriate.</remarks> private void DrawDecoration(DrawingContext context, RectI siteRegion) { var sites = MapView.WorldState.Sites; var geometry = MapView.ElementGeometry; // traverse all specified sites for (int x = siteRegion.Left; x < siteRegion.Right; x++) { for (int y = siteRegion.Top; y < siteRegion.Bottom; y++) { Site site = sites[x, y]; // shift origin to center of current site PointD pixel = MapView.SiteToView(site.Location); context.PushTransform(new TranslateTransform(pixel.X, pixel.Y)); // brighten polygon in selected region if (MapView.SelectedRegion != null && MapView.SelectedRegion[x, y]) { context.DrawGeometry(MediaObjects.ShadeLightBrush, null, geometry); } // tint polygon with owner color if (MapView.ShowOwner) { Color color = (site.Owner == null ? Colors.Black : site.Owner.Color); context.DrawGeometry(MediaObjects.GetShadeBrush(color), null, geometry); } // draw unit flag near unit stack if (MapView.ShowFlags) { UnitDecorator.DrawFlag(context, site); } // draw resource gauge below unit stack if (MapView.GaugeResource != null) { UnitDecorator.DrawGauge(context, site); } // draw variable values as numbers or shades if (MapView.ShownVariable != null && MapView.ShownVariableFlags != 0) { VariableDrawer.Draw(context, site); } // reset transformation matrix context.Pop(); } } // draw polygon outlines for entire grid if (!this._bitmapGrid && MapView.ShowGrid) { context.DrawGeometry(null, MediaObjects.ThickPen, MapView.GridGeometry); } }
public RectI Union(RectI other) { int minX = (MinX < other.MinX) ? MinX : other.MinX, minY = (MinY < other.MinY) ? MinY : other.MinY, maxX = (MaxX < other.MaxX) ? MaxX : other.MaxX, maxY = (MaxY < other.MaxY) ? MaxY : other.MaxY; return(new RectI(minX, minY, maxX - minX + 1, maxY - minY + 1)); }
/// <summary> /// Copies the specified region from memory into the current bitmap. /// </summary> /// <param name="destinationRect">In the current bitmap, the rectangle to which the region specified by srcRect is copied.</param> /// <param name="data">The data to copy.</param> /// <param name="pitch">The stride, or pitch, of the source bitmap stored in srcData. The stride is the byte count of a scanline (one row of pixels in memory).</param> /// <returns>The result of the operation.</returns> public Result CopyFromMemory(RectI destinationRect, byte[] data, int pitch) { RawRect dstRect = destinationRect; fixed(byte *dataPtr = data) { return(CopyFromMemory(&dstRect, dataPtr, pitch)); } }
public void Fill(RectI bounds, Tile tile) { for (var row = bounds.Top; row <= bounds.Bottom; row++) { for (var column = bounds.Left; column <= bounds.Right; column++) { this[row, column] = tile; } } }
//-------------------------------------------------------ClipLiangbarsky //template<class T> public static uint ClipLiangbarsky(int x1, int y1, int x2, int y2, RectI clip_box, int[] x, int[] y) { uint XIndex = 0; uint YIndex = 0; double nearzero = 1e-30; double deltax = x2 - x1; double deltay = y2 - y1; double xin; double xout; double yin; double yout; double tinx; double tiny; double toutx; double touty; double tin1; double tin2; double tout1; uint np = 0; if(deltax == 0.0) { // bump off of the vertical deltax = (x1 > clip_box.x1) ? -nearzero : nearzero; } if(deltay == 0.0) { // bump off of the horizontal deltay = (y1 > clip_box.y1) ? -nearzero : nearzero; } if(deltax > 0.0) { // points to right xin = clip_box.x1; xout = clip_box.x2; } else { xin = clip_box.x2; xout = clip_box.x1; } if(deltay > 0.0) { // points up yin = clip_box.y1; yout = clip_box.y2; } else { yin = clip_box.y2; yout = clip_box.y1; } tinx = (xin - x1) / deltax; tiny = (yin - y1) / deltay; if (tinx < tiny) { // hits x first tin1 = tinx; tin2 = tiny; } else { // hits y first tin1 = tiny; tin2 = tinx; } if(tin1 <= 1.0) { if(0.0 < tin1) { x[XIndex++] = (int)xin; y[YIndex++] = (int)yin; ++np; } if(tin2 <= 1.0) { toutx = (xout - x1) / deltax; touty = (yout - y1) / deltay; tout1 = (toutx < touty) ? toutx : touty; if(tin2 > 0.0 || tout1 > 0.0) { if(tin2 <= tout1) { if(tin2 > 0.0) { if(tinx > tiny) { x[XIndex++] = (int)xin; y[YIndex++] = (int)(y1 + tinx * deltay); } else { x[XIndex++] = (int)(x1 + tiny * deltax); y[YIndex++] = (int)yin; } ++np; } if(tout1 < 1.0) { if(toutx < touty) { x[XIndex++] = (int)xout; y[YIndex++] = (int)(y1 + toutx * deltay); } else { x[XIndex++] = (int)(x1 + touty * deltax); y[YIndex++] = (int)yout; } } else { x[XIndex++] = x2; y[YIndex++] = y2; } ++np; } else { if(tinx > tiny) { x[XIndex++] = (int)xin; y[YIndex++] = (int)yout; } else { x[XIndex++] = (int)xout; y[YIndex++] = (int)yin; } ++np; } } } } return np; }
//----------------------------------------------------------GetClippingFlags // Determine the clipping code of the Vertex according to the // Cyrus-Beck Line clipping algorithm // // | | // 0110 | 0010 | 0011 // | | // -------+--------+-------- ClipBox.y2 // | | // 0100 | 0000 | 0001 // | | // -------+--------+-------- ClipBox.y1 // | | // 1100 | 1000 | 1001 // | | // ClipBox.x1 ClipBox.x2 // // //template<class T> public static uint GetClippingFlags(int x, int y, RectI clip_box) { return (uint)(((x > clip_box.x2) ? 1 : 0) | ((y > clip_box.y2) ? 1 << 1 : 0) | ((x < clip_box.x1) ? 1 << 2 : 0) | ((y < clip_box.y1) ? 1 << 3 : 0)); }
//--------------------------------------------------------ClippingFlagsY //template<class T> public static uint ClippingFlagsY(int y, RectI clip_box) { return (uint)(((y > clip_box.y2 ? 1 : 0) << 1) | ((y < clip_box.y1 ? 1 : 0) << 3)); }
public override void Attach(IPixelFormat ren) { base.Attach(ren); m_clip_box = new RectI(0, 0, (int)ren.Width - 1, (int)ren.Height - 1); }
public void CopyFrom(RasterBuffer src, RectI rect_src_ptr, int dx, int dy) { RectI rsrc = new RectI(rect_src_ptr.x1, rect_src_ptr.y1, rect_src_ptr.x2 + 1, rect_src_ptr.y2 + 1); // Version with xdst, ydst (absolute positioning) //RectI rdst(xdst, ydst, xdst + rsrc.x2 - rsrc.x1, ydst + rsrc.y2 - rsrc.y1); // Version with dx, dy (relative positioning) RectI rdst = new RectI(rsrc.x1 + dx, rsrc.y1 + dy, rsrc.x2 + dx, rsrc.y2 + dy); RectI rc = ClipRectangleArea(ref rdst, ref rsrc, (int)src.Width(), (int)src.Height()); if (rc.x2 > 0) { int incy = 1; if (rdst.y1 > rsrc.y1) { rsrc.y1 += rc.y2 - 1; rdst.y1 += rc.y2 - 1; incy = -1; } while (rc.y2 > 0) { base.CopyFrom(src, rdst.x1, rdst.y1, rsrc.x1, rsrc.y1, (uint)rc.x2); rdst.y1 += incy; rsrc.y1 += incy; --rc.y2; } } }
/// <summary> /// Create a new rectangle, inflated by <paramref name="x"/> and <paramref name="y"/>. /// </summary> public RectI Inflate(int x, int y) { var newRect = new RectI(this); newRect.Left -= x; newRect.Right += x; newRect.Top -= y; newRect.Bottom += y; return newRect; }
/// <summary> /// Determine whether this rectangle intersects the given rectangle. /// </summary> /// <param name="other">The rectangle to test.</param> /// <returns>True if this rectangle intersects the given rectangle.</returns> public bool Intersects(RectI other) { return !(this.Y <= other.Bottom || this.X >= other.Right || this.Bottom >= other.Y || this.Right <= other.X); }
/// <summary> /// Determine whether this rectangle contains the given rectangle. /// </summary> /// <param name="other">The rectangle to test.</param> /// <returns>True if this rectangle contains the given rectangle.</returns> public bool Contains(RectI other) { return this.Y >= other.Y && this.X <= other.X && this.Bottom <= other.Bottom && this.Right >= other.Right; }
public bool Contains(RectI rect) { return Contains(rect.TopLeft) && Contains(rect.TopRight) && Contains(rect.BottomLeft) && Contains(rect.BottomRight); }
public void AddObjectToMotionMap( MapObject obj ) { if( !initialized ) return; OnGetMotionMapRectanglesForObject( obj, tempRectangles ); if( tempRectangles.Count != 0 ) { RectI[] rectangles = new RectI[ tempRectangles.Count ]; for( int nRectangle = 0; nRectangle < tempRectangles.Count; nRectangle++ ) { Rect rectangle = tempRectangles[ nRectangle ]; RectI mapMotionRectangle = GetMapMotionRectangle( rectangle ); for( int y = mapMotionRectangle.Top; y <= mapMotionRectangle.Bottom; y++ ) for( int x = mapMotionRectangle.Left; x <= mapMotionRectangle.Right; x++ ) mapMotion[ x, y ]++; rectangles[ nRectangle ] = mapMotionRectangle; } mapMotionRectangles.Add( obj, rectangles ); tempRectangles.Clear(); } }
//-------------------------------------------------------------------- public FormatClippingProxy(IPixelFormat ren) : base(ren) { m_clip_box = new RectI(0, 0, (int)ren.Width - 1, (int)ren.Height - 1); }
//-------------------------------------------------------ClipLineSegment // Returns: ret >= 4 - Fully clipped // (ret & 1) != 0 - First point has been moved // (ret & 2) != 0 - Second point has been moved // //template<class T> public static uint ClipLineSegment(ref int x1, ref int y1, ref int x2, ref int y2, RectI clip_box) { uint f1 = GetClippingFlags(x1, y1, clip_box); uint f2 = GetClippingFlags(x2, y2, clip_box); uint ret = 0; if((f2 | f1) == 0) { // Fully visible return 0; } if ((f1 & (uint)ClippingFlags.xClipped) != 0 && (f1 & (uint)ClippingFlags.xClipped) == (f2 & (uint)ClippingFlags.xClipped)) { // Fully clipped return 4; } if ((f1 & (uint)ClippingFlags.yClipped) != 0 && (f1 & (uint)ClippingFlags.yClipped) == (f2 & (uint)ClippingFlags.yClipped)) { // Fully clipped return 4; } int tx1 = x1; int ty1 = y1; int tx2 = x2; int ty2 = y2; if(f1 != 0) { if(!ClipMovePoint(tx1, ty1, tx2, ty2, clip_box, ref x1, ref y1, f1)) { return 4; } if(x1 == x2 && y1 == y2) { return 4; } ret |= 1; } if(f2 != 0) { if(!ClipMovePoint(tx1, ty1, tx2, ty2, clip_box, ref x2, ref y2, f2)) { return 4; } if(x1 == x2 && y1 == y2) { return 4; } ret |= 2; } return ret; }
public RectI ClipRectangleArea(ref RectI dst, ref RectI src, int wsrc, int hsrc) { RectI rc = new RectI(0, 0, 0, 0); RectI cb = ClipBox; ++cb.x2; ++cb.y2; if (src.x1 < 0) { dst.x1 -= src.x1; src.x1 = 0; } if (src.y1 < 0) { dst.y1 -= src.y1; src.y1 = 0; } if (src.x2 > wsrc) src.x2 = wsrc; if (src.y2 > hsrc) src.y2 = hsrc; if (dst.x1 < cb.x1) { src.x1 += cb.x1 - dst.x1; dst.x1 = cb.x1; } if (dst.y1 < cb.y1) { src.y1 += cb.y1 - dst.y1; dst.y1 = cb.y1; } if (dst.x2 > cb.x2) dst.x2 = cb.x2; if (dst.y2 > cb.y2) dst.y2 = cb.y2; rc.x2 = dst.x2 - dst.x1; rc.y2 = dst.y2 - dst.y1; if (rc.x2 > src.x2 - src.x1) rc.x2 = src.x2 - src.x1; if (rc.y2 > src.y2 - src.y1) rc.y2 = src.y2 - src.y1; return rc; }
//---------------------------------------------------------------------------- //template<class T> public static bool ClipMovePoint(int x1, int y1, int x2, int y2, RectI clip_box, ref int x, ref int y, uint flags) { int bound; if ((flags & (uint)ClippingFlags.xClipped) != 0) { if(x1 == x2) { return false; } bound = ((flags & (uint)ClippingFlags.x1Clipped) != 0) ? clip_box.x1 : clip_box.x2; y = (int)((double)(bound - x1) * (y2 - y1) / (x2 - x1) + y1); x = bound; } flags = ClippingFlagsY(y, clip_box); if ((flags & (uint)ClippingFlags.yClipped) != 0) { if(y1 == y2) { return false; } bound = ((flags & (uint)ClippingFlags.x1Clipped) != 0) ? clip_box.y1 : clip_box.y2; x = (int)((double)(bound - y1) * (x2 - x1) / (y2 - y1) + x1); y = bound; } return true; }
//-------------------------------------------------------------------- //public IPixelFormat ren() { return m_ren; } //-------------------------------------------------------------------- public bool SetClippingBox(int x1, int y1, int x2, int y2) { RectI cb = new RectI(x1, y1, x2, y2); cb.Normalize(); if (cb.Clip(new RectI(0, 0, (int)Width - 1, (int)Height - 1))) { m_clip_box = cb; return true; } m_clip_box.x1 = 1; m_clip_box.y1 = 1; m_clip_box.x2 = 0; m_clip_box.y2 = 0; return false; }
//--------------------------------------------------------ClippingFlagsX //template<class T> public static uint ClippingFlagsX(int x, RectI clip_box) { return (uint)((x > clip_box.x2 ? 1 : 0) | ((x < clip_box.x1 ? 1 : 0) << 2)); }
protected override void OnUpdateRenderLightmap( out bool finished ) { finished = false; //render bucket { //DoLogEvent( string.Format( "Render bucket {0},{1}", lightmapBucketIndex.X, // lightmapBucketIndex.Y ) ); RectI bucketRectangle = new RectI( lightmapBucketIndex * bucketSize, ( lightmapBucketIndex + new Vec2I( 1, 1 ) ) * bucketSize ); if( bucketRectangle.Right > lightmapRenderingImage.Size.X ) bucketRectangle.Right = lightmapRenderingImage.Size.X; if( bucketRectangle.Bottom > lightmapRenderingImage.Size.Y ) bucketRectangle.Bottom = lightmapRenderingImage.Size.Y; lightmapRenderingImage.Fill( bucketRectangle, new ColorValue( 1, 1, 0 ) ); ColorValue[] colors = new ColorValue[ bucketRectangle.Size.X * bucketRectangle.Size.Y ]; for( int y = bucketRectangle.Minimum.Y; y < bucketRectangle.Maximum.Y; y++ ) { for( int x = bucketRectangle.Minimum.X; x < bucketRectangle.Maximum.X; x++ ) { Vec2I pixelIndex = new Vec2I( x, y ); ColorValue color = RenderPixel( pixelIndex ); Vec2I colorIndex = pixelIndex - bucketRectangle.Minimum; colors[ colorIndex.Y * bucketRectangle.Size.X + colorIndex.X ] = color; } } lightmapRenderingImage.Fill( bucketRectangle, colors ); } //change bucket { Vec2I bucketCount = lightmapRenderingImage.Size / bucketSize; if( lightmapRenderingImage.Size.X % bucketSize != 0 ) bucketCount.X++; if( lightmapRenderingImage.Size.Y % bucketSize != 0 ) bucketCount.Y++; lightmapBucketIndex.X++; if( lightmapBucketIndex.X >= bucketCount.X ) { lightmapBucketIndex.X = 0; lightmapBucketIndex.Y++; if( lightmapBucketIndex.Y >= bucketCount.Y ) finished = true; } } //image finished. do final operations. if( finished ) { lightmapRenderingImage.FillHoles( 5 ); lightmapRenderingImage.Finish(); } }
///<summary> ///</summary> ///<param name="pixf"></param> ///<param name="x1"></param> ///<param name="y1"></param> ///<param name="x2"></param> ///<param name="y2"></param> ///<returns></returns> public bool Attach(IPixelFormat pixf, int x1, int y1, int x2, int y2) { RectI r = new RectI(x1, y1, x2, y2); if (r.Clip(new RectI(0, 0, (int)pixf.Width - 1, (int)pixf.Height - 1))) { int stride = pixf.Stride; unsafe { _rasterBuffer.Attach(pixf.PixelPointer(r.x1, stride < 0 ? r.y2 : r.y1), (uint)(r.x2 - r.x1) + 1, (uint)(r.y2 - r.y1) + 1, stride, 3); } return true; } return false; }