Add Vulkan backend for 3D rendering with advanced features

Beutl.slnx

@@ -25,6 +25,7 @@
     <File Path="version.json" />
   </Folder>
   <Folder Name="/Tests/">
+    <Project Path="tests/Beutl.Graphics3DTests/Beutl.Graphics3DTests.csproj" />
     <Project Path="tests\Beutl.Benchmarks\Beutl.Benchmarks.csproj" />
     <Project Path="tests\Beutl.UnitTests\Beutl.UnitTests.csproj" />
     <Project Path="tests\DirectoryViewTest\DirectoryViewTest.csproj" />

Directory.Packages.props

@@ -16,6 +16,8 @@
     <PackageVersion Include="Silk.NET.Vulkan.Extensions.KHR" Version="2.22.0" />
     <PackageVersion Include="Silk.NET.Vulkan.Loader.Native" Version="2024.10.25" />
     <PackageVersion Include="Silk.NET.Vulkan.SwiftShader.Native" Version="2024.5.8" />
+    <PackageVersion Include="Silk.NET.Shaderc" Version="2.22.0" />
+    <PackageVersion Include="Silk.NET.Shaderc.Native" Version="2.22.0" />
     <PackageVersion Include="Svg.Controls.Skia.Avalonia" Version="11.3.6.2" />
     <PackageVersion Include="Avalonia.Themes.Fluent" Version="11.3.9" />
     <PackageVersion Include="Xaml.Behaviors.Avalonia" Version="11.3.9" />

src/Beutl.Core/JsonConverters/QuaternionJsonConverter.cs

@@ -0,0 +1,28 @@
+using System.Numerics;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Beutl.Utilities;
+
+namespace Beutl.JsonConverters;
+
+internal sealed class QuaternionJsonConverter : JsonConverter<Quaternion>
+{
+    public override Quaternion Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        string? s = reader.GetString();
+        if (s == null)
+            throw new Exception("Invalid Quaternion.");
+
+        var tokenizer = new RefStringTokenizer(s, exceptionMessage: "Invalid Quaternion.");
+        float x = tokenizer.ReadSingle();
+        float y = tokenizer.ReadSingle();
+        float z = tokenizer.ReadSingle();
+        float w = tokenizer.ReadSingle();
+        return new Quaternion(x, y, z, w);
+    }
+
+    public override void Write(Utf8JsonWriter writer, Quaternion value, JsonSerializerOptions options)
+    {
+        writer.WriteStringValue($"{value.X},{value.Y},{value.Z},{value.W}");
+    }
+}

src/Beutl.Core/JsonConverters/Vector3JsonConverter.cs

@@ -0,0 +1,28 @@
+using System.Numerics;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+using Beutl.Utilities;
+
+namespace Beutl.JsonConverters;
+
+internal sealed class Vector3JsonConverter : JsonConverter<Vector3>
+{
+    public override Vector3 Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        string? s = reader.GetString();
+        if (s == null)
+            throw new Exception("Invalid Vector3.");
+
+        var tokenizer = new RefStringTokenizer(s, exceptionMessage: "Invalid Quaternion.");
+        float x = tokenizer.ReadSingle();
+        float y = tokenizer.ReadSingle();
+        float z = tokenizer.ReadSingle();
+        return new Vector3(x, y, z);
+    }
+
+    public override void Write(Utf8JsonWriter writer, Vector3 value, JsonSerializerOptions options)
+    {
+        writer.WriteStringValue($"{value.X},{value.Y},{value.Z}");
+    }
+}

src/Beutl.Core/JsonHelper.cs

@@ -30,6 +30,8 @@ public static class JsonHelper
             new DirectoryInfoConverter(),
             new FileInfoConverter(),
             new CoreSerializableJsonConverter(),
+            new Vector3JsonConverter(),
+            new QuaternionJsonConverter()
             //new CoreObjectJsonConverter()
         }
     };

src/Beutl.Engine/Beutl.Engine.csproj

@@ -2,6 +2,10 @@
   <PropertyGroup>
     <RootNameSpace>Beutl</RootNameSpace>
   </PropertyGroup>
+  <ItemGroup>
+    <InternalsVisibleTo Include="Beutl.Graphics3DTests" />
+    <InternalsVisibleTo Include="Beutl.UnitTests" />
+  </ItemGroup>
   <ItemGroup>
     <Compile Remove="Graphics\VertexMode.cs" />
   </ItemGroup>
