private void _DrawPoint(Int32Point pos, byte[] color, int colorValue, int thickness = 1)
{
foreach (var point in GeometryHelper.CalcPositions(pos.X, pos.Y, Offset, Stride, thickness, _bounds, _flags))
{
_DrawPixel(point, color, colorValue);
}
}
private void MainWindow_MouseUp(object sender, MouseButtonEventArgs e)
{
_down = false;
InvalidateVisual();
// find rects selected
var x1 = (int)Math.Floor(_position1.X / (size.Width / columns));
var y1 = (int)Math.Floor(_position1.Y / (size.Height / rows));
var x2 = (int)Math.Ceiling(_position2.X / (size.Width / columns));
var y2 = (int)Math.Ceiling(_position2.Y / (size.Height / rows));
var w = x2 - x1;
var h = y2 - y1;
var builder = new StringBuilder();
for (var y = 0; y < h; y++)
{
for (var x = 0; x < w; x++)
{
var int32Point = new Int32Point(x1 + x, y1 + y);
var add = _set.Add(int32Point);
if (add)
{
// download image !!!
}
else
{
// image already downloaded, do something !
}
builder.AppendLine(string.Format("{0} : {1}", int32Point, (add ? "added" : "ignored")));
}
}
MessageBox.Show(builder.ToString());
}
public Ellipse(byte[] fillColor, Int32Point center, Int32 radiusX, Int32 radiusY, _DrawingPen pen)
{
_fillColor = fillColor;
Center = center;
RadiusX = radiusX;
RadiusY = radiusY;
RadiusXSquared = (Int64)RadiusX * RadiusX;
RadiusYSquared = (Int64)RadiusY * RadiusY;
SplitX = (Int32)(RadiusXSquared / Math.Sqrt(RadiusXSquared + RadiusYSquared));
A_2 = Math.Max(RadiusX, RadiusY) << 1;
Int32 c;
if (RadiusX > RadiusY)
{
c = (Int32)Math.Sqrt(RadiusXSquared - RadiusYSquared);
}
else
{
c = (Int32)Math.Sqrt(RadiusYSquared - RadiusXSquared);
}
if (radiusX > radiusY)
{
FocusP1 = new Int32Point(center.X + c, center.Y);
FocusP2 = new Int32Point(center.X - c, center.Y);
}
else
{
FocusP1 = new Int32Point(center.X, center.Y + c);
FocusP2 = new Int32Point(center.X, center.Y - c);
}
var _bounds = GeometryHelper.CalcBounds(center, radiusX, RadiusY, pen.Thickness);
_property = new PrimitiveProperty(pen, _bounds);
}
private List <Int32Point> GetCellNeighbours(Int32Point cell)
{
List <Int32Point> neighbours = new List <Int32Point> ();
if (cell != null)
{
int x = cell.X;
int y = cell.Y;
if (x > 0)
{
neighbours.Add(new Int32Point(x - 1, y));
}
if (x < Width - 1)
{
neighbours.Add(new Int32Point(x + 1, y));
}
if (y > 0)
{
neighbours.Add(new Int32Point(x, y - 1));
}
if (y < Height - 1)
{
neighbours.Add(new Int32Point(x, y + 1));
}
}
return(neighbours);
}
bool HasWallBetween(Int32Point cell1, Int32Point cell2)
{
Int32Point diff = cell1 - cell2;
WallType wallType = WallType.None;
if (diff.X != 0)
{
if (diff.X > 0)
{
wallType = WallType.Left;
}
else
{
wallType = WallType.Right;
}
}
else if (diff.Y != 0)
{
if (diff.Y < 0)
{
wallType = WallType.Top;
}
else
{
wallType = WallType.Bottom;
}
}
if (wallType != WallType.None)
{
return(mazeLayer.LayerArray [cell1.X, cell1.Y].GetComponent <CellBehavior> ().IsWallStanding(wallType));
}
return(false);
}
/// <summary>
/// Swaps the two given points.
/// </summary>
/// <param name="a">Point a.</param>
/// <param name="b">Point b.</param>
private static void Swap(ref Int32Point a, ref Int32Point b)
{
var tmp = a;
a = b;
b = tmp;
}
public DesignTimeGraphicsPixelHistoryViewModel()
: base(new DesignTimeSelectionService())
{
HasSelectedPixel = true;
FinalFrameBufferColor = new ColorViewModel(new Number4(0, 0, 1, 1));
FrameNumber = 2;
PixelLocation = new Int32Point(200, 305);
PixelEvents.AddRange(new[]
{
new PixelHistoryEventViewModel(new TracefileEvent
{
Number = 1,
OperationType = OperationType.DeviceContextClearRenderTargetView,
PixelEvents = new List <PixelEvent>(new[] { new SimpleEvent(new Number4(1, 0, 0, 1)) })
}),
new PixelHistoryEventViewModel(new TracefileEvent
{
Number = 15,
OperationType = OperationType.DeviceContextDraw,
PixelEvents = new List <PixelEvent>(new[]
{
DesignTimeDrawPixelHistoryEventViewModel.CreateDrawEvent(),
DesignTimeDrawPixelHistoryEventViewModel.CreateDrawEvent(PixelExclusionReason.FailedDepthTest)
})
}),
});
}
public void SetBits(Buffer2DView <T> srcView, Int32Rect srcRect, Int32Point?dstPoint = null)
{
if (srcRect.X < 0 || srcRect.Width < 0 || (srcRect.X + srcRect.Width) > srcView._buffer._bounds.Width ||
srcRect.Y < 0 || srcRect.Height < 0 || (srcRect.Y + srcRect.Height) > srcView._buffer._bounds.Height)
{
throw new ArgumentOutOfRangeException("srcRect", "The source rect must specify coordinates within the bounds of the source buffer.");
}
Int32Point theDstPoint = dstPoint ?? new Int32Point(srcRect.X, srcRect.Y);
if (theDstPoint.X < 0 || (theDstPoint.X + srcRect.Width) > _bounds.Width ||
theDstPoint.Y < 0 || (theDstPoint.Y + srcRect.Height) > _bounds.Height)
{
throw new ArgumentOutOfRangeException("dstPoint", "The destination point must specify coordinates within the bounds of the buffer.");
}
unsafe
{
int sizeOfT = Marshal.SizeOf(typeof(T));
byte *pRead = ((byte *)srcView._buffer._pBits.ToPointer()) + (srcRect.Y + srcView._buffer._bounds.Y) * srcView._buffer._rowWidth * sizeOfT + (srcRect.X + srcView._buffer._bounds.X) * sizeOfT;
byte *pWrite = ((byte *)_pBits.ToPointer()) + (theDstPoint.Y + _bounds.Y) * _rowWidth * sizeOfT + (theDstPoint.X + _bounds.X) * sizeOfT;
for (int row = 0; row < srcRect.Height; row++)
{
for (int col = 0; col < srcRect.Width * sizeOfT; col++)
{
*(pWrite + col) = *(pRead + col);
}
pRead += srcView._buffer._rowWidth * sizeOfT;
pWrite += _rowWidth * sizeOfT;
}
}
}
private void DrawTriangleCore(Color c, Int32Point p1, Int32Point p2, Int32Point p3, bool mr, bool ml)
{
int currentLine, bottom;
bool flatTop = (mr && p1.Y == p2.Y) || (ml && p2.Y == p3.Y) || (p1.Y == p3.Y),
flatBottom = p1.Y == p3.Y && p2.Y < p1.Y;
BresenhamEnumerator leftSide, rightSide;
if (flatTop && mr)
{
currentLine = p1.Y;
leftSide = new BresenhamEnumerator(p1, p3);
rightSide = new BresenhamEnumerator(p2, p3);
bottom = p3.Y;
}
else if (flatTop && ml)
{
return;
}
else
{
currentLine = p2.Y;
bottom = Math.Min(p1.Y, p3.Y);
leftSide = new BresenhamEnumerator(p2, p1);
rightSide = new BresenhamEnumerator(p2, p3);
}
int leftX = leftSide.Current.X,
rightX = rightSide.Current.X;
while (currentLine < bottom)
{
// Draw current scan line
context.FillRect(c, new Int32Rect(leftX, currentLine, rightX - leftX + 1, 1));
// Advance to next scan line
//
leftSide.MoveNextY();
rightSide.MoveNextY();
currentLine++;
leftX = leftSide.Current.X;
rightX = rightSide.Current.X;
}
if (flatTop || flatBottom)
{
// Draw last line
context.FillRect(c, new Int32Rect(leftX, currentLine, rightX - leftX + 1, 1));
}
else if (mr)
{
// Draw bottom triangle
DrawTriangleCore(c, p1, new Int32Point(rightX, currentLine), p3, mr, ml);
}
else if (ml)
{
// Draw bottom triangle
// DrawTriangleCore(new Int32Point(leftX, currentLine), p3, mr, ml);
}
}
/// <summary>
/// Swaps two points.
/// </summary>
/// <param name="a">Point a.</param>
/// <param name="b">Point b.</param>
private static void SwapPoints(ref Int32Point a, ref Int32Point b)
{
Int32Point tmp = a;
a = b;
b = tmp;
}
public MazeGraph GenerateGraphPathFromMaze(Int32Point point)
{
MazeGraph pathGraph = new MazeGraph();
Stack <Int32Point> cells = new Stack <Int32Point> ();
List <Int32Point> processedCells = new List <Int32Point> ();
cells.Push(point);
while (cells.Count > 0)
{
Int32Point cell = cells.Pop();
if (processedCells.Contains(cell))
{
continue;
}
processedCells.Add(cell);
List <Int32Point> neighbours = GetCellNeighbours(cell);
foreach (Int32Point neighbour in neighbours)
{
if (!HasWallBetween(cell, neighbour))
{
pathGraph.AddEdge(cell, neighbour);
cells.Push(neighbour);
}
}
}
//Debug.Log (pathGraph);
return(pathGraph);
}
private void GenerateMaze()
{
GenerateEmptyMaze();
Stack <Int32Point> cellLocations = new Stack <Int32Point> ();
Int32Point currentCell = new Int32Point(Random.Range(0, Width), Random.Range(0, Height));
int visitedCells = 1;
while (visitedCells != TotalCells)
{
List <Int32Point> intactNeighbors = GetIntactNeighbors(currentCell);
if (intactNeighbors.Count > 0)
{
Int32Point randomNeighbor = intactNeighbors [Random.Range(0, intactNeighbors.Count)];
KnockWallBetween(currentCell, randomNeighbor);
cellLocations.Push(currentCell);
currentCell = randomNeighbor;
visitedCells++;
}
else
{
currentCell = cellLocations.Pop();
}
}
}
private static Int32Point?GetNeighbour4(Int32Point u, int neighbourIndex, LiveWireGraph graph, out double distance)
{
int width = graph.Width;
int height = graph.Height;
int x = u.X;
int y = u.Y;
distance = 0.0;
switch (neighbourIndex)
{
case 0:
if (x >= width - 1)
{
return(null);
}
else
{
distance = graph.EdgeData[y * width + x, 0];
return(new Int32Point(x + 1, y));
}
case 1:
if (y >= height - 1)
{
return(null);
}
else
{
distance = graph.EdgeData[y * width + x, 2];
return(new Int32Point(x, y + 1));
}
case 2:
if (x == 0)
{
return(null);
}
else
{
distance = graph.EdgeData[y * width + x - 1, 0];
return(new Int32Point(x - 1, y));
}
case 3:
if (y == 0)
{
return(null);
}
else
{
distance = graph.EdgeData[y * width + x - width, 2];
return(new Int32Point(x, y - 1));
}
default:
return(null);
}
}
public bool HitTest(Int32Point p)
{
if (GeometryHelper.IsPossibleArcContains(Center, Start, End, p))
{
return(Math.Abs((p - Center).Length - Radius) <= _property.Pen.Thickness + VisualHelper.HitTestThickness);
}
return(false);
}
public PointToProcess(Int32Point point)
{
X = point.X;
Y = point.Y;
K = 0;
Distance = 0;
}
internal Cicle(byte[] fillColor, Int32Point center, Int32 radius, _DrawingPen pen)
{
_fillColor = fillColor;
Center = center;
Radius = radius;
var _bounds = GeometryHelper.CalcBounds(center, radius, pen.Thickness);
_property = new PrimitiveProperty(pen, _bounds);
}
internal void DrawLine(Color color, Int32Point start, Int32Point end)
{
// Implementation of the Bresenham line algorithm derived from the ideas given in
// https://de.wikipedia.org/wiki/Bresenham-Algorithmus
// https://en.wikipedia.org/wiki/Bresenham%27s_line_algorithm
int x1 = start.X;
int y1 = start.Y;
int x2 = end.X;
int y2 = end.Y;
int dy = y2 - y1;
int dx = x2 - x1;
int xinc = Math.Sign(dx);
int yinc = Math.Sign(dy);
dx *= xinc; // make dx always positive
dy *= yinc; // make dy always positive
if (dy == 0) // horizontal line
{
FillRect(color, new Int32Rect((x2 < x1 ? x2 : x1), y1, Math.Abs(x2 - x1), 1));
}
else if (dx == 0) // vertical line
{
FillRect(color, new Int32Rect(x1, (y2 < y1 ? y2 : y1), 1, Math.Abs(y2 - y1)));
}
else if (dy <= dx) // between pi/4 and -pi/4 (including)
{
int error = -dx / 2;
for (; x1 != x2; x1 += xinc)
{
DrawPixel(color, x1, y1);
error += dy;
if (error >= 0)
{
y1 += yinc;
error -= dx;
}
}
}
else
{
int error = -dy / 2; // between pi/2 and pi/4 or between -pi/4 and -pi/2 (excluding)
for (; y1 != y2; y1 += yinc)
{
DrawPixel(color, x1, y1);
error += dx;
if (error >= 0)
{
x1 += xinc;
error -= dy;
}
}
}
}
/// <summary>
/// Convert the given integer Cartesian coordinate to a polar coordinate.
/// </summary>
/// <param name="p">The integer Cartesian coordinate to convert.</param>
/// <param name="radiusSqr">Returns the square of the radius, as an integer. I.e. the distance from the pole, squared.</param>
/// <param name="azimuth">Returns the azimuth; the anticlockwise angle from the polar axis.</param>
/// <remarks>
/// The radius coordinate is returned as the *square* of the radius. This is because normally we want to compare the radius
/// with some threshold, and it's faster to avoid a square root operation to calculate the radius, and instead to compare
/// squared radii.
///
/// By convention the polar axis is horizontal and to the right, and a positive azimuth represents an anticlockwise
/// rotation. Therefore an azimuth of zero degrees represents due east (note. this same angle is never represented by
/// +360 degrees), and an angle of +90 degrees represents due north.
/// </remarks>
private static void CartesianToPolar(Int32Point p, out int radiusSqr, out float azimuth)
{
radiusSqr = (p.X * p.X) + (p.Y * p.Y);
azimuth = __atan2Lookup[p.Y + __atan2LookupOffset, p.X + __atan2LookupOffset];
if (azimuth < 0f)
{
azimuth += 2f * MathF.PI;
}
}
internal Arc(Int32Point start, Int32Point end, Int32Point center, _DrawingPen pen)
{
Start = start;
End = end;
Center = center;
Radius = (Start - Center).Length;
var _bounds = GeometryHelper.CalcBounds(center, start, end, Radius, pen.Thickness);
_property = new PrimitiveProperty(pen, _bounds);
}
public bool HitTest(Int32Point p)
{
foreach (var innerLine in _innerLines)
{
if (innerLine.HitTest(p))
{
return(true);
}
}
return(false);
}
internal bool HitTest(Int32Point p)
{
foreach (var primitive in _context.Primitives)
{
if (primitive.HitTest(p))
{
return(true);
}
}
return(false);
}
internal Line(Int32Point start, Int32Point end, _DrawingPen pen)
{
Start = start;
End = end;
Len = (Start - End).Length;
GeometryHelper.CalcLineABC(Start, End, out A, out B, out C);
Arg = (long)Math.Sqrt((long)A * A + (long)B * B);
var _bounds = GeometryHelper.CalcBounds(pen.Thickness, start, end);
_property = new PrimitiveProperty(pen, _bounds);
}
public override bool Equals(object obj)
{
if (obj is Int32Point)
{
Int32Point otherPoint = (Int32Point)obj;
return(this.X == otherPoint.X && this.Y == otherPoint.Y);
}
return(false);
}
public bool ContainsTile(GameObject tileGameObject)
{
if (tileGameObject != null)
{
Int32Point tilePosition = GetTilePosition(tileGameObject);
return(tilePosition.X != -1 && tilePosition.Y != -1);
}
return(false);
}
public void MoveAgent()
{
var world = new PreyCaptureWorld(4, 1f, 4f, 100);
var agent = new MockPreyCaptureAgent();
// Agent moving north test.
{
world.InitPositions();
Int32Point posBefore = world.AgentPosition;
var outputs = agent.Outputs.Span;
outputs.Clear();
outputs[0] = 1.0;
world.MoveAgent(agent);
Int32Point posDelta = world.AgentPosition - posBefore;
Assert.Equal(new Int32Point(0, 1), posDelta);
}
// Agent moving east test.
{
world.InitPositions();
Int32Point posBefore = world.AgentPosition;
var outputs = agent.Outputs.Span;
outputs.Clear();
outputs[1] = 1.0;
world.MoveAgent(agent);
Int32Point posDelta = world.AgentPosition - posBefore;
Assert.Equal(new Int32Point(1, 0), posDelta);
}
// Agent moving south test.
{
world.InitPositions();
Int32Point posBefore = world.AgentPosition;
var outputs = agent.Outputs.Span;
outputs.Clear();
outputs[2] = 1.0;
world.MoveAgent(agent);
Int32Point posDelta = world.AgentPosition - posBefore;
Assert.Equal(new Int32Point(0, -1), posDelta);
}
// Agent moving west test.
{
world.InitPositions();
Int32Point posBefore = world.AgentPosition;
var outputs = agent.Outputs.Span;
outputs.Clear();
outputs[3] = 1.0;
world.MoveAgent(agent);
Int32Point posDelta = world.AgentPosition - posBefore;
Assert.Equal(new Int32Point(-1, 0), posDelta);
}
}
public bool Equals(Int32Point obj)
{
if (!obj.X.Equals(this.X))
{
return(false);
}
if (!obj.Y.Equals(this.Y))
{
return(false);
}
return(true);
}
public override bool Equals(object o)
{
// Check for null and compare run-time types.
if ((o == null) || !o.GetType().Equals(o.GetType()))
{
return(false);
}
else
{
Int32Point p = (Int32Point)o;
return((X == p.X) && (Y == p.Y));
}
}
public bool HitTest(Int32Point p)
{
var len = (p - Center).Length;
if (_fillColor == null)
{
return(Math.Abs(len - Radius) <= _property.Pen.Thickness + VisualHelper.HitTestThickness);
}
else
{
return(len < Radius + _property.Pen.Thickness + VisualHelper.HitTestThickness);
}
}
public bool HitTest(Int32Point p)
{
var len1 = (p - FocusP1).Length;
var len2 = (p - FocusP2).Length;
if (_fillColor == null)
{
return(Math.Abs(len1 + len2 - A_2) <= _property.Pen.Thickness + VisualHelper.HitTestThickness);
}
else
{
return(len1 + len2 <= A_2 + _property.Pen.Thickness + VisualHelper.HitTestThickness);
}
}
public bool RemoveTile(GameObject tileGameObject)
{
if (tileGameObject != null && layerArray != null)
{
if (ContainsTile(tileGameObject))
{
Int32Point tilePosition = GetTilePosition(tileGameObject);
layerArray [tilePosition.X, tilePosition.Y] = null;
MonoBehaviour.Destroy(tileGameObject);
return(true);
}
}
return(false);
}
