Refactor folder structure

2026-02-18 00:50:46 +09:00
parent 426786397c
commit db8ca971a8
413 changed files with 2885 additions and 3634 deletions
--- a/src/Editor/Ghost.Editor.Core/AssetHandler/Asset.cs
+++ b/src/Editor/Ghost.Editor.Core/AssetHandler/Asset.cs
@@ -0,0 +1,185 @@
+using Ghost.Core;
+using Ghost.Editor.Core.Contracts;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Serialization;
+
+namespace Ghost.Editor.Core.AssetHandler;
+
+public abstract class Asset
+{
+    public Guid ID
+    {
+        get;
+    }
+
+    public abstract Guid TypeID
+    {
+        get;
+    }
+
+    public Guid[] Dependencies
+    {
+        get;
+    }
+
+    public IAssetSettings? Settings
+    {
+        get;
+    }
+
+    protected Asset(Guid id, Guid[] dependencies, IAssetSettings? settings)
+    {
+        ID = id;
+        Dependencies = dependencies;
+        Settings = settings;
+    }
+
+    public virtual ValueTask RefreshAsync(IAssetRegistry db, CancellationToken token = default)
+    {
+        return ValueTask.CompletedTask;
+    }
+}
+
+// Do not change the order of the fields in this struct, as it is used for binary serialization/deserialization.
+[StructLayout(LayoutKind.Sequential, Size = SIZE)]
+internal struct AssetMetadata
+{
+    public const int CURRENT_FORMAT_VERSION = 1;
+    public const int SIZE = 128; // Fixed size for metadata header. We choose 128 bytes to allow future expansion without breaking compatibility.
+
+    public AssetMetadata(Guid id, Guid typeID)
+    {
+        FormatVersion = CURRENT_FORMAT_VERSION;
+        ID = id;
+        TypeID = typeID;
+    }
+
+    public int FormatVersion
+    {
+        get;
+    }
+
+    public Guid ID
+    {
+        get;
+    }
+
+    public Guid TypeID
+    {
+        get;
+    }
+
+    public int HandlerVersion
+    {
+        get; set;
+    }
+
+    public int DependencyCount
+    {
+        get; set;
+    }
+
+    public long DependenciesOffset
+    {
+        get; set;
+    }
+
+    public long SettingsOffset
+    {
+        get; set;
+    }
+
+    public long SettingsSize
+    {
+        get; set;
+    }
+
+    public long ContentOffset
+    {
+        get; set;
+    }
+
+    public long ContentSize
+    {
+        get; set;
+    }
+
+    public static void WriteToStream(Stream stream, scoped ref readonly AssetMetadata metadata)
+    {
+        var buffer = MemoryMarshal.AsBytes(MemoryMarshal.CreateReadOnlySpan(in metadata, 1));
+        stream.Write(buffer);
+    }
+
+    public static AssetMetadata ReadFromStream(Stream stream)
+    {
+        Span<byte> buffer = stackalloc byte[SIZE];
+        stream.ReadExactly(buffer);
+        return Unsafe.ReadUnaligned<AssetMetadata>(ref MemoryMarshal.GetReference(buffer));
+    }
+}
+
+[StructLayout(LayoutKind.Sequential, Size = SIZE)]
+public readonly struct DependencyInfo
+{
+    public const int SIZE = 16;
+
+    public Guid ID
+    {
+        get; init;
+    }
+
+    public readonly ReadOnlySpan<byte> AsBytes()
+    {
+        return MemoryMarshal.AsBytes(MemoryMarshal.CreateReadOnlySpan(in this, 1));
+    }
+}
+
+public readonly struct AssetReference : IEquatable<AssetReference>
+{
+    private readonly int _value;
+
+    /// <summary>
+    /// The index of the asset in the dependency list.
+    /// </summary>
+    public int Index
+    {
+        get => Math.Abs(_value) - 1;
+    }
+
+    public static AssetReference Null => default;
+
+    public readonly bool IsInternal => _value >= 0;
+    public readonly bool IsExternal => _value < 0;
+
+    public bool Equals(AssetReference other)
+    {
+        return _value == other._value;
+    }
+
+    public override int GetHashCode()
+    {
+        return _value.GetHashCode();
+    }
+
+    public override bool Equals(object? obj)
+    {
+        return obj is AssetReference reference && Equals(reference);
+    }
+
+    public static bool operator ==(AssetReference left, AssetReference right)
+    {
+        return left.Equals(right);
+    }
+
+    public static bool operator !=(AssetReference left, AssetReference right)
+    {
+        return !(left == right);
+    }
+}
+
+public interface IAssetSettings
+{
+    ValueTask<Result<long>> WriteToStreamAsync(Stream stream, CancellationToken token = default);
+    ValueTask<Result<IAssetSettings>> ReadFromStreamAsync(Stream stream, CancellationToken token = default);
+}
--- a/src/Editor/Ghost.Editor.Core/AssetHandler/AssetHandler.cs
+++ b/src/Editor/Ghost.Editor.Core/AssetHandler/AssetHandler.cs
@@ -0,0 +1,66 @@
+using Ghost.Core;
+using Ghost.Editor.Core.Contracts;
+
+namespace Ghost.Editor.Core.AssetHandler;
+
+[AttributeUsage(AttributeTargets.Class)]
+public sealed class CustomAssetHandlerAttribute : Attribute
+{
+    public required string ID
+    {
+        get; init;
+    }
+
+    public bool AllowCaching
+    {
+        get; init;
+    } = true;
+
+    public required string[] SupportedExtensions
+    {
+        get; init;
+    }
+}
+
+public enum DependencyUpdateType
+{
+    Add,
+    Remove
+}
+
+public interface IAssetExportOptions;
+
+public interface IAssetHandler
+{
+    ValueTask<Result<Asset>> LoadAsync(Stream sourceStream, IAssetRegistry assetDatabase, CancellationToken token = default);
+    ValueTask<Result> SaveAsync(Asset asset, Stream targetStream, IAssetRegistry assetDatabase, CancellationToken token = default);
+}
+
+public interface IImportableAssetHandler : IAssetHandler
+{
+    ValueTask<Result> ImportAsync(Stream sourceStream, Stream targetStream, Guid id, CancellationToken token = default);
+    ValueTask<Result> ExportAsync(Stream assetStream, Stream targetStream, IAssetExportOptions? options, CancellationToken token = default);
+}
+
+public static class AssetHandlerExtensions
+{
+    public static async ValueTask<Result> ImportAsync(this IImportableAssetHandler handler, string sourceFilePath, string targetFilePath, Guid id, CancellationToken token = default)
+    {
+        await using var sourceStream = new FileStream(sourceFilePath, FileMode.Open, FileAccess.Read, FileShare.Read);
+        await using var targetStream = new FileStream(targetFilePath, FileMode.Create, FileAccess.Write, FileShare.None);
+        return await handler.ImportAsync(sourceStream, targetStream, id, token);
+    }
+
+    public static async ValueTask<Result> ExportAsync(this IImportableAssetHandler handler, string assetFilePath, string targetFilePath, IAssetExportOptions? options, CancellationToken token = default)
+    {
+        await using var assetStream = new FileStream(assetFilePath, FileMode.Open, FileAccess.Read, FileShare.Read);
+        await using var targetStream = new FileStream(targetFilePath, FileMode.Create, FileAccess.Write, FileShare.None);
+        return await handler.ExportAsync(assetStream, targetStream, options, token);
+    }
+
+    public static async ValueTask<Result<Asset>> ReadAsync(this IAssetHandler handler, string assetFilePath, IAssetRegistry assetDatabase, CancellationToken token = default)
+    {
+        await using var sourceStream = new FileStream(assetFilePath, FileMode.Open, FileAccess.Read, FileShare.Read);
+        return await handler.LoadAsync(sourceStream, assetDatabase, token);
+    }
+}
--- a/src/Editor/Ghost.Editor.Core/AssetHandler/TextureAsset.cs
+++ b/src/Editor/Ghost.Editor.Core/AssetHandler/TextureAsset.cs
@@ -0,0 +1,378 @@
+using Ghost.Core;
+using Ghost.Editor.Core.Contracts;
+using Ghost.Graphics.Core;
+using Ghost.Graphics.RHI;
+using Misaki.HighPerformance.Image;
+using System.Buffers;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace Ghost.Editor.Core.AssetHandler;
+
+public enum TextureType : uint
+{
+    Default,
+    Normal,
+    Lightmap,
+    SingleChannel
+}
+
+public enum TextureShape : uint
+{
+    Texture2D,
+    Texture3D,
+    TextureCube
+}
+
+public enum TextureSize : uint
+{
+    Size256 = 256,
+    Size512 = 512,
+    Size1024 = 1024,
+    Size2048 = 2048,
+    Size4096 = 4096,
+    Size8192 = 8192
+}
+
+public enum TextureCompressionLevel : uint
+{
+    Low,
+    Normal,
+    High
+}
+
+public enum TextureCompressionEffort : uint
+{
+    Fastest,
+    Normal,
+    Production
+}
+
+public enum MipmapFilter : uint
+{
+    Box,
+    Triangle,
+    Kaiser,
+    MitchellNetravali
+}
+
+public class TextureAsset : Asset
+{
+    internal const string _TYPE_ID = "0906F4EB-C3F0-431B-BCEA-132C88AB0C3F";
+
+    internal static readonly Guid s_typeGuid = Guid.Parse(_TYPE_ID);
+
+    public override Guid TypeID => s_typeGuid;
+
+    public TextureAsset(Guid id, Guid[] dependencies, IAssetSettings? settings)
+        : base(id, dependencies, settings)
+    {
+    }
+}
+
+public class TextureAssetSettings : IAssetSettings
+{
+    public struct BasicSettings()
+    {
+        public TextureType TextureType
+        {
+            get; set;
+        } = TextureType.Default;
+
+        public TextureShape TextureShape
+        {
+            get; set;
+        } = TextureShape.Texture2D;
+
+        public int Columns
+        {
+            get; set;
+        } = 1;
+
+        public int Rows
+        {
+            get; set;
+        } = 1;
+
+        public bool IsSRGB
+        {
+            get; set;
+        } = true;
+    }
+
+    public struct AdvancedSettings()
+    {
+        public bool StretchToPowerOfTwo
+        {
+            get; set;
+        } = true;
+
+        public bool VirtualTexture
+        {
+            get; set;
+        } = false;
+
+        public bool GenerateMipmaps
+        {
+            get; set;
+        } = true;
+
+        public uint MipmapLevelCount
+        {
+            get; set;
+        } = 0; // 0 means generate full mipmap levels.
+
+        public bool GammaCorrection
+        {
+            get; set;
+        } = true;
+
+        public bool PremultiplyAlpha
+        {
+            get; set;
+        } = false;
+
+        public MipmapFilter MipmapFilter
+        {
+            get; set;
+        } = MipmapFilter.Kaiser;
+
+        public TextureCompressionLevel CompressionLevel
+        {
+            get; set;
+        } = TextureCompressionLevel.Normal;
+
+        public TextureCompressionEffort CompressionEffort
+        {
+            get; set;
+        } = TextureCompressionEffort.Normal;
+
+        public bool UseBorderColor
+        {
+            get; set;
+        } = false;
+
+        public Color32 BorderColor
+        {
+            get; set;
+        } = new Color32(0, 0, 0, 0);
+
+        public bool ZeroAlphaBorder
+        {
+            get; set;
+        } = false;
+
+        public bool CutoutAlpha
+        {
+            get; set;
+        } = false;
+
+        public byte CutoutAlphaThreshold
+        {
+            get; set;
+        } = 127;
+
+        public bool ScaleAlphaForMipCoverage
+        {
+            get; set;
+        } = false;
+
+        public byte ScaleAlphaForMipCoverageThreshold
+        {
+            get; set;
+        } = 127;
+
+        public bool MipmapStreaming
+        {
+            get; set;
+        } = false;
+    }
+
+    public struct SamplerSettings()
+    {
+        public TextureSize MaxSize
+        {
+            get; set;
+        } = TextureSize.Size2048;
+
+        public TextureFilterMode FilterMode
+        {
+            get; set;
+        } = TextureFilterMode.Anisotropic;
+
+        public TextureAddressMode WrapMode
+        {
+            get; set;
+        } = TextureAddressMode.Repeat;
+    }
+
+    public BasicSettings Basic
+    {
+        get; set;
+    } = new BasicSettings();
+
+    public AdvancedSettings Advanced
+    {
+        get; set;
+    } = new AdvancedSettings();
+
+    public SamplerSettings Sampler
+    {
+        get; set;
+    } = new SamplerSettings();
+
+    public async ValueTask<Result<long>> WriteToStreamAsync(Stream stream, CancellationToken token = default)
+    {
+        var size = Unsafe.SizeOf<BasicSettings>() + Unsafe.SizeOf<AdvancedSettings>() + Unsafe.SizeOf<SamplerSettings>();
+        var tempArray = ArrayPool<byte>.Shared.Rent(size);
+
+        try
+        {
+            ref byte address = ref MemoryMarshal.GetReference(tempArray);
+            Unsafe.WriteUnaligned(ref address, Basic);
+            Unsafe.WriteUnaligned(ref Unsafe.Add(ref address, Unsafe.SizeOf<BasicSettings>()), Advanced);
+            Unsafe.WriteUnaligned(ref Unsafe.Add(ref address, Unsafe.SizeOf<BasicSettings>() + Unsafe.SizeOf<AdvancedSettings>()), Sampler);
+
+            await stream.WriteAsync(tempArray.AsMemory(0, size), token).ConfigureAwait(false);
+
+            return Result.Success<long>(size);
+        }
+        catch (Exception ex)
+        {
+            return Result.Failure($"Failed to write texture asset settings to stream: {ex.Message}");
+        }
+        finally
+        {
+            ArrayPool<byte>.Shared.Return(tempArray);
+        }
+    }
+
+    public async ValueTask<Result<IAssetSettings>> ReadFromStreamAsync(Stream stream, CancellationToken token = default)
+    {
+        var size = Unsafe.SizeOf<BasicSettings>() + Unsafe.SizeOf<AdvancedSettings>() + Unsafe.SizeOf<SamplerSettings>();
+        var tempArray = ArrayPool<byte>.Shared.Rent(size);
+
+        try
+        {
+            ref byte address = ref MemoryMarshal.GetReference(tempArray);
+            await stream.ReadAsync(tempArray.AsMemory(0, size), token).ConfigureAwait(false);
+            var basic = Unsafe.ReadUnaligned<BasicSettings>(ref address);
+            var advanced = Unsafe.ReadUnaligned<AdvancedSettings>(ref Unsafe.Add(ref address, Unsafe.SizeOf<BasicSettings>()));
+            var sampler = Unsafe.ReadUnaligned<SamplerSettings>(ref Unsafe.Add(ref address, Unsafe.SizeOf<BasicSettings>() + Unsafe.SizeOf<AdvancedSettings>()));
+
+            var settings = new TextureAssetSettings
+            {
+                Basic = basic,
+                Advanced = advanced,
+                Sampler = sampler
+            };
+
+            return Result.Success<IAssetSettings>(settings);
+        }
+        catch (Exception ex)
+        {
+            return Result.Failure($"Failed to read texture asset settings from stream: {ex.Message}");
+        }
+        finally
+        {
+            ArrayPool<byte>.Shared.Return(tempArray);
+        }
+    }
+}
+
+internal class TextureAssetHandler : IImportableAssetHandler
+{
+    private const int _CURRENT_VERSION = 1;
+
+    public ValueTask<Result> ExportAsync(Stream assetStream, Stream targetStream, IAssetExportOptions? options, CancellationToken token = default)
+    {
+        throw new NotImplementedException();
+    }
+
+    public async ValueTask<Result> ImportAsync(Stream sourceStream, Stream targetStream, Guid id, CancellationToken token = default)
+    {
+        var info = ImageInfo.FromStream(sourceStream);
+        if (info.BitsPerChannel <= 0)
+        {
+            return Result.Failure($"Unsupported image format with {info.BitsPerChannel} bits per channel.");
+        }
+
+        ref byte pData = ref Unsafe.NullRef<byte>();
+        var imageSize = 0ul;
+        var isFloat = info.BitsPerChannel > 8;
+
+        if (isFloat)
+        {
+            using var image = ImageResultFloat.FromStream(sourceStream, info.ColorComponents);
+            pData = ref MemoryMarshal.GetReference(MemoryMarshal.AsBytes(image.AsSpan()));
+            imageSize = image.Size;
+        }
+        else
+        {
+            using var image = ImageResult.FromStream(sourceStream, info.ColorComponents);
+            pData = ref MemoryMarshal.GetReference(MemoryMarshal.AsBytes(image.AsSpan()));
+            imageSize = image.Size;
+        }
+
+        var header = new AssetMetadata(id, TextureAsset.s_typeGuid)
+        {
+            HandlerVersion = _CURRENT_VERSION,
+            SettingsOffset = AssetMetadata.SIZE,
+        };
+
+        targetStream.Seek(0, SeekOrigin.Begin);
+        AssetMetadata.WriteToStream(targetStream, ref header);
+
+        targetStream.Seek(header.SettingsOffset, SeekOrigin.Begin);
+        var settings = new TextureAssetSettings();
+        var sizeResult = await settings.WriteToStreamAsync(targetStream, token).ConfigureAwait(false);
+        if (sizeResult.IsFailure)
+        {
+            return Result.Failure($"Failed to write texture asset settings: {sizeResult.Message}");
+        }
+
+        header.SettingsSize = sizeResult.Value;
+        header.ContentOffset = header.SettingsOffset + sizeResult.Value;
+        header.ContentSize = (long)imageSize;
+
+        targetStream.Seek(header.ContentOffset, SeekOrigin.Begin);
+
+        var offset = 0;
+        var tempArray = ArrayPool<byte>.Shared.Rent((int)Math.Min(imageSize, 40960ul));
+        var remaining = imageSize;
+
+        try
+        {
+            while (remaining > 0)
+            {
+                var chunkSize = (int)Math.Min(remaining, (ulong)tempArray.Length);
+                Unsafe.CopyBlockUnaligned(ref tempArray[0], ref Unsafe.Add(ref pData, offset), (uint)chunkSize);
+                
+                await targetStream.WriteAsync(tempArray.AsMemory(0, chunkSize), token).ConfigureAwait(false);
+
+                offset += chunkSize;
+                remaining -= (ulong)chunkSize;
+            }
+
+            return Result.Success();
+        }
+        catch (Exception ex)
+        {
+            return Result.Failure($"Failed to write texture asset content to stream: {ex.Message}");
+        }
+        finally
+        {
+            ArrayPool<byte>.Shared.Return(tempArray);
+        }
+    }
+
+    public ValueTask<Result<Asset>> LoadAsync(Stream sourceStream, IAssetRegistry assetDatabase, CancellationToken token = default)
+    {
+        throw new NotImplementedException();
+    }
+
+    public ValueTask<Result> SaveAsync(Asset asset, Stream targetStream, IAssetRegistry assetDatabase, CancellationToken token = default)
+    {
+        throw new NotImplementedException();
+    }
+}