Example #1
0
        private static void _Write(WriteSettings settings, string baseName, MODEL model)
        {
            Guard.NotNull(settings, nameof(settings));
            Guard.NotNullOrEmpty(baseName, nameof(baseName));
            Guard.NotNull(model, nameof(model));

            model = settings.FilterModel(model);

            if (settings._UpdateSupportedExtensions)
            {
                model.UpdateExtensionsSupport();
            }

            if (settings.BinaryMode)
            {
                var ex = glb.IsBinaryCompatible(model);
                if (ex != null)
                {
                    throw ex;
                }

                // setup all buffers to be written internally
                for (int i = 0; i < model._buffers.Count; ++i)
                {
                    var buffer = model._buffers[i];
                    buffer._WriteToInternal();
                }
            }
            else
            {
                // setup all buffers to be written as satellite files
                for (int i = 0; i < model._buffers.Count; ++i)
                {
                    var buffer = model._buffers[i];
                    var bname  = model._buffers.Count != 1 ? $"{baseName}_{i}.bin" : $"{baseName}.bin";
                    buffer._WriteToSatellite(settings.FileWriter, bname);
                }
            }

            // setup all images to be written to the appropiate location.
            for (int i = 0; i < model._images.Count; ++i)
            {
                var image = model._images[i];
                var iname = model._images.Count != 1 ? $"{baseName}_{i}" : $"{baseName}";
                if (settings.ImageWriting != ImageWriteMode.SatelliteFile)
                {
                    image._WriteToInternal();
                }
                else
                {
                    image._WriteToSatellite(settings.FileWriter, iname);
                }
            }

            using (var m = new MemoryStream())
            {
                if (settings.BinaryMode)
                {
                    using (var w = new BinaryWriter(m))
                    {
                        glb.WriteBinaryModel(w, model);
                    }

                    settings.FileWriter($"{baseName}.glb", m.ToArraySegment());
                }
                else
                {
                    using (var w = new StreamWriter(m))
                    {
                        model._WriteJSON(w, settings.JsonFormatting);
                    }

                    settings.FileWriter($"{baseName}.gltf", m.ToArraySegment());
                }
            }

            foreach (var b in model._buffers)
            {
                b._ClearAfterWrite();
            }
            foreach (var i in model._images)
            {
                i._ClearAfterWrite();
            }
        }
Example #2
0
 /// <summary>
 /// Writes this <see cref="MODEL"/> to the asset writer in <see cref="WriteSettings"/> configuration.
 /// </summary>
 /// <param name="settings">A <see cref="WriteSettings"/> to use to write the files.</param>
 /// <param name="baseName">The base name to use for asset files.</param>
 /// <remarks>
 /// Satellite files like buffers and images are also written with the file name formatted as "FILE_{Index}.EXT".
 /// </remarks>
 public void Write(WriteSettings settings, string baseName)
 {
     Guard.NotNull(settings, nameof(settings));
     _Write(settings, baseName, this);
 }
Example #3
0
 public WriteSettings(WriteSettings other)
 {
     Guard.NotNull(other, nameof(other));
     other.CopyTo(this);
 }
 /// <summary>
 /// Writes this <see cref="MODEL"/> to the asset writer in <see cref="WriteSettings"/> configuration.
 /// </summary>
 /// <param name="settings">A <see cref="WriteSettings"/> to use to write the files.</param>
 /// <param name="baseName">The base name to use for asset files.</param>
 /// <remarks>
 /// Satellite files like buffers and images are also written with the file name formatted as "FILE_{Index}.EXT".
 /// </remarks>
 public void Write(WriteSettings settings, string baseName)
 {
     _Write(settings, baseName, this);
 }
 public WriteContext WithSettingsFrom(WriteSettings settings)
 {
     settings?.CopyTo(this);
     return(this);
 }