ItsTheSky/GsaViewer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

Add project restore files and NuGet cache for GsaViewer

Browse Source 
- Created project.nuget.cache to store NuGet package cache information.
- Added project.packagespec.json to define project restore settings and dependencies.
- Included rider.project.restore.info for Rider IDE integration.
This commit is contained in:
Nicolas RACOT
2026-04-09 16:56:58 +02:00
commit d6d621dc92
170 changed files with 8191 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

88
GsaEditor.Core/Compression/ZlibHelper.cs Normal file
View File

@ -0,0 +1,88 @@
using System.IO.Compression;
namespace GsaEditor.Core.Compression;
/// <summary>
/// Provides zlib compression and decompression utilities for GSA archive entries.
/// The GSA format stores zlib-wrapped data: 2-byte header (CMF+FLG) + deflate stream + 4-byte Adler-32 checksum.
/// This helper skips the 2-byte zlib header and uses <see cref="DeflateStream"/> for the core deflate data.
/// </summary>
public static class ZlibHelper
{
/// <summary>
/// Decompresses zlib-wrapped data into a byte array of the specified original size.
/// Skips the 2-byte zlib header before feeding data to <see cref="DeflateStream"/>.
/// </summary>
/// <param name="compressedData">The zlib-wrapped compressed data (header + deflate + checksum).</param>
/// <param name="originalLength">The expected decompressed size in bytes.</param>
/// <returns>The decompressed byte array.</returns>
/// <exception cref="InvalidDataException">Thrown when decompression fails or data is corrupt.</exception>
public static byte[] Decompress(byte[] compressedData, uint originalLength)
{
if (compressedData.Length < 2)
throw new InvalidDataException("Compressed data is too short to contain a zlib header.");
// Skip the 2-byte zlib header (typically 0x78 0x9C for default compression)
using var ms = new MemoryStream(compressedData, 2, compressedData.Length - 2);
using var deflate = new DeflateStream(ms, CompressionMode.Decompress);
var result = new byte[originalLength];
int totalRead = 0;
while (totalRead < result.Length)
{
int bytesRead = deflate.Read(result, totalRead, result.Length - totalRead);
if (bytesRead == 0)
break;
totalRead += bytesRead;
}
return result;
}
/// <summary>
/// Compresses data using zlib format: 2-byte header + deflate stream + 4-byte Adler-32 checksum.
/// </summary>
/// <param name="data">The uncompressed data to compress.</param>
/// <returns>The zlib-wrapped compressed byte array.</returns>
public static byte[] Compress(byte[] data)
{
using var output = new MemoryStream();
// Write zlib header: CMF=0x78 (deflate method, 32K window), FLG=0x9C (default level, valid check bits)
output.WriteByte(0x78);
output.WriteByte(0x9C);
using (var deflate = new DeflateStream(output, CompressionLevel.Optimal, leaveOpen: true))
{
deflate.Write(data, 0, data.Length);
}
// Write Adler-32 checksum in big-endian byte order
uint adler = ComputeAdler32(data);
output.WriteByte((byte)(adler >> 24));
output.WriteByte((byte)(adler >> 16));
output.WriteByte((byte)(adler >> 8));
output.WriteByte((byte)adler);
return output.ToArray();
}
/// <summary>
/// Computes the Adler-32 checksum of the given data.
/// </summary>
/// <param name="data">The data to checksum.</param>
/// <returns>The 32-bit Adler-32 checksum value.</returns>
private static uint ComputeAdler32(byte[] data)
{
const uint MOD_ADLER = 65521;
uint a = 1, b = 0;
for (int i = 0; i < data.Length; i++)
{
a = (a + data[i]) % MOD_ADLER;
b = (b + a) % MOD_ADLER;
}
return (b << 16) | a;
}
}

8
GsaEditor.Core/GsaEditor.Core.csproj Normal file
View File

@ -0,0 +1,8 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net8.0</TargetFramework>
<Nullable>enable</Nullable>
<ImplicitUsings>enable</ImplicitUsings>
<GenerateDocumentationFile>true</GenerateDocumentationFile>
</PropertyGroup>
</Project>

70
GsaEditor.Core/IO/GsaIndexReader.cs Normal file
View File

@ -0,0 +1,70 @@
using System.Xml.Linq;
namespace GsaEditor.Core.IO;
/// <summary>
/// Represents a single entry parsed from a .idx NML index file.
/// </summary>
public class GsaIndexEntry
{
/// <summary>
/// The file alias (relative path) of the entry.
/// </summary>
public string Id { get; set; } = string.Empty;
/// <summary>
/// Compression method: 0 = raw, 1 = zlib.
/// </summary>
public int Method { get; set; }
/// <summary>
/// Original (decompressed) size in bytes.
/// </summary>
public uint Length { get; set; }
/// <summary>
/// Compressed size in bytes.
/// </summary>
public uint CompressedLength { get; set; }
/// <summary>
/// Byte offset of the data block within the archive.
/// </summary>
public long Offset { get; set; }
}
/// <summary>
/// Parses .idx NML index files (XML-compatible format) into a list of <see cref="GsaIndexEntry"/>.
/// </summary>
public static class GsaIndexReader
{
/// <summary>
/// Reads index entries from the specified .idx file.
/// </summary>
/// <param name="filePath">The path to the .idx file.</param>
/// <returns>A list of parsed index entries.</returns>
public static List<GsaIndexEntry> Read(string filePath)
{
var doc = XDocument.Load(filePath);
var entries = new List<GsaIndexEntry>();
var root = doc.Root;
if (root == null || root.Name.LocalName != "Index")
return entries;
foreach (var entryEl in root.Elements("Entry"))
{
var entry = new GsaIndexEntry
{
Id = entryEl.Element("Id")?.Value ?? string.Empty,
Method = int.TryParse(entryEl.Element("Method")?.Value, out var m) ? m : 0,
Length = uint.TryParse(entryEl.Element("Len")?.Value, out var l) ? l : 0,
CompressedLength = uint.TryParse(entryEl.Element("CompLen")?.Value, out var cl) ? cl : 0,
Offset = long.TryParse(entryEl.Element("Offset")?.Value, out var o) ? o : 0
};
entries.Add(entry);
}
return entries;
}
}

36
GsaEditor.Core/IO/GsaIndexWriter.cs Normal file
View File

@ -0,0 +1,36 @@
using System.Xml.Linq;
using GsaEditor.Core.Models;
namespace GsaEditor.Core.IO;
/// <summary>
/// Writes a .idx NML index file from a <see cref="GsaArchive"/>.
/// The index file is XML-compatible and lists each entry with its alias, compression method,
/// sizes, and data offset for fast lookup without a full sequential scan.
/// </summary>
public static class GsaIndexWriter
{
/// <summary>
/// Writes the index file for the given archive to the specified path.
/// </summary>
/// <param name="archive">The archive whose entries will be indexed.</param>
/// <param name="filePath">The output .idx file path.</param>
public static void Write(GsaArchive archive, string filePath)
{
var doc = new XDocument(
new XElement("Index",
archive.Entries.Select(e =>
new XElement("Entry",
new XElement("Id", e.Alias),
new XElement("Method", e.IsCompressed ? 1 : 0),
new XElement("Len", e.OriginalLength),
new XElement("CompLen", e.CompressedLength),
new XElement("Offset", e.DataOffset)
)
)
)
);
doc.Save(filePath);
}
}

163
GsaEditor.Core/IO/GsaReader.cs Normal file
View File

