123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680 |
- #include "imgui_sdl.h"
- #if defined(WIN32) || defined(WIN64) || defined(_WIN32) || defined(_WIN64)
- #include <SDL.h>
- #else
- #include <SDL2/SDL.h>
- #endif
- #include "imgui.h"
- #include <map>
- #include <list>
- #include <cmath>
- #include <array>
- #include <vector>
- #include <memory>
- #include <iostream>
- #include <algorithm>
- #include <functional>
- #include <unordered_map>
- namespace
- {
- struct Device* CurrentDevice = nullptr;
- namespace TupleHash
- {
- template <typename T> struct Hash
- {
- std::size_t operator()(const T& value) const
- {
- return std::hash<T>()(value);
- }
- };
- template <typename T> void CombineHash(std::size_t& seed, const T& value)
- {
- seed ^= TupleHash::Hash<T>()(value) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
- }
- template <typename Tuple, std::size_t Index = std::tuple_size<Tuple>::value - 1> struct Hasher
- {
- static void Hash(std::size_t& seed, const Tuple& tuple)
- {
- Hasher<Tuple, Index - 1>::Hash(seed, tuple);
- CombineHash(seed, std::get<Index>(tuple));
- }
- };
- template <typename Tuple> struct Hasher<Tuple, 0>
- {
- static void Hash(std::size_t& seed, const Tuple& tuple)
- {
- CombineHash(seed, std::get<0>(tuple));
- }
- };
- template <typename... T> struct Hash<std::tuple<T...>>
- {
- std::size_t operator()(const std::tuple<T...>& value) const
- {
- std::size_t seed = 0;
- Hasher<std::tuple<T...>>::Hash(seed, value);
- return seed;
- }
- };
- }
- template <typename Key, typename Value, std::size_t Size> class LRUCache
- {
- public:
- bool Contains(const Key& key) const
- {
- return Container.find(key) != Container.end();
- }
- const Value& At(const Key& key)
- {
- assert(Contains(key));
- const auto location = Container.find(key);
- Order.splice(Order.begin(), Order, location->second);
- return location->second->second;
- }
- void Insert(const Key& key, Value value)
- {
- const auto existingLocation = Container.find(key);
- if (existingLocation != Container.end())
- {
- Order.erase(existingLocation->second);
- Container.erase(existingLocation);
- }
- Order.push_front(std::make_pair(key, std::move(value)));
- Container.insert(std::make_pair(key, Order.begin()));
- Clean();
- }
- private:
- void Clean()
- {
- while (Container.size() > Size)
- {
- auto last = Order.end();
- last--;
- Container.erase(last->first);
- Order.pop_back();
- }
- }
- std::list<std::pair<Key, Value>> Order;
- std::unordered_map<Key, decltype(Order.begin()), TupleHash::Hash<Key>> Container;
- };
- struct Color
- {
- const float R, G, B, A;
- explicit Color(uint32_t color)
- : R(((color >> 0) & 0xff) / 255.0f), G(((color >> 8) & 0xff) / 255.0f), B(((color >> 16) & 0xff) / 255.0f), A(((color >> 24) & 0xff) / 255.0f) { }
- Color(float r, float g, float b, float a) : R(r), G(g), B(b), A(a) { }
- Color operator*(const Color& c) const { return Color(R * c.R, G * c.G, B * c.B, A * c.A); }
- Color operator*(float v) const { return Color(R * v, G * v, B * v, A * v); }
- Color operator+(const Color& c) const { return Color(R + c.R, G + c.G, B + c.B, A + c.A); }
- uint32_t ToInt() const
- {
- return ((static_cast<int>(R * 255) & 0xff) << 0)
- | ((static_cast<int>(G * 255) & 0xff) << 8)
- | ((static_cast<int>(B * 255) & 0xff) << 16)
- | ((static_cast<int>(A * 255) & 0xff) << 24);
- }
- void UseAsDrawColor(SDL_Renderer* renderer) const
- {
- SDL_SetRenderDrawColor(renderer,
- static_cast<uint8_t>(R * 255),
- static_cast<uint8_t>(G * 255),
- static_cast<uint8_t>(B * 255),
- static_cast<uint8_t>(A * 255));
- }
- };
- struct Device
- {
- SDL_Renderer* Renderer;
- struct ClipRect
- {
- int X, Y, Width, Height;
- } Clip;
- struct TriangleCacheItem
- {
- SDL_Texture* Texture = nullptr;
- int Width = 0, Height = 0;
- ~TriangleCacheItem() { if (Texture) SDL_DestroyTexture(Texture); }
- };
- // You can tweak these to values that you find that work the best.
- static constexpr std::size_t UniformColorTriangleCacheSize = 512;
- static constexpr std::size_t GenericTriangleCacheSize = 64;
- // Uniform color is identified by its color and the coordinates of the edges.
- using UniformColorTriangleKey = std::tuple<uint32_t, int, int, int, int, int, int>;
- // The generic triangle cache unfortunately has to be basically a full representation of the triangle.
- // This includes the (offset) vertex positions, texture coordinates and vertex colors.
- using GenericTriangleVertexKey = std::tuple<int, int, double, double, uint32_t>;
- using GenericTriangleKey = std::tuple<GenericTriangleVertexKey, GenericTriangleVertexKey, GenericTriangleVertexKey>;
- LRUCache<UniformColorTriangleKey, std::unique_ptr<TriangleCacheItem>, UniformColorTriangleCacheSize> UniformColorTriangleCache;
- LRUCache<GenericTriangleKey, std::unique_ptr<TriangleCacheItem>, GenericTriangleCacheSize> GenericTriangleCache;
- Device(SDL_Renderer* renderer) : Renderer(renderer) { }
- void SetClipRect(const ClipRect& rect)
- {
- Clip = rect;
- const SDL_Rect clip = { rect.X, rect.Y, rect.Width, rect.Height };
- SDL_RenderSetClipRect(Renderer, &clip);
- }
- void EnableClip() { SetClipRect(Clip); }
- void DisableClip() { SDL_RenderSetClipRect(Renderer, nullptr); }
- void SetAt(int x, int y, const Color& color)
- {
- color.UseAsDrawColor(Renderer);
- SDL_RenderDrawPoint(Renderer, x, y);
- }
- SDL_Texture* MakeTexture(int width, int height)
- {
- SDL_Texture* texture = SDL_CreateTexture(Renderer, SDL_PIXELFORMAT_RGBA32, SDL_TEXTUREACCESS_TARGET, width, height);
- SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_BLEND);
- return texture;
- }
- void UseAsRenderTarget(SDL_Texture* texture)
- {
- SDL_SetRenderTarget(Renderer, texture);
- if (texture)
- {
- SDL_SetRenderDrawColor(Renderer, 0, 0, 0, 0);
- SDL_RenderClear(Renderer);
- }
- }
- };
- struct Texture
- {
- SDL_Surface* Surface;
- SDL_Texture* Source;
- ~Texture()
- {
- SDL_FreeSurface(Surface);
- SDL_DestroyTexture(Source);
- }
- Color Sample(float u, float v) const
- {
- const int x = static_cast<int>(std::round(u * (Surface->w - 1) + 0.5f));
- const int y = static_cast<int>(std::round(v * (Surface->h - 1) + 0.5f));
- const int location = y * Surface->w + x;
- assert(location < Surface->w * Surface->h);
- return Color(static_cast<uint32_t*>(Surface->pixels)[location]);
- }
- };
- template <typename T> class InterpolatedFactorEquation
- {
- public:
- InterpolatedFactorEquation(const T& value0, const T& value1, const T& value2, const ImVec2& v0, const ImVec2& v1, const ImVec2& v2)
- : Value0(value0), Value1(value1), Value2(value2), V0(v0), V1(v1), V2(v2),
- Divisor((V1.y - V2.y) * (V0.x - V2.x) + (V2.x - V1.x) * (V0.y - V2.y)) { }
- T Evaluate(float x, float y) const
- {
- const float w1 = ((V1.y - V2.y) * (x - V2.x) + (V2.x - V1.x) * (y - V2.y)) / Divisor;
- const float w2 = ((V2.y - V0.y) * (x - V2.x) + (V0.x - V2.x) * (y - V2.y)) / Divisor;
- const float w3 = 1.0f - w1 - w2;
- return static_cast<T>((Value0 * w1) + (Value1 * w2) + (Value2 * w3));
- }
- private:
- const T Value0;
- const T Value1;
- const T Value2;
- const ImVec2& V0;
- const ImVec2& V1;
- const ImVec2& V2;
- const float Divisor;
- };
- struct Rect
- {
- float MinX, MinY, MaxX, MaxY;
- float MinU, MinV, MaxU, MaxV;
- bool IsOnExtreme(const ImVec2& point) const
- {
- return (point.x == MinX || point.x == MaxX) && (point.y == MinY || point.y == MaxY);
- }
- bool UsesOnlyColor() const
- {
- const ImVec2& whitePixel = ImGui::GetIO().Fonts->TexUvWhitePixel;
- return MinU == MaxU && MinU == whitePixel.x && MinV == MaxV && MaxV == whitePixel.y;
- }
- static Rect CalculateBoundingBox(const ImDrawVert& v0, const ImDrawVert& v1, const ImDrawVert& v2)
- {
- return Rect{
- std::min({ v0.pos.x, v1.pos.x, v2.pos.x }),
- std::min({ v0.pos.y, v1.pos.y, v2.pos.y }),
- std::max({ v0.pos.x, v1.pos.x, v2.pos.x }),
- std::max({ v0.pos.y, v1.pos.y, v2.pos.y }),
- std::min({ v0.uv.x, v1.uv.x, v2.uv.x }),
- std::min({ v0.uv.y, v1.uv.y, v2.uv.y }),
- std::max({ v0.uv.x, v1.uv.x, v2.uv.x }),
- std::max({ v0.uv.y, v1.uv.y, v2.uv.y })
- };
- }
- };
- struct FixedPointTriangleRenderInfo
- {
- int X1, X2, X3, Y1, Y2, Y3;
- int MinX, MaxX, MinY, MaxY;
- static FixedPointTriangleRenderInfo CalculateFixedPointTriangleInfo(const ImVec2& v1, const ImVec2& v2, const ImVec2& v3)
- {
- static constexpr float scale = 16.0f;
- const int x1 = static_cast<int>(std::round(v1.x * scale));
- const int x2 = static_cast<int>(std::round(v2.x * scale));
- const int x3 = static_cast<int>(std::round(v3.x * scale));
- const int y1 = static_cast<int>(std::round(v1.y * scale));
- const int y2 = static_cast<int>(std::round(v2.y * scale));
- const int y3 = static_cast<int>(std::round(v3.y * scale));
- int minX = (std::min({ x1, x2, x3 }) + 0xF) >> 4;
- int maxX = (std::max({ x1, x2, x3 }) + 0xF) >> 4;
- int minY = (std::min({ y1, y2, y3 }) + 0xF) >> 4;
- int maxY = (std::max({ y1, y2, y3 }) + 0xF) >> 4;
- return FixedPointTriangleRenderInfo{ x1, x2, x3, y1, y2, y3, minX, maxX, minY, maxY };
- }
- };
- void DrawTriangleWithColorFunction(const FixedPointTriangleRenderInfo& renderInfo, const std::function<Color(float x, float y)>& colorFunction, Device::TriangleCacheItem* cacheItem)
- {
- // Implementation source: https://web.archive.org/web/20171128164608/http://forum.devmaster.net/t/advanced-rasterization/6145.
- // This is a fixed point implementation that rounds to top-left.
- const int deltaX12 = renderInfo.X1 - renderInfo.X2;
- const int deltaX23 = renderInfo.X2 - renderInfo.X3;
- const int deltaX31 = renderInfo.X3 - renderInfo.X1;
- const int deltaY12 = renderInfo.Y1 - renderInfo.Y2;
- const int deltaY23 = renderInfo.Y2 - renderInfo.Y3;
- const int deltaY31 = renderInfo.Y3 - renderInfo.Y1;
- const int fixedDeltaX12 = deltaX12 << 4;
- const int fixedDeltaX23 = deltaX23 << 4;
- const int fixedDeltaX31 = deltaX31 << 4;
- const int fixedDeltaY12 = deltaY12 << 4;
- const int fixedDeltaY23 = deltaY23 << 4;
- const int fixedDeltaY31 = deltaY31 << 4;
- const int width = renderInfo.MaxX - renderInfo.MinX;
- const int height = renderInfo.MaxY - renderInfo.MinY;
- if (width == 0 || height == 0) return;
- int c1 = deltaY12 * renderInfo.X1 - deltaX12 * renderInfo.Y1;
- int c2 = deltaY23 * renderInfo.X2 - deltaX23 * renderInfo.Y2;
- int c3 = deltaY31 * renderInfo.X3 - deltaX31 * renderInfo.Y3;
- if (deltaY12 < 0 || (deltaY12 == 0 && deltaX12 > 0)) c1++;
- if (deltaY23 < 0 || (deltaY23 == 0 && deltaX23 > 0)) c2++;
- if (deltaY31 < 0 || (deltaY31 == 0 && deltaX31 > 0)) c3++;
- int edgeStart1 = c1 + deltaX12 * (renderInfo.MinY << 4) - deltaY12 * (renderInfo.MinX << 4);
- int edgeStart2 = c2 + deltaX23 * (renderInfo.MinY << 4) - deltaY23 * (renderInfo.MinX << 4);
- int edgeStart3 = c3 + deltaX31 * (renderInfo.MinY << 4) - deltaY31 * (renderInfo.MinX << 4);
- SDL_Texture* cache = CurrentDevice->MakeTexture(width, height);
- CurrentDevice->DisableClip();
- CurrentDevice->UseAsRenderTarget(cache);
- for (int y = renderInfo.MinY; y < renderInfo.MaxY; y++)
- {
- int edge1 = edgeStart1;
- int edge2 = edgeStart2;
- int edge3 = edgeStart3;
- for (int x = renderInfo.MinX; x < renderInfo.MaxX; x++)
- {
- if (edge1 > 0 && edge2 > 0 && edge3 > 0)
- {
- CurrentDevice->SetAt(x - renderInfo.MinX, y - renderInfo.MinY, colorFunction(x + 0.5f, y + 0.5f));
- }
- edge1 -= fixedDeltaY12;
- edge2 -= fixedDeltaY23;
- edge3 -= fixedDeltaY31;
- }
- edgeStart1 += fixedDeltaX12;
- edgeStart2 += fixedDeltaX23;
- edgeStart3 += fixedDeltaX31;
- }
- CurrentDevice->UseAsRenderTarget(nullptr);
- CurrentDevice->EnableClip();
- cacheItem->Texture = cache;
- cacheItem->Width = width;
- cacheItem->Height = height;
- }
- void DrawCachedTriangle(const Device::TriangleCacheItem& triangle, const FixedPointTriangleRenderInfo& renderInfo)
- {
- const SDL_Rect destination = { renderInfo.MinX, renderInfo.MinY, triangle.Width, triangle.Height };
- SDL_RenderCopy(CurrentDevice->Renderer, triangle.Texture, nullptr, &destination);
- }
- void DrawTriangle(const ImDrawVert& v1, const ImDrawVert& v2, const ImDrawVert& v3, const Texture* texture)
- {
- // The naming inconsistency in the parameters is intentional. The fixed point algorithm wants the vertices in a counter clockwise order.
- const auto& renderInfo = FixedPointTriangleRenderInfo::CalculateFixedPointTriangleInfo(v3.pos, v2.pos, v1.pos);
- // First we check if there is a cached version of this triangle already waiting for us. If so, we can just do a super fast texture copy.
- const auto key = std::make_tuple(
- std::make_tuple(static_cast<int>(std::round(v1.pos.x)) - renderInfo.MinX, static_cast<int>(std::round(v1.pos.y)) - renderInfo.MinY, v1.uv.x, v1.uv.y, v1.col),
- std::make_tuple(static_cast<int>(std::round(v2.pos.x)) - renderInfo.MinX, static_cast<int>(std::round(v2.pos.y)) - renderInfo.MinY, v2.uv.x, v2.uv.y, v2.col),
- std::make_tuple(static_cast<int>(std::round(v3.pos.x)) - renderInfo.MinX, static_cast<int>(std::round(v3.pos.y)) - renderInfo.MinY, v3.uv.x, v3.uv.y, v3.col));
- if (CurrentDevice->GenericTriangleCache.Contains(key))
- {
- const auto& cached = CurrentDevice->GenericTriangleCache.At(key);
- DrawCachedTriangle(*cached, renderInfo);
- return;
- }
- const InterpolatedFactorEquation<float> textureU(v1.uv.x, v2.uv.x, v3.uv.x, v1.pos, v2.pos, v3.pos);
- const InterpolatedFactorEquation<float> textureV(v1.uv.y, v2.uv.y, v3.uv.y, v1.pos, v2.pos, v3.pos);
- const InterpolatedFactorEquation<Color> shadeColor(Color(v1.col), Color(v2.col), Color(v3.col), v1.pos, v2.pos, v3.pos);
- auto cached = std::make_unique<Device::TriangleCacheItem>();
- DrawTriangleWithColorFunction(renderInfo, [&](float x, float y) {
- const float u = textureU.Evaluate(x, y);
- const float v = textureV.Evaluate(x, y);
- const Color sampled = texture->Sample(u, v);
- const Color shade = shadeColor.Evaluate(x, y);
- return sampled * shade;
- }, cached.get());
- if (!cached->Texture) return;
- const SDL_Rect destination = { renderInfo.MinX, renderInfo.MinY, cached->Width, cached->Height };
- SDL_RenderCopy(CurrentDevice->Renderer, cached->Texture, nullptr, &destination);
- CurrentDevice->GenericTriangleCache.Insert(key, std::move(cached));
- }
- void DrawUniformColorTriangle(const ImDrawVert& v1, const ImDrawVert& v2, const ImDrawVert& v3)
- {
- const Color color(v1.col);
- // The naming inconsistency in the parameters is intentional. The fixed point algorithm wants the vertices in a counter clockwise order.
- const auto& renderInfo = FixedPointTriangleRenderInfo::CalculateFixedPointTriangleInfo(v3.pos, v2.pos, v1.pos);
- const auto key =std::make_tuple(v1.col,
- static_cast<int>(std::round(v1.pos.x)) - renderInfo.MinX, static_cast<int>(std::round(v1.pos.y)) - renderInfo.MinY,
- static_cast<int>(std::round(v2.pos.x)) - renderInfo.MinX, static_cast<int>(std::round(v2.pos.y)) - renderInfo.MinY,
- static_cast<int>(std::round(v3.pos.x)) - renderInfo.MinX, static_cast<int>(std::round(v3.pos.y)) - renderInfo.MinY);
- if (CurrentDevice->UniformColorTriangleCache.Contains(key))
- {
- const auto& cached = CurrentDevice->UniformColorTriangleCache.At(key);
- DrawCachedTriangle(*cached, renderInfo);
- return;
- }
- auto cached = std::make_unique<Device::TriangleCacheItem>();
- DrawTriangleWithColorFunction(renderInfo, [&color](float, float) { return color; }, cached.get());
- if (!cached->Texture) return;
- const SDL_Rect destination = { renderInfo.MinX, renderInfo.MinY, cached->Width, cached->Height };
- SDL_RenderCopy(CurrentDevice->Renderer, cached->Texture, nullptr, &destination);
- CurrentDevice->UniformColorTriangleCache.Insert(key, std::move(cached));
- }
- void DrawRectangle(const Rect& bounding, SDL_Texture* texture, int textureWidth, int textureHeight, const Color& color, bool doHorizontalFlip, bool doVerticalFlip)
- {
- // We are safe to assume uniform color here, because the caller checks it and and uses the triangle renderer to render those.
- const SDL_Rect destination = {
- static_cast<int>(bounding.MinX),
- static_cast<int>(bounding.MinY),
- static_cast<int>(bounding.MaxX - bounding.MinX),
- static_cast<int>(bounding.MaxY - bounding.MinY)
- };
- // If the area isn't textured, we can just draw a rectangle with the correct color.
- if (bounding.UsesOnlyColor())
- {
- color.UseAsDrawColor(CurrentDevice->Renderer);
- SDL_RenderFillRect(CurrentDevice->Renderer, &destination);
- }
- else
- {
- // We can now just calculate the correct source rectangle and draw it.
- const SDL_Rect source = {
- static_cast<int>(bounding.MinU * textureWidth),
- static_cast<int>(bounding.MinV * textureHeight),
- static_cast<int>((bounding.MaxU - bounding.MinU) * textureWidth),
- static_cast<int>((bounding.MaxV - bounding.MinV) * textureHeight)
- };
- const SDL_RendererFlip flip = static_cast<SDL_RendererFlip>((doHorizontalFlip ? SDL_FLIP_HORIZONTAL : 0) | (doVerticalFlip ? SDL_FLIP_VERTICAL : 0));
- SDL_SetTextureColorMod(texture, static_cast<uint8_t>(color.R * 255), static_cast<uint8_t>(color.G * 255), static_cast<uint8_t>(color.B * 255));
- SDL_RenderCopyEx(CurrentDevice->Renderer, texture, &source, &destination, 0.0, nullptr, flip);
- }
- }
- void DrawRectangle(const Rect& bounding, const Texture* texture, const Color& color, bool doHorizontalFlip, bool doVerticalFlip)
- {
- DrawRectangle(bounding, texture->Source, texture->Surface->w, texture->Surface->h, color, doHorizontalFlip, doVerticalFlip);
- }
- void DrawRectangle(const Rect& bounding, SDL_Texture* texture, const Color& color, bool doHorizontalFlip, bool doVerticalFlip)
- {
- int width, height;
- SDL_QueryTexture(texture, nullptr, nullptr, &width, &height);
- DrawRectangle(bounding, texture, width, height, color, doHorizontalFlip, doVerticalFlip);
- }
- }
- namespace ImGuiSDL
- {
- void Initialize(SDL_Renderer* renderer, int windowWidth, int windowHeight)
- {
- ImGuiIO& io = ImGui::GetIO();
- io.DisplaySize.x = static_cast<float>(windowWidth);
- io.DisplaySize.y = static_cast<float>(windowHeight);
- ImGui::GetStyle().WindowRounding = 0.0f;
- ImGui::GetStyle().AntiAliasedFill = false;
- ImGui::GetStyle().AntiAliasedLines = false;
- // Loads the font texture.
- unsigned char* pixels;
- int width, height;
- io.Fonts->GetTexDataAsRGBA32(&pixels, &width, &height);
- static constexpr uint32_t rmask = 0x000000ff, gmask = 0x0000ff00, bmask = 0x00ff0000, amask = 0xff000000;
- SDL_Surface* surface = SDL_CreateRGBSurfaceFrom(pixels, width, height, 32, 4 * width, rmask, gmask, bmask, amask);
- Texture* texture = new Texture();
- texture->Surface = surface;
- texture->Source = SDL_CreateTextureFromSurface(renderer, surface);
- io.Fonts->TexID = (void*)texture;
- CurrentDevice = new Device(renderer);
- }
- void Deinitialize()
- {
- // Frees up the memory of the font texture.
- ImGuiIO& io = ImGui::GetIO();
- Texture* texture = static_cast<Texture*>(io.Fonts->TexID);
- delete texture;
- delete CurrentDevice;
- }
- void Render(ImDrawData* drawData)
- {
- SDL_BlendMode blendMode;
- SDL_GetRenderDrawBlendMode(CurrentDevice->Renderer, &blendMode);
- SDL_SetRenderDrawBlendMode(CurrentDevice->Renderer, SDL_BLENDMODE_BLEND);
- Uint8 initialR, initialG, initialB, initialA;
- SDL_GetRenderDrawColor(CurrentDevice->Renderer, &initialR, &initialG, &initialB, &initialA);
- SDL_bool initialClipEnabled = SDL_RenderIsClipEnabled(CurrentDevice->Renderer);
- SDL_Rect initialClipRect;
- SDL_RenderGetClipRect(CurrentDevice->Renderer, &initialClipRect);
- SDL_Texture* initialRenderTarget = SDL_GetRenderTarget(CurrentDevice->Renderer);
- ImGuiIO& io = ImGui::GetIO();
- for (int n = 0; n < drawData->CmdListsCount; n++)
- {
- auto commandList = drawData->CmdLists[n];
- auto vertexBuffer = commandList->VtxBuffer;
- auto indexBuffer = commandList->IdxBuffer.Data;
- for (int cmd_i = 0; cmd_i < commandList->CmdBuffer.Size; cmd_i++)
- {
- const ImDrawCmd* drawCommand = &commandList->CmdBuffer[cmd_i];
- const Device::ClipRect clipRect = {
- static_cast<int>(drawCommand->ClipRect.x),
- static_cast<int>(drawCommand->ClipRect.y),
- static_cast<int>(drawCommand->ClipRect.z - drawCommand->ClipRect.x),
- static_cast<int>(drawCommand->ClipRect.w - drawCommand->ClipRect.y)
- };
- CurrentDevice->SetClipRect(clipRect);
- if (drawCommand->UserCallback)
- {
- drawCommand->UserCallback(commandList, drawCommand);
- }
- else
- {
- const bool isWrappedTexture = drawCommand->TextureId == io.Fonts->TexID;
- // Loops over triangles.
- for (unsigned int i = 0; i + 3 <= drawCommand->ElemCount; i += 3)
- {
- const ImDrawVert& v0 = vertexBuffer[indexBuffer[i + 0]];
- const ImDrawVert& v1 = vertexBuffer[indexBuffer[i + 1]];
- const ImDrawVert& v2 = vertexBuffer[indexBuffer[i + 2]];
- const Rect& bounding = Rect::CalculateBoundingBox(v0, v1, v2);
- const bool isTriangleUniformColor = v0.col == v1.col && v1.col == v2.col;
- const bool doesTriangleUseOnlyColor = bounding.UsesOnlyColor();
- // Actually, since we render a whole bunch of rectangles, we try to first detect those, and render them more efficiently.
- // How are rectangles detected? It's actually pretty simple: If all 6 vertices lie on the extremes of the bounding box,
- // it's a rectangle.
- if (i + 6 <= drawCommand->ElemCount)
- {
- const ImDrawVert& v3 = vertexBuffer[indexBuffer[i + 3]];
- const ImDrawVert& v4 = vertexBuffer[indexBuffer[i + 4]];
- const ImDrawVert& v5 = vertexBuffer[indexBuffer[i + 5]];
- const bool isUniformColor = isTriangleUniformColor && v2.col == v3.col && v3.col == v4.col && v4.col == v5.col;
- if (isUniformColor
- && bounding.IsOnExtreme(v0.pos)
- && bounding.IsOnExtreme(v1.pos)
- && bounding.IsOnExtreme(v2.pos)
- && bounding.IsOnExtreme(v3.pos)
- && bounding.IsOnExtreme(v4.pos)
- && bounding.IsOnExtreme(v5.pos))
- {
- // ImGui gives the triangles in a nice order: the first vertex happens to be the topleft corner of our rectangle.
- // We need to check for the orientation of the texture, as I believe in theory ImGui could feed us a flipped texture,
- // so that the larger texture coordinates are at topleft instead of bottomright.
- // We don't consider equal texture coordinates to require a flip, as then the rectangle is mostlikely simply a colored rectangle.
- const bool doHorizontalFlip = v2.uv.x < v0.uv.x;
- const bool doVerticalFlip = v2.uv.x < v0.uv.x;
- if (isWrappedTexture)
- {
- DrawRectangle(bounding, static_cast<const Texture*>(drawCommand->TextureId), Color(v0.col), doHorizontalFlip, doVerticalFlip);
- }
- else
- {
- DrawRectangle(bounding, static_cast<SDL_Texture*>(drawCommand->TextureId), Color(v0.col), doHorizontalFlip, doVerticalFlip);
- }
- i += 3; // Additional increment to account for the extra 3 vertices we consumed.
- continue;
- }
- }
- if (isTriangleUniformColor && doesTriangleUseOnlyColor)
- {
- DrawUniformColorTriangle(v0, v1, v2);
- }
- else
- {
- // Currently we assume that any non rectangular texture samples the font texture. Dunno if that's what actually happens, but it seems to work.
- assert(isWrappedTexture);
- DrawTriangle(v0, v1, v2, static_cast<const Texture*>(drawCommand->TextureId));
- }
- }
- }
- indexBuffer += drawCommand->ElemCount;
- }
- }
- CurrentDevice->DisableClip();
- SDL_SetRenderTarget(CurrentDevice->Renderer, initialRenderTarget);
- SDL_RenderSetClipRect(CurrentDevice->Renderer, initialClipEnabled ? &initialClipRect : nullptr);
- SDL_SetRenderDrawColor(CurrentDevice->Renderer,
- initialR, initialG, initialB, initialA);
- SDL_SetRenderDrawBlendMode(CurrentDevice->Renderer, blendMode);
- }
- }
|