regions and a whole bunch of other shit

src/imgui/dockspace.cpp

@@ -31,6 +31,7 @@ namespace anm2ed::imgui
         {
           if (settings.windowIsAnimationPreview) animationPreview.update(manager, settings, resources);
           if (settings.windowIsAnimations) animations.update(manager, settings, resources, clipboard);
+          if (settings.windowIsRegions) regions.update(manager, settings, resources, clipboard);
           if (settings.windowIsEvents) events.update(manager, settings, resources, clipboard);
           if (settings.windowIsFrameProperties) frameProperties.update(manager, settings);
           if (settings.windowIsLayers) layers.update(manager, settings, resources, clipboard);

src/imgui/dockspace.h

@@ -4,6 +4,7 @@
 #include "taskbar.h"
 #include "window/animation_preview.h"
 #include "window/animations.h"
+#include "window/regions.h"
 #include "window/events.h"
 #include "window/frame_properties.h"
 #include "window/layers.h"
@@ -22,6 +23,7 @@ namespace anm2ed::imgui
   {
     AnimationPreview animationPreview;
     Animations animations;
+    Regions regions;
     Events events;
     FrameProperties frameProperties;
     Layers layers;

src/imgui/window/animation_preview.cpp

@@ -562,12 +562,26 @@ namespace anm2ed::imgui
               auto texSize = vec2(texture.size);
               if (texSize.x <= 0.0f || texSize.y <= 0.0f) return;
 
-              auto layerModel = math::quad_model_get(frame.size, frame.position, frame.pivot,
+              auto crop = frame.crop;
+              auto size = frame.size;
+              auto pivot = frame.pivot;
+              if (frame.regionID != -1)
+              {
+                auto regionIt = spritesheet->regions.find(frame.regionID);
+                if (regionIt != spritesheet->regions.end())
+                {
+                  crop = regionIt->second.crop;
+                  size = regionIt->second.size;
+                  pivot = regionIt->second.pivot;
+                }
+              }
+
+              auto layerModel = math::quad_model_get(size, frame.position, pivot,
                                                      math::percent_to_unit(frame.scale), frame.rotation);
               auto layerTransform = sampleTransform * layerModel;
 
-              auto uvMin = frame.crop / texSize;
-              auto uvMax = (frame.crop + frame.size) / texSize;
+              auto uvMin = crop / texSize;
+              auto uvMax = (crop + size) / texSize;
 
               vec3 frameColorOffset = frame.colorOffset + colorOffset + sampleColor;
               vec4 frameTint = frame.tint;

src/imgui/window/frame_properties.cpp

@@ -3,6 +3,7 @@
 #include <glm/gtc/type_ptr.hpp>
 #include <limits>
 #include <ranges>
+#include <vector>
 
 #include "math_.h"
 #include "strings.h"
@@ -21,6 +22,21 @@ namespace anm2ed::imgui
       auto& document = *manager.get();
       auto& frames = document.frames.selection;
       auto& type = document.reference.itemType;
+      auto regionLabelsString = std::vector<std::string>{localize.get(BASIC_NONE)};
+      auto regionLabels = std::vector<const char*>{regionLabelsString[0].c_str()};
+      auto regionIds = std::vector<int>{-1};
+
+      if (type == anm2::LAYER && document.reference.itemID != -1)
+      {
+        auto spritesheetID = document.anm2.content.layers.at(document.reference.itemID).spritesheetID;
+        auto regionIt = document.regionBySpritesheet.find(spritesheetID);
+        if (regionIt != document.regionBySpritesheet.end() && !regionIt->second.ids.empty() &&
+            !regionIt->second.labels.empty())
+        {
+          regionLabels = regionIt->second.labels;
+          regionIds = regionIt->second.ids;
+        }
+      }
 
       if (frames.size() <= 1)
       {
@@ -93,7 +109,8 @@ namespace anm2ed::imgui
           }
           else
           {
-            ImGui::BeginDisabled(type == anm2::ROOT || type == anm2::NULL_);
+            bool isRegionSet = frame && frame->regionID != -1;
+            ImGui::BeginDisabled(type == anm2::ROOT || type == anm2::NULL_ || isRegionSet);
             {
               auto cropEdit =
                   drag_float2_persistent(localize.get(BASIC_CROP), frame ? &frame->crop : &dummy_value<vec2>(),
@@ -124,7 +141,7 @@ namespace anm2ed::imgui
               document.change(Document::FRAMES);
             ImGui::SetItemTooltip("%s", localize.get(TOOLTIP_POSITION));
 
-            ImGui::BeginDisabled(type == anm2::ROOT || type == anm2::NULL_);
+            ImGui::BeginDisabled(type == anm2::ROOT || type == anm2::NULL_ || isRegionSet);
             {
               auto pivotEdit =
                   drag_float2_persistent(localize.get(BASIC_PIVOT), frame ? &frame->pivot : &dummy_value<vec2>(),
@@ -179,6 +196,15 @@ namespace anm2ed::imgui
             else if (colorOffsetEdit == edit::END)
               document.change(Document::FRAMES);
 
+            ImGui::BeginDisabled(type != anm2::LAYER);
+            if (combo_id_mapped(localize.get(BASIC_REGION), frame ? &useFrame.regionID : &dummy_value_negative<int>(),
+                                regionIds, regionLabels) &&
+                frame)
+              DOCUMENT_EDIT(document, localize.get(EDIT_SET_REGION_PROPERTIES), Document::FRAMES,
+                            frame->regionID = useFrame.regionID);
+            ImGui::SetItemTooltip("%s", localize.get(TOOLTIP_REGION));
+            ImGui::EndDisabled();
+
             if (ImGui::Checkbox(localize.get(BASIC_VISIBLE), frame ? &useFrame.isVisible : &dummy_value<bool>()) &&
                 frame)
               DOCUMENT_EDIT(document, localize.get(EDIT_FRAME_VISIBILITY), Document::FRAMES,

src/imgui/window/regions.cpp

@@ -0,0 +1,363 @@
+#include "regions.h"
+
+#include <ranges>
+
+#include <filesystem>
+#include <format>
+
+#include "document.h"
+#include "log.h"
+#include "map_.h"
+#include "math_.h"
+#include "path_.h"
+#include "strings.h"
+#include "toast.h"
+
+#include "../../util/map_.h"
+
+using namespace anm2ed::types;
+using namespace anm2ed::resource;
+using namespace anm2ed::util;
+using namespace glm;
+
+namespace anm2ed::imgui
+{
+  void Regions::update(Manager& manager, Settings& settings, Resources& resources, Clipboard& clipboard)
+  {
+    auto& document = *manager.get();
+    auto& anm2 = document.anm2;
+    auto& selection = document.region.selection;
+    auto& frame = document.frames;
+    auto& spritesheetReference = document.spritesheet.reference;
+    auto& reference = document.region.reference;
+    auto style = ImGui::GetStyle();
+
+    auto spritesheet = map::find(anm2.content.spritesheets, spritesheetReference);
+
+    auto remove_unused = [&]()
+    {
+      if (!spritesheet) return;
+
+      auto unused = anm2.regions_unused(*spritesheet);
+      if (unused.empty()) return;
+
+      auto behavior = [&]()
+      {
+        for (auto& id : unused)
+        {
+          for (auto& animation : anm2.animations.items)
+            for (auto& layerAnimation : animation.layerAnimations | std::views::values)
+              for (auto& frame : layerAnimation.frames)
+                if (frame.regionID == id) frame.regionID = -1;
+
+          spritesheet->regions.erase(id);
+        }
+      };
+
+      DOCUMENT_EDIT(document, localize.get(EDIT_REMOVE_UNUSED_REGIONS), Document::SPRITESHEETS, behavior());
+    };
+
+    auto copy = [&]()
+    {
+      if (!spritesheet || selection.empty()) return;
+
+      std::string clipboardText{};
+      for (auto& id : selection)
+        clipboardText += spritesheet->region_to_string(id);
+      clipboard.set(clipboardText);
+    };
+
+    auto paste = [&]()
+    {
+      if (!spritesheet || clipboard.is_empty()) return;
+
+      auto behavior = [&]()
+      {
+        std::string errorString{};
+        document.snapshot(localize.get(EDIT_PASTE_REGIONS));
+        if (spritesheet->regions_deserialize(clipboard.get(), merge::APPEND, &errorString))
+          document.change(Document::SPRITESHEETS);
+        else
+        {
+          toasts.push(std::vformat(localize.get(TOAST_DESERIALIZE_REGIONS_FAILED), std::make_format_args(errorString)));
+          logger.error(std::vformat(localize.get(TOAST_DESERIALIZE_REGIONS_FAILED, anm2ed::ENGLISH),
+                                    std::make_format_args(errorString)));
+        }
+      };
+
+      DOCUMENT_EDIT(document, localize.get(EDIT_PASTE_REGIONS), Document::SPRITESHEETS, behavior());
+    };
+
+    auto add_open = [&]()
+    {
+      reference = -1;
+      editRegion = anm2::Spritesheet::Region{};
+      propertiesPopup.open();
+    };
+
+    auto properties_open = [&](int id)
+    {
+      if (!spritesheet || !spritesheet->regions.contains(id)) return;
+      reference = id;
+      propertiesPopup.open();
+    };
+
+    auto context_menu = [&]()
+    {
+      ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, style.WindowPadding);
+      ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, style.ItemSpacing);
+
+      if (ImGui::IsItemHovered(ImGuiHoveredFlags_AllowWhenOverlappedByWindow) &&
+          ImGui::IsMouseClicked(ImGuiMouseButton_Right))
+        ImGui::OpenPopup("##Region Context Menu");
+
+      if (ImGui::BeginPopup("##Region Context Menu"))
+      {
+        if (ImGui::MenuItem(localize.get(SHORTCUT_STRING_UNDO), settings.shortcutUndo.c_str(), false,
+                            document.is_able_to_undo()))
+          document.undo();
+
+        if (ImGui::MenuItem(localize.get(SHORTCUT_STRING_REDO), settings.shortcutRedo.c_str(), false,
+                            document.is_able_to_redo()))
+          document.redo();
+
+        ImGui::Separator();
+
+        if (ImGui::MenuItem(localize.get(BASIC_PROPERTIES), nullptr, false, selection.size() == 1))
+          properties_open(*selection.begin());
+        if (ImGui::MenuItem(localize.get(BASIC_ADD), settings.shortcutAdd.c_str())) add_open();
+        if (ImGui::MenuItem(localize.get(BASIC_REMOVE_UNUSED), settings.shortcutRemove.c_str())) remove_unused();
+
+        ImGui::Separator();
+
+        if (ImGui::MenuItem(localize.get(BASIC_COPY), settings.shortcutCopy.c_str(), false, !selection.empty())) copy();
+        if (ImGui::MenuItem(localize.get(BASIC_PASTE), settings.shortcutPaste.c_str(), false, !clipboard.is_empty()))
+          paste();
+
+        ImGui::EndPopup();
+      }
+      ImGui::PopStyleVar(2);
+    };
+
+    if (ImGui::Begin(localize.get(LABEL_REGIONS_WINDOW), &settings.windowIsRegions))
+    {
+      if (!spritesheet)
+      {
+        ImGui::TextUnformatted(localize.get(TEXT_SELECT_SPRITESHEET));
+        ImGui::End();
+        return;
+      }
+
+      auto childSize = size_without_footer_get();
+
+      ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2());
+      if (ImGui::BeginChild("##Regions Child", childSize, ImGuiChildFlags_Borders))
+      {
+        auto regionChildSize = ImVec2(ImGui::GetContentRegionAvail().x, ImGui::GetTextLineHeightWithSpacing() * 4);
+
+        ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2());
+
+        selection.start(spritesheet->regions.size());
+        bool isValid = spritesheet->is_valid();
+        auto& texture = isValid ? spritesheet->texture : resources.icons[icon::NONE];
+        auto tintColor = !isValid ? ImVec4(1.0f, 0.25f, 0.25f, 1.0f) : ImVec4(1.0f, 1.0f, 1.0f, 1.0f);
+
+        for (auto& [id, region] : spritesheet->regions)
+        {
+          auto nameCStr = region.name.c_str();
+          auto isSelected = selection.contains(id);
+          auto isReferenced = id == reference;
+
+          ImGui::PushID(id);
+
+          if (ImGui::BeginChild("##Region Child", regionChildSize, ImGuiChildFlags_Borders))
+          {
+            auto cursorPos = ImGui::GetCursorPos();
+
+            ImGui::SetNextItemSelectionUserData(id);
+            ImGui::SetNextItemStorageID(id);
+            if (ImGui::Selectable("##Region Selectable", isSelected, 0, regionChildSize))
+            {
+              reference = id;
+              document.reference = {document.reference.animationIndex};
+              frame.reference = -1;
+              frame.selection.clear();
+            }
+            if (ImGui::IsItemHovered() && ImGui::IsMouseDoubleClicked(ImGuiMouseButton_Left)) propertiesPopup.open();
+
+            auto viewport = ImGui::GetMainViewport();
+            auto maxPreviewSize = to_vec2(viewport->Size) * 0.5f;
+            vec2 regionSize = glm::max(region.size, vec2(1.0f));
+            vec2 previewSize = regionSize;
+            if (previewSize.x > maxPreviewSize.x || previewSize.y > maxPreviewSize.y)
+            {
+              auto scale = glm::min(maxPreviewSize.x / previewSize.x, maxPreviewSize.y / previewSize.y);
+              previewSize *= scale;
+            }
+            auto uvMin = region.crop / vec2(texture.size);
+            auto uvMax = (region.crop + region.size) / vec2(texture.size);
+
+            auto textWidth = ImGui::CalcTextSize(nameCStr).x;
+            auto tooltipPadding = style.WindowPadding.x * 4.0f;
+            auto minWidth = previewSize.x + style.ItemSpacing.x + textWidth + tooltipPadding;
+
+            ImGui::SetNextWindowSize(ImVec2(minWidth, 0), ImGuiCond_Appearing);
+
+            ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, style.ItemSpacing);
+            ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, style.WindowPadding);
+            if (ImGui::BeginItemTooltip())
+            {
+              ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2());
+              auto childFlags = ImGuiChildFlags_Borders | ImGuiChildFlags_AutoResizeX | ImGuiChildFlags_AutoResizeY;
+              auto noScrollFlags = ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoScrollWithMouse;
+
+              if (ImGui::BeginChild("##Region Tooltip Image Child", to_imvec2(previewSize), childFlags, noScrollFlags))
+                ImGui::ImageWithBg(texture.id, to_imvec2(previewSize), to_imvec2(uvMin), to_imvec2(uvMax), ImVec4(),
+                                   tintColor);
+              ImGui::EndChild();
+              ImGui::PopStyleVar();
+
+              ImGui::SameLine();
+
+              auto infoChildFlags = ImGuiChildFlags_AutoResizeX | ImGuiChildFlags_AutoResizeY;
+              if (ImGui::BeginChild("##Region Info Tooltip Child", ImVec2(), infoChildFlags, noScrollFlags))
+              {
+                ImGui::PushFont(resources.fonts[font::BOLD].get(), font::SIZE);
+                ImGui::TextUnformatted(nameCStr);
+                ImGui::PopFont();
+
+                ImGui::TextUnformatted(std::vformat(localize.get(FORMAT_ID), std::make_format_args(id)).c_str());
+                ImGui::TextUnformatted(
+                    std::vformat(localize.get(FORMAT_CROP), std::make_format_args(region.crop.x, region.crop.y))
+                        .c_str());
+                ImGui::TextUnformatted(
+                    std::vformat(localize.get(FORMAT_SIZE), std::make_format_args(region.size.x, region.size.y))
+                        .c_str());
+                ImGui::TextUnformatted(
+                    std::vformat(localize.get(FORMAT_PIVOT), std::make_format_args(region.pivot.x, region.pivot.y))
+                        .c_str());
+              }
+              ImGui::EndChild();
+              ImGui::EndTooltip();
+            }
+            ImGui::PopStyleVar(2);
+
+            auto imageSize = to_imvec2(vec2(regionChildSize.y));
+            auto aspectRatio = region.size.y != 0.0f ? (float)region.size.x / region.size.y : 1.0f;
+
+            if (imageSize.x / imageSize.y > aspectRatio)
+              imageSize.x = imageSize.y * aspectRatio;
+            else
+              imageSize.y = imageSize.x / aspectRatio;
+
+            ImGui::SetCursorPos(cursorPos);
+            ImGui::ImageWithBg(texture.id, imageSize, to_imvec2(uvMin), to_imvec2(uvMax), ImVec4(), tintColor);
+
+            ImGui::SetCursorPos(ImVec2(regionChildSize.y + style.ItemSpacing.x,
+                                       regionChildSize.y - regionChildSize.y / 2 - ImGui::GetTextLineHeight() / 2));
+
+            if (isReferenced) ImGui::PushFont(resources.fonts[font::ITALICS].get(), font::SIZE);
+            ImGui::TextUnformatted(
+                std::vformat(localize.get(FORMAT_SPRITESHEET), std::make_format_args(id, nameCStr)).c_str());
+            if (isReferenced) ImGui::PopFont();
+          }
+
+          ImGui::EndChild();
+          ImGui::PopID();
+        }
+
+        ImGui::PopStyleVar();
+        selection.finish();
+
+        if (shortcut(manager.chords[SHORTCUT_ADD], shortcut::FOCUSED)) add_open();
+        if (shortcut(manager.chords[SHORTCUT_REMOVE], shortcut::FOCUSED)) remove_unused();
+        if (shortcut(manager.chords[SHORTCUT_COPY], shortcut::FOCUSED)) copy();
+        if (shortcut(manager.chords[SHORTCUT_PASTE], shortcut::FOCUSED)) paste();
+      }
+      ImGui::EndChild();
+      ImGui::PopStyleVar();
+
+      context_menu();
+
+      auto rowOneWidgetSize = widget_size_with_row_get(2);
+
+      shortcut(manager.chords[SHORTCUT_ADD]);
+      if (ImGui::Button(localize.get(BASIC_ADD), rowOneWidgetSize)) add_open();
+      set_item_tooltip_shortcut(localize.get(TOOLTIP_ADD_REGION), settings.shortcutAdd);
+
+      ImGui::SameLine();
+
+      shortcut(manager.chords[SHORTCUT_REMOVE]);
+      if (ImGui::Button(localize.get(BASIC_REMOVE_UNUSED), rowOneWidgetSize)) remove_unused();
+      set_item_tooltip_shortcut(localize.get(TOOLTIP_REMOVE_UNUSED_REGIONS), settings.shortcutAdd);
+    }
+
+    ImGui::End();
+
+    propertiesPopup.trigger();
+
+    if (ImGui::BeginPopupModal(propertiesPopup.label(), &propertiesPopup.isOpen, ImGuiWindowFlags_NoResize))
+    {
+      auto childSize = child_size_get(4);
+      auto& region = reference == -1 ? editRegion : spritesheet->regions.at(reference);
+
+      if (propertiesPopup.isJustOpened) editRegion = anm2::Spritesheet::Region{};
+
+      if (ImGui::BeginChild("##Child", childSize, ImGuiChildFlags_Borders))
+      {
+        if (propertiesPopup.isJustOpened) ImGui::SetKeyboardFocusHere();
+        input_text_string(localize.get(BASIC_NAME), &region.name);
+        ImGui::SetItemTooltip("%s", localize.get(TOOLTIP_ITEM_NAME));
+
+        ImGui::DragFloat2(localize.get(BASIC_CROP), value_ptr(region.crop), DRAG_SPEED, 0.0f, 0.0f,
+                          math::vec2_format_get(region.crop));
+        ImGui::DragFloat2(localize.get(BASIC_SIZE), value_ptr(region.size), DRAG_SPEED, 0.0f, 0.0f,
+                          math::vec2_format_get(region.size));
+        ImGui::DragFloat2(localize.get(BASIC_PIVOT), value_ptr(region.pivot), DRAG_SPEED, 0.0f, 0.0f,
+                          math::vec2_format_get(region.pivot));
+      }
+      ImGui::EndChild();
+
+      auto widgetSize = widget_size_with_row_get(2);
+
+      if (ImGui::Button(reference == -1 ? localize.get(BASIC_ADD) : localize.get(BASIC_CONFIRM), widgetSize))
+      {
+        if (reference == -1)
+        {
+          auto add = [&]()
+          {
+            auto id = map::next_id_get(spritesheet->regions);
+            spritesheet->regions[id] = region;
+            selection = {id};
+            newRegionId = id;
+          };
+
+          DOCUMENT_EDIT(document, localize.get(EDIT_ADD_REGION), Document::SPRITESHEETS, add());
+        }
+        else
+        {
+          auto set = [&]()
+          {
+            spritesheet->regions.at(reference) = region;
+            selection = {reference};
+          };
+
+          DOCUMENT_EDIT(document, localize.get(EDIT_SET_REGION_PROPERTIES), Document::SPRITESHEETS, set());
+        }
+
+        frame.reference = -1;
+        frame.selection.clear();
+
+        propertiesPopup.close();
+      }
+
+      ImGui::SameLine();
+
+      if (ImGui::Button(localize.get(BASIC_CANCEL), widgetSize)) propertiesPopup.close();
+
+      ImGui::EndPopup();
+    }
+
+    propertiesPopup.end();
+  }
+}

src/imgui/window/regions.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "clipboard.h"
+#include "manager.h"
+#include "resources.h"
+#include "settings.h"
+
+namespace anm2ed::imgui
+{
+  class Regions
+  {
+  public:
+    anm2::Spritesheet::Region editRegion{};
+    int newRegionId{-1};
+    imgui::PopupHelper propertiesPopup{imgui::PopupHelper(LABEL_REGION_PROPERTIES, imgui::POPUP_SMALL_NO_HEIGHT)};
+
+    void update(Manager&, Settings&, Resources&, Clipboard&);
+  };
+}

src/imgui/window/spritesheet_editor.cpp

@@ -44,6 +44,8 @@ namespace anm2ed::imgui
     auto& shaderTexture = resources.shaders[shader::TEXTURE];
     auto& dashedShader = resources.shaders[shader::DASHED];
     auto& frames = document.frames.selection;
+    auto& regionReference = document.region.reference;
+    auto& regionSelection = document.region.selection;
 
     auto reset_checker_pan = [&]()
     {
@@ -216,6 +218,21 @@ namespace anm2ed::imgui
               transform * math::quad_model_get(PIVOT_SIZE, frame->crop + frame->pivot, PIVOT_SIZE * 0.5f);
           texture_render(shaderTexture, resources.icons[icon::PIVOT].id, pivotTransform, PIVOT_COLOR);
         }
+        else if (regionReference != -1)
+        {
+          auto regionIt = spritesheet->regions.find(regionReference);
+          if (regionIt != spritesheet->regions.end())
+          {
+            auto& region = regionIt->second;
+            auto cropModel = math::quad_model_get(region.size, region.crop);
+            auto cropTransform = transform * cropModel;
+            rect_render(dashedShader, cropTransform, cropModel, color::RED);
+
+            auto pivotTransform =
+                transform * math::quad_model_get(PIVOT_SIZE, region.crop + region.pivot, PIVOT_SIZE * 0.5f);
+            texture_render(shaderTexture, resources.icons[icon::PIVOT].id, pivotTransform, PIVOT_COLOR);
+          }
+        }
       }
 
       unbind();
@@ -303,6 +320,27 @@ namespace anm2ed::imgui
 
         auto frame_change_apply = [&](anm2::FrameChange frameChange, anm2::ChangeType changeType = anm2::ADJUST)
         { item->frames_change(frameChange, reference.itemType, changeType, frames); };
+        auto region_set_all = [&](const vec2& crop, const vec2& size)
+        {
+          if (!spritesheet) return;
+          for (auto id : regionSelection)
+          {
+            auto it = spritesheet->regions.find(id);
+            if (it == spritesheet->regions.end()) continue;
+            it->second.crop = crop;
+            it->second.size = size;
+          }
+        };
+        auto region_offset_all = [&](const vec2& delta)
+        {
+          if (!spritesheet) return;
+          for (auto id : regionSelection)
+          {
+            auto it = spritesheet->regions.find(id);
+            if (it == spritesheet->regions.end()) continue;
+            it->second.crop += delta;
+          }
+        };
 
         if (isMouseMiddleDown) useTool = tool::PAN;
         if (tool == tool::MOVE && isMouseRightDown) useTool = tool::CROP;
@@ -315,7 +353,13 @@ namespace anm2ed::imgui
         bool isAreaAllowed = areaType == tool::ALL || areaType == tool::SPRITESHEET_EDITOR;
         bool isFrameRequired =
             !(useTool == tool::PAN || useTool == tool::DRAW || useTool == tool::ERASE || useTool == tool::COLOR_PICKER);
-        bool isFrameAvailable = !isFrameRequired || frame;
+        bool isRegionInUse =
+            frame && frame->regionID != -1 && (useTool == tool::CROP || useTool == tool::MOVE);
+        bool isFrameAvailable =
+            !isFrameRequired ||
+            (frame && !isRegionInUse) ||
+            (useTool == tool::CROP && !frame && !regionSelection.empty()) ||
+            (useTool == tool::MOVE && !frame && regionReference != -1);
         bool isSpritesheetRequired = useTool == tool::DRAW || useTool == tool::ERASE || useTool == tool::COLOR_PICKER;
         bool isSpritesheetAvailable = !isSpritesheetRequired || (spritesheet && spritesheet->texture.is_valid());
         auto cursor = (isAreaAllowed && isFrameAvailable && isSpritesheetAvailable) ? toolInfo.cursor
@@ -329,6 +373,37 @@ namespace anm2ed::imgui
             if (isMouseDown || isMouseMiddleDown) pan += mouseDelta;
             break;
           case tool::MOVE:
+            if (isRegionInUse) break;
+            if (!frame && regionReference != -1)
+            {
+              if (!spritesheet) break;
+              auto regionIt = spritesheet->regions.find(regionReference);
+              if (regionIt == spritesheet->regions.end()) break;
+
+              auto& region = regionIt->second;
+              if (isBegin) document.snapshot(localize.get(EDIT_REGION_MOVE));
+              if (isMouseDown)
+                region.pivot = ivec2(mousePos) - ivec2(region.crop);
+              if (isLeftPressed) region.pivot.x -= step;
+              if (isRightPressed) region.pivot.x += step;
+              if (isUpPressed) region.pivot.y -= step;
+              if (isDownPressed) region.pivot.y += step;
+
+              if (isDuring)
+              {
+                if (ImGui::BeginTooltip())
+                {
+                  ImGui::TextUnformatted(
+                      std::vformat(localize.get(FORMAT_PIVOT), std::make_format_args(region.pivot.x, region.pivot.y))
+                          .c_str());
+                  ImGui::EndTooltip();
+                }
+              }
+
+              if (isEnd) document.change(Document::SPRITESHEETS);
+              break;
+            }
+
             if (!item || frames.empty()) break;
             if (isBegin) document.snapshot(localize.get(EDIT_FRAME_PIVOT));
             if (isMouseDown)
@@ -358,7 +433,74 @@ namespace anm2ed::imgui
             if (isEnd) document.change(Document::FRAMES);
             break;
           case tool::CROP:
-            if (!item || frames.empty()) break;
+            if (isRegionInUse) break;
+            if (frames.empty())
+            {
+              if (!spritesheet || regionSelection.empty()) break;
+              if (isBegin) document.snapshot(localize.get(EDIT_REGION_CROP));
+
+              if (isMouseClicked)
+              {
+                cropAnchor = mousePos;
+                region_set_all(vec2((int)cropAnchor.x, (int)cropAnchor.y), vec2());
+              }
+              if (isMouseDown)
+              {
+                auto [minPoint, maxPoint] = snap_rect(glm::min(cropAnchor, mousePos), glm::max(cropAnchor, mousePos));
+                region_set_all(vec2(minPoint), vec2(maxPoint - minPoint));
+              }
+              if (isLeftPressed) region_offset_all(vec2(stepX * -1, 0));
+              if (isRightPressed) region_offset_all(vec2(stepX, 0));
+              if (isUpPressed) region_offset_all(vec2(0, stepY * -1));
+              if (isDownPressed) region_offset_all(vec2(0, stepY));
+
+              if (isDuring)
+              {
+                if (!isMouseDown)
+                {
+                  for (auto id : regionSelection)
+                  {
+                    auto it = spritesheet->regions.find(id);
+                    if (it == spritesheet->regions.end()) continue;
+
+                    auto& region = it->second;
+                    auto minPoint = glm::min(region.crop, region.crop + region.size);
+                    auto maxPoint = glm::max(region.crop, region.crop + region.size);
+                    region.crop = minPoint;
+                    region.size = maxPoint - minPoint;
+
+                    if (isGridSnap)
+                    {
+                      auto [snapMin, snapMax] = snap_rect(region.crop, region.crop + region.size);
+                      region.crop = snapMin;
+                      region.size = snapMax - snapMin;
+                    }
+                  }
+                }
+
+                if (ImGui::BeginTooltip())
+                {
+                  auto it = spritesheet->regions.find(*regionSelection.begin());
+                  if (it != spritesheet->regions.end())
+                  {
+                    ImGui::TextUnformatted(
+                        std::vformat(localize.get(FORMAT_CROP),
+                                     std::make_format_args(it->second.crop.x, it->second.crop.y))
+                            .c_str());
+                    ImGui::TextUnformatted(
+                        std::vformat(localize.get(FORMAT_SIZE),
+                                     std::make_format_args(it->second.size.x, it->second.size.y))
+                            .c_str());
+                  }
+                  ImGui::EndTooltip();
+                }
+              }
+
+              if (isEnd) document.change(Document::SPRITESHEETS);
+              break;
+            }
+
+            if (!item) break;
             if (isBegin) document.snapshot(localize.get(EDIT_FRAME_CROP));
 
             if (isMouseClicked)
@@ -473,7 +615,13 @@ namespace anm2ed::imgui
           {
             if (ImGui::BeginTooltip())
             {
-              ImGui::TextUnformatted(localize.get(TEXT_SELECT_FRAME));
+              if (isRegionInUse)
+                ImGui::TextUnformatted(localize.get(TEXT_REGION_IN_USE));
+              else
+              if (useTool == tool::CROP)
+                ImGui::TextUnformatted(localize.get(TEXT_SELECT_FRAME_OR_REGION));
+              else
+                ImGui::TextUnformatted(localize.get(TEXT_SELECT_FRAME));
               ImGui::EndTooltip();
             }
           }

src/imgui/window/spritesheets.cpp

@@ -25,6 +25,7 @@ namespace anm2ed::imgui
     auto& anm2 = document.anm2;
     auto& selection = document.spritesheet.selection;
     auto& reference = document.spritesheet.reference;
+    auto& region = document.region;
     auto style = ImGui::GetStyle();
 
     auto add_open = [&]() { dialog.file_open(Dialog::SPRITESHEET_OPEN); };
@@ -234,7 +235,12 @@ namespace anm2ed::imgui
 
             ImGui::SetNextItemSelectionUserData(id);
             ImGui::SetNextItemStorageID(id);
-            if (ImGui::Selectable("##Spritesheet Selectable", isSelected, 0, spritesheetChildSize)) reference = id;
+            if (ImGui::Selectable("##Spritesheet Selectable", isSelected, 0, spritesheetChildSize))
+            {
+              reference = id;
+              region.reference = -1;
+              region.selection.clear();
+            }
             if (ImGui::IsItemHovered() && ImGui::IsMouseDoubleClicked(ImGuiMouseButton_Left))
               open_directory(spritesheet);
             if (newSpritesheetId == id)

src/imgui/window/timeline.cpp

@@ -93,6 +93,7 @@ namespace anm2ed::imgui
     auto& playback = document.playback;
     auto& reference = document.reference;
     auto& frames = document.frames;
+    auto& region = document.region;
     auto animation = document.animation_get();
 
     style = ImGui::GetStyle();
@@ -392,6 +393,22 @@ namespace anm2ed::imgui
             auto start = reference.itemType == anm2::TRIGGER ? hoveredTime : insertIndex;
             if (item->frames_deserialize(clipboard.get(), reference.itemType, start, indices, &errorString))
             {
+              if (reference.itemType == anm2::LAYER && reference.itemID != -1)
+              {
+                auto& layer = anm2.content.layers.at(reference.itemID);
+                auto spritesheet = anm2.spritesheet_get(layer.spritesheetID);
+                if (spritesheet)
+                {
+                  for (auto i : indices)
+                  {
+                    if (!vector::in_bounds(item->frames, i)) continue;
+                    auto& frame = item->frames[i];
+                    if (frame.regionID != -1 && !spritesheet->regions.contains(frame.regionID))
+                      frame.regionID = -1;
+                  }
+                }
+              }
+
               frames.selection.clear();
               for (auto i : indices)
                 frames.selection.insert(i);
@@ -1137,6 +1154,8 @@ namespace anm2ed::imgui
 
               reference = frameReference;
               isReferenced = true;
+              region.reference = -1;
+              region.selection.clear();
               if (isDifferentItem) frames_selection_set_reference();
             }
             ImGui::PopStyleVar();

src/imgui/wizard/change_all_frame_properties.cpp

@@ -1,6 +1,7 @@
 #include "change_all_frame_properties.h"
 
 #include <string>
+#include <vector>
 
 #include "math_.h"
 
@@ -37,6 +38,7 @@ namespace anm2ed::imgui::wizard
     auto& isInterpolatedSet = settings.changeIsInterpolatedSet;
     auto& isFlipXSet = settings.changeIsFlipXSet;
     auto& isFlipYSet = settings.changeIsFlipYSet;
+    auto& isRegion = settings.changeIsRegion;
     auto& crop = settings.changeCrop;
     auto& size = settings.changeSize;
     auto& position = settings.changePosition;
@@ -46,6 +48,7 @@ namespace anm2ed::imgui::wizard
     auto& duration = settings.changeDuration;
     auto& tint = settings.changeTint;
     auto& colorOffset = settings.changeColorOffset;
+    auto& regionId = settings.changeRegionId;
     auto& isVisible = settings.changeIsVisible;
     auto& isInterpolated = settings.changeIsInterpolated;
     auto& isFlipX = settings.changeIsFlipX;
@@ -180,15 +183,8 @@ namespace anm2ed::imgui::wizard
           checkboxLabel, isEnabled);
     };
 