@ -0,0 +1,163 @@
using System.Text;
using GsaEditor.Core.Models;
namespace GsaEditor.Core.IO;
/// <summary>
/// Reads a .gsa binary archive from a stream or file and produces a <see cref="GsaArchive"/>.
/// Supports both NARC (legacy) and NARD (enhanced with padding) format variants.
/// </summary>
public static class GsaReader
{
/// <summary>Magic word for the NARC (legacy) format.</summary>
private const uint MAGIC_NARC = 0x4E415243;
/// <summary>Magic word for the NARD (enhanced) format.</summary>
private const uint MAGIC_NARD = 0x4E415244;
/// <summary>Maximum allowed alias length in characters.</summary>
private const int MAX_ALIAS_LENGTH = 511;
/// <summary>
/// Reads a GSA archive from the specified file path.
/// </summary>
/// <param name="filePath">The path to the .gsa archive file.</param>
/// <returns>A fully populated <see cref="GsaArchive"/>.</returns>
/// <exception cref="InvalidDataException">Thrown if the file has an invalid magic word.</exception>
public static GsaArchive Read(string filePath)
{
using var stream = File.OpenRead(filePath);
return Read(stream);
}
/// <summary>
/// Reads a GSA archive from a stream by performing a sequential scan of all entries.
/// </summary>
/// <param name="stream">A readable, seekable stream positioned at the start of the archive.</param>
/// <returns>A fully populated <see cref="GsaArchive"/>.</returns>
/// <exception cref="InvalidDataException">Thrown if the stream has an invalid magic word.</exception>
public static GsaArchive Read(Stream stream)
{
using var reader = new BinaryReader(stream, Encoding.ASCII, leaveOpen: true);
var archive = new GsaArchive();
// Read global header
uint magic = reader.ReadUInt32();
if (magic == MAGIC_NARC)
{
archive.Format = GsaFormat.NARC;
}
else if (magic == MAGIC_NARD)
{
archive.Format = GsaFormat.NARD;
archive.OffsetPadding = reader.ReadInt32();
archive.SizePadding = reader.ReadInt32();
}
else
{
throw new InvalidDataException(
$"Invalid GSA magic word: 0x{magic:X8}. Expected NARC (0x{MAGIC_NARC:X8}) or NARD (0x{MAGIC_NARD:X8}).");
}
// Sequentially read all entries until EOF
while (stream.Position < stream.Length)
{
var entry = ReadEntry(reader, archive);
if (entry == null)
break;
archive.Entries.Add(entry);
}
return archive;
}
/// <summary>
/// Reads a single file entry from the current stream position.
/// </summary>
/// <param name="reader">The binary reader positioned at the start of an entry.</param>
/// <param name="archive">The parent archive (used for NARD padding alignment).</param>
/// <returns>A populated <see cref="GsaEntry"/>, or null if no more entries can be read.</returns>
private static GsaEntry? ReadEntry(BinaryReader reader, GsaArchive archive)
{
var stream = reader.BaseStream;
if (stream.Position >= stream.Length)
return null;
// NARD: align stream position before reading entry header
if (archive.Format == GsaFormat.NARD && archive.OffsetPadding > 0)
AlignStream(stream, archive.OffsetPadding);
// Check if enough bytes remain for the alias length field
if (stream.Length - stream.Position < 4)
return null;
// Read alias
uint aliasLength = reader.ReadUInt32();
if (aliasLength == 0 || aliasLength > MAX_ALIAS_LENGTH)
return null;
if (stream.Length - stream.Position < aliasLength)
return null;
byte[] aliasBytes = reader.ReadBytes((int)aliasLength);
string alias = Encoding.ASCII.GetString(aliasBytes);
// Read compression flag (bit 0: 1=compressed, 0=raw)
byte compressionByte = reader.ReadByte();
bool isCompressed = (compressionByte & 0x01) != 0;
// Read original (decompressed) length
uint originalLength = reader.ReadUInt32();
// Read compressed length (only present if compressed)
uint compressedLength;
if (isCompressed)
{
compressedLength = reader.ReadUInt32();
}
else
{
compressedLength = originalLength;
}
// NARD: align stream position before reading the data block
if (archive.Format == GsaFormat.NARD && archive.OffsetPadding > 0)
AlignStream(stream, archive.OffsetPadding);
// Read raw data
long dataOffset = stream.Position;
uint dataSize = isCompressed ? compressedLength : originalLength;
if (stream.Length - stream.Position < dataSize)
return null;
byte[] rawData = reader.ReadBytes((int)dataSize);
return new GsaEntry
{
Alias = alias,
IsCompressed = isCompressed,
OriginalLength = originalLength,
CompressedLength = compressedLength,
RawData = rawData,
DataOffset = dataOffset
};
}
/// <summary>
/// Advances the stream position to the next aligned boundary.
/// </summary>
/// <param name="stream">The stream to align.</param>
/// <param name="alignment">The alignment boundary in bytes.</param>
private static void AlignStream(Stream stream, int alignment)
{
if (alignment <= 1) return;
long pos = stream.Position;
long remainder = pos % alignment;
if (remainder != 0)
{
stream.Position = pos + (alignment - remainder);
}
}
}

114
GsaEditor.Core/IO/GsaWriter.cs Normal file
View File

@ -0,0 +1,114 @@
using System.Text;
using GsaEditor.Core.Models;
namespace GsaEditor.Core.IO;
/// <summary>
/// Writes a <see cref="GsaArchive"/> to a binary .gsa stream or file.
/// Supports both NARC (legacy) and NARD (enhanced with padding) format variants.
/// </summary>
public static class GsaWriter
{
/// <summary>Magic word for the NARC (legacy) format.</summary>
private const uint MAGIC_NARC = 0x4E415243;
/// <summary>Magic word for the NARD (enhanced) format.</summary>
private const uint MAGIC_NARD = 0x4E415244;
/// <summary>
/// Writes the archive to the specified file path.
/// </summary>
/// <param name="archive">The archive to write.</param>
/// <param name="filePath">The output file path.</param>
public static void Write(GsaArchive archive, string filePath)
{
using var stream = File.Create(filePath);
Write(archive, stream);
}
/// <summary>
/// Writes the archive to the given stream.
/// Each entry's <see cref="GsaEntry.DataOffset"/> is updated to reflect the new position in the output.
/// </summary>
/// <param name="archive">The archive to write.</param>
/// <param name="stream">A writable stream.</param>
public static void Write(GsaArchive archive, Stream stream)
{
using var writer = new BinaryWriter(stream, Encoding.ASCII, leaveOpen: true);
// Write global header
if (archive.Format == GsaFormat.NARC)
{
writer.Write(MAGIC_NARC);
}
else
{
writer.Write(MAGIC_NARD);
writer.Write(archive.OffsetPadding);
writer.Write(archive.SizePadding);
}
// Write each entry sequentially
foreach (var entry in archive.Entries)
{
WriteEntry(writer, entry, archive);
}
}
/// <summary>
/// Writes a single file entry at the current stream position.
/// </summary>
/// <param name="writer">The binary writer.</param>
/// <param name="entry">The entry to write.</param>
/// <param name="archive">The parent archive (used for NARD padding alignment).</param>
private static void WriteEntry(BinaryWriter writer, GsaEntry entry, GsaArchive archive)
{
// NARD: align stream position before writing entry header
if (archive.Format == GsaFormat.NARD && archive.OffsetPadding > 0)
WritePadding(writer, archive.OffsetPadding);
// Write alias
byte[] aliasBytes = Encoding.ASCII.GetBytes(entry.Alias);
writer.Write((uint)aliasBytes.Length);
writer.Write(aliasBytes);
// Write compression flag
writer.Write((byte)(entry.IsCompressed ? 1 : 0));
// Write original (decompressed) length
writer.Write(entry.OriginalLength);
// Write compressed length (only if compressed)
if (entry.IsCompressed)
{
writer.Write(entry.CompressedLength);
}
// NARD: align stream position before writing the data block
if (archive.Format == GsaFormat.NARD && archive.OffsetPadding > 0)
WritePadding(writer, archive.OffsetPadding);
// Update the entry's data offset to reflect the new position
entry.DataOffset = writer.BaseStream.Position;
// Write raw data
writer.Write(entry.RawData);
}
/// <summary>
/// Writes zero-bytes to pad the stream to the next aligned boundary.
/// </summary>
/// <param name="writer">The binary writer.</param>
/// <param name="alignment">The alignment boundary in bytes.</param>
private static void WritePadding(BinaryWriter writer, int alignment)
{
if (alignment <= 1) return;
long pos = writer.BaseStream.Position;
long remainder = pos % alignment;
if (remainder != 0)
{
int paddingBytes = (int)(alignment - remainder);
writer.Write(new byte[paddingBytes]);
}
}
}