@@ -38,5 +42,7 @@
     <PackageReference Include="SkiaSharp" />
     <PackageReference Include="SkiaSharp.NativeAssets.Linux" />
     <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Scripting" />
+    <PackageReference Include="Silk.NET.Shaderc" />
+    <PackageReference Include="Silk.NET.Shaderc.Native" />
   </ItemGroup>
 </Project>

src/Beutl.Engine/Graphics/Backend/AttachmentLoadOp.cs

@@ -0,0 +1,22 @@
+namespace Beutl.Graphics.Backend;
+
+/// <summary>
+/// Specifies the operation to perform on an attachment at the beginning of a render pass.
+/// </summary>
+public enum AttachmentLoadOp
+{
+    /// <summary>
+    /// The previous contents of the attachment are preserved.
+    /// </summary>
+    Load = 0,
+
+    /// <summary>
+    /// The previous contents of the attachment are cleared.
+    /// </summary>
+    Clear = 1,
+
+    /// <summary>
+    /// The previous contents of the attachment are undefined.
+    /// </summary>
+    DontCare = 2
+}

src/Beutl.Engine/Graphics/Backend/BufferUsage.cs

@@ -1,13 +1,50 @@
-namespace Beutl.Graphics.Backend;
+using System;
 
+namespace Beutl.Graphics.Backend;
+
+/// <summary>
+/// Specifies how a buffer will be used.
+/// </summary>
 [Flags]
-internal enum BufferUsage
+public enum BufferUsage
 {
+    /// <summary>
+    /// No specific usage.
+    /// </summary>
     None = 0,
+
+    /// <summary>
+    /// Buffer can be used as a vertex buffer.
+    /// </summary>
     VertexBuffer = 1 << 0,
+
+    /// <summary>
+    /// Buffer can be used as an index buffer.
+    /// </summary>
     IndexBuffer = 1 << 1,
+
+    /// <summary>
+    /// Buffer can be used as a uniform buffer.
+    /// </summary>
     UniformBuffer = 1 << 2,
+
+    /// <summary>
+    /// Buffer can be used as a storage buffer.
+    /// </summary>
     StorageBuffer = 1 << 3,
-    TransferSrc = 1 << 4,
-    TransferDst = 1 << 5
+
+    /// <summary>
+    /// Buffer can be used as a source for transfer operations.
+    /// </summary>
+    TransferSource = 1 << 4,
+
+    /// <summary>
+    /// Buffer can be used as a destination for transfer operations.
+    /// </summary>
+    TransferDestination = 1 << 5,
+
+    /// <summary>
+    /// Buffer can be used as an indirect buffer.
+    /// </summary>
+    IndirectBuffer = 1 << 6,
 }

src/Beutl.Engine/Graphics/Backend/Composite/CompositeContext.cs