-#undef PROPERTIES_WIDGET
-
     ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImGui::GetStyle().ItemInnerSpacing);
 
-    ImGui::BeginDisabled(itemType != anm2::LAYER);
-    float2_value("##Is Crop X", "##Is Crop Y", "##Crop X", localize.get(BASIC_CROP), isCropX, isCropY, crop);
-    float2_value("##Is Size X", "##Is Size Y", "##Size X", localize.get(BASIC_SIZE), isSizeX, isSizeY, size);
-    ImGui::EndDisabled();
-
     float2_value("##Is Position X", "##Is Position Y", "##Position X", localize.get(BASIC_POSITION), isPositionX,
                  isPositionY, position);
 
@@ -196,6 +192,11 @@ namespace anm2ed::imgui::wizard
     float2_value("##Is Pivot X", "##Is Pivot Y", "##Pivot X", localize.get(BASIC_PIVOT), isPivotX, isPivotY, pivot);
     ImGui::EndDisabled();
 
+    ImGui::BeginDisabled(itemType != anm2::LAYER);
+    float2_value("##Is Crop X", "##Is Crop Y", "##Crop X", localize.get(BASIC_CROP), isCropX, isCropY, crop);
+    float2_value("##Is Size X", "##Is Size Y", "##Size X", localize.get(BASIC_SIZE), isSizeX, isSizeY, size);
+    ImGui::EndDisabled();
+
     float2_value("##Is Scale X", "##Is Scale Y", "##Scale X", localize.get(BASIC_SCALE), isScaleX, isScaleY, scale);
 
     float_value("##Is Rotation", localize.get(BASIC_ROTATION), isRotation, rotation);
