internal void _ResolveSatelliteDependencies(ReadContext context) { // resolve satellite buffers foreach (var buffer in this._buffers) { buffer._ResolveUri(context); } // resolve satellite images foreach (var image in this._images) { // reads the image file into the current object. image._ResolveUri(context); // if we have a decoder hook, call the decoder, and free the memory. if (context.ImageDecoder != null) { if (!context.ImageDecoder(image)) { image._DiscardContent(); } } } }
/// <summary> /// Creates a complete clone of this <see cref="ModelRoot"/> instance. /// </summary> /// <returns>A new <see cref="ModelRoot"/> instance.</returns> /// <remarks> /// Deep cloning is performed as a brute force operation; by serializing /// the whole model to GLTF into memory, and then deserializing it back to DOM. /// </remarks> public ModelRoot DeepClone() { // prepare the in-memory temporary storage var dict = new Dictionary <string, ArraySegment <Byte> >(); var wcontext = WriteContext .CreateFromDictionary(dict) .WithDeepCloneSettings(); System.Diagnostics.Debug.Assert(wcontext._NoCloneWatchdog, "invalid clone settings"); // write the model to the temporary storage wcontext.WriteTextSchema2("deepclone", this); // restore the model from the temporary storage var rcontext = ReadContext.CreateFromDictionary(dict, wcontext._UpdateSupportedExtensions); rcontext.Validation = Validation.ValidationMode.Skip; var cloned = rcontext._ReadFromDictionary("deepclone.gltf"); // Restore MemoryImage source URIs (they're not cloned as part of the serialization) foreach (var srcImg in this.LogicalImages) { var dstImg = cloned.LogicalImages[srcImg.LogicalIndex]; var img = dstImg.Content; dstImg.Content = new Memory.MemoryImage(img._GetBuffer(), srcImg.Content.SourcePath); } return(cloned); }
public static Validation.ValidationResult Validate(string filePath) { Guard.FilePathMustExist(filePath, nameof(filePath)); var context = ReadContext.CreateFromFile(filePath); return(context.Validate(filePath)); }
public static Validation.ValidationResult Validate(string filePath) { Guard.NotNull(filePath, nameof(filePath)); Guard.FilePathMustExist(filePath, nameof(filePath)); var dir = Path.GetDirectoryName(filePath); filePath = System.IO.Path.GetFileName(filePath); var context = ReadContext.CreateFromDirectory(dir); return context.Validate(filePath); }
private static Byte[] _LoadBinaryBufferUnchecked(string uri, ReadContext context) { var data = uri.TryParseBase64Unchecked(EMBEDDEDGLTFBUFFER, EMBEDDEDOCTETSTREAM); if (data != null) { return(data); } return(context .ReadAllBytesToEnd(uri) .ToUnderlayingArray()); }
/// <summary> /// Gets the list of satellite / dependency files for a given glTF file. /// This includes binary blobs and texture images. /// </summary> /// <param name="filePath">A valid file path.</param> /// <returns>A list of relative file paths, as found in the file.</returns> /// <remarks> /// This method is designed to be as fast as possible, and it avoids performing much /// of the validation and parsing of a glTf file, it just blindly looks for URI fields. /// </remarks> public static string[] GetSatellitePaths(string filePath) { Guard.FilePathMustExist(filePath, nameof(filePath)); var json = ReadOnlyMemory <byte> .Empty; using (var s = File.OpenRead(filePath)) { json = ReadContext.ReadJsonBytes(s); } return(ParseSatellitePaths(json)); }
/// <summary> /// Reads a <see cref="MODEL"/> instance from a path pointing to a GLB or a GLTF file /// </summary> /// <param name="filePath">A valid file path.</param> /// <param name="settings">Optional settings.</param> /// <returns>A <see cref="MODEL"/> instance.</returns> public static MODEL Load(string filePath, ReadSettings settings = null) { Guard.FilePathMustExist(filePath, nameof(filePath)); var context = ReadContext .CreateFromFile(filePath) .WithSettingsFrom(settings); using (var s = File.OpenRead(filePath)) { return(context.ReadSchema2(s)); } }
/// <summary> /// Reads a <see cref="MODEL"/> instance from a path pointing to a GLB or a GLTF file /// </summary> /// <param name="filePath">A valid file path.</param> /// <param name="settings">Optional settings.</param> /// <returns>A <see cref="MODEL"/> instance.</returns> /// <remarks> /// <paramref name="settings"/> can be either a plain <see cref="ReadSettings"/> instance, /// or a <see cref="ReadContext"/>, in which case, the context will be used to read the /// files from it. /// </remarks> public static MODEL Load(string filePath, ReadSettings settings = null) { Guard.NotNull(filePath, nameof(filePath)); if (!(settings is ReadContext context)) { Guard.FilePathMustExist(filePath, nameof(filePath)); var dir = Path.GetDirectoryName(filePath); filePath = System.IO.Path.GetFileName(filePath); context = ReadContext .CreateFromDirectory(dir) .WithSettingsFrom(settings); } return context.ReadSchema2(filePath); }
private (MODEL Model, Validation.ValidationResult Validation) _ReadGLB(Stream stream) { Guard.NotNull(stream, nameof(stream)); IReadOnlyDictionary <uint, byte[]> chunks; try { chunks = _BinarySerialization.ReadBinaryFile(stream); } catch (System.IO.EndOfStreamException ex) { var vr = new Validation.ValidationResult(null, this.Validation); vr.SetError(new Validation.SchemaException(null, ex.Message)); return(null, vr); } catch (Validation.SchemaException ex) { var vr = new Validation.ValidationResult(null, this.Validation); vr.SetError(ex); return(null, vr); } var context = this; if (chunks.ContainsKey(_BinarySerialization.CHUNKBIN)) { // clone self var binChunk = chunks[_BinarySerialization.CHUNKBIN]; context = new ReadContext(context); context._BinaryChunk = binChunk; } var jsonChunk = chunks[_BinarySerialization.CHUNKJSON]; return(context._Read(jsonChunk)); }
internal void _ResolveUri(ReadContext context) { _Content = _LoadBinaryBufferUnchecked(_uri, context); _uri = null; // When _Data is not empty, clear URI }
internal ReadContext(ReadContext other) : base(other) { this._FileReader = other._FileReader; this.ImageDecoder = other.ImageDecoder; }