27
GsaEditor.Core/Models/GsaArchive.cs Normal file
View File

@ -0,0 +1,27 @@
namespace GsaEditor.Core.Models;
/// <summary>
/// Represents a loaded GSA archive with its global header information and file entries.
/// </summary>
public class GsaArchive
{
/// <summary>
/// The format variant of this archive (NARC or NARD).
/// </summary>
public GsaFormat Format { get; set; } = GsaFormat.NARC;
/// <summary>
/// (NARD only) Byte alignment for data offsets. Zero or unused for NARC.
/// </summary>
public int OffsetPadding { get; set; }
/// <summary>
/// (NARD only) Byte alignment for data sizes. Zero or unused for NARC.
/// </summary>
public int SizePadding { get; set; }
/// <summary>
/// The ordered list of file entries in the archive.
/// </summary>
public List<GsaEntry> Entries { get; set; } = new();
}

77
GsaEditor.Core/Models/GsaEntry.cs Normal file
View File

@ -0,0 +1,77 @@
using GsaEditor.Core.Compression;
namespace GsaEditor.Core.Models;
/// <summary>
/// Represents a single file entry within a GSA archive.
/// </summary>
public class GsaEntry
{
/// <summary>
/// Relative path (alias) of the file within the archive, using '/' as separator.
/// Maximum 511 characters.
/// </summary>
public string Alias { get; set; } = string.Empty;
/// <summary>
/// Whether this entry's data is zlib-compressed.
/// </summary>
public bool IsCompressed { get; set; }
/// <summary>
/// Original (decompressed) size of the file in bytes.
/// </summary>
public uint OriginalLength { get; set; }
/// <summary>
/// Compressed size of the file in bytes. Equal to <see cref="OriginalLength"/> if not compressed.
/// </summary>
public uint CompressedLength { get; set; }
/// <summary>
/// Raw data as stored in the archive (compressed bytes if <see cref="IsCompressed"/> is true).
/// </summary>
public byte[] RawData { get; set; } = Array.Empty<byte>();
/// <summary>
/// Byte offset of this entry's data block within the archive file.
/// </summary>
public long DataOffset { get; set; }
/// <summary>
/// Returns the decompressed data for this entry.
/// If the entry is not compressed, returns <see cref="RawData"/> directly.
/// </summary>
/// <returns>The decompressed file content.</returns>
public byte[] GetDecompressedData()
{
if (!IsCompressed)
return RawData;
return ZlibHelper.Decompress(RawData, OriginalLength);
}
/// <summary>
/// Sets the entry data from uncompressed bytes, optionally compressing with zlib.
/// Updates <see cref="OriginalLength"/>, <see cref="CompressedLength"/>,
/// <see cref="IsCompressed"/>, and <see cref="RawData"/>.
/// </summary>
/// <param name="uncompressedData">The uncompressed file content.</param>
/// <param name="compress">Whether to compress the data with zlib.</param>
public void SetData(byte[] uncompressedData, bool compress)
{
OriginalLength = (uint)uncompressedData.Length;
IsCompressed = compress;
if (compress)
{
RawData = ZlibHelper.Compress(uncompressedData);
CompressedLength = (uint)RawData.Length;
}
else
{
RawData = uncompressedData;
CompressedLength = OriginalLength;
}
}
}

18
GsaEditor.Core/Models/GsaFormat.cs Normal file
View File

@ -0,0 +1,18 @@
namespace GsaEditor.Core.Models;
/// <summary>
/// Identifies the archive format variant.
/// </summary>
public enum GsaFormat
{
/// <summary>
/// Legacy format with no padding support. Magic word = 0x4E415243 ("NARC").
/// </summary>
NARC,
/// <summary>
/// Enhanced format with offset and size padding for console DVD alignment.
/// Magic word = 0x4E415244 ("NARD").
/// </summary>
NARD
}

23
GsaEditor.Core/bin/Debug/net8.0/GsaEditor.Core.deps.json Normal file
View File

@ -0,0 +1,23 @@
{
"runtimeTarget": {
"name": ".NETCoreApp,Version=v8.0",
"signature": ""
},
"compilationOptions": {},
"targets": {
".NETCoreApp,Version=v8.0": {
"GsaEditor.Core/1.0.0": {
"runtime": {
"GsaEditor.Core.dll": {}
}
}
}
},
"libraries": {
"GsaEditor.Core/1.0.0": {
"type": "project",
"serviceable": false,
"sha512": ""
}
}
}

BIN
GsaEditor.Core/bin/Debug/net8.0/GsaEditor.Core.dll Normal file
View File

Binary file not shown.

BIN
GsaEditor.Core/bin/Debug/net8.0/GsaEditor.Core.pdb Normal file
View File

Binary file not shown.

276
GsaEditor.Core/bin/Debug/net8.0/GsaEditor.Core.xml Normal file
View File

