private static bool HaveLineSegmentsIntersection(BzPolyLoop[] loops, LoopIndex l1, LoopIndex l2)
{
Vector2 b1 = l1.vector2d;
Vector2 b2 = l2.vector2d;
int i1 = l1.indexPointer.value;
int i2 = l2.indexPointer.value;
for (int j = 0; j < loops.Length; j++)
{
var loop = loops[j];
var edgeNode = loop.edgeLoop.first;
Vector2 prevA = loop.polyVertices2D[loop.edgeLoop.size - 1];
int prevI = edgeNode.previous.value;
for (int i = 0; i < loop.edgeLoop.size; i++)
{
Vector2 a1 = prevA;
Vector2 a2 = loop.polyVertices2D[i];
prevA = a2;
int ii1 = prevI;
int ii2 = edgeNode.value;
prevI = ii2;
edgeNode = edgeNode.next;
if (ii1 == i1 | ii1 == i2 |
ii2 == i1 | ii2 == i2)
{
continue;
}
var d = (a2.x - a1.x) * (b2.y - b1.y) - (a2.y - a1.y) * (b2.x - b1.x);
if (d == 0.0f)
{
continue;
}
var u = ((b1.x - a1.x) * (b2.y - b1.y) - (b1.y - a1.y) * (b2.x - b1.x)) / d;
var v = ((b1.x - a1.x) * (a2.y - a1.y) - (b1.y - a1.y) * (a2.x - a1.x)) / d;
if (u >= 0.0f & u <= 1.0f & v >= 0.0f & v <= 1.0f)
{
return(true);
}
}
}
return(false);
}
private void OptimizeData(out LoopIndex[] newLoopIndexers, out int[] triangles)
{
bool[] inUseValues = new bool[_loopPoints.Length];
// if it is the same index, use only first one
var length = _newTriangles.Count;
for (int i = 0; i < length; i++)
{
int iindex = _newTriangles[i];
int vertexIndex = _loopPoints[iindex].indexPointer.value;
for (int l = i + 1; l < length; l++)
{
int iindex2 = _newTriangles[l];
int vertexIndex2 = _loopPoints[iindex2].indexPointer.value;
if (vertexIndex == vertexIndex2)
{
_newTriangles[l] = iindex;
}
}
}
for (int i = 0; i < length; ++i)
{
int vertexIndex = _newTriangles[i];
inUseValues[vertexIndex] = true;
}
// count how much values in use
int newLength = 0;
for (int i = 0; i < inUseValues.Length; i++)
{
var inUse = inUseValues[i];
if (inUse)
{
++newLength;
}
}
var vertexIndexShift = new int[_loopPoints.Length];
int index = 0;
newLoopIndexers = new LoopIndex[newLength];
for (int i = 0; i < _loopPoints.Length; i++)
{
var edgeValue = _loopPoints[i];
var inUse = inUseValues[i];
if (!inUse)
{
vertexIndexShift[i] = -1;
continue;
}
vertexIndexShift[i] = index;
newLoopIndexers[index] = edgeValue;
++index;
}
triangles = new int[length];
for (int i = 0; i < triangles.Length; i++)
{
var trIndex = _newTriangles[i];
trIndex = vertexIndexShift[trIndex];
triangles[i] = trIndex;
}
}
private LoopIndex[] CombineLoops(BzPolyLoop outer, BzPolyLoop[] inners)
{
var outerData = GetIndexCollection(outer);
var innersData = new LoopIndexCollection[inners.Length];
for (int i = 0; i < innersData.Length; i++)
{
var loop = inners[i];
innersData[i] = GetIndexCollection(loop);
}
var allLoops = new BzPolyLoop[inners.Length + 1];
allLoops[0] = outer;
Array.Copy(inners, 0, allLoops, 1, inners.Length);
for (int i = 0; i < innersData.Length; i++)
{
LoopNode <LoopIndex> minOliNode;
LoopNode <LoopIndex> minIliNode;
var inner = inners[i];
var innerData = innersData[i];
if (outer.Volume <= inner.Volume)
{
continue;
}
if (!inner.IsInside(outer))
{
continue;
}
if (!GetShortestConnection(outerData, innerData, allLoops, out minOliNode, out minIliNode))
{
continue;
}
if (minOliNode != null)
{
outerToInnerConnections.Add(new IndexVector(
minOliNode.value.indexPointer.value,
minIliNode.value.indexPointer.value)
);
var list = minOliNode.list;
list.InsertAfter(minOliNode, minOliNode.value);
list.InsertAfter(minOliNode, minIliNode.value);
list.InsertAfter(minOliNode, minIliNode, minIliNode.previous);
}
}
var result = new LoopIndex[outerData.items.size];
var node = outerData.items.first;
for (int i = 0; i < outerData.items.size; i++)
{
result[i] = node.value;
node = node.next;
}
return(result);
}
