/// <summary>
/// Added function to set the root
/// </summary>
/// <param name="glb">GLB to add</param>
/// <param name="newRoot">The new root to update it with</param>
public static void SetRoot(GLBObject glb, GLTFRoot newRoot)
{
if (newRoot != null)
{
glb.Root = newRoot;
}
}
/// <summary>
/// Merges two glb files together
/// </summary>
/// <param name="mergeTo">The glb to update</param>
/// <param name="mergeFrom">The glb to merge from</param>
public static void MergeGLBs(GLBObject mergeTo, GLBObject mergeFrom)
{
if (mergeTo == null)
{
throw new ArgumentNullException(nameof(mergeTo));
}
if (mergeFrom == null)
{
throw new ArgumentNullException(nameof(mergeFrom));
}
// 1) merge json
// 2) copy mergefrom binary data to mergeto binary data
// 3) Fix up bufferviews to be the new offset
int previousBufferViewsCount = mergeTo.Root.BufferViews?.Count ?? 0;
uint previousBufferSize = mergeTo.BinaryChunkInfo.Length;
GLTFHelpers.MergeGLTF(mergeTo.Root, mergeFrom.Root);
_AddBinaryData(mergeTo, mergeFrom.Stream, false, mergeFrom.BinaryChunkInfo.StartPosition + GLTFParser.CHUNK_HEADER_SIZE);
uint bufferSizeDiff =
mergeTo.BinaryChunkInfo.Length -
previousBufferSize; // calculate buffer size change to update the byte offsets of the appended buffer views
if (mergeTo.Root.BufferViews != null)
{
for (int i = previousBufferViewsCount; i < mergeTo.Root.BufferViews.Count; ++i)
{
mergeTo.Root.BufferViews[i].ByteOffset += bufferSizeDiff;
}
}
}
/// <summary>
/// Adds binary data to the GLB
/// </summary>
/// <param name="glb">The glb to update</param>
/// <param name="binaryData">The binary data to append</param>
/// <param name="createBufferView">Whether a buffer view should be created, added to the GLTFRoot, and id returned</param>
/// <param name="streamStartPosition">Start position of stream</param>
/// <param name="bufferViewName">Root to replace the current one with</param>
/// <returns>The location of the added buffer view</returns>
public static BufferViewId AddBinaryData(GLBObject glb, Stream binaryData, bool createBufferView = true, long streamStartPosition = 0, string bufferViewName = null)
{
if (glb == null)
{
throw new ArgumentNullException(nameof(glb));
}
if (glb.Root == null && bufferViewName == null)
{
throw new ArgumentException("glb Root and new root cannot be null", nameof(glb));
}
if (glb.Stream == null)
{
throw new ArgumentException("glb Stream cannot be null", nameof(glb));
}
if (binaryData == null)
{
throw new ArgumentNullException(nameof(binaryData));
}
if (binaryData.Length > uint.MaxValue)
{
throw new ArgumentException("Stream cannot be larger than uint.MaxValue", nameof(binaryData));
}
return(_AddBinaryData(glb, binaryData, createBufferView, streamStartPosition, bufferViewName));
}
private static GLBObject _ConstructFromEmptyStream(Stream inStream, long streamStartPosition)
{
GLBObject glbObject = new GLBObject
{
Stream = inStream,
JsonChunkInfo = new ChunkInfo
{
Length = 0,
StartPosition = GLTFParser.HEADER_SIZE,
Type = ChunkFormat.JSON
},
BinaryChunkInfo = new ChunkInfo
{
Length = 0,
StartPosition = GLTFParser.HEADER_SIZE + GLTFParser.CHUNK_HEADER_SIZE,
Type = ChunkFormat.BIN
},
Header = new GLBHeader
{
FileLength = GLTFParser.HEADER_SIZE,
Version = 2
},
StreamStartPosition = streamStartPosition
};
return(glbObject);
}
public GLBObject(GLBObject other)
{
Root = other.Root;
Header = other.Header;
StreamStartPosition = other.StreamStartPosition;
JsonChunkInfo = other.JsonChunkInfo;
BinaryChunkInfo = other.BinaryChunkInfo;
}
/// <summary>
/// Turns a glTF file w/ structure into a GLB. Does not currently copy binary data
/// </summary>
/// <param name="root">The glTF root to turn into a GLBObject</param>
/// <param name="glbOutStream">Output stream to write the GLB to</param>
/// <param name="loader">Loader for loading external components from GLTFRoot. The loader will receive uris and return the stream to the resource</param>
/// <returns>A constructed GLBObject</returns>
private static GLBObject ConstructFromGLTF(GLTFRoot root, Stream glbOutStream, Func <string, Stream> loader)
{
if (root == null)
{
throw new ArgumentNullException(nameof(root));
}
if (glbOutStream == null)
{
throw new ArgumentNullException(nameof(glbOutStream));
}
MemoryStream gltfJsonStream = new MemoryStream();
using (StreamWriter sw = new StreamWriter(gltfJsonStream))
{
root.Serialize(sw, true);
sw.Flush();
long proposedLength = gltfJsonStream.Length + GLTFParser.HEADER_SIZE + GLTFParser.CHUNK_HEADER_SIZE;
if (gltfJsonStream.Length > uint.MaxValue)
{
throw new ArgumentException("Serialized root cannot exceed uint.maxvalue", nameof(root));
}
uint proposedLengthAsUint = (uint)proposedLength;
glbOutStream.SetLength(proposedLengthAsUint);
GLBObject glbObject = new GLBObject
{
Header = new GLBHeader
{
FileLength = proposedLengthAsUint,
Version = 2
},
Root = root,
Stream = glbOutStream,
JsonChunkInfo = new ChunkInfo
{
Length = (uint)gltfJsonStream.Length,
StartPosition = GLTFParser.HEADER_SIZE,
Type = ChunkFormat.JSON
}
};
// write header
WriteHeader(glbOutStream, glbObject.Header, glbObject.StreamStartPosition);
// write chunk header
WriteChunkHeader(glbOutStream, glbObject.JsonChunkInfo);
gltfJsonStream.Position = 0;
gltfJsonStream.CopyTo(glbOutStream);
// todo: implement getting binary data for loader
return(glbObject);
}
}
/// <summary>
/// Removes a blob from the GLB at the given BufferView
/// Updates accessors and images to have correct new bufferview index
/// This function can invalidate BufferViewId's returned by previous function
/// </summary>
/// <param name="glb">The glb to remove from</param>
/// <param name="bufferViewId">The buffer to remove</param>
public static void RemoveBinaryData(GLBObject glb, BufferViewId bufferViewId)
{
if (glb == null)
{
throw new ArgumentNullException(nameof(glb));
}
if (bufferViewId == null)
{
throw new ArgumentNullException(nameof(bufferViewId));
}
BufferView bufferViewToRemove = bufferViewId.Value;
int id = bufferViewId.Id;
if (bufferViewToRemove.ByteOffset + bufferViewToRemove.ByteLength == glb.BinaryChunkInfo.Length)
{
uint bufferViewLengthAsUint = bufferViewToRemove.ByteLength;
glb.SetFileLength(glb.Header.FileLength - bufferViewLengthAsUint);
glb.SetBinaryChunkLength(glb.BinaryChunkInfo.Length - bufferViewLengthAsUint);
if (glb.BinaryChunkInfo.Length == 0)
{
glb.Root.Buffers.RemoveAt(0);
foreach (BufferView bufferView in glb.Root.BufferViews) // other buffers may still exist, and their index has now changed
{
--bufferView.Buffer.Id;
}
glb.SetFileLength(glb.Header.FileLength - GLTFParser.CHUNK_HEADER_SIZE);
}
else
{
glb.Root.Buffers[0].ByteLength = glb.BinaryChunkInfo.Length;
// write binary chunk header
WriteChunkHeader(glb.Stream, glb.BinaryChunkInfo);
}
// trim the end
glb.Stream.SetLength(glb.Header.FileLength);
// write glb header
WriteHeader(glb.Stream, glb.Header, glb.StreamStartPosition);
}
glb.Root.BufferViews.RemoveAt(id);
if (glb.Root.Accessors != null)
{
foreach (Accessor accessor in glb.Root.Accessors) // shift over all accessors
{
if (accessor.BufferView != null && accessor.BufferView.Id >= id)
{
--accessor.BufferView.Id;
}
if (accessor.Sparse != null)
{
if (accessor.Sparse.Indices?.BufferView.Id >= id)
{
--accessor.Sparse.Indices.BufferView.Id;
}
if (accessor.Sparse.Values?.BufferView.Id >= id)
{
--accessor.Sparse.Values.BufferView.Id;
}
}
}
}
if (glb.Root.Images != null)
{
foreach (GLTFImage image in glb.Root.Images)
{
if (image.BufferView != null && image.BufferView.Id >= id)
{
--image.BufferView.Id;
}
}
}
}
private static BufferViewId _AddBinaryData(GLBObject glb, Stream binaryData, bool createBufferView, long streamStartPosition, string bufferViewName = null)
{
binaryData.Position = streamStartPosition;
// Append new binary chunk to end
uint blobLengthAsUInt = CalculateAlignment((uint)(binaryData.Length - streamStartPosition), 4);
uint newBinaryBufferSize = glb.BinaryChunkInfo.Length + blobLengthAsUInt;
uint newGLBSize = glb.Header.FileLength + blobLengthAsUInt;
uint blobWritePosition = glb.Header.FileLength;
// there was an existing file that had no binary chunk info previously
if (glb.BinaryChunkInfo.Length == 0)
{
newGLBSize += GLTFParser.CHUNK_HEADER_SIZE;
blobWritePosition += GLTFParser.CHUNK_HEADER_SIZE;
glb.SetBinaryChunkStartPosition(glb.Header.FileLength); // if 0, then appends chunk info at the end
}
glb.Stream.SetLength(glb.Header.FileLength + blobLengthAsUInt);
glb.Stream.Position = blobWritePosition; // assuming the end of the file is the end of the binary chunk
binaryData.CopyTo(glb.Stream); // make sure this doesn't supersize it
glb.SetFileLength(newGLBSize);
glb.SetBinaryChunkLength(newBinaryBufferSize);
// write glb header past magic number
WriteHeader(glb.Stream, glb.Header, glb.StreamStartPosition);
WriteChunkHeader(glb.Stream, glb.BinaryChunkInfo);
if (createBufferView)
{
// Add a new BufferView to the GLTFRoot
BufferView bufferView = new BufferView
{
Buffer = new BufferId
{
Id = 0,
Root = glb.Root
},
ByteLength = blobLengthAsUInt, // figure out whether glb size is wrong or if documentation is unclear
ByteOffset = glb.BinaryChunkInfo.Length - blobLengthAsUInt,
Name = bufferViewName
};
if (glb.Root.BufferViews == null)
{
glb.Root.BufferViews = new List <BufferView>();
}
glb.Root.BufferViews.Add(bufferView);
return(new BufferViewId
{
Id = glb.Root.BufferViews.Count - 1,
Root = glb.Root
});
}
return(null);
}
/// <summary>
/// Saves out the GLBObject to its own stream
/// The GLBObject stream will be updated to be the output stream. Callers are reponsible for handling Stream lifetime
/// </summary>
/// <param name="glb">The GLB to flush to the output stream and update</param>
/// <param name="newRoot">Optional root to replace the one in the glb</param>
/// <returns>A GLBObject that is based upon outStream</returns>
public static void UpdateStream(GLBObject glb)
{
if (glb.Root == null)
{
throw new ArgumentException("glb Root and newRoot cannot be null", nameof(glb.Root));
}
if (glb.Stream == null)
{
throw new ArgumentException("glb GLBStream property cannot be null", nameof(glb.Stream));
}
MemoryStream gltfJsonStream = new MemoryStream();
using (StreamWriter sw = new StreamWriter(gltfJsonStream))
{
glb.Root.Serialize(sw, true); // todo: this could out of memory exception
sw.Flush();
if (gltfJsonStream.Length > int.MaxValue)
{
// todo: make this a non generic exception
throw new Exception("JSON chunk of GLB has exceeded maximum allowed size (4 GB)");
}
// realloc of out of space
if (glb.JsonChunkInfo.Length < gltfJsonStream.Length)
{
uint proposedJsonChunkLength = (uint)System.Math.Min((long)gltfJsonStream.Length * 2, uint.MaxValue); // allocate double what is required
proposedJsonChunkLength = CalculateAlignment(proposedJsonChunkLength, 4);
// chunks must be 4 byte aligned
uint amountToAddToFile = proposedJsonChunkLength - glb.JsonChunkInfo.Length;
// we have not yet initialized a json chunk before
if (glb.JsonChunkInfo.Length == 0)
{
amountToAddToFile += GLTFParser.CHUNK_HEADER_SIZE;
glb.SetJsonChunkStartPosition(GLTFParser.HEADER_SIZE);
}
// new proposed length = propsoedJsonBufferSize - currentJsonBufferSize + totalFileLength
long proposedLength = amountToAddToFile + glb.Header.FileLength;
if (proposedLength > uint.MaxValue)
{
throw new Exception("GLB has exceeded max allowed size (4 GB)");
}
uint proposedLengthAsUint = (uint)proposedLength;
try
{
glb.Stream.SetLength(proposedLength);
}
catch (IOException e)
{
#if WINDOWS_UWP
Debug.WriteLine(e);
#else
Console.WriteLine(e);
#endif
throw;
}
long newBinaryChunkStartPosition =
GLTFParser.HEADER_SIZE + GLTFParser.CHUNK_HEADER_SIZE + proposedJsonChunkLength;
glb.Stream.Position = glb.BinaryChunkInfo.StartPosition;
glb.SetBinaryChunkStartPosition(newBinaryChunkStartPosition);
if (glb.BinaryChunkInfo.Length > 0)
{
uint lengthToCopy = glb.BinaryChunkInfo.Length + GLTFParser.CHUNK_HEADER_SIZE;
// todo: we need to be able to copy while doing it with smaller buffers. Also int is smaller than uint, so this is not standards compliant.
glb.Stream.CopyToSelf((int)newBinaryChunkStartPosition,
lengthToCopy);
}
// write out new GLB length
glb.SetFileLength(proposedLengthAsUint);
WriteHeader(glb.Stream, glb.Header, glb.StreamStartPosition);
// write out new JSON header
glb.SetJsonChunkLength(proposedJsonChunkLength);
WriteChunkHeader(glb.Stream, glb.JsonChunkInfo);
}
// clear the buffer
glb.Stream.Position = glb.JsonChunkInfo.StartPosition + GLTFParser.CHUNK_HEADER_SIZE;
uint amountToCopy = glb.JsonChunkInfo.Length;
while (amountToCopy != 0)
{
int currAmountToCopy = (int)System.Math.Min(amountToCopy, int.MaxValue);
byte[] filler =
Encoding.ASCII.GetBytes(new string(' ', currAmountToCopy));
glb.Stream.Write(filler, 0, filler.Length);
amountToCopy -= (uint)currAmountToCopy;
}
// write new JSON data
gltfJsonStream.Position = 0;
glb.Stream.Position = glb.JsonChunkInfo.StartPosition + GLTFParser.CHUNK_HEADER_SIZE;
gltfJsonStream.CopyTo(glb.Stream);
glb.Stream.Flush();
}
}
