diff --git a/backends/imgui_impl_sdlsurface2.cpp b/backends/imgui_impl_sdlsurface2.cpp new file mode 100644 index 000000000..c6e27a651 --- /dev/null +++ b/backends/imgui_impl_sdlsurface2.cpp @@ -0,0 +1,225 @@ +// imgui_impl_sdlsurface2.cpp +// CPU-only SDL_Surface backend for Dear ImGui + +#include "imgui_impl_sdlsurface2.h" +#include "imgui.h" +#include +#include +#include + +static SDL_Surface* g_TargetSurface = nullptr; +static SDL_Surface* g_FontSurface = nullptr; + +static inline void PutPixel(SDL_Surface* surface, int x, int y, Uint8 r, Uint8 g, Uint8 b, Uint8 a) +{ + if (x < 0 || y < 0 || x >= surface->w || y >= surface->h) return; + Uint32 pixel = SDL_MapRGBA(surface->format, r, g, b, a); + Uint8* pixels = (Uint8*)surface->pixels; + int pitch = surface->pitch; + Uint32* dst = (Uint32*)(pixels + y * pitch + x * 4); + *dst = pixel; +} + +static inline float Edge(const ImVec2& a, const ImVec2& b, float x, float y) +{ + return (b.x - a.x) * (y - a.y) - (b.y - a.y) * (x - a.x); +} + +SDL_Surface* ImGui_ImplSDLSurface2_CreateFontAtlasSurface() +{ + ImGuiIO& io = ImGui::GetIO(); + unsigned char* pixels = nullptr; + int width = 0, height = 0; + io.Fonts->GetTexDataAsRGBA32(&pixels, &width, &height); + if (!pixels || width <= 0 || height <= 0) return nullptr; + + SDL_Surface* surf = SDL_CreateRGBSurfaceWithFormat(0, width, height, 32, SDL_PIXELFORMAT_RGBA32); + if (!surf) return nullptr; + + SDL_LockSurface(surf); + memcpy(surf->pixels, pixels, width * height * 4); + SDL_UnlockSurface(surf); + return surf; +} + +bool ImGui_ImplSDLSurface2_Init(SDL_Surface* surface) +{ + if (!surface) return false; + g_TargetSurface = surface; + + g_FontSurface = ImGui_ImplSDLSurface2_CreateFontAtlasSurface(); + if (g_FontSurface) + { + ImGui::GetIO().Fonts->TexID = (ImTextureID)g_FontSurface; + } + return true; +} + +void ImGui_ImplSDLSurface2_Shutdown() +{ + ImGui::GetIO().Fonts->TexID = nullptr; + if (g_FontSurface) + { + SDL_FreeSurface(g_FontSurface); + g_FontSurface = nullptr; + } + g_TargetSurface = nullptr; +} + +void ImGui_ImplSDLSurface2_NewFrame() +{ + // noop +} + +void ImGui_ImplSDLSurface2_RenderDrawData(ImDrawData* draw_data) +{ + if (!draw_data || !g_TargetSurface) return; + + if (SDL_MUSTLOCK(g_TargetSurface)) SDL_LockSurface(g_TargetSurface); + + const ImVec2 display_pos = draw_data->DisplayPos; + const ImVec2 fb_scale = draw_data->FramebufferScale; + + for (int n = 0; n < draw_data->CmdListsCount; n++) + { + const ImDrawList* cmd_list = draw_data->CmdLists[n]; + const ImDrawVert* vtx_buffer = cmd_list->VtxBuffer.Data; + const ImDrawIdx* idx_buffer = cmd_list->IdxBuffer.Data; + + int idx_offset = 0; + + for (int cmd_i = 0; cmd_i < cmd_list->CmdBuffer.Size; cmd_i++) + { + const ImDrawCmd* pcmd = &cmd_list->CmdBuffer[cmd_i]; + if (pcmd->ElemCount == 0) { idx_offset += 0; continue; } + + ImVec2 clip_min = ImVec2((pcmd->ClipRect.x - display_pos.x) * fb_scale.x, + (pcmd->ClipRect.y - display_pos.y) * fb_scale.y); + ImVec2 clip_max = ImVec2((pcmd->ClipRect.z - display_pos.x) * fb_scale.x, + (pcmd->ClipRect.w - display_pos.y) * fb_scale.y); + + int cx0 = (int)floor(clip_min.x); + int cy0 = (int)floor(clip_min.y); + int cx1 = (int)ceil(clip_max.x); + int cy1 = (int)ceil(clip_max.y); + + cx0 = std::max(cx0, 0); + cy0 = std::max(cy0, 0); + cx1 = std::min(cx1, g_TargetSurface->w); + cy1 = std::min(cy1, g_TargetSurface->h); + + if (cx0 >= cx1 || cy0 >= cy1) + { + idx_offset += pcmd->ElemCount; + continue; + } + + SDL_Rect srect; + srect.x = cx0; + srect.y = cy0; + srect.w = cx1 - cx0; + srect.h = cy1 - cy0; + SDL_SetClipRect(g_TargetSurface, &srect); + + SDL_Surface* tex = (SDL_Surface*)pcmd->GetTexID(); + + for (unsigned int i = 0; i + 2 < (unsigned int)pcmd->ElemCount; i += 3) + { + ImDrawIdx i0 = idx_buffer[idx_offset + i + 0]; + ImDrawIdx i1 = idx_buffer[idx_offset + i + 1]; + ImDrawIdx i2 = idx_buffer[idx_offset + i + 2]; + + const ImDrawVert& v0 = vtx_buffer[i0]; + const ImDrawVert& v1 = vtx_buffer[i1]; + const ImDrawVert& v2 = vtx_buffer[i2]; + + ImVec2 p0 = ImVec2((v0.pos.x - display_pos.x) * fb_scale.x, (v0.pos.y - display_pos.y) * fb_scale.y); + ImVec2 p1 = ImVec2((v1.pos.x - display_pos.x) * fb_scale.x, (v1.pos.y - display_pos.y) * fb_scale.y); + ImVec2 p2 = ImVec2((v2.pos.x - display_pos.x) * fb_scale.x, (v2.pos.y - display_pos.y) * fb_scale.y); + + int minx = (int)floor(std::min(std::min(p0.x, p1.x), p2.x)); + int miny = (int)floor(std::min(std::min(p0.y, p1.y), p2.y)); + int maxx = (int)ceil(std::max(std::max(p0.x, p1.x), p2.x)); + int maxy = (int)ceil(std::max(std::max(p0.y, p1.y), p2.y)); + + minx = std::max(minx, cx0); + miny = std::max(miny, cy0); + maxx = std::min(maxx, cx1 - 1); + maxy = std::min(maxy, cy1 - 1); + + if (minx > maxx || miny > maxy) continue; + + float area = Edge(p0, p1, p2.x, p2.y); + if (area == 0.0f) continue; + + auto unpack_col = [](ImU32 c, float out[4]) { + out[0] = (float)((c >> IM_COL32_R_SHIFT) & 0xFF) / 255.0f; + out[1] = (float)((c >> IM_COL32_G_SHIFT) & 0xFF) / 255.0f; + out[2] = (float)((c >> IM_COL32_B_SHIFT) & 0xFF) / 255.0f; + out[3] = (float)((c >> IM_COL32_A_SHIFT) & 0xFF) / 255.0f; + }; + + float c0[4], c1[4], c2[4]; + unpack_col(v0.col, c0); unpack_col(v1.col, c1); unpack_col(v2.col, c2); + + for (int y = miny; y <= maxy; y++) + { + for (int x = minx; x <= maxx; x++) + { + float px = (float)x + 0.5f; + float py = (float)y + 0.5f; + + float w0 = Edge(p1, p2, px, py) / area; + float w1 = Edge(p2, p0, px, py) / area; + float w2 = Edge(p0, p1, px, py) / area; + + if (w0 < 0.0f || w1 < 0.0f || w2 < 0.0f) continue; + + float r = w0 * c0[0] + w1 * c1[0] + w2 * c2[0]; + float g = w0 * c0[1] + w1 * c1[1] + w2 * c2[1]; + float b = w0 * c0[2] + w1 * c1[2] + w2 * c2[2]; + float a = w0 * c0[3] + w1 * c1[3] + w2 * c2[3]; + + Uint8 out_r = (Uint8)(std::min(1.0f, r) * 255.0f); + Uint8 out_g = (Uint8)(std::min(1.0f, g) * 255.0f); + Uint8 out_b = (Uint8)(std::min(1.0f, b) * 255.0f); + Uint8 out_a = (Uint8)(std::min(1.0f, a) * 255.0f); + + if (tex) + { + ImVec2 uv0 = v0.uv; ImVec2 uv1 = v1.uv; ImVec2 uv2 = v2.uv; + float u = w0 * uv0.x + w1 * uv1.x + w2 * uv2.x; + float v = w0 * uv0.y + w1 * uv1.y + w2 * uv2.y; + int tx = (int)(u * (tex->w - 1) + 0.5f); + int ty = (int)(v * (tex->h - 1) + 0.5f); + tx = std::clamp(tx, 0, tex->w - 1); + ty = std::clamp(ty, 0, tex->h - 1); + + Uint8* tpx = (Uint8*)tex->pixels + ty * tex->pitch + tx * 4; + Uint8 tr = tpx[0]; + Uint8 tg = tpx[1]; + Uint8 tb = tpx[2]; + Uint8 ta = tpx[3]; + + Uint8 final_r = (Uint8)((tr * out_r) / 255); + Uint8 final_g = (Uint8)((tg * out_g) / 255); + Uint8 final_b = (Uint8)((tb * out_b) / 255); + Uint8 final_a = (Uint8)((ta * out_a) / 255); + + PutPixel(g_TargetSurface, x, y, final_r, final_g, final_b, final_a); + } + else + { + PutPixel(g_TargetSurface, x, y, out_r, out_g, out_b, out_a); + } + } + } + } + + idx_offset += pcmd->ElemCount; + } + } + + SDL_SetClipRect(g_TargetSurface, nullptr); + if (SDL_MUSTLOCK(g_TargetSurface)) SDL_UnlockSurface(g_TargetSurface); +} diff --git a/backends/imgui_impl_sdlsurface2.h b/backends/imgui_impl_sdlsurface2.h new file mode 100644 index 000000000..32ff2ec08 --- /dev/null +++ b/backends/imgui_impl_sdlsurface2.h @@ -0,0 +1,14 @@ +// imgui_impl_sdlsurface2.h +// CPU-only SDL_Surface backend for Dear ImGui +#pragma once + +#include "imgui.h" +#include + +// Initialize with target SDL_Surface (32-bit RGBA) +IMGUI_API bool ImGui_ImplSDLSurface2_Init(SDL_Surface* surface); +IMGUI_API void ImGui_ImplSDLSurface2_Shutdown(); +IMGUI_API void ImGui_ImplSDLSurface2_NewFrame(); +IMGUI_API void ImGui_ImplSDLSurface2_RenderDrawData(ImDrawData* draw_data); + +IMGUI_API SDL_Surface* ImGui_ImplSDLSurface2_CreateFontAtlasSurface(); diff --git a/examples/example_sdl2_surface/Makefile b/examples/example_sdl2_surface/Makefile new file mode 100644 index 000000000..400112ea5 --- /dev/null +++ b/examples/example_sdl2_surface/Makefile @@ -0,0 +1,31 @@ +# Makefile for example_sdl2_surface (MinGW) + +CXX = g++ +CXXFLAGS = -std=c++17 -Wall -Wformat +INCLUDES = -I../.. -I../../backends -I/mingw64/include/SDL2 +LIBS = -lmingw32 -lSDL2main -lSDL2 -lgdi32 + +IMGUI_DIR = ../.. +SOURCES = main.cpp +SOURCES += $(IMGUI_DIR)/imgui.cpp $(IMGUI_DIR)/imgui_demo.cpp $(IMGUI_DIR)/imgui_draw.cpp $(IMGUI_DIR)/imgui_tables.cpp $(IMGUI_DIR)/imgui_widgets.cpp +SOURCES += $(IMGUI_DIR)/backends/imgui_impl_sdl2.cpp +SOURCES += $(IMGUI_DIR)/backends/imgui_impl_sdlsurface2.cpp + +OBJS = $(addsuffix .o, $(basename $(notdir $(SOURCES)))) + +%.o:%.cpp + $(CXX) $(CXXFLAGS) $(INCLUDES) -c -o $@ $< + +%.o:$(IMGUI_DIR)/%.cpp + $(CXX) $(CXXFLAGS) $(INCLUDES) -c -o $@ $< + +%.o:$(IMGUI_DIR)/backends/%.cpp + $(CXX) $(CXXFLAGS) $(INCLUDES) -c -o $@ $< + +all: example_sdl2_surface.exe + +example_sdl2_surface.exe: $(OBJS) + $(CXX) -o $@ $^ $(LIBS) + +clean: + del /Q *.o *.exe diff --git a/examples/example_sdl2_surface/main.cpp b/examples/example_sdl2_surface/main.cpp new file mode 100644 index 000000000..e2e935d23 --- /dev/null +++ b/examples/example_sdl2_surface/main.cpp @@ -0,0 +1,95 @@ +// main.cpp +// Example program using imgui_impl_sdlsurface2 backend + +#include "imgui.h" +#include "imgui_impl_sdl2.h" +#include "imgui_impl_sdlsurface2.h" +#include +#include + +int main(int, char**) +{ + if (SDL_Init(SDL_INIT_VIDEO) != 0) + { + printf("Error: %s\n", SDL_GetError()); + return -1; + } + + SDL_Window* window = SDL_CreateWindow("Dear ImGui SDL2+Surface Example", + SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, + 1280, 720, SDL_WINDOW_SHOWN); + if (!window) + { + printf("Error creating window: %s\n", SDL_GetError()); + return -1; + } + + SDL_Surface* window_surface = SDL_GetWindowSurface(window); + if (!window_surface) + { + printf("Error getting window surface: %s\n", SDL_GetError()); + return -1; + } + + SDL_Surface* framebuffer = SDL_CreateRGBSurfaceWithFormat(0, 1280, 720, 32, SDL_PIXELFORMAT_RGBA32); + if (!framebuffer) + { + printf("Error creating framebuffer: %s\n", SDL_GetError()); + return -1; + } + + IMGUI_CHECKVERSION(); + ImGui::CreateContext(); + ImGuiIO& io = ImGui::GetIO(); (void)io; + + ImGui::StyleColorsDark(); + + ImGui_ImplSDL2_InitForSDLRenderer(window, nullptr); + ImGui_ImplSDLSurface2_Init(framebuffer); + + bool show_demo_window = true; + ImVec4 clear_color = ImVec4(0.45f, 0.55f, 0.60f, 1.00f); + + bool done = false; + while (!done) + { + SDL_Event event; + while (SDL_PollEvent(&event)) + { + ImGui_ImplSDL2_ProcessEvent(&event); + if (event.type == SDL_QUIT) + done = true; + if (event.type == SDL_WINDOWEVENT && event.window.event == SDL_WINDOWEVENT_CLOSE && event.window.windowID == SDL_GetWindowID(window)) + done = true; + } + + ImGui_ImplSDLSurface2_NewFrame(); + ImGui_ImplSDL2_NewFrame(); + ImGui::NewFrame(); + + if (show_demo_window) + ImGui::ShowDemoWindow(&show_demo_window); + + ImGui::Render(); + + SDL_FillRect(framebuffer, nullptr, SDL_MapRGB(framebuffer->format, + (Uint8)(clear_color.x * 255), + (Uint8)(clear_color.y * 255), + (Uint8)(clear_color.z * 255))); + + ImGui_ImplSDLSurface2_RenderDrawData(ImGui::GetDrawData()); + + SDL_BlitSurface(framebuffer, nullptr, window_surface, nullptr); + SDL_UpdateWindowSurface(window); + } + + ImGui_ImplSDLSurface2_Shutdown(); + ImGui_ImplSDL2_Shutdown(); + ImGui::DestroyContext(); + + SDL_FreeSurface(framebuffer); + SDL_DestroyWindow(window); + SDL_Quit(); + + return 0; +}