@@ -0,0 +1,158 @@
+using System.Runtime.InteropServices;
+using Beutl.Graphics.Backend.Metal;
+using Beutl.Graphics.Backend.Vulkan;
+using Beutl.Graphics3D;
+using Silk.NET.Vulkan;
+using SkiaSharp;
+
+namespace Beutl.Graphics.Backend.Composite;
+
+internal sealed class CompositeContext : IGraphicsContext
+{
+    private bool _disposed;
+
+    public CompositeContext(VulkanInstance vulkanInstance, VulkanPhysicalDeviceInfo physicalDevice)
+    {
+        if (!RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
+        {
+            throw new PlatformNotSupportedException("CompositeContext is only available on macOS");
+        }
+
+        // MoltenVKの場合はMetalコンテキストを使用する
+        if (physicalDevice.IsMoltenVK)
+        {
+            Metal = new MetalContext();
+        }
+
+        Vulkan = new VulkanContext(vulkanInstance, physicalDevice);
+    }
+
+    public GraphicsBackend Backend => GraphicsBackend.Metal;
+
+    public GRContext SkiaContext => Metal?.SkiaContext ?? Vulkan.SkiaContext!;
+
+    public MetalContext? Metal { get; }
+
+    public VulkanContext Vulkan { get; }
+
+    public bool Supports3DRendering => Vulkan.Supports3DRendering;
+
+    public ISharedTexture CreateTexture(int width, int height, TextureFormat format)
+    {
+        if (Metal == null)
+            return Vulkan.CreateTexture(width, height, format);
+
+        return new MetalVulkanSharedTexture(Metal, Vulkan, width, height, format);
+    }
+
+    public ITexture2D CreateTexture2D(int width, int height, TextureFormat format)
+    {
+        return Vulkan.CreateTexture2D(width, height, format);
+    }
+
+    public ITextureCube CreateTextureCube(int size, TextureFormat format)
+    {
+        return Vulkan.CreateTextureCube(size, format);
+    }
+
+    public ITextureArray CreateTextureArray(int width, int height, uint arraySize, TextureFormat format)
+    {
+        return Vulkan.CreateTextureArray(width, height, arraySize, format);
+    }
+
+    public ITextureCubeArray CreateTextureCubeArray(int size, uint arraySize, TextureFormat format)
+    {
+        return Vulkan.CreateTextureCubeArray(size, arraySize, format);
+    }
+
+    public IBuffer CreateBuffer(ulong size, BufferUsage usage, MemoryProperty memoryProperty)
+    {
+        return Vulkan.CreateBuffer(size, usage, memoryProperty);
+    }
+
+    public IShaderCompiler CreateShaderCompiler()
+    {
+        return Vulkan.CreateShaderCompiler();
+    }
+
+    public IRenderPass3D CreateRenderPass3D(
+        IReadOnlyList<TextureFormat> colorFormats,
+        TextureFormat depthFormat = TextureFormat.Depth32Float,
+        AttachmentLoadOp colorLoadOp = AttachmentLoadOp.Clear,
+        AttachmentLoadOp depthLoadOp = AttachmentLoadOp.Clear)
+    {
+        return Vulkan.CreateRenderPass3D(colorFormats, depthFormat, colorLoadOp, depthLoadOp);
+    }
+
+    public IFramebuffer3D CreateFramebuffer3D(IRenderPass3D renderPass, IReadOnlyList<ITexture2D> colorTextures, ITexture2D depthTexture)
+    {
+        return Vulkan.CreateFramebuffer3D(renderPass, colorTextures, depthTexture);
+    }
+
+    public IPipeline3D CreatePipeline3D(
+        IRenderPass3D renderPass,
+        byte[] vertexShaderSpirv,
+        byte[] fragmentShaderSpirv,
+        DescriptorBinding[] descriptorBindings,
+        VertexInputDescription vertexInput,
+        PipelineOptions? options = null)
+    {
+        return Vulkan.CreatePipeline3D(renderPass, vertexShaderSpirv, fragmentShaderSpirv, descriptorBindings, vertexInput, options);
+    }
+
+    public IDescriptorSet CreateDescriptorSet(IPipeline3D pipeline, DescriptorPoolSize[] poolSizes)
+    {
+        return Vulkan.CreateDescriptorSet(pipeline, poolSizes);
+    }
+
+    public ISampler CreateSampler(
+        SamplerFilter minFilter = SamplerFilter.Linear,
+        SamplerFilter magFilter = SamplerFilter.Linear,
+        SamplerAddressMode addressModeU = SamplerAddressMode.ClampToEdge,
+        SamplerAddressMode addressModeV = SamplerAddressMode.ClampToEdge)
+    {
+        return Vulkan.CreateSampler(minFilter, magFilter, addressModeU, addressModeV);
+    }
+
+    public void CopyBuffer(IBuffer source, IBuffer destination, ulong size)
+    {
+        Vulkan.CopyBuffer(source, destination, size);
+    }
+
+
+    public void CopyTexture(ITexture2D source, ISharedTexture destination)
+    {
+        Vulkan.CopyTexture(source, destination);
+    }
+
+    public void CopyTextureToCubeFace(ITexture2D source, ITextureCube destination, int faceIndex)
+    {
+        Vulkan.CopyTextureToCubeFace(source, destination, faceIndex);
+    }
+
+
+    public void CopyTextureToArrayLayer(ITexture2D source, ITextureArray destination, int layerIndex)
+    {
+        Vulkan.CopyTextureToArrayLayer(source, destination, layerIndex);
+    }
+
+    public void CopyTextureToCubeArrayFace(ITexture2D source, ITextureCubeArray destination, int arrayIndex, int faceIndex)
+    {
+        Vulkan.CopyTextureToCubeArrayFace(source, destination, arrayIndex, faceIndex);
+    }
+
+    public void WaitIdle()
+    {
+        Vulkan.WaitIdle();
+        Metal?.WaitIdle();
+    }
+
+    public void Dispose()
+    {
+        if (_disposed) return;
+        _disposed = true;
+
+        Vulkan.Dispose();
+        Metal?.Dispose();
+    }
+}