/// <inheritdoc/> void IDataSerializable.Serialize(BinarySerializer serializer) { serializer.BeginChunk(OdysseyIdentifier); // Writes the version if (serializer.Mode == SerializerMode.Read) { int version = serializer.Reader.ReadInt32(); if (version != Version) { throw new NotSupportedException(string.Format("ModelData version [0x{0:X}] is not supported. Expecting [0x{1:X}]", version, Version)); } } else { serializer.Writer.Write(Version); } // Serialize the maximum buffer size used when loading this model. serializer.Serialize(ref MaximumBufferSizeInBytes); // Mesh section serializer.BeginChunk("MESH"); serializer.Serialize(ref meshData); serializer.EndChunk(); serializer.EndChunk(); }
public void Serialize(BinarySerializer serializer) { serializer.Serialize(ref id); serializer.BeginChunk("CHLD"); bool hasPrecondition = PreCondition != null; serializer.Serialize(ref hasPrecondition); if (hasPrecondition) { if (serializer.Mode == SerializerMode.Write) { WriteNode(serializer, PreCondition); } else { PreCondition = ReadNode(serializer); } } SerializeDescendants(serializer); serializer.EndChunk(); serializer.BeginChunk("FUNC"); SerializeMethods(serializer); serializer.EndChunk(); serializer.BeginChunk("VARS"); SerializeVariables(serializer); serializer.EndChunk(); serializer.BeginChunk("PROP"); SerializeProperties(serializer); serializer.EndChunk(); }
public void Serialize(BinarySerializer serializer) { serializer.BeginChunk(OdysseyIdentifier); // Writes the version if (serializer.Mode == SerializerMode.Read) { int version = serializer.Reader.ReadInt32(); if (version != Version) { throw new NotSupportedException(string.Format("ModelData version [0x{0:X}] is not supported. Expecting [0x{1:X}]", version, Version)); } } else { serializer.Writer.Write(Version); } serializer.Serialize(ref name); // Techniques serializer.BeginChunk("TECH"); serializer.Serialize(ref techniques, serializer.Serialize, (ref TechniqueMapping t) => serializer.Serialize(ref t)); serializer.EndChunk(); serializer.EndChunk(); }
/// <inheritdoc/> void IDataSerializable.Serialize(BinarySerializer serializer) { // Starts the whole EffectData by the magiccode "TKFX" // If the serializer don't find the TKFX, It will throw an // exception that will be caught by Load method. serializer.BeginChunk(MagicCode); // Writes the version if (serializer.Mode == SerializerMode.Read) { int version = serializer.Reader.ReadInt32(); if (version != Version) { throw new NotSupportedException(string.Format("EffectData version [0x{0:X}] is not supported. Expecting [0x{1:X}]", version, Version)); } } else { serializer.Writer.Write(Version); } // Shaders section serializer.BeginChunk("SHDR"); serializer.Serialize(ref Shaders); serializer.EndChunk(); // Effects section serializer.BeginChunk("EFFX"); serializer.Serialize(ref Description); serializer.EndChunk(); // Close TKFX section serializer.EndChunk(); }
public void Serialize(BinarySerializer serializer) { var sgs = (ShaderGraphSerializer)serializer; sgs.Clear(); serializer.BeginChunk("SHAD"); serializer.BeginChunk("PROP"); serializer.Serialize(ref name); serializer.Serialize(ref keyPart); serializer.Serialize(ref enableSeparators); serializer.SerializeEnum(ref featureLevel); serializer.SerializeEnum(ref type); serializer.EndChunk(); variables.Serialize(serializer); Struct sInput = (Struct)inputStruct; Struct sOutput = (Struct)outputStruct; serializer.BeginChunk("STRT"); serializer.Serialize(ref sInput); serializer.Serialize(ref sOutput); serializer.EndChunk(); serializer.BeginChunk("RSLT"); if (serializer.Mode == SerializerMode.Write) { NodeBase.WriteNode(serializer, Result); } else { Result = NodeBase.ReadNode(serializer); } serializer.EndChunk(); serializer.EndChunk(); if (serializer.Mode == SerializerMode.Read) { InputStruct = sInput; OutputStruct = sOutput; } }
public void Serialize(BinarySerializer serializer) { serializer.BeginChunk("FXDS"); serializer.Serialize(ref name); serializer.SerializeEnum(ref featureLevel); serializer.SerializeEnum(ref shaderType); serializer.Serialize(ref byteCode); // Shader References serializer.BeginChunk("REFS"); serializer.Serialize(ref cbReferences, serializer.Serialize, (ref ConstantBufferDescription cb) => serializer.Serialize(ref cb)); serializer.Serialize(ref textureReferences, serializer.Serialize); serializer.Serialize(ref samplerReferences, serializer.Serialize); serializer.EndChunk(); serializer.EndChunk(); }
public void Serialize(BinarySerializer serializer) { serializer.BeginChunk("TECH"); serializer.Serialize(ref name); serializer.Serialize(ref key); serializer.Serialize(ref shaders, serializer.SerializeEnum, (ref Shaders.Shader s) => serializer.Serialize(ref s)); serializer.EndChunk(); }
public void Begin(WaveFormat waveFormat) { if (isBegin) { throw new InvalidOperationException("Cannot begin a new WAV while another begin has not been closed"); } serializer.BeginChunk("RIFF"); var fourCC = new FourCC("WAVE"); serializer.Serialize(ref fourCC); serializer.BeginChunk("fmt "); serializer.Serialize(ref waveFormat); serializer.EndChunk(); serializer.BeginChunk("data"); isBegin = true; }
public void Serialize(BinarySerializer serializer) { serializer.BeginChunk("VARS"); int varCount = Count; serializer.Serialize(ref varCount); var vars = Values.Cast <Variable>().ToList(); for (int i = 0; i < varCount; i++) { if (serializer.Mode == SerializerMode.Write) { Variable.WriteVariable(serializer, vars[i]); } else { Variable variable = Variable.ReadVariable(serializer); Owner.Add(variable); } } serializer.EndChunk(); }
/// <summary> /// Saves the specified pixel buffers in TKTX format. /// </summary> /// <param name="pixelBuffers">The pixel buffers.</param> /// <param name="count">The count.</param> /// <param name="description">The description.</param> /// <param name="imageStream">The image stream.</param> internal static void SaveTKTX(PixelBuffer[] pixelBuffers, int count, ImageDescription description, Stream imageStream) { var serializer = new BinarySerializer(imageStream, SerializerMode.Write); var beginPosition = imageStream.Position; // Write MagicCode for TKTX serializer.BeginChunk(MagicCodeTKTX); // Serialize Description serializer.Serialize(ref description); // Serialize Size int size = 0; for (int i = 0; i < count; i++) { size += pixelBuffers[i].BufferStride; } serializer.Serialize(ref size); // Pad to align pixel buffer on 16 bytes (fixed offset at 48 bytes from the beginning of the file). var padBuffer = new byte[OffsetBufferTKTX - (int)(imageStream.Position - beginPosition)]; if (padBuffer.Length > 0) { imageStream.Write(padBuffer, 0, padBuffer.Length); } // Write the whole pixel buffer for (int i = 0; i < count; i++) { serializer.SerializeMemoryRegion(pixelBuffers[i].DataPointer, pixelBuffers[i].BufferStride); } serializer.EndChunk(); }
/// <summary> /// Saves the specified pixel buffers in TKTX format. /// </summary> internal static Image LoadTKTX(IntPtr dataPointer, int dataSize, bool makeACopy, GCHandle?handle) { // Make a copy? if (makeACopy) { var temp = Utilities.AllocateMemory(dataSize); Utilities.CopyMemory(temp, dataPointer, dataSize); dataPointer = temp; } // Use DataStream to load from memory pointer var imageStream = new DataStream(dataPointer, dataSize, true, true); var beginPosition = imageStream.Position; var serializer = new BinarySerializer(imageStream, SerializerMode.Read); var description = default(ImageDescription); // Load MagicCode TKTX try { serializer.BeginChunk(MagicCodeTKTX); } catch (InvalidChunkException ex) { // If magic code not found, return null if (ex.ExpectedChunkId == MagicCodeTKTX) { return(null); } throw; } // Read description serializer.Serialize(ref description); // Read size of pixel buffer int size = 0; serializer.Serialize(ref size); // Pad to align pixel buffer on 16 bytes (fixed offset at 48 bytes from the beginning of the file). var padBuffer = new byte[OffsetBufferTKTX - (int)(imageStream.Position - beginPosition)]; if (padBuffer.Length > 0) { if (imageStream.Read(padBuffer, 0, padBuffer.Length) != padBuffer.Length) { throw new EndOfStreamException(); } } // Check that current offset is exactly our fixed offset. int pixelBufferOffsets = (int)serializer.Stream.Position; if (pixelBufferOffsets != OffsetBufferTKTX) { throw new InvalidOperationException(string.Format("Unexpected offset [{0}] for pixel buffers. Must be {1}", pixelBufferOffsets, OffsetBufferTKTX)); } // Seek to the end of the stream to the number of pixel buffers imageStream.Seek(size, SeekOrigin.Current); // Close the chunk to verify that we did read the whole chunk serializer.EndChunk(); return(new Image(description, dataPointer, pixelBufferOffsets, handle, makeACopy)); }
/// <inheritdoc/> void IDataSerializable.Serialize(BinarySerializer serializer) { // Starts the whole ModelData by the magiccode "TKMD" // If the serializer don't find the TKMD, It will throw an // exception that will be catched by Load method. serializer.BeginChunk(MagicCode); // Bones section serializer.BeginChunk("BONE"); serializer.Serialize(ref Bones); serializer.EndChunk(); // Mesh section serializer.BeginChunk("MESH"); serializer.Serialize(ref Meshes); serializer.EndChunk(); // Serialize attributes serializer.Serialize(ref Attributes); // Close TKFX section serializer.EndChunk(); }
/// <inheritdoc/> void IDataSerializable.Serialize(BinarySerializer serializer) { // Starts the whole ModelData by the magiccode "TKMD" // If the serializer don't find the TKMD, It will throw an // exception that will be caught by Load method. // This code should not be modified without modifying the serialize code in Model. serializer.BeginChunk(MagicCode); // Writes the version if (serializer.Mode == SerializerMode.Read) { int version = serializer.Reader.ReadInt32(); if (version != Version) { throw new NotSupportedException(string.Format("ModelData version [0x{0:X}] is not supported. Expecting [0x{1:X}]", version, Version)); } } else { serializer.Writer.Write(Version); } // Serialize the maximum buffer size used when loading this model. serializer.Serialize(ref MaximumBufferSizeInBytes); // Texture section serializer.BeginChunk("TEXS"); if (serializer.Mode == SerializerMode.Read) { int textureCount = serializer.Reader.ReadInt32(); Textures = new List <byte[]>(textureCount); for (int i = 0; i < textureCount; i++) { byte[] textureData = null; serializer.Serialize(ref textureData); Textures.Add(textureData); } } else { serializer.Writer.Write(Textures.Count); for (int i = 0; i < Textures.Count; i++) { byte[] textureData = Textures[i]; serializer.Serialize(ref textureData); } } serializer.EndChunk(); // Material section serializer.BeginChunk("MATL"); serializer.Serialize(ref Materials); serializer.EndChunk(); // Bones section serializer.BeginChunk("BONE"); serializer.Serialize(ref Bones); serializer.EndChunk(); // Mesh section serializer.BeginChunk("MESH"); serializer.Serialize(ref Meshes); serializer.EndChunk(); // Animation section serializer.BeginChunk("ANIM"); serializer.Serialize(ref Animations); serializer.EndChunk(); // Serialize attributes serializer.Serialize(ref Attributes); // Close TKMD section serializer.EndChunk(); }
/// <summary> /// Saves the specified pixel buffers in TKTX format. /// </summary> /// <param name="pixelBuffers">The pixel buffers.</param> /// <param name="count">The count.</param> /// <param name="description">The description.</param> /// <param name="imageStream">The image stream.</param> internal static void SaveTKTX(PixelBuffer[] pixelBuffers, int count, ImageDescription description, Stream imageStream) { var serializer = new BinarySerializer(imageStream, SerializerMode.Write); var beginPosition = imageStream.Position; // Write MagicCode for TKTX serializer.BeginChunk(MagicCodeTKTX); // Serialize Description serializer.Serialize(ref description); // Serialize Size int size = 0; for (int i = 0; i < count; i++) size += pixelBuffers[i].BufferStride; serializer.Serialize(ref size); // Pad to align pixel buffer on 16 bytes (fixed offset at 48 bytes from the beginning of the file). var padBuffer = new byte[OffsetBufferTKTX - (int) (imageStream.Position - beginPosition)]; if (padBuffer.Length > 0) imageStream.Write(padBuffer, 0, padBuffer.Length); // Write the whole pixel buffer for (int i = 0; i < count; i++) serializer.SerializeMemoryRegion(pixelBuffers[i].DataPointer, pixelBuffers[i].BufferStride); serializer.EndChunk(); }
void IDataSerializable.Serialize(BinarySerializer serializer) { serializer.BeginChunk("ABCD"); serializer.Serialize(ref A); serializer.EndChunk(); }
/// <inheritdoc/> void IDataSerializable.Serialize(BinarySerializer serializer) { // Starts the whole ModelData by the magiccode "TKMD" // If the serializer don't find the TKMD, It will throw an // exception that will be catched by Load method. // This code should not be modified without modifying the serialize code in Model. serializer.BeginChunk(MagicCode); // Writes the version if (serializer.Mode == SerializerMode.Read) { int version = serializer.Reader.ReadInt32(); if (version != Version) { throw new NotSupportedException(string.Format("ModelData version [0x{0:X}] is not supported. Expecting [0x{1:X}]", version, Version)); } } else { serializer.Writer.Write(Version); } // Serialize the maximum buffer size used when loading this model. serializer.Serialize(ref MaximumBufferSizeInBytes); // Texture section serializer.BeginChunk("TEXS"); if (serializer.Mode == SerializerMode.Read) { int textureCount = serializer.Reader.ReadInt32(); Textures = new List<byte[]>(textureCount); for (int i = 0; i < textureCount; i++) { byte[] textureData = null; serializer.Serialize(ref textureData); Textures.Add(textureData); } } else { serializer.Writer.Write(Textures.Count); for (int i = 0; i < Textures.Count; i++) { byte[] textureData = Textures[i]; serializer.Serialize(ref textureData); } } serializer.EndChunk(); // Material section serializer.BeginChunk("MATL"); serializer.Serialize(ref Materials); serializer.EndChunk(); // Bones section serializer.BeginChunk("BONE"); serializer.Serialize(ref Bones); serializer.EndChunk(); //// DISABLE_SKINNED_BONES //// Skinned Bones section //serializer.BeginChunk("SKIN"); //serializer.Serialize(ref SkinnedBones); //serializer.EndChunk(); // Mesh section serializer.BeginChunk("MESH"); serializer.Serialize(ref Meshes); serializer.EndChunk(); // Serialize attributes serializer.Serialize(ref Attributes); // Close TKMD section serializer.EndChunk(); }
/// <inheritdoc/> void IDataSerializable.Serialize(BinarySerializer serializer) { // Starts the whole EffectData by the magiccode "TKFX" // If the serializer don't find the TKFX, It will throw an // exception that will be catched by Load method. serializer.BeginChunk(MagicCode); // Writes the version if (serializer.Mode == SerializerMode.Read) { int version = serializer.Reader.ReadInt32(); if (version != Version) { throw new NotSupportedException(string.Format("EffectData version [0x{0:X}] is not supported. Expecting [0x{1:X}]", version, Version)); } } else { serializer.Writer.Write(Version); } // Shaders section serializer.BeginChunk("SHDR"); serializer.Serialize(ref Shaders); serializer.EndChunk(); // Effects section serializer.BeginChunk("EFFX"); serializer.Serialize(ref Description); serializer.EndChunk(); // Close TKFX section serializer.EndChunk(); }
/// <inheritdoc/> void IDataSerializable.Serialize(BinarySerializer serializer) { // Starts the whole EffectData by the magiccode "TKFX" // If the serializer don't find the TKFX, It will throw an // exception that will be catched by Load method. serializer.BeginChunk(MagicCode); // Shaders section serializer.BeginChunk("SHDR"); serializer.Serialize(ref Shaders); serializer.EndChunk(); // Effects section serializer.BeginChunk("EFFX"); serializer.Serialize(ref Effects); serializer.EndChunk(); // Close TKFX section serializer.EndChunk(); }
/// <summary> /// Saves the specified pixel buffers in TKTX format. /// </summary> internal static Image LoadTKTX(IntPtr dataPointer, int dataSize, bool makeACopy, GCHandle? handle) { // Make a copy? if (makeACopy) { var temp = Utilities.AllocateMemory(dataSize); Utilities.CopyMemory(temp, dataPointer, dataSize); dataPointer = temp; } // Use DataStream to load from memory pointer var imageStream = new DataStream(dataPointer, dataSize, true, true); var beginPosition = imageStream.Position; var serializer = new BinarySerializer(imageStream, SerializerMode.Read); var description = default(ImageDescription); // Load MagicCode TKTX try { serializer.BeginChunk(MagicCodeTKTX); } catch (InvalidChunkException ex) { // If magic code not found, return null if (ex.ExpectedChunkId == MagicCodeTKTX) return null; throw; } // Read description serializer.Serialize(ref description); // Read size of pixel buffer int size = 0; serializer.Serialize(ref size); // Pad to align pixel buffer on 16 bytes (fixed offset at 48 bytes from the beginning of the file). var padBuffer = new byte[OffsetBufferTKTX - (int)(imageStream.Position - beginPosition)]; if (padBuffer.Length > 0) { if (imageStream.Read(padBuffer, 0, padBuffer.Length) != padBuffer.Length) throw new EndOfStreamException(); } // Check that current offset is exactly our fixed offset. int pixelBufferOffsets = (int)serializer.Stream.Position; if (pixelBufferOffsets != OffsetBufferTKTX) throw new InvalidOperationException(string.Format("Unexpected offset [{0}] for pixel buffers. Must be {1}", pixelBufferOffsets, OffsetBufferTKTX)); // Seek to the end of the stream to the number of pixel buffers imageStream.Seek(size, SeekOrigin.Current); // Close the chunk to verify that we did read the whole chunk serializer.EndChunk(); return new Image(description, dataPointer, pixelBufferOffsets, handle, makeACopy); }