public void Draw(Texture2D texture, Vector2 position, DoubleRectangle? sourceRectangle, Color color, float rotation, Vector2 origin, Vector2 scale, SpriteEffects effects, float layerDepth) { DrawCommand cmd = GetRenderer().GetAvailableCommand(); cmd.CommandType = DrawCommand.DrawCommandType.Texture; cmd.Texture = texture; cmd.Position = position; cmd.Color = color; // Vic says - make sure this stays in, or else previously-drawn Sprites can make later-drawn Sprites have the wrong effect cmd.ShaderEffect = null; cmd.Rotation = rotation; cmd.Origin = origin; if (sourceRectangle != null) { cmd.SourceRectangle = sourceRectangle.Value; } else { cmd.SourceRectangle = DoubleRectangle.Empty; } cmd.Scale = scale; cmd.Effects = effects; cmd.LayerDepth = layerDepth; cmd.CalculateDestinationRectangle(texture); }
/// <summary> /// Used to construct a rectangle using the canvas coordinate system /// </summary> /// <param name="startX">Origin point of the click on the X axis</param> /// <param name="startY">Origin point of the click on the Y axis</param> /// <param name="drawWidth">The width of the object in the web layer (may be negative)</param> /// <param name="drawHeight">The height of the object in the web layer (may be negative)</param> public DoubleRectangle CreateDoubleRectangleFromWebCoordinates(int startX, int startY, int drawWidth, int drawHeight) { var x = drawWidth > 0 ? startX : startX + drawWidth; var y = drawHeight > 0 ? startY : startY + drawHeight; var width = Math.Abs(drawWidth); var height = Math.Abs(drawHeight); var doubleRectangle = new DoubleRectangle(x, y, width, height); return doubleRectangle; }
void RenderText() { Vector2 size = Font.InternalMeasureString(_text); renderedText = new WriteableBitmap((int)size.X, (int)size.Y); pixelWidth = renderedText.PixelWidth; pixelHeight = renderedText.PixelHeight; SourceRectangle = new DoubleRectangle(0, 0, pixelWidth, pixelHeight); Font.Draw(this, _text); brush.ImageSource = renderedText; }
/// <summary> /// True if small rectangle is entirely contained within the larger rectangle /// </summary> /// <param name="largerRectangle">The larger rectangle</param> /// <param name="smallerRectangle">The smaller rectangle</param> /// <returns>True if small rectangle is entirely contained within the larger rectangle, false otherwise</returns> private bool ContainedWithin(DoubleRectangle largerRectangle, DoubleRectangle smallerRectangle) { bool lowerLeftCheck = largerRectangle.LowerLeft.X <= smallerRectangle.LowerLeft.X && largerRectangle.LowerLeft.Y <= smallerRectangle.LowerLeft.Y; bool upperLeftCheck = largerRectangle.UpperLeft.X <= smallerRectangle.UpperLeft.X && largerRectangle.UpperLeft.Y >= smallerRectangle.UpperLeft.Y; bool lowerRightCheck = largerRectangle.LowerRight.X >= smallerRectangle.LowerRight.X && largerRectangle.LowerRight.Y <= smallerRectangle.LowerRight.Y; bool upperRightCheck = largerRectangle.UpperRight.X >= smallerRectangle.UpperRight.X && largerRectangle.UpperRight.Y >= smallerRectangle.UpperRight.Y; return lowerLeftCheck && upperLeftCheck && lowerRightCheck && upperRightCheck; }
/// <summary> /// True if small rectangle is entirely contained within the larger rectangle /// </summary> /// <param name="largerRectangle">The larger rectangle</param> /// <param name="smallerRectangle">The smaller rectangle</param> /// <returns>True if small rectangle is entirely contained within the larger rectangle, false otherwise</returns> private bool ContainedWithin(DoubleRectangle largerRectangle, DoubleRectangle smallerRectangle) { bool lowerLeftCheck = largerRectangle.LowerLeft.X <= smallerRectangle.LowerLeft.X && largerRectangle.LowerLeft.Y <= smallerRectangle.LowerLeft.Y; bool upperLeftCheck = largerRectangle.UpperLeft.X <= smallerRectangle.UpperLeft.X && largerRectangle.UpperLeft.Y >= smallerRectangle.UpperLeft.Y; bool lowerRightCheck = largerRectangle.LowerRight.X >= smallerRectangle.LowerRight.X && largerRectangle.LowerRight.Y <= smallerRectangle.LowerRight.Y; bool upperRightCheck = largerRectangle.UpperRight.X >= smallerRectangle.UpperRight.X && largerRectangle.UpperRight.Y >= smallerRectangle.UpperRight.Y; return(lowerLeftCheck && upperLeftCheck && lowerRightCheck && upperRightCheck); }
/// <summary> /// Used to construct a rectangle using the canvas coordinate system /// </summary> /// <param name="startX">Origin point of the click on the X axis</param> /// <param name="startY">Origin point of the click on the Y axis</param> /// <param name="drawWidth">The width of the object in the web layer (may be negative)</param> /// <param name="drawHeight">The height of the object in the web layer (may be negative)</param> public DoubleRectangle CreateDoubleRectangleFromWebCoordinates(int startX, int startY, int drawWidth, int drawHeight) { var x = drawWidth > 0 ? startX : startX + drawWidth; var y = drawHeight > 0 ? startY : startY + drawHeight; var width = Math.Abs(drawWidth); var height = Math.Abs(drawHeight); var doubleRectangle = new DoubleRectangle(x, y, width, height); return(doubleRectangle); }
void GetDestinationRect(ref Rectangle rect, Vector2 position, ref DoubleRectangle sourceRectangle, Vector2 scale, Vector2 origin) { position -= origin * scale; Vector2 pos = Vector2.Transform(position, _transformMatrix); Vector2 pos2 = position; pos2.X += (float)(sourceRectangle.Width * scale.X); pos2.Y += (float)(sourceRectangle.Height * scale.Y); pos2 = Vector2.Transform(pos2, _transformMatrix); rect.X = (int)(pos.X + .5); rect.Y = (int)(pos.Y + .5); int right = (int)(pos2.X + .5); int bottom = (int)(pos2.Y + .5); rect.Width = right - rect.X; rect.Height = bottom - rect.Y; }
/// <summary> /// Check that two double precision rectangles overlap with each other /// </summary> /// <param name="rect1">The first rectangle</param> /// <param name="rect2">The second rectangle</param> /// <returns>The rectangles overlap</returns> public bool DoesEitherRectangleOverlapTheOther(DoubleRectangle rect1, DoubleRectangle rect2) { if (IsEitherRectangleAdjacentToTheOther(rect1, rect2)) return true; bool leftOfRect1InsideRect2Width = ValuesOverlap(rect1.X, rect2.X, rect2.X + rect2.Width); bool leftOfRect2InsideRect1Width = ValuesOverlap(rect2.X, rect1.X, rect1.X + rect1.Width); bool xOverlap = leftOfRect1InsideRect2Width || leftOfRect2InsideRect1Width; bool topOfRect1InsideRect2Height = ValuesOverlap(rect1.Y, rect2.Y, rect2.Y + rect2.Height); bool topOfRect2InsideRect1Height = ValuesOverlap(rect2.Y, rect1.Y, rect1.Y + rect1.Height); bool yOverlap = topOfRect1InsideRect2Height || topOfRect2InsideRect1Height; bool rectanglesIntersect = xOverlap && yOverlap && !DoesEitherRectangleContainTheOther(rect1, rect2); return rectanglesIntersect; }
/// <summary> /// Check that two double precision rectangles overlap with each other /// </summary> /// <param name="rect1">The first rectangle</param> /// <param name="rect2">The second rectangle</param> /// <returns>The rectangles overlap</returns> public bool DoesEitherRectangleOverlapTheOther(DoubleRectangle rect1, DoubleRectangle rect2) { if (IsEitherRectangleAdjacentToTheOther(rect1, rect2)) { return(true); } bool leftOfRect1InsideRect2Width = ValuesOverlap(rect1.X, rect2.X, rect2.X + rect2.Width); bool leftOfRect2InsideRect1Width = ValuesOverlap(rect2.X, rect1.X, rect1.X + rect1.Width); bool xOverlap = leftOfRect1InsideRect2Width || leftOfRect2InsideRect1Width; bool topOfRect1InsideRect2Height = ValuesOverlap(rect1.Y, rect2.Y, rect2.Y + rect2.Height); bool topOfRect2InsideRect1Height = ValuesOverlap(rect2.Y, rect1.Y, rect1.Y + rect1.Height); bool yOverlap = topOfRect1InsideRect2Height || topOfRect2InsideRect1Height; bool rectanglesIntersect = xOverlap && yOverlap && !DoesEitherRectangleContainTheOther(rect1, rect2); return(rectanglesIntersect); }
public void DoesEitherRectangleContainTheOther_LeftSideRect1ExtendsPast_ReturnsFalse() { /*Picture of rectangle location 0000 1110 1110 0000 */ DoubleRectangle rectangle1 = new DoubleRectangle(0, 1, 2, 1); /*Picture of rectangle location 0222 0202 0202 0222 */ DoubleRectangle rectangle2 = new DoubleRectangle(1, 0, 3, 4); var isContained = RectangleMathHelper.DoesEitherRectangleContainTheOther(rectangle1, rectangle2); Assert.IsFalse(isContained); }
/// <summary> /// True if either rectangle is adjacent to the other rectangle /// </summary> /// <param name="rect1">The first rectangle</param> /// <param name="rect2">The second rectangle</param> /// <returns>At least one rectangle is adjacent to the other rectangle</returns> public bool IsEitherRectangleAdjacentToTheOther(DoubleRectangle rect1, DoubleRectangle rect2) { bool overlapsWithRect2Left = rect1.X.Equals(rect2.X) || rect1.RightSideX.Equals(rect2.X); bool overlapsWithRect2Right = rect1.X.Equals(rect2.RightSideX) || rect1.RightSideX.Equals(rect2.RightSideX); bool overlapsWithRect2Top = rect1.Y.Equals(rect2.Y) || rect1.BotY.Equals(rect2.Y); bool overlapsWithRect2Bottom = rect1.Y.Equals(rect2.BotY) || rect1.BotY.Equals(rect2.BotY); if (overlapsWithRect2Left || overlapsWithRect2Right) { bool isWithinYAxis = ValuesOverlap(rect1.Y, rect2.Y, rect2.BotY) || ValuesOverlap(rect1.BotY, rect2.Y, rect2.BotY); return(isWithinYAxis); } if (overlapsWithRect2Bottom || overlapsWithRect2Top) { bool isWithinXAxis = ValuesOverlap(rect1.X, rect2.X, rect2.RightSideX) || ValuesOverlap(rect1.RightSideX, rect2.X, rect2.RightSideX); return(isWithinXAxis); } return(false); }
/// <summary> /// True if either rectangle is adjacent to the other rectangle /// </summary> /// <param name="rect1">The first rectangle</param> /// <param name="rect2">The second rectangle</param> /// <returns>At least one rectangle is adjacent to the other rectangle</returns> public bool IsEitherRectangleAdjacentToTheOther(DoubleRectangle rect1, DoubleRectangle rect2) { bool overlapsWithRect2Left = rect1.X.Equals(rect2.X) || rect1.RightSideX.Equals(rect2.X); bool overlapsWithRect2Right = rect1.X.Equals(rect2.RightSideX) || rect1.RightSideX.Equals(rect2.RightSideX); bool overlapsWithRect2Top = rect1.Y.Equals(rect2.Y) || rect1.BotY.Equals(rect2.Y); bool overlapsWithRect2Bottom = rect1.Y.Equals(rect2.BotY) || rect1.BotY.Equals(rect2.BotY); if (overlapsWithRect2Left || overlapsWithRect2Right) { bool isWithinYAxis = ValuesOverlap(rect1.Y, rect2.Y, rect2.BotY) || ValuesOverlap(rect1.BotY, rect2.Y, rect2.BotY); return isWithinYAxis; } if(overlapsWithRect2Bottom || overlapsWithRect2Top) { bool isWithinXAxis = ValuesOverlap(rect1.X, rect2.X, rect2.RightSideX) || ValuesOverlap(rect1.RightSideX, rect2.X, rect2.RightSideX); return isWithinXAxis; } return false; }
public void DoesEitherRectangleContainTheOther_BottomSideRect2ExtendsPast_ReturnsFalse() { /*Picture of rectangle location 0000 0110 0110 0110 */ DoubleRectangle rectangle1 = new DoubleRectangle(1, 1, 1, 2); /*Picture of rectangle location 2222 2002 2222 0000 */ DoubleRectangle rectangle2 = new DoubleRectangle(0, 0, 3, 2); var isContained = RectangleMathHelper.DoesEitherRectangleContainTheOther(rectangle2, rectangle1); Assert.IsFalse(isContained); }
public void Draw(Texture2D texture, Vector2 position, DoubleRectangle? sourceRectangle, ShaderEffect shaderEffect, float rotation, Vector2 origin, Vector2 scale, SpriteEffects effects, float layerDepth) { DrawCommand cmd = GetRenderer().GetAvailableCommand(); cmd.CommandType = DrawCommand.DrawCommandType.Texture; cmd.Texture = texture; cmd.Position = position; cmd.ShaderEffect = shaderEffect; cmd.Rotation = rotation; cmd.Origin = origin; if (sourceRectangle != null) { cmd.SourceRectangle = sourceRectangle.Value; } else { cmd.SourceRectangle = DoubleRectangle.FromRectangle(texture.SourceRect); } cmd.Scale = scale; cmd.Effects = effects; cmd.LayerDepth = layerDepth; }
public void DoesEitherRectangleContainTheOther_BottomSideRect2ExtendsPast_ReturnsFalse() { /*Picture of rectangle location * 0000 * 0110 * 0110 * 0110 */ DoubleRectangle rectangle1 = new DoubleRectangle(1, 1, 1, 2); /*Picture of rectangle location * 2222 * 2002 * 2222 * 0000 */ DoubleRectangle rectangle2 = new DoubleRectangle(0, 0, 3, 2); var isContained = RectangleMathHelper.DoesEitherRectangleContainTheOther(rectangle2, rectangle1); Assert.IsFalse(isContained); }
public void DoesEitherRectangleContainTheOther_NoOverlapAtAll_ReturnsFalse() { /*Picture of rectangle location * 1100 * 1100 * 0000 * 0000 */ DoubleRectangle rectangle1 = new DoubleRectangle(0, 0, 1, 1); /*Picture of rectangle location * 0000 * 0000 * 0022 * 0022 */ DoubleRectangle rectangle2 = new DoubleRectangle(2, 2, 1, 1); var isContained = RectangleMathHelper.DoesEitherRectangleContainTheOther(rectangle1, rectangle2); Assert.IsFalse(isContained); }
public void IsEitherRectangleAdjacentToTheOther_NoSideAdjacent_ReturnsFalse() { /*Picture of rectangle location * 1100 * 1100 * 0000 * 0000 */ DoubleRectangle rectangle1 = new DoubleRectangle(0, 0, 1, 1); /*Picture of rectangle location * 0000 * 0000 * 0022 * 0022 */ DoubleRectangle rectangle2 = new DoubleRectangle(2, 2, 1, 1); var isAdjacent = RectangleMathHelper.IsEitherRectangleAdjacentToTheOther(rectangle1, rectangle2); Assert.IsFalse(isAdjacent); }
public void IsEitherRectangleAdjacentToTheOther_BottomSideRect2Adjacent_ReturnsTrue() { /*Picture of rectangle location * 0000 * 1100 * 1100 * 0000 */ DoubleRectangle rectangle1 = new DoubleRectangle(0, 1, 1, 1); /*Picture of rectangle location * 0220 * 0220 * 0220 * 0000 */ DoubleRectangle rectangle2 = new DoubleRectangle(1, 0, 1, 2); var isAdjacent = RectangleMathHelper.IsEitherRectangleAdjacentToTheOther(rectangle2, rectangle1); Assert.IsTrue(isAdjacent); }
public void IsEitherRectangleAdjacentToTheOther_RightSideRect1Adjacent_ReturnsTrue() { /*Picture of rectangle location * 0110 * 0110 * 0000 * 0000 */ DoubleRectangle rectangle1 = new DoubleRectangle(1, 0, 1, 1); /*Picture of rectangle location * 0000 * 2220 * 2220 * 0000 */ DoubleRectangle rectangle2 = new DoubleRectangle(0, 0, 2, 1); var isAdjacent = RectangleMathHelper.IsEitherRectangleAdjacentToTheOther(rectangle1, rectangle2); Assert.IsTrue(isAdjacent); }
public void DoesEitherRectangleContainTheOther_LeftSideRect2ExtendsPast_ReturnsFalse() { /*Picture of rectangle location * 0000 * 1110 * 1110 * 0000 */ DoubleRectangle rectangle1 = new DoubleRectangle(0, 1, 2, 1); /*Picture of rectangle location * 0222 * 0202 * 0202 * 0222 */ DoubleRectangle rectangle2 = new DoubleRectangle(1, 0, 2, 3); var isContained = RectangleMathHelper.DoesEitherRectangleContainTheOther(rectangle2, rectangle1); Assert.IsFalse(isContained); }
public void DoesEitherRectangleOverlapTheOther_OneContainsTheOther_ReturnsFalse() { /*Picture of rectangle location * 1111 * 1001 * 1001 * 1111 */ DoubleRectangle rectangle1 = new DoubleRectangle(0, 0, 4, 4); /*Picture of rectangle location * 0000 * 0220 * 0220 * 0000 */ DoubleRectangle rectangle2 = new DoubleRectangle(1, 1, 1, 1); var isOverlapping = RectangleMathHelper.DoesEitherRectangleOverlapTheOther(rectangle1, rectangle2); Assert.IsFalse(isOverlapping); }
public void DoesEitherRectangleContainTheOther_RightSideRect1ExtendsPast_ReturnsFalse() { /*Picture of rectangle location * 0000 * 0111 * 0111 * 0000 */ DoubleRectangle rectangle1 = new DoubleRectangle(1, 1, 2, 1); /*Picture of rectangle location * 2220 * 2020 * 2020 * 2220 */ DoubleRectangle rectangle2 = new DoubleRectangle(0, 0, 2, 3); var isContained = RectangleMathHelper.DoesEitherRectangleContainTheOther(rectangle1, rectangle2); Assert.IsFalse(isContained); }
public void DoesEitherRectangleContainTheOther_RectTwoContainsRectOne_ReturnsTrue() { /*Picture of rectangle location * 0000 * 0110 * 0110 * 0000 */ DoubleRectangle rectangle1 = new DoubleRectangle(1, 1, 1, 1); /*Picture of rectangle location * 2222 * 2002 * 2002 * 2222 */ DoubleRectangle rectangle2 = new DoubleRectangle(0, 0, 4, 4); var isContained = RectangleMathHelper.DoesEitherRectangleContainTheOther(rectangle1, rectangle2); Assert.IsTrue(isContained); }
public void TestAll_ValidInput_ReturnsValidJson() { Rectangle rect1 = new Rectangle() { StartX = 1, StartY = 2, Width = 3, Height = 4 }; Rectangle rect2 = new Rectangle() { StartX = 5, StartY = 6, Width = 7, Height = 8 }; DoubleRectangle doubleRect1 = new DoubleRectangle(1, 2, 3, 4); DoubleRectangle doubleRect2 = new DoubleRectangle(5, 6, 7, 8); _doubleRectangleFactory.Expect(x => x.CreateDoubleRectangleFromWebCoordinates(1, 2, 3, 4)).Return(doubleRect1); _doubleRectangleFactory.Expect(x => x.CreateDoubleRectangleFromWebCoordinates(5, 6, 7, 8)).Return(doubleRect1); _rectangleMathHelper.Expect(x => x.DoesEitherRectangleContainTheOther(doubleRect1, doubleRect2)).Return(true).IgnoreArguments(); _rectangleMathHelper.Expect(x => x.DoesEitherRectangleOverlapTheOther(doubleRect1, doubleRect2)).Return(true).IgnoreArguments(); _rectangleMathHelper.Expect(x => x.IsEitherRectangleAdjacentToTheOther(doubleRect1, doubleRect2)).Return(true).IgnoreArguments(); var actionReturn = _rectangleProcessorController.TestAll(rect1, rect2); Assert.IsInstanceOfType(actionReturn, typeof(JsonResult)); JsonResult jsonReturn = (JsonResult)actionReturn; Assert.AreEqual("{ isOverlap = True, isContain = True, isAdjacent = True }", jsonReturn.Data.ToString()); _rectangleMathHelper.VerifyAllExpectations(); _doubleRectangleFactory.VerifyAllExpectations(); }
public void DoesEitherRectangleOverlapTheOther_BothXOverlapEachOther_BothYOverlapEachOther_ReturnsTrue() { //1111 /*Picture of rectangle location * 1100 * 1100 * 0000 * 0000 */ DoubleRectangle rectangle1 = new DoubleRectangle(0, 0, 1, 1); /*Picture of rectangle location * 2200 * 2200 * 0000 * 0000 */ DoubleRectangle rectangle2 = new DoubleRectangle(0, 0, 1, 1); var isOverlapping = RectangleMathHelper.DoesEitherRectangleOverlapTheOther(rectangle1, rectangle2); Assert.IsTrue(isOverlapping); }
public void DoesEitherRectangleOverlapTheOther_DoesNotOverlapAtAll_ReturnsFalse() { //0000 /*Picture of rectangle location * 1100 * 1100 * 0000 * 0000 */ DoubleRectangle rectangle1 = new DoubleRectangle(0, 0, 1, 1); /*Picture of rectangle location * 0022 * 0022 * 0000 * 0000 */ DoubleRectangle rectangle2 = new DoubleRectangle(2, 2, 1, 1); var isOverlapping = RectangleMathHelper.DoesEitherRectangleOverlapTheOther(rectangle1, rectangle2); Assert.IsFalse(isOverlapping); }
public void DoesEitherRectangleOverlapTheOther_LeftOfRect1WithinRect2XArea_BothYOverlapEachOther_ReturnsTrue() { //1011 /*Picture of rectangle location * 0110 * 0110 * 0000 * 0000 */ DoubleRectangle rectangle1 = new DoubleRectangle(1, 0, 1, 1); /*Picture of rectangle location * 2220 * 2220 * 0000 * 0000 */ DoubleRectangle rectangle2 = new DoubleRectangle(0, 0, 2, 1); var isOverlapping = RectangleMathHelper.DoesEitherRectangleOverlapTheOther(rectangle1, rectangle2); Assert.IsTrue(isOverlapping); }
public void DoesEitherRectangleOverlapTheOther_LeftOfRect2WithinRect1XArea_YDoesntOverlap_ReturnsFalse() { //0100 /*Picture of rectangle location * 0000 * 0000 * 1110 * 1110 */ DoubleRectangle rectangle1 = new DoubleRectangle(0, 2, 2, 1); /*Picture of rectangle location * 0220 * 0220 * 0000 * 0000 */ DoubleRectangle rectangle2 = new DoubleRectangle(1, 0, 1, 1); var isOverlapping = RectangleMathHelper.DoesEitherRectangleOverlapTheOther(rectangle1, rectangle2); Assert.IsFalse(isOverlapping); }
public void DoesEitherRectangleOverlapTheOther_XDoesntOverlap_TopOfRect2YWithinRect1YArea_ReturnsFalse() { //0010 /*Picture of rectangle location * 0000 * 1100 * 1100 * 1100 */ DoubleRectangle rectangle1 = new DoubleRectangle(0, 1, 1, 2); /*Picture of rectangle location * 0022 * 0022 * 0000 * 0000 */ DoubleRectangle rectangle2 = new DoubleRectangle(2, 0, 1, 1); var isOverlapping = RectangleMathHelper.DoesEitherRectangleOverlapTheOther(rectangle1, rectangle2); Assert.IsFalse(isOverlapping); }
public void DoesEitherRectangleOverlapTheOther_LeftOfRect2WithinRect1XArea_TopOfRect2YWithinRect1YArea_ReturnsTrue() { //0110 /*Picture of rectangle location * 0000 * 1110 * 1010 * 1110 */ DoubleRectangle rectangle1 = new DoubleRectangle(0, 1, 2, 2); /*Picture of rectangle location * 0222 * 0202 * 0222 * 0000 */ DoubleRectangle rectangle2 = new DoubleRectangle(1, 0, 2, 2); var isOverlapping = RectangleMathHelper.DoesEitherRectangleOverlapTheOther(rectangle1, rectangle2); Assert.IsTrue(isOverlapping); }
private static void DrawSprites( List <VertexPositionColorTexture[]> spriteVertices, List <RenderBreak> mSpriteRenderBreaks, List <Sprite> spritesToDraw, int startIndex, int numberToDraw, Camera camera) { //public static void DrawSprites<T>(IList<T> spritesToDraw, int startIndex, int numberToDraw, Camera camera) where T : Sprite //{ DrawSpritesNew(spritesToDraw, startIndex, numberToDraw, camera); return; if (numberToDraw == 0) { return; } // Vic says: I don't think this is needed now that the Renderer is handling mixed drawing //mAutomaticallyUpdatedSprites.SortZInsertionAscending(); SpriteBlendMode lastBlendMode = SpriteBlendMode.AlphaBlend; // Vic says: At the time of this writing Additive blend isn't working properly if (spritesToDraw[startIndex].BlendOperation == BlendOperation.Add) { lastBlendMode = SpriteBlendMode.Additive; } Matrix lookAtMatrix = camera.GetLookAtMatrix(); GraphicsBatch.Begin(lastBlendMode, SpriteSortMode.Immediate, SaveStateMode.None, lookAtMatrix ); int endIndex = startIndex + numberToDraw; for (int i = startIndex; i < endIndex; i++) { Sprite s = spritesToDraw[i]; if (s.BlendOperation == BlendOperation.Add && lastBlendMode == SpriteBlendMode.AlphaBlend) { lastBlendMode = SpriteBlendMode.Additive; GraphicsBatch.End(); GraphicsBatch.Begin(lastBlendMode, SpriteSortMode.Immediate, SaveStateMode.None, lookAtMatrix); } if (s.BlendOperation == BlendOperation.Regular && lastBlendMode == SpriteBlendMode.Additive) { lastBlendMode = SpriteBlendMode.AlphaBlend; GraphicsBatch.End(); GraphicsBatch.Begin(lastBlendMode, SpriteSortMode.Immediate, SaveStateMode.None, lookAtMatrix); } // Cache this to speed up calls Color whiteColor = Color.White; if (camera.IsSpriteInView(s)) { //SpriteBatch.Draw(s.Texture, new Vector2(0, 0), Color.Black); float x = s.X; float y = s.Y; if (s.Visible && s.Texture != null) { float leftPixel = 0; float rightPixel = 32; float topPixel = 0; float bottomPixel = 32; float textureWidth = 32; float textureHeight = 32; if (s.Texture != null) { leftPixel = s.LeftTextureCoordinate * s.Texture.Width; rightPixel = s.RightTextureCoordinate * s.Texture.Width; topPixel = s.TopTextureCoordinate * s.Texture.Height; bottomPixel = s.BottomTextureCoordinate * s.Texture.Height; textureWidth = (float)s.Texture.Width; textureHeight = (float)s.Texture.Height; } DoubleRectangle textureRectangle = new DoubleRectangle(leftPixel, topPixel, rightPixel - leftPixel, bottomPixel - topPixel); float xOffsetForTopLeftDrawing = -s.ScaleX; float yOffsetForTopLeftDrawing = -s.ScaleY; // positive rotation should be counterclockwise, but for some reason // it's clockwise. Invert for now. Man, I don't like these hacks. float rotationToUse = -s.RotationZ; FlatRedBall.Math.MathFunctions.RotatePointAroundPoint( 0, 0, ref xOffsetForTopLeftDrawing, ref yOffsetForTopLeftDrawing, rotationToUse); Vector2 position = new Vector2(x + xOffsetForTopLeftDrawing, // - s.ScaleX, -y + yOffsetForTopLeftDrawing); // - s.ScaleY); Vector2 origin = new Vector2(0, 0); // this keeps gaps from happening const float extraScale = .05f; Vector2 scale = new Vector2( (extraScale + 2 * s.ScaleX) / (float)textureRectangle.Width, (extraScale + 2 * s.ScaleY) / (float)textureRectangle.Height); ShaderEffect effect = Renderer.GetShaderEffectForColorOperation(s.ColorOperation, s.Red, s.Green, s.Blue, s.Alpha); SpriteEffects flipValue = SpriteEffects.None; if (s.FlipHorizontal) { flipValue |= SpriteEffects.FlipHorizontally; } if (s.FlipVertical) { flipValue |= SpriteEffects.FlipVertically; } if (effect == null) { whiteColor.A = (byte)(255 * s.Alpha); GraphicsBatch.Draw(s.Texture, position, textureRectangle, whiteColor, rotationToUse, origin, scale, //scale flipValue, 0); } else { GraphicsBatch.Draw(s.Texture, position, textureRectangle, effect, rotationToUse, origin, scale, //scale flipValue, 0); } } } } GraphicsBatch.End(); }
public void IsEitherRectangleAdjacentToTheOther_NoSideAdjacent_ReturnsFalse() { /*Picture of rectangle location 1100 1100 0000 0000 */ DoubleRectangle rectangle1 = new DoubleRectangle(0, 0, 1, 1); /*Picture of rectangle location 0000 0000 0022 0022 */ DoubleRectangle rectangle2 = new DoubleRectangle(2, 2, 1, 1); var isAdjacent = RectangleMathHelper.IsEitherRectangleAdjacentToTheOther(rectangle1, rectangle2); Assert.IsFalse(isAdjacent); }
public void Draw(Texture2D texture, Vector2 position, ref DoubleRectangle sourceRectangle, Color color, float rotation, Vector2 origin, Vector2 scale, SpriteEffects effects, float layerDepth) { Blit(texture.ImageSource, position, ref sourceRectangle, color, scale, origin, effects); }
public void DrawString(SpriteFont spriteFont, string text, Vector2 position, Color color, float rotation, Vector2 origin, Vector2 scale, SpriteEffects effects, float layerDepth) { origin = origin * scale; if (color.A == 0 && blendMode == SpriteBlendMode.AlphaBlend) return; if (spriteFont is BitmapSpriteFont) { BitmapSpriteFont font = spriteFont as BitmapSpriteFont; Vector2 pos = Vector2.Zero; foreach (char c in text) { if (c == '\n') { pos.Y += font.LineSpacing; pos.X = 0; continue; } if (font.characterData.ContainsKey(c) == false) continue; GlyphData g = font.characterData[c]; DoubleRectangle rect = new DoubleRectangle(g.Glyph.X, g.Glyph.Y, g.Glyph.Width, g.Glyph.Height); Blit(font.SourceData, position - origin + pos + new Vector2(g.Cropping.X * scale.X, g.Cropping.Y * scale.Y), ref rect, color, scale, Vector2.Zero, effects); pos.X += (g.Kerning.Y + g.Kerning.Z + font.Spacing) * scale.X; } } else { _text.Text = text; _text.FontFamily = spriteFont.FontFamily; _text.FontSize = spriteFont.FontSize; _text.Foreground = new SWM.SolidColorBrush(color.ToSilverlightColor()); _textTranslate.X = position.X; _textTranslate.Y = position.Y; _bmp.Invalidate(); _bmp.Render(_text, _textTranslate); _bmp.Invalidate(); } }
public void DoesEitherRectangleContainTheOther_RectTwoContainsRectOne_ReturnsTrue() { /*Picture of rectangle location 0000 0110 0110 0000 */ DoubleRectangle rectangle1 = new DoubleRectangle(1, 1, 1, 1); /*Picture of rectangle location 2222 2002 2002 2222 */ DoubleRectangle rectangle2 = new DoubleRectangle(0, 0, 4, 4); var isContained = RectangleMathHelper.DoesEitherRectangleContainTheOther(rectangle1, rectangle2); Assert.IsTrue(isContained); }
public void Draw(Texture2D texture, Vector2 position, DoubleRectangle? sourceRectangle, ShaderEffect shaderEffect, float rotation, Vector2 origin, Vector2 scale, SpriteEffects effects, float layerDepth) { if (sourceRectangle == null || sourceRectangle.Value.IsEmpty) { SpriteImage d = GetSprite(texture); if (d.ZIndex < zIndex) { d.ZIndex = zIndex; } else { zIndex = d.ZIndex; } zIndex++; d.InUse = true; d.PositionX = position.X; d.PositionY = position.Y; d.Scale = new Vector2((float)scale.X, (float)scale.Y); d.Rotation = rotation; d.Origin = origin; d.Effects = effects; d.CustomEffect = shaderEffect; } else { ClippedSpriteImage d = GetClippedSprite(texture); if (d.ZIndex < zIndex) { d.ZIndex = zIndex; } else { zIndex = d.ZIndex; } zIndex++; d.InUse = true; d.SourceRectangle = sourceRectangle.Value; d.PositionX = position.X; d.PositionY = position.Y; d.Scale = new Vector2((float)scale.X, (float)scale.Y); d.Rotation = rotation; d.Origin = origin; d.Effects = effects; d.CustomEffect = shaderEffect; } }
public void CreateDoubleRectangleFromWebCoordinates_WidthIsPositive_LeaveAsPositive() { DoubleRectangle rect = DoubleRectangleFactory.CreateDoubleRectangleFromWebCoordinates(4, 3, 2, 1); Assert.AreEqual(2, rect.Width); }
public void DoesEitherRectangleOverlapTheOther_BothXOverlapEachOther_TopOfRect1YWithinRect2YArea_ReturnsTrue() { //1110 /*Picture of rectangle location 0000 1100 1100 0000 */ DoubleRectangle rectangle1 = new DoubleRectangle(0, 1, 1, 1); /*Picture of rectangle location 2200 2200 0000 0000 */ DoubleRectangle rectangle2 = new DoubleRectangle(0, 0, 1, 1); var isOverlapping = RectangleMathHelper.DoesEitherRectangleOverlapTheOther(rectangle1, rectangle2); Assert.IsTrue(isOverlapping); }
public void CreateDoubleRectangleFromWebCoordinates_HeightIsPositive_YIsStartY() { DoubleRectangle rect = DoubleRectangleFactory.CreateDoubleRectangleFromWebCoordinates(1, 2, 3, 4); Assert.AreEqual(2, rect.Y); }
public void CreateDoubleRectangleFromWebCoordinates_HeightIsNegative_YIsStartYMinusHeight() { DoubleRectangle rect = DoubleRectangleFactory.CreateDoubleRectangleFromWebCoordinates(4, 3, 2, -1); Assert.AreEqual(2, rect.Y); }
public void CreateDoubleRectangleFromWebCoordinates_WidthIsNegative_XIsStartXMinusWidth() { DoubleRectangle rect = DoubleRectangleFactory.CreateDoubleRectangleFromWebCoordinates(4, 3, -2, 1); Assert.AreEqual(2, rect.X); }
public void CreateDoubleRectangleFromWebCoordinates_WidthIsPositive_XIsStartX() { DoubleRectangle rect = DoubleRectangleFactory.CreateDoubleRectangleFromWebCoordinates(1, 2, 3, 4); Assert.AreEqual(1, rect.X); }
public void IsEitherRectangleAdjacentToTheOther_TopSideRect2Adjacent_ReturnsTrue() { /*Picture of rectangle location 1100 1100 0000 0000 */ DoubleRectangle rectangle1 = new DoubleRectangle(0, 0, 1, 1); /*Picture of rectangle location 0220 0220 0220 0000 */ DoubleRectangle rectangle2 = new DoubleRectangle(1, 0, 1, 2); var isAdjacent = RectangleMathHelper.IsEitherRectangleAdjacentToTheOther(rectangle2, rectangle1); Assert.IsTrue(isAdjacent); }
/// <summary> /// True if either rectangle is entirely contained within the other rectangle /// </summary> /// <param name="rect1">The first rectangle</param> /// <param name="rect2">The second rectangle</param> /// <returns>At least one rectangle is contained within the other</returns> public bool DoesEitherRectangleContainTheOther(DoubleRectangle rect1, DoubleRectangle rect2) { return(ContainedWithin(rect1, rect2) || ContainedWithin(rect2, rect1)); }
public void CreateDoubleRectangleFromWebCoordinates_WidthIsNegative_ConvertToPositive() { DoubleRectangle rect = DoubleRectangleFactory.CreateDoubleRectangleFromWebCoordinates(4, 3, -2, 1); Assert.AreEqual(2, rect.Width); }
public void DoesEitherRectangleOverlapTheOther_LeftOfRect1WithinRect2XArea_TopOfRect2YWithinRect1YArea_ReturnsTrue() { //1001 /*Picture of rectangle location 0110 0110 0000 0000 */ DoubleRectangle rectangle1 = new DoubleRectangle(1, 0, 1, 1); /*Picture of rectangle location 0000 2220 2220 0000 */ DoubleRectangle rectangle2 = new DoubleRectangle(0, 1, 2, 1); var isOverlapping = RectangleMathHelper.DoesEitherRectangleOverlapTheOther(rectangle1, rectangle2); Assert.IsTrue(isOverlapping); }
public void CreateDoubleRectangleFromWebCoordinates_HeightIsPositive_LeaveAsPositive() { DoubleRectangle rect = DoubleRectangleFactory.CreateDoubleRectangleFromWebCoordinates(4, 3, 2, 1); Assert.AreEqual(1, rect.Height); }
/// <summary> /// True if either rectangle is entirely contained within the other rectangle /// </summary> /// <param name="rect1">The first rectangle</param> /// <param name="rect2">The second rectangle</param> /// <returns>At least one rectangle is contained within the other</returns> public bool DoesEitherRectangleContainTheOther(DoubleRectangle rect1, DoubleRectangle rect2) { return ContainedWithin(rect1, rect2) || ContainedWithin(rect2, rect1); }
public void CreateDoubleRectangleFromWebCoordinates_HeightIsNegative_ConvertToPositive() { DoubleRectangle rect = DoubleRectangleFactory.CreateDoubleRectangleFromWebCoordinates(4, 3, 2, -1); Assert.AreEqual(1, rect.Height); }
public void DoesEitherRectangleContainTheOther_NoOverlapAtAll_ReturnsFalse() { /*Picture of rectangle location 1100 1100 0000 0000 */ DoubleRectangle rectangle1 = new DoubleRectangle(0, 0, 1, 1); /*Picture of rectangle location 0000 0000 0022 0022 */ DoubleRectangle rectangle2 = new DoubleRectangle(2, 2, 1, 1); var isContained = RectangleMathHelper.DoesEitherRectangleContainTheOther(rectangle1, rectangle2); Assert.IsFalse(isContained); }
protected virtual void Draw(Texture2D texture, Vector2 position, ref DoubleRectangle sourceRectangle, ShaderEffect shaderEffect, float rotation, Vector2 origin, Vector2 scale, SpriteEffects effects, float layerDepth) { }
void Blit(WriteableBitmap source, Vector2 position, ref DoubleRectangle sourceRectangle, Color color, Vector2 scale, Vector2 origin, SpriteEffects effects) { int sourceWidth = source.PixelWidth; int sourceHeight = source.PixelHeight; int[] sourcePixels = source.Pixels; int[] destPixels = _bmp.Pixels; int sourceLength = sourcePixels.Length; int destLength = destPixels.Length; if (color.A == 0) return; Root.Rectangle DestinationRect = new Root.Rectangle(); GetDestinationRect(ref DestinationRect, position, ref sourceRectangle, scale, origin); scale.X = (float)(DestinationRect.Width / sourceRectangle.Width); scale.Y = (float)(DestinationRect.Height / sourceRectangle.Height); foreach (DirtyQuad q in _quads.GetDirtyQuads(DestinationRect)) { int sourceIdx = -1; int px = Math.Max(q.BoundingRect.X, DestinationRect.X); int py = Math.Max(q.BoundingRect.Y, DestinationRect.Y); int right = Math.Min(q.BoundingRect.Right, DestinationRect.Right); int bottom = Math.Min(q.BoundingRect.Bottom, DestinationRect.Bottom); int dw = right - px; int dh = bottom - py; int x; int y; int idx; float ii; float jj; int sr = 0; int sg = 0; int sb = 0; int dr, dg, db; int sourcePixel; int sa = 0; int da; int ca = color.A; int cr = color.R; int cg = color.G; int cb = color.B; bool tinted = color.PackedValue != 0xffffffff; bool hflip = (effects & SpriteEffects.FlipHorizontally) == SpriteEffects.FlipHorizontally; bool vflip = (effects & SpriteEffects.FlipVertically) == SpriteEffects.FlipVertically; float sdx = 1 / scale.X; float sdy = 1 / scale.Y; float sourceStartX = (float)sourceRectangle.Left + ((px - DestinationRect.X) * sdx) + sdx/2; float sourceStartY = (float)sourceRectangle.Top + ((py - DestinationRect.Y) * sdy) + sdy/2; int lastii, lastjj; lastii = -1; lastjj = -1; if (hflip) { sourceStartX = (float)sourceRectangle.Right - ((px - DestinationRect.X) / scale.X) - sdx/2; sdx = -sdx; } if (vflip) { sourceStartY = (float)sourceRectangle.Bottom - ((py - DestinationRect.Y) / scale.Y) - sdy/2; sdy = -sdy; } jj = sourceStartY; y = py; for (int j = 0; j < dh; j++) { ii = sourceStartX; idx = px + y * _width; x = px; sourcePixel = sourcePixels[0]; for (int i = 0; i < dw; i++) { int ir = (int)(ii); int jr = (int)(jj); if (ir < sourceWidth && jr < sourceHeight) { if (ir != lastii || jr != lastjj) { lastii = ir; lastjj = jr; sourceIdx = ir + jr * sourceWidth; if (sourceIdx >= 0 && sourceIdx < sourceLength) { sourcePixel = sourcePixels[sourceIdx]; sa = ((sourcePixel >> 24) & 0xff); sr = ((sourcePixel >> 16) & 0xff); sg = ((sourcePixel >> 8) & 0xff); sb = ((sourcePixel) & 0xff); if (tinted && sa != 0) { sa = (((sa * ca) * 0x8081) >> 23); sr = ((((((sr * cr) * 0x8081) >> 23) * ca) * 0x8081) >> 23); sg = ((((((sg * cg) * 0x8081) >> 23) * ca) * 0x8081) >> 23); sb = ((((((sb * cb) * 0x8081) >> 23) * ca) * 0x8081) >> 23); sourcePixel = (sa << 24) | (sr << 16) | (sg << 8) | sb; } } else { sa = 0; } } if (blendMode == SpriteBlendMode.None) { destPixels[idx] = sourcePixel; } else if (sa > 0) { int destPixel = destPixels[idx]; da = ((destPixel >> 24) & 0xff); if ((sa == 255 || da == 0) && blendMode != SpriteBlendMode.Additive) { destPixels[idx] = sourcePixel; } else { dr = ((destPixel >> 16) & 0xff); dg = ((destPixel >> 8) & 0xff); db = ((destPixel) & 0xff); if (blendMode == SpriteBlendMode.AlphaBlend) { #if false destPixel = ((sa + blend(da, (255 - sa))) << 24) | ((sr + blend(dr, 255-sa)) << 16) | ((sg + blend(dg, 255-sa)) << 8) | ((sb + blend(db, 255-sa))); #endif destPixel = ((sa + (((da * (255 - sa)) * 0x8081) >> 23)) << 24) | ((sr + (((dr * (255 - sa)) * 0x8081) >> 23)) << 16) | ((sg + (((dg * (255 - sa)) * 0x8081) >> 23)) << 8) | ((sb + (((db * (255 - sa)) * 0x8081) >> 23))); } else if (blendMode == SpriteBlendMode.Additive) { int a = 255 <= sa + da ? 255 : sa + da; destPixel = (a << 24) | ((a <= sr + dr ? a : sr + dr) << 16) | ((a <= sg + dg ? a : sg + dg) << 8) | ((a <= sb + db ? a : sb + db)); } destPixels[idx] = destPixel; } } } x++; idx++; ii += sdx; } jj += sdy; y++; } } }
public void DoesEitherRectangleOverlapTheOther_OneContainsTheOther_ReturnsFalse() { /*Picture of rectangle location 1111 1001 1001 1111 */ DoubleRectangle rectangle1 = new DoubleRectangle(0, 0, 4, 4); /*Picture of rectangle location 0000 0220 0220 0000 */ DoubleRectangle rectangle2 = new DoubleRectangle(1, 1, 1, 1); var isOverlapping = RectangleMathHelper.DoesEitherRectangleOverlapTheOther(rectangle1, rectangle2); Assert.IsFalse(isOverlapping); }
public void Draw(Texture2D texture, Vector2 position, ref DoubleRectangle sourceRectangle, System.Windows.Media.Effects.ShaderEffect shaderEffect, float rotation, Vector2 origin, Vector2 scale, SpriteEffects effects, float layerDepth) { Blit(texture.ImageSource, position, ref sourceRectangle, Color.White, scale, origin, effects); }
public void DoesEitherRectangleOverlapTheOther_LeftOfRect2WithinRect1XArea_YDoesntOverlap_ReturnsFalse() { //0100 /*Picture of rectangle location 0000 0000 1110 1110 */ DoubleRectangle rectangle1 = new DoubleRectangle(0, 2, 2, 1); /*Picture of rectangle location 0220 0220 0000 0000 */ DoubleRectangle rectangle2 = new DoubleRectangle(1, 0, 1, 1); var isOverlapping = RectangleMathHelper.DoesEitherRectangleOverlapTheOther(rectangle1, rectangle2); Assert.IsFalse(isOverlapping); }
public void Draw(Texture2D texture, Vector2 position, DoubleRectangle? sourceRectangle, G.Color color, float rotation, Vector2 origin, Vector2 scale, SpriteEffects effects, float layerDepth) { if (sourceRectangle == null || sourceRectangle.Value.IsEmpty) { SpriteImage d = GetSprite(texture); if (d.ZIndex < zIndex) { d.ZIndex = zIndex; } else { zIndex = d.ZIndex; } zIndex++; d.InUse = true; if (color != d.color) d.Color = color; d.PositionX = position.X; d.PositionY = position.Y; d.Scale = new Vector2((float)scale.X, (float)scale.Y); d.Rotation = rotation; d.SetOriginAndEffects(origin, effects); d.CustomEffect = null; // this needs to get reset in case it's left-over from another call } else { ClippedSpriteImage d = GetClippedSprite(texture); if (d.ZIndex < zIndex) { d.ZIndex = zIndex; } else { zIndex = d.ZIndex; } zIndex++; d.InUse = true; if (color != d.color) d.Color = color; d.SourceRectangle = sourceRectangle.Value; d.PositionX = position.X; d.PositionY = position.Y; d.Scale = new Vector2((float)scale.X, (float)scale.Y); d.Rotation = rotation; d.SetOriginAndEffects(origin, effects); d.CustomEffect = null; // this needs to get reset in case it's left-over from another call } }
public void DoesEitherRectangleOverlapTheOther_LeftOfRect2WithinRect1XArea_BothYOverlapEachOther_ReturnsTrue() { //0111 /*Picture of rectangle location 1100 1100 0000 0000 */ DoubleRectangle rectangle1 = new DoubleRectangle(0, 0, 1, 1); /*Picture of rectangle location 0220 0220 0000 0000 */ DoubleRectangle rectangle2 = new DoubleRectangle(1, 0, 1, 1); var isOverlapping = RectangleMathHelper.DoesEitherRectangleOverlapTheOther(rectangle1, rectangle2); Assert.IsTrue(isOverlapping); }
public void DoesEitherRectangleOverlapTheOther_XDoesntOverlap_TopOfRect2YWithinRect1YArea_ReturnsFalse() { //0010 /*Picture of rectangle location 0000 1100 1100 1100 */ DoubleRectangle rectangle1 = new DoubleRectangle(0, 1, 1, 2); /*Picture of rectangle location 0022 0022 0000 0000 */ DoubleRectangle rectangle2 = new DoubleRectangle(2, 0, 1, 1); var isOverlapping = RectangleMathHelper.DoesEitherRectangleOverlapTheOther(rectangle1, rectangle2); Assert.IsFalse(isOverlapping); }
public void DoesEitherRectangleOverlapTheOther_XDoesntOverlap_BothYOverlapEachOther_ReturnsFalse() { //0011 /*Picture of rectangle location 1100 1100 0000 0000 */ DoubleRectangle rectangle1 = new DoubleRectangle(0, 0, 1, 1); /*Picture of rectangle location 0022 0022 0000 0000 */ DoubleRectangle rectangle2 = new DoubleRectangle(2, 0, 1, 1); var isOverlapping = RectangleMathHelper.DoesEitherRectangleOverlapTheOther(rectangle1, rectangle2); Assert.IsFalse(isOverlapping); }