/// <summary> /// Applies a new viewport rectangle. /// </summary> /// <param name="viewport">The viewport rectangle.</param> public static void PushViewport(RectangleI viewport) { var actualRect = viewport; if (actualRect.Width < 0) { actualRect.X += viewport.Width; actualRect.Width = -viewport.Width; } if (actualRect.Height < 0) { actualRect.Y += viewport.Height; actualRect.Height = -viewport.Height; } PushOrtho(viewport); viewport_stack.Push(actualRect); if (Viewport == actualRect) { return; } Viewport = actualRect; GL.Viewport(Viewport.Left, Viewport.Top, Viewport.Width, Viewport.Height); UpdateScissorToCurrentViewportAndOrtho(); }
private void refreshScreens() { screenContainer.Remove(windowContainer); screenContainer.Clear(); var bounds = new RectangleI(); for (int i = 0;; i++) { var device = DisplayDevice.GetDisplay((DisplayIndex)i); if (device == null) { break; } screenContainer.Add(createScreen(device, device.IsPrimary ? $"Screen {i} (Primary)" : $"Screen {i}")); bounds = RectangleI.Union(bounds, new RectangleI(device.Bounds.X, device.Bounds.Y, device.Width, device.Height)); } screenContainer.Add(windowContainer); screenContainerOffset = bounds.Location; foreach (var box in screenContainer.Children) { box.Position -= bounds.Location; } screenContainer.Size = bounds.Size; }
public static SizeI GetAdjustedBoundingRectangleOffsetSize(this UIObject obj) { RectangleI boundingRectangle1 = obj.GetAdjustedBoundingRectangle(); RectangleI boundingRectangle2 = obj.BoundingRectangle; return(new SizeI(boundingRectangle2.Width - boundingRectangle1.Width, boundingRectangle2.Height - boundingRectangle1.Height)); }
public TextureGLAtlas(int width, int height, bool manualMipmaps, All filteringMode = All.Linear, int padding = 0) : base(width, height, manualMipmaps, filteringMode) { this.padding = padding; atlasBounds = new RectangleI(0, 0, Width, Height); }
internal override void SetData(ITextureUpload upload, WrapMode wrapModeS, WrapMode wrapModeT, Opacity?uploadOpacity) { // Can only perform padding when the bounds are a sub-part of the texture RectangleI middleBounds = upload.Bounds; if (middleBounds.IsEmpty || middleBounds.Width * middleBounds.Height > upload.Data.Length) { // For a texture atlas, we don't care about opacity, so we avoid // any computations related to it by assuming it to be mixed. base.SetData(upload, wrapModeS, wrapModeT, Opacity.Mixed); return; } int actualPadding = padding / (1 << upload.Level); if (wrapModeS != WrapMode.None && wrapModeT != WrapMode.None) { uploadCornerPadding(upload, middleBounds, actualPadding); } if (wrapModeS != WrapMode.None) { uploadHorizontalPadding(upload, middleBounds, actualPadding); } if (wrapModeT != WrapMode.None) { uploadVerticalPadding(upload, middleBounds, actualPadding); } // Upload the middle part of the texture // For a texture atlas, we don't care about opacity, so we avoid // any computations related to it by assuming it to be mixed. base.SetData(upload, wrapModeS, wrapModeT, Opacity.Mixed); }
/// <summary> /// 点是否在区域内 /// </summary> /// <param name="Rect">矩形区域</param> /// <param name="P">点P</param> /// <returns> /// 返回True表示点P在区域内,返回False则不在区域内. /// </returns> public static Boolean InRectangle(RectangleI Rect, PointI P) { MinMax <Int32> MX = new MinMax <Int32>(Rect.Left, Rect.Right); MinMax <Int32> MY = new MinMax <Int32>(Rect.Top, Rect.Bottom); return(MX.InRange(P.X) && MY.InRange(P.Y)); }
public override void ProcessPixels(RectangleI region) { ComplexGrid gridDirect = new ComplexGrid(ImageBounds, ProjectionBounds, fDir); ComplexGrid gridInverse = new ComplexGrid(ImageBounds, ProjectionBounds, fInv); Parallel.For(region.TopLeft.Y, region.BottomRight.Y, y => { Parallel.For(region.TopLeft.X, region.BottomRight.X, x => { var pDir = (PointI)lerpPoint(new PointD(x, y), gridDirect[x, y], Alpha); var pInv = (PointI)lerpPoint(new PointD(x, y), gridInverse[x, y], Alpha); SKColor color; if (IsPointInRange(pDir, ImageBounds)) { color = SourceImage.GetPixel(pDir.X, pDir.Y); } else if (IsPointInRange(pInv, ImageBounds)) { color = SourceImage.GetPixel(pInv.X, pInv.Y); } else { color = SKColor.Empty; } DestImage.SetPixel(x, y, color); }); }); }
public static RectangleI GetAdjustedBoundingRectangle(this UIObject obj) { RectangleI rectangleI = obj.BoundingRectangle; if (obj != UIObject.Root) { IntPtr nativeWindowHandle = obj.NativeWindowHandle; if (nativeWindowHandle != IntPtr.Zero) { RECT extendedFrameBoundsRect = new RECT(); int dwmRectangle = GetDwmRectangle(nativeWindowHandle, ref extendedFrameBoundsRect); switch (dwmRectangle) { case -2147024890: break; case 0: rectangleI = new RectangleI(extendedFrameBoundsRect.Left, extendedFrameBoundsRect.Top, extendedFrameBoundsRect.Right - extendedFrameBoundsRect.Left, extendedFrameBoundsRect.Bottom - extendedFrameBoundsRect.Top); break; default: throw new ExternalException("DwmGetWindowAttribute failed.", dwmRectangle); } } } return(rectangleI); }
public static PointI GetAdjustedBoundingRectangleOffsetPosition(this UIObject obj) { RectangleI boundingRectangle1 = obj.GetAdjustedBoundingRectangle(); RectangleI boundingRectangle2 = obj.BoundingRectangle; return(new PointI(boundingRectangle2.Left - boundingRectangle1.Left, boundingRectangle2.Top - boundingRectangle1.Top)); }
internal TextureGL Add(int width, int height) { if (width > atlasWidth) { throw new ArgumentOutOfRangeException(nameof(width), width, $"Must be less than this atlas' width ({atlasWidth}px)."); } if (height > atlasHeight) { throw new ArgumentOutOfRangeException(nameof(height), height, $"Must be less than this atlas' height ({atlasHeight}px)."); } lock (textureRetrievalLock) { if (AtlasTexture == null) { Reset(); } Vector2I position = findPosition(width, height); RectangleI bounds = new RectangleI(position.X, position.Y, width, height); subTextureBounds.Add(bounds); return(new TextureGLSub(bounds, AtlasTexture)); } }
private InvokeOnDisposal establishFrameBufferViewport(Vector2 roundedSize) { // Disable masking for generating the frame buffer since masking will be re-applied // when actually drawing later on anyways. This allows more information to be captured // in the frame buffer and helps with cached buffers being re-used. RectangleI screenSpaceMaskingRect = new RectangleI((int)Math.Floor(ScreenSpaceDrawRectangle.X), (int)Math.Floor(ScreenSpaceDrawRectangle.Y), (int)roundedSize.X + 1, (int)roundedSize.Y + 1); GLWrapper.PushMaskingInfo(new MaskingInfo { ScreenSpaceAABB = screenSpaceMaskingRect, MaskingRect = ScreenSpaceDrawRectangle, ToMaskingSpace = Matrix3.Identity, BlendRange = 1, AlphaExponent = 1, }, true); // Match viewport to FrameBuffer such that we don't draw unnecessary pixels. GLWrapper.PushViewport(new RectangleI(0, 0, (int)roundedSize.X, (int)roundedSize.Y)); return(new InvokeOnDisposal(delegate { GLWrapper.PopViewport(); GLWrapper.PopMaskingInfo(); })); }
protected void UpdateCursorTransitionOnScreenBorder() { System.Drawing.Point p = Cursor.Position; Vector2I position = new Vector2I(p.X, p.Y); System.Drawing.Rectangle r = cursorTransitionOnScreenBorderScreen.Bounds; RectangleI rectangle = new RectangleI(r.Left, r.Top, r.Right, r.Bottom); if (position.X < rectangle.Left + 3) { Cursor.Position = new System.Drawing.Point(rectangle.Right - 6, position.Y); cursorTransitionOnScreenBorderOffset -= new Vector2(rectangle.Size.X, 0); } if (position.X > rectangle.Right - 3) { Cursor.Position = new System.Drawing.Point(rectangle.Left + 6, position.Y); cursorTransitionOnScreenBorderOffset += new Vector2(rectangle.Size.X, 0); } if (position.Y < rectangle.Top + 3) { Cursor.Position = new System.Drawing.Point(position.X, rectangle.Bottom - 6); cursorTransitionOnScreenBorderOffset -= new Vector2(0, rectangle.Size.Y); } if (position.Y > rectangle.Bottom - 3) { Cursor.Position = new System.Drawing.Point(position.X, rectangle.Top + 6); cursorTransitionOnScreenBorderOffset += new Vector2(0, rectangle.Size.Y); } }
static ImageHelpers.IWICBitmap GetImageMobile(RectangleI rectangle) { var deviceFamily = AnalyticsInfo.VersionInfo.DeviceFamily; if (!deviceFamily.Equals(value: "Windows.Mobile", comparisonType: StringComparison.OrdinalIgnoreCase)) { throw new InvalidOperationException(message: string.Format(format: "GetImageMobile not supported on your platform: {0}", arg0: deviceFamily)); } if (rectangle.Width <= 0) { throw new ArgumentOutOfRangeException(paramName: "width", actualValue: rectangle.Width, message: StringResource.Get(id: "RectangleMustBeNonEmpty")); } if (rectangle.Height <= 0) { throw new ArgumentOutOfRangeException(paramName: "height", actualValue: rectangle.Height, message: StringResource.Get(id: "RectangleMustBeNonEmpty")); } var bitmap = ImageHelpers.CaptureMobileScreenshot(); if (bitmap == null) { throw new ScreenCaptureException(message: "CaptureMobileScreenshot failed to capture screen. Returned bitmap is null."); } uint puiWidth = 0; uint puiHeight = 0; bitmap.GetSize(puiWidth: out puiWidth, puiHeight: out puiHeight); if (rectangle.Width == puiWidth && rectangle.Height == puiHeight) { return(bitmap); } Log.Out(msg: "Requested capture area is different than screen size:"); Log.Out(msg: " Requested: Width: {0} Height: {1} Left: {2} Top {3}", (object)rectangle.Width, (object)rectangle.Height, (object)rectangle.Left, (object)rectangle.Top); Log.Out(msg: " Screen: Width: {0} Height: {1}", (object)puiWidth, (object)puiHeight); return(ClipImage(bitmap: bitmap, rectangle: rectangle)); }
private void DrawPrinterPreview(Context context, int i, RectangleI currentPage) { if (i + StartPage >= document.PageContexts.Count) { return; } var page = document.PageContexts [i + StartPage]; int left = document.FormArea.X; int top = document.FormArea.Y; Surface cache; if (!pageCache.TryGetValue(i + startPage, out cache)) { cache = zoom < 0.5 ? page.Target.ScaleSmooth(document.FormArea.Width, document.FormArea.Height, zoom, zoom) : page.Target.ScaleFast(document.FormArea.Width, document.FormArea.Height, zoom, zoom); pageCache [i + startPage] = cache; } context.SetSourceSurface(cache, (int)Math.Round(currentPage.X + left * zoom), (int)Math.Round(currentPage.Y + top * zoom)); context.Paint(); }
//----------------------------------------------------------clipping_flags // Determine the clipping code of the vertex according to the // Cyrus-Beck line clipping algorithm // // | | // 0110 | 0010 | 0011 // | | // -------+--------+-------- clip_box.y2 // | | // 0100 | 0000 | 0001 // | | // -------+--------+-------- clip_box.y1 // | | // 1100 | 1000 | 1001 // | | // clip_box.x1 clip_box.x2 // // //template<class T> public static int clipping_flags(int x, int y, RectangleI clip_box) { return ((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); }
public override Bitmap Bitmap(TextureAttachment textureAttachment, RectangleI rectangle) { if (textureAttachment == TextureAttachment.Depth || textureAttachment == TextureAttachment.DepthStencil) { throw new CKGLException("Cannot read pixels of the Depth(Stecil) attachment."); } if (rectangle.X < 0 || rectangle.Y < 0 || rectangle.X + rectangle.W > Width || rectangle.Y + rectangle.H > Height) { throw new CKGLException("Rectangle outside of Framebuffer bounds."); } Framebuffer originalFramebuffer = Current; Bind(); if (IsDefault) { if (textureAttachment == TextureAttachment.Depth || textureAttachment == TextureAttachment.DepthStencil) { throw new IllegalValueException(typeof(TextureAttachment), textureAttachment); } GL.ReadBuffer(ReadBuffer.Back); } else { GL.ReadBuffer((ReadBuffer)textureAttachment.ToOpenGL()); } Bitmap bitmap = new Bitmap(GL.ReadPixelsAsColourArray(rectangle, PixelFormat.RGBA), rectangle.W, rectangle.H); originalFramebuffer.Bind(); return(bitmap); }
/// <summary> /// Get the estimated bounding box of a text rendering. /// </summary> /// <param name="font">Font to use.</param> /// <param name="text">Text to draw.</param> /// <param name="position">Text position.</param> /// <param name="fontSize">Font size.</param> /// <param name="maxWidth">Max line width.</param> /// <param name="origin">Text origin.</param> /// <param name="rotation">Text rotation.</param> /// <returns>Estimated text drawing bounding box.</returns> public RectangleI GetTextBoundingBox(FontAsset font, string text, PointF position, int fontSize, int maxWidth, PointF origin, float rotation) { RectangleI ret = new RectangleI(); _BonEngineBind.BON_Gfx_GetTextBoundingBox(font._handle, text, position.X, position.Y, fontSize, maxWidth, origin.X, origin.Y, rotation, ref ret.X, ref ret.Y, ref ret.Width, ref ret.Height); return(ret); }
private static void setMaskingInfo(MaskingInfo maskingInfo, bool isPushing, bool overwritePreviousScissor) { FlushCurrentBatch(); GlobalPropertyManager.Set(GlobalProperty.MaskingRect, new Vector4( maskingInfo.MaskingRect.Left, maskingInfo.MaskingRect.Top, maskingInfo.MaskingRect.Right, maskingInfo.MaskingRect.Bottom)); GlobalPropertyManager.Set(GlobalProperty.ToMaskingSpace, maskingInfo.ToMaskingSpace); GlobalPropertyManager.Set(GlobalProperty.CornerRadius, maskingInfo.CornerRadius); GlobalPropertyManager.Set(GlobalProperty.BorderThickness, maskingInfo.BorderThickness / maskingInfo.BlendRange); if (maskingInfo.BorderThickness > 0) { GlobalPropertyManager.Set(GlobalProperty.BorderColour, new Vector4( maskingInfo.BorderColour.Linear.R, maskingInfo.BorderColour.Linear.G, maskingInfo.BorderColour.Linear.B, maskingInfo.BorderColour.Linear.A)); } GlobalPropertyManager.Set(GlobalProperty.MaskingBlendRange, maskingInfo.BlendRange); GlobalPropertyManager.Set(GlobalProperty.AlphaExponent, maskingInfo.AlphaExponent); GlobalPropertyManager.Set(GlobalProperty.EdgeOffset, maskingInfo.EdgeOffset); GlobalPropertyManager.Set(GlobalProperty.DiscardInner, maskingInfo.Hollow); RectangleI actualRect = maskingInfo.ScreenSpaceAABB; actualRect.X += Viewport.X; actualRect.Y += Viewport.Y; // Ensure the rectangle only has positive width and height. (Required by OGL) if (actualRect.Width < 0) { actualRect.X += actualRect.Width; actualRect.Width = -actualRect.Width; } if (actualRect.Height < 0) { actualRect.Y += actualRect.Height; actualRect.Height = -actualRect.Height; } if (isPushing) { scissor_rect_stack.Push(overwritePreviousScissor ? actualRect : RectangleI.Intersect(scissor_rect_stack.Peek(), actualRect)); } else { Trace.Assert(scissor_rect_stack.Count > 1); scissor_rect_stack.Pop(); } UpdateScissorToCurrentViewportAndOrtho(); }
public static PointI GetWindowTopLeft(this RectangleI rect, IntPtr nativeWindowHandle) { int xClient; int yClient; ConvertScreenToClient(nativeWindowHandle, rect.Left, rect.Top, out xClient, out yClient); return(new PointI(xClient, yClient)); }
public static SDL.SDL_Rect ToSDLRect(this RectangleI rectangle) => new SDL.SDL_Rect { x = rectangle.X, y = rectangle.Y, h = rectangle.Height, w = rectangle.Width, };
//-------------------------------------------------------------------- public VectorClipper_DoClip() { m_clip_box = new RectangleI(0, 0, 0, 0); m_x1 = (0); m_y1 = (0); m_f1 = (0); m_clipping = (false); }
private static void setMaskingInfo(MaskingInfo maskingInfo, bool isPushing, bool overwritePreviousScissor) { FlushCurrentBatch(); GlobalPropertyManager.Set(GlobalProperty.MaskingRect, new Vector4( maskingInfo.MaskingRect.Left, maskingInfo.MaskingRect.Top, maskingInfo.MaskingRect.Right, maskingInfo.MaskingRect.Bottom)); GlobalPropertyManager.Set(GlobalProperty.ToMaskingSpace, maskingInfo.ToMaskingSpace); GlobalPropertyManager.Set(GlobalProperty.CornerRadius, maskingInfo.CornerRadius); GlobalPropertyManager.Set(GlobalProperty.CornerExponent, maskingInfo.CornerExponent); GlobalPropertyManager.Set(GlobalProperty.BorderThickness, maskingInfo.BorderThickness / maskingInfo.BlendRange); if (maskingInfo.BorderThickness > 0) { GlobalPropertyManager.Set(GlobalProperty.BorderColour, new Vector4( maskingInfo.BorderColour.Linear.R, maskingInfo.BorderColour.Linear.G, maskingInfo.BorderColour.Linear.B, maskingInfo.BorderColour.Linear.A)); } GlobalPropertyManager.Set(GlobalProperty.MaskingBlendRange, maskingInfo.BlendRange); GlobalPropertyManager.Set(GlobalProperty.AlphaExponent, maskingInfo.AlphaExponent); GlobalPropertyManager.Set(GlobalProperty.EdgeOffset, maskingInfo.EdgeOffset); GlobalPropertyManager.Set(GlobalProperty.DiscardInner, maskingInfo.Hollow); if (maskingInfo.Hollow) { GlobalPropertyManager.Set(GlobalProperty.InnerCornerRadius, maskingInfo.HollowCornerRadius); } if (isPushing) { // When drawing to a viewport that doesn't match the projection size (e.g. via framebuffers), the resultant image will be scaled Vector2 viewportScale = Vector2.Divide(Viewport.Size, Ortho.Size); Vector2 location = (maskingInfo.ScreenSpaceAABB.Location - ScissorOffset) * viewportScale; Vector2 size = maskingInfo.ScreenSpaceAABB.Size * viewportScale; RectangleI actualRect = new RectangleI( (int)Math.Floor(location.X), (int)Math.Floor(location.Y), (int)Math.Ceiling(size.X), (int)Math.Ceiling(size.Y)); PushScissor(overwritePreviousScissor ? actualRect : RectangleI.Intersect(scissor_rect_stack.Peek(), actualRect)); } else { PopScissor(); } }
public void TestRectangleICenter() { // ARRANGE. var rectangle = new RectangleI(new Vector2I(2, 3), new Vector2I(6, 8)); var center = new Vector2I(5, 7); // ASSERT. Assert.AreEqual(center, rectangle.Center); }
public void TestRectangleICenter() { // ARRANGE. var rectangle = new RectangleI(new Vector2I(2, 3), new Vector2I(6, 8)); var center = new Vector2I(5, 7); // ASSERT. Assert.AreEqual(center, rectangle.Center); }
public GuiView(Shader shader, int width, int height, LayoutMode layout) : base(width, height, layout) { rect = new RectangleI(width, height); FlexX = FlexY = false; View = this; Texture = new Texture2D(width, height, TextureFormat.RGBA); target = new RenderTarget(Texture); material = new Material(shader); }
public static int Main() { int iRetVal = 100; var rF = new RectangleF(1.2f, 3.4f, 5.6f, 7.8f); var rD = new RectangleD(1.7E+3d, 4.5d, 500.1d, 60.0d); var rI = new RectangleI(100, -2, 3, 64); var rLSmall = new RectangleLSmall(11231L); var rLLarge = new RectangleLLarge(1L, 20041L, 22L, 88L); var rNestedFSmall = new RectangleNestedF(1.2f, 3.4f, 5.6f, 7.8f); typeof(Test7685).GetTypeInfo().GetDeclaredMethod("DoStuffF").Invoke(null, new object[] { rF }); typeof(Test7685).GetTypeInfo().GetDeclaredMethod("DoStuffD").Invoke(null, new object[] { rD }); typeof(Test7685).GetTypeInfo().GetDeclaredMethod("DoStuffI").Invoke(null, new object[] { rI }); typeof(Test7685).GetTypeInfo().GetDeclaredMethod("DoStuffLSmall").Invoke(null, new object[] { rLSmall }); typeof(Test7685).GetTypeInfo().GetDeclaredMethod("DoStuffLLarge").Invoke(null, new object[] { rLLarge }); typeof(Test7685).GetTypeInfo().GetDeclaredMethod("DoStuffNestedF").Invoke(null, new object[] { rNestedFSmall }); if (!RectangleF.Equals(ref passedFloatStruct, ref rF)) { TestLibrary.Logging.WriteLine($"Error: passing struct with floats via reflection. Callee received {passedFloatStruct} instead of {rF}"); iRetVal = 0; } if (!RectangleD.Equals(ref passedDoubleStruct, ref rD)) { TestLibrary.Logging.WriteLine($"Error: passing struct with doubles via reflection. Callee received {passedDoubleStruct} instead of {rD}"); iRetVal = 1; } if (!RectangleI.Equals(ref passedIntStruct, ref rI)) { TestLibrary.Logging.WriteLine($"Error: passing struct with ints via reflection. Callee received {passedIntStruct} instead of {rI}"); iRetVal = 2; } if (!RectangleLSmall.Equals(ref passedLongSmallStruct, ref rLSmall)) { TestLibrary.Logging.WriteLine($"Error: passing struct with a long via reflection. Callee received {passedLongSmallStruct} instead of {rLSmall}"); iRetVal = 3; } if (!RectangleLLarge.Equals(ref passedLongLargeStruct, ref rLLarge)) { TestLibrary.Logging.WriteLine($"Error: passing struct with longs via reflection. Callee received {passedLongLargeStruct} instead of {rLLarge}"); iRetVal = 4; } if (!RectangleNestedF.Equals(ref passedNestedSmallFStruct, ref rNestedFSmall)) { TestLibrary.Logging.WriteLine($"Error: passing struct with longs via reflection. Callee received {passedNestedSmallFStruct} instead of {rNestedFSmall}"); iRetVal = 5; } return iRetVal; }
/// <summary> /// Get RectangleI from config. /// </summary> /// <param name="section">Section to get value from.</param> /// <param name="key">Key to get.</param> /// <param name="defaultVal">Default value to return if not found.</param> /// <returns>Value from config, or defaultVal if not found.</returns> public RectangleI GetRectangleI(string section, string key, RectangleI defaultVal) { var asStr = GetStr(section, key, null); if (asStr == null) { return(defaultVal); } return(RectangleI.FromString(asStr.Trim())); }
/// <summary> /// Get the estimated bounding box of a text rendering. /// </summary> /// <param name="font">Font to use.</param> /// <param name="text">Text to draw.</param> /// <param name="position">Text position.</param> /// <param name="fontSize">Font size.</param> /// <param name="maxWidth">Max line width.</param> /// <param name="origin">Text origin.</param> /// <param name="rotation">Text rotation.</param> /// <returns>Estimated text drawing bounding box.</returns> public RectangleI GetTextBoundingBox(FontAsset font, string text, PointF position, int fontSize, int maxWidth, PointF origin, float rotation) { if (!font.HaveHandle) { throw new Exception("Tried to render a font without handle!"); } RectangleI ret = new RectangleI(); _BonEngineBind.BON_Gfx_GetTextBoundingBox(font._handle, text, position.X, position.Y, fontSize, maxWidth, origin.X, origin.Y, rotation, ref ret.X, ref ret.Y, ref ret.Width, ref ret.Height); return(ret); }
/// <summary> /// 判断矩形R是否在多边形内 /// </summary> /// <param name="PG">PG多边形</param> /// <param name="R">R矩形</param> /// <returns>如果R矩形在区域内返回True,否则返回False.</returns> public static Boolean InPolygon(PolygonI PG, RectangleI R) { foreach (LineD L in R) { if (InPolygon(PG, L) == false) { return(false); } } return(true); }
private void uploadHorizontalPadding(ReadOnlySpan <Rgba32> upload, RectangleI middleBounds, int actualPadding, bool fillOpaque) { RectangleI[] sideBoundsArray = { new RectangleI(middleBounds.X - actualPadding, middleBounds.Y, actualPadding, middleBounds.Height).Intersect(atlasBounds), // Left new RectangleI(middleBounds.X + middleBounds.Width, middleBounds.Y, actualPadding, middleBounds.Height).Intersect(atlasBounds), // Right }; int[] sideIndices = { 0, // Left middleBounds.Width - 1, // Right }; for (int i = 0; i < 2; ++i) { RectangleI sideBounds = sideBoundsArray[i]; if (!sideBounds.IsEmpty) { bool allTransparent = true; int index = sideIndices[i]; var sideUpload = new MemoryAllocatorTextureUpload(sideBounds.Width, sideBounds.Height) { Bounds = sideBounds }; var data = sideUpload.RawData; int stride = middleBounds.Width; for (int y = 0; y < sideBounds.Height; ++y) { for (int x = 0; x < sideBounds.Width; ++x) { Rgba32 pixel = upload[index + y * stride]; allTransparent &= checkEdgeRGB(pixel); transferBorderPixel(ref data[y * sideBounds.Width + x], pixel, fillOpaque); } } // Only upload padding if the border isn't completely transparent. if (!allTransparent) { // For a texture atlas, we don't care about opacity, so we avoid // any computations related to it by assuming it to be mixed. base.SetData(sideUpload, WrapMode.None, WrapMode.None, Opacity.Mixed); } } } }
/// <summary> /// 判断折线PL是否在圆内 /// </summary> /// <param name="C">圆C</param> /// <param name="R">矩形R</param> /// <returns>如果在圆内返回True,否则返回False。</returns> public static Boolean InCircle(CircleI C, RectangleI R) { if (PointAlgorithm.Distance(new PointI(R.Left, R.Top), C.Center) > C.Radius) { return(false); } if (PointAlgorithm.Distance(new PointI(R.Right, R.Bottom), C.Center) > C.Radius) { return(false); } return(true); }
public RectangleG(int x, int y, int width, int height) { fRectangle = new RectangleI(x, y, width, height); Begin(); MoveTo(x, y, false); LineTo(x, y + height, false); LineTo(x + width, y + height, false); LineTo(x + width, y, false); LineTo(x, y, true); End(); }
public TextureGLSub(RectangleI bounds, TextureGLSingle parent) { // If GLWrapper is not initialized at this point, it means we do not have OpenGL available // and thus will never draw anything. In this case it is fine if the parent texture is null. if (GLWrapper.IsInitialized && parent == null) { throw new InvalidOperationException("May not construct a subtexture without a parent texture to refer to."); } this.bounds = bounds; this.parent = parent; }
/// <summary> /// Applies a new scissor rectangle. /// </summary> /// <param name="scissor">The scissor rectangle.</param> public static void PushScissor(RectangleI scissor) { FlushCurrentBatch(); scissor_rect_stack.Push(scissor); if (Scissor == scissor) { return; } Scissor = scissor; setScissor(scissor); }
public Graphic(String name, int x, int y, int width, int height) { fName = name; fOrigin = new Point3D(0, 0); fDimension = new Vector3D(width, height); fFrame = new RectangleI(x, y, width, height); //fGraphicsUnit = GraphicsUnit.Display; fVisible = true; fActive = true; fEnabled = false; }
//public IPixelFormat ren() { return m_ren; } public bool SetClippingBox(int x1, int y1, int x2, int y2) { RectangleI cb = new RectangleI(x1, y1, x2, y2); if (cb.Clip(new RectangleI(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; }
public RectangleI clip_rect_area(ref RectangleI dst, ref RectangleI src, int wsrc, int hsrc) { RectangleI rc = new RectangleI(0, 0, 0, 0); RectangleI cb = clip_box(); ++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; }
public static GDIRegion CreateFromRectangles(RectangleI[] rects, Guid uniqueID) { // 1. Create a header RGNDATAHEADER header = new RGNDATAHEADER(); header.dwSize = Marshal.SizeOf(header); header.iType = 1; header.nCount = (uint)rects.Length; header.nRgnSize = (uint)Marshal.SizeOf(typeof(RECT)) * header.nCount; //header.rcBound = // 2. Allocate memory to hold the header plus the data for the rectangles int dataLengthNeeded = (int)(header.dwSize + header.nRgnSize); IntPtr memoryPtr = Marshal.AllocCoTaskMem((int)dataLengthNeeded); UnmanagedPointer structPtr = new UnmanagedPointer(memoryPtr); // 4. Copy the Header into the memory buffer Marshal.StructureToPtr(header, structPtr, false); // 5. Increment the memory buffer pointer to write the rectangles structPtr = structPtr + header.dwSize; // The nRgnSize / nCount will tell us how many bytes per rectangle structure // and therefore how much to advance the pointer as we turn the buffer // into a set of rectangles using PtrToStructure. int structIncrement = (int)(header.nRgnSize / header.nCount); // 6. Write the rectangles for (int i = 0; i < header.nCount; i++) { RECT aRect = new RECT(rects[i].Left, rects[i].Top, rects[i].Width, rects[i].Height); Marshal.StructureToPtr(aRect, structPtr, false); // Increment the structure pointer to the next position structPtr = structPtr + structIncrement; } // 7. Create the region IntPtr regionHandle = GDI32.ExtCreateRegion(IntPtr.Zero, (uint)rects.Length, memoryPtr); GDIRegion newRegion = new GDIRegion(regionHandle, true, uniqueID); // 8. Free the memory Marshal.FreeCoTaskMem(memoryPtr); return newRegion; }
public static bool clip_move_point(int x1, int y1, int x2, int y2, RectangleI clip_box, ref int x, ref int y, int flags) { int bound; if ((flags & (int)clipping_flags_e.clipping_flags_x_clipped) != 0) { if (x1 == x2) { return false; } bound = ((flags & (int)clipping_flags_e.clipping_flags_x1_clipped) != 0) ? clip_box.x1 : clip_box.x2; y = (int)((double)(bound - x1) * (y2 - y1) / (x2 - x1) + y1); x = bound; } flags = clipping_flags_y(y, clip_box); if ((flags & (int)clipping_flags_e.clipping_flags_y_clipped) != 0) { if (y1 == y2) { return false; } bound = ((flags & (int)clipping_flags_e.clipping_flags_x1_clipped) != 0) ? clip_box.y1 : clip_box.y2; x = (int)((double)(bound - y1) * (x2 - x1) / (y2 - y1) + x1); y = bound; } return true; }
// By default, debugging will just draw a red rectangle around the frame protected virtual void OnDebug(DrawEvent devent) { RectangleI aRect = new RectangleI((int)Origin.x, (int)Origin.y, (int)Dimension.x, (int)Dimension.y); devent.GraphPort.DrawRectangle(GDICosmeticPen.Red, aRect); }
/// <summary> /// Whenever a frame is received from the camera, this routine is called. /// </summary> /// <param name="sender">the object that hosts the callback routine for the received frame.</param> /// <param name="camEvent">Event containing video frame information</param> void OnFrameReceived(object sender, CameraEventArgs camEvent) { RectangleI srcRect = new RectangleI(0, 0, camEvent.Width, camEvent.Height); RectangleI dstRect = srcRect; if (fUseScaling) { dstRect = this.ClientRectangle; } DeviceContextClientArea.PixelBlt(srcRect, dstRect, camEvent.fData, BitCount.Bits24); }
public override void LinkToImage(IImage ren) { base.LinkToImage(ren); m_clip_box = new RectangleI(0, 0, (int)ren.Width() - 1, (int)ren.Height() - 1); }
public virtual void ResizeBy(int dw, int dh) { fFrame = new RectangleI(new Point2I(fFrame.Left, fFrame.Top), new Size2I(Frame.Width+dw, Frame.Height+dh)); fDimension.x = fFrame.Width; fDimension.y = fFrame.Height; UpdateGeometryState(); }
public virtual void ResizeTo(int width, int height) { fFrame = new RectangleI(new Point2I(fFrame.Left, fFrame.Top), new Size2I(width, height)); fDimension.x = width; fDimension.y = height; UpdateGeometryState(); }
public virtual void OnGraphicAdded(IGraphic aGraphic) { // Layout the graphic again LayoutHandler.AddToLayout(aGraphic); if (AutoGrow) { // Make sure our frame expands appropriately RectangleI frame = Frame; Point2I gOrigin = new Point2I(frame.Left + aGraphic.Frame.Left, frame.Top + aGraphic.Frame.Top); //float3 iPoint = WorldTransform.ApplyInverse(new float3(gOrigin.X, gOrigin.Y, 0)); //Point tOrigin = new Point((int)iPoint.x, (int)iPoint.y); RectangleI tRect = new RectangleI((int)gOrigin.x, (int)gOrigin.y, (int)aGraphic.Dimension.x, (int)aGraphic.Dimension.y); // WAA - need to do this frame = RectangleI.Union(frame, tRect); Dimension = new Vector3D(frame.Width, frame.Height); fFrame = frame; } }
//-------------------------------------------------------------------- public void clip_box(int x1, int y1, int x2, int y2) { m_clip_box = new RectangleI(x1, y1, x2, y2); m_clipping = true; }
public PushButton(string name, RectangleI frame, IGraphic label) : this(name, frame.Left, frame.Top, frame.Width, frame.Height, label) { }
public static int clipping_flags_y(int y, RectangleI clip_box) { return (((y > clip_box.y2 ? 1 : 0) << 1) | ((y < clip_box.y1 ? 1 : 0) << 3)); }
/// <summary> /// Checks whether the two specified rectangles at least partially intersect each other. /// </summary> /// <param name="first"> /// First rectangle to check. /// </param> /// <param name="second"> /// Second rectangle to check. /// </param> /// <returns> /// <c>true</c>, if the two rectangles intersect each other, and <c>false</c> otherwise. /// </returns> public static bool Intersects(this RectangleI first, RectangleI second) { return (first.MaxX > second.X && first.X < second.MaxX) && (first.MaxY > second.Y && first.Y < second.MaxY); }
public Graphic(String name, RectangleI frame) : this(name, frame.Left, frame.Top, frame.Width, frame.Height) { // Do nothing in here. It's just a convenience for the // more general call. }
public static int clip_liang_barsky(int x1, int y1, int x2, int y2, RectangleI clip_box, int[] x, int[] y) { int XIndex = 0; int 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; int 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; }
public ImageClippingProxy(IImage ren) : base(ren) { m_clip_box = new RectangleI(0, 0, (int)ren.Width() - 1, (int)ren.Height() - 1); }
public static int clipping_flags_x(int x, RectangleI clip_box) { return ((x > clip_box.x2 ? 1 : 0) | ((x < clip_box.x1 ? 1 : 0) << 2)); }
/// <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(RectangleI other) { return this.Y >= other.Y && this.X <= other.X && this.Bottom <= other.Bottom && this.Right >= other.Right; }
//-------------------------------------------------------clip_line_segment // 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 int clip_line_segment(ref int x1, ref int y1, ref int x2, ref int y2, RectangleI clip_box) { int f1 = clipping_flags(x1, y1, clip_box); int f2 = clipping_flags(x2, y2, clip_box); int ret = 0; if ((f2 | f1) == 0) { // Fully visible return 0; } if ((f1 & (int)clipping_flags_e.clipping_flags_x_clipped) != 0 && (f1 & (int)clipping_flags_e.clipping_flags_x_clipped) == (f2 & (int)clipping_flags_e.clipping_flags_x_clipped)) { // Fully clipped return 4; } if ((f1 & (int)clipping_flags_e.clipping_flags_y_clipped) != 0 && (f1 & (int)clipping_flags_e.clipping_flags_y_clipped) == (f2 & (int)clipping_flags_e.clipping_flags_y_clipped)) { // Fully clipped return 4; } int tx1 = x1; int ty1 = y1; int tx2 = x2; int ty2 = y2; if (f1 != 0) { if (!clip_move_point(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 (!clip_move_point(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> /// 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(RectangleI other) { return !(this.Y <= other.Bottom || this.X >= other.Right || this.Bottom >= other.Y || this.Right <= other.X); }
public RectangleI[] GetRectangles() { // If the region is empty, return a single empty rectangle if (IsEmpty) { return new RectangleI[1]; } // 1. Call GetRgnData with null to get size uint dataLengthNeeded = GDI32.GetRegionData(DangerousGetHandle(), 0, IntPtr.Zero); // 2. allocate some memory to hold the data UnmanagedMemory uMem = new UnmanagedMemory((int)dataLengthNeeded); IntPtr memoryPtr = uMem.MemoryPointer; UnmanagedPointer structPtr = new UnmanagedPointer(memoryPtr); // 3. call again passing in memory uint bytesFilled = GDI32.GetRegionData(DangerousGetHandle(), dataLengthNeeded, structPtr); // If the return value is 0, then the call failed. if (0 == bytesFilled) return null; // 4. convert memory to data structures // First get the RGNDATAHEADER RGNDATAHEADER dataHeader; dataHeader = (RGNDATAHEADER)Marshal.PtrToStructure(structPtr, typeof(RGNDATAHEADER)); // dataHeader.dwSize - tells us how big the header is, and thus how many bytes to skip to get // to the rectangle information // dataHeader.nRgnSize - tells us how many bytes are needed for the rectangle information // dataHeader.nCount - tells us how many rectangles there are structPtr = structPtr + dataHeader.dwSize; // The nRgnSize / nCount will tell us how many bytes per rectangle structure // and therefore how much to advance the pointer as we turn the buffer // into a set of rectangles using PtrToStructure. int structIncrement = (int)(dataHeader.nRgnSize / dataHeader.nCount); // Create a list to add the rectangles to. This is simply convenient. RectangleI[] rects = new RectangleI[dataHeader.nCount]; // Loop through creating as many rectangles as indicated by the dataheader nCount field for (int i = 0; i < dataHeader.nCount; i++) { RECT rect = (RECT)Marshal.PtrToStructure(structPtr, typeof(RECT)); rects[i].x1 = rect.X; rects[i].y1 = rect.Y; rects[i].x2 = rect.X + rect.Width; rects[i].y2 = rect.Y + rect.Height; rects[i].Normalize(); structPtr = structPtr + structIncrement; } // 5. free memory uMem.Dispose(); return rects; }
public GraphicGroup(String name, RectangleI rect) : this(name, rect.Left, rect.Top, rect.Width, rect.Height, LayoutManager.Empty) { }
/// <summary> /// Invalidate a portion of the client rectangle. /// </summary> /// <param name="partialFrame"></param> public virtual void Invalidate(RectangleI portionOfClientRectangle) { // The portion to be invalidated is given in the coordinate space // of the client rectangle. That portion needs to be converted // into the parent's space and sent to the parent for evaluation portionOfClientRectangle.Offset(Frame.Left, Frame.Top); if (null != Container) { Container.Invalidate(portionOfClientRectangle); } else if (null != Window) Window.Invalidate(portionOfClientRectangle); }
public void copy_from(IImage src, RectangleI rect_src_ptr, int dx, int dy) { RectangleI rsrc = new RectangleI(rect_src_ptr.x1, rect_src_ptr.y1, rect_src_ptr.x2 + 1, rect_src_ptr.y2 + 1); // Version with xdst, ydst (absolute positioning) //rect_i rdst(xdst, ydst, xdst + rsrc.x2 - rsrc.x1, ydst + rsrc.y2 - rsrc.y1); // Version with dx, dy (relative positioning) RectangleI rdst = new RectangleI(rsrc.x1 + dx, rsrc.y1 + dy, rsrc.x2 + dx, rsrc.y2 + dy); RectangleI rc = clip_rect_area(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; } int getDistanceBetweenPixelsInclusive = src.GetDistanceBetweenPixelsInclusive(); while (rc.y2 > 0) { base.CopyFrom(src, rdst.x1, rdst.y1, rsrc.x1, rsrc.y1, rc.x2 * getDistanceBetweenPixelsInclusive); rdst.y1 += incy; rsrc.y1 += incy; --rc.y2; } } }