BuildingFx.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
// 建筑放置渲染桥（可选模块）：监听 building::PlacementWorld 的实例，
// 按 BuildingDefinition.renderMode 生成 / 同步 / 销毁 Renderable2D 或 Renderable3D，
// 并提供鬼影预览 + 占地光标 + 网格可视化。
// 纯逻辑（building）与渲染解耦：本模块依赖 building / graphics / ECS，不反向依赖。
 
#include "common/Module.h"
#include "common/Result.h"
 
#include <cstdint>
#include <functional>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
 
namespace eve::building {
struct BuildingDefinition;
class Ghost;
class PlacementWorld;
class PlacementSession;
struct PlacedBuilding;
}
 
namespace eve::graphics {
class Graphics;
class Mesh;
class Renderable2D;
class Renderable3D;
}
 
namespace eve::buildingfx {
 
enum class CurvePreviewUpdateStatus { Updated, Rejected };
 
class EVENGINE_API_WORLD BuildingFx : public Module {
public:
    struct CurveControlPoint {
        float x = 0.f;
        float y = 0.f;
        bool operator==(const CurveControlPoint &) const = default;
    };
    struct CurveMeshData {
        std::vector<float> positions;
        std::vector<float> normals;
        std::vector<float> uvs;
        std::vector<uint32_t> indices;
        int sampleCount = 0;
        float length = 0.f;
    };
    struct CurveSurfaceSample {
        float x = 0.f;
        float y = 0.f;
        float z = 0.f;
        float normalX = 0.f;
        float normalY = 1.f;
        float normalZ = 0.f;
    };
    using MeshResolver = std::function<graphics::Mesh *(const std::string &resourceId)>;
    Module_REG(BuildingFx);
    BuildingFx() = default;
    ~BuildingFx() override = default;
 
    bool attach(building::PlacementWorld *world);
    bool detach(building::PlacementWorld *world);
    bool isAttached(building::PlacementWorld *world) const;
    int getAttachedCount() const;
 
    void sync(building::PlacementWorld *world);
    int getVisualCount(building::PlacementWorld *world) const;
    void setMeshResolver(MeshResolver resolver) { meshResolver_ = std::move(resolver); }
    void clearMeshResolver() { meshResolver_ = {}; }
    std::string getVisualVariant(building::PlacementWorld *world, int instanceId) const;
    std::string getVisualResource(building::PlacementWorld *world, int instanceId) const;
    std::string getVisualFallbackReason(building::PlacementWorld *world, int instanceId) const;
    void setLevelVisibilityMode(building::PlacementWorld *world, const std::string &mode);
    std::string getLevelVisibilityMode(building::PlacementWorld *world) const;
    bool isVisualVisible(building::PlacementWorld *world, int instanceId) const;
    int getCurveGroupCount(building::PlacementWorld *world) const;
    int getContinuousCurveVisualCount(building::PlacementWorld *world) const;
    std::string getCurveVisualFallbackReason(building::PlacementWorld *world,
                                             int instanceId) const;
 
    [[nodiscard]] static eve::Result<CurveMeshData>
    buildEdgeCurveMesh(const building::PlacementWorld &world,
                       const std::vector<CurveControlPoint> &controlPoints, int subdivisions,
                       float width, float height, float elevation = 0.f);
    [[nodiscard]] static eve::Result<CurveMeshData>
    buildSurfaceCurveMesh(const std::vector<CurveSurfaceSample> &samples, float width,
                          float height);
 
    [[nodiscard]] static eve::Result<CurveMeshData>
    buildEdgeCurveGroupMeshForInstance(const building::PlacementWorld &world, int instanceId,
                                       float width, float height, float elevation = 0.f);
 
    [[nodiscard]] eve::Result<void> updateEdgeCurvePreview(
        building::PlacementWorld *world, const std::string &buildingId,
        const std::vector<CurveControlPoint> &controlPoints, int subdivisions, int level = 0);
    [[nodiscard]] eve::Result<void> updateEdgeCurveSurfacePreview(
        building::PlacementWorld *world, building::PlacementSession *session,
        int subdivisions, const std::string &surfaceName);
    CurvePreviewUpdateStatus updateEdgeCurveSurfacePreviewStatus(
        building::PlacementWorld *world, building::PlacementSession *session,
        int subdivisions, const std::string &surfaceName);
    void clearEdgeCurvePreview(building::PlacementWorld *world);
    bool hasEdgeCurvePreview(building::PlacementWorld *world) const;
    std::string getEdgeCurvePreviewFallbackReason(building::PlacementWorld *world) const;
    std::string getEdgeCurvePreviewSurfaceId(building::PlacementWorld *world) const;
    std::uint64_t getEdgeCurvePreviewSurfaceRevision(building::PlacementWorld *world) const;
 
