mirror/imgui
1
0
Fork 0
mirror of https://github.com/ocornut/imgui.git synced 2026-01-09 23:54:20 +00:00
Code Activity

Merge a941c96d1f into f5384544cb

Browse source
This commit is contained in:
MoonPower 2026-01-09 00:57:29 +04:00 • committed by GitHub
commit d1551e5272
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
4 changed files with 597 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

324
backends/imgui_impl_sdlsurface2.cpp Normal file
View file

@ -0,0 +1,324 @@
// imgui_impl_sdlsurface2.cpp
// CPU-only SDL_Surface backend for Dear ImGui
#include "imgui_impl_sdlsurface2.h"
#include "imgui.h"
#include <SDL.h>
#include <cstring>
#include <algorithm>
// No clamp in C++11
template<typename T>
static inline T ImClamp(T v, T lo, T hi)
{
if (v < lo) return lo;
if (v > hi) return hi;
return v;
}
static SDL_Surface* g_TargetSurface = nullptr;
static SDL_Surface* g_FontSurface = nullptr;
static inline Uint32 GetPixel(SDL_Surface* s, int x, int y)
{
Uint8* p = (Uint8*)s->pixels + y * s->pitch + x * s->format->BytesPerPixel;
switch (s->format->BytesPerPixel)
{
case 1: return *p;
case 2: return *(Uint16*)p;
case 3:
if (SDL_BYTEORDER == SDL_BIG_ENDIAN)
return (p[0] << 16) | (p[1] << 8) | p[2];
else
return p[0] | (p[1] << 8) | (p[2] << 16);
case 4: return *(Uint32*)p;
}
return 0;
}
static inline void BlendPixel(SDL_Surface* s, int x, int y,
Uint8 sr, Uint8 sg, Uint8 sb, Uint8 sa)
{
if (!s || sa == 0) return;
if (x < 0 || y < 0 || x >= s->w || y >= s->h) return;
if (sa == 255)
{
Uint32 out_pix = SDL_MapRGBA(s->format, sr, sg, sb, sa);
Uint8* p = (Uint8*)s->pixels + y * s->pitch + x * s->format->BytesPerPixel;
switch (s->format->BytesPerPixel)
{
case 1: *p = (Uint8)out_pix; break;
case 2: *(Uint16*)p = (Uint16)out_pix; break;
case 3:
if (SDL_BYTEORDER == SDL_BIG_ENDIAN)
{
p[0] = (out_pix >> 16) & 0xFF;
p[1] = (out_pix >> 8) & 0xFF;
p[2] = out_pix & 0xFF;
}
else
{
p[0] = out_pix & 0xFF;
p[1] = (out_pix >> 8) & 0xFF;
p[2] = (out_pix >> 16) & 0xFF;
}
break;
case 4: *(Uint32*)p = out_pix; break;
}
return;
}
Uint32 dst_pix = GetPixel(s, x, y);
Uint8 dr, dg, db, da;
SDL_GetRGBA(dst_pix, s->format, &dr, &dg, &db, &da);
Uint8 out_r = (Uint8)((sr * sa + dr * (255 - sa)) / 255);
Uint8 out_g = (Uint8)((sg * sa + dg * (255 - sa)) / 255);
Uint8 out_b = (Uint8)((sb * sa + db * (255 - sa)) / 255);
Uint8 out_a = (Uint8)((sa + (da * (255 - sa)) / 255));
Uint32 out_pix = SDL_MapRGBA(s->format, out_r, out_g, out_b, out_a);
Uint8* p = (Uint8*)s->pixels + y * s->pitch + x * s->format->BytesPerPixel;
switch (s->format->BytesPerPixel)
{
case 1: *p = (Uint8)out_pix; break;
case 2: *(Uint16*)p = (Uint16)out_pix; break;
case 3:
if (SDL_BYTEORDER == SDL_BIG_ENDIAN)
{
p[0] = (out_pix >> 16) & 0xFF;
p[1] = (out_pix >> 8) & 0xFF;
p[2] = out_pix & 0xFF;
}
else
{
p[0] = out_pix & 0xFF;
p[1] = (out_pix >> 8) & 0xFF;
p[2] = (out_pix >> 16) & 0xFF;
}
break;
case 4: *(Uint32*)p = out_pix; break;
}
}
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);
std::memcpy(surf->pixels, pixels, width * height * 4);
SDL_UnlockSurface(surf);
SDL_SetSurfaceBlendMode(surf, SDL_BLENDMODE_NONE);
return surf;
}
bool ImGui_ImplSDLSurface2_Init(SDL_Surface* surface)
{
if (!surface) return false;
ImGuiIO& io = ImGui::GetIO();
IM_ASSERT(io.BackendRendererName == nullptr && "Already initialized a renderer backend!");
io.BackendRendererName = "imgui_impl_sdlsurface2";
g_TargetSurface = surface;
g_FontSurface = ImGui_ImplSDLSurface2_CreateFontAtlasSurface();
if (g_FontSurface)
{
if (g_TargetSurface && g_FontSurface->format->format != g_TargetSurface->format->format)
{
SDL_Surface* converted = SDL_ConvertSurfaceFormat(g_FontSurface, g_TargetSurface->format->format, 0);
if (converted)
{
SDL_FreeSurface(g_FontSurface);
g_FontSurface = converted;
}
}
ImGui::GetIO().Fonts->TexID = (ImTextureID)g_FontSurface;
}
return true;
}
void ImGui_ImplSDLSurface2_Shutdown()
{
ImGuiIO& io = ImGui::GetIO();
io.BackendRendererName = nullptr;
io.BackendFlags &= ~ImGuiBackendFlags_RendererHasTextures;
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)
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)std::floor(clip_min.x);
int cy0 = (int)std::floor(clip_min.y);
int cx1 = (int)std::ceil (clip_max.x);
int cy1 = (int)std::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{ cx0, cy0, cx1 - cx0, 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)std::floor(std::min({ p0.x, p1.x, p2.x }));
int miny = (int)std::floor(std::min({ p0.y, p1.y, p2.y }));
int maxx = (int)std::ceil (std::max({ p0.x, p1.x, p2.x }));
int maxy = (int)std::ceil (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)(ImClamp(r, 0.0f, 1.0f) * 255.0f);
Uint8 out_g = (Uint8)(ImClamp(g, 0.0f, 1.0f) * 255.0f);
Uint8 out_b = (Uint8)(ImClamp(b, 0.0f, 1.0f) * 255.0f);
Uint8 out_a = (Uint8)(ImClamp(a, 0.0f, 1.0f) * 255.0f);
if (tex)
{
ImVec2 uv0 = v0.uv, uv1 = v1.uv, 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 = ImClamp(tx, 0, tex->w - 1);
ty = ImClamp(ty, 0, tex->h - 1);
Uint32 tpx = GetPixel(tex, tx, ty);
Uint8 tr, tg, tb, ta;
SDL_GetRGBA(tpx, tex->format, &tr, &tg, &tb, &ta);
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);
BlendPixel(g_TargetSurface, x, y, final_r, final_g, final_b, final_a);
}
else
{
BlendPixel(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);
}

