TileLayer.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/ECS.h"
#include "common/RenderTypes.h"
#include "map/TileOrientation.h"
 
#include <cstdint>
#include <string>
#include <vector>
 
namespace eve::graphics {
class Graphics;
class Camera2D;
class Canvas;
class Texture;
}  // namespace eve::graphics
 
namespace eve::map {
 
using eve::Color;
 
class EVENGINE_API_WORLD TileLayer : public ecs::Entity {
public:
    ENTITY(TileLayer, ecs::Entity)
 
    
    void release() override {}
 
    struct Config {
        int mapW = 0;
        int mapH = 0;
        float tileW = 32.f;
        float tileH = 32.f;
        float cellGapX = 0.f;
        float cellGapY = 0.f;
        float originX = 0.f;
        float originY = 0.f;
        MapOrientation orientation = MapOrientation::Orthogonal;
        StaggerAxis staggerAxis = StaggerAxis::Y;
        StaggerIndex staggerIndex = StaggerIndex::Odd;
        float hexSideLength = 0.f;
        TileLayer *entity = nullptr;
    };
 
    struct Tiles {
        struct Chunk {
            int nonEmpty = 0;
        };
 
        static constexpr int kChunkSize = 32;
        std::vector<uint32_t> gids;
        std::vector<Chunk> chunks;
        int chunkColumns = 0;
        int chunkRows = 0;
        uint64_t revision = 1;
        std::vector<int> terrainIds;
    };
 
    struct Tileset {
        struct AnimationFrame {
            int gid = 0;
            int durationMs = 100;
        };
 
        struct Animation {
            int gid = 0;
            std::vector<AnimationFrame> frames;
        };
 
        struct TerrainRule {
            int gid = 0;
            int terrain = 0;
            int neighborMask = 0;
            int weight       = 1;
        };
 
        struct TerrainFamily {
            int         terrain = 0;
            std::string kind    = "terrain";
            uint32_t    seed    = 0;
        };
 
        struct CustomData {
            int gid = 0;
            std::string name;
            std::string type;
            std::string value;
        };
 
        struct Visual {
            struct Subtile {
                int   x       = 0;
                int   y       = 0;
                int   width   = 0;
                int   height  = 0;
                float offsetX = 0.f;
                float offsetY = 0.f;
            };
 
            struct SubtileFrame {
                std::vector<Subtile> parts;
                int                  durationMs = 500;
            };
 
            struct CollisionShape {
                float x      = 0.f;
                float y      = 0.f;
                float width  = 0.f;
                float height = 0.f;
            };
 
            int gid = 0;
            int x = 0;
            int y = 0;
            int width = 0;
            int height = 0;
            float pivotX = 0.f;
            float pivotY = 0.f;
            float sortBias = 0.f;
            int footprintW = 1;
            int footprintH = 1;
            bool walkable = true;
            bool                        opaque        = false;
            float cost = 1.f;
            uint8_t                     enterMask     = 0xff;
            uint8_t                     exitMask      = 0xff;
            uint32_t                    semanticFlags = 0;
            std::vector<SubtileFrame>   subtileFrames;
            std::vector<CollisionShape> collisionShapes;
        };
 
        struct Atlas {
            graphics::Texture *texture  = nullptr;
            int                firstGid = 1;
            int                columns  = 1;
            int                tileW    = 32;
            int                tileH    = 32;
            int                margin   = 0;
            int                spacing  = 0;
            std::string        imagePath;
        };
 
        graphics::Texture *texture = nullptr;
        int firstGid = 1;
        int columns = 1;
        int tileW = 32;
        int tileH = 32;
        int margin = 0;
        int spacing = 0;
        std::vector<Visual> visuals;
        std::vector<Animation> animations;
        std::vector<TerrainRule> terrainRules;
        std::vector<TerrainFamily> terrainFamilies;
        std::vector<CustomData> customData;
        std::vector<Atlas>         atlases;
    };
 
    struct Draw {
        graphics::Canvas *canvas = nullptr;
        graphics::Camera2D *camera = nullptr;
        int layer = 0;
        bool visible = true;
        bool receiveLight = false;
        Color tint{1.f, 1.f, 1.f, 1.f};
        float visualScaleX = 1.f;
        float visualScaleY = 1.f;
    };
 
    struct Resource {
        std::string path;
        std::string texturePath;
        std::vector<std::string> dependencyPaths;
        std::vector<int64_t>     dependencyModtimes;
        std::string              sourceEngine;
        std::string              sourceVersion;
        int64_t modtime = -1;
        bool autoReload = true;
    };
 