    void updateGhost(building::PlacementWorld *world, building::Ghost *ghost);
    void hideGhost(building::PlacementWorld *world);
    void updateAreaPreview(building::PlacementWorld *world, building::PlacementSession *session);
    void clearAreaPreview(building::PlacementWorld *world);
    int getAreaPreviewCount(building::PlacementWorld *world) const;
    bool getAreaPreviewAccepted(building::PlacementWorld *world, int index) const;
 
    void setGridVisible(building::PlacementWorld *world, bool visible);
    bool getGridVisible(building::PlacementWorld *world) const;
    void drawGrid2D(building::PlacementWorld *world, graphics::Graphics *gfx);
    void drawGrid3D(building::PlacementWorld *world, graphics::Graphics *gfx, float height = 0.f);
 
private:
    struct Visual {
        graphics::Renderable2D *r2d = nullptr;
        graphics::Renderable3D *r3d = nullptr;
        std::string topologyVariant;
        std::string resourceId;
        std::string fallbackReason;
        int topologyMask = 0;
    };
 
    struct WorldState {
        enum class LevelVisibility { All, Active, ActiveAndBelow };
        struct HeatCell {
            int x = 0;
            int y = 0;
            bool accepted = false;
        };
        struct CurveVisual {
            graphics::Renderable3D *renderable = nullptr;
            graphics::Mesh *mesh = nullptr;
            CurveMeshData cpuMesh;
            std::vector<CurveControlPoint> controlPoints;
            std::vector<int> memberIds;
            int subdivisions = 0;
            float width = 0.f;
            float height = 0.f;
            float elevation = 0.f;
            std::string surfaceId;
            std::uint64_t surfaceRevision = 0;
            std::string fallbackReason;
            bool active = false;
        };
        std::unordered_map<int, Visual> visuals;
        std::unordered_map<std::uint64_t, CurveVisual> curveVisuals;
        CurveVisual curvePreview;
        LevelVisibility levelVisibility = LevelVisibility::All;
        Visual ghost;
        Visual cursor;
        std::string ghostBuildingId;
        bool gridVisible = false;
        std::vector<graphics::Renderable3D *> gridLines;
        int gridLineCount = -1;
        std::vector<HeatCell> heatCells;
        std::vector<graphics::Renderable3D *> heatCells3d;
    };
 
    bool is3d(const building::BuildingDefinition &def) const;
    void createVisual(WorldState &st, const building::BuildingDefinition &def,
                      const building::PlacedBuilding &pb, building::PlacementWorld *world,
                      Visual &v, float alpha);
    void updateVisual(const building::BuildingDefinition &def,
                      const building::PlacedBuilding &pb, building::PlacementWorld *world,
                      Visual &v);
    void destroyVisual(Visual &v);
    void destroyAll(WorldState &st);
 
    graphics::Mesh *cubeMesh(graphics::Graphics *gfx);
    void rebuildGridLines(WorldState &st, building::PlacementWorld *world,
                          graphics::Graphics *gfx, float height);
    void setVisible(Visual &v, bool visible);
    void destroyHeatmap(WorldState &st);
    void syncCurveVisuals(WorldState &st, building::PlacementWorld *world);
    [[nodiscard]] eve::Result<void> presentCurvePreview(
        WorldState &state, CurveMeshData mesh, std::vector<CurveControlPoint> controls,
        int subdivisions, float width, float height, float elevation,
        std::string surfaceId = {}, std::uint64_t surfaceRevision = 0);
 
    std::unordered_map<building::PlacementWorld *, WorldState> states_;
    graphics::Mesh *cubeMesh_ = nullptr;
    MeshResolver meshResolver_;
};
 
}  // namespace eve::buildingfx