14
backends/imgui_impl_sdlsurface2.h Normal file
View file

@ -0,0 +1,14 @@
// imgui_impl_sdlsurface2.h
// CPU-only SDL_Surface backend for Dear ImGui
#pragma once
#include "imgui.h"
#include <SDL.h>
// 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();

72
examples/example_sdl2_surface/Makefile Normal file
View file

@ -0,0 +1,72 @@
#
# Cross Platform Makefile (example_sdl2_surface)
# Compatible with MSYS2/MINGW, Linux and macOS
#
# You will need SDL2 (http://www.libsdl.org):
# Linux: apt-get install libsdl2-dev
# macOS: brew install sdl2
# MSYS2: pacman -S mingw-w64-i686-SDL2
#
#EXE = example_sdl2_surface
EXE = example_sdl2_surface
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 $(IMGUI_DIR)/backends/imgui_impl_sdlsurface2.cpp
OBJS = $(addsuffix .o, $(basename $(notdir $(SOURCES))))
UNAME_S := $(shell uname -s)
CXXFLAGS = -std=c++11 -I$(IMGUI_DIR) -I$(IMGUI_DIR)/backends
CXXFLAGS += -g -Wall -Wformat
LIBS =
##---------------------------------------------------------------------
## BUILD FLAGS PER PLATFORM
##---------------------------------------------------------------------
ifeq ($(UNAME_S), Linux) #LINUX
ECHO_MESSAGE = "Linux"
LIBS += `sdl2-config --libs`
CXXFLAGS += `sdl2-config --cflags`
CFLAGS = $(CXXFLAGS)
endif
ifeq ($(UNAME_S), Darwin) #APPLE
ECHO_MESSAGE = "Mac OS X"
LIBS += `sdl2-config --libs`
CXXFLAGS += `sdl2-config --cflags`
CXXFLAGS += -I/usr/local/include -I/opt/local/include
CFLAGS = $(CXXFLAGS)
endif
ifeq ($(OS), Windows_NT)
ECHO_MESSAGE = "MinGW"
LIBS += -lgdi32 `pkg-config --static --libs sdl2`
CXXFLAGS += `pkg-config --cflags sdl2`
CFLAGS = $(CXXFLAGS)
endif
##---------------------------------------------------------------------
## BUILD RULES
##---------------------------------------------------------------------
%.o:%.cpp
$(CXX) $(CXXFLAGS) -c -o $@ $<
%.o:$(IMGUI_DIR)/%.cpp
$(CXX) $(CXXFLAGS) -c -o $@ $<
%.o:$(IMGUI_DIR)/backends/%.cpp
$(CXX) $(CXXFLAGS) -c -o $@ $<
all: $(EXE)
@echo Build complete for $(ECHO_MESSAGE)
$(EXE): $(OBJS)
$(CXX) -o $@ $^ $(CXXFLAGS) $(LIBS)
clean:
rm -f $(EXE) $(OBJS)

