EditorController.h

Go to the documentation of this file.

 
#pragma once

 
#include "Action/Action.h"
#include "Core/AppSettings.h"
#include "Core/Grid.h"
#include "Core/Player.h"
#include "Project/Frame.h"
#include "Selection/Selection.h"
#include "Tool/ToolManager.h"
#include "Util/Ptr.h"
#include "imgui.h"
 
#include <unordered_map>
#include <vector>
 
namespace FuncDoodle {
    class EditorController {
        public:
        struct CanvasContext {
            class Frame* Frame =
                nullptr;  
            class Frame* PreviousFrame =
                nullptr;         
            uint64_t Index = 0;  
            ToolManager* ToolManager =
                nullptr;  
            AnimationPlayer* Player =
                nullptr;  
            UniquePtr<Grid> Grid =
                nullptr;         
            int PixelScale = 8;  
            ImVec2 LastMousePos = {-1,
                -1};  
            ImVec2 LastHoverMousePos = {
                -1, -1};  
            AppSettings&
                Settings;  

            CanvasContext(AppSettings& settings) : Settings(settings) {}
        };

        EditorController();

        bool Paint(Frame* frame, uint64_t frameI, ToolManager* toolManager,
            AnimationPlayer* player, int pixelX, int pixelY, bool mouseDown,
            bool mouseClicked);
        void SetUndoByStroke(bool undoByStroke, AnimationPlayer* player);
        void RenderCanvas(CanvasContext& context);
        void EndStroke(AnimationPlayer* player);
        void ResetState();
        SharedPtr<Selection> Sel() { return m_Sel; }
        void SetSel(SharedPtr<Selection> sel) {
            m_Sel = sel;
            m_SquareSel = SquareSelection{};
        }
 
        private:
        bool PaintPencil(Frame* frame, uint64_t frameI,
            ToolManager* toolManager, AnimationPlayer* player, int pixelX,
            int pixelY, bool mouseDown);
        bool PaintEraser(Frame* frame, uint64_t frameI,
            ToolManager* toolManager, AnimationPlayer* player, int pixelX,
            int pixelY, bool mouseDown);
        bool PaintBucket(Frame* frame, uint64_t frameI,
            ToolManager* toolManager, AnimationPlayer* player, int pixelX,
            int pixelY, bool mouseClicked);
        static bool PaintPicker(
            Frame* frame, ToolManager* toolManager, int pixelX, int pixelY);
        bool PaintSelect(
            Frame* frame, ToolManager* toolManager, int pixelX, int pixelY);
        static void FloodFill(int x, int y, ToolManager* toolManager,
            Col targetCol, Col fillCol, Frame* targetFrame,
            std::vector<std::tuple<int, int, Col>>& changed);
        void RecordStrokeChange(
            uint64_t frameI, int x, int y, const Col& prev, const Col& next);
        static void HandleCanvasInput(CanvasContext& context);
        void ApplyToolAt(CanvasContext& context, const ImageArray* pixels,
            float startX, float startY, float frameWidth, float frameHeight);
        void DrawCanvas(CanvasContext& context, const ImageArray* pixels,
            ImDrawList* drawList, float startX, float startY, float frameWidth,
            float frameHeight);
        void FinalizeStroke(AnimationPlayer* player);
 
        bool m_UndoByStroke = false;
        bool m_StrokeActive = false;
        uint64_t m_StrokeFrameI = 0;
        std::vector<StrokeAction::PixelChange> m_StrokeChanges;
        std::unordered_map<uint64_t, size_t> m_StrokeIndexByKey;
        SharedPtr<Selection> m_Sel;
        SquareSelection m_SquareSel;
    };
}  // namespace FuncDoodle