@ -0,0 +1,276 @@
<?xml version="1.0"?>
<doc>
<assembly>
<name>GsaEditor.Core</name>
</assembly>
<members>
<member name="T:GsaEditor.Core.Compression.ZlibHelper">
<summary>
Provides zlib compression and decompression utilities for GSA archive entries.
The GSA format stores zlib-wrapped data: 2-byte header (CMF+FLG) + deflate stream + 4-byte Adler-32 checksum.
This helper skips the 2-byte zlib header and uses <see cref="T:System.IO.Compression.DeflateStream"/> for the core deflate data.
</summary>
</member>
<member name="M:GsaEditor.Core.Compression.ZlibHelper.Decompress(System.Byte[],System.UInt32)">
<summary>
Decompresses zlib-wrapped data into a byte array of the specified original size.
Skips the 2-byte zlib header before feeding data to <see cref="T:System.IO.Compression.DeflateStream"/>.
</summary>
<param name="compressedData">The zlib-wrapped compressed data (header + deflate + checksum).</param>
<param name="originalLength">The expected decompressed size in bytes.</param>
<returns>The decompressed byte array.</returns>
<exception cref="T:System.IO.InvalidDataException">Thrown when decompression fails or data is corrupt.</exception>
</member>
<member name="M:GsaEditor.Core.Compression.ZlibHelper.Compress(System.Byte[])">
<summary>
Compresses data using zlib format: 2-byte header + deflate stream + 4-byte Adler-32 checksum.
</summary>
<param name="data">The uncompressed data to compress.</param>
<returns>The zlib-wrapped compressed byte array.</returns>
</member>
<member name="M:GsaEditor.Core.Compression.ZlibHelper.ComputeAdler32(System.Byte[])">
<summary>
Computes the Adler-32 checksum of the given data.
</summary>
<param name="data">The data to checksum.</param>
<returns>The 32-bit Adler-32 checksum value.</returns>
</member>
<member name="T:GsaEditor.Core.IO.GsaIndexEntry">
<summary>
Represents a single entry parsed from a .idx NML index file.
</summary>
</member>
<member name="P:GsaEditor.Core.IO.GsaIndexEntry.Id">
<summary>
The file alias (relative path) of the entry.
</summary>
</member>
<member name="P:GsaEditor.Core.IO.GsaIndexEntry.Method">
<summary>
Compression method: 0 = raw, 1 = zlib.
</summary>
</member>
<member name="P:GsaEditor.Core.IO.GsaIndexEntry.Length">
<summary>
Original (decompressed) size in bytes.
</summary>
</member>
<member name="P:GsaEditor.Core.IO.GsaIndexEntry.CompressedLength">
<summary>
Compressed size in bytes.
</summary>
</member>
<member name="P:GsaEditor.Core.IO.GsaIndexEntry.Offset">
<summary>
Byte offset of the data block within the archive.
</summary>
</member>
<member name="T:GsaEditor.Core.IO.GsaIndexReader">
<summary>
Parses .idx NML index files (XML-compatible format) into a list of <see cref="T:GsaEditor.Core.IO.GsaIndexEntry"/>.
</summary>
</member>
<member name="M:GsaEditor.Core.IO.GsaIndexReader.Read(System.String)">
<summary>
Reads index entries from the specified .idx file.
</summary>
<param name="filePath">The path to the .idx file.</param>
<returns>A list of parsed index entries.</returns>
</member>
<member name="T:GsaEditor.Core.IO.GsaIndexWriter">
<summary>
Writes a .idx NML index file from a <see cref="T:GsaEditor.Core.Models.GsaArchive"/>.
The index file is XML-compatible and lists each entry with its alias, compression method,
sizes, and data offset for fast lookup without a full sequential scan.
</summary>
</member>
<member name="M:GsaEditor.Core.IO.GsaIndexWriter.Write(GsaEditor.Core.Models.GsaArchive,System.String)">
<summary>
Writes the index file for the given archive to the specified path.
</summary>
<param name="archive">The archive whose entries will be indexed.</param>
<param name="filePath">The output .idx file path.</param>
</member>
<member name="T:GsaEditor.Core.IO.GsaReader">
<summary>
Reads a .gsa binary archive from a stream or file and produces a <see cref="T:GsaEditor.Core.Models.GsaArchive"/>.
Supports both NARC (legacy) and NARD (enhanced with padding) format variants.
</summary>
</member>
<member name="F:GsaEditor.Core.IO.GsaReader.MAGIC_NARC">
<summary>Magic word for the NARC (legacy) format.</summary>
</member>
<member name="F:GsaEditor.Core.IO.GsaReader.MAGIC_NARD">
<summary>Magic word for the NARD (enhanced) format.</summary>
</member>
<member name="F:GsaEditor.Core.IO.GsaReader.MAX_ALIAS_LENGTH">
<summary>Maximum allowed alias length in characters.</summary>
</member>
<member name="M:GsaEditor.Core.IO.GsaReader.Read(System.String)">
<summary>
Reads a GSA archive from the specified file path.
</summary>
<param name="filePath">The path to the .gsa archive file.</param>
<returns>A fully populated <see cref="T:GsaEditor.Core.Models.GsaArchive"/>.</returns>
<exception cref="T:System.IO.InvalidDataException">Thrown if the file has an invalid magic word.</exception>
</member>
<member name="M:GsaEditor.Core.IO.GsaReader.Read(System.IO.Stream)">
<summary>
Reads a GSA archive from a stream by performing a sequential scan of all entries.
</summary>
<param name="stream">A readable, seekable stream positioned at the start of the archive.</param>
<returns>A fully populated <see cref="T:GsaEditor.Core.Models.GsaArchive"/>.</returns>
<exception cref="T:System.IO.InvalidDataException">Thrown if the stream has an invalid magic word.</exception>
</member>
<member name="M:GsaEditor.Core.IO.GsaReader.ReadEntry(System.IO.BinaryReader,GsaEditor.Core.Models.GsaArchive)">
<summary>
Reads a single file entry from the current stream position.
</summary>
<param name="reader">The binary reader positioned at the start of an entry.</param>
<param name="archive">The parent archive (used for NARD padding alignment).</param>
<returns>A populated <see cref="T:GsaEditor.Core.Models.GsaEntry"/>, or null if no more entries can be read.</returns>
</member>
<member name="M:GsaEditor.Core.IO.GsaReader.AlignStream(System.IO.Stream,System.Int32)">
<summary>
Advances the stream position to the next aligned boundary.
</summary>
<param name="stream">The stream to align.</param>
<param name="alignment">The alignment boundary in bytes.</param>
</member>
<member name="T:GsaEditor.Core.IO.GsaWriter">
<summary>
Writes a <see cref="T:GsaEditor.Core.Models.GsaArchive"/> to a binary .gsa stream or file.
Supports both NARC (legacy) and NARD (enhanced with padding) format variants.
</summary>
</member>
<member name="F:GsaEditor.Core.IO.GsaWriter.MAGIC_NARC">
<summary>Magic word for the NARC (legacy) format.</summary>
</member>
<member name="F:GsaEditor.Core.IO.GsaWriter.MAGIC_NARD">
<summary>Magic word for the NARD (enhanced) format.</summary>
</member>
<member name="M:GsaEditor.Core.IO.GsaWriter.Write(GsaEditor.Core.Models.GsaArchive,System.String)">
<summary>
Writes the archive to the specified file path.
</summary>
<param name="archive">The archive to write.</param>
<param name="filePath">The output file path.</param>
</member>
<member name="M:GsaEditor.Core.IO.GsaWriter.Write(GsaEditor.Core.Models.GsaArchive,System.IO.Stream)">
<summary>
Writes the archive to the given stream.
Each entry's <see cref="P:GsaEditor.Core.Models.GsaEntry.DataOffset"/> is updated to reflect the new position in the output.
</summary>
<param name="archive">The archive to write.</param>
<param name="stream">A writable stream.</param>
</member>
<member name="M:GsaEditor.Core.IO.GsaWriter.WriteEntry(System.IO.BinaryWriter,GsaEditor.Core.Models.GsaEntry,GsaEditor.Core.Models.GsaArchive)">
<summary>
Writes a single file entry at the current stream position.
</summary>
<param name="writer">The binary writer.</param>
<param name="entry">The entry to write.</param>
<param name="archive">The parent archive (used for NARD padding alignment).</param>
</member>
<member name="M:GsaEditor.Core.IO.GsaWriter.WritePadding(System.IO.BinaryWriter,System.Int32)">
<summary>
Writes zero-bytes to pad the stream to the next aligned boundary.
</summary>
<param name="writer">The binary writer.</param>
<param name="alignment">The alignment boundary in bytes.</param>
</member>
<member name="T:GsaEditor.Core.Models.GsaArchive">
<summary>
Represents a loaded GSA archive with its global header information and file entries.
</summary>
</member>
<member name="P:GsaEditor.Core.Models.GsaArchive.Format">
<summary>
The format variant of this archive (NARC or NARD).
</summary>
</member>
<member name="P:GsaEditor.Core.Models.GsaArchive.OffsetPadding">
<summary>
(NARD only) Byte alignment for data offsets. Zero or unused for NARC.
</summary>
</member>
<member name="P:GsaEditor.Core.Models.GsaArchive.SizePadding">
<summary>
(NARD only) Byte alignment for data sizes. Zero or unused for NARC.
</summary>
</member>
<member name="P:GsaEditor.Core.Models.GsaArchive.Entries">
<summary>
The ordered list of file entries in the archive.
</summary>
</member>
<member name="T:GsaEditor.Core.Models.GsaEntry">
<summary>
Represents a single file entry within a GSA archive.
</summary>
</member>
<member name="P:GsaEditor.Core.Models.GsaEntry.Alias">
<summary>
Relative path (alias) of the file within the archive, using '/' as separator.
Maximum 511 characters.
</summary>
</member>
<member name="P:GsaEditor.Core.Models.GsaEntry.IsCompressed">
<summary>
Whether this entry's data is zlib-compressed.
</summary>
</member>
<member name="P:GsaEditor.Core.Models.GsaEntry.OriginalLength">
<summary>
Original (decompressed) size of the file in bytes.
</summary>
</member>
<member name="P:GsaEditor.Core.Models.GsaEntry.CompressedLength">
<summary>
Compressed size of the file in bytes. Equal to <see cref="P:GsaEditor.Core.Models.GsaEntry.OriginalLength"/> if not compressed.
</summary>
</member>
<member name="P:GsaEditor.Core.Models.GsaEntry.RawData">
<summary>
Raw data as stored in the archive (compressed bytes if <see cref="P:GsaEditor.Core.Models.GsaEntry.IsCompressed"/> is true).
</summary>
</member>
<member name="P:GsaEditor.Core.Models.GsaEntry.DataOffset">
<summary>
Byte offset of this entry's data block within the archive file.
</summary>
</member>
<member name="M:GsaEditor.Core.Models.GsaEntry.GetDecompressedData">
<summary>
Returns the decompressed data for this entry.
If the entry is not compressed, returns <see cref="P:GsaEditor.Core.Models.GsaEntry.RawData"/> directly.
</summary>
<returns>The decompressed file content.</returns>
</member>
<member name="M:GsaEditor.Core.Models.GsaEntry.SetData(System.Byte[],System.Boolean)">
<summary>
Sets the entry data from uncompressed bytes, optionally compressing with zlib.
Updates <see cref="P:GsaEditor.Core.Models.GsaEntry.OriginalLength"/>, <see cref="P:GsaEditor.Core.Models.GsaEntry.CompressedLength"/>,
<see cref="P:GsaEditor.Core.Models.GsaEntry.IsCompressed"/>, and <see cref="P:GsaEditor.Core.Models.GsaEntry.RawData"/>.
</summary>
<param name="uncompressedData">The uncompressed file content.</param>
<param name="compress">Whether to compress the data with zlib.</param>
</member>
<member name="T:GsaEditor.Core.Models.GsaFormat">
<summary>
Identifies the archive format variant.
</summary>
</member>
<member name="F:GsaEditor.Core.Models.GsaFormat.NARC">
<summary>
Legacy format with no padding support. Magic word = 0x4E415243 ("NARC").
</summary>
</member>
<member name="F:GsaEditor.Core.Models.GsaFormat.NARD">
<summary>
Enhanced format with offset and size padding for console DVD alignment.
Magic word = 0x4E415244 ("NARD").
</summary>
</member>
</members>
</doc>

