EditMap.hpp

Go to the documentation of this file.

#ifndef EDITOR_COMPONENTS_EDITMAP_HPP
#define EDITOR_COMPONENTS_EDITMAP_HPP
 
#include <BLIB/Cameras/2D/Camera2D.hpp>
#include <BLIB/Interfaces/GUI.hpp>
#include <Core/Items/Id.hpp>
#include <Core/Maps/Map.hpp>
#include <Editor/Components/Render/EditMapComponent.hpp>
#include <Editor/Components/RenderMapWindow.hpp>
 
namespace editor
{
namespace page
{
class Map;
class Towns;
} // namespace page
 
namespace component
{
class EditMap
: public bl::gui::Element
, public core::map::Map {
public:
    typedef std::shared_ptr<EditMap> Ptr;
 
    using PositionCb = std::function<void(const sf::Vector2f& pixels, const sf::Vector2i& tiles)>;
 
    using ActionCb = std::function<void()>;
 
    enum struct RenderOverlay {
        None,
 
        Collisions,
 
        CatchTiles,
 
        Towns,
 
        Events,
 
        Spawns,
 
        LevelTransitions
    };
 
    static Ptr create(const PositionCb& clickCb, const PositionCb& moveCb, const ActionCb& actionCb,
                      const ActionCb& syncCb, core::system::Systems& systems);
 
    virtual ~EditMap();
 
    bool unsavedChanges() const;
 
    const std::string& currentFile() const;
 
    void newMap(const std::string& filename, const std::string& name, const std::string& tileset,
                unsigned int width, unsigned int height);
 
    bool editorLoad(const std::string& filename);
 
    bool editorSave();
 
    const char* undoDescription() const;
 
    void undo();
 
    const char* redoDescription() const;
 
    void redo();
 
    void setControlsEnabled(bool enabled);
 
    void setLevelVisible(unsigned int level, bool visible);
 
    void setLayerVisible(unsigned int level, unsigned int layer, bool visible);
 
    void setRenderOverlay(RenderOverlay overlay, unsigned int level);
 
    void showGrid(bool show);
 
    void showSelection(const sf::IntRect& selection);
 
    void removeAllTiles(core::map::Tile::IdType id, bool isAnim);
 
    void resize(unsigned int width, unsigned int height, bool modLeft, bool modTop);
 
    void setName(const std::string& name);
 
    void setPlaylist(const std::string& playlist);
 
    void setWeather(core::map::Weather::Type weather);
 
    void setOnEnterScript(const std::string& script);
 
    const std::string& getOnEnterScript() const;
 
    void setOnExitScript(const std::string& script);
 
    const std::string& getOnExitScript() const;
 
    void setAmbientLight(std::uint8_t lower, std::uint8_t upper, bool sunlight);
 
    void appendLevel();
 
    void shiftLevel(unsigned int level, bool up);
 
    void removeLevel(unsigned int level);
 
    void appendBottomLayer(unsigned int level);
 
    void appendYsortLayer(unsigned int level);
 
    void appendTopLayer(unsigned int level);
 
    void shiftLayer(unsigned int level, unsigned int layer, bool up);
 
    void removeLayer(unsigned int level, unsigned int layer);
 
    void setTile(unsigned int level, unsigned int layer, const sf::Vector2i& position,
                 core::map::Tile::IdType id, bool isAnim);
 
    void setTileArea(unsigned int level, unsigned int layer, const sf::IntRect& area,
                     core::map::Tile::IdType id, bool isAnim);
 
    void fillTile(unsigned int level, unsigned int layer, const sf::Vector2i& position,
                  core::map::Tile::IdType id, bool isAnim);
 
    void setCollision(unsigned int level, const sf::Vector2i& position, core::map::Collision id);
 
    void setCollisionArea(unsigned int level, const sf::IntRect& area, core::map::Collision id);
 
    void fillCollision(unsigned int level, const sf::Vector2i& position, core::map::Collision id);
 
    void setCatch(unsigned int level, const sf::Vector2i& position, std::uint8_t id);
 
    void setCatchArea(unsigned int level, const sf::IntRect& area, std::uint8_t id);
 
    void fillCatch(unsigned int level, const sf::Vector2i& position, std::uint8_t id);
 
    bool spawnIdUnused(unsigned int id) const;
 
    void addSpawn(unsigned int level, const sf::Vector2i& tile, unsigned int id,
                  bl::tmap::Direction dir);
 
    void rotateSpawn(unsigned int level, const sf::Vector2i& tile);
 
    void removeSpawn(unsigned int level, const sf::Vector2i& position);
 
    void addNpcSpawn(const core::map::CharacterSpawn& spawn);
 
    const core::map::CharacterSpawn* getNpcSpawn(unsigned int level,
                                                 const sf::Vector2i& position) const;
 
    void editNpcSpawn(const core::map::CharacterSpawn* orig,
                      const core::map::CharacterSpawn& spawn);
 
    void removeNpcSpawn(const core::map::CharacterSpawn* spawn);
 
    std::pair<core::item::Id, bool> getItem(unsigned int level, const sf::Vector2i& position);
 
    void addOrEditItem(unsigned int level, const sf::Vector2i& position, core::item::Id item,
                       bool visible);
 
    void removeItem(unsigned int level, const sf::Vector2i& position);
 
    void setLight(const sf::Vector2i& positionPixels, unsigned int radius);
 
    void removeLight(const sf::Vector2i& positionPixels);
 
    void createEvent(const core::map::Event& event);
 
    const core::map::Event* getEvent(const sf::Vector2i& position);
 
    void editEvent(const core::map::Event* orig, const core::map::Event& event);
 
    void removeEvent(const core::map::Event* event);
 
    void addCatchRegion();
 
    const std::vector<core::map::CatchRegion>& catchRegions() const;
 
    void editCatchRegion(std::uint8_t index, const core::map::CatchRegion& zone);
 
    void removeCatchRegion(std::uint8_t index);
 
    void addTown();
 
    void editTown(std::uint8_t i, const core::map::Town& town);
 
    void removeTown(std::uint8_t i);
 
    void setTownTile(const sf::Vector2i& position, std::uint8_t id);
 
    void setTownTileArea(const sf::IntRect& area, std::uint8_t id);
 
    void fillTownTiles(const sf::Vector2i& position, std::uint8_t id);
 
    void setLevelTile(const sf::Vector2i& position, core::map::LevelTransition lt);
 
    void setLevelTileArea(const sf::IntRect& area, core::map::LevelTransition lt);
 
    void staticRender(const RenderMapWindow& params);
 
private:
    struct Action {
        using Ptr = std::shared_ptr<Action>;
 
        virtual ~Action()                           = default;
        virtual bool apply(component::EditMap& map) = 0;
        virtual bool undo(component::EditMap& map)  = 0;
        virtual const char* description() const     = 0;
    };
    std::vector<Action::Ptr> history;
    unsigned int historyHead;
    unsigned int saveHead;
    void addAction(const Action::Ptr& action);
 
    struct EditCameraController : public bl::cam::CameraController2D {
        EditCameraController(EditMap* owner);
        virtual ~EditCameraController() = default;
        virtual void update(float dt) override;
        void reset(const sf::Vector2i& size);
        void zoom(float z);
        void updateDepthPlanes();
        bl::cam::Camera2D& getCamera() { return camera(); }
 
        EditMap* owner;
        bool enabled;
        glm::vec2 mapSize;
        float zoomAmount;
    };
 
    const PositionCb clickCb;
    const PositionCb moveCb;
    const ActionCb actionCb;
    const ActionCb syncCb;
    EditCameraController* camera;
    bool controlsEnabled;
    std::string savefile;
    std::vector<bool> levelFilter;
    std::vector<std::vector<bool>> layerFilter;
    sf::IntRect selection;
 
    struct SpawnGraphics {
        bl::gfx::Sprite arrow;
        bl::gfx::Text label;
    };
 
    struct CatchTileLayerGraphics {
        bl::gfx::BatchedShapes2D shapeBatch;
        bl::ctr::Vector2D<bl::gfx::BatchRectangle> tiles;
 
        ~CatchTileLayerGraphics();
    };
 
    struct BatchSpriteOverlayLayer {
        bl::gfx::BatchedSprites batch;
        bl::ctr::Vector2D<bl::gfx::BatchSprite> tiles;
 
        ~BatchSpriteOverlayLayer();
    };
 
    bl::gfx::Rectangle selectRect;
    bl::ctr::Vector2D<bl::gfx::BatchRectangle> townSquares;
    bl::gfx::BatchedShapes2D townSquareBatch;
    bl::gfx::VertexBuffer2D grid;
    std::unordered_map<unsigned int, SpawnGraphics> spawnSprites;
    std::list<CatchTileLayerGraphics> catchTileOverlay;
    std::optional<bl::util::ImageStitcher> colStitcher;
    bl::rc::res::TextureRef collisionTilesTexture;
    std::vector<glm::vec2> collisionTextureCoords;
    std::list<BatchSpriteOverlayLayer> collisionTileOverlay;
    std::optional<bl::util::ImageStitcher> levelTransitionsStitcher;
    bl::rc::res::TextureRef levelTransitionsTexture;
    std::vector<glm::vec2> levelTransitionsTextureCoords;
    std::optional<BatchSpriteOverlayLayer> levelTransitionsOverlay;
    std::list<bl::gfx::Rectangle> eventsOverlay;
    sf::Color currentEventFillColor;
    float eventColorTime;
 
    struct ExportState {
        std::atomic_bool exportInProgress;
        RenderOverlay prevRenderOverlay;
        unsigned int prevOverlayLevel;
        sf::IntRect prevSelection;
        glm::vec2 prevCenter;
        float prevZoom;
        std::uint8_t prevAmbientLightLow;
        std::uint8_t prevAmbientLightHigh;
        bool entitiesHidden;
        bool prevEnabled;
        std::atomic_bool exportComplete;
 
        std::string outputPath;
        bl::rc::vk::RenderTexture::Handle renderTexture;
        bl::cam::Camera2D* camera;
        glm::u32vec2 center;
        glm::u32vec2 size;
        bl::rc::tfr::TextureExport* exportJob;
 
        ExportState();
    } exportState;
 
    void exportRendering();
 
    RenderOverlay renderOverlay;
    unsigned int overlayLevel;
    unsigned int nextItemId;
    bool setRenderTarget;
 
    EditMap(const PositionCb& cb, const PositionCb& moveCb, const ActionCb& actionCb,
            const ActionCb& syncCb, core::system::Systems& systems);
    bool doLoad(const std::string& file);
    void stitchOverlayTextures();
    bool editorActivate();
    void setupOverlay();
 
    void addSpawnGfx(const core::map::Spawn& spawn);
    void updateSpawnRotation(std::uint16_t id);
    void updateAllDepths();
    void updateLevelDepths(unsigned int level);
    void swapRenderLevels(unsigned int i1, unsigned int i2);
    void updateLayerDepths(unsigned int level, unsigned int layer);
    void swapRenderLayers(unsigned int level, unsigned int l1, unsigned int l2);
    void updateLayerVisibility(unsigned int level, unsigned int layer, bool hide);
    void updateCatchTileColor(unsigned int level, unsigned int x, unsigned int y);
    void updateTownTileColor(unsigned int x, unsigned int y);
    void updateCollisionTileTexture(unsigned int level, unsigned int x, unsigned int y);
    void updateLevelTransitionTexture(unsigned int x, unsigned int y);
    void addEventGfx(unsigned int i);
    void removeEventGfx(unsigned int i);
    sf::Color nextEventFillColor(float dt);
 
    virtual sf::Vector2f minimumRequisition() const override;
    virtual bl::gui::rdr::Component* doPrepareRender(bl::gui::rdr::Renderer& renderer) override;
    virtual bool handleScroll(const bl::gui::Event& scroll) override;
    virtual void update(float dt) override;
 
    friend class page::Map;
    friend class page::Towns;
    friend class rdr::EditMapComponent;
 
    class SetNameAction;
    class SetPlaylistAction;
    class SetWeatherAction;
    class SetYSortLayerAction;
    class SetTopLayerAction;
    class SetScriptAction;
    class SetAmbientLightAction;
    class AppendLevelAction;
    class ShiftLevelAction;
    class RemoveLevelAction;
    class AppendLayerAction;
    class ShiftLayerAction;
    class RemoveLayerAction;
    class SetTileAction;
    class SetTileAreaAction;
    class FillTileAction;
    class SetCollisionAction;
    class SetCollisionAreaAction;
    class FillCollisionAction;
    class SetCatchAction;
    class SetCatchAreaAction;
    class FillCatchAction;
    class AddSpawnAction;
    class RotateSpawnAction;
    class RemoveSpawnAction;
    class AddNpcSpawnAction;
    class EditNpcSpawnAction;
    class RemoveNpcSpawnAction;
    class AddOrEditItemAction;
    class RemoveItemAction;
    class SetLightAction;
    class RemoveLightAction;
    class AddEventAction;
    class EditEventAction;
    class RemoveEventAction;
    class AddCatchRegionAction;
    class EditCatchRegionAction;
    class RemoveCatchRegionAction;
    class AddTownAction;
    class EditTownAction;
    class RemoveTownAction;
    class SetTownTileAction;
    class SetTownTileAreaAction;
    class FillTownTileAction;
    class SetLevelTileAction;
    class SetLevelTileAreaAction;
};
 
} // namespace component
} // namespace editor
 
#endif