wehub-resource-sync
630 lines
27 KiB
C#
630 lines
27 KiB
C#
using System.Diagnostics.CodeAnalysis;
|
|
using System.Runtime.CompilerServices;
|
|
using System.Runtime.InteropServices;
|
|
using System.Threading;
|
|
using ImGuiNET;
|
|
using SharpDX.D3DCompiler;
|
|
using SharpDX.Direct3D11;
|
|
using SharpDX.DXGI;
|
|
using SharpDX.Mathematics.Interop;
|
|
using T3.Core.Operator.Slots;
|
|
using T3.Core.Rendering;
|
|
using T3.Core.Resource;
|
|
using T3.Core.SystemUi;
|
|
using T3.Editor.App;
|
|
using T3.Editor.Gui;
|
|
using T3.Editor.Gui.UiHelpers;
|
|
using T3.Editor.Gui.Windows;
|
|
using T3.Editor.Gui.Windows.Analyze;
|
|
using T3.Editor.SystemUi;
|
|
using T3.SystemUi;
|
|
using Buffer = SharpDX.Direct3D11.Buffer;
|
|
using Device = SharpDX.Direct3D11.Device;
|
|
using Vector2 = System.Numerics.Vector2;
|
|
|
|
namespace T3.Editor.UiContentDrawing;
|
|
|
|
/// <summary>
|
|
/// Renders draw data generated by ImGui with SharpDX render form
|
|
/// </summary>
|
|
internal sealed class WindowsUiContentDrawer : IUiContentDrawer<Device>
|
|
{
|
|
private IntPtr _imguiContext;
|
|
private object _contextLock;
|
|
private readonly ShaderResourceView _customImageView = new ShaderResourceView(IntPtr.Zero);
|
|
|
|
#region Init
|
|
public void Initialize(Device device, int width, int height, object contextLock, out IntPtr imguiContext)
|
|
{
|
|
if (device == null)
|
|
{
|
|
Log.Error("Can't initialize window without device.");
|
|
BlockingWindow.Instance.ShowMessageBox("Can't initialize rendering device.", "Graphics error");
|
|
EditorUi.Instance.ExitApplication();
|
|
imguiContext = IntPtr.Zero;
|
|
return;
|
|
}
|
|
|
|
_device = device;
|
|
_deviceContext = device.ImmediateContext;
|
|
_windowWidth = width;
|
|
_windowHeight = height;
|
|
_contextLock = contextLock;
|
|
|
|
lock (_contextLock)
|
|
{
|
|
IntPtr previousContext;
|
|
|
|
try
|
|
{
|
|
previousContext = ImGui.GetCurrentContext();
|
|
}
|
|
catch
|
|
{
|
|
// ignored
|
|
previousContext = IntPtr.Zero;
|
|
}
|
|
|
|
_imguiContext = ImGui.CreateContext();
|
|
ImGui.SetCurrentContext(_imguiContext);
|
|
|
|
SetPerFrameImGuiData(1f / 60f);
|
|
|
|
var io = ImGui.GetIO();
|
|
io.BackendFlags |= ImGuiBackendFlags.HasMouseCursors
|
|
| ImGuiBackendFlags.RendererHasVtxOffset;
|
|
io.ConfigFlags |= ImGuiConfigFlags.DockingEnable;
|
|
|
|
// ImGui 1.91 error-recovery: stack imbalances (Push/Pop, Begin/End, etc.)
|
|
// are auto-fixed and logged. Recoverable errors appear as:
|
|
// - Red warning bar in the editor (ConfigErrorRecoveryEnableTooltip)
|
|
// - [imgui-error] lines in Rider's terminal/stderr (ConfigErrorRecoveryEnableDebugLog)
|
|
// Hard asserts (zero-size buttons, invalid flags) are caught by our
|
|
// try/catch(SEHException) around the render loop.
|
|
//
|
|
// TODO: To get recoverable errors into the managed Log.Warning, build a tiny
|
|
// native shim that hooks ImGuiContext.ErrorCallback and forwards messages to
|
|
// a managed delegate via P/Invoke. See imgui.cpp:10611.
|
|
io.ConfigErrorRecovery = true;
|
|
io.ConfigErrorRecoveryEnableDebugLog = true;
|
|
io.ConfigErrorRecoveryEnableTooltip = true;
|
|
io.ConfigErrorRecoveryEnableAssert = false; // default is true; suppress native dialog
|
|
// io.ConfigDebugHighlightIdConflicts = false; // enable this to suppress ID conflict overlay
|
|
|
|
// restore previous context
|
|
if (previousContext != IntPtr.Zero)
|
|
{
|
|
ImGui.SetCurrentContext(previousContext);
|
|
}
|
|
}
|
|
|
|
imguiContext = _imguiContext;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Rendering
|
|
public void RenderCallback()
|
|
{
|
|
// An attempt to prevent System.ObjectDisposedException
|
|
if (Program.IsShuttingDown)
|
|
return;
|
|
|
|
// Frame-pacing wait via DXGI's FrameLatencyWaitableObject. Must run *before* any other
|
|
// per-frame work so the loop is locked to the swap chain's signalled cadence rather than
|
|
// queueing up speculatively. No-op if the waitable wasn't enabled at swap-chain creation.
|
|
ProgramWindows.Main.WaitForFrameLatency();
|
|
|
|
lock (_contextLock)
|
|
{
|
|
ImGui.SetCurrentContext(_imguiContext);
|
|
UiContentUpdate.SetupResourcesAndFontsWithScaling();
|
|
|
|
if (ProgramWindows.Main.IsMinimized && UserSettings.Config.SuspendRenderingWhenHidden)
|
|
{
|
|
Thread.Sleep(100);
|
|
return;
|
|
}
|
|
|
|
UiContentUpdate.TakeMeasurement();
|
|
ImGui.GetIO().DisplaySize = ProgramWindows.Main.Size;
|
|
|
|
ProgramWindows.HandleFullscreenToggle();
|
|
|
|
DirtyFlag.IncrementGlobalTicks();
|
|
T3Metrics.UiRenderingStarted();
|
|
|
|
if (!string.IsNullOrEmpty(Program.NewImGuiLayoutDefinition))
|
|
{
|
|
ImGui.LoadIniSettingsFromMemory(Program.NewImGuiLayoutDefinition);
|
|
Program.NewImGuiLayoutDefinition = string.Empty;
|
|
}
|
|
|
|
ImGui.NewFrame();
|
|
|
|
// Render 2nd view
|
|
ProgramWindows.Viewer.SetVisible(T3Ui.ShowSecondaryRenderWindow);
|
|
|
|
if (T3Ui.ShowSecondaryRenderWindow)
|
|
{
|
|
var viewer = ProgramWindows.Viewer;
|
|
ProgramWindows.Viewer.PrepareRenderingFrame();
|
|
|
|
ProgramWindows.SetVertexShader(SharedResources.FullScreenVertexShaderResource);
|
|
ProgramWindows.SetPixelShader(SharedResources.FullScreenPixelShaderResource);
|
|
|
|
if (UserSettings.Config.MirrorUiOnSecondView)
|
|
{
|
|
ProgramWindows.RebuildUiCopyTextureIfRequired();
|
|
ProgramWindows.CopyUiContentToShareTexture();
|
|
|
|
if (ProgramWindows.UiCopyTextureSrv != null && !ProgramWindows.UiCopyTextureSrv.IsDisposed)
|
|
{
|
|
ProgramWindows.SetRasterizerState(SharedResources.ViewWindowRasterizerState);
|
|
ProgramWindows.SetPixelShaderSRV(ProgramWindows.UiCopyTextureSrv);
|
|
ProgramWindows.DrawTextureToSecondaryRenderOutput();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (viewer.Texture is { IsDisposed: false })
|
|
{
|
|
if (_viewWindowBackgroundSrv == null ||
|
|
_viewWindowBackgroundSrv.Resource.NativePointer != viewer.Texture.NativePointer)
|
|
{
|
|
_viewWindowBackgroundSrv?.Dispose();
|
|
_viewWindowBackgroundSrv = new ShaderResourceView(Program.Device, viewer.Texture);
|
|
}
|
|
|
|
ProgramWindows.SetRasterizerState(SharedResources.ViewWindowRasterizerState);
|
|
ProgramWindows.SetPixelShaderSRV(_viewWindowBackgroundSrv);
|
|
ProgramWindows.DrawTextureToSecondaryRenderOutput();
|
|
}
|
|
else
|
|
{
|
|
Log.Debug($"Null {nameof(ShaderResourceView)} for 2nd render view");
|
|
}
|
|
}
|
|
}
|
|
|
|
ProgramWindows.Main.PrepareRenderingFrame();
|
|
|
|
// Clear the main window buffer for next frame
|
|
try
|
|
{
|
|
T3Ui.ProcessFrame();
|
|
ProgramWindows.RefreshViewport();
|
|
|
|
ImGui.Render();
|
|
ProgramWindows.Main.Form.ApplyRequestedCursor();
|
|
RenderDrawData(ImGui.GetDrawData());
|
|
}
|
|
catch (SEHException e)
|
|
{
|
|
// A native ImGui assertion fired (e.g. SetCursorPos extent check,
|
|
// invalid BeginChild flags, empty-stack pop). Log the full managed
|
|
// stack trace so the call site is visible in the console/log file
|
|
// alongside the [imgui-error] line that ImGui prints to stderr.
|
|
Log.Error($"ImGui native assertion failed (frame skipped):\n{e}");
|
|
|
|
// Try to end the frame so the next NewFrame doesn't assert on
|
|
// "NewFrame called without Render".
|
|
try { ImGui.EndFrame(); } catch { /* best-effort cleanup */ }
|
|
}
|
|
}
|
|
|
|
T3Metrics.UiRenderingCompleted();
|
|
|
|
ProgramWindows.Present(T3Ui.UseVSync, T3Ui.ShowSecondaryRenderWindow);
|
|
}
|
|
|
|
public void InitializeScaling()
|
|
{
|
|
ImGui.GetIO().ConfigFlags |= ImGuiConfigFlags.DpiEnableScaleFonts;
|
|
ImGui.GetIO().ConfigFlags |= ImGuiConfigFlags.DpiEnableScaleViewports;
|
|
|
|
unsafe
|
|
{
|
|
// Disable ImGui ini file settings
|
|
ImGui.GetIO().NativePtr->IniFilename = null;
|
|
}
|
|
}
|
|
|
|
public void RenderDrawData(ImDrawDataPtr drawData)
|
|
{
|
|
lock (_contextLock)
|
|
{
|
|
PrepareData(drawData);
|
|
DrawData(drawData);
|
|
}
|
|
}
|
|
|
|
private void PrepareData(ImDrawDataPtr drawData)
|
|
{
|
|
if (_vb == null || _vertexBufferSize < drawData.TotalVtxCount)
|
|
{
|
|
DisposeObj(ref _vb);
|
|
_vertexBufferSize = drawData.TotalVtxCount + 5000;
|
|
_vb = new Buffer(_device,
|
|
new BufferDescription()
|
|
{
|
|
SizeInBytes = _vertexBufferSize * Unsafe.SizeOf<ImDrawVert>(),
|
|
Usage = ResourceUsage.Dynamic,
|
|
BindFlags = BindFlags.VertexBuffer,
|
|
CpuAccessFlags = CpuAccessFlags.Write
|
|
});
|
|
}
|
|
|
|
if (_ib == null || _indexBufferSize < drawData.TotalIdxCount)
|
|
{
|
|
DisposeObj(ref _ib);
|
|
_indexBufferSize = drawData.TotalIdxCount + 10000;
|
|
_ib = new Buffer(_device,
|
|
new BufferDescription()
|
|
{
|
|
SizeInBytes = _indexBufferSize * Unsafe.SizeOf<ushort>(),
|
|
Usage = ResourceUsage.Dynamic,
|
|
BindFlags = BindFlags.IndexBuffer,
|
|
CpuAccessFlags = CpuAccessFlags.Write
|
|
});
|
|
}
|
|
|
|
// Copy and convert all vertices into a single contiguous buffer
|
|
_deviceContext.MapSubresource(_vb, MapMode.WriteDiscard, SharpDX.Direct3D11.MapFlags.None, out var vbStream);
|
|
_deviceContext.MapSubresource(_ib, MapMode.WriteDiscard, SharpDX.Direct3D11.MapFlags.None, out var ibStream);
|
|
for (int n = 0; n < drawData.CmdListsCount; n++)
|
|
{
|
|
ImDrawListPtr cmdList = drawData.CmdLists[n];
|
|
vbStream.WriteRange(cmdList.VtxBuffer.Data, (uint)(cmdList.VtxBuffer.Size * Unsafe.SizeOf<ImDrawVert>()));
|
|
ibStream.WriteRange(cmdList.IdxBuffer.Data, (uint)(cmdList.IdxBuffer.Size * Unsafe.SizeOf<ushort>()));
|
|
}
|
|
|
|
vbStream.Dispose();
|
|
ibStream.Dispose();
|
|
_deviceContext.UnmapSubresource(_vb, 0);
|
|
_deviceContext.UnmapSubresource(_ib, 0);
|
|
}
|
|
|
|
private readonly SharpDX.Mathematics.Interop.RawRectangle[] _prevScissorRects = new SharpDX.Mathematics.Interop.RawRectangle[16];
|
|
|
|
//Note : mrvux : unless you use multi viewport, you can set to 1, I leave 16 for safety here since it's only called once per frame, better than accumulating GC
|
|
private readonly SharpDX.Mathematics.Interop.RawViewportF[] _prevViewports = new SharpDX.Mathematics.Interop.RawViewportF[16];
|
|
|
|
private void DrawData(ImDrawDataPtr drawData)
|
|
{
|
|
// Setup orthographic projection matrix into our constant buffer
|
|
// Our visible imgui space lies from draw_data->DisplayPos (top left) to draw_data->DisplayPos+data_data->DisplaySize (bottom right).
|
|
var imGuiIO = ImGui.GetIO();
|
|
var projectionMatrix = Matrix4x4.CreateOrthographicOffCenter(0.0f, imGuiIO.DisplaySize.X, imGuiIO.DisplaySize.Y, 0.0f, -1.0f, 1.0f);
|
|
|
|
ResourceUtils.WriteDynamicBufferData<Matrix4x4>(_deviceContext, _vertexConstantBuffer, projectionMatrix);
|
|
|
|
// Backup DX state that will be modified to restore it afterwards (unfortunately this is very ugly looking and verbose. Close your eyes!)
|
|
_deviceContext.Rasterizer.GetScissorRectangles(_prevScissorRects);
|
|
_deviceContext.Rasterizer.GetViewports(_prevViewports);
|
|
var prevRasterizerState = _deviceContext.Rasterizer.State;
|
|
var prevBlendState = _deviceContext.OutputMerger.BlendState;
|
|
var prevBlendFactor = _deviceContext.OutputMerger.BlendFactor;
|
|
var prevSampleMask = _deviceContext.OutputMerger.BlendSampleMask;
|
|
var prevDepthStencilState = _deviceContext.OutputMerger.DepthStencilState;
|
|
var prevStencilRef = _deviceContext.OutputMerger.DepthStencilReference;
|
|
var prevPsShaderResource = _deviceContext.PixelShader.GetShaderResources(0, 1)[0];
|
|
var prevPsSampler = _deviceContext.PixelShader.GetSamplers(0, 1);
|
|
var prevPs = _deviceContext.PixelShader.Get();
|
|
var prevVs = _deviceContext.VertexShader.Get();
|
|
var prevHs = _deviceContext.HullShader.Get();
|
|
var prevGs = _deviceContext.GeometryShader.Get();
|
|
var prevDs = _deviceContext.DomainShader.Get();
|
|
var prevVsConstantBuffer = _deviceContext.VertexShader.GetConstantBuffers(0, 1);
|
|
var prevPrimitiveTopology = _deviceContext.InputAssembler.PrimitiveTopology;
|
|
|
|
_deviceContext.InputAssembler.GetIndexBuffer(out var prevIndexBuffer, out var prevIndexBufferFormat, out var prevIndexBufferOffset);
|
|
Buffer[] prevVertexBuffer = new Buffer[1];
|
|
int[] prevVertexBufferOffset = new int[1], prevVertexBufferStride = new int[1];
|
|
_deviceContext.InputAssembler.GetVertexBuffers(0, 1, prevVertexBuffer, prevVertexBufferOffset, prevVertexBufferStride);
|
|
var prevInputLayout = _deviceContext.InputAssembler.InputLayout;
|
|
|
|
// Setup viewport
|
|
_deviceContext.Rasterizer.SetViewport(0, 0, drawData.DisplaySize.X, drawData.DisplaySize.Y);
|
|
|
|
// Bind shader and vertex buffers
|
|
int stride = Unsafe.SizeOf<ImDrawVert>();
|
|
int offset = 0;
|
|
_deviceContext.InputAssembler.InputLayout = _inputLayout;
|
|
_deviceContext.InputAssembler.SetVertexBuffers(0, new VertexBufferBinding(_vb, stride, offset));
|
|
_deviceContext.InputAssembler.SetIndexBuffer(_ib, Format.R16_UInt, 0);
|
|
_deviceContext.InputAssembler.PrimitiveTopology = SharpDX.Direct3D.PrimitiveTopology.TriangleList;
|
|
_deviceContext.VertexShader.SetShader(_vertexShader, null, 0);
|
|
_deviceContext.VertexShader.SetConstantBuffer(0, _vertexConstantBuffer);
|
|
_deviceContext.PixelShader.SetShader(_pixelShader, null, 0);
|
|
_deviceContext.PixelShader.SetSampler(0, _fontSampler);
|
|
|
|
//make sure we have no tessel/gs
|
|
_deviceContext.HullShader.Set(null);
|
|
_deviceContext.DomainShader.Set(null);
|
|
_deviceContext.GeometryShader.Set(null);
|
|
|
|
// Setup render state
|
|
// Note : mrvux do not use properties for blend state / blend, since the native functions are packed with the
|
|
_deviceContext.OutputMerger.SetBlendState(_blendState, new RawColor4(0.0f, 0.0f, 0.0f, 0.0f)); //sample mask to -1, no GC
|
|
_deviceContext.OutputMerger.SetDepthStencilState(_depthStencilState, 0);
|
|
_deviceContext.Rasterizer.State = _rasterizerState;
|
|
|
|
// Render command lists
|
|
int vtxOffset = 0;
|
|
int idxOffset = 0;
|
|
Vector2 pos = drawData.DisplayPos;
|
|
for (int n = 0; n < drawData.CmdListsCount; n++)
|
|
{
|
|
var cmdList = drawData.CmdLists[n];
|
|
for (int cmdI = 0; cmdI < cmdList.CmdBuffer.Size; cmdI++)
|
|
{
|
|
var cmd = cmdList.CmdBuffer[cmdI];
|
|
if (cmd.UserCallback != IntPtr.Zero)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
else
|
|
{
|
|
_deviceContext.Rasterizer.SetScissorRectangle((int)(cmd.ClipRect.X - pos.X), (int)(cmd.ClipRect.Y - pos.Y),
|
|
(int)(cmd.ClipRect.Z - pos.X), (int)(cmd.ClipRect.W - pos.Y));
|
|
|
|
//This set native pointer without using QueryInterface or new, which allows a "GC free" cast
|
|
|
|
_customImageView.NativePointer = cmd.TextureId;
|
|
_deviceContext.PixelShader.SetShaderResource(0, _customImageView);
|
|
_deviceContext.DrawIndexed((int)cmd.ElemCount,
|
|
idxOffset + (int)cmd.IdxOffset,
|
|
vtxOffset + (int)cmd.VtxOffset);
|
|
|
|
//Set to IntPtr.Zero since that would create issue when disposing (on application Exit)
|
|
//Internally it only resets the pointer and deref the device if it was queried (which in this case, did not)
|
|
_customImageView.NativePointer = IntPtr.Zero;
|
|
}
|
|
}
|
|
|
|
idxOffset += cmdList.IdxBuffer.Size;
|
|
vtxOffset += cmdList.VtxBuffer.Size;
|
|
}
|
|
|
|
// Restore modified DX state
|
|
_deviceContext.Rasterizer.SetScissorRectangles(_prevScissorRects);
|
|
_deviceContext.Rasterizer.SetViewports(_prevViewports);
|
|
_deviceContext.Rasterizer.State = prevRasterizerState;
|
|
_deviceContext.OutputMerger.BlendState = prevBlendState;
|
|
_deviceContext.OutputMerger.BlendFactor = prevBlendFactor;
|
|
_deviceContext.OutputMerger.BlendSampleMask = prevSampleMask;
|
|
_deviceContext.OutputMerger.DepthStencilState = prevDepthStencilState;
|
|
_deviceContext.OutputMerger.DepthStencilReference = prevStencilRef;
|
|
_deviceContext.PixelShader.SetShaderResources(0, prevPsShaderResource);
|
|
_deviceContext.PixelShader.SetSamplers(0, prevPsSampler);
|
|
_deviceContext.PixelShader.Set(prevPs);
|
|
_deviceContext.VertexShader.Set(prevVs);
|
|
_deviceContext.DomainShader.Set(prevDs);
|
|
_deviceContext.HullShader.Set(prevHs);
|
|
_deviceContext.GeometryShader.Set(prevGs);
|
|
_deviceContext.VertexShader.SetConstantBuffers(0, prevVsConstantBuffer);
|
|
_deviceContext.InputAssembler.PrimitiveTopology = prevPrimitiveTopology;
|
|
_deviceContext.InputAssembler.SetIndexBuffer(prevIndexBuffer, prevIndexBufferFormat, prevIndexBufferOffset);
|
|
_deviceContext.InputAssembler.SetVertexBuffers(0, prevVertexBuffer, prevVertexBufferOffset, prevVertexBufferStride);
|
|
_deviceContext.InputAssembler.InputLayout = prevInputLayout;
|
|
}
|
|
|
|
private void SetPerFrameImGuiData(float deltaSeconds)
|
|
{
|
|
ImGuiIOPtr io = ImGui.GetIO();
|
|
io.DisplaySize = new Vector2(_windowWidth / _scaleFactor.X, _windowHeight / _scaleFactor.Y);
|
|
io.DisplayFramebufferScale = _scaleFactor;
|
|
io.DeltaTime = deltaSeconds; // DeltaTime is in seconds.
|
|
}
|
|
#endregion
|
|
|
|
private bool _initialized;
|
|
|
|
#region setup
|
|
[SuppressMessage("ReSharper", "RedundantArgumentDefaultValue")]
|
|
public bool CreateDeviceObjectsAndFonts()
|
|
{
|
|
if (_device == null)
|
|
return false;
|
|
|
|
if (!_initialized)
|
|
{
|
|
if (!CreateShaders())
|
|
return false;
|
|
|
|
_initialized = true;
|
|
}
|
|
|
|
lock (_contextLock)
|
|
{
|
|
FontAtlasGenerator.CreateFontAtlasWithIcons(_device, _imguiContext, out _fontTextureView, out _fontSampler);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
private bool CreateShaders()
|
|
{
|
|
if (_fontSampler == null)
|
|
DisposeDeviceObjects();
|
|
|
|
// Create the vertex shader
|
|
string vertexShader =
|
|
@"cbuffer vertexBuffer : register(b0)
|
|
{
|
|
float4x4 ProjectionMatrix;
|
|
};
|
|
struct VS_INPUT
|
|
{
|
|
float2 pos : POSITION;
|
|
float4 col : COLOR0;
|
|
float2 uv : TEXCOORD0;
|
|
};
|
|
|
|
struct PS_INPUT
|
|
{
|
|
float4 pos : SV_POSITION;
|
|
float4 col : COLOR0;
|
|
float2 uv : TEXCOORD0;
|
|
};
|
|
|
|
PS_INPUT main(VS_INPUT input)
|
|
{
|
|
PS_INPUT output;
|
|
output.pos = mul( ProjectionMatrix, float4(input.pos.xy, 0.f, 1.f));
|
|
output.col = input.col;
|
|
output.uv = input.uv;
|
|
return output;
|
|
}";
|
|
|
|
_vertexShaderBlob = ShaderBytecode.Compile(vertexShader, "main", "vs_4_0", ShaderFlags.None, EffectFlags.None);
|
|
if (_vertexShaderBlob == null)
|
|
return false;
|
|
|
|
_vertexShader = new VertexShader(_device, _vertexShaderBlob);
|
|
if (_vertexShader == null)
|
|
return false;
|
|
|
|
// Create the input layout
|
|
_inputLayout = new InputLayout(_device, ShaderSignature.GetInputSignature(_vertexShaderBlob),
|
|
new[]
|
|
{
|
|
new InputElement("POSITION", 0, Format.R32G32_Float, 0, 0),
|
|
new InputElement("TEXCOORD", 0, Format.R32G32_Float, 8, 0),
|
|
new InputElement("COLOR", 0, Format.R8G8B8A8_UNorm, 16, 0)
|
|
});
|
|
|
|
// Create the constant buffer
|
|
_vertexConstantBuffer = ResourceUtils.CreateDynamicConstantBuffer(_device, Unsafe.SizeOf<Matrix4x4>());
|
|
|
|
// Create the pixel shader
|
|
string pixelShader =
|
|
@"struct PS_INPUT
|
|
{
|
|
float4 pos : SV_POSITION;
|
|
float4 col : COLOR0;
|
|
float2 uv : TEXCOORD0;
|
|
};
|
|
sampler sampler0;
|
|
Texture2D texture0;
|
|
|
|
float4 main(PS_INPUT input) : SV_Target
|
|
{
|
|
float4 out_col = input.col * texture0.Sample(sampler0, input.uv);
|
|
return out_col;
|
|
}";
|
|
|
|
_pixelShaderBlob = ShaderBytecode.Compile(pixelShader, "main", "ps_4_0", ShaderFlags.None, EffectFlags.None);
|
|
if (_pixelShaderBlob == null)
|
|
return false;
|
|
|
|
_pixelShader = new PixelShader(_device, _pixelShaderBlob);
|
|
if (_pixelShader == null)
|
|
return false;
|
|
|
|
// Create the blending setup
|
|
var blendDesc = new BlendStateDescription() { AlphaToCoverageEnable = false, IndependentBlendEnable = false };
|
|
blendDesc.RenderTarget[0].IsBlendEnabled = true;
|
|
blendDesc.RenderTarget[0].SourceBlend = BlendOption.SourceAlpha;
|
|
blendDesc.RenderTarget[0].DestinationBlend = BlendOption.InverseSourceAlpha;
|
|
blendDesc.RenderTarget[0].BlendOperation = BlendOperation.Add;
|
|
blendDesc.RenderTarget[0].SourceAlphaBlend = BlendOption.InverseSourceAlpha;
|
|
blendDesc.RenderTarget[0].DestinationAlphaBlend = BlendOption.Zero;
|
|
blendDesc.RenderTarget[0].AlphaBlendOperation = BlendOperation.Add;
|
|
blendDesc.RenderTarget[0].RenderTargetWriteMask = ColorWriteMaskFlags.All;
|
|
_blendState = new BlendState(_device, blendDesc);
|
|
|
|
// Create the rasterizer state
|
|
var rasterizerDesc = new RasterizerStateDescription()
|
|
{
|
|
FillMode = FillMode.Solid,
|
|
CullMode = CullMode.None,
|
|
IsScissorEnabled = true,
|
|
IsDepthClipEnabled = true
|
|
};
|
|
_rasterizerState = new RasterizerState(_device, rasterizerDesc);
|
|
|
|
// Create depth-stencil State
|
|
var depthStencilDesc = new DepthStencilStateDescription()
|
|
{
|
|
IsDepthEnabled = false,
|
|
DepthWriteMask = DepthWriteMask.All,
|
|
DepthComparison = Comparison.Always,
|
|
IsStencilEnabled = false
|
|
};
|
|
depthStencilDesc.FrontFace.FailOperation =
|
|
depthStencilDesc.FrontFace.DepthFailOperation = depthStencilDesc.FrontFace.PassOperation = StencilOperation.Keep;
|
|
|
|
depthStencilDesc.BackFace = depthStencilDesc.FrontFace;
|
|
_depthStencilState = new DepthStencilState(_device, depthStencilDesc);
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
public void Dispose()
|
|
{
|
|
DisposeDeviceObjects();
|
|
}
|
|
|
|
private void DisposeObj<T>(ref T obj) where T : class, IDisposable
|
|
{
|
|
obj?.Dispose();
|
|
obj = null;
|
|
}
|
|
|
|
private void DisposeDeviceObjects()
|
|
{
|
|
if (_device == null)
|
|
return;
|
|
|
|
try
|
|
{
|
|
// Sadly a resource leak causes this to trigger memory exceptions.
|
|
// So disabled for now
|
|
|
|
DisposeObj(ref _fontSampler);
|
|
DisposeObj(ref _fontTextureView);
|
|
DisposeObj(ref _ib);
|
|
DisposeObj(ref _vb);
|
|
DisposeObj(ref _blendState);
|
|
DisposeObj(ref _depthStencilState);
|
|
DisposeObj(ref _rasterizerState);
|
|
DisposeObj(ref _pixelShader);
|
|
DisposeObj(ref _pixelShaderBlob);
|
|
DisposeObj(ref _vertexConstantBuffer);
|
|
DisposeObj(ref _inputLayout);
|
|
DisposeObj(ref _vertexShader);
|
|
DisposeObj(ref _vertexShaderBlob);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Log.Warning($"Failed to dispose resources :{e.Message}");
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
private Device _device;
|
|
private DeviceContext _deviceContext;
|
|
private Buffer _vb;
|
|
private Buffer _ib;
|
|
private ShaderBytecode _vertexShaderBlob;
|
|
private VertexShader _vertexShader;
|
|
private InputLayout _inputLayout;
|
|
private Buffer _vertexConstantBuffer;
|
|
private ShaderBytecode _pixelShaderBlob;
|
|
private PixelShader _pixelShader;
|
|
private SamplerState _fontSampler;
|
|
private ShaderResourceView _fontTextureView;
|
|
private RasterizerState _rasterizerState;
|
|
private BlendState _blendState;
|
|
private DepthStencilState _depthStencilState;
|
|
private int _vertexBufferSize = 5000, _indexBufferSize = 1000;
|
|
|
|
private int _windowWidth;
|
|
private int _windowHeight;
|
|
private static ShaderResourceView _viewWindowBackgroundSrv;
|
|
|
|
private readonly Vector2 _scaleFactor = Vector2.One;
|
|
} |