4
GsaEditor.Core/obj/Debug/net8.0/.NETCoreApp,Version=v8.0.AssemblyAttributes.cs Normal file
View File

@ -0,0 +1,4 @@
// <autogenerated />
using System;
using System.Reflection;
[assembly: global::System.Runtime.Versioning.TargetFrameworkAttribute(".NETCoreApp,Version=v8.0", FrameworkDisplayName = ".NET 8.0")]

22
GsaEditor.Core/obj/Debug/net8.0/GsaEditor.Core.AssemblyInfo.cs Normal file
View File

@ -0,0 +1,22 @@
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
using System;
using System.Reflection;
[assembly: System.Reflection.AssemblyCompanyAttribute("GsaEditor.Core")]
[assembly: System.Reflection.AssemblyConfigurationAttribute("Debug")]
[assembly: System.Reflection.AssemblyFileVersionAttribute("1.0.0.0")]
[assembly: System.Reflection.AssemblyInformationalVersionAttribute("1.0.0")]
[assembly: System.Reflection.AssemblyProductAttribute("GsaEditor.Core")]
[assembly: System.Reflection.AssemblyTitleAttribute("GsaEditor.Core")]
[assembly: System.Reflection.AssemblyVersionAttribute("1.0.0.0")]
// Généré par la classe MSBuild WriteCodeFragment.

1
GsaEditor.Core/obj/Debug/net8.0/GsaEditor.Core.AssemblyInfoInputs.cache Normal file
View File

@ -0,0 +1 @@
68387796343863a0e5c11cd0f612a1b364816551cf5816c6d556d410439a3710

15
GsaEditor.Core/obj/Debug/net8.0/GsaEditor.Core.GeneratedMSBuildEditorConfig.editorconfig Normal file
View File

@ -0,0 +1,15 @@
is_global = true
build_property.TargetFramework = net8.0
build_property.TargetPlatformMinVersion =
build_property.UsingMicrosoftNETSdkWeb =
build_property.ProjectTypeGuids =
build_property.InvariantGlobalization =
build_property.PlatformNeutralAssembly =
build_property.EnforceExtendedAnalyzerRules =
build_property._SupportedPlatformList = Linux,macOS,Windows
build_property.RootNamespace = GsaEditor.Core
build_property.ProjectDir = C:\Users\simulateur\Desktop\GsaViewer\GsaEditor.Core\
build_property.EnableComHosting =
build_property.EnableGeneratedComInterfaceComImportInterop =
build_property.EffectiveAnalysisLevelStyle = 8.0
build_property.EnableCodeStyleSeverity =

8
GsaEditor.Core/obj/Debug/net8.0/GsaEditor.Core.GlobalUsings.g.cs Normal file
View File

@ -0,0 +1,8 @@
// <auto-generated/>
global using global::System;
global using global::System.Collections.Generic;
global using global::System.IO;
global using global::System.Linq;
global using global::System.Net.Http;
global using global::System.Threading;
global using global::System.Threading.Tasks;

BIN
GsaEditor.Core/obj/Debug/net8.0/GsaEditor.Core.assets.cache Normal file
View File

Binary file not shown.

1
GsaEditor.Core/obj/Debug/net8.0/GsaEditor.Core.csproj.CoreCompileInputs.cache Normal file
View File

@ -0,0 +1 @@
f57ab49a8539dcd5eaae9903c06c691e87a9ead2bd6a913638151d11a0b5901a

13
GsaEditor.Core/obj/Debug/net8.0/GsaEditor.Core.csproj.FileListAbsolute.txt Normal file
View File

