495 lines
12 KiB
C#
495 lines
12 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Runtime.InteropServices;
|
|
using MoonWorks.Video;
|
|
using RefreshCS;
|
|
|
|
namespace MoonWorks.Graphics
|
|
{
|
|
/// <summary>
|
|
/// GraphicsDevice manages all graphics-related concerns.
|
|
/// </summary>
|
|
public class GraphicsDevice : IDisposable
|
|
{
|
|
public IntPtr Handle { get; }
|
|
public BackendFlags Backend { get; }
|
|
public bool DebugMode { get; }
|
|
|
|
// Built-in video pipeline
|
|
internal GraphicsPipeline VideoPipeline { get; }
|
|
|
|
// Built-in text shader info
|
|
public Shader TextVertexShader;
|
|
public Shader TextFragmentShader;
|
|
public GraphicsPipelineResourceInfo TextVertexShaderInfo { get; }
|
|
public GraphicsPipelineResourceInfo TextFragmentShaderInfo { get; }
|
|
public VertexInputState TextVertexInputState { get; }
|
|
|
|
// Built-in samplers
|
|
public Sampler PointSampler { get; }
|
|
public Sampler LinearSampler { get; }
|
|
|
|
public bool IsDisposed { get; private set; }
|
|
|
|
private readonly HashSet<GCHandle> resources = new HashSet<GCHandle>();
|
|
private CommandBufferPool CommandBufferPool;
|
|
private FencePool FencePool;
|
|
internal RenderPassPool RenderPassPool = new RenderPassPool();
|
|
internal ComputePassPool ComputePassPool = new ComputePassPool();
|
|
internal CopyPassPool CopyPassPool = new CopyPassPool();
|
|
|
|
internal unsafe GraphicsDevice(
|
|
BackendFlags preferredBackends,
|
|
bool debugMode
|
|
) {
|
|
if (preferredBackends == BackendFlags.Invalid)
|
|
{
|
|
throw new System.Exception("Could not set graphics backend!");
|
|
}
|
|
|
|
Handle = Refresh.Refresh_CreateDevice(
|
|
(Refresh.BackendFlags) preferredBackends,
|
|
Conversions.BoolToByte(debugMode)
|
|
);
|
|
|
|
DebugMode = debugMode;
|
|
// TODO: check for CreateDevice fail
|
|
|
|
Backend = (BackendFlags) Refresh.Refresh_GetBackend(Handle);
|
|
|
|
// Check for replacement stock shaders
|
|
string basePath = System.AppContext.BaseDirectory;
|
|
|
|
string fullscreenVertPath = Path.Combine(basePath, "fullscreen.vert.refresh");
|
|
|
|
string textVertPath = Path.Combine(basePath, "text_transform.vert.refresh");
|
|
string textFragPath = Path.Combine(basePath, "text_msdf.frag.refresh");
|
|
|
|
string videoFragPath = Path.Combine(basePath, "video_yuv2rgba.frag.refresh");
|
|
|
|
Shader fullscreenVertShader;
|
|
|
|
Shader textVertShader;
|
|
Shader textFragShader;
|
|
|
|
Shader videoFragShader;
|
|
|
|
if (File.Exists(fullscreenVertPath))
|
|
{
|
|
fullscreenVertShader = new Shader(
|
|
this,
|
|
fullscreenVertPath,
|
|
"main",
|
|
ShaderStage.Vertex,
|
|
ShaderFormat.SECRET
|
|
);
|
|
}
|
|
else
|
|
{
|
|
// use defaults
|
|
var assembly = typeof(GraphicsDevice).Assembly;
|
|
using var vertStream = assembly.GetManifestResourceStream("MoonWorks.Graphics.StockShaders.Fullscreen.vert.spv");
|
|
fullscreenVertShader = new Shader(
|
|
this,
|
|
vertStream,
|
|
"main",
|
|
ShaderStage.Vertex,
|
|
ShaderFormat.SPIRV
|
|
);
|
|
}
|
|
|
|
if (File.Exists(videoFragPath))
|
|
{
|
|
videoFragShader = new Shader(
|
|
this,
|
|
videoFragPath,
|
|
"main",
|
|
ShaderStage.Fragment,
|
|
ShaderFormat.SECRET
|
|
);
|
|
}
|
|
else
|
|
{
|
|
// use defaults
|
|
var assembly = typeof(GraphicsDevice).Assembly;
|
|
using var fragStream = assembly.GetManifestResourceStream("MoonWorks.Graphics.StockShaders.VideoYUV2RGBA.frag.spv");
|
|
videoFragShader = new Shader(
|
|
this,
|
|
fragStream,
|
|
"main",
|
|
ShaderStage.Fragment,
|
|
ShaderFormat.SPIRV
|
|
);
|
|
}
|
|
|
|
if (File.Exists(textVertPath) && File.Exists(textFragPath))
|
|
{
|
|
textVertShader = new Shader(
|
|
this,
|
|
textVertPath,
|
|
"main",
|
|
ShaderStage.Vertex,
|
|
ShaderFormat.SECRET
|
|
);
|
|
|
|
textFragShader = new Shader(
|
|
this,
|
|
textFragPath,
|
|
"main",
|
|
ShaderStage.Fragment,
|
|
ShaderFormat.SECRET
|
|
);
|
|
}
|
|
else
|
|
{
|
|
// use defaults
|
|
var assembly = typeof(GraphicsDevice).Assembly;
|
|
|
|
using var vertStream = assembly.GetManifestResourceStream("MoonWorks.Graphics.StockShaders.TextTransform.vert.spv");
|
|
using var fragStream = assembly.GetManifestResourceStream("MoonWorks.Graphics.StockShaders.TextMSDF.frag.spv");
|
|
|
|
textVertShader = new Shader(
|
|
this,
|
|
vertStream,
|
|
"main",
|
|
ShaderStage.Fragment,
|
|
ShaderFormat.SPIRV
|
|
);
|
|
|
|
textFragShader = new Shader(
|
|
this,
|
|
fragStream,
|
|
"main",
|
|
ShaderStage.Fragment,
|
|
ShaderFormat.SPIRV
|
|
);
|
|
}
|
|
|
|
VideoPipeline = new GraphicsPipeline(
|
|
this,
|
|
new GraphicsPipelineCreateInfo
|
|
{
|
|
AttachmentInfo = new GraphicsPipelineAttachmentInfo(
|
|
new ColorAttachmentDescription(
|
|
TextureFormat.R8G8B8A8,
|
|
ColorAttachmentBlendState.None
|
|
)
|
|
),
|
|
DepthStencilState = DepthStencilState.Disable,
|
|
VertexShader = fullscreenVertShader,
|
|
FragmentShader = videoFragShader,
|
|
FragmentShaderResourceInfo = new GraphicsPipelineResourceInfo
|
|
{
|
|
SamplerCount = 3
|
|
},
|
|
VertexInputState = VertexInputState.Empty,
|
|
RasterizerState = RasterizerState.CCW_CullNone,
|
|
PrimitiveType = PrimitiveType.TriangleList,
|
|
MultisampleState = MultisampleState.None
|
|
}
|
|
);
|
|
|
|
TextVertexShader = textVertShader;
|
|
TextVertexShaderInfo = new GraphicsPipelineResourceInfo();
|
|
|
|
TextFragmentShader = textFragShader;
|
|
TextFragmentShaderInfo = new GraphicsPipelineResourceInfo
|
|
{
|
|
SamplerCount = 1
|
|
};
|
|
|
|
TextVertexInputState = VertexInputState.CreateSingleBinding<Font.Vertex>();
|
|
|
|
PointSampler = new Sampler(this, SamplerCreateInfo.PointClamp);
|
|
LinearSampler = new Sampler(this, SamplerCreateInfo.LinearClamp);
|
|
|
|
FencePool = new FencePool(this);
|
|
CommandBufferPool = new CommandBufferPool(this);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Prepares a window so that frames can be presented to it.
|
|
/// </summary>
|
|
/// <param name="swapchainComposition">The desired composition of the swapchain. Ignore this unless you are using HDR or tonemapping.</param>
|
|
/// <param name="presentMode">The desired presentation mode for the window. Roughly equivalent to V-Sync.</param>
|
|
/// <returns>True if successfully claimed.</returns>
|
|
public bool ClaimWindow(
|
|
Window window,
|
|
SwapchainComposition swapchainComposition,
|
|
PresentMode presentMode
|
|
) {
|
|
if (window.Claimed)
|
|
{
|
|
Logger.LogError("Window already claimed!");
|
|
return false;
|
|
}
|
|
|
|
var success = Conversions.IntToBool(
|
|
Refresh.Refresh_ClaimWindow(
|
|
Handle,
|
|
window.Handle,
|
|
(Refresh.SwapchainComposition) swapchainComposition,
|
|
(Refresh.PresentMode) presentMode
|
|
)
|
|
);
|
|
|
|
if (success)
|
|
{
|
|
window.Claimed = true;
|
|
window.SwapchainComposition = swapchainComposition;
|
|
window.SwapchainFormat = GetSwapchainFormat(window);
|
|
|
|
if (window.SwapchainTexture == null)
|
|
{
|
|
window.SwapchainTexture = new Texture(this, window.SwapchainFormat);
|
|
}
|
|
}
|
|
|
|
return success;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Unclaims a window, making it unavailable for presenting and freeing associated resources.
|
|
/// </summary>
|
|
public void UnclaimWindow(Window window)
|
|
{
|
|
if (window.Claimed)
|
|
{
|
|
Refresh.Refresh_UnclaimWindow(
|
|
Handle,
|
|
window.Handle
|
|
);
|
|
window.Claimed = false;
|
|
|
|
// The swapchain texture doesn't actually have a permanent texture reference, so we zero the handle before disposing.
|
|
window.SwapchainTexture.Handle = IntPtr.Zero;
|
|
window.SwapchainTexture.Dispose();
|
|
window.SwapchainTexture = null;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Changes the present mode of a claimed window. Does nothing if the window is not claimed.
|
|
/// </summary>
|
|
/// <param name="window"></param>
|
|
/// <param name="presentMode"></param>
|
|
public void SetSwapchainParameters(
|
|
Window window,
|
|
SwapchainComposition swapchainComposition,
|
|
PresentMode presentMode
|
|
) {
|
|
if (!window.Claimed)
|
|
{
|
|
Logger.LogError("Cannot set present mode on unclaimed window!");
|
|
return;
|
|
}
|
|
|
|
Refresh.Refresh_SetSwapchainParameters(
|
|
Handle,
|
|
window.Handle,
|
|
(Refresh.SwapchainComposition) swapchainComposition,
|
|
(Refresh.PresentMode) presentMode
|
|
);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Acquires a command buffer.
|
|
/// This is the start of your rendering process.
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public CommandBuffer AcquireCommandBuffer()
|
|
{
|
|
var commandBuffer = CommandBufferPool.Obtain();
|
|
commandBuffer.SetHandle(Refresh.Refresh_AcquireCommandBuffer(Handle));
|
|
#if DEBUG
|
|
commandBuffer.ResetStateTracking();
|
|
#endif
|
|
return commandBuffer;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Submits a command buffer to the GPU for processing.
|
|
/// </summary>
|
|
public void Submit(CommandBuffer commandBuffer)
|
|
{
|
|
#if DEBUG
|
|
if (commandBuffer.Submitted)
|
|
{
|
|
throw new System.InvalidOperationException("Command buffer already submitted!");
|
|
}
|
|
#endif
|
|
|
|
Refresh.Refresh_Submit(
|
|
commandBuffer.Handle
|
|
);
|
|
|
|
CommandBufferPool.Return(commandBuffer);
|
|
|
|
#if DEBUG
|
|
commandBuffer.Submitted = true;
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// Submits a command buffer to the GPU for processing and acquires a fence associated with the submission.
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public Fence SubmitAndAcquireFence(CommandBuffer commandBuffer)
|
|
{
|
|
var fenceHandle = Refresh.Refresh_SubmitAndAcquireFence(
|
|
commandBuffer.Handle
|
|
);
|
|
|
|
var fence = FencePool.Obtain();
|
|
fence.SetHandle(fenceHandle);
|
|
|
|
return fence;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Wait for the graphics device to become idle.
|
|
/// </summary>
|
|
public void Wait()
|
|
{
|
|
Refresh.Refresh_Wait(Handle);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Waits for the given fence to become signaled.
|
|
/// </summary>
|
|
public unsafe void WaitForFence(Fence fence)
|
|
{
|
|
var fenceHandle = fence.Handle;
|
|
|
|
Refresh.Refresh_WaitForFences(
|
|
Handle,
|
|
1,
|
|
&fenceHandle,
|
|
1
|
|
);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Wait for one or more fences to become signaled.
|
|
/// </summary>
|
|
/// <param name="waitAll">If true, will wait for all given fences to be signaled.</param>
|
|
public unsafe void WaitForFences(Span<Fence> fences, bool waitAll)
|
|
{
|
|
var handlePtr = stackalloc nint[fences.Length];
|
|
|
|
for (var i = 0; i < fences.Length; i += 1)
|
|
{
|
|
handlePtr[i] = fences[i].Handle;
|
|
}
|
|
|
|
Refresh.Refresh_WaitForFences(
|
|
Handle,
|
|
Conversions.BoolToInt(waitAll),
|
|
handlePtr,
|
|
(uint) fences.Length
|
|
);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns true if the fence is signaled, indicating that the associated command buffer has finished processing.
|
|
/// </summary>
|
|
/// <exception cref="InvalidOperationException">Throws if the fence query indicates that the graphics device has been lost.</exception>
|
|
public bool QueryFence(Fence fence)
|
|
{
|
|
var result = Refresh.Refresh_QueryFence(Handle, fence.Handle);
|
|
|
|
if (result < 0)
|
|
{
|
|
throw new InvalidOperationException("The graphics device has been lost.");
|
|
}
|
|
|
|
return result != 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Release reference to an acquired fence, enabling it to be reused.
|
|
/// </summary>
|
|
public void ReleaseFence(Fence fence)
|
|
{
|
|
Refresh.Refresh_ReleaseFence(Handle, fence.Handle);
|
|
fence.Handle = IntPtr.Zero;
|
|
FencePool.Return(fence);
|
|
}
|
|
|
|
private TextureFormat GetSwapchainFormat(Window window)
|
|
{
|
|
if (!window.Claimed)
|
|
{
|
|
throw new System.ArgumentException("Cannot get swapchain format of unclaimed window!");
|
|
}
|
|
|
|
return (TextureFormat) Refresh.Refresh_GetSwapchainTextureFormat(Handle, window.Handle);
|
|
}
|
|
|
|
internal void AddResourceReference(GCHandle resourceReference)
|
|
{
|
|
lock (resources)
|
|
{
|
|
resources.Add(resourceReference);
|
|
}
|
|
}
|
|
|
|
internal void RemoveResourceReference(GCHandle resourceReference)
|
|
{
|
|
lock (resources)
|
|
{
|
|
resources.Remove(resourceReference);
|
|
}
|
|
}
|
|
|
|
protected virtual void Dispose(bool disposing)
|
|
{
|
|
if (!IsDisposed)
|
|
{
|
|
if (disposing)
|
|
{
|
|
lock (resources)
|
|
{
|
|
// Dispose video players first to avoid race condition on threaded decoding
|
|
foreach (var resource in resources)
|
|
{
|
|
if (resource.Target is VideoPlayer player)
|
|
{
|
|
player.Dispose();
|
|
}
|
|
}
|
|
|
|
// Dispose everything else
|
|
foreach (var resource in resources)
|
|
{
|
|
if (resource.Target is IDisposable disposable)
|
|
{
|
|
disposable.Dispose();
|
|
}
|
|
}
|
|
resources.Clear();
|
|
}
|
|
}
|
|
|
|
Refresh.Refresh_DestroyDevice(Handle);
|
|
|
|
IsDisposed = true;
|
|
}
|
|
}
|
|
|
|
~GraphicsDevice()
|
|
{
|
|
// Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
|
|
Dispose(disposing: false);
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
// Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
|
|
Dispose(disposing: true);
|
|
GC.SuppressFinalize(this);
|
|
}
|
|
}
|
|
}
|