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

Actual working viewports :)

Browse Source
This commit is contained in:
NepuShiro
2026-05-18 10:43:19 -05:00
parent fc0b04a4bc
commit 7167d98cb6
5 changed files with 234 additions and 268 deletions
Download Patch File Download Diff File Expand all files Collapse all files
SDL3/ImGuiSDL3Renderer.cs
+77 -155
View File
@@ -11,11 +11,7 @@ namespace SDL3_TestingSuite.SDL3;
/// </summary>
public unsafe static class ImGuiSDL3Renderer
{
private sealed class TextureState
{
public ImTextureDataPtr Source;
public readonly Dictionary<nint, nint> RendererTextures = new();
}
public static SDL3Window Parent;
public class RendererData
{
@@ -44,11 +40,6 @@ public unsafe static class ImGuiSDL3Renderer
private static readonly RendererDestroyWindowFn RendererDestroyWindowDelegate = RendererDestroyWindow;
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
private delegate void RendererSetWindowSizeFn(ImGuiViewportPtr viewport, Vector2 size);
private static readonly RendererSetWindowSizeFn RendererSetWindowSizeDelegate = RendererSetWindowSize;
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
private delegate void RendererRenderWindowFn(ImGuiViewportPtr viewport);
@@ -61,8 +52,9 @@ public unsafe static class ImGuiSDL3Renderer
public static RendererData Data => ImGui.GetCurrentContext().Handle != null ? ImGuiUserData<RendererData>.Get(ImGui.GetIO().BackendRendererUserData)! : null!;
public static bool Init(nint renderer)
public static bool Init(nint renderer, SDL3Window parentWindow = null)
{
Parent = parentWindow;
ImGuiIOPtr io = ImGui.GetIO();
RendererData bd = new RendererData();
@@ -77,7 +69,6 @@ public unsafe static class ImGuiSDL3Renderer
ImGuiPlatformIOPtr platformIO = ImGui.GetPlatformIO();
platformIO.RendererCreateWindow = (void*)Marshal.GetFunctionPointerForDelegate(RendererCreateWindowDelegate);
platformIO.RendererDestroyWindow = (void*)Marshal.GetFunctionPointerForDelegate(RendererDestroyWindowDelegate);
platformIO.RendererSetWindowSize = (void*)Marshal.GetFunctionPointerForDelegate(RendererSetWindowSizeDelegate);
platformIO.RendererRenderWindow = (void*)Marshal.GetFunctionPointerForDelegate(RendererRenderWindowDelegate);
platformIO.RendererSwapBuffers = (void*)Marshal.GetFunctionPointerForDelegate(RendererSwapBuffersDelegate);
@@ -108,22 +99,19 @@ public unsafe static class ImGuiSDL3Renderer
private static void RendererCreateWindow(ImGuiViewportPtr viewport)
{
Program.Logger.Log(null);
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, (string?)null);
vd.Renderer = SDL.CreateRenderer(vd.Window, null);
vd.RendererOwned = true;
}
Program.Logger.Log(null);
}
private static void RendererDestroyWindow(ImGuiViewportPtr viewport)
{
Program.Logger.Log(null);
ImGuiSDL3Platform.ViewPortData? vd = ImGuiUserData<ImGuiSDL3Platform.ViewPortData>.Get(viewport.PlatformUserData);
if (vd == null)
return;
@@ -135,37 +123,32 @@ public unsafe static class ImGuiSDL3Renderer
vd.Renderer = nint.Zero;
vd.RendererOwned = false;
Program.Logger.Log(null);
}
private static void RendererSetWindowSize(ImGuiViewportPtr viewport, Vector2 size)
{
// SDL renderer windows track size through the platform window callback.
Program.Logger.Log(null);
}
private static void RendererRenderWindow(ImGuiViewportPtr viewport)
{
Program.Logger.Log(null);
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);
Program.Logger.Log(null);
}
private static void RendererSwapBuffers(ImGuiViewportPtr viewport)
{
Program.Logger.Log(null);
ImGuiSDL3Platform.ViewPortData? vd = ImGuiUserData<ImGuiSDL3Platform.ViewPortData>.Get(viewport.PlatformUserData);
if (vd == null || vd.Renderer == nint.Zero)
return;
SDL.RenderPresent(vd.Renderer);
Program.Logger.Log(null);
}
public static void RenderDrawData(ImDrawDataPtr drawData, nint renderer)
@@ -175,9 +158,7 @@ public unsafe static class ImGuiSDL3Renderer
return;
SDL.GetRenderScale(renderer, out float renderScaleX, out float renderScaleY);
Vector2 renderScale = new Vector2(
renderScaleX == 1.0f ? drawData.FramebufferScale.X : 1.0f,
renderScaleY == 1.0f ? drawData.FramebufferScale.Y : 1.0f);
Vector2 renderScale = new Vector2(renderScaleX == 1.0f ? drawData.FramebufferScale.X : 1.0f, renderScaleY == 1.0f ? drawData.FramebufferScale.Y : 1.0f);
int fbWidth = (int)(drawData.DisplaySize.X * renderScale.X);
int fbHeight = (int)(drawData.DisplaySize.Y * renderScale.Y);
@@ -196,13 +177,11 @@ public unsafe static class ImGuiSDL3Renderer
ViewportEnabled = SDL.RenderViewportSet(renderer),
ClipEnabled = SDL.RenderClipEnabled(renderer)
};
SDL.GetRenderViewport(renderer, out var oldViewport);
old.Viewport = oldViewport;
SDL.GetRenderClipRect(renderer, out var oldClipRect);
old.ClipRect = oldClipRect;
SDL.GetRenderViewport(renderer, out old.Viewport);
SDL.GetRenderClipRect(renderer, out old.ClipRect);
// Set up render state
SDL.SetRenderViewport(renderer, 0);
SDL.SetRenderViewport(renderer, nint.Zero);
SDL.SetRenderClipRect(renderer, nint.Zero);
// Set render state in platform IO
@@ -224,37 +203,35 @@ public unsafe static class ImGuiSDL3Renderer
{
continue; // User callback not implemented
}
else
// 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
{
// 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);
X = (int)clipMin.X,
Y = (int)clipMin.Y,
W = (int)(clipMax.X - clipMin.X),
H = (int)(clipMax.Y - clipMin.Y)
};
SDL.SetRenderClipRect(renderer, r);
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;
// Get texture
nint texId = cmd.GetTexID();
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);
// Get texture
nint texId = ResolveTextureId(cmd.GetTexID(), renderer);
// Convert ImGui vertices to SDL vertices
if (!RenderDrawCommand(cmdList, cmd, renderer, texId, renderScale))
{
Console.WriteLine($"Failed to render ImGui draw command: {SDL.GetError()}");
}
// Convert ImGui vertices to SDL vertices
if (!RenderDrawCommand(cmdList, cmd, renderer, texId, renderScale, clipOffset))
{
Console.WriteLine($"Failed to render ImGui draw command: {SDL.GetError()}");
}
}
}
@@ -267,108 +244,53 @@ public unsafe static class ImGuiSDL3Renderer
SDL.SetRenderClipRect(renderer, old.ClipEnabled ? old.ClipRect : new SDL.Rect());
}
private static nint ResolveTextureId(ImTextureID texId, nint renderer)
{
if (texId == ImTextureID.Null)
return nint.Zero;
TextureState? state = ImGuiUserData<TextureState>.Get((void*)(nint)texId);
if (state == null)
return (nint)texId;
if (!state.RendererTextures.TryGetValue(renderer, out nint rendererTexture) || rendererTexture == nint.Zero)
{
rendererTexture = CreateRendererTexture(state, renderer);
state.RendererTextures[renderer] = rendererTexture;
}
return rendererTexture;
}
private static nint CreateRendererTexture(TextureState state, nint renderer)
{
ImTextureDataPtr tex = state.Source;
// We keep ARGB8888 here because this project already relies on that upload path.
nint sdlTexture = SDL.CreateTexture(renderer, SDL.PixelFormat.ARGB8888, SDL.TextureAccess.Static, tex.Width, tex.Height);
if (sdlTexture == nint.Zero)
return nint.Zero;
SDL.UpdateTexture(sdlTexture, nint.Zero, (nint)tex.GetPixels(), tex.GetPitch());
SDL.SetTextureBlendMode(sdlTexture, SDL.BlendMode.Blend);
SDL.SetTextureScaleMode(sdlTexture, SDL.ScaleMode.Linear);
return sdlTexture;
}
private static void UploadRendererTexture(ImTextureDataPtr tex, nint renderer, nint sdlTexture)
{
if (tex.Status == ImTextureStatus.WantUpdates)
{
for (int i = 0; i < tex.Updates.Size; i++)
{
var r = tex.Updates[i];
SDL.Rect rect = new SDL.Rect
{
X = r.X,
Y = r.Y,
W = r.W,
H = r.H
};
SDL.UpdateTexture(sdlTexture, rect, (nint)tex.GetPixelsAt(r.X, r.Y), tex.GetPitch());
}
}
else
{
SDL.UpdateTexture(sdlTexture, nint.Zero, (nint)tex.GetPixels(), tex.GetPitch());
}
}
private static void UpdateTexture(ImTextureDataPtr tex, nint renderer)
{
TextureState? state = null;
if ((nint)tex.BackendUserData != nint.Zero)
state = ImGuiUserData<TextureState>.Get(tex.BackendUserData);
if (state == null)
{
state = new TextureState();
tex.BackendUserData = ImGuiUserData<TextureState>.Store(state);
}
state.Source = tex;
tex.SetTexID((nint)tex.BackendUserData);
if (tex.Status == ImTextureStatus.WantDestroy)
{
foreach (nint rendererTexture in state.RendererTextures.Values)
{
if (rendererTexture != nint.Zero)
SDL.DestroyTexture(rendererTexture);
}
if (tex.TexID != ImTextureID.Null)
SDL.DestroyTexture(tex.TexID);
state.RendererTextures.Clear();
ImGuiUserData<TextureState>.Free(tex.BackendUserData);
tex.BackendUserData = (void*)nint.Zero;
tex.SetTexID(ImTextureID.Null);
tex.SetStatus(ImTextureStatus.Destroyed);
return;
}
bool hasRendererTexture = state.RendererTextures.TryGetValue(renderer, out nint sdlTexture) && sdlTexture != nint.Zero;
if (!hasRendererTexture)
bool needsCreate = tex.TexID == ImTextureID.Null || SDL.GetRendererFromTexture(tex.TexID) != renderer;
if (tex.Status == ImTextureStatus.WantCreate || needsCreate)
{
sdlTexture = CreateRendererTexture(state, renderer);
state.RendererTextures[renderer] = sdlTexture;
if (tex.TexID != ImTextureID.Null)
SDL.DestroyTexture(tex.TexID);
// Create texture on the renderer that is actually drawing this viewport.
// SDL textures are renderer-owned and cannot be shared across renderer instances.
nint sdlTexture = SDL.CreateTexture(renderer, SDL.PixelFormat.ABGR8888, SDL.TextureAccess.Static, tex.Width, tex.Height);
SDL.UpdateTexture(sdlTexture, nint.Zero, (nint)tex.GetPixels(), tex.GetPitch());
SDL.SetTextureBlendMode(sdlTexture, SDL.BlendMode.Blend);
SDL.SetTextureScaleMode(sdlTexture, SDL.ScaleMode.Linear);
tex.SetTexID(sdlTexture);
tex.SetStatus(ImTextureStatus.Ok);
return;
}
if (sdlTexture != nint.Zero && (tex.Status == ImTextureStatus.WantCreate || tex.Status == ImTextureStatus.WantUpdates || !hasRendererTexture))
if (tex.Status == ImTextureStatus.WantUpdates)
{
UploadRendererTexture(tex, renderer, sdlTexture);
// Update selected blocks. We only ever write to textures regions which have never been used before!
// This backend choose to use tex.Updates[] but you can use tex.UpdateRect to upload a single region.
nint sdlTexture = tex.TexID;
for (int i = 0; i < tex.Updates.Size; i++)
{
var 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());
}
tex.SetStatus(ImTextureStatus.Ok);
}
}
private static bool RenderDrawCommand(ImDrawListPtr drawList, ImDrawCmd cmd, nint renderer, nint texId, Vector2 scale)
private static bool RenderDrawCommand(ImDrawListPtr drawList, ImDrawCmd cmd, nint renderer, nint texId, Vector2 scale, Vector2 displayPos)
{
uint indexOffset = cmd.IdxOffset;
uint vertexOffset = cmd.VtxOffset;
@@ -391,21 +313,21 @@ public unsafe static class ImGuiSDL3Renderer
byte b = (byte)((col >> 16) & 0xFF);
byte a = (byte)((col >> 24) & 0xFF);
vertices[i] = new SDL.Vertex()
vertices[i] = new SDL.Vertex
{
Position = new SDL.FPoint()
Position = new SDL.FPoint
{
X = srcVert.Pos.X * scale.X,
Y = srcVert.Pos.Y * scale.Y
X = (srcVert.Pos.X - displayPos.X) * scale.X,
Y = (srcVert.Pos.Y - displayPos.Y) * scale.Y
},
Color = new SDL.FColor()
Color = new SDL.FColor
{
R = r / 255f,
G = g / 255f,
B = b / 255f,
A = a / 255f
},
TexCoord = new SDL.FPoint()
TexCoord = new SDL.FPoint
{
X = srcVert.Uv.X,
Y = srcVert.Uv.Y
@@ -427,7 +349,7 @@ public unsafe static class ImGuiSDL3Renderer
{
var texture = texures[i];
texture.Status = ImTextureStatus.WantDestroy;
UpdateTexture(texture, nint.Zero);
UpdateTexture(texture, Data.Renderer);
}
}
}
}