@@ -209,6 +210,24 @@ namespace anm2ed::imgui::wizard
                  "##Color Offset B", "##Color Offset G", localize.get(BASIC_COLOR_OFFSET), isColorOffsetR,
                  isColorOffsetG, isColorOffsetB, colorOffset);
 
+    std::vector<int> fallbackIds{-1};
+    std::vector<std::string> fallbackLabelsString{localize.get(BASIC_NONE)};
+    std::vector<const char*> fallbackLabels{fallbackLabelsString[0].c_str()};
+
+    const Storage* regionStorage = nullptr;
+    if (itemType == anm2::LAYER && document.reference.itemID != -1)
+    {
+      auto spritesheetID = document.anm2.content.layers.at(document.reference.itemID).spritesheetID;
+      auto regionIt = document.regionBySpritesheet.find(spritesheetID);
+      if (regionIt != document.regionBySpritesheet.end()) regionStorage = &regionIt->second;
+    }
+
+    auto regionIds = regionStorage && !regionStorage->ids.empty() ? regionStorage->ids : fallbackIds;
+    auto regionLabels = regionStorage && !regionStorage->labels.empty() ? regionStorage->labels : fallbackLabels;
+
+    PROPERTIES_WIDGET(combo_id_mapped(localize.get(BASIC_REGION), &regionId, regionIds, regionLabels), "##Is Region",
+                      isRegion);
+
     bool_value("##Is Visible", localize.get(BASIC_VISIBLE), isVisibleSet, isVisible);
 
     ImGui::SameLine();