@ -0,0 +1,13 @@
C:\Users\simulateur\Desktop\GsaViewer\GsaEditor.Core\bin\Debug\net8.0\GsaEditor.Core.deps.json
C:\Users\simulateur\Desktop\GsaViewer\GsaEditor.Core\bin\Debug\net8.0\GsaEditor.Core.dll
C:\Users\simulateur\Desktop\GsaViewer\GsaEditor.Core\bin\Debug\net8.0\GsaEditor.Core.pdb
C:\Users\simulateur\Desktop\GsaViewer\GsaEditor.Core\bin\Debug\net8.0\GsaEditor.Core.xml
C:\Users\simulateur\Desktop\GsaViewer\GsaEditor.Core\obj\Debug\net8.0\GsaEditor.Core.GeneratedMSBuildEditorConfig.editorconfig
C:\Users\simulateur\Desktop\GsaViewer\GsaEditor.Core\obj\Debug\net8.0\GsaEditor.Core.AssemblyInfoInputs.cache
C:\Users\simulateur\Desktop\GsaViewer\GsaEditor.Core\obj\Debug\net8.0\GsaEditor.Core.AssemblyInfo.cs
C:\Users\simulateur\Desktop\GsaViewer\GsaEditor.Core\obj\Debug\net8.0\GsaEditor.Core.csproj.CoreCompileInputs.cache
C:\Users\simulateur\Desktop\GsaViewer\GsaEditor.Core\obj\Debug\net8.0\GsaEditor.Core.dll
C:\Users\simulateur\Desktop\GsaViewer\GsaEditor.Core\obj\Debug\net8.0\refint\GsaEditor.Core.dll
C:\Users\simulateur\Desktop\GsaViewer\GsaEditor.Core\obj\Debug\net8.0\GsaEditor.Core.xml
C:\Users\simulateur\Desktop\GsaViewer\GsaEditor.Core\obj\Debug\net8.0\GsaEditor.Core.pdb
C:\Users\simulateur\Desktop\GsaViewer\GsaEditor.Core\obj\Debug\net8.0\ref\GsaEditor.Core.dll

BIN
GsaEditor.Core/obj/Debug/net8.0/GsaEditor.Core.dll Normal file
View File

Binary file not shown.

BIN
GsaEditor.Core/obj/Debug/net8.0/GsaEditor.Core.pdb Normal file
View File

Binary file not shown.

276
GsaEditor.Core/obj/Debug/net8.0/GsaEditor.Core.xml Normal file
View File

