diff --git a/CHANGELOG.md b/CHANGELOG.md index 626f7db..51f0f23 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -17,6 +17,9 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/). - A constructor with a boolean argument in `Blowfish`. - `Workspace` parameter in deserialize methods in `Toolkit`. - Helper methods for `VersionInfo`. +- Helper version crc calculator method for `MetaClass`. +- Better `TTArchive` compression detection. +- A dedicated `Compression` class. ### Changed - Rename the following MetaStream implementations: `MetaStreamReader`/`MetaStreamWriter` to `BinaryMetaStreamReader`/`BinaryMetaStreamWriter`. @@ -28,6 +31,8 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/). - Reorganize some namespaces. - Make the default serializer not throw errors and use logger instead. - `Serialize` from `MetaStream` now automatically preserializes. +- Namespaces organization. (#24) +- Various class names. (#24) ### Fixed - A regression that did not allow files being copied to the output folder. @@ -39,6 +44,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/). - `AreSymbolsHashed` from `GameProfile` as symbols are always hashed. - `PreSerialize` from `MetaStream`. - Redundant `Version` from `MetaStreamParams`. +- Unused `ISymbolResolver` interface. ## [0.2.0] - 2026-05-28 diff --git a/samples/VersionDatabaseCreator/Program.cs b/samples/VersionDatabaseCreator/Program.cs index 22de66b..27d0a5e 100644 --- a/samples/VersionDatabaseCreator/Program.cs +++ b/samples/VersionDatabaseCreator/Program.cs @@ -4,13 +4,14 @@ using System.Text.Encodings.Web; using System.Text.Json; using TelltaleToolKit; -using TelltaleToolKit.GamesDatabase; -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Binary; -using TelltaleToolKit.TelltaleArchives; -using TelltaleToolKit.Utility.Blowfish; -using TelltaleToolKit.Utility.Lua; +using TelltaleToolKit.Encryption; +using TelltaleToolKit.Games; +using TelltaleToolKit.IO.Archives; +using TelltaleToolKit.Lua; +using TelltaleToolKit.Meta; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Binary; // !!!IMPORTANT!!! // This project creates ONLY the VERSION DATABASE for a specific game. diff --git a/src/TelltaleToolKit/Utility/Blowfish/Blowfish.cs b/src/TelltaleToolKit/Encryption/Blowfish.cs similarity index 99% rename from src/TelltaleToolKit/Utility/Blowfish/Blowfish.cs rename to src/TelltaleToolKit/Encryption/Blowfish.cs index 444a727..153f395 100644 --- a/src/TelltaleToolKit/Utility/Blowfish/Blowfish.cs +++ b/src/TelltaleToolKit/Encryption/Blowfish.cs @@ -1,7 +1,7 @@ using System.Buffers.Binary; using System.Text; -namespace TelltaleToolKit.Utility.Blowfish; +namespace TelltaleToolKit.Encryption; /// /// Class that provides 'Blowfish' encryption. diff --git a/src/TelltaleToolKit/Utility/Blowfish/BlowfishConstants.cs b/src/TelltaleToolKit/Encryption/BlowfishConstants.cs similarity index 99% rename from src/TelltaleToolKit/Utility/Blowfish/BlowfishConstants.cs rename to src/TelltaleToolKit/Encryption/BlowfishConstants.cs index adfdfbe..a26cdba 100644 --- a/src/TelltaleToolKit/Utility/Blowfish/BlowfishConstants.cs +++ b/src/TelltaleToolKit/Encryption/BlowfishConstants.cs @@ -1,4 +1,4 @@ -namespace TelltaleToolKit.Utility.Blowfish; +namespace TelltaleToolKit.Encryption; public static class BlowfishConstants { diff --git a/src/TelltaleToolKit/Serialization/Binary/LegacyEncryption.cs b/src/TelltaleToolKit/Encryption/LegacyEncryption.cs similarity index 98% rename from src/TelltaleToolKit/Serialization/Binary/LegacyEncryption.cs rename to src/TelltaleToolKit/Encryption/LegacyEncryption.cs index 52d4697..dfa5a74 100644 --- a/src/TelltaleToolKit/Serialization/Binary/LegacyEncryption.cs +++ b/src/TelltaleToolKit/Encryption/LegacyEncryption.cs @@ -1,8 +1,7 @@ using System.Buffers; -using System.Buffers.Binary; -using TelltaleToolKit.Utility.Blowfish; +using TelltaleToolKit.Meta.Serialization; -namespace TelltaleToolKit.Serialization.Binary; +namespace TelltaleToolKit.Encryption; /// /// Provides static helpers to encrypt and decrypt legacy Telltale MetaStream files diff --git a/src/TelltaleToolKit/Utility/Blowfish/T3BlowfishKey.cs b/src/TelltaleToolKit/Encryption/T3BlowfishKey.cs similarity index 99% rename from src/TelltaleToolKit/Utility/Blowfish/T3BlowfishKey.cs rename to src/TelltaleToolKit/Encryption/T3BlowfishKey.cs index f43da6f..752d00c 100644 --- a/src/TelltaleToolKit/Utility/Blowfish/T3BlowfishKey.cs +++ b/src/TelltaleToolKit/Encryption/T3BlowfishKey.cs @@ -1,6 +1,6 @@ using System.ComponentModel.DataAnnotations; -namespace TelltaleToolKit.Utility.Blowfish; +namespace TelltaleToolKit.Encryption; /// /// Enum representing the various Telltale games which use different blowfish keys. diff --git a/src/TelltaleToolKit/Utility/Blowfish/T3BlowfishKeyExtensions.cs b/src/TelltaleToolKit/Encryption/T3BlowfishKeyExtensions.cs similarity index 99% rename from src/TelltaleToolKit/Utility/Blowfish/T3BlowfishKeyExtensions.cs rename to src/TelltaleToolKit/Encryption/T3BlowfishKeyExtensions.cs index 9d16a6c..7f96bd1 100644 --- a/src/TelltaleToolKit/Utility/Blowfish/T3BlowfishKeyExtensions.cs +++ b/src/TelltaleToolKit/Encryption/T3BlowfishKeyExtensions.cs @@ -1,11 +1,11 @@ using System.ComponentModel.DataAnnotations; using System.Reflection; -namespace TelltaleToolKit.Utility.Blowfish; +namespace TelltaleToolKit.Encryption; public static class T3BlowfishKeyExtensions { - // TODO: In C#13 there is a feature that makes adding extensions easier. + // TODO: In C#14 there is a feature that makes adding extensions easier. /// /// Gets the display name of . @@ -198,4 +198,4 @@ public static string GetBlowfishKey(this T3BlowfishKey game) _ => throw new NotImplementedException("Game is not supported or the key is invalid.") }; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/GamesDatabase/GameProfile.cs b/src/TelltaleToolKit/Games/GameProfile.cs similarity index 93% rename from src/TelltaleToolKit/GamesDatabase/GameProfile.cs rename to src/TelltaleToolKit/Games/GameProfile.cs index c7d4201..c210e35 100644 --- a/src/TelltaleToolKit/GamesDatabase/GameProfile.cs +++ b/src/TelltaleToolKit/Games/GameProfile.cs @@ -1,10 +1,9 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.TelltaleArchives; -using TelltaleToolKit.Utility.Blowfish; -using TelltaleToolKit.Utility.Lua; +using TelltaleToolKit.Encryption; +using TelltaleToolKit.IO.Archives; +using TelltaleToolKit.Lua; +using TelltaleToolKit.Meta.Reflection; -namespace TelltaleToolKit.GamesDatabase; +namespace TelltaleToolKit.Games; /// /// Represents a registry entry for a Telltale game configuration. diff --git a/src/TelltaleToolKit/GamesDatabase/GameProfileJsonConverter.cs b/src/TelltaleToolKit/Games/GameProfileJsonConverter.cs similarity index 95% rename from src/TelltaleToolKit/GamesDatabase/GameProfileJsonConverter.cs rename to src/TelltaleToolKit/Games/GameProfileJsonConverter.cs index 179eccd..d51aca9 100644 --- a/src/TelltaleToolKit/GamesDatabase/GameProfileJsonConverter.cs +++ b/src/TelltaleToolKit/Games/GameProfileJsonConverter.cs @@ -1,10 +1,10 @@ using System.Text.Json; using System.Text.Json.Serialization; -using TelltaleToolKit.TelltaleArchives; -using TelltaleToolKit.Utility.Blowfish; -using TelltaleToolKit.Utility.Lua; +using TelltaleToolKit.Encryption; +using TelltaleToolKit.IO.Archives; +using TelltaleToolKit.Lua; -namespace TelltaleToolKit.GamesDatabase; +namespace TelltaleToolKit.Games; /// /// Custom JSON converter for objects. diff --git a/src/TelltaleToolKit/GamesDatabase/GameProfileJsonExtensions.cs b/src/TelltaleToolKit/Games/GameProfileJsonExtensions.cs similarity index 94% rename from src/TelltaleToolKit/GamesDatabase/GameProfileJsonExtensions.cs rename to src/TelltaleToolKit/Games/GameProfileJsonExtensions.cs index 64a1c5b..5d4392d 100644 --- a/src/TelltaleToolKit/GamesDatabase/GameProfileJsonExtensions.cs +++ b/src/TelltaleToolKit/Games/GameProfileJsonExtensions.cs @@ -1,7 +1,7 @@ using System.Text.Json; -using TelltaleToolKit.Reflection; +using TelltaleToolKit.Meta.Reflection; -namespace TelltaleToolKit.GamesDatabase; +namespace TelltaleToolKit.Games; public class GameProfileJsonExtensions { diff --git a/src/TelltaleToolKit/HashDatabase/ISymbolResolver.cs b/src/TelltaleToolKit/HashDatabase/ISymbolResolver.cs deleted file mode 100644 index 2266072..0000000 --- a/src/TelltaleToolKit/HashDatabase/ISymbolResolver.cs +++ /dev/null @@ -1,46 +0,0 @@ -using TelltaleToolKit.T3Types; - -namespace TelltaleToolKit.HashDatabase; - -/// -/// Interface for resolving names from CRC64 values. -/// -public interface ISymbolResolver -{ - /// - /// Resolves a single symbol. - /// - bool ResolveSymbol(Symbol symbol); - - /// - /// Resolves multiple symbols in a batch. - /// - int ResolveSymbols(IEnumerable symbols); - - /// - /// Adds a symbol to the resolver. - /// - void AddSymbol(string symbolName); - - /// - /// Adds a symbol with its CRC64. - /// - void AddSymbol(ulong crc64, string symbolName); - - bool RemoveSymbol(ulong crc64); - bool RemoveSymbol(string symbolName); - - /// - /// Clears all symbols. - /// - void Clear(); - - bool Contains(ulong crc64); - bool Contains(string symbolName); - bool TryGetValue(ulong crc64, out string? symbolName); - - /// - /// Gets the number of symbols in the resolver. - /// - int Count { get; } -} diff --git a/src/TelltaleToolKit/Utility/Hashing/Crc64.cs b/src/TelltaleToolKit/Hashing/Crc64.cs similarity index 97% rename from src/TelltaleToolKit/Utility/Hashing/Crc64.cs rename to src/TelltaleToolKit/Hashing/Crc64.cs index bf09aa4..8aa3531 100644 --- a/src/TelltaleToolKit/Utility/Hashing/Crc64.cs +++ b/src/TelltaleToolKit/Hashing/Crc64.cs @@ -1,6 +1,6 @@ using System.Diagnostics; -namespace TelltaleToolKit.Utility.Hashing; +namespace TelltaleToolKit.Hashing; public static class Crc64 { diff --git a/src/TelltaleToolKit/HashDatabase/HashDatabase.cs b/src/TelltaleToolKit/Hashing/HashDatabase.cs similarity index 94% rename from src/TelltaleToolKit/HashDatabase/HashDatabase.cs rename to src/TelltaleToolKit/Hashing/HashDatabase.cs index f8681f4..b21e821 100644 --- a/src/TelltaleToolKit/HashDatabase/HashDatabase.cs +++ b/src/TelltaleToolKit/Hashing/HashDatabase.cs @@ -1,15 +1,14 @@ using System.Collections.Concurrent; using System.Text; using TelltaleToolKit.T3Types; -using TelltaleToolKit.Utility.Hashing; -namespace TelltaleToolKit.HashDatabase; +namespace TelltaleToolKit.Hashing; /// /// An in-memory, thread-safe hash database for storing and resolving entries. /// Supports loading from text files and automatic caching. /// -public class HashDatabase : ISymbolResolver +public class HashDatabase { private readonly ConcurrentDictionary _symbols = new(); @@ -326,20 +325,13 @@ public void ExportToFile(string filePath, IEnumerable /// Merges another hash database into this one. /// - public void Merge(ISymbolResolver other) + public void Merge(HashDatabase other) { if (other == null) throw new ArgumentNullException(nameof(other)); - if (other is HashDatabase memoryDb) + foreach (KeyValuePair kvp in other._symbols) { - foreach (KeyValuePair kvp in memoryDb._symbols) - { - AddSymbol(kvp.Key, kvp.Value); - } - } - else - { - throw new NotImplementedException("Merging with non-HashDatabase not yet implemented"); + AddSymbol(kvp.Key, kvp.Value); } } } diff --git a/src/TelltaleToolKit/TelltaleArchives/Archive.cs b/src/TelltaleToolKit/IO/Archives/Archive.cs similarity index 99% rename from src/TelltaleToolKit/TelltaleArchives/Archive.cs rename to src/TelltaleToolKit/IO/Archives/Archive.cs index 798932c..bcd03e2 100644 --- a/src/TelltaleToolKit/TelltaleArchives/Archive.cs +++ b/src/TelltaleToolKit/IO/Archives/Archive.cs @@ -1,10 +1,10 @@ using System.IO.Enumeration; +using TelltaleToolKit.Encryption; +using TelltaleToolKit.Hashing; +using TelltaleToolKit.IO.Archives.Formats; using TelltaleToolKit.T3Types; -using TelltaleToolKit.TelltaleArchives.Formats; -using TelltaleToolKit.Utility.Blowfish; -using TelltaleToolKit.Utility.Hashing; -namespace TelltaleToolKit.TelltaleArchives; +namespace TelltaleToolKit.IO.Archives; /// /// Base class for all Telltale archive formats (.ttarch, .ttarch2, PK2). diff --git a/src/TelltaleToolKit/TelltaleArchives/ArchiveFlags.cs b/src/TelltaleToolKit/IO/Archives/ArchiveFlags.cs similarity index 97% rename from src/TelltaleToolKit/TelltaleArchives/ArchiveFlags.cs rename to src/TelltaleToolKit/IO/Archives/ArchiveFlags.cs index a677189..510ed8d 100644 --- a/src/TelltaleToolKit/TelltaleArchives/ArchiveFlags.cs +++ b/src/TelltaleToolKit/IO/Archives/ArchiveFlags.cs @@ -1,4 +1,4 @@ -namespace TelltaleToolKit.TelltaleArchives; +namespace TelltaleToolKit.IO.Archives; /// /// Flags that describe the encryption and compression state of a Telltale archive. diff --git a/src/TelltaleToolKit/TelltaleArchives/ArchiveInfo.cs b/src/TelltaleToolKit/IO/Archives/ArchiveInfo.cs similarity index 97% rename from src/TelltaleToolKit/TelltaleArchives/ArchiveInfo.cs rename to src/TelltaleToolKit/IO/Archives/ArchiveInfo.cs index cde8b59..6aee46e 100644 --- a/src/TelltaleToolKit/TelltaleArchives/ArchiveInfo.cs +++ b/src/TelltaleToolKit/IO/Archives/ArchiveInfo.cs @@ -1,4 +1,4 @@ -namespace TelltaleToolKit.TelltaleArchives; +namespace TelltaleToolKit.IO.Archives; /// /// Contains metadata about a Telltale archive, including its container type, diff --git a/src/TelltaleToolKit/TelltaleArchives/ArchiveWriteOptions.cs b/src/TelltaleToolKit/IO/Archives/ArchiveWriteOptions.cs similarity index 87% rename from src/TelltaleToolKit/TelltaleArchives/ArchiveWriteOptions.cs rename to src/TelltaleToolKit/IO/Archives/ArchiveWriteOptions.cs index ddec78a..66bd24c 100644 --- a/src/TelltaleToolKit/TelltaleArchives/ArchiveWriteOptions.cs +++ b/src/TelltaleToolKit/IO/Archives/ArchiveWriteOptions.cs @@ -1,7 +1,6 @@ -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Utility.Compression; +using TelltaleToolKit.IO.Streams; -namespace TelltaleToolKit.TelltaleArchives; +namespace TelltaleToolKit.IO.Archives; /// /// Controls how an archive is written or repacked. @@ -27,9 +26,9 @@ public sealed class ArchiveWriteOptions /// /// Gets or sets the compression algorithm to use. - /// Defaults to . + /// Defaults to . /// - public Compression Algorithm { get; set; } = Compression.Deflate; + public Compression.Mode Compression { get; set; } = IO.Compression.Mode.Deflate; /// /// Gets or sets the decompressed size of each chunk in bytes. diff --git a/src/TelltaleToolKit/TelltaleArchives/Formats/PK2.cs b/src/TelltaleToolKit/IO/Archives/Formats/PK2.cs similarity index 82% rename from src/TelltaleToolKit/TelltaleArchives/Formats/PK2.cs rename to src/TelltaleToolKit/IO/Archives/Formats/PK2.cs index 21d0156..723e04c 100644 --- a/src/TelltaleToolKit/TelltaleArchives/Formats/PK2.cs +++ b/src/TelltaleToolKit/IO/Archives/Formats/PK2.cs @@ -1,4 +1,4 @@ -namespace TelltaleToolKit.TelltaleArchives.Formats; +namespace TelltaleToolKit.IO.Archives.Formats; // TODO: PK2 for CSI. public class Pk2TTArchive : Archive diff --git a/src/TelltaleToolKit/TelltaleArchives/Formats/TTArchive.cs b/src/TelltaleToolKit/IO/Archives/Formats/TTArchive.cs similarity index 94% rename from src/TelltaleToolKit/TelltaleArchives/Formats/TTArchive.cs rename to src/TelltaleToolKit/IO/Archives/Formats/TTArchive.cs index cb45112..b9fcf91 100644 --- a/src/TelltaleToolKit/TelltaleArchives/Formats/TTArchive.cs +++ b/src/TelltaleToolKit/IO/Archives/Formats/TTArchive.cs @@ -2,13 +2,11 @@ using System.IO.Hashing; using System.Text; using ICSharpCode.SharpZipLib.Zip.Compression.Streams; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.TelltaleArchives.IO; -using TelltaleToolKit.Utility.Blowfish; -using TelltaleToolKit.Utility.Compression; -using Crc64 = TelltaleToolKit.Utility.Hashing.Crc64; +using TelltaleToolKit.Encryption; +using TelltaleToolKit.IO.Streams; +using Crc64 = TelltaleToolKit.Hashing.Crc64; -namespace TelltaleToolKit.TelltaleArchives.Formats; +namespace TelltaleToolKit.IO.Archives.Formats; /// /// Reader for the original .ttarch archive format (versions 0–9). @@ -83,9 +81,8 @@ protected override void Activate() if (Info.ChunkCount > 0) { - // Both flags are set; DecompressBlock sorts out which algorithm is active. + // Both flags are set; Decompress sorts out which algorithm is active. Info.ChunkSize = 0x10000; - Info.Flags |= ArchiveFlags.IsRawDeflateCompressed | ArchiveFlags.IsZlibCompressed; } _ = reader.ReadUInt32(); // total file-data region size AFTER the ttarch header is read (and the name) @@ -128,15 +125,22 @@ protected override void Activate() int infoHeaderSize = reader.ReadInt32(); + Compression.Mode compression = Compression.Mode.None; + // This is compressed byte[] header; if (version >= 6 && filesMode == 2) { int compressedHeaderSize = reader.ReadInt32(); header = reader.ReadBytes(compressedHeaderSize); - ArchiveFlags archiveFlags = Info.Flags; - header = ChunkDecoder.DecompressBlock(header, infoHeaderSize, ref archiveFlags); - Info.Flags = archiveFlags; + + compression = Compression.DetectMode(header); + + Info.Flags |= compression is Compression.Mode.Deflate + ? ArchiveFlags.IsRawDeflateCompressed + : ArchiveFlags.IsZlibCompressed; + + header = Compression.Decompress(header, compression); } else { @@ -151,7 +155,16 @@ protected override void Activate() Info.FilesOffset = (ulong)reader.BaseStream.Position; ParseEntries(new MemoryStream(header)); - _dataStream = BuildFileDataStream(version, filesMode, decryptionMode); + _dataStream = BuildFileDataStream(version, filesMode, decryptionMode, compression); + + if (compression is Compression.Mode.None && _dataStream is TtarchiveChunkedDataStream chunkedStream) + { + OpenResource(Entries.First().Key)?.ReadByte(); + + Info.Flags |= chunkedStream.Compression is Compression.Mode.Deflate + ? ArchiveFlags.IsRawDeflateCompressed + : ArchiveFlags.IsZlibCompressed; + } } /// @@ -183,7 +196,7 @@ private void ReadLegacyStream(BinaryReader reader) ParseEntries(new MemoryStream(header)); Info.FilesOffset = (ulong)reader.BaseStream.Position; - _dataStream = BuildFileDataStream(0, 0, 1); + _dataStream = BuildFileDataStream(0, 0, 1, Compression.Mode.None); } else { @@ -192,7 +205,7 @@ private void ReadLegacyStream(BinaryReader reader) ParseEntries(reader.BaseStream); Info.FilesOffset = reader.ReadUInt32(); _ = reader.ReadUInt32(); // file size - _dataStream = BuildFileDataStream(0, 0, 0); + _dataStream = BuildFileDataStream(0, 0, 0, Compression.Mode.None); } } @@ -238,7 +251,8 @@ private void ParseEntries(Stream stream) SetEntries(entries); } - private Stream BuildFileDataStream(int version, uint filesMode, uint decryptionMode) + private Stream BuildFileDataStream(int version, uint filesMode, uint decryptionMode, + Compression.Mode compressionMode) { // No compression → raw substream (may still need per-file decryption later) if (Info.ChunkCount == 0 || filesMode != 2) @@ -252,7 +266,7 @@ private Stream BuildFileDataStream(int version, uint filesMode, uint decryptionM (long)Info.FilesOffset, Info.ChunkSize, Info.ChunkBlockSizes, - Info.Flags, + compressionMode, Info.BlowfishKey, version, decryptionMode == 1); @@ -294,7 +308,7 @@ public static void Create(Stream output, IEnumerable<(string name, Stream dataSt } bool encrypt = options.Encrypt; - bool compressFileData = options.Algorithm != Compression.None && version >= 3; + bool compressFileData = options.Compression != Compression.Mode.None && version >= 3; bool compressHeader = compressFileData && version >= 6; // compressed entry table block (filesMode=2) Blowfish bf = new(options.BlowfishKey, version); @@ -352,7 +366,7 @@ public static void Create(Stream output, IEnumerable<(string name, Stream dataSt byte[] CompressBlock(byte[] data) { using MemoryStream ms = new(); - if (options.Algorithm == Compression.Zlib) + if (options.Compression == Compression.Mode.Zlib) { using DeflaterOutputStream zlib = new(ms); zlib.Write(data, 0, data.Length); diff --git a/src/TelltaleToolKit/TelltaleArchives/Formats/TTArchive2.cs b/src/TelltaleToolKit/IO/Archives/Formats/TTArchive2.cs similarity index 98% rename from src/TelltaleToolKit/TelltaleArchives/Formats/TTArchive2.cs rename to src/TelltaleToolKit/IO/Archives/Formats/TTArchive2.cs index d6900ae..fa8084b 100644 --- a/src/TelltaleToolKit/TelltaleArchives/Formats/TTArchive2.cs +++ b/src/TelltaleToolKit/IO/Archives/Formats/TTArchive2.cs @@ -1,9 +1,8 @@ using System.Text; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Utility.Compression; -using TelltaleToolKit.Utility.Hashing; +using TelltaleToolKit.Hashing; +using TelltaleToolKit.IO.Streams; -namespace TelltaleToolKit.TelltaleArchives.Formats; +namespace TelltaleToolKit.IO.Archives.Formats; /// /// Reader for the .ttarch2 archive format (TTA2 / TTA3 / TTA4). @@ -34,10 +33,10 @@ protected override void Activate() // Copy container state back to Info so the rest of the code (and callers // that inspect Info) see the right values. Info.Flags |= _containerStream.Params.Encrypt ? ArchiveFlags.IsEncrypted : 0; - Info.Flags |= _containerStream.Params.Algorithm == Compression.Deflate + Info.Flags |= _containerStream.Params.Algorithm == Compression.Mode.Deflate ? ArchiveFlags.IsRawDeflateCompressed : 0; - Info.Flags |= _containerStream.Params.Algorithm == Compression.Oodle + Info.Flags |= _containerStream.Params.Algorithm == Compression.Mode.Oodle ? ArchiveFlags.IsOodleCompressed : 0; Info.ChunkSize = _containerStream.WindowSize; @@ -321,7 +320,7 @@ public static void Create(Stream output, IEnumerable<(string name, Stream dataSt { Encrypt = options.Encrypt, ChunkSize = options.ChunkSize, - Algorithm = options.Algorithm, + Algorithm = options.Compression, BlowfishKey = options.BlowfishKey }; diff --git a/src/TelltaleToolKit/TelltaleArchives/ResourceEntry.cs b/src/TelltaleToolKit/IO/Archives/ResourceEntry.cs similarity index 91% rename from src/TelltaleToolKit/TelltaleArchives/ResourceEntry.cs rename to src/TelltaleToolKit/IO/Archives/ResourceEntry.cs index 411286c..fd0a577 100644 --- a/src/TelltaleToolKit/TelltaleArchives/ResourceEntry.cs +++ b/src/TelltaleToolKit/IO/Archives/ResourceEntry.cs @@ -1,8 +1,8 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; -namespace TelltaleToolKit.TelltaleArchives; +namespace TelltaleToolKit.IO.Archives; /// /// Represents a single file record inside a Telltale archive. @@ -14,7 +14,7 @@ namespace TelltaleToolKit.TelltaleArchives; /// and must not change after insertion. /// /// -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public sealed class ResourceEntry { /// diff --git a/src/TelltaleToolKit/TelltaleArchives/TTArchiveVersion.cs b/src/TelltaleToolKit/IO/Archives/TTArchiveVersion.cs similarity index 98% rename from src/TelltaleToolKit/TelltaleArchives/TTArchiveVersion.cs rename to src/TelltaleToolKit/IO/Archives/TTArchiveVersion.cs index 9a2ce55..8d29174 100644 --- a/src/TelltaleToolKit/TelltaleArchives/TTArchiveVersion.cs +++ b/src/TelltaleToolKit/IO/Archives/TTArchiveVersion.cs @@ -1,4 +1,4 @@ -namespace TelltaleToolKit.TelltaleArchives; +namespace TelltaleToolKit.IO.Archives; /// /// Version identifier for the inner Telltale archive format. diff --git a/src/TelltaleToolKit/Utility/Caching/ChunkCache.cs b/src/TelltaleToolKit/IO/Caching/ChunkCache.cs similarity index 96% rename from src/TelltaleToolKit/Utility/Caching/ChunkCache.cs rename to src/TelltaleToolKit/IO/Caching/ChunkCache.cs index e1ed7e4..7e5ddbf 100644 --- a/src/TelltaleToolKit/Utility/Caching/ChunkCache.cs +++ b/src/TelltaleToolKit/IO/Caching/ChunkCache.cs @@ -1,4 +1,4 @@ -namespace TelltaleToolKit.Utility.Caching; +namespace TelltaleToolKit.IO.Caching; /// /// Defines the contract for a chunk-level cache. diff --git a/src/TelltaleToolKit/Utility/Caching/LruChunkCache.cs b/src/TelltaleToolKit/IO/Caching/LruChunkCache.cs similarity index 97% rename from src/TelltaleToolKit/Utility/Caching/LruChunkCache.cs rename to src/TelltaleToolKit/IO/Caching/LruChunkCache.cs index b3c077e..4250582 100644 --- a/src/TelltaleToolKit/Utility/Caching/LruChunkCache.cs +++ b/src/TelltaleToolKit/IO/Caching/LruChunkCache.cs @@ -1,4 +1,4 @@ -namespace TelltaleToolKit.Utility.Caching; +namespace TelltaleToolKit.IO.Caching; /// /// Cache strategy that retains the N most-recently-used decoded chunks. diff --git a/src/TelltaleToolKit/Utility/Caching/SinglePageCache.cs b/src/TelltaleToolKit/IO/Caching/SinglePageCache.cs similarity index 96% rename from src/TelltaleToolKit/Utility/Caching/SinglePageCache.cs rename to src/TelltaleToolKit/IO/Caching/SinglePageCache.cs index 9d9e72f..3415da7 100644 --- a/src/TelltaleToolKit/Utility/Caching/SinglePageCache.cs +++ b/src/TelltaleToolKit/IO/Caching/SinglePageCache.cs @@ -1,4 +1,4 @@ -namespace TelltaleToolKit.Utility.Caching; +namespace TelltaleToolKit.IO.Caching; /// /// Cache strategy that keeps exactly one decoded chunk in memory at a time. diff --git a/src/TelltaleToolKit/IO/Compression.cs b/src/TelltaleToolKit/IO/Compression.cs new file mode 100644 index 0000000..581446c --- /dev/null +++ b/src/TelltaleToolKit/IO/Compression.cs @@ -0,0 +1,119 @@ +using System.IO.Compression; +using ICSharpCode.SharpZipLib.Zip.Compression.Streams; + +namespace TelltaleToolKit.IO; + +public static class Compression +{ + /// Compression algorithm to use when writing archive chunks. + public enum Mode + { + /// No compression. + None, + + /// Raw DEFLATE (no zlib header). Used by most Telltale games. + Deflate, + + /// Zlib-wrapped DEFLATE. Used by some CSI and earlier titles. + Zlib, + + /// + /// Oodle compression. + /// + Oodle + } + + /// Reads exactly buffer.Length bytes from . + internal static void ReadExact(Stream stream, byte[] buffer) + { + int total = 0; + while (total < buffer.Length) + { + int read = stream.Read(buffer, total, buffer.Length - total); + if (read == 0) + { + throw new EndOfStreamException( + $"Unexpected end of stream after {total} / {buffer.Length} bytes."); + } + + total += read; + } + } + + public static byte[] Decompress(byte[] compressedData, Mode mode, int expectedSize = 0) + { + // This is a hack? In TWD:DE, 401_txmesh, there's a page which is the same size as the expected size (65535) + // C#'s raw deflate fails. + // ttarchext returns the same data: + // https://github.com/infernokun/TelltaleGamesExtractionGUI/blob/fec9fc1a70b545bcc67062fedc3fe3f7cd0d3e1b/bin/Debug/net6.0-windows/ttarchext/ttarchext.c#L1512 + // If the data isn't actually compressed (e.g., same size as expected) + if (expectedSize > 0 && compressedData.Length == expectedSize) + return compressedData; // Already uncompressed + + using var input = new MemoryStream(compressedData, writable: false); + using var output = expectedSize > 0 ? new MemoryStream(expectedSize) : new MemoryStream(); + + try + { + Stream decompressor = mode switch + { + Mode.None => input, // No compression – just copy + Mode.Deflate => new DeflateStream(input, CompressionMode.Decompress), + Mode.Zlib => new InflaterInputStream(input), // from SharpZipLib + Mode.Oodle => throw new NotSupportedException("Oodle not implemented"), // TODO: Add Oodle compression. + _ => throw new ArgumentOutOfRangeException(nameof(mode), mode, null) + }; + + using (decompressor) + { + decompressor.CopyTo(output); + } + + return output.ToArray(); + } + catch (Exception ex) + { + throw new InvalidDataException($"Decompression failed using {mode}.", ex); + } + } + + /// + /// Compresses a single chunk using the specified algorithm. + /// + /// Number of compressed bytes written into . + public static int Compress(ReadOnlySpan input, Mode algorithm, byte[] outputBuffer) + { + using MemoryStream ms = new(outputBuffer, true); + if (algorithm == Mode.Zlib) + { + using DeflaterOutputStream zlib = new(ms); + zlib.Write(input); + zlib.Finish(); + } + else // Deflate (raw) + { + using DeflateStream deflate = new(ms, CompressionLevel.Optimal, true); + deflate.Write(input); + } + + return (int)ms.Position; + } + + public static Mode DetectMode(ReadOnlySpan data) + { + // TODO: Investigate ttarch + // CSI games use zlib compression instead of the regular raw deflate. + // According to TTG Tools, version 8 archives use zlib (presumably for the files themselves) + + if (data.Length < 2) + return Mode.None; // Not enough data to decide + + // Zlib header: first byte = 0x78, second byte's high nibble = 0xC + // Common values: 0x78 0x9C, 0x78 0xDA, 0x78 0x01, 0x78 0x5E + if ((data[0] * 256 + data[1]) % 31 == 0) + return Mode.Zlib; + + // Default: raw DEFLATE has no fixed header + return Mode.Deflate; + } +} diff --git a/src/TelltaleToolKit/Resource/ArchiveProvider.cs b/src/TelltaleToolKit/IO/Resources/ArchiveProvider.cs similarity index 94% rename from src/TelltaleToolKit/Resource/ArchiveProvider.cs rename to src/TelltaleToolKit/IO/Resources/ArchiveProvider.cs index 2fd208f..099ea8a 100644 --- a/src/TelltaleToolKit/Resource/ArchiveProvider.cs +++ b/src/TelltaleToolKit/IO/Resources/ArchiveProvider.cs @@ -1,7 +1,7 @@ -using TelltaleToolKit.TelltaleArchives; -using TelltaleToolKit.Utility.Hashing; +using TelltaleToolKit.Hashing; +using TelltaleToolKit.IO.Archives; -namespace TelltaleToolKit.Resource; +namespace TelltaleToolKit.IO.Resources; /// /// Wraps a single Telltale archive (.ttarch or .ttarch2) as an . @@ -22,7 +22,7 @@ public sealed class ArchiveProvider : IFileProvider, IDisposable /// /// Absolute or relative path to the .ttarch / .ttarch2 file. /// - /// The workspace whose method is + /// The workspace whose method is /// used so the ArchiveLoaded event fires and the correct decryption key is applied. /// /// diff --git a/src/TelltaleToolKit/Resource/FolderProvider.cs b/src/TelltaleToolKit/IO/Resources/FolderProvider.cs similarity index 97% rename from src/TelltaleToolKit/Resource/FolderProvider.cs rename to src/TelltaleToolKit/IO/Resources/FolderProvider.cs index d0e200f..cb86887 100644 --- a/src/TelltaleToolKit/Resource/FolderProvider.cs +++ b/src/TelltaleToolKit/IO/Resources/FolderProvider.cs @@ -1,7 +1,7 @@ -using TelltaleToolKit.TelltaleArchives; -using TelltaleToolKit.Utility.Hashing; +using TelltaleToolKit.Hashing; +using TelltaleToolKit.IO.Archives; -namespace TelltaleToolKit.Resource; +namespace TelltaleToolKit.IO.Resources; /// /// Recursively exposes a directory tree of loose files and Telltale archives diff --git a/src/TelltaleToolKit/Resource/IFileProvider.cs b/src/TelltaleToolKit/IO/Resources/IFileProvider.cs similarity index 97% rename from src/TelltaleToolKit/Resource/IFileProvider.cs rename to src/TelltaleToolKit/IO/Resources/IFileProvider.cs index ac82f3b..77b446d 100644 --- a/src/TelltaleToolKit/Resource/IFileProvider.cs +++ b/src/TelltaleToolKit/IO/Resources/IFileProvider.cs @@ -1,6 +1,6 @@ -using TelltaleToolKit.TelltaleArchives; +using TelltaleToolKit.IO.Archives; -namespace TelltaleToolKit.Resource; +namespace TelltaleToolKit.IO.Resources; /// /// Abstracts access to one or more Telltale game files, whether from a loose file on disk, diff --git a/src/TelltaleToolKit/Resource/LooseFileProvider.cs b/src/TelltaleToolKit/IO/Resources/LooseFileProvider.cs similarity index 95% rename from src/TelltaleToolKit/Resource/LooseFileProvider.cs rename to src/TelltaleToolKit/IO/Resources/LooseFileProvider.cs index 2a63031..f1015c5 100644 --- a/src/TelltaleToolKit/Resource/LooseFileProvider.cs +++ b/src/TelltaleToolKit/IO/Resources/LooseFileProvider.cs @@ -1,6 +1,6 @@ -using TelltaleToolKit.TelltaleArchives; +using TelltaleToolKit.IO.Archives; -namespace TelltaleToolKit.Resource; +namespace TelltaleToolKit.IO.Resources; /// /// Exposes a single loose file on disk as an . @@ -25,7 +25,7 @@ public LooseFileProvider(string path) Path = path; Name = System.IO.Path.GetFileName(path); - Crc64 = Utility.Hashing.Crc64.Compute(Name); + Crc64 = Hashing.Crc64.Compute(Name); Size = new FileInfo(path).Length; } diff --git a/src/TelltaleToolKit/Resource/ResourceContext.cs b/src/TelltaleToolKit/IO/Resources/ResourceContext.cs similarity index 97% rename from src/TelltaleToolKit/Resource/ResourceContext.cs rename to src/TelltaleToolKit/IO/Resources/ResourceContext.cs index e1f3102..a55c85f 100644 --- a/src/TelltaleToolKit/Resource/ResourceContext.cs +++ b/src/TelltaleToolKit/IO/Resources/ResourceContext.cs @@ -1,7 +1,7 @@ -using TelltaleToolKit.TelltaleArchives; -using TelltaleToolKit.Utility.Hashing; +using TelltaleToolKit.Hashing; +using TelltaleToolKit.IO.Archives; -namespace TelltaleToolKit.Resource; +namespace TelltaleToolKit.IO.Resources; /// /// Represents a named, prioritized group of instances. diff --git a/src/TelltaleToolKit/Serialization/ContainerMagic.cs b/src/TelltaleToolKit/IO/Streams/ContainerMagic.cs similarity index 96% rename from src/TelltaleToolKit/Serialization/ContainerMagic.cs rename to src/TelltaleToolKit/IO/Streams/ContainerMagic.cs index 4a984ab..1fb1f4d 100644 --- a/src/TelltaleToolKit/Serialization/ContainerMagic.cs +++ b/src/TelltaleToolKit/IO/Streams/ContainerMagic.cs @@ -1,4 +1,4 @@ -namespace TelltaleToolKit.Serialization; +namespace TelltaleToolKit.IO.Streams; /// /// Four‑byte magic numbers identifying the container format of a file. diff --git a/src/TelltaleToolKit/Serialization/ContainerStream.cs b/src/TelltaleToolKit/IO/Streams/ContainerStream.cs similarity index 90% rename from src/TelltaleToolKit/Serialization/ContainerStream.cs rename to src/TelltaleToolKit/IO/Streams/ContainerStream.cs index c236c4c..522eb43 100644 --- a/src/TelltaleToolKit/Serialization/ContainerStream.cs +++ b/src/TelltaleToolKit/IO/Streams/ContainerStream.cs @@ -1,11 +1,11 @@ using System.IO.Compression; using System.Text; using ICSharpCode.SharpZipLib.Zip.Compression.Streams; -using TelltaleToolKit.Utility.Blowfish; -using TelltaleToolKit.Utility.Caching; -using TelltaleToolKit.Utility.Compression; +using TelltaleToolKit.Encryption; +using TelltaleToolKit.IO.Archives.Formats; +using TelltaleToolKit.IO.Caching; -namespace TelltaleToolKit.Serialization; +namespace TelltaleToolKit.IO.Streams; /// /// A forward-readable, seekable that decodes the outer @@ -14,7 +14,7 @@ namespace TelltaleToolKit.Serialization; /// /// /// Single responsibility: parse the container header and expose the -/// inner TTA2/3/4 payload as a readable stream so can walk +/// inner TTA2/3/4 payload as a readable stream so can walk /// the entry table and name-page stream. It is disposed immediately after that forward /// pass — extraction never goes through it. /// @@ -67,11 +67,11 @@ public ContainerStream(Stream source, string blowfishKey, IChunkCache? cache = n throw new NotSupportedException($"[ContainerStream] Unknown container magic {ContainerMagic}."); } - Compression algorithm = ContainerMagic switch + Compression.Mode algorithm = ContainerMagic switch { - ContainerMagic.TTCN => Compression.None, + ContainerMagic.TTCN => Compression.Mode.None, ContainerMagic.TTCe or ContainerMagic.TTCz => ReadCompressionType(reader), - _ => Compression.Deflate + _ => Compression.Mode.Deflate }; Params = new ContainerStreamParams @@ -81,7 +81,7 @@ public ContainerStream(Stream source, string blowfishKey, IChunkCache? cache = n Algorithm = algorithm }; - if (Params.Algorithm != Compression.None) + if (Params.Algorithm != Compression.Mode.None) { WindowSize = reader.ReadUInt32(); @@ -114,13 +114,13 @@ public ContainerStream(Stream source, string blowfishKey, IChunkCache? cache = n PayloadStart = source.Position; // first byte of TTA2/3/4 payload } - private static Compression ReadCompressionType(BinaryReader reader) + private static Compression.Mode ReadCompressionType(BinaryReader reader) { uint compressionType = reader.ReadUInt32(); return compressionType switch { - 0 => Compression.Deflate, - 1 => Compression.Oodle, + 0 => Compression.Mode.Deflate, + 1 => Compression.Mode.Oodle, _ => throw new NotSupportedException( $"[ContainerStream] Unknown compression type {compressionType}.") }; @@ -208,7 +208,7 @@ public override int Read(Span buffer) } // ---- Uncompressed — backed by MemoryStream ---- - if (Params.Algorithm is Compression.None) + if (Params.Algorithm is Compression.Mode.None) { _source.Position = PayloadStart + _position; int bytesToRead = (int)Math.Min(buffer.Length, Length - _position); @@ -274,7 +274,7 @@ private byte[] DecodeChunk(int chunkIndex) _source.Seek(chunkSrcOffset, SeekOrigin.Begin); byte[] compressed = new byte[ChunkBlockSizes[chunkIndex]]; - ChunkDecoder.ReadExact(_source, compressed); + Compression.ReadExact(_source, compressed); if (Params.Encrypt) { @@ -286,7 +286,7 @@ private byte[] DecodeChunk(int chunkIndex) } public static byte[] DecompressBlock(byte[] compressedData, int expectedSize, - Compression compression) + Compression.Mode compression) { // This is a hack? In TWD:DE, 401_txmesh, there's a page which is the same size as the expected size (65535) // C#'s raw deflate fails. @@ -299,9 +299,9 @@ public static byte[] DecompressBlock(byte[] compressedData, int expectedSize, return compression switch { - Compression.Deflate => Decompress(ms => new DeflateStream(ms, CompressionMode.Decompress)), - Compression.Zlib => Decompress(ms => new InflaterInputStream(ms)), - Compression.Oodle => throw new NotSupportedException("Oodle compression is not supported yet."), + Compression.Mode.Deflate => Decompress(ms => new DeflateStream(ms, CompressionMode.Decompress)), + Compression.Mode.Zlib => Decompress(ms => new InflaterInputStream(ms)), + Compression.Mode.Oodle => throw new NotSupportedException("Oodle compression is not supported yet."), // No compression, return the original data _ => compressedData }; @@ -379,7 +379,7 @@ public static void Create(Stream destination, ReadOnlySpan payload, Contai /// Archive options (compression, encryption, chunk size, key). public static void Create(Stream destination, Stream payloadStream, ContainerStreamParams options) { - if (options.Algorithm == Compression.Oodle) + if (options.Algorithm == Compression.Mode.Oodle) { throw new NotSupportedException("Oodle compression not yet implemented."); } @@ -387,15 +387,15 @@ public static void Create(Stream destination, Stream payloadStream, ContainerStr // Choose magic automatically ContainerMagic magic = (options.Encrypt, options.Algorithm) switch { - (false, Compression.None) => ContainerMagic.TTCN, - (true, Compression.Deflate) => ContainerMagic.TTCE, - (false, Compression.Deflate) => ContainerMagic.TTCZ, - (true, Compression.Oodle) => ContainerMagic + (false, Compression.Mode.None) => ContainerMagic.TTCN, + (true, Compression.Mode.Deflate) => ContainerMagic.TTCE, + (false, Compression.Mode.Deflate) => ContainerMagic.TTCZ, + (true, Compression.Mode.Oodle) => ContainerMagic .TTCe, // encryption without compression? Rare, but fallback - (false, Compression.Oodle) => ContainerMagic + (false, Compression.Mode.Oodle) => ContainerMagic .TTCz, // encryption without compression? Rare, but fallback _ => throw new NotSupportedException( - $"Unsupported combination: Encrypt={options.Encrypt}, Algorithm={options.Algorithm}") + $"Unsupported combination: Encrypt={options.Encrypt}, Compression={options.Algorithm}") }; using BinaryWriter writer = new(destination, Encoding.UTF8, true); @@ -403,11 +403,11 @@ public static void Create(Stream destination, Stream payloadStream, ContainerStr if (magic is ContainerMagic.TTCe or ContainerMagic.TTCz) { - uint comprType = options.Algorithm == Compression.Deflate ? 0u : 1u; // 1 = Oodle + uint comprType = options.Algorithm == Compression.Mode.Deflate ? 0u : 1u; // 1 = Oodle writer.Write(comprType); } - bool compress = options.Algorithm != Compression.None; + bool compress = options.Algorithm != Compression.Mode.None; Blowfish blowfish = new(options.BlowfishKey, 7); if (!compress) @@ -453,7 +453,7 @@ public static void Create(Stream destination, Stream payloadStream, ContainerStr throw new EndOfStreamException("Unexpected end of payload stream."); } - int compressedLen = Utility.Compression.ChunkDecoder.CompressBlock(chunk, options.Algorithm, compressedBuffer); + int compressedLen = Compression.Compress(chunk, options.Algorithm, compressedBuffer); byte[] finalData = compressedBuffer.AsSpan(0, compressedLen).ToArray(); if (options.Encrypt) { diff --git a/src/TelltaleToolKit/Serialization/ContainerStreamParams.cs b/src/TelltaleToolKit/IO/Streams/ContainerStreamParams.cs similarity index 84% rename from src/TelltaleToolKit/Serialization/ContainerStreamParams.cs rename to src/TelltaleToolKit/IO/Streams/ContainerStreamParams.cs index 4b8fa81..98b44a5 100644 --- a/src/TelltaleToolKit/Serialization/ContainerStreamParams.cs +++ b/src/TelltaleToolKit/IO/Streams/ContainerStreamParams.cs @@ -1,6 +1,4 @@ -using TelltaleToolKit.Utility.Compression; - -namespace TelltaleToolKit.Serialization; +namespace TelltaleToolKit.IO.Streams; /// /// Parameters for creating a Telltale Tool Container stream. @@ -18,7 +16,7 @@ public sealed class ContainerStreamParams /// The compression algorithm used to compress the container. /// Defaults to Deflate (ZLIB in Telltale's terms). /// - public Compression Algorithm { get; init; } = Compression.Deflate; + public Compression.Mode Algorithm { get; init; } = Compression.Mode.Deflate; /// /// Blowfish key used when is true. diff --git a/src/TelltaleToolKit/Serialization/LegacyEncryptedStream.cs b/src/TelltaleToolKit/IO/Streams/LegacyEncryptedStream.cs similarity index 98% rename from src/TelltaleToolKit/Serialization/LegacyEncryptedStream.cs rename to src/TelltaleToolKit/IO/Streams/LegacyEncryptedStream.cs index e39ca88..4257900 100644 --- a/src/TelltaleToolKit/Serialization/LegacyEncryptedStream.cs +++ b/src/TelltaleToolKit/IO/Streams/LegacyEncryptedStream.cs @@ -1,6 +1,6 @@ -using TelltaleToolKit.Utility.Blowfish; +using TelltaleToolKit.Encryption; -namespace TelltaleToolKit.Serialization.Binary; +namespace TelltaleToolKit.IO.Streams; /// /// Stream wrapper that decrypts TTArchive per‑file data on the fly. diff --git a/src/TelltaleToolKit/Serialization/SubStream.cs b/src/TelltaleToolKit/IO/Streams/SubStream.cs similarity index 99% rename from src/TelltaleToolKit/Serialization/SubStream.cs rename to src/TelltaleToolKit/IO/Streams/SubStream.cs index eff15b2..a2ac1cb 100644 --- a/src/TelltaleToolKit/Serialization/SubStream.cs +++ b/src/TelltaleToolKit/IO/Streams/SubStream.cs @@ -1,4 +1,4 @@ -namespace TelltaleToolKit.Serialization; +namespace TelltaleToolKit.IO.Streams; /// /// Represents a substream of an underlying . diff --git a/src/TelltaleToolKit/TelltaleArchives/IO/TtarchiveChunkedDataStream.cs b/src/TelltaleToolKit/IO/Streams/TtarchiveChunkedDataStream.cs similarity index 87% rename from src/TelltaleToolKit/TelltaleArchives/IO/TtarchiveChunkedDataStream.cs rename to src/TelltaleToolKit/IO/Streams/TtarchiveChunkedDataStream.cs index 0b4a919..79a9905 100644 --- a/src/TelltaleToolKit/TelltaleArchives/IO/TtarchiveChunkedDataStream.cs +++ b/src/TelltaleToolKit/IO/Streams/TtarchiveChunkedDataStream.cs @@ -1,8 +1,7 @@ -using TelltaleToolKit.Utility.Blowfish; -using TelltaleToolKit.Utility.Caching; -using TelltaleToolKit.Utility.Compression; +using TelltaleToolKit.Encryption; +using TelltaleToolKit.IO.Caching; -namespace TelltaleToolKit.TelltaleArchives.IO; +namespace TelltaleToolKit.IO.Streams; /// /// Presents a continuous, seekable stream of decompressed file data from a @@ -18,7 +17,7 @@ internal sealed class TtarchiveChunkedDataStream : Stream private readonly long _dataStart; private readonly bool _isEncrypted; private readonly Stream _source; - private ArchiveFlags _flags; + public Compression.Mode Compression { get; private set; } private long _position; public TtarchiveChunkedDataStream( @@ -26,7 +25,7 @@ public TtarchiveChunkedDataStream( long dataStart, uint chunkSize, ulong[] chunkSizes, - ArchiveFlags flags, + Compression.Mode compressionMode, string blowfishKey, int archiveVersion, bool isEncrypted, IChunkCache? cache = null) @@ -35,11 +34,10 @@ public TtarchiveChunkedDataStream( _dataStart = dataStart; _chunkSize = chunkSize; _chunkSizes = chunkSizes; - _flags = flags; _isEncrypted = isEncrypted; _blowfish = new Blowfish(blowfishKey, archiveVersion); _cache = cache ?? new SinglePageCache(); - + Compression = compressionMode; // Build prefix sums for O(1) chunk offset lookup _chunkPrefixSums = new ulong[chunkSizes.Length + 1]; for (int i = 0; i < chunkSizes.Length; i++) @@ -117,7 +115,7 @@ private byte[] DecodeChunk(int chunkIdx) _source.Seek(offset, SeekOrigin.Begin); byte[] compressed = new byte[_chunkSizes[chunkIdx]]; - ChunkDecoder.ReadExact(_source, compressed); + IO.Compression.ReadExact(_source, compressed); // Decrypt chunk if needed (per‑chunk, not per‑file) if (_isEncrypted) @@ -125,11 +123,13 @@ private byte[] DecodeChunk(int chunkIdx) _blowfish.Decipher(compressed.AsSpan(), compressed.Length); } - // Decompress the chunk - ArchiveFlags flags = _flags; - byte[] res = ChunkDecoder.DecompressBlock(compressed, (int)_chunkSize, ref flags); - _flags = flags; - return res; + if (Compression is IO.Compression.Mode.None) + { + // Detect the compression + Compression = IO.Compression.DetectMode(compressed); + } + + return IO.Compression.Decompress(compressed, Compression, (int)_chunkSize); } public override long Seek(long offset, SeekOrigin origin) diff --git a/src/TelltaleToolKit/Utility/Lua/LuaVersion.cs b/src/TelltaleToolKit/Lua/LuaVersion.cs similarity index 90% rename from src/TelltaleToolKit/Utility/Lua/LuaVersion.cs rename to src/TelltaleToolKit/Lua/LuaVersion.cs index acc2931..82d8fb1 100644 --- a/src/TelltaleToolKit/Utility/Lua/LuaVersion.cs +++ b/src/TelltaleToolKit/Lua/LuaVersion.cs @@ -1,4 +1,4 @@ -namespace TelltaleToolKit.Utility.Lua; +namespace TelltaleToolKit.Lua; /// /// Specifies the supported Lua scripting engine versions for Telltale games. diff --git a/src/TelltaleToolKit/Utility/Lua/LuaVersionExtensions.cs b/src/TelltaleToolKit/Lua/LuaVersionExtensions.cs similarity index 97% rename from src/TelltaleToolKit/Utility/Lua/LuaVersionExtensions.cs rename to src/TelltaleToolKit/Lua/LuaVersionExtensions.cs index 0078c77..9a254f9 100644 --- a/src/TelltaleToolKit/Utility/Lua/LuaVersionExtensions.cs +++ b/src/TelltaleToolKit/Lua/LuaVersionExtensions.cs @@ -1,4 +1,4 @@ -namespace TelltaleToolKit.Utility.Lua; +namespace TelltaleToolKit.Lua; /// /// Extension methods for to handle conversions between string representations and enum values. diff --git a/src/TelltaleToolKit/Meta/Reflection/MetaClass.cs b/src/TelltaleToolKit/Meta/Reflection/MetaClass.cs new file mode 100644 index 0000000..34f49f3 --- /dev/null +++ b/src/TelltaleToolKit/Meta/Reflection/MetaClass.cs @@ -0,0 +1,112 @@ +using System.IO.Hashing; +using System.Text; + +namespace TelltaleToolKit.Meta.Reflection; +// TODO: Maybe Add enum descriptors. Currently we assume that the enums are fixed. It may not be worth it for the extra memory usage. + +/// +/// Represents a description of a metaclass. +/// This includes type information, versioning, and a list of properties (members). +/// +public sealed class MetaClass +{ + /// + /// Class information, including the name, original type name, and the linking type. + /// + public MetaClassType ClassType { get; init; } = null!; + + /// + /// The CRC32 version number, which is calculated per game. + /// Used to identify the version of the class. + /// + public uint Crc32 { get; set; } + + /// + /// The members (properties) of this class. + /// This is a list of MetaMember objects, each describing a property. + /// + public List Members { get; set; } = []; + + /// + /// Checks whether a member with the specified name exists in the class properties. + /// + /// The member name to check for. + /// True if the member exists; otherwise, false. + public bool ContainsMember(string name) + => Members.Any(member => member.MemberName.Equals(name)); + + /// + /// Calculate the version Crc for the given meta stream version and workspace. + /// + public static uint CalculateVersionCrc(MetaClass metaClass, uint streamVersion, Workspace? workspace = null) + { + var crc32 = new Crc32(); + + // Step 1: Initial value depends on version + if (streamVersion <= 2) + { + uint initial = metaClass.ClassType.IsBlocked() ? 0xFFFFu : 0u; + crc32.Append(BitConverter.GetBytes(initial)); + } + else // MTRE, MSV5, MSV6 all use the same int initializer + { + int initial = metaClass.ClassType.IsBlocked() ? -1 : 0; + crc32.Append(BitConverter.GetBytes(initial)); + } + + // Step 2: Process members + foreach (MetaMember member in metaClass.Members) + { + if (member.Flags.HasFlag(MetaFlags.MetaSerializeDisable)) + continue; + + // Member name is always appended first + crc32.Append(Encoding.UTF8.GetBytes(member.MemberName)); + + var metaclass = workspace?.GetMetaClassDescription(member.Type.LinkingType); + + if (metaclass == null) + throw new InvalidOperationException($"MetaClass not found for type: {member.Type.LinkingType}"); + + // Version specific - this is only a guess + switch (streamVersion) + { + case 1: + case 2: + string typeName = member.Type.FullTypeName; + // Hack for inherited classes in early MBIN builds + if (member.MemberName.StartsWith("Baseclass_")) + typeName += " *"; + crc32.Append(Encoding.UTF8.GetBytes(typeName)); + break; + case 3: + crc32.Append(BitConverter.GetBytes(member.Type.Symbol.Crc64)); + crc32.Append( + BitConverter.GetBytes(metaclass + .Crc32)); // TODO: This breaks when the type is does not have a metaclass description. + break; + case 4: + case 5: + crc32.Append(BitConverter.GetBytes(member.Type.Symbol.Crc64)); + crc32.Append(new[] { Convert.ToByte(member.Type.IsBlocked()) }); + crc32.Append( + BitConverter.GetBytes(metaclass + .Crc32)); // TODO: This breaks when the type is does not have a metaclass description. + break; + case 6: + crc32.Append(BitConverter.GetBytes(member.Type.Symbol.Crc64)); + crc32.Append(new[] { Convert.ToByte(member.Type.IsBlocked()) }); + break; + + default: + throw new ArgumentOutOfRangeException(nameof(streamVersion), + $"Unsupported stream version: {streamVersion}"); + } + } + + return crc32.GetCurrentHashAsUInt32(); + } + + public bool IsCompiledForWorkspace(Workspace workspace) + => Crc32 == CalculateVersionCrc(this, workspace.Profile.StreamVersion, workspace); +} diff --git a/src/TelltaleToolKit/Reflection/MetaClassBuilder.cs b/src/TelltaleToolKit/Meta/Reflection/MetaClassBuilder.cs similarity index 98% rename from src/TelltaleToolKit/Reflection/MetaClassBuilder.cs rename to src/TelltaleToolKit/Meta/Reflection/MetaClassBuilder.cs index 9d0001e..76cc21a 100644 --- a/src/TelltaleToolKit/Reflection/MetaClassBuilder.cs +++ b/src/TelltaleToolKit/Meta/Reflection/MetaClassBuilder.cs @@ -1,4 +1,4 @@ -namespace TelltaleToolKit.Reflection; +namespace TelltaleToolKit.Meta.Reflection; /// /// Builder pattern for constructing instances. @@ -53,7 +53,7 @@ private MetaClassBuilder AddMember(MetaMember? member) _metaClass.Members.Add(member ?? throw new ArgumentNullException(nameof(member))); return this; } - + /// /// Adds a member to the class by name, type, and optional flags. /// @@ -89,4 +89,4 @@ public MetaClass Build() Reset(); return result; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/Reflection/MetaClassJsonConverter.cs b/src/TelltaleToolKit/Meta/Reflection/MetaClassJsonConverter.cs similarity index 98% rename from src/TelltaleToolKit/Reflection/MetaClassJsonConverter.cs rename to src/TelltaleToolKit/Meta/Reflection/MetaClassJsonConverter.cs index da3e1b8..6d971ad 100644 --- a/src/TelltaleToolKit/Reflection/MetaClassJsonConverter.cs +++ b/src/TelltaleToolKit/Meta/Reflection/MetaClassJsonConverter.cs @@ -1,7 +1,7 @@ using System.Text.Json; using System.Text.Json.Serialization; -namespace TelltaleToolKit.Reflection; +namespace TelltaleToolKit.Meta.Reflection; /// /// Provides custom serialization and deserialization for objects. diff --git a/src/TelltaleToolKit/Reflection/MetaClassRegistry.cs b/src/TelltaleToolKit/Meta/Reflection/MetaClassRegistry.cs similarity index 98% rename from src/TelltaleToolKit/Reflection/MetaClassRegistry.cs rename to src/TelltaleToolKit/Meta/Reflection/MetaClassRegistry.cs index 03d7221..cd27a50 100644 --- a/src/TelltaleToolKit/Reflection/MetaClassRegistry.cs +++ b/src/TelltaleToolKit/Meta/Reflection/MetaClassRegistry.cs @@ -1,6 +1,6 @@ using TelltaleToolKit.T3Types; -namespace TelltaleToolKit.Reflection; +namespace TelltaleToolKit.Meta.Reflection; /// /// Registry for metaclass descriptions, allowing lookup and management by type hash and CRC32. diff --git a/src/TelltaleToolKit/Reflection/MetaClassType.cs b/src/TelltaleToolKit/Meta/Reflection/MetaClassType.cs similarity index 98% rename from src/TelltaleToolKit/Reflection/MetaClassType.cs rename to src/TelltaleToolKit/Meta/Reflection/MetaClassType.cs index f81ba35..d9aa0df 100644 --- a/src/TelltaleToolKit/Reflection/MetaClassType.cs +++ b/src/TelltaleToolKit/Meta/Reflection/MetaClassType.cs @@ -1,7 +1,7 @@ using System.Text; using TelltaleToolKit.T3Types; -namespace TelltaleToolKit.Reflection; +namespace TelltaleToolKit.Meta.Reflection; /// /// Represents metadata and reflection information for a class/type, including its name, symbol, linking .NET type, and metadata flags. diff --git a/src/TelltaleToolKit/Reflection/MetaClassTypeRegistry.cs b/src/TelltaleToolKit/Meta/Reflection/MetaClassTypeRegistry.cs similarity index 99% rename from src/TelltaleToolKit/Reflection/MetaClassTypeRegistry.cs rename to src/TelltaleToolKit/Meta/Reflection/MetaClassTypeRegistry.cs index 221ee75..86fe7a4 100644 --- a/src/TelltaleToolKit/Reflection/MetaClassTypeRegistry.cs +++ b/src/TelltaleToolKit/Meta/Reflection/MetaClassTypeRegistry.cs @@ -1,5 +1,6 @@ using System.Numerics; using System.Runtime.CompilerServices; +using TelltaleToolKit.Meta.Serialization; using TelltaleToolKit.T3Types; using TelltaleToolKit.T3Types.ActorMaps; using TelltaleToolKit.T3Types.Animations; @@ -11,6 +12,7 @@ using TelltaleToolKit.T3Types.Dialogs.Dlg; using TelltaleToolKit.T3Types.Dialogs.Dlg.Nodes; using TelltaleToolKit.T3Types.Dialogs.DlgSettings; +using TelltaleToolKit.T3Types.Dialogs.Dlog; using TelltaleToolKit.T3Types.Effects; using TelltaleToolKit.T3Types.Fonts; using TelltaleToolKit.T3Types.InputMaps; @@ -37,7 +39,7 @@ using TelltaleToolKit.T3Types.Voice; using TelltaleToolKit.T3Types.WalkBoxes; -namespace TelltaleToolKit.Reflection; +namespace TelltaleToolKit.Meta.Reflection; public static class MetaClassTypeRegistry { diff --git a/src/TelltaleToolKit/Reflection/MetaFlags.cs b/src/TelltaleToolKit/Meta/Reflection/MetaFlags.cs similarity index 98% rename from src/TelltaleToolKit/Reflection/MetaFlags.cs rename to src/TelltaleToolKit/Meta/Reflection/MetaFlags.cs index 36afd65..87bce97 100644 --- a/src/TelltaleToolKit/Reflection/MetaFlags.cs +++ b/src/TelltaleToolKit/Meta/Reflection/MetaFlags.cs @@ -1,4 +1,4 @@ -namespace TelltaleToolKit.Reflection; +namespace TelltaleToolKit.Meta.Reflection; /// /// Flags to describe metadata properties for classes/types. @@ -149,4 +149,4 @@ public enum MetaFlags /// This type is not a meta file. /// IsNotMetaFile = 0x4000000, -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/Reflection/MetaMember.cs b/src/TelltaleToolKit/Meta/Reflection/MetaMember.cs similarity index 90% rename from src/TelltaleToolKit/Reflection/MetaMember.cs rename to src/TelltaleToolKit/Meta/Reflection/MetaMember.cs index fd9c02f..f6aa338 100644 --- a/src/TelltaleToolKit/Reflection/MetaMember.cs +++ b/src/TelltaleToolKit/Meta/Reflection/MetaMember.cs @@ -1,4 +1,4 @@ -namespace TelltaleToolKit.Reflection; +namespace TelltaleToolKit.Meta.Reflection; public record MetaMember( string MemberName, @@ -7,7 +7,7 @@ public record MetaMember( { public bool IsFlagType() => Flags.HasFlag(MetaFlags.FlagType); public bool IsEnumType() => Flags.HasFlag(MetaFlags.EnumIntType) || Flags.HasFlag(MetaFlags.EnumStringType); - + /// public bool IsSerialized() => !Flags.HasFlag(MetaFlags.MetaSerializeDisable) && Type.IsSerialized(); -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/Reflection/MetaMemberAttribute.cs b/src/TelltaleToolKit/Meta/Reflection/MetaMemberAttribute.cs similarity index 82% rename from src/TelltaleToolKit/Reflection/MetaMemberAttribute.cs rename to src/TelltaleToolKit/Meta/Reflection/MetaMemberAttribute.cs index b41e95b..e17c571 100644 --- a/src/TelltaleToolKit/Reflection/MetaMemberAttribute.cs +++ b/src/TelltaleToolKit/Meta/Reflection/MetaMemberAttribute.cs @@ -1,4 +1,4 @@ -namespace TelltaleToolKit.Reflection; +namespace TelltaleToolKit.Meta.Reflection; [AttributeUsage(AttributeTargets.Property | AttributeTargets.Field)] public class MetaMemberAttribute : Attribute @@ -9,4 +9,4 @@ public MetaMemberAttribute(string name) } public string Name { get; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/Serialization/Binary/BinaryMetaStreamReader.cs b/src/TelltaleToolKit/Meta/Serialization/Binary/BinaryMetaStreamReader.cs similarity index 98% rename from src/TelltaleToolKit/Serialization/Binary/BinaryMetaStreamReader.cs rename to src/TelltaleToolKit/Meta/Serialization/Binary/BinaryMetaStreamReader.cs index 7eb8ff0..dcfa7de 100644 --- a/src/TelltaleToolKit/Serialization/Binary/BinaryMetaStreamReader.cs +++ b/src/TelltaleToolKit/Meta/Serialization/Binary/BinaryMetaStreamReader.cs @@ -1,9 +1,10 @@ using System.Text; -using TelltaleToolKit.Reflection; +using TelltaleToolKit.Hashing; +using TelltaleToolKit.IO.Streams; +using TelltaleToolKit.Meta.Reflection; using TelltaleToolKit.T3Types; -using TelltaleToolKit.Utility.Hashing; -namespace TelltaleToolKit.Serialization.Binary; +namespace TelltaleToolKit.Meta.Serialization.Binary; public sealed class BinaryMetaStreamReader : MetaStream { diff --git a/src/TelltaleToolKit/Serialization/Binary/BinaryMetaStreamWriter.cs b/src/TelltaleToolKit/Meta/Serialization/Binary/BinaryMetaStreamWriter.cs similarity index 98% rename from src/TelltaleToolKit/Serialization/Binary/BinaryMetaStreamWriter.cs rename to src/TelltaleToolKit/Meta/Serialization/Binary/BinaryMetaStreamWriter.cs index 7a71535..1f87b74 100644 --- a/src/TelltaleToolKit/Serialization/Binary/BinaryMetaStreamWriter.cs +++ b/src/TelltaleToolKit/Meta/Serialization/Binary/BinaryMetaStreamWriter.cs @@ -1,7 +1,9 @@ using System.Text; +using TelltaleToolKit.Encryption; +using TelltaleToolKit.IO.Streams; using TelltaleToolKit.T3Types; -namespace TelltaleToolKit.Serialization.Binary; +namespace TelltaleToolKit.Meta.Serialization.Binary; public sealed class BinaryMetaStreamWriter : MetaStream { diff --git a/src/TelltaleToolKit/Serialization/Binary/InvalidBooleanException.cs b/src/TelltaleToolKit/Meta/Serialization/Binary/InvalidBooleanException.cs similarity index 85% rename from src/TelltaleToolKit/Serialization/Binary/InvalidBooleanException.cs rename to src/TelltaleToolKit/Meta/Serialization/Binary/InvalidBooleanException.cs index a31544b..3bbffaf 100644 --- a/src/TelltaleToolKit/Serialization/Binary/InvalidBooleanException.cs +++ b/src/TelltaleToolKit/Meta/Serialization/Binary/InvalidBooleanException.cs @@ -1,4 +1,4 @@ -namespace TelltaleToolKit.Serialization.Binary; +namespace TelltaleToolKit.Meta.Serialization.Binary; public class InvalidBooleanException : Exception { diff --git a/src/TelltaleToolKit/Serialization/Json/JsonMetaStreamReader.cs b/src/TelltaleToolKit/Meta/Serialization/Json/JsonMetaStreamReader.cs similarity index 99% rename from src/TelltaleToolKit/Serialization/Json/JsonMetaStreamReader.cs rename to src/TelltaleToolKit/Meta/Serialization/Json/JsonMetaStreamReader.cs index 3502c84..c127941 100644 --- a/src/TelltaleToolKit/Serialization/Json/JsonMetaStreamReader.cs +++ b/src/TelltaleToolKit/Meta/Serialization/Json/JsonMetaStreamReader.cs @@ -1,7 +1,7 @@ using System.Text.Json; using TelltaleToolKit.T3Types; -namespace TelltaleToolKit.Serialization.Json; +namespace TelltaleToolKit.Meta.Serialization.Json; /// /// Reads a JSON file written by . diff --git a/src/TelltaleToolKit/Serialization/Json/JsonMetaStreamWriter.cs b/src/TelltaleToolKit/Meta/Serialization/Json/JsonMetaStreamWriter.cs similarity index 99% rename from src/TelltaleToolKit/Serialization/Json/JsonMetaStreamWriter.cs rename to src/TelltaleToolKit/Meta/Serialization/Json/JsonMetaStreamWriter.cs index 8738739..16ffcb7 100644 --- a/src/TelltaleToolKit/Serialization/Json/JsonMetaStreamWriter.cs +++ b/src/TelltaleToolKit/Meta/Serialization/Json/JsonMetaStreamWriter.cs @@ -1,7 +1,7 @@ using System.Text.Json; using TelltaleToolKit.T3Types; -namespace TelltaleToolKit.Serialization.Json; +namespace TelltaleToolKit.Meta.Serialization.Json; /// /// Writes a MetaStream as human-readable JSON, following the same two-part layout diff --git a/src/TelltaleToolKit/Serialization/Serializers/MetaMemberNotFoundException.cs b/src/TelltaleToolKit/Meta/Serialization/MetaMemberNotFoundException.cs similarity index 68% rename from src/TelltaleToolKit/Serialization/Serializers/MetaMemberNotFoundException.cs rename to src/TelltaleToolKit/Meta/Serialization/MetaMemberNotFoundException.cs index d07b516..83f4379 100644 --- a/src/TelltaleToolKit/Serialization/Serializers/MetaMemberNotFoundException.cs +++ b/src/TelltaleToolKit/Meta/Serialization/MetaMemberNotFoundException.cs @@ -1,15 +1,15 @@ -namespace TelltaleToolKit.Serialization.Serializers; +namespace TelltaleToolKit.Meta.Serialization; public class MetaMemberNotFoundException : Exception { public MetaMemberNotFoundException () {} - public MetaMemberNotFoundException (string message) + public MetaMemberNotFoundException (string message) : base(message) {} public MetaMemberNotFoundException (string message, Exception innerException) : base (message, innerException) - {} -} \ No newline at end of file + {} +} diff --git a/src/TelltaleToolKit/Serialization/MetaClassSerializer.cs b/src/TelltaleToolKit/Meta/Serialization/MetaSerializer.cs similarity index 80% rename from src/TelltaleToolKit/Serialization/MetaClassSerializer.cs rename to src/TelltaleToolKit/Meta/Serialization/MetaSerializer.cs index 03b7b6e..7344357 100644 --- a/src/TelltaleToolKit/Serialization/MetaClassSerializer.cs +++ b/src/TelltaleToolKit/Meta/Serialization/MetaSerializer.cs @@ -1,14 +1,13 @@ using System.Runtime.CompilerServices; -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization.Binary; +using TelltaleToolKit.Meta.Reflection; -namespace TelltaleToolKit.Serialization; +namespace TelltaleToolKit.Meta.Serialization; /// /// Describes how to serialize and deserialize an object without knowing its type. /// Used as a common base class for all data serializers. /// -public abstract class MetaClassSerializer +public abstract class MetaSerializer { /// /// The type of the object that can be serialized or deserialized. @@ -19,8 +18,8 @@ public abstract class MetaClassSerializer /// Initializes the specified serializer. /// /// This method should be thread-safe and OK to call multiple times. - /// The serializer. - public virtual void Initialize(MetaClassSerializerSelector classSerializerSelector) + /// The serializer. + public virtual void Initialize(MetaSerializerSelector serializerSelector) { } @@ -40,14 +39,14 @@ public virtual void Initialize(MetaClassSerializerSelector classSerializerSelect /// The object to process. /// The stream to serialize or deserialize to. /// - public abstract void PreSerialize(ref object obj, MetaStream stream, MetaClassType? type = null); + public abstract void PreSerialize(ref object? obj, MetaStream stream, MetaClassType? type = null); } /// /// Describes how to serialize and deserialize an object of a given type. /// /// The type of object to serialize or deserialize. -public abstract class MetaClassSerializer : MetaClassSerializer +public abstract class MetaSerializer : MetaSerializer { /// public override Type SerializationType => typeof(T); @@ -55,9 +54,9 @@ public abstract class MetaClassSerializer : MetaClassSerializer /// public override void Serialize(ref object obj, MetaStream stream) { - T? objT = obj == null ? default : (T)obj; + T objT = (T)obj; Serialize(ref objT, stream); - obj = objT; + obj = objT!; } /// @@ -72,7 +71,7 @@ public void Serialize(T obj, MetaStream stream) } /// - public override void PreSerialize(ref object obj, MetaStream stream, MetaClassType? type = null) + public override void PreSerialize(ref object? obj, MetaStream stream, MetaClassType? type = null) { T? objT = obj == null ? default : (T)obj; PreSerialize(ref objT, stream, type); @@ -88,7 +87,7 @@ public override void PreSerialize(ref object obj, MetaStream stream, MetaClassTy /// The object to process. /// The stream to serialize or deserialize to. /// - public virtual void PreSerialize(ref T obj, MetaStream stream, MetaClassType? type = null) + public virtual void PreSerialize(ref T? obj, MetaStream stream, MetaClassType? type = null) { } diff --git a/src/TelltaleToolKit/Serialization/MetaClassSerializerGlobalAttribute.cs b/src/TelltaleToolKit/Meta/Serialization/MetaSerializerAttribute.cs similarity index 75% rename from src/TelltaleToolKit/Serialization/MetaClassSerializerGlobalAttribute.cs rename to src/TelltaleToolKit/Meta/Serialization/MetaSerializerAttribute.cs index 4c9ebf0..d9b967b 100644 --- a/src/TelltaleToolKit/Serialization/MetaClassSerializerGlobalAttribute.cs +++ b/src/TelltaleToolKit/Meta/Serialization/MetaSerializerAttribute.cs @@ -1,4 +1,4 @@ -namespace TelltaleToolKit.Serialization; +namespace TelltaleToolKit.Meta.Serialization; // TODO: Maybe use this only for custom serializers and automatically generate serializers. // The downside is (if it's true) that there will be serializers for types that aren't needed. @@ -8,22 +8,22 @@ /// Can be applied to assemblies, classes, structs, or enums. /// /// -/// If is a generic type definition, this attribute +/// If is a generic type definition, this attribute /// can be used to register open generic serializers (e.g., for List<>). /// [AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum)] -public class MetaClassSerializerGlobalAttribute : Attribute +public class MetaSerializerAttribute : Attribute { /// - /// Initializes a new instance of the class. + /// Initializes a new instance of the class. /// /// - /// The type of the serializer (must inherit from ). + /// The type of the serializer (must inherit from ). /// /// /// The target type this serializer handles. If null, the serializer will be queried for its supported type. /// - public MetaClassSerializerGlobalAttribute(Type? serializerType, Type? serializedType = null) + public MetaSerializerAttribute(Type? serializerType, Type? serializedType = null) { SerializerType = serializerType; SerializedType = serializedType; @@ -33,9 +33,9 @@ public MetaClassSerializerGlobalAttribute(Type? serializerType, Type? serialized /// Gets the serializer type to be registered. /// public Type? SerializerType { get; } - + /// /// Gets the type that will be serialized/deserialized by the serializer. /// public Type? SerializedType { get; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/Serialization/MetaClassSerializerSelector.cs b/src/TelltaleToolKit/Meta/Serialization/MetaSerializerSelector.cs similarity index 69% rename from src/TelltaleToolKit/Serialization/MetaClassSerializerSelector.cs rename to src/TelltaleToolKit/Meta/Serialization/MetaSerializerSelector.cs index da94517..9484870 100644 --- a/src/TelltaleToolKit/Serialization/MetaClassSerializerSelector.cs +++ b/src/TelltaleToolKit/Meta/Serialization/MetaSerializerSelector.cs @@ -1,24 +1,24 @@ using System.Reflection; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Serialization.Serializers; -namespace TelltaleToolKit.Serialization; +namespace TelltaleToolKit.Meta.Serialization; /// -/// Responsible for selecting and providing the appropriate +/// Responsible for selecting and providing the appropriate /// instance for a given .NET type, including support for open generics and arrays. /// -public class MetaClassSerializerSelector +public class MetaSerializerSelector { - private readonly Dictionary _serializers = new(); + private readonly Dictionary _serializers = new(); // Open generics (List<>, Dictionary<,>, etc.) private readonly Dictionary _openGenericSerializers = new(); /// - /// Initializes a new instance of the class, + /// Initializes a new instance of the class, /// scanning loaded assemblies for serializer registrations. /// - public MetaClassSerializerSelector() + public MetaSerializerSelector() { Initialize(); } @@ -27,11 +27,11 @@ public MetaClassSerializerSelector() /// Registers a serializer instance for the specified type key. /// /// Type of the object to be (de)serialized. - /// Serializer instance for that type. - public void Register(Type? key, MetaClassSerializer classSerializer) + /// Serializer instance for that type. + public void Register(Type? key, MetaSerializer serializer) { if (key != null) - _serializers[key] = classSerializer; + _serializers[key] = serializer; } /// @@ -39,11 +39,11 @@ public void Register(Type? key, MetaClassSerializer classSerializer) /// /// The type being serialized. /// Type of the object to be (de)serialized. - /// Serializer instance for that type. - public void Register(Type? key, MetaClassSerializer classSerializer) + /// Serializer instance for that type. + public void Register(Type? key, MetaSerializer serializer) { if (key != null) - _serializers[key] = classSerializer; + _serializers[key] = serializer; } /// @@ -52,8 +52,8 @@ public void Register(Type? key, MetaClassSerializer classSerializer) /// Serializer instance. public void Register(object serializer) { - var type = (MetaClassSerializer)serializer; - _serializers[type.SerializationType] = (MetaClassSerializer)serializer; + var type = (MetaSerializer)serializer; + _serializers[type.SerializationType] = (MetaSerializer)serializer; } /// @@ -61,8 +61,8 @@ public void Register(object serializer) /// /// The type to (de)serialize. /// The serializer instance, or null if not found. - public MetaClassSerializer GetSerializer() - => GetSerializer(typeof(T)) as MetaClassSerializer; + public MetaSerializer GetSerializer() + => GetSerializer(typeof(T)) as MetaSerializer; /// @@ -70,22 +70,22 @@ public MetaClassSerializer GetSerializer() /// /// The type that you want to (de)serialize. /// - /// The for this type if it exists or can be created; otherwise, throws. + /// The for this type if it exists or can be created; otherwise, throws. /// /// Thrown when a serializer cannot be found for the provided type. - public MetaClassSerializer GetSerializer(Type type) + public MetaSerializer GetSerializer(Type type) { - if (_serializers.TryGetValue(type, out MetaClassSerializer? serializer)) + if (_serializers.TryGetValue(type, out MetaSerializer? serializer)) { return serializer; } // Handle 1D arrays - if (type.IsArray && type.GetArrayRank() == 1) + if (type.IsArray && type.GetArrayRank() == 1) { Type? elementType = type.GetElementType(); Type serializerType = typeof(ArraySerializer<>).MakeGenericType(elementType); - var arraySerializer = (MetaClassSerializer)Activator.CreateInstance(serializerType)!; + var arraySerializer = (MetaSerializer)Activator.CreateInstance(serializerType)!; arraySerializer?.Initialize(this); _serializers[type] = arraySerializer; // Cache for later return arraySerializer; @@ -101,7 +101,7 @@ public MetaClassSerializer GetSerializer(Type type) // Instantiate the open generic serializer for the type arguments Type[] args = type.GetGenericArguments(); Type closedSerializerType = serializerGenericType.MakeGenericType(args); - var closedSerializer = (MetaClassSerializer)Activator.CreateInstance(closedSerializerType)!; + var closedSerializer = (MetaSerializer)Activator.CreateInstance(closedSerializerType)!; closedSerializer?.Initialize(this); @@ -117,7 +117,7 @@ public MetaClassSerializer GetSerializer(Type type) } /// - /// Scans all loaded assemblies for types decorated with + /// Scans all loaded assemblies for types decorated with /// and registers the corresponding serializers. /// public void Initialize() @@ -126,7 +126,7 @@ public void Initialize() { foreach (Type type in assembly.GetTypes()) { - var globalAttr = type.GetCustomAttribute(); + var globalAttr = type.GetCustomAttribute(); if (globalAttr == null) continue; @@ -141,17 +141,17 @@ public void Initialize() else if (serializedType != null) { // Register a closed serializer instance - var serializer = (MetaClassSerializer)Activator.CreateInstance(serializerType); + var serializer = (MetaSerializer)Activator.CreateInstance(serializerType); serializer?.Initialize(this); _serializers[serializedType] = serializer; } else { - var serializer = (MetaClassSerializer)Activator.CreateInstance(serializerType); + var serializer = (MetaSerializer)Activator.CreateInstance(serializerType); serializer?.Initialize(this); _serializers[serializer.SerializationType] = serializer; } } } } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/Serialization/MetaStream.cs b/src/TelltaleToolKit/Meta/Serialization/MetaStream.cs similarity index 98% rename from src/TelltaleToolKit/Serialization/MetaStream.cs rename to src/TelltaleToolKit/Meta/Serialization/MetaStream.cs index 6cb7110..502cd2c 100644 --- a/src/TelltaleToolKit/Serialization/MetaStream.cs +++ b/src/TelltaleToolKit/Meta/Serialization/MetaStream.cs @@ -1,10 +1,10 @@ using System.Text; -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization.Binary; -using TelltaleToolKit.Serialization.Json; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization.Binary; +using TelltaleToolKit.Meta.Serialization.Json; using TelltaleToolKit.T3Types; -namespace TelltaleToolKit.Serialization; +namespace TelltaleToolKit.Meta.Serialization; /// /// Stream wrapper used for serializing telltale assets. diff --git a/src/TelltaleToolKit/Serialization/MetaStreamExtensions.cs b/src/TelltaleToolKit/Meta/Serialization/MetaStreamExtensions.cs similarity index 99% rename from src/TelltaleToolKit/Serialization/MetaStreamExtensions.cs rename to src/TelltaleToolKit/Meta/Serialization/MetaStreamExtensions.cs index 0a6b588..f7f116a 100644 --- a/src/TelltaleToolKit/Serialization/MetaStreamExtensions.cs +++ b/src/TelltaleToolKit/Meta/Serialization/MetaStreamExtensions.cs @@ -1,8 +1,8 @@ using System.Runtime.CompilerServices; -using TelltaleToolKit.Reflection; +using TelltaleToolKit.Meta.Reflection; using TelltaleToolKit.T3Types; -namespace TelltaleToolKit.Serialization; +namespace TelltaleToolKit.Meta.Serialization; public static class MetaStreamExtensions { diff --git a/src/TelltaleToolKit/Serialization/MetaStreamMagic.cs b/src/TelltaleToolKit/Meta/Serialization/MetaStreamMagic.cs similarity index 99% rename from src/TelltaleToolKit/Serialization/MetaStreamMagic.cs rename to src/TelltaleToolKit/Meta/Serialization/MetaStreamMagic.cs index 1c0fea9..c6683a4 100644 --- a/src/TelltaleToolKit/Serialization/MetaStreamMagic.cs +++ b/src/TelltaleToolKit/Meta/Serialization/MetaStreamMagic.cs @@ -1,4 +1,4 @@ -namespace TelltaleToolKit.Serialization; +namespace TelltaleToolKit.Meta.Serialization; /// /// Four‑character codes (magic numbers) that identify the format and encryption state diff --git a/src/TelltaleToolKit/Serialization/MetaStreamMagicExtensions.cs b/src/TelltaleToolKit/Meta/Serialization/MetaStreamMagicExtensions.cs similarity index 96% rename from src/TelltaleToolKit/Serialization/MetaStreamMagicExtensions.cs rename to src/TelltaleToolKit/Meta/Serialization/MetaStreamMagicExtensions.cs index 9826c25..b9a0458 100644 --- a/src/TelltaleToolKit/Serialization/MetaStreamMagicExtensions.cs +++ b/src/TelltaleToolKit/Meta/Serialization/MetaStreamMagicExtensions.cs @@ -1,4 +1,4 @@ -namespace TelltaleToolKit.Serialization; +namespace TelltaleToolKit.Meta.Serialization; public static class MetaStreamMagicExtensions { diff --git a/src/TelltaleToolKit/Serialization/MetaStreamMode.cs b/src/TelltaleToolKit/Meta/Serialization/MetaStreamMode.cs similarity index 87% rename from src/TelltaleToolKit/Serialization/MetaStreamMode.cs rename to src/TelltaleToolKit/Meta/Serialization/MetaStreamMode.cs index b780672..eb89b02 100644 --- a/src/TelltaleToolKit/Serialization/MetaStreamMode.cs +++ b/src/TelltaleToolKit/Meta/Serialization/MetaStreamMode.cs @@ -1,4 +1,4 @@ -namespace TelltaleToolKit.Serialization; +namespace TelltaleToolKit.Meta.Serialization; /// /// Enumerates the different mode of serialization (either serialization or deserialization). diff --git a/src/TelltaleToolKit/Serialization/MetaStreamParams.cs b/src/TelltaleToolKit/Meta/Serialization/MetaStreamParams.cs similarity index 98% rename from src/TelltaleToolKit/Serialization/MetaStreamParams.cs rename to src/TelltaleToolKit/Meta/Serialization/MetaStreamParams.cs index 2e8be5d..f9d2ba8 100644 --- a/src/TelltaleToolKit/Serialization/MetaStreamParams.cs +++ b/src/TelltaleToolKit/Meta/Serialization/MetaStreamParams.cs @@ -1,7 +1,7 @@ -using TelltaleToolKit.Reflection; +using TelltaleToolKit.Meta.Reflection; using TelltaleToolKit.T3Types; -namespace TelltaleToolKit.Serialization; +namespace TelltaleToolKit.Meta.Serialization; /// /// Holds parameters and metadata for a MetaStream during serialization or deserialization. diff --git a/src/TelltaleToolKit/T3Types/MetaVersionInfo.cs b/src/TelltaleToolKit/Meta/Serialization/MetaVersionInfo.cs similarity index 74% rename from src/TelltaleToolKit/T3Types/MetaVersionInfo.cs rename to src/TelltaleToolKit/Meta/Serialization/MetaVersionInfo.cs index a334a1c..5f30456 100644 --- a/src/TelltaleToolKit/T3Types/MetaVersionInfo.cs +++ b/src/TelltaleToolKit/Meta/Serialization/MetaVersionInfo.cs @@ -1,13 +1,12 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization.Serializers; -namespace TelltaleToolKit.T3Types; +namespace TelltaleToolKit.Meta.Serialization; /// /// Represents a single version info entry. /// -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class MetaVersionInfo { [MetaMember("mTypeSymbolCrc")] diff --git a/src/TelltaleToolKit/Serialization/Serializers/ByteArraySerializer.cs b/src/TelltaleToolKit/Meta/Serialization/Serializers/ByteArraySerializer.cs similarity index 59% rename from src/TelltaleToolKit/Serialization/Serializers/ByteArraySerializer.cs rename to src/TelltaleToolKit/Meta/Serialization/Serializers/ByteArraySerializer.cs index 695ad89..3cdc778 100644 --- a/src/TelltaleToolKit/Serialization/Serializers/ByteArraySerializer.cs +++ b/src/TelltaleToolKit/Meta/Serialization/Serializers/ByteArraySerializer.cs @@ -1,9 +1,7 @@ -using TelltaleToolKit.Serialization.Binary; +namespace TelltaleToolKit.Meta.Serialization.Serializers; -namespace TelltaleToolKit.Serialization.Serializers; - -[MetaClassSerializerGlobal(typeof(ByteArraySerializer))] -public class ByteArraySerializer : MetaClassSerializer +[MetaSerializer(typeof(ByteArraySerializer))] +public class ByteArraySerializer : MetaSerializer { public override void Serialize(ref byte[] obj, MetaStream stream) { diff --git a/src/TelltaleToolKit/Meta/Serialization/Serializers/CollectionSerializers.cs b/src/TelltaleToolKit/Meta/Serialization/Serializers/CollectionSerializers.cs new file mode 100644 index 0000000..9c16fb4 --- /dev/null +++ b/src/TelltaleToolKit/Meta/Serialization/Serializers/CollectionSerializers.cs @@ -0,0 +1,180 @@ +using TelltaleToolKit.Meta.Reflection; + +namespace TelltaleToolKit.Meta.Serialization.Serializers; + +// Collection serializers are lazily initialized during runtime. +[MetaSerializer(typeof(ListSerializer<>), typeof(List<>))] +public sealed class ListSerializer : MetaSerializer> +{ + private MetaSerializer _itemDataSerializer = null!; + + public override void Initialize(MetaSerializerSelector selector) + { + _itemDataSerializer = selector.GetSerializer(); + } + + /// + public override void PreSerialize(ref List? obj, MetaStream stream, MetaClassType? type = null) + { + if (stream.Mode is MetaStreamMode.Read) + { + if (obj is null) + obj = []; + else + obj.Clear(); + } + } + + /// + public override void Serialize(ref List obj, MetaStream stream) + { + if (stream.Mode is MetaStreamMode.Write) + { + stream.Write(obj.Count); + + foreach (T entry in obj) + { + _itemDataSerializer.Serialize(entry, stream); + } + } + else if (stream.Mode is MetaStreamMode.Read) + { + int count = stream.ReadInt32(); + obj.Capacity = count; + + for (var i = 0; i < count; i++) + { + var value = default(T); + _itemDataSerializer.PreSerialize(ref value, stream); + _itemDataSerializer.Serialize(ref value, stream); + + obj.Add(value); + } + } + } +} + +[MetaSerializer(typeof(HashSetSerializer<>), typeof(HashSet<>))] +public sealed class HashSetSerializer : MetaSerializer> +{ + private MetaSerializer _itemDataSerializer = null!; + + public override void Initialize(MetaSerializerSelector selector) + { + _itemDataSerializer = selector.GetSerializer(); + } + + /// + public override void PreSerialize(ref HashSet? obj, MetaStream stream, MetaClassType? type = null) + { + if (stream.Mode is MetaStreamMode.Read) + { + if (obj is null) + obj = []; + else + obj.Clear(); + } + } + + /// + public override void Serialize(ref HashSet obj, MetaStream stream) + { + if (stream.Mode is MetaStreamMode.Write) + { + stream.Write(obj.Count); + + foreach (T entry in obj) + { + _itemDataSerializer.Serialize(entry, stream); + } + } + else if (stream.Mode is MetaStreamMode.Read) + { + int count = stream.ReadInt32(); + + for (var i = 0; i < count; i++) + { + var value = default(T); + _itemDataSerializer.PreSerialize(ref value, stream); + _itemDataSerializer.Serialize(ref value, stream); + + obj.Add(value); + } + } + } +} + +[MetaSerializer(typeof(DictionarySerializer<,>), typeof(Dictionary<,>))] +public sealed class DictionarySerializer : MetaSerializer> + where TKey : notnull +{ + private MetaSerializer _keySerializer = null!; + private MetaSerializer _valueSerializer = null!; + + /// + public override void PreSerialize(ref Dictionary? obj, MetaStream stream, MetaClassType? type = null) + { + if (stream.Mode is MetaStreamMode.Read) + { + if (obj is null) + obj = new Dictionary(); + else + obj.Clear(); + } + } + + public override void Initialize(MetaSerializerSelector selector) + { + _keySerializer = selector.GetSerializer(); + _valueSerializer = selector.GetSerializer(); + } + + /// + public override void Serialize(ref Dictionary obj, MetaStream stream) + { + if (stream.Mode is MetaStreamMode.Write) + { + stream.Write(obj.Count); + + foreach (KeyValuePair item in obj) + { + _keySerializer.Serialize(item.Key, stream); + _valueSerializer.Serialize(item.Value, stream); + } + } + else if (stream.Mode is MetaStreamMode.Read) + { + int count = stream.ReadInt32(); + + for (var i = 0; i < count; i++) + { + var key = default(TKey); + var value = default(TValue); + _keySerializer.PreSerialize(ref key, stream); + _keySerializer.Serialize(ref key, stream); + _valueSerializer.PreSerialize(ref value, stream); + _valueSerializer.Serialize(ref value, stream); + obj.Add(key!, value!); + } + } + } +} + +public sealed class ArraySerializer : MetaSerializer +{ + private MetaSerializer _itemDataSerializer = null!; + + public override void Initialize(MetaSerializerSelector selector) + { + _itemDataSerializer = selector.GetSerializer(); + } + + public override void Serialize(ref T[] obj, MetaStream stream) + { + for (var i = 0; i < obj.Length; ++i) + { + _itemDataSerializer.PreSerialize(ref obj[i], stream); + _itemDataSerializer.Serialize(ref obj[i], stream); + } + } +} diff --git a/src/TelltaleToolKit/Serialization/Serializers/MathTypeSerializer.cs b/src/TelltaleToolKit/Meta/Serialization/Serializers/MathTypeSerializer.cs similarity index 82% rename from src/TelltaleToolKit/Serialization/Serializers/MathTypeSerializer.cs rename to src/TelltaleToolKit/Meta/Serialization/Serializers/MathTypeSerializer.cs index 41b5b68..055229e 100644 --- a/src/TelltaleToolKit/Serialization/Serializers/MathTypeSerializer.cs +++ b/src/TelltaleToolKit/Meta/Serialization/Serializers/MathTypeSerializer.cs @@ -1,11 +1,10 @@ using System.Numerics; -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization.Binary; +using TelltaleToolKit.Meta.Reflection; -namespace TelltaleToolKit.Serialization.Serializers; +namespace TelltaleToolKit.Meta.Serialization.Serializers; -[MetaClassSerializerGlobal(typeof(Vector2Serializer))] -public class Vector2Serializer : MetaClassSerializer +[MetaSerializer(typeof(Vector2Serializer))] +public class Vector2Serializer : MetaSerializer { public override void Serialize(ref Vector2 obj, MetaStream stream) { @@ -28,8 +27,8 @@ public override void Serialize(ref Vector2 obj, MetaStream stream) } } -[MetaClassSerializerGlobal(typeof(Vector3Serializer))] -public class Vector3Serializer : MetaClassSerializer +[MetaSerializer(typeof(Vector3Serializer))] +public class Vector3Serializer : MetaSerializer { public override void Serialize(ref Vector3 obj, MetaStream stream) { @@ -54,8 +53,8 @@ public override void Serialize(ref Vector3 obj, MetaStream stream) } } -[MetaClassSerializerGlobal(typeof(Vector4Serializer))] -public class Vector4Serializer : MetaClassSerializer +[MetaSerializer(typeof(Vector4Serializer))] +public class Vector4Serializer : MetaSerializer { public override void Serialize(ref Vector4 obj, MetaStream stream) { @@ -82,8 +81,8 @@ public override void Serialize(ref Vector4 obj, MetaStream stream) } } -[MetaClassSerializerGlobal(typeof(QuaternionSerializer))] -public class QuaternionSerializer : MetaClassSerializer +[MetaSerializer(typeof(QuaternionSerializer))] +public class QuaternionSerializer : MetaSerializer { public override void Serialize(ref Quaternion obj, MetaStream stream) { diff --git a/src/TelltaleToolKit/Serialization/Serializers/DefaultClassSerializer.cs b/src/TelltaleToolKit/Meta/Serialization/Serializers/MetaClassSerializer.cs similarity index 92% rename from src/TelltaleToolKit/Serialization/Serializers/DefaultClassSerializer.cs rename to src/TelltaleToolKit/Meta/Serialization/Serializers/MetaClassSerializer.cs index 8257820..547d001 100644 --- a/src/TelltaleToolKit/Serialization/Serializers/DefaultClassSerializer.cs +++ b/src/TelltaleToolKit/Meta/Serialization/Serializers/MetaClassSerializer.cs @@ -1,13 +1,11 @@ using System.Reflection; -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization.Binary; +using TelltaleToolKit.Meta.Reflection; using TelltaleToolKit.T3Types; -using TransitionMap = TelltaleToolKit.T3Types.TransitionMap; -namespace TelltaleToolKit.Serialization.Serializers; +namespace TelltaleToolKit.Meta.Serialization.Serializers; /// -/// Provides a default implementation of for class serialization, +/// Provides a default implementation of for class serialization, /// using reflection and attribute caching to efficiently map class properties to meta members. /// /// This serializer builds a cache of properties with , linking them to their @@ -18,12 +16,12 @@ namespace TelltaleToolKit.Serialization.Serializers; /// /// /// The type of the class being serialized. -public class DefaultClassSerializer : MetaClassSerializer where T : new() +public class MetaClassSerializer : MetaSerializer where T : new() { private static readonly Dictionary<(string, Type), CachedMember> MemberCache; // Initialize the mapping dictionary. - static DefaultClassSerializer() + static MetaClassSerializer() { MemberCache = typeof(T).GetProperties() .Select(p => new { Property = p, Attribute = p.GetCustomAttribute() }) @@ -70,7 +68,6 @@ public override void Serialize(ref T obj, MetaStream stream) if (propDesc.Type.IsBlocked()) stream.BeginBlock(); - stream.Key(propDesc.MemberName); if (propDesc.Type.LinkingType.IsPrimitive || (propDesc.Type.LinkingType == typeof(string) || @@ -86,7 +83,7 @@ public override void Serialize(ref T obj, MetaStream stream) object? value = cached?.Getter(ref obj); - MetaClassSerializer serializer = + MetaSerializer serializer = Toolkit.Instance.GetSerializer(cached?.Property.PropertyType ?? propDesc.Type.LinkingType); serializer.PreSerialize(ref value, stream, propDesc.Type); serializer.Serialize(ref value, stream); @@ -115,7 +112,7 @@ public override void Serialize(ref T obj, MetaStream stream) Toolkit.Instance.Logger.LogInfo($"Ending {typeof(T).Name}."); } - public override void PreSerialize(ref T obj, MetaStream stream, MetaClassType? type = null) + public override void PreSerialize(ref T? obj, MetaStream stream, MetaClassType? type = null) { if (stream.Mode is MetaStreamMode.Read && obj == null) { diff --git a/src/TelltaleToolKit/Serialization/Serializers/PrimitiveTypeSerializer.cs b/src/TelltaleToolKit/Meta/Serialization/Serializers/PrimitiveTypeSerializer.cs similarity index 53% rename from src/TelltaleToolKit/Serialization/Serializers/PrimitiveTypeSerializer.cs rename to src/TelltaleToolKit/Meta/Serialization/Serializers/PrimitiveTypeSerializer.cs index c11b08c..d98d296 100644 --- a/src/TelltaleToolKit/Serialization/Serializers/PrimitiveTypeSerializer.cs +++ b/src/TelltaleToolKit/Meta/Serialization/Serializers/PrimitiveTypeSerializer.cs @@ -1,10 +1,9 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization.Binary; +using TelltaleToolKit.Meta.Reflection; -namespace TelltaleToolKit.Serialization.Serializers; +namespace TelltaleToolKit.Meta.Serialization.Serializers; -[MetaClassSerializerGlobal(typeof(BoolSerializer))] -public sealed class BoolSerializer : MetaClassSerializer +[MetaSerializer(typeof(BoolSerializer))] +public sealed class BoolSerializer : MetaSerializer { /// public override void Serialize(ref bool obj, MetaStream stream) @@ -13,8 +12,8 @@ public override void Serialize(ref bool obj, MetaStream stream) } } -[MetaClassSerializerGlobal(typeof(SByteSerializer))] -public sealed class SByteSerializer : MetaClassSerializer +[MetaSerializer(typeof(SByteSerializer))] +public sealed class SByteSerializer : MetaSerializer { /// public override void Serialize(ref sbyte obj, MetaStream stream) @@ -23,8 +22,8 @@ public override void Serialize(ref sbyte obj, MetaStream stream) } } -[MetaClassSerializerGlobal(typeof(ByteSerializer))] -public sealed class ByteSerializer : MetaClassSerializer +[MetaSerializer(typeof(ByteSerializer))] +public sealed class ByteSerializer : MetaSerializer { /// public override void Serialize(ref byte obj, MetaStream stream) @@ -33,8 +32,8 @@ public override void Serialize(ref byte obj, MetaStream stream) } } -[MetaClassSerializerGlobal(typeof(Int16ClassSerializer))] -public sealed class Int16ClassSerializer : MetaClassSerializer +[MetaSerializer(typeof(Int16Serializer))] +public sealed class Int16Serializer : MetaSerializer { /// public override void Serialize(ref short obj, MetaStream stream) @@ -43,8 +42,8 @@ public override void Serialize(ref short obj, MetaStream stream) } } -[MetaClassSerializerGlobal(typeof(UInt16ClassSerializer))] -public sealed class UInt16ClassSerializer : MetaClassSerializer +[MetaSerializer(typeof(UInt16Serializer))] +public sealed class UInt16Serializer : MetaSerializer { /// public override void Serialize(ref ushort obj, MetaStream stream) @@ -53,8 +52,8 @@ public override void Serialize(ref ushort obj, MetaStream stream) } } -[MetaClassSerializerGlobal(typeof(Int32ClassSerializer))] -public sealed class Int32ClassSerializer : MetaClassSerializer +[MetaSerializer(typeof(Int32Serializer))] +public sealed class Int32Serializer : MetaSerializer { /// public override void Serialize(ref int obj, MetaStream stream) @@ -63,8 +62,8 @@ public override void Serialize(ref int obj, MetaStream stream) } } -[MetaClassSerializerGlobal(typeof(UInt32ClassSerializer))] -public sealed class UInt32ClassSerializer : MetaClassSerializer +[MetaSerializer(typeof(UInt32Serializer))] +public sealed class UInt32Serializer : MetaSerializer { /// public override void Serialize(ref uint obj, MetaStream stream) @@ -73,8 +72,8 @@ public override void Serialize(ref uint obj, MetaStream stream) } } -[MetaClassSerializerGlobal(typeof(Int64ClassSerializer))] -public sealed class Int64ClassSerializer : MetaClassSerializer +[MetaSerializer(typeof(Int64Serializer))] +public sealed class Int64Serializer : MetaSerializer { /// public override void Serialize(ref long obj, MetaStream stream) @@ -83,8 +82,8 @@ public override void Serialize(ref long obj, MetaStream stream) } } -[MetaClassSerializerGlobal(typeof(UInt64ClassSerializer))] -public sealed class UInt64ClassSerializer : MetaClassSerializer +[MetaSerializer(typeof(UInt64Serializer))] +public sealed class UInt64Serializer : MetaSerializer { /// public override void Serialize(ref ulong obj, MetaStream stream) @@ -93,8 +92,8 @@ public override void Serialize(ref ulong obj, MetaStream stream) } } -[MetaClassSerializerGlobal(typeof(SingleClassSerializer))] -public sealed class SingleClassSerializer : MetaClassSerializer +[MetaSerializer(typeof(SingleSerializer))] +public sealed class SingleSerializer : MetaSerializer { /// public override void Serialize(ref float obj, MetaStream stream) @@ -103,8 +102,8 @@ public override void Serialize(ref float obj, MetaStream stream) } } -[MetaClassSerializerGlobal(typeof(DoubleClassSerializer))] -public sealed class DoubleClassSerializer : MetaClassSerializer +[MetaSerializer(typeof(DoubleSerializer))] +public sealed class DoubleSerializer : MetaSerializer { /// public override void Serialize(ref double obj, MetaStream stream) @@ -113,8 +112,8 @@ public override void Serialize(ref double obj, MetaStream stream) } } -[MetaClassSerializerGlobal(typeof(StringClassSerializer))] -public sealed class StringClassSerializer : MetaClassSerializer +[MetaSerializer(typeof(StringSerializer))] +public sealed class StringSerializer : MetaSerializer { /// public override void Serialize(ref string obj, MetaStream stream) @@ -123,12 +122,12 @@ public override void Serialize(ref string obj, MetaStream stream) } /// - public override void PreSerialize(ref string obj, MetaStream stream, MetaClassType? type) + public override void PreSerialize(ref string? obj, MetaStream stream, MetaClassType? type) { } } -public sealed class EnumSerializer : MetaClassSerializer where TEnum : Enum +public sealed class EnumSerializer : MetaSerializer where TEnum : Enum { /// public override void Serialize(ref TEnum obj, MetaStream stream) diff --git a/src/TelltaleToolKit/Serialization/Serializers/SymbolSerializer.cs b/src/TelltaleToolKit/Meta/Serialization/Serializers/SymbolSerializer.cs similarity index 63% rename from src/TelltaleToolKit/Serialization/Serializers/SymbolSerializer.cs rename to src/TelltaleToolKit/Meta/Serialization/Serializers/SymbolSerializer.cs index 1cc34e9..620156d 100644 --- a/src/TelltaleToolKit/Serialization/Serializers/SymbolSerializer.cs +++ b/src/TelltaleToolKit/Meta/Serialization/Serializers/SymbolSerializer.cs @@ -1,12 +1,12 @@ -using TelltaleToolKit.Reflection; +using TelltaleToolKit.Meta.Reflection; using TelltaleToolKit.T3Types; -namespace TelltaleToolKit.Serialization.Serializers; +namespace TelltaleToolKit.Meta.Serialization.Serializers; -[MetaClassSerializerGlobal(typeof(SymbolSerializer))] -public class SymbolSerializer : MetaClassSerializer +[MetaSerializer(typeof(SymbolSerializer))] +public class SymbolSerializer : MetaSerializer { - public override void PreSerialize(ref Symbol obj, MetaStream stream, MetaClassType? type = null) + public override void PreSerialize(ref Symbol? obj, MetaStream stream, MetaClassType? type = null) { obj ??= Symbol.Empty; } diff --git a/src/TelltaleToolKit/Reflection/MetaClass.cs b/src/TelltaleToolKit/Reflection/MetaClass.cs deleted file mode 100644 index b92ea3a..0000000 --- a/src/TelltaleToolKit/Reflection/MetaClass.cs +++ /dev/null @@ -1,34 +0,0 @@ -namespace TelltaleToolKit.Reflection; -// TODO: Maybe Add enum descriptors. Currently we assume that the enums are fixed. It may not be worth it for the extra memory usage. - -/// -/// Represents a description of a metaclass. -/// This includes type information, versioning, and a list of properties (members). -/// -public sealed class MetaClass -{ - /// - /// Class information, including the name, original type name, and the linking type. - /// - public MetaClassType ClassType { get; init; } = null!; - - /// - /// The CRC32 version number, which is calculated per game. - /// Used to identify the version of the class. - /// - public uint Crc32 { get; set; } - - /// - /// The members (properties) of this class. - /// This is a list of MetaMember objects, each describing a property. - /// - public List Members { get; set; } = []; - - /// - /// Checks whether a member with the specified name exists in the class properties. - /// - /// The member name to check for. - /// True if the member exists; otherwise, false. - public bool ContainsMember(string name) - => Members.Any(member => member.MemberName.Equals(name)); -} \ No newline at end of file diff --git a/src/TelltaleToolKit/Serialization/Serializers/CollectionSerializers.cs b/src/TelltaleToolKit/Serialization/Serializers/CollectionSerializers.cs deleted file mode 100644 index 6b44b93..0000000 --- a/src/TelltaleToolKit/Serialization/Serializers/CollectionSerializers.cs +++ /dev/null @@ -1,183 +0,0 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization.Binary; - -namespace TelltaleToolKit.Serialization.Serializers; - -// Collection serializers are lazily initialized during runtime. -[MetaClassSerializerGlobal(typeof(ListSerializer<>), typeof(List<>))] -public sealed class ListSerializer : MetaClassSerializer> -{ - private MetaClassSerializer _itemDataClassSerializer = null!; - - public override void Initialize(MetaClassSerializerSelector selector) - { - _itemDataClassSerializer = selector.GetSerializer(); - } - - /// - public override void PreSerialize(ref List obj, MetaStream stream, MetaClassType? type = null) - { - if (stream.Mode is MetaStreamMode.Read) - { - if (obj is null) - obj = []; - else - obj.Clear(); - } - } - - /// - public override void Serialize(ref List obj, MetaStream stream) - { - if (stream.Mode is MetaStreamMode.Write) - { - stream.Write(obj.Count); - - foreach (T entry in obj) - { - _itemDataClassSerializer.Serialize(entry, stream); - } - } - else if (stream.Mode is MetaStreamMode.Read) - { - int count = stream.ReadInt32(); - obj.Capacity = count; - - for (var i = 0; i < count; i++) - { - var value = default(T); - _itemDataClassSerializer.PreSerialize(ref value, stream); - _itemDataClassSerializer.Serialize(ref value, stream); - - obj.Add(value); - } - } - } -} - -[MetaClassSerializerGlobal(typeof(HashSetSerializer<>), typeof(HashSet<>))] -public sealed class HashSetSerializer : MetaClassSerializer> -{ - private MetaClassSerializer _itemDataClassSerializer = null!; - - public override void Initialize(MetaClassSerializerSelector selector) - { - _itemDataClassSerializer = selector.GetSerializer(); - } - - /// - public override void PreSerialize(ref HashSet obj, MetaStream stream, MetaClassType? type = null) - { - if (stream.Mode is MetaStreamMode.Read) - { - if (obj is null) - obj = []; - else - obj.Clear(); - } - } - - /// - public override void Serialize(ref HashSet obj, MetaStream stream) - { - if (stream.Mode is MetaStreamMode.Write) - { - stream.Write(obj.Count); - - foreach (T entry in obj) - { - _itemDataClassSerializer.Serialize(entry, stream); - } - } - else if (stream.Mode is MetaStreamMode.Read) - { - int count = stream.ReadInt32(); - - for (var i = 0; i < count; i++) - { - var value = default(T); - _itemDataClassSerializer.PreSerialize(ref value, stream); - _itemDataClassSerializer.Serialize(ref value, stream); - - obj.Add(value); - } - } - } -} - -[MetaClassSerializerGlobal(typeof(DictionarySerializer<,>), typeof(Dictionary<,>))] -public sealed class DictionarySerializer : MetaClassSerializer> - where TKey : notnull -{ - private MetaClassSerializer _keyClassSerializer = null!; - private MetaClassSerializer _valueClassSerializer = null!; - - /// - public override void PreSerialize(ref Dictionary obj, MetaStream stream, MetaClassType? type = null) - { - if (stream.Mode is MetaStreamMode.Read) - { - if (obj is null) - obj = new Dictionary(); - else - obj.Clear(); - } - } - - public override void Initialize(MetaClassSerializerSelector selector) - { - _keyClassSerializer = selector.GetSerializer(); - _valueClassSerializer = selector.GetSerializer(); - } - - /// - public override void Serialize(ref Dictionary obj, MetaStream stream) - { - PreSerialize(ref obj, stream); - - if (stream.Mode is MetaStreamMode.Write) - { - stream.Write(obj.Count); - - foreach (KeyValuePair item in obj) - { - _keyClassSerializer.Serialize(item.Key, stream); - _valueClassSerializer.Serialize(item.Value, stream); - } - } - else if (stream.Mode is MetaStreamMode.Read) - { - int count = stream.ReadInt32(); - - for (var i = 0; i < count; i++) - { - var key = default(TKey); - var value = default(TValue); - _keyClassSerializer.PreSerialize(ref key, stream); - _keyClassSerializer.Serialize(ref key, stream); - _valueClassSerializer.PreSerialize(ref value, stream); - _valueClassSerializer.Serialize(ref value, stream); - obj.Add(key, value); - } - } - } -} - -public sealed class ArraySerializer : MetaClassSerializer -{ - private MetaClassSerializer _itemDataClassSerializer = null!; - - public override void Initialize(MetaClassSerializerSelector selector) - { - _itemDataClassSerializer = selector.GetSerializer(); - } - - public override void Serialize(ref T[] obj, MetaStream stream) - { - for (var i = 0; i < obj.Length; ++i) - { - _itemDataClassSerializer.PreSerialize(ref obj[i], stream); - _itemDataClassSerializer.Serialize(ref obj[i], stream); - } - } -} diff --git a/src/TelltaleToolKit/T3Types/ActorMaps/ActorAgentMapper.cs b/src/TelltaleToolKit/T3Types/ActorMaps/ActorAgentMapper.cs index 23a9b33..7092a76 100644 --- a/src/TelltaleToolKit/T3Types/ActorMaps/ActorAgentMapper.cs +++ b/src/TelltaleToolKit/T3Types/ActorMaps/ActorAgentMapper.cs @@ -1,6 +1,6 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Properties; namespace TelltaleToolKit.T3Types.ActorMaps; @@ -8,7 +8,7 @@ namespace TelltaleToolKit.T3Types.ActorMaps; /// /// Represents the main class for .aam files. /// -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class ActorAgentMapper { [MetaMember("mActorAgentMap")] @@ -16,4 +16,4 @@ public class ActorAgentMapper [MetaMember("mActionActors")] public HashSet ActionActors { get; set; } = []; -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/ActorMaps/AgentMap.cs b/src/TelltaleToolKit/T3Types/ActorMaps/AgentMap.cs index fa05003..c7315af 100644 --- a/src/TelltaleToolKit/T3Types/ActorMaps/AgentMap.cs +++ b/src/TelltaleToolKit/T3Types/ActorMaps/AgentMap.cs @@ -1,19 +1,19 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.ActorMaps; /// /// Represents the class for .amap files. /// -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class AgentMap { [MetaMember("maAgents")] public Dictionary Agents { get; set; } = new(); - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public class AgentMapEntry { [MetaMember("mzName")] @@ -31,4 +31,4 @@ public class AgentMapEntry [MetaMember("mazStyleIdles")] public HashSet StyleIdles { get; set; } = []; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/AnimOrChore.cs b/src/TelltaleToolKit/T3Types/AnimOrChore.cs index 4f7926f..8d5ff75 100644 --- a/src/TelltaleToolKit/T3Types/AnimOrChore.cs +++ b/src/TelltaleToolKit/T3Types/AnimOrChore.cs @@ -1,12 +1,12 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Animations; using TelltaleToolKit.T3Types.Chores; namespace TelltaleToolKit.T3Types; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class AnimOrChore { [MetaMember("mhAnim")] @@ -14,4 +14,4 @@ public class AnimOrChore [MetaMember("mhChore")] public Handle Chore { get; set; } = new(); -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Animations/AnimatedValueInterface.cs b/src/TelltaleToolKit/T3Types/Animations/AnimatedValueInterface.cs index 8b35d1c..a53895e 100644 --- a/src/TelltaleToolKit/T3Types/Animations/AnimatedValueInterface.cs +++ b/src/TelltaleToolKit/T3Types/Animations/AnimatedValueInterface.cs @@ -1,25 +1,24 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Binary; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Animations; // TODO: Add interface -[MetaClassSerializerGlobal(typeof(AnimatedValueInterface<>.Serializer), typeof(AnimatedValueInterface<>))] +[MetaSerializer(typeof(AnimatedValueInterface<>.Serializer), typeof(AnimatedValueInterface<>))] public class AnimatedValueInterface : IAnimatedValueInterface { [MetaMember("Baseclass_AnimationValueInterfaceBase")] public AnimationValueInterfaceBase AnimationValueInterfaceBase { get; set; } = new(); - public class Serializer : MetaClassSerializer> + public class Serializer : MetaSerializer> { - private static readonly DefaultClassSerializer> DefaultSerializer = new(); + private static readonly MetaClassSerializer> s_metaClassSerializer = new(); public override void Serialize(ref AnimatedValueInterface obj, MetaStream stream) { - DefaultSerializer.PreSerialize(ref obj, stream); - DefaultSerializer.Serialize(ref obj, stream); + s_metaClassSerializer.PreSerialize(ref obj, stream); + s_metaClassSerializer.Serialize(ref obj, stream); } } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Animations/Animation.cs b/src/TelltaleToolKit/T3Types/Animations/Animation.cs index 2e73014..63d6440 100644 --- a/src/TelltaleToolKit/T3Types/Animations/Animation.cs +++ b/src/TelltaleToolKit/T3Types/Animations/Animation.cs @@ -1,13 +1,12 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Binary; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Properties; namespace TelltaleToolKit.T3Types.Animations; // TODO: Add Interface -[MetaClassSerializerGlobal(typeof(Serializer))] +[MetaSerializer(typeof(Serializer))] public class Animation { [MetaMember("mVersion")] @@ -43,14 +42,14 @@ public class InterfaceInfo public byte[] Buffer = []; - public class Serializer : MetaClassSerializer + public class Serializer : MetaSerializer { - private static readonly DefaultClassSerializer DefaultSerializer = new(); + private static readonly MetaClassSerializer s_metaClassSerializer = new(); public override void Serialize(ref Animation obj, MetaStream stream) { - DefaultSerializer.PreSerialize(ref obj, stream); - DefaultSerializer.Serialize(ref obj, stream); + s_metaClassSerializer.PreSerialize(ref obj, stream); + s_metaClassSerializer.Serialize(ref obj, stream); stream.BeginBlock(); @@ -100,7 +99,7 @@ public override void Serialize(ref Animation obj, MetaStream stream) foreach (InterfaceInfo desc in obj.Descriptors) { - MetaClassSerializer serializer = Toolkit.Instance.GetSerializer(desc.Type.LinkingType); + MetaSerializer serializer = Toolkit.Instance.GetSerializer(desc.Type.LinkingType); for (var j = 0; j < desc.ValueCount; j++) { @@ -158,7 +157,7 @@ public void SerializeOldAnimation(ref Animation obj, MetaStream stream) int numOfType = stream.ReadInt32(); // The number of times that type has been serialized - MetaClassSerializer serializer = Toolkit.Instance.GetSerializer(typeSymbol.LinkingType); + MetaSerializer serializer = Toolkit.Instance.GetSerializer(typeSymbol.LinkingType); for (var j = 0; j < numOfType; j++) { diff --git a/src/TelltaleToolKit/T3Types/Animations/AnimationValueInterfaceBase.cs b/src/TelltaleToolKit/T3Types/Animations/AnimationValueInterfaceBase.cs index b6b6f85..4560771 100644 --- a/src/TelltaleToolKit/T3Types/Animations/AnimationValueInterfaceBase.cs +++ b/src/TelltaleToolKit/T3Types/Animations/AnimationValueInterfaceBase.cs @@ -1,10 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Animations; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class AnimationValueInterfaceBase { // Both Symbol and a String @@ -15,4 +15,4 @@ public class AnimationValueInterfaceBase public int Flags { get; set; } public short Version { get; set; } = 0; -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Animations/CompressedQuaternionKeys.cs b/src/TelltaleToolKit/T3Types/Animations/CompressedQuaternionKeys.cs index 1ffe2b5..a0dfaa9 100644 --- a/src/TelltaleToolKit/T3Types/Animations/CompressedQuaternionKeys.cs +++ b/src/TelltaleToolKit/T3Types/Animations/CompressedQuaternionKeys.cs @@ -1,9 +1,8 @@ -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Binary; +using TelltaleToolKit.Meta.Serialization; namespace TelltaleToolKit.T3Types.Animations; -[MetaClassSerializerGlobal(typeof(Serializer))] +[MetaSerializer(typeof(Serializer))] public class CompressedQuaternionKeys { public string Name { get; set; } = string.Empty; @@ -13,7 +12,7 @@ public class CompressedQuaternionKeys public int Flags { get; set; } - public class Serializer : MetaClassSerializer + public class Serializer : MetaSerializer { public override void Serialize(ref CompressedQuaternionKeys obj, MetaStream stream) { diff --git a/src/TelltaleToolKit/T3Types/Animations/CompressedSkeletonPoseKeys.cs b/src/TelltaleToolKit/T3Types/Animations/CompressedSkeletonPoseKeys.cs index c970d6b..2a86efc 100644 --- a/src/TelltaleToolKit/T3Types/Animations/CompressedSkeletonPoseKeys.cs +++ b/src/TelltaleToolKit/T3Types/Animations/CompressedSkeletonPoseKeys.cs @@ -1,12 +1,11 @@ using System.Numerics; using System.Runtime.InteropServices; -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Binary; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; namespace TelltaleToolKit.T3Types.Animations; -[MetaClassSerializerGlobal(typeof(Serializer))] +[MetaSerializer(typeof(Serializer))] public class CompressedSkeletonPoseKeys : IAnimatedValueInterface { public AnimationValueInterfaceBase AnimationValueInterfaceBase { get; set; } = new(); @@ -49,9 +48,9 @@ public Header GetHeader() public byte[] Data { get; set; } - public class Serializer : MetaClassSerializer + public class Serializer : MetaSerializer { - public override void PreSerialize(ref CompressedSkeletonPoseKeys2 obj, MetaStream stream, + public override void PreSerialize(ref CompressedSkeletonPoseKeys2? obj, MetaStream stream, MetaClassType? type = null) { obj ??= new CompressedSkeletonPoseKeys2(); diff --git a/src/TelltaleToolKit/T3Types/Animations/CompressedSkeletonPoseKeys2.cs b/src/TelltaleToolKit/T3Types/Animations/CompressedSkeletonPoseKeys2.cs index 4879681..f6c50d0 100644 --- a/src/TelltaleToolKit/T3Types/Animations/CompressedSkeletonPoseKeys2.cs +++ b/src/TelltaleToolKit/T3Types/Animations/CompressedSkeletonPoseKeys2.cs @@ -1,12 +1,11 @@ using System.Numerics; using System.Runtime.InteropServices; -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Binary; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; namespace TelltaleToolKit.T3Types.Animations; -[MetaClassSerializerGlobal(typeof(Serializer))] +[MetaSerializer(typeof(Serializer))] public class CompressedSkeletonPoseKeys2 : IAnimatedValueInterface { public AnimationValueInterfaceBase AnimationValueInterfaceBase { get; set; } = new(); @@ -48,9 +47,9 @@ public Header GetHeader() public byte[] Data { get; set; } - public class Serializer : MetaClassSerializer + public class Serializer : MetaSerializer { - public override void PreSerialize(ref CompressedSkeletonPoseKeys2 obj, MetaStream stream, + public override void PreSerialize(ref CompressedSkeletonPoseKeys2? obj, MetaStream stream, MetaClassType? type = null) { obj ??= new CompressedSkeletonPoseKeys2(); diff --git a/src/TelltaleToolKit/T3Types/Animations/CompressedVector3Keys.cs b/src/TelltaleToolKit/T3Types/Animations/CompressedVector3Keys.cs index 34c6ed3..fd750cd 100644 --- a/src/TelltaleToolKit/T3Types/Animations/CompressedVector3Keys.cs +++ b/src/TelltaleToolKit/T3Types/Animations/CompressedVector3Keys.cs @@ -1,10 +1,9 @@ using System.Numerics; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Binary; +using TelltaleToolKit.Meta.Serialization; namespace TelltaleToolKit.T3Types.Animations; -[MetaClassSerializerGlobal(typeof(Serializer))] +[MetaSerializer(typeof(Serializer))] public class CompressedVector3Keys { public string Name { get; set; } @@ -15,7 +14,7 @@ public class CompressedVector3Keys public Vector3 Min { get; set; } public Vector3 Max { get; set; } - public class Serializer : MetaClassSerializer + public class Serializer : MetaSerializer { public override void Serialize(ref CompressedVector3Keys obj, MetaStream stream) { diff --git a/src/TelltaleToolKit/T3Types/Animations/KeyframedValue.cs b/src/TelltaleToolKit/T3Types/Animations/KeyframedValue.cs index 3811b69..45d3ba3 100644 --- a/src/TelltaleToolKit/T3Types/Animations/KeyframedValue.cs +++ b/src/TelltaleToolKit/T3Types/Animations/KeyframedValue.cs @@ -1,11 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Binary; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Animations; -[MetaClassSerializerGlobal(typeof(KeyframedValue<>.Serializer), typeof(KeyframedValue<>))] +[MetaSerializer(typeof(KeyframedValue<>.Serializer), typeof(KeyframedValue<>))] public class KeyframedValue : IAnimatedValueInterface where T : notnull { [MetaMember("Baseclass_AnimatedValueInterface")] @@ -26,7 +25,7 @@ public AnimationValueInterfaceBase AnimationValueInterfaceBase [MetaMember("mSamples")] public List Samples { get; set; } = []; - [MetaClassSerializerGlobal(typeof(KeyframedValue<>.Sample.Serializer), typeof(KeyframedValue<>.Sample))] + [MetaSerializer(typeof(KeyframedValue<>.Sample.Serializer), typeof(KeyframedValue<>.Sample))] public class Sample { [MetaMember("mTime")] @@ -41,26 +40,26 @@ public class Sample [MetaMember("mTangentMode")] public TangentMode TangentMode { get; set; } - public class Serializer : MetaClassSerializer + public class Serializer : MetaSerializer { - private static readonly DefaultClassSerializer DefaultSerializer = new(); + private static readonly MetaClassSerializer s_metaClassSerializer = new(); public override void Serialize(ref Sample obj, MetaStream stream) { - DefaultSerializer.PreSerialize(ref obj, stream); - DefaultSerializer.Serialize(ref obj, stream); + s_metaClassSerializer.PreSerialize(ref obj, stream); + s_metaClassSerializer.Serialize(ref obj, stream); } } } - public class Serializer : MetaClassSerializer> + public class Serializer : MetaSerializer> { - private static readonly DefaultClassSerializer> DefaultSerializer = new(); + private static readonly MetaClassSerializer> s_metaClassSerializer = new(); public override void Serialize(ref KeyframedValue obj, MetaStream stream) { - DefaultSerializer.PreSerialize(ref obj, stream); - DefaultSerializer.Serialize(ref obj, stream); + s_metaClassSerializer.PreSerialize(ref obj, stream); + s_metaClassSerializer.Serialize(ref obj, stream); if (stream.Mode is MetaStreamMode.Write) { @@ -72,7 +71,7 @@ public override void Serialize(ref KeyframedValue obj, MetaStream stream) } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum TangentMode { // eTangent diff --git a/src/TelltaleToolKit/T3Types/Animations/LocationInfo.cs b/src/TelltaleToolKit/T3Types/Animations/LocationInfo.cs index b5b2ae3..1b69828 100644 --- a/src/TelltaleToolKit/T3Types/Animations/LocationInfo.cs +++ b/src/TelltaleToolKit/T3Types/Animations/LocationInfo.cs @@ -1,11 +1,11 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Skeletons; namespace TelltaleToolKit.T3Types.Animations; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class LocationInfo { [MetaMember("mAttachmentAgent")] @@ -16,4 +16,4 @@ public class LocationInfo [MetaMember("mInitialLocalTransform")] public Transform InitialLocalTransform { get; set; } = new(); -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Animations/PhonemeKey.cs b/src/TelltaleToolKit/T3Types/Animations/PhonemeKey.cs index 88f030f..81ae640 100644 --- a/src/TelltaleToolKit/T3Types/Animations/PhonemeKey.cs +++ b/src/TelltaleToolKit/T3Types/Animations/PhonemeKey.cs @@ -1,10 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Animations; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class PhonemeKey { [MetaMember("mPhoneme")] @@ -21,4 +21,4 @@ public class PhonemeKey [MetaMember("mTargetContribution")] public float TargetContribution { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Animations/PhonemeTable.cs b/src/TelltaleToolKit/T3Types/Animations/PhonemeTable.cs index c40ad77..4cf5dcb 100644 --- a/src/TelltaleToolKit/T3Types/Animations/PhonemeTable.cs +++ b/src/TelltaleToolKit/T3Types/Animations/PhonemeTable.cs @@ -1,13 +1,13 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Animations; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class PhonemeTable { - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public class PhonemeEntry { [MetaMember("mAnimation")] @@ -28,4 +28,4 @@ public class PhonemeEntry [MetaMember("mAnimations")] public Dictionary Animations { get; set; } = new(); -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Animations/ProceduralLookAt.cs b/src/TelltaleToolKit/T3Types/Animations/ProceduralLookAt.cs index d57415c..3337258 100644 --- a/src/TelltaleToolKit/T3Types/Animations/ProceduralLookAt.cs +++ b/src/TelltaleToolKit/T3Types/Animations/ProceduralLookAt.cs @@ -1,13 +1,12 @@ using System.Numerics; -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Binary; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Animations; // TODO: .look Files -[MetaClassSerializerGlobal(typeof(Serializer))] +[MetaSerializer(typeof(Serializer))] public class ProceduralLookAt { [MetaMember("Baseclass_Animation")] @@ -61,7 +60,7 @@ public struct EnumLookAtComputeStage // 2 = final look at } - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public struct Constraint { @@ -84,7 +83,7 @@ public struct Constraint public float UpDownFixedOffset { get; set; } } - public class Serializer : MetaClassSerializer + public class Serializer : MetaSerializer { public override void Serialize(ref ProceduralLookAt obj, MetaStream stream) { diff --git a/src/TelltaleToolKit/T3Types/Animations/ProceduralLookAtValue.cs b/src/TelltaleToolKit/T3Types/Animations/ProceduralLookAtValue.cs index 6ff368a..67fa107 100644 --- a/src/TelltaleToolKit/T3Types/Animations/ProceduralLookAtValue.cs +++ b/src/TelltaleToolKit/T3Types/Animations/ProceduralLookAtValue.cs @@ -1,17 +1,16 @@ using System.Numerics; -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Binary; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; namespace TelltaleToolKit.T3Types.Animations; -[MetaClassSerializerGlobal(typeof(Serializer))] +[MetaSerializer(typeof(Serializer))] public class ProceduralLookAtValue { [MetaMember("Baseclass_AnimatedValueInterface")] public AnimatedValueInterface Quaternion { get; set; } = new(); - public class Serializer : MetaClassSerializer + public class Serializer : MetaSerializer { public override void Serialize(ref ProceduralLookAtValue obj, MetaStream stream) { diff --git a/src/TelltaleToolKit/T3Types/AssetCollection.cs b/src/TelltaleToolKit/T3Types/AssetCollection.cs index fa8180c..e3c78bd 100644 --- a/src/TelltaleToolKit/T3Types/AssetCollection.cs +++ b/src/TelltaleToolKit/T3Types/AssetCollection.cs @@ -1,13 +1,13 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types; /// /// The base class for .acol files. /// -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class AssetCollection { [MetaMember("mIncludeMasks")] @@ -18,4 +18,4 @@ public class AssetCollection [MetaMember("mPreFilter")] public string PreFilter { get; set; } = string.Empty; -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Audio/AudioData.cs b/src/TelltaleToolKit/T3Types/Audio/AudioData.cs index 28634fd..840336e 100644 --- a/src/TelltaleToolKit/T3Types/Audio/AudioData.cs +++ b/src/TelltaleToolKit/T3Types/Audio/AudioData.cs @@ -1,7 +1,6 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Binary; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Audio; @@ -11,7 +10,7 @@ namespace TelltaleToolKit.T3Types.Audio; /// In MSV4+ games, only the filename and length are serialized (if these files are even found in the first place). /// Presumably replaced by FMOD. /// -[MetaClassSerializerGlobal(typeof(Serializer))] +[MetaSerializer(typeof(Serializer))] public class AudioData { [MetaMember("mFilename")] @@ -39,7 +38,7 @@ public class AudioData public int NumChannels { get; set; } public int SampleSizeBytes { get; set; } - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public struct Streamed { [MetaMember("mStreamRegionSize")] @@ -49,13 +48,13 @@ public struct Streamed public float StreamBufferSecs { get; set; } } - public class Serializer : MetaClassSerializer + public class Serializer : MetaSerializer { - private static readonly DefaultClassSerializer DefaultSerializer = new(); + private static readonly MetaClassSerializer s_metaClassSerializer = new(); public override void Serialize(ref AudioData obj, MetaStream stream) { - DefaultSerializer.Serialize(ref obj, stream); + s_metaClassSerializer.Serialize(ref obj, stream); if (stream.Mode is MetaStreamMode.Write) { diff --git a/src/TelltaleToolKit/T3Types/Audio/AudioSound.cs b/src/TelltaleToolKit/T3Types/Audio/AudioSound.cs index ee6e1a0..b132fe4 100644 --- a/src/TelltaleToolKit/T3Types/Audio/AudioSound.cs +++ b/src/TelltaleToolKit/T3Types/Audio/AudioSound.cs @@ -1,10 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Audio; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class AudioSound { // TODO: Check CSI Hard Evidence @@ -14,11 +14,11 @@ public struct EnumSoundMode public SoundMode SoundMode { get; set; } } - [MetaClassSerializerGlobal(typeof(EnumSerializer))] + [MetaSerializer(typeof(EnumSerializer))] public enum SoundMode { mono = 0, stereo = 1, surround = 2 } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Audio/FootSteps.cs b/src/TelltaleToolKit/T3Types/Audio/FootSteps.cs index 1445e01..904916a 100644 --- a/src/TelltaleToolKit/T3Types/Audio/FootSteps.cs +++ b/src/TelltaleToolKit/T3Types/Audio/FootSteps.cs @@ -1,12 +1,12 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Audio; public class FootSteps { - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public class FootstepBank { [MetaMember("mSounds")] @@ -16,4 +16,4 @@ public class FootstepBank public Dictionary>> MaterialFootsteps { get; set; } = new(); } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Audio/FootSteps2.cs b/src/TelltaleToolKit/T3Types/Audio/FootSteps2.cs index f6ce506..c36cfd7 100644 --- a/src/TelltaleToolKit/T3Types/Audio/FootSteps2.cs +++ b/src/TelltaleToolKit/T3Types/Audio/FootSteps2.cs @@ -1,13 +1,13 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Miscellaneous; namespace TelltaleToolKit.T3Types.Audio; public class FootSteps2 { - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public class FootstepBank { [MetaMember("mEventName")] @@ -16,4 +16,4 @@ public class FootstepBank [MetaMember("mMaterialMap")] public Dictionary MaterialMap { get; set; } } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Audio/SoundFootSteps.cs b/src/TelltaleToolKit/T3Types/Audio/SoundFootSteps.cs index 688cfb5..5da99d9 100644 --- a/src/TelltaleToolKit/T3Types/Audio/SoundFootSteps.cs +++ b/src/TelltaleToolKit/T3Types/Audio/SoundFootSteps.cs @@ -1,12 +1,12 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Audio; public class SoundFootsteps { - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public struct EnumMaterial { [MetaMember("mVal")] @@ -14,7 +14,7 @@ public struct EnumMaterial public Material Val { get; set; } } - [MetaClassSerializerGlobal(typeof(EnumSerializer))] + [MetaSerializer(typeof(EnumSerializer))] public enum Material { Never = 0x1, @@ -26,4 +26,4 @@ public enum Material GreaterEqual = 0x7, Always = 0x8, } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Audio/SoundReverbPreset.cs b/src/TelltaleToolKit/T3Types/Audio/SoundReverbPreset.cs index 5132f1a..2fa9061 100644 --- a/src/TelltaleToolKit/T3Types/Audio/SoundReverbPreset.cs +++ b/src/TelltaleToolKit/T3Types/Audio/SoundReverbPreset.cs @@ -1,12 +1,12 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Audio; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class SoundReverbPreset { [MetaMember("mPreset")] public int Preset { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/BinaryBuffer.cs b/src/TelltaleToolKit/T3Types/BinaryBuffer.cs index 30e47f7..f908fb9 100644 --- a/src/TelltaleToolKit/T3Types/BinaryBuffer.cs +++ b/src/TelltaleToolKit/T3Types/BinaryBuffer.cs @@ -1,15 +1,14 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Binary; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; namespace TelltaleToolKit.T3Types; -[MetaClassSerializerGlobal(typeof(Serializer))] +[MetaSerializer(typeof(Serializer))] public class BinaryBuffer { - public class Serializer : MetaClassSerializer + public class Serializer : MetaSerializer { - public override void PreSerialize(ref BinaryBuffer obj, MetaStream stream, MetaClassType? type = null) + public override void PreSerialize(ref BinaryBuffer? obj, MetaStream stream, MetaClassType? type = null) { obj ??= new BinaryBuffer(); } @@ -29,5 +28,5 @@ public override void Serialize(ref BinaryBuffer obj, MetaStream stream) } } - public byte[] Data { get; set; } + public byte[] Data { get; set; } = []; } diff --git a/src/TelltaleToolKit/T3Types/BitSet.cs b/src/TelltaleToolKit/T3Types/BitSet.cs index b2eea25..26a84a6 100644 --- a/src/TelltaleToolKit/T3Types/BitSet.cs +++ b/src/TelltaleToolKit/T3Types/BitSet.cs @@ -1,8 +1,8 @@ -using TelltaleToolKit.Serialization; +using TelltaleToolKit.Meta.Serialization; namespace TelltaleToolKit.T3Types; -[MetaClassSerializerGlobal(typeof(Serializer))] +[MetaSerializer(typeof(Serializer))] public class BitSet : BitSetBase where T : Enum { // A rare case where I actually inherit, and it makes sense to do so. @@ -18,4 +18,4 @@ public BitSet(int count, int first = 0) : base((count + 31) / 32) _count = count; _first = first; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/BitSetBase.cs b/src/TelltaleToolKit/T3Types/BitSetBase.cs index 432906c..da5a6ab 100644 --- a/src/TelltaleToolKit/T3Types/BitSetBase.cs +++ b/src/TelltaleToolKit/T3Types/BitSetBase.cs @@ -1,10 +1,9 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Binary; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; namespace TelltaleToolKit.T3Types; -[MetaClassSerializerGlobal(typeof(Serializer))] +[MetaSerializer(typeof(Serializer))] public class BitSetBase { public uint[] Values { get; set; } @@ -14,9 +13,9 @@ public BitSetBase(int numValues) Values = new uint[numValues]; } - public class Serializer : MetaClassSerializer + public class Serializer : MetaSerializer { - public override void PreSerialize(ref BitSetBase obj, MetaStream stream, MetaClassType? type = null) + public override void PreSerialize(ref BitSetBase? obj, MetaStream stream, MetaClassType? type = null) { if (type is null) { diff --git a/src/TelltaleToolKit/T3Types/Chores/ActorAgentBinding.cs b/src/TelltaleToolKit/T3Types/Chores/ActorAgentBinding.cs index 2ec7f07..d00f5db 100644 --- a/src/TelltaleToolKit/T3Types/Chores/ActorAgentBinding.cs +++ b/src/TelltaleToolKit/T3Types/Chores/ActorAgentBinding.cs @@ -1,12 +1,12 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Chores; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class ActorAgentBinding { [MetaMember("mActorName")] public string ActorName { get; set; } = string.Empty; -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Chores/Chore.cs b/src/TelltaleToolKit/T3Types/Chores/Chore.cs index 126ebf8..4b998fb 100644 --- a/src/TelltaleToolKit/T3Types/Chores/Chore.cs +++ b/src/TelltaleToolKit/T3Types/Chores/Chore.cs @@ -1,7 +1,6 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Binary; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Dialogs.Dlg; using TelltaleToolKit.T3Types.Languages.Landb; using TelltaleToolKit.T3Types.Properties; @@ -9,7 +8,7 @@ namespace TelltaleToolKit.T3Types.Chores; -[MetaClassSerializerGlobal(typeof(Serializer))] +[MetaSerializer(typeof(Serializer))] public class Chore { // [MetaMember("mpChore")] @@ -75,14 +74,14 @@ public class Chore [MetaMember("mWalkPaths")] public Dictionary WalkPaths { get; set; } - public class Serializer : MetaClassSerializer + public class Serializer : MetaSerializer { - private static readonly DefaultClassSerializer DefaultSerializer = new(); + private static readonly MetaClassSerializer s_metaClassSerializer = new(); public override void Serialize(ref Chore obj, MetaStream stream) { - DefaultSerializer.PreSerialize(ref obj, stream); - DefaultSerializer.Serialize(ref obj, stream); + s_metaClassSerializer.PreSerialize(ref obj, stream); + s_metaClassSerializer.Serialize(ref obj, stream); MetaClass? choreMetaClassDescription = stream.GetMetaClass(typeof(Chore)); if (stream.Mode is MetaStreamMode.Write) diff --git a/src/TelltaleToolKit/T3Types/Chores/ChoreAgent.cs b/src/TelltaleToolKit/T3Types/Chores/ChoreAgent.cs index 73d1877..23adab8 100644 --- a/src/TelltaleToolKit/T3Types/Chores/ChoreAgent.cs +++ b/src/TelltaleToolKit/T3Types/Chores/ChoreAgent.cs @@ -1,13 +1,13 @@ using System.Numerics; -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Properties; using TelltaleToolKit.T3Types.Rules; namespace TelltaleToolKit.T3Types.Chores; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class ChoreAgent { [MetaMember("mAgentName")] @@ -30,14 +30,14 @@ public class ChoreAgent [MetaMember("mAttachment")] public Attachment AttachmentWhat { get; set; } = new(); // ???????/ - + [MetaMember("mAABinding")] - public ActorAgentBinding AABinding { get; set; } - + public ActorAgentBinding AABinding { get; set; } + [MetaMember("mAgentEnabledRule")] public Rule AgentEnabledRule { get; set; } // Bone only - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public class Attachment { [MetaMember("mbDoAttach")] @@ -61,4 +61,4 @@ public class Attachment [MetaMember("mbLeaveAttachedWhenComplete")] public bool LeaveAttachedWhenComplete { get; set; } } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Chores/ChoreResource.cs b/src/TelltaleToolKit/T3Types/Chores/ChoreResource.cs index 66b53ea..0836fe9 100644 --- a/src/TelltaleToolKit/T3Types/Chores/ChoreResource.cs +++ b/src/TelltaleToolKit/T3Types/Chores/ChoreResource.cs @@ -1,13 +1,12 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Binary; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Animations; using TelltaleToolKit.T3Types.Properties; namespace TelltaleToolKit.T3Types.Chores; -[MetaClassSerializerGlobal(typeof(Serializer))] +[MetaSerializer(typeof(Serializer))] public class ChoreResource { [MetaMember("mVersion")] @@ -78,7 +77,7 @@ public class ChoreResource public object? Embedded { get; set; } - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public class Block { [MetaMember("mStartTime")] @@ -94,19 +93,19 @@ public class Block public float Scale { get; set; } } - [MetaClassSerializerGlobal(typeof(EnumSerializer))] + [MetaSerializer(typeof(EnumSerializer))] public enum AutoActStatus { } - public class Serializer : MetaClassSerializer + public class Serializer : MetaSerializer { - private static readonly DefaultClassSerializer DefaultSerializer = new(); + private static readonly MetaClassSerializer s_metaClassSerializer = new(); public override void Serialize(ref ChoreResource obj, MetaStream stream) { - DefaultSerializer.PreSerialize(ref obj, stream); - DefaultSerializer.Serialize(ref obj, stream); + s_metaClassSerializer.PreSerialize(ref obj, stream); + s_metaClassSerializer.Serialize(ref obj, stream); MetaClass? description = stream.GetMetaClass(typeof(ChoreResource)); diff --git a/src/TelltaleToolKit/T3Types/Chores/WalkPath.cs b/src/TelltaleToolKit/T3Types/Chores/WalkPath.cs index 81ba6d0..fe7d311 100644 --- a/src/TelltaleToolKit/T3Types/Chores/WalkPath.cs +++ b/src/TelltaleToolKit/T3Types/Chores/WalkPath.cs @@ -1,25 +1,24 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Binary; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Chores; -[MetaClassSerializerGlobal(typeof(Serializer))] +[MetaSerializer(typeof(Serializer))] public class WalkPath { [MetaMember("mName")] public string Name { get; set; } public List Paths { get; set; } - public class Serializer : MetaClassSerializer + public class Serializer : MetaSerializer { - private static readonly DefaultClassSerializer DefaultSerializer = new(); + private static readonly MetaClassSerializer s_metaClassSerializer = new(); public override void Serialize(ref WalkPath obj, MetaStream stream) { - DefaultSerializer.PreSerialize(ref obj, stream); - DefaultSerializer.Serialize(ref obj, stream); + s_metaClassSerializer.PreSerialize(ref obj, stream); + s_metaClassSerializer.Serialize(ref obj, stream); if (stream.Mode is MetaStreamMode.Write) { @@ -33,15 +32,15 @@ public override void Serialize(ref WalkPath obj, MetaStream stream) if (type is null) throw new InvalidOperationException("[WalkPath] Type is not registered."); - MetaClassSerializer classTypeSerializer = + MetaSerializer typeSerializer = Toolkit.Instance.GetSerializer(type.LinkingType); for (var i = 0; i < count; i++) { object? value = null; - classTypeSerializer.PreSerialize(ref value, stream, type); - classTypeSerializer.Serialize(ref value, stream); + typeSerializer.PreSerialize(ref value, stream, type); + typeSerializer.Serialize(ref value, stream); if (value is PathBase pathBase) { diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/ChildSets/DlgChildSet.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/ChildSets/DlgChildSet.cs index 4876e46..bc607f3 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/ChildSets/DlgChildSet.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/ChildSets/DlgChildSet.cs @@ -1,10 +1,9 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Binary; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; namespace TelltaleToolKit.T3Types.Dialogs.Dlg; -[MetaClassSerializerGlobal(typeof(Serializer))] +[MetaSerializer(typeof(Serializer))] public class DlgChildSet { [MetaMember("mChildren")] @@ -13,9 +12,9 @@ public class DlgChildSet [MetaMember("mParent")] public DlgNodeLink Parent { get; set; } - public class Serializer : MetaClassSerializer + public class Serializer : MetaSerializer { - public override void PreSerialize(ref DlgChildSet obj, MetaStream stream, MetaClassType? type = null) + public override void PreSerialize(ref DlgChildSet? obj, MetaStream stream, MetaClassType? type = null) { if (obj is null) { @@ -40,7 +39,7 @@ public override void Serialize(ref DlgChildSet obj, MetaStream stream) if (type == null) throw new InvalidOperationException("[DlgChildSet] Type is not registered."); - MetaClassSerializer childSerializer = Toolkit.Instance.GetSerializer(type.LinkingType); + MetaSerializer childSerializer = Toolkit.Instance.GetSerializer(type.LinkingType); object? dlgChild = null; childSerializer.PreSerialize(ref dlgChild, stream); diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/ChildSets/DlgChildSetChoice.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/ChildSets/DlgChildSetChoice.cs index 7b1f610..5294b4f 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/ChildSets/DlgChildSetChoice.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/ChildSets/DlgChildSetChoice.cs @@ -1,12 +1,12 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Dialogs.Dlg; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class DlgChildSetChoice : IDlgChildSet { [MetaMember("Baseclass_DlgChildSet")] public DlgChildSet DlgChildSet { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/ChildSets/DlgChildSetChoicesChildPost.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/ChildSets/DlgChildSetChoicesChildPost.cs index 84ff371..9b6622e 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/ChildSets/DlgChildSetChoicesChildPost.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/ChildSets/DlgChildSetChoicesChildPost.cs @@ -1,12 +1,12 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Dialogs.Dlg; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class DlgChildSetChoicesChildPost : IDlgChildSet { [MetaMember("Baseclass_DlgChildSet")] public DlgChildSet DlgChildSet { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/ChildSets/DlgChildSetChoicesChildPre.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/ChildSets/DlgChildSetChoicesChildPre.cs index 0046877..287859b 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/ChildSets/DlgChildSetChoicesChildPre.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/ChildSets/DlgChildSetChoicesChildPre.cs @@ -1,12 +1,12 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Dialogs.Dlg; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class DlgChildSetChoicesChildPre: IDlgChildSet { [MetaMember("Baseclass_DlgChildSet")] public DlgChildSet DlgChildSet { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/ChildSets/DlgChildSetConditionalCase.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/ChildSets/DlgChildSetConditionalCase.cs index 2d11129..5ec9fbf 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/ChildSets/DlgChildSetConditionalCase.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/ChildSets/DlgChildSetConditionalCase.cs @@ -1,12 +1,12 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Dialogs.Dlg; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class DlgChildSetConditionalCase : IDlgChildSet { [MetaMember("Baseclass_DlgChildSet")] public DlgChildSet DlgChildSet { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Children/DlgChild.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Children/DlgChild.cs index 8a5fead..6e9fbac 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Children/DlgChild.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Children/DlgChild.cs @@ -1,10 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Dialogs.Dlg; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class DlgChild : IDlgChainHead, IDlgVisibilityConditionsOwner, IDlgObjectPropsOwner { [MetaMember("Baseclass_DlgChainHead")] @@ -21,4 +21,4 @@ public class DlgChild : IDlgChainHead, IDlgVisibilityConditionsOwner, IDlgObject [MetaMember("mParent")] public DlgNodeLink Parent { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Children/DlgChoice.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Children/DlgChoice.cs index 1ddb796..c5eb556 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Children/DlgChoice.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Children/DlgChoice.cs @@ -1,10 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Dialogs.Dlg; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class DlgChoice : IDlgChild, IDlgConditionSet { [MetaMember("Baseclass_DlgChild")] @@ -14,4 +14,4 @@ public class DlgChoice : IDlgChild, IDlgConditionSet [MetaMember("Baseclass_DlgConditionSet")] public DlgConditionSet DlgConditionSet { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Children/DlgChoicesChildPost.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Children/DlgChoicesChildPost.cs index 9e4b2be..44da475 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Children/DlgChoicesChildPost.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Children/DlgChoicesChildPost.cs @@ -1,12 +1,12 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Dialogs.Dlg; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class DlgChoicesChildPost : IDlgChild { [MetaMember("Baseclass_DlgChild")] public DlgChild DlgChild { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Children/DlgChoicesChildPre.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Children/DlgChoicesChildPre.cs index 8bcc65a..cb686c6 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Children/DlgChoicesChildPre.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Children/DlgChoicesChildPre.cs @@ -1,12 +1,12 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Dialogs.Dlg; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class DlgChoicesChildPre : IDlgChild { [MetaMember("Baseclass_DlgChild")] public DlgChild DlgChild { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Children/DlgConditionalCase.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Children/DlgConditionalCase.cs index c42619c..ca1b677 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Children/DlgConditionalCase.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Children/DlgConditionalCase.cs @@ -1,12 +1,12 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Dialogs.Dlg; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class DlgConditionalCase : IDlgChild { [MetaMember("Baseclass_DlgChild")] public DlgChild DlgChild { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Children/DlgFolderChild.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Children/DlgFolderChild.cs index 0f3ecc6..d2f2b52 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Children/DlgFolderChild.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Children/DlgFolderChild.cs @@ -1,12 +1,12 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Dialogs.Dlg; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class DlgFolderChild : IDlgChild { [MetaMember("Baseclass_DlgChild")] public DlgChild DlgChild { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Conditions/DlgCondition.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Conditions/DlgCondition.cs index 93c0ace..22a67f3 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Conditions/DlgCondition.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Conditions/DlgCondition.cs @@ -1,12 +1,12 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Dialogs.Dlg; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class DlgCondition : IDlgObjIdOwner { [MetaMember("Baseclass_DlgObjIDOwner")] public DlgObjIDOwner DlgObjIdOwner { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Conditions/DlgConditionInput.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Conditions/DlgConditionInput.cs index 50919b8..6ac7b13 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Conditions/DlgConditionInput.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Conditions/DlgConditionInput.cs @@ -1,12 +1,12 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Dialogs.Dlg; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class DlgConditionInput : IDlgCondition { [MetaMember("Baseclass_DlgCondition")] public DlgCondition DlgCondition { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Conditions/DlgConditionRule.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Conditions/DlgConditionRule.cs index f0300c4..8674dc7 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Conditions/DlgConditionRule.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Conditions/DlgConditionRule.cs @@ -1,11 +1,11 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Rules; namespace TelltaleToolKit.T3Types.Dialogs.Dlg; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class DlgConditionRule : IDlgCondition { [MetaMember("Baseclass_DlgCondition")] @@ -13,4 +13,4 @@ public class DlgConditionRule : IDlgCondition [MetaMember("mRule")] public Rule Rule { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Conditions/DlgConditionSet.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Conditions/DlgConditionSet.cs index 567c819..9857f96 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Conditions/DlgConditionSet.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Conditions/DlgConditionSet.cs @@ -1,17 +1,16 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Binary; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; namespace TelltaleToolKit.T3Types.Dialogs.Dlg; -[MetaClassSerializerGlobal(typeof(Serializer))] +[MetaSerializer(typeof(Serializer))] public class DlgConditionSet { public List Conditions { get; set; } = []; - public class Serializer : MetaClassSerializer + public class Serializer : MetaSerializer { - public override void PreSerialize(ref DlgConditionSet obj, MetaStream stream, MetaClassType? type = null) + public override void PreSerialize(ref DlgConditionSet? obj, MetaStream stream, MetaClassType? type = null) { obj ??= new DlgConditionSet(); } @@ -34,7 +33,7 @@ public override void Serialize(ref DlgConditionSet obj, MetaStream stream) if (type == null) throw new InvalidOperationException("[DlgConditionSet] Type is not registered."); - MetaClassSerializer conditionSerializer = Toolkit.Instance.GetSerializer(type.LinkingType); + MetaSerializer conditionSerializer = Toolkit.Instance.GetSerializer(type.LinkingType); object? dlgConditionSet = null; conditionSerializer.PreSerialize(ref dlgConditionSet, stream); diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Conditions/DlgConditionTime.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Conditions/DlgConditionTime.cs index 36557c3..044c1c5 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Conditions/DlgConditionTime.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Conditions/DlgConditionTime.cs @@ -1,13 +1,13 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Dialogs.Dlg; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class DlgConditionTime : IDlgCondition { - [MetaClassSerializerGlobal(typeof(EnumSerializer))] + [MetaSerializer(typeof(EnumSerializer))] public enum DurationClass { Timed = 1, @@ -22,4 +22,4 @@ public enum DurationClass [MetaMember("Baseclass_DlgCondition")] public DlgCondition DlgCondition { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Datestamp.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Datestamp.cs index 5a933c1..ed17541 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Datestamp.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Datestamp.cs @@ -1,10 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Dialogs.Dlg; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class Datestamp { [MetaMember("mSec")] @@ -33,4 +33,4 @@ public class Datestamp [MetaMember("mIsdst")] public byte Isdst { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/DepedencyLoader.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/DepedencyLoader.cs index bf6d0b4..bad8e1d 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/DepedencyLoader.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/DepedencyLoader.cs @@ -1,16 +1,14 @@ -using System.Diagnostics; -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Binary; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; namespace TelltaleToolKit.T3Types.Dialogs.Dlg; -[MetaClassSerializerGlobal(typeof(Serializer))] +[MetaSerializer(typeof(Serializer))] public class DependencyLoader { public List ResourceNames { get; set; } = []; - public class Serializer : MetaClassSerializer + public class Serializer : MetaSerializer { public override void Serialize(ref DependencyLoader obj, MetaStream stream) { diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Dlg.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Dlg.cs index 0083d8b..a6c659b 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Dlg.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Dlg.cs @@ -1,13 +1,12 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Binary; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Languages.Landb; using TelltaleToolKit.T3Types.Properties; namespace TelltaleToolKit.T3Types.Dialogs.Dlg; -[MetaClassSerializerGlobal(typeof(Serializer))] +[MetaSerializer(typeof(Serializer))] public class Dlg : IDlgObjIdOwner, ITaskOwner { [MetaMember("Baseclass_DlgObjIDOwner")] @@ -58,13 +57,13 @@ public class Dlg : IDlgObjIdOwner, ITaskOwner public List Nodes { get; set; } = []; - public class Serializer : MetaClassSerializer + public class Serializer : MetaSerializer { - private static readonly DefaultClassSerializer DefaultSerializer = new(); + private static readonly MetaClassSerializer s_metaClassSerializer = new(); public override void Serialize(ref Dlg obj, MetaStream stream) { - DefaultSerializer.PreSerialize(ref obj, stream); - DefaultSerializer.Serialize(ref obj, stream); + s_metaClassSerializer.PreSerialize(ref obj, stream); + s_metaClassSerializer.Serialize(ref obj, stream); MetaClass metaClass = stream.GetMetaClass(typeof(Dlg))!; @@ -94,11 +93,11 @@ public override void Serialize(ref Dlg obj, MetaStream stream) if (type == null) throw new InvalidOperationException("[Dlg] Type is not registered."); - MetaClassSerializer metaClassSerializer = Toolkit.Instance.GetSerializer(type.LinkingType); + MetaSerializer metaSerializer = Toolkit.Instance.GetSerializer(type.LinkingType); object node = null!; - metaClassSerializer.PreSerialize(ref node, stream); - metaClassSerializer.Serialize(ref node, stream); + metaSerializer.PreSerialize(ref node, stream); + metaSerializer.Serialize(ref node, stream); if (node is IDlgNode dlgNode) { diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/DlgChainHead.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/DlgChainHead.cs index fda7282..e96e795 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/DlgChainHead.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/DlgChainHead.cs @@ -1,10 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Dialogs.Dlg; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class DlgChainHead : IDlgObjIdOwner { [MetaMember("Baseclass_DlgObjIDOwner")] @@ -12,4 +12,4 @@ public class DlgChainHead : IDlgObjIdOwner [MetaMember("mLink")] public DlgNodeLink Link { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/DlgDownstreamVisibilityConditions.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/DlgDownstreamVisibilityConditions.cs index 72a44a1..de24af9 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/DlgDownstreamVisibilityConditions.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/DlgDownstreamVisibilityConditions.cs @@ -1,10 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Dialogs.Dlg; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class DlgDownstreamVisibilityConditions { [MetaMember("mNodeTypeFlags")] @@ -12,4 +12,4 @@ public class DlgDownstreamVisibilityConditions [MetaMember("mMaxNumNodeEvals")] public int MaxNumNodeEvals { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/DlgFolder.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/DlgFolder.cs index 83f36be..4b9857f 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/DlgFolder.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/DlgFolder.cs @@ -1,11 +1,11 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Properties; namespace TelltaleToolKit.T3Types.Dialogs.Dlg; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class DlgFolder : IDlgObjIdOwner, IDlgObjectPropsOwner, IDlgChildSet, ITaskOwner { [MetaMember("Baseclass_DlgObjIDOwner")] @@ -13,10 +13,10 @@ public class DlgFolder : IDlgObjIdOwner, IDlgObjectPropsOwner, IDlgChildSet, ITa [MetaMember("Baseclass_DlgObjectPropsOwner")] public DlgObjectPropsOwner DlgObjectPropsOwner { get; set; } - + [MetaMember("Baseclass_DlgChildSet")] public DlgChildSet DlgChildSet { get; set; } - + [MetaMember("Baseclass_TaskOwner")] public TaskOwner TaskOwner { get; set; } @@ -27,4 +27,4 @@ public class DlgFolder : IDlgObjIdOwner, IDlgObjectPropsOwner, IDlgChildSet, ITa public PropertySet ProdReportProps { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/DlgLine.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/DlgLine.cs index bcfab5c..4d7d107 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/DlgLine.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/DlgLine.cs @@ -1,12 +1,12 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Common.UID; using TelltaleToolKit.T3Types.Languages.Landb; namespace TelltaleToolKit.T3Types.Dialogs.Dlg; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class DlgLine : IOwner, IDlgObjIdOwner { [MetaMember("Baseclass_UID::Owner")] @@ -17,4 +17,4 @@ public class DlgLine : IOwner, IDlgObjIdOwner [MetaMember("mLangResProxy")] public LanguageResProxy LangResProxy { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/DlgLineCollection.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/DlgLineCollection.cs index d540de6..67962ec 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/DlgLineCollection.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/DlgLineCollection.cs @@ -1,11 +1,11 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Common.UID; namespace TelltaleToolKit.T3Types.Dialogs.Dlg; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class DlgLineCollection : IGenerator { [MetaMember("Baseclass_UID::Generator")] @@ -13,4 +13,4 @@ public class DlgLineCollection : IGenerator [MetaMember("mLines")] public Dictionary Lines { get; set; } = new(); -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/DlgNodeLink.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/DlgNodeLink.cs index 587e6ff..51f1b45 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/DlgNodeLink.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/DlgNodeLink.cs @@ -1,10 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Dialogs.Dlg; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class DlgNodeLink : IDlgObjIdOwner { [MetaMember("mRequiredCCType")] @@ -14,11 +14,11 @@ public class DlgNodeLink : IDlgObjIdOwner public DlgObjIDOwner DlgObjIdOwner { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum ChainContextTypeID { // eCC Unspecified = 1, Action = 2, Data = 3 -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/DlgObjID.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/DlgObjID.cs index 530b85d..3ef2846 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/DlgObjID.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/DlgObjID.cs @@ -1,12 +1,12 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Dialogs.Dlg; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class DlgObjId { [MetaMember("mID")] public Symbol Id { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/DlgObjIDOwner.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/DlgObjIDOwner.cs index 7400b4c..50cb637 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/DlgObjIDOwner.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/DlgObjIDOwner.cs @@ -1,12 +1,12 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Dialogs.Dlg; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class DlgObjIDOwner { [MetaMember("mDlgObjID")] public DlgObjId DlgObjID { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/DlgObjectProps.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/DlgObjectProps.cs index 30d5ebf..bea413f 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/DlgObjectProps.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/DlgObjectProps.cs @@ -1,12 +1,11 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Binary; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Properties; namespace TelltaleToolKit.T3Types.Dialogs.Dlg; -[MetaClassSerializerGlobal(typeof(Serializer))] +[MetaSerializer(typeof(Serializer))] public class DlgObjectProps { public enum PropsType { @@ -21,14 +20,14 @@ public enum PropsType { public PropertySet UserProperties { get; set; } public PropertySet ProductionProperties { get; set; } public PropertySet ToolProperties { get; set; } - public class Serializer : MetaClassSerializer + public class Serializer : MetaSerializer { - private static readonly DefaultClassSerializer DefaultSerializer = new(); + private static readonly MetaClassSerializer s_metaClassSerializer = new(); public override void Serialize(ref DlgObjectProps obj, MetaStream stream) { - DefaultSerializer.PreSerialize(ref obj, stream); - DefaultSerializer.Serialize(ref obj, stream); + s_metaClassSerializer.PreSerialize(ref obj, stream); + s_metaClassSerializer.Serialize(ref obj, stream); if (stream.Mode is MetaStreamMode.Write) { diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/DlgObjectPropsOwner.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/DlgObjectPropsOwner.cs index c712ecb..8ce31fb 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/DlgObjectPropsOwner.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/DlgObjectPropsOwner.cs @@ -1,12 +1,12 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Dialogs.Dlg; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class DlgObjectPropsOwner { [MetaMember("mDlgObjectProps")] public DlgObjectProps DlgObjectProps { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/DlgVisibilityConditions.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/DlgVisibilityConditions.cs index da70453..b956384 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/DlgVisibilityConditions.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/DlgVisibilityConditions.cs @@ -1,12 +1,11 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Binary; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Rules; namespace TelltaleToolKit.T3Types.Dialogs.Dlg; -[MetaClassSerializerGlobal(typeof(Serializer))] +[MetaSerializer(typeof(Serializer))] public class DlgVisibilityConditions { public Rule Rule { get; set; } @@ -23,14 +22,14 @@ public class DlgVisibilityConditions [MetaMember("mScriptVisCond")] public string ScriptVisCond { get; set; } - public class Serializer : MetaClassSerializer + public class Serializer : MetaSerializer { - private static readonly DefaultClassSerializer DefaultSerializer = new(); + private static readonly MetaClassSerializer s_metaClassSerializer = new(); public override void Serialize(ref DlgVisibilityConditions obj, MetaStream stream) { - DefaultSerializer.PreSerialize(ref obj, stream); - DefaultSerializer.Serialize(ref obj, stream); + s_metaClassSerializer.PreSerialize(ref obj, stream); + s_metaClassSerializer.Serialize(ref obj, stream); if (stream.Mode is MetaStreamMode.Write) { diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/DlgVisibilityConditionsOwner.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/DlgVisibilityConditionsOwner.cs index efa1cde..126460c 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/DlgVisibilityConditionsOwner.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/DlgVisibilityConditionsOwner.cs @@ -1,12 +1,12 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Dialogs.Dlg; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class DlgVisibilityConditionsOwner { [MetaMember("mVisCond")] public DlgVisibilityConditions VisCond { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/JiraRecordManager.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/JiraRecordManager.cs index 2bbecc3..eb9887b 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/JiraRecordManager.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/JiraRecordManager.cs @@ -1,16 +1,15 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Binary; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; namespace TelltaleToolKit.T3Types.Dialogs.Dlg; // TODO: -[MetaClassSerializerGlobal(typeof(Serializer))] +[MetaSerializer(typeof(Serializer))] public class JiraRecordManager { public Dictionary Records = new(); - public class Serializer : MetaClassSerializer + public class Serializer : MetaSerializer { public override void PreSerialize(ref JiraRecordManager? obj, MetaStream stream, MetaClassType? type = null) { diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNode.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNode.cs index d10b62f..50048fe 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNode.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNode.cs @@ -1,10 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Dialogs.Dlg; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class DlgNode : IDlgObjIdOwner, IDlgObjectPropsOwner, IDlgVisibilityConditionsOwner, ITaskOwner { [MetaMember("Baseclass_DlgObjIDOwner")] @@ -35,4 +35,4 @@ public class DlgNode : IDlgObjIdOwner, IDlgObjectPropsOwner, IDlgVisibilityCondi [MetaMember("mChainContextTypeID")] public ChainContextTypeID ChainContextTypeID { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeCancelChoices.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeCancelChoices.cs index 01cb9a5..4ff11c9 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeCancelChoices.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeCancelChoices.cs @@ -1,16 +1,16 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Dialogs.Dlg.Nodes; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class DlgNodeCancelChoices : IDlgNode { [MetaMember("Baseclass_DlgNode")] public DlgNode DlgNode { get; set; } - [MetaClassSerializerGlobal(typeof(EnumSerializer))] + [MetaSerializer(typeof(EnumSerializer))] public enum CancelGroupT { AllActiveChoices = 1, @@ -18,4 +18,4 @@ public enum CancelGroupT [MetaMember("mCancelGroup")] public CancelGroupT CancelGroup { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeChoices.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeChoices.cs index 0f45b74..759e77b 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeChoices.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeChoices.cs @@ -1,10 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Dialogs.Dlg.Nodes; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class DlgNodeChoices : IDlgNode { [MetaMember("Baseclass_DlgNode")] @@ -17,4 +17,4 @@ public class DlgNodeChoices : IDlgNode [MetaMember("mPostChoice")] public DlgChildSetChoicesChildPost PostChoice { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeChore.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeChore.cs index 69e10ea..8698ab9 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeChore.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeChore.cs @@ -1,16 +1,16 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Chores; namespace TelltaleToolKit.T3Types.Dialogs.Dlg.Nodes; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class DlgNodeChore : IDlgNode { [MetaMember("Baseclass_DlgNode")] public DlgNode DlgNode { get; set; } - + [MetaMember("mChore")] public Handle Chore { get; set; } @@ -19,4 +19,4 @@ public class DlgNodeChore : IDlgNode [MetaMember("mLooping")] public bool Looping { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeConditional.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeConditional.cs index 133be91..b1871d3 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeConditional.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeConditional.cs @@ -1,10 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Dialogs.Dlg.Nodes; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class DlgNodeConditional : IDlgNode { [MetaMember("Baseclass_DlgNode")] @@ -12,4 +12,4 @@ public class DlgNodeConditional : IDlgNode [MetaMember("mCases")] public DlgChildSetConditionalCase Cases { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeCriteria.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeCriteria.cs index a8ae8be..95a36d7 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeCriteria.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeCriteria.cs @@ -1,13 +1,13 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Dialogs.Dlg.Nodes; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class DlgNodeCriteria : IDlgNode { - [MetaClassSerializerGlobal(typeof(EnumSerializer))] + [MetaSerializer(typeof(EnumSerializer))] public enum DefaultResult { DefaultToPass = 1, @@ -15,14 +15,14 @@ public enum DefaultResult DefaultToNotPassUnlessTransparent = 3 } - [MetaClassSerializerGlobal(typeof(EnumSerializer))] + [MetaSerializer(typeof(EnumSerializer))] public enum Test { Required = 1, Forbidden = 2 } - [MetaClassSerializerGlobal(typeof(EnumSerializer))] + [MetaSerializer(typeof(EnumSerializer))] public enum Threshold { Any = 1, @@ -55,24 +55,24 @@ public enum Threshold public DlgNode DlgNode { get; set; } - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public struct EnumTestT { [MetaMember("mVal")] public Test Val { get; set; } } - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public struct EnumThresholdT { [MetaMember("mVal")] public Threshold Val { get; set; } } - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public struct EnumDefaultResultT { [MetaMember("mVal")] public DefaultResult Val { get; set; } } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeExchange.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeExchange.cs index 1d27654..f476e7e 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeExchange.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeExchange.cs @@ -1,12 +1,11 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Binary; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Chores; namespace TelltaleToolKit.T3Types.Dialogs.Dlg.Nodes; -[MetaClassSerializerGlobal(typeof(Serializer))] +[MetaSerializer(typeof(Serializer))] public class DlgNodeExchange : IDlgNode { [MetaMember("Baseclass_DlgNode")] @@ -24,14 +23,14 @@ public class DlgNodeExchange : IDlgNode public NoteCollection Notes { get; set; } public DlgLineCollection Lines { get; set; } - [MetaClassSerializerGlobal(typeof(EnumSerializer))] + [MetaSerializer(typeof(EnumSerializer))] public enum EntryType { Line = 1, Note = 2 } - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public class Entry { [MetaMember("mID")] @@ -41,14 +40,14 @@ public class Entry public EntryType Type { get; set; } } - public class Serializer : MetaClassSerializer + public class Serializer : MetaSerializer { - private static readonly DefaultClassSerializer DefaultClassSerializer = new(); + private static readonly MetaClassSerializer s_metaClassSerializer = new(); public override void Serialize(ref DlgNodeExchange obj, MetaStream stream) { - DefaultClassSerializer.PreSerialize(ref obj, stream); - DefaultClassSerializer.Serialize(ref obj, stream); + s_metaClassSerializer.PreSerialize(ref obj, stream); + s_metaClassSerializer.Serialize(ref obj, stream); if (stream.Mode is MetaStreamMode.Write) { diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeExit.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeExit.cs index a93cdd8..65d23dd 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeExit.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeExit.cs @@ -1,12 +1,12 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Dialogs.Dlg.Nodes; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class DlgNodeExit : IDlgNode { [MetaMember("Baseclass_DlgNode")] public DlgNode DlgNode { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeIdle.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeIdle.cs index 5067bdd..d73bed5 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeIdle.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeIdle.cs @@ -1,14 +1,14 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Chores; namespace TelltaleToolKit.T3Types.Dialogs.Dlg.Nodes; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class DlgNodeIdle : IDlgNode { - [MetaClassSerializerGlobal(typeof(EnumSerializer))] + [MetaSerializer(typeof(EnumSerializer))] public enum OverrideOption { UseDefaults = 1, @@ -32,7 +32,7 @@ public enum OverrideOption [MetaMember("mOverrideOptionStyle")] public OverrideOption OverrideOptionStyle { get; set; } - + [MetaMember("Baseclass_DlgNode")] public DlgNode DlgNode { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeJump.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeJump.cs index 0ee2aa8..0ee9a28 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeJump.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeJump.cs @@ -1,14 +1,14 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Dialogs.Dlg.Nodes; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class DlgNodeJump : IDlgNode { // TODO: Not exactly the right names. - [MetaClassSerializerGlobal(typeof(EnumSerializer))] + [MetaSerializer(typeof(EnumSerializer))] public enum JumpBehaviourEnum { JumpAndExecute = 1, @@ -16,7 +16,7 @@ public enum JumpBehaviourEnum Return = 3 } - [MetaClassSerializerGlobal(typeof(EnumSerializer))] + [MetaSerializer(typeof(EnumSerializer))] public enum JumpTargetClassEnum { ToName = 1, @@ -24,7 +24,7 @@ public enum JumpTargetClassEnum ToNodeAfterParentWaitNode = 3 } - [MetaClassSerializerGlobal(typeof(EnumSerializer))] + [MetaSerializer(typeof(EnumSerializer))] public enum VisibilityBehaviourEnum { IgnoreVisibility = 1, @@ -33,7 +33,7 @@ public enum VisibilityBehaviourEnum [MetaMember("Baseclass_DlgNode")] public DlgNode DlgNode { get; set; } - + [MetaMember("mJumpToLink")] public DlgNodeLink JumpToLink { get; set; } @@ -54,4 +54,4 @@ public enum VisibilityBehaviourEnum [MetaMember("mhJumpToDlg")] public Handle JumpToDlg { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeLogic.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeLogic.cs index e2f0c8e..5dffda2 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeLogic.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeLogic.cs @@ -1,11 +1,11 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Rules; namespace TelltaleToolKit.T3Types.Dialogs.Dlg.Nodes; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class DlgNodeLogic : IDlgNode { [MetaMember("Baseclass_DlgNode")] @@ -13,4 +13,4 @@ public class DlgNodeLogic : IDlgNode [MetaMember("mRule")] public Rule Rule { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeMarker.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeMarker.cs index 9dcc3f1..84d1dfb 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeMarker.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeMarker.cs @@ -1,12 +1,12 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Dialogs.Dlg.Nodes; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class DlgNodeMarker : IDlgNode { [MetaMember("Baseclass_DlgNode")] public DlgNode DlgNode { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeNotes.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeNotes.cs index 5dfd5a6..7c0d93e 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeNotes.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeNotes.cs @@ -1,10 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Dialogs.Dlg.Nodes; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class DlgNodeNotes : IDlgNode { [MetaMember("Baseclass_DlgNode")] @@ -12,4 +12,4 @@ public class DlgNodeNotes : IDlgNode [MetaMember("mNoteText")] public string NoteText { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeParallel.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeParallel.cs index 7a41a51..592266b 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeParallel.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeParallel.cs @@ -1,10 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Dialogs.Dlg.Nodes; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class DlgNodeParallel : IDlgNode { [MetaMember("Baseclass_DlgNode")] @@ -16,17 +16,17 @@ public class DlgNodeParallel : IDlgNode [MetaMember("mElemUseCriteria")] public DlgNodeCriteria ElemUseCriteria { get; set; } - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public class PElement : IDlgChild { [MetaMember("Baseclass_DlgChild")] public DlgChild DlgChild { get; set; } } - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public class DlgChildSetElement : IDlgChildSet { [MetaMember("Baseclass_DlgChildSet")] public DlgChildSet DlgChildSet { get; set; } } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeScript.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeScript.cs index 1023db0..d229e88 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeScript.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeScript.cs @@ -1,10 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Dialogs.Dlg.Nodes; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class DlgNodeScript : IDlgNode { [MetaMember("Baseclass_DlgNode")] @@ -18,4 +18,4 @@ public class DlgNodeScript : IDlgNode [MetaMember("mbExecuteOnInstanceRetire")] public bool ExecuteOnInstanceRetire { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeSequence.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeSequence.cs index 5c3ff5c..8fb4517 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeSequence.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeSequence.cs @@ -1,20 +1,20 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Dialogs.Dlg.Nodes; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class DlgNodeSequence : IDlgNode { - [MetaClassSerializerGlobal(typeof(EnumSerializer))] + [MetaSerializer(typeof(EnumSerializer))] public enum PlaybackModeT { Sequential = 1, Shuffle = 2 } - [MetaClassSerializerGlobal(typeof(EnumSerializer))] + [MetaSerializer(typeof(EnumSerializer))] public enum PlayPositionT { Unspecified = 1, @@ -22,7 +22,7 @@ public enum PlayPositionT Last = 3 } - [MetaClassSerializerGlobal(typeof(EnumSerializer))] + [MetaSerializer(typeof(EnumSerializer))] public enum RepeatT { Indefinitely = 1, @@ -35,7 +35,7 @@ public enum RepeatT MaxPlusOne = 8 } - [MetaClassSerializerGlobal(typeof(EnumSerializer))] + [MetaSerializer(typeof(EnumSerializer))] public enum LifetimeModeT { Looping = 1, @@ -58,7 +58,7 @@ public enum LifetimeModeT [MetaMember("mElemUseCriteria")] public DlgNodeCriteria ElemUseCriteria { get; set; } - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public class Element : IDlgChild { [MetaMember("Baseclass_DlgChild")] @@ -72,10 +72,10 @@ public class Element : IDlgChild } - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public class DlgChildSetElement : IDlgChildSet { [MetaMember("Baseclass_DlgChildSet")] public DlgChildSet DlgChildSet { get; set; } } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeStart.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeStart.cs index dd39d43..deb205c 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeStart.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeStart.cs @@ -1,16 +1,16 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Properties; namespace TelltaleToolKit.T3Types.Dialogs.Dlg.Nodes; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class DlgNodeStart : IDlgNode { [MetaMember("Baseclass_DlgNode")] public DlgNode DlgNode { get; set; } - + [MetaMember("mProdReportProps")] public PropertySet ProdReportProps { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeStats.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeStats.cs index 3c9c860..a1c3753 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeStats.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeStats.cs @@ -1,15 +1,15 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Languages.Landb; using TelltaleToolKit.T3Types.Textures; namespace TelltaleToolKit.T3Types.Dialogs.Dlg.Nodes; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class DlgNodeStats { - [MetaClassSerializerGlobal(typeof(EnumSerializer))] + [MetaSerializer(typeof(EnumSerializer))] public enum StatsType { Choices = 1, @@ -29,9 +29,9 @@ public enum StatsType [MetaMember("mDisplayText")] public LanguageResProxy DisplayText { get; set; } - - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + + [MetaSerializer(typeof(MetaClassSerializer))] public class Cohort : IDlgChild { [MetaMember("mhImage")] @@ -53,10 +53,10 @@ public class Cohort : IDlgChild public DlgChild DlgChild { get; set; } } - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public class DlgChildSetCohort : IDlgChildSet { [MetaMember("Baseclass_DlgChildSet")] public DlgChildSet DlgChildSet { get; set; } } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeStoryBoard.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeStoryBoard.cs index 03bcfad..932a6a7 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeStoryBoard.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeStoryBoard.cs @@ -1,10 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Dialogs.Dlg.Nodes; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class DlgNodeStoryBoard : IDlgNode { [MetaMember("Baseclass_DlgNode")] @@ -12,4 +12,4 @@ public class DlgNodeStoryBoard : IDlgNode [MetaMember("mStoryBoardImage")] public Symbol StoryBoardImage { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeText.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeText.cs index dfad5f8..5b9610c 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeText.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeText.cs @@ -1,11 +1,11 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Languages.Landb; namespace TelltaleToolKit.T3Types.Dialogs.Dlg.Nodes; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class DlgNodeText : IDlgNode { [MetaMember("Baseclass_DlgNode")] @@ -13,4 +13,4 @@ public class DlgNodeText : IDlgNode [MetaMember("mLangResProxy")] public LanguageResProxy LangResProxy { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeWait.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeWait.cs index 12e8567..0e6f796 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeWait.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Nodes/DlgNodeWait.cs @@ -1,10 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Dialogs.Dlg.Nodes; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class DlgNodeWait : IDlgNode, IDlgConditionSet { [MetaMember("Baseclass_DlgNode")] @@ -14,4 +14,4 @@ public class DlgNodeWait : IDlgNode, IDlgConditionSet [MetaMember("Baseclass_DlgConditionSet")] public DlgConditionSet DlgConditionSet { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Note.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Note.cs index 2332a49..fc0ea91 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Note.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/Note.cs @@ -1,12 +1,11 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Binary; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Common.UID; namespace TelltaleToolKit.T3Types.Dialogs.Dlg; -[MetaClassSerializerGlobal(typeof(Serializer))] +[MetaSerializer(typeof(Serializer))] public class Note : IGenerator, IOwner { [MetaMember("Baseclass_UID::Generator")] @@ -42,14 +41,14 @@ public class Entry : IGenerator, IOwner public string Text { get; set; } } - public class Serializer : MetaClassSerializer + public class Serializer : MetaSerializer { - private static readonly DefaultClassSerializer DefaultClassSerializer = new(); + private static readonly MetaClassSerializer s_metaClassSerializer = new(); public override void Serialize(ref Note obj, MetaStream stream) { - DefaultClassSerializer.PreSerialize(ref obj, stream); - DefaultClassSerializer.Serialize(ref obj, stream); + s_metaClassSerializer.PreSerialize(ref obj, stream); + s_metaClassSerializer.Serialize(ref obj, stream); if (stream.Mode is MetaStreamMode.Write) { diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/NoteCollection.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/NoteCollection.cs index 5093548..12da838 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlg/NoteCollection.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlg/NoteCollection.cs @@ -1,11 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Binary; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; using TelltaleToolKit.T3Types.Common.UID; namespace TelltaleToolKit.T3Types.Dialogs.Dlg; -[MetaClassSerializerGlobal(typeof(Serializer))] +[MetaSerializer(typeof(Serializer))] public class NoteCollection : IGenerator { [MetaMember("Baseclass_UID::Generator")] @@ -14,7 +13,7 @@ public class NoteCollection : IGenerator [MetaMember("mNotes")] public Dictionary Notes { get; set; } = new(); - public class Serializer : MetaClassSerializer + public class Serializer : MetaSerializer { public override void Serialize(ref NoteCollection obj, MetaStream stream) { diff --git a/src/TelltaleToolKit/T3Types/Dialogs/DlgSettings/DlgObjectPropsMap.cs b/src/TelltaleToolKit/T3Types/Dialogs/DlgSettings/DlgObjectPropsMap.cs index e437654..94cb6c5 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/DlgSettings/DlgObjectPropsMap.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/DlgSettings/DlgObjectPropsMap.cs @@ -1,12 +1,11 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Binary; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; using TelltaleToolKit.T3Types.Common.UID; using TelltaleToolKit.T3Types.Properties; namespace TelltaleToolKit.T3Types.Dialogs.DlgSettings; -[MetaClassSerializerGlobal(typeof(Serializer))] +[MetaSerializer(typeof(Serializer))] public class DlgObjectPropsMap : IGenerator { public List GroupDefinitions { get; set; } @@ -29,7 +28,7 @@ public class GroupDefinition : IOwner public Owner Owner { get; set; } } - public class Serializer : MetaClassSerializer + public class Serializer : MetaSerializer { public override void Serialize(ref DlgObjectPropsMap obj, MetaStream stream) { diff --git a/src/TelltaleToolKit/T3Types/Dialogs/DlgSettings/DlgSystemSettings.cs b/src/TelltaleToolKit/T3Types/Dialogs/DlgSettings/DlgSystemSettings.cs index 56b57c1..6972bab 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/DlgSettings/DlgSystemSettings.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/DlgSettings/DlgSystemSettings.cs @@ -1,10 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Dialogs.DlgSettings; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class DlgSystemSettings { [MetaMember("mPropsMapUser")] @@ -12,4 +12,4 @@ public class DlgSystemSettings [MetaMember("mPropsMapProduction")] public DlgObjectPropsMap PropsMapProduction { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlog/DialogBase.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlog/DialogBase.cs index e5da38a..aee4213 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlog/DialogBase.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlog/DialogBase.cs @@ -1,15 +1,14 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Binary; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Chores; using TelltaleToolKit.T3Types.Properties; using TelltaleToolKit.T3Types.Rules; using TelltaleToolKit.T3Types.StyleGuides; -namespace TelltaleToolKit.T3Types.Dialogs; +namespace TelltaleToolKit.T3Types.Dialogs.Dlog; -[MetaClassSerializerGlobal(typeof(Serializer))] +[MetaSerializer(typeof(Serializer))] public class DialogBase { [MetaMember("mDialogElemType")] @@ -42,11 +41,11 @@ public class DialogBase public int ActualId; public List StyleGuideRefs = []; - public class Serializer : MetaClassSerializer + public class Serializer : MetaSerializer { public override void Serialize(ref DialogBase obj, MetaStream stream) { - new DefaultClassSerializer().Serialize(ref obj, stream); + new MetaClassSerializer().Serialize(ref obj, stream); if (stream.Mode is MetaStreamMode.Write) { diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlog/DialogBranch.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlog/DialogBranch.cs index d827ece..a313a57 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlog/DialogBranch.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlog/DialogBranch.cs @@ -1,10 +1,11 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; +using TelltaleToolKit.T3Types.Dialogs.Dlog; namespace TelltaleToolKit.T3Types.Dialogs; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class DialogBranch : IDialogBase { [MetaMember("Baseclass_DialogBase")] @@ -36,4 +37,4 @@ public class DialogBranch : IDialogBase [MetaMember("mPersistBGChore")] public bool PersistBackgroundChore { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlog/DialogDialog.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlog/DialogDialog.cs index 1047798..09de6fc 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlog/DialogDialog.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlog/DialogDialog.cs @@ -1,10 +1,11 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; +using TelltaleToolKit.T3Types.Dialogs.Dlog; namespace TelltaleToolKit.T3Types.Dialogs; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class DialogDialog : IDialogBase { [MetaMember("Baseclass_DialogBase")] @@ -15,4 +16,4 @@ public class DialogDialog : IDialogBase [MetaMember("mBranches")] public List Branches { get; set; } = []; -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlog/DialogExchange.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlog/DialogExchange.cs index fb7db3c..7f40449 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlog/DialogExchange.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlog/DialogExchange.cs @@ -1,12 +1,13 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Chores; +using TelltaleToolKit.T3Types.Dialogs.Dlog; using TelltaleToolKit.T3Types.Languages.Landb; namespace TelltaleToolKit.T3Types.Dialogs; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class DialogExchange : IDialogBase { [MetaMember("Baseclass_DialogBase")] @@ -36,4 +37,4 @@ public class DialogExchange : IDialogBase internal class ExchangeElem { } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlog/DialogItem.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlog/DialogItem.cs index 792c947..feaa5a6 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlog/DialogItem.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlog/DialogItem.cs @@ -1,11 +1,12 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; +using TelltaleToolKit.T3Types.Dialogs.Dlog; using TelltaleToolKit.T3Types.Languages.Landb; namespace TelltaleToolKit.T3Types.Dialogs; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class DialogItem : IDialogBase { [MetaMember("Baseclass_DialogBase")] @@ -56,14 +57,14 @@ public class DialogItem : IDialogBase [MetaMember("mbCutscene")] public bool Cutscene { get; set; } - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public struct EnumPlaybackMode { [MetaMember("mVal")] public PlaybackModeEnum Value { get; set; } } - [MetaClassSerializerGlobal(typeof(EnumSerializer))] + [MetaSerializer(typeof(EnumSerializer))] public enum PlaybackModeEnum { sequential_looping = 0x0, @@ -74,4 +75,4 @@ public enum PlaybackModeEnum shuffle_die_off = 0x5, first_then_shuffle_repeat_remaining = 0x6, } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlog/DialogLine.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlog/DialogLine.cs index c9fba44..ec131fb 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlog/DialogLine.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlog/DialogLine.cs @@ -1,11 +1,12 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; +using TelltaleToolKit.T3Types.Dialogs.Dlog; using TelltaleToolKit.T3Types.Languages.Landb; namespace TelltaleToolKit.T3Types.Dialogs; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class DialogLine : IDialogBase { [MetaMember("Baseclass_DialogBase")] @@ -13,4 +14,4 @@ public class DialogLine : IDialogBase [MetaMember("mLangResProxy")] public LanguageResProxy LangResProxy { get; set; } = new(); -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlog/DialogResource.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlog/DialogResource.cs index bf8776a..4e18708 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlog/DialogResource.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlog/DialogResource.cs @@ -1,11 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Binary; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Dialogs; -[MetaClassSerializerGlobal(typeof(Serializer))] +[MetaSerializer(typeof(Serializer))] public class DialogResource { [MetaMember("miNextDialogID")] @@ -51,14 +50,14 @@ public class DialogResource public List Lines = []; public List Texts = []; - public class Serializer : MetaClassSerializer + public class Serializer : MetaSerializer { - private static readonly DefaultClassSerializer DefaultSerializer = new(); + private static readonly MetaClassSerializer s_metaClassSerializer = new(); public override void Serialize(ref DialogResource obj, MetaStream stream) { - DefaultSerializer.PreSerialize(ref obj, stream); - DefaultSerializer.Serialize(ref obj, stream); + s_metaClassSerializer.PreSerialize(ref obj, stream); + s_metaClassSerializer.Serialize(ref obj, stream); if (stream.Mode is MetaStreamMode.Write) { diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlog/DialogText.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlog/DialogText.cs index ca71f21..7b56bec 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlog/DialogText.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlog/DialogText.cs @@ -1,11 +1,12 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; +using TelltaleToolKit.T3Types.Dialogs.Dlog; using TelltaleToolKit.T3Types.Languages.Landb; namespace TelltaleToolKit.T3Types.Dialogs; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class DialogText : IDialogBase { [MetaMember("Baseclass_DialogBase")] @@ -17,4 +18,4 @@ public class DialogText : IDialogBase [MetaMember("mLangResProxy")] public LanguageResProxy LangResProxy { get; set; } = new(); -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlog/DialogUtils.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlog/DialogUtils.cs index 06fdf5f..69bb1f0 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlog/DialogUtils.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlog/DialogUtils.cs @@ -1,11 +1,11 @@ -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Dialogs; public class DialogUtils { - [MetaClassSerializerGlobal(typeof(EnumSerializer))] + [MetaSerializer(typeof(EnumSerializer))] public enum DialogElemT : uint { Exchange = 1, @@ -15,4 +15,4 @@ public enum DialogElemT : uint Text = 5, Line = 0xFEEDFACE, } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Dialogs/Dlog/LanguageResourceProxy.cs b/src/TelltaleToolKit/T3Types/Dialogs/Dlog/LanguageResourceProxy.cs index 36f3bf5..15c5f0e 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/Dlog/LanguageResourceProxy.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/Dlog/LanguageResourceProxy.cs @@ -1,12 +1,12 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Dialogs; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class LanguageResourceProxy { [MetaMember("mID")] public uint LangId { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Dialogs/IDialogBase.cs b/src/TelltaleToolKit/T3Types/Dialogs/IDialogBase.cs index 66ce23b..55a6230 100644 --- a/src/TelltaleToolKit/T3Types/Dialogs/IDialogBase.cs +++ b/src/TelltaleToolKit/T3Types/Dialogs/IDialogBase.cs @@ -1,6 +1,8 @@ +using TelltaleToolKit.T3Types.Dialogs.Dlog; + namespace TelltaleToolKit.T3Types.Dialogs; public interface IDialogBase { public DialogBase DialogBase { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Effects/ParticleLODKey.cs b/src/TelltaleToolKit/T3Types/Effects/ParticleLODKey.cs index 58a3395..bbdf448 100644 --- a/src/TelltaleToolKit/T3Types/Effects/ParticleLODKey.cs +++ b/src/TelltaleToolKit/T3Types/Effects/ParticleLODKey.cs @@ -1,10 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Effects; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class ParticleLODKey { [MetaMember("mCountScale")] @@ -18,4 +18,4 @@ public class ParticleLODKey [MetaMember("mLifeScale")] public float mLifeScale { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Effects/ParticlePropConnect.cs b/src/TelltaleToolKit/T3Types/Effects/ParticlePropConnect.cs index 35b9b3a..ef724b2 100644 --- a/src/TelltaleToolKit/T3Types/Effects/ParticlePropConnect.cs +++ b/src/TelltaleToolKit/T3Types/Effects/ParticlePropConnect.cs @@ -1,11 +1,11 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Miscellaneous; namespace TelltaleToolKit.T3Types.Effects; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class ParticlePropConnect { [MetaMember("mModType")] @@ -28,4 +28,4 @@ public class ParticlePropConnect [MetaMember("mInvert")] public bool mInvert { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/EnlightenModule.cs b/src/TelltaleToolKit/T3Types/EnlightenModule.cs index 9dea7d9..4edcb84 100644 --- a/src/TelltaleToolKit/T3Types/EnlightenModule.cs +++ b/src/TelltaleToolKit/T3Types/EnlightenModule.cs @@ -1,14 +1,14 @@ using System.Numerics; -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class EnlightenModule { - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public class EnlightenSystemSettings { [MetaMember("mDefaultQuality")] @@ -21,14 +21,14 @@ public class EnlightenSystemSettings public bool DisableEnlighten { get; set; } } - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public struct EnumeProbeResolution { [MetaMember("mVal")] public ProbeResolution Val { get; set; } } - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public class EnlightenCubemapSettings { [MetaMember("mFaceWidth")] @@ -42,7 +42,7 @@ public struct EnlightenAdaptiveProbeVolumeSettings { } - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public struct EnumeQuality { [MetaMember("mVal")] @@ -57,7 +57,7 @@ public struct EnlightenAutoProbeVolumeSettings { } - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public struct EnlightenLightSettings { [MetaMember("mEnlightenSaturation")] @@ -70,7 +70,7 @@ public struct EnlightenLightSettings public bool CastDynamicEnlightenShadows { get; set; } } - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public class EnlightenPrimitiveSettings { [MetaMember("mSystemId")] @@ -86,21 +86,21 @@ public class EnlightenPrimitiveSettings public EnumeQualityWithDefault EnlightenQuality { get; set; } } - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public struct EnumeInstanceType { [MetaMember("mVal")] public InstanceType Val { get; set; } } - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public struct EnumeUpdateMethod { [MetaMember("mVal")] public UpdateMethod Val { get; set; } } - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public struct EnumeQualityWithDefault { [MetaMember("mVal")] @@ -158,7 +158,7 @@ public struct EnumeSimplifyMode { } - [MetaClassSerializerGlobal(typeof(EnumSerializer))] + [MetaSerializer(typeof(EnumSerializer))] public enum InstanceType { // InstanceType_ @@ -170,7 +170,7 @@ public enum InstanceType Disabled = 0x5, } - [MetaClassSerializerGlobal(typeof(EnumSerializer))] + [MetaSerializer(typeof(EnumSerializer))] public enum UpdateMethod { // UpdateMethod_ @@ -179,7 +179,7 @@ public enum UpdateMethod Auto = 0x2, } - [MetaClassSerializerGlobal(typeof(EnumSerializer))] + [MetaSerializer(typeof(EnumSerializer))] public enum QualityWithDefault { // QualityWithDefault_ @@ -191,7 +191,7 @@ public enum QualityWithDefault UseDefault = 0x5, } - [MetaClassSerializerGlobal(typeof(EnumSerializer))] + [MetaSerializer(typeof(EnumSerializer))] public enum ProbeResolution { // ProbeResolution_ @@ -201,7 +201,7 @@ public enum ProbeResolution ProbeResolution_1_8 = 0x3, } - [MetaClassSerializerGlobal(typeof(EnumSerializer))] + [MetaSerializer(typeof(EnumSerializer))] public enum Quality { // Quality_ @@ -211,4 +211,4 @@ public enum Quality High = 3, Auto = 4, } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Flags.cs b/src/TelltaleToolKit/T3Types/Flags.cs index dab1cc5..f80cb06 100644 --- a/src/TelltaleToolKit/T3Types/Flags.cs +++ b/src/TelltaleToolKit/T3Types/Flags.cs @@ -1,10 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct Flags { // TODO: Potentially migrate to C# enum flags. @@ -36,4 +36,4 @@ public struct Flags public static Flags operator &(Flags a, Flags b) => new Flags(a.Data & b.Data); public static Flags operator ^(Flags a, Flags b) => new Flags(a.Data ^ b.Data); public static Flags operator ~(Flags a) => new Flags(~a.Data); -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Fonts/Font.cs b/src/TelltaleToolKit/T3Types/Fonts/Font.cs index eb6517c..3bb7391 100644 --- a/src/TelltaleToolKit/T3Types/Fonts/Font.cs +++ b/src/TelltaleToolKit/T3Types/Fonts/Font.cs @@ -1,12 +1,12 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Mathematics; using TelltaleToolKit.T3Types.Textures; namespace TelltaleToolKit.T3Types.Fonts; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class Font { [MetaMember("mName")] @@ -51,7 +51,7 @@ public class Font [MetaMember("mPreferredPointSizes")] public List PreferredPointSizes { get; set; } - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public class GlyphInfo { [MetaMember("mTexturePage")] @@ -84,4 +84,4 @@ public class GlyphInfo public class FontCreateParam { } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Handle.cs b/src/TelltaleToolKit/T3Types/Handle.cs index 6362fbb..be5277a 100644 --- a/src/TelltaleToolKit/T3Types/Handle.cs +++ b/src/TelltaleToolKit/T3Types/Handle.cs @@ -1,6 +1,5 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Binary; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; namespace TelltaleToolKit.T3Types; @@ -22,10 +21,10 @@ public class HandleBase // public Symbol ObjectName; public HandleObjectInfo ObjectInfo = new(); - [MetaClassSerializerGlobal(typeof(HandleBaseSerializer))] - public class HandleBaseSerializer : MetaClassSerializer + [MetaSerializer(typeof(HandleBaseSerializer))] + public class HandleBaseSerializer : MetaSerializer { - public override void PreSerialize(ref HandleBase obj, MetaStream stream, MetaClassType? type = null) + public override void PreSerialize(ref HandleBase? obj, MetaStream stream, MetaClassType? type = null) { if (obj is null) { @@ -54,7 +53,7 @@ public override string ToString() } } -[MetaClassSerializerGlobal(typeof(HandleSerializer<>), typeof(Handle<>))] +[MetaSerializer(typeof(HandleSerializer<>), typeof(Handle<>))] public class Handle : HandleBase { } @@ -63,9 +62,9 @@ public class HandleLock : Handle { } -public class HandleSerializer : MetaClassSerializer> +public class HandleSerializer : MetaSerializer> { - public override void PreSerialize(ref Handle obj, MetaStream stream, MetaClassType? type = null) + public override void PreSerialize(ref Handle? obj, MetaStream stream, MetaClassType? type = null) { if (obj is null) obj = new Handle(); diff --git a/src/TelltaleToolKit/T3Types/InputMaps/InputCode.cs b/src/TelltaleToolKit/T3Types/InputMaps/InputCode.cs index 0bfd5ae..dbbe314 100644 --- a/src/TelltaleToolKit/T3Types/InputMaps/InputCode.cs +++ b/src/TelltaleToolKit/T3Types/InputMaps/InputCode.cs @@ -1,10 +1,10 @@ -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.InputMaps; -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum InputCode { - -} \ No newline at end of file + +} diff --git a/src/TelltaleToolKit/T3Types/InputMaps/InputMapper.cs b/src/TelltaleToolKit/T3Types/InputMaps/InputMapper.cs index 0a61e97..bffb8a9 100644 --- a/src/TelltaleToolKit/T3Types/InputMaps/InputMapper.cs +++ b/src/TelltaleToolKit/T3Types/InputMaps/InputMapper.cs @@ -1,10 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.InputMaps; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class InputMapper { [MetaMember("mName")] @@ -13,7 +13,7 @@ public class InputMapper [MetaMember("mMappedEvents")] public List MappedEvents { get; set; } = []; - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public class EventMapping { [MetaMember("mInputCode")] @@ -29,7 +29,7 @@ public class EventMapping public int ControllerIndexOverride { get; set; } } - [MetaClassSerializerGlobal(typeof(EnumSerializer))] + [MetaSerializer(typeof(EnumSerializer))] public enum EventType { ForceDword = -1, @@ -42,4 +42,4 @@ public enum EventType public class RawEvent { } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Languages/Landb/LanguageDb.cs b/src/TelltaleToolKit/T3Types/Languages/Landb/LanguageDb.cs index 6b34700..258d173 100644 --- a/src/TelltaleToolKit/T3Types/Languages/Landb/LanguageDb.cs +++ b/src/TelltaleToolKit/T3Types/Languages/Landb/LanguageDb.cs @@ -1,14 +1,13 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Binary; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Common.UID; using TelltaleToolKit.T3Types.Languages.Locreg; namespace TelltaleToolKit.T3Types.Languages.Landb; // New language database files -[MetaClassSerializerGlobal(typeof(Serializer))] +[MetaSerializer(typeof(Serializer))] public class LanguageDb { [MetaMember("Baseclass_UID::Owner")] @@ -32,14 +31,14 @@ public class LanguageDb [MetaMember("mExpandedIDRanges")] public List ExpandedIdRanges { get; set; } = []; - public class Serializer : MetaClassSerializer + public class Serializer : MetaSerializer { - private static readonly DefaultClassSerializer DefaultSerializer = new(); + private static readonly MetaClassSerializer s_metaClassSerializer = new(); public override void Serialize(ref LanguageDb obj, MetaStream stream) { - DefaultSerializer.PreSerialize(ref obj, stream); - DefaultSerializer.Serialize(ref obj, stream); + s_metaClassSerializer.PreSerialize(ref obj, stream); + s_metaClassSerializer.Serialize(ref obj, stream); if (stream.Mode is MetaStreamMode.Read) { diff --git a/src/TelltaleToolKit/T3Types/Languages/Landb/LanguageRes.cs b/src/TelltaleToolKit/T3Types/Languages/Landb/LanguageRes.cs index 75fd1d6..fbf536e 100644 --- a/src/TelltaleToolKit/T3Types/Languages/Landb/LanguageRes.cs +++ b/src/TelltaleToolKit/T3Types/Languages/Landb/LanguageRes.cs @@ -1,11 +1,11 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Animations; namespace TelltaleToolKit.T3Types.Languages.Landb; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class LanguageRes { [MetaMember("mResName")] @@ -34,7 +34,7 @@ public class LanguageRes [MetaMember("mRecordingStatus")] public RecordingUtils.EnumRecordingStatus RecordingStatus { get; set; } - + [MetaMember("mFlags")] public Flags Flags { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Languages/Landb/LanguageResLocal.cs b/src/TelltaleToolKit/T3Types/Languages/Landb/LanguageResLocal.cs index ded68de..760bb71 100644 --- a/src/TelltaleToolKit/T3Types/Languages/Landb/LanguageResLocal.cs +++ b/src/TelltaleToolKit/T3Types/Languages/Landb/LanguageResLocal.cs @@ -1,10 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Languages.Landb; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class LanguageResLocal { [MetaMember("mPrefix")] @@ -15,4 +15,4 @@ public class LanguageResLocal [MetaMember("mLocalInfo")] public LocalizeInfo LocalInfo { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Languages/Landb/LanguageResProxy.cs b/src/TelltaleToolKit/T3Types/Languages/Landb/LanguageResProxy.cs index cdfa763..3045d30 100644 --- a/src/TelltaleToolKit/T3Types/Languages/Landb/LanguageResProxy.cs +++ b/src/TelltaleToolKit/T3Types/Languages/Landb/LanguageResProxy.cs @@ -1,12 +1,12 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Languages.Landb; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class LanguageResProxy { [MetaMember("mID")] public uint Id { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Languages/Landb/LocalizeInfo.cs b/src/TelltaleToolKit/T3Types/Languages/Landb/LocalizeInfo.cs index b4ff8f9..4686468 100644 --- a/src/TelltaleToolKit/T3Types/Languages/Landb/LocalizeInfo.cs +++ b/src/TelltaleToolKit/T3Types/Languages/Landb/LocalizeInfo.cs @@ -1,12 +1,12 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Languages.Landb; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class LocalizeInfo { [MetaMember("mFlags")] public Flags Flags { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Languages/Landb/ProjectDatabaseIDPair.cs b/src/TelltaleToolKit/T3Types/Languages/Landb/ProjectDatabaseIDPair.cs index 7f8a444..c60c844 100644 --- a/src/TelltaleToolKit/T3Types/Languages/Landb/ProjectDatabaseIDPair.cs +++ b/src/TelltaleToolKit/T3Types/Languages/Landb/ProjectDatabaseIDPair.cs @@ -1,15 +1,15 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Languages.Landb; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class ProjectDatabaseIdPair { [MetaMember("mProjectID")] public uint ProjectId { get; set; } - + [MetaMember("mDBID")] public int DatabaseId { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Languages/Langdb/LanguageDatabase.cs b/src/TelltaleToolKit/T3Types/Languages/Langdb/LanguageDatabase.cs index 7040284..7b99728 100644 --- a/src/TelltaleToolKit/T3Types/Languages/Langdb/LanguageDatabase.cs +++ b/src/TelltaleToolKit/T3Types/Languages/Langdb/LanguageDatabase.cs @@ -1,10 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Languages.Langdb; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class LanguageDatabase { [MetaMember("mName")] @@ -12,4 +12,4 @@ public class LanguageDatabase [MetaMember("mLanguageResources")] public Dictionary LanguageResources { get; set; } = new(); -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Languages/Langdb/LanguageResource.cs b/src/TelltaleToolKit/T3Types/Languages/Langdb/LanguageResource.cs index 8311f05..8dab41a 100644 --- a/src/TelltaleToolKit/T3Types/Languages/Langdb/LanguageResource.cs +++ b/src/TelltaleToolKit/T3Types/Languages/Langdb/LanguageResource.cs @@ -1,12 +1,12 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Animations; using TelltaleToolKit.T3Types.Voice; namespace TelltaleToolKit.T3Types.Languages.Langdb; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class LanguageResource { [MetaMember("mId")] diff --git a/src/TelltaleToolKit/T3Types/Languages/Lanreg/LanguageRegister.cs b/src/TelltaleToolKit/T3Types/Languages/Lanreg/LanguageRegister.cs index c0289e8..07cd9b6 100644 --- a/src/TelltaleToolKit/T3Types/Languages/Lanreg/LanguageRegister.cs +++ b/src/TelltaleToolKit/T3Types/Languages/Lanreg/LanguageRegister.cs @@ -1,13 +1,13 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Common.UID; namespace TelltaleToolKit.T3Types.Languages.Lanreg; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class LanguageRegister { [MetaMember("Baseclass_UID::Generator")] public Generator UIDGenerator { get; set; } = null!; -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Languages/Llm/LanguageLookupMap.cs b/src/TelltaleToolKit/T3Types/Languages/Llm/LanguageLookupMap.cs index 0eac3ee..4633ec8 100644 --- a/src/TelltaleToolKit/T3Types/Languages/Llm/LanguageLookupMap.cs +++ b/src/TelltaleToolKit/T3Types/Languages/Llm/LanguageLookupMap.cs @@ -1,18 +1,18 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Dialogs.Dlg; using TelltaleToolKit.T3Types.Mathematics; namespace TelltaleToolKit.T3Types.Languages.Llm; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class LanguageLookupMap { [MetaMember("mIDSets")] public List IdSets { get; set; } = []; - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public class DlgIdSet { [MetaMember("mIDRange")] @@ -24,4 +24,4 @@ public class DlgIdSet [MetaMember("mhDlg")] public Handle DlgReference { get; set; } = new(); } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Languages/Locreg/Localization.cs b/src/TelltaleToolKit/T3Types/Languages/Locreg/Localization.cs index 6b45bbd..a8ea3c9 100644 --- a/src/TelltaleToolKit/T3Types/Languages/Locreg/Localization.cs +++ b/src/TelltaleToolKit/T3Types/Languages/Locreg/Localization.cs @@ -1,12 +1,12 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Languages.Locreg; public class Localization { - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public class Language { [MetaMember("mName")] @@ -39,4 +39,4 @@ public class Language [MetaMember("mAudioVersionNumber")] public uint AudioVersionNumber { get; set; } } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Languages/Locreg/LocalizationRegistry.cs b/src/TelltaleToolKit/T3Types/Languages/Locreg/LocalizationRegistry.cs index 2382d64..7095d7e 100644 --- a/src/TelltaleToolKit/T3Types/Languages/Locreg/LocalizationRegistry.cs +++ b/src/TelltaleToolKit/T3Types/Languages/Locreg/LocalizationRegistry.cs @@ -1,12 +1,12 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Properties; namespace TelltaleToolKit.T3Types.Languages.Locreg; // .locreg -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class LocalizationRegistry { [MetaMember("mFlagIndexMap")] @@ -17,4 +17,4 @@ public class LocalizationRegistry [MetaMember("mToolProps")] public ToolProps ToolProps { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/LightMaps/LightType.cs b/src/TelltaleToolKit/T3Types/LightMaps/LightType.cs index 7a9778f..684dec5 100644 --- a/src/TelltaleToolKit/T3Types/LightMaps/LightType.cs +++ b/src/TelltaleToolKit/T3Types/LightMaps/LightType.cs @@ -1,11 +1,11 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.LightMaps; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct LightType { [MetaMember("mLightType")] public int Type { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/LightMaps/MeshSceneLightmapData.cs b/src/TelltaleToolKit/T3Types/LightMaps/MeshSceneLightmapData.cs index 2f7b306..4743162 100644 --- a/src/TelltaleToolKit/T3Types/LightMaps/MeshSceneLightmapData.cs +++ b/src/TelltaleToolKit/T3Types/LightMaps/MeshSceneLightmapData.cs @@ -1,14 +1,14 @@ using System.Numerics; -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.LightMaps; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class MeshSceneLightmapData { - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public class Entry { [MetaMember("mMeshName")] @@ -43,11 +43,11 @@ public class Entry } // Example enum for camera-facing type. Replace/extend as appropriate. -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum CameraFacingType { None = 0, Billboard = 1, Cylindrical = 2, Spherical = 3 -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/LightMaps/T3LightSceneInternalData.cs b/src/TelltaleToolKit/T3Types/LightMaps/T3LightSceneInternalData.cs index a6142bd..bdeb5dc 100644 --- a/src/TelltaleToolKit/T3Types/LightMaps/T3LightSceneInternalData.cs +++ b/src/TelltaleToolKit/T3Types/LightMaps/T3LightSceneInternalData.cs @@ -1,14 +1,14 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Textures; namespace TelltaleToolKit.T3Types.LightMaps; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class T3LightSceneInternalData { - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public class QualityEntry { [MetaMember("mLightmapPages")] @@ -18,7 +18,7 @@ public class QualityEntry public Handle mhStaticShadowVolumeTexture { get; set; } } - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public class LightmapPage { [MetaMember("mhTextureAtlas")] @@ -45,4 +45,4 @@ public class LightmapPage [MetaMember("mBakeVersion")] public uint BakeVersion { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/LocomotionDB.cs b/src/TelltaleToolKit/T3Types/LocomotionDB.cs index 1434473..659655b 100644 --- a/src/TelltaleToolKit/T3Types/LocomotionDB.cs +++ b/src/TelltaleToolKit/T3Types/LocomotionDB.cs @@ -1,18 +1,18 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types; //.LDB FILES // TODO: Verify these values. -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class LocomotionDb { [MetaMember("maAnimInfoList")] public Dictionary AnimInfoList { get; set; } - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public class AnimationInfo { [MetaMember("mu64TimeStamp")] @@ -59,7 +59,7 @@ public class AnimationInfo } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum Category { // Category_ @@ -74,4 +74,4 @@ public enum Category Unknown = 8, Number = 9, None = -1 -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Mathematics/BoundingBox.cs b/src/TelltaleToolKit/T3Types/Mathematics/BoundingBox.cs index 970a8be..db210e6 100644 --- a/src/TelltaleToolKit/T3Types/Mathematics/BoundingBox.cs +++ b/src/TelltaleToolKit/T3Types/Mathematics/BoundingBox.cs @@ -1,12 +1,12 @@ using System.Numerics; using System.Runtime.InteropServices; -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Mathematics; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] [StructLayout(LayoutKind.Sequential, Pack = 4)] public struct BoundingBox { @@ -15,4 +15,4 @@ public struct BoundingBox [MetaMember("mMax")] public Vector3 Max{get; set;} public override string ToString() => $"{Min}, {Max}"; -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Mathematics/Color.cs b/src/TelltaleToolKit/T3Types/Mathematics/Color.cs index 8f09ab5..e413282 100644 --- a/src/TelltaleToolKit/T3Types/Mathematics/Color.cs +++ b/src/TelltaleToolKit/T3Types/Mathematics/Color.cs @@ -1,11 +1,10 @@ using System.Runtime.InteropServices; -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Binary; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; namespace TelltaleToolKit.T3Types.Mathematics; -[MetaClassSerializerGlobal(typeof(Serializer))] +[MetaSerializer(typeof(Serializer))] [StructLayout(LayoutKind.Sequential, Pack = 4)] public struct Color { @@ -22,7 +21,7 @@ public struct Color public float A; - public class Serializer : MetaClassSerializer + public class Serializer : MetaSerializer { public override void Serialize(ref Color obj, MetaStream stream) { diff --git a/src/TelltaleToolKit/T3Types/Mathematics/Polar.cs b/src/TelltaleToolKit/T3Types/Mathematics/Polar.cs index 6101e05..3698f0f 100644 --- a/src/TelltaleToolKit/T3Types/Mathematics/Polar.cs +++ b/src/TelltaleToolKit/T3Types/Mathematics/Polar.cs @@ -1,11 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Binary; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Mathematics; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct Polar { [MetaMember("mR")] diff --git a/src/TelltaleToolKit/T3Types/Mathematics/Rect.cs b/src/TelltaleToolKit/T3Types/Mathematics/Rect.cs index 8216b2a..c3ab050 100644 --- a/src/TelltaleToolKit/T3Types/Mathematics/Rect.cs +++ b/src/TelltaleToolKit/T3Types/Mathematics/Rect.cs @@ -1,14 +1,14 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Mathematics; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct Rect { [MetaMember("left")] public int Left { get; set; } [MetaMember("right")] public int Right { get; set; } [MetaMember("top")] public int Top { get; set; } [MetaMember("bottom")] public int Bottom { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Mathematics/Sphere.cs b/src/TelltaleToolKit/T3Types/Mathematics/Sphere.cs index 8e93a6d..e3095bb 100644 --- a/src/TelltaleToolKit/T3Types/Mathematics/Sphere.cs +++ b/src/TelltaleToolKit/T3Types/Mathematics/Sphere.cs @@ -1,11 +1,11 @@ using System.Numerics; -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Mathematics; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct Sphere { [MetaMember("mCenter")] @@ -15,4 +15,4 @@ public struct Sphere public float Radius { get; set; } public override string ToString() => $"{Center}, {Radius}"; -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Mathematics/TRange.cs b/src/TelltaleToolKit/T3Types/Mathematics/TRange.cs index 1b0d9d3..09e65b8 100644 --- a/src/TelltaleToolKit/T3Types/Mathematics/TRange.cs +++ b/src/TelltaleToolKit/T3Types/Mathematics/TRange.cs @@ -1,7 +1,6 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Binary; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Mathematics; @@ -14,13 +13,13 @@ public class Range public T Max { get; set; } = default!; } -[MetaClassSerializerGlobal(typeof(RangeClassSerializer<>), typeof(Range<>))] -public class RangeClassSerializer : MetaClassSerializer> +[MetaSerializer(typeof(RangeSerializer<>), typeof(Range<>))] +public class RangeSerializer : MetaSerializer> { - private static readonly DefaultClassSerializer> DefaultSerializer = new(); + private static readonly MetaClassSerializer> s_metaClassSerializer = new(); /// - public override void PreSerialize(ref Range obj, MetaStream stream, MetaClassType? type) + public override void PreSerialize(ref Range? obj, MetaStream stream, MetaClassType? type = null) { if (stream.Mode is MetaStreamMode.Read) { @@ -31,7 +30,7 @@ public override void PreSerialize(ref Range obj, MetaStream stream, MetaClass public override void Serialize(ref Range obj, MetaStream stream) { - DefaultSerializer.PreSerialize(ref obj, stream); - DefaultSerializer.Serialize(ref obj, stream); + s_metaClassSerializer.PreSerialize(ref obj, stream); + s_metaClassSerializer.Serialize(ref obj, stream); } } diff --git a/src/TelltaleToolKit/T3Types/Mathematics/TRect.cs b/src/TelltaleToolKit/T3Types/Mathematics/TRect.cs index 1d5ec3e..a0fc2b7 100644 --- a/src/TelltaleToolKit/T3Types/Mathematics/TRect.cs +++ b/src/TelltaleToolKit/T3Types/Mathematics/TRect.cs @@ -1,11 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Binary; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Mathematics; -[MetaClassSerializerGlobal(typeof(RectClassSerializer<>), typeof(Rect<>))] +[MetaSerializer(typeof(RectSerializer<>), typeof(Rect<>))] public class Rect { [MetaMember("left")] public T Left { get; set; } = default!; @@ -16,12 +15,12 @@ public class Rect public override string ToString() => $"{Left}"; } -public class RectClassSerializer : MetaClassSerializer> +public class RectSerializer : MetaSerializer> { - private static readonly DefaultClassSerializer> DefaultSerializer = new(); + private static readonly MetaClassSerializer> s_metaClassSerializer = new(); /// - public override void PreSerialize(ref Rect obj, MetaStream stream, MetaClassType? type) + public override void PreSerialize(ref Rect? obj, MetaStream stream, MetaClassType? type = null) { if (stream.Mode is MetaStreamMode.Read) { @@ -33,6 +32,6 @@ public override void PreSerialize(ref Rect obj, MetaStream stream, MetaClassT public override void Serialize(ref Rect obj, MetaStream stream) { - DefaultSerializer.Serialize(ref obj, stream); + s_metaClassSerializer.Serialize(ref obj, stream); } } diff --git a/src/TelltaleToolKit/T3Types/Meshes/D3DMesh.cs b/src/TelltaleToolKit/T3Types/Meshes/D3DMesh.cs index f7d8e70..870d41d 100644 --- a/src/TelltaleToolKit/T3Types/Meshes/D3DMesh.cs +++ b/src/TelltaleToolKit/T3Types/Meshes/D3DMesh.cs @@ -1,8 +1,7 @@ using System.Numerics; -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Binary; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Mathematics; using TelltaleToolKit.T3Types.Meshes.T3Types; using TelltaleToolKit.T3Types.Properties; @@ -10,7 +9,7 @@ namespace TelltaleToolKit.T3Types.Meshes; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class D3DMesh { /// @@ -94,7 +93,7 @@ public class D3DMesh [MetaMember("mLocalTransformPalettes")] public List> LocalTransformPalettes { get; set; } - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public class LocalTransformEntry; @@ -125,13 +124,13 @@ public class LocalTransformEntry; [MetaMember("mToolAnimatedVertexEntries")] public List ToolAnimatedVertexEntries { get; set; } = []; - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public class AnimatedVertexEntry; [MetaMember("mToolAnimatedVertexGroupEntries")] public Dictionary ToolAnimatedVertexGroupEntries { get; set; } = new(); - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public class AnimatedVertexGroupEntry; [MetaMember("mInternalResources")] @@ -151,7 +150,7 @@ public class AnimatedVertexGroupEntry; /// /// This is a combination of T3MeshBatch and others for old games ( from Texas Hold'em to unknown). /// - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public class TriangleSet { [MetaMember("mFlags")] @@ -292,15 +291,15 @@ public class TriangleSet [MetaMember("mSubsurfaceScateringRadius")] public float SubsurfaceScateringRadius { get; set; } - [MetaClassSerializerGlobal(typeof(TriangleSetSerializer))] - public class TriangleSetSerializer : MetaClassSerializer + [MetaSerializer(typeof(TriangleSetSerializer))] + public class TriangleSetSerializer : MetaSerializer { - private static readonly DefaultClassSerializer DefaultSerializer = new(); + private static readonly MetaClassSerializer s_metaClassSerializer = new(); public override void Serialize(ref TriangleSet obj, MetaStream stream) { - DefaultSerializer.PreSerialize(ref obj, stream); - DefaultSerializer.Serialize(ref obj, stream); + s_metaClassSerializer.PreSerialize(ref obj, stream); + s_metaClassSerializer.Serialize(ref obj, stream); if (stream.Mode is MetaStreamMode.Write) { @@ -323,7 +322,7 @@ public override void Serialize(ref TriangleSet obj, MetaStream stream) /// /// This is for old games where bones were embedded inside the mesh. /// - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public class PaletteEntry { [MetaMember("mBoneName")] @@ -345,15 +344,15 @@ public class PaletteEntry public int SkeletonIndex { get; set; } } - [MetaClassSerializerGlobal(typeof(Serializer))] - public class Serializer : MetaClassSerializer + [MetaSerializer(typeof(Serializer))] + public class Serializer : MetaSerializer { - private static readonly DefaultClassSerializer DefaultSerializer = new(); + private static readonly MetaClassSerializer s_metaClassSerializer = new(); public override void Serialize(ref D3DMesh obj, MetaStream stream) { - DefaultSerializer.PreSerialize(ref obj, stream); - DefaultSerializer.Serialize(ref obj, stream); + s_metaClassSerializer.PreSerialize(ref obj, stream); + s_metaClassSerializer.Serialize(ref obj, stream); if (stream.Mode is MetaStreamMode.Write) { @@ -663,7 +662,7 @@ private static void SerializeInternalResources(ref D3DMesh obj, MetaStream strea stream.BeginBlock(); - MetaClassSerializer serializer = Toolkit.Instance.GetSerializer(typeSymbol.LinkingType); + MetaSerializer serializer = Toolkit.Instance.GetSerializer(typeSymbol.LinkingType); serializer.PreSerialize(ref propertyValue, stream, typeSymbol); @@ -749,10 +748,10 @@ public enum MeshFlags } - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public class VertexAnimation; - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public class Texture { [MetaMember("mName")] @@ -777,10 +776,10 @@ public class Texture public float AverageObjAreaPerUVArea { get; set; } } - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public class SkinningEntry; - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public class BoneEntry; public PropertySet? GetMaterialPropertySet(int index) diff --git a/src/TelltaleToolKit/T3Types/Meshes/T3Types/BlendMode.cs b/src/TelltaleToolKit/T3Types/Meshes/T3Types/BlendMode.cs index 4742369..27b5235 100644 --- a/src/TelltaleToolKit/T3Types/Meshes/T3Types/BlendMode.cs +++ b/src/TelltaleToolKit/T3Types/Meshes/T3Types/BlendMode.cs @@ -1,17 +1,17 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Meshes.T3Types; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct BlendMode { [MetaMember("mVal")] public T3BlendMode Val {get;set;} } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum T3BlendMode { // eBlendMode_ @@ -31,4 +31,4 @@ public enum T3BlendMode AddInvAlphaTest = 12, MultiplyAlphaTest = 13, MultiplyInvAlphaTest = 14, -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Meshes/T3Types/EnumT3MaterialLightModelType.cs b/src/TelltaleToolKit/T3Types/Meshes/T3Types/EnumT3MaterialLightModelType.cs index b5c2a75..404e2c6 100644 --- a/src/TelltaleToolKit/T3Types/Meshes/T3Types/EnumT3MaterialLightModelType.cs +++ b/src/TelltaleToolKit/T3Types/Meshes/T3Types/EnumT3MaterialLightModelType.cs @@ -1,17 +1,17 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Meshes.T3Types; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct EnumT3MaterialLightModelType { [MetaMember("mVal")] public T3MaterialLightModelType Val { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum T3MaterialLightModelType { // eMaterialLightModel_ @@ -31,4 +31,4 @@ public enum T3MaterialLightModelType DiffuseNoDirection = 0xC, HybridHair = 0xD, Count = 0xE, -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Meshes/T3Types/EnumT3MaterialNormalSpaceType.cs b/src/TelltaleToolKit/T3Types/Meshes/T3Types/EnumT3MaterialNormalSpaceType.cs index 4ab1797..329d81d 100644 --- a/src/TelltaleToolKit/T3Types/Meshes/T3Types/EnumT3MaterialNormalSpaceType.cs +++ b/src/TelltaleToolKit/T3Types/Meshes/T3Types/EnumT3MaterialNormalSpaceType.cs @@ -1,20 +1,20 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Meshes.T3Types; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct EnumT3MaterialNormalSpaceType { [MetaMember("mVal")] public T3MaterialNormalSpaceType Val { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum T3MaterialNormalSpaceType { // eMaterialNormalSpace_ Tangent = 0x0, World = 0x1, -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Meshes/T3Types/GFXPlatformAttributeParams.cs b/src/TelltaleToolKit/T3Types/Meshes/T3Types/GFXPlatformAttributeParams.cs index 804a50f..6310cb2 100644 --- a/src/TelltaleToolKit/T3Types/Meshes/T3Types/GFXPlatformAttributeParams.cs +++ b/src/TelltaleToolKit/T3Types/Meshes/T3Types/GFXPlatformAttributeParams.cs @@ -1,10 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Meshes.T3Types; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class GFXPlatformAttributeParams { [MetaMember("mAttribute")] @@ -26,7 +26,7 @@ public class GFXPlatformAttributeParams public uint BufferIndex { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum GFXPlatformVertexFrequency { // eGFXPlatformFrequency_ @@ -34,7 +34,7 @@ public enum GFXPlatformVertexFrequency PerInstance = 0x1, } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum GFXPlatformVertexAttribute { // eGFXPlatformAttribute_ @@ -46,4 +46,4 @@ public enum GFXPlatformVertexAttribute BlendIndex = 4, Color = 5, TexCoord = 6, -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3GFXBuffer.cs b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3GFXBuffer.cs index 9ae1d63..3c96c5d 100644 --- a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3GFXBuffer.cs +++ b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3GFXBuffer.cs @@ -1,11 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Binary; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Meshes.T3Types; -[MetaClassSerializerGlobal(typeof(Serializer))] +[MetaSerializer(typeof(Serializer))] public class T3GFXBuffer { // TODO: Merge with T3MeshBuffer @@ -31,14 +30,14 @@ public class T3GFXBuffer // cpu buffer public byte[] Buffer { get; set; } = []; - public class Serializer : MetaClassSerializer + public class Serializer : MetaSerializer { - private static readonly DefaultClassSerializer DefaultSerializer = new(); + private static readonly MetaClassSerializer s_metaClassSerializer = new(); public override void Serialize(ref T3GFXBuffer obj, MetaStream stream) { - DefaultSerializer.PreSerialize(ref obj, stream); - DefaultSerializer.Serialize(ref obj, stream); + s_metaClassSerializer.PreSerialize(ref obj, stream); + s_metaClassSerializer.Serialize(ref obj, stream); // I have a slightly different implementation // Telltale's meta serializer only applies to write-only streams @@ -60,7 +59,7 @@ public override void Serialize(ref T3GFXBuffer obj, MetaStream stream) } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum GFXPlatformResourceUsage { // eGFXPlatformUsage_ @@ -73,7 +72,7 @@ public enum GFXPlatformResourceUsage CPUWriteStaging = 0x6, } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum GFXPlatformBufferUsage { // eGFXPlatformBuffer_ diff --git a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3GFXVertexState.cs b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3GFXVertexState.cs index 27823b1..678e93b 100644 --- a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3GFXVertexState.cs +++ b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3GFXVertexState.cs @@ -1,11 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Binary; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Meshes.T3Types; -[MetaClassSerializerGlobal(typeof(Serializer))] +[MetaSerializer(typeof(Serializer))] public class T3GFXVertexState { // TODO: Merge with T3MeshVertexState, old games use it. @@ -26,14 +25,14 @@ public class T3GFXVertexState public List IndexBuffer { get; set; } = []; public List VertexBuffer { get; set; } = []; - public class Serializer : MetaClassSerializer + public class Serializer : MetaSerializer { - private static readonly DefaultClassSerializer DefaultSerializer = new(); + private static readonly MetaClassSerializer s_metaClassSerializer = new(); public override void Serialize(ref T3GFXVertexState obj, MetaStream stream) { - DefaultSerializer.PreSerialize(ref obj, stream); - DefaultSerializer.Serialize(ref obj, stream); + s_metaClassSerializer.PreSerialize(ref obj, stream); + s_metaClassSerializer.Serialize(ref obj, stream); MetaClass? desc = stream.GetMetaClass(typeof(T3GFXVertexState)); diff --git a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3IndexBuffer.cs b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3IndexBuffer.cs index 97f948c..564107b 100644 --- a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3IndexBuffer.cs +++ b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3IndexBuffer.cs @@ -1,14 +1,13 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Binary; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Meshes.T3Types; /// /// Old name - D3DIndexBuffer /// -[MetaClassSerializerGlobal(typeof(T3IndexBufferSerializer))] +[MetaSerializer(typeof(T3IndexBufferSerializer))] public class T3IndexBuffer { [MetaMember("mbLocked")] @@ -31,14 +30,14 @@ public class T3IndexBuffer public byte[] Buffer { get; set; } = []; - [MetaClassSerializerGlobal(typeof(T3IndexBufferSerializer))] - public class T3IndexBufferSerializer : MetaClassSerializer + [MetaSerializer(typeof(T3IndexBufferSerializer))] + public class T3IndexBufferSerializer : MetaSerializer { - private static readonly DefaultClassSerializer DefaultSerializer = new(); + private static readonly MetaClassSerializer s_metaClassSerializer = new(); public override void Serialize(ref T3IndexBuffer obj, MetaStream stream) { - DefaultSerializer.Serialize(ref obj, stream); + s_metaClassSerializer.Serialize(ref obj, stream); if (stream.Mode is MetaStreamMode.Write) { @@ -63,7 +62,7 @@ public override void Serialize(ref T3IndexBuffer obj, MetaStream stream) } } -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class T3VertexComponent { [MetaMember("mOffset")] @@ -75,7 +74,7 @@ public class T3VertexComponent [MetaMember("mType")] public EnumType Type { get; set; } - [MetaClassSerializerGlobal(typeof(EnumSerializer))] + [MetaSerializer(typeof(EnumSerializer))] public enum EnumType { VTypeNone = 0, VTypeFloat = 1, @@ -102,11 +101,11 @@ public enum EnumType { // public byte[] IndexBufferData = []; // // [DataSerializerGlobal(typeof(D3DIndexBufferSerializer))] -// public class D3DIndexBufferSerializer : MetaClassSerializer +// public class D3DIndexBufferSerializer : MetaSerializer // { // public override void Serialize(ref D3DIndexBuffer obj, MetaStream stream, MetaClass desc) // { -// new DefaultClassSerializer().Serialize(ref obj, stream, desc); +// new MetaClassSerializer().Serialize(ref obj, stream, desc); // // if (stream.Mode is MetaStreamMode.Write) // { diff --git a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MaterialCompiledData.cs b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MaterialCompiledData.cs index 0e1dc81..f4f8c71 100644 --- a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MaterialCompiledData.cs +++ b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MaterialCompiledData.cs @@ -1,10 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Meshes.T3Types; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class T3MaterialCompiledData { [MetaMember("mParameters")] @@ -96,7 +96,7 @@ public class T3MaterialCompiledData public uint PreShaderParameterBufferScalarSize { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum T3MaterialChannelType { // eMaterialChannel_ @@ -148,10 +148,10 @@ public enum T3MaterialChannelType TexCoordCount = 0x4, } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum T3MaterialQualityType { High = 0, Low = 1, Lowest = 2 -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MaterialData.cs b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MaterialData.cs index bd6ee1c..4a1c620 100644 --- a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MaterialData.cs +++ b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MaterialData.cs @@ -1,12 +1,11 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Binary; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.LightMaps; namespace TelltaleToolKit.T3Types.Meshes.T3Types; -[MetaClassSerializerGlobal(typeof(Serializer))] +[MetaSerializer(typeof(Serializer))] public class T3MaterialData { [MetaMember("mMaterialName")] @@ -42,13 +41,12 @@ public class T3MaterialData [MetaMember("mCompiledData2")] public List CompiledData2 { get; set; } - public class Serializer : MetaClassSerializer + public class Serializer : MetaSerializer { - private static readonly DefaultClassSerializer DefaultSerializer = new(); + private static readonly MetaClassSerializer s_metaClassSerializer = new(); - public override void PreSerialize(ref T3MaterialData obj, MetaStream stream, MetaClassType? type = null) + public override void PreSerialize(ref T3MaterialData? obj, MetaStream stream, MetaClassType? type = null) { - DefaultSerializer.PreSerialize(ref obj, stream); if (obj is null) { obj = new T3MaterialData(); @@ -57,7 +55,7 @@ public override void PreSerialize(ref T3MaterialData obj, MetaStream stream, Met public override void Serialize(ref T3MaterialData obj, MetaStream stream) { - DefaultSerializer.Serialize(ref obj, stream); + s_metaClassSerializer.Serialize(ref obj, stream); MetaClass? classDescription = stream.GetMetaClass(typeof(T3MaterialData)); diff --git a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MaterialDomainType.cs b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MaterialDomainType.cs index e3ce155..5ab9198 100644 --- a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MaterialDomainType.cs +++ b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MaterialDomainType.cs @@ -1,12 +1,12 @@ -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Meshes.T3Types; -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum T3MaterialDomainType { - // eMaterialDomain_ + // eMaterialDomain_ None = -1, Mesh = 0x0, Particle = 0x1, @@ -14,4 +14,4 @@ public enum T3MaterialDomainType Post = 0x3, ExportMeshShader = 0x4, Count = 0x5, -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MaterialEnlightenPrecomputeParams.cs b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MaterialEnlightenPrecomputeParams.cs index 43ef6d9..7b9390b 100644 --- a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MaterialEnlightenPrecomputeParams.cs +++ b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MaterialEnlightenPrecomputeParams.cs @@ -1,15 +1,15 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Meshes.T3Types; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class T3MaterialEnlightenPrecomputeParams { [MetaMember("mIndirectReflectivity")] public float IndirectReflectivity { get; set; }= 1.0f; [MetaMember("mIndirectTransparency")] - public float IndirectTransparency { get; set; } -} \ No newline at end of file + public float IndirectTransparency { get; set; } +} diff --git a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MaterialNestedMaterial.cs b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MaterialNestedMaterial.cs index 13cf2f8..3ab3c3a 100644 --- a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MaterialNestedMaterial.cs +++ b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MaterialNestedMaterial.cs @@ -1,14 +1,14 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Properties; namespace TelltaleToolKit.T3Types.Meshes.T3Types; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class T3MaterialNestedMaterial { [MetaMember("mhMaterial")] public Handle Material { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MaterialParameter.cs b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MaterialParameter.cs index ee5165f..1d453cd 100644 --- a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MaterialParameter.cs +++ b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MaterialParameter.cs @@ -1,10 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Meshes.T3Types; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class T3MaterialParameter { [MetaMember("mName")] @@ -21,16 +21,16 @@ public class T3MaterialParameter [MetaMember("mScalarOffset")] public int ScalarOffset { get; set; } - + [MetaMember("mScalarOffset[0]")] public int ScalarOffset0 { get; set; } - + [MetaMember("mScalarOffset[1]")] public int ScalarOffset1{ get; set; } - + [MetaMember("mScalarOffset[2]")] public int ScalarOffset2{ get; set; } - + [MetaMember("mScalarOffset[3]")] public int ScalarOffset3 { get; set; } @@ -41,7 +41,7 @@ public class T3MaterialParameter public int NestedMaterialIndex { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum T3MaterialValueType { // eMaterialValue_ @@ -53,7 +53,7 @@ public enum T3MaterialValueType Channels = 0x4, } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum T3MaterialPropertyType { // eMaterialProperty_ @@ -89,4 +89,4 @@ public enum T3MaterialPropertyType HairTerms = 0x1C, ClothOffsetScale = 0x1D, LightWrap = 0x1E, -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MaterialPassData.cs b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MaterialPassData.cs index f23040c..43127ce 100644 --- a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MaterialPassData.cs +++ b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MaterialPassData.cs @@ -1,10 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Meshes.T3Types; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class T3MaterialPassData { [MetaMember("mPassType")] @@ -17,10 +17,10 @@ public class T3MaterialPassData public ulong MaterialCrc { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum T3MaterialPassType { - // + // FirstMesh = 0x0, Main = 0x0, PreZ = 0x1, @@ -52,4 +52,4 @@ public enum T3MaterialPassType MeshCount = 0xC, ParticleCount = 0x3, DecalCount = 0x3, -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MaterialPreShader.cs b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MaterialPreShader.cs index a044d8e..9a96d0a 100644 --- a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MaterialPreShader.cs +++ b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MaterialPreShader.cs @@ -1,10 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Meshes.T3Types; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class T3MaterialPreShader { [MetaMember("mValueType")] @@ -30,4 +30,4 @@ public class T3MaterialPreShader [MetaMember("mScalarParameterOffset[3]")] public int ScalarParameterOffset3 { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MaterialRequirements.cs b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MaterialRequirements.cs index 6b1e757..ab42672 100644 --- a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MaterialRequirements.cs +++ b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MaterialRequirements.cs @@ -1,10 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Meshes.T3Types; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class T3MaterialRequirements { [MetaMember("mPasses")] @@ -15,4 +15,4 @@ public class T3MaterialRequirements [MetaMember("mInputs")] public BitSetBase Inputs { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MaterialRuntimeProperty.cs b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MaterialRuntimeProperty.cs index eeb72f8..c43ea04 100644 --- a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MaterialRuntimeProperty.cs +++ b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MaterialRuntimeProperty.cs @@ -1,10 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Meshes.T3Types; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class T3MaterialRuntimeProperty { [MetaMember("mName")] @@ -12,4 +12,4 @@ public class T3MaterialRuntimeProperty [MetaMember("mRuntimeName")] public Symbol RuntimeName { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MaterialStaticParameter.cs b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MaterialStaticParameter.cs index bec9659..d29ef1b 100644 --- a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MaterialStaticParameter.cs +++ b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MaterialStaticParameter.cs @@ -1,10 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Meshes.T3Types; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class T3MaterialStaticParameter { [MetaMember("mName")] @@ -12,4 +12,4 @@ public class T3MaterialStaticParameter [MetaMember("mNestedMaterialIndex")] public int NestedMaterialIndex { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MaterialTexture.cs b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MaterialTexture.cs index eccefb1..5323903 100644 --- a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MaterialTexture.cs +++ b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MaterialTexture.cs @@ -1,11 +1,11 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Textures.T3Types; namespace TelltaleToolKit.T3Types.Meshes.T3Types; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class T3MaterialTexture { [MetaMember("mName")] @@ -37,4 +37,4 @@ public class T3MaterialTexture [MetaMember("mNestedMaterialIndex")] public int NestedMaterialIndex { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MaterialTextureParam.cs b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MaterialTextureParam.cs index fe3e94e..564514b 100644 --- a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MaterialTextureParam.cs +++ b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MaterialTextureParam.cs @@ -1,10 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Meshes.T3Types; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class T3MaterialTextureParam { [MetaMember("mParamType")] @@ -20,10 +20,10 @@ public class T3MaterialTextureParam public int ScalarOffset { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum T3MaterialTextureParamType { // eMaterialTextureParam_ None = -1, Unused = 0, -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MaterialTransform2D.cs b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MaterialTransform2D.cs index f1aae5c..2414740 100644 --- a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MaterialTransform2D.cs +++ b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MaterialTransform2D.cs @@ -1,6 +1,6 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Meshes.T3Types; @@ -8,7 +8,7 @@ namespace TelltaleToolKit.T3Types.Meshes.T3Types; // I am probably going to add SArrays (unfortunately) // Maybe check if the value contains "[...]"? // Or maybe leave it as it is. -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class T3MaterialTransform2D { [MetaMember("mParameterPrefix")] @@ -21,14 +21,14 @@ public class T3MaterialTransform2D public int ScalarOffset0 { get; set; } [MetaMember("mScalarOffset1")] - public int ScalarOffset1 { get; set; } - + public int ScalarOffset1 { get; set; } + [MetaMember("mScalarOffset0[0]")] public int ScalarOffset00 { get; set; } [MetaMember("mScalarOffset1[0]")] - public int ScalarOffset10 { get; set; } - + public int ScalarOffset10 { get; set; } + [MetaMember("mScalarOffset0[1]")] public int ScalarOffset01 { get; set; } [MetaMember("mScalarOffset0[2]")] @@ -36,7 +36,7 @@ public class T3MaterialTransform2D [MetaMember("mScalarOffset0[3]")] public int ScalarOffset03 { get; set; } [MetaMember("mScalarOffset1[1]")] - public int ScalarOffset11 { get; set; } + public int ScalarOffset11 { get; set; } [MetaMember("mScalarOffset1[2]")] public int ScalarOffset12 { get; set; } [MetaMember("mScalarOffset1[3]")] @@ -49,4 +49,4 @@ public class T3MaterialTransform2D [MetaMember("mNestedMaterialIndex")] public int NestedMaterialIndex { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshBatch.cs b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshBatch.cs index be9421a..4a6c3a9 100644 --- a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshBatch.cs +++ b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshBatch.cs @@ -1,11 +1,11 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Mathematics; namespace TelltaleToolKit.T3Types.Meshes.T3Types; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class T3MeshBatch { [MetaMember("mBoundingBox")] @@ -49,4 +49,4 @@ public class T3MeshBatch [MetaMember("mBonePaletteIndex")] public uint BonePaletteIndex { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshBoneEntry.cs b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshBoneEntry.cs index 2788d99..1fd1f6c 100644 --- a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshBoneEntry.cs +++ b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshBoneEntry.cs @@ -1,11 +1,11 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Mathematics; namespace TelltaleToolKit.T3Types.Meshes.T3Types; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class T3MeshBoneEntry { [MetaMember("mBoneName")] @@ -19,4 +19,4 @@ public class T3MeshBoneEntry [MetaMember("mNumVerts")] public int NumVerts { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshCPUSkinningData.cs b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshCPUSkinningData.cs index 067106b..203a9c2 100644 --- a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshCPUSkinningData.cs +++ b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshCPUSkinningData.cs @@ -1,10 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Meshes.T3Types; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class T3MeshCPUSkinningData { [MetaMember("mPositionFormat")] @@ -35,7 +35,7 @@ public class T3MeshCPUSkinningData public BinaryBuffer Data { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum GFXPlatformFormat { // eGFXPlatformFormat_ @@ -82,4 +82,4 @@ public enum GFXPlatformFormat SN10x3_SN2 = 0x28, UN10x3_UN2 = 0x29, // 41 D3DCOLOR = 0x2A, -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshData.cs b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshData.cs index 0cade51..f858fdd 100644 --- a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshData.cs +++ b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshData.cs @@ -1,17 +1,16 @@ using System.Numerics; -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Binary; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Mathematics; namespace TelltaleToolKit.T3Types.Meshes.T3Types; -[MetaClassSerializerGlobal(typeof(Serializer))] +[MetaSerializer(typeof(Serializer))] public class T3MeshData { [Flags] - [MetaClassSerializerGlobal(typeof(EnumSerializer))] + [MetaSerializer(typeof(EnumSerializer))] public enum MeshFlags { eDeformable = 0x1, @@ -92,15 +91,15 @@ public enum MeshFlags public T3MeshCPUSkinningData CPUSkinningData { get; set; } public T3MeshTexCoordTransform[] TexCoordTransform { get; set; } = [new(), new(), new(), new()]; - public class Serializer : MetaClassSerializer + public class Serializer : MetaSerializer { - private static readonly DefaultClassSerializer DefaultSerializer = new(); + private static readonly MetaClassSerializer s_metaClassSerializer = new(); public override void Serialize(ref T3MeshData obj, MetaStream stream) { - DefaultSerializer.PreSerialize(ref obj, stream); - DefaultSerializer.Serialize(ref obj, stream); + s_metaClassSerializer.PreSerialize(ref obj, stream); + s_metaClassSerializer.Serialize(ref obj, stream); if (stream.Mode is MetaStreamMode.Write) { @@ -182,7 +181,7 @@ public override void Serialize(ref T3MeshData obj, MetaStream stream) } } -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class T3MeshBonePaletteEntry { [MetaMember("mBoneName")] diff --git a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshEffectPreload.cs b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshEffectPreload.cs index cf39308..92f9223 100644 --- a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshEffectPreload.cs +++ b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshEffectPreload.cs @@ -1,10 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Meshes.T3Types; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class T3MeshEffectPreload { [MetaMember("mEffectQuality")] @@ -15,4 +15,4 @@ public class T3MeshEffectPreload [MetaMember("mTotalEffectCount")] public uint TotalEffectCount { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshEffectPreloadDynamicFeatures.cs b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshEffectPreloadDynamicFeatures.cs index 5861521..ceb45f5 100644 --- a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshEffectPreloadDynamicFeatures.cs +++ b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshEffectPreloadDynamicFeatures.cs @@ -1,10 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Meshes.T3Types; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class T3MeshEffectPreloadDynamicFeatures { [MetaMember("mDynamicFeatures")] @@ -12,4 +12,4 @@ public class T3MeshEffectPreloadDynamicFeatures [MetaMember("mPriority")] public int Priority { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshEffectPreloadEntry.cs b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshEffectPreloadEntry.cs index ca3bfcf..a4167e7 100644 --- a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshEffectPreloadEntry.cs +++ b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshEffectPreloadEntry.cs @@ -1,10 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Meshes.T3Types; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class T3MeshEffectPreloadEntry { [MetaMember("mEffectType")] @@ -25,7 +25,7 @@ public class T3MeshEffectPreloadEntry // The effect type is serialized as a regular uint. // Probably because there are different effect for each platform? // But then - there would have been metaflags for it. -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum T3EffectType { // WDC_eEffect_ @@ -220,4 +220,4 @@ public enum T3EffectType CS_ComputeAsyncTest = 0x0DA, Count = 0x0DB, WDC_eEffect_None = -1, -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshEndianType.cs b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshEndianType.cs index f7bc5ef..965b9a2 100644 --- a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshEndianType.cs +++ b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshEndianType.cs @@ -1,13 +1,13 @@ -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Meshes.T3Types; -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum T3MeshEndianType { // eMeshEndian_ Default = 0, Swap = 1, SwapBytesAsWord = 2 -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshLOD.cs b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshLOD.cs index 72d7e4f..018b339 100644 --- a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshLOD.cs +++ b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshLOD.cs @@ -1,11 +1,11 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Mathematics; namespace TelltaleToolKit.T3Types.Meshes.T3Types; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class T3MeshLOD { // Michonne for e.g. uses a DCArray of batches. In new games they only use 2. @@ -13,7 +13,7 @@ public class T3MeshLOD public List Batches { get; set; } = []; // Default [MetaMember("mBatches[0]")] - public List Batches1 { get; set; } = []; // Default + public List Batches1 { get; set; } = []; // Default [MetaMember("mBatches[1]")] public List Batches2 { get; set; } = []; // Shadow @@ -59,4 +59,4 @@ public class T3MeshLOD [MetaMember("mBones")] public List Bones { get; set; } = []; -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshLocalTransformEntry.cs b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshLocalTransformEntry.cs index 8341567..82a624e 100644 --- a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshLocalTransformEntry.cs +++ b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshLocalTransformEntry.cs @@ -1,11 +1,11 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Skeletons; namespace TelltaleToolKit.T3Types.Meshes.T3Types; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class T3MeshLocalTransformEntry { [MetaMember("mTransform")] @@ -15,11 +15,11 @@ public class T3MeshLocalTransformEntry public T3CameraFacingType CameraFacingType { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum T3CameraFacingType { // eCameraFacing_ None = 0, Enable = 1, EnableY = 2, EnableLocalY = 3 -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshMaterial.cs b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshMaterial.cs index 6213845..0f42ecb 100644 --- a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshMaterial.cs +++ b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshMaterial.cs @@ -1,12 +1,12 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Mathematics; using TelltaleToolKit.T3Types.Properties; namespace TelltaleToolKit.T3Types.Meshes.T3Types; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class T3MeshMaterial { [MetaMember("mhMaterial")] @@ -26,4 +26,4 @@ public class T3MeshMaterial [MetaMember("mFlags")] public Flags Flags { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshMaterialOverride.cs b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshMaterialOverride.cs index 7232bbd..c6bac0f 100644 --- a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshMaterialOverride.cs +++ b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshMaterialOverride.cs @@ -1,11 +1,11 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Properties; namespace TelltaleToolKit.T3Types.Meshes.T3Types; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class T3MeshMaterialOverride { @@ -14,4 +14,4 @@ public class T3MeshMaterialOverride [MetaMember("mMaterialIndex")] public uint MaterialIndex { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshPropertyEntry.cs b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshPropertyEntry.cs index 7bf8308..31b004e 100644 --- a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshPropertyEntry.cs +++ b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshPropertyEntry.cs @@ -1,11 +1,11 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Properties; namespace TelltaleToolKit.T3Types.Meshes.T3Types; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class T3MeshPropertyEntry { @@ -20,4 +20,4 @@ public class T3MeshPropertyEntry [MetaMember("mPriority")] public int Priority { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshTexCoordTransform.cs b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshTexCoordTransform.cs index 0055ac8..7932aec 100644 --- a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshTexCoordTransform.cs +++ b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshTexCoordTransform.cs @@ -1,16 +1,16 @@ using System.Numerics; -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Meshes.T3Types; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class T3MeshTexCoordTransform { [MetaMember("mScale")] public Vector2 Scale { get; set; } = Vector2.One; - + [MetaMember("mOffset")] public Vector2 Offset { get; set; } = Vector2.Zero; -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshTexture.cs b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshTexture.cs index 8a9a3d1..2b27e35 100644 --- a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshTexture.cs +++ b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshTexture.cs @@ -1,12 +1,12 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Mathematics; using TelltaleToolKit.T3Types.Textures; namespace TelltaleToolKit.T3Types.Meshes.T3Types; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class T3MeshTexture { [MetaMember("mTextureType")] @@ -38,4 +38,4 @@ public enum T3MeshTextureType LightMap = 0, ShadowMap = 1, Count = 2, -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshTextureIndices.cs b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshTextureIndices.cs index 1d46624..e30458f 100644 --- a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshTextureIndices.cs +++ b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3MeshTextureIndices.cs @@ -1,14 +1,13 @@ -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Binary; +using TelltaleToolKit.Meta.Serialization; namespace TelltaleToolKit.T3Types.Meshes.T3Types; -[MetaClassSerializerGlobal(typeof(Serializer))] +[MetaSerializer(typeof(Serializer))] public class T3MeshTextureIndices { public int[] Index { get; set; } = [-1, -1]; // Usually 2 elements: for batch Default and for batch Shadow - public class Serializer : MetaClassSerializer + public class Serializer : MetaSerializer { public override void Serialize(ref T3MeshTextureIndices obj, MetaStream stream) { diff --git a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3OcclusionMeshBatch.cs b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3OcclusionMeshBatch.cs index cff1f4c..02725b2 100644 --- a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3OcclusionMeshBatch.cs +++ b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3OcclusionMeshBatch.cs @@ -1,10 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Meshes.T3Types; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class T3OcclusionMeshBatch { [MetaMember("mFlags")] @@ -15,4 +15,4 @@ public class T3OcclusionMeshBatch [MetaMember("mNumTriangles")] public long NumTriangles { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3OcclusionMeshData.cs b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3OcclusionMeshData.cs index 79d5ff5..2e90bc3 100644 --- a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3OcclusionMeshData.cs +++ b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3OcclusionMeshData.cs @@ -1,11 +1,11 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Mathematics; namespace TelltaleToolKit.T3Types.Meshes.T3Types; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class T3OcclusionMeshData { [MetaMember("mData")] diff --git a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3VertexBuffer.cs b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3VertexBuffer.cs index 3f9733e..d3b6e5b 100644 --- a/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3VertexBuffer.cs +++ b/src/TelltaleToolKit/T3Types/Meshes/T3Types/T3VertexBuffer.cs @@ -1,14 +1,13 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Binary; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Meshes.T3Types; /// /// Old name - D3DVertexBuffer /// -[MetaClassSerializerGlobal(typeof(T3VertexBufferSerializer))] +[MetaSerializer(typeof(T3VertexBufferSerializer))] public class T3VertexBuffer { [MetaMember("mNumVerts")] @@ -40,14 +39,14 @@ public class T3VertexBuffer public byte[] Buffer = []; - [MetaClassSerializerGlobal(typeof(T3VertexBufferSerializer))] - public class T3VertexBufferSerializer : MetaClassSerializer + [MetaSerializer(typeof(T3VertexBufferSerializer))] + public class T3VertexBufferSerializer : MetaSerializer { - private static readonly DefaultClassSerializer DefaultSerializer = new(); + private static readonly MetaClassSerializer s_metaClassSerializer = new(); public override void Serialize(ref T3VertexBuffer obj, MetaStream stream) { - DefaultSerializer.Serialize(ref obj, stream); + s_metaClassSerializer.Serialize(ref obj, stream); if (stream.Mode is MetaStreamMode.Write) { @@ -71,7 +70,7 @@ public override void Serialize(ref T3VertexBuffer obj, MetaStream stream) // Right, so D3DVertexBuffer changes to T3VertexBuffer (probably because the engine became cross-platform at the time). // Since most values are the same, I merged D3DVertexBuffer with T3VertexBuffer. -// [DataSerializerGlobal(typeof(DefaultClassSerializer))] +// [DataSerializerGlobal(typeof(MetaClassSerializer))] // public class D3DVertexBuffer // { // [MetaMember("mNumVerts")] public int NumVerts { get; set; } @@ -82,11 +81,11 @@ public override void Serialize(ref T3VertexBuffer obj, MetaStream stream) // public byte[] VertexBufferData = []; // // [DataSerializerGlobal(typeof(D3DIndexBufferSerializer))] -// public class D3DIndexBufferSerializer : MetaClassSerializer +// public class D3DIndexBufferSerializer : MetaSerializer // { // public override void Serialize(ref D3DIndexBuffer obj, MetaStream stream, MetaClass desc) // { -// new DefaultClassSerializer().Serialize(ref obj, stream, desc); +// new MetaClassSerializer().Serialize(ref obj, stream, desc); // // if (stream.Mode is MetaStreamMode.Write) // { diff --git a/src/TelltaleToolKit/T3Types/Miscellaneous/CameraFacingTypes.cs b/src/TelltaleToolKit/T3Types/Miscellaneous/CameraFacingTypes.cs index 43591cc..77affdc 100644 --- a/src/TelltaleToolKit/T3Types/Miscellaneous/CameraFacingTypes.cs +++ b/src/TelltaleToolKit/T3Types/Miscellaneous/CameraFacingTypes.cs @@ -1,20 +1,20 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Miscellaneous; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class CameraFacingTypes { [MetaMember("mCameraFacingType")] public FacingTypes CameraFacingType { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum FacingTypes { Facing = 0, FacingY = 1, FacingLocalY = 2, -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumBokehOcclusionType.cs b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumBokehOcclusionType.cs index 89087dd..95721e5 100644 --- a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumBokehOcclusionType.cs +++ b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumBokehOcclusionType.cs @@ -1,18 +1,18 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Miscellaneous; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct EnumBokehOcclusionType { [MetaMember("mVal")] public BokehOcclusionType Val { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum BokehOcclusionType { // TODO: -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumBokehQualityLevel.cs b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumBokehQualityLevel.cs index b5c8cc0..ab60d24 100644 --- a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumBokehQualityLevel.cs +++ b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumBokehQualityLevel.cs @@ -1,18 +1,18 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Miscellaneous; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct EnumBokehQualityLevel { [MetaMember("mVal")] public BokehQualityLevel Val { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum BokehQualityLevel { // TODO: -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumDOFQualityLevel.cs b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumDOFQualityLevel.cs index 60fa158..3a9dada 100644 --- a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumDOFQualityLevel.cs +++ b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumDOFQualityLevel.cs @@ -1,18 +1,18 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Miscellaneous; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct EnumDOFQualityLevel { [MetaMember("mVal")] public DOFQualityLevel Val { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum DOFQualityLevel { // TODO: -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumDepthOfFieldType.cs b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumDepthOfFieldType.cs index c283c35..b76c664 100644 --- a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumDepthOfFieldType.cs +++ b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumDepthOfFieldType.cs @@ -1,18 +1,18 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Miscellaneous; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct EnumDepthOfFieldType { [MetaMember("mVal")] public DepthOfFieldType Val { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum DepthOfFieldType { // TODO: -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumEmitterBoneSelection.cs b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumEmitterBoneSelection.cs index 7b05139..1663dbc 100644 --- a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumEmitterBoneSelection.cs +++ b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumEmitterBoneSelection.cs @@ -1,16 +1,16 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct EnumEmitterBoneSelection { [MetaMember("mVal")] public EmitterBoneSelection Val { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum EmitterBoneSelection { // TODO: -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumEmitterColorType.cs b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumEmitterColorType.cs index 62c5b5c..5d94914 100644 --- a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumEmitterColorType.cs +++ b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumEmitterColorType.cs @@ -1,18 +1,18 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Miscellaneous; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct EnumEmitterColorType { [MetaMember("mVal")] public EmitterColorType Val { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum EmitterColorType { // TODO: -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumEmitterConstraintType.cs b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumEmitterConstraintType.cs index 7e5c462..e27c2fd 100644 --- a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumEmitterConstraintType.cs +++ b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumEmitterConstraintType.cs @@ -1,18 +1,18 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Miscellaneous; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct EnumEmitterConstraintType { [MetaMember("mVal")] public EmitterConstraintType Val { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum EmitterConstraintType { // TODO: -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumEmitterParticleCountType.cs b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumEmitterParticleCountType.cs index 1af3701..a5823d2 100644 --- a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumEmitterParticleCountType.cs +++ b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumEmitterParticleCountType.cs @@ -1,18 +1,18 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Miscellaneous; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct EnumEmitterParticleCountType { [MetaMember("mVal")] public EmitterParticleCountType Val { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum EmitterParticleCountType { // TODO: -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumEmitterSpawnShape.cs b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumEmitterSpawnShape.cs index ae0a202..c8ed266 100644 --- a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumEmitterSpawnShape.cs +++ b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumEmitterSpawnShape.cs @@ -1,18 +1,18 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Miscellaneous; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct EnumEmitterSpawnShape { [MetaMember("mVal")] public EmitterSpawnShape Val { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum EmitterSpawnShape { // TODO: -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumEmitterSpriteAnimationSelection.cs b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumEmitterSpriteAnimationSelection.cs index 194fcd5..d9010fe 100644 --- a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumEmitterSpriteAnimationSelection.cs +++ b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumEmitterSpriteAnimationSelection.cs @@ -1,18 +1,18 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Miscellaneous; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct EnumEmitterSpriteAnimationSelection { [MetaMember("mVal")] public EmitterSpriteAnimationSelection Val { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum EmitterSpriteAnimationSelection { // TODO: -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumEmitterSpriteAnimationType.cs b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumEmitterSpriteAnimationType.cs index 47be10a..a74a054 100644 --- a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumEmitterSpriteAnimationType.cs +++ b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumEmitterSpriteAnimationType.cs @@ -1,18 +1,18 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Miscellaneous; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct EnumEmitterSpriteAnimationType { [MetaMember("mVal")] public EmitterSpriteAnimationType Val { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum EmitterSpriteAnimationType { // TODO: -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumEmitterTriggerEnable.cs b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumEmitterTriggerEnable.cs index 1340187..a2e1f30 100644 --- a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumEmitterTriggerEnable.cs +++ b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumEmitterTriggerEnable.cs @@ -1,18 +1,18 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Miscellaneous; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct EnumEmitterTriggerEnable { [MetaMember("mVal")] public EmitterTriggerEnable Val { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum EmitterTriggerEnable { // TODO: -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumEmittersEnableType.cs b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumEmittersEnableType.cs index 4c07ff1..7c946f0 100644 --- a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumEmittersEnableType.cs +++ b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumEmittersEnableType.cs @@ -1,18 +1,18 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Miscellaneous; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct EnumEmittersEnableType { [MetaMember("mVal")] public EmittersEnableType Val { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum EmittersEnableType { // TODO: -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumGlowQualityLevel.cs b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumGlowQualityLevel.cs index 1ba19ad..c0f552e 100644 --- a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumGlowQualityLevel.cs +++ b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumGlowQualityLevel.cs @@ -1,18 +1,18 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Miscellaneous; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct EnumGlowQualityLevel { [MetaMember("mVal")] public GlowQualityLevel Val { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum GlowQualityLevel { // TODO: -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumHBAOBlurQuality.cs b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumHBAOBlurQuality.cs index 11a2aba..4d7b713 100644 --- a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumHBAOBlurQuality.cs +++ b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumHBAOBlurQuality.cs @@ -1,18 +1,18 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Miscellaneous; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct EnumHBAOBlurQuality { [MetaMember("mVal")] public HBAOBlurQuality Val { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum HBAOBlurQuality { // TODO: -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumHBAODeinterleaving.cs b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumHBAODeinterleaving.cs index 92bf22b..0f998c8 100644 --- a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumHBAODeinterleaving.cs +++ b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumHBAODeinterleaving.cs @@ -1,18 +1,18 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Miscellaneous; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct EnumHBAODeinterleaving { [MetaMember("mVal")] public HBAODeinterleaving Val { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum HBAODeinterleaving { // TODO: -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumHBAOParticipationType.cs b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumHBAOParticipationType.cs index 9006dbd..0e1635b 100644 --- a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumHBAOParticipationType.cs +++ b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumHBAOParticipationType.cs @@ -1,18 +1,18 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Miscellaneous; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct EnumHBAOParticipationType { [MetaMember("mVal")] public HBAOParticipationType Val { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum HBAOParticipationType { // TODO: -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumHBAOPerPixelNormals.cs b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumHBAOPerPixelNormals.cs index de0d6ae..786cd22 100644 --- a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumHBAOPerPixelNormals.cs +++ b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumHBAOPerPixelNormals.cs @@ -1,18 +1,18 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Miscellaneous; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct EnumHBAOPerPixelNormals { [MetaMember("mVal")] public HBAOPerPixelNormals Val { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum HBAOPerPixelNormals { //TODO: -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumHBAOPreset.cs b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumHBAOPreset.cs index 287fc5d..210c4c4 100644 --- a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumHBAOPreset.cs +++ b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumHBAOPreset.cs @@ -1,18 +1,18 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Miscellaneous; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct EnumHBAOPreset { [MetaMember("mVal")] public HBAOPreset Val { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum HBAOPreset { // TODO: -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumHBAOQualityLevel.cs b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumHBAOQualityLevel.cs index 4ec326a..2744754 100644 --- a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumHBAOQualityLevel.cs +++ b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumHBAOQualityLevel.cs @@ -1,18 +1,18 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Miscellaneous; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct EnumHBAOQualityLevel { [MetaMember("mVal")] public HBAOQualityLevel Val { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum HBAOQualityLevel { // TODO: -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumHBAOResolution.cs b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumHBAOResolution.cs index ec32aa2..110d341 100644 --- a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumHBAOResolution.cs +++ b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumHBAOResolution.cs @@ -1,18 +1,18 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Miscellaneous; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct EnumHBAOResolution { [MetaMember("mVal")] public HBAOResolution Val { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum HBAOResolution { // TODO: -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumHTextAlignmentType.cs b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumHTextAlignmentType.cs index 61e60ce..a33315b 100644 --- a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumHTextAlignmentType.cs +++ b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumHTextAlignmentType.cs @@ -1,17 +1,17 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Miscellaneous; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct EnumHTextAlignmentType { [MetaMember("mVal")] public HTextAlignmentType Val { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum HTextAlignmentType { // eHTextAlignment_ @@ -19,4 +19,4 @@ public enum HTextAlignmentType LeftJustified = 1, Centered = 2, RightJustified = 3, -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumLightCellBlendMode.cs b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumLightCellBlendMode.cs index 43a6a9a..8dce2b7 100644 --- a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumLightCellBlendMode.cs +++ b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumLightCellBlendMode.cs @@ -1,18 +1,18 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Miscellaneous; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct EnumLightCellBlendMode { [MetaMember("mVal")] public LightCellBlendMode Val { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum LightCellBlendMode { // TODO: -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumMeshDebugRenderType.cs b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumMeshDebugRenderType.cs index 22a394b..dae2729 100644 --- a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumMeshDebugRenderType.cs +++ b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumMeshDebugRenderType.cs @@ -1,18 +1,18 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Miscellaneous; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct EnumMeshDebugRenderType { [MetaMember("mVal")] public MeshDebugRenderType Val { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum MeshDebugRenderType { // TODO: -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumParticleAffectorType.cs b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumParticleAffectorType.cs index 2669280..497bf57 100644 --- a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumParticleAffectorType.cs +++ b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumParticleAffectorType.cs @@ -1,17 +1,17 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Miscellaneous; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct EnumParticleAffectorType { [MetaMember("mVal")] public ParticleAffectorType Val { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum ParticleAffectorType { // eParticleAffectorType_ @@ -23,4 +23,4 @@ public enum ParticleAffectorType CollisionSphere = 6, CollisionBox = 7, CollisionCylinder = 8, -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumParticleGeometryType.cs b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumParticleGeometryType.cs index baaafdf..b1b0052 100644 --- a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumParticleGeometryType.cs +++ b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumParticleGeometryType.cs @@ -1,17 +1,17 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Miscellaneous; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct EnumParticleGeometryType { [MetaMember("mVal")] public ParticleGeometryType Val { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum ParticleGeometryType { // eParticleGeometry_ @@ -23,4 +23,4 @@ public enum ParticleGeometryType None = 6 // TODO: Verify if non is really number 6. I have a feeling it's 0. -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumParticlePropDriver.cs b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumParticlePropDriver.cs index 05034b7..de0fbf7 100644 --- a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumParticlePropDriver.cs +++ b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumParticlePropDriver.cs @@ -1,17 +1,17 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Miscellaneous; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct EnumParticlePropDriver { [MetaMember("mVal")] public ParticlePropDriver Val { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum ParticlePropDriver { // TODO: @@ -24,4 +24,4 @@ public enum ParticlePropDriver ePartPropDriver_KeyControl03 = 0x7, ePartPropDriver_KeyControl04 = 0x8, ePartPropDriver_DistanceToCamera = 0x9, -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumParticlePropModifier.cs b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumParticlePropModifier.cs index c835b68..2667826 100644 --- a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumParticlePropModifier.cs +++ b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumParticlePropModifier.cs @@ -1,17 +1,17 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Miscellaneous; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct EnumParticlePropModifier { [MetaMember("mVal")] public ParticlePropModifier Val { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum ParticlePropModifier { // TODO: @@ -45,4 +45,4 @@ public enum ParticlePropModifier ePartPropModifier_Geometry_Scale = 0x1B, ePartPropModifier_Enable = 0x1C, ePartPropModifier_Count = 0x1D, -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumParticleSortMode.cs b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumParticleSortMode.cs index 5b41415..b7d4a13 100644 --- a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumParticleSortMode.cs +++ b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumParticleSortMode.cs @@ -1,17 +1,17 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Miscellaneous; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct EnumParticleSortMode { [MetaMember("mVal")] public ParticleSortMode Val { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum ParticleSortMode { // eParticleSortMode_ @@ -19,4 +19,4 @@ public enum ParticleSortMode ByDistance = 0x2, YoungestFirst = 0x3, OldestFirst = 0x4, -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumRenderAntialiasType.cs b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumRenderAntialiasType.cs index c96d2c8..4d55ab7 100644 --- a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumRenderAntialiasType.cs +++ b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumRenderAntialiasType.cs @@ -1,18 +1,18 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Miscellaneous; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct EnumRenderAntialiasType { [MetaMember("mVal")] public RenderAntialiasType Val { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum RenderAntialiasType { // TODO: -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumRenderLightmapUVGenerationType.cs b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumRenderLightmapUVGenerationType.cs index a232579..b87dcfb 100644 --- a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumRenderLightmapUVGenerationType.cs +++ b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumRenderLightmapUVGenerationType.cs @@ -1,15 +1,15 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct EnumRenderLightmapUVGenerationType { [MetaMember("mVal")] public RenderLightmapUVGenerationType Val { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum RenderLightmapUVGenerationType { // TODO: diff --git a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumRenderMaskTest.cs b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumRenderMaskTest.cs index 4b2c0c2..1570518 100644 --- a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumRenderMaskTest.cs +++ b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumRenderMaskTest.cs @@ -1,21 +1,21 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Miscellaneous; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct EnumRenderMaskTest { [MetaMember("mVal")] public RenderMaskTest Val { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum RenderMaskTest { // eRenderMaskTest_ None = 0x1, Set = 0x2, Clear = 0x3, -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumRenderMaskWrite.cs b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumRenderMaskWrite.cs index bc1ec4f..52b6c93 100644 --- a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumRenderMaskWrite.cs +++ b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumRenderMaskWrite.cs @@ -1,21 +1,21 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Miscellaneous; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct EnumRenderMaskWrite { [MetaMember("mVal")] public RenderMaskWrite Val { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum RenderMaskWrite { // eRenderMaskWrite_ None = 0x1, Set = 0x2, Clear = 0x3, -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumRenderTAAJitterType.cs b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumRenderTAAJitterType.cs index 4ec3dc4..ff2436c 100644 --- a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumRenderTAAJitterType.cs +++ b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumRenderTAAJitterType.cs @@ -1,18 +1,18 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Miscellaneous; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct EnumRenderTAAJitterType { [MetaMember("mVal")] public RenderTAAJitterType Val { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum RenderTAAJitterType { // TODO: -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumRenderTextureResolution.cs b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumRenderTextureResolution.cs index 30422d3..98f07a1 100644 --- a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumRenderTextureResolution.cs +++ b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumRenderTextureResolution.cs @@ -1,18 +1,18 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Miscellaneous; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct EnumRenderTextureResolution { [MetaMember("mVal")] public RenderTextureResolution Val { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum RenderTextureResolution { // TODO: -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumT3DetailShadingType.cs b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumT3DetailShadingType.cs index 87ae484..a6e2aed 100644 --- a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumT3DetailShadingType.cs +++ b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumT3DetailShadingType.cs @@ -1,18 +1,18 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Miscellaneous; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct EnumT3DetailShadingType { [MetaMember("mVal")] public T3DetailShadingType Val { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum T3DetailShadingType { // TODO: -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumT3LightEnvBakeOnStatic.cs b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumT3LightEnvBakeOnStatic.cs index b50d45f..e704d8b 100644 --- a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumT3LightEnvBakeOnStatic.cs +++ b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumT3LightEnvBakeOnStatic.cs @@ -1,18 +1,18 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Miscellaneous; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct EnumT3LightEnvBakeOnStatic { [MetaMember("mVal")] public T3LightEnvBakeOnStatic Val { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum T3LightEnvBakeOnStatic { // TODO: -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumT3LightEnvEnlightenBakeBehavior.cs b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumT3LightEnvEnlightenBakeBehavior.cs index 8834592..f0735fc 100644 --- a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumT3LightEnvEnlightenBakeBehavior.cs +++ b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumT3LightEnvEnlightenBakeBehavior.cs @@ -1,18 +1,18 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Miscellaneous; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct EnumT3LightEnvEnlightenBakeBehavior { [MetaMember("mVal")] public T3LightEnvEnlightenBakeBehavior Val { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum T3LightEnvEnlightenBakeBehavior { // TODO: -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumT3LightEnvGroup.cs b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumT3LightEnvGroup.cs index 2b7b37d..3b57d79 100644 --- a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumT3LightEnvGroup.cs +++ b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumT3LightEnvGroup.cs @@ -1,17 +1,17 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Miscellaneous; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct EnumT3LightEnvGroup { [MetaMember("mVal")] public T3LightEnvGroup Val { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum T3LightEnvGroup { // eLightEnvGroup_ @@ -38,4 +38,4 @@ public enum T3LightEnvGroup AmbientGroup1 = 0x11, AmbientGroup2 = 0x12, AmbientGroup3 = 0x13, -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumT3LightEnvLODBehavior.cs b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumT3LightEnvLODBehavior.cs index 086cee7..ae05293 100644 --- a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumT3LightEnvLODBehavior.cs +++ b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumT3LightEnvLODBehavior.cs @@ -1,20 +1,20 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Miscellaneous; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct EnumT3LightEnvLodBehavior { [MetaMember("mVal")] public T3LightEnvLODBehavior Val { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum T3LightEnvLODBehavior { // eLightEnvLOD_ Disable = 0x0, BakeOnly = 0x1, -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumT3LightEnvMobility.cs b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumT3LightEnvMobility.cs index f08cd93..b3658f2 100644 --- a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumT3LightEnvMobility.cs +++ b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumT3LightEnvMobility.cs @@ -1,21 +1,21 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Miscellaneous; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct EnumT3LightEnvMobility { [MetaMember("mVal")] public T3LightEnvMobility Val { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum T3LightEnvMobility { // eLightEnvMobility_ Static = 0, Stationary = 1, Moveable = 2, -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumT3LightEnvShadowQuality.cs b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumT3LightEnvShadowQuality.cs index 42f415a..bbbdb72 100644 --- a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumT3LightEnvShadowQuality.cs +++ b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumT3LightEnvShadowQuality.cs @@ -1,21 +1,21 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Miscellaneous; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct EnumT3LightEnvShadowQuality { [MetaMember("mVal")] public T3LightEnvShadowQuality Val { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum T3LightEnvShadowQuality { // eLightEnvShadowQuality_ Low = 0, Medium = 1, High = 2, -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumT3LightEnvShadowType.cs b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumT3LightEnvShadowType.cs index 675f795..450c561 100644 --- a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumT3LightEnvShadowType.cs +++ b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumT3LightEnvShadowType.cs @@ -1,21 +1,21 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Miscellaneous; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct EnumT3LightEnvShadowType { [MetaMember("mVal")] public T3LightEnvShadowType Val { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum T3LightEnvShadowType { // eLightEnvShadowType_ None = 0, PerLight = 2, Modulated = 3, -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumT3LightEnvType.cs b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumT3LightEnvType.cs index 553524e..55cc17a 100644 --- a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumT3LightEnvType.cs +++ b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumT3LightEnvType.cs @@ -1,17 +1,17 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Miscellaneous; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct EnumT3LightEnvType { [MetaMember("mVal")] public T3LightEnvType Val { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum T3LightEnvType { // eLightEnvType_ @@ -20,4 +20,4 @@ public enum T3LightEnvType DirectionalKey = 0x2, Ambient = 0x3, DirectionalAmbient = 0x4, -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumT3MaterialLODFullyRough.cs b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumT3MaterialLODFullyRough.cs index 27e62f8..82768a7 100644 --- a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumT3MaterialLODFullyRough.cs +++ b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumT3MaterialLODFullyRough.cs @@ -1,18 +1,18 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Miscellaneous; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct EnumT3MaterialLODFullyRough { [MetaMember("mVal")] public T3MaterialLODFullyRough Val { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum T3MaterialLODFullyRough { // TODO: -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumT3MaterialSwizzleType.cs b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumT3MaterialSwizzleType.cs index 6d6b42f..c5e896c 100644 --- a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumT3MaterialSwizzleType.cs +++ b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumT3MaterialSwizzleType.cs @@ -1,18 +1,18 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Miscellaneous; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct EnumT3MaterialSwizzleType { [MetaMember("mVal")] public T3MaterialSwizzleType Val { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum T3MaterialSwizzleType { // TODO: -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumT3NPRSpecularType.cs b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumT3NPRSpecularType.cs index 7bb0fd2..e947d4b 100644 --- a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumT3NPRSpecularType.cs +++ b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumT3NPRSpecularType.cs @@ -1,18 +1,18 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Miscellaneous; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct EnumT3NPRSpecularType { [MetaMember("mVal")] public T3NPRSpecularType Val { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum T3NPRSpecularType { // TODO: -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumTextOrientationType.cs b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumTextOrientationType.cs index 732af64..078ffd5 100644 --- a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumTextOrientationType.cs +++ b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumTextOrientationType.cs @@ -1,21 +1,21 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Miscellaneous; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct EnumTextOrientationType { [MetaMember("mVal")] public TextOrientationType Val { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum TextOrientationType { // eTextOrientation_ Screen = 0x0, WorldZ = 0x1, WorldXYZ = 0x2, -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumTonemapType.cs b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumTonemapType.cs index 6b9a1c2..b6de33a 100644 --- a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumTonemapType.cs +++ b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumTonemapType.cs @@ -1,16 +1,16 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct EnumTonemapType { [MetaMember("mVal")] public TonemapType Val { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum TonemapType { // TODO: -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumVTextAlignmentType.cs b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumVTextAlignmentType.cs index f69a955..e2ff586 100644 --- a/src/TelltaleToolKit/T3Types/Miscellaneous/EnumVTextAlignmentType.cs +++ b/src/TelltaleToolKit/T3Types/Miscellaneous/EnumVTextAlignmentType.cs @@ -1,17 +1,17 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Miscellaneous; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct EnumVTextAlignmentType { [MetaMember("mVal")] public VTextAlignmentType Val { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum VTextAlignmentType { // eVTextAlignment_ @@ -19,4 +19,4 @@ public enum VTextAlignmentType Top = 1, Middle = 2, Bottom = 3, -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Miscellaneous/FileNameBase.cs b/src/TelltaleToolKit/T3Types/Miscellaneous/FileNameBase.cs index 9b13b00..4049a59 100644 --- a/src/TelltaleToolKit/T3Types/Miscellaneous/FileNameBase.cs +++ b/src/TelltaleToolKit/T3Types/Miscellaneous/FileNameBase.cs @@ -1,28 +1,27 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Binary; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Miscellaneous; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class FileNameBase { [MetaMember("mFileName")] public Symbol FileName { get; set; } } -[MetaClassSerializerGlobal(typeof(FileName<>.Serializer), typeof(FileName<>))] +[MetaSerializer(typeof(FileName<>.Serializer), typeof(FileName<>))] public class FileName { [MetaMember("Baseclass_FileNameBase")] public FileNameBase FileNameBase { get; set; } = new(); - public class Serializer : MetaClassSerializer> + public class Serializer : MetaSerializer> { - private static readonly DefaultClassSerializer> DefaultSerializer = new(); + private static readonly MetaClassSerializer> s_metaClassSerializer = new(); - public override void PreSerialize(ref FileName obj, MetaStream stream, MetaClassType? type = null) + public override void PreSerialize(ref FileName? obj, MetaStream stream, MetaClassType? type = null) { if (obj is null) { @@ -32,8 +31,8 @@ public override void PreSerialize(ref FileName obj, MetaStream stream, MetaCl public override void Serialize(ref FileName obj, MetaStream stream) { - DefaultSerializer.PreSerialize(ref obj, stream); - DefaultSerializer.Serialize(ref obj, stream); + s_metaClassSerializer.PreSerialize(ref obj, stream); + s_metaClassSerializer.Serialize(ref obj, stream); } } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Miscellaneous/FlagsT3LightEnvGroupSet.cs b/src/TelltaleToolKit/T3Types/Miscellaneous/FlagsT3LightEnvGroupSet.cs index b80d7d4..7421dca 100644 --- a/src/TelltaleToolKit/T3Types/Miscellaneous/FlagsT3LightEnvGroupSet.cs +++ b/src/TelltaleToolKit/T3Types/Miscellaneous/FlagsT3LightEnvGroupSet.cs @@ -1,12 +1,12 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Miscellaneous; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct FlagsT3LightEnvGroupSet { [MetaMember("mFlags")] public Flags Flags { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Miscellaneous/SoundEventName.cs b/src/TelltaleToolKit/T3Types/Miscellaneous/SoundEventName.cs index 9102f78..1bc2159 100644 --- a/src/TelltaleToolKit/T3Types/Miscellaneous/SoundEventName.cs +++ b/src/TelltaleToolKit/T3Types/Miscellaneous/SoundEventName.cs @@ -1,11 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Binary; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Miscellaneous; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class SoundEventNameBase { [MetaMember("mEventGuid")] @@ -23,7 +22,7 @@ public enum NameType } } -[MetaClassSerializerGlobal(typeof(Serializer))] +[MetaSerializer(typeof(Serializer))] public class SoundEventName { @@ -42,11 +41,11 @@ public SoundEventName() Type = SoundEventNameBase.NameType.Default; } - public class Serializer : MetaClassSerializer + public class Serializer : MetaSerializer { - private static readonly DefaultClassSerializer DefaultSerializer = new(); + private static readonly MetaClassSerializer s_metaClassSerializer = new(); - public override void PreSerialize(ref SoundEventName obj, MetaStream stream, MetaClassType? type = null) + public override void PreSerialize(ref SoundEventName? obj, MetaStream stream, MetaClassType? type = null) { if (type is null) { @@ -64,8 +63,8 @@ public override void PreSerialize(ref SoundEventName obj, MetaStream stream, Met public override void Serialize(ref SoundEventName obj, MetaStream stream) { - DefaultSerializer.PreSerialize(ref obj, stream); - DefaultSerializer.Serialize(ref obj, stream); + s_metaClassSerializer.PreSerialize(ref obj, stream); + s_metaClassSerializer.Serialize(ref obj, stream); } } } diff --git a/src/TelltaleToolKit/T3Types/Miscellaneous/T3LightCinematicRigLOD.cs b/src/TelltaleToolKit/T3Types/Miscellaneous/T3LightCinematicRigLOD.cs index 91da436..796e64d 100644 --- a/src/TelltaleToolKit/T3Types/Miscellaneous/T3LightCinematicRigLOD.cs +++ b/src/TelltaleToolKit/T3Types/Miscellaneous/T3LightCinematicRigLOD.cs @@ -1,12 +1,12 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Miscellaneous; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct T3LightCinematicRigLOD { [MetaMember("mFlags")] public Flags Flags { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Miscellaneous/T3LightEnvInternalData.cs b/src/TelltaleToolKit/T3Types/Miscellaneous/T3LightEnvInternalData.cs index 4102a15..ec5893f 100644 --- a/src/TelltaleToolKit/T3Types/Miscellaneous/T3LightEnvInternalData.cs +++ b/src/TelltaleToolKit/T3Types/Miscellaneous/T3LightEnvInternalData.cs @@ -1,10 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Miscellaneous; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class T3LightEnvInternalData { [MetaMember("mEntryForQuality[0]")] @@ -22,7 +22,7 @@ public class T3LightEnvInternalData [MetaMember("mStationaryLightIndex")] public int StationaryLightIndex { get; set; } - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public class QualityEntry { [MetaMember("mShadowLayer")] @@ -31,4 +31,4 @@ public class QualityEntry [MetaMember("mFlags")] public Flags Flags { get; set; } } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Miscellaneous/T3LightEnvLOD.cs b/src/TelltaleToolKit/T3Types/Miscellaneous/T3LightEnvLOD.cs index be3d9d4..4f59676 100644 --- a/src/TelltaleToolKit/T3Types/Miscellaneous/T3LightEnvLOD.cs +++ b/src/TelltaleToolKit/T3Types/Miscellaneous/T3LightEnvLOD.cs @@ -1,10 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Miscellaneous; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct T3LightEnvLOD { [MetaMember("mFlags")] @@ -18,4 +18,4 @@ public enum T3LightEnvLODFlags { High = 0x10000, Medium = 0x20000, Low = 0x40000, -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Miscellaneous/T3LightProbeInternalData.cs b/src/TelltaleToolKit/T3Types/Miscellaneous/T3LightProbeInternalData.cs index b81da9d..47bf785 100644 --- a/src/TelltaleToolKit/T3Types/Miscellaneous/T3LightProbeInternalData.cs +++ b/src/TelltaleToolKit/T3Types/Miscellaneous/T3LightProbeInternalData.cs @@ -1,11 +1,11 @@ using System.Numerics; -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Miscellaneous; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class T3LightProbeInternalData { [MetaMember("mEntryForQuality[0]")] @@ -20,7 +20,7 @@ public class T3LightProbeInternalData [MetaMember("mEntryForQuality[3]")] public QualityEntry EntryForQuality3 { get; set; } - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public class QualityEntry { [MetaMember("mShadowTextureScale")] @@ -29,4 +29,4 @@ public class QualityEntry [MetaMember("mShadowTextureBias")] public Vector3 Flags { get; set; } } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Miscellaneous/ZTestFunction.cs b/src/TelltaleToolKit/T3Types/Miscellaneous/ZTestFunction.cs index 215bebb..5911ccb 100644 --- a/src/TelltaleToolKit/T3Types/Miscellaneous/ZTestFunction.cs +++ b/src/TelltaleToolKit/T3Types/Miscellaneous/ZTestFunction.cs @@ -1,10 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Miscellaneous; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct ZTestFunction { [MetaMember("mZTestType")] @@ -12,7 +12,7 @@ public struct ZTestFunction public FuncTypes ZTestType { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum FuncTypes { Never = 0x1, @@ -23,4 +23,4 @@ public enum FuncTypes NotEqual = 0x6, GreaterEqual = 0x7, Always = 0x8, -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Movie.cs b/src/TelltaleToolKit/T3Types/Movie.cs index e61a8b9..1be62fb 100644 --- a/src/TelltaleToolKit/T3Types/Movie.cs +++ b/src/TelltaleToolKit/T3Types/Movie.cs @@ -1,10 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class MovieCaptureInfo { [MetaMember("mFPS")] @@ -14,12 +14,12 @@ public class MovieCaptureInfo public EnumCompressorType CType { get; set; } = new(); - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public struct EnumCompressorType { [MetaMember("mVal")] public CompressorType Val { get; set; } } - [MetaClassSerializerGlobal(typeof(EnumSerializer))] + [MetaSerializer(typeof(EnumSerializer))] public enum CompressorType{} -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/NavCam/NavCam.cs b/src/TelltaleToolKit/T3Types/NavCam/NavCam.cs index 5e71756..a655179 100644 --- a/src/TelltaleToolKit/T3Types/NavCam/NavCam.cs +++ b/src/TelltaleToolKit/T3Types/NavCam/NavCam.cs @@ -1,10 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.NavCam; -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum Mode { None = 1, @@ -17,9 +17,9 @@ public enum Mode DynamicConversationCamera = 8 } -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct EnumMode { [MetaMember("mVal")] public Mode Val { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Overlays/T3OverlayData.cs b/src/TelltaleToolKit/T3Types/Overlays/T3OverlayData.cs index 1b588fb..0f7214c 100644 --- a/src/TelltaleToolKit/T3Types/Overlays/T3OverlayData.cs +++ b/src/TelltaleToolKit/T3Types/Overlays/T3OverlayData.cs @@ -1,13 +1,13 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Overlays; /// /// Main class for .overlay files. /// -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class T3OverlayData { [MetaMember("mName")] @@ -21,4 +21,4 @@ public class T3OverlayData [MetaMember("mParams")] public T3OverlayParams Parameters { get; set; } = new(); -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Overlays/T3OverlayObjectData_Sprite.cs b/src/TelltaleToolKit/T3Types/Overlays/T3OverlayObjectData_Sprite.cs index acdc715..62dbe8b 100644 --- a/src/TelltaleToolKit/T3Types/Overlays/T3OverlayObjectData_Sprite.cs +++ b/src/TelltaleToolKit/T3Types/Overlays/T3OverlayObjectData_Sprite.cs @@ -1,10 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Overlays; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class T3OverlayObjectDataSprite { [MetaMember("mName")] @@ -12,4 +12,4 @@ public class T3OverlayObjectDataSprite [MetaMember("mParams")] public T3OverlaySpriteParams Parameters { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Overlays/T3OverlayObjectData_Text.cs b/src/TelltaleToolKit/T3Types/Overlays/T3OverlayObjectData_Text.cs index 20ebd9e..d6fd7ea 100644 --- a/src/TelltaleToolKit/T3Types/Overlays/T3OverlayObjectData_Text.cs +++ b/src/TelltaleToolKit/T3Types/Overlays/T3OverlayObjectData_Text.cs @@ -1,10 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Overlays; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class T3OverlayObjectDataText { [MetaMember("mName")] @@ -12,4 +12,4 @@ public class T3OverlayObjectDataText [MetaMember("mParams")] public T3OverlayTextParams Parameters { get; set; } = new(); -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Overlays/T3OverlayParams.cs b/src/TelltaleToolKit/T3Types/Overlays/T3OverlayParams.cs index fef7519..6ca06a8 100644 --- a/src/TelltaleToolKit/T3Types/Overlays/T3OverlayParams.cs +++ b/src/TelltaleToolKit/T3Types/Overlays/T3OverlayParams.cs @@ -1,12 +1,12 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Chores; using TelltaleToolKit.T3Types.Textures; namespace TelltaleToolKit.T3Types.Overlays; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class T3OverlayParams { [MetaMember("mhBackgroundTexture")] @@ -20,4 +20,4 @@ public class T3OverlayParams [MetaMember("mFadeTime")] public float FadeTime { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Overlays/T3OverlaySpriteParams.cs b/src/TelltaleToolKit/T3Types/Overlays/T3OverlaySpriteParams.cs index d007cb4..81cd1e8 100644 --- a/src/TelltaleToolKit/T3Types/Overlays/T3OverlaySpriteParams.cs +++ b/src/TelltaleToolKit/T3Types/Overlays/T3OverlaySpriteParams.cs @@ -1,11 +1,11 @@ using System.Numerics; -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Overlays; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class T3OverlaySpriteParams { [MetaMember("mhSprite")] @@ -25,4 +25,4 @@ public class T3OverlaySpriteParams [MetaMember("mFlags")] public Flags Flags { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Overlays/T3OverlayTextParams.cs b/src/TelltaleToolKit/T3Types/Overlays/T3OverlayTextParams.cs index 14f4930..161f91d 100644 --- a/src/TelltaleToolKit/T3Types/Overlays/T3OverlayTextParams.cs +++ b/src/TelltaleToolKit/T3Types/Overlays/T3OverlayTextParams.cs @@ -1,13 +1,13 @@ using System.Numerics; -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Dialogs.Dlg; using TelltaleToolKit.T3Types.Fonts; namespace TelltaleToolKit.T3Types.Overlays; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class T3OverlayTextParams { [MetaMember("mhFont")] @@ -24,4 +24,4 @@ public class T3OverlayTextParams [MetaMember("mInitialPosition")] public Vector2 InitialPosition { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Properties/PropertySet.cs b/src/TelltaleToolKit/T3Types/Properties/PropertySet.cs index 9ef6f57..98a5c98 100644 --- a/src/TelltaleToolKit/T3Types/Properties/PropertySet.cs +++ b/src/TelltaleToolKit/T3Types/Properties/PropertySet.cs @@ -1,11 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Binary; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Properties; -[MetaClassSerializerGlobal(typeof(Serializer))] +[MetaSerializer(typeof(Serializer))] public class PropertySet { // Starts appearing later @@ -36,11 +35,11 @@ public PropertyEntry(object? value, MetaClassType? metaType = null) public PropertySet ParentProperties; - public class Serializer : MetaClassSerializer + public class Serializer : MetaSerializer { - private static readonly DefaultClassSerializer DefaultSerializer = new(); + private static readonly MetaClassSerializer s_metaClassSerializer = new(); - public override void PreSerialize(ref PropertySet obj, MetaStream stream, MetaClassType? type = null) + public override void PreSerialize(ref PropertySet? obj, MetaStream stream, MetaClassType? type = null) { if (obj is null) { @@ -50,8 +49,8 @@ public override void PreSerialize(ref PropertySet obj, MetaStream stream, MetaCl public override void Serialize(ref PropertySet obj, MetaStream stream) { - DefaultSerializer.PreSerialize(ref obj, stream); - DefaultSerializer.Serialize(ref obj, stream); + s_metaClassSerializer.PreSerialize(ref obj, stream); + s_metaClassSerializer.Serialize(ref obj, stream); stream.BeginBlock(); @@ -63,7 +62,7 @@ public override void Serialize(ref PropertySet obj, MetaStream stream) int parentCount = obj.ParentList.Count; stream.Write(parentCount); - MetaClassSerializer> parentSerializer = + MetaSerializer> parentSerializer = Toolkit.Instance.GetSerializer>(); for (var i = 0; i < parentCount; i++) { @@ -127,7 +126,7 @@ public override void Serialize(ref PropertySet obj, MetaStream stream) stream.Write(typeSymbol); stream.Write(entries.Count); - MetaClassSerializer classTypeSerializer = + MetaSerializer typeSerializer = Toolkit.Instance.GetSerializer(typeSymbol.LinkingType); foreach ((Symbol key, PropertyEntry value) in entries) @@ -136,8 +135,8 @@ public override void Serialize(ref PropertySet obj, MetaStream stream) object? propertyValue = value.Value; - classTypeSerializer.PreSerialize(ref propertyValue, stream, typeSymbol); - classTypeSerializer.Serialize(ref propertyValue, stream); + typeSerializer.PreSerialize(ref propertyValue, stream, typeSymbol); + typeSerializer.Serialize(ref propertyValue, stream); // Note: we intentionally don't mutate the stored PropertyEntry.Value here. // If serializer changes the in-memory object and you want that persisted, set it before calling Serialize. @@ -175,7 +174,7 @@ public override void Serialize(ref PropertySet obj, MetaStream stream) if (typeSymbol is null) throw new InvalidOperationException("[PropertySet] Type symbol is null"); - MetaClassSerializer classTypeSerializer = Toolkit.Instance.GetSerializer(typeSymbol.LinkingType); + MetaSerializer typeSerializer = Toolkit.Instance.GetSerializer(typeSymbol.LinkingType); for (var j = 0; j < numOfType; j++) { @@ -184,8 +183,8 @@ public override void Serialize(ref PropertySet obj, MetaStream stream) object? propertyValue = null; - classTypeSerializer.PreSerialize(ref propertyValue, stream, typeSymbol); - classTypeSerializer.Serialize(ref propertyValue, stream); + typeSerializer.PreSerialize(ref propertyValue, stream, typeSymbol); + typeSerializer.Serialize(ref propertyValue, stream); obj.Properties[propertyKey] = new PropertyEntry(propertyValue, typeSymbol); } } diff --git a/src/TelltaleToolKit/T3Types/Properties/ToolProps.cs b/src/TelltaleToolKit/T3Types/Properties/ToolProps.cs index 81caf3d..9f96af8 100644 --- a/src/TelltaleToolKit/T3Types/Properties/ToolProps.cs +++ b/src/TelltaleToolKit/T3Types/Properties/ToolProps.cs @@ -1,18 +1,17 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Binary; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; namespace TelltaleToolKit.T3Types.Properties; -[MetaClassSerializerGlobal(typeof(Serializer))] +[MetaSerializer(typeof(Serializer))] public class ToolProps { [MetaMember("mbHasProps")] public bool HasProps { get; set; } - public class Serializer : MetaClassSerializer + public class Serializer : MetaSerializer { - public override void PreSerialize(ref ToolProps obj, MetaStream stream, MetaClassType? type = null) + public override void PreSerialize(ref ToolProps? obj, MetaStream stream, MetaClassType? type = null) { if (obj is null) { diff --git a/src/TelltaleToolKit/T3Types/Rules/LogicGroup.cs b/src/TelltaleToolKit/T3Types/Rules/LogicGroup.cs index c7d46d3..60693a7 100644 --- a/src/TelltaleToolKit/T3Types/Rules/LogicGroup.cs +++ b/src/TelltaleToolKit/T3Types/Rules/LogicGroup.cs @@ -1,11 +1,11 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Properties; namespace TelltaleToolKit.T3Types.Rules; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class LogicGroup { [MetaMember("mOperator")] @@ -26,7 +26,7 @@ public class LogicGroup [MetaMember("mName")] public string Name { get; set; } = string.Empty; - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public class LogicItem { [MetaMember("Baseclass_PropertySet")] @@ -36,15 +36,15 @@ public class LogicItem public string Name { get; set; } = string.Empty; [MetaMember("mKeyNegateList")] - public Dictionary GroupOperator { get; set; } = new(); // also a string/symbol - + public Dictionary GroupOperator { get; set; } = new(); // also a string/symbol + [MetaMember("mKeyComparisonList")] - public Dictionary KeyComparisonList { get; set; } = new(); // also a string/symbol + public Dictionary KeyComparisonList { get; set; } = new(); // also a string/symbol [MetaMember("mKeyActionList")] - public Dictionary KeyActionList { get; set; } = new(); // also a string/symbol + public Dictionary KeyActionList { get; set; } = new(); // also a string/symbol [MetaMember("mReferenceKeyList")] - public List ReferenceKeyList { get; set; } = []; // also a string/symbol + public List ReferenceKeyList { get; set; } = []; // also a string/symbol } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Rules/Rule.cs b/src/TelltaleToolKit/T3Types/Rules/Rule.cs index 3684a4b..c338ba7 100644 --- a/src/TelltaleToolKit/T3Types/Rules/Rule.cs +++ b/src/TelltaleToolKit/T3Types/Rules/Rule.cs @@ -1,12 +1,11 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Binary; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Properties; namespace TelltaleToolKit.T3Types.Rules; -[MetaClassSerializerGlobal(typeof(Serializer))] +[MetaSerializer(typeof(Serializer))] public class Rule { [MetaMember("mName")] @@ -41,7 +40,7 @@ public class Rule public List AgentInformation { get; set; } = []; - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public class AgentInfo { [MetaMember("mAgentName")] @@ -54,11 +53,11 @@ public class AgentInfo public PropertySet ActionProperties { get; set; } = new(); } - public class Serializer : MetaClassSerializer + public class Serializer : MetaSerializer { - private static readonly DefaultClassSerializer DefaultSerializer = new(); + private static readonly MetaClassSerializer s_metaClassSerializer = new(); - public override void PreSerialize(ref Rule obj, MetaStream stream, MetaClassType? type = null) + public override void PreSerialize(ref Rule? obj, MetaStream stream, MetaClassType? type = null) { if (obj is null) { @@ -69,7 +68,7 @@ public override void PreSerialize(ref Rule obj, MetaStream stream, MetaClassType public override void Serialize(ref Rule obj, MetaStream stream) { PreSerialize(ref obj, stream); - DefaultSerializer.Serialize(ref obj, stream); + s_metaClassSerializer.Serialize(ref obj, stream); if (!obj.VersionHasAgents) { diff --git a/src/TelltaleToolKit/T3Types/Rules/Rules.cs b/src/TelltaleToolKit/T3Types/Rules/Rules.cs index 74aba5c..4fa15dd 100644 --- a/src/TelltaleToolKit/T3Types/Rules/Rules.cs +++ b/src/TelltaleToolKit/T3Types/Rules/Rules.cs @@ -1,12 +1,11 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Binary; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Properties; namespace TelltaleToolKit.T3Types.Rules; -[MetaClassSerializerGlobal(typeof(Serializer))] +[MetaSerializer(typeof(Serializer))] public class Rules { [MetaMember("mFlags")] @@ -20,14 +19,14 @@ public class Rules [MetaMember("mRuleMap")] public Dictionary RuleMap { get; set; } = new(); - public class Serializer : MetaClassSerializer + public class Serializer : MetaSerializer { - private static readonly DefaultClassSerializer DefaultSerializer = new(); + private static readonly MetaClassSerializer s_metaClassSerializer = new(); public override void Serialize(ref Rules obj, MetaStream stream) { PreSerialize(ref obj, stream); - DefaultSerializer.Serialize(ref obj, stream); + s_metaClassSerializer.Serialize(ref obj, stream); stream.BeginBlock(); if (stream.Mode is MetaStreamMode.Write) diff --git a/src/TelltaleToolKit/T3Types/SaveGame.cs b/src/TelltaleToolKit/T3Types/SaveGame.cs index db9af29..ecd00a0 100644 --- a/src/TelltaleToolKit/T3Types/SaveGame.cs +++ b/src/TelltaleToolKit/T3Types/SaveGame.cs @@ -1,13 +1,12 @@ using System.Numerics; -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Binary; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Properties; namespace TelltaleToolKit.T3Types; -[MetaClassSerializerGlobal(typeof(Serializer))] +[MetaSerializer(typeof(Serializer))] public class SaveGame { [MetaMember("mLuaDoFile")] @@ -22,7 +21,7 @@ public class SaveGame [MetaMember("mAdditionalPropNames")] public HashSet AdditionalPropNames { get; set; } = []; - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public class AgentInfo { [MetaMember("mAgentName")] @@ -45,13 +44,13 @@ public class AgentInfo } - public class Serializer : MetaClassSerializer + public class Serializer : MetaSerializer { - private static readonly DefaultClassSerializer DefaultSaveGameSerializer = new(); + private static readonly MetaClassSerializer s_metaClassSaveGameSerializer = new(); public override void Serialize(ref SaveGame obj, MetaStream stream) { - DefaultSaveGameSerializer.Serialize(ref obj, stream); + s_metaClassSaveGameSerializer.Serialize(ref obj, stream); if (stream.Mode is MetaStreamMode.Write) { diff --git a/src/TelltaleToolKit/T3Types/Scenes/MeshSceneEnlightenData.cs b/src/TelltaleToolKit/T3Types/Scenes/MeshSceneEnlightenData.cs index 7eac650..3167733 100644 --- a/src/TelltaleToolKit/T3Types/Scenes/MeshSceneEnlightenData.cs +++ b/src/TelltaleToolKit/T3Types/Scenes/MeshSceneEnlightenData.cs @@ -1,11 +1,11 @@ using System.Numerics; -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Scenes; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class MeshSceneEnlightenData { [MetaMember("mSystemName")] @@ -16,4 +16,4 @@ public class MeshSceneEnlightenData [MetaMember("mFlags")] public Flags Flags { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Scenes/Scene.cs b/src/TelltaleToolKit/T3Types/Scenes/Scene.cs index 3af7b5c..3c93816 100644 --- a/src/TelltaleToolKit/T3Types/Scenes/Scene.cs +++ b/src/TelltaleToolKit/T3Types/Scenes/Scene.cs @@ -1,13 +1,12 @@ using System.Numerics; -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Binary; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Properties; namespace TelltaleToolKit.T3Types.Scenes; -[MetaClassSerializerGlobal(typeof(Serializer))] +[MetaSerializer(typeof(Serializer))] public class Scene { [MetaMember("mbHidden")] @@ -21,14 +20,14 @@ public class Scene public List Agents { get; set; } = []; - public class Serializer : MetaClassSerializer + public class Serializer : MetaSerializer { - private static readonly DefaultClassSerializer DefaultSceneSerializer = new(); + private static readonly MetaClassSerializer s_metaClassSceneSerializer = new(); public override void Serialize(ref Scene obj, MetaStream stream) { - DefaultSceneSerializer.PreSerialize(ref obj, stream); - DefaultSceneSerializer.Serialize(ref obj, stream); + s_metaClassSceneSerializer.PreSerialize(ref obj, stream); + s_metaClassSceneSerializer.Serialize(ref obj, stream); stream.BeginBlock(); @@ -54,7 +53,7 @@ public override void Serialize(ref Scene obj, MetaStream stream) } } - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public class AgentInfo { [MetaMember("mAgentName")] @@ -91,7 +90,7 @@ public class AgentInfo public bool MembersImportedIntoSceneProps { get; set; } } - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public class AgentQualitySettings { [MetaMember("mFlags")] diff --git a/src/TelltaleToolKit/T3Types/Script/ScriptEnums.cs b/src/TelltaleToolKit/T3Types/Script/ScriptEnums.cs index 4f7ffed..6057745 100644 --- a/src/TelltaleToolKit/T3Types/Script/ScriptEnums.cs +++ b/src/TelltaleToolKit/T3Types/Script/ScriptEnums.cs @@ -1,14 +1,14 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Script; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class ScriptEnum { [MetaMember("mCurValue")] public string CurValue { get; set; } = string.Empty; public override string ToString() => CurValue; -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Skeletons/BallJointKey.cs b/src/TelltaleToolKit/T3Types/Skeletons/BallJointKey.cs index dfdf0a8..d46a5f7 100644 --- a/src/TelltaleToolKit/T3Types/Skeletons/BallJointKey.cs +++ b/src/TelltaleToolKit/T3Types/Skeletons/BallJointKey.cs @@ -1,10 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Skeletons; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class BallJointKey { [MetaMember("mBoneLengthConstraint__Enabled")] @@ -48,4 +48,4 @@ public class BallJointKey [MetaMember("mRotationConstraint_MaxBendAngularAcceleration")] public float mRotationConstraint_MaxBendAngularAcceleration { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Skeletons/BallTwistJointKey.cs b/src/TelltaleToolKit/T3Types/Skeletons/BallTwistJointKey.cs index cf023d3..47fc15e 100644 --- a/src/TelltaleToolKit/T3Types/Skeletons/BallTwistJointKey.cs +++ b/src/TelltaleToolKit/T3Types/Skeletons/BallTwistJointKey.cs @@ -1,10 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Skeletons; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class BallTwistJointKey { [MetaMember("mBoneLengthConstraint__Enabled")] @@ -60,4 +60,4 @@ public class BallTwistJointKey [MetaMember("mRotationConstraint_MaxTwistAngularAcceleration")] public float mRotationConstraint_MaxTwistAngularAcceleration { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Skeletons/BoneConstraints.cs b/src/TelltaleToolKit/T3Types/Skeletons/BoneConstraints.cs index a3e27a8..8c2227b 100644 --- a/src/TelltaleToolKit/T3Types/Skeletons/BoneConstraints.cs +++ b/src/TelltaleToolKit/T3Types/Skeletons/BoneConstraints.cs @@ -1,12 +1,12 @@ using System.Numerics; -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Mathematics; namespace TelltaleToolKit.T3Types.Skeletons; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class BoneConstraints { [MetaMember("mBoneType")] @@ -19,10 +19,10 @@ public class BoneConstraints public Range[] AxisRange { get; set; } = [new(), new(), new()]; } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum BoneType { // eBoneType_ Hinge = 0, Ball = 1 -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Skeletons/ConstraintReferenceFrame.cs b/src/TelltaleToolKit/T3Types/Skeletons/ConstraintReferenceFrame.cs index 84c6910..55199d7 100644 --- a/src/TelltaleToolKit/T3Types/Skeletons/ConstraintReferenceFrame.cs +++ b/src/TelltaleToolKit/T3Types/Skeletons/ConstraintReferenceFrame.cs @@ -1,11 +1,11 @@ -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Skeletons; -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum ConstraintReferenceFrame { World = 0, Root = 1, Parent = 2, -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Skeletons/HingeJointKey.cs b/src/TelltaleToolKit/T3Types/Skeletons/HingeJointKey.cs index 3ab7cfc..f21fe97 100644 --- a/src/TelltaleToolKit/T3Types/Skeletons/HingeJointKey.cs +++ b/src/TelltaleToolKit/T3Types/Skeletons/HingeJointKey.cs @@ -1,10 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Skeletons; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class HingeJointKey { [MetaMember("mBoneLengthConstraint__Enabled")] @@ -51,4 +51,4 @@ public class HingeJointKey [MetaMember("mRotationConstraint_MaxBendAngularAcceleration")] public float mRotationConstraint_MaxBendAngularAcceleration { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Skeletons/LinkedBallTwistJointKey.cs b/src/TelltaleToolKit/T3Types/Skeletons/LinkedBallTwistJointKey.cs index 43a05e9..d484931 100644 --- a/src/TelltaleToolKit/T3Types/Skeletons/LinkedBallTwistJointKey.cs +++ b/src/TelltaleToolKit/T3Types/Skeletons/LinkedBallTwistJointKey.cs @@ -1,10 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Skeletons; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class LinkedBallTwistJointKey { [MetaMember("mBoneLengthConstraint__Enabled")] @@ -78,4 +78,4 @@ public class LinkedBallTwistJointKey [MetaMember("mLinkTwistConstraint_EchoDelay")] public float mLinkTwistConstraint_EchoDelay{get;set;} -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Skeletons/PivotJointKey.cs b/src/TelltaleToolKit/T3Types/Skeletons/PivotJointKey.cs index 88993cb..0148a06 100644 --- a/src/TelltaleToolKit/T3Types/Skeletons/PivotJointKey.cs +++ b/src/TelltaleToolKit/T3Types/Skeletons/PivotJointKey.cs @@ -1,10 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Skeletons; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class PivotJointKey { [MetaMember("mBoneLengthConstraint__Enabled")] @@ -57,4 +57,4 @@ public class PivotJointKey [MetaMember("mRotationConstraint_MaxBendAngularAcceleration")] public float mRotationConstraint_MaxBendAngularAcceleration { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Skeletons/PlaceableBallTwistJointKey.cs b/src/TelltaleToolKit/T3Types/Skeletons/PlaceableBallTwistJointKey.cs index 2cad380..ac62daf 100644 --- a/src/TelltaleToolKit/T3Types/Skeletons/PlaceableBallTwistJointKey.cs +++ b/src/TelltaleToolKit/T3Types/Skeletons/PlaceableBallTwistJointKey.cs @@ -1,10 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Skeletons; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class PlaceableBallTwistJointKey { [MetaMember("mBoneLengthConstraint__Enabled")] @@ -32,11 +32,11 @@ public class PlaceableBallTwistJointKey public float mAngleConstraint_MaxTwistAngle { get; set; } [MetaMember("mPlacementLockToAnimConstraint__Enabled")] - public bool mPlacementLockToAnimConstraint__Enabled { get; set; } - + public bool mPlacementLockToAnimConstraint__Enabled { get; set; } + [MetaMember("mPlacementLockToAnimConstraint_Offset")] - public Transform mPlacementLockToAnimConstraint_Offset { get; set; } - + public Transform mPlacementLockToAnimConstraint_Offset { get; set; } + [MetaMember("mPlacementLockToNodeConstraint_Offset")] public Transform mPlacementLockToNodeConstraint_Offset { get; set; } @@ -85,7 +85,7 @@ public class PlaceableBallTwistJointKey public struct AnimationConstraint { - [MetaClassSerializerGlobal(typeof(EnumSerializer))] + [MetaSerializer(typeof(EnumSerializer))] public enum LockMode { eTrafoMode = 0, /*pos and rot*/ @@ -93,7 +93,7 @@ public enum LockMode eOriMode = 2, /*rot*/ } - [MetaClassSerializerGlobal(typeof(EnumSerializer))] + [MetaSerializer(typeof(EnumSerializer))] public enum Node { eWorld = 0x0, @@ -154,4 +154,4 @@ public enum Node eAnkle_R = 0x37, eNumNodes = 0x38, } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Skeletons/RootKey.cs b/src/TelltaleToolKit/T3Types/Skeletons/RootKey.cs index cd7bc34..29dbb16 100644 --- a/src/TelltaleToolKit/T3Types/Skeletons/RootKey.cs +++ b/src/TelltaleToolKit/T3Types/Skeletons/RootKey.cs @@ -1,10 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Skeletons; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class RootKey { [MetaMember("mTranslationConstraint__Enabled")] @@ -30,4 +30,4 @@ public class RootKey [MetaMember("mRotationConstraint_MaxTwistAngularAcceleration")] public float mRotationConstraint_MaxTwistAngularAcceleration { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Skeletons/Skeleton.cs b/src/TelltaleToolKit/T3Types/Skeletons/Skeleton.cs index 5a9c119..e863084 100644 --- a/src/TelltaleToolKit/T3Types/Skeletons/Skeleton.cs +++ b/src/TelltaleToolKit/T3Types/Skeletons/Skeleton.cs @@ -1,17 +1,17 @@ using System.Numerics; -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Skeletons; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class Skeleton { [MetaMember("mEntries")] public List Entries { get; set; } = []; - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public class Entry { // This is a string and a symbol at the same time @@ -65,11 +65,11 @@ public class Entry [MetaMember("mResourceGroupMembership")] public Dictionary ResourceGroupMembershipStr { get; set; } = new(); - + [MetaMember("mConstraints")] public BoneConstraints Constraints { get; set; } = new(); [MetaMember("mFlags")] public Flags Flags { get; set; } } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Skeletons/Transform.cs b/src/TelltaleToolKit/T3Types/Skeletons/Transform.cs index 5f82bee..295be10 100644 --- a/src/TelltaleToolKit/T3Types/Skeletons/Transform.cs +++ b/src/TelltaleToolKit/T3Types/Skeletons/Transform.cs @@ -1,11 +1,11 @@ using System.Numerics; -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Skeletons; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class Transform { [MetaMember("mRot")] @@ -13,4 +13,4 @@ public class Transform [MetaMember("mTrans")] public Vector3 Translation { get; set; } = new(); -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/SoundReverbDefinition.cs b/src/TelltaleToolKit/T3Types/SoundReverbDefinition.cs index db2e97b..d895fdf 100644 --- a/src/TelltaleToolKit/T3Types/SoundReverbDefinition.cs +++ b/src/TelltaleToolKit/T3Types/SoundReverbDefinition.cs @@ -1,13 +1,13 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types; /// /// Main class for .reverb files. /// -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class SoundReverbDefinition { [MetaMember("mbEnabled")] @@ -51,4 +51,4 @@ public class SoundReverbDefinition [MetaMember("mfDensity")] public float Density { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/StyleGuides/ActingPaletteClass.cs b/src/TelltaleToolKit/T3Types/StyleGuides/ActingPaletteClass.cs index 7506fa4..7846a2f 100644 --- a/src/TelltaleToolKit/T3Types/StyleGuides/ActingPaletteClass.cs +++ b/src/TelltaleToolKit/T3Types/StyleGuides/ActingPaletteClass.cs @@ -1,13 +1,12 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Binary; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Common; using TelltaleToolKit.T3Types.Common.UID; namespace TelltaleToolKit.T3Types.StyleGuides; -[MetaClassSerializerGlobal(typeof(Serializer))] +[MetaSerializer(typeof(Serializer))] public class ActingPaletteClass { [MetaMember("Baseclass_UID::Owner")] @@ -40,14 +39,14 @@ public class ActingPaletteClass [MetaMember("mIdle")] public AnimOrChore Idle { get; set; } - public class Serializer : MetaClassSerializer + public class Serializer : MetaSerializer { - private static readonly DefaultClassSerializer DefaultSerializer = new(); + private static readonly MetaClassSerializer s_metaClassSerializer = new(); public override void Serialize(ref ActingPaletteClass obj, MetaStream stream) { - DefaultSerializer.PreSerialize(ref obj, stream); - DefaultSerializer.Serialize(ref obj, stream); + s_metaClassSerializer.PreSerialize(ref obj, stream); + s_metaClassSerializer.Serialize(ref obj, stream); // TODO: MetaClass? classDescription = stream.GetMetaClass(typeof(ActingPaletteClass)); diff --git a/src/TelltaleToolKit/T3Types/StyleGuides/ActingPaletteGroup.cs b/src/TelltaleToolKit/T3Types/StyleGuides/ActingPaletteGroup.cs index 38fca1f..30d7ae6 100644 --- a/src/TelltaleToolKit/T3Types/StyleGuides/ActingPaletteGroup.cs +++ b/src/TelltaleToolKit/T3Types/StyleGuides/ActingPaletteGroup.cs @@ -1,11 +1,11 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Common.UID; namespace TelltaleToolKit.T3Types.StyleGuides; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class ActingPaletteGroup { [MetaMember("Baseclass_UID::Owner")] @@ -33,4 +33,4 @@ public class ActingPaletteTransition public class EnumIdleTransition { } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/StyleGuides/ActingPallete.cs b/src/TelltaleToolKit/T3Types/StyleGuides/ActingPallete.cs index 8f90e26..29b384a 100644 --- a/src/TelltaleToolKit/T3Types/StyleGuides/ActingPallete.cs +++ b/src/TelltaleToolKit/T3Types/StyleGuides/ActingPallete.cs @@ -1,16 +1,16 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Common; using TelltaleToolKit.T3Types.Common.UID; using TelltaleToolKit.T3Types.Mathematics; namespace TelltaleToolKit.T3Types.StyleGuides; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class ActingPalette { - [MetaClassSerializerGlobal(typeof(EnumSerializer))] + [MetaSerializer(typeof(EnumSerializer))] public enum ActiveDuring { } @@ -66,10 +66,10 @@ public enum ActiveDuring public Dictionary PaletteResourceGroups { get; set; } - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public struct EnumActiveDuring { [MetaMember("mVal")] public ActiveDuring Val { get; set; } } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/StyleGuides/ActingResource.cs b/src/TelltaleToolKit/T3Types/StyleGuides/ActingResource.cs index 0e9cba0..628e7a8 100644 --- a/src/TelltaleToolKit/T3Types/StyleGuides/ActingResource.cs +++ b/src/TelltaleToolKit/T3Types/StyleGuides/ActingResource.cs @@ -1,12 +1,12 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Common; using TelltaleToolKit.T3Types.Mathematics; namespace TelltaleToolKit.T3Types.StyleGuides; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class ActingResource { [MetaMember("Baseclass_ActingOverridablePropOwner")] @@ -20,4 +20,4 @@ public class ActingResource [MetaMember("mValidIntensityRange")] public Range ValidIntensityRange { get; set; } = new(); -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/StyleGuides/ResourceGroups.cs b/src/TelltaleToolKit/T3Types/StyleGuides/ResourceGroups.cs index d3c5268..3f25a1e 100644 --- a/src/TelltaleToolKit/T3Types/StyleGuides/ResourceGroups.cs +++ b/src/TelltaleToolKit/T3Types/StyleGuides/ResourceGroups.cs @@ -1,13 +1,13 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.StyleGuides; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class ResourceGroups { // String and symbol at the same time [MetaMember("mGroups")] public Dictionary Groups { get; set; } = new(); -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/StyleGuides/StyleGuide.cs b/src/TelltaleToolKit/T3Types/StyleGuides/StyleGuide.cs index f367e0b..3e44ecb 100644 --- a/src/TelltaleToolKit/T3Types/StyleGuides/StyleGuide.cs +++ b/src/TelltaleToolKit/T3Types/StyleGuides/StyleGuide.cs @@ -1,13 +1,12 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Binary; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Common; using TelltaleToolKit.T3Types.Common.UID; namespace TelltaleToolKit.T3Types.StyleGuides; -[MetaClassSerializerGlobal(typeof(Serializer))] +[MetaSerializer(typeof(Serializer))] public class StyleGuide { [MetaMember("Baseclass_UID::Generator")] @@ -36,15 +35,15 @@ public class StyleGuide public List PaletteClassesPtrs { get; set; } = []; - [MetaClassSerializerGlobal(typeof(ActingOverridablePropOwnerSerializer))] - public class Serializer : MetaClassSerializer + [MetaSerializer(typeof(ActingOverridablePropOwnerSerializer))] + public class Serializer : MetaSerializer { - private static readonly DefaultClassSerializer DefaultSerializer = new(); + private static readonly MetaClassSerializer s_metaClassSerializer = new(); public override void Serialize(ref StyleGuide obj, MetaStream stream) { - DefaultSerializer.PreSerialize(ref obj, stream); - DefaultSerializer.Serialize(ref obj, stream); + s_metaClassSerializer.PreSerialize(ref obj, stream); + s_metaClassSerializer.Serialize(ref obj, stream); MetaClass? classDescription = stream.GetMetaClass(typeof(StyleGuide)); diff --git a/src/TelltaleToolKit/T3Types/StyleGuides/StyleGuideMapper.cs b/src/TelltaleToolKit/T3Types/StyleGuides/StyleGuideMapper.cs index aa13f3f..6ec6002 100644 --- a/src/TelltaleToolKit/T3Types/StyleGuides/StyleGuideMapper.cs +++ b/src/TelltaleToolKit/T3Types/StyleGuides/StyleGuideMapper.cs @@ -1,12 +1,12 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.StyleGuides; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class StyleGuideMapper { [MetaMember("mStyleGuideMap")] public Dictionary, Handle> StyleGuideMap { get; set; } = new(); -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/StyleGuides/StyleGuideRef.cs b/src/TelltaleToolKit/T3Types/StyleGuides/StyleGuideRef.cs index 3c6c073..a1d678f 100644 --- a/src/TelltaleToolKit/T3Types/StyleGuides/StyleGuideRef.cs +++ b/src/TelltaleToolKit/T3Types/StyleGuides/StyleGuideRef.cs @@ -1,10 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.StyleGuides; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class StyleGuideRef { [MetaMember("mhStyleGuide")] @@ -18,4 +18,4 @@ public class StyleGuideRef [MetaMember("mOverridden")] public bool Overridden { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Symbol.cs b/src/TelltaleToolKit/T3Types/Symbol.cs index 59b7aea..b10c932 100644 --- a/src/TelltaleToolKit/T3Types/Symbol.cs +++ b/src/TelltaleToolKit/T3Types/Symbol.cs @@ -16,7 +16,7 @@ public sealed class Symbol : IEquatable private Symbol(string name) { DebugString = name; - Crc64 = Utility.Hashing.Crc64.Compute(name); + Crc64 = Hashing.Crc64.Compute(name); } private Symbol(ulong crc64) @@ -67,7 +67,7 @@ private Symbol(string name, ulong crc64) /// Always returns false for unresolved symbols. /// public bool IsDebugStringConsistent => - DebugString is not null && Crc64 == Utility.Hashing.Crc64.Compute(DebugString); + DebugString is not null && Crc64 == Hashing.Crc64.Compute(DebugString); /// Creates a resolved symbol by computing CRC64 from . /// The name is lowercased before hashing, making symbols case-insensitive. @@ -91,7 +91,7 @@ public static Symbol FromExplicit(string name, ulong crc64) var symbol = new Symbol(name, crc64); Debug.Assert( symbol.IsDebugStringConsistent, - $"Symbol CRC mismatch: '{name}' hashes to 0x{Utility.Hashing.Crc64.Compute(name):X16}, but 0x{crc64:X16} was provided."); + $"Symbol CRC mismatch: '{name}' hashes to 0x{Hashing.Crc64.Compute(name):X16}, but 0x{crc64:X16} was provided."); return symbol; } @@ -99,7 +99,7 @@ public static Symbol FromExplicit(string name, ulong crc64) /// Returns true if would hash to this symbol's . /// public bool MatchesName(string name) - => Crc64 == Utility.Hashing.Crc64.Compute(name); + => Crc64 == Hashing.Crc64.Compute(name); /// /// Attaches a debug string to an unresolved symbol. @@ -107,8 +107,8 @@ public bool MatchesName(string name) /// The resolved name. public void Resolve(string name) { - Debug.Assert(Utility.Hashing.Crc64.Compute(name) == Crc64, - $"Resolve mismatch: '{name}' hashes to 0x{Utility.Hashing.Crc64.Compute(name):X16}, expected 0x{Crc64:X16}."); + Debug.Assert(Hashing.Crc64.Compute(name) == Crc64, + $"Resolve mismatch: '{name}' hashes to 0x{Hashing.Crc64.Compute(name):X16}, expected 0x{Crc64:X16}."); DebugString = name; } diff --git a/src/TelltaleToolKit/T3Types/TaskOwner.cs b/src/TelltaleToolKit/T3Types/TaskOwner.cs index 38b64bb..987ac14 100644 --- a/src/TelltaleToolKit/T3Types/TaskOwner.cs +++ b/src/TelltaleToolKit/T3Types/TaskOwner.cs @@ -1,12 +1,12 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class TaskOwner { [MetaMember("mTaskID")] public uint TaskId { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Text/TextAlignmentText.cs b/src/TelltaleToolKit/T3Types/Text/TextAlignmentText.cs index 925afc5..e42486c 100644 --- a/src/TelltaleToolKit/T3Types/Text/TextAlignmentText.cs +++ b/src/TelltaleToolKit/T3Types/Text/TextAlignmentText.cs @@ -1,12 +1,12 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Text; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class TextAlignmentType { [MetaMember("mAlignmentType")] public int AlignmentType { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Textures/AlphaMode.cs b/src/TelltaleToolKit/T3Types/Textures/AlphaMode.cs index dee3e51..0395dbb 100644 --- a/src/TelltaleToolKit/T3Types/Textures/AlphaMode.cs +++ b/src/TelltaleToolKit/T3Types/Textures/AlphaMode.cs @@ -1,13 +1,13 @@ -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Textures; -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum AlphaMode { Unknown = -1, NoAlpha = 0, AlphaTest = 1, AlphaBlend = 2, -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Textures/ColorMode.cs b/src/TelltaleToolKit/T3Types/Textures/ColorMode.cs index 09d8ff8..5ffd0b2 100644 --- a/src/TelltaleToolKit/T3Types/Textures/ColorMode.cs +++ b/src/TelltaleToolKit/T3Types/Textures/ColorMode.cs @@ -1,9 +1,9 @@ -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Textures; -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum ColorMode { @@ -12,4 +12,4 @@ public enum ColorMode eTxColorBlack = 1, eTxColorGrayscale = 2, eTxColorGrayscaleAlpha = 3, -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Textures/D3DTexture.cs b/src/TelltaleToolKit/T3Types/Textures/D3DTexture.cs index 7dcb370..611447d 100644 --- a/src/TelltaleToolKit/T3Types/Textures/D3DTexture.cs +++ b/src/TelltaleToolKit/T3Types/Textures/D3DTexture.cs @@ -40,12 +40,12 @@ namespace TelltaleToolKit.T3Types.Textures; // // public byte[] DdsTextureData { get; set; } = []; // -// public class D3DTextureClassSerializer : MetaClassSerializer +// public class D3DTextureClassSerializer : MetaSerializer // { // public override void Serialize(ref D3DTexture obj, MetaStream stream, MetaClass desc) // { // // Default Serializer -// new DefaultClassSerializer().Serialize(ref obj, stream, desc); +// new MetaClassSerializer().Serialize(ref obj, stream, desc); // // if (stream.Mode is MetaStreamMode.Write) // { diff --git a/src/TelltaleToolKit/T3Types/Textures/RenderSwizzleParams.cs b/src/TelltaleToolKit/T3Types/Textures/RenderSwizzleParams.cs index 1e26ab9..8c88b06 100644 --- a/src/TelltaleToolKit/T3Types/Textures/RenderSwizzleParams.cs +++ b/src/TelltaleToolKit/T3Types/Textures/RenderSwizzleParams.cs @@ -1,10 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Textures; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct RenderSwizzleParams { [MetaMember("mSwizzle[0]")] @@ -18,4 +18,4 @@ public struct RenderSwizzleParams [MetaMember("mSwizzle[3]")] public byte Channel3 { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Textures/T3Texture.cs b/src/TelltaleToolKit/T3Types/Textures/T3Texture.cs index a2cc716..3c4fc8a 100644 --- a/src/TelltaleToolKit/T3Types/Textures/T3Texture.cs +++ b/src/TelltaleToolKit/T3Types/Textures/T3Texture.cs @@ -1,15 +1,14 @@ using System.Numerics; -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Binary; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Encryption; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Properties; using TelltaleToolKit.T3Types.Textures.T3Types; -using TelltaleToolKit.Utility.Blowfish; namespace TelltaleToolKit.T3Types.Textures; -[MetaClassSerializerGlobal(typeof(Serializer))] +[MetaSerializer(typeof(Serializer))] public class T3Texture { // Most members here are before Poker Night 2 @@ -295,7 +294,7 @@ public void Encrypt(Blowfish blowfish) IsEncrypted = true; } - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public struct StreamHeader { [MetaMember("mRegionCount")] @@ -309,7 +308,7 @@ public struct StreamHeader } - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public class RegionStreamHeader { // mVersion >= 5 @@ -339,11 +338,11 @@ public class RegionStreamHeader public byte[] RegionData { get; set; } = []; } - public class Serializer : MetaClassSerializer + public class Serializer : MetaSerializer { - private static readonly DefaultClassSerializer DefaultT3TextureSerializer = new(); + private static readonly MetaClassSerializer s_metaClassT3TextureSerializer = new(); - public override void PreSerialize(ref T3Texture obj, MetaStream stream, MetaClassType? type = null) + public override void PreSerialize(ref T3Texture? obj, MetaStream stream, MetaClassType? type = null) { obj ??= new T3Texture(); } @@ -351,7 +350,7 @@ public override void PreSerialize(ref T3Texture obj, MetaStream stream, MetaClas public override void Serialize(ref T3Texture obj, MetaStream stream) { // Default Serializer - DefaultT3TextureSerializer.Serialize(ref obj, stream); + s_metaClassT3TextureSerializer.Serialize(ref obj, stream); // The default serializer will throw if there is no serialized T3Texture. MetaClass classDescription = stream.GetMetaClass(typeof(T3Texture))!; @@ -482,7 +481,7 @@ public override void Serialize(ref T3Texture obj, MetaStream stream) } } - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public class AuxiliaryData { [MetaMember("mType")] diff --git a/src/TelltaleToolKit/T3Types/Textures/T3Types/T3PlatformType.cs b/src/TelltaleToolKit/T3Types/Textures/T3Types/T3PlatformType.cs index 8cb8a01..712dc0d 100644 --- a/src/TelltaleToolKit/T3Types/Textures/T3Types/T3PlatformType.cs +++ b/src/TelltaleToolKit/T3Types/Textures/T3Types/T3PlatformType.cs @@ -1,26 +1,26 @@ using System.ComponentModel.DataAnnotations; -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Textures.T3Types; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct EnumBase { } -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct EnumPlatformType { [MetaMember("mVal")] public PlatformType Value { get; set; } - + [MetaMember("Baseclass_EnumBase")] public EnumBase EnumBase { get; set; } } -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum PlatformType { [Display(Name = "Default Mode")] @@ -71,4 +71,4 @@ public enum PlatformType [Display(Name = "Nintendo Switch")] NX = 15, Count = 16, -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Textures/T3Types/T3ResourceUsage.cs b/src/TelltaleToolKit/T3Types/Textures/T3Types/T3ResourceUsage.cs index 814adcc..a010909 100644 --- a/src/TelltaleToolKit/T3Types/Textures/T3Types/T3ResourceUsage.cs +++ b/src/TelltaleToolKit/T3Types/Textures/T3Types/T3ResourceUsage.cs @@ -1,9 +1,9 @@ -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Textures.T3Types; -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum T3ResourceUsage { // eResourceUsage @@ -12,4 +12,4 @@ public enum T3ResourceUsage System = 2, RenderTarget = 3, ShaderWrite = 4, -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Textures/T3Types/T3SamplerStateBlock.cs b/src/TelltaleToolKit/T3Types/Textures/T3Types/T3SamplerStateBlock.cs index 21d40bc..5c3cfbd 100644 --- a/src/TelltaleToolKit/T3Types/Textures/T3Types/T3SamplerStateBlock.cs +++ b/src/TelltaleToolKit/T3Types/Textures/T3Types/T3SamplerStateBlock.cs @@ -1,6 +1,6 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Textures.T3Types; @@ -14,10 +14,10 @@ namespace TelltaleToolKit.T3Types.Textures.T3Types; /// bit 13 : Gamma Correct (1 bit) /// bits 14..21 : Mip Bias (8 bits) /// Remaining bits unused/reserved. -/// +/// /// This class provides typed accessors and several utility functions. /// -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class T3SamplerStateBlock { [MetaMember("mData")] @@ -114,7 +114,7 @@ public enum T3SamplerStateValue WrapU = 0x0, // TextureWrapMode. WrapV = 0x1, // TextureWrapMode. Filtered = 0x2, // bool - BorderColor = 0x3, // TextureBorderColor + BorderColor = 0x3, // TextureBorderColor GammaCorrect = 0x4, // bool MipBias = 0x5, // char } @@ -133,4 +133,4 @@ public enum TextureBorderColor Black = 0, // Color(0,0,0,0) White = 1, // Color(1,1,1,1) } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Textures/T3Types/T3SurfaceFormat.cs b/src/TelltaleToolKit/T3Types/Textures/T3Types/T3SurfaceFormat.cs index 90e5a3d..2dc23fc 100644 --- a/src/TelltaleToolKit/T3Types/Textures/T3Types/T3SurfaceFormat.cs +++ b/src/TelltaleToolKit/T3Types/Textures/T3Types/T3SurfaceFormat.cs @@ -1,9 +1,9 @@ -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Textures.T3Types; -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum T3SurfaceFormat { // Note: Apparently, some of these formats are equivalent to each other. It's just that some are used for Direct3D9, while others are used for Direct3D11. @@ -223,4 +223,4 @@ public enum T3SurfaceFormat Count = 0x91, //91h Unknown = unchecked((int)0xFFFFFFFF), //0FFFFFFFFh -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Textures/T3Types/T3SurfaceGamma.cs b/src/TelltaleToolKit/T3Types/Textures/T3Types/T3SurfaceGamma.cs index 3469cea..631104a 100644 --- a/src/TelltaleToolKit/T3Types/Textures/T3Types/T3SurfaceGamma.cs +++ b/src/TelltaleToolKit/T3Types/Textures/T3Types/T3SurfaceGamma.cs @@ -1,15 +1,15 @@ -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Textures.T3Types; /// /// The gamma of the surface. In Telltale Tool it is represented as eSurfaceGamma. /// -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum T3SurfaceGamma { Unknown = -1, Linear = 0, sRGB = 1, -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Textures/T3Types/T3SurfaceMultisample.cs b/src/TelltaleToolKit/T3Types/Textures/T3Types/T3SurfaceMultisample.cs index 82de4df..ccb7863 100644 --- a/src/TelltaleToolKit/T3Types/Textures/T3Types/T3SurfaceMultisample.cs +++ b/src/TelltaleToolKit/T3Types/Textures/T3Types/T3SurfaceMultisample.cs @@ -1,9 +1,9 @@ -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Textures.T3Types; -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum T3SurfaceMultisample { // eSurfaceMultisample @@ -12,4 +12,4 @@ public enum T3SurfaceMultisample X4 = 2, // X4 X8 = 3, // X8 X16 = 4, // X16 -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Textures/T3Types/T3TextureLayout.cs b/src/TelltaleToolKit/T3Types/Textures/T3Types/T3TextureLayout.cs index a1a8f3e..85327c2 100644 --- a/src/TelltaleToolKit/T3Types/Textures/T3Types/T3TextureLayout.cs +++ b/src/TelltaleToolKit/T3Types/Textures/T3Types/T3TextureLayout.cs @@ -1,9 +1,9 @@ -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Textures.T3Types; -[MetaClassSerializerGlobal(typeof(EnumSerializer))] +[MetaSerializer(typeof(EnumSerializer))] public enum T3TextureLayout { @@ -14,4 +14,4 @@ public enum T3TextureLayout Texture2DArray = 3, TextureCubemapArray = 4, TextureCount = 5, -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Textures/T3Types/T3ToonGradientRegion.cs b/src/TelltaleToolKit/T3Types/Textures/T3Types/T3ToonGradientRegion.cs index 3472b6a..98d9f18 100644 --- a/src/TelltaleToolKit/T3Types/Textures/T3Types/T3ToonGradientRegion.cs +++ b/src/TelltaleToolKit/T3Types/Textures/T3Types/T3ToonGradientRegion.cs @@ -1,11 +1,11 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Mathematics; namespace TelltaleToolKit.T3Types.Textures.T3Types; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public struct T3ToonGradientRegion { [MetaMember("mColor")] @@ -13,4 +13,4 @@ public struct T3ToonGradientRegion [MetaMember("mSize")] public float Size { get; set; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/Textures/TextureType.cs b/src/TelltaleToolKit/T3Types/Textures/TextureType.cs index 0ad679f..ae562fb 100644 --- a/src/TelltaleToolKit/T3Types/Textures/TextureType.cs +++ b/src/TelltaleToolKit/T3Types/Textures/TextureType.cs @@ -1,9 +1,9 @@ -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Textures; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public enum TextureType { Unknown = 0, @@ -48,4 +48,4 @@ public enum TextureType LightmapFlatAtlas = 39, LookupXy = 40, ObjectNormalMap = 41, -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/TransitionMap.cs b/src/TelltaleToolKit/T3Types/TransitionMap.cs index cf8a7fb..c37094f 100644 --- a/src/TelltaleToolKit/T3Types/TransitionMap.cs +++ b/src/TelltaleToolKit/T3Types/TransitionMap.cs @@ -1,23 +1,23 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types; /// /// Main class for .tmap files. /// -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class TransitionMap { // Symbols can be both strings and crc64s. [MetaMember("mRemapper")] public Dictionary TransitionRemappers = new(); - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public class TransitionMapInfo { [MetaMember("mRemapper")] public TransitionRemapper Remapper = new(); } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/TransitionRemapper.cs b/src/TelltaleToolKit/T3Types/TransitionRemapper.cs index 04beb7a..bce5aab 100644 --- a/src/TelltaleToolKit/T3Types/TransitionRemapper.cs +++ b/src/TelltaleToolKit/T3Types/TransitionRemapper.cs @@ -1,13 +1,13 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Animations; namespace TelltaleToolKit.T3Types; -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class TransitionRemapper { [MetaMember("mRemapKeys")] public KeyframedValue RemapKeys = new(); -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/T3Types/UID.cs b/src/TelltaleToolKit/T3Types/UID.cs index 919a5e9..2075bbe 100644 --- a/src/TelltaleToolKit/T3Types/UID.cs +++ b/src/TelltaleToolKit/T3Types/UID.cs @@ -1,7 +1,6 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Binary; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; using TelltaleToolKit.T3Types.Properties; namespace TelltaleToolKit.T3Types.Common @@ -9,7 +8,7 @@ namespace TelltaleToolKit.T3Types.Common namespace UID { // TODO: Convert these into interfaces. - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public class Generator { [MetaMember("miNextUniqueID")] @@ -21,7 +20,7 @@ public interface IGenerator public Generator Generator { get; set; } } - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public class Owner { [MetaMember("miUniqueID")] @@ -53,12 +52,12 @@ public class ActingOverridablePropOwner // TODO: Add a proper serializer } - [MetaClassSerializerGlobal(typeof(ActingOverridablePropOwnerSerializer))] - public class ActingOverridablePropOwnerSerializer : MetaClassSerializer + [MetaSerializer(typeof(ActingOverridablePropOwnerSerializer))] + public class ActingOverridablePropOwnerSerializer : MetaSerializer { - private static readonly DefaultClassSerializer DefaultSerializer = new(); + private static readonly MetaClassSerializer s_metaClassSerializer = new(); - public override void PreSerialize(ref ActingOverridablePropOwner obj, MetaStream stream, + public override void PreSerialize(ref ActingOverridablePropOwner? obj, MetaStream stream, MetaClassType? type = null) { if (obj is null) @@ -81,8 +80,8 @@ public override void Serialize(ref ActingOverridablePropOwner obj, MetaStream st if (value == ActingOverridablePropOwner.kHeader) { - DefaultSerializer.PreSerialize(ref obj, stream); - DefaultSerializer.Serialize(ref obj, stream); + s_metaClassSerializer.PreSerialize(ref obj, stream); + s_metaClassSerializer.Serialize(ref obj, stream); return; } diff --git a/src/TelltaleToolKit/T3Types/Vers.cs b/src/TelltaleToolKit/T3Types/Vers.cs index 6036193..9f1edee 100644 --- a/src/TelltaleToolKit/T3Types/Vers.cs +++ b/src/TelltaleToolKit/T3Types/Vers.cs @@ -1,5 +1,4 @@ -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Binary; +using TelltaleToolKit.Meta.Serialization; namespace TelltaleToolKit.T3Types; @@ -27,8 +26,8 @@ public override string ToString() => } // TODO: Convert this to the meta type system. - [MetaClassSerializerGlobal(typeof(VersSerializer))] - public class VersSerializer : MetaClassSerializer + [MetaSerializer(typeof(VersSerializer))] + public class VersSerializer : MetaSerializer { public override void Serialize(ref Vers obj, MetaStream stream) { diff --git a/src/TelltaleToolKit/T3Types/Voice/VoiceData.cs b/src/TelltaleToolKit/T3Types/Voice/VoiceData.cs index c773b33..998b967 100644 --- a/src/TelltaleToolKit/T3Types/Voice/VoiceData.cs +++ b/src/TelltaleToolKit/T3Types/Voice/VoiceData.cs @@ -1,11 +1,10 @@ -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Binary; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.Voice; -[MetaClassSerializerGlobal(typeof(Serializer))] +[MetaSerializer(typeof(Serializer))] public class VoiceData { [MetaMember("mbEncrypted")] @@ -32,14 +31,14 @@ public class VoiceData public byte[] VoiceDataBuffer { get; set; } - public class Serializer : MetaClassSerializer + public class Serializer : MetaSerializer { - private static readonly DefaultClassSerializer DefaultSerializer = new(); + private static readonly MetaClassSerializer s_metaClassSerializer = new(); public override void Serialize(ref VoiceData obj, MetaStream stream) { - DefaultSerializer.PreSerialize(ref obj, stream); - DefaultSerializer.Serialize(ref obj, stream); + s_metaClassSerializer.PreSerialize(ref obj, stream); + s_metaClassSerializer.Serialize(ref obj, stream); if (stream.Mode is MetaStreamMode.Write) { diff --git a/src/TelltaleToolKit/T3Types/WalkBoxes/WalkBoxes.cs b/src/TelltaleToolKit/T3Types/WalkBoxes/WalkBoxes.cs index 6da56ae..c79a47e 100644 --- a/src/TelltaleToolKit/T3Types/WalkBoxes/WalkBoxes.cs +++ b/src/TelltaleToolKit/T3Types/WalkBoxes/WalkBoxes.cs @@ -1,14 +1,14 @@ using System.Numerics; -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Serializers; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Serializers; namespace TelltaleToolKit.T3Types.WalkBoxes; /// /// Represents the class for .wbox files. /// -[MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] +[MetaSerializer(typeof(MetaClassSerializer))] public class WalkBoxes { [MetaMember("mName")] @@ -26,7 +26,7 @@ public class WalkBoxes [MetaMember("mQuads")] public List Quads { get; set; } = []; - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public class Edge { [MetaMember("mV1")] @@ -48,7 +48,7 @@ public class Edge public float MaxRadius { get; set; } } - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public class Tri { [MetaMember("mFlags")] @@ -76,20 +76,20 @@ public class Tri public float[] VertScales { get; set; } = new float[3]; } - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public struct Vert { [MetaMember("mFlags")] - public Flags Flags { get; set; } + public Flags Flags { get; set; } [MetaMember("mPos")] - public Vector3 Position { get; set; } + public Vector3 Position { get; set; } } - [MetaClassSerializerGlobal(typeof(DefaultClassSerializer))] + [MetaSerializer(typeof(MetaClassSerializer))] public class Quad { [MetaMember("mVerts")] public int[] Verts { get; set; } = new int[4]; } -} \ No newline at end of file +} diff --git a/src/TelltaleToolKit/Toolkit.cs b/src/TelltaleToolKit/Toolkit.cs index 6671eda..01d338c 100644 --- a/src/TelltaleToolKit/Toolkit.cs +++ b/src/TelltaleToolKit/Toolkit.cs @@ -1,13 +1,14 @@ using System.Text; using System.Text.Json; -using TelltaleToolKit.GamesDatabase; +using TelltaleToolKit.Encryption; +using TelltaleToolKit.Games; +using TelltaleToolKit.Hashing; +using TelltaleToolKit.IO.Archives; +using TelltaleToolKit.IO.Archives.Formats; using TelltaleToolKit.Logging; -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; using TelltaleToolKit.T3Types; -using TelltaleToolKit.TelltaleArchives; -using TelltaleToolKit.TelltaleArchives.Formats; -using TelltaleToolKit.Utility.Blowfish; namespace TelltaleToolKit; @@ -40,8 +41,8 @@ private Toolkit(Configuration config) Config = config ?? throw new ArgumentNullException(nameof(config)); ClassRegistry = new MetaClassRegistry(); - SerializerSelector = new MetaClassSerializerSelector(); - GlobalHashDatabase = new HashDatabase.HashDatabase(); + SerializerSelector = new MetaSerializerSelector(); + GlobalHashDatabase = new HashDatabase(); LoadMetaClassDescriptions(); LoadGameProfiles(config.DataFolder); @@ -82,12 +83,12 @@ public static Toolkit Instance /// Gets the global hash database used for symbol resolution. /// Workspace-local databases are checked after this one. /// - public HashDatabase.HashDatabase GlobalHashDatabase { get; } + public HashDatabase GlobalHashDatabase { get; } /// /// Gets the serializer selector used to pick the right serializer for a given type. /// - public MetaClassSerializerSelector SerializerSelector { get; } + public MetaSerializerSelector SerializerSelector { get; } /// /// Gets all registered game profiles, keyed by profile name (case-insensitive). @@ -223,6 +224,7 @@ public void ResolveSymbols(IEnumerable symbols) /// /// The target type. It must have a parameterless constructor. /// Path to the MetaStream file on disk. + /// Optional workspace for additional context. /// /// A tuple containing the deserialized object and the @params embedded in the stream, /// or (null, null) if reading or parsing fails. @@ -267,6 +269,7 @@ public void ResolveSymbols(IEnumerable symbols) /// A readable stream positioned at the start of a MetaStream file. /// Not disposed by this method. /// + /// Optional workspace for additional context. /// /// A tuple containing the deserialized object and the @params embedded in the stream, /// or (null, null) if parsing fails. @@ -290,6 +293,7 @@ public void ResolveSymbols(IEnumerable symbols) /// /// The target type. It must have a parameterless constructor. /// Path to the MetaStream file on disk. + /// Optional workspace for additional context. /// /// The deserialized object, or if reading or parsing fails. /// @@ -328,6 +332,7 @@ public void ResolveSymbols(IEnumerable symbols) /// A readable stream positioned at the start of a MetaStream file. /// Not disposed by this method. /// + /// Optional workspace for additional context. /// /// The deserialized object, or if parsing fails. /// @@ -500,13 +505,13 @@ public static bool IsMetaFile(Stream stream) /// /// Returns the typed serializer for . /// - public MetaClassSerializer GetSerializer() where T : new() + public MetaSerializer GetSerializer() where T : new() => SerializerSelector.GetSerializer(); /// /// Returns the serializer for the given runtime . /// - public MetaClassSerializer GetSerializer(Type type) + public MetaSerializer GetSerializer(Type type) => SerializerSelector.GetSerializer(type); // ------------------------------------------------------------------------- @@ -665,9 +670,9 @@ public class Configuration /// /// Gets or sets a value indicating whether symbols found in the - /// table are automatically + /// table are automatically /// resolved against the global hash database after every successful - /// call. + /// call. /// /// Individual call sites can override this with the autoResolveSymbols /// parameter: forces resolution, diff --git a/src/TelltaleToolKit/Utility/Compression/ChunkDecoder.cs b/src/TelltaleToolKit/Utility/Compression/ChunkDecoder.cs deleted file mode 100644 index 10bd278..0000000 --- a/src/TelltaleToolKit/Utility/Compression/ChunkDecoder.cs +++ /dev/null @@ -1,150 +0,0 @@ -using System.IO.Compression; -using ICSharpCode.SharpZipLib.Zip.Compression.Streams; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.TelltaleArchives; - -namespace TelltaleToolKit.Utility.Compression; - -/// -/// Provides chunk-level decrypt + decompress logic. -/// -/// -/// -/// All methods are thread-safe with respect to the archive stream as long as each -/// concurrent caller holds its own instance and does not -/// share a reference. -/// -/// -internal static class ChunkDecoder -{ - // ------------------------------------------------------------------------- - // Build a block-offset table for the range [blockStart, blockEnd] - // ------------------------------------------------------------------------- - - // ------------------------------------------------------------------------- - // Helpers - // ------------------------------------------------------------------------- - - /// Reads exactly buffer.Length bytes from . - internal static void ReadExact(Stream stream, byte[] buffer) - { - int total = 0; - while (total < buffer.Length) - { - int read = stream.Read(buffer, total, buffer.Length - total); - if (read == 0) - { - throw new EndOfStreamException( - $"Unexpected end of stream after {total} / {buffer.Length} bytes."); - } - - total += read; - } - } - - public static byte[] DecompressBlock(byte[] compressedData, int expectedSize, ref ArchiveFlags flags) - { - // This is a hack? In TWD:DE, 401_txmesh, there's a page which is the same size as the expected size (65535) - // C#'s raw deflate fails. - // ttarchext returns the same data: - // https://github.com/infernokun/TelltaleGamesExtractionGUI/blob/fec9fc1a70b545bcc67062fedc3fe3f7cd0d3e1b/bin/Debug/net6.0-windows/ttarchext/ttarchext.c#L1512 - if (compressedData.Length == expectedSize) - { - return compressedData; - } - - // Try both Deflate and Zlib if both flags are set - // TODO: Investigate ttarch - // CSI games use zlib compression instead of the regular raw deflate. - // According to TTG Tools, version 8 archives use zlib (presumably for the files themselves) - if (flags.HasFlag(ArchiveFlags.IsRawDeflateCompressed) && flags.HasFlag(ArchiveFlags.IsZlibCompressed)) - { - // Compression compressionAlgorithm = DetectCompressionAlgorithm(compressedData); - - try - { - byte[] result = Decompress(ms => new DeflateStream(ms, CompressionMode.Decompress)); - flags &= ~ArchiveFlags.IsZlibCompressed; - return result; - } - catch (Exception) - { - // flags &= ~ContainerFlags.IsRawDeflateCompressed; - } - - try - { - byte[] result = Decompress(ms => new InflaterInputStream(ms)); - flags &= ~ArchiveFlags.IsRawDeflateCompressed; - return result; - } - catch (Exception) - { - // flags &= ~ContainerFlags.IsZlibCompressed; - } - - throw new InvalidDataException("Compression not supported"); - } - - if (flags.HasFlag(ArchiveFlags.IsRawDeflateCompressed)) - { - return Decompress(ms => new DeflateStream(ms, CompressionMode.Decompress)); - } - - if (flags.HasFlag(ArchiveFlags.IsZlibCompressed)) - { - return Decompress(ms => new InflaterInputStream(ms)); - } - - if (flags.HasFlag(ArchiveFlags.IsOodleCompressed)) - { - // TODO: Add Oodle compression. - throw new NotSupportedException("Oodle compression is not supported yet."); - } - - // No compression, return the original data - return compressedData; - - // Local function to handle decompression - byte[] Decompress(Func streamFactory) - { - using MemoryStream outputStream = new(expectedSize); - using Stream decompressStream = streamFactory(new MemoryStream(compressedData)); - decompressStream.CopyTo(outputStream); - return outputStream.ToArray(); - } - } - - private static Compression DetectCompressionAlgorithm(byte[] chunk) - { - // Zlib header: first byte 0x78, second byte in {0x9C, 0xDA, 0x01, 0x5E, 0x9E, ...} - if (chunk[0] == 0x78 && (chunk[1] & 0xF0) == 0xC0) // 0x78 0x9C, 0x78 0xDA, etc. - { - return Compression.Zlib; - } - - return Compression.Deflate; // raw Deflate has no header - } - - /// - /// Compresses a single chunk using the specified algorithm. - /// - /// Number of compressed bytes written into . - public static int CompressBlock(ReadOnlySpan input, Compression algorithm, byte[] outputBuffer) - { - using MemoryStream ms = new(outputBuffer, true); - if (algorithm == Compression.Zlib) - { - using DeflaterOutputStream zlib = new(ms); - zlib.Write(input); - zlib.Finish(); - } - else // Deflate (raw) - { - using DeflateStream deflate = new(ms, CompressionLevel.Optimal, true); - deflate.Write(input); - } - - return (int)ms.Position; - } -} diff --git a/src/TelltaleToolKit/Utility/Compression/Compression.cs b/src/TelltaleToolKit/Utility/Compression/Compression.cs deleted file mode 100644 index 4b1b516..0000000 --- a/src/TelltaleToolKit/Utility/Compression/Compression.cs +++ /dev/null @@ -1,19 +0,0 @@ -namespace TelltaleToolKit.Utility.Compression; - -/// Compression algorithm to use when writing archive chunks. -public enum Compression -{ - /// No compression. - None, - - /// Raw DEFLATE (no zlib header). Used by most Telltale games. - Deflate, - - /// Zlib-wrapped DEFLATE. Used by some CSI and earlier titles. - Zlib, - - /// - /// Oodle compression. - /// - Oodle -} diff --git a/src/TelltaleToolKit/Utility/Hashing/Crc32Utility.cs b/src/TelltaleToolKit/Utility/Hashing/Crc32Utility.cs deleted file mode 100644 index 2b2f9de..0000000 --- a/src/TelltaleToolKit/Utility/Hashing/Crc32Utility.cs +++ /dev/null @@ -1,125 +0,0 @@ -using System.IO.Hashing; -using System.Text; -using TelltaleToolKit.Reflection; - -namespace TelltaleToolKit.Utility.Hashing; - -/// -/// MetaClass version info (crc32) calculating utility. -/// This is only useful for looking at how the game calculate the versions themselves. -/// -public static class Crc32Utilities -{ - /// - /// Calculate CRC32 for a given MetaClass. - /// This CRC32 is used for the 2016 version of the Telltale Tool. - /// - /// - /// - public static uint CalculateCRC32_MSV6(MetaClass metaClass) - { - // if it's blocked, start with 0xFFFFFFFF (or -1) - int buf = metaClass.ClassType.IsBlocked() ? -1 : 0; - var crc32 = new Crc32(); - crc32.Append(BitConverter.GetBytes(buf)); - - foreach (MetaMember member in metaClass.Members) - { - if (member.Flags.HasFlag(MetaFlags.MetaSerializeDisable)) - continue; - bool isMemberBlocked = member.Type.IsBlocked(); - - // Append member Name - crc32.Append(Encoding.UTF8.GetBytes(member.MemberName)); - // Append member Type CRC64 - crc32.Append(BitConverter.GetBytes(member.Type.Symbol.Crc64)); - // Append 1 or 0 whether it's blocked or not - crc32.Append(new[] { Convert.ToByte(isMemberBlocked) }); - } - - return crc32.GetCurrentHashAsUInt32(); - } - - /// - /// Calculate CRC32 for a given MetaClass. - /// This CRC32 is used for the 2005 version of the Telltale Tool. - /// - /// - /// - public static uint CalculateCRC32_MBIN(MetaClass metaClass) - { - // Initialize CRC with 0xFFFFFFFF if class is blocked (not NonBlocked), 0 otherwise - // if it's blocked, start with 0xFFFFFFFF - uint buf = metaClass.ClassType.IsBlocked() ? 0xFFFF : 0u; - var crc32 = new Crc32(); - crc32.Append(BitConverter.GetBytes(buf)); - - foreach (MetaMember member in metaClass.Members) - { - if (member.Flags.HasFlag(MetaFlags.MetaSerializeDisable)) - continue; - - crc32.Append(Encoding.UTF8.GetBytes(member.MemberName)); - - string typeName = member.Type.FullTypeName; - // Hack for inherited classes. The types of all `Baseclass_` members are pointers. - // Presumably that is fixed after the first MBIN games. - if (member.MemberName.StartsWith("Baseclass_")) - { - typeName += " *"; - } - crc32.Append(Encoding.UTF8.GetBytes(typeName)); - } - - return crc32.GetCurrentHashAsUInt32(); - } - - /// - /// Calculate CRC32 for a given MetaClass. - /// This CRC32 is used for the 2008 version of the Telltale Tool. - /// - /// - /// - public static uint CalculateCRC32_MTRE(MetaClass metaClass) - { - int buf = metaClass.ClassType.IsBlocked() ? -1 : 0; // if it's blocked, start with 0xFFFFFFFF (or -1) - var crc32 = new Crc32(); - crc32.Append(BitConverter.GetBytes(buf)); - - foreach (MetaMember member in from member in metaClass.Members where !member.Flags.HasFlag(MetaFlags.MetaSerializeDisable) let isMemberBlocked = member.Type.IsBlocked() select member) - { - crc32.Append(Encoding.UTF8.GetBytes(member.MemberName)); // Append member name - crc32.Append(BitConverter.GetBytes(member.Type.Symbol.Crc64)); // TODO: Get CRC32 - } - - return crc32.GetCurrentHashAsUInt32(); - } - - /// - /// Calculate CRC32 for a given MetaClass. - /// This CRC32 is used for the 2013 version of the Telltale Tool. - /// - /// - /// - public static uint CalculateCRC32_MSV5(MetaClass metaClass) - { - int buf = metaClass.ClassType.IsBlocked() ? -1 : 0; // if it's blocked, start with 0xFFFFFFFF (or -1) - var crc32 = new Crc32(); - crc32.Append(BitConverter.GetBytes(buf)); - - foreach (MetaMember member in metaClass.Members) - { - if (member.Flags.HasFlag(MetaFlags.MetaSerializeDisable)) - continue; - - bool isMemberBlocked = member.Type.IsBlocked(); - - crc32.Append(Encoding.UTF8.GetBytes(member.MemberName)); // Append member name - crc32.Append(BitConverter.GetBytes(member.Type.Symbol.Crc64)); // Append member Type CRC64 - crc32.Append(new[] { Convert.ToByte(isMemberBlocked) }); // Append 1 or 0 whether it's blocked or not - crc32.Append(BitConverter.GetBytes(member.Type.Symbol.Crc64)); // TODO: Get CRC32 - } - - return crc32.GetCurrentHashAsUInt32(); - } -} diff --git a/src/TelltaleToolKit/Workspace.cs b/src/TelltaleToolKit/Workspace.cs index a398237..2249f4d 100644 --- a/src/TelltaleToolKit/Workspace.cs +++ b/src/TelltaleToolKit/Workspace.cs @@ -1,13 +1,13 @@ using System.Text; using Lua; -using TelltaleToolKit.GamesDatabase; -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Resource; -using TelltaleToolKit.Serialization; +using TelltaleToolKit.Encryption; +using TelltaleToolKit.Games; +using TelltaleToolKit.Hashing; +using TelltaleToolKit.IO.Archives; +using TelltaleToolKit.IO.Resources; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; using TelltaleToolKit.T3Types; -using TelltaleToolKit.TelltaleArchives; -using TelltaleToolKit.Utility.Blowfish; -using TelltaleToolKit.Utility.Hashing; namespace TelltaleToolKit; @@ -60,7 +60,7 @@ internal Workspace(string name, Toolkit toolkit, GameProfile profile) Name = name ?? throw new ArgumentNullException(nameof(name)); _toolkit = toolkit ?? throw new ArgumentNullException(nameof(toolkit)); Profile = profile ?? throw new ArgumentNullException(nameof(profile)); - LocalHashDatabase = new HashDatabase.HashDatabase(); + LocalHashDatabase = new HashDatabase(); bool isModifiedBlowfish = Profile.TtarchVersion >= TTArchiveVersion.Seven; Blowfish = new Blowfish(profile.BlowfishKey, isModifiedBlowfish); @@ -99,7 +99,7 @@ internal Workspace(string name, Toolkit toolkit, GameProfile profile) /// Gets the workspace-local hash database used for symbol resolution. /// Entries here complement (and are checked after) the global database in . /// - public HashDatabase.HashDatabase LocalHashDatabase { get; } + public HashDatabase LocalHashDatabase { get; } /// /// Gets or sets a value indicating whether symbols are automatically resolved after diff --git a/tools/TTKDatabaseGenerator/Program.cs b/tools/TTKDatabaseGenerator/Program.cs index 3aa2d28..fade4e6 100644 --- a/tools/TTKDatabaseGenerator/Program.cs +++ b/tools/TTKDatabaseGenerator/Program.cs @@ -6,13 +6,14 @@ using System.Text.Encodings.Web; using System.Text.Json; using TelltaleToolKit; -using TelltaleToolKit.GamesDatabase; -using TelltaleToolKit.Reflection; -using TelltaleToolKit.Serialization; -using TelltaleToolKit.Serialization.Binary; -using TelltaleToolKit.TelltaleArchives; -using TelltaleToolKit.Utility.Blowfish; -using TelltaleToolKit.Utility.Lua; +using TelltaleToolKit.Encryption; +using TelltaleToolKit.Games; +using TelltaleToolKit.IO.Archives; +using TelltaleToolKit.Lua; +using TelltaleToolKit.Meta; +using TelltaleToolKit.Meta.Reflection; +using TelltaleToolKit.Meta.Serialization; +using TelltaleToolKit.Meta.Serialization.Binary; namespace DatabaseGenerator;