    COMPONENT(Config, config)
    COMPONENT(Tiles, tiles)
    COMPONENT(Tileset, tileset)
    COMPONENT(Draw, draw)
    COMPONENT(Resource, resource)
 
    static TileLayer *createLayer(int mapW, int mapH, float tileW = 32.f, float tileH = 32.f);
 
    void setOrigin(float x, float y);
    float getX();
    float getY();
 
    int getMapWidth();
    int getMapHeight();
    float getTileWidth();
    float getTileHeight();
    void setTileSize(float tileW, float tileH);
    void setCellGap(float gapX, float gapY);
    void setRenderSpacing(float spacingX, float spacingY);
    float getCellGapX();
    float getCellGapY();
    float getRenderSpacingX();
    float getRenderSpacingY();
    void setVisualScale(float scaleX, float scaleY);
    float getVisualScaleX();
    float getVisualScaleY();
 
    void resize(int mapW, int mapH);
 
    void setTile(int tx, int ty, int gid);
    int getTile(int tx, int ty);
    void fillRect(int x, int y, int width, int height, int gid);
    void fill(int gid);
    void clear();
 
    int getRevision();
    int getChunkSize();
    int getChunkCount();
    int getNonEmptyChunkCount();
 
    void rebuildSpatialIndex();
 
    void clearTileAnimation(int gid);
    void addTileAnimationFrame(int gid, int frameGid, int durationMs);
    int getTileAnimationFrameCount(int gid);
    void setTileDataString(int gid, const std::string &name, const std::string &value);
    void setTileDataNumber(int gid, const std::string &name, float value);
    void setTileDataBool(int gid, const std::string &name, bool value);
    std::string getTileDataType(int gid, const std::string &name);
    std::string getTileDataString(int gid, const std::string &name);
    float getTileDataNumber(int gid, const std::string &name);
    bool getTileDataBool(int gid, const std::string &name);
    void setTerrainRule(int gid, int terrain, int neighborMask);
    void defineAutotileFamily(int terrain, const std::string &kind, int seed = 0);
    void setAutotileRule(int gid, int terrain, int neighborMask, int weight = 1);
    void clearTerrainRules();
    void paintTerrain(int x, int y, int terrain);
    void paintTerrainRect(int x, int y, int width, int height, int terrain);
    void fillTerrain(int terrain);
    void eraseTerrainRect(int x, int y, int width, int height);
    int getTerrain(int x, int y);
 
    void setTileset(graphics::Texture *texture, int firstGid, int columns, int margin = 0,
                    int spacing = 0);
    void setTilesetTileSize(int tileW, int tileH);
    void setTileVisual(int gid, int x, int y, int width, int height, float pivotX,
                       float pivotY, float sortBias = 0.f);
    void clearTileVisuals();
    int getTileVisualCount();
    void setTileMetadata(int gid, int footprintW, int footprintH, bool walkable,
                         float cost = 1.f);
    void setTileNavigationProfile(int gid, bool walkable, float cost, int enterMask, int exitMask, bool opaque,
                                  int semanticFlags = 0);
    bool loadTilesetManifest(const std::string &path);
    graphics::Texture *getTilesetTexture();
    int getTilesetFirstGid();
    int getTilesetColumns();
 
    void setCanvas(graphics::Canvas *canvas);
    void setCamera(graphics::Camera2D *camera);
 
    void setLayer(int layer);
    int getLayer();
 
    void setVisible(bool visible);
    bool isVisible();
    void setReceiveLight(bool receive);
    bool getReceiveLight();
 
    void setTint(float r, float g, float b, float a = 1.f);
 
    bool applyConfig(const std::string &json);
    bool loadConfig(const std::string &path);
    bool reloadConfig();
    void setAutoReload(bool enable);
    bool getAutoReload();
    std::string getConfigPath();
 
    void tileToWorld(int tx, int ty, float &wx, float &wy);
    float depthY(int tx, int ty);
    void worldToTile(float wx, float wy, int &tx, int &ty);
 
    float tileToWorldX(int tx, int ty);
    float tileToWorldY(int tx, int ty);
    float depthYAt(int tx, int ty);
    int worldToTileX(float wx, float wy);
    int worldToTileY(float wx, float wy);
};
 
inline uint32_t tileGid(uint32_t raw) { return raw & 0x0FFFFFFFu; }
 
}  // namespace eve::map