187
examples/example_sdl2_surface/main.cpp Normal file
View file

@ -0,0 +1,187 @@
// main.cpp
// Example program using imgui_impl_sdlsurface2 backend
#include "imgui.h"
#include "imgui_impl_sdl2.h"
#include "imgui_impl_sdlsurface2.h"
#include <SDL.h>
#include <stdio.h>
int main(int, char**)
{
// Setup SDL
if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER | SDL_INIT_GAMECONTROLLER) != 0)
{
printf("Error: %s\n", SDL_GetError());
return -1;
}
// From 2.0.18: Enable native IME.
#ifdef SDL_HINT_IME_SHOW_UI
SDL_SetHint(SDL_HINT_IME_SHOW_UI, "1");
#endif
// Create window
float main_scale = ImGui_ImplSDL2_GetContentScaleForDisplay(0);
SDL_WindowFlags window_flags = (SDL_WindowFlags)(SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI | SDL_WINDOW_SHOWN);
SDL_Window* window = SDL_CreateWindow("Dear ImGui SDL2+Surface Example",
SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
(int)(1280 * main_scale), (int)(720 * main_scale), window_flags);
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;
}
int win_w = window_surface->w;
int win_h = window_surface->h;
SDL_Surface* framebuffer = SDL_CreateRGBSurfaceWithFormat(0, win_w, win_h, 32, SDL_PIXELFORMAT_RGBA32);
if (!framebuffer)
{
printf("Error creating framebuffer: %s\n", SDL_GetError());
return -1;
}
// Setup Dear ImGui context
IMGUI_CHECKVERSION();
ImGui::CreateContext();
ImGuiIO& io = ImGui::GetIO(); (void)io;
io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard; // Enable Keyboard Controls
io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad; // Enable Gamepad Controls
// Setup Dear ImGui style
ImGui::StyleColorsDark();
// Setup scaling
ImGuiStyle& style = ImGui::GetStyle();
style.ScaleAllSizes(main_scale); // Bake a fixed style scale.
style.FontScaleDpi = main_scale;
// Setup Platform/Renderer backends
ImGui_ImplSDL2_InitForOther(window);
ImGui_ImplSDL2_SetGamepadMode(ImGui_ImplSDL2_GamepadMode_AutoFirst, nullptr, 0);
ImGui_ImplSDLSurface2_Init(framebuffer);
// Our state
bool show_demo_window = true;
bool show_another_window = false;
ImVec4 clear_color = ImVec4(0.45f, 0.55f, 0.60f, 1.00f);
// Main loop
bool done = false;
while (!done)
{
// Poll and handle events (inputs, window resize, etc.)
SDL_Event event;
while (SDL_PollEvent(&event))
{
ImGui_ImplSDL2_ProcessEvent(&event);
if (event.type == SDL_QUIT)
done = true;
if (event.type == SDL_WINDOWEVENT)
{
if (event.window.event == SDL_WINDOWEVENT_CLOSE && event.window.windowID == SDL_GetWindowID(window))
done = true;
if (event.window.event == SDL_WINDOWEVENT_SIZE_CHANGED || event.window.event == SDL_WINDOWEVENT_RESIZED)
{
// Recreate framebuffer at new size
window_surface = SDL_GetWindowSurface(window);
int new_w = window_surface->w;
int new_h = window_surface->h;
if (new_w != win_w || new_h != win_h)
{
SDL_FreeSurface(framebuffer);
framebuffer = SDL_CreateRGBSurfaceWithFormat(0, new_w, new_h, 32, SDL_PIXELFORMAT_RGBA32);
if (!framebuffer) { printf("Error creating framebuffer after resize: %s\n", SDL_GetError()); return -1; }
win_w = new_w; win_h = new_h;
// Re-init the backend with the new framebuffer
ImGui_ImplSDLSurface2_Shutdown();
ImGui_ImplSDLSurface2_Init(framebuffer);
}
}
}
}
// Skip rendering when minimized to avoid busy-looping
if (SDL_GetWindowFlags(window) & SDL_WINDOW_MINIMIZED)
{
SDL_Delay(10);
continue;
}
// Start the Dear ImGui frame
ImGui_ImplSDLSurface2_NewFrame();
ImGui_ImplSDL2_NewFrame();
ImGui::NewFrame();
// 1. Show the big demo window
if (show_demo_window)
ImGui::ShowDemoWindow(&show_demo_window);
// 2. Show a simple window that we create ourselves. Mirror the SDL_Renderer example.
{
static float f = 0.0f;
static int counter = 0;
ImGui::Begin("Hello, world!"); // Create a window called "Hello, world!" and append into it.
ImGui::Text("This is some useful text."); // Display some text
ImGui::Checkbox("Demo Window", &show_demo_window); // Edit bools storing our window open/close state
ImGui::Checkbox("Another Window", &show_another_window);
ImGui::SliderFloat("float", &f, 0.0f, 1.0f); // Edit 1 float using a slider from 0.0f to 1.0f
ImGui::ColorEdit3("clear color", (float*)&clear_color); // Edit 3 floats representing a color
if (ImGui::Button("Button")) // Buttons return true when clicked
counter++;
ImGui::SameLine();
ImGui::Text("counter = %d", counter);
ImGui::Text("Application average %.3f ms/frame (%.1f FPS)", 1000.0f / io.Framerate, io.Framerate);
ImGui::End();
}
// 3. Show another simple window.
if (show_another_window)
{
ImGui::Begin("Another Window", &show_another_window); // Pass a pointer to our bool variable (the window will have a closing button that will clear the bool when clicked)
ImGui::Text("Hello from another window!");
if (ImGui::Button("Close Me"))
show_another_window = false;
ImGui::End();
}
// Rendering
ImGui::Render();
SDL_FillRect(framebuffer, nullptr, SDL_MapRGBA(framebuffer->format,
(Uint8)(clear_color.x * 255),
(Uint8)(clear_color.y * 255),
(Uint8)(clear_color.z * 255),
(Uint8)(clear_color.w * 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;
}