public static UnsafeRawList <byte> ReadToEnd(this Stream stream, out int length)
{
if (stream is null)
{
throw new ArgumentNullException(nameof(stream));
}
var buf = new UnsafeRawList <byte>(0);
try {
length = 0;
while (true)
{
var span = buf.Extend(1024);
var readLen = stream.Read(span);
length += readLen;
if (readLen == 0)
{
break;
}
}
return(buf);
}
catch {
buf.Dispose();
throw;
}
}
public FbxConnectionResolver(FbxNode connectionsNode)
{
var count = connectionsNode.Children.Count;
var destLists = new UnsafeRawList <UnsafeRawList <long> >(count);
var srcToDest = new BufferPooledDictionary <long, int>(count);
var destToSrc = new BufferPooledDictionary <long, int>(count);
var srcLists = new UnsafeRawList <UnsafeRawList <long> >(count);
try {
foreach (var c in connectionsNode.Children)
{
var props = c.Properties;
var conn = new Connection(props[0].AsString().ToConnectionType(), props[1].AsInt64(), props[2].AsInt64());
// Create source-to-dest dictionary
{
UnsafeRawList <long> dests;
if (srcToDest.TryAdd(conn.SourceID, destLists.Count))
{
dests = new UnsafeRawList <long>();
destLists.Add(dests);
}
else
{
dests = destLists[srcToDest[conn.SourceID]];
}
Debug.Assert(dests.IsNull == false);
dests.Add(conn.DestID);
}
// Create dest-to-source dictionary
{
UnsafeRawList <long> sources;
if (destToSrc.TryAdd(conn.DestID, srcLists.Count))
{
sources = new UnsafeRawList <long>();
srcLists.Add(sources);
}
else
{
sources = srcLists[destToSrc[conn.DestID]];
}
Debug.Assert(sources.IsNull == false);
sources.Add(conn.SourceID);
}
}
}
catch {
destLists.Dispose();
srcToDest.Dispose();
destToSrc.Dispose();
srcLists.Dispose();
throw;
}
_destLists = destLists;
_srcToDest = srcToDest;
_destToSrc = destToSrc;
_srcLists = srcLists;
}
public void New()
{
using (var list = UnsafeRawList <int> .Null) {
Assert.True(list.Equals(list));
Assert.Throws <NullReferenceException>(() => list.Count);
Assert.Throws <NullReferenceException>(() => list.Capacity);
Assert.Throws <NullReferenceException>(() => list.Ptr);
Assert.Throws <NullReferenceException>(() => list.Add(0));
}
using (var list = new UnsafeRawList <int>()) {
Assert.Equal(0, list.Count);
Assert.True(list.Capacity >= 0);
Assert.NotEqual(IntPtr.Zero, list.Ptr);
}
using (var list = new UnsafeRawList <int>(10)) {
Assert.Equal(0, list.Count);
Assert.Equal(10, list.Capacity);
Assert.NotEqual(IntPtr.Zero, list.Ptr);
}
ReadOnlySpan <int> source = Enumerable.Range(0, 100).ToArray();
using (var list = new UnsafeRawList <int>(source)) {
Assert.Equal(source.Length, list.Count);
Assert.True(source.Length >= list.Capacity);
Assert.NotEqual(IntPtr.Zero, list.Ptr);
Assert.True(list.AsSpan().SequenceEqual(source));
}
}
public static unsafe FbxObject Parse(Stream stream)
{
if (stream is null)
{
throw new ArgumentNullException(nameof(stream));
}
var reader = new Reader(stream);
ParseHeader(reader, out var version);
UnsafeRawList <FbxNode_> nodes = default;
try {
while (true)
{
if (!ParseNodeRecord(reader, version, out var node))
{
break;
}
nodes.Add(node);
}
return(new FbxObject(nodes));
}
catch {
nodes.Dispose();
throw;
}
}
public ResolvedMesh()
{
const int capacity = 1024;
_vertices = new UnsafeRawList <TVertex>(capacity);
_indices = new UnsafeRawList <int>(capacity);
}
public ObjObjectCore()
{
_positions = new UnsafeRawList <Vector3>();
_normals = new UnsafeRawList <Vector3>();
_uvs = new UnsafeRawList <Vector2>();
_positionIndices = new UnsafeRawList <int>();
_normalIndices = new UnsafeRawList <int>();
_uvIndices = new UnsafeRawList <int>();
}
public void Clear()
{
ReadOnlySpan <int> source = Enumerable.Range(0, 10).ToArray();
using (var list = new UnsafeRawList <int>(source)) {
list.Clear();
Assert.Equal(0, list.Count);
Assert.True(list.Capacity >= 0);
}
}
public unsafe void GetReference()
{
using (var list = new UnsafeRawList <int>(0)) {
Assert.True(Unsafe.AsPointer(ref list.GetReference()) == null);
}
using (var list = new UnsafeRawList <int>(new[] { 0, 1, 2, 3, 4 })) {
Assert.True(Unsafe.AreSame(ref list.GetReference(), ref list[0]));
}
}
public void IndexOf()
{
ReadOnlySpan <int> source = Enumerable.Range(0, 10).ToArray();
using (var list = new UnsafeRawList <int>(source)) {
for (int i = 0; i < list.Count; i++)
{
Assert.True(list.IndexOf(i) == list[i]);
}
}
}
public void Remove()
{
const int Count = 10;
ReadOnlySpan <int> source = Enumerable.Range(0, Count).ToArray();
using (var list = new UnsafeRawList <int>(source)) {
for (int i = 0; i < Count; i++)
{
var removed = list.Remove(i);
Assert.True(removed);
Assert.Equal(Count - i - 1, list.Count);
}
}
}
public void RemoveAt()
{
const int Count = 10;
ReadOnlySpan <int> source = Enumerable.Range(0, Count).ToArray();
using (var list = new UnsafeRawList <int>(source)) {
Assert.True(list.AsSpan().SequenceEqual(source));
list.RemoveAt(5);
Assert.True(list.AsSpan().SequenceEqual(new[] { 0, 1, 2, 3, 4, 6, 7, 8, 9 }));
list.RemoveAt(0);
Assert.True(list.AsSpan().SequenceEqual(new[] { 1, 2, 3, 4, 6, 7, 8, 9 }));
list.RemoveAt(1);
Assert.True(list.AsSpan().SequenceEqual(new[] { 1, 3, 4, 6, 7, 8, 9 }));
list.RemoveAt(6);
Assert.True(list.AsSpan().SequenceEqual(new[] { 1, 3, 4, 6, 7, 8, }));
}
}
public void Extend()
{
using (var list = new UnsafeRawList <int>(0)) {
Assert.True(list.Count == 0);
Assert.True(list.Capacity == 0);
var extended = list.Extend(0, true);
Assert.True(list.Count == 0);
Assert.True(list.Capacity == 0);
Assert.True(extended.IsEmpty);
}
using (var list = new UnsafeRawList <int>(0)) {
Assert.True(list.Count == 0);
Assert.True(list.Capacity == 0);
var extended = list.Extend(3, true);
Assert.True(list.Count == 3);
// When extended, the minimum capacity is 4.
Assert.True(list.Capacity == 4);
Assert.True(extended.Length == 3);
}
using (var list = new UnsafeRawList <int>(40)) {
Assert.True(list.Count == 0);
Assert.True(list.Capacity == 40);
var extended1 = list.Extend(10, true);
Assert.True(list.Count == 10);
// The capacity does not changed because it is large enough,.
Assert.True(list.Capacity == 40);
Assert.True(extended1.Length == 10);
// -----------------------------
var extended2 = list.Extend(50, true);
Assert.True(list.Count == 60);
// 'Extend' does not allocate memory of the exact size, but allocates a large enough size.
// It is twice the size of the current one.
Assert.True(list.Capacity == 80);
Assert.True(extended2.Length == 50);
}
}
private static UnsafeRawList <byte> ReadToBuffer(Stream stream, out int length)
{
if (stream.CanSeek)
{
var streamLen = stream.Length;
if (streamLen <= int.MaxValue)
{
var buffer = new UnsafeRawList <byte>((int)streamLen);
try {
length = stream.Read(buffer.Extend((int)streamLen, false));
return(buffer);
}
catch {
buffer.Dispose();
throw;
}
}
else
{
throw new NotSupportedException();
}
}
else
{
var buffer = new UnsafeRawList <byte>();
var totalLen = 0;
while (true)
{
const int BlockSize = 1024;
var readLen = stream.Read(buffer.Extend(BlockSize, false));
totalLen += readLen;
if (readLen < BlockSize)
{
break;
}
}
length = totalLen;
return(buffer);
}
}
public void Add()
{
using (var list = new UnsafeRawList <int>()) {
const int Count = 10;
for (int i = 0; i < Count; i++)
{
list.Add(i);
}
for (int i = 0; i < list.Count; i++)
{
Assert.Equal(i, list[i]);
}
}
ReadOnlySpan <int> source = Enumerable.Range(0, 100).ToArray();
using (var list = new UnsafeRawList <int>(source)) {
list.AddRange(source);
Assert.True(list.AsSpan(0, source.Length).SequenceEqual(source));
Assert.True(list.AsSpan(source.Length, source.Length).SequenceEqual(source));
}
}
private ResolvedMeshList(int capacity)
{
_meshes = new UnsafeRawList <ResolvedMesh <TVertex> >(capacity);
}
public static Image Parse(Stream stream)
{
CheckSignature(stream);
var buf = new BufferSpanReader(stackalloc byte[8]);
using var data = new UnsafeRawList <byte>(0);
UnsafeEx.SkipInitIfPossible(out Header header);
var palette = UnsafeRawArray <PngColor> .Empty;
try {
bool hasHeader = false;
while (true)
{
buf.Position = 0;
stream.SafeRead(buf.Span);
var chunkSize = buf.Next(4).Int32BigEndian();
var chunkType = buf.Next(4);
if (hasHeader == false)
{
if (chunkType.SequenceEqual(ChunkTypeIHDR))
{
hasHeader = true;
ParseIHDR(stream, chunkSize, out header);
ValidateHeader(header);
}
else
{
ThrowHelper.ThrowFormatException("No IHDR chunk");
}
}
else
{
if (chunkType.SequenceEqual(ChunkTypeIDAT))
{
ParseIDAT(stream, chunkSize, data);
}
else if (chunkType.SequenceEqual(ChunkTypeIEND))
{
if (chunkSize != 0)
{
ThrowHelper.ThrowFormatException("IEND chunk size must be 0");
}
break;
}
else if (chunkType.SequenceEqual(ChunkTypePLTE))
{
palette = ParsePLTE(stream, chunkSize);
}
else
{
Debug.WriteLine(System.Text.Encoding.ASCII.GetString(chunkType) + " (skip)");
stream.SafeSkip(chunkSize); // Skip not supported chunk
}
}
stream.SafeSkip(4); // I don't validate CRC
}
Debug.Assert(hasHeader);
return(Decompress(data, header, palette.AsSpan()));
}
finally {
palette.Dispose();
}
}
