/// <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);
}
