C_tilelayer.hpp

/*
 * Copyright 2024 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"
 
namespace fge
{
 
using TileId = int32_t;
using TileSetList = std::vector<std::shared_ptr<fge::TileSet>>;
 
#ifdef FGE_DEF_SERVER
class FGE_API TileLayer : public fge::Transformable
#else
class FGE_API TileLayer : public fge::Transformable, public fge::Drawable
#endif
{
public:
    class FGE_API Tile
    {
    public:
        Tile();
 
        void setGid(TileId gid);
        [[nodiscard]] TileId getGid() const;
 
        void setPosition(fge::Vector2f const& position);
        [[nodiscard]] fge::Vector2f const& getPosition() const;
 
        void setColor(fge::Color const& color);
        [[nodiscard]] fge::Color getColor() const;
 
        void setTileSet(std::shared_ptr<fge::TileSet> tileSet);
        [[nodiscard]] std::shared_ptr<fge::TileSet> const& getTileSet() const;
 
    private:
        void updatePositions();
        void updateTexCoords();
 
        TileId g_gid{0};
        std::shared_ptr<fge::TileSet> g_tileSet;
        fge::vulkan::VertexBuffer g_vertexBuffer;
        fge::Vector2f g_position;
 
        friend TileLayer;
    };
 
    TileLayer() = default;
 
#ifndef FGE_DEF_SERVER
    void draw(fge::RenderTarget& target, fge::RenderStates const& states) const override;
#endif
 
    void clear();
 
    void setId(TileId id);
    [[nodiscard]] TileId getId() const;
 
    void setName(std::string name);
    [[nodiscard]] std::string const& getName() const;
 
    [[nodiscard]] fge::Matrix<TileLayer::Tile> const& getTiles() const;
    void setGid(std::size_t x, std::size_t y, TileSetList const& tileSets, TileId gid);
    void setGid(std::size_t x, std::size_t y, TileId gid);
    void setGridSize(std::size_t x, std::size_t y);
 
    void refreshTextures(TileSetList const& tileSets);
 
private:
    static std::shared_ptr<fge::TileSet> retrieveAssociatedTileSet(TileSetList const& tileSets, TileId gid);
 
    TileId g_id{1};
    std::string g_name;
    fge::Matrix<TileLayer::Tile> g_data;
};
 
FGE_API void to_json(nlohmann::json& j, fge::TileLayer const& p);
FGE_API void from_json(nlohmann::json const& j, fge::TileLayer& p);
 
} // namespace fge
 
#endif // _FGE_C_TILELAYER_HPP_INCLUDED