@ -0,0 +1,276 @@
<?xml version="1.0"?>
<doc>
<assembly>
<name>GsaEditor.Core</name>
</assembly>
<members>
<member name="T:GsaEditor.Core.Compression.ZlibHelper">
<summary>
Provides zlib compression and decompression utilities for GSA archive entries.
The GSA format stores zlib-wrapped data: 2-byte header (CMF+FLG) + deflate stream + 4-byte Adler-32 checksum.
This helper skips the 2-byte zlib header and uses <see cref="T:System.IO.Compression.DeflateStream"/> for the core deflate data.
</summary>
</member>
<member name="M:GsaEditor.Core.Compression.ZlibHelper.Decompress(System.Byte[],System.UInt32)">
<summary>
Decompresses zlib-wrapped data into a byte array of the specified original size.
Skips the 2-byte zlib header before feeding data to <see cref="T:System.IO.Compression.DeflateStream"/>.
</summary>
<param name="compressedData">The zlib-wrapped compressed data (header + deflate + checksum).</param>
<param name="originalLength">The expected decompressed size in bytes.</param>
<returns>The decompressed byte array.</returns>
<exception cref="T:System.IO.InvalidDataException">Thrown when decompression fails or data is corrupt.</exception>
</member>
<member name="M:GsaEditor.Core.Compression.ZlibHelper.Compress(System.Byte[])">
<summary>
Compresses data using zlib format: 2-byte header + deflate stream + 4-byte Adler-32 checksum.
</summary>
<param name="data">The uncompressed data to compress.</param>
<returns>The zlib-wrapped compressed byte array.</returns>
</member>
<member name="M:GsaEditor.Core.Compression.ZlibHelper.ComputeAdler32(System.Byte[])">
<summary>
Computes the Adler-32 checksum of the given data.
</summary>
<param name="data">The data to checksum.</param>
<returns>The 32-bit Adler-32 checksum value.</returns>
</member>
<member name="T:GsaEditor.Core.IO.GsaIndexEntry">
<summary>
Represents a single entry parsed from a .idx NML index file.
</summary>
</member>
<member name="P:GsaEditor.Core.IO.GsaIndexEntry.Id">
<summary>
The file alias (relative path) of the entry.
</summary>
</member>
<member name="P:GsaEditor.Core.IO.GsaIndexEntry.Method">
<summary>
Compression method: 0 = raw, 1 = zlib.
</summary>
</member>
<member name="P:GsaEditor.Core.IO.GsaIndexEntry.Length">
<summary>
Original (decompressed) size in bytes.
</summary>
</member>
<member name="P:GsaEditor.Core.IO.GsaIndexEntry.CompressedLength">
<summary>
Compressed size in bytes.
</summary>
</member>
<member name="P:GsaEditor.Core.IO.GsaIndexEntry.Offset">
<summary>
Byte offset of the data block within the archive.
</summary>
</member>
<member name="T:GsaEditor.Core.IO.GsaIndexReader">
<summary>
Parses .idx NML index files (XML-compatible format) into a list of <see cref="T:GsaEditor.Core.IO.GsaIndexEntry"/>.
</summary>
</member>
<member name="M:GsaEditor.Core.IO.GsaIndexReader.Read(System.String)">
<summary>
Reads index entries from the specified .idx file.
</summary>
<param name="filePath">The path to the .idx file.</param>
<returns>A list of parsed index entries.</returns>
</member>
<member name="T:GsaEditor.Core.IO.GsaIndexWriter">
<summary>
Writes a .idx NML index file from a <see cref="T:GsaEditor.Core.Models.GsaArchive"/>.
The index file is XML-compatible and lists each entry with its alias, compression method,
sizes, and data offset for fast lookup without a full sequential scan.
</summary>
</member>
<member name="M:GsaEditor.Core.IO.GsaIndexWriter.Write(GsaEditor.Core.Models.GsaArchive,System.String)">
<summary>
Writes the index file for the given archive to the specified path.
</summary>
<param name="archive">The archive whose entries will be indexed.</param>
<param name="filePath">The output .idx file path.</param>
</member>
<member name="T:GsaEditor.Core.IO.GsaReader">
<summary>
Reads a .gsa binary archive from a stream or file and produces a <see cref="T:GsaEditor.Core.Models.GsaArchive"/>.
Supports both NARC (legacy) and NARD (enhanced with padding) format variants.
</summary>
</member>
<member name="F:GsaEditor.Core.IO.GsaReader.MAGIC_NARC">
<summary>Magic word for the NARC (legacy) format.</summary>
</member>
<member name="F:GsaEditor.Core.IO.GsaReader.MAGIC_NARD">
<summary>Magic word for the NARD (enhanced) format.</summary>
</member>
<member name="F:GsaEditor.Core.IO.GsaReader.MAX_ALIAS_LENGTH">
<summary>Maximum allowed alias length in characters.</summary>
</member>
<member name="M:GsaEditor.Core.IO.GsaReader.Read(System.String)">
<summary>
Reads a GSA archive from the specified file path.
</summary>
<param name="filePath">The path to the .gsa archive file.</param>
<returns>A fully populated <see cref="T:GsaEditor.Core.Models.GsaArchive"/>.</returns>
<exception cref="T:System.IO.InvalidDataException">Thrown if the file has an invalid magic word.</exception>
</member>
<member name="M:GsaEditor.Core.IO.GsaReader.Read(System.IO.Stream)">
<summary>
Reads a GSA archive from a stream by performing a sequential scan of all entries.
</summary>
<param name="stream">A readable, seekable stream positioned at the start of the archive.</param>
<returns>A fully populated <see cref="T:GsaEditor.Core.Models.GsaArchive"/>.</returns>
<exception cref="T:System.IO.InvalidDataException">Thrown if the stream has an invalid magic word.</exception>
</member>
<member name="M:GsaEditor.Core.IO.GsaReader.ReadEntry(System.IO.BinaryReader,GsaEditor.Core.Models.GsaArchive)">
<summary>
Reads a single file entry from the current stream position.
</summary>
<param name="reader">The binary reader positioned at the start of an entry.</param>
<param name="archive">The parent archive (used for NARD padding alignment).</param>
<returns>A populated <see cref="T:GsaEditor.Core.Models.GsaEntry"/>, or null if no more entries can be read.</returns>
</member>
<member name="M:GsaEditor.Core.IO.GsaReader.AlignStream(System.IO.Stream,System.Int32)">
<summary>
Advances the stream position to the next aligned boundary.
</summary>
<param name="stream">The stream to align.</param>
<param name="alignment">The alignment boundary in bytes.</param>
</member>
<member name="T:GsaEditor.Core.IO.GsaWriter">
<summary>
Writes a <see cref="T:GsaEditor.Core.Models.GsaArchive"/> to a binary .gsa stream or file.
Supports both NARC (legacy) and NARD (enhanced with padding) format variants.
</summary>
</member>
<member name="F:GsaEditor.Core.IO.GsaWriter.MAGIC_NARC">
<summary>Magic word for the NARC (legacy) format.</summary>
</member>
<member name="F:GsaEditor.Core.IO.GsaWriter.MAGIC_NARD">
<summary>Magic word for the NARD (enhanced) format.</summary>
</member>
<member name="M:GsaEditor.Core.IO.GsaWriter.Write(GsaEditor.Core.Models.GsaArchive,System.String)">
<summary>
Writes the archive to the specified file path.
</summary>
<param name="archive">The archive to write.</param>
<param name="filePath">The output file path.</param>
</member>
<member name="M:GsaEditor.Core.IO.GsaWriter.Write(GsaEditor.Core.Models.GsaArchive,System.IO.Stream)">
<summary>
Writes the archive to the given stream.
Each entry's <see cref="P:GsaEditor.Core.Models.GsaEntry.DataOffset"/> is updated to reflect the new position in the output.
</summary>
<param name="archive">The archive to write.</param>
<param name="stream">A writable stream.</param>
</member>
<member name="M:GsaEditor.Core.IO.GsaWriter.WriteEntry(System.IO.BinaryWriter,GsaEditor.Core.Models.GsaEntry,GsaEditor.Core.Models.GsaArchive)">
<summary>
Writes a single file entry at the current stream position.
</summary>
<param name="writer">The binary writer.</param>
<param name="entry">The entry to write.</param>
<param name="archive">The parent archive (used for NARD padding alignment).</param>
</member>
<member name="M:GsaEditor.Core.IO.GsaWriter.WritePadding(System.IO.BinaryWriter,System.Int32)">
<summary>
Writes zero-bytes to pad the stream to the next aligned boundary.
</summary>
<param name="writer">The binary writer.</param>
<param name="alignment">The alignment boundary in bytes.</param>
</member>
<member name="T:GsaEditor.Core.Models.GsaArchive">
<summary>
Represents a loaded GSA archive with its global header information and file entries.
</summary>
</member>
<member name="P:GsaEditor.Core.Models.GsaArchive.Format">
<summary>
The format variant of this archive (NARC or NARD).
</summary>
</member>
<member name="P:GsaEditor.Core.Models.GsaArchive.OffsetPadding">
<summary>
(NARD only) Byte alignment for data offsets. Zero or unused for NARC.
</summary>
</member>
<member name="P:GsaEditor.Core.Models.GsaArchive.SizePadding">
<summary>
(NARD only) Byte alignment for data sizes. Zero or unused for NARC.
</summary>
</member>
<member name="P:GsaEditor.Core.Models.GsaArchive.Entries">
<summary>
The ordered list of file entries in the archive.
</summary>
</member>
<member name="T:GsaEditor.Core.Models.GsaEntry">
<summary>
Represents a single file entry within a GSA archive.
</summary>
</member>
<member name="P:GsaEditor.Core.Models.GsaEntry.Alias">
<summary>
Relative path (alias) of the file within the archive, using '/' as separator.
Maximum 511 characters.
</summary>
</member>
<member name="P:GsaEditor.Core.Models.GsaEntry.IsCompressed">
<summary>
Whether this entry's data is zlib-compressed.
</summary>
</member>
<member name="P:GsaEditor.Core.Models.GsaEntry.OriginalLength">
<summary>
Original (decompressed) size of the file in bytes.
</summary>
</member>
<member name="P:GsaEditor.Core.Models.GsaEntry.CompressedLength">
<summary>
Compressed size of the file in bytes. Equal to <see cref="P:GsaEditor.Core.Models.GsaEntry.OriginalLength"/> if not compressed.
</summary>
</member>
<member name="P:GsaEditor.Core.Models.GsaEntry.RawData">
<summary>
Raw data as stored in the archive (compressed bytes if <see cref="P:GsaEditor.Core.Models.GsaEntry.IsCompressed"/> is true).
</summary>
</member>
<member name="P:GsaEditor.Core.Models.GsaEntry.DataOffset">
<summary>
Byte offset of this entry's data block within the archive file.
</summary>
</member>
<member name="M:GsaEditor.Core.Models.GsaEntry.GetDecompressedData">
<summary>
Returns the decompressed data for this entry.
If the entry is not compressed, returns <see cref="P:GsaEditor.Core.Models.GsaEntry.RawData"/> directly.
</summary>
<returns>The decompressed file content.</returns>
</member>
<member name="M:GsaEditor.Core.Models.GsaEntry.SetData(System.Byte[],System.Boolean)">
<summary>
Sets the entry data from uncompressed bytes, optionally compressing with zlib.
Updates <see cref="P:GsaEditor.Core.Models.GsaEntry.OriginalLength"/>, <see cref="P:GsaEditor.Core.Models.GsaEntry.CompressedLength"/>,
<see cref="P:GsaEditor.Core.Models.GsaEntry.IsCompressed"/>, and <see cref="P:GsaEditor.Core.Models.GsaEntry.RawData"/>.
</summary>
<param name="uncompressedData">The uncompressed file content.</param>
<param name="compress">Whether to compress the data with zlib.</param>
</member>
<member name="T:GsaEditor.Core.Models.GsaFormat">
<summary>
Identifies the archive format variant.
</summary>
</member>
<member name="F:GsaEditor.Core.Models.GsaFormat.NARC">
<summary>
Legacy format with no padding support. Magic word = 0x4E415243 ("NARC").
</summary>
</member>
<member name="F:GsaEditor.Core.Models.GsaFormat.NARD">
<summary>
Enhanced format with offset and size padding for console DVD alignment.
Magic word = 0x4E415244 ("NARD").
</summary>
</member>
</members>
</doc>

BIN
GsaEditor.Core/obj/Debug/net8.0/ref/GsaEditor.Core.dll Normal file
View File

Binary file not shown.

BIN
GsaEditor.Core/obj/Debug/net8.0/refint/GsaEditor.Core.dll Normal file
View File

Binary file not shown.

81
GsaEditor.Core/obj/GsaEditor.Core.csproj.nuget.dgspec.json Normal file
View File

