|
|
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 |
