C_tileset.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_TILESET_HPP_INCLUDED
#define _FGE_C_TILESET_HPP_INCLUDED
 
#include "FastEngine/fge_extern.hpp"
#include "C_rect.hpp"
#include "FastEngine/C_propertyList.hpp"
#include "FastEngine/accessor/C_texture.hpp"
#include "json.hpp"
#include <optional>
#include <set>
 
namespace fge
{
 
using GlobalTileId = int32_t;
using LocalTileId = int32_t;

struct TileData
{
    LocalTileId _id{0};
    fge::RectInt _rect;
    mutable std::vector<fge::RectInt> _collisionRects{};
    mutable fge::PropertyList _properties{};
};
 
inline bool operator<(fge::TileData const& l, int r)
{
    return l._id < r;
}
inline bool operator<(int l, fge::TileData const& r)
{
    return l < r._id;
}
inline bool operator<(fge::TileData const& l, fge::TileData const& r)
{
    return l._id < r._id;
}

class FGE_API TileSet
{
public:
    using TileListType = std::set<fge::TileData, std::less<>>;
 
    TileSet() = default;
    explicit TileSet(fge::Texture texture);
    TileSet(fge::Texture texture, fge::Vector2i const& tileSize);
    TileSet(fge::Texture texture, fge::Vector2i const& tileSize, fge::Vector2i const& offset);

    void clearTiles();

    void setName(std::string name);
    [[nodiscard]] std::string const& getName() const;

    [[nodiscard]] bool valid() const;

    [[nodiscard]] fge::Texture const& getTexture() const;
    void setTexture(fge::Texture texture);

    [[nodiscard]] fge::Vector2i const& getTileSize() const;
    void setTileSize(fge::Vector2i const& tileSize);

    [[nodiscard]] fge::Vector2i const& getOffset() const;
    void setOffset(fge::Vector2i const& offset);

    [[nodiscard]] std::size_t getTileCount() const;

    [[nodiscard]] fge::TileData const* getTile(LocalTileId id) const;

    [[nodiscard]] LocalTileId getLocalId(fge::Vector2i const& position) const;
    [[nodiscard]] LocalTileId getLocalId(GlobalTileId gid) const;
    [[nodiscard]] GlobalTileId getGlobalId(LocalTileId id) const;
    [[nodiscard]] bool containsGlobal(GlobalTileId gid) const;
    [[nodiscard]] bool containsLocal(LocalTileId id) const;
    void setFirstGid(GlobalTileId gid);
    [[nodiscard]] GlobalTileId getFirstGid() const;
 
    [[nodiscard]] TileListType::const_iterator begin() const;
    [[nodiscard]] TileListType::const_iterator end() const;

    void slice();

    [[nodiscard]] int getColumns() const;
    [[nodiscard]] int getRows() const;

    [[nodiscard]] std::optional<fge::RectInt> getTextureRect(LocalTileId id) const;
    [[nodiscard]] fge::RectInt computeTextureRect(LocalTileId id) const;
 
    fge::TileSet& operator=(fge::Texture texture);
 
private:
    void setTile(fge::TileData tile);
    void pushTile(fge::TileData tile);
 
    std::string g_name;
    fge::Texture g_texture;
    fge::Vector2i g_tileSize;
    fge::Vector2i g_offset{0, 0};
    TileListType g_tiles;
    GlobalTileId g_firstGid{1};
    int g_columns{0};
    int g_rows{0};
};
 
FGE_API void to_json(nlohmann::json& j, fge::TileSet const& p);
FGE_API void from_json(nlohmann::json const& j, fge::TileSet& p);
 
FGE_API void to_json(nlohmann::json& j, fge::TileData const& p);
FGE_API void from_json(nlohmann::json const& j, fge::TileData& p);
 
} // namespace fge
 
#endif // _FGE_C_TILESET_HPP_INCLUDED