shweet/anm2ed
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
f75369f67082c0110a053b774b255144a410c0e5
anm2ed/src/imgui.h
shweet f75369f670 dragging frames with ctrl
2025-08-15 16:18:00 -04:00

2064 lines
68 KiB
C++
Raw Blame History

#pragma once
#include "clipboard.h"
#include "dialog.h"
#include "editor.h"
#include "ffmpeg.h"
#include "preview.h"
#include "generate_preview.h"
#include "resources.h"
#include "settings.h"
#include "snapshots.h"
#include "tool.h"
#include "window.h"
#define IMGUI_IMPL_OPENGL_LOADER_CUSTOM
#define IMGUI_ENABLE_DOCKING
#define IM_VEC2_CLASS_EXTRA \
inline bool operator==(const ImVec2& rhs) const { return x == rhs.x && y == rhs.y; } \
inline bool operator!=(const ImVec2& rhs) const { return !(*this == rhs); } \
inline ImVec2 operator+(const ImVec2& rhs) const { return ImVec2(x + rhs.x, y + rhs.y); } \
inline ImVec2 operator-(const ImVec2& rhs) const { return ImVec2(x - rhs.x, y - rhs.y); } \
inline ImVec2 operator*(const ImVec2& rhs) const { return ImVec2(x * rhs.x, y * rhs.y); } \
inline ImVec2 operator*(float s) const { return ImVec2(x * s, y * s); } \
friend inline ImVec2 operator*(float s, const ImVec2& v) { return ImVec2(v.x * s, v.y * s); } \
inline ImVec2& operator+=(const ImVec2& rhs) { x += rhs.x; y += rhs.y; return *this; } \
inline ImVec2& operator-=(const ImVec2& rhs) { x -= rhs.x; y -= rhs.y; return *this; } \
inline ImVec2& operator*=(float s) { x *= s; y *= s; return *this; } \
inline ImVec2(const vec2& v) : x(v.x), y(v.y) {} \
inline operator vec2() const { return vec2(x, y); }
#define IM_VEC4_CLASS_EXTRA \
inline bool operator==(const ImVec4& rhs) const { return x == rhs.x && y == rhs.y && z == rhs.z && w == rhs.w; } \
inline bool operator!=(const ImVec4& rhs) const { return !(*this == rhs); } \
inline ImVec4 operator+(const ImVec4& rhs) const { return ImVec4(x + rhs.x, y + rhs.y, z + rhs.z, w + rhs.w); } \
inline ImVec4 operator-(const ImVec4& rhs) const { return ImVec4(x - rhs.x, y - rhs.y, z - rhs.z, w - rhs.w); } \
inline ImVec4 operator*(const ImVec4& rhs) const { return ImVec4(x * rhs.x, y * rhs.y, z * rhs.z, w * rhs.w); } \
inline ImVec4 operator*(float s) const { return ImVec4(x * s, y * s, z * s, w * s); } \
friend inline ImVec4 operator*(float s, const ImVec4& v) { return ImVec4(v.x * s, v.y * s, v.z * s, v.w * s); } \
inline ImVec4& operator+=(const ImVec4& rhs) { x += rhs.x; y += rhs.y; z += rhs.z; w += rhs.w; return *this; } \
inline ImVec4& operator-=(const ImVec4& rhs) { x -= rhs.x; y -= rhs.y; z -= rhs.z; w -= rhs.w; return *this; } \
inline ImVec4& operator*=(float s) { x *= s; y *= s; z *= s; w *= s; return *this; } \
inline ImVec4(const vec4& v) : x(v.x), y(v.y), z(v.z), w(v.w) {} \
inline operator vec4() const { return vec4(x, y, z, w); }
#include <imgui/imgui.h>
#include <imgui/imgui_internal.h>
#include <imgui/backends/imgui_impl_sdl3.h>
#include <imgui/backends/imgui_impl_opengl3.h>
#define IMGUI_CHORD_NONE (ImGuiMod_None)
#define IMGUI_EVENTS_FOOTER_HEIGHT 40
#define IMGUI_FRAME_BORDER 2.0f
#define IMGUI_LOG_DURATION 3.0f
#define IMGUI_LOG_PADDING 10.0f
#define IMGUI_PLAYHEAD_LINE_COLOR IM_COL32(255, 255, 255, 255)
#define IMGUI_TRIGGERS_EVENT_COLOR IM_COL32(255, 255, 255, 128)
#define IMGUI_PLAYHEAD_LINE_WIDTH 2.0f
#define IMGUI_SPRITESHEETS_FOOTER_HEIGHT 65
#define IMGUI_TIMELINE_FRAME_MULTIPLE 5
#define IMGUI_TIMELINE_MERGE
#define IMGUI_TOOL_COLOR_PICKER_DURATION 0.25f
#define IMGUI_OPTION_POPUP_ROW_COUNT 2
#define IMGUI_ACTION_FRAME_CROP "Frame Crop"
#define IMGUI_ACTION_FRAME_SWAP "Frame Swap"
#define IMGUI_ACTION_FRAME_TRANSFORM "Frame Transform"
#define IMGUI_ACTION_ANIMATION_SWAP "Animation Swap"
#define IMGUI_ACTION_TRIGGER_MOVE "Trigger AtFrame"
#define IMGUI_ACTION_FRAME_DELAY "Frame Delay"
#define IMGUI_ACTION_MOVE_PLAYHEAD "Move Playhead"
#define IMGUI_POPUP_FLAGS ImGuiWindowFlags_NoMove
#define IMGUI_POPUP_MODAL_FLAGS ImGuiWindowFlags_NoMove | ImGuiWindowFlags_AlwaysAutoResize
#define IMGUI_LOG_FILE_OPEN_FORMAT "Opened anm2: {}"
#define IMGUI_LOG_FILE_SAVE_FORMAT "Saved anm2 to: {}"
#define IMGUI_LOG_RENDER_ANIMATION_FRAMES_SAVE_FORMAT "Saved rendered frames to: {}"
#define IMGUI_LOG_RENDER_ANIMATION_SAVE_FORMAT "Saved rendered animation to: {}"
#define IMGUI_LOG_RENDER_ANIMATION_NO_ANIMATION_ERROR "No animation selected; rendering cancelled."
#define IMGUI_LOG_RENDER_ANIMATION_NO_FRAMES_ERROR "No frames to render; rendering cancelled."
#define IMGUI_LOG_RENDER_ANIMATION_DIRECTORY_ERROR "Invalid directory! Make sure it exists and you have write permissions."
#define IMGUI_LOG_RENDER_ANIMATION_PATH_ERROR "Invalid path! Make sure it's valid and you have write permissions."
#define IMGUI_LOG_RENDER_ANIMATION_FFMPEG_PATH_ERROR "Invalid FFmpeg path! Make sure you have it installed and the path is correct."
#define IMGUI_LOG_RENDER_ANIMATION_FFMPEG_ERROR "FFmpeg could not render animation! Check paths or your FFmpeg installation."
#define IMGUI_LOG_SPRITESHEET_SAVE_FORMAT "Saved spritesheet #{} to: {}"
#define IMGUI_NONE "None"
#define IMGUI_ANIMATION_DEFAULT_FORMAT "(*) {}"
#define IMGUI_BUFFER_MAX 255
#define IMGUI_INVISIBLE_LABEL_MARKER "##"
#define IMGUI_ITEM_SELECTABLE_EDITABLE_LABEL "## Editing"
#define IMGUI_LOG_FORMAT "## Log {}"
#define IMGUI_LOG_REDO_FORMAT "Redo: {}"
#define IMGUI_LOG_UNDO_FORMAT "Undo: {}"
#define IMGUI_OPENGL_VERSION "#version 330"
#define IMGUI_POSITION_FORMAT "Position: ({:8}, {:8})"
#define IMGUI_SPRITESHEET_FORMAT "#{} {}"
#define IMGUI_SPRITESHEET_ID_FORMAT "#{}"
#define IMGUI_TIMELINE_ITEM_CHILD_FORMAT "#{} {}"
#define IMGUI_TIMELINE_FRAME_LABEL_FORMAT "## {}"
#define IMGUI_SELECTABLE_INPUT_INT_FORMAT "#{}"
#define IMGUI_TIMELINE_ANIMATION_NONE "Select an animation to show timeline..."
#define IMGUI_LABEL_SHORTCUT_FORMAT "({})"
#define IMGUI_TOOLTIP_SHORTCUT_FORMAT "\n(Shortcut: {})"
#define IMGUI_INVISIBLE_FORMAT "## {}"
#define IMGUI_TRIGGERS_FONT_SCALE 2.0
const ImVec2 IMGUI_TIMELINE_FRAME_SIZE = {12, 36};
const ImVec2 IMGUI_TIMELINE_FRAME_ATLAS_OFFSET = {ATLAS_SIZE_SMALL.x * 0.25f, (IMGUI_TIMELINE_FRAME_SIZE.y * 0.5f) - (ATLAS_SIZE_SMALL.y * 0.5f)};
const ImVec2 IMGUI_TIMELINE_ITEM_SELECTABLE_SIZE = {150, 0};
const ImVec2 IMGUI_TIMELINE_ITEM_SIZE = {300, IMGUI_TIMELINE_FRAME_SIZE.y};
const ImVec4 IMGUI_TIMELINE_FRAME_COLOR = {0.0f, 0.0f, 0.0f, 0.125};
const ImVec4 IMGUI_TIMELINE_FRAME_MULTIPLE_COLOR = {0.113, 0.184, 0.286, 0.125};
const ImVec4 IMGUI_TIMELINE_HEADER_FRAME_COLOR = {0.113, 0.184, 0.286, 0.5};
const ImVec4 IMGUI_TIMELINE_HEADER_FRAME_MULTIPLE_COLOR = {0.113, 0.184, 0.286, 1.0};
const ImVec4 IMGUI_TIMELINE_HEADER_FRAME_INACTIVE_COLOR = {0.113, 0.184, 0.286, 0.125};
const ImVec4 IMGUI_TIMELINE_HEADER_FRAME_MULTIPLE_INACTIVE_COLOR = {0.113, 0.184, 0.286, 0.25};
const ImVec4 IMGUI_ACTIVE_COLOR = {1.0, 1.0, 1.0, 1.0};
const ImVec4 IMGUI_INACTIVE_COLOR = {1.0, 1.0, 1.0, 0.25};
const ImVec2 IMGUI_SPRITESHEET_PREVIEW_SIZE = {50.0, 50.0};
const ImVec2 IMGUI_TOOLTIP_OFFSET = {16, 8};
const vec2 IMGUI_SPRITESHEET_EDITOR_CROP_FORGIVENESS = {1, 1};
const ImGuiKey IMGUI_INPUT_DELETE = ImGuiKey_Delete;
const ImGuiKey IMGUI_INPUT_LEFT = ImGuiKey_LeftArrow;
const ImGuiKey IMGUI_INPUT_RIGHT = ImGuiKey_RightArrow;
const ImGuiKey IMGUI_INPUT_UP = ImGuiKey_UpArrow;
const ImGuiKey IMGUI_INPUT_DOWN = ImGuiKey_DownArrow;
const ImGuiKey IMGUI_INPUT_SHIFT = ImGuiMod_Shift;
const ImGuiKey IMGUI_INPUT_CTRL = ImGuiMod_Ctrl;
const ImGuiKey IMGUI_INPUT_ZOOM_IN = ImGuiKey_1;
const ImGuiKey IMGUI_INPUT_ZOOM_OUT = ImGuiKey_2;
const ImGuiKey IMGUI_INPUT_ENTER = ImGuiKey_Enter;
const ImGuiKey IMGUI_INPUT_RENAME = ImGuiKey_F2;
const ImGuiKey IMGUI_INPUT_DEFAULT = ImGuiKey_Home;
const ImGuiMouseButton IMGUI_MOUSE_DEFAULT = ImGuiMouseButton_Middle;
enum ImguiPopupType
{
IMGUI_POPUP_NONE,
IMGUI_POPUP_BY_ITEM,
IMGUI_POPUP_CENTER_WINDOW
};
struct ImguiColorSet
{
ImVec4 normal{};
ImVec4 active{};
ImVec4 hovered{};
ImVec4 border{};
bool is_normal() const { return normal != ImVec4(); }
bool is_active() const { return active != ImVec4(); }
bool is_hovered() const { return hovered != ImVec4(); }
bool is_border() const { return border != ImVec4(); }
};
struct ImguiLogItem
{
std::string text;
f32 timeRemaining;
};
struct Imgui
{
Dialog* dialog = nullptr;
Resources* resources = nullptr;
Anm2* anm2 = nullptr;
Anm2Reference* reference = nullptr;
Editor* editor = nullptr;
Preview* preview = nullptr;
GeneratePreview* generatePreview = nullptr;
Settings* settings = nullptr;
Snapshots* snapshots = nullptr;
Clipboard* clipboard = nullptr;
SDL_Window* window = nullptr;
SDL_GLContext* glContext = nullptr;
std::string pendingPopup{};
ImguiPopupType pendingPopupType = IMGUI_POPUP_NONE;
ImVec2 pendingPopupPosition{};
std::vector<ImguiLogItem> log;
SDL_SystemCursor cursor;
SDL_SystemCursor pendingCursor;
bool isCursorSet = false;
bool isContextualActionsEnabled = true;
bool isQuit = false;
bool isTryQuit = false;
};
typedef void(*ImguiFunction)(Imgui*);
struct ImguiHotkey
{
ImGuiKeyChord chord;
ImguiFunction function;
std::string focusWindow{};
std::string undoAction{};
bool is_focus_window() const { return !focusWindow.empty(); }
bool is_undoable() const { return !undoAction.empty(); }
};
static void imgui_log_push(Imgui* self, const std::string& text)
{
self->log.push_back({text, IMGUI_LOG_DURATION});
std::println("[IMGUI] {}", text);
}
static std::vector<ImguiHotkey>& imgui_hotkey_registry()
{
static std::vector<ImguiHotkey> registry;
return registry;
}
static inline void imgui_file_new(Imgui* self)
{
anm2_reference_clear(self->reference);
anm2_new(self->anm2);
resources_textures_free(self->resources);
}
static inline void imgui_file_open(Imgui* self)
{
dialog_anm2_open(self->dialog);
}
static inline void imgui_file_save(Imgui* self)
{
if (self->anm2->path.empty())
dialog_anm2_save(self->dialog);
else
{
anm2_serialize(self->anm2, self->anm2->path);
imgui_log_push(self, std::format(IMGUI_LOG_FILE_SAVE_FORMAT, self->anm2->path));
}
}
static inline void imgui_file_save_as(Imgui* self)
{
dialog_anm2_save(self->dialog);
}
static inline void imgui_quit(Imgui* self)
{
if (!self->snapshots->undoStack.is_empty())
self->isTryQuit = true;
else
self->isQuit = true;
}
static inline void imgui_explore(Imgui* self)
{
std::filesystem::path filePath = self->anm2->path;
std::filesystem::path parentPath = filePath.parent_path();
dialog_explorer_open(parentPath.string());
}
static inline void imgui_undo_push(Imgui* self, const std::string& action = SNAPSHOT_ACTION)
{
Snapshot snapshot = {*self->anm2, *self->reference, self->preview->time, action};
snapshots_undo_push(self->snapshots, &snapshot);
}
static inline void imgui_tool_pan_set(Imgui* self)
{
self->settings->tool = TOOL_PAN;
}
static inline void imgui_tool_move_set(Imgui* self)
{
self->settings->tool = TOOL_MOVE;
}
static inline void imgui_tool_rotate_set(Imgui* self)
{
self->settings->tool = TOOL_ROTATE;
}
static inline void imgui_tool_scale_set(Imgui* self)
{
self->settings->tool = TOOL_SCALE;
}
static inline void imgui_tool_crop_set(Imgui* self)
{
self->settings->tool = TOOL_CROP;
}
static inline void imgui_tool_draw_set(Imgui* self)
{
self->settings->tool = TOOL_DRAW;
}
static inline void imgui_tool_erase_set(Imgui* self)
{
self->settings->tool = TOOL_ERASE;
}
static inline void imgui_tool_color_picker_set(Imgui* self)
{
self->settings->tool = TOOL_COLOR_PICKER;
}
static inline void imgui_undo(Imgui* self)
{
if (self->snapshots->undoStack.top == 0) return;
snapshots_undo(self->snapshots);
imgui_log_push(self, std::format(IMGUI_LOG_UNDO_FORMAT, self->snapshots->action));
}
static inline void imgui_redo(Imgui* self)
{
if (self->snapshots->redoStack.top == 0) return;
std::string action = self->snapshots->action;
snapshots_redo(self->snapshots);
imgui_log_push(self, std::format(IMGUI_LOG_REDO_FORMAT, action));
}
static inline void imgui_cut(Imgui* self)
{
clipboard_cut(self->clipboard);
}
static inline void imgui_copy(Imgui* self)
{
clipboard_copy(self->clipboard);
}
static inline void imgui_paste(Imgui* self)
{
clipboard_paste(self->clipboard);
}
static inline ImGuiKey imgui_key_from_char_get(char c)
{
if (c >= 'a' && c <= 'z') c -= 'a' - 'A';
if (c >= 'A' && c <= 'Z') return (ImGuiKey)(ImGuiKey_A + (c - 'A'));
return ImGuiKey_None;
}
static inline std::string imgui_string_from_chord_get(ImGuiKeyChord chord)
{
std::string result;
if (chord & ImGuiMod_Ctrl) result += "Ctrl+";
if (chord & ImGuiMod_Shift) result += "Shift+";
if (chord & ImGuiMod_Alt) result += "Alt+";
ImGuiKey key = (ImGuiKey)(chord & ~ImGuiMod_Mask_);
if (key >= ImGuiKey_A && key <= ImGuiKey_Z)
result.push_back('A' + (key - ImGuiKey_A));
else if (key >= ImGuiKey_0 && key <= ImGuiKey_9)
result.push_back('0' + (key - ImGuiKey_0));
else
{
// Fallback to ImGui's built-in name for non-alphanumerics
const char* name = ImGui::GetKeyName(key);
if (name && *name)
result += name;
else
result += "Unknown";
}
return result;
}
static void imgui_contextual_actions_enable(Imgui* self) { self->isContextualActionsEnabled = true; }
static void imgui_contextual_actions_disable(Imgui* self){ self->isContextualActionsEnabled = false; }
static inline bool imgui_is_popup_open(const std::string& label) { return ImGui::IsPopupOpen(label.c_str()); }
static inline void imgui_open_popup(const std::string& label) { ImGui::OpenPopup(label.c_str()); }
static inline void imgui_pending_popup_process(Imgui* self)
{
if (self->pendingPopup.empty()) return;
switch (self->pendingPopupType)
{
case IMGUI_POPUP_CENTER_WINDOW:
ImGui::SetNextWindowPos(ImGui::GetMainViewport()->GetCenter(), ImGuiCond_Appearing, ImVec2(0.5f, 0.5f));
break;
case IMGUI_POPUP_BY_ITEM:
default:
ImGui::SetNextWindowPos(self->pendingPopupPosition);
break;
}
imgui_open_popup(self->pendingPopup.c_str());
self->pendingPopup.clear();
self->pendingPopupType = IMGUI_POPUP_NONE;
self->pendingPopupPosition = ImVec2();
}
static inline bool imgui_begin_popup(const std::string& label, Imgui* imgui, ImVec2 size = ImVec2())
{
imgui_pending_popup_process(imgui);
if (size != ImVec2()) ImGui::SetNextWindowSizeConstraints(size, ImVec2(FLT_MAX, FLT_MAX));
bool isActivated = ImGui::BeginPopup(label.c_str(), IMGUI_POPUP_FLAGS);
return isActivated;
}
static inline bool imgui_begin_popup_modal(const std::string& label, Imgui* imgui, ImVec2 size = ImVec2())
{
imgui_pending_popup_process(imgui);
if (size != ImVec2()) ImGui::SetNextWindowSizeConstraints(size, ImVec2(FLT_MAX, FLT_MAX));
bool isActivated = ImGui::BeginPopupModal(label.c_str(), nullptr, IMGUI_POPUP_MODAL_FLAGS);
if (isActivated) imgui_contextual_actions_disable(imgui);
return isActivated;
}
static inline void imgui_close_current_popup(Imgui* imgui)
{
imgui_contextual_actions_enable(imgui);
ImGui::CloseCurrentPopup();
}
static inline void imgui_end_popup(Imgui* imgui)
{
ImGui::EndPopup();
imgui_pending_popup_process(imgui);
}
enum ImguiItemType
{
IMGUI_ITEM,
IMGUI_TEXT,
IMGUI_WINDOW,
IMGUI_DOCKSPACE,
IMGUI_CHILD,
IMGUI_OPTION_POPUP,
IMGUI_SELECTABLE,
IMGUI_BUTTON,
IMGUI_RADIO_BUTTON,
IMGUI_COLOR_BUTTON,
IMGUI_CHECKBOX,
IMGUI_INPUT_INT,
IMGUI_INPUT_TEXT,
IMGUI_INPUT_FLOAT,
IMGUI_SLIDER_FLOAT,
IMGUI_DRAG_FLOAT,
IMGUI_COLOR_EDIT,
IMGUI_COMBO,
IMGUI_ATLAS_BUTTON
};
struct ImguiItemOverride
{
bool isDisabled{};
bool isSelected{};
std::string label{};
ImVec2 size{};
s32 id{};
s32 max{};
AtlasType atlas = ATLAS_NONE;
bool isMnemonicDisabled{};
s32 value{};
};
// Item
struct ImguiItem
{
std::string label{};
std::string tooltip{};
std::string& text = tooltip;
std::string undoAction{};
std::string popup{};
std::string dragDrop{};
std::string focusWindow{};
std::vector<std::string> items{};
AtlasType atlas;
ImGuiKeyChord chord = IMGUI_CHORD_NONE;
ImGuiKey mnemonicKey = ImGuiKey_None;
s32 mnemonicIndex = INDEX_NONE;
ImVec2 size{};
ImVec2 popupSize{};
ImguiColorSet color{};
ImguiFunction function = nullptr;
ImguiPopupType popupType = IMGUI_POPUP_CENTER_WINDOW;
bool isDisabled = false;
bool isMnemonicDisabled = false;
bool isSelected = false;
bool isUseItemActivated = false;
bool isSizeToText = false;
bool isShortcutInLabel = false;
bool isSameLine = false;
bool isSeparator = false;
s32 id = 0;
s32 idOffset{};
f32 speed = 0.25f;
s32 step = 1;
s32 stepFast = 10;
s32 min{};
s32 max{};
s32 value{};
vec2 atlasOffset;
s32 border{};
s32 flags{};
s32 windowFlags{};
s32 rowCount = 0;
void construct()
{
static s32 idNew = 0;
id = idNew++;
if (is_chord())
{
std::string chordString = imgui_string_from_chord_get(chord);
if (isShortcutInLabel)
label += std::format(IMGUI_LABEL_SHORTCUT_FORMAT, chordString);
tooltip += std::format(IMGUI_TOOLTIP_SHORTCUT_FORMAT, chordString);
if (function)
imgui_hotkey_registry().push_back({chord, function, focusWindow, undoAction});
}
std::string labelNew{};
for (s32 i = 0; i < (s32)label.size(); i++)
{
if (label[i] == '&')
{
if (label[i + 1] == '&')
{
labelNew += '&';
i++;
}
else if (label[i + 1] != '\0')
{
mnemonicKey = imgui_key_from_char_get(label[i + 1]);
mnemonicIndex = (s32)labelNew.size();
labelNew += label[i + 1];
i++;
}
}
else
labelNew += label[i];
}
label = labelNew;
}
ImguiItem copy(const ImguiItemOverride& override) const
{
ImguiItem out = *this;
if (override.isDisabled) out.isDisabled = override.isDisabled;
if(override.isSelected) out.isSelected = override.isSelected;
if (is_popup() && imgui_is_popup_open(popup)) out.isSelected = true;
if (id != ID_NONE) out.id = id + idOffset + override.id;
if (!override.label.empty()) out.label = override.label;
if (override.size != ImVec2{}) out.size = override.size;
if (override.max != 0) out.max = override.max;
if (override.value != 0) out.value = override.value;
if (override.atlas != ATLAS_NONE) out.atlas = override.atlas;
if (override.isMnemonicDisabled) out.isMnemonicDisabled = override.isMnemonicDisabled;
return out;
}
bool is_border() const { return border != 0; }
bool is_row() const { return rowCount != 0; }
bool is_chord() const { return chord != IMGUI_CHORD_NONE; }
bool is_drag_drop() const { return !dragDrop.empty(); }
bool is_focus_window() const { return !focusWindow.empty(); }
bool is_popup() const { return !popup.empty(); }
bool is_size() const { return size != ImVec2(); }
bool is_popup_size() const { return popupSize != ImVec2(); }
bool is_tooltip() const { return !tooltip.empty(); }
bool is_undoable() const { return !undoAction.empty(); }
bool is_mnemonic() const { return mnemonicKey != ImGuiKey_None; }
bool is_range() const { return min != 0 || max != 0; }
const char* label_get() const { return label.c_str(); }
const char* drag_drop_get() const { return dragDrop.c_str(); }
const char* tooltip_get() const { return tooltip.c_str(); }
const char* text_get() const { return text.c_str(); }
};
#define IMGUI_ITEM(NAME, ...) const inline ImguiItem NAME = []{ ImguiItem self; __VA_ARGS__; self.construct(); return self; }()
IMGUI_ITEM(IMGUI_WINDOW_MAIN,
self.label = "## Window",
self.flags = ImGuiWindowFlags_NoTitleBar |
ImGuiWindowFlags_NoCollapse |
ImGuiWindowFlags_NoResize |
ImGuiWindowFlags_NoMove |
ImGuiWindowFlags_NoBringToFrontOnFocus |
ImGuiWindowFlags_NoNavFocus
);
IMGUI_ITEM(IMGUI_DOCKSPACE_MAIN,
self.label = "## Dockspace",
self.flags = ImGuiDockNodeFlags_PassthruCentralNode
);
IMGUI_ITEM(IMGUI_FOOTER_CHILD,
self.label = "## Footer Child",
self.size = {0, 36},
self.flags = true
);
IMGUI_ITEM(IMGUI_TASKBAR,
self.label = "## Taskbar",
self.size = {0, 32},
self.flags = ImGuiWindowFlags_NoTitleBar |
ImGuiWindowFlags_NoResize |
ImGuiWindowFlags_NoMove |
ImGuiWindowFlags_NoScrollbar |
ImGuiWindowFlags_NoScrollWithMouse |
ImGuiWindowFlags_NoSavedSettings
);
IMGUI_ITEM(IMGUI_FILE,
self.label = "&File",
self.tooltip = "Opens the file menu, for reading/writing anm2 files.",
self.popup = "## File Popup",
self.popupType = IMGUI_POPUP_BY_ITEM,
self.isSizeToText = true,
self.isSameLine = true
);
IMGUI_ITEM(IMGUI_NEW,
self.label = "&New ",
self.tooltip = "Load a blank .anm2 file to edit.",
self.function = imgui_file_new,
self.chord = ImGuiMod_Ctrl | ImGuiKey_N,
self.isSizeToText = true,
self.isShortcutInLabel = true
);
IMGUI_ITEM(IMGUI_OPEN,
self.label = "&Open ",
self.tooltip = "Open an existing .anm2 file to edit.",
self.function = imgui_file_open,
self.chord = ImGuiMod_Ctrl | ImGuiKey_O,
self.isSizeToText = true,
self.isShortcutInLabel = true
);
IMGUI_ITEM(IMGUI_SAVE,
self.label = "&Save ",
self.tooltip = "Saves the current .anm2 file to its path.\nIf no path exists, one can be chosen.",
self.function = imgui_file_save,
self.chord = ImGuiMod_Ctrl | ImGuiKey_S,
self.isSizeToText = true,
self.isShortcutInLabel = true
);
IMGUI_ITEM(IMGUI_SAVE_AS,
self.label = "S&ave As ",
self.tooltip = "Saves the current .anm2 file to a chosen path.",
self.function = imgui_file_save_as,
self.chord = ImGuiMod_Ctrl | ImGuiMod_Shift | ImGuiKey_S,
self.isSizeToText = true,
self.isShortcutInLabel = true
);
IMGUI_ITEM(IMGUI_EXPLORE_ANM2_LOCATION,
self.label = "E&xplore Anm2 Location",
self.tooltip = "Open the system's file explorer in the anm2's path.",
self.function = imgui_explore,
self.isSizeToText = true,
self.isSeparator = true
);
IMGUI_ITEM(IMGUI_EXIT,
self.label = "&Exit ",
self.tooltip = "Exits the program.",
self.function = imgui_quit,
self.chord = ImGuiMod_Alt | ImGuiKey_F4,
self.isSizeToText = true,
self.isShortcutInLabel = true
);
IMGUI_ITEM(IMGUI_EXIT_CONFIRMATION,
self.label = "Exit Confirmation",
self.text = "Unsaved changes will be lost!\nAre you sure you want to exit?"
);
IMGUI_ITEM(IMGUI_WIZARD,
self.label = "&Wizard",
self.tooltip = "Opens the wizard menu, for neat functions related to the .anm2.",
self.popup = "## Wizard Popup",
self.popupType = IMGUI_POPUP_BY_ITEM,
self.isSizeToText = true,
self.isSameLine = true
);
#define IMGUI_GENERATE_ANIMATION_FROM_GRID_PADDING 40
IMGUI_ITEM(IMGUI_GENERATE_ANIMATION_FROM_GRID,
self.label = "&Generate Animation from Grid",
self.tooltip = "Generate a new animation from grid values.",
self.popup = "Generate Animation from Grid",
self.popupType = IMGUI_POPUP_CENTER_WINDOW,
self.popupSize =
{
(GENERATE_PREVIEW_SIZE.x * 2) + IMGUI_GENERATE_ANIMATION_FROM_GRID_PADDING,
GENERATE_PREVIEW_SIZE.y + (IMGUI_FOOTER_CHILD.size.y * 2) + (IMGUI_GENERATE_ANIMATION_FROM_GRID_PADDING / 2)
}
);
IMGUI_ITEM(IMGUI_GENERATE_ANIMATION_FROM_GRID_OPTIONS_CHILD,
self.label = "## Generate Animation From Grid Options Child",
self.size =
{
IMGUI_GENERATE_ANIMATION_FROM_GRID.popupSize.x / 2,
IMGUI_GENERATE_ANIMATION_FROM_GRID.popupSize.y - IMGUI_FOOTER_CHILD.size.y
},
self.flags = true
);
IMGUI_ITEM(IMGUI_GENERATE_ANIMATION_FROM_GRID_START_POSITION,
self.label = "Start Position",
self.tooltip = "Set the starting position on the layer's spritesheet for the generated animation."
);
IMGUI_ITEM(IMGUI_GENERATE_ANIMATION_FROM_GRID_SIZE,
self.label = "Size",
self.tooltip = "Set the size of each frame in the generated animation."
);
IMGUI_ITEM(IMGUI_GENERATE_ANIMATION_FROM_GRID_PIVOT,
self.label = "Pivot",
self.tooltip = "Set the pivot of each frame in the generated animation."
);
IMGUI_ITEM(IMGUI_GENERATE_ANIMATION_FROM_GRID_ROWS,
self.label = "Rows",
self.tooltip = "Set how many rows will be used in the generated animation.",
self.max = 1000
);
IMGUI_ITEM(IMGUI_GENERATE_ANIMATION_FROM_GRID_COLUMNS,
self.label = "Columns",
self.tooltip = "Set how many columns will be used in the generated animation.",
self.max = 1000
);
IMGUI_ITEM(IMGUI_GENERATE_ANIMATION_FROM_GRID_COUNT,
self.label = "Count",
self.tooltip = "Set how many frames will be made for the generated animation.",
self.value = ANM2_FRAME_NUM_MIN
);
IMGUI_ITEM(IMGUI_GENERATE_ANIMATION_FROM_GRID_DELAY,
self.label = "Delay",
self.tooltip = "Set the delay of each frame in the generated animation.",
self.max = 1000
);
IMGUI_ITEM(IMGUI_GENERATE_ANIMATION_FROM_GRID_PREVIEW_CHILD,
self.label = "## Generate Animation From Grid Preview Child",
self.size =
{
IMGUI_GENERATE_ANIMATION_FROM_GRID.popupSize.x / 2,
IMGUI_GENERATE_ANIMATION_FROM_GRID.popupSize.y - IMGUI_FOOTER_CHILD.size.y
},
self.flags = true
);
IMGUI_ITEM(IMGUI_GENERATE_ANIMATION_FROM_GRID_SLIDER_CHILD,
self.label = "## Generate Animation From Grid Slider Child",
self.size =
{
(IMGUI_GENERATE_ANIMATION_FROM_GRID.popupSize.x / 2) - (IMGUI_GENERATE_ANIMATION_FROM_GRID_PADDING / 2),
IMGUI_FOOTER_CHILD.size.y
},
self.flags = true
);
IMGUI_ITEM(IMGUI_GENERATE_ANIMATION_FROM_GRID_SLIDER,
self.label = "## Generate Animation From Grid Slider",
self.tooltip = "Change the time of the generated animation preview.",
self.min = GENERATE_PREVIEW_TIME_MIN,
self.max = GENERATE_PREVIEW_TIME_MAX,
self.value = GENERATE_PREVIEW_TIME_MIN,
self.rowCount = 1,
self.flags = ImGuiSliderFlags_NoInput
);
IMGUI_ITEM(IMGUI_GENERATE_ANIMATION_FROM_GRID_GENERATE,
self.label = "Generate",
self.tooltip = "Generate an animation with the used settings.",
self.undoAction = "Generate Animation from Grid",
self.rowCount = IMGUI_OPTION_POPUP_ROW_COUNT,
self.isSameLine = true
);
IMGUI_ITEM(IMGUI_CHANGE_ALL_FRAME_PROPERTIES,
self.label = "&Change All Frame Properties",
self.tooltip = "Change all frame properties in the selected animation item (or selected frame).",
self.popup = "Change All Frame Properties",
self.popupType = IMGUI_POPUP_CENTER_WINDOW,
self.popupSize = {500, 380}
);
IMGUI_ITEM(IMGUI_CHANGE_ALL_FRAME_PROPERTIES_CHILD,
self.label = "## Change All Frame Properties Child",
self.size =
{
IMGUI_CHANGE_ALL_FRAME_PROPERTIES.popupSize.x,
250
},
self.flags = true
);
IMGUI_ITEM(IMGUI_CHANGE_ALL_FRAME_PROPERTIES_SETTINGS_CHILD,
self.label = "## Change All Frame Properties Settings Child",
self.size =
{
IMGUI_CHANGE_ALL_FRAME_PROPERTIES.popupSize.x,
55
},
self.flags = true
);
IMGUI_ITEM(IMGUI_CHANGE_ALL_FRAME_PROPERTIES_SETTINGS, self.label = "Settings");
IMGUI_ITEM(IMGUI_CHANGE_ALL_FRAME_PROPERTIES_FROM_SELECTED_FRAME,
self.label = "From Selected Frames",
self.tooltip = "The set frame properties will start from the selected frame.",
self.isSameLine = true
);
IMGUI_ITEM(IMGUI_CHANGE_ALL_FRAME_PROPERTIES_NUMBER_FRAMES,
self.label = "# of Frames",
self.tooltip = "Set the amount of frames that the set frame properties will apply to.",
self.size = {200, 0},
self.value = ANM2_FRAME_NUM_MIN,
self.max = 1000
);
#define IMGUI_CHANGE_ALL_FRAME_PROPERTIES_OPTIONS_ROW_COUNT 4
IMGUI_ITEM(IMGUI_CHANGE_ALL_FRAME_PROPERTIES_ADD,
self.label = "Add",
self.tooltip = "The specified values will be added to all specified frames.",
self.undoAction = "Add Frame Properties",
self.rowCount = IMGUI_CHANGE_ALL_FRAME_PROPERTIES_OPTIONS_ROW_COUNT,
self.isSameLine = true
);
IMGUI_ITEM(IMGUI_CHANGE_ALL_FRAME_PROPERTIES_SUBTRACT,
self.label = "Subtract",
self.tooltip = "The specified values will be added to all selected frames.",
self.undoAction = "Subtract Frame Properties",
self.rowCount = IMGUI_CHANGE_ALL_FRAME_PROPERTIES_OPTIONS_ROW_COUNT,
self.isSameLine = true
);
IMGUI_ITEM(IMGUI_CHANGE_ALL_FRAME_PROPERTIES_SET,
self.label = "Set",
self.tooltip = "The specified values will be set to the specified value in selected frames.",
self.undoAction = "Set Frame Properties",
self.rowCount = IMGUI_CHANGE_ALL_FRAME_PROPERTIES_OPTIONS_ROW_COUNT,
self.isSameLine = true
);
IMGUI_ITEM(IMGUI_CHANGE_ALL_FRAME_PROPERTIES_CANCEL,
self.label = "Cancel",
self.tooltip = "Cancel changing all frame properties.",
self.rowCount = IMGUI_CHANGE_ALL_FRAME_PROPERTIES_OPTIONS_ROW_COUNT
);
IMGUI_ITEM(IMGUI_SCALE_ANM2,
self.label = "&Scale Anm2",
self.tooltip = "Scale up all size and position-related frame properties in the anm2.",
self.popup = "Scale Anm2",
self.popupType = IMGUI_POPUP_CENTER_WINDOW,
self.popupSize = {260, 72},
self.isSizeToText = true,
self.isSeparator = true
);
IMGUI_ITEM(IMGUI_SCALE_ANM2_OPTIONS_CHILD,
self.label = "## Scale Anm2 Options Child",
self.size = {IMGUI_SCALE_ANM2.popupSize.x, IMGUI_SCALE_ANM2.popupSize.y - IMGUI_FOOTER_CHILD.size.y},
self.flags = true
);
IMGUI_ITEM(IMGUI_SCALE_ANM2_VALUE,
self.label = "Value",
self.tooltip = "The size and position-related frame properties in the anm2 will be scaled by this value.",
self.value = 1,
self.step = 0.25,
self.stepFast = 1
);
IMGUI_ITEM(IMGUI_SCALE_ANM2_SCALE,
self.label = "Scale",
self.tooltip = "Scale the anm2 with the value specified.",
self.undoAction = "Scale Anm2",
self.rowCount = IMGUI_OPTION_POPUP_ROW_COUNT,
self.isSameLine = true
);
IMGUI_ITEM(IMGUI_RENDER_ANIMATION,
self.label = "&Render Animation",
self.tooltip = "Renders the current animation preview; output options can be customized.",
self.popup = "Render Animation",
self.popupSize = {600, 125}
);
IMGUI_ITEM(IMGUI_RENDER_ANIMATION_CHILD,
self.label = "## Render Animation Child",
self.size = {600, 125}
);
IMGUI_ITEM(IMGUI_RENDER_ANIMATION_LOCATION_BROWSE,
self.label = "## Location Browse",
self.tooltip = "Open file explorer to pick rendered animation location.",
self.atlas = ATLAS_FOLDER,
self.isSameLine = true
);
IMGUI_ITEM(IMGUI_RENDER_ANIMATION_LOCATION,
self.label = "Location",
self.tooltip = "Select the location of the rendered animation.",
self.max = 255
);
IMGUI_ITEM(IMGUI_RENDER_ANIMATION_FFMPEG_BROWSE,
self.label = "## FFMpeg Browse",
self.tooltip = "Open file explorer to pick the path of FFmpeg",
self.atlas = ATLAS_FOLDER,
self.isSameLine = true
);
IMGUI_ITEM(IMGUI_RENDER_ANIMATION_FFMPEG_PATH,
self.label = "FFmpeg Path",
self.tooltip = "Sets the path FFmpeg currently resides in.\nFFmpeg is required for rendering animations.\nDownload it from https://ffmpeg.org/, your package manager, or wherever else.",
self.max = 255
);
IMGUI_ITEM(IMGUI_RENDER_ANIMATION_OUTPUT,
self.label = "Output",
self.tooltip = "Select the rendered animation output.\nIt can either be one animated image or a sequence of frames.",
self.items = {std::begin(RENDER_TYPE_STRINGS), std::end(RENDER_TYPE_STRINGS)},
self.value = RENDER_PNG,
self.isSeparator = true
);
IMGUI_ITEM(IMGUI_RENDER_ANIMATION_FORMAT,
self.label = "Format",
self.tooltip = "(PNG images only).\nSet the format of each output frame; i.e., its filename.\nThe format will only take one argument; that being the frame's index.\nFor example, a format like \"{}.png\" will export a frame of index 0 as \"0.png\".",
self.max = 255
);
IMGUI_ITEM(IMGUI_RENDER_ANIMATION_CONFIRM,
self.label = "Render",
self.tooltip = "Render the animation, with the used settings.",
self.popup = "Rendering Animation...",
self.popupType = IMGUI_POPUP_CENTER_WINDOW,
self.popupSize = {300, 60},
self.isSameLine = true,
self.rowCount = IMGUI_OPTION_POPUP_ROW_COUNT
);
IMGUI_ITEM(IMGUI_RENDERING_ANIMATION_CANCEL,
self.label = "Cancel",
self.tooltip = "Cancel rendering the animation.",
self.rowCount = 1
);
IMGUI_ITEM(IMGUI_PLAYBACK,
self.label = "&Playback",
self.tooltip = "Opens the playback menu, for configuring playback settings.",
self.popup = "## Playback Popup",
self.popupType = IMGUI_POPUP_BY_ITEM,
self.isSizeToText = true,
self.isSameLine = true
);
IMGUI_ITEM(IMGUI_ALWAYS_LOOP,
self.label = "&Always Loop",
self.tooltip = "Sets the animation playback to always loop, regardless of the animation's loop setting.",
self.isSizeToText = true
);
IMGUI_ITEM(IMGUI_CLAMP_PLAYHEAD,
self.label = "&Clamp Playhead",
self.tooltip = "The playhead (draggable icon on timeline) won't be able to exceed the animation length.",
self.isSizeToText = true
);
IMGUI_ITEM(IMGUI_SETTINGS,
self.label = "&Settings",
self.tooltip = "Opens the setting menu, for configuring general program settings.",
self.popup = "## Settings Popup",
self.popupType = IMGUI_POPUP_BY_ITEM,
self.isSizeToText = true
);
IMGUI_ITEM(IMGUI_VSYNC,
self.label = "&Vsync",
self.tooltip = "Toggle vertical sync; synchronizes program framerate with your monitor's refresh rate.",
self.isSizeToText = true
);
IMGUI_ITEM(IMGUI_ANIMATIONS,
self.label = "Animations",
self.flags = ImGuiWindowFlags_NoScrollbar |
ImGuiWindowFlags_NoScrollWithMouse
);
IMGUI_ITEM(IMGUI_ANIMATIONS_CHILD, self.label = "## Animations Child", self.flags = true);
IMGUI_ITEM(IMGUI_ANIMATION,
self.label = "## Animation Item",
self.undoAction = "Select Animation",
self.dragDrop = "## Animation Drag Drop",
self.atlas = ATLAS_ANIMATION,
self.idOffset = 2000
);
#define IMGUI_ANIMATIONS_OPTIONS_ROW_COUNT 5
IMGUI_ITEM(IMGUI_ANIMATION_ADD,
self.label = "Add",
self.tooltip = "Adds a new animation.",
self.undoAction = "Add Animation",
self.rowCount = IMGUI_ANIMATIONS_OPTIONS_ROW_COUNT,
self.isSameLine = true
);
IMGUI_ITEM(IMGUI_ANIMATION_DUPLICATE,
self.label = "Duplicate",
self.tooltip = "Duplicates the selected animation, placing it after.",
self.undoAction = "Duplicate Animation",
self.rowCount = IMGUI_ANIMATIONS_OPTIONS_ROW_COUNT,
self.isSameLine = true
);
IMGUI_ITEM(IMGUI_ANIMATION_MERGE,
self.label = "Merge",
self.tooltip = "Open the animation merge popup, to merge animations together.",
self.popup = "Merge Animations",
self.popupSize = {300, 400},
self.rowCount = IMGUI_ANIMATIONS_OPTIONS_ROW_COUNT,
self.isSameLine = true
);
IMGUI_ITEM(IMGUI_MERGE_ANIMATIONS_CHILD,
self.label = "## Merge Animations",
self.size = {IMGUI_ANIMATION_MERGE.popupSize.x, 250},
self.flags = true
);
IMGUI_ITEM(IMGUI_MERGE_ON_CONFLICT_CHILD,
self.label = "## Merge On Conflict Child",
self.size = {IMGUI_ANIMATION_MERGE.popupSize.x, 75},
self.flags = true
);
IMGUI_ITEM(IMGUI_MERGE_ON_CONFLICT, self.label = "On Conflict");
IMGUI_ITEM(IMGUI_MERGE_APPEND_FRAMES,
self.label = "Append Frames ",
self.tooltip = "On frame conflict, the merged animation will have the selected animations' frames appended.",
self.value = ANM2_MERGE_APPEND_FRAMES,
self.isSameLine = true
);
IMGUI_ITEM(IMGUI_MERGE_REPLACE_FRAMES,
self.label = "Replace Frames",
self.tooltip = "On frame conflict, the merged animation will have the latest selected animations' frames.",
self.value = ANM2_MERGE_REPLACE_FRAMES
);
IMGUI_ITEM(IMGUI_MERGE_PREPEND_FRAMES,
self.label = "Prepend Frames",
self.tooltip = "On frame conflict, the merged animation will have the selected animations' frames prepended.",
self.value = ANM2_MERGE_PREPEND_FRAMES,
self.isSameLine = true
);
IMGUI_ITEM(IMGUI_MERGE_IGNORE,
self.label = "Ignore ",
self.tooltip = "On frame conflict, the merged animation will ignore the other selected animations' frames.",
self.value = ANM2_MERGE_IGNORE
);
IMGUI_ITEM(IMGUI_MERGE_OPTIONS_CHILD,
self.label = "## Merge Options Child",
self.size = {IMGUI_ANIMATION_MERGE.popupSize.x, 35},
self.flags = true
);
IMGUI_ITEM(IMGUI_MERGE_DELETE_ANIMATIONS_AFTER,
self.label = "Delete Animations After Merging",
self.tooltip = "After merging, the selected animations (besides the original) will be deleted."
);
IMGUI_ITEM(IMGUI_MERGE_CONFIRM,
self.label = "Merge",
self.tooltip = "Merge the selected animations with the options set.",
self.undoAction = "Merge Animations",
self.rowCount = IMGUI_OPTION_POPUP_ROW_COUNT,
self.isSameLine = true
);
IMGUI_ITEM(IMGUI_ANIMATION_REMOVE,
self.label = "Remove",
self.tooltip = "Remove the selected animation.",
self.undoAction = "Remove Animation",
self.rowCount = IMGUI_ANIMATIONS_OPTIONS_ROW_COUNT,
self.chord = ImGuiKey_Delete,
self.focusWindow = IMGUI_ANIMATIONS.label,
self.isSameLine = true
);
IMGUI_ITEM(IMGUI_ANIMATION_DEFAULT,
self.label = "Default",
self.tooltip = "Set the selected animation as the default one.",
self.undoAction = "Default Animation",
self.rowCount = IMGUI_ANIMATIONS_OPTIONS_ROW_COUNT,
self.isSameLine = true
);
IMGUI_ITEM(IMGUI_EVENTS,
self.label = "Events",
self.flags = ImGuiWindowFlags_NoScrollbar |
ImGuiWindowFlags_NoScrollWithMouse
);
IMGUI_ITEM(IMGUI_EVENTS_CHILD, self.label = "## Events Child", self.flags = true);
IMGUI_ITEM(IMGUI_EVENT,
self.label = "## Event",
self.atlas = ATLAS_EVENT,
self.idOffset = 1000
);
#define IMGUI_EVENTS_OPTIONS_ROW_COUNT 2
IMGUI_ITEM(IMGUI_EVENTS_ADD,
self.label = "Add",
self.tooltip = "Adds a new event.",
self.undoAction = "Add Event",
self.rowCount = IMGUI_EVENTS_OPTIONS_ROW_COUNT,
self.isSameLine = true
);
IMGUI_ITEM(IMGUI_EVENTS_REMOVE_UNUSED,
self.label = "Remove Unused",
self.tooltip = "Removes all unused events (i.e., not being used in any triggers in any animation).",
self.undoAction = "Remove Unused Events",
self.rowCount = IMGUI_EVENTS_OPTIONS_ROW_COUNT
);
IMGUI_ITEM(IMGUI_SPRITESHEETS,
self.label = "Spritesheets",
self.flags = ImGuiWindowFlags_NoScrollbar |
ImGuiWindowFlags_NoScrollWithMouse
);
IMGUI_ITEM(IMGUI_SPRITESHEETS_CHILD, self.label = "## Spritesheets Child", self.flags = true);
IMGUI_ITEM(IMGUI_SPRITESHEET_CHILD,
self.label = "## Spritesheet Child",
self.rowCount = 1,
self.size = {0, IMGUI_SPRITESHEET_PREVIEW_SIZE.y + 40},
self.flags = true
);
IMGUI_ITEM(IMGUI_SPRITESHEET_SELECTED, self.label = "## Spritesheet Selected", self.isSameLine = true);
IMGUI_ITEM(IMGUI_SPRITESHEET,
self.label = "## Spritesheet",
self.dragDrop = "## Spritesheet Drag Drop",
self.atlas = ATLAS_SPRITESHEET,
self.isSizeToText = true
);
IMGUI_ITEM(IMGUI_SPRITESHEETS_FOOTER_CHILD,
self.label = "## Spritesheets Footer Child",
self.size = {0, 60},
self.flags = true
);
#define IMGUI_SPRITESHEETS_OPTIONS_FIRST_ROW_COUNT 4
#define IMGUI_SPRITESHEETS_OPTIONS_SECOND_ROW_COUNT 3
IMGUI_ITEM(IMGUI_SPRITESHEET_ADD,
self.label = "Add",
self.tooltip = "Select an image to add as a spritesheet.",
self.rowCount = IMGUI_SPRITESHEETS_OPTIONS_FIRST_ROW_COUNT,
self.isSameLine = true
);
IMGUI_ITEM(IMGUI_SPRITESHEETS_RELOAD,
self.label = "Reload",
self.tooltip = "Reload the selected spritesheet.",
self.rowCount = IMGUI_SPRITESHEETS_OPTIONS_FIRST_ROW_COUNT,
self.isSameLine = true
);
IMGUI_ITEM(IMGUI_SPRITESHEETS_REPLACE,
self.label = "Replace",
self.tooltip = "Replace the highlighted spritesheet with another.",
self.rowCount = IMGUI_SPRITESHEETS_OPTIONS_FIRST_ROW_COUNT,
self.isSameLine = true
);
IMGUI_ITEM(IMGUI_SPRITESHEETS_REMOVE_UNUSED,
self.label = "Remove Unused",
self.tooltip = "Remove all unused spritesheets in the anm2 (i.e., no layer in any animation uses the spritesheet).",
self.rowCount = IMGUI_SPRITESHEETS_OPTIONS_FIRST_ROW_COUNT
);
IMGUI_ITEM(IMGUI_SPRITESHEETS_SELECT_ALL,
self.label = "Select All",
self.tooltip = "Select all spritesheets.",
self.rowCount = IMGUI_SPRITESHEETS_OPTIONS_SECOND_ROW_COUNT,
self.isSameLine = true
);
IMGUI_ITEM(IMGUI_SPRITESHEETS_SELECT_NONE,
self.label = "Select None",
self.tooltip = "Unselect all spritesheets.",
self.rowCount = IMGUI_SPRITESHEETS_OPTIONS_SECOND_ROW_COUNT,
self.isSameLine = true
);
IMGUI_ITEM(IMGUI_SPRITESHEET_SAVE,
self.label = "Save",
self.tooltip = "Save the selected spritesheets to their original locations.",
self.rowCount = IMGUI_SPRITESHEETS_OPTIONS_SECOND_ROW_COUNT
);
const ImVec2 IMGUI_CANVAS_CHILD_SIZE = {230, 85};
IMGUI_ITEM(IMGUI_CANVAS_GRID_CHILD,
self.label = "## Canvas Grid Child",
self.size = IMGUI_CANVAS_CHILD_SIZE,
self.flags = true
);
IMGUI_ITEM(IMGUI_CANVAS_GRID,
self.label = "Grid",
self.tooltip = "Toggles the visiblity of the canvas' grid."
);
IMGUI_ITEM(IMGUI_CANVAS_GRID_SNAP,
self.label = "Snap",
self.tooltip = "Using the crop tool will snap the points to the nearest grid point."
);
IMGUI_ITEM(IMGUI_CANVAS_GRID_COLOR,
self.label = "Color",
self.tooltip = "Change the color of the canvas' grid.",
self.flags = ImGuiColorEditFlags_NoInputs
);
IMGUI_ITEM(IMGUI_CANVAS_GRID_SIZE,
self.label = "Size",
self.tooltip = "Change the size of the canvas' grid.",
self.min = CANVAS_GRID_MIN,
self.max = CANVAS_GRID_MAX,
self.value = CANVAS_GRID_DEFAULT
);
IMGUI_ITEM(IMGUI_CANVAS_GRID_OFFSET,
self.label = "Offset",
self.tooltip = "Change the offset of the canvas' grid, in pixels."
);
IMGUI_ITEM(IMGUI_CANVAS_VIEW_CHILD,
self.label = "## View Child",
self.size = IMGUI_CANVAS_CHILD_SIZE,
self.flags = true
);
IMGUI_ITEM(IMGUI_CANVAS_ZOOM,
self.label = "Zoom",
self.tooltip = "Change the zoom of the canvas.",
self.min = CANVAS_ZOOM_MIN,
self.max = CANVAS_ZOOM_MAX,
self.value = CANVAS_ZOOM_DEFAULT
);
IMGUI_ITEM(IMGUI_CANVAS_CENTER_VIEW,
self.label = "Center View",
self.tooltip = "Centers the current view on the canvas.",
self.size = {-FLT_MIN, 0}
);
IMGUI_ITEM(IMGUI_CANVAS_VISUAL_CHILD,
self.label = "## Animation Preview Visual Child",
self.size = IMGUI_CANVAS_CHILD_SIZE,
self.flags = true
);
IMGUI_ITEM(IMGUI_CANVAS_BACKGROUND_COLOR,
self.label = "Background Color",
self.tooltip = "Change the background color of the canvas.",
self.flags = ImGuiColorEditFlags_NoInputs
);
IMGUI_ITEM(IMGUI_CANVAS_ANIMATION_OVERLAY,
self.label = "Overlay",
self.tooltip = "Choose an animation to overlay over the previewed animation, for reference."
);
IMGUI_ITEM(IMGUI_CANVAS_ANIMATION_OVERLAY_TRANSPARENCY,
self.label = "Alpha",
self.tooltip = "Set the transparency of the animation overlay.",
self.value = 255,
self.max = 255
);
IMGUI_ITEM(IMGUI_CANVAS_HELPER_CHILD,
self.label = "## Animation Preview Helper Child",
self.size = IMGUI_CANVAS_CHILD_SIZE,
self.flags = true
);
IMGUI_ITEM(IMGUI_CANVAS_AXES,
self.label = "Axes",
self.tooltip = "Toggle the display of the X/Y axes."
);
IMGUI_ITEM(IMGUI_CANVAS_AXES_COLOR,
self.label = "Color",
self.tooltip = "Change the color of the axes.",
self.flags = ImGuiColorEditFlags_NoInputs
);
IMGUI_ITEM(IMGUI_CANVAS_ROOT_TRANSFORM,
self.label = "Root Transform",
self.tooltip = "Toggles the root frames's attributes transforming the other items in an animation.",
self.value = true
);
IMGUI_ITEM(IMGUI_CANVAS_TRIGGERS,
self.label = "Triggers",
self.tooltip = "Toggles activated triggers drawing their event name.",
self.value = true
);
IMGUI_ITEM(IMGUI_CANVAS_PIVOTS,
self.label = "Pivots",
self.tooltip = "Toggles drawing each layer's pivot."
);
IMGUI_ITEM(IMGUI_CANVAS_TARGETS,
self.label = "Targets",
self.tooltip = "Toggles drawing the targets (i.e., the colored root/null icons)."
);
IMGUI_ITEM(IMGUI_CANVAS_BORDER,
self.label = "Border",
self.tooltip = "Toggles the appearance of a border around the items."
);
IMGUI_ITEM(IMGUI_ANIMATION_PREVIEW,
self.label = "Animation Preview",
self.flags = ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoScrollWithMouse
);
IMGUI_ITEM(IMGUI_SPRITESHEET_EDITOR,
self.label = "Spritesheet Editor",
self.flags = ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoScrollWithMouse
);
IMGUI_ITEM(IMGUI_FRAME_PROPERTIES, self.label = "Frame Properties");
IMGUI_ITEM(IMGUI_FRAME_PROPERTIES_POSITION,
self.label = "Position",
self.tooltip = "Change the position of the selected frame.",
self.undoAction = "Frame Position",
self.isUseItemActivated = true
);
IMGUI_ITEM(IMGUI_FRAME_PROPERTIES_CROP,
self.label = "Crop",
self.tooltip = "Change the crop position of the selected frame.",
self.undoAction = "Frame Crop",
self.isUseItemActivated = true
);
IMGUI_ITEM(IMGUI_FRAME_PROPERTIES_SIZE,
self.label = "Size",
self.tooltip = "Change the size of the crop of the selected frame.",
self.undoAction = "Frame Size",
self.isUseItemActivated = true
);
IMGUI_ITEM(IMGUI_FRAME_PROPERTIES_PIVOT,
self.label = "Pivot",
self.tooltip = "Change the pivot of the selected frame.",
self.undoAction = "Frame Pivot",
self.isUseItemActivated = true
);
IMGUI_ITEM(IMGUI_FRAME_PROPERTIES_SCALE,
self.label = "Scale",
self.tooltip = "Change the scale of the selected frame.",
self.undoAction = "Frame Scale",
self.isUseItemActivated = true,
self.value = 100
);
IMGUI_ITEM(IMGUI_FRAME_PROPERTIES_ROTATION,
self.label = "Rotation",
self.tooltip = "Change the rotation of the selected frame.",
self.undoAction = "Frame Rotation",
self.isUseItemActivated = true
);
IMGUI_ITEM(IMGUI_FRAME_PROPERTIES_DELAY,
self.label = "Duration",
self.tooltip = "Change the duration of the selected frame.",
self.undoAction = "Frame Duration",
self.isUseItemActivated = true,
self.min = ANM2_FRAME_NUM_MIN,
self.max = ANM2_FRAME_NUM_MAX,
self.value = ANM2_FRAME_NUM_MIN
);
IMGUI_ITEM(IMGUI_FRAME_PROPERTIES_TINT,
self.label = "Tint",
self.tooltip = "Change the tint of the selected frame.",
self.undoAction = "Frame Tint",
self.isUseItemActivated = true,
self.value = 1
);
IMGUI_ITEM(IMGUI_FRAME_PROPERTIES_COLOR_OFFSET,
self.label = "Color Offset",
self.tooltip = "Change the color offset of the selected frame.",
self.undoAction = "Frame Color Offset",
self.isUseItemActivated = true,
self.value = 0
);
const ImVec2 IMGUI_FRAME_PROPERTIES_FLIP_BUTTON_SIZE = {75, 0};
IMGUI_ITEM(IMGUI_FRAME_PROPERTIES_FLIP_X,
self.label = "Flip X",
self.tooltip = "Change the sign of the X scale, to cheat flipping the layer horizontally.\n(Anm2 doesn't support flipping directly.)",
self.undoAction = "Frame Flip X",
self.size = IMGUI_FRAME_PROPERTIES_FLIP_BUTTON_SIZE,
self.isSameLine = true
);
IMGUI_ITEM(IMGUI_FRAME_PROPERTIES_FLIP_Y,
self.label = "Flip Y",
self.tooltip = "Change the sign of the Y scale, to cheat flipping the layer vertically.\n(Anm2 doesn't support flipping directly.)",
self.undoAction = "Frame Flip Y",
self.size = IMGUI_FRAME_PROPERTIES_FLIP_BUTTON_SIZE
);
IMGUI_ITEM(IMGUI_FRAME_PROPERTIES_VISIBLE,
self.label = "Visible",
self.tooltip = "Toggles the visibility of the selected frame.",
self.undoAction = "Frame Visibility",
self.isSameLine = true,
self.value = true
);
IMGUI_ITEM(IMGUI_FRAME_PROPERTIES_INTERPOLATED,
self.label = "Interpolation",
self.tooltip = "Toggles the interpolation of the selected frame.",
self.undoAction = "Frame Interpolation",
self.value = true
);
IMGUI_ITEM(IMGUI_FRAME_PROPERTIES_EVENT,
self.label = "Event",
self.tooltip = "Change the event the trigger uses.",
self.undoAction = "Trigger Event"
);
IMGUI_ITEM(IMGUI_FRAME_PROPERTIES_AT_FRAME,
self.label = "At Frame",
self.tooltip = "Change the frame where the trigger occurs.",
self.undoAction = "Trigger At Frame"
);
IMGUI_ITEM(IMGUI_TOOLS, self.label = "Tools");
IMGUI_ITEM(IMGUI_TOOL_PAN,
self.label = "## Pan",
self.tooltip = "Use the pan tool.\nWill shift the view as the cursor is dragged.\nYou can also use the middle mouse button to pan at any time.",
self.function = imgui_tool_pan_set,
self.chord = ImGuiKey_P,
self.atlas = ATLAS_PAN
);
IMGUI_ITEM(IMGUI_TOOL_MOVE,
self.label = "## Move",
self.tooltip = "Use the move tool.\nWill move the selected item as the cursor is dragged, or directional keys are pressed.\n(Animation Preview only.)",
self.function = imgui_tool_move_set,
self.chord = ImGuiKey_M,
self.atlas = ATLAS_MOVE
);
IMGUI_ITEM(IMGUI_TOOL_ROTATE,
self.label = "## Rotate",
self.tooltip = "Use the rotate tool.\nWill rotate the selected item as the cursor is dragged, or directional keys are pressed.\n(Animation Preview only.)",
self.function = imgui_tool_rotate_set,
self.chord = ImGuiKey_R,
self.atlas = ATLAS_ROTATE
);
IMGUI_ITEM(IMGUI_TOOL_SCALE,
self.label = "## Scale",
self.tooltip = "Use the scale tool.\nWill scale the selected item as the cursor is dragged, or directional keys are pressed.\n(Animation Preview only.)",
self.function = imgui_tool_scale_set,
self.chord = ImGuiKey_S,
self.atlas = ATLAS_SCALE
);
IMGUI_ITEM(IMGUI_TOOL_CROP,
self.label = "## Crop",
self.tooltip = "Use the crop tool.\nWill produce a crop rectangle based on how the cursor is dragged.\n(Spritesheet Editor only.)",
self.function = imgui_tool_crop_set,
self.chord = ImGuiKey_C,
self.atlas = ATLAS_CROP
);
IMGUI_ITEM(IMGUI_TOOL_DRAW,
self.label = "## Draw",
self.tooltip = "Draws pixels onto the selected spritesheet, with the current color.\n(Spritesheet Editor only.)",
self.function = imgui_tool_draw_set,
self.chord = ImGuiKey_B,
self.atlas = ATLAS_DRAW
);
IMGUI_ITEM(IMGUI_TOOL_ERASE,
self.label = "## Erase",
self.tooltip = "Erases pixels from the selected spritesheet.\n(Spritesheet Editor only.)",
self.function = imgui_tool_erase_set,
self.chord = ImGuiKey_E,
self.atlas = ATLAS_ERASE
);
IMGUI_ITEM(IMGUI_TOOL_COLOR_PICKER,
self.label = "## Color Picker",
self.tooltip = "Selects a color from the canvas, to be used for drawing.\n(Spritesheet Editor only).",
self.function = imgui_tool_color_picker_set,
self.chord = ImGuiKey_W,
self.atlas = ATLAS_COLOR_PICKER
);
IMGUI_ITEM(IMGUI_TOOL_UNDO,
self.label = "## Undo",
self.tooltip = "Undoes the last action.",
self.function = imgui_undo,
self.chord = ImGuiKey_Z,
self.atlas = ATLAS_UNDO
);
IMGUI_ITEM(IMGUI_TOOL_REDO,
self.label = "## Redo",
self.tooltip = "Redoes the last action.",
self.function = imgui_redo,
self.chord = ImGuiMod_Shift + ImGuiKey_Z,
self.atlas = ATLAS_REDO
);
IMGUI_ITEM(IMGUI_TOOL_COLOR,
self.label = "## Color",
self.tooltip = "Set the color, to be used by the draw tool.",
self.flags = ImGuiColorEditFlags_NoInputs
);
const inline ImguiItem* IMGUI_TOOL_ITEMS[TOOL_COUNT] =
{
&IMGUI_TOOL_PAN,
&IMGUI_TOOL_MOVE,
&IMGUI_TOOL_ROTATE,
&IMGUI_TOOL_SCALE,
&IMGUI_TOOL_CROP,
&IMGUI_TOOL_DRAW,
&IMGUI_TOOL_ERASE,
&IMGUI_TOOL_COLOR_PICKER,
&IMGUI_TOOL_UNDO,
&IMGUI_TOOL_REDO,
&IMGUI_TOOL_COLOR
};
IMGUI_ITEM(IMGUI_COLOR_PICKER_BUTTON, self.label = "## Color Picker Button");
IMGUI_ITEM(IMGUI_TIMELINE,
self.label = "Timeline",
self.flags = ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoScrollWithMouse
);
IMGUI_ITEM(IMGUI_TIMELINE_CHILD,
self.label = "## Timeline Child",
self.flags = true
);
IMGUI_ITEM(IMGUI_TIMELINE_HEADER_CHILD,
self.label = "## Timeline Header Child",
self.size = {0, IMGUI_TIMELINE_FRAME_SIZE.y},
self.windowFlags = ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoScrollWithMouse
);
IMGUI_ITEM(IMGUI_PLAYHEAD,
self.label = "## Playhead",
self.flags = ImGuiWindowFlags_NoTitleBar |
ImGuiWindowFlags_NoResize |
ImGuiWindowFlags_NoMove |
ImGuiWindowFlags_NoBackground |
ImGuiWindowFlags_NoInputs
);
IMGUI_ITEM(IMGUI_TIMELINE_ITEMS_CHILD,
self.label = "## Timeline Items",
self.size = {IMGUI_TIMELINE_ITEM_SIZE.x, 0},
self.windowFlags = ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoScrollWithMouse
);
IMGUI_ITEM(IMGUI_TIMELINE_ITEM_CHILD,
self.label = "## Timeline Item Child",
self.size = IMGUI_TIMELINE_ITEM_SIZE,
self.flags = true,
self.windowFlags = ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoScrollWithMouse
);
IMGUI_ITEM(IMGUI_TIMELINE_ITEM_ROOT_CHILD,
self.label = "## Root Item Child",
self.color = {{0.045f, 0.08f, 0.11f, 1.0f}},
self.size = IMGUI_TIMELINE_ITEM_SIZE,
self.flags = true,
self.windowFlags = ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoScrollWithMouse
);
IMGUI_ITEM(IMGUI_TIMELINE_ITEM_LAYER_CHILD,
self.label = "## Layer Item Child",
self.color = {{0.0875f, 0.05f, 0.015f, 1.0f}},
self.size = IMGUI_TIMELINE_ITEM_SIZE,
self.flags = true,
self.windowFlags = ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoScrollWithMouse
);
IMGUI_ITEM(IMGUI_TIMELINE_ITEM_NULL_CHILD,
self.label = "## Null Item Child",
self.color = {{0.055f, 0.10f, 0.055f, 1.0f}},
self.size = IMGUI_TIMELINE_ITEM_SIZE,
self.flags = true,
self.windowFlags = ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoScrollWithMouse
);
IMGUI_ITEM(IMGUI_TIMELINE_ITEM_TRIGGERS_CHILD,
self.label = "## Triggers Item Child",
self.color = {{0.10f, 0.0375f, 0.07f, 1.0f}},
self.size = IMGUI_TIMELINE_ITEM_SIZE,
self.flags = true,
self.windowFlags = ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoScrollWithMouse
);
const inline ImguiItem* IMGUI_TIMELINE_ITEM_CHILDS[ANM2_COUNT]
{
&IMGUI_TIMELINE_ITEM_CHILD,
&IMGUI_TIMELINE_ITEM_ROOT_CHILD,
&IMGUI_TIMELINE_ITEM_LAYER_CHILD,
&IMGUI_TIMELINE_ITEM_NULL_CHILD,
&IMGUI_TIMELINE_ITEM_TRIGGERS_CHILD
};
IMGUI_ITEM(IMGUI_TIMELINE_ITEM_SELECTABLE,
self.label = "## Selectable",
self.size = IMGUI_TIMELINE_ITEM_SELECTABLE_SIZE
);
IMGUI_ITEM(IMGUI_TIMELINE_ITEM_ROOT_SELECTABLE,
self.label = "Root",
self.tooltip = "The root item of an animation.\nChanging its properties will transform the rest of the animation.",
self.undoAction = "Root Item Select",
self.atlas = ATLAS_ROOT,
self.size = IMGUI_TIMELINE_ITEM_SELECTABLE_SIZE
);
IMGUI_ITEM(IMGUI_TIMELINE_ITEM_LAYER_SELECTABLE,
self.label = "## Layer Selectable",
self.tooltip = "A layer item.\nA graphical item within the animation.",
self.undoAction = "Layer Item Select",
self.dragDrop = "## Layer Drag Drop",
self.atlas = ATLAS_LAYER,
self.size = IMGUI_TIMELINE_ITEM_SELECTABLE_SIZE
);
IMGUI_ITEM(IMGUI_TIMELINE_ITEM_NULL_SELECTABLE,
self.label = "## Null Selectable",
self.tooltip = "A null item.\nAn invisible item within the animation that is accessible via a game engine.",
self.undoAction = "Null Item Select",
self.dragDrop = "## Null Drag Drop",
self.atlas = ATLAS_NULL,
self.size = IMGUI_TIMELINE_ITEM_SELECTABLE_SIZE
);
IMGUI_ITEM(IMGUI_TIMELINE_ITEM_TRIGGERS_SELECTABLE,
self.label = "Triggers",
self.tooltip = "The animation's triggers.\nWill fire based on an event.",
self.undoAction = "Triggers Item Select",
self.atlas = ATLAS_TRIGGERS,
self.size = IMGUI_TIMELINE_ITEM_SELECTABLE_SIZE
);
const inline ImguiItem* IMGUI_TIMELINE_ITEM_SELECTABLES[ANM2_COUNT]
{
&IMGUI_TIMELINE_ITEM_SELECTABLE,
&IMGUI_TIMELINE_ITEM_ROOT_SELECTABLE,
&IMGUI_TIMELINE_ITEM_LAYER_SELECTABLE,
&IMGUI_TIMELINE_ITEM_NULL_SELECTABLE,
&IMGUI_TIMELINE_ITEM_TRIGGERS_SELECTABLE
};
IMGUI_ITEM(IMGUI_TIMELINE_ITEM_VISIBLE,
self.label = "## Visible",
self.tooltip = "The item is visible.\nPress to set to invisible.",
self.undoAction = "Item Invisible",
self.atlas = ATLAS_VISIBLE
);
IMGUI_ITEM(IMGUI_TIMELINE_ITEM_INVISIBLE,
self.label = "## Invisible",
self.tooltip = "The item is invisible.\nPress to set to visible.",
self.undoAction = "Item Visible",
self.atlas = ATLAS_INVISIBLE
);
IMGUI_ITEM(IMGUI_TIMELINE_ITEM_SHOW_RECT,
self.label = "## Show Rect",
self.tooltip = "The rect is shown.\nPress to hide rect.",
self.undoAction = "Hide Rect",
self.atlas = ATLAS_SHOW_RECT
);
IMGUI_ITEM(IMGUI_TIMELINE_ITEM_HIDE_RECT,
self.label = "## Hide Rect",
self.tooltip = "The rect is hidden.\nPress to show rect.",
self.undoAction = "Show Rect",
self.atlas = ATLAS_HIDE_RECT
);
IMGUI_ITEM(IMGUI_TIMELINE_SPRITESHEET_ID,
self.label = "## Spritesheet ID",
self.tooltip = "Change the spritesheet ID this item uses.",
self.atlas = ATLAS_SPRITESHEET,
self.size = {32, 0}
);
IMGUI_ITEM(IMGUI_TIMELINE_FRAMES_CHILD,
self.label = "## Timeline Frames Child",
self.windowFlags = ImGuiWindowFlags_NoScrollWithMouse | ImGuiWindowFlags_HorizontalScrollbar
);
IMGUI_ITEM(IMGUI_TIMELINE_ITEM_FRAMES_CHILD,
self.label = "## Timeline Item Frames Child",
self.size = {0, IMGUI_TIMELINE_FRAME_SIZE.y}
);
IMGUI_ITEM(IMGUI_TIMELINE_FRAME, self.label = "## Frame");
#define IMGUI_TIMELINE_FRAME_BORDER 5
static const vec4 IMGUI_FRAME_BORDER_COLOR = {1.0f, 1.0f, 1.0f, 0.25f};
IMGUI_ITEM(IMGUI_TIMELINE_ROOT_FRAME,
self.label = "## Root Frame",
self.undoAction = "Root Frame Select",
self.color = {{0.14f, 0.27f, 0.39f, 1.0f}, {0.28f, 0.54f, 0.78f, 1.0f}, {0.36f, 0.70f, 0.95f, 1.0f}, IMGUI_FRAME_BORDER_COLOR},
self.size = IMGUI_TIMELINE_FRAME_SIZE,
self.atlasOffset = IMGUI_TIMELINE_FRAME_ATLAS_OFFSET,
self.border = IMGUI_FRAME_BORDER
);
IMGUI_ITEM(IMGUI_TIMELINE_LAYER_FRAME,
self.label = "## Layer Frame",
self.undoAction = "Layer Frame Select",
self.dragDrop = "## Layer Frame Drag Drop",
self.color = {{0.45f, 0.18f, 0.07f, 1.0f}, {0.78f, 0.32f, 0.12f, 1.0f}, {0.95f, 0.40f, 0.15f, 1.0f}, IMGUI_FRAME_BORDER_COLOR},
self.size = IMGUI_TIMELINE_FRAME_SIZE,
self.atlasOffset = IMGUI_TIMELINE_FRAME_ATLAS_OFFSET,
self.border = IMGUI_FRAME_BORDER
);
IMGUI_ITEM(IMGUI_TIMELINE_NULL_FRAME,
self.label = "## Null Frame",
self.undoAction = "Null Frame Select",
self.dragDrop = "## Null Frame Drag Drop",
self.color = {{0.17f, 0.33f, 0.17f, 1.0f}, {0.34f, 0.68f, 0.34f, 1.0f}, {0.44f, 0.88f, 0.44f, 1.0f}, IMGUI_FRAME_BORDER_COLOR},
self.size = IMGUI_TIMELINE_FRAME_SIZE,
self.atlasOffset = IMGUI_TIMELINE_FRAME_ATLAS_OFFSET,
self.border = IMGUI_FRAME_BORDER
);
IMGUI_ITEM(IMGUI_TIMELINE_TRIGGERS_FRAME,
self.label = "## Triggers Frame",
self.undoAction = "Trigger Select",
self.color = {{0.36f, 0.14f, 0.24f, 1.0f}, {0.72f, 0.28f, 0.48f, 1.0f}, {0.92f, 0.36f, 0.60f, 1.0f}, IMGUI_FRAME_BORDER_COLOR},
self.size = IMGUI_TIMELINE_FRAME_SIZE,
self.atlasOffset = IMGUI_TIMELINE_FRAME_ATLAS_OFFSET,
self.border = IMGUI_FRAME_BORDER
);
const inline ImguiItem* IMGUI_TIMELINE_FRAMES[ANM2_COUNT]
{
&IMGUI_TIMELINE_FRAME,
&IMGUI_TIMELINE_ROOT_FRAME,
&IMGUI_TIMELINE_LAYER_FRAME,
&IMGUI_TIMELINE_NULL_FRAME,
&IMGUI_TIMELINE_TRIGGERS_FRAME
};
IMGUI_ITEM(IMGUI_TIMELINE_ITEM_FOOTER_CHILD,
self.label = "## Item Footer Child",
self.size = {IMGUI_TIMELINE_ITEM_CHILD.size.x, IMGUI_FOOTER_CHILD.size.y},
self.flags = true
);
IMGUI_ITEM(IMGUI_TIMELINE_OPTIONS_FOOTER_CHILD,
self.label = "## Options Footer Child",
self.size = {0, IMGUI_FOOTER_CHILD.size.y},
self.flags = true
);
#define IMGUI_TIMELINE_FOOTER_ITEM_CHILD_ITEM_COUNT 2
IMGUI_ITEM(IMGUI_TIMELINE_ADD_ITEM,
self.label = "Add",
self.tooltip = "Adds an item (layer or null) to the animation.",
self.popup = "## Add Item Popup",
self.popupType = IMGUI_POPUP_BY_ITEM,
self.rowCount = IMGUI_TIMELINE_FOOTER_ITEM_CHILD_ITEM_COUNT,
self.isSameLine = true
);
IMGUI_ITEM(IMGUI_TIMELINE_ADD_ITEM_LAYER,
self.label = "Layer",
self.tooltip = "Adds a layer item.\nA layer item is a primary graphical item, using a spritesheet.",
self.undoAction = "Add Layer",
self.isSizeToText = true
);
IMGUI_ITEM(IMGUI_TIMELINE_ADD_ITEM_NULL,
self.label = "Null",
self.tooltip = "Adds a null item.\nA null item is an invisible item, often accessed by the game engine.",
self.undoAction = "Add Null",
self.isSizeToText = true
);
IMGUI_ITEM(IMGUI_TIMELINE_REMOVE_ITEM,
self.label = "Remove",
self.tooltip = "Removes the selected item (layer or null) from the animation.",
self.undoAction = "Remove Item",
self.focusWindow = IMGUI_TIMELINE.label,
self.rowCount = IMGUI_TIMELINE_FOOTER_ITEM_CHILD_ITEM_COUNT
);
#define IMGUI_TIMELINE_OPTIONS_ROW_COUNT 10
IMGUI_ITEM(IMGUI_PLAY,
self.label = "|> Play",
self.tooltip = "Play the current animation, if paused.",
self.focusWindow = IMGUI_TIMELINE.label,
self.chord = ImGuiKey_Space,
self.rowCount = IMGUI_TIMELINE_OPTIONS_ROW_COUNT,
self.isSameLine = true
);
IMGUI_ITEM(IMGUI_PAUSE,
self.label = "|| Pause",
self.tooltip = "Pause the current animation, if playing.",
self.focusWindow = IMGUI_TIMELINE.label,
self.chord = ImGuiKey_Space,
self.rowCount = IMGUI_TIMELINE_OPTIONS_ROW_COUNT,
self.isSameLine = true
);
IMGUI_ITEM(IMGUI_ADD_FRAME,
self.label = "+ Insert Frame",
self.tooltip = "Inserts a frame in the selected animation item, based on the preview time.",
self.undoAction = "Insert Frame",
self.rowCount = IMGUI_TIMELINE_OPTIONS_ROW_COUNT,
self.isSameLine = true
);
IMGUI_ITEM(IMGUI_REMOVE_FRAME,
self.label = "- Delete Frame",
self.tooltip = "Removes the selected frame from the selected animation item.",
self.undoAction = "Delete Frame",
self.focusWindow = IMGUI_TIMELINE.label,
self.chord = ImGuiKey_Delete,
self.rowCount = IMGUI_TIMELINE_OPTIONS_ROW_COUNT,
self.isSameLine = true
);
IMGUI_ITEM(IMGUI_BAKE,
self.label = "Bake",
self.tooltip = "Opens the bake popup menu, if a frame is selected.\nBaking a frame takes the currently interpolated values at the time between it and the next frame and separates them based on the interval.",
self.popup = "Bake Frames",
self.rowCount = IMGUI_TIMELINE_OPTIONS_ROW_COUNT,
self.popupSize = {260, 145},
self.isSameLine = true
);
IMGUI_ITEM(IMGUI_BAKE_CHILD,
self.label = "## Bake Child",
self.flags = true
);
IMGUI_ITEM(IMGUI_BAKE_INTERVAL,
self.label = "Interval",
self.tooltip = "Sets the delay of the baked frames the selected frame will be separated out into.",
self.min = ANM2_FRAME_DELAY_MIN,
self.value = ANM2_FRAME_DELAY_MIN
);
IMGUI_ITEM(IMGUI_BAKE_ROUND_SCALE,
self.label = "Round Scale",
self.tooltip = "The scale of the baked frames will be rounded to the nearest integer.",
self.value = true
);
IMGUI_ITEM(IMGUI_BAKE_ROUND_ROTATION,
self.label = "Round Rotation",
self.tooltip = "The rotation of the baked frames will be rounded to the nearest integer.",
self.value = true,
self.isSeparator = true
);
IMGUI_ITEM(IMGUI_BAKE_CONFIRM,
self.label = "Bake",
self.tooltip = "Bake the selected frame with the options selected.",
self.undoAction = "Bake Frames",
self.rowCount = IMGUI_OPTION_POPUP_ROW_COUNT,
self.isSameLine = true
);
IMGUI_ITEM(IMGUI_FIT_ANIMATION_LENGTH,
self.label = "Fit Animation Length",
self.tooltip = "Sets the animation's length to the latest frame.",
self.undoAction = "Fit Animation Length",
self.rowCount = IMGUI_TIMELINE_OPTIONS_ROW_COUNT,
self.isSameLine = true
);
IMGUI_ITEM(IMGUI_ANIMATION_LENGTH,
self.label = "Length",
self.tooltip = "Sets the animation length.\n(Will not change frames.)",
self.undoAction = "Set Animation Length",
self.rowCount = IMGUI_TIMELINE_OPTIONS_ROW_COUNT,
self.min = ANM2_FRAME_NUM_MIN,
self.max = ANM2_FRAME_NUM_MAX,
self.value = ANM2_FRAME_NUM_MIN,
self.isSameLine = true
);
IMGUI_ITEM(IMGUI_FPS,
self.label = "FPS",
self.tooltip = "Sets the animation's frames per second (its speed).",
self.undoAction = "Set FPS",
self.rowCount = IMGUI_TIMELINE_OPTIONS_ROW_COUNT,
self.min = ANM2_FPS_MIN,
self.max = ANM2_FPS_MAX,
self.value = ANM2_FPS_DEFAULT,
self.isSameLine = true
);
IMGUI_ITEM(IMGUI_LOOP,
self.label = "Loop",
self.tooltip = "Toggles the animation looping.",
self.undoAction = "Set Loop",
self.rowCount = IMGUI_TIMELINE_OPTIONS_ROW_COUNT,
self.value = true,
self.isSameLine = true
);
IMGUI_ITEM(IMGUI_CREATED_BY,
self.label = "Author",
self.tooltip = "Sets the author of the animation.",
self.rowCount = IMGUI_TIMELINE_OPTIONS_ROW_COUNT,
self.max = 255
);
IMGUI_ITEM(IMGUI_CONTEXT_MENU, self.label = "## Context Menu");
IMGUI_ITEM(IMGUI_CUT,
self.label = "Cut",
self.tooltip = "Cuts the currently selected contextual element; removing it and putting it to the clipboard.",
self.undoAction = "Cut",
self.function = imgui_cut,
self.chord = ImGuiMod_Ctrl | ImGuiKey_X,
self.isSizeToText = true
);
IMGUI_ITEM(IMGUI_COPY,
self.label = "Copy",
self.tooltip = "Copies the currently selected contextual element to the clipboard.",
self.undoAction = "Copy",
self.function = imgui_copy,
self.chord = ImGuiMod_Ctrl | ImGuiKey_C,
self.isSizeToText = true
);
IMGUI_ITEM(IMGUI_PASTE,
self.label = "Paste",
self.tooltip = "Pastes the currently selection contextual element from the clipboard.",
self.undoAction = "Paste",
self.function = imgui_paste,
self.chord = ImGuiMod_Ctrl | ImGuiKey_V,
self.isSizeToText = true
);
IMGUI_ITEM(IMGUI_CHANGE_INPUT_TEXT,
self.label = "## Input Text",
self.tooltip = "Rename the selected item.",
self.undoAction = "Rename Item",
self.flags = ImGuiInputTextFlags_AutoSelectAll | ImGuiInputTextFlags_EnterReturnsTrue,
self.max = 255
);
IMGUI_ITEM(IMGUI_CHANGE_INPUT_INT,
self.label = "## Input Int",
self.tooltip = "Change the selected item's value.",
self.undoAction = "Change Value",
self.step = 0
);
#define IMGUI_OPTION_POPUP_ROW_COUNT 2
IMGUI_ITEM(IMGUI_POPUP_OK,
self.label = "OK",
self.tooltip = "Confirm the action.",
self.rowCount = IMGUI_OPTION_POPUP_ROW_COUNT
);
IMGUI_ITEM(IMGUI_POPUP_CANCEL,
self.label = "Cancel",
self.tooltip = "Cancel the action.",
self.rowCount = IMGUI_OPTION_POPUP_ROW_COUNT
);
IMGUI_ITEM(IMGUI_LOG_WINDOW,
self.label = "## Log Window",
self.flags = ImGuiWindowFlags_NoTitleBar |
ImGuiWindowFlags_NoResize |
ImGuiWindowFlags_NoMove |
ImGuiWindowFlags_NoScrollbar |
ImGuiWindowFlags_NoSavedSettings |
ImGuiWindowFlags_AlwaysAutoResize |
ImGuiWindowFlags_NoFocusOnAppearing |
ImGuiWindowFlags_NoNav |
ImGuiWindowFlags_NoInputs
);
void imgui_init
(
Imgui* self,
Dialog* dialog,
Resources* resources,
Anm2* anm2,
Anm2Reference* reference,
Editor* editor,
Preview* preview,
GeneratePreview* generatePreview,
Settings* settings,
Snapshots* snapshots,
Clipboard* clipboard,
SDL_Window* window,
SDL_GLContext* glContext
);
void imgui_update(Imgui* self);
void imgui_draw();
void imgui_free();
Reference in New Issue View Git Blame Copy Permalink