//-----------------------------------------------------------------------
//
//ORIGINAL LINE: void _findAllIntersections(const Shape& STLAllocator<U, AllocPolicy>, List<IntersectionInShape>& intersections) const
private void _findAllIntersections(Shape other, ref std_vector<IntersectionInShape> intersections) {
for (ushort i = 0; i < getSegCount(); i++) {
Segment2D seg1 = new Segment2D(getPoint(i), getPoint(i + 1));
for (ushort j = 0; j < other.getSegCount(); j++) {
Segment2D seg2 = new Segment2D(other.getPoint(j), other.getPoint(j + 1));
Vector2 intersect = new Vector2();
if (seg1.findIntersect(seg2, ref intersect)) {
IntersectionInShape inter = new IntersectionInShape(i, j, intersect);
// check if intersection is "borderline" : too near to a vertex
if ((seg1.mA - intersect).SquaredLength < 1e-8) {
inter.onVertex[0] = true;
}
if ((seg1.mB - intersect).SquaredLength < 1e-8) {
inter.onVertex[0] = true;
inter.index[0]++;
}
if ((seg2.mA - intersect).SquaredLength < 1e-8) {
inter.onVertex[1] = true;
}
if ((seg2.mB - intersect).SquaredLength < 1e-8) {
inter.onVertex[1] = true;
inter.index[1]++;
}
intersections.push_back(inter);
}
}
}
}
//-----------------------------------------------------------------------
//
//ORIGINAL LINE: bool _findWhereToGo(const Shape* inputShapes[], BooleanOperationType opType, IntersectionInShape intersection, byte& shapeSelector, sbyte& isIncreasing, uint& currentSegment) const
private bool _findWhereToGo(Shape[] inputShapes, BooleanOperationType opType, IntersectionInShape intersection, ref byte shapeSelector, ref sbyte isIncreasing, ref uint currentSegment) {
if (intersection.onVertex[0] || intersection.onVertex[1]) {
// determine 4 directions with normal info
// if 2 normals "face each other" then you have the couple of outside directions
Vector2[] directions = new Vector2[4];
//string sides = new string(new char[4]);
byte[] sides = new byte[4];
byte incomingDirection;
// fill-in the incoming arrays
if (isIncreasing == 0) {
incomingDirection = 255;
}
else {
incomingDirection = (byte)(shapeSelector + (isIncreasing == 1 ? 2 : 0));
}
for (byte i = 0; i < 2; i++)
if (intersection.onVertex[i]) {
directions[i] = inputShapes[i].getDirectionBefore(intersection.index[i]);
directions[2 + i] = -inputShapes[i].getDirectionAfter(intersection.index[i]);
}
else {
directions[2 + i] = -inputShapes[i].getDirectionAfter(intersection.index[i]);
directions[i] = -directions[2 + i];
}
for (byte i = 0; i < 4; i++) {
sides[i] = (byte)((i / 2 == 0 ? -1 : 1) * (inputShapes[i % 2].mOutSide == Side.SIDE_RIGHT ? -1 : 1));
}
bool[] isOutside = new bool[4];
//std.pair<Radian, byte>[] sortedDirections = new std.pair[4];
KeyValuePair<Radian, byte>[] sortedDirections = new KeyValuePair<Radian, byte>[4];
// sort by angle
for (byte i = 0; i < 4; i++) {
if (i == 0) {
//sortedDirections[i].first = 0;
sortedDirections[i] = new KeyValuePair<Radian, byte>(0, i);
}
else {
Radian first = sides[0] * Utils.angleTo(directions[0], directions[i]);
sortedDirections[i] = new KeyValuePair<Radian, byte>(first, i);
}
//sortedDirections[i].second=i;
}
//std.sort(sortedDirections, sortedDirections+4, GlobalMembersProceduralShape._sortAngles);
//ToDo:sortedDirectionsÅÅÐò
List<KeyValuePair<Radian, byte>> sort_sortedDirections = new List<KeyValuePair<Radian, byte>>();
sort_sortedDirections.AddRange(sortedDirections);
sort_sortedDirections.Sort((X, Y) => {
return _sortAngles(X, Y) ? -1 : 1;
});
sortedDirections = sort_sortedDirections.ToArray();
//Array.Sort(sortedDirections);
//find which segments are outside
if (sides[0] != sides[sortedDirections[1].Value]) {
isOutside[0] = isOutside[sortedDirections[1].Value] = true;
isOutside[sortedDirections[2].Value] = isOutside[sortedDirections[3].Value] = false;
}
else {
isOutside[sortedDirections[1].Value] = isOutside[sortedDirections[2].Value] = true;
isOutside[sortedDirections[3].Value] = isOutside[sortedDirections[0].Value] = false;
}
//find first eligible segment that is not the current segment
for (ushort i = 0; i < 4; i++)
if ((isOutside[i] == _isLookingForOutside(opType, (sbyte)(i % 2))) && (i != incomingDirection)) {
shapeSelector = (byte)(i % 2);
isIncreasing = (sbyte)(i / 2 == 0 ? 1 : -1);
currentSegment = intersection.index[shapeSelector];
return true;
}
// if we reach here, it means that no segment is eligible! (it should only happen with difference opereation
return false;
}
else {
// determine which way to go
int nextShapeSelector = (shapeSelector + 1) % 2;
float d = inputShapes[nextShapeSelector].getDirectionAfter(intersection.index[nextShapeSelector]).DotProduct(inputShapes[shapeSelector].getNormalAfter(currentSegment));
isIncreasing = _isIncreasing(d, opType, (sbyte)nextShapeSelector);
shapeSelector = (byte)nextShapeSelector;
currentSegment = intersection.index[shapeSelector];
return true;
}
}