@ -0,0 +1,81 @@
{
"format": 1,
"restore": {
"C:\\Users\\simulateur\\Desktop\\GsaViewer\\GsaEditor.Core\\GsaEditor.Core.csproj": {}
},
"projects": {
"C:\\Users\\simulateur\\Desktop\\GsaViewer\\GsaEditor.Core\\GsaEditor.Core.csproj": {
"version": "1.0.0",
"restore": {
"projectUniqueName": "C:\\Users\\simulateur\\Desktop\\GsaViewer\\GsaEditor.Core\\GsaEditor.Core.csproj",
"projectName": "GsaEditor.Core",
"projectPath": "C:\\Users\\simulateur\\Desktop\\GsaViewer\\GsaEditor.Core\\GsaEditor.Core.csproj",
"packagesPath": "C:\\Users\\simulateur\\.nuget\\packages\\",
"outputPath": "C:\\Users\\simulateur\\Desktop\\GsaViewer\\GsaEditor.Core\\obj\\",
"projectStyle": "PackageReference",
"configFilePaths": [
"C:\\Users\\simulateur\\AppData\\Roaming\\NuGet\\NuGet.Config"
],
"originalTargetFrameworks": [
"net8.0"
],
"sources": {
"https://api.nuget.org/v3/index.json": {}
},
"frameworks": {
"net8.0": {
"targetAlias": "net8.0",
"projectReferences": {}
}
},
"warningProperties": {
"warnAsError": [
"NU1605"
]
},
"restoreAuditProperties": {
"enableAudit": "true",
"auditLevel": "low",
"auditMode": "direct"
},
"SdkAnalysisLevel": "9.0.300"
},
"frameworks": {
"net8.0": {
"targetAlias": "net8.0",
"imports": [
"net461",
"net462",
"net47",
"net471",
"net472",
"net48",
"net481"
],
"assetTargetFallback": true,
"warn": true,
"downloadDependencies": [
{
"name": "Microsoft.AspNetCore.App.Ref",
"version": "[8.0.21, 8.0.21]"
},
{
"name": "Microsoft.NETCore.App.Ref",
"version": "[8.0.21, 8.0.21]"
},
{
"name": "Microsoft.WindowsDesktop.App.Ref",
"version": "[8.0.21, 8.0.21]"
}
],
"frameworkReferences": {
"Microsoft.NETCore.App": {
"privateAssets": "all"
}
},
"runtimeIdentifierGraphPath": "C:\\Program Files\\dotnet\\sdk\\9.0.306/PortableRuntimeIdentifierGraph.json"
}
}
}
}
}

15
GsaEditor.Core/obj/GsaEditor.Core.csproj.nuget.g.props Normal file
View File

@ -0,0 +1,15 @@
<?xml version="1.0" encoding="utf-8" standalone="no"?>
<Project ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup Condition=" '$(ExcludeRestorePackageImports)' != 'true' ">
<RestoreSuccess Condition=" '$(RestoreSuccess)' == '' ">True</RestoreSuccess>
<RestoreTool Condition=" '$(RestoreTool)' == '' ">NuGet</RestoreTool>
<ProjectAssetsFile Condition=" '$(ProjectAssetsFile)' == '' ">$(MSBuildThisFileDirectory)project.assets.json</ProjectAssetsFile>
<NuGetPackageRoot Condition=" '$(NuGetPackageRoot)' == '' ">$(UserProfile)\.nuget\packages\</NuGetPackageRoot>
<NuGetPackageFolders Condition=" '$(NuGetPackageFolders)' == '' ">C:\Users\simulateur\.nuget\packages\</NuGetPackageFolders>
<NuGetProjectStyle Condition=" '$(NuGetProjectStyle)' == '' ">PackageReference</NuGetProjectStyle>
<NuGetToolVersion Condition=" '$(NuGetToolVersion)' == '' ">6.14.0</NuGetToolVersion>
</PropertyGroup>
<ItemGroup Condition=" '$(ExcludeRestorePackageImports)' != 'true' ">
<SourceRoot Include="C:\Users\simulateur\.nuget\packages\" />
</ItemGroup>
</Project>

2
GsaEditor.Core/obj/GsaEditor.Core.csproj.nuget.g.targets Normal file
View File

@ -0,0 +1,2 @@
<?xml version="1.0" encoding="utf-8" standalone="no"?>
<Project ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" />

86
GsaEditor.Core/obj/project.assets.json Normal file
View File

@ -0,0 +1,86 @@
{
"version": 3,
"targets": {
"net8.0": {}
},
"libraries": {},
"projectFileDependencyGroups": {
"net8.0": []
},
"packageFolders": {
"C:\\Users\\simulateur\\.nuget\\packages\\": {}
},
"project": {
"version": "1.0.0",
"restore": {
"projectUniqueName": "C:\\Users\\simulateur\\Desktop\\GsaViewer\\GsaEditor.Core\\GsaEditor.Core.csproj",
"projectName": "GsaEditor.Core",
"projectPath": "C:\\Users\\simulateur\\Desktop\\GsaViewer\\GsaEditor.Core\\GsaEditor.Core.csproj",
"packagesPath": "C:\\Users\\simulateur\\.nuget\\packages\\",
"outputPath": "C:\\Users\\simulateur\\Desktop\\GsaViewer\\GsaEditor.Core\\obj\\",
"projectStyle": "PackageReference",
"configFilePaths": [
"C:\\Users\\simulateur\\AppData\\Roaming\\NuGet\\NuGet.Config"
],
"originalTargetFrameworks": [
"net8.0"
],
"sources": {
"https://api.nuget.org/v3/index.json": {}
},
"frameworks": {
"net8.0": {
"targetAlias": "net8.0",
"projectReferences": {}
}
},
"warningProperties": {
"warnAsError": [
"NU1605"
]
},
"restoreAuditProperties": {
"enableAudit": "true",
"auditLevel": "low",
"auditMode": "direct"
},
"SdkAnalysisLevel": "9.0.300"
},
"frameworks": {
"net8.0": {
"targetAlias": "net8.0",
"imports": [
"net461",
"net462",
"net47",
"net471",
"net472",
"net48",
"net481"
],
"assetTargetFallback": true,
"warn": true,
"downloadDependencies": [
{
"name": "Microsoft.AspNetCore.App.Ref",
"version": "[8.0.21, 8.0.21]"
},
{
"name": "Microsoft.NETCore.App.Ref",
"version": "[8.0.21, 8.0.21]"
},
{
"name": "Microsoft.WindowsDesktop.App.Ref",
"version": "[8.0.21, 8.0.21]"
}
],
"frameworkReferences": {
"Microsoft.NETCore.App": {
"privateAssets": "all"
}
},
"runtimeIdentifierGraphPath": "C:\\Program Files\\dotnet\\sdk\\9.0.306/PortableRuntimeIdentifierGraph.json"
}
}
}
}

12
GsaEditor.Core/obj/project.nuget.cache Normal file
View File

@ -0,0 +1,12 @@
{
"version": 2,
"dgSpecHash": "8Lf0I0TQO2o=",
"success": true,
"projectFilePath": "C:\\Users\\simulateur\\Desktop\\GsaViewer\\GsaEditor.Core\\GsaEditor.Core.csproj",
"expectedPackageFiles": [
"C:\\Users\\simulateur\\.nuget\\packages\\microsoft.netcore.app.ref\\8.0.21\\microsoft.netcore.app.ref.8.0.21.nupkg.sha512",
"C:\\Users\\simulateur\\.nuget\\packages\\microsoft.windowsdesktop.app.ref\\8.0.21\\microsoft.windowsdesktop.app.ref.8.0.21.nupkg.sha512",
"C:\\Users\\simulateur\\.nuget\\packages\\microsoft.aspnetcore.app.ref\\8.0.21\\microsoft.aspnetcore.app.ref.8.0.21.nupkg.sha512"
],
"logs": []
}