C_tilelayer.hpp

/*
 * Copyright 2025 Guillaume Guillet
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#ifndef _FGE_C_TILELAYER_HPP_INCLUDED
#define _FGE_C_TILELAYER_HPP_INCLUDED
 
#include "FastEngine/fge_extern.hpp"
#include "FastEngine/C_matrix.hpp"
#include "FastEngine/C_tileset.hpp"
#include "FastEngine/graphic/C_color.hpp"
#include "FastEngine/graphic/C_drawable.hpp"
#include "FastEngine/graphic/C_transformable.hpp"
#include "FastEngine/vulkan/C_vertexBuffer.hpp"
#include "json.hpp"
#include <span>
 
#define FGE_LAYER_BAD_ID 0
 
namespace fge
{
 
using GlobalTileId = int32_t;
using LocalTileId = int32_t;
 
#ifdef FGE_DEF_SERVER
class FGE_API BaseLayer : public fge::Transformable
#else
class FGE_API BaseLayer : public fge::Transformable, public fge::Drawable
#endif
{
public:
    enum class Types
    {
        TILE_LAYER,
        OBJECT_GROUP
    };
 
    BaseLayer() = default;
    ~BaseLayer() override = default;
 
    [[nodiscard]] virtual Types getType() const = 0;
 
    virtual void clear();

    void setId(GlobalTileId id);
    [[nodiscard]] GlobalTileId getId() const;

    void setName(std::string_view name);
    [[nodiscard]] std::string const& getName() const;
 
    virtual void save(nlohmann::json& jsonObject);
    virtual void load(nlohmann::json const& jsonObject, std::filesystem::path const& filePath);
 
    [[nodiscard]] static std::shared_ptr<BaseLayer> loadLayer(nlohmann::json const& jsonObject,
                                                              std::filesystem::path const& filePath);
 
    template<class T>
    constexpr T const* as() const
    {
        static_assert(std::is_base_of_v<BaseLayer, T>, "T must inherit from BaseLayer");
        return static_cast<T*>(this);
    }
    template<class T>
    constexpr T* as()
    {
        static_assert(std::is_base_of_v<BaseLayer, T>, "T must inherit from BaseLayer");
        return static_cast<T*>(this);
    }
 
private:
    std::string g_name;
    GlobalTileId g_id{FGE_LAYER_BAD_ID};
};

class FGE_API TileLayer : public BaseLayer
{
public:
    class FGE_API Tile
    {
    public:
        Tile();

        void setGid(GlobalTileId gid);
        [[nodiscard]] GlobalTileId getGid() const;

        void setPosition(Vector2f const& position);
        [[nodiscard]] Vector2f const& getPosition() const;

        void setColor(Color const& color);
        [[nodiscard]] Color getColor() const;

        void setTileSet(std::shared_ptr<TileSet> const& tileSet);
        [[nodiscard]] std::shared_ptr<TileSet> getTileSet() const;
 
        [[nodiscard]] TileData const* getTileData() const;
 
    private:
        void updatePositions();
        void updateTexCoords();
 
        GlobalTileId g_gid{0};
        std::weak_ptr<TileSet> g_tileSet;
        vulkan::VertexBuffer g_vertexBuffer;
        Vector2f g_position;
 
        friend TileLayer;
    };
 
    TileLayer() = default;
 
#ifndef FGE_DEF_SERVER
    void draw(fge::RenderTarget& target, fge::RenderStates const& states) const override;
#endif
 
    [[nodiscard]] Types getType() const override;
 
    void clear() override;

    [[nodiscard]] fge::Matrix<Tile> const& getTiles() const;
    void setGid(fge::Vector2size position, std::span<std::shared_ptr<TileSet>> tileSets, GlobalTileId gid);
    [[nodiscard]] GlobalTileId getGid(fge::Vector2size position) const;
    [[nodiscard]] std::optional<fge::Vector2size> getGridPosition(fge::Vector2f position) const;
    void setGid(fge::Vector2size position, GlobalTileId gid);
    void setGridSize(fge::Vector2size size);

    void refreshTextures(std::span<std::shared_ptr<TileSet>> tileSets);
    [[nodiscard]] static std::shared_ptr<TileSet>
    retrieveAssociatedTileSet(std::span<std::shared_ptr<TileSet>> tileSets, GlobalTileId gid);
 
    [[nodiscard]] fge::RectFloat getGlobalBounds() const;
    [[nodiscard]] fge::RectFloat getLocalBounds() const;
 
    void save(nlohmann::json& jsonObject) override;
    void load(nlohmann::json const& jsonObject, std::filesystem::path const& filePath) override;
 
private:
    fge::Matrix<Tile> g_tiles;
};

class FGE_API ObjectGroupLayer : public BaseLayer
{
public:
    ObjectGroupLayer() = default;
 
    struct Object
    {
        fge::Vector2f _position;
        fge::Vector2f _size;
        std::string _name;
        LocalTileId _id;
        float _rotation;
        bool _point;
    };
 
#ifndef FGE_DEF_SERVER
    void draw(fge::RenderTarget& target, fge::RenderStates const& states) const override;
#endif
 
    [[nodiscard]] Types getType() const override;
 
    void clear() override;
 
    [[nodiscard]] std::vector<Object> const& getObjects() const;
    [[nodiscard]] std::vector<Object>& getObjects();
 
    [[nodiscard]] Object* findObjectName(std::string_view name);
    [[nodiscard]] Object const* findObjectName(std::string_view name) const;
 
    void save(nlohmann::json& jsonObject) override;
    void load(nlohmann::json const& jsonObject, std::filesystem::path const& filePath) override;
 
private:
    std::vector<Object> g_objects;
};
 
} // namespace fge
 
#endif // _FGE_C_TILELAYER_HPP_INCLUDED