@@ -223,6 +242,8 @@ namespace anm2ed::imgui::wizard
 
     ImGui::PopStyleVar();
 
+#undef PROPERTIES_WIDGET
+
     auto frame_change = [&](anm2::ChangeType changeType)
     {
       anm2::FrameChange frameChange;
@@ -238,6 +259,7 @@ namespace anm2ed::imgui::wizard
       if (isScaleY) frameChange.scaleY = scale.y;
       if (isRotation) frameChange.rotation = std::make_optional(rotation);
       if (isDuration) frameChange.duration = std::make_optional(duration);
+      if (isRegion) frameChange.regionID = std::make_optional(regionId);
       if (isTintR) frameChange.tintR = tint.r;
       if (isTintG) frameChange.tintG = tint.g;
       if (isTintB) frameChange.tintB = tint.b;
@@ -260,8 +282,8 @@ namespace anm2ed::imgui::wizard
 
     bool isAnyProperty = isCropX || isCropY || isSizeX || isSizeY || isPositionX || isPositionY || isPivotX ||
                          isPivotY || isScaleX || isScaleY || isRotation || isDuration || isTintR || isTintG ||
-                         isTintB || isTintA || isColorOffsetR || isColorOffsetG || isColorOffsetB || isVisibleSet ||
-                         isInterpolatedSet || isFlipXSet || isFlipYSet;
+                         isTintB || isTintA || isColorOffsetR || isColorOffsetG || isColorOffsetB || isRegion ||
+                         isVisibleSet || isInterpolatedSet || isFlipXSet || isFlipYSet;
 
     auto rowWidgetSize = widget_size_with_row_get(5);