NepuShiro/SDL3-TestingSuite
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

some cleanup

Browse Source
This commit is contained in:
NepuShiro
2026-05-18 23:19:40 -05:00
parent 7167d98cb6
commit 221cfa5e9c
7 changed files with 765 additions and 764 deletions
Download Patch File Download Diff File Expand all files Collapse all files
SDL3/ImGuiSDL3Renderer.cs
+200 -178
View File
@@ -1,4 +1,6 @@
using System.Diagnostics;
using System.Numerics;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using Hexa.NET.ImGui;
using SDL3;
@@ -11,8 +13,6 @@ namespace SDL3_TestingSuite.SDL3;
/// </summary>
public unsafe static class ImGuiSDL3Renderer
{
public static SDL3Window Parent;
public class RendererData
{
public nint Renderer; // Main viewport's renderer
@@ -25,34 +25,15 @@ public unsafe static class ImGuiSDL3Renderer
private struct BackupSDLRendererState
{
public SDL.Rect Viewport;
public bool ViewportEnabled;
public bool ClipEnabled;
public SDL.Rect ClipRect;
}
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
private delegate void RendererCreateWindowFn(ImGuiViewportPtr viewport);
public static RendererData GetRendererData() => ImGui.GetCurrentContext().Handle != null ? ImGuiUserData<RendererData>.Get(ImGui.GetIO().BackendRendererUserData)! : null!;
private static readonly RendererCreateWindowFn RendererCreateWindowDelegate = RendererCreateWindow;
public static SDL3Window? Parent;
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
private delegate void RendererDestroyWindowFn(ImGuiViewportPtr viewport);
private static readonly RendererDestroyWindowFn RendererDestroyWindowDelegate = RendererDestroyWindow;
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
private delegate void RendererRenderWindowFn(ImGuiViewportPtr viewport);
private static readonly RendererRenderWindowFn RendererRenderWindowDelegate = RendererRenderWindow;
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
private delegate void RendererSwapBuffersFn(ImGuiViewportPtr viewport);
private static readonly RendererSwapBuffersFn RendererSwapBuffersDelegate = RendererSwapBuffers;
public static RendererData Data => ImGui.GetCurrentContext().Handle != null ? ImGuiUserData<RendererData>.Get(ImGui.GetIO().BackendRendererUserData)! : null!;
public static bool Init(nint renderer, SDL3Window parentWindow = null)
public static bool Init(nint renderer, SDL3Window? parentWindow = null)
{
Parent = parentWindow;
ImGuiIOPtr io = ImGui.GetIO();
@@ -67,88 +48,45 @@ public unsafe static class ImGuiSDL3Renderer
bd.Renderer = renderer;
ImGuiPlatformIOPtr platformIO = ImGui.GetPlatformIO();
platformIO.RendererCreateWindow = (void*)Marshal.GetFunctionPointerForDelegate(RendererCreateWindowDelegate);
platformIO.RendererDestroyWindow = (void*)Marshal.GetFunctionPointerForDelegate(RendererDestroyWindowDelegate);
platformIO.RendererRenderWindow = (void*)Marshal.GetFunctionPointerForDelegate(RendererRenderWindowDelegate);
platformIO.RendererSwapBuffers = (void*)Marshal.GetFunctionPointerForDelegate(RendererSwapBuffersDelegate);
platformIO.RendererCreateWindow = DelegateStorage.RendererCreateWindowDelegate.GetPtrForDelegate();
platformIO.RendererDestroyWindow = DelegateStorage.RendererDestroyWindowDelegate.GetPtrForDelegate();
platformIO.RendererRenderWindow = DelegateStorage.RendererRenderWindowDelegate.GetPtrForDelegate();
platformIO.RendererSwapBuffers = DelegateStorage.RendererSwapBuffersDelegate.GetPtrForDelegate();
return true;
}
public static void Dispose()
{
var io = ImGui.GetIO();
var platformIO = ImGui.GetPlatformIO();
ImGuiIOPtr io = ImGui.GetIO();
ImGuiPlatformIOPtr platformIO = ImGui.GetPlatformIO();
DestroyDeviceObjects();
if (io.BackendRendererName != null)
{
Marshal.FreeHGlobal((nint)io.BackendRendererName);
}
ImGuiUserData<RendererData>.Free(io.BackendRendererUserData);
io.BackendRendererName = null;
io.BackendRendererUserData = null;
io.BackendFlags &= ~(ImGuiBackendFlags.RendererHasVtxOffset | ImGuiBackendFlags.RendererHasTextures);
io.BackendFlags &= ~(ImGuiBackendFlags.RendererHasVtxOffset | ImGuiBackendFlags.RendererHasTextures | ImGuiBackendFlags.RendererHasViewports);
platformIO.RendererTextureMaxWidth = 0;
platformIO.RendererTextureMaxHeight = 0;
platformIO.RendererRenderState = null;
platformIO.RendererCreateWindow = null;
platformIO.RendererDestroyWindow = null;
platformIO.RendererSetWindowSize = null;
platformIO.RendererRenderWindow = null;
platformIO.RendererSwapBuffers = null;
}
public static void NewFrame() { }
private static void RendererCreateWindow(ImGuiViewportPtr viewport)
public static void SetupRenderState(nint renderer)
{
ImGuiSDL3Platform.ViewPortData? vd = ImGuiUserData<ImGuiSDL3Platform.ViewPortData>.Get(viewport.PlatformUserData);
if (vd == null || vd.Window == nint.Zero)
return;
if (vd.Renderer == nint.Zero)
{
vd.Renderer = SDL.CreateRenderer(vd.Window, null);
vd.RendererOwned = true;
}
// Clear out any viewports and cliprect set by the user
// FIXME: Technically speaking there are lots of other things we could backup/setup/restore during our render process.
SDL.SetRenderViewport(renderer, nint.Zero);
SDL.SetRenderClipRect(renderer, nint.Zero);
}
private static void RendererDestroyWindow(ImGuiViewportPtr viewport)
public static void NewFrame()
{
ImGuiSDL3Platform.ViewPortData? vd = ImGuiUserData<ImGuiSDL3Platform.ViewPortData>.Get(viewport.PlatformUserData);
if (vd == null)
return;
if (vd.RendererOwned && vd.Renderer != nint.Zero)
{
SDL.DestroyRenderer(vd.Renderer);
}
vd.Renderer = nint.Zero;
vd.RendererOwned = false;
}
private static void RendererRenderWindow(ImGuiViewportPtr viewport)
{
ImGuiSDL3Platform.ViewPortData? vd = ImGuiUserData<ImGuiSDL3Platform.ViewPortData>.Get(viewport.PlatformUserData);
if (vd == null || vd.Renderer == nint.Zero)
{
return;
}
if (Parent != null)
{
SDL.SetRenderDrawColorFloat(vd.Renderer, Parent.ClearColor.X, Parent.ClearColor.Y, Parent.ClearColor.Z, 0f);
SDL.RenderClear(vd.Renderer);
}
RenderDrawData(viewport.DrawData, vd.Renderer);
}
private static void RendererSwapBuffers(ImGuiViewportPtr viewport)
{
ImGuiSDL3Platform.ViewPortData? vd = ImGuiUserData<ImGuiSDL3Platform.ViewPortData>.Get(viewport.PlatformUserData);
if (vd == null || vd.Renderer == nint.Zero)
return;
SDL.RenderPresent(vd.Renderer);
RendererData bd = GetRendererData();
Debug.Assert(bd != null, "Context or backend not initialized! Did you call ImGuiSDL3Renderer.Init()?");
}
public static void RenderDrawData(ImDrawDataPtr drawData, nint renderer)
@@ -167,22 +105,23 @@ public unsafe static class ImGuiSDL3Renderer
for (int i = 0; i < drawData.Textures.Size; i++)
{
var texture = drawData.Textures[i];
UpdateTexture(texture, renderer);
ImTextureDataPtr texture = drawData.Textures[i];
if (texture.Handle != null)
{
UpdateTexture(texture, renderer);
}
}
// Backup SDL renderer state
BackupSDLRendererState old = new BackupSDLRendererState
{
ViewportEnabled = SDL.RenderViewportSet(renderer),
ClipEnabled = SDL.RenderClipEnabled(renderer)
};
SDL.GetRenderViewport(renderer, out old.Viewport);
SDL.GetRenderClipRect(renderer, out old.ClipRect);
// Set up render state
SDL.SetRenderViewport(renderer, nint.Zero);
SDL.SetRenderClipRect(renderer, nint.Zero);
SetupRenderState(renderer);
// Set render state in platform IO
ImGuiPlatformIOPtr platformIo = ImGui.GetPlatformIO();
@@ -193,45 +132,103 @@ public unsafe static class ImGuiSDL3Renderer
// Render command lists
for (int n = 0; n < drawData.CmdListsCount; n++)
{
ImDrawListPtr cmdList = drawData.CmdLists[n];
ImDrawListPtr drawList = drawData.CmdLists[n];
for (int cmdIndex = 0; cmdIndex < cmdList.CmdBuffer.Size; cmdIndex++)
for (int cmdIndex = 0; cmdIndex < drawList.CmdBuffer.Size; cmdIndex++)
{
ImDrawCmd cmd = cmdList.CmdBuffer[cmdIndex];
ImDrawCmd cmd = drawList.CmdBuffer[cmdIndex];
if (cmd.UserCallback != null)
{
continue; // User callback not implemented
if (cmd.UserCallback == DelegateStorage.DrawCallbackResetRenderStateDelegate.GetPtrForDelegate())
{
SetupRenderState(renderer);
}
else
{
// this is cursed af and idk if it even works :)
ImDrawCmdPtr cmdPtr = new ImDrawCmdPtr
{
Handle = (ImDrawCmd*)Unsafe.AsPointer(ref cmd)
};
((delegate* unmanaged[Cdecl]<ImDrawListPtr, ImDrawCmdPtr, void>)cmd.UserCallback)(drawList, cmdPtr);
}
}
// Apply clipping rectangle
Vector4 clipRect = cmd.ClipRect;
Vector2 clipMin = new Vector2((clipRect.X - clipOffset.X) * renderScale.X, (clipRect.Y - clipOffset.Y) * renderScale.Y);
Vector2 clipMax = new Vector2((clipRect.Z - clipOffset.X) * renderScale.X, (clipRect.W - clipOffset.Y) * renderScale.Y);
clipMin.X = Math.Max(0, clipMin.X);
clipMin.Y = Math.Max(0, clipMin.Y);
clipMax.X = Math.Min(fbWidth, clipMax.X);
clipMax.Y = Math.Min(fbHeight, clipMax.Y);
if (clipMax.X <= clipMin.X || clipMax.Y <= clipMin.Y)
continue;
SDL.Rect r = new SDL.Rect
else
{
X = (int)clipMin.X,
Y = (int)clipMin.Y,
W = (int)(clipMax.X - clipMin.X),
H = (int)(clipMax.Y - clipMin.Y)
};
SDL.SetRenderClipRect(renderer, r);
// Apply clipping rectangle
Vector4 clipRect = cmd.ClipRect;
Vector2 clipMin = new Vector2((clipRect.X - clipOffset.X) * renderScale.X, (clipRect.Y - clipOffset.Y) * renderScale.Y);
Vector2 clipMax = new Vector2((clipRect.Z - clipOffset.X) * renderScale.X, (clipRect.W - clipOffset.Y) * renderScale.Y);
// Get texture
nint texId = cmd.GetTexID();
clipMin.X = Math.Max(0, clipMin.X);
clipMin.Y = Math.Max(0, clipMin.Y);
clipMax.X = Math.Min(fbWidth, clipMax.X);
clipMax.Y = Math.Min(fbHeight, clipMax.Y);
if (clipMax.X <= clipMin.X || clipMax.Y <= clipMin.Y)
continue;
// Convert ImGui vertices to SDL vertices
if (!RenderDrawCommand(cmdList, cmd, renderer, texId, renderScale, clipOffset))
{
Console.WriteLine($"Failed to render ImGui draw command: {SDL.GetError()}");
SDL.Rect r = new SDL.Rect
{
X = (int)clipMin.X,
Y = (int)clipMin.Y,
W = (int)(clipMax.X - clipMin.X),
H = (int)(clipMax.Y - clipMin.Y)
};
SDL.SetRenderClipRect(renderer, r);
// Convert ImGui vertices to SDL vertices
uint indexOffset = cmd.IdxOffset;
uint vertexOffset = cmd.VtxOffset;
uint elemCount = cmd.ElemCount;
SDL.Vertex[] vertices = new SDL.Vertex[elemCount];
int[] indices = new int[elemCount];
for (int i = 0; i < elemCount; i++)
{
ushort idx = drawList.IdxBuffer[(int)indexOffset + i];
int vertIdx = (int)(vertexOffset + idx);
ImDrawVert srcVert = drawList.VtxBuffer[vertIdx];
uint col = srcVert.Col;
byte colR = (byte)((col >> 0) & 0xFF);
byte colG = (byte)((col >> 8) & 0xFF);
byte colB = (byte)((col >> 16) & 0xFF);
byte colA = (byte)((col >> 24) & 0xFF);
vertices[i] = new SDL.Vertex
{
Position = new SDL.FPoint
{
X = (srcVert.Pos.X - clipOffset.X) * renderScale.X,
Y = (srcVert.Pos.Y - clipOffset.Y) * renderScale.Y
},
Color = new SDL.FColor
{
R = colR / 255f,
G = colG / 255f,
B = colB / 255f,
A = colA / 255f
},
TexCoord = new SDL.FPoint
{
X = srcVert.Uv.X,
Y = srcVert.Uv.Y
}
};
indices[i] = i;
}
// Get texture
ImTextureID texId = cmd.GetTexID();
if (!SDL.RenderGeometry(renderer, texId, vertices, vertices.Length, indices, indices.Length))
{
Program.Logger.Log($"Failed to render ImGui draw command: {SDL.GetError()}");
}
}
}
}
@@ -240,7 +237,7 @@ public unsafe static class ImGuiSDL3Renderer
platformIo.RendererRenderState = null;
// Restore renderer state
SDL.SetRenderViewport(renderer, old.ViewportEnabled ? old.Viewport : new SDL.Rect());
SDL.SetRenderViewport(renderer, old.Viewport);
SDL.SetRenderClipRect(renderer, old.ClipEnabled ? old.ClipRect : new SDL.Rect());
}
@@ -281,7 +278,7 @@ public unsafe static class ImGuiSDL3Renderer
nint sdlTexture = tex.TexID;
for (int i = 0; i < tex.Updates.Size; i++)
{
var r = tex.Updates[i];
ImTextureRect r = tex.Updates[i];
SDL.Rect sdlR = new SDL.Rect { X = r.X, Y = r.Y, W = r.W, H = r.H };
SDL.UpdateTexture(sdlTexture, sdlR, (nint)tex.GetPixelsAt(r.X, r.Y), tex.GetPitch());
}
@@ -289,67 +286,92 @@ public unsafe static class ImGuiSDL3Renderer
}
}
private static bool RenderDrawCommand(ImDrawListPtr drawList, ImDrawCmd cmd, nint renderer, nint texId, Vector2 scale, Vector2 displayPos)
{
uint indexOffset = cmd.IdxOffset;
uint vertexOffset = cmd.VtxOffset;
uint elemCount = cmd.ElemCount;
SDL.Vertex[] vertices = new SDL.Vertex[elemCount];
int[] indices = new int[elemCount];
for (int i = 0; i < elemCount; i++)
{
ushort idx = drawList.IdxBuffer[(int)indexOffset + i];
int vertIdx = (int)(vertexOffset + idx);
ImDrawVert srcVert = drawList.VtxBuffer[vertIdx];
uint col = srcVert.Col;
byte r = (byte)((col >> 0) & 0xFF);
byte g = (byte)((col >> 8) & 0xFF);
byte b = (byte)((col >> 16) & 0xFF);
byte a = (byte)((col >> 24) & 0xFF);
vertices[i] = new SDL.Vertex
{
Position = new SDL.FPoint
{
X = (srcVert.Pos.X - displayPos.X) * scale.X,
Y = (srcVert.Pos.Y - displayPos.Y) * scale.Y
},
Color = new SDL.FColor
{
R = r / 255f,
G = g / 255f,
B = b / 255f,
A = a / 255f
},
TexCoord = new SDL.FPoint
{
X = srcVert.Uv.X,
Y = srcVert.Uv.Y
}
};
indices[i] = i;
}
return SDL.RenderGeometry(renderer, texId, vertices, vertices.Length, indices, indices.Length);
}
public static void CreateDeviceObjects() { }
public static void DestroyDeviceObjects()
{
var texures = ImGui.GetPlatformIO().Textures;
ImVector<ImTextureDataPtr> texures = ImGui.GetPlatformIO().Textures;
for (int i = 0; i < texures.Size; i++)
{
var texture = texures[i];
ImTextureDataPtr texture = texures[i];
texture.Status = ImTextureStatus.WantDestroy;
UpdateTexture(texture, Data.Renderer);
UpdateTexture(texture, GetRendererData().Renderer);
}
}
// @formatter:off — disable formatter after this line
public static class DelegateStorage
{
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
internal delegate void DrawCallbackResetRenderStateFn(ImDrawListPtr drawList, ImDrawCmdPtr cmd);
internal static readonly DrawCallbackResetRenderStateFn DrawCallbackResetRenderStateDelegate = DrawCallbackResetRenderState;
private static void DrawCallbackResetRenderState(ImDrawListPtr drawList, ImDrawCmdPtr cmd) { } // Intentionally empty. Used as an identifier for rendering loop to call its code. Simpler to implement this way.
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
internal delegate void RendererCreateWindowFn(ImGuiViewportPtr viewport);
internal static readonly RendererCreateWindowFn RendererCreateWindowDelegate = RendererCreateWindow;
private static void RendererCreateWindow(ImGuiViewportPtr viewport)
{
ImGuiSDL3Platform.ViewPortData? vd = ImGuiUserData<ImGuiSDL3Platform.ViewPortData>.Get(viewport.PlatformUserData);
if (vd == null || vd.Window == nint.Zero)
return;
if (vd.Renderer == nint.Zero)
{
vd.Renderer = SDL.CreateRenderer(vd.Window, null);
vd.RendererOwned = true;
}
}
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
internal delegate void RendererDestroyWindowFn(ImGuiViewportPtr viewport);
internal static readonly RendererDestroyWindowFn RendererDestroyWindowDelegate = RendererDestroyWindow;
private static void RendererDestroyWindow(ImGuiViewportPtr viewport)
{
ImGuiSDL3Platform.ViewPortData? vd = ImGuiUserData<ImGuiSDL3Platform.ViewPortData>.Get(viewport.PlatformUserData);
if (vd == null)
return;
if (vd.RendererOwned && vd.Renderer != nint.Zero)
{
SDL.DestroyRenderer(vd.Renderer);
}
vd.Renderer = nint.Zero;
vd.RendererOwned = false;
}
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
internal delegate void RendererRenderWindowFn(ImGuiViewportPtr viewport);
internal static readonly RendererRenderWindowFn RendererRenderWindowDelegate = RendererRenderWindow;
private static void RendererRenderWindow(ImGuiViewportPtr viewport)
{
ImGuiSDL3Platform.ViewPortData? vd = ImGuiUserData<ImGuiSDL3Platform.ViewPortData>.Get(viewport.PlatformUserData);
if (vd == null || vd.Renderer == nint.Zero)
{
return;
}
if (Parent != null)
{
SDL.SetRenderDrawColorFloat(vd.Renderer, Parent.ClearColor.X, Parent.ClearColor.Y, Parent.ClearColor.Z, 0f);
SDL.RenderClear(vd.Renderer);
}
RenderDrawData(viewport.DrawData, vd.Renderer);
}
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
internal delegate void RendererSwapBuffersFn(ImGuiViewportPtr viewport);
internal static readonly RendererSwapBuffersFn RendererSwapBuffersDelegate = RendererSwapBuffers;
private static void RendererSwapBuffers(ImGuiViewportPtr viewport)
{
ImGuiSDL3Platform.ViewPortData? vd = ImGuiUserData<ImGuiSDL3Platform.ViewPortData>.Get(viewport.PlatformUserData);
if (vd == null || vd.Renderer == nint.Zero)
return;
SDL.RenderPresent(vd.Renderer);
}
}
// @formatter:on — enable formatter after this line
}