internal static int InternalBinarySearch(SegmentedArray <T> array, int index, int length, T value, IComparer <T> comparer)
{
LorettaDebug.Assert(index >= 0 && length >= 0 && (array.Length - index >= length), "Check the arguments in the caller!");
int lo = index;
int hi = index + length - 1;
while (lo <= hi)
{
int i = lo + ((hi - lo) >> 1);
int order = comparer.Compare(array[i], value);
if (order == 0)
{
return(i);
}
if (order < 0)
{
lo = i + 1;
}
else
{
hi = i - 1;
}
}
return(~lo);
}
private static void ResetToSequence(SegmentedArray <IntPtr> array)
{
for (var i = 0; i < array.Length; i++)
{
array[i] = (IntPtr)i;
}
}
private IEnumerable <Point3D> Point3DFromLinearCoordinates(SegmentedArray <STL_Showcase.Logic.Rendering.Mesh3D.Vertexh> vertices)
{
for (int i = 0; i < vertices.Length; i++)
{
yield return(new Point3D(vertices[i].x, vertices[i].y, vertices[i].z));
}
}
public UnalignedSegmentEnumerable(
SegmentedArray <T> first,
SegmentedArray <T> second,
int length
) : this(first, 0, second, 0, length)
{
}
public void GlobalSetup()
{
_values = new int[Count];
_valuesObject = new object?[Count];
_segmentedValues = new SegmentedArray <int>(Count);
_segmentedValuesObject = new SegmentedArray <object?>(Count);
}
private IEnumerable <Point3D> Point3DFromLinearCoordinates(SegmentedArray <Half> vertices)
{
for (int i = 0; i + 2 < vertices.Length; i += 3)
{
yield return(new Point3D(vertices[i], vertices[i + 1], vertices[i + 2]));
}
}
public TokenStream(TreeData treeData, SyntaxFormattingOptions options, TextSpan spanToFormat, AbstractTriviaDataFactory factory)
{
using (Logger.LogBlock(FunctionId.Formatting_TokenStreamConstruction, CancellationToken.None))
{
// initialize basic info
_factory = factory;
_treeData = treeData;
_options = options;
// use some heuristics to get initial size of list rather than blindly start from default size == 4
var sizeOfList = spanToFormat.Length / MagicTextLengthToTokensRatio;
_tokens = new SegmentedList <SyntaxToken>(sizeOfList);
_tokens.AddRange(_treeData.GetApplicableTokens(spanToFormat));
Debug.Assert(this.TokenCount > 0);
// initialize trivia related info
_cachedOriginalTriviaInfo = new SegmentedArray <TriviaData>(this.TokenCount - 1);
// Func Cache
_getTriviaData = this.GetTriviaData;
_getOriginalTriviaData = this.GetOriginalTriviaData;
}
DebugCheckTokenOrder();
}
public void TestIndexer(int length)
{
var data = new SegmentedArray <IntPtr>(length);
ResetToSequence(data);
for (var i = 0; i < length; i++)
{
data[i] = (IntPtr)i;
}
for (var i = 0; i < length; i++)
{
Assert.Equal((IntPtr)i, data[i]);
}
for (var i = 0; i < length; i++)
{
ref var value = ref data[i];
Assert.Equal((IntPtr)i, data[i]);
value = IntPtr.Add(value, 1);
Assert.Equal((IntPtr)(i + 1), value);
Assert.Equal((IntPtr)(i + 1), data[i]);
}
public UnalignedSegmentEnumerable(SegmentedArray <T> first, int firstOffset, SegmentedArray <T> second, int secondOffset, int length)
{
_first = first;
_firstOffset = firstOffset;
_second = second;
_secondOffset = secondOffset;
_length = length;
}
public SegmentEnumerable(SegmentedArray<T> array, int offset, int length)
{
if (offset < 0 || length < 0 || (uint)(offset + length) > (uint)array.Length)
ThrowHelper.ThrowArgumentOutOfRangeException();
_array = array;
_offset = offset;
_length = length;
}
public Mesh3D(SegmentedArray <Vertexh> vertices, SegmentedArray <int> triangles, Half[] faceNormals = null)
{
this.Vertices = vertices;
this.Triangles = triangles;
this.vertexNormals = faceNormals;
Scale = 1f;
OffsetX = 0f;
OffsetY = 0f;
OffsetZ = 0f;
}
public void GlobalSetup()
{
_values = new List <int>(Count);
_valuesObject = new List <object?>(Count);
_segmentedValues = new Microsoft.CodeAnalysis.Collections.SegmentedList <int>(Count);
_segmentedValuesObject = new Microsoft.CodeAnalysis.Collections.SegmentedList <object?>(Count);
_insertValues = new int[100];
_insertValuesObject = new object?[100];
_segmentedInsertValues = new SegmentedArray <int>(100);
_segmentedInsertValuesObject = new SegmentedArray <object?>(100);
}
static Mesh3D ParseSTLASCII(ModelFileData fileData)
{
// STL ASCII Format: https://en.wikipedia.org/wiki/STL_(file_format)#Binary_STL
if (!fileData.HasBytes())
{
return(null);
}
List <Mesh3D.Vertexh> vertices = new List <Mesh3D.Vertexh>();
try
{
Stream fileDataStream = fileData.GetStream();
fileDataStream.Position = 0;
StreamReader reader = new StreamReader(fileDataStream);
while (!reader.EndOfStream)
{
string line = reader.ReadLine().TrimStart();
if (!line.StartsWith("vertex"))
{
continue;
}
for (int i = 0; i < 3; i++)
{
var matches = Regex.Matches(line, FloatStringPattern);
vertices.Add(new Mesh3D.Vertexh(
Half.Parse(matches[0].Value),
Half.Parse(matches[1].Value),
Half.Parse(matches[2].Value)
));
line = reader.ReadLine().TrimStart();
}
}
}
catch (Exception ex)
{
logger.Trace(ex, "Exception when processing file: {FileName}, {FileSizeKB}, {FileType}", fileData.FileName, fileData.FileSizeKB, fileData.FileType.ToString());
return(null);
}
SegmentedArray <Mesh3D.Vertexh> verticesArray = new SegmentedArray <Mesh3D.Vertexh>(vertices.Count);
SegmentedArray <int> trianglesArray = new SegmentedArray <int>(vertices.Count);
for (int i = 0; i < vertices.Count; i++)
{
verticesArray[i] = vertices[i];
trianglesArray[i] = i;
}
return(new Mesh3D(verticesArray, trianglesArray));
}
public static int BinarySearch(SegmentedArray <T> array, int index, int length, T value, IComparer <T>?comparer)
{
try
{
comparer ??= Comparer <T> .Default;
return(InternalBinarySearch(array, index, length, value, comparer));
}
catch (Exception e)
{
ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_IComparerFailed, e);
return(0);
}
}
public Mesh3DExtended(SegmentedArray <Half> vertices) : base(vertices)
{
this.Triangles = new Triangle[TriangleCount];
for (int i = 0, j = 0; i < TriangleCount; i++, j += 9)
{
Triangles[i] = new Triangle(
new Vertex(Vertices[j], Vertices[j + 1], Vertices[j + 2]),
new Vertex(Vertices[j + 3], Vertices[j + 4], Vertices[j + 5]),
new Vertex(Vertices[j + 6], Vertices[j + 7], Vertices[j + 8])
);
}
}
public void TestBasicProperties(int length)
{
var data = new SegmentedArray <IntPtr>(length);
Assert.True(data.IsFixedSize);
Assert.False(data.IsReadOnly);
Assert.False(data.IsSynchronized);
Assert.Equal(length, data.Length);
Assert.Same(data.GetTestAccessor().Items, data.SyncRoot);
Assert.Equal(length, ((ICollection)data).Count);
Assert.Equal(length, ((ICollection <IntPtr>)data).Count);
Assert.Equal(length, ((IReadOnlyCollection <IntPtr>)data).Count);
}
private void ApplyTokenOperations(
FormattingContext context,
NodeOperations nodeOperations,
SegmentedArray <TokenPairWithOperations> tokenOperations,
CancellationToken cancellationToken)
{
var applier = new OperationApplier(context, _formattingRules);
ApplySpaceAndWrappingOperations(context, tokenOperations, applier, cancellationToken);
ApplyAnchorOperations(context, tokenOperations, applier, cancellationToken);
ApplySpecialOperations(context, nodeOperations, applier, cancellationToken);
}
protected override StreamArray build_stream()
{
const int src_length = 3;
var a = new SegmentedArray <short>(this._items.Count, src_length);
for (int i = 0; i < this._items.Count; i++)
{
var src = this._items[i];
var item = a[i];
item[0] = src.Section;
item[1] = src.Row;
item[2] = src.Cell;
}
return(new StreamArray(a.Array, Streams.StreamType.Src, this.Count));
}
public void TestConstructor2(int length)
{
var data = new SegmentedArray <IntPtr>(length);
Assert.Equal(length, data.Length);
var items = data.GetTestAccessor().Items;
Assert.Equal(length, items.Sum(item => item.Length));
for (var i = 0; i < items.Length - 1; i++)
{
Assert.Equal(SegmentedArray <IntPtr> .TestAccessor.SegmentSize, items[i].Length);
Assert.True(items[i].Length <= SegmentedArray <IntPtr> .TestAccessor.SegmentSize);
}
}
private SegmentedArray <TokenPairWithOperations> CreateTokenOperation(
TokenStream tokenStream,
CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
using (Logger.LogBlock(FunctionId.Formatting_CollectTokenOperation, cancellationToken))
{
// pre-allocate list once. this is cheaper than re-adjusting list as items are added.
var list = new SegmentedArray <TokenPairWithOperations>(tokenStream.TokenCount - 1);
foreach (var(index, currentToken, nextToken) in tokenStream.TokenIterator)
{
cancellationToken.ThrowIfCancellationRequested();
var spaceOperation = _formattingRules.GetAdjustSpacesOperation(currentToken, nextToken);
var lineOperation = _formattingRules.GetAdjustNewLinesOperation(currentToken, nextToken);
list[index] = new TokenPairWithOperations(tokenStream, index, spaceOperation, lineOperation);
}
return(list);
}
}
static Mesh3D ParseSTLBinary(ModelFileData fileData)
{
// STL Binary Format: https://en.wikipedia.org/wiki/STL_(file_format)#Binary_STL
if (!fileData.HasBytes())
{
return(null);
}
byte[] byteBuffer = new byte[4 * 9];
int index = 80;
int byteBufferIndex = 0;
fileData.ReadBytes(byteBuffer, index, 0, 4);
int triangleAmount = (int)System.BitConverter.ToUInt32(byteBuffer, 0); index += 4;
if (triangleAmount <= 0 || fileData.BytesLength < 80 + triangleAmount * 50)
{
return(null);
}
try
{
if (triangleAmount <= 0 || triangleAmount > 10000000)
{
throw new Exception("The STLBinary file has too many triangles.");
}
SegmentedArray <int> triangles = new SegmentedArray <int>(triangleAmount * 3);
SegmentedArray <Mesh3D.Vertexh> vertices = new SegmentedArray <Mesh3D.Vertexh>(triangleAmount * 3);
for (int i = 0; i < triangles.Length;)
{
// Skip reading the facet normal (why STL come with normals???).
index += 4 * 3;
// Triangle vertices
{
fileData.ReadBytes(byteBuffer, index, 0, byteBuffer.Length); byteBufferIndex = 0;
index += 4 * 9;
vertices[i] = new Mesh3D.Vertexh(
(Half)System.BitConverter.ToSingle(byteBuffer, byteBufferIndex),
(Half)System.BitConverter.ToSingle(byteBuffer, byteBufferIndex += 4),
(Half)System.BitConverter.ToSingle(byteBuffer, byteBufferIndex += 4)
);
triangles[i] = i++;
vertices[i] = new Mesh3D.Vertexh(
(Half)System.BitConverter.ToSingle(byteBuffer, byteBufferIndex += 4),
(Half)System.BitConverter.ToSingle(byteBuffer, byteBufferIndex += 4),
(Half)System.BitConverter.ToSingle(byteBuffer, byteBufferIndex += 4)
);
triangles[i] = i++;
vertices[i] = new Mesh3D.Vertexh(
(Half)System.BitConverter.ToSingle(byteBuffer, byteBufferIndex += 4),
(Half)System.BitConverter.ToSingle(byteBuffer, byteBufferIndex += 4),
(Half)System.BitConverter.ToSingle(byteBuffer, byteBufferIndex += 4)
);
triangles[i] = i++;
}
// Skip the remaining bytes.
index += 2;
}
return(new Mesh3D(vertices, triangles));
}
catch (Exception ex)
{
logger.Trace(ex, "Exception when processing file: {FileName}, {FileSizeKB}, {FileType}", fileData.FileName, fileData.FileSizeKB, fileData.FileType.ToString());
return(null);
}
}
static Mesh3D ParseWavefront(ModelFileData fileData)
{
// Wavefront OBJ Format: https://en.wikipedia.org/wiki/Wavefront_.obj_file
if (!fileData.HasBytes())
{
return(null);
}
List <Mesh3D.Vertexh> vertices = new List <Mesh3D.Vertexh>();
List <int> triangles = new List <int>();
try
{
Stream fileDataStream = fileData.GetStream();
fileDataStream.Position = 0;
StreamReader reader = new StreamReader(fileDataStream);
while (!reader.EndOfStream)
{
string line = reader.ReadLine().TrimStart();
if (string.IsNullOrWhiteSpace(line))
{
continue;
}
if (line.StartsWith("v "))
{
var matches = Regex.Matches(line, FloatStringPattern);
if (matches.Count >= 6)
{ // Dodge the vertex color (or is it supposed to come after x y z? Wikipedia is not clear about it).
vertices.Add(new Mesh3D.Vertexh(
Half.Parse(matches[0].Value),
Half.Parse(matches[2].Value),
Half.Parse(matches[4].Value)
));
}
else
{
vertices.Add(new Mesh3D.Vertexh(
Half.Parse(matches[0].Value),
Half.Parse(matches[1].Value),
Half.Parse(matches[2].Value)
));
}
}
else if (line.StartsWith("f"))
{
IEnumerable <string> faceIndexes = line.Split(' ').Where(s => s != "f" && !string.IsNullOrWhiteSpace(s));
int index0 = triangles.Count; // First index added for this line.
for (int i = 0; i < faceIndexes.Count(); i++)
{
int.TryParse(faceIndexes.ElementAt(i).Split('/').First(), out int parsedIndex);
// Handle the face as a triangle fan to support faces with more than 3 vertex (idea from https://notes.underscorediscovery.com/obj-parser-easy-parse-time-triangulation/).
if (i >= 3)
{
triangles.Add(triangles[index0]);
triangles.Add(triangles[triangles.Count - 2]);
}
triangles.Add(parsedIndex - 1); // -1 because our array starts at 0 while the OBJ starts at 1.
}
}
else
{
continue;
}
}
}
catch (Exception ex)
{
logger.Trace(ex, "Exception when processing file: {FileName}, {FileSizeKB}, {FileType}", fileData.FileName, fileData.FileSizeKB, fileData.FileType.ToString());
return(null);
}
SegmentedArray <Mesh3D.Vertexh> verticesArray = new SegmentedArray <Mesh3D.Vertexh>(vertices.Count);
SegmentedArray <int> trianglesArray = new SegmentedArray <int>(triangles.Count);
for (int i = 0; i < vertices.Count; i++)
{
verticesArray[i] = vertices[i];
}
for (int i = 0; i < triangles.Count; i++)
{
trianglesArray[i] = triangles[i];
}
return(new Mesh3D(verticesArray, trianglesArray));
}
public Enumerator(SegmentedArray <T> array)
{
_items = array._items;
_nextItemSegment = 0;
_nextItemIndex = 0;
_current = default !;
static Mesh3D Parse3MF(ModelFileData filedData)
{
#if !X64
// The library is not supported for no x64 builds.
return(null);
#else
// 3MF (3D Manufacturing Format): https://github.com/3MFConsortium/spec_core/blob/master/3MF%20Core%20Specification.md
// File loading using Lib3MF: https://github.com/3MFConsortium/lib3mf
List <int> trianglesList = new List <int>();
List <Mesh3D.Vertexh> vertexList = new List <Mesh3D.Vertexh>();
Lib3MF.CModel model = Lib3MF.Wrapper.CreateModel();
model.QueryReader("3mf").ReadFromFile(filedData.FileFullPath);
var meshIterator = model.GetMeshObjects();
int lastMeshVertexIndex = 0;
while (meshIterator.MoveNext())
{
var resource = meshIterator.GetCurrent();
Lib3MF.CMeshObject meshobject = model.GetMeshObjectByID(resource.GetResourceID());
int triangleAmount = (int)meshobject.GetTriangleCount();
if (triangleAmount == 0)
{
continue;
}
for (int i = 0; i < triangleAmount; i++)
{
var triangle = meshobject.GetTriangle((uint)i);
int index0 = trianglesList.Count;
for (int j = 0; j < triangle.Indices.Length; j++)
{
if (j >= 3)
{ // Trick to triangulate polygons with more than 3 vertex.
trianglesList.Add(trianglesList[index0]);
trianglesList.Add(trianglesList[trianglesList.Count - 2]);
}
trianglesList.Add(lastMeshVertexIndex + (int)triangle.Indices[j]);
}
}
var vertexAmount = meshobject.GetVertexCount();
for (int i = 0; i < vertexAmount; i++)
{
var vertex = meshobject.GetVertex((uint)i);
vertexList.Add(new Mesh3D.Vertexh((Half)vertex.Coordinates[0], (Half)vertex.Coordinates[1], (Half)vertex.Coordinates[2]));
}
lastMeshVertexIndex = vertexList.Count;
}
if (trianglesList.Count == 0 || vertexList.Count == 0)
{
return(null);
}
SegmentedArray <Mesh3D.Vertexh> verticesArray = new SegmentedArray <Mesh3D.Vertexh>(vertexList.Count);
SegmentedArray <int> trianglesArray = new SegmentedArray <int>(trianglesList.Count);
for (int i = 0; i < vertexList.Count; i++)
{
verticesArray[i] = vertexList[i];
}
for (int i = 0; i < trianglesList.Count; i++)
{
trianglesArray[i] = trianglesList[i];
}
return(new Mesh3D(verticesArray, trianglesArray));
#endif
}
public SegmentedArraySegment(SegmentedArray <T> array, int start, int length)
{
Array = array;
Start = start;
Length = length;
}
public SegmentEnumerable(SegmentedArray <T> array)
{
_array = array;
_offset = 0;
_length = array.Length;
}
