|
|
@@ -1176,7 +1176,7 @@ namespace ImGui
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
|
|
// Lightweight std::vector<> like class to avoid dragging dependencies (also: Windows implementation of STL with debug enabled is absurdly slow, so let's bypass it so our code runs fast in debug).
|
|
|
-// Our implementation does NOT call C++ constructors/destructors. This is intentional and we do not require it. Do not use this class as a straight std::vector replacement in your code!
|
|
|
+// *Important* Our implementation does NOT call C++ constructors/destructors. This is intentional, we do not require it but you have to be mindful of that. Do not use this class as a straight std::vector replacement in your code!
|
|
|
template<typename T>
|
|
|
class ImVector
|
|
|
{
|
|
|
@@ -1191,6 +1191,8 @@ public:
|
|
|
|
|
|
inline ImVector() { Size = Capacity = 0; Data = NULL; }
|
|
|
inline ~ImVector() { if (Data) ImGui::MemFree(Data); }
|
|
|
+ inline ImVector(const ImVector<T>& src) { Size = Capacity = 0; Data = NULL; operator=(src); }
|
|
|
+ inline ImVector& operator=(const ImVector<T>& src) { clear(); resize(src.Size); memcpy(Data, src.Data, (size_t)Size * sizeof(value_type)); return *this; }
|
|
|
|
|
|
inline bool empty() const { return Size == 0; }
|
|
|
inline int size() const { return Size; }
|
|
|
@@ -1207,25 +1209,25 @@ public:
|
|
|
inline const value_type& front() const { IM_ASSERT(Size > 0); return Data[0]; }
|
|
|
inline value_type& back() { IM_ASSERT(Size > 0); return Data[Size - 1]; }
|
|
|
inline const value_type& back() const { IM_ASSERT(Size > 0); return Data[Size - 1]; }
|
|
|
- inline void swap(ImVector<T>& rhs) { int rhs_size = rhs.Size; rhs.Size = Size; Size = rhs_size; int rhs_cap = rhs.Capacity; rhs.Capacity = Capacity; Capacity = rhs_cap; value_type* rhs_data = rhs.Data; rhs.Data = Data; Data = rhs_data; }
|
|
|
+ inline void swap(ImVector<value_type>& rhs) { int rhs_size = rhs.Size; rhs.Size = Size; Size = rhs_size; int rhs_cap = rhs.Capacity; rhs.Capacity = Capacity; Capacity = rhs_cap; value_type* rhs_data = rhs.Data; rhs.Data = Data; Data = rhs_data; }
|
|
|
|
|
|
inline int _grow_capacity(int sz) const { int new_capacity = Capacity ? (Capacity + Capacity/2) : 8; return new_capacity > sz ? new_capacity : sz; }
|
|
|
inline void resize(int new_size) { if (new_size > Capacity) reserve(_grow_capacity(new_size)); Size = new_size; }
|
|
|
- inline void resize(int new_size, const T& v) { if (new_size > Capacity) reserve(_grow_capacity(new_size)); if (new_size > Size) for (int n = Size; n < new_size; n++) Data[n] = v; Size = new_size; }
|
|
|
+ inline void resize(int new_size,const value_type& v){ if (new_size > Capacity) reserve(_grow_capacity(new_size)); if (new_size > Size) for (int n = Size; n < new_size; n++) memcpy(&Data[n], &v, sizeof(v)); Size = new_size; }
|
|
|
inline void reserve(int new_capacity)
|
|
|
{
|
|
|
if (new_capacity <= Capacity)
|
|
|
return;
|
|
|
- T* new_data = (value_type*)ImGui::MemAlloc((size_t)new_capacity * sizeof(T));
|
|
|
+ value_type* new_data = (value_type*)ImGui::MemAlloc((size_t)new_capacity * sizeof(value_type));
|
|
|
if (Data)
|
|
|
- memcpy(new_data, Data, (size_t)Size * sizeof(T));
|
|
|
+ memcpy(new_data, Data, (size_t)Size * sizeof(value_type));
|
|
|
ImGui::MemFree(Data);
|
|
|
Data = new_data;
|
|
|
Capacity = new_capacity;
|
|
|
}
|
|
|
|
|
|
// NB: &v cannot be pointing inside the ImVector Data itself! e.g. v.push_back(v[10]) is forbidden.
|
|
|
- inline void push_back(const value_type& v) { if (Size == Capacity) reserve(_grow_capacity(Size + 1)); Data[Size++] = v; }
|
|
|
+ inline void push_back(const value_type& v) { if (Size == Capacity) reserve(_grow_capacity(Size + 1)); memcpy(&Data[Size], &v, sizeof(v)); Size++; }
|
|
|
inline void pop_back() { IM_ASSERT(Size > 0); Size--; }
|
|
|
inline void push_front(const value_type& v) { if (Size == 0) push_back(v); else insert(Data, v); }
|
|
|
inline iterator erase(const_iterator it) { IM_ASSERT(it >= Data && it < Data+Size); const ptrdiff_t off = it - Data; memmove(Data + off, Data + off + 1, ((size_t)Size - (size_t)off - 1) * sizeof(value_type)); Size--; return Data + off; }
|
|
|
@@ -1635,6 +1637,7 @@ struct ImDrawList
|
|
|
// Advanced
|
|
|
IMGUI_API void AddCallback(ImDrawCallback callback, void* callback_data); // Your rendering function must check for 'UserCallback' in ImDrawCmd and call the function instead of rendering triangles.
|
|
|
IMGUI_API void AddDrawCmd(); // This is useful if you need to forcefully create a new draw call (to allow for dependent rendering / blending). Otherwise primitives are merged into the same draw-call as much as possible
|
|
|
+ IMGUI_API ImDrawList* CloneOutput() const; // Create a clone of the CmdBuffer/IdxBuffer/VtxBuffer.
|
|
|
|
|
|
// Internal helpers
|
|
|
// NB: all primitives needs to be reserved via PrimReserve() beforehand!
|
|
|
@@ -1652,21 +1655,23 @@ struct ImDrawList
|
|
|
};
|
|
|
|
|
|
// All draw data to render an ImGui frame
|
|
|
+// (NB: the style and the naming convention here is a little inconsistent but we preserve them for backward compatibility purpose)
|
|
|
struct ImDrawData
|
|
|
{
|
|
|
bool Valid; // Only valid after Render() is called and before the next NewFrame() is called.
|
|
|
- ImDrawList** CmdLists;
|
|
|
- int CmdListsCount;
|
|
|
- int TotalVtxCount; // For convenience, sum of all cmd_lists vtx_buffer.Size
|
|
|
- int TotalIdxCount; // For convenience, sum of all cmd_lists idx_buffer.Size
|
|
|
+ ImDrawList** CmdLists; // Array of ImDrawList* to render. The ImDrawList are owned by ImGuiContext and only pointed to from here.
|
|
|
+ int CmdListsCount; // Number of ImDrawList* to render
|
|
|
+ int TotalIdxCount; // For convenience, sum of all ImDrawList's IdxBuffer.Size
|
|
|
+ int TotalVtxCount; // For convenience, sum of all ImDrawList's VtxBuffer.Size
|
|
|
ImVec2 DisplayPos; // Virtual upper-left position of the viewport to render (== ImVec2(0,0) for the main viewport == upper-left of the orthogonal projection matrix to use)
|
|
|
ImVec2 DisplaySize; // Size of the viewport to render (== io.DisplaySize for the main viewport) (DisplayPos + DisplaySize == lower-right of the orthogonal projection matrix to use)
|
|
|
|
|
|
// Functions
|
|
|
- ImDrawData() { Clear(); }
|
|
|
- void Clear() { Valid = false; CmdLists = NULL; CmdListsCount = TotalVtxCount = TotalIdxCount = 0; DisplayPos = DisplaySize = ImVec2(0.f, 0.f); } // Draw lists are owned by the ImGuiContext and only pointed to here.
|
|
|
- IMGUI_API void DeIndexAllBuffers(); // Convenience: convert all buffers from indexed to non-indexed, in case you cannot render indexed. Note: this is slow and most likely a waste of resources. Always prefer indexed rendering!
|
|
|
- IMGUI_API void ScaleClipRects(const ImVec2& sc); // Helper to scale the ClipRect field of each ImDrawCmd. Use if your final output buffer is at a different scale than ImGui expects, or if there is a difference between your window resolution and framebuffer resolution.
|
|
|
+ ImDrawData() { Valid = false; Clear(); }
|
|
|
+ ~ImDrawData() { Clear(); }
|
|
|
+ void Clear() { Valid = false; CmdLists = NULL; CmdListsCount = TotalVtxCount = TotalIdxCount = 0; DisplayPos = DisplaySize = ImVec2(0.f, 0.f); } // The ImDrawList are owned by ImGuiContext!
|
|
|
+ IMGUI_API void DeIndexAllBuffers(); // Helper to convert all buffers from indexed to non-indexed, in case you cannot render indexed. Note: this is slow and most likely a waste of resources. Always prefer indexed rendering!
|
|
|
+ IMGUI_API void ScaleClipRects(const ImVec2& sc); // Helper to scale the ClipRect field of each ImDrawCmd. Use if your final output buffer is at a different scale than ImGui expects, or if there is a difference between your window resolution and framebuffer resolution.
|
|
|
};
|
|
|
|
|
|
struct ImFontConfig
|
omar