GraphNode(int index, ConvexPolygon polygon, PolyType t, List <int> siblings)
{
Idx = index;
Poly = polygon;
Type = t;
Siblings = siblings;
}
private void DropNewThing(PolyType newShape, double newSize, Color newColor)
{
// Only drop within the center "square" area
double fDropWidth = (sceneRect.Bottom - sceneRect.Top);
if (fDropWidth > sceneRect.Right - sceneRect.Left)
{
fDropWidth = sceneRect.Right - sceneRect.Left;
}
var newThing = new Thing()
{
size = newSize,
yVelocity = (0.5 * rnd.NextDouble() - 0.25) / targetFrameRate,
xVelocity = 0,
shape = newShape,
center = new Point(rnd.NextDouble() * fDropWidth + (sceneRect.Left + sceneRect.Right - fDropWidth) / 2, sceneRect.Top - newSize),
spinRate = (rnd.NextDouble() * 12.0 - 6.0) * 2.0 * Math.PI / targetFrameRate / 4.0,
theta = 0,
timeLastHit = DateTime.MinValue,
avgTimeBetweenHits = 100,
color = newColor,
brush = null,
brush2 = null,
brushPulse = null,
dissolve = 0,
state = ThingState.Falling,
touchedBy = 0,
hotness = 0,
flashCount = 0
};
things.Add(newThing);
}
public void Add(IEnumerable <IPolygon2D> polygons, PolyType type)
{
foreach (var polygon in polygons)
{
this.Add(polygon, type);
}
}
private void AddPoints(Clipper clipper, IEnumerable <IShape> shapes, PolyType polyType)
{
foreach (IShape shape in shapes)
{
this.AddPoints(clipper, shape, polyType);
}
}
private void DropNewThing(PolyType newShape, double newSize, System.Windows.Media.Color newColor)
{
// Only drop within the center "square" area
double dropWidth = this.sceneRect.Bottom - this.sceneRect.Top;
if (dropWidth > this.sceneRect.Right - this.sceneRect.Left)
{
dropWidth = this.sceneRect.Right - this.sceneRect.Left;
}
var newThing = new Spider
{
Size = newSize,
YVelocity = ((0.5 * this.rnd.NextDouble()) - 0.25) / this.targetFrameRate,
XVelocity = 0,
Shape = newShape,
Center = new System.Windows.Point((this.rnd.NextDouble() * dropWidth) + ((this.sceneRect.Left + this.sceneRect.Right - dropWidth) / 2), this.sceneRect.Top - newSize),
SpinRate = ((this.rnd.NextDouble() * 12.0) - 6.0) * 2.0 * Math.PI / this.targetFrameRate / 4.0,
Theta = 0,
TimeLastHit = DateTime.MinValue,
AvgTimeBetweenHits = 100,
Color = newColor,
Brush = null,
Brush2 = null,
BrushPulse = null,
Dissolve = 0,
State = ThingState.Falling,
TouchedBy = 0,
Hotness = 0,
FlashCount = 0
};
this.things.Add(newThing);
}
private void DropNewThing(PolyType newShape, double newSize, Color newColor)
{
// Only drop within the center "square" area
double dropWidth = _sceneRect.Bottom - _sceneRect.Top;
if (dropWidth > _sceneRect.Right - _sceneRect.Left)
{
dropWidth = _sceneRect.Right - _sceneRect.Left;
}
var newThing = new Thing
{
Size = newSize,
YVelocity = ((0.5 * _rnd.NextDouble()) - 0.25) / _targetFrameRate,
XVelocity = 0,
Shape = newShape,
Center = new Point((_rnd.NextDouble() * dropWidth) + ((_sceneRect.Left + _sceneRect.Right - dropWidth) / 2), _sceneRect.Top - newSize),
TimeLastHit = DateTime.MinValue,
AvgTimeBetweenHits = 100,
Color = newColor,
Brush = null,
Brush2 = null,
BrushPulse = null,
Dissolve = 0,
State = ThingState.Falling,
Hotness = 0,
FlashCount = 0
};
_things.Add(newThing);
}
public void AddPath(Region region, PolyType polyType)
{
if (region == null || region.points == null)
{
return;
}
int count = region.points.Length;
List <IntPoint> points = new List <IntPoint> (count);
for (int k = 0; k < count; k++)
{
float ix = region.points [k].x * MULTIPLIER;
float iy = region.points [k].y * MULTIPLIER;
IntPoint p = new IntPoint(ix, iy);
points.Add(p);
}
AddPath(points, polyType, true);
if (polyType == PolyType.ptSubject)
{
subject = region;
if (subjects == null)
{
subjects = new List <Region>();
}
subjects.Add(region);
}
}
private void AddRegion(IRegion2D r, PolyType polyType)
{
var polygons = CreatePolygons(r);
foreach (var poly in polygons)
{
this.clipper.AddPath(poly, polyType, true);
}
}
public void AddPaths(List <Region> regions, PolyType polyType)
{
int regionCount = regions.Count;
for (int k = 0; k < regionCount; k++)
{
AddPath(regions [k], polyType);
}
}
public bool AddPath(IEnumerable <Point2d> poly, PolyType type, bool closed)
{
bool ret = this.clipper.AddPath(poly.Select(p => this.converter.ToIntPoint(p)).ToList(), type, closed);
if (!ret)
{
Debug.WriteLine("Error in clipper.AddPath");
}
return(ret);
}
/// <summary>
/// Adds iText
/// <see cref="iText.Kernel.Geom.Path"/>
/// to the given
/// <see cref="Clipper"/>
/// object.
/// </summary>
/// <param name="clipper">
/// The
/// <see cref="Clipper"/>
/// object.
/// </param>
/// <param name="path">
/// The
/// <see cref="iText.Kernel.Geom.Path"/>
/// object to be added to the
/// <see cref="Clipper"/>.
/// </param>
/// <param name="polyType">
/// See
/// <see cref="PolyType"/>.
/// </param>
public static void AddPath(Clipper clipper, Path path, PolyType polyType)
{
foreach (Subpath subpath in path.GetSubpaths())
{
if (!subpath.IsSinglePointClosed() && !subpath.IsSinglePointOpen())
{
IList <Point> linearApproxPoints = subpath.GetPiecewiseLinearApproximation();
clipper.AddPath(new List <IntPoint>(ConvertToLongPoints(linearApproxPoints)), polyType, subpath.IsClosed());
}
}
}
private void DropNewThing(PolyType newShape, double newSize, System.Windows.Media.Color newColor, double shoulderX, double shoulderY)
{
// Only drop within the center "square" area
//double dropWidth = this.sceneRect.Bottom - this.sceneRect.Top;
//if (dropWidth > this.sceneRect.Right - this.sceneRect.Left)
//{
// dropWidth = this.sceneRect.Right - this.sceneRect.Left;
//}
if (shoulderX == 0)
{
shoulderX = (this.sceneRect.Left + this.sceneRect.Right) / 2;
}
double dropLeft = shoulderX - 50;
double dropRight = shoulderX + 50;
double dropHeight = this.sceneRect.Bottom - this.sceneRect.Top;
double num = this.rnd.NextDouble();
double xDrop = 0;
if (this.rnd.Next(0, 2) == 0)
{
xDrop = num * (dropLeft - this.sceneRect.Left - newSize) + this.sceneRect.Left + newSize;
}
else
{
xDrop = num * (this.sceneRect.Right - newSize - dropRight) + dropRight;
}
var newThing = new Thing
{
Size = newSize,
//YVelocity = ((0.5 * this.rnd.NextDouble()) - 0.25) / this.targetFrameRate,
YVelocity = 0.5 * this.rnd.NextDouble() + 0.5,
XVelocity = 0.5 * this.rnd.NextDouble() + 0.5,
Shape = newShape,
Center = new System.Windows.Point(xDrop, (this.rnd.NextDouble() * dropHeight) + ((this.sceneRect.Top + this.sceneRect.Bottom - dropHeight) / 2)),
SpinRate = ((this.rnd.NextDouble() * 12.0) - 6.0) * 2.0 * Math.PI / this.targetFrameRate / 4.0,
//SpinRate = 0,
Theta = 0,
TimeLastHit = DateTime.MinValue,
AvgTimeBetweenHits = 100,
Color = newColor,
Brush = null,
Brush2 = null,
BrushPulse = null,
Dissolve = 0,
State = ThingState.Falling,
TouchedBy = 0,
Hotness = 0,
FlashCount = 0
};
this.things.Add(newThing);
}
private void PolyTypeFlagChanged(PolyType flag)
{
if ((flag | EditorMaterial.materialPolyTypes) != PolyType.None) //if this changes any flag of the material we have to change material
{
Material = new EditorMaterial(Material.TexturePath, info.polyType, Material.TransVal);
}
if (flag == PolyType.QUAD)
{
UpdateMesh();
}
}
public void Add(IPolyLine2D polyline, PolyType type)
{
if (!this.containsCircArc)
{
this.containsCircArc |= polyline.Segments.FirstOrDefault(s => s is CircularArcSegment2D) != null;
}
var p = CreatePolygon(polyline, this.Discretizator, false);
this.clipper.AddPath(p, type, polyline.IsClosed);
}
public bool AddPaths <TPoly>(IEnumerable <TPoly> polys, PolyType type, bool closed)
where TPoly : IEnumerable <Point2d>
{
bool ret = this.clipper.AddPaths(polys.Select(poly => poly.Select(p => this.converter.ToIntPoint(p)).ToList()).ToList(), type, closed);
if (!ret)
{
Debug.WriteLine("Error in clipper.AddPaths");
}
return(ret);
}
public void RemoveShape(PolyType shape)
{
for (int thingIndex = 0; thingIndex < this.things.Count; thingIndex++)
{
Thing thing = this.things[thingIndex];
if (thing.Shape == shape)
{
this.things.Remove(thing);
thingIndex--;
}
}
}
private PolyType GetPolyType()
{
PolyType type = 0;
foreach (var v in lstType.CheckedItems)
{
var tmp = (PolyType)Enum.Parse(typeof(PolyType), v.ToString());
type |= tmp;
}
return(type);
}
void SetPolyType(PolyType type)
{
for (int i = 0; i < lstType.Items.Count; i++)
{
var v = lstType.Items[i];
lstType.SetItemChecked(i, false);
var itemPolyType = (PolyType)Enum.Parse(typeof(PolyType), v.ToString());
if (type.HasFlag(itemPolyType))
{
lstType.SetItemChecked(i, true);
}
}
}
public bool AddPaths(List <List <IntPoint> > ppg, PolyType polyType, bool closed)
{
bool result = false;
for (int i = 0; i < ppg.Count; i++)
{
if (AddPath(ppg[i], polyType, closed))
{
result = true;
}
}
return(result);
}
//------------------------------------------------------------------------------
public bool AddPolygons(List <List <IntPoint> > ppg, PolyType polyType)
{
bool result = false;
for (int i = 0; i < ppg.Count; ++i)
{
if (AddPath(ppg[i], polyType, true))
{
result = true;
}
}
return(result);
}
public void AddPolygon(List <Vector2> polygon, PolyType type)
{
List <IntPoint> preparedPolygon = new List <IntPoint>();
foreach (Vector2 origVertice in polygon)
{
Vector2 multipliedVector = ClipperUnitsPerUnityUnit * origVertice;
Vector2 rounded = new Vector2((float)Math.Round(multipliedVector.x), (float)Math.Round(multipliedVector.y));
IntPoint preparedVertice = new IntPoint((int)rounded.x, (int)rounded.y);
preparedPolygon.Add(preparedVertice);
}
TheClipper.AddPolygon(preparedPolygon, type);
}
static TriangleHelper.PolygonType ConvertType(PolyType type)
{
switch (type)
{
case PolyType.QUADS: return(TriangleHelper.PolygonType.Quad);
case PolyType.QUAD_STRIP: return(TriangleHelper.PolygonType.QuadStrip);
case PolyType.TRIANGLES: return(TriangleHelper.PolygonType.Triangle);
case PolyType.TRIANGLE_STRIP: return(TriangleHelper.PolygonType.TriangleStrip);
}
return(TriangleHelper.PolygonType.Triangle);
}
private void InitEdge2(TEdge e, PolyType polyType)
{
if (e.Curr.Y >= e.Next.Curr.Y)
{
e.Bot = e.Curr;
e.Top = e.Next.Curr;
}
else
{
e.Top = e.Curr;
e.Bot = e.Next.Curr;
}
SetDx(e);
e.PolyTyp = polyType;
}
/// <summary>
/// Get the hash code for this object
/// </summary>
///
/// <returns>Hash code</returns>
public override int GetHashCode()
{
int prime = 31;
int result = 1;
result = prime * result + N;
result = prime * result + (_fastFp ? 1231 : 1237);
result = prime * result + ((FP == null) ? 0 : FP.GetHashCode());
result = prime * result + PolyType.GetHashCode();
result = prime * result + Q;
result = prime * result + (_sparse ? 1231 : 1237);
result = prime * result + ((T == null) ? 0 : T.GetHashCode());
return(result);
}
public void AddPath(Region region, PolyType polyType)
{
if (region == null)
{
return;
}
int count = region.latlon.Length;
List <IntPoint> points = new List <IntPoint> (count);
for (int k = 0; k < count; k++)
{
IntPoint p = new IntPoint(region.latlon [k].x * MULTIPLIER, region.latlon [k].y * MULTIPLIER);
points.Add(p);
}
AddPath(points, polyType, true);
}
/// <summary>
/// Joins all the polygones.
/// ClipType: http://www.angusj.com/delphi/clipper/documentation/Docs/Units/ClipperLib/Types/ClipType.htm
/// PolyFillType: http://www.angusj.com/delphi/clipper/documentation/Docs/Units/ClipperLib/Types/PolyFillType.htm
/// </summary>
/// <param name="sList">The s list.</param>
/// <param name="cType">Type of the c.</param>
/// <param name="pType">Type of the p.</param>
/// <param name="pFType1">The p f type1.</param>
/// <param name="pFType2">The p f type2.</param>
/// <returns></returns>
public static List <Polygon> JoinPolygons(
this List <Polygon> sList,
ClipType cType,
PolyType pType = PolyType.ptClip,
PolyFillType pFType1 = PolyFillType.pftNonZero,
PolyFillType pFType2 = PolyFillType.pftNonZero)
{
var p = ClipPolygons(sList);
var tList = new List <List <IntPoint> >();
var c = new Clipper();
c.AddPaths(p, pType, true);
c.Execute(cType, tList, pFType1, pFType2);
return(ToPolygons(tList));
}
/// <summary>
/// Adds the path.
/// </summary>
/// <param name="path">The path.</param>
/// <param name="clippingType">Type of the poly.</param>
/// <exception cref="ClipperException">AddPath: Open paths have been disabled.</exception>
internal void AddPath(ISimplePath path, ClippingType clippingType)
{
var vectors = path.Points;
List <IntPoint> points = new List <ClipperLib.IntPoint>(vectors.Length);
foreach (var v in vectors)
{
points.Add(new IntPoint(v.X * ScalingFactor, v.Y * ScalingFactor));
}
PolyType type = clippingType == ClippingType.Clip ? PolyType.ptClip : PolyType.ptSubject;
lock (this.syncRoot)
{
this.innerClipper.AddPath(points, type, path.IsClosed, path);
}
}
/// <summary>
/// Reset all fields to default values in preparation for object recycling
/// </summary>
public void PrepareForRecycle()
{
PolyTyp = PolyType.Subject;
Side = EdgeSide.Left;
Bot = Curr = Top = Delta = new IntPoint();
Dx = 0;
WindDelta = 0;
WindCnt = 0;
WindCnt2 = 0;
OutIdx = 0;
Next = Prev = null;
PrevInAEL = PrevInSEL = null;
NextInLML = NextInAEL = NextInSEL = null;
}
private void AddPoints(Clipper clipper, IShape shape, PolyType polyType)
{
// if the path is already the shape use it directly and skip the path loop.
if (shape is IPath)
{
clipper.AddPath(
(IPath)shape,
polyType);
}
else
{
foreach (IPath path in shape)
{
clipper.AddPath(
path,
polyType);
}
}
}
public void AddPath(Vector2[] points, PolyType polyType)
{
if (points == null)
{
return;
}
if (polyType == PolyType.ptSubject)
{
Debug.LogError("Subject polytype needs a Region object.");
return;
}
int count = points.Length;
List <IntPoint> newPoints = new List <IntPoint> (count);
for (int k = 0; k < count; k++)
{
float ix = points [k].x * MULTIPLIER;
float iy = points [k].y * MULTIPLIER;
IntPoint p = new IntPoint(ix, iy);
newPoints.Add(p);
}
AddPath(newPoints, polyType, true);
}
//------------------------------------------------------------------------------
private void InitEdge2(TEdge e, PolyType polyType)
{
if (e.Curr.Y >= e.Next.Curr.Y)
{
e.Bot = e.Curr;
e.Top = e.Next.Curr;
}
else
{
e.Top = e.Curr;
e.Bot = e.Next.Curr;
}
SetDx(e);
e.PolyTyp = polyType;
}
private void DropNewThing(PolyType newShape, double newSize, Color newColor, int number)
{
// Only drop within the center "square" area
double dropWidth = _sceneRect.Bottom - _sceneRect.Top;
if (dropWidth > _sceneRect.Right - _sceneRect.Left)
{
dropWidth = _sceneRect.Right - _sceneRect.Left;
}
var newThing = new Thing
{
Size = newSize,
YVelocity = ((0.5 * _rnd.NextDouble()) - 0.25) / _targetFrameRate,
XVelocity = 0,
Shape = newShape,
Center = new Point((_rnd.NextDouble() * dropWidth) + ((_sceneRect.Left + _sceneRect.Right - dropWidth) / 2), _sceneRect.Top - newSize),
TimeLastHit = DateTime.MinValue,
AvgTimeBetweenHits = 100,
Color = newColor,
Brush = null,
Brush2 = null,
BrushPulse = null,
Dissolve = 0,
State = ThingState.Falling,
Hotness = 0,
FlashCount = 0,
Number = number
};
if (BubblesFallen < _maxBubbles)
{
_things.Add(newThing);
BubblesFallen++;
}
}
//------------------------------------------------------------------------------
public void AddPolygons(Polygons ppg, PolyType polyType)
{
for (int i = 0; i < ppg.Count; ++i)
AddPolygon(ppg[i], polyType);
}
/// <summary>
/// Joins all the polygones.
/// ClipType: http://www.angusj.com/delphi/clipper/documentation/Docs/Units/ClipperLib/Types/ClipType.htm
/// PolyFillType: http://www.angusj.com/delphi/clipper/documentation/Docs/Units/ClipperLib/Types/PolyFillType.htm
/// </summary>
/// <param name="sList">The s list.</param>
/// <param name="cType">Type of the c.</param>
/// <param name="pType">Type of the p.</param>
/// <param name="pFType1">The p f type1.</param>
/// <param name="pFType2">The p f type2.</param>
/// <returns></returns>
public static List<Polygon> ELJoinPolygons(this List<Polygon> sList, ClipType cType,
PolyType pType = PolyType.ptClip, PolyFillType pFType1 = PolyFillType.pftNonZero,
PolyFillType pFType2 = PolyFillType.pftNonZero)
{
var p = ELClipPolygons(sList);
var tList = new List<List<IntPoint>>();
var c = new Clipper();
c.AddPaths(p, pType, true);
c.Execute(cType, tList, pFType1, pFType2);
return ToPolygons(tList);
}
//------------------------------------------------------------------------------
public bool AddPath(List<IntPoint> pg, PolyType polyType, bool Closed)
{
#if use_lines
if (!Closed && polyType == PolyType.ptClip)
throw new ClipperException("AddPath: Open paths must be subject.");
#else
if (!Closed)
throw new ClipperException("AddPath: Open paths have been disabled.");
#endif
int highI = (int)pg.Count - 1;
if (Closed) while (highI > 0 && (pg[highI] == pg[0])) --highI;
while (highI > 0 && (pg[highI] == pg[highI - 1])) --highI;
if ((Closed && highI < 2) || (!Closed && highI < 1)) return false;
//create a new edge array ...
List<TEdge> edges = new List<TEdge>(highI + 1);
for (int i = 0; i <= highI; i++) edges.Add(new TEdge());
bool IsFlat = true;
//1. Basic (first) edge initialization ...
edges[1].Curr = pg[1];
RangeTest(pg[0], ref m_UseFullRange);
RangeTest(pg[highI], ref m_UseFullRange);
InitEdge(edges[0], edges[1], edges[highI], pg[0]);
InitEdge(edges[highI], edges[0], edges[highI - 1], pg[highI]);
for (int i = highI - 1; i >= 1; --i)
{
RangeTest(pg[i], ref m_UseFullRange);
InitEdge(edges[i], edges[i + 1], edges[i - 1], pg[i]);
}
TEdge eStart = edges[0];
//2. Remove duplicate vertices, and (when closed) collinear edges ...
TEdge E = eStart, eLoopStop = eStart;
for (;;)
{
//nb: allows matching start and end points when not Closed ...
if (E.Curr == E.Next.Curr && (Closed || E.Next != eStart))
{
if (E == E.Next) break;
if (E == eStart) eStart = E.Next;
E = RemoveEdge(E);
eLoopStop = E;
continue;
}
if (E.Prev == E.Next)
break; //only two vertices
else if (Closed &&
SlopesEqual(E.Prev.Curr, E.Curr, E.Next.Curr, m_UseFullRange) &&
(!PreserveCollinear ||
!Pt2IsBetweenPt1AndPt3(E.Prev.Curr, E.Curr, E.Next.Curr)))
{
//Collinear edges are allowed for open paths but in closed paths
//the default is to merge adjacent collinear edges into a single edge.
//However, if the PreserveCollinear property is enabled, only overlapping
//collinear edges (ie spikes) will be removed from closed paths.
if (E == eStart) eStart = E.Next;
E = RemoveEdge(E);
E = E.Prev;
eLoopStop = E;
continue;
}
E = E.Next;
if ((E == eLoopStop) || (!Closed && E.Next == eStart)) break;
}
if ((!Closed && (E == E.Next)) || (Closed && (E.Prev == E.Next)))
return false;
if (!Closed)
{
m_HasOpenPaths = true;
eStart.Prev.OutIdx = Skip;
}
//3. Do second stage of edge initialization ...
E = eStart;
do
{
InitEdge2(E, polyType);
E = E.Next;
if (IsFlat && E.Curr.Y != eStart.Curr.Y) IsFlat = false;
}
while (E != eStart);
//4. Finally, add edge bounds to LocalMinima list ...
//Totally flat paths must be handled differently when adding them
//to LocalMinima list to avoid endless loops etc ...
if (IsFlat)
{
if (Closed) return false;
E.Prev.OutIdx = Skip;
LocalMinima locMin = new LocalMinima();
locMin.Next = null;
locMin.Y = E.Bot.Y;
locMin.LeftBound = null;
locMin.RightBound = E;
locMin.RightBound.Side = EdgeSide.esRight;
locMin.RightBound.WindDelta = 0;
for (;;)
{
if (E.Bot.X != E.Prev.Top.X) ReverseHorizontal(E);
if (E.Next.OutIdx == Skip) break;
E.NextInLML = E.Next;
E = E.Next;
}
InsertLocalMinima(locMin);
m_edges.Add(edges);
return true;
}
m_edges.Add(edges);
bool leftBoundIsForward;
TEdge EMin = null;
//workaround to avoid an endless loop in the while loop below when
//open paths have matching start and end points ...
if (E.Prev.Bot == E.Prev.Top) E = E.Next;
for (;;)
{
E = FindNextLocMin(E);
if (E == EMin) break;
else if (EMin == null) EMin = E;
//E and E.Prev now share a local minima (left aligned if horizontal).
//Compare their slopes to find which starts which bound ...
LocalMinima locMin = new LocalMinima();
locMin.Next = null;
locMin.Y = E.Bot.Y;
if (E.Dx < E.Prev.Dx)
{
locMin.LeftBound = E.Prev;
locMin.RightBound = E;
leftBoundIsForward = false; //Q.nextInLML = Q.prev
}
else
{
locMin.LeftBound = E;
locMin.RightBound = E.Prev;
leftBoundIsForward = true; //Q.nextInLML = Q.next
}
locMin.LeftBound.Side = EdgeSide.esLeft;
locMin.RightBound.Side = EdgeSide.esRight;
if (!Closed) locMin.LeftBound.WindDelta = 0;
else if (locMin.LeftBound.Next == locMin.RightBound)
locMin.LeftBound.WindDelta = -1;
else locMin.LeftBound.WindDelta = 1;
locMin.RightBound.WindDelta = -locMin.LeftBound.WindDelta;
E = ProcessBound(locMin.LeftBound, leftBoundIsForward);
if (E.OutIdx == Skip) E = ProcessBound(E, leftBoundIsForward);
TEdge E2 = ProcessBound(locMin.RightBound, !leftBoundIsForward);
if (E2.OutIdx == Skip) E2 = ProcessBound(E2, !leftBoundIsForward);
if (locMin.LeftBound.OutIdx == Skip)
locMin.LeftBound = null;
else if (locMin.RightBound.OutIdx == Skip)
locMin.RightBound = null;
InsertLocalMinima(locMin);
if (!leftBoundIsForward) E = E2;
}
return true;
}
public void AddPolygons(IEnumerable<List<IntPoint>> ppg, PolyType polyType)
{
Contract.Requires(ppg != null);
Contract.Requires(Contract.ForAll(ppg, a => a != null));
foreach (var poly in ppg)
AddPolygon(poly, polyType);
}
private static void InitEdge(TEdge e, TEdge eNext, TEdge ePrev, IntPoint pt, PolyType polyType)
{
Contract.Requires(e != null);
Contract.Requires(eNext != null);
e.Next = eNext;
e.Prev = ePrev;
e.XCurr = pt.X;
e.YCurr = pt.Y;
if (e.YCurr >= e.Next.YCurr)
{
e.XBot = e.XCurr;
e.YBot = e.YCurr;
e.XTop = e.Next.XCurr;
e.YTop = e.Next.YCurr;
e.WindDelta = 1;
}
else
{
e.XTop = e.XCurr;
e.YTop = e.YCurr;
e.XBot = e.Next.XCurr;
e.YBot = e.Next.YCurr;
e.WindDelta = -1;
}
SetDx(e);
e.PolyType = polyType;
e.OutIdx = -1;
}
public void AddPolygon(IReadOnlyList<IntPoint> pg, PolyType polyType)
{
Contract.Requires(pg != null);
var len = pg.Count;
if (len < 3)
return;
var maxVal = HI_RANGE;
InternalHelpers.RangeTest(pg[0], ref maxVal);
var p = new List<IntPoint>(len) { new IntPoint(pg[0].X, pg[0].Y) };
var j = 0;
for (var i = 1; i < len; ++i)
{
InternalHelpers.RangeTest(pg[i], ref maxVal);
if (p[j].Equals(pg[i]))
continue;
else if (j > 0 && InternalHelpers.SlopesEqual(p[j - 1], p[j], pg[i]))
{
if (p[j - 1].Equals(pg[i]))
j--;
}
else
j++;
if (j < p.Count)
p[j] = pg[i];
else
p.Add(new IntPoint(pg[i].X, pg[i].Y));
}
if (j < 2)
return;
len = j + 1;
while (len > 2)
{
//nb: test for point equality before testing slopes ...
if (p[j].Equals(p[0]))
j--;
else if (p[0].Equals(p[1]) || InternalHelpers.SlopesEqual(p[j], p[0], p[1]))
p[0] = p[j--];
else if (InternalHelpers.SlopesEqual(p[j - 1], p[j], p[0]))
j--;
else if (InternalHelpers.SlopesEqual(p[0], p[1], p[2]))
{
for (var i = 2; i <= j; ++i)
p[i - 1] = p[i];
j--;
}
else
break;
len--;
}
if (len < 3)
return;
//create a new edge array ...
var edges = new List<TEdge>(len);
for (var i = 0; i < len; i++)
edges.Add(new TEdge());
Edges.Add(edges);
//convert vertices to a double-linked-list of edges and initialize ...
edges[0].XCurr = p[0].X;
edges[0].YCurr = p[0].Y;
InitEdge(edges[len - 1], edges[0], edges[len - 2], p[len - 1], polyType);
for (var i = len - 2; i > 0; --i)
InitEdge(edges[i], edges[i + 1], edges[i - 1], p[i], polyType);
InitEdge(edges[0], edges[1], edges[len - 1], p[0], polyType);
//reset xcurr & ycurr and find 'eHighest' (given the Y axis coordinates
//increase downward so the 'highest' edge will have the smallest ytop) ...
var e = edges[0];
var eHighest = e;
do
{
e.XCurr = e.XBot;
e.YCurr = e.YBot;
if (e.YTop < eHighest.YTop)
eHighest = e;
e = e.Next;
} while (e != edges[0]);
//make sure eHighest is positioned so the following loop works safely ...
if (eHighest.WindDelta > 0)
eHighest = eHighest.Next;
if (eHighest.Dx == HORIZONTAL)
eHighest = eHighest.Next;
//finally insert each local minima ...
e = eHighest;
do
{
e = AddBoundsToLML(e);
} while (e != eHighest);
}
public void DropNewThing(PolyType newShape, double newSize, double appleLocation ,Color newColor, UIElementCollection children, String word /*, List<ShoopDoup.Models.DataObject> data*/)
{
// Only drop within the center "square" area
double dropX;
double fDropWidth = (sceneRect.Bottom - sceneRect.Top);
if (fDropWidth > sceneRect.Right - sceneRect.Left)
fDropWidth = sceneRect.Right - sceneRect.Left;
if (appleLocation == 0)
{
dropX = rnd.NextDouble() * fDropWidth + (sceneRect.Left + sceneRect.Right - fDropWidth) / 2;
while(Math.Abs(dropX-lastDropLocation)<150)
{
dropX = rnd.NextDouble() * fDropWidth + (sceneRect.Left + sceneRect.Right - fDropWidth) / 2;
}
lastDropLocation = dropX;
}
else
{
dropX = appleLocation;
}
var newThing = new Thing()
{
size = 125,
yVelocity = (0.5 * rnd.NextDouble() - 0.25) / targetFrameRate,
xVelocity = 0,
shape = newShape,
center = new Point(dropX, sceneRect.Top - newSize),
spinRate = (rnd.NextDouble() * 12.0 - 6.0) * 2.0 * Math.PI / targetFrameRate / 4.0,
theta = 0,
timeLastHit = DateTime.MinValue,
avgTimeBetweenHits = 100,
color = newColor,
brush = null,
brush2 = null,
brushPulse = null,
dissolve = 0,
state = ThingState.Falling,
touchedBy = 0,
hotness = 0,
flashCount = 0,
};
things.Add(newThing);
String text = word;
if (word == null)
{
int randomLabel = rnd.Next(0, textLabels.Count - 1);
text = textLabels[randomLabel];
while (usedLabels.Contains(text))
{
if (usedLabels.Count > textLabels.Count - 5)
{
usedLabels.Clear();
}
randomLabel = rnd.Next(0, textLabels.Count - 1);
text = textLabels[randomLabel];
}
usedLabels.Add(text);
}
Label label = new Label();
TextBlock bubbleTextBlock = new TextBlock();
bubbleTextBlock.Text = text;
SolidColorBrush appleColor = new SolidColorBrush();
appleColor.Color = Color.FromArgb(255, 227, 50, 50);
bubbleTextBlock.Foreground=appleColor;
Viewbox bubbleViewBox = new Viewbox();
bubbleViewBox.Stretch = Stretch.Uniform;
bubbleViewBox.Height = 80;
bubbleViewBox.Width = 100;
bubbleViewBox.Child = bubbleTextBlock;
label.Content = bubbleViewBox;
appleLabels.Add(label);
children.Add(label);
children.Add(makeApple(PolyDefs[newThing.shape].numSides, PolyDefs[newThing.shape].skip,
newThing.size, newThing.theta, newThing.center, newThing.brush,
newThing.brushPulse, newThing.size * 0.1, 0));
}
public void DropNewThing(PolyType newShape, double newSize, System.Windows.Media.Color newColor)
{
// Only drop within the center "square" area
double dropWidth = this.sceneRect.Bottom - this.sceneRect.Top;
if (dropWidth > this.sceneRect.Right - this.sceneRect.Left)
{
dropWidth = this.sceneRect.Right - this.sceneRect.Left;
}
var newThing = new Thing
{
Size = newSize,
YVelocity = ((0.5 * this.rnd.NextDouble()) - 0.25) / this.targetFrameRate,
XVelocity = 0,
Shape = newShape,
Center = new System.Windows.Point((this.rnd.NextDouble() * dropWidth) + ((this.sceneRect.Left + this.sceneRect.Right - dropWidth) / 2), this.sceneRect.Top - newSize),
SpinRate = ((this.rnd.NextDouble() * 12.0) - 6.0) * 2.0 * Math.PI / this.targetFrameRate / 4.0,
Theta = 0,
TimeLastHit = DateTime.MinValue,
AvgTimeBetweenHits = 100,
Color = newColor,
Brush = null,
Brush2 = null,
BrushPulse = null,
Dissolve = 0,
State = ThingState.Falling,
TouchedBy = 0,
Hotness = 0,
FlashCount = 0
};
this.things.Add(newThing);
}
private void DropNewThing(PolyType newShape, double newSize, Color newColor)
{
// Only drop within the center "square" area
double fDropWidth = (sceneRect.Bottom - sceneRect.Top);
if (fDropWidth > sceneRect.Right - sceneRect.Left)
fDropWidth = sceneRect.Right - sceneRect.Left;
var newThing = new Thing()
{
size = newSize,
yVelocity = (0.5 * rnd.NextDouble() - 0.25) / targetFrameRate,
xVelocity = 0,
shape = newShape,
center = new Point(rnd.NextDouble() * fDropWidth + (sceneRect.Left + sceneRect.Right - fDropWidth) / 2, sceneRect.Top - newSize),
spinRate = (rnd.NextDouble() * 12.0 - 6.0) * 2.0 * Math.PI / targetFrameRate / 4.0,
theta = 0,
timeLastHit = DateTime.MinValue,
avgTimeBetweenHits = 100,
color = newColor,
brush = null,
brush2 = null,
brushPulse = null,
dissolve = 0,
state = ThingState.Falling,
touchedBy = 0,
hotness = 0,
flashCount = 0
};
things.Add(newThing);
}
public void SetPolies(PolyType polies)
{
polyTypes = polies;
}
//------------------------------------------------------------------------------
public bool AddPolygons(Polygons ppg, PolyType polyType)
{
bool result = false;
for (int i = 0; i < ppg.Count; ++i)
if (AddPolygon(ppg[i], polyType)) result = true;
return result;
}
//------------------------------------------------------------------------------
#if use_deprecated
public bool AddPolygon(Path pg, PolyType polyType)
{
return AddPath(pg, polyType, true);
}
private static void AddRect(Clipper clipper, Point2D[] rectVertices, PolyType polyType) {
clipper.AddPath(ConvertToIntPoints(new List<Point2D>(rectVertices)), polyType, true);
}
//------------------------------------------------------------------------------
public bool AddPolygon(Polygon pg, PolyType polyType)
{
int len = pg.Count;
if (len < 3) return false;
Polygon p = new Polygon(len);
p.Add(new IntPoint(pg[0].X, pg[0].Y));
int j = 0;
for (int i = 1; i < len; ++i)
{
Int64 maxVal;
if (m_UseFullRange) maxVal = hiRange; else maxVal = loRange;
if (Math.Abs(pg[i].X) > maxVal || Math.Abs(pg[i].Y) > maxVal)
{
if (m_UseFullRange)
throw new ClipperException("Coordinate exceeds range bounds");
maxVal = hiRange;
if (Math.Abs(pg[i].X) > maxVal || Math.Abs(pg[i].Y) > maxVal)
throw new ClipperException("Coordinate exceeds range bounds");
m_UseFullRange = true;
}
if (PointsEqual(p[j], pg[i])) continue;
else if (j > 0 && SlopesEqual(p[j-1], p[j], pg[i], m_UseFullRange))
{
if (PointsEqual(p[j-1], pg[i])) j--;
} else j++;
if (j < p.Count)
p[j] = pg[i]; else
p.Add(new IntPoint(pg[i].X, pg[i].Y));
}
if (j < 2) return false;
len = j+1;
for (;;)
{
//nb: test for point equality before testing slopes ...
if (PointsEqual(p[j], p[0])) j--;
else if (PointsEqual(p[0], p[1]) || SlopesEqual(p[j], p[0], p[1], m_UseFullRange))
p[0] = p[j--];
else if (SlopesEqual(p[j-1], p[j], p[0], m_UseFullRange)) j--;
else if (SlopesEqual(p[0], p[1], p[2], m_UseFullRange))
{
for (int i = 2; i <= j; ++i) p[i-1] = p[i];
j--;
}
//exit loop if nothing is changed or there are too few vertices ...
if (j == len-1 || j < 2) break;
len = j +1;
}
if (len < 3) return false;
//create a new edge array ...
List<TEdge> edges = new List<TEdge>(len);
for (int i = 0; i < len; i++) edges.Add(new TEdge());
m_edges.Add(edges);
//convert vertices to a double-linked-list of edges and initialize ...
edges[0].xcurr = p[0].X;
edges[0].ycurr = p[0].Y;
InitEdge(edges[len-1], edges[0], edges[len-2], p[len-1], polyType);
for (int i = len-2; i > 0; --i)
InitEdge(edges[i], edges[i+1], edges[i-1], p[i], polyType);
InitEdge(edges[0], edges[1], edges[len-1], p[0], polyType);
//reset xcurr & ycurr and find 'eHighest' (given the Y axis coordinates
//increase downward so the 'highest' edge will have the smallest ytop) ...
TEdge e = edges[0];
TEdge eHighest = e;
do
{
e.xcurr = e.xbot;
e.ycurr = e.ybot;
if (e.ytop < eHighest.ytop) eHighest = e;
e = e.next;
}
while ( e != edges[0]);
//make sure eHighest is positioned so the following loop works safely ...
if (eHighest.windDelta > 0) eHighest = eHighest.next;
if (eHighest.dx == horizontal) eHighest = eHighest.next;
//finally insert each local minima ...
e = eHighest;
do {
e = AddBoundsToLML(e);
}
while( e != eHighest );
return true;
}
//------------------------------------------------------------------------------
public bool AddPath(Path pg, PolyType polyType, bool Closed)
{
#if use_lines
if (!Closed && polyType == PolyType.ptClip)
throw new ClipperException("AddPath: Open paths must be subject.");
#else
if (!Closed)
throw new ClipperException("AddPath: Open paths have been disabled.");
#endif
int highI = (int)pg.Count - 1;
bool ClosedOrSemiClosed = (highI > 0) && (Closed || (pg[0] == pg[highI]));
while (highI > 0 && (pg[highI] == pg[0])) --highI;
while (highI > 0 && (pg[highI] == pg[highI - 1])) --highI;
if ((Closed && highI < 2) || (!Closed && highI < 1)) return false;
//create a new edge array ...
List<TEdge> edges = new List<TEdge>(highI+1);
for (int i = 0; i <= highI; i++) edges.Add(new TEdge());
//1. Basic initialization of Edges ...
try
{
edges[1].Curr = pg[1];
RangeTest(pg[0], ref m_UseFullRange);
RangeTest(pg[highI], ref m_UseFullRange);
InitEdge(edges[0], edges[1], edges[highI], pg[0]);
InitEdge(edges[highI], edges[0], edges[highI - 1], pg[highI]);
for (int i = highI - 1; i >= 1; --i)
{
RangeTest(pg[i], ref m_UseFullRange);
InitEdge(edges[i], edges[i + 1], edges[i - 1], pg[i]);
}
}
catch
{
return false; //almost certainly a vertex has exceeded range
};
TEdge eStart = edges[0];
if (!ClosedOrSemiClosed) eStart.Prev.OutIdx = Skip;
//2. Remove duplicate vertices, and collinear edges (when closed) ...
TEdge E = eStart, eLoopStop = eStart;
for (;;)
{
if (E.Curr == E.Next.Curr)
{
//nb if E.OutIdx == Skip, it would have been semiOpen
if (E == eStart) eStart = E.Next;
E = RemoveEdge(E);
eLoopStop = E;
continue;
}
if (E.Prev == E.Next)
break; //only two vertices
else if ((ClosedOrSemiClosed ||
(E.Prev.OutIdx != Skip && E.OutIdx != Skip &&
E.Next.OutIdx != Skip)) &&
SlopesEqual(E.Prev.Curr, E.Curr, E.Next.Curr, m_UseFullRange))
{
//All collinear edges are allowed for open paths but in closed paths
//inner vertices of adjacent collinear edges are removed. However if the
//PreserveCollinear property has been enabled, only overlapping collinear
//edges (ie spikes) are removed from closed paths.
if (Closed && (!PreserveCollinear ||
!Pt2IsBetweenPt1AndPt3(E.Prev.Curr, E.Curr, E.Next.Curr)))
{
if (E == eStart) eStart = E.Next;
E = RemoveEdge(E);
E = E.Prev;
eLoopStop = E;
continue;
}
}
E = E.Next;
if (E == eLoopStop) break;
}
if ((!Closed && (E == E.Next)) || (Closed && (E.Prev == E.Next)))
return false;
m_edges.Add(edges);
if (!Closed)
m_HasOpenPaths = true;
//3. Do final Init and also find the 'highest' Edge. (nb: since I'm much
//more familiar with positive downwards Y axes, 'highest' here will be
//the Edge with the *smallest* Top.Y.)
TEdge eHighest = eStart;
E = eStart;
do
{
InitEdge2(E, polyType);
if (E.Top.Y < eHighest.Top.Y) eHighest = E;
E = E.Next;
}
while (E != eStart);
//4. build the local minima list ...
if (AllHorizontal(E))
{
if (ClosedOrSemiClosed)
E.Prev.OutIdx = Skip;
AscendToMax(ref E, false, false);
return true;
}
//if eHighest is also the Skip then it's a natural break, otherwise
//make sure eHighest is positioned so we're either at a top horizontal or
//just starting to head down one edge of the polygon
E = eStart.Prev; //EStart.Prev == Skip edge
if (E.Prev == E.Next)
eHighest = E.Next;
else if (!ClosedOrSemiClosed && E.Top.Y == eHighest.Top.Y)
{
if ((IsHorizontal(E) || IsHorizontal(E.Next)) &&
E.Next.Bot.Y == eHighest.Top.Y)
eHighest = E.Next;
else if (SharedVertWithPrevAtTop(E)) eHighest = E;
else if (E.Top == E.Prev.Top) eHighest = E.Prev;
else eHighest = E.Next;
} else
{
E = eHighest;
while (IsHorizontal(eHighest) ||
(eHighest.Top == eHighest.Next.Top) ||
(eHighest.Top == eHighest.Next.Bot)) //next is high horizontal
{
eHighest = eHighest.Next;
if (eHighest == E)
{
while (IsHorizontal(eHighest) || !SharedVertWithPrevAtTop(eHighest))
eHighest = eHighest.Next;
break; //avoids potential endless loop
}
}
}
E = eHighest;
do
E = AddBoundsToLML(E, Closed);
while (E != eHighest);
return true;
}
//------------------------------------------------------------------------------
private void InitEdge(TEdge e, TEdge eNext,
TEdge ePrev, IntPoint pt, PolyType polyType)
{
e.next = eNext;
e.prev = ePrev;
e.xcurr = pt.X;
e.ycurr = pt.Y;
if (e.ycurr >= e.next.ycurr)
{
e.xbot = e.xcurr;
e.ybot = e.ycurr;
e.xtop = e.next.xcurr;
e.ytop = e.next.ycurr;
e.windDelta = 1;
} else
{
e.xtop = e.xcurr;
e.ytop = e.ycurr;
e.xbot = e.next.xcurr;
e.ybot = e.next.ycurr;
e.windDelta = -1;
}
SetDx(e);
e.polyType = polyType;
e.outIdx = -1;
}
//------------------------------------------------------------------------------
public bool AddPaths(Paths ppg, PolyType polyType, bool closed)
{
bool result = false;
for (int i = 0; i < ppg.Count; ++i)
if (AddPath(ppg[i], polyType, closed)) result = true;
return result;
}
