/// <summary> /// Override to serialize the object to a byte array that can be stored /// in the GFF's binary data. It serializes the data according to /// BioWare's GFF file specification. Simple data items are returned /// in the return value, complex items are stored in the stream and 0 /// is returned. /// </summary> /// <param name="rawData">The raw data in which to store the field's /// data.</param> /// <returns>For simple items the return value contains the item's /// data and the stream is uneffected. For complex items, the /// return value is the offset of the written data and the items's /// data is added to the end of the stream.</returns> UInt32 IGffFieldSerialize.Serialize(RawGffData rawData) { byte[] bytes = BitConverter.GetBytes((uint) Value.Length); uint offset = rawData.WriteComplexData(bytes, bytes.Length); rawData.WriteComplexData(Value.GetBuffer(), (int) Value.Length); return offset; }
/// <summary> /// Override to serialize the object to a byte array that can be stored /// in the GFF's binary data. It serializes the data according to /// BioWare's GFF file specification. Simple data items are returned /// in the return value, complex items are stored in the stream and 0 /// is returned. /// </summary> /// <param name="rawData">The raw data in which to store the field's /// data.</param> /// <returns>For simple items the return value contains the item's /// data and the stream is uneffected. For complex items, the /// return value is the offset of the written data and the items's /// data is added to the end of the stream.</returns> UInt32 IGffFieldSerialize.Serialize(RawGffData rawData) { return SaveFieldStruct(structureType, Value, rawData); }
/// <summary> /// Override to deserialize the object from the GFF file's binary data. /// </summary> /// <param name="rawField">The raw field from the GFF</param> /// <param name="rawData">The GFF's raw file data</param> void IGffFieldSerialize.Deserialize(RawGffData.RawGffField rawField, RawGffData rawData) { // Determine the length of the bob. byte[] complexData = rawData.GetComplexDataBuffer(); uint length = BitConverter.ToUInt32(complexData, (int) rawField.DataOrDataOffset); // Copy the data from the complex data byte array to a local byte array. byte[] bytes = new Byte[length]; for (int i = 0; i < length; i++) bytes[i] = complexData[rawField.DataOrDataOffset + 4 + i]; // Save the data in a memory stream. Value = new MemoryStream(bytes, 0, bytes.Length, true, true); }
/// <summary> /// Override to serialize the object to a byte array that can be stored /// in the GFF's binary data. It serializes the data according to /// BioWare's GFF file specification. Simple data items are returned /// in the return value, complex items are stored in the stream and 0 /// is returned. /// </summary> /// <param name="rawData">The raw data in which to store the field's /// data.</param> /// <returns>For simple items the return value contains the item's /// data and the stream is uneffected. For complex items, the /// return value is the offset of the written data and the items's /// data is added to the end of the stream.</returns> UInt32 IGffFieldSerialize.Serialize(RawGffData rawData) { byte[] bytes = Value.Serialize(); return rawData.WriteComplexData(bytes, bytes.Length); }
/// <summary> /// Override to deserialize the object from the GFF file's binary data. /// </summary> /// <param name="rawField">The raw field from the GFF</param> /// <param name="rawData">The GFF's raw file data</param> void IGffFieldSerialize.Deserialize(RawGffData.RawGffField rawField, RawGffData rawData) { // Save the structure type. RawGffData.RawGffStruct rawStruct = rawData.GetStruct(rawField.DataOrDataOffset); structureType = rawStruct.Type; // Fill in the field dictionary and assign it to our value. Value = GetFieldStruct(rawStruct, rawData); }
/// <summary> /// Override to deserialize the object from the GFF file's binary data. /// </summary> /// <param name="rawField">The raw field from the GFF</param> /// <param name="rawData">The GFF's raw file data</param> void IGffFieldSerialize.Deserialize(RawGffData.RawGffField rawField, RawGffData rawData) { Value = BitConverter.ToUInt64(rawData.GetComplexDataBuffer(), (int) rawField.DataOrDataOffset); }
/// <summary> /// Override to deserialize the object from the GFF file's binary data. /// </summary> /// <param name="rawField">The raw field from the GFF</param> /// <param name="rawData">The GFF's raw file data</param> void IGffFieldSerialize.Deserialize(RawGffData.RawGffField rawField, RawGffData rawData) { Value = (uint) rawField.DataOrDataOffset; }
/// <summary> /// Override to serialize the object to a byte array that can be stored /// in the GFF's binary data. It serializes the data according to /// BioWare's GFF file specification. Simple data items are returned /// in the return value, complex items are stored in the stream and 0 /// is returned. /// </summary> /// <param name="rawData">The raw data in which to store the field's /// data.</param> /// <returns>For simple items the return value contains the item's /// data and the stream is uneffected. For complex items, the /// return value is the offset of the written data and the items's /// data is added to the end of the stream.</returns> UInt32 IGffFieldSerialize.Serialize(RawGffData rawData) { // Create an array to hold all of the structure indeces, // then loop through all of the structures, serializing // them and saving the returned offsets. uint[] indeces = new uint[Value.Count]; for (int i = 0; i < Value.Count; i++) { IGffFieldSerialize serialize = (IGffFieldSerialize) Value[i]; indeces[i] = serialize.Serialize(rawData); } // Add the index array to the list indeces and return that offset. return rawData.AddListIndeces(indeces); }
/// <summary> /// Override to deserialize the object from the GFF file's binary data. /// </summary> /// <param name="rawField">The raw field from the GFF</param> /// <param name="rawData">The GFF's raw file data</param> void IGffFieldSerialize.Deserialize(RawGffData.RawGffField rawField, RawGffData rawData) { byte[] bytes = rawData.GetComplexDataBuffer(); byte length = bytes[rawField.DataOrDataOffset]; Value = RawGffData.DeserializeString(bytes, (int) rawField.DataOrDataOffset + 1, (int) length); }
/// <summary> /// Override to serialize the object to a byte array that can be stored /// in the GFF's binary data. It serializes the data according to /// BioWare's GFF file specification. Simple data items are returned /// in the return value, complex items are stored in the stream and 0 /// is returned. /// </summary> /// <param name="rawData">The raw data in which to store the field's /// data.</param> /// <returns>For simple items the return value contains the item's /// data and the stream is uneffected. For complex items, the /// return value is the offset of the written data and the items's /// data is added to the end of the stream.</returns> UInt32 IGffFieldSerialize.Serialize(RawGffData rawData) { byte[] bytes = BitConverter.GetBytes(Value); return BitConverter.ToUInt32(bytes, 0); }
/// <summary> /// Override to deserialize the object from the GFF file's binary data. /// </summary> /// <param name="rawField">The raw field from the GFF</param> /// <param name="rawData">The GFF's raw file data</param> void IGffFieldSerialize.Deserialize(RawGffData.RawGffField rawField, RawGffData rawData) { // Get the list of structure indeces for the items in the list uint[] indeces = rawData.GetListIndeces(rawField.DataOrDataOffset); // Create a field collection for the structures, and loop through // the index array. GffFieldCollection fields = new GffFieldCollection(); for (int i = 0; i < indeces.Length; i++) { // Get the raw structure data for this structure. RawGffData.RawGffStruct rawStruct = rawData.GetStruct(indeces[i]); // Create a GffStructField object for the structure and set it's // structure type. GffStructField field = (GffStructField) GffFieldFactory.CreateField(GffFieldType.Struct); field.StructureType = rawStruct.Type; // Create a dummy field object so we can deserialize the structure, // set it's DataOrDataOffset to the structure index. RawGffData.RawGffField dummyField = new RawGffData.RawGffField(GffFieldType.Struct); dummyField.LabelIndex = 0; dummyField.DataOrDataOffset = indeces[i]; // Deserialize the structure. ((IGffFieldSerialize) field).Deserialize(dummyField, rawData); // Add the structure to the collection. fields.Add(field); } Value = fields; }
/// <summary> /// Override to deserialize the object from the GFF file's binary data. /// </summary> /// <param name="rawField">The raw field from the GFF</param> /// <param name="rawData">The GFF's raw file data</param> void IGffFieldSerialize.Deserialize(RawGffData.RawGffField rawField, RawGffData rawData) { byte[] bytes = BitConverter.GetBytes(rawField.DataOrDataOffset); Value = BitConverter.ToSingle(bytes, 0); }
/// <summary> /// Creates a GffField derived object and deserializes the field's data /// into the created object. /// </summary> /// <param name="rawField">The raw field data for the object to create</param> /// <param name="rawData">The raw GFF file data</param> /// <returns>The created GffField derived object</returns> public static GffField CreateField(RawGffData.RawGffField rawField, RawGffData rawData) { // Create an empty GffField object. GffField field = CreateField((GffFieldType) rawField.Type); // Get the field's IGffFieldSerialize implementation. IGffFieldSerialize serialize = field as IGffFieldSerialize; if (null == serialize) throw new InvalidCastException("IGffSerialize not implemented"); // Deserialize the object. serialize.Deserialize(rawField, rawData); return field; }
/// <summary> /// Override to deserialize the object from the GFF file's binary data. /// </summary> /// <param name="rawField">The raw field from the GFF</param> /// <param name="rawData">The GFF's raw file data</param> void IGffFieldSerialize.Deserialize(RawGffData.RawGffField rawField, RawGffData rawData) { byte[] bytes = rawData.GetComplexDataBuffer(); uint length = BitConverter.ToUInt32(bytes, (int) rawField.DataOrDataOffset); Value = RawGffData.DeserializeString(bytes, (int) rawField.DataOrDataOffset + 4, (int) length); }
/// <summary> /// Saves the GFF, using a new file name. /// </summary> /// <param name="fileName">The new file name for the GFF</param> public void SaveAs(string fileName) { // Save the top level structure to the raw data. RawGffData rawData = new RawGffData(); GffStructField.SaveFieldStruct(0xffffffff, topLevel, rawData); // Create a header for the GFF file. string type = Path.GetExtension(fileName); type = type.Substring(1, type.Length - 1); GffHeader header = new GffHeader(type); rawData.InitializeHeader(ref header); // Create the disk file and save the header and raw data. using (FileStream writer = new FileStream(fileName, FileMode.Create, FileAccess.Write, FileShare.Write)) { header.Serialize(writer); rawData.Save(writer); writer.Close(); } }
/// <summary> /// Override to serialize the object to a byte array that can be stored /// in the GFF's binary data. It serializes the data according to /// BioWare's GFF file specification. Simple data items are returned /// in the return value, complex items are stored in the stream and 0 /// is returned. /// </summary> /// <param name="rawData">The raw data in which to store the field's /// data.</param> /// <returns>For simple items the return value contains the item's /// data and the stream is uneffected. For complex items, the /// return value is the offset of the written data and the items's /// data is added to the end of the stream.</returns> UInt32 IGffFieldSerialize.Serialize(RawGffData rawData) { // Write the string length first, saving the offset of the written // position. byte[] bytes = new Byte[1]; bytes[0] = (byte) Value.Length; uint offset = rawData.WriteComplexData(bytes, bytes.Length); // Now write the string data. bytes = new byte[Value.Length]; for (int i = 0; i < Value.Length; i++) bytes[i] = (byte) Value[i]; rawData.WriteComplexData(bytes, bytes.Length); // return the offset of our data. return offset; }
/// <summary> /// Loads the GFF file from the specified stream. /// </summary> /// <param name="stream">The stream to load the GFF file from.s</param> private void LoadStream(Stream stream) { // Read the header. NWNLogger.Log(0, "Gff.LoadStream loading header"); GffHeader header = new GffHeader(stream); NWNLogger.Log(1, "Gff.LoadStream version {0}", header.VersionText); if ("V3.2" != header.VersionText) throw new NWNException("Version {0} GFF files are unsupported", header.VersionText); NWNLogger.Log(0, "Gff.LoadStream reading raw GFF data"); RawGffData rawData = new RawGffData(stream, header); topLevel = GffStructField.GetFieldStruct(rawData.GetStruct(0), rawData); }
public static GffFieldDictionary GetFieldStruct(RawGffData.RawGffStruct gstruct, RawGffData rawData) { // Loop through all of the fields in the struct adding them to the // collection. GffFieldDictionary fields = new GffFieldDictionary(); for (int i = 0; i < gstruct.FieldCount; i++) { // Get the index of the current field. If the structure has 1 // member then the offset is in DataOrDataOffset directly, if not // then DataOrDataOffset points to an array of DWORD indeces in // the raw field indeces block. uint fieldIndex = 1 == gstruct.FieldCount ? gstruct.DataOrDataOffset : rawData.GetFieldIndex((uint) (gstruct.DataOrDataOffset + (i * 4))); // Get the data label. RawGffData.RawGffField rawField = rawData.GetField(fieldIndex); string label = rawData.GetLabel(rawField.LabelIndex); // Create a GffField object for the field and add it to the // dictionary, using the label as the key. GffField field = GffFieldFactory.CreateField(rawField, rawData); fields.Add(label, field); } return fields; }
/// <summary> /// Override to serialize the object to a byte array that can be stored /// in the GFF's binary data. It serializes the data according to /// BioWare's GFF file specification. Simple data items are returned /// in the return value, complex items are stored in the stream and 0 /// is returned. /// </summary> /// <param name="rawData">The raw data in which to store the field's /// data.</param> /// <returns>For simple items the return value contains the item's /// data and the stream is uneffected. For complex items, the /// return value is the offset of the written data and the items's /// data is added to the end of the stream.</returns> UInt32 IGffFieldSerialize.Serialize(RawGffData rawData) { byte[] bytes = BitConverter.GetBytes(Value); return rawData.WriteComplexData(bytes, bytes.Length); }
/// <summary> /// Saves all of the data associated with the given structure. /// </summary> /// <param name="type">The type ID of the structure</param> /// <param name="dict">The structure's dictionary</param> /// <param name="rawData">The raw data in which to save the structure</param> /// <returns>The index of the structure in the raw data</returns> public static uint SaveFieldStruct(uint type, GffFieldDictionary dict, RawGffData rawData) { // Create the structure and fill in the data we can then add it. Note // that we can't fill in the DataOrDataOffset yet since we don't know // what that value is until after all of the fields have been added. // We will update the structure when we are done. RawGffData.RawGffStruct rawStruct = new RawGffData.RawGffStruct(type); rawStruct.FieldCount = (uint) dict.Count; rawStruct.DataOrDataOffset = 0; uint structureIndex = rawData.AddStruct(rawStruct); // Create an array to hold all of the field index values and loop through // the dictionary to store all of the structure elements. uint[] indeces = new uint[dict.Count]; uint i = 0; foreach (DictionaryEntry entry in dict) { // Get the label and field from the entry. string label = (string) entry.Key; GffField field = (GffField) entry.Value; // Create a raw field for the field. RawGffData.RawGffField rawField = new RawGffData.RawGffField(field.Type); // Get the index of the label, adding it if it's not in the raw data. rawField.LabelIndex = (uint) rawData.GetLabelIndex(label); if (0xffffffff == rawField.LabelIndex) rawField.LabelIndex = (uint) rawData.AddLabel(label); // Serialize the field's data and save the offset to the serialized // data (for some fields the offset may be the data itself). IGffFieldSerialize serialize = (IGffFieldSerialize) field; rawField.DataOrDataOffset = serialize.Serialize(rawData); // Add the field to the raw data, saving the index of the added // field in our index array. indeces[i++] = rawData.AddField(rawField); } // If we have multiple fields, we have to add the index array to the // field indeces and save the offset, otherwise we can just save the // field index as our data offset. Once we do this we have to update // the structure to store the offset. rawStruct.DataOrDataOffset = 1 == dict.Count ? indeces[0] : rawData.AddFieldIndeces(indeces); rawData.UpdateStruct(structureIndex, rawStruct); // Return the structure's index. return structureIndex; }
/// <summary> /// Override to serialize the object to a byte array that can be stored /// in the GFF's binary data. It serializes the data according to /// BioWare's GFF file specification. Simple data items are returned /// in the return value, complex items are stored in the stream and 0 /// is returned. /// </summary> /// <param name="rawData">The raw data in which to store the field's /// data.</param> /// <returns>For simple items the return value contains the item's /// data and the stream is uneffected. For complex items, the /// return value is the offset of the written data and the items's /// data is added to the end of the stream.</returns> UInt32 IGffFieldSerialize.Serialize(RawGffData rawData) { return (UInt32) Value; }
/// <summary> /// Override to deserialize the object from the GFF file's binary data. /// </summary> /// <param name="rawField">The raw field from the GFF</param> /// <param name="rawData">The GFF's raw file data</param> void IGffFieldSerialize.Deserialize(RawGffData.RawGffField rawField, RawGffData rawData) { Value = new ExoLocString(rawData.GetComplexDataBuffer(), (int) rawField.DataOrDataOffset); }