public static void Add(
Action <PointD3D, VectorD3D> AddPositionAndNormal,
Action <int, int, int, bool> AddIndices,
ref int vertexIndexOffset,
bool isStartCap,
PointD3D basePoint,
VectorD3D westVector,
VectorD3D northVector,
VectorD3D forwardVectorNormalized,
ICrossSectionOfLine lineCrossSection,
PointD3D[] crossSectionPositions,
VectorD3D[] crossSectionNormals,
ref object temporaryStorageSpace,
ILineCapContour capContour
)
{
var crossSectionVertexCount = lineCrossSection.NumberOfVertices;
var crossSectionNormalCount = lineCrossSection.NumberOfNormals;
var contourZScale = 0.5 * Math.Max(lineCrossSection.Size1, lineCrossSection.Size2);
// do we need a flat end at the beginning of the cap?
if (null == crossSectionPositions && // if lineCrossSectionPositions are null, it means that our cap is not connected to the line and needs a flat end
capContour.Vertices(0) == _pointD2D_0_1) // furthermore the cap assumes to be started at the cross section
{
// the parameter isStartCap must be negated, because this flat cap is the "counterpart" of our cap to draw
Flat.AddGeometry(
AddPositionAndNormal,
AddIndices,
ref vertexIndexOffset,
!isStartCap,
basePoint,
westVector,
northVector,
forwardVectorNormalized,
lineCrossSection);
}
if (isStartCap)
{
forwardVectorNormalized = -forwardVectorNormalized;
}
var contourVertexCount = capContour.NumberOfVertices;
var contourNormalCount = capContour.NumberOfNormals;
// now the calculation can start
CrossSectionCases previousCrossSectionType = CrossSectionCases.MiddlePointSmooth;
int previousGeneratedPoints = 0;
int previousContourVertexIndex = 0;
bool isOnSecondSideOfContourVertexSharp = true;
for (int contourVertexIndex = 0, contourNormalIndex = 0; contourVertexIndex < contourVertexCount; ++contourVertexIndex, ++contourNormalIndex)
{
// we have 4 different situations here:
// 1st) the crossSection.Y is zero, thus this is the middle point (the normal should then go in z-direction) -> we need only one single vertex and normal for that
// 2nd) the countour normal is in x-direction -> we need only a point for each crossSection vertex, but not for each crossSectionNormal
// 3rd) the regular case -> we need a point for each crossSection normal
var capContourVertex = capContour.Vertices(contourVertexIndex);
var capContourNormal = capContour.Normals(contourNormalIndex);
CrossSectionCases currentCrossSectionType;
if (capContourVertex.Y == 0 && capContourNormal.Y == 0)
{
currentCrossSectionType = CrossSectionCases.MiddlePointSmooth;
}
else if (capContourVertex.Y == 0)
{
currentCrossSectionType = CrossSectionCases.MiddlePointSharp;
}
else if (0 == capContourNormal.Y)
{
currentCrossSectionType = CrossSectionCases.VerticesOnly;
}
else
{
currentCrossSectionType = CrossSectionCases.Regular;
}
var currentLocation = basePoint + forwardVectorNormalized * capContourVertex.X * contourZScale;
var matrix = Matrix4x3.NewFromBasisVectorsAndLocation(westVector, northVector, forwardVectorNormalized, currentLocation);
int currentGeneratedPoints = 0;
switch (currentCrossSectionType)
{
case CrossSectionCases.MiddlePointSmooth:
{
var position = matrix.Transform(PointD2D.Empty);
var normal = matrix.Transform(new VectorD3D(0, 0, capContourNormal.X));
AddPositionAndNormal(position, normal);
currentGeneratedPoints = 1;
}
break;
case CrossSectionCases.MiddlePointSharp:
{
for (int i = 0, j = 0; i < crossSectionVertexCount; ++i, ++j)
{
var normal1 = (i == 0) ? lineCrossSection.Normals(crossSectionNormalCount - 1) : lineCrossSection.Normals(j - 1);
var normal2 = lineCrossSection.Normals(j);
var sn = (normal1 + normal2).Normalized;
var utNormal = GetNormalVector(lineCrossSection.Vertices(i), sn, capContourNormal, contourZScale);
AddPositionAndNormal(currentLocation, matrix.Transform(utNormal)); // store the tip point with the averaged normal
if (lineCrossSection.IsVertexSharp(i))
{
++j;
}
}
currentGeneratedPoints = crossSectionVertexCount;
}
break;
case CrossSectionCases.VerticesOnly:
{
var commonNormal = matrix.Transform(new VectorD3D(0, 0, capContourNormal.X));
for (int i = 0; i < crossSectionVertexCount; ++i)
{
var position = matrix.Transform(lineCrossSection.Vertices(i) * capContourVertex.Y);
AddPositionAndNormal(position, commonNormal);
}
currentGeneratedPoints = crossSectionVertexCount;
}
break;
case CrossSectionCases.Regular:
{
for (int i = 0, j = 0; i < crossSectionVertexCount; ++i, ++j)
{
var sp = lineCrossSection.Vertices(i);
var sn = lineCrossSection.Normals(j);
var utNormal = GetNormalVector(sp, sn, capContourNormal, contourZScale);
var position = matrix.Transform(sp * capContourVertex.Y);
var normal = matrix.Transform(utNormal);
AddPositionAndNormal(position, normal);
if (lineCrossSection.IsVertexSharp(i))
{
++j;
sn = lineCrossSection.Normals(j);
utNormal = GetNormalVector(sp, sn, capContourNormal, contourZScale);
normal = matrix.Transform(utNormal);
AddPositionAndNormal(position, normal);
}
}
currentGeneratedPoints = crossSectionNormalCount;
}
break;
default:
throw new NotImplementedException();
}
vertexIndexOffset += currentGeneratedPoints;
// now we start generating triangles
if (contourVertexIndex > previousContourVertexIndex)
{
int voffset1 = vertexIndexOffset - currentGeneratedPoints;
int voffset0 = voffset1 - previousGeneratedPoints;
switch (previousCrossSectionType)
{
case CrossSectionCases.MiddlePointSmooth:
{
switch (currentCrossSectionType)
{
case CrossSectionCases.MiddlePointSmooth: // Middle point to middle point
{
// no triangles, since from middle point to middle point we have an infinity thin line
}
break;
case CrossSectionCases.MiddlePointSharp: // Middle point to middle point
{
// no triangles, since from middle point to middle point we have an infinity thin line
}
break;
case CrossSectionCases.VerticesOnly: // Middle point to vertices only
{
for (int i = 0; i < crossSectionVertexCount; ++i)
{
AddIndices(voffset0, voffset1 + i, voffset1 + (i + 1) % crossSectionVertexCount, isStartCap);
}
}
break;
case CrossSectionCases.Regular: // Middle point to regular
{
for (int i = 0; i < crossSectionNormalCount; ++i)
{
AddIndices(voffset0, voffset1 + i, voffset1 + (i + 1) % crossSectionNormalCount, isStartCap);
}
}
break;
default:
throw new NotImplementedException();
}
}
break;
case CrossSectionCases.MiddlePointSharp:
{
switch (currentCrossSectionType)
{
case CrossSectionCases.MiddlePointSmooth: // Middle point to middle point
{
// no triangles, since from middle point to middle point we have an infinity thin line
}
break;
case CrossSectionCases.MiddlePointSharp: // Middle point to middle point
{
// no triangles, since from middle point to middle point we have an infinity thin line
}
break;
case CrossSectionCases.VerticesOnly: // MiddlePointSharp to VerticesOnly
{
for (int i = 0; i < crossSectionVertexCount; ++i)
{
AddIndices(voffset0, voffset1 + i, voffset1 + (i + 1) % crossSectionVertexCount, isStartCap);
}
}
break;
case CrossSectionCases.Regular: // MiddlePointSharp to Regular
{
for (int i = 0, j = 0; i < crossSectionNormalCount; ++i, ++j)
{
AddIndices(voffset0 + i, voffset1 + i, voffset1 + (i + 1) % crossSectionNormalCount, isStartCap);
}
}
break;
default:
throw new NotImplementedException();
}
}
break;
case CrossSectionCases.VerticesOnly:
{
switch (currentCrossSectionType)
{
case CrossSectionCases.MiddlePointSmooth: // VerticesOnly to MiddlePoint
{
for (int i = 0; i < crossSectionVertexCount; ++i)
{
AddIndices(voffset1, voffset0 + i, voffset0 + (i + 1) % crossSectionVertexCount, isStartCap);
}
}
break;
case CrossSectionCases.VerticesOnly: // VerticesOnly to VerticesOnly
{
for (int i = 0; i < crossSectionVertexCount; ++i)
{
AddIndices(voffset0 + ((i == 0) ? crossSectionVertexCount - 1 : i - 1), voffset0 + i, voffset1 + i, isStartCap);
AddIndices(voffset0 + ((i == 0) ? crossSectionVertexCount - 1 : i - 1), voffset1 + i, voffset1 + ((i == 0) ? crossSectionVertexCount - 1 : i - 1), isStartCap);
}
}
break;
case CrossSectionCases.Regular: // VerticesOnly to regular
{
throw new NotImplementedException();
}
//break;
default:
throw new NotImplementedException();
}
}
break;
case CrossSectionCases.Regular:
{
switch (currentCrossSectionType)
{
case CrossSectionCases.MiddlePointSmooth: // Regular to MiddlePointOnly
{
for (int i = 0, j = 0; i < crossSectionVertexCount; ++i, ++j)
{
AddIndices(voffset0 + ((j == 0) ? crossSectionNormalCount - 1 : j - 1), voffset0 + j, voffset1, isStartCap);
if (lineCrossSection.IsVertexSharp(i))
{
++j;
}
}
}
break;
case CrossSectionCases.MiddlePointSharp: // Regular to MiddlePointSharp
{
for (int i = 0, j = 0; i < crossSectionVertexCount; ++i, ++j)
{
AddIndices(voffset0 + ((j == 0) ? crossSectionNormalCount - 1 : j - 1), voffset0 + j, voffset1 + i, isStartCap);
if (lineCrossSection.IsVertexSharp(i))
{
++j;
}
}
}
break;
case CrossSectionCases.VerticesOnly: // Regular to VerticesOnly
{
for (int i = 0, j = 0; i < crossSectionVertexCount; ++i, ++j)
{
AddIndices(voffset0 + ((j == 0) ? crossSectionNormalCount - 1 : j - 1), voffset0 + j, voffset1 + i, isStartCap);
AddIndices(voffset0 + ((j == 0) ? crossSectionNormalCount - 1 : j - 1), voffset1 + i, voffset1 + ((i == 0) ? crossSectionVertexCount - 1 : i - 1), isStartCap);
if (lineCrossSection.IsVertexSharp(i))
{
++j;
}
}
}
break;
case CrossSectionCases.Regular: // Regular to Regular
{
for (int i = 0, j = 0; i < crossSectionVertexCount; ++i, ++j)
{
AddIndices(voffset0 + ((j == 0) ? crossSectionNormalCount - 1 : j - 1), voffset0 + j, voffset1 + j, isStartCap);
AddIndices(voffset0 + ((j == 0) ? crossSectionNormalCount - 1 : j - 1), voffset1 + j, voffset1 + ((j == 0) ? crossSectionNormalCount - 1 : j - 1), isStartCap);
if (lineCrossSection.IsVertexSharp(i))
{
++j;
}
}
}
break;
default:
throw new NotImplementedException();
}
}
break;
default:
throw new NotImplementedException();
}
}
if (!isOnSecondSideOfContourVertexSharp && capContour.IsVertexSharp(contourVertexIndex) && contourVertexIndex < (contourVertexCount - 1))
{
previousContourVertexIndex = contourVertexIndex;
--contourVertexIndex; // trick: decrement the vertex index, it is incremented then again in the following for loop, so that contourVertexIndex stays constant
isOnSecondSideOfContourVertexSharp = true;
continue;
}
isOnSecondSideOfContourVertexSharp = false;
// now we switch the current calculated positions and normals with the old ones
previousCrossSectionType = currentCrossSectionType;
previousGeneratedPoints = currentGeneratedPoints;
previousContourVertexIndex = contourVertexIndex;
}
}
public static void Add(
Action<PointD3D, VectorD3D> AddPositionAndNormal,
Action<int, int, int, bool> AddIndices,
ref int vertexIndexOffset,
bool isStartCap,
PointD3D basePoint,
VectorD3D westVector,
VectorD3D northVector,
VectorD3D forwardVectorNormalized,
ICrossSectionOfLine lineCrossSection,
PointD3D[] crossSectionPositions,
VectorD3D[] crossSectionNormals,
ref object temporaryStorageSpace,
ILineCapContour capContour
)
{
var crossSectionVertexCount = lineCrossSection.NumberOfVertices;
var crossSectionNormalCount = lineCrossSection.NumberOfNormals;
var contourZScale = 0.5 * Math.Max(lineCrossSection.Size1, lineCrossSection.Size2);
// do we need a flat end at the beginning of the cap?
if (null == crossSectionPositions && // if lineCrossSectionPositions are null, it means that our cap is not connected to the line and needs a flat end
capContour.Vertices(0) == _pointD2D_0_1) // furthermore the cap assumes to be started at the cross section
{
// the parameter isStartCap must be negated, because this flat cap is the "counterpart" of our cap to draw
Flat.AddGeometry(
AddPositionAndNormal,
AddIndices,
ref vertexIndexOffset,
!isStartCap,
basePoint,
westVector,
northVector,
forwardVectorNormalized,
lineCrossSection);
}
if (isStartCap)
forwardVectorNormalized = -forwardVectorNormalized;
var contourVertexCount = capContour.NumberOfVertices;
var contourNormalCount = capContour.NumberOfNormals;
// now the calculation can start
CrossSectionCases previousCrossSectionType = CrossSectionCases.MiddlePointSmooth;
int previousGeneratedPoints = 0;
int previousContourVertexIndex = 0;
bool isOnSecondSideOfContourVertexSharp = true;
for (int contourVertexIndex = 0, contourNormalIndex = 0; contourVertexIndex < contourVertexCount; ++contourVertexIndex, ++contourNormalIndex)
{
// we have 4 different situations here:
// 1st) the crossSection.Y is zero, thus this is the middle point (the normal should then go in z-direction) -> we need only one single vertex and normal for that
// 2nd) the countour normal is in x-direction -> we need only a point for each crossSection vertex, but not for each crossSectionNormal
// 3rd) the regular case -> we need a point for each crossSection normal
var capContourVertex = capContour.Vertices(contourVertexIndex);
var capContourNormal = capContour.Normals(contourNormalIndex);
CrossSectionCases currentCrossSectionType;
if (capContourVertex.Y == 0 && capContourNormal.Y == 0)
currentCrossSectionType = CrossSectionCases.MiddlePointSmooth;
else if (capContourVertex.Y == 0)
currentCrossSectionType = CrossSectionCases.MiddlePointSharp;
else if (0 == capContourNormal.Y)
currentCrossSectionType = CrossSectionCases.VerticesOnly;
else
currentCrossSectionType = CrossSectionCases.Regular;
var currentLocation = basePoint + forwardVectorNormalized * capContourVertex.X * contourZScale;
var matrix = Matrix4x3.NewFromBasisVectorsAndLocation(westVector, northVector, forwardVectorNormalized, currentLocation);
int currentGeneratedPoints = 0;
switch (currentCrossSectionType)
{
case CrossSectionCases.MiddlePointSmooth:
{
var position = matrix.Transform(PointD2D.Empty);
var normal = matrix.Transform(new VectorD3D(0, 0, capContourNormal.X));
AddPositionAndNormal(position, normal);
currentGeneratedPoints = 1;
}
break;
case CrossSectionCases.MiddlePointSharp:
{
for (int i = 0, j = 0; i < crossSectionVertexCount; ++i, ++j)
{
var normal1 = (i == 0) ? lineCrossSection.Normals(crossSectionNormalCount - 1) : lineCrossSection.Normals(j - 1);
var normal2 = lineCrossSection.Normals(j);
var sn = (normal1 + normal2).Normalized;
var utNormal = GetNormalVector(lineCrossSection.Vertices(i), sn, capContourNormal, contourZScale);
AddPositionAndNormal(currentLocation, matrix.Transform(utNormal)); // store the tip point with the averaged normal
if (lineCrossSection.IsVertexSharp(i))
{
++j;
}
}
currentGeneratedPoints = crossSectionVertexCount;
}
break;
case CrossSectionCases.VerticesOnly:
{
var commonNormal = matrix.Transform(new VectorD3D(0, 0, capContourNormal.X));
for (int i = 0; i < crossSectionVertexCount; ++i)
{
var position = matrix.Transform(lineCrossSection.Vertices(i) * capContourVertex.Y);
AddPositionAndNormal(position, commonNormal);
}
currentGeneratedPoints = crossSectionVertexCount;
}
break;
case CrossSectionCases.Regular:
{
for (int i = 0, j = 0; i < crossSectionVertexCount; ++i, ++j)
{
var sp = lineCrossSection.Vertices(i);
var sn = lineCrossSection.Normals(j);
var utNormal = GetNormalVector(sp, sn, capContourNormal, contourZScale);
var position = matrix.Transform(sp * capContourVertex.Y);
var normal = matrix.Transform(utNormal);
AddPositionAndNormal(position, normal);
if (lineCrossSection.IsVertexSharp(i))
{
++j;
sn = lineCrossSection.Normals(j);
utNormal = GetNormalVector(sp, sn, capContourNormal, contourZScale);
normal = matrix.Transform(utNormal);
AddPositionAndNormal(position, normal);
}
}
currentGeneratedPoints = crossSectionNormalCount;
}
break;
default:
throw new NotImplementedException();
}
vertexIndexOffset += currentGeneratedPoints;
// now we start generating triangles
if (contourVertexIndex > previousContourVertexIndex)
{
int voffset1 = vertexIndexOffset - currentGeneratedPoints;
int voffset0 = voffset1 - previousGeneratedPoints;
switch (previousCrossSectionType)
{
case CrossSectionCases.MiddlePointSmooth:
{
switch (currentCrossSectionType)
{
case CrossSectionCases.MiddlePointSmooth: // Middle point to middle point
{
// no triangles, since from middle point to middle point we have an infinity thin line
}
break;
case CrossSectionCases.MiddlePointSharp: // Middle point to middle point
{
// no triangles, since from middle point to middle point we have an infinity thin line
}
break;
case CrossSectionCases.VerticesOnly: // Middle point to vertices only
{
for (int i = 0; i < crossSectionVertexCount; ++i)
{
AddIndices(voffset0, voffset1 + i, voffset1 + (i + 1) % crossSectionVertexCount, isStartCap);
}
}
break;
case CrossSectionCases.Regular: // Middle point to regular
{
for (int i = 0; i < crossSectionNormalCount; ++i)
{
AddIndices(voffset0, voffset1 + i, voffset1 + (i + 1) % crossSectionNormalCount, isStartCap);
}
}
break;
default:
throw new NotImplementedException();
}
}
break;
case CrossSectionCases.MiddlePointSharp:
{
switch (currentCrossSectionType)
{
case CrossSectionCases.MiddlePointSmooth: // Middle point to middle point
{
// no triangles, since from middle point to middle point we have an infinity thin line
}
break;
case CrossSectionCases.MiddlePointSharp: // Middle point to middle point
{
// no triangles, since from middle point to middle point we have an infinity thin line
}
break;
case CrossSectionCases.VerticesOnly: // MiddlePointSharp to VerticesOnly
{
for (int i = 0; i < crossSectionVertexCount; ++i)
{
AddIndices(voffset0, voffset1 + i, voffset1 + (i + 1) % crossSectionVertexCount, isStartCap);
}
}
break;
case CrossSectionCases.Regular: // MiddlePointSharp to Regular
{
for (int i = 0, j = 0; i < crossSectionNormalCount; ++i, ++j)
{
AddIndices(voffset0 + i, voffset1 + i, voffset1 + (i + 1) % crossSectionNormalCount, isStartCap);
}
}
break;
default:
throw new NotImplementedException();
}
}
break;
case CrossSectionCases.VerticesOnly:
{
switch (currentCrossSectionType)
{
case CrossSectionCases.MiddlePointSmooth: // VerticesOnly to MiddlePoint
{
for (int i = 0; i < crossSectionVertexCount; ++i)
{
AddIndices(voffset1, voffset0 + i, voffset0 + (i + 1) % crossSectionVertexCount, isStartCap);
}
}
break;
case CrossSectionCases.VerticesOnly: // VerticesOnly to VerticesOnly
{
for (int i = 0; i < crossSectionVertexCount; ++i)
{
AddIndices(voffset0 + ((i == 0) ? crossSectionVertexCount - 1 : i - 1), voffset0 + i, voffset1 + i, isStartCap);
AddIndices(voffset0 + ((i == 0) ? crossSectionVertexCount - 1 : i - 1), voffset1 + i, voffset1 + ((i == 0) ? crossSectionVertexCount - 1 : i - 1), isStartCap);
}
}
break;
case CrossSectionCases.Regular: // VerticesOnly to regular
{
throw new NotImplementedException();
}
//break;
default:
throw new NotImplementedException();
}
}
break;
case CrossSectionCases.Regular:
{
switch (currentCrossSectionType)
{
case CrossSectionCases.MiddlePointSmooth: // Regular to MiddlePointOnly
{
for (int i = 0, j = 0; i < crossSectionVertexCount; ++i, ++j)
{
AddIndices(voffset0 + ((j == 0) ? crossSectionNormalCount - 1 : j - 1), voffset0 + j, voffset1, isStartCap);
if (lineCrossSection.IsVertexSharp(i))
++j;
}
}
break;
case CrossSectionCases.MiddlePointSharp: // Regular to MiddlePointSharp
{
for (int i = 0, j = 0; i < crossSectionVertexCount; ++i, ++j)
{
AddIndices(voffset0 + ((j == 0) ? crossSectionNormalCount - 1 : j - 1), voffset0 + j, voffset1 + i, isStartCap);
if (lineCrossSection.IsVertexSharp(i))
++j;
}
}
break;
case CrossSectionCases.VerticesOnly: // Regular to VerticesOnly
{
for (int i = 0, j = 0; i < crossSectionVertexCount; ++i, ++j)
{
AddIndices(voffset0 + ((j == 0) ? crossSectionNormalCount - 1 : j - 1), voffset0 + j, voffset1 + i, isStartCap);
AddIndices(voffset0 + ((j == 0) ? crossSectionNormalCount - 1 : j - 1), voffset1 + i, voffset1 + ((i == 0) ? crossSectionVertexCount - 1 : i - 1), isStartCap);
if (lineCrossSection.IsVertexSharp(i))
++j;
}
}
break;
case CrossSectionCases.Regular: // Regular to Regular
{
for (int i = 0, j = 0; i < crossSectionVertexCount; ++i, ++j)
{
AddIndices(voffset0 + ((j == 0) ? crossSectionNormalCount - 1 : j - 1), voffset0 + j, voffset1 + j, isStartCap);
AddIndices(voffset0 + ((j == 0) ? crossSectionNormalCount - 1 : j - 1), voffset1 + j, voffset1 + ((j == 0) ? crossSectionNormalCount - 1 : j - 1), isStartCap);
if (lineCrossSection.IsVertexSharp(i))
++j;
}
}
break;
default:
throw new NotImplementedException();
}
}
break;
default:
throw new NotImplementedException();
}
}
if (!isOnSecondSideOfContourVertexSharp && capContour.IsVertexSharp(contourVertexIndex) && contourVertexIndex < (contourVertexCount - 1))
{
previousContourVertexIndex = contourVertexIndex;
--contourVertexIndex; // trick: decrement the vertex index, it is incremented then again in the following for loop, so that contourVertexIndex stays constant
isOnSecondSideOfContourVertexSharp = true;
continue;
}
isOnSecondSideOfContourVertexSharp = false;
// now we switch the current calculated positions and normals with the old ones
previousCrossSectionType = currentCrossSectionType;
previousGeneratedPoints = currentGeneratedPoints;
previousContourVertexIndex = contourVertexIndex;
}
}