|
|
@@ -98,7 +98,8 @@ IMGUI_API int ImTextCountUtf8BytesFromStr(const ImWchar* in_text, cons
|
|
|
IMGUI_API ImU32 ImHash(const void* data, int data_size, ImU32 seed = 0); // Pass data_size==0 for zero-terminated strings
|
|
|
IMGUI_API void* ImFileLoadToMemory(const char* filename, const char* file_open_mode, size_t* out_file_size = NULL, int padding_bytes = 0);
|
|
|
IMGUI_API FILE* ImFileOpen(const char* filename, const char* file_open_mode);
|
|
|
-static inline bool ImCharIsSpace(unsigned int c) { return c == ' ' || c == '\t' || c == 0x3000; }
|
|
|
+static inline bool ImCharIsBlankA(char c) { return c == ' ' || c == '\t'; }
|
|
|
+static inline bool ImCharIsBlankW(unsigned int c) { return c == ' ' || c == '\t' || c == 0x3000; }
|
|
|
static inline bool ImIsPowerOfTwo(int v) { return v != 0 && (v & (v - 1)) == 0; }
|
|
|
static inline int ImUpperPowerOfTwo(int v) { v--; v |= v >> 1; v |= v >> 2; v |= v >> 4; v |= v >> 8; v |= v >> 16; v++; return v; }
|
|
|
|
|
|
@@ -117,11 +118,17 @@ IMGUI_API const char* ImStrchrRange(const char* str_begin, const char* str_end
|
|
|
IMGUI_API int ImStrlenW(const ImWchar* str);
|
|
|
IMGUI_API const ImWchar*ImStrbolW(const ImWchar* buf_mid_line, const ImWchar* buf_begin); // Find beginning-of-line
|
|
|
IMGUI_API const char* ImStristr(const char* haystack, const char* haystack_end, const char* needle, const char* needle_end);
|
|
|
+IMGUI_API void ImStrTrimBlanks(char* str);
|
|
|
IMGUI_API int ImFormatString(char* buf, size_t buf_size, const char* fmt, ...) IM_FMTARGS(3);
|
|
|
IMGUI_API int ImFormatStringV(char* buf, size_t buf_size, const char* fmt, va_list args) IM_FMTLIST(3);
|
|
|
-
|
|
|
-// Helpers: Math
|
|
|
-// We are keeping those not leaking to the user by default, in the case the user has implicit cast operators between ImVec2 and its own types (when IM_VEC2_CLASS_EXTRA is defined)
|
|
|
+IMGUI_API const char* ImParseFormatFindStart(const char* format);
|
|
|
+IMGUI_API const char* ImParseFormatFindEnd(const char* format);
|
|
|
+IMGUI_API const char* ImParseFormatTrimDecorations(const char* format, char* buf, int buf_size);
|
|
|
+IMGUI_API int ImParseFormatPrecision(const char* format, int default_value);
|
|
|
+
|
|
|
+// Helpers: ImVec2/ImVec4 operators
|
|
|
+// We are keeping those disabled by default so they don't leak in user space, to allow user enabling implicit cast operators between ImVec2 and their own types (using IM_VEC2_CLASS_EXTRA etc.)
|
|
|
+// We unfortunately don't have a unary- operator for ImVec2 because this would needs to be defined inside the class itself.
|
|
|
#ifdef IMGUI_DEFINE_MATH_OPERATORS
|
|
|
static inline ImVec2 operator*(const ImVec2& lhs, const float rhs) { return ImVec2(lhs.x*rhs, lhs.y*rhs); }
|
|
|
static inline ImVec2 operator/(const ImVec2& lhs, const float rhs) { return ImVec2(lhs.x/rhs, lhs.y/rhs); }
|
|
|
@@ -138,23 +145,19 @@ static inline ImVec4 operator-(const ImVec4& lhs, const ImVec4& rhs)
|
|
|
static inline ImVec4 operator*(const ImVec4& lhs, const ImVec4& rhs) { return ImVec4(lhs.x*rhs.x, lhs.y*rhs.y, lhs.z*rhs.z, lhs.w*rhs.w); }
|
|
|
#endif
|
|
|
|
|
|
-static inline int ImMin(int lhs, int rhs) { return lhs < rhs ? lhs : rhs; }
|
|
|
-static inline int ImMax(int lhs, int rhs) { return lhs >= rhs ? lhs : rhs; }
|
|
|
-static inline float ImMin(float lhs, float rhs) { return lhs < rhs ? lhs : rhs; }
|
|
|
-static inline float ImMax(float lhs, float rhs) { return lhs >= rhs ? lhs : rhs; }
|
|
|
+// Helpers: Maths
|
|
|
+template<typename T> static inline T ImMin(T lhs, T rhs) { return lhs < rhs ? lhs : rhs; }
|
|
|
+template<typename T> static inline T ImMax(T lhs, T rhs) { return lhs >= rhs ? lhs : rhs; }
|
|
|
+template<typename T> static inline T ImClamp(T v, T mn, T mx) { return (v < mn) ? mn : (v > mx) ? mx : v; }
|
|
|
+template<typename T> static inline T ImLerp(T a, T b, float t) { return (T)(a + (b - a) * t); }
|
|
|
+template<typename T> static inline void ImSwap(T& a, T& b) { T tmp = a; a = b; b = tmp; }
|
|
|
static inline ImVec2 ImMin(const ImVec2& lhs, const ImVec2& rhs) { return ImVec2(lhs.x < rhs.x ? lhs.x : rhs.x, lhs.y < rhs.y ? lhs.y : rhs.y); }
|
|
|
static inline ImVec2 ImMax(const ImVec2& lhs, const ImVec2& rhs) { return ImVec2(lhs.x >= rhs.x ? lhs.x : rhs.x, lhs.y >= rhs.y ? lhs.y : rhs.y); }
|
|
|
-static inline int ImClamp(int v, int mn, int mx) { return (v < mn) ? mn : (v > mx) ? mx : v; }
|
|
|
-static inline float ImClamp(float v, float mn, float mx) { return (v < mn) ? mn : (v > mx) ? mx : v; }
|
|
|
-static inline ImVec2 ImClamp(const ImVec2& f, const ImVec2& mn, ImVec2 mx) { return ImVec2(ImClamp(f.x,mn.x,mx.x), ImClamp(f.y,mn.y,mx.y)); }
|
|
|
-static inline float ImSaturate(float f) { return (f < 0.0f) ? 0.0f : (f > 1.0f) ? 1.0f : f; }
|
|
|
-static inline void ImSwap(int& a, int& b) { int tmp = a; a = b; b = tmp; }
|
|
|
-static inline void ImSwap(float& a, float& b) { float tmp = a; a = b; b = tmp; }
|
|
|
-static inline int ImLerp(int a, int b, float t) { return (int)(a + (b - a) * t); }
|
|
|
-static inline float ImLerp(float a, float b, float t) { return a + (b - a) * t; }
|
|
|
+static inline ImVec2 ImClamp(const ImVec2& v, const ImVec2& mn, ImVec2 mx) { return ImVec2((v.x < mn.x) ? mn.x : (v.x > mx.x) ? mx.x : v.x, (v.y < mn.y) ? mn.y : (v.y > mx.y) ? mx.y : v.y); }
|
|
|
static inline ImVec2 ImLerp(const ImVec2& a, const ImVec2& b, float t) { return ImVec2(a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t); }
|
|
|
static inline ImVec2 ImLerp(const ImVec2& a, const ImVec2& b, const ImVec2& t) { return ImVec2(a.x + (b.x - a.x) * t.x, a.y + (b.y - a.y) * t.y); }
|
|
|
static inline ImVec4 ImLerp(const ImVec4& a, const ImVec4& b, float t) { return ImVec4(a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t, a.z + (b.z - a.z) * t, a.w + (b.w - a.w) * t); }
|
|
|
+static inline float ImSaturate(float f) { return (f < 0.0f) ? 0.0f : (f > 1.0f) ? 1.0f : f; }
|
|
|
static inline float ImLengthSqr(const ImVec2& lhs) { return lhs.x*lhs.x + lhs.y*lhs.y; }
|
|
|
static inline float ImLengthSqr(const ImVec4& lhs) { return lhs.x*lhs.x + lhs.y*lhs.y + lhs.z*lhs.z + lhs.w*lhs.w; }
|
|
|
static inline float ImInvLength(const ImVec2& lhs, float fail_value) { float d = lhs.x*lhs.x + lhs.y*lhs.y; if (d > 0.0f) return 1.0f / sqrtf(d); return fail_value; }
|
|
|
@@ -164,6 +167,10 @@ static inline float ImDot(const ImVec2& a, const ImVec2& b)
|
|
|
static inline ImVec2 ImRotate(const ImVec2& v, float cos_a, float sin_a) { return ImVec2(v.x * cos_a - v.y * sin_a, v.x * sin_a + v.y * cos_a); }
|
|
|
static inline float ImLinearSweep(float current, float target, float speed) { if (current < target) return ImMin(current + speed, target); if (current > target) return ImMax(current - speed, target); return current; }
|
|
|
static inline ImVec2 ImMul(const ImVec2& lhs, const ImVec2& rhs) { return ImVec2(lhs.x * rhs.x, lhs.y * rhs.y); }
|
|
|
+static inline float ImPow(float x, float y) { return powf(x, y); }
|
|
|
+static inline double ImPow(double x, double y) { return pow(x, y); }
|
|
|
+static inline float ImFmod(float x, float y) { return fmodf(x, y); }
|
|
|
+static inline double ImFmod(double x, double y) { return fmod(x, y); }
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
// Types
|
|
|
@@ -244,15 +251,6 @@ enum ImGuiPlotType
|
|
|
ImGuiPlotType_Histogram
|
|
|
};
|
|
|
|
|
|
-enum ImGuiDataType
|
|
|
-{
|
|
|
- ImGuiDataType_Int32,
|
|
|
- ImGuiDataType_Uint32,
|
|
|
- ImGuiDataType_Float,
|
|
|
- ImGuiDataType_Double,
|
|
|
- ImGuiDataType_COUNT
|
|
|
-};
|
|
|
-
|
|
|
enum ImGuiInputSource
|
|
|
{
|
|
|
ImGuiInputSource_None = 0,
|
|
|
@@ -664,11 +662,9 @@ struct ImGuiContext
|
|
|
ImGuiID ScalarAsInputTextId; // Temporary text input when CTRL+clicking on a slider, etc.
|
|
|
ImGuiColorEditFlags ColorEditOptions; // Store user options for color edit widgets
|
|
|
ImVec4 ColorPickerRef;
|
|
|
- float DragCurrentValue; // Currently dragged value, always float, not rounded by end-user precision settings
|
|
|
- ImVec2 DragLastMouseDelta;
|
|
|
+ bool DragCurrentAccumDirty;
|
|
|
+ float DragCurrentAccum; // Accumulator for dragging modification. Always high-precision, not rounded by end-user precision settings
|
|
|
float DragSpeedDefaultRatio; // If speed == 0.0f, uses (max-min) * DragSpeedDefaultRatio
|
|
|
- float DragSpeedScaleSlow;
|
|
|
- float DragSpeedScaleFast;
|
|
|
ImVec2 ScrollbarClickDeltaToGrabCenter; // Distance between mouse and center of grab box, normalized in parent space. Use storage?
|
|
|
int TooltipOverrideCount;
|
|
|
ImVector<char> PrivateClipboard; // If no custom clipboard handler is defined
|
|
|
@@ -770,11 +766,9 @@ struct ImGuiContext
|
|
|
|
|
|
ScalarAsInputTextId = 0;
|
|
|
ColorEditOptions = ImGuiColorEditFlags__OptionsDefault;
|
|
|
- DragCurrentValue = 0.0f;
|
|
|
- DragLastMouseDelta = ImVec2(0.0f, 0.0f);
|
|
|
+ DragCurrentAccumDirty = false;
|
|
|
+ DragCurrentAccum = 0.0f;
|
|
|
DragSpeedDefaultRatio = 1.0f / 100.0f;
|
|
|
- DragSpeedScaleSlow = 1.0f / 100.0f;
|
|
|
- DragSpeedScaleFast = 10.0f;
|
|
|
ScrollbarClickDeltaToGrabCenter = ImVec2(0.0f, 0.0f);
|
|
|
TooltipOverrideCount = 0;
|
|
|
PlatformImePos = PlatformImeLastPos = ImVec2(FLT_MAX, FLT_MAX);
|
|
|
@@ -1098,18 +1092,10 @@ namespace ImGui
|
|
|
IMGUI_API bool ButtonEx(const char* label, const ImVec2& size_arg = ImVec2(0,0), ImGuiButtonFlags flags = 0);
|
|
|
IMGUI_API bool CloseButton(ImGuiID id, const ImVec2& pos, float radius);
|
|
|
|
|
|
- IMGUI_API bool SliderBehavior(const ImRect& frame_bb, ImGuiID id, float* v, float v_min, float v_max, const char* format, float power, ImGuiSliderFlags flags = 0);
|
|
|
- IMGUI_API bool SliderFloatN(const char* label, float* v, int components, float v_min, float v_max, const char* format, float power);
|
|
|
- IMGUI_API bool SliderIntN(const char* label, int* v, int components, int v_min, int v_max, const char* format);
|
|
|
-
|
|
|
- IMGUI_API bool DragBehavior(const ImRect& frame_bb, ImGuiID id, float* v, float v_speed, float v_min, float v_max, const char* format, float power);
|
|
|
- IMGUI_API bool DragFloatN(const char* label, float* v, int components, float v_speed, float v_min, float v_max, const char* format, float power);
|
|
|
- IMGUI_API bool DragIntN(const char* label, int* v, int components, float v_speed, int v_min, int v_max, const char* format);
|
|
|
+ IMGUI_API bool DragBehavior(ImGuiID id, ImGuiDataType data_type, void* v, float v_speed, const void* v_min, const void* v_max, const char* format, float power);
|
|
|
+ IMGUI_API bool SliderBehavior(const ImRect& bb, ImGuiID id, ImGuiDataType data_type, void* v, const void* v_min, const void* v_max, const char* format, float power, ImGuiSliderFlags flags = 0);
|
|
|
|
|
|
IMGUI_API bool InputTextEx(const char* label, char* buf, int buf_size, const ImVec2& size_arg, ImGuiInputTextFlags flags, ImGuiTextEditCallback callback = NULL, void* user_data = NULL);
|
|
|
- IMGUI_API bool InputFloatN(const char* label, float* v, int components, const char* format, ImGuiInputTextFlags extra_flags);
|
|
|
- IMGUI_API bool InputIntN(const char* label, int* v, int components, ImGuiInputTextFlags extra_flags);
|
|
|
- IMGUI_API bool InputScalarEx(const char* label, ImGuiDataType data_type, void* data_ptr, void* step_ptr, void* step_fast_ptr, const char* format, ImGuiInputTextFlags extra_flags = 0);
|
|
|
IMGUI_API bool InputScalarAsWidgetReplacement(const ImRect& bb, ImGuiID id, const char* label, ImGuiDataType data_type, void* data_ptr, const char* format);
|
|
|
|
|
|
IMGUI_API void ColorTooltip(const char* text, const float* col, ImGuiColorEditFlags flags);
|
|
|
@@ -1121,11 +1107,6 @@ namespace ImGui
|
|
|
|
|
|
IMGUI_API void PlotEx(ImGuiPlotType plot_type, const char* label, float (*values_getter)(void* data, int idx), void* data, int values_count, int values_offset, const char* overlay_text, float scale_min, float scale_max, ImVec2 graph_size);
|
|
|
|
|
|
- IMGUI_API const char* ParseFormatTrimDecorationsLeading(const char* format);
|
|
|
- IMGUI_API const char* ParseFormatTrimDecorations(const char* format, char* buf, int buf_size);
|
|
|
- IMGUI_API int ParseFormatPrecision(const char* format, int default_value);
|
|
|
- IMGUI_API float RoundScalarWithFormat(const char* format, float value);
|
|
|
-
|
|
|
// Shade functions (write over already created vertices)
|
|
|
IMGUI_API void ShadeVertsLinearColorGradientKeepAlpha(ImDrawVert* vert_start, ImDrawVert* vert_end, ImVec2 gradient_p0, ImVec2 gradient_p1, ImU32 col0, ImU32 col1);
|
|
|
IMGUI_API void ShadeVertsLinearAlphaGradientForLeftToRightText(ImDrawVert* vert_start, ImDrawVert* vert_end, float gradient_p0_x, float gradient_p1_x);
|
omar