| local imgui = require 'mimgui' |
| local ffi = require 'ffi' |
|
|
| |
| local M = {} |
| setmetatable(M, { |
| __index = function(self, index) |
| if index == '_AUTHOR' then |
| return 'Cosmo' |
| elseif index == '_VERSION' then |
| return '1.0' |
| end |
| end |
| }) |
|
|
| |
| local AI_HINTS = {} |
| local AI_MATERIAL = {} |
| local AI_ANIMBUT = {} |
| local AI_TOGGLE = {} |
| local AI_PICTURE = {} |
| local AI_HEADERBUT = {} |
| local AI_PAGE = {} |
|
|
| |
| local ToU32 = imgui.ColorConvertFloat4ToU32 |
| local ToVEC = imgui.ColorConvertU32ToFloat4 |
|
|
| function limit(v, min, max) |
| min = min or 0.0 |
| max = max or 1.0 |
| return v < min and min or (v > max and max or v) |
| end |
|
|
| function bringVec4To(from, to, start_time, duration) |
| local timer = os.clock() - start_time |
| if timer >= 0.00 and timer <= duration then |
| local count = timer / (duration / 100) |
| return imgui.ImVec4( |
| from.x + (count * (to.x - from.x) / 100), |
| from.y + (count * (to.y - from.y) / 100), |
| from.z + (count * (to.z - from.z) / 100), |
| from.w + (count * (to.w - from.w) / 100) |
| ), true |
| end |
| return (timer > duration) and to or from, false |
| end |
|
|
| function bringVec2To(from, to, start_time, duration) |
| local timer = os.clock() - start_time |
| if timer >= 0.00 and timer <= duration then |
| local count = timer / (duration / 100) |
| return imgui.ImVec2( |
| from.x + (count * (to.x - from.x) / 100), |
| from.y + (count * (to.y - from.y) / 100) |
| ), true |
| end |
| return (timer > duration) and to or from, false |
| end |
|
|
| function bringFloatTo(from, to, start_time, duration) |
| local timer = os.clock() - start_time |
| if timer >= 0.00 and timer <= duration then |
| local count = timer / (duration / 100) |
| return from + (count * (to - from) / 100), true |
| end |
| return (timer > duration) and to or from, false |
| end |
|
|
| function isPlaceHovered(a, b) |
| local m = imgui.GetMousePos() |
| if m.x >= a.x and m.y >= a.y then |
| if m.x <= b.x and m.y <= b.y then |
| return true |
| end |
| end |
| return false |
| end |
|
|
| function getContrastColor(bg_col, col_1, col_2) |
| col_1 = col_1 or imgui.ImVec4(0.00, 0.00, 0.00, 1.00) |
| col_2 = col_2 or imgui.ImVec4(1.00, 1.00, 1.00, 1.00) |
| local luminance = 1 - (0.299 * bg_col.x + 0.587 * bg_col.y + 0.114 * bg_col.z) |
| return luminance < 0.5 and col_1 or col_2 |
| end |
|
|
| function set_alpha(color, alpha) |
| alpha = alpha and limit(alpha, 0.0, 1.0) or 1.0 |
| return imgui.ImVec4(color.x, color.y, color.z, alpha) |
| end |
|
|
| M.limit = limit |
| M.bringVec4To = bringVec4To |
| M.bringVec2To = bringVec2To |
| M.bringFloatTo = bringFloatTo |
| M.isPlaceHovered = isPlaceHovered |
| M.getContrastColor = getContrastColor |
| M.set_alpha = set_alpha |
|
|
| |
| M.MaterialButton = function(str_id, size, duration) |
| if type(duration) ~= 'table' then |
| duration = { 0.4, 0.2, 0.4 } |
| end |
| local cols = { |
| default = imgui.ImVec4(imgui.GetStyle().Colors[imgui.Col.Button]), |
| hovered = imgui.ImVec4(imgui.GetStyle().Colors[imgui.Col.ButtonHovered]), |
| active = imgui.ImVec4(imgui.GetStyle().Colors[imgui.Col.ButtonActive]), |
| window = imgui.ImVec4(imgui.GetStyle().Colors[imgui.Col.WindowBg]) |
| } |
|
|
| local result = false |
| local rounding = imgui.GetStyle().FrameRounding |
| local label = string.gsub(str_id, "##.*$", "") |
| local text_size = imgui.CalcTextSize(label) |
| if not size then |
| local pad = imgui.GetStyle().FramePadding |
| size = imgui.ImVec2(text_size.x + (pad.x * 2), text_size.y + (pad.y * 2)) |
| end |
|
|
| if not AI_MATERIAL[str_id] then |
| AI_MATERIAL[str_id] = { |
| hovered = { |
| state = false, |
| before = nil, |
| clock = 0, |
| color = cols.hovered |
| }, |
| radius = 0, |
| clock = {0, 0}, |
| pos = nil, |
| size = nil |
| } |
| end |
|
|
| local pool = AI_MATERIAL[str_id] |
| local p = imgui.GetCursorScreenPos() |
| if pool['size'] ~= nil then |
| local DL = imgui.GetWindowDrawList() |
| local s = pool['size'] |
|
|
| if os.clock() - pool['hovered']['clock'] <= duration[3] then |
| local start_time = pool['hovered']['clock'] |
| if pool['hovered']['state'] then |
| pool['hovered']['color'] = bringVec4To(pool['hovered']['color'], cols.active, start_time, duration[3]) |
| else |
| pool['hovered']['color'] = bringVec4To(pool['hovered']['color'], cols.hovered, start_time, duration[3]) |
| end |
| elseif pool['hovered']['state'] then |
| pool['hovered']['color'] = cols.active |
| end |
|
|
| DL:AddRect( |
| p, |
| imgui.ImVec2(p.x + s.x, p.y + s.y), |
| ToU32(pool['hovered']['color']), |
| rounding, |
| 15 |
| ) |
| end |
|
|
| imgui.PushStyleVarFloat(imgui.StyleVar.ChildRounding, rounding) |
| imgui.PushStyleColor(imgui.Col.ChildBg, cols.default) |
| local pos = imgui.GetCursorPos() |
| imgui.SetCursorPos(imgui.ImVec2(pos.x + 1, pos.y + 1)) |
| imgui.BeginChild(str_id .. "_ANIMBUTTON", imgui.ImVec2(size.x - 2, size.y - 2), false) |
| local DL = imgui.GetWindowDrawList() |
| if pool['pos'] ~= nil then |
| local alpha = 0.00 |
|
|
| local timer = os.clock() - pool['clock'][2] |
| if timer <= duration[2] then |
| alpha = limit(1.00 - ((1.00 / duration[2]) * timer), 0.0, 1.0) |
| end |
|
|
| local timer = os.clock() - pool['clock'][1] |
| if timer <= duration[1] then |
| alpha = limit((1.00 / duration[1]) * timer, 0.0, 1.0) |
| pool['radius'] = (size.x * 1.5 / duration[1]) * timer |
| end |
|
|
| local col = imgui.GetStyle().Colors[imgui.Col.ButtonActive] |
| DL:AddCircleFilled( |
| pool['pos'], |
| pool['radius'], |
| ToU32(imgui.ImVec4(col.x, col.y, col.z, alpha)), |
| 64 |
| ) |
|
|
| local a, b = p, imgui.ImVec2(p.x + pool['size'].x, p.y + pool['size'].y) |
| local color = ToU32(cols.window) |
|
|
| DL:PathLineTo(a) |
| DL:PathArcTo(imgui.ImVec2(a.x + rounding, a.y + rounding), rounding, -3.0, -1.500) |
| DL:PathFillConvex(color) |
|
|
| DL:PathLineTo(imgui.ImVec2(b.x, a.y)) |
| DL:PathArcTo(imgui.ImVec2(b.x - rounding, a.y + rounding), rounding, -1.5, -0.205) |
| DL:PathFillConvex(color) |
|
|
| DL:PathLineTo(imgui.ImVec2(b.x, b.y)) |
| DL:PathArcTo(imgui.ImVec2(b.x - rounding, b.y - rounding), rounding, 1.5, 0.205) |
| DL:PathFillConvex(color) |
|
|
| DL:PathLineTo(imgui.ImVec2(a.x, b.y)) |
| DL:PathArcTo(imgui.ImVec2(a.x + rounding, b.y - rounding), rounding, 3.0, 1.500) |
| DL:PathFillConvex(color) |
|
|
| if alpha <= 0 then pool['pos'] = nil end |
| end |
|
|
| local ws, al = imgui.GetWindowSize(), imgui.GetStyle().ButtonTextAlign |
| imgui.SetCursorPos(imgui.ImVec2((ws.x - text_size.x) * al.x, (ws.y - text_size.y) * al.y)) |
| imgui.TextUnformatted(label) |
| imgui.EndChild() |
| imgui.PopStyleColor() |
| imgui.PopStyleVar() |
|
|
| local size = imgui.GetItemRectSize() |
| pool['size'] = imgui.ImVec2(size.x + 2, size.y + 2) |
| pool['hovered']['state'] = imgui.IsItemHovered() or os.clock() - pool['clock'][2] < 0 |
| if pool['hovered']['state'] ~= pool['hovered']['before'] then |
| pool['hovered']['before'] = pool['hovered']['state'] |
| pool['hovered']['clock'] = os.clock() |
| end |
|
|
| if imgui.IsItemClicked() then |
| pool['radius'] = 0 |
| pool['pos'] = imgui.GetMousePos() |
| pool['clock'] = { |
| os.clock(), |
| os.clock() + duration[1] |
| } |
| result = true |
| end |
|
|
| return result |
| end |
|
|
| M.AnimButton = function(label, size, duration) |
| if type(duration) ~= 'table' then |
| duration = { 1.0, 0.3 } |
| end |
|
|
| local cols = { |
| default = imgui.ImVec4(imgui.GetStyle().Colors[imgui.Col.Button]), |
| hovered = imgui.ImVec4(imgui.GetStyle().Colors[imgui.Col.ButtonHovered]), |
| active = imgui.ImVec4(imgui.GetStyle().Colors[imgui.Col.ButtonActive]) |
| } |
|
|
| if not AI_ANIMBUT[label] then |
| AI_ANIMBUT[label] = { |
| color = cols.default, |
| clicked = { nil, nil }, |
| hovered = { |
| cur = false, |
| old = false, |
| clock = nil, |
| } |
| } |
| end |
| local pool = AI_ANIMBUT[label] |
|
|
| if pool['clicked'][1] and pool['clicked'][2] then |
| if os.clock() - pool['clicked'][1] <= duration[2] then |
| pool['color'] = bringVec4To( |
| pool['color'], |
| cols.active, |
| pool['clicked'][1], |
| duration[2] |
| ) |
| goto no_hovered |
| end |
|
|
| if os.clock() - pool['clicked'][2] <= duration[2] then |
| pool['color'] = bringVec4To( |
| pool['color'], |
| pool['hovered']['cur'] and cols.hovered or cols.default, |
| pool['clicked'][2], |
| duration[2] |
| ) |
| goto no_hovered |
| end |
| end |
|
|
| if pool['hovered']['clock'] ~= nil then |
| if os.clock() - pool['hovered']['clock'] <= duration[1] then |
| pool['color'] = bringVec4To( |
| pool['color'], |
| pool['hovered']['cur'] and cols.hovered or cols.default, |
| pool['hovered']['clock'], |
| duration[1] |
| ) |
| else |
| pool['color'] = pool['hovered']['cur'] and cols.hovered or cols.default |
| end |
| end |
|
|
| ::no_hovered:: |
|
|
| imgui.PushStyleColor(imgui.Col.Button, imgui.ImVec4(pool['color'])) |
| imgui.PushStyleColor(imgui.Col.ButtonHovered, imgui.ImVec4(pool['color'])) |
| imgui.PushStyleColor(imgui.Col.ButtonActive, imgui.ImVec4(pool['color'])) |
| local result = imgui.Button(label, size or imgui.ImVec2(0, 0)) |
| imgui.PopStyleColor(3) |
|
|
| if result then |
| pool['clicked'] = { |
| os.clock(), |
| os.clock() + duration[2] |
| } |
| end |
|
|
| pool['hovered']['cur'] = imgui.IsItemHovered() |
| if pool['hovered']['old'] ~= pool['hovered']['cur'] then |
| pool['hovered']['old'] = pool['hovered']['cur'] |
| pool['hovered']['clock'] = os.clock() |
| end |
|
|
| return result |
| end |
|
|
| M.CloseButton = function(str_id, value, size, rounding) |
| size = size or 40 |
| rounding = rounding or 5 |
| local DL = imgui.GetWindowDrawList() |
| local p = imgui.GetCursorScreenPos() |
| |
| local result = imgui.InvisibleButton(str_id, imgui.ImVec2(size, size)) |
| if result then |
| value[0] = false |
| end |
| local hovered = imgui.IsItemHovered() |
|
|
| local col = ToU32(imgui.GetStyle().Colors[imgui.Col.Border]) |
| local col_bg = hovered and 0x50000000 or 0x30000000 |
| local offs = (size / 4) |
|
|
| DL:AddRectFilled(p, imgui.ImVec2(p.x + size, p.y + size), col_bg, rounding, 15) |
| DL:AddLine( |
| imgui.ImVec2(p.x + offs, p.y + offs), |
| imgui.ImVec2(p.x + size - offs, p.y + size - offs), |
| col, |
| size / 10 |
| ) |
| DL:AddLine( |
| imgui.ImVec2(p.x + size - offs, p.y + offs), |
| imgui.ImVec2(p.x + offs, p.y + size - offs), |
| col, |
| size / 10 |
| ) |
| return result |
| end |
|
|
| M.Hint = function(str_id, hint_text, color, no_center) |
| color = color or imgui.GetStyle().Colors[imgui.Col.PopupBg] |
| local p_orig = imgui.GetCursorPos() |
| local hovered = imgui.IsItemHovered() |
| imgui.SameLine(nil, 0) |
|
|
| local duration = 0.2 |
| local show = true |
|
|
| if not AI_HINTS[str_id] then |
| AI_HINTS[str_id] = { |
| status = false, |
| timer = 0 |
| } |
| end |
| local pool = AI_HINTS[str_id] |
|
|
| if hovered then |
| for k, v in pairs(AI_HINTS) do |
| if k ~= str_id and os.clock() - v.timer <= duration then |
| show = false |
| end |
| end |
| end |
|
|
| if show and pool.status ~= hovered then |
| pool.status = hovered |
| pool.timer = os.clock() |
| end |
|
|
| local rend_window = function(alpha) |
| local size = imgui.GetItemRectSize() |
| local scrPos = imgui.GetCursorScreenPos() |
| local DL = imgui.GetWindowDrawList() |
| local center = imgui.ImVec2( scrPos.x - (size.x / 2), scrPos.y + (size.y / 2) - (alpha * 4) + 10 ) |
| local a = imgui.ImVec2( center.x - 7, center.y - size.y - 3 ) |
| local b = imgui.ImVec2( center.x + 7, center.y - size.y - 3) |
| local c = imgui.ImVec2( center.x, center.y - size.y + 3 ) |
| local col = ToU32(imgui.ImVec4(color.x, color.y, color.z, alpha)) |
|
|
| DL:AddTriangleFilled(a, b, c, col) |
| imgui.SetNextWindowPos(imgui.ImVec2(center.x, center.y - size.y - 3), imgui.Cond.Always, imgui.ImVec2(0.5, 1.0)) |
| imgui.PushStyleColor(imgui.Col.PopupBg, color) |
| imgui.PushStyleColor(imgui.Col.Border, color) |
| imgui.PushStyleColor(imgui.Col.Text, getContrastColor(color)) |
| imgui.PushStyleVarVec2(imgui.StyleVar.WindowPadding, imgui.ImVec2(8, 8)) |
| imgui.PushStyleVarFloat(imgui.StyleVar.WindowRounding, 6) |
| imgui.PushStyleVarFloat(imgui.StyleVar.Alpha, alpha) |
|
|
| local max_width = function(text) |
| local result = 0 |
| for line in text:gmatch('[^\r\n]+') do |
| local len = imgui.CalcTextSize(line).x |
| if len > result then |
| result = len |
| end |
| end |
| return result |
| end |
|
|
| local hint_width = max_width(hint_text) + (imgui.GetStyle().WindowPadding.x * 2) |
| imgui.SetNextWindowSize(imgui.ImVec2(hint_width, -1), imgui.Cond.Always) |
| imgui.Begin('##' .. str_id, _, imgui.WindowFlags.Tooltip + imgui.WindowFlags.NoResize + imgui.WindowFlags.NoScrollbar + imgui.WindowFlags.NoTitleBar) |
| for line in hint_text:gmatch('[^\r\n]+') do |
| if no_center then |
| imgui.Text(line) |
| else |
| imgui.SetCursorPosX((hint_width - imgui.CalcTextSize(line).x) / 2) |
| imgui.Text(line) |
| end |
| end |
| imgui.End() |
|
|
| imgui.PopStyleVar(3) |
| imgui.PopStyleColor(3) |
| end |
|
|
| if show then |
| local between = os.clock() - pool.timer |
| if between <= duration then |
| local alpha = hovered and limit(between / duration, 0.0, 1.0) or limit(1.00 - between / duration, 0.0, 1.0) |
| rend_window(alpha) |
| elseif hovered then |
| rend_window(1.00) |
| end |
| end |
|
|
| imgui.SetCursorPos(p_orig) |
| end |
|
|
| M.AlignedText = function(text, align, color) |
| color = color or imgui.GetStyle().Colors[imgui.Col.Text] |
| local width = imgui.GetWindowWidth() |
| for line in text:gmatch('[^\n]+') do |
| local lenght = imgui.CalcTextSize(line).x |
| if align == 2 then |
| imgui.SetCursorPosX((width - lenght) / 2) |
| elseif align == 3 then |
| imgui.SetCursorPosX(width - lenght - imgui.GetStyle().WindowPadding.x) |
| end |
| imgui.TextColored(color, line) |
| end |
| end |
|
|
| M.BeginTitleChild = function(str_id, size, thickness, flags) |
| thickness = thickness or 1 |
| local DL = imgui.GetWindowDrawList() |
| local title = str_id:gsub('##.*$', '') |
| local ts = imgui.CalcTextSize(title) |
| local bgColor = ToU32(imgui.GetStyle().Colors[imgui.Col.WindowBg]) |
| local bdColor = ToU32(imgui.GetStyle().Colors[imgui.Col.Border]) |
| local rounding = imgui.GetStyle().ChildRounding |
| local spacing = 5 |
| |
| local pos = imgui.GetCursorPos() |
| local wsize = imgui.GetWindowSize() |
| local padding = imgui.GetStyle().WindowPadding |
| if size.x == -1 then |
| size.x = wsize.x - pos.x - padding.x * 2 |
| end |
| if size.y == -1 then |
| size.y = wsize.y - pos.y - padding.y * 2 |
| end |
|
|
| local offset = (size.x - ts.x) / 10 |
| imgui.SetCursorPosY(pos.y + (ts.y / 2)) |
| local p = imgui.GetCursorScreenPos() |
| DL:AddRect(p, imgui.ImVec2(p.x + size.x, p.y + size.y), bdColor, rounding, 15, thickness) |
| DL:AddLine(imgui.ImVec2(p.x + offset, p.y), imgui.ImVec2(p.x + offset + ts.x + (spacing * 2), p.y), bgColor, thickness * 3) |
| DL:AddText(imgui.ImVec2(p.x + offset + spacing, p.y - (ts.y / 2)), bdColor, title) |
|
|
| imgui.PushStyleColor(imgui.Col.ChildBg, imgui.ImVec4(0, 0, 0, 0)) |
| imgui.PushStyleColor(imgui.Col.Border, imgui.ImVec4(0, 0, 0, 0)) |
| imgui.BeginChild(str_id, size, true, flags) |
| imgui.SetCursorPosY(imgui.GetCursorPos().y + (ts.y / 2)) |
| end |
|
|
| M.EndTitleChild = function() |
| imgui.EndChild() |
| imgui.PopStyleColor(2) |
| end |
|
|
| M.CircularProgressBar = function(value, radius, thickness, format) |
| local DL = imgui.GetWindowDrawList() |
| local p = imgui.GetCursorScreenPos() |
| local pos = imgui.GetCursorPos() |
| local ts = nil |
|
|
| if type(format) == 'string' then |
| format = string.format(format, value[0]) |
| ts = imgui.CalcTextSize(format) |
| end |
|
|
| local side = imgui.ImVec2( |
| radius * 2 + thickness, |
| radius * 2 + thickness + (ts and (ts.y + imgui.GetStyle().ItemSpacing.y) or 0) |
| ) |
| local centre = imgui.ImVec2(p.x + radius + (thickness / 2), p.y + radius + (thickness / 2)) |
|
|
| imgui.BeginGroup() |
| imgui.Dummy(side) |
|
|
| local corners = radius * 5 |
| local col_bg = ToU32(imgui.GetStyle().Colors[imgui.Col.FrameBg]) |
| local col = ToU32(imgui.GetStyle().Colors[imgui.Col.ButtonActive]) |
| local a1 = 90 - (360 / 100) * (value[0] / 2) |
| local a2 = 90 + (360 / 100) * (value[0] / 2) |
|
|
| DL:AddCircle(centre, radius, col_bg, corners, thickness / 2) |
| DL:PathClear() |
| DL:PathArcTo(centre, radius, math.rad(a1), math.rad(a2), corners) |
| DL:PathStroke(col, 0, thickness) |
|
|
| if format ~= nil then |
| imgui.SetCursorPos( |
| imgui.ImVec2( |
| pos.x + (side.x - ts.x) / 2, |
| pos.y + radius * 2 + thickness + imgui.GetStyle().FramePadding.y |
| ) |
| ) |
| imgui.Text(format) |
| end |
| imgui.EndGroup() |
| end |
|
|
| M.ToggleButton = function(str_id, value) |
| local duration = 0.3 |
| local p = imgui.GetCursorScreenPos() |
| local DL = imgui.GetWindowDrawList() |
| local size = imgui.ImVec2(40, 20) |
| local title = str_id:gsub('##.*$', '') |
| local ts = imgui.CalcTextSize(title) |
| local cols = { |
| enable = imgui.GetStyle().Colors[imgui.Col.ButtonActive], |
| disable = imgui.GetStyle().Colors[imgui.Col.TextDisabled] |
| } |
| local radius = 6 |
| local o = { |
| x = 4, |
| y = p.y + (size.y / 2) |
| } |
| local A = imgui.ImVec2(p.x + radius + o.x, o.y) |
| local B = imgui.ImVec2(p.x + size.x - radius - o.x, o.y) |
|
|
| if AI_TOGGLE[str_id] == nil then |
| AI_TOGGLE[str_id] = { |
| clock = nil, |
| color = value[0] and cols.enable or cols.disable, |
| pos = value[0] and B or A |
| } |
| end |
| local pool = AI_TOGGLE[str_id] |
| |
| imgui.BeginGroup() |
| local pos = imgui.GetCursorPos() |
| local result = imgui.InvisibleButton(str_id, imgui.ImVec2(size.x, size.y)) |
| if result then |
| value[0] = not value[0] |
| pool.clock = os.clock() |
| end |
| if #title > 0 then |
| local spc = imgui.GetStyle().ItemSpacing |
| imgui.SetCursorPos(imgui.ImVec2(pos.x + size.x + spc.x, pos.y + ((size.y - ts.y) / 2))) |
| imgui.Text(title) |
| end |
| imgui.EndGroup() |
|
|
| if pool.clock and os.clock() - pool.clock <= duration then |
| pool.color = bringVec4To( |
| imgui.ImVec4(pool.color), |
| value[0] and cols.enable or cols.disable, |
| pool.clock, |
| duration |
| ) |
|
|
| pool.pos = bringVec2To( |
| imgui.ImVec2(pool.pos), |
| value[0] and B or A, |
| pool.clock, |
| duration |
| ) |
| else |
| pool.color = value[0] and cols.enable or cols.disable |
| pool.pos = value[0] and B or A |
| end |
|
|
| DL:AddRect(p, imgui.ImVec2(p.x + size.x, p.y + size.y), ToU32(pool.color), 10, 15, 1) |
| DL:AddCircleFilled(pool.pos, radius, ToU32(pool.color)) |
|
|
| return result |
| end |
|
|
| M.Picture = function(str_id, image, size, mult, hint) |
| hint = hint or u8'��������� �����������' |
| mult = mult and limit(mult, 2, 10) or 5 |
| local duration = { 0.3, 1.0 } |
| local p = imgui.GetCursorScreenPos() |
| imgui.Image(image, imgui.ImVec2(size.x / mult, size.y / mult)) |
| local hovered = imgui.IsItemHovered() |
| local clicked = imgui.IsItemClicked(0) |
| local DL = imgui.GetWindowDrawList() |
| local ws, wh = getScreenResolution() |
| local s = imgui.GetItemRectSize() |
| local ts = imgui.CalcTextSize(hint) |
| local cols = { |
| bg = { |
| hovr = imgui.GetStyle().Colors[imgui.Col.ModalWindowDimBg], |
| idle = imgui.ImVec4(0.0, 0.0, 0.0, 0.0) |
| }, |
| t = { |
| hovr = imgui.GetStyle().Colors[imgui.Col.Text], |
| idle = imgui.ImVec4(0.0, 0.0, 0.0, 0.0) |
| } |
| } |
|
|
| if AI_PICTURE[str_id] == nil then |
| AI_PICTURE[str_id] = { |
| o = { |
| clock = nil, |
| alpha = 0 |
| }, |
| h = { |
| clock = nil, |
| before = false, |
| bg_col = hovered and cols.bg.hovr or cols.bg.idle, |
| t_col = hovered and cols.t.hovr or cols.t.idle |
| } |
| } |
| end |
| local pool = AI_PICTURE[str_id] |
|
|
| if hovered ~= pool.h.before then |
| pool.h.before = hovered |
| pool.h.clock = os.clock() |
| end |
|
|
| if clicked then |
| pool.o.state = true |
| pool.o.clock = os.clock() |
| end |
|
|
| if pool.o.clock ~= nil then |
| local bg_col |
| if os.clock() - pool.o.clock <= duration[2] then |
| local timer = (os.clock() - pool.o.clock) |
| local offset = (1.0 - pool.o.alpha) |
| pool.o.alpha = pool.o.alpha + ((offset / duration[2]) * timer) |
| bg_col = bringVec4To( |
| imgui.ImVec4(0, 0, 0, 0), |
| cols.bg.hovr, |
| pool.o.clock, |
| duration[2] |
| ) |
| else |
| pool.o.alpha = 1.0 |
| bg_col = cols.bg.hovr |
| end |
|
|
| local DL = imgui.GetForegroundDrawList() |
| local A = imgui.ImVec2((ws - size.x) / 2, (wh - size.y) / 2) |
| local B = imgui.ImVec2(A.x + size.x, A.y + size.y) |
|
|
| DL:AddRectFilled(imgui.ImVec2(0, 0), imgui.ImVec2(ws, wh), ToU32(bg_col)) |
| DL:AddImage(image, A, B, _, _, ToU32(imgui.ImVec4(1, 1, 1, pool.o.alpha))) |
|
|
| if imgui.IsMouseClicked(0) and pool.o.alpha >= 0.1 then |
| pool.o.alpha = 0.0 |
| pool.o.clock = nil |
| end |
| goto finish |
| end |
|
|
| if pool.h.clock ~= nil then |
| if os.clock() - pool.h.clock <= duration[1] then |
| pool.h.bg_col = bringVec4To( |
| imgui.ImVec4(pool.h.bg_col), |
| hovered and cols.bg.hovr or cols.bg.idle, |
| pool.h.clock, |
| duration[1] |
| ) |
| pool.h.t_col = bringVec4To( |
| imgui.ImVec4(pool.h.t_col), |
| hovered and cols.t.hovr or cols.t.idle, |
| pool.h.clock, |
| duration[1] |
| ) |
| else |
| pool.h.bg_col = hovered and cols.bg.hovr or cols.bg.idle |
| pool.h.t_col = hovered and cols.t.hovr or cols.t.idle |
| if not hovered then |
| pool.h.clock = nil |
| end |
| end |
| DL:AddRectFilled(p, imgui.ImVec2(p.x + s.x, p.y + s.y), ToU32(pool.h.bg_col)) |
| DL:AddText(imgui.ImVec2(p.x + (s.x - ts.x) / 2, p.y + (s.y - ts.y) / 2), ToU32(pool.h.t_col), hint) |
| end |
|
|
| ::finish:: |
| return clicked |
| end |
|
|
| M.PageButton = function(bool, icon, name, but_wide) |
| but_wide = but_wide or 190 |
| local duration = 0.25 |
| local DL = imgui.GetWindowDrawList() |
| local p1 = imgui.GetCursorScreenPos() |
| local p2 = imgui.GetCursorPos() |
| local col = imgui.GetStyle().Colors[imgui.Col.ButtonActive] |
| |
| if not AI_PAGE[name] then |
| AI_PAGE[name] = { clock = nil } |
| end |
| local pool = AI_PAGE[name] |
|
|
| imgui.PushStyleColor(imgui.Col.Button, imgui.ImVec4(0.00, 0.00, 0.00, 0.00)) |
| imgui.PushStyleColor(imgui.Col.ButtonHovered, imgui.ImVec4(0.00, 0.00, 0.00, 0.00)) |
| imgui.PushStyleColor(imgui.Col.ButtonActive, imgui.ImVec4(0.00, 0.00, 0.00, 0.00)) |
| local result = imgui.InvisibleButton(name, imgui.ImVec2(but_wide, 35)) |
| if result and not bool then |
| pool.clock = os.clock() |
| end |
| local pressed = imgui.IsItemActive() |
| imgui.PopStyleColor(3) |
| if bool then |
| if pool.clock and (os.clock() - pool.clock) < duration then |
| local wide = (os.clock() - pool.clock) * (but_wide / duration) |
| DL:AddRectFilled(imgui.ImVec2(p1.x, p1.y), imgui.ImVec2((p1.x + 190) - wide, p1.y + 35), 0x10FFFFFF, 15, 10) |
| DL:AddRectFilled(imgui.ImVec2(p1.x, p1.y), imgui.ImVec2(p1.x + 5, p1.y + 35), ToU32(col)) |
| DL:AddRectFilled(imgui.ImVec2(p1.x, p1.y), imgui.ImVec2(p1.x + wide, p1.y + 35), ToU32(imgui.ImVec4(col.x, col.y, col.z, 0.6)), 15, 10) |
| else |
| DL:AddRectFilled(imgui.ImVec2(p1.x, (pressed and p1.y + 3 or p1.y)), imgui.ImVec2(p1.x + 5, (pressed and p1.y + 32 or p1.y + 35)), ToU32(col)) |
| DL:AddRectFilled(imgui.ImVec2(p1.x, p1.y), imgui.ImVec2(p1.x + 190, p1.y + 35), ToU32(imgui.ImVec4(col.x, col.y, col.z, 0.6)), 15, 10) |
| end |
| else |
| if imgui.IsItemHovered() then |
| DL:AddRectFilled(imgui.ImVec2(p1.x, p1.y), imgui.ImVec2(p1.x + 190, p1.y + 35), 0x10FFFFFF, 15, 10) |
| end |
| end |
| imgui.SameLine(10); imgui.SetCursorPosY(p2.y + 8) |
| if bool then |
| imgui.Text((' '):rep(3) .. icon) |
| imgui.SameLine(60) |
| imgui.Text(name) |
| else |
| imgui.TextColored(imgui.ImVec4(0.60, 0.60, 0.60, 1.00), (' '):rep(3) .. icon) |
| imgui.SameLine(60) |
| imgui.TextColored(imgui.ImVec4(0.60, 0.60, 0.60, 1.00), name) |
| end |
| imgui.SetCursorPosY(p2.y + 40) |
| return result |
| end |
|
|
| M.StateButton = function(bool, ...) |
| if bool then |
| return imgui.Button(...) |
| else |
| local but_col = imgui.GetStyle().Colors[imgui.Col.Button] |
| imgui.PushStyleColor(imgui.Col.Text, imgui.GetStyle().Colors[imgui.Col.TextDisabled]) |
| imgui.PushStyleColor(imgui.Col.Button, set_alpha(but_col, 0.2)) |
| imgui.PushStyleColor(imgui.Col.ButtonHovered, set_alpha(but_col, 0.2)) |
| imgui.PushStyleColor(imgui.Col.ButtonActive, set_alpha(but_col, 0.2)) |
| imgui.Button(...) |
| imgui.PopStyleColor(4) |
| end |
| end |
|
|
| M.CheckButton = function(str_id, value, size) |
| local pos = imgui.GetCursorPos() |
| local p = imgui.GetCursorScreenPos() |
| local DL = imgui.GetWindowDrawList() |
|
|
| imgui.BeginGroup() |
| |
| local result = imgui.InvisibleButton(str_id, size) |
| if result then |
| value[0] = not value[0] |
| end |
|
|
| DL:AddRectFilled(p, imgui.ImVec2(p.x + size.x, p.y + size.y), 0xFFFFFFFF) |
|
|
| imgui.EndGroup() |
| return result |
| end |
|
|
| M.HeaderButton = function(bool, str_id) |
| local DL = imgui.GetWindowDrawList() |
| local result = false |
| local label = string.gsub(str_id, "##.*$", "") |
| local duration = { 0.5, 0.3 } |
| local cols = { |
| idle = imgui.GetStyle().Colors[imgui.Col.TextDisabled], |
| hovr = imgui.GetStyle().Colors[imgui.Col.Text], |
| slct = imgui.GetStyle().Colors[imgui.Col.ButtonActive] |
| } |
|
|
| if not AI_HEADERBUT[str_id] then |
| AI_HEADERBUT[str_id] = { |
| color = bool and cols.slct or cols.idle, |
| clock = os.clock() + duration[1], |
| h = { |
| state = bool, |
| alpha = bool and 1.00 or 0.00, |
| clock = os.clock() + duration[2], |
| } |
| } |
| end |
| local pool = AI_HEADERBUT[str_id] |
|
|
| imgui.BeginGroup() |
| local pos = imgui.GetCursorPos() |
| local p = imgui.GetCursorScreenPos() |
| |
| |
| imgui.TextColored(pool.color, label) |
| local s = imgui.GetItemRectSize() |
| local hovered = isPlaceHovered(p, imgui.ImVec2(p.x + s.x, p.y + s.y)) |
| local clicked = imgui.IsItemClicked() |
| |
| |
| if pool.h.state ~= hovered and not bool then |
| pool.h.state = hovered |
| pool.h.clock = os.clock() |
| end |
| |
| if clicked then |
| pool.clock = os.clock() |
| result = true |
| end |
|
|
| if os.clock() - pool.clock <= duration[1] then |
| pool.color = bringVec4To( |
| imgui.ImVec4(pool.color), |
| bool and cols.slct or (hovered and cols.hovr or cols.idle), |
| pool.clock, |
| duration[1] |
| ) |
| else |
| pool.color = bool and cols.slct or (hovered and cols.hovr or cols.idle) |
| end |
|
|
| if pool.h.clock ~= nil then |
| if os.clock() - pool.h.clock <= duration[2] then |
| pool.h.alpha = bringFloatTo( |
| pool.h.alpha, |
| pool.h.state and 1.00 or 0.00, |
| pool.h.clock, |
| duration[2] |
| ) |
| else |
| pool.h.alpha = pool.h.state and 1.00 or 0.00 |
| if not pool.h.state then |
| pool.h.clock = nil |
| end |
| end |
|
|
| local max = s.x / 2 |
| local Y = p.y + s.y + 3 |
| local mid = p.x + max |
|
|
| DL:AddLine(imgui.ImVec2(mid, Y), imgui.ImVec2(mid + (max * pool.h.alpha), Y), ToU32(set_alpha(pool.color, pool.h.alpha)), 3) |
| DL:AddLine(imgui.ImVec2(mid, Y), imgui.ImVec2(mid - (max * pool.h.alpha), Y), ToU32(set_alpha(pool.color, pool.h.alpha)), 3) |
| end |
|
|
| imgui.EndGroup() |
| return result |
| end |